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