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