drivers/net/ibmlana.c

   1 /*
   2 net-3-driver for the IBM LAN Adapter/A
   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 SK_MCA driver, which is itself based on the
  10 SK_G16 and 3C523 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   'DP83934CVUL-20/25 MHz SONIC-T Ethernet Controller Datasheet' by National
  20   Semiconductor for info on the MAC chip
  21
  22   'LAN Technical Reference Ethernet Adapter Interface Version 1 Release 1.0
  23    Document Number SC30-3661-00' by IBM for info on the adapter itself
  24
  25   Also see http://www.natsemi.com/
  26
  27 special acknowledgements to:
  28   - Bob Eager for helping me out with documentation from IBM
  29   - Jim Shorney for his endless patience with me while I was using
  30     him as a beta tester to trace down the address filter bug ;-)
  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   Nov 6th, 1999
  41         startup from SK_MCA driver
  42   Dec 6th, 1999
  43         finally got docs about the card.  A big thank you to Bob Eager!
  44   Dec 12th, 1999
  45         first packet received
  46   Dec 13th, 1999
  47         recv queue done, tcpdump works
  48   Dec 15th, 1999
  49         transmission part works
  50   Dec 28th, 1999
  51         added usage of the isa_functions for Linux 2.3 .  Things should
  52         still work with 2.0.x....
  53   Jan 28th, 2000
  54         in Linux 2.2.13, the version.h file mysteriously didn't get
  55         included.  Added a workaround for this.  Futhermore, it now
  56         not only compiles as a modules ;-)
  57   Jan 30th, 2000
  58         newer kernels automatically probe more than one board, so the
  59         'startslot' as a variable is also needed here
  60   Apr 12th, 2000
  61         the interrupt mask register is not set 'hard' instead of individually
  62         setting registers, since this seems to set bits that shouldn't be
  63         set
  64   May 21st, 2000
  65         reset interrupt status immediately after CAM load
  66         add a recovery delay after releasing the chip's reset line
  67   May 24th, 2000
  68         finally found the bug in the address filter setup - damned signed
  69         chars!
  70   June 1st, 2000
  71         corrected version codes, added support for the latest 2.3 changes
  72
  73  *************************************************************************/
  74
  75 #include <linux/version.h>
  76 #include <linux/kernel.h>
  77 #include <linux/sched.h>
  78 #include <linux/string.h>
  79 #include <linux/errno.h>
  80 #include <linux/ioport.h>
  81 #include <linux/slab.h>
  82 #include <linux/interrupt.h>
  83 #include <linux/delay.h>
  84 #include <linux/time.h>
  85 #include <linux/mca.h>
  86 #include <asm/processor.h>
  87 #include <asm/bitops.h>
  88 #include <asm/io.h>
  89
  90 #include <linux/module.h>
  91
  92 #include <linux/netdevice.h>
  93 #include <linux/etherdevice.h>
  94 #include <linux/skbuff.h>
  95
  96 #define _IBM_LANA_DRIVER_
  97 #include "ibmlana.h"
  98
  99 #undef DEBUG
 100
 101 /* ------------------------------------------------------------------------
 102  * global static data - not more since we can handle multiple boards and
 103  * have to pack all state info into the device struct!
 104  * ------------------------------------------------------------------------ */
 105
 106 static char *MediaNames[Media_Count] =
 107     { "10BaseT", "10Base5", "Unknown", "10Base2" };
 108
 109 /* ------------------------------------------------------------------------
 110  * private subfunctions
 111  * ------------------------------------------------------------------------ */
 112
 113 #ifdef DEBUG
 114   /* dump all registers */
 115
 116 static void dumpregs(struct IBMLANA_NETDEV *dev)
 117 {
 118         int z;
 119
 120         for (z = 0; z < 160; z += 2) {
 121                 if (!(z & 15))
 122                         printk("REGS: %04x:", z);
 123                 printk(" %04x", inw(dev->base_addr + z));
 124                 if ((z & 15) == 14)
 125                         printk("\n");
 126         }
 127 }
 128
 129 /* dump parts of shared memory - only needed during debugging */
 130
 131 static void dumpmem(struct IBMLANA_NETDEV *dev, u32 start, u32 len)
 132 {
 133         int z;
 134
 135         printk("Address %04x:\n", start);
 136         for (z = 0; z < len; z++) {
 137                 if ((z & 15) == 0)
 138                         printk("%04x:", z);
 139                 printk(" %02x", IBMLANA_READB(dev->mem_start + start + z));
 140                 if ((z & 15) == 15)
 141                         printk("\n");
 142         }
 143         if ((z & 15) != 0)
 144                 printk("\n");
 145 }
 146
 147 /* print exact time - ditto */
 148
 149 static void PrTime(void)
 150 {
 151         struct timeval tv;
 152
 153         do_gettimeofday(&tv);
 154         printk("%9d:%06d: ", (int) tv.tv_sec, (int) tv.tv_usec);
 155 }
 156 #endif                          /* DEBUG */
 157
 158 /* deduce resources out of POS registers */
 159
 160 static void getaddrs(int slot, int *base, int *memlen, int *iobase,
 161                      int *irq, ibmlana_medium * medium)
 162 {
 163         u_char pos0, pos1;
 164
 165         pos0 = mca_read_stored_pos(slot, 2);
 166         pos1 = mca_read_stored_pos(slot, 3);
 167
 168         *base = 0xc0000 + ((pos1 & 0xf0) << 9);
 169         *memlen = (pos1 & 0x01) ? 0x8000 : 0x4000;
 170         *iobase = (pos0 & 0xe0) << 7;
 171         switch (pos0 & 0x06) {
 172         case 0:
 173                 *irq = 5;
 174                 break;
 175         case 2:
 176                 *irq = 15;
 177                 break;
 178         case 4:
 179                 *irq = 10;
 180                 break;
 181         case 6:
 182                 *irq = 11;
 183                 break;
 184         }
 185         *medium = (pos0 & 0x18) >> 3;
 186 }
 187
 188 /* wait on register value with mask and timeout */
 189
 190 static int wait_timeout(struct IBMLANA_NETDEV *dev, int regoffs, u16 mask,
 191                         u16 value, int timeout)
 192 {
 193         unsigned long fin = jiffies + timeout;
 194
 195         while (jiffies != fin)
 196                 if ((inw(dev->base_addr + regoffs) & mask) == value)
 197                         return 1;
 198
 199         return 0;
 200 }
 201
 202
 203 /* reset the whole board */
 204
 205 static void ResetBoard(struct IBMLANA_NETDEV *dev)
 206 {
 207         unsigned char bcmval;
 208
 209         /* read original board control value */
 210
 211         bcmval = inb(dev->base_addr + BCMREG);
 212
 213         /* set reset bit for a while */
 214
 215         bcmval |= BCMREG_RESET;
 216         outb(bcmval, dev->base_addr + BCMREG);
 217         udelay(10);
 218         bcmval &= ~BCMREG_RESET;
 219         outb(bcmval, dev->base_addr + BCMREG);
 220
 221         /* switch over to RAM again */
 222
 223         bcmval |= BCMREG_RAMEN | BCMREG_RAMWIN;
 224         outb(bcmval, dev->base_addr + BCMREG);
 225 }
 226
 227 /* calculate RAM layout & set up descriptors in RAM */
 228
 229 static void InitDscrs(struct IBMLANA_NETDEV *dev)
 230 {
 231         ibmlana_priv *priv = (ibmlana_priv *) dev->priv;
 232         u32 addr, baddr, raddr;
 233         int z;
 234         tda_t tda;
 235         rda_t rda;
 236         rra_t rra;
 237
 238         /* initialize RAM */
 239
 240         IBMLANA_SETIO(dev->mem_start, 0xaa,
 241                       dev->mem_start - dev->mem_start);
 242
 243         /* setup n TX descriptors - independent of RAM size */
 244
 245         priv->tdastart = addr = 0;
 246         priv->txbufstart = baddr = sizeof(tda_t) * TXBUFCNT;
 247         for (z = 0; z < TXBUFCNT; z++) {
 248                 tda.status = 0;
 249                 tda.config = 0;
 250                 tda.length = 0;
 251                 tda.fragcount = 1;
 252                 tda.startlo = baddr;
 253                 tda.starthi = 0;
 254                 tda.fraglength = 0;
 255                 if (z == TXBUFCNT - 1)
 256                         tda.link = priv->tdastart;
 257                 else
 258                         tda.link = addr + sizeof(tda_t);
 259                 tda.link |= 1;
 260                 IBMLANA_TOIO(dev->mem_start + addr, &tda, sizeof(tda_t));
 261                 addr += sizeof(tda_t);
 262                 baddr += PKTSIZE;
 263         }
 264
 265         /* calculate how many receive buffers fit into remaining memory */
 266
 267         priv->rxbufcnt = (dev->mem_end - dev->mem_start - baddr) /
 268             (sizeof(rra_t) + sizeof(rda_t) + PKTSIZE);
 269
 270         /* calculate receive addresses */
 271
 272         priv->rrastart = raddr = priv->txbufstart + (TXBUFCNT * PKTSIZE);
 273         priv->rdastart = addr =
 274             priv->rrastart + (priv->rxbufcnt * sizeof(rra_t));
 275         priv->rxbufstart = baddr =
 276             priv->rdastart + (priv->rxbufcnt * sizeof(rda_t));
 277         for (z = 0; z < priv->rxbufcnt; z++) {
 278                 rra.startlo = baddr;
 279                 rra.starthi = 0;
 280                 rra.cntlo = PKTSIZE >> 1;
 281                 rra.cnthi = 0;
 282                 IBMLANA_TOIO(dev->mem_start + raddr, &rra, sizeof(rra_t));
 283
 284                 rda.status = 0;
 285                 rda.length = 0;
 286                 rda.startlo = 0;
 287                 rda.starthi = 0;
 288                 rda.seqno = 0;
 289                 if (z < priv->rxbufcnt - 1)
 290                         rda.link = addr + sizeof(rda_t);
 291                 else
 292                         rda.link = 1;
 293                 rda.inuse = 1;
 294                 IBMLANA_TOIO(dev->mem_start + addr, &rda, sizeof(rda_t));
 295
 296                 baddr += PKTSIZE;
 297                 raddr += sizeof(rra_t);
 298                 addr += sizeof(rda_t);
 299         }
 300
 301         /* initialize current pointers */
 302
 303         priv->nextrxdescr = 0;
 304         priv->lastrxdescr = priv->rxbufcnt - 1;
 305         priv->nexttxdescr = 0;
 306         priv->currtxdescr = 0;
 307         priv->txusedcnt = 0;
 308         memset(priv->txused, 0, sizeof(priv->txused));
 309 }
 310
 311 /* set up Rx + Tx descriptors in SONIC */
 312
 313 static int InitSONIC(struct IBMLANA_NETDEV *dev)
 314 {
 315         ibmlana_priv *priv = (ibmlana_priv *) dev->priv;
 316
 317         /* set up start & end of resource area */
 318
 319         outw(0, SONIC_URRA);
 320         outw(priv->rrastart, dev->base_addr + SONIC_RSA);
 321         outw(priv->rrastart + (priv->rxbufcnt * sizeof(rra_t)),
 322              dev->base_addr + SONIC_REA);
 323         outw(priv->rrastart, dev->base_addr + SONIC_RRP);
 324         outw(priv->rrastart, dev->base_addr + SONIC_RWP);
 325
 326         /* set EOBC so that only one packet goes into one buffer */
 327
 328         outw((PKTSIZE - 4) >> 1, dev->base_addr + SONIC_EOBC);
 329
 330         /* let SONIC read the first RRA descriptor */
 331
 332         outw(CMDREG_RRRA, dev->base_addr + SONIC_CMDREG);
 333         if (!wait_timeout(dev, SONIC_CMDREG, CMDREG_RRRA, 0, 2)) {
 334                 printk
 335                     ("%s: SONIC did not respond on RRRA command - giving up.",
 336                      dev->name);
 337                 return 0;
 338         }
 339
 340         /* point SONIC to the first RDA */
 341
 342         outw(0, dev->base_addr + SONIC_URDA);
 343         outw(priv->rdastart, dev->base_addr + SONIC_CRDA);
 344
 345         /* set upper half of TDA address */
 346
 347         outw(0, dev->base_addr + SONIC_UTDA);
 348
 349         return 1;
 350 }
 351
 352 /* stop SONIC so we can reinitialize it */
 353
 354 static void StopSONIC(struct IBMLANA_NETDEV *dev)
 355 {
 356         /* disable interrupts */
 357
 358         outb(inb(dev->base_addr + BCMREG) & (~BCMREG_IEN),
 359              dev->base_addr + BCMREG);
 360         outb(0, dev->base_addr + SONIC_IMREG);
 361
 362         /* reset the SONIC */
 363
 364         outw(CMDREG_RST, dev->base_addr + SONIC_CMDREG);
 365         udelay(10);
 366         outw(CMDREG_RST, dev->base_addr + SONIC_CMDREG);
 367 }
 368
 369 /* initialize card and SONIC for proper operation */
 370
 371 static void putcam(camentry_t * cams, int *camcnt, char *addr)
 372 {
 373         camentry_t *pcam = cams + (*camcnt);
 374         u8 *uaddr = (u8 *) addr;
 375
 376         pcam->index = *camcnt;
 377         pcam->addr0 = (((u16) uaddr[1]) << 8) | uaddr[0];
 378         pcam->addr1 = (((u16) uaddr[3]) << 8) | uaddr[2];
 379         pcam->addr2 = (((u16) uaddr[5]) << 8) | uaddr[4];
 380         (*camcnt)++;
 381 }
 382
 383 static void InitBoard(struct IBMLANA_NETDEV *dev)
 384 {
 385         int camcnt;
 386         camentry_t cams[16];
 387         u32 cammask;
 388         struct dev_mc_list *mcptr;
 389         u16 rcrval;
 390
 391         /* reset the SONIC */
 392
 393         outw(CMDREG_RST, dev->base_addr + SONIC_CMDREG);
 394         udelay(10);
 395
 396         /* clear all spurious interrupts */
 397
 398         outw(inw(dev->base_addr + SONIC_ISREG),
 399              dev->base_addr + SONIC_ISREG);
 400
 401         /* set up the SONIC's bus interface - constant for this adapter -
 402            must be done while the SONIC is in reset */
 403
 404         outw(DCREG_USR1 | DCREG_USR0 | DCREG_WC1 | DCREG_DW32,
 405              dev->base_addr + SONIC_DCREG);
 406         outw(0, dev->base_addr + SONIC_DCREG2);
 407
 408         /* remove reset form the SONIC */
 409
 410         outw(0, dev->base_addr + SONIC_CMDREG);
 411         udelay(10);
 412
 413         /* data sheet requires URRA to be programmed before setting up the CAM contents */
 414
 415         outw(0, dev->base_addr + SONIC_URRA);
 416
 417         /* program the CAM entry 0 to the device address */
 418
 419         camcnt = 0;
 420         putcam(cams, &camcnt, dev->dev_addr);
 421
 422         /* start putting the multicast addresses into the CAM list.  Stop if
 423            it is full. */
 424
 425         for (mcptr = dev->mc_list; mcptr != NULL; mcptr = mcptr->next) {
 426                 putcam(cams, &camcnt, mcptr->dmi_addr);
 427                 if (camcnt == 16)
 428                         break;
 429         }
 430
 431         /* calculate CAM mask */
 432
 433         cammask = (1 << camcnt) - 1;
 434
 435         /* feed CDA into SONIC, initialize RCR value (always get broadcasts) */
 436
 437         IBMLANA_TOIO(dev->mem_start, cams, sizeof(camentry_t) * camcnt);
 438         IBMLANA_TOIO(dev->mem_start + (sizeof(camentry_t) * camcnt),
 439                      &cammask, sizeof(cammask));
 440
 441 #ifdef DEBUG
 442         printk("CAM setup:\n");
 443         dumpmem(dev, 0, sizeof(camentry_t) * camcnt + sizeof(cammask));
 444 #endif
 445
 446         outw(0, dev->base_addr + SONIC_CAMPTR);
 447         outw(camcnt, dev->base_addr + SONIC_CAMCNT);
 448         outw(CMDREG_LCAM, dev->base_addr + SONIC_CMDREG);
 449         if (!wait_timeout(dev, SONIC_CMDREG, CMDREG_LCAM, 0, 2)) {
 450                 printk
 451                     ("%s:SONIC did not respond on LCAM command - giving up.",
 452                      dev->name);
 453                 return;
 454         } else {
 455                 /* clear interrupt condition */
 456
 457                 outw(ISREG_LCD, dev->base_addr + SONIC_ISREG);
 458
 459 #ifdef DEBUG
 460                 printk("Loading CAM done, address pointers %04x:%04x\n",
 461                        inw(dev->base_addr + SONIC_URRA),
 462                        inw(dev->base_addr + SONIC_CAMPTR));
 463                 {
 464                         int z;
 465
 466                         printk("\n-->CAM: PTR %04x CNT %04x\n",
 467                                inw(dev->base_addr + SONIC_CAMPTR),
 468                                inw(dev->base_addr + SONIC_CAMCNT));
 469                         outw(CMDREG_RST, dev->base_addr + SONIC_CMDREG);
 470                         for (z = 0; z < camcnt; z++) {
 471                                 outw(z, dev->base_addr + SONIC_CAMEPTR);
 472                                 printk("Entry %d: %04x %04x %04x\n", z,
 473                                        inw(dev->base_addr +
 474                                            SONIC_CAMADDR0),
 475                                        inw(dev->base_addr +
 476                                            SONIC_CAMADDR1),
 477                                        inw(dev->base_addr +
 478                                            SONIC_CAMADDR2));
 479                         }
 480                         outw(0, dev->base_addr + SONIC_CMDREG);
 481                 }
 482 #endif
 483         }
 484
 485         rcrval = RCREG_BRD | RCREG_LB_NONE;
 486
 487         /* if still multicast addresses left or ALLMULTI is set, set the multicast
 488            enable bit */
 489
 490         if ((dev->flags & IFF_ALLMULTI) || (mcptr != NULL))
 491                 rcrval |= RCREG_AMC;
 492
 493         /* promiscous mode ? */
 494
 495         if (dev->flags & IFF_PROMISC)
 496                 rcrval |= RCREG_PRO;
 497
 498         /* program receive mode */
 499
 500         outw(rcrval, dev->base_addr + SONIC_RCREG);
 501 #ifdef DEBUG
 502         printk("\nRCRVAL: %04x\n", rcrval);
 503 #endif
 504
 505         /* set up descriptors in shared memory + feed them into SONIC registers */
 506
 507         InitDscrs(dev);
 508         if (!InitSONIC(dev))
 509                 return;
 510
 511         /* reset all pending interrupts */
 512
 513         outw(0xffff, dev->base_addr + SONIC_ISREG);
 514
 515         /* enable transmitter + receiver interrupts */
 516
 517         outw(CMDREG_RXEN, dev->base_addr + SONIC_CMDREG);
 518         outw(IMREG_PRXEN | IMREG_RBEEN | IMREG_PTXEN | IMREG_TXEREN,
 519              dev->base_addr + SONIC_IMREG);
 520
 521         /* turn on card interrupts */
 522
 523         outb(inb(dev->base_addr + BCMREG) | BCMREG_IEN,
 524              dev->base_addr + BCMREG);
 525
 526 #ifdef DEBUG
 527         printk("Register dump after initialization:\n");
 528         dumpregs(dev);
 529 #endif
 530 }
 531
 532 /* start transmission of a descriptor */
 533
 534 static void StartTx(struct IBMLANA_NETDEV *dev, int descr)
 535 {
 536         ibmlana_priv *priv = (ibmlana_priv *) dev->priv;
 537         int addr;
 538
 539         addr = priv->tdastart + (descr * sizeof(tda_t));
 540
 541         /* put descriptor address into SONIC */
 542
 543         outw(addr, dev->base_addr + SONIC_CTDA);
 544
 545         /* trigger transmitter */
 546
 547         priv->currtxdescr = descr;
 548         outw(CMDREG_TXP, dev->base_addr + SONIC_CMDREG);
 549 }
 550
 551 /* ------------------------------------------------------------------------
 552  * interrupt handler(s)
 553  * ------------------------------------------------------------------------ */
 554
 555 /* receive buffer area exhausted */
 556
 557 static void irqrbe_handler(struct IBMLANA_NETDEV *dev)
 558 {
 559         ibmlana_priv *priv = (ibmlana_priv *) dev->priv;
 560
 561         /* point the SONIC back to the RRA start */
 562
 563         outw(priv->rrastart, dev->base_addr + SONIC_RRP);
 564         outw(priv->rrastart, dev->base_addr + SONIC_RWP);
 565 }
 566
 567 /* receive interrupt */
 568
 569 static void irqrx_handler(struct IBMLANA_NETDEV *dev)
 570 {
 571         ibmlana_priv *priv = (ibmlana_priv *) dev->priv;
 572         rda_t rda;
 573         u32 rdaaddr, lrdaaddr;
 574
 575         /* loop until ... */
 576
 577         while (1) {
 578                 /* read descriptor that was next to be filled by SONIC */
 579
 580                 rdaaddr =
 581                     priv->rdastart + (priv->nextrxdescr * sizeof(rda_t));
 582                 lrdaaddr =
 583                     priv->rdastart + (priv->lastrxdescr * sizeof(rda_t));
 584                 IBMLANA_FROMIO(&rda, dev->mem_start + rdaaddr,
 585                                sizeof(rda_t));
 586
 587                 /* iron out upper word halves of fields we use - SONIC will duplicate
 588                    bits 0..15 to 16..31 */
 589
 590                 rda.status &= 0xffff;
 591                 rda.length &= 0xffff;
 592                 rda.startlo &= 0xffff;
 593
 594                 /* stop if the SONIC still owns it, i.e. there is no data for us */
 595
 596                 if (rda.inuse)
 597                         break;
 598
 599                 /* good packet? */
 600
 601                 else if (rda.status & RCREG_PRX) {
 602                         struct sk_buff *skb;
 603
 604                         /* fetch buffer */
 605
 606                         skb = dev_alloc_skb(rda.length + 2);
 607                         if (skb == NULL)
 608                                 priv->stat.rx_dropped++;
 609                         else {
 610                                 /* copy out data */
 611
 612                                 IBMLANA_FROMIO(skb_put(skb, rda.length),
 613                                                dev->mem_start +
 614                                                rda.startlo, rda.length);
 615
 616                                 /* set up skb fields */
 617
 618                                 skb->dev = dev;
 619                                 skb->protocol = eth_type_trans(skb, dev);
 620                                 skb->ip_summed = CHECKSUM_NONE;
 621
 622                                 /* bookkeeping */
 623
 624                                 dev->last_rx = jiffies;
 625                                 priv->stat.rx_packets++;
 626 #if (LINUX_VERSION_CODE >= 0x20119)     /* byte counters for kernel >= 2.1.25 */
 627                                 priv->stat.rx_bytes += rda.length;
 628 #endif
 629
 630                                 /* pass to the upper layers */
 631
 632                                 netif_rx(skb);
 633                         }
 634                 }
 635
 636                 /* otherwise check error status bits and increase statistics */
 637
 638                 else {
 639                         priv->stat.rx_errors++;
 640
 641                         if (rda.status & RCREG_FAER)
 642                                 priv->stat.rx_frame_errors++;
 643
 644                         if (rda.status & RCREG_CRCR)
 645                                 priv->stat.rx_crc_errors++;
 646                 }
 647
 648                 /* descriptor processed, will become new last descriptor in queue */
 649
 650                 rda.link = 1;
 651                 rda.inuse = 1;
 652                 IBMLANA_TOIO(dev->mem_start + rdaaddr, &rda,
 653                              sizeof(rda_t));
 654
 655                 /* set up link and EOL = 0 in currently last descriptor. Only write
 656                    the link field since the SONIC may currently already access the
 657                    other fields. */
 658
 659                 IBMLANA_TOIO(dev->mem_start + lrdaaddr + 20, &rdaaddr, 4);
 660
 661                 /* advance indices */
 662
 663                 priv->lastrxdescr = priv->nextrxdescr;
 664                 if ((++priv->nextrxdescr) >= priv->rxbufcnt)
 665                         priv->nextrxdescr = 0;
 666         }
 667 }
 668
 669 /* transmit interrupt */
 670
 671 static void irqtx_handler(struct IBMLANA_NETDEV *dev)
 672 {
 673         ibmlana_priv *priv = (ibmlana_priv *) dev->priv;
 674         tda_t tda;
 675
 676         /* fetch descriptor (we forgot the size ;-) */
 677
 678         IBMLANA_FROMIO(&tda,
 679                        dev->mem_start + priv->tdastart +
 680                        (priv->currtxdescr * sizeof(tda_t)), sizeof(tda_t));
 681
 682         /* update statistics */
 683
 684         priv->stat.tx_packets++;
 685 #if (LINUX_VERSION_CODE >= 0x020119)
 686         priv->stat.tx_bytes += tda.length;
 687 #endif
 688
 689         /* update our pointers */
 690
 691         priv->txused[priv->currtxdescr] = 0;
 692         priv->txusedcnt--;
 693
 694         /* if there are more descriptors present in RAM, start them */
 695
 696         if (priv->txusedcnt > 0)
 697                 StartTx(dev, (priv->currtxdescr + 1) % TXBUFCNT);
 698
 699         /* tell the upper layer we can go on transmitting */
 700
 701 #if LINUX_VERSION_CODE >= 0x02032a
 702         netif_wake_queue(dev);
 703 #else
 704         dev->tbusy = 0;
 705         mark_bh(NET_BH);
 706 #endif
 707 }
 708
 709 static void irqtxerr_handler(struct IBMLANA_NETDEV *dev)
 710 {
 711         ibmlana_priv *priv = (ibmlana_priv *) dev->priv;
 712         tda_t tda;
 713
 714         /* fetch descriptor to check status */
 715
 716         IBMLANA_FROMIO(&tda,
 717                        dev->mem_start + priv->tdastart +
 718                        (priv->currtxdescr * sizeof(tda_t)), sizeof(tda_t));
 719
 720         /* update statistics */
 721
 722         priv->stat.tx_errors++;
 723         if (tda.status & (TCREG_NCRS | TCREG_CRSL))
 724                 priv->stat.tx_carrier_errors++;
 725         if (tda.status & TCREG_EXC)
 726                 priv->stat.tx_aborted_errors++;
 727         if (tda.status & TCREG_OWC)
 728                 priv->stat.tx_window_errors++;
 729         if (tda.status & TCREG_FU)
 730                 priv->stat.tx_fifo_errors++;
 731
 732         /* update our pointers */
 733
 734         priv->txused[priv->currtxdescr] = 0;
 735         priv->txusedcnt--;
 736
 737         /* if there are more descriptors present in RAM, start them */
 738
 739         if (priv->txusedcnt > 0)
 740                 StartTx(dev, (priv->currtxdescr + 1) % TXBUFCNT);
 741
 742         /* tell the upper layer we can go on transmitting */
 743
 744 #if LINUX_VERSION_CODE >= 0x02032a
 745         netif_wake_queue(dev);
 746 #else
 747         dev->tbusy = 0;
 748         mark_bh(NET_BH);
 749 #endif
 750 }
 751
 752 /* general interrupt entry */
 753
 754 static void irq_handler(int irq, void *device, struct pt_regs *regs)
 755 {
 756         struct IBMLANA_NETDEV *dev = (struct IBMLANA_NETDEV *) device;
 757         u16 ival;
 758
 759         /* in case we're not meant... */
 760
 761         if (!(inb(dev->base_addr + BCMREG) & BCMREG_IPEND))
 762                 return;
 763
 764 #if (LINUX_VERSION_CODE >= 0x02032a)
 765 #if 0
 766         set_bit(LINK_STATE_RXSEM, &dev->state);
 767 #endif
 768 #else
 769         dev->interrupt = 1;
 770 #endif
 771
 772         /* loop through the interrupt bits until everything is clear */
 773
 774         while (1) {
 775                 ival = inw(dev->base_addr + SONIC_ISREG);
 776
 777                 if (ival & ISREG_RBE) {
 778                         irqrbe_handler(dev);
 779                         outw(ISREG_RBE, dev->base_addr + SONIC_ISREG);
 780                 }
 781
 782                 if (ival & ISREG_PKTRX) {
 783                         irqrx_handler(dev);
 784                         outw(ISREG_PKTRX, dev->base_addr + SONIC_ISREG);
 785                 }
 786
 787                 if (ival & ISREG_TXDN) {
 788                         irqtx_handler(dev);
 789                         outw(ISREG_TXDN, dev->base_addr + SONIC_ISREG);
 790                 }
 791
 792                 if (ival & ISREG_TXER) {
 793                         irqtxerr_handler(dev);
 794                         outw(ISREG_TXER, dev->base_addr + SONIC_ISREG);
 795                 }
 796
 797                 break;
 798         }
 799
 800 #if (LINUX_VERSION_CODE >= 0x02032a)
 801 #if 0
 802         clear_bit(LINK_STATE_RXSEM, &dev->state);
 803 #endif
 804 #else
 805         dev->interrupt = 0;
 806 #endif
 807 }
 808
 809 /* ------------------------------------------------------------------------
 810  * driver methods
 811  * ------------------------------------------------------------------------ */
 812
 813 /* MCA info */
 814
 815 static int ibmlana_getinfo(char *buf, int slot, void *d)
 816 {
 817         int len = 0, i;
 818         struct IBMLANA_NETDEV *dev = (struct IBMLANA_NETDEV *) d;
 819         ibmlana_priv *priv;
 820
 821         /* can't say anything about an uninitialized device... */
 822
 823         if (dev == NULL)
 824                 return len;
 825         if (dev->priv == NULL)
 826                 return len;
 827         priv = (ibmlana_priv *) dev->priv;
 828
 829         /* print info */
 830
 831         len += sprintf(buf + len, "IRQ: %d\n", priv->realirq);
 832         len += sprintf(buf + len, "I/O: %#lx\n", dev->base_addr);
 833         len += sprintf(buf + len, "Memory: %#lx-%#lx\n", dev->mem_start,
 834                        dev->mem_end - 1);
 835         len +=
 836             sprintf(buf + len, "Transceiver: %s\n",
 837                     MediaNames[priv->medium]);
 838         len += sprintf(buf + len, "Device: %s\n", dev->name);
 839         len += sprintf(buf + len, "MAC address:");
 840         for (i = 0; i < 6; i++)
 841                 len += sprintf(buf + len, " %02x", dev->dev_addr[i]);
 842         buf[len++] = '\n';
 843         buf[len] = 0;
 844
 845         return len;
 846 }
 847
 848 /* open driver.  Means also initialization and start of LANCE */
 849
 850 static int ibmlana_open(struct IBMLANA_NETDEV *dev)
 851 {
 852         int result;
 853         ibmlana_priv *priv = (ibmlana_priv *) dev->priv;
 854
 855         /* register resources - only necessary for IRQ */
 856
 857         result =
 858             request_irq(priv->realirq, irq_handler,
 859                         SA_SHIRQ | SA_SAMPLE_RANDOM, dev->name, dev);
 860         if (result != 0) {
 861                 printk("%s: failed to register irq %d\n", dev->name,
 862                        dev->irq);
 863                 return result;
 864         }
 865         dev->irq = priv->realirq;
 866
 867         /* set up the card and SONIC */
 868
 869         InitBoard(dev);
 870
 871         /* initialize operational flags */
 872
 873 #if (LINUX_VERSION_CODE >= 0x02032a)
 874         netif_start_queue(dev);
 875 #else
 876         dev->interrupt = 0;
 877         dev->tbusy = 0;
 878         dev->start = 1;
 879         MOD_INC_USE_COUNT;
 880 #endif
 881
 882         return 0;
 883 }
 884
 885 /* close driver.  Shut down board and free allocated resources */
 886
 887 static int ibmlana_close(struct IBMLANA_NETDEV *dev)
 888 {
 889         /* turn off board */
 890
 891         /* release resources */
 892         if (dev->irq != 0)
 893                 free_irq(dev->irq, dev);
 894         dev->irq = 0;
 895
 896 #if (LINUX_VERSION_CODE < 0x02032a)
 897         MOD_DEC_USE_COUNT;
 898 #endif
 899
 900         return 0;
 901 }
 902
 903 /* transmit a block. */
 904
 905 static int ibmlana_tx(struct sk_buff *skb, struct IBMLANA_NETDEV *dev)
 906 {
 907         ibmlana_priv *priv = (ibmlana_priv *) dev->priv;
 908         int retval = 0, tmplen, addr;
 909         unsigned long flags;
 910         tda_t tda;
 911         int baddr;
 912
 913         /* if we get called with a NULL descriptor, the Ethernet layer thinks
 914            our card is stuck an we should reset it.  We'll do this completely: */
 915
 916         if (skb == NULL) {
 917                 printk("%s: Resetting SONIC\n", dev->name);
 918                 StopSONIC(dev);
 919                 InitBoard(dev);
 920                 return 0;       /* don't try to free the block here ;-) */
 921         }
 922
 923         /* find out if there are free slots for a frame to transmit. If not,
 924            the upper layer is in deep desperation and we simply ignore the frame. */
 925
 926         if (priv->txusedcnt >= TXBUFCNT) {
 927                 retval = -EIO;
 928                 priv->stat.tx_dropped++;
 929                 goto tx_done;
 930         }
 931
 932         /* copy the frame data into the next free transmit buffer - fillup missing */
 933
 934         tmplen = skb->len;
 935         if (tmplen < 60)
 936                 tmplen = 60;
 937         baddr = priv->txbufstart + (priv->nexttxdescr * PKTSIZE);
 938         IBMLANA_TOIO(dev->mem_start + baddr, skb->data, skb->len);
 939
 940         /* copy filler into RAM - in case we're filling up...
 941            we're filling a bit more than necessary, but that doesn't harm
 942            since the buffer is far larger...
 943            Sorry Linus for the filler string but I couldn't resist ;-) */
 944
 945         if (tmplen > skb->len) {
 946                 char *fill = "NetBSD is a nice OS too! ";
 947                 unsigned int destoffs = skb->len, l = strlen(fill);
 948
 949                 while (destoffs < tmplen) {
 950                         IBMLANA_TOIO(dev->mem_start + baddr + destoffs,
 951                                      fill, l);
 952                         destoffs += l;
 953                 }
 954         }
 955
 956         /* set up the new frame descriptor */
 957
 958         addr = priv->tdastart + (priv->nexttxdescr * sizeof(tda_t));
 959         IBMLANA_FROMIO(&tda, dev->mem_start + addr, sizeof(tda_t));
 960         tda.length = tda.fraglength = tmplen;
 961         IBMLANA_TOIO(dev->mem_start + addr, &tda, sizeof(tda_t));
 962
 963         /* if there were no active descriptors, trigger the SONIC */
 964
 965         save_flags(flags);
 966         cli();
 967
 968         priv->txusedcnt++;
 969         priv->txused[priv->nexttxdescr] = 1;
 970
 971         /* are all transmission slots used up ? */
 972
 973         if (priv->txusedcnt >= TXBUFCNT)
 974 #if (LINUX_VERSION_CODE >= 0x02032a)
 975                 netif_stop_queue(dev);
 976 #else
 977                 dev->tbusy = 1;
 978 #endif
 979
 980         if (priv->txusedcnt == 1)
 981                 StartTx(dev, priv->nexttxdescr);
 982         priv->nexttxdescr = (priv->nexttxdescr + 1) % TXBUFCNT;
 983
 984         restore_flags(flags);
 985
 986       tx_done:
 987
 988         /* When did that change exactly ? */
 989
 990 #if (LINUX_VERSION_CODE >= 0x20200)
 991         dev_kfree_skb(skb);
 992 #else
 993         dev_kfree_skb(skb, FREE_WRITE);
 994 #endif
 995         return retval;
 996 }
 997
 998 /* return pointer to Ethernet statistics */
 999
