i386/linux/linux-2.3.21/drivers/net/sk_mca.c

   1 /*
   2 net-3-driver for the SKNET MCA-based cards
   3
   4 This is an extension to the Linux operating system, and is covered by the
   5 same Gnu Public License that covers that work.
   6
   7 Copyright 1999 by Alfred Arnold (alfred@ccac.rwth-aachen.de, aarnold@elsa.de)
   8
   9 This driver is based both on the 3C523 driver and the SK_G16 driver.
  10
  11 paper sources:
  12   'PC Hardware: Aufbau, Funktionsweise, Programmierung' by
  13   Hans-Peter Messmer for the basic Microchannel stuff
  14
  15   'Linux Geraetetreiber' by Allesandro Rubini, Kalle Dalheimer
  16   for help on Ethernet driver programming
  17
  18   'Ethernet/IEEE 802.3 Family 1992 World Network Data Book/Handbook' by AMD
  19   for documentation on the AM7990 LANCE
  20
  21   'SKNET Personal Technisches Manual', Version 1.2 by Schneider&Koch
  22   for documentation on the Junior board
  23
  24   'SK-NET MC2+ Technical Manual", Version 1.1 by Schneider&Koch for
  25   documentation on the MC2 bord
  26
  27   A big thank you to the S&K support for providing me so quickly with
  28   documentation!
  29
  30   Also see http://www.syskonnect.com/
  31
  32   Missing things:
  33
  34   -> set debug level via ioctl instead of compile-time switches
  35   -> I didn't follow the development of the 2.1.x kernels, so my
  36      assumptions about which things changed with which kernel version
  37      are probably nonsense
  38
  39 History:
  40   May 16th, 1999
  41         startup
  42   May 22st, 1999
  43         added private structure, methods
  44         begun building data structures in RAM
  45   May 23nd, 1999
  46         can receive frames, send frames
  47   May 24th, 1999
  48         modularized intialization of LANCE
  49         loadable as module
  50         still Tx problem :-(
  51   May 26th, 1999
  52         MC2 works
  53         support for multiple devices
  54         display media type for MC2+
  55   May 28th, 1999
  56         fixed problem in GetLANCE leaving interrupts turned off
  57         increase TX queue to 4 packets to improve send performance
  58   May 29th, 1999
  59         a few corrections in statistics, caught rcvr overruns
  60         reinitialization of LANCE/board in critical situations
  61         MCA info implemented
  62         implemented LANCE multicast filter
  63   Jun 6th, 1999
  64         additions for Linux 2.2
  65   Aug 2nd, 1999
  66         small fixes (David Weinehall)
  67
  68  *************************************************************************/
  69
  70 #include <linux/module.h>
  71 #include <linux/version.h>
  72
  73 #include <linux/kernel.h>
  74 #include <linux/version.h>
  75 #include <linux/sched.h>
  76 #include <linux/string.h>
  77 #include <linux/errno.h>
  78 #include <linux/ioport.h>
  79 #include <linux/malloc.h>
  80 #include <linux/interrupt.h>
  81 #include <linux/delay.h>
  82 #include <linux/time.h>
  83 #include <linux/mca.h>
  84 #include <asm/processor.h>
  85 #include <asm/bitops.h>
  86 #include <asm/io.h>
  87
  88 #include <linux/netdevice.h>
  89 #include <linux/etherdevice.h>
  90 #include <linux/skbuff.h>
  91
  92 #define _SK_MCA_DRIVER_
  93 #include "sk_mca.h"
  94
  95 /* ------------------------------------------------------------------------
  96  * global static data - not more since we can handle multiple boards and
  97  * have to pack all state info into the device struct!
  98  * ------------------------------------------------------------------------ */
  99
 100 static char *MediaNames[Media_Count]=
 101             {"10Base2", "10BaseT", "10Base5", "Unknown"};
 102
 103 static unsigned char poly[] =
 104        {1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0,
 105         1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0};
 106
 107 /* ------------------------------------------------------------------------
 108  * private subfunctions
 109  * ------------------------------------------------------------------------ */
 110
 111 /* dump parts of shared memory - only needed during debugging */
 112
 113 #ifdef DEBUG
 114 static void dumpmem(struct net_device *dev, u32 start, u32 len)
 115 {
 116   int z;
 117
 118   for (z = 0; z < len; z++)
 119   {
 120     if ((z & 15) == 0)
 121       printk("%04x:", z);
 122     printk(" %02x", readb(dev->mem_start + start + z));
 123     if ((z & 15) == 15)
 124       printk("\n");
 125   }
 126 }
 127
 128 /* print exact time - ditto */
 129
 130 static void PrTime(void)
 131 {
 132   struct timeval tv;
 133
 134   do_gettimeofday(&tv);
 135   printk("%9d:%06d: ", tv.tv_sec, tv.tv_usec);
 136 }
 137 #endif
 138
 139 /* deduce resources out of POS registers */
 140
 141 static void getaddrs(int slot, int junior, int *base, int *irq,
 142                      skmca_medium *medium)
 143 {
 144   u_char pos0, pos1, pos2;
 145
 146   if (junior)
 147   {
 148     pos0 = mca_read_stored_pos(slot, 2);
 149     *base = ((pos0 & 0x0e) << 13) + 0xc0000;
 150     *irq = ((pos0 & 0x10) >> 4) + 10;
 151     *medium = Media_Unknown;
 152   }
 153   else
 154   {
 155     /* reset POS 104 Bits 0+1 so the shared memory region goes to the
 156        configured area between 640K and 1M.  Afterwards, enable the MC2.
 157        I really don't know what rode SK to do this... */
 158
 159     mca_write_pos(slot, 4, mca_read_stored_pos(slot, 4) & 0xfc);
 160     mca_write_pos(slot, 2, mca_read_stored_pos(slot, 2) | 0x01);
 161
 162     pos1 = mca_read_stored_pos(slot, 3);
 163     pos2 = mca_read_stored_pos(slot, 4);
 164     *base = ((pos1 & 0x07) << 14) + 0xc0000;
 165     switch (pos2 & 0x0c)
 166     {
 167       case 0: *irq = 3; break;
 168       case 4: *irq = 5; break;
 169       case 8: *irq = 10; break;
 170       case 12: *irq = 11; break;
 171     }
 172     *medium = (pos2 >> 6) & 3;
 173   }
 174 }
 175
 176 /* check for both cards:
 177    When the MC2 is turned off, it was configured for more than 15MB RAM,
 178    is disabled and won't get detected using the standard probe.  We
 179    therefore have to scan the slots manually :-( */
 180
 181 static int dofind(int *junior, int firstslot)
 182 {
 183   int slot;
 184   unsigned int id;
 185
 186   for (slot = firstslot; slot < MCA_MAX_SLOT_NR; slot++)
 187   {
 188     id = mca_read_stored_pos(slot, 0)
 189        + (((unsigned int) mca_read_stored_pos(slot, 1)) << 8);
 190
 191     *junior = 0;
 192     if (id == SKNET_MCA_ID)
 193       return slot;
 194     *junior = 1;
 195     if (id == SKNET_JUNIOR_MCA_ID)
 196       return slot;
 197   }
 198   return MCA_NOTFOUND;
 199 }
 200
 201 /* reset the whole board */
 202
 203 static void ResetBoard(struct net_device *dev)
 204 {
 205   skmca_priv *priv = (skmca_priv*) dev->priv;
 206
 207   writeb(CTRL_RESET_ON, priv->ctrladdr);
 208   udelay(10);
 209   writeb(CTRL_RESET_OFF, priv->ctrladdr);
 210 }
 211
 212 /* set LANCE register - must be atomic */
 213
 214 static void SetLANCE(struct net_device *dev, u16 addr, u16 value)
 215 {
 216   skmca_priv *priv = (skmca_priv*) dev->priv;
 217   unsigned long flags;
 218
 219   /* disable interrupts */
 220
 221   save_flags(flags);
 222   cli();
 223
 224   /* wait until no transfer is pending */
 225
 226   while ((readb(priv->ctrladdr) & STAT_IO_BUSY) == STAT_IO_BUSY);
 227
 228   /* transfer register address to RAP */
 229
 230   writeb(CTRL_RESET_OFF | CTRL_RW_WRITE | CTRL_ADR_RAP, priv->ctrladdr);
 231   writew(addr, priv->ioregaddr);
 232   writeb(IOCMD_GO, priv->cmdaddr);
 233   udelay(1);
 234   while ((readb(priv->ctrladdr) & STAT_IO_BUSY) == STAT_IO_BUSY);
 235
 236   /* transfer data to register */
 237
 238   writeb(CTRL_RESET_OFF | CTRL_RW_WRITE | CTRL_ADR_DATA, priv->ctrladdr);
 239   writew(value, priv->ioregaddr);
 240   writeb(IOCMD_GO, priv->cmdaddr);
 241   udelay(1);
 242   while ((readb(priv->ctrladdr) & STAT_IO_BUSY) == STAT_IO_BUSY);
 243
 244   /* reenable interrupts */
 245
 246   restore_flags(flags);
 247 }
 248
 249 /* get LANCE register */
 250
 251 static u16 GetLANCE(struct net_device *dev, u16 addr)
 252 {
 253   skmca_priv *priv = (skmca_priv*) dev->priv;
 254   unsigned long flags;
 255   unsigned int res;
 256
 257   /* disable interrupts */
 258
 259   save_flags(flags);
 260   cli();
 261
 262   /* wait until no transfer is pending */
 263
 264   while ((readb(priv->ctrladdr) & STAT_IO_BUSY) == STAT_IO_BUSY);
 265
 266   /* transfer register address to RAP */
 267
 268   writeb(CTRL_RESET_OFF | CTRL_RW_WRITE | CTRL_ADR_RAP, priv->ctrladdr);
 269   writew(addr, priv->ioregaddr);
 270   writeb(IOCMD_GO, priv->cmdaddr);
 271   udelay(1);
 272   while ((readb(priv->ctrladdr) & STAT_IO_BUSY) == STAT_IO_BUSY);
 273
 274   /* transfer data from register */
 275
 276   writeb(CTRL_RESET_OFF | CTRL_RW_READ | CTRL_ADR_DATA, priv->ctrladdr);
 277   writeb(IOCMD_GO, priv->cmdaddr);
 278   udelay(1);
 279   while ((readb(priv->ctrladdr) & STAT_IO_BUSY) == STAT_IO_BUSY);
 280   res = readw(priv->ioregaddr);
 281
 282   /* reenable interrupts */
 283
 284   restore_flags(flags);
 285
 286   return res;
 287 }
 288
 289 /* build up descriptors in shared RAM */
 290
 291 static void InitDscrs(struct net_device *dev)
 292 {
 293   u32 bufaddr;
 294
 295   /* Set up Tx descriptors. The board has only 16K RAM so bits 16..23
 296      are always 0. */
 297
 298   bufaddr = RAM_DATABASE;
 299   {
 300     LANCE_TxDescr descr;
 301     int z;
 302
 303     for (z = 0; z < TXCOUNT; z++)
 304     {
 305       descr.LowAddr = bufaddr;
 306       descr.Flags = 0;
 307       descr.Len = 0xf000;
 308       descr.Status = 0;
 309       memcpy_toio(dev->mem_start + RAM_TXBASE + (z * sizeof(LANCE_TxDescr)),
 310                   &descr, sizeof(LANCE_TxDescr));
 311       memset_io(dev->mem_start + bufaddr, 0, RAM_BUFSIZE);
 312       bufaddr += RAM_BUFSIZE;
 313     }
 314   }
 315
 316   /* do the same for the Rx descriptors */
 317
 318   {
 319     LANCE_RxDescr descr;
 320     int z;
 321
 322     for (z = 0; z < RXCOUNT; z++)
 323     {
 324       descr.LowAddr = bufaddr;
 325       descr.Flags = RXDSCR_FLAGS_OWN;
 326       descr.MaxLen = -RAM_BUFSIZE;
 327       descr.Len = 0;
 328       memcpy_toio(dev->mem_start + RAM_RXBASE + (z * sizeof(LANCE_RxDescr)),
 329                   &descr, sizeof(LANCE_RxDescr));
 330       memset_io(dev->mem_start + bufaddr, 0, RAM_BUFSIZE);
 331       bufaddr += RAM_BUFSIZE;
 332     }
 333   }
 334 }
 335
 336 /* calculate the hash bit position for a given multicast address
 337    taken more or less directly from the AMD datasheet... */
 338
 339 static void UpdateCRC(unsigned char *CRC, int bit)
 340 {
 341   int j;
 342
 343   /* shift CRC one bit */
 344
 345   memmove(CRC + 1, CRC, 32 * sizeof(unsigned char));
 346   CRC[0] = 0;
 347
 348   /* if bit XOR controlbit = 1, set CRC = CRC XOR polynomial */
 349
 350   if (bit ^ CRC[32])
 351     for (j = 0; j < 32; j++)
 352       CRC[j] ^= poly[j];
 353 }
 354
 355 static unsigned int GetHash(char *address)
 356 {
 357   unsigned char CRC[33];
 358   int i, byte, hashcode;
 359
 360   /* a multicast address has bit 0 in the first byte set */
 361
 362   if ((address[0] & 1) == 0)
 363     return -1;
 364
 365   /* initialize CRC */
 366
 367   memset(CRC, 1, sizeof(CRC));
 368
 369   /* loop through address bits */
 370
 371   for (byte = 0; byte < 6; byte++)
 372     for (i = 0; i < 8; i++)
 373       UpdateCRC(CRC, (address[byte] >> i) & 1);
 374
 375   /* hashcode is the 6 least significant bits of the CRC */
 376
 377   hashcode = 0;
 378   for (i = 0; i < 6; i++)
 379     hashcode = (hashcode << 1) + CRC[i];
 380   return hashcode;
 381 }
 382
 383 /* feed ready-built initialization block into LANCE */
 384
 385 static void InitLANCE(struct net_device *dev)
 386 {
 387   skmca_priv *priv = (skmca_priv*) dev->priv;
 388
 389   /* build up descriptors. */
 390
 391   InitDscrs(dev);
 392
 393   /* next RX descriptor to be read is the first one.  Since the LANCE
 394      will start from the beginning after initialization, we have to
 395      reset out pointers too. */
 396
 397   priv->nextrx = 0;
 398
 399   /* no TX descriptors active */
 400
 401   priv->nexttxput = priv->nexttxdone = priv->txbusy = 0;
 402
 403   /* set up the LANCE bus control register - constant for SKnet boards */
 404
 405   SetLANCE(dev, LANCE_CSR3, CSR3_BSWAP_OFF | CSR3_ALE_LOW | CSR3_BCON_HOLD);
 406
 407   /* write address of initialization block into LANCE */
 408
 409   SetLANCE(dev, LANCE_CSR1, RAM_INITBASE & 0xffff);
 410   SetLANCE(dev, LANCE_CSR2, (RAM_INITBASE >> 16) & 0xff);
 411
 412   /* we don't get ready until the LANCE has read the init block */
 413
 414   dev->tbusy = 1;
 415
 416   /* let LANCE read the initialization block.  LANCE is ready
 417      when we receive the corresponding interrupt. */
 418
 419   SetLANCE(dev, LANCE_CSR0, CSR0_INEA | CSR0_INIT);
 420 }
 421
 422 /* stop the LANCE so we can reinitialize it */
 423
 424 static void StopLANCE(struct net_device *dev)
 425 {
 426   /* can't take frames any more */
 427
 428   dev->tbusy = 1;
 429
 430   /* disable interrupts, stop it */
 431
 432   SetLANCE(dev, LANCE_CSR0, CSR0_STOP);
 433 }
 434
 435 /* initialize card and LANCE for proper operation */
 436
 437 static void InitBoard(struct net_device *dev)
 438 {
 439   LANCE_InitBlock block;
 440
 441   /* Lay out the shared RAM - first we create the init block for the LANCE.
 442      We do not overwrite it later because we need it again when we switch
 443      promiscous mode on/off. */
 444
 445   block.Mode = 0;
 446   if (dev->flags & IFF_PROMISC)
 447     block.Mode |= LANCE_INIT_PROM;
 448   memcpy(block.PAdr, dev->dev_addr, 6);
 449   memset(block.LAdrF, 0, sizeof(block.LAdrF));
 450   block.RdrP = (RAM_RXBASE & 0xffffff) | (LRXCOUNT << 29);
 451   block.TdrP = (RAM_TXBASE & 0xffffff) | (LTXCOUNT << 29);
 452
 453   memcpy_toio(dev->mem_start + RAM_INITBASE, &block, sizeof(block));
 454
 455   /* initialize LANCE. Implicitly sets up other structures in RAM. */
 456
 457   InitLANCE(dev);
 458 }
 459
 460 /* deinitialize card and LANCE */
 461
 462 static void DeinitBoard(struct net_device *dev)
 463 {
 464   /* stop LANCE */
 465
 466   StopLANCE(dev);
 467
 468   /* reset board */
 469
 470   ResetBoard(dev);
 471 }
 472
 473 /* ------------------------------------------------------------------------
 474  * interrupt handler(s)
 475  * ------------------------------------------------------------------------ */
 476
 477 /* LANCE has read initializazion block -> start it */
 478
 479 static u16 irqstart_handler(struct net_device *dev, u16 oldcsr0)
 480 {
 481   /* now we're ready to transmit */
 482
 483   dev->tbusy = 0;
 484
 485   /* reset IDON bit, start LANCE */
 486
 487   SetLANCE(dev, LANCE_CSR0, oldcsr0 | CSR0_IDON | CSR0_STRT);
 488   return GetLANCE(dev, LANCE_CSR0);
 489 }
 490
 491 /* receive interrupt */
 492
 493 static u16 irqrx_handler(struct net_device *dev, u16 oldcsr0)
 494 {
 495   skmca_priv *priv = (skmca_priv*) dev->priv;
 496   LANCE_RxDescr descr;
 497   unsigned int descraddr;
 498
 499   /* did we loose blocks due to a FIFO overrun ? */
 500
 501   if (oldcsr0 & CSR0_MISS)
 502     priv->stat.rx_fifo_errors++;
 503
 504   /* run through queue until we reach a descriptor we do not own */
 505
 506   descraddr = RAM_RXBASE + (priv->nextrx * sizeof(LANCE_RxDescr));
 507   while (1)
 508   {
 509     /* read descriptor */
 510     memcpy_fromio(&descr, dev->mem_start + descraddr, sizeof(LANCE_RxDescr));
 511
 512     /* if we reach a descriptor we do not own, we're done */
 513     if ((descr.Flags & RXDSCR_FLAGS_OWN) != 0)
 514       break;
 515
 516 #ifdef DEBUG
 517     PrTime(); printk("Receive packet on descr %d len %d\n", priv->nextrx, descr.Len);
 518 #endif
 519
 520     /* erroneous packet ? */
 521     if ((descr.Flags & RXDSCR_FLAGS_ERR) != 0)
 522     {
 523       priv->stat.rx_errors++;
 524       if ((descr.Flags & RXDSCR_FLAGS_CRC) != 0)
 525         priv->stat.rx_crc_errors++;
 526       else if ((descr.Flags & RXDSCR_FLAGS_CRC) != 0)
 527         priv->stat.rx_frame_errors++;
 528       else if ((descr.Flags & RXDSCR_FLAGS_OFLO) != 0)
 529         priv->stat.rx_fifo_errors++;
 530     }
 531
 532     /* good packet ? */
 533     else
 534     {
 535       struct sk_buff *skb;
 536
 537       skb = dev_alloc_skb(descr.Len + 2);
 538       if (skb == NULL)
 539         priv->stat.rx_dropped++;
 540       else
 541       {
 542         memcpy_fromio(skb_put(skb, descr.Len),
 543                       dev->mem_start + descr.LowAddr, descr.Len);
 544         skb->dev = dev;
 545         skb->protocol = eth_type_trans(skb, dev);
 546         skb->ip_summed = CHECKSUM_NONE;
 547         priv->stat.rx_packets++;
 548 #if LINUX_VERSION_CODE >= 0x020119       /* byte counters for >= 2.1.25 */
 549         priv->stat.rx_bytes += descr.Len;
 550 #endif
 551         netif_rx(skb);
 552       }
 553     }
 554
 555     /* give descriptor back to LANCE */
 556     descr.Len = 0;
 557     descr.Flags |= RXDSCR_FLAGS_OWN;
 558
 559     /* update descriptor in shared RAM */
 560     memcpy_toio(dev->mem_start + descraddr, &descr, sizeof(LANCE_RxDescr));
 561
 562     /* go to next descriptor */
 563     priv->nextrx++; descraddr += sizeof(LANCE_RxDescr);
 564     if (priv->nextrx >= RXCOUNT)
 565     {
 566       priv->nextrx = 0;
 567       descraddr = RAM_RXBASE;
 568     }
 569   }
 570
 571   /* reset RINT bit */
 572
 573   SetLANCE(dev, LANCE_CSR0, oldcsr0 | CSR0_RINT);
 574   return GetLANCE(dev, LANCE_CSR0);
 575 }
 576
 577 /* transmit interrupt */
 578
 579 static u16 irqtx_handler(struct net_device *dev, u16 oldcsr0)
 580 {
 581   skmca_priv *priv = (skmca_priv*) dev->priv;
 582   LANCE_TxDescr descr;
 583   unsigned int descraddr;
 584
 585   /* check descriptors at most until no busy one is left */
 586
 587   descraddr = RAM_TXBASE + (priv->nexttxdone * sizeof(LANCE_TxDescr));
 588   while (priv->txbusy > 0)
 589   {
 590     /* read descriptor */
 591     memcpy_fromio(&descr, dev->mem_start + descraddr, sizeof(LANCE_TxDescr));
 592
 593     /* if the LANCE still owns this one, we've worked out all sent packets */
 594     if ((descr.Flags & TXDSCR_FLAGS_OWN) != 0)
 595       break;
 596
 597 #ifdef DEBUG
 598     PrTime(); printk("Send packet done on descr %d\n", priv->nexttxdone);
 599 #endif
 600
 601     /* update statistics */
 602     if ((descr.Flags & TXDSCR_FLAGS_ERR) == 0)
 603     {
 604       priv->stat.tx_packets++;
 605 #if LINUX_VERSION_CODE >= 0x020119       /* byte counters for >= 2.1.25 */
 606       priv->stat.tx_bytes++;
 607 #endif
 608     }
 609     else
 610     {
 611       priv->stat.tx_errors++;
 612       if ((descr.Status & TXDSCR_STATUS_UFLO) != 0)
 613       {
 614         priv->stat.tx_fifo_errors++;
 615         InitLANCE(dev);
 616       }
 617       else if ((descr.Status & TXDSCR_STATUS_LCOL) != 0)
 618         priv->stat.tx_window_errors++;
 619       else if ((descr.Status & TXDSCR_STATUS_LCAR) != 0)
 620         priv->stat.tx_carrier_errors++;
 621       else if ((descr.Status & TXDSCR_STATUS_RTRY) != 0)
 622         priv->stat.tx_aborted_errors++;
 623     }
 624
 625     /* go to next descriptor */
 626     priv->nexttxdone++;
 627     descraddr += sizeof(LANCE_TxDescr);
 628     if (priv->nexttxdone >= TXCOUNT)
 629     {
 630       priv->nexttxdone = 0;
 631       descraddr = RAM_TXBASE;
 632     }
 633     priv->txbusy--;
 634   }
 635
 636   /* reset TX interrupt bit */
 637
 638   SetLANCE(dev, LANCE_CSR0, oldcsr0 | CSR0_TINT);
 639   oldcsr0 = GetLANCE(dev, LANCE_CSR0);
 640
 641   /* at least one descriptor is freed.  Therefore we can accept
 642      a new one */
 643
 644   dev->tbusy = 0;
 645
 646   /* inform upper layers we're in business again */
 647
 648   mark_bh(NET_BH);
 649
 650   return oldcsr0;
 651 }
 652
 653 /* general interrupt entry */
 654
 655 static void irq_handler(int irq, void *device, struct pt_regs *regs)
 656 {
 657   struct net_device *dev = (struct net_device*) device;
 658   u16 csr0val;
 659
 660   /* read CSR0 to get interrupt cause */
 661
 662   csr0val = GetLANCE(dev, LANCE_CSR0);
 663
 664   /* in case we're not meant... */
 665
 666   if ((csr0val & CSR0_INTR) == 0)
 667     return;
 668
 669   dev->interrupt = 1;
 670
 671   /* loop through the interrupt bits until everything is clear */
 672
 673   do
 674   {
 675     if ((csr0val & CSR0_IDON) != 0)
 676       csr0val = irqstart_handler(dev, csr0val);
 677     if ((csr0val & CSR0_RINT) != 0)
 678       csr0val = irqrx_handler(dev, csr0val);
 679     if ((csr0val & CSR0_TINT) != 0)
 680       csr0val = irqtx_handler(dev, csr0val);
 681   }
 682   while ((csr0val & CSR0_INTR) != 0);
 683
 684   dev->interrupt = 0;
 685 }
 686
 687 /* ------------------------------------------------------------------------
 688  * driver methods
 689  * ------------------------------------------------------------------------ */
 690
 691 /* MCA info */
 692
 693 static int skmca_getinfo(char *buf, int slot, void *d)
 694 {
 695   int len = 0, i;
 696   struct net_device *dev = (struct net_device*) d;
 697   skmca_priv *priv;
 698
 699   /* can't say anything about an uninitialized device... */
 700
 701   if (dev == NULL)
 702     return len;
 703   if (dev->priv == NULL)
 704     return len;
 705   priv = (skmca_priv*) dev->priv;
 706
 707   /* print info */
 708
 709   len += sprintf(buf + len, "IRQ: %d\n", priv->realirq);
 710   len += sprintf(buf + len, "Memory: %#lx-%#lx\n", dev->mem_start,
 711                  dev->mem_end - 1);
 712   len += sprintf(buf + len, "Transceiver: %s\n", MediaNames[priv->medium]);
 713   len += sprintf(buf + len, "Device: %s\n", dev->name);
 714   len += sprintf(buf + len, "MAC address:");
 715   for (i = 0; i < 6; i ++ )
 716     len += sprintf( buf+len, " %02x", dev->dev_addr[i] );
 717   buf[len++] = '\n';
 718   buf[len] = 0;
 719
 720   return len;
 721 }
 722
 723 /* open driver.  Means also initialization and start of LANCE */
 724
 725 static int skmca_open(struct net_device *dev)
 726 {
 727   int result;
 728   skmca_priv *priv = (skmca_priv*) dev->priv;
 729
 730   /* register resources - only necessary for IRQ */
 731   result = request_irq(priv->realirq, irq_handler, SA_SHIRQ | SA_SAMPLE_RANDOM,
 732                        "sk_mca", dev);
 733   if (result != 0)
 734   {
 735     printk("%s: failed to register irq %d\n", dev->name, dev->irq);
 736     return result;
 737   }
 738   dev->irq = priv->realirq;
 739
 740   /* set up the card and LANCE */
 741   InitBoard(dev);
 742
 743 #ifdef MODULE
 744   MOD_INC_USE_COUNT;
 745 #endif
 746
 747   return 0;
 748 }
 749
 750 /* close driver.  Shut down board and free allocated resources */
 751
 752 static int skmca_close(struct net_device *dev)
 753 {
 754   /* turn off board */
 755   DeinitBoard(dev);
 756
 757   /* release resources */
 758   if (dev->irq != 0)
 759     free_irq(dev->irq, dev);
 760   dev->irq = 0;
 761
 762 #ifdef MODULE
 763   MOD_DEC_USE_COUNT;
 764 #endif
 765
 766   return 0;
 767 }
 768
 769 /* transmit a block. */
 770
 771 static int skmca_tx(struct sk_buff *skb, struct net_device *dev)
 772 {
 773   skmca_priv *priv = (skmca_priv*) dev->priv;
 774   LANCE_TxDescr descr;
 775   unsigned int address;
 776   int tmplen, retval = 0;
 777   unsigned long flags;
 778
 779   /* if we get called with a NULL descriptor, the Ethernet layer thinks
 780      our card is stuck an we should reset it.  We'll do this completely: */
 781
 782   if (skb == NULL)
 783   {
 784     DeinitBoard(dev);
 785     InitBoard(dev);
 786     return 0; /* don't try to free the block here ;-) */
 787   }
 788
 789   /* is there space in the Tx queue ? If no, the upper layer gave us a
 790      packet in spite of us not being ready and is really in trouble.
 791      We'll do the dropping for him: */
 792   if (priv->txbusy >= TXCOUNT)
 793   {
 794     priv->stat.tx_dropped++;
 795     retval = -EIO;
 796     goto tx_done;
 797   }
 798
 799   /* get TX descriptor */
 800   address = RAM_TXBASE + (priv->nexttxput * sizeof(LANCE_TxDescr));
 801   memcpy_fromio(&descr, dev->mem_start + address, sizeof(LANCE_TxDescr));
 802
 803   /* enter packet length as 2s complement - assure minimum length */
 804   tmplen = skb->len;
 805   if (tmplen < 60)
 806     tmplen = 60;
 807   descr.Len = 65536 - tmplen;
 808
 809   /* copy filler into RAM - in case we're filling up...
 810      we're filling a bit more than necessary, but that doesn't harm
 811      since the buffer is far larger... */
 812   if (tmplen > skb->len)
 813   {
 814     char *fill = "NetBSD is a nice OS too! ";
 815     unsigned int destoffs = 0, l = strlen(fill);
 816
 817     while (destoffs < tmplen)
 818     {
 819       memcpy_toio(dev->mem_start + descr.LowAddr + destoffs, fill, l);
 820       destoffs += l;
 821     }
 822   }
 823
 824   /* do the real data copying */
 825   memcpy_toio(dev->mem_start + descr.LowAddr, skb->data, skb->len);
 826
 827   /* hand descriptor over to LANCE - this is the first and last chunk */
 828   descr.Flags = TXDSCR_FLAGS_OWN | TXDSCR_FLAGS_STP | TXDSCR_FLAGS_ENP;
 829
 830 #ifdef DEBUG
 831   PrTime(); printk("Send packet on descr %d len %d\n", priv->nexttxput, skb->len);
 832 #endif
 833
 834   /* one more descriptor busy */
 835   save_flags(flags);
 836   cli();
 837   priv->nexttxput++;
 838   if (priv->nexttxput >= TXCOUNT)
 839     priv->nexttxput = 0;
 840   priv->txbusy++;
 841   dev->tbusy = (priv->txbusy >= TXCOUNT);
 842
 843   /* write descriptor back to RAM */
 844   memcpy_toio(dev->mem_start + address, &descr, sizeof(LANCE_TxDescr));
 845
 846   /* if no descriptors were active, give the LANCE a hint to read it
 847      immediately */
 848
 849   if (priv->txbusy == 0)
 850     SetLANCE(dev, LANCE_CSR0, CSR0_INEA | CSR0_TDMD);
 851
 852   restore_flags(flags);
 853
 854 tx_done:
 855
 856   /* When did that change exactly ? */
 857
 858 #if LINUX_VERSION_CODE >= 0x020200
 859   dev_kfree_skb(skb);
 860 #else
 861   dev_kfree_skb(skb, FREE_WRITE);
 862 #endif
 863   return retval;
 864 }
 865
 866 /* return pointer to Ethernet statistics */
 867
 868 static struct enet_statistics *skmca_stats(struct net_device *dev)
 869 {
 870   skmca_priv *priv = (skmca_priv*) dev->priv;
 871
 872   return &(priv->stat);
 873 }
 874
 875 /* we don't support runtime reconfiguration, since an MCA card can
 876    be unambigously identified by its POS registers. */
 877
 878 static int skmca_config(struct net_device *dev, struct ifmap *map)
 879 {
 880   return 0;
 881 }
 882
 883 /* switch receiver mode.  We use the LANCE's multicast filter to prefilter
 884    multicast addresses. */
 885
 886 static void skmca_set_multicast_list(struct net_device *dev)
 887 {
 888   LANCE_InitBlock block;
 889
 890   /* first stop the LANCE... */
 891   StopLANCE(dev);
 892
 893   /* ...then modify the initialization block... */
 894   memcpy_fromio(&block, dev->mem_start + RAM_INITBASE, sizeof(block));
 895   if (dev->flags & IFF_PROMISC)
 896     block.Mode |= LANCE_INIT_PROM;
 897   else
 898     block.Mode &= ~LANCE_INIT_PROM;
 899
 900   if (dev->flags & IFF_ALLMULTI)   /* get all multicasts */
 901   {
 902     memset(block.LAdrF, 8, 0xff);
 903   }
 904   else                             /* get selected/no multicasts */
 905   {
 906     struct dev_mc_list *mptr;
 907     int code;
 908
 909     memset(block.LAdrF, 8, 0x00);
 910     for (mptr = dev->mc_list; mptr != NULL; mptr = mptr->next)
 911     {
 912       code = GetHash(mptr->dmi_addr);
 913       block.LAdrF[(code >> 3) & 7] |= 1 << (code & 7);
 914     }
 915   }
 916
 917   memcpy_toio(dev->mem_start + RAM_INITBASE, &block, sizeof(block));
 918
 919   /* ...then reinit LANCE with the correct flags */
 920   InitLANCE(dev);
 921 }
 922
 923 /* ------------------------------------------------------------------------
 924  * hardware check
 925  * ------------------------------------------------------------------------ */
 926
 927 #ifdef MODULE
 928 static int startslot; /* counts through slots when probing multiple devices */
 929 #else
 930 #define startslot 0   /* otherwise a dummy, since there is only eth0 in-kern*/
 931 #endif
 932
 933 int skmca_probe(struct net_device *dev)
 934 {
 935   int force_detect = 0;
 936   int junior, slot, i;
 937   int base = 0, irq = 0;
 938   skmca_priv *priv;
 939   skmca_medium medium;
 940
 941   /* can't work without an MCA bus ;-) */
 942
 943   if (MCA_bus == 0)
 944     return ENODEV;
 945
 946   /* start address of 1 --> forced detection */
 947
 948   if (dev->mem_start == 1)
 949     force_detect = 1;
 950
 951   /* search through slots */
 952
 953   if (dev != NULL)
 954   {
 955     base = dev->mem_start;
 956     irq = dev->irq;
 957   }
 958   slot = dofind(&junior, startslot);
 959
 960   while (slot != -1)
 961   {
 962     /* deduce card addresses */
 963
 964     getaddrs(slot, junior, &base, &irq, &medium);
 965
 966 #if LINUX_VERSION_CODE >= 0x020200
 967     /* slot already in use ? */
 968
 969     if (mca_is_adapter_used(slot))
 970     {
 971       slot = dofind(&junior, slot + 1);
 972       continue;
 973     }
 974 #endif
 975
 976     /* were we looking for something different ? */
 977
 978     if ((dev->irq != 0) || (dev->mem_start != 0))
 979     {
 980       if ((dev->irq != 0) && (dev->irq != irq))
 981       {
 982         slot = dofind(&junior, slot + 1);
 983         continue;
 984       }
 985       if ((dev->mem_start != 0) && (dev->mem_start != base))
 986       {
 987         slot = dofind(&junior, slot + 1);
 988         continue;
 989       }
 990     }
 991
 992     /* found something that matches */
 993
 994     break;
 995   }
 996
 997   /* nothing found ? */
 998
 999   if (slot == -1)
1000     return ((base != 0) || (irq != 0)) ? ENXIO : ENODEV;
1001
1002   /* make procfs entries */
1003
1004   if (junior)
1005     mca_set_adapter_name(slot, "SKNET junior MC2 Ethernet Adapter");
1006   else
1007     mca_set_adapter_name(slot, "SKNET MC2+ Ethernet Adapter");
1008   mca_set_adapter_procfn(slot, (MCA_ProcFn) skmca_getinfo, dev);
1009
1010 #if LINUX_VERSION_CODE >= 0x020200
1011   mca_mark_as_used(slot);
1012 #endif
1013
1014   /* announce success */
1015   printk("%s: SKNet %s adapter found in slot %d\n", dev->name,
1016          junior ? "Junior MC2" : "MC2+", slot + 1);
1017
1018   /* allocate structure */
1019   priv = dev->priv = (skmca_priv*) kmalloc(sizeof(skmca_priv), GFP_KERNEL);
1020   priv->slot = slot;
1021   priv->macbase = base + 0x3fc0;
1022   priv->ioregaddr = base + 0x3ff0;
1023   priv->ctrladdr = base + 0x3ff2;
1024   priv->cmdaddr = base + 0x3ff3;
1025   priv->realirq = irq;
1026   priv->medium = medium;
1027   memset(&(priv->stat), 0, sizeof(struct enet_statistics));
1028
1029   /* set base + irq for this device (irq not allocated so far) */
1030   dev->irq = 0;
1031   dev->mem_start = base;
1032   dev->mem_end = base + 0x4000;
1033
1034   /* set methods */
1035   dev->open = skmca_open;
1036   dev->stop = skmca_close;
1037   dev->set_config = skmca_config;
1038   dev->hard_start_xmit = skmca_tx;
1039   dev->do_ioctl = NULL;
1040   dev->get_stats = skmca_stats;
1041   dev->set_multicast_list = skmca_set_multicast_list;
1042   dev->flags |= IFF_MULTICAST;
1043
1044   /* generic setup */
1045   ether_setup(dev);
1046   dev->interrupt = 0;
1047   dev->tbusy = 0;
1048   dev->start = 0;
1049
1050   /* copy out MAC address */
1051   for (i = 0; i < 6; i++)
1052     dev->dev_addr[i] = readb(priv->macbase + (i << 1));
1053
1054   /* print config */
1055   printk("%s: IRQ %d, memory %#lx-%#lx, "
1056          "MAC address %02x:%02x:%02x:%02x:%02x:%02x.\n",
1057          dev->name, priv->realirq,  dev->mem_start, dev->mem_end - 1,
1058          dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
1059          dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5]);
1060   printk("%s: %s medium\n", dev->name, MediaNames[priv->medium]);
1061
1062   /* reset board */
1063
1064   ResetBoard(dev);
1065
1066 #ifdef MODULE
1067   startslot = slot + 1;
1068 #endif
1069
1070   return 0;
1071 }
1072
1073 /* ------------------------------------------------------------------------
1074  * modularization support
1075  * ------------------------------------------------------------------------ */
1076
1077 #ifdef MODULE
1078
1079 #define DEVMAX 5
1080
1081 static char NameSpace[8 * DEVMAX];
1082 static struct net_device moddevs[DEVMAX] =
1083        {{NameSpace +  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, skmca_probe},
1084         {NameSpace +  8, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, skmca_probe},
1085         {NameSpace + 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, skmca_probe},
1086         {NameSpace + 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, skmca_probe},
1087         {NameSpace + 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, skmca_probe}};
1088
1089 int irq=0;
1090 int io=0;
1091
1092 int init_module(void)
1093 {
1094   int z, res;
1095
1096   startslot = 0;
1097   for (z = 0; z < DEVMAX; z++)
1098   {
1099     strcpy(moddevs[z].name, "     ");
1100     res = register_netdev(moddevs + z);
1101     if (res != 0)
1102       return (z > 0) ? 0 : -EIO;
1103   }
1104
1105   return 0;
1106 }
1107
1108 void cleanup_module(void)
1109 {
1110   struct net_device *dev;
1111   skmca_priv *priv;
1112   int z;
1113
1114   if (MOD_IN_USE)
1115   {
1116     printk("cannot unload, module in use\n");
1117     return;
1118   }
1119
1120   for (z = 0; z < DEVMAX; z++)
1121   {
1122     dev = moddevs + z;
1123     if (dev->priv != NULL)
1124     {
1125       priv = (skmca_priv*) dev->priv;
1126       DeinitBoard(dev);
1127       if (dev->irq != 0)
1128         free_irq(dev->irq, dev);
1129       dev->irq = 0;
1130       unregister_netdev(dev);
1131 #if LINUX_VERSION_CODE >= 0x020200
1132       mca_mark_as_unused(priv->slot);
1133 #endif
1134       mca_set_adapter_procfn(priv->slot, NULL, NULL);
1135       kfree_s(dev->priv, sizeof(skmca_priv));
1136       dev->priv = NULL;
1137     }
1138   }
1139 }
1140 #endif /* MODULE */