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