1000 static struct net_device_stats *ibmlana_stats(struct IBMLANA_NETDEV *dev)
1001 {
1002         ibmlana_priv *priv = (ibmlana_priv *) dev->priv;
1003
1004         return &(priv->stat);
1005 }
1006
1007 /* we don't support runtime reconfiguration, since am MCA card can
1008    be unambigously identified by its POS registers. */
1009
1010 static int ibmlana_config(struct IBMLANA_NETDEV *dev, struct ifmap *map)
1011 {
1012         return 0;
1013 }
1014
1015 /* switch receiver mode. */
1016
1017 static void ibmlana_set_multicast_list(struct IBMLANA_NETDEV *dev)
1018 {
1019         /* first stop the SONIC... */
1020
1021         StopSONIC(dev);
1022
1023         /* ...then reinit it with the new flags */
1024
1025         InitBoard(dev);
1026 }
1027
1028 /* ------------------------------------------------------------------------
1029  * hardware check
1030  * ------------------------------------------------------------------------ */
1031
1032 static int startslot;           /* counts through slots when probing multiple devices */
1033
1034 int ibmlana_probe(struct IBMLANA_NETDEV *dev)
1035 {
1036         int force_detect = 0;
1037         int slot, z;
1038         int base = 0, irq = 0, iobase = 0, memlen = 0;
1039         ibmlana_priv *priv;
1040         ibmlana_medium medium;
1041
1042 #if (LINUX_VERSION_CODE >= 0x02032a)
1043         SET_MODULE_OWNER(dev);
1044 #endif
1045
1046         /* can't work without an MCA bus ;-) */
1047
1048         if (MCA_bus == 0)
1049                 return -ENODEV;
1050
1051         /* start address of 1 --> forced detection */
1052
1053         if (dev->mem_start == 1)
1054                 force_detect = 1;
1055
1056         /* search through slots */
1057
1058         if (dev != NULL) {
1059                 base = dev->mem_start;
1060                 irq = dev->irq;
1061         }
1062         slot = mca_find_adapter(IBM_LANA_ID, startslot);
1063
1064         while (slot != -1) {
1065                 /* deduce card addresses */
1066
1067                 getaddrs(slot, &base, &memlen, &iobase, &irq, &medium);
1068
1069 #if (LINUX_VERSION_CODE >= 0x20300)
1070                 /* slot already in use ? */
1071
1072                 if (mca_is_adapter_used(slot)) {
1073                         slot = mca_find_adapter(IBM_LANA_ID, slot + 1);
1074                         continue;
1075                 }
1076 #endif
1077
1078                 /* were we looking for something different ? */
1079
1080                 if ((dev->irq != 0) || (dev->mem_start != 0)) {
1081                         if ((dev->irq != 0) && (dev->irq != irq)) {
1082                                 slot =
1083                                     mca_find_adapter(IBM_LANA_ID,
1084                                                      slot + 1);
1085                                 continue;
1086                         }
1087                         if ((dev->mem_start != 0)
1088                             && (dev->mem_start != base)) {
1089                                 slot =
1090                                     mca_find_adapter(IBM_LANA_ID,
1091                                                      slot + 1);
1092                                 continue;
1093                         }
1094                 }
1095
1096                 /* found something that matches */
1097
1098                 break;
1099         }
1100
1101         /* nothing found ? */
1102
1103         if (slot == -1)
1104                 return ((base != 0) || (irq != 0)) ? -ENXIO : -ENODEV;
1105
1106         /* announce success */
1107         printk("%s: IBM LAN Adapter/A found in slot %d\n", dev->name,
1108                slot + 1);
1109
1110         /* try to obtain I/O range */
1111         if (!request_region(iobase, IBM_LANA_IORANGE, dev->name)) {
1112                 printk("%s: cannot allocate I/O range at %#x!\n", dev->name, iobase);
1113                 startslot = slot + 1;
1114                 return -EBUSY;
1115         }
1116
1117         /* make procfs entries */
1118
1119         mca_set_adapter_name(slot, "IBM LAN Adapter/A");
1120         mca_set_adapter_procfn(slot, (MCA_ProcFn) ibmlana_getinfo, dev);
1121
1122 #if (LINUX_VERSION_CODE >= 0x20200)
1123         mca_mark_as_used(slot);
1124 #endif
1125
1126         /* allocate structure */
1127
1128         priv = dev->priv =
1129             (ibmlana_priv *) kmalloc(sizeof(ibmlana_priv), GFP_KERNEL);
1130         if (!priv) {
1131                 release_region(iobase, IBM_LANA_IORANGE);
1132                 return -ENOMEM;
1133         }
1134         priv->slot = slot;
1135         priv->realirq = irq;
1136         priv->medium = medium;
1137         memset(&(priv->stat), 0, sizeof(struct net_device_stats));
1138
1139         /* set base + irq for this device (irq not allocated so far) */
1140
1141         dev->irq = 0;
1142         dev->mem_start = base;
1143         dev->mem_end = base + memlen;
1144         dev->base_addr = iobase;
1145
1146         /* set methods */
1147
1148         dev->open = ibmlana_open;
1149         dev->stop = ibmlana_close;
1150         dev->set_config = ibmlana_config;
1151         dev->hard_start_xmit = ibmlana_tx;
1152         dev->do_ioctl = NULL;
1153         dev->get_stats = ibmlana_stats;
1154         dev->set_multicast_list = ibmlana_set_multicast_list;
1155         dev->flags |= IFF_MULTICAST;
1156
1157         /* generic setup */
1158
1159         ether_setup(dev);
1160
1161         /* copy out MAC address */
1162
1163         for (z = 0; z < sizeof(dev->dev_addr); z++)
1164                 dev->dev_addr[z] = inb(dev->base_addr + MACADDRPROM + z);
1165
1166         /* print config */
1167
1168         printk("%s: IRQ %d, I/O %#lx, memory %#lx-%#lx, "
1169                "MAC address %02x:%02x:%02x:%02x:%02x:%02x.\n",
1170                dev->name, priv->realirq, dev->base_addr,
1171                dev->mem_start, dev->mem_end - 1,
1172                dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
1173                dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5]);
1174         printk("%s: %s medium\n", dev->name, MediaNames[priv->medium]);
1175
1176         /* reset board */
1177
1178         ResetBoard(dev);
1179
1180         /* next probe will start at next slot */
1181
1182         startslot = slot + 1;
1183
1184         return 0;
1185 }
1186
1187 /* ------------------------------------------------------------------------
1188  * modularization support
1189  * ------------------------------------------------------------------------ */
1190
1191 #ifdef MODULE
1192
1193 #define DEVMAX 5
1194
1195 static struct IBMLANA_NETDEV moddevs[DEVMAX];
1196 static int irq;
1197 static int io;
1198 MODULE_PARM(irq, "i");
1199 MODULE_PARM(io, "i");
1200 MODULE_PARM_DESC(irq, "IBM LAN/A IRQ number");
1201 MODULE_PARM_DESC(io, "IBM LAN/A I/O base address");
1202 MODULE_LICENSE("GPL");
1203
1204 int init_module(void)
1205 {
1206         int z, res;
1207
1208         startslot = 0;
1209         for (z = 0; z < DEVMAX; z++) {
1210                 moddevs[z].init = ibmlana_probe;
1211                 moddevs[z].irq = irq;
1212                 moddevs[z].base_addr = io;
1213                 res = register_netdev(moddevs + z);
1214                 if (res != 0)
1215                         return (z > 0) ? 0 : -EIO;
1216         }
1217
1218         return 0;
1219 }
1220
1221 void cleanup_module(void)
1222 {
1223         struct IBMLANA_NETDEV *dev;
1224         ibmlana_priv *priv;
1225         int z;
1226
1227         if (MOD_IN_USE) {
1228                 printk("cannot unload, module in use\n");
1229                 return;
1230         }
1231
1232         for (z = 0; z < DEVMAX; z++) {
1233                 dev = moddevs + z;
1234                 if (dev->priv != NULL) {
1235                         priv = (ibmlana_priv *) dev->priv;
1236                         /*DeinitBoard(dev); */
1237                         if (dev->irq != 0)
1238                                 free_irq(dev->irq, dev);
1239                         dev->irq = 0;
1240                         release_region(dev->base_addr, IBM_LANA_IORANGE);
1241                         unregister_netdev(dev);
1242 #if (LINUX_VERSION_CODE >= 0x20200)
1243                         mca_mark_as_unused(priv->slot);
1244 #endif
1245                         mca_set_adapter_name(priv->slot, "");
1246                         mca_set_adapter_procfn(priv->slot, NULL, NULL);
1247                         kfree(dev->priv);
1248                         dev->priv = NULL;
1249                 }
1250         }
1251 }
1252 #endif                          /* MODULE */