Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* ne2.c: A NE/2 Ethernet Driver for Linux. */ |
2 | /* | |
3 | Based on the NE2000 driver written by Donald Becker (1992-94). | |
4 | modified by Wim Dumon (Apr 1996) | |
5 | ||
6 | This software may be used and distributed according to the terms | |
7 | of the GNU General Public License, incorporated herein by reference. | |
8 | ||
9 | The author may be reached as wimpie@linux.cc.kuleuven.ac.be | |
10 | ||
11 | Currently supported: NE/2 | |
12 | This patch was never tested on other MCA-ethernet adapters, but it | |
13 | might work. Just give it a try and let me know if you have problems. | |
14 | Also mail me if it really works, please! | |
15 | ||
16 | Changelog: | |
17 | Mon Feb 3 16:26:02 MET 1997 | |
18 | - adapted the driver to work with the 2.1.25 kernel | |
19 | - multiple ne2 support (untested) | |
20 | - module support (untested) | |
21 | ||
22 | Fri Aug 28 00:18:36 CET 1998 (David Weinehall) | |
23 | - fixed a few minor typos | |
24 | - made the MODULE_PARM conditional (it only works with the v2.1.x kernels) | |
25 | - fixed the module support (Now it's working...) | |
26 | ||
27 | Mon Sep 7 19:01:44 CET 1998 (David Weinehall) | |
28 | - added support for Arco Electronics AE/2-card (experimental) | |
29 | ||
30 | Mon Sep 14 09:53:42 CET 1998 (David Weinehall) | |
31 | - added support for Compex ENET-16MC/P (experimental) | |
32 | ||
33 | Tue Sep 15 16:21:12 CET 1998 (David Weinehall, Magnus Jonsson, Tomas Ogren) | |
34 | - Miscellaneous bugfixes | |
35 | ||
36 | Tue Sep 19 16:21:12 CET 1998 (Magnus Jonsson) | |
37 | - Cleanup | |
38 | ||
39 | Wed Sep 23 14:33:34 CET 1998 (David Weinehall) | |
40 | - Restructuring and rewriting for v2.1.x compliance | |
41 | ||
42 | Wed Oct 14 17:19:21 CET 1998 (David Weinehall) | |
43 | - Added code that unregisters irq and proc-info | |
44 | - Version# bump | |
45 | ||
46 | Mon Nov 16 15:28:23 CET 1998 (Wim Dumon) | |
47 | - pass 'dev' as last parameter of request_irq in stead of 'NULL' | |
48 | ||
49 | Wed Feb 7 21:24:00 CET 2001 (Alfred Arnold) | |
50 | - added support for the D-Link DE-320CT | |
51 | ||
52 | * WARNING | |
53 | ------- | |
54 | This is alpha-test software. It is not guaranteed to work. As a | |
55 | matter of fact, I'm quite sure there are *LOTS* of bugs in here. I | |
56 | would like to hear from you if you use this driver, even if it works. | |
57 | If it doesn't work, be sure to send me a mail with the problems ! | |
58 | */ | |
59 | ||
60 | static const char *version = "ne2.c:v0.91 Nov 16 1998 Wim Dumon <wimpie@kotnet.org>\n"; | |
61 | ||
62 | #include <linux/module.h> | |
63 | #include <linux/kernel.h> | |
64 | #include <linux/types.h> | |
65 | #include <linux/fcntl.h> | |
66 | #include <linux/interrupt.h> | |
67 | #include <linux/ioport.h> | |
68 | #include <linux/in.h> | |
69 | #include <linux/slab.h> | |
70 | #include <linux/string.h> | |
71 | #include <linux/errno.h> | |
72 | #include <linux/init.h> | |
73 | #include <linux/mca-legacy.h> | |
74 | #include <linux/netdevice.h> | |
75 | #include <linux/etherdevice.h> | |
76 | #include <linux/skbuff.h> | |
77 | #include <linux/bitops.h> | |
ff5688ae | 78 | #include <linux/jiffies.h> |
1da177e4 LT |
79 | |
80 | #include <asm/system.h> | |
81 | #include <asm/io.h> | |
82 | #include <asm/dma.h> | |
83 | ||
84 | #include "8390.h" | |
85 | ||
86 | #define DRV_NAME "ne2" | |
87 | ||
88 | /* Some defines that people can play with if so inclined. */ | |
89 | ||
90 | /* Do we perform extra sanity checks on stuff ? */ | |
91 | /* #define NE_SANITY_CHECK */ | |
92 | ||
93 | /* Do we implement the read before write bugfix ? */ | |
94 | /* #define NE_RW_BUGFIX */ | |
95 | ||
96 | /* Do we have a non std. amount of memory? (in units of 256 byte pages) */ | |
97 | /* #define PACKETBUF_MEMSIZE 0x40 */ | |
98 | ||
99 | ||
100 | /* ---- No user-serviceable parts below ---- */ | |
101 | ||
102 | #define NE_BASE (dev->base_addr) | |
103 | #define NE_CMD 0x00 | |
104 | #define NE_DATAPORT 0x10 /* NatSemi-defined port window offset. */ | |
105 | #define NE_RESET 0x20 /* Issue a read to reset, a write to clear. */ | |
106 | #define NE_IO_EXTENT 0x30 | |
107 | ||
108 | #define NE1SM_START_PG 0x20 /* First page of TX buffer */ | |
109 | #define NE1SM_STOP_PG 0x40 /* Last page +1 of RX ring */ | |
110 | #define NESM_START_PG 0x40 /* First page of TX buffer */ | |
111 | #define NESM_STOP_PG 0x80 /* Last page +1 of RX ring */ | |
112 | ||
113 | /* From the .ADF file: */ | |
114 | static unsigned int addresses[7] __initdata = | |
115 | {0x1000, 0x2020, 0x8020, 0xa0a0, 0xb0b0, 0xc0c0, 0xc3d0}; | |
116 | static int irqs[4] __initdata = {3, 4, 5, 9}; | |
117 | ||
118 | /* From the D-Link ADF file: */ | |
119 | static unsigned int dlink_addresses[4] __initdata = | |
120 | {0x300, 0x320, 0x340, 0x360}; | |
121 | static int dlink_irqs[8] __initdata = {3, 4, 5, 9, 10, 11, 14, 15}; | |
122 | ||
123 | struct ne2_adapters_t { | |
124 | unsigned int id; | |
125 | char *name; | |
126 | }; | |
127 | ||
128 | static struct ne2_adapters_t ne2_adapters[] __initdata = { | |
129 | { 0x6354, "Arco Ethernet Adapter AE/2" }, | |
130 | { 0x70DE, "Compex ENET-16 MC/P" }, | |
131 | { 0x7154, "Novell Ethernet Adapter NE/2" }, | |
132 | { 0x56ea, "D-Link DE-320CT" }, | |
133 | { 0x0000, NULL } | |
134 | }; | |
135 | ||
136 | extern int netcard_probe(struct net_device *dev); | |
137 | ||
138 | static int ne2_probe1(struct net_device *dev, int slot); | |
139 | ||
140 | static int ne_open(struct net_device *dev); | |
141 | static int ne_close(struct net_device *dev); | |
142 | ||
143 | static void ne_reset_8390(struct net_device *dev); | |
144 | static void ne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, | |
145 | int ring_page); | |
146 | static void ne_block_input(struct net_device *dev, int count, | |
147 | struct sk_buff *skb, int ring_offset); | |
148 | static void ne_block_output(struct net_device *dev, const int count, | |
149 | const unsigned char *buf, const int start_page); | |
150 | ||
151 | ||
152 | /* | |
153 | * special code to read the DE-320's MAC address EEPROM. In contrast to a | |
154 | * standard NE design, this is a serial EEPROM (93C46) that has to be read | |
155 | * bit by bit. The EEPROM cotrol port at base + 0x1e has the following | |
156 | * layout: | |
157 | * | |
158 | * Bit 0 = Data out (read from EEPROM) | |
159 | * Bit 1 = Data in (write to EEPROM) | |
160 | * Bit 2 = Clock | |
161 | * Bit 3 = Chip Select | |
162 | * Bit 7 = ~50 kHz clock for defined delays | |
163 | * | |
164 | */ | |
165 | ||
166 | static void __init dlink_put_eeprom(unsigned char value, unsigned int addr) | |
167 | { | |
168 | int z; | |
169 | unsigned char v1, v2; | |
170 | ||
171 | /* write the value to the NIC EEPROM register */ | |
172 | ||
173 | outb(value, addr + 0x1e); | |
174 | ||
175 | /* now wait the clock line to toggle twice. Effectively, we are | |
176 | waiting (at least) for one clock cycle */ | |
177 | ||
178 | for (z = 0; z < 2; z++) { | |
179 | do { | |
180 | v1 = inb(addr + 0x1e); | |
181 | v2 = inb(addr + 0x1e); | |
182 | } | |
183 | while (!((v1 ^ v2) & 0x80)); | |
184 | } | |
185 | } | |
186 | ||
187 | static void __init dlink_send_eeprom_bit(unsigned int bit, unsigned int addr) | |
188 | { | |
189 | /* shift data bit into correct position */ | |
190 | ||
191 | bit = bit << 1; | |
192 | ||
193 | /* write value, keep clock line high for two cycles */ | |
194 | ||
195 | dlink_put_eeprom(0x09 | bit, addr); | |
196 | dlink_put_eeprom(0x0d | bit, addr); | |
197 | dlink_put_eeprom(0x0d | bit, addr); | |
198 | dlink_put_eeprom(0x09 | bit, addr); | |
199 | } | |
200 | ||
201 | static void __init dlink_send_eeprom_word(unsigned int value, unsigned int len, unsigned int addr) | |
202 | { | |
203 | int z; | |
204 | ||
205 | /* adjust bits so that they are left-aligned in a 16-bit-word */ | |
206 | ||
207 | value = value << (16 - len); | |
208 | ||
209 | /* shift bits out to the EEPROM */ | |
210 | ||
211 | for (z = 0; z < len; z++) { | |
212 | dlink_send_eeprom_bit((value & 0x8000) >> 15, addr); | |
213 | value = value << 1; | |
214 | } | |
215 | } | |
216 | ||
217 | static unsigned int __init dlink_get_eeprom(unsigned int eeaddr, unsigned int addr) | |
218 | { | |
219 | int z; | |
220 | unsigned int value = 0; | |
221 | ||
222 | /* pull the CS line low for a moment. This resets the EEPROM- | |
223 | internal logic, and makes it ready for a new command. */ | |
224 | ||
225 | dlink_put_eeprom(0x01, addr); | |
226 | dlink_put_eeprom(0x09, addr); | |
227 | ||
228 | /* send one start bit, read command (1 - 0), plus the address to | |
229 | the EEPROM */ | |
230 | ||
231 | dlink_send_eeprom_word(0x0180 | (eeaddr & 0x3f), 9, addr); | |
232 | ||
233 | /* get the data word. We clock by sending 0s to the EEPROM, which | |
234 | get ignored during the read process */ | |
235 | ||
236 | for (z = 0; z < 16; z++) { | |
237 | dlink_send_eeprom_bit(0, addr); | |
238 | value = (value << 1) | (inb(addr + 0x1e) & 0x01); | |
239 | } | |
240 | ||
241 | return value; | |
242 | } | |
243 | ||
244 | /* | |
245 | * Note that at boot, this probe only picks up one card at a time. | |
246 | */ | |
247 | ||
248 | static int __init do_ne2_probe(struct net_device *dev) | |
249 | { | |
250 | static int current_mca_slot = -1; | |
251 | int i; | |
252 | int adapter_found = 0; | |
253 | ||
254 | SET_MODULE_OWNER(dev); | |
255 | ||
256 | /* Do not check any supplied i/o locations. | |
257 | POS registers usually don't fail :) */ | |
258 | ||
259 | /* MCA cards have POS registers. | |
260 | Autodetecting MCA cards is extremely simple. | |
261 | Just search for the card. */ | |
262 | ||
263 | for(i = 0; (ne2_adapters[i].name != NULL) && !adapter_found; i++) { | |
264 | current_mca_slot = | |
265 | mca_find_unused_adapter(ne2_adapters[i].id, 0); | |
266 | ||
267 | if((current_mca_slot != MCA_NOTFOUND) && !adapter_found) { | |
268 | int res; | |
269 | mca_set_adapter_name(current_mca_slot, | |
270 | ne2_adapters[i].name); | |
271 | mca_mark_as_used(current_mca_slot); | |
272 | ||
273 | res = ne2_probe1(dev, current_mca_slot); | |
274 | if (res) | |
275 | mca_mark_as_unused(current_mca_slot); | |
276 | return res; | |
277 | } | |
278 | } | |
279 | return -ENODEV; | |
280 | } | |
281 | ||
1da177e4 LT |
282 | #ifndef MODULE |
283 | struct net_device * __init ne2_probe(int unit) | |
284 | { | |
285 | struct net_device *dev = alloc_ei_netdev(); | |
286 | int err; | |
287 | ||
288 | if (!dev) | |
289 | return ERR_PTR(-ENOMEM); | |
290 | ||
291 | sprintf(dev->name, "eth%d", unit); | |
292 | netdev_boot_setup_check(dev); | |
293 | ||
294 | err = do_ne2_probe(dev); | |
295 | if (err) | |
296 | goto out; | |
1da177e4 | 297 | return dev; |
1da177e4 LT |
298 | out: |
299 | free_netdev(dev); | |
300 | return ERR_PTR(err); | |
301 | } | |
302 | #endif | |
303 | ||
304 | static int ne2_procinfo(char *buf, int slot, struct net_device *dev) | |
305 | { | |
306 | int len=0; | |
307 | ||
308 | len += sprintf(buf+len, "The NE/2 Ethernet Adapter\n" ); | |
309 | len += sprintf(buf+len, "Driver written by Wim Dumon "); | |
310 | len += sprintf(buf+len, "<wimpie@kotnet.org>\n"); | |
311 | len += sprintf(buf+len, "Modified by "); | |
312 | len += sprintf(buf+len, "David Weinehall <tao@acc.umu.se>\n"); | |
313 | len += sprintf(buf+len, "and by Magnus Jonsson <bigfoot@acc.umu.se>\n"); | |
314 | len += sprintf(buf+len, "Based on the original NE2000 drivers\n" ); | |
315 | len += sprintf(buf+len, "Base IO: %#x\n", (unsigned int)dev->base_addr); | |
316 | len += sprintf(buf+len, "IRQ : %d\n", dev->irq); | |
317 | ||
318 | #define HW_ADDR(i) dev->dev_addr[i] | |
319 | len += sprintf(buf+len, "HW addr : %x:%x:%x:%x:%x:%x\n", | |
320 | HW_ADDR(0), HW_ADDR(1), HW_ADDR(2), | |
321 | HW_ADDR(3), HW_ADDR(4), HW_ADDR(5) ); | |
322 | #undef HW_ADDR | |
323 | ||
324 | return len; | |
325 | } | |
326 | ||
327 | static int __init ne2_probe1(struct net_device *dev, int slot) | |
328 | { | |
329 | int i, base_addr, irq, retval; | |
330 | unsigned char POS; | |
331 | unsigned char SA_prom[32]; | |
332 | const char *name = "NE/2"; | |
333 | int start_page, stop_page; | |
334 | static unsigned version_printed; | |
335 | ||
336 | if (ei_debug && version_printed++ == 0) | |
337 | printk(version); | |
338 | ||
339 | printk("NE/2 ethercard found in slot %d:", slot); | |
340 | ||
341 | /* Read base IO and IRQ from the POS-registers */ | |
342 | POS = mca_read_stored_pos(slot, 2); | |
343 | if(!(POS % 2)) { | |
344 | printk(" disabled.\n"); | |
345 | return -ENODEV; | |
346 | } | |
347 | ||
348 | /* handle different POS register structure for D-Link card */ | |
349 | ||
350 | if (mca_read_stored_pos(slot, 0) == 0xea) { | |
351 | base_addr = dlink_addresses[(POS >> 5) & 0x03]; | |
352 | irq = dlink_irqs[(POS >> 2) & 0x07]; | |
353 | } | |
354 | else { | |
355 | i = (POS & 0xE)>>1; | |
356 | /* printk("Halleluja sdog, als er na de pijl een 1 staat is 1 - 1 == 0" | |
357 | " en zou het moeten werken -> %d\n", i); | |
358 | The above line was for remote testing, thanx to sdog ... */ | |
359 | base_addr = addresses[i - 1]; | |
360 | irq = irqs[(POS & 0x60)>>5]; | |
361 | } | |
362 | ||
363 | if (!request_region(base_addr, NE_IO_EXTENT, DRV_NAME)) | |
364 | return -EBUSY; | |
365 | ||
366 | #ifdef DEBUG | |
367 | printk("POS info : pos 2 = %#x ; base = %#x ; irq = %ld\n", POS, | |
368 | base_addr, irq); | |
369 | #endif | |
370 | ||
371 | #ifndef CRYNWR_WAY | |
372 | /* Reset the card the way they do it in the Crynwr packet driver */ | |
373 | for (i=0; i<8; i++) | |
374 | outb(0x0, base_addr + NE_RESET); | |
375 | inb(base_addr + NE_RESET); | |
376 | outb(0x21, base_addr + NE_CMD); | |
377 | if (inb(base_addr + NE_CMD) != 0x21) { | |
378 | printk("NE/2 adapter not responding\n"); | |
379 | retval = -ENODEV; | |
380 | goto out; | |
381 | } | |
382 | ||
383 | /* In the crynwr sources they do a RAM-test here. I skip it. I suppose | |
384 | my RAM is okay. Suppose your memory is broken. Then this test | |
385 | should fail and you won't be able to use your card. But if I do not | |
386 | test, you won't be able to use your card, neither. So this test | |
387 | won't help you. */ | |
388 | ||
389 | #else /* _I_ never tested it this way .. Go ahead and try ...*/ | |
390 | /* Reset card. Who knows what dain-bramaged state it was left in. */ | |
391 | { | |
392 | unsigned long reset_start_time = jiffies; | |
393 | ||
394 | /* DON'T change these to inb_p/outb_p or reset will fail on | |
395 | clones.. */ | |
396 | outb(inb(base_addr + NE_RESET), base_addr + NE_RESET); | |
397 | ||
398 | while ((inb_p(base_addr + EN0_ISR) & ENISR_RESET) == 0) | |
ff5688ae | 399 | if (time_after(jiffies, reset_start_time + 2*HZ/100)) { |
1da177e4 LT |
400 | printk(" not found (no reset ack).\n"); |
401 | retval = -ENODEV; | |
402 | goto out; | |
403 | } | |
404 | ||
405 | outb_p(0xff, base_addr + EN0_ISR); /* Ack all intr. */ | |
406 | } | |
407 | #endif | |
408 | ||
409 | ||
410 | /* Read the 16 bytes of station address PROM. | |
411 | We must first initialize registers, similar to | |
412 | NS8390_init(eifdev, 0). | |
413 | We can't reliably read the SAPROM address without this. | |
414 | (I learned the hard way!). */ | |
415 | { | |
416 | struct { | |
417 | unsigned char value, offset; | |
418 | } program_seq[] = { | |
419 | /* Select page 0 */ | |
420 | {E8390_NODMA+E8390_PAGE0+E8390_STOP, E8390_CMD}, | |
421 | {0x49, EN0_DCFG}, /* Set WORD-wide (0x49) access. */ | |
422 | {0x00, EN0_RCNTLO}, /* Clear the count regs. */ | |
423 | {0x00, EN0_RCNTHI}, | |
424 | {0x00, EN0_IMR}, /* Mask completion irq. */ | |
425 | {0xFF, EN0_ISR}, | |
426 | {E8390_RXOFF, EN0_RXCR}, /* 0x20 Set to monitor */ | |
427 | {E8390_TXOFF, EN0_TXCR}, /* 0x02 and loopback mode. */ | |
428 | {32, EN0_RCNTLO}, | |
429 | {0x00, EN0_RCNTHI}, | |
430 | {0x00, EN0_RSARLO}, /* DMA starting at 0x0000. */ | |
431 | {0x00, EN0_RSARHI}, | |
432 | {E8390_RREAD+E8390_START, E8390_CMD}, | |
433 | }; | |
434 | ||
435 | for (i = 0; i < sizeof(program_seq)/sizeof(program_seq[0]); i++) | |
436 | outb_p(program_seq[i].value, base_addr + | |
437 | program_seq[i].offset); | |
438 | ||
439 | } | |
440 | for(i = 0; i < 6 /*sizeof(SA_prom)*/; i+=1) { | |
441 | SA_prom[i] = inb(base_addr + NE_DATAPORT); | |
442 | } | |
443 | ||
444 | /* I don't know whether the previous sequence includes the general | |
445 | board reset procedure, so better don't omit it and just overwrite | |
446 | the garbage read from a DE-320 with correct stuff. */ | |
447 | ||
448 | if (mca_read_stored_pos(slot, 0) == 0xea) { | |
449 | unsigned int v; | |
450 | ||
451 | for (i = 0; i < 3; i++) { | |
452 | v = dlink_get_eeprom(i, base_addr); | |
453 | SA_prom[(i << 1) ] = v & 0xff; | |
454 | SA_prom[(i << 1) + 1] = (v >> 8) & 0xff; | |
455 | } | |
456 | } | |
457 | ||
458 | start_page = NESM_START_PG; | |
459 | stop_page = NESM_STOP_PG; | |
460 | ||
461 | dev->irq=irq; | |
462 | ||
463 | /* Snarf the interrupt now. There's no point in waiting since we cannot | |
464 | share and the board will usually be enabled. */ | |
465 | retval = request_irq(dev->irq, ei_interrupt, 0, DRV_NAME, dev); | |
466 | if (retval) { | |
467 | printk (" unable to get IRQ %d (irqval=%d).\n", | |
468 | dev->irq, retval); | |
469 | goto out; | |
470 | } | |
471 | ||
472 | dev->base_addr = base_addr; | |
473 | ||
474 | for(i = 0; i < ETHER_ADDR_LEN; i++) { | |
475 | printk(" %2.2x", SA_prom[i]); | |
476 | dev->dev_addr[i] = SA_prom[i]; | |
477 | } | |
478 | ||
479 | printk("\n%s: %s found at %#x, using IRQ %d.\n", | |
480 | dev->name, name, base_addr, dev->irq); | |
481 | ||
482 | mca_set_adapter_procfn(slot, (MCA_ProcFn) ne2_procinfo, dev); | |
483 | ||
484 | ei_status.name = name; | |
485 | ei_status.tx_start_page = start_page; | |
486 | ei_status.stop_page = stop_page; | |
487 | ei_status.word16 = (2 == 2); | |
488 | ||
489 | ei_status.rx_start_page = start_page + TX_PAGES; | |
490 | #ifdef PACKETBUF_MEMSIZE | |
491 | /* Allow the packet buffer size to be overridden by know-it-alls. */ | |
492 | ei_status.stop_page = ei_status.tx_start_page + PACKETBUF_MEMSIZE; | |
493 | #endif | |
494 | ||
495 | ei_status.reset_8390 = &ne_reset_8390; | |
496 | ei_status.block_input = &ne_block_input; | |
497 | ei_status.block_output = &ne_block_output; | |
498 | ei_status.get_8390_hdr = &ne_get_8390_hdr; | |
499 | ||
500 | ei_status.priv = slot; | |
501 | ||
502 | dev->open = &ne_open; | |
503 | dev->stop = &ne_close; | |
504 | #ifdef CONFIG_NET_POLL_CONTROLLER | |
505 | dev->poll_controller = ei_poll; | |
506 | #endif | |
507 | NS8390_init(dev, 0); | |
b1fc5505 | 508 | |
509 | retval = register_netdev(dev); | |
510 | if (retval) | |
511 | goto out1; | |
1da177e4 | 512 | return 0; |
b1fc5505 | 513 | out1: |
514 | mca_set_adapter_procfn( ei_status.priv, NULL, NULL); | |
515 | free_irq(dev->irq, dev); | |
1da177e4 LT |
516 | out: |
517 | release_region(base_addr, NE_IO_EXTENT); | |
518 | return retval; | |
519 | } | |
520 | ||
521 | static int ne_open(struct net_device *dev) | |
522 | { | |
523 | ei_open(dev); | |
524 | return 0; | |
525 | } | |
526 | ||
527 | static int ne_close(struct net_device *dev) | |
528 | { | |
529 | if (ei_debug > 1) | |
530 | printk("%s: Shutting down ethercard.\n", dev->name); | |
531 | ei_close(dev); | |
532 | return 0; | |
533 | } | |
534 | ||
535 | /* Hard reset the card. This used to pause for the same period that a | |
536 | 8390 reset command required, but that shouldn't be necessary. */ | |
537 | static void ne_reset_8390(struct net_device *dev) | |
538 | { | |
539 | unsigned long reset_start_time = jiffies; | |
540 | ||
541 | if (ei_debug > 1) | |
542 | printk("resetting the 8390 t=%ld...", jiffies); | |
543 | ||
544 | /* DON'T change these to inb_p/outb_p or reset will fail on clones. */ | |
545 | outb(inb(NE_BASE + NE_RESET), NE_BASE + NE_RESET); | |
546 | ||
547 | ei_status.txing = 0; | |
548 | ei_status.dmaing = 0; | |
549 | ||
550 | /* This check _should_not_ be necessary, omit eventually. */ | |
551 | while ((inb_p(NE_BASE+EN0_ISR) & ENISR_RESET) == 0) | |
ff5688ae | 552 | if (time_after(jiffies, reset_start_time + 2*HZ/100)) { |
1da177e4 LT |
553 | printk("%s: ne_reset_8390() did not complete.\n", |
554 | dev->name); | |
555 | break; | |
556 | } | |
557 | outb_p(ENISR_RESET, NE_BASE + EN0_ISR); /* Ack intr. */ | |
558 | } | |
559 | ||
560 | /* Grab the 8390 specific header. Similar to the block_input routine, but | |
561 | we don't need to be concerned with ring wrap as the header will be at | |
562 | the start of a page, so we optimize accordingly. */ | |
563 | ||
564 | static void ne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, | |
565 | int ring_page) | |
566 | { | |
567 | ||
568 | int nic_base = dev->base_addr; | |
569 | ||
570 | /* This *shouldn't* happen. | |
571 | If it does, it's the last thing you'll see */ | |
572 | if (ei_status.dmaing) { | |
573 | printk("%s: DMAing conflict in ne_get_8390_hdr " | |
574 | "[DMAstat:%d][irqlock:%d].\n", | |
575 | dev->name, ei_status.dmaing, ei_status.irqlock); | |
576 | return; | |
577 | } | |
578 | ||
579 | ei_status.dmaing |= 0x01; | |
580 | outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD); | |
581 | outb_p(sizeof(struct e8390_pkt_hdr), nic_base + EN0_RCNTLO); | |
582 | outb_p(0, nic_base + EN0_RCNTHI); | |
583 | outb_p(0, nic_base + EN0_RSARLO); /* On page boundary */ | |
584 | outb_p(ring_page, nic_base + EN0_RSARHI); | |
585 | outb_p(E8390_RREAD+E8390_START, nic_base + NE_CMD); | |
586 | ||
587 | if (ei_status.word16) | |
588 | insw(NE_BASE + NE_DATAPORT, hdr, | |
589 | sizeof(struct e8390_pkt_hdr)>>1); | |
590 | else | |
591 | insb(NE_BASE + NE_DATAPORT, hdr, | |
592 | sizeof(struct e8390_pkt_hdr)); | |
593 | ||
594 | outb_p(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */ | |
595 | ei_status.dmaing &= ~0x01; | |
596 | } | |
597 | ||
598 | /* Block input and output, similar to the Crynwr packet driver. If you | |
599 | are porting to a new ethercard, look at the packet driver source for | |
600 | hints. The NEx000 doesn't share the on-board packet memory -- you have | |
601 | to put the packet out through the "remote DMA" dataport using outb. */ | |
602 | ||
603 | static void ne_block_input(struct net_device *dev, int count, struct sk_buff *skb, | |
604 | int ring_offset) | |
605 | { | |
606 | #ifdef NE_SANITY_CHECK | |
607 | int xfer_count = count; | |
608 | #endif | |
609 | int nic_base = dev->base_addr; | |
610 | char *buf = skb->data; | |
611 | ||
612 | /* This *shouldn't* happen. | |
613 | If it does, it's the last thing you'll see */ | |
614 | if (ei_status.dmaing) { | |
615 | printk("%s: DMAing conflict in ne_block_input " | |
616 | "[DMAstat:%d][irqlock:%d].\n", | |
617 | dev->name, ei_status.dmaing, ei_status.irqlock); | |
618 | return; | |
619 | } | |
620 | ei_status.dmaing |= 0x01; | |
621 | outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD); | |
622 | outb_p(count & 0xff, nic_base + EN0_RCNTLO); | |
623 | outb_p(count >> 8, nic_base + EN0_RCNTHI); | |
624 | outb_p(ring_offset & 0xff, nic_base + EN0_RSARLO); | |
625 | outb_p(ring_offset >> 8, nic_base + EN0_RSARHI); | |
626 | outb_p(E8390_RREAD+E8390_START, nic_base + NE_CMD); | |
627 | if (ei_status.word16) { | |
628 | insw(NE_BASE + NE_DATAPORT,buf,count>>1); | |
629 | if (count & 0x01) { | |
630 | buf[count-1] = inb(NE_BASE + NE_DATAPORT); | |
631 | #ifdef NE_SANITY_CHECK | |
632 | xfer_count++; | |
633 | #endif | |
634 | } | |
635 | } else { | |
636 | insb(NE_BASE + NE_DATAPORT, buf, count); | |
637 | } | |
638 | ||
639 | #ifdef NE_SANITY_CHECK | |
640 | /* This was for the ALPHA version only, but enough people have | |
641 | been encountering problems so it is still here. If you see | |
642 | this message you either 1) have a slightly incompatible clone | |
643 | or 2) have noise/speed problems with your bus. */ | |
644 | if (ei_debug > 1) { /* DMA termination address check... */ | |
645 | int addr, tries = 20; | |
646 | do { | |
647 | /* DON'T check for 'inb_p(EN0_ISR) & ENISR_RDC' here | |
648 | -- it's broken for Rx on some cards! */ | |
649 | int high = inb_p(nic_base + EN0_RSARHI); | |
650 | int low = inb_p(nic_base + EN0_RSARLO); | |
651 | addr = (high << 8) + low; | |
652 | if (((ring_offset + xfer_count) & 0xff) == low) | |
653 | break; | |
654 | } while (--tries > 0); | |
655 | if (tries <= 0) | |
656 | printk("%s: RX transfer address mismatch," | |
657 | "%#4.4x (expected) vs. %#4.4x (actual).\n", | |
658 | dev->name, ring_offset + xfer_count, addr); | |
659 | } | |
660 | #endif | |
661 | outb_p(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */ | |
662 | ei_status.dmaing &= ~0x01; | |
663 | } | |
664 | ||
665 | static void ne_block_output(struct net_device *dev, int count, | |
666 | const unsigned char *buf, const int start_page) | |
667 | { | |
668 | int nic_base = NE_BASE; | |
669 | unsigned long dma_start; | |
670 | #ifdef NE_SANITY_CHECK | |
671 | int retries = 0; | |
672 | #endif | |
673 | ||
674 | /* Round the count up for word writes. Do we need to do this? | |
675 | What effect will an odd byte count have on the 8390? | |
676 | I should check someday. */ | |
677 | if (ei_status.word16 && (count & 0x01)) | |
678 | count++; | |
679 | ||
680 | /* This *shouldn't* happen. | |
681 | If it does, it's the last thing you'll see */ | |
682 | if (ei_status.dmaing) { | |
683 | printk("%s: DMAing conflict in ne_block_output." | |
684 | "[DMAstat:%d][irqlock:%d]\n", | |
685 | dev->name, ei_status.dmaing, ei_status.irqlock); | |
686 | return; | |
687 | } | |
688 | ei_status.dmaing |= 0x01; | |
689 | /* We should already be in page 0, but to be safe... */ | |
690 | outb_p(E8390_PAGE0+E8390_START+E8390_NODMA, nic_base + NE_CMD); | |
691 | ||
692 | #ifdef NE_SANITY_CHECK | |
693 | retry: | |
694 | #endif | |
695 | ||
696 | #ifdef NE8390_RW_BUGFIX | |
697 | /* Handle the read-before-write bug the same way as the | |
698 | Crynwr packet driver -- the NatSemi method doesn't work. | |
699 | Actually this doesn't always work either, but if you have | |
700 | problems with your NEx000 this is better than nothing! */ | |
701 | outb_p(0x42, nic_base + EN0_RCNTLO); | |
702 | outb_p(0x00, nic_base + EN0_RCNTHI); | |
703 | outb_p(0x42, nic_base + EN0_RSARLO); | |
704 | outb_p(0x00, nic_base + EN0_RSARHI); | |
705 | outb_p(E8390_RREAD+E8390_START, nic_base + NE_CMD); | |
706 | /* Make certain that the dummy read has occurred. */ | |
707 | SLOW_DOWN_IO; | |
708 | SLOW_DOWN_IO; | |
709 | SLOW_DOWN_IO; | |
710 | #endif | |
711 | ||
712 | outb_p(ENISR_RDC, nic_base + EN0_ISR); | |
713 | ||
714 | /* Now the normal output. */ | |
715 | outb_p(count & 0xff, nic_base + EN0_RCNTLO); | |
716 | outb_p(count >> 8, nic_base + EN0_RCNTHI); | |
717 | outb_p(0x00, nic_base + EN0_RSARLO); | |
718 | outb_p(start_page, nic_base + EN0_RSARHI); | |
719 | ||
720 | outb_p(E8390_RWRITE+E8390_START, nic_base + NE_CMD); | |
721 | if (ei_status.word16) { | |
722 | outsw(NE_BASE + NE_DATAPORT, buf, count>>1); | |
723 | } else { | |
724 | outsb(NE_BASE + NE_DATAPORT, buf, count); | |
725 | } | |
726 | ||
727 | dma_start = jiffies; | |
728 | ||
729 | #ifdef NE_SANITY_CHECK | |
730 | /* This was for the ALPHA version only, but enough people have | |
731 | been encountering problems so it is still here. */ | |
732 | ||
733 | if (ei_debug > 1) { /* DMA termination address check... */ | |
734 | int addr, tries = 20; | |
735 | do { | |
736 | int high = inb_p(nic_base + EN0_RSARHI); | |
737 | int low = inb_p(nic_base + EN0_RSARLO); | |
738 | addr = (high << 8) + low; | |
739 | if ((start_page << 8) + count == addr) | |
740 | break; | |
741 | } while (--tries > 0); | |
742 | if (tries <= 0) { | |
743 | printk("%s: Tx packet transfer address mismatch," | |
744 | "%#4.4x (expected) vs. %#4.4x (actual).\n", | |
745 | dev->name, (start_page << 8) + count, addr); | |
746 | if (retries++ == 0) | |
747 | goto retry; | |
748 | } | |
749 | } | |
750 | #endif | |
751 | ||
752 | while ((inb_p(nic_base + EN0_ISR) & ENISR_RDC) == 0) | |
ff5688ae | 753 | if (time_after(jiffies, dma_start + 2*HZ/100)) { /* 20ms */ |
1da177e4 LT |
754 | printk("%s: timeout waiting for Tx RDC.\n", dev->name); |
755 | ne_reset_8390(dev); | |
756 | NS8390_init(dev,1); | |
757 | break; | |
758 | } | |
759 | ||
760 | outb_p(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */ | |
761 | ei_status.dmaing &= ~0x01; | |
762 | return; | |
763 | } | |
764 | ||
765 | ||
766 | #ifdef MODULE | |
767 | #define MAX_NE_CARDS 4 /* Max number of NE cards per module */ | |
768 | static struct net_device *dev_ne[MAX_NE_CARDS]; | |
769 | static int io[MAX_NE_CARDS]; | |
770 | static int irq[MAX_NE_CARDS]; | |
771 | static int bad[MAX_NE_CARDS]; /* 0xbad = bad sig or no reset ack */ | |
772 | MODULE_LICENSE("GPL"); | |
773 | ||
774 | module_param_array(io, int, NULL, 0); | |
775 | module_param_array(irq, int, NULL, 0); | |
776 | module_param_array(bad, int, NULL, 0); | |
777 | MODULE_PARM_DESC(io, "(ignored)"); | |
778 | MODULE_PARM_DESC(irq, "(ignored)"); | |
779 | MODULE_PARM_DESC(bad, "(ignored)"); | |
780 | ||
781 | /* Module code fixed by David Weinehall */ | |
782 | ||
783 | int init_module(void) | |
784 | { | |
785 | struct net_device *dev; | |
786 | int this_dev, found = 0; | |
787 | ||
788 | for (this_dev = 0; this_dev < MAX_NE_CARDS; this_dev++) { | |
789 | dev = alloc_ei_netdev(); | |
790 | if (!dev) | |
791 | break; | |
792 | dev->irq = irq[this_dev]; | |
793 | dev->mem_end = bad[this_dev]; | |
794 | dev->base_addr = io[this_dev]; | |
795 | if (do_ne2_probe(dev) == 0) { | |
b1fc5505 | 796 | dev_ne[found++] = dev; |
797 | continue; | |
1da177e4 LT |
798 | } |
799 | free_netdev(dev); | |
800 | break; | |
801 | } | |
802 | if (found) | |
803 | return 0; | |
804 | printk(KERN_WARNING "ne2.c: No NE/2 card found\n"); | |
805 | return -ENXIO; | |
806 | } | |
807 | ||
64916f1e DV |
808 | static void cleanup_card(struct net_device *dev) |
809 | { | |
810 | mca_mark_as_unused(ei_status.priv); | |
811 | mca_set_adapter_procfn( ei_status.priv, NULL, NULL); | |
812 | free_irq(dev->irq, dev); | |
813 | release_region(dev->base_addr, NE_IO_EXTENT); | |
814 | } | |
815 | ||
1da177e4 LT |
816 | void cleanup_module(void) |
817 | { | |
818 | int this_dev; | |
819 | ||
820 | for (this_dev = 0; this_dev < MAX_NE_CARDS; this_dev++) { | |
821 | struct net_device *dev = dev_ne[this_dev]; | |
822 | if (dev) { | |
823 | unregister_netdev(dev); | |
824 | cleanup_card(dev); | |
825 | free_netdev(dev); | |
826 | } | |
827 | } | |
828 | } | |
829 | #endif /* MODULE */ |