d431b59e7d11bda7b203a96cec3217570344eade
[linux-2.6.git] / drivers / net / pcmcia / axnet_cs.c
1 /*======================================================================
2
3     A PCMCIA ethernet driver for Asix AX88190-based cards
4
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.
11
12     Copyright (C) 2001 David A. Hinds -- dahinds@users.sourceforge.net
13
14     axnet_cs.c 1.28 2002/06/29 06:27:37
15
16     The network driver code is based on Donald Becker's NE2000 code:
17
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
24
25 ======================================================================*/
26
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>
38 #include <linux/etherdevice.h>
39 #include <linux/crc32.h>
40 #include <linux/mii.h>
41 #include "../8390.h"
42
43 #include <pcmcia/cs_types.h>
44 #include <pcmcia/cs.h>
45 #include <pcmcia/cistpl.h>
46 #include <pcmcia/ciscode.h>
47 #include <pcmcia/ds.h>
48 #include <pcmcia/cisreg.h>
49
50 #include <asm/io.h>
51 #include <asm/system.h>
52 #include <asm/byteorder.h>
53 #include <asm/uaccess.h>
54
55 #define AXNET_CMD       0x00
56 #define AXNET_DATAPORT  0x10    /* NatSemi-defined port window offset. */
57 #define AXNET_RESET     0x1f    /* Issue a read to reset, a write to clear. */
58 #define AXNET_MII_EEP   0x14    /* Offset of MII access port */
59 #define AXNET_TEST      0x15    /* Offset of TEST Register port */
60 #define AXNET_GPIO      0x17    /* Offset of General Purpose Register Port */
61
62 #define AXNET_START_PG  0x40    /* First page of TX buffer */
63 #define AXNET_STOP_PG   0x80    /* Last page +1 of RX ring */
64
65 #define AXNET_RDC_TIMEOUT 0x02  /* Max wait in jiffies for Tx RDC */
66
67 #define IS_AX88190      0x0001
68 #define IS_AX88790      0x0002
69
70 /*====================================================================*/
71
72 /* Module parameters */
73
74 MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
75 MODULE_DESCRIPTION("Asix AX88190 PCMCIA ethernet driver");
76 MODULE_LICENSE("GPL");
77
78
79 /*====================================================================*/
80
81 static int axnet_config(struct pcmcia_device *link);
82 static void axnet_release(struct pcmcia_device *link);
83 static int axnet_open(struct net_device *dev);
84 static int axnet_close(struct net_device *dev);
85 static int axnet_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
86 static netdev_tx_t axnet_start_xmit(struct sk_buff *skb,
87                                           struct net_device *dev);
88 static struct net_device_stats *get_stats(struct net_device *dev);
89 static void set_multicast_list(struct net_device *dev);
90 static void axnet_tx_timeout(struct net_device *dev);
91 static const struct ethtool_ops netdev_ethtool_ops;
92 static irqreturn_t ei_irq_wrapper(int irq, void *dev_id);
93 static void ei_watchdog(u_long arg);
94 static void axnet_reset_8390(struct net_device *dev);
95
96 static int mdio_read(unsigned int addr, int phy_id, int loc);
97 static void mdio_write(unsigned int addr, int phy_id, int loc, int value);
98
99 static void get_8390_hdr(struct net_device *,
100                          struct e8390_pkt_hdr *, int);
101 static void block_input(struct net_device *dev, int count,
102                         struct sk_buff *skb, int ring_offset);
103 static void block_output(struct net_device *dev, int count,
104                          const u_char *buf, const int start_page);
105
106 static void axnet_detach(struct pcmcia_device *p_dev);
107
108 static void AX88190_init(struct net_device *dev, int startp);
109 static int ax_open(struct net_device *dev);
110 static int ax_close(struct net_device *dev);
111 static irqreturn_t ax_interrupt(int irq, void *dev_id);
112
113 /*====================================================================*/
114
115 typedef struct axnet_dev_t {
116         struct pcmcia_device    *p_dev;
117     dev_node_t          node;
118     caddr_t             base;
119     struct timer_list   watchdog;
120     int                 stale, fast_poll;
121     u_short             link_status;
122     u_char              duplex_flag;
123     int                 phy_id;
124     int                 flags;
125 } axnet_dev_t;
126
127 static inline axnet_dev_t *PRIV(struct net_device *dev)
128 {
129         void *p = (char *)netdev_priv(dev) + sizeof(struct ei_device);
130         return p;
131 }
132
133 static const struct net_device_ops axnet_netdev_ops = {
134         .ndo_open               = axnet_open,
135         .ndo_stop               = axnet_close,
136         .ndo_do_ioctl           = axnet_ioctl,
137         .ndo_start_xmit         = axnet_start_xmit,
138         .ndo_tx_timeout         = axnet_tx_timeout,
139         .ndo_get_stats          = get_stats,
140         .ndo_set_multicast_list = set_multicast_list,
141         .ndo_change_mtu         = eth_change_mtu,
142         .ndo_set_mac_address    = eth_mac_addr,
143         .ndo_validate_addr      = eth_validate_addr,
144 };
145
146 /*======================================================================
147
148     axnet_attach() creates an "instance" of the driver, allocating
149     local data structures for one device.  The device is registered
150     with Card Services.
151
152 ======================================================================*/
153
154 static int axnet_probe(struct pcmcia_device *link)
155 {
156     axnet_dev_t *info;
157     struct net_device *dev;
158     struct ei_device *ei_local;
159
160     dev_dbg(&link->dev, "axnet_attach()\n");
161
162     dev = alloc_etherdev(sizeof(struct ei_device) + sizeof(axnet_dev_t));
163     if (!dev)
164         return -ENOMEM;
165
166     ei_local = netdev_priv(dev);
167     spin_lock_init(&ei_local->page_lock);
168
169     info = PRIV(dev);
170     info->p_dev = link;
171     link->priv = dev;
172     link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING;
173     link->conf.Attributes = CONF_ENABLE_IRQ;
174     link->conf.IntType = INT_MEMORY_AND_IO;
175
176     dev->netdev_ops = &axnet_netdev_ops;
177
178     SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
179     dev->watchdog_timeo = TX_TIMEOUT;
180
181     return axnet_config(link);
182 } /* axnet_attach */
183
184 /*======================================================================
185
186     This deletes a driver "instance".  The device is de-registered
187     with Card Services.  If it has been released, all local data
188     structures are freed.  Otherwise, the structures will be freed
189     when the device is released.
190
191 ======================================================================*/
192
193 static void axnet_detach(struct pcmcia_device *link)
194 {
195     struct net_device *dev = link->priv;
196
197     dev_dbg(&link->dev, "axnet_detach(0x%p)\n", link);
198
199     if (link->dev_node)
200         unregister_netdev(dev);
201
202     axnet_release(link);
203
204     free_netdev(dev);
205 } /* axnet_detach */
206
207 /*======================================================================
208
209     This probes for a card's hardware address by reading the PROM.
210
211 ======================================================================*/
212
213 static int get_prom(struct pcmcia_device *link)
214 {
215     struct net_device *dev = link->priv;
216     unsigned int ioaddr = dev->base_addr;
217     int i, j;
218
219     /* This is based on drivers/net/ne.c */
220     struct {
221         u_char value, offset;
222     } program_seq[] = {
223         {E8390_NODMA+E8390_PAGE0+E8390_STOP, E8390_CMD}, /* Select page 0*/
224         {0x01,  EN0_DCFG},      /* Set word-wide access. */
225         {0x00,  EN0_RCNTLO},    /* Clear the count regs. */
226         {0x00,  EN0_RCNTHI},
227         {0x00,  EN0_IMR},       /* Mask completion irq. */
228         {0xFF,  EN0_ISR},
229         {E8390_RXOFF|0x40, EN0_RXCR},   /* 0x60  Set to monitor */
230         {E8390_TXOFF, EN0_TXCR},        /* 0x02  and loopback mode. */
231         {0x10,  EN0_RCNTLO},
232         {0x00,  EN0_RCNTHI},
233         {0x00,  EN0_RSARLO},    /* DMA starting at 0x0400. */
234         {0x04,  EN0_RSARHI},
235         {E8390_RREAD+E8390_START, E8390_CMD},
236     };
237
238     /* Not much of a test, but the alternatives are messy */
239     if (link->conf.ConfigBase != 0x03c0)
240         return 0;
241
242     axnet_reset_8390(dev);
243     mdelay(10);
244
245     for (i = 0; i < ARRAY_SIZE(program_seq); i++)
246         outb_p(program_seq[i].value, ioaddr + program_seq[i].offset);
247
248     for (i = 0; i < 6; i += 2) {
249         j = inw(ioaddr + AXNET_DATAPORT);
250         dev->dev_addr[i] = j & 0xff;
251         dev->dev_addr[i+1] = j >> 8;
252     }
253     return 1;
254 } /* get_prom */
255
256 /*======================================================================
257
258     axnet_config() is scheduled to run after a CARD_INSERTION event
259     is received, to configure the PCMCIA socket, and to make the
260     ethernet device available to the system.
261
262 ======================================================================*/
263
264 static int try_io_port(struct pcmcia_device *link)
265 {
266     int j, ret;
267     if (link->io.NumPorts1 == 32) {
268         link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
269         if (link->io.NumPorts2 > 0) {
270             /* for master/slave multifunction cards */
271             link->io.Attributes2 = IO_DATA_PATH_WIDTH_8;
272             link->irq.Attributes =
273                 IRQ_TYPE_DYNAMIC_SHARING;
274         }
275     } else {
276         /* This should be two 16-port windows */
277         link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
278         link->io.Attributes2 = IO_DATA_PATH_WIDTH_16;
279     }
280     if (link->io.BasePort1 == 0) {
281         link->io.IOAddrLines = 16;
282         for (j = 0; j < 0x400; j += 0x20) {
283             link->io.BasePort1 = j ^ 0x300;
284             link->io.BasePort2 = (j ^ 0x300) + 0x10;
285             ret = pcmcia_request_io(link, &link->io);
286             if (ret == 0)
287                     return ret;
288         }
289         return ret;
290     } else {
291         return pcmcia_request_io(link, &link->io);
292     }
293 }
294
295 static int axnet_configcheck(struct pcmcia_device *p_dev,
296                              cistpl_cftable_entry_t *cfg,
297                              cistpl_cftable_entry_t *dflt,
298                              unsigned int vcc,
299                              void *priv_data)
300 {
301         int i;
302         cistpl_io_t *io = &cfg->io;
303
304         if (cfg->index == 0 || cfg->io.nwin == 0)
305                 return -ENODEV;
306
307         p_dev->conf.ConfigIndex = 0x05;
308         /* For multifunction cards, by convention, we configure the
309            network function with window 0, and serial with window 1 */
310         if (io->nwin > 1) {
311                 i = (io->win[1].len > io->win[0].len);
312                 p_dev->io.BasePort2 = io->win[1-i].base;
313                 p_dev->io.NumPorts2 = io->win[1-i].len;
314         } else {
315                 i = p_dev->io.NumPorts2 = 0;
316         }
317         p_dev->io.BasePort1 = io->win[i].base;
318         p_dev->io.NumPorts1 = io->win[i].len;
319         p_dev->io.IOAddrLines = io->flags & CISTPL_IO_LINES_MASK;
320         if (p_dev->io.NumPorts1 + p_dev->io.NumPorts2 >= 32)
321                 return try_io_port(p_dev);
322
323         return -ENODEV;
324 }
325
326 static int axnet_config(struct pcmcia_device *link)
327 {
328     struct net_device *dev = link->priv;
329     axnet_dev_t *info = PRIV(dev);
330     int i, j, j2, ret;
331
332     dev_dbg(&link->dev, "axnet_config(0x%p)\n", link);
333
334     /* don't trust the CIS on this; Linksys got it wrong */
335     link->conf.Present = 0x63;
336     ret = pcmcia_loop_config(link, axnet_configcheck, NULL);
337     if (ret != 0)
338         goto failed;
339
340     ret = pcmcia_request_irq(link, &link->irq);
341     if (ret)
342             goto failed;
343     
344     if (link->io.NumPorts2 == 8) {
345         link->conf.Attributes |= CONF_ENABLE_SPKR;
346         link->conf.Status = CCSR_AUDIO_ENA;
347     }
348     
349     ret = pcmcia_request_configuration(link, &link->conf);
350     if (ret)
351             goto failed;
352
353     dev->irq = link->irq.AssignedIRQ;
354     dev->base_addr = link->io.BasePort1;
355
356     if (!get_prom(link)) {
357         printk(KERN_NOTICE "axnet_cs: this is not an AX88190 card!\n");
358         printk(KERN_NOTICE "axnet_cs: use pcnet_cs instead.\n");
359         goto failed;
360     }
361
362     ei_status.name = "AX88190";
363     ei_status.word16 = 1;
364     ei_status.tx_start_page = AXNET_START_PG;
365     ei_status.rx_start_page = AXNET_START_PG + TX_PAGES;
366     ei_status.stop_page = AXNET_STOP_PG;
367     ei_status.reset_8390 = &axnet_reset_8390;
368     ei_status.get_8390_hdr = &get_8390_hdr;
369     ei_status.block_input = &block_input;
370     ei_status.block_output = &block_output;
371
372     if (inb(dev->base_addr + AXNET_TEST) != 0)
373         info->flags |= IS_AX88790;
374     else
375         info->flags |= IS_AX88190;
376
377     if (info->flags & IS_AX88790)
378         outb(0x10, dev->base_addr + AXNET_GPIO);  /* select Internal PHY */
379
380     for (i = 0; i < 32; i++) {
381         j = mdio_read(dev->base_addr + AXNET_MII_EEP, i, 1);
382         j2 = mdio_read(dev->base_addr + AXNET_MII_EEP, i, 2);
383         if (j == j2) continue;
384         if ((j != 0) && (j != 0xffff)) break;
385     }
386
387     /* Maybe PHY is in power down mode. (PPD_SET = 1) 
388        Bit 2 of CCSR is active low. */ 
389     if (i == 32) {
390         conf_reg_t reg = { 0, CS_WRITE, CISREG_CCSR, 0x04 };
391         pcmcia_access_configuration_register(link, &reg);
392         for (i = 0; i < 32; i++) {
393             j = mdio_read(dev->base_addr + AXNET_MII_EEP, i, 1);
394             j2 = mdio_read(dev->base_addr + AXNET_MII_EEP, i, 2);
395             if (j == j2) continue;
396             if ((j != 0) && (j != 0xffff)) break;
397         }
398     }
399
400     info->phy_id = (i < 32) ? i : -1;
401     link->dev_node = &info->node;
402     SET_NETDEV_DEV(dev, &link->dev);
403
404     if (register_netdev(dev) != 0) {
405         printk(KERN_NOTICE "axnet_cs: register_netdev() failed\n");
406         link->dev_node = NULL;
407         goto failed;
408     }
409
410     strcpy(info->node.dev_name, dev->name);
411
412     printk(KERN_INFO "%s: Asix AX88%d90: io %#3lx, irq %d, "
413            "hw_addr %pM\n",
414            dev->name, ((info->flags & IS_AX88790) ? 7 : 1),
415            dev->base_addr, dev->irq,
416            dev->dev_addr);
417     if (info->phy_id != -1) {
418         dev_dbg(&link->dev, "  MII transceiver at index %d, status %x.\n", info->phy_id, j);
419     } else {
420         printk(KERN_NOTICE "  No MII transceivers found!\n");
421     }
422     return 0;
423
424 failed:
425     axnet_release(link);
426     return -ENODEV;
427 } /* axnet_config */
428
429 /*======================================================================
430
431     After a card is removed, axnet_release() will unregister the net
432     device, and release the PCMCIA configuration.  If the device is
433     still open, this will be postponed until it is closed.
434
435 ======================================================================*/
436
437 static void axnet_release(struct pcmcia_device *link)
438 {
439         pcmcia_disable_device(link);
440 }
441
442 static int axnet_suspend(struct pcmcia_device *link)
443 {
444         struct net_device *dev = link->priv;
445
446         if (link->open)
447                 netif_device_detach(dev);
448
449         return 0;
450 }
451
452 static int axnet_resume(struct pcmcia_device *link)
453 {
454         struct net_device *dev = link->priv;
455
456         if (link->open) {
457                 axnet_reset_8390(dev);
458                 AX88190_init(dev, 1);
459                 netif_device_attach(dev);
460         }
461
462         return 0;
463 }
464
465
466 /*======================================================================
467
468     MII interface support
469
470 ======================================================================*/
471
472 #define MDIO_SHIFT_CLK          0x01
473 #define MDIO_DATA_WRITE0        0x00
474 #define MDIO_DATA_WRITE1        0x08
475 #define MDIO_DATA_READ          0x04
476 #define MDIO_MASK               0x0f
477 #define MDIO_ENB_IN             0x02
478
479 static void mdio_sync(unsigned int addr)
480 {
481     int bits;
482     for (bits = 0; bits < 32; bits++) {
483         outb_p(MDIO_DATA_WRITE1, addr);
484         outb_p(MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, addr);
485     }
486 }
487
488 static int mdio_read(unsigned int addr, int phy_id, int loc)
489 {
490     u_int cmd = (0xf6<<10)|(phy_id<<5)|loc;
491     int i, retval = 0;
492
493     mdio_sync(addr);
494     for (i = 14; i >= 0; i--) {
495         int dat = (cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
496         outb_p(dat, addr);
497         outb_p(dat | MDIO_SHIFT_CLK, addr);
498     }
499     for (i = 19; i > 0; i--) {
500         outb_p(MDIO_ENB_IN, addr);
501         retval = (retval << 1) | ((inb_p(addr) & MDIO_DATA_READ) != 0);
502         outb_p(MDIO_ENB_IN | MDIO_SHIFT_CLK, addr);
503     }
504     return (retval>>1) & 0xffff;
505 }
506
507 static void mdio_write(unsigned int addr, int phy_id, int loc, int value)
508 {
509     u_int cmd = (0x05<<28)|(phy_id<<23)|(loc<<18)|(1<<17)|value;
510     int i;
511
512     mdio_sync(addr);
513     for (i = 31; i >= 0; i--) {
514         int dat = (cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
515         outb_p(dat, addr);
516         outb_p(dat | MDIO_SHIFT_CLK, addr);
517     }
518     for (i = 1; i >= 0; i--) {
519         outb_p(MDIO_ENB_IN, addr);
520         outb_p(MDIO_ENB_IN | MDIO_SHIFT_CLK, addr);
521     }
522 }
523
524 /*====================================================================*/
525
526 static int axnet_open(struct net_device *dev)
527 {
528     int ret;
529     axnet_dev_t *info = PRIV(dev);
530     struct pcmcia_device *link = info->p_dev;
531     unsigned int nic_base = dev->base_addr;
532     
533     dev_dbg(&link->dev, "axnet_open('%s')\n", dev->name);
534
535     if (!pcmcia_dev_present(link))
536         return -ENODEV;
537
538     outb_p(0xFF, nic_base + EN0_ISR); /* Clear bogus intr. */
539     ret = request_irq(dev->irq, ei_irq_wrapper, IRQF_SHARED, "axnet_cs", dev);
540     if (ret)
541             return ret;
542
543     link->open++;
544
545     info->link_status = 0x00;
546     init_timer(&info->watchdog);
547     info->watchdog.function = &ei_watchdog;
548     info->watchdog.data = (u_long)dev;
549     info->watchdog.expires = jiffies + HZ;
550     add_timer(&info->watchdog);
551
552     return ax_open(dev);
553 } /* axnet_open */
554
555 /*====================================================================*/
556
557 static int axnet_close(struct net_device *dev)
558 {
559     axnet_dev_t *info = PRIV(dev);
560     struct pcmcia_device *link = info->p_dev;
561
562     dev_dbg(&link->dev, "axnet_close('%s')\n", dev->name);
563
564     ax_close(dev);
565     free_irq(dev->irq, dev);
566     
567     link->open--;
568     netif_stop_queue(dev);
569     del_timer_sync(&info->watchdog);
570
571     return 0;
572 } /* axnet_close */
573
574 /*======================================================================
575
576     Hard reset the card.  This used to pause for the same period that
577     a 8390 reset command required, but that shouldn't be necessary.
578
579 ======================================================================*/
580
581 static void axnet_reset_8390(struct net_device *dev)
582 {
583     unsigned int nic_base = dev->base_addr;
584     int i;
585
586     ei_status.txing = ei_status.dmaing = 0;
587
588     outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, nic_base + E8390_CMD);
589
590     outb(inb(nic_base + AXNET_RESET), nic_base + AXNET_RESET);
591
592     for (i = 0; i < 100; i++) {
593         if ((inb_p(nic_base+EN0_ISR) & ENISR_RESET) != 0)
594             break;
595         udelay(100);
596     }
597     outb_p(ENISR_RESET, nic_base + EN0_ISR); /* Ack intr. */
598     
599     if (i == 100)
600         printk(KERN_ERR "%s: axnet_reset_8390() did not complete.\n",
601                dev->name);
602     
603 } /* axnet_reset_8390 */
604
605 /*====================================================================*/
606
607 static irqreturn_t ei_irq_wrapper(int irq, void *dev_id)
608 {
609     struct net_device *dev = dev_id;
610     PRIV(dev)->stale = 0;
611     return ax_interrupt(irq, dev_id);
612 }
613
614 static void ei_watchdog(u_long arg)
615 {
616     struct net_device *dev = (struct net_device *)(arg);
617     axnet_dev_t *info = PRIV(dev);
618     unsigned int nic_base = dev->base_addr;
619     unsigned int mii_addr = nic_base + AXNET_MII_EEP;
620     u_short link;
621
622     if (!netif_device_present(dev)) goto reschedule;
623
624     /* Check for pending interrupt with expired latency timer: with
625        this, we can limp along even if the interrupt is blocked */
626     if (info->stale++ && (inb_p(nic_base + EN0_ISR) & ENISR_ALL)) {
627         if (!info->fast_poll)
628             printk(KERN_INFO "%s: interrupt(s) dropped!\n", dev->name);
629         ei_irq_wrapper(dev->irq, dev);
630         info->fast_poll = HZ;
631     }
632     if (info->fast_poll) {
633         info->fast_poll--;
634         info->watchdog.expires = jiffies + 1;
635         add_timer(&info->watchdog);
636         return;
637     }
638
639     if (info->phy_id < 0)
640         goto reschedule;
641     link = mdio_read(mii_addr, info->phy_id, 1);
642     if (!link || (link == 0xffff)) {
643         printk(KERN_INFO "%s: MII is missing!\n", dev->name);
644         info->phy_id = -1;
645         goto reschedule;
646     }
647
648     link &= 0x0004;
649     if (link != info->link_status) {
650         u_short p = mdio_read(mii_addr, info->phy_id, 5);
651         printk(KERN_INFO "%s: %s link beat\n", dev->name,
652                (link) ? "found" : "lost");
653         if (link) {
654             info->duplex_flag = (p & 0x0140) ? 0x80 : 0x00;
655             if (p)
656                 printk(KERN_INFO "%s: autonegotiation complete: "
657                        "%sbaseT-%cD selected\n", dev->name,
658                        ((p & 0x0180) ? "100" : "10"),
659                        ((p & 0x0140) ? 'F' : 'H'));
660             else
661                 printk(KERN_INFO "%s: link partner did not autonegotiate\n",
662                        dev->name);
663             AX88190_init(dev, 1);
664         }
665         info->link_status = link;
666     }
667
668 reschedule:
669     info->watchdog.expires = jiffies + HZ;
670     add_timer(&info->watchdog);
671 }
672
673 static void netdev_get_drvinfo(struct net_device *dev,
674                                struct ethtool_drvinfo *info)
675 {
676         strcpy(info->driver, "axnet_cs");
677 }
678
679 static const struct ethtool_ops netdev_ethtool_ops = {
680         .get_drvinfo            = netdev_get_drvinfo,
681 };
682
683 /*====================================================================*/
684
685 static int axnet_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
686 {
687     axnet_dev_t *info = PRIV(dev);
688     struct mii_ioctl_data *data = if_mii(rq);
689     unsigned int mii_addr = dev->base_addr + AXNET_MII_EEP;
690     switch (cmd) {
691     case SIOCGMIIPHY:
692         data->phy_id = info->phy_id;
693     case SIOCGMIIREG:           /* Read MII PHY register. */
694         data->val_out = mdio_read(mii_addr, data->phy_id, data->reg_num & 0x1f);
695         return 0;
696     case SIOCSMIIREG:           /* Write MII PHY register. */
697         mdio_write(mii_addr, data->phy_id, data->reg_num & 0x1f, data->val_in);
698         return 0;
699     }
700     return -EOPNOTSUPP;
701 }
702
703 /*====================================================================*/
704
705 static void get_8390_hdr(struct net_device *dev,
706                          struct e8390_pkt_hdr *hdr,
707                          int ring_page)
708 {
709     unsigned int nic_base = dev->base_addr;
710
711     outb_p(0, nic_base + EN0_RSARLO);           /* On page boundary */
712     outb_p(ring_page, nic_base + EN0_RSARHI);
713     outb_p(E8390_RREAD+E8390_START, nic_base + AXNET_CMD);
714
715     insw(nic_base + AXNET_DATAPORT, hdr,
716             sizeof(struct e8390_pkt_hdr)>>1);
717     /* Fix for big endian systems */
718     hdr->count = le16_to_cpu(hdr->count);
719
720 }
721
722 /*====================================================================*/
723
724 static void block_input(struct net_device *dev, int count,
725                         struct sk_buff *skb, int ring_offset)
726 {
727     unsigned int nic_base = dev->base_addr;
728     int xfer_count = count;
729     char *buf = skb->data;
730
731     if ((ei_debug > 4) && (count != 4))
732             pr_debug("%s: [bi=%d]\n", dev->name, count+4);
733     outb_p(ring_offset & 0xff, nic_base + EN0_RSARLO);
734     outb_p(ring_offset >> 8, nic_base + EN0_RSARHI);
735     outb_p(E8390_RREAD+E8390_START, nic_base + AXNET_CMD);
736
737     insw(nic_base + AXNET_DATAPORT,buf,count>>1);
738     if (count & 0x01)
739         buf[count-1] = inb(nic_base + AXNET_DATAPORT), xfer_count++;
740
741 }
742
743 /*====================================================================*/
744
745 static void block_output(struct net_device *dev, int count,
746                          const u_char *buf, const int start_page)
747 {
748     unsigned int nic_base = dev->base_addr;
749
750     pr_debug("%s: [bo=%d]\n", dev->name, count);
751
752     /* Round the count up for word writes.  Do we need to do this?
753        What effect will an odd byte count have on the 8390?
754        I should check someday. */
755     if (count & 0x01)
756         count++;
757
758     outb_p(0x00, nic_base + EN0_RSARLO);
759     outb_p(start_page, nic_base + EN0_RSARHI);
760     outb_p(E8390_RWRITE+E8390_START, nic_base + AXNET_CMD);
761     outsw(nic_base + AXNET_DATAPORT, buf, count>>1);
762 }
763
764 static struct pcmcia_device_id axnet_ids[] = {
765         PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x016c, 0x0081),
766         PCMCIA_DEVICE_MANF_CARD(0x018a, 0x0301),
767         PCMCIA_DEVICE_MANF_CARD(0x026f, 0x0301),
768         PCMCIA_DEVICE_MANF_CARD(0x026f, 0x0303),
769         PCMCIA_DEVICE_MANF_CARD(0x026f, 0x0309),
770         PCMCIA_DEVICE_MANF_CARD(0x0274, 0x1106),
771         PCMCIA_DEVICE_MANF_CARD(0x8a01, 0xc1ab),
772         PCMCIA_DEVICE_MANF_CARD(0x021b, 0x0202), 
773         PCMCIA_DEVICE_MANF_CARD(0xffff, 0x1090),
774         PCMCIA_DEVICE_PROD_ID12("AmbiCom,Inc.", "Fast Ethernet PC Card(AMB8110)", 0x49b020a7, 0x119cc9fc),
775         PCMCIA_DEVICE_PROD_ID124("Fast Ethernet", "16-bit PC Card", "AX88190", 0xb4be14e3, 0x9a12eb6a, 0xab9be5ef),
776         PCMCIA_DEVICE_PROD_ID12("ASIX", "AX88190", 0x0959823b, 0xab9be5ef),
777         PCMCIA_DEVICE_PROD_ID12("Billionton", "LNA-100B", 0x552ab682, 0xbc3b87e1),
778         PCMCIA_DEVICE_PROD_ID12("CHEETAH ETHERCARD", "EN2228", 0x00fa7bc8, 0x00e990cc),
779         PCMCIA_DEVICE_PROD_ID12("CNet", "CNF301", 0xbc477dde, 0x78c5f40b),
780         PCMCIA_DEVICE_PROD_ID12("corega K.K.", "corega FEther PCC-TXD", 0x5261440f, 0x436768c5),
781         PCMCIA_DEVICE_PROD_ID12("corega K.K.", "corega FEtherII PCC-TXD", 0x5261440f, 0x730df72e),
782         PCMCIA_DEVICE_PROD_ID12("Dynalink", "L100C16", 0x55632fd5, 0x66bc2a90),
783         PCMCIA_DEVICE_PROD_ID12("IO DATA", "ETXPCM", 0x547e66dc, 0x233adac2),
784         PCMCIA_DEVICE_PROD_ID12("Linksys", "EtherFast 10/100 PC Card (PCMPC100 V3)", 0x0733cc81, 0x232019a8),
785         PCMCIA_DEVICE_PROD_ID12("MELCO", "LPC3-TX", 0x481e0094, 0xf91af609),
786         PCMCIA_DEVICE_PROD_ID12("NETGEAR", "FA411", 0x9aa79dc3, 0x40fad875),
787         PCMCIA_DEVICE_PROD_ID12("PCMCIA", "100BASE", 0x281f1c5d, 0x7c2add04),
788         PCMCIA_DEVICE_PROD_ID12("PCMCIA", "FastEtherCard", 0x281f1c5d, 0x7ef26116),
789         PCMCIA_DEVICE_PROD_ID12("PCMCIA", "FEP501", 0x281f1c5d, 0x2e272058),
790         PCMCIA_DEVICE_PROD_ID14("Network Everywhere", "AX88190", 0x820a67b6,  0xab9be5ef),
791         PCMCIA_DEVICE_NULL,
792 };
793 MODULE_DEVICE_TABLE(pcmcia, axnet_ids);
794
795 static struct pcmcia_driver axnet_cs_driver = {
796         .owner          = THIS_MODULE,
797         .drv            = {
798                 .name   = "axnet_cs",
799         },
800         .probe          = axnet_probe,
801         .remove         = axnet_detach,
802         .id_table       = axnet_ids,
803         .suspend        = axnet_suspend,
804         .resume         = axnet_resume,
805 };
806
807 static int __init init_axnet_cs(void)
808 {
809         return pcmcia_register_driver(&axnet_cs_driver);
810 }
811
812 static void __exit exit_axnet_cs(void)
813 {
814         pcmcia_unregister_driver(&axnet_cs_driver);
815 }
816
817 module_init(init_axnet_cs);
818 module_exit(exit_axnet_cs);
819
820 /*====================================================================*/
821
822 /* 8390.c: A general NS8390 ethernet driver core for linux. */
823 /*
824         Written 1992-94 by Donald Becker.
825   
826         Copyright 1993 United States Government as represented by the
827         Director, National Security Agency.
828
829         This software may be used and distributed according to the terms
830         of the GNU General Public License, incorporated herein by reference.
831
832         The author may be reached as becker@scyld.com, or C/O
833         Scyld Computing Corporation
834         410 Severn Ave., Suite 210
835         Annapolis MD 21403
836
837   This is the chip-specific code for many 8390-based ethernet adaptors.
838   This is not a complete driver, it must be combined with board-specific
839   code such as ne.c, wd.c, 3c503.c, etc.
840
841   Seeing how at least eight drivers use this code, (not counting the
842   PCMCIA ones either) it is easy to break some card by what seems like
843   a simple innocent change. Please contact me or Donald if you think
844   you have found something that needs changing. -- PG
845
846   Changelog:
847
848   Paul Gortmaker        : remove set_bit lock, other cleanups.
849   Paul Gortmaker        : add ei_get_8390_hdr() so we can pass skb's to 
850                           ei_block_input() for eth_io_copy_and_sum().
851   Paul Gortmaker        : exchange static int ei_pingpong for a #define,
852                           also add better Tx error handling.
853   Paul Gortmaker        : rewrite Rx overrun handling as per NS specs.
854   Alexey Kuznetsov      : use the 8390's six bit hash multicast filter.
855   Paul Gortmaker        : tweak ANK's above multicast changes a bit.
856   Paul Gortmaker        : update packet statistics for v2.1.x
857   Alan Cox              : support arbitary stupid port mappings on the
858                           68K Macintosh. Support >16bit I/O spaces
859   Paul Gortmaker        : add kmod support for auto-loading of the 8390
860                           module by all drivers that require it.
861   Alan Cox              : Spinlocking work, added 'BUG_83C690'
862   Paul Gortmaker        : Separate out Tx timeout code from Tx path.
863
864   Sources:
865   The National Semiconductor LAN Databook, and the 3Com 3c503 databook.
866
867   */
868
869 static const char version_8390[] = KERN_INFO \
870     "8390.c:v1.10cvs 9/23/94 Donald Becker (becker@scyld.com)\n";
871
872 #include <linux/bitops.h>
873 #include <asm/irq.h>
874 #include <linux/fcntl.h>
875 #include <linux/in.h>
876 #include <linux/interrupt.h>
877
878 #define BUG_83C690
879
880 /* These are the operational function interfaces to board-specific
881    routines.
882         void reset_8390(struct net_device *dev)
883                 Resets the board associated with DEV, including a hardware reset of
884                 the 8390.  This is only called when there is a transmit timeout, and
885                 it is always followed by 8390_init().
886         void block_output(struct net_device *dev, int count, const unsigned char *buf,
887                                           int start_page)
888                 Write the COUNT bytes of BUF to the packet buffer at START_PAGE.  The
889                 "page" value uses the 8390's 256-byte pages.
890         void get_8390_hdr(struct net_device *dev, struct e8390_hdr *hdr, int ring_page)
891                 Read the 4 byte, page aligned 8390 header. *If* there is a
892                 subsequent read, it will be of the rest of the packet.
893         void block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
894                 Read COUNT bytes from the packet buffer into the skb data area. Start 
895                 reading from RING_OFFSET, the address as the 8390 sees it.  This will always
896                 follow the read of the 8390 header. 
897 */
898 #define ei_reset_8390 (ei_local->reset_8390)
899 #define ei_block_output (ei_local->block_output)
900 #define ei_block_input (ei_local->block_input)
901 #define ei_get_8390_hdr (ei_local->get_8390_hdr)
902
903 /* use 0 for production, 1 for verification, >2 for debug */
904 #ifndef ei_debug
905 int ei_debug = 1;
906 #endif
907
908 /* Index to functions. */
909 static void ei_tx_intr(struct net_device *dev);
910 static void ei_tx_err(struct net_device *dev);
911 static void ei_receive(struct net_device *dev);
912 static void ei_rx_overrun(struct net_device *dev);
913
914 /* Routines generic to NS8390-based boards. */
915 static void NS8390_trigger_send(struct net_device *dev, unsigned int length,
916                                                                 int start_page);
917 static void do_set_multicast_list(struct net_device *dev);
918
919 /*
920  *      SMP and the 8390 setup.
921  *
922  *      The 8390 isnt exactly designed to be multithreaded on RX/TX. There is
923  *      a page register that controls bank and packet buffer access. We guard
924  *      this with ei_local->page_lock. Nobody should assume or set the page other
925  *      than zero when the lock is not held. Lock holders must restore page 0
926  *      before unlocking. Even pure readers must take the lock to protect in 
927  *      page 0.
928  *
929  *      To make life difficult the chip can also be very slow. We therefore can't
930  *      just use spinlocks. For the longer lockups we disable the irq the device
931  *      sits on and hold the lock. We must hold the lock because there is a dual
932  *      processor case other than interrupts (get stats/set multicast list in
933  *      parallel with each other and transmit).
934  *
935  *      Note: in theory we can just disable the irq on the card _but_ there is
936  *      a latency on SMP irq delivery. So we can easily go "disable irq" "sync irqs"
937  *      enter lock, take the queued irq. So we waddle instead of flying.
938  *
939  *      Finally by special arrangement for the purpose of being generally 
940  *      annoying the transmit function is called bh atomic. That places
941  *      restrictions on the user context callers as disable_irq won't save
942  *      them.
943  */
944  
945 /**
946  * ax_open - Open/initialize the board.
947  * @dev: network device to initialize
948  *
949  * This routine goes all-out, setting everything
950  * up anew at each open, even though many of these registers should only
951  * need to be set once at boot.
952  */
953 static int ax_open(struct net_device *dev)
954 {
955         unsigned long flags;
956         struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
957
958         /*
959          *      Grab the page lock so we own the register set, then call
960          *      the init function.
961          */
962       
963         spin_lock_irqsave(&ei_local->page_lock, flags);
964         AX88190_init(dev, 1);
965         /* Set the flag before we drop the lock, That way the IRQ arrives
966            after its set and we get no silly warnings */
967         netif_start_queue(dev);
968         spin_unlock_irqrestore(&ei_local->page_lock, flags);
969         ei_local->irqlock = 0;
970         return 0;
971 }
972
973 #define dev_lock(dev) (((struct ei_device *)netdev_priv(dev))->page_lock)
974
975 /**
976  * ax_close - shut down network device
977  * @dev: network device to close
978  *
979  * Opposite of ax_open(). Only used when "ifconfig <devname> down" is done.
980  */
981 static int ax_close(struct net_device *dev)
982 {
983         unsigned long flags;
984
985         /*
986          *      Hold the page lock during close
987          */
988
989         spin_lock_irqsave(&dev_lock(dev), flags);
990         AX88190_init(dev, 0);
991         spin_unlock_irqrestore(&dev_lock(dev), flags);
992         netif_stop_queue(dev);
993         return 0;
994 }
995
996 /**
997  * axnet_tx_timeout - handle transmit time out condition
998  * @dev: network device which has apparently fallen asleep
999  *
1000  * Called by kernel when device never acknowledges a transmit has
1001  * completed (or failed) - i.e. never posted a Tx related interrupt.
1002  */
1003
1004 static void axnet_tx_timeout(struct net_device *dev)
1005 {
1006         long e8390_base = dev->base_addr;
1007         struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
1008         int txsr, isr, tickssofar = jiffies - dev->trans_start;
1009         unsigned long flags;
1010
1011         dev->stats.tx_errors++;
1012
1013         spin_lock_irqsave(&ei_local->page_lock, flags);
1014         txsr = inb(e8390_base+EN0_TSR);
1015         isr = inb(e8390_base+EN0_ISR);
1016         spin_unlock_irqrestore(&ei_local->page_lock, flags);
1017
1018         printk(KERN_DEBUG "%s: Tx timed out, %s TSR=%#2x, ISR=%#2x, t=%d.\n",
1019                 dev->name, (txsr & ENTSR_ABT) ? "excess collisions." :
1020                 (isr) ? "lost interrupt?" : "cable problem?", txsr, isr, tickssofar);
1021
1022         if (!isr && !dev->stats.tx_packets) 
1023         {
1024                 /* The 8390 probably hasn't gotten on the cable yet. */
1025                 ei_local->interface_num ^= 1;   /* Try a different xcvr.  */
1026         }
1027
1028         /* Ugly but a reset can be slow, yet must be protected */
1029                 
1030         spin_lock_irqsave(&ei_local->page_lock, flags);
1031                 
1032         /* Try to restart the card.  Perhaps the user has fixed something. */
1033         ei_reset_8390(dev);
1034         AX88190_init(dev, 1);
1035                 
1036         spin_unlock_irqrestore(&ei_local->page_lock, flags);
1037         netif_wake_queue(dev);
1038 }
1039     
1040 /**
1041  * axnet_start_xmit - begin packet transmission
1042  * @skb: packet to be sent
1043  * @dev: network device to which packet is sent
1044  *
1045  * Sends a packet to an 8390 network device.
1046  */
1047  
1048 static netdev_tx_t axnet_start_xmit(struct sk_buff *skb,
1049                                           struct net_device *dev)
1050 {
1051         long e8390_base = dev->base_addr;
1052         struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
1053         int length, send_length, output_page;
1054         unsigned long flags;
1055         u8 packet[ETH_ZLEN];
1056         
1057         netif_stop_queue(dev);
1058
1059         length = skb->len;
1060
1061         /* Mask interrupts from the ethercard. 
1062            SMP: We have to grab the lock here otherwise the IRQ handler
1063            on another CPU can flip window and race the IRQ mask set. We end
1064            up trashing the mcast filter not disabling irqs if we don't lock */
1065            
1066         spin_lock_irqsave(&ei_local->page_lock, flags);
1067         outb_p(0x00, e8390_base + EN0_IMR);
1068         spin_unlock_irqrestore(&ei_local->page_lock, flags);
1069         
1070         /*
1071          *      Slow phase with lock held.
1072          */
1073          
1074         spin_lock_irqsave(&ei_local->page_lock, flags);
1075         
1076         ei_local->irqlock = 1;
1077
1078         send_length = max(length, ETH_ZLEN);
1079
1080         /*
1081          * We have two Tx slots available for use. Find the first free
1082          * slot, and then perform some sanity checks. With two Tx bufs,
1083          * you get very close to transmitting back-to-back packets. With
1084          * only one Tx buf, the transmitter sits idle while you reload the
1085          * card, leaving a substantial gap between each transmitted packet.
1086          */
1087
1088         if (ei_local->tx1 == 0) 
1089         {
1090                 output_page = ei_local->tx_start_page;
1091                 ei_local->tx1 = send_length;
1092                 if (ei_debug  &&  ei_local->tx2 > 0)
1093                         printk(KERN_DEBUG "%s: idle transmitter tx2=%d, lasttx=%d, txing=%d.\n",
1094                                 dev->name, ei_local->tx2, ei_local->lasttx, ei_local->txing);
1095         }
1096         else if (ei_local->tx2 == 0) 
1097         {
1098                 output_page = ei_local->tx_start_page + TX_PAGES/2;
1099                 ei_local->tx2 = send_length;
1100                 if (ei_debug  &&  ei_local->tx1 > 0)
1101                         printk(KERN_DEBUG "%s: idle transmitter, tx1=%d, lasttx=%d, txing=%d.\n",
1102                                 dev->name, ei_local->tx1, ei_local->lasttx, ei_local->txing);
1103         }
1104         else
1105         {       /* We should never get here. */
1106                 if (ei_debug)
1107                         printk(KERN_DEBUG "%s: No Tx buffers free! tx1=%d tx2=%d last=%d\n",
1108                                 dev->name, ei_local->tx1, ei_local->tx2, ei_local->lasttx);
1109                 ei_local->irqlock = 0;
1110                 netif_stop_queue(dev);
1111                 outb_p(ENISR_ALL, e8390_base + EN0_IMR);
1112                 spin_unlock_irqrestore(&ei_local->page_lock, flags);
1113                 dev->stats.tx_errors++;
1114                 return NETDEV_TX_BUSY;
1115         }
1116
1117         /*
1118          * Okay, now upload the packet and trigger a send if the transmitter
1119          * isn't already sending. If it is busy, the interrupt handler will
1120          * trigger the send later, upon receiving a Tx done interrupt.
1121          */
1122
1123         if (length == skb->len)
1124                 ei_block_output(dev, length, skb->data, output_page);
1125         else {
1126                 memset(packet, 0, ETH_ZLEN);
1127                 skb_copy_from_linear_data(skb, packet, skb->len);
1128                 ei_block_output(dev, length, packet, output_page);
1129         }
1130         
1131         if (! ei_local->txing) 
1132         {
1133                 ei_local->txing = 1;
1134                 NS8390_trigger_send(dev, send_length, output_page);
1135                 dev->trans_start = jiffies;
1136                 if (output_page == ei_local->tx_start_page) 
1137                 {
1138                         ei_local->tx1 = -1;
1139                         ei_local->lasttx = -1;
1140                 }
1141                 else 
1142                 {
1143                         ei_local->tx2 = -1;
1144                         ei_local->lasttx = -2;
1145                 }
1146         }
1147         else ei_local->txqueue++;
1148
1149         if (ei_local->tx1  &&  ei_local->tx2)
1150                 netif_stop_queue(dev);
1151         else
1152                 netif_start_queue(dev);
1153
1154         /* Turn 8390 interrupts back on. */
1155         ei_local->irqlock = 0;
1156         outb_p(ENISR_ALL, e8390_base + EN0_IMR);
1157         
1158         spin_unlock_irqrestore(&ei_local->page_lock, flags);
1159
1160         dev_kfree_skb (skb);
1161         dev->stats.tx_bytes += send_length;
1162     
1163         return NETDEV_TX_OK;
1164 }
1165
1166 /**
1167  * ax_interrupt - handle the interrupts from an 8390
1168  * @irq: interrupt number
1169  * @dev_id: a pointer to the net_device
1170  *
1171  * Handle the ether interface interrupts. We pull packets from
1172  * the 8390 via the card specific functions and fire them at the networking
1173  * stack. We also handle transmit completions and wake the transmit path if
1174  * necessary. We also update the counters and do other housekeeping as
1175  * needed.
1176  */
1177
1178 static irqreturn_t ax_interrupt(int irq, void *dev_id)
1179 {
1180         struct net_device *dev = dev_id;
1181         long e8390_base;
1182         int interrupts, nr_serviced = 0, i;
1183         struct ei_device *ei_local;
1184         int handled = 0;
1185
1186         e8390_base = dev->base_addr;
1187         ei_local = netdev_priv(dev);
1188
1189         /*
1190          *      Protect the irq test too.
1191          */
1192          
1193         spin_lock(&ei_local->page_lock);
1194
1195         if (ei_local->irqlock) 
1196         {
1197 #if 1 /* This might just be an interrupt for a PCI device sharing this line */
1198                 /* The "irqlock" check is only for testing. */
1199                 printk(ei_local->irqlock
1200                            ? "%s: Interrupted while interrupts are masked! isr=%#2x imr=%#2x.\n"
1201                            : "%s: Reentering the interrupt handler! isr=%#2x imr=%#2x.\n",
1202                            dev->name, inb_p(e8390_base + EN0_ISR),
1203                            inb_p(e8390_base + EN0_IMR));
1204 #endif
1205                 spin_unlock(&ei_local->page_lock);
1206                 return IRQ_NONE;
1207         }
1208     
1209         if (ei_debug > 3)
1210                 printk(KERN_DEBUG "%s: interrupt(isr=%#2.2x).\n", dev->name,
1211                            inb_p(e8390_base + EN0_ISR));
1212
1213         outb_p(0x00, e8390_base + EN0_ISR);
1214         ei_local->irqlock = 1;
1215    
1216         /* !!Assumption!! -- we stay in page 0.  Don't break this. */
1217         while ((interrupts = inb_p(e8390_base + EN0_ISR)) != 0 &&
1218                ++nr_serviced < MAX_SERVICE)
1219         {
1220                 if (!netif_running(dev) || (interrupts == 0xff)) {
1221                         if (ei_debug > 1)
1222                                 printk(KERN_WARNING "%s: interrupt from stopped card\n", dev->name);
1223                         outb_p(interrupts, e8390_base + EN0_ISR);
1224                         interrupts = 0;
1225                         break;
1226                 }
1227                 handled = 1;
1228
1229                 /* AX88190 bug fix. */
1230                 outb_p(interrupts, e8390_base + EN0_ISR);
1231                 for (i = 0; i < 10; i++) {
1232                         if (!(inb(e8390_base + EN0_ISR) & interrupts))
1233                                 break;
1234                         outb_p(0, e8390_base + EN0_ISR);
1235                         outb_p(interrupts, e8390_base + EN0_ISR);
1236                 }
1237                 if (interrupts & ENISR_OVER) 
1238                         ei_rx_overrun(dev);
1239                 else if (interrupts & (ENISR_RX+ENISR_RX_ERR)) 
1240                 {
1241                         /* Got a good (?) packet. */
1242                         ei_receive(dev);
1243                 }
1244                 /* Push the next to-transmit packet through. */
1245                 if (interrupts & ENISR_TX)
1246                         ei_tx_intr(dev);
1247                 else if (interrupts & ENISR_TX_ERR)
1248                         ei_tx_err(dev);
1249
1250                 if (interrupts & ENISR_COUNTERS) 
1251                 {
1252                         dev->stats.rx_frame_errors += inb_p(e8390_base + EN0_COUNTER0);
1253                         dev->stats.rx_crc_errors   += inb_p(e8390_base + EN0_COUNTER1);
1254                         dev->stats.rx_missed_errors+= inb_p(e8390_base + EN0_COUNTER2);
1255                 }
1256         }
1257     
1258         if (interrupts && ei_debug > 3) 
1259         {
1260                 handled = 1;
1261                 if (nr_serviced >= MAX_SERVICE) 
1262                 {
1263                         /* 0xFF is valid for a card removal */
1264                         if(interrupts!=0xFF)
1265                                 printk(KERN_WARNING "%s: Too much work at interrupt, status %#2.2x\n",
1266                                    dev->name, interrupts);
1267                         outb_p(ENISR_ALL, e8390_base + EN0_ISR); /* Ack. most intrs. */
1268                 } else {
1269                         printk(KERN_WARNING "%s: unknown interrupt %#2x\n", dev->name, interrupts);
1270                         outb_p(0xff, e8390_base + EN0_ISR); /* Ack. all intrs. */
1271                 }
1272         }
1273
1274         /* Turn 8390 interrupts back on. */
1275         ei_local->irqlock = 0;
1276         outb_p(ENISR_ALL, e8390_base + EN0_IMR);
1277
1278         spin_unlock(&ei_local->page_lock);
1279         return IRQ_RETVAL(handled);
1280 }
1281
1282 /**
1283  * ei_tx_err - handle transmitter error
1284  * @dev: network device which threw the exception
1285  *
1286  * A transmitter error has happened. Most likely excess collisions (which
1287  * is a fairly normal condition). If the error is one where the Tx will
1288  * have been aborted, we try and send another one right away, instead of
1289  * letting the failed packet sit and collect dust in the Tx buffer. This
1290  * is a much better solution as it avoids kernel based Tx timeouts, and
1291  * an unnecessary card reset.
1292  *
1293  * Called with lock held.
1294  */
1295
1296 static void ei_tx_err(struct net_device *dev)
1297 {
1298         long e8390_base = dev->base_addr;
1299         unsigned char txsr = inb_p(e8390_base+EN0_TSR);
1300         unsigned char tx_was_aborted = txsr & (ENTSR_ABT+ENTSR_FU);
1301
1302 #ifdef VERBOSE_ERROR_DUMP
1303         printk(KERN_DEBUG "%s: transmitter error (%#2x): ", dev->name, txsr);
1304         if (txsr & ENTSR_ABT)
1305                 printk("excess-collisions ");
1306         if (txsr & ENTSR_ND)
1307                 printk("non-deferral ");
1308         if (txsr & ENTSR_CRS)
1309                 printk("lost-carrier ");
1310         if (txsr & ENTSR_FU)
1311                 printk("FIFO-underrun ");
1312         if (txsr & ENTSR_CDH)
1313                 printk("lost-heartbeat ");
1314         printk("\n");
1315 #endif
1316
1317         if (tx_was_aborted)
1318                 ei_tx_intr(dev);
1319         else 
1320         {
1321                 dev->stats.tx_errors++;
1322                 if (txsr & ENTSR_CRS) dev->stats.tx_carrier_errors++;
1323                 if (txsr & ENTSR_CDH) dev->stats.tx_heartbeat_errors++;
1324                 if (txsr & ENTSR_OWC) dev->stats.tx_window_errors++;
1325         }
1326 }
1327
1328 /**
1329  * ei_tx_intr - transmit interrupt handler
1330  * @dev: network device for which tx intr is handled
1331  *
1332  * We have finished a transmit: check for errors and then trigger the next
1333  * packet to be sent. Called with lock held.
1334  */
1335
1336 static void ei_tx_intr(struct net_device *dev)
1337 {
1338         long e8390_base = dev->base_addr;
1339         struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
1340         int status = inb(e8390_base + EN0_TSR);
1341     
1342         /*
1343          * There are two Tx buffers, see which one finished, and trigger
1344          * the send of another one if it exists.
1345          */
1346         ei_local->txqueue--;
1347
1348         if (ei_local->tx1 < 0) 
1349         {
1350                 if (ei_local->lasttx != 1 && ei_local->lasttx != -1)
1351                         printk(KERN_ERR "%s: bogus last_tx_buffer %d, tx1=%d.\n",
1352                                 ei_local->name, ei_local->lasttx, ei_local->tx1);
1353                 ei_local->tx1 = 0;
1354                 if (ei_local->tx2 > 0) 
1355                 {
1356                         ei_local->txing = 1;
1357                         NS8390_trigger_send(dev, ei_local->tx2, ei_local->tx_start_page + 6);
1358                         dev->trans_start = jiffies;
1359                         ei_local->tx2 = -1,
1360                         ei_local->lasttx = 2;
1361                 }
1362                 else ei_local->lasttx = 20, ei_local->txing = 0;        
1363         }
1364         else if (ei_local->tx2 < 0) 
1365         {
1366                 if (ei_local->lasttx != 2  &&  ei_local->lasttx != -2)
1367                         printk("%s: bogus last_tx_buffer %d, tx2=%d.\n",
1368                                 ei_local->name, ei_local->lasttx, ei_local->tx2);
1369                 ei_local->tx2 = 0;
1370                 if (ei_local->tx1 > 0) 
1371                 {
1372                         ei_local->txing = 1;
1373                         NS8390_trigger_send(dev, ei_local->tx1, ei_local->tx_start_page);
1374                         dev->trans_start = jiffies;
1375                         ei_local->tx1 = -1;
1376                         ei_local->lasttx = 1;
1377                 }
1378                 else
1379                         ei_local->lasttx = 10, ei_local->txing = 0;
1380         }
1381 //      else printk(KERN_WARNING "%s: unexpected TX-done interrupt, lasttx=%d.\n",
1382 //                      dev->name, ei_local->lasttx);
1383
1384         /* Minimize Tx latency: update the statistics after we restart TXing. */
1385         if (status & ENTSR_COL)
1386                 dev->stats.collisions++;
1387         if (status & ENTSR_PTX)
1388                 dev->stats.tx_packets++;
1389         else 
1390         {
1391                 dev->stats.tx_errors++;
1392                 if (status & ENTSR_ABT) 
1393                 {
1394                         dev->stats.tx_aborted_errors++;
1395                         dev->stats.collisions += 16;
1396                 }
1397                 if (status & ENTSR_CRS) 
1398                         dev->stats.tx_carrier_errors++;
1399                 if (status & ENTSR_FU) 
1400                         dev->stats.tx_fifo_errors++;
1401                 if (status & ENTSR_CDH)
1402                         dev->stats.tx_heartbeat_errors++;
1403                 if (status & ENTSR_OWC)
1404                         dev->stats.tx_window_errors++;
1405         }
1406         netif_wake_queue(dev);
1407 }
1408
1409 /**
1410  * ei_receive - receive some packets
1411  * @dev: network device with which receive will be run
1412  *
1413  * We have a good packet(s), get it/them out of the buffers. 
1414  * Called with lock held.
1415  */
1416
1417 static void ei_receive(struct net_device *dev)
1418 {
1419         long e8390_base = dev->base_addr;
1420         struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
1421         unsigned char rxing_page, this_frame, next_frame;
1422         unsigned short current_offset;
1423         int rx_pkt_count = 0;
1424         struct e8390_pkt_hdr rx_frame;
1425     
1426         while (++rx_pkt_count < 10) 
1427         {
1428                 int pkt_len, pkt_stat;
1429                 
1430                 /* Get the rx page (incoming packet pointer). */
1431                 rxing_page = inb_p(e8390_base + EN1_CURPAG -1);
1432                 
1433                 /* Remove one frame from the ring.  Boundary is always a page behind. */
1434                 this_frame = inb_p(e8390_base + EN0_BOUNDARY) + 1;
1435                 if (this_frame >= ei_local->stop_page)
1436                         this_frame = ei_local->rx_start_page;
1437                 
1438                 /* Someday we'll omit the previous, iff we never get this message.
1439                    (There is at least one clone claimed to have a problem.)  
1440                    
1441                    Keep quiet if it looks like a card removal. One problem here
1442                    is that some clones crash in roughly the same way.
1443                  */
1444                 if (ei_debug > 0  &&  this_frame != ei_local->current_page && (this_frame!=0x0 || rxing_page!=0xFF))
1445                         printk(KERN_ERR "%s: mismatched read page pointers %2x vs %2x.\n",
1446                                    dev->name, this_frame, ei_local->current_page);
1447                 
1448                 if (this_frame == rxing_page)   /* Read all the frames? */
1449                         break;                          /* Done for now */
1450                 
1451                 current_offset = this_frame << 8;
1452                 ei_get_8390_hdr(dev, &rx_frame, this_frame);
1453                 
1454                 pkt_len = rx_frame.count - sizeof(struct e8390_pkt_hdr);
1455                 pkt_stat = rx_frame.status;
1456                 
1457                 next_frame = this_frame + 1 + ((pkt_len+4)>>8);
1458                 
1459                 if (pkt_len < 60  ||  pkt_len > 1518) 
1460                 {
1461                         if (ei_debug)
1462                                 printk(KERN_DEBUG "%s: bogus packet size: %d, status=%#2x nxpg=%#2x.\n",
1463                                            dev->name, rx_frame.count, rx_frame.status,
1464                                            rx_frame.next);
1465                         dev->stats.rx_errors++;
1466                         dev->stats.rx_length_errors++;
1467                 }
1468                  else if ((pkt_stat & 0x0F) == ENRSR_RXOK) 
1469                 {
1470                         struct sk_buff *skb;
1471                         
1472                         skb = dev_alloc_skb(pkt_len+2);
1473                         if (skb == NULL) 
1474                         {
1475                                 if (ei_debug > 1)
1476                                         printk(KERN_DEBUG "%s: Couldn't allocate a sk_buff of size %d.\n",
1477                                                    dev->name, pkt_len);
1478                                 dev->stats.rx_dropped++;
1479                                 break;
1480                         }
1481                         else
1482                         {
1483                                 skb_reserve(skb,2);     /* IP headers on 16 byte boundaries */
1484                                 skb_put(skb, pkt_len);  /* Make room */
1485                                 ei_block_input(dev, pkt_len, skb, current_offset + sizeof(rx_frame));
1486                                 skb->protocol=eth_type_trans(skb,dev);
1487                                 netif_rx(skb);
1488                                 dev->stats.rx_packets++;
1489                                 dev->stats.rx_bytes += pkt_len;
1490                                 if (pkt_stat & ENRSR_PHY)
1491                                         dev->stats.multicast++;
1492                         }
1493                 } 
1494                 else 
1495                 {
1496                         if (ei_debug)
1497                                 printk(KERN_DEBUG "%s: bogus packet: status=%#2x nxpg=%#2x size=%d\n",
1498                                            dev->name, rx_frame.status, rx_frame.next,
1499                                            rx_frame.count);
1500                         dev->stats.rx_errors++;
1501                         /* NB: The NIC counts CRC, frame and missed errors. */
1502                         if (pkt_stat & ENRSR_FO)
1503                                 dev->stats.rx_fifo_errors++;
1504                 }
1505                 next_frame = rx_frame.next;
1506                 
1507                 /* This _should_ never happen: it's here for avoiding bad clones. */
1508                 if (next_frame >= ei_local->stop_page) {
1509                         printk("%s: next frame inconsistency, %#2x\n", dev->name,
1510                                    next_frame);
1511                         next_frame = ei_local->rx_start_page;
1512                 }
1513                 ei_local->current_page = next_frame;
1514                 outb_p(next_frame-1, e8390_base+EN0_BOUNDARY);
1515         }
1516
1517         return;
1518 }
1519
1520 /**
1521  * ei_rx_overrun - handle receiver overrun
1522  * @dev: network device which threw exception
1523  *
1524  * We have a receiver overrun: we have to kick the 8390 to get it started
1525  * again. Problem is that you have to kick it exactly as NS prescribes in
1526  * the updated datasheets, or "the NIC may act in an unpredictable manner."
1527  * This includes causing "the NIC to defer indefinitely when it is stopped
1528  * on a busy network."  Ugh.
1529  * Called with lock held. Don't call this with the interrupts off or your
1530  * computer will hate you - it takes 10ms or so. 
1531  */
1532
1533 static void ei_rx_overrun(struct net_device *dev)
1534 {
1535         axnet_dev_t *info = PRIV(dev);
1536         long e8390_base = dev->base_addr;
1537         unsigned char was_txing, must_resend = 0;
1538     
1539         /*
1540          * Record whether a Tx was in progress and then issue the
1541          * stop command.
1542          */
1543         was_txing = inb_p(e8390_base+E8390_CMD) & E8390_TRANS;
1544         outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base+E8390_CMD);
1545     
1546         if (ei_debug > 1)
1547                 printk(KERN_DEBUG "%s: Receiver overrun.\n", dev->name);
1548         dev->stats.rx_over_errors++;
1549     
1550         /* 
1551          * Wait a full Tx time (1.2ms) + some guard time, NS says 1.6ms total.
1552          * Early datasheets said to poll the reset bit, but now they say that
1553          * it "is not a reliable indicator and subsequently should be ignored."
1554          * We wait at least 10ms.
1555          */
1556
1557         mdelay(10);
1558
1559         /*
1560          * Reset RBCR[01] back to zero as per magic incantation.
1561          */
1562         outb_p(0x00, e8390_base+EN0_RCNTLO);
1563         outb_p(0x00, e8390_base+EN0_RCNTHI);
1564
1565         /*
1566          * See if any Tx was interrupted or not. According to NS, this
1567          * step is vital, and skipping it will cause no end of havoc.
1568          */
1569
1570         if (was_txing)
1571         { 
1572                 unsigned char tx_completed = inb_p(e8390_base+EN0_ISR) & (ENISR_TX+ENISR_TX_ERR);
1573                 if (!tx_completed)
1574                         must_resend = 1;
1575         }
1576
1577         /*
1578          * Have to enter loopback mode and then restart the NIC before
1579          * you are allowed to slurp packets up off the ring.
1580          */
1581         outb_p(E8390_TXOFF, e8390_base + EN0_TXCR);
1582         outb_p(E8390_NODMA + E8390_PAGE0 + E8390_START, e8390_base + E8390_CMD);
1583
1584         /*
1585          * Clear the Rx ring of all the debris, and ack the interrupt.
1586          */
1587         ei_receive(dev);
1588
1589         /*
1590          * Leave loopback mode, and resend any packet that got stopped.
1591          */
1592         outb_p(E8390_TXCONFIG | info->duplex_flag, e8390_base + EN0_TXCR); 
1593         if (must_resend)
1594                 outb_p(E8390_NODMA + E8390_PAGE0 + E8390_START + E8390_TRANS, e8390_base + E8390_CMD);
1595 }
1596
1597 /*
1598  *      Collect the stats. This is called unlocked and from several contexts.
1599  */
1600  
1601 static struct net_device_stats *get_stats(struct net_device *dev)
1602 {
1603         long ioaddr = dev->base_addr;
1604         struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
1605         unsigned long flags;
1606     
1607         /* If the card is stopped, just return the present stats. */
1608         if (!netif_running(dev))
1609                 return &dev->stats;
1610
1611         spin_lock_irqsave(&ei_local->page_lock,flags);
1612         /* Read the counter registers, assuming we are in page 0. */
1613         dev->stats.rx_frame_errors += inb_p(ioaddr + EN0_COUNTER0);
1614         dev->stats.rx_crc_errors   += inb_p(ioaddr + EN0_COUNTER1);
1615         dev->stats.rx_missed_errors+= inb_p(ioaddr + EN0_COUNTER2);
1616         spin_unlock_irqrestore(&ei_local->page_lock, flags);
1617     
1618         return &dev->stats;
1619 }
1620
1621 /*
1622  * Form the 64 bit 8390 multicast table from the linked list of addresses
1623  * associated with this dev structure.
1624  */
1625  
1626 static inline void make_mc_bits(u8 *bits, struct net_device *dev)
1627 {
1628         struct dev_mc_list *dmi;
1629         u32 crc;
1630
1631         for (dmi=dev->mc_list; dmi; dmi=dmi->next) {
1632                 
1633                 crc = ether_crc(ETH_ALEN, dmi->dmi_addr);
1634                 /* 
1635                  * The 8390 uses the 6 most significant bits of the
1636                  * CRC to index the multicast table.
1637                  */
1638                 bits[crc>>29] |= (1<<((crc>>26)&7));
1639         }
1640 }
1641
1642 /**
1643  * do_set_multicast_list - set/clear multicast filter
1644  * @dev: net device for which multicast filter is adjusted
1645  *
1646  *      Set or clear the multicast filter for this adaptor.
1647  *      Must be called with lock held. 
1648  */
1649  
1650 static void do_set_multicast_list(struct net_device *dev)
1651 {
1652         long e8390_base = dev->base_addr;
1653         int i;
1654         struct ei_device *ei_local = (struct ei_device*)netdev_priv(dev);
1655
1656         if (!(dev->flags&(IFF_PROMISC|IFF_ALLMULTI))) {
1657                 memset(ei_local->mcfilter, 0, 8);
1658                 if (dev->mc_list)
1659                         make_mc_bits(ei_local->mcfilter, dev);
1660         } else {
1661                 /* set to accept-all */
1662                 memset(ei_local->mcfilter, 0xFF, 8);
1663         }
1664
1665         outb_p(E8390_NODMA + E8390_PAGE1, e8390_base + E8390_CMD);
1666         for(i = 0; i < 8; i++) 
1667         {
1668                 outb_p(ei_local->mcfilter[i], e8390_base + EN1_MULT_SHIFT(i));
1669         }
1670         outb_p(E8390_NODMA + E8390_PAGE0, e8390_base + E8390_CMD);
1671
1672         if(dev->flags&IFF_PROMISC)
1673                 outb_p(E8390_RXCONFIG | 0x58, e8390_base + EN0_RXCR);
1674         else if(dev->flags&IFF_ALLMULTI || dev->mc_list)
1675                 outb_p(E8390_RXCONFIG | 0x48, e8390_base + EN0_RXCR);
1676         else
1677                 outb_p(E8390_RXCONFIG | 0x40, e8390_base + EN0_RXCR);
1678
1679         outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, e8390_base+E8390_CMD);
1680 }
1681
1682 /*
1683  *      Called without lock held. This is invoked from user context and may
1684  *      be parallel to just about everything else. Its also fairly quick and
1685  *      not called too often. Must protect against both bh and irq users
1686  */
1687
1688 static void set_multicast_list(struct net_device *dev)
1689 {
1690         unsigned long flags;
1691
1692         spin_lock_irqsave(&dev_lock(dev), flags);
1693         do_set_multicast_list(dev);
1694         spin_unlock_irqrestore(&dev_lock(dev), flags);
1695 }       
1696
1697 /* This page of functions should be 8390 generic */
1698 /* Follow National Semi's recommendations for initializing the "NIC". */
1699
1700 /**
1701  * AX88190_init - initialize 8390 hardware
1702  * @dev: network device to initialize
1703  * @startp: boolean.  non-zero value to initiate chip processing
1704  *
1705  *      Must be called with lock held.
1706  */
1707
1708 static void AX88190_init(struct net_device *dev, int startp)
1709 {
1710         axnet_dev_t *info = PRIV(dev);
1711         long e8390_base = dev->base_addr;
1712         struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
1713         int i;
1714         int endcfg = ei_local->word16 ? (0x48 | ENDCFG_WTS) : 0x48;
1715     
1716         if(sizeof(struct e8390_pkt_hdr)!=4)
1717                 panic("8390.c: header struct mispacked\n");    
1718         /* Follow National Semi's recommendations for initing the DP83902. */
1719         outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base+E8390_CMD); /* 0x21 */
1720         outb_p(endcfg, e8390_base + EN0_DCFG);  /* 0x48 or 0x49 */
1721         /* Clear the remote byte count registers. */
1722         outb_p(0x00,  e8390_base + EN0_RCNTLO);
1723         outb_p(0x00,  e8390_base + EN0_RCNTHI);
1724         /* Set to monitor and loopback mode -- this is vital!. */
1725         outb_p(E8390_RXOFF|0x40, e8390_base + EN0_RXCR); /* 0x60 */
1726         outb_p(E8390_TXOFF, e8390_base + EN0_TXCR); /* 0x02 */
1727         /* Set the transmit page and receive ring. */
1728         outb_p(ei_local->tx_start_page, e8390_base + EN0_TPSR);
1729         ei_local->tx1 = ei_local->tx2 = 0;
1730         outb_p(ei_local->rx_start_page, e8390_base + EN0_STARTPG);
1731         outb_p(ei_local->stop_page-1, e8390_base + EN0_BOUNDARY);       /* 3c503 says 0x3f,NS0x26*/
1732         ei_local->current_page = ei_local->rx_start_page;               /* assert boundary+1 */
1733         outb_p(ei_local->stop_page, e8390_base + EN0_STOPPG);
1734         /* Clear the pending interrupts and mask. */
1735         outb_p(0xFF, e8390_base + EN0_ISR);
1736         outb_p(0x00,  e8390_base + EN0_IMR);
1737     
1738         /* Copy the station address into the DS8390 registers. */
1739
1740         outb_p(E8390_NODMA + E8390_PAGE1 + E8390_STOP, e8390_base+E8390_CMD); /* 0x61 */
1741         for(i = 0; i < 6; i++) 
1742         {
1743                 outb_p(dev->dev_addr[i], e8390_base + EN1_PHYS_SHIFT(i));
1744                 if(inb_p(e8390_base + EN1_PHYS_SHIFT(i))!=dev->dev_addr[i])
1745                         printk(KERN_ERR "Hw. address read/write mismap %d\n",i);
1746         }
1747
1748         outb_p(ei_local->rx_start_page, e8390_base + EN1_CURPAG);
1749         outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base+E8390_CMD);
1750
1751         netif_start_queue(dev);
1752         ei_local->tx1 = ei_local->tx2 = 0;
1753         ei_local->txing = 0;
1754
1755         if (info->flags & IS_AX88790)   /* select Internal PHY */
1756                 outb(0x10, e8390_base + AXNET_GPIO);
1757
1758         if (startp) 
1759         {
1760                 outb_p(0xff,  e8390_base + EN0_ISR);
1761                 outb_p(ENISR_ALL,  e8390_base + EN0_IMR);
1762                 outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, e8390_base+E8390_CMD);
1763                 outb_p(E8390_TXCONFIG | info->duplex_flag,
1764                        e8390_base + EN0_TXCR); /* xmit on. */
1765                 /* 3c503 TechMan says rxconfig only after the NIC is started. */
1766                 outb_p(E8390_RXCONFIG | 0x40, e8390_base + EN0_RXCR); /* rx on, */
1767                 do_set_multicast_list(dev);     /* (re)load the mcast table */
1768         }
1769 }
1770
1771 /* Trigger a transmit start, assuming the length is valid. 
1772    Always called with the page lock held */
1773    
1774 static void NS8390_trigger_send(struct net_device *dev, unsigned int length,
1775                                                                 int start_page)
1776 {
1777         long e8390_base = dev->base_addr;
1778         struct ei_device *ei_local __attribute((unused)) = (struct ei_device *) netdev_priv(dev);
1779     
1780         if (inb_p(e8390_base) & E8390_TRANS) 
1781         {
1782                 printk(KERN_WARNING "%s: trigger_send() called with the transmitter busy.\n",
1783                         dev->name);
1784                 return;
1785         }
1786         outb_p(length & 0xff, e8390_base + EN0_TCNTLO);
1787         outb_p(length >> 8, e8390_base + EN0_TCNTHI);
1788         outb_p(start_page, e8390_base + EN0_TPSR);
1789         outb_p(E8390_NODMA+E8390_TRANS+E8390_START, e8390_base+E8390_CMD);
1790 }