1/* 2 * net-3-driver for the NI5210 card (i82586 Ethernet chip) 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 * Alphacode 0.82 (96/09/29) for Linux 2.0.0 (or later) 8 * Copyrights (c) 1994,1995,1996 by M.Hipp (hippm@informatik.uni-tuebingen.de) 9 * [feel free to mail ....] 10 * 11 * when using as module: (no autoprobing!) 12 * compile with: 13 * gcc -O2 -fomit-frame-pointer -m486 -D__KERNEL__ -DMODULE -c ni52.c 14 * run with e.g: 15 * insmod ni52.o io=0x360 irq=9 memstart=0xd0000 memend=0xd4000 16 * 17 * CAN YOU PLEASE REPORT ME YOUR PERFORMANCE EXPERIENCES !!. 18 * 19 * If you find a bug, please report me: 20 * The kernel panic output and any kmsg from the ni52 driver 21 * the ni5210-driver-version and the linux-kernel version 22 * how many shared memory (memsize) on the netcard, 23 * bootprom: yes/no, base_addr, mem_start 24 * maybe the ni5210-card revision and the i82586 version 25 * 26 * autoprobe for: base_addr: 0x300,0x280,0x360,0x320,0x340 27 * mem_start: 0xd0000,0xd2000,0xc8000,0xca000,0xd4000,0xd6000, 28 * 0xd8000,0xcc000,0xce000,0xda000,0xdc000 29 * 30 * sources: 31 * skeleton.c from Donald Becker 32 * 33 * I have also done a look in the following sources: (mail me if you need them) 34 * crynwr-packet-driver by Russ Nelson 35 * Garret A. Wollman's (fourth) i82586-driver for BSD 36 * (before getting an i82596 (yes 596 not 586) manual, the existing drivers helped 37 * me a lot to understand this tricky chip.) 38 * 39 * Known Problems: 40 * The internal sysbus seems to be slow. So we often lose packets because of 41 * overruns while receiving from a fast remote host. 42 * This can slow down TCP connections. Maybe the newer ni5210 cards are better. 43 * my experience is, that if a machine sends with more than about 500-600K/s 44 * the fifo/sysbus overflows. 45 * 46 * IMPORTANT NOTE: 47 * On fast networks, it's a (very) good idea to have 16K shared memory. With 48 * 8K, we can store only 4 receive frames, so it can (easily) happen that a remote 49 * machine 'overruns' our system. 50 * 51 * Known i82586/card problems (I'm sure, there are many more!): 52 * Running the NOP-mode, the i82586 sometimes seems to forget to report 53 * every xmit-interrupt until we restart the CU. 54 * Another MAJOR bug is, that the RU sometimes seems to ignore the EL-Bit 55 * in the RBD-Struct which indicates an end of the RBD queue. 56 * Instead, the RU fetches another (randomly selected and 57 * usually used) RBD and begins to fill it. (Maybe, this happens only if 58 * the last buffer from the previous RFD fits exact into the queue and 59 * the next RFD can't fetch an initial RBD. Anyone knows more? ) 60 * 61 * results from ftp performance tests with Linux 1.2.5 62 * send and receive about 350-400 KByte/s (peak up to 460 kbytes/s) 63 * sending in NOP-mode: peak performance up to 530K/s (but better don't run this mode) 64 */ 65 66 67static int debuglevel; /* debug-printk 0: off 1: a few 2: more */ 68static int automatic_resume; /* experimental .. better should be zero */ 69static int rfdadd; /* rfdadd=1 may be better for 8K MEM cards */ 70static int fifo=0x8; /* don't change */ 71 72#include <linux/module.h> 73#include <linux/kernel.h> 74#include <linux/string.h> 75#include <linux/errno.h> 76#include <linux/ioport.h> 77#include <linux/slab.h> 78#include <linux/interrupt.h> 79#include <linux/delay.h> 80#include <linux/init.h> 81#include <linux/bitops.h> 82#include <asm/io.h> 83 84#include <linux/netdevice.h> 85#include <linux/etherdevice.h> 86#include <linux/skbuff.h> 87 88#include "ni52.h" 89 90#define DRV_NAME "ni52" 91 92#define DEBUG /* debug on */ 93#define SYSBUSVAL 1 /* 8 Bit */ 94 95#define ni_attn586() {outb(0,dev->base_addr+NI52_ATTENTION);} 96#define ni_reset586() {outb(0,dev->base_addr+NI52_RESET);} 97#define ni_disint() {outb(0,dev->base_addr+NI52_INTDIS);} 98#define ni_enaint() {outb(0,dev->base_addr+NI52_INTENA);} 99 100#define make32(ptr16) (p->memtop + (short) (ptr16) ) 101#define make24(ptr32) ( ((char *) (ptr32)) - p->base) 102#define make16(ptr32) ((unsigned short) ((unsigned long)(ptr32) - (unsigned long) p->memtop )) 103 104/******************* how to calculate the buffers ***************************** 105 106 * IMPORTANT NOTE: if you configure only one NUM_XMIT_BUFFS, the driver works 107 * --------------- in a different (more stable?) mode. Only in this mode it's 108 * possible to configure the driver with 'NO_NOPCOMMANDS' 109 110sizeof(scp)=12; sizeof(scb)=16; sizeof(iscp)=8; 111sizeof(scp)+sizeof(iscp)+sizeof(scb) = 36 = INIT 112sizeof(rfd) = 24; sizeof(rbd) = 12; 113sizeof(tbd) = 8; sizeof(transmit_cmd) = 16; 114sizeof(nop_cmd) = 8; 115 116 * if you don't know the driver, better do not change these values: */ 117 118#define RECV_BUFF_SIZE 1524 /* slightly oversized */ 119#define XMIT_BUFF_SIZE 1524 /* slightly oversized */ 120#define NUM_XMIT_BUFFS 1 /* config for both, 8K and 16K shmem */ 121#define NUM_RECV_BUFFS_8 4 /* config for 8K shared mem */ 122#define NUM_RECV_BUFFS_16 9 /* config for 16K shared mem */ 123#define NO_NOPCOMMANDS /* only possible with NUM_XMIT_BUFFS=1 */ 124 125/**************************************************************************/ 126 127/* different DELAYs */ 128#define DELAY(x) mdelay(32 * x); 129#define DELAY_16(); { udelay(16); } 130#define DELAY_18(); { udelay(4); } 131 132/* wait for command with timeout: */ 133#define WAIT_4_SCB_CMD() \ 134{ int i; \ 135 for(i=0;i<16384;i++) { \ 136 if(!p->scb->cmd_cuc) break; \ 137 DELAY_18(); \ 138 if(i == 16383) { \ 139 printk("%s: scb_cmd timed out: %04x,%04x .. disabling i82586!!\n",dev->name,p->scb->cmd_cuc,p->scb->cus); \ 140 if(!p->reseted) { p->reseted = 1; ni_reset586(); } } } } 141 142#define WAIT_4_SCB_CMD_RUC() { int i; \ 143 for(i=0;i<16384;i++) { \ 144 if(!p->scb->cmd_ruc) break; \ 145 DELAY_18(); \ 146 if(i == 16383) { \ 147 printk("%s: scb_cmd (ruc) timed out: %04x,%04x .. disabling i82586!!\n",dev->name,p->scb->cmd_ruc,p->scb->rus); \ 148 if(!p->reseted) { p->reseted = 1; ni_reset586(); } } } } 149 150#define WAIT_4_STAT_COMPL(addr) { int i; \ 151 for(i=0;i<32767;i++) { \ 152 if((addr)->cmd_status & STAT_COMPL) break; \ 153 DELAY_16(); DELAY_16(); } } 154 155#define NI52_TOTAL_SIZE 16 156#define NI52_ADDR0 0x02 157#define NI52_ADDR1 0x07 158#define NI52_ADDR2 0x01 159 160static int ni52_probe1(struct net_device *dev,int ioaddr); 161static irqreturn_t ni52_interrupt(int irq,void *dev_id); 162static int ni52_open(struct net_device *dev); 163static int ni52_close(struct net_device *dev); 164static int ni52_send_packet(struct sk_buff *,struct net_device *); 165static struct net_device_stats *ni52_get_stats(struct net_device *dev); 166static void set_multicast_list(struct net_device *dev); 167static void ni52_timeout(struct net_device *dev); 168 169/* helper-functions */ 170static int init586(struct net_device *dev); 171static int check586(struct net_device *dev,char *where,unsigned size); 172static void alloc586(struct net_device *dev); 173static void startrecv586(struct net_device *dev); 174static void *alloc_rfa(struct net_device *dev,void *ptr); 175static void ni52_rcv_int(struct net_device *dev); 176static void ni52_xmt_int(struct net_device *dev); 177static void ni52_rnr_int(struct net_device *dev); 178 179struct priv 180{ 181 struct net_device_stats stats; 182 unsigned long base; 183 char *memtop; 184 long int lock; 185 int reseted; 186 volatile struct rfd_struct *rfd_last,*rfd_top,*rfd_first; 187 volatile struct scp_struct *scp; /* volatile is important */ 188 volatile struct iscp_struct *iscp; /* volatile is important */ 189 volatile struct scb_struct *scb; /* volatile is important */ 190 volatile struct tbd_struct *xmit_buffs[NUM_XMIT_BUFFS]; 191#if (NUM_XMIT_BUFFS == 1) 192 volatile struct transmit_cmd_struct *xmit_cmds[2]; 193 volatile struct nop_cmd_struct *nop_cmds[2]; 194#else 195 volatile struct transmit_cmd_struct *xmit_cmds[NUM_XMIT_BUFFS]; 196 volatile struct nop_cmd_struct *nop_cmds[NUM_XMIT_BUFFS]; 197#endif 198 volatile int nop_point,num_recv_buffs; 199 volatile char *xmit_cbuffs[NUM_XMIT_BUFFS]; 200 volatile int xmit_count,xmit_last; 201}; 202 203/********************************************** 204 * close device 205 */ 206static int ni52_close(struct net_device *dev) 207{ 208 free_irq(dev->irq, dev); 209 210 ni_reset586(); /* the hard way to stop the receiver */ 211 212 netif_stop_queue(dev); 213 214 return 0; 215} 216 217/********************************************** 218 * open device 219 */ 220static int ni52_open(struct net_device *dev) 221{ 222 int ret; 223 224 ni_disint(); 225 alloc586(dev); 226 init586(dev); 227 startrecv586(dev); 228 ni_enaint(); 229 230 ret = request_irq(dev->irq, &ni52_interrupt,0,dev->name,dev); 231 if (ret) 232 { 233 ni_reset586(); 234 return ret; 235 } 236 237 netif_start_queue(dev); 238 239 return 0; /* most done by init */ 240} 241 242/********************************************** 243 * Check to see if there's an 82586 out there. 244 */ 245static int check586(struct net_device *dev,char *where,unsigned size) 246{ 247 struct priv pb; 248 struct priv *p = /* (struct priv *) dev->priv*/ &pb; 249 char *iscp_addrs[2]; 250 int i; 251 252 p->base = (unsigned long) isa_bus_to_virt((unsigned long)where) + size - 0x01000000; 253 p->memtop = isa_bus_to_virt((unsigned long)where) + size; 254 p->scp = (struct scp_struct *)(p->base + SCP_DEFAULT_ADDRESS); 255 memset((char *)p->scp,0, sizeof(struct scp_struct)); 256 for(i=0;i<sizeof(struct scp_struct);i++) /* memory was writeable? */ 257 if(((char *)p->scp)[i]) 258 return 0; 259 p->scp->sysbus = SYSBUSVAL; /* 1 = 8Bit-Bus, 0 = 16 Bit */ 260 if(p->scp->sysbus != SYSBUSVAL) 261 return 0; 262 263 iscp_addrs[0] = isa_bus_to_virt((unsigned long)where); 264 iscp_addrs[1]= (char *) p->scp - sizeof(struct iscp_struct); 265 266 for(i=0;i<2;i++) 267 { 268 p->iscp = (struct iscp_struct *) iscp_addrs[i]; 269 memset((char *)p->iscp,0, sizeof(struct iscp_struct)); 270 271 p->scp->iscp = make24(p->iscp); 272 p->iscp->busy = 1; 273 274 ni_reset586(); 275 ni_attn586(); 276 DELAY(1); /* wait a while... */ 277 278 if(p->iscp->busy) /* i82586 clears 'busy' after successful init */ 279 return 0; 280 } 281 return 1; 282} 283 284/****************************************************************** 285 * set iscp at the right place, called by ni52_probe1 and open586. 286 */ 287static void alloc586(struct net_device *dev) 288{ 289 struct priv *p = (struct priv *) dev->priv; 290 291 ni_reset586(); 292 DELAY(1); 293 294 p->scp = (struct scp_struct *) (p->base + SCP_DEFAULT_ADDRESS); 295 p->scb = (struct scb_struct *) isa_bus_to_virt(dev->mem_start); 296 p->iscp = (struct iscp_struct *) ((char *)p->scp - sizeof(struct iscp_struct)); 297 298 memset((char *) p->iscp,0,sizeof(struct iscp_struct)); 299 memset((char *) p->scp ,0,sizeof(struct scp_struct)); 300 301 p->scp->iscp = make24(p->iscp); 302 p->scp->sysbus = SYSBUSVAL; 303 p->iscp->scb_offset = make16(p->scb); 304 305 p->iscp->busy = 1; 306 ni_reset586(); 307 ni_attn586(); 308 309 DELAY(1); 310 311 if(p->iscp->busy) 312 printk("%s: Init-Problems (alloc).\n",dev->name); 313 314 p->reseted = 0; 315 316 memset((char *)p->scb,0,sizeof(struct scb_struct)); 317} 318 319/* set: io,irq,memstart,memend or set it when calling insmod */ 320static int irq=9; 321static int io=0x300; 322static long memstart; /* e.g 0xd0000 */ 323static long memend; /* e.g 0xd4000 */ 324 325/********************************************** 326 * probe the ni5210-card 327 */ 328struct net_device * __init ni52_probe(int unit) 329{ 330 struct net_device *dev = alloc_etherdev(sizeof(struct priv)); 331 static int ports[] = {0x300, 0x280, 0x360 , 0x320 , 0x340, 0}; 332 int *port; 333 int err = 0; 334 335 if (!dev) 336 return ERR_PTR(-ENOMEM); 337 338 if (unit >= 0) { 339 sprintf(dev->name, "eth%d", unit); 340 netdev_boot_setup_check(dev); 341 io = dev->base_addr; 342 irq = dev->irq; 343 memstart = dev->mem_start; 344 memend = dev->mem_end; 345 } 346 347 SET_MODULE_OWNER(dev); 348 349 if (io > 0x1ff) { /* Check a single specified location. */ 350 err = ni52_probe1(dev, io); 351 } else if (io > 0) { /* Don't probe at all. */ 352 err = -ENXIO; 353 } else { 354 for (port = ports; *port && ni52_probe1(dev, *port) ; port++) 355 ; 356 if (*port) 357 goto got_it; 358#ifdef FULL_IO_PROBE 359 for (io = 0x200; io < 0x400 && ni52_probe1(dev, io); io += 8) 360 ; 361 if (io < 0x400) 362 goto got_it; 363#endif 364 err = -ENODEV; 365 } 366 if (err) 367 goto out; 368got_it: 369 err = register_netdev(dev); 370 if (err) 371 goto out1; 372 return dev; 373out1: 374 release_region(dev->base_addr, NI52_TOTAL_SIZE); 375out: 376 free_netdev(dev); 377 return ERR_PTR(err); 378} 379 380static int __init ni52_probe1(struct net_device *dev,int ioaddr) 381{ 382 int i, size, retval; 383 384 dev->base_addr = ioaddr; 385 dev->irq = irq; 386 dev->mem_start = memstart; 387 dev->mem_end = memend; 388 389 if (!request_region(ioaddr, NI52_TOTAL_SIZE, DRV_NAME)) 390 return -EBUSY; 391 392 if( !(inb(ioaddr+NI52_MAGIC1) == NI52_MAGICVAL1) || 393 !(inb(ioaddr+NI52_MAGIC2) == NI52_MAGICVAL2)) { 394 retval = -ENODEV; 395 goto out; 396 } 397 398 for(i=0;i<ETH_ALEN;i++) 399 dev->dev_addr[i] = inb(dev->base_addr+i); 400 401 if(dev->dev_addr[0] != NI52_ADDR0 || dev->dev_addr[1] != NI52_ADDR1 402 || dev->dev_addr[2] != NI52_ADDR2) { 403 retval = -ENODEV; 404 goto out; 405 } 406 407 printk(KERN_INFO "%s: NI5210 found at %#3lx, ",dev->name,dev->base_addr); 408 409 /* 410 * check (or search) IO-Memory, 8K and 16K 411 */ 412#ifdef MODULE 413 size = dev->mem_end - dev->mem_start; 414 if(size != 0x2000 && size != 0x4000) { 415 printk("\n%s: Illegal memory size %d. Allowed is 0x2000 or 0x4000 bytes.\n",dev->name,size); 416 retval = -ENODEV; 417 goto out; 418 } 419 if(!check586(dev,(char *) dev->mem_start,size)) { 420 printk("?memcheck, Can't find memory at 0x%lx with size %d!\n",dev->mem_start,size); 421 retval = -ENODEV; 422 goto out; 423 } 424#else 425 if(dev->mem_start != 0) /* no auto-mem-probe */ 426 { 427 size = 0x4000; /* check for 16K mem */ 428 if(!check586(dev,(char *) dev->mem_start,size)) { 429 size = 0x2000; /* check for 8K mem */ 430 if(!check586(dev,(char *) dev->mem_start,size)) { 431 printk("?memprobe, Can't find memory at 0x%lx!\n",dev->mem_start); 432 retval = -ENODEV; 433 goto out; 434 } 435 } 436 } 437 else 438 { 439 static long memaddrs[] = { 0xc8000,0xca000,0xcc000,0xce000,0xd0000,0xd2000, 440 0xd4000,0xd6000,0xd8000,0xda000,0xdc000, 0 }; 441 for(i=0;;i++) 442 { 443 if(!memaddrs[i]) { 444 printk("?memprobe, Can't find io-memory!\n"); 445 retval = -ENODEV; 446 goto out; 447 } 448 dev->mem_start = memaddrs[i]; 449 size = 0x2000; /* check for 8K mem */ 450 if(check586(dev,(char *)dev->mem_start,size)) /* 8K-check */ 451 break; 452 size = 0x4000; /* check for 16K mem */ 453 if(check586(dev,(char *)dev->mem_start,size)) /* 16K-check */ 454 break; 455 } 456 } 457 dev->mem_end = dev->mem_start + size; /* set mem_end showed by 'ifconfig' */ 458#endif 459 460 memset((char *) dev->priv,0,sizeof(struct priv)); 461 462 ((struct priv *) (dev->priv))->memtop = isa_bus_to_virt(dev->mem_start) + size; 463 ((struct priv *) (dev->priv))->base = (unsigned long) isa_bus_to_virt(dev->mem_start) + size - 0x01000000; 464 alloc586(dev); 465 466 /* set number of receive-buffs according to memsize */ 467 if(size == 0x2000) 468 ((struct priv *) dev->priv)->num_recv_buffs = NUM_RECV_BUFFS_8; 469 else 470 ((struct priv *) dev->priv)->num_recv_buffs = NUM_RECV_BUFFS_16; 471 472 printk("Memaddr: 0x%lx, Memsize: %d, ",dev->mem_start,size); 473 474 if(dev->irq < 2) 475 { 476 unsigned long irq_mask; 477 478 irq_mask = probe_irq_on(); 479 ni_reset586(); 480 ni_attn586(); 481 482 mdelay(20); 483 dev->irq = probe_irq_off(irq_mask); 484 if(!dev->irq) 485 { 486 printk("?autoirq, Failed to detect IRQ line!\n"); 487 retval = -EAGAIN; 488 goto out; 489 } 490 printk("IRQ %d (autodetected).\n",dev->irq); 491 } 492 else { 493 if(dev->irq == 2) 494 dev->irq = 9; 495 printk("IRQ %d (assigned and not checked!).\n",dev->irq); 496 } 497 498 dev->open = ni52_open; 499 dev->stop = ni52_close; 500 dev->get_stats = ni52_get_stats; 501 dev->tx_timeout = ni52_timeout; 502 dev->watchdog_timeo = HZ/20; 503 dev->hard_start_xmit = ni52_send_packet; 504 dev->set_multicast_list = set_multicast_list; 505 506 dev->if_port = 0; 507 508 return 0; 509out: 510 release_region(ioaddr, NI52_TOTAL_SIZE); 511 return retval; 512} 513 514/********************************************** 515 * init the chip (ni52-interrupt should be disabled?!) 516 * needs a correct 'allocated' memory 517 */ 518 519static int init586(struct net_device *dev) 520{ 521 void *ptr; 522 int i,result=0; 523 struct priv *p = (struct priv *) dev->priv; 524 volatile struct configure_cmd_struct *cfg_cmd; 525 volatile struct iasetup_cmd_struct *ias_cmd; 526 volatile struct tdr_cmd_struct *tdr_cmd; 527 volatile struct mcsetup_cmd_struct *mc_cmd; 528 struct dev_mc_list *dmi=dev->mc_list; 529 int num_addrs=dev->mc_count; 530 531 ptr = (void *) ((char *)p->scb + sizeof(struct scb_struct)); 532 533 cfg_cmd = (struct configure_cmd_struct *)ptr; /* configure-command */ 534 cfg_cmd->cmd_status = 0; 535 cfg_cmd->cmd_cmd = CMD_CONFIGURE | CMD_LAST; 536 cfg_cmd->cmd_link = 0xffff; 537 538 cfg_cmd->byte_cnt = 0x0a; /* number of cfg bytes */ 539 cfg_cmd->fifo = fifo; /* fifo-limit (8=tx:32/rx:64) */ 540 cfg_cmd->sav_bf = 0x40; /* hold or discard bad recv frames (bit 7) */ 541 cfg_cmd->adr_len = 0x2e; /* addr_len |!src_insert |pre-len |loopback */ 542 cfg_cmd->priority = 0x00; 543 cfg_cmd->ifs = 0x60; 544 cfg_cmd->time_low = 0x00; 545 cfg_cmd->time_high = 0xf2; 546 cfg_cmd->promisc = 0; 547 if(dev->flags & IFF_ALLMULTI) { 548 int len = ((char *) p->iscp - (char *) ptr - 8) / 6; 549 if(num_addrs > len) { 550 printk("%s: switching to promisc. mode\n",dev->name); 551 dev->flags|=IFF_PROMISC; 552 } 553 } 554 if(dev->flags&IFF_PROMISC) 555 { 556 cfg_cmd->promisc=1; 557 dev->flags|=IFF_PROMISC; 558 } 559 cfg_cmd->carr_coll = 0x00; 560 561 p->scb->cbl_offset = make16(cfg_cmd); 562 p->scb->cmd_ruc = 0; 563 564 p->scb->cmd_cuc = CUC_START; /* cmd.-unit start */ 565 ni_attn586(); 566 567 WAIT_4_STAT_COMPL(cfg_cmd); 568 569 if((cfg_cmd->cmd_status & (STAT_OK|STAT_COMPL)) != (STAT_COMPL|STAT_OK)) 570 { 571 printk("%s: configure command failed: %x\n",dev->name,cfg_cmd->cmd_status); 572 return 1; 573 } 574 575 /* 576 * individual address setup 577 */ 578 579 ias_cmd = (struct iasetup_cmd_struct *)ptr; 580 581 ias_cmd->cmd_status = 0; 582 ias_cmd->cmd_cmd = CMD_IASETUP | CMD_LAST; 583 ias_cmd->cmd_link = 0xffff; 584 585 memcpy((char *)&ias_cmd->iaddr,(char *) dev->dev_addr,ETH_ALEN); 586 587 p->scb->cbl_offset = make16(ias_cmd); 588 589 p->scb->cmd_cuc = CUC_START; /* cmd.-unit start */ 590 ni_attn586(); 591 592 WAIT_4_STAT_COMPL(ias_cmd); 593 594 if((ias_cmd->cmd_status & (STAT_OK|STAT_COMPL)) != (STAT_OK|STAT_COMPL)) { 595 printk("%s (ni52): individual address setup command failed: %04x\n",dev->name,ias_cmd->cmd_status); 596 return 1; 597 } 598 599 /* 600 * TDR, wire check .. e.g. no resistor e.t.c 601 */ 602 603 tdr_cmd = (struct tdr_cmd_struct *)ptr; 604 605 tdr_cmd->cmd_status = 0; 606 tdr_cmd->cmd_cmd = CMD_TDR | CMD_LAST; 607 tdr_cmd->cmd_link = 0xffff; 608 tdr_cmd->status = 0; 609 610 p->scb->cbl_offset = make16(tdr_cmd); 611 p->scb->cmd_cuc = CUC_START; /* cmd.-unit start */ 612 ni_attn586(); 613 614 WAIT_4_STAT_COMPL(tdr_cmd); 615 616 if(!(tdr_cmd->cmd_status & STAT_COMPL)) 617 { 618 printk("%s: Problems while running the TDR.\n",dev->name); 619 } 620 else 621 { 622 DELAY_16(); /* wait for result */ 623 result = tdr_cmd->status; 624 625 p->scb->cmd_cuc = p->scb->cus & STAT_MASK; 626 ni_attn586(); /* ack the interrupts */ 627 628 if(result & TDR_LNK_OK) 629 ; 630 else if(result & TDR_XCVR_PRB) 631 printk("%s: TDR: Transceiver problem. Check the cable(s)!\n",dev->name); 632 else if(result & TDR_ET_OPN) 633 printk("%s: TDR: No correct termination %d clocks away.\n",dev->name,result & TDR_TIMEMASK); 634 else if(result & TDR_ET_SRT) 635 { 636 if (result & TDR_TIMEMASK) /* time == 0 -> strange :-) */ 637 printk("%s: TDR: Detected a short circuit %d clocks away.\n",dev->name,result & TDR_TIMEMASK); 638 } 639 else 640 printk("%s: TDR: Unknown status %04x\n",dev->name,result); 641 } 642 643 /* 644 * Multicast setup 645 */ 646 if(num_addrs && !(dev->flags & IFF_PROMISC) ) 647 { 648 mc_cmd = (struct mcsetup_cmd_struct *) ptr; 649 mc_cmd->cmd_status = 0; 650 mc_cmd->cmd_cmd = CMD_MCSETUP | CMD_LAST; 651 mc_cmd->cmd_link = 0xffff; 652 mc_cmd->mc_cnt = num_addrs * 6; 653 654 for(i=0;i<num_addrs;i++,dmi=dmi->next) 655 memcpy((char *) mc_cmd->mc_list[i], dmi->dmi_addr,6); 656 657 p->scb->cbl_offset = make16(mc_cmd); 658 p->scb->cmd_cuc = CUC_START; 659 ni_attn586(); 660 661 WAIT_4_STAT_COMPL(mc_cmd); 662 663 if( (mc_cmd->cmd_status & (STAT_COMPL|STAT_OK)) != (STAT_COMPL|STAT_OK) ) 664 printk("%s: Can't apply multicast-address-list.\n",dev->name); 665 } 666 667 /* 668 * alloc nop/xmit-cmds 669 */ 670#if (NUM_XMIT_BUFFS == 1) 671 for(i=0;i<2;i++) 672 { 673 p->nop_cmds[i] = (struct nop_cmd_struct *)ptr; 674 p->nop_cmds[i]->cmd_cmd = CMD_NOP; 675 p->nop_cmds[i]->cmd_status = 0; 676 p->nop_cmds[i]->cmd_link = make16((p->nop_cmds[i])); 677 ptr = (char *) ptr + sizeof(struct nop_cmd_struct); 678 } 679#else 680 for(i=0;i<NUM_XMIT_BUFFS;i++) 681 { 682 p->nop_cmds[i] = (struct nop_cmd_struct *)ptr; 683 p->nop_cmds[i]->cmd_cmd = CMD_NOP; 684 p->nop_cmds[i]->cmd_status = 0; 685 p->nop_cmds[i]->cmd_link = make16((p->nop_cmds[i])); 686 ptr = (char *) ptr + sizeof(struct nop_cmd_struct); 687 } 688#endif 689 690 ptr = alloc_rfa(dev,(void *)ptr); /* init receive-frame-area */ 691 692 /* 693 * alloc xmit-buffs / init xmit_cmds 694 */ 695 for(i=0;i<NUM_XMIT_BUFFS;i++) 696 { 697 p->xmit_cmds[i] = (struct transmit_cmd_struct *)ptr; /*transmit cmd/buff 0*/ 698 ptr = (char *) ptr + sizeof(struct transmit_cmd_struct); 699 p->xmit_cbuffs[i] = (char *)ptr; /* char-buffs */ 700 ptr = (char *) ptr + XMIT_BUFF_SIZE; 701 p->xmit_buffs[i] = (struct tbd_struct *)ptr; /* TBD */ 702 ptr = (char *) ptr + sizeof(struct tbd_struct); 703 if((void *)ptr > (void *)p->iscp) 704 { 705 printk("%s: not enough shared-mem for your configuration!\n",dev->name); 706 return 1; 707 } 708 memset((char *)(p->xmit_cmds[i]) ,0, sizeof(struct transmit_cmd_struct)); 709 memset((char *)(p->xmit_buffs[i]),0, sizeof(struct tbd_struct)); 710 p->xmit_cmds[i]->cmd_link = make16(p->nop_cmds[(i+1)%NUM_XMIT_BUFFS]); 711 p->xmit_cmds[i]->cmd_status = STAT_COMPL; 712 p->xmit_cmds[i]->cmd_cmd = CMD_XMIT | CMD_INT; 713 p->xmit_cmds[i]->tbd_offset = make16((p->xmit_buffs[i])); 714 p->xmit_buffs[i]->next = 0xffff; 715 p->xmit_buffs[i]->buffer = make24((p->xmit_cbuffs[i])); 716 } 717 718 p->xmit_count = 0; 719 p->xmit_last = 0; 720#ifndef NO_NOPCOMMANDS 721 p->nop_point = 0; 722#endif 723 724 /* 725 * 'start transmitter' 726 */ 727#ifndef NO_NOPCOMMANDS 728 p->scb->cbl_offset = make16(p->nop_cmds[0]); 729 p->scb->cmd_cuc = CUC_START; 730 ni_attn586(); 731 WAIT_4_SCB_CMD(); 732#else 733 p->xmit_cmds[0]->cmd_link = make16(p->xmit_cmds[0]); 734 p->xmit_cmds[0]->cmd_cmd = CMD_XMIT | CMD_SUSPEND | CMD_INT; 735#endif 736 737 /* 738 * ack. interrupts 739 */ 740 p->scb->cmd_cuc = p->scb->cus & STAT_MASK; 741 ni_attn586(); 742 DELAY_16(); 743 744 ni_enaint(); 745 746 return 0; 747} 748 749/****************************************************** 750 * This is a helper routine for ni52_rnr_int() and init586(). 751 * It sets up the Receive Frame Area (RFA). 752 */ 753 754static void *alloc_rfa(struct net_device *dev,void *ptr) 755{ 756 volatile struct rfd_struct *rfd = (struct rfd_struct *)ptr; 757 volatile struct rbd_struct *rbd; 758 int i; 759 struct priv *p = (struct priv *) dev->priv; 760 761 memset((char *) rfd,0,sizeof(struct rfd_struct)*(p->num_recv_buffs+rfdadd)); 762 p->rfd_first = rfd; 763 764 for(i = 0; i < (p->num_recv_buffs+rfdadd); i++) { 765 rfd[i].next = make16(rfd + (i+1) % (p->num_recv_buffs+rfdadd) ); 766 rfd[i].rbd_offset = 0xffff; 767 } 768 rfd[p->num_recv_buffs-1+rfdadd].last = RFD_SUSP; /* RU suspend */ 769 770 ptr = (void *) (rfd + (p->num_recv_buffs + rfdadd) ); 771 772 rbd = (struct rbd_struct *) ptr; 773 ptr = (void *) (rbd + p->num_recv_buffs); 774 775 /* clr descriptors */ 776 memset((char *) rbd,0,sizeof(struct rbd_struct)*(p->num_recv_buffs)); 777 778 for(i=0;i<p->num_recv_buffs;i++) 779 { 780 rbd[i].next = make16((rbd + (i+1) % p->num_recv_buffs)); 781 rbd[i].size = RECV_BUFF_SIZE; 782 rbd[i].buffer = make24(ptr); 783 ptr = (char *) ptr + RECV_BUFF_SIZE; 784 } 785 786 p->rfd_top = p->rfd_first; 787 p->rfd_last = p->rfd_first + (p->num_recv_buffs - 1 + rfdadd); 788 789 p->scb->rfa_offset = make16(p->rfd_first); 790 p->rfd_first->rbd_offset = make16(rbd); 791 792 return ptr; 793} 794 795 796/************************************************** 797 * Interrupt Handler ... 798 */ 799 800static irqreturn_t ni52_interrupt(int irq,void *dev_id) 801{ 802 struct net_device *dev = dev_id; 803 unsigned short stat; 804 int cnt=0; 805 struct priv *p; 806 807 if (!dev) { 808 printk ("ni5210-interrupt: irq %d for unknown device.\n",irq); 809 return IRQ_NONE; 810 } 811 p = (struct priv *) dev->priv; 812 813 if(debuglevel > 1) 814 printk("I"); 815 816 WAIT_4_SCB_CMD(); /* wait for last command */ 817 818 while((stat=p->scb->cus & STAT_MASK)) 819 { 820 p->scb->cmd_cuc = stat; 821 ni_attn586(); 822 823 if(stat & STAT_FR) /* received a frame */ 824 ni52_rcv_int(dev); 825 826 if(stat & STAT_RNR) /* RU went 'not ready' */ 827 { 828 printk("(R)"); 829 if(p->scb->rus & RU_SUSPEND) /* special case: RU_SUSPEND */ 830 { 831 WAIT_4_SCB_CMD(); 832 p->scb->cmd_ruc = RUC_RESUME; 833 ni_attn586(); 834 WAIT_4_SCB_CMD_RUC(); 835 } 836 else 837 { 838 printk("%s: Receiver-Unit went 'NOT READY': %04x/%02x.\n",dev->name,(int) stat,(int) p->scb->rus); 839 ni52_rnr_int(dev); 840 } 841 } 842 843 if(stat & STAT_CX) /* command with I-bit set complete */ 844 ni52_xmt_int(dev); 845 846#ifndef NO_NOPCOMMANDS 847 if(stat & STAT_CNA) /* CU went 'not ready' */ 848 { 849 if(netif_running(dev)) 850 printk("%s: oops! CU has left active state. stat: %04x/%02x.\n",dev->name,(int) stat,(int) p->scb->cus); 851 } 852#endif 853 854 if(debuglevel > 1) 855 printk("%d",cnt++); 856 857 WAIT_4_SCB_CMD(); /* wait for ack. (ni52_xmt_int can be faster than ack!!) */ 858 if(p->scb->cmd_cuc) /* timed out? */ 859 { 860 printk("%s: Acknowledge timed out.\n",dev->name); 861 ni_disint(); 862 break; 863 } 864 } 865 866 if(debuglevel > 1) 867 printk("i"); 868 return IRQ_HANDLED; 869} 870 871/******************************************************* 872 * receive-interrupt 873 */ 874 875static void ni52_rcv_int(struct net_device *dev) 876{ 877 int status,cnt=0; 878 unsigned short totlen; 879 struct sk_buff *skb; 880 struct rbd_struct *rbd; 881 struct priv *p = (struct priv *) dev->priv; 882 883 if(debuglevel > 0) 884 printk("R"); 885 886 for(;(status = p->rfd_top->stat_high) & RFD_COMPL;) 887 { 888 rbd = (struct rbd_struct *) make32(p->rfd_top->rbd_offset); 889 890 if(status & RFD_OK) /* frame received without error? */ 891 { 892 if( (totlen = rbd->status) & RBD_LAST) /* the first and the last buffer? */ 893 { 894 totlen &= RBD_MASK; /* length of this frame */ 895 rbd->status = 0; 896 skb = (struct sk_buff *) dev_alloc_skb(totlen+2); 897 if(skb != NULL) 898 { 899 skb_reserve(skb,2); 900 skb_put(skb,totlen); 901 eth_copy_and_sum(skb,(char *) p->base+(unsigned long) rbd->buffer,totlen,0); 902 skb->protocol=eth_type_trans(skb,dev); 903 netif_rx(skb); 904 dev->last_rx = jiffies; 905 p->stats.rx_packets++; 906 p->stats.rx_bytes += totlen; 907 } 908 else 909 p->stats.rx_dropped++; 910 } 911 else 912 { 913 int rstat; 914 /* free all RBD's until RBD_LAST is set */ 915 totlen = 0; 916 while(!((rstat=rbd->status) & RBD_LAST)) 917 { 918 totlen += rstat & RBD_MASK; 919 if(!rstat) 920 { 921 printk("%s: Whoops .. no end mark in RBD list\n",dev->name); 922 break; 923 } 924 rbd->status = 0; 925 rbd = (struct rbd_struct *) make32(rbd->next); 926 } 927 totlen += rstat & RBD_MASK; 928 rbd->status = 0; 929 printk("%s: received oversized frame! length: %d\n",dev->name,totlen); 930 p->stats.rx_dropped++; 931 } 932 } 933 else /* frame !(ok), only with 'save-bad-frames' */ 934 { 935 printk("%s: oops! rfd-error-status: %04x\n",dev->name,status); 936 p->stats.rx_errors++; 937 } 938 p->rfd_top->stat_high = 0; 939 p->rfd_top->last = RFD_SUSP; /* maybe exchange by RFD_LAST */ 940 p->rfd_top->rbd_offset = 0xffff; 941 p->rfd_last->last = 0; /* delete RFD_SUSP */ 942 p->rfd_last = p->rfd_top; 943 p->rfd_top = (struct rfd_struct *) make32(p->rfd_top->next); /* step to next RFD */ 944 p->scb->rfa_offset = make16(p->rfd_top); 945 946 if(debuglevel > 0) 947 printk("%d",cnt++); 948 } 949 950 if(automatic_resume) 951 { 952 WAIT_4_SCB_CMD(); 953 p->scb->cmd_ruc = RUC_RESUME; 954 ni_attn586(); 955 WAIT_4_SCB_CMD_RUC(); 956 } 957 958#ifdef WAIT_4_BUSY 959 { 960 int i; 961 for(i=0;i<1024;i++) 962 { 963 if(p->rfd_top->status) 964 break; 965 DELAY_16(); 966 if(i == 1023) 967 printk("%s: RU hasn't fetched next RFD (not busy/complete)\n",dev->name); 968 } 969 } 970#endif 971 972 973 if(debuglevel > 0) 974 printk("r"); 975} 976 977/********************************************************** 978 * handle 'Receiver went not ready'. 979 */ 980 981static void ni52_rnr_int(struct net_device *dev) 982{ 983 struct priv *p = (struct priv *) dev->priv; 984 985 p->stats.rx_errors++; 986 987 WAIT_4_SCB_CMD(); /* wait for the last cmd, WAIT_4_FULLSTAT?? */ 988 p->scb->cmd_ruc = RUC_ABORT; /* usually the RU is in the 'no resource'-state .. abort it now. */ 989 ni_attn586(); 990 WAIT_4_SCB_CMD_RUC(); /* wait for accept cmd. */ 991 992 alloc_rfa(dev,(char *)p->rfd_first); 993/* maybe add a check here, before restarting the RU */ 994 startrecv586(dev); /* restart RU */ 995 996 printk("%s: Receive-Unit restarted. Status: %04x\n",dev->name,p->scb->rus); 997 998} 999 1000/********************************************************** 1001 * handle xmit - interrupt 1002 */ 1003 1004static void ni52_xmt_int(struct net_device *dev) 1005{ 1006 int status; 1007 struct priv *p = (struct priv *) dev->priv; 1008 1009 if(debuglevel > 0) 1010 printk("X"); 1011 1012 status = p->xmit_cmds[p->xmit_last]->cmd_status; 1013 if(!(status & STAT_COMPL)) 1014 printk("%s: strange .. xmit-int without a 'COMPLETE'\n",dev->name); 1015 1016 if(status & STAT_OK) 1017 { 1018 p->stats.tx_packets++; 1019 p->stats.collisions += (status & TCMD_MAXCOLLMASK); 1020 } 1021 else 1022 { 1023 p->stats.tx_errors++; 1024 if(status & TCMD_LATECOLL) { 1025 printk("%s: late collision detected.\n",dev->name); 1026 p->stats.collisions++; 1027 } 1028 else if(status & TCMD_NOCARRIER) { 1029 p->stats.tx_carrier_errors++; 1030 printk("%s: no carrier detected.\n",dev->name); 1031 } 1032 else if(status & TCMD_LOSTCTS) 1033 printk("%s: loss of CTS detected.\n",dev->name); 1034 else if(status & TCMD_UNDERRUN) { 1035 p->stats.tx_fifo_errors++; 1036 printk("%s: DMA underrun detected.\n",dev->name); 1037 } 1038 else if(status & TCMD_MAXCOLL) { 1039 printk("%s: Max. collisions exceeded.\n",dev->name); 1040 p->stats.collisions += 16; 1041 } 1042 } 1043 1044#if (NUM_XMIT_BUFFS > 1) 1045 if( (++p->xmit_last) == NUM_XMIT_BUFFS) 1046 p->xmit_last = 0; 1047#endif 1048 netif_wake_queue(dev); 1049} 1050 1051/*********************************************************** 1052 * (re)start the receiver 1053 */ 1054 1055static void startrecv586(struct net_device *dev) 1056{ 1057 struct priv *p = (struct priv *) dev->priv; 1058 1059 WAIT_4_SCB_CMD(); 1060 WAIT_4_SCB_CMD_RUC(); 1061 p->scb->rfa_offset = make16(p->rfd_first); 1062 p->scb->cmd_ruc = RUC_START; 1063 ni_attn586(); /* start cmd. */ 1064 WAIT_4_SCB_CMD_RUC(); /* wait for accept cmd. (no timeout!!) */ 1065} 1066 1067static void ni52_timeout(struct net_device *dev) 1068{ 1069 struct priv *p = (struct priv *) dev->priv; 1070#ifndef NO_NOPCOMMANDS 1071 if(p->scb->cus & CU_ACTIVE) /* COMMAND-UNIT active? */ 1072 { 1073 netif_wake_queue(dev); 1074#ifdef DEBUG 1075 printk("%s: strange ... timeout with CU active?!?\n",dev->name); 1076 printk("%s: X0: %04x N0: %04x N1: %04x %d\n",dev->name,(int)p->xmit_cmds[0]->cmd_status,(int)p->nop_cmds[0]->cmd_status,(int)p->nop_cmds[1]->cmd_status,(int)p->nop_point); 1077#endif 1078 p->scb->cmd_cuc = CUC_ABORT; 1079 ni_attn586(); 1080 WAIT_4_SCB_CMD(); 1081 p->scb->cbl_offset = make16(p->nop_cmds[p->nop_point]); 1082 p->scb->cmd_cuc = CUC_START; 1083 ni_attn586(); 1084 WAIT_4_SCB_CMD(); 1085 dev->trans_start = jiffies; 1086 return 0; 1087 } 1088#endif 1089 { 1090#ifdef DEBUG 1091 printk("%s: xmitter timed out, try to restart! stat: %02x\n",dev->name,p->scb->cus); 1092 printk("%s: command-stats: %04x %04x\n",dev->name,p->xmit_cmds[0]->cmd_status,p->xmit_cmds[1]->cmd_status); 1093 printk("%s: check, whether you set the right interrupt number!\n",dev->name); 1094#endif 1095 ni52_close(dev); 1096 ni52_open(dev); 1097 } 1098 dev->trans_start = jiffies; 1099} 1100 1101/****************************************************** 1102 * send frame 1103 */ 1104 1105static int ni52_send_packet(struct sk_buff *skb, struct net_device *dev) 1106{ 1107 int len,i; 1108#ifndef NO_NOPCOMMANDS 1109 int next_nop; 1110#endif 1111 struct priv *p = (struct priv *) dev->priv; 1112 1113 if(skb->len > XMIT_BUFF_SIZE) 1114 { 1115 printk("%s: Sorry, max. framelength is %d bytes. The length of your frame is %d bytes.\n",dev->name,XMIT_BUFF_SIZE,skb->len); 1116 return 0; 1117 } 1118 1119 netif_stop_queue(dev); 1120 1121#if(NUM_XMIT_BUFFS > 1) 1122 if(test_and_set_bit(0,(void *) &p->lock)) { 1123 printk("%s: Queue was locked\n",dev->name); 1124 return 1; 1125 } 1126 else 1127#endif 1128 { 1129 skb_copy_from_linear_data(skb, (char *) p->xmit_cbuffs[p->xmit_count], skb->len); 1130 len = skb->len; 1131 if (len < ETH_ZLEN) { 1132 len = ETH_ZLEN; 1133 memset((char *)p->xmit_cbuffs[p->xmit_count]+skb->len, 0, len - skb->len); 1134 } 1135 1136#if (NUM_XMIT_BUFFS == 1) 1137# ifdef NO_NOPCOMMANDS 1138 1139#ifdef DEBUG 1140 if(p->scb->cus & CU_ACTIVE) 1141 { 1142 printk("%s: Hmmm .. CU is still running and we wanna send a new packet.\n",dev->name); 1143 printk("%s: stat: %04x %04x\n",dev->name,p->scb->cus,p->xmit_cmds[0]->cmd_status); 1144 } 1145#endif 1146 1147 p->xmit_buffs[0]->size = TBD_LAST | len; 1148 for(i=0;i<16;i++) 1149 { 1150 p->xmit_cmds[0]->cmd_status = 0; 1151 WAIT_4_SCB_CMD(); 1152 if( (p->scb->cus & CU_STATUS) == CU_SUSPEND) 1153 p->scb->cmd_cuc = CUC_RESUME; 1154 else 1155 { 1156 p->scb->cbl_offset = make16(p->xmit_cmds[0]); 1157 p->scb->cmd_cuc = CUC_START; 1158 } 1159 1160 ni_attn586(); 1161 dev->trans_start = jiffies; 1162 if(!i) 1163 dev_kfree_skb(skb); 1164 WAIT_4_SCB_CMD(); 1165 if( (p->scb->cus & CU_ACTIVE)) /* test it, because CU sometimes doesn't start immediately */ 1166 break; 1167 if(p->xmit_cmds[0]->cmd_status) 1168 break; 1169 if(i==15) 1170 printk("%s: Can't start transmit-command.\n",dev->name); 1171 } 1172# else 1173 next_nop = (p->nop_point + 1) & 0x1; 1174 p->xmit_buffs[0]->size = TBD_LAST | len; 1175 1176 p->xmit_cmds[0]->cmd_link = p->nop_cmds[next_nop]->cmd_link 1177 = make16((p->nop_cmds[next_nop])); 1178 p->xmit_cmds[0]->cmd_status = p->nop_cmds[next_nop]->cmd_status = 0; 1179 1180 p->nop_cmds[p->nop_point]->cmd_link = make16((p->xmit_cmds[0])); 1181 dev->trans_start = jiffies; 1182 p->nop_point = next_nop; 1183 dev_kfree_skb(skb); 1184# endif 1185#else 1186 p->xmit_buffs[p->xmit_count]->size = TBD_LAST | len; 1187 if( (next_nop = p->xmit_count + 1) == NUM_XMIT_BUFFS ) 1188 next_nop = 0; 1189 1190 p->xmit_cmds[p->xmit_count]->cmd_status = 0; 1191 /* linkpointer of xmit-command already points to next nop cmd */ 1192 p->nop_cmds[next_nop]->cmd_link = make16((p->nop_cmds[next_nop])); 1193 p->nop_cmds[next_nop]->cmd_status = 0; 1194 1195 p->nop_cmds[p->xmit_count]->cmd_link = make16((p->xmit_cmds[p->xmit_count])); 1196 dev->trans_start = jiffies; 1197 p->xmit_count = next_nop; 1198 1199 { 1200 unsigned long flags; 1201 save_flags(flags); 1202 cli(); 1203 if(p->xmit_count != p->xmit_last) 1204 netif_wake_queue(dev); 1205 p->lock = 0; 1206 restore_flags(flags); 1207 } 1208 dev_kfree_skb(skb); 1209#endif 1210 } 1211 return 0; 1212} 1213 1214/******************************************* 1215 * Someone wanna have the statistics 1216 */ 1217 1218static struct net_device_stats *ni52_get_stats(struct net_device *dev) 1219{ 1220 struct priv *p = (struct priv *) dev->priv; 1221 unsigned short crc,aln,rsc,ovrn; 1222 1223 crc = p->scb->crc_errs; /* get error-statistic from the ni82586 */ 1224 p->scb->crc_errs = 0; 1225 aln = p->scb->aln_errs; 1226 p->scb->aln_errs = 0; 1227 rsc = p->scb->rsc_errs; 1228 p->scb->rsc_errs = 0; 1229 ovrn = p->scb->ovrn_errs; 1230 p->scb->ovrn_errs = 0; 1231 1232 p->stats.rx_crc_errors += crc; 1233 p->stats.rx_fifo_errors += ovrn; 1234 p->stats.rx_frame_errors += aln; 1235 p->stats.rx_dropped += rsc; 1236 1237 return &p->stats; 1238} 1239 1240/******************************************************** 1241 * Set MC list .. 1242 */ 1243 1244static void set_multicast_list(struct net_device *dev) 1245{ 1246 netif_stop_queue(dev); 1247 ni_disint(); 1248 alloc586(dev); 1249 init586(dev); 1250 startrecv586(dev); 1251 ni_enaint(); 1252 netif_wake_queue(dev); 1253} 1254 1255#ifdef MODULE 1256static struct net_device *dev_ni52; 1257 1258module_param(io, int, 0); 1259module_param(irq, int, 0); 1260module_param(memstart, long, 0); 1261module_param(memend, long, 0); 1262MODULE_PARM_DESC(io, "NI5210 I/O base address,required"); 1263MODULE_PARM_DESC(irq, "NI5210 IRQ number,required"); 1264MODULE_PARM_DESC(memstart, "NI5210 memory base address,required"); 1265MODULE_PARM_DESC(memend, "NI5210 memory end address,required"); 1266 1267int __init init_module(void) 1268{ 1269 if(io <= 0x0 || !memend || !memstart || irq < 2) { 1270 printk("ni52: Autoprobing not allowed for modules.\nni52: Set symbols 'io' 'irq' 'memstart' and 'memend'\n"); 1271 return -ENODEV; 1272 } 1273 dev_ni52 = ni52_probe(-1); 1274 if (IS_ERR(dev_ni52)) 1275 return PTR_ERR(dev_ni52); 1276 return 0; 1277} 1278 1279void __exit cleanup_module(void) 1280{ 1281 unregister_netdev(dev_ni52); 1282 release_region(dev_ni52->base_addr, NI52_TOTAL_SIZE); 1283 free_netdev(dev_ni52); 1284} 1285#endif /* MODULE */ 1286 1287MODULE_LICENSE("GPL"); 1288 1289/* 1290 * END: linux/drivers/net/ni52.c 1291 */ 1292