projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit...
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / net / 3c509.c
CommitLineData
1da177e4
LT		 1/* 3c509.c: A 3c509 EtherLink3 ethernet driver for linux. */
2/*
3 Written 1993-2000 by Donald Becker.
4
5 Copyright 1994-2000 by Donald Becker.
6 Copyright 1993 United States Government as represented by the
7 Director, National Security Agency. This software may be used and
8 distributed according to the terms of the GNU General Public License,
9 incorporated herein by reference.
10
11 This driver is for the 3Com EtherLinkIII series.
12
13 The author may be reached as becker@scyld.com, or C/O
14 Scyld Computing Corporation
15 410 Severn Ave., Suite 210
16 Annapolis MD 21403
17
18 Known limitations:
19 Because of the way 3c509 ISA detection works it's difficult to predict
20 a priori which of several ISA-mode cards will be detected first.
21
22 This driver does not use predictive interrupt mode, resulting in higher
23 packet latency but lower overhead. If interrupts are disabled for an
24 unusually long time it could also result in missed packets, but in
25 practice this rarely happens.
26
27
28 FIXES:
29 Alan Cox: Removed the 'Unexpected interrupt' bug.
30 Michael Meskes: Upgraded to Donald Becker's version 1.07.
6aa20a22 31 Alan Cox: Increased the eeprom delay. Regardless of
1da177e4
LT		 32 what the docs say some people definitely
33 get problems with lower (but in card spec)
34 delays
35 v1.10 4/21/97 Fixed module code so that multiple cards may be detected,
36 other cleanups. -djb
37 Andrea Arcangeli: Upgraded to Donald Becker's version 1.12.
38 Rick Payne: Fixed SMP race condition
39 v1.13 9/8/97 Made 'max_interrupt_work' an insmod-settable variable -djb
40 v1.14 10/15/97 Avoided waiting..discard message for fast machines -djb
41 v1.15 1/31/98 Faster recovery for Tx errors. -djb
42 v1.16 2/3/98 Different ID port handling to avoid sound cards. -djb
e1f8e874 43 v1.18 12Mar2001 Andrew Morton
1da177e4
LT		 44 - Avoid bogus detect of 3c590's (Andrzej Krzysztofowicz)
45 - Reviewed against 1.18 from scyld.com
46 v1.18a 17Nov2001 Jeff Garzik <jgarzik@pobox.com>
47 - ethtool support
48 v1.18b 1Mar2002 Zwane Mwaikambo <zwane@commfireservices.com>
49 - Power Management support
50 v1.18c 1Mar2002 David Ruggiero <jdr@farfalle.com>
51 - Full duplex support
52 v1.19 16Oct2002 Zwane Mwaikambo <zwane@linuxpower.ca>
53 - Additional ethtool features
54 v1.19a 28Oct2002 Davud Ruggiero <jdr@farfalle.com>
55 - Increase *read_eeprom udelay to workaround oops with 2 cards.
56 v1.19b 08Nov2002 Marc Zyngier <maz@wild-wind.fr.eu.org>
ac4bed13
OZ		 57 - Introduce driver model for EISA cards.
58 v1.20 04Feb2008 Ondrej Zary <linux@rainbow-software.org>
59 - convert to isa_driver and pnp_driver and some cleanups
1da177e4
LT		 60*/
61
62#define DRV_NAME "3c509"
ac4bed13
OZ		 63#define DRV_VERSION "1.20"
64#define DRV_RELDATE "04Feb2008"
1da177e4
LT		 65
66/* A few values that may be tweaked. */
67
68/* Time in jiffies before concluding the transmitter is hung. */
69#define TX_TIMEOUT (400*HZ/1000)
1da177e4 70
1da177e4 71#include <linux/module.h>
1da177e4 72#include <linux/mca.h>
ac4bed13
OZ		 73#include <linux/isa.h>
74#include <linux/pnp.h>
1da177e4
LT		 75#include <linux/string.h>
76#include <linux/interrupt.h>
77#include <linux/errno.h>
78#include <linux/in.h>
1da177e4
LT		 79#include <linux/ioport.h>
80#include <linux/init.h>
81#include <linux/netdevice.h>
82#include <linux/etherdevice.h>
83#include <linux/pm.h>
84#include <linux/skbuff.h>
85#include <linux/delay.h> /* for udelay() */
86#include <linux/spinlock.h>
87#include <linux/ethtool.h>
88#include <linux/device.h>
89#include <linux/eisa.h>
90#include <linux/bitops.h>
91
92#include <asm/uaccess.h>
93#include <asm/io.h>
94#include <asm/irq.h>
95
37b2a179 96static char version[] __devinitdata = DRV_NAME ".c:" DRV_VERSION " " DRV_RELDATE " becker@scyld.com\n";
1da177e4
LT		 97
98#ifdef EL3_DEBUG
99static int el3_debug = EL3_DEBUG;
100#else
101static int el3_debug = 2;
102#endif
103
104/* Used to do a global count of all the cards in the system. Must be
105 * a global variable so that the mca/eisa probe routines can increment
106 * it */
107static int el3_cards = 0;
ac4bed13 108#define EL3_MAX_CARDS 8
1da177e4
LT		 109
110/* To minimize the size of the driver source I only define operating
111 constants if they are used several times. You'll need the manual
112 anyway if you want to understand driver details. */
113/* Offsets from base I/O address. */
114#define EL3_DATA 0x00
115#define EL3_CMD 0x0e
116#define EL3_STATUS 0x0e
ac4bed13 117#define EEPROM_READ 0x80
1da177e4
LT		 118
119#define EL3_IO_EXTENT 16
120
121#define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
122
123
124/* The top five bits written to EL3_CMD are a command, the lower
125 11 bits are the parameter, if applicable. */
126enum c509cmd {
127 TotalReset = 0<<11, SelectWindow = 1<<11, StartCoax = 2<<11,
128 RxDisable = 3<<11, RxEnable = 4<<11, RxReset = 5<<11, RxDiscard = 8<<11,
129 TxEnable = 9<<11, TxDisable = 10<<11, TxReset = 11<<11,
130 FakeIntr = 12<<11, AckIntr = 13<<11, SetIntrEnb = 14<<11,
131 SetStatusEnb = 15<<11, SetRxFilter = 16<<11, SetRxThreshold = 17<<11,
132 SetTxThreshold = 18<<11, SetTxStart = 19<<11, StatsEnable = 21<<11,
133 StatsDisable = 22<<11, StopCoax = 23<<11, PowerUp = 27<<11,
134 PowerDown = 28<<11, PowerAuto = 29<<11};
135
136enum c509status {
137 IntLatch = 0x0001, AdapterFailure = 0x0002, TxComplete = 0x0004,
138 TxAvailable = 0x0008, RxComplete = 0x0010, RxEarly = 0x0020,
139 IntReq = 0x0040, StatsFull = 0x0080, CmdBusy = 0x1000, };
140
141/* The SetRxFilter command accepts the following classes: */
142enum RxFilter {
143 RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8 };
144
145/* Register window 1 offsets, the window used in normal operation. */
146#define TX_FIFO 0x00
147#define RX_FIFO 0x00
148#define RX_STATUS 0x08
149#define TX_STATUS 0x0B
150#define TX_FREE 0x0C /* Remaining free bytes in Tx buffer. */
151
152#define WN0_CONF_CTRL 0x04 /* Window 0: Configuration control register */
153#define WN0_ADDR_CONF 0x06 /* Window 0: Address configuration register */
154#define WN0_IRQ 0x08 /* Window 0: Set IRQ line in bits 12-15. */
155#define WN4_MEDIA 0x0A /* Window 4: Various transcvr/media bits. */
156#define MEDIA_TP 0x00C0 /* Enable link beat and jabber for 10baseT. */
157#define WN4_NETDIAG 0x06 /* Window 4: Net diagnostic */
6aa20a22 158#define FD_ENABLE 0x8000 /* Enable full-duplex ("external loopback") */
1da177e4
LT		 159
160/*
161 * Must be a power of two (we use a binary and in the
162 * circular queue)
163 */
164#define SKB_QUEUE_SIZE 64
165
ac4bed13
OZ		 166enum el3_cardtype { EL3_ISA, EL3_PNP, EL3_MCA, EL3_EISA };
167
1da177e4 168struct el3_private {
1da177e4
LT		 169 spinlock_t lock;
170 /* skb send-queue */
171 int head, size;
172 struct sk_buff *queue[SKB_QUEUE_SIZE];
ac4bed13 173 enum el3_cardtype type;
1da177e4 174};
ac4bed13
OZ		 175static int id_port;
176static int current_tag;
177static struct net_device *el3_devs[EL3_MAX_CARDS];
178
179/* Parameters that may be passed into the module. */
180static int debug = -1;
181static int irq[] = {-1, -1, -1, -1, -1, -1, -1, -1};
182/* Maximum events (Rx packets, etc.) to handle at each interrupt. */
183static int max_interrupt_work = 10;
184#ifdef CONFIG_PNP
185static int nopnp;
186#endif
1da177e4 187
37b2a179 188static int __devinit el3_common_init(struct net_device *dev);
ac4bed13 189static void el3_common_remove(struct net_device *dev);
1da177e4
LT		 190static ushort id_read_eeprom(int index);
191static ushort read_eeprom(int ioaddr, int index);
192static int el3_open(struct net_device *dev);
27a1de95 193static netdev_tx_t el3_start_xmit(struct sk_buff *skb, struct net_device *dev);
7d12e780 194static irqreturn_t el3_interrupt(int irq, void *dev_id);
1da177e4
LT		 195static void update_stats(struct net_device *dev);
196static struct net_device_stats *el3_get_stats(struct net_device *dev);
197static int el3_rx(struct net_device *dev);
198static int el3_close(struct net_device *dev);
199static void set_multicast_list(struct net_device *dev);
200static void el3_tx_timeout (struct net_device *dev);
201static void el3_down(struct net_device *dev);
202static void el3_up(struct net_device *dev);
7282d491 203static const struct ethtool_ops ethtool_ops;
ac4bed13 204#ifdef CONFIG_PM
60a89ff6
PE		 205static int el3_suspend(struct device *, pm_message_t);
206static int el3_resume(struct device *);
207#else
208#define el3_suspend NULL
209#define el3_resume NULL
1da177e4 210#endif
60a89ff6
PE		 211
212
1da177e4 213/* generic device remove for all device types */
1da177e4 214static int el3_device_remove (struct device *device);
1da177e4
LT		 215#ifdef CONFIG_NET_POLL_CONTROLLER
216static void el3_poll_controller(struct net_device *dev);
217#endif
218
ac4bed13
OZ		 219/* Return 0 on success, 1 on error, 2 when found already detected PnP card */
220static int el3_isa_id_sequence(__be16 *phys_addr)
221{
222 short lrs_state = 0xff;
223 int i;
224
225 /* ISA boards are detected by sending the ID sequence to the
226 ID_PORT. We find cards past the first by setting the 'current_tag'
227 on cards as they are found. Cards with their tag set will not
228 respond to subsequent ID sequences. */
229
230 outb(0x00, id_port);
231 outb(0x00, id_port);
232 for (i = 0; i < 255; i++) {
233 outb(lrs_state, id_port);
234 lrs_state <<= 1;
235 lrs_state = lrs_state & 0x100 ? lrs_state ^ 0xcf : lrs_state;
236 }
237 /* For the first probe, clear all board's tag registers. */
238 if (current_tag == 0)
239 outb(0xd0, id_port);
240 else /* Otherwise kill off already-found boards. */
241 outb(0xd8, id_port);
242 if (id_read_eeprom(7) != 0x6d50)
243 return 1;
244 /* Read in EEPROM data, which does contention-select.
245 Only the lowest address board will stay "on-line".
246 3Com got the byte order backwards. */
247 for (i = 0; i < 3; i++)
248 phys_addr[i] = htons(id_read_eeprom(i));
249#ifdef CONFIG_PNP
250 if (!nopnp) {
251 /* The ISA PnP 3c509 cards respond to the ID sequence too.
252 This check is needed in order not to register them twice. */
253 for (i = 0; i < el3_cards; i++) {
254 struct el3_private *lp = netdev_priv(el3_devs[i]);
8e95a202
JP		 255 if (lp->type == EL3_PNP &&
256 !memcmp(phys_addr, el3_devs[i]->dev_addr,
257 ETH_ALEN)) {
ac4bed13 258 if (el3_debug > 3)
646cdb32 259 pr_debug("3c509 with address %02x %02x %02x %02x %02x %02x was found by ISAPnP\n",
ac4bed13
OZ		 260 phys_addr[0] & 0xff, phys_addr[0] >> 8,
261 phys_addr[1] & 0xff, phys_addr[1] >> 8,
262 phys_addr[2] & 0xff, phys_addr[2] >> 8);
263 /* Set the adaptor tag so that the next card can be found. */
264 outb(0xd0 + ++current_tag, id_port);
265 return 2;
266 }
267 }
268 }
269#endif /* CONFIG_PNP */
270 return 0;
271
272}
273
274static void __devinit el3_dev_fill(struct net_device *dev, __be16 *phys_addr,
275 int ioaddr, int irq, int if_port,
276 enum el3_cardtype type)
277{
278 struct el3_private *lp = netdev_priv(dev);
279
280 memcpy(dev->dev_addr, phys_addr, ETH_ALEN);
281 dev->base_addr = ioaddr;
282 dev->irq = irq;
283 dev->if_port = if_port;
284 lp->type = type;
285}
286
287static int __devinit el3_isa_match(struct device *pdev,
288 unsigned int ndev)
289{
290 struct net_device *dev;
291 int ioaddr, isa_irq, if_port, err;
292 unsigned int iobase;
293 __be16 phys_addr[3];
294
295 while ((err = el3_isa_id_sequence(phys_addr)) == 2)
296 ; /* Skip to next card when PnP card found */
297 if (err == 1)
298 return 0;
299
300 iobase = id_read_eeprom(8);
301 if_port = iobase >> 14;
302 ioaddr = 0x200 + ((iobase & 0x1f) << 4);
303 if (irq[el3_cards] > 1 && irq[el3_cards] < 16)
304 isa_irq = irq[el3_cards];
305 else
306 isa_irq = id_read_eeprom(9) >> 12;
307
308 dev = alloc_etherdev(sizeof(struct el3_private));
309 if (!dev)
310 return -ENOMEM;
311
312 netdev_boot_setup_check(dev);
313
314 if (!request_region(ioaddr, EL3_IO_EXTENT, "3c509-isa")) {
315 free_netdev(dev);
316 return 0;
317 }
318
319 /* Set the adaptor tag so that the next card can be found. */
320 outb(0xd0 + ++current_tag, id_port);
321
322 /* Activate the adaptor at the EEPROM location. */
323 outb((ioaddr >> 4) | 0xe0, id_port);
324
325 EL3WINDOW(0);
326 if (inw(ioaddr) != 0x6d50) {
327 free_netdev(dev);
328 return 0;
329 }
330
331 /* Free the interrupt so that some other card can use it. */
332 outw(0x0f00, ioaddr + WN0_IRQ);
333
334 el3_dev_fill(dev, phys_addr, ioaddr, isa_irq, if_port, EL3_ISA);
335 dev_set_drvdata(pdev, dev);
336 if (el3_common_init(dev)) {
337 free_netdev(dev);
338 return 0;
339 }
340
341 el3_devs[el3_cards++] = dev;
342 return 1;
343}
344
345static int __devexit el3_isa_remove(struct device *pdev,
346 unsigned int ndev)
347{
348 el3_device_remove(pdev);
349 dev_set_drvdata(pdev, NULL);
350 return 0;
351}
352
353#ifdef CONFIG_PM
354static int el3_isa_suspend(struct device *dev, unsigned int n,
355 pm_message_t state)
356{
357 current_tag = 0;
358 return el3_suspend(dev, state);
359}
360
361static int el3_isa_resume(struct device *dev, unsigned int n)
362{
363 struct net_device *ndev = dev_get_drvdata(dev);
364 int ioaddr = ndev->base_addr, err;
365 __be16 phys_addr[3];
366
367 while ((err = el3_isa_id_sequence(phys_addr)) == 2)
368 ; /* Skip to next card when PnP card found */
369 if (err == 1)
370 return 0;
371 /* Set the adaptor tag so that the next card can be found. */
372 outb(0xd0 + ++current_tag, id_port);
373 /* Enable the card */
374 outb((ioaddr >> 4) | 0xe0, id_port);
375 EL3WINDOW(0);
376 if (inw(ioaddr) != 0x6d50)
377 return 1;
378 /* Free the interrupt so that some other card can use it. */
379 outw(0x0f00, ioaddr + WN0_IRQ);
380 return el3_resume(dev);
381}
382#endif
383
384static struct isa_driver el3_isa_driver = {
385 .match = el3_isa_match,
386 .remove = __devexit_p(el3_isa_remove),
387#ifdef CONFIG_PM
388 .suspend = el3_isa_suspend,
389 .resume = el3_isa_resume,
390#endif
391 .driver = {
392 .name = "3c509"
393 },
394};
395static int isa_registered;
396
397#ifdef CONFIG_PNP
398static struct pnp_device_id el3_pnp_ids[] = {
399 { .id = "TCM5090" }, /* 3Com Etherlink III (TP) */
400 { .id = "TCM5091" }, /* 3Com Etherlink III */
401 { .id = "TCM5094" }, /* 3Com Etherlink III (combo) */
402 { .id = "TCM5095" }, /* 3Com Etherlink III (TPO) */
403 { .id = "TCM5098" }, /* 3Com Etherlink III (TPC) */
404 { .id = "PNP80f7" }, /* 3Com Etherlink III compatible */
405 { .id = "PNP80f8" }, /* 3Com Etherlink III compatible */
406 { .id = "" }
407};
408MODULE_DEVICE_TABLE(pnp, el3_pnp_ids);
409
410static int __devinit el3_pnp_probe(struct pnp_dev *pdev,
411 const struct pnp_device_id *id)
412{
413 short i;
414 int ioaddr, irq, if_port;
4ec7ffa2 415 __be16 phys_addr[3];
ac4bed13
OZ		 416 struct net_device *dev = NULL;
417 int err;
418
419 ioaddr = pnp_port_start(pdev, 0);
420 if (!request_region(ioaddr, EL3_IO_EXTENT, "3c509-pnp"))
421 return -EBUSY;
422 irq = pnp_irq(pdev, 0);
423 EL3WINDOW(0);
424 for (i = 0; i < 3; i++)
425 phys_addr[i] = htons(read_eeprom(ioaddr, i));
426 if_port = read_eeprom(ioaddr, 8) >> 14;
427 dev = alloc_etherdev(sizeof(struct el3_private));
428 if (!dev) {
429 release_region(ioaddr, EL3_IO_EXTENT);
430 return -ENOMEM;
431 }
432 SET_NETDEV_DEV(dev, &pdev->dev);
433 netdev_boot_setup_check(dev);
434
435 el3_dev_fill(dev, phys_addr, ioaddr, irq, if_port, EL3_PNP);
436 pnp_set_drvdata(pdev, dev);
437 err = el3_common_init(dev);
438
439 if (err) {
440 pnp_set_drvdata(pdev, NULL);
441 free_netdev(dev);
442 return err;
443 }
444
445 el3_devs[el3_cards++] = dev;
446 return 0;
447}
448
449static void __devexit el3_pnp_remove(struct pnp_dev *pdev)
450{
451 el3_common_remove(pnp_get_drvdata(pdev));
452 pnp_set_drvdata(pdev, NULL);
453}
454
455#ifdef CONFIG_PM
456static int el3_pnp_suspend(struct pnp_dev *pdev, pm_message_t state)
457{
458 return el3_suspend(&pdev->dev, state);
459}
460
461static int el3_pnp_resume(struct pnp_dev *pdev)
462{
463 return el3_resume(&pdev->dev);
464}
465#endif
466
467static struct pnp_driver el3_pnp_driver = {
468 .name = "3c509",
469 .id_table = el3_pnp_ids,
470 .probe = el3_pnp_probe,
471 .remove = __devexit_p(el3_pnp_remove),
472#ifdef CONFIG_PM
473 .suspend = el3_pnp_suspend,
474 .resume = el3_pnp_resume,
475#endif
476};
477static int pnp_registered;
478#endif /* CONFIG_PNP */
479
1da177e4
LT		 480#ifdef CONFIG_EISA
481static struct eisa_device_id el3_eisa_ids[] = {
cf9f6e21
MR		 482 { "TCM5090" },
483 { "TCM5091" },
1da177e4
LT		 484 { "TCM5092" },
485 { "TCM5093" },
cf9f6e21 486 { "TCM5094" },
f04e3f09 487 { "TCM5095" },
cf9f6e21 488 { "TCM5098" },
1da177e4
LT		 489 { "" }
490};
07563c71 491MODULE_DEVICE_TABLE(eisa, el3_eisa_ids);
1da177e4
LT		 492
493static int el3_eisa_probe (struct device *device);
494
495static struct eisa_driver el3_eisa_driver = {
496 .id_table = el3_eisa_ids,
497 .driver = {
ac4bed13 498 .name = "3c579",
1da177e4 499 .probe = el3_eisa_probe,
60a89ff6
PE		 500 .remove = __devexit_p (el3_device_remove),
501 .suspend = el3_suspend,
502 .resume = el3_resume,
1da177e4
LT		 503 }
504};
ac4bed13 505static int eisa_registered;
1da177e4
LT		 506#endif
507
508#ifdef CONFIG_MCA
509static int el3_mca_probe(struct device *dev);
510
511static short el3_mca_adapter_ids[] __initdata = {
512 0x627c,
513 0x627d,
514 0x62db,
515 0x62f6,
516 0x62f7,
517 0x0000
518};
519
520static char *el3_mca_adapter_names[] __initdata = {
521 "3Com 3c529 EtherLink III (10base2)",
522 "3Com 3c529 EtherLink III (10baseT)",
523 "3Com 3c529 EtherLink III (test mode)",
524 "3Com 3c529 EtherLink III (TP or coax)",
525 "3Com 3c529 EtherLink III (TP)",
526 NULL
527};
528
529static struct mca_driver el3_mca_driver = {
530 .id_table = el3_mca_adapter_ids,
531 .driver = {
532 .name = "3c529",
533 .bus = &mca_bus_type,
534 .probe = el3_mca_probe,
535 .remove = __devexit_p(el3_device_remove),
60a89ff6
PE		 536 .suspend = el3_suspend,
537 .resume = el3_resume,
1da177e4
LT		 538 },
539};
ac4bed13 540static int mca_registered;
1da177e4
LT		 541#endif /* CONFIG_MCA */
542
3186ae8f
SH		 543static const struct net_device_ops netdev_ops = {
544 .ndo_open = el3_open,
545 .ndo_stop = el3_close,
546 .ndo_start_xmit = el3_start_xmit,
547 .ndo_get_stats = el3_get_stats,
548 .ndo_set_multicast_list = set_multicast_list,
549 .ndo_tx_timeout = el3_tx_timeout,
550 .ndo_change_mtu = eth_change_mtu,
551 .ndo_set_mac_address = eth_mac_addr,
552 .ndo_validate_addr = eth_validate_addr,
553#ifdef CONFIG_NET_POLL_CONTROLLER
554 .ndo_poll_controller = el3_poll_controller,
555#endif
556};
557
37b2a179 558static int __devinit el3_common_init(struct net_device *dev)
1da177e4
LT		 559{
560 struct el3_private *lp = netdev_priv(dev);
1da177e4 561 int err;
0795af57 562 const char *if_names[] = {"10baseT", "AUI", "undefined", "BNC"};
1da177e4
LT		 563
564 spin_lock_init(&lp->lock);
565
566 if (dev->mem_start & 0x05) { /* xcvr codes 1/3/4/12 */
567 dev->if_port = (dev->mem_start & 0x0f);
568 } else { /* xcvr codes 0/8 */
569 /* use eeprom value, but save user's full-duplex selection */
570 dev->if_port |= (dev->mem_start & 0x08);
571 }
572
573 /* The EL3-specific entries in the device structure. */
3186ae8f 574 dev->netdev_ops = &netdev_ops;
1da177e4 575 dev->watchdog_timeo = TX_TIMEOUT;
1da177e4
LT		 576 SET_ETHTOOL_OPS(dev, &ethtool_ops);
577
578 err = register_netdev(dev);
579 if (err) {
646cdb32 580 pr_err("Failed to register 3c5x9 at %#3.3lx, IRQ %d.\n",
1da177e4
LT		 581 dev->base_addr, dev->irq);
582 release_region(dev->base_addr, EL3_IO_EXTENT);
583 return err;
584 }
585
646cdb32 586 pr_info("%s: 3c5x9 found at %#3.3lx, %s port, address %pM, IRQ %d.\n",
0795af57 587 dev->name, dev->base_addr, if_names[(dev->if_port & 0x03)],
e174961c 588 dev->dev_addr, dev->irq);
1da177e4
LT		 589
590 if (el3_debug > 0)
646cdb32 591 pr_info("%s", version);
1da177e4
LT		 592 return 0;
593
594}
595
596static void el3_common_remove (struct net_device *dev)
597{
1da177e4
LT		 598 unregister_netdev (dev);
599 release_region(dev->base_addr, EL3_IO_EXTENT);
600 free_netdev (dev);
601}
602
1da177e4
LT		 603#ifdef CONFIG_MCA
604static int __init el3_mca_probe(struct device *device)
605{
606 /* Based on Erik Nygren's (nygren@mit.edu) 3c529 patch,
607 * heavily modified by Chris Beauregard
608 * (cpbeaure@csclub.uwaterloo.ca) to support standard MCA
609 * probing.
610 *
611 * redone for multi-card detection by ZP Gu (zpg@castle.net)
612 * now works as a module */
613
1da177e4
LT		 614 short i;
615 int ioaddr, irq, if_port;
4ec7ffa2 616 __be16 phys_addr[3];
1da177e4
LT		 617 struct net_device *dev = NULL;
618 u_char pos4, pos5;
619 struct mca_device *mdev = to_mca_device(device);
620 int slot = mdev->slot;
621 int err;
622
623 pos4 = mca_device_read_stored_pos(mdev, 4);
624 pos5 = mca_device_read_stored_pos(mdev, 5);
625
626 ioaddr = ((short)((pos4&0xfc)|0x02)) << 8;
627 irq = pos5 & 0x0f;
628
629
646cdb32
AB		 630 pr_info("3c529: found %s at slot %d\n",
631 el3_mca_adapter_names[mdev->index], slot + 1);
1da177e4
LT		 632
633 /* claim the slot */
634 strncpy(mdev->name, el3_mca_adapter_names[mdev->index],
635 sizeof(mdev->name));
636 mca_device_set_claim(mdev, 1);
637
638 if_port = pos4 & 0x03;
639
640 irq = mca_device_transform_irq(mdev, irq);
6aa20a22 641 ioaddr = mca_device_transform_ioport(mdev, ioaddr);
1da177e4 642 if (el3_debug > 2) {
646cdb32 643 pr_debug("3c529: irq %d ioaddr 0x%x ifport %d\n", irq, ioaddr, if_port);
1da177e4
LT		 644 }
645 EL3WINDOW(0);
4ec7ffa2
AV		 646 for (i = 0; i < 3; i++)
647 phys_addr[i] = htons(read_eeprom(ioaddr, i));
1da177e4
LT		 648
649 dev = alloc_etherdev(sizeof (struct el3_private));
650 if (dev == NULL) {
4ec7ffa2
AV		 651 release_region(ioaddr, EL3_IO_EXTENT);
652 return -ENOMEM;
1da177e4
LT		 653 }
654
1da177e4
LT		 655 netdev_boot_setup_check(dev);
656
ac4bed13 657 el3_dev_fill(dev, phys_addr, ioaddr, irq, if_port, EL3_MCA);
1aec5bdf 658 dev_set_drvdata(device, dev);
1da177e4
LT		 659 err = el3_common_init(dev);
660
661 if (err) {
1aec5bdf 662 dev_set_drvdata(device, NULL);
1da177e4
LT		 663 free_netdev(dev);
664 return -ENOMEM;
665 }
666
ac4bed13 667 el3_devs[el3_cards++] = dev;
1da177e4
LT		 668 return 0;
669}
6aa20a22 670
1da177e4
LT		 671#endif /* CONFIG_MCA */
672
673#ifdef CONFIG_EISA
674static int __init el3_eisa_probe (struct device *device)
675{
1da177e4
LT		 676 short i;
677 int ioaddr, irq, if_port;
4ec7ffa2 678 __be16 phys_addr[3];
1da177e4
LT		 679 struct net_device *dev = NULL;
680 struct eisa_device *edev;
681 int err;
682
683 /* Yeepee, The driver framework is calling us ! */
684 edev = to_eisa_device (device);
685 ioaddr = edev->base_addr;
6aa20a22 686
ac4bed13 687 if (!request_region(ioaddr, EL3_IO_EXTENT, "3c579-eisa"))
1da177e4
LT		 688 return -EBUSY;
689
690 /* Change the register set to the configuration window 0. */
691 outw(SelectWindow | 0, ioaddr + 0xC80 + EL3_CMD);
692
693 irq = inw(ioaddr + WN0_IRQ) >> 12;
694 if_port = inw(ioaddr + 6)>>14;
695 for (i = 0; i < 3; i++)
696 phys_addr[i] = htons(read_eeprom(ioaddr, i));
697
698 /* Restore the "Product ID" to the EEPROM read register. */
699 read_eeprom(ioaddr, 3);
700
701 dev = alloc_etherdev(sizeof (struct el3_private));
702 if (dev == NULL) {
703 release_region(ioaddr, EL3_IO_EXTENT);
704 return -ENOMEM;
705 }
706
1da177e4
LT		 707 netdev_boot_setup_check(dev);
708
ac4bed13 709 el3_dev_fill(dev, phys_addr, ioaddr, irq, if_port, EL3_EISA);
1da177e4
LT		 710 eisa_set_drvdata (edev, dev);
711 err = el3_common_init(dev);
712
713 if (err) {
714 eisa_set_drvdata (edev, NULL);
715 free_netdev(dev);
716 return err;
717 }
718
ac4bed13 719 el3_devs[el3_cards++] = dev;
1da177e4
LT		 720 return 0;
721}
722#endif
723
1da177e4
LT		 724/* This remove works for all device types.
725 *
1aec5bdf 726 * The net dev must be stored in the driver data field */
1da177e4
LT		 727static int __devexit el3_device_remove (struct device *device)
728{
729 struct net_device *dev;
730
1aec5bdf 731 dev = dev_get_drvdata(device);
1da177e4
LT		 732
733 el3_common_remove (dev);
734 return 0;
735}
1da177e4
LT		 736
737/* Read a word from the EEPROM using the regular EEPROM access register.
738 Assume that we are in register window zero.
739 */
740static ushort read_eeprom(int ioaddr, int index)
741{
742 outw(EEPROM_READ + index, ioaddr + 10);
6aa20a22 743 /* Pause for at least 162 us. for the read to take place.
1da177e4
LT		 744 Some chips seem to require much longer */
745 mdelay(2);
746 return inw(ioaddr + 12);
747}
748
749/* Read a word from the EEPROM when in the ISA ID probe state. */
ac4bed13 750static ushort id_read_eeprom(int index)
1da177e4
LT		 751{
752 int bit, word = 0;
753
754 /* Issue read command, and pause for at least 162 us. for it to complete.
755 Assume extra-fast 16Mhz bus. */
756 outb(EEPROM_READ + index, id_port);
757
758 /* Pause for at least 162 us. for the read to take place. */
759 /* Some chips seem to require much longer */
760 mdelay(4);
6aa20a22 761
1da177e4
LT		 762 for (bit = 15; bit >= 0; bit--)
763 word = (word << 1) + (inb(id_port) & 0x01);
764
765 if (el3_debug > 3)
646cdb32 766 pr_debug(" 3c509 EEPROM word %d %#4.4x.\n", index, word);
1da177e4
LT		 767
768 return word;
769}
770
771
772static int
773el3_open(struct net_device *dev)
774{
775 int ioaddr = dev->base_addr;
776 int i;
777
778 outw(TxReset, ioaddr + EL3_CMD);
779 outw(RxReset, ioaddr + EL3_CMD);
780 outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
781
a0607fd3 782 i = request_irq(dev->irq, el3_interrupt, 0, dev->name, dev);
1da177e4
LT		 783 if (i)
784 return i;
785
786 EL3WINDOW(0);
787 if (el3_debug > 3)
646cdb32 788 pr_debug("%s: Opening, IRQ %d status@%x %4.4x.\n", dev->name,
1da177e4
LT		 789 dev->irq, ioaddr + EL3_STATUS, inw(ioaddr + EL3_STATUS));
790
791 el3_up(dev);
792
793 if (el3_debug > 3)
646cdb32 794 pr_debug("%s: Opened 3c509 IRQ %d status %4.4x.\n",
1da177e4
LT		 795 dev->name, dev->irq, inw(ioaddr + EL3_STATUS));
796
797 return 0;
798}
799
800static void
801el3_tx_timeout (struct net_device *dev)
802{
1da177e4
LT		 803 int ioaddr = dev->base_addr;
804
805 /* Transmitter timeout, serious problems. */
646cdb32 806 pr_warning("%s: transmit timed out, Tx_status %2.2x status %4.4x Tx FIFO room %d.\n",
1da177e4
LT		 807 dev->name, inb(ioaddr + TX_STATUS), inw(ioaddr + EL3_STATUS),
808 inw(ioaddr + TX_FREE));
815f8802 809 dev->stats.tx_errors++;
1da177e4
LT		 810 dev->trans_start = jiffies;
811 /* Issue TX_RESET and TX_START commands. */
812 outw(TxReset, ioaddr + EL3_CMD);
813 outw(TxEnable, ioaddr + EL3_CMD);
814 netif_wake_queue(dev);
815}
816
817
27a1de95 818static netdev_tx_t
1da177e4
LT		 819el3_start_xmit(struct sk_buff *skb, struct net_device *dev)
820{
821 struct el3_private *lp = netdev_priv(dev);
822 int ioaddr = dev->base_addr;
823 unsigned long flags;
824
825 netif_stop_queue (dev);
826
815f8802 827 dev->stats.tx_bytes += skb->len;
6aa20a22 828
1da177e4 829 if (el3_debug > 4) {
646cdb32 830 pr_debug("%s: el3_start_xmit(length = %u) called, status %4.4x.\n",
1da177e4
LT		 831 dev->name, skb->len, inw(ioaddr + EL3_STATUS));
832 }
833#if 0
834#ifndef final_version
835 { /* Error-checking code, delete someday. */
836 ushort status = inw(ioaddr + EL3_STATUS);
8e95a202
JP		 837 if (status & 0x0001 && /* IRQ line active, missed one. */
838 inw(ioaddr + EL3_STATUS) & 1) { /* Make sure. */
646cdb32 839 pr_debug("%s: Missed interrupt, status then %04x now %04x"
1da177e4
LT		 840 " Tx %2.2x Rx %4.4x.\n", dev->name, status,
841 inw(ioaddr + EL3_STATUS), inb(ioaddr + TX_STATUS),
842 inw(ioaddr + RX_STATUS));
843 /* Fake interrupt trigger by masking, acknowledge interrupts. */
844 outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
845 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
846 ioaddr + EL3_CMD);
847 outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
848 }
849 }
850#endif
851#endif
852 /*
853 * We lock the driver against other processors. Note
854 * we don't need to lock versus the IRQ as we suspended
855 * that. This means that we lose the ability to take
856 * an RX during a TX upload. That sucks a bit with SMP
857 * on an original 3c509 (2K buffer)
858 *
859 * Using disable_irq stops us crapping on other
860 * time sensitive devices.
861 */
862
863 spin_lock_irqsave(&lp->lock, flags);
864
865 /* Put out the doubleword header... */
866 outw(skb->len, ioaddr + TX_FIFO);
867 outw(0x00, ioaddr + TX_FIFO);
868 /* ... and the packet rounded to a doubleword. */
1da177e4 869 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
1da177e4
LT		 870
871 dev->trans_start = jiffies;
872 if (inw(ioaddr + TX_FREE) > 1536)
873 netif_start_queue(dev);
874 else
875 /* Interrupt us when the FIFO has room for max-sized packet. */
876 outw(SetTxThreshold + 1536, ioaddr + EL3_CMD);
877
878 spin_unlock_irqrestore(&lp->lock, flags);
879
880 dev_kfree_skb (skb);
881
882 /* Clear the Tx status stack. */
883 {
884 short tx_status;
885 int i = 4;
886
887 while (--i > 0 && (tx_status = inb(ioaddr + TX_STATUS)) > 0) {
815f8802 888 if (tx_status & 0x38) dev->stats.tx_aborted_errors++;
1da177e4
LT		 889 if (tx_status & 0x30) outw(TxReset, ioaddr + EL3_CMD);
890 if (tx_status & 0x3C) outw(TxEnable, ioaddr + EL3_CMD);
891 outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
892 }
893 }
6ed10654 894 return NETDEV_TX_OK;
1da177e4
LT		 895}
896
897/* The EL3 interrupt handler. */
898static irqreturn_t
7d12e780 899el3_interrupt(int irq, void *dev_id)
1da177e4 900{
c31f28e7 901 struct net_device *dev = dev_id;
1da177e4
LT		 902 struct el3_private *lp;
903 int ioaddr, status;
904 int i = max_interrupt_work;
905
1da177e4
LT		 906 lp = netdev_priv(dev);
907 spin_lock(&lp->lock);
908
909 ioaddr = dev->base_addr;
910
911 if (el3_debug > 4) {
912 status = inw(ioaddr + EL3_STATUS);
646cdb32 913 pr_debug("%s: interrupt, status %4.4x.\n", dev->name, status);
1da177e4
LT		 914 }
915
916 while ((status = inw(ioaddr + EL3_STATUS)) &
917 (IntLatch | RxComplete | StatsFull)) {
918
919 if (status & RxComplete)
920 el3_rx(dev);
921
922 if (status & TxAvailable) {
923 if (el3_debug > 5)
646cdb32 924 pr_debug(" TX room bit was handled.\n");
1da177e4
LT		 925 /* There's room in the FIFO for a full-sized packet. */
926 outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
927 netif_wake_queue (dev);
928 }
929 if (status & (AdapterFailure | RxEarly | StatsFull | TxComplete)) {
930 /* Handle all uncommon interrupts. */
931 if (status & StatsFull) /* Empty statistics. */
932 update_stats(dev);
933 if (status & RxEarly) { /* Rx early is unused. */
934 el3_rx(dev);
935 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
936 }
937 if (status & TxComplete) { /* Really Tx error. */
1da177e4
LT		 938 short tx_status;
939 int i = 4;
940
941 while (--i>0 && (tx_status = inb(ioaddr + TX_STATUS)) > 0) {
815f8802 942 if (tx_status & 0x38) dev->stats.tx_aborted_errors++;
1da177e4
LT		 943 if (tx_status & 0x30) outw(TxReset, ioaddr + EL3_CMD);
944 if (tx_status & 0x3C) outw(TxEnable, ioaddr + EL3_CMD);
945 outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
946 }
947 }
948 if (status & AdapterFailure) {
949 /* Adapter failure requires Rx reset and reinit. */
950 outw(RxReset, ioaddr + EL3_CMD);
951 /* Set the Rx filter to the current state. */
952 outw(SetRxFilter | RxStation | RxBroadcast
953 | (dev->flags & IFF_ALLMULTI ? RxMulticast : 0)
954 | (dev->flags & IFF_PROMISC ? RxProm : 0),
955 ioaddr + EL3_CMD);
956 outw(RxEnable, ioaddr + EL3_CMD); /* Re-enable the receiver. */
957 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
958 }
959 }
960
961 if (--i < 0) {
646cdb32 962 pr_err("%s: Infinite loop in interrupt, status %4.4x.\n",
1da177e4
LT		 963 dev->name, status);
964 /* Clear all interrupts. */
965 outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
966 break;
967 }
968 /* Acknowledge the IRQ. */
969 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD); /* Ack IRQ */
970 }
971
972 if (el3_debug > 4) {
646cdb32 973 pr_debug("%s: exiting interrupt, status %4.4x.\n", dev->name,
1da177e4
LT		 974 inw(ioaddr + EL3_STATUS));
975 }
976 spin_unlock(&lp->lock);
977 return IRQ_HANDLED;
978}
979
980
981#ifdef CONFIG_NET_POLL_CONTROLLER
982/*
983 * Polling receive - used by netconsole and other diagnostic tools
984 * to allow network i/o with interrupts disabled.
985 */
986static void el3_poll_controller(struct net_device *dev)
987{
988 disable_irq(dev->irq);
7d12e780 989 el3_interrupt(dev->irq, dev);
1da177e4
LT		 990 enable_irq(dev->irq);
991}
992#endif
993
994static struct net_device_stats *
995el3_get_stats(struct net_device *dev)
996{
997 struct el3_private *lp = netdev_priv(dev);
998 unsigned long flags;
999
1000 /*
1001 * This is fast enough not to bother with disable IRQ
1002 * stuff.
1003 */
6aa20a22 1004
1da177e4
LT		 1005 spin_lock_irqsave(&lp->lock, flags);
1006 update_stats(dev);
1007 spin_unlock_irqrestore(&lp->lock, flags);
815f8802 1008 return &dev->stats;
1da177e4
LT		 1009}
1010
1011/* Update statistics. We change to register window 6, so this should be run
1012 single-threaded if the device is active. This is expected to be a rare
1013 operation, and it's simpler for the rest of the driver to assume that
1014 window 1 is always valid rather than use a special window-state variable.
1015 */
1016static void update_stats(struct net_device *dev)
1017{
1da177e4
LT		 1018 int ioaddr = dev->base_addr;
1019
1020 if (el3_debug > 5)
646cdb32 1021 pr_debug(" Updating the statistics.\n");
1da177e4
LT		 1022 /* Turn off statistics updates while reading. */
1023 outw(StatsDisable, ioaddr + EL3_CMD);
1024 /* Switch to the stats window, and read everything. */
1025 EL3WINDOW(6);
815f8802
PZ		 1026 dev->stats.tx_carrier_errors += inb(ioaddr + 0);
1027 dev->stats.tx_heartbeat_errors += inb(ioaddr + 1);
1da177e4 1028 /* Multiple collisions. */ inb(ioaddr + 2);
815f8802
PZ		 1029 dev->stats.collisions += inb(ioaddr + 3);
1030 dev->stats.tx_window_errors += inb(ioaddr + 4);
1031 dev->stats.rx_fifo_errors += inb(ioaddr + 5);
1032 dev->stats.tx_packets += inb(ioaddr + 6);
1da177e4
LT		 1033 /* Rx packets */ inb(ioaddr + 7);
1034 /* Tx deferrals */ inb(ioaddr + 8);
1035 inw(ioaddr + 10); /* Total Rx and Tx octets. */
1036 inw(ioaddr + 12);
1037
1038 /* Back to window 1, and turn statistics back on. */
1039 EL3WINDOW(1);
1040 outw(StatsEnable, ioaddr + EL3_CMD);
1041 return;
1042}
1043
1044static int
1045el3_rx(struct net_device *dev)
1046{
1da177e4
LT		 1047 int ioaddr = dev->base_addr;
1048 short rx_status;
1049
1050 if (el3_debug > 5)
646cdb32 1051 pr_debug(" In rx_packet(), status %4.4x, rx_status %4.4x.\n",
1da177e4
LT		 1052 inw(ioaddr+EL3_STATUS), inw(ioaddr+RX_STATUS));
1053 while ((rx_status = inw(ioaddr + RX_STATUS)) > 0) {
1054 if (rx_status & 0x4000) { /* Error, update stats. */
1055 short error = rx_status & 0x3800;
1056
1057 outw(RxDiscard, ioaddr + EL3_CMD);
815f8802 1058 dev->stats.rx_errors++;
1da177e4 1059 switch (error) {
815f8802
PZ		 1060 case 0x0000: dev->stats.rx_over_errors++; break;
1061 case 0x0800: dev->stats.rx_length_errors++; break;
1062 case 0x1000: dev->stats.rx_frame_errors++; break;
1063 case 0x1800: dev->stats.rx_length_errors++; break;
1064 case 0x2000: dev->stats.rx_frame_errors++; break;
1065 case 0x2800: dev->stats.rx_crc_errors++; break;
1da177e4
LT		 1066 }
1067 } else {
1068 short pkt_len = rx_status & 0x7ff;
1069 struct sk_buff *skb;
1070
1071 skb = dev_alloc_skb(pkt_len+5);
1da177e4 1072 if (el3_debug > 4)
646cdb32 1073 pr_debug("Receiving packet size %d status %4.4x.\n",
1da177e4
LT		 1074 pkt_len, rx_status);
1075 if (skb != NULL) {
1da177e4
LT		 1076 skb_reserve(skb, 2); /* Align IP on 16 byte */
1077
1078 /* 'skb->data' points to the start of sk_buff data area. */
1da177e4
LT		 1079 insl(ioaddr + RX_FIFO, skb_put(skb,pkt_len),
1080 (pkt_len + 3) >> 2);
1da177e4
LT		 1081
1082 outw(RxDiscard, ioaddr + EL3_CMD); /* Pop top Rx packet. */
1083 skb->protocol = eth_type_trans(skb,dev);
1084 netif_rx(skb);
f7f312a0 1085 dev->stats.rx_bytes += pkt_len;
815f8802 1086 dev->stats.rx_packets++;
1da177e4
LT		 1087 continue;
1088 }
1089 outw(RxDiscard, ioaddr + EL3_CMD);
815f8802 1090 dev->stats.rx_dropped++;
1da177e4 1091 if (el3_debug)
646cdb32 1092 pr_debug("%s: Couldn't allocate a sk_buff of size %d.\n",
1da177e4
LT		 1093 dev->name, pkt_len);
1094 }
1095 inw(ioaddr + EL3_STATUS); /* Delay. */
1096 while (inw(ioaddr + EL3_STATUS) & 0x1000)
646cdb32 1097 pr_debug(" Waiting for 3c509 to discard packet, status %x.\n",
1da177e4
LT		 1098 inw(ioaddr + EL3_STATUS) );
1099 }
1100
1101 return 0;
1102}
1103
1104/*
1105 * Set or clear the multicast filter for this adaptor.
1106 */
1107static void
1108set_multicast_list(struct net_device *dev)
1109{
1110 unsigned long flags;
1111 struct el3_private *lp = netdev_priv(dev);
1112 int ioaddr = dev->base_addr;
4cd24eaf 1113 int mc_count = netdev_mc_count(dev);
1da177e4
LT		 1114
1115 if (el3_debug > 1) {
1116 static int old;
4cd24eaf
JP		 1117 if (old != mc_count) {
1118 old = mc_count;
1119 pr_debug("%s: Setting Rx mode to %d addresses.\n",
1120 dev->name, mc_count);
1da177e4
LT		 1121 }
1122 }
1123 spin_lock_irqsave(&lp->lock, flags);
1124 if (dev->flags&IFF_PROMISC) {
1125 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm,
1126 ioaddr + EL3_CMD);
1127 }
4cd24eaf 1128 else if (mc_count || (dev->flags&IFF_ALLMULTI)) {
1da177e4
LT		 1129 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast, ioaddr + EL3_CMD);
1130 }
1131 else
1132 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1133 spin_unlock_irqrestore(&lp->lock, flags);
1134}
1135
1136static int
1137el3_close(struct net_device *dev)
1138{
1139 int ioaddr = dev->base_addr;
1140 struct el3_private *lp = netdev_priv(dev);
6aa20a22 1141
1da177e4 1142 if (el3_debug > 2)
646cdb32 1143 pr_debug("%s: Shutting down ethercard.\n", dev->name);
1da177e4
LT		 1144
1145 el3_down(dev);
1146
1147 free_irq(dev->irq, dev);
1148 /* Switching back to window 0 disables the IRQ. */
1149 EL3WINDOW(0);
1150 if (lp->type != EL3_EISA) {
1151 /* But we explicitly zero the IRQ line select anyway. Don't do
1152 * it on EISA cards, it prevents the module from getting an
1153 * IRQ after unload+reload... */
1154 outw(0x0f00, ioaddr + WN0_IRQ);
1155 }
1156
1157 return 0;
1158}
1159
6aa20a22 1160static int
1da177e4
LT		 1161el3_link_ok(struct net_device *dev)
1162{
1163 int ioaddr = dev->base_addr;
1164 u16 tmp;
1165
1166 EL3WINDOW(4);
1167 tmp = inw(ioaddr + WN4_MEDIA);
1168 EL3WINDOW(1);
1169 return tmp & (1<<11);
1170}
1171
1172static int
1173el3_netdev_get_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
1174{
1175 u16 tmp;
1176 int ioaddr = dev->base_addr;
6aa20a22 1177
1da177e4 1178 EL3WINDOW(0);
6aa20a22 1179 /* obtain current transceiver via WN4_MEDIA? */
1da177e4
LT		 1180 tmp = inw(ioaddr + WN0_ADDR_CONF);
1181 ecmd->transceiver = XCVR_INTERNAL;
1182 switch (tmp >> 14) {
1183 case 0:
1184 ecmd->port = PORT_TP;
1185 break;
1186 case 1:
1187 ecmd->port = PORT_AUI;
1188 ecmd->transceiver = XCVR_EXTERNAL;
1189 break;
1190 case 3:
1191 ecmd->port = PORT_BNC;
1192 default:
1193 break;
1194 }
1195
1196 ecmd->duplex = DUPLEX_HALF;
1197 ecmd->supported = 0;
1198 tmp = inw(ioaddr + WN0_CONF_CTRL);
1199 if (tmp & (1<<13))
1200 ecmd->supported |= SUPPORTED_AUI;
1201 if (tmp & (1<<12))
1202 ecmd->supported |= SUPPORTED_BNC;
1203 if (tmp & (1<<9)) {
1204 ecmd->supported |= SUPPORTED_TP | SUPPORTED_10baseT_Half |
1205 SUPPORTED_10baseT_Full; /* hmm... */
1206 EL3WINDOW(4);
1207 tmp = inw(ioaddr + WN4_NETDIAG);
1208 if (tmp & FD_ENABLE)
1209 ecmd->duplex = DUPLEX_FULL;
1210 }
1211
1212 ecmd->speed = SPEED_10;
1213 EL3WINDOW(1);
1214 return 0;
1215}
1216
1217static int
1218el3_netdev_set_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
1219{
1220 u16 tmp;
1221 int ioaddr = dev->base_addr;
1222
1223 if (ecmd->speed != SPEED_10)
1224 return -EINVAL;
1225 if ((ecmd->duplex != DUPLEX_HALF) && (ecmd->duplex != DUPLEX_FULL))
1226 return -EINVAL;
1227 if ((ecmd->transceiver != XCVR_INTERNAL) && (ecmd->transceiver != XCVR_EXTERNAL))
1228 return -EINVAL;
1229
1230 /* change XCVR type */
1231 EL3WINDOW(0);
1232 tmp = inw(ioaddr + WN0_ADDR_CONF);
1233 switch (ecmd->port) {
1234 case PORT_TP:
1235 tmp &= ~(3<<14);
1236 dev->if_port = 0;
1237 break;
1238 case PORT_AUI:
1239 tmp |= (1<<14);
1240 dev->if_port = 1;
1241 break;
1242 case PORT_BNC:
1243 tmp |= (3<<14);
1244 dev->if_port = 3;
1245 break;
1246 default:
1247 return -EINVAL;
1248 }
1249
1250 outw(tmp, ioaddr + WN0_ADDR_CONF);
1251 if (dev->if_port == 3) {
1252 /* fire up the DC-DC convertor if BNC gets enabled */
1253 tmp = inw(ioaddr + WN0_ADDR_CONF);
1254 if (tmp & (3 << 14)) {
1255 outw(StartCoax, ioaddr + EL3_CMD);
1256 udelay(800);
1257 } else
1258 return -EIO;
1259 }
1260
1261 EL3WINDOW(4);
1262 tmp = inw(ioaddr + WN4_NETDIAG);
1263 if (ecmd->duplex == DUPLEX_FULL)
1264 tmp |= FD_ENABLE;
1265 else
1266 tmp &= ~FD_ENABLE;
1267 outw(tmp, ioaddr + WN4_NETDIAG);
1268 EL3WINDOW(1);
1269
1270 return 0;
1271}
1272
1273static void el3_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1274{
1275 strcpy(info->driver, DRV_NAME);
1276 strcpy(info->version, DRV_VERSION);
1277}
1278
1279static int el3_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1280{
1281 struct el3_private *lp = netdev_priv(dev);
1282 int ret;
1283
1284 spin_lock_irq(&lp->lock);
1285 ret = el3_netdev_get_ecmd(dev, ecmd);
1286 spin_unlock_irq(&lp->lock);
1287 return ret;
1288}
1289
1290static int el3_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1291{
1292 struct el3_private *lp = netdev_priv(dev);
1293 int ret;
1294
1295 spin_lock_irq(&lp->lock);
1296 ret = el3_netdev_set_ecmd(dev, ecmd);
1297 spin_unlock_irq(&lp->lock);
1298 return ret;
1299}
1300
1301static u32 el3_get_link(struct net_device *dev)
1302{
1303 struct el3_private *lp = netdev_priv(dev);
1304 u32 ret;
1305
1306 spin_lock_irq(&lp->lock);
1307 ret = el3_link_ok(dev);
1308 spin_unlock_irq(&lp->lock);
1309 return ret;
1310}
1311
1312static u32 el3_get_msglevel(struct net_device *dev)
1313{
1314 return el3_debug;
1315}
1316
1317static void el3_set_msglevel(struct net_device *dev, u32 v)
1318{
1319 el3_debug = v;
1320}
1321
7282d491 1322static const struct ethtool_ops ethtool_ops = {
1da177e4
LT		 1323 .get_drvinfo = el3_get_drvinfo,
1324 .get_settings = el3_get_settings,
1325 .set_settings = el3_set_settings,
1326 .get_link = el3_get_link,
1327 .get_msglevel = el3_get_msglevel,
1328 .set_msglevel = el3_set_msglevel,
1329};
1330
1331static void
1332el3_down(struct net_device *dev)
1333{
1334 int ioaddr = dev->base_addr;
1335
1336 netif_stop_queue(dev);
1337
1338 /* Turn off statistics ASAP. We update lp->stats below. */
1339 outw(StatsDisable, ioaddr + EL3_CMD);
1340
1341 /* Disable the receiver and transmitter. */
1342 outw(RxDisable, ioaddr + EL3_CMD);
1343 outw(TxDisable, ioaddr + EL3_CMD);
1344
1345 if (dev->if_port == 3)
1346 /* Turn off thinnet power. Green! */
1347 outw(StopCoax, ioaddr + EL3_CMD);
1348 else if (dev->if_port == 0) {
1349 /* Disable link beat and jabber, if_port may change here next open(). */
1350 EL3WINDOW(4);
1351 outw(inw(ioaddr + WN4_MEDIA) & ~MEDIA_TP, ioaddr + WN4_MEDIA);
1352 }
1353
1354 outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1355
1356 update_stats(dev);
1357}
1358
1359static void
1360el3_up(struct net_device *dev)
1361{
1362 int i, sw_info, net_diag;
1363 int ioaddr = dev->base_addr;
6aa20a22 1364
1da177e4
LT		 1365 /* Activating the board required and does no harm otherwise */
1366 outw(0x0001, ioaddr + 4);
1367
1368 /* Set the IRQ line. */
1369 outw((dev->irq << 12) | 0x0f00, ioaddr + WN0_IRQ);
1370
1371 /* Set the station address in window 2 each time opened. */
1372 EL3WINDOW(2);
1373
1374 for (i = 0; i < 6; i++)
1375 outb(dev->dev_addr[i], ioaddr + i);
1376
1377 if ((dev->if_port & 0x03) == 3) /* BNC interface */
1378 /* Start the thinnet transceiver. We should really wait 50ms...*/
1379 outw(StartCoax, ioaddr + EL3_CMD);
1380 else if ((dev->if_port & 0x03) == 0) { /* 10baseT interface */
1381 /* Combine secondary sw_info word (the adapter level) and primary
1382 sw_info word (duplex setting plus other useless bits) */
1383 EL3WINDOW(0);
6aa20a22 1384 sw_info = (read_eeprom(ioaddr, 0x14) & 0x400f) |
1da177e4
LT		 1385 (read_eeprom(ioaddr, 0x0d) & 0xBff0);
1386
1387 EL3WINDOW(4);
1388 net_diag = inw(ioaddr + WN4_NETDIAG);
1389 net_diag = (net_diag | FD_ENABLE); /* temporarily assume full-duplex will be set */
646cdb32 1390 pr_info("%s: ", dev->name);
1da177e4
LT		 1391 switch (dev->if_port & 0x0c) {
1392 case 12:
1393 /* force full-duplex mode if 3c5x9b */
1394 if (sw_info & 0x000f) {
646cdb32 1395 pr_cont("Forcing 3c5x9b full-duplex mode");
1da177e4
LT		 1396 break;
1397 }
1398 case 8:
1399 /* set full-duplex mode based on eeprom config setting */
1400 if ((sw_info & 0x000f) && (sw_info & 0x8000)) {
646cdb32 1401 pr_cont("Setting 3c5x9b full-duplex mode (from EEPROM configuration bit)");
1da177e4
LT		 1402 break;
1403 }
1404 default:
1405 /* xcvr=(0 || 4) OR user has an old 3c5x9 non "B" model */
646cdb32 1406 pr_cont("Setting 3c5x9/3c5x9B half-duplex mode");
1da177e4
LT		 1407 net_diag = (net_diag & ~FD_ENABLE); /* disable full duplex */
1408 }
1409
1410 outw(net_diag, ioaddr + WN4_NETDIAG);
646cdb32 1411 pr_cont(" if_port: %d, sw_info: %4.4x\n", dev->if_port, sw_info);
1da177e4 1412 if (el3_debug > 3)
646cdb32 1413 pr_debug("%s: 3c5x9 net diag word is now: %4.4x.\n", dev->name, net_diag);
1da177e4
LT		 1414 /* Enable link beat and jabber check. */
1415 outw(inw(ioaddr + WN4_MEDIA) | MEDIA_TP, ioaddr + WN4_MEDIA);
1416 }
1417
1418 /* Switch to the stats window, and clear all stats by reading. */
1419 outw(StatsDisable, ioaddr + EL3_CMD);
1420 EL3WINDOW(6);
1421 for (i = 0; i < 9; i++)
1422 inb(ioaddr + i);
1423 inw(ioaddr + 10);
1424 inw(ioaddr + 12);
1425
1426 /* Switch to register set 1 for normal use. */
1427 EL3WINDOW(1);
1428
1429 /* Accept b-case and phys addr only. */
1430 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1431 outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
1432
1433 outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
1434 outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
1435 /* Allow status bits to be seen. */
1436 outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
1437 /* Ack all pending events, and set active indicator mask. */
1438 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
1439 ioaddr + EL3_CMD);
1440 outw(SetIntrEnb | IntLatch|TxAvailable|TxComplete|RxComplete|StatsFull,
1441 ioaddr + EL3_CMD);
1442
1443 netif_start_queue(dev);
1444}
1445
1446/* Power Management support functions */
ac4bed13 1447#ifdef CONFIG_PM
1da177e4
LT		 1448
1449static int
60a89ff6 1450el3_suspend(struct device *pdev, pm_message_t state)
1da177e4
LT		 1451{
1452 unsigned long flags;
1453 struct net_device *dev;
1454 struct el3_private *lp;
1455 int ioaddr;
6aa20a22 1456
1aec5bdf 1457 dev = dev_get_drvdata(pdev);
1da177e4
LT		 1458 lp = netdev_priv(dev);
1459 ioaddr = dev->base_addr;
1460
1461 spin_lock_irqsave(&lp->lock, flags);
1462
1463 if (netif_running(dev))
1464 netif_device_detach(dev);
1465
1466 el3_down(dev);
1467 outw(PowerDown, ioaddr + EL3_CMD);
1468
1469 spin_unlock_irqrestore(&lp->lock, flags);
1470 return 0;
1471}
1472
1473static int
60a89ff6 1474el3_resume(struct device *pdev)
1da177e4
LT		 1475{
1476 unsigned long flags;
1477 struct net_device *dev;
1478 struct el3_private *lp;
1479 int ioaddr;
6aa20a22 1480
1aec5bdf 1481 dev = dev_get_drvdata(pdev);
1da177e4
LT		 1482 lp = netdev_priv(dev);
1483 ioaddr = dev->base_addr;
1484
1485 spin_lock_irqsave(&lp->lock, flags);
1486
1487 outw(PowerUp, ioaddr + EL3_CMD);
152abd13 1488 EL3WINDOW(0);
1da177e4
LT		 1489 el3_up(dev);
1490
1491 if (netif_running(dev))
1492 netif_device_attach(dev);
6aa20a22 1493
1da177e4
LT		 1494 spin_unlock_irqrestore(&lp->lock, flags);
1495 return 0;
1496}
1497
ac4bed13 1498#endif /* CONFIG_PM */
1da177e4
LT		 1499
1500module_param(debug,int, 0);
1501module_param_array(irq, int, NULL, 0);
1da177e4
LT		 1502module_param(max_interrupt_work, int, 0);
1503MODULE_PARM_DESC(debug, "debug level (0-6)");
1504MODULE_PARM_DESC(irq, "IRQ number(s) (assigned)");
1da177e4 1505MODULE_PARM_DESC(max_interrupt_work, "maximum events handled per interrupt");
ac4bed13 1506#ifdef CONFIG_PNP
1da177e4
LT		 1507module_param(nopnp, int, 0);
1508MODULE_PARM_DESC(nopnp, "disable ISA PnP support (0-1)");
ac4bed13
OZ		 1509#endif /* CONFIG_PNP */
1510MODULE_DESCRIPTION("3Com Etherlink III (3c509, 3c509B, 3c529, 3c579) ethernet driver");
1da177e4
LT		 1511MODULE_LICENSE("GPL");
1512
1513static int __init el3_init_module(void)
1514{
0992a5d0 1515 int ret = 0;
1da177e4
LT		 1516
1517 if (debug >= 0)
1518 el3_debug = debug;
1519
ac4bed13
OZ		 1520#ifdef CONFIG_PNP
1521 if (!nopnp) {
1522 ret = pnp_register_driver(&el3_pnp_driver);
1523 if (!ret)
1524 pnp_registered = 1;
1525 }
1526#endif
1527 /* Select an open I/O location at 0x1*0 to do ISA contention select. */
1528 /* Start with 0x110 to avoid some sound cards.*/
1529 for (id_port = 0x110 ; id_port < 0x200; id_port += 0x10) {
1530 if (!request_region(id_port, 1, "3c509-control"))
1531 continue;
1532 outb(0x00, id_port);
1533 outb(0xff, id_port);
1534 if (inb(id_port) & 0x01)
1535 break;
1536 else
1537 release_region(id_port, 1);
1538 }
1539 if (id_port >= 0x200) {
1540 id_port = 0;
646cdb32 1541 pr_err("No I/O port available for 3c509 activation.\n");
ac4bed13
OZ		 1542 } else {
1543 ret = isa_register_driver(&el3_isa_driver, EL3_MAX_CARDS);
1544 if (!ret)
1545 isa_registered = 1;
1da177e4 1546 }
1da177e4 1547#ifdef CONFIG_EISA
0992a5d0 1548 ret = eisa_driver_register(&el3_eisa_driver);
ac4bed13
OZ		 1549 if (!ret)
1550 eisa_registered = 1;
1da177e4
LT		 1551#endif
1552#ifdef CONFIG_MCA
ac4bed13
OZ		 1553 ret = mca_register_driver(&el3_mca_driver);
1554 if (!ret)
1555 mca_registered = 1;
1556#endif
1557
1558#ifdef CONFIG_PNP
1559 if (pnp_registered)
1560 ret = 0;
1561#endif
1562 if (isa_registered)
1563 ret = 0;
1564#ifdef CONFIG_EISA
1565 if (eisa_registered)
1566 ret = 0;
1567#endif
1568#ifdef CONFIG_MCA
1569 if (mca_registered)
1570 ret = 0;
1da177e4 1571#endif
0992a5d0 1572 return ret;
1da177e4
LT		 1573}
1574
1575static void __exit el3_cleanup_module(void)
1576{
ac4bed13
OZ		 1577#ifdef CONFIG_PNP
1578 if (pnp_registered)
1579 pnp_unregister_driver(&el3_pnp_driver);
1580#endif
1581 if (isa_registered)
1582 isa_unregister_driver(&el3_isa_driver);
1583 if (id_port)
1584 release_region(id_port, 1);
1da177e4 1585#ifdef CONFIG_EISA
ac4bed13
OZ		 1586 if (eisa_registered)
1587 eisa_driver_unregister(&el3_eisa_driver);
1da177e4
LT		 1588#endif
1589#ifdef CONFIG_MCA
ac4bed13
OZ		 1590 if (mca_registered)
1591 mca_unregister_driver(&el3_mca_driver);
1da177e4
LT		 1592#endif
1593}
1594
1595module_init (el3_init_module);
1596module_exit (el3_cleanup_module);
kernel source for telekom puls (alcatel/mediatek)