tulip.c@ 1300

Last change on this file since 1300 was 1, checked in by vboxsync, 55 years ago
import
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 74.2 KB

Line
1	/* -- Mode:C; c-basic-offset:4; -- */
2
3	/*
4	Tulip and clone Etherboot Driver
5
6	By Marty Connor ([email protected])
7	Copyright (C) 2001 Entity Cyber, Inc.
8
9	This software may be used and distributed according to the terms
10	of the GNU Public License, incorporated herein by reference.
11
12	As of April 2001 this driver should support most tulip cards that
13	the Linux tulip driver supports because Donald Becker's Linux media
14	detection code is now included.
15
16	Based on Ken Yap's Tulip Etherboot Driver and Donald Becker's
17	Linux Tulip Driver. Supports N-Way speed auto-configuration on
18	MX98715, MX98715A and MX98725. Support inexpensive PCI 10/100 cards
19	based on the Macronix MX987x5 chip, such as the SOHOware Fast
20	model SFA110A, and the LinkSYS model LNE100TX. The NetGear
21	model FA310X, based on the LC82C168 chip is supported.
22	The TRENDnet TE100-PCIA NIC which uses a genuine Intel 21143-PD
23	chipset is supported. Also, Davicom DM9102's.
24
25	Documentation and source code used:
26	Source for Etherboot driver at
27	http://etherboot.sourceforge.net/
28	MX98715A Data Sheet and MX98715A Application Note
29	on http://www.macronix.com/ (PDF format files)
30	Source for Linux tulip driver at
31	http://cesdis.gsfc.nasa.gov/linux/drivers/tulip.html
32
33	Adapted by Ken Yap from
34	FreeBSD netboot DEC 21143 driver
35	Author: David Sharp
36	date: Nov/98
37
38	Some code fragments were taken from verious places, Ken Yap's
39	etherboot, FreeBSD's if_de.c, and various Linux related files.
40	DEC's manuals for the 21143 and SROM format were very helpful.
41	The Linux de driver development page has a number of links to
42	useful related information. Have a look at:
43	ftp://cesdis.gsfc.nasa.gov/pub/linux/drivers/tulip-devel.html
44	*/
45
46	/*********************************************************************/
47	/* Revision History */
48	/*********************************************************************/
49
50	/*
51	08 Feb 2005 Ramesh Chander chhabaramesh at yahoo.co.in added table entries
52	for SGThomson STE10/100A
53	07 Sep 2003 timlegge Multicast Support Added
54	11 Apr 2001 mdc [patch to etherboot 4.7.24]
55	Major rewrite to include Linux tulip driver media detection
56	code. This driver should support a lot more cards now.
57	16 Jul 2000 mdc 0.75b11
58	Added support for ADMtek 0985 Centaur-P, a "Comet" tulip clone
59	which is used on the LinkSYS LNE100TX v4.x cards. We already
60	support LNE100TX v2.0 cards, which use a different controller.
61	04 Jul 2000 jam ?
62	Added test of status after receiving a packet from the card.
63	Also uncommented the tulip_disable routine. Stray packets
64	seemed to be causing problems.
65	27 Apr 2000 njl ?
66	29 Feb 2000 mdc 0.75b7
67	Increased reset delay to 3 seconds because Macronix cards seem to
68	need more reset time before card comes back to a usable state.
69	26 Feb 2000 mdc 0.75b6
70	Added a 1 second delay after initializing the transmitter because
71	some cards seem to need the time or they drop the first packet
72	transmitted.
73	23 Feb 2000 mdc 0.75b5
74	removed udelay code and used currticks() for more reliable delay
75	code in reset pause and sanity timeouts. Added function prototypes
76	and TX debugging code.
77	21 Feb 2000 mdc patch to Etherboot 4.4.3
78	Incorporated patches from Bob Edwards and Paul Mackerras of
79	Linuxcare's OZLabs to deal with inefficiencies in tulip_transmit
80	and udelay. We now wait for packet transmission to complete
81	(or sanity timeout).
82	04 Feb 2000 [email protected] patch to Etherboot 4.4.2
83	patch to tulip.c that implements the automatic selection of the MII
84	interface on cards using the Intel/DEC 21143 reference design, in
85	particular, the TRENDnet TE100-PCIA NIC which uses a genuine Intel
86	21143-PD chipset.
87	11 Jan 2000 mdc 0.75b4
88	Added support for NetGear FA310TX card based on the LC82C168
89	chip. This should also support Lite-On LC82C168 boards.
90	Added simple MII support. Re-arranged code to better modularize
91	initializations.
92	04 Dec 1999 mdc 0.75b3
93	Added preliminary support for LNE100TX PCI cards. Should work for
94	PNIC2 cards. No MII support, but single interface (RJ45) tulip
95	cards seem to not care.
96	03 Dec 1999 mdc 0.75b2
97	Renamed from mx987x5 to tulip, merged in original tulip init code
98	from tulip.c to support other tulip compatible cards.
99	02 Dec 1999 mdc 0.75b1
100	Released Beta MX987x5 Driver for code review and testing to netboot
101	and thinguin mailing lists.
102	*/
103
104
105
106	/*********************************************************************/
107	/* Declarations */
108	/*********************************************************************/
109
110	#include "etherboot.h"
111	#include "nic.h"
112	#include "pci.h"
113
114	/* User settable parameters */
115
116	#undef TULIP_DEBUG
117	#undef TULIP_DEBUG_WHERE
118	#ifdef TULIP_DEBUG
119	static int tulip_debug = 2; /* 1 normal messages, 0 quiet .. 7 verbose. */
120	#endif
121
122	#define TX_TIME_OUT 2*TICKS_PER_SEC
123
124	/* helpful macros if on a big_endian machine for changing byte order.
125	not strictly needed on Intel */
126	#define get_unaligned(ptr) (*(ptr))
127	#define put_unaligned(val, ptr) ((void)( *(ptr) = (val) ))
128	#define get_u16(ptr) ((u16 )(ptr))
129	#define virt_to_le32desc(addr) virt_to_bus(addr)
130
131	#define TULIP_IOTYPE PCI_USES_MASTER \| PCI_USES_IO \| PCI_ADDR0
132	#define TULIP_SIZE 0x80
133
134	/* This is a mysterious value that can be written to CSR11 in the 21040 (only)
135	to support a pre-NWay full-duplex signaling mechanism using short frames.
136	No one knows what it should be, but if left at its default value some
137	10base2(!) packets trigger a full-duplex-request interrupt. */
138	#define FULL_DUPLEX_MAGIC 0x6969
139
140	static const int csr0 = 0x01A00000 \| 0x8000;
141
142	/* The possible media types that can be set in options[] are: */
143	#define MEDIA_MASK 31
144	static const char * const medianame[32] = {
145	"10baseT", "10base2", "AUI", "100baseTx",
146	"10baseT-FDX", "100baseTx-FDX", "100baseT4", "100baseFx",
147	"100baseFx-FDX", "MII 10baseT", "MII 10baseT-FDX", "MII",
148	"10baseT(forced)", "MII 100baseTx", "MII 100baseTx-FDX", "MII 100baseT4",
149	"MII 100baseFx-HDX", "MII 100baseFx-FDX", "Home-PNA 1Mbps", "Invalid-19",
150	};
151
152	/* This much match tulip_tbl[]! Note 21142 == 21143. */
153	enum tulip_chips {
154	DC21040=0, DC21041=1, DC21140=2, DC21142=3, DC21143=3,
155	LC82C168, MX98713, MX98715, MX98725, AX88141, AX88140, PNIC2, COMET,
156	COMPEX9881, I21145, XIRCOM, SGThomson, /Ramesh Chander/
157	};
158
159	enum pci_id_flags_bits {
160	/* Set PCI command register bits before calling probe1(). */
161	PCI_USES_IO=1, PCI_USES_MEM=2, PCI_USES_MASTER=4,
162	/* Read and map the single following PCI BAR. */
163	PCI_ADDR0=0<<4, PCI_ADDR1=1<<4, PCI_ADDR2=2<<4, PCI_ADDR3=3<<4,
164	PCI_ADDR_64BITS=0x100, PCI_NO_ACPI_WAKE=0x200, PCI_NO_MIN_LATENCY=0x400,
165	PCI_UNUSED_IRQ=0x800,
166	};
167
168	struct pci_id_info {
169	char *name;
170	struct match_info {
171	u32 pci, pci_mask, subsystem, subsystem_mask;
172	u32 revision, revision_mask; /* Only 8 bits. */
173	} id;
174	enum pci_id_flags_bits pci_flags;
175	int io_size; /* Needed for I/O region check or ioremap(). */
176	int drv_flags; /* Driver use, intended as capability flags. */
177	};
178
179	static struct pci_id_info pci_id_tbl[] = {
180	{ "Digital DC21040 Tulip", { 0x00021011, 0xffffffff, 0, 0, 0, 0 },
181	TULIP_IOTYPE, 0x80, DC21040 },
182	{ "Digital DC21041 Tulip", { 0x00141011, 0xffffffff, 0, 0, 0, 0 },
183	TULIP_IOTYPE, 0x80, DC21041 },
184	{ "Digital DS21140A Tulip", { 0x00091011, 0xffffffff, 0,0, 0x20,0xf0 },
185	TULIP_IOTYPE, 0x80, DC21140 },
186	{ "Digital DS21140 Tulip", { 0x00091011, 0xffffffff, 0, 0, 0, 0 },
187	TULIP_IOTYPE, 0x80, DC21140 },
188	{ "Digital DS21143 Tulip", { 0x00191011, 0xffffffff, 0,0, 65,0xff },
189	TULIP_IOTYPE, TULIP_SIZE, DC21142 },
190	{ "Digital DS21142 Tulip", { 0x00191011, 0xffffffff, 0, 0, 0, 0 },
191	TULIP_IOTYPE, TULIP_SIZE, DC21142 },
192	{ "Kingston KNE110tx (PNIC)", { 0x000211AD, 0xffffffff, 0xf0022646, 0xffffffff, 0, 0 },
193	TULIP_IOTYPE, 256, LC82C168 },
194	{ "Lite-On 82c168 PNIC", { 0x000211AD, 0xffffffff, 0, 0, 0, 0 },
195	TULIP_IOTYPE, 256, LC82C168 },
196	{ "Macronix 98713 PMAC", { 0x051210d9, 0xffffffff, 0, 0, 0, 0 },
197	TULIP_IOTYPE, 256, MX98713 },
198	{ "Macronix 98715 PMAC", { 0x053110d9, 0xffffffff, 0, 0, 0, 0 },
199	TULIP_IOTYPE, 256, MX98715 },
200	{ "Macronix 98725 PMAC", { 0x053110d9, 0xffffffff, 0, 0, 0, 0 },
201	TULIP_IOTYPE, 256, MX98725 },
202	{ "ASIX AX88141", { 0x1400125B, 0xffffffff, 0,0, 0x10, 0xf0 },
203	TULIP_IOTYPE, 128, AX88141 },
204	{ "ASIX AX88140", { 0x1400125B, 0xffffffff, 0, 0, 0, 0 },
205	TULIP_IOTYPE, 128, AX88140 },
206	{ "Lite-On LC82C115 PNIC-II", { 0xc11511AD, 0xffffffff, 0, 0, 0, 0 },
207	TULIP_IOTYPE, 256, PNIC2 },
208	{ "ADMtek AN981 Comet", { 0x09811317, 0xffffffff, 0, 0, 0, 0 },
209	TULIP_IOTYPE, 256, COMET },
210	{ "ADMTek AN983 Comet", { 0x12161113, 0xffffffff, 0, 0, 0, 0 },
211	TULIP_IOTYPE, 256, COMET },
212	{ "ADMTek Comet AN983b", { 0x95111317, 0xffffffff, 0, 0, 0, 0 },
213	TULIP_IOTYPE, 256, COMET },
214	{ "ADMtek Centaur-P", { 0x09851317, 0xffffffff, 0, 0, 0, 0 },
215	TULIP_IOTYPE, 256, COMET },
216	{ "ADMtek Centaur-C", { 0x19851317, 0xffffffff, 0, 0, 0, 0 },
217	TULIP_IOTYPE, 256, COMET },
218	{ "Compex RL100-TX", { 0x988111F6, 0xffffffff, 0, 0, 0, 0 },
219	TULIP_IOTYPE, 128, COMPEX9881 },
220	{ "Intel 21145 Tulip", { 0x00398086, 0xffffffff, 0, 0, 0, 0 },
221	TULIP_IOTYPE, 128, I21145 },
222	{ "Xircom Tulip clone", { 0x0003115d, 0xffffffff, 0, 0, 0, 0 },
223	TULIP_IOTYPE, 128, XIRCOM },
224	{ "Davicom DM9102", { 0x91021282, 0xffffffff, 0, 0, 0, 0 },
225	TULIP_IOTYPE, 0x80, DC21140 },
226	{ "Davicom DM9100", { 0x91001282, 0xffffffff, 0, 0, 0, 0 },
227	TULIP_IOTYPE, 0x80, DC21140 },
228	{ "Macronix mxic-98715 (EN1217)", { 0x12171113, 0xffffffff, 0, 0, 0, 0 },
229	TULIP_IOTYPE, 256, MX98715 },
230	{ "3Com 3cSOHO100B-TX (ADMtek Centuar)", { 0x930010b7, 0xffffffff, 0, 0, 0, 0 },
231	TULIP_IOTYPE, TULIP_SIZE, COMET },
232	{ "SG Thomson STE10/100A", { 0x2774104a, 0xffffffff, 0, 0, 0, 0 },
233	TULIP_IOTYPE, 256, COMET }, /Ramesh Chander/
234	{ 0, { 0, 0, 0, 0, 0, 0 }, 0, 0, 0 },
235	};
236
237	enum tbl_flag {
238	HAS_MII=1, HAS_MEDIA_TABLE=2, CSR12_IN_SROM=4, ALWAYS_CHECK_MII=8,
239	HAS_PWRDWN=0x10, MC_HASH_ONLY=0x20, /* Hash-only multicast filter. */
240	HAS_PNICNWAY=0x80, HAS_NWAY=0x40, /* Uses internal NWay xcvr. */
241	HAS_INTR_MITIGATION=0x100, IS_ASIX=0x200, HAS_8023X=0x400,
242	};
243
244	/* Note: this table must match enum tulip_chips above. */
245	static struct tulip_chip_table {
246	char *chip_name;
247	int flags;
248	} tulip_tbl[] = {
249	{ "Digital DC21040 Tulip", 0},
250	{ "Digital DC21041 Tulip", HAS_MEDIA_TABLE \| HAS_NWAY },
251	{ "Digital DS21140 Tulip", HAS_MII \| HAS_MEDIA_TABLE \| CSR12_IN_SROM },
252	{ "Digital DS21143 Tulip", HAS_MII \| HAS_MEDIA_TABLE \| ALWAYS_CHECK_MII
253	\| HAS_PWRDWN \| HAS_NWAY \| HAS_INTR_MITIGATION },
254	{ "Lite-On 82c168 PNIC", HAS_MII \| HAS_PNICNWAY },
255	{ "Macronix 98713 PMAC", HAS_MII \| HAS_MEDIA_TABLE \| CSR12_IN_SROM },
256	{ "Macronix 98715 PMAC", HAS_MEDIA_TABLE },
257	{ "Macronix 98725 PMAC", HAS_MEDIA_TABLE },
258	{ "ASIX AX88140", HAS_MII \| HAS_MEDIA_TABLE \| CSR12_IN_SROM
259	\| MC_HASH_ONLY \| IS_ASIX },
260	{ "ASIX AX88141", HAS_MII \| HAS_MEDIA_TABLE \| CSR12_IN_SROM \| MC_HASH_ONLY
261	\| IS_ASIX },
262	{ "Lite-On PNIC-II", HAS_MII \| HAS_NWAY \| HAS_8023X },
263	{ "ADMtek Comet", HAS_MII \| MC_HASH_ONLY },
264	{ "Compex 9881 PMAC", HAS_MII \| HAS_MEDIA_TABLE \| CSR12_IN_SROM },
265	{ "Intel DS21145 Tulip", HAS_MII \| HAS_MEDIA_TABLE \| ALWAYS_CHECK_MII
266	\| HAS_PWRDWN \| HAS_NWAY },
267	{ "Xircom tulip work-alike", HAS_MII \| HAS_MEDIA_TABLE \| ALWAYS_CHECK_MII
268	\| HAS_PWRDWN \| HAS_NWAY },
269	{ "SGThomson STE10/100A", HAS_MII \| MC_HASH_ONLY }, /Ramesh Chander/
270	{ 0, 0 },
271	};
272
273	/* A full-duplex map for media types. */
274	enum MediaIs {
275	MediaIsFD = 1, MediaAlwaysFD=2, MediaIsMII=4, MediaIsFx=8,
276	MediaIs100=16};
277
278	static const char media_cap[32] =
279	{0,0,0,16, 3,19,16,24, 27,4,7,5, 0,20,23,20, 20,31,0,0, };
280	static u8 t21040_csr13[] = {2,0x0C,8,4, 4,0,0,0, 0,0,0,0, 4,0,0,0};
281
282	/* 21041 transceiver register settings: 10-T, 10-2, AUI, 10-T, 10T-FD */
283	static u16 t21041_csr13[] = { 0xEF01, 0xEF09, 0xEF09, 0xEF01, 0xEF09, };
284	static u16 t21041_csr14[] = { 0xFFFF, 0xF7FD, 0xF7FD, 0x7F3F, 0x7F3D, };
285	static u16 t21041_csr15[] = { 0x0008, 0x0006, 0x000E, 0x0008, 0x0008, };
286
287	/* not used
288	static u16 t21142_csr13[] = { 0x0001, 0x0009, 0x0009, 0x0000, 0x0001, };
289	*/
290	static u16 t21142_csr14[] = { 0xFFFF, 0x0705, 0x0705, 0x0000, 0x7F3D, };
291	/* not used
292	static u16 t21142_csr15[] = { 0x0008, 0x0006, 0x000E, 0x0008, 0x0008, };
293	*/
294
295	/* Offsets to the Command and Status Registers, "CSRs". All accesses
296	must be longword instructions and quadword aligned. */
297	enum tulip_offsets {
298	CSR0=0, CSR1=0x08, CSR2=0x10, CSR3=0x18, CSR4=0x20, CSR5=0x28,
299	CSR6=0x30, CSR7=0x38, CSR8=0x40, CSR9=0x48, CSR10=0x50, CSR11=0x58,
300	CSR12=0x60, CSR13=0x68, CSR14=0x70, CSR15=0x78, CSR16=0x80, CSR20=0xA0
301	};
302
303	/* The bits in the CSR5 status registers, mostly interrupt sources. */
304	enum status_bits {
305	TimerInt=0x800, TPLnkFail=0x1000, TPLnkPass=0x10,
306	NormalIntr=0x10000, AbnormalIntr=0x8000,
307	RxJabber=0x200, RxDied=0x100, RxNoBuf=0x80, RxIntr=0x40,
308	TxFIFOUnderflow=0x20, TxJabber=0x08, TxNoBuf=0x04, TxDied=0x02, TxIntr=0x01,
309	};
310
311	/* The configuration bits in CSR6. */
312	enum csr6_mode_bits {
313	TxOn=0x2000, RxOn=0x0002, FullDuplex=0x0200,
314	AcceptBroadcast=0x0100, AcceptAllMulticast=0x0080,
315	AcceptAllPhys=0x0040, AcceptRunt=0x0008,
316	};
317
318
319	enum desc_status_bits {
320	DescOwnded=0x80000000, RxDescFatalErr=0x8000, RxWholePkt=0x0300,
321	};
322
323	struct medialeaf {
324	u8 type;
325	u8 media;
326	unsigned char *leafdata;
327	};
328
329	struct mediatable {
330	u16 defaultmedia;
331	u8 leafcount, csr12dir; /* General purpose pin directions. */
332	unsigned has_mii:1, has_nonmii:1, has_reset:6;
333	u32 csr15dir, csr15val; /* 21143 NWay setting. */
334	struct medialeaf mleaf[0];
335	};
336
337	struct mediainfo {
338	struct mediainfo *next;
339	int info_type;
340	int index;
341	unsigned char *info;
342	};
343
344	/* EEPROM Address width definitions */
345	#define EEPROM_ADDRLEN 6
346	#define EEPROM_SIZE 128 /* 2 << EEPROM_ADDRLEN */
347
348	/* The EEPROM commands include the alway-set leading bit. */
349	#define EE_WRITE_CMD (5 << addr_len)
350	#define EE_READ_CMD (6 << addr_len)
351	#define EE_ERASE_CMD (7 << addr_len)
352
353	/* EEPROM_Ctrl bits. */
354	#define EE_SHIFT_CLK 0x02 /* EEPROM shift clock. */
355	#define EE_CS 0x01 /* EEPROM chip select. */
356	#define EE_DATA_WRITE 0x04 /* EEPROM chip data in. */
357	#define EE_WRITE_0 0x01
358	#define EE_WRITE_1 0x05
359	#define EE_DATA_READ 0x08 /* EEPROM chip data out. */
360	#define EE_ENB (0x4800 \| EE_CS)
361
362	/* Delay between EEPROM clock transitions. Even at 33Mhz current PCI
363	implementations don't overrun the EEPROM clock. We add a bus
364	turn-around to insure that this remains true. */
365	#define eeprom_delay() inl(ee_addr)
366
367	/* Size of transmit and receive buffers */
368	#define BUFLEN 1536
369
370	/* Ring-wrap flag in length field, use for last ring entry.
371	0x01000000 means chain on buffer2 address,
372	0x02000000 means use the ring start address in CSR2/3.
373	Note: Some work-alike chips do not function correctly in chained mode.
374	The ASIX chip works only in chained mode.
375	Thus we indicate ring mode, but always write the 'next' field for
376	chained mode as well. */
377	#define DESC_RING_WRAP 0x02000000
378
379	/* transmit and receive descriptor format */
380	struct tulip_rx_desc {
381	volatile u32 status;
382	u32 length;
383	u32 buffer1, buffer2;
384	};
385
386	struct tulip_tx_desc {
387	volatile u32 status;
388	u32 length;
389	u32 buffer1, buffer2;
390	};
391
392	/*********************************************************************/
393	/* Global Storage */
394	/*********************************************************************/
395
396	static u32 ioaddr;
397
398	/* Note: transmit and receive buffers must be longword aligned and
399	longword divisable */
400
401	#define TX_RING_SIZE 2
402	static struct tulip_tx_desc tx_ring[TX_RING_SIZE] __attribute__ ((aligned(4)));
403	static unsigned char txb[BUFLEN] __attribute__ ((aligned(4)));
404
405	#define RX_RING_SIZE 4
406	static struct tulip_rx_desc rx_ring[RX_RING_SIZE] __attribute__ ((aligned(4)));
407	static unsigned char rxb[RX_RING_SIZE * BUFLEN] __attribute__ ((aligned(4)));
408
409	static struct tulip_private {
410	int cur_rx;
411	int chip_id; /* index into tulip_tbl[] */
412	int pci_id_idx; /* index into pci_id_tbl[] */
413	int revision;
414	int flags;
415	unsigned short vendor_id; /* PCI card vendor code */
416	unsigned short dev_id; /* PCI card device code */
417	unsigned char ehdr[ETH_HLEN]; /* buffer for ethernet header */
418	const char *nic_name;
419	unsigned int csr0, csr6; /* Current CSR0, CSR6 settings. */
420	unsigned int if_port;
421	unsigned int full_duplex; /* Full-duplex operation requested. */
422	unsigned int full_duplex_lock;
423	unsigned int medialock; /* Do not sense media type. */
424	unsigned int mediasense; /* Media sensing in progress. */
425	unsigned int nway, nwayset; /* 21143 internal NWay. */
426	unsigned int default_port;
427	unsigned char eeprom[EEPROM_SIZE]; /* Serial EEPROM contents. */
428	u8 media_table_storage[(sizeof(struct mediatable) + 32*sizeof(struct medialeaf))];
429	u16 sym_advertise, mii_advertise; /* NWay to-advertise. */
430	struct mediatable *mtable;
431	u16 lpar; /* 21143 Link partner ability. */
432	u16 advertising[4]; /* MII advertise, from SROM table. */
433	signed char phys[4], mii_cnt; /* MII device addresses. */
434	int cur_index; /* Current media index. */
435	int saved_if_port;
436	} tpx;
437
438	static struct tulip_private *tp;
439
440	/* Known cards that have old-style EEPROMs.
441	Writing this table is described at
442	http://cesdis.gsfc.nasa.gov/linux/drivers/tulip-drivers/tulip-media.html */
443	static struct fixups {
444	char *name;
445	unsigned char addr0, addr1, addr2;
446	u16 newtable[32]; /* Max length below. */
447	} eeprom_fixups[] = {
448	{"Asante", 0, 0, 0x94, {0x1e00, 0x0000, 0x0800, 0x0100, 0x018c,
449	0x0000, 0x0000, 0xe078, 0x0001, 0x0050, 0x0018 }},
450	{"SMC9332DST", 0, 0, 0xC0, { 0x1e00, 0x0000, 0x0800, 0x041f,
451	0x0000, 0x009E, /* 10baseT */
452	0x0004, 0x009E, /* 10baseT-FD */
453	0x0903, 0x006D, /* 100baseTx */
454	0x0905, 0x006D, /* 100baseTx-FD */ }},
455	{"Cogent EM100", 0, 0, 0x92, { 0x1e00, 0x0000, 0x0800, 0x063f,
456	0x0107, 0x8021, /* 100baseFx */
457	0x0108, 0x8021, /* 100baseFx-FD */
458	0x0100, 0x009E, /* 10baseT */
459	0x0104, 0x009E, /* 10baseT-FD */
460	0x0103, 0x006D, /* 100baseTx */
461	0x0105, 0x006D, /* 100baseTx-FD */ }},
462	{"Maxtech NX-110", 0, 0, 0xE8, { 0x1e00, 0x0000, 0x0800, 0x0513,
463	0x1001, 0x009E, /* 10base2, CSR12 0x10*/
464	0x0000, 0x009E, /* 10baseT */
465	0x0004, 0x009E, /* 10baseT-FD */
466	0x0303, 0x006D, /* 100baseTx, CSR12 0x03 */
467	0x0305, 0x006D, /* 100baseTx-FD CSR12 0x03 */}},
468	{"Accton EN1207", 0, 0, 0xE8, { 0x1e00, 0x0000, 0x0800, 0x051F,
469	0x1B01, 0x0000, /* 10base2, CSR12 0x1B */
470	0x0B00, 0x009E, /* 10baseT, CSR12 0x0B */
471	0x0B04, 0x009E, /* 10baseT-FD,CSR12 0x0B */
472	0x1B03, 0x006D, /* 100baseTx, CSR12 0x1B */
473	0x1B05, 0x006D, /* 100baseTx-FD CSR12 0x1B */
474	}},
475	{0, 0, 0, 0, {}}};
476
477	static const char * block_name[] = {"21140 non-MII", "21140 MII PHY",
478	"21142 Serial PHY", "21142 MII PHY", "21143 SYM PHY", "21143 reset method"};
479
480
481
482	/*********************************************************************/
483	/* Function Prototypes */
484	/*********************************************************************/
485	static int mdio_read(struct nic *nic, int phy_id, int location);
486	static void mdio_write(struct nic *nic, int phy_id, int location, int value);
487	static int read_eeprom(unsigned long ioaddr, int location, int addr_len);
488	static void parse_eeprom(struct nic *nic);
489	static int tulip_probe(struct dev dev, struct pci_device pci);
490	static void tulip_init_ring(struct nic *nic);
491	static void tulip_reset(struct nic *nic);
492	static void tulip_transmit(struct nic nic, const char d, unsigned int t,
493	unsigned int s, const char *p);
494	static int tulip_poll(struct nic *nic, int retrieve);
495	static void tulip_disable(struct dev *dev);
496	static void nway_start(struct nic *nic);
497	static void pnic_do_nway(struct nic *nic);
498	static void select_media(struct nic *nic, int startup);
499	static void init_media(struct nic *nic);
500	static void start_link(struct nic *nic);
501	static int tulip_check_duplex(struct nic *nic);
502
503	static void tulip_wait(unsigned int nticks);
504
505	#ifdef TULIP_DEBUG_WHERE
506	static void whereami(const char *str);
507	#endif
508
509	#ifdef TULIP_DEBUG
510	static void tulip_more(void);
511	#endif
512
513
514
515	/*********************************************************************/
516	/* Utility Routines */
517	/*********************************************************************/
518
519	#ifdef TULIP_DEBUG_WHERE
520	static void whereami (const char *str)
521	{
522	printf("%s: %s\n", tp->nic_name, str);
523	/* sleep(2); */
524	}
525	#endif
526
527	#ifdef TULIP_DEBUG
528	static void tulip_more(void)
529	{
530	printf("\n\n-- more --");
531	while (!iskey())
532	/* wait */;
533	getchar();
534	printf("\n\n");
535	}
536	#endif /* TULIP_DEBUG */
537
538	static void tulip_wait(unsigned int nticks)
539	{
540	unsigned int to = currticks() + nticks;
541	while (currticks() < to)
542	/* wait */ ;
543	}
544
545
546
547	/*********************************************************************/
548	/* Media Descriptor Code */
549	/*********************************************************************/
550
551	/* MII transceiver control section.
552	Read and write the MII registers using software-generated serial
553	MDIO protocol. See the MII specifications or DP83840A data sheet
554	for details. */
555
556	/* The maximum data clock rate is 2.5 Mhz. The minimum timing is usually
557	met by back-to-back PCI I/O cycles, but we insert a delay to avoid
558	"overclocking" issues or future 66Mhz PCI. */
559	#define mdio_delay() inl(mdio_addr)
560
561	/* Read and write the MII registers using software-generated serial
562	MDIO protocol. It is just different enough from the EEPROM protocol
563	to not share code. The maxium data clock rate is 2.5 Mhz. */
564	#define MDIO_SHIFT_CLK 0x10000
565	#define MDIO_DATA_WRITE0 0x00000
566	#define MDIO_DATA_WRITE1 0x20000
567	#define MDIO_ENB 0x00000 /* Ignore the 0x02000 databook setting. */
568	#define MDIO_ENB_IN 0x40000
569	#define MDIO_DATA_READ 0x80000
570
571	/* MII transceiver control section.
572	Read and write the MII registers using software-generated serial
573	MDIO protocol. See the MII specifications or DP83840A data sheet
574	for details. */
575
576	int mdio_read(struct nic *nic __unused, int phy_id, int location)
577	{
578	int i;
579	int read_cmd = (0xf6 << 10) \| (phy_id << 5) \| location;
580	int retval = 0;
581	long mdio_addr = ioaddr + CSR9;
582
583	#ifdef TULIP_DEBUG_WHERE
584	whereami("mdio_read\n");
585	#endif
586
587	if (tp->chip_id == LC82C168) {
588	int i = 1000;
589	outl(0x60020000 + (phy_id<<23) + (location<<18), ioaddr + 0xA0);
590	inl(ioaddr + 0xA0);
591	inl(ioaddr + 0xA0);
592	while (--i > 0)
593	if ( ! ((retval = inl(ioaddr + 0xA0)) & 0x80000000))
594	return retval & 0xffff;
595	return 0xffff;
596	}
597
598	if (tp->chip_id == COMET) {
599	if (phy_id == 1) {
600	if (location < 7)
601	return inl(ioaddr + 0xB4 + (location<<2));
602	else if (location == 17)
603	return inl(ioaddr + 0xD0);
604	else if (location >= 29 && location <= 31)
605	return inl(ioaddr + 0xD4 + ((location-29)<<2));
606	}
607	return 0xffff;
608	}
609
610	/* Establish sync by sending at least 32 logic ones. */
611	for (i = 32; i >= 0; i--) {
612	outl(MDIO_ENB \| MDIO_DATA_WRITE1, mdio_addr);
613	mdio_delay();
614	outl(MDIO_ENB \| MDIO_DATA_WRITE1 \| MDIO_SHIFT_CLK, mdio_addr);
615	mdio_delay();
616	}
617	/* Shift the read command bits out. */
618	for (i = 15; i >= 0; i--) {
619	int dataval = (read_cmd & (1 << i)) ? MDIO_DATA_WRITE1 : 0;
620
621	outl(MDIO_ENB \| dataval, mdio_addr);
622	mdio_delay();
623	outl(MDIO_ENB \| dataval \| MDIO_SHIFT_CLK, mdio_addr);
624	mdio_delay();
625	}
626	/* Read the two transition, 16 data, and wire-idle bits. */
627	for (i = 19; i > 0; i--) {
628	outl(MDIO_ENB_IN, mdio_addr);
629	mdio_delay();
630	retval = (retval << 1) \| ((inl(mdio_addr) & MDIO_DATA_READ) ? 1 : 0);
631	outl(MDIO_ENB_IN \| MDIO_SHIFT_CLK, mdio_addr);
632	mdio_delay();
633	}
634	return (retval>>1) & 0xffff;
635	}
636
637	void mdio_write(struct nic *nic __unused, int phy_id, int location, int value)
638	{
639	int i;
640	int cmd = (0x5002 << 16) \| (phy_id << 23) \| (location<<18) \| value;
641	long mdio_addr = ioaddr + CSR9;
642
643	#ifdef TULIP_DEBUG_WHERE
644	whereami("mdio_write\n");
645	#endif
646
647	if (tp->chip_id == LC82C168) {
648	int i = 1000;
649	outl(cmd, ioaddr + 0xA0);
650	do
651	if ( ! (inl(ioaddr + 0xA0) & 0x80000000))
652	break;
653	while (--i > 0);
654	return;
655	}
656
657	if (tp->chip_id == COMET) {
658	if (phy_id != 1)
659	return;
660	if (location < 7)
661	outl(value, ioaddr + 0xB4 + (location<<2));
662	else if (location == 17)
663	outl(value, ioaddr + 0xD0);
664	else if (location >= 29 && location <= 31)
665	outl(value, ioaddr + 0xD4 + ((location-29)<<2));
666	return;
667	}
668
669	/* Establish sync by sending 32 logic ones. */
670	for (i = 32; i >= 0; i--) {
671	outl(MDIO_ENB \| MDIO_DATA_WRITE1, mdio_addr);
672	mdio_delay();
673	outl(MDIO_ENB \| MDIO_DATA_WRITE1 \| MDIO_SHIFT_CLK, mdio_addr);
674	mdio_delay();
675	}
676	/* Shift the command bits out. */
677	for (i = 31; i >= 0; i--) {
678	int dataval = (cmd & (1 << i)) ? MDIO_DATA_WRITE1 : 0;
679	outl(MDIO_ENB \| dataval, mdio_addr);
680	mdio_delay();
681	outl(MDIO_ENB \| dataval \| MDIO_SHIFT_CLK, mdio_addr);
682	mdio_delay();
683	}
684	/* Clear out extra bits. */
685	for (i = 2; i > 0; i--) {
686	outl(MDIO_ENB_IN, mdio_addr);
687	mdio_delay();
688	outl(MDIO_ENB_IN \| MDIO_SHIFT_CLK, mdio_addr);
689	mdio_delay();
690	}
691	}
692
693
694
695	/*********************************************************************/
696	/* EEPROM Reading Code */
697	/*********************************************************************/
698	/* EEPROM routines adapted from the Linux Tulip Code */
699	/* Reading a serial EEPROM is a "bit" grungy, but we work our way
700	through:->.
701	*/
702	static int read_eeprom(unsigned long ioaddr, int location, int addr_len)
703	{
704	int i;
705	unsigned short retval = 0;
706	long ee_addr = ioaddr + CSR9;
707	int read_cmd = location \| EE_READ_CMD;
708
709	#ifdef TULIP_DEBUG_WHERE
710	whereami("read_eeprom\n");
711	#endif
712
713	outl(EE_ENB & ~EE_CS, ee_addr);
714	outl(EE_ENB, ee_addr);
715
716	/* Shift the read command bits out. */
717	for (i = 4 + addr_len; i >= 0; i--) {
718	short dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
719	outl(EE_ENB \| dataval, ee_addr);
720	eeprom_delay();
721	outl(EE_ENB \| dataval \| EE_SHIFT_CLK, ee_addr);
722	eeprom_delay();
723	}
724	outl(EE_ENB, ee_addr);
725
726	for (i = 16; i > 0; i--) {
727	outl(EE_ENB \| EE_SHIFT_CLK, ee_addr);
728	eeprom_delay();
729	retval = (retval << 1) \| ((inl(ee_addr) & EE_DATA_READ) ? 1 : 0);
730	outl(EE_ENB, ee_addr);
731	eeprom_delay();
732	}
733
734	/* Terminate the EEPROM access. */
735	outl(EE_ENB & ~EE_CS, ee_addr);
736	return retval;
737	}
738
739
740
741	/*********************************************************************/
742	/* EEPROM Parsing Code */
743	/*********************************************************************/
744	static void parse_eeprom(struct nic *nic)
745	{
746	unsigned char p, ee_data = tp->eeprom;
747	int new_advertise = 0;
748	int i;
749
750	#ifdef TULIP_DEBUG_WHERE
751	whereami("parse_eeprom\n");
752	#endif
753
754	tp->mtable = 0;
755	/* Detect an old-style (SA only) EEPROM layout:
756	memcmp(ee_data, ee_data+16, 8). */
757	for (i = 0; i < 8; i ++)
758	if (ee_data[i] != ee_data[16+i])
759	break;
760	if (i >= 8) {
761	/* Do a fix-up based on the vendor half of the station address. */
762	for (i = 0; eeprom_fixups[i].name; i++) {
763	if (nic->node_addr[0] == eeprom_fixups[i].addr0
764	&& nic->node_addr[1] == eeprom_fixups[i].addr1
765	&& nic->node_addr[2] == eeprom_fixups[i].addr2) {
766	if (nic->node_addr[2] == 0xE8 && ee_data[0x1a] == 0x55)
767	i++; /* An Accton EN1207, not an outlaw Maxtech. */
768	memcpy(ee_data + 26, eeprom_fixups[i].newtable,
769	sizeof(eeprom_fixups[i].newtable));
770	#ifdef TULIP_DEBUG
771	printf("%s: Old format EEPROM on '%s' board.\n%s: Using substitute media control info.\n",
772	tp->nic_name, eeprom_fixups[i].name, tp->nic_name);
773	#endif
774	break;
775	}
776	}
777	if (eeprom_fixups[i].name == NULL) { /* No fixup found. */
778	#ifdef TULIP_DEBUG
779	printf("%s: Old style EEPROM with no media selection information.\n",
780	tp->nic_name);
781	#endif
782	return;
783	}
784	}
785
786	if (ee_data[19] > 1) {
787	#ifdef TULIP_DEBUG
788	printf("%s: Multiport cards (%d ports) may not work correctly.\n",
789	tp->nic_name, ee_data[19]);
790	#endif
791	}
792
793	p = (void *)ee_data + ee_data[27];
794
795	if (ee_data[27] == 0) { /* No valid media table. */
796	#ifdef TULIP_DEBUG
797	if (tulip_debug > 1) {
798	printf("%s: No Valid Media Table. ee_data[27] = %hhX\n",
799	tp->nic_name, ee_data[27]);
800	}
801	#endif
802	} else if (tp->chip_id == DC21041) {
803	int media = get_u16(p);
804	int count = p[2];
805	p += 3;
806
807	printf("%s: 21041 Media table, default media %hX (%s).\n",
808	tp->nic_name, media,
809	media & 0x0800 ? "Autosense" : medianame[media & 15]);
810	for (i = 0; i < count; i++) {
811	unsigned char media_block = *p++;
812	int media_code = media_block & MEDIA_MASK;
813	if (media_block & 0x40)
814	p += 6;
815	switch(media_code) {
816	case 0: new_advertise \|= 0x0020; break;
817	case 4: new_advertise \|= 0x0040; break;
818	}
819	printf("%s: 21041 media #%d, %s.\n",
820	tp->nic_name, media_code, medianame[media_code]);
821	}
822	} else {
823	unsigned char csr12dir = 0;
824	int count;
825	struct mediatable *mtable;
826	u16 media = get_u16(p);
827
828	p += 2;
829	if (tp->flags & CSR12_IN_SROM)
830	csr12dir = *p++;
831	count = *p++;
832
833	tp->mtable = mtable = (struct mediatable *)&tp->media_table_storage[0];
834
835	mtable->defaultmedia = media;
836	mtable->leafcount = count;
837	mtable->csr12dir = csr12dir;
838	mtable->has_nonmii = mtable->has_mii = mtable->has_reset = 0;
839	mtable->csr15dir = mtable->csr15val = 0;
840
841	printf("%s: EEPROM default media type %s.\n", tp->nic_name,
842	media & 0x0800 ? "Autosense" : medianame[media & MEDIA_MASK]);
843
844	for (i = 0; i < count; i++) {
845	struct medialeaf *leaf = &mtable->mleaf[i];
846
847	if ((p[0] & 0x80) == 0) { /* 21140 Compact block. */
848	leaf->type = 0;
849	leaf->media = p[0] & 0x3f;
850	leaf->leafdata = p;
851	if ((p[2] & 0x61) == 0x01) /* Bogus, but Znyx boards do it. */
852	mtable->has_mii = 1;
853	p += 4;
854	} else {
855	switch(leaf->type = p[1]) {
856	case 5:
857	mtable->has_reset = i;
858	leaf->media = p[2] & 0x0f;
859	break;
860	case 1: case 3:
861	mtable->has_mii = 1;
862	leaf->media = 11;
863	break;
864	case 2:
865	if ((p[2] & 0x3f) == 0) {
866	u32 base15 = (p[2] & 0x40) ? get_u16(p + 7) : 0x0008;
867	u16 p1 = (u16 )(p + (p[2] & 0x40 ? 9 : 3));
868	mtable->csr15dir = (get_unaligned(p1 + 0)<<16) + base15;
869	mtable->csr15val = (get_unaligned(p1 + 1)<<16) + base15;
870	}
871	/* Fall through. */
872	case 0: case 4:
873	mtable->has_nonmii = 1;
874	leaf->media = p[2] & MEDIA_MASK;
875	switch (leaf->media) {
876	case 0: new_advertise \|= 0x0020; break;
877	case 4: new_advertise \|= 0x0040; break;
878	case 3: new_advertise \|= 0x0080; break;
879	case 5: new_advertise \|= 0x0100; break;
880	case 6: new_advertise \|= 0x0200; break;
881	}
882	break;
883	default:
884	leaf->media = 19;
885	}
886	leaf->leafdata = p + 2;
887	p += (p[0] & 0x3f) + 1;
888	}
889	#ifdef TULIP_DEBUG
890	if (tulip_debug > 1 && leaf->media == 11) {
891	unsigned char *bp = leaf->leafdata;
892	printf("%s: MII interface PHY %d, setup/reset sequences %d/%d long, capabilities %hhX %hhX.\n",
893	tp->nic_name, bp[0], bp[1], bp[2 + bp[1]*2],
894	bp[5 + bp[2 + bp[1]2]2], bp[4 + bp[2 + bp[1]2]2]);
895	}
896	#endif
897	printf("%s: Index #%d - Media %s (#%d) described "
898	"by a %s (%d) block.\n",
899	tp->nic_name, i, medianame[leaf->media], leaf->media,
900	leaf->type < 6 ? block_name[leaf->type] : "UNKNOWN",
901	leaf->type);
902	}
903	if (new_advertise)
904	tp->sym_advertise = new_advertise;
905	}
906	}
907
908
909
910	/*********************************************************************/
911	/* tulip_init_ring - setup the tx and rx descriptors */
912	/*********************************************************************/
913	static void tulip_init_ring(struct nic *nic __unused)
914	{
915	int i;
916
917	#ifdef TULIP_DEBUG_WHERE
918	whereami("tulip_init_ring\n");
919	#endif
920
921	tp->cur_rx = 0;
922
923	for (i = 0; i < RX_RING_SIZE; i++) {
924	rx_ring[i].status = cpu_to_le32(0x80000000);
925	rx_ring[i].length = cpu_to_le32(BUFLEN);
926	rx_ring[i].buffer1 = virt_to_le32desc(&rxb[i * BUFLEN]);
927	rx_ring[i].buffer2 = virt_to_le32desc(&rx_ring[i+1]);
928	}
929	/* Mark the last entry as wrapping the ring. */
930	rx_ring[i-1].length = cpu_to_le32(DESC_RING_WRAP \| BUFLEN);
931	rx_ring[i-1].buffer2 = virt_to_le32desc(&rx_ring[0]);
932
933	/* We only use 1 transmit buffer, but we use 2 descriptors so
934	transmit engines have somewhere to point to if they feel the need */
935
936	tx_ring[0].status = 0x00000000;
937	tx_ring[0].buffer1 = virt_to_le32desc(&txb[0]);
938	tx_ring[0].buffer2 = virt_to_le32desc(&tx_ring[1]);
939
940	/* this descriptor should never get used, since it will never be owned
941	by the machine (status will always == 0) */
942	tx_ring[1].status = 0x00000000;
943	tx_ring[1].buffer1 = virt_to_le32desc(&txb[0]);
944	tx_ring[1].buffer2 = virt_to_le32desc(&tx_ring[0]);
945
946	/* Mark the last entry as wrapping the ring, though this should never happen */
947	tx_ring[1].length = cpu_to_le32(DESC_RING_WRAP \| BUFLEN);
948	}
949
950
951
952	static void set_rx_mode(struct nic *nic __unused) {
953	int csr6 = inl(ioaddr + CSR6) & ~0x00D5;
954
955	tp->csr6 &= ~0x00D5;
956
957	/* !IFF_PROMISC */
958	tp->csr6 \|= AcceptAllMulticast;
959	csr6 \|= AcceptAllMulticast;
960
961	outl(csr6, ioaddr + CSR6);
962
963
964
965	}
966
967	/*********************************************************************/
968	/* eth_reset - Reset adapter */
969	/*********************************************************************/
970	static void tulip_reset(struct nic *nic)
971	{
972	int i;
973	unsigned long to;
974
975	#ifdef TULIP_DEBUG_WHERE
976	whereami("tulip_reset\n");
977	#endif
978
979	/* Stop Tx and RX */
980	outl(inl(ioaddr + CSR6) & ~0x00002002, ioaddr + CSR6);
981
982	/* On some chip revs we must set the MII/SYM port before the reset!? */
983	if (tp->mii_cnt \|\| (tp->mtable && tp->mtable->has_mii)) {
984	outl(0x814C0000, ioaddr + CSR6);
985	}
986
987	/* Reset the chip, holding bit 0 set at least 50 PCI cycles. */
988	outl(0x00000001, ioaddr + CSR0);
989	tulip_wait(1);
990
991	/* turn off reset and set cache align=16lword, burst=unlimit */
992	outl(tp->csr0, ioaddr + CSR0);
993
994	/* Wait the specified 50 PCI cycles after a reset */
995	tulip_wait(1);
996
997	/* set up transmit and receive descriptors */
998	tulip_init_ring(nic);
999
1000	if (tp->chip_id == PNIC2) {
1001	u32 addr_high = (nic->node_addr[1]<<8) + (nic->node_addr[0]<<0);
1002	/* This address setting does not appear to impact chip operation?? */
1003	outl((nic->node_addr[5]<<8) + nic->node_addr[4] +
1004	(nic->node_addr[3]<<24) + (nic->node_addr[2]<<16),
1005	ioaddr + 0xB0);
1006	outl(addr_high + (addr_high<<16), ioaddr + 0xB8);
1007	}
1008
1009	/* MC_HASH_ONLY boards don't support setup packets */
1010	if (tp->flags & MC_HASH_ONLY) {
1011	u32 addr_low = cpu_to_le32(get_unaligned((u32 *)nic->node_addr));
1012	u32 addr_high = cpu_to_le32(get_unaligned((u16 *)(nic->node_addr+4)));
1013
1014	/* clear multicast hash filters and setup MAC address filters */
1015	if (tp->flags & IS_ASIX) {
1016	outl(0, ioaddr + CSR13);
1017	outl(addr_low, ioaddr + CSR14);
1018	outl(1, ioaddr + CSR13);
1019	outl(addr_high, ioaddr + CSR14);
1020	outl(2, ioaddr + CSR13);
1021	outl(0, ioaddr + CSR14);
1022	outl(3, ioaddr + CSR13);
1023	outl(0, ioaddr + CSR14);
1024	} else if (tp->chip_id == COMET) {
1025	outl(addr_low, ioaddr + 0xA4);
1026	outl(addr_high, ioaddr + 0xA8);
1027	outl(0, ioaddr + 0xAC);
1028	outl(0, ioaddr + 0xB0);
1029	}
1030	} else {
1031	/* for other boards we send a setup packet to initialize
1032	the filters */
1033	u32 tx_flags = 0x08000000 \| 192;
1034
1035	/* construct perfect filter frame with mac address as first match
1036	and broadcast address for all others */
1037	for (i=0; i<192; i++)
1038	txb[i] = 0xFF;
1039	txb[0] = nic->node_addr[0];
1040	txb[1] = nic->node_addr[1];
1041	txb[4] = nic->node_addr[2];
1042	txb[5] = nic->node_addr[3];
1043	txb[8] = nic->node_addr[4];
1044	txb[9] = nic->node_addr[5];
1045
1046	tx_ring[0].length = cpu_to_le32(tx_flags);
1047	tx_ring[0].buffer1 = virt_to_le32desc(&txb[0]);
1048	tx_ring[0].status = cpu_to_le32(0x80000000);
1049	}
1050
1051	/* Point to rx and tx descriptors */
1052	outl(virt_to_le32desc(&rx_ring[0]), ioaddr + CSR3);
1053	outl(virt_to_le32desc(&tx_ring[0]), ioaddr + CSR4);
1054
1055	init_media(nic);
1056
1057	/* set the chip's operating mode (but don't turn on xmit and recv yet) */
1058	outl((tp->csr6 & ~0x00002002), ioaddr + CSR6);
1059
1060	/* send setup packet for cards that support it */
1061	if (!(tp->flags & MC_HASH_ONLY)) {
1062	/* enable transmit wait for completion */
1063	outl(tp->csr6 \| 0x00002000, ioaddr + CSR6);
1064	/* immediate transmit demand */
1065	outl(0, ioaddr + CSR1);
1066
1067	to = currticks() + TX_TIME_OUT;
1068	while ((tx_ring[0].status & 0x80000000) && (currticks() < to))
1069	/* wait */ ;
1070
1071	if (currticks() >= to) {
1072	printf ("%s: TX Setup Timeout.\n", tp->nic_name);
1073	}
1074	}
1075
1076	if (tp->chip_id == LC82C168)
1077	tulip_check_duplex(nic);
1078
1079	set_rx_mode(nic);
1080
1081	/* enable transmit and receive */
1082	outl(tp->csr6 \| 0x00002002, ioaddr + CSR6);
1083	}
1084
1085
1086
1087	/*********************************************************************/
1088	/* eth_transmit - Transmit a frame */
1089	/*********************************************************************/
1090	static void tulip_transmit(struct nic nic, const char d, unsigned int t,
1091	unsigned int s, const char *p)
1092	{
1093	u16 nstype;
1094	u32 to;
1095	u32 csr6 = inl(ioaddr + CSR6);
1096
1097	#ifdef TULIP_DEBUG_WHERE
1098	whereami("tulip_transmit\n");
1099	#endif
1100
1101	/* Disable Tx */
1102	outl(csr6 & ~0x00002000, ioaddr + CSR6);
1103
1104	memcpy(txb, d, ETH_ALEN);
1105	memcpy(txb + ETH_ALEN, nic->node_addr, ETH_ALEN);
1106	nstype = htons((u16) t);
1107	memcpy(txb + 2 * ETH_ALEN, (u8 *)&nstype, 2);
1108	memcpy(txb + ETH_HLEN, p, s);
1109
1110	s += ETH_HLEN;
1111	s &= 0x0FFF;
1112
1113	/* pad to minimum packet size */
1114	while (s < ETH_ZLEN)
1115	txb[s++] = '\0';
1116
1117	#ifdef TULIP_DEBUG
1118	if (tulip_debug > 1)
1119	printf("%s: sending %d bytes ethtype %hX\n", tp->nic_name, s, t);
1120	#endif
1121
1122	/* setup the transmit descriptor */
1123	/* 0x60000000 = no interrupt on completion */
1124	tx_ring[0].length = cpu_to_le32(0x60000000 \| s);
1125	tx_ring[0].status = cpu_to_le32(0x80000000);
1126
1127	/* Point to transmit descriptor */
1128	outl(virt_to_le32desc(&tx_ring[0]), ioaddr + CSR4);
1129
1130	/* Enable Tx */
1131	outl(csr6 \| 0x00002000, ioaddr + CSR6);
1132	/* immediate transmit demand */
1133	outl(0, ioaddr + CSR1);
1134
1135	to = currticks() + TX_TIME_OUT;
1136	while ((tx_ring[0].status & 0x80000000) && (currticks() < to))
1137	/* wait */ ;
1138
1139	if (currticks() >= to) {
1140	printf ("TX Timeout!\n");
1141	}
1142
1143	/* Disable Tx */
1144	outl(csr6 & ~0x00002000, ioaddr + CSR6);
1145	}
1146
1147
1148	/*********************************************************************/
1149	/* eth_poll - Wait for a frame */
1150	/*********************************************************************/
1151	static int tulip_poll(struct nic *nic, int retrieve)
1152	{
1153
1154	#ifdef TULIP_DEBUG_WHERE
1155	whereami("tulip_poll\n");
1156	#endif
1157
1158	/* no packet waiting. packet still owned by NIC */
1159	if (rx_ring[tp->cur_rx].status & 0x80000000)
1160	return 0;
1161
1162	if ( ! retrieve ) return 1;
1163
1164	#ifdef TULIP_DEBUG_WHERE
1165	whereami("tulip_poll got one\n");
1166	#endif
1167
1168	nic->packetlen = (rx_ring[tp->cur_rx].status & 0x3FFF0000) >> 16;
1169
1170	/* if we get a corrupted packet. throw it away and move on */
1171	if (rx_ring[tp->cur_rx].status & 0x00008000) {
1172	/* return the descriptor and buffer to receive ring */
1173	rx_ring[tp->cur_rx].status = 0x80000000;
1174	tp->cur_rx = (++tp->cur_rx) % RX_RING_SIZE;
1175	return 0;
1176	}
1177
1178	/* copy packet to working buffer */
1179	memcpy(nic->packet, rxb + tp->cur_rx * BUFLEN, nic->packetlen);
1180
1181	/* return the descriptor and buffer to receive ring */
1182	rx_ring[tp->cur_rx].status = 0x80000000;
1183	tp->cur_rx = (++tp->cur_rx) % RX_RING_SIZE;
1184
1185	return 1;
1186	}
1187
1188
1189	/*********************************************************************/
1190	/* eth_disable - Disable the interface */
1191	/*********************************************************************/
1192	static void tulip_disable(struct dev *dev)
1193	{
1194	struct nic nic = (struct nic )dev;
1195	#ifdef TULIP_DEBUG_WHERE
1196	whereami("tulip_disable\n");
1197	#endif
1198
1199	/* merge reset and disable */
1200	tulip_reset(nic);
1201
1202	/* disable interrupts */
1203	outl(0x00000000, ioaddr + CSR7);
1204
1205	/* Stop the chip's Tx and Rx processes. */
1206	outl(inl(ioaddr + CSR6) & ~0x00002002, ioaddr + CSR6);
1207
1208	/* Clear the missed-packet counter. */
1209	(volatile unsigned long)inl(ioaddr + CSR8);
1210	}
1211
1212
1213	/*********************************************************************/
1214	/IRQ - Enable, Disable, or Force interrupts /
1215	/*********************************************************************/
1216	static void tulip_irq(struct nic *nic __unused, irq_action_t action __unused)
1217	{
1218	switch ( action ) {
1219	case DISABLE :
1220	break;
1221	case ENABLE :
1222	break;
1223	case FORCE :
1224	break;
1225	}
1226	}
1227
1228
1229	/*********************************************************************/
1230	/* eth_probe - Look for an adapter */
1231	/*********************************************************************/
1232	static int tulip_probe(struct dev dev, struct pci_device pci)
1233	{
1234	struct nic nic = (struct nic )dev;
1235	u32 i;
1236	u8 chip_rev;
1237	u8 ee_data[EEPROM_SIZE];
1238	unsigned short sum;
1239	int chip_idx;
1240	static unsigned char last_phys_addr[ETH_ALEN] = {0x00, 'L', 'i', 'n', 'u', 'x'};
1241
1242	if (pci->ioaddr == 0)
1243	return 0;
1244
1245	ioaddr = pci->ioaddr;
1246	nic->ioaddr = pci->ioaddr & ~3;
1247	nic->irqno = 0;
1248
1249	/* point to private storage */
1250	tp = &tpx;
1251
1252	tp->vendor_id = pci->vendor;
1253	tp->dev_id = pci->dev_id;
1254	tp->nic_name = pci->name;
1255
1256	tp->if_port = 0;
1257	tp->default_port = 0;
1258
1259	adjust_pci_device(pci);
1260
1261	/* disable interrupts */
1262	outl(0x00000000, ioaddr + CSR7);
1263
1264	/* Stop the chip's Tx and Rx processes. */
1265	outl(inl(ioaddr + CSR6) & ~0x00002002, ioaddr + CSR6);
1266
1267	/* Clear the missed-packet counter. */
1268	(volatile unsigned long)inl(ioaddr + CSR8);
1269
1270	printf("\n"); /* so we start on a fresh line */
1271	#ifdef TULIP_DEBUG_WHERE
1272	whereami("tulip_probe\n");
1273	#endif
1274
1275	#ifdef TULIP_DEBUG
1276	if (tulip_debug > 1)
1277	printf ("%s: Looking for Tulip Chip: Vendor=%hX Device=%hX\n", tp->nic_name,
1278	tp->vendor_id, tp->dev_id);
1279	#endif
1280
1281	/* Figure out which chip we're dealing with */
1282	i = 0;
1283	chip_idx = -1;
1284
1285	while (pci_id_tbl[i].name) {
1286	if ( (((u32) tp->dev_id << 16) \| tp->vendor_id) ==
1287	(pci_id_tbl[i].id.pci & pci_id_tbl[i].id.pci_mask) ) {
1288	chip_idx = pci_id_tbl[i].drv_flags;
1289	break;
1290	}
1291	i++;
1292	}
1293
1294	if (chip_idx == -1) {
1295	printf ("%s: Unknown Tulip Chip: Vendor=%hX Device=%hX\n", tp->nic_name,
1296	tp->vendor_id, tp->dev_id);
1297	return 0;
1298	}
1299
1300	tp->pci_id_idx = i;
1301	tp->flags = tulip_tbl[chip_idx].flags;
1302
1303	#ifdef TULIP_DEBUG
1304	if (tulip_debug > 1) {
1305	printf ("%s: tp->pci_id_idx == %d, name == %s\n", tp->nic_name,
1306	tp->pci_id_idx, pci_id_tbl[tp->pci_id_idx].name);
1307	printf ("%s: chip_idx == %d, name == %s\n", tp->nic_name, chip_idx,
1308	tulip_tbl[chip_idx].chip_name);
1309	}
1310	#endif
1311
1312	/* Bring the 21041/21143 out of sleep mode.
1313	Caution: Snooze mode does not work with some boards! */
1314	if (tp->flags & HAS_PWRDWN)
1315	pcibios_write_config_dword(pci->bus, pci->devfn, 0x40, 0x00000000);
1316
1317	if (inl(ioaddr + CSR5) == 0xFFFFFFFF) {
1318	printf("%s: The Tulip chip at %X is not functioning.\n",
1319	tp->nic_name, ioaddr);
1320	return 0;
1321	}
1322
1323	pcibios_read_config_byte(pci->bus, pci->devfn, PCI_REVISION, &chip_rev);
1324
1325	printf("%s: [chip: %s] rev %d at %hX\n", tp->nic_name,
1326	tulip_tbl[chip_idx].chip_name, chip_rev, ioaddr);
1327	printf("%s: Vendor=%hX Device=%hX", tp->nic_name, tp->vendor_id, tp->dev_id);
1328
1329	if (chip_idx == DC21041 && inl(ioaddr + CSR9) & 0x8000) {
1330	printf(" 21040 compatible mode.");
1331	chip_idx = DC21040;
1332	}
1333
1334	printf("\n");
1335
1336	/* The SROM/EEPROM interface varies dramatically. */
1337	sum = 0;
1338	if (chip_idx == DC21040) {
1339	outl(0, ioaddr + CSR9); /* Reset the pointer with a dummy write. */
1340	for (i = 0; i < ETH_ALEN; i++) {
1341	int value, boguscnt = 100000;
1342	do
1343	value = inl(ioaddr + CSR9);
1344	while (value < 0 && --boguscnt > 0);
1345	nic->node_addr[i] = value;
1346	sum += value & 0xff;
1347	}
1348	} else if (chip_idx == LC82C168) {
1349	for (i = 0; i < 3; i++) {
1350	int value, boguscnt = 100000;
1351	outl(0x600 \| i, ioaddr + 0x98);
1352	do
1353	value = inl(ioaddr + CSR9);
1354	while (value < 0 && --boguscnt > 0);
1355	put_unaligned(le16_to_cpu(value), ((u16*)nic->node_addr) + i);
1356	sum += value & 0xffff;
1357	}
1358	} else if (chip_idx == COMET) {
1359	/* No need to read the EEPROM. */
1360	put_unaligned(inl(ioaddr + 0xA4), (u32 *)nic->node_addr);
1361	put_unaligned(inl(ioaddr + 0xA8), (u16 *)(nic->node_addr + 4));
1362	for (i = 0; i < ETH_ALEN; i ++)
1363	sum += nic->node_addr[i];
1364	} else {
1365	/* A serial EEPROM interface, we read now and sort it out later. */
1366	int sa_offset = 0;
1367	int ee_addr_size = read_eeprom(ioaddr, 0xff, 8) & 0x40000 ? 8 : 6;
1368
1369	for (i = 0; i < sizeof(ee_data)/2; i++)
1370	((u16 *)ee_data)[i] =
1371	le16_to_cpu(read_eeprom(ioaddr, i, ee_addr_size));
1372
1373	/* DEC now has a specification (see Notes) but early board makers
1374	just put the address in the first EEPROM locations. */
1375	/* This does memcmp(eedata, eedata+16, 8) */
1376	for (i = 0; i < 8; i ++)
1377	if (ee_data[i] != ee_data[16+i])
1378	sa_offset = 20;
1379	if (ee_data[0] == 0xff && ee_data[1] == 0xff && ee_data[2] == 0) {
1380	sa_offset = 2; /* Grrr, damn Matrox boards. */
1381	}
1382	for (i = 0; i < ETH_ALEN; i ++) {
1383	nic->node_addr[i] = ee_data[i + sa_offset];
1384	sum += ee_data[i + sa_offset];
1385	}
1386	}
1387	/* Lite-On boards have the address byte-swapped. */
1388	if ((nic->node_addr[0] == 0xA0 \|\| nic->node_addr[0] == 0xC0)
1389	&& nic->node_addr[1] == 0x00)
1390	for (i = 0; i < ETH_ALEN; i+=2) {
1391	char tmp = nic->node_addr[i];
1392	nic->node_addr[i] = nic->node_addr[i+1];
1393	nic->node_addr[i+1] = tmp;
1394	}
1395
1396	if (sum == 0 \|\| sum == ETH_ALEN*0xff) {
1397	printf("%s: EEPROM not present!\n", tp->nic_name);
1398	for (i = 0; i < ETH_ALEN-1; i++)
1399	nic->node_addr[i] = last_phys_addr[i];
1400	nic->node_addr[i] = last_phys_addr[i] + 1;
1401	}
1402
1403	for (i = 0; i < ETH_ALEN; i++)
1404	last_phys_addr[i] = nic->node_addr[i];
1405
1406	printf("%s: %! at ioaddr %hX\n", tp->nic_name, nic->node_addr, ioaddr);
1407
1408	tp->chip_id = chip_idx;
1409	tp->revision = chip_rev;
1410	tp->csr0 = csr0;
1411
1412	/* BugFixes: The 21143-TD hangs with PCI Write-and-Invalidate cycles.
1413	And the ASIX must have a burst limit or horrible things happen. */
1414	if (chip_idx == DC21143 && chip_rev == 65)
1415	tp->csr0 &= ~0x01000000;
1416	else if (tp->flags & IS_ASIX)
1417	tp->csr0 \|= 0x2000;
1418
1419	if (media_cap[tp->default_port] & MediaIsMII) {
1420	u16 media2advert[] = { 0x20, 0x40, 0x03e0, 0x60, 0x80, 0x100, 0x200 };
1421	tp->mii_advertise = media2advert[tp->default_port - 9];
1422	tp->mii_advertise \|= (tp->flags & HAS_8023X); /* Matching bits! */
1423	}
1424
1425	/* This is logically part of the probe routine, but too complex
1426	to write inline. */
1427	if (tp->flags & HAS_MEDIA_TABLE) {
1428	memcpy(tp->eeprom, ee_data, sizeof(tp->eeprom));
1429	parse_eeprom(nic);
1430	}
1431
1432	start_link(nic);
1433
1434	/* reset the device and make ready for tx and rx of packets */
1435	tulip_reset(nic);
1436
1437	dev->disable = tulip_disable;
1438	nic->poll = tulip_poll;
1439	nic->transmit = tulip_transmit;
1440	nic->irq = tulip_irq;
1441
1442	/* give the board a chance to reset before returning */
1443	tulip_wait(4*TICKS_PER_SEC);
1444
1445	return 1;
1446	}
1447
1448	static void start_link(struct nic *nic)
1449	{
1450	int i;
1451
1452	#ifdef TULIP_DEBUG_WHERE
1453	whereami("start_link\n");
1454	#endif
1455
1456	if ((tp->flags & ALWAYS_CHECK_MII) \|\|
1457	(tp->mtable && tp->mtable->has_mii) \|\|
1458	( ! tp->mtable && (tp->flags & HAS_MII))) {
1459	unsigned int phy, phy_idx;
1460	if (tp->mtable && tp->mtable->has_mii) {
1461	for (i = 0; i < tp->mtable->leafcount; i++)
1462	if (tp->mtable->mleaf[i].media == 11) {
1463	tp->cur_index = i;
1464	tp->saved_if_port = tp->if_port;
1465	select_media(nic, 2);
1466	tp->if_port = tp->saved_if_port;
1467	break;
1468	}
1469	}
1470
1471	/* Find the connected MII xcvrs. */
1472	for (phy = 0, phy_idx = 0; phy < 32 && phy_idx < sizeof(tp->phys);
1473	phy++) {
1474	int mii_status = mdio_read(nic, phy, 1);
1475	if ((mii_status & 0x8301) == 0x8001 \|\|
1476	((mii_status & 0x8000) == 0 && (mii_status & 0x7800) != 0)) {
1477	int mii_reg0 = mdio_read(nic, phy, 0);
1478	int mii_advert = mdio_read(nic, phy, 4);
1479	int to_advert;
1480
1481	if (tp->mii_advertise)
1482	to_advert = tp->mii_advertise;
1483	else if (tp->advertising[phy_idx])
1484	to_advert = tp->advertising[phy_idx];
1485	else /* Leave unchanged. */
1486	tp->mii_advertise = to_advert = mii_advert;
1487
1488	tp->phys[phy_idx++] = phy;
1489	printf("%s: MII transceiver %d config %hX status %hX advertising %hX.\n",
1490	tp->nic_name, phy, mii_reg0, mii_status, mii_advert);
1491	/* Fixup for DLink with miswired PHY. */
1492	if (mii_advert != to_advert) {
1493	printf("%s: Advertising %hX on PHY %d previously advertising %hX.\n",
1494	tp->nic_name, to_advert, phy, mii_advert);
1495	mdio_write(nic, phy, 4, to_advert);
1496	}
1497	/* Enable autonegotiation: some boards default to off. */
1498	mdio_write(nic, phy, 0, mii_reg0 \|
1499	(tp->full_duplex ? 0x1100 : 0x1000) \|
1500	(media_cap[tp->default_port]&MediaIs100 ? 0x2000:0));
1501	}
1502	}
1503	tp->mii_cnt = phy_idx;
1504	if (tp->mtable && tp->mtable->has_mii && phy_idx == 0) {
1505	printf("%s: *WARNING*: No MII transceiver found!\n",
1506	tp->nic_name);
1507	tp->phys[0] = 1;
1508	}
1509	}
1510
1511	/* Reset the xcvr interface and turn on heartbeat. */
1512	switch (tp->chip_id) {
1513	case DC21040:
1514	outl(0x00000000, ioaddr + CSR13);
1515	outl(0x00000004, ioaddr + CSR13);
1516	break;
1517	case DC21041:
1518	/* This is nway_start(). */
1519	if (tp->sym_advertise == 0)
1520	tp->sym_advertise = 0x0061;
1521	outl(0x00000000, ioaddr + CSR13);
1522	outl(0xFFFFFFFF, ioaddr + CSR14);
1523	outl(0x00000008, ioaddr + CSR15); /* Listen on AUI also. */
1524	outl(inl(ioaddr + CSR6) \| 0x0200, ioaddr + CSR6);
1525	outl(0x0000EF01, ioaddr + CSR13);
1526	break;
1527	case DC21140: default:
1528	if (tp->mtable)
1529	outl(tp->mtable->csr12dir \| 0x100, ioaddr + CSR12);
1530	break;
1531	case DC21142:
1532	case PNIC2:
1533	if (tp->mii_cnt \|\| media_cap[tp->if_port] & MediaIsMII) {
1534	outl(0x82020000, ioaddr + CSR6);
1535	outl(0x0000, ioaddr + CSR13);
1536	outl(0x0000, ioaddr + CSR14);
1537	outl(0x820E0000, ioaddr + CSR6);
1538	} else
1539	nway_start(nic);
1540	break;
1541	case LC82C168:
1542	if ( ! tp->mii_cnt) {
1543	tp->nway = 1;
1544	tp->nwayset = 0;
1545	outl(0x00420000, ioaddr + CSR6);
1546	outl(0x30, ioaddr + CSR12);
1547	outl(0x0001F078, ioaddr + 0xB8);
1548	outl(0x0201F078, ioaddr + 0xB8); /* Turn on autonegotiation. */
1549	}
1550	break;
1551	case MX98713: case COMPEX9881:
1552	outl(0x00000000, ioaddr + CSR6);
1553	outl(0x000711C0, ioaddr + CSR14); /* Turn on NWay. */
1554	outl(0x00000001, ioaddr + CSR13);
1555	break;
1556	case MX98715: case MX98725:
1557	outl(0x01a80000, ioaddr + CSR6);
1558	outl(0xFFFFFFFF, ioaddr + CSR14);
1559	outl(0x00001000, ioaddr + CSR12);
1560	break;
1561	case COMET:
1562	/* No initialization necessary. */
1563	break;
1564	}
1565	}
1566
1567	static void nway_start(struct nic *nic __unused)
1568	{
1569	int csr14 = ((tp->sym_advertise & 0x0780) << 9) \|
1570	((tp->sym_advertise&0x0020)<<1) \| 0xffbf;
1571
1572	#ifdef TULIP_DEBUG_WHERE
1573	whereami("nway_start\n");
1574	#endif
1575
1576	tp->if_port = 0;
1577	tp->nway = tp->mediasense = 1;
1578	tp->nwayset = tp->lpar = 0;
1579	if (tp->chip_id == PNIC2) {
1580	tp->csr6 = 0x01000000 \| (tp->sym_advertise & 0x0040 ? 0x0200 : 0);
1581	return;
1582	}
1583	#ifdef TULIP_DEBUG
1584	if (tulip_debug > 1)
1585	printf("%s: Restarting internal NWay autonegotiation, %X.\n",
1586	tp->nic_name, csr14);
1587	#endif
1588	outl(0x0001, ioaddr + CSR13);
1589	outl(csr14, ioaddr + CSR14);
1590	tp->csr6 = 0x82420000 \| (tp->sym_advertise & 0x0040 ? 0x0200 : 0);
1591	outl(tp->csr6, ioaddr + CSR6);
1592	if (tp->mtable && tp->mtable->csr15dir) {
1593	outl(tp->mtable->csr15dir, ioaddr + CSR15);
1594	outl(tp->mtable->csr15val, ioaddr + CSR15);
1595	} else if (tp->chip_id != PNIC2)
1596	outw(0x0008, ioaddr + CSR15);
1597	if (tp->chip_id == DC21041) /* Trigger NWAY. */
1598	outl(0xEF01, ioaddr + CSR12);
1599	else
1600	outl(0x1301, ioaddr + CSR12);
1601	}
1602
1603	static void init_media(struct nic *nic)
1604	{
1605	int i;
1606
1607	#ifdef TULIP_DEBUG_WHERE
1608	whereami("init_media\n");
1609	#endif
1610
1611	tp->saved_if_port = tp->if_port;
1612	if (tp->if_port == 0)
1613	tp->if_port = tp->default_port;
1614
1615	/* Allow selecting a default media. */
1616	i = 0;
1617	if (tp->mtable == NULL)
1618	goto media_picked;
1619	if (tp->if_port) {
1620	int looking_for = media_cap[tp->if_port] & MediaIsMII ? 11 :
1621	(tp->if_port == 12 ? 0 : tp->if_port);
1622	for (i = 0; i < tp->mtable->leafcount; i++)
1623	if (tp->mtable->mleaf[i].media == looking_for) {
1624	printf("%s: Using user-specified media %s.\n",
1625	tp->nic_name, medianame[tp->if_port]);
1626	goto media_picked;
1627	}
1628	}
1629	if ((tp->mtable->defaultmedia & 0x0800) == 0) {
1630	int looking_for = tp->mtable->defaultmedia & 15;
1631	for (i = 0; i < tp->mtable->leafcount; i++)
1632	if (tp->mtable->mleaf[i].media == looking_for) {
1633	printf("%s: Using EEPROM-set media %s.\n",
1634	tp->nic_name, medianame[looking_for]);
1635	goto media_picked;
1636	}
1637	}
1638	/* Start sensing first non-full-duplex media. */
1639	for (i = tp->mtable->leafcount - 1;
1640	(media_cap[tp->mtable->mleaf[i].media] & MediaAlwaysFD) && i > 0; i--)
1641	;
1642	media_picked:
1643
1644	tp->csr6 = 0;
1645	tp->cur_index = i;
1646	tp->nwayset = 0;
1647
1648	if (tp->if_port) {
1649	if (tp->chip_id == DC21143 && media_cap[tp->if_port] & MediaIsMII) {
1650	/* We must reset the media CSRs when we force-select MII mode. */
1651	outl(0x0000, ioaddr + CSR13);
1652	outl(0x0000, ioaddr + CSR14);
1653	outl(0x0008, ioaddr + CSR15);
1654	}
1655	select_media(nic, 1);
1656	return;
1657	}
1658	switch(tp->chip_id) {
1659	case DC21041:
1660	/* tp->nway = 1;*/
1661	nway_start(nic);
1662	break;
1663	case DC21142:
1664	if (tp->mii_cnt) {
1665	select_media(nic, 1);
1666	#ifdef TULIP_DEBUG
1667	if (tulip_debug > 1)
1668	printf("%s: Using MII transceiver %d, status %hX.\n",
1669	tp->nic_name, tp->phys[0], mdio_read(nic, tp->phys[0], 1));
1670	#endif
1671	outl(0x82020000, ioaddr + CSR6);
1672	tp->csr6 = 0x820E0000;
1673	tp->if_port = 11;
1674	outl(0x0000, ioaddr + CSR13);
1675	outl(0x0000, ioaddr + CSR14);
1676	} else
1677	nway_start(nic);
1678	break;
1679	case PNIC2:
1680	nway_start(nic);
1681	break;
1682	case LC82C168:
1683	if (tp->mii_cnt) {
1684	tp->if_port = 11;
1685	tp->csr6 = 0x814C0000 \| (tp->full_duplex ? 0x0200 : 0);
1686	outl(0x0001, ioaddr + CSR15);
1687	} else if (inl(ioaddr + CSR5) & TPLnkPass)
1688	pnic_do_nway(nic);
1689	else {
1690	/* Start with 10mbps to do autonegotiation. */
1691	outl(0x32, ioaddr + CSR12);
1692	tp->csr6 = 0x00420000;
1693	outl(0x0001B078, ioaddr + 0xB8);
1694	outl(0x0201B078, ioaddr + 0xB8);
1695	}
1696	break;
1697	case MX98713: case COMPEX9881:
1698	tp->if_port = 0;
1699	tp->csr6 = 0x01880000 \| (tp->full_duplex ? 0x0200 : 0);
1700	outl(0x0f370000 \| inw(ioaddr + 0x80), ioaddr + 0x80);
1701	break;
1702	case MX98715: case MX98725:
1703	/* Provided by BOLO, Macronix - 12/10/1998. */
1704	tp->if_port = 0;
1705	tp->csr6 = 0x01a80200;
1706	outl(0x0f370000 \| inw(ioaddr + 0x80), ioaddr + 0x80);
1707	outl(0x11000 \| inw(ioaddr + 0xa0), ioaddr + 0xa0);
1708	break;
1709	case COMET:
1710	/* Enable automatic Tx underrun recovery */
1711	outl(inl(ioaddr + 0x88) \| 1, ioaddr + 0x88);
1712	tp->if_port = 0;
1713	tp->csr6 = 0x00040000;
1714	break;
1715	case AX88140: case AX88141:
1716	tp->csr6 = tp->mii_cnt ? 0x00040100 : 0x00000100;
1717	break;
1718	default:
1719	select_media(nic, 1);
1720	}
1721	}
1722
1723	static void pnic_do_nway(struct nic *nic __unused)
1724	{
1725	u32 phy_reg = inl(ioaddr + 0xB8);
1726	u32 new_csr6 = tp->csr6 & ~0x40C40200;
1727
1728	#ifdef TULIP_DEBUG_WHERE
1729	whereami("pnic_do_nway\n");
1730	#endif
1731
1732	if (phy_reg & 0x78000000) { /* Ignore baseT4 */
1733	if (phy_reg & 0x20000000) tp->if_port = 5;
1734	else if (phy_reg & 0x40000000) tp->if_port = 3;
1735	else if (phy_reg & 0x10000000) tp->if_port = 4;
1736	else if (phy_reg & 0x08000000) tp->if_port = 0;
1737	tp->nwayset = 1;
1738	new_csr6 = (tp->if_port & 1) ? 0x01860000 : 0x00420000;
1739	outl(0x32 \| (tp->if_port & 1), ioaddr + CSR12);
1740	if (tp->if_port & 1)
1741	outl(0x1F868, ioaddr + 0xB8);
1742	if (phy_reg & 0x30000000) {
1743	tp->full_duplex = 1;
1744	new_csr6 \|= 0x00000200;
1745	}
1746	#ifdef TULIP_DEBUG
1747	if (tulip_debug > 1)
1748	printf("%s: PNIC autonegotiated status %X, %s.\n",
1749	tp->nic_name, phy_reg, medianame[tp->if_port]);
1750	#endif
1751	if (tp->csr6 != new_csr6) {
1752	tp->csr6 = new_csr6;
1753	outl(tp->csr6 \| 0x0002, ioaddr + CSR6); /* Restart Tx */
1754	outl(tp->csr6 \| 0x2002, ioaddr + CSR6);
1755	}
1756	}
1757	}
1758
1759	/* Set up the transceiver control registers for the selected media type. */
1760	static void select_media(struct nic *nic, int startup)
1761	{
1762	struct mediatable *mtable = tp->mtable;
1763	u32 new_csr6;
1764	int i;
1765
1766	#ifdef TULIP_DEBUG_WHERE
1767	whereami("select_media\n");
1768	#endif
1769
1770	if (mtable) {
1771	struct medialeaf *mleaf = &mtable->mleaf[tp->cur_index];
1772	unsigned char *p = mleaf->leafdata;
1773	switch (mleaf->type) {
1774	case 0: /* 21140 non-MII xcvr. */
1775	#ifdef TULIP_DEBUG
1776	if (tulip_debug > 1)
1777	printf("%s: Using a 21140 non-MII transceiver"
1778	" with control setting %hhX.\n",
1779	tp->nic_name, p[1]);
1780	#endif
1781	tp->if_port = p[0];
1782	if (startup)
1783	outl(mtable->csr12dir \| 0x100, ioaddr + CSR12);
1784	outl(p[1], ioaddr + CSR12);
1785	new_csr6 = 0x02000000 \| ((p[2] & 0x71) << 18);
1786	break;
1787	case 2: case 4: {
1788	u16 setup[5];
1789	u32 csr13val, csr14val, csr15dir, csr15val;
1790	for (i = 0; i < 5; i++)
1791	setup[i] = get_u16(&p[i*2 + 1]);
1792
1793	tp->if_port = p[0] & 15;
1794	if (media_cap[tp->if_port] & MediaAlwaysFD)
1795	tp->full_duplex = 1;
1796
1797	if (startup && mtable->has_reset) {
1798	struct medialeaf *rleaf = &mtable->mleaf[mtable->has_reset];
1799	unsigned char *rst = rleaf->leafdata;
1800	#ifdef TULIP_DEBUG
1801	if (tulip_debug > 1)
1802	printf("%s: Resetting the transceiver.\n",
1803	tp->nic_name);
1804	#endif
1805	for (i = 0; i < rst[0]; i++)
1806	outl(get_u16(rst + 1 + (i<<1)) << 16, ioaddr + CSR15);
1807	}
1808	#ifdef TULIP_DEBUG
1809	if (tulip_debug > 1)
1810	printf("%s: 21143 non-MII %s transceiver control "
1811	"%hX/%hX.\n",
1812	tp->nic_name, medianame[tp->if_port], setup[0], setup[1]);
1813	#endif
1814	if (p[0] & 0x40) { /* SIA (CSR13-15) setup values are provided. */
1815	csr13val = setup[0];
1816	csr14val = setup[1];
1817	csr15dir = (setup[3]<<16) \| setup[2];
1818	csr15val = (setup[4]<<16) \| setup[2];
1819	outl(0, ioaddr + CSR13);
1820	outl(csr14val, ioaddr + CSR14);
1821	outl(csr15dir, ioaddr + CSR15); /* Direction */
1822	outl(csr15val, ioaddr + CSR15); /* Data */
1823	outl(csr13val, ioaddr + CSR13);
1824	} else {
1825	csr13val = 1;
1826	csr14val = 0x0003FF7F;
1827	csr15dir = (setup[0]<<16) \| 0x0008;
1828	csr15val = (setup[1]<<16) \| 0x0008;
1829	if (tp->if_port <= 4)
1830	csr14val = t21142_csr14[tp->if_port];
1831	if (startup) {
1832	outl(0, ioaddr + CSR13);
1833	outl(csr14val, ioaddr + CSR14);
1834	}
1835	outl(csr15dir, ioaddr + CSR15); /* Direction */
1836	outl(csr15val, ioaddr + CSR15); /* Data */
1837	if (startup) outl(csr13val, ioaddr + CSR13);
1838	}
1839	#ifdef TULIP_DEBUG
1840	if (tulip_debug > 1)
1841	printf("%s: Setting CSR15 to %X/%X.\n",
1842	tp->nic_name, csr15dir, csr15val);
1843	#endif
1844	if (mleaf->type == 4)
1845	new_csr6 = 0x82020000 \| ((setup[2] & 0x71) << 18);
1846	else
1847	new_csr6 = 0x82420000;
1848	break;
1849	}
1850	case 1: case 3: {
1851	int phy_num = p[0];
1852	int init_length = p[1];
1853	u16 *misc_info;
1854
1855	tp->if_port = 11;
1856	new_csr6 = 0x020E0000;
1857	if (mleaf->type == 3) { /* 21142 */
1858	u16 init_sequence = (u16)(p+2);
1859	u16 reset_sequence = &((u16)(p+3))[init_length];
1860	int reset_length = p[2 + init_length*2];
1861	misc_info = reset_sequence + reset_length;
1862	if (startup)
1863	for (i = 0; i < reset_length; i++)
1864	outl(get_u16(&reset_sequence[i]) << 16, ioaddr + CSR15);
1865	for (i = 0; i < init_length; i++)
1866	outl(get_u16(&init_sequence[i]) << 16, ioaddr + CSR15);
1867	} else {
1868	u8 *init_sequence = p + 2;
1869	u8 *reset_sequence = p + 3 + init_length;
1870	int reset_length = p[2 + init_length];
1871	misc_info = (u16*)(reset_sequence + reset_length);
1872	if (startup) {
1873	outl(mtable->csr12dir \| 0x100, ioaddr + CSR12);
1874	for (i = 0; i < reset_length; i++)
1875	outl(reset_sequence[i], ioaddr + CSR12);
1876	}
1877	for (i = 0; i < init_length; i++)
1878	outl(init_sequence[i], ioaddr + CSR12);
1879	}
1880	tp->advertising[phy_num] = get_u16(&misc_info[1]) \| 1;
1881	if (startup < 2) {
1882	if (tp->mii_advertise == 0)
1883	tp->mii_advertise = tp->advertising[phy_num];
1884	#ifdef TULIP_DEBUG
1885	if (tulip_debug > 1)
1886	printf("%s: Advertising %hX on MII %d.\n",
1887	tp->nic_name, tp->mii_advertise, tp->phys[phy_num]);
1888	#endif
1889	mdio_write(nic, tp->phys[phy_num], 4, tp->mii_advertise);
1890	}
1891	break;
1892	}
1893	default:
1894	printf("%s: Invalid media table selection %d.\n",
1895	tp->nic_name, mleaf->type);
1896	new_csr6 = 0x020E0000;
1897	}
1898	#ifdef TULIP_DEBUG
1899	if (tulip_debug > 1)
1900	printf("%s: Using media type %s, CSR12 is %hhX.\n",
1901	tp->nic_name, medianame[tp->if_port],
1902	inl(ioaddr + CSR12) & 0xff);
1903	#endif
1904	} else if (tp->chip_id == DC21041) {
1905	int port = tp->if_port <= 4 ? tp->if_port : 0;
1906	#ifdef TULIP_DEBUG
1907	if (tulip_debug > 1)
1908	printf("%s: 21041 using media %s, CSR12 is %hX.\n",
1909	tp->nic_name, medianame[port == 3 ? 12: port],
1910	inl(ioaddr + CSR12));
1911	#endif
1912	outl(0x00000000, ioaddr + CSR13); /* Reset the serial interface */
1913	outl(t21041_csr14[port], ioaddr + CSR14);
1914	outl(t21041_csr15[port], ioaddr + CSR15);
1915	outl(t21041_csr13[port], ioaddr + CSR13);
1916	new_csr6 = 0x80020000;
1917	} else if (tp->chip_id == LC82C168) {
1918	if (startup && ! tp->medialock)
1919	tp->if_port = tp->mii_cnt ? 11 : 0;
1920	#ifdef TULIP_DEBUG
1921	if (tulip_debug > 1)
1922	printf("%s: PNIC PHY status is %hX, media %s.\n",
1923	tp->nic_name, inl(ioaddr + 0xB8), medianame[tp->if_port]);
1924	#endif
1925	if (tp->mii_cnt) {
1926	new_csr6 = 0x810C0000;
1927	outl(0x0001, ioaddr + CSR15);
1928	outl(0x0201B07A, ioaddr + 0xB8);
1929	} else if (startup) {
1930	/* Start with 10mbps to do autonegotiation. */
1931	outl(0x32, ioaddr + CSR12);
1932	new_csr6 = 0x00420000;
1933	outl(0x0001B078, ioaddr + 0xB8);
1934	outl(0x0201B078, ioaddr + 0xB8);
1935	} else if (tp->if_port == 3 \|\| tp->if_port == 5) {
1936	outl(0x33, ioaddr + CSR12);
1937	new_csr6 = 0x01860000;
1938	/* Trigger autonegotiation. */
1939	outl(startup ? 0x0201F868 : 0x0001F868, ioaddr + 0xB8);
1940	} else {
1941	outl(0x32, ioaddr + CSR12);
1942	new_csr6 = 0x00420000;
1943	outl(0x1F078, ioaddr + 0xB8);
1944	}
1945	} else if (tp->chip_id == DC21040) { /* 21040 */
1946	/* Turn on the xcvr interface. */
1947	#ifdef TULIP_DEBUG
1948	int csr12 = inl(ioaddr + CSR12);
1949	if (tulip_debug > 1)
1950	printf("%s: 21040 media type is %s, CSR12 is %hhX.\n",
1951	tp->nic_name, medianame[tp->if_port], csr12);
1952	#endif
1953	if (media_cap[tp->if_port] & MediaAlwaysFD)
1954	tp->full_duplex = 1;
1955	new_csr6 = 0x20000;
1956	/* Set the full duplux match frame. */
1957	outl(FULL_DUPLEX_MAGIC, ioaddr + CSR11);
1958	outl(0x00000000, ioaddr + CSR13); /* Reset the serial interface */
1959	if (t21040_csr13[tp->if_port] & 8) {
1960	outl(0x0705, ioaddr + CSR14);
1961	outl(0x0006, ioaddr + CSR15);
1962	} else {
1963	outl(0xffff, ioaddr + CSR14);
1964	outl(0x0000, ioaddr + CSR15);
1965	}
1966	outl(0x8f01 \| t21040_csr13[tp->if_port], ioaddr + CSR13);
1967	} else { /* Unknown chip type with no media table. */
1968	if (tp->default_port == 0)
1969	tp->if_port = tp->mii_cnt ? 11 : 3;
1970	if (media_cap[tp->if_port] & MediaIsMII) {
1971	new_csr6 = 0x020E0000;
1972	} else if (media_cap[tp->if_port] & MediaIsFx) {
1973	new_csr6 = 0x028600000;
1974	} else
1975	new_csr6 = 0x038600000;
1976	#ifdef TULIP_DEBUG
1977	if (tulip_debug > 1)
1978	printf("%s: No media description table, assuming "
1979	"%s transceiver, CSR12 %hhX.\n",
1980	tp->nic_name, medianame[tp->if_port],
1981	inl(ioaddr + CSR12));
1982	#endif
1983	}
1984
1985	tp->csr6 = new_csr6 \| (tp->csr6 & 0xfdff) \| (tp->full_duplex ? 0x0200 : 0);
1986	return;
1987	}
1988
1989	/*
1990	Check the MII negotiated duplex and change the CSR6 setting if
1991	required.
1992	Return 0 if everything is OK.
1993	Return < 0 if the transceiver is missing or has no link beat.
1994	*/
1995	static int tulip_check_duplex(struct nic *nic)
1996	{
1997	unsigned int bmsr, lpa, negotiated, new_csr6;
1998
1999	bmsr = mdio_read(nic, tp->phys[0], 1);
2000	lpa = mdio_read(nic, tp->phys[0], 5);
2001
2002	#ifdef TULIP_DEBUG
2003	if (tulip_debug > 1)
2004	printf("%s: MII status %#x, Link partner report "
2005	"%#x.\n", tp->nic_name, bmsr, lpa);
2006	#endif
2007
2008	if (bmsr == 0xffff)
2009	return -2;
2010	if ((bmsr & 4) == 0) {
2011	int new_bmsr = mdio_read(nic, tp->phys[0], 1);
2012	if ((new_bmsr & 4) == 0) {
2013	#ifdef TULIP_DEBUG
2014	if (tulip_debug > 1)
2015	printf("%s: No link beat on the MII interface,"
2016	" status %#x.\n", tp->nic_name,
2017	new_bmsr);
2018	#endif
2019	return -1;
2020	}
2021	}
2022	tp->full_duplex = lpa & 0x140;
2023
2024	new_csr6 = tp->csr6;
2025	negotiated = lpa & tp->advertising[0];
2026
2027	if(negotiated & 0x380) new_csr6 &= ~0x400000;
2028	else new_csr6 \|= 0x400000;
2029	if (tp->full_duplex) new_csr6 \|= 0x200;
2030	else new_csr6 &= ~0x200;
2031
2032	if (new_csr6 != tp->csr6) {
2033	tp->csr6 = new_csr6;
2034
2035	#ifdef TULIP_DEBUG
2036	if (tulip_debug > 0)
2037	printf("%s: Setting %s-duplex based on MII"
2038	"#%d link partner capability of %#x.\n",
2039	tp->nic_name,
2040	tp->full_duplex ? "full" : "half",
2041	tp->phys[0], lpa);
2042	#endif
2043	return 1;
2044	}
2045
2046	return 0;
2047	}
2048
2049	static struct pci_id tulip_nics[] = {
2050	PCI_ROM(0x1011, 0x0002, "dc21040", "Digital Tulip"),
2051	PCI_ROM(0x1011, 0x0009, "ds21140", "Digital Tulip Fast"),
2052	PCI_ROM(0x1011, 0x0014, "dc21041", "Digital Tulip+"),
2053	PCI_ROM(0x1011, 0x0019, "ds21142", "Digital Tulip 21142"),
2054	PCI_ROM(0x10b7, 0x9300, "3csoho100b-tx","3ComSOHO100B-TX"),
2055	PCI_ROM(0x10b9, 0x5261, "ali1563", "ALi 1563 integrated ethernet"),
2056	PCI_ROM(0x10d9, 0x0512, "mx98713", "Macronix MX987x3"),
2057	PCI_ROM(0x10d9, 0x0531, "mx98715", "Macronix MX987x5"),
2058	PCI_ROM(0x1113, 0x1217, "mxic-98715", "Macronix MX987x5"),
2059	PCI_ROM(0x11ad, 0xc115, "lc82c115", "LinkSys LNE100TX"),
2060	PCI_ROM(0x11ad, 0x0002, "82c168", "Netgear FA310TX"),
2061	PCI_ROM(0x1282, 0x9100, "dm9100", "Davicom 9100"),
2062	PCI_ROM(0x1282, 0x9102, "dm9102", "Davicom 9102"),
2063	PCI_ROM(0x1282, 0x9009, "dm9009", "Davicom 9009"),
2064	PCI_ROM(0x1282, 0x9132, "dm9132", "Davicom 9132"),
2065	PCI_ROM(0x1317, 0x0985, "centaur-p", "ADMtek Centaur-P"),
2066	PCI_ROM(0x1317, 0x0981, "an981", "ADMtek AN981 Comet"), /* ADMTek Centaur-P (stmicro) */
2067	PCI_ROM(0x1113, 0x1216, "an983", "ADMTek AN983 Comet"),
2068	PCI_ROM(0x1317, 0x9511, "an983b", "ADMTek Comet 983b"),
2069	PCI_ROM(0x1317, 0x1985, "centaur-c", "ADMTek Centaur-C"),
2070	PCI_ROM(0x8086, 0x0039, "intel21145", "Intel Tulip"),
2071	PCI_ROM(0x125b, 0x1400, "ax88140", "ASIX AX88140"),
2072	PCI_ROM(0x11f6, 0x9881, "rl100tx", "Compex RL100-TX"),
2073	PCI_ROM(0x115d, 0x0003, "xircomtulip", "Xircom Tulip"),
2074	PCI_ROM(0x104a, 0x0981, "tulip-0981", "Tulip 0x104a 0x0981"),
2075	PCI_ROM(0x104a, 0x2774, "SGThomson-STE10100A", "Tulip 0x104a 0x2774"), /Modified by Ramesh Chander/
2076	PCI_ROM(0x1113, 0x9511, "tulip-9511", "Tulip 0x1113 0x9511"),
2077	PCI_ROM(0x1186, 0x1561, "tulip-1561", "Tulip 0x1186 0x1561"),
2078	PCI_ROM(0x1259, 0xa120, "tulip-a120", "Tulip 0x1259 0xa120"),
2079	PCI_ROM(0x13d1, 0xab02, "tulip-ab02", "Tulip 0x13d1 0xab02"),
2080	PCI_ROM(0x13d1, 0xab03, "tulip-ab03", "Tulip 0x13d1 0xab03"),
2081	PCI_ROM(0x13d1, 0xab08, "tulip-ab08", "Tulip 0x13d1 0xab08"),
2082	PCI_ROM(0x14f1, 0x1803, "lanfinity", "Conexant LANfinity"),
2083	PCI_ROM(0x1626, 0x8410, "tulip-8410", "Tulip 0x1626 0x8410"),
2084	PCI_ROM(0x1737, 0xab08, "tulip-1737-ab08","Tulip 0x1737 0xab08"),
2085	PCI_ROM(0x1737, 0xab09, "tulip-ab09", "Tulip 0x1737 0xab09"),
2086	};
2087
2088	static struct pci_driver tulip_driver __pci_driver = {
2089	.type = NIC_DRIVER,
2090	.name = "Tulip",
2091	.probe = tulip_probe,
2092	.ids = tulip_nics,
2093	.id_count = sizeof(tulip_nics)/sizeof(tulip_nics[0]),
2094	.class = 0,
2095	};

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Devices/PC/Etherboot-src/drivers/net/tulip.c@ 1300

Download in other formats: