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