3331cacce8ff648e1bdf548f6b16d0268e2b175e
[dragonfly.git] / sys / dev / atm / hfa / fore_load.c
1 /*
2  *
3  * ===================================
4  * HARP  |  Host ATM Research Platform
5  * ===================================
6  *
7  *
8  * This Host ATM Research Platform ("HARP") file (the "Software") is
9  * made available by Network Computing Services, Inc. ("NetworkCS")
10  * "AS IS".  NetworkCS does not provide maintenance, improvements or
11  * support of any kind.
12  *
13  * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED,
14  * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
15  * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE
16  * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE.
17  * In no event shall NetworkCS be responsible for any damages, including
18  * but not limited to consequential damages, arising from or relating to
19  * any use of the Software or related support.
20  *
21  * Copyright 1994-1998 Network Computing Services, Inc.
22  *
23  * Copies of this Software may be made, however, the above copyright
24  * notice must be reproduced on all copies.
25  *
26  *      @(#) $FreeBSD: src/sys/dev/hfa/fore_load.c,v 1.13 1999/09/25 18:23:49 phk Exp $
27  *      @(#) $DragonFly: src/sys/dev/atm/hfa/fore_load.c,v 1.11 2005/06/02 21:36:09 dillon Exp $
28  */
29
30 /*
31  * FORE Systems 200-Series Adapter Support
32  * ---------------------------------------
33  *
34  * Loadable kernel module and device identification support
35  *
36  */
37
38 #include "fore_include.h"
39
40 /*
41  * Local functions
42  */
43 static int      fore_start (void);
44 static const char *     fore_pci_probe (pcici_t, pcidi_t);
45 static void     fore_pci_attach (pcici_t, int);
46 static void     fore_pci_shutdown (void *, int);
47 static void     fore_unattach (Fore_unit *);
48 static void     fore_reset (Fore_unit *);
49
50
51 /*
52  * Local variables
53  */
54 static int      fore_inited = 0;
55
56 /*
57  * Driver entry points
58  */
59 static  u_long  fore_pci_count = 0;
60
61 static struct pci_device fore_pci_device = {
62         FORE_DEV_NAME,
63         fore_pci_probe,
64         fore_pci_attach,
65         &fore_pci_count,
66         NULL
67 };
68
69 COMPAT_PCI_DRIVER(fore_pci, fore_pci_device);
70
71 /*
72  * Initialize driver processing
73  * 
74  * This will be called during module loading.  Not much to do here, as
75  * we must wait for our identify/attach routines to get called before
76  * we know what we're in for.
77  *
78  * Arguments:
79  *      none
80  *
81  * Returns:
82  *      0       startup was successful 
83  *      errno   startup failed - reason indicated
84  *
85  */
86 static int
87 fore_start()
88 {
89
90         /*
91          * Verify software version
92          */
93         if (atm_version != ATM_VERSION) {
94                 log(LOG_ERR, "version mismatch: fore=%d.%d kernel=%d.%d\n",
95                         ATM_VERS_MAJ(ATM_VERSION), ATM_VERS_MIN(ATM_VERSION),
96                         ATM_VERS_MAJ(atm_version), ATM_VERS_MIN(atm_version));
97                 return (EINVAL);
98         }
99
100         /*
101          * Initialize DMA mapping
102          */
103         DMA_INIT();
104
105         /*
106          * Start up watchdog timer
107          */
108         atm_timeout(&fore_timer, ATM_HZ * FORE_TIME_TICK, fore_timeout);
109
110         fore_inited = 1;
111
112         return (0);
113 }
114
115 /*
116  * Device probe routine
117  * 
118  * Determine if this driver will support the identified device.  If we claim
119  * to support the device, our attach routine will (later) be called for the
120  * device.
121  *
122  * Arguments:
123  *      config_id       device's PCI configuration ID
124  *      device_id       device's PCI Vendor/Device ID
125  *
126  * Returns:
127  *      name    device identification string
128  *      NULL    device not claimed by this driver
129  *
130  */
131 static const char *
132 fore_pci_probe(config_id, device_id)
133         pcici_t config_id;
134         pcidi_t device_id;
135 {
136
137         /*
138          * Initialize driver stuff
139          */
140         if (fore_inited == 0) {
141                 if (fore_start())
142                         return (NULL);
143         }
144
145         if ((device_id & 0xffff) != FORE_VENDOR_ID)
146                 return (NULL);
147
148         if (((device_id >> 16) & 0xffff) == FORE_PCA200E_ID)
149                 return ("FORE Systems PCA-200E ATM");
150
151         return (NULL);
152 }
153
154
155 /*
156  * Device attach routine
157  * 
158  * Attach a device we've previously claimed to support.  Walk through its
159  * register set and map, as required.  Determine what level the device will
160  * be interrupting at and then register an interrupt handler for it.  If we
161  * succeed, then reset the adapter and initialize the microcode.
162  * Last, register the interface with the kernel ATM services.
163  *
164  * Arguments:
165  *      config_id       device's PCI configuration ID
166  *      unit            device unit number
167  *
168  * Returns:
169  *      none
170  *
171  */
172 static void
173 fore_pci_attach(config_id, unit)
174         pcici_t config_id;
175         int     unit;
176 {
177         Fore_unit       *fup;
178         vm_offset_t     va;
179         vm_offset_t     pa;
180         pcidi_t         device_id;
181         long            val;
182         int             err_count = BOOT_LOOPS;
183
184         /*
185          * Just checking...
186          */
187         if (unit >= FORE_MAX_UNITS) {
188                 log(LOG_ERR, "%s%d: too many devices\n", 
189                         FORE_DEV_NAME, unit);
190                 return;
191         }
192
193         /*
194          * Make sure this isn't a duplicate unit
195          */
196         if (fore_units[unit] != NULL)
197                 return;
198
199         /*
200          * Allocate a new unit structure
201          */
202         fup = (Fore_unit *) atm_dev_alloc(sizeof(Fore_unit), sizeof(int), 0);
203         if (fup == NULL)
204                 return;
205
206         /*
207          * Start initializing it
208          */
209         fup->fu_unit = unit;
210         fup->fu_mtu = FORE_IFF_MTU;
211         fup->fu_pcitag = config_id;
212         fup->fu_vcc_pool = &fore_vcc_pool;
213         fup->fu_nif_pool = &fore_nif_pool;
214         fup->fu_ioctl = fore_atm_ioctl;
215         fup->fu_instvcc = fore_instvcc;
216         fup->fu_openvcc = fore_openvcc;
217         fup->fu_closevcc = fore_closevcc;
218         fup->fu_output = fore_output;
219         callout_init(&fup->fu_init_timer);
220
221         /*
222          * Get our device type
223          */
224         device_id = pci_conf_read ( config_id, PCI_ID_REG );
225         switch ((device_id >> 16) & 0xffff) {
226
227         case FORE_PCA200E_ID:
228                 fup->fu_config.ac_device = DEV_FORE_PCA200E;
229                 break;
230
231         default:
232                 fup->fu_config.ac_device = DEV_UNKNOWN;
233         }
234
235         /*
236          * Enable Memory Mapping / Bus Mastering 
237          */
238         val = pci_conf_read(config_id, PCI_COMMAND_STATUS_REG);
239         val |= (PCIM_CMD_MEMEN | PCIM_CMD_BUSMASTEREN);
240         pci_conf_write(config_id, PCI_COMMAND_STATUS_REG, val);
241
242         /*
243          * Map RAM
244          */
245         val = pci_conf_read(config_id, PCI_COMMAND_STATUS_REG);
246         if ((val & PCIM_CMD_MEMEN) == 0) {
247                 log(LOG_ERR, "%s%d: memory mapping not enabled\n", 
248                         FORE_DEV_NAME, unit);
249                 goto failed;
250         }
251         if ((pci_map_mem(config_id, PCA200E_PCI_MEMBASE, &va, &pa)) == 0) {
252                 log(LOG_ERR, "%s%d: unable to map memory\n", 
253                         FORE_DEV_NAME, unit);
254                 goto failed;
255         }
256         fup->fu_ram = (Fore_mem *)va;
257         fup->fu_ramsize = PCA200E_RAM_SIZE;
258         fup->fu_mon = (Mon960 *)(fup->fu_ram + MON960_BASE);
259         fup->fu_ctlreg = (Fore_reg *)(va + PCA200E_HCR_OFFSET);
260         fup->fu_imask = (Fore_reg *)(va + PCA200E_IMASK_OFFSET);
261         fup->fu_psr = (Fore_reg *)(va + PCA200E_PSR_OFFSET);
262
263         /*
264          * Convert Endianess of Slave RAM accesses
265          */
266         val = pci_conf_read(config_id, PCA200E_PCI_MCTL);
267         val |= PCA200E_MCTL_SWAP;
268         pci_conf_write(config_id, PCA200E_PCI_MCTL, val);
269
270         /*
271          * Map interrupt in
272          */
273         if ( !pci_map_int( config_id, fore_intr, fup, &net_imask ) ) {
274                 log(LOG_ERR, "%s%d: unable to map interrupt\n", 
275                         FORE_DEV_NAME, unit);
276                 goto failed;
277         }
278
279         /*
280          * Poke the hardware - boot the CP and prepare it for downloading
281          */
282         fore_reset(fup);
283
284         /*
285          * Wait for the monitor to perform self-test
286          */
287         while (CP_READ(fup->fu_mon->mon_bstat) != BOOT_MONREADY) {
288                 if (CP_READ(fup->fu_mon->mon_bstat) == BOOT_FAILTEST) {
289                         log(LOG_ERR, "%s%d: failed self-test\n", 
290                                 FORE_DEV_NAME, unit);
291                         goto failed;
292                 } else if ( --err_count == 0 ) {
293                         log(LOG_ERR, "%s%d: unable to boot - status=0x%lx\n", 
294                                 FORE_DEV_NAME, unit,
295                                 (u_long)CP_READ(fup->fu_mon->mon_bstat));
296                         goto failed;
297                 }
298                 DELAY ( BOOT_DELAY );
299         }
300
301         /*
302          * Setup the adapter config info - at least as much as we can
303          */
304         fup->fu_config.ac_vendor = VENDOR_FORE;
305         fup->fu_config.ac_vendapi = VENDAPI_FORE_1;
306         fup->fu_config.ac_media = MEDIA_OC3C;
307         fup->fu_pif.pif_pcr = ATM_PCR_OC3C;
308         fup->fu_config.ac_bustype = BUS_PCI;
309         fup->fu_config.ac_busslot = config_id->bus << 8 | config_id->slot;
310
311         /*
312          * Save device ram info for user-level programs
313          */
314         fup->fu_config.ac_ram = (long)fup->fu_ram;
315         fup->fu_config.ac_ramsize = fup->fu_ramsize;
316
317         /*
318          * Set device capabilities
319          */
320         fup->fu_pif.pif_maxvpi = FORE_MAX_VPI;
321         fup->fu_pif.pif_maxvci = FORE_MAX_VCI;
322
323         /*
324          * Register this interface with ATM core services
325          */
326         if ( atm_physif_register
327                         ((Cmn_unit *)fup, FORE_DEV_NAME, fore_services) != 0 )
328         {
329                 /*
330                  * Registration failed - back everything out
331                  */
332                 goto failed;
333         }
334
335         fore_units[unit] = fup;
336         fore_nunits++;
337
338         /*
339          * Add hook to our shutdown function
340          */
341         EVENTHANDLER_REGISTER(shutdown_post_sync, fore_pci_shutdown, fup,
342                               SHUTDOWN_PRI_DEFAULT);
343
344         /*
345          * Initialize the CP microcode program.
346          */
347         fore_initialize(fup);
348
349         return;
350
351 failed:
352         /*
353          * Unattach the device from the system
354          */
355         fore_unattach(fup);
356
357         /*
358          * Free any Fore-specific device resources
359          */
360         fore_interface_free(fup);
361
362         atm_dev_free(fup);
363
364         return;
365 }
366
367 /*
368  * Device shutdown routine
369  * 
370  * Arguments:
371  *      howto           type of shutdown
372  *      fup             pointer to device unit structure
373  *
374  * Returns:
375  *      none
376  *
377  */
378 static void
379 fore_pci_shutdown(fup, howto)
380         void            *fup;
381         int             howto;
382 {
383
384         fore_reset((Fore_unit *) fup);
385
386         return;
387 }
388
389 /*
390  * Device unattach routine
391  * 
392  * Reset the physical device, remove any pending timeouts, 
393  * unmap any register sets, and unregister any interrupts.
394  *
395  * Arguments:
396  *      fup             pointer to device unit structure
397  *
398  * Returns:
399  *      none
400  */ 
401 static void
402 fore_unattach(fup)
403         Fore_unit       *fup;
404 {
405         /*
406          * Reset the board and return it to cold_start state.
407          * Hopefully, this will prevent use of resources as
408          * we're trying to free things up.
409          */
410         fore_reset(fup);
411
412         /*
413          * Lock out all device interrupts
414          */
415         DEVICE_LOCK((Cmn_unit *)fup);
416
417         /*
418          * Remove any pending timeout()'s
419          */
420         callout_stop(&fup->fu_init_timer);
421
422         /*
423          * Unmap the device interrupt
424          */
425         (void) pci_unmap_int(fup->fu_pcitag);
426
427         /*
428          * Unmap memory
429          */
430 #ifdef notdef
431         (void) pci_unmap_mem(fup->fu_pcitag, PCA200E_PCI_MEMBASE);
432 #endif
433
434         DEVICE_UNLOCK((Cmn_unit *)fup);
435 }
436
437
438 /*
439  * Device reset routine
440  * 
441  * Reset the physical device
442  *
443  * Arguments:
444  *      fup             pointer to device unit structure
445  *
446  * Returns:
447  *      none
448  */ 
449 static void
450 fore_reset(fup)
451         Fore_unit       *fup;
452 {
453         /*
454          * Reset the board and return it to cold_start state
455          */
456         crit_enter();
457         if (fup->fu_mon)
458                 fup->fu_mon->mon_bstat = CP_WRITE(BOOT_COLDSTART);
459
460         if (fup->fu_ctlreg) {
461
462                 switch (fup->fu_config.ac_device) {
463
464                 case DEV_FORE_PCA200E:
465                         /*
466                          * Reset i960 by setting and clearing RESET
467                          */
468                         PCA200E_HCR_INIT(*fup->fu_ctlreg, PCA200E_RESET);
469                         DELAY(10000);
470                         PCA200E_HCR_CLR(*fup->fu_ctlreg, PCA200E_RESET);
471                         break;
472
473                 default:
474                         panic("fore_reset: unknown device type");
475                         break;
476                 }
477         }
478         crit_exit();
479         return;
480 }
481
482
483 #ifndef ATM_LINKED
484 /*
485  *******************************************************************
486  *
487  * Loadable Module Support
488  *
489  *******************************************************************
490  */
491
492 #ifdef notdef
493
494 /*
495  * Driver entry points
496  */
497 static struct cdevsw fore_cdev = {
498         /* name */      noname,
499         /* maj */       -1,
500         /* flags */     0,
501         /* port */      NULL,
502         /* clone */     NULL,
503
504         /* open */      noopen,
505         /* close */     noclose,
506         /* read */      noread,
507         /* write */     nowrite,
508         /* ioctl */     noioctl,
509         /* poll */      nopoll,
510         /* mmap */      nommap,
511         /* strategy */  nostrategy,
512         /* dump */      nodump,
513         /* psize */     nopsize
514 };
515
516
517 /*
518  * Loadable device driver module description
519  */
520 MOD_DEV(fore, LM_DT_CHAR, -1, (void *)&fore_cdev);
521
522
523 /*
524  * Loadable module support "load" entry point
525  * 
526  * This is the routine called by the lkm driver whenever the
527  * modload(1) command is issued for this module.
528  *
529  * Arguments:
530  *      lkmtp   pointer to lkm drivers's structure
531  *      cmd     lkm command code
532  *
533  * Returns:
534  *      0       command was successful 
535  *      errno   command failed - reason indicated
536  *
537  */
538 static int
539 fore_load(lkmtp, cmd)
540         struct lkm_table        *lkmtp;
541         int             cmd;
542 {
543         return(fore_doload());
544 }
545
546
547 /*
548  * Loadable module support "unload" entry point
549  * 
550  * This is the routine called by the lkm driver whenever the
551  * modunload(1) command is issued for this module.
552  *
553  * Arguments:
554  *      lkmtp   pointer to lkm drivers's structure
555  *      cmd     lkm command code
556  *
557  * Returns:
558  *      0       command was successful 
559  *      errno   command failed - reason indicated
560  *
561  */
562 static int
563 fore_unload(lkmtp, cmd)
564         struct lkm_table        *lkmtp;
565         int             cmd;
566 {
567         return(fore_dounload());
568 }
569
570
571 /*
572  * Loadable module support entry point
573  * 
574  * This is the routine called by the lkm driver for all loadable module
575  * functions for this driver.  This routine name must be specified
576  * on the modload(1) command.  This routine will be called whenever the
577  * modload(1), modunload(1) or modstat(1) commands are issued for this
578  * module.
579  *
580  * Arguments:
581  *      lkmtp   pointer to lkm drivers's structure
582  *      cmd     lkm command code
583  *      ver     lkm version
584  *
585  * Returns:
586  *      0       command was successful 
587  *      errno   command failed - reason indicated
588  *
589  */
590 int
591 fore_mod(lkmtp, cmd, ver)
592         struct lkm_table        *lkmtp;
593         int             cmd;
594         int             ver;
595 {
596         DISPATCH(lkmtp, cmd, ver, fore_load, fore_unload, lkm_nullcmd);
597 }
598 #endif  /* notdef */
599
600 #endif  /* ATM_LINKED */
601