Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* at1700.c: A network device driver for the Allied Telesis AT1700. |
2 | ||
3 | Written 1993-98 by Donald Becker. | |
4 | ||
5 | Copyright 1993 United States Government as represented by the | |
6 | Director, National Security Agency. | |
7 | ||
8 | This software may be used and distributed according to the terms | |
9 | of the GNU General Public License, incorporated herein by reference. | |
10 | ||
11 | The author may be reached as becker@scyld.com, or C/O | |
12 | Scyld Computing Corporation | |
13 | 410 Severn Ave., Suite 210 | |
14 | Annapolis MD 21403 | |
15 | ||
16 | This is a device driver for the Allied Telesis AT1700, and | |
17 | Fujitsu FMV-181/182/181A/182A/183/184/183A/184A, which are | |
18 | straight-forward Fujitsu MB86965 implementations. | |
19 | ||
20 | Modification for Fujitsu FMV-18X cards is done by Yutaka Tamiya | |
6aa20a22 | 21 | (tamy@flab.fujitsu.co.jp). |
1da177e4 LT |
22 | |
23 | Sources: | |
24 | The Fujitsu MB86965 datasheet. | |
25 | ||
26 | After the initial version of this driver was written Gerry Sawkins of | |
27 | ATI provided their EEPROM configuration code header file. | |
28 | Thanks to NIIBE Yutaka <gniibe@mri.co.jp> for bug fixes. | |
29 | ||
30 | MCA bus (AT1720) support by Rene Schmit <rene@bss.lu> | |
31 | ||
32 | Bugs: | |
33 | The MB86965 has a design flaw that makes all probes unreliable. Not | |
34 | only is it difficult to detect, it also moves around in I/O space in | |
35 | response to inb()s from other device probes! | |
36 | */ | |
1da177e4 | 37 | |
1da177e4 LT |
38 | #include <linux/errno.h> |
39 | #include <linux/netdevice.h> | |
40 | #include <linux/etherdevice.h> | |
41 | #include <linux/mca-legacy.h> | |
42 | #include <linux/module.h> | |
43 | #include <linux/kernel.h> | |
44 | #include <linux/types.h> | |
45 | #include <linux/fcntl.h> | |
46 | #include <linux/interrupt.h> | |
47 | #include <linux/ioport.h> | |
48 | #include <linux/in.h> | |
49 | #include <linux/skbuff.h> | |
50 | #include <linux/slab.h> | |
51 | #include <linux/string.h> | |
52 | #include <linux/init.h> | |
53 | #include <linux/crc32.h> | |
54 | #include <linux/bitops.h> | |
55 | ||
56 | #include <asm/system.h> | |
57 | #include <asm/io.h> | |
58 | #include <asm/dma.h> | |
59 | ||
60 | static char version[] __initdata = | |
d5b20697 | 61 | "at1700.c:v1.16 9/11/06 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n"; |
1da177e4 LT |
62 | |
63 | #define DRV_NAME "at1700" | |
64 | ||
65 | /* Tunable parameters. */ | |
66 | ||
67 | /* When to switch from the 64-entry multicast filter to Rx-all-multicast. */ | |
68 | #define MC_FILTERBREAK 64 | |
69 | ||
70 | /* These unusual address orders are used to verify the CONFIG register. */ | |
71 | ||
72 | static int fmv18x_probe_list[] __initdata = { | |
73 | 0x220, 0x240, 0x260, 0x280, 0x2a0, 0x2c0, 0x300, 0x340, 0 | |
74 | }; | |
75 | ||
76 | /* | |
77 | * ISA | |
78 | */ | |
79 | ||
80 | static unsigned at1700_probe_list[] __initdata = { | |
81 | 0x260, 0x280, 0x2a0, 0x240, 0x340, 0x320, 0x380, 0x300, 0 | |
82 | }; | |
83 | ||
84 | /* | |
85 | * MCA | |
86 | */ | |
87 | #ifdef CONFIG_MCA_LEGACY | |
88 | static int at1700_ioaddr_pattern[] __initdata = { | |
89 | 0x00, 0x04, 0x01, 0x05, 0x02, 0x06, 0x03, 0x07 | |
90 | }; | |
91 | ||
92 | static int at1700_mca_probe_list[] __initdata = { | |
93 | 0x400, 0x1400, 0x2400, 0x3400, 0x4400, 0x5400, 0x6400, 0x7400, 0 | |
94 | }; | |
95 | ||
96 | static int at1700_irq_pattern[] __initdata = { | |
97 | 0x00, 0x00, 0x00, 0x30, 0x70, 0xb0, 0x00, 0x00, | |
98 | 0x00, 0xf0, 0x34, 0x74, 0xb4, 0x00, 0x00, 0xf4, 0x00 | |
99 | }; | |
100 | #endif | |
101 | ||
102 | /* use 0 for production, 1 for verification, >2 for debug */ | |
103 | #ifndef NET_DEBUG | |
104 | #define NET_DEBUG 1 | |
105 | #endif | |
106 | static unsigned int net_debug = NET_DEBUG; | |
107 | ||
108 | typedef unsigned char uchar; | |
109 | ||
110 | /* Information that need to be kept for each board. */ | |
111 | struct net_local { | |
112 | struct net_device_stats stats; | |
113 | spinlock_t lock; | |
114 | unsigned char mc_filter[8]; | |
115 | uint jumpered:1; /* Set iff the board has jumper config. */ | |
116 | uint tx_started:1; /* Packets are on the Tx queue. */ | |
117 | uint tx_queue_ready:1; /* Tx queue is ready to be sent. */ | |
118 | uint rx_started:1; /* Packets are Rxing. */ | |
119 | uchar tx_queue; /* Number of packet on the Tx queue. */ | |
120 | char mca_slot; /* -1 means ISA */ | |
121 | ushort tx_queue_len; /* Current length of the Tx queue. */ | |
122 | }; | |
123 | ||
124 | ||
125 | /* Offsets from the base address. */ | |
126 | #define STATUS 0 | |
127 | #define TX_STATUS 0 | |
128 | #define RX_STATUS 1 | |
129 | #define TX_INTR 2 /* Bit-mapped interrupt enable registers. */ | |
130 | #define RX_INTR 3 | |
131 | #define TX_MODE 4 | |
132 | #define RX_MODE 5 | |
133 | #define CONFIG_0 6 /* Misc. configuration settings. */ | |
134 | #define CONFIG_1 7 | |
135 | /* Run-time register bank 2 definitions. */ | |
136 | #define DATAPORT 8 /* Word-wide DMA or programmed-I/O dataport. */ | |
137 | #define TX_START 10 | |
138 | #define COL16CNTL 11 /* Controll Reg for 16 collisions */ | |
139 | #define MODE13 13 | |
140 | #define RX_CTRL 14 | |
141 | /* Configuration registers only on the '865A/B chips. */ | |
142 | #define EEPROM_Ctrl 16 | |
143 | #define EEPROM_Data 17 | |
144 | #define CARDSTATUS 16 /* FMV-18x Card Status */ | |
145 | #define CARDSTATUS1 17 /* FMV-18x Card Status */ | |
146 | #define IOCONFIG 18 /* Either read the jumper, or move the I/O. */ | |
147 | #define IOCONFIG1 19 | |
148 | #define SAPROM 20 /* The station address PROM, if no EEPROM. */ | |
149 | #define MODE24 24 | |
150 | #define RESET 31 /* Write to reset some parts of the chip. */ | |
151 | #define AT1700_IO_EXTENT 32 | |
152 | #define PORT_OFFSET(o) (o) | |
153 | ||
154 | ||
155 | #define TX_TIMEOUT 10 | |
156 | ||
157 | ||
158 | /* Index to functions, as function prototypes. */ | |
159 | ||
160 | static int at1700_probe1(struct net_device *dev, int ioaddr); | |
161 | static int read_eeprom(long ioaddr, int location); | |
162 | static int net_open(struct net_device *dev); | |
163 | static int net_send_packet(struct sk_buff *skb, struct net_device *dev); | |
7d12e780 | 164 | static irqreturn_t net_interrupt(int irq, void *dev_id); |
1da177e4 LT |
165 | static void net_rx(struct net_device *dev); |
166 | static int net_close(struct net_device *dev); | |
167 | static struct net_device_stats *net_get_stats(struct net_device *dev); | |
168 | static void set_rx_mode(struct net_device *dev); | |
169 | static void net_tx_timeout (struct net_device *dev); | |
170 | ||
6aa20a22 | 171 | |
1da177e4 LT |
172 | #ifdef CONFIG_MCA_LEGACY |
173 | struct at1720_mca_adapters_struct { | |
174 | char* name; | |
175 | int id; | |
176 | }; | |
177 | /* rEnE : maybe there are others I don't know off... */ | |
178 | ||
179 | static struct at1720_mca_adapters_struct at1720_mca_adapters[] __initdata = { | |
180 | { "Allied Telesys AT1720AT", 0x6410 }, | |
181 | { "Allied Telesys AT1720BT", 0x6413 }, | |
182 | { "Allied Telesys AT1720T", 0x6416 }, | |
183 | { NULL, 0 }, | |
184 | }; | |
185 | #endif | |
186 | ||
187 | /* Check for a network adaptor of this type, and return '0' iff one exists. | |
188 | If dev->base_addr == 0, probe all likely locations. | |
189 | If dev->base_addr == 1, always return failure. | |
190 | If dev->base_addr == 2, allocate space for the device and return success | |
191 | (detachable devices only). | |
192 | */ | |
193 | ||
194 | static int io = 0x260; | |
195 | ||
196 | static int irq; | |
197 | ||
198 | static void cleanup_card(struct net_device *dev) | |
199 | { | |
200 | #ifdef CONFIG_MCA_LEGACY | |
201 | struct net_local *lp = netdev_priv(dev); | |
202 | if (lp->mca_slot >= 0) | |
203 | mca_mark_as_unused(lp->mca_slot); | |
6aa20a22 | 204 | #endif |
1da177e4 LT |
205 | free_irq(dev->irq, NULL); |
206 | release_region(dev->base_addr, AT1700_IO_EXTENT); | |
207 | } | |
208 | ||
209 | struct net_device * __init at1700_probe(int unit) | |
210 | { | |
211 | struct net_device *dev = alloc_etherdev(sizeof(struct net_local)); | |
212 | unsigned *port; | |
213 | int err = 0; | |
214 | ||
215 | if (!dev) | |
216 | return ERR_PTR(-ENODEV); | |
217 | ||
218 | if (unit >= 0) { | |
219 | sprintf(dev->name, "eth%d", unit); | |
220 | netdev_boot_setup_check(dev); | |
221 | io = dev->base_addr; | |
222 | irq = dev->irq; | |
223 | } else { | |
224 | dev->base_addr = io; | |
225 | dev->irq = irq; | |
226 | } | |
227 | ||
228 | SET_MODULE_OWNER(dev); | |
229 | ||
230 | if (io > 0x1ff) { /* Check a single specified location. */ | |
231 | err = at1700_probe1(dev, io); | |
232 | } else if (io != 0) { /* Don't probe at all. */ | |
233 | err = -ENXIO; | |
234 | } else { | |
235 | for (port = at1700_probe_list; *port; port++) { | |
236 | if (at1700_probe1(dev, *port) == 0) | |
237 | break; | |
238 | dev->irq = irq; | |
239 | } | |
240 | if (!*port) | |
241 | err = -ENODEV; | |
242 | } | |
243 | if (err) | |
244 | goto out; | |
245 | err = register_netdev(dev); | |
246 | if (err) | |
247 | goto out1; | |
248 | return dev; | |
249 | out1: | |
250 | cleanup_card(dev); | |
251 | out: | |
252 | free_netdev(dev); | |
253 | return ERR_PTR(err); | |
254 | } | |
255 | ||
256 | /* The Fujitsu datasheet suggests that the NIC be probed for by checking its | |
257 | "signature", the default bit pattern after a reset. This *doesn't* work -- | |
258 | there is no way to reset the bus interface without a complete power-cycle! | |
259 | ||
260 | It turns out that ATI came to the same conclusion I did: the only thing | |
261 | that can be done is checking a few bits and then diving right into an | |
262 | EEPROM read. */ | |
263 | ||
264 | static int __init at1700_probe1(struct net_device *dev, int ioaddr) | |
265 | { | |
266 | char fmv_irqmap[4] = {3, 7, 10, 15}; | |
267 | char fmv_irqmap_pnp[8] = {3, 4, 5, 7, 9, 10, 11, 15}; | |
268 | char at1700_irqmap[8] = {3, 4, 5, 9, 10, 11, 14, 15}; | |
269 | unsigned int i, irq, is_fmv18x = 0, is_at1700 = 0; | |
270 | int slot, ret = -ENODEV; | |
271 | struct net_local *lp = netdev_priv(dev); | |
272 | ||
273 | if (!request_region(ioaddr, AT1700_IO_EXTENT, DRV_NAME)) | |
274 | return -EBUSY; | |
275 | ||
276 | /* Resetting the chip doesn't reset the ISA interface, so don't bother. | |
277 | That means we have to be careful with the register values we probe | |
278 | for. | |
279 | */ | |
280 | #ifdef notdef | |
281 | printk("at1700 probe at %#x, eeprom is %4.4x %4.4x %4.4x ctrl %4.4x.\n", | |
282 | ioaddr, read_eeprom(ioaddr, 4), read_eeprom(ioaddr, 5), | |
283 | read_eeprom(ioaddr, 6), inw(ioaddr + EEPROM_Ctrl)); | |
284 | #endif | |
285 | ||
286 | #ifdef CONFIG_MCA_LEGACY | |
287 | /* rEnE (rene@bss.lu): got this from 3c509 driver source , adapted for AT1720 */ | |
288 | ||
289 | /* Based on Erik Nygren's (nygren@mit.edu) 3c529 patch, heavily | |
290 | modified by Chris Beauregard (cpbeaure@csclub.uwaterloo.ca) | |
291 | to support standard MCA probing. */ | |
292 | ||
293 | /* redone for multi-card detection by ZP Gu (zpg@castle.net) */ | |
294 | /* now works as a module */ | |
295 | ||
296 | if (MCA_bus) { | |
297 | int j; | |
298 | int l_i; | |
299 | u_char pos3, pos4; | |
300 | ||
301 | for (j = 0; at1720_mca_adapters[j].name != NULL; j ++) { | |
302 | slot = 0; | |
303 | while (slot != MCA_NOTFOUND) { | |
6aa20a22 | 304 | |
1da177e4 LT |
305 | slot = mca_find_unused_adapter( at1720_mca_adapters[j].id, slot ); |
306 | if (slot == MCA_NOTFOUND) break; | |
307 | ||
308 | /* if we get this far, an adapter has been detected and is | |
309 | enabled */ | |
310 | ||
311 | pos3 = mca_read_stored_pos( slot, 3 ); | |
312 | pos4 = mca_read_stored_pos( slot, 4 ); | |
313 | ||
314 | for (l_i = 0; l_i < 0x09; l_i++) | |
315 | if (( pos3 & 0x07) == at1700_ioaddr_pattern[l_i]) | |
316 | break; | |
317 | ioaddr = at1700_mca_probe_list[l_i]; | |
6aa20a22 | 318 | |
1da177e4 LT |
319 | for (irq = 0; irq < 0x10; irq++) |
320 | if (((((pos4>>4) & 0x0f) | (pos3 & 0xf0)) & 0xff) == at1700_irq_pattern[irq]) | |
321 | break; | |
322 | ||
323 | /* probing for a card at a particular IO/IRQ */ | |
324 | if ((dev->irq && dev->irq != irq) || | |
325 | (dev->base_addr && dev->base_addr != ioaddr)) { | |
326 | slot++; /* probing next slot */ | |
327 | continue; | |
328 | } | |
329 | ||
330 | dev->irq = irq; | |
6aa20a22 | 331 | |
1da177e4 LT |
332 | /* claim the slot */ |
333 | mca_set_adapter_name( slot, at1720_mca_adapters[j].name ); | |
334 | mca_mark_as_used(slot); | |
335 | ||
336 | goto found; | |
337 | } | |
338 | } | |
339 | /* if we get here, we didn't find an MCA adapter - try ISA */ | |
340 | } | |
341 | #endif | |
342 | slot = -1; | |
343 | /* We must check for the EEPROM-config boards first, else accessing | |
344 | IOCONFIG0 will move the board! */ | |
345 | if (at1700_probe_list[inb(ioaddr + IOCONFIG1) & 0x07] == ioaddr | |
346 | && read_eeprom(ioaddr, 4) == 0x0000 | |
347 | && (read_eeprom(ioaddr, 5) & 0xff00) == 0xF400) | |
348 | is_at1700 = 1; | |
349 | else if (inb(ioaddr + SAPROM ) == 0x00 | |
350 | && inb(ioaddr + SAPROM + 1) == 0x00 | |
351 | && inb(ioaddr + SAPROM + 2) == 0x0e) | |
352 | is_fmv18x = 1; | |
353 | else { | |
354 | goto err_out; | |
355 | } | |
6aa20a22 | 356 | |
1da177e4 LT |
357 | #ifdef CONFIG_MCA_LEGACY |
358 | found: | |
359 | #endif | |
360 | ||
361 | /* Reset the internal state machines. */ | |
362 | outb(0, ioaddr + RESET); | |
363 | ||
364 | if (is_at1700) { | |
365 | irq = at1700_irqmap[(read_eeprom(ioaddr, 12)&0x04) | |
366 | | (read_eeprom(ioaddr, 0)>>14)]; | |
367 | } else { | |
368 | /* Check PnP mode for FMV-183/184/183A/184A. */ | |
369 | /* This PnP routine is very poor. IO and IRQ should be known. */ | |
370 | if (inb(ioaddr + CARDSTATUS1) & 0x20) { | |
371 | irq = dev->irq; | |
372 | for (i = 0; i < 8; i++) { | |
373 | if (irq == fmv_irqmap_pnp[i]) | |
374 | break; | |
375 | } | |
376 | if (i == 8) { | |
377 | goto err_mca; | |
378 | } | |
379 | } else { | |
380 | if (fmv18x_probe_list[inb(ioaddr + IOCONFIG) & 0x07] != ioaddr) | |
381 | goto err_mca; | |
382 | irq = fmv_irqmap[(inb(ioaddr + IOCONFIG)>>6) & 0x03]; | |
383 | } | |
384 | } | |
385 | ||
386 | printk("%s: %s found at %#3x, IRQ %d, address ", dev->name, | |
387 | is_at1700 ? "AT1700" : "FMV-18X", ioaddr, irq); | |
388 | ||
389 | dev->base_addr = ioaddr; | |
390 | dev->irq = irq; | |
391 | ||
392 | if (is_at1700) { | |
393 | for(i = 0; i < 3; i++) { | |
394 | unsigned short eeprom_val = read_eeprom(ioaddr, 4+i); | |
395 | printk("%04x", eeprom_val); | |
396 | ((unsigned short *)dev->dev_addr)[i] = ntohs(eeprom_val); | |
397 | } | |
398 | } else { | |
399 | for(i = 0; i < 6; i++) { | |
400 | unsigned char val = inb(ioaddr + SAPROM + i); | |
401 | printk("%02x", val); | |
402 | dev->dev_addr[i] = val; | |
403 | } | |
404 | } | |
405 | ||
406 | /* The EEPROM word 12 bit 0x0400 means use regular 100 ohm 10baseT signals, | |
407 | rather than 150 ohm shielded twisted pair compensation. | |
408 | 0x0000 == auto-sense the interface | |
409 | 0x0800 == use TP interface | |
410 | 0x1800 == use coax interface | |
411 | */ | |
412 | { | |
413 | const char *porttype[] = {"auto-sense", "10baseT", "auto-sense", "10base2"}; | |
414 | if (is_at1700) { | |
415 | ushort setup_value = read_eeprom(ioaddr, 12); | |
416 | dev->if_port = setup_value >> 8; | |
417 | } else { | |
418 | ushort setup_value = inb(ioaddr + CARDSTATUS); | |
419 | switch (setup_value & 0x07) { | |
420 | case 0x01: /* 10base5 */ | |
421 | case 0x02: /* 10base2 */ | |
422 | dev->if_port = 0x18; break; | |
423 | case 0x04: /* 10baseT */ | |
424 | dev->if_port = 0x08; break; | |
425 | default: /* auto-sense */ | |
426 | dev->if_port = 0x00; break; | |
427 | } | |
428 | } | |
429 | printk(" %s interface.\n", porttype[(dev->if_port>>3) & 3]); | |
430 | } | |
431 | ||
432 | /* Set the configuration register 0 to 32K 100ns. byte-wide memory, 16 bit | |
433 | bus access, two 4K Tx queues, and disabled Tx and Rx. */ | |
434 | outb(0xda, ioaddr + CONFIG_0); | |
435 | ||
436 | /* Set the station address in bank zero. */ | |
437 | outb(0x00, ioaddr + CONFIG_1); | |
438 | for (i = 0; i < 6; i++) | |
439 | outb(dev->dev_addr[i], ioaddr + PORT_OFFSET(8 + i)); | |
440 | ||
441 | /* Switch to bank 1 and set the multicast table to accept none. */ | |
442 | outb(0x04, ioaddr + CONFIG_1); | |
443 | for (i = 0; i < 8; i++) | |
444 | outb(0x00, ioaddr + PORT_OFFSET(8 + i)); | |
445 | ||
446 | ||
447 | /* Switch to bank 2 */ | |
448 | /* Lock our I/O address, and set manual processing mode for 16 collisions. */ | |
449 | outb(0x08, ioaddr + CONFIG_1); | |
450 | outb(dev->if_port, ioaddr + MODE13); | |
451 | outb(0x00, ioaddr + COL16CNTL); | |
452 | ||
453 | if (net_debug) | |
454 | printk(version); | |
455 | ||
456 | memset(lp, 0, sizeof(struct net_local)); | |
457 | ||
458 | dev->open = net_open; | |
459 | dev->stop = net_close; | |
460 | dev->hard_start_xmit = net_send_packet; | |
461 | dev->get_stats = net_get_stats; | |
462 | dev->set_multicast_list = &set_rx_mode; | |
463 | dev->tx_timeout = net_tx_timeout; | |
464 | dev->watchdog_timeo = TX_TIMEOUT; | |
465 | ||
466 | spin_lock_init(&lp->lock); | |
467 | ||
468 | lp->jumpered = is_fmv18x; | |
469 | lp->mca_slot = slot; | |
470 | /* Snarf the interrupt vector now. */ | |
471 | ret = request_irq(irq, &net_interrupt, 0, DRV_NAME, dev); | |
472 | if (ret) { | |
473 | printk (" AT1700 at %#3x is unusable due to a conflict on" | |
474 | "IRQ %d.\n", ioaddr, irq); | |
475 | goto err_mca; | |
476 | } | |
477 | ||
478 | return 0; | |
479 | ||
480 | err_mca: | |
481 | #ifdef CONFIG_MCA_LEGACY | |
482 | if (slot >= 0) | |
483 | mca_mark_as_unused(slot); | |
484 | #endif | |
485 | err_out: | |
486 | release_region(ioaddr, AT1700_IO_EXTENT); | |
487 | return ret; | |
488 | } | |
489 | ||
6aa20a22 | 490 | |
1da177e4 LT |
491 | /* EEPROM_Ctrl bits. */ |
492 | #define EE_SHIFT_CLK 0x40 /* EEPROM shift clock, in reg. 16. */ | |
493 | #define EE_CS 0x20 /* EEPROM chip select, in reg. 16. */ | |
494 | #define EE_DATA_WRITE 0x80 /* EEPROM chip data in, in reg. 17. */ | |
495 | #define EE_DATA_READ 0x80 /* EEPROM chip data out, in reg. 17. */ | |
496 | ||
497 | /* The EEPROM commands include the alway-set leading bit. */ | |
498 | #define EE_WRITE_CMD (5 << 6) | |
499 | #define EE_READ_CMD (6 << 6) | |
500 | #define EE_ERASE_CMD (7 << 6) | |
501 | ||
502 | static int __init read_eeprom(long ioaddr, int location) | |
503 | { | |
504 | int i; | |
505 | unsigned short retval = 0; | |
506 | long ee_addr = ioaddr + EEPROM_Ctrl; | |
507 | long ee_daddr = ioaddr + EEPROM_Data; | |
508 | int read_cmd = location | EE_READ_CMD; | |
509 | ||
510 | /* Shift the read command bits out. */ | |
511 | for (i = 9; i >= 0; i--) { | |
512 | short dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0; | |
513 | outb(EE_CS, ee_addr); | |
514 | outb(dataval, ee_daddr); | |
515 | outb(EE_CS | EE_SHIFT_CLK, ee_addr); /* EEPROM clock tick. */ | |
516 | } | |
517 | outb(EE_DATA_WRITE, ee_daddr); | |
518 | for (i = 16; i > 0; i--) { | |
519 | outb(EE_CS, ee_addr); | |
520 | outb(EE_CS | EE_SHIFT_CLK, ee_addr); | |
521 | retval = (retval << 1) | ((inb(ee_daddr) & EE_DATA_READ) ? 1 : 0); | |
522 | } | |
523 | ||
524 | /* Terminate the EEPROM access. */ | |
525 | outb(EE_CS, ee_addr); | |
526 | outb(EE_SHIFT_CLK, ee_addr); | |
527 | outb(0, ee_addr); | |
528 | return retval; | |
529 | } | |
530 | ||
6aa20a22 | 531 | |
1da177e4 LT |
532 | |
533 | static int net_open(struct net_device *dev) | |
534 | { | |
535 | struct net_local *lp = netdev_priv(dev); | |
536 | int ioaddr = dev->base_addr; | |
537 | ||
538 | /* Set the configuration register 0 to 32K 100ns. byte-wide memory, 16 bit | |
539 | bus access, and two 4K Tx queues. */ | |
540 | outb(0x5a, ioaddr + CONFIG_0); | |
541 | ||
542 | /* Powerup, switch to register bank 2, and enable the Rx and Tx. */ | |
543 | outb(0xe8, ioaddr + CONFIG_1); | |
544 | ||
545 | lp->tx_started = 0; | |
546 | lp->tx_queue_ready = 1; | |
547 | lp->rx_started = 0; | |
548 | lp->tx_queue = 0; | |
549 | lp->tx_queue_len = 0; | |
550 | ||
551 | /* Turn on hardware Tx and Rx interrupts. */ | |
552 | outb(0x82, ioaddr + TX_INTR); | |
553 | outb(0x81, ioaddr + RX_INTR); | |
554 | ||
555 | /* Enable the IRQ on boards of fmv18x it is feasible. */ | |
556 | if (lp->jumpered) { | |
557 | outb(0x80, ioaddr + IOCONFIG1); | |
558 | } | |
559 | ||
560 | netif_start_queue(dev); | |
561 | return 0; | |
562 | } | |
563 | ||
564 | static void net_tx_timeout (struct net_device *dev) | |
565 | { | |
566 | struct net_local *lp = netdev_priv(dev); | |
567 | int ioaddr = dev->base_addr; | |
568 | ||
569 | printk ("%s: transmit timed out with status %04x, %s?\n", dev->name, | |
570 | inw (ioaddr + STATUS), inb (ioaddr + TX_STATUS) & 0x80 | |
571 | ? "IRQ conflict" : "network cable problem"); | |
572 | printk ("%s: timeout registers: %04x %04x %04x %04x %04x %04x %04x %04x.\n", | |
573 | dev->name, inw(ioaddr + TX_STATUS), inw(ioaddr + TX_INTR), inw(ioaddr + TX_MODE), | |
574 | inw(ioaddr + CONFIG_0), inw(ioaddr + DATAPORT), inw(ioaddr + TX_START), | |
575 | inw(ioaddr + MODE13 - 1), inw(ioaddr + RX_CTRL)); | |
576 | lp->stats.tx_errors++; | |
577 | /* ToDo: We should try to restart the adaptor... */ | |
578 | outw(0xffff, ioaddr + MODE24); | |
579 | outw (0xffff, ioaddr + TX_STATUS); | |
580 | outb (0x5a, ioaddr + CONFIG_0); | |
581 | outb (0xe8, ioaddr + CONFIG_1); | |
582 | outw (0x8182, ioaddr + TX_INTR); | |
583 | outb (0x00, ioaddr + TX_START); | |
584 | outb (0x03, ioaddr + COL16CNTL); | |
585 | ||
586 | dev->trans_start = jiffies; | |
587 | ||
588 | lp->tx_started = 0; | |
589 | lp->tx_queue_ready = 1; | |
590 | lp->rx_started = 0; | |
591 | lp->tx_queue = 0; | |
592 | lp->tx_queue_len = 0; | |
593 | ||
594 | netif_wake_queue(dev); | |
595 | } | |
596 | ||
597 | ||
598 | static int net_send_packet (struct sk_buff *skb, struct net_device *dev) | |
599 | { | |
600 | struct net_local *lp = netdev_priv(dev); | |
601 | int ioaddr = dev->base_addr; | |
602 | short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN; | |
603 | short len = skb->len; | |
604 | unsigned char *buf = skb->data; | |
605 | static u8 pad[ETH_ZLEN]; | |
606 | ||
607 | netif_stop_queue (dev); | |
608 | ||
609 | /* We may not start transmitting unless we finish transferring | |
610 | a packet into the Tx queue. During executing the following | |
611 | codes we possibly catch a Tx interrupt. Thus we flag off | |
612 | tx_queue_ready, so that we prevent the interrupt routine | |
613 | (net_interrupt) to start transmitting. */ | |
614 | lp->tx_queue_ready = 0; | |
615 | { | |
616 | outw (length, ioaddr + DATAPORT); | |
617 | /* Packet data */ | |
618 | outsw (ioaddr + DATAPORT, buf, len >> 1); | |
619 | /* Check for dribble byte */ | |
620 | if (len & 1) { | |
621 | outw(skb->data[skb->len-1], ioaddr + DATAPORT); | |
622 | len++; | |
623 | } | |
624 | /* Check for packet padding */ | |
625 | if (length != skb->len) | |
626 | outsw(ioaddr + DATAPORT, pad, (length - len + 1) >> 1); | |
627 | ||
628 | lp->tx_queue++; | |
629 | lp->tx_queue_len += length + 2; | |
630 | } | |
631 | lp->tx_queue_ready = 1; | |
632 | ||
633 | if (lp->tx_started == 0) { | |
634 | /* If the Tx is idle, always trigger a transmit. */ | |
635 | outb (0x80 | lp->tx_queue, ioaddr + TX_START); | |
636 | lp->tx_queue = 0; | |
637 | lp->tx_queue_len = 0; | |
638 | dev->trans_start = jiffies; | |
639 | lp->tx_started = 1; | |
640 | netif_start_queue (dev); | |
641 | } else if (lp->tx_queue_len < 4096 - 1502) | |
642 | /* Yes, there is room for one more packet. */ | |
643 | netif_start_queue (dev); | |
644 | dev_kfree_skb (skb); | |
645 | ||
646 | return 0; | |
647 | } | |
6aa20a22 | 648 | |
1da177e4 LT |
649 | /* The typical workload of the driver: |
650 | Handle the network interface interrupts. */ | |
7d12e780 | 651 | static irqreturn_t net_interrupt(int irq, void *dev_id) |
1da177e4 LT |
652 | { |
653 | struct net_device *dev = dev_id; | |
654 | struct net_local *lp; | |
655 | int ioaddr, status; | |
656 | int handled = 0; | |
657 | ||
658 | if (dev == NULL) { | |
659 | printk ("at1700_interrupt(): irq %d for unknown device.\n", irq); | |
660 | return IRQ_NONE; | |
661 | } | |
662 | ||
663 | ioaddr = dev->base_addr; | |
664 | lp = netdev_priv(dev); | |
6aa20a22 | 665 | |
1da177e4 | 666 | spin_lock (&lp->lock); |
6aa20a22 | 667 | |
1da177e4 LT |
668 | status = inw(ioaddr + TX_STATUS); |
669 | outw(status, ioaddr + TX_STATUS); | |
670 | ||
671 | if (net_debug > 4) | |
672 | printk("%s: Interrupt with status %04x.\n", dev->name, status); | |
673 | if (lp->rx_started == 0 && | |
674 | (status & 0xff00 || (inb(ioaddr + RX_MODE) & 0x40) == 0)) { | |
675 | /* Got a packet(s). | |
676 | We cannot execute net_rx more than once at the same time for | |
677 | the same device. During executing net_rx, we possibly catch a | |
678 | Tx interrupt. Thus we flag on rx_started, so that we prevent | |
679 | the interrupt routine (net_interrupt) to dive into net_rx | |
680 | again. */ | |
681 | handled = 1; | |
682 | lp->rx_started = 1; | |
683 | outb(0x00, ioaddr + RX_INTR); /* Disable RX intr. */ | |
684 | net_rx(dev); | |
685 | outb(0x81, ioaddr + RX_INTR); /* Enable RX intr. */ | |
686 | lp->rx_started = 0; | |
687 | } | |
688 | if (status & 0x00ff) { | |
689 | handled = 1; | |
690 | if (status & 0x02) { | |
691 | /* More than 16 collisions occurred */ | |
692 | if (net_debug > 4) | |
693 | printk("%s: 16 Collision occur during Txing.\n", dev->name); | |
694 | /* Cancel sending a packet. */ | |
695 | outb(0x03, ioaddr + COL16CNTL); | |
696 | lp->stats.collisions++; | |
697 | } | |
698 | if (status & 0x82) { | |
699 | lp->stats.tx_packets++; | |
700 | /* The Tx queue has any packets and is not being | |
701 | transferred a packet from the host, start | |
702 | transmitting. */ | |
703 | if (lp->tx_queue && lp->tx_queue_ready) { | |
704 | outb(0x80 | lp->tx_queue, ioaddr + TX_START); | |
705 | lp->tx_queue = 0; | |
706 | lp->tx_queue_len = 0; | |
707 | dev->trans_start = jiffies; | |
708 | netif_wake_queue (dev); | |
709 | } else { | |
710 | lp->tx_started = 0; | |
711 | netif_wake_queue (dev); | |
712 | } | |
713 | } | |
714 | } | |
715 | ||
716 | spin_unlock (&lp->lock); | |
717 | return IRQ_RETVAL(handled); | |
718 | } | |
719 | ||
720 | /* We have a good packet(s), get it/them out of the buffers. */ | |
721 | static void | |
722 | net_rx(struct net_device *dev) | |
723 | { | |
724 | struct net_local *lp = netdev_priv(dev); | |
725 | int ioaddr = dev->base_addr; | |
726 | int boguscount = 5; | |
727 | ||
728 | while ((inb(ioaddr + RX_MODE) & 0x40) == 0) { | |
729 | ushort status = inw(ioaddr + DATAPORT); | |
730 | ushort pkt_len = inw(ioaddr + DATAPORT); | |
731 | ||
732 | if (net_debug > 4) | |
733 | printk("%s: Rxing packet mode %02x status %04x.\n", | |
734 | dev->name, inb(ioaddr + RX_MODE), status); | |
735 | #ifndef final_version | |
736 | if (status == 0) { | |
737 | outb(0x05, ioaddr + RX_CTRL); | |
738 | break; | |
739 | } | |
740 | #endif | |
741 | ||
742 | if ((status & 0xF0) != 0x20) { /* There was an error. */ | |
743 | lp->stats.rx_errors++; | |
744 | if (status & 0x08) lp->stats.rx_length_errors++; | |
745 | if (status & 0x04) lp->stats.rx_frame_errors++; | |
746 | if (status & 0x02) lp->stats.rx_crc_errors++; | |
747 | if (status & 0x01) lp->stats.rx_over_errors++; | |
748 | } else { | |
749 | /* Malloc up new buffer. */ | |
750 | struct sk_buff *skb; | |
751 | ||
752 | if (pkt_len > 1550) { | |
753 | printk("%s: The AT1700 claimed a very large packet, size %d.\n", | |
754 | dev->name, pkt_len); | |
755 | /* Prime the FIFO and then flush the packet. */ | |
756 | inw(ioaddr + DATAPORT); inw(ioaddr + DATAPORT); | |
757 | outb(0x05, ioaddr + RX_CTRL); | |
758 | lp->stats.rx_errors++; | |
759 | break; | |
760 | } | |
761 | skb = dev_alloc_skb(pkt_len+3); | |
762 | if (skb == NULL) { | |
763 | printk("%s: Memory squeeze, dropping packet (len %d).\n", | |
764 | dev->name, pkt_len); | |
765 | /* Prime the FIFO and then flush the packet. */ | |
766 | inw(ioaddr + DATAPORT); inw(ioaddr + DATAPORT); | |
767 | outb(0x05, ioaddr + RX_CTRL); | |
768 | lp->stats.rx_dropped++; | |
769 | break; | |
770 | } | |
1da177e4 LT |
771 | skb_reserve(skb,2); |
772 | ||
773 | insw(ioaddr + DATAPORT, skb_put(skb,pkt_len), (pkt_len + 1) >> 1); | |
774 | skb->protocol=eth_type_trans(skb, dev); | |
775 | netif_rx(skb); | |
776 | dev->last_rx = jiffies; | |
777 | lp->stats.rx_packets++; | |
778 | lp->stats.rx_bytes += pkt_len; | |
779 | } | |
780 | if (--boguscount <= 0) | |
781 | break; | |
782 | } | |
783 | ||
784 | /* If any worth-while packets have been received, dev_rint() | |
785 | has done a mark_bh(NET_BH) for us and will work on them | |
786 | when we get to the bottom-half routine. */ | |
787 | { | |
788 | int i; | |
789 | for (i = 0; i < 20; i++) { | |
790 | if ((inb(ioaddr + RX_MODE) & 0x40) == 0x40) | |
791 | break; | |
792 | inw(ioaddr + DATAPORT); /* dummy status read */ | |
793 | outb(0x05, ioaddr + RX_CTRL); | |
794 | } | |
795 | ||
796 | if (net_debug > 5) | |
797 | printk("%s: Exint Rx packet with mode %02x after %d ticks.\n", | |
798 | dev->name, inb(ioaddr + RX_MODE), i); | |
799 | } | |
800 | return; | |
801 | } | |
802 | ||
803 | /* The inverse routine to net_open(). */ | |
804 | static int net_close(struct net_device *dev) | |
805 | { | |
806 | struct net_local *lp = netdev_priv(dev); | |
807 | int ioaddr = dev->base_addr; | |
808 | ||
809 | netif_stop_queue(dev); | |
810 | ||
811 | /* Set configuration register 0 to disable Tx and Rx. */ | |
812 | outb(0xda, ioaddr + CONFIG_0); | |
813 | ||
814 | /* No statistic counters on the chip to update. */ | |
815 | ||
816 | /* Disable the IRQ on boards of fmv18x where it is feasible. */ | |
817 | if (lp->jumpered) { | |
818 | outb(0x00, ioaddr + IOCONFIG1); | |
819 | free_irq(dev->irq, dev); | |
820 | } | |
821 | ||
822 | /* Power-down the chip. Green, green, green! */ | |
823 | outb(0x00, ioaddr + CONFIG_1); | |
824 | return 0; | |
825 | } | |
826 | ||
827 | /* Get the current statistics. | |
828 | This may be called with the card open or closed. | |
829 | There are no on-chip counters, so this function is trivial. | |
830 | */ | |
831 | static struct net_device_stats * | |
832 | net_get_stats(struct net_device *dev) | |
833 | { | |
834 | struct net_local *lp = netdev_priv(dev); | |
835 | return &lp->stats; | |
836 | } | |
837 | ||
838 | /* | |
839 | Set the multicast/promiscuous mode for this adaptor. | |
840 | */ | |
841 | ||
842 | static void | |
843 | set_rx_mode(struct net_device *dev) | |
844 | { | |
845 | int ioaddr = dev->base_addr; | |
846 | struct net_local *lp = netdev_priv(dev); | |
847 | unsigned char mc_filter[8]; /* Multicast hash filter */ | |
848 | unsigned long flags; | |
849 | int i; | |
850 | ||
851 | if (dev->flags & IFF_PROMISC) { | |
1da177e4 LT |
852 | memset(mc_filter, 0xff, sizeof(mc_filter)); |
853 | outb(3, ioaddr + RX_MODE); /* Enable promiscuous mode */ | |
854 | } else if (dev->mc_count > MC_FILTERBREAK | |
855 | || (dev->flags & IFF_ALLMULTI)) { | |
856 | /* Too many to filter perfectly -- accept all multicasts. */ | |
857 | memset(mc_filter, 0xff, sizeof(mc_filter)); | |
858 | outb(2, ioaddr + RX_MODE); /* Use normal mode. */ | |
859 | } else if (dev->mc_count == 0) { | |
860 | memset(mc_filter, 0x00, sizeof(mc_filter)); | |
861 | outb(1, ioaddr + RX_MODE); /* Ignore almost all multicasts. */ | |
862 | } else { | |
863 | struct dev_mc_list *mclist; | |
864 | int i; | |
865 | ||
866 | memset(mc_filter, 0, sizeof(mc_filter)); | |
867 | for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count; | |
868 | i++, mclist = mclist->next) { | |
869 | unsigned int bit = | |
870 | ether_crc_le(ETH_ALEN, mclist->dmi_addr) >> 26; | |
871 | mc_filter[bit >> 3] |= (1 << bit); | |
872 | } | |
873 | outb(0x02, ioaddr + RX_MODE); /* Use normal mode. */ | |
874 | } | |
875 | ||
876 | spin_lock_irqsave (&lp->lock, flags); | |
877 | if (memcmp(mc_filter, lp->mc_filter, sizeof(mc_filter))) { | |
878 | int saved_bank = inw(ioaddr + CONFIG_0); | |
879 | /* Switch to bank 1 and set the multicast table. */ | |
880 | outw((saved_bank & ~0x0C00) | 0x0480, ioaddr + CONFIG_0); | |
881 | for (i = 0; i < 8; i++) | |
882 | outb(mc_filter[i], ioaddr + PORT_OFFSET(8 + i)); | |
883 | memcpy(lp->mc_filter, mc_filter, sizeof(mc_filter)); | |
884 | outw(saved_bank, ioaddr + CONFIG_0); | |
885 | } | |
886 | spin_unlock_irqrestore (&lp->lock, flags); | |
887 | return; | |
888 | } | |
889 | ||
890 | #ifdef MODULE | |
891 | static struct net_device *dev_at1700; | |
892 | ||
893 | module_param(io, int, 0); | |
894 | module_param(irq, int, 0); | |
895 | module_param(net_debug, int, 0); | |
896 | MODULE_PARM_DESC(io, "AT1700/FMV18X I/O base address"); | |
897 | MODULE_PARM_DESC(irq, "AT1700/FMV18X IRQ number"); | |
898 | MODULE_PARM_DESC(net_debug, "AT1700/FMV18X debug level (0-6)"); | |
899 | ||
5d930108 | 900 | int __init init_module(void) |
1da177e4 LT |
901 | { |
902 | if (io == 0) | |
903 | printk("at1700: You should not use auto-probing with insmod!\n"); | |
904 | dev_at1700 = at1700_probe(-1); | |
905 | if (IS_ERR(dev_at1700)) | |
906 | return PTR_ERR(dev_at1700); | |
907 | return 0; | |
908 | } | |
909 | ||
afc8eb46 | 910 | void __exit |
1da177e4 LT |
911 | cleanup_module(void) |
912 | { | |
913 | unregister_netdev(dev_at1700); | |
914 | cleanup_card(dev_at1700); | |
915 | free_netdev(dev_at1700); | |
916 | } | |
917 | #endif /* MODULE */ | |
918 | MODULE_LICENSE("GPL"); | |
919 | ||
6aa20a22 | 920 | |
1da177e4 LT |
921 | /* |
922 | * Local variables: | |
923 | * compile-command: "gcc -DMODULE -D__KERNEL__ -Wall -Wstrict-prototypes -O6 -c at1700.c" | |
924 | * alt-compile-command: "gcc -DMODVERSIONS -DMODULE -D__KERNEL__ -Wall -Wstrict-prototypes -O6 -c at1700.c" | |
925 | * tab-width: 4 | |
926 | * c-basic-offset: 4 | |
927 | * c-indent-level: 4 | |
928 | * End: | |
929 | */ | |
930 |