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