![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to 3c574_cs.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / linux / pcmcia-cs / clients|
Return to 3c574_cs.c CVS log | Up to [GnuMach] / Gnu-Mach / linux / pcmcia-cs / clients |
1.1 root 1: /* 3c574.c: A PCMCIA ethernet driver for the 3com 3c574 "RoadRunner".
2:
3: Written 1993-1998 by
4: Donald Becker, [email protected], (driver core) and
5: David Hinds, [email protected] (from his PC card code).
6:
7: This software may be used and distributed according to the terms of
8: the GNU General Public License, incorporated herein by reference.
9:
10: This driver derives from Donald Becker's 3c509 core, which has the
11: following copyright:
12: Copyright 1993 United States Government as represented by the
13: Director, National Security Agency.
14:
15: */
16:
17: /*
18: Theory of Operation
19:
20: I. Board Compatibility
21:
22: This device driver is designed for the 3Com 3c574 PC card Fast Ethernet
23: Adapter.
24:
25: II. Board-specific settings
26:
27: None -- PC cards are autoconfigured.
28:
29: III. Driver operation
30:
31: The 3c574 uses a Boomerang-style interface, without the bus-master capability.
32: See the Boomerang driver and documentation for most details.
33:
34: IV. Notes and chip documentation.
35:
36: Two added registers are used to enhance PIO performance, RunnerRdCtrl and
37: RunnerWrCtrl. These are 11 bit down-counters that are preloaded with the
38: count of word (16 bits) reads or writes the driver is about to do to the Rx
39: or Tx FIFO. The chip is then able to hide the internal-PCI-bus to PC-card
40: translation latency by buffering the I/O operations with an 8 word FIFO.
41: Note: No other chip accesses are permitted when this buffer is used.
42:
43: A second enhancement is that both attribute and common memory space
44: 0x0800-0x0fff can translated to the PIO FIFO. Thus memory operations (faster
45: with *some* PCcard bridges) may be used instead of I/O operations.
46: This is enabled by setting the 0x10 bit in the PCMCIA LAN COR.
47:
48: Some slow PC card bridges work better if they never see a WAIT signal.
49: This is configured by setting the 0x20 bit in the PCMCIA LAN COR.
50: Only do this after testing that it is reliable and improves performance.
51:
52: The upper five bits of RunnerRdCtrl are used to window into PCcard
53: configuration space registers. Window 0 is the regular Boomerang/Odie
54: register set, 1-5 are various PC card control registers, and 16-31 are
55: the (reversed!) CIS table.
56:
57: A final note: writing the InternalConfig register in window 3 with an
58: invalid ramWidth is Very Bad.
59:
60: V. References
61:
62: http://www.scyld.com/expert/NWay.html
63: http://www.national.com/pf/DP/DP83840.html
64:
65: Thanks to Terry Murphy of 3Com for providing development information for
66: earlier 3Com products.
67:
68: */
69:
70: #include <linux/module.h>
71: #include <linux/kernel.h>
72: #include <linux/init.h>
73: #include <linux/sched.h>
74: #include <linux/slab.h>
75: #include <linux/string.h>
76: #include <linux/timer.h>
77: #include <linux/interrupt.h>
78: #include <linux/in.h>
79: #include <linux/delay.h>
80: #include <asm/io.h>
81: #include <asm/system.h>
82: #include <asm/bitops.h>
83:
84: #include <linux/netdevice.h>
85: #include <linux/etherdevice.h>
86: #include <linux/skbuff.h>
87: #include <linux/if_arp.h>
88: #include <linux/ioport.h>
89:
90: #include <pcmcia/version.h>
91: #include <pcmcia/cs_types.h>
92: #include <pcmcia/cs.h>
93: #include <pcmcia/cistpl.h>
94: #include <pcmcia/cisreg.h>
95: #include <pcmcia/ciscode.h>
96: #include <pcmcia/ds.h>
97: #include <pcmcia/mem_op.h>
98:
99: /*====================================================================*/
100:
101: /* Module parameters */
102:
103: MODULE_AUTHOR("David Hinds <[email protected]>");
104: MODULE_DESCRIPTION("3Com 3c574 series PCMCIA ethernet driver");
105: MODULE_LICENSE("GPL");
106:
107: #define INT_MODULE_PARM(n, v) static int n = v; MODULE_PARM(n, "i")
108:
109: /* Now-standard PC card module parameters. */
110: INT_MODULE_PARM(irq_mask, 0xdeb8);
111: static int irq_list[4] = { -1 };
112: MODULE_PARM(irq_list, "1-4i");
113:
114: /* Maximum events (Rx packets, etc.) to handle at each interrupt. */
115: INT_MODULE_PARM(max_interrupt_work, 32);
116:
117: /* Force full duplex modes? */
118: INT_MODULE_PARM(full_duplex, 0);
119:
120: /* Autodetect link polarity reversal? */
121: INT_MODULE_PARM(auto_polarity, 1);
122:
123: #ifdef PCMCIA_DEBUG
124: INT_MODULE_PARM(pc_debug, PCMCIA_DEBUG);
125: #define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
126: static char *version =
127: "3c574_cs.c 1.70 2003/08/25 15:57:40 Donald Becker/David Hinds, [email protected].\n";
128: #else
129: #define DEBUG(n, args...)
130: #endif
131:
132: /*====================================================================*/
133:
134: /* Time in jiffies before concluding the transmitter is hung. */
135: #define TX_TIMEOUT ((800*HZ)/1000)
136:
137: /* To minimize the size of the driver source and make the driver more
138: readable not all constants are symbolically defined.
139: You'll need the manual if you want to understand driver details anyway. */
140: /* Offsets from base I/O address. */
141: #define EL3_DATA 0x00
142: #define EL3_CMD 0x0e
143: #define EL3_STATUS 0x0e
144:
145: #define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
146:
147: /* The top five bits written to EL3_CMD are a command, the lower
148: 11 bits are the parameter, if applicable. */
149: enum el3_cmds {
150: TotalReset = 0<<11, SelectWindow = 1<<11, StartCoax = 2<<11,
151: RxDisable = 3<<11, RxEnable = 4<<11, RxReset = 5<<11, RxDiscard = 8<<11,
152: TxEnable = 9<<11, TxDisable = 10<<11, TxReset = 11<<11,
153: FakeIntr = 12<<11, AckIntr = 13<<11, SetIntrEnb = 14<<11,
154: SetStatusEnb = 15<<11, SetRxFilter = 16<<11, SetRxThreshold = 17<<11,
155: SetTxThreshold = 18<<11, SetTxStart = 19<<11, StatsEnable = 21<<11,
156: StatsDisable = 22<<11, StopCoax = 23<<11,
157: };
158:
159: enum elxl_status {
160: IntLatch = 0x0001, AdapterFailure = 0x0002, TxComplete = 0x0004,
161: TxAvailable = 0x0008, RxComplete = 0x0010, RxEarly = 0x0020,
162: IntReq = 0x0040, StatsFull = 0x0080, CmdBusy = 0x1000 };
163:
164: /* The SetRxFilter command accepts the following classes: */
165: enum RxFilter {
166: RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8
167: };
168:
169: enum Window0 {
170: Wn0EepromCmd = 10, Wn0EepromData = 12, /* EEPROM command/address, data. */
171: IntrStatus=0x0E, /* Valid in all windows. */
172: };
173: /* These assumes the larger EEPROM. */
174: enum Win0_EEPROM_cmds {
175: EEPROM_Read = 0x200, EEPROM_WRITE = 0x100, EEPROM_ERASE = 0x300,
176: EEPROM_EWENB = 0x30, /* Enable erasing/writing for 10 msec. */
177: EEPROM_EWDIS = 0x00, /* Disable EWENB before 10 msec timeout. */
178: };
179:
180: /* Register window 1 offsets, the window used in normal operation.
181: On the "Odie" this window is always mapped at offsets 0x10-0x1f.
182: Except for TxFree, which is overlapped by RunnerWrCtrl. */
183: enum Window1 {
184: TX_FIFO = 0x10, RX_FIFO = 0x10, RxErrors = 0x14,
185: RxStatus = 0x18, Timer=0x1A, TxStatus = 0x1B,
186: TxFree = 0x0C, /* Remaining free bytes in Tx buffer. */
187: RunnerRdCtrl = 0x16, RunnerWrCtrl = 0x1c,
188: };
189:
190: enum Window3 { /* Window 3: MAC/config bits. */
191: Wn3_Config=0, Wn3_MAC_Ctrl=6, Wn3_Options=8,
192: };
193: union wn3_config {
194: int i;
195: struct w3_config_fields {
196: unsigned int ram_size:3, ram_width:1, ram_speed:2, rom_size:2;
197: int pad8:8;
198: unsigned int ram_split:2, pad18:2, xcvr:3, pad21:1, autoselect:1;
199: int pad24:7;
200: } u;
201: };
202:
203: enum Window4 { /* Window 4: Xcvr/media bits. */
204: Wn4_FIFODiag = 4, Wn4_NetDiag = 6, Wn4_PhysicalMgmt=8, Wn4_Media = 10,
205: };
206:
207:
208: #define MEDIA_TP 0x00C0 /* Enable link beat and jabber for 10baseT. */
209:
210: struct el3_private {
211: dev_link_t link;
212: struct net_device dev;
213: dev_node_t node;
214: struct net_device_stats stats;
215: u16 advertising, partner; /* NWay media advertisement */
216: unsigned char phys; /* MII device address */
217: unsigned int
218: autoselect:1, default_media:3; /* Read from the EEPROM/Wn3_Config. */
219: /* for transceiver monitoring */
220: struct timer_list media;
221: u_short media_status;
222: u_short fast_poll;
223: u_long last_irq;
224: };
225:
226: /* Set iff a MII transceiver on any interface requires mdio preamble.
227: This only set with the original DP83840 on older 3c905 boards, so the extra
228: code size of a per-interface flag is not worthwhile. */
229: static char mii_preamble_required = 0;
230:
231: /* Index of functions. */
232:
233: static void tc574_config(dev_link_t *link);
234: static void tc574_release(u_long arg);
235: static int tc574_event(event_t event, int priority,
236: event_callback_args_t *args);
237:
238: static void mdio_sync(ioaddr_t ioaddr, int bits);
239: static int mdio_read(ioaddr_t ioaddr, int phy_id, int location);
240: static void mdio_write(ioaddr_t ioaddr, int phy_id, int location, int value);
241: static u_short read_eeprom(ioaddr_t ioaddr, int index);
242: static void tc574_wait_for_completion(struct net_device *dev, int cmd);
243:
244: static void tc574_reset(struct net_device *dev);
245: static void media_check(u_long arg);
246: static int el3_open(struct net_device *dev);
247: static int el3_start_xmit(struct sk_buff *skb, struct net_device *dev);
248: static void el3_interrupt(int irq, void *dev_id, struct pt_regs *regs);
249: static void update_stats(struct net_device *dev);
250: static struct net_device_stats *el3_get_stats(struct net_device *dev);
251: static int el3_rx(struct net_device *dev, int worklimit);
252: static int el3_close(struct net_device *dev);
253: static void el3_tx_timeout(struct net_device *dev);
254: static int el3_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
255: static void set_rx_mode(struct net_device *dev);
256:
257: static dev_info_t dev_info = "3c574_cs";
258:
259: static dev_link_t *tc574_attach(void);
260: static void tc574_detach(dev_link_t *);
261:
262: static dev_link_t *dev_list = NULL;
263:
264: static void flush_stale_links(void)
265: {
266: dev_link_t *link, *next;
267: for (link = dev_list; link; link = next) {
268: next = link->next;
269: if (link->state & DEV_STALE_LINK)
270: tc574_detach(link);
271: }
272: }
273:
274: static void cs_error(client_handle_t handle, int func, int ret)
275: {
276: #if CS_RELEASE_CODE < 0x2911
277: CardServices(ReportError, dev_info, (void *)func, (void *)ret);
278: #else
279: error_info_t err = { func, ret };
280: CardServices(ReportError, handle, &err);
281: #endif
282: }
283:
284: /*
285: tc574_attach() creates an "instance" of the driver, allocating
286: local data structures for one device. The device is registered
287: with Card Services.
288: */
289:
290: static dev_link_t *tc574_attach(void)
291: {
292: struct el3_private *lp;
293: client_reg_t client_reg;
294: dev_link_t *link;
295: struct net_device *dev;
296: int i, ret;
297:
298: DEBUG(0, "3c574_attach()\n");
299: flush_stale_links();
300:
301: /* Create the PC card device object. */
302: lp = kmalloc(sizeof(*lp), GFP_KERNEL);
303: if (!lp) return NULL;
304: memset(lp, 0, sizeof(*lp));
305: link = &lp->link; dev = &lp->dev;
306: link->priv = dev->priv = link->irq.Instance = lp;
307:
308: init_timer(&link->release);
309: link->release.function = &tc574_release;
310: link->release.data = (u_long)link;
311: link->io.NumPorts1 = 32;
312: link->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
313: link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
314: link->irq.IRQInfo1 = IRQ_INFO2_VALID|IRQ_LEVEL_ID;
315: if (irq_list[0] == -1)
316: link->irq.IRQInfo2 = irq_mask;
317: else
318: for (i = 0; i < 4; i++)
319: link->irq.IRQInfo2 |= 1 << irq_list[i];
320: link->irq.Handler = &el3_interrupt;
321: link->conf.Attributes = CONF_ENABLE_IRQ;
322: link->conf.Vcc = 50;
323: link->conf.IntType = INT_MEMORY_AND_IO;
324: link->conf.ConfigIndex = 1;
325: link->conf.Present = PRESENT_OPTION;
326:
327: /* The EL3-specific entries in the device structure. */
328: dev->hard_start_xmit = &el3_start_xmit;
329: dev->get_stats = &el3_get_stats;
330: dev->do_ioctl = &el3_ioctl;
331: dev->set_multicast_list = &set_rx_mode;
332: ether_setup(dev);
333: init_dev_name(dev, lp->node);
334: dev->open = &el3_open;
335: dev->stop = &el3_close;
336: #ifdef HAVE_TX_TIMEOUT
337: dev->tx_timeout = el3_tx_timeout;
338: dev->watchdog_timeo = TX_TIMEOUT;
339: #endif
340:
341: /* Register with Card Services */
342: link->next = dev_list;
343: dev_list = link;
344: client_reg.dev_info = &dev_info;
345: client_reg.Attributes = INFO_IO_CLIENT | INFO_CARD_SHARE;
346: client_reg.EventMask =
347: CS_EVENT_CARD_INSERTION | CS_EVENT_CARD_REMOVAL |
348: CS_EVENT_RESET_PHYSICAL | CS_EVENT_CARD_RESET |
349: CS_EVENT_PM_SUSPEND | CS_EVENT_PM_RESUME;
350: client_reg.event_handler = &tc574_event;
351: client_reg.Version = 0x0210;
352: client_reg.event_callback_args.client_data = link;
353: ret = CardServices(RegisterClient, &link->handle, &client_reg);
354: if (ret != 0) {
355: cs_error(link->handle, RegisterClient, ret);
356: tc574_detach(link);
357: return NULL;
358: }
359:
360: return link;
361: } /* tc574_attach */
362:
363: /*
364:
365: This deletes a driver "instance". The device is de-registered
366: with Card Services. If it has been released, all local data
367: structures are freed. Otherwise, the structures will be freed
368: when the device is released.
369:
370: */
371:
372: static void tc574_detach(dev_link_t *link)
373: {
374: struct el3_private *lp = link->priv;
375: dev_link_t **linkp;
376:
377: DEBUG(0, "3c574_detach(0x%p)\n", link);
378:
379: /* Locate device structure */
380: for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next)
381: if (*linkp == link) break;
382: if (*linkp == NULL)
383: return;
384:
385: del_timer(&link->release);
386: if (link->state & DEV_CONFIG) {
387: tc574_release((u_long)link);
388: if (link->state & DEV_STALE_CONFIG) {
389: link->state |= DEV_STALE_LINK;
390: return;
391: }
392: }
393:
394: if (link->handle)
395: CardServices(DeregisterClient, link->handle);
396:
397: /* Unlink device structure, free bits */
398: *linkp = link->next;
399: if (link->dev)
400: unregister_netdev(&lp->dev);
401: kfree(lp);
402:
403: } /* tc574_detach */
404:
405: /*
406: tc574_config() is scheduled to run after a CARD_INSERTION event
407: is received, to configure the PCMCIA socket, and to make the
408: ethernet device available to the system.
409: */
410:
411: #define CS_CHECK(fn, args...) \
412: while ((last_ret=CardServices(last_fn=(fn), args))!=0) goto cs_failed
413:
414: static void tc574_config(dev_link_t *link)
415: {
416: client_handle_t handle = link->handle;
417: struct el3_private *lp = link->priv;
418: struct net_device *dev = &lp->dev;
419: tuple_t tuple;
420: cisparse_t parse;
421: u_short buf[32];
422: int last_fn, last_ret, i, j;
423: ioaddr_t ioaddr;
424: u16 *phys_addr;
425: char *cardname;
426:
427: phys_addr = (u16 *)dev->dev_addr;
428:
429: DEBUG(0, "3c574_config(0x%p)\n", link);
430:
431: tuple.Attributes = 0;
432: tuple.DesiredTuple = CISTPL_CONFIG;
433: CS_CHECK(GetFirstTuple, handle, &tuple);
434: tuple.TupleData = (cisdata_t *)buf;
435: tuple.TupleDataMax = 64;
436: tuple.TupleOffset = 0;
437: CS_CHECK(GetTupleData, handle, &tuple);
438: CS_CHECK(ParseTuple, handle, &tuple, &parse);
439: link->conf.ConfigBase = parse.config.base;
440: link->conf.Present = parse.config.rmask[0];
441:
442: /* Configure card */
443: link->state |= DEV_CONFIG;
444:
445: link->io.IOAddrLines = 16;
446: for (i = j = 0; j < 0x400; j += 0x20) {
447: link->io.BasePort1 = j ^ 0x300;
448: i = CardServices(RequestIO, link->handle, &link->io);
449: if (i == CS_SUCCESS) break;
450: }
451: if (i != CS_SUCCESS) {
452: cs_error(link->handle, RequestIO, i);
453: goto failed;
454: }
455: CS_CHECK(RequestIRQ, link->handle, &link->irq);
456: CS_CHECK(RequestConfiguration, link->handle, &link->conf);
457:
458: dev->irq = link->irq.AssignedIRQ;
459: dev->base_addr = link->io.BasePort1;
460:
461: if (register_netdev(dev) != 0) {
462: printk(KERN_NOTICE "3c574_cs: register_netdev() failed\n");
463: goto failed;
464: }
465:
466: ioaddr = dev->base_addr;
467: copy_dev_name(lp->node, dev);
468: link->dev = &lp->node;
469:
470: /* The 3c574 normally uses an EEPROM for configuration info, including
471: the hardware address. The future products may include a modem chip
472: and put the address in the CIS. */
473: tuple.DesiredTuple = 0x88;
474: if (CardServices(GetFirstTuple, handle, &tuple) == CS_SUCCESS) {
475: CardServices(GetTupleData, handle, &tuple);
476: for (i = 0; i < 3; i++)
477: phys_addr[i] = htons(buf[i]);
478: } else {
479: EL3WINDOW(0);
480: for (i = 0; i < 3; i++)
481: phys_addr[i] = htons(read_eeprom(ioaddr, i + 10));
482: if (phys_addr[0] == 0x6060) {
483: printk(KERN_NOTICE "3c574_cs: IO port conflict at 0x%03lx"
484: "-0x%03lx\n", dev->base_addr, dev->base_addr+15);
485: goto failed;
486: }
487: }
488: tuple.DesiredTuple = CISTPL_VERS_1;
489: if (CardServices(GetFirstTuple, handle, &tuple) == CS_SUCCESS &&
490: CardServices(GetTupleData, handle, &tuple) == CS_SUCCESS &&
491: CardServices(ParseTuple, handle, &tuple, &parse) == CS_SUCCESS) {
492: cardname = parse.version_1.str + parse.version_1.ofs[1];
493: } else
494: cardname = "3Com 3c574";
495:
496: printk(KERN_INFO "%s: %s at io %#3lx, irq %d, hw_addr ",
497: dev->name, cardname, dev->base_addr, dev->irq);
498:
499: for (i = 0; i < 6; i++)
500: printk("%02X%s", dev->dev_addr[i], ((i<5) ? ":" : ".\n"));
501:
502: {
503: u_char mcr, *ram_split[] = {"5:3", "3:1", "1:1", "3:5"};
504: union wn3_config config;
505: outw(2<<11, ioaddr + RunnerRdCtrl);
506: mcr = inb(ioaddr + 2);
507: outw(0<<11, ioaddr + RunnerRdCtrl);
508: printk(KERN_INFO " ASIC rev %d,", mcr>>3);
509: EL3WINDOW(3);
510: config.i = inl(ioaddr + Wn3_Config);
511: printk(" %dK FIFO split %s Rx:Tx, %sMII interface.\n",
512: 8 << config.u.ram_size, ram_split[config.u.ram_split],
513: config.u.autoselect ? "autoselect " : "");
514: lp->default_media = config.u.xcvr;
515: lp->autoselect = config.u.autoselect;
516: }
517:
518: {
519: int phy;
520:
521: /* Roadrunner only: Turn on the MII transceiver */
522: outw(0x8040, ioaddr + Wn3_Options);
523: mdelay(1);
524: outw(0xc040, ioaddr + Wn3_Options);
525: tc574_wait_for_completion(dev, TxReset);
526: tc574_wait_for_completion(dev, RxReset);
527: mdelay(1);
528: outw(0x8040, ioaddr + Wn3_Options);
529:
530: EL3WINDOW(4);
531: for (phy = 1; phy <= 32; phy++) {
532: int mii_status;
533: mdio_sync(ioaddr, 32);
534: mii_status = mdio_read(ioaddr, phy & 0x1f, 1);
535: if (mii_status != 0xffff) {
536: lp->phys = phy & 0x1f;
537: DEBUG(0, " MII transceiver at index %d, status %x.\n",
538: phy, mii_status);
539: if ((mii_status & 0x0040) == 0)
540: mii_preamble_required = 1;
541: break;
542: }
543: }
544: if (phy > 32) {
545: printk(KERN_NOTICE " No MII transceivers found!\n");
546: goto failed;
547: }
548: i = mdio_read(ioaddr, lp->phys, 16) | 0x40;
549: mdio_write(ioaddr, lp->phys, 16, i);
550: lp->advertising = mdio_read(ioaddr, lp->phys, 4);
551: if (full_duplex) {
552: /* Only advertise the FD media types. */
553: lp->advertising &= ~0x02a0;
554: mdio_write(ioaddr, lp->phys, 4, lp->advertising);
555: }
556: }
557:
558: link->state &= ~DEV_CONFIG_PENDING;
559: return;
560:
561: cs_failed:
562: cs_error(link->handle, last_fn, last_ret);
563: failed:
564: tc574_release((u_long)link);
565: link->state &= ~DEV_CONFIG_PENDING;
566: return;
567:
568: } /* tc574_config */
569:
570: /*
571: After a card is removed, tc574_release() will unregister the net
572: device, and release the PCMCIA configuration. If the device is
573: still open, this will be postponed until it is closed.
574: */
575:
576: static void tc574_release(u_long arg)
577: {
578: dev_link_t *link = (dev_link_t *)arg;
579:
580: DEBUG(0, "3c574_release(0x%p)\n", link);
581:
582: if (link->open) {
583: DEBUG(1, "3c574_cs: release postponed, '%s' still open\n",
584: link->dev->dev_name);
585: link->state |= DEV_STALE_CONFIG;
586: return;
587: }
588:
589: CardServices(ReleaseConfiguration, link->handle);
590: CardServices(ReleaseIO, link->handle, &link->io);
591: CardServices(ReleaseIRQ, link->handle, &link->irq);
592:
593: link->state &= ~DEV_CONFIG;
594:
595: } /* tc574_release */
596:
597: /*
598: The card status event handler. Mostly, this schedules other
599: stuff to run after an event is received. A CARD_REMOVAL event
600: also sets some flags to discourage the net drivers from trying
601: to talk to the card any more.
602: */
603:
604: static int tc574_event(event_t event, int priority,
605: event_callback_args_t *args)
606: {
607: dev_link_t *link = args->client_data;
608: struct el3_private *lp = link->priv;
609: struct net_device *dev = &lp->dev;
610:
611: DEBUG(1, "3c574_event(0x%06x)\n", event);
612:
613: switch (event) {
614: case CS_EVENT_CARD_REMOVAL:
615: link->state &= ~DEV_PRESENT;
616: if (link->state & DEV_CONFIG) {
617: netif_device_detach(dev);
618: mod_timer(&link->release, jiffies + HZ/20);
619: }
620: break;
621: case CS_EVENT_CARD_INSERTION:
622: link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
623: tc574_config(link);
624: break;
625: case CS_EVENT_PM_SUSPEND:
626: link->state |= DEV_SUSPEND;
627: /* Fall through... */
628: case CS_EVENT_RESET_PHYSICAL:
629: if (link->state & DEV_CONFIG) {
630: if (link->open)
631: netif_device_detach(dev);
632: CardServices(ReleaseConfiguration, link->handle);
633: }
634: break;
635: case CS_EVENT_PM_RESUME:
636: link->state &= ~DEV_SUSPEND;
637: /* Fall through... */
638: case CS_EVENT_CARD_RESET:
639: if (link->state & DEV_CONFIG) {
640: CardServices(RequestConfiguration, link->handle, &link->conf);
641: if (link->open) {
642: tc574_reset(dev);
643: netif_device_attach(dev);
644: }
645: }
646: break;
647: }
648: return 0;
649: } /* tc574_event */
650:
651: static void dump_status(struct net_device *dev)
652: {
653: ioaddr_t ioaddr = dev->base_addr;
654: EL3WINDOW(1);
655: printk(KERN_INFO " irq status %04x, rx status %04x, tx status "
656: "%02x, tx free %04x\n", inw(ioaddr+EL3_STATUS),
657: inw(ioaddr+RxStatus), inb(ioaddr+TxStatus),
658: inw(ioaddr+TxFree));
659: EL3WINDOW(4);
660: printk(KERN_INFO " diagnostics: fifo %04x net %04x ethernet %04x"
661: " media %04x\n", inw(ioaddr+0x04), inw(ioaddr+0x06),
662: inw(ioaddr+0x08), inw(ioaddr+0x0a));
663: EL3WINDOW(1);
664: }
665:
666: /*
667: Use this for commands that may take time to finish
668: */
669: static void tc574_wait_for_completion(struct net_device *dev, int cmd)
670: {
671: int i = 1500;
672: outw(cmd, dev->base_addr + EL3_CMD);
673: while (--i > 0)
674: if (!(inw(dev->base_addr + EL3_STATUS) & 0x1000)) break;
675: if (i == 0)
676: printk(KERN_NOTICE "%s: command 0x%04x did not complete!\n",
677: dev->name, cmd);
678: }
679:
680: /* Read a word from the EEPROM using the regular EEPROM access register.
681: Assume that we are in register window zero.
682: */
683: static u_short read_eeprom(ioaddr_t ioaddr, int index)
684: {
685: int timer;
686: outw(EEPROM_Read + index, ioaddr + Wn0EepromCmd);
687: /* Pause for at least 162 usec for the read to take place. */
688: for (timer = 1620; timer >= 0; timer--) {
689: if ((inw(ioaddr + Wn0EepromCmd) & 0x8000) == 0)
690: break;
691: }
692: return inw(ioaddr + Wn0EepromData);
693: }
694:
695: /* MII transceiver control section.
696: Read and write the MII registers using software-generated serial
697: MDIO protocol. See the MII specifications or DP83840A data sheet
698: for details.
699: The maxium data clock rate is 2.5 Mhz. The timing is easily met by the
700: slow PC card interface. */
701:
702: #define MDIO_SHIFT_CLK 0x01
703: #define MDIO_DIR_WRITE 0x04
704: #define MDIO_DATA_WRITE0 (0x00 | MDIO_DIR_WRITE)
705: #define MDIO_DATA_WRITE1 (0x02 | MDIO_DIR_WRITE)
706: #define MDIO_DATA_READ 0x02
707: #define MDIO_ENB_IN 0x00
708:
709: /* Generate the preamble required for initial synchronization and
710: a few older transceivers. */
711: static void mdio_sync(ioaddr_t ioaddr, int bits)
712: {
713: int mdio_addr = ioaddr + Wn4_PhysicalMgmt;
714:
715: /* Establish sync by sending at least 32 logic ones. */
716: while (-- bits >= 0) {
717: outw(MDIO_DATA_WRITE1, mdio_addr);
718: outw(MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, mdio_addr);
719: }
720: }
721:
722: static int mdio_read(ioaddr_t ioaddr, int phy_id, int location)
723: {
724: int i;
725: int read_cmd = (0xf6 << 10) | (phy_id << 5) | location;
726: unsigned int retval = 0;
727: int mdio_addr = ioaddr + Wn4_PhysicalMgmt;
728:
729: if (mii_preamble_required)
730: mdio_sync(ioaddr, 32);
731:
732: /* Shift the read command bits out. */
733: for (i = 14; i >= 0; i--) {
734: int dataval = (read_cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
735: outw(dataval, mdio_addr);
736: outw(dataval | MDIO_SHIFT_CLK, mdio_addr);
737: }
738: /* Read the two transition, 16 data, and wire-idle bits. */
739: for (i = 19; i > 0; i--) {
740: outw(MDIO_ENB_IN, mdio_addr);
741: retval = (retval << 1) | ((inw(mdio_addr) & MDIO_DATA_READ) ? 1 : 0);
742: outw(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
743: }
744: return (retval>>1) & 0xffff;
745: }
746:
747: static void mdio_write(ioaddr_t ioaddr, int phy_id, int location, int value)
748: {
749: int write_cmd = 0x50020000 | (phy_id << 23) | (location << 18) | value;
750: int mdio_addr = ioaddr + Wn4_PhysicalMgmt;
751: int i;
752:
753: if (mii_preamble_required)
754: mdio_sync(ioaddr, 32);
755:
756: /* Shift the command bits out. */
757: for (i = 31; i >= 0; i--) {
758: int dataval = (write_cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
759: outw(dataval, mdio_addr);
760: outw(dataval | MDIO_SHIFT_CLK, mdio_addr);
761: }
762: /* Leave the interface idle. */
763: for (i = 1; i >= 0; i--) {
764: outw(MDIO_ENB_IN, mdio_addr);
765: outw(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
766: }
767:
768: return;
769: }
770:
771: /* Reset and restore all of the 3c574 registers. */
772: static void tc574_reset(struct net_device *dev)
773: {
774: struct el3_private *lp = (struct el3_private *)dev->priv;
775: int i, ioaddr = dev->base_addr;
776:
777: tc574_wait_for_completion(dev, TotalReset|0x10);
778:
779: /* Clear any transactions in progress. */
780: outw(0, ioaddr + RunnerWrCtrl);
781: outw(0, ioaddr + RunnerRdCtrl);
782:
783: /* Set the station address and mask. */
784: EL3WINDOW(2);
785: for (i = 0; i < 6; i++)
786: outb(dev->dev_addr[i], ioaddr + i);
787: for (; i < 12; i+=2)
788: outw(0, ioaddr + i);
789:
790: /* Reset config options */
791: EL3WINDOW(3);
792: outb((dev->mtu > 1500 ? 0x40 : 0), ioaddr + Wn3_MAC_Ctrl);
793: outl((lp->autoselect ? 0x01000000 : 0) | 0x0062001b,
794: ioaddr + Wn3_Config);
795:
796: /* Roadrunner only: Turn on the MII transceiver. */
797: outw(0x8040, ioaddr + Wn3_Options);
798: mdelay(1);
799: outw(0xc040, ioaddr + Wn3_Options);
800: tc574_wait_for_completion(dev, TxReset);
801: tc574_wait_for_completion(dev, RxReset);
802: mdelay(1);
803: outw(0x8040, ioaddr + Wn3_Options);
804:
805: /* Switch to the stats window, and clear all stats by reading. */
806: outw(StatsDisable, ioaddr + EL3_CMD);
807: EL3WINDOW(6);
808: for (i = 0; i < 10; i++)
809: inb(ioaddr + i);
810: inw(ioaddr + 10);
811: inw(ioaddr + 12);
812: EL3WINDOW(4);
813: inb(ioaddr + 12);
814: inb(ioaddr + 13);
815:
816: /* .. enable any extra statistics bits.. */
817: outw(0x0040, ioaddr + Wn4_NetDiag);
818: /* .. re-sync MII and re-fill what NWay is advertising. */
819: mdio_sync(ioaddr, 32);
820: mdio_write(ioaddr, lp->phys, 4, lp->advertising);
821: if (!auto_polarity) {
822: /* works for TDK 78Q2120 series MII's */
823: int i = mdio_read(ioaddr, lp->phys, 16) | 0x20;
824: mdio_write(ioaddr, lp->phys, 16, i);
825: }
826:
827: /* Switch to register set 1 for normal use, just for TxFree. */
828: EL3WINDOW(1);
829:
830: set_rx_mode(dev);
831: outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
832: outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
833: outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
834: /* Allow status bits to be seen. */
835: outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
836: /* Ack all pending events, and set active indicator mask. */
837: outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
838: ioaddr + EL3_CMD);
839: outw(SetIntrEnb | IntLatch | TxAvailable | RxComplete | StatsFull
840: | AdapterFailure | RxEarly, ioaddr + EL3_CMD);
841: }
842:
843: static int el3_open(struct net_device *dev)
844: {
845: struct el3_private *lp = (struct el3_private *)dev->priv;
846: dev_link_t *link = &lp->link;
847:
848: if (!DEV_OK(link))
849: return -ENODEV;
850:
851: link->open++;
852: MOD_INC_USE_COUNT;
853: netif_start_queue(dev);
854: netif_mark_up(dev);
855:
856: tc574_reset(dev);
857: lp->media.function = &media_check;
858: lp->media.data = (u_long)lp;
859: lp->media.expires = jiffies + HZ;
860: add_timer(&lp->media);
861:
862: DEBUG(2, "%s: opened, status %4.4x.\n",
863: dev->name, inw(dev->base_addr + EL3_STATUS));
864:
865: return 0;
866: }
867:
868: static void el3_tx_timeout(struct net_device *dev)
869: {
870: struct el3_private *lp = (struct el3_private *)dev->priv;
871: ioaddr_t ioaddr = dev->base_addr;
872:
873: printk(KERN_NOTICE "%s: Transmit timed out!\n", dev->name);
874: dump_status(dev);
875: lp->stats.tx_errors++;
876: dev->trans_start = jiffies;
877: /* Issue TX_RESET and TX_START commands. */
878: tc574_wait_for_completion(dev, TxReset);
879: outw(TxEnable, ioaddr + EL3_CMD);
880: netif_wake_queue(dev);
881: }
882:
883: static void pop_tx_status(struct net_device *dev)
884: {
885: struct el3_private *lp = (struct el3_private *)dev->priv;
886: ioaddr_t ioaddr = dev->base_addr;
887: int i;
888:
889: /* Clear the Tx status stack. */
890: for (i = 32; i > 0; i--) {
891: u_char tx_status = inb(ioaddr + TxStatus);
892: if (!(tx_status & 0x84)) break;
893: /* reset transmitter on jabber error or underrun */
894: if (tx_status & 0x30)
895: tc574_wait_for_completion(dev, TxReset);
896: if (tx_status & 0x38) {
897: DEBUG(1, "%s: transmit error: status 0x%02x\n",
898: dev->name, tx_status);
899: outw(TxEnable, ioaddr + EL3_CMD);
900: lp->stats.tx_aborted_errors++;
901: }
902: outb(0x00, ioaddr + TxStatus); /* Pop the status stack. */
903: }
904: }
905:
906: static int el3_start_xmit(struct sk_buff *skb, struct net_device *dev)
907: {
908: ioaddr_t ioaddr = dev->base_addr;
909:
910: tx_timeout_check(dev, el3_tx_timeout);
911: skb_tx_check(dev, skb);
912:
913: DEBUG(3, "%s: el3_start_xmit(length = %ld) called, "
914: "status %4.4x.\n", dev->name, (long)skb->len,
915: inw(ioaddr + EL3_STATUS));
916:
917: outw(skb->len, ioaddr + TX_FIFO);
918: outw(0, ioaddr + TX_FIFO);
919: outsl(ioaddr + TX_FIFO, skb->data, (skb->len+3)>>2);
920:
921: dev->trans_start = jiffies;
922:
923: /* TxFree appears only in Window 1, not offset 0x1c. */
924: if (inw(ioaddr + TxFree) > 1536) {
925: netif_start_queue(dev);
926: } else
927: /* Interrupt us when the FIFO has room for max-sized packet.
928: The threshold is in units of dwords. */
929: outw(SetTxThreshold + (1536>>2), ioaddr + EL3_CMD);
930:
931: DEV_KFREE_SKB (skb);
932: pop_tx_status(dev);
933:
934: return 0;
935: }
936:
937: /* The EL3 interrupt handler. */
938: static void el3_interrupt(int irq, void *dev_id, struct pt_regs *regs)
939: {
940: struct el3_private *lp = dev_id;
941: struct net_device *dev = &lp->dev;
942: ioaddr_t ioaddr, status;
943: int work_budget = max_interrupt_work;
944:
945: if (!netif_device_present(dev))
946: return;
947: ioaddr = dev->base_addr;
948:
949: DEBUG(3, "%s: interrupt, status %4.4x.\n",
950: dev->name, inw(ioaddr + EL3_STATUS));
951:
952: while ((status = inw(ioaddr + EL3_STATUS)) &
953: (IntLatch | RxComplete | RxEarly | StatsFull)) {
954: if (!netif_device_present(dev) ||
955: ((status & 0xe000) != 0x2000)) {
956: DEBUG(1, "%s: Interrupt from dead card\n", dev->name);
957: break;
958: }
959:
960: if (status & RxComplete)
961: work_budget = el3_rx(dev, work_budget);
962:
963: if (status & TxAvailable) {
964: DEBUG(3, " TX room bit was handled.\n");
965: /* There's room in the FIFO for a full-sized packet. */
966: outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
967: netif_wake_queue(dev);
968: }
969:
970: if (status & TxComplete)
971: pop_tx_status(dev);
972:
973: if (status & (AdapterFailure | RxEarly | StatsFull)) {
974: /* Handle all uncommon interrupts. */
975: if (status & StatsFull)
976: update_stats(dev);
977: if (status & RxEarly) {
978: work_budget = el3_rx(dev, work_budget);
979: outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
980: }
981: if (status & AdapterFailure) {
982: u16 fifo_diag;
983: EL3WINDOW(4);
984: fifo_diag = inw(ioaddr + Wn4_FIFODiag);
985: EL3WINDOW(1);
986: printk(KERN_NOTICE "%s: adapter failure, FIFO diagnostic"
987: " register %04x.\n", dev->name, fifo_diag);
988: if (fifo_diag & 0x0400) {
989: /* Tx overrun */
990: tc574_wait_for_completion(dev, TxReset);
991: outw(TxEnable, ioaddr + EL3_CMD);
992: }
993: if (fifo_diag & 0x2000) {
994: /* Rx underrun */
995: tc574_wait_for_completion(dev, RxReset);
996: set_rx_mode(dev);
997: outw(RxEnable, ioaddr + EL3_CMD);
998: }
999: outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
1000: }
1001: }
1002:
1003: if (--work_budget < 0) {
1004: DEBUG(0, "%s: Too much work in interrupt, "
1005: "status %4.4x.\n", dev->name, status);
1006: /* Clear all interrupts */
1007: outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
1008: break;
1009: }
1010: /* Acknowledge the IRQ. */
1011: outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
1012: }
1013:
1014: DEBUG(3, "%s: exiting interrupt, status %4.4x.\n",
1015: dev->name, inw(ioaddr + EL3_STATUS));
1016: return;
1017: }
1018:
1019: /*
1020: This timer serves two purposes: to check for missed interrupts
1021: (and as a last resort, poll the NIC for events), and to monitor
1022: the MII, reporting changes in cable status.
1023: */
1024: static void media_check(u_long arg)
1025: {
1026: struct el3_private *lp = (struct el3_private *)arg;
1027: struct net_device *dev = &lp->dev;
1028: ioaddr_t ioaddr = dev->base_addr;
1029: u_long flags;
1030: u_short /* cable, */ media, partner;
1031:
1032: if (!netif_device_present(dev))
1033: goto reschedule;
1034:
1035: /* Check for pending interrupt with expired latency timer: with
1036: this, we can limp along even if the interrupt is blocked */
1037: if ((inw(ioaddr + EL3_STATUS) & IntLatch) &&
1038: (inb(ioaddr + Timer) == 0xff)) {
1039: if (!lp->fast_poll)
1040: printk(KERN_INFO "%s: interrupt(s) dropped!\n", dev->name);
1041: el3_interrupt(dev->irq, lp, NULL);
1042: lp->fast_poll = HZ;
1043: }
1044: if (lp->fast_poll) {
1045: lp->fast_poll--;
1046: lp->media.expires = jiffies + 2;
1047: add_timer(&lp->media);
1048: return;
1049: }
1050:
1051: save_flags(flags);
1052: cli();
1053: #if 0
1054: outw(2<<11, ioaddr + RunnerRdCtrl);
1055: cable = inb(ioaddr);
1056: outb(0x20, ioaddr);
1057: outw(0, ioaddr + RunnerRdCtrl);
1058: #endif
1059: EL3WINDOW(4);
1060: media = mdio_read(ioaddr, lp->phys, 1);
1061: partner = mdio_read(ioaddr, lp->phys, 5);
1062: EL3WINDOW(1);
1063: restore_flags(flags);
1064:
1065: #if 0
1066: if (cable & 0x20)
1067: printk(KERN_INFO "%s: cable %s\n", dev->name,
1068: ((cable & 0x08) ? "fixed" : "problem"));
1069: #endif
1070: if (media != lp->media_status) {
1071: if ((media ^ lp->media_status) & 0x0004)
1072: printk(KERN_INFO "%s: %s link beat\n", dev->name,
1073: (lp->media_status & 0x0004) ? "lost" : "found");
1074: if ((media ^ lp->media_status) & 0x0020) {
1075: lp->partner = 0;
1076: if (lp->media_status & 0x0020) {
1077: printk(KERN_INFO "%s: autonegotiation restarted\n",
1078: dev->name);
1079: } else if (partner) {
1080: partner &= lp->advertising;
1081: lp->partner = partner;
1082: printk(KERN_INFO "%s: autonegotiation complete: "
1083: "%sbaseT-%cD selected\n", dev->name,
1084: ((partner & 0x0180) ? "100" : "10"),
1085: ((partner & 0x0140) ? 'F' : 'H'));
1086: } else {
1087: printk(KERN_INFO "%s: link partner did not autonegotiate\n",
1088: dev->name);
1089: }
1090:
1091: EL3WINDOW(3);
1092: outb((partner & 0x0140 ? 0x20 : 0) |
1093: (dev->mtu > 1500 ? 0x40 : 0), ioaddr + Wn3_MAC_Ctrl);
1094: EL3WINDOW(1);
1095:
1096: }
1097: if (media & 0x0010)
1098: printk(KERN_INFO "%s: remote fault detected\n",
1099: dev->name);
1100: if (media & 0x0002)
1101: printk(KERN_INFO "%s: jabber detected\n", dev->name);
1102: lp->media_status = media;
1103: }
1104:
1105: reschedule:
1106: lp->media.expires = jiffies + HZ;
1107: add_timer(&lp->media);
1108: }
1109:
1110: static struct net_device_stats *el3_get_stats(struct net_device *dev)
1111: {
1112: struct el3_private *lp = (struct el3_private *)dev->priv;
1113:
1114: if (netif_device_present(dev))
1115: update_stats(dev);
1116: return &lp->stats;
1117: }
1118:
1119: /* Update statistics.
1120: Suprisingly this need not be run single-threaded, but it effectively is.
1121: The counters clear when read, so the adds must merely be atomic.
1122: */
1123: static void update_stats(struct net_device *dev)
1124: {
1125: struct el3_private *lp = (struct el3_private *)dev->priv;
1126: ioaddr_t ioaddr = dev->base_addr;
1127: u8 rx, tx, up;
1128:
1129: DEBUG(2, "%s: updating the statistics.\n", dev->name);
1130:
1131: if (inw(ioaddr+EL3_STATUS) == 0xffff) /* No card. */
1132: return;
1133:
1134: /* Unlike the 3c509 we need not turn off stats updates while reading. */
1135: /* Switch to the stats window, and read everything. */
1136: EL3WINDOW(6);
1137: lp->stats.tx_carrier_errors += inb(ioaddr + 0);
1138: lp->stats.tx_heartbeat_errors += inb(ioaddr + 1);
1139: /* Multiple collisions. */ inb(ioaddr + 2);
1140: lp->stats.collisions += inb(ioaddr + 3);
1141: lp->stats.tx_window_errors += inb(ioaddr + 4);
1142: lp->stats.rx_fifo_errors += inb(ioaddr + 5);
1143: lp->stats.tx_packets += inb(ioaddr + 6);
1144: up = inb(ioaddr + 9);
1145: lp->stats.tx_packets += (up&0x30) << 4;
1146: /* Rx packets */ inb(ioaddr + 7);
1147: /* Tx deferrals */ inb(ioaddr + 8);
1148: rx = inw(ioaddr + 10);
1149: tx = inw(ioaddr + 12);
1150:
1151: EL3WINDOW(4);
1152: /* BadSSD */ inb(ioaddr + 12);
1153: up = inb(ioaddr + 13);
1154:
1155: add_tx_bytes(&lp->stats, tx + ((up & 0xf0) << 12));
1156:
1157: EL3WINDOW(1);
1158: }
1159:
1160: static int el3_rx(struct net_device *dev, int worklimit)
1161: {
1162: struct el3_private *lp = (struct el3_private *)dev->priv;
1163: ioaddr_t ioaddr = dev->base_addr;
1164: short rx_status;
1165:
1166: DEBUG(3, "%s: in rx_packet(), status %4.4x, rx_status %4.4x.\n",
1167: dev->name, inw(ioaddr+EL3_STATUS), inw(ioaddr+RxStatus));
1168: while (!((rx_status = inw(ioaddr + RxStatus)) & 0x8000) &&
1169: (--worklimit >= 0)) {
1170: if (rx_status & 0x4000) { /* Error, update stats. */
1171: short error = rx_status & 0x3800;
1172: lp->stats.rx_errors++;
1173: switch (error) {
1174: case 0x0000: lp->stats.rx_over_errors++; break;
1175: case 0x0800: lp->stats.rx_length_errors++; break;
1176: case 0x1000: lp->stats.rx_frame_errors++; break;
1177: case 0x1800: lp->stats.rx_length_errors++; break;
1178: case 0x2000: lp->stats.rx_frame_errors++; break;
1179: case 0x2800: lp->stats.rx_crc_errors++; break;
1180: }
1181: } else {
1182: short pkt_len = rx_status & 0x7ff;
1183: struct sk_buff *skb;
1184:
1185: skb = dev_alloc_skb(pkt_len+5);
1186:
1187: DEBUG(3, " Receiving packet size %d status %4.4x.\n",
1188: pkt_len, rx_status);
1189: if (skb != NULL) {
1190: skb->dev = dev;
1191: skb_reserve(skb, 2);
1192: insl(ioaddr+RX_FIFO, skb_put(skb, pkt_len),
1193: ((pkt_len+3)>>2));
1194: skb->protocol = eth_type_trans(skb, dev);
1195: netif_rx(skb);
1196: dev->last_rx = jiffies;
1197: lp->stats.rx_packets++;
1198: add_rx_bytes(&lp->stats, pkt_len);
1199: } else {
1200: DEBUG(1, "%s: couldn't allocate a sk_buff of"
1201: " size %d.\n", dev->name, pkt_len);
1202: lp->stats.rx_dropped++;
1203: }
1204: }
1205: tc574_wait_for_completion(dev, RxDiscard);
1206: }
1207:
1208: return worklimit;
1209: }
1210:
1211: /* Provide ioctl() calls to examine the MII xcvr state. */
1212: static int el3_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1213: {
1214: struct el3_private *lp = (struct el3_private *)dev->priv;
1215: ioaddr_t ioaddr = dev->base_addr;
1216: u16 *data = (u16 *)&rq->ifr_data;
1217: int phy = lp->phys & 0x1f;
1218:
1219: DEBUG(2, "%s: In ioct(%-.6s, %#4.4x) %4.4x %4.4x %4.4x %4.4x.\n",
1220: dev->name, rq->ifr_ifrn.ifrn_name, cmd,
1221: data[0], data[1], data[2], data[3]);
1222:
1223: switch(cmd) {
1224: case SIOCDEVPRIVATE: /* Get the address of the PHY in use. */
1225: data[0] = phy;
1226: case SIOCDEVPRIVATE+1: /* Read the specified MII register. */
1227: {
1228: int saved_window;
1229: long flags;
1230:
1231: save_flags(flags);
1232: cli();
1233: saved_window = inw(ioaddr + EL3_CMD) >> 13;
1234: EL3WINDOW(4);
1235: data[3] = mdio_read(ioaddr, data[0] & 0x1f, data[1] & 0x1f);
1236: EL3WINDOW(saved_window);
1237: restore_flags(flags);
1238: return 0;
1239: }
1240: case SIOCDEVPRIVATE+2: /* Write the specified MII register */
1241: {
1242: int saved_window;
1243: long flags;
1244:
1245: if (!capable(CAP_NET_ADMIN))
1246: return -EPERM;
1247: save_flags(flags);
1248: cli();
1249: saved_window = inw(ioaddr + EL3_CMD) >> 13;
1250: EL3WINDOW(4);
1251: mdio_write(ioaddr, data[0] & 0x1f, data[1] & 0x1f, data[2]);
1252: EL3WINDOW(saved_window);
1253: restore_flags(flags);
1254: return 0;
1255: }
1256: default:
1257: return -EOPNOTSUPP;
1258: }
1259: }
1260:
1261: /* The Odie chip has a 64 bin multicast filter, but the bit layout is not
1262: documented. Until it is we revert to receiving all multicast frames when
1263: any multicast reception is desired.
1264: Note: My other drivers emit a log message whenever promiscuous mode is
1265: entered to help detect password sniffers. This is less desirable on
1266: typical PC card machines, so we omit the message.
1267: */
1268:
1269: static void set_rx_mode(struct net_device *dev)
1270: {
1271: ioaddr_t ioaddr = dev->base_addr;
1272:
1273: if (dev->flags & IFF_PROMISC)
1274: outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm,
1275: ioaddr + EL3_CMD);
1276: else if (dev->mc_count || (dev->flags & IFF_ALLMULTI))
1277: outw(SetRxFilter|RxStation|RxMulticast|RxBroadcast, ioaddr + EL3_CMD);
1278: else
1279: outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1280: }
1281:
1282: static int el3_close(struct net_device *dev)
1283: {
1284: ioaddr_t ioaddr = dev->base_addr;
1285: struct el3_private *lp = dev->priv;
1286: dev_link_t *link = &lp->link;
1287:
1288: DEBUG(2, "%s: shutting down ethercard.\n", dev->name);
1289:
1290: if (DEV_OK(link)) {
1291: /* Turn off statistics ASAP. We update lp->stats below. */
1292: outw(StatsDisable, ioaddr + EL3_CMD);
1293:
1294: /* Disable the receiver and transmitter. */
1295: outw(RxDisable, ioaddr + EL3_CMD);
1296: outw(TxDisable, ioaddr + EL3_CMD);
1297:
1298: /* Note: Switching to window 0 may disable the IRQ. */
1299: EL3WINDOW(0);
1300:
1301: update_stats(dev);
1302: }
1303:
1304: link->open--;
1305: netif_stop_queue(dev);
1306: netif_mark_down(dev);
1307: del_timer(&lp->media);
1308: if (link->state & DEV_STALE_CONFIG)
1309: mod_timer(&link->release, jiffies + HZ/20);
1310:
1311: MOD_DEC_USE_COUNT;
1312:
1313: return 0;
1314: }
1315:
1316: static int __init init_3c574_cs(void)
1317: {
1318: servinfo_t serv;
1319:
1320: DEBUG(0, "%s\n", version);
1321: CardServices(GetCardServicesInfo, &serv);
1322: if (serv.Revision != CS_RELEASE_CODE) {
1323: printk(KERN_NOTICE "3c574_cs: Card Services release "
1324: "does not match!\n");
1325: return -EINVAL;
1326: }
1327: register_pccard_driver(&dev_info, &tc574_attach, &tc574_detach);
1328: return 0;
1329: }
1330:
1331: static void __exit exit_3c574_cs(void)
1332: {
1333: DEBUG(0, "3c574_cs: unloading\n");
1334: unregister_pccard_driver(&dev_info);
1335: while (dev_list != NULL)
1336: tc574_detach(dev_list);
1337: }
1338:
1339: module_init(init_3c574_cs);
1340: module_exit(exit_3c574_cs);
1341:
1342: /*
1343: * Local variables:
1344: * compile-command: "make 3c574_cs.o"
1345: * c-indent-level: 4
1346: * c-basic-offset: 4
1347: * tab-width: 4
1348: * End:
1349: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.