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