1 /* at1700.c: A network device driver for the Allied Telesis AT1700.
3 Written 1993-98 by Donald Becker.
5 Copyright 1993 United States Government as represented by the
6 Director, National Security Agency.
8 This software may be used and distributed according to the terms
9 of the GNU General Public License, incorporated herein by reference.
11 The author may be reached as becker@scyld.com, or C/O
12 Scyld Computing Corporation
13 410 Severn Ave., Suite 210
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.
20 Modification for Fujitsu FMV-18X cards is done by Yutaka Tamiya
21 (tamy@flab.fujitsu.co.jp).
24 The Fujitsu MB86965 datasheet.
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.
30 MCA bus (AT1720) support by Rene Schmit <rene@bss.lu>
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!
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>
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>
56 #include <asm/system.h>
60 static char version[] __initdata =
61 "at1700.c:v1.16 9/11/06 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
63 #define DRV_NAME "at1700"
65 /* Tunable parameters. */
67 /* When to switch from the 64-entry multicast filter to Rx-all-multicast. */
68 #define MC_FILTERBREAK 64
70 /* These unusual address orders are used to verify the CONFIG register. */
72 static int fmv18x_probe_list[] __initdata = {
73 0x220, 0x240, 0x260, 0x280, 0x2a0, 0x2c0, 0x300, 0x340, 0
80 static unsigned at1700_probe_list[] __initdata = {
81 0x260, 0x280, 0x2a0, 0x240, 0x340, 0x320, 0x380, 0x300, 0
87 #ifdef CONFIG_MCA_LEGACY
88 static int at1700_ioaddr_pattern[] __initdata = {
89 0x00, 0x04, 0x01, 0x05, 0x02, 0x06, 0x03, 0x07
92 static int at1700_mca_probe_list[] __initdata = {
93 0x400, 0x1400, 0x2400, 0x3400, 0x4400, 0x5400, 0x6400, 0x7400, 0
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
102 /* use 0 for production, 1 for verification, >2 for debug */
106 static unsigned int net_debug = NET_DEBUG;
108 typedef unsigned char uchar;
110 /* Information that need to be kept for each board. */
112 struct net_device_stats stats;
114 unsigned char mc_filter[8];
115 uint jumpered:1; /* Set iff the board has jumper config. */
116 uint tx_started:1; /* Packets are on the Tx queue. */
117 uint tx_queue_ready:1; /* Tx queue is ready to be sent. */
118 uint rx_started:1; /* Packets are Rxing. */
119 uchar tx_queue; /* Number of packet on the Tx queue. */
120 char mca_slot; /* -1 means ISA */
121 ushort tx_queue_len; /* Current length of the Tx queue. */
125 /* Offsets from the base address. */
129 #define TX_INTR 2 /* Bit-mapped interrupt enable registers. */
133 #define CONFIG_0 6 /* Misc. configuration settings. */
135 /* Run-time register bank 2 definitions. */
136 #define DATAPORT 8 /* Word-wide DMA or programmed-I/O dataport. */
138 #define COL16CNTL 11 /* Controll Reg for 16 collisions */
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. */
148 #define SAPROM 20 /* The station address PROM, if no EEPROM. */
150 #define RESET 31 /* Write to reset some parts of the chip. */
151 #define AT1700_IO_EXTENT 32
152 #define PORT_OFFSET(o) (o)
155 #define TX_TIMEOUT 10
158 /* Index to functions, as function prototypes. */
160 static int at1700_probe1(struct net_device *dev, int ioaddr);
161 static int read_eeprom(long ioaddr, int location);
162 static int net_open(struct net_device *dev);
163 static int net_send_packet(struct sk_buff *skb, struct net_device *dev);
164 static irqreturn_t net_interrupt(int irq, void *dev_id);
165 static void net_rx(struct net_device *dev);
166 static int net_close(struct net_device *dev);
167 static struct net_device_stats *net_get_stats(struct net_device *dev);
168 static void set_rx_mode(struct net_device *dev);
169 static void net_tx_timeout (struct net_device *dev);
172 #ifdef CONFIG_MCA_LEGACY
173 struct at1720_mca_adapters_struct {
177 /* rEnE : maybe there are others I don't know off... */
179 static struct at1720_mca_adapters_struct at1720_mca_adapters[] __initdata = {
180 { "Allied Telesys AT1720AT", 0x6410 },
181 { "Allied Telesys AT1720BT", 0x6413 },
182 { "Allied Telesys AT1720T", 0x6416 },
187 /* Check for a network adaptor of this type, and return '0' iff one exists.
188 If dev->base_addr == 0, probe all likely locations.
189 If dev->base_addr == 1, always return failure.
190 If dev->base_addr == 2, allocate space for the device and return success
191 (detachable devices only).
194 static int io = 0x260;
198 static void cleanup_card(struct net_device *dev)
200 #ifdef CONFIG_MCA_LEGACY
201 struct net_local *lp = netdev_priv(dev);
202 if (lp->mca_slot >= 0)
203 mca_mark_as_unused(lp->mca_slot);
205 free_irq(dev->irq, NULL);
206 release_region(dev->base_addr, AT1700_IO_EXTENT);
209 struct net_device * __init at1700_probe(int unit)
211 struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
216 return ERR_PTR(-ENODEV);
219 sprintf(dev->name, "eth%d", unit);
220 netdev_boot_setup_check(dev);
228 if (io > 0x1ff) { /* Check a single specified location. */
229 err = at1700_probe1(dev, io);
230 } else if (io != 0) { /* Don't probe at all. */
233 for (port = at1700_probe_list; *port; port++) {
234 if (at1700_probe1(dev, *port) == 0)
243 err = register_netdev(dev);
254 /* The Fujitsu datasheet suggests that the NIC be probed for by checking its
255 "signature", the default bit pattern after a reset. This *doesn't* work --
256 there is no way to reset the bus interface without a complete power-cycle!
258 It turns out that ATI came to the same conclusion I did: the only thing
259 that can be done is checking a few bits and then diving right into an
262 static int __init at1700_probe1(struct net_device *dev, int ioaddr)
264 char fmv_irqmap[4] = {3, 7, 10, 15};
265 char fmv_irqmap_pnp[8] = {3, 4, 5, 7, 9, 10, 11, 15};
266 char at1700_irqmap[8] = {3, 4, 5, 9, 10, 11, 14, 15};
267 unsigned int i, irq, is_fmv18x = 0, is_at1700 = 0;
268 int slot, ret = -ENODEV;
269 struct net_local *lp = netdev_priv(dev);
271 if (!request_region(ioaddr, AT1700_IO_EXTENT, DRV_NAME))
274 /* Resetting the chip doesn't reset the ISA interface, so don't bother.
275 That means we have to be careful with the register values we probe
279 printk("at1700 probe at %#x, eeprom is %4.4x %4.4x %4.4x ctrl %4.4x.\n",
280 ioaddr, read_eeprom(ioaddr, 4), read_eeprom(ioaddr, 5),
281 read_eeprom(ioaddr, 6), inw(ioaddr + EEPROM_Ctrl));
284 #ifdef CONFIG_MCA_LEGACY
285 /* rEnE (rene@bss.lu): got this from 3c509 driver source , adapted for AT1720 */
287 /* Based on Erik Nygren's (nygren@mit.edu) 3c529 patch, heavily
288 modified by Chris Beauregard (cpbeaure@csclub.uwaterloo.ca)
289 to support standard MCA probing. */
291 /* redone for multi-card detection by ZP Gu (zpg@castle.net) */
292 /* now works as a module */
299 for (j = 0; at1720_mca_adapters[j].name != NULL; j ++) {
301 while (slot != MCA_NOTFOUND) {
303 slot = mca_find_unused_adapter( at1720_mca_adapters[j].id, slot );
304 if (slot == MCA_NOTFOUND) break;
306 /* if we get this far, an adapter has been detected and is
309 pos3 = mca_read_stored_pos( slot, 3 );
310 pos4 = mca_read_stored_pos( slot, 4 );
312 for (l_i = 0; l_i < 0x09; l_i++)
313 if (( pos3 & 0x07) == at1700_ioaddr_pattern[l_i])
315 ioaddr = at1700_mca_probe_list[l_i];
317 for (irq = 0; irq < 0x10; irq++)
318 if (((((pos4>>4) & 0x0f) | (pos3 & 0xf0)) & 0xff) == at1700_irq_pattern[irq])
321 /* probing for a card at a particular IO/IRQ */
322 if ((dev->irq && dev->irq != irq) ||
323 (dev->base_addr && dev->base_addr != ioaddr)) {
324 slot++; /* probing next slot */
331 mca_set_adapter_name( slot, at1720_mca_adapters[j].name );
332 mca_mark_as_used(slot);
337 /* if we get here, we didn't find an MCA adapter - try ISA */
341 /* We must check for the EEPROM-config boards first, else accessing
342 IOCONFIG0 will move the board! */
343 if (at1700_probe_list[inb(ioaddr + IOCONFIG1) & 0x07] == ioaddr
344 && read_eeprom(ioaddr, 4) == 0x0000
345 && (read_eeprom(ioaddr, 5) & 0xff00) == 0xF400)
347 else if (inb(ioaddr + SAPROM ) == 0x00
348 && inb(ioaddr + SAPROM + 1) == 0x00
349 && inb(ioaddr + SAPROM + 2) == 0x0e)
355 #ifdef CONFIG_MCA_LEGACY
359 /* Reset the internal state machines. */
360 outb(0, ioaddr + RESET);
363 irq = at1700_irqmap[(read_eeprom(ioaddr, 12)&0x04)
364 | (read_eeprom(ioaddr, 0)>>14)];
366 /* Check PnP mode for FMV-183/184/183A/184A. */
367 /* This PnP routine is very poor. IO and IRQ should be known. */
368 if (inb(ioaddr + CARDSTATUS1) & 0x20) {
370 for (i = 0; i < 8; i++) {
371 if (irq == fmv_irqmap_pnp[i])
378 if (fmv18x_probe_list[inb(ioaddr + IOCONFIG) & 0x07] != ioaddr)
380 irq = fmv_irqmap[(inb(ioaddr + IOCONFIG)>>6) & 0x03];
384 printk("%s: %s found at %#3x, IRQ %d, address ", dev->name,
385 is_at1700 ? "AT1700" : "FMV-18X", ioaddr, irq);
387 dev->base_addr = ioaddr;
391 for(i = 0; i < 3; i++) {
392 unsigned short eeprom_val = read_eeprom(ioaddr, 4+i);
393 printk("%04x", eeprom_val);
394 ((unsigned short *)dev->dev_addr)[i] = ntohs(eeprom_val);
397 for(i = 0; i < 6; i++) {
398 unsigned char val = inb(ioaddr + SAPROM + i);
400 dev->dev_addr[i] = val;
404 /* The EEPROM word 12 bit 0x0400 means use regular 100 ohm 10baseT signals,
405 rather than 150 ohm shielded twisted pair compensation.
406 0x0000 == auto-sense the interface
407 0x0800 == use TP interface
408 0x1800 == use coax interface
411 const char *porttype[] = {"auto-sense", "10baseT", "auto-sense", "10base2"};
413 ushort setup_value = read_eeprom(ioaddr, 12);
414 dev->if_port = setup_value >> 8;
416 ushort setup_value = inb(ioaddr + CARDSTATUS);
417 switch (setup_value & 0x07) {
418 case 0x01: /* 10base5 */
419 case 0x02: /* 10base2 */
420 dev->if_port = 0x18; break;
421 case 0x04: /* 10baseT */
422 dev->if_port = 0x08; break;
423 default: /* auto-sense */
424 dev->if_port = 0x00; break;
427 printk(" %s interface.\n", porttype[(dev->if_port>>3) & 3]);
430 /* Set the configuration register 0 to 32K 100ns. byte-wide memory, 16 bit
431 bus access, two 4K Tx queues, and disabled Tx and Rx. */
432 outb(0xda, ioaddr + CONFIG_0);
434 /* Set the station address in bank zero. */
435 outb(0x00, ioaddr + CONFIG_1);
436 for (i = 0; i < 6; i++)
437 outb(dev->dev_addr[i], ioaddr + PORT_OFFSET(8 + i));
439 /* Switch to bank 1 and set the multicast table to accept none. */
440 outb(0x04, ioaddr + CONFIG_1);
441 for (i = 0; i < 8; i++)
442 outb(0x00, ioaddr + PORT_OFFSET(8 + i));
445 /* Switch to bank 2 */
446 /* Lock our I/O address, and set manual processing mode for 16 collisions. */
447 outb(0x08, ioaddr + CONFIG_1);
448 outb(dev->if_port, ioaddr + MODE13);
449 outb(0x00, ioaddr + COL16CNTL);
454 memset(lp, 0, sizeof(struct net_local));
456 dev->open = net_open;
457 dev->stop = net_close;
458 dev->hard_start_xmit = net_send_packet;
459 dev->get_stats = net_get_stats;
460 dev->set_multicast_list = &set_rx_mode;
461 dev->tx_timeout = net_tx_timeout;
462 dev->watchdog_timeo = TX_TIMEOUT;
464 spin_lock_init(&lp->lock);
466 lp->jumpered = is_fmv18x;
468 /* Snarf the interrupt vector now. */
469 ret = request_irq(irq, &net_interrupt, 0, DRV_NAME, dev);
471 printk (" AT1700 at %#3x is unusable due to a conflict on"
472 "IRQ %d.\n", ioaddr, irq);
479 #ifdef CONFIG_MCA_LEGACY
481 mca_mark_as_unused(slot);
484 release_region(ioaddr, AT1700_IO_EXTENT);
489 /* EEPROM_Ctrl bits. */
490 #define EE_SHIFT_CLK 0x40 /* EEPROM shift clock, in reg. 16. */
491 #define EE_CS 0x20 /* EEPROM chip select, in reg. 16. */
492 #define EE_DATA_WRITE 0x80 /* EEPROM chip data in, in reg. 17. */
493 #define EE_DATA_READ 0x80 /* EEPROM chip data out, in reg. 17. */
495 /* The EEPROM commands include the alway-set leading bit. */
496 #define EE_WRITE_CMD (5 << 6)
497 #define EE_READ_CMD (6 << 6)
498 #define EE_ERASE_CMD (7 << 6)
500 static int __init read_eeprom(long ioaddr, int location)
503 unsigned short retval = 0;
504 long ee_addr = ioaddr + EEPROM_Ctrl;
505 long ee_daddr = ioaddr + EEPROM_Data;
506 int read_cmd = location | EE_READ_CMD;
508 /* Shift the read command bits out. */
509 for (i = 9; i >= 0; i--) {
510 short dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
511 outb(EE_CS, ee_addr);
512 outb(dataval, ee_daddr);
513 outb(EE_CS | EE_SHIFT_CLK, ee_addr); /* EEPROM clock tick. */
515 outb(EE_DATA_WRITE, ee_daddr);
516 for (i = 16; i > 0; i--) {
517 outb(EE_CS, ee_addr);
518 outb(EE_CS | EE_SHIFT_CLK, ee_addr);
519 retval = (retval << 1) | ((inb(ee_daddr) & EE_DATA_READ) ? 1 : 0);
522 /* Terminate the EEPROM access. */
523 outb(EE_CS, ee_addr);
524 outb(EE_SHIFT_CLK, ee_addr);
531 static int net_open(struct net_device *dev)
533 struct net_local *lp = netdev_priv(dev);
534 int ioaddr = dev->base_addr;
536 /* Set the configuration register 0 to 32K 100ns. byte-wide memory, 16 bit
537 bus access, and two 4K Tx queues. */
538 outb(0x5a, ioaddr + CONFIG_0);
540 /* Powerup, switch to register bank 2, and enable the Rx and Tx. */
541 outb(0xe8, ioaddr + CONFIG_1);
544 lp->tx_queue_ready = 1;
547 lp->tx_queue_len = 0;
549 /* Turn on hardware Tx and Rx interrupts. */
550 outb(0x82, ioaddr + TX_INTR);
551 outb(0x81, ioaddr + RX_INTR);
553 /* Enable the IRQ on boards of fmv18x it is feasible. */
555 outb(0x80, ioaddr + IOCONFIG1);
558 netif_start_queue(dev);
562 static void net_tx_timeout (struct net_device *dev)
564 struct net_local *lp = netdev_priv(dev);
565 int ioaddr = dev->base_addr;
567 printk ("%s: transmit timed out with status %04x, %s?\n", dev->name,
568 inw (ioaddr + STATUS), inb (ioaddr + TX_STATUS) & 0x80
569 ? "IRQ conflict" : "network cable problem");
570 printk ("%s: timeout registers: %04x %04x %04x %04x %04x %04x %04x %04x.\n",
571 dev->name, inw(ioaddr + TX_STATUS), inw(ioaddr + TX_INTR), inw(ioaddr + TX_MODE),
572 inw(ioaddr + CONFIG_0), inw(ioaddr + DATAPORT), inw(ioaddr + TX_START),
573 inw(ioaddr + MODE13 - 1), inw(ioaddr + RX_CTRL));
574 lp->stats.tx_errors++;
575 /* ToDo: We should try to restart the adaptor... */
576 outw(0xffff, ioaddr + MODE24);
577 outw (0xffff, ioaddr + TX_STATUS);
578 outb (0x5a, ioaddr + CONFIG_0);
579 outb (0xe8, ioaddr + CONFIG_1);
580 outw (0x8182, ioaddr + TX_INTR);
581 outb (0x00, ioaddr + TX_START);
582 outb (0x03, ioaddr + COL16CNTL);
584 dev->trans_start = jiffies;
587 lp->tx_queue_ready = 1;
590 lp->tx_queue_len = 0;
592 netif_wake_queue(dev);
596 static int net_send_packet (struct sk_buff *skb, struct net_device *dev)
598 struct net_local *lp = netdev_priv(dev);
599 int ioaddr = dev->base_addr;
600 short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
601 short len = skb->len;
602 unsigned char *buf = skb->data;
603 static u8 pad[ETH_ZLEN];
605 netif_stop_queue (dev);
607 /* We may not start transmitting unless we finish transferring
608 a packet into the Tx queue. During executing the following
609 codes we possibly catch a Tx interrupt. Thus we flag off
610 tx_queue_ready, so that we prevent the interrupt routine
611 (net_interrupt) to start transmitting. */
612 lp->tx_queue_ready = 0;
614 outw (length, ioaddr + DATAPORT);
616 outsw (ioaddr + DATAPORT, buf, len >> 1);
617 /* Check for dribble byte */
619 outw(skb->data[skb->len-1], ioaddr + DATAPORT);
622 /* Check for packet padding */
623 if (length != skb->len)
624 outsw(ioaddr + DATAPORT, pad, (length - len + 1) >> 1);
627 lp->tx_queue_len += length + 2;
629 lp->tx_queue_ready = 1;
631 if (lp->tx_started == 0) {
632 /* If the Tx is idle, always trigger a transmit. */
633 outb (0x80 | lp->tx_queue, ioaddr + TX_START);
635 lp->tx_queue_len = 0;
636 dev->trans_start = jiffies;
638 netif_start_queue (dev);
639 } else if (lp->tx_queue_len < 4096 - 1502)
640 /* Yes, there is room for one more packet. */
641 netif_start_queue (dev);
647 /* The typical workload of the driver:
648 Handle the network interface interrupts. */
649 static irqreturn_t net_interrupt(int irq, void *dev_id)
651 struct net_device *dev = dev_id;
652 struct net_local *lp;
657 printk ("at1700_interrupt(): irq %d for unknown device.\n", irq);
661 ioaddr = dev->base_addr;
662 lp = netdev_priv(dev);
664 spin_lock (&lp->lock);
666 status = inw(ioaddr + TX_STATUS);
667 outw(status, ioaddr + TX_STATUS);
670 printk("%s: Interrupt with status %04x.\n", dev->name, status);
671 if (lp->rx_started == 0 &&
672 (status & 0xff00 || (inb(ioaddr + RX_MODE) & 0x40) == 0)) {
674 We cannot execute net_rx more than once at the same time for
675 the same device. During executing net_rx, we possibly catch a
676 Tx interrupt. Thus we flag on rx_started, so that we prevent
677 the interrupt routine (net_interrupt) to dive into net_rx
681 outb(0x00, ioaddr + RX_INTR); /* Disable RX intr. */
683 outb(0x81, ioaddr + RX_INTR); /* Enable RX intr. */
686 if (status & 0x00ff) {
689 /* More than 16 collisions occurred */
691 printk("%s: 16 Collision occur during Txing.\n", dev->name);
692 /* Cancel sending a packet. */
693 outb(0x03, ioaddr + COL16CNTL);
694 lp->stats.collisions++;
697 lp->stats.tx_packets++;
698 /* The Tx queue has any packets and is not being
699 transferred a packet from the host, start
701 if (lp->tx_queue && lp->tx_queue_ready) {
702 outb(0x80 | lp->tx_queue, ioaddr + TX_START);
704 lp->tx_queue_len = 0;
705 dev->trans_start = jiffies;
706 netif_wake_queue (dev);
709 netif_wake_queue (dev);
714 spin_unlock (&lp->lock);
715 return IRQ_RETVAL(handled);
718 /* We have a good packet(s), get it/them out of the buffers. */
720 net_rx(struct net_device *dev)
722 struct net_local *lp = netdev_priv(dev);
723 int ioaddr = dev->base_addr;
726 while ((inb(ioaddr + RX_MODE) & 0x40) == 0) {
727 ushort status = inw(ioaddr + DATAPORT);
728 ushort pkt_len = inw(ioaddr + DATAPORT);
731 printk("%s: Rxing packet mode %02x status %04x.\n",
732 dev->name, inb(ioaddr + RX_MODE), status);
733 #ifndef final_version
735 outb(0x05, ioaddr + RX_CTRL);
740 if ((status & 0xF0) != 0x20) { /* There was an error. */
741 lp->stats.rx_errors++;
742 if (status & 0x08) lp->stats.rx_length_errors++;
743 if (status & 0x04) lp->stats.rx_frame_errors++;
744 if (status & 0x02) lp->stats.rx_crc_errors++;
745 if (status & 0x01) lp->stats.rx_over_errors++;
747 /* Malloc up new buffer. */
750 if (pkt_len > 1550) {
751 printk("%s: The AT1700 claimed a very large packet, size %d.\n",
753 /* Prime the FIFO and then flush the packet. */
754 inw(ioaddr + DATAPORT); inw(ioaddr + DATAPORT);
755 outb(0x05, ioaddr + RX_CTRL);
756 lp->stats.rx_errors++;
759 skb = dev_alloc_skb(pkt_len+3);
761 printk("%s: Memory squeeze, dropping packet (len %d).\n",
763 /* Prime the FIFO and then flush the packet. */
764 inw(ioaddr + DATAPORT); inw(ioaddr + DATAPORT);
765 outb(0x05, ioaddr + RX_CTRL);
766 lp->stats.rx_dropped++;
771 insw(ioaddr + DATAPORT, skb_put(skb,pkt_len), (pkt_len + 1) >> 1);
772 skb->protocol=eth_type_trans(skb, dev);
774 dev->last_rx = jiffies;
775 lp->stats.rx_packets++;
776 lp->stats.rx_bytes += pkt_len;
778 if (--boguscount <= 0)
782 /* If any worth-while packets have been received, dev_rint()
783 has done a mark_bh(NET_BH) for us and will work on them
784 when we get to the bottom-half routine. */
787 for (i = 0; i < 20; i++) {
788 if ((inb(ioaddr + RX_MODE) & 0x40) == 0x40)
790 inw(ioaddr + DATAPORT); /* dummy status read */
791 outb(0x05, ioaddr + RX_CTRL);
795 printk("%s: Exint Rx packet with mode %02x after %d ticks.\n",
796 dev->name, inb(ioaddr + RX_MODE), i);
801 /* The inverse routine to net_open(). */
802 static int net_close(struct net_device *dev)
804 struct net_local *lp = netdev_priv(dev);
805 int ioaddr = dev->base_addr;
807 netif_stop_queue(dev);
809 /* Set configuration register 0 to disable Tx and Rx. */
810 outb(0xda, ioaddr + CONFIG_0);
812 /* No statistic counters on the chip to update. */
814 /* Disable the IRQ on boards of fmv18x where it is feasible. */
816 outb(0x00, ioaddr + IOCONFIG1);
817 free_irq(dev->irq, dev);
820 /* Power-down the chip. Green, green, green! */
821 outb(0x00, ioaddr + CONFIG_1);
825 /* Get the current statistics.
826 This may be called with the card open or closed.
827 There are no on-chip counters, so this function is trivial.
829 static struct net_device_stats *
830 net_get_stats(struct net_device *dev)
832 struct net_local *lp = netdev_priv(dev);
837 Set the multicast/promiscuous mode for this adaptor.
841 set_rx_mode(struct net_device *dev)
843 int ioaddr = dev->base_addr;
844 struct net_local *lp = netdev_priv(dev);
845 unsigned char mc_filter[8]; /* Multicast hash filter */
849 if (dev->flags & IFF_PROMISC) {
850 memset(mc_filter, 0xff, sizeof(mc_filter));
851 outb(3, ioaddr + RX_MODE); /* Enable promiscuous mode */
852 } else if (dev->mc_count > MC_FILTERBREAK
853 || (dev->flags & IFF_ALLMULTI)) {
854 /* Too many to filter perfectly -- accept all multicasts. */
855 memset(mc_filter, 0xff, sizeof(mc_filter));
856 outb(2, ioaddr + RX_MODE); /* Use normal mode. */
857 } else if (dev->mc_count == 0) {
858 memset(mc_filter, 0x00, sizeof(mc_filter));
859 outb(1, ioaddr + RX_MODE); /* Ignore almost all multicasts. */
861 struct dev_mc_list *mclist;
864 memset(mc_filter, 0, sizeof(mc_filter));
865 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
866 i++, mclist = mclist->next) {
868 ether_crc_le(ETH_ALEN, mclist->dmi_addr) >> 26;
869 mc_filter[bit >> 3] |= (1 << bit);
871 outb(0x02, ioaddr + RX_MODE); /* Use normal mode. */
874 spin_lock_irqsave (&lp->lock, flags);
875 if (memcmp(mc_filter, lp->mc_filter, sizeof(mc_filter))) {
876 int saved_bank = inw(ioaddr + CONFIG_0);
877 /* Switch to bank 1 and set the multicast table. */
878 outw((saved_bank & ~0x0C00) | 0x0480, ioaddr + CONFIG_0);
879 for (i = 0; i < 8; i++)
880 outb(mc_filter[i], ioaddr + PORT_OFFSET(8 + i));
881 memcpy(lp->mc_filter, mc_filter, sizeof(mc_filter));
882 outw(saved_bank, ioaddr + CONFIG_0);
884 spin_unlock_irqrestore (&lp->lock, flags);
889 static struct net_device *dev_at1700;
891 module_param(io, int, 0);
892 module_param(irq, int, 0);
893 module_param(net_debug, int, 0);
894 MODULE_PARM_DESC(io, "AT1700/FMV18X I/O base address");
895 MODULE_PARM_DESC(irq, "AT1700/FMV18X IRQ number");
896 MODULE_PARM_DESC(net_debug, "AT1700/FMV18X debug level (0-6)");
898 int __init init_module(void)
901 printk("at1700: You should not use auto-probing with insmod!\n");
902 dev_at1700 = at1700_probe(-1);
903 if (IS_ERR(dev_at1700))
904 return PTR_ERR(dev_at1700);
911 unregister_netdev(dev_at1700);
912 cleanup_card(dev_at1700);
913 free_netdev(dev_at1700);
916 MODULE_LICENSE("GPL");
921 * compile-command: "gcc -DMODULE -D__KERNEL__ -Wall -Wstrict-prototypes -O6 -c at1700.c"
922 * alt-compile-command: "gcc -DMODVERSIONS -DMODULE -D__KERNEL__ -Wall -Wstrict-prototypes -O6 -c at1700.c"