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