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