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