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