1/* 2 * ni6510 (am7990 'lance' chip) driver for Linux-net-3 3 * BETAcode v0.71 (96/09/29) for 2.0.0 (or later) 4 * copyrights (c) 1994,1995,1996 by M.Hipp 5 * 6 * This driver can handle the old ni6510 board and the newer ni6510 7 * EtherBlaster. (probably it also works with every full NE2100 8 * compatible card) 9 * 10 * driver probes: io: 0x360,0x300,0x320,0x340 / dma: 3,5,6,7 11 * 12 * This is an extension to the Linux operating system, and is covered by the 13 * same GNU General Public License that covers the Linux-kernel. 14 * 15 * comments/bugs/suggestions can be sent to: 16 * Michael Hipp 17 * email: hippm@informatik.uni-tuebingen.de 18 * 19 * sources: 20 * some things are from the 'ni6510-packet-driver for dos by Russ Nelson' 21 * and from the original drivers by D.Becker 22 * 23 * known problems: 24 * - on some PCI boards (including my own) the card/board/ISA-bridge has 25 * problems with bus master DMA. This results in lotsa overruns. 26 * It may help to '#define RCV_PARANOIA_CHECK' or try to #undef 27 * the XMT and RCV_VIA_SKB option .. this reduces driver performance. 28 * Or just play with your BIOS options to optimize ISA-DMA access. 29 * Maybe you also wanna play with the LOW_PERFORAMCE and MID_PERFORMANCE 30 * defines -> please report me your experience then 31 * - Harald reported for ASUS SP3G mainboards, that you should use 32 * the 'optimal settings' from the user's manual on page 3-12! 33 * 34 * credits: 35 * thanx to Jason Sullivan for sending me a ni6510 card! 36 * lot of debug runs with ASUS SP3G Boards (Intel Saturn) by Harald Koenig 37 * 38 * simple performance test: (486DX-33/Ni6510-EB receives from 486DX4-100/Ni6510-EB) 39 * average: FTP -> 8384421 bytes received in 8.5 seconds 40 * (no RCV_VIA_SKB,no XMT_VIA_SKB,PARANOIA_CHECK,4 XMIT BUFS, 8 RCV_BUFFS) 41 * peak: FTP -> 8384421 bytes received in 7.5 seconds 42 * (RCV_VIA_SKB,XMT_VIA_SKB,no PARANOIA_CHECK,1(!) XMIT BUF, 16 RCV BUFFS) 43 */ 44 45/* 46 * 99.Jun.8: added support for /proc/net/dev byte count for xosview (HK) 47 * 96.Sept.29: virt_to_bus stuff added for new memory modell 48 * 96.April.29: Added Harald Koenig's Patches (MH) 49 * 96.April.13: enhanced error handling .. more tests (MH) 50 * 96.April.5/6: a lot of performance tests. Got it stable now (hopefully) (MH) 51 * 96.April.1: (no joke ;) .. added EtherBlaster and Module support (MH) 52 * 96.Feb.19: fixed a few bugs .. cleanups .. tested for 1.3.66 (MH) 53 * hopefully no more 16MB limit 54 * 55 * 95.Nov.18: multicast tweaked (AC). 56 * 57 * 94.Aug.22: changes in xmit_intr (ack more than one xmitted-packet), ni65_send_packet (p->lock) (MH) 58 * 59 * 94.July.16: fixed bugs in recv_skb and skb-alloc stuff (MH) 60 */ 61 62#include <linux/kernel.h> 63#include <linux/string.h> 64#include <linux/errno.h> 65#include <linux/ioport.h> 66#include <linux/slab.h> 67#include <linux/interrupt.h> 68#include <linux/delay.h> 69#include <linux/init.h> 70#include <linux/netdevice.h> 71#include <linux/etherdevice.h> 72#include <linux/skbuff.h> 73#include <linux/module.h> 74#include <linux/bitops.h> 75 76#include <asm/io.h> 77#include <asm/dma.h> 78 79#include "ni65.h" 80 81/* 82 * the current setting allows an acceptable performance 83 * for 'RCV_PARANOIA_CHECK' read the 'known problems' part in 84 * the header of this file 85 * 'invert' the defines for max. performance. This may cause DMA problems 86 * on some boards (e.g on my ASUS SP3G) 87 */ 88#undef XMT_VIA_SKB 89#undef RCV_VIA_SKB 90#define RCV_PARANOIA_CHECK 91 92#define MID_PERFORMANCE 93 94#if defined(LOW_PERFORMANCE) 95 static int isa0=7,isa1=7,csr80=0x0c10; 96#elif defined(MID_PERFORMANCE) 97 static int isa0=5,isa1=5,csr80=0x2810; 98#else /* high performance */ 99 static int isa0=4,isa1=4,csr80=0x0017; 100#endif 101 102/* 103 * a few card/vendor specific defines 104 */ 105#define NI65_ID0 0x00 106#define NI65_ID1 0x55 107#define NI65_EB_ID0 0x52 108#define NI65_EB_ID1 0x44 109#define NE2100_ID0 0x57 110#define NE2100_ID1 0x57 111 112#define PORT p->cmdr_addr 113 114/* 115 * buffer configuration 116 */ 117#define RMDNUM 16 118#define RMDNUMMASK 0x80000000 119 120#define TMDNUM 4 121#define TMDNUMMASK 0x40000000 /* log2(TMDNUM)<<29 */ 122 123/* slightly oversized */ 124#define R_BUF_SIZE 1544 125#define T_BUF_SIZE 1544 126 127/* 128 * lance register defines 129 */ 130#define L_DATAREG 0x00 131#define L_ADDRREG 0x02 132#define L_RESET 0x04 133#define L_CONFIG 0x05 134#define L_BUSIF 0x06 135 136/* 137 * to access the lance/am7990-regs, you have to write 138 * reg-number into L_ADDRREG, then you can access it using L_DATAREG 139 */ 140#define CSR0 0x00 141#define CSR1 0x01 142#define CSR2 0x02 143#define CSR3 0x03 144 145#define INIT_RING_BEFORE_START 0x1 146#define FULL_RESET_ON_ERROR 0x2 147 148#define writereg(val,reg) {outw(reg,PORT+L_ADDRREG);outw(val,PORT+L_DATAREG);} 149#define readreg(reg) (outw(reg,PORT+L_ADDRREG),inw(PORT+L_DATAREG)) 150#define writedatareg(val) { writereg(val,CSR0); } 151 152static unsigned char ni_vendor[] = { 0x02,0x07,0x01 }; 153 154static struct card { 155 unsigned char id0,id1; 156 short id_offset; 157 short total_size; 158 short cmd_offset; 159 short addr_offset; 160 unsigned char *vendor_id; 161 char *cardname; 162 unsigned long config; 163} cards[] = { 164 { 165 .id0 = NI65_ID0, 166 .id1 = NI65_ID1, 167 .id_offset = 0x0e, 168 .total_size = 0x10, 169 .cmd_offset = 0x0, 170 .addr_offset = 0x8, 171 .vendor_id = ni_vendor, 172 .cardname = "ni6510", 173 .config = 0x1, 174 }, 175 { 176 .id0 = NI65_EB_ID0, 177 .id1 = NI65_EB_ID1, 178 .id_offset = 0x0e, 179 .total_size = 0x18, 180 .cmd_offset = 0x10, 181 .addr_offset = 0x0, 182 .vendor_id = ni_vendor, 183 .cardname = "ni6510 EtherBlaster", 184 .config = 0x2, 185 }, 186 { 187 .id0 = NE2100_ID0, 188 .id1 = NE2100_ID1, 189 .id_offset = 0x0e, 190 .total_size = 0x18, 191 .cmd_offset = 0x10, 192 .addr_offset = 0x0, 193 .vendor_id = NULL, 194 .cardname = "generic NE2100", 195 .config = 0x0, 196 }, 197}; 198#define NUM_CARDS 3 199 200struct priv 201{ 202 struct rmd rmdhead[RMDNUM]; 203 struct tmd tmdhead[TMDNUM]; 204 struct init_block ib; 205 int rmdnum; 206 int tmdnum,tmdlast; 207#ifdef RCV_VIA_SKB 208 struct sk_buff *recv_skb[RMDNUM]; 209#else 210 void *recvbounce[RMDNUM]; 211#endif 212#ifdef XMT_VIA_SKB 213 struct sk_buff *tmd_skb[TMDNUM]; 214#endif 215 void *tmdbounce[TMDNUM]; 216 int tmdbouncenum; 217 int lock,xmit_queued; 218 219 void *self; 220 int cmdr_addr; 221 int cardno; 222 int features; 223 spinlock_t ring_lock; 224}; 225 226static int ni65_probe1(struct net_device *dev,int); 227static irqreturn_t ni65_interrupt(int irq, void * dev_id); 228static void ni65_recv_intr(struct net_device *dev,int); 229static void ni65_xmit_intr(struct net_device *dev,int); 230static int ni65_open(struct net_device *dev); 231static int ni65_lance_reinit(struct net_device *dev); 232static void ni65_init_lance(struct priv *p,unsigned char*,int,int); 233static netdev_tx_t ni65_send_packet(struct sk_buff *skb, 234 struct net_device *dev); 235static void ni65_timeout(struct net_device *dev); 236static int ni65_close(struct net_device *dev); 237static int ni65_alloc_buffer(struct net_device *dev); 238static void ni65_free_buffer(struct priv *p); 239static void set_multicast_list(struct net_device *dev); 240 241static int irqtab[] __initdata = { 9,12,15,5 }; /* irq config-translate */ 242static int dmatab[] __initdata = { 0,3,5,6,7 }; /* dma config-translate and autodetect */ 243 244static int debuglevel = 1; 245 246/* 247 * set 'performance' registers .. we must STOP lance for that 248 */ 249static void ni65_set_performance(struct priv *p) 250{ 251 writereg(CSR0_STOP | CSR0_CLRALL,CSR0); /* STOP */ 252 253 if( !(cards[p->cardno].config & 0x02) ) 254 return; 255 256 outw(80,PORT+L_ADDRREG); 257 if(inw(PORT+L_ADDRREG) != 80) 258 return; 259 260 writereg( (csr80 & 0x3fff) ,80); /* FIFO watermarks */ 261 outw(0,PORT+L_ADDRREG); 262 outw((short)isa0,PORT+L_BUSIF); /* write ISA 0: DMA_R : isa0 * 50ns */ 263 outw(1,PORT+L_ADDRREG); 264 outw((short)isa1,PORT+L_BUSIF); /* write ISA 1: DMA_W : isa1 * 50ns */ 265 266 outw(CSR0,PORT+L_ADDRREG); /* switch back to CSR0 */ 267} 268 269/* 270 * open interface (up) 271 */ 272static int ni65_open(struct net_device *dev) 273{ 274 struct priv *p = dev->ml_priv; 275 int irqval = request_irq(dev->irq, ni65_interrupt,0, 276 cards[p->cardno].cardname,dev); 277 if (irqval) { 278 printk(KERN_ERR "%s: unable to get IRQ %d (irqval=%d).\n", 279 dev->name,dev->irq, irqval); 280 return -EAGAIN; 281 } 282 283 if(ni65_lance_reinit(dev)) 284 { 285 netif_start_queue(dev); 286 return 0; 287 } 288 else 289 { 290 free_irq(dev->irq,dev); 291 return -EAGAIN; 292 } 293} 294 295/* 296 * close interface (down) 297 */ 298static int ni65_close(struct net_device *dev) 299{ 300 struct priv *p = dev->ml_priv; 301 302 netif_stop_queue(dev); 303 304 outw(inw(PORT+L_RESET),PORT+L_RESET); /* that's the hard way */ 305 306#ifdef XMT_VIA_SKB 307 { 308 int i; 309 for(i=0;i<TMDNUM;i++) 310 { 311 if(p->tmd_skb[i]) { 312 dev_kfree_skb(p->tmd_skb[i]); 313 p->tmd_skb[i] = NULL; 314 } 315 } 316 } 317#endif 318 free_irq(dev->irq,dev); 319 return 0; 320} 321 322static void cleanup_card(struct net_device *dev) 323{ 324 struct priv *p = dev->ml_priv; 325 disable_dma(dev->dma); 326 free_dma(dev->dma); 327 release_region(dev->base_addr, cards[p->cardno].total_size); 328 ni65_free_buffer(p); 329} 330 331/* set: io,irq,dma or set it when calling insmod */ 332static int irq; 333static int io; 334static int dma; 335 336/* 337 * Probe The Card (not the lance-chip) 338 */ 339struct net_device * __init ni65_probe(int unit) 340{ 341 struct net_device *dev = alloc_etherdev(0); 342 static int ports[] = {0x360,0x300,0x320,0x340, 0}; 343 int *port; 344 int err = 0; 345 346 if (!dev) 347 return ERR_PTR(-ENOMEM); 348 349 if (unit >= 0) { 350 sprintf(dev->name, "eth%d", unit); 351 netdev_boot_setup_check(dev); 352 irq = dev->irq; 353 dma = dev->dma; 354 } else { 355 dev->base_addr = io; 356 } 357 358 if (dev->base_addr > 0x1ff) { /* Check a single specified location. */ 359 err = ni65_probe1(dev, dev->base_addr); 360 } else if (dev->base_addr > 0) { /* Don't probe at all. */ 361 err = -ENXIO; 362 } else { 363 for (port = ports; *port && ni65_probe1(dev, *port); port++) 364 ; 365 if (!*port) 366 err = -ENODEV; 367 } 368 if (err) 369 goto out; 370 371 err = register_netdev(dev); 372 if (err) 373 goto out1; 374 return dev; 375out1: 376 cleanup_card(dev); 377out: 378 free_netdev(dev); 379 return ERR_PTR(err); 380} 381 382static const struct net_device_ops ni65_netdev_ops = { 383 .ndo_open = ni65_open, 384 .ndo_stop = ni65_close, 385 .ndo_start_xmit = ni65_send_packet, 386 .ndo_tx_timeout = ni65_timeout, 387 .ndo_set_multicast_list = set_multicast_list, 388 .ndo_change_mtu = eth_change_mtu, 389 .ndo_set_mac_address = eth_mac_addr, 390 .ndo_validate_addr = eth_validate_addr, 391}; 392 393/* 394 * this is the real card probe .. 395 */ 396static int __init ni65_probe1(struct net_device *dev,int ioaddr) 397{ 398 int i,j; 399 struct priv *p; 400 unsigned long flags; 401 402 dev->irq = irq; 403 dev->dma = dma; 404 405 for(i=0;i<NUM_CARDS;i++) { 406 if(!request_region(ioaddr, cards[i].total_size, cards[i].cardname)) 407 continue; 408 if(cards[i].id_offset >= 0) { 409 if(inb(ioaddr+cards[i].id_offset+0) != cards[i].id0 || 410 inb(ioaddr+cards[i].id_offset+1) != cards[i].id1) { 411 release_region(ioaddr, cards[i].total_size); 412 continue; 413 } 414 } 415 if(cards[i].vendor_id) { 416 for(j=0;j<3;j++) 417 if(inb(ioaddr+cards[i].addr_offset+j) != cards[i].vendor_id[j]) { 418 release_region(ioaddr, cards[i].total_size); 419 continue; 420 } 421 } 422 break; 423 } 424 if(i == NUM_CARDS) 425 return -ENODEV; 426 427 for(j=0;j<6;j++) 428 dev->dev_addr[j] = inb(ioaddr+cards[i].addr_offset+j); 429 430 if( (j=ni65_alloc_buffer(dev)) < 0) { 431 release_region(ioaddr, cards[i].total_size); 432 return j; 433 } 434 p = dev->ml_priv; 435 p->cmdr_addr = ioaddr + cards[i].cmd_offset; 436 p->cardno = i; 437 spin_lock_init(&p->ring_lock); 438 439 printk(KERN_INFO "%s: %s found at %#3x, ", dev->name, cards[p->cardno].cardname , ioaddr); 440 441 outw(inw(PORT+L_RESET),PORT+L_RESET); /* first: reset the card */ 442 if( (j=readreg(CSR0)) != 0x4) { 443 printk("failed.\n"); 444 printk(KERN_ERR "%s: Can't RESET card: %04x\n", dev->name, j); 445 ni65_free_buffer(p); 446 release_region(ioaddr, cards[p->cardno].total_size); 447 return -EAGAIN; 448 } 449 450 outw(88,PORT+L_ADDRREG); 451 if(inw(PORT+L_ADDRREG) == 88) { 452 unsigned long v; 453 v = inw(PORT+L_DATAREG); 454 v <<= 16; 455 outw(89,PORT+L_ADDRREG); 456 v |= inw(PORT+L_DATAREG); 457 printk("Version %#08lx, ",v); 458 p->features = INIT_RING_BEFORE_START; 459 } 460 else { 461 printk("ancient LANCE, "); 462 p->features = 0x0; 463 } 464 465 if(test_bit(0,&cards[i].config)) { 466 dev->irq = irqtab[(inw(ioaddr+L_CONFIG)>>2)&3]; 467 dev->dma = dmatab[inw(ioaddr+L_CONFIG)&3]; 468 printk("IRQ %d (from card), DMA %d (from card).\n",dev->irq,dev->dma); 469 } 470 else { 471 if(dev->dma == 0) { 472 /* 'stuck test' from lance.c */ 473 unsigned long dma_channels = 474 ((inb(DMA1_STAT_REG) >> 4) & 0x0f) 475 | (inb(DMA2_STAT_REG) & 0xf0); 476 for(i=1;i<5;i++) { 477 int dma = dmatab[i]; 478 if(test_bit(dma,&dma_channels) || request_dma(dma,"ni6510")) 479 continue; 480 481 flags=claim_dma_lock(); 482 disable_dma(dma); 483 set_dma_mode(dma,DMA_MODE_CASCADE); 484 enable_dma(dma); 485 release_dma_lock(flags); 486 487 ni65_init_lance(p,dev->dev_addr,0,0); /* trigger memory access */ 488 489 flags=claim_dma_lock(); 490 disable_dma(dma); 491 free_dma(dma); 492 release_dma_lock(flags); 493 494 if(readreg(CSR0) & CSR0_IDON) 495 break; 496 } 497 if(i == 5) { 498 printk("failed.\n"); 499 printk(KERN_ERR "%s: Can't detect DMA channel!\n", dev->name); 500 ni65_free_buffer(p); 501 release_region(ioaddr, cards[p->cardno].total_size); 502 return -EAGAIN; 503 } 504 dev->dma = dmatab[i]; 505 printk("DMA %d (autodetected), ",dev->dma); 506 } 507 else 508 printk("DMA %d (assigned), ",dev->dma); 509 510 if(dev->irq < 2) 511 { 512 unsigned long irq_mask; 513 514 ni65_init_lance(p,dev->dev_addr,0,0); 515 irq_mask = probe_irq_on(); 516 writereg(CSR0_INIT|CSR0_INEA,CSR0); /* trigger interrupt */ 517 msleep(20); 518 dev->irq = probe_irq_off(irq_mask); 519 if(!dev->irq) 520 { 521 printk("Failed to detect IRQ line!\n"); 522 ni65_free_buffer(p); 523 release_region(ioaddr, cards[p->cardno].total_size); 524 return -EAGAIN; 525 } 526 printk("IRQ %d (autodetected).\n",dev->irq); 527 } 528 else 529 printk("IRQ %d (assigned).\n",dev->irq); 530 } 531 532 if(request_dma(dev->dma, cards[p->cardno].cardname ) != 0) 533 { 534 printk(KERN_ERR "%s: Can't request dma-channel %d\n",dev->name,(int) dev->dma); 535 ni65_free_buffer(p); 536 release_region(ioaddr, cards[p->cardno].total_size); 537 return -EAGAIN; 538 } 539 540 dev->base_addr = ioaddr; 541 dev->netdev_ops = &ni65_netdev_ops; 542 dev->watchdog_timeo = HZ/2; 543 544 return 0; /* everything is OK */ 545} 546 547/* 548 * set lance register and trigger init 549 */ 550static void ni65_init_lance(struct priv *p,unsigned char *daddr,int filter,int mode) 551{ 552 int i; 553 u32 pib; 554 555 writereg(CSR0_CLRALL|CSR0_STOP,CSR0); 556 557 for(i=0;i<6;i++) 558 p->ib.eaddr[i] = daddr[i]; 559 560 for(i=0;i<8;i++) 561 p->ib.filter[i] = filter; 562 p->ib.mode = mode; 563 564 p->ib.trp = (u32) isa_virt_to_bus(p->tmdhead) | TMDNUMMASK; 565 p->ib.rrp = (u32) isa_virt_to_bus(p->rmdhead) | RMDNUMMASK; 566 writereg(0,CSR3); /* busmaster/no word-swap */ 567 pib = (u32) isa_virt_to_bus(&p->ib); 568 writereg(pib & 0xffff,CSR1); 569 writereg(pib >> 16,CSR2); 570 571 writereg(CSR0_INIT,CSR0); /* this changes L_ADDRREG to CSR0 */ 572 573 for(i=0;i<32;i++) 574 { 575 mdelay(4); 576 if(inw(PORT+L_DATAREG) & (CSR0_IDON | CSR0_MERR) ) 577 break; /* init ok ? */ 578 } 579} 580 581/* 582 * allocate memory area and check the 16MB border 583 */ 584static void *ni65_alloc_mem(struct net_device *dev,char *what,int size,int type) 585{ 586 struct sk_buff *skb=NULL; 587 unsigned char *ptr; 588 void *ret; 589 590 if(type) { 591 ret = skb = alloc_skb(2+16+size,GFP_KERNEL|GFP_DMA); 592 if(!skb) { 593 printk(KERN_WARNING "%s: unable to allocate %s memory.\n",dev->name,what); 594 return NULL; 595 } 596 skb_reserve(skb,2+16); 597 skb_put(skb,R_BUF_SIZE); /* grab the whole space .. (not necessary) */ 598 ptr = skb->data; 599 } 600 else { 601 ret = ptr = kmalloc(T_BUF_SIZE,GFP_KERNEL | GFP_DMA); 602 if(!ret) { 603 printk(KERN_WARNING "%s: unable to allocate %s memory.\n",dev->name,what); 604 return NULL; 605 } 606 } 607 if( (u32) virt_to_phys(ptr+size) > 0x1000000) { 608 printk(KERN_WARNING "%s: unable to allocate %s memory in lower 16MB!\n",dev->name,what); 609 if(type) 610 kfree_skb(skb); 611 else 612 kfree(ptr); 613 return NULL; 614 } 615 return ret; 616} 617 618/* 619 * allocate all memory structures .. send/recv buffers etc ... 620 */ 621static int ni65_alloc_buffer(struct net_device *dev) 622{ 623 unsigned char *ptr; 624 struct priv *p; 625 int i; 626 627 /* 628 * we need 8-aligned memory .. 629 */ 630 ptr = ni65_alloc_mem(dev,"BUFFER",sizeof(struct priv)+8,0); 631 if(!ptr) 632 return -ENOMEM; 633 634 p = dev->ml_priv = (struct priv *) (((unsigned long) ptr + 7) & ~0x7); 635 memset((char *)p, 0, sizeof(struct priv)); 636 p->self = ptr; 637 638 for(i=0;i<TMDNUM;i++) 639 { 640#ifdef XMT_VIA_SKB 641 p->tmd_skb[i] = NULL; 642#endif 643 p->tmdbounce[i] = ni65_alloc_mem(dev,"XMIT",T_BUF_SIZE,0); 644 if(!p->tmdbounce[i]) { 645 ni65_free_buffer(p); 646 return -ENOMEM; 647 } 648 } 649 650 for(i=0;i<RMDNUM;i++) 651 { 652#ifdef RCV_VIA_SKB 653 p->recv_skb[i] = ni65_alloc_mem(dev,"RECV",R_BUF_SIZE,1); 654 if(!p->recv_skb[i]) { 655 ni65_free_buffer(p); 656 return -ENOMEM; 657 } 658#else 659 p->recvbounce[i] = ni65_alloc_mem(dev,"RECV",R_BUF_SIZE,0); 660 if(!p->recvbounce[i]) { 661 ni65_free_buffer(p); 662 return -ENOMEM; 663 } 664#endif 665 } 666 667 return 0; /* everything is OK */ 668} 669 670/* 671 * free buffers and private struct 672 */ 673static void ni65_free_buffer(struct priv *p) 674{ 675 int i; 676 677 if(!p) 678 return; 679 680 for(i=0;i<TMDNUM;i++) { 681 kfree(p->tmdbounce[i]); 682#ifdef XMT_VIA_SKB 683 if(p->tmd_skb[i]) 684 dev_kfree_skb(p->tmd_skb[i]); 685#endif 686 } 687 688 for(i=0;i<RMDNUM;i++) 689 { 690#ifdef RCV_VIA_SKB 691 if(p->recv_skb[i]) 692 dev_kfree_skb(p->recv_skb[i]); 693#else 694 kfree(p->recvbounce[i]); 695#endif 696 } 697 kfree(p->self); 698} 699 700 701/* 702 * stop and (re)start lance .. e.g after an error 703 */ 704static void ni65_stop_start(struct net_device *dev,struct priv *p) 705{ 706 int csr0 = CSR0_INEA; 707 708 writedatareg(CSR0_STOP); 709 710 if(debuglevel > 1) 711 printk(KERN_DEBUG "ni65_stop_start\n"); 712 713 if(p->features & INIT_RING_BEFORE_START) { 714 int i; 715#ifdef XMT_VIA_SKB 716 struct sk_buff *skb_save[TMDNUM]; 717#endif 718 unsigned long buffer[TMDNUM]; 719 short blen[TMDNUM]; 720 721 if(p->xmit_queued) { 722 while(1) { 723 if((p->tmdhead[p->tmdlast].u.s.status & XMIT_OWN)) 724 break; 725 p->tmdlast = (p->tmdlast + 1) & (TMDNUM-1); 726 if(p->tmdlast == p->tmdnum) 727 break; 728 } 729 } 730 731 for(i=0;i<TMDNUM;i++) { 732 struct tmd *tmdp = p->tmdhead + i; 733#ifdef XMT_VIA_SKB 734 skb_save[i] = p->tmd_skb[i]; 735#endif 736 buffer[i] = (u32) isa_bus_to_virt(tmdp->u.buffer); 737 blen[i] = tmdp->blen; 738 tmdp->u.s.status = 0x0; 739 } 740 741 for(i=0;i<RMDNUM;i++) { 742 struct rmd *rmdp = p->rmdhead + i; 743 rmdp->u.s.status = RCV_OWN; 744 } 745 p->tmdnum = p->xmit_queued = 0; 746 writedatareg(CSR0_STRT | csr0); 747 748 for(i=0;i<TMDNUM;i++) { 749 int num = (i + p->tmdlast) & (TMDNUM-1); 750 p->tmdhead[i].u.buffer = (u32) isa_virt_to_bus((char *)buffer[num]); /* status is part of buffer field */ 751 p->tmdhead[i].blen = blen[num]; 752 if(p->tmdhead[i].u.s.status & XMIT_OWN) { 753 p->tmdnum = (p->tmdnum + 1) & (TMDNUM-1); 754 p->xmit_queued = 1; 755 writedatareg(CSR0_TDMD | CSR0_INEA | csr0); 756 } 757#ifdef XMT_VIA_SKB 758 p->tmd_skb[i] = skb_save[num]; 759#endif 760 } 761 p->rmdnum = p->tmdlast = 0; 762 if(!p->lock) 763 if (p->tmdnum || !p->xmit_queued) 764 netif_wake_queue(dev); 765 dev->trans_start = jiffies; /* prevent tx timeout */ 766 } 767 else 768 writedatareg(CSR0_STRT | csr0); 769} 770 771/* 772 * init lance (write init-values .. init-buffers) (open-helper) 773 */ 774static int ni65_lance_reinit(struct net_device *dev) 775{ 776 int i; 777 struct priv *p = dev->ml_priv; 778 unsigned long flags; 779 780 p->lock = 0; 781 p->xmit_queued = 0; 782 783 flags=claim_dma_lock(); 784 disable_dma(dev->dma); /* I've never worked with dma, but we do it like the packetdriver */ 785 set_dma_mode(dev->dma,DMA_MODE_CASCADE); 786 enable_dma(dev->dma); 787 release_dma_lock(flags); 788 789 outw(inw(PORT+L_RESET),PORT+L_RESET); /* first: reset the card */ 790 if( (i=readreg(CSR0) ) != 0x4) 791 { 792 printk(KERN_ERR "%s: can't RESET %s card: %04x\n",dev->name, 793 cards[p->cardno].cardname,(int) i); 794 flags=claim_dma_lock(); 795 disable_dma(dev->dma); 796 release_dma_lock(flags); 797 return 0; 798 } 799 800 p->rmdnum = p->tmdnum = p->tmdlast = p->tmdbouncenum = 0; 801 for(i=0;i<TMDNUM;i++) 802 { 803 struct tmd *tmdp = p->tmdhead + i; 804#ifdef XMT_VIA_SKB 805 if(p->tmd_skb[i]) { 806 dev_kfree_skb(p->tmd_skb[i]); 807 p->tmd_skb[i] = NULL; 808 } 809#endif 810 tmdp->u.buffer = 0x0; 811 tmdp->u.s.status = XMIT_START | XMIT_END; 812 tmdp->blen = tmdp->status2 = 0; 813 } 814 815 for(i=0;i<RMDNUM;i++) 816 { 817 struct rmd *rmdp = p->rmdhead + i; 818#ifdef RCV_VIA_SKB 819 rmdp->u.buffer = (u32) isa_virt_to_bus(p->recv_skb[i]->data); 820#else 821 rmdp->u.buffer = (u32) isa_virt_to_bus(p->recvbounce[i]); 822#endif 823 rmdp->blen = -(R_BUF_SIZE-8); 824 rmdp->mlen = 0; 825 rmdp->u.s.status = RCV_OWN; 826 } 827 828 if(dev->flags & IFF_PROMISC) 829 ni65_init_lance(p,dev->dev_addr,0x00,M_PROM); 830 else if (netdev_mc_count(dev) || dev->flags & IFF_ALLMULTI) 831 ni65_init_lance(p,dev->dev_addr,0xff,0x0); 832 else 833 ni65_init_lance(p,dev->dev_addr,0x00,0x00); 834 835 /* 836 * ni65_set_lance_mem() sets L_ADDRREG to CSR0 837 * NOW, WE WILL NEVER CHANGE THE L_ADDRREG, CSR0 IS ALWAYS SELECTED 838 */ 839 840 if(inw(PORT+L_DATAREG) & CSR0_IDON) { 841 ni65_set_performance(p); 842 /* init OK: start lance , enable interrupts */ 843 writedatareg(CSR0_CLRALL | CSR0_INEA | CSR0_STRT); 844 return 1; /* ->OK */ 845 } 846 printk(KERN_ERR "%s: can't init lance, status: %04x\n",dev->name,(int) inw(PORT+L_DATAREG)); 847 flags=claim_dma_lock(); 848 disable_dma(dev->dma); 849 release_dma_lock(flags); 850 return 0; /* ->Error */ 851} 852 853/* 854 * interrupt handler 855 */ 856static irqreturn_t ni65_interrupt(int irq, void * dev_id) 857{ 858 int csr0 = 0; 859 struct net_device *dev = dev_id; 860 struct priv *p; 861 int bcnt = 32; 862 863 p = dev->ml_priv; 864 865 spin_lock(&p->ring_lock); 866 867 while(--bcnt) { 868 csr0 = inw(PORT+L_DATAREG); 869 870 writedatareg( (csr0 & CSR0_CLRALL) | CSR0_INEA ); /* ack interrupts, interrupts enabled */ 871 872 if(!(csr0 & (CSR0_ERR | CSR0_RINT | CSR0_TINT))) 873 break; 874 875 if(csr0 & CSR0_RINT) /* RECV-int? */ 876 ni65_recv_intr(dev,csr0); 877 if(csr0 & CSR0_TINT) /* XMIT-int? */ 878 ni65_xmit_intr(dev,csr0); 879 880 if(csr0 & CSR0_ERR) 881 { 882 if(debuglevel > 1) 883 printk(KERN_ERR "%s: general error: %04x.\n",dev->name,csr0); 884 if(csr0 & CSR0_BABL) 885 dev->stats.tx_errors++; 886 if(csr0 & CSR0_MISS) { 887 int i; 888 for(i=0;i<RMDNUM;i++) 889 printk("%02x ",p->rmdhead[i].u.s.status); 890 printk("\n"); 891 dev->stats.rx_errors++; 892 } 893 if(csr0 & CSR0_MERR) { 894 if(debuglevel > 1) 895 printk(KERN_ERR "%s: Ooops .. memory error: %04x.\n",dev->name,csr0); 896 ni65_stop_start(dev,p); 897 } 898 } 899 } 900 901#ifdef RCV_PARANOIA_CHECK 902{ 903 int j; 904 for(j=0;j<RMDNUM;j++) 905 { 906 int i, num2; 907 for(i=RMDNUM-1;i>0;i--) { 908 num2 = (p->rmdnum + i) & (RMDNUM-1); 909 if(!(p->rmdhead[num2].u.s.status & RCV_OWN)) 910 break; 911 } 912 913 if(i) { 914 int k, num1; 915 for(k=0;k<RMDNUM;k++) { 916 num1 = (p->rmdnum + k) & (RMDNUM-1); 917 if(!(p->rmdhead[num1].u.s.status & RCV_OWN)) 918 break; 919 } 920 if(!k) 921 break; 922 923 if(debuglevel > 0) 924 { 925 char buf[256],*buf1; 926 buf1 = buf; 927 for(k=0;k<RMDNUM;k++) { 928 sprintf(buf1,"%02x ",(p->rmdhead[k].u.s.status)); /* & RCV_OWN) ); */ 929 buf1 += 3; 930 } 931 *buf1 = 0; 932 printk(KERN_ERR "%s: Ooops, receive ring corrupted %2d %2d | %s\n",dev->name,p->rmdnum,i,buf); 933 } 934 935 p->rmdnum = num1; 936 ni65_recv_intr(dev,csr0); 937 if((p->rmdhead[num2].u.s.status & RCV_OWN)) 938 break; /* ok, we are 'in sync' again */ 939 } 940 else 941 break; 942 } 943} 944#endif 945 946 if( (csr0 & (CSR0_RXON | CSR0_TXON)) != (CSR0_RXON | CSR0_TXON) ) { 947 printk(KERN_DEBUG "%s: RX or TX was offline -> restart\n",dev->name); 948 ni65_stop_start(dev,p); 949 } 950 else 951 writedatareg(CSR0_INEA); 952 953 spin_unlock(&p->ring_lock); 954 return IRQ_HANDLED; 955} 956 957/* 958 * We have received an Xmit-Interrupt .. 959 * send a new packet if necessary 960 */ 961static void ni65_xmit_intr(struct net_device *dev,int csr0) 962{ 963 struct priv *p = dev->ml_priv; 964 965 while(p->xmit_queued) 966 { 967 struct tmd *tmdp = p->tmdhead + p->tmdlast; 968 int tmdstat = tmdp->u.s.status; 969 970 if(tmdstat & XMIT_OWN) 971 break; 972 973 if(tmdstat & XMIT_ERR) 974 { 975 /* checking some errors */ 976 if(tmdp->status2 & XMIT_RTRY) 977 dev->stats.tx_aborted_errors++; 978 if(tmdp->status2 & XMIT_LCAR) 979 dev->stats.tx_carrier_errors++; 980 if(tmdp->status2 & (XMIT_BUFF | XMIT_UFLO )) { 981 /* this stops the xmitter */ 982 dev->stats.tx_fifo_errors++; 983 if(debuglevel > 0) 984 printk(KERN_ERR "%s: Xmit FIFO/BUFF error\n",dev->name); 985 if(p->features & INIT_RING_BEFORE_START) { 986 tmdp->u.s.status = XMIT_OWN | XMIT_START | XMIT_END; /* test: resend this frame */ 987 ni65_stop_start(dev,p); 988 break; /* no more Xmit processing .. */ 989 } 990 else 991 ni65_stop_start(dev,p); 992 } 993 if(debuglevel > 2) 994 printk(KERN_ERR "%s: xmit-error: %04x %02x-%04x\n",dev->name,csr0,(int) tmdstat,(int) tmdp->status2); 995 if(!(csr0 & CSR0_BABL)) /* don't count errors twice */ 996 dev->stats.tx_errors++; 997 tmdp->status2 = 0; 998 } 999 else { 1000 dev->stats.tx_bytes -= (short)(tmdp->blen); 1001 dev->stats.tx_packets++; 1002 } 1003 1004#ifdef XMT_VIA_SKB 1005 if(p->tmd_skb[p->tmdlast]) { 1006 dev_kfree_skb_irq(p->tmd_skb[p->tmdlast]); 1007 p->tmd_skb[p->tmdlast] = NULL; 1008 } 1009#endif 1010 1011 p->tmdlast = (p->tmdlast + 1) & (TMDNUM-1); 1012 if(p->tmdlast == p->tmdnum) 1013 p->xmit_queued = 0; 1014 } 1015 netif_wake_queue(dev); 1016} 1017 1018/* 1019 * We have received a packet 1020 */ 1021static void ni65_recv_intr(struct net_device *dev,int csr0) 1022{ 1023 struct rmd *rmdp; 1024 int rmdstat,len; 1025 int cnt=0; 1026 struct priv *p = dev->ml_priv; 1027 1028 rmdp = p->rmdhead + p->rmdnum; 1029 while(!( (rmdstat = rmdp->u.s.status) & RCV_OWN)) 1030 { 1031 cnt++; 1032 if( (rmdstat & (RCV_START | RCV_END | RCV_ERR)) != (RCV_START | RCV_END) ) /* error or oversized? */ 1033 { 1034 if(!(rmdstat & RCV_ERR)) { 1035 if(rmdstat & RCV_START) 1036 { 1037 dev->stats.rx_length_errors++; 1038 printk(KERN_ERR "%s: recv, packet too long: %d\n",dev->name,rmdp->mlen & 0x0fff); 1039 } 1040 } 1041 else { 1042 if(debuglevel > 2) 1043 printk(KERN_ERR "%s: receive-error: %04x, lance-status: %04x/%04x\n", 1044 dev->name,(int) rmdstat,csr0,(int) inw(PORT+L_DATAREG) ); 1045 if(rmdstat & RCV_FRAM) 1046 dev->stats.rx_frame_errors++; 1047 if(rmdstat & RCV_OFLO) 1048 dev->stats.rx_over_errors++; 1049 if(rmdstat & RCV_CRC) 1050 dev->stats.rx_crc_errors++; 1051 if(rmdstat & RCV_BUF_ERR) 1052 dev->stats.rx_fifo_errors++; 1053 } 1054 if(!(csr0 & CSR0_MISS)) /* don't count errors twice */ 1055 dev->stats.rx_errors++; 1056 } 1057 else if( (len = (rmdp->mlen & 0x0fff) - 4) >= 60) 1058 { 1059#ifdef RCV_VIA_SKB 1060 struct sk_buff *skb = alloc_skb(R_BUF_SIZE+2+16,GFP_ATOMIC); 1061 if (skb) 1062 skb_reserve(skb,16); 1063#else 1064 struct sk_buff *skb = dev_alloc_skb(len+2); 1065#endif 1066 if(skb) 1067 { 1068 skb_reserve(skb,2); 1069#ifdef RCV_VIA_SKB 1070 if( (unsigned long) (skb->data + R_BUF_SIZE) > 0x1000000) { 1071 skb_put(skb,len); 1072 skb_copy_to_linear_data(skb, (unsigned char *)(p->recv_skb[p->rmdnum]->data),len); 1073 } 1074 else { 1075 struct sk_buff *skb1 = p->recv_skb[p->rmdnum]; 1076 skb_put(skb,R_BUF_SIZE); 1077 p->recv_skb[p->rmdnum] = skb; 1078 rmdp->u.buffer = (u32) isa_virt_to_bus(skb->data); 1079 skb = skb1; 1080 skb_trim(skb,len); 1081 } 1082#else 1083 skb_put(skb,len); 1084 skb_copy_to_linear_data(skb, (unsigned char *) p->recvbounce[p->rmdnum],len); 1085#endif 1086 dev->stats.rx_packets++; 1087 dev->stats.rx_bytes += len; 1088 skb->protocol=eth_type_trans(skb,dev); 1089 netif_rx(skb); 1090 } 1091 else 1092 { 1093 printk(KERN_ERR "%s: can't alloc new sk_buff\n",dev->name); 1094 dev->stats.rx_dropped++; 1095 } 1096 } 1097 else { 1098 printk(KERN_INFO "%s: received runt packet\n",dev->name); 1099 dev->stats.rx_errors++; 1100 } 1101 rmdp->blen = -(R_BUF_SIZE-8); 1102 rmdp->mlen = 0; 1103 rmdp->u.s.status = RCV_OWN; /* change owner */ 1104 p->rmdnum = (p->rmdnum + 1) & (RMDNUM-1); 1105 rmdp = p->rmdhead + p->rmdnum; 1106 } 1107} 1108 1109/* 1110 * kick xmitter .. 1111 */ 1112 1113static void ni65_timeout(struct net_device *dev) 1114{ 1115 int i; 1116 struct priv *p = dev->ml_priv; 1117 1118 printk(KERN_ERR "%s: xmitter timed out, try to restart!\n",dev->name); 1119 for(i=0;i<TMDNUM;i++) 1120 printk("%02x ",p->tmdhead[i].u.s.status); 1121 printk("\n"); 1122 ni65_lance_reinit(dev); 1123 dev->trans_start = jiffies; /* prevent tx timeout */ 1124 netif_wake_queue(dev); 1125} 1126 1127/* 1128 * Send a packet 1129 */ 1130 1131static netdev_tx_t ni65_send_packet(struct sk_buff *skb, 1132 struct net_device *dev) 1133{ 1134 struct priv *p = dev->ml_priv; 1135 1136 netif_stop_queue(dev); 1137 1138 if (test_and_set_bit(0, (void*)&p->lock)) { 1139 printk(KERN_ERR "%s: Queue was locked.\n", dev->name); 1140 return NETDEV_TX_BUSY; 1141 } 1142 1143 { 1144 short len = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN; 1145 struct tmd *tmdp; 1146 unsigned long flags; 1147 1148#ifdef XMT_VIA_SKB 1149 if( (unsigned long) (skb->data + skb->len) > 0x1000000) { 1150#endif 1151 1152 skb_copy_from_linear_data(skb, p->tmdbounce[p->tmdbouncenum], 1153 skb->len > T_BUF_SIZE ? T_BUF_SIZE : 1154 skb->len); 1155 if (len > skb->len) 1156 memset((char *)p->tmdbounce[p->tmdbouncenum]+skb->len, 0, len-skb->len); 1157 dev_kfree_skb (skb); 1158 1159 spin_lock_irqsave(&p->ring_lock, flags); 1160 tmdp = p->tmdhead + p->tmdnum; 1161 tmdp->u.buffer = (u32) isa_virt_to_bus(p->tmdbounce[p->tmdbouncenum]); 1162 p->tmdbouncenum = (p->tmdbouncenum + 1) & (TMDNUM - 1); 1163 1164#ifdef XMT_VIA_SKB 1165 } 1166 else { 1167 spin_lock_irqsave(&p->ring_lock, flags); 1168 1169 tmdp = p->tmdhead + p->tmdnum; 1170 tmdp->u.buffer = (u32) isa_virt_to_bus(skb->data); 1171 p->tmd_skb[p->tmdnum] = skb; 1172 } 1173#endif 1174 tmdp->blen = -len; 1175 1176 tmdp->u.s.status = XMIT_OWN | XMIT_START | XMIT_END; 1177 writedatareg(CSR0_TDMD | CSR0_INEA); /* enable xmit & interrupt */ 1178 1179 p->xmit_queued = 1; 1180 p->tmdnum = (p->tmdnum + 1) & (TMDNUM-1); 1181 1182 if(p->tmdnum != p->tmdlast) 1183 netif_wake_queue(dev); 1184 1185 p->lock = 0; 1186 1187 spin_unlock_irqrestore(&p->ring_lock, flags); 1188 } 1189 1190 return NETDEV_TX_OK; 1191} 1192 1193static void set_multicast_list(struct net_device *dev) 1194{ 1195 if(!ni65_lance_reinit(dev)) 1196 printk(KERN_ERR "%s: Can't switch card into MC mode!\n",dev->name); 1197 netif_wake_queue(dev); 1198} 1199 1200#ifdef MODULE 1201static struct net_device *dev_ni65; 1202 1203module_param(irq, int, 0); 1204module_param(io, int, 0); 1205module_param(dma, int, 0); 1206MODULE_PARM_DESC(irq, "ni6510 IRQ number (ignored for some cards)"); 1207MODULE_PARM_DESC(io, "ni6510 I/O base address"); 1208MODULE_PARM_DESC(dma, "ni6510 ISA DMA channel (ignored for some cards)"); 1209 1210int __init init_module(void) 1211{ 1212 dev_ni65 = ni65_probe(-1); 1213 return IS_ERR(dev_ni65) ? PTR_ERR(dev_ni65) : 0; 1214} 1215 1216void __exit cleanup_module(void) 1217{ 1218 unregister_netdev(dev_ni65); 1219 cleanup_card(dev_ni65); 1220 free_netdev(dev_ni65); 1221} 1222#endif /* MODULE */ 1223 1224MODULE_LICENSE("GPL"); 1225