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/slab.h>
32 #include <linux/string.h>
33 #include <linux/timer.h>
34 #include <linux/delay.h>
35 #include <linux/spinlock.h>
36 #include <linux/ethtool.h>
37 #include <linux/netdevice.h>
40 #include <pcmcia/version.h>
41 #include <pcmcia/cs_types.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");
76 #define INT_MODULE_PARM(n, v) static int n = v; MODULE_PARM(n, "i")
78 /* Bit map of interrupts to choose from */
79 INT_MODULE_PARM(irq_mask, 0xdeb8);
80 static int irq_list[4] = { -1 };
81 MODULE_PARM(irq_list, "1-4i");
84 INT_MODULE_PARM(pc_debug, PCMCIA_DEBUG);
85 #define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
86 static char *version =
87 "axnet_cs.c 1.28 2002/06/29 06:27:37 (David Hinds)";
89 #define DEBUG(n, args...)
92 /*====================================================================*/
94 static void axnet_config(dev_link_t *link);
95 static void axnet_release(dev_link_t *link);
96 static int axnet_event(event_t event, int priority,
97 event_callback_args_t *args);
98 static int axnet_open(struct net_device *dev);
99 static int axnet_close(struct net_device *dev);
100 static int axnet_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
101 static struct ethtool_ops netdev_ethtool_ops;
102 static irqreturn_t ei_irq_wrapper(int irq, void *dev_id, struct pt_regs *regs);
103 static void ei_watchdog(u_long arg);
104 static void axnet_reset_8390(struct net_device *dev);
106 static int mdio_read(ioaddr_t addr, int phy_id, int loc);
107 static void mdio_write(ioaddr_t addr, int phy_id, int loc, int value);
109 static void get_8390_hdr(struct net_device *,
110 struct e8390_pkt_hdr *, int);
111 static void block_input(struct net_device *dev, int count,
112 struct sk_buff *skb, int ring_offset);
113 static void block_output(struct net_device *dev, int count,
114 const u_char *buf, const int start_page);
116 static dev_link_t *axnet_attach(void);
117 static void axnet_detach(dev_link_t *);
119 static dev_info_t dev_info = "axnet_cs";
120 static dev_link_t *dev_list;
122 static void axdev_setup(struct net_device *dev);
123 static void AX88190_init(struct net_device *dev, int startp);
124 static int ax_open(struct net_device *dev);
125 static int ax_close(struct net_device *dev);
126 static irqreturn_t ax_interrupt(int irq, void *dev_id, struct pt_regs *regs);
128 /*====================================================================*/
130 typedef struct axnet_dev_t {
134 struct timer_list watchdog;
135 int stale, fast_poll;
142 static inline axnet_dev_t *PRIV(struct net_device *dev)
144 void *p = (char *)netdev_priv(dev) + sizeof(struct ei_device);
148 /*======================================================================
150 axnet_attach() creates an "instance" of the driver, allocating
151 local data structures for one device. The device is registered
154 ======================================================================*/
156 static dev_link_t *axnet_attach(void)
160 struct net_device *dev;
161 client_reg_t client_reg;
164 DEBUG(0, "axnet_attach()\n");
166 dev = alloc_netdev(sizeof(struct ei_device) + sizeof(axnet_dev_t),
167 "eth%d", axdev_setup);
175 link->irq.Attributes = IRQ_TYPE_EXCLUSIVE;
176 link->irq.IRQInfo1 = IRQ_INFO2_VALID|IRQ_LEVEL_ID;
177 if (irq_list[0] == -1)
178 link->irq.IRQInfo2 = irq_mask;
180 for (i = 0; i < 4; i++)
181 link->irq.IRQInfo2 |= 1 << irq_list[i];
182 link->conf.Attributes = CONF_ENABLE_IRQ;
183 link->conf.IntType = INT_MEMORY_AND_IO;
185 dev->open = &axnet_open;
186 dev->stop = &axnet_close;
187 dev->do_ioctl = &axnet_ioctl;
188 SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
190 /* Register with Card Services */
191 link->next = dev_list;
193 client_reg.dev_info = &dev_info;
194 client_reg.Attributes = INFO_IO_CLIENT | INFO_CARD_SHARE;
195 client_reg.EventMask =
196 CS_EVENT_CARD_INSERTION | CS_EVENT_CARD_REMOVAL |
197 CS_EVENT_RESET_PHYSICAL | CS_EVENT_CARD_RESET |
198 CS_EVENT_PM_SUSPEND | CS_EVENT_PM_RESUME;
199 client_reg.event_handler = &axnet_event;
200 client_reg.Version = 0x0210;
201 client_reg.event_callback_args.client_data = link;
202 ret = pcmcia_register_client(&link->handle, &client_reg);
203 if (ret != CS_SUCCESS) {
204 cs_error(link->handle, RegisterClient, ret);
212 /*======================================================================
214 This deletes a driver "instance". The device is de-registered
215 with Card Services. If it has been released, all local data
216 structures are freed. Otherwise, the structures will be freed
217 when the device is released.
219 ======================================================================*/
221 static void axnet_detach(dev_link_t *link)
223 struct net_device *dev = link->priv;
226 DEBUG(0, "axnet_detach(0x%p)\n", link);
228 /* Locate device structure */
229 for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next)
230 if (*linkp == link) break;
235 unregister_netdev(dev);
237 if (link->state & DEV_CONFIG)
241 pcmcia_deregister_client(link->handle);
243 /* Unlink device structure, free bits */
248 /*======================================================================
250 This probes for a card's hardware address by reading the PROM.
252 ======================================================================*/
254 static int get_prom(dev_link_t *link)
256 struct net_device *dev = link->priv;
257 ioaddr_t ioaddr = dev->base_addr;
260 /* This is based on drivers/net/ne.c */
262 u_char value, offset;
264 {E8390_NODMA+E8390_PAGE0+E8390_STOP, E8390_CMD}, /* Select page 0*/
265 {0x01, EN0_DCFG}, /* Set word-wide access. */
266 {0x00, EN0_RCNTLO}, /* Clear the count regs. */
268 {0x00, EN0_IMR}, /* Mask completion irq. */
270 {E8390_RXOFF|0x40, EN0_RXCR}, /* 0x60 Set to monitor */
271 {E8390_TXOFF, EN0_TXCR}, /* 0x02 and loopback mode. */
274 {0x00, EN0_RSARLO}, /* DMA starting at 0x0400. */
276 {E8390_RREAD+E8390_START, E8390_CMD},
279 /* Not much of a test, but the alternatives are messy */
280 if (link->conf.ConfigBase != 0x03c0)
283 axnet_reset_8390(dev);
286 for (i = 0; i < sizeof(program_seq)/sizeof(program_seq[0]); i++)
287 outb_p(program_seq[i].value, ioaddr + program_seq[i].offset);
289 for (i = 0; i < 6; i += 2) {
290 j = inw(ioaddr + AXNET_DATAPORT);
291 dev->dev_addr[i] = j & 0xff;
292 dev->dev_addr[i+1] = j >> 8;
297 /*======================================================================
299 axnet_config() is scheduled to run after a CARD_INSERTION event
300 is received, to configure the PCMCIA socket, and to make the
301 ethernet device available to the system.
303 ======================================================================*/
305 #define CS_CHECK(fn, ret) \
306 do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
308 static int try_io_port(dev_link_t *link)
311 if (link->io.NumPorts1 == 32) {
312 link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
313 if (link->io.NumPorts2 > 0) {
314 /* for master/slave multifunction cards */
315 link->io.Attributes2 = IO_DATA_PATH_WIDTH_8;
316 link->irq.Attributes =
317 IRQ_TYPE_DYNAMIC_SHARING|IRQ_FIRST_SHARED;
320 /* This should be two 16-port windows */
321 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
322 link->io.Attributes2 = IO_DATA_PATH_WIDTH_16;
324 if (link->io.BasePort1 == 0) {
325 link->io.IOAddrLines = 16;
326 for (j = 0; j < 0x400; j += 0x20) {
327 link->io.BasePort1 = j ^ 0x300;
328 link->io.BasePort2 = (j ^ 0x300) + 0x10;
329 ret = pcmcia_request_io(link->handle, &link->io);
330 if (ret == CS_SUCCESS) return ret;
334 return pcmcia_request_io(link->handle, &link->io);
338 static void axnet_config(dev_link_t *link)
340 client_handle_t handle = link->handle;
341 struct net_device *dev = link->priv;
342 axnet_dev_t *info = PRIV(dev);
345 int i, j, last_ret, last_fn;
349 DEBUG(0, "axnet_config(0x%p)\n", link);
351 tuple.Attributes = 0;
352 tuple.TupleData = (cisdata_t *)buf;
353 tuple.TupleDataMax = sizeof(buf);
354 tuple.TupleOffset = 0;
355 tuple.DesiredTuple = CISTPL_CONFIG;
356 CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
357 CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple));
358 CS_CHECK(ParseTuple, pcmcia_parse_tuple(handle, &tuple, &parse));
359 link->conf.ConfigBase = parse.config.base;
360 /* don't trust the CIS on this; Linksys got it wrong */
361 link->conf.Present = 0x63;
364 link->state |= DEV_CONFIG;
366 /* Look up current Vcc */
367 CS_CHECK(GetConfigurationInfo, pcmcia_get_configuration_info(handle, &conf));
368 link->conf.Vcc = conf.Vcc;
370 tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
371 tuple.Attributes = 0;
372 CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
373 while (last_ret == CS_SUCCESS) {
374 cistpl_cftable_entry_t *cfg = &(parse.cftable_entry);
375 cistpl_io_t *io = &(parse.cftable_entry.io);
377 if (pcmcia_get_tuple_data(handle, &tuple) != 0 ||
378 pcmcia_parse_tuple(handle, &tuple, &parse) != 0 ||
379 cfg->index == 0 || cfg->io.nwin == 0)
382 link->conf.ConfigIndex = 0x05;
383 /* For multifunction cards, by convention, we configure the
384 network function with window 0, and serial with window 1 */
386 i = (io->win[1].len > io->win[0].len);
387 link->io.BasePort2 = io->win[1-i].base;
388 link->io.NumPorts2 = io->win[1-i].len;
390 i = link->io.NumPorts2 = 0;
392 link->io.BasePort1 = io->win[i].base;
393 link->io.NumPorts1 = io->win[i].len;
394 link->io.IOAddrLines = io->flags & CISTPL_IO_LINES_MASK;
395 if (link->io.NumPorts1 + link->io.NumPorts2 >= 32) {
396 last_ret = try_io_port(link);
397 if (last_ret == CS_SUCCESS) break;
400 last_ret = pcmcia_get_next_tuple(handle, &tuple);
402 if (last_ret != CS_SUCCESS) {
403 cs_error(handle, RequestIO, last_ret);
407 CS_CHECK(RequestIRQ, pcmcia_request_irq(handle, &link->irq));
409 if (link->io.NumPorts2 == 8) {
410 link->conf.Attributes |= CONF_ENABLE_SPKR;
411 link->conf.Status = CCSR_AUDIO_ENA;
414 CS_CHECK(RequestConfiguration, pcmcia_request_configuration(handle, &link->conf));
415 dev->irq = link->irq.AssignedIRQ;
416 dev->base_addr = link->io.BasePort1;
418 if (!get_prom(link)) {
419 printk(KERN_NOTICE "axnet_cs: this is not an AX88190 card!\n");
420 printk(KERN_NOTICE "axnet_cs: use pcnet_cs instead.\n");
424 ei_status.name = "AX88190";
425 ei_status.word16 = 1;
426 ei_status.tx_start_page = AXNET_START_PG;
427 ei_status.rx_start_page = AXNET_START_PG + TX_PAGES;
428 ei_status.stop_page = AXNET_STOP_PG;
429 ei_status.reset_8390 = &axnet_reset_8390;
430 ei_status.get_8390_hdr = &get_8390_hdr;
431 ei_status.block_input = &block_input;
432 ei_status.block_output = &block_output;
434 if (inb(dev->base_addr + AXNET_TEST) != 0)
435 info->flags |= IS_AX88790;
437 info->flags |= IS_AX88190;
439 if (info->flags & IS_AX88790)
440 outb(0x10, dev->base_addr + AXNET_GPIO); /* select Internal PHY */
442 for (i = 0; i < 32; i++) {
443 j = mdio_read(dev->base_addr + AXNET_MII_EEP, i, 1);
444 if ((j != 0) && (j != 0xffff)) break;
447 /* Maybe PHY is in power down mode. (PPD_SET = 1)
448 Bit 2 of CCSR is active low. */
450 conf_reg_t reg = { 0, CS_WRITE, CISREG_CCSR, 0x04 };
451 pcmcia_access_configuration_register(link->handle, ®);
452 for (i = 0; i < 32; i++) {
453 j = mdio_read(dev->base_addr + AXNET_MII_EEP, i, 1);
454 if ((j != 0) && (j != 0xffff)) break;
458 info->phy_id = (i < 32) ? i : -1;
459 link->dev = &info->node;
460 link->state &= ~DEV_CONFIG_PENDING;
462 if (register_netdev(dev) != 0) {
463 printk(KERN_NOTICE "axnet_cs: register_netdev() failed\n");
468 strcpy(info->node.dev_name, dev->name);
470 printk(KERN_INFO "%s: Asix AX88%d90: io %#3lx, irq %d, hw_addr ",
471 dev->name, ((info->flags & IS_AX88790) ? 7 : 1),
472 dev->base_addr, dev->irq);
473 for (i = 0; i < 6; i++)
474 printk("%02X%s", dev->dev_addr[i], ((i<5) ? ":" : "\n"));
475 if (info->phy_id != -1) {
476 DEBUG(0, " MII transceiver at index %d, status %x.\n", info->phy_id, j);
478 printk(KERN_NOTICE " No MII transceivers found!\n");
483 cs_error(link->handle, last_fn, last_ret);
486 link->state &= ~DEV_CONFIG_PENDING;
490 /*======================================================================
492 After a card is removed, axnet_release() will unregister the net
493 device, and release the PCMCIA configuration. If the device is
494 still open, this will be postponed until it is closed.
496 ======================================================================*/
498 static void axnet_release(dev_link_t *link)
500 DEBUG(0, "axnet_release(0x%p)\n", link);
502 pcmcia_release_configuration(link->handle);
503 pcmcia_release_io(link->handle, &link->io);
504 pcmcia_release_irq(link->handle, &link->irq);
506 link->state &= ~DEV_CONFIG;
509 /*======================================================================
511 The card status event handler. Mostly, this schedules other
512 stuff to run after an event is received. A CARD_REMOVAL event
513 also sets some flags to discourage the net drivers from trying
514 to talk to the card any more.
516 ======================================================================*/
518 static int axnet_event(event_t event, int priority,
519 event_callback_args_t *args)
521 dev_link_t *link = args->client_data;
522 struct net_device *dev = link->priv;
524 DEBUG(2, "axnet_event(0x%06x)\n", event);
527 case CS_EVENT_CARD_REMOVAL:
528 link->state &= ~DEV_PRESENT;
529 if (link->state & DEV_CONFIG)
530 netif_device_detach(dev);
532 case CS_EVENT_CARD_INSERTION:
533 link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
536 case CS_EVENT_PM_SUSPEND:
537 link->state |= DEV_SUSPEND;
538 /* Fall through... */
539 case CS_EVENT_RESET_PHYSICAL:
540 if (link->state & DEV_CONFIG) {
542 netif_device_detach(dev);
543 pcmcia_release_configuration(link->handle);
546 case CS_EVENT_PM_RESUME:
547 link->state &= ~DEV_SUSPEND;
548 /* Fall through... */
549 case CS_EVENT_CARD_RESET:
550 if (link->state & DEV_CONFIG) {
551 pcmcia_request_configuration(link->handle, &link->conf);
553 axnet_reset_8390(dev);
554 AX88190_init(dev, 1);
555 netif_device_attach(dev);
563 /*======================================================================
565 MII interface support
567 ======================================================================*/
569 #define MDIO_SHIFT_CLK 0x01
570 #define MDIO_DATA_WRITE0 0x00
571 #define MDIO_DATA_WRITE1 0x08
572 #define MDIO_DATA_READ 0x04
573 #define MDIO_MASK 0x0f
574 #define MDIO_ENB_IN 0x02
576 static void mdio_sync(ioaddr_t addr)
579 for (bits = 0; bits < 32; bits++) {
580 outb_p(MDIO_DATA_WRITE1, addr);
581 outb_p(MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, addr);
585 static int mdio_read(ioaddr_t addr, int phy_id, int loc)
587 u_int cmd = (0xf6<<10)|(phy_id<<5)|loc;
591 for (i = 14; i >= 0; i--) {
592 int dat = (cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
594 outb_p(dat | MDIO_SHIFT_CLK, addr);
596 for (i = 19; i > 0; i--) {
597 outb_p(MDIO_ENB_IN, addr);
598 retval = (retval << 1) | ((inb_p(addr) & MDIO_DATA_READ) != 0);
599 outb_p(MDIO_ENB_IN | MDIO_SHIFT_CLK, addr);
601 return (retval>>1) & 0xffff;
604 static void mdio_write(ioaddr_t addr, int phy_id, int loc, int value)
606 u_int cmd = (0x05<<28)|(phy_id<<23)|(loc<<18)|(1<<17)|value;
610 for (i = 31; i >= 0; i--) {
611 int dat = (cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
613 outb_p(dat | MDIO_SHIFT_CLK, addr);
615 for (i = 1; i >= 0; i--) {
616 outb_p(MDIO_ENB_IN, addr);
617 outb_p(MDIO_ENB_IN | MDIO_SHIFT_CLK, addr);
621 /*====================================================================*/
623 static int axnet_open(struct net_device *dev)
625 axnet_dev_t *info = PRIV(dev);
626 dev_link_t *link = &info->link;
628 DEBUG(2, "axnet_open('%s')\n", dev->name);
635 request_irq(dev->irq, ei_irq_wrapper, SA_SHIRQ, dev_info, dev);
637 info->link_status = 0x00;
638 init_timer(&info->watchdog);
639 info->watchdog.function = &ei_watchdog;
640 info->watchdog.data = (u_long)dev;
641 info->watchdog.expires = jiffies + HZ;
642 add_timer(&info->watchdog);
647 /*====================================================================*/
649 static int axnet_close(struct net_device *dev)
651 axnet_dev_t *info = PRIV(dev);
652 dev_link_t *link = &info->link;
654 DEBUG(2, "axnet_close('%s')\n", dev->name);
657 free_irq(dev->irq, dev);
660 netif_stop_queue(dev);
661 del_timer_sync(&info->watchdog);
666 /*======================================================================
668 Hard reset the card. This used to pause for the same period that
669 a 8390 reset command required, but that shouldn't be necessary.
671 ======================================================================*/
673 static void axnet_reset_8390(struct net_device *dev)
675 ioaddr_t nic_base = dev->base_addr;
678 ei_status.txing = ei_status.dmaing = 0;
680 outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, nic_base + E8390_CMD);
682 outb(inb(nic_base + AXNET_RESET), nic_base + AXNET_RESET);
684 for (i = 0; i < 100; i++) {
685 if ((inb_p(nic_base+EN0_ISR) & ENISR_RESET) != 0)
689 outb_p(ENISR_RESET, nic_base + EN0_ISR); /* Ack intr. */
692 printk(KERN_ERR "%s: axnet_reset_8390() did not complete.\n",
695 } /* axnet_reset_8390 */
697 /*====================================================================*/
699 static irqreturn_t ei_irq_wrapper(int irq, void *dev_id, struct pt_regs *regs)
701 struct net_device *dev = dev_id;
702 PRIV(dev)->stale = 0;
703 return ax_interrupt(irq, dev_id, regs);
706 static void ei_watchdog(u_long arg)
708 struct net_device *dev = (struct net_device *)(arg);
709 axnet_dev_t *info = PRIV(dev);
710 ioaddr_t nic_base = dev->base_addr;
711 ioaddr_t mii_addr = nic_base + AXNET_MII_EEP;
714 if (!netif_device_present(dev)) goto reschedule;
716 /* Check for pending interrupt with expired latency timer: with
717 this, we can limp along even if the interrupt is blocked */
718 if (info->stale++ && (inb_p(nic_base + EN0_ISR) & ENISR_ALL)) {
719 if (!info->fast_poll)
720 printk(KERN_INFO "%s: interrupt(s) dropped!\n", dev->name);
721 ei_irq_wrapper(dev->irq, dev, NULL);
722 info->fast_poll = HZ;
724 if (info->fast_poll) {
726 info->watchdog.expires = jiffies + 1;
727 add_timer(&info->watchdog);
731 if (info->phy_id < 0)
733 link = mdio_read(mii_addr, info->phy_id, 1);
734 if (!link || (link == 0xffff)) {
735 printk(KERN_INFO "%s: MII is missing!\n", dev->name);
741 if (link != info->link_status) {
742 u_short p = mdio_read(mii_addr, info->phy_id, 5);
743 printk(KERN_INFO "%s: %s link beat\n", dev->name,
744 (link) ? "found" : "lost");
746 info->duplex_flag = (p & 0x0140) ? 0x80 : 0x00;
748 printk(KERN_INFO "%s: autonegotiation complete: "
749 "%sbaseT-%cD selected\n", dev->name,
750 ((p & 0x0180) ? "100" : "10"),
751 ((p & 0x0140) ? 'F' : 'H'));
753 printk(KERN_INFO "%s: link partner did not autonegotiate\n",
755 AX88190_init(dev, 1);
757 info->link_status = link;
761 info->watchdog.expires = jiffies + HZ;
762 add_timer(&info->watchdog);
765 static void netdev_get_drvinfo(struct net_device *dev,
766 struct ethtool_drvinfo *info)
768 strcpy(info->driver, "axnet_cs");
771 static struct ethtool_ops netdev_ethtool_ops = {
772 .get_drvinfo = netdev_get_drvinfo,
775 /*====================================================================*/
777 static int axnet_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
779 axnet_dev_t *info = PRIV(dev);
780 u16 *data = (u16 *)&rq->ifr_ifru;
781 ioaddr_t mii_addr = dev->base_addr + AXNET_MII_EEP;
784 data[0] = info->phy_id;
785 case SIOCGMIIREG: /* Read MII PHY register. */
786 data[3] = mdio_read(mii_addr, data[0], data[1] & 0x1f);
788 case SIOCSMIIREG: /* Write MII PHY register. */
789 if (!capable(CAP_NET_ADMIN))
791 mdio_write(mii_addr, data[0], data[1] & 0x1f, data[2]);
797 /*====================================================================*/
799 static void get_8390_hdr(struct net_device *dev,
800 struct e8390_pkt_hdr *hdr,
803 ioaddr_t nic_base = dev->base_addr;
805 outb_p(0, nic_base + EN0_RSARLO); /* On page boundary */
806 outb_p(ring_page, nic_base + EN0_RSARHI);
807 outb_p(E8390_RREAD+E8390_START, nic_base + AXNET_CMD);
809 insw(nic_base + AXNET_DATAPORT, hdr,
810 sizeof(struct e8390_pkt_hdr)>>1);
811 /* Fix for big endian systems */
812 hdr->count = le16_to_cpu(hdr->count);
816 /*====================================================================*/
818 static void block_input(struct net_device *dev, int count,
819 struct sk_buff *skb, int ring_offset)
821 ioaddr_t nic_base = dev->base_addr;
822 int xfer_count = count;
823 char *buf = skb->data;
826 if ((ei_debug > 4) && (count != 4))
827 printk(KERN_DEBUG "%s: [bi=%d]\n", dev->name, count+4);
829 outb_p(ring_offset & 0xff, nic_base + EN0_RSARLO);
830 outb_p(ring_offset >> 8, nic_base + EN0_RSARHI);
831 outb_p(E8390_RREAD+E8390_START, nic_base + AXNET_CMD);
833 insw(nic_base + AXNET_DATAPORT,buf,count>>1);
835 buf[count-1] = inb(nic_base + AXNET_DATAPORT), xfer_count++;
839 /*====================================================================*/
841 static void block_output(struct net_device *dev, int count,
842 const u_char *buf, const int start_page)
844 ioaddr_t nic_base = dev->base_addr;
848 printk(KERN_DEBUG "%s: [bo=%d]\n", dev->name, count);
851 /* Round the count up for word writes. Do we need to do this?
852 What effect will an odd byte count have on the 8390?
853 I should check someday. */
857 outb_p(0x00, nic_base + EN0_RSARLO);
858 outb_p(start_page, nic_base + EN0_RSARHI);
859 outb_p(E8390_RWRITE+E8390_START, nic_base + AXNET_CMD);
860 outsw(nic_base + AXNET_DATAPORT, buf, count>>1);
863 static struct pcmcia_driver axnet_cs_driver = {
864 .owner = THIS_MODULE,
868 .attach = axnet_attach,
869 .detach = axnet_detach,
872 static int __init init_axnet_cs(void)
874 return pcmcia_register_driver(&axnet_cs_driver);
877 static void __exit exit_axnet_cs(void)
879 pcmcia_unregister_driver(&axnet_cs_driver);
880 while (dev_list != NULL)
881 axnet_detach(dev_list);
884 module_init(init_axnet_cs);
885 module_exit(exit_axnet_cs);
887 /*====================================================================*/
889 /* 8390.c: A general NS8390 ethernet driver core for linux. */
891 Written 1992-94 by Donald Becker.
893 Copyright 1993 United States Government as represented by the
894 Director, National Security Agency.
896 This software may be used and distributed according to the terms
897 of the GNU General Public License, incorporated herein by reference.
899 The author may be reached as becker@scyld.com, or C/O
900 Scyld Computing Corporation
901 410 Severn Ave., Suite 210
904 This is the chip-specific code for many 8390-based ethernet adaptors.
905 This is not a complete driver, it must be combined with board-specific
906 code such as ne.c, wd.c, 3c503.c, etc.
908 Seeing how at least eight drivers use this code, (not counting the
909 PCMCIA ones either) it is easy to break some card by what seems like
910 a simple innocent change. Please contact me or Donald if you think
911 you have found something that needs changing. -- PG
915 Paul Gortmaker : remove set_bit lock, other cleanups.
916 Paul Gortmaker : add ei_get_8390_hdr() so we can pass skb's to
917 ei_block_input() for eth_io_copy_and_sum().
918 Paul Gortmaker : exchange static int ei_pingpong for a #define,
919 also add better Tx error handling.
920 Paul Gortmaker : rewrite Rx overrun handling as per NS specs.
921 Alexey Kuznetsov : use the 8390's six bit hash multicast filter.
922 Paul Gortmaker : tweak ANK's above multicast changes a bit.
923 Paul Gortmaker : update packet statistics for v2.1.x
924 Alan Cox : support arbitary stupid port mappings on the
925 68K Macintosh. Support >16bit I/O spaces
926 Paul Gortmaker : add kmod support for auto-loading of the 8390
927 module by all drivers that require it.
928 Alan Cox : Spinlocking work, added 'BUG_83C690'
929 Paul Gortmaker : Separate out Tx timeout code from Tx path.
932 The National Semiconductor LAN Databook, and the 3Com 3c503 databook.
936 static const char *version_8390 =
937 "8390.c:v1.10cvs 9/23/94 Donald Becker (becker@scyld.com)\n";
939 #include <asm/bitops.h>
941 #include <linux/fcntl.h>
942 #include <linux/in.h>
943 #include <linux/interrupt.h>
945 #include <linux/etherdevice.h>
949 /* These are the operational function interfaces to board-specific
951 void reset_8390(struct net_device *dev)
952 Resets the board associated with DEV, including a hardware reset of
953 the 8390. This is only called when there is a transmit timeout, and
954 it is always followed by 8390_init().
955 void block_output(struct net_device *dev, int count, const unsigned char *buf,
957 Write the COUNT bytes of BUF to the packet buffer at START_PAGE. The
958 "page" value uses the 8390's 256-byte pages.
959 void get_8390_hdr(struct net_device *dev, struct e8390_hdr *hdr, int ring_page)
960 Read the 4 byte, page aligned 8390 header. *If* there is a
961 subsequent read, it will be of the rest of the packet.
962 void block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
963 Read COUNT bytes from the packet buffer into the skb data area. Start
964 reading from RING_OFFSET, the address as the 8390 sees it. This will always
965 follow the read of the 8390 header.
967 #define ei_reset_8390 (ei_local->reset_8390)
968 #define ei_block_output (ei_local->block_output)
969 #define ei_block_input (ei_local->block_input)
970 #define ei_get_8390_hdr (ei_local->get_8390_hdr)
972 /* use 0 for production, 1 for verification, >2 for debug */
977 /* Index to functions. */
978 static void ei_tx_intr(struct net_device *dev);
979 static void ei_tx_err(struct net_device *dev);
980 static void ei_tx_timeout(struct net_device *dev);
981 static void ei_receive(struct net_device *dev);
982 static void ei_rx_overrun(struct net_device *dev);
984 /* Routines generic to NS8390-based boards. */
985 static void NS8390_trigger_send(struct net_device *dev, unsigned int length,
987 static void set_multicast_list(struct net_device *dev);
988 static void do_set_multicast_list(struct net_device *dev);
991 * SMP and the 8390 setup.
993 * The 8390 isnt exactly designed to be multithreaded on RX/TX. There is
994 * a page register that controls bank and packet buffer access. We guard
995 * this with ei_local->page_lock. Nobody should assume or set the page other
996 * than zero when the lock is not held. Lock holders must restore page 0
997 * before unlocking. Even pure readers must take the lock to protect in
1000 * To make life difficult the chip can also be very slow. We therefore can't
1001 * just use spinlocks. For the longer lockups we disable the irq the device
1002 * sits on and hold the lock. We must hold the lock because there is a dual
1003 * processor case other than interrupts (get stats/set multicast list in
1004 * parallel with each other and transmit).
1006 * Note: in theory we can just disable the irq on the card _but_ there is
1007 * a latency on SMP irq delivery. So we can easily go "disable irq" "sync irqs"
1008 * enter lock, take the queued irq. So we waddle instead of flying.
1010 * Finally by special arrangement for the purpose of being generally
1011 * annoying the transmit function is called bh atomic. That places
1012 * restrictions on the user context callers as disable_irq won't save
1017 * ax_open - Open/initialize the board.
1018 * @dev: network device to initialize
1020 * This routine goes all-out, setting everything
1021 * up anew at each open, even though many of these registers should only
1022 * need to be set once at boot.
1024 static int ax_open(struct net_device *dev)
1026 unsigned long flags;
1027 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
1029 #ifdef HAVE_TX_TIMEOUT
1030 /* The card I/O part of the driver (e.g. 3c503) can hook a Tx timeout
1031 wrapper that does e.g. media check & then calls ei_tx_timeout. */
1032 if (dev->tx_timeout == NULL)
1033 dev->tx_timeout = ei_tx_timeout;
1034 if (dev->watchdog_timeo <= 0)
1035 dev->watchdog_timeo = TX_TIMEOUT;
1039 * Grab the page lock so we own the register set, then call
1040 * the init function.
1043 spin_lock_irqsave(&ei_local->page_lock, flags);
1044 AX88190_init(dev, 1);
1045 /* Set the flag before we drop the lock, That way the IRQ arrives
1046 after its set and we get no silly warnings */
1047 netif_start_queue(dev);
1048 spin_unlock_irqrestore(&ei_local->page_lock, flags);
1049 ei_local->irqlock = 0;
1053 #define dev_lock(dev) (((struct ei_device *)netdev_priv(dev))->page_lock)
1056 * ax_close - shut down network device
1057 * @dev: network device to close
1059 * Opposite of ax_open(). Only used when "ifconfig <devname> down" is done.
1061 int ax_close(struct net_device *dev)
1063 unsigned long flags;
1066 * Hold the page lock during close
1069 spin_lock_irqsave(&dev_lock(dev), flags);
1070 AX88190_init(dev, 0);
1071 spin_unlock_irqrestore(&dev_lock(dev), flags);
1072 netif_stop_queue(dev);
1077 * ei_tx_timeout - handle transmit time out condition
1078 * @dev: network device which has apparently fallen asleep
1080 * Called by kernel when device never acknowledges a transmit has
1081 * completed (or failed) - i.e. never posted a Tx related interrupt.
1084 void ei_tx_timeout(struct net_device *dev)
1086 long e8390_base = dev->base_addr;
1087 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
1088 int txsr, isr, tickssofar = jiffies - dev->trans_start;
1089 unsigned long flags;
1091 ei_local->stat.tx_errors++;
1093 spin_lock_irqsave(&ei_local->page_lock, flags);
1094 txsr = inb(e8390_base+EN0_TSR);
1095 isr = inb(e8390_base+EN0_ISR);
1096 spin_unlock_irqrestore(&ei_local->page_lock, flags);
1098 printk(KERN_DEBUG "%s: Tx timed out, %s TSR=%#2x, ISR=%#2x, t=%d.\n",
1099 dev->name, (txsr & ENTSR_ABT) ? "excess collisions." :
1100 (isr) ? "lost interrupt?" : "cable problem?", txsr, isr, tickssofar);
1102 if (!isr && !ei_local->stat.tx_packets)
1104 /* The 8390 probably hasn't gotten on the cable yet. */
1105 ei_local->interface_num ^= 1; /* Try a different xcvr. */
1108 /* Ugly but a reset can be slow, yet must be protected */
1110 disable_irq_nosync(dev->irq);
1111 spin_lock(&ei_local->page_lock);
1113 /* Try to restart the card. Perhaps the user has fixed something. */
1115 AX88190_init(dev, 1);
1117 spin_unlock(&ei_local->page_lock);
1118 enable_irq(dev->irq);
1119 netif_wake_queue(dev);
1123 * ei_start_xmit - begin packet transmission
1124 * @skb: packet to be sent
1125 * @dev: network device to which packet is sent
1127 * Sends a packet to an 8390 network device.
1130 static int ei_start_xmit(struct sk_buff *skb, struct net_device *dev)
1132 long e8390_base = dev->base_addr;
1133 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
1134 int length, send_length, output_page;
1135 unsigned long flags;
1136 u8 packet[ETH_ZLEN];
1138 netif_stop_queue(dev);
1142 /* Mask interrupts from the ethercard.
1143 SMP: We have to grab the lock here otherwise the IRQ handler
1144 on another CPU can flip window and race the IRQ mask set. We end
1145 up trashing the mcast filter not disabling irqs if we don't lock */
1147 spin_lock_irqsave(&ei_local->page_lock, flags);
1148 outb_p(0x00, e8390_base + EN0_IMR);
1149 spin_unlock_irqrestore(&ei_local->page_lock, flags);
1152 * Slow phase with lock held.
1155 disable_irq_nosync(dev->irq);
1157 spin_lock(&ei_local->page_lock);
1159 ei_local->irqlock = 1;
1161 send_length = ETH_ZLEN < length ? length : ETH_ZLEN;
1164 * We have two Tx slots available for use. Find the first free
1165 * slot, and then perform some sanity checks. With two Tx bufs,
1166 * you get very close to transmitting back-to-back packets. With
1167 * only one Tx buf, the transmitter sits idle while you reload the
1168 * card, leaving a substantial gap between each transmitted packet.
1171 if (ei_local->tx1 == 0)
1173 output_page = ei_local->tx_start_page;
1174 ei_local->tx1 = send_length;
1175 if (ei_debug && ei_local->tx2 > 0)
1176 printk(KERN_DEBUG "%s: idle transmitter tx2=%d, lasttx=%d, txing=%d.\n",
1177 dev->name, ei_local->tx2, ei_local->lasttx, ei_local->txing);
1179 else if (ei_local->tx2 == 0)
1181 output_page = ei_local->tx_start_page + TX_PAGES/2;
1182 ei_local->tx2 = send_length;
1183 if (ei_debug && ei_local->tx1 > 0)
1184 printk(KERN_DEBUG "%s: idle transmitter, tx1=%d, lasttx=%d, txing=%d.\n",
1185 dev->name, ei_local->tx1, ei_local->lasttx, ei_local->txing);
1188 { /* We should never get here. */
1190 printk(KERN_DEBUG "%s: No Tx buffers free! tx1=%d tx2=%d last=%d\n",
1191 dev->name, ei_local->tx1, ei_local->tx2, ei_local->lasttx);
1192 ei_local->irqlock = 0;
1193 netif_stop_queue(dev);
1194 outb_p(ENISR_ALL, e8390_base + EN0_IMR);
1195 spin_unlock(&ei_local->page_lock);
1196 enable_irq(dev->irq);
1197 ei_local->stat.tx_errors++;
1202 * Okay, now upload the packet and trigger a send if the transmitter
1203 * isn't already sending. If it is busy, the interrupt handler will
1204 * trigger the send later, upon receiving a Tx done interrupt.
1207 if (length == skb->len)
1208 ei_block_output(dev, length, skb->data, output_page);
1210 memset(packet, 0, ETH_ZLEN);
1211 memcpy(packet, skb->data, skb->len);
1212 ei_block_output(dev, length, packet, output_page);
1215 if (! ei_local->txing)
1217 ei_local->txing = 1;
1218 NS8390_trigger_send(dev, send_length, output_page);
1219 dev->trans_start = jiffies;
1220 if (output_page == ei_local->tx_start_page)
1223 ei_local->lasttx = -1;
1228 ei_local->lasttx = -2;
1231 else ei_local->txqueue++;
1233 if (ei_local->tx1 && ei_local->tx2)
1234 netif_stop_queue(dev);
1236 netif_start_queue(dev);
1238 /* Turn 8390 interrupts back on. */
1239 ei_local->irqlock = 0;
1240 outb_p(ENISR_ALL, e8390_base + EN0_IMR);
1242 spin_unlock(&ei_local->page_lock);
1243 enable_irq(dev->irq);
1245 dev_kfree_skb (skb);
1246 ei_local->stat.tx_bytes += send_length;
1252 * ax_interrupt - handle the interrupts from an 8390
1253 * @irq: interrupt number
1254 * @dev_id: a pointer to the net_device
1257 * Handle the ether interface interrupts. We pull packets from
1258 * the 8390 via the card specific functions and fire them at the networking
1259 * stack. We also handle transmit completions and wake the transmit path if
1260 * necessary. We also update the counters and do other housekeeping as
1264 static irqreturn_t ax_interrupt(int irq, void *dev_id, struct pt_regs * regs)
1266 struct net_device *dev = dev_id;
1268 int interrupts, nr_serviced = 0, i;
1269 struct ei_device *ei_local;
1274 printk ("net_interrupt(): irq %d for unknown device.\n", irq);
1278 e8390_base = dev->base_addr;
1279 ei_local = (struct ei_device *) netdev_priv(dev);
1282 * Protect the irq test too.
1285 spin_lock(&ei_local->page_lock);
1287 if (ei_local->irqlock)
1289 #if 1 /* This might just be an interrupt for a PCI device sharing this line */
1290 /* The "irqlock" check is only for testing. */
1291 printk(ei_local->irqlock
1292 ? "%s: Interrupted while interrupts are masked! isr=%#2x imr=%#2x.\n"
1293 : "%s: Reentering the interrupt handler! isr=%#2x imr=%#2x.\n",
1294 dev->name, inb_p(e8390_base + EN0_ISR),
1295 inb_p(e8390_base + EN0_IMR));
1297 spin_unlock(&ei_local->page_lock);
1302 printk(KERN_DEBUG "%s: interrupt(isr=%#2.2x).\n", dev->name,
1303 inb_p(e8390_base + EN0_ISR));
1305 outb_p(0x00, e8390_base + EN0_ISR);
1306 ei_local->irqlock = 1;
1308 /* !!Assumption!! -- we stay in page 0. Don't break this. */
1309 while ((interrupts = inb_p(e8390_base + EN0_ISR)) != 0
1310 && ++nr_serviced < MAX_SERVICE)
1312 if (!netif_running(dev) || (interrupts == 0xff)) {
1314 printk(KERN_WARNING "%s: interrupt from stopped card\n", dev->name);
1315 outb_p(interrupts, e8390_base + EN0_ISR);
1321 /* AX88190 bug fix. */
1322 outb_p(interrupts, e8390_base + EN0_ISR);
1323 for (i = 0; i < 10; i++) {
1324 if (!(inb(e8390_base + EN0_ISR) & interrupts))
1326 outb_p(0, e8390_base + EN0_ISR);
1327 outb_p(interrupts, e8390_base + EN0_ISR);
1329 if (interrupts & ENISR_OVER)
1331 else if (interrupts & (ENISR_RX+ENISR_RX_ERR))
1333 /* Got a good (?) packet. */
1336 /* Push the next to-transmit packet through. */
1337 if (interrupts & ENISR_TX)
1339 else if (interrupts & ENISR_TX_ERR)
1342 if (interrupts & ENISR_COUNTERS)
1344 ei_local->stat.rx_frame_errors += inb_p(e8390_base + EN0_COUNTER0);
1345 ei_local->stat.rx_crc_errors += inb_p(e8390_base + EN0_COUNTER1);
1346 ei_local->stat.rx_missed_errors+= inb_p(e8390_base + EN0_COUNTER2);
1350 if (interrupts && ei_debug)
1353 if (nr_serviced >= MAX_SERVICE)
1355 /* 0xFF is valid for a card removal */
1356 if(interrupts!=0xFF)
1357 printk(KERN_WARNING "%s: Too much work at interrupt, status %#2.2x\n",
1358 dev->name, interrupts);
1359 outb_p(ENISR_ALL, e8390_base + EN0_ISR); /* Ack. most intrs. */
1361 printk(KERN_WARNING "%s: unknown interrupt %#2x\n", dev->name, interrupts);
1362 outb_p(0xff, e8390_base + EN0_ISR); /* Ack. all intrs. */
1366 /* Turn 8390 interrupts back on. */
1367 ei_local->irqlock = 0;
1368 outb_p(ENISR_ALL, e8390_base + EN0_IMR);
1370 spin_unlock(&ei_local->page_lock);
1371 return IRQ_RETVAL(handled);
1375 * ei_tx_err - handle transmitter error
1376 * @dev: network device which threw the exception
1378 * A transmitter error has happened. Most likely excess collisions (which
1379 * is a fairly normal condition). If the error is one where the Tx will
1380 * have been aborted, we try and send another one right away, instead of
1381 * letting the failed packet sit and collect dust in the Tx buffer. This
1382 * is a much better solution as it avoids kernel based Tx timeouts, and
1383 * an unnecessary card reset.
1385 * Called with lock held.
1388 static void ei_tx_err(struct net_device *dev)
1390 long e8390_base = dev->base_addr;
1391 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
1392 unsigned char txsr = inb_p(e8390_base+EN0_TSR);
1393 unsigned char tx_was_aborted = txsr & (ENTSR_ABT+ENTSR_FU);
1395 #ifdef VERBOSE_ERROR_DUMP
1396 printk(KERN_DEBUG "%s: transmitter error (%#2x): ", dev->name, txsr);
1397 if (txsr & ENTSR_ABT)
1398 printk("excess-collisions ");
1399 if (txsr & ENTSR_ND)
1400 printk("non-deferral ");
1401 if (txsr & ENTSR_CRS)
1402 printk("lost-carrier ");
1403 if (txsr & ENTSR_FU)
1404 printk("FIFO-underrun ");
1405 if (txsr & ENTSR_CDH)
1406 printk("lost-heartbeat ");
1414 ei_local->stat.tx_errors++;
1415 if (txsr & ENTSR_CRS) ei_local->stat.tx_carrier_errors++;
1416 if (txsr & ENTSR_CDH) ei_local->stat.tx_heartbeat_errors++;
1417 if (txsr & ENTSR_OWC) ei_local->stat.tx_window_errors++;
1422 * ei_tx_intr - transmit interrupt handler
1423 * @dev: network device for which tx intr is handled
1425 * We have finished a transmit: check for errors and then trigger the next
1426 * packet to be sent. Called with lock held.
1429 static void ei_tx_intr(struct net_device *dev)
1431 long e8390_base = dev->base_addr;
1432 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
1433 int status = inb(e8390_base + EN0_TSR);
1436 * There are two Tx buffers, see which one finished, and trigger
1437 * the send of another one if it exists.
1439 ei_local->txqueue--;
1441 if (ei_local->tx1 < 0)
1443 if (ei_local->lasttx != 1 && ei_local->lasttx != -1)
1444 printk(KERN_ERR "%s: bogus last_tx_buffer %d, tx1=%d.\n",
1445 ei_local->name, ei_local->lasttx, ei_local->tx1);
1447 if (ei_local->tx2 > 0)
1449 ei_local->txing = 1;
1450 NS8390_trigger_send(dev, ei_local->tx2, ei_local->tx_start_page + 6);
1451 dev->trans_start = jiffies;
1453 ei_local->lasttx = 2;
1455 else ei_local->lasttx = 20, ei_local->txing = 0;
1457 else if (ei_local->tx2 < 0)
1459 if (ei_local->lasttx != 2 && ei_local->lasttx != -2)
1460 printk("%s: bogus last_tx_buffer %d, tx2=%d.\n",
1461 ei_local->name, ei_local->lasttx, ei_local->tx2);
1463 if (ei_local->tx1 > 0)
1465 ei_local->txing = 1;
1466 NS8390_trigger_send(dev, ei_local->tx1, ei_local->tx_start_page);
1467 dev->trans_start = jiffies;
1469 ei_local->lasttx = 1;
1472 ei_local->lasttx = 10, ei_local->txing = 0;
1474 // else printk(KERN_WARNING "%s: unexpected TX-done interrupt, lasttx=%d.\n",
1475 // dev->name, ei_local->lasttx);
1477 /* Minimize Tx latency: update the statistics after we restart TXing. */
1478 if (status & ENTSR_COL)
1479 ei_local->stat.collisions++;
1480 if (status & ENTSR_PTX)
1481 ei_local->stat.tx_packets++;
1484 ei_local->stat.tx_errors++;
1485 if (status & ENTSR_ABT)
1487 ei_local->stat.tx_aborted_errors++;
1488 ei_local->stat.collisions += 16;
1490 if (status & ENTSR_CRS)
1491 ei_local->stat.tx_carrier_errors++;
1492 if (status & ENTSR_FU)
1493 ei_local->stat.tx_fifo_errors++;
1494 if (status & ENTSR_CDH)
1495 ei_local->stat.tx_heartbeat_errors++;
1496 if (status & ENTSR_OWC)
1497 ei_local->stat.tx_window_errors++;
1499 netif_wake_queue(dev);
1503 * ei_receive - receive some packets
1504 * @dev: network device with which receive will be run
1506 * We have a good packet(s), get it/them out of the buffers.
1507 * Called with lock held.
1510 static void ei_receive(struct net_device *dev)
1512 long e8390_base = dev->base_addr;
1513 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
1514 unsigned char rxing_page, this_frame, next_frame;
1515 unsigned short current_offset;
1516 int rx_pkt_count = 0;
1517 struct e8390_pkt_hdr rx_frame;
1519 while (++rx_pkt_count < 10)
1521 int pkt_len, pkt_stat;
1523 /* Get the rx page (incoming packet pointer). */
1524 rxing_page = inb_p(e8390_base + EN1_CURPAG -1);
1526 /* Remove one frame from the ring. Boundary is always a page behind. */
1527 this_frame = inb_p(e8390_base + EN0_BOUNDARY) + 1;
1528 if (this_frame >= ei_local->stop_page)
1529 this_frame = ei_local->rx_start_page;
1531 /* Someday we'll omit the previous, iff we never get this message.
1532 (There is at least one clone claimed to have a problem.)
1534 Keep quiet if it looks like a card removal. One problem here
1535 is that some clones crash in roughly the same way.
1537 if (ei_debug > 0 && this_frame != ei_local->current_page && (this_frame!=0x0 || rxing_page!=0xFF))
1538 printk(KERN_ERR "%s: mismatched read page pointers %2x vs %2x.\n",
1539 dev->name, this_frame, ei_local->current_page);
1541 if (this_frame == rxing_page) /* Read all the frames? */
1542 break; /* Done for now */
1544 current_offset = this_frame << 8;
1545 ei_get_8390_hdr(dev, &rx_frame, this_frame);
1547 pkt_len = rx_frame.count - sizeof(struct e8390_pkt_hdr);
1548 pkt_stat = rx_frame.status;
1550 next_frame = this_frame + 1 + ((pkt_len+4)>>8);
1552 if (pkt_len < 60 || pkt_len > 1518)
1555 printk(KERN_DEBUG "%s: bogus packet size: %d, status=%#2x nxpg=%#2x.\n",
1556 dev->name, rx_frame.count, rx_frame.status,
1558 ei_local->stat.rx_errors++;
1559 ei_local->stat.rx_length_errors++;
1561 else if ((pkt_stat & 0x0F) == ENRSR_RXOK)
1563 struct sk_buff *skb;
1565 skb = dev_alloc_skb(pkt_len+2);
1569 printk(KERN_DEBUG "%s: Couldn't allocate a sk_buff of size %d.\n",
1570 dev->name, pkt_len);
1571 ei_local->stat.rx_dropped++;
1576 skb_reserve(skb,2); /* IP headers on 16 byte boundaries */
1578 skb_put(skb, pkt_len); /* Make room */
1579 ei_block_input(dev, pkt_len, skb, current_offset + sizeof(rx_frame));
1580 skb->protocol=eth_type_trans(skb,dev);
1582 dev->last_rx = jiffies;
1583 ei_local->stat.rx_packets++;
1584 ei_local->stat.rx_bytes += pkt_len;
1585 if (pkt_stat & ENRSR_PHY)
1586 ei_local->stat.multicast++;
1592 printk(KERN_DEBUG "%s: bogus packet: status=%#2x nxpg=%#2x size=%d\n",
1593 dev->name, rx_frame.status, rx_frame.next,
1595 ei_local->stat.rx_errors++;
1596 /* NB: The NIC counts CRC, frame and missed errors. */
1597 if (pkt_stat & ENRSR_FO)
1598 ei_local->stat.rx_fifo_errors++;
1600 next_frame = rx_frame.next;
1602 /* This _should_ never happen: it's here for avoiding bad clones. */
1603 if (next_frame >= ei_local->stop_page) {
1604 printk("%s: next frame inconsistency, %#2x\n", dev->name,
1606 next_frame = ei_local->rx_start_page;
1608 ei_local->current_page = next_frame;
1609 outb_p(next_frame-1, e8390_base+EN0_BOUNDARY);
1616 * ei_rx_overrun - handle receiver overrun
1617 * @dev: network device which threw exception
1619 * We have a receiver overrun: we have to kick the 8390 to get it started
1620 * again. Problem is that you have to kick it exactly as NS prescribes in
1621 * the updated datasheets, or "the NIC may act in an unpredictable manner."
1622 * This includes causing "the NIC to defer indefinitely when it is stopped
1623 * on a busy network." Ugh.
1624 * Called with lock held. Don't call this with the interrupts off or your
1625 * computer will hate you - it takes 10ms or so.
1628 static void ei_rx_overrun(struct net_device *dev)
1630 axnet_dev_t *info = (axnet_dev_t *)dev;
1631 long e8390_base = dev->base_addr;
1632 unsigned char was_txing, must_resend = 0;
1633 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
1636 * Record whether a Tx was in progress and then issue the
1639 was_txing = inb_p(e8390_base+E8390_CMD) & E8390_TRANS;
1640 outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base+E8390_CMD);
1643 printk(KERN_DEBUG "%s: Receiver overrun.\n", dev->name);
1644 ei_local->stat.rx_over_errors++;
1647 * Wait a full Tx time (1.2ms) + some guard time, NS says 1.6ms total.
1648 * Early datasheets said to poll the reset bit, but now they say that
1649 * it "is not a reliable indicator and subsequently should be ignored."
1650 * We wait at least 10ms.
1656 * Reset RBCR[01] back to zero as per magic incantation.
1658 outb_p(0x00, e8390_base+EN0_RCNTLO);
1659 outb_p(0x00, e8390_base+EN0_RCNTHI);
1662 * See if any Tx was interrupted or not. According to NS, this
1663 * step is vital, and skipping it will cause no end of havoc.
1668 unsigned char tx_completed = inb_p(e8390_base+EN0_ISR) & (ENISR_TX+ENISR_TX_ERR);
1674 * Have to enter loopback mode and then restart the NIC before
1675 * you are allowed to slurp packets up off the ring.
1677 outb_p(E8390_TXOFF, e8390_base + EN0_TXCR);
1678 outb_p(E8390_NODMA + E8390_PAGE0 + E8390_START, e8390_base + E8390_CMD);
1681 * Clear the Rx ring of all the debris, and ack the interrupt.
1686 * Leave loopback mode, and resend any packet that got stopped.
1688 outb_p(E8390_TXCONFIG | info->duplex_flag, e8390_base + EN0_TXCR);
1690 outb_p(E8390_NODMA + E8390_PAGE0 + E8390_START + E8390_TRANS, e8390_base + E8390_CMD);
1694 * Collect the stats. This is called unlocked and from several contexts.
1697 static struct net_device_stats *get_stats(struct net_device *dev)
1699 long ioaddr = dev->base_addr;
1700 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
1701 unsigned long flags;
1703 /* If the card is stopped, just return the present stats. */
1704 if (!netif_running(dev))
1705 return &ei_local->stat;
1707 spin_lock_irqsave(&ei_local->page_lock,flags);
1708 /* Read the counter registers, assuming we are in page 0. */
1709 ei_local->stat.rx_frame_errors += inb_p(ioaddr + EN0_COUNTER0);
1710 ei_local->stat.rx_crc_errors += inb_p(ioaddr + EN0_COUNTER1);
1711 ei_local->stat.rx_missed_errors+= inb_p(ioaddr + EN0_COUNTER2);
1712 spin_unlock_irqrestore(&ei_local->page_lock, flags);
1714 return &ei_local->stat;
1718 * do_set_multicast_list - set/clear multicast filter
1719 * @dev: net device for which multicast filter is adjusted
1721 * Set or clear the multicast filter for this adaptor. May be called
1722 * from a BH in 2.1.x. Must be called with lock held.
1725 static void do_set_multicast_list(struct net_device *dev)
1727 long e8390_base = dev->base_addr;
1729 if(dev->flags&IFF_PROMISC)
1730 outb_p(E8390_RXCONFIG | 0x58, e8390_base + EN0_RXCR);
1731 else if(dev->flags&IFF_ALLMULTI || dev->mc_list)
1732 outb_p(E8390_RXCONFIG | 0x48, e8390_base + EN0_RXCR);
1734 outb_p(E8390_RXCONFIG | 0x40, e8390_base + EN0_RXCR);
1738 * Called without lock held. This is invoked from user context and may
1739 * be parallel to just about everything else. Its also fairly quick and
1740 * not called too often. Must protect against both bh and irq users
1743 static void set_multicast_list(struct net_device *dev)
1745 unsigned long flags;
1747 spin_lock_irqsave(&dev_lock(dev), flags);
1748 do_set_multicast_list(dev);
1749 spin_unlock_irqrestore(&dev_lock(dev), flags);
1753 * axdev_setup - init rest of 8390 device struct
1754 * @dev: network device structure to init
1756 * Initialize the rest of the 8390 device structure. Do NOT __init
1757 * this, as it is used by 8390 based modular drivers too.
1760 static void axdev_setup(struct net_device *dev)
1762 struct ei_device *ei_local;
1764 printk(version_8390);
1766 SET_MODULE_OWNER(dev);
1769 ei_local = (struct ei_device *)netdev_priv(dev);
1770 spin_lock_init(&ei_local->page_lock);
1772 dev->hard_start_xmit = &ei_start_xmit;
1773 dev->get_stats = get_stats;
1774 dev->set_multicast_list = &set_multicast_list;
1779 /* This page of functions should be 8390 generic */
1780 /* Follow National Semi's recommendations for initializing the "NIC". */
1783 * AX88190_init - initialize 8390 hardware
1784 * @dev: network device to initialize
1785 * @startp: boolean. non-zero value to initiate chip processing
1787 * Must be called with lock held.
1790 static void AX88190_init(struct net_device *dev, int startp)
1792 axnet_dev_t *info = PRIV(dev);
1793 long e8390_base = dev->base_addr;
1794 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
1796 int endcfg = ei_local->word16 ? (0x48 | ENDCFG_WTS) : 0x48;
1798 if(sizeof(struct e8390_pkt_hdr)!=4)
1799 panic("8390.c: header struct mispacked\n");
1800 /* Follow National Semi's recommendations for initing the DP83902. */
1801 outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base+E8390_CMD); /* 0x21 */
1802 outb_p(endcfg, e8390_base + EN0_DCFG); /* 0x48 or 0x49 */
1803 /* Clear the remote byte count registers. */
1804 outb_p(0x00, e8390_base + EN0_RCNTLO);
1805 outb_p(0x00, e8390_base + EN0_RCNTHI);
1806 /* Set to monitor and loopback mode -- this is vital!. */
1807 outb_p(E8390_RXOFF|0x40, e8390_base + EN0_RXCR); /* 0x60 */
1808 outb_p(E8390_TXOFF, e8390_base + EN0_TXCR); /* 0x02 */
1809 /* Set the transmit page and receive ring. */
1810 outb_p(ei_local->tx_start_page, e8390_base + EN0_TPSR);
1811 ei_local->tx1 = ei_local->tx2 = 0;
1812 outb_p(ei_local->rx_start_page, e8390_base + EN0_STARTPG);
1813 outb_p(ei_local->stop_page-1, e8390_base + EN0_BOUNDARY); /* 3c503 says 0x3f,NS0x26*/
1814 ei_local->current_page = ei_local->rx_start_page; /* assert boundary+1 */
1815 outb_p(ei_local->stop_page, e8390_base + EN0_STOPPG);
1816 /* Clear the pending interrupts and mask. */
1817 outb_p(0xFF, e8390_base + EN0_ISR);
1818 outb_p(0x00, e8390_base + EN0_IMR);
1820 /* Copy the station address into the DS8390 registers. */
1822 outb_p(E8390_NODMA + E8390_PAGE1 + E8390_STOP, e8390_base+E8390_CMD); /* 0x61 */
1823 for(i = 0; i < 6; i++)
1825 outb_p(dev->dev_addr[i], e8390_base + EN1_PHYS_SHIFT(i));
1826 if(inb_p(e8390_base + EN1_PHYS_SHIFT(i))!=dev->dev_addr[i])
1827 printk(KERN_ERR "Hw. address read/write mismap %d\n",i);
1830 * Initialize the multicast list to accept-all. If we enable multicast
1831 * the higher levels can do the filtering.
1833 for (i = 0; i < 8; i++)
1834 outb_p(0xff, e8390_base + EN1_MULT + i);
1836 outb_p(ei_local->rx_start_page, e8390_base + EN1_CURPAG);
1837 outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base+E8390_CMD);
1839 netif_start_queue(dev);
1840 ei_local->tx1 = ei_local->tx2 = 0;
1841 ei_local->txing = 0;
1845 outb_p(0xff, e8390_base + EN0_ISR);
1846 outb_p(ENISR_ALL, e8390_base + EN0_IMR);
1847 outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, e8390_base+E8390_CMD);
1848 outb_p(E8390_TXCONFIG | info->duplex_flag,
1849 e8390_base + EN0_TXCR); /* xmit on. */
1850 /* 3c503 TechMan says rxconfig only after the NIC is started. */
1851 outb_p(E8390_RXCONFIG | 0x40, e8390_base + EN0_RXCR); /* rx on, */
1852 do_set_multicast_list(dev); /* (re)load the mcast table */
1856 /* Trigger a transmit start, assuming the length is valid.
1857 Always called with the page lock held */
1859 static void NS8390_trigger_send(struct net_device *dev, unsigned int length,
1862 long e8390_base = dev->base_addr;
1863 struct ei_device *ei_local __attribute((unused)) = (struct ei_device *) netdev_priv(dev);
1865 if (inb_p(e8390_base) & E8390_TRANS)
1867 printk(KERN_WARNING "%s: trigger_send() called with the transmitter busy.\n",
1871 outb_p(length & 0xff, e8390_base + EN0_TCNTLO);
1872 outb_p(length >> 8, e8390_base + EN0_TCNTHI);
1873 outb_p(start_page, e8390_base + EN0_TPSR);
1874 outb_p(E8390_NODMA+E8390_TRANS+E8390_START, e8390_base+E8390_CMD);