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