![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to 3c59x.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / i386 / i386at / gpl / linux / net|
Return to 3c59x.c CVS log | Up to [GnuMach] / Gnu-Mach / i386 / i386at / gpl / linux / net |
1.1 root 1: /* 3c59x.c: A 3Com 3c590/3c595 "Vortex" ethernet driver for linux. */
2: /*
3: Written 1995 by Donald Becker.
4:
5: This software may be used and distributed according to the terms
6: of the GNU Public License, incorporated herein by reference.
7:
8: This driver is for the 3Com "Vortex" series ethercards. Members of
9: the series include the 3c590 PCI EtherLink III and 3c595-Tx PCI Fast
10: EtherLink. It also works with the 10Mbs-only 3c590 PCI EtherLink III.
11:
12: The author may be reached as [email protected], or C/O
13: Center of Excellence in Space Data and Information Sciences
14: Code 930.5, Goddard Space Flight Center, Greenbelt MD 20771
15: */
16:
17: static char *version = "3c59x.c:v0.13 2/13/96 [email protected]\n";
18:
19: /* "Knobs" that turn on special features. */
20: /* Allow the use of bus master transfers instead of programmed-I/O for the
21: Tx process. Bus master transfers are always disabled by default, but
22: iff this is set they may be turned on using 'options'. */
23: #define VORTEX_BUS_MASTER
24:
25: /* Put out somewhat more debugging messages. (0 - no msg, 1 minimal msgs). */
26: #define VORTEX_DEBUG 1
27:
28: #include <linux/module.h>
29:
30: #include <linux/kernel.h>
31: #include <linux/sched.h>
32: #include <linux/string.h>
33: #include <linux/ptrace.h>
34: #include <linux/errno.h>
35: #include <linux/in.h>
36: #include <linux/ioport.h>
37: #include <linux/malloc.h>
38: #include <linux/interrupt.h>
39: #include <linux/pci.h>
40: #include <linux/bios32.h>
41: #include <linux/timer.h>
42: #include <asm/bitops.h>
43: #include <asm/io.h>
44:
45: #include <linux/netdevice.h>
46: #include <linux/etherdevice.h>
47: #include <linux/skbuff.h>
48:
49: #ifdef HAVE_SHARED_IRQ
50: #define USE_SHARED_IRQ
51: #include <linux/shared_irq.h>
52: #endif
53:
54: /* The total size is twice that of the original EtherLinkIII series: the
55: runtime register window, window 1, is now always mapped in. */
56: #define VORTEX_TOTAL_SIZE 0x20
57:
58: #ifdef HAVE_DEVLIST
59: struct netdev_entry tc59x_drv =
60: {"Vortex", vortex_pci_probe, VORTEX_TOTAL_SIZE, NULL};
61: #endif
62:
63: #ifdef VORTEX_DEBUG
64: int vortex_debug = VORTEX_DEBUG;
65: #else
66: int vortex_debug = 1;
67: #endif
68:
69: static int product_ids[] = {0x5900, 0x5950, 0x5951, 0x5952, 0, 0};
70: static const char *product_names[] = {
71: "3c590 Vortex 10Mbps",
72: "3c595 Vortex 100baseTX",
73: "3c595 Vortex 100baseT4",
74: "3c595 Vortex 100base-MII",
75: "EISA Vortex 3c597",
76: };
77: #define DEMON_INDEX 5 /* Caution! Must be consistent with above! */
78:
79: /*
80: Theory of Operation
81:
82: I. Board Compatibility
83:
84: This device driver is designed for the 3Com FastEtherLink, 3Com's PCI to
85: 10/100baseT adapter. It also works with the 3c590, a similar product
86: with only a 10Mbs interface.
87:
88: II. Board-specific settings
89:
90: PCI bus devices are configured by the system at boot time, so no jumpers
91: need to be set on the board. The system BIOS should be set to assign the
92: PCI INTA signal to an otherwise unused system IRQ line. While it's
93: physically possible to shared PCI interrupt lines, the 1.2.0 kernel doesn't
94: support it.
95:
96: III. Driver operation
97:
98: The 3c59x series use an interface that's very similar to the previous 3c5x9
99: series. The primary interface is two programmed-I/O FIFOs, with an
100: alternate single-contiguous-region bus-master transfer (see next).
101:
102: One extension that is advertised in a very large font is that the adapters
103: are capable of being bus masters. Unfortunately this capability is only for
104: a single contiguous region making it less useful than the list of transfer
105: regions available with the DEC Tulip or AMD PCnet. Given the significant
106: performance impact of taking an extra interrupt for each transfer, using
107: DMA transfers is a win only with large blocks.
108:
109: IIIC. Synchronization
110: The driver runs as two independent, single-threaded flows of control. One
111: is the send-packet routine, which enforces single-threaded use by the
112: dev->tbusy flag. The other thread is the interrupt handler, which is single
113: threaded by the hardware and other software.
114:
115: IV. Notes
116:
117: Thanks to Cameron Spitzer and Terry Murphy of 3Com for providing both
118: 3c590 and 3c595 boards.
119: The name "Vortex" is the internal 3Com project name for the PCI ASIC, and
120: the not-yet-released (3/95) EISA version is called "Demon". According to
121: Terry these names come from rides at the local amusement park.
122:
123: The new chips support both ethernet (1.5K) and FDDI (4.5K) packet sizes!
124: This driver only supports ethernet packets because of the skbuff allocation
125: limit of 4K.
126: */
127:
128: #define TCOM_VENDOR_ID 0x10B7 /* 3Com's manufacturer's ID. */
129:
130: /* Operational defintions.
131: These are not used by other compilation units and thus are not
132: exported in a ".h" file.
133:
134: First the windows. There are eight register windows, with the command
135: and status registers available in each.
136: */
137: #define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
138: #define EL3_CMD 0x0e
139: #define EL3_STATUS 0x0e
140:
141: /* The top five bits written to EL3_CMD are a command, the lower
142: 11 bits are the parameter, if applicable.
143: Note that 11 parameters bits was fine for ethernet, but the new chip
144: can handle FDDI lenght frames (~4500 octets) and now parameters count
145: 32-bit 'Dwords' rather than octets. */
146:
147: enum vortex_cmd {
148: TotalReset = 0<<11, SelectWindow = 1<<11, StartCoax = 2<<11,
149: RxDisable = 3<<11, RxEnable = 4<<11, RxReset = 5<<11, RxDiscard = 8<<11,
150: TxEnable = 9<<11, TxDisable = 10<<11, TxReset = 11<<11,
151: FakeIntr = 12<<11, AckIntr = 13<<11, SetIntrEnb = 14<<11,
152: SetStatusEnb = 15<<11, SetRxFilter = 16<<11, SetRxThreshold = 17<<11,
153: SetTxThreshold = 18<<11, SetTxStart = 19<<11,
154: StartDMAUp = 20<<11, StartDMADown = (20<<11)+1, StatsEnable = 21<<11,
155: StatsDisable = 22<<11, StopCoax = 23<<11,};
156:
157: /* The SetRxFilter command accepts the following classes: */
158: enum RxFilter {
159: RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8 };
160:
161: /* Bits in the general status register. */
162: enum vortex_status {
163: IntLatch = 0x0001, AdapterFailure = 0x0002, TxComplete = 0x0004,
164: TxAvailable = 0x0008, RxComplete = 0x0010, RxEarly = 0x0020,
165: IntReq = 0x0040, StatsFull = 0x0080, DMADone = 1<<8,
166: DMAInProgress = 1<<11, /* DMA controller is still busy.*/
167: CmdInProgress = 1<<12, /* EL3_CMD is still busy.*/
168: };
169:
170: /* Register window 1 offsets, the window used in normal operation.
171: On the Vortex this window is always mapped at offsets 0x10-0x1f. */
172: enum Window1 {
173: TX_FIFO = 0x10, RX_FIFO = 0x10, RxErrors = 0x14,
174: RxStatus = 0x18, Timer=0x1A, TxStatus = 0x1B,
175: TxFree = 0x1C, /* Remaining free bytes in Tx buffer. */
176: };
177: enum Window0 {
178: Wn0EepromCmd = 10, /* Window 0: EEPROM command register. */
179: };
180: enum Win0_EEPROM_bits {
181: EEPROM_Read = 0x80, EEPROM_WRITE = 0x40, EEPROM_ERASE = 0xC0,
182: EEPROM_EWENB = 0x30, /* Enable erasing/writing for 10 msec. */
183: EEPROM_EWDIS = 0x00, /* Disable EWENB before 10 msec timeout. */
184: };
185: /* EEPROM locations. */
186: enum eeprom_offset {
187: PhysAddr01=0, PhysAddr23=1, PhysAddr45=2, ModelID=3,
188: EtherLink3ID=7, IFXcvrIO=8, IRQLine=9,
189: NodeAddr01=10, NodeAddr23=11, NodeAddr45=12,
190: DriverTune=13, Checksum=15};
191:
192: enum Window3 { /* Window 3: MAC/config bits. */
193: Wn3_Config=0, Wn3_MAC_Ctrl=6, Wn3_Options=8,
194: };
195: union wn3_config {
196: int i;
197: struct w3_config_fields {
198: unsigned int ram_size:3, ram_width:1, ram_speed:2, rom_size:2;
199: int pad8:8;
200: unsigned int ram_split:2, pad18:2, xcvr:3, pad21:1, autoselect:1;
201: int pad24:8;
202: } u;
203: };
204:
205: enum Window4 {
206: Wn4_Media = 0x0A, /* Window 4: Various transcvr/media bits. */
207: };
208: enum Win4_Media_bits {
209: Media_TP = 0x00C0, /* Enable link beat and jabber for 10baseT. */
210: };
211: enum Window7 { /* Window 7: Bus Master control. */
212: Wn7_MasterAddr = 0, Wn7_MasterLen = 6, Wn7_MasterStatus = 12,
213: };
214:
215: struct vortex_private {
216: char devname[8]; /* "ethN" string, also for kernel debug. */
217: const char *product_name;
218: struct device *next_module;
219: struct enet_statistics stats;
220: #ifdef VORTEX_BUS_MASTER
221: struct sk_buff *tx_skb; /* Packet being eaten by bus master ctrl. */
222: #endif
223: struct timer_list timer; /* Media selection timer. */
224: int options; /* User-settable driver options (none yet). */
225: unsigned int media_override:3, full_duplex:1, bus_master:1, autoselect:1;
226: };
227:
228: static char *if_names[] = {
229: "10baseT", "10Mbs AUI", "undefined", "10base2",
230: "100baseTX", "100baseFX", "MII", "undefined"};
231:
232: static int vortex_scan(struct device *dev);
233: static int vortex_found_device(struct device *dev, int ioaddr, int irq,
234: int product_index, int options);
235: static int vortex_probe1(struct device *dev);
236: static int vortex_open(struct device *dev);
237: static void vortex_timer(unsigned long arg);
238: static int vortex_start_xmit(struct sk_buff *skb, struct device *dev);
239: static int vortex_rx(struct device *dev);
240: static void vortex_interrupt(int irq, struct pt_regs *regs);
241: static int vortex_close(struct device *dev);
242: static void update_stats(int addr, struct device *dev);
243: static struct enet_statistics *vortex_get_stats(struct device *dev);
244: static void set_multicast_list(struct device *dev);
245:
246:
247: /* Unlike the other PCI cards the 59x cards don't need a large contiguous
248: memory region, so making the driver a loadable module is feasible.
249:
250: Unfortuneately maximizing the shared code between the integrated and
251: module version of the driver results in a complicated set of initialization
252: procedures.
253: init_module() -- modules / tc59x_init() -- built-in
254: The wrappers for vortex_scan()
255: vortex_scan() The common routine that scans for PCI and EISA cards
256: vortex_found_device() Allocate a device structure when we find a card.
257: Different versions exist for modules and built-in.
258: vortex_probe1() Fill in the device structure -- this is seperated
259: so that the modules code can put it in dev->init.
260: */
261: /* This driver uses 'options' to pass the media type, full-duplex flag, etc. */
262: /* Note: this is the only limit on the number of cards supported!! */
263: int options[8] = { -1, -1, -1, -1, -1, -1, -1, -1,};
264:
265: #ifdef MODULE
266: static int debug = -1;
267: /* A list of all installed Vortex devices, for removing the driver module. */
268: static struct device *root_vortex_dev = NULL;
269:
270: int
271: init_module(void)
272: {
273: int cards_found;
274:
275: if (debug >= 0)
276: vortex_debug = debug;
277: if (vortex_debug)
278: printk(version);
279:
280: root_vortex_dev = NULL;
281: cards_found = vortex_scan(0);
282: return cards_found < 0 ? cards_found : 0;
283: }
284:
285: #else
286: unsigned long tc59x_probe(struct device *dev)
287: {
288: int cards_found = 0;
289:
290: cards_found = vortex_scan(dev);
291:
292: if (vortex_debug > 0 && cards_found)
293: printk(version);
294:
295: return cards_found ? 0 : -ENODEV;
296: }
297: #endif /* not MODULE */
298:
299: static int vortex_scan(struct device *dev)
300: {
301: int cards_found = 0;
302:
303: if (pcibios_present()) {
304: static int pci_index = 0;
305: for (; pci_index < 8; pci_index++) {
306: unsigned char pci_bus, pci_device_fn, pci_irq_line, pci_latency;
307: unsigned int pci_ioaddr;
308: unsigned short pci_command;
309: int index;
310:
311: for (index = 0; product_ids[index]; index++) {
312: if ( ! pcibios_find_device(TCOM_VENDOR_ID, product_ids[index],
313: pci_index, &pci_bus,
314: &pci_device_fn))
315: break;
316: }
317: if ( ! product_ids[index])
318: break;
319:
320: pcibios_read_config_byte(pci_bus, pci_device_fn,
321: PCI_INTERRUPT_LINE, &pci_irq_line);
322: pcibios_read_config_dword(pci_bus, pci_device_fn,
323: PCI_BASE_ADDRESS_0, &pci_ioaddr);
324: /* Remove I/O space marker in bit 0. */
325: pci_ioaddr &= ~3;
326:
327: #ifdef VORTEX_BUS_MASTER
328: /* Get and check the bus-master and latency values.
329: Some PCI BIOSes fail to set the master-enable bit, and
330: the latency timer must be set to the maximum value to avoid
331: data corruption that occurs when the timer expires during
332: a transfer. Yes, it's a bug. */
333: pcibios_read_config_word(pci_bus, pci_device_fn,
334: PCI_COMMAND, &pci_command);
335: if ( ! (pci_command & PCI_COMMAND_MASTER)) {
336: printk(" PCI Master Bit has not been set! Setting...\n");
337: pci_command |= PCI_COMMAND_MASTER;
338: pcibios_write_config_word(pci_bus, pci_device_fn,
339: PCI_COMMAND, pci_command);
340: }
341: pcibios_read_config_byte(pci_bus, pci_device_fn,
342: PCI_LATENCY_TIMER, &pci_latency);
343: if (pci_latency != 255) {
344: printk(" Overriding PCI latency timer (CFLT) setting of %d, new value is 255.\n", pci_latency);
345: pcibios_write_config_byte(pci_bus, pci_device_fn,
346: PCI_LATENCY_TIMER, 255);
347: }
348: #endif /* VORTEX_BUS_MASTER */
349: vortex_found_device(dev, pci_ioaddr, pci_irq_line, index,
350: dev && dev->mem_start ? dev->mem_start
351: : options[cards_found]);
352: dev = 0;
353: cards_found++;
354: }
355: }
356:
357: /* Now check all slots of the EISA bus. */
358: if (EISA_bus) {
359: static int ioaddr = 0x1000;
360: for (ioaddr = 0x1000; ioaddr < 0x9000; ioaddr += 0x1000) {
361: /* Check the standard EISA ID register for an encoded '3Com'. */
362: if (inw(ioaddr + 0xC80) != 0x6d50)
363: continue;
364: /* Check for a product that we support. */
365: if ((inw(ioaddr + 0xC82) & 0xFFF0) != 0x5970
366: && (inw(ioaddr + 0xC82) & 0xFFF0) != 0x5920)
367: continue;
368: vortex_found_device(dev, ioaddr, inw(ioaddr + 0xC88) >> 12,
369: DEMON_INDEX, dev && dev->mem_start
370: ? dev->mem_start : options[cards_found]);
371: dev = 0;
372: cards_found++;
373: }
374: }
375:
376: return cards_found;
377: }
378:
379: static int vortex_found_device(struct device *dev, int ioaddr, int irq,
380: int product_index, int options)
381: {
382: struct vortex_private *vp;
383:
384: #ifdef MODULE
385: /* Allocate and fill new device structure. */
386: int dev_size = sizeof(struct device) +
387: sizeof(struct vortex_private);
388:
389: dev = (struct device *) kmalloc(dev_size, GFP_KERNEL);
390: memset(dev, 0, dev_size);
391: dev->priv = ((void *)dev) + sizeof(struct device);
392: vp = (struct vortex_private *)dev->priv;
393: dev->name = vp->devname; /* An empty string. */
394: dev->base_addr = ioaddr;
395: dev->irq = irq;
396: dev->init = vortex_probe1;
397: vp->product_name = product_names[product_index];
398: vp->options = options;
399: if (options >= 0) {
400: vp->media_override = ((options & 7) == 2) ? 0 : options & 7;
401: vp->full_duplex = (options & 8) ? 1 : 0;
402: vp->bus_master = (options & 16) ? 1 : 0;
403: } else {
404: vp->media_override = 7;
405: vp->full_duplex = 0;
406: vp->bus_master = 0;
407: }
408: ether_setup(dev);
409: vp->next_module = root_vortex_dev;
410: root_vortex_dev = dev;
411: if (register_netdev(dev) != 0)
412: return -EIO;
413: #else /* not a MODULE */
414: if (dev) {
415: dev->priv = kmalloc(sizeof (struct vortex_private), GFP_KERNEL);
416: memset(dev->priv, 0, sizeof (struct vortex_private));
417: }
418: dev = init_etherdev(dev, sizeof(struct vortex_private));
419: dev->base_addr = ioaddr;
420: dev->irq = irq;
421: vp = (struct vortex_private *)dev->priv;
422: vp->product_name = product_names[product_index];
423: vp->options = options;
424: if (options >= 0) {
425: vp->media_override = ((options & 7) == 2) ? 0 : options & 7;
426: vp->full_duplex = (options & 8) ? 1 : 0;
427: vp->bus_master = (options & 16) ? 1 : 0;
428: } else {
429: vp->media_override = 7;
430: vp->full_duplex = 0;
431: vp->bus_master = 0;
432: }
433:
434: vortex_probe1(dev);
435: #endif /* MODULE */
436: return 0;
437: }
438:
439: static int vortex_probe1(struct device *dev)
440: {
441: int ioaddr = dev->base_addr;
442: struct vortex_private *vp = (struct vortex_private *)dev->priv;
443: int i;
444:
445: printk("%s: 3Com %s at %#3x,", dev->name,
446: vp->product_name, ioaddr);
447:
448: /* Read the station address from the EEPROM. */
449: EL3WINDOW(0);
450: for (i = 0; i < 3; i++) {
451: short *phys_addr = (short *)dev->dev_addr;
452: int timer;
453: outw(EEPROM_Read + PhysAddr01 + i, ioaddr + Wn0EepromCmd);
454: /* Pause for at least 162 us. for the read to take place. */
455: for (timer = 0; timer < 162*4 + 400; timer++) {
456: SLOW_DOWN_IO;
457: if ((inw(ioaddr + Wn0EepromCmd) & 0x8000) == 0)
458: break;
459: }
460: phys_addr[i] = htons(inw(ioaddr + 12));
461: }
462: for (i = 0; i < 6; i++)
463: printk("%c%2.2x", i ? ':' : ' ', dev->dev_addr[i]);
464: printk(", IRQ %d\n", dev->irq);
465: /* Tell them about an invalid IRQ. */
466: if (vortex_debug && (dev->irq <= 0 || dev->irq > 15))
467: printk(" *** Warning: this IRQ is unlikely to work!\n");
468:
469: {
470: char *ram_split[] = {"5:3", "3:1", "1:1", "invalid"};
471: union wn3_config config;
472: EL3WINDOW(3);
473: config.i = inl(ioaddr + Wn3_Config);
474: if (vortex_debug > 1)
475: printk(" Internal config register is %4.4x, transceivers %#x.\n",
476: config.i, inw(ioaddr + Wn3_Options));
477: printk(" %dK %s-wide RAM %s Rx:Tx split, %s%s interface.\n",
478: 8 << config.u.ram_size,
479: config.u.ram_width ? "word" : "byte",
480: ram_split[config.u.ram_split],
481: config.u.autoselect ? "autoselect/" : "",
482: if_names[config.u.xcvr]);
483: dev->if_port = config.u.xcvr;
484: vp->autoselect = config.u.autoselect;
485: }
486:
487: /* We do a request_region() only to register /proc/ioports info. */
488: request_region(ioaddr, VORTEX_TOTAL_SIZE, vp->product_name);
489:
490: /* The 3c59x-specific entries in the device structure. */
491: dev->open = &vortex_open;
492: dev->hard_start_xmit = &vortex_start_xmit;
493: dev->stop = &vortex_close;
494: dev->get_stats = &vortex_get_stats;
495: dev->set_multicast_list = &set_multicast_list;
496: #if defined (HAVE_SET_MAC_ADDR) && 0
497: dev->set_mac_address = &set_mac_address;
498: #endif
499:
500: return 0;
501: }
502:
503:
504: static int
505: vortex_open(struct device *dev)
506: {
507: int ioaddr = dev->base_addr;
508: struct vortex_private *vp = (struct vortex_private *)dev->priv;
509: union wn3_config config;
510: int i;
511:
512: /* Before initializing select the active media port. */
513: EL3WINDOW(3);
514: if (vp->full_duplex)
515: outb(0x20, ioaddr + Wn3_MAC_Ctrl); /* Set the full-duplex bit. */
516: config.i = inl(ioaddr + Wn3_Config);
517:
518: if (vp->media_override != 7) {
519: if (vortex_debug > 1)
520: printk("%s: Media override to transceiver %d (%s).\n",
521: dev->name, vp->media_override, if_names[vp->media_override]);
522: config.u.xcvr = vp->media_override;
523: dev->if_port = vp->media_override;
524: outl(config.i, ioaddr + Wn3_Config);
525: }
526:
527: if (vortex_debug > 1) {
528: printk("%s: vortex_open() InternalConfig %8.8x.\n",
529: dev->name, config.i);
530: }
531:
532: outw(TxReset, ioaddr + EL3_CMD);
533: for (i = 20; i >= 0 ; i--)
534: if ( ! inw(ioaddr + EL3_STATUS) & CmdInProgress)
535: break;
536:
537: outw(RxReset, ioaddr + EL3_CMD);
538: /* Wait a few ticks for the RxReset command to complete. */
539: for (i = 20; i >= 0 ; i--)
540: if ( ! inw(ioaddr + EL3_STATUS) & CmdInProgress)
541: break;
542:
543: outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
544:
545: #ifdef USE_SHARED_IRQ
546: i = request_shared_irq(dev->irq, &vortex_interrupt, dev, vp->product_name);
547: if (i) /* Error */
548: return i;
549: #else
550: if (dev->irq == 0 || irq2dev_map[dev->irq] != NULL)
551: return -EAGAIN;
552: irq2dev_map[dev->irq] = dev;
553: if (request_irq(dev->irq, &vortex_interrupt, 0, vp->product_name)) {
554: irq2dev_map[dev->irq] = NULL;
555: return -EAGAIN;
556: }
557: #endif
558:
559: if (vortex_debug > 1) {
560: EL3WINDOW(4);
561: printk("%s: vortex_open() irq %d media status %4.4x.\n",
562: dev->name, dev->irq, inw(ioaddr + Wn4_Media));
563: }
564:
565: /* Set the station address and mask in window 2 each time opened. */
566: EL3WINDOW(2);
567: for (i = 0; i < 6; i++)
568: outb(dev->dev_addr[i], ioaddr + i);
569: for (; i < 12; i+=2)
570: outw(0, ioaddr + i);
571:
572: if (dev->if_port == 3)
573: /* Start the thinnet transceiver. We should really wait 50ms...*/
574: outw(StartCoax, ioaddr + EL3_CMD);
575: else if (dev->if_port == 0) {
576: /* 10baseT interface, enabled link beat and jabber check. */
577: EL3WINDOW(4);
578: outw(inw(ioaddr + Wn4_Media) | Media_TP, ioaddr + Wn4_Media);
579: }
580:
581: /* Switch to the stats window, and clear all stats by reading. */
582: outw(StatsDisable, ioaddr + EL3_CMD);
583: EL3WINDOW(6);
584: for (i = 0; i < 10; i++)
585: inb(ioaddr + i);
586: inw(ioaddr + 10);
587: inw(ioaddr + 12);
588: /* New: On the Vortex we must also clear the BadSSD counter. */
589: EL3WINDOW(4);
590: inb(ioaddr + 12);
591:
592: /* Switch to register set 7 for normal use. */
593: EL3WINDOW(7);
594:
595: /* Accept b-case and phys addr only. */
596: outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
597: outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
598:
599: dev->tbusy = 0;
600: dev->interrupt = 0;
601: dev->start = 1;
602:
603: outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
604: outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
605: /* Allow status bits to be seen. */
606: outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
607: /* Ack all pending events, and set active indicator mask. */
608: outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
609: ioaddr + EL3_CMD);
610: outw(SetIntrEnb | IntLatch | TxAvailable | RxComplete | StatsFull
611: | DMADone, ioaddr + EL3_CMD);
612:
613: #ifdef MODULE
614: MOD_INC_USE_COUNT;
615: #endif
616:
617: if (vp->autoselect) {
618: init_timer(&vp->timer);
619: vp->timer.expires = (14*HZ)/10; /* 1.4 sec. */
620: vp->timer.data = (unsigned long)dev;
621: vp->timer.function = &vortex_timer; /* timer handler */
622: add_timer(&vp->timer);
623: }
624: return 0;
625: }
626:
627: static void vortex_timer(unsigned long data)
628: {
629: struct device *dev = (struct device *)data;
630: if (vortex_debug > 2)
631: printk("%s: Media selection timer tick happened.\n", dev->name);
632: /* ToDo: active media selection here! */
633: }
634:
635: static int
636: vortex_start_xmit(struct sk_buff *skb, struct device *dev)
637: {
638: struct vortex_private *vp = (struct vortex_private *)dev->priv;
639: int ioaddr = dev->base_addr;
640:
641: /* Transmitter timeout, serious problems. */
642: if (dev->tbusy) {
643: int tickssofar = jiffies - dev->trans_start;
644: if (tickssofar < 40)
645: return 1;
646: printk("%s: transmit timed out, tx_status %2.2x status %4.4x.\n",
647: dev->name, inb(ioaddr + TxStatus), inw(ioaddr + EL3_STATUS));
648: vp->stats.tx_errors++;
649: /* Issue TX_RESET and TX_START commands. */
650: outw(TxReset, ioaddr + EL3_CMD);
651: {
652: int i;
653: for (i = 20; i >= 0 ; i--)
654: if ( ! inw(ioaddr + EL3_STATUS) & CmdInProgress)
655: break;
656: }
657: outw(TxEnable, ioaddr + EL3_CMD);
658: dev->trans_start = jiffies;
659: dev->tbusy = 0;
660: return 0;
661: }
662:
663: if (skb == NULL || skb->len <= 0) {
664: printk("%s: Obsolete driver layer request made: skbuff==NULL.\n",
665: dev->name);
666: dev_tint(dev);
667: return 0;
668: }
669:
670: /* Block a timer-based transmit from overlapping. This could better be
671: done with atomic_swap(1, dev->tbusy), but set_bit() works as well.
672: If this ever occurs the queue layer is doing something evil! */
673: if (set_bit(0, (void*)&dev->tbusy) != 0) {
674: printk("%s: Transmitter access conflict.\n", dev->name);
675: return 1;
676: }
677:
678: /* Put out the doubleword header... */
679: outl(skb->len, ioaddr + TX_FIFO);
680: #ifdef VORTEX_BUS_MASTER
681: if (vp->bus_master) {
682: /* Set the bus-master controller to transfer the packet. */
683: outl((int)(skb->data), ioaddr + Wn7_MasterAddr);
684: outw((skb->len + 3) & ~3, ioaddr + Wn7_MasterLen);
685: vp->tx_skb = skb;
686: outw(StartDMADown, ioaddr + EL3_CMD);
687: } else {
688: /* ... and the packet rounded to a doubleword. */
689: outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
690: dev_kfree_skb (skb, FREE_WRITE);
691: if (inw(ioaddr + TxFree) > 1536) {
692: dev->tbusy = 0;
693: } else
694: /* Interrupt us when the FIFO has room for max-sized packet. */
695: outw(SetTxThreshold + 1536, ioaddr + EL3_CMD);
696: }
697: #else
698: /* ... and the packet rounded to a doubleword. */
699: outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
700: dev_kfree_skb (skb, FREE_WRITE);
701: if (inw(ioaddr + TxFree) > 1536) {
702: dev->tbusy = 0;
703: } else
704: /* Interrupt us when the FIFO has room for max-sized packet. */
705: outw(SetTxThreshold + 1536, ioaddr + EL3_CMD);
706: #endif /* bus master */
707:
708: dev->trans_start = jiffies;
709:
710: /* Clear the Tx status stack. */
711: {
712: short tx_status;
713: int i = 4;
714:
715: while (--i > 0 && (tx_status = inb(ioaddr + TxStatus)) > 0) {
716: if (tx_status & 0x3C) { /* A Tx-disabling error occured. */
717: if (vortex_debug > 2)
718: printk("%s: Tx error, status %2.2x.\n",
719: dev->name, tx_status);
720: if (tx_status & 0x04) vp->stats.tx_fifo_errors++;
721: if (tx_status & 0x38) vp->stats.tx_aborted_errors++;
722: if (tx_status & 0x30) {
723: int j;
724: outw(TxReset, ioaddr + EL3_CMD);
725: for (j = 20; j >= 0 ; j--)
726: if ( ! inw(ioaddr + EL3_STATUS) & CmdInProgress)
727: break;
728: }
729: outw(TxEnable, ioaddr + EL3_CMD);
730: }
731: outb(0x00, ioaddr + TxStatus); /* Pop the status stack. */
732: }
733: }
734: return 0;
735: }
736:
737: /* The interrupt handler does all of the Rx thread work and cleans up
738: after the Tx thread. */
739: static void vortex_interrupt(int irq, struct pt_regs *regs)
740: {
741: #ifdef USE_SHARED_IRQ
742: struct device *dev = (struct device *)(irq == 0 ? regs : irq2dev_map[irq]);
743: #else
744: struct device *dev = (struct device *)(irq2dev_map[irq]);
745: #endif
746: struct vortex_private *lp;
747: int ioaddr, status;
748: int latency;
749: int i = 0;
750:
751: if (dev == NULL) {
752: printk ("vortex_interrupt(): irq %d for unknown device.\n", irq);
753: return;
754: }
755:
756: if (dev->interrupt)
757: printk("%s: Re-entering the interrupt handler.\n", dev->name);
758: dev->interrupt = 1;
759:
760: ioaddr = dev->base_addr;
761: latency = inb(ioaddr + Timer);
762: lp = (struct vortex_private *)dev->priv;
763:
764: status = inw(ioaddr + EL3_STATUS);
765:
766: if (vortex_debug > 4)
767: printk("%s: interrupt, status %4.4x, timer %d.\n", dev->name,
768: status, latency);
769: if ((status & 0xE000) != 0xE000) {
770: static int donedidthis=0;
771: /* Some interrupt controllers store a bogus interrupt from boot-time.
772: Ignore a single early interrupt, but don't hang the machine for
773: other interrupt problems. */
774: if (donedidthis++ > 1) {
775: printk("%s: Bogus interrupt, bailing. Status %4.4x, start=%d.\n",
776: dev->name, status, dev->start);
777: free_irq(dev->irq);
778: }
779: }
780:
781: do {
782: if (vortex_debug > 5)
783: printk("%s: In interrupt loop, status %4.4x.\n",
784: dev->name, status);
785: if (status & RxComplete)
786: vortex_rx(dev);
787:
788: if (status & TxAvailable) {
789: if (vortex_debug > 5)
790: printk(" TX room bit was handled.\n");
791: /* There's room in the FIFO for a full-sized packet. */
792: outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
793: dev->tbusy = 0;
794: mark_bh(NET_BH);
795: }
796: #ifdef VORTEX_BUS_MASTER
797: if (status & DMADone) {
798: outw(0x1000, ioaddr + Wn7_MasterStatus); /* Ack the event. */
799: dev->tbusy = 0;
800: mark_bh(NET_BH);
801: }
802: #endif
803: if (status & (AdapterFailure | RxEarly | StatsFull)) {
804: /* Handle all uncommon interrupts at once. */
805: if (status & RxEarly) { /* Rx early is unused. */
806: vortex_rx(dev);
807: outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
808: }
809: if (status & StatsFull) { /* Empty statistics. */
810: static int DoneDidThat = 0;
811: if (vortex_debug > 4)
812: printk("%s: Updating stats.\n", dev->name);
813: update_stats(ioaddr, dev);
814: /* DEBUG HACK: Disable statistics as an interrupt source. */
815: /* This occurs when we have the wrong media type! */
816: if (DoneDidThat == 0 &&
817: inw(ioaddr + EL3_STATUS) & StatsFull) {
818: int win, reg;
819: printk("%s: Updating stats failed, disabling stats as an"
820: " interrupt source.\n", dev->name);
821: for (win = 0; win < 8; win++) {
822: EL3WINDOW(win);
823: printk("\n Vortex window %d:", win);
824: for (reg = 0; reg < 16; reg++)
825: printk(" %2.2x", inb(ioaddr+reg));
826: }
827: EL3WINDOW(7);
828: outw(SetIntrEnb | 0x18, ioaddr + EL3_CMD);
829: DoneDidThat++;
830: }
831: }
832: if (status & AdapterFailure) {
833: /* Adapter failure requires Rx reset and reinit. */
834: outw(RxReset, ioaddr + EL3_CMD);
835: /* Set the Rx filter to the current state. */
836: outw(SetRxFilter | RxStation | RxBroadcast
837: | (dev->flags & IFF_ALLMULTI ? RxMulticast : 0)
838: | (dev->flags & IFF_PROMISC ? RxProm : 0),
839: ioaddr + EL3_CMD);
840: outw(RxEnable, ioaddr + EL3_CMD); /* Re-enable the receiver. */
841: outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
842: }
843: }
844:
845: if (++i > 10) {
846: printk("%s: Infinite loop in interrupt, status %4.4x. "
847: "Disabling functions (%4.4x).\n",
848: dev->name, status, SetStatusEnb | ((~status) & 0xFE));
849: /* Disable all pending interrupts. */
850: outw(SetStatusEnb | ((~status) & 0xFE), ioaddr + EL3_CMD);
851: outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
852: break;
853: }
854: /* Acknowledge the IRQ. */
855: outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
856:
857: } while ((status = inw(ioaddr + EL3_STATUS)) & (IntLatch | RxComplete));
858:
859: if (vortex_debug > 4)
860: printk("%s: exiting interrupt, status %4.4x.\n", dev->name, status);
861:
862: dev->interrupt = 0;
863: return;
864: }
865:
866: static int
867: vortex_rx(struct device *dev)
868: {
869: struct vortex_private *vp = (struct vortex_private *)dev->priv;
870: int ioaddr = dev->base_addr;
871: int i;
872: short rx_status;
873:
874: if (vortex_debug > 5)
875: printk(" In rx_packet(), status %4.4x, rx_status %4.4x.\n",
876: inw(ioaddr+EL3_STATUS), inw(ioaddr+RxStatus));
877: while ((rx_status = inw(ioaddr + RxStatus)) > 0) {
878: if (rx_status & 0x4000) { /* Error, update stats. */
879: unsigned char rx_error = inb(ioaddr + RxErrors);
880: if (vortex_debug > 4)
881: printk(" Rx error: status %2.2x.\n", rx_error);
882: vp->stats.rx_errors++;
883: if (rx_error & 0x01) vp->stats.rx_over_errors++;
884: if (rx_error & 0x02) vp->stats.rx_length_errors++;
885: if (rx_error & 0x04) vp->stats.rx_frame_errors++;
886: if (rx_error & 0x08) vp->stats.rx_crc_errors++;
887: if (rx_error & 0x10) vp->stats.rx_length_errors++;
888: } else {
889: /* The packet length: up to 4.5K!. */
890: short pkt_len = rx_status & 0x1fff;
891: struct sk_buff *skb;
892:
893: skb = dev_alloc_skb(pkt_len + 5);
894: if (vortex_debug > 4)
895: printk("Receiving packet size %d status %4.4x.\n",
896: pkt_len, rx_status);
897: if (skb != NULL) {
898: skb->dev = dev;
899: skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
900: /* 'skb_put()' points to the start of sk_buff data area. */
901: insl(ioaddr + RX_FIFO, skb_put(skb, pkt_len),
902: (pkt_len + 3) >> 2);
903: skb->protocol = eth_type_trans(skb, dev);
904: netif_rx(skb);
905: outw(RxDiscard, ioaddr + EL3_CMD); /* Pop top Rx packet. */
906: /* Wait a limited time to go to next packet. */
907: for (i = 200; i >= 0; i--)
908: if ( ! inw(ioaddr + EL3_STATUS) & CmdInProgress)
909: break;
910: vp->stats.rx_packets++;
911: continue;
912: } else if (vortex_debug)
913: printk("%s: Couldn't allocate a sk_buff of size %d.\n",
914: dev->name, pkt_len);
915: }
916: vp->stats.rx_dropped++;
917: outw(RxDiscard, ioaddr + EL3_CMD);
918: /* Wait a limited time to skip this packet. */
919: for (i = 200; i >= 0; i--)
920: if ( ! inw(ioaddr + EL3_STATUS) & CmdInProgress)
921: break;
922: }
923:
924: return 0;
925: }
926:
927: static int
928: vortex_close(struct device *dev)
929: {
930: int ioaddr = dev->base_addr;
931:
932: dev->start = 0;
933: dev->tbusy = 1;
934:
935: if (vortex_debug > 1)
936: printk("%s: vortex_close() status %4.4x, Tx status %2.2x.\n",
937: dev->name, inw(ioaddr + EL3_STATUS), inb(ioaddr + TxStatus));
938:
939: /* Turn off statistics ASAP. We update lp->stats below. */
940: outw(StatsDisable, ioaddr + EL3_CMD);
941:
942: /* Disable the receiver and transmitter. */
943: outw(RxDisable, ioaddr + EL3_CMD);
944: outw(TxDisable, ioaddr + EL3_CMD);
945:
946: if (dev->if_port == 3)
947: /* Turn off thinnet power. Green! */
948: outw(StopCoax, ioaddr + EL3_CMD);
949: else if (dev->if_port == 0) {
950: /* Disable link beat and jabber, if_port may change ere next open(). */
951: EL3WINDOW(4);
952: outw(inw(ioaddr + Wn4_Media) & ~Media_TP, ioaddr + Wn4_Media);
953: }
954:
955: #ifdef USE_SHARED_IRQ
956: free_shared_irq(dev->irq, dev);
957: #else
958: free_irq(dev->irq);
959: /* Mmmm, we should diable all interrupt sources here. */
960: irq2dev_map[dev->irq] = 0;
961: #endif
962:
963: update_stats(ioaddr, dev);
964: #ifdef MODULE
965: MOD_DEC_USE_COUNT;
966: #endif
967:
968: return 0;
969: }
970:
971: static struct enet_statistics *
972: vortex_get_stats(struct device *dev)
973: {
974: struct vortex_private *vp = (struct vortex_private *)dev->priv;
975: unsigned long flags;
976:
977: save_flags(flags);
978: cli();
979: update_stats(dev->base_addr, dev);
980: restore_flags(flags);
981: return &vp->stats;
982: }
983:
984: /* Update statistics.
985: Unlike with the EL3 we need not worry about interrupts changing
986: the window setting from underneath us, but we must still guard
987: against a race condition with a StatsUpdate interrupt updating the
988: table. This is done by checking that the ASM (!) code generated uses
989: atomic updates with '+='.
990: */
991: static void update_stats(int ioaddr, struct device *dev)
992: {
993: struct vortex_private *vp = (struct vortex_private *)dev->priv;
994:
995: /* Unlike the 3c5x9 we need not turn off stats updates while reading. */
996: /* Switch to the stats window, and read everything. */
997: EL3WINDOW(6);
998: vp->stats.tx_carrier_errors += inb(ioaddr + 0);
999: vp->stats.tx_heartbeat_errors += inb(ioaddr + 1);
1000: /* Multiple collisions. */ inb(ioaddr + 2);
1001: vp->stats.collisions += inb(ioaddr + 3);
1002: vp->stats.tx_window_errors += inb(ioaddr + 4);
1003: vp->stats.rx_fifo_errors += inb(ioaddr + 5);
1004: vp->stats.tx_packets += inb(ioaddr + 6);
1005: vp->stats.tx_packets += (inb(ioaddr + 9)&0x30) << 4;
1006: /* Rx packets */ inb(ioaddr + 7); /* Must read to clear */
1007: /* Tx deferrals */ inb(ioaddr + 8);
1008: /* Don't bother with register 9, an extention of registers 6&7.
1009: If we do use the 6&7 values the atomic update assumption above
1010: is invalid. */
1011: inw(ioaddr + 10); /* Total Rx and Tx octets. */
1012: inw(ioaddr + 12);
1013: /* New: On the Vortex we must also clear the BadSSD counter. */
1014: EL3WINDOW(4);
1015: inb(ioaddr + 12);
1016:
1017: /* We change back to window 7 (not 1) with the Vortex. */
1018: EL3WINDOW(7);
1019: return;
1020: }
1021:
1022: /* There are two version of set_multicast_list() to support both v1.2 and
1023: v1.4 kernels. */
1024: static void
1025: set_multicast_list(struct device *dev)
1026: {
1027: short ioaddr = dev->base_addr;
1028:
1029: if ((dev->mc_list) || (dev->flags & IFF_ALLMULTI)) {
1030: outw(SetRxFilter|RxStation|RxMulticast|RxBroadcast, ioaddr + EL3_CMD);
1031: if (vortex_debug > 3) {
1032: printk("%s: Setting Rx multicast mode, %d addresses.\n",
1033: dev->name, dev->mc_count);
1034: }
1035: } else if (dev->flags & IFF_PROMISC) {
1036: outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm,
1037: ioaddr + EL3_CMD);
1038: } else
1039: outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1040: }
1041:
1042:
1043: #ifdef MODULE
1044: void
1045: cleanup_module(void)
1046: {
1047: struct device *next_dev;
1048:
1049: /* No need to check MOD_IN_USE, as sys_delete_module() checks. */
1050: while (root_vortex_dev) {
1051: next_dev = ((struct vortex_private *)root_vortex_dev->priv)->next_module;
1052: unregister_netdev(root_vortex_dev);
1053: release_region(root_vortex_dev->base_addr, VORTEX_TOTAL_SIZE);
1054: kfree(root_vortex_dev);
1055: root_vortex_dev = next_dev;
1056: }
1057: }
1058: #endif /* MODULE */
1059:
1060: /*
1061: * Local variables:
1062: * compile-command: "gcc -DMODULE -D__KERNEL__ -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O6 -m486 -c 3c59x.c -o 3c59x.o"
1063: * c-indent-level: 4
1064: * tab-width: 4
1065: * End:
1066: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.