1 /*======================================================================
3 A PCMCIA ethernet driver for Asix AX88190-based cards
5 The Asix AX88190 is a NS8390-derived chipset with a few nasty
6 idiosyncracies that make it very inconvenient to support with a
7 standard 8390 driver. This driver is based on pcnet_cs, with the
8 tweaked 8390 code grafted on the end. Much of what I did was to
9 clean up and update a similar driver supplied by Asix, which was
10 adapted by William Lee, william@asix.com.tw.
12 Copyright (C) 2001 David A. Hinds -- dahinds@users.sourceforge.net
14 axnet_cs.c 1.28 2002/06/29 06:27:37
16 The network driver code is based on Donald Becker's NE2000 code:
18 Written 1992,1993 by Donald Becker.
19 Copyright 1993 United States Government as represented by the
20 Director, National Security Agency. This software may be used and
21 distributed according to the terms of the GNU General Public License,
22 incorporated herein by reference.
23 Donald Becker may be reached at becker@scyld.com
25 ======================================================================*/
27 #include <linux/kernel.h>
28 #include <linux/module.h>
29 #include <linux/init.h>
30 #include <linux/ptrace.h>
31 #include <linux/string.h>
32 #include <linux/timer.h>
33 #include <linux/delay.h>
34 #include <linux/spinlock.h>
35 #include <linux/ethtool.h>
36 #include <linux/netdevice.h>
37 #include <linux/etherdevice.h>
38 #include <linux/crc32.h>
39 #include <linux/mii.h>
42 #include <pcmcia/cs.h>
43 #include <pcmcia/cistpl.h>
44 #include <pcmcia/ciscode.h>
45 #include <pcmcia/ds.h>
46 #include <pcmcia/cisreg.h>
49 #include <asm/system.h>
50 #include <asm/byteorder.h>
51 #include <asm/uaccess.h>
53 #define AXNET_CMD 0x00
54 #define AXNET_DATAPORT 0x10 /* NatSemi-defined port window offset. */
55 #define AXNET_RESET 0x1f /* Issue a read to reset, a write to clear. */
56 #define AXNET_MII_EEP 0x14 /* Offset of MII access port */
57 #define AXNET_TEST 0x15 /* Offset of TEST Register port */
58 #define AXNET_GPIO 0x17 /* Offset of General Purpose Register Port */
60 #define AXNET_START_PG 0x40 /* First page of TX buffer */
61 #define AXNET_STOP_PG 0x80 /* Last page +1 of RX ring */
63 #define AXNET_RDC_TIMEOUT 0x02 /* Max wait in jiffies for Tx RDC */
65 #define IS_AX88190 0x0001
66 #define IS_AX88790 0x0002
68 /*====================================================================*/
70 /* Module parameters */
72 MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
73 MODULE_DESCRIPTION("Asix AX88190 PCMCIA ethernet driver");
74 MODULE_LICENSE("GPL");
77 /*====================================================================*/
79 static int axnet_config(struct pcmcia_device *link);
80 static void axnet_release(struct pcmcia_device *link);
81 static int axnet_open(struct net_device *dev);
82 static int axnet_close(struct net_device *dev);
83 static int axnet_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
84 static netdev_tx_t axnet_start_xmit(struct sk_buff *skb,
85 struct net_device *dev);
86 static struct net_device_stats *get_stats(struct net_device *dev);
87 static void set_multicast_list(struct net_device *dev);
88 static void axnet_tx_timeout(struct net_device *dev);
89 static const struct ethtool_ops netdev_ethtool_ops;
90 static irqreturn_t ei_irq_wrapper(int irq, void *dev_id);
91 static void ei_watchdog(u_long arg);
92 static void axnet_reset_8390(struct net_device *dev);
94 static int mdio_read(unsigned int addr, int phy_id, int loc);
95 static void mdio_write(unsigned int addr, int phy_id, int loc, int value);
97 static void get_8390_hdr(struct net_device *,
98 struct e8390_pkt_hdr *, int);
99 static void block_input(struct net_device *dev, int count,
100 struct sk_buff *skb, int ring_offset);
101 static void block_output(struct net_device *dev, int count,
102 const u_char *buf, const int start_page);
104 static void axnet_detach(struct pcmcia_device *p_dev);
106 static void AX88190_init(struct net_device *dev, int startp);
107 static int ax_open(struct net_device *dev);
108 static int ax_close(struct net_device *dev);
109 static irqreturn_t ax_interrupt(int irq, void *dev_id);
111 /*====================================================================*/
113 typedef struct axnet_dev_t {
114 struct pcmcia_device *p_dev;
116 struct timer_list watchdog;
117 int stale, fast_poll;
124 static inline axnet_dev_t *PRIV(struct net_device *dev)
126 void *p = (char *)netdev_priv(dev) + sizeof(struct ei_device);
130 static const struct net_device_ops axnet_netdev_ops = {
131 .ndo_open = axnet_open,
132 .ndo_stop = axnet_close,
133 .ndo_do_ioctl = axnet_ioctl,
134 .ndo_start_xmit = axnet_start_xmit,
135 .ndo_tx_timeout = axnet_tx_timeout,
136 .ndo_get_stats = get_stats,
137 .ndo_set_multicast_list = set_multicast_list,
138 .ndo_change_mtu = eth_change_mtu,
139 .ndo_set_mac_address = eth_mac_addr,
140 .ndo_validate_addr = eth_validate_addr,
143 /*======================================================================
145 axnet_attach() creates an "instance" of the driver, allocating
146 local data structures for one device. The device is registered
149 ======================================================================*/
151 static int axnet_probe(struct pcmcia_device *link)
154 struct net_device *dev;
155 struct ei_device *ei_local;
157 dev_dbg(&link->dev, "axnet_attach()\n");
159 dev = alloc_etherdev(sizeof(struct ei_device) + sizeof(axnet_dev_t));
163 ei_local = netdev_priv(dev);
164 spin_lock_init(&ei_local->page_lock);
169 link->conf.Attributes = CONF_ENABLE_IRQ;
170 link->conf.IntType = INT_MEMORY_AND_IO;
172 dev->netdev_ops = &axnet_netdev_ops;
174 SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
175 dev->watchdog_timeo = TX_TIMEOUT;
177 return axnet_config(link);
180 /*======================================================================
182 This deletes a driver "instance". The device is de-registered
183 with Card Services. If it has been released, all local data
184 structures are freed. Otherwise, the structures will be freed
185 when the device is released.
187 ======================================================================*/
189 static void axnet_detach(struct pcmcia_device *link)
191 struct net_device *dev = link->priv;
193 dev_dbg(&link->dev, "axnet_detach(0x%p)\n", link);
195 unregister_netdev(dev);
202 /*======================================================================
204 This probes for a card's hardware address by reading the PROM.
206 ======================================================================*/
208 static int get_prom(struct pcmcia_device *link)
210 struct net_device *dev = link->priv;
211 unsigned int ioaddr = dev->base_addr;
214 /* This is based on drivers/net/ne.c */
216 u_char value, offset;
218 {E8390_NODMA+E8390_PAGE0+E8390_STOP, E8390_CMD}, /* Select page 0*/
219 {0x01, EN0_DCFG}, /* Set word-wide access. */
220 {0x00, EN0_RCNTLO}, /* Clear the count regs. */
222 {0x00, EN0_IMR}, /* Mask completion irq. */
224 {E8390_RXOFF|0x40, EN0_RXCR}, /* 0x60 Set to monitor */
225 {E8390_TXOFF, EN0_TXCR}, /* 0x02 and loopback mode. */
228 {0x00, EN0_RSARLO}, /* DMA starting at 0x0400. */
230 {E8390_RREAD+E8390_START, E8390_CMD},
233 /* Not much of a test, but the alternatives are messy */
234 if (link->conf.ConfigBase != 0x03c0)
237 axnet_reset_8390(dev);
240 for (i = 0; i < ARRAY_SIZE(program_seq); i++)
241 outb_p(program_seq[i].value, ioaddr + program_seq[i].offset);
243 for (i = 0; i < 6; i += 2) {
244 j = inw(ioaddr + AXNET_DATAPORT);
245 dev->dev_addr[i] = j & 0xff;
246 dev->dev_addr[i+1] = j >> 8;
251 /*======================================================================
253 axnet_config() is scheduled to run after a CARD_INSERTION event
254 is received, to configure the PCMCIA socket, and to make the
255 ethernet device available to the system.
257 ======================================================================*/
259 static int try_io_port(struct pcmcia_device *link)
262 if (link->io.NumPorts1 == 32) {
263 link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
264 /* for master/slave multifunction cards */
265 if (link->io.NumPorts2 > 0)
266 link->io.Attributes2 = IO_DATA_PATH_WIDTH_8;
268 /* This should be two 16-port windows */
269 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
270 link->io.Attributes2 = IO_DATA_PATH_WIDTH_16;
272 if (link->io.BasePort1 == 0) {
273 link->io.IOAddrLines = 16;
274 for (j = 0; j < 0x400; j += 0x20) {
275 link->io.BasePort1 = j ^ 0x300;
276 link->io.BasePort2 = (j ^ 0x300) + 0x10;
277 ret = pcmcia_request_io(link, &link->io);
283 return pcmcia_request_io(link, &link->io);
287 static int axnet_configcheck(struct pcmcia_device *p_dev,
288 cistpl_cftable_entry_t *cfg,
289 cistpl_cftable_entry_t *dflt,
294 cistpl_io_t *io = &cfg->io;
296 if (cfg->index == 0 || cfg->io.nwin == 0)
299 p_dev->conf.ConfigIndex = 0x05;
300 /* For multifunction cards, by convention, we configure the
301 network function with window 0, and serial with window 1 */
303 i = (io->win[1].len > io->win[0].len);
304 p_dev->io.BasePort2 = io->win[1-i].base;
305 p_dev->io.NumPorts2 = io->win[1-i].len;
307 i = p_dev->io.NumPorts2 = 0;
309 p_dev->io.BasePort1 = io->win[i].base;
310 p_dev->io.NumPorts1 = io->win[i].len;
311 p_dev->io.IOAddrLines = io->flags & CISTPL_IO_LINES_MASK;
312 if (p_dev->io.NumPorts1 + p_dev->io.NumPorts2 >= 32)
313 return try_io_port(p_dev);
318 static int axnet_config(struct pcmcia_device *link)
320 struct net_device *dev = link->priv;
321 axnet_dev_t *info = PRIV(dev);
324 dev_dbg(&link->dev, "axnet_config(0x%p)\n", link);
326 /* don't trust the CIS on this; Linksys got it wrong */
327 link->conf.Present = 0x63;
328 ret = pcmcia_loop_config(link, axnet_configcheck, NULL);
335 if (link->io.NumPorts2 == 8) {
336 link->conf.Attributes |= CONF_ENABLE_SPKR;
337 link->conf.Status = CCSR_AUDIO_ENA;
340 ret = pcmcia_request_configuration(link, &link->conf);
344 dev->irq = link->irq;
345 dev->base_addr = link->io.BasePort1;
347 if (!get_prom(link)) {
348 printk(KERN_NOTICE "axnet_cs: this is not an AX88190 card!\n");
349 printk(KERN_NOTICE "axnet_cs: use pcnet_cs instead.\n");
353 ei_status.name = "AX88190";
354 ei_status.word16 = 1;
355 ei_status.tx_start_page = AXNET_START_PG;
356 ei_status.rx_start_page = AXNET_START_PG + TX_PAGES;
357 ei_status.stop_page = AXNET_STOP_PG;
358 ei_status.reset_8390 = &axnet_reset_8390;
359 ei_status.get_8390_hdr = &get_8390_hdr;
360 ei_status.block_input = &block_input;
361 ei_status.block_output = &block_output;
363 if (inb(dev->base_addr + AXNET_TEST) != 0)
364 info->flags |= IS_AX88790;
366 info->flags |= IS_AX88190;
368 if (info->flags & IS_AX88790)
369 outb(0x10, dev->base_addr + AXNET_GPIO); /* select Internal PHY */
371 for (i = 0; i < 32; i++) {
372 j = mdio_read(dev->base_addr + AXNET_MII_EEP, i, 1);
373 j2 = mdio_read(dev->base_addr + AXNET_MII_EEP, i, 2);
374 if (j == j2) continue;
375 if ((j != 0) && (j != 0xffff)) break;
378 /* Maybe PHY is in power down mode. (PPD_SET = 1)
379 Bit 2 of CCSR is active low. */
381 conf_reg_t reg = { 0, CS_WRITE, CISREG_CCSR, 0x04 };
382 pcmcia_access_configuration_register(link, ®);
383 for (i = 0; i < 32; i++) {
384 j = mdio_read(dev->base_addr + AXNET_MII_EEP, i, 1);
385 j2 = mdio_read(dev->base_addr + AXNET_MII_EEP, i, 2);
386 if (j == j2) continue;
387 if ((j != 0) && (j != 0xffff)) break;
391 info->phy_id = (i < 32) ? i : -1;
392 SET_NETDEV_DEV(dev, &link->dev);
394 if (register_netdev(dev) != 0) {
395 printk(KERN_NOTICE "axnet_cs: register_netdev() failed\n");
399 printk(KERN_INFO "%s: Asix AX88%d90: io %#3lx, irq %d, "
401 dev->name, ((info->flags & IS_AX88790) ? 7 : 1),
402 dev->base_addr, dev->irq,
404 if (info->phy_id != -1) {
405 dev_dbg(&link->dev, " MII transceiver at index %d, status %x.\n", info->phy_id, j);
407 printk(KERN_NOTICE " No MII transceivers found!\n");
416 /*======================================================================
418 After a card is removed, axnet_release() will unregister the net
419 device, and release the PCMCIA configuration. If the device is
420 still open, this will be postponed until it is closed.
422 ======================================================================*/
424 static void axnet_release(struct pcmcia_device *link)
426 pcmcia_disable_device(link);
429 static int axnet_suspend(struct pcmcia_device *link)
431 struct net_device *dev = link->priv;
434 netif_device_detach(dev);
439 static int axnet_resume(struct pcmcia_device *link)
441 struct net_device *dev = link->priv;
444 axnet_reset_8390(dev);
445 AX88190_init(dev, 1);
446 netif_device_attach(dev);
453 /*======================================================================
455 MII interface support
457 ======================================================================*/
459 #define MDIO_SHIFT_CLK 0x01
460 #define MDIO_DATA_WRITE0 0x00
461 #define MDIO_DATA_WRITE1 0x08
462 #define MDIO_DATA_READ 0x04
463 #define MDIO_MASK 0x0f
464 #define MDIO_ENB_IN 0x02
466 static void mdio_sync(unsigned int addr)
469 for (bits = 0; bits < 32; bits++) {
470 outb_p(MDIO_DATA_WRITE1, addr);
471 outb_p(MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, addr);
475 static int mdio_read(unsigned int addr, int phy_id, int loc)
477 u_int cmd = (0xf6<<10)|(phy_id<<5)|loc;
481 for (i = 14; i >= 0; i--) {
482 int dat = (cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
484 outb_p(dat | MDIO_SHIFT_CLK, addr);
486 for (i = 19; i > 0; i--) {
487 outb_p(MDIO_ENB_IN, addr);
488 retval = (retval << 1) | ((inb_p(addr) & MDIO_DATA_READ) != 0);
489 outb_p(MDIO_ENB_IN | MDIO_SHIFT_CLK, addr);
491 return (retval>>1) & 0xffff;
494 static void mdio_write(unsigned int addr, int phy_id, int loc, int value)
496 u_int cmd = (0x05<<28)|(phy_id<<23)|(loc<<18)|(1<<17)|value;
500 for (i = 31; i >= 0; i--) {
501 int dat = (cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
503 outb_p(dat | MDIO_SHIFT_CLK, addr);
505 for (i = 1; i >= 0; i--) {
506 outb_p(MDIO_ENB_IN, addr);
507 outb_p(MDIO_ENB_IN | MDIO_SHIFT_CLK, addr);
511 /*====================================================================*/
513 static int axnet_open(struct net_device *dev)
516 axnet_dev_t *info = PRIV(dev);
517 struct pcmcia_device *link = info->p_dev;
518 unsigned int nic_base = dev->base_addr;
520 dev_dbg(&link->dev, "axnet_open('%s')\n", dev->name);
522 if (!pcmcia_dev_present(link))
525 outb_p(0xFF, nic_base + EN0_ISR); /* Clear bogus intr. */
526 ret = request_irq(dev->irq, ei_irq_wrapper, IRQF_SHARED, "axnet_cs", dev);
532 info->link_status = 0x00;
533 init_timer(&info->watchdog);
534 info->watchdog.function = &ei_watchdog;
535 info->watchdog.data = (u_long)dev;
536 info->watchdog.expires = jiffies + HZ;
537 add_timer(&info->watchdog);
542 /*====================================================================*/
544 static int axnet_close(struct net_device *dev)
546 axnet_dev_t *info = PRIV(dev);
547 struct pcmcia_device *link = info->p_dev;
549 dev_dbg(&link->dev, "axnet_close('%s')\n", dev->name);
552 free_irq(dev->irq, dev);
555 netif_stop_queue(dev);
556 del_timer_sync(&info->watchdog);
561 /*======================================================================
563 Hard reset the card. This used to pause for the same period that
564 a 8390 reset command required, but that shouldn't be necessary.
566 ======================================================================*/
568 static void axnet_reset_8390(struct net_device *dev)
570 unsigned int nic_base = dev->base_addr;
573 ei_status.txing = ei_status.dmaing = 0;
575 outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, nic_base + E8390_CMD);
577 outb(inb(nic_base + AXNET_RESET), nic_base + AXNET_RESET);
579 for (i = 0; i < 100; i++) {
580 if ((inb_p(nic_base+EN0_ISR) & ENISR_RESET) != 0)
584 outb_p(ENISR_RESET, nic_base + EN0_ISR); /* Ack intr. */
587 printk(KERN_ERR "%s: axnet_reset_8390() did not complete.\n",
590 } /* axnet_reset_8390 */
592 /*====================================================================*/
594 static irqreturn_t ei_irq_wrapper(int irq, void *dev_id)
596 struct net_device *dev = dev_id;
597 PRIV(dev)->stale = 0;
598 return ax_interrupt(irq, dev_id);
601 static void ei_watchdog(u_long arg)
603 struct net_device *dev = (struct net_device *)(arg);
604 axnet_dev_t *info = PRIV(dev);
605 unsigned int nic_base = dev->base_addr;
606 unsigned int mii_addr = nic_base + AXNET_MII_EEP;
609 if (!netif_device_present(dev)) goto reschedule;
611 /* Check for pending interrupt with expired latency timer: with
612 this, we can limp along even if the interrupt is blocked */
613 if (info->stale++ && (inb_p(nic_base + EN0_ISR) & ENISR_ALL)) {
614 if (!info->fast_poll)
615 printk(KERN_INFO "%s: interrupt(s) dropped!\n", dev->name);
616 ei_irq_wrapper(dev->irq, dev);
617 info->fast_poll = HZ;
619 if (info->fast_poll) {
621 info->watchdog.expires = jiffies + 1;
622 add_timer(&info->watchdog);
626 if (info->phy_id < 0)
628 link = mdio_read(mii_addr, info->phy_id, 1);
629 if (!link || (link == 0xffff)) {
630 printk(KERN_INFO "%s: MII is missing!\n", dev->name);
636 if (link != info->link_status) {
637 u_short p = mdio_read(mii_addr, info->phy_id, 5);
638 printk(KERN_INFO "%s: %s link beat\n", dev->name,
639 (link) ? "found" : "lost");
641 info->duplex_flag = (p & 0x0140) ? 0x80 : 0x00;
643 printk(KERN_INFO "%s: autonegotiation complete: "
644 "%sbaseT-%cD selected\n", dev->name,
645 ((p & 0x0180) ? "100" : "10"),
646 ((p & 0x0140) ? 'F' : 'H'));
648 printk(KERN_INFO "%s: link partner did not autonegotiate\n",
650 AX88190_init(dev, 1);
652 info->link_status = link;
656 info->watchdog.expires = jiffies + HZ;
657 add_timer(&info->watchdog);
660 static void netdev_get_drvinfo(struct net_device *dev,
661 struct ethtool_drvinfo *info)
663 strcpy(info->driver, "axnet_cs");
666 static const struct ethtool_ops netdev_ethtool_ops = {
667 .get_drvinfo = netdev_get_drvinfo,
670 /*====================================================================*/
672 static int axnet_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
674 axnet_dev_t *info = PRIV(dev);
675 struct mii_ioctl_data *data = if_mii(rq);
676 unsigned int mii_addr = dev->base_addr + AXNET_MII_EEP;
679 data->phy_id = info->phy_id;
680 case SIOCGMIIREG: /* Read MII PHY register. */
681 data->val_out = mdio_read(mii_addr, data->phy_id, data->reg_num & 0x1f);
683 case SIOCSMIIREG: /* Write MII PHY register. */
684 mdio_write(mii_addr, data->phy_id, data->reg_num & 0x1f, data->val_in);
690 /*====================================================================*/
692 static void get_8390_hdr(struct net_device *dev,
693 struct e8390_pkt_hdr *hdr,
696 unsigned int nic_base = dev->base_addr;
698 outb_p(0, nic_base + EN0_RSARLO); /* On page boundary */
699 outb_p(ring_page, nic_base + EN0_RSARHI);
700 outb_p(E8390_RREAD+E8390_START, nic_base + AXNET_CMD);
702 insw(nic_base + AXNET_DATAPORT, hdr,
703 sizeof(struct e8390_pkt_hdr)>>1);
704 /* Fix for big endian systems */
705 hdr->count = le16_to_cpu(hdr->count);
709 /*====================================================================*/
711 static void block_input(struct net_device *dev, int count,
712 struct sk_buff *skb, int ring_offset)
714 unsigned int nic_base = dev->base_addr;
715 int xfer_count = count;
716 char *buf = skb->data;
718 if ((ei_debug > 4) && (count != 4))
719 pr_debug("%s: [bi=%d]\n", dev->name, count+4);
720 outb_p(ring_offset & 0xff, nic_base + EN0_RSARLO);
721 outb_p(ring_offset >> 8, nic_base + EN0_RSARHI);
722 outb_p(E8390_RREAD+E8390_START, nic_base + AXNET_CMD);
724 insw(nic_base + AXNET_DATAPORT,buf,count>>1);
726 buf[count-1] = inb(nic_base + AXNET_DATAPORT), xfer_count++;
730 /*====================================================================*/
732 static void block_output(struct net_device *dev, int count,
733 const u_char *buf, const int start_page)
735 unsigned int nic_base = dev->base_addr;
737 pr_debug("%s: [bo=%d]\n", dev->name, count);
739 /* Round the count up for word writes. Do we need to do this?
740 What effect will an odd byte count have on the 8390?
741 I should check someday. */
745 outb_p(0x00, nic_base + EN0_RSARLO);
746 outb_p(start_page, nic_base + EN0_RSARHI);
747 outb_p(E8390_RWRITE+E8390_START, nic_base + AXNET_CMD);
748 outsw(nic_base + AXNET_DATAPORT, buf, count>>1);
751 static struct pcmcia_device_id axnet_ids[] = {
752 PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x016c, 0x0081),
753 PCMCIA_DEVICE_MANF_CARD(0x018a, 0x0301),
754 PCMCIA_DEVICE_MANF_CARD(0x026f, 0x0301),
755 PCMCIA_DEVICE_MANF_CARD(0x026f, 0x0303),
756 PCMCIA_DEVICE_MANF_CARD(0x026f, 0x0309),
757 PCMCIA_DEVICE_MANF_CARD(0x0274, 0x1106),
758 PCMCIA_DEVICE_MANF_CARD(0x8a01, 0xc1ab),
759 PCMCIA_DEVICE_MANF_CARD(0x021b, 0x0202),
760 PCMCIA_DEVICE_MANF_CARD(0xffff, 0x1090),
761 PCMCIA_DEVICE_PROD_ID12("AmbiCom,Inc.", "Fast Ethernet PC Card(AMB8110)", 0x49b020a7, 0x119cc9fc),
762 PCMCIA_DEVICE_PROD_ID124("Fast Ethernet", "16-bit PC Card", "AX88190", 0xb4be14e3, 0x9a12eb6a, 0xab9be5ef),
763 PCMCIA_DEVICE_PROD_ID12("ASIX", "AX88190", 0x0959823b, 0xab9be5ef),
764 PCMCIA_DEVICE_PROD_ID12("Billionton", "LNA-100B", 0x552ab682, 0xbc3b87e1),
765 PCMCIA_DEVICE_PROD_ID12("CHEETAH ETHERCARD", "EN2228", 0x00fa7bc8, 0x00e990cc),
766 PCMCIA_DEVICE_PROD_ID12("CNet", "CNF301", 0xbc477dde, 0x78c5f40b),
767 PCMCIA_DEVICE_PROD_ID12("corega K.K.", "corega FEther PCC-TXD", 0x5261440f, 0x436768c5),
768 PCMCIA_DEVICE_PROD_ID12("corega K.K.", "corega FEtherII PCC-TXD", 0x5261440f, 0x730df72e),
769 PCMCIA_DEVICE_PROD_ID12("corega K.K.", "corega FEther PCC-TXM", 0x5261440f, 0x3abbd061),
770 PCMCIA_DEVICE_PROD_ID12("Dynalink", "L100C16", 0x55632fd5, 0x66bc2a90),
771 PCMCIA_DEVICE_PROD_ID12("IO DATA", "ETXPCM", 0x547e66dc, 0x233adac2),
772 PCMCIA_DEVICE_PROD_ID12("Linksys", "EtherFast 10/100 PC Card (PCMPC100 V3)", 0x0733cc81, 0x232019a8),
773 PCMCIA_DEVICE_PROD_ID12("MELCO", "LPC3-TX", 0x481e0094, 0xf91af609),
774 PCMCIA_DEVICE_PROD_ID12("NETGEAR", "FA411", 0x9aa79dc3, 0x40fad875),
775 PCMCIA_DEVICE_PROD_ID12("PCMCIA", "100BASE", 0x281f1c5d, 0x7c2add04),
776 PCMCIA_DEVICE_PROD_ID12("PCMCIA", "FastEtherCard", 0x281f1c5d, 0x7ef26116),
777 PCMCIA_DEVICE_PROD_ID12("PCMCIA", "FEP501", 0x281f1c5d, 0x2e272058),
778 PCMCIA_DEVICE_PROD_ID14("Network Everywhere", "AX88190", 0x820a67b6, 0xab9be5ef),
781 MODULE_DEVICE_TABLE(pcmcia, axnet_ids);
783 static struct pcmcia_driver axnet_cs_driver = {
784 .owner = THIS_MODULE,
788 .probe = axnet_probe,
789 .remove = axnet_detach,
790 .id_table = axnet_ids,
791 .suspend = axnet_suspend,
792 .resume = axnet_resume,
795 static int __init init_axnet_cs(void)
797 return pcmcia_register_driver(&axnet_cs_driver);
800 static void __exit exit_axnet_cs(void)
802 pcmcia_unregister_driver(&axnet_cs_driver);
805 module_init(init_axnet_cs);
806 module_exit(exit_axnet_cs);
808 /*====================================================================*/
810 /* 8390.c: A general NS8390 ethernet driver core for linux. */
812 Written 1992-94 by Donald Becker.
814 Copyright 1993 United States Government as represented by the
815 Director, National Security Agency.
817 This software may be used and distributed according to the terms
818 of the GNU General Public License, incorporated herein by reference.
820 The author may be reached as becker@scyld.com, or C/O
821 Scyld Computing Corporation
822 410 Severn Ave., Suite 210
825 This is the chip-specific code for many 8390-based ethernet adaptors.
826 This is not a complete driver, it must be combined with board-specific
827 code such as ne.c, wd.c, 3c503.c, etc.
829 Seeing how at least eight drivers use this code, (not counting the
830 PCMCIA ones either) it is easy to break some card by what seems like
831 a simple innocent change. Please contact me or Donald if you think
832 you have found something that needs changing. -- PG
836 Paul Gortmaker : remove set_bit lock, other cleanups.
837 Paul Gortmaker : add ei_get_8390_hdr() so we can pass skb's to
838 ei_block_input() for eth_io_copy_and_sum().
839 Paul Gortmaker : exchange static int ei_pingpong for a #define,
840 also add better Tx error handling.
841 Paul Gortmaker : rewrite Rx overrun handling as per NS specs.
842 Alexey Kuznetsov : use the 8390's six bit hash multicast filter.
843 Paul Gortmaker : tweak ANK's above multicast changes a bit.
844 Paul Gortmaker : update packet statistics for v2.1.x
845 Alan Cox : support arbitary stupid port mappings on the
846 68K Macintosh. Support >16bit I/O spaces
847 Paul Gortmaker : add kmod support for auto-loading of the 8390
848 module by all drivers that require it.
849 Alan Cox : Spinlocking work, added 'BUG_83C690'
850 Paul Gortmaker : Separate out Tx timeout code from Tx path.
853 The National Semiconductor LAN Databook, and the 3Com 3c503 databook.
857 static const char version_8390[] = KERN_INFO \
858 "8390.c:v1.10cvs 9/23/94 Donald Becker (becker@scyld.com)\n";
860 #include <linux/bitops.h>
862 #include <linux/fcntl.h>
863 #include <linux/in.h>
864 #include <linux/interrupt.h>
868 /* These are the operational function interfaces to board-specific
870 void reset_8390(struct net_device *dev)
871 Resets the board associated with DEV, including a hardware reset of
872 the 8390. This is only called when there is a transmit timeout, and
873 it is always followed by 8390_init().
874 void block_output(struct net_device *dev, int count, const unsigned char *buf,
876 Write the COUNT bytes of BUF to the packet buffer at START_PAGE. The
877 "page" value uses the 8390's 256-byte pages.
878 void get_8390_hdr(struct net_device *dev, struct e8390_hdr *hdr, int ring_page)
879 Read the 4 byte, page aligned 8390 header. *If* there is a
880 subsequent read, it will be of the rest of the packet.
881 void block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
882 Read COUNT bytes from the packet buffer into the skb data area. Start
883 reading from RING_OFFSET, the address as the 8390 sees it. This will always
884 follow the read of the 8390 header.
886 #define ei_reset_8390 (ei_local->reset_8390)
887 #define ei_block_output (ei_local->block_output)
888 #define ei_block_input (ei_local->block_input)
889 #define ei_get_8390_hdr (ei_local->get_8390_hdr)
891 /* use 0 for production, 1 for verification, >2 for debug */
896 /* Index to functions. */
897 static void ei_tx_intr(struct net_device *dev);
898 static void ei_tx_err(struct net_device *dev);
899 static void ei_receive(struct net_device *dev);
900 static void ei_rx_overrun(struct net_device *dev);
902 /* Routines generic to NS8390-based boards. */
903 static void NS8390_trigger_send(struct net_device *dev, unsigned int length,
905 static void do_set_multicast_list(struct net_device *dev);
908 * SMP and the 8390 setup.
910 * The 8390 isnt exactly designed to be multithreaded on RX/TX. There is
911 * a page register that controls bank and packet buffer access. We guard
912 * this with ei_local->page_lock. Nobody should assume or set the page other
913 * than zero when the lock is not held. Lock holders must restore page 0
914 * before unlocking. Even pure readers must take the lock to protect in
917 * To make life difficult the chip can also be very slow. We therefore can't
918 * just use spinlocks. For the longer lockups we disable the irq the device
919 * sits on and hold the lock. We must hold the lock because there is a dual
920 * processor case other than interrupts (get stats/set multicast list in
921 * parallel with each other and transmit).
923 * Note: in theory we can just disable the irq on the card _but_ there is
924 * a latency on SMP irq delivery. So we can easily go "disable irq" "sync irqs"
925 * enter lock, take the queued irq. So we waddle instead of flying.
927 * Finally by special arrangement for the purpose of being generally
928 * annoying the transmit function is called bh atomic. That places
929 * restrictions on the user context callers as disable_irq won't save
934 * ax_open - Open/initialize the board.
935 * @dev: network device to initialize
937 * This routine goes all-out, setting everything
938 * up anew at each open, even though many of these registers should only
939 * need to be set once at boot.
941 static int ax_open(struct net_device *dev)
944 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
947 * Grab the page lock so we own the register set, then call
951 spin_lock_irqsave(&ei_local->page_lock, flags);
952 AX88190_init(dev, 1);
953 /* Set the flag before we drop the lock, That way the IRQ arrives
954 after its set and we get no silly warnings */
955 netif_start_queue(dev);
956 spin_unlock_irqrestore(&ei_local->page_lock, flags);
957 ei_local->irqlock = 0;
961 #define dev_lock(dev) (((struct ei_device *)netdev_priv(dev))->page_lock)
964 * ax_close - shut down network device
965 * @dev: network device to close
967 * Opposite of ax_open(). Only used when "ifconfig <devname> down" is done.
969 static int ax_close(struct net_device *dev)
974 * Hold the page lock during close
977 spin_lock_irqsave(&dev_lock(dev), flags);
978 AX88190_init(dev, 0);
979 spin_unlock_irqrestore(&dev_lock(dev), flags);
980 netif_stop_queue(dev);
985 * axnet_tx_timeout - handle transmit time out condition
986 * @dev: network device which has apparently fallen asleep
988 * Called by kernel when device never acknowledges a transmit has
989 * completed (or failed) - i.e. never posted a Tx related interrupt.
992 static void axnet_tx_timeout(struct net_device *dev)
994 long e8390_base = dev->base_addr;
995 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
996 int txsr, isr, tickssofar = jiffies - dev_trans_start(dev);
999 dev->stats.tx_errors++;
1001 spin_lock_irqsave(&ei_local->page_lock, flags);
1002 txsr = inb(e8390_base+EN0_TSR);
1003 isr = inb(e8390_base+EN0_ISR);
1004 spin_unlock_irqrestore(&ei_local->page_lock, flags);
1006 printk(KERN_DEBUG "%s: Tx timed out, %s TSR=%#2x, ISR=%#2x, t=%d.\n",
1007 dev->name, (txsr & ENTSR_ABT) ? "excess collisions." :
1008 (isr) ? "lost interrupt?" : "cable problem?", txsr, isr, tickssofar);
1010 if (!isr && !dev->stats.tx_packets)
1012 /* The 8390 probably hasn't gotten on the cable yet. */
1013 ei_local->interface_num ^= 1; /* Try a different xcvr. */
1016 /* Ugly but a reset can be slow, yet must be protected */
1018 spin_lock_irqsave(&ei_local->page_lock, flags);
1020 /* Try to restart the card. Perhaps the user has fixed something. */
1022 AX88190_init(dev, 1);
1024 spin_unlock_irqrestore(&ei_local->page_lock, flags);
1025 netif_wake_queue(dev);
1029 * axnet_start_xmit - begin packet transmission
1030 * @skb: packet to be sent
1031 * @dev: network device to which packet is sent
1033 * Sends a packet to an 8390 network device.
1036 static netdev_tx_t axnet_start_xmit(struct sk_buff *skb,
1037 struct net_device *dev)
1039 long e8390_base = dev->base_addr;
1040 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
1041 int length, send_length, output_page;
1042 unsigned long flags;
1043 u8 packet[ETH_ZLEN];
1045 netif_stop_queue(dev);
1049 /* Mask interrupts from the ethercard.
1050 SMP: We have to grab the lock here otherwise the IRQ handler
1051 on another CPU can flip window and race the IRQ mask set. We end
1052 up trashing the mcast filter not disabling irqs if we don't lock */
1054 spin_lock_irqsave(&ei_local->page_lock, flags);
1055 outb_p(0x00, e8390_base + EN0_IMR);
1058 * Slow phase with lock held.
1061 ei_local->irqlock = 1;
1063 send_length = max(length, ETH_ZLEN);
1066 * We have two Tx slots available for use. Find the first free
1067 * slot, and then perform some sanity checks. With two Tx bufs,
1068 * you get very close to transmitting back-to-back packets. With
1069 * only one Tx buf, the transmitter sits idle while you reload the
1070 * card, leaving a substantial gap between each transmitted packet.
1073 if (ei_local->tx1 == 0)
1075 output_page = ei_local->tx_start_page;
1076 ei_local->tx1 = send_length;
1077 if (ei_debug && ei_local->tx2 > 0)
1078 printk(KERN_DEBUG "%s: idle transmitter tx2=%d, lasttx=%d, txing=%d.\n",
1079 dev->name, ei_local->tx2, ei_local->lasttx, ei_local->txing);
1081 else if (ei_local->tx2 == 0)
1083 output_page = ei_local->tx_start_page + TX_PAGES/2;
1084 ei_local->tx2 = send_length;
1085 if (ei_debug && ei_local->tx1 > 0)
1086 printk(KERN_DEBUG "%s: idle transmitter, tx1=%d, lasttx=%d, txing=%d.\n",
1087 dev->name, ei_local->tx1, ei_local->lasttx, ei_local->txing);
1090 { /* We should never get here. */
1092 printk(KERN_DEBUG "%s: No Tx buffers free! tx1=%d tx2=%d last=%d\n",
1093 dev->name, ei_local->tx1, ei_local->tx2, ei_local->lasttx);
1094 ei_local->irqlock = 0;
1095 netif_stop_queue(dev);
1096 outb_p(ENISR_ALL, e8390_base + EN0_IMR);
1097 spin_unlock_irqrestore(&ei_local->page_lock, flags);
1098 dev->stats.tx_errors++;
1099 return NETDEV_TX_BUSY;
1103 * Okay, now upload the packet and trigger a send if the transmitter
1104 * isn't already sending. If it is busy, the interrupt handler will
1105 * trigger the send later, upon receiving a Tx done interrupt.
1108 if (length == skb->len)
1109 ei_block_output(dev, length, skb->data, output_page);
1111 memset(packet, 0, ETH_ZLEN);
1112 skb_copy_from_linear_data(skb, packet, skb->len);
1113 ei_block_output(dev, length, packet, output_page);
1116 if (! ei_local->txing)
1118 ei_local->txing = 1;
1119 NS8390_trigger_send(dev, send_length, output_page);
1120 dev->trans_start = jiffies;
1121 if (output_page == ei_local->tx_start_page)
1124 ei_local->lasttx = -1;
1129 ei_local->lasttx = -2;
1132 else ei_local->txqueue++;
1134 if (ei_local->tx1 && ei_local->tx2)
1135 netif_stop_queue(dev);
1137 netif_start_queue(dev);
1139 /* Turn 8390 interrupts back on. */
1140 ei_local->irqlock = 0;
1141 outb_p(ENISR_ALL, e8390_base + EN0_IMR);
1143 spin_unlock_irqrestore(&ei_local->page_lock, flags);
1145 dev_kfree_skb (skb);
1146 dev->stats.tx_bytes += send_length;
1148 return NETDEV_TX_OK;
1152 * ax_interrupt - handle the interrupts from an 8390
1153 * @irq: interrupt number
1154 * @dev_id: a pointer to the net_device
1156 * Handle the ether interface interrupts. We pull packets from
1157 * the 8390 via the card specific functions and fire them at the networking
1158 * stack. We also handle transmit completions and wake the transmit path if
1159 * necessary. We also update the counters and do other housekeeping as
1163 static irqreturn_t ax_interrupt(int irq, void *dev_id)
1165 struct net_device *dev = dev_id;
1167 int interrupts, nr_serviced = 0, i;
1168 struct ei_device *ei_local;
1170 unsigned long flags;
1172 e8390_base = dev->base_addr;
1173 ei_local = netdev_priv(dev);
1176 * Protect the irq test too.
1179 spin_lock_irqsave(&ei_local->page_lock, flags);
1181 if (ei_local->irqlock)
1183 #if 1 /* This might just be an interrupt for a PCI device sharing this line */
1184 /* The "irqlock" check is only for testing. */
1185 printk(ei_local->irqlock
1186 ? "%s: Interrupted while interrupts are masked! isr=%#2x imr=%#2x.\n"
1187 : "%s: Reentering the interrupt handler! isr=%#2x imr=%#2x.\n",
1188 dev->name, inb_p(e8390_base + EN0_ISR),
1189 inb_p(e8390_base + EN0_IMR));
1191 spin_unlock_irqrestore(&ei_local->page_lock, flags);
1196 printk(KERN_DEBUG "%s: interrupt(isr=%#2.2x).\n", dev->name,
1197 inb_p(e8390_base + EN0_ISR));
1199 outb_p(0x00, e8390_base + EN0_ISR);
1200 ei_local->irqlock = 1;
1202 /* !!Assumption!! -- we stay in page 0. Don't break this. */
1203 while ((interrupts = inb_p(e8390_base + EN0_ISR)) != 0 &&
1204 ++nr_serviced < MAX_SERVICE)
1206 if (!netif_running(dev) || (interrupts == 0xff)) {
1208 printk(KERN_WARNING "%s: interrupt from stopped card\n", dev->name);
1209 outb_p(interrupts, e8390_base + EN0_ISR);
1215 /* AX88190 bug fix. */
1216 outb_p(interrupts, e8390_base + EN0_ISR);
1217 for (i = 0; i < 10; i++) {
1218 if (!(inb(e8390_base + EN0_ISR) & interrupts))
1220 outb_p(0, e8390_base + EN0_ISR);
1221 outb_p(interrupts, e8390_base + EN0_ISR);
1223 if (interrupts & ENISR_OVER)
1225 else if (interrupts & (ENISR_RX+ENISR_RX_ERR))
1227 /* Got a good (?) packet. */
1230 /* Push the next to-transmit packet through. */
1231 if (interrupts & ENISR_TX)
1233 else if (interrupts & ENISR_TX_ERR)
1236 if (interrupts & ENISR_COUNTERS)
1238 dev->stats.rx_frame_errors += inb_p(e8390_base + EN0_COUNTER0);
1239 dev->stats.rx_crc_errors += inb_p(e8390_base + EN0_COUNTER1);
1240 dev->stats.rx_missed_errors+= inb_p(e8390_base + EN0_COUNTER2);
1244 if (interrupts && ei_debug > 3)
1247 if (nr_serviced >= MAX_SERVICE)
1249 /* 0xFF is valid for a card removal */
1250 if(interrupts!=0xFF)
1251 printk(KERN_WARNING "%s: Too much work at interrupt, status %#2.2x\n",
1252 dev->name, interrupts);
1253 outb_p(ENISR_ALL, e8390_base + EN0_ISR); /* Ack. most intrs. */
1255 printk(KERN_WARNING "%s: unknown interrupt %#2x\n", dev->name, interrupts);
1256 outb_p(0xff, e8390_base + EN0_ISR); /* Ack. all intrs. */
1260 /* Turn 8390 interrupts back on. */
1261 ei_local->irqlock = 0;
1262 outb_p(ENISR_ALL, e8390_base + EN0_IMR);
1264 spin_unlock_irqrestore(&ei_local->page_lock, flags);
1265 return IRQ_RETVAL(handled);
1269 * ei_tx_err - handle transmitter error
1270 * @dev: network device which threw the exception
1272 * A transmitter error has happened. Most likely excess collisions (which
1273 * is a fairly normal condition). If the error is one where the Tx will
1274 * have been aborted, we try and send another one right away, instead of
1275 * letting the failed packet sit and collect dust in the Tx buffer. This
1276 * is a much better solution as it avoids kernel based Tx timeouts, and
1277 * an unnecessary card reset.
1279 * Called with lock held.
1282 static void ei_tx_err(struct net_device *dev)
1284 long e8390_base = dev->base_addr;
1285 unsigned char txsr = inb_p(e8390_base+EN0_TSR);
1286 unsigned char tx_was_aborted = txsr & (ENTSR_ABT+ENTSR_FU);
1288 #ifdef VERBOSE_ERROR_DUMP
1289 printk(KERN_DEBUG "%s: transmitter error (%#2x): ", dev->name, txsr);
1290 if (txsr & ENTSR_ABT)
1291 printk("excess-collisions ");
1292 if (txsr & ENTSR_ND)
1293 printk("non-deferral ");
1294 if (txsr & ENTSR_CRS)
1295 printk("lost-carrier ");
1296 if (txsr & ENTSR_FU)
1297 printk("FIFO-underrun ");
1298 if (txsr & ENTSR_CDH)
1299 printk("lost-heartbeat ");
1307 dev->stats.tx_errors++;
1308 if (txsr & ENTSR_CRS) dev->stats.tx_carrier_errors++;
1309 if (txsr & ENTSR_CDH) dev->stats.tx_heartbeat_errors++;
1310 if (txsr & ENTSR_OWC) dev->stats.tx_window_errors++;
1315 * ei_tx_intr - transmit interrupt handler
1316 * @dev: network device for which tx intr is handled
1318 * We have finished a transmit: check for errors and then trigger the next
1319 * packet to be sent. Called with lock held.
1322 static void ei_tx_intr(struct net_device *dev)
1324 long e8390_base = dev->base_addr;
1325 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
1326 int status = inb(e8390_base + EN0_TSR);
1329 * There are two Tx buffers, see which one finished, and trigger
1330 * the send of another one if it exists.
1332 ei_local->txqueue--;
1334 if (ei_local->tx1 < 0)
1336 if (ei_local->lasttx != 1 && ei_local->lasttx != -1)
1337 printk(KERN_ERR "%s: bogus last_tx_buffer %d, tx1=%d.\n",
1338 ei_local->name, ei_local->lasttx, ei_local->tx1);
1340 if (ei_local->tx2 > 0)
1342 ei_local->txing = 1;
1343 NS8390_trigger_send(dev, ei_local->tx2, ei_local->tx_start_page + 6);
1344 dev->trans_start = jiffies;
1346 ei_local->lasttx = 2;
1348 else ei_local->lasttx = 20, ei_local->txing = 0;
1350 else if (ei_local->tx2 < 0)
1352 if (ei_local->lasttx != 2 && ei_local->lasttx != -2)
1353 printk("%s: bogus last_tx_buffer %d, tx2=%d.\n",
1354 ei_local->name, ei_local->lasttx, ei_local->tx2);
1356 if (ei_local->tx1 > 0)
1358 ei_local->txing = 1;
1359 NS8390_trigger_send(dev, ei_local->tx1, ei_local->tx_start_page);
1360 dev->trans_start = jiffies;
1362 ei_local->lasttx = 1;
1365 ei_local->lasttx = 10, ei_local->txing = 0;
1367 // else printk(KERN_WARNING "%s: unexpected TX-done interrupt, lasttx=%d.\n",
1368 // dev->name, ei_local->lasttx);
1370 /* Minimize Tx latency: update the statistics after we restart TXing. */
1371 if (status & ENTSR_COL)
1372 dev->stats.collisions++;
1373 if (status & ENTSR_PTX)
1374 dev->stats.tx_packets++;
1377 dev->stats.tx_errors++;
1378 if (status & ENTSR_ABT)
1380 dev->stats.tx_aborted_errors++;
1381 dev->stats.collisions += 16;
1383 if (status & ENTSR_CRS)
1384 dev->stats.tx_carrier_errors++;
1385 if (status & ENTSR_FU)
1386 dev->stats.tx_fifo_errors++;
1387 if (status & ENTSR_CDH)
1388 dev->stats.tx_heartbeat_errors++;
1389 if (status & ENTSR_OWC)
1390 dev->stats.tx_window_errors++;
1392 netif_wake_queue(dev);
1396 * ei_receive - receive some packets
1397 * @dev: network device with which receive will be run
1399 * We have a good packet(s), get it/them out of the buffers.
1400 * Called with lock held.
1403 static void ei_receive(struct net_device *dev)
1405 long e8390_base = dev->base_addr;
1406 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
1407 unsigned char rxing_page, this_frame, next_frame;
1408 unsigned short current_offset;
1409 int rx_pkt_count = 0;
1410 struct e8390_pkt_hdr rx_frame;
1412 while (++rx_pkt_count < 10)
1414 int pkt_len, pkt_stat;
1416 /* Get the rx page (incoming packet pointer). */
1417 rxing_page = inb_p(e8390_base + EN1_CURPAG -1);
1419 /* Remove one frame from the ring. Boundary is always a page behind. */
1420 this_frame = inb_p(e8390_base + EN0_BOUNDARY) + 1;
1421 if (this_frame >= ei_local->stop_page)
1422 this_frame = ei_local->rx_start_page;
1424 /* Someday we'll omit the previous, iff we never get this message.
1425 (There is at least one clone claimed to have a problem.)
1427 Keep quiet if it looks like a card removal. One problem here
1428 is that some clones crash in roughly the same way.
1430 if (ei_debug > 0 && this_frame != ei_local->current_page && (this_frame!=0x0 || rxing_page!=0xFF))
1431 printk(KERN_ERR "%s: mismatched read page pointers %2x vs %2x.\n",
1432 dev->name, this_frame, ei_local->current_page);
1434 if (this_frame == rxing_page) /* Read all the frames? */
1435 break; /* Done for now */
1437 current_offset = this_frame << 8;
1438 ei_get_8390_hdr(dev, &rx_frame, this_frame);
1440 pkt_len = rx_frame.count - sizeof(struct e8390_pkt_hdr);
1441 pkt_stat = rx_frame.status;
1443 next_frame = this_frame + 1 + ((pkt_len+4)>>8);
1445 if (pkt_len < 60 || pkt_len > 1518)
1448 printk(KERN_DEBUG "%s: bogus packet size: %d, status=%#2x nxpg=%#2x.\n",
1449 dev->name, rx_frame.count, rx_frame.status,
1451 dev->stats.rx_errors++;
1452 dev->stats.rx_length_errors++;
1454 else if ((pkt_stat & 0x0F) == ENRSR_RXOK)
1456 struct sk_buff *skb;
1458 skb = dev_alloc_skb(pkt_len+2);
1462 printk(KERN_DEBUG "%s: Couldn't allocate a sk_buff of size %d.\n",
1463 dev->name, pkt_len);
1464 dev->stats.rx_dropped++;
1469 skb_reserve(skb,2); /* IP headers on 16 byte boundaries */
1470 skb_put(skb, pkt_len); /* Make room */
1471 ei_block_input(dev, pkt_len, skb, current_offset + sizeof(rx_frame));
1472 skb->protocol=eth_type_trans(skb,dev);
1474 dev->stats.rx_packets++;
1475 dev->stats.rx_bytes += pkt_len;
1476 if (pkt_stat & ENRSR_PHY)
1477 dev->stats.multicast++;
1483 printk(KERN_DEBUG "%s: bogus packet: status=%#2x nxpg=%#2x size=%d\n",
1484 dev->name, rx_frame.status, rx_frame.next,
1486 dev->stats.rx_errors++;
1487 /* NB: The NIC counts CRC, frame and missed errors. */
1488 if (pkt_stat & ENRSR_FO)
1489 dev->stats.rx_fifo_errors++;
1491 next_frame = rx_frame.next;
1493 /* This _should_ never happen: it's here for avoiding bad clones. */
1494 if (next_frame >= ei_local->stop_page) {
1495 printk("%s: next frame inconsistency, %#2x\n", dev->name,
1497 next_frame = ei_local->rx_start_page;
1499 ei_local->current_page = next_frame;
1500 outb_p(next_frame-1, e8390_base+EN0_BOUNDARY);
1505 * ei_rx_overrun - handle receiver overrun
1506 * @dev: network device which threw exception
1508 * We have a receiver overrun: we have to kick the 8390 to get it started
1509 * again. Problem is that you have to kick it exactly as NS prescribes in
1510 * the updated datasheets, or "the NIC may act in an unpredictable manner."
1511 * This includes causing "the NIC to defer indefinitely when it is stopped
1512 * on a busy network." Ugh.
1513 * Called with lock held. Don't call this with the interrupts off or your
1514 * computer will hate you - it takes 10ms or so.
1517 static void ei_rx_overrun(struct net_device *dev)
1519 axnet_dev_t *info = PRIV(dev);
1520 long e8390_base = dev->base_addr;
1521 unsigned char was_txing, must_resend = 0;
1524 * Record whether a Tx was in progress and then issue the
1527 was_txing = inb_p(e8390_base+E8390_CMD) & E8390_TRANS;
1528 outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base+E8390_CMD);
1531 printk(KERN_DEBUG "%s: Receiver overrun.\n", dev->name);
1532 dev->stats.rx_over_errors++;
1535 * Wait a full Tx time (1.2ms) + some guard time, NS says 1.6ms total.
1536 * Early datasheets said to poll the reset bit, but now they say that
1537 * it "is not a reliable indicator and subsequently should be ignored."
1538 * We wait at least 10ms.
1544 * Reset RBCR[01] back to zero as per magic incantation.
1546 outb_p(0x00, e8390_base+EN0_RCNTLO);
1547 outb_p(0x00, e8390_base+EN0_RCNTHI);
1550 * See if any Tx was interrupted or not. According to NS, this
1551 * step is vital, and skipping it will cause no end of havoc.
1556 unsigned char tx_completed = inb_p(e8390_base+EN0_ISR) & (ENISR_TX+ENISR_TX_ERR);
1562 * Have to enter loopback mode and then restart the NIC before
1563 * you are allowed to slurp packets up off the ring.
1565 outb_p(E8390_TXOFF, e8390_base + EN0_TXCR);
1566 outb_p(E8390_NODMA + E8390_PAGE0 + E8390_START, e8390_base + E8390_CMD);
1569 * Clear the Rx ring of all the debris, and ack the interrupt.
1574 * Leave loopback mode, and resend any packet that got stopped.
1576 outb_p(E8390_TXCONFIG | info->duplex_flag, e8390_base + EN0_TXCR);
1578 outb_p(E8390_NODMA + E8390_PAGE0 + E8390_START + E8390_TRANS, e8390_base + E8390_CMD);
1582 * Collect the stats. This is called unlocked and from several contexts.
1585 static struct net_device_stats *get_stats(struct net_device *dev)
1587 long ioaddr = dev->base_addr;
1588 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
1589 unsigned long flags;
1591 /* If the card is stopped, just return the present stats. */
1592 if (!netif_running(dev))
1595 spin_lock_irqsave(&ei_local->page_lock,flags);
1596 /* Read the counter registers, assuming we are in page 0. */
1597 dev->stats.rx_frame_errors += inb_p(ioaddr + EN0_COUNTER0);
1598 dev->stats.rx_crc_errors += inb_p(ioaddr + EN0_COUNTER1);
1599 dev->stats.rx_missed_errors+= inb_p(ioaddr + EN0_COUNTER2);
1600 spin_unlock_irqrestore(&ei_local->page_lock, flags);
1606 * Form the 64 bit 8390 multicast table from the linked list of addresses
1607 * associated with this dev structure.
1610 static inline void make_mc_bits(u8 *bits, struct net_device *dev)
1612 struct netdev_hw_addr *ha;
1615 netdev_for_each_mc_addr(ha, dev) {
1616 crc = ether_crc(ETH_ALEN, ha->addr);
1618 * The 8390 uses the 6 most significant bits of the
1619 * CRC to index the multicast table.
1621 bits[crc>>29] |= (1<<((crc>>26)&7));
1626 * do_set_multicast_list - set/clear multicast filter
1627 * @dev: net device for which multicast filter is adjusted
1629 * Set or clear the multicast filter for this adaptor.
1630 * Must be called with lock held.
1633 static void do_set_multicast_list(struct net_device *dev)
1635 long e8390_base = dev->base_addr;
1637 struct ei_device *ei_local = (struct ei_device*)netdev_priv(dev);
1639 if (!(dev->flags&(IFF_PROMISC|IFF_ALLMULTI))) {
1640 memset(ei_local->mcfilter, 0, 8);
1641 if (!netdev_mc_empty(dev))
1642 make_mc_bits(ei_local->mcfilter, dev);
1644 /* set to accept-all */
1645 memset(ei_local->mcfilter, 0xFF, 8);
1648 outb_p(E8390_NODMA + E8390_PAGE1, e8390_base + E8390_CMD);
1649 for(i = 0; i < 8; i++)
1651 outb_p(ei_local->mcfilter[i], e8390_base + EN1_MULT_SHIFT(i));
1653 outb_p(E8390_NODMA + E8390_PAGE0, e8390_base + E8390_CMD);
1655 if(dev->flags&IFF_PROMISC)
1656 outb_p(E8390_RXCONFIG | 0x58, e8390_base + EN0_RXCR);
1657 else if (dev->flags & IFF_ALLMULTI || !netdev_mc_empty(dev))
1658 outb_p(E8390_RXCONFIG | 0x48, e8390_base + EN0_RXCR);
1660 outb_p(E8390_RXCONFIG | 0x40, e8390_base + EN0_RXCR);
1662 outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, e8390_base+E8390_CMD);
1666 * Called without lock held. This is invoked from user context and may
1667 * be parallel to just about everything else. Its also fairly quick and
1668 * not called too often. Must protect against both bh and irq users
1671 static void set_multicast_list(struct net_device *dev)
1673 unsigned long flags;
1675 spin_lock_irqsave(&dev_lock(dev), flags);
1676 do_set_multicast_list(dev);
1677 spin_unlock_irqrestore(&dev_lock(dev), flags);
1680 /* This page of functions should be 8390 generic */
1681 /* Follow National Semi's recommendations for initializing the "NIC". */
1684 * AX88190_init - initialize 8390 hardware
1685 * @dev: network device to initialize
1686 * @startp: boolean. non-zero value to initiate chip processing
1688 * Must be called with lock held.
1691 static void AX88190_init(struct net_device *dev, int startp)
1693 axnet_dev_t *info = PRIV(dev);
1694 long e8390_base = dev->base_addr;
1695 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
1697 int endcfg = ei_local->word16 ? (0x48 | ENDCFG_WTS) : 0x48;
1699 if(sizeof(struct e8390_pkt_hdr)!=4)
1700 panic("8390.c: header struct mispacked\n");
1701 /* Follow National Semi's recommendations for initing the DP83902. */
1702 outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base+E8390_CMD); /* 0x21 */
1703 outb_p(endcfg, e8390_base + EN0_DCFG); /* 0x48 or 0x49 */
1704 /* Clear the remote byte count registers. */
1705 outb_p(0x00, e8390_base + EN0_RCNTLO);
1706 outb_p(0x00, e8390_base + EN0_RCNTHI);
1707 /* Set to monitor and loopback mode -- this is vital!. */
1708 outb_p(E8390_RXOFF|0x40, e8390_base + EN0_RXCR); /* 0x60 */
1709 outb_p(E8390_TXOFF, e8390_base + EN0_TXCR); /* 0x02 */
1710 /* Set the transmit page and receive ring. */
1711 outb_p(ei_local->tx_start_page, e8390_base + EN0_TPSR);
1712 ei_local->tx1 = ei_local->tx2 = 0;
1713 outb_p(ei_local->rx_start_page, e8390_base + EN0_STARTPG);
1714 outb_p(ei_local->stop_page-1, e8390_base + EN0_BOUNDARY); /* 3c503 says 0x3f,NS0x26*/
1715 ei_local->current_page = ei_local->rx_start_page; /* assert boundary+1 */
1716 outb_p(ei_local->stop_page, e8390_base + EN0_STOPPG);
1717 /* Clear the pending interrupts and mask. */
1718 outb_p(0xFF, e8390_base + EN0_ISR);
1719 outb_p(0x00, e8390_base + EN0_IMR);
1721 /* Copy the station address into the DS8390 registers. */
1723 outb_p(E8390_NODMA + E8390_PAGE1 + E8390_STOP, e8390_base+E8390_CMD); /* 0x61 */
1724 for(i = 0; i < 6; i++)
1726 outb_p(dev->dev_addr[i], e8390_base + EN1_PHYS_SHIFT(i));
1727 if(inb_p(e8390_base + EN1_PHYS_SHIFT(i))!=dev->dev_addr[i])
1728 printk(KERN_ERR "Hw. address read/write mismap %d\n",i);
1731 outb_p(ei_local->rx_start_page, e8390_base + EN1_CURPAG);
1732 outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base+E8390_CMD);
1734 netif_start_queue(dev);
1735 ei_local->tx1 = ei_local->tx2 = 0;
1736 ei_local->txing = 0;
1738 if (info->flags & IS_AX88790) /* select Internal PHY */
1739 outb(0x10, e8390_base + AXNET_GPIO);
1743 outb_p(0xff, e8390_base + EN0_ISR);
1744 outb_p(ENISR_ALL, e8390_base + EN0_IMR);
1745 outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, e8390_base+E8390_CMD);
1746 outb_p(E8390_TXCONFIG | info->duplex_flag,
1747 e8390_base + EN0_TXCR); /* xmit on. */
1748 /* 3c503 TechMan says rxconfig only after the NIC is started. */
1749 outb_p(E8390_RXCONFIG | 0x40, e8390_base + EN0_RXCR); /* rx on, */
1750 do_set_multicast_list(dev); /* (re)load the mcast table */
1754 /* Trigger a transmit start, assuming the length is valid.
1755 Always called with the page lock held */
1757 static void NS8390_trigger_send(struct net_device *dev, unsigned int length,
1760 long e8390_base = dev->base_addr;
1761 struct ei_device *ei_local __attribute((unused)) = (struct ei_device *) netdev_priv(dev);
1763 if (inb_p(e8390_base) & E8390_TRANS)
1765 printk(KERN_WARNING "%s: trigger_send() called with the transmitter busy.\n",
1769 outb_p(length & 0xff, e8390_base + EN0_TCNTLO);
1770 outb_p(length >> 8, e8390_base + EN0_TCNTHI);
1771 outb_p(start_page, e8390_base + EN0_TPSR);
1772 outb_p(E8390_NODMA+E8390_TRANS+E8390_START, e8390_base+E8390_CMD);