Debian Codegraph @

linux/pcmcia-cs/clients/axnet_cs.c

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