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.14 2008/03/01 22:03:13 swildner 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(void)
  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(pcici_t config_id, pcidi_t device_id)
 133 {
 134
 135         /*
 136          * Initialize driver stuff
 137          */
 138         if (fore_inited == 0) {
 139                 if (fore_start())
 140                         return (NULL);
 141         }
 142
 143         if ((device_id & 0xffff) != FORE_VENDOR_ID)
 144                 return (NULL);
 145
 146         if (((device_id >> 16) & 0xffff) == FORE_PCA200E_ID)
 147                 return ("FORE Systems PCA-200E ATM");
 148
 149         return (NULL);
 150 }
 151
 152
 153 /*
 154  * Device attach routine
 155  *
 156  * Attach a device we've previously claimed to support.  Walk through its
 157  * register set and map, as required.  Determine what level the device will
 158  * be interrupting at and then register an interrupt handler for it.  If we
 159  * succeed, then reset the adapter and initialize the microcode.
 160  * Last, register the interface with the kernel ATM services.
 161  *
 162  * Arguments:
 163  *      config_id       device's PCI configuration ID
 164  *      unit            device unit number
 165  *
 166  * Returns:
 167  *      none
 168  *
 169  */
 170 static void
 171 fore_pci_attach(pcici_t config_id, int unit)
 172 {
 173         Fore_unit       *fup;
 174         vm_offset_t     va;
 175         vm_offset_t     pa;
 176         pcidi_t         device_id;
 177         long            val;
 178         int             err_count = BOOT_LOOPS;
 179
 180         /*
 181          * Just checking...
 182          */
 183         if (unit >= FORE_MAX_UNITS) {
 184                 log(LOG_ERR, "%s%d: too many devices\n",
 185                         FORE_DEV_NAME, unit);
 186                 return;
 187         }
 188
 189         /*
 190          * Make sure this isn't a duplicate unit
 191          */
 192         if (fore_units[unit] != NULL)
 193                 return;
 194
 195         /*
 196          * Allocate a new unit structure
 197          */
 198         fup = (Fore_unit *) atm_dev_alloc(sizeof(Fore_unit), sizeof(int), 0);
 199         if (fup == NULL)
 200                 return;
 201
 202         /*
 203          * Start initializing it
 204          */
 205         fup->fu_unit = unit;
 206         fup->fu_mtu = FORE_IFF_MTU;
 207         fup->fu_pcitag = config_id;
 208         fup->fu_vcc_pool = &fore_vcc_pool;
 209         fup->fu_nif_pool = &fore_nif_pool;
 210         fup->fu_ioctl = fore_atm_ioctl;
 211         fup->fu_instvcc = fore_instvcc;
 212         fup->fu_openvcc = fore_openvcc;
 213         fup->fu_closevcc = fore_closevcc;
 214         fup->fu_output = fore_output;
 215         callout_init(&fup->fu_init_timer);
 216
 217         /*
 218          * Get our device type
 219          */
 220         device_id = pci_conf_read ( config_id, PCI_ID_REG );
 221         switch ((device_id >> 16) & 0xffff) {
 222
 223         case FORE_PCA200E_ID:
 224                 fup->fu_config.ac_device = DEV_FORE_PCA200E;
 225                 break;
 226
 227         default:
 228                 fup->fu_config.ac_device = DEV_UNKNOWN;
 229         }
 230
 231         /*
 232          * Enable Memory Mapping / Bus Mastering
 233          */
 234         val = pci_conf_read(config_id, PCI_COMMAND_STATUS_REG);
 235         val |= (PCIM_CMD_MEMEN | PCIM_CMD_BUSMASTEREN);
 236         pci_conf_write(config_id, PCI_COMMAND_STATUS_REG, val);
 237
 238         /*
 239          * Map RAM
 240          */
 241         val = pci_conf_read(config_id, PCI_COMMAND_STATUS_REG);
 242         if ((val & PCIM_CMD_MEMEN) == 0) {
 243                 log(LOG_ERR, "%s%d: memory mapping not enabled\n",
 244                         FORE_DEV_NAME, unit);
 245                 goto failed;
 246         }
 247         if ((pci_map_mem(config_id, PCA200E_PCI_MEMBASE, &va, &pa)) == 0) {
 248                 log(LOG_ERR, "%s%d: unable to map memory\n",
 249                         FORE_DEV_NAME, unit);
 250                 goto failed;
 251         }
 252         fup->fu_ram = (Fore_mem *)va;
 253         fup->fu_ramsize = PCA200E_RAM_SIZE;
 254         fup->fu_mon = (Mon960 *)(fup->fu_ram + MON960_BASE);
 255         fup->fu_ctlreg = (Fore_reg *)(va + PCA200E_HCR_OFFSET);
 256         fup->fu_imask = (Fore_reg *)(va + PCA200E_IMASK_OFFSET);
 257         fup->fu_psr = (Fore_reg *)(va + PCA200E_PSR_OFFSET);
 258
 259         /*
 260          * Convert Endianess of Slave RAM accesses
 261          */
 262         val = pci_conf_read(config_id, PCA200E_PCI_MCTL);
 263         val |= PCA200E_MCTL_SWAP;
 264         pci_conf_write(config_id, PCA200E_PCI_MCTL, val);
 265
 266         /*
 267          * Map interrupt in
 268          */
 269         if ( !pci_map_int( config_id, fore_intr, fup) ) {
 270                 log(LOG_ERR, "%s%d: unable to map interrupt\n",
 271                         FORE_DEV_NAME, unit);
 272                 goto failed;
 273         }
 274
 275         /*
 276          * Poke the hardware - boot the CP and prepare it for downloading
 277          */
 278         fore_reset(fup);
 279
 280         /*
 281          * Wait for the monitor to perform self-test
 282          */
 283         while (CP_READ(fup->fu_mon->mon_bstat) != BOOT_MONREADY) {
 284                 if (CP_READ(fup->fu_mon->mon_bstat) == BOOT_FAILTEST) {
 285                         log(LOG_ERR, "%s%d: failed self-test\n",
 286                                 FORE_DEV_NAME, unit);
 287                         goto failed;
 288                 } else if ( --err_count == 0 ) {
 289                         log(LOG_ERR, "%s%d: unable to boot - status=0x%lx\n",
 290                                 FORE_DEV_NAME, unit,
 291                                 (u_long)CP_READ(fup->fu_mon->mon_bstat));
 292                         goto failed;
 293                 }
 294                 DELAY ( BOOT_DELAY );
 295         }
 296
 297         /*
 298          * Setup the adapter config info - at least as much as we can
 299          */
 300         fup->fu_config.ac_vendor = VENDOR_FORE;
 301         fup->fu_config.ac_vendapi = VENDAPI_FORE_1;
 302         fup->fu_config.ac_media = MEDIA_OC3C;
 303         fup->fu_pif.pif_pcr = ATM_PCR_OC3C;
 304         fup->fu_config.ac_bustype = BUS_PCI;
 305         fup->fu_config.ac_busslot = config_id->bus << 8 | config_id->slot;
 306
 307         /*
 308          * Save device ram info for user-level programs
 309          */
 310         fup->fu_config.ac_ram = (long)fup->fu_ram;
 311         fup->fu_config.ac_ramsize = fup->fu_ramsize;
 312
 313         /*
 314          * Set device capabilities
 315          */
 316         fup->fu_pif.pif_maxvpi = FORE_MAX_VPI;
 317         fup->fu_pif.pif_maxvci = FORE_MAX_VCI;
 318
 319         /*
 320          * Register this interface with ATM core services
 321          */
 322         if ( atm_physif_register
 323                         ((Cmn_unit *)fup, FORE_DEV_NAME, fore_services) != 0 )
 324         {
 325                 /*
 326                  * Registration failed - back everything out
 327                  */
 328                 goto failed;
 329         }
 330
 331         fore_units[unit] = fup;
 332         fore_nunits++;
 333
 334         /*
 335          * Add hook to our shutdown function
 336          */
 337         EVENTHANDLER_REGISTER(shutdown_post_sync, fore_pci_shutdown, fup,
 338                               SHUTDOWN_PRI_DRIVER);
 339
 340         /*
 341          * Initialize the CP microcode program.
 342          */
 343         fore_initialize(fup);
 344
 345         return;
 346
 347 failed:
 348         /*
 349          * Unattach the device from the system
 350          */
 351         fore_unattach(fup);
 352
 353         /*
 354          * Free any Fore-specific device resources
 355          */
 356         fore_interface_free(fup);
 357
 358         atm_dev_free(fup);
 359
 360         return;
 361 }
 362
 363 /*
 364  * Device shutdown routine
 365  *
 366  * Arguments:
 367  *      howto           type of shutdown
 368  *      fup             pointer to device unit structure
 369  *
 370  * Returns:
 371  *      none
 372  *
 373  */
 374 static void
 375 fore_pci_shutdown(void *fup, int howto)
 376 {
 377
 378         fore_reset((Fore_unit *) fup);
 379
 380         return;
 381 }
 382
 383 /*
 384  * Device unattach routine
 385  *
 386  * Reset the physical device, remove any pending timeouts,
 387  * unmap any register sets, and unregister any interrupts.
 388  *
 389  * Arguments:
 390  *      fup             pointer to device unit structure
 391  *
 392  * Returns:
 393  *      none
 394  */
 395 static void
 396 fore_unattach(Fore_unit *fup)
 397 {
 398         /*
 399          * Reset the board and return it to cold_start state.
 400          * Hopefully, this will prevent use of resources as
 401          * we're trying to free things up.
 402          */
 403         fore_reset(fup);
 404
 405         /*
 406          * Lock out all device interrupts
 407          */
 408         DEVICE_LOCK((Cmn_unit *)fup);
 409
 410         /*
 411          * Remove any pending timeout()'s
 412          */
 413         callout_stop(&fup->fu_init_timer);
 414
 415         /*
 416          * Unmap the device interrupt
 417          */
 418         (void) pci_unmap_int(fup->fu_pcitag);
 419
 420         /*
 421          * Unmap memory
 422          */
 423 #ifdef notdef
 424         (void) pci_unmap_mem(fup->fu_pcitag, PCA200E_PCI_MEMBASE);
 425 #endif
 426
 427         DEVICE_UNLOCK((Cmn_unit *)fup);
 428 }
 429
 430
 431 /*
 432  * Device reset routine
 433  *
 434  * Reset the physical device
 435  *
 436  * Arguments:
 437  *      fup             pointer to device unit structure
 438  *
 439  * Returns:
 440  *      none
 441  */
 442 static void
 443 fore_reset(Fore_unit *fup)
 444 {
 445         /*
 446          * Reset the board and return it to cold_start state
 447          */
 448         crit_enter();
 449         if (fup->fu_mon)
 450                 fup->fu_mon->mon_bstat = CP_WRITE(BOOT_COLDSTART);
 451
 452         if (fup->fu_ctlreg) {
 453
 454                 switch (fup->fu_config.ac_device) {
 455
 456                 case DEV_FORE_PCA200E:
 457                         /*
 458                          * Reset i960 by setting and clearing RESET
 459                          */
 460                         PCA200E_HCR_INIT(*fup->fu_ctlreg, PCA200E_RESET);
 461                         DELAY(10000);
 462                         PCA200E_HCR_CLR(*fup->fu_ctlreg, PCA200E_RESET);
 463                         break;
 464
 465                 default:
 466                         panic("fore_reset: unknown device type");
 467                         break;
 468                 }
 469         }
 470         crit_exit();
 471         return;
 472 }
 473
 474
 475 #ifndef ATM_LINKED
 476 /*
 477  *******************************************************************
 478  *
 479  * Loadable Module Support
 480  *
 481  *******************************************************************
 482  */
 483
 484 #ifdef notdef
 485
 486 /*
 487  * Driver entry points
 488  */
 489 static struct cdevsw fore_cdev = {
 490         /* name */      noname,
 491         /* maj */       -1,
 492         /* flags */     0,
 493         /* port */      NULL,
 494         /* clone */     NULL,
 495
 496         /* open */      noopen,
 497         /* close */     noclose,
 498         /* read */      noread,
 499         /* write */     nowrite,
 500         /* ioctl */     noioctl,
 501         /* poll */      nopoll,
 502         /* mmap */      nommap,
 503         /* strategy */  nostrategy,
 504         /* dump */      nodump,
 505         /* psize */     nopsize
 506 };
 507
 508
 509 /*
 510  * Loadable device driver module description
 511  */
 512 MOD_DEV(fore, LM_DT_CHAR, -1, (void *)&fore_cdev);
 513
 514
 515 /*
 516  * Loadable module support "load" entry point
 517  *
 518  * This is the routine called by the lkm driver whenever the
 519  * modload(1) command is issued for this module.
 520  *
 521  * Arguments:
 522  *      lkmtp   pointer to lkm drivers's structure
 523  *      cmd     lkm command code
 524  *
 525  * Returns:
 526  *      0       command was successful
 527  *      errno   command failed - reason indicated
 528  *
 529  */
 530 static int
 531 fore_load(struct lkm_table *lkmtp, int cmd)
 532 {
 533         return(fore_doload());
 534 }
 535
 536
 537 /*
 538  * Loadable module support "unload" entry point
 539  *
 540  * This is the routine called by the lkm driver whenever the
 541  * modunload(1) command is issued for this module.
 542  *
 543  * Arguments:
 544  *      lkmtp   pointer to lkm drivers's structure
 545  *      cmd     lkm command code
 546  *
 547  * Returns:
 548  *      0       command was successful
 549  *      errno   command failed - reason indicated
 550  *
 551  */
 552 static int
 553 fore_unload(struct lkm_table *lkmtp, int cmd)
 554 {
 555         return(fore_dounload());
 556 }
 557
 558
 559 /*
 560  * Loadable module support entry point
 561  *
 562  * This is the routine called by the lkm driver for all loadable module
 563  * functions for this driver.  This routine name must be specified
 564  * on the modload(1) command.  This routine will be called whenever the
 565  * modload(1), modunload(1) or modstat(1) commands are issued for this
 566  * module.
 567  *
 568  * Arguments:
 569  *      lkmtp   pointer to lkm drivers's structure
 570  *      cmd     lkm command code
 571  *      ver     lkm version
 572  *
 573  * Returns:
 574  *      0       command was successful
 575  *      errno   command failed - reason indicated
 576  *
 577  */
 578 int
 579 fore_mod(struct lkm_table *lkmtp, int cmd, int ver)
 580 {
 581         DISPATCH(lkmtp, cmd, ver, fore_load, fore_unload, lkm_nullcmd);
 582 }
 583 #endif  /* notdef */
 584
 585 #endif  /* ATM_LINKED */
 586