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