projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[PATCH] pcmcia: default suspend and resume handling
[linux-2.6-block.git] / drivers / net / pcmcia / 3c589_cs.c
CommitLineData
1da177e4
LT		 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>
ff5688ae 42#include <linux/jiffies.h>
1da177e4 43
1da177e4
LT		 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. */
71enum 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
81enum 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: */
88enum 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
107struct 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
f71e1309 119static const char *if_names[] = { "auto", "10baseT", "10base2", "AUI" };
1da177e4
LT		 120
121/*====================================================================*/
122
123/* Module parameters */
124
125MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
126MODULE_DESCRIPTION("3Com 3c589 series PCMCIA ethernet driver");
127MODULE_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 */
132INT_MODULE_PARM(if_port, 0);
133
134#ifdef PCMCIA_DEBUG
135INT_MODULE_PARM(pc_debug, PCMCIA_DEBUG);
136#define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
137static char *version =
138DRV_NAME ".c " DRV_VERSION " 2001/10/13 00:08:50 (David Hinds)";
139#else
140#define DEBUG(n, args...)
141#endif
142
143/*====================================================================*/
144
145static void tc589_config(dev_link_t *link);
146static void tc589_release(dev_link_t *link);
1da177e4
LT		 147
148static u16 read_eeprom(kio_addr_t ioaddr, int index);
149static void tc589_reset(struct net_device *dev);
150static void media_check(unsigned long arg);
151static int el3_config(struct net_device *dev, struct ifmap *map);
152static int el3_open(struct net_device *dev);
153static int el3_start_xmit(struct sk_buff *skb, struct net_device *dev);
154static irqreturn_t el3_interrupt(int irq, void *dev_id, struct pt_regs *regs);
155static void update_stats(struct net_device *dev);
156static struct net_device_stats *el3_get_stats(struct net_device *dev);
157static int el3_rx(struct net_device *dev);
158static int el3_close(struct net_device *dev);
159static void el3_tx_timeout(struct net_device *dev);
160static void set_multicast_list(struct net_device *dev);
161static struct ethtool_ops netdev_ethtool_ops;
162
cc3b4866 163static void tc589_detach(struct pcmcia_device *p_dev);
1da177e4 164
1da177e4
LT		 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
f8cfa618 173static int tc589_attach(struct pcmcia_device *p_dev)
1da177e4
LT		 174{
175 struct el3_private *lp;
1da177e4
LT		 176 dev_link_t *link;
177 struct net_device *dev;
1da177e4
LT		 178
179 DEBUG(0, "3c589_attach()\n");
f8cfa618 180
1da177e4
LT		 181 /* Create new ethernet device */
182 dev = alloc_etherdev(sizeof(struct el3_private));
183 if (!dev)
f8cfa618 184 return -ENOMEM;
1da177e4
LT		 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;
f8cfa618 201
1da177e4
LT		 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
f8cfa618
DB		 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;
1da177e4
LT		 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
cc3b4866 234static void tc589_detach(struct pcmcia_device *p_dev)
1da177e4 235{
cc3b4866 236 dev_link_t *link = dev_to_instance(p_dev);
1da177e4 237 struct net_device *dev = link->priv;
b4635811 238
1da177e4 239 DEBUG(0, "3c589_detach(0x%p)\n", link);
1da177e4
LT		 240
241 if (link->dev)
242 unregister_netdev(dev);
243
244 if (link->state & DEV_CONFIG)
245 tc589_release(link);
cc3b4866 246
1da177e4
LT		 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) \
259do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
260
261static 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
371cs_failed:
372 cs_error(link->handle, last_fn, last_ret);
373failed:
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
387static void tc589_release(dev_link_t *link)
388{
5f2a71fc 389 pcmcia_disable_device(link->handle);
1da177e4
LT		 390}
391
98e4c28b
DB		 392static int tc589_suspend(struct pcmcia_device *p_dev)
393{
394 dev_link_t *link = dev_to_instance(p_dev);
395 struct net_device *dev = link->priv;
396
8661bb5b
DB		 397 if ((link->state & DEV_CONFIG) && (link->open))
398 netif_device_detach(dev);
98e4c28b
DB		 399
400 return 0;
401}
402
403static int tc589_resume(struct pcmcia_device *p_dev)
404{
405 dev_link_t *link = dev_to_instance(p_dev);
406 struct net_device *dev = link->priv;
407
8661bb5b
DB		 408 if ((link->state & DEV_CONFIG) && (link->open)) {
409 tc589_reset(dev);
410 netif_device_attach(dev);
98e4c28b
DB		 411 }
412
413 return 0;
414}
415
1da177e4
LT		 416/*====================================================================*/
417
418/*
419 Use this for commands that may take time to finish
420*/
421static void tc589_wait_for_completion(struct net_device *dev, int cmd)
422{
423 int i = 100;
424 outw(cmd, dev->base_addr + EL3_CMD);
425 while (--i > 0)
426 if (!(inw(dev->base_addr + EL3_STATUS) & 0x1000)) break;
427 if (i == 0)
428 printk(KERN_WARNING "%s: command 0x%04x did not complete!\n",
429 dev->name, cmd);
430}
431
432/*
433 Read a word from the EEPROM using the regular EEPROM access register.
434 Assume that we are in register window zero.
435*/
436static u16 read_eeprom(kio_addr_t ioaddr, int index)
437{
438 int i;
439 outw(EEPROM_READ + index, ioaddr + 10);
440 /* Reading the eeprom takes 162 us */
441 for (i = 1620; i >= 0; i--)
442 if ((inw(ioaddr + 10) & EEPROM_BUSY) == 0)
443 break;
444 return inw(ioaddr + 12);
445}
446
447/*
448 Set transceiver type, perhaps to something other than what the user
449 specified in dev->if_port.
450*/
451static void tc589_set_xcvr(struct net_device *dev, int if_port)
452{
453 struct el3_private *lp = netdev_priv(dev);
454 kio_addr_t ioaddr = dev->base_addr;
455
456 EL3WINDOW(0);
457 switch (if_port) {
458 case 0: case 1: outw(0, ioaddr + 6); break;
459 case 2: outw(3<<14, ioaddr + 6); break;
460 case 3: outw(1<<14, ioaddr + 6); break;
461 }
462 /* On PCMCIA, this just turns on the LED */
463 outw((if_port == 2) ? StartCoax : StopCoax, ioaddr + EL3_CMD);
464 /* 10baseT interface, enable link beat and jabber check. */
465 EL3WINDOW(4);
466 outw(MEDIA_LED | ((if_port < 2) ? MEDIA_TP : 0), ioaddr + WN4_MEDIA);
467 EL3WINDOW(1);
468 if (if_port == 2)
469 lp->media_status = ((dev->if_port == 0) ? 0x8000 : 0x4000);
470 else
471 lp->media_status = ((dev->if_port == 0) ? 0x4010 : 0x8800);
472}
473
474static void dump_status(struct net_device *dev)
475{
476 kio_addr_t ioaddr = dev->base_addr;
477 EL3WINDOW(1);
478 printk(KERN_INFO " irq status %04x, rx status %04x, tx status "
479 "%02x tx free %04x\n", inw(ioaddr+EL3_STATUS),
480 inw(ioaddr+RX_STATUS), inb(ioaddr+TX_STATUS),
481 inw(ioaddr+TX_FREE));
482 EL3WINDOW(4);
483 printk(KERN_INFO " diagnostics: fifo %04x net %04x ethernet %04x"
484 " media %04x\n", inw(ioaddr+0x04), inw(ioaddr+0x06),
485 inw(ioaddr+0x08), inw(ioaddr+0x0a));
486 EL3WINDOW(1);
487}
488
489/* Reset and restore all of the 3c589 registers. */
490static void tc589_reset(struct net_device *dev)
491{
492 kio_addr_t ioaddr = dev->base_addr;
493 int i;
494
495 EL3WINDOW(0);
496 outw(0x0001, ioaddr + 4); /* Activate board. */
497 outw(0x3f00, ioaddr + 8); /* Set the IRQ line. */
498
499 /* Set the station address in window 2. */
500 EL3WINDOW(2);
501 for (i = 0; i < 6; i++)
502 outb(dev->dev_addr[i], ioaddr + i);
503
504 tc589_set_xcvr(dev, dev->if_port);
505
506 /* Switch to the stats window, and clear all stats by reading. */
507 outw(StatsDisable, ioaddr + EL3_CMD);
508 EL3WINDOW(6);
509 for (i = 0; i < 9; i++)
510 inb(ioaddr+i);
511 inw(ioaddr + 10);
512 inw(ioaddr + 12);
513
514 /* Switch to register set 1 for normal use. */
515 EL3WINDOW(1);
516
517 /* Accept b-cast and phys addr only. */
518 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
519 outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
520 outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
521 outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
522 /* Allow status bits to be seen. */
523 outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
524 /* Ack all pending events, and set active indicator mask. */
525 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
526 ioaddr + EL3_CMD);
527 outw(SetIntrEnb | IntLatch | TxAvailable | RxComplete | StatsFull
528 | AdapterFailure, ioaddr + EL3_CMD);
529}
530
531static void netdev_get_drvinfo(struct net_device *dev,
532 struct ethtool_drvinfo *info)
533{
534 strcpy(info->driver, DRV_NAME);
535 strcpy(info->version, DRV_VERSION);
536 sprintf(info->bus_info, "PCMCIA 0x%lx", dev->base_addr);
537}
538
539#ifdef PCMCIA_DEBUG
540static u32 netdev_get_msglevel(struct net_device *dev)
541{
542 return pc_debug;
543}
544
545static void netdev_set_msglevel(struct net_device *dev, u32 level)
546{
547 pc_debug = level;
548}
549#endif /* PCMCIA_DEBUG */
550
551static struct ethtool_ops netdev_ethtool_ops = {
552 .get_drvinfo = netdev_get_drvinfo,
553#ifdef PCMCIA_DEBUG
554 .get_msglevel = netdev_get_msglevel,
555 .set_msglevel = netdev_set_msglevel,
556#endif /* PCMCIA_DEBUG */
557};
558
559static int el3_config(struct net_device *dev, struct ifmap *map)
560{
561 if ((map->port != (u_char)(-1)) && (map->port != dev->if_port)) {
562 if (map->port <= 3) {
563 dev->if_port = map->port;
564 printk(KERN_INFO "%s: switched to %s port\n",
565 dev->name, if_names[dev->if_port]);
566 tc589_set_xcvr(dev, dev->if_port);
567 } else
568 return -EINVAL;
569 }
570 return 0;
571}
572
573static int el3_open(struct net_device *dev)
574{
575 struct el3_private *lp = netdev_priv(dev);
576 dev_link_t *link = &lp->link;
577
578 if (!DEV_OK(link))
579 return -ENODEV;
580
581 link->open++;
582 netif_start_queue(dev);
583
584 tc589_reset(dev);
585 init_timer(&lp->media);
586 lp->media.function = &media_check;
587 lp->media.data = (unsigned long) dev;
588 lp->media.expires = jiffies + HZ;
589 add_timer(&lp->media);
590
591 DEBUG(1, "%s: opened, status %4.4x.\n",
592 dev->name, inw(dev->base_addr + EL3_STATUS));
593
594 return 0;
595}
596
597static void el3_tx_timeout(struct net_device *dev)
598{
599 struct el3_private *lp = netdev_priv(dev);
600 kio_addr_t ioaddr = dev->base_addr;
601
602 printk(KERN_WARNING "%s: Transmit timed out!\n", dev->name);
603 dump_status(dev);
604 lp->stats.tx_errors++;
605 dev->trans_start = jiffies;
606 /* Issue TX_RESET and TX_START commands. */
607 tc589_wait_for_completion(dev, TxReset);
608 outw(TxEnable, ioaddr + EL3_CMD);
609 netif_wake_queue(dev);
610}
611
612static void pop_tx_status(struct net_device *dev)
613{
614 struct el3_private *lp = netdev_priv(dev);
615 kio_addr_t ioaddr = dev->base_addr;
616 int i;
617
618 /* Clear the Tx status stack. */
619 for (i = 32; i > 0; i--) {
620 u_char tx_status = inb(ioaddr + TX_STATUS);
621 if (!(tx_status & 0x84)) break;
622 /* reset transmitter on jabber error or underrun */
623 if (tx_status & 0x30)
624 tc589_wait_for_completion(dev, TxReset);
625 if (tx_status & 0x38) {
626 DEBUG(1, "%s: transmit error: status 0x%02x\n",
627 dev->name, tx_status);
628 outw(TxEnable, ioaddr + EL3_CMD);
629 lp->stats.tx_aborted_errors++;
630 }
631 outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
632 }
633}
634
635static int el3_start_xmit(struct sk_buff *skb, struct net_device *dev)
636{
637 kio_addr_t ioaddr = dev->base_addr;
638 struct el3_private *priv = netdev_priv(dev);
639
640 DEBUG(3, "%s: el3_start_xmit(length = %ld) called, "
641 "status %4.4x.\n", dev->name, (long)skb->len,
642 inw(ioaddr + EL3_STATUS));
643
644 priv->stats.tx_bytes += skb->len;
645
646 /* Put out the doubleword header... */
647 outw(skb->len, ioaddr + TX_FIFO);
648 outw(0x00, ioaddr + TX_FIFO);
649 /* ... and the packet rounded to a doubleword. */
650 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
651
652 dev->trans_start = jiffies;
653 if (inw(ioaddr + TX_FREE) <= 1536) {
654 netif_stop_queue(dev);
655 /* Interrupt us when the FIFO has room for max-sized packet. */
656 outw(SetTxThreshold + 1536, ioaddr + EL3_CMD);
657 }
658
659 dev_kfree_skb(skb);
660 pop_tx_status(dev);
661
662 return 0;
663}
664
665/* The EL3 interrupt handler. */
666static irqreturn_t el3_interrupt(int irq, void *dev_id, struct pt_regs *regs)
667{
668 struct net_device *dev = (struct net_device *) dev_id;
669 struct el3_private *lp = netdev_priv(dev);
670 kio_addr_t ioaddr;
671 __u16 status;
672 int i = 0, handled = 1;
673
674 if (!netif_device_present(dev))
675 return IRQ_NONE;
676
677 ioaddr = dev->base_addr;
678
679 DEBUG(3, "%s: interrupt, status %4.4x.\n",
680 dev->name, inw(ioaddr + EL3_STATUS));
681
682 spin_lock(&lp->lock);
683 while ((status = inw(ioaddr + EL3_STATUS)) &
684 (IntLatch | RxComplete | StatsFull)) {
685 if ((status & 0xe000) != 0x2000) {
686 DEBUG(1, "%s: interrupt from dead card\n", dev->name);
687 handled = 0;
688 break;
689 }
690
691 if (status & RxComplete)
692 el3_rx(dev);
693
694 if (status & TxAvailable) {
695 DEBUG(3, " TX room bit was handled.\n");
696 /* There's room in the FIFO for a full-sized packet. */
697 outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
698 netif_wake_queue(dev);
699 }
700
701 if (status & TxComplete)
702 pop_tx_status(dev);
703
704 if (status & (AdapterFailure | RxEarly | StatsFull)) {
705 /* Handle all uncommon interrupts. */
706 if (status & StatsFull) /* Empty statistics. */
707 update_stats(dev);
708 if (status & RxEarly) { /* Rx early is unused. */
709 el3_rx(dev);
710 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
711 }
712 if (status & AdapterFailure) {
713 u16 fifo_diag;
714 EL3WINDOW(4);
715 fifo_diag = inw(ioaddr + 4);
716 EL3WINDOW(1);
717 printk(KERN_WARNING "%s: adapter failure, FIFO diagnostic"
718 " register %04x.\n", dev->name, fifo_diag);
719 if (fifo_diag & 0x0400) {
720 /* Tx overrun */
721 tc589_wait_for_completion(dev, TxReset);
722 outw(TxEnable, ioaddr + EL3_CMD);
723 }
724 if (fifo_diag & 0x2000) {
725 /* Rx underrun */
726 tc589_wait_for_completion(dev, RxReset);
727 set_multicast_list(dev);
728 outw(RxEnable, ioaddr + EL3_CMD);
729 }
730 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
731 }
732 }
733
734 if (++i > 10) {
735 printk(KERN_ERR "%s: infinite loop in interrupt, "
736 "status %4.4x.\n", dev->name, status);
737 /* Clear all interrupts */
738 outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
739 break;
740 }
741 /* Acknowledge the IRQ. */
742 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
743 }
744
745 lp->last_irq = jiffies;
746 spin_unlock(&lp->lock);
747 DEBUG(3, "%s: exiting interrupt, status %4.4x.\n",
748 dev->name, inw(ioaddr + EL3_STATUS));
749 return IRQ_RETVAL(handled);
750}
751
752static void media_check(unsigned long arg)
753{
754 struct net_device *dev = (struct net_device *)(arg);
755 struct el3_private *lp = netdev_priv(dev);
756 kio_addr_t ioaddr = dev->base_addr;
757 u16 media, errs;
758 unsigned long flags;
759
760 if (!netif_device_present(dev)) goto reschedule;
761
762 EL3WINDOW(1);
763 /* Check for pending interrupt with expired latency timer: with
764 this, we can limp along even if the interrupt is blocked */
765 if ((inw(ioaddr + EL3_STATUS) & IntLatch) &&
766 (inb(ioaddr + EL3_TIMER) == 0xff)) {
767 if (!lp->fast_poll)
768 printk(KERN_WARNING "%s: interrupt(s) dropped!\n", dev->name);
769 el3_interrupt(dev->irq, lp, NULL);
770 lp->fast_poll = HZ;
771 }
772 if (lp->fast_poll) {
773 lp->fast_poll--;
774 lp->media.expires = jiffies + HZ/100;
775 add_timer(&lp->media);
776 return;
777 }
778
779 /* lp->lock guards the EL3 window. Window should always be 1 except
780 when the lock is held */
781 spin_lock_irqsave(&lp->lock, flags);
782 EL3WINDOW(4);
783 media = inw(ioaddr+WN4_MEDIA) & 0xc810;
784
785 /* Ignore collisions unless we've had no irq's recently */
ff5688ae 786 if (time_before(jiffies, lp->last_irq + HZ)) {
1da177e4
LT		 787 media &= ~0x0010;
788 } else {
789 /* Try harder to detect carrier errors */
790 EL3WINDOW(6);
791 outw(StatsDisable, ioaddr + EL3_CMD);
792 errs = inb(ioaddr + 0);
793 outw(StatsEnable, ioaddr + EL3_CMD);
794 lp->stats.tx_carrier_errors += errs;
795 if (errs || (lp->media_status & 0x0010)) media |= 0x0010;
796 }
797
798 if (media != lp->media_status) {
799 if ((media & lp->media_status & 0x8000) &&
800 ((lp->media_status ^ media) & 0x0800))
801 printk(KERN_INFO "%s: %s link beat\n", dev->name,
802 (lp->media_status & 0x0800 ? "lost" : "found"));
803 else if ((media & lp->media_status & 0x4000) &&
804 ((lp->media_status ^ media) & 0x0010))
805 printk(KERN_INFO "%s: coax cable %s\n", dev->name,
806 (lp->media_status & 0x0010 ? "ok" : "problem"));
807 if (dev->if_port == 0) {
808 if (media & 0x8000) {
809 if (media & 0x0800)
810 printk(KERN_INFO "%s: flipped to 10baseT\n",
811 dev->name);
812 else
813 tc589_set_xcvr(dev, 2);
814 } else if (media & 0x4000) {
815 if (media & 0x0010)
816 tc589_set_xcvr(dev, 1);
817 else
818 printk(KERN_INFO "%s: flipped to 10base2\n",
819 dev->name);
820 }
821 }
822 lp->media_status = media;
823 }
824
825 EL3WINDOW(1);
826 spin_unlock_irqrestore(&lp->lock, flags);
827
828reschedule:
829 lp->media.expires = jiffies + HZ;
830 add_timer(&lp->media);
831}
832
833static struct net_device_stats *el3_get_stats(struct net_device *dev)
834{
835 struct el3_private *lp = netdev_priv(dev);
836 unsigned long flags;
837 dev_link_t *link = &lp->link;
838
839 if (DEV_OK(link)) {
840 spin_lock_irqsave(&lp->lock, flags);
841 update_stats(dev);
842 spin_unlock_irqrestore(&lp->lock, flags);
843 }
844 return &lp->stats;
845}
846
847/*
848 Update statistics. We change to register window 6, so this should be run
849 single-threaded if the device is active. This is expected to be a rare
850 operation, and it's simpler for the rest of the driver to assume that
851 window 1 is always valid rather than use a special window-state variable.
852
853 Caller must hold the lock for this
854*/
855static void update_stats(struct net_device *dev)
856{
857 struct el3_private *lp = netdev_priv(dev);
858 kio_addr_t ioaddr = dev->base_addr;
859
860 DEBUG(2, "%s: updating the statistics.\n", dev->name);
861 /* Turn off statistics updates while reading. */
862 outw(StatsDisable, ioaddr + EL3_CMD);
863 /* Switch to the stats window, and read everything. */
864 EL3WINDOW(6);
865 lp->stats.tx_carrier_errors += inb(ioaddr + 0);
866 lp->stats.tx_heartbeat_errors += inb(ioaddr + 1);
867 /* Multiple collisions. */ inb(ioaddr + 2);
868 lp->stats.collisions += inb(ioaddr + 3);
869 lp->stats.tx_window_errors += inb(ioaddr + 4);
870 lp->stats.rx_fifo_errors += inb(ioaddr + 5);
871 lp->stats.tx_packets += inb(ioaddr + 6);
872 /* Rx packets */ inb(ioaddr + 7);
873 /* Tx deferrals */ inb(ioaddr + 8);
874 /* Rx octets */ inw(ioaddr + 10);
875 /* Tx octets */ inw(ioaddr + 12);
876
877 /* Back to window 1, and turn statistics back on. */
878 EL3WINDOW(1);
879 outw(StatsEnable, ioaddr + EL3_CMD);
880}
881
882static int el3_rx(struct net_device *dev)
883{
884 struct el3_private *lp = netdev_priv(dev);
885 kio_addr_t ioaddr = dev->base_addr;
886 int worklimit = 32;
887 short rx_status;
888
889 DEBUG(3, "%s: in rx_packet(), status %4.4x, rx_status %4.4x.\n",
890 dev->name, inw(ioaddr+EL3_STATUS), inw(ioaddr+RX_STATUS));
891 while (!((rx_status = inw(ioaddr + RX_STATUS)) & 0x8000) &&
892 (--worklimit >= 0)) {
893 if (rx_status & 0x4000) { /* Error, update stats. */
894 short error = rx_status & 0x3800;
895 lp->stats.rx_errors++;
896 switch (error) {
897 case 0x0000: lp->stats.rx_over_errors++; break;
898 case 0x0800: lp->stats.rx_length_errors++; break;
899 case 0x1000: lp->stats.rx_frame_errors++; break;
900 case 0x1800: lp->stats.rx_length_errors++; break;
901 case 0x2000: lp->stats.rx_frame_errors++; break;
902 case 0x2800: lp->stats.rx_crc_errors++; break;
903 }
904 } else {
905 short pkt_len = rx_status & 0x7ff;
906 struct sk_buff *skb;
907
908 skb = dev_alloc_skb(pkt_len+5);
909
910 DEBUG(3, " Receiving packet size %d status %4.4x.\n",
911 pkt_len, rx_status);
912 if (skb != NULL) {
913 skb->dev = dev;
914 skb_reserve(skb, 2);
915 insl(ioaddr+RX_FIFO, skb_put(skb, pkt_len),
916 (pkt_len+3)>>2);
917 skb->protocol = eth_type_trans(skb, dev);
918 netif_rx(skb);
919 dev->last_rx = jiffies;
920 lp->stats.rx_packets++;
921 lp->stats.rx_bytes += pkt_len;
922 } else {
923 DEBUG(1, "%s: couldn't allocate a sk_buff of"
924 " size %d.\n", dev->name, pkt_len);
925 lp->stats.rx_dropped++;
926 }
927 }
928 /* Pop the top of the Rx FIFO */
929 tc589_wait_for_completion(dev, RxDiscard);
930 }
931 if (worklimit == 0)
932 printk(KERN_WARNING "%s: too much work in el3_rx!\n", dev->name);
933 return 0;
934}
935
936static void set_multicast_list(struct net_device *dev)
937{
938 struct el3_private *lp = netdev_priv(dev);
939 dev_link_t *link = &lp->link;
940 kio_addr_t ioaddr = dev->base_addr;
941 u16 opts = SetRxFilter | RxStation | RxBroadcast;
942
943 if (!(DEV_OK(link))) return;
944 if (dev->flags & IFF_PROMISC)
945 opts |= RxMulticast | RxProm;
946 else if (dev->mc_count || (dev->flags & IFF_ALLMULTI))
947 opts |= RxMulticast;
948 outw(opts, ioaddr + EL3_CMD);
949}
950
951static int el3_close(struct net_device *dev)
952{
953 struct el3_private *lp = netdev_priv(dev);
954 dev_link_t *link = &lp->link;
955 kio_addr_t ioaddr = dev->base_addr;
956
957 DEBUG(1, "%s: shutting down ethercard.\n", dev->name);
958
959 if (DEV_OK(link)) {
960 /* Turn off statistics ASAP. We update lp->stats below. */
961 outw(StatsDisable, ioaddr + EL3_CMD);
962
963 /* Disable the receiver and transmitter. */
964 outw(RxDisable, ioaddr + EL3_CMD);
965 outw(TxDisable, ioaddr + EL3_CMD);
966
967 if (dev->if_port == 2)
968 /* Turn off thinnet power. Green! */
969 outw(StopCoax, ioaddr + EL3_CMD);
970 else if (dev->if_port == 1) {
971 /* Disable link beat and jabber */
972 EL3WINDOW(4);
973 outw(0, ioaddr + WN4_MEDIA);
974 }
975
976 /* Switching back to window 0 disables the IRQ. */
977 EL3WINDOW(0);
978 /* But we explicitly zero the IRQ line select anyway. */
979 outw(0x0f00, ioaddr + WN0_IRQ);
980
981 /* Check if the card still exists */
982 if ((inw(ioaddr+EL3_STATUS) & 0xe000) == 0x2000)
983 update_stats(dev);
984 }
985
986 link->open--;
987 netif_stop_queue(dev);
988 del_timer_sync(&lp->media);
989
990 return 0;
991}
992
7ffec58c
DB		 993static struct pcmcia_device_id tc589_ids[] = {
994 PCMCIA_MFC_DEVICE_MANF_CARD(0, 0x0101, 0x0562),
995 PCMCIA_MFC_DEVICE_PROD_ID1(0, "Motorola MARQUIS", 0xf03e4e77),
996 PCMCIA_DEVICE_MANF_CARD(0x0101, 0x0589),
997 PCMCIA_DEVICE_PROD_ID12("Farallon", "ENet", 0x58d93fc4, 0x992c2202),
998 PCMCIA_MFC_DEVICE_CIS_MANF_CARD(0, 0x0101, 0x0035, "3CXEM556.cis"),
999 PCMCIA_MFC_DEVICE_CIS_MANF_CARD(0, 0x0101, 0x003d, "3CXEM556.cis"),
1000 PCMCIA_DEVICE_NULL,
1001};
1002MODULE_DEVICE_TABLE(pcmcia, tc589_ids);
1003
1da177e4
LT		 1004static struct pcmcia_driver tc589_driver = {
1005 .owner = THIS_MODULE,
1006 .drv = {
1007 .name = "3c589_cs",
1008 },
f8cfa618 1009 .probe = tc589_attach,
cc3b4866 1010 .remove = tc589_detach,
7ffec58c 1011 .id_table = tc589_ids,
98e4c28b
DB		 1012 .suspend = tc589_suspend,
1013 .resume = tc589_resume,
1da177e4
LT		 1014};
1015
1016static int __init init_tc589(void)
1017{
1018 return pcmcia_register_driver(&tc589_driver);
1019}
1020
1021static void __exit exit_tc589(void)
1022{
1023 pcmcia_unregister_driver(&tc589_driver);
1da177e4
LT		 1024}
1025
1026module_init(init_tc589);
1027module_exit(exit_tc589);
Linux 6.x block layer and io_uring tree(s)