projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
r8169: Fix warning in rtl8169_start_xmit().
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / net / 3c503.c
CommitLineData
1da177e4
LT		 1/* 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);
7282d491 82static const struct ethtool_ops netdev_ethtool_ops;
1da177e4 83
6aa20a22 84
1da177e4
LT		 85/* 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
1da177e4
LT		 98 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. */
6aa20a22 128static int __init
1da177e4
LT		 129el2_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
1da177e4
LT		 149#ifndef MODULE
150struct net_device * __init el2_probe(int unit)
151{
055e5110 152 struct net_device *dev = alloc_eip_netdev();
1da177e4
LT		 153 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;
1da177e4 164 return dev;
1da177e4
LT		 165out:
166 free_netdev(dev);
167 return ERR_PTR(err);
168}
169#endif
170
53cdd289
SH		 171static 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,
fe96aaa1 180 .ndo_set_mac_address = eth_mac_addr,
53cdd289
SH		 181 .ndo_change_mtu = eth_change_mtu,
182#ifdef CONFIG_NET_POLL_CONTROLLER
183 .ndo_poll_controller = eip_poll,
184#endif
185};
186
1da177e4
LT		 187/* 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. */
6aa20a22 190static int __init
1da177e4
LT		 191el2_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)
646cdb32 237 pr_debug("%s", version);
1da177e4
LT		 238
239 dev->base_addr = ioaddr;
240
646cdb32 241 pr_info("%s: 3c503 at i/o base %#3x, node ", dev->name, ioaddr);
1da177e4
LT		 242
243 /* Retrieve and print the ethernet address. */
244 for (i = 0; i < 6; i++)
0795af57 245 dev->dev_addr[i] = inb(ioaddr + i);
646cdb32 246 pr_cont("%pM", dev->dev_addr);
1da177e4
LT		 247
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. */
646cdb32
AB		 259 if (ei_debug > 2)
260 pr_cont(" memory jumpers %2.2x ", membase_reg);
1da177e4
LT		 261 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
646cdb32 272 pr_cont(", using %sternal xcvr.\n", ei_status.interface_num == 0 ? "in" : "ex");
1da177e4
LT		 273
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) {
646cdb32 296 pr_warning("3c503: memory failure or memory address conflict.\n");
1da177e4
LT		 297 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) {
646cdb32 348 pr_warning("3c503: configured interrupt %d invalid, will use autoIRQ.\n",
1da177e4
LT		 349 dev->irq);
350 dev->irq = 0;
351 }
352
353 ei_status.saved_irq = dev->irq;
354
53cdd289 355 dev->netdev_ops = &el2_netdev_ops;
1da177e4 356 dev->ethtool_ops = &netdev_ethtool_ops;
1da177e4 357
b1fc5505
HX		 358 retval = register_netdev(dev);
359 if (retval)
360 goto out1;
361
1da177e4 362 if (dev->mem_start)
646cdb32 363 pr_info("%s: %s - %dkB RAM, 8kB shared mem window at %#6lx-%#6lx.\n",
1da177e4
LT		 364 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;
646cdb32 371 pr_info("%s: %s, %dkB RAM, using programmed I/O (REJUMPER for SHARED MEMORY).\n",
1da177e4
LT		 372 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}
6aa20a22 382
1da177e4
LT		 383static int
384el2_open(struct net_device *dev)
385{
ab08999d 386 int retval;
1da177e4
LT		 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 {
ab08999d 394 retval = request_irq(*irqp, NULL, 0, "bogus", dev);
395 if (retval >= 0) {
1da177e4
LT		 396 /* Twinkle the interrupt, and check if it's seen. */
397 unsigned long cookie = probe_irq_on();
398 outb_p(0x04 << ((*irqp == 9) ? 2 : *irqp), E33G_IDCFR);
399 outb_p(0x00, E33G_IDCFR);
400 if (*irqp == probe_irq_off(cookie) /* It's a good IRQ line! */
6aa20a22 401 && ((retval = request_irq(dev->irq = *irqp,
055e5110 402 eip_interrupt, 0, dev->name, dev)) == 0))
1da177e4 403 break;
ab08999d 404 } else {
405 if (retval != -EBUSY)
8a34e2f8 406 return retval;
1da177e4
LT		 407 }
408 } while (*++irqp);
409 if (*irqp == 0) {
410 outb(EGACFR_IRQOFF, E33G_GACFR); /* disable interrupts. */
ab08999d 411 return -EAGAIN;
1da177e4
LT		 412 }
413 } else {
055e5110 414 if ((retval = request_irq(dev->irq, eip_interrupt, 0, dev->name, dev))) {
1da177e4
LT		 415 return retval;
416 }
417 }
418
419 el2_init_card(dev);
055e5110 420 eip_open(dev);
1da177e4
LT		 421 return 0;
422}
423
424static int
425el2_close(struct net_device *dev)
426{
427 free_irq(dev->irq, dev);
428 dev->irq = ei_status.saved_irq;
429 outb(EGACFR_IRQOFF, E33G_GACFR); /* disable interrupts. */
430
055e5110 431 eip_close(dev);
1da177e4
LT		 432 return 0;
433}
434
435/* This is called whenever we have a unrecoverable failure:
436 transmit timeout
437 Bad ring buffer packet header
438 */
439static void
440el2_reset_8390(struct net_device *dev)
441{
442 if (ei_debug > 1) {
646cdb32
AB		 443 pr_debug("%s: Resetting the 3c503 board...", dev->name);
444 pr_cont(" %#lx=%#02x %#lx=%#02x %#lx=%#02x...", E33G_IDCFR, inb(E33G_IDCFR),
1da177e4
LT		 445 E33G_CNTRL, inb(E33G_CNTRL), E33G_GACFR, inb(E33G_GACFR));
446 }
447 outb_p(ECNTRL_RESET|ECNTRL_THIN, E33G_CNTRL);
448 ei_status.txing = 0;
449 outb_p(ei_status.interface_num==0 ? ECNTRL_THIN : ECNTRL_AUI, E33G_CNTRL);
450 el2_init_card(dev);
646cdb32
AB		 451 if (ei_debug > 1)
452 pr_cont("done\n");
1da177e4
LT		 453}
454
455/* Initialize the 3c503 GA registers after a reset. */
456static void
457el2_init_card(struct net_device *dev)
458{
459 /* Unmap the station PROM and select the DIX or BNC connector. */
460 outb_p(ei_status.interface_num==0 ? ECNTRL_THIN : ECNTRL_AUI, E33G_CNTRL);
461
462 /* Set ASIC copy of rx's first and last+1 buffer pages */
463 /* These must be the same as in the 8390. */
464 outb(ei_status.rx_start_page, E33G_STARTPG);
465 outb(ei_status.stop_page, E33G_STOPPG);
466
467 /* Point the vector pointer registers somewhere ?harmless?. */
468 outb(0xff, E33G_VP2); /* Point at the ROM restart location 0xffff0 */
469 outb(0xff, E33G_VP1);
470 outb(0x00, E33G_VP0);
471 /* Turn off all interrupts until we're opened. */
472 outb_p(0x00, dev->base_addr + EN0_IMR);
473 /* Enable IRQs iff started. */
474 outb(EGACFR_NORM, E33G_GACFR);
475
476 /* Set the interrupt line. */
477 outb_p((0x04 << (dev->irq == 9 ? 2 : dev->irq)), E33G_IDCFR);
478 outb_p((WRD_COUNT << 1), E33G_DRQCNT); /* Set burst size to 8 */
479 outb_p(0x20, E33G_DMAAH); /* Put a valid addr in the GA DMA */
480 outb_p(0x00, E33G_DMAAL);
481 return; /* We always succeed */
482}
483
484/*
485 * Either use the shared memory (if enabled on the board) or put the packet
486 * out through the ASIC FIFO.
487 */
488static void
489el2_block_output(struct net_device *dev, int count,
490 const unsigned char *buf, int start_page)
491{
492 unsigned short int *wrd;
493 int boguscount; /* timeout counter */
494 unsigned short word; /* temporary for better machine code */
495 void __iomem *base = ei_status.mem;
496
497 if (ei_status.word16) /* Tx packets go into bank 0 on EL2/16 card */
498 outb(EGACFR_RSEL|EGACFR_TCM, E33G_GACFR);
499 else
500 outb(EGACFR_NORM, E33G_GACFR);
501
502 if (base) { /* Shared memory transfer */
503 memcpy_toio(base + ((start_page - ei_status.tx_start_page) << 8),
504 buf, count);
505 outb(EGACFR_NORM, E33G_GACFR); /* Back to bank1 in case on bank0 */
506 return;
507 }
508
509/*
510 * No shared memory, put the packet out the other way.
511 * Set up then start the internal memory transfer to Tx Start Page
512 */
513
514 word = (unsigned short)start_page;
515 outb(word&0xFF, E33G_DMAAH);
516 outb(word>>8, E33G_DMAAL);
517
518 outb_p((ei_status.interface_num ? ECNTRL_AUI : ECNTRL_THIN ) | ECNTRL_OUTPUT
519 | ECNTRL_START, E33G_CNTRL);
520
521/*
522 * Here I am going to write data to the FIFO as quickly as possible.
523 * Note that E33G_FIFOH is defined incorrectly. It is really
524 * E33G_FIFOL, the lowest port address for both the byte and
525 * word write. Variable 'count' is NOT checked. Caller must supply a
526 * valid count. Note that I may write a harmless extra byte to the
527 * 8390 if the byte-count was not even.
528 */
529 wrd = (unsigned short int *) buf;
530 count = (count + 1) >> 1;
531 for(;;)
532 {
533 boguscount = 0x1000;
534 while ((inb(E33G_STATUS) & ESTAT_DPRDY) == 0)
535 {
536 if(!boguscount--)
537 {
646cdb32 538 pr_notice("%s: FIFO blocked in el2_block_output.\n", dev->name);
1da177e4
LT		 539 el2_reset_8390(dev);
540 goto blocked;
541 }
542 }
543 if(count > WRD_COUNT)
544 {
545 outsw(E33G_FIFOH, wrd, WRD_COUNT);
546 wrd += WRD_COUNT;
547 count -= WRD_COUNT;
548 }
549 else
550 {
551 outsw(E33G_FIFOH, wrd, count);
552 break;
553 }
554 }
555 blocked:;
556 outb_p(ei_status.interface_num==0 ? ECNTRL_THIN : ECNTRL_AUI, E33G_CNTRL);
557 return;
558}
559
560/* Read the 4 byte, page aligned 8390 specific header. */
561static void
562el2_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
563{
564 int boguscount;
565 void __iomem *base = ei_status.mem;
566 unsigned short word;
567
568 if (base) { /* Use the shared memory. */
569 void __iomem *hdr_start = base + ((ring_page - EL2_MB1_START_PG)<<8);
570 memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
571 hdr->count = le16_to_cpu(hdr->count);
572 return;
573 }
574
575/*
576 * No shared memory, use programmed I/O.
577 */
578
579 word = (unsigned short)ring_page;
580 outb(word&0xFF, E33G_DMAAH);
581 outb(word>>8, E33G_DMAAL);
582
583 outb_p((ei_status.interface_num == 0 ? ECNTRL_THIN : ECNTRL_AUI) | ECNTRL_INPUT
584 | ECNTRL_START, E33G_CNTRL);
585 boguscount = 0x1000;
586 while ((inb(E33G_STATUS) & ESTAT_DPRDY) == 0)
587 {
588 if(!boguscount--)
589 {
646cdb32 590 pr_notice("%s: FIFO blocked in el2_get_8390_hdr.\n", dev->name);
1da177e4
LT		 591 memset(hdr, 0x00, sizeof(struct e8390_pkt_hdr));
592 el2_reset_8390(dev);
593 goto blocked;
594 }
595 }
596 insw(E33G_FIFOH, hdr, (sizeof(struct e8390_pkt_hdr))>> 1);
597 blocked:;
598 outb_p(ei_status.interface_num == 0 ? ECNTRL_THIN : ECNTRL_AUI, E33G_CNTRL);
599}
600
601
602static void
603el2_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
604{
605 int boguscount = 0;
606 void __iomem *base = ei_status.mem;
607 unsigned short int *buf;
608 unsigned short word;
609
610 /* Maybe enable shared memory just be to be safe... nahh.*/
611 if (base) { /* Use the shared memory. */
612 ring_offset -= (EL2_MB1_START_PG<<8);
613 if (ring_offset + count > EL2_MEMSIZE) {
614 /* We must wrap the input move. */
615 int semi_count = EL2_MEMSIZE - ring_offset;
616 memcpy_fromio(skb->data, base + ring_offset, semi_count);
617 count -= semi_count;
618 memcpy_fromio(skb->data + semi_count, base + ei_status.priv, count);
619 } else {
4ec03116 620 memcpy_fromio(skb->data, base + ring_offset, count);
1da177e4
LT		 621 }
622 return;
623 }
624
625/*
626 * No shared memory, use programmed I/O.
627 */
628 word = (unsigned short) ring_offset;
629 outb(word>>8, E33G_DMAAH);
630 outb(word&0xFF, E33G_DMAAL);
631
632 outb_p((ei_status.interface_num == 0 ? ECNTRL_THIN : ECNTRL_AUI) | ECNTRL_INPUT
633 | ECNTRL_START, E33G_CNTRL);
634
635/*
636 * Here I also try to get data as fast as possible. I am betting that I
637 * can read one extra byte without clobbering anything in the kernel because
638 * this would only occur on an odd byte-count and allocation of skb->data
639 * is word-aligned. Variable 'count' is NOT checked. Caller must check
640 * for a valid count.
641 * [This is currently quite safe.... but if one day the 3c503 explodes
642 * you know where to come looking ;)]
643 */
644
645 buf = (unsigned short int *) skb->data;
646 count = (count + 1) >> 1;
647 for(;;)
648 {
649 boguscount = 0x1000;
650 while ((inb(E33G_STATUS) & ESTAT_DPRDY) == 0)
651 {
652 if(!boguscount--)
653 {
646cdb32 654 pr_notice("%s: FIFO blocked in el2_block_input.\n", dev->name);
1da177e4
LT		 655 el2_reset_8390(dev);
656 goto blocked;
657 }
658 }
659 if(count > WRD_COUNT)
660 {
661 insw(E33G_FIFOH, buf, WRD_COUNT);
662 buf += WRD_COUNT;
663 count -= WRD_COUNT;
664 }
665 else
666 {
667 insw(E33G_FIFOH, buf, count);
668 break;
669 }
670 }
671 blocked:;
672 outb_p(ei_status.interface_num == 0 ? ECNTRL_THIN : ECNTRL_AUI, E33G_CNTRL);
673 return;
674}
675
676
677static void netdev_get_drvinfo(struct net_device *dev,
678 struct ethtool_drvinfo *info)
679{
680 strcpy(info->driver, DRV_NAME);
681 strcpy(info->version, DRV_VERSION);
682 sprintf(info->bus_info, "ISA 0x%lx", dev->base_addr);
683}
684
7282d491 685static const struct ethtool_ops netdev_ethtool_ops = {
1da177e4
LT		 686 .get_drvinfo = netdev_get_drvinfo,
687};
688
689#ifdef MODULE
690#define MAX_EL2_CARDS 4 /* Max number of EL2 cards per module */
691
692static struct net_device *dev_el2[MAX_EL2_CARDS];
693static int io[MAX_EL2_CARDS];
694static int irq[MAX_EL2_CARDS];
695static int xcvr[MAX_EL2_CARDS]; /* choose int. or ext. xcvr */
696module_param_array(io, int, NULL, 0);
697module_param_array(irq, int, NULL, 0);
698module_param_array(xcvr, int, NULL, 0);
699MODULE_PARM_DESC(io, "I/O base address(es)");
700MODULE_PARM_DESC(irq, "IRQ number(s) (assigned)");
701MODULE_PARM_DESC(xcvr, "transceiver(s) (0=internal, 1=external)");
702MODULE_DESCRIPTION("3Com ISA EtherLink II, II/16 (3c503, 3c503/16) driver");
703MODULE_LICENSE("GPL");
704
705/* This is set up so that only a single autoprobe takes place per call.
706ISA device autoprobes on a running machine are not recommended. */
96e672c7 707int __init
1da177e4
LT		 708init_module(void)
709{
710 struct net_device *dev;
711 int this_dev, found = 0;
712
713 for (this_dev = 0; this_dev < MAX_EL2_CARDS; this_dev++) {
714 if (io[this_dev] == 0) {
715 if (this_dev != 0) break; /* only autoprobe 1st one */
646cdb32 716 pr_notice("3c503.c: Presently autoprobing (not recommended) for a single card.\n");
1da177e4 717 }
055e5110 718 dev = alloc_eip_netdev();
1da177e4
LT		 719 if (!dev)
720 break;
721 dev->irq = irq[this_dev];
722 dev->base_addr = io[this_dev];
723 dev->mem_end = xcvr[this_dev]; /* low 4bits = xcvr sel. */
724 if (do_el2_probe(dev) == 0) {
b1fc5505
HX		 725 dev_el2[found++] = dev;
726 continue;
1da177e4
LT		 727 }
728 free_netdev(dev);
646cdb32 729 pr_warning("3c503.c: No 3c503 card found (i/o = 0x%x).\n", io[this_dev]);
1da177e4
LT		 730 break;
731 }
732 if (found)
733 return 0;
734 return -ENXIO;
735}
736
64916f1e
DV		 737static void cleanup_card(struct net_device *dev)
738{
739 /* NB: el2_close() handles free_irq */
740 release_region(dev->base_addr, EL2_IO_EXTENT);
741 if (ei_status.mem)
742 iounmap(ei_status.mem);
743}
744
afc8eb46 745void __exit
1da177e4
LT		 746cleanup_module(void)
747{
748 int this_dev;
749
750 for (this_dev = 0; this_dev < MAX_EL2_CARDS; this_dev++) {
751 struct net_device *dev = dev_el2[this_dev];
752 if (dev) {
753 unregister_netdev(dev);
754 cleanup_card(dev);
755 free_netdev(dev);
756 }
757 }
758}
759#endif /* MODULE */
kernel source for telekom puls (alcatel/mediatek)