1/* 2 net-3-driver for the 3c523 Etherlink/MC card (i82586 Ethernet chip) 3 4 5 This is an extension to the Linux operating system, and is covered by the 6 same GNU General Public License that covers that work. 7 8 Copyright 1995, 1996 by Chris Beauregard (cpbeaure@undergrad.math.uwaterloo.ca) 9 10 This is basically Michael Hipp's ni52 driver, with a new probing 11 algorithm and some minor changes to the 82586 CA and reset routines. 12 Thanks a lot Michael for a really clean i82586 implementation! Unless 13 otherwise documented in ni52.c, any bugs are mine. 14 15 Contrary to the Ethernet-HOWTO, this isn't based on the 3c507 driver in 16 any way. The ni52 is a lot easier to modify. 17 18 sources: 19 ni52.c 20 21 Crynwr packet driver collection was a great reference for my first 22 attempt at this sucker. The 3c507 driver also helped, until I noticed 23 that ni52.c was a lot nicer. 24 25 EtherLink/MC: Micro Channel Ethernet Adapter Technical Reference 26 Manual, courtesy of 3Com CardFacts, documents the 3c523-specific 27 stuff. Information on CardFacts is found in the Ethernet HOWTO. 28 Also see <a href="http://www.3com.com/"> 29 30 Microprocessor Communications Support Chips, T.J. Byers, ISBN 31 0-444-01224-9, has a section on the i82586. It tells you just enough 32 to know that you really don't want to learn how to program the chip. 33 34 The original device probe code was stolen from ps2esdi.c 35 36 Known Problems: 37 Since most of the code was stolen from ni52.c, you'll run across the 38 same bugs in the 0.62 version of ni52.c, plus maybe a few because of 39 the 3c523 idiosynchacies. The 3c523 has 16K of RAM though, so there 40 shouldn't be the overrun problem that the 8K ni52 has. 41 42 This driver is for a 16K adapter. It should work fine on the 64K 43 adapters, but it will only use one of the 4 banks of RAM. Modifying 44 this for the 64K version would require a lot of heinous bank 45 switching, which I'm sure not interested in doing. If you try to 46 implement a bank switching version, you'll basically have to remember 47 what bank is enabled and do a switch everytime you access a memory 48 location that's not current. You'll also have to remap pointers on 49 the driver side, because it only knows about 16K of the memory. 50 Anyone desperate or masochistic enough to try? 51 52 It seems to be stable now when multiple transmit buffers are used. I 53 can't see any performance difference, but then I'm working on a 386SX. 54 55 Multicast doesn't work. It doesn't even pretend to work. Don't use 56 it. Don't compile your kernel with multicast support. I don't know 57 why. 58 59 Features: 60 This driver is useable as a loadable module. If you try to specify an 61 IRQ or a IO address (via insmod 3c523.o irq=xx io=0xyyy), it will 62 search the MCA slots until it finds a 3c523 with the specified 63 parameters. 64 65 This driver does support multiple ethernet cards when used as a module 66 (up to MAX_3C523_CARDS, the default being 4) 67 68 This has been tested with both BNC and TP versions, internal and 69 external transceivers. Haven't tested with the 64K version (that I 70 know of). 71 72 History: 73 Jan 1st, 1996 74 first public release 75 Feb 4th, 1996 76 update to 1.3.59, incorporated multicast diffs from ni52.c 77 Feb 15th, 1996 78 added shared irq support 79 Apr 1999 80 added support for multiple cards when used as a module 81 added option to disable multicast as is causes problems 82 Ganesh Sittampalam <ganesh.sittampalam@magdalen.oxford.ac.uk> 83 Stuart Adamson <stuart.adamson@compsoc.net> 84 Nov 2001 85 added support for ethtool (jgarzik) 86 87 $Header: /fsys2/home/chrisb/linux-1.3.59-MCA/drivers/net/RCS/3c523.c,v 1.1 1996/02/05 01:53:46 chrisb Exp chrisb $ 88 */ 89 90#define DRV_NAME "3c523" 91#define DRV_VERSION "17-Nov-2001" 92 93#include <linux/init.h> 94#include <linux/netdevice.h> 95#include <linux/etherdevice.h> 96#include <linux/module.h> 97#include <linux/kernel.h> 98#include <linux/string.h> 99#include <linux/errno.h> 100#include <linux/ioport.h> 101#include <linux/skbuff.h> 102#include <linux/interrupt.h> 103#include <linux/delay.h> 104#include <linux/mca-legacy.h> 105#include <linux/ethtool.h> 106#include <linux/bitops.h> 107#include <linux/jiffies.h> 108 109#include <asm/uaccess.h> 110#include <asm/processor.h> 111#include <asm/io.h> 112 113#include "3c523.h" 114 115/*************************************************************************/ 116#define DEBUG /* debug on */ 117#define SYSBUSVAL 0 /* 1 = 8 Bit, 0 = 16 bit - 3c523 only does 16 bit */ 118#undef ELMC_MULTICAST /* Disable multicast support as it is somewhat seriously broken at the moment */ 119 120#define make32(ptr16) (p->memtop + (short) (ptr16) ) 121#define make24(ptr32) ((char *) (ptr32) - p->base) 122#define make16(ptr32) ((unsigned short) ((unsigned long) (ptr32) - (unsigned long) p->memtop )) 123 124/*************************************************************************/ 125/* 126 Tables to which we can map values in the configuration registers. 127 */ 128static int irq_table[] __initdata = { 129 12, 7, 3, 9 130}; 131 132static int csr_table[] __initdata = { 133 0x300, 0x1300, 0x2300, 0x3300 134}; 135 136static int shm_table[] __initdata = { 137 0x0c0000, 0x0c8000, 0x0d0000, 0x0d8000 138}; 139 140/******************* how to calculate the buffers ***************************** 141 142 143 * IMPORTANT NOTE: if you configure only one NUM_XMIT_BUFFS, the driver works 144 * --------------- in a different (more stable?) mode. Only in this mode it's 145 * possible to configure the driver with 'NO_NOPCOMMANDS' 146 147sizeof(scp)=12; sizeof(scb)=16; sizeof(iscp)=8; 148sizeof(scp)+sizeof(iscp)+sizeof(scb) = 36 = INIT 149sizeof(rfd) = 24; sizeof(rbd) = 12; 150sizeof(tbd) = 8; sizeof(transmit_cmd) = 16; 151sizeof(nop_cmd) = 8; 152 153 * if you don't know the driver, better do not change this values: */ 154 155#define RECV_BUFF_SIZE 1524 /* slightly oversized */ 156#define XMIT_BUFF_SIZE 1524 /* slightly oversized */ 157#define NUM_XMIT_BUFFS 1 /* config for both, 8K and 16K shmem */ 158#define NUM_RECV_BUFFS_8 4 /* config for 8K shared mem */ 159#define NUM_RECV_BUFFS_16 9 /* config for 16K shared mem */ 160 161#if (NUM_XMIT_BUFFS == 1) 162#define NO_NOPCOMMANDS /* only possible with NUM_XMIT_BUFFS=1 */ 163#endif 164 165/**************************************************************************/ 166 167#define DELAY(x) { mdelay(32 * x); } 168 169/* a much shorter delay: */ 170#define DELAY_16(); { udelay(16) ; } 171 172/* wait for command with timeout: */ 173#define WAIT_4_SCB_CMD() { int i; \ 174 for(i=0;i<1024;i++) { \ 175 if(!p->scb->cmd) break; \ 176 DELAY_16(); \ 177 if(i == 1023) { \ 178 pr_warning("%s:%d: scb_cmd timed out .. resetting i82586\n",\ 179 dev->name,__LINE__); \ 180 elmc_id_reset586(); } } } 181 182static irqreturn_t elmc_interrupt(int irq, void *dev_id); 183static int elmc_open(struct net_device *dev); 184static int elmc_close(struct net_device *dev); 185static netdev_tx_t elmc_send_packet(struct sk_buff *, struct net_device *); 186static struct net_device_stats *elmc_get_stats(struct net_device *dev); 187static void elmc_timeout(struct net_device *dev); 188#ifdef ELMC_MULTICAST 189static void set_multicast_list(struct net_device *dev); 190#endif 191static const struct ethtool_ops netdev_ethtool_ops; 192 193/* helper-functions */ 194static int init586(struct net_device *dev); 195static int check586(struct net_device *dev, unsigned long where, unsigned size); 196static void alloc586(struct net_device *dev); 197static void startrecv586(struct net_device *dev); 198static void *alloc_rfa(struct net_device *dev, void *ptr); 199static void elmc_rcv_int(struct net_device *dev); 200static void elmc_xmt_int(struct net_device *dev); 201static void elmc_rnr_int(struct net_device *dev); 202 203struct priv { 204 unsigned long base; 205 char *memtop; 206 unsigned long mapped_start; /* Start of ioremap */ 207 volatile struct rfd_struct *rfd_last, *rfd_top, *rfd_first; 208 volatile struct scp_struct *scp; /* volatile is important */ 209 volatile struct iscp_struct *iscp; /* volatile is important */ 210 volatile struct scb_struct *scb; /* volatile is important */ 211 volatile struct tbd_struct *xmit_buffs[NUM_XMIT_BUFFS]; 212#if (NUM_XMIT_BUFFS == 1) 213 volatile struct transmit_cmd_struct *xmit_cmds[2]; 214 volatile struct nop_cmd_struct *nop_cmds[2]; 215#else 216 volatile struct transmit_cmd_struct *xmit_cmds[NUM_XMIT_BUFFS]; 217 volatile struct nop_cmd_struct *nop_cmds[NUM_XMIT_BUFFS]; 218#endif 219 volatile int nop_point, num_recv_buffs; 220 volatile char *xmit_cbuffs[NUM_XMIT_BUFFS]; 221 volatile int xmit_count, xmit_last; 222 volatile int slot; 223}; 224 225#define elmc_attn586() {elmc_do_attn586(dev->base_addr,ELMC_CTRL_INTE);} 226#define elmc_reset586() {elmc_do_reset586(dev->base_addr,ELMC_CTRL_INTE);} 227 228/* with interrupts disabled - this will clear the interrupt bit in the 229 3c523 control register, and won't put it back. This effectively 230 disables interrupts on the card. */ 231#define elmc_id_attn586() {elmc_do_attn586(dev->base_addr,0);} 232#define elmc_id_reset586() {elmc_do_reset586(dev->base_addr,0);} 233 234/*************************************************************************/ 235/* 236 Do a Channel Attention on the 3c523. This is extremely board dependent. 237 */ 238static void elmc_do_attn586(int ioaddr, int ints) 239{ 240 /* the 3c523 requires a minimum of 500 ns. The delays here might be 241 a little too large, and hence they may cut the performance of the 242 card slightly. If someone who knows a little more about Linux 243 timing would care to play with these, I'd appreciate it. */ 244 245 /* this bit masking stuff is crap. I'd rather have separate 246 registers with strobe triggers for each of these functions. <sigh> 247 Ya take what ya got. */ 248 249 outb(ELMC_CTRL_RST | 0x3 | ELMC_CTRL_CA | ints, ioaddr + ELMC_CTRL); 250 DELAY_16(); /* > 500 ns */ 251 outb(ELMC_CTRL_RST | 0x3 | ints, ioaddr + ELMC_CTRL); 252} 253 254/*************************************************************************/ 255/* 256 Reset the 82586 on the 3c523. Also very board dependent. 257 */ 258static void elmc_do_reset586(int ioaddr, int ints) 259{ 260 /* toggle the RST bit low then high */ 261 outb(0x3 | ELMC_CTRL_LBK, ioaddr + ELMC_CTRL); 262 DELAY_16(); /* > 500 ns */ 263 outb(ELMC_CTRL_RST | ELMC_CTRL_LBK | 0x3, ioaddr + ELMC_CTRL); 264 265 elmc_do_attn586(ioaddr, ints); 266} 267 268/********************************************** 269 * close device 270 */ 271 272static int elmc_close(struct net_device *dev) 273{ 274 netif_stop_queue(dev); 275 elmc_id_reset586(); /* the hard way to stop the receiver */ 276 free_irq(dev->irq, dev); 277 return 0; 278} 279 280/********************************************** 281 * open device 282 */ 283 284static int elmc_open(struct net_device *dev) 285{ 286 int ret; 287 288 elmc_id_attn586(); /* disable interrupts */ 289 290 ret = request_irq(dev->irq, elmc_interrupt, IRQF_SHARED | IRQF_SAMPLE_RANDOM, 291 dev->name, dev); 292 if (ret) { 293 pr_err("%s: couldn't get irq %d\n", dev->name, dev->irq); 294 elmc_id_reset586(); 295 return ret; 296 } 297 alloc586(dev); 298 init586(dev); 299 startrecv586(dev); 300 netif_start_queue(dev); 301 return 0; /* most done by init */ 302} 303 304/********************************************** 305 * Check to see if there's an 82586 out there. 306 */ 307 308static int __init check586(struct net_device *dev, unsigned long where, unsigned size) 309{ 310 struct priv *p = netdev_priv(dev); 311 char *iscp_addrs[2]; 312 int i = 0; 313 314 p->base = (unsigned long) isa_bus_to_virt((unsigned long)where) + size - 0x01000000; 315 p->memtop = isa_bus_to_virt((unsigned long)where) + size; 316 p->scp = (struct scp_struct *)(p->base + SCP_DEFAULT_ADDRESS); 317 memset((char *) p->scp, 0, sizeof(struct scp_struct)); 318 p->scp->sysbus = SYSBUSVAL; /* 1 = 8Bit-Bus, 0 = 16 Bit */ 319 320 iscp_addrs[0] = isa_bus_to_virt((unsigned long)where); 321 iscp_addrs[1] = (char *) p->scp - sizeof(struct iscp_struct); 322 323 for (i = 0; i < 2; i++) { 324 p->iscp = (struct iscp_struct *) iscp_addrs[i]; 325 memset((char *) p->iscp, 0, sizeof(struct iscp_struct)); 326 327 p->scp->iscp = make24(p->iscp); 328 p->iscp->busy = 1; 329 330 elmc_id_reset586(); 331 332 /* reset586 does an implicit CA */ 333 334 /* apparently, you sometimes have to kick the 82586 twice... */ 335 elmc_id_attn586(); 336 DELAY(1); 337 338 if (p->iscp->busy) { /* i82586 clears 'busy' after successful init */ 339 return 0; 340 } 341 } 342 return 1; 343} 344 345/****************************************************************** 346 * set iscp at the right place, called by elmc_probe and open586. 347 */ 348 349static void alloc586(struct net_device *dev) 350{ 351 struct priv *p = netdev_priv(dev); 352 353 elmc_id_reset586(); 354 DELAY(2); 355 356 p->scp = (struct scp_struct *) (p->base + SCP_DEFAULT_ADDRESS); 357 p->scb = (struct scb_struct *) isa_bus_to_virt(dev->mem_start); 358 p->iscp = (struct iscp_struct *) ((char *) p->scp - sizeof(struct iscp_struct)); 359 360 memset((char *) p->iscp, 0, sizeof(struct iscp_struct)); 361 memset((char *) p->scp, 0, sizeof(struct scp_struct)); 362 363 p->scp->iscp = make24(p->iscp); 364 p->scp->sysbus = SYSBUSVAL; 365 p->iscp->scb_offset = make16(p->scb); 366 367 p->iscp->busy = 1; 368 elmc_id_reset586(); 369 elmc_id_attn586(); 370 371 DELAY(2); 372 373 if (p->iscp->busy) 374 pr_err("%s: Init-Problems (alloc).\n", dev->name); 375 376 memset((char *) p->scb, 0, sizeof(struct scb_struct)); 377} 378 379/*****************************************************************/ 380 381static int elmc_getinfo(char *buf, int slot, void *d) 382{ 383 int len = 0; 384 struct net_device *dev = d; 385 386 if (dev == NULL) 387 return len; 388 389 len += sprintf(buf + len, "Revision: 0x%x\n", 390 inb(dev->base_addr + ELMC_REVISION) & 0xf); 391 len += sprintf(buf + len, "IRQ: %d\n", dev->irq); 392 len += sprintf(buf + len, "IO Address: %#lx-%#lx\n", dev->base_addr, 393 dev->base_addr + ELMC_IO_EXTENT); 394 len += sprintf(buf + len, "Memory: %#lx-%#lx\n", dev->mem_start, 395 dev->mem_end - 1); 396 len += sprintf(buf + len, "Transceiver: %s\n", dev->if_port ? 397 "External" : "Internal"); 398 len += sprintf(buf + len, "Device: %s\n", dev->name); 399 len += sprintf(buf + len, "Hardware Address: %pM\n", 400 dev->dev_addr); 401 402 return len; 403} /* elmc_getinfo() */ 404 405static const struct net_device_ops netdev_ops = { 406 .ndo_open = elmc_open, 407 .ndo_stop = elmc_close, 408 .ndo_get_stats = elmc_get_stats, 409 .ndo_start_xmit = elmc_send_packet, 410 .ndo_tx_timeout = elmc_timeout, 411#ifdef ELMC_MULTICAST 412 .ndo_set_multicast_list = set_multicast_list, 413#endif 414 .ndo_change_mtu = eth_change_mtu, 415 .ndo_set_mac_address = eth_mac_addr, 416 .ndo_validate_addr = eth_validate_addr, 417}; 418 419/*****************************************************************/ 420 421static int __init do_elmc_probe(struct net_device *dev) 422{ 423 static int slot; 424 int base_addr = dev->base_addr; 425 int irq = dev->irq; 426 u_char status = 0; 427 u_char revision = 0; 428 int i = 0; 429 unsigned int size = 0; 430 int retval; 431 struct priv *pr = netdev_priv(dev); 432 433 if (MCA_bus == 0) { 434 return -ENODEV; 435 } 436 /* search through the slots for the 3c523. */ 437 slot = mca_find_adapter(ELMC_MCA_ID, 0); 438 while (slot != -1) { 439 status = mca_read_stored_pos(slot, 2); 440 441 dev->irq=irq_table[(status & ELMC_STATUS_IRQ_SELECT) >> 6]; 442 dev->base_addr=csr_table[(status & ELMC_STATUS_CSR_SELECT) >> 1]; 443 444 /* 445 If we're trying to match a specified irq or IO address, 446 we'll reject a match unless it's what we're looking for. 447 Also reject it if the card is already in use. 448 */ 449 450 if ((irq && irq != dev->irq) || 451 (base_addr && base_addr != dev->base_addr)) { 452 slot = mca_find_adapter(ELMC_MCA_ID, slot + 1); 453 continue; 454 } 455 if (!request_region(dev->base_addr, ELMC_IO_EXTENT, DRV_NAME)) { 456 slot = mca_find_adapter(ELMC_MCA_ID, slot + 1); 457 continue; 458 } 459 460 /* found what we're looking for... */ 461 break; 462 } 463 464 /* we didn't find any 3c523 in the slots we checked for */ 465 if (slot == MCA_NOTFOUND) 466 return ((base_addr || irq) ? -ENXIO : -ENODEV); 467 468 mca_set_adapter_name(slot, "3Com 3c523 Etherlink/MC"); 469 mca_set_adapter_procfn(slot, (MCA_ProcFn) elmc_getinfo, dev); 470 471 /* if we get this far, adapter has been found - carry on */ 472 pr_info("%s: 3c523 adapter found in slot %d\n", dev->name, slot + 1); 473 474 /* Now we extract configuration info from the card. 475 The 3c523 provides information in two of the POS registers, but 476 the second one is only needed if we want to tell the card what IRQ 477 to use. I suspect that whoever sets the thing up initially would 478 prefer we don't screw with those things. 479 480 Note that we read the status info when we found the card... 481 482 See 3c523.h for more details. 483 */ 484 485 /* revision is stored in the first 4 bits of the revision register */ 486 revision = inb(dev->base_addr + ELMC_REVISION) & 0xf; 487 488 /* according to docs, we read the interrupt and write it back to 489 the IRQ select register, since the POST might not configure the IRQ 490 properly. */ 491 switch (dev->irq) { 492 case 3: 493 mca_write_pos(slot, 3, 0x04); 494 break; 495 case 7: 496 mca_write_pos(slot, 3, 0x02); 497 break; 498 case 9: 499 mca_write_pos(slot, 3, 0x08); 500 break; 501 case 12: 502 mca_write_pos(slot, 3, 0x01); 503 break; 504 } 505 506 pr->slot = slot; 507 508 pr_info("%s: 3Com 3c523 Rev 0x%x at %#lx\n", dev->name, (int) revision, 509 dev->base_addr); 510 511 /* Determine if we're using the on-board transceiver (i.e. coax) or 512 an external one. The information is pretty much useless, but I 513 guess it's worth brownie points. */ 514 dev->if_port = (status & ELMC_STATUS_DISABLE_THIN); 515 516 /* The 3c523 has a 24K chunk of memory. The first 16K is the 517 shared memory, while the last 8K is for the EtherStart BIOS ROM. 518 Which we don't care much about here. We'll just tell Linux that 519 we're using 16K. MCA won't permit address space conflicts caused 520 by not mapping the other 8K. */ 521 dev->mem_start = shm_table[(status & ELMC_STATUS_MEMORY_SELECT) >> 3]; 522 523 /* We're using MCA, so it's a given that the information about memory 524 size is correct. The Crynwr drivers do something like this. */ 525 526 elmc_id_reset586(); /* seems like a good idea before checking it... */ 527 528 size = 0x4000; /* check for 16K mem */ 529 if (!check586(dev, dev->mem_start, size)) { 530 pr_err("%s: memprobe, Can't find memory at 0x%lx!\n", dev->name, 531 dev->mem_start); 532 retval = -ENODEV; 533 goto err_out; 534 } 535 dev->mem_end = dev->mem_start + size; /* set mem_end showed by 'ifconfig' */ 536 537 pr->memtop = isa_bus_to_virt(dev->mem_start) + size; 538 pr->base = (unsigned long) isa_bus_to_virt(dev->mem_start) + size - 0x01000000; 539 alloc586(dev); 540 541 elmc_id_reset586(); /* make sure it doesn't generate spurious ints */ 542 543 /* set number of receive-buffs according to memsize */ 544 pr->num_recv_buffs = NUM_RECV_BUFFS_16; 545 546 /* dump all the assorted information */ 547 pr_info("%s: IRQ %d, %sternal xcvr, memory %#lx-%#lx.\n", dev->name, 548 dev->irq, dev->if_port ? "ex" : "in", 549 dev->mem_start, dev->mem_end - 1); 550 551 /* The hardware address for the 3c523 is stored in the first six 552 bytes of the IO address. */ 553 for (i = 0; i < 6; i++) 554 dev->dev_addr[i] = inb(dev->base_addr + i); 555 556 pr_info("%s: hardware address %pM\n", 557 dev->name, dev->dev_addr); 558 559 dev->netdev_ops = &netdev_ops; 560 dev->watchdog_timeo = HZ; 561 dev->ethtool_ops = &netdev_ethtool_ops; 562 563 /* note that we haven't actually requested the IRQ from the kernel. 564 That gets done in elmc_open(). I'm not sure that's such a good idea, 565 but it works, so I'll go with it. */ 566 567#ifndef ELMC_MULTICAST 568 dev->flags&=~IFF_MULTICAST; /* Multicast doesn't work */ 569#endif 570 571 retval = register_netdev(dev); 572 if (retval) 573 goto err_out; 574 575 return 0; 576err_out: 577 mca_set_adapter_procfn(slot, NULL, NULL); 578 release_region(dev->base_addr, ELMC_IO_EXTENT); 579 return retval; 580} 581 582#ifdef MODULE 583static void cleanup_card(struct net_device *dev) 584{ 585 mca_set_adapter_procfn(((struct priv *)netdev_priv(dev))->slot, 586 NULL, NULL); 587 release_region(dev->base_addr, ELMC_IO_EXTENT); 588} 589#else 590struct net_device * __init elmc_probe(int unit) 591{ 592 struct net_device *dev = alloc_etherdev(sizeof(struct priv)); 593 int err; 594 595 if (!dev) 596 return ERR_PTR(-ENOMEM); 597 598 sprintf(dev->name, "eth%d", unit); 599 netdev_boot_setup_check(dev); 600 601 err = do_elmc_probe(dev); 602 if (err) 603 goto out; 604 return dev; 605out: 606 free_netdev(dev); 607 return ERR_PTR(err); 608} 609#endif 610 611/********************************************** 612 * init the chip (elmc-interrupt should be disabled?!) 613 * needs a correct 'allocated' memory 614 */ 615 616static int init586(struct net_device *dev) 617{ 618 void *ptr; 619 unsigned long s; 620 int i, result = 0; 621 struct priv *p = netdev_priv(dev); 622 volatile struct configure_cmd_struct *cfg_cmd; 623 volatile struct iasetup_cmd_struct *ias_cmd; 624 volatile struct tdr_cmd_struct *tdr_cmd; 625 volatile struct mcsetup_cmd_struct *mc_cmd; 626 struct netdev_hw_addr *ha; 627 int num_addrs = netdev_mc_count(dev); 628 629 ptr = (void *) ((char *) p->scb + sizeof(struct scb_struct)); 630 631 cfg_cmd = (struct configure_cmd_struct *) ptr; /* configure-command */ 632 cfg_cmd->cmd_status = 0; 633 cfg_cmd->cmd_cmd = CMD_CONFIGURE | CMD_LAST; 634 cfg_cmd->cmd_link = 0xffff; 635 636 cfg_cmd->byte_cnt = 0x0a; /* number of cfg bytes */ 637 cfg_cmd->fifo = 0x08; /* fifo-limit (8=tx:32/rx:64) */ 638 cfg_cmd->sav_bf = 0x40; /* hold or discard bad recv frames (bit 7) */ 639 cfg_cmd->adr_len = 0x2e; /* addr_len |!src_insert |pre-len |loopback */ 640 cfg_cmd->priority = 0x00; 641 cfg_cmd->ifs = 0x60; 642 cfg_cmd->time_low = 0x00; 643 cfg_cmd->time_high = 0xf2; 644 cfg_cmd->promisc = 0; 645 if (dev->flags & (IFF_ALLMULTI | IFF_PROMISC)) 646 cfg_cmd->promisc = 1; 647 cfg_cmd->carr_coll = 0x00; 648 649 p->scb->cbl_offset = make16(cfg_cmd); 650 651 p->scb->cmd = CUC_START; /* cmd.-unit start */ 652 elmc_id_attn586(); 653 654 s = jiffies; /* warning: only active with interrupts on !! */ 655 while (!(cfg_cmd->cmd_status & STAT_COMPL)) { 656 if (time_after(jiffies, s + 30*HZ/100)) 657 break; 658 } 659 660 if ((cfg_cmd->cmd_status & (STAT_OK | STAT_COMPL)) != (STAT_COMPL | STAT_OK)) { 661 pr_warning("%s (elmc): configure command failed: %x\n", dev->name, cfg_cmd->cmd_status); 662 return 1; 663 } 664 /* 665 * individual address setup 666 */ 667 ias_cmd = (struct iasetup_cmd_struct *) ptr; 668 669 ias_cmd->cmd_status = 0; 670 ias_cmd->cmd_cmd = CMD_IASETUP | CMD_LAST; 671 ias_cmd->cmd_link = 0xffff; 672 673 memcpy((char *) &ias_cmd->iaddr, (char *) dev->dev_addr, ETH_ALEN); 674 675 p->scb->cbl_offset = make16(ias_cmd); 676 677 p->scb->cmd = CUC_START; /* cmd.-unit start */ 678 elmc_id_attn586(); 679 680 s = jiffies; 681 while (!(ias_cmd->cmd_status & STAT_COMPL)) { 682 if (time_after(jiffies, s + 30*HZ/100)) 683 break; 684 } 685 686 if ((ias_cmd->cmd_status & (STAT_OK | STAT_COMPL)) != (STAT_OK | STAT_COMPL)) { 687 pr_warning("%s (elmc): individual address setup command failed: %04x\n", 688 dev->name, ias_cmd->cmd_status); 689 return 1; 690 } 691 /* 692 * TDR, wire check .. e.g. no resistor e.t.c 693 */ 694 tdr_cmd = (struct tdr_cmd_struct *) ptr; 695 696 tdr_cmd->cmd_status = 0; 697 tdr_cmd->cmd_cmd = CMD_TDR | CMD_LAST; 698 tdr_cmd->cmd_link = 0xffff; 699 tdr_cmd->status = 0; 700 701 p->scb->cbl_offset = make16(tdr_cmd); 702 703 p->scb->cmd = CUC_START; /* cmd.-unit start */ 704 elmc_attn586(); 705 706 s = jiffies; 707 while (!(tdr_cmd->cmd_status & STAT_COMPL)) { 708 if (time_after(jiffies, s + 30*HZ/100)) { 709 pr_warning("%s: %d Problems while running the TDR.\n", dev->name, __LINE__); 710 result = 1; 711 break; 712 } 713 } 714 715 if (!result) { 716 DELAY(2); /* wait for result */ 717 result = tdr_cmd->status; 718 719 p->scb->cmd = p->scb->status & STAT_MASK; 720 elmc_id_attn586(); /* ack the interrupts */ 721 722 if (result & TDR_LNK_OK) { 723 /* empty */ 724 } else if (result & TDR_XCVR_PRB) { 725 pr_warning("%s: TDR: Transceiver problem!\n", dev->name); 726 } else if (result & TDR_ET_OPN) { 727 pr_warning("%s: TDR: No correct termination %d clocks away.\n", dev->name, result & TDR_TIMEMASK); 728 } else if (result & TDR_ET_SRT) { 729 if (result & TDR_TIMEMASK) /* time == 0 -> strange :-) */ 730 pr_warning("%s: TDR: Detected a short circuit %d clocks away.\n", dev->name, result & TDR_TIMEMASK); 731 } else { 732 pr_warning("%s: TDR: Unknown status %04x\n", dev->name, result); 733 } 734 } 735 /* 736 * ack interrupts 737 */ 738 p->scb->cmd = p->scb->status & STAT_MASK; 739 elmc_id_attn586(); 740 741 /* 742 * alloc nop/xmit-cmds 743 */ 744#if (NUM_XMIT_BUFFS == 1) 745 for (i = 0; i < 2; i++) { 746 p->nop_cmds[i] = (struct nop_cmd_struct *) ptr; 747 p->nop_cmds[i]->cmd_cmd = CMD_NOP; 748 p->nop_cmds[i]->cmd_status = 0; 749 p->nop_cmds[i]->cmd_link = make16((p->nop_cmds[i])); 750 ptr = (char *) ptr + sizeof(struct nop_cmd_struct); 751 } 752 p->xmit_cmds[0] = (struct transmit_cmd_struct *) ptr; /* transmit cmd/buff 0 */ 753 ptr = (char *) ptr + sizeof(struct transmit_cmd_struct); 754#else 755 for (i = 0; i < NUM_XMIT_BUFFS; i++) { 756 p->nop_cmds[i] = (struct nop_cmd_struct *) ptr; 757 p->nop_cmds[i]->cmd_cmd = CMD_NOP; 758 p->nop_cmds[i]->cmd_status = 0; 759 p->nop_cmds[i]->cmd_link = make16((p->nop_cmds[i])); 760 ptr = (char *) ptr + sizeof(struct nop_cmd_struct); 761 p->xmit_cmds[i] = (struct transmit_cmd_struct *) ptr; /*transmit cmd/buff 0 */ 762 ptr = (char *) ptr + sizeof(struct transmit_cmd_struct); 763 } 764#endif 765 766 ptr = alloc_rfa(dev, (void *) ptr); /* init receive-frame-area */ 767 768 /* 769 * Multicast setup 770 */ 771 772 if (num_addrs) { 773 /* I don't understand this: do we really need memory after the init? */ 774 int len = ((char *) p->iscp - (char *) ptr - 8) / 6; 775 if (len <= 0) { 776 pr_err("%s: Ooooops, no memory for MC-Setup!\n", dev->name); 777 } else { 778 if (len < num_addrs) { 779 num_addrs = len; 780 pr_warning("%s: Sorry, can only apply %d MC-Address(es).\n", 781 dev->name, num_addrs); 782 } 783 mc_cmd = (struct mcsetup_cmd_struct *) ptr; 784 mc_cmd->cmd_status = 0; 785 mc_cmd->cmd_cmd = CMD_MCSETUP | CMD_LAST; 786 mc_cmd->cmd_link = 0xffff; 787 mc_cmd->mc_cnt = num_addrs * 6; 788 i = 0; 789 netdev_for_each_mc_addr(ha, dev) 790 memcpy((char *) mc_cmd->mc_list[i++], 791 ha->addr, 6); 792 p->scb->cbl_offset = make16(mc_cmd); 793 p->scb->cmd = CUC_START; 794 elmc_id_attn586(); 795 s = jiffies; 796 while (!(mc_cmd->cmd_status & STAT_COMPL)) { 797 if (time_after(jiffies, s + 30*HZ/100)) 798 break; 799 } 800 if (!(mc_cmd->cmd_status & STAT_COMPL)) { 801 pr_warning("%s: Can't apply multicast-address-list.\n", dev->name); 802 } 803 } 804 } 805 /* 806 * alloc xmit-buffs / init xmit_cmds 807 */ 808 for (i = 0; i < NUM_XMIT_BUFFS; i++) { 809 p->xmit_cbuffs[i] = (char *) ptr; /* char-buffs */ 810 ptr = (char *) ptr + XMIT_BUFF_SIZE; 811 p->xmit_buffs[i] = (struct tbd_struct *) ptr; /* TBD */ 812 ptr = (char *) ptr + sizeof(struct tbd_struct); 813 if ((void *) ptr > (void *) p->iscp) { 814 pr_err("%s: not enough shared-mem for your configuration!\n", dev->name); 815 return 1; 816 } 817 memset((char *) (p->xmit_cmds[i]), 0, sizeof(struct transmit_cmd_struct)); 818 memset((char *) (p->xmit_buffs[i]), 0, sizeof(struct tbd_struct)); 819 p->xmit_cmds[i]->cmd_status = STAT_COMPL; 820 p->xmit_cmds[i]->cmd_cmd = CMD_XMIT | CMD_INT; 821 p->xmit_cmds[i]->tbd_offset = make16((p->xmit_buffs[i])); 822 p->xmit_buffs[i]->next = 0xffff; 823 p->xmit_buffs[i]->buffer = make24((p->xmit_cbuffs[i])); 824 } 825 826 p->xmit_count = 0; 827 p->xmit_last = 0; 828#ifndef NO_NOPCOMMANDS 829 p->nop_point = 0; 830#endif 831 832 /* 833 * 'start transmitter' (nop-loop) 834 */ 835#ifndef NO_NOPCOMMANDS 836 p->scb->cbl_offset = make16(p->nop_cmds[0]); 837 p->scb->cmd = CUC_START; 838 elmc_id_attn586(); 839 WAIT_4_SCB_CMD(); 840#else 841 p->xmit_cmds[0]->cmd_link = 0xffff; 842 p->xmit_cmds[0]->cmd_cmd = CMD_XMIT | CMD_LAST | CMD_INT; 843#endif 844 845 return 0; 846} 847 848/****************************************************** 849 * This is a helper routine for elmc_rnr_int() and init586(). 850 * It sets up the Receive Frame Area (RFA). 851 */ 852 853static void *alloc_rfa(struct net_device *dev, void *ptr) 854{ 855 volatile struct rfd_struct *rfd = (struct rfd_struct *) ptr; 856 volatile struct rbd_struct *rbd; 857 int i; 858 struct priv *p = netdev_priv(dev); 859 860 memset((char *) rfd, 0, sizeof(struct rfd_struct) * p->num_recv_buffs); 861 p->rfd_first = rfd; 862 863 for (i = 0; i < p->num_recv_buffs; i++) { 864 rfd[i].next = make16(rfd + (i + 1) % p->num_recv_buffs); 865 } 866 rfd[p->num_recv_buffs - 1].last = RFD_SUSP; /* RU suspend */ 867 868 ptr = (void *) (rfd + p->num_recv_buffs); 869 870 rbd = (struct rbd_struct *) ptr; 871 ptr = (void *) (rbd + p->num_recv_buffs); 872 873 /* clr descriptors */ 874 memset((char *) rbd, 0, sizeof(struct rbd_struct) * p->num_recv_buffs); 875 876 for (i = 0; i < p->num_recv_buffs; i++) { 877 rbd[i].next = make16((rbd + (i + 1) % p->num_recv_buffs)); 878 rbd[i].size = RECV_BUFF_SIZE; 879 rbd[i].buffer = make24(ptr); 880 ptr = (char *) ptr + RECV_BUFF_SIZE; 881 } 882 883 p->rfd_top = p->rfd_first; 884 p->rfd_last = p->rfd_first + p->num_recv_buffs - 1; 885 886 p->scb->rfa_offset = make16(p->rfd_first); 887 p->rfd_first->rbd_offset = make16(rbd); 888 889 return ptr; 890} 891 892 893/************************************************** 894 * Interrupt Handler ... 895 */ 896 897static irqreturn_t 898elmc_interrupt(int irq, void *dev_id) 899{ 900 struct net_device *dev = dev_id; 901 unsigned short stat; 902 struct priv *p; 903 904 if (!netif_running(dev)) { 905 /* The 3c523 has this habit of generating interrupts during the 906 reset. I'm not sure if the ni52 has this same problem, but it's 907 really annoying if we haven't finished initializing it. I was 908 hoping all the elmc_id_* commands would disable this, but I 909 might have missed a few. */ 910 911 elmc_id_attn586(); /* ack inter. and disable any more */ 912 return IRQ_HANDLED; 913 } else if (!(ELMC_CTRL_INT & inb(dev->base_addr + ELMC_CTRL))) { 914 /* wasn't this device */ 915 return IRQ_NONE; 916 } 917 /* reading ELMC_CTRL also clears the INT bit. */ 918 919 p = netdev_priv(dev); 920 921 while ((stat = p->scb->status & STAT_MASK)) 922 { 923 p->scb->cmd = stat; 924 elmc_attn586(); /* ack inter. */ 925 926 if (stat & STAT_CX) { 927 /* command with I-bit set complete */ 928 elmc_xmt_int(dev); 929 } 930 if (stat & STAT_FR) { 931 /* received a frame */ 932 elmc_rcv_int(dev); 933 } 934#ifndef NO_NOPCOMMANDS 935 if (stat & STAT_CNA) { 936 /* CU went 'not ready' */ 937 if (netif_running(dev)) { 938 pr_warning("%s: oops! CU has left active state. stat: %04x/%04x.\n", 939 dev->name, (int) stat, (int) p->scb->status); 940 } 941 } 942#endif 943 944 if (stat & STAT_RNR) { 945 /* RU went 'not ready' */ 946 947 if (p->scb->status & RU_SUSPEND) { 948 /* special case: RU_SUSPEND */ 949 950 WAIT_4_SCB_CMD(); 951 p->scb->cmd = RUC_RESUME; 952 elmc_attn586(); 953 } else { 954 pr_warning("%s: Receiver-Unit went 'NOT READY': %04x/%04x.\n", 955 dev->name, (int) stat, (int) p->scb->status); 956 elmc_rnr_int(dev); 957 } 958 } 959 WAIT_4_SCB_CMD(); /* wait for ack. (elmc_xmt_int can be faster than ack!!) */ 960 if (p->scb->cmd) { /* timed out? */ 961 break; 962 } 963 } 964 return IRQ_HANDLED; 965} 966 967/******************************************************* 968 * receive-interrupt 969 */ 970 971static void elmc_rcv_int(struct net_device *dev) 972{ 973 int status; 974 unsigned short totlen; 975 struct sk_buff *skb; 976 struct rbd_struct *rbd; 977 struct priv *p = netdev_priv(dev); 978 979 for (; (status = p->rfd_top->status) & STAT_COMPL;) { 980 rbd = (struct rbd_struct *) make32(p->rfd_top->rbd_offset); 981 982 if (status & STAT_OK) { /* frame received without error? */ 983 if ((totlen = rbd->status) & RBD_LAST) { /* the first and the last buffer? */ 984 totlen &= RBD_MASK; /* length of this frame */ 985 rbd->status = 0; 986 skb = (struct sk_buff *) dev_alloc_skb(totlen + 2); 987 if (skb != NULL) { 988 skb_reserve(skb, 2); /* 16 byte alignment */ 989 skb_put(skb,totlen); 990 skb_copy_to_linear_data(skb, (char *) p->base+(unsigned long) rbd->buffer,totlen); 991 skb->protocol = eth_type_trans(skb, dev); 992 netif_rx(skb); 993 dev->stats.rx_packets++; 994 dev->stats.rx_bytes += totlen; 995 } else { 996 dev->stats.rx_dropped++; 997 } 998 } else { 999 pr_warning("%s: received oversized frame.\n", dev->name); 1000 dev->stats.rx_dropped++; 1001 } 1002 } else { /* frame !(ok), only with 'save-bad-frames' */ 1003 pr_warning("%s: oops! rfd-error-status: %04x\n", dev->name, status); 1004 dev->stats.rx_errors++; 1005 } 1006 p->rfd_top->status = 0; 1007 p->rfd_top->last = RFD_SUSP; 1008 p->rfd_last->last = 0; /* delete RU_SUSP */ 1009 p->rfd_last = p->rfd_top; 1010 p->rfd_top = (struct rfd_struct *) make32(p->rfd_top->next); /* step to next RFD */ 1011 } 1012} 1013 1014/********************************************************** 1015 * handle 'Receiver went not ready'. 1016 */ 1017 1018static void elmc_rnr_int(struct net_device *dev) 1019{ 1020 struct priv *p = netdev_priv(dev); 1021 1022 dev->stats.rx_errors++; 1023 1024 WAIT_4_SCB_CMD(); /* wait for the last cmd */ 1025 p->scb->cmd = RUC_ABORT; /* usually the RU is in the 'no resource'-state .. abort it now. */ 1026 elmc_attn586(); 1027 WAIT_4_SCB_CMD(); /* wait for accept cmd. */ 1028 1029 alloc_rfa(dev, (char *) p->rfd_first); 1030 startrecv586(dev); /* restart RU */ 1031 1032 pr_warning("%s: Receive-Unit restarted. Status: %04x\n", dev->name, p->scb->status); 1033 1034} 1035 1036/********************************************************** 1037 * handle xmit - interrupt 1038 */ 1039 1040static void elmc_xmt_int(struct net_device *dev) 1041{ 1042 int status; 1043 struct priv *p = netdev_priv(dev); 1044 1045 status = p->xmit_cmds[p->xmit_last]->cmd_status; 1046 if (!(status & STAT_COMPL)) { 1047 pr_warning("%s: strange .. xmit-int without a 'COMPLETE'\n", dev->name); 1048 } 1049 if (status & STAT_OK) { 1050 dev->stats.tx_packets++; 1051 dev->stats.collisions += (status & TCMD_MAXCOLLMASK); 1052 } else { 1053 dev->stats.tx_errors++; 1054 if (status & TCMD_LATECOLL) { 1055 pr_warning("%s: late collision detected.\n", dev->name); 1056 dev->stats.collisions++; 1057 } else if (status & TCMD_NOCARRIER) { 1058 dev->stats.tx_carrier_errors++; 1059 pr_warning("%s: no carrier detected.\n", dev->name); 1060 } else if (status & TCMD_LOSTCTS) { 1061 pr_warning("%s: loss of CTS detected.\n", dev->name); 1062 } else if (status & TCMD_UNDERRUN) { 1063 dev->stats.tx_fifo_errors++; 1064 pr_warning("%s: DMA underrun detected.\n", dev->name); 1065 } else if (status & TCMD_MAXCOLL) { 1066 pr_warning("%s: Max. collisions exceeded.\n", dev->name); 1067 dev->stats.collisions += 16; 1068 } 1069 } 1070 1071#if (NUM_XMIT_BUFFS != 1) 1072 if ((++p->xmit_last) == NUM_XMIT_BUFFS) { 1073 p->xmit_last = 0; 1074 } 1075#endif 1076 1077 netif_wake_queue(dev); 1078} 1079 1080/*********************************************************** 1081 * (re)start the receiver 1082 */ 1083 1084static void startrecv586(struct net_device *dev) 1085{ 1086 struct priv *p = netdev_priv(dev); 1087 1088 p->scb->rfa_offset = make16(p->rfd_first); 1089 p->scb->cmd = RUC_START; 1090 elmc_attn586(); /* start cmd. */ 1091 WAIT_4_SCB_CMD(); /* wait for accept cmd. (no timeout!!) */ 1092} 1093 1094/****************************************************** 1095 * timeout 1096 */ 1097 1098static void elmc_timeout(struct net_device *dev) 1099{ 1100 struct priv *p = netdev_priv(dev); 1101 /* COMMAND-UNIT active? */ 1102 if (p->scb->status & CU_ACTIVE) { 1103 pr_debug("%s: strange ... timeout with CU active?!?\n", dev->name); 1104 pr_debug("%s: X0: %04x N0: %04x N1: %04x %d\n", dev->name, 1105 (int)p->xmit_cmds[0]->cmd_status, 1106 (int)p->nop_cmds[0]->cmd_status, 1107 (int)p->nop_cmds[1]->cmd_status, (int)p->nop_point); 1108 p->scb->cmd = CUC_ABORT; 1109 elmc_attn586(); 1110 WAIT_4_SCB_CMD(); 1111 p->scb->cbl_offset = make16(p->nop_cmds[p->nop_point]); 1112 p->scb->cmd = CUC_START; 1113 elmc_attn586(); 1114 WAIT_4_SCB_CMD(); 1115 netif_wake_queue(dev); 1116 } else { 1117 pr_debug("%s: xmitter timed out, try to restart! stat: %04x\n", 1118 dev->name, p->scb->status); 1119 pr_debug("%s: command-stats: %04x %04x\n", dev->name, 1120 p->xmit_cmds[0]->cmd_status, p->xmit_cmds[1]->cmd_status); 1121 elmc_close(dev); 1122 elmc_open(dev); 1123 } 1124} 1125 1126/****************************************************** 1127 * send frame 1128 */ 1129 1130static netdev_tx_t elmc_send_packet(struct sk_buff *skb, struct net_device *dev) 1131{ 1132 int len; 1133 int i; 1134#ifndef NO_NOPCOMMANDS 1135 int next_nop; 1136#endif 1137 struct priv *p = netdev_priv(dev); 1138 1139 netif_stop_queue(dev); 1140 1141 len = (ETH_ZLEN < skb->len) ? skb->len : ETH_ZLEN; 1142 1143 if (len != skb->len) 1144 memset((char *) p->xmit_cbuffs[p->xmit_count], 0, ETH_ZLEN); 1145 skb_copy_from_linear_data(skb, (char *) p->xmit_cbuffs[p->xmit_count], skb->len); 1146 1147#if (NUM_XMIT_BUFFS == 1) 1148#ifdef NO_NOPCOMMANDS 1149 p->xmit_buffs[0]->size = TBD_LAST | len; 1150 for (i = 0; i < 16; i++) { 1151 p->scb->cbl_offset = make16(p->xmit_cmds[0]); 1152 p->scb->cmd = CUC_START; 1153 p->xmit_cmds[0]->cmd_status = 0; 1154 elmc_attn586(); 1155 if (!i) { 1156 dev_kfree_skb(skb); 1157 } 1158 WAIT_4_SCB_CMD(); 1159 if ((p->scb->status & CU_ACTIVE)) { /* test it, because CU sometimes doesn't start immediately */ 1160 break; 1161 } 1162 if (p->xmit_cmds[0]->cmd_status) { 1163 break; 1164 } 1165 if (i == 15) { 1166 pr_warning("%s: Can't start transmit-command.\n", dev->name); 1167 } 1168 } 1169#else 1170 next_nop = (p->nop_point + 1) & 0x1; 1171 p->xmit_buffs[0]->size = TBD_LAST | len; 1172 1173 p->xmit_cmds[0]->cmd_link = p->nop_cmds[next_nop]->cmd_link 1174 = make16((p->nop_cmds[next_nop])); 1175 p->xmit_cmds[0]->cmd_status = p->nop_cmds[next_nop]->cmd_status = 0; 1176 1177 p->nop_cmds[p->nop_point]->cmd_link = make16((p->xmit_cmds[0])); 1178 p->nop_point = next_nop; 1179 dev_kfree_skb(skb); 1180#endif 1181#else 1182 p->xmit_buffs[p->xmit_count]->size = TBD_LAST | len; 1183 if ((next_nop = p->xmit_count + 1) == NUM_XMIT_BUFFS) { 1184 next_nop = 0; 1185 } 1186 p->xmit_cmds[p->xmit_count]->cmd_status = 0; 1187 p->xmit_cmds[p->xmit_count]->cmd_link = p->nop_cmds[next_nop]->cmd_link 1188 = make16((p->nop_cmds[next_nop])); 1189 p->nop_cmds[next_nop]->cmd_status = 0; 1190 p->nop_cmds[p->xmit_count]->cmd_link = make16((p->xmit_cmds[p->xmit_count])); 1191 p->xmit_count = next_nop; 1192 if (p->xmit_count != p->xmit_last) 1193 netif_wake_queue(dev); 1194 dev_kfree_skb(skb); 1195#endif 1196 return NETDEV_TX_OK; 1197} 1198 1199/******************************************* 1200 * Someone wanna have the statistics 1201 */ 1202 1203static struct net_device_stats *elmc_get_stats(struct net_device *dev) 1204{ 1205 struct priv *p = netdev_priv(dev); 1206 unsigned short crc, aln, rsc, ovrn; 1207 1208 crc = p->scb->crc_errs; /* get error-statistic from the ni82586 */ 1209 p->scb->crc_errs -= crc; 1210 aln = p->scb->aln_errs; 1211 p->scb->aln_errs -= aln; 1212 rsc = p->scb->rsc_errs; 1213 p->scb->rsc_errs -= rsc; 1214 ovrn = p->scb->ovrn_errs; 1215 p->scb->ovrn_errs -= ovrn; 1216 1217 dev->stats.rx_crc_errors += crc; 1218 dev->stats.rx_fifo_errors += ovrn; 1219 dev->stats.rx_frame_errors += aln; 1220 dev->stats.rx_dropped += rsc; 1221 1222 return &dev->stats; 1223} 1224 1225/******************************************************** 1226 * Set MC list .. 1227 */ 1228 1229#ifdef ELMC_MULTICAST 1230static void set_multicast_list(struct net_device *dev) 1231{ 1232 if (!dev->start) { 1233 /* without a running interface, promiscuous doesn't work */ 1234 return; 1235 } 1236 dev->start = 0; 1237 alloc586(dev); 1238 init586(dev); 1239 startrecv586(dev); 1240 dev->start = 1; 1241} 1242#endif 1243 1244static void netdev_get_drvinfo(struct net_device *dev, 1245 struct ethtool_drvinfo *info) 1246{ 1247 strcpy(info->driver, DRV_NAME); 1248 strcpy(info->version, DRV_VERSION); 1249 sprintf(info->bus_info, "MCA 0x%lx", dev->base_addr); 1250} 1251 1252static const struct ethtool_ops netdev_ethtool_ops = { 1253 .get_drvinfo = netdev_get_drvinfo, 1254}; 1255 1256#ifdef MODULE 1257 1258/* Increase if needed ;) */ 1259#define MAX_3C523_CARDS 4 1260 1261static struct net_device *dev_elmc[MAX_3C523_CARDS]; 1262static int irq[MAX_3C523_CARDS]; 1263static int io[MAX_3C523_CARDS]; 1264module_param_array(irq, int, NULL, 0); 1265module_param_array(io, int, NULL, 0); 1266MODULE_PARM_DESC(io, "EtherLink/MC I/O base address(es)"); 1267MODULE_PARM_DESC(irq, "EtherLink/MC IRQ number(s)"); 1268MODULE_LICENSE("GPL"); 1269 1270int __init init_module(void) 1271{ 1272 int this_dev,found = 0; 1273 1274 /* Loop until we either can't find any more cards, or we have MAX_3C523_CARDS */ 1275 for(this_dev=0; this_dev<MAX_3C523_CARDS; this_dev++) { 1276 struct net_device *dev = alloc_etherdev(sizeof(struct priv)); 1277 if (!dev) 1278 break; 1279 dev->irq=irq[this_dev]; 1280 dev->base_addr=io[this_dev]; 1281 if (do_elmc_probe(dev) == 0) { 1282 dev_elmc[this_dev] = dev; 1283 found++; 1284 continue; 1285 } 1286 free_netdev(dev); 1287 if (io[this_dev]==0) 1288 break; 1289 pr_warning("3c523.c: No 3c523 card found at io=%#x\n",io[this_dev]); 1290 } 1291 1292 if(found==0) { 1293 if (io[0]==0) 1294 pr_notice("3c523.c: No 3c523 cards found\n"); 1295 return -ENXIO; 1296 } else return 0; 1297} 1298 1299void __exit cleanup_module(void) 1300{ 1301 int this_dev; 1302 for (this_dev=0; this_dev<MAX_3C523_CARDS; this_dev++) { 1303 struct net_device *dev = dev_elmc[this_dev]; 1304 if (dev) { 1305 unregister_netdev(dev); 1306 cleanup_card(dev); 1307 free_netdev(dev); 1308 } 1309 } 1310} 1311 1312#endif /* MODULE */ 1313