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