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