blob: 134638a9759fabbdc9f06150fce3d9d5a2523904 [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>
52#include <linux/ethtool.h>
53
54#include <asm/uaccess.h>
55#include <asm/io.h>
56#include <asm/system.h>
57#include <asm/byteorder.h>
58
59#include "8390.h"
60#include "3c503.h"
61#define WRD_COUNT 4
62
63static int el2_pio_probe(struct net_device *dev);
64static int el2_probe1(struct net_device *dev, int ioaddr);
65
66/* A zero-terminated list of I/O addresses to be probed in PIO mode. */
67static unsigned int netcard_portlist[] __initdata =
68 { 0x300,0x310,0x330,0x350,0x250,0x280,0x2a0,0x2e0,0};
69
70#define EL2_IO_EXTENT 16
71
72static int el2_open(struct net_device *dev);
73static int el2_close(struct net_device *dev);
74static void el2_reset_8390(struct net_device *dev);
75static void el2_init_card(struct net_device *dev);
76static void el2_block_output(struct net_device *dev, int count,
77 const unsigned char *buf, int start_page);
78static void el2_block_input(struct net_device *dev, int count, struct sk_buff *skb,
79 int ring_offset);
80static void el2_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
81 int ring_page);
Jeff Garzik7282d492006-09-13 14:30:00 -040082static const struct ethtool_ops netdev_ethtool_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -070083
Jeff Garzik6aa20a22006-09-13 13:24:59 -040084
Linus Torvalds1da177e2005-04-16 15:20:36 -070085/* This routine probes for a memory-mapped 3c503 board by looking for
86 the "location register" at the end of the jumpered boot PROM space.
87 This works even if a PROM isn't there.
88
89 If the ethercard isn't found there is an optional probe for
90 ethercard jumpered to programmed-I/O mode.
91 */
92static int __init do_el2_probe(struct net_device *dev)
93{
94 int *addr, addrs[] = { 0xddffe, 0xd9ffe, 0xcdffe, 0xc9ffe, 0};
95 int base_addr = dev->base_addr;
96 int irq = dev->irq;
97
Linus Torvalds1da177e2005-04-16 15:20:36 -070098 if (base_addr > 0x1ff) /* Check a single specified location. */
99 return el2_probe1(dev, base_addr);
100 else if (base_addr != 0) /* Don't probe at all. */
101 return -ENXIO;
102
103 for (addr = addrs; *addr; addr++) {
104 void __iomem *p = ioremap(*addr, 1);
105 unsigned base_bits;
106 int i;
107
108 if (!p)
109 continue;
110 base_bits = readb(p);
111 iounmap(p);
112 i = ffs(base_bits) - 1;
113 if (i == -1 || base_bits != (1 << i))
114 continue;
115 if (el2_probe1(dev, netcard_portlist[i]) == 0)
116 return 0;
117 dev->irq = irq;
118 }
119#if ! defined(no_probe_nonshared_memory)
120 return el2_pio_probe(dev);
121#else
122 return -ENODEV;
123#endif
124}
125
126/* Try all of the locations that aren't obviously empty. This touches
127 a lot of locations, and is much riskier than the code above. */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400128static int __init
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129el2_pio_probe(struct net_device *dev)
130{
131 int i;
132 int base_addr = dev->base_addr;
133 int irq = dev->irq;
134
135 if (base_addr > 0x1ff) /* Check a single specified location. */
136 return el2_probe1(dev, base_addr);
137 else if (base_addr != 0) /* Don't probe at all. */
138 return -ENXIO;
139
140 for (i = 0; netcard_portlist[i]; i++) {
141 if (el2_probe1(dev, netcard_portlist[i]) == 0)
142 return 0;
143 dev->irq = irq;
144 }
145
146 return -ENODEV;
147}
148
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149#ifndef MODULE
150struct net_device * __init el2_probe(int unit)
151{
Alan Cox055e5112008-07-03 23:43:12 -0700152 struct net_device *dev = alloc_eip_netdev();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 int err;
154
155 if (!dev)
156 return ERR_PTR(-ENOMEM);
157
158 sprintf(dev->name, "eth%d", unit);
159 netdev_boot_setup_check(dev);
160
161 err = do_el2_probe(dev);
162 if (err)
163 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 return dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165out:
166 free_netdev(dev);
167 return ERR_PTR(err);
168}
169#endif
170
Stephen Hemminger53cdd282008-11-25 18:26:20 -0800171static const struct net_device_ops el2_netdev_ops = {
172 .ndo_open = el2_open,
173 .ndo_stop = el2_close,
174
175 .ndo_start_xmit = eip_start_xmit,
176 .ndo_tx_timeout = eip_tx_timeout,
177 .ndo_get_stats = eip_get_stats,
178 .ndo_set_multicast_list = eip_set_multicast_list,
179 .ndo_validate_addr = eth_validate_addr,
Stephen Hemmingerfe96aaa2009-01-09 11:13:14 +0000180 .ndo_set_mac_address = eth_mac_addr,
Stephen Hemminger53cdd282008-11-25 18:26:20 -0800181 .ndo_change_mtu = eth_change_mtu,
182#ifdef CONFIG_NET_POLL_CONTROLLER
183 .ndo_poll_controller = eip_poll,
184#endif
185};
186
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187/* Probe for the Etherlink II card at I/O port base IOADDR,
188 returning non-zero on success. If found, set the station
189 address and memory parameters in DEVICE. */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400190static int __init
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191el2_probe1(struct net_device *dev, int ioaddr)
192{
193 int i, iobase_reg, membase_reg, saved_406, wordlength, retval;
194 static unsigned version_printed;
195 unsigned long vendor_id;
196
197 if (!request_region(ioaddr, EL2_IO_EXTENT, DRV_NAME))
198 return -EBUSY;
199
200 if (!request_region(ioaddr + 0x400, 8, DRV_NAME)) {
201 retval = -EBUSY;
202 goto out;
203 }
204
205 /* Reset and/or avoid any lurking NE2000 */
206 if (inb(ioaddr + 0x408) == 0xff) {
207 mdelay(1);
208 retval = -ENODEV;
209 goto out1;
210 }
211
212 /* We verify that it's a 3C503 board by checking the first three octets
213 of its ethernet address. */
214 iobase_reg = inb(ioaddr+0x403);
215 membase_reg = inb(ioaddr+0x404);
216 /* ASIC location registers should be 0 or have only a single bit set. */
217 if ( (iobase_reg & (iobase_reg - 1))
218 || (membase_reg & (membase_reg - 1))) {
219 retval = -ENODEV;
220 goto out1;
221 }
222 saved_406 = inb_p(ioaddr + 0x406);
223 outb_p(ECNTRL_RESET|ECNTRL_THIN, ioaddr + 0x406); /* Reset it... */
224 outb_p(ECNTRL_THIN, ioaddr + 0x406);
225 /* Map the station addr PROM into the lower I/O ports. We now check
226 for both the old and new 3Com prefix */
227 outb(ECNTRL_SAPROM|ECNTRL_THIN, ioaddr + 0x406);
228 vendor_id = inb(ioaddr)*0x10000 + inb(ioaddr + 1)*0x100 + inb(ioaddr + 2);
229 if ((vendor_id != OLD_3COM_ID) && (vendor_id != NEW_3COM_ID)) {
230 /* Restore the register we frobbed. */
231 outb(saved_406, ioaddr + 0x406);
232 retval = -ENODEV;
233 goto out1;
234 }
235
236 if (ei_debug && version_printed++ == 0)
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000237 pr_debug("%s", version);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238
239 dev->base_addr = ioaddr;
240
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000241 pr_info("%s: 3c503 at i/o base %#3x, node ", dev->name, ioaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242
243 /* Retrieve and print the ethernet address. */
244 for (i = 0; i < 6; i++)
Joe Perches0795af52007-10-03 17:59:30 -0700245 dev->dev_addr[i] = inb(ioaddr + i);
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000246 pr_cont("%pM", dev->dev_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247
248 /* Map the 8390 back into the window. */
249 outb(ECNTRL_THIN, ioaddr + 0x406);
250
251 /* Check for EL2/16 as described in tech. man. */
252 outb_p(E8390_PAGE0, ioaddr + E8390_CMD);
253 outb_p(0, ioaddr + EN0_DCFG);
254 outb_p(E8390_PAGE2, ioaddr + E8390_CMD);
255 wordlength = inb_p(ioaddr + EN0_DCFG) & ENDCFG_WTS;
256 outb_p(E8390_PAGE0, ioaddr + E8390_CMD);
257
258 /* Probe for, turn on and clear the board's shared memory. */
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000259 if (ei_debug > 2)
260 pr_cont(" memory jumpers %2.2x ", membase_reg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 outb(EGACFR_NORM, ioaddr + 0x405); /* Enable RAM */
262
263 /* This should be probed for (or set via an ioctl()) at run-time.
264 Right now we use a sleazy hack to pass in the interface number
265 at boot-time via the low bits of the mem_end field. That value is
266 unused, and the low bits would be discarded even if it was used. */
267#if defined(EI8390_THICK) || defined(EL2_AUI)
268 ei_status.interface_num = 1;
269#else
270 ei_status.interface_num = dev->mem_end & 0xf;
271#endif
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000272 pr_cont(", using %sternal xcvr.\n", ei_status.interface_num == 0 ? "in" : "ex");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273
274 if ((membase_reg & 0xf0) == 0) {
275 dev->mem_start = 0;
276 ei_status.name = "3c503-PIO";
277 ei_status.mem = NULL;
278 } else {
279 dev->mem_start = ((membase_reg & 0xc0) ? 0xD8000 : 0xC8000) +
280 ((membase_reg & 0xA0) ? 0x4000 : 0);
281#define EL2_MEMSIZE (EL2_MB1_STOP_PG - EL2_MB1_START_PG)*256
282 ei_status.mem = ioremap(dev->mem_start, EL2_MEMSIZE);
283
284#ifdef EL2MEMTEST
285 /* This has never found an error, but someone might care.
286 Note that it only tests the 2nd 8kB on 16kB 3c503/16
287 cards between card addr. 0x2000 and 0x3fff. */
288 { /* Check the card's memory. */
289 void __iomem *mem_base = ei_status.mem;
290 unsigned int test_val = 0xbbadf00d;
291 writel(0xba5eba5e, mem_base);
292 for (i = sizeof(test_val); i < EL2_MEMSIZE; i+=sizeof(test_val)) {
293 writel(test_val, mem_base + i);
294 if (readl(mem_base) != 0xba5eba5e
295 || readl(mem_base + i) != test_val) {
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000296 pr_warning("3c503: memory failure or memory address conflict.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 dev->mem_start = 0;
298 ei_status.name = "3c503-PIO";
299 iounmap(mem_base);
300 ei_status.mem = NULL;
301 break;
302 }
303 test_val += 0x55555555;
304 writel(0, mem_base + i);
305 }
306 }
307#endif /* EL2MEMTEST */
308
309 if (dev->mem_start)
310 dev->mem_end = dev->mem_start + EL2_MEMSIZE;
311
312 if (wordlength) { /* No Tx pages to skip over to get to Rx */
313 ei_status.priv = 0;
314 ei_status.name = "3c503/16";
315 } else {
316 ei_status.priv = TX_PAGES * 256;
317 ei_status.name = "3c503";
318 }
319 }
320
321 /*
322 Divide up the memory on the card. This is the same regardless of
323 whether shared-mem or PIO is used. For 16 bit cards (16kB RAM),
324 we use the entire 8k of bank1 for an Rx ring. We only use 3k
325 of the bank0 for 2 full size Tx packet slots. For 8 bit cards,
326 (8kB RAM) we use 3kB of bank1 for two Tx slots, and the remaining
327 5kB for an Rx ring. */
328
329 if (wordlength) {
330 ei_status.tx_start_page = EL2_MB0_START_PG;
331 ei_status.rx_start_page = EL2_MB1_START_PG;
332 } else {
333 ei_status.tx_start_page = EL2_MB1_START_PG;
334 ei_status.rx_start_page = EL2_MB1_START_PG + TX_PAGES;
335 }
336
337 /* Finish setting the board's parameters. */
338 ei_status.stop_page = EL2_MB1_STOP_PG;
339 ei_status.word16 = wordlength;
340 ei_status.reset_8390 = &el2_reset_8390;
341 ei_status.get_8390_hdr = &el2_get_8390_hdr;
342 ei_status.block_input = &el2_block_input;
343 ei_status.block_output = &el2_block_output;
344
345 if (dev->irq == 2)
346 dev->irq = 9;
347 else if (dev->irq > 5 && dev->irq != 9) {
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000348 pr_warning("3c503: configured interrupt %d invalid, will use autoIRQ.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 dev->irq);
350 dev->irq = 0;
351 }
352
353 ei_status.saved_irq = dev->irq;
354
Stephen Hemminger53cdd282008-11-25 18:26:20 -0800355 dev->netdev_ops = &el2_netdev_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 dev->ethtool_ops = &netdev_ethtool_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357
b1fc5502005-05-12 20:11:55 -0400358 retval = register_netdev(dev);
359 if (retval)
360 goto out1;
361
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 if (dev->mem_start)
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000363 pr_info("%s: %s - %dkB RAM, 8kB shared mem window at %#6lx-%#6lx.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 dev->name, ei_status.name, (wordlength+1)<<3,
365 dev->mem_start, dev->mem_end-1);
366
367 else
368 {
369 ei_status.tx_start_page = EL2_MB1_START_PG;
370 ei_status.rx_start_page = EL2_MB1_START_PG + TX_PAGES;
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000371 pr_info("%s: %s, %dkB RAM, using programmed I/O (REJUMPER for SHARED MEMORY).\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 dev->name, ei_status.name, (wordlength+1)<<3);
373 }
374 release_region(ioaddr + 0x400, 8);
375 return 0;
376out1:
377 release_region(ioaddr + 0x400, 8);
378out:
379 release_region(ioaddr, EL2_IO_EXTENT);
380 return retval;
381}
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400382
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383static int
384el2_open(struct net_device *dev)
385{
386 int retval = -EAGAIN;
387
388 if (dev->irq < 2) {
389 int irqlist[] = {5, 9, 3, 4, 0};
390 int *irqp = irqlist;
391
392 outb(EGACFR_NORM, E33G_GACFR); /* Enable RAM and interrupts. */
393 do {
394 if (request_irq (*irqp, NULL, 0, "bogus", dev) != -EBUSY) {
395 /* Twinkle the interrupt, and check if it's seen. */
396 unsigned long cookie = probe_irq_on();
397 outb_p(0x04 << ((*irqp == 9) ? 2 : *irqp), E33G_IDCFR);
398 outb_p(0x00, E33G_IDCFR);
399 if (*irqp == probe_irq_off(cookie) /* It's a good IRQ line! */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400400 && ((retval = request_irq(dev->irq = *irqp,
Alan Cox055e5112008-07-03 23:43:12 -0700401 eip_interrupt, 0, dev->name, dev)) == 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 break;
403 }
404 } while (*++irqp);
405 if (*irqp == 0) {
406 outb(EGACFR_IRQOFF, E33G_GACFR); /* disable interrupts. */
407 return retval;
408 }
409 } else {
Alan Cox055e5112008-07-03 23:43:12 -0700410 if ((retval = request_irq(dev->irq, eip_interrupt, 0, dev->name, dev))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 return retval;
412 }
413 }
414
415 el2_init_card(dev);
Alan Cox055e5112008-07-03 23:43:12 -0700416 eip_open(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 return 0;
418}
419
420static int
421el2_close(struct net_device *dev)
422{
423 free_irq(dev->irq, dev);
424 dev->irq = ei_status.saved_irq;
425 outb(EGACFR_IRQOFF, E33G_GACFR); /* disable interrupts. */
426
Alan Cox055e5112008-07-03 23:43:12 -0700427 eip_close(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428 return 0;
429}
430
431/* This is called whenever we have a unrecoverable failure:
432 transmit timeout
433 Bad ring buffer packet header
434 */
435static void
436el2_reset_8390(struct net_device *dev)
437{
438 if (ei_debug > 1) {
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000439 pr_debug("%s: Resetting the 3c503 board...", dev->name);
440 pr_cont(" %#lx=%#02x %#lx=%#02x %#lx=%#02x...", E33G_IDCFR, inb(E33G_IDCFR),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 E33G_CNTRL, inb(E33G_CNTRL), E33G_GACFR, inb(E33G_GACFR));
442 }
443 outb_p(ECNTRL_RESET|ECNTRL_THIN, E33G_CNTRL);
444 ei_status.txing = 0;
445 outb_p(ei_status.interface_num==0 ? ECNTRL_THIN : ECNTRL_AUI, E33G_CNTRL);
446 el2_init_card(dev);
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000447 if (ei_debug > 1)
448 pr_cont("done\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449}
450
451/* Initialize the 3c503 GA registers after a reset. */
452static void
453el2_init_card(struct net_device *dev)
454{
455 /* Unmap the station PROM and select the DIX or BNC connector. */
456 outb_p(ei_status.interface_num==0 ? ECNTRL_THIN : ECNTRL_AUI, E33G_CNTRL);
457
458 /* Set ASIC copy of rx's first and last+1 buffer pages */
459 /* These must be the same as in the 8390. */
460 outb(ei_status.rx_start_page, E33G_STARTPG);
461 outb(ei_status.stop_page, E33G_STOPPG);
462
463 /* Point the vector pointer registers somewhere ?harmless?. */
464 outb(0xff, E33G_VP2); /* Point at the ROM restart location 0xffff0 */
465 outb(0xff, E33G_VP1);
466 outb(0x00, E33G_VP0);
467 /* Turn off all interrupts until we're opened. */
468 outb_p(0x00, dev->base_addr + EN0_IMR);
469 /* Enable IRQs iff started. */
470 outb(EGACFR_NORM, E33G_GACFR);
471
472 /* Set the interrupt line. */
473 outb_p((0x04 << (dev->irq == 9 ? 2 : dev->irq)), E33G_IDCFR);
474 outb_p((WRD_COUNT << 1), E33G_DRQCNT); /* Set burst size to 8 */
475 outb_p(0x20, E33G_DMAAH); /* Put a valid addr in the GA DMA */
476 outb_p(0x00, E33G_DMAAL);
477 return; /* We always succeed */
478}
479
480/*
481 * Either use the shared memory (if enabled on the board) or put the packet
482 * out through the ASIC FIFO.
483 */
484static void
485el2_block_output(struct net_device *dev, int count,
486 const unsigned char *buf, int start_page)
487{
488 unsigned short int *wrd;
489 int boguscount; /* timeout counter */
490 unsigned short word; /* temporary for better machine code */
491 void __iomem *base = ei_status.mem;
492
493 if (ei_status.word16) /* Tx packets go into bank 0 on EL2/16 card */
494 outb(EGACFR_RSEL|EGACFR_TCM, E33G_GACFR);
495 else
496 outb(EGACFR_NORM, E33G_GACFR);
497
498 if (base) { /* Shared memory transfer */
499 memcpy_toio(base + ((start_page - ei_status.tx_start_page) << 8),
500 buf, count);
501 outb(EGACFR_NORM, E33G_GACFR); /* Back to bank1 in case on bank0 */
502 return;
503 }
504
505/*
506 * No shared memory, put the packet out the other way.
507 * Set up then start the internal memory transfer to Tx Start Page
508 */
509
510 word = (unsigned short)start_page;
511 outb(word&0xFF, E33G_DMAAH);
512 outb(word>>8, E33G_DMAAL);
513
514 outb_p((ei_status.interface_num ? ECNTRL_AUI : ECNTRL_THIN ) | ECNTRL_OUTPUT
515 | ECNTRL_START, E33G_CNTRL);
516
517/*
518 * Here I am going to write data to the FIFO as quickly as possible.
519 * Note that E33G_FIFOH is defined incorrectly. It is really
520 * E33G_FIFOL, the lowest port address for both the byte and
521 * word write. Variable 'count' is NOT checked. Caller must supply a
522 * valid count. Note that I may write a harmless extra byte to the
523 * 8390 if the byte-count was not even.
524 */
525 wrd = (unsigned short int *) buf;
526 count = (count + 1) >> 1;
527 for(;;)
528 {
529 boguscount = 0x1000;
530 while ((inb(E33G_STATUS) & ESTAT_DPRDY) == 0)
531 {
532 if(!boguscount--)
533 {
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000534 pr_notice("%s: FIFO blocked in el2_block_output.\n", dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 el2_reset_8390(dev);
536 goto blocked;
537 }
538 }
539 if(count > WRD_COUNT)
540 {
541 outsw(E33G_FIFOH, wrd, WRD_COUNT);
542 wrd += WRD_COUNT;
543 count -= WRD_COUNT;
544 }
545 else
546 {
547 outsw(E33G_FIFOH, wrd, count);
548 break;
549 }
550 }
551 blocked:;
552 outb_p(ei_status.interface_num==0 ? ECNTRL_THIN : ECNTRL_AUI, E33G_CNTRL);
553 return;
554}
555
556/* Read the 4 byte, page aligned 8390 specific header. */
557static void
558el2_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
559{
560 int boguscount;
561 void __iomem *base = ei_status.mem;
562 unsigned short word;
563
564 if (base) { /* Use the shared memory. */
565 void __iomem *hdr_start = base + ((ring_page - EL2_MB1_START_PG)<<8);
566 memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
567 hdr->count = le16_to_cpu(hdr->count);
568 return;
569 }
570
571/*
572 * No shared memory, use programmed I/O.
573 */
574
575 word = (unsigned short)ring_page;
576 outb(word&0xFF, E33G_DMAAH);
577 outb(word>>8, E33G_DMAAL);
578
579 outb_p((ei_status.interface_num == 0 ? ECNTRL_THIN : ECNTRL_AUI) | ECNTRL_INPUT
580 | ECNTRL_START, E33G_CNTRL);
581 boguscount = 0x1000;
582 while ((inb(E33G_STATUS) & ESTAT_DPRDY) == 0)
583 {
584 if(!boguscount--)
585 {
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000586 pr_notice("%s: FIFO blocked in el2_get_8390_hdr.\n", dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 memset(hdr, 0x00, sizeof(struct e8390_pkt_hdr));
588 el2_reset_8390(dev);
589 goto blocked;
590 }
591 }
592 insw(E33G_FIFOH, hdr, (sizeof(struct e8390_pkt_hdr))>> 1);
593 blocked:;
594 outb_p(ei_status.interface_num == 0 ? ECNTRL_THIN : ECNTRL_AUI, E33G_CNTRL);
595}
596
597
598static void
599el2_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
600{
601 int boguscount = 0;
602 void __iomem *base = ei_status.mem;
603 unsigned short int *buf;
604 unsigned short word;
605
606 /* Maybe enable shared memory just be to be safe... nahh.*/
607 if (base) { /* Use the shared memory. */
608 ring_offset -= (EL2_MB1_START_PG<<8);
609 if (ring_offset + count > EL2_MEMSIZE) {
610 /* We must wrap the input move. */
611 int semi_count = EL2_MEMSIZE - ring_offset;
612 memcpy_fromio(skb->data, base + ring_offset, semi_count);
613 count -= semi_count;
614 memcpy_fromio(skb->data + semi_count, base + ei_status.priv, count);
615 } else {
Al Viro4ec03112007-02-09 16:38:30 +0000616 memcpy_fromio(skb->data, base + ring_offset, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 }
618 return;
619 }
620
621/*
622 * No shared memory, use programmed I/O.
623 */
624 word = (unsigned short) ring_offset;
625 outb(word>>8, E33G_DMAAH);
626 outb(word&0xFF, E33G_DMAAL);
627
628 outb_p((ei_status.interface_num == 0 ? ECNTRL_THIN : ECNTRL_AUI) | ECNTRL_INPUT
629 | ECNTRL_START, E33G_CNTRL);
630
631/*
632 * Here I also try to get data as fast as possible. I am betting that I
633 * can read one extra byte without clobbering anything in the kernel because
634 * this would only occur on an odd byte-count and allocation of skb->data
635 * is word-aligned. Variable 'count' is NOT checked. Caller must check
636 * for a valid count.
637 * [This is currently quite safe.... but if one day the 3c503 explodes
638 * you know where to come looking ;)]
639 */
640
641 buf = (unsigned short int *) skb->data;
642 count = (count + 1) >> 1;
643 for(;;)
644 {
645 boguscount = 0x1000;
646 while ((inb(E33G_STATUS) & ESTAT_DPRDY) == 0)
647 {
648 if(!boguscount--)
649 {
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000650 pr_notice("%s: FIFO blocked in el2_block_input.\n", dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 el2_reset_8390(dev);
652 goto blocked;
653 }
654 }
655 if(count > WRD_COUNT)
656 {
657 insw(E33G_FIFOH, buf, WRD_COUNT);
658 buf += WRD_COUNT;
659 count -= WRD_COUNT;
660 }
661 else
662 {
663 insw(E33G_FIFOH, buf, count);
664 break;
665 }
666 }
667 blocked:;
668 outb_p(ei_status.interface_num == 0 ? ECNTRL_THIN : ECNTRL_AUI, E33G_CNTRL);
669 return;
670}
671
672
673static void netdev_get_drvinfo(struct net_device *dev,
674 struct ethtool_drvinfo *info)
675{
676 strcpy(info->driver, DRV_NAME);
677 strcpy(info->version, DRV_VERSION);
678 sprintf(info->bus_info, "ISA 0x%lx", dev->base_addr);
679}
680
Jeff Garzik7282d492006-09-13 14:30:00 -0400681static const struct ethtool_ops netdev_ethtool_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682 .get_drvinfo = netdev_get_drvinfo,
683};
684
685#ifdef MODULE
686#define MAX_EL2_CARDS 4 /* Max number of EL2 cards per module */
687
688static struct net_device *dev_el2[MAX_EL2_CARDS];
689static int io[MAX_EL2_CARDS];
690static int irq[MAX_EL2_CARDS];
691static int xcvr[MAX_EL2_CARDS]; /* choose int. or ext. xcvr */
692module_param_array(io, int, NULL, 0);
693module_param_array(irq, int, NULL, 0);
694module_param_array(xcvr, int, NULL, 0);
695MODULE_PARM_DESC(io, "I/O base address(es)");
696MODULE_PARM_DESC(irq, "IRQ number(s) (assigned)");
697MODULE_PARM_DESC(xcvr, "transceiver(s) (0=internal, 1=external)");
698MODULE_DESCRIPTION("3Com ISA EtherLink II, II/16 (3c503, 3c503/16) driver");
699MODULE_LICENSE("GPL");
700
701/* This is set up so that only a single autoprobe takes place per call.
702ISA device autoprobes on a running machine are not recommended. */
Randy Dunlap96e672c2006-06-10 13:33:48 -0700703int __init
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704init_module(void)
705{
706 struct net_device *dev;
707 int this_dev, found = 0;
708
709 for (this_dev = 0; this_dev < MAX_EL2_CARDS; this_dev++) {
710 if (io[this_dev] == 0) {
711 if (this_dev != 0) break; /* only autoprobe 1st one */
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000712 pr_notice("3c503.c: Presently autoprobing (not recommended) for a single card.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713 }
Alan Cox055e5112008-07-03 23:43:12 -0700714 dev = alloc_eip_netdev();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 if (!dev)
716 break;
717 dev->irq = irq[this_dev];
718 dev->base_addr = io[this_dev];
719 dev->mem_end = xcvr[this_dev]; /* low 4bits = xcvr sel. */
720 if (do_el2_probe(dev) == 0) {
b1fc5502005-05-12 20:11:55 -0400721 dev_el2[found++] = dev;
722 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723 }
724 free_netdev(dev);
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000725 pr_warning("3c503.c: No 3c503 card found (i/o = 0x%x).\n", io[this_dev]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726 break;
727 }
728 if (found)
729 return 0;
730 return -ENXIO;
731}
732
Denis Vlasenko64916f12006-01-05 22:45:47 -0800733static void cleanup_card(struct net_device *dev)
734{
735 /* NB: el2_close() handles free_irq */
736 release_region(dev->base_addr, EL2_IO_EXTENT);
737 if (ei_status.mem)
738 iounmap(ei_status.mem);
739}
740
Al Viroafc8eb42006-06-14 18:50:53 -0400741void __exit
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742cleanup_module(void)
743{
744 int this_dev;
745
746 for (this_dev = 0; this_dev < MAX_EL2_CARDS; this_dev++) {
747 struct net_device *dev = dev_el2[this_dev];
748 if (dev) {
749 unregister_netdev(dev);
750 cleanup_card(dev);
751 free_netdev(dev);
752 }
753 }
754}
755#endif /* MODULE */