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