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