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