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 Public License, incorporated herein by reference.
10
11 The author may be reached as becker@CESDIS.gsfc.nasa.gov, or C/O
12 Center of Excellence in Space Data and Information Sciences
13 Code 930.5, Goddard Space Flight Center, Greenbelt MD 20771
14
15 This is a device driver for the Allied Telesis AT1700, and
16 Fujitsu FMV-181/182/181A/182A/183/184/183A/184A, which are
17 straight-forward Fujitsu MB86965 implementations.
18
19 Modification for Fujitsu FMV-18X cards is done by Yutaka Tamiya
20 (tamy@flab.fujitsu.co.jp).
21
22 Sources:
23 The Fujitsu MB86965 datasheet.
24
25 After the initial version of this driver was written Gerry Sawkins of
26 ATI provided their EEPROM configuration code header file.
27 Thanks to NIIBE Yutaka <gniibe@mri.co.jp> for bug fixes.
28
29 MCA bus (AT1720) support by Rene Schmit <rene@bss.lu>
30
31 Bugs:
32 The MB86965 has a design flaw that makes all probes unreliable. Not
33 only is it difficult to detect, it also moves around in I/O space in
34 response to inb()s from other device probes!
35 */
36
37 static const char *version =
38 "at1700.c:v1.15 4/7/98 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
39
40 #include <linux/config.h>
41 #include <linux/module.h>
42
43 #include <linux/kernel.h>
44 #include <linux/sched.h>
45 #include <linux/types.h>
46 #include <linux/fcntl.h>
47 #include <linux/interrupt.h>
48 #include <linux/ptrace.h>
49 #include <linux/ioport.h>
50 #include <linux/in.h>
51 #include <linux/malloc.h>
52 #include <linux/string.h>
53 #include <linux/init.h>
54 #include <asm/system.h>
55 #include <asm/bitops.h>
56 #include <asm/io.h>
57 #include <asm/dma.h>
58 #include <linux/errno.h>
59
60 #include <linux/netdevice.h>
61 #include <linux/etherdevice.h>
62 #include <linux/skbuff.h>
63
64 #include <linux/mca.h>
65
66 /* Tunable parameters. */
67
68 /* When to switch from the 64-entry multicast filter to Rx-all-multicast. */
69 #define MC_FILTERBREAK 64
70
71 /* These unusual address orders are used to verify the CONFIG register. */
72
73 static int fmv18x_probe_list[] = {
74 0x220, 0x240, 0x260, 0x280, 0x2a0, 0x2c0, 0x300, 0x340, 0
75 };
76
77 /*
78 * ISA
79 */
80
81 static int at1700_probe_list[] = {
82 0x260, 0x280, 0x2a0, 0x240, 0x340, 0x320, 0x380, 0x300, 0
83 };
84
85 /*
86 * MCA
87 */
88 #ifdef CONFIG_MCA
89 static int at1700_ioaddr_pattern[] = {
90 0x00, 0x04, 0x01, 0x05, 0x02, 0x06, 0x03, 0x07
91 };
92
93 static int at1700_mca_probe_list[] = {
94 0x400, 0x1400, 0x2400, 0x3400, 0x4400, 0x5400, 0x6400, 0x7400, 0
95 };
96
97 static int at1700_irq_pattern[] = {
98 0x00, 0x00, 0x00, 0x30, 0x70, 0xb0, 0x00, 0x00,
99 0x00, 0xf0, 0x34, 0x74, 0xb4, 0x00, 0x00, 0xf4, 0x00
100 };
101 #endif
102
103 /* use 0 for production, 1 for verification, >2 for debug */
104 #ifndef NET_DEBUG
105 #define NET_DEBUG 1
106 #endif
107 static unsigned int net_debug = NET_DEBUG;
108
109 typedef unsigned char uchar;
110
111 /* Information that need to be kept for each board. */
112 struct net_local {
113 struct net_device_stats stats;
114 spinlock_t lock;
115 unsigned char mc_filter[8];
116 uint jumpered:1; /* Set iff the board has jumper config. */
117 uint tx_started:1; /* Packets are on the Tx queue. */
118 uint tx_queue_ready:1; /* Tx queue is ready to be sent. */
119 uint rx_started:1; /* Packets are Rxing. */
120 uchar tx_queue; /* Number of packet on the Tx queue. */
121 char mca_slot; /* -1 means ISA */
122 ushort tx_queue_len; /* Current length of the Tx queue. */
123 };
124
125
126 /* Offsets from the base address. */
127 #define STATUS 0
128 #define TX_STATUS 0
129 #define RX_STATUS 1
130 #define TX_INTR 2 /* Bit-mapped interrupt enable registers. */
131 #define RX_INTR 3
132 #define TX_MODE 4
133 #define RX_MODE 5
134 #define CONFIG_0 6 /* Misc. configuration settings. */
135 #define CONFIG_1 7
136 /* Run-time register bank 2 definitions. */
137 #define DATAPORT 8 /* Word-wide DMA or programmed-I/O dataport. */
138 #define TX_START 10
139 #define COL16CNTL 11 /* Controll Reg for 16 collisions */
140 #define MODE13 13
141 /* Configuration registers only on the '865A/B chips. */
142 #define EEPROM_Ctrl 16
143 #define EEPROM_Data 17
144 #define CARDSTATUS 16 /* FMV-18x Card Status */
145 #define CARDSTATUS1 17 /* FMV-18x Card Status */
146 #define IOCONFIG 18 /* Either read the jumper, or move the I/O. */
147 #define IOCONFIG1 19
148 #define SAPROM 20 /* The station address PROM, if no EEPROM. */
149 #define RESET 31 /* Write to reset some parts of the chip. */
150 #define AT1700_IO_EXTENT 32
151
152 #define TX_TIMEOUT 10
153
154
155 /* Index to functions, as function prototypes. */
156
157 extern int at1700_probe(struct net_device *dev);
158
159 static int at1700_probe1(struct net_device *dev, int ioaddr);
160 static int read_eeprom(int 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);
163 static void net_interrupt(int irq, void *dev_id, struct pt_regs *regs);
164 static void net_rx(struct net_device *dev);
165 static int net_close(struct net_device *dev);
166 static struct net_device_stats *net_get_stats(struct net_device *dev);
167 static void set_rx_mode(struct net_device *dev);
168 static void net_tx_timeout (struct net_device *dev);
169
170
171 #ifdef CONFIG_MCA
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 struct at1720_mca_adapters_struct at1720_mca_adapters[] = {
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 '' 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 int __init at1700_probe(struct net_device *dev)
194 {
195 int i;
196 int base_addr = dev->base_addr;
197
198 SET_MODULE_OWNER(dev);
199
200 if (base_addr > 0x1ff) /* Check a single specified location. */
201 return at1700_probe1(dev, base_addr);
202 else if (base_addr != 0) /* Don't probe at all. */
203 return -ENXIO;
204
205 for (i = 0; at1700_probe_list[i]; i++) {
206 int ioaddr = at1700_probe_list[i];
207 if (at1700_probe1(dev, ioaddr) == 0)
208 return 0;
209 }
210 return -ENODEV;
211 }
212
213 /* The Fujitsu datasheet suggests that the NIC be probed for by checking its
214 "signature", the default bit pattern after a reset. This *doesn't* work --
215 there is no way to reset the bus interface without a complete power-cycle!
216
217 It turns out that ATI came to the same conclusion I did: the only thing
218 that can be done is checking a few bits and then diving right into an
219 EEPROM read. */
220
221 static int at1700_probe1(struct net_device *dev, int ioaddr)
222 {
223 char fmv_irqmap[4] = {3, 7, 10, 15};
224 char fmv_irqmap_pnp[8] = {3, 4, 5, 7, 9, 10, 11, 15};
225 char at1700_irqmap[8] = {3, 4, 5, 9, 10, 11, 14, 15};
226 unsigned int i, irq, is_fmv18x = 0, is_at1700 = 0;
227 int slot, ret = -ENODEV;
228 struct net_local *lp;
229
230 if (!request_region(ioaddr, AT1700_IO_EXTENT, dev->name))
231 return -EBUSY;
232
233 /* Resetting the chip doesn't reset the ISA interface, so don't bother.
234 That means we have to be careful with the register values we probe for.
235 */
236 #ifdef notdef
237 printk("at1700 probe at %#x, eeprom is %4.4x %4.4x %4.4x ctrl %4.4x.\n",
238 ioaddr, read_eeprom(ioaddr, 4), read_eeprom(ioaddr, 5),
239 read_eeprom(ioaddr, 6), inw(ioaddr + EEPROM_Ctrl));
240 #endif
241
242 #ifdef CONFIG_MCA
243 /* rEnE (rene@bss.lu): got this from 3c509 driver source , adapted for AT1720 */
244
245 /* Based on Erik Nygren's (nygren@mit.edu) 3c529 patch, heavily
246 modified by Chris Beauregard (cpbeaure@csclub.uwaterloo.ca)
247 to support standard MCA probing. */
248
249 /* redone for multi-card detection by ZP Gu (zpg@castle.net) */
250 /* now works as a module */
251
252 if (MCA_bus) {
253 int j;
254 int l_i;
255 u_char pos3, pos4;
256
257 for (j = 0; at1720_mca_adapters[j].name != NULL; j ++) {
258 slot = 0;
259 while (slot != MCA_NOTFOUND) {
260
261 slot = mca_find_unused_adapter( at1720_mca_adapters[j].id, slot );
262 if (slot == MCA_NOTFOUND) break;
263
264 /* if we get this far, an adapter has been detected and is
265 enabled */
266
267 pos3 = mca_read_stored_pos( slot, 3 );
268 pos4 = mca_read_stored_pos( slot, 4 );
269
270 for (l_i = 0; l_i < 0x09; l_i++)
271 if (( pos3 & 0x07) == at1700_ioaddr_pattern[l_i])
272 break;
273 ioaddr = at1700_mca_probe_list[l_i];
274
275 for (irq = 0; irq < 0x10; irq++)
276 if (((((pos4>>4) & 0x0f) | (pos3 & 0xf0)) & 0xff) == at1700_irq_pattern[irq])
277 break;
278
279 /* probing for a card at a particular IO/IRQ */
280 if (dev &&
281 ((dev->irq && dev->irq != irq) ||
282 (dev->base_addr && dev->base_addr != ioaddr))) {
283 slot++; /* probing next slot */
284 continue;
285 }
286
287 if (dev)
288 dev->irq = irq;
289
290 /* claim the slot */
291 mca_set_adapter_name( slot, at1720_mca_adapters[j].name );
292 mca_mark_as_used(slot);
293
294 goto found;
295 }
296 }
297 /* if we get here, we didn't find an MCA adapter - try ISA */
298 }
299 #endif
300 slot = -1;
301 /* We must check for the EEPROM-config boards first, else accessing
302 IOCONFIG0 will move the board! */
303 if (at1700_probe_list[inb(ioaddr + IOCONFIG1) & 0x07] == ioaddr
304 && read_eeprom(ioaddr, 4) == 0x0000
305 && (read_eeprom(ioaddr, 5) & 0xff00) == 0xF400)
306 is_at1700 = 1;
307 else if (inb(ioaddr + SAPROM ) == 0x00
308 && inb(ioaddr + SAPROM + 1) == 0x00
309 && inb(ioaddr + SAPROM + 2) == 0x0e)
310 is_fmv18x = 1;
311 else {
312 ret = -ENODEV;
313 goto err_out;
314 }
315
316 #ifdef CONFIG_MCA
317 found:
318 #endif
319
320 /* Reset the internal state machines. */
321 outb(0, ioaddr + RESET);
322
323 if (is_at1700)
324 irq = at1700_irqmap[(read_eeprom(ioaddr, 12)&0x04)
325 | (read_eeprom(ioaddr, 0)>>14)];
326 else {
327 /* Check PnP mode for FMV-183/184/183A/184A. */
328 /* This PnP routine is very poor. IO and IRQ should be known. */
329 if (inb(ioaddr + CARDSTATUS1) & 0x20) {
330 irq = dev->irq;
331 for (i = 0; i < 8; i++) {
332 if (irq == fmv_irqmap_pnp[i])
333 break;
334 }
335 if (i == 8) {
336 goto err_out;
337 ret = -ENODEV;
338 }
339 } else {
340 if (fmv18x_probe_list[inb(ioaddr + IOCONFIG) & 0x07] != ioaddr)
341 return -ENODEV;
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
473 static int read_eeprom(int ioaddr, int location)
474 {
475 int i;
476 unsigned short retval = 0;
477 int ee_addr = ioaddr + EEPROM_Ctrl;
478 int 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
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
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
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 unsigned char *buf = skb->data;
580
581 netif_stop_queue (dev);
582
583 /* We may not start transmitting unless we finish transferring
584 a packet into the Tx queue. During executing the following
585 codes we possibly catch a Tx interrupt. Thus we flag off
586 tx_queue_ready, so that we prevent the interrupt routine
587 (net_interrupt) to start transmitting. */
588 lp->tx_queue_ready = 0;
589 {
590 outw (length, ioaddr + DATAPORT);
591 outsw (ioaddr + DATAPORT, buf, (length + 1) >> 1);
592
593 lp->tx_queue++;
594 lp->tx_queue_len += length + 2;
595 }
596 lp->tx_queue_ready = 1;
597
598 if (lp->tx_started == 0) {
599 /* If the Tx is idle, always trigger a transmit. */
600 outb (0x80 | lp->tx_queue, ioaddr + TX_START);
601 lp->tx_queue = 0;
602 lp->tx_queue_len = 0;
603 dev->trans_start = jiffies;
604 lp->tx_started = 1;
605 netif_start_queue (dev);
606 } else if (lp->tx_queue_len < 4096 - 1502)
607 /* Yes, there is room for one more packet. */
608 netif_start_queue (dev);
609 dev_kfree_skb (skb);
610
611 return 0;
612 }
613
614 /* The typical workload of the driver:
615 Handle the network interface interrupts. */
616 static void
617 net_interrupt(int irq, void *dev_id, struct pt_regs *regs)
618 {
619 struct net_device *dev = dev_id;
620 struct net_local *lp;
621 int ioaddr, status;
622
623 if (dev == NULL) {
624 printk ("at1700_interrupt(): irq %d for unknown device.\n", irq);
625 return;
626 }
627
628 ioaddr = dev->base_addr;
629 lp = (struct net_local *)dev->priv;
630
631 spin_lock (&lp->lock);
632
633 status = inw(ioaddr + TX_STATUS);
634 outw(status, ioaddr + TX_STATUS);
635
636 if (net_debug > 4)
637 printk("%s: Interrupt with status %04x.\n", dev->name, status);
638 if (lp->rx_started == 0 &&
639 (status & 0xff00 || (inb(ioaddr + RX_MODE) & 0x40) == 0)) {
640 /* Got a packet(s).
641 We cannot execute net_rx more than once at the same time for
642 the same device. During executing net_rx, we possibly catch a
643 Tx interrupt. Thus we flag on rx_started, so that we prevent
644 the interrupt routine (net_interrupt) to dive into net_rx
645 again. */
646 lp->rx_started = 1;
647 outb(0x00, ioaddr + RX_INTR); /* Disable RX intr. */
648 net_rx(dev);
649 outb(0x81, ioaddr + RX_INTR); /* Enable RX intr. */
650 lp->rx_started = 0;
651 }
652 if (status & 0x00ff) {
653 if (status & 0x02) {
654 /* More than 16 collisions occurred */
655 if (net_debug > 4)
656 printk("%s: 16 Collision occur during Txing.\n", dev->name);
657 /* Cancel sending a packet. */
658 outb(0x03, ioaddr + COL16CNTL);
659 lp->stats.collisions++;
660 }
661 if (status & 0x82) {
662 lp->stats.tx_packets++;
663 /* The Tx queue has any packets and is not being
664 transferred a packet from the host, start
665 transmitting. */
666 if (lp->tx_queue && lp->tx_queue_ready) {
667 outb(0x80 | lp->tx_queue, ioaddr + TX_START);
668 lp->tx_queue = 0;
669 lp->tx_queue_len = 0;
670 dev->trans_start = jiffies;
671 netif_wake_queue (dev);
672 } else {
673 lp->tx_started = 0;
674 netif_wake_queue (dev);
675 }
676 }
677 }
678
679 spin_unlock (&lp->lock);
680 return;
681 }
682
683 /* We have a good packet(s), get it/them out of the buffers. */
684 static void
685 net_rx(struct net_device *dev)
686 {
687 struct net_local *lp = (struct net_local *)dev->priv;
688 int ioaddr = dev->base_addr;
689 int boguscount = 5;
690
691 while ((inb(ioaddr + RX_MODE) & 0x40) == 0) {
692 ushort status = inw(ioaddr + DATAPORT);
693 ushort pkt_len = inw(ioaddr + DATAPORT);
694
695 if (net_debug > 4)
696 printk("%s: Rxing packet mode %02x status %04x.\n",
697 dev->name, inb(ioaddr + RX_MODE), status);
698 #ifndef final_version
699 if (status == 0) {
700 outb(0x05, ioaddr + 14);
701 break;
702 }
703 #endif
704
705 if ((status & 0xF0) != 0x20) { /* There was an error. */
706 lp->stats.rx_errors++;
707 if (status & 0x08) lp->stats.rx_length_errors++;
708 if (status & 0x04) lp->stats.rx_frame_errors++;
709 if (status & 0x02) lp->stats.rx_crc_errors++;
710 if (status & 0x01) lp->stats.rx_over_errors++;
711 } else {
712 /* Malloc up new buffer. */
713 struct sk_buff *skb;
714
715 if (pkt_len > 1550) {
716 printk("%s: The AT1700 claimed a very large packet, size %d.\n",
717 dev->name, pkt_len);
718 /* Prime the FIFO and then flush the packet. */
719 inw(ioaddr + DATAPORT); inw(ioaddr + DATAPORT);
720 outb(0x05, ioaddr + 14);
721 lp->stats.rx_errors++;
722 break;
723 }
724 skb = dev_alloc_skb(pkt_len+3);
725 if (skb == NULL) {
726 printk("%s: Memory squeeze, dropping packet (len %d).\n",
727 dev->name, pkt_len);
728 /* Prime the FIFO and then flush the packet. */
729 inw(ioaddr + DATAPORT); inw(ioaddr + DATAPORT);
730 outb(0x05, ioaddr + 14);
731 lp->stats.rx_dropped++;
732 break;
733 }
734 skb->dev = dev;
735 skb_reserve(skb,2);
736
737 insw(ioaddr + DATAPORT, skb_put(skb,pkt_len), (pkt_len + 1) >> 1);
738 skb->protocol=eth_type_trans(skb, dev);
739 netif_rx(skb);
740 lp->stats.rx_packets++;
741 }
742 if (--boguscount <= 0)
743 break;
744 }
745
746 /* If any worth-while packets have been received, dev_rint()
747 has done a mark_bh(NET_BH) for us and will work on them
748 when we get to the bottom-half routine. */
749 {
750 int i;
751 for (i = 0; i < 20; i++) {
752 if ((inb(ioaddr + RX_MODE) & 0x40) == 0x40)
753 break;
754 inw(ioaddr + DATAPORT); /* dummy status read */
755 outb(0x05, ioaddr + 14);
756 }
757
758 if (net_debug > 5)
759 printk("%s: Exint Rx packet with mode %02x after %d ticks.\n",
760 dev->name, inb(ioaddr + RX_MODE), i);
761 }
762 return;
763 }
764
765 /* The inverse routine to net_open(). */
766 static int net_close(struct net_device *dev)
767 {
768 struct net_local *lp = (struct net_local *)dev->priv;
769 int ioaddr = dev->base_addr;
770
771 netif_stop_queue(dev);
772
773 /* Set configuration register 0 to disable Tx and Rx. */
774 outb(0xda, ioaddr + CONFIG_0);
775
776 /* No statistic counters on the chip to update. */
777
778 /* Disable the IRQ on boards of fmv18x where it is feasible. */
779 if (lp->jumpered) {
780 outb(0x00, ioaddr + IOCONFIG1);
781 free_irq(dev->irq, dev);
782 }
783
784 /* Power-down the chip. Green, green, green! */
785 outb(0x00, ioaddr + CONFIG_1);
786 return 0;
787 }
788
789 /* Get the current statistics.
790 This may be called with the card open or closed.
791 There are no on-chip counters, so this function is trivial.
792 */
793 static struct net_device_stats *
794 net_get_stats(struct net_device *dev)
795 {
796 struct net_local *lp = (struct net_local *)dev->priv;
797 return &lp->stats;
798 }
799
800 /*
801 Set the multicast/promiscuous mode for this adaptor.
802 */
803
804 /* The little-endian AUTODIN II ethernet CRC calculation.
805 N.B. Do not use for bulk data, use a table-based routine instead.
806 This is common code and should be moved to net/core/crc.c */
807 static unsigned const ethernet_polynomial_le = 0xedb88320U;
808 static inline unsigned ether_crc_le(int length, unsigned char *data)
809 {
810 unsigned int crc = 0xffffffff; /* Initial value. */
811 while(--length >= 0) {
812 unsigned char current_octet = *data++;
813 int bit;
814 for (bit = 8; --bit >= 0; current_octet >>= 1) {
815 if ((crc ^ current_octet) & 1) {
816 crc >>= 1;
817 crc ^= ethernet_polynomial_le;
818 } else
819 crc >>= 1;
820 }
821 }
822 return crc;
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 = (struct net_local *)dev->priv;
830 unsigned char mc_filter[8]; /* Multicast hash filter */
831 long flags;
832 int i;
833
834 if (dev->flags & IFF_PROMISC) {
835 /* Unconditionally log net taps. */
836 printk("%s: Promiscuous mode enabled.\n", dev->name);
837 memset(mc_filter, 0xff, sizeof(mc_filter));
838 outb(3, ioaddr + RX_MODE); /* Enable promiscuous mode */
839 } else if (dev->mc_count > MC_FILTERBREAK
840 || (dev->flags & IFF_ALLMULTI)) {
841 /* Too many to filter perfectly -- accept all multicasts. */
842 memset(mc_filter, 0xff, sizeof(mc_filter));
843 outb(2, ioaddr + RX_MODE); /* Use normal mode. */
844 } else if (dev->mc_count == 0) {
845 memset(mc_filter, 0x00, sizeof(mc_filter));
846 outb(1, ioaddr + RX_MODE); /* Ignore almost all multicasts. */
847 } else {
848 struct dev_mc_list *mclist;
849 int i;
850
851 memset(mc_filter, 0, sizeof(mc_filter));
852 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
853 i++, mclist = mclist->next)
854 set_bit(ether_crc_le(ETH_ALEN, mclist->dmi_addr) >> 26,
855 mc_filter);
856 }
857
858 save_flags(flags);
859 cli();
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 + 8 + i);
866 memcpy(lp->mc_filter, mc_filter, sizeof(mc_filter));
867 outw(saved_bank, ioaddr + CONFIG_0);
868 }
869 restore_flags(flags);
870 return;
871 }
872
873 #ifdef MODULE
874 static struct net_device dev_at1700;
875 static int io = 0x260;
876 static int irq;
877
878 MODULE_PARM(io, "i");
879 MODULE_PARM(irq, "i");
880 MODULE_PARM(net_debug, "i");
881
882 int init_module(void)
883 {
884 if (io == 0)
885 printk("at1700: You should not use auto-probing with insmod!\n");
886 dev_at1700.base_addr = io;
887 dev_at1700.irq = irq;
888 dev_at1700.init = at1700_probe;
889 if (register_netdev(&dev_at1700) != 0) {
890 printk("at1700: register_netdev() returned non-zero.\n");
891 return -EIO;
892 }
893 return 0;
894 }
895
896 void
897 cleanup_module(void)
898 {
899 #ifdef CONFIG_MCA
900 struct net_local *lp = dev_at1700.priv;
901 if(lp->mca_slot)
902 {
903 mca_mark_as_unused(lp->mca_slot);
904 }
905 #endif
906 unregister_netdev(&dev_at1700);
907 kfree(dev_at1700.priv);
908 dev_at1700.priv = NULL;
909
910 /* If we don't do this, we can't re-insmod it later. */
911 free_irq(dev_at1700.irq, NULL);
912 release_region(dev_at1700.base_addr, AT1700_IO_EXTENT);
913 }
914 #endif /* MODULE */
915
916 /*
917 * Local variables:
918 * compile-command: "gcc -DMODULE -D__KERNEL__ -Wall -Wstrict-prototypes -O6 -c at1700.c"
919 * alt-compile-command: "gcc -DMODVERSIONS -DMODULE -D__KERNEL__ -Wall -Wstrict-prototypes -O6 -c at1700.c"
920 * tab-width: 4
921 * c-basic-offset: 4
922 * c-indent-level: 4
923 * End:
924 */
925
926
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.