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