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 { | |
1da177e4 LT |
112 | spinlock_t lock; |
113 | unsigned char mc_filter[8]; | |
114 | uint jumpered:1; /* Set iff the board has jumper config. */ | |
115 | uint tx_started:1; /* Packets are on the Tx queue. */ | |
116 | uint tx_queue_ready:1; /* Tx queue is ready to be sent. */ | |
117 | uint rx_started:1; /* Packets are Rxing. */ | |
118 | uchar tx_queue; /* Number of packet on the Tx queue. */ | |
119 | char mca_slot; /* -1 means ISA */ | |
120 | ushort tx_queue_len; /* Current length of the Tx queue. */ | |
121 | }; | |
122 | ||
123 | ||
124 | /* Offsets from the base address. */ | |
125 | #define STATUS 0 | |
126 | #define TX_STATUS 0 | |
127 | #define RX_STATUS 1 | |
128 | #define TX_INTR 2 /* Bit-mapped interrupt enable registers. */ | |
129 | #define RX_INTR 3 | |
130 | #define TX_MODE 4 | |
131 | #define RX_MODE 5 | |
132 | #define CONFIG_0 6 /* Misc. configuration settings. */ | |
133 | #define CONFIG_1 7 | |
134 | /* Run-time register bank 2 definitions. */ | |
135 | #define DATAPORT 8 /* Word-wide DMA or programmed-I/O dataport. */ | |
136 | #define TX_START 10 | |
137 | #define COL16CNTL 11 /* Controll Reg for 16 collisions */ | |
138 | #define MODE13 13 | |
139 | #define RX_CTRL 14 | |
140 | /* Configuration registers only on the '865A/B chips. */ | |
141 | #define EEPROM_Ctrl 16 | |
142 | #define EEPROM_Data 17 | |
143 | #define CARDSTATUS 16 /* FMV-18x Card Status */ | |
144 | #define CARDSTATUS1 17 /* FMV-18x Card Status */ | |
145 | #define IOCONFIG 18 /* Either read the jumper, or move the I/O. */ | |
146 | #define IOCONFIG1 19 | |
147 | #define SAPROM 20 /* The station address PROM, if no EEPROM. */ | |
148 | #define MODE24 24 | |
149 | #define RESET 31 /* Write to reset some parts of the chip. */ | |
150 | #define AT1700_IO_EXTENT 32 | |
151 | #define PORT_OFFSET(o) (o) | |
152 | ||
153 | ||
154 | #define TX_TIMEOUT 10 | |
155 | ||
156 | ||
157 | /* Index to functions, as function prototypes. */ | |
158 | ||
159 | static int at1700_probe1(struct net_device *dev, int ioaddr); | |
160 | static int read_eeprom(long ioaddr, int location); | |
161 | static int net_open(struct net_device *dev); | |
61357325 SH |
162 | static netdev_tx_t net_send_packet(struct sk_buff *skb, |
163 | 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); | |
1da177e4 LT |
167 | static void set_rx_mode(struct net_device *dev); |
168 | static void net_tx_timeout (struct net_device *dev); | |
169 | ||
6aa20a22 | 170 | |
1da177e4 LT |
171 | #ifdef CONFIG_MCA_LEGACY |
172 | struct at1720_mca_adapters_struct { | |
173 | char* name; | |
174 | int id; | |
175 | }; | |
176 | /* rEnE : maybe there are others I don't know off... */ | |
177 | ||
178 | static struct at1720_mca_adapters_struct at1720_mca_adapters[] __initdata = { | |
179 | { "Allied Telesys AT1720AT", 0x6410 }, | |
180 | { "Allied Telesys AT1720BT", 0x6413 }, | |
181 | { "Allied Telesys AT1720T", 0x6416 }, | |
182 | { NULL, 0 }, | |
183 | }; | |
184 | #endif | |
185 | ||
186 | /* Check for a network adaptor of this type, and return '0' iff one exists. | |
187 | If dev->base_addr == 0, probe all likely locations. | |
188 | If dev->base_addr == 1, always return failure. | |
189 | If dev->base_addr == 2, allocate space for the device and return success | |
190 | (detachable devices only). | |
191 | */ | |
192 | ||
193 | static int io = 0x260; | |
194 | ||
195 | static int irq; | |
196 | ||
197 | static void cleanup_card(struct net_device *dev) | |
198 | { | |
199 | #ifdef CONFIG_MCA_LEGACY | |
200 | struct net_local *lp = netdev_priv(dev); | |
201 | if (lp->mca_slot >= 0) | |
202 | mca_mark_as_unused(lp->mca_slot); | |
6aa20a22 | 203 | #endif |
1da177e4 LT |
204 | free_irq(dev->irq, NULL); |
205 | release_region(dev->base_addr, AT1700_IO_EXTENT); | |
206 | } | |
207 | ||
208 | struct net_device * __init at1700_probe(int unit) | |
209 | { | |
210 | struct net_device *dev = alloc_etherdev(sizeof(struct net_local)); | |
211 | unsigned *port; | |
212 | int err = 0; | |
213 | ||
214 | if (!dev) | |
215 | return ERR_PTR(-ENODEV); | |
216 | ||
217 | if (unit >= 0) { | |
218 | sprintf(dev->name, "eth%d", unit); | |
219 | netdev_boot_setup_check(dev); | |
220 | io = dev->base_addr; | |
221 | irq = dev->irq; | |
222 | } else { | |
223 | dev->base_addr = io; | |
224 | dev->irq = irq; | |
225 | } | |
226 | ||
1da177e4 LT |
227 | if (io > 0x1ff) { /* Check a single specified location. */ |
228 | err = at1700_probe1(dev, io); | |
229 | } else if (io != 0) { /* Don't probe at all. */ | |
230 | err = -ENXIO; | |
231 | } else { | |
232 | for (port = at1700_probe_list; *port; port++) { | |
233 | if (at1700_probe1(dev, *port) == 0) | |
234 | break; | |
235 | dev->irq = irq; | |
236 | } | |
237 | if (!*port) | |
238 | err = -ENODEV; | |
239 | } | |
240 | if (err) | |
241 | goto out; | |
242 | err = register_netdev(dev); | |
243 | if (err) | |
244 | goto out1; | |
245 | return dev; | |
246 | out1: | |
247 | cleanup_card(dev); | |
248 | out: | |
249 | free_netdev(dev); | |
250 | return ERR_PTR(err); | |
251 | } | |
252 | ||
cb0c7005 SH |
253 | static const struct net_device_ops at1700_netdev_ops = { |
254 | .ndo_open = net_open, | |
255 | .ndo_stop = net_close, | |
256 | .ndo_start_xmit = net_send_packet, | |
257 | .ndo_set_multicast_list = set_rx_mode, | |
258 | .ndo_tx_timeout = net_tx_timeout, | |
259 | .ndo_change_mtu = eth_change_mtu, | |
260 | .ndo_set_mac_address = eth_mac_addr, | |
261 | .ndo_validate_addr = eth_validate_addr, | |
262 | }; | |
263 | ||
1da177e4 LT |
264 | /* The Fujitsu datasheet suggests that the NIC be probed for by checking its |
265 | "signature", the default bit pattern after a reset. This *doesn't* work -- | |
266 | there is no way to reset the bus interface without a complete power-cycle! | |
267 | ||
268 | It turns out that ATI came to the same conclusion I did: the only thing | |
269 | that can be done is checking a few bits and then diving right into an | |
270 | EEPROM read. */ | |
271 | ||
272 | static int __init at1700_probe1(struct net_device *dev, int ioaddr) | |
273 | { | |
274 | char fmv_irqmap[4] = {3, 7, 10, 15}; | |
275 | char fmv_irqmap_pnp[8] = {3, 4, 5, 7, 9, 10, 11, 15}; | |
276 | char at1700_irqmap[8] = {3, 4, 5, 9, 10, 11, 14, 15}; | |
277 | unsigned int i, irq, is_fmv18x = 0, is_at1700 = 0; | |
278 | int slot, ret = -ENODEV; | |
279 | struct net_local *lp = netdev_priv(dev); | |
280 | ||
281 | if (!request_region(ioaddr, AT1700_IO_EXTENT, DRV_NAME)) | |
282 | return -EBUSY; | |
283 | ||
284 | /* Resetting the chip doesn't reset the ISA interface, so don't bother. | |
285 | That means we have to be careful with the register values we probe | |
286 | for. | |
287 | */ | |
288 | #ifdef notdef | |
289 | printk("at1700 probe at %#x, eeprom is %4.4x %4.4x %4.4x ctrl %4.4x.\n", | |
290 | ioaddr, read_eeprom(ioaddr, 4), read_eeprom(ioaddr, 5), | |
291 | read_eeprom(ioaddr, 6), inw(ioaddr + EEPROM_Ctrl)); | |
292 | #endif | |
293 | ||
294 | #ifdef CONFIG_MCA_LEGACY | |
295 | /* rEnE (rene@bss.lu): got this from 3c509 driver source , adapted for AT1720 */ | |
296 | ||
297 | /* Based on Erik Nygren's (nygren@mit.edu) 3c529 patch, heavily | |
298 | modified by Chris Beauregard (cpbeaure@csclub.uwaterloo.ca) | |
299 | to support standard MCA probing. */ | |
300 | ||
301 | /* redone for multi-card detection by ZP Gu (zpg@castle.net) */ | |
302 | /* now works as a module */ | |
303 | ||
304 | if (MCA_bus) { | |
305 | int j; | |
306 | int l_i; | |
307 | u_char pos3, pos4; | |
308 | ||
309 | for (j = 0; at1720_mca_adapters[j].name != NULL; j ++) { | |
310 | slot = 0; | |
311 | while (slot != MCA_NOTFOUND) { | |
6aa20a22 | 312 | |
1da177e4 LT |
313 | slot = mca_find_unused_adapter( at1720_mca_adapters[j].id, slot ); |
314 | if (slot == MCA_NOTFOUND) break; | |
315 | ||
316 | /* if we get this far, an adapter has been detected and is | |
317 | enabled */ | |
318 | ||
319 | pos3 = mca_read_stored_pos( slot, 3 ); | |
320 | pos4 = mca_read_stored_pos( slot, 4 ); | |
321 | ||
3b73e79b | 322 | for (l_i = 0; l_i < 8; l_i++) |
1da177e4 LT |
323 | if (( pos3 & 0x07) == at1700_ioaddr_pattern[l_i]) |
324 | break; | |
325 | ioaddr = at1700_mca_probe_list[l_i]; | |
6aa20a22 | 326 | |
1da177e4 LT |
327 | for (irq = 0; irq < 0x10; irq++) |
328 | if (((((pos4>>4) & 0x0f) | (pos3 & 0xf0)) & 0xff) == at1700_irq_pattern[irq]) | |
329 | break; | |
330 | ||
331 | /* probing for a card at a particular IO/IRQ */ | |
332 | if ((dev->irq && dev->irq != irq) || | |
333 | (dev->base_addr && dev->base_addr != ioaddr)) { | |
334 | slot++; /* probing next slot */ | |
335 | continue; | |
336 | } | |
337 | ||
338 | dev->irq = irq; | |
6aa20a22 | 339 | |
1da177e4 LT |
340 | /* claim the slot */ |
341 | mca_set_adapter_name( slot, at1720_mca_adapters[j].name ); | |
342 | mca_mark_as_used(slot); | |
343 | ||
344 | goto found; | |
345 | } | |
346 | } | |
347 | /* if we get here, we didn't find an MCA adapter - try ISA */ | |
348 | } | |
349 | #endif | |
350 | slot = -1; | |
351 | /* We must check for the EEPROM-config boards first, else accessing | |
352 | IOCONFIG0 will move the board! */ | |
353 | if (at1700_probe_list[inb(ioaddr + IOCONFIG1) & 0x07] == ioaddr | |
354 | && read_eeprom(ioaddr, 4) == 0x0000 | |
355 | && (read_eeprom(ioaddr, 5) & 0xff00) == 0xF400) | |
356 | is_at1700 = 1; | |
357 | else if (inb(ioaddr + SAPROM ) == 0x00 | |
358 | && inb(ioaddr + SAPROM + 1) == 0x00 | |
359 | && inb(ioaddr + SAPROM + 2) == 0x0e) | |
360 | is_fmv18x = 1; | |
361 | else { | |
362 | goto err_out; | |
363 | } | |
6aa20a22 | 364 | |
1da177e4 LT |
365 | #ifdef CONFIG_MCA_LEGACY |
366 | found: | |
367 | #endif | |
368 | ||
369 | /* Reset the internal state machines. */ | |
370 | outb(0, ioaddr + RESET); | |
371 | ||
372 | if (is_at1700) { | |
373 | irq = at1700_irqmap[(read_eeprom(ioaddr, 12)&0x04) | |
374 | | (read_eeprom(ioaddr, 0)>>14)]; | |
375 | } else { | |
376 | /* Check PnP mode for FMV-183/184/183A/184A. */ | |
377 | /* This PnP routine is very poor. IO and IRQ should be known. */ | |
378 | if (inb(ioaddr + CARDSTATUS1) & 0x20) { | |
379 | irq = dev->irq; | |
380 | for (i = 0; i < 8; i++) { | |
381 | if (irq == fmv_irqmap_pnp[i]) | |
382 | break; | |
383 | } | |
384 | if (i == 8) { | |
385 | goto err_mca; | |
386 | } | |
387 | } else { | |
388 | if (fmv18x_probe_list[inb(ioaddr + IOCONFIG) & 0x07] != ioaddr) | |
389 | goto err_mca; | |
390 | irq = fmv_irqmap[(inb(ioaddr + IOCONFIG)>>6) & 0x03]; | |
391 | } | |
392 | } | |
393 | ||
394 | printk("%s: %s found at %#3x, IRQ %d, address ", dev->name, | |
395 | is_at1700 ? "AT1700" : "FMV-18X", ioaddr, irq); | |
396 | ||
397 | dev->base_addr = ioaddr; | |
398 | dev->irq = irq; | |
399 | ||
400 | if (is_at1700) { | |
401 | for(i = 0; i < 3; i++) { | |
402 | unsigned short eeprom_val = read_eeprom(ioaddr, 4+i); | |
1da177e4 LT |
403 | ((unsigned short *)dev->dev_addr)[i] = ntohs(eeprom_val); |
404 | } | |
405 | } else { | |
406 | for(i = 0; i < 6; i++) { | |
407 | unsigned char val = inb(ioaddr + SAPROM + i); | |
1da177e4 LT |
408 | dev->dev_addr[i] = val; |
409 | } | |
410 | } | |
e174961c | 411 | printk("%pM", dev->dev_addr); |
1da177e4 LT |
412 | |
413 | /* The EEPROM word 12 bit 0x0400 means use regular 100 ohm 10baseT signals, | |
414 | rather than 150 ohm shielded twisted pair compensation. | |
415 | 0x0000 == auto-sense the interface | |
416 | 0x0800 == use TP interface | |
417 | 0x1800 == use coax interface | |
418 | */ | |
419 | { | |
420 | const char *porttype[] = {"auto-sense", "10baseT", "auto-sense", "10base2"}; | |
421 | if (is_at1700) { | |
422 | ushort setup_value = read_eeprom(ioaddr, 12); | |
423 | dev->if_port = setup_value >> 8; | |
424 | } else { | |
425 | ushort setup_value = inb(ioaddr + CARDSTATUS); | |
426 | switch (setup_value & 0x07) { | |
427 | case 0x01: /* 10base5 */ | |
428 | case 0x02: /* 10base2 */ | |
429 | dev->if_port = 0x18; break; | |
430 | case 0x04: /* 10baseT */ | |
431 | dev->if_port = 0x08; break; | |
432 | default: /* auto-sense */ | |
433 | dev->if_port = 0x00; break; | |
434 | } | |
435 | } | |
436 | printk(" %s interface.\n", porttype[(dev->if_port>>3) & 3]); | |
437 | } | |
438 | ||
439 | /* Set the configuration register 0 to 32K 100ns. byte-wide memory, 16 bit | |
440 | bus access, two 4K Tx queues, and disabled Tx and Rx. */ | |
441 | outb(0xda, ioaddr + CONFIG_0); | |
442 | ||
443 | /* Set the station address in bank zero. */ | |
444 | outb(0x00, ioaddr + CONFIG_1); | |
445 | for (i = 0; i < 6; i++) | |
446 | outb(dev->dev_addr[i], ioaddr + PORT_OFFSET(8 + i)); | |
447 | ||
448 | /* Switch to bank 1 and set the multicast table to accept none. */ | |
449 | outb(0x04, ioaddr + CONFIG_1); | |
450 | for (i = 0; i < 8; i++) | |
451 | outb(0x00, ioaddr + PORT_OFFSET(8 + i)); | |
452 | ||
453 | ||
454 | /* Switch to bank 2 */ | |
455 | /* Lock our I/O address, and set manual processing mode for 16 collisions. */ | |
456 | outb(0x08, ioaddr + CONFIG_1); | |
457 | outb(dev->if_port, ioaddr + MODE13); | |
458 | outb(0x00, ioaddr + COL16CNTL); | |
459 | ||
460 | if (net_debug) | |
461 | printk(version); | |
462 | ||
cb0c7005 | 463 | dev->netdev_ops = &at1700_netdev_ops; |
1da177e4 LT |
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) { | |
cba0516d JG |
473 | printk(KERN_ERR "AT1700 at %#3x is unusable due to a " |
474 | "conflict on IRQ %d.\n", | |
475 | ioaddr, irq); | |
1da177e4 LT |
476 | goto err_mca; |
477 | } | |
478 | ||
479 | return 0; | |
480 | ||
481 | err_mca: | |
482 | #ifdef CONFIG_MCA_LEGACY | |
483 | if (slot >= 0) | |
484 | mca_mark_as_unused(slot); | |
485 | #endif | |
486 | err_out: | |
487 | release_region(ioaddr, AT1700_IO_EXTENT); | |
488 | return ret; | |
489 | } | |
490 | ||
6aa20a22 | 491 | |
1da177e4 LT |
492 | /* EEPROM_Ctrl bits. */ |
493 | #define EE_SHIFT_CLK 0x40 /* EEPROM shift clock, in reg. 16. */ | |
494 | #define EE_CS 0x20 /* EEPROM chip select, in reg. 16. */ | |
495 | #define EE_DATA_WRITE 0x80 /* EEPROM chip data in, in reg. 17. */ | |
496 | #define EE_DATA_READ 0x80 /* EEPROM chip data out, in reg. 17. */ | |
497 | ||
498 | /* The EEPROM commands include the alway-set leading bit. */ | |
499 | #define EE_WRITE_CMD (5 << 6) | |
500 | #define EE_READ_CMD (6 << 6) | |
501 | #define EE_ERASE_CMD (7 << 6) | |
502 | ||
503 | static int __init read_eeprom(long ioaddr, int location) | |
504 | { | |
505 | int i; | |
506 | unsigned short retval = 0; | |
507 | long ee_addr = ioaddr + EEPROM_Ctrl; | |
508 | long ee_daddr = ioaddr + EEPROM_Data; | |
509 | int read_cmd = location | EE_READ_CMD; | |
510 | ||
511 | /* Shift the read command bits out. */ | |
512 | for (i = 9; i >= 0; i--) { | |
513 | short dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0; | |
514 | outb(EE_CS, ee_addr); | |
515 | outb(dataval, ee_daddr); | |
516 | outb(EE_CS | EE_SHIFT_CLK, ee_addr); /* EEPROM clock tick. */ | |
517 | } | |
518 | outb(EE_DATA_WRITE, ee_daddr); | |
519 | for (i = 16; i > 0; i--) { | |
520 | outb(EE_CS, ee_addr); | |
521 | outb(EE_CS | EE_SHIFT_CLK, ee_addr); | |
522 | retval = (retval << 1) | ((inb(ee_daddr) & EE_DATA_READ) ? 1 : 0); | |
523 | } | |
524 | ||
525 | /* Terminate the EEPROM access. */ | |
526 | outb(EE_CS, ee_addr); | |
527 | outb(EE_SHIFT_CLK, ee_addr); | |
528 | outb(0, ee_addr); | |
529 | return retval; | |
530 | } | |
531 | ||
6aa20a22 | 532 | |
1da177e4 LT |
533 | |
534 | static int net_open(struct net_device *dev) | |
535 | { | |
536 | struct net_local *lp = netdev_priv(dev); | |
537 | int ioaddr = dev->base_addr; | |
538 | ||
539 | /* Set the configuration register 0 to 32K 100ns. byte-wide memory, 16 bit | |
540 | bus access, and two 4K Tx queues. */ | |
541 | outb(0x5a, ioaddr + CONFIG_0); | |
542 | ||
543 | /* Powerup, switch to register bank 2, and enable the Rx and Tx. */ | |
544 | outb(0xe8, ioaddr + CONFIG_1); | |
545 | ||
546 | lp->tx_started = 0; | |
547 | lp->tx_queue_ready = 1; | |
548 | lp->rx_started = 0; | |
549 | lp->tx_queue = 0; | |
550 | lp->tx_queue_len = 0; | |
551 | ||
552 | /* Turn on hardware Tx and Rx interrupts. */ | |
553 | outb(0x82, ioaddr + TX_INTR); | |
554 | outb(0x81, ioaddr + RX_INTR); | |
555 | ||
556 | /* Enable the IRQ on boards of fmv18x it is feasible. */ | |
557 | if (lp->jumpered) { | |
558 | outb(0x80, ioaddr + IOCONFIG1); | |
559 | } | |
560 | ||
561 | netif_start_queue(dev); | |
562 | return 0; | |
563 | } | |
564 | ||
565 | static void net_tx_timeout (struct net_device *dev) | |
566 | { | |
567 | struct net_local *lp = netdev_priv(dev); | |
568 | int ioaddr = dev->base_addr; | |
569 | ||
570 | printk ("%s: transmit timed out with status %04x, %s?\n", dev->name, | |
571 | inw (ioaddr + STATUS), inb (ioaddr + TX_STATUS) & 0x80 | |
572 | ? "IRQ conflict" : "network cable problem"); | |
573 | printk ("%s: timeout registers: %04x %04x %04x %04x %04x %04x %04x %04x.\n", | |
574 | dev->name, inw(ioaddr + TX_STATUS), inw(ioaddr + TX_INTR), inw(ioaddr + TX_MODE), | |
575 | inw(ioaddr + CONFIG_0), inw(ioaddr + DATAPORT), inw(ioaddr + TX_START), | |
576 | inw(ioaddr + MODE13 - 1), inw(ioaddr + RX_CTRL)); | |
09f75cd7 | 577 | dev->stats.tx_errors++; |
1da177e4 LT |
578 | /* ToDo: We should try to restart the adaptor... */ |
579 | outw(0xffff, ioaddr + MODE24); | |
580 | outw (0xffff, ioaddr + TX_STATUS); | |
581 | outb (0x5a, ioaddr + CONFIG_0); | |
582 | outb (0xe8, ioaddr + CONFIG_1); | |
583 | outw (0x8182, ioaddr + TX_INTR); | |
584 | outb (0x00, ioaddr + TX_START); | |
585 | outb (0x03, ioaddr + COL16CNTL); | |
586 | ||
587 | dev->trans_start = jiffies; | |
588 | ||
589 | lp->tx_started = 0; | |
590 | lp->tx_queue_ready = 1; | |
591 | lp->rx_started = 0; | |
592 | lp->tx_queue = 0; | |
593 | lp->tx_queue_len = 0; | |
594 | ||
595 | netif_wake_queue(dev); | |
596 | } | |
597 | ||
598 | ||
61357325 SH |
599 | static netdev_tx_t net_send_packet (struct sk_buff *skb, |
600 | struct net_device *dev) | |
1da177e4 LT |
601 | { |
602 | struct net_local *lp = netdev_priv(dev); | |
603 | int ioaddr = dev->base_addr; | |
604 | short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN; | |
605 | short len = skb->len; | |
606 | unsigned char *buf = skb->data; | |
607 | static u8 pad[ETH_ZLEN]; | |
608 | ||
609 | netif_stop_queue (dev); | |
610 | ||
611 | /* We may not start transmitting unless we finish transferring | |
612 | a packet into the Tx queue. During executing the following | |
613 | codes we possibly catch a Tx interrupt. Thus we flag off | |
614 | tx_queue_ready, so that we prevent the interrupt routine | |
615 | (net_interrupt) to start transmitting. */ | |
616 | lp->tx_queue_ready = 0; | |
617 | { | |
618 | outw (length, ioaddr + DATAPORT); | |
619 | /* Packet data */ | |
620 | outsw (ioaddr + DATAPORT, buf, len >> 1); | |
621 | /* Check for dribble byte */ | |
622 | if (len & 1) { | |
623 | outw(skb->data[skb->len-1], ioaddr + DATAPORT); | |
624 | len++; | |
625 | } | |
626 | /* Check for packet padding */ | |
627 | if (length != skb->len) | |
628 | outsw(ioaddr + DATAPORT, pad, (length - len + 1) >> 1); | |
629 | ||
630 | lp->tx_queue++; | |
631 | lp->tx_queue_len += length + 2; | |
632 | } | |
633 | lp->tx_queue_ready = 1; | |
634 | ||
635 | if (lp->tx_started == 0) { | |
636 | /* If the Tx is idle, always trigger a transmit. */ | |
637 | outb (0x80 | lp->tx_queue, ioaddr + TX_START); | |
638 | lp->tx_queue = 0; | |
639 | lp->tx_queue_len = 0; | |
640 | dev->trans_start = jiffies; | |
641 | lp->tx_started = 1; | |
642 | netif_start_queue (dev); | |
643 | } else if (lp->tx_queue_len < 4096 - 1502) | |
644 | /* Yes, there is room for one more packet. */ | |
645 | netif_start_queue (dev); | |
646 | dev_kfree_skb (skb); | |
647 | ||
6ed10654 | 648 | return NETDEV_TX_OK; |
1da177e4 | 649 | } |
6aa20a22 | 650 | |
1da177e4 LT |
651 | /* The typical workload of the driver: |
652 | Handle the network interface interrupts. */ | |
7d12e780 | 653 | static irqreturn_t net_interrupt(int irq, void *dev_id) |
1da177e4 LT |
654 | { |
655 | struct net_device *dev = dev_id; | |
656 | struct net_local *lp; | |
657 | int ioaddr, status; | |
658 | int handled = 0; | |
659 | ||
660 | if (dev == NULL) { | |
661 | printk ("at1700_interrupt(): irq %d for unknown device.\n", irq); | |
662 | return IRQ_NONE; | |
663 | } | |
664 | ||
665 | ioaddr = dev->base_addr; | |
666 | lp = netdev_priv(dev); | |
6aa20a22 | 667 | |
1da177e4 | 668 | spin_lock (&lp->lock); |
6aa20a22 | 669 | |
1da177e4 LT |
670 | status = inw(ioaddr + TX_STATUS); |
671 | outw(status, ioaddr + TX_STATUS); | |
672 | ||
673 | if (net_debug > 4) | |
674 | printk("%s: Interrupt with status %04x.\n", dev->name, status); | |
675 | if (lp->rx_started == 0 && | |
676 | (status & 0xff00 || (inb(ioaddr + RX_MODE) & 0x40) == 0)) { | |
677 | /* Got a packet(s). | |
678 | We cannot execute net_rx more than once at the same time for | |
679 | the same device. During executing net_rx, we possibly catch a | |
680 | Tx interrupt. Thus we flag on rx_started, so that we prevent | |
681 | the interrupt routine (net_interrupt) to dive into net_rx | |
682 | again. */ | |
683 | handled = 1; | |
684 | lp->rx_started = 1; | |
685 | outb(0x00, ioaddr + RX_INTR); /* Disable RX intr. */ | |
686 | net_rx(dev); | |
687 | outb(0x81, ioaddr + RX_INTR); /* Enable RX intr. */ | |
688 | lp->rx_started = 0; | |
689 | } | |
690 | if (status & 0x00ff) { | |
691 | handled = 1; | |
692 | if (status & 0x02) { | |
693 | /* More than 16 collisions occurred */ | |
694 | if (net_debug > 4) | |
695 | printk("%s: 16 Collision occur during Txing.\n", dev->name); | |
696 | /* Cancel sending a packet. */ | |
697 | outb(0x03, ioaddr + COL16CNTL); | |
09f75cd7 | 698 | dev->stats.collisions++; |
1da177e4 LT |
699 | } |
700 | if (status & 0x82) { | |
09f75cd7 | 701 | dev->stats.tx_packets++; |
1da177e4 LT |
702 | /* The Tx queue has any packets and is not being |
703 | transferred a packet from the host, start | |
704 | transmitting. */ | |
705 | if (lp->tx_queue && lp->tx_queue_ready) { | |
706 | outb(0x80 | lp->tx_queue, ioaddr + TX_START); | |
707 | lp->tx_queue = 0; | |
708 | lp->tx_queue_len = 0; | |
709 | dev->trans_start = jiffies; | |
710 | netif_wake_queue (dev); | |
711 | } else { | |
712 | lp->tx_started = 0; | |
713 | netif_wake_queue (dev); | |
714 | } | |
715 | } | |
716 | } | |
717 | ||
718 | spin_unlock (&lp->lock); | |
719 | return IRQ_RETVAL(handled); | |
720 | } | |
721 | ||
722 | /* We have a good packet(s), get it/them out of the buffers. */ | |
723 | static void | |
724 | net_rx(struct net_device *dev) | |
725 | { | |
1da177e4 LT |
726 | int ioaddr = dev->base_addr; |
727 | int boguscount = 5; | |
728 | ||
729 | while ((inb(ioaddr + RX_MODE) & 0x40) == 0) { | |
730 | ushort status = inw(ioaddr + DATAPORT); | |
731 | ushort pkt_len = inw(ioaddr + DATAPORT); | |
732 | ||
733 | if (net_debug > 4) | |
734 | printk("%s: Rxing packet mode %02x status %04x.\n", | |
735 | dev->name, inb(ioaddr + RX_MODE), status); | |
736 | #ifndef final_version | |
737 | if (status == 0) { | |
738 | outb(0x05, ioaddr + RX_CTRL); | |
739 | break; | |
740 | } | |
741 | #endif | |
742 | ||
743 | if ((status & 0xF0) != 0x20) { /* There was an error. */ | |
09f75cd7 JG |
744 | dev->stats.rx_errors++; |
745 | if (status & 0x08) dev->stats.rx_length_errors++; | |
746 | if (status & 0x04) dev->stats.rx_frame_errors++; | |
747 | if (status & 0x02) dev->stats.rx_crc_errors++; | |
748 | if (status & 0x01) dev->stats.rx_over_errors++; | |
1da177e4 LT |
749 | } else { |
750 | /* Malloc up new buffer. */ | |
751 | struct sk_buff *skb; | |
752 | ||
753 | if (pkt_len > 1550) { | |
754 | printk("%s: The AT1700 claimed a very large packet, size %d.\n", | |
755 | dev->name, pkt_len); | |
756 | /* Prime the FIFO and then flush the packet. */ | |
757 | inw(ioaddr + DATAPORT); inw(ioaddr + DATAPORT); | |
758 | outb(0x05, ioaddr + RX_CTRL); | |
09f75cd7 | 759 | dev->stats.rx_errors++; |
1da177e4 LT |
760 | break; |
761 | } | |
762 | skb = dev_alloc_skb(pkt_len+3); | |
763 | if (skb == NULL) { | |
764 | printk("%s: Memory squeeze, dropping packet (len %d).\n", | |
765 | dev->name, pkt_len); | |
766 | /* Prime the FIFO and then flush the packet. */ | |
767 | inw(ioaddr + DATAPORT); inw(ioaddr + DATAPORT); | |
768 | outb(0x05, ioaddr + RX_CTRL); | |
09f75cd7 | 769 | dev->stats.rx_dropped++; |
1da177e4 LT |
770 | break; |
771 | } | |
1da177e4 LT |
772 | skb_reserve(skb,2); |
773 | ||
774 | insw(ioaddr + DATAPORT, skb_put(skb,pkt_len), (pkt_len + 1) >> 1); | |
775 | skb->protocol=eth_type_trans(skb, dev); | |
776 | netif_rx(skb); | |
09f75cd7 JG |
777 | dev->stats.rx_packets++; |
778 | dev->stats.rx_bytes += pkt_len; | |
1da177e4 LT |
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 | ||
1da177e4 LT |
827 | /* |
828 | Set the multicast/promiscuous mode for this adaptor. | |
829 | */ | |
830 | ||
831 | static void | |
832 | set_rx_mode(struct net_device *dev) | |
833 | { | |
834 | int ioaddr = dev->base_addr; | |
835 | struct net_local *lp = netdev_priv(dev); | |
836 | unsigned char mc_filter[8]; /* Multicast hash filter */ | |
837 | unsigned long flags; | |
1da177e4 LT |
838 | |
839 | if (dev->flags & IFF_PROMISC) { | |
1da177e4 LT |
840 | memset(mc_filter, 0xff, sizeof(mc_filter)); |
841 | outb(3, ioaddr + RX_MODE); /* Enable promiscuous mode */ | |
842 | } else if (dev->mc_count > MC_FILTERBREAK | |
843 | || (dev->flags & IFF_ALLMULTI)) { | |
844 | /* Too many to filter perfectly -- accept all multicasts. */ | |
845 | memset(mc_filter, 0xff, sizeof(mc_filter)); | |
846 | outb(2, ioaddr + RX_MODE); /* Use normal mode. */ | |
847 | } else if (dev->mc_count == 0) { | |
848 | memset(mc_filter, 0x00, sizeof(mc_filter)); | |
849 | outb(1, ioaddr + RX_MODE); /* Ignore almost all multicasts. */ | |
850 | } else { | |
851 | struct dev_mc_list *mclist; | |
852 | int i; | |
853 | ||
854 | memset(mc_filter, 0, sizeof(mc_filter)); | |
855 | for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count; | |
856 | i++, mclist = mclist->next) { | |
857 | unsigned int bit = | |
858 | ether_crc_le(ETH_ALEN, mclist->dmi_addr) >> 26; | |
859 | mc_filter[bit >> 3] |= (1 << bit); | |
860 | } | |
861 | outb(0x02, ioaddr + RX_MODE); /* Use normal mode. */ | |
862 | } | |
863 | ||
864 | spin_lock_irqsave (&lp->lock, flags); | |
865 | if (memcmp(mc_filter, lp->mc_filter, sizeof(mc_filter))) { | |
1256f739 | 866 | int i; |
1da177e4 LT |
867 | int saved_bank = inw(ioaddr + CONFIG_0); |
868 | /* Switch to bank 1 and set the multicast table. */ | |
869 | outw((saved_bank & ~0x0C00) | 0x0480, ioaddr + CONFIG_0); | |
870 | for (i = 0; i < 8; i++) | |
871 | outb(mc_filter[i], ioaddr + PORT_OFFSET(8 + i)); | |
872 | memcpy(lp->mc_filter, mc_filter, sizeof(mc_filter)); | |
873 | outw(saved_bank, ioaddr + CONFIG_0); | |
874 | } | |
875 | spin_unlock_irqrestore (&lp->lock, flags); | |
876 | return; | |
877 | } | |
878 | ||
879 | #ifdef MODULE | |
880 | static struct net_device *dev_at1700; | |
881 | ||
882 | module_param(io, int, 0); | |
883 | module_param(irq, int, 0); | |
884 | module_param(net_debug, int, 0); | |
885 | MODULE_PARM_DESC(io, "AT1700/FMV18X I/O base address"); | |
886 | MODULE_PARM_DESC(irq, "AT1700/FMV18X IRQ number"); | |
887 | MODULE_PARM_DESC(net_debug, "AT1700/FMV18X debug level (0-6)"); | |
888 | ||
5250f332 | 889 | static int __init at1700_module_init(void) |
1da177e4 LT |
890 | { |
891 | if (io == 0) | |
892 | printk("at1700: You should not use auto-probing with insmod!\n"); | |
893 | dev_at1700 = at1700_probe(-1); | |
894 | if (IS_ERR(dev_at1700)) | |
895 | return PTR_ERR(dev_at1700); | |
896 | return 0; | |
897 | } | |
898 | ||
5250f332 | 899 | static void __exit at1700_module_exit(void) |
1da177e4 LT |
900 | { |
901 | unregister_netdev(dev_at1700); | |
902 | cleanup_card(dev_at1700); | |
903 | free_netdev(dev_at1700); | |
904 | } | |
5250f332 JS |
905 | module_init(at1700_module_init); |
906 | module_exit(at1700_module_exit); | |
1da177e4 LT |
907 | #endif /* MODULE */ |
908 | MODULE_LICENSE("GPL"); |