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