blob: 554a26c551887f69662211c53d33e2c781afc921 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* 3c503.c: A shared-memory NS8390 ethernet driver for linux. */
2/*
3 Written 1992-94 by Donald Becker.
4
5 Copyright 1993 United States Government as represented by the
6 Director, National Security Agency. This software may be used and
7 distributed according to the terms of the GNU General Public License,
8 incorporated herein by reference.
9
10 The author may be reached as becker@scyld.com, or C/O
11 Scyld Computing Corporation
12 410 Severn Ave., Suite 210
13 Annapolis MD 21403
14
15
16 This driver should work with the 3c503 and 3c503/16. It should be used
17 in shared memory mode for best performance, although it may also work
18 in programmed-I/O mode.
19
20 Sources:
21 EtherLink II Technical Reference Manual,
22 EtherLink II/16 Technical Reference Manual Supplement,
23 3Com Corporation, 5400 Bayfront Plaza, Santa Clara CA 95052-8145
24
25 The Crynwr 3c503 packet driver.
26
27 Changelog:
28
29 Paul Gortmaker : add support for the 2nd 8kB of RAM on 16 bit cards.
30 Paul Gortmaker : multiple card support for module users.
31 rjohnson@analogic.com : Fix up PIO interface for efficient operation.
32 Jeff Garzik : ethtool support
33
34*/
35
36#define DRV_NAME "3c503"
37#define DRV_VERSION "1.10a"
38#define DRV_RELDATE "11/17/2001"
39
40
41static const char version[] =
42 DRV_NAME ".c:v" DRV_VERSION " " DRV_RELDATE " Donald Becker (becker@scyld.com)\n";
43
44#include <linux/module.h>
45#include <linux/kernel.h>
46#include <linux/errno.h>
47#include <linux/string.h>
48#include <linux/delay.h>
49#include <linux/netdevice.h>
50#include <linux/etherdevice.h>
51#include <linux/init.h>
Alexey Dobriyana6b7a402011-06-06 10:43:46 +000052#include <linux/interrupt.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070053#include <linux/ethtool.h>
54
55#include <asm/uaccess.h>
56#include <asm/io.h>
57#include <asm/system.h>
58#include <asm/byteorder.h>
59
60#include "8390.h"
61#include "3c503.h"
62#define WRD_COUNT 4
63
64static int el2_pio_probe(struct net_device *dev);
65static int el2_probe1(struct net_device *dev, int ioaddr);
66
67/* A zero-terminated list of I/O addresses to be probed in PIO mode. */
68static unsigned int netcard_portlist[] __initdata =
69 { 0x300,0x310,0x330,0x350,0x250,0x280,0x2a0,0x2e0,0};
70
71#define EL2_IO_EXTENT 16
72
73static int el2_open(struct net_device *dev);
74static int el2_close(struct net_device *dev);
75static void el2_reset_8390(struct net_device *dev);
76static void el2_init_card(struct net_device *dev);
77static void el2_block_output(struct net_device *dev, int count,
78 const unsigned char *buf, int start_page);
79static void el2_block_input(struct net_device *dev, int count, struct sk_buff *skb,
80 int ring_offset);
81static void el2_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
82 int ring_page);
Jeff Garzik7282d492006-09-13 14:30:00 -040083static const struct ethtool_ops netdev_ethtool_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -070084
Jeff Garzik6aa20a22006-09-13 13:24:59 -040085
Linus Torvalds1da177e2005-04-16 15:20:36 -070086/* This routine probes for a memory-mapped 3c503 board by looking for
87 the "location register" at the end of the jumpered boot PROM space.
88 This works even if a PROM isn't there.
89
90 If the ethercard isn't found there is an optional probe for
91 ethercard jumpered to programmed-I/O mode.
92 */
93static int __init do_el2_probe(struct net_device *dev)
94{
95 int *addr, addrs[] = { 0xddffe, 0xd9ffe, 0xcdffe, 0xc9ffe, 0};
96 int base_addr = dev->base_addr;
97 int irq = dev->irq;
98
Linus Torvalds1da177e2005-04-16 15:20:36 -070099 if (base_addr > 0x1ff) /* Check a single specified location. */
100 return el2_probe1(dev, base_addr);
101 else if (base_addr != 0) /* Don't probe at all. */
102 return -ENXIO;
103
104 for (addr = addrs; *addr; addr++) {
105 void __iomem *p = ioremap(*addr, 1);
106 unsigned base_bits;
107 int i;
108
109 if (!p)
110 continue;
111 base_bits = readb(p);
112 iounmap(p);
113 i = ffs(base_bits) - 1;
114 if (i == -1 || base_bits != (1 << i))
115 continue;
116 if (el2_probe1(dev, netcard_portlist[i]) == 0)
117 return 0;
118 dev->irq = irq;
119 }
120#if ! defined(no_probe_nonshared_memory)
121 return el2_pio_probe(dev);
122#else
123 return -ENODEV;
124#endif
125}
126
127/* Try all of the locations that aren't obviously empty. This touches
128 a lot of locations, and is much riskier than the code above. */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400129static int __init
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130el2_pio_probe(struct net_device *dev)
131{
132 int i;
133 int base_addr = dev->base_addr;
134 int irq = dev->irq;
135
136 if (base_addr > 0x1ff) /* Check a single specified location. */
137 return el2_probe1(dev, base_addr);
138 else if (base_addr != 0) /* Don't probe at all. */
139 return -ENXIO;
140
141 for (i = 0; netcard_portlist[i]; i++) {
142 if (el2_probe1(dev, netcard_portlist[i]) == 0)
143 return 0;
144 dev->irq = irq;
145 }
146
147 return -ENODEV;
148}
149
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150#ifndef MODULE
151struct net_device * __init el2_probe(int unit)
152{
Alan Cox055e5112008-07-03 23:43:12 -0700153 struct net_device *dev = alloc_eip_netdev();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154 int err;
155
156 if (!dev)
157 return ERR_PTR(-ENOMEM);
158
159 sprintf(dev->name, "eth%d", unit);
160 netdev_boot_setup_check(dev);
161
162 err = do_el2_probe(dev);
163 if (err)
164 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165 return dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166out:
167 free_netdev(dev);
168 return ERR_PTR(err);
169}
170#endif
171
Stephen Hemminger53cdd282008-11-25 18:26:20 -0800172static const struct net_device_ops el2_netdev_ops = {
173 .ndo_open = el2_open,
174 .ndo_stop = el2_close,
175
176 .ndo_start_xmit = eip_start_xmit,
177 .ndo_tx_timeout = eip_tx_timeout,
178 .ndo_get_stats = eip_get_stats,
179 .ndo_set_multicast_list = eip_set_multicast_list,
180 .ndo_validate_addr = eth_validate_addr,
Stephen Hemmingerfe96aaa2009-01-09 11:13:14 +0000181 .ndo_set_mac_address = eth_mac_addr,
Stephen Hemminger53cdd282008-11-25 18:26:20 -0800182 .ndo_change_mtu = eth_change_mtu,
183#ifdef CONFIG_NET_POLL_CONTROLLER
184 .ndo_poll_controller = eip_poll,
185#endif
186};
187
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188/* Probe for the Etherlink II card at I/O port base IOADDR,
189 returning non-zero on success. If found, set the station
190 address and memory parameters in DEVICE. */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400191static int __init
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192el2_probe1(struct net_device *dev, int ioaddr)
193{
194 int i, iobase_reg, membase_reg, saved_406, wordlength, retval;
195 static unsigned version_printed;
196 unsigned long vendor_id;
197
198 if (!request_region(ioaddr, EL2_IO_EXTENT, DRV_NAME))
199 return -EBUSY;
200
201 if (!request_region(ioaddr + 0x400, 8, DRV_NAME)) {
202 retval = -EBUSY;
203 goto out;
204 }
205
206 /* Reset and/or avoid any lurking NE2000 */
207 if (inb(ioaddr + 0x408) == 0xff) {
208 mdelay(1);
209 retval = -ENODEV;
210 goto out1;
211 }
212
213 /* We verify that it's a 3C503 board by checking the first three octets
214 of its ethernet address. */
215 iobase_reg = inb(ioaddr+0x403);
216 membase_reg = inb(ioaddr+0x404);
217 /* ASIC location registers should be 0 or have only a single bit set. */
Joe Perches8e95a202009-12-03 07:58:21 +0000218 if ((iobase_reg & (iobase_reg - 1)) ||
219 (membase_reg & (membase_reg - 1))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220 retval = -ENODEV;
221 goto out1;
222 }
223 saved_406 = inb_p(ioaddr + 0x406);
224 outb_p(ECNTRL_RESET|ECNTRL_THIN, ioaddr + 0x406); /* Reset it... */
225 outb_p(ECNTRL_THIN, ioaddr + 0x406);
226 /* Map the station addr PROM into the lower I/O ports. We now check
227 for both the old and new 3Com prefix */
228 outb(ECNTRL_SAPROM|ECNTRL_THIN, ioaddr + 0x406);
229 vendor_id = inb(ioaddr)*0x10000 + inb(ioaddr + 1)*0x100 + inb(ioaddr + 2);
230 if ((vendor_id != OLD_3COM_ID) && (vendor_id != NEW_3COM_ID)) {
231 /* Restore the register we frobbed. */
232 outb(saved_406, ioaddr + 0x406);
233 retval = -ENODEV;
234 goto out1;
235 }
236
237 if (ei_debug && version_printed++ == 0)
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000238 pr_debug("%s", version);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239
240 dev->base_addr = ioaddr;
241
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000242 pr_info("%s: 3c503 at i/o base %#3x, node ", dev->name, ioaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243
244 /* Retrieve and print the ethernet address. */
245 for (i = 0; i < 6; i++)
Joe Perches0795af52007-10-03 17:59:30 -0700246 dev->dev_addr[i] = inb(ioaddr + i);
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000247 pr_cont("%pM", dev->dev_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248
249 /* Map the 8390 back into the window. */
250 outb(ECNTRL_THIN, ioaddr + 0x406);
251
252 /* Check for EL2/16 as described in tech. man. */
253 outb_p(E8390_PAGE0, ioaddr + E8390_CMD);
254 outb_p(0, ioaddr + EN0_DCFG);
255 outb_p(E8390_PAGE2, ioaddr + E8390_CMD);
256 wordlength = inb_p(ioaddr + EN0_DCFG) & ENDCFG_WTS;
257 outb_p(E8390_PAGE0, ioaddr + E8390_CMD);
258
259 /* Probe for, turn on and clear the board's shared memory. */
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000260 if (ei_debug > 2)
261 pr_cont(" memory jumpers %2.2x ", membase_reg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 outb(EGACFR_NORM, ioaddr + 0x405); /* Enable RAM */
263
264 /* This should be probed for (or set via an ioctl()) at run-time.
265 Right now we use a sleazy hack to pass in the interface number
266 at boot-time via the low bits of the mem_end field. That value is
267 unused, and the low bits would be discarded even if it was used. */
268#if defined(EI8390_THICK) || defined(EL2_AUI)
269 ei_status.interface_num = 1;
270#else
271 ei_status.interface_num = dev->mem_end & 0xf;
272#endif
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000273 pr_cont(", using %sternal xcvr.\n", ei_status.interface_num == 0 ? "in" : "ex");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274
275 if ((membase_reg & 0xf0) == 0) {
276 dev->mem_start = 0;
277 ei_status.name = "3c503-PIO";
278 ei_status.mem = NULL;
279 } else {
280 dev->mem_start = ((membase_reg & 0xc0) ? 0xD8000 : 0xC8000) +
281 ((membase_reg & 0xA0) ? 0x4000 : 0);
282#define EL2_MEMSIZE (EL2_MB1_STOP_PG - EL2_MB1_START_PG)*256
283 ei_status.mem = ioremap(dev->mem_start, EL2_MEMSIZE);
284
285#ifdef EL2MEMTEST
286 /* This has never found an error, but someone might care.
287 Note that it only tests the 2nd 8kB on 16kB 3c503/16
288 cards between card addr. 0x2000 and 0x3fff. */
289 { /* Check the card's memory. */
290 void __iomem *mem_base = ei_status.mem;
291 unsigned int test_val = 0xbbadf00d;
292 writel(0xba5eba5e, mem_base);
293 for (i = sizeof(test_val); i < EL2_MEMSIZE; i+=sizeof(test_val)) {
294 writel(test_val, mem_base + i);
Joe Perches8e95a202009-12-03 07:58:21 +0000295 if (readl(mem_base) != 0xba5eba5e ||
296 readl(mem_base + i) != test_val) {
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000297 pr_warning("3c503: memory failure or memory address conflict.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298 dev->mem_start = 0;
299 ei_status.name = "3c503-PIO";
300 iounmap(mem_base);
301 ei_status.mem = NULL;
302 break;
303 }
304 test_val += 0x55555555;
305 writel(0, mem_base + i);
306 }
307 }
308#endif /* EL2MEMTEST */
309
310 if (dev->mem_start)
311 dev->mem_end = dev->mem_start + EL2_MEMSIZE;
312
313 if (wordlength) { /* No Tx pages to skip over to get to Rx */
314 ei_status.priv = 0;
315 ei_status.name = "3c503/16";
316 } else {
317 ei_status.priv = TX_PAGES * 256;
318 ei_status.name = "3c503";
319 }
320 }
321
322 /*
323 Divide up the memory on the card. This is the same regardless of
324 whether shared-mem or PIO is used. For 16 bit cards (16kB RAM),
325 we use the entire 8k of bank1 for an Rx ring. We only use 3k
326 of the bank0 for 2 full size Tx packet slots. For 8 bit cards,
327 (8kB RAM) we use 3kB of bank1 for two Tx slots, and the remaining
328 5kB for an Rx ring. */
329
330 if (wordlength) {
331 ei_status.tx_start_page = EL2_MB0_START_PG;
332 ei_status.rx_start_page = EL2_MB1_START_PG;
333 } else {
334 ei_status.tx_start_page = EL2_MB1_START_PG;
335 ei_status.rx_start_page = EL2_MB1_START_PG + TX_PAGES;
336 }
337
338 /* Finish setting the board's parameters. */
339 ei_status.stop_page = EL2_MB1_STOP_PG;
340 ei_status.word16 = wordlength;
Joe Perchesc061b182010-08-23 18:20:03 +0000341 ei_status.reset_8390 = el2_reset_8390;
342 ei_status.get_8390_hdr = el2_get_8390_hdr;
343 ei_status.block_input = el2_block_input;
344 ei_status.block_output = el2_block_output;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345
346 if (dev->irq == 2)
347 dev->irq = 9;
348 else if (dev->irq > 5 && dev->irq != 9) {
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000349 pr_warning("3c503: configured interrupt %d invalid, will use autoIRQ.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 dev->irq);
351 dev->irq = 0;
352 }
353
354 ei_status.saved_irq = dev->irq;
355
Stephen Hemminger53cdd282008-11-25 18:26:20 -0800356 dev->netdev_ops = &el2_netdev_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 dev->ethtool_ops = &netdev_ethtool_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358
b1fc5502005-05-12 20:11:55 -0400359 retval = register_netdev(dev);
360 if (retval)
361 goto out1;
362
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 if (dev->mem_start)
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000364 pr_info("%s: %s - %dkB RAM, 8kB shared mem window at %#6lx-%#6lx.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 dev->name, ei_status.name, (wordlength+1)<<3,
366 dev->mem_start, dev->mem_end-1);
367
368 else
369 {
370 ei_status.tx_start_page = EL2_MB1_START_PG;
371 ei_status.rx_start_page = EL2_MB1_START_PG + TX_PAGES;
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000372 pr_info("%s: %s, %dkB RAM, using programmed I/O (REJUMPER for SHARED MEMORY).\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373 dev->name, ei_status.name, (wordlength+1)<<3);
374 }
375 release_region(ioaddr + 0x400, 8);
376 return 0;
377out1:
378 release_region(ioaddr + 0x400, 8);
379out:
380 release_region(ioaddr, EL2_IO_EXTENT);
381 return retval;
382}
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400383
Ben Hutchingsb0cf4df2010-04-07 20:55:47 -0700384static irqreturn_t el2_probe_interrupt(int irq, void *seen)
385{
386 *(bool *)seen = true;
387 return IRQ_HANDLED;
388}
389
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390static int
391el2_open(struct net_device *dev)
392{
roel kluinab089992009-09-01 06:24:53 +0000393 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394
395 if (dev->irq < 2) {
Joe Perchesb6bc7652010-12-21 02:16:08 -0800396 static const int irqlist[] = {5, 9, 3, 4, 0};
397 const int *irqp = irqlist;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398
399 outb(EGACFR_NORM, E33G_GACFR); /* Enable RAM and interrupts. */
400 do {
Ben Hutchingsb0cf4df2010-04-07 20:55:47 -0700401 bool seen;
402
403 retval = request_irq(*irqp, el2_probe_interrupt, 0,
404 dev->name, &seen);
405 if (retval == -EBUSY)
406 continue;
407 if (retval < 0)
408 goto err_disable;
409
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410 /* Twinkle the interrupt, and check if it's seen. */
Ben Hutchingsb0cf4df2010-04-07 20:55:47 -0700411 seen = false;
412 smp_wmb();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413 outb_p(0x04 << ((*irqp == 9) ? 2 : *irqp), E33G_IDCFR);
414 outb_p(0x00, E33G_IDCFR);
Ben Hutchingsb0cf4df2010-04-07 20:55:47 -0700415 msleep(1);
416 free_irq(*irqp, el2_probe_interrupt);
417 if (!seen)
418 continue;
419
420 retval = request_irq(dev->irq = *irqp, eip_interrupt, 0,
421 dev->name, dev);
422 if (retval == -EBUSY)
423 continue;
424 if (retval < 0)
425 goto err_disable;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 } while (*++irqp);
Ben Hutchingsb0cf4df2010-04-07 20:55:47 -0700427
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428 if (*irqp == 0) {
Ben Hutchingsb0cf4df2010-04-07 20:55:47 -0700429 err_disable:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430 outb(EGACFR_IRQOFF, E33G_GACFR); /* disable interrupts. */
roel kluinab089992009-09-01 06:24:53 +0000431 return -EAGAIN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 }
433 } else {
Alan Cox055e5112008-07-03 23:43:12 -0700434 if ((retval = request_irq(dev->irq, eip_interrupt, 0, dev->name, dev))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 return retval;
436 }
437 }
438
439 el2_init_card(dev);
Alan Cox055e5112008-07-03 23:43:12 -0700440 eip_open(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 return 0;
442}
443
444static int
445el2_close(struct net_device *dev)
446{
447 free_irq(dev->irq, dev);
448 dev->irq = ei_status.saved_irq;
449 outb(EGACFR_IRQOFF, E33G_GACFR); /* disable interrupts. */
450
Alan Cox055e5112008-07-03 23:43:12 -0700451 eip_close(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 return 0;
453}
454
455/* This is called whenever we have a unrecoverable failure:
456 transmit timeout
457 Bad ring buffer packet header
458 */
459static void
460el2_reset_8390(struct net_device *dev)
461{
462 if (ei_debug > 1) {
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000463 pr_debug("%s: Resetting the 3c503 board...", dev->name);
464 pr_cont(" %#lx=%#02x %#lx=%#02x %#lx=%#02x...", E33G_IDCFR, inb(E33G_IDCFR),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 E33G_CNTRL, inb(E33G_CNTRL), E33G_GACFR, inb(E33G_GACFR));
466 }
467 outb_p(ECNTRL_RESET|ECNTRL_THIN, E33G_CNTRL);
468 ei_status.txing = 0;
469 outb_p(ei_status.interface_num==0 ? ECNTRL_THIN : ECNTRL_AUI, E33G_CNTRL);
470 el2_init_card(dev);
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000471 if (ei_debug > 1)
472 pr_cont("done\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473}
474
475/* Initialize the 3c503 GA registers after a reset. */
476static void
477el2_init_card(struct net_device *dev)
478{
479 /* Unmap the station PROM and select the DIX or BNC connector. */
480 outb_p(ei_status.interface_num==0 ? ECNTRL_THIN : ECNTRL_AUI, E33G_CNTRL);
481
482 /* Set ASIC copy of rx's first and last+1 buffer pages */
483 /* These must be the same as in the 8390. */
484 outb(ei_status.rx_start_page, E33G_STARTPG);
485 outb(ei_status.stop_page, E33G_STOPPG);
486
487 /* Point the vector pointer registers somewhere ?harmless?. */
488 outb(0xff, E33G_VP2); /* Point at the ROM restart location 0xffff0 */
489 outb(0xff, E33G_VP1);
490 outb(0x00, E33G_VP0);
491 /* Turn off all interrupts until we're opened. */
492 outb_p(0x00, dev->base_addr + EN0_IMR);
493 /* Enable IRQs iff started. */
494 outb(EGACFR_NORM, E33G_GACFR);
495
496 /* Set the interrupt line. */
497 outb_p((0x04 << (dev->irq == 9 ? 2 : dev->irq)), E33G_IDCFR);
498 outb_p((WRD_COUNT << 1), E33G_DRQCNT); /* Set burst size to 8 */
499 outb_p(0x20, E33G_DMAAH); /* Put a valid addr in the GA DMA */
500 outb_p(0x00, E33G_DMAAL);
501 return; /* We always succeed */
502}
503
504/*
505 * Either use the shared memory (if enabled on the board) or put the packet
506 * out through the ASIC FIFO.
507 */
508static void
509el2_block_output(struct net_device *dev, int count,
510 const unsigned char *buf, int start_page)
511{
512 unsigned short int *wrd;
513 int boguscount; /* timeout counter */
514 unsigned short word; /* temporary for better machine code */
515 void __iomem *base = ei_status.mem;
516
517 if (ei_status.word16) /* Tx packets go into bank 0 on EL2/16 card */
518 outb(EGACFR_RSEL|EGACFR_TCM, E33G_GACFR);
519 else
520 outb(EGACFR_NORM, E33G_GACFR);
521
522 if (base) { /* Shared memory transfer */
523 memcpy_toio(base + ((start_page - ei_status.tx_start_page) << 8),
524 buf, count);
525 outb(EGACFR_NORM, E33G_GACFR); /* Back to bank1 in case on bank0 */
526 return;
527 }
528
529/*
530 * No shared memory, put the packet out the other way.
531 * Set up then start the internal memory transfer to Tx Start Page
532 */
533
534 word = (unsigned short)start_page;
535 outb(word&0xFF, E33G_DMAAH);
536 outb(word>>8, E33G_DMAAL);
537
538 outb_p((ei_status.interface_num ? ECNTRL_AUI : ECNTRL_THIN ) | ECNTRL_OUTPUT
539 | ECNTRL_START, E33G_CNTRL);
540
541/*
542 * Here I am going to write data to the FIFO as quickly as possible.
543 * Note that E33G_FIFOH is defined incorrectly. It is really
544 * E33G_FIFOL, the lowest port address for both the byte and
545 * word write. Variable 'count' is NOT checked. Caller must supply a
546 * valid count. Note that I may write a harmless extra byte to the
547 * 8390 if the byte-count was not even.
548 */
549 wrd = (unsigned short int *) buf;
550 count = (count + 1) >> 1;
551 for(;;)
552 {
553 boguscount = 0x1000;
554 while ((inb(E33G_STATUS) & ESTAT_DPRDY) == 0)
555 {
556 if(!boguscount--)
557 {
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000558 pr_notice("%s: FIFO blocked in el2_block_output.\n", dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559 el2_reset_8390(dev);
560 goto blocked;
561 }
562 }
563 if(count > WRD_COUNT)
564 {
565 outsw(E33G_FIFOH, wrd, WRD_COUNT);
566 wrd += WRD_COUNT;
567 count -= WRD_COUNT;
568 }
569 else
570 {
571 outsw(E33G_FIFOH, wrd, count);
572 break;
573 }
574 }
575 blocked:;
576 outb_p(ei_status.interface_num==0 ? ECNTRL_THIN : ECNTRL_AUI, E33G_CNTRL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577}
578
579/* Read the 4 byte, page aligned 8390 specific header. */
580static void
581el2_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
582{
583 int boguscount;
584 void __iomem *base = ei_status.mem;
585 unsigned short word;
586
587 if (base) { /* Use the shared memory. */
588 void __iomem *hdr_start = base + ((ring_page - EL2_MB1_START_PG)<<8);
589 memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
590 hdr->count = le16_to_cpu(hdr->count);
591 return;
592 }
593
594/*
595 * No shared memory, use programmed I/O.
596 */
597
598 word = (unsigned short)ring_page;
599 outb(word&0xFF, E33G_DMAAH);
600 outb(word>>8, E33G_DMAAL);
601
602 outb_p((ei_status.interface_num == 0 ? ECNTRL_THIN : ECNTRL_AUI) | ECNTRL_INPUT
603 | ECNTRL_START, E33G_CNTRL);
604 boguscount = 0x1000;
605 while ((inb(E33G_STATUS) & ESTAT_DPRDY) == 0)
606 {
607 if(!boguscount--)
608 {
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000609 pr_notice("%s: FIFO blocked in el2_get_8390_hdr.\n", dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610 memset(hdr, 0x00, sizeof(struct e8390_pkt_hdr));
611 el2_reset_8390(dev);
612 goto blocked;
613 }
614 }
615 insw(E33G_FIFOH, hdr, (sizeof(struct e8390_pkt_hdr))>> 1);
616 blocked:;
617 outb_p(ei_status.interface_num == 0 ? ECNTRL_THIN : ECNTRL_AUI, E33G_CNTRL);
618}
619
620
621static void
622el2_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
623{
624 int boguscount = 0;
625 void __iomem *base = ei_status.mem;
626 unsigned short int *buf;
627 unsigned short word;
628
629 /* Maybe enable shared memory just be to be safe... nahh.*/
630 if (base) { /* Use the shared memory. */
631 ring_offset -= (EL2_MB1_START_PG<<8);
632 if (ring_offset + count > EL2_MEMSIZE) {
633 /* We must wrap the input move. */
634 int semi_count = EL2_MEMSIZE - ring_offset;
635 memcpy_fromio(skb->data, base + ring_offset, semi_count);
636 count -= semi_count;
637 memcpy_fromio(skb->data + semi_count, base + ei_status.priv, count);
638 } else {
Al Viro4ec03112007-02-09 16:38:30 +0000639 memcpy_fromio(skb->data, base + ring_offset, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640 }
641 return;
642 }
643
644/*
645 * No shared memory, use programmed I/O.
646 */
647 word = (unsigned short) ring_offset;
648 outb(word>>8, E33G_DMAAH);
649 outb(word&0xFF, E33G_DMAAL);
650
651 outb_p((ei_status.interface_num == 0 ? ECNTRL_THIN : ECNTRL_AUI) | ECNTRL_INPUT
652 | ECNTRL_START, E33G_CNTRL);
653
654/*
655 * Here I also try to get data as fast as possible. I am betting that I
656 * can read one extra byte without clobbering anything in the kernel because
657 * this would only occur on an odd byte-count and allocation of skb->data
658 * is word-aligned. Variable 'count' is NOT checked. Caller must check
659 * for a valid count.
660 * [This is currently quite safe.... but if one day the 3c503 explodes
661 * you know where to come looking ;)]
662 */
663
664 buf = (unsigned short int *) skb->data;
665 count = (count + 1) >> 1;
666 for(;;)
667 {
668 boguscount = 0x1000;
669 while ((inb(E33G_STATUS) & ESTAT_DPRDY) == 0)
670 {
671 if(!boguscount--)
672 {
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000673 pr_notice("%s: FIFO blocked in el2_block_input.\n", dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 el2_reset_8390(dev);
675 goto blocked;
676 }
677 }
678 if(count > WRD_COUNT)
679 {
680 insw(E33G_FIFOH, buf, WRD_COUNT);
681 buf += WRD_COUNT;
682 count -= WRD_COUNT;
683 }
684 else
685 {
686 insw(E33G_FIFOH, buf, count);
687 break;
688 }
689 }
690 blocked:;
691 outb_p(ei_status.interface_num == 0 ? ECNTRL_THIN : ECNTRL_AUI, E33G_CNTRL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692}
693
694
695static void netdev_get_drvinfo(struct net_device *dev,
696 struct ethtool_drvinfo *info)
697{
698 strcpy(info->driver, DRV_NAME);
699 strcpy(info->version, DRV_VERSION);
700 sprintf(info->bus_info, "ISA 0x%lx", dev->base_addr);
701}
702
Jeff Garzik7282d492006-09-13 14:30:00 -0400703static const struct ethtool_ops netdev_ethtool_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704 .get_drvinfo = netdev_get_drvinfo,
705};
706
707#ifdef MODULE
708#define MAX_EL2_CARDS 4 /* Max number of EL2 cards per module */
709
710static struct net_device *dev_el2[MAX_EL2_CARDS];
711static int io[MAX_EL2_CARDS];
712static int irq[MAX_EL2_CARDS];
713static int xcvr[MAX_EL2_CARDS]; /* choose int. or ext. xcvr */
714module_param_array(io, int, NULL, 0);
715module_param_array(irq, int, NULL, 0);
716module_param_array(xcvr, int, NULL, 0);
717MODULE_PARM_DESC(io, "I/O base address(es)");
718MODULE_PARM_DESC(irq, "IRQ number(s) (assigned)");
719MODULE_PARM_DESC(xcvr, "transceiver(s) (0=internal, 1=external)");
720MODULE_DESCRIPTION("3Com ISA EtherLink II, II/16 (3c503, 3c503/16) driver");
721MODULE_LICENSE("GPL");
722
723/* This is set up so that only a single autoprobe takes place per call.
724ISA device autoprobes on a running machine are not recommended. */
Randy Dunlap96e672c2006-06-10 13:33:48 -0700725int __init
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726init_module(void)
727{
728 struct net_device *dev;
729 int this_dev, found = 0;
730
731 for (this_dev = 0; this_dev < MAX_EL2_CARDS; this_dev++) {
732 if (io[this_dev] == 0) {
733 if (this_dev != 0) break; /* only autoprobe 1st one */
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000734 pr_notice("3c503.c: Presently autoprobing (not recommended) for a single card.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735 }
Alan Cox055e5112008-07-03 23:43:12 -0700736 dev = alloc_eip_netdev();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737 if (!dev)
738 break;
739 dev->irq = irq[this_dev];
740 dev->base_addr = io[this_dev];
741 dev->mem_end = xcvr[this_dev]; /* low 4bits = xcvr sel. */
742 if (do_el2_probe(dev) == 0) {
b1fc5502005-05-12 20:11:55 -0400743 dev_el2[found++] = dev;
744 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745 }
746 free_netdev(dev);
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000747 pr_warning("3c503.c: No 3c503 card found (i/o = 0x%x).\n", io[this_dev]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 break;
749 }
750 if (found)
751 return 0;
752 return -ENXIO;
753}
754
Denis Vlasenko64916f12006-01-05 22:45:47 -0800755static void cleanup_card(struct net_device *dev)
756{
757 /* NB: el2_close() handles free_irq */
758 release_region(dev->base_addr, EL2_IO_EXTENT);
759 if (ei_status.mem)
760 iounmap(ei_status.mem);
761}
762
Al Viroafc8eb42006-06-14 18:50:53 -0400763void __exit
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764cleanup_module(void)
765{
766 int this_dev;
767
768 for (this_dev = 0; this_dev < MAX_EL2_CARDS; this_dev++) {
769 struct net_device *dev = dev_el2[this_dev];
770 if (dev) {
771 unregister_netdev(dev);
772 cleanup_card(dev);
773 free_netdev(dev);
774 }
775 }
776}
777#endif /* MODULE */