?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[contrib] Allow Network Protocol header to display in rom-o-matic
[gpxe.git] / src / drivers / net / tulip.c
blobaf30ec646e6219d9f69e51142c04b99286358d05
1 /* -*- Mode:C; c-basic-offset:4; -*- */
2
3 /*
4 Tulip and clone Etherboot Driver
5
6 By Marty Connor (mdc@etherboot.org)
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 FILE_LICENCE ( GPL_ANY );
47
48 /*********************************************************************/
49 /* Revision History */
50 /*********************************************************************/
51
52 /*
53 08 Feb 2005 Ramesh Chander chhabaramesh at yahoo.co.in added table entries
54 for SGThomson STE10/100A
55 07 Sep 2003 timlegge Multicast Support Added
56 11 Apr 2001 mdc [patch to etherboot 4.7.24]
57 Major rewrite to include Linux tulip driver media detection
58 code. This driver should support a lot more cards now.
59 16 Jul 2000 mdc 0.75b11
60 Added support for ADMtek 0985 Centaur-P, a "Comet" tulip clone
61 which is used on the LinkSYS LNE100TX v4.x cards. We already
62 support LNE100TX v2.0 cards, which use a different controller.
63 04 Jul 2000 jam ?
64 Added test of status after receiving a packet from the card.
65 Also uncommented the tulip_disable routine. Stray packets
66 seemed to be causing problems.
67 27 Apr 2000 njl ?
68 29 Feb 2000 mdc 0.75b7
69 Increased reset delay to 3 seconds because Macronix cards seem to
70 need more reset time before card comes back to a usable state.
71 26 Feb 2000 mdc 0.75b6
72 Added a 1 second delay after initializing the transmitter because
73 some cards seem to need the time or they drop the first packet
74 transmitted.
75 23 Feb 2000 mdc 0.75b5
76 removed udelay code and used currticks() for more reliable delay
77 code in reset pause and sanity timeouts. Added function prototypes
78 and TX debugging code.
79 21 Feb 2000 mdc patch to Etherboot 4.4.3
80 Incorporated patches from Bob Edwards and Paul Mackerras of
81 Linuxcare's OZLabs to deal with inefficiencies in tulip_transmit
82 and udelay. We now wait for packet transmission to complete
83 (or sanity timeout).
84 04 Feb 2000 Robert.Edwards@anu.edu.au patch to Etherboot 4.4.2
85 patch to tulip.c that implements the automatic selection of the MII
86 interface on cards using the Intel/DEC 21143 reference design, in
87 particular, the TRENDnet TE100-PCIA NIC which uses a genuine Intel
88 21143-PD chipset.
89 11 Jan 2000 mdc 0.75b4
90 Added support for NetGear FA310TX card based on the LC82C168
91 chip. This should also support Lite-On LC82C168 boards.
92 Added simple MII support. Re-arranged code to better modularize
93 initializations.
94 04 Dec 1999 mdc 0.75b3
95 Added preliminary support for LNE100TX PCI cards. Should work for
96 PNIC2 cards. No MII support, but single interface (RJ45) tulip
97 cards seem to not care.
98 03 Dec 1999 mdc 0.75b2
99 Renamed from mx987x5 to tulip, merged in original tulip init code
100 from tulip.c to support other tulip compatible cards.
101 02 Dec 1999 mdc 0.75b1
102 Released Beta MX987x5 Driver for code review and testing to netboot
103 and thinguin mailing lists.
104 */
105
106 \f
107 /*********************************************************************/
108 /* Declarations */
109 /*********************************************************************/
110
111 #include "etherboot.h"
112 #include "nic.h"
113
114 #include <gpxe/ethernet.h>
115 #include <gpxe/pci.h>
116
117 /* User settable parameters */
118
119 #undef TULIP_DEBUG
120 #undef TULIP_DEBUG_WHERE
121 #ifdef TULIP_DEBUG
122 static int tulip_debug = 2; /* 1 normal messages, 0 quiet .. 7 verbose. */
123 #endif
124
125 #define TX_TIME_OUT 2*TICKS_PER_SEC
126
127 /* helpful macros if on a big_endian machine for changing byte order.
128 not strictly needed on Intel */
129 #define get_unaligned(ptr) (*(ptr))
130 #define put_unaligned(val, ptr) ((void)( *(ptr) = (val) ))
131 #define get_u16(ptr) (*(u16 *)(ptr))
132 #define virt_to_le32desc(addr) virt_to_bus(addr)
133
134 #define TULIP_IOTYPE PCI_USES_MASTER | PCI_USES_IO | PCI_ADDR0
135 #define TULIP_SIZE 0x80
136
137 /* This is a mysterious value that can be written to CSR11 in the 21040 (only)
138 to support a pre-NWay full-duplex signaling mechanism using short frames.
139 No one knows what it should be, but if left at its default value some
140 10base2(!) packets trigger a full-duplex-request interrupt. */
141 #define FULL_DUPLEX_MAGIC 0x6969
142
143 static const int csr0 = 0x01A00000 | 0x8000;
144
145 /* The possible media types that can be set in options[] are: */
146 #define MEDIA_MASK 31
147 static const char * const medianame[32] = {
148 "10baseT", "10base2", "AUI", "100baseTx",
149 "10baseT-FDX", "100baseTx-FDX", "100baseT4", "100baseFx",
150 "100baseFx-FDX", "MII 10baseT", "MII 10baseT-FDX", "MII",
151 "10baseT(forced)", "MII 100baseTx", "MII 100baseTx-FDX", "MII 100baseT4",
152 "MII 100baseFx-HDX", "MII 100baseFx-FDX", "Home-PNA 1Mbps", "Invalid-19",
153 };
154
155 /* This much match tulip_tbl[]! Note 21142 == 21143. */
156 enum tulip_chips {
157 DC21040=0, DC21041=1, DC21140=2, DC21142=3, DC21143=3,
158 LC82C168, MX98713, MX98715, MX98725, AX88141, AX88140, PNIC2, COMET,
159 COMPEX9881, I21145, XIRCOM, SGThomson, /*Ramesh Chander*/
160 };
161
162 enum pci_id_flags_bits {
163 /* Set PCI command register bits before calling probe1(). */
164 PCI_USES_IO=1, PCI_USES_MEM=2, PCI_USES_MASTER=4,
165 /* Read and map the single following PCI BAR. */
166 PCI_ADDR0=0<<4, PCI_ADDR1=1<<4, PCI_ADDR2=2<<4, PCI_ADDR3=3<<4,
167 PCI_ADDR_64BITS=0x100, PCI_NO_ACPI_WAKE=0x200, PCI_NO_MIN_LATENCY=0x400,
168 PCI_UNUSED_IRQ=0x800,
169 };
170
171 struct pci_id_info {
172 char *name;
173 struct match_info {
174 u32 pci, pci_mask, subsystem, subsystem_mask;
175 u32 revision, revision_mask; /* Only 8 bits. */
176 } id;
177 enum pci_id_flags_bits pci_flags;
178 int io_size; /* Needed for I/O region check or ioremap(). */
179 int drv_flags; /* Driver use, intended as capability flags. */
180 };
181
182 static const struct pci_id_info pci_id_tbl[] = {
183 { "Digital DC21040 Tulip", { 0x00021011, 0xffffffff, 0, 0, 0, 0 },
184 TULIP_IOTYPE, 0x80, DC21040 },
185 { "Digital DC21041 Tulip", { 0x00141011, 0xffffffff, 0, 0, 0, 0 },
186 TULIP_IOTYPE, 0x80, DC21041 },
187 { "Digital DS21140A Tulip", { 0x00091011, 0xffffffff, 0,0, 0x20,0xf0 },
188 TULIP_IOTYPE, 0x80, DC21140 },
189 { "Digital DS21140 Tulip", { 0x00091011, 0xffffffff, 0, 0, 0, 0 },
190 TULIP_IOTYPE, 0x80, DC21140 },
191 { "Digital DS21143 Tulip", { 0x00191011, 0xffffffff, 0,0, 65,0xff },
192 TULIP_IOTYPE, TULIP_SIZE, DC21142 },
193 { "Digital DS21142 Tulip", { 0x00191011, 0xffffffff, 0, 0, 0, 0 },
194 TULIP_IOTYPE, TULIP_SIZE, DC21142 },
195 { "Kingston KNE110tx (PNIC)", { 0x000211AD, 0xffffffff, 0xf0022646, 0xffffffff, 0, 0 },
196 TULIP_IOTYPE, 256, LC82C168 },
197 { "Lite-On 82c168 PNIC", { 0x000211AD, 0xffffffff, 0, 0, 0, 0 },
198 TULIP_IOTYPE, 256, LC82C168 },
199 { "Macronix 98713 PMAC", { 0x051210d9, 0xffffffff, 0, 0, 0, 0 },
200 TULIP_IOTYPE, 256, MX98713 },
201 { "Macronix 98715 PMAC", { 0x053110d9, 0xffffffff, 0, 0, 0, 0 },
202 TULIP_IOTYPE, 256, MX98715 },
203 { "Macronix 98725 PMAC", { 0x053110d9, 0xffffffff, 0, 0, 0, 0 },
204 TULIP_IOTYPE, 256, MX98725 },
205 { "ASIX AX88141", { 0x1400125B, 0xffffffff, 0,0, 0x10, 0xf0 },
206 TULIP_IOTYPE, 128, AX88141 },
207 { "ASIX AX88140", { 0x1400125B, 0xffffffff, 0, 0, 0, 0 },
208 TULIP_IOTYPE, 128, AX88140 },
209 { "Lite-On LC82C115 PNIC-II", { 0xc11511AD, 0xffffffff, 0, 0, 0, 0 },
210 TULIP_IOTYPE, 256, PNIC2 },
211 { "ADMtek AN981 Comet", { 0x09811317, 0xffffffff, 0, 0, 0, 0 },
212 TULIP_IOTYPE, 256, COMET },
213 { "ADMTek AN983 Comet", { 0x12161113, 0xffffffff, 0, 0, 0, 0 },
214 TULIP_IOTYPE, 256, COMET },
215 { "ADMTek Comet AN983b", { 0x95111317, 0xffffffff, 0, 0, 0, 0 },
216 TULIP_IOTYPE, 256, COMET },
217 { "ADMtek Centaur-P", { 0x09851317, 0xffffffff, 0, 0, 0, 0 },
218 TULIP_IOTYPE, 256, COMET },
219 { "ADMtek Centaur-C", { 0x19851317, 0xffffffff, 0, 0, 0, 0 },
220 TULIP_IOTYPE, 256, COMET },
221 { "Compex RL100-TX", { 0x988111F6, 0xffffffff, 0, 0, 0, 0 },
222 TULIP_IOTYPE, 128, COMPEX9881 },
223 { "Intel 21145 Tulip", { 0x00398086, 0xffffffff, 0, 0, 0, 0 },
224 TULIP_IOTYPE, 128, I21145 },
225 { "Xircom Tulip clone", { 0x0003115d, 0xffffffff, 0, 0, 0, 0 },
226 TULIP_IOTYPE, 128, XIRCOM },
227 { "Davicom DM9102", { 0x91021282, 0xffffffff, 0, 0, 0, 0 },
228 TULIP_IOTYPE, 0x80, DC21140 },
229 { "Davicom DM9100", { 0x91001282, 0xffffffff, 0, 0, 0, 0 },
230 TULIP_IOTYPE, 0x80, DC21140 },
231 { "Macronix mxic-98715 (EN1217)", { 0x12171113, 0xffffffff, 0, 0, 0, 0 },
232 TULIP_IOTYPE, 256, MX98715 },
233 { "3Com 3cSOHO100B-TX (ADMtek Centuar)", { 0x930010b7, 0xffffffff, 0, 0, 0, 0 },
234 TULIP_IOTYPE, TULIP_SIZE, COMET },
235 { "SG Thomson STE10/100A", { 0x2774104a, 0xffffffff, 0, 0, 0, 0 },
236 TULIP_IOTYPE, 256, COMET }, /*Ramesh Chander*/
237 { 0, { 0, 0, 0, 0, 0, 0 }, 0, 0, 0 },
238 };
239
240 enum tbl_flag {
241 HAS_MII=1, HAS_MEDIA_TABLE=2, CSR12_IN_SROM=4, ALWAYS_CHECK_MII=8,
242 HAS_PWRDWN=0x10, MC_HASH_ONLY=0x20, /* Hash-only multicast filter. */
243 HAS_PNICNWAY=0x80, HAS_NWAY=0x40, /* Uses internal NWay xcvr. */
244 HAS_INTR_MITIGATION=0x100, IS_ASIX=0x200, HAS_8023X=0x400,
245 };
246
247 /* Note: this table must match enum tulip_chips above. */
248 static struct tulip_chip_table {
249 char *chip_name;
250 int flags;
251 } tulip_tbl[] = {
252 { "Digital DC21040 Tulip", 0},
253 { "Digital DC21041 Tulip", HAS_MEDIA_TABLE | HAS_NWAY },
254 { "Digital DS21140 Tulip", HAS_MII | HAS_MEDIA_TABLE | CSR12_IN_SROM },
255 { "Digital DS21143 Tulip", HAS_MII | HAS_MEDIA_TABLE | ALWAYS_CHECK_MII
256 | HAS_PWRDWN | HAS_NWAY | HAS_INTR_MITIGATION },
257 { "Lite-On 82c168 PNIC", HAS_MII | HAS_PNICNWAY },
258 { "Macronix 98713 PMAC", HAS_MII | HAS_MEDIA_TABLE | CSR12_IN_SROM },
259 { "Macronix 98715 PMAC", HAS_MEDIA_TABLE },
260 { "Macronix 98725 PMAC", HAS_MEDIA_TABLE },
261 { "ASIX AX88140", HAS_MII | HAS_MEDIA_TABLE | CSR12_IN_SROM
262 | MC_HASH_ONLY | IS_ASIX },
263 { "ASIX AX88141", HAS_MII | HAS_MEDIA_TABLE | CSR12_IN_SROM | MC_HASH_ONLY
264 | IS_ASIX },
265 { "Lite-On PNIC-II", HAS_MII | HAS_NWAY | HAS_8023X },
266 { "ADMtek Comet", HAS_MII | MC_HASH_ONLY },
267 { "Compex 9881 PMAC", HAS_MII | HAS_MEDIA_TABLE | CSR12_IN_SROM },
268 { "Intel DS21145 Tulip", HAS_MII | HAS_MEDIA_TABLE | ALWAYS_CHECK_MII
269 | HAS_PWRDWN | HAS_NWAY },
270 { "Xircom tulip work-alike", HAS_MII | HAS_MEDIA_TABLE | ALWAYS_CHECK_MII
271 | HAS_PWRDWN | HAS_NWAY },
272 { "SGThomson STE10/100A", HAS_MII | MC_HASH_ONLY }, /*Ramesh Chander*/
273 { 0, 0 },
274 };
275
276 /* A full-duplex map for media types. */
277 enum MediaIs {
278 MediaIsFD = 1, MediaAlwaysFD=2, MediaIsMII=4, MediaIsFx=8,
279 MediaIs100=16};
280
281 static const char media_cap[32] =
282 {0,0,0,16, 3,19,16,24, 27,4,7,5, 0,20,23,20, 20,31,0,0, };
283 static u8 t21040_csr13[] = {2,0x0C,8,4, 4,0,0,0, 0,0,0,0, 4,0,0,0};
284
285 /* 21041 transceiver register settings: 10-T, 10-2, AUI, 10-T, 10T-FD */
286 static u16 t21041_csr13[] = { 0xEF01, 0xEF09, 0xEF09, 0xEF01, 0xEF09, };
287 static u16 t21041_csr14[] = { 0xFFFF, 0xF7FD, 0xF7FD, 0x7F3F, 0x7F3D, };
288 static u16 t21041_csr15[] = { 0x0008, 0x0006, 0x000E, 0x0008, 0x0008, };
289
290 /* not used
291 static u16 t21142_csr13[] = { 0x0001, 0x0009, 0x0009, 0x0000, 0x0001, };
292 */
293 static u16 t21142_csr14[] = { 0xFFFF, 0x0705, 0x0705, 0x0000, 0x7F3D, };
294 /* not used
295 static u16 t21142_csr15[] = { 0x0008, 0x0006, 0x000E, 0x0008, 0x0008, };
296 */
297
298 /* Offsets to the Command and Status Registers, "CSRs". All accesses
299 must be longword instructions and quadword aligned. */
300 enum tulip_offsets {
301 CSR0=0, CSR1=0x08, CSR2=0x10, CSR3=0x18, CSR4=0x20, CSR5=0x28,
302 CSR6=0x30, CSR7=0x38, CSR8=0x40, CSR9=0x48, CSR10=0x50, CSR11=0x58,
303 CSR12=0x60, CSR13=0x68, CSR14=0x70, CSR15=0x78, CSR16=0x80, CSR20=0xA0
304 };
305
306 /* The bits in the CSR5 status registers, mostly interrupt sources. */
307 enum status_bits {
308 TimerInt=0x800, TPLnkFail=0x1000, TPLnkPass=0x10,
309 NormalIntr=0x10000, AbnormalIntr=0x8000,
310 RxJabber=0x200, RxDied=0x100, RxNoBuf=0x80, RxIntr=0x40,
311 TxFIFOUnderflow=0x20, TxJabber=0x08, TxNoBuf=0x04, TxDied=0x02, TxIntr=0x01,
312 };
313
314 /* The configuration bits in CSR6. */
315 enum csr6_mode_bits {
316 TxOn=0x2000, RxOn=0x0002, FullDuplex=0x0200,
317 AcceptBroadcast=0x0100, AcceptAllMulticast=0x0080,
318 AcceptAllPhys=0x0040, AcceptRunt=0x0008,
319 };
320
321
322 enum desc_status_bits {
323 DescOwnded=0x80000000, RxDescFatalErr=0x8000, RxWholePkt=0x0300,
324 };
325
326 struct medialeaf {
327 u8 type;
328 u8 media;
329 unsigned char *leafdata;
330 };
331
332 struct mediatable {
333 u16 defaultmedia;
334 u8 leafcount, csr12dir; /* General purpose pin directions. */
335 unsigned has_mii:1, has_nonmii:1, has_reset:6;
336 u32 csr15dir, csr15val; /* 21143 NWay setting. */
337 struct medialeaf mleaf[0];
338 };
339
340 struct mediainfo {
341 struct mediainfo *next;
342 int info_type;
343 int index;
344 unsigned char *info;
345 };
346
347 /* EEPROM Address width definitions */
348 #define EEPROM_ADDRLEN 6
349 #define EEPROM_SIZE 128 /* 2 << EEPROM_ADDRLEN */
350
351 /* The EEPROM commands include the alway-set leading bit. */
352 #define EE_WRITE_CMD (5 << addr_len)
353 #define EE_READ_CMD (6 << addr_len)
354 #define EE_ERASE_CMD (7 << addr_len)
355
356 /* EEPROM_Ctrl bits. */
357 #define EE_SHIFT_CLK 0x02 /* EEPROM shift clock. */
358 #define EE_CS 0x01 /* EEPROM chip select. */
359 #define EE_DATA_WRITE 0x04 /* EEPROM chip data in. */
360 #define EE_WRITE_0 0x01
361 #define EE_WRITE_1 0x05
362 #define EE_DATA_READ 0x08 /* EEPROM chip data out. */
363 #define EE_ENB (0x4800 | EE_CS)
364
365 /* Delay between EEPROM clock transitions. Even at 33Mhz current PCI
366 implementations don't overrun the EEPROM clock. We add a bus
367 turn-around to insure that this remains true. */
368 #define eeprom_delay() inl(ee_addr)
369
370 /* Size of transmit and receive buffers */
371 #define BUFLEN 1536
372
373 /* Ring-wrap flag in length field, use for last ring entry.
374 0x01000000 means chain on buffer2 address,
375 0x02000000 means use the ring start address in CSR2/3.
376 Note: Some work-alike chips do not function correctly in chained mode.
377 The ASIX chip works only in chained mode.
378 Thus we indicate ring mode, but always write the 'next' field for
379 chained mode as well. */
380 #define DESC_RING_WRAP 0x02000000
381
382 /* transmit and receive descriptor format */
383 struct tulip_rx_desc {
384 volatile u32 status;
385 u32 length;
386 u32 buffer1, buffer2;
387 };
388
389 struct tulip_tx_desc {
390 volatile u32 status;
391 u32 length;
392 u32 buffer1, buffer2;
393 };
394
395 /*********************************************************************/
396 /* Global Storage */
397 /*********************************************************************/
398
399 static u32 ioaddr;
400
401 struct tulip_private {
402 int cur_rx;
403 int chip_id; /* index into tulip_tbl[] */
404 int pci_id_idx; /* index into pci_id_tbl[] */
405 int revision;
406 int flags;
407 unsigned short vendor_id; /* PCI card vendor code */
408 unsigned short dev_id; /* PCI card device code */
409 unsigned char ehdr[ETH_HLEN]; /* buffer for ethernet header */
410 const char *nic_name;
411 unsigned int csr0, csr6; /* Current CSR0, CSR6 settings. */
412 unsigned int if_port;
413 unsigned int full_duplex; /* Full-duplex operation requested. */
414 unsigned int full_duplex_lock;
415 unsigned int medialock; /* Do not sense media type. */
416 unsigned int mediasense; /* Media sensing in progress. */
417 unsigned int nway, nwayset; /* 21143 internal NWay. */
418 unsigned int default_port;
419 unsigned char eeprom[EEPROM_SIZE]; /* Serial EEPROM contents. */
420 u8 media_table_storage[(sizeof(struct mediatable) + 32*sizeof(struct medialeaf))];
421 u16 sym_advertise, mii_advertise; /* NWay to-advertise. */
422 struct mediatable *mtable;
423 u16 lpar; /* 21143 Link partner ability. */
424 u16 advertising[4]; /* MII advertise, from SROM table. */
425 signed char phys[4], mii_cnt; /* MII device addresses. */
426 int cur_index; /* Current media index. */
427 int saved_if_port;
428 };
429
430 /* Note: transmit and receive buffers must be longword aligned and
431 longword divisable */
432
433 #define TX_RING_SIZE 2
434 #define RX_RING_SIZE 4
435 struct {
436 struct tulip_tx_desc tx_ring[TX_RING_SIZE];
437 unsigned char txb[BUFLEN];
438 struct tulip_rx_desc rx_ring[RX_RING_SIZE];
439 unsigned char rxb[RX_RING_SIZE * BUFLEN];
440 struct tulip_private tpx;
441 } tulip_bss __shared __attribute__ ((aligned(4)));
442 #define tx_ring tulip_bss.tx_ring
443 #define txb tulip_bss.txb
444 #define rx_ring tulip_bss.rx_ring
445 #define rxb tulip_bss.rxb
446
447 static struct tulip_private *tp;
448
449 /* Known cards that have old-style EEPROMs.
450 Writing this table is described at
451 http://cesdis.gsfc.nasa.gov/linux/drivers/tulip-drivers/tulip-media.html */
452 static struct fixups {
453 char *name;
454 unsigned char addr0, addr1, addr2;
455 u16 newtable[32]; /* Max length below. */
456 } eeprom_fixups[] = {
457 {"Asante", 0, 0, 0x94, {0x1e00, 0x0000, 0x0800, 0x0100, 0x018c,
458 0x0000, 0x0000, 0xe078, 0x0001, 0x0050, 0x0018 }},
459 {"SMC9332DST", 0, 0, 0xC0, { 0x1e00, 0x0000, 0x0800, 0x041f,
460 0x0000, 0x009E, /* 10baseT */
461 0x0004, 0x009E, /* 10baseT-FD */
462 0x0903, 0x006D, /* 100baseTx */
463 0x0905, 0x006D, /* 100baseTx-FD */ }},
464 {"Cogent EM100", 0, 0, 0x92, { 0x1e00, 0x0000, 0x0800, 0x063f,
465 0x0107, 0x8021, /* 100baseFx */
466 0x0108, 0x8021, /* 100baseFx-FD */
467 0x0100, 0x009E, /* 10baseT */
468 0x0104, 0x009E, /* 10baseT-FD */
469 0x0103, 0x006D, /* 100baseTx */
470 0x0105, 0x006D, /* 100baseTx-FD */ }},
471 {"Maxtech NX-110", 0, 0, 0xE8, { 0x1e00, 0x0000, 0x0800, 0x0513,
472 0x1001, 0x009E, /* 10base2, CSR12 0x10*/
473 0x0000, 0x009E, /* 10baseT */
474 0x0004, 0x009E, /* 10baseT-FD */
475 0x0303, 0x006D, /* 100baseTx, CSR12 0x03 */
476 0x0305, 0x006D, /* 100baseTx-FD CSR12 0x03 */}},
477 {"Accton EN1207", 0, 0, 0xE8, { 0x1e00, 0x0000, 0x0800, 0x051F,
478 0x1B01, 0x0000, /* 10base2, CSR12 0x1B */
479 0x0B00, 0x009E, /* 10baseT, CSR12 0x0B */
480 0x0B04, 0x009E, /* 10baseT-FD,CSR12 0x0B */
481 0x1B03, 0x006D, /* 100baseTx, CSR12 0x1B */
482 0x1B05, 0x006D, /* 100baseTx-FD CSR12 0x1B */
483 }},
484 {0, 0, 0, 0, {}}};
485
486 static const char * block_name[] = {"21140 non-MII", "21140 MII PHY",
487 "21142 Serial PHY", "21142 MII PHY", "21143 SYM PHY", "21143 reset method"};
488
489 \f
490 /*********************************************************************/
491 /* Function Prototypes */
492 /*********************************************************************/
493 static int mdio_read(struct nic *nic, int phy_id, int location);
494 static void mdio_write(struct nic *nic, int phy_id, int location, int value);
495 static int read_eeprom(unsigned long ioaddr, int location, int addr_len);
496 static void parse_eeprom(struct nic *nic);
497 static int tulip_probe(struct nic *nic,struct pci_device *pci);
498 static void tulip_init_ring(struct nic *nic);
499 static void tulip_reset(struct nic *nic);
500 static void tulip_transmit(struct nic *nic, const char *d, unsigned int t,
501 unsigned int s, const char *p);
502 static int tulip_poll(struct nic *nic, int retrieve);
503 static void tulip_disable(struct nic *nic);
504 static void nway_start(struct nic *nic);
505 static void pnic_do_nway(struct nic *nic);
506 static void select_media(struct nic *nic, int startup);
507 static void init_media(struct nic *nic);
508 static void start_link(struct nic *nic);
509 static int tulip_check_duplex(struct nic *nic);
510
511 static void tulip_wait(unsigned int nticks);
512
513 #ifdef TULIP_DEBUG_WHERE
514 static void whereami(const char *str);
515 #endif
516
517 #ifdef TULIP_DEBUG
518 static void tulip_more(void);
519 #endif
520
521 \f
522 /*********************************************************************/
523 /* Utility Routines */
524 /*********************************************************************/
525
526 #ifdef TULIP_DEBUG_WHERE
527 static void whereami (const char *str, struct pci_device *pci)
528 {
529 printf("%s: %s\n", tp->nic_name, str);
530 /* sleep(2); */
531 }
532 #endif
533
534 #ifdef TULIP_DEBUG
535 static void tulip_more(void)
536 {
537 printf("\n\n-- more --");
538 while (!iskey())
539 /* wait */;
540 getchar();
541 printf("\n\n");
542 }
543 #endif /* TULIP_DEBUG */
544
545 static void tulip_wait(unsigned int nticks)
546 {
547 unsigned int to = currticks() + nticks;
548 while (currticks() < to)
549 /* wait */ ;
550 }
551
552 \f
553 /*********************************************************************/
554 /* Media Descriptor Code */
555 /*********************************************************************/
556
557 /* MII transceiver control section.
558 Read and write the MII registers using software-generated serial
559 MDIO protocol. See the MII specifications or DP83840A data sheet
560 for details. */
561
562 /* The maximum data clock rate is 2.5 Mhz. The minimum timing is usually
563 met by back-to-back PCI I/O cycles, but we insert a delay to avoid
564 "overclocking" issues or future 66Mhz PCI. */
565 #define mdio_delay() inl(mdio_addr)
566
567 /* Read and write the MII registers using software-generated serial
568 MDIO protocol. It is just different enough from the EEPROM protocol
569 to not share code. The maxium data clock rate is 2.5 Mhz. */
570 #define MDIO_SHIFT_CLK 0x10000
571 #define MDIO_DATA_WRITE0 0x00000
572 #define MDIO_DATA_WRITE1 0x20000
573 #define MDIO_ENB 0x00000 /* Ignore the 0x02000 databook setting. */
574 #define MDIO_ENB_IN 0x40000
575 #define MDIO_DATA_READ 0x80000
576
577 /* MII transceiver control section.
578 Read and write the MII registers using software-generated serial
579 MDIO protocol. See the MII specifications or DP83840A data sheet
580 for details. */
581
582 int mdio_read(struct nic *nic __unused, int phy_id, int location)
583 {
584 int i;
585 int read_cmd = (0xf6 << 10) | (phy_id << 5) | location;
586 int retval = 0;
587 long mdio_addr = ioaddr + CSR9;
588
589 #ifdef TULIP_DEBUG_WHERE
590 whereami("mdio_read\n");
591 #endif
592
593 if (tp->chip_id == LC82C168) {
594 int i = 1000;
595 outl(0x60020000 + (phy_id<<23) + (location<<18), ioaddr + 0xA0);
596 inl(ioaddr + 0xA0);
597 inl(ioaddr + 0xA0);
598 while (--i > 0)
599 if ( ! ((retval = inl(ioaddr + 0xA0)) & 0x80000000))
600 return retval & 0xffff;
601 return 0xffff;
602 }
603
604 if (tp->chip_id == COMET) {
605 if (phy_id == 1) {
606 if (location < 7)
607 return inl(ioaddr + 0xB4 + (location<<2));
608 else if (location == 17)
609 return inl(ioaddr + 0xD0);
610 else if (location >= 29 && location <= 31)
611 return inl(ioaddr + 0xD4 + ((location-29)<<2));
612 }
613 return 0xffff;
614 }
615
616 /* Establish sync by sending at least 32 logic ones. */
617 for (i = 32; i >= 0; i--) {
618 outl(MDIO_ENB | MDIO_DATA_WRITE1, mdio_addr);
619 mdio_delay();
620 outl(MDIO_ENB | MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, mdio_addr);
621 mdio_delay();
622 }
623 /* Shift the read command bits out. */
624 for (i = 15; i >= 0; i--) {
625 int dataval = (read_cmd & (1 << i)) ? MDIO_DATA_WRITE1 : 0;
626
627 outl(MDIO_ENB | dataval, mdio_addr);
628 mdio_delay();
629 outl(MDIO_ENB | dataval | MDIO_SHIFT_CLK, mdio_addr);
630 mdio_delay();
631 }
632 /* Read the two transition, 16 data, and wire-idle bits. */
633 for (i = 19; i > 0; i--) {
634 outl(MDIO_ENB_IN, mdio_addr);
635 mdio_delay();
636 retval = (retval << 1) | ((inl(mdio_addr) & MDIO_DATA_READ) ? 1 : 0);
637 outl(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
638 mdio_delay();
639 }
640 return (retval>>1) & 0xffff;
641 }
642
643 void mdio_write(struct nic *nic __unused, int phy_id, int location, int value)
644 {
645 int i;
646 int cmd = (0x5002 << 16) | (phy_id << 23) | (location<<18) | value;
647 long mdio_addr = ioaddr + CSR9;
648
649 #ifdef TULIP_DEBUG_WHERE
650 whereami("mdio_write\n");
651 #endif
652
653 if (tp->chip_id == LC82C168) {
654 int i = 1000;
655 outl(cmd, ioaddr + 0xA0);
656 do
657 if ( ! (inl(ioaddr + 0xA0) & 0x80000000))
658 break;
659 while (--i > 0);
660 return;
661 }
662
663 if (tp->chip_id == COMET) {
664 if (phy_id != 1)
665 return;
666 if (location < 7)
667 outl(value, ioaddr + 0xB4 + (location<<2));
668 else if (location == 17)
669 outl(value, ioaddr + 0xD0);
670 else if (location >= 29 && location <= 31)
671 outl(value, ioaddr + 0xD4 + ((location-29)<<2));
672 return;
673 }
674
675 /* Establish sync by sending 32 logic ones. */
676 for (i = 32; i >= 0; i--) {
677 outl(MDIO_ENB | MDIO_DATA_WRITE1, mdio_addr);
678 mdio_delay();
679 outl(MDIO_ENB | MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, mdio_addr);
680 mdio_delay();
681 }
682 /* Shift the command bits out. */
683 for (i = 31; i >= 0; i--) {
684 int dataval = (cmd & (1 << i)) ? MDIO_DATA_WRITE1 : 0;
685 outl(MDIO_ENB | dataval, mdio_addr);
686 mdio_delay();
687 outl(MDIO_ENB | dataval | MDIO_SHIFT_CLK, mdio_addr);
688 mdio_delay();
689 }
690 /* Clear out extra bits. */
691 for (i = 2; i > 0; i--) {
692 outl(MDIO_ENB_IN, mdio_addr);
693 mdio_delay();
694 outl(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
695 mdio_delay();
696 }
697 }
698
699 \f
700 /*********************************************************************/
701 /* EEPROM Reading Code */
702 /*********************************************************************/
703 /* EEPROM routines adapted from the Linux Tulip Code */
704 /* Reading a serial EEPROM is a "bit" grungy, but we work our way
705 through:->.
706 */
707 static int read_eeprom(unsigned long ioaddr, int location, int addr_len)
708 {
709 int i;
710 unsigned short retval = 0;
711 long ee_addr = ioaddr + CSR9;
712 int read_cmd = location | EE_READ_CMD;
713
714 #ifdef TULIP_DEBUG_WHERE
715 whereami("read_eeprom\n");
716 #endif
717
718 outl(EE_ENB & ~EE_CS, ee_addr);
719 outl(EE_ENB, ee_addr);
720
721 /* Shift the read command bits out. */
722 for (i = 4 + addr_len; i >= 0; i--) {
723 short dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
724 outl(EE_ENB | dataval, ee_addr);
725 eeprom_delay();
726 outl(EE_ENB | dataval | EE_SHIFT_CLK, ee_addr);
727 eeprom_delay();
728 }
729 outl(EE_ENB, ee_addr);
730
731 for (i = 16; i > 0; i--) {
732 outl(EE_ENB | EE_SHIFT_CLK, ee_addr);
733 eeprom_delay();
734 retval = (retval << 1) | ((inl(ee_addr) & EE_DATA_READ) ? 1 : 0);
735 outl(EE_ENB, ee_addr);
736 eeprom_delay();
737 }
738
739 /* Terminate the EEPROM access. */
740 outl(EE_ENB & ~EE_CS, ee_addr);
741 return retval;
742 }
743
744 \f
745 /*********************************************************************/
746 /* EEPROM Parsing Code */
747 /*********************************************************************/
748 static void parse_eeprom(struct nic *nic)
749 {
750 unsigned char *p, *ee_data = tp->eeprom;
751 int new_advertise = 0;
752 int i;
753
754 #ifdef TULIP_DEBUG_WHERE
755 whereami("parse_eeprom\n");
756 #endif
757
758 tp->mtable = 0;
759 /* Detect an old-style (SA only) EEPROM layout:
760 memcmp(ee_data, ee_data+16, 8). */
761 for (i = 0; i < 8; i ++)
762 if (ee_data[i] != ee_data[16+i])
763 break;
764 if (i >= 8) {
765 /* Do a fix-up based on the vendor half of the station address. */
766 for (i = 0; eeprom_fixups[i].name; i++) {
767 if (nic->node_addr[0] == eeprom_fixups[i].addr0
768 && nic->node_addr[1] == eeprom_fixups[i].addr1
769 && nic->node_addr[2] == eeprom_fixups[i].addr2) {
770 if (nic->node_addr[2] == 0xE8 && ee_data[0x1a] == 0x55)
771 i++; /* An Accton EN1207, not an outlaw Maxtech. */
772 memcpy(ee_data + 26, eeprom_fixups[i].newtable,
773 sizeof(eeprom_fixups[i].newtable));
774 #ifdef TULIP_DEBUG
775 printf("%s: Old format EEPROM on '%s' board.\n%s: Using substitute media control info.\n",
776 tp->nic_name, eeprom_fixups[i].name, tp->nic_name);
777 #endif
778 break;
779 }
780 }
781 if (eeprom_fixups[i].name == NULL) { /* No fixup found. */
782 #ifdef TULIP_DEBUG
783 printf("%s: Old style EEPROM with no media selection information.\n",
784 tp->nic_name);
785 #endif
786 return;
787 }
788 }
789
790 if (ee_data[19] > 1) {
791 #ifdef TULIP_DEBUG
792 printf("%s: Multiport cards (%d ports) may not work correctly.\n",
793 tp->nic_name, ee_data[19]);
794 #endif
795 }
796
797 p = (void *)ee_data + ee_data[27];
798
799 if (ee_data[27] == 0) { /* No valid media table. */
800 #ifdef TULIP_DEBUG
801 if (tulip_debug > 1) {
802 printf("%s: No Valid Media Table. ee_data[27] = %hhX\n",
803 tp->nic_name, ee_data[27]);
804 }
805 #endif
806 } else if (tp->chip_id == DC21041) {
807 int media = get_u16(p);
808 int count = p[2];
809 p += 3;
810
811 printf("%s: 21041 Media table, default media %hX (%s).\n",
812 tp->nic_name, media,
813 media & 0x0800 ? "Autosense" : medianame[media & 15]);
814 for (i = 0; i < count; i++) {
815 unsigned char media_block = *p++;
816 int media_code = media_block & MEDIA_MASK;
817 if (media_block & 0x40)
818 p += 6;
819 switch(media_code) {
820 case 0: new_advertise |= 0x0020; break;
821 case 4: new_advertise |= 0x0040; break;
822 }
823 printf("%s: 21041 media #%d, %s.\n",
824 tp->nic_name, media_code, medianame[media_code]);
825 }
826 } else {
827 unsigned char csr12dir = 0;
828 int count;
829 struct mediatable *mtable;
830 u16 media = get_u16(p);
831
832 p += 2;
833 if (tp->flags & CSR12_IN_SROM)
834 csr12dir = *p++;
835 count = *p++;
836
837 tp->mtable = mtable = (struct mediatable *)&tp->media_table_storage[0];
838
839 mtable->defaultmedia = media;
840 mtable->leafcount = count;
841 mtable->csr12dir = csr12dir;
842 mtable->has_nonmii = mtable->has_mii = mtable->has_reset = 0;
843 mtable->csr15dir = mtable->csr15val = 0;
844
845 printf("%s: EEPROM default media type %s.\n", tp->nic_name,
846 media & 0x0800 ? "Autosense" : medianame[media & MEDIA_MASK]);
847
848 for (i = 0; i < count; i++) {
849 struct medialeaf *leaf = &mtable->mleaf[i];
850
851 if ((p[0] & 0x80) == 0) { /* 21140 Compact block. */
852 leaf->type = 0;
853 leaf->media = p[0] & 0x3f;
854 leaf->leafdata = p;
855 if ((p[2] & 0x61) == 0x01) /* Bogus, but Znyx boards do it. */
856 mtable->has_mii = 1;
857 p += 4;
858 } else {
859 switch(leaf->type = p[1]) {
860 case 5:
861 mtable->has_reset = i;
862 leaf->media = p[2] & 0x0f;
863 break;
864 case 1: case 3:
865 mtable->has_mii = 1;
866 leaf->media = 11;
867 break;
868 case 2:
869 if ((p[2] & 0x3f) == 0) {
870 u32 base15 = (p[2] & 0x40) ? get_u16(p + 7) : 0x0008;
871 u16 *p1 = (u16 *)(p + (p[2] & 0x40 ? 9 : 3));
872 mtable->csr15dir = (get_unaligned(p1 + 0)<<16) + base15;
873 mtable->csr15val = (get_unaligned(p1 + 1)<<16) + base15;
874 }
875 /* Fall through. */
876 case 0: case 4:
877 mtable->has_nonmii = 1;
878 leaf->media = p[2] & MEDIA_MASK;
879 switch (leaf->media) {
880 case 0: new_advertise |= 0x0020; break;
881 case 4: new_advertise |= 0x0040; break;
882 case 3: new_advertise |= 0x0080; break;
883 case 5: new_advertise |= 0x0100; break;
884 case 6: new_advertise |= 0x0200; break;
885 }
886 break;
887 default:
888 leaf->media = 19;
889 }
890 leaf->leafdata = p + 2;
891 p += (p[0] & 0x3f) + 1;
892 }
893 #ifdef TULIP_DEBUG
894 if (tulip_debug > 1 && leaf->media == 11) {
895 unsigned char *bp = leaf->leafdata;
896 printf("%s: MII interface PHY %d, setup/reset sequences %d/%d long, capabilities %hhX %hhX.\n",
897 tp->nic_name, bp[0], bp[1], bp[2 + bp[1]*2],
898 bp[5 + bp[2 + bp[1]*2]*2], bp[4 + bp[2 + bp[1]*2]*2]);
899 }
900 #endif
901 printf("%s: Index #%d - Media %s (#%d) described "
902 "by a %s (%d) block.\n",
903 tp->nic_name, i, medianame[leaf->media], leaf->media,
904 leaf->type < 6 ? block_name[leaf->type] : "UNKNOWN",
905 leaf->type);
906 }
907 if (new_advertise)
908 tp->sym_advertise = new_advertise;
909 }
910 }
911
912 \f
913 /*********************************************************************/
914 /* tulip_init_ring - setup the tx and rx descriptors */
915 /*********************************************************************/
916 static void tulip_init_ring(struct nic *nic __unused)
917 {
918 int i;
919
920 #ifdef TULIP_DEBUG_WHERE
921 whereami("tulip_init_ring\n");
922 #endif
923
924 tp->cur_rx = 0;
925
926 for (i = 0; i < RX_RING_SIZE; i++) {
927 rx_ring[i].status = cpu_to_le32(0x80000000);
928 rx_ring[i].length = cpu_to_le32(BUFLEN);
929 rx_ring[i].buffer1 = virt_to_le32desc(&rxb[i * BUFLEN]);
930 rx_ring[i].buffer2 = virt_to_le32desc(&rx_ring[i+1]);
931 }
932 /* Mark the last entry as wrapping the ring. */
933 rx_ring[i-1].length = cpu_to_le32(DESC_RING_WRAP | BUFLEN);
934 rx_ring[i-1].buffer2 = virt_to_le32desc(&rx_ring[0]);
935
936 /* We only use 1 transmit buffer, but we use 2 descriptors so
937 transmit engines have somewhere to point to if they feel the need */
938
939 tx_ring[0].status = 0x00000000;
940 tx_ring[0].buffer1 = virt_to_le32desc(&txb[0]);
941 tx_ring[0].buffer2 = virt_to_le32desc(&tx_ring[1]);
942
943 /* this descriptor should never get used, since it will never be owned
944 by the machine (status will always == 0) */
945 tx_ring[1].status = 0x00000000;
946 tx_ring[1].buffer1 = virt_to_le32desc(&txb[0]);
947 tx_ring[1].buffer2 = virt_to_le32desc(&tx_ring[0]);
948
949 /* Mark the last entry as wrapping the ring, though this should never happen */
950 tx_ring[1].length = cpu_to_le32(DESC_RING_WRAP | BUFLEN);
951 }
952 \f
953
954 static void set_rx_mode(struct nic *nic __unused) {
955 int csr6 = inl(ioaddr + CSR6) & ~0x00D5;
956
957 tp->csr6 &= ~0x00D5;
958
959 /* !IFF_PROMISC */
960 tp->csr6 |= AcceptAllMulticast;
961 csr6 |= AcceptAllMulticast;
962
963 outl(csr6, ioaddr + CSR6);
964
965
966
967 }
968
969 /*********************************************************************/
970 /* eth_reset - Reset adapter */
971 /*********************************************************************/
972 static void tulip_reset(struct nic *nic)
973 {
974 int i;
975 unsigned long to;
976
977 #ifdef TULIP_DEBUG_WHERE
978 whereami("tulip_reset\n");
979 #endif
980
981 /* Stop Tx and RX */
982 outl(inl(ioaddr + CSR6) & ~0x00002002, ioaddr + CSR6);
983
984 /* On some chip revs we must set the MII/SYM port before the reset!? */
985 if (tp->mii_cnt || (tp->mtable && tp->mtable->has_mii)) {
986 outl(0x814C0000, ioaddr + CSR6);
987 }
988
989 /* Reset the chip, holding bit 0 set at least 50 PCI cycles. */
990 outl(0x00000001, ioaddr + CSR0);
991 tulip_wait(1);
992
993 /* turn off reset and set cache align=16lword, burst=unlimit */
994 outl(tp->csr0, ioaddr + CSR0);
995
996 /* Wait the specified 50 PCI cycles after a reset */
997 tulip_wait(1);
998
999 /* set up transmit and receive descriptors */
1000 tulip_init_ring(nic);
1001
1002 if (tp->chip_id == PNIC2) {
1003 u32 addr_high = (nic->node_addr[1]<<8) + (nic->node_addr[0]<<0);
1004 /* This address setting does not appear to impact chip operation?? */
1005 outl((nic->node_addr[5]<<8) + nic->node_addr[4] +
1006 (nic->node_addr[3]<<24) + (nic->node_addr[2]<<16),
1007 ioaddr + 0xB0);
1008 outl(addr_high + (addr_high<<16), ioaddr + 0xB8);
1009 }
1010
1011 /* MC_HASH_ONLY boards don't support setup packets */
1012 if (tp->flags & MC_HASH_ONLY) {
1013 u32 addr_low = cpu_to_le32(get_unaligned((u32 *)nic->node_addr));
1014 u32 addr_high = cpu_to_le32(get_unaligned((u16 *)(nic->node_addr+4)));
1015
1016 /* clear multicast hash filters and setup MAC address filters */
1017 if (tp->flags & IS_ASIX) {
1018 outl(0, ioaddr + CSR13);
1019 outl(addr_low, ioaddr + CSR14);
1020 outl(1, ioaddr + CSR13);
1021 outl(addr_high, ioaddr + CSR14);
1022 outl(2, ioaddr + CSR13);
1023 outl(0, ioaddr + CSR14);
1024 outl(3, ioaddr + CSR13);
1025 outl(0, ioaddr + CSR14);
1026 } else if (tp->chip_id == COMET) {
1027 outl(addr_low, ioaddr + 0xA4);
1028 outl(addr_high, ioaddr + 0xA8);
1029 outl(0, ioaddr + 0xAC);
1030 outl(0, ioaddr + 0xB0);
1031 }
1032 } else {
1033 /* for other boards we send a setup packet to initialize
1034 the filters */
1035 u32 tx_flags = 0x08000000 | 192;
1036
1037 /* construct perfect filter frame with mac address as first match
1038 and broadcast address for all others */
1039 for (i=0; i<192; i++)
1040 txb[i] = 0xFF;
1041 txb[0] = nic->node_addr[0];
1042 txb[1] = nic->node_addr[1];
1043 txb[4] = nic->node_addr[2];
1044 txb[5] = nic->node_addr[3];
1045 txb[8] = nic->node_addr[4];
1046 txb[9] = nic->node_addr[5];
1047
1048 tx_ring[0].length = cpu_to_le32(tx_flags);
1049 tx_ring[0].buffer1 = virt_to_le32desc(&txb[0]);
1050 tx_ring[0].status = cpu_to_le32(0x80000000);
1051 }
1052
1053 /* Point to rx and tx descriptors */
1054 outl(virt_to_le32desc(&rx_ring[0]), ioaddr + CSR3);
1055 outl(virt_to_le32desc(&tx_ring[0]), ioaddr + CSR4);
1056
1057 init_media(nic);
1058
1059 /* set the chip's operating mode (but don't turn on xmit and recv yet) */
1060 outl((tp->csr6 & ~0x00002002), ioaddr + CSR6);
1061
1062 /* send setup packet for cards that support it */
1063 if (!(tp->flags & MC_HASH_ONLY)) {
1064 /* enable transmit wait for completion */
1065 outl(tp->csr6 | 0x00002000, ioaddr + CSR6);
1066 /* immediate transmit demand */
1067 outl(0, ioaddr + CSR1);
1068
1069 to = currticks() + TX_TIME_OUT;
1070 while ((tx_ring[0].status & 0x80000000) && (currticks() < to))
1071 /* wait */ ;
1072
1073 if (currticks() >= to) {
1074 printf ("%s: TX Setup Timeout.\n", tp->nic_name);
1075 }
1076 }
1077
1078 if (tp->chip_id == LC82C168)
1079 tulip_check_duplex(nic);
1080
1081 set_rx_mode(nic);
1082
1083 /* enable transmit and receive */
1084 outl(tp->csr6 | 0x00002002, ioaddr + CSR6);
1085 }
1086
1087 \f
1088 /*********************************************************************/
1089 /* eth_transmit - Transmit a frame */
1090 /*********************************************************************/
1091 static void tulip_transmit(struct nic *nic, const char *d, unsigned int t,
1092 unsigned int s, const char *p)
1093 {
1094 u16 nstype;
1095 u32 to;
1096 u32 csr6 = inl(ioaddr + CSR6);
1097
1098 #ifdef TULIP_DEBUG_WHERE
1099 whereami("tulip_transmit\n");
1100 #endif
1101
1102 /* Disable Tx */
1103 outl(csr6 & ~0x00002000, ioaddr + CSR6);
1104
1105 memcpy(txb, d, ETH_ALEN);
1106 memcpy(txb + ETH_ALEN, nic->node_addr, ETH_ALEN);
1107 nstype = htons((u16) t);
1108 memcpy(txb + 2 * ETH_ALEN, (u8 *)&nstype, 2);
1109 memcpy(txb + ETH_HLEN, p, s);
1110
1111 s += ETH_HLEN;
1112 s &= 0x0FFF;
1113
1114 /* pad to minimum packet size */
1115 while (s < ETH_ZLEN)
1116 txb[s++] = '\0';
1117
1118 #ifdef TULIP_DEBUG
1119 if (tulip_debug > 1)
1120 printf("%s: sending %d bytes ethtype %hX\n", tp->nic_name, s, t);
1121 #endif
1122
1123 /* setup the transmit descriptor */
1124 /* 0x60000000 = no interrupt on completion */
1125 tx_ring[0].length = cpu_to_le32(0x60000000 | s);
1126 tx_ring[0].status = cpu_to_le32(0x80000000);
1127
1128 /* Point to transmit descriptor */
1129 outl(virt_to_le32desc(&tx_ring[0]), ioaddr + CSR4);
1130
1131 /* Enable Tx */
1132 outl(csr6 | 0x00002000, ioaddr + CSR6);
1133 /* immediate transmit demand */
1134 outl(0, ioaddr + CSR1);
1135
1136 to = currticks() + TX_TIME_OUT;
1137 while ((tx_ring[0].status & 0x80000000) && (currticks() < to))
1138 /* wait */ ;
1139
1140 if (currticks() >= to) {
1141 printf ("TX Timeout!\n");
1142 }
1143
1144 /* Disable Tx */
1145 outl(csr6 & ~0x00002000, ioaddr + CSR6);
1146 }
1147 \f
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 + 1) % 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 + 1) % RX_RING_SIZE;
1184
1185 return 1;
1186 }
1187 \f
1188 /*********************************************************************/
1189 /* eth_disable - Disable the interface */
1190 /*********************************************************************/
1191 static void tulip_disable ( struct nic *nic ) {
1192
1193 #ifdef TULIP_DEBUG_WHERE
1194 whereami("tulip_disable\n");
1195 #endif
1196
1197 tulip_reset(nic);
1198
1199 /* disable interrupts */
1200 outl(0x00000000, ioaddr + CSR7);
1201
1202 /* Stop the chip's Tx and Rx processes. */
1203 outl(inl(ioaddr + CSR6) & ~0x00002002, ioaddr + CSR6);
1204
1205 /* Clear the missed-packet counter. */
1206 inl(ioaddr + CSR8);
1207 }
1208 \f
1209 /*********************************************************************/
1210 /*IRQ - Enable, Disable, or Force interrupts */
1211 /*********************************************************************/
1212 static void tulip_irq(struct nic *nic __unused, irq_action_t action __unused)
1213 {
1214 switch ( action ) {
1215 case DISABLE :
1216 break;
1217 case ENABLE :
1218 break;
1219 case FORCE :
1220 break;
1221 }
1222 }
1223 \f
1224 static struct nic_operations tulip_operations = {
1225 .connect = dummy_connect,
1226 .poll = tulip_poll,
1227 .transmit = tulip_transmit,
1228 .irq = tulip_irq,
1229
1230 };
1231 \f
1232 /*********************************************************************/
1233 /* eth_probe - Look for an adapter */
1234 /*********************************************************************/
1235 static int tulip_probe ( struct nic *nic, struct pci_device *pci ) {
1236
1237 u32 i;
1238 u8 chip_rev;
1239 u8 ee_data[EEPROM_SIZE];
1240 unsigned short sum;
1241 int chip_idx;
1242 static unsigned char last_phys_addr[ETH_ALEN] = {0x00, 'L', 'i', 'n', 'u', 'x'};
1243
1244 if (pci->ioaddr == 0)
1245 return 0;
1246
1247 ioaddr = pci->ioaddr;
1248 nic->ioaddr = pci->ioaddr & ~3;
1249 nic->irqno = 0;
1250
1251 /* point to private storage */
1252 tp = &tulip_bss.tpx;
1253
1254 tp->vendor_id = pci->vendor;
1255 tp->dev_id = pci->device;
1256 tp->nic_name = pci->driver_name;
1257
1258 tp->if_port = 0;
1259 tp->default_port = 0;
1260
1261 adjust_pci_device(pci);
1262
1263 /* disable interrupts */
1264 outl(0x00000000, ioaddr + CSR7);
1265
1266 /* Stop the chip's Tx and Rx processes. */
1267 outl(inl(ioaddr + CSR6) & ~0x00002002, ioaddr + CSR6);
1268
1269 /* Clear the missed-packet counter. */
1270 inl(ioaddr + CSR8);
1271
1272 printf("\n"); /* so we start on a fresh line */
1273 #ifdef TULIP_DEBUG_WHERE
1274 whereami("tulip_probe\n");
1275 #endif
1276
1277 #ifdef TULIP_DEBUG
1278 if (tulip_debug > 1)
1279 printf ("%s: Looking for Tulip Chip: Vendor=%hX Device=%hX\n", tp->nic_name,
1280 tp->vendor, tp->dev_id);
1281 #endif
1282
1283 /* Figure out which chip we're dealing with */
1284 i = 0;
1285 chip_idx = -1;
1286
1287 while (pci_id_tbl[i].name) {
1288 if ( (((u32) tp->dev_id << 16) | tp->vendor_id) ==
1289 (pci_id_tbl[i].id.pci & pci_id_tbl[i].id.pci_mask) ) {
1290 chip_idx = pci_id_tbl[i].drv_flags;
1291 break;
1292 }
1293 i++;
1294 }
1295
1296 if (chip_idx == -1) {
1297 printf ("%s: Unknown Tulip Chip: Vendor=%hX Device=%hX\n", tp->nic_name,
1298 tp->vendor_id, tp->dev_id);
1299 return 0;
1300 }
1301
1302 tp->pci_id_idx = i;
1303 tp->flags = tulip_tbl[chip_idx].flags;
1304
1305 #ifdef TULIP_DEBUG
1306 if (tulip_debug > 1) {
1307 printf ("%s: tp->pci_id_idx == %d, name == %s\n", tp->nic_name,
1308 tp->pci_id_idx, pci_id_tbl[tp->pci_id_idx].name);
1309 printf ("%s: chip_idx == %d, name == %s\n", tp->nic_name, chip_idx,
1310 tulip_tbl[chip_idx].chip_name);
1311 }
1312 #endif
1313
1314 /* Bring the 21041/21143 out of sleep mode.
1315 Caution: Snooze mode does not work with some boards! */
1316 if (tp->flags & HAS_PWRDWN)
1317 pci_write_config_dword(pci, 0x40, 0x00000000);
1318
1319 if (inl(ioaddr + CSR5) == 0xFFFFFFFF) {
1320 printf("%s: The Tulip chip at %X is not functioning.\n",
1321 tp->nic_name, (unsigned int) ioaddr);
1322 return 0;
1323 }
1324
1325 pci_read_config_byte(pci, PCI_REVISION, &chip_rev);
1326
1327 printf("%s: [chip: %s] rev %d at %hX\n", tp->nic_name,
1328 tulip_tbl[chip_idx].chip_name, chip_rev, (unsigned int) ioaddr);
1329 printf("%s: Vendor=%hX Device=%hX", tp->nic_name, tp->vendor_id, tp->dev_id);
1330
1331 if (chip_idx == DC21041 && inl(ioaddr + CSR9) & 0x8000) {
1332 printf(" 21040 compatible mode.");
1333 chip_idx = DC21040;
1334 }
1335
1336 printf("\n");
1337
1338 /* The SROM/EEPROM interface varies dramatically. */
1339 sum = 0;
1340 if (chip_idx == DC21040) {
1341 outl(0, ioaddr + CSR9); /* Reset the pointer with a dummy write. */
1342 for (i = 0; i < ETH_ALEN; i++) {
1343 int value, boguscnt = 100000;
1344 do
1345 value = inl(ioaddr + CSR9);
1346 while (value < 0 && --boguscnt > 0);
1347 nic->node_addr[i] = value;
1348 sum += value & 0xff;
1349 }
1350 } else if (chip_idx == LC82C168) {
1351 for (i = 0; i < 3; i++) {
1352 int value, boguscnt = 100000;
1353 outl(0x600 | i, ioaddr + 0x98);
1354 do
1355 value = inl(ioaddr + CSR9);
1356 while (value < 0 && --boguscnt > 0);
1357 put_unaligned(le16_to_cpu(value), ((u16*)nic->node_addr) + i);
1358 sum += value & 0xffff;
1359 }
1360 } else if (chip_idx == COMET) {
1361 /* No need to read the EEPROM. */
1362 put_unaligned(inl(ioaddr + 0xA4), (u32 *)nic->node_addr);
1363 put_unaligned(inl(ioaddr + 0xA8), (u16 *)(nic->node_addr + 4));
1364 for (i = 0; i < ETH_ALEN; i ++)
1365 sum += nic->node_addr[i];
1366 } else {
1367 /* A serial EEPROM interface, we read now and sort it out later. */
1368 int sa_offset = 0;
1369 int ee_addr_size = read_eeprom(ioaddr, 0xff, 8) & 0x40000 ? 8 : 6;
1370
1371 for (i = 0; i < sizeof(ee_data)/2; i++)
1372 ((u16 *)ee_data)[i] =
1373 le16_to_cpu(read_eeprom(ioaddr, i, ee_addr_size));
1374
1375 /* DEC now has a specification (see Notes) but early board makers
1376 just put the address in the first EEPROM locations. */
1377 /* This does memcmp(eedata, eedata+16, 8) */
1378 for (i = 0; i < 8; i ++)
1379 if (ee_data[i] != ee_data[16+i])
1380 sa_offset = 20;
1381 if (ee_data[0] == 0xff && ee_data[1] == 0xff && ee_data[2] == 0) {
1382 sa_offset = 2; /* Grrr, damn Matrox boards. */
1383 }
1384 for (i = 0; i < ETH_ALEN; i ++) {
1385 nic->node_addr[i] = ee_data[i + sa_offset];
1386 sum += ee_data[i + sa_offset];
1387 }
1388 }
1389 /* Lite-On boards have the address byte-swapped. */
1390 if ((nic->node_addr[0] == 0xA0 || nic->node_addr[0] == 0xC0)
1391 && nic->node_addr[1] == 0x00)
1392 for (i = 0; i < ETH_ALEN; i+=2) {
1393 char tmp = nic->node_addr[i];
1394 nic->node_addr[i] = nic->node_addr[i+1];
1395 nic->node_addr[i+1] = tmp;
1396 }
1397
1398 if (sum == 0 || sum == ETH_ALEN*0xff) {
1399 printf("%s: EEPROM not present!\n", tp->nic_name);
1400 for (i = 0; i < ETH_ALEN-1; i++)
1401 nic->node_addr[i] = last_phys_addr[i];
1402 nic->node_addr[i] = last_phys_addr[i] + 1;
1403 }
1404
1405 for (i = 0; i < ETH_ALEN; i++)
1406 last_phys_addr[i] = nic->node_addr[i];
1407
1408 DBG ( "%s: %s at ioaddr %hX\n", tp->nic_name, eth_ntoa ( nic->node_addr ),
1409 (unsigned int) ioaddr );
1410
1411 tp->chip_id = chip_idx;
1412 tp->revision = chip_rev;
1413 tp->csr0 = csr0;
1414
1415 /* BugFixes: The 21143-TD hangs with PCI Write-and-Invalidate cycles.
1416 And the ASIX must have a burst limit or horrible things happen. */
1417 if (chip_idx == DC21143 && chip_rev == 65)
1418 tp->csr0 &= ~0x01000000;
1419 else if (tp->flags & IS_ASIX)
1420 tp->csr0 |= 0x2000;
1421
1422 if (media_cap[tp->default_port] & MediaIsMII) {
1423 static const u16 media2advert[] = { 0x20, 0x40, 0x03e0, 0x60,
1424 0x80, 0x100, 0x200 };
1425 tp->mii_advertise = media2advert[tp->default_port - 9];
1426 tp->mii_advertise |= (tp->flags & HAS_8023X); /* Matching bits! */
1427 }
1428
1429 /* This is logically part of the probe routine, but too complex
1430 to write inline. */
1431 if (tp->flags & HAS_MEDIA_TABLE) {
1432 memcpy(tp->eeprom, ee_data, sizeof(tp->eeprom));
1433 parse_eeprom(nic);
1434 }
1435
1436 start_link(nic);
1437
1438 /* reset the device and make ready for tx and rx of packets */
1439 tulip_reset(nic);
1440 nic->nic_op = &tulip_operations;
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_device_id tulip_nics[] = {
2050 PCI_ROM(0x1011, 0x0002, "dc21040", "Digital Tulip", 0),
2051 PCI_ROM(0x1011, 0x0009, "ds21140", "Digital Tulip Fast", 0),
2052 PCI_ROM(0x1011, 0x0014, "dc21041", "Digital Tulip+", 0),
2053 PCI_ROM(0x1011, 0x0019, "ds21142", "Digital Tulip 21142", 0),
2054 PCI_ROM(0x10b7, 0x9300, "3csoho100b-tx","3ComSOHO100B-TX", 0),
2055 PCI_ROM(0x10b9, 0x5261, "ali1563", "ALi 1563 integrated ethernet", 0),
2056 PCI_ROM(0x10d9, 0x0512, "mx98713", "Macronix MX987x3", 0),
2057 PCI_ROM(0x10d9, 0x0531, "mx98715", "Macronix MX987x5", 0),
2058 PCI_ROM(0x1113, 0x1217, "mxic-98715", "Macronix MX987x5", 0),
2059 PCI_ROM(0x11ad, 0xc115, "lc82c115", "LinkSys LNE100TX", 0),
2060 PCI_ROM(0x11ad, 0x0002, "82c168", "Netgear FA310TX", 0),
2061 PCI_ROM(0x1282, 0x9100, "dm9100", "Davicom 9100", 0),
2062 PCI_ROM(0x1282, 0x9102, "dm9102", "Davicom 9102", 0),
2063 PCI_ROM(0x1282, 0x9009, "dm9009", "Davicom 9009", 0),
2064 PCI_ROM(0x1282, 0x9132, "dm9132", "Davicom 9132", 0),
2065 PCI_ROM(0x1317, 0x0985, "centaur-p", "ADMtek Centaur-P", 0),
2066 PCI_ROM(0x1317, 0x0981, "an981", "ADMtek AN981 Comet", 0), /* ADMTek Centaur-P (stmicro) */
2067 PCI_ROM(0x1113, 0x1216, "an983", "ADMTek AN983 Comet", 0),
2068 PCI_ROM(0x1317, 0x9511, "an983b", "ADMTek Comet 983b", 0),
2069 PCI_ROM(0x1317, 0x1985, "centaur-c", "ADMTek Centaur-C", 0),
2070 PCI_ROM(0x8086, 0x0039, "intel21145", "Intel Tulip", 0),
2071 PCI_ROM(0x125b, 0x1400, "ax88140", "ASIX AX88140", 0),
2072 PCI_ROM(0x11f6, 0x9881, "rl100tx", "Compex RL100-TX", 0),
2073 PCI_ROM(0x115d, 0x0003, "xircomtulip", "Xircom Tulip", 0),
2074 PCI_ROM(0x104a, 0x0981, "tulip-0981", "Tulip 0x104a 0x0981", 0),
2075 PCI_ROM(0x104a, 0x2774, "SGThomson-STE10100A", "Tulip 0x104a 0x2774", 0), /*Modified by Ramesh Chander*/
2076 PCI_ROM(0x1113, 0x9511, "tulip-9511", "Tulip 0x1113 0x9511", 0),
2077 PCI_ROM(0x1186, 0x1561, "tulip-1561", "Tulip 0x1186 0x1561", 0),
2078 PCI_ROM(0x1259, 0xa120, "tulip-a120", "Tulip 0x1259 0xa120", 0),
2079 PCI_ROM(0x13d1, 0xab02, "tulip-ab02", "Tulip 0x13d1 0xab02", 0),
2080 PCI_ROM(0x13d1, 0xab03, "tulip-ab03", "Tulip 0x13d1 0xab03", 0),
2081 PCI_ROM(0x13d1, 0xab08, "tulip-ab08", "Tulip 0x13d1 0xab08", 0),
2082 PCI_ROM(0x14f1, 0x1803, "lanfinity", "Conexant LANfinity", 0),
2083 PCI_ROM(0x1626, 0x8410, "tulip-8410", "Tulip 0x1626 0x8410", 0),
2084 PCI_ROM(0x1737, 0xab08, "tulip-1737-ab08","Tulip 0x1737 0xab08", 0),
2085 PCI_ROM(0x1737, 0xab09, "tulip-ab09", "Tulip 0x1737 0xab09", 0),
2086 };
2087
2088 PCI_DRIVER ( tulip_driver, tulip_nics, PCI_NO_CLASS );
2089
2090 DRIVER ( "Tulip", nic_driver, pci_driver, tulip_driver,
2091 tulip_probe, tulip_disable );
2092
2093 /*
2094 * Local variables:
2095 * c-basic-offset: 8
2096 * c-indent-level: 8
2097 * tab-width: 8
2098 * End:
2099 */
gPXE - free pxe roms