blob: b32b7a1710b735dd3a074d4073baf94b3256b301 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* 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>
Daniel Drake1f044932009-12-24 08:11:24 +000059#include <linux/if_ether.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070060#include <linux/skbuff.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070061#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 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121 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);
Stephen Hemminger27a1de92009-08-31 19:50:54 +0000287static netdev_tx_t el16_send_packet(struct sk_buff *skb,
288 struct net_device *dev);
David Howells7d12e782006-10-05 14:55:46 +0100289static irqreturn_t el16_interrupt(int irq, void *dev_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290static void el16_rx(struct net_device *dev);
291static int el16_close(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292static 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);
Jeff Garzik7282d492006-09-13 14:30:00 -0400296static const struct ethtool_ops netdev_ethtool_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297static void init_rx_bufs(struct net_device *);
298
299static int io = 0x300;
300static int irq;
301static int mem_start;
302
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400303
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304/* 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 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
Stephen Hemminger1722de52009-01-09 13:01:13 +0000356static 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366static int __init el16_probe1(struct net_device *dev, int ioaddr)
367{
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000368 static unsigned char init_ID_done;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 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
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400389 if ((inb(ioaddr) != '*') || (inb(ioaddr + 1) != '3') ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 (inb(ioaddr + 2) != 'C') || (inb(ioaddr + 3) != 'O')) {
391 retval = -ENODEV;
392 goto out;
393 }
394
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000395 pr_info("%s: 3c507 at %#x,", dev->name, ioaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396
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
Joe Perchesa0607fd2009-11-18 23:29:17 -0800402 irqval = request_irq(irq, el16_interrupt, 0, DRV_NAME, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403 if (irqval) {
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000404 pr_cont("\n");
405 pr_err("3c507: unable to get IRQ %d (irqval=%d).\n", irq, irqval);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 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);
Joe Perches0795af52007-10-03 17:59:30 -0700414 for (i = 0; i < 6; i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 dev->dev_addr[i] = inb(ioaddr + i);
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000416 pr_cont(" %pM", dev->dev_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417
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
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000445 pr_cont(", IRQ %d, %sternal xcvr, memory %#lx-%#lx.\n", dev->irq,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446 dev->if_port ? "ex" : "in", dev->mem_start, dev->mem_end-1);
447
448 if (net_debug)
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000449 pr_debug("%s", version);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450
451 lp = netdev_priv(dev);
452 memset(lp, 0, sizeof(*lp));
453 spin_lock_init(&lp->lock);
454 lp->base = ioremap(dev->mem_start, RX_BUF_END);
455 if (!lp->base) {
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000456 pr_err("3c507: unable to remap memory\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 retval = -EAGAIN;
458 goto out1;
459 }
460
Stephen Hemminger1722de52009-01-09 13:01:13 +0000461 dev->netdev_ops = &netdev_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 dev->watchdog_timeo = TX_TIMEOUT;
463 dev->ethtool_ops = &netdev_ethtool_ops;
464 dev->flags &= ~IFF_MULTICAST; /* Multicast doesn't work */
465 return 0;
466out1:
467 free_irq(dev->irq, dev);
468out:
469 release_region(ioaddr, EL16_IO_EXTENT);
470 return retval;
471}
472
473static int el16_open(struct net_device *dev)
474{
475 /* Initialize the 82586 memory and start it. */
476 init_82586_mem(dev);
477
478 netif_start_queue(dev);
479 return 0;
480}
481
482
483static void el16_tx_timeout (struct net_device *dev)
484{
485 struct net_local *lp = netdev_priv(dev);
486 int ioaddr = dev->base_addr;
487 void __iomem *shmem = lp->base;
488
489 if (net_debug > 1)
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000490 pr_debug("%s: transmit timed out, %s? ", dev->name,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491 readw(shmem + iSCB_STATUS) & 0x8000 ? "IRQ conflict" :
492 "network cable problem");
493 /* Try to restart the adaptor. */
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700494 if (lp->last_restart == dev->stats.tx_packets) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495 if (net_debug > 1)
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000496 pr_cont("Resetting board.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497 /* Completely reset the adaptor. */
498 init_82586_mem (dev);
499 lp->tx_pkts_in_ring = 0;
500 } else {
501 /* Issue the channel attention signal and hope it "gets better". */
502 if (net_debug > 1)
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000503 pr_cont("Kicking board.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504 writew(0xf000 | CUC_START | RX_START, shmem + iSCB_CMD);
505 outb (0, ioaddr + SIGNAL_CA); /* Issue channel-attn. */
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700506 lp->last_restart = dev->stats.tx_packets;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 }
508 dev->trans_start = jiffies;
509 netif_wake_queue (dev);
510}
511
512
Stephen Hemminger27a1de92009-08-31 19:50:54 +0000513static netdev_tx_t el16_send_packet (struct sk_buff *skb,
514 struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515{
516 struct net_local *lp = netdev_priv(dev);
517 int ioaddr = dev->base_addr;
518 unsigned long flags;
519 short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
520 unsigned char *buf = skb->data;
521
522 netif_stop_queue (dev);
523
524 spin_lock_irqsave (&lp->lock, flags);
525
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700526 dev->stats.tx_bytes += length;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 /* Disable the 82586's input to the interrupt line. */
528 outb (0x80, ioaddr + MISC_CTRL);
529
530 hardware_send_packet (dev, buf, skb->len, length - skb->len);
531
532 dev->trans_start = jiffies;
533 /* Enable the 82586 interrupt input. */
534 outb (0x84, ioaddr + MISC_CTRL);
535
536 spin_unlock_irqrestore (&lp->lock, flags);
537
538 dev_kfree_skb (skb);
539
540 /* You might need to clean up and record Tx statistics here. */
541
Patrick McHardy6ed10652009-06-23 06:03:08 +0000542 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543}
544
545/* The typical workload of the driver:
546 Handle the network interface interrupts. */
David Howells7d12e782006-10-05 14:55:46 +0100547static irqreturn_t el16_interrupt(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548{
549 struct net_device *dev = dev_id;
550 struct net_local *lp;
551 int ioaddr, status, boguscount = 0;
552 ushort ack_cmd = 0;
553 void __iomem *shmem;
554
555 if (dev == NULL) {
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000556 pr_err("%s: net_interrupt(): irq %d for unknown device.\n",
557 dev->name, irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558 return IRQ_NONE;
559 }
560
561 ioaddr = dev->base_addr;
562 lp = netdev_priv(dev);
563 shmem = lp->base;
564
565 spin_lock(&lp->lock);
566
567 status = readw(shmem+iSCB_STATUS);
568
569 if (net_debug > 4) {
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000570 pr_debug("%s: 3c507 interrupt, status %4.4x.\n", dev->name, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571 }
572
573 /* Disable the 82586's input to the interrupt line. */
574 outb(0x80, ioaddr + MISC_CTRL);
575
576 /* Reap the Tx packet buffers. */
577 while (lp->tx_pkts_in_ring) {
578 unsigned short tx_status = readw(shmem+lp->tx_reap);
579 if (!(tx_status & 0x8000)) {
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400580 if (net_debug > 5)
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000581 pr_debug("Tx command incomplete (%#x).\n", lp->tx_reap);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 break;
583 }
584 /* Tx unsuccessful or some interesting status bit set. */
585 if (!(tx_status & 0x2000) || (tx_status & 0x0f3f)) {
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700586 dev->stats.tx_errors++;
587 if (tx_status & 0x0600) dev->stats.tx_carrier_errors++;
588 if (tx_status & 0x0100) dev->stats.tx_fifo_errors++;
589 if (!(tx_status & 0x0040)) dev->stats.tx_heartbeat_errors++;
590 if (tx_status & 0x0020) dev->stats.tx_aborted_errors++;
591 dev->stats.collisions += tx_status & 0xf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 }
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700593 dev->stats.tx_packets++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594 if (net_debug > 5)
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000595 pr_debug("Reaped %x, Tx status %04x.\n" , lp->tx_reap, tx_status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596 lp->tx_reap += TX_BUF_SIZE;
597 if (lp->tx_reap > RX_BUF_START - TX_BUF_SIZE)
598 lp->tx_reap = TX_BUF_START;
599
600 lp->tx_pkts_in_ring--;
601 /* There is always more space in the Tx ring buffer now. */
602 netif_wake_queue(dev);
603
604 if (++boguscount > 10)
605 break;
606 }
607
608 if (status & 0x4000) { /* Packet received. */
609 if (net_debug > 5)
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000610 pr_debug("Received packet, rx_head %04x.\n", lp->rx_head);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611 el16_rx(dev);
612 }
613
614 /* Acknowledge the interrupt sources. */
615 ack_cmd = status & 0xf000;
616
617 if ((status & 0x0700) != 0x0200 && netif_running(dev)) {
618 if (net_debug)
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000619 pr_debug("%s: Command unit stopped, status %04x, restarting.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620 dev->name, status);
621 /* If this ever occurs we should really re-write the idle loop, reset
622 the Tx list, and do a complete restart of the command unit.
623 For now we rely on the Tx timeout if the resume doesn't work. */
624 ack_cmd |= CUC_RESUME;
625 }
626
627 if ((status & 0x0070) != 0x0040 && netif_running(dev)) {
628 /* The Rx unit is not ready, it must be hung. Restart the receiver by
629 initializing the rx buffers, and issuing an Rx start command. */
630 if (net_debug)
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000631 pr_debug("%s: Rx unit stopped, status %04x, restarting.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632 dev->name, status);
633 init_rx_bufs(dev);
634 writew(RX_BUF_START,shmem+iSCB_RFA);
635 ack_cmd |= RX_START;
636 }
637
638 writew(ack_cmd,shmem+iSCB_CMD);
639 outb(0, ioaddr + SIGNAL_CA); /* Issue channel-attn. */
640
641 /* Clear the latched interrupt. */
642 outb(0, ioaddr + RESET_IRQ);
643
644 /* Enable the 82586's interrupt input. */
645 outb(0x84, ioaddr + MISC_CTRL);
646 spin_unlock(&lp->lock);
647 return IRQ_HANDLED;
648}
649
650static int el16_close(struct net_device *dev)
651{
652 struct net_local *lp = netdev_priv(dev);
653 int ioaddr = dev->base_addr;
654 void __iomem *shmem = lp->base;
655
656 netif_stop_queue(dev);
657
658 /* Flush the Tx and disable Rx. */
659 writew(RX_SUSPEND | CUC_SUSPEND,shmem+iSCB_CMD);
660 outb(0, ioaddr + SIGNAL_CA);
661
662 /* Disable the 82586's input to the interrupt line. */
663 outb(0x80, ioaddr + MISC_CTRL);
664
665 /* We always physically use the IRQ line, so we don't do free_irq(). */
666
667 /* Update the statistics here. */
668
669 return 0;
670}
671
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672/* Initialize the Rx-block list. */
673static void init_rx_bufs(struct net_device *dev)
674{
675 struct net_local *lp = netdev_priv(dev);
676 void __iomem *write_ptr;
677 unsigned short SCB_base = SCB_BASE;
678
679 int cur_rxbuf = lp->rx_head = RX_BUF_START;
680
681 /* Initialize each Rx frame + data buffer. */
682 do { /* While there is room for one more. */
683
684 write_ptr = lp->base + cur_rxbuf;
685
686 writew(0x0000,write_ptr); /* Status */
687 writew(0x0000,write_ptr+=2); /* Command */
688 writew(cur_rxbuf + RX_BUF_SIZE,write_ptr+=2); /* Link */
689 writew(cur_rxbuf + 22,write_ptr+=2); /* Buffer offset */
690 writew(0x0000,write_ptr+=2); /* Pad for dest addr. */
691 writew(0x0000,write_ptr+=2);
692 writew(0x0000,write_ptr+=2);
693 writew(0x0000,write_ptr+=2); /* Pad for source addr. */
694 writew(0x0000,write_ptr+=2);
695 writew(0x0000,write_ptr+=2);
696 writew(0x0000,write_ptr+=2); /* Pad for protocol. */
697
698 writew(0x0000,write_ptr+=2); /* Buffer: Actual count */
699 writew(-1,write_ptr+=2); /* Buffer: Next (none). */
700 writew(cur_rxbuf + 0x20 + SCB_base,write_ptr+=2);/* Buffer: Address low */
701 writew(0x0000,write_ptr+=2);
702 /* Finally, the number of bytes in the buffer. */
703 writew(0x8000 + RX_BUF_SIZE-0x20,write_ptr+=2);
704
705 lp->rx_tail = cur_rxbuf;
706 cur_rxbuf += RX_BUF_SIZE;
707 } while (cur_rxbuf <= RX_BUF_END - RX_BUF_SIZE);
708
709 /* Terminate the list by setting the EOL bit, and wrap the pointer to make
710 the list a ring. */
711 write_ptr = lp->base + lp->rx_tail + 2;
712 writew(0xC000,write_ptr); /* Command, mark as last. */
713 writew(lp->rx_head,write_ptr+2); /* Link */
714}
715
716static void init_82586_mem(struct net_device *dev)
717{
718 struct net_local *lp = netdev_priv(dev);
719 short ioaddr = dev->base_addr;
720 void __iomem *shmem = lp->base;
721
722 /* Enable loopback to protect the wire while starting up,
723 and hold the 586 in reset during the memory initialization. */
724 outb(0x20, ioaddr + MISC_CTRL);
725
726 /* Fix the ISCP address and base. */
727 init_words[3] = SCB_BASE;
728 init_words[7] = SCB_BASE;
729
730 /* Write the words at 0xfff6 (address-aliased to 0xfffff6). */
731 memcpy_toio(lp->base + RX_BUF_END - 10, init_words, 10);
732
733 /* Write the words at 0x0000. */
734 memcpy_toio(lp->base, init_words + 5, sizeof(init_words) - 10);
735
736 /* Fill in the station address. */
Daniel Drake1f044932009-12-24 08:11:24 +0000737 memcpy_toio(lp->base+SA_OFFSET, dev->dev_addr, ETH_ALEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738
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;
742
743 init_rx_bufs(dev);
744
745 /* Start the 586 by releasing the reset line, but leave loopback. */
746 outb(0xA0, ioaddr + MISC_CTRL);
747
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);
751
752 {
753 int boguscnt = 50;
754 while (readw(shmem+iSCB_STATUS) == 0)
755 if (--boguscnt == 0) {
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000756 pr_warning("%s: i82586 initialization timed out with status %04x, cmd %04x.\n",
757 dev->name, readw(shmem+iSCB_STATUS), readw(shmem+iSCB_CMD));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758 break;
759 }
760 /* Issue channel-attn -- the 82586 won't start. */
761 outb(0, ioaddr + SIGNAL_CA);
762 }
763
764 /* Disable loopback and enable interrupts. */
765 outb(0x84, ioaddr + MISC_CTRL);
766 if (net_debug > 4)
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000767 pr_debug("%s: Initialized 82586, status %04x.\n", dev->name,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768 readw(shmem+iSCB_STATUS));
769 return;
770}
771
772static void hardware_send_packet(struct net_device *dev, void *buf, short length, short pad)
773{
774 struct net_local *lp = netdev_priv(dev);
775 short ioaddr = dev->base_addr;
776 ushort tx_block = lp->tx_head;
777 void __iomem *write_ptr = lp->base + tx_block;
778 static char padding[ETH_ZLEN];
779
780 /* Set the write pointer to the Tx block, and put out the header. */
781 writew(0x0000,write_ptr); /* Tx status */
782 writew(CMD_INTR|CmdTx,write_ptr+=2); /* Tx command */
783 writew(tx_block+16,write_ptr+=2); /* Next command is a NoOp. */
784 writew(tx_block+8,write_ptr+=2); /* Data Buffer offset. */
785
786 /* Output the data buffer descriptor. */
787 writew((pad + length) | 0x8000,write_ptr+=2); /* Byte count parameter. */
788 writew(-1,write_ptr+=2); /* No next data buffer. */
789 writew(tx_block+22+SCB_BASE,write_ptr+=2); /* Buffer follows the NoOp command. */
790 writew(0x0000,write_ptr+=2); /* Buffer address high bits (always zero). */
791
792 /* Output the Loop-back NoOp command. */
793 writew(0x0000,write_ptr+=2); /* Tx status */
794 writew(CmdNOp,write_ptr+=2); /* Tx command */
795 writew(tx_block+16,write_ptr+=2); /* Next is myself. */
796
797 /* Output the packet at the write pointer. */
798 memcpy_toio(write_ptr+2, buf, length);
799 if (pad)
800 memcpy_toio(write_ptr+length+2, padding, pad);
801
802 /* Set the old command link pointing to this send packet. */
803 writew(tx_block,lp->base + lp->tx_cmd_link);
804 lp->tx_cmd_link = tx_block + 20;
805
806 /* Set the next free tx region. */
807 lp->tx_head = tx_block + TX_BUF_SIZE;
808 if (lp->tx_head > RX_BUF_START - TX_BUF_SIZE)
809 lp->tx_head = TX_BUF_START;
810
811 if (net_debug > 4) {
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000812 pr_debug("%s: 3c507 @%x send length = %d, tx_block %3x, next %3x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813 dev->name, ioaddr, length, tx_block, lp->tx_head);
814 }
815
816 /* Grimly block further packets if there has been insufficient reaping. */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400817 if (++lp->tx_pkts_in_ring < NUM_TX_BUFS)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818 netif_wake_queue(dev);
819}
820
821static void el16_rx(struct net_device *dev)
822{
823 struct net_local *lp = netdev_priv(dev);
824 void __iomem *shmem = lp->base;
825 ushort rx_head = lp->rx_head;
826 ushort rx_tail = lp->rx_tail;
827 ushort boguscount = 10;
828 short frame_status;
829
830 while ((frame_status = readw(shmem+rx_head)) < 0) { /* Command complete */
831 void __iomem *read_frame = lp->base + rx_head;
832 ushort rfd_cmd = readw(read_frame+2);
833 ushort next_rx_frame = readw(read_frame+4);
834 ushort data_buffer_addr = readw(read_frame+6);
835 void __iomem *data_frame = lp->base + data_buffer_addr;
836 ushort pkt_len = readw(data_frame);
837
Joe Perches8e95a202009-12-03 07:58:21 +0000838 if (rfd_cmd != 0 || data_buffer_addr != rx_head + 22 ||
839 (pkt_len & 0xC000) != 0xC000) {
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000840 pr_err("%s: Rx frame at %#x corrupted, "
Jeff Garzikcba05162007-11-23 21:50:34 -0500841 "status %04x cmd %04x next %04x "
842 "data-buf @%04x %04x.\n",
843 dev->name, rx_head, frame_status, rfd_cmd,
844 next_rx_frame, data_buffer_addr, pkt_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845 } else if ((frame_status & 0x2000) == 0) {
846 /* Frame Rxed, but with error. */
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700847 dev->stats.rx_errors++;
848 if (frame_status & 0x0800) dev->stats.rx_crc_errors++;
849 if (frame_status & 0x0400) dev->stats.rx_frame_errors++;
850 if (frame_status & 0x0200) dev->stats.rx_fifo_errors++;
851 if (frame_status & 0x0100) dev->stats.rx_over_errors++;
852 if (frame_status & 0x0080) dev->stats.rx_length_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853 } else {
854 /* Malloc up new buffer. */
855 struct sk_buff *skb;
856
857 pkt_len &= 0x3fff;
858 skb = dev_alloc_skb(pkt_len+2);
859 if (skb == NULL) {
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000860 pr_err("%s: Memory squeeze, dropping packet.\n",
Jeff Garzikcba05162007-11-23 21:50:34 -0500861 dev->name);
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700862 dev->stats.rx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863 break;
864 }
865
866 skb_reserve(skb,2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867
868 /* 'skb->data' points to the start of sk_buff data area. */
869 memcpy_fromio(skb_put(skb,pkt_len), data_frame + 10, pkt_len);
870
871 skb->protocol=eth_type_trans(skb,dev);
872 netif_rx(skb);
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700873 dev->stats.rx_packets++;
874 dev->stats.rx_bytes += pkt_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875 }
876
877 /* Clear the status word and set End-of-List on the rx frame. */
878 writew(0,read_frame);
879 writew(0xC000,read_frame+2);
880 /* Clear the end-of-list on the prev. RFD. */
881 writew(0x0000,lp->base + rx_tail + 2);
882
883 rx_tail = rx_head;
884 rx_head = next_rx_frame;
885 if (--boguscount == 0)
886 break;
887 }
888
889 lp->rx_head = rx_head;
890 lp->rx_tail = rx_tail;
891}
892
893static void netdev_get_drvinfo(struct net_device *dev,
894 struct ethtool_drvinfo *info)
895{
896 strcpy(info->driver, DRV_NAME);
897 strcpy(info->version, DRV_VERSION);
898 sprintf(info->bus_info, "ISA 0x%lx", dev->base_addr);
899}
900
901static u32 netdev_get_msglevel(struct net_device *dev)
902{
903 return debug;
904}
905
906static void netdev_set_msglevel(struct net_device *dev, u32 level)
907{
908 debug = level;
909}
910
Jeff Garzik7282d492006-09-13 14:30:00 -0400911static const struct ethtool_ops netdev_ethtool_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912 .get_drvinfo = netdev_get_drvinfo,
913 .get_msglevel = netdev_get_msglevel,
914 .set_msglevel = netdev_set_msglevel,
915};
916
917#ifdef MODULE
918static struct net_device *dev_3c507;
919module_param(io, int, 0);
920module_param(irq, int, 0);
921MODULE_PARM_DESC(io, "EtherLink16 I/O base address");
922MODULE_PARM_DESC(irq, "(ignored)");
923
Randy Dunlap96e672c2006-06-10 13:33:48 -0700924int __init init_module(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925{
926 if (io == 0)
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000927 pr_notice("3c507: You should not use auto-probing with insmod!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928 dev_3c507 = el16_probe(-1);
929 return IS_ERR(dev_3c507) ? PTR_ERR(dev_3c507) : 0;
930}
931
Al Viroafc8eb42006-06-14 18:50:53 -0400932void __exit
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933cleanup_module(void)
934{
935 struct net_device *dev = dev_3c507;
936 unregister_netdev(dev);
937 free_irq(dev->irq, dev);
938 iounmap(((struct net_local *)netdev_priv(dev))->base);
939 release_region(dev->base_addr, EL16_IO_EXTENT);
940 free_netdev(dev);
941}
942#endif /* MODULE */
943MODULE_LICENSE("GPL");