1 /* 3c507.c: An EtherLink16 device driver for Linux. */
3 Written 1993,1994 by Donald Becker.
5 Copyright 1993 United States Government as represented by the
6 Director, National Security Agency.
8 This software may be used and distributed according to the terms
9 of the GNU General Public License, incorporated herein by reference.
11 The author may be reached as becker@scyld.com, or C/O
12 Scyld Computing Corporation
13 410 Severn Ave., Suite 210
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.
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.
28 #define DRV_NAME "3c507"
29 #define DRV_VERSION "1.10a"
30 #define DRV_RELDATE "11/17/2001"
32 static const char version[] =
33 DRV_NAME ".c:v" DRV_VERSION " " DRV_RELDATE " Donald Becker (becker@scyld.com)\n";
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
42 Intel Microcommunications Databook, Vol. 1, 1990. It provides just enough
43 info that the casual reader might think that it documents the i82586 :-<.
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>
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/skbuff.h>
60 #include <linux/slab.h>
61 #include <linux/init.h>
62 #include <linux/bitops.h>
66 #include <asm/system.h>
67 #include <asm/uaccess.h>
69 /* use 0 for production, 1 for verification, 2..7 for debug */
73 static unsigned int net_debug = NET_DEBUG;
74 #define debug net_debug
78 Details of the i82586.
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:
87 Tx/Command block addr.
89 The command word accepts the following controls for the Tx and Rx units:
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
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.
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).
109 Some definitions related to the Command Word are:
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. */
116 CmdNOp = 0, CmdSASetup = 1, CmdConfigure = 2, CmdMulticastList = 3,
117 CmdTx = 4, CmdTDR = 5, CmdDump = 6, CmdDiagnose = 7};
119 /* Information that need to be kept for each board. */
127 ushort tx_pkts_in_ring;
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.
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
149 /* The ID port is used at boot-time to locate the ethercard. */
150 #define ID_PORT 0x100
152 /* Offsets to registers in the mailbox (SCB). */
153 #define iSCB_STATUS 0x8
155 #define iSCB_CBL 0xC /* Command BLock offset. */
156 #define iSCB_RFA 0xE /* Rx Frame Area offset. */
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
167 #define SCB_BASE ((unsigned)64*1024 - (dev->mem_end - dev->mem_start))
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.
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
179 The databook is particularly useless for the first two structures, I had
180 to use the Crynwr driver as an example.
182 The memory setup is as follows:
185 #define CONFIG_CMD 0x0018
186 #define SET_SA_CMD 0x0024
187 #define SA_OFFSET 0x002A
188 #define IDLELOOP 0x30
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. */
196 #define TX_BUF_START 0x0100
197 #define NUM_TX_BUFS 5
198 #define TX_BUF_SIZE (1518+14+20+16) /* packet+header+TBD */
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)
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
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.
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,
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.
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
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.
239 static 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(). */
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) */
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. */
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. */
262 /* 0x0024: Setup station address command. */
264 SET_MC_CMD, /* Next command. */
265 0xaa00,0xb000,0x0bad, /* Station address (to be filled in) */
267 /* 0x0030: NOP, looping back to itself. Point to first Tx buffer to Tx. */
268 0, CmdNOp, IDLELOOP, 0 /* pad */,
270 /* 0x0038: A unused Time-Domain Reflectometer command. */
271 0, CmdTDR, IDLELOOP, 0,
273 /* 0x0040: An unused Dump State command. */
274 0, CmdDump, IDLELOOP, DUMP_DATA,
276 /* 0x0048: An unused Diagnose command. */
277 0, CmdDiagnose, IDLELOOP,
279 /* 0x004E: An empty set-multicast-list command. */
280 0, CmdMulticastList, IDLELOOP, 0,
283 /* Index to functions, as function prototypes. */
285 static int el16_probe1(struct net_device *dev, int ioaddr);
286 static int el16_open(struct net_device *dev);
287 static int el16_send_packet(struct sk_buff *skb, struct net_device *dev);
288 static irqreturn_t el16_interrupt(int irq, void *dev_id);
289 static void el16_rx(struct net_device *dev);
290 static int el16_close(struct net_device *dev);
291 static void el16_tx_timeout (struct net_device *dev);
293 static void hardware_send_packet(struct net_device *dev, void *buf, short length, short pad);
294 static void init_82586_mem(struct net_device *dev);
295 static const struct ethtool_ops netdev_ethtool_ops;
296 static void init_rx_bufs(struct net_device *);
298 static int io = 0x300;
300 static int mem_start;
303 /* Check for a network adaptor of this type, and return '0' iff one exists.
304 If dev->base_addr == 0, probe all likely locations.
305 If dev->base_addr == 1, always return failure.
306 If dev->base_addr == 2, (detachable devices only) allocate space for the
307 device and return success.
310 struct net_device * __init el16_probe(int unit)
312 struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
313 static unsigned ports[] = { 0x300, 0x320, 0x340, 0x280, 0};
318 return ERR_PTR(-ENODEV);
321 sprintf(dev->name, "eth%d", unit);
322 netdev_boot_setup_check(dev);
325 mem_start = dev->mem_start & 15;
328 if (io > 0x1ff) /* Check a single specified location. */
329 err = el16_probe1(dev, io);
331 err = -ENXIO; /* Don't probe at all. */
333 for (port = ports; *port; port++) {
334 err = el16_probe1(dev, *port);
342 err = register_netdev(dev);
347 free_irq(dev->irq, dev);
348 iounmap(((struct net_local *)netdev_priv(dev))->base);
349 release_region(dev->base_addr, EL16_IO_EXTENT);
355 static const struct net_device_ops netdev_ops = {
356 .ndo_open = el16_open,
357 .ndo_stop = el16_close,
358 .ndo_start_xmit = el16_send_packet,
359 .ndo_tx_timeout = el16_tx_timeout,
360 .ndo_change_mtu = eth_change_mtu,
361 .ndo_set_mac_address = eth_mac_addr,
362 .ndo_validate_addr = eth_validate_addr,
365 static int __init el16_probe1(struct net_device *dev, int ioaddr)
367 static unsigned char init_ID_done, version_printed;
368 int i, irq, irqval, retval;
369 struct net_local *lp;
371 if (init_ID_done == 0) {
372 ushort lrs_state = 0xff;
373 /* Send the ID sequence to the ID_PORT to enable the board(s). */
375 for(i = 0; i < 255; i++) {
376 outb(lrs_state, ID_PORT);
378 if (lrs_state & 0x100)
385 if (!request_region(ioaddr, EL16_IO_EXTENT, DRV_NAME))
388 if ((inb(ioaddr) != '*') || (inb(ioaddr + 1) != '3') ||
389 (inb(ioaddr + 2) != 'C') || (inb(ioaddr + 3) != 'O')) {
394 if (net_debug && version_printed++ == 0)
397 printk("%s: 3c507 at %#x,", dev->name, ioaddr);
399 /* We should make a few more checks here, like the first three octets of
400 the S.A. for the manufacturer's code. */
402 irq = inb(ioaddr + IRQ_CONFIG) & 0x0f;
404 irqval = request_irq(irq, &el16_interrupt, 0, DRV_NAME, dev);
406 printk(KERN_ERR "3c507: unable to get IRQ %d (irqval=%d).\n", irq, irqval);
411 /* We've committed to using the board, and can start filling in *dev. */
412 dev->base_addr = ioaddr;
414 outb(0x01, ioaddr + MISC_CTRL);
415 for (i = 0; i < 6; i++)
416 dev->dev_addr[i] = inb(ioaddr + i);
417 printk(" %pM", dev->dev_addr);
420 net_debug = mem_start & 7;
423 dev->mem_start = MEM_BASE;
424 dev->mem_end = dev->mem_start + 0x10000;
429 char mem_config = inb(ioaddr + MEM_CONFIG);
430 if (mem_config & 0x20) {
432 base = 0xf00000 + (mem_config & 0x08 ? 0x080000
433 : ((mem_config & 3) << 17));
435 size = ((mem_config & 3) + 1) << 14;
436 base = 0x0c0000 + ( (mem_config & 0x18) << 12);
438 dev->mem_start = base;
439 dev->mem_end = base + size;
443 dev->if_port = (inb(ioaddr + ROM_CONFIG) & 0x80) ? 1 : 0;
444 dev->irq = inb(ioaddr + IRQ_CONFIG) & 0x0f;
446 printk(", IRQ %d, %sternal xcvr, memory %#lx-%#lx.\n", dev->irq,
447 dev->if_port ? "ex" : "in", dev->mem_start, dev->mem_end-1);
452 lp = netdev_priv(dev);
453 memset(lp, 0, sizeof(*lp));
454 spin_lock_init(&lp->lock);
455 lp->base = ioremap(dev->mem_start, RX_BUF_END);
457 printk(KERN_ERR "3c507: unable to remap memory\n");
462 dev->netdev_ops = &netdev_ops;
463 dev->watchdog_timeo = TX_TIMEOUT;
464 dev->ethtool_ops = &netdev_ethtool_ops;
465 dev->flags &= ~IFF_MULTICAST; /* Multicast doesn't work */
468 free_irq(dev->irq, dev);
470 release_region(ioaddr, EL16_IO_EXTENT);
474 static int el16_open(struct net_device *dev)
476 /* Initialize the 82586 memory and start it. */
479 netif_start_queue(dev);
484 static void el16_tx_timeout (struct net_device *dev)
486 struct net_local *lp = netdev_priv(dev);
487 int ioaddr = dev->base_addr;
488 void __iomem *shmem = lp->base;
491 printk ("%s: transmit timed out, %s? ", dev->name,
492 readw(shmem + iSCB_STATUS) & 0x8000 ? "IRQ conflict" :
493 "network cable problem");
494 /* Try to restart the adaptor. */
495 if (lp->last_restart == dev->stats.tx_packets) {
497 printk ("Resetting board.\n");
498 /* Completely reset the adaptor. */
499 init_82586_mem (dev);
500 lp->tx_pkts_in_ring = 0;
502 /* Issue the channel attention signal and hope it "gets better". */
504 printk ("Kicking board.\n");
505 writew(0xf000 | CUC_START | RX_START, shmem + iSCB_CMD);
506 outb (0, ioaddr + SIGNAL_CA); /* Issue channel-attn. */
507 lp->last_restart = dev->stats.tx_packets;
509 dev->trans_start = jiffies;
510 netif_wake_queue (dev);
514 static int el16_send_packet (struct sk_buff *skb, struct net_device *dev)
516 struct net_local *lp = netdev_priv(dev);
517 int ioaddr = dev->base_addr;
519 short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
520 unsigned char *buf = skb->data;
522 netif_stop_queue (dev);
524 spin_lock_irqsave (&lp->lock, flags);
526 dev->stats.tx_bytes += length;
527 /* Disable the 82586's input to the interrupt line. */
528 outb (0x80, ioaddr + MISC_CTRL);
530 hardware_send_packet (dev, buf, skb->len, length - skb->len);
532 dev->trans_start = jiffies;
533 /* Enable the 82586 interrupt input. */
534 outb (0x84, ioaddr + MISC_CTRL);
536 spin_unlock_irqrestore (&lp->lock, flags);
540 /* You might need to clean up and record Tx statistics here. */
545 /* The typical workload of the driver:
546 Handle the network interface interrupts. */
547 static irqreturn_t el16_interrupt(int irq, void *dev_id)
549 struct net_device *dev = dev_id;
550 struct net_local *lp;
551 int ioaddr, status, boguscount = 0;
556 printk ("net_interrupt(): irq %d for unknown device.\n", irq);
560 ioaddr = dev->base_addr;
561 lp = netdev_priv(dev);
564 spin_lock(&lp->lock);
566 status = readw(shmem+iSCB_STATUS);
569 printk("%s: 3c507 interrupt, status %4.4x.\n", dev->name, status);
572 /* Disable the 82586's input to the interrupt line. */
573 outb(0x80, ioaddr + MISC_CTRL);
575 /* Reap the Tx packet buffers. */
576 while (lp->tx_pkts_in_ring) {
577 unsigned short tx_status = readw(shmem+lp->tx_reap);
578 if (!(tx_status & 0x8000)) {
580 printk("Tx command incomplete (%#x).\n", lp->tx_reap);
583 /* Tx unsuccessful or some interesting status bit set. */
584 if (!(tx_status & 0x2000) || (tx_status & 0x0f3f)) {
585 dev->stats.tx_errors++;
586 if (tx_status & 0x0600) dev->stats.tx_carrier_errors++;
587 if (tx_status & 0x0100) dev->stats.tx_fifo_errors++;
588 if (!(tx_status & 0x0040)) dev->stats.tx_heartbeat_errors++;
589 if (tx_status & 0x0020) dev->stats.tx_aborted_errors++;
590 dev->stats.collisions += tx_status & 0xf;
592 dev->stats.tx_packets++;
594 printk("Reaped %x, Tx status %04x.\n" , lp->tx_reap, tx_status);
595 lp->tx_reap += TX_BUF_SIZE;
596 if (lp->tx_reap > RX_BUF_START - TX_BUF_SIZE)
597 lp->tx_reap = TX_BUF_START;
599 lp->tx_pkts_in_ring--;
600 /* There is always more space in the Tx ring buffer now. */
601 netif_wake_queue(dev);
603 if (++boguscount > 10)
607 if (status & 0x4000) { /* Packet received. */
609 printk("Received packet, rx_head %04x.\n", lp->rx_head);
613 /* Acknowledge the interrupt sources. */
614 ack_cmd = status & 0xf000;
616 if ((status & 0x0700) != 0x0200 && netif_running(dev)) {
618 printk("%s: Command unit stopped, status %04x, restarting.\n",
620 /* If this ever occurs we should really re-write the idle loop, reset
621 the Tx list, and do a complete restart of the command unit.
622 For now we rely on the Tx timeout if the resume doesn't work. */
623 ack_cmd |= CUC_RESUME;
626 if ((status & 0x0070) != 0x0040 && netif_running(dev)) {
627 /* The Rx unit is not ready, it must be hung. Restart the receiver by
628 initializing the rx buffers, and issuing an Rx start command. */
630 printk("%s: Rx unit stopped, status %04x, restarting.\n",
633 writew(RX_BUF_START,shmem+iSCB_RFA);
637 writew(ack_cmd,shmem+iSCB_CMD);
638 outb(0, ioaddr + SIGNAL_CA); /* Issue channel-attn. */
640 /* Clear the latched interrupt. */
641 outb(0, ioaddr + RESET_IRQ);
643 /* Enable the 82586's interrupt input. */
644 outb(0x84, ioaddr + MISC_CTRL);
645 spin_unlock(&lp->lock);
649 static int el16_close(struct net_device *dev)
651 struct net_local *lp = netdev_priv(dev);
652 int ioaddr = dev->base_addr;
653 void __iomem *shmem = lp->base;
655 netif_stop_queue(dev);
657 /* Flush the Tx and disable Rx. */
658 writew(RX_SUSPEND | CUC_SUSPEND,shmem+iSCB_CMD);
659 outb(0, ioaddr + SIGNAL_CA);
661 /* Disable the 82586's input to the interrupt line. */
662 outb(0x80, ioaddr + MISC_CTRL);
664 /* We always physically use the IRQ line, so we don't do free_irq(). */
666 /* Update the statistics here. */
671 /* Initialize the Rx-block list. */
672 static void init_rx_bufs(struct net_device *dev)
674 struct net_local *lp = netdev_priv(dev);
675 void __iomem *write_ptr;
676 unsigned short SCB_base = SCB_BASE;
678 int cur_rxbuf = lp->rx_head = RX_BUF_START;
680 /* Initialize each Rx frame + data buffer. */
681 do { /* While there is room for one more. */
683 write_ptr = lp->base + cur_rxbuf;
685 writew(0x0000,write_ptr); /* Status */
686 writew(0x0000,write_ptr+=2); /* Command */
687 writew(cur_rxbuf + RX_BUF_SIZE,write_ptr+=2); /* Link */
688 writew(cur_rxbuf + 22,write_ptr+=2); /* Buffer offset */
689 writew(0x0000,write_ptr+=2); /* Pad for dest addr. */
690 writew(0x0000,write_ptr+=2);
691 writew(0x0000,write_ptr+=2);
692 writew(0x0000,write_ptr+=2); /* Pad for source addr. */
693 writew(0x0000,write_ptr+=2);
694 writew(0x0000,write_ptr+=2);
695 writew(0x0000,write_ptr+=2); /* Pad for protocol. */
697 writew(0x0000,write_ptr+=2); /* Buffer: Actual count */
698 writew(-1,write_ptr+=2); /* Buffer: Next (none). */
699 writew(cur_rxbuf + 0x20 + SCB_base,write_ptr+=2);/* Buffer: Address low */
700 writew(0x0000,write_ptr+=2);
701 /* Finally, the number of bytes in the buffer. */
702 writew(0x8000 + RX_BUF_SIZE-0x20,write_ptr+=2);
704 lp->rx_tail = cur_rxbuf;
705 cur_rxbuf += RX_BUF_SIZE;
706 } while (cur_rxbuf <= RX_BUF_END - RX_BUF_SIZE);
708 /* Terminate the list by setting the EOL bit, and wrap the pointer to make
710 write_ptr = lp->base + lp->rx_tail + 2;
711 writew(0xC000,write_ptr); /* Command, mark as last. */
712 writew(lp->rx_head,write_ptr+2); /* Link */
715 static void init_82586_mem(struct net_device *dev)
717 struct net_local *lp = netdev_priv(dev);
718 short ioaddr = dev->base_addr;
719 void __iomem *shmem = lp->base;
721 /* Enable loopback to protect the wire while starting up,
722 and hold the 586 in reset during the memory initialization. */
723 outb(0x20, ioaddr + MISC_CTRL);
725 /* Fix the ISCP address and base. */
726 init_words[3] = SCB_BASE;
727 init_words[7] = SCB_BASE;
729 /* Write the words at 0xfff6 (address-aliased to 0xfffff6). */
730 memcpy_toio(lp->base + RX_BUF_END - 10, init_words, 10);
732 /* Write the words at 0x0000. */
733 memcpy_toio(lp->base, init_words + 5, sizeof(init_words) - 10);
735 /* Fill in the station address. */
736 memcpy_toio(lp->base+SA_OFFSET, dev->dev_addr,
737 sizeof(dev->dev_addr));
739 /* The Tx-block list is written as needed. We just set up the values. */
740 lp->tx_cmd_link = IDLELOOP + 4;
741 lp->tx_head = lp->tx_reap = TX_BUF_START;
745 /* Start the 586 by releasing the reset line, but leave loopback. */
746 outb(0xA0, ioaddr + MISC_CTRL);
748 /* This was time consuming to track down: you need to give two channel
749 attention signals to reliably start up the i82586. */
750 outb(0, ioaddr + SIGNAL_CA);
754 while (readw(shmem+iSCB_STATUS) == 0)
755 if (--boguscnt == 0) {
756 printk("%s: i82586 initialization timed out with status %04x, "
757 "cmd %04x.\n", dev->name,
758 readw(shmem+iSCB_STATUS), readw(shmem+iSCB_CMD));
761 /* Issue channel-attn -- the 82586 won't start. */
762 outb(0, ioaddr + SIGNAL_CA);
765 /* Disable loopback and enable interrupts. */
766 outb(0x84, ioaddr + MISC_CTRL);
768 printk("%s: Initialized 82586, status %04x.\n", dev->name,
769 readw(shmem+iSCB_STATUS));
773 static void hardware_send_packet(struct net_device *dev, void *buf, short length, short pad)
775 struct net_local *lp = netdev_priv(dev);
776 short ioaddr = dev->base_addr;
777 ushort tx_block = lp->tx_head;
778 void __iomem *write_ptr = lp->base + tx_block;
779 static char padding[ETH_ZLEN];
781 /* Set the write pointer to the Tx block, and put out the header. */
782 writew(0x0000,write_ptr); /* Tx status */
783 writew(CMD_INTR|CmdTx,write_ptr+=2); /* Tx command */
784 writew(tx_block+16,write_ptr+=2); /* Next command is a NoOp. */
785 writew(tx_block+8,write_ptr+=2); /* Data Buffer offset. */
787 /* Output the data buffer descriptor. */
788 writew((pad + length) | 0x8000,write_ptr+=2); /* Byte count parameter. */
789 writew(-1,write_ptr+=2); /* No next data buffer. */
790 writew(tx_block+22+SCB_BASE,write_ptr+=2); /* Buffer follows the NoOp command. */
791 writew(0x0000,write_ptr+=2); /* Buffer address high bits (always zero). */
793 /* Output the Loop-back NoOp command. */
794 writew(0x0000,write_ptr+=2); /* Tx status */
795 writew(CmdNOp,write_ptr+=2); /* Tx command */
796 writew(tx_block+16,write_ptr+=2); /* Next is myself. */
798 /* Output the packet at the write pointer. */
799 memcpy_toio(write_ptr+2, buf, length);
801 memcpy_toio(write_ptr+length+2, padding, pad);
803 /* Set the old command link pointing to this send packet. */
804 writew(tx_block,lp->base + lp->tx_cmd_link);
805 lp->tx_cmd_link = tx_block + 20;
807 /* Set the next free tx region. */
808 lp->tx_head = tx_block + TX_BUF_SIZE;
809 if (lp->tx_head > RX_BUF_START - TX_BUF_SIZE)
810 lp->tx_head = TX_BUF_START;
813 printk("%s: 3c507 @%x send length = %d, tx_block %3x, next %3x.\n",
814 dev->name, ioaddr, length, tx_block, lp->tx_head);
817 /* Grimly block further packets if there has been insufficient reaping. */
818 if (++lp->tx_pkts_in_ring < NUM_TX_BUFS)
819 netif_wake_queue(dev);
822 static void el16_rx(struct net_device *dev)
824 struct net_local *lp = netdev_priv(dev);
825 void __iomem *shmem = lp->base;
826 ushort rx_head = lp->rx_head;
827 ushort rx_tail = lp->rx_tail;
828 ushort boguscount = 10;
831 while ((frame_status = readw(shmem+rx_head)) < 0) { /* Command complete */
832 void __iomem *read_frame = lp->base + rx_head;
833 ushort rfd_cmd = readw(read_frame+2);
834 ushort next_rx_frame = readw(read_frame+4);
835 ushort data_buffer_addr = readw(read_frame+6);
836 void __iomem *data_frame = lp->base + data_buffer_addr;
837 ushort pkt_len = readw(data_frame);
839 if (rfd_cmd != 0 || data_buffer_addr != rx_head + 22
840 || (pkt_len & 0xC000) != 0xC000) {
841 printk(KERN_ERR "%s: Rx frame at %#x corrupted, "
842 "status %04x cmd %04x next %04x "
843 "data-buf @%04x %04x.\n",
844 dev->name, rx_head, frame_status, rfd_cmd,
845 next_rx_frame, data_buffer_addr, pkt_len);
846 } else if ((frame_status & 0x2000) == 0) {
847 /* Frame Rxed, but with error. */
848 dev->stats.rx_errors++;
849 if (frame_status & 0x0800) dev->stats.rx_crc_errors++;
850 if (frame_status & 0x0400) dev->stats.rx_frame_errors++;
851 if (frame_status & 0x0200) dev->stats.rx_fifo_errors++;
852 if (frame_status & 0x0100) dev->stats.rx_over_errors++;
853 if (frame_status & 0x0080) dev->stats.rx_length_errors++;
855 /* Malloc up new buffer. */
859 skb = dev_alloc_skb(pkt_len+2);
861 printk(KERN_ERR "%s: Memory squeeze, "
862 "dropping packet.\n",
864 dev->stats.rx_dropped++;
870 /* 'skb->data' points to the start of sk_buff data area. */
871 memcpy_fromio(skb_put(skb,pkt_len), data_frame + 10, pkt_len);
873 skb->protocol=eth_type_trans(skb,dev);
875 dev->stats.rx_packets++;
876 dev->stats.rx_bytes += pkt_len;
879 /* Clear the status word and set End-of-List on the rx frame. */
880 writew(0,read_frame);
881 writew(0xC000,read_frame+2);
882 /* Clear the end-of-list on the prev. RFD. */
883 writew(0x0000,lp->base + rx_tail + 2);
886 rx_head = next_rx_frame;
887 if (--boguscount == 0)
891 lp->rx_head = rx_head;
892 lp->rx_tail = rx_tail;
895 static void netdev_get_drvinfo(struct net_device *dev,
896 struct ethtool_drvinfo *info)
898 strcpy(info->driver, DRV_NAME);
899 strcpy(info->version, DRV_VERSION);
900 sprintf(info->bus_info, "ISA 0x%lx", dev->base_addr);
903 static u32 netdev_get_msglevel(struct net_device *dev)
908 static void netdev_set_msglevel(struct net_device *dev, u32 level)
913 static const struct ethtool_ops netdev_ethtool_ops = {
914 .get_drvinfo = netdev_get_drvinfo,
915 .get_msglevel = netdev_get_msglevel,
916 .set_msglevel = netdev_set_msglevel,
920 static struct net_device *dev_3c507;
921 module_param(io, int, 0);
922 module_param(irq, int, 0);
923 MODULE_PARM_DESC(io, "EtherLink16 I/O base address");
924 MODULE_PARM_DESC(irq, "(ignored)");
926 int __init init_module(void)
929 printk("3c507: You should not use auto-probing with insmod!\n");
930 dev_3c507 = el16_probe(-1);
931 return IS_ERR(dev_3c507) ? PTR_ERR(dev_3c507) : 0;
937 struct net_device *dev = dev_3c507;
938 unregister_netdev(dev);
939 free_irq(dev->irq, dev);
940 iounmap(((struct net_local *)netdev_priv(dev))->base);
941 release_region(dev->base_addr, EL16_IO_EXTENT);
945 MODULE_LICENSE("GPL");