?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[TG3]: Speed up SRAM access
[linux-2.6.git] / drivers / net / pcmcia / 3c589_cs.c
blob3dba50849da748a0631f12288a7e78e800c98da0
1 /*======================================================================
2
3 A PCMCIA ethernet driver for the 3com 3c589 card.
4
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:
10
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
17
18 Updated for 2.5.x by Alan Cox <alan@redhat.com>
19
20 ======================================================================*/
21
22 #define DRV_NAME "3c589_cs"
23 #define DRV_VERSION "1.162-ac"
24
25 #include <linux/module.h>
26 #include <linux/init.h>
27 #include <linux/kernel.h>
28 #include <linux/ptrace.h>
29 #include <linux/slab.h>
30 #include <linux/string.h>
31 #include <linux/timer.h>
32 #include <linux/interrupt.h>
33 #include <linux/in.h>
34 #include <linux/delay.h>
35 #include <linux/ethtool.h>
36 #include <linux/netdevice.h>
37 #include <linux/etherdevice.h>
38 #include <linux/skbuff.h>
39 #include <linux/if_arp.h>
40 #include <linux/ioport.h>
41 #include <linux/bitops.h>
42 #include <linux/jiffies.h>
43
44 #include <pcmcia/cs_types.h>
45 #include <pcmcia/cs.h>
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. */
71 enum c509cmd {
72 TotalReset = 0<<11, SelectWindow = 1<<11, StartCoax = 2<<11,
73 RxDisable = 3<<11, RxEnable = 4<<11, RxReset = 5<<11, RxDiscard = 8<<11,
74 TxEnable = 9<<11, TxDisable = 10<<11, TxReset = 11<<11,
75 FakeIntr = 12<<11, AckIntr = 13<<11, SetIntrEnb = 14<<11,
76 SetStatusEnb = 15<<11, SetRxFilter = 16<<11, SetRxThreshold = 17<<11,
77 SetTxThreshold = 18<<11, SetTxStart = 19<<11, StatsEnable = 21<<11,
78 StatsDisable = 22<<11, StopCoax = 23<<11,
79 };
80
81 enum c509status {
82 IntLatch = 0x0001, AdapterFailure = 0x0002, TxComplete = 0x0004,
83 TxAvailable = 0x0008, RxComplete = 0x0010, RxEarly = 0x0020,
84 IntReq = 0x0040, StatsFull = 0x0080, CmdBusy = 0x1000
85 };
86
87 /* The SetRxFilter command accepts the following classes: */
88 enum RxFilter {
89 RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8
90 };
91
92 /* Register window 1 offsets, the window used in normal operation. */
93 #define TX_FIFO 0x00
94 #define RX_FIFO 0x00
95 #define RX_STATUS 0x08
96 #define TX_STATUS 0x0B
97 #define TX_FREE 0x0C /* Remaining free bytes in Tx buffer. */
98
99 #define WN0_IRQ 0x08 /* Window 0: Set IRQ line in bits 12-15. */
100 #define WN4_MEDIA 0x0A /* Window 4: Various transcvr/media bits. */
101 #define MEDIA_TP 0x00C0 /* Enable link beat and jabber for 10baseT. */
102 #define MEDIA_LED 0x0001 /* Enable link light on 3C589E cards. */
103
104 /* Time in jiffies before concluding Tx hung */
105 #define TX_TIMEOUT ((400*HZ)/1000)
106
107 struct el3_private {
108 dev_link_t link;
109 dev_node_t node;
110 struct net_device_stats stats;
111 /* For transceiver monitoring */
112 struct timer_list media;
113 u16 media_status;
114 u16 fast_poll;
115 unsigned long last_irq;
116 spinlock_t lock;
117 };
118
119 static const char *if_names[] = { "auto", "10baseT", "10base2", "AUI" };
120
121 /*====================================================================*/
122
123 /* Module parameters */
124
125 MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
126 MODULE_DESCRIPTION("3Com 3c589 series PCMCIA ethernet driver");
127 MODULE_LICENSE("GPL");
128
129 #define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0)
130
131 /* Special hook for setting if_port when module is loaded */
132 INT_MODULE_PARM(if_port, 0);
133
134 #ifdef PCMCIA_DEBUG
135 INT_MODULE_PARM(pc_debug, PCMCIA_DEBUG);
136 #define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
137 static char *version =
138 DRV_NAME ".c " DRV_VERSION " 2001/10/13 00:08:50 (David Hinds)";
139 #else
140 #define DEBUG(n, args...)
141 #endif
142
143 /*====================================================================*/
144
145 static void tc589_config(dev_link_t *link);
146 static void tc589_release(dev_link_t *link);
147
148 static u16 read_eeprom(kio_addr_t ioaddr, int index);
149 static void tc589_reset(struct net_device *dev);
150 static void media_check(unsigned long arg);
151 static int el3_config(struct net_device *dev, struct ifmap *map);
152 static int el3_open(struct net_device *dev);
153 static int el3_start_xmit(struct sk_buff *skb, struct net_device *dev);
154 static irqreturn_t el3_interrupt(int irq, void *dev_id, struct pt_regs *regs);
155 static void update_stats(struct net_device *dev);
156 static struct net_device_stats *el3_get_stats(struct net_device *dev);
157 static int el3_rx(struct net_device *dev);
158 static int el3_close(struct net_device *dev);
159 static void el3_tx_timeout(struct net_device *dev);
160 static void set_multicast_list(struct net_device *dev);
161 static struct ethtool_ops netdev_ethtool_ops;
162
163 static void tc589_detach(struct pcmcia_device *p_dev);
164
165 /*======================================================================
166
167 tc589_attach() creates an "instance" of the driver, allocating
168 local data structures for one device. The device is registered
169 with Card Services.
170
171 ======================================================================*/
172
173 static int tc589_attach(struct pcmcia_device *p_dev)
174 {
175 struct el3_private *lp;
176 dev_link_t *link;
177 struct net_device *dev;
178
179 DEBUG(0, "3c589_attach()\n");
180
181 /* Create new ethernet device */
182 dev = alloc_etherdev(sizeof(struct el3_private));
183 if (!dev)
184 return -ENOMEM;
185 lp = netdev_priv(dev);
186 link = &lp->link;
187 link->priv = dev;
188
189 spin_lock_init(&lp->lock);
190 link->io.NumPorts1 = 16;
191 link->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
192 link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
193 link->irq.IRQInfo1 = IRQ_LEVEL_ID;
194 link->irq.Handler = &el3_interrupt;
195 link->irq.Instance = dev;
196 link->conf.Attributes = CONF_ENABLE_IRQ;
197 link->conf.Vcc = 50;
198 link->conf.IntType = INT_MEMORY_AND_IO;
199 link->conf.ConfigIndex = 1;
200 link->conf.Present = PRESENT_OPTION;
201
202 /* The EL3-specific entries in the device structure. */
203 SET_MODULE_OWNER(dev);
204 dev->hard_start_xmit = &el3_start_xmit;
205 dev->set_config = &el3_config;
206 dev->get_stats = &el3_get_stats;
207 dev->set_multicast_list = &set_multicast_list;
208 dev->open = &el3_open;
209 dev->stop = &el3_close;
210 #ifdef HAVE_TX_TIMEOUT
211 dev->tx_timeout = el3_tx_timeout;
212 dev->watchdog_timeo = TX_TIMEOUT;
213 #endif
214 SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
215
216 link->handle = p_dev;
217 p_dev->instance = link;
218
219 link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
220 tc589_config(link);
221
222 return 0;
223 } /* tc589_attach */
224
225 /*======================================================================
226
227 This deletes a driver "instance". The device is de-registered
228 with Card Services. If it has been released, all local data
229 structures are freed. Otherwise, the structures will be freed
230 when the device is released.
231
232 ======================================================================*/
233
234 static void tc589_detach(struct pcmcia_device *p_dev)
235 {
236 dev_link_t *link = dev_to_instance(p_dev);
237 struct net_device *dev = link->priv;
238
239 DEBUG(0, "3c589_detach(0x%p)\n", link);
240
241 if (link->dev)
242 unregister_netdev(dev);
243
244 if (link->state & DEV_CONFIG)
245 tc589_release(link);
246
247 free_netdev(dev);
248 } /* tc589_detach */
249
250 /*======================================================================
251
252 tc589_config() is scheduled to run after a CARD_INSERTION event
253 is received, to configure the PCMCIA socket, and to make the
254 ethernet device available to the system.
255
256 ======================================================================*/
257
258 #define CS_CHECK(fn, ret) \
259 do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
260
261 static void tc589_config(dev_link_t *link)
262 {
263 client_handle_t handle = link->handle;
264 struct net_device *dev = link->priv;
265 struct el3_private *lp = netdev_priv(dev);
266 tuple_t tuple;
267 cisparse_t parse;
268 u16 buf[32], *phys_addr;
269 int last_fn, last_ret, i, j, multi = 0, fifo;
270 kio_addr_t ioaddr;
271 char *ram_split[] = {"5:3", "3:1", "1:1", "3:5"};
272
273 DEBUG(0, "3c589_config(0x%p)\n", link);
274
275 phys_addr = (u16 *)dev->dev_addr;
276 tuple.Attributes = 0;
277 tuple.DesiredTuple = CISTPL_CONFIG;
278 CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
279 tuple.TupleData = (cisdata_t *)buf;
280 tuple.TupleDataMax = sizeof(buf);
281 tuple.TupleOffset = 0;
282 CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple));
283 CS_CHECK(ParseTuple, pcmcia_parse_tuple(handle, &tuple, &parse));
284 link->conf.ConfigBase = parse.config.base;
285 link->conf.Present = parse.config.rmask[0];
286
287 /* Is this a 3c562? */
288 tuple.DesiredTuple = CISTPL_MANFID;
289 tuple.Attributes = TUPLE_RETURN_COMMON;
290 if ((pcmcia_get_first_tuple(handle, &tuple) == CS_SUCCESS) &&
291 (pcmcia_get_tuple_data(handle, &tuple) == CS_SUCCESS)) {
292 if (le16_to_cpu(buf[0]) != MANFID_3COM)
293 printk(KERN_INFO "3c589_cs: hmmm, is this really a "
294 "3Com card??\n");
295 multi = (le16_to_cpu(buf[1]) == PRODID_3COM_3C562);
296 }
297
298 /* Configure card */
299 link->state |= DEV_CONFIG;
300
301 /* For the 3c562, the base address must be xx00-xx7f */
302 link->io.IOAddrLines = 16;
303 for (i = j = 0; j < 0x400; j += 0x10) {
304 if (multi && (j & 0x80)) continue;
305 link->io.BasePort1 = j ^ 0x300;
306 i = pcmcia_request_io(link->handle, &link->io);
307 if (i == CS_SUCCESS) break;
308 }
309 if (i != CS_SUCCESS) {
310 cs_error(link->handle, RequestIO, i);
311 goto failed;
312 }
313 CS_CHECK(RequestIRQ, pcmcia_request_irq(link->handle, &link->irq));
314 CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link->handle, &link->conf));
315
316 dev->irq = link->irq.AssignedIRQ;
317 dev->base_addr = link->io.BasePort1;
318 ioaddr = dev->base_addr;
319 EL3WINDOW(0);
320
321 /* The 3c589 has an extra EEPROM for configuration info, including
322 the hardware address. The 3c562 puts the address in the CIS. */
323 tuple.DesiredTuple = 0x88;
324 if (pcmcia_get_first_tuple(handle, &tuple) == CS_SUCCESS) {
325 pcmcia_get_tuple_data(handle, &tuple);
326 for (i = 0; i < 3; i++)
327 phys_addr[i] = htons(buf[i]);
328 } else {
329 for (i = 0; i < 3; i++)
330 phys_addr[i] = htons(read_eeprom(ioaddr, i));
331 if (phys_addr[0] == 0x6060) {
332 printk(KERN_ERR "3c589_cs: IO port conflict at 0x%03lx"
333 "-0x%03lx\n", dev->base_addr, dev->base_addr+15);
334 goto failed;
335 }
336 }
337
338 /* The address and resource configuration register aren't loaded from
339 the EEPROM and *must* be set to 0 and IRQ3 for the PCMCIA version. */
340 outw(0x3f00, ioaddr + 8);
341 fifo = inl(ioaddr);
342
343 /* The if_port symbol can be set when the module is loaded */
344 if ((if_port >= 0) && (if_port <= 3))
345 dev->if_port = if_port;
346 else
347 printk(KERN_ERR "3c589_cs: invalid if_port requested\n");
348
349 link->dev = &lp->node;
350 link->state &= ~DEV_CONFIG_PENDING;
351 SET_NETDEV_DEV(dev, &handle_to_dev(handle));
352
353 if (register_netdev(dev) != 0) {
354 printk(KERN_ERR "3c589_cs: register_netdev() failed\n");
355 link->dev = NULL;
356 goto failed;
357 }
358
359 strcpy(lp->node.dev_name, dev->name);
360
361 printk(KERN_INFO "%s: 3Com 3c%s, io %#3lx, irq %d, hw_addr ",
362 dev->name, (multi ? "562" : "589"), dev->base_addr,
363 dev->irq);
364 for (i = 0; i < 6; i++)
365 printk("%02X%s", dev->dev_addr[i], ((i<5) ? ":" : "\n"));
366 printk(KERN_INFO " %dK FIFO split %s Rx:Tx, %s xcvr\n",
367 (fifo & 7) ? 32 : 8, ram_split[(fifo >> 16) & 3],
368 if_names[dev->if_port]);
369 return;
370
371 cs_failed:
372 cs_error(link->handle, last_fn, last_ret);
373 failed:
374 tc589_release(link);
375 return;
376
377 } /* tc589_config */
378
379 /*======================================================================
380
381 After a card is removed, tc589_release() will unregister the net
382 device, and release the PCMCIA configuration. If the device is
383 still open, this will be postponed until it is closed.
384
385 ======================================================================*/
386
387 static void tc589_release(dev_link_t *link)
388 {
389 DEBUG(0, "3c589_release(0x%p)\n", link);
390
391 pcmcia_release_configuration(link->handle);
392 pcmcia_release_io(link->handle, &link->io);
393 pcmcia_release_irq(link->handle, &link->irq);
394
395 link->state &= ~DEV_CONFIG;
396 }
397
398 static int tc589_suspend(struct pcmcia_device *p_dev)
399 {
400 dev_link_t *link = dev_to_instance(p_dev);
401 struct net_device *dev = link->priv;
402
403 link->state |= DEV_SUSPEND;
404 if (link->state & DEV_CONFIG) {
405 if (link->open)
406 netif_device_detach(dev);
407 pcmcia_release_configuration(link->handle);
408 }
409
410 return 0;
411 }
412
413 static int tc589_resume(struct pcmcia_device *p_dev)
414 {
415 dev_link_t *link = dev_to_instance(p_dev);
416 struct net_device *dev = link->priv;
417
418 link->state &= ~DEV_SUSPEND;
419 if (link->state & DEV_CONFIG) {
420 pcmcia_request_configuration(link->handle, &link->conf);
421 if (link->open) {
422 tc589_reset(dev);
423 netif_device_attach(dev);
424 }
425 }
426
427 return 0;
428 }
429
430 /*====================================================================*/
431
432 /*
433 Use this for commands that may take time to finish
434 */
435 static void tc589_wait_for_completion(struct net_device *dev, int cmd)
436 {
437 int i = 100;
438 outw(cmd, dev->base_addr + EL3_CMD);
439 while (--i > 0)
440 if (!(inw(dev->base_addr + EL3_STATUS) & 0x1000)) break;
441 if (i == 0)
442 printk(KERN_WARNING "%s: command 0x%04x did not complete!\n",
443 dev->name, cmd);
444 }
445
446 /*
447 Read a word from the EEPROM using the regular EEPROM access register.
448 Assume that we are in register window zero.
449 */
450 static u16 read_eeprom(kio_addr_t ioaddr, int index)
451 {
452 int i;
453 outw(EEPROM_READ + index, ioaddr + 10);
454 /* Reading the eeprom takes 162 us */
455 for (i = 1620; i >= 0; i--)
456 if ((inw(ioaddr + 10) & EEPROM_BUSY) == 0)
457 break;
458 return inw(ioaddr + 12);
459 }
460
461 /*
462 Set transceiver type, perhaps to something other than what the user
463 specified in dev->if_port.
464 */
465 static void tc589_set_xcvr(struct net_device *dev, int if_port)
466 {
467 struct el3_private *lp = netdev_priv(dev);
468 kio_addr_t ioaddr = dev->base_addr;
469
470 EL3WINDOW(0);
471 switch (if_port) {
472 case 0: case 1: outw(0, ioaddr + 6); break;
473 case 2: outw(3<<14, ioaddr + 6); break;
474 case 3: outw(1<<14, ioaddr + 6); break;
475 }
476 /* On PCMCIA, this just turns on the LED */
477 outw((if_port == 2) ? StartCoax : StopCoax, ioaddr + EL3_CMD);
478 /* 10baseT interface, enable link beat and jabber check. */
479 EL3WINDOW(4);
480 outw(MEDIA_LED | ((if_port < 2) ? MEDIA_TP : 0), ioaddr + WN4_MEDIA);
481 EL3WINDOW(1);
482 if (if_port == 2)
483 lp->media_status = ((dev->if_port == 0) ? 0x8000 : 0x4000);
484 else
485 lp->media_status = ((dev->if_port == 0) ? 0x4010 : 0x8800);
486 }
487
488 static void dump_status(struct net_device *dev)
489 {
490 kio_addr_t ioaddr = dev->base_addr;
491 EL3WINDOW(1);
492 printk(KERN_INFO " irq status %04x, rx status %04x, tx status "
493 "%02x tx free %04x\n", inw(ioaddr+EL3_STATUS),
494 inw(ioaddr+RX_STATUS), inb(ioaddr+TX_STATUS),
495 inw(ioaddr+TX_FREE));
496 EL3WINDOW(4);
497 printk(KERN_INFO " diagnostics: fifo %04x net %04x ethernet %04x"
498 " media %04x\n", inw(ioaddr+0x04), inw(ioaddr+0x06),
499 inw(ioaddr+0x08), inw(ioaddr+0x0a));
500 EL3WINDOW(1);
501 }
502
503 /* Reset and restore all of the 3c589 registers. */
504 static void tc589_reset(struct net_device *dev)
505 {
506 kio_addr_t ioaddr = dev->base_addr;
507 int i;
508
509 EL3WINDOW(0);
510 outw(0x0001, ioaddr + 4); /* Activate board. */
511 outw(0x3f00, ioaddr + 8); /* Set the IRQ line. */
512
513 /* Set the station address in window 2. */
514 EL3WINDOW(2);
515 for (i = 0; i < 6; i++)
516 outb(dev->dev_addr[i], ioaddr + i);
517
518 tc589_set_xcvr(dev, dev->if_port);
519
520 /* Switch to the stats window, and clear all stats by reading. */
521 outw(StatsDisable, ioaddr + EL3_CMD);
522 EL3WINDOW(6);
523 for (i = 0; i < 9; i++)
524 inb(ioaddr+i);
525 inw(ioaddr + 10);
526 inw(ioaddr + 12);
527
528 /* Switch to register set 1 for normal use. */
529 EL3WINDOW(1);
530
531 /* Accept b-cast and phys addr only. */
532 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
533 outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
534 outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
535 outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
536 /* Allow status bits to be seen. */
537 outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
538 /* Ack all pending events, and set active indicator mask. */
539 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
540 ioaddr + EL3_CMD);
541 outw(SetIntrEnb | IntLatch | TxAvailable | RxComplete | StatsFull
542 | AdapterFailure, ioaddr + EL3_CMD);
543 }
544
545 static void netdev_get_drvinfo(struct net_device *dev,
546 struct ethtool_drvinfo *info)
547 {
548 strcpy(info->driver, DRV_NAME);
549 strcpy(info->version, DRV_VERSION);
550 sprintf(info->bus_info, "PCMCIA 0x%lx", dev->base_addr);
551 }
552
553 #ifdef PCMCIA_DEBUG
554 static u32 netdev_get_msglevel(struct net_device *dev)
555 {
556 return pc_debug;
557 }
558
559 static void netdev_set_msglevel(struct net_device *dev, u32 level)
560 {
561 pc_debug = level;
562 }
563 #endif /* PCMCIA_DEBUG */
564
565 static struct ethtool_ops netdev_ethtool_ops = {
566 .get_drvinfo = netdev_get_drvinfo,
567 #ifdef PCMCIA_DEBUG
568 .get_msglevel = netdev_get_msglevel,
569 .set_msglevel = netdev_set_msglevel,
570 #endif /* PCMCIA_DEBUG */
571 };
572
573 static int el3_config(struct net_device *dev, struct ifmap *map)
574 {
575 if ((map->port != (u_char)(-1)) && (map->port != dev->if_port)) {
576 if (map->port <= 3) {
577 dev->if_port = map->port;
578 printk(KERN_INFO "%s: switched to %s port\n",
579 dev->name, if_names[dev->if_port]);
580 tc589_set_xcvr(dev, dev->if_port);
581 } else
582 return -EINVAL;
583 }
584 return 0;
585 }
586
587 static int el3_open(struct net_device *dev)
588 {
589 struct el3_private *lp = netdev_priv(dev);
590 dev_link_t *link = &lp->link;
591
592 if (!DEV_OK(link))
593 return -ENODEV;
594
595 link->open++;
596 netif_start_queue(dev);
597
598 tc589_reset(dev);
599 init_timer(&lp->media);
600 lp->media.function = &media_check;
601 lp->media.data = (unsigned long) dev;
602 lp->media.expires = jiffies + HZ;
603 add_timer(&lp->media);
604
605 DEBUG(1, "%s: opened, status %4.4x.\n",
606 dev->name, inw(dev->base_addr + EL3_STATUS));
607
608 return 0;
609 }
610
611 static void el3_tx_timeout(struct net_device *dev)
612 {
613 struct el3_private *lp = netdev_priv(dev);
614 kio_addr_t ioaddr = dev->base_addr;
615
616 printk(KERN_WARNING "%s: Transmit timed out!\n", dev->name);
617 dump_status(dev);
618 lp->stats.tx_errors++;
619 dev->trans_start = jiffies;
620 /* Issue TX_RESET and TX_START commands. */
621 tc589_wait_for_completion(dev, TxReset);
622 outw(TxEnable, ioaddr + EL3_CMD);
623 netif_wake_queue(dev);
624 }
625
626 static void pop_tx_status(struct net_device *dev)
627 {
628 struct el3_private *lp = netdev_priv(dev);
629 kio_addr_t ioaddr = dev->base_addr;
630 int i;
631
632 /* Clear the Tx status stack. */
633 for (i = 32; i > 0; i--) {
634 u_char tx_status = inb(ioaddr + TX_STATUS);
635 if (!(tx_status & 0x84)) break;
636 /* reset transmitter on jabber error or underrun */
637 if (tx_status & 0x30)
638 tc589_wait_for_completion(dev, TxReset);
639 if (tx_status & 0x38) {
640 DEBUG(1, "%s: transmit error: status 0x%02x\n",
641 dev->name, tx_status);
642 outw(TxEnable, ioaddr + EL3_CMD);
643 lp->stats.tx_aborted_errors++;
644 }
645 outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
646 }
647 }
648
649 static int el3_start_xmit(struct sk_buff *skb, struct net_device *dev)
650 {
651 kio_addr_t ioaddr = dev->base_addr;
652 struct el3_private *priv = netdev_priv(dev);
653
654 DEBUG(3, "%s: el3_start_xmit(length = %ld) called, "
655 "status %4.4x.\n", dev->name, (long)skb->len,
656 inw(ioaddr + EL3_STATUS));
657
658 priv->stats.tx_bytes += skb->len;
659
660 /* Put out the doubleword header... */
661 outw(skb->len, ioaddr + TX_FIFO);
662 outw(0x00, ioaddr + TX_FIFO);
663 /* ... and the packet rounded to a doubleword. */
664 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
665
666 dev->trans_start = jiffies;
667 if (inw(ioaddr + TX_FREE) <= 1536) {
668 netif_stop_queue(dev);
669 /* Interrupt us when the FIFO has room for max-sized packet. */
670 outw(SetTxThreshold + 1536, ioaddr + EL3_CMD);
671 }
672
673 dev_kfree_skb(skb);
674 pop_tx_status(dev);
675
676 return 0;
677 }
678
679 /* The EL3 interrupt handler. */
680 static irqreturn_t el3_interrupt(int irq, void *dev_id, struct pt_regs *regs)
681 {
682 struct net_device *dev = (struct net_device *) dev_id;
683 struct el3_private *lp = netdev_priv(dev);
684 kio_addr_t ioaddr;
685 __u16 status;
686 int i = 0, handled = 1;
687
688 if (!netif_device_present(dev))
689 return IRQ_NONE;
690
691 ioaddr = dev->base_addr;
692
693 DEBUG(3, "%s: interrupt, status %4.4x.\n",
694 dev->name, inw(ioaddr + EL3_STATUS));
695
696 spin_lock(&lp->lock);
697 while ((status = inw(ioaddr + EL3_STATUS)) &
698 (IntLatch | RxComplete | StatsFull)) {
699 if ((status & 0xe000) != 0x2000) {
700 DEBUG(1, "%s: interrupt from dead card\n", dev->name);
701 handled = 0;
702 break;
703 }
704
705 if (status & RxComplete)
706 el3_rx(dev);
707
708 if (status & TxAvailable) {
709 DEBUG(3, " TX room bit was handled.\n");
710 /* There's room in the FIFO for a full-sized packet. */
711 outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
712 netif_wake_queue(dev);
713 }
714
715 if (status & TxComplete)
716 pop_tx_status(dev);
717
718 if (status & (AdapterFailure | RxEarly | StatsFull)) {
719 /* Handle all uncommon interrupts. */
720 if (status & StatsFull) /* Empty statistics. */
721 update_stats(dev);
722 if (status & RxEarly) { /* Rx early is unused. */
723 el3_rx(dev);
724 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
725 }
726 if (status & AdapterFailure) {
727 u16 fifo_diag;
728 EL3WINDOW(4);
729 fifo_diag = inw(ioaddr + 4);
730 EL3WINDOW(1);
731 printk(KERN_WARNING "%s: adapter failure, FIFO diagnostic"
732 " register %04x.\n", dev->name, fifo_diag);
733 if (fifo_diag & 0x0400) {
734 /* Tx overrun */
735 tc589_wait_for_completion(dev, TxReset);
736 outw(TxEnable, ioaddr + EL3_CMD);
737 }
738 if (fifo_diag & 0x2000) {
739 /* Rx underrun */
740 tc589_wait_for_completion(dev, RxReset);
741 set_multicast_list(dev);
742 outw(RxEnable, ioaddr + EL3_CMD);
743 }
744 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
745 }
746 }
747
748 if (++i > 10) {
749 printk(KERN_ERR "%s: infinite loop in interrupt, "
750 "status %4.4x.\n", dev->name, status);
751 /* Clear all interrupts */
752 outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
753 break;
754 }
755 /* Acknowledge the IRQ. */
756 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
757 }
758
759 lp->last_irq = jiffies;
760 spin_unlock(&lp->lock);
761 DEBUG(3, "%s: exiting interrupt, status %4.4x.\n",
762 dev->name, inw(ioaddr + EL3_STATUS));
763 return IRQ_RETVAL(handled);
764 }
765
766 static void media_check(unsigned long arg)
767 {
768 struct net_device *dev = (struct net_device *)(arg);
769 struct el3_private *lp = netdev_priv(dev);
770 kio_addr_t ioaddr = dev->base_addr;
771 u16 media, errs;
772 unsigned long flags;
773
774 if (!netif_device_present(dev)) goto reschedule;
775
776 EL3WINDOW(1);
777 /* Check for pending interrupt with expired latency timer: with
778 this, we can limp along even if the interrupt is blocked */
779 if ((inw(ioaddr + EL3_STATUS) & IntLatch) &&
780 (inb(ioaddr + EL3_TIMER) == 0xff)) {
781 if (!lp->fast_poll)
782 printk(KERN_WARNING "%s: interrupt(s) dropped!\n", dev->name);
783 el3_interrupt(dev->irq, lp, NULL);
784 lp->fast_poll = HZ;
785 }
786 if (lp->fast_poll) {
787 lp->fast_poll--;
788 lp->media.expires = jiffies + HZ/100;
789 add_timer(&lp->media);
790 return;
791 }
792
793 /* lp->lock guards the EL3 window. Window should always be 1 except
794 when the lock is held */
795 spin_lock_irqsave(&lp->lock, flags);
796 EL3WINDOW(4);
797 media = inw(ioaddr+WN4_MEDIA) & 0xc810;
798
799 /* Ignore collisions unless we've had no irq's recently */
800 if (time_before(jiffies, lp->last_irq + HZ)) {
801 media &= ~0x0010;
802 } else {
803 /* Try harder to detect carrier errors */
804 EL3WINDOW(6);
805 outw(StatsDisable, ioaddr + EL3_CMD);
806 errs = inb(ioaddr + 0);
807 outw(StatsEnable, ioaddr + EL3_CMD);
808 lp->stats.tx_carrier_errors += errs;
809 if (errs || (lp->media_status & 0x0010)) media |= 0x0010;
810 }
811
812 if (media != lp->media_status) {
813 if ((media & lp->media_status & 0x8000) &&
814 ((lp->media_status ^ media) & 0x0800))
815 printk(KERN_INFO "%s: %s link beat\n", dev->name,
816 (lp->media_status & 0x0800 ? "lost" : "found"));
817 else if ((media & lp->media_status & 0x4000) &&
818 ((lp->media_status ^ media) & 0x0010))
819 printk(KERN_INFO "%s: coax cable %s\n", dev->name,
820 (lp->media_status & 0x0010 ? "ok" : "problem"));
821 if (dev->if_port == 0) {
822 if (media & 0x8000) {
823 if (media & 0x0800)
824 printk(KERN_INFO "%s: flipped to 10baseT\n",
825 dev->name);
826 else
827 tc589_set_xcvr(dev, 2);
828 } else if (media & 0x4000) {
829 if (media & 0x0010)
830 tc589_set_xcvr(dev, 1);
831 else
832 printk(KERN_INFO "%s: flipped to 10base2\n",
833 dev->name);
834 }
835 }
836 lp->media_status = media;
837 }
838
839 EL3WINDOW(1);
840 spin_unlock_irqrestore(&lp->lock, flags);
841
842 reschedule:
843 lp->media.expires = jiffies + HZ;
844 add_timer(&lp->media);
845 }
846
847 static struct net_device_stats *el3_get_stats(struct net_device *dev)
848 {
849 struct el3_private *lp = netdev_priv(dev);
850 unsigned long flags;
851 dev_link_t *link = &lp->link;
852
853 if (DEV_OK(link)) {
854 spin_lock_irqsave(&lp->lock, flags);
855 update_stats(dev);
856 spin_unlock_irqrestore(&lp->lock, flags);
857 }
858 return &lp->stats;
859 }
860
861 /*
862 Update statistics. We change to register window 6, so this should be run
863 single-threaded if the device is active. This is expected to be a rare
864 operation, and it's simpler for the rest of the driver to assume that
865 window 1 is always valid rather than use a special window-state variable.
866
867 Caller must hold the lock for this
868 */
869 static void update_stats(struct net_device *dev)
870 {
871 struct el3_private *lp = netdev_priv(dev);
872 kio_addr_t ioaddr = dev->base_addr;
873
874 DEBUG(2, "%s: updating the statistics.\n", dev->name);
875 /* Turn off statistics updates while reading. */
876 outw(StatsDisable, ioaddr + EL3_CMD);
877 /* Switch to the stats window, and read everything. */
878 EL3WINDOW(6);
879 lp->stats.tx_carrier_errors += inb(ioaddr + 0);
880 lp->stats.tx_heartbeat_errors += inb(ioaddr + 1);
881 /* Multiple collisions. */ inb(ioaddr + 2);
882 lp->stats.collisions += inb(ioaddr + 3);
883 lp->stats.tx_window_errors += inb(ioaddr + 4);
884 lp->stats.rx_fifo_errors += inb(ioaddr + 5);
885 lp->stats.tx_packets += inb(ioaddr + 6);
886 /* Rx packets */ inb(ioaddr + 7);
887 /* Tx deferrals */ inb(ioaddr + 8);
888 /* Rx octets */ inw(ioaddr + 10);
889 /* Tx octets */ inw(ioaddr + 12);
890
891 /* Back to window 1, and turn statistics back on. */
892 EL3WINDOW(1);
893 outw(StatsEnable, ioaddr + EL3_CMD);
894 }
895
896 static int el3_rx(struct net_device *dev)
897 {
898 struct el3_private *lp = netdev_priv(dev);
899 kio_addr_t ioaddr = dev->base_addr;
900 int worklimit = 32;
901 short rx_status;
902
903 DEBUG(3, "%s: in rx_packet(), status %4.4x, rx_status %4.4x.\n",
904 dev->name, inw(ioaddr+EL3_STATUS), inw(ioaddr+RX_STATUS));
905 while (!((rx_status = inw(ioaddr + RX_STATUS)) & 0x8000) &&
906 (--worklimit >= 0)) {
907 if (rx_status & 0x4000) { /* Error, update stats. */
908 short error = rx_status & 0x3800;
909 lp->stats.rx_errors++;
910 switch (error) {
911 case 0x0000: lp->stats.rx_over_errors++; break;
912 case 0x0800: lp->stats.rx_length_errors++; break;
913 case 0x1000: lp->stats.rx_frame_errors++; break;
914 case 0x1800: lp->stats.rx_length_errors++; break;
915 case 0x2000: lp->stats.rx_frame_errors++; break;
916 case 0x2800: lp->stats.rx_crc_errors++; break;
917 }
918 } else {
919 short pkt_len = rx_status & 0x7ff;
920 struct sk_buff *skb;
921
922 skb = dev_alloc_skb(pkt_len+5);
923
924 DEBUG(3, " Receiving packet size %d status %4.4x.\n",
925 pkt_len, rx_status);
926 if (skb != NULL) {
927 skb->dev = dev;
928 skb_reserve(skb, 2);
929 insl(ioaddr+RX_FIFO, skb_put(skb, pkt_len),
930 (pkt_len+3)>>2);
931 skb->protocol = eth_type_trans(skb, dev);
932 netif_rx(skb);
933 dev->last_rx = jiffies;
934 lp->stats.rx_packets++;
935 lp->stats.rx_bytes += pkt_len;
936 } else {
937 DEBUG(1, "%s: couldn't allocate a sk_buff of"
938 " size %d.\n", dev->name, pkt_len);
939 lp->stats.rx_dropped++;
940 }
941 }
942 /* Pop the top of the Rx FIFO */
943 tc589_wait_for_completion(dev, RxDiscard);
944 }
945 if (worklimit == 0)
946 printk(KERN_WARNING "%s: too much work in el3_rx!\n", dev->name);
947 return 0;
948 }
949
950 static void set_multicast_list(struct net_device *dev)
951 {
952 struct el3_private *lp = netdev_priv(dev);
953 dev_link_t *link = &lp->link;
954 kio_addr_t ioaddr = dev->base_addr;
955 u16 opts = SetRxFilter | RxStation | RxBroadcast;
956
957 if (!(DEV_OK(link))) return;
958 if (dev->flags & IFF_PROMISC)
959 opts |= RxMulticast | RxProm;
960 else if (dev->mc_count || (dev->flags & IFF_ALLMULTI))
961 opts |= RxMulticast;
962 outw(opts, ioaddr + EL3_CMD);
963 }
964
965 static int el3_close(struct net_device *dev)
966 {
967 struct el3_private *lp = netdev_priv(dev);
968 dev_link_t *link = &lp->link;
969 kio_addr_t ioaddr = dev->base_addr;
970
971 DEBUG(1, "%s: shutting down ethercard.\n", dev->name);
972
973 if (DEV_OK(link)) {
974 /* Turn off statistics ASAP. We update lp->stats below. */
975 outw(StatsDisable, ioaddr + EL3_CMD);
976
977 /* Disable the receiver and transmitter. */
978 outw(RxDisable, ioaddr + EL3_CMD);
979 outw(TxDisable, ioaddr + EL3_CMD);
980
981 if (dev->if_port == 2)
982 /* Turn off thinnet power. Green! */
983 outw(StopCoax, ioaddr + EL3_CMD);
984 else if (dev->if_port == 1) {
985 /* Disable link beat and jabber */
986 EL3WINDOW(4);
987 outw(0, ioaddr + WN4_MEDIA);
988 }
989
990 /* Switching back to window 0 disables the IRQ. */
991 EL3WINDOW(0);
992 /* But we explicitly zero the IRQ line select anyway. */
993 outw(0x0f00, ioaddr + WN0_IRQ);
994
995 /* Check if the card still exists */
996 if ((inw(ioaddr+EL3_STATUS) & 0xe000) == 0x2000)
997 update_stats(dev);
998 }
999
1000 link->open--;
1001 netif_stop_queue(dev);
1002 del_timer_sync(&lp->media);
1003
1004 return 0;
1005 }
1006
1007 static struct pcmcia_device_id tc589_ids[] = {
1008 PCMCIA_MFC_DEVICE_MANF_CARD(0, 0x0101, 0x0562),
1009 PCMCIA_MFC_DEVICE_PROD_ID1(0, "Motorola MARQUIS", 0xf03e4e77),
1010 PCMCIA_DEVICE_MANF_CARD(0x0101, 0x0589),
1011 PCMCIA_DEVICE_PROD_ID12("Farallon", "ENet", 0x58d93fc4, 0x992c2202),
1012 PCMCIA_MFC_DEVICE_CIS_MANF_CARD(0, 0x0101, 0x0035, "3CXEM556.cis"),
1013 PCMCIA_MFC_DEVICE_CIS_MANF_CARD(0, 0x0101, 0x003d, "3CXEM556.cis"),
1014 PCMCIA_DEVICE_NULL,
1015 };
1016 MODULE_DEVICE_TABLE(pcmcia, tc589_ids);
1017
1018 static struct pcmcia_driver tc589_driver = {
1019 .owner = THIS_MODULE,
1020 .drv = {
1021 .name = "3c589_cs",
1022 },
1023 .probe = tc589_attach,
1024 .remove = tc589_detach,
1025 .id_table = tc589_ids,
1026 .suspend = tc589_suspend,
1027 .resume = tc589_resume,
1028 };
1029
1030 static int __init init_tc589(void)
1031 {
1032 return pcmcia_register_driver(&tc589_driver);
1033 }
1034
1035 static void __exit exit_tc589(void)
1036 {
1037 pcmcia_unregister_driver(&tc589_driver);
1038 }
1039
1040 module_init(init_tc589);
1041 module_exit(exit_tc589);
Linus' kernel tree