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