![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tulip.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / linux / src / drivers / net|
Return to tulip.c CVS log | Up to [GnuMach] / Gnu-Mach / linux / src / drivers / net |
1.1 root 1: /* tulip.c: A DEC 21040-family ethernet driver for Linux. */
2: /*
3: Written 1994-1998 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 Digital "Tulip" ethernet adapter interface.
9: It should work with most DEC 21*4*-based chips/ethercards, as well as
10: PNIC and MXIC chips.
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: Support and updates available at
17: http://cesdis.gsfc.nasa.gov/linux/drivers/tulip.html
18: */
19:
20: #define SMP_CHECK
21: static const char version[] = "tulip.c:v0.89H 5/23/98 [email protected]\n";
22:
23: /* A few user-configurable values. */
24:
25: /* Maximum events (Rx packets, etc.) to handle at each interrupt. */
26: static int max_interrupt_work = 25;
27:
28: #define MAX_UNITS 8
29: /* Used to pass the full-duplex flag, etc. */
30: static int full_duplex[MAX_UNITS] = {0, };
31: static int options[MAX_UNITS] = {0, };
32: static int mtu[MAX_UNITS] = {0, }; /* Jumbo MTU for interfaces. */
33:
34: /* The possible media types that can be set in options[] are: */
35: static const char * const medianame[] = {
36: "10baseT", "10base2", "AUI", "100baseTx",
37: "10baseT-FD", "100baseTx-FD", "100baseT4", "100baseFx",
38: "100baseFx-FD", "MII 10baseT", "MII 10baseT-FD", "MII",
39: "10baseT(forced)", "MII 100baseTx", "MII 100baseTx-FD", "MII 100baseT4",
40: };
41:
42: /* Set if the PCI BIOS detects the chips on a multiport board backwards. */
43: #ifdef REVERSE_PROBE_ORDER
44: static int reverse_probe = 1;
45: #else
46: static int reverse_probe = 0;
47: #endif
48:
49: /* Keep the ring sizes a power of two for efficiency.
50: Making the Tx ring too large decreases the effectiveness of channel
51: bonding and packet priority.
52: There are no ill effects from too-large receive rings. */
53: #define TX_RING_SIZE 16
54: #define RX_RING_SIZE 32
55:
56: /* Set the copy breakpoint for the copy-only-tiny-buffer Rx structure. */
57: #ifdef __alpha__
58: static int rx_copybreak = 1518;
59: #else
60: static int rx_copybreak = 100;
61: #endif
62:
63: /* Operational parameters that usually are not changed. */
64: /* Time in jiffies before concluding the transmitter is hung. */
65: #define TX_TIMEOUT (4*HZ)
66:
67: #include <linux/config.h>
68: #ifdef MODULE
69: #ifdef MODVERSIONS
70: #include <linux/modversions.h>
71: #endif
72: #include <linux/module.h>
73: #include <linux/version.h>
74: #else
75: #define MOD_INC_USE_COUNT
76: #define MOD_DEC_USE_COUNT
77: #endif
78:
79: #include <linux/kernel.h>
80: #include <linux/sched.h>
81: #include <linux/string.h>
82: #include <linux/timer.h>
83: #include <linux/ptrace.h>
84: #include <linux/errno.h>
85: #include <linux/ioport.h>
86: #include <linux/malloc.h>
87: #include <linux/interrupt.h>
88: #include <linux/pci.h>
89: #include <linux/bios32.h>
90: #include <asm/processor.h> /* Processor type for cache alignment. */
91: #include <asm/bitops.h>
92: #include <asm/io.h>
93: #include <asm/dma.h>
94:
95: #include <linux/netdevice.h>
96: #include <linux/etherdevice.h>
97: #include <linux/skbuff.h>
98:
99: /* Kernel compatibility defines, common to David Hind's PCMCIA package.
100: This is only in the support-all-kernels source code. */
101: #include <linux/version.h> /* Evil, but neccessary */
102:
103: #if defined (LINUX_VERSION_CODE) && LINUX_VERSION_CODE < 0x10300
104: #define RUN_AT(x) (x) /* What to put in timer->expires. */
105: #define DEV_ALLOC_SKB(len) alloc_skb(len, GFP_ATOMIC)
106: #define virt_to_bus(addr) ((unsigned long)addr)
107: #define bus_to_virt(addr) ((void*)addr)
108:
109: #else /* 1.3.0 and later */
110: #define RUN_AT(x) (jiffies + (x))
111: #define DEV_ALLOC_SKB(len) dev_alloc_skb(len + 2)
112: #endif
113:
114: #if defined (LINUX_VERSION_CODE) && LINUX_VERSION_CODE < 0x10338
115: #ifdef MODULE
116: #if !defined(CONFIG_MODVERSIONS) && !defined(__NO_VERSION__)
117: char kernel_version[] = UTS_RELEASE;
118: #endif
119: #else
120: #undef MOD_INC_USE_COUNT
121: #define MOD_INC_USE_COUNT
122: #undef MOD_DEC_USE_COUNT
123: #define MOD_DEC_USE_COUNT
124: #endif
125: #endif /* 1.3.38 */
126:
127: #if (LINUX_VERSION_CODE >= 0x10344)
128: #define NEW_MULTICAST
129: #include <linux/delay.h>
130: #endif
131: #if (LINUX_VERSION_CODE >= 0x20100)
132: char kernel_version[] = UTS_RELEASE;
133: #endif
134: #ifdef SA_SHIRQ
135: #define IRQ(irq, dev_id, pt_regs) (irq, dev_id, pt_regs)
136: #else
137: #define IRQ(irq, dev_id, pt_regs) (irq, pt_regs)
138: #endif
139:
140: #if (LINUX_VERSION_CODE < 0x20123)
141: #define hard_smp_processor_id() smp_processor_id()
142: #define test_and_set_bit(val, addr) set_bit(val, addr)
143: #endif
144:
145: /* This my implementation of shared IRQs, now only used for 1.2.13. */
146: #ifdef HAVE_SHARED_IRQ
147: #define USE_SHARED_IRQ
148: #include <linux/shared_irq.h>
149: #endif
150:
151: /* The total size is unusually large: The 21040 aligns each of its 16
152: longword-wide registers on a quadword boundary. */
153: #define TULIP_TOTAL_SIZE 0x80
154:
155: #ifdef HAVE_DEVLIST
156: struct netdev_entry tulip_drv =
157: {"Tulip", tulip_pci_probe, TULIP_TOTAL_SIZE, NULL};
158: #endif
159:
160: #ifdef TULIP_DEBUG
161: int tulip_debug = TULIP_DEBUG;
162: #else
163: int tulip_debug = 1;
164: #endif
165:
166: /*
167: Theory of Operation
168:
169: I. Board Compatibility
170:
171: This device driver is designed for the DECchip "Tulip", Digital's
172: single-chip ethernet controllers for PCI. Supported members of the family
173: are the 21040, 21041, 21140, 21140A, 21142, and 21143. These chips are used on
174: many PCI boards including the SMC EtherPower series.
175:
176:
177: II. Board-specific settings
178:
179: PCI bus devices are configured by the system at boot time, so no jumpers
180: need to be set on the board. The system BIOS preferably should assign the
181: PCI INTA signal to an otherwise unused system IRQ line.
182: Note: Kernel versions earlier than 1.3.73 do not support shared PCI
183: interrupt lines.
184:
185: III. Driver operation
186:
187: IIIa. Ring buffers
188:
189: The Tulip can use either ring buffers or lists of Tx and Rx descriptors.
190: This driver uses statically allocated rings of Rx and Tx descriptors, set at
191: compile time by RX/TX_RING_SIZE. This version of the driver allocates skbuffs
192: for the Rx ring buffers at open() time and passes the skb->data field to the
193: Tulip as receive data buffers. When an incoming frame is less than
194: RX_COPYBREAK bytes long, a fresh skbuff is allocated and the frame is
195: copied to the new skbuff. When the incoming frame is larger, the skbuff is
196: passed directly up the protocol stack and replaced by a newly allocated
197: skbuff.
198:
199: The RX_COPYBREAK value is chosen to trade-off the memory wasted by
200: using a full-sized skbuff for small frames vs. the copying costs of larger
201: frames. For small frames the copying cost is negligible (esp. considering
202: that we are pre-loading the cache with immediately useful header
203: information). For large frames the copying cost is non-trivial, and the
204: larger copy might flush the cache of useful data. A subtle aspect of this
205: choice is that the Tulip only receives into longword aligned buffers, thus
206: the IP header at offset 14 isn't longword aligned for further processing.
207: Copied frames are put into the new skbuff at an offset of "+2", thus copying
208: has the beneficial effect of aligning the IP header and preloading the
209: cache.
210:
211: IIIC. Synchronization
212: The driver runs as two independent, single-threaded flows of control. One
213: is the send-packet routine, which enforces single-threaded use by the
214: dev->tbusy flag. The other thread is the interrupt handler, which is single
215: threaded by the hardware and other software.
216:
217: The send packet thread has partial control over the Tx ring and 'dev->tbusy'
218: flag. It sets the tbusy flag whenever it's queuing a Tx packet. If the next
219: queue slot is empty, it clears the tbusy flag when finished otherwise it sets
220: the 'tp->tx_full' flag.
221:
222: The interrupt handler has exclusive control over the Rx ring and records stats
223: from the Tx ring. (The Tx-done interrupt can't be selectively turned off, so
224: we can't avoid the interrupt overhead by having the Tx routine reap the Tx
225: stats.) After reaping the stats, it marks the queue entry as empty by setting
226: the 'base' to zero. Iff the 'tp->tx_full' flag is set, it clears both the
227: tx_full and tbusy flags.
228:
229: IV. Notes
230:
231: Thanks to Duke Kamstra of SMC for providing an EtherPower board.
232:
233: IVb. References
234:
235: http://cesdis.gsfc.nasa.gov/linux/misc/NWay.html
236: http://www.digital.com (search for current 21*4* datasheets and "21X4 SROM")
237: http://www.national.com/pf/DP/DP83840.html
238:
239: IVc. Errata
240:
241: The DEC databook doesn't document which Rx filter settings accept broadcast
242: packets. Nor does it document how to configure the part to configure the
243: serial subsystem for normal (vs. loopback) operation or how to have it
244: autoswitch between internal 10baseT, SIA and AUI transceivers.
245:
246: The 21040 databook claims that CSR13, CSR14, and CSR15 should each be the last
247: register of the set CSR12-15 written. Hmmm, now how is that possible? */
248:
249:
250: /* A few values that may be tweaked. */
251: #define PKT_BUF_SZ 1536 /* Size of each temporary Rx buffer.*/
252:
253: /* This is a mysterious value that can be written to CSR11 in the 21040 (only)
254: to support a pre-NWay full-duplex signaling mechanism using short frames.
255: No one knows what it should be, but if left at its default value some
256: 10base2(!) packets trigger a full-duplex-request interrupt. */
257: #define FULL_DUPLEX_MAGIC 0x6969
258:
259: #ifndef PCI_VENDOR_ID_DEC /* Now defined in linux/pci.h */
260: #define PCI_VENDOR_ID_DEC 0x1011
261: #define PCI_DEVICE_ID_TULIP 0x0002 /* 21040. */
262: #define PCI_DEVICE_ID_TULIP_FAST 0x0009 /* 21140. */
263: #endif
264:
265: #ifndef PCI_DEVICE_ID_DEC_TULIP_PLUS
266: #define PCI_DEVICE_ID_DEC_TULIP_PLUS 0x0014 /* 21041. */
267: #endif
268: #ifndef PCI_DEVICE_ID_DEC_TULIP_21142
269: #define PCI_DEVICE_ID_DEC_TULIP_21142 0x0019
270: #endif
271:
272: #ifndef PCI_VENDOR_ID_LITEON
273: #define PCI_VENDOR_ID_LITEON 0x11AD
274: #endif
275:
276: #ifndef PCI_VENDOR_ID_MXIC
277: #define PCI_VENDOR_ID_MXIC 0x10d9
278: #define PCI_DEVICE_ID_MX98713 0x0512
279: #define PCI_DEVICE_ID_MX98715 0x0531
280: #define PCI_DEVICE_ID_MX98725 0x0531
281: #endif
282:
283: /* The rest of these values should never change. */
284:
285: static void tulip_timer(unsigned long data);
286: static void t21142_timer(unsigned long data);
287: static void mxic_timer(unsigned long data);
288: static void pnic_timer(unsigned long data);
289:
290: /* A table describing the chip types. */
291: enum tbl_flag { HAS_MII=1, HAS_MEDIA_TABLE = 2, CSR12_IN_SROM = 4,};
292: static struct tulip_chip_table {
293: int vendor_id, device_id;
294: char *chip_name;
295: int io_size;
296: int valid_intrs; /* CSR7 interrupt enable settings */
297: int flags;
298: void (*media_timer)(unsigned long data);
299: } tulip_tbl[] = {
300: { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_TULIP,
301: "Digital DC21040 Tulip", 128, 0x0001ebef, 0, tulip_timer },
302: { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_TULIP_PLUS,
303: "Digital DC21041 Tulip", 128, 0x0001ebef, HAS_MEDIA_TABLE, tulip_timer },
304: { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_TULIP_FAST,
305: "Digital DS21140 Tulip", 128, 0x0001ebef,
306: HAS_MII | HAS_MEDIA_TABLE | CSR12_IN_SROM,
307: tulip_timer },
308: { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_TULIP_21142,
309: "Digital DS21142/3 Tulip", 256, 0x0801fbff,
310: HAS_MII | HAS_MEDIA_TABLE, t21142_timer },
311: { PCI_VENDOR_ID_LITEON, 0x0002,
312: "Lite-On 82c168 PNIC", 256, 0x0001ebef, HAS_MII, pnic_timer },
313: { PCI_VENDOR_ID_MXIC, PCI_DEVICE_ID_MX98713,
314: "Macronix 98713 PMAC", 128, 0x0001ebef,
315: HAS_MII | HAS_MEDIA_TABLE | CSR12_IN_SROM, tulip_timer /* Tulip-like! */ },
316: { PCI_VENDOR_ID_MXIC, PCI_DEVICE_ID_MX98715,
317: "Macronix 98715 PMAC", 256, 0x0001ebef, HAS_MEDIA_TABLE, mxic_timer },
318: { PCI_VENDOR_ID_MXIC, PCI_DEVICE_ID_MX98725,
319: "Macronix 98725 PMAC", 256, 0x0001ebef, HAS_MEDIA_TABLE, mxic_timer },
320: { 0x125B, 0x1400, "ASIX AX88140", 128, 0x0001fbff,
321: HAS_MII | HAS_MEDIA_TABLE | CSR12_IN_SROM, tulip_timer },
322: {0, 0, 0, 0},
323: };
324: /* This matches the table above. */
325: enum chips { DC21040=0, DC21041=1, DC21140=2, DC21142=3, DC21143=3,
326: LC82C168, MX98713, MX98715, MX98725};
327:
328: /* A full-duplex map for media types. */
329: enum MediaIs {MediaIsFD = 1, MediaAlwaysFD=2, MediaIsMII=4, MediaIsFx=8,
330: MediaIs100=16};
331: static const char media_cap[] =
332: {0,0,0,16, 3,19,16,24, 27,4,7,5, 0,20,23,20 };
333: /* 21041 transceiver register settings: 10-T, 10-2, AUI, 10-T, 10T-FD*/
334: static u16 t21041_csr13[] = { 0xEF05, 0xEF09, 0xEF09, 0xEF01, 0xEF09, };
335: static u16 t21041_csr14[] = { 0x7F3F, 0xF7FD, 0xF7FD, 0x7F3F, 0x7F3D, };
336: static u16 t21041_csr15[] = { 0x0008, 0x0006, 0x000E, 0x0008, 0x0008, };
337:
338: static u16 t21142_csr13[] = { 0x0001, 0x0009, 0x0009, 0x0000, 0x0001, };
339: static u16 t21142_csr14[] = { 0xFFFF, 0x0705, 0x0705, 0x0000, 0x7F3D, };
340: static u16 t21142_csr15[] = { 0x0008, 0x0006, 0x000E, 0x0008, 0x0008, };
341:
342: /* Offsets to the Command and Status Registers, "CSRs". All accesses
343: must be longword instructions and quadword aligned. */
344: enum tulip_offsets {
345: CSR0=0, CSR1=0x08, CSR2=0x10, CSR3=0x18, CSR4=0x20, CSR5=0x28,
346: CSR6=0x30, CSR7=0x38, CSR8=0x40, CSR9=0x48, CSR10=0x50, CSR11=0x58,
347: CSR12=0x60, CSR13=0x68, CSR14=0x70, CSR15=0x78 };
348:
349: /* The bits in the CSR5 status registers, mostly interrupt sources. */
350: enum status_bits {
351: TimerInt=0x800, TPLnkFail=0x1000, TPLnkPass=0x10,
352: NormalIntr=0x10000, AbnormalIntr=0x8000,
353: RxJabber=0x200, RxDied=0x100, RxNoBuf=0x80, RxIntr=0x40,
354: TxFIFOUnderflow=0x20, TxJabber=0x08, TxNoBuf=0x04, TxDied=0x02, TxIntr=0x01,
355: };
356:
357: /* The Tulip Rx and Tx buffer descriptors. */
358: struct tulip_rx_desc {
359: s32 status;
360: s32 length;
361: u32 buffer1, buffer2;
362: };
363:
364: struct tulip_tx_desc {
365: s32 status;
366: s32 length;
367: u32 buffer1, buffer2; /* We use only buffer 1. */
368: };
369:
370: struct medialeaf {
371: u8 type;
372: u8 media;
373: unsigned char *leafdata;
374: };
375:
376: struct mediatable {
377: u16 defaultmedia;
378: u8 leafcount, csr12dir; /* General purpose pin directions. */
379: unsigned has_mii:1, has_nonmii:1;
380: struct medialeaf mleaf[0];
381: };
382:
383: struct mediainfo {
384: struct mediainfo *next;
385: int info_type;
386: int index;
387: unsigned char *info;
388: };
389:
390: struct tulip_private {
391: char devname[8]; /* Used only for kernel debugging. */
392: const char *product_name;
393: struct device *next_module;
394: struct tulip_rx_desc rx_ring[RX_RING_SIZE];
395: struct tulip_tx_desc tx_ring[TX_RING_SIZE];
396: /* The saved address of a sent-in-place packet/buffer, for skfree(). */
397: struct sk_buff* tx_skbuff[TX_RING_SIZE];
398: /* The addresses of receive-in-place skbuffs. */
399: struct sk_buff* rx_skbuff[RX_RING_SIZE];
400: char *rx_buffs; /* Address of temporary Rx buffers. */
401: u32 setup_frame[48]; /* Pseudo-Tx frame to init address table. */
402: int chip_id;
403: int revision;
404: #if LINUX_VERSION_CODE > 0x20139
405: struct net_device_stats stats;
406: #else
407: struct enet_statistics stats;
408: #endif
409: struct timer_list timer; /* Media selection timer. */
410: int interrupt; /* In-interrupt flag. */
411: #ifdef SMP_CHECK
412: int smp_proc_id; /* Which processor in IRQ handler. */
413: #endif
414: unsigned int cur_rx, cur_tx; /* The next free ring entry */
415: unsigned int dirty_rx, dirty_tx; /* The ring entries to be free()ed. */
416: unsigned int tx_full:1; /* The Tx queue is full. */
417: unsigned int full_duplex:1; /* Full-duplex operation requested. */
418: unsigned int full_duplex_lock:1;
419: unsigned int fake_addr:1; /* Multiport board faked address. */
420: unsigned int default_port:4; /* Last dev->if_port value. */
421: unsigned int media2:4; /* Secondary monitored media port. */
422: unsigned int medialock:1; /* Don't sense media type. */
423: unsigned int mediasense:1; /* Media sensing in progress. */
424: unsigned int csr6; /* Current CSR6 control settings. */
425: unsigned char eeprom[128]; /* Serial EEPROM contents. */
426: u16 to_advertise; /* NWay capabilities advertised. */
427: u16 advertising[4];
428: signed char phys[4], mii_cnt; /* MII device addresses. */
429: struct mediatable *mtable;
430: int cur_index; /* Current media index. */
431: unsigned char pci_bus, pci_dev_fn;
432: int pad0, pad1; /* Used for 8-byte alignment */
433: };
434:
435: static struct device *tulip_probe1(int pci_bus, int pci_devfn,
436: struct device *dev,
437: int chip_id, int options);
438: static void parse_eeprom(struct device *dev);
439: static int read_eeprom(long ioaddr, int location);
440: static int mdio_read(struct device *dev, int phy_id, int location);
441: static void mdio_write(struct device *dev, int phy_id, int location, int value);
442: static void select_media(struct device *dev, int startup);
443: static int tulip_open(struct device *dev);
444: static void tulip_timer(unsigned long data);
445: static void tulip_tx_timeout(struct device *dev);
446: static void tulip_init_ring(struct device *dev);
447: static int tulip_start_xmit(struct sk_buff *skb, struct device *dev);
448: static int tulip_rx(struct device *dev);
449: static void tulip_interrupt IRQ(int irq, void *dev_instance, struct pt_regs *regs);
450: static int tulip_close(struct device *dev);
451: static struct enet_statistics *tulip_get_stats(struct device *dev);
452: #ifdef HAVE_PRIVATE_IOCTL
453: static int private_ioctl(struct device *dev, struct ifreq *rq, int cmd);
454: #endif
455: #ifdef NEW_MULTICAST
456: static void set_rx_mode(struct device *dev);
457: #else
458: static void set_rx_mode(struct device *dev, int num_addrs, void *addrs);
459: #endif
460:
461:
462:
463: /* A list of all installed Tulip devices, for removing the driver module. */
464: static struct device *root_tulip_dev = NULL;
465:
466: /* This 21040 probe no longer uses a large fixed contiguous Rx buffer region,
467: but now receives directly into full-sized skbuffs that are allocated
468: at open() time.
469: This allows the probe routine to use the old driver initialization
470: interface. */
471:
472: int tulip_probe(struct device *dev)
473: {
474: int cards_found = 0;
475: static int pci_index = 0; /* Static, for multiple probe calls. */
476: unsigned char pci_bus, pci_device_fn;
477:
478: /* Ideally we would detect all network cards in slot order. That would
479: be best done a central PCI probe dispatch, which wouldn't work
480: well with the current structure. So instead we detect just the
481: Tulip cards in slot order. */
482:
483: #if LINUX_VERSION_CODE >= 0x20155
484: if (! pci_present())
485: return -ENODEV;
486: #else
487: if (! pcibios_present())
488: return -ENODEV;
489: #endif
490: for (;pci_index < 0xff; pci_index++) {
491: u16 vendor, device, pci_command, new_command;
492: u32 pci_ioaddr;
493: int chip_idx = 0;
494:
495: if (pcibios_find_class
496: (PCI_CLASS_NETWORK_ETHERNET << 8,
497: reverse_probe ? 0xfe - pci_index : pci_index,
498: &pci_bus, &pci_device_fn) != PCIBIOS_SUCCESSFUL)
499: if (reverse_probe)
500: continue;
501: else
502: break;
503: pcibios_read_config_word(pci_bus, pci_device_fn,
504: PCI_VENDOR_ID, &vendor);
505: pcibios_read_config_word(pci_bus, pci_device_fn,
506: PCI_DEVICE_ID, &device);
507:
508: for (chip_idx = 0; tulip_tbl[chip_idx].chip_name; chip_idx++)
509: if (vendor == tulip_tbl[chip_idx].vendor_id &&
510: device == tulip_tbl[chip_idx].device_id)
511: break;
512: if (tulip_tbl[chip_idx].chip_name == 0) {
513: if (vendor == PCI_VENDOR_ID_DEC ||
514: vendor == PCI_VENDOR_ID_LITEON)
515: printk(KERN_INFO "Unknown Tulip-style PCI ethernet chip type"
516: " %4.4x %4.4x"" detected: not configured.\n",
517: vendor, device);
518: continue;
519: }
520: #if LINUX_VERSION_CODE >= 0x20155
521: pci_ioaddr = pci_find_slot(pci_bus, pci_device_fn)->base_address[0];
522: #else
523: pcibios_read_config_dword(pci_bus, pci_device_fn, PCI_BASE_ADDRESS_0,
524: &pci_ioaddr);
525: #endif
526: /* Remove I/O space marker in bit 0. */
527: pci_ioaddr &= ~3;
528:
529: if (tulip_debug > 2)
530: printk(KERN_DEBUG "Found %s at I/O %#x.\n",
531: tulip_tbl[chip_idx].chip_name, pci_ioaddr);
532:
533: if (check_region(pci_ioaddr, tulip_tbl[chip_idx].io_size))
534: continue;
535:
536: pcibios_read_config_word(pci_bus, pci_device_fn,
537: PCI_COMMAND, &pci_command);
538: new_command = pci_command | PCI_COMMAND_MASTER|PCI_COMMAND_IO;
539: if (pci_command != new_command) {
540: printk(KERN_INFO " The PCI BIOS has not enabled this"
541: " device! Updating PCI command %4.4x->%4.4x.\n",
542: pci_command, new_command);
543: pcibios_write_config_word(pci_bus, pci_device_fn,
544: PCI_COMMAND, new_command);
545: }
546:
547: dev = tulip_probe1(pci_bus, pci_device_fn, dev, chip_idx, cards_found);
548:
549: /* Get and check the bus-master and latency values. */
550: if (dev) {
551: unsigned char pci_latency;
552: pcibios_read_config_byte(pci_bus, pci_device_fn,
553: PCI_LATENCY_TIMER, &pci_latency);
554: if (pci_latency < 10) {
555: printk(KERN_INFO " PCI latency timer (CFLT) is "
556: "unreasonably low at %d. Setting to 64 clocks.\n",
557: pci_latency);
558: pcibios_write_config_byte(pci_bus, pci_device_fn,
559: PCI_LATENCY_TIMER, 64);
560: } else if (tulip_debug > 1)
561: printk(KERN_INFO " PCI latency timer (CFLT) is %#x, "
562: " PCI command is %4.4x.\n",
563: pci_latency, new_command);
564: /* Bring the 21143 out power-down mode. */
565: if (device == PCI_DEVICE_ID_DEC_TULIP_21142)
566: pcibios_write_config_dword(pci_bus, pci_device_fn,
567: 0x40, 0x40000000);
568: dev = 0;
569: cards_found++;
570: }
571: }
572:
573: return cards_found ? 0 : -ENODEV;
574: }
575:
576: static struct device *tulip_probe1(int pci_bus, int pci_device_fn,
577: struct device *dev,
578: int chip_id, int board_idx)
579: {
580: static int did_version = 0; /* Already printed version info. */
581: struct tulip_private *tp;
582: long ioaddr;
583: int irq;
584: /* See note below on the multiport cards. */
585: static unsigned char last_phys_addr[6] = {0x00, 'L', 'i', 'n', 'u', 'x'};
586: static int last_irq = 0;
587: static int multiport_cnt = 0; /* For four-port boards w/one EEPROM */
588: int i;
589: unsigned short sum;
590:
591: if (tulip_debug > 0 && did_version++ == 0)
592: printk(KERN_INFO "%s", version);
593:
594: dev = init_etherdev(dev, 0);
595:
596: #if LINUX_VERSION_CODE >= 0x20155
597: irq = pci_find_slot(pci_bus, pci_device_fn)->irq;
598: ioaddr = pci_find_slot(pci_bus, pci_device_fn)->base_address[0];
599: #else
600: {
601: u8 pci_irq_line;
602: u32 pci_ioaddr;
603: pcibios_read_config_byte(pci_bus, pci_device_fn,
604: PCI_INTERRUPT_LINE, &pci_irq_line);
605: pcibios_read_config_dword(pci_bus, pci_device_fn, PCI_BASE_ADDRESS_0,
606: &pci_ioaddr);
607: irq = pci_irq_line;
608: ioaddr = pci_ioaddr;
609: }
610: #endif
611: /* Remove I/O space marker in bit 0. */
612: ioaddr &= ~3;
613:
614: printk(KERN_INFO "%s: %s at %#3lx,",
615: dev->name, tulip_tbl[chip_id].chip_name, ioaddr);
616:
617: /* Stop the chip's Tx and Rx processes. */
618: outl(inl(ioaddr + CSR6) & ~0x2002, ioaddr + CSR6);
619: /* Clear the missed-packet counter. */
620: (volatile int)inl(ioaddr + CSR8);
621:
622: if (chip_id == DC21041) {
623: if (inl(ioaddr + CSR9) & 0x8000) {
624: printk(" 21040 compatible mode,");
625: chip_id = DC21040;
626: } else {
627: printk(" 21041 mode,");
628: }
629: }
630:
631: /* The station address ROM is read byte serially. The register must
632: be polled, waiting for the value to be read bit serially from the
633: EEPROM.
634: */
635: sum = 0;
636: if (chip_id == DC21040) {
637: outl(0, ioaddr + CSR9); /* Reset the pointer with a dummy write. */
638: for (i = 0; i < 6; i++) {
639: int value, boguscnt = 100000;
640: do
641: value = inl(ioaddr + CSR9);
642: while (value < 0 && --boguscnt > 0);
643: dev->dev_addr[i] = value;
644: sum += value & 0xff;
645: }
646: } else if (chip_id == LC82C168) {
647: for (i = 0; i < 3; i++) {
648: int value, boguscnt = 100000;
649: outl(0x600 | i, ioaddr + 0x98);
650: do
651: value = inl(ioaddr + CSR9);
652: while (value < 0 && --boguscnt > 0);
653: ((u16*)dev->dev_addr)[i] = value;
654: sum += value & 0xffff;
655: }
656: } else { /* Must be a new chip, with a serial EEPROM interface. */
657: /* We read the whole EEPROM, and sort it out later. DEC has a
658: specification _Digital Semiconductor 21X4 Serial ROM Format_
659: but early vendor boards just put the address in the first six
660: EEPROM locations. */
661: unsigned char ee_data[128];
662: int sa_offset = 0;
663:
664: for (i = 0; i < sizeof(ee_data)/2; i++)
665: ((u16 *)ee_data)[i] = read_eeprom(ioaddr, i);
666:
667: /* Detect the simple EEPROM format by the duplicated station addr. */
668: for (i = 0; i < 8; i ++)
669: if (ee_data[i] != ee_data[16+i])
670: sa_offset = 20;
671: if (ee_data[0] == 0xff && ee_data[1] == 0xff && ee_data[2] == 0) {
672: sa_offset = 2; /* Grrr, damn Matrox boards. */
673: multiport_cnt = 4;
674: }
675: for (i = 0; i < 6; i ++) {
676: dev->dev_addr[i] = ee_data[i + sa_offset];
677: sum += ee_data[i + sa_offset];
678: }
679: }
680: /* Lite-On boards have the address byte-swapped. */
681: if (dev->dev_addr[0] == 0xA0 && dev->dev_addr[1] == 0x00)
682: for (i = 0; i < 6; i+=2) {
683: char tmp = dev->dev_addr[i];
684: dev->dev_addr[i] = dev->dev_addr[i+1];
685: dev->dev_addr[i+1] = tmp;
686: }
687: /* On the Zynx 315 Etherarray and other multiport boards only the
688: first Tulip has an EEPROM.
689: The addresses of the subsequent ports are derived from the first.
690: Many PCI BIOSes also incorrectly report the IRQ line, so we correct
691: that here as well. */
692: if (sum == 0 || sum == 6*0xff) {
693: printk(" EEPROM not present,");
694: for (i = 0; i < 5; i++)
695: dev->dev_addr[i] = last_phys_addr[i];
696: dev->dev_addr[i] = last_phys_addr[i] + 1;
697: #if defined(__i386__) /* This BIOS bug doesn't exist on Alphas. */
698: irq = last_irq;
699: #endif
700: }
701:
702: for (i = 0; i < 6; i++)
703: printk(" %2.2x", last_phys_addr[i] = dev->dev_addr[i]);
704: printk(", IRQ %d.\n", irq);
705: last_irq = irq;
706:
707: /* We do a request_region() only to register /proc/ioports info. */
708: /* Note that proper size is tulip_tbl[chip_id].chip_name, but... */
709: request_region(ioaddr, TULIP_TOTAL_SIZE, dev->name);
710:
711: dev->base_addr = ioaddr;
712: dev->irq = irq;
713:
714: /* Make certain the data structures are quadword aligned. */
715: tp = (void *)(((long)kmalloc(sizeof(*tp), GFP_KERNEL | GFP_DMA) + 7) & ~7);
716: memset(tp, 0, sizeof(*tp));
717: dev->priv = tp;
718:
719: tp->next_module = root_tulip_dev;
720: root_tulip_dev = dev;
721:
722: tp->pci_bus = pci_bus;
723: tp->pci_dev_fn = pci_device_fn;
724: tp->chip_id = chip_id;
725:
726: #ifdef TULIP_FULL_DUPLEX
727: tp->full_duplex = 1;
728: tp->full_duplex_lock = 1;
729: #endif
730: #ifdef TULIP_DEFAULT_MEDIA
731: tp->default_port = TULIP_DEFAULT_MEDIA;
732: #endif
733: #ifdef TULIP_NO_MEDIA_SWITCH
734: tp->medialock = 1;
735: #endif
736:
737: /* The lower four bits are the media type. */
738: if (board_idx >= 0 && board_idx < MAX_UNITS) {
739: tp->default_port = options[board_idx] & 15;
740: if ((options[board_idx] & 0x90) || full_duplex[board_idx] > 0)
741: tp->full_duplex = 1;
742: if (mtu[board_idx] > 0)
743: dev->mtu = mtu[board_idx];
744: }
745: if (dev->mem_start)
746: tp->default_port = dev->mem_start;
747: if (tp->default_port) {
748: tp->medialock = 1;
749: if (media_cap[tp->default_port] & MediaAlwaysFD)
750: tp->full_duplex = 1;
751: }
752: if (tp->full_duplex)
753: tp->full_duplex_lock = 1;
754:
755: /* This is logically part of probe1(), but too complex to write inline. */
756: if (tulip_tbl[chip_id].flags & HAS_MEDIA_TABLE)
757: parse_eeprom(dev);
758:
759: if (media_cap[tp->default_port] & MediaIsMII) {
760: u16 media2advert[] = { 0x20, 0x40, 0x03e0, 0x60, 0x80, 0x100, 0x200 };
761: tp->to_advertise = media2advert[tp->default_port - 9];
762: } else
763: tp->to_advertise = 0x03e1;
764:
765: if ((tp->mtable && tp->mtable->has_mii) ||
766: ( ! tp->mtable && (tulip_tbl[tp->chip_id].flags & HAS_MII))) {
767: int phy, phy_idx;
768: /* Find the connected MII xcvrs.
769: Doing this in open() would allow detecting external xcvrs later,
770: but takes much time. */
771: for (phy = 0, phy_idx = 0; phy < 32 && phy_idx < sizeof(tp->phys);
772: phy++) {
773: int mii_status = mdio_read(dev, phy, 1);
774: if (mii_status != 0xffff && mii_status != 0x0000) {
775: int mii_reg0 = mdio_read(dev, phy, 0);
776: int reg4 = ((mii_status>>6) & tp->to_advertise) | 1;
777: tp->phys[phy_idx] = phy;
778: tp->advertising[phy_idx++] = reg4;
779: printk(KERN_INFO "%s: MII transceiver found at MDIO address "
780: "%d, config %4.4x status %4.4x.\n",
781: dev->name, phy, mii_reg0, mii_status);
782: if (1 || (media_cap[tp->default_port] & MediaIsMII)) {
783: printk(KERN_DEBUG "%s: Advertising %4.4x on PHY %d,"
784: " previously advertising %4.4x.\n",
785: dev->name, reg4, phy, mdio_read(dev, phy, 4));
786: mdio_write(dev, phy, 4, reg4);
787: }
788: /* Enable autonegotiation: some boards default to off. */
789: mdio_write(dev, phy, 0, mii_reg0 |
790: (tp->full_duplex ? 0x1100 : 0x1000) |
791: (media_cap[tp->default_port]&MediaIs100 ? 0x2000:0));
792: }
793: }
794: tp->mii_cnt = phy_idx;
795: if (tp->mtable && tp->mtable->has_mii && phy_idx == 0) {
796: printk(KERN_INFO "%s: ***WARNING***: No MII transceiver found!\n",
797: dev->name);
798: tp->phys[0] = 1;
799: }
800: }
801:
802: /* The Tulip-specific entries in the device structure. */
803: dev->open = &tulip_open;
804: dev->hard_start_xmit = &tulip_start_xmit;
805: dev->stop = &tulip_close;
806: dev->get_stats = &tulip_get_stats;
807: #ifdef HAVE_PRIVATE_IOCTL
808: dev->do_ioctl = &private_ioctl;
809: #endif
810: #ifdef HAVE_MULTICAST
811: dev->set_multicast_list = &set_rx_mode;
812: #endif
813:
814: /* Reset the xcvr interface and turn on heartbeat. */
815: switch (chip_id) {
816: case DC21041:
817: outl(0x00000000, ioaddr + CSR13);
818: outl(0xFFFFFFFF, ioaddr + CSR14);
819: outl(0x00000008, ioaddr + CSR15); /* Listen on AUI also. */
820: outl(inl(ioaddr + CSR6) | 0x0200, ioaddr + CSR6);
821: outl(0x0000EF05, ioaddr + CSR13);
822: break;
823: case DC21040:
824: outl(0x00000000, ioaddr + CSR13);
825: outl(0x00000004, ioaddr + CSR13);
826: break;
827: case DC21140: default:
828: if (tp->mtable)
829: outl(tp->mtable->csr12dir | 0x100, ioaddr + CSR12);
830: break;
831: case DC21142:
832: outl(0x82420200, ioaddr + CSR6);
833: outl(0x0001, ioaddr + CSR13);
834: outl(0x0003FFFF, ioaddr + CSR14);
835: outl(0x0008, ioaddr + CSR15);
836: outl(0x0001, ioaddr + CSR13);
837: outl(0x1301, ioaddr + CSR12); /* Start NWay. */
838: break;
839: case LC82C168:
840: if ( ! tp->mii_cnt) {
841: outl(0x00420000, ioaddr + CSR6);
842: outl(0x30, ioaddr + CSR12);
843: outl(0x0001F078, ioaddr + 0xB8);
844: outl(0x0201F078, ioaddr + 0xB8); /* Turn on autonegotiation. */
845: }
846: break;
847: case MX98713: case MX98715: case MX98725:
848: outl(0x00000000, ioaddr + CSR6);
849: outl(0x000711C0, ioaddr + CSR14); /* Turn on NWay. */
850: outl(0x00000001, ioaddr + CSR13);
851: break;
852: }
853:
854: return dev;
855: }
856:
857: /* Serial EEPROM section. */
858: /* The main routine to parse the very complicated SROM structure.
859: Search www.digital.com for "21X4 SROM" to get details.
860: This code is very complex, and will require changes to support
861: additional cards, so I'll be verbose about what is going on.
862: */
863:
864: /* Known cards that have old-style EEPROMs. */
865: static struct fixups {
866: char *name;
867: unsigned char addr0, addr1, addr2;
868: u16 newtable[32]; /* Max length below. */
869: } eeprom_fixups[] = {
870: {"Asante", 0, 0, 0x94, {0x1e00, 0x0000, 0x0800, 0x0100, 0x018c,
871: 0x0000, 0x0000, 0xe078, 0x0001, 0x0050, 0x0018 }},
872: {"SMC9332DST", 0, 0, 0xC0, { 0x1e00, 0x0000, 0x0800, 0x021f,
873: 0x0000, 0x009E, /* 10baseT */
874: 0x0903, 0x006D, /* 100baseTx */ }},
875: {"Cogent EM100", 0, 0, 0x92, { 0x1e00, 0x0000, 0x0800, 0x033f,
876: 0x0107, 0x8021, /* 100baseFx */
877: 0x0108, 0x8021, /* 100baseFx-FD */
878: 0x0103, 0x006D, /* 100baseTx */ }},
879: {"Maxtech NX-110", 0, 0, 0xE8, { 0x1e00, 0x0000, 0x0800, 0x0313,
880: 0x1001, 0x009E, /* 10base2, CSR12 0x10*/
881: 0x0000, 0x009E, /* 10baseT */
882: 0x0303, 0x006D, /* 100baseTx, CSR12 0x03 */ }},
883: {"Accton EN1207", 0, 0, 0xE8, { 0x1e00, 0x0000, 0x0800, 0x031F,
884: 0x1B01, 0x0000, /* 10base2, CSR12 0x1B */
885: 0x1B03, 0x006D, /* 100baseTx, CSR12 0x1B */
886: 0x0B00, 0x009E, /* 10baseT, CSR12 0x0B */
887: }},
888: {0, 0, 0, 0, {}}};
889:
890: static const char * block_name[] = {"21140 non-MII", "21140 MII PHY",
891: "21142 Serial PHY", "21142 MII PHY", "21143 SYM PHY", "21143 reset method"};
892:
893: #define EEPROM_SIZE 128
894: #if defined(__i386__)
895: #define get_u16(ptr) (*(u16 *)(ptr))
896: #else
897: #define get_u16(ptr) (((u8*)(ptr))[0] + (((u8*)(ptr))[1]<<8))
898: #endif
899:
900: static void parse_eeprom(struct device *dev)
901: {
902: /* The last media info list parsed, for multiport boards. */
903: static struct mediatable *last_mediatable = NULL;
904: static unsigned char *last_ee_data = NULL;
905: static int controller_index = 0;
906: struct tulip_private *tp = (struct tulip_private *)dev->priv;
907: long ioaddr = dev->base_addr;
908: unsigned char *ee_data = tp->eeprom;
909: int i;
910:
911: tp->mtable = 0;
912: for (i = 0; i < EEPROM_SIZE/2; i++)
913: ((u16 *)ee_data)[i] = read_eeprom(ioaddr, i);
914:
915: /* Detect an old-style (SA only) EEPROM layout:
916: memcmp(eedata, eedata+16, 8). */
917: for (i = 0; i < 8; i ++)
918: if (ee_data[i] != ee_data[16+i])
919: break;
920: if (i >= 8) {
921: if (ee_data[0] == 0xff) {
922: if (last_mediatable) {
923: controller_index++;
924: printk(KERN_INFO "%s: Controller %d of multiport board.\n",
925: dev->name, controller_index);
926: tp->mtable = last_mediatable;
927: ee_data = last_ee_data;
928: goto subsequent_board;
929: } else
930: printk(KERN_INFO "%s: Missing EEPROM, this interface may "
931: "not work correctly!\n",
932: dev->name);
933: return;
934: }
935: /* Do a fix-up based on the vendor half of the station address prefix. */
936: for (i = 0; eeprom_fixups[i].name; i++) {
937: if (dev->dev_addr[0] == eeprom_fixups[i].addr0
938: && dev->dev_addr[1] == eeprom_fixups[i].addr1
939: && dev->dev_addr[2] == eeprom_fixups[i].addr2) {
940: if (dev->dev_addr[2] == 0xE8 && ee_data[0x1a] == 0x55)
941: i++; /* An Accton EN1207, not an outlaw Maxtech. */
942: memcpy(ee_data + 26, eeprom_fixups[i].newtable,
943: sizeof(eeprom_fixups[i].newtable));
944: printk(KERN_INFO "%s: Old format EEPROM on '%s' board. Using"
945: " substitute media control info.\n",
946: dev->name, eeprom_fixups[i].name);
947: break;
948: }
949: }
950: if (eeprom_fixups[i].name == NULL) { /* No fixup found. */
951: printk(KERN_INFO "%s: Old style EEPROM -- no media selection information.\n",
952: dev->name);
953: return;
954: }
955: }
956: if (tulip_debug > 1) {
957: printk(KERN_DEBUG "read_eeprom:");
958: for (i = 0; i < 64; i++) {
959: printk("%s%4.4x", (i & 7) == 0 ? "\n" KERN_DEBUG : " ",
960: read_eeprom(ioaddr, i));
961: }
962: printk("\n");
963: }
964:
965: controller_index = 0;
966: if (ee_data[19] > 1) { /* Multiport board. */
967: last_ee_data = ee_data;
968: }
969: subsequent_board:
970:
971: if (ee_data[27] == 0) { /* No valid media table. */
972: } else if (tp->chip_id == DC21041) {
973: unsigned char *p = (void *)ee_data + ee_data[27 + controller_index*3];
974: short media;
975: int count;
976:
977: media = get_u16(p);
978: p += 2;
979: count = *p++;
980:
981: printk(KERN_INFO "%s:21041 Media information at %d, default media "
982: "%4.4x (%s).\n", dev->name, ee_data[27], media,
983: media & 0x0800 ? "Autosense" : medianame[media & 15]);
984: for (i = 0; i < count; i++) {
985: unsigned char media_code = *p++;
986: u16 csrvals[3];
987: int idx;
988: for (idx = 0; idx < 3; idx++) {
989: csrvals[idx] = get_u16(p);
990: p += 2;
991: }
992: if (media_code & 0x40) {
993: printk(KERN_INFO "%s: 21041 media %2.2x (%s),"
994: " csr13 %4.4x csr14 %4.4x csr15 %4.4x.\n",
995: dev->name, media_code & 15, medianame[media_code & 15],
996: csrvals[0], csrvals[1], csrvals[2]);
997: } else
998: printk(KERN_INFO "%s: 21041 media #%d, %s.\n",
999: dev->name, media_code & 15, medianame[media_code & 15]);
1000: }
1001: } else {
1002: unsigned char *p = (void *)ee_data + ee_data[27];
1003: unsigned char csr12dir = 0;
1004: int count;
1005: struct mediatable *mtable;
1006: u16 media = get_u16(p);
1007:
1008: p += 2;
1009: if (tulip_tbl[tp->chip_id].flags & CSR12_IN_SROM)
1010: csr12dir = *p++;
1011: count = *p++;
1012: mtable = (struct mediatable *)
1013: kmalloc(sizeof(struct mediatable) + count*sizeof(struct medialeaf),
1014: GFP_KERNEL);
1015: if (mtable == NULL)
1016: return; /* Horrible, impossible failure. */
1017: last_mediatable = tp->mtable = mtable;
1018: mtable->defaultmedia = media;
1019: mtable->leafcount = count;
1020: mtable->csr12dir = csr12dir;
1021: mtable->has_nonmii = mtable->has_mii = 0;
1022:
1023: printk(KERN_INFO "%s: EEPROM default media type %s.\n", dev->name,
1024: media & 0x0800 ? "Autosense" : medianame[media & 15]);
1025: for (i = 0; i < count; i++) {
1026: struct medialeaf *leaf = &mtable->mleaf[i];
1027:
1028: if ((p[0] & 0x80) == 0) { /* 21140 Compact block. */
1029: leaf->type = 0;
1030: leaf->media = p[0] & 0x3f;
1031: leaf->leafdata = p;
1032: if ((p[2] & 0x61) == 0x01) /* Bogus, but Znyx boards do it. */
1033: mtable->has_mii = 1;
1034: p += 4;
1035: } else {
1036: leaf->type = p[1];
1037: if (p[1] & 1) {
1038: mtable->has_mii = 1;
1039: leaf->media = 11;
1040: } else {
1041: mtable->has_nonmii = 1;
1042: leaf->media = p[2] & 0x0f;
1043: }
1044: leaf->leafdata = p + 2;
1045: p += (p[0] & 0x3f) + 1;
1046: }
1047: if (tulip_debug > 1 && leaf->media == 11) {
1048: unsigned char *bp = leaf->leafdata;
1049: printk(KERN_INFO "%s: MII interface PHY %d, setup/reset "
1050: "sequences %d/%d long, capabilities %2.2x %2.2x.\n",
1051: dev->name, bp[0], bp[1], bp[1 + bp[1]*2],
1052: bp[5 + bp[2 + bp[1]*2]*2], bp[4 + bp[2 + bp[1]*2]*2]);
1053: }
1054: printk(KERN_INFO "%s: Index #%d - Media %s (#%d) described "
1055: "by a %s (%d) block.\n",
1056: dev->name, i, medianame[leaf->media], leaf->media,
1057: block_name[leaf->type], leaf->type);
1058: }
1059: }
1060: }
1061: /* Reading a serial EEPROM is a "bit" grungy, but we work our way through:->.*/
1062:
1063: /* EEPROM_Ctrl bits. */
1064: #define EE_SHIFT_CLK 0x02 /* EEPROM shift clock. */
1065: #define EE_CS 0x01 /* EEPROM chip select. */
1066: #define EE_DATA_WRITE 0x04 /* EEPROM chip data in. */
1067: #define EE_WRITE_0 0x01
1068: #define EE_WRITE_1 0x05
1069: #define EE_DATA_READ 0x08 /* EEPROM chip data out. */
1070: #define EE_ENB (0x4800 | EE_CS)
1071:
1072: /* Delay between EEPROM clock transitions.
1073: The 1.2 code is a "nasty" timing loop, but PC compatible machines are
1074: *supposed* to delay an ISA-compatible period for the SLOW_DOWN_IO macro. */
1075: #ifdef _LINUX_DELAY_H
1076: #define eeprom_delay(nanosec) udelay((nanosec + 999)/1000)
1077: #else
1078: #define eeprom_delay(nanosec) do { int _i = 3; while (--_i > 0) { __SLOW_DOWN_IO; }} while (0)
1079: #endif
1080:
1081: /* The EEPROM commands include the alway-set leading bit. */
1082: #define EE_WRITE_CMD (5 << 6)
1083: #define EE_READ_CMD (6 << 6)
1084: #define EE_ERASE_CMD (7 << 6)
1085:
1086: static int read_eeprom(long ioaddr, int location)
1087: {
1088: int i;
1089: unsigned short retval = 0;
1090: long ee_addr = ioaddr + CSR9;
1091: int read_cmd = location | EE_READ_CMD;
1092:
1093: outl(EE_ENB & ~EE_CS, ee_addr);
1094: outl(EE_ENB, ee_addr);
1095:
1096: /* Shift the read command bits out. */
1097: for (i = 10; i >= 0; i--) {
1098: short dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
1099: outl(EE_ENB | dataval, ee_addr);
1100: eeprom_delay(100);
1101: outl(EE_ENB | dataval | EE_SHIFT_CLK, ee_addr);
1102: eeprom_delay(150);
1103: outl(EE_ENB | dataval, ee_addr); /* Finish EEPROM a clock tick. */
1104: eeprom_delay(250);
1105: }
1106: outl(EE_ENB, ee_addr);
1107:
1108: for (i = 16; i > 0; i--) {
1109: outl(EE_ENB | EE_SHIFT_CLK, ee_addr);
1110: eeprom_delay(100);
1111: retval = (retval << 1) | ((inl(ee_addr) & EE_DATA_READ) ? 1 : 0);
1112: outl(EE_ENB, ee_addr);
1113: eeprom_delay(100);
1114: }
1115:
1116: /* Terminate the EEPROM access. */
1117: outl(EE_ENB & ~EE_CS, ee_addr);
1118: return retval;
1119: }
1120:
1121: /* MII transceiver control section.
1122: Read and write the MII registers using software-generated serial
1123: MDIO protocol. See the MII specifications or DP83840A data sheet
1124: for details. */
1125:
1126: /* The maximum data clock rate is 2.5 Mhz. The minimum timing is usually
1127: met by back-to-back PCI I/O cycles, but we insert a delay to avoid
1128: "overclocking" issues or future 66Mhz PCI. */
1129: #define mdio_delay() inl(mdio_addr)
1130:
1131: /* Read and write the MII registers using software-generated serial
1132: MDIO protocol. It is just different enough from the EEPROM protocol
1133: to not share code. The maxium data clock rate is 2.5 Mhz. */
1134: #define MDIO_SHIFT_CLK 0x10000
1135: #define MDIO_DATA_WRITE0 0x00000
1136: #define MDIO_DATA_WRITE1 0x20000
1137: #define MDIO_ENB 0x00000 /* Ignore the 0x02000 databook setting. */
1138: #define MDIO_ENB_IN 0x40000
1139: #define MDIO_DATA_READ 0x80000
1140:
1141: static int mdio_read(struct device *dev, int phy_id, int location)
1142: {
1143: struct tulip_private *tp = (struct tulip_private *)dev->priv;
1144: int i;
1145: int read_cmd = (0xf6 << 10) | (phy_id << 5) | location;
1146: int retval = 0;
1147: long mdio_addr = dev->base_addr + CSR9;
1148:
1149: if (tp->chip_id == LC82C168) {
1150: long ioaddr = dev->base_addr;
1151: int i = 1000;
1152: outl(0x60020000 + (phy_id<<23) + (location<<18), ioaddr + 0xA0);
1153: while (--i > 0)
1154: if ( ! ((retval = inl(ioaddr + 0xA0)) & 0x80000000))
1155: return retval & 0xffff;
1156: return 0xffff;
1157: }
1158:
1159: /* Establish sync by sending at least 32 logic ones. */
1160: for (i = 32; i >= 0; i--) {
1161: outl(MDIO_ENB | MDIO_DATA_WRITE1, mdio_addr);
1162: mdio_delay();
1163: outl(MDIO_ENB | MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, mdio_addr);
1164: mdio_delay();
1165: }
1166: /* Shift the read command bits out. */
1167: for (i = 15; i >= 0; i--) {
1168: int dataval = (read_cmd & (1 << i)) ? MDIO_DATA_WRITE1 : 0;
1169:
1170: outl(MDIO_ENB | dataval, mdio_addr);
1171: mdio_delay();
1172: outl(MDIO_ENB | dataval | MDIO_SHIFT_CLK, mdio_addr);
1173: mdio_delay();
1174: }
1175: /* Read the two transition, 16 data, and wire-idle bits. */
1176: for (i = 19; i > 0; i--) {
1177: outl(MDIO_ENB_IN, mdio_addr);
1178: mdio_delay();
1179: retval = (retval << 1) | ((inl(mdio_addr) & MDIO_DATA_READ) ? 1 : 0);
1180: outl(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
1181: mdio_delay();
1182: }
1183: return (retval>>1) & 0xffff;
1184: }
1185:
1186: static void mdio_write(struct device *dev, int phy_id, int location, int value)
1187: {
1188: struct tulip_private *tp = (struct tulip_private *)dev->priv;
1189: int i;
1190: int cmd = (0x5002 << 16) | (phy_id << 23) | (location<<18) | value;
1191: long mdio_addr = dev->base_addr + CSR9;
1192:
1193: if (tp->chip_id == LC82C168) {
1194: long ioaddr = dev->base_addr;
1195: int i = 1000;
1196: outl(cmd, ioaddr + 0xA0);
1197: do
1198: if ( ! (inl(ioaddr + 0xA0) & 0x80000000))
1199: break;
1200: while (--i > 0);
1201: return;
1202: }
1203:
1204: /* Establish sync by sending 32 logic ones. */
1205: for (i = 32; i >= 0; i--) {
1206: outl(MDIO_ENB | MDIO_DATA_WRITE1, mdio_addr);
1207: mdio_delay();
1208: outl(MDIO_ENB | MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, mdio_addr);
1209: mdio_delay();
1210: }
1211: /* Shift the command bits out. */
1212: for (i = 31; i >= 0; i--) {
1213: int dataval = (cmd & (1 << i)) ? MDIO_DATA_WRITE1 : 0;
1214: outl(MDIO_ENB | dataval, mdio_addr);
1215: mdio_delay();
1216: outl(MDIO_ENB | dataval | MDIO_SHIFT_CLK, mdio_addr);
1217: mdio_delay();
1218: }
1219: /* Clear out extra bits. */
1220: for (i = 2; i > 0; i--) {
1221: outl(MDIO_ENB_IN, mdio_addr);
1222: mdio_delay();
1223: outl(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
1224: mdio_delay();
1225: }
1226: return;
1227: }
1228:
1229:
1230: static int
1231: tulip_open(struct device *dev)
1232: {
1233: struct tulip_private *tp = (struct tulip_private *)dev->priv;
1234: long ioaddr = dev->base_addr;
1235: int i = 0;
1236:
1237: /* On some chip revs we must set the MII/SYM port before the reset!? */
1238: if (tp->mii_cnt || (tp->mtable && tp->mtable->has_mii))
1239: outl(0x00040000, ioaddr + CSR6);
1240:
1241: /* Reset the chip, holding bit 0 set at least 50 PCI cycles. */
1242: outl(0x00000001, ioaddr + CSR0);
1243: #ifdef _LINUX_DELAY_H
1244: udelay(2);
1245: #else
1246: SLOW_DOWN_IO;
1247: #endif
1248: /* Deassert reset.
1249: 486: Set 8 longword cache alignment, 8 longword burst.
1250: 586: Set 16 longword cache alignment, no burst limit.
1251: Cache alignment bits 15:14 Burst length 13:8
1252: 0000 No alignment 0x00000000 unlimited 0800 8 longwords
1253: 4000 8 longwords 0100 1 longword 1000 16 longwords
1254: 8000 16 longwords 0200 2 longwords 2000 32 longwords
1255: C000 32 longwords 0400 4 longwords
1256: Wait the specified 50 PCI cycles after a reset by initializing
1257: Tx and Rx queues and the address filter list. */
1258: #if defined(__alpha__)
1259: /* ToDo: Alpha setting could be better. */
1260: outl(0x01A00000 | 0xE000, ioaddr + CSR0);
1261: #elif defined(__powerpc__)
1262: outl(0x01A00080 | 0x8000, ioaddr + CSR0);
1263: #elif defined(__i386__)
1264: #if defined(MODULE)
1265: /* When a module we don't have 'x86' to check. */
1266: outl(0x01A00000 | 0x4800, ioaddr + CSR0);
1267: #else
1268: #if (LINUX_VERSION_CODE > 0x2014c)
1269: #define x86 boot_cpu_data.x86
1270: #endif
1271: outl(0x01A00000 | (x86 <= 4 ? 0x4800 : 0x8000), ioaddr + CSR0);
1272: if (x86 <= 4)
1273: printk(KERN_INFO "%s: This is a 386/486 PCI system, setting cache "
1274: "alignment to %x.\n", dev->name,
1275: 0x01A00000 | (x86 <= 4 ? 0x4800 : 0x8000));
1276: #endif
1277: #else
1278: outl(0x01A00000 | 0x4800, ioaddr + CSR0);
1279: #warning Processor architecture undefined!
1280: #endif
1281:
1282: #ifdef SA_SHIRQ
1283: if (request_irq(dev->irq, &tulip_interrupt, SA_SHIRQ, dev->name, dev)) {
1284: return -EAGAIN;
1285: }
1286: #else
1287: if (irq2dev_map[dev->irq] != NULL
1288: || (irq2dev_map[dev->irq] = dev) == NULL
1289: || dev->irq == 0
1290: || request_irq(dev->irq, &tulip_interrupt, 0,
1291: tulip_tbl[tp->chip_id].chip_name)) {
1292: return -EAGAIN;
1293: }
1294: #endif
1295:
1296: if (tulip_debug > 1)
1297: printk(KERN_DEBUG "%s: tulip_open() irq %d.\n", dev->name, dev->irq);
1298:
1299: MOD_INC_USE_COUNT;
1300:
1301: tulip_init_ring(dev);
1302:
1303: /* This is set_rx_mode(), but without starting the transmitter. */
1304: /* Fill the whole address filter table with our physical address. */
1305: {
1306: u16 *eaddrs = (u16 *)dev->dev_addr;
1307: u32 *setup_frm = tp->setup_frame, i;
1308:
1309: /* You must add the broadcast address when doing perfect filtering! */
1310: *setup_frm++ = 0xffff;
1311: *setup_frm++ = 0xffff;
1312: *setup_frm++ = 0xffff;
1313: /* Fill the rest of the accept table with our physical address. */
1314: for (i = 1; i < 16; i++) {
1315: *setup_frm++ = eaddrs[0];
1316: *setup_frm++ = eaddrs[1];
1317: *setup_frm++ = eaddrs[2];
1318: }
1319: /* Put the setup frame on the Tx list. */
1320: tp->tx_ring[0].length = 0x08000000 | 192;
1321: tp->tx_ring[0].buffer1 = virt_to_bus(tp->setup_frame);
1322: tp->tx_ring[0].status = 0x80000000;
1323:
1324: tp->cur_tx++;
1325: }
1326:
1327: outl(virt_to_bus(tp->rx_ring), ioaddr + CSR3);
1328: outl(virt_to_bus(tp->tx_ring), ioaddr + CSR4);
1329:
1330: if (dev->if_port == 0)
1331: dev->if_port = tp->default_port;
1332: if (tp->chip_id == DC21041 && dev->if_port > 4)
1333: /* Invalid: Select initial TP, autosense, autonegotiate. */
1334: dev->if_port = 4;
1335:
1336: /* Allow selecting a default media. */
1337: if (tp->mtable == NULL)
1338: goto media_picked;
1339: if (dev->if_port) {
1340: int looking_for = media_cap[dev->if_port] & MediaIsMII ? 11 :
1341: (dev->if_port == 12 ? 0 : dev->if_port);
1342: for (i = 0; i < tp->mtable->leafcount; i++)
1343: if (tp->mtable->mleaf[i].media == looking_for) {
1344: printk(KERN_INFO "%s: Using user-specified media %s.\n",
1345: dev->name, medianame[dev->if_port]);
1346: goto media_picked;
1347: }
1348: }
1349: if ((tp->mtable->defaultmedia & 0x0800) == 0)
1350: for (i = 0; i < tp->mtable->leafcount; i++)
1351: if (tp->mtable->mleaf[i].media == (tp->mtable->defaultmedia & 15)) {
1352: printk(KERN_INFO "%s: Using EEPROM-set media %s.\n",
1353: dev->name, medianame[tp->mtable->mleaf[i].media]);
1354: goto media_picked;
1355: }
1356: /* Start sensing first non-full-duplex media. */
1357: for (i = tp->mtable->leafcount - 1;
1358: (media_cap[tp->mtable->mleaf[i].media] & MediaAlwaysFD) && i > 0; i--)
1359: ;
1360: media_picked:
1361:
1362: tp->csr6 = 0;
1363: tp->cur_index = i;
1364: if (dev->if_port == 0 && tp->chip_id == DC21142) {
1365: tp->csr6 = 0x82420200;
1366: outl(0x0003FFFF, ioaddr + CSR14);
1367: outl(0x0008, ioaddr + CSR15);
1368: outl(0x0001, ioaddr + CSR13);
1369: outl(0x1301, ioaddr + CSR12);
1370: } else if (tp->chip_id == LC82C168 && tp->mii_cnt && ! tp->medialock) {
1371: dev->if_port = 11;
1372: tp->csr6 = 0x816C0000 | (tp->full_duplex ? 0x0200 : 0);
1373: outl(0x0001, ioaddr + CSR15);
1374: } else
1375: select_media(dev, 1);
1376:
1377: /* Start the chip's Tx to process setup frame. */
1378: outl(tp->csr6, ioaddr + CSR6);
1379: outl(tp->csr6 | 0x2000, ioaddr + CSR6);
1380:
1381: dev->tbusy = 0;
1382: tp->interrupt = 0;
1383: dev->start = 1;
1384:
1385: /* Enable interrupts by setting the interrupt mask. */
1386: outl(tulip_tbl[tp->chip_id].valid_intrs, ioaddr + CSR5);
1387: outl(tulip_tbl[tp->chip_id].valid_intrs, ioaddr + CSR7);
1388: outl(tp->csr6 | 0x2002, ioaddr + CSR6);
1389: outl(0, ioaddr + CSR2); /* Rx poll demand */
1390:
1391: if (tulip_debug > 2) {
1392: printk(KERN_DEBUG "%s: Done tulip_open(), CSR0 %8.8x, CSR5 %8.8x CSR6 %8.8x.\n",
1393: dev->name, inl(ioaddr + CSR0), inl(ioaddr + CSR5),
1394: inl(ioaddr + CSR6));
1395: }
1396: /* Set the timer to switch to check for link beat and perhaps switch
1397: to an alternate media type. */
1398: init_timer(&tp->timer);
1399: tp->timer.expires = RUN_AT(5*HZ);
1400: tp->timer.data = (unsigned long)dev;
1401: tp->timer.function = tulip_tbl[tp->chip_id].media_timer;
1402: add_timer(&tp->timer);
1403:
1404: return 0;
1405: }
1406:
1407: /* Set up the transceiver control registers for the selected media type. */
1408: static void select_media(struct device *dev, int startup)
1409: {
1410: long ioaddr = dev->base_addr;
1411: struct tulip_private *tp = (struct tulip_private *)dev->priv;
1412: struct mediatable *mtable = tp->mtable;
1413: u32 new_csr6;
1414: int check_mii =0, i;
1415:
1416: if (mtable) {
1417: struct medialeaf *mleaf = &mtable->mleaf[tp->cur_index];
1418: unsigned char *p = mleaf->leafdata;
1419: switch (mleaf->type) {
1420: case 0: /* 21140 non-MII xcvr. */
1421: if (tulip_debug > 1)
1422: printk(KERN_DEBUG "%s: Using a 21140 non-MII transceiver"
1423: " with control setting %2.2x.\n",
1424: dev->name, p[1]);
1425: dev->if_port = p[0];
1426: if (startup)
1427: outl(mtable->csr12dir | 0x100, ioaddr + CSR12);
1428: outl(p[1], ioaddr + CSR12);
1429: new_csr6 = 0x02000000 | ((p[2] & 0x71) << 18);
1430: break;
1431: case 2: case 4: {
1432: u16 setup[3];
1433: for (i = 0; i < 3; i++)
1434: setup[i] = get_u16(&p[i*2 + 1]);
1435:
1436: dev->if_port = p[0] & 15;
1437: if (tulip_debug > 1)
1438: printk(KERN_DEBUG "%s: 21142 non-MII %s transceiver control %4.4x/%4.4x.\n",
1439: dev->name, medianame[dev->if_port], setup[0], setup[1]);
1440: if (p[0] & 0x40) { /* SIA (CSR13-15) setup values are provided. */
1441: outl(0, ioaddr + CSR13);
1442: outl(setup[1], ioaddr + CSR14);
1443: outl(setup[2], ioaddr + CSR15);
1444: outl(setup[0], ioaddr + CSR13);
1445: for (i = 0; i < 3; i++) /* Re-fill setup[] */
1446: setup[i] = get_u16(&p[i*2 + 7]);
1447: } else if (dev->if_port <= 4) {
1448: outl(0, ioaddr + CSR13);
1449: outl(t21142_csr14[dev->if_port], ioaddr + CSR14);
1450: outl(t21142_csr15[dev->if_port], ioaddr + CSR15);
1451: outl(t21142_csr13[dev->if_port], ioaddr + CSR13);
1452: } else {
1453: outl(0, ioaddr + CSR14);
1454: outl(8, ioaddr + CSR15);
1455: outl(0, ioaddr + CSR13);
1456: }
1457: outl(setup[0]<<16, ioaddr + CSR15); /* Direction */
1458: outl(setup[1]<<16, ioaddr + CSR15); /* Data */
1459: if (mleaf->type == 4)
1460: new_csr6 = 0x82020000 | ((setup[2] & 0x71) << 18);
1461: else
1462: new_csr6 = 0x82420000;
1463: break;
1464: }
1465: case 1: case 3: {
1466: int phy_num = p[0];
1467: int init_length = p[1];
1468: u16 *misc_info;
1469: u16 to_advertise;
1470:
1471: dev->if_port = 11;
1472: check_mii = 1;
1473: new_csr6 = 0x020E0000;
1474: if (mleaf->type == 3) { /* 21142 */
1475: u16 *init_sequence = (u16*)(p+2);
1476: u16 *reset_sequence = &((u16*)(p+3))[init_length];
1477: int reset_length = p[2 + init_length*2];
1478: misc_info = reset_sequence + reset_length;
1479: if (startup)
1480: for (i = 0; i < reset_length; i++)
1481: outl(get_u16(&reset_sequence[i]) << 16, ioaddr + CSR15);
1482: for (i = 0; i < init_length; i++)
1483: outl(get_u16(&init_sequence[i]) << 16, ioaddr + CSR15);
1484: } else {
1485: u8 *init_sequence = p + 2;
1486: u8 *reset_sequence = p + 3 + init_length;
1487: int reset_length = p[2 + init_length];
1488: misc_info = (u16*)(reset_sequence + reset_length);
1489: if (startup) {
1490: outl(mtable->csr12dir | 0x100, ioaddr + CSR12);
1491: for (i = 0; i < reset_length; i++)
1492: outl(reset_sequence[i], ioaddr + CSR12);
1493: }
1494: for (i = 0; i < init_length; i++)
1495: outl(init_sequence[i], ioaddr + CSR12);
1496: }
1497: to_advertise = (get_u16(&misc_info[1]) & tp->to_advertise) | 1;
1498: tp->advertising[phy_num] = to_advertise;
1499: if (tulip_debug > 1 || 1)
1500: printk(KERN_DEBUG "%s: Advertising %4.4x on PHY %d (%d).\n",
1501: dev->name, to_advertise, phy_num, tp->phys[phy_num]);
1502: /* Bogus: put in by a committee? */
1503: mdio_write(dev, tp->phys[phy_num], 4, to_advertise);
1504: break;
1505: }
1506: default:
1507: new_csr6 = 0x020E0000;
1508: }
1509: if (tulip_debug > 1)
1510: printk(KERN_DEBUG "%s: Using media type %s, CSR12 is %2.2x.\n",
1511: dev->name, medianame[dev->if_port],
1512: inl(ioaddr + CSR12) & 0xff);
1513: } else if (tp->chip_id == DC21041) {
1514: if (tulip_debug > 1)
1515: printk(KERN_DEBUG "%s: 21041 using media %s, CSR12 is %4.4x.\n",
1516: dev->name, medianame[dev->if_port & 15],
1517: inl(ioaddr + CSR12) & 0xffff);
1518: outl(0x00000000, ioaddr + CSR13); /* Reset the serial interface */
1519: outl(t21041_csr14[dev->if_port], ioaddr + CSR14);
1520: outl(t21041_csr15[dev->if_port], ioaddr + CSR15);
1521: outl(t21041_csr13[dev->if_port], ioaddr + CSR13);
1522: new_csr6 = 0x80020000;
1523: } else if (tp->chip_id == LC82C168) {
1524: if (startup && ! tp->medialock)
1525: dev->if_port = tp->mii_cnt ? 11 : 0;
1526: if (tulip_debug > 1)
1527: printk(KERN_DEBUG "%s: PNIC PHY status is %3.3x, CSR12 %4.4x,"
1528: " media %s.\n",
1529: dev->name, inl(ioaddr + 0xB8), inl(ioaddr + CSR12),
1530: medianame[dev->if_port]);
1531: if (tp->mii_cnt) {
1532: new_csr6 = 0x812C0000;
1533: outl(0x0001, ioaddr + CSR15);
1534: outl(0x0201B07A, ioaddr + 0xB8);
1535: } else if (startup) {
1536: /* Start with 10mbps to do autonegotiation. */
1537: outl(0x32, ioaddr + CSR12);
1538: new_csr6 = 0x00420000;
1539: outl(0x0001B078, ioaddr + 0xB8);
1540: outl(0x0201B078, ioaddr + 0xB8);
1541: } else if (dev->if_port == 3 || dev->if_port == 5) {
1542: outl(0x33, ioaddr + CSR12);
1543: new_csr6 = 0x01860000;
1544: if (startup)
1545: outl(0x0201F868, ioaddr + 0xB8); /* Trigger autonegotiation. */
1546: else
1547: outl(0x1F868, ioaddr + 0xB8);
1548: } else {
1549: outl(0x32, ioaddr + CSR12);
1550: new_csr6 = 0x00420000;
1551: outl(0x1F078, ioaddr + 0xB8);
1552: }
1553: } else if (tp->chip_id == DC21040) { /* 21040 */
1554: /* Turn on the xcvr interface. */
1555: int csr12 = inl(ioaddr + CSR12);
1556: if (tulip_debug > 1)
1557: printk(KERN_DEBUG "%s: 21040 media type is %s, CSR12 is %2.2x.\n",
1558: dev->name, dev->if_port ? "AUI" : "10baseT", csr12);
1559: new_csr6 = (dev->if_port ? 0x01860000 : 0x00420000);
1560: /* Set the full duplux match frame. */
1561: outl(FULL_DUPLEX_MAGIC, ioaddr + CSR11);
1562: outl(0x00000000, ioaddr + CSR13); /* Reset the serial interface */
1563: outl(dev->if_port ? 0x0000000C : 0x00000004, ioaddr + CSR13);
1564: } else { /* Unknown chip type with no media table. */
1565: if (tp->default_port == 0)
1566: if (tp->mii_cnt) {
1567: dev->if_port = 11;
1568: } else
1569: dev->if_port = 3;
1570: if (media_cap[dev->if_port] & MediaIsMII) {
1571: new_csr6 = 0x020E0000;
1572: } else if (media_cap[dev->if_port] & MediaIsFx) {
1573: new_csr6 = 0x028600000;
1574: } else
1575: new_csr6 = 0x038600000;
1576: if (tulip_debug > 1)
1577: printk(KERN_DEBUG "%s: No media description table, assuming "
1578: "%s transceiver, CSR12 %2.2x.\n",
1579: dev->name, medianame[dev->if_port],
1580: inl(ioaddr + CSR12));
1581: }
1582:
1583: tp->csr6 = new_csr6 | (tp->csr6 & 0xfdff) | (tp->full_duplex ? 0x0200 : 0);
1584: return;
1585: }
1586:
1587: static void tulip_timer(unsigned long data)
1588: {
1589: struct device *dev = (struct device *)data;
1590: struct tulip_private *tp = (struct tulip_private *)dev->priv;
1591: long ioaddr = dev->base_addr;
1592: u32 csr12 = inl(ioaddr + CSR12);
1593: int next_tick = 0;
1594:
1595: if (tulip_debug > 3) {
1596: printk(KERN_DEBUG "%s: Media selection tick, status %8.8x mode %8.8x "
1597: "SIA %8.8x %8.8x %8.8x %8.8x.\n",
1598: dev->name, inl(ioaddr + CSR5), inl(ioaddr + CSR6),
1599: csr12, inl(ioaddr + CSR13),
1600: inl(ioaddr + CSR14), inl(ioaddr + CSR15));
1601: }
1602: switch (tp->chip_id) {
1603: case DC21040:
1604: if (csr12 & 0x0002) { /* Network error */
1605: printk(KERN_INFO "%s: No 10baseT link beat found, switching to %s media.\n",
1606: dev->name, dev->if_port ? "10baseT" : "AUI");
1607: dev->if_port ^= 1;
1608: outl(dev->if_port ? 0x0000000C : 0x00000004, ioaddr + CSR13);
1609: dev->trans_start = jiffies;
1610: }
1611: break;
1612: case DC21041:
1613: if (tulip_debug > 2)
1614: printk(KERN_DEBUG "%s: 21041 media tick CSR12 %8.8x.\n",
1615: dev->name, csr12);
1616: switch (dev->if_port) {
1617: case 0: case 3: case 4:
1618: if (csr12 & 0x0004) { /*LnkFail */
1619: /* 10baseT is dead. Check for activity on alternate port. */
1620: tp->mediasense = 1;
1621: if (csr12 & 0x0200)
1622: dev->if_port = 2;
1623: else
1624: dev->if_port = 1;
1625: printk(KERN_INFO "%s: No 21041 10baseT link beat, Media switched to %s.\n",
1626: dev->name, medianame[dev->if_port]);
1627: outl(0, ioaddr + CSR13); /* Reset */
1628: outl(t21041_csr14[dev->if_port], ioaddr + CSR14);
1629: outl(t21041_csr15[dev->if_port], ioaddr + CSR15);
1630: outl(t21041_csr13[dev->if_port], ioaddr + CSR13);
1631: next_tick = 10*HZ; /* 2.4 sec. */
1632: } else
1633: next_tick = 30*HZ;
1634: break;
1635: case 1: /* 10base2 */
1636: case 2: /* AUI */
1637: if (csr12 & 0x0100) {
1638: next_tick = (30*HZ); /* 30 sec. */
1639: tp->mediasense = 0;
1640: } else if ((csr12 & 0x0004) == 0) {
1641: printk(KERN_INFO "%s: 21041 media switched to 10baseT.\n", dev->name);
1642: dev->if_port = 0;
1643: select_media(dev, 0);
1644: next_tick = (24*HZ)/10; /* 2.4 sec. */
1645: } else if (tp->mediasense || (csr12 & 0x0002)) {
1646: dev->if_port = 3 - dev->if_port; /* Swap ports. */
1647: select_media(dev, 0);
1648: next_tick = 20*HZ;
1649: } else {
1650: next_tick = 20*HZ;
1651: }
1652: break;
1653: }
1654: break;
1655: case DC21140: case DC21142: case MX98713: default: {
1656: struct medialeaf *mleaf;
1657: unsigned char *p;
1658: if (tp->mtable == NULL) { /* No EEPROM info, use generic code. */
1659: /* Not much that can be done.
1660: Assume this a generic MII or SYM transceiver. */
1661: next_tick = 60*HZ;
1662: if (tulip_debug > 2)
1663: printk(KERN_DEBUG "%s: network media monitor CSR6 %8.8x "
1664: "CSR12 0x%2.2x.\n",
1665: dev->name, inl(ioaddr + CSR6), csr12 & 0xff);
1666: break;
1667: }
1668: mleaf = &tp->mtable->mleaf[tp->cur_index];
1669: p = mleaf->leafdata;
1670: switch (mleaf->type) {
1671: case 0: case 4: {
1672: /* Type 0 serial or 4 SYM transceiver. Check the link beat bit. */
1673: int offset = mleaf->type == 4 ? 5 : 2;
1674: s8 bitnum = p[offset];
1675: if (p[offset+1] & 0x80) {
1676: if (tulip_debug > 1)
1677: printk(KERN_DEBUG"%s: Transceiver monitor tick "
1678: "CSR12=%#2.2x, no media sense.\n",
1679: dev->name, csr12);
1680: if (mleaf->type == 4) {
1681: if (mleaf->media == 3 && (csr12 & 0x02))
1682: goto select_next_media;
1683: }
1684: break;
1685: }
1686: if (tulip_debug > 2)
1687: printk(KERN_DEBUG "%s: Transceiver monitor tick: CSR12=%#2.2x"
1688: " bit %d is %d, expecting %d.\n",
1689: dev->name, csr12, (bitnum >> 1) & 7,
1690: (csr12 & (1 << ((bitnum >> 1) & 7))) != 0,
1691: (bitnum >= 0));
1692: /* Check that the specified bit has the proper value. */
1693: if ((bitnum < 0) !=
1694: ((csr12 & (1 << ((bitnum >> 1) & 7))) != 0)) {
1695: if (tulip_debug > 1)
1696: printk(KERN_DEBUG "%s: Link beat detected for %s.\n", dev->name,
1697: medianame[mleaf->media]);
1698: if ((p[2] & 0x61) == 0x01) /* Bogus Znyx board. */
1699: goto actually_mii;
1700: break;
1701: }
1702: if (tp->medialock)
1703: break;
1704: select_next_media:
1705: if (--tp->cur_index < 0) {
1706: /* We start again, but should instead look for default. */
1707: tp->cur_index = tp->mtable->leafcount - 1;
1708: }
1709: dev->if_port = tp->mtable->mleaf[tp->cur_index].media;
1710: if (media_cap[dev->if_port] & MediaIsFD)
1711: goto select_next_media; /* Skip FD entries. */
1712: if (tulip_debug > 1)
1713: printk(KERN_DEBUG "%s: No link beat on media %s,"
1714: " trying transceiver type %s.\n",
1715: dev->name, medianame[mleaf->media & 15],
1716: medianame[tp->mtable->mleaf[tp->cur_index].media]);
1717: select_media(dev, 0);
1718: /* Restart the transmit process. */
1719: outl(tp->csr6 | 0x0002, ioaddr + CSR6);
1720: outl(tp->csr6 | 0x2002, ioaddr + CSR6);
1721: next_tick = (24*HZ)/10;
1722: break;
1723: }
1724: case 1: case 3: { /* 21140, 21142 MII */
1725: int mii_reg1, mii_reg5;
1726: actually_mii:
1727: mii_reg1 = mdio_read(dev, tp->phys[0], 1);
1728: mii_reg5 = mdio_read(dev, tp->phys[0], 5);
1729: if (tulip_debug > 1)
1730: printk(KERN_INFO "%s: MII status %4.4x, Link partner report "
1731: "%4.4x, CSR12 %2.2x, %cD.\n",
1732: dev->name, mii_reg1, mii_reg5, csr12,
1733: tp->full_duplex ? 'F' : 'H');
1734: if (mii_reg1 != 0xffff && (mii_reg1 & 0x0004) == 0) {
1735: int new_reg1 = mdio_read(dev, tp->phys[0], 1);
1736: if ((new_reg1 & 0x0004) == 0) {
1737: printk(KERN_INFO "%s: No link beat on the MII interface,"
1738: " status then %4.4x now %4.4x.\n",
1739: dev->name, mii_reg1, new_reg1);
1740: if (tp->mtable && tp->mtable->has_nonmii)
1741: goto select_next_media;
1742: }
1743: }
1744: if (mii_reg5 == 0xffff || mii_reg5 == 0x0000)
1745: ; /* No MII device or no link partner report */
1746: else if (tp->full_duplex_lock)
1747: ;
1748: else {
1749: int negotiated = mii_reg5 & tp->advertising[0];
1750: int duplex = ((negotiated & 0x0100) != 0
1751: || (negotiated & 0x00C0) == 0x0040);
1752: /* 100baseTx-FD or 10T-FD, but not 100-HD */
1753: if (tp->full_duplex != duplex) {
1754: tp->full_duplex = duplex;
1755: if (tp->full_duplex)
1756: tp->csr6 |= 0x0200;
1757: else
1758: tp->csr6 &= ~0x0200;
1759: outl(tp->csr6 | 0x0002, ioaddr + CSR6);
1760: outl(tp->csr6 | 0x2002, ioaddr + CSR6);
1761: if (tulip_debug > 0) /* Gurppp, should be >1 */
1762: printk(KERN_INFO "%s: Setting %s-duplex based on MII"
1763: " Xcvr #%d parter capability of %4.4x.\n",
1764: dev->name, tp->full_duplex ? "full" : "half",
1765: tp->phys[0], mii_reg5);
1766: }
1767: }
1768: next_tick = 60*HZ;
1769: break;
1770: }
1771: case 2: /* 21142 serial block has no link beat. */
1772: default:
1773: break;
1774: }
1775: }
1776: break;
1777: }
1778: if (next_tick) {
1779: tp->timer.expires = RUN_AT(next_tick);
1780: add_timer(&tp->timer);
1781: }
1782: }
1783:
1784: /* Handle the 21143 uniquely: do autoselect with NWay, not the EEPROM list
1785: of available transceivers. */
1786: static void t21142_timer(unsigned long data)
1787: {
1788: struct device *dev = (struct device *)data;
1789: struct tulip_private *tp = (struct tulip_private *)dev->priv;
1790: long ioaddr = dev->base_addr;
1791: int csr12 = inl(ioaddr + CSR12);
1792: int next_tick = 60*HZ;
1793: int new_csr6 = 0;
1794:
1795: if (tulip_debug > 1)
1796: printk(KERN_INFO"%s: 21142 negotiation status %8.8x, %s.\n",
1797: dev->name, csr12, medianame[dev->if_port]);
1798: if (dev->if_port == 3) {
1799: if (csr12 & 2) { /* No 100mbps link beat, revert to 10mbps. */
1800: new_csr6 = 0x82420200;
1801: outl(new_csr6, ioaddr + CSR6);
1802: outl(0x0000, ioaddr + CSR13);
1803: outl(0x0003FFFF, ioaddr + CSR14);
1804: outl(0x0008, ioaddr + CSR15);
1805: outl(0x0001, ioaddr + CSR13);
1806: outl(0x1301, ioaddr + CSR12); /* Start NWay. */
1807: }
1808: } else if ((csr12 & 0x7000) != 0x5000) {
1809: /* Negotiation failed. Search media types. */
1810: if (tulip_debug > 1)
1811: printk(KERN_INFO"%s: 21142 negotiation failed, status %8.8x.\n",
1812: dev->name, csr12);
1813: if (!(csr12 & 4)) { /* 10mbps link beat good. */
1814: new_csr6 = 0x82420000;
1815: dev->if_port = 0;
1816: outl(0, ioaddr + CSR13);
1817: outl(0x0003FFFF, ioaddr + CSR14);
1818: outl(t21142_csr15[dev->if_port], ioaddr + CSR15);
1819: outl(t21142_csr13[dev->if_port], ioaddr + CSR13);
1820: } else if (csr12 & 0x100) {
1821: new_csr6 = 0x82420200;
1822: dev->if_port = 2;
1823: outl(0, ioaddr + CSR13);
1824: outl(0x0003FFFF, ioaddr + CSR14);
1825: outl(0x0008, ioaddr + CSR15);
1826: outl(0x0001, ioaddr + CSR13);
1827: } else {
1828: /* Select 100mbps port to check for link beat. */
1829: new_csr6 = 0x83860000;
1830: dev->if_port = 3;
1831: outl(0, ioaddr + CSR13);
1832: outl(0x0003FF7F, ioaddr + CSR14);
1833: outl(8, ioaddr + CSR15);
1834: outl(1, ioaddr + CSR13);
1835: }
1836: if (tulip_debug > 1)
1837: printk(KERN_INFO"%s: Testing new 21142 media %s.\n",
1838: dev->name, medianame[dev->if_port]);
1839: if (new_csr6 != (tp->csr6 & ~0x00D5)) {
1840: tp->csr6 &= 0x00D5;
1841: tp->csr6 |= new_csr6;
1842: outl(0x0301, ioaddr + CSR12);
1843: outl(tp->csr6 | 0x0002, ioaddr + CSR6);
1844: outl(tp->csr6 | 0x2002, ioaddr + CSR6);
1845: }
1846: }
1847: tp->timer.expires = RUN_AT(next_tick);
1848: add_timer(&tp->timer);
1849: }
1850:
1851: static void t21142_lnk_change( struct device *dev)
1852: {
1853: struct tulip_private *tp = (struct tulip_private *)dev->priv;
1854: long ioaddr = dev->base_addr;
1855: int csr12 = inl(ioaddr + CSR12);
1856:
1857: if (tulip_debug > 1)
1858: printk(KERN_INFO"%s: 21142 link status interrupt %8.8x, CSR5 %x.\n",
1859: dev->name, csr12, inl(ioaddr + CSR5));
1860:
1861: if ((csr12 & 0x7000) == 0x5000) {
1862: if (csr12 & 0x01800000) {
1863: /* Switch to 100mbps mode. */
1864: outl(tp->csr6 | 0x0002, ioaddr + CSR6);
1865: if (csr12 & 0x01000000) {
1866: dev->if_port = 5;
1867: tp->csr6 = 0x83860200;
1868: } else {
1869: dev->if_port = 3;
1870: tp->csr6 = 0x83860000;
1871: }
1872: outl(tp->csr6 | 0x2002, ioaddr + CSR6);
1873: } /* Else 10baseT-FD is handled automatically. */
1874: } else if (dev->if_port == 3) {
1875: if (!(csr12 & 2))
1876: printk(KERN_INFO"%s: 21142 100baseTx link beat good.\n",
1877: dev->name);
1878: else
1879: dev->if_port = 0;
1880: } else if (dev->if_port == 0) {
1881: if (!(csr12 & 4))
1882: printk(KERN_INFO"%s: 21142 10baseT link beat good.\n",
1883: dev->name);
1884: } else if (!(csr12 & 4)) { /* 10mbps link beat good. */
1885: printk(KERN_INFO"%s: 21142 10mpbs sensed media.\n",
1886: dev->name);
1887: dev->if_port = 0;
1888: } else { /* 100mbps link beat good. */
1889: printk(KERN_INFO"%s: 21142 100baseTx sensed media.\n",
1890: dev->name);
1891: dev->if_port = 3;
1892: tp->csr6 = 0x83860000;
1893: outl(0x0003FF7F, ioaddr + CSR14);
1894: outl(0x0301, ioaddr + CSR12);
1895: outl(tp->csr6 | 0x0002, ioaddr + CSR6);
1896: outl(tp->csr6 | 0x2002, ioaddr + CSR6);
1897: }
1898: }
1899:
1900:
1901: static void mxic_timer(unsigned long data)
1902: {
1903: struct device *dev = (struct device *)data;
1904: struct tulip_private *tp = (struct tulip_private *)dev->priv;
1905: long ioaddr = dev->base_addr;
1906: int next_tick = 60*HZ;
1907:
1908: if (tulip_debug > 3) {
1909: printk(KERN_INFO"%s: MXIC negotiation status %8.8x.\n", dev->name,
1910: inl(ioaddr + CSR12));
1911: }
1912: if (next_tick) {
1913: tp->timer.expires = RUN_AT(next_tick);
1914: add_timer(&tp->timer);
1915: }
1916: }
1917:
1918: static void pnic_timer(unsigned long data)
1919: {
1920: struct device *dev = (struct device *)data;
1921: struct tulip_private *tp = (struct tulip_private *)dev->priv;
1922: long ioaddr = dev->base_addr;
1923: int csr12 = inl(ioaddr + CSR12);
1924: int next_tick = 60*HZ;
1925: int new_csr6 = tp->csr6 & ~0x40C40200;
1926:
1927: if (media_cap[dev->if_port] & MediaIsMII) {
1928: int negotiated = mdio_read(dev, tp->phys[0], 5) & tp->advertising[0];
1929:
1930: if (tulip_debug > 1)
1931: printk(KERN_DEBUG "%s: LC82C168 negotiated capability %8.8x, "
1932: "CSR5 %8.8x.\n",
1933: dev->name, negotiated, inl(ioaddr + CSR5));
1934:
1935: if (negotiated & 0x0380) /* 10 vs 100mbps */
1936: new_csr6 |= 0x812E0000;
1937: else
1938: new_csr6 |= 0x816E0000;
1939: if (((negotiated & 0x0300) == 0x0100) /* Duplex */
1940: || (negotiated & 0x00C0) == 0x0040
1941: || tp->full_duplex_lock) {
1942: tp->full_duplex = 1;
1943: new_csr6 |= 0x0200;
1944: }
1945: if (tulip_debug > 1)
1946: printk(KERN_DEBUG "%s: LC82C168 MII PHY status %4.4x, Link "
1947: "partner report %4.4x, csr6 %8.8x/%8.8x.\n",
1948: dev->name, mdio_read(dev, tp->phys[0], 1), negotiated,
1949: tp->csr6, inl(ioaddr + CSR6));
1950: } else {
1951: int phy_reg = inl(ioaddr + 0xB8);
1952: int csr5 = inl(ioaddr + CSR5);
1953:
1954: if (tulip_debug > 1)
1955: printk(KERN_DEBUG "%s: LC82C168 phy status %8.8x, CSR5 %8.8x.\n",
1956: dev->name, phy_reg, csr5);
1957:
1958: if (phy_reg & 0x04000000) { /* Remote link fault */
1959: /*outl(0x0201F078, ioaddr + 0xB8);*/
1960: next_tick = 3*HZ;
1961: }
1962: if (inl(ioaddr + CSR5) & TPLnkFail) { /* 100baseTx link beat */
1963: if (tulip_debug > 1)
1964: printk(KERN_DEBUG "%s: %s link beat failed, CSR12 %4.4x, "
1965: "CSR5 %8.8x, PHY %3.3x.\n",
1966: dev->name, medianame[dev->if_port], csr12,
1967: inl(ioaddr + CSR5), inl(ioaddr + 0xB8));
1968: if (tp->medialock) {
1969: } else if (dev->if_port == 0) {
1970: dev->if_port = 3;
1971: outl(0x33, ioaddr + CSR12);
1972: new_csr6 = 0x01860000;
1973: outl(0x1F868, ioaddr + 0xB8);
1974: } else {
1975: dev->if_port = 0;
1976: outl(0x32, ioaddr + CSR12);
1977: new_csr6 = 0x00420000;
1978: outl(0x1F078, ioaddr + 0xB8);
1979: }
1980: new_csr6 |= (tp->csr6 & 0xfdff);
1981: next_tick = 3*HZ;
1982: } else
1983: new_csr6 = tp->csr6;
1984: if (tp->full_duplex_lock || (phy_reg & 0x30000000) != 0) {
1985: tp->full_duplex = 1;
1986: new_csr6 |= 0x00000200;
1987: }
1988: }
1989: if (tp->csr6 != new_csr6) {
1990: tp->csr6 = new_csr6;
1991: outl(tp->csr6 | 0x0002, ioaddr + CSR6); /* Restart Tx */
1992: outl(tp->csr6 | 0x2002, ioaddr + CSR6);
1993: dev->trans_start = jiffies;
1994: if (tulip_debug > 0) /* Gurppp, should be >1 */
1995: printk(KERN_INFO "%s: Changing PNIC configuration to %s-duplex, "
1996: "CSR6 %8.8x.\n",
1997: dev->name, tp->full_duplex ? "full" : "half", new_csr6);
1998: }
1999: tp->timer.expires = RUN_AT(next_tick);
2000: add_timer(&tp->timer);
2001: }
2002:
2003: static void tulip_tx_timeout(struct device *dev)
2004: {
2005: struct tulip_private *tp = (struct tulip_private *)dev->priv;
2006: long ioaddr = dev->base_addr;
2007:
2008: if (media_cap[dev->if_port] & MediaIsMII) {
2009: /* Do nothing -- the media monitor should handle this. */
2010: if (tulip_debug > 1)
2011: printk(KERN_WARNING "%s: Transmit timeout using MII device.\n",
2012: dev->name);
2013: dev->trans_start = jiffies;
2014: return;
2015: } else if (tp->chip_id == DC21040) {
2016: if (inl(ioaddr + CSR12) & 0x0002) {
2017: printk(KERN_INFO "%s: transmit timed out, switching to %s media.\n",
2018: dev->name, dev->if_port ? "10baseT" : "AUI");
2019: dev->if_port ^= 1;
2020: outl(dev->if_port ? 0x0000000C : 0x00000004, ioaddr + CSR13);
2021: }
2022: dev->trans_start = jiffies;
2023: return;
2024: } else if (tp->chip_id == DC21041) {
2025: u32 csr12 = inl(ioaddr + CSR12);
2026:
2027: printk(KERN_WARNING "%s: 21041 transmit timed out, status %8.8x, CSR12 %8.8x,"
2028: " CSR13 %8.8x, CSR14 %8.8x, resetting...\n",
2029: dev->name, inl(ioaddr + CSR5), csr12,
2030: inl(ioaddr + CSR13), inl(ioaddr + CSR14));
2031: tp->mediasense = 1;
2032: if (dev->if_port == 1 || dev->if_port == 2)
2033: if (csr12 & 0x0004) {
2034: dev->if_port = 2 - dev->if_port;
2035: } else
2036: dev->if_port = 0;
2037: else
2038: dev->if_port = 1;
2039: select_media(dev, 0);
2040: tp->stats.tx_errors++;
2041: dev->trans_start = jiffies;
2042: return;
2043: } else if (tp->chip_id == DC21140 || tp->chip_id == DC21142
2044: || tp->chip_id == MX98713) {
2045: /* Stop the transmit process. */
2046: outl(tp->csr6 | 0x0002, ioaddr + CSR6);
2047: printk(KERN_WARNING "%s: 21140 transmit timed out, status %8.8x, "
2048: "SIA %8.8x %8.8x %8.8x %8.8x, resetting...\n",
2049: dev->name, inl(ioaddr + CSR5), inl(ioaddr + CSR12),
2050: inl(ioaddr + CSR13), inl(ioaddr + CSR14), inl(ioaddr + CSR15));
2051: if (tp->mtable) {
2052: if (--tp->cur_index < 0) {
2053: /* We start again, but should instead look for default. */
2054: tp->cur_index = tp->mtable->leafcount - 1;
2055: }
2056: select_media(dev, 0);
2057: printk(KERN_WARNING "%s: transmit timed out, switching to %s media.\n",
2058: dev->name, dev->if_port ? "100baseTx" : "10baseT");
2059: }
2060: outl(tp->csr6 | 0x2002, ioaddr + CSR6);
2061: tp->stats.tx_errors++;
2062: dev->trans_start = jiffies;
2063: return;
2064: } else
2065: printk(KERN_WARNING "%s: transmit timed out, status %8.8x, CSR12 %8.8x,"
2066: " resetting...\n",
2067: dev->name, inl(ioaddr + CSR5), inl(ioaddr + CSR12));
2068: #ifdef way_too_many_messages
2069: printk(" Rx ring %8.8x: ", (int)tp->rx_ring);
2070: for (i = 0; i < RX_RING_SIZE; i++)
2071: printk(" %8.8x", (unsigned int)tp->rx_ring[i].status);
2072: printk("\n Tx ring %8.8x: ", (int)tp->tx_ring);
2073: for (i = 0; i < TX_RING_SIZE; i++)
2074: printk(" %8.8x", (unsigned int)tp->tx_ring[i].status);
2075: printk("\n");
2076: #endif
2077:
2078: /* Perhaps we should reinitialize the hardware here. */
2079: dev->if_port = 0;
2080: /* Stop and restart the chip's Tx processes . */
2081: outl(tp->csr6 | 0x0002, ioaddr + CSR6);
2082: outl(tp->csr6 | 0x2002, ioaddr + CSR6);
2083: /* Trigger an immediate transmit demand. */
2084: outl(0, ioaddr + CSR1);
2085:
2086: dev->trans_start = jiffies;
2087: tp->stats.tx_errors++;
2088: return;
2089: }
2090:
2091:
2092: /* Initialize the Rx and Tx rings, along with various 'dev' bits. */
2093: static void
2094: tulip_init_ring(struct device *dev)
2095: {
2096: struct tulip_private *tp = (struct tulip_private *)dev->priv;
2097: int i;
2098:
2099: tp->tx_full = 0;
2100: tp->cur_rx = tp->cur_tx = 0;
2101: tp->dirty_rx = tp->dirty_tx = 0;
2102:
2103: for (i = 0; i < RX_RING_SIZE; i++) {
2104: tp->rx_ring[i].status = 0x80000000; /* Owned by Tulip chip */
2105: tp->rx_ring[i].length = PKT_BUF_SZ;
2106: {
2107: /* Note the receive buffer must be longword aligned.
2108: dev_alloc_skb() provides 16 byte alignment. But do *not*
2109: use skb_reserve() to align the IP header! */
2110: struct sk_buff *skb;
2111: skb = DEV_ALLOC_SKB(PKT_BUF_SZ);
2112: tp->rx_skbuff[i] = skb;
2113: if (skb == NULL)
2114: break; /* Bad news! */
2115: skb->dev = dev; /* Mark as being used by this device. */
2116: #if LINUX_VERSION_CODE > 0x10300
2117: tp->rx_ring[i].buffer1 = virt_to_bus(skb->tail);
2118: #else
2119: tp->rx_ring[i].buffer1 = virt_to_bus(skb->data);
2120: #endif
2121: }
2122: tp->rx_ring[i].buffer2 = virt_to_bus(&tp->rx_ring[i+1]);
2123: }
2124: /* Mark the last entry as wrapping the ring. */
2125: tp->rx_ring[i-1].length = PKT_BUF_SZ | 0x02000000;
2126: tp->rx_ring[i-1].buffer2 = virt_to_bus(&tp->rx_ring[0]);
2127:
2128: /* The Tx buffer descriptor is filled in as needed, but we
2129: do need to clear the ownership bit. */
2130: for (i = 0; i < TX_RING_SIZE; i++) {
2131: tp->tx_skbuff[i] = 0;
2132: tp->tx_ring[i].status = 0x00000000;
2133: tp->tx_ring[i].buffer2 = virt_to_bus(&tp->tx_ring[i+1]);
2134: }
2135: tp->tx_ring[i-1].buffer2 = virt_to_bus(&tp->tx_ring[0]);
2136: }
2137:
2138: static int
2139: tulip_start_xmit(struct sk_buff *skb, struct device *dev)
2140: {
2141: struct tulip_private *tp = (struct tulip_private *)dev->priv;
2142: int entry;
2143: u32 flag;
2144:
2145: /* Block a timer-based transmit from overlapping. This could better be
2146: done with atomic_swap(1, dev->tbusy), but set_bit() works as well. */
2147: if (test_and_set_bit(0, (void*)&dev->tbusy) != 0) {
2148: if (jiffies - dev->trans_start < TX_TIMEOUT)
2149: return 1;
2150: tulip_tx_timeout(dev);
2151: return 1;
2152: }
2153:
2154: /* Caution: the write order is important here, set the base address
2155: with the "ownership" bits last. */
2156:
2157: /* Calculate the next Tx descriptor entry. */
2158: entry = tp->cur_tx % TX_RING_SIZE;
2159:
2160: tp->tx_skbuff[entry] = skb;
2161: tp->tx_ring[entry].buffer1 = virt_to_bus(skb->data);
2162:
2163: if (tp->cur_tx - tp->dirty_tx < TX_RING_SIZE/2) {/* Typical path */
2164: flag = 0x60000000; /* No interrupt */
2165: dev->tbusy = 0;
2166: } else if (tp->cur_tx - tp->dirty_tx == TX_RING_SIZE/2) {
2167: flag = 0xe0000000; /* Tx-done intr. */
2168: dev->tbusy = 0;
2169: } else if (tp->cur_tx - tp->dirty_tx < TX_RING_SIZE - 2) {
2170: flag = 0x60000000; /* No Tx-done intr. */
2171: dev->tbusy = 0;
2172: } else {
2173: /* Leave room for set_rx_mode() to fill entries. */
2174: flag = 0xe0000000; /* Tx-done intr. */
2175: tp->tx_full = 1;
2176: }
2177: if (entry == TX_RING_SIZE-1)
2178: flag |= 0xe2000000;
2179:
2180: tp->tx_ring[entry].length = skb->len | flag;
2181: tp->tx_ring[entry].status = 0x80000000; /* Pass ownership to the chip. */
2182: tp->cur_tx++;
2183: /* Trigger an immediate transmit demand. */
2184: outl(0, dev->base_addr + CSR1);
2185:
2186: dev->trans_start = jiffies;
2187:
2188: return 0;
2189: }
2190:
2191: /* The interrupt handler does all of the Rx thread work and cleans up
2192: after the Tx thread. */
2193: static void tulip_interrupt IRQ(int irq, void *dev_instance, struct pt_regs *regs)
2194: {
2195: #ifdef SA_SHIRQ /* Use the now-standard shared IRQ implementation. */
2196: struct device *dev = (struct device *)dev_instance;
2197: #else
2198: struct device *dev = (struct device *)(irq2dev_map[irq]);
2199: #endif
2200:
2201: struct tulip_private *tp;
2202: long ioaddr;
2203: int csr5, work_budget = max_interrupt_work;
2204:
2205: if (dev == NULL) {
2206: printk (KERN_ERR" tulip_interrupt(): irq %d for unknown device.\n",
2207: irq);
2208: return;
2209: }
2210:
2211: ioaddr = dev->base_addr;
2212: tp = (struct tulip_private *)dev->priv;
2213: if (test_and_set_bit(0, (void*)&tp->interrupt)) {
2214: #ifdef SMP_CHECK
2215: printk(KERN_ERR "%s: Re-entering the interrupt handler with proc %d,"
2216: " proc %d already handling.\n", dev->name,
2217: tp->smp_proc_id, hard_smp_processor_id());
2218: #else
2219: printk(KERN_ERR "%s: Re-entering the interrupt handler.\n", dev->name);
2220: #endif
2221: return;
2222: }
2223: dev->interrupt = 1;
2224: #ifdef SMP_CHECK
2225: tp->smp_proc_id = hard_smp_processor_id();
2226: #endif
2227:
2228: do {
2229: csr5 = inl(ioaddr + CSR5);
2230: /* Acknowledge all of the current interrupt sources ASAP. */
2231: outl(csr5 & 0x0001ffff, ioaddr + CSR5);
2232:
2233: if (tulip_debug > 4)
2234: printk(KERN_DEBUG "%s: interrupt csr5=%#8.8x new csr5=%#8.8x.\n",
2235: dev->name, csr5, inl(dev->base_addr + CSR5));
2236:
2237: if ((csr5 & (NormalIntr|AbnormalIntr)) == 0)
2238: break;
2239:
2240: if (csr5 & (RxIntr | RxNoBuf))
2241: work_budget -= tulip_rx(dev);
2242:
2243: if (csr5 & (TxNoBuf | TxDied | TxIntr)) {
2244: unsigned int dirty_tx;
2245:
2246: for (dirty_tx = tp->dirty_tx; tp->cur_tx - dirty_tx > 0;
2247: dirty_tx++) {
2248: int entry = dirty_tx % TX_RING_SIZE;
2249: int status = tp->tx_ring[entry].status;
2250:
2251: if (status < 0)
2252: break; /* It still hasn't been Txed */
2253: /* Check for Rx filter setup frames. */
2254: if (tp->tx_skbuff[entry] == NULL)
2255: continue;
2256:
2257: if (status & 0x8000) {
2258: /* There was an major error, log it. */
2259: #ifndef final_version
2260: if (tulip_debug > 1)
2261: printk(KERN_DEBUG "%s: Transmit error, Tx status %8.8x.\n",
2262: dev->name, status);
2263: #endif
2264: tp->stats.tx_errors++;
2265: if (status & 0x4104) tp->stats.tx_aborted_errors++;
2266: if (status & 0x0C00) tp->stats.tx_carrier_errors++;
2267: if (status & 0x0200) tp->stats.tx_window_errors++;
2268: if (status & 0x0002) tp->stats.tx_fifo_errors++;
2269: if ((status & 0x0080) && tp->full_duplex == 0)
2270: tp->stats.tx_heartbeat_errors++;
2271: #ifdef ETHER_STATS
2272: if (status & 0x0100) tp->stats.collisions16++;
2273: #endif
2274: } else {
2275: #ifdef ETHER_STATS
2276: if (status & 0x0001) tp->stats.tx_deferred++;
2277: #endif
2278: #if LINUX_VERSION_CODE > 0x20127
2279: tp->stats.tx_bytes += tp->tx_ring[entry].length & 0x7ff;
2280: #endif
2281: tp->stats.collisions += (status >> 3) & 15;
2282: tp->stats.tx_packets++;
2283: }
2284:
2285: /* Free the original skb. */
2286: #if (LINUX_VERSION_CODE > 0x20155)
2287: dev_kfree_skb(tp->tx_skbuff[entry]);
2288: #else
2289: dev_kfree_skb(tp->tx_skbuff[entry], FREE_WRITE);
2290: #endif
2291: tp->tx_skbuff[entry] = 0;
2292: }
2293:
2294: #ifndef final_version
2295: if (tp->cur_tx - dirty_tx > TX_RING_SIZE) {
2296: printk(KERN_ERR "%s: Out-of-sync dirty pointer, %d vs. %d, full=%d.\n",
2297: dev->name, dirty_tx, tp->cur_tx, tp->tx_full);
2298: dirty_tx += TX_RING_SIZE;
2299: }
2300: #endif
2301:
2302: if (tp->tx_full && dev->tbusy
2303: && tp->cur_tx - dirty_tx < TX_RING_SIZE - 2) {
2304: /* The ring is no longer full, clear tbusy. */
2305: tp->tx_full = 0;
2306: dev->tbusy = 0;
2307: mark_bh(NET_BH);
2308: }
2309:
2310: tp->dirty_tx = dirty_tx;
2311: if (csr5 & TxDied) {
2312: if (tulip_debug > 1)
2313: printk(KERN_WARNING "%s: The transmitter stopped!"
2314: " CSR5 is %x, CSR6 %x.\n",
2315: dev->name, csr5, inl(ioaddr + CSR6));
2316: outl(tp->csr6 | 0x0002, ioaddr + CSR6);
2317: outl(tp->csr6 | 0x2002, ioaddr + CSR6);
2318: }
2319: }
2320:
2321: /* Log errors. */
2322: if (csr5 & AbnormalIntr) { /* Abnormal error summary bit. */
2323: if (csr5 & TxJabber) tp->stats.tx_errors++;
2324: if (csr5 & TxFIFOUnderflow) {
2325: if ((tp->csr6 & 0xC000) != 0xC000)
2326: tp->csr6 += 0x4000; /* Bump up the Tx threshold */
2327: else
2328: tp->csr6 |= 0x00200000; /* Store-n-forward. */
2329: /* Restart the transmit process. */
2330: outl(tp->csr6 | 0x0002, ioaddr + CSR6);
2331: outl(tp->csr6 | 0x2002, ioaddr + CSR6);
2332: }
2333: if (csr5 & RxDied) { /* Missed a Rx frame. */
2334: tp->stats.rx_errors++;
2335: tp->stats.rx_missed_errors += inl(ioaddr + CSR8) & 0xffff;
2336: }
2337: if (csr5 & TimerInt) {
2338: printk(KERN_ERR "%s: Something Wicked happened! %8.8x.\n",
2339: dev->name, csr5);
2340: /* Hmmmmm, it's not clear what to do here. */
2341: }
2342: if (csr5 & (TPLnkPass | TPLnkFail | 0x08000000)
2343: && tp->chip_id == DC21142) {
2344: if (tulip_debug > 1)
2345: printk(KERN_INFO"%s: 21142 link change, CSR5 = %8.8x.\n",
2346: dev->name, csr5);
2347: t21142_lnk_change(dev);
2348: }
2349: /* Clear all error sources, included undocumented ones! */
2350: outl(0x0800f7ba, ioaddr + CSR5);
2351: }
2352: if (--work_budget < 0) {
2353: if (tulip_debug > 1)
2354: printk(KERN_WARNING "%s: Too much work at interrupt, "
2355: "csr5=0x%8.8x.\n", dev->name, csr5);
2356: /* Acknowledge all interrupt sources. */
2357: outl(0x8001ffff, ioaddr + CSR5);
2358: #ifdef notdef
2359: /* Clear all but standard interrupt sources. */
2360: outl((~csr5) & 0x0001ebef, ioaddr + CSR7);
2361: #endif
2362: break;
2363: }
2364: } while (1);
2365:
2366: if (tulip_debug > 3)
2367: printk(KERN_DEBUG "%s: exiting interrupt, csr5=%#4.4x.\n",
2368: dev->name, inl(ioaddr + CSR5));
2369:
2370: dev->interrupt = 0;
2371: clear_bit(0, (void*)&tp->interrupt);
2372: return;
2373: }
2374:
2375: static int
2376: tulip_rx(struct device *dev)
2377: {
2378: struct tulip_private *tp = (struct tulip_private *)dev->priv;
2379: int entry = tp->cur_rx % RX_RING_SIZE;
2380: int rx_work_limit = tp->dirty_rx + RX_RING_SIZE - tp->cur_rx;
2381: int work_done = 0;
2382:
2383: if (tulip_debug > 4)
2384: printk(KERN_DEBUG " In tulip_rx(), entry %d %8.8x.\n", entry,
2385: tp->rx_ring[entry].status);
2386: /* If we own the next entry, it's a new packet. Send it up. */
2387: while (tp->rx_ring[entry].status >= 0) {
2388: s32 status = tp->rx_ring[entry].status;
2389:
2390: if (--rx_work_limit < 0)
2391: break;
2392: if ((status & 0x0300) != 0x0300) {
2393: if ((status & 0xffff) != 0x7fff) { /* Ingore earlier buffers. */
2394: if (tulip_debug > 1)
2395: printk(KERN_WARNING "%s: Oversized Ethernet frame spanned "
2396: "multiple buffers, status %8.8x!\n",
2397: dev->name, status);
2398: tp->stats.rx_length_errors++;
2399: }
2400: } else if (status & 0x8000) {
2401: /* There was a fatal error. */
2402: if (tulip_debug > 2)
2403: printk(KERN_DEBUG "%s: Receive error, Rx status %8.8x.\n",
2404: dev->name, status);
2405: tp->stats.rx_errors++; /* end of a packet.*/
2406: if (status & 0x0890) tp->stats.rx_length_errors++;
2407: if (status & 0x0004) tp->stats.rx_frame_errors++;
2408: if (status & 0x0002) tp->stats.rx_crc_errors++;
2409: if (status & 0x0001) tp->stats.rx_fifo_errors++;
2410: } else {
2411: /* Omit the four octet CRC from the length. */
2412: short pkt_len = ((status >> 16) & 0x7FF) - 4;
2413: struct sk_buff *skb;
2414:
2415: /* Check if the packet is long enough to just accept without
2416: copying to a properly sized skbuff. */
2417: if (pkt_len < rx_copybreak
2418: && (skb = DEV_ALLOC_SKB(pkt_len+2)) != NULL) {
2419: skb->dev = dev;
2420: skb_reserve(skb, 2); /* 16 byte align the IP header */
2421: #if LINUX_VERSION_CODE < 0x10300
2422: memcpy(skb->data, tp->rx_ring[entry].buffer1, pkt_len);
2423: #elif LINUX_VERSION_CODE < 0x20200 || defined(__alpha__)
2424: memcpy(skb_put(skb, pkt_len),
2425: bus_to_virt(tp->rx_ring[entry].buffer1), pkt_len);
2426: #else
2427: #warning Code untested
2428: eth_copy_and_sum(skb, bus_to_virt(tp->rx_ring[entry].buffer1),
2429: pkt_len, 0);
2430: skb_put(skb, pkt_len);
2431: #endif
2432: work_done++;
2433: } else { /* Pass up the skb already on the Rx ring. */
2434: skb = tp->rx_skbuff[entry];
2435: tp->rx_skbuff[entry] = NULL;
2436: #ifndef final_version
2437: {
2438: void *temp = skb_put(skb, pkt_len);
2439: if (bus_to_virt(tp->rx_ring[entry].buffer1) != temp)
2440: printk(KERN_ERR "%s: Internal consistency error! The "
2441: "skbuff addresses do not match in tulip_rx:"
2442: " %p vs. %p / %p.\n", dev->name,
2443: bus_to_virt(tp->rx_ring[entry].buffer1),
2444: skb->head, temp);
2445: }
2446: #else
2447: skb_put(skb, pkt_len);
2448: #endif
2449: }
2450: #if LINUX_VERSION_CODE > 0x10300
2451: skb->protocol = eth_type_trans(skb, dev);
2452: #else
2453: skb->len = pkt_len;
2454: #endif
2455: netif_rx(skb);
2456: dev->last_rx = jiffies;
2457: tp->stats.rx_packets++;
2458: #if LINUX_VERSION_CODE > 0x20127
2459: tp->stats.rx_bytes += pkt_len;
2460: #endif
2461: }
2462: entry = (++tp->cur_rx) % RX_RING_SIZE;
2463: }
2464:
2465: /* Refill the Rx ring buffers. */
2466: for (; tp->cur_rx - tp->dirty_rx > 0; tp->dirty_rx++) {
2467: entry = tp->dirty_rx % RX_RING_SIZE;
2468: if (tp->rx_skbuff[entry] == NULL) {
2469: struct sk_buff *skb;
2470: skb = tp->rx_skbuff[entry] = DEV_ALLOC_SKB(PKT_BUF_SZ);
2471: if (skb == NULL)
2472: break;
2473: skb->dev = dev; /* Mark as being used by this device. */
2474: #if LINUX_VERSION_CODE > 0x10300
2475: tp->rx_ring[entry].buffer1 = virt_to_bus(skb->tail);
2476: #else
2477: tp->rx_ring[entry].buffer1 = virt_to_bus(skb->data);
2478: #endif
2479: work_done++;
2480: }
2481: tp->rx_ring[entry].status = 0x80000000;
2482: }
2483:
2484: return work_done;
2485: }
2486:
2487: static int
2488: tulip_close(struct device *dev)
2489: {
2490: long ioaddr = dev->base_addr;
2491: struct tulip_private *tp = (struct tulip_private *)dev->priv;
2492: int i;
2493:
2494: dev->start = 0;
2495: dev->tbusy = 1;
2496:
2497: if (tulip_debug > 1)
2498: printk(KERN_DEBUG "%s: Shutting down ethercard, status was %2.2x.\n",
2499: dev->name, inl(ioaddr + CSR5));
2500:
2501: /* Disable interrupts by clearing the interrupt mask. */
2502: outl(0x00000000, ioaddr + CSR7);
2503: /* Stop the chip's Tx and Rx processes. */
2504: outl(inl(ioaddr + CSR6) & ~0x2002, ioaddr + CSR6);
2505: /* 21040 -- Leave the card in 10baseT state. */
2506: if (tp->chip_id == DC21040)
2507: outl(0x00000004, ioaddr + CSR13);
2508:
2509: tp->stats.rx_missed_errors += inl(ioaddr + CSR8) & 0xffff;
2510:
2511: del_timer(&tp->timer);
2512:
2513: #ifdef SA_SHIRQ
2514: free_irq(dev->irq, dev);
2515: #else
2516: free_irq(dev->irq);
2517: irq2dev_map[dev->irq] = 0;
2518: #endif
2519:
2520: /* Free all the skbuffs in the Rx queue. */
2521: for (i = 0; i < RX_RING_SIZE; i++) {
2522: struct sk_buff *skb = tp->rx_skbuff[i];
2523: tp->rx_skbuff[i] = 0;
2524: tp->rx_ring[i].status = 0; /* Not owned by Tulip chip. */
2525: tp->rx_ring[i].length = 0;
2526: tp->rx_ring[i].buffer1 = 0xBADF00D0; /* An invalid address. */
2527: if (skb) {
2528: #if LINUX_VERSION_CODE < 0x20100
2529: skb->free = 1;
2530: #endif
2531: #if (LINUX_VERSION_CODE > 0x20155)
2532: dev_kfree_skb(skb);
2533: #else
2534: dev_kfree_skb(skb, FREE_WRITE);
2535: #endif
2536: }
2537: }
2538: for (i = 0; i < TX_RING_SIZE; i++) {
2539: if (tp->tx_skbuff[i])
2540: #if (LINUX_VERSION_CODE > 0x20155)
2541: dev_kfree_skb(tp->tx_skbuff[i]);
2542: #else
2543: dev_kfree_skb(tp->tx_skbuff[i], FREE_WRITE);
2544: #endif
2545: tp->tx_skbuff[i] = 0;
2546: }
2547:
2548:
2549: MOD_DEC_USE_COUNT;
2550:
2551: return 0;
2552: }
2553:
2554: static struct enet_statistics *
2555: tulip_get_stats(struct device *dev)
2556: {
2557: struct tulip_private *tp = (struct tulip_private *)dev->priv;
2558: long ioaddr = dev->base_addr;
2559:
2560: if (dev->start)
2561: tp->stats.rx_missed_errors += inl(ioaddr + CSR8) & 0xffff;
2562:
2563: return &tp->stats;
2564: }
2565:
2566: #ifdef HAVE_PRIVATE_IOCTL
2567: /* Provide ioctl() calls to examine the MII xcvr state. */
2568: static int private_ioctl(struct device *dev, struct ifreq *rq, int cmd)
2569: {
2570: struct tulip_private *tp = (struct tulip_private *)dev->priv;
2571: long ioaddr = dev->base_addr;
2572: u16 *data = (u16 *)&rq->ifr_data;
2573: int phy = tp->phys[0] & 0x1f;
2574: long flags;
2575:
2576: switch(cmd) {
2577: case SIOCDEVPRIVATE: /* Get the address of the PHY in use. */
2578: if (tp->mtable && tp->mtable->has_mii)
2579: data[0] = phy;
2580: else if (tp->chip_id == DC21142)
2581: data[0] = 32;
2582: else
2583: return -ENODEV;
2584: return 0;
2585: case SIOCDEVPRIVATE+1: /* Read the specified MII register. */
2586: if (data[0] == 32) { /* 21142 pseudo-MII */
2587: int csr12 = inl(ioaddr + CSR12);
2588: int csr14 = inl(ioaddr + CSR14);
2589: switch (data[1]) {
2590: case 0: {
2591: data[3] = ((csr14<<13)&0x4000) + ((csr14<<5)&0x1000);
2592: break; }
2593: case 1:
2594: data[3] = 0x7848 + ((csr12&0x7000) == 0x5000 ? 0x20 : 0)
2595: + (csr12&0x06 ? 0x04 : 0);
2596: break;
2597: case 4: {
2598: int csr14 = inl(ioaddr + CSR14);
2599: data[3] = ((csr14>>9)&0x0380) + ((csr14>>1)&0x20) + 1;
2600: break;
2601: }
2602: case 5: data[3] = inl(ioaddr + CSR12) >> 16; break;
2603: default: data[3] = 0; break;
2604: }
2605: } else {
2606: save_flags(flags);
2607: cli();
2608: data[3] = mdio_read(dev, data[0] & 0x1f, data[1] & 0x1f);
2609: restore_flags(flags);
2610: }
2611: return 0;
2612: case SIOCDEVPRIVATE+2: /* Write the specified MII register */
2613: if (!suser())
2614: return -EPERM;
2615: if (data[0] == 32) { /* 21142 pseudo-MII */
2616: } else {
2617: save_flags(flags);
2618: cli();
2619: mdio_write(dev, data[0] & 0x1f, data[1] & 0x1f, data[2]);
2620: restore_flags(flags);
2621: }
2622: return 0;
2623: default:
2624: return -EOPNOTSUPP;
2625: }
2626:
2627: return -EOPNOTSUPP;
2628: }
2629: #endif /* HAVE_PRIVATE_IOCTL */
2630:
2631: /* Set or clear the multicast filter for this adaptor.
2632: Note that we only use exclusion around actually queueing the
2633: new frame, not around filling tp->setup_frame. This is non-deterministic
2634: when re-entered but still correct. */
2635:
2636: /* The little-endian AUTODIN32 ethernet CRC calculation.
2637: N.B. Do not use for bulk data, use a table-based routine instead.
2638: This is common code and should be moved to net/core/crc.c */
2639: static unsigned const ethernet_polynomial_le = 0xedb88320U;
2640: static inline unsigned ether_crc_le(int length, unsigned char *data)
2641: {
2642: unsigned int crc = 0xffffffff; /* Initial value. */
2643: while(--length >= 0) {
2644: unsigned char current_octet = *data++;
2645: int bit;
2646: for (bit = 8; --bit >= 0; current_octet >>= 1) {
2647: if ((crc ^ current_octet) & 1) {
2648: crc >>= 1;
2649: crc ^= ethernet_polynomial_le;
2650: } else
2651: crc >>= 1;
2652: }
2653: }
2654: return crc;
2655: }
2656:
2657: #ifdef NEW_MULTICAST
2658: static void set_rx_mode(struct device *dev)
2659: #else
2660: static void set_rx_mode(struct device *dev, int num_addrs, void *addrs)
2661: #endif
2662: {
2663: long ioaddr = dev->base_addr;
2664: int csr6 = inl(ioaddr + CSR6) & ~0x00D5;
2665: struct tulip_private *tp = (struct tulip_private *)dev->priv;
2666:
2667: tp->csr6 &= ~0x00D5;
2668: if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */
2669: outl(csr6 | 0x00C0, ioaddr + CSR6);
2670: /* Unconditionally log net taps. */
2671: printk(KERN_INFO "%s: Promiscuous mode enabled.\n", dev->name);
2672: tp->csr6 |= 0xC0;
2673: } else if ((dev->mc_count > 1000) || (dev->flags & IFF_ALLMULTI)) {
2674: /* Too many to filter perfectly -- accept all multicasts. */
2675: outl(csr6 | 0x0080, ioaddr + CSR6);
2676: tp->csr6 |= 0x80;
2677: } else {
2678: u32 *setup_frm = tp->setup_frame;
2679: struct dev_mc_list *mclist;
2680: u16 *eaddrs;
2681: u32 tx_flags;
2682: int i;
2683:
2684: if (dev->mc_count > 14) { /* Must use a multicast hash table. */
2685: u16 hash_table[32];
2686: memset(hash_table, 0, sizeof(hash_table));
2687: /* This should work on big-endian machines as well. */
2688: for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
2689: i++, mclist = mclist->next)
2690: set_bit(ether_crc_le(ETH_ALEN, mclist->dmi_addr) & 0x1ff,
2691: hash_table);
2692: /* Copy the hash table to the setup frame.
2693: NOTE that only the LOW SHORTWORD of setup_frame[] is valid! */
2694: for (i = 0; i < 32; i++)
2695: *setup_frm++ = hash_table[i];
2696: setup_frm += 7;
2697: tx_flags = 0x08400000 | 192;
2698: /* Too clever: i > 15 for fall-though. */
2699: } else {
2700: /* We have <= 15 addresses so we can use the wonderful
2701: 16 address perfect filtering of the Tulip. */
2702: for (i = 0, mclist = dev->mc_list; i < dev->mc_count;
2703: i++, mclist = mclist->next) {
2704: /* Note that only the low shortword of setup_frame[] is valid!
2705: This code may require tweaking for non-x86 architectures! */
2706: eaddrs = (u16 *)mclist->dmi_addr;
2707: *setup_frm++ = *eaddrs++;
2708: *setup_frm++ = *eaddrs++;
2709: *setup_frm++ = *eaddrs++;
2710: }
2711: /* Fill the rest of the table with our physical address.
2712: Once again, only the low shortword or setup_frame[] is valid! */
2713: *setup_frm++ = 0xffff;
2714: *setup_frm++ = 0xffff;
2715: *setup_frm++ = 0xffff;
2716: tx_flags = 0x08000000 | 192;
2717: }
2718: eaddrs = (u16 *)dev->dev_addr;
2719: do {
2720: *setup_frm++ = eaddrs[0];
2721: *setup_frm++ = eaddrs[1];
2722: *setup_frm++ = eaddrs[2];
2723: } while (++i < 15);
2724: /* Now add this frame to the Tx list. */
2725: if (tp->cur_tx - tp->dirty_tx > TX_RING_SIZE - 2) {
2726: /* Same setup recently queued, we need not add it. */
2727: } else {
2728: unsigned long flags;
2729: unsigned int entry;
2730:
2731: save_flags(flags); cli();
2732: entry = tp->cur_tx++ % TX_RING_SIZE;
2733:
2734: if (entry != 0) {
2735: /* Avoid a chip errata by prefixing a dummy entry. */
2736: tp->tx_skbuff[entry] = 0;
2737: tp->tx_ring[entry].length =
2738: (entry == TX_RING_SIZE-1) ? 0x02000000 : 0;
2739: tp->tx_ring[entry].buffer1 = 0;
2740: tp->tx_ring[entry].status = 0x80000000;
2741: entry = tp->cur_tx++ % TX_RING_SIZE;
2742: }
2743:
2744: tp->tx_skbuff[entry] = 0;
2745: /* Put the setup frame on the Tx list. */
2746: if (entry == TX_RING_SIZE-1)
2747: tx_flags |= 0x02000000; /* Wrap ring. */
2748: tp->tx_ring[entry].length = tx_flags;
2749: tp->tx_ring[entry].buffer1 = virt_to_bus(tp->setup_frame);
2750: tp->tx_ring[entry].status = 0x80000000;
2751: if (tp->cur_tx - tp->dirty_tx >= TX_RING_SIZE - 2) {
2752: dev->tbusy = 1;
2753: tp->tx_full = 1;
2754: }
2755: restore_flags(flags);
2756: /* Trigger an immediate transmit demand. */
2757: outl(0, ioaddr + CSR1);
2758: }
2759: outl(csr6 | 0x0000, ioaddr + CSR6);
2760: }
2761: }
2762:
2763: #ifdef CARDBUS
2764:
2765: #include <pcmcia/driver_ops.h>
2766:
2767: static dev_node_t *tulip_attach(dev_locator_t *loc)
2768: {
2769: u16 dev_id;
2770: u32 io;
2771: u8 bus, devfn;
2772: struct device *dev;
2773:
2774: if (loc->bus != LOC_PCI) return NULL;
2775: bus = loc->b.pci.bus; devfn = loc->b.pci.devfn;
2776: printk(KERN_INFO "tulip_attach(bus %d, function %d)\n", bus, devfn);
2777: pcibios_read_config_dword(bus, devfn, PCI_BASE_ADDRESS_0, &io);
2778: pcibios_read_config_word(bus, devfn, PCI_DEVICE_ID, &dev_id);
2779: io &= ~3;
2780: dev = tulip_probe1(bus, devfn, NULL, DC21142, -1);
2781: if (dev) {
2782: dev_node_t *node = kmalloc(sizeof(dev_node_t), GFP_KERNEL);
2783: strcpy(node->dev_name, dev->name);
2784: node->major = node->minor = 0;
2785: node->next = NULL;
2786: MOD_INC_USE_COUNT;
2787: return node;
2788: }
2789: return NULL;
2790: }
2791:
2792: static void tulip_detach(dev_node_t *node)
2793: {
2794: struct device **devp, **next;
2795: printk(KERN_INFO "tulip_detach(%s)\n", node->dev_name);
2796: for (devp = &root_tulip_dev; *devp; devp = next) {
2797: next = &((struct tulip_private *)(*devp)->priv)->next_module;
2798: if (strcmp((*devp)->name, node->dev_name) == 0) break;
2799: }
2800: if (*devp) {
2801: unregister_netdev(*devp);
2802: kfree(*devp);
2803: *devp = *next;
2804: kfree(node);
2805: MOD_DEC_USE_COUNT;
2806: }
2807: }
2808:
2809: struct driver_operations tulip_ops = {
2810: "tulip_cb", tulip_attach, NULL, NULL, tulip_detach
2811: };
2812:
2813: #endif /* Cardbus support */
2814:
2815:
2816: #ifdef MODULE
2817: #if LINUX_VERSION_CODE > 0x20118
2818: MODULE_AUTHOR("Donald Becker <[email protected]>");
2819: MODULE_DESCRIPTION("Digital 21*4* Tulip ethernet driver");
2820: MODULE_PARM(debug, "i");
2821: MODULE_PARM(max_interrupt_work, "i");
2822: MODULE_PARM(reverse_probe, "i");
2823: MODULE_PARM(rx_copybreak, "i");
2824: MODULE_PARM(options, "1-" __MODULE_STRING(MAX_UNITS) "i");
2825: MODULE_PARM(full_duplex, "1-" __MODULE_STRING(MAX_UNITS) "i");
2826: #endif
2827:
2828: /* An additional parameter that may be passed in... */
2829: static int debug = -1;
2830:
2831: int
2832: init_module(void)
2833: {
2834: if (debug >= 0)
2835: tulip_debug = debug;
2836:
2837: #ifdef CARDBUS
2838: register_driver(&tulip_ops);
2839: return 0;
2840: #else
2841: return tulip_probe(NULL);
2842: #endif
2843: }
2844:
2845: void
2846: cleanup_module(void)
2847: {
2848: struct device *next_dev;
2849:
2850: #ifdef CARDBUS
2851: unregister_driver(&tulip_ops);
2852: #endif
2853:
2854: /* No need to check MOD_IN_USE, as sys_delete_module() checks. */
2855: while (root_tulip_dev) {
2856: next_dev = ((struct tulip_private *)root_tulip_dev->priv)->next_module;
2857: unregister_netdev(root_tulip_dev);
2858: release_region(root_tulip_dev->base_addr, TULIP_TOTAL_SIZE);
2859: kfree(root_tulip_dev);
2860: root_tulip_dev = next_dev;
2861: }
2862: }
2863:
2864: #endif /* MODULE */
2865:
2866: /*
2867: * Local variables:
2868: * SMP-compile-command: "gcc -D__SMP__ -DMODULE -D__KERNEL__ -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O6 -c tulip.c `[ -f /usr/include/linux/modversions.h ] && echo -DMODVERSIONS`"
2869: * compile-command: "gcc -DMODULE -D__KERNEL__ -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O6 -c tulip.c `[ -f /usr/include/linux/modversions.h ] && echo -DMODVERSIONS`"
2870: * c-indent-level: 4
2871: * c-basic-offset: 4
2872: * tab-width: 4
2873: * End:
2874: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.