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