blob: 4f08bd995836760285741b40110cf591819fd1e6 [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)
237 printk(version);
238
239 dev->base_addr = ioaddr;
240
241 printk("%s: 3c503 at i/o base %#3x, node ", dev->name, ioaddr);
242
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);
Johannes Berge1749612008-10-27 15:59:26 -0700246 printk("%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. */
259 if (ei_debug > 2) printk(" memory jumpers %2.2x ", membase_reg);
260 outb(EGACFR_NORM, ioaddr + 0x405); /* Enable RAM */
261
262 /* This should be probed for (or set via an ioctl()) at run-time.
263 Right now we use a sleazy hack to pass in the interface number
264 at boot-time via the low bits of the mem_end field. That value is
265 unused, and the low bits would be discarded even if it was used. */
266#if defined(EI8390_THICK) || defined(EL2_AUI)
267 ei_status.interface_num = 1;
268#else
269 ei_status.interface_num = dev->mem_end & 0xf;
270#endif
271 printk(", using %sternal xcvr.\n", ei_status.interface_num == 0 ? "in" : "ex");
272
273 if ((membase_reg & 0xf0) == 0) {
274 dev->mem_start = 0;
275 ei_status.name = "3c503-PIO";
276 ei_status.mem = NULL;
277 } else {
278 dev->mem_start = ((membase_reg & 0xc0) ? 0xD8000 : 0xC8000) +
279 ((membase_reg & 0xA0) ? 0x4000 : 0);
280#define EL2_MEMSIZE (EL2_MB1_STOP_PG - EL2_MB1_START_PG)*256
281 ei_status.mem = ioremap(dev->mem_start, EL2_MEMSIZE);
282
283#ifdef EL2MEMTEST
284 /* This has never found an error, but someone might care.
285 Note that it only tests the 2nd 8kB on 16kB 3c503/16
286 cards between card addr. 0x2000 and 0x3fff. */
287 { /* Check the card's memory. */
288 void __iomem *mem_base = ei_status.mem;
289 unsigned int test_val = 0xbbadf00d;
290 writel(0xba5eba5e, mem_base);
291 for (i = sizeof(test_val); i < EL2_MEMSIZE; i+=sizeof(test_val)) {
292 writel(test_val, mem_base + i);
293 if (readl(mem_base) != 0xba5eba5e
294 || readl(mem_base + i) != test_val) {
295 printk("3c503: memory failure or memory address conflict.\n");
296 dev->mem_start = 0;
297 ei_status.name = "3c503-PIO";
298 iounmap(mem_base);
299 ei_status.mem = NULL;
300 break;
301 }
302 test_val += 0x55555555;
303 writel(0, mem_base + i);
304 }
305 }
306#endif /* EL2MEMTEST */
307
308 if (dev->mem_start)
309 dev->mem_end = dev->mem_start + EL2_MEMSIZE;
310
311 if (wordlength) { /* No Tx pages to skip over to get to Rx */
312 ei_status.priv = 0;
313 ei_status.name = "3c503/16";
314 } else {
315 ei_status.priv = TX_PAGES * 256;
316 ei_status.name = "3c503";
317 }
318 }
319
320 /*
321 Divide up the memory on the card. This is the same regardless of
322 whether shared-mem or PIO is used. For 16 bit cards (16kB RAM),
323 we use the entire 8k of bank1 for an Rx ring. We only use 3k
324 of the bank0 for 2 full size Tx packet slots. For 8 bit cards,
325 (8kB RAM) we use 3kB of bank1 for two Tx slots, and the remaining
326 5kB for an Rx ring. */
327
328 if (wordlength) {
329 ei_status.tx_start_page = EL2_MB0_START_PG;
330 ei_status.rx_start_page = EL2_MB1_START_PG;
331 } else {
332 ei_status.tx_start_page = EL2_MB1_START_PG;
333 ei_status.rx_start_page = EL2_MB1_START_PG + TX_PAGES;
334 }
335
336 /* Finish setting the board's parameters. */
337 ei_status.stop_page = EL2_MB1_STOP_PG;
338 ei_status.word16 = wordlength;
339 ei_status.reset_8390 = &el2_reset_8390;
340 ei_status.get_8390_hdr = &el2_get_8390_hdr;
341 ei_status.block_input = &el2_block_input;
342 ei_status.block_output = &el2_block_output;
343
344 if (dev->irq == 2)
345 dev->irq = 9;
346 else if (dev->irq > 5 && dev->irq != 9) {
347 printk("3c503: configured interrupt %d invalid, will use autoIRQ.\n",
348 dev->irq);
349 dev->irq = 0;
350 }
351
352 ei_status.saved_irq = dev->irq;
353
Stephen Hemminger53cdd282008-11-25 18:26:20 -0800354 dev->netdev_ops = &el2_netdev_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 dev->ethtool_ops = &netdev_ethtool_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356
b1fc5502005-05-12 20:11:55 -0400357 retval = register_netdev(dev);
358 if (retval)
359 goto out1;
360
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 if (dev->mem_start)
362 printk("%s: %s - %dkB RAM, 8kB shared mem window at %#6lx-%#6lx.\n",
363 dev->name, ei_status.name, (wordlength+1)<<3,
364 dev->mem_start, dev->mem_end-1);
365
366 else
367 {
368 ei_status.tx_start_page = EL2_MB1_START_PG;
369 ei_status.rx_start_page = EL2_MB1_START_PG + TX_PAGES;
370 printk("\n%s: %s, %dkB RAM, using programmed I/O (REJUMPER for SHARED MEMORY).\n",
371 dev->name, ei_status.name, (wordlength+1)<<3);
372 }
373 release_region(ioaddr + 0x400, 8);
374 return 0;
375out1:
376 release_region(ioaddr + 0x400, 8);
377out:
378 release_region(ioaddr, EL2_IO_EXTENT);
379 return retval;
380}
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400381
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382static int
383el2_open(struct net_device *dev)
384{
385 int retval = -EAGAIN;
386
387 if (dev->irq < 2) {
388 int irqlist[] = {5, 9, 3, 4, 0};
389 int *irqp = irqlist;
390
391 outb(EGACFR_NORM, E33G_GACFR); /* Enable RAM and interrupts. */
392 do {
393 if (request_irq (*irqp, NULL, 0, "bogus", dev) != -EBUSY) {
394 /* Twinkle the interrupt, and check if it's seen. */
395 unsigned long cookie = probe_irq_on();
396 outb_p(0x04 << ((*irqp == 9) ? 2 : *irqp), E33G_IDCFR);
397 outb_p(0x00, E33G_IDCFR);
398 if (*irqp == probe_irq_off(cookie) /* It's a good IRQ line! */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400399 && ((retval = request_irq(dev->irq = *irqp,
Alan Cox055e5112008-07-03 23:43:12 -0700400 eip_interrupt, 0, dev->name, dev)) == 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 break;
402 }
403 } while (*++irqp);
404 if (*irqp == 0) {
405 outb(EGACFR_IRQOFF, E33G_GACFR); /* disable interrupts. */
406 return retval;
407 }
408 } else {
Alan Cox055e5112008-07-03 23:43:12 -0700409 if ((retval = request_irq(dev->irq, eip_interrupt, 0, dev->name, dev))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410 return retval;
411 }
412 }
413
414 el2_init_card(dev);
Alan Cox055e5112008-07-03 23:43:12 -0700415 eip_open(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 return 0;
417}
418
419static int
420el2_close(struct net_device *dev)
421{
422 free_irq(dev->irq, dev);
423 dev->irq = ei_status.saved_irq;
424 outb(EGACFR_IRQOFF, E33G_GACFR); /* disable interrupts. */
425
Alan Cox055e5112008-07-03 23:43:12 -0700426 eip_close(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 return 0;
428}
429
430/* This is called whenever we have a unrecoverable failure:
431 transmit timeout
432 Bad ring buffer packet header
433 */
434static void
435el2_reset_8390(struct net_device *dev)
436{
437 if (ei_debug > 1) {
438 printk("%s: Resetting the 3c503 board...", dev->name);
439 printk("%#lx=%#02x %#lx=%#02x %#lx=%#02x...", E33G_IDCFR, inb(E33G_IDCFR),
440 E33G_CNTRL, inb(E33G_CNTRL), E33G_GACFR, inb(E33G_GACFR));
441 }
442 outb_p(ECNTRL_RESET|ECNTRL_THIN, E33G_CNTRL);
443 ei_status.txing = 0;
444 outb_p(ei_status.interface_num==0 ? ECNTRL_THIN : ECNTRL_AUI, E33G_CNTRL);
445 el2_init_card(dev);
446 if (ei_debug > 1) printk("done\n");
447}
448
449/* Initialize the 3c503 GA registers after a reset. */
450static void
451el2_init_card(struct net_device *dev)
452{
453 /* Unmap the station PROM and select the DIX or BNC connector. */
454 outb_p(ei_status.interface_num==0 ? ECNTRL_THIN : ECNTRL_AUI, E33G_CNTRL);
455
456 /* Set ASIC copy of rx's first and last+1 buffer pages */
457 /* These must be the same as in the 8390. */
458 outb(ei_status.rx_start_page, E33G_STARTPG);
459 outb(ei_status.stop_page, E33G_STOPPG);
460
461 /* Point the vector pointer registers somewhere ?harmless?. */
462 outb(0xff, E33G_VP2); /* Point at the ROM restart location 0xffff0 */
463 outb(0xff, E33G_VP1);
464 outb(0x00, E33G_VP0);
465 /* Turn off all interrupts until we're opened. */
466 outb_p(0x00, dev->base_addr + EN0_IMR);
467 /* Enable IRQs iff started. */
468 outb(EGACFR_NORM, E33G_GACFR);
469
470 /* Set the interrupt line. */
471 outb_p((0x04 << (dev->irq == 9 ? 2 : dev->irq)), E33G_IDCFR);
472 outb_p((WRD_COUNT << 1), E33G_DRQCNT); /* Set burst size to 8 */
473 outb_p(0x20, E33G_DMAAH); /* Put a valid addr in the GA DMA */
474 outb_p(0x00, E33G_DMAAL);
475 return; /* We always succeed */
476}
477
478/*
479 * Either use the shared memory (if enabled on the board) or put the packet
480 * out through the ASIC FIFO.
481 */
482static void
483el2_block_output(struct net_device *dev, int count,
484 const unsigned char *buf, int start_page)
485{
486 unsigned short int *wrd;
487 int boguscount; /* timeout counter */
488 unsigned short word; /* temporary for better machine code */
489 void __iomem *base = ei_status.mem;
490
491 if (ei_status.word16) /* Tx packets go into bank 0 on EL2/16 card */
492 outb(EGACFR_RSEL|EGACFR_TCM, E33G_GACFR);
493 else
494 outb(EGACFR_NORM, E33G_GACFR);
495
496 if (base) { /* Shared memory transfer */
497 memcpy_toio(base + ((start_page - ei_status.tx_start_page) << 8),
498 buf, count);
499 outb(EGACFR_NORM, E33G_GACFR); /* Back to bank1 in case on bank0 */
500 return;
501 }
502
503/*
504 * No shared memory, put the packet out the other way.
505 * Set up then start the internal memory transfer to Tx Start Page
506 */
507
508 word = (unsigned short)start_page;
509 outb(word&0xFF, E33G_DMAAH);
510 outb(word>>8, E33G_DMAAL);
511
512 outb_p((ei_status.interface_num ? ECNTRL_AUI : ECNTRL_THIN ) | ECNTRL_OUTPUT
513 | ECNTRL_START, E33G_CNTRL);
514
515/*
516 * Here I am going to write data to the FIFO as quickly as possible.
517 * Note that E33G_FIFOH is defined incorrectly. It is really
518 * E33G_FIFOL, the lowest port address for both the byte and
519 * word write. Variable 'count' is NOT checked. Caller must supply a
520 * valid count. Note that I may write a harmless extra byte to the
521 * 8390 if the byte-count was not even.
522 */
523 wrd = (unsigned short int *) buf;
524 count = (count + 1) >> 1;
525 for(;;)
526 {
527 boguscount = 0x1000;
528 while ((inb(E33G_STATUS) & ESTAT_DPRDY) == 0)
529 {
530 if(!boguscount--)
531 {
532 printk("%s: FIFO blocked in el2_block_output.\n", dev->name);
533 el2_reset_8390(dev);
534 goto blocked;
535 }
536 }
537 if(count > WRD_COUNT)
538 {
539 outsw(E33G_FIFOH, wrd, WRD_COUNT);
540 wrd += WRD_COUNT;
541 count -= WRD_COUNT;
542 }
543 else
544 {
545 outsw(E33G_FIFOH, wrd, count);
546 break;
547 }
548 }
549 blocked:;
550 outb_p(ei_status.interface_num==0 ? ECNTRL_THIN : ECNTRL_AUI, E33G_CNTRL);
551 return;
552}
553
554/* Read the 4 byte, page aligned 8390 specific header. */
555static void
556el2_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
557{
558 int boguscount;
559 void __iomem *base = ei_status.mem;
560 unsigned short word;
561
562 if (base) { /* Use the shared memory. */
563 void __iomem *hdr_start = base + ((ring_page - EL2_MB1_START_PG)<<8);
564 memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
565 hdr->count = le16_to_cpu(hdr->count);
566 return;
567 }
568
569/*
570 * No shared memory, use programmed I/O.
571 */
572
573 word = (unsigned short)ring_page;
574 outb(word&0xFF, E33G_DMAAH);
575 outb(word>>8, E33G_DMAAL);
576
577 outb_p((ei_status.interface_num == 0 ? ECNTRL_THIN : ECNTRL_AUI) | ECNTRL_INPUT
578 | ECNTRL_START, E33G_CNTRL);
579 boguscount = 0x1000;
580 while ((inb(E33G_STATUS) & ESTAT_DPRDY) == 0)
581 {
582 if(!boguscount--)
583 {
584 printk("%s: FIFO blocked in el2_get_8390_hdr.\n", dev->name);
585 memset(hdr, 0x00, sizeof(struct e8390_pkt_hdr));
586 el2_reset_8390(dev);
587 goto blocked;
588 }
589 }
590 insw(E33G_FIFOH, hdr, (sizeof(struct e8390_pkt_hdr))>> 1);
591 blocked:;
592 outb_p(ei_status.interface_num == 0 ? ECNTRL_THIN : ECNTRL_AUI, E33G_CNTRL);
593}
594
595
596static void
597el2_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
598{
599 int boguscount = 0;
600 void __iomem *base = ei_status.mem;
601 unsigned short int *buf;
602 unsigned short word;
603
604 /* Maybe enable shared memory just be to be safe... nahh.*/
605 if (base) { /* Use the shared memory. */
606 ring_offset -= (EL2_MB1_START_PG<<8);
607 if (ring_offset + count > EL2_MEMSIZE) {
608 /* We must wrap the input move. */
609 int semi_count = EL2_MEMSIZE - ring_offset;
610 memcpy_fromio(skb->data, base + ring_offset, semi_count);
611 count -= semi_count;
612 memcpy_fromio(skb->data + semi_count, base + ei_status.priv, count);
613 } else {
Al Viro4ec03112007-02-09 16:38:30 +0000614 memcpy_fromio(skb->data, base + ring_offset, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615 }
616 return;
617 }
618
619/*
620 * No shared memory, use programmed I/O.
621 */
622 word = (unsigned short) ring_offset;
623 outb(word>>8, E33G_DMAAH);
624 outb(word&0xFF, E33G_DMAAL);
625
626 outb_p((ei_status.interface_num == 0 ? ECNTRL_THIN : ECNTRL_AUI) | ECNTRL_INPUT
627 | ECNTRL_START, E33G_CNTRL);
628
629/*
630 * Here I also try to get data as fast as possible. I am betting that I
631 * can read one extra byte without clobbering anything in the kernel because
632 * this would only occur on an odd byte-count and allocation of skb->data
633 * is word-aligned. Variable 'count' is NOT checked. Caller must check
634 * for a valid count.
635 * [This is currently quite safe.... but if one day the 3c503 explodes
636 * you know where to come looking ;)]
637 */
638
639 buf = (unsigned short int *) skb->data;
640 count = (count + 1) >> 1;
641 for(;;)
642 {
643 boguscount = 0x1000;
644 while ((inb(E33G_STATUS) & ESTAT_DPRDY) == 0)
645 {
646 if(!boguscount--)
647 {
648 printk("%s: FIFO blocked in el2_block_input.\n", dev->name);
649 el2_reset_8390(dev);
650 goto blocked;
651 }
652 }
653 if(count > WRD_COUNT)
654 {
655 insw(E33G_FIFOH, buf, WRD_COUNT);
656 buf += WRD_COUNT;
657 count -= WRD_COUNT;
658 }
659 else
660 {
661 insw(E33G_FIFOH, buf, count);
662 break;
663 }
664 }
665 blocked:;
666 outb_p(ei_status.interface_num == 0 ? ECNTRL_THIN : ECNTRL_AUI, E33G_CNTRL);
667 return;
668}
669
670
671static void netdev_get_drvinfo(struct net_device *dev,
672 struct ethtool_drvinfo *info)
673{
674 strcpy(info->driver, DRV_NAME);
675 strcpy(info->version, DRV_VERSION);
676 sprintf(info->bus_info, "ISA 0x%lx", dev->base_addr);
677}
678
Jeff Garzik7282d492006-09-13 14:30:00 -0400679static const struct ethtool_ops netdev_ethtool_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 .get_drvinfo = netdev_get_drvinfo,
681};
682
683#ifdef MODULE
684#define MAX_EL2_CARDS 4 /* Max number of EL2 cards per module */
685
686static struct net_device *dev_el2[MAX_EL2_CARDS];
687static int io[MAX_EL2_CARDS];
688static int irq[MAX_EL2_CARDS];
689static int xcvr[MAX_EL2_CARDS]; /* choose int. or ext. xcvr */
690module_param_array(io, int, NULL, 0);
691module_param_array(irq, int, NULL, 0);
692module_param_array(xcvr, int, NULL, 0);
693MODULE_PARM_DESC(io, "I/O base address(es)");
694MODULE_PARM_DESC(irq, "IRQ number(s) (assigned)");
695MODULE_PARM_DESC(xcvr, "transceiver(s) (0=internal, 1=external)");
696MODULE_DESCRIPTION("3Com ISA EtherLink II, II/16 (3c503, 3c503/16) driver");
697MODULE_LICENSE("GPL");
698
699/* This is set up so that only a single autoprobe takes place per call.
700ISA device autoprobes on a running machine are not recommended. */
Randy Dunlap96e672c2006-06-10 13:33:48 -0700701int __init
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702init_module(void)
703{
704 struct net_device *dev;
705 int this_dev, found = 0;
706
707 for (this_dev = 0; this_dev < MAX_EL2_CARDS; this_dev++) {
708 if (io[this_dev] == 0) {
709 if (this_dev != 0) break; /* only autoprobe 1st one */
710 printk(KERN_NOTICE "3c503.c: Presently autoprobing (not recommended) for a single card.\n");
711 }
Alan Cox055e5112008-07-03 23:43:12 -0700712 dev = alloc_eip_netdev();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713 if (!dev)
714 break;
715 dev->irq = irq[this_dev];
716 dev->base_addr = io[this_dev];
717 dev->mem_end = xcvr[this_dev]; /* low 4bits = xcvr sel. */
718 if (do_el2_probe(dev) == 0) {
b1fc5502005-05-12 20:11:55 -0400719 dev_el2[found++] = dev;
720 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721 }
722 free_netdev(dev);
723 printk(KERN_WARNING "3c503.c: No 3c503 card found (i/o = 0x%x).\n", io[this_dev]);
724 break;
725 }
726 if (found)
727 return 0;
728 return -ENXIO;
729}
730
Denis Vlasenko64916f12006-01-05 22:45:47 -0800731static void cleanup_card(struct net_device *dev)
732{
733 /* NB: el2_close() handles free_irq */
734 release_region(dev->base_addr, EL2_IO_EXTENT);
735 if (ei_status.mem)
736 iounmap(ei_status.mem);
737}
738
Al Viroafc8eb42006-06-14 18:50:53 -0400739void __exit
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740cleanup_module(void)
741{
742 int this_dev;
743
744 for (this_dev = 0; this_dev < MAX_EL2_CARDS; this_dev++) {
745 struct net_device *dev = dev_el2[this_dev];
746 if (dev) {
747 unregister_netdev(dev);
748 cleanup_card(dev);
749 free_netdev(dev);
750 }
751 }
752}
753#endif /* MODULE */