diff options
author | Jonathan Herman <hermanjl@cs.unc.edu> | 2013-01-22 10:38:37 -0500 |
---|---|---|
committer | Jonathan Herman <hermanjl@cs.unc.edu> | 2013-01-22 10:38:37 -0500 |
commit | fcc9d2e5a6c89d22b8b773a64fb4ad21ac318446 (patch) | |
tree | a57612d1888735a2ec7972891b68c1ac5ec8faea /drivers/net/3c507.c | |
parent | 8dea78da5cee153b8af9c07a2745f6c55057fe12 (diff) |
Diffstat (limited to 'drivers/net/3c507.c')
-rw-r--r-- | drivers/net/3c507.c | 939 |
1 files changed, 939 insertions, 0 deletions
diff --git a/drivers/net/3c507.c b/drivers/net/3c507.c new file mode 100644 index 00000000000..1e945551c14 --- /dev/null +++ b/drivers/net/3c507.c | |||
@@ -0,0 +1,939 @@ | |||
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 | |||
32 | static 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 | ||
73 | static 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 | |||
115 | enum 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. */ | ||
120 | struct 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 (HZ/20) | ||
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 | |||
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(). */ | ||
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 | |||
285 | static int el16_probe1(struct net_device *dev, int ioaddr); | ||
286 | static int el16_open(struct net_device *dev); | ||
287 | static netdev_tx_t el16_send_packet(struct sk_buff *skb, | ||
288 | struct net_device *dev); | ||
289 | static irqreturn_t el16_interrupt(int irq, void *dev_id); | ||
290 | static void el16_rx(struct net_device *dev); | ||
291 | static int el16_close(struct net_device *dev); | ||
292 | static void el16_tx_timeout (struct net_device *dev); | ||
293 | |||
294 | static void hardware_send_packet(struct net_device *dev, void *buf, short length, short pad); | ||
295 | static void init_82586_mem(struct net_device *dev); | ||
296 | static const struct ethtool_ops netdev_ethtool_ops; | ||
297 | static void init_rx_bufs(struct net_device *); | ||
298 | |||
299 | static int io = 0x300; | ||
300 | static int irq; | ||
301 | static 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 | |||
311 | struct net_device * __init el16_probe(int unit) | ||
312 | { | ||
313 | struct net_device *dev = alloc_etherdev(sizeof(struct net_local)); | ||
314 | static const unsigned ports[] = { 0x300, 0x320, 0x340, 0x280, 0}; | ||
315 | const 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; | ||
347 | out1: | ||
348 | free_irq(dev->irq, dev); | ||
349 | iounmap(((struct net_local *)netdev_priv(dev))->base); | ||
350 | release_region(dev->base_addr, EL16_IO_EXTENT); | ||
351 | out: | ||
352 | free_netdev(dev); | ||
353 | return ERR_PTR(err); | ||
354 | } | ||
355 | |||
356 | static 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 | |||
366 | static 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; | ||
465 | out1: | ||
466 | free_irq(dev->irq, dev); | ||
467 | out: | ||
468 | release_region(ioaddr, EL16_IO_EXTENT); | ||
469 | return retval; | ||
470 | } | ||
471 | |||
472 | static 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 | |||
482 | static 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 | |||
512 | static 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. */ | ||
545 | static 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 | |||
647 | static 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. */ | ||
670 | static 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 | |||
713 | static 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 | |||
768 | static 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 | |||
817 | static 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 | |||
889 | static 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 | |||
897 | static u32 netdev_get_msglevel(struct net_device *dev) | ||
898 | { | ||
899 | return debug; | ||
900 | } | ||
901 | |||
902 | static void netdev_set_msglevel(struct net_device *dev, u32 level) | ||
903 | { | ||
904 | debug = level; | ||
905 | } | ||
906 | |||
907 | static 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 | ||
914 | static struct net_device *dev_3c507; | ||
915 | module_param(io, int, 0); | ||
916 | module_param(irq, int, 0); | ||
917 | MODULE_PARM_DESC(io, "EtherLink16 I/O base address"); | ||
918 | MODULE_PARM_DESC(irq, "(ignored)"); | ||
919 | |||
920 | int __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 | |||
928 | void __exit | ||
929 | cleanup_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 */ | ||
939 | MODULE_LICENSE("GPL"); | ||