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