projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
drivers/net/ethernet: Add ethernet dir and config option
[deliverable/linux.git] / drivers / net / pcmcia / 3c589_cs.c
CommitLineData
1da177e4
LT		 1/*======================================================================
2
3 A PCMCIA ethernet driver for the 3com 3c589 card.
f64e9697 4
1da177e4
LT		 5 Copyright (C) 1999 David A. Hinds -- dahinds@users.sourceforge.net
6
7 3c589_cs.c 1.162 2001/10/13 00:08:50
8
9 The network driver code is based on Donald Becker's 3c589 code:
f64e9697 10
1da177e4
LT		 11 Written 1994 by Donald Becker.
12 Copyright 1993 United States Government as represented by the
13 Director, National Security Agency. This software may be used and
14 distributed according to the terms of the GNU General Public License,
15 incorporated herein by reference.
16 Donald Becker may be reached at becker@scyld.com
f64e9697 17
113aa838 18 Updated for 2.5.x by Alan Cox <alan@lxorguk.ukuu.org.uk>
1da177e4
LT		 19
20======================================================================*/
21
636b8116
JP		 22#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
23
1da177e4
LT		 24#define DRV_NAME "3c589_cs"
25#define DRV_VERSION "1.162-ac"
26
27#include <linux/module.h>
28#include <linux/init.h>
29#include <linux/kernel.h>
30#include <linux/ptrace.h>
31#include <linux/slab.h>
32#include <linux/string.h>
33#include <linux/timer.h>
34#include <linux/interrupt.h>
35#include <linux/in.h>
36#include <linux/delay.h>
37#include <linux/ethtool.h>
38#include <linux/netdevice.h>
39#include <linux/etherdevice.h>
40#include <linux/skbuff.h>
41#include <linux/if_arp.h>
42#include <linux/ioport.h>
43#include <linux/bitops.h>
ff5688ae 44#include <linux/jiffies.h>
1da177e4 45
1da177e4
LT		 46#include <pcmcia/cistpl.h>
47#include <pcmcia/cisreg.h>
48#include <pcmcia/ciscode.h>
49#include <pcmcia/ds.h>
50
51#include <asm/uaccess.h>
52#include <asm/io.h>
53#include <asm/system.h>
54
55/* To minimize the size of the driver source I only define operating
56 constants if they are used several times. You'll need the manual
57 if you want to understand driver details. */
58/* Offsets from base I/O address. */
59#define EL3_DATA 0x00
60#define EL3_TIMER 0x0a
61#define EL3_CMD 0x0e
62#define EL3_STATUS 0x0e
63
64#define EEPROM_READ 0x0080
65#define EEPROM_BUSY 0x8000
66
67#define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
68
69/* The top five bits written to EL3_CMD are a command, the lower
70 11 bits are the parameter, if applicable. */
71enum c509cmd {
f64e9697
AK		 72 TotalReset = 0<<11,
73 SelectWindow = 1<<11,
74 StartCoax = 2<<11,
75 RxDisable = 3<<11,
76 RxEnable = 4<<11,
77 RxReset = 5<<11,
78 RxDiscard = 8<<11,
79 TxEnable = 9<<11,
80 TxDisable = 10<<11,
81 TxReset = 11<<11,
82 FakeIntr = 12<<11,
83 AckIntr = 13<<11,
84 SetIntrEnb = 14<<11,
85 SetStatusEnb = 15<<11,
86 SetRxFilter = 16<<11,
87 SetRxThreshold = 17<<11,
88 SetTxThreshold = 18<<11,
89 SetTxStart = 19<<11,
90 StatsEnable = 21<<11,
91 StatsDisable = 22<<11,
92 StopCoax = 23<<11
1da177e4
LT		 93};
94
95enum c509status {
f64e9697
AK		 96 IntLatch = 0x0001,
97 AdapterFailure = 0x0002,
98 TxComplete = 0x0004,
99 TxAvailable = 0x0008,
100 RxComplete = 0x0010,
101 RxEarly = 0x0020,
102 IntReq = 0x0040,
103 StatsFull = 0x0080,
104 CmdBusy = 0x1000
1da177e4
LT		 105};
106
107/* The SetRxFilter command accepts the following classes: */
108enum RxFilter {
f64e9697
AK		 109 RxStation = 1,
110 RxMulticast = 2,
111 RxBroadcast = 4,
112 RxProm = 8
1da177e4
LT		 113};
114
115/* Register window 1 offsets, the window used in normal operation. */
116#define TX_FIFO 0x00
117#define RX_FIFO 0x00
f64e9697
AK		 118#define RX_STATUS 0x08
119#define TX_STATUS 0x0B
1da177e4
LT		 120#define TX_FREE 0x0C /* Remaining free bytes in Tx buffer. */
121
122#define WN0_IRQ 0x08 /* Window 0: Set IRQ line in bits 12-15. */
123#define WN4_MEDIA 0x0A /* Window 4: Various transcvr/media bits. */
124#define MEDIA_TP 0x00C0 /* Enable link beat and jabber for 10baseT. */
125#define MEDIA_LED 0x0001 /* Enable link light on 3C589E cards. */
126
127/* Time in jiffies before concluding Tx hung */
128#define TX_TIMEOUT ((400*HZ)/1000)
129
130struct el3_private {
fd238232 131 struct pcmcia_device *p_dev;
f64e9697
AK		 132 /* For transceiver monitoring */
133 struct timer_list media;
134 u16 media_status;
135 u16 fast_poll;
136 unsigned long last_irq;
137 spinlock_t lock;
1da177e4
LT		 138};
139
21c0f275 140static const char *if_names[] = { "auto", "10baseT", "10base2", "AUI" };
1da177e4
LT		 141
142/*====================================================================*/
143
144/* Module parameters */
145
146MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
147MODULE_DESCRIPTION("3Com 3c589 series PCMCIA ethernet driver");
148MODULE_LICENSE("GPL");
149
150#define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0)
151
152/* Special hook for setting if_port when module is loaded */
153INT_MODULE_PARM(if_port, 0);
154
1da177e4
LT		 155
156/*====================================================================*/
157
15b99ac1 158static int tc589_config(struct pcmcia_device *link);
fba395ee 159static void tc589_release(struct pcmcia_device *link);
1da177e4 160
906da809 161static u16 read_eeprom(unsigned int ioaddr, int index);
1da177e4
LT		 162static void tc589_reset(struct net_device *dev);
163static void media_check(unsigned long arg);
164static int el3_config(struct net_device *dev, struct ifmap *map);
165static int el3_open(struct net_device *dev);
dbf02fae
SH		 166static netdev_tx_t el3_start_xmit(struct sk_buff *skb,
167 struct net_device *dev);
7d12e780 168static irqreturn_t el3_interrupt(int irq, void *dev_id);
1da177e4
LT		 169static void update_stats(struct net_device *dev);
170static struct net_device_stats *el3_get_stats(struct net_device *dev);
171static int el3_rx(struct net_device *dev);
172static int el3_close(struct net_device *dev);
173static void el3_tx_timeout(struct net_device *dev);
e445bb4e 174static void set_rx_mode(struct net_device *dev);
1da177e4 175static void set_multicast_list(struct net_device *dev);
7282d491 176static const struct ethtool_ops netdev_ethtool_ops;
1da177e4 177
cc3b4866 178static void tc589_detach(struct pcmcia_device *p_dev);
1da177e4 179
97161d4b 180static const struct net_device_ops el3_netdev_ops = {
f64e9697
AK		 181 .ndo_open = el3_open,
182 .ndo_stop = el3_close,
97161d4b 183 .ndo_start_xmit = el3_start_xmit,
f64e9697 184 .ndo_tx_timeout = el3_tx_timeout,
97161d4b
SH		 185 .ndo_set_config = el3_config,
186 .ndo_get_stats = el3_get_stats,
187 .ndo_set_multicast_list = set_multicast_list,
188 .ndo_change_mtu = eth_change_mtu,
f64e9697 189 .ndo_set_mac_address = eth_mac_addr,
97161d4b
SH		 190 .ndo_validate_addr = eth_validate_addr,
191};
192
15b99ac1 193static int tc589_probe(struct pcmcia_device *link)
1da177e4
LT		 194{
195 struct el3_private *lp;
1da177e4 196 struct net_device *dev;
1da177e4 197
dd0fab5b 198 dev_dbg(&link->dev, "3c589_attach()\n");
f8cfa618 199
1da177e4
LT		 200 /* Create new ethernet device */
201 dev = alloc_etherdev(sizeof(struct el3_private));
202 if (!dev)
f8cfa618 203 return -ENOMEM;
1da177e4 204 lp = netdev_priv(dev);
1da177e4 205 link->priv = dev;
fba395ee 206 lp->p_dev = link;
1da177e4
LT		 207
208 spin_lock_init(&lp->lock);
90abdc3b
DB		 209 link->resource[0]->end = 16;
210 link->resource[0]->flags |= IO_DATA_PATH_WIDTH_16;
eb14120f 211
1ac71e5a 212 link->config_flags |= CONF_ENABLE_IRQ;
7feabb64 213 link->config_index = 1;
f8cfa618 214
97161d4b 215 dev->netdev_ops = &el3_netdev_ops;
1da177e4 216 dev->watchdog_timeo = TX_TIMEOUT;
97161d4b 217
1da177e4
LT		 218 SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
219
15b99ac1 220 return tc589_config(link);
2262054e 221}
1da177e4 222
fba395ee 223static void tc589_detach(struct pcmcia_device *link)
1da177e4
LT		 224{
225 struct net_device *dev = link->priv;
b4635811 226
dd0fab5b 227 dev_dbg(&link->dev, "3c589_detach\n");
1da177e4 228
c7c2fa07 229 unregister_netdev(dev);
1da177e4 230
e2d40963 231 tc589_release(link);
cc3b4866 232
1da177e4
LT		 233 free_netdev(dev);
234} /* tc589_detach */
235
15b99ac1 236static int tc589_config(struct pcmcia_device *link)
1da177e4 237{
1da177e4 238 struct net_device *dev = link->priv;
b1e247ad 239 __be16 *phys_addr;
dd0fab5b 240 int ret, i, j, multi = 0, fifo;
906da809 241 unsigned int ioaddr;
99101d3d 242 static const char * const ram_split[] = {"5:3", "3:1", "1:1", "3:5"};
dddfbd82
DB		 243 u8 *buf;
244 size_t len;
f64e9697 245
dd0fab5b 246 dev_dbg(&link->dev, "3c589_config\n");
1da177e4 247
b1e247ad 248 phys_addr = (__be16 *)dev->dev_addr;
efd50585
DB		 249 /* Is this a 3c562? */
250 if (link->manf_id != MANFID_3COM)
636b8116 251 dev_info(&link->dev, "hmmm, is this really a 3Com card??\n");
efd50585 252 multi = (link->card_id == PRODID_3COM_3C562);
1da177e4 253
90abdc3b
DB		 254 link->io_lines = 16;
255
1da177e4 256 /* For the 3c562, the base address must be xx00-xx7f */
1da177e4
LT		 257 for (i = j = 0; j < 0x400; j += 0x10) {
258 if (multi && (j & 0x80)) continue;
90abdc3b
DB		 259 link->resource[0]->start = j ^ 0x300;
260 i = pcmcia_request_io(link);
4c89e88b
DB		 261 if (i == 0)
262 break;
1da177e4 263 }
dd0fab5b 264 if (i != 0)
1da177e4 265 goto failed;
dd0fab5b 266
eb14120f 267 ret = pcmcia_request_irq(link, el3_interrupt);
dd0fab5b
DB		 268 if (ret)
269 goto failed;
270
1ac71e5a 271 ret = pcmcia_enable_device(link);
dd0fab5b
DB		 272 if (ret)
273 goto failed;
f64e9697 274
eb14120f 275 dev->irq = link->irq;
9a017a91 276 dev->base_addr = link->resource[0]->start;
1da177e4
LT		 277 ioaddr = dev->base_addr;
278 EL3WINDOW(0);
279
280 /* The 3c589 has an extra EEPROM for configuration info, including
281 the hardware address. The 3c562 puts the address in the CIS. */
dddfbd82
DB		 282 len = pcmcia_get_tuple(link, 0x88, &buf);
283 if (buf && len >= 6) {
284 for (i = 0; i < 3; i++)
285 phys_addr[i] = htons(le16_to_cpu(buf[i*2]));
286 kfree(buf);
1da177e4 287 } else {
dddfbd82 288 kfree(buf); /* 0 < len < 6 */
1da177e4
LT		 289 for (i = 0; i < 3; i++)
290 phys_addr[i] = htons(read_eeprom(ioaddr, i));
b1e247ad 291 if (phys_addr[0] == htons(0x6060)) {
636b8116
JP		 292 dev_err(&link->dev, "IO port conflict at 0x%03lx-0x%03lx\n",
293 dev->base_addr, dev->base_addr+15);
1da177e4
LT		 294 goto failed;
295 }
296 }
297
298 /* The address and resource configuration register aren't loaded from
299 the EEPROM and *must* be set to 0 and IRQ3 for the PCMCIA version. */
300 outw(0x3f00, ioaddr + 8);
301 fifo = inl(ioaddr);
302
303 /* The if_port symbol can be set when the module is loaded */
304 if ((if_port >= 0) && (if_port <= 3))
305 dev->if_port = if_port;
306 else
636b8116 307 dev_err(&link->dev, "invalid if_port requested\n");
f64e9697 308
dd2e5a15 309 SET_NETDEV_DEV(dev, &link->dev);
1da177e4
LT		 310
311 if (register_netdev(dev) != 0) {
636b8116 312 dev_err(&link->dev, "register_netdev() failed\n");
1da177e4
LT		 313 goto failed;
314 }
315
f64e9697
AK		 316 netdev_info(dev, "3Com 3c%s, io %#3lx, irq %d, hw_addr %pM\n",
317 (multi ? "562" : "589"), dev->base_addr, dev->irq,
318 dev->dev_addr);
319 netdev_info(dev, " %dK FIFO split %s Rx:Tx, %s xcvr\n",
320 (fifo & 7) ? 32 : 8, ram_split[(fifo >> 16) & 3],
321 if_names[dev->if_port]);
15b99ac1 322 return 0;
1da177e4 323
1da177e4
LT		 324failed:
325 tc589_release(link);
15b99ac1 326 return -ENODEV;
1da177e4
LT		 327} /* tc589_config */
328
fba395ee 329static void tc589_release(struct pcmcia_device *link)
1da177e4 330{
fba395ee 331 pcmcia_disable_device(link);
1da177e4
LT		 332}
333
fba395ee 334static int tc589_suspend(struct pcmcia_device *link)
98e4c28b 335{
98e4c28b
DB		 336 struct net_device *dev = link->priv;
337
e2d40963 338 if (link->open)
8661bb5b 339 netif_device_detach(dev);
98e4c28b
DB		 340
341 return 0;
342}
343
fba395ee 344static int tc589_resume(struct pcmcia_device *link)
98e4c28b 345{
98e4c28b
DB		 346 struct net_device *dev = link->priv;
347
f64e9697 348 if (link->open) {
8661bb5b
DB		 349 tc589_reset(dev);
350 netif_device_attach(dev);
98e4c28b
DB		 351 }
352
353 return 0;
354}
355
1da177e4
LT		 356/*====================================================================*/
357
358/*
359 Use this for commands that may take time to finish
360*/
361static void tc589_wait_for_completion(struct net_device *dev, int cmd)
362{
363 int i = 100;
364 outw(cmd, dev->base_addr + EL3_CMD);
365 while (--i > 0)
366 if (!(inw(dev->base_addr + EL3_STATUS) & 0x1000)) break;
367 if (i == 0)
f64e9697 368 netdev_warn(dev, "command 0x%04x did not complete!\n", cmd);
1da177e4
LT		 369}
370
371/*
372 Read a word from the EEPROM using the regular EEPROM access register.
373 Assume that we are in register window zero.
374*/
906da809 375static u16 read_eeprom(unsigned int ioaddr, int index)
1da177e4
LT		 376{
377 int i;
378 outw(EEPROM_READ + index, ioaddr + 10);
379 /* Reading the eeprom takes 162 us */
380 for (i = 1620; i >= 0; i--)
381 if ((inw(ioaddr + 10) & EEPROM_BUSY) == 0)
382 break;
383 return inw(ioaddr + 12);
384}
385
386/*
387 Set transceiver type, perhaps to something other than what the user
388 specified in dev->if_port.
389*/
390static void tc589_set_xcvr(struct net_device *dev, int if_port)
391{
392 struct el3_private *lp = netdev_priv(dev);
906da809 393 unsigned int ioaddr = dev->base_addr;
f64e9697 394
1da177e4
LT		 395 EL3WINDOW(0);
396 switch (if_port) {
397 case 0: case 1: outw(0, ioaddr + 6); break;
398 case 2: outw(3<<14, ioaddr + 6); break;
399 case 3: outw(1<<14, ioaddr + 6); break;
400 }
401 /* On PCMCIA, this just turns on the LED */
402 outw((if_port == 2) ? StartCoax : StopCoax, ioaddr + EL3_CMD);
403 /* 10baseT interface, enable link beat and jabber check. */
404 EL3WINDOW(4);
405 outw(MEDIA_LED | ((if_port < 2) ? MEDIA_TP : 0), ioaddr + WN4_MEDIA);
406 EL3WINDOW(1);
407 if (if_port == 2)
408 lp->media_status = ((dev->if_port == 0) ? 0x8000 : 0x4000);
409 else
410 lp->media_status = ((dev->if_port == 0) ? 0x4010 : 0x8800);
411}
412
413static void dump_status(struct net_device *dev)
414{
906da809 415 unsigned int ioaddr = dev->base_addr;
1da177e4 416 EL3WINDOW(1);
f64e9697
AK		 417 netdev_info(dev, " irq status %04x, rx status %04x, tx status %02x tx free %04x\n",
418 inw(ioaddr+EL3_STATUS), inw(ioaddr+RX_STATUS),
419 inb(ioaddr+TX_STATUS), inw(ioaddr+TX_FREE));
1da177e4 420 EL3WINDOW(4);
f64e9697
AK		 421 netdev_info(dev, " diagnostics: fifo %04x net %04x ethernet %04x media %04x\n",
422 inw(ioaddr+0x04), inw(ioaddr+0x06), inw(ioaddr+0x08),
423 inw(ioaddr+0x0a));
1da177e4
LT		 424 EL3WINDOW(1);
425}
426
427/* Reset and restore all of the 3c589 registers. */
428static void tc589_reset(struct net_device *dev)
429{
906da809 430 unsigned int ioaddr = dev->base_addr;
1da177e4 431 int i;
f64e9697 432
1da177e4 433 EL3WINDOW(0);
f64e9697 434 outw(0x0001, ioaddr + 4); /* Activate board. */
1da177e4 435 outw(0x3f00, ioaddr + 8); /* Set the IRQ line. */
f64e9697 436
1da177e4
LT		 437 /* Set the station address in window 2. */
438 EL3WINDOW(2);
439 for (i = 0; i < 6; i++)
440 outb(dev->dev_addr[i], ioaddr + i);
441
442 tc589_set_xcvr(dev, dev->if_port);
f64e9697 443
1da177e4
LT		 444 /* Switch to the stats window, and clear all stats by reading. */
445 outw(StatsDisable, ioaddr + EL3_CMD);
446 EL3WINDOW(6);
447 for (i = 0; i < 9; i++)
448 inb(ioaddr+i);
449 inw(ioaddr + 10);
450 inw(ioaddr + 12);
f64e9697 451
1da177e4
LT		 452 /* Switch to register set 1 for normal use. */
453 EL3WINDOW(1);
454
e445bb4e 455 set_rx_mode(dev);
1da177e4
LT		 456 outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
457 outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
458 outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
459 /* Allow status bits to be seen. */
460 outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
461 /* Ack all pending events, and set active indicator mask. */
462 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
463 ioaddr + EL3_CMD);
464 outw(SetIntrEnb | IntLatch | TxAvailable | RxComplete | StatsFull
465 | AdapterFailure, ioaddr + EL3_CMD);
466}
467
468static void netdev_get_drvinfo(struct net_device *dev,
469 struct ethtool_drvinfo *info)
470{
471 strcpy(info->driver, DRV_NAME);
472 strcpy(info->version, DRV_VERSION);
473 sprintf(info->bus_info, "PCMCIA 0x%lx", dev->base_addr);
474}
475
7282d491 476static const struct ethtool_ops netdev_ethtool_ops = {
1da177e4 477 .get_drvinfo = netdev_get_drvinfo,
1da177e4
LT		 478};
479
480static int el3_config(struct net_device *dev, struct ifmap *map)
481{
482 if ((map->port != (u_char)(-1)) && (map->port != dev->if_port)) {
483 if (map->port <= 3) {
484 dev->if_port = map->port;
f64e9697 485 netdev_info(dev, "switched to %s port\n", if_names[dev->if_port]);
1da177e4
LT		 486 tc589_set_xcvr(dev, dev->if_port);
487 } else
488 return -EINVAL;
489 }
490 return 0;
491}
492
493static int el3_open(struct net_device *dev)
494{
495 struct el3_private *lp = netdev_priv(dev);
fba395ee 496 struct pcmcia_device *link = lp->p_dev;
f64e9697 497
9940ec36 498 if (!pcmcia_dev_present(link))
1da177e4
LT		 499 return -ENODEV;
500
501 link->open++;
502 netif_start_queue(dev);
f64e9697 503
1da177e4
LT		 504 tc589_reset(dev);
505 init_timer(&lp->media);
c061b18d 506 lp->media.function = media_check;
1da177e4
LT		 507 lp->media.data = (unsigned long) dev;
508 lp->media.expires = jiffies + HZ;
509 add_timer(&lp->media);
510
dd0fab5b 511 dev_dbg(&link->dev, "%s: opened, status %4.4x.\n",
1da177e4 512 dev->name, inw(dev->base_addr + EL3_STATUS));
f64e9697 513
1da177e4
LT		 514 return 0;
515}
516
517static void el3_tx_timeout(struct net_device *dev)
518{
906da809 519 unsigned int ioaddr = dev->base_addr;
f64e9697
AK		 520
521 netdev_warn(dev, "Transmit timed out!\n");
1da177e4 522 dump_status(dev);
cd65284f 523 dev->stats.tx_errors++;
1ae5dc34 524 dev->trans_start = jiffies; /* prevent tx timeout */
1da177e4
LT		 525 /* Issue TX_RESET and TX_START commands. */
526 tc589_wait_for_completion(dev, TxReset);
527 outw(TxEnable, ioaddr + EL3_CMD);
528 netif_wake_queue(dev);
529}
530
531static void pop_tx_status(struct net_device *dev)
532{
906da809 533 unsigned int ioaddr = dev->base_addr;
1da177e4 534 int i;
f64e9697 535
1da177e4
LT		 536 /* Clear the Tx status stack. */
537 for (i = 32; i > 0; i--) {
538 u_char tx_status = inb(ioaddr + TX_STATUS);
539 if (!(tx_status & 0x84)) break;
540 /* reset transmitter on jabber error or underrun */
541 if (tx_status & 0x30)
f64e9697 542 tc589_wait_for_completion(dev, TxReset);
1da177e4 543 if (tx_status & 0x38) {
f64e9697
AK		 544 netdev_dbg(dev, "transmit error: status 0x%02x\n", tx_status);
545 outw(TxEnable, ioaddr + EL3_CMD);
546 dev->stats.tx_aborted_errors++;
1da177e4
LT		 547 }
548 outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
549 }
550}
551
dbf02fae
SH		 552static netdev_tx_t el3_start_xmit(struct sk_buff *skb,
553 struct net_device *dev)
1da177e4 554{
906da809 555 unsigned int ioaddr = dev->base_addr;
1da177e4 556 struct el3_private *priv = netdev_priv(dev);
d08d2839 557 unsigned long flags;
1da177e4 558
f64e9697
AK		 559 netdev_dbg(dev, "el3_start_xmit(length = %ld) called, status %4.4x.\n",
560 (long)skb->len, inw(ioaddr + EL3_STATUS));
1da177e4 561
f64e9697 562 spin_lock_irqsave(&priv->lock, flags);
d08d2839 563
cd65284f 564 dev->stats.tx_bytes += skb->len;
1da177e4
LT		 565
566 /* Put out the doubleword header... */
567 outw(skb->len, ioaddr + TX_FIFO);
568 outw(0x00, ioaddr + TX_FIFO);
569 /* ... and the packet rounded to a doubleword. */
570 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
571
1da177e4
LT		 572 if (inw(ioaddr + TX_FREE) <= 1536) {
573 netif_stop_queue(dev);
574 /* Interrupt us when the FIFO has room for max-sized packet. */
575 outw(SetTxThreshold + 1536, ioaddr + EL3_CMD);
576 }
577
1da177e4 578 pop_tx_status(dev);
f64e9697 579 spin_unlock_irqrestore(&priv->lock, flags);
63ac9b91 580 dev_kfree_skb(skb);
f64e9697 581
6ed10654 582 return NETDEV_TX_OK;
1da177e4
LT		 583}
584
585/* The EL3 interrupt handler. */
7d12e780 586static irqreturn_t el3_interrupt(int irq, void *dev_id)
1da177e4
LT		 587{
588 struct net_device *dev = (struct net_device *) dev_id;
589 struct el3_private *lp = netdev_priv(dev);
906da809 590 unsigned int ioaddr;
1da177e4
LT		 591 __u16 status;
592 int i = 0, handled = 1;
f64e9697 593
1da177e4
LT		 594 if (!netif_device_present(dev))
595 return IRQ_NONE;
596
597 ioaddr = dev->base_addr;
598
f64e9697 599 netdev_dbg(dev, "interrupt, status %4.4x.\n", inw(ioaddr + EL3_STATUS));
1da177e4 600
f64e9697 601 spin_lock(&lp->lock);
1da177e4
LT		 602 while ((status = inw(ioaddr + EL3_STATUS)) &
603 (IntLatch | RxComplete | StatsFull)) {
604 if ((status & 0xe000) != 0x2000) {
f64e9697
AK		 605 netdev_dbg(dev, "interrupt from dead card\n");
606 handled = 0;
607 break;
1da177e4 608 }
1da177e4 609 if (status & RxComplete)
f64e9697 610 el3_rx(dev);
1da177e4 611 if (status & TxAvailable) {
f64e9697
AK		 612 netdev_dbg(dev, " TX room bit was handled.\n");
613 /* There's room in the FIFO for a full-sized packet. */
614 outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
615 netif_wake_queue(dev);
1da177e4 616 }
1da177e4 617 if (status & TxComplete)
f64e9697 618 pop_tx_status(dev);
1da177e4
LT		 619 if (status & (AdapterFailure | RxEarly | StatsFull)) {
620 /* Handle all uncommon interrupts. */
621 if (status & StatsFull) /* Empty statistics. */
622 update_stats(dev);
623 if (status & RxEarly) { /* Rx early is unused. */
624 el3_rx(dev);
625 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
626 }
627 if (status & AdapterFailure) {
628 u16 fifo_diag;
629 EL3WINDOW(4);
630 fifo_diag = inw(ioaddr + 4);
631 EL3WINDOW(1);
f64e9697
AK		 632 netdev_warn(dev, "adapter failure, FIFO diagnostic register %04x.\n",
633 fifo_diag);
1da177e4
LT		 634 if (fifo_diag & 0x0400) {
635 /* Tx overrun */
636 tc589_wait_for_completion(dev, TxReset);
637 outw(TxEnable, ioaddr + EL3_CMD);
638 }
639 if (fifo_diag & 0x2000) {
640 /* Rx underrun */
641 tc589_wait_for_completion(dev, RxReset);
e445bb4e 642 set_rx_mode(dev);
1da177e4
LT		 643 outw(RxEnable, ioaddr + EL3_CMD);
644 }
645 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
646 }
647 }
1da177e4 648 if (++i > 10) {
f64e9697
AK		 649 netdev_err(dev, "infinite loop in interrupt, status %4.4x.\n",
650 status);
651 /* Clear all interrupts */
652 outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
653 break;
1da177e4
LT		 654 }
655 /* Acknowledge the IRQ. */
656 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
657 }
1da177e4 658 lp->last_irq = jiffies;
f64e9697
AK		 659 spin_unlock(&lp->lock);
660 netdev_dbg(dev, "exiting interrupt, status %4.4x.\n",
661 inw(ioaddr + EL3_STATUS));
1da177e4
LT		 662 return IRQ_RETVAL(handled);
663}
664
665static void media_check(unsigned long arg)
666{
667 struct net_device *dev = (struct net_device *)(arg);
668 struct el3_private *lp = netdev_priv(dev);
906da809 669 unsigned int ioaddr = dev->base_addr;
1da177e4
LT		 670 u16 media, errs;
671 unsigned long flags;
672
673 if (!netif_device_present(dev)) goto reschedule;
674
1da177e4
LT		 675 /* Check for pending interrupt with expired latency timer: with
676 this, we can limp along even if the interrupt is blocked */
677 if ((inw(ioaddr + EL3_STATUS) & IntLatch) &&
678 (inb(ioaddr + EL3_TIMER) == 0xff)) {
679 if (!lp->fast_poll)
f64e9697 680 netdev_warn(dev, "interrupt(s) dropped!\n");
671c8806
KK		 681
682 local_irq_save(flags);
d08d2839 683 el3_interrupt(dev->irq, dev);
671c8806
KK		 684 local_irq_restore(flags);
685
1da177e4
LT		 686 lp->fast_poll = HZ;
687 }
688 if (lp->fast_poll) {
689 lp->fast_poll--;
690 lp->media.expires = jiffies + HZ/100;
691 add_timer(&lp->media);
692 return;
693 }
694
695 /* lp->lock guards the EL3 window. Window should always be 1 except
696 when the lock is held */
f64e9697 697 spin_lock_irqsave(&lp->lock, flags);
1da177e4
LT		 698 EL3WINDOW(4);
699 media = inw(ioaddr+WN4_MEDIA) & 0xc810;
700
701 /* Ignore collisions unless we've had no irq's recently */
ff5688ae 702 if (time_before(jiffies, lp->last_irq + HZ)) {
1da177e4
LT		 703 media &= ~0x0010;
704 } else {
705 /* Try harder to detect carrier errors */
706 EL3WINDOW(6);
707 outw(StatsDisable, ioaddr + EL3_CMD);
708 errs = inb(ioaddr + 0);
709 outw(StatsEnable, ioaddr + EL3_CMD);
cd65284f 710 dev->stats.tx_carrier_errors += errs;
1da177e4
LT		 711 if (errs || (lp->media_status & 0x0010)) media |= 0x0010;
712 }
713
714 if (media != lp->media_status) {
715 if ((media & lp->media_status & 0x8000) &&
716 ((lp->media_status ^ media) & 0x0800))
f64e9697
AK		 717 netdev_info(dev, "%s link beat\n",
718 (lp->media_status & 0x0800 ? "lost" : "found"));
1da177e4
LT		 719 else if ((media & lp->media_status & 0x4000) &&
720 ((lp->media_status ^ media) & 0x0010))
f64e9697
AK		 721 netdev_info(dev, "coax cable %s\n",
722 (lp->media_status & 0x0010 ? "ok" : "problem"));
1da177e4
LT		 723 if (dev->if_port == 0) {
724 if (media & 0x8000) {
725 if (media & 0x0800)
f64e9697 726 netdev_info(dev, "flipped to 10baseT\n");
1da177e4 727 else
f64e9697 728 tc589_set_xcvr(dev, 2);
1da177e4
LT		 729 } else if (media & 0x4000) {
730 if (media & 0x0010)
731 tc589_set_xcvr(dev, 1);
732 else
f64e9697 733 netdev_info(dev, "flipped to 10base2\n");
1da177e4
LT		 734 }
735 }
736 lp->media_status = media;
737 }
f64e9697 738
1da177e4 739 EL3WINDOW(1);
f64e9697 740 spin_unlock_irqrestore(&lp->lock, flags);
1da177e4
LT		 741
742reschedule:
743 lp->media.expires = jiffies + HZ;
744 add_timer(&lp->media);
745}
746
747static struct net_device_stats *el3_get_stats(struct net_device *dev)
748{
749 struct el3_private *lp = netdev_priv(dev);
750 unsigned long flags;
fba395ee 751 struct pcmcia_device *link = lp->p_dev;
1da177e4 752
9940ec36 753 if (pcmcia_dev_present(link)) {
f64e9697 754 spin_lock_irqsave(&lp->lock, flags);
1da177e4
LT		 755 update_stats(dev);
756 spin_unlock_irqrestore(&lp->lock, flags);
757 }
cd65284f 758 return &dev->stats;
1da177e4
LT		 759}
760
761/*
762 Update statistics. We change to register window 6, so this should be run
763 single-threaded if the device is active. This is expected to be a rare
764 operation, and it's simpler for the rest of the driver to assume that
765 window 1 is always valid rather than use a special window-state variable.
f64e9697 766
1da177e4
LT		 767 Caller must hold the lock for this
768*/
769static void update_stats(struct net_device *dev)
770{
906da809 771 unsigned int ioaddr = dev->base_addr;
1da177e4 772
f64e9697 773 netdev_dbg(dev, "updating the statistics.\n");
1da177e4
LT		 774 /* Turn off statistics updates while reading. */
775 outw(StatsDisable, ioaddr + EL3_CMD);
776 /* Switch to the stats window, and read everything. */
777 EL3WINDOW(6);
f64e9697 778 dev->stats.tx_carrier_errors += inb(ioaddr + 0);
cd65284f 779 dev->stats.tx_heartbeat_errors += inb(ioaddr + 1);
f64e9697 780 /* Multiple collisions. */ inb(ioaddr + 2);
cd65284f
PZ		 781 dev->stats.collisions += inb(ioaddr + 3);
782 dev->stats.tx_window_errors += inb(ioaddr + 4);
783 dev->stats.rx_fifo_errors += inb(ioaddr + 5);
784 dev->stats.tx_packets += inb(ioaddr + 6);
1da177e4
LT		 785 /* Rx packets */ inb(ioaddr + 7);
786 /* Tx deferrals */ inb(ioaddr + 8);
787 /* Rx octets */ inw(ioaddr + 10);
788 /* Tx octets */ inw(ioaddr + 12);
f64e9697 789
1da177e4
LT		 790 /* Back to window 1, and turn statistics back on. */
791 EL3WINDOW(1);
792 outw(StatsEnable, ioaddr + EL3_CMD);
793}
794
795static int el3_rx(struct net_device *dev)
796{
906da809 797 unsigned int ioaddr = dev->base_addr;
1da177e4
LT		 798 int worklimit = 32;
799 short rx_status;
f64e9697
AK		 800
801 netdev_dbg(dev, "in rx_packet(), status %4.4x, rx_status %4.4x.\n",
802 inw(ioaddr+EL3_STATUS), inw(ioaddr+RX_STATUS));
1da177e4 803 while (!((rx_status = inw(ioaddr + RX_STATUS)) & 0x8000) &&
b9bdcd9b
RK		 804 worklimit > 0) {
805 worklimit--;
1da177e4
LT		 806 if (rx_status & 0x4000) { /* Error, update stats. */
807 short error = rx_status & 0x3800;
cd65284f 808 dev->stats.rx_errors++;
1da177e4 809 switch (error) {
cd65284f
PZ		 810 case 0x0000: dev->stats.rx_over_errors++; break;
811 case 0x0800: dev->stats.rx_length_errors++; break;
812 case 0x1000: dev->stats.rx_frame_errors++; break;
813 case 0x1800: dev->stats.rx_length_errors++; break;
814 case 0x2000: dev->stats.rx_frame_errors++; break;
815 case 0x2800: dev->stats.rx_crc_errors++; break;
1da177e4
LT		 816 }
817 } else {
818 short pkt_len = rx_status & 0x7ff;
819 struct sk_buff *skb;
f64e9697 820
1da177e4 821 skb = dev_alloc_skb(pkt_len+5);
f64e9697
AK		 822
823 netdev_dbg(dev, " Receiving packet size %d status %4.4x.\n",
824 pkt_len, rx_status);
1da177e4 825 if (skb != NULL) {
1da177e4
LT		 826 skb_reserve(skb, 2);
827 insl(ioaddr+RX_FIFO, skb_put(skb, pkt_len),
828 (pkt_len+3)>>2);
829 skb->protocol = eth_type_trans(skb, dev);
830 netif_rx(skb);
cd65284f
PZ		 831 dev->stats.rx_packets++;
832 dev->stats.rx_bytes += pkt_len;
1da177e4 833 } else {
f64e9697
AK		 834 netdev_dbg(dev, "couldn't allocate a sk_buff of size %d.\n",
835 pkt_len);
cd65284f 836 dev->stats.rx_dropped++;
1da177e4
LT		 837 }
838 }
839 /* Pop the top of the Rx FIFO */
840 tc589_wait_for_completion(dev, RxDiscard);
841 }
842 if (worklimit == 0)
f64e9697 843 netdev_warn(dev, "too much work in el3_rx!\n");
1da177e4
LT		 844 return 0;
845}
846
e445bb4e 847static void set_rx_mode(struct net_device *dev)
1da177e4 848{
906da809 849 unsigned int ioaddr = dev->base_addr;
1da177e4
LT		 850 u16 opts = SetRxFilter | RxStation | RxBroadcast;
851
1da177e4
LT		 852 if (dev->flags & IFF_PROMISC)
853 opts |= RxMulticast | RxProm;
4cd24eaf 854 else if (!netdev_mc_empty(dev) || (dev->flags & IFF_ALLMULTI))
1da177e4
LT		 855 opts |= RxMulticast;
856 outw(opts, ioaddr + EL3_CMD);
857}
858
e445bb4e
KK		 859static void set_multicast_list(struct net_device *dev)
860{
861 struct el3_private *priv = netdev_priv(dev);
862 unsigned long flags;
863
864 spin_lock_irqsave(&priv->lock, flags);
865 set_rx_mode(dev);
866 spin_unlock_irqrestore(&priv->lock, flags);
867}
868
1da177e4
LT		 869static int el3_close(struct net_device *dev)
870{
871 struct el3_private *lp = netdev_priv(dev);
fba395ee 872 struct pcmcia_device *link = lp->p_dev;
906da809 873 unsigned int ioaddr = dev->base_addr;
f64e9697 874
dd0fab5b 875 dev_dbg(&link->dev, "%s: shutting down ethercard.\n", dev->name);
1da177e4 876
9940ec36 877 if (pcmcia_dev_present(link)) {
cd65284f 878 /* Turn off statistics ASAP. We update dev->stats below. */
1da177e4 879 outw(StatsDisable, ioaddr + EL3_CMD);
f64e9697 880
1da177e4
LT		 881 /* Disable the receiver and transmitter. */
882 outw(RxDisable, ioaddr + EL3_CMD);
883 outw(TxDisable, ioaddr + EL3_CMD);
f64e9697 884
1da177e4
LT		 885 if (dev->if_port == 2)
886 /* Turn off thinnet power. Green! */
887 outw(StopCoax, ioaddr + EL3_CMD);
888 else if (dev->if_port == 1) {
889 /* Disable link beat and jabber */
890 EL3WINDOW(4);
891 outw(0, ioaddr + WN4_MEDIA);
892 }
f64e9697 893
1da177e4
LT		 894 /* Switching back to window 0 disables the IRQ. */
895 EL3WINDOW(0);
896 /* But we explicitly zero the IRQ line select anyway. */
897 outw(0x0f00, ioaddr + WN0_IRQ);
f64e9697 898
1da177e4
LT		 899 /* Check if the card still exists */
900 if ((inw(ioaddr+EL3_STATUS) & 0xe000) == 0x2000)
901 update_stats(dev);
902 }
903
904 link->open--;
905 netif_stop_queue(dev);
906 del_timer_sync(&lp->media);
f64e9697 907
1da177e4
LT		 908 return 0;
909}
910
25f8f54f 911static const struct pcmcia_device_id tc589_ids[] = {
7ffec58c
DB		 912 PCMCIA_MFC_DEVICE_MANF_CARD(0, 0x0101, 0x0562),
913 PCMCIA_MFC_DEVICE_PROD_ID1(0, "Motorola MARQUIS", 0xf03e4e77),
914 PCMCIA_DEVICE_MANF_CARD(0x0101, 0x0589),
915 PCMCIA_DEVICE_PROD_ID12("Farallon", "ENet", 0x58d93fc4, 0x992c2202),
f0a3a153
KK		 916 PCMCIA_MFC_DEVICE_CIS_MANF_CARD(0, 0x0101, 0x0035, "cis/3CXEM556.cis"),
917 PCMCIA_MFC_DEVICE_CIS_MANF_CARD(0, 0x0101, 0x003d, "cis/3CXEM556.cis"),
7ffec58c
DB		 918 PCMCIA_DEVICE_NULL,
919};
920MODULE_DEVICE_TABLE(pcmcia, tc589_ids);
921
1da177e4
LT		 922static struct pcmcia_driver tc589_driver = {
923 .owner = THIS_MODULE,
2e9b981a 924 .name = "3c589_cs",
15b99ac1 925 .probe = tc589_probe,
cc3b4866 926 .remove = tc589_detach,
f64e9697 927 .id_table = tc589_ids,
98e4c28b
DB		 928 .suspend = tc589_suspend,
929 .resume = tc589_resume,
1da177e4
LT		 930};
931
932static int __init init_tc589(void)
933{
934 return pcmcia_register_driver(&tc589_driver);
935}
936
937static void __exit exit_tc589(void)
938{
939 pcmcia_unregister_driver(&tc589_driver);
1da177e4
LT		 940}
941
942module_init(init_tc589);
943module_exit(exit_tc589);
Linux kernel - Deliverables
This page took 0.806381 seconds and 5 git commands to generate.