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