1/* 3c507.c: An EtherLink16 device driver for Linux. */ 2/* 3 Written 1993,1994 by Donald Becker. 4 5 Copyright 1993 United States Government as represented by the 6 Director, National Security Agency. 7 8 This software may be used and distributed according to the terms 9 of the GNU General Public License, incorporated herein by reference. 10 11 The author may be reached as becker@scyld.com, or C/O 12 Scyld Computing Corporation 13 410 Severn Ave., Suite 210 14 Annapolis MD 21403 15 16 17 Thanks go to jennings@Montrouge.SMR.slb.com ( Patrick Jennings) 18 and jrs@world.std.com (Rick Sladkey) for testing and bugfixes. 19 Mark Salazar <leslie@access.digex.net> made the changes for cards with 20 only 16K packet buffers. 21 22 Things remaining to do: 23 Verify that the tx and rx buffers don't have fencepost errors. 24 Move the theory of operation and memory map documentation. 25 The statistics need to be updated correctly. 26*/ 27 28#define DRV_NAME "3c507" 29#define DRV_VERSION "1.10a" 30#define DRV_RELDATE "11/17/2001" 31 32static const char version[] = 33 DRV_NAME ".c:v" DRV_VERSION " " DRV_RELDATE " Donald Becker (becker@scyld.com)\n"; 34 35 36#include <linux/module.h> 37 38/* 39 Sources: 40 This driver wouldn't have been written with the availability of the 41 Crynwr driver source code. It provided a known-working implementation 42 that filled in the gaping holes of the Intel documentation. Three cheers 43 for Russ Nelson. 44 45 Intel Microcommunications Databook, Vol. 1, 1990. It provides just enough 46 info that the casual reader might think that it documents the i82586 :-<. 47*/ 48 49#include <linux/kernel.h> 50#include <linux/sched.h> 51#include <linux/types.h> 52#include <linux/fcntl.h> 53#include <linux/interrupt.h> 54#include <linux/ptrace.h> 55#include <linux/ioport.h> 56#include <linux/in.h> 57#include <linux/string.h> 58#include <linux/spinlock.h> 59#include <linux/ethtool.h> 60 61#include <asm/uaccess.h> 62#include <asm/system.h> 63#include <asm/bitops.h> 64#include <asm/io.h> 65#include <asm/dma.h> 66#include <linux/errno.h> 67 68#include <linux/netdevice.h> 69#include <linux/etherdevice.h> 70#include <linux/skbuff.h> 71#include <linux/slab.h> 72#include <linux/init.h> 73 74 75/* use 0 for production, 1 for verification, 2..7 for debug */ 76#ifndef NET_DEBUG 77#define NET_DEBUG 1 78#endif 79static unsigned int net_debug = NET_DEBUG; 80#define debug net_debug 81 82 83/* A zero-terminated list of common I/O addresses to be probed. */ 84static unsigned int netcard_portlist[] __initdata = 85 { 0x300, 0x320, 0x340, 0x280, 0}; 86 87/* 88 Details of the i82586. 89 90 You'll really need the databook to understand the details of this part, 91 but the outline is that the i82586 has two separate processing units. 92 Both are started from a list of three configuration tables, of which only 93 the last, the System Control Block (SCB), is used after reset-time. The SCB 94 has the following fields: 95 Status word 96 Command word 97 Tx/Command block addr. 98 Rx block addr. 99 The command word accepts the following controls for the Tx and Rx units: 100 */ 101 102#define CUC_START 0x0100 103#define CUC_RESUME 0x0200 104#define CUC_SUSPEND 0x0300 105#define RX_START 0x0010 106#define RX_RESUME 0x0020 107#define RX_SUSPEND 0x0030 108 109/* The Rx unit uses a list of frame descriptors and a list of data buffer 110 descriptors. We use full-sized (1518 byte) data buffers, so there is 111 a one-to-one pairing of frame descriptors to buffer descriptors. 112 113 The Tx ("command") unit executes a list of commands that look like: 114 Status word Written by the 82586 when the command is done. 115 Command word Command in lower 3 bits, post-command action in upper 3 116 Link word The address of the next command. 117 Parameters (as needed). 118 119 Some definitions related to the Command Word are: 120 */ 121#define CMD_EOL 0x8000 /* The last command of the list, stop. */ 122#define CMD_SUSP 0x4000 /* Suspend after doing cmd. */ 123#define CMD_INTR 0x2000 /* Interrupt after doing cmd. */ 124 125enum commands { 126 CmdNOp = 0, CmdSASetup = 1, CmdConfigure = 2, CmdMulticastList = 3, 127 CmdTx = 4, CmdTDR = 5, CmdDump = 6, CmdDiagnose = 7}; 128 129/* Information that need to be kept for each board. */ 130struct net_local { 131 struct net_device_stats stats; 132 int last_restart; 133 ushort rx_head; 134 ushort rx_tail; 135 ushort tx_head; 136 ushort tx_cmd_link; 137 ushort tx_reap; 138 ushort tx_pkts_in_ring; 139 spinlock_t lock; 140}; 141 142/* 143 Details of the EtherLink16 Implementation 144 The 3c507 is a generic shared-memory i82586 implementation. 145 The host can map 16K, 32K, 48K, or 64K of the 64K memory into 146 0x0[CD][08]0000, or all 64K into 0xF[02468]0000. 147 */ 148 149/* Offsets from the base I/O address. */ 150#define SA_DATA 0 /* Station address data, or 3Com signature. */ 151#define MISC_CTRL 6 /* Switch the SA_DATA banks, and bus config bits. */ 152#define RESET_IRQ 10 /* Reset the latched IRQ line. */ 153#define SIGNAL_CA 11 /* Frob the 82586 Channel Attention line. */ 154#define ROM_CONFIG 13 155#define MEM_CONFIG 14 156#define IRQ_CONFIG 15 157#define EL16_IO_EXTENT 16 158 159/* The ID port is used at boot-time to locate the ethercard. */ 160#define ID_PORT 0x100 161 162/* Offsets to registers in the mailbox (SCB). */ 163#define iSCB_STATUS 0x8 164#define iSCB_CMD 0xA 165#define iSCB_CBL 0xC /* Command BLock offset. */ 166#define iSCB_RFA 0xE /* Rx Frame Area offset. */ 167 168/* Since the 3c507 maps the shared memory window so that the last byte is 169 at 82586 address FFFF, the first byte is at 82586 address 0, 16K, 32K, or 170 48K corresponding to window sizes of 64K, 48K, 32K and 16K respectively. 171 We can account for this be setting the 'SBC Base' entry in the ISCP table 172 below for all the 16 bit offset addresses, and also adding the 'SCB Base' 173 value to all 24 bit physical addresses (in the SCP table and the TX and RX 174 Buffer Descriptors). 175 -Mark 176 */ 177#define SCB_BASE ((unsigned)64*1024 - (dev->mem_end - dev->mem_start)) 178 179/* 180 What follows in 'init_words[]' is the "program" that is downloaded to the 181 82586 memory. It's mostly tables and command blocks, and starts at the 182 reset address 0xfffff6. This is designed to be similar to the EtherExpress, 183 thus the unusual location of the SCB at 0x0008. 184 185 Even with the additional "don't care" values, doing it this way takes less 186 program space than initializing the individual tables, and I feel it's much 187 cleaner. 188 189 The databook is particularly useless for the first two structures, I had 190 to use the Crynwr driver as an example. 191 192 The memory setup is as follows: 193 */ 194 195#define CONFIG_CMD 0x0018 196#define SET_SA_CMD 0x0024 197#define SA_OFFSET 0x002A 198#define IDLELOOP 0x30 199#define TDR_CMD 0x38 200#define TDR_TIME 0x3C 201#define DUMP_CMD 0x40 202#define DIAG_CMD 0x48 203#define SET_MC_CMD 0x4E 204#define DUMP_DATA 0x56 /* A 170 byte buffer for dump and Set-MC into. */ 205 206#define TX_BUF_START 0x0100 207#define NUM_TX_BUFS 5 208#define TX_BUF_SIZE (1518+14+20+16) /* packet+header+TBD */ 209 210#define RX_BUF_START 0x2000 211#define RX_BUF_SIZE (1518+14+18) /* packet+header+RBD */ 212#define RX_BUF_END (dev->mem_end - dev->mem_start) 213 214#define TX_TIMEOUT 5 215 216/* 217 That's it: only 86 bytes to set up the beast, including every extra 218 command available. The 170 byte buffer at DUMP_DATA is shared between the 219 Dump command (called only by the diagnostic program) and the SetMulticastList 220 command. 221 222 To complete the memory setup you only have to write the station address at 223 SA_OFFSET and create the Tx & Rx buffer lists. 224 225 The Tx command chain and buffer list is setup as follows: 226 A Tx command table, with the data buffer pointing to... 227 A Tx data buffer descriptor. The packet is in a single buffer, rather than 228 chaining together several smaller buffers. 229 A NoOp command, which initially points to itself, 230 And the packet data. 231 232 A transmit is done by filling in the Tx command table and data buffer, 233 re-writing the NoOp command, and finally changing the offset of the last 234 command to point to the current Tx command. When the Tx command is finished, 235 it jumps to the NoOp, when it loops until the next Tx command changes the 236 "link offset" in the NoOp. This way the 82586 never has to go through the 237 slow restart sequence. 238 239 The Rx buffer list is set up in the obvious ring structure. We have enough 240 memory (and low enough interrupt latency) that we can avoid the complicated 241 Rx buffer linked lists by alway associating a full-size Rx data buffer with 242 each Rx data frame. 243 244 I current use four transmit buffers starting at TX_BUF_START (0x0100), and 245 use the rest of memory, from RX_BUF_START to RX_BUF_END, for Rx buffers. 246 247 */ 248 249static unsigned short init_words[] = { 250 /* System Configuration Pointer (SCP). */ 251 0x0000, /* Set bus size to 16 bits. */ 252 0,0, /* pad words. */ 253 0x0000,0x0000, /* ISCP phys addr, set in init_82586_mem(). */ 254 255 /* Intermediate System Configuration Pointer (ISCP). */ 256 0x0001, /* Status word that's cleared when init is done. */ 257 0x0008,0,0, /* SCB offset, (skip, skip) */ 258 259 /* System Control Block (SCB). */ 260 0,0xf000|RX_START|CUC_START, /* SCB status and cmd. */ 261 CONFIG_CMD, /* Command list pointer, points to Configure. */ 262 RX_BUF_START, /* Rx block list. */ 263 0,0,0,0, /* Error count: CRC, align, buffer, overrun. */ 264 265 /* 0x0018: Configure command. Change to put MAC data with packet. */ 266 0, CmdConfigure, /* Status, command. */ 267 SET_SA_CMD, /* Next command is Set Station Addr. */ 268 0x0804, /* "4" bytes of config data, 8 byte FIFO. */ 269 0x2e40, /* Magic values, including MAC data location. */ 270 0, /* Unused pad word. */ 271 272 /* 0x0024: Setup station address command. */ 273 0, CmdSASetup, 274 SET_MC_CMD, /* Next command. */ 275 0xaa00,0xb000,0x0bad, /* Station address (to be filled in) */ 276 277 /* 0x0030: NOP, looping back to itself. Point to first Tx buffer to Tx. */ 278 0, CmdNOp, IDLELOOP, 0 /* pad */, 279 280 /* 0x0038: A unused Time-Domain Reflectometer command. */ 281 0, CmdTDR, IDLELOOP, 0, 282 283 /* 0x0040: An unused Dump State command. */ 284 0, CmdDump, IDLELOOP, DUMP_DATA, 285 286 /* 0x0048: An unused Diagnose command. */ 287 0, CmdDiagnose, IDLELOOP, 288 289 /* 0x004E: An empty set-multicast-list command. */ 290 0, CmdMulticastList, IDLELOOP, 0, 291}; 292 293/* Index to functions, as function prototypes. */ 294 295extern int el16_probe(struct net_device *dev); /* Called from Space.c */ 296 297static int el16_probe1(struct net_device *dev, int ioaddr); 298static int el16_open(struct net_device *dev); 299static int el16_send_packet(struct sk_buff *skb, struct net_device *dev); 300static void el16_interrupt(int irq, void *dev_id, struct pt_regs *regs); 301static void el16_rx(struct net_device *dev); 302static int el16_close(struct net_device *dev); 303static struct net_device_stats *el16_get_stats(struct net_device *dev); 304static void el16_tx_timeout (struct net_device *dev); 305 306static void hardware_send_packet(struct net_device *dev, void *buf, short length); 307static void init_82586_mem(struct net_device *dev); 308static int netdev_ioctl (struct net_device *dev, struct ifreq *rq, int cmd); 309 310 311/* Check for a network adaptor of this type, and return '0' iff one exists. 312 If dev->base_addr == 0, probe all likely locations. 313 If dev->base_addr == 1, always return failure. 314 If dev->base_addr == 2, (detachable devices only) allocate space for the 315 device and return success. 316 */ 317 318int __init el16_probe(struct net_device *dev) 319{ 320 int base_addr = dev->base_addr; 321 int i; 322 323 SET_MODULE_OWNER(dev); 324 325 if (base_addr > 0x1ff) /* Check a single specified location. */ 326 return el16_probe1(dev, base_addr); 327 else if (base_addr != 0) 328 return -ENXIO; /* Don't probe at all. */ 329 330 for (i = 0; netcard_portlist[i]; i++) 331 if (el16_probe1(dev, netcard_portlist[i]) == 0) 332 return 0; 333 334 return -ENODEV; 335} 336 337static int __init el16_probe1(struct net_device *dev, int ioaddr) 338{ 339 static unsigned char init_ID_done, version_printed; 340 int i, irq, irqval, retval; 341 struct net_local *lp; 342 343 if (init_ID_done == 0) { 344 ushort lrs_state = 0xff; 345 /* Send the ID sequence to the ID_PORT to enable the board(s). */ 346 outb(0x00, ID_PORT); 347 for(i = 0; i < 255; i++) { 348 outb(lrs_state, ID_PORT); 349 lrs_state <<= 1; 350 if (lrs_state & 0x100) 351 lrs_state ^= 0xe7; 352 } 353 outb(0x00, ID_PORT); 354 init_ID_done = 1; 355 } 356 357 if (!request_region(ioaddr, EL16_IO_EXTENT, dev->name)) 358 return -ENODEV; 359 360 if ((inb(ioaddr) != '*') || (inb(ioaddr + 1) != '3') || 361 (inb(ioaddr + 2) != 'C') || (inb(ioaddr + 3) != 'O')) { 362 retval = -ENODEV; 363 goto out; 364 } 365 366 if (net_debug && version_printed++ == 0) 367 printk(version); 368 369 printk("%s: 3c507 at %#x,", dev->name, ioaddr); 370 371 /* We should make a few more checks here, like the first three octets of 372 the S.A. for the manufacturer's code. */ 373 374 irq = inb(ioaddr + IRQ_CONFIG) & 0x0f; 375 376 irqval = request_irq(irq, &el16_interrupt, 0, dev->name, dev); 377 if (irqval) { 378 printk ("unable to get IRQ %d (irqval=%d).\n", irq, irqval); 379 retval = -EAGAIN; 380 goto out; 381 } 382 383 /* We've committed to using the board, and can start filling in *dev. */ 384 dev->base_addr = ioaddr; 385 386 outb(0x01, ioaddr + MISC_CTRL); 387 for (i = 0; i < 6; i++) { 388 dev->dev_addr[i] = inb(ioaddr + i); 389 printk(" %02x", dev->dev_addr[i]); 390 } 391 392 if ((dev->mem_start & 0xf) > 0) 393 net_debug = dev->mem_start & 7; 394 395#ifdef MEM_BASE 396 dev->mem_start = MEM_BASE; 397 dev->mem_end = dev->mem_start + 0x10000; 398#else 399 { 400 int base; 401 int size; 402 char mem_config = inb(ioaddr + MEM_CONFIG); 403 if (mem_config & 0x20) { 404 size = 64*1024; 405 base = 0xf00000 + (mem_config & 0x08 ? 0x080000 406 : ((mem_config & 3) << 17)); 407 } else { 408 size = ((mem_config & 3) + 1) << 14; 409 base = 0x0c0000 + ( (mem_config & 0x18) << 12); 410 } 411 dev->mem_start = base; 412 dev->mem_end = base + size; 413 } 414#endif 415 416 dev->if_port = (inb(ioaddr + ROM_CONFIG) & 0x80) ? 1 : 0; 417 dev->irq = inb(ioaddr + IRQ_CONFIG) & 0x0f; 418 419 printk(", IRQ %d, %sternal xcvr, memory %#lx-%#lx.\n", dev->irq, 420 dev->if_port ? "ex" : "in", dev->mem_start, dev->mem_end-1); 421 422 if (net_debug) 423 printk(version); 424 425 /* Initialize the device structure. */ 426 lp = dev->priv = kmalloc(sizeof(struct net_local), GFP_KERNEL); 427 if (dev->priv == NULL) { 428 retval = -ENOMEM; 429 goto out; 430 } 431 memset(dev->priv, 0, sizeof(struct net_local)); 432 spin_lock_init(&lp->lock); 433 434 dev->open = el16_open; 435 dev->stop = el16_close; 436 dev->hard_start_xmit = el16_send_packet; 437 dev->get_stats = el16_get_stats; 438 dev->tx_timeout = el16_tx_timeout; 439 dev->watchdog_timeo = TX_TIMEOUT; 440 dev->do_ioctl = netdev_ioctl; 441 442 ether_setup(dev); /* Generic ethernet behaviour */ 443 444 dev->flags&=~IFF_MULTICAST; /* Multicast doesn't work */ 445 446 return 0; 447out: 448 release_region(ioaddr, EL16_IO_EXTENT); 449 return retval; 450} 451 452static int el16_open(struct net_device *dev) 453{ 454 /* Initialize the 82586 memory and start it. */ 455 init_82586_mem(dev); 456 457 netif_start_queue(dev); 458 return 0; 459} 460 461 462static void el16_tx_timeout (struct net_device *dev) 463{ 464 struct net_local *lp = (struct net_local *) dev->priv; 465 int ioaddr = dev->base_addr; 466 unsigned long shmem = dev->mem_start; 467 468 if (net_debug > 1) 469 printk ("%s: transmit timed out, %s? ", dev->name, 470 isa_readw (shmem + iSCB_STATUS) & 0x8000 ? "IRQ conflict" : 471 "network cable problem"); 472 /* Try to restart the adaptor. */ 473 if (lp->last_restart == lp->stats.tx_packets) { 474 if (net_debug > 1) 475 printk ("Resetting board.\n"); 476 /* Completely reset the adaptor. */ 477 init_82586_mem (dev); 478 lp->tx_pkts_in_ring = 0; 479 } else { 480 /* Issue the channel attention signal and hope it "gets better". */ 481 if (net_debug > 1) 482 printk ("Kicking board.\n"); 483 isa_writew (0xf000 | CUC_START | RX_START, shmem + iSCB_CMD); 484 outb (0, ioaddr + SIGNAL_CA); /* Issue channel-attn. */ 485 lp->last_restart = lp->stats.tx_packets; 486 } 487 dev->trans_start = jiffies; 488 netif_wake_queue (dev); 489} 490 491 492static int el16_send_packet (struct sk_buff *skb, struct net_device *dev) 493{ 494 struct net_local *lp = (struct net_local *) dev->priv; 495 int ioaddr = dev->base_addr; 496 unsigned long flags; 497 short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN; 498 unsigned char *buf = skb->data; 499 500 netif_stop_queue (dev); 501 502 spin_lock_irqsave (&lp->lock, flags); 503 504 lp->stats.tx_bytes += length; 505 /* Disable the 82586's input to the interrupt line. */ 506 outb (0x80, ioaddr + MISC_CTRL); 507 508 hardware_send_packet (dev, buf, length); 509 510 dev->trans_start = jiffies; 511 /* Enable the 82586 interrupt input. */ 512 outb (0x84, ioaddr + MISC_CTRL); 513 514 spin_unlock_irqrestore (&lp->lock, flags); 515 516 dev_kfree_skb (skb); 517 518 /* You might need to clean up and record Tx statistics here. */ 519 520 return 0; 521} 522 523/* The typical workload of the driver: 524 Handle the network interface interrupts. */ 525static void el16_interrupt(int irq, void *dev_id, struct pt_regs *regs) 526{ 527 struct net_device *dev = dev_id; 528 struct net_local *lp; 529 int ioaddr, status, boguscount = 0; 530 ushort ack_cmd = 0; 531 unsigned long shmem; 532 533 if (dev == NULL) { 534 printk ("net_interrupt(): irq %d for unknown device.\n", irq); 535 return; 536 } 537 538 ioaddr = dev->base_addr; 539 lp = (struct net_local *)dev->priv; 540 shmem = dev->mem_start; 541 542 spin_lock(&lp->lock); 543 544 status = isa_readw(shmem+iSCB_STATUS); 545 546 if (net_debug > 4) { 547 printk("%s: 3c507 interrupt, status %4.4x.\n", dev->name, status); 548 } 549 550 /* Disable the 82586's input to the interrupt line. */ 551 outb(0x80, ioaddr + MISC_CTRL); 552 553 /* Reap the Tx packet buffers. */ 554 while (lp->tx_pkts_in_ring) { 555 unsigned short tx_status = isa_readw(shmem+lp->tx_reap); 556 if (!(tx_status & 0x8000)) { 557 if (net_debug > 5) 558 printk("Tx command incomplete (%#x).\n", lp->tx_reap); 559 break; 560 } 561 /* Tx unsuccessful or some interesting status bit set. */ 562 if (!(tx_status & 0x2000) || (tx_status & 0x0f3f)) { 563 lp->stats.tx_errors++; 564 if (tx_status & 0x0600) lp->stats.tx_carrier_errors++; 565 if (tx_status & 0x0100) lp->stats.tx_fifo_errors++; 566 if (!(tx_status & 0x0040)) lp->stats.tx_heartbeat_errors++; 567 if (tx_status & 0x0020) lp->stats.tx_aborted_errors++; 568 lp->stats.collisions += tx_status & 0xf; 569 } 570 lp->stats.tx_packets++; 571 if (net_debug > 5) 572 printk("Reaped %x, Tx status %04x.\n" , lp->tx_reap, tx_status); 573 lp->tx_reap += TX_BUF_SIZE; 574 if (lp->tx_reap > RX_BUF_START - TX_BUF_SIZE) 575 lp->tx_reap = TX_BUF_START; 576 577 lp->tx_pkts_in_ring--; 578 /* There is always more space in the Tx ring buffer now. */ 579 netif_wake_queue(dev); 580 581 if (++boguscount > 10) 582 break; 583 } 584 585 if (status & 0x4000) { /* Packet received. */ 586 if (net_debug > 5) 587 printk("Received packet, rx_head %04x.\n", lp->rx_head); 588 el16_rx(dev); 589 } 590 591 /* Acknowledge the interrupt sources. */ 592 ack_cmd = status & 0xf000; 593 594 if ((status & 0x0700) != 0x0200 && netif_running(dev)) { 595 if (net_debug) 596 printk("%s: Command unit stopped, status %04x, restarting.\n", 597 dev->name, status); 598 /* If this ever occurs we should really re-write the idle loop, reset 599 the Tx list, and do a complete restart of the command unit. 600 For now we rely on the Tx timeout if the resume doesn't work. */ 601 ack_cmd |= CUC_RESUME; 602 } 603 604 if ((status & 0x0070) != 0x0040 && netif_running(dev)) { 605 static void init_rx_bufs(struct net_device *); 606 /* The Rx unit is not ready, it must be hung. Restart the receiver by 607 initializing the rx buffers, and issuing an Rx start command. */ 608 if (net_debug) 609 printk("%s: Rx unit stopped, status %04x, restarting.\n", 610 dev->name, status); 611 init_rx_bufs(dev); 612 isa_writew(RX_BUF_START,shmem+iSCB_RFA); 613 ack_cmd |= RX_START; 614 } 615 616 isa_writew(ack_cmd,shmem+iSCB_CMD); 617 outb(0, ioaddr + SIGNAL_CA); /* Issue channel-attn. */ 618 619 /* Clear the latched interrupt. */ 620 outb(0, ioaddr + RESET_IRQ); 621 622 /* Enable the 82586's interrupt input. */ 623 outb(0x84, ioaddr + MISC_CTRL); 624 spin_unlock(&lp->lock); 625} 626 627static int el16_close(struct net_device *dev) 628{ 629 int ioaddr = dev->base_addr; 630 unsigned long shmem = dev->mem_start; 631 632 netif_stop_queue(dev); 633 634 /* Flush the Tx and disable Rx. */ 635 isa_writew(RX_SUSPEND | CUC_SUSPEND,shmem+iSCB_CMD); 636 outb(0, ioaddr + SIGNAL_CA); 637 638 /* Disable the 82586's input to the interrupt line. */ 639 outb(0x80, ioaddr + MISC_CTRL); 640 641 /* We always physically use the IRQ line, so we don't do free_irq(). */ 642 643 /* Update the statistics here. */ 644 645 return 0; 646} 647 648/* Get the current statistics. This may be called with the card open or 649 closed. */ 650static struct net_device_stats *el16_get_stats(struct net_device *dev) 651{ 652 struct net_local *lp = (struct net_local *)dev->priv; 653 654 /* ToDo: decide if there are any useful statistics from the SCB. */ 655 656 return &lp->stats; 657} 658 659/* Initialize the Rx-block list. */ 660static void init_rx_bufs(struct net_device *dev) 661{ 662 struct net_local *lp = (struct net_local *)dev->priv; 663 unsigned long write_ptr; 664 unsigned short SCB_base = SCB_BASE; 665 666 int cur_rxbuf = lp->rx_head = RX_BUF_START; 667 668 /* Initialize each Rx frame + data buffer. */ 669 do { /* While there is room for one more. */ 670 671 write_ptr = dev->mem_start + cur_rxbuf; 672 673 isa_writew(0x0000,write_ptr); /* Status */ 674 isa_writew(0x0000,write_ptr+=2); /* Command */ 675 isa_writew(cur_rxbuf + RX_BUF_SIZE,write_ptr+=2); /* Link */ 676 isa_writew(cur_rxbuf + 22,write_ptr+=2); /* Buffer offset */ 677 isa_writew(0x0000,write_ptr+=2); /* Pad for dest addr. */ 678 isa_writew(0x0000,write_ptr+=2); 679 isa_writew(0x0000,write_ptr+=2); 680 isa_writew(0x0000,write_ptr+=2); /* Pad for source addr. */ 681 isa_writew(0x0000,write_ptr+=2); 682 isa_writew(0x0000,write_ptr+=2); 683 isa_writew(0x0000,write_ptr+=2); /* Pad for protocol. */ 684 685 isa_writew(0x0000,write_ptr+=2); /* Buffer: Actual count */ 686 isa_writew(-1,write_ptr+=2); /* Buffer: Next (none). */ 687 isa_writew(cur_rxbuf + 0x20 + SCB_base,write_ptr+=2);/* Buffer: Address low */ 688 isa_writew(0x0000,write_ptr+=2); 689 /* Finally, the number of bytes in the buffer. */ 690 isa_writew(0x8000 + RX_BUF_SIZE-0x20,write_ptr+=2); 691 692 lp->rx_tail = cur_rxbuf; 693 cur_rxbuf += RX_BUF_SIZE; 694 } while (cur_rxbuf <= RX_BUF_END - RX_BUF_SIZE); 695 696 /* Terminate the list by setting the EOL bit, and wrap the pointer to make 697 the list a ring. */ 698 write_ptr = dev->mem_start + lp->rx_tail + 2; 699 isa_writew(0xC000,write_ptr); /* Command, mark as last. */ 700 isa_writew(lp->rx_head,write_ptr+2); /* Link */ 701} 702 703static void init_82586_mem(struct net_device *dev) 704{ 705 struct net_local *lp = (struct net_local *)dev->priv; 706 short ioaddr = dev->base_addr; 707 unsigned long shmem = dev->mem_start; 708 709 /* Enable loopback to protect the wire while starting up, 710 and hold the 586 in reset during the memory initialization. */ 711 outb(0x20, ioaddr + MISC_CTRL); 712 713 /* Fix the ISCP address and base. */ 714 init_words[3] = SCB_BASE; 715 init_words[7] = SCB_BASE; 716 717 /* Write the words at 0xfff6 (address-aliased to 0xfffff6). */ 718 isa_memcpy_toio(dev->mem_end-10, init_words, 10); 719 720 /* Write the words at 0x0000. */ 721 isa_memcpy_toio(dev->mem_start, init_words + 5, sizeof(init_words) - 10); 722 723 /* Fill in the station address. */ 724 isa_memcpy_toio(dev->mem_start+SA_OFFSET, dev->dev_addr, 725 sizeof(dev->dev_addr)); 726 727 /* The Tx-block list is written as needed. We just set up the values. */ 728 lp->tx_cmd_link = IDLELOOP + 4; 729 lp->tx_head = lp->tx_reap = TX_BUF_START; 730 731 init_rx_bufs(dev); 732 733 /* Start the 586 by releasing the reset line, but leave loopback. */ 734 outb(0xA0, ioaddr + MISC_CTRL); 735 736 /* This was time consuming to track down: you need to give two channel 737 attention signals to reliably start up the i82586. */ 738 outb(0, ioaddr + SIGNAL_CA); 739 740 { 741 int boguscnt = 50; 742 while (isa_readw(shmem+iSCB_STATUS) == 0) 743 if (--boguscnt == 0) { 744 printk("%s: i82586 initialization timed out with status %04x," 745 "cmd %04x.\n", dev->name, 746 isa_readw(shmem+iSCB_STATUS), isa_readw(shmem+iSCB_CMD)); 747 break; 748 } 749 /* Issue channel-attn -- the 82586 won't start. */ 750 outb(0, ioaddr + SIGNAL_CA); 751 } 752 753 /* Disable loopback and enable interrupts. */ 754 outb(0x84, ioaddr + MISC_CTRL); 755 if (net_debug > 4) 756 printk("%s: Initialized 82586, status %04x.\n", dev->name, 757 isa_readw(shmem+iSCB_STATUS)); 758 return; 759} 760 761static void hardware_send_packet(struct net_device *dev, void *buf, short length) 762{ 763 struct net_local *lp = (struct net_local *)dev->priv; 764 short ioaddr = dev->base_addr; 765 ushort tx_block = lp->tx_head; 766 unsigned long write_ptr = dev->mem_start + tx_block; 767 768 /* Set the write pointer to the Tx block, and put out the header. */ 769 isa_writew(0x0000,write_ptr); /* Tx status */ 770 isa_writew(CMD_INTR|CmdTx,write_ptr+=2); /* Tx command */ 771 isa_writew(tx_block+16,write_ptr+=2); /* Next command is a NoOp. */ 772 isa_writew(tx_block+8,write_ptr+=2); /* Data Buffer offset. */ 773 774 /* Output the data buffer descriptor. */ 775 isa_writew(length | 0x8000,write_ptr+=2); /* Byte count parameter. */ 776 isa_writew(-1,write_ptr+=2); /* No next data buffer. */ 777 isa_writew(tx_block+22+SCB_BASE,write_ptr+=2); /* Buffer follows the NoOp command. */ 778 isa_writew(0x0000,write_ptr+=2); /* Buffer address high bits (always zero). */ 779 780 /* Output the Loop-back NoOp command. */ 781 isa_writew(0x0000,write_ptr+=2); /* Tx status */ 782 isa_writew(CmdNOp,write_ptr+=2); /* Tx command */ 783 isa_writew(tx_block+16,write_ptr+=2); /* Next is myself. */ 784 785 /* Output the packet at the write pointer. */ 786 isa_memcpy_toio(write_ptr+2, buf, length); 787 788 /* Set the old command link pointing to this send packet. */ 789 isa_writew(tx_block,dev->mem_start + lp->tx_cmd_link); 790 lp->tx_cmd_link = tx_block + 20; 791 792 /* Set the next free tx region. */ 793 lp->tx_head = tx_block + TX_BUF_SIZE; 794 if (lp->tx_head > RX_BUF_START - TX_BUF_SIZE) 795 lp->tx_head = TX_BUF_START; 796 797 if (net_debug > 4) { 798 printk("%s: 3c507 @%x send length = %d, tx_block %3x, next %3x.\n", 799 dev->name, ioaddr, length, tx_block, lp->tx_head); 800 } 801 802 /* Grimly block further packets if there has been insufficient reaping. */ 803 if (++lp->tx_pkts_in_ring < NUM_TX_BUFS) 804 netif_wake_queue(dev); 805} 806 807static void el16_rx(struct net_device *dev) 808{ 809 struct net_local *lp = (struct net_local *)dev->priv; 810 unsigned long shmem = dev->mem_start; 811 ushort rx_head = lp->rx_head; 812 ushort rx_tail = lp->rx_tail; 813 ushort boguscount = 10; 814 short frame_status; 815 816 while ((frame_status = isa_readw(shmem+rx_head)) < 0) { /* Command complete */ 817 unsigned long read_frame = dev->mem_start + rx_head; 818 ushort rfd_cmd = isa_readw(read_frame+2); 819 ushort next_rx_frame = isa_readw(read_frame+4); 820 ushort data_buffer_addr = isa_readw(read_frame+6); 821 unsigned long data_frame = dev->mem_start + data_buffer_addr; 822 ushort pkt_len = isa_readw(data_frame); 823 824 if (rfd_cmd != 0 || data_buffer_addr != rx_head + 22 825 || (pkt_len & 0xC000) != 0xC000) { 826 printk("%s: Rx frame at %#x corrupted, status %04x cmd %04x" 827 "next %04x data-buf @%04x %04x.\n", dev->name, rx_head, 828 frame_status, rfd_cmd, next_rx_frame, data_buffer_addr, 829 pkt_len); 830 } else if ((frame_status & 0x2000) == 0) { 831 /* Frame Rxed, but with error. */ 832 lp->stats.rx_errors++; 833 if (frame_status & 0x0800) lp->stats.rx_crc_errors++; 834 if (frame_status & 0x0400) lp->stats.rx_frame_errors++; 835 if (frame_status & 0x0200) lp->stats.rx_fifo_errors++; 836 if (frame_status & 0x0100) lp->stats.rx_over_errors++; 837 if (frame_status & 0x0080) lp->stats.rx_length_errors++; 838 } else { 839 /* Malloc up new buffer. */ 840 struct sk_buff *skb; 841 842 pkt_len &= 0x3fff; 843 skb = dev_alloc_skb(pkt_len+2); 844 if (skb == NULL) { 845 printk("%s: Memory squeeze, dropping packet.\n", dev->name); 846 lp->stats.rx_dropped++; 847 break; 848 } 849 850 skb_reserve(skb,2); 851 skb->dev = dev; 852 853 /* 'skb->data' points to the start of sk_buff data area. */ 854 isa_memcpy_fromio(skb_put(skb,pkt_len), data_frame + 10, pkt_len); 855 856 skb->protocol=eth_type_trans(skb,dev); 857 netif_rx(skb); 858 dev->last_rx = jiffies; 859 lp->stats.rx_packets++; 860 lp->stats.rx_bytes += pkt_len; 861 } 862 863 /* Clear the status word and set End-of-List on the rx frame. */ 864 isa_writew(0,read_frame); 865 isa_writew(0xC000,read_frame+2); 866 /* Clear the end-of-list on the prev. RFD. */ 867 isa_writew(0x0000,dev->mem_start + rx_tail + 2); 868 869 rx_tail = rx_head; 870 rx_head = next_rx_frame; 871 if (--boguscount == 0) 872 break; 873 } 874 875 lp->rx_head = rx_head; 876 lp->rx_tail = rx_tail; 877} 878 879/** 880 * netdev_ethtool_ioctl: Handle network interface SIOCETHTOOL ioctls 881 * @dev: network interface on which out-of-band action is to be performed 882 * @useraddr: userspace address to which data is to be read and returned 883 * 884 * Process the various commands of the SIOCETHTOOL interface. 885 */ 886 887static int netdev_ethtool_ioctl (struct net_device *dev, void *useraddr) 888{ 889 u32 ethcmd; 890 891 /* dev_ioctl() in ../../net/core/dev.c has already checked 892 capable(CAP_NET_ADMIN), so don't bother with that here. */ 893 894 if (get_user(ethcmd, (u32 *)useraddr)) 895 return -EFAULT; 896 897 switch (ethcmd) { 898 899 case ETHTOOL_GDRVINFO: { 900 struct ethtool_drvinfo info = { ETHTOOL_GDRVINFO }; 901 strcpy (info.driver, DRV_NAME); 902 strcpy (info.version, DRV_VERSION); 903 sprintf(info.bus_info, "ISA 0x%lx", dev->base_addr); 904 if (copy_to_user (useraddr, &info, sizeof (info))) 905 return -EFAULT; 906 return 0; 907 } 908 909 /* get message-level */ 910 case ETHTOOL_GMSGLVL: { 911 struct ethtool_value edata = {ETHTOOL_GMSGLVL}; 912 edata.data = debug; 913 if (copy_to_user(useraddr, &edata, sizeof(edata))) 914 return -EFAULT; 915 return 0; 916 } 917 /* set message-level */ 918 case ETHTOOL_SMSGLVL: { 919 struct ethtool_value edata; 920 if (copy_from_user(&edata, useraddr, sizeof(edata))) 921 return -EFAULT; 922 debug = edata.data; 923 return 0; 924 } 925 926 default: 927 break; 928 } 929 930 return -EOPNOTSUPP; 931} 932 933/** 934 * netdev_ioctl: Handle network interface ioctls 935 * @dev: network interface on which out-of-band action is to be performed 936 * @rq: user request data 937 * @cmd: command issued by user 938 * 939 * Process the various out-of-band ioctls passed to this driver. 940 */ 941 942static int netdev_ioctl (struct net_device *dev, struct ifreq *rq, int cmd) 943{ 944 int rc = 0; 945 946 switch (cmd) { 947 case SIOCETHTOOL: 948 rc = netdev_ethtool_ioctl(dev, (void *) rq->ifr_data); 949 break; 950 951 default: 952 rc = -EOPNOTSUPP; 953 break; 954 } 955 956 return rc; 957} 958 959 960#ifdef MODULE 961static struct net_device dev_3c507; 962static int io = 0x300; 963static int irq; 964MODULE_PARM(io, "i"); 965MODULE_PARM(irq, "i"); 966MODULE_PARM_DESC(io, "EtherLink16 I/O base address"); 967MODULE_PARM_DESC(irq, "(ignored)"); 968 969int init_module(void) 970{ 971 if (io == 0) 972 printk("3c507: You should not use auto-probing with insmod!\n"); 973 dev_3c507.base_addr = io; 974 dev_3c507.irq = irq; 975 dev_3c507.init = el16_probe; 976 if (register_netdev(&dev_3c507) != 0) { 977 printk("3c507: register_netdev() returned non-zero.\n"); 978 return -EIO; 979 } 980 return 0; 981} 982 983void 984cleanup_module(void) 985{ 986 unregister_netdev(&dev_3c507); 987 kfree(dev_3c507.priv); 988 dev_3c507.priv = NULL; 989 990 /* If we don't do this, we can't re-insmod it later. */ 991 free_irq(dev_3c507.irq, &dev_3c507); 992 release_region(dev_3c507.base_addr, EL16_IO_EXTENT); 993} 994#endif /* MODULE */ 995MODULE_LICENSE("GPL"); 996 997 998/* 999 * Local variables: 1000 * compile-command: "gcc -D__KERNEL__ -I/usr/src/linux/net/inet -I/usr/src/linux/drivers/net -Wall -Wstrict-prototypes -O6 -m486 -c 3c507.c" 1001 * version-control: t 1002 * kept-new-versions: 5 1003 * tab-width: 4 1004 * c-indent-level: 4 1005 * End: 1006 */ 1007