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