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