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