[forcedeth] Add support for newer forcedeth NICs
[people/sha0/gpxe.git] / src / drivers / net / forcedeth.c
1 /**************************************************************************
2 *    forcedeth.c -- Etherboot device driver for the NVIDIA nForce 
3 *                       media access controllers.
4 *
5 * Note: This driver is based on the Linux driver that was based on
6 *      a cleanroom reimplementation which was based on reverse
7 *      engineered documentation written by Carl-Daniel Hailfinger
8 *      and Andrew de Quincey. It's neither supported nor endorsed
9 *      by NVIDIA Corp. Use at your own risk.
10 *
11 *    Written 2004 by Timothy Legge <tlegge@rogers.com>
12 *
13 *    This program is free software; you can redistribute it and/or modify
14 *    it under the terms of the GNU General Public License as published by
15 *    the Free Software Foundation; either version 2 of the License, or
16 *    (at your option) any later version.
17 *
18 *    This program is distributed in the hope that it will be useful,
19 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
20 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21 *    GNU General Public License for more details.
22 *
23 *    You should have received a copy of the GNU General Public License
24 *    along with this program; if not, write to the Free Software
25 *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26 *
27 *    Portions of this code based on:
28 *               forcedeth: Ethernet driver for NVIDIA nForce media access controllers:
29 *
30 *       (C) 2003 Manfred Spraul
31 *               See Linux Driver for full information
32 *       
33 *       Linux Driver Version 0.30, 25 Sep 2004
34 *       Linux Kernel 2.6.10
35
36
37 *    REVISION HISTORY:
38 *    ================
39 *    v1.0       01-31-2004      timlegge        Initial port of Linux driver
40 *    v1.1       02-03-2004      timlegge        Large Clean up, first release 
41 *    v1.2       05-14-2005      timlegge        Add Linux 0.22 to .030 features
42 *
43 *    Indent Options: indent -kr -i8
44 ***************************************************************************/
45
46 /* to get some global routines like printf */
47 #include "etherboot.h"
48 /* to get the interface to the body of the program */
49 #include "nic.h"
50 /* to get the PCI support functions, if this is a PCI NIC */
51 #include <gpxe/pci.h>
52 /* Include timer support functions */
53 #include <gpxe/ethernet.h>
54 #include "mii.h"
55
56 #define drv_version "v1.2"
57 #define drv_date "05-14-2005"
58
59 //#define TFTM_DEBUG
60 #ifdef TFTM_DEBUG
61 #define dprintf(x) printf x
62 #else
63 #define dprintf(x)
64 #endif
65
66 #define ETH_DATA_LEN   1500
67
68 /* Condensed operations for readability. */
69 #define virt_to_le32desc(addr)  cpu_to_le32(virt_to_bus(addr))
70 #define le32desc_to_virt(addr)  bus_to_virt(le32_to_cpu(addr))
71
72 static unsigned long BASE;
73 /* NIC specific static variables go here */
74 #define PCI_DEVICE_ID_NVIDIA_NVENET_1           0x01c3
75 #define PCI_DEVICE_ID_NVIDIA_NVENET_2           0x0066
76 #define PCI_DEVICE_ID_NVIDIA_NVENET_4           0x0086
77 #define PCI_DEVICE_ID_NVIDIA_NVENET_5           0x008c
78 #define PCI_DEVICE_ID_NVIDIA_NVENET_3           0x00d6
79 #define PCI_DEVICE_ID_NVIDIA_NVENET_7           0x00df
80 #define PCI_DEVICE_ID_NVIDIA_NVENET_6           0x00e6
81 #define PCI_DEVICE_ID_NVIDIA_NVENET_8           0x0056
82 #define PCI_DEVICE_ID_NVIDIA_NVENET_9           0x0057
83 #define PCI_DEVICE_ID_NVIDIA_NVENET_10          0x0037
84 #define PCI_DEVICE_ID_NVIDIA_NVENET_11          0x0038
85 #define PCI_DEVICE_ID_NVIDIA_NVENET_15          0x0373
86
87
88 /*
89  * Hardware access:
90  */
91
92 #define DEV_NEED_LASTPACKET1    0x0001  /* set LASTPACKET1 in tx flags */
93 #define DEV_IRQMASK_1           0x0002  /* use NVREG_IRQMASK_WANTED_1 for irq mask */
94 #define DEV_IRQMASK_2           0x0004  /* use NVREG_IRQMASK_WANTED_2 for irq mask */
95 #define DEV_NEED_TIMERIRQ       0x0008  /* set the timer irq flag in the irq mask */
96 #define DEV_NEED_LINKTIMER      0x0010  /* poll link settings. Relies on the timer irq */
97
98 enum {
99         NvRegIrqStatus = 0x000,
100 #define NVREG_IRQSTAT_MIIEVENT  0040
101 #define NVREG_IRQSTAT_MASK              0x1ff
102         NvRegIrqMask = 0x004,
103 #define NVREG_IRQ_RX_ERROR              0x0001
104 #define NVREG_IRQ_RX                    0x0002
105 #define NVREG_IRQ_RX_NOBUF              0x0004
106 #define NVREG_IRQ_TX_ERR                0x0008
107 #define NVREG_IRQ_TX2                   0x0010
108 #define NVREG_IRQ_TIMER                 0x0020
109 #define NVREG_IRQ_LINK                  0x0040
110 #define NVREG_IRQ_TX1                   0x0100
111 #define NVREG_IRQMASK_WANTED_1          0x005f
112 #define NVREG_IRQMASK_WANTED_2          0x0147
113 #define NVREG_IRQ_UNKNOWN               (~(NVREG_IRQ_RX_ERROR|NVREG_IRQ_RX|NVREG_IRQ_RX_NOBUF|NVREG_IRQ_TX_ERR|NVREG_IRQ_TX2|NVREG_IRQ_TIMER|NVREG_IRQ_LINK|NVREG_IRQ_TX1))
114
115         NvRegUnknownSetupReg6 = 0x008,
116 #define NVREG_UNKSETUP6_VAL             3
117
118 /*
119  * NVREG_POLL_DEFAULT is the interval length of the timer source on the nic
120  * NVREG_POLL_DEFAULT=97 would result in an interval length of 1 ms
121  */
122         NvRegPollingInterval = 0x00c,
123 #define NVREG_POLL_DEFAULT      970
124         NvRegMisc1 = 0x080,
125 #define NVREG_MISC1_HD          0x02
126 #define NVREG_MISC1_FORCE       0x3b0f3c
127
128         NvRegTransmitterControl = 0x084,
129 #define NVREG_XMITCTL_START     0x01
130         NvRegTransmitterStatus = 0x088,
131 #define NVREG_XMITSTAT_BUSY     0x01
132
133         NvRegPacketFilterFlags = 0x8c,
134 #define NVREG_PFF_ALWAYS        0x7F0008
135 #define NVREG_PFF_PROMISC       0x80
136 #define NVREG_PFF_MYADDR        0x20
137
138         NvRegOffloadConfig = 0x90,
139 #define NVREG_OFFLOAD_HOMEPHY   0x601
140 #define NVREG_OFFLOAD_NORMAL    RX_NIC_BUFSIZE
141         NvRegReceiverControl = 0x094,
142 #define NVREG_RCVCTL_START      0x01
143         NvRegReceiverStatus = 0x98,
144 #define NVREG_RCVSTAT_BUSY      0x01
145
146         NvRegRandomSeed = 0x9c,
147 #define NVREG_RNDSEED_MASK      0x00ff
148 #define NVREG_RNDSEED_FORCE     0x7f00
149 #define NVREG_RNDSEED_FORCE2    0x2d00
150 #define NVREG_RNDSEED_FORCE3    0x7400
151
152         NvRegUnknownSetupReg1 = 0xA0,
153 #define NVREG_UNKSETUP1_VAL     0x16070f
154         NvRegUnknownSetupReg2 = 0xA4,
155 #define NVREG_UNKSETUP2_VAL     0x16
156         NvRegMacAddrA = 0xA8,
157         NvRegMacAddrB = 0xAC,
158         NvRegMulticastAddrA = 0xB0,
159 #define NVREG_MCASTADDRA_FORCE  0x01
160         NvRegMulticastAddrB = 0xB4,
161         NvRegMulticastMaskA = 0xB8,
162         NvRegMulticastMaskB = 0xBC,
163
164         NvRegPhyInterface = 0xC0,
165 #define PHY_RGMII               0x10000000
166
167         NvRegTxRingPhysAddr = 0x100,
168         NvRegRxRingPhysAddr = 0x104,
169         NvRegRingSizes = 0x108,
170 #define NVREG_RINGSZ_TXSHIFT 0
171 #define NVREG_RINGSZ_RXSHIFT 16
172         NvRegUnknownTransmitterReg = 0x10c,
173         NvRegLinkSpeed = 0x110,
174 #define NVREG_LINKSPEED_FORCE 0x10000
175 #define NVREG_LINKSPEED_10      1000
176 #define NVREG_LINKSPEED_100     100
177 #define NVREG_LINKSPEED_1000    50
178         NvRegUnknownSetupReg5 = 0x130,
179 #define NVREG_UNKSETUP5_BIT31   (1<<31)
180         NvRegUnknownSetupReg3 = 0x13c,
181 #define NVREG_UNKSETUP3_VAL1    0x200010
182         NvRegTxRxControl = 0x144,
183 #define NVREG_TXRXCTL_KICK      0x0001
184 #define NVREG_TXRXCTL_BIT1      0x0002
185 #define NVREG_TXRXCTL_BIT2      0x0004
186 #define NVREG_TXRXCTL_IDLE      0x0008
187 #define NVREG_TXRXCTL_RESET     0x0010
188 #define NVREG_TXRXCTL_RXCHECK   0x0400
189         NvRegMIIStatus = 0x180,
190 #define NVREG_MIISTAT_ERROR             0x0001
191 #define NVREG_MIISTAT_LINKCHANGE        0x0008
192 #define NVREG_MIISTAT_MASK              0x000f
193 #define NVREG_MIISTAT_MASK2             0x000f
194         NvRegUnknownSetupReg4 = 0x184,
195 #define NVREG_UNKSETUP4_VAL     8
196
197         NvRegAdapterControl = 0x188,
198 #define NVREG_ADAPTCTL_START    0x02
199 #define NVREG_ADAPTCTL_LINKUP   0x04
200 #define NVREG_ADAPTCTL_PHYVALID 0x40000
201 #define NVREG_ADAPTCTL_RUNNING  0x100000
202 #define NVREG_ADAPTCTL_PHYSHIFT 24
203         NvRegMIISpeed = 0x18c,
204 #define NVREG_MIISPEED_BIT8     (1<<8)
205 #define NVREG_MIIDELAY  5
206         NvRegMIIControl = 0x190,
207 #define NVREG_MIICTL_INUSE      0x08000
208 #define NVREG_MIICTL_WRITE      0x00400
209 #define NVREG_MIICTL_ADDRSHIFT  5
210         NvRegMIIData = 0x194,
211         NvRegWakeUpFlags = 0x200,
212 #define NVREG_WAKEUPFLAGS_VAL           0x7770
213 #define NVREG_WAKEUPFLAGS_BUSYSHIFT     24
214 #define NVREG_WAKEUPFLAGS_ENABLESHIFT   16
215 #define NVREG_WAKEUPFLAGS_D3SHIFT       12
216 #define NVREG_WAKEUPFLAGS_D2SHIFT       8
217 #define NVREG_WAKEUPFLAGS_D1SHIFT       4
218 #define NVREG_WAKEUPFLAGS_D0SHIFT       0
219 #define NVREG_WAKEUPFLAGS_ACCEPT_MAGPAT         0x01
220 #define NVREG_WAKEUPFLAGS_ACCEPT_WAKEUPPAT      0x02
221 #define NVREG_WAKEUPFLAGS_ACCEPT_LINKCHANGE     0x04
222 #define NVREG_WAKEUPFLAGS_ENABLE        0x1111
223
224         NvRegPatternCRC = 0x204,
225         NvRegPatternMask = 0x208,
226         NvRegPowerCap = 0x268,
227 #define NVREG_POWERCAP_D3SUPP   (1<<30)
228 #define NVREG_POWERCAP_D2SUPP   (1<<26)
229 #define NVREG_POWERCAP_D1SUPP   (1<<25)
230         NvRegPowerState = 0x26c,
231 #define NVREG_POWERSTATE_POWEREDUP      0x8000
232 #define NVREG_POWERSTATE_VALID          0x0100
233 #define NVREG_POWERSTATE_MASK           0x0003
234 #define NVREG_POWERSTATE_D0             0x0000
235 #define NVREG_POWERSTATE_D1             0x0001
236 #define NVREG_POWERSTATE_D2             0x0002
237 #define NVREG_POWERSTATE_D3             0x0003
238 };
239
240 #define FLAG_MASK_V1 0xffff0000
241 #define FLAG_MASK_V2 0xffffc000
242 #define LEN_MASK_V1 (0xffffffff ^ FLAG_MASK_V1)
243 #define LEN_MASK_V2 (0xffffffff ^ FLAG_MASK_V2)
244
245 #define NV_TX_LASTPACKET        (1<<16)
246 #define NV_TX_RETRYERROR        (1<<19)
247 #define NV_TX_LASTPACKET1       (1<<24)
248 #define NV_TX_DEFERRED          (1<<26)
249 #define NV_TX_CARRIERLOST       (1<<27)
250 #define NV_TX_LATECOLLISION     (1<<28)
251 #define NV_TX_UNDERFLOW         (1<<29)
252 #define NV_TX_ERROR             (1<<30)
253 #define NV_TX_VALID             (1<<31)
254
255 #define NV_TX2_LASTPACKET       (1<<29)
256 #define NV_TX2_RETRYERROR       (1<<18)
257 #define NV_TX2_LASTPACKET1      (1<<23)
258 #define NV_TX2_DEFERRED         (1<<25)
259 #define NV_TX2_CARRIERLOST      (1<<26)
260 #define NV_TX2_LATECOLLISION    (1<<27)
261 #define NV_TX2_UNDERFLOW        (1<<28)
262 /* error and valid are the same for both */
263 #define NV_TX2_ERROR            (1<<30)
264 #define NV_TX2_VALID            (1<<31)
265
266 #define NV_RX_DESCRIPTORVALID   (1<<16)
267 #define NV_RX_MISSEDFRAME       (1<<17)
268 #define NV_RX_SUBSTRACT1        (1<<18)
269 #define NV_RX_ERROR1            (1<<23)
270 #define NV_RX_ERROR2            (1<<24)
271 #define NV_RX_ERROR3            (1<<25)
272 #define NV_RX_ERROR4            (1<<26)
273 #define NV_RX_CRCERR            (1<<27)
274 #define NV_RX_OVERFLOW          (1<<28)
275 #define NV_RX_FRAMINGERR        (1<<29)
276 #define NV_RX_ERROR             (1<<30)
277 #define NV_RX_AVAIL             (1<<31)
278
279 #define NV_RX2_CHECKSUMMASK     (0x1C000000)
280 #define NV_RX2_CHECKSUMOK1      (0x10000000)
281 #define NV_RX2_CHECKSUMOK2      (0x14000000)
282 #define NV_RX2_CHECKSUMOK3      (0x18000000)
283 #define NV_RX2_DESCRIPTORVALID  (1<<29)
284 #define NV_RX2_SUBSTRACT1       (1<<25)
285 #define NV_RX2_ERROR1           (1<<18)
286 #define NV_RX2_ERROR2           (1<<19)
287 #define NV_RX2_ERROR3           (1<<20)
288 #define NV_RX2_ERROR4           (1<<21)
289 #define NV_RX2_CRCERR           (1<<22)
290 #define NV_RX2_OVERFLOW         (1<<23)
291 #define NV_RX2_FRAMINGERR       (1<<24)
292 /* error and avail are the same for both */
293 #define NV_RX2_ERROR            (1<<30)
294 #define NV_RX2_AVAIL            (1<<31)
295
296 /* Miscelaneous hardware related defines: */
297 #define NV_PCI_REGSZ            0x270
298
299 /* various timeout delays: all in usec */
300 #define NV_TXRX_RESET_DELAY     4
301 #define NV_TXSTOP_DELAY1        10
302 #define NV_TXSTOP_DELAY1MAX     500000
303 #define NV_TXSTOP_DELAY2        100
304 #define NV_RXSTOP_DELAY1        10
305 #define NV_RXSTOP_DELAY1MAX     500000
306 #define NV_RXSTOP_DELAY2        100
307 #define NV_SETUP5_DELAY         5
308 #define NV_SETUP5_DELAYMAX      50000
309 #define NV_POWERUP_DELAY        5
310 #define NV_POWERUP_DELAYMAX     5000
311 #define NV_MIIBUSY_DELAY        50
312 #define NV_MIIPHY_DELAY 10
313 #define NV_MIIPHY_DELAYMAX      10000
314
315 #define NV_WAKEUPPATTERNS       5
316 #define NV_WAKEUPMASKENTRIES    4
317
318 /* General driver defaults */
319 #define NV_WATCHDOG_TIMEO       (5*HZ)
320
321 #define RX_RING         4
322 #define TX_RING         2
323
324 /* 
325  * If your nic mysteriously hangs then try to reduce the limits
326  * to 1/0: It might be required to set NV_TX_LASTPACKET in the
327  * last valid ring entry. But this would be impossible to
328  * implement - probably a disassembly error.
329  */
330 #define TX_LIMIT_STOP   63
331 #define TX_LIMIT_START  62
332
333 /* rx/tx mac addr + type + vlan + align + slack*/
334 #define RX_NIC_BUFSIZE          (ETH_DATA_LEN + 64)
335 /* even more slack */
336 #define RX_ALLOC_BUFSIZE        (ETH_DATA_LEN + 128)
337
338 #define OOM_REFILL      (1+HZ/20)
339 #define POLL_WAIT       (1+HZ/100)
340 #define LINK_TIMEOUT    (3*HZ)
341
342 /* 
343  * desc_ver values:
344  * This field has two purposes:
345  * - Newer nics uses a different ring layout. The layout is selected by
346  *   comparing np->desc_ver with DESC_VER_xy.
347  * - It contains bits that are forced on when writing to NvRegTxRxControl.
348  */
349 #define DESC_VER_1      0x0
350 #define DESC_VER_2      (0x02100|NVREG_TXRXCTL_RXCHECK)
351
352 /* PHY defines */
353 #define PHY_OUI_MARVELL 0x5043
354 #define PHY_OUI_CICADA  0x03f1
355 #define PHYID1_OUI_MASK 0x03ff
356 #define PHYID1_OUI_SHFT 6
357 #define PHYID2_OUI_MASK 0xfc00
358 #define PHYID2_OUI_SHFT 10
359 #define PHY_INIT1       0x0f000
360 #define PHY_INIT2       0x0e00
361 #define PHY_INIT3       0x01000
362 #define PHY_INIT4       0x0200
363 #define PHY_INIT5       0x0004
364 #define PHY_INIT6       0x02000
365 #define PHY_GIGABIT     0x0100
366
367 #define PHY_TIMEOUT     0x1
368 #define PHY_ERROR       0x2
369
370 #define PHY_100 0x1
371 #define PHY_1000        0x2
372 #define PHY_HALF        0x100
373
374 /* FIXME: MII defines that should be added to <linux/mii.h> */
375 #define MII_1000BT_CR   0x09
376 #define MII_1000BT_SR   0x0a
377 #define ADVERTISE_1000FULL      0x0200
378 #define ADVERTISE_1000HALF      0x0100
379 #define LPA_1000FULL    0x0800
380 #define LPA_1000HALF    0x0400
381
382 /* Bit to know if MAC addr is stored in correct order */
383 #define MAC_ADDR_CORRECT        0x01
384
385 /* Big endian: should work, but is untested */
386 struct ring_desc {
387         u32 PacketBuffer;
388         u32 FlagLen;
389 };
390
391
392 /* Define the TX and RX Descriptor and Buffers */
393 struct {
394         struct ring_desc tx_ring[TX_RING];
395         unsigned char txb[TX_RING * RX_NIC_BUFSIZE];
396         struct ring_desc rx_ring[RX_RING];
397         unsigned char rxb[RX_RING * RX_NIC_BUFSIZE];
398 } forcedeth_bufs __shared;
399 #define tx_ring forcedeth_bufs.tx_ring
400 #define rx_ring forcedeth_bufs.rx_ring
401 #define txb forcedeth_bufs.txb
402 #define rxb forcedeth_bufs.rxb
403
404 /* Private Storage for the NIC */
405 static struct forcedeth_private {
406         /* General data:
407          * Locking: spin_lock(&np->lock); */
408         int in_shutdown;
409         u32 linkspeed;
410         int duplex;
411         int phyaddr;
412         int wolenabled;
413         unsigned int phy_oui;
414         u16 gigabit;
415
416         /* General data: RO fields */
417         u8 *ring_addr;
418         u32 orig_mac[2];
419         u32 irqmask;
420         u32 desc_ver;
421         /* rx specific fields.
422          * Locking: Within irq hander or disable_irq+spin_lock(&np->lock);
423          */
424         unsigned int cur_rx, refill_rx;
425
426         /*
427          * tx specific fields.
428          */
429         unsigned int next_tx, nic_tx;
430         u32 tx_flags;
431 } npx;
432
433 static struct forcedeth_private *np;
434
435 static inline void pci_push(u8 * base)
436 {
437         /* force out pending posted writes */
438         readl(base);
439 }
440
441 static inline u32 nv_descr_getlength(struct ring_desc *prd, u32 v)
442 {
443         return le32_to_cpu(prd->FlagLen)
444             & ((v == DESC_VER_1) ? LEN_MASK_V1 : LEN_MASK_V2);
445 }
446
447 static int reg_delay(int offset, u32 mask,
448                      u32 target, int delay, int delaymax, const char *msg)
449 {
450         u8 *base = (u8 *) BASE;
451
452         pci_push(base);
453         do {
454                 udelay(delay);
455                 delaymax -= delay;
456                 if (delaymax < 0) {
457                         if (msg)
458                                 printf("%s", msg);
459                         return 1;
460                 }
461         } while ((readl(base + offset) & mask) != target);
462         return 0;
463 }
464
465 #define MII_READ        (-1)
466 #define MII_PHYSID1         0x02        /* PHYS ID 1                   */
467 #define MII_PHYSID2         0x03        /* PHYS ID 2                   */
468 #define MII_BMCR            0x00        /* Basic mode control register */
469 #define MII_BMSR            0x01        /* Basic mode status register  */
470 #define MII_ADVERTISE       0x04        /* Advertisement control reg   */
471 #define MII_LPA             0x05        /* Link partner ability reg    */
472
473 #define BMSR_ANEGCOMPLETE       0x0020  /* Auto-negotiation complete   */
474
475 /* Link partner ability register. */
476 #define LPA_SLCT                0x001f  /* Same as advertise selector  */
477 #define LPA_10HALF              0x0020  /* Can do 10mbps half-duplex   */
478 #define LPA_10FULL              0x0040  /* Can do 10mbps full-duplex   */
479 #define LPA_100HALF             0x0080  /* Can do 100mbps half-duplex  */
480 #define LPA_100FULL             0x0100  /* Can do 100mbps full-duplex  */
481 #define LPA_100BASE4            0x0200  /* Can do 100mbps 4k packets   */
482 #define LPA_RESV                0x1c00  /* Unused...                   */
483 #define LPA_RFAULT              0x2000  /* Link partner faulted        */
484 #define LPA_LPACK               0x4000  /* Link partner acked us       */
485 #define LPA_NPAGE               0x8000  /* Next page bit               */
486
487 /* mii_rw: read/write a register on the PHY.
488  *
489  * Caller must guarantee serialization
490  */
491 static int mii_rw(struct nic *nic __unused, int addr, int miireg,
492                   int value)
493 {
494         u8 *base = (u8 *) BASE;
495         u32 reg;
496         int retval;
497
498         writel(NVREG_MIISTAT_MASK, base + NvRegMIIStatus);
499
500         reg = readl(base + NvRegMIIControl);
501         if (reg & NVREG_MIICTL_INUSE) {
502                 writel(NVREG_MIICTL_INUSE, base + NvRegMIIControl);
503                 udelay(NV_MIIBUSY_DELAY);
504         }
505
506         reg =
507             (addr << NVREG_MIICTL_ADDRSHIFT) | miireg;
508         if (value != MII_READ) {
509                 writel(value, base + NvRegMIIData);
510                 reg |= NVREG_MIICTL_WRITE;
511         }
512         writel(reg, base + NvRegMIIControl);
513
514         if (reg_delay(NvRegMIIControl, NVREG_MIICTL_INUSE, 0,
515                       NV_MIIPHY_DELAY, NV_MIIPHY_DELAYMAX, NULL)) {
516                 dprintf(("mii_rw of reg %d at PHY %d timed out.\n",
517                          miireg, addr));
518                 retval = -1;
519         } else if (value != MII_READ) {
520                 /* it was a write operation - fewer failures are detectable */
521                 dprintf(("mii_rw wrote 0x%x to reg %d at PHY %d\n",
522                          value, miireg, addr));
523                 retval = 0;
524         } else if (readl(base + NvRegMIIStatus) & NVREG_MIISTAT_ERROR) {
525                 dprintf(("mii_rw of reg %d at PHY %d failed.\n",
526                          miireg, addr));
527                 retval = -1;
528         } else {
529                 retval = readl(base + NvRegMIIData);
530                 dprintf(("mii_rw read from reg %d at PHY %d: 0x%x.\n",
531                          miireg, addr, retval));
532         }
533         return retval;
534 }
535
536 static int phy_reset(struct nic *nic)
537 {
538
539         u32 miicontrol;
540         unsigned int tries = 0;
541
542         miicontrol = mii_rw(nic, np->phyaddr, MII_BMCR, MII_READ);
543         miicontrol |= BMCR_RESET;
544         if (mii_rw(nic, np->phyaddr, MII_BMCR, miicontrol)) {
545                 return -1;
546         }
547
548         /* wait for 500ms */
549         mdelay(500);
550
551         /* must wait till reset is deasserted */
552         while (miicontrol & BMCR_RESET) {
553                 mdelay(10);
554                 miicontrol = mii_rw(nic, np->phyaddr, MII_BMCR, MII_READ);
555                 /* FIXME: 100 tries seem excessive */
556                 if (tries++ > 100)
557                         return -1;
558         }
559         return 0;
560 }
561
562 static int phy_init(struct nic *nic)
563 {
564         u8 *base = (u8 *) BASE;
565         u32 phyinterface, phy_reserved, mii_status, mii_control,
566             mii_control_1000, reg;
567
568         /* set advertise register */
569         reg = mii_rw(nic, np->phyaddr, MII_ADVERTISE, MII_READ);
570         reg |=
571             (ADVERTISE_10HALF | ADVERTISE_10FULL | ADVERTISE_100HALF |
572              ADVERTISE_100FULL | 0x800 | 0x400);
573         if (mii_rw(nic, np->phyaddr, MII_ADVERTISE, reg)) {
574                 printf("phy write to advertise failed.\n");
575                 return PHY_ERROR;
576         }
577
578         /* get phy interface type */
579         phyinterface = readl(base + NvRegPhyInterface);
580
581         /* see if gigabit phy */
582         mii_status = mii_rw(nic, np->phyaddr, MII_BMSR, MII_READ);
583
584         if (mii_status & PHY_GIGABIT) {
585                 np->gigabit = PHY_GIGABIT;
586                 mii_control_1000 =
587                     mii_rw(nic, np->phyaddr, MII_1000BT_CR, MII_READ);
588                 mii_control_1000 &= ~ADVERTISE_1000HALF;
589                 if (phyinterface & PHY_RGMII)
590                         mii_control_1000 |= ADVERTISE_1000FULL;
591                 else
592                         mii_control_1000 &= ~ADVERTISE_1000FULL;
593
594                 if (mii_rw
595                     (nic, np->phyaddr, MII_1000BT_CR, mii_control_1000)) {
596                         printf("phy init failed.\n");
597                         return PHY_ERROR;
598                 }
599         } else
600                 np->gigabit = 0;
601
602         /* reset the phy */
603         if (phy_reset(nic)) {
604                 printf("phy reset failed\n");
605                 return PHY_ERROR;
606         }
607
608         /* phy vendor specific configuration */
609         if ((np->phy_oui == PHY_OUI_CICADA) && (phyinterface & PHY_RGMII)) {
610                 phy_reserved =
611                     mii_rw(nic, np->phyaddr, MII_RESV1, MII_READ);
612                 phy_reserved &= ~(PHY_INIT1 | PHY_INIT2);
613                 phy_reserved |= (PHY_INIT3 | PHY_INIT4);
614                 if (mii_rw(nic, np->phyaddr, MII_RESV1, phy_reserved)) {
615                         printf("phy init failed.\n");
616                         return PHY_ERROR;
617                 }
618                 phy_reserved =
619                     mii_rw(nic, np->phyaddr, MII_NCONFIG, MII_READ);
620                 phy_reserved |= PHY_INIT5;
621                 if (mii_rw(nic, np->phyaddr, MII_NCONFIG, phy_reserved)) {
622                         printf("phy init failed.\n");
623                         return PHY_ERROR;
624                 }
625         }
626         if (np->phy_oui == PHY_OUI_CICADA) {
627                 phy_reserved =
628                     mii_rw(nic, np->phyaddr, MII_SREVISION, MII_READ);
629                 phy_reserved |= PHY_INIT6;
630                 if (mii_rw(nic, np->phyaddr, MII_SREVISION, phy_reserved)) {
631                         printf("phy init failed.\n");
632                         return PHY_ERROR;
633                 }
634         }
635
636         /* restart auto negotiation */
637         mii_control = mii_rw(nic, np->phyaddr, MII_BMCR, MII_READ);
638         mii_control |= (BMCR_ANRESTART | BMCR_ANENABLE);
639         if (mii_rw(nic, np->phyaddr, MII_BMCR, mii_control)) {
640                 return PHY_ERROR;
641         }
642
643         return 0;
644 }
645
646 static void start_rx(struct nic *nic __unused)
647 {
648         u8 *base = (u8 *) BASE;
649
650         dprintf(("start_rx\n"));
651         /* Already running? Stop it. */
652         if (readl(base + NvRegReceiverControl) & NVREG_RCVCTL_START) {
653                 writel(0, base + NvRegReceiverControl);
654                 pci_push(base);
655         }
656         writel(np->linkspeed, base + NvRegLinkSpeed);
657         pci_push(base);
658         writel(NVREG_RCVCTL_START, base + NvRegReceiverControl);
659         pci_push(base);
660 }
661
662 static void stop_rx(void)
663 {
664         u8 *base = (u8 *) BASE;
665
666         dprintf(("stop_rx\n"));
667         writel(0, base + NvRegReceiverControl);
668         reg_delay(NvRegReceiverStatus, NVREG_RCVSTAT_BUSY, 0,
669                   NV_RXSTOP_DELAY1, NV_RXSTOP_DELAY1MAX,
670                   "stop_rx: ReceiverStatus remained busy");
671
672         udelay(NV_RXSTOP_DELAY2);
673         writel(0, base + NvRegLinkSpeed);
674 }
675
676 static void start_tx(struct nic *nic __unused)
677 {
678         u8 *base = (u8 *) BASE;
679
680         dprintf(("start_tx\n"));
681         writel(NVREG_XMITCTL_START, base + NvRegTransmitterControl);
682         pci_push(base);
683 }
684
685 static void stop_tx(void)
686 {
687         u8 *base = (u8 *) BASE;
688
689         dprintf(("stop_tx\n"));
690         writel(0, base + NvRegTransmitterControl);
691         reg_delay(NvRegTransmitterStatus, NVREG_XMITSTAT_BUSY, 0,
692                   NV_TXSTOP_DELAY1, NV_TXSTOP_DELAY1MAX,
693                   "stop_tx: TransmitterStatus remained busy");
694
695         udelay(NV_TXSTOP_DELAY2);
696         writel(0, base + NvRegUnknownTransmitterReg);
697 }
698
699
700 static void txrx_reset(struct nic *nic __unused)
701 {
702         u8 *base = (u8 *) BASE;
703
704         dprintf(("txrx_reset\n"));
705         writel(NVREG_TXRXCTL_BIT2 | NVREG_TXRXCTL_RESET | np->desc_ver,
706                base + NvRegTxRxControl);
707
708         pci_push(base);
709         udelay(NV_TXRX_RESET_DELAY);
710         writel(NVREG_TXRXCTL_BIT2 | np->desc_ver, base + NvRegTxRxControl);
711         pci_push(base);
712 }
713
714 /*
715  * alloc_rx: fill rx ring entries.
716  * Return 1 if the allocations for the skbs failed and the
717  * rx engine is without Available descriptors
718  */
719 static int alloc_rx(struct nic *nic __unused)
720 {
721         unsigned int refill_rx = np->refill_rx;
722         int i;
723         //while (np->cur_rx != refill_rx) {
724         for (i = 0; i < RX_RING; i++) {
725                 //int nr = refill_rx % RX_RING;
726                 rx_ring[i].PacketBuffer =
727                     virt_to_le32desc(&rxb[i * RX_NIC_BUFSIZE]);
728                 wmb();
729                 rx_ring[i].FlagLen =
730                     cpu_to_le32(RX_NIC_BUFSIZE | NV_RX_AVAIL);
731                 /*      printf("alloc_rx: Packet  %d marked as Available\n",
732                    refill_rx); */
733                 refill_rx++;
734         }
735         np->refill_rx = refill_rx;
736         if (np->cur_rx - refill_rx == RX_RING)
737                 return 1;
738         return 0;
739 }
740
741 static int update_linkspeed(struct nic *nic)
742 {
743         int adv, lpa;
744         u32 newls;
745         int newdup = np->duplex;
746         u32 mii_status;
747         int retval = 0; 
748         u32 control_1000, status_1000, phyreg;
749         u8 *base = (u8 *) BASE;
750         int i;
751
752         /* BMSR_LSTATUS is latched, read it twice:
753          * we want the current value.
754          */
755         mii_rw(nic, np->phyaddr, MII_BMSR, MII_READ);
756         mii_status = mii_rw(nic, np->phyaddr, MII_BMSR, MII_READ);
757
758 #if 1
759         //yhlu
760         for(i=0;i<30;i++) {
761                 mii_status = mii_rw(nic, np->phyaddr, MII_BMSR, MII_READ);
762                 if((mii_status & BMSR_LSTATUS) && (mii_status & BMSR_ANEGCOMPLETE)) break;
763                 mdelay(100);
764         }
765 #endif
766
767         if (!(mii_status & BMSR_LSTATUS)) {
768                 printf
769                     ("no link detected by phy - falling back to 10HD.\n");
770                 newls = NVREG_LINKSPEED_FORCE | NVREG_LINKSPEED_10;
771                 newdup = 0;
772                 retval = 0;
773                 goto set_speed;
774         }
775
776         /* check auto negotiation is complete */
777         if (!(mii_status & BMSR_ANEGCOMPLETE)) {
778                 /* still in autonegotiation - configure nic for 10 MBit HD and wait. */
779                 newls = NVREG_LINKSPEED_FORCE | NVREG_LINKSPEED_10;
780                 newdup = 0;
781                 retval = 0;
782                 printf("autoneg not completed - falling back to 10HD.\n");
783                 goto set_speed;
784         }
785
786         retval = 1;
787         if (np->gigabit == PHY_GIGABIT) {
788                 control_1000 =
789                     mii_rw(nic, np->phyaddr, MII_1000BT_CR, MII_READ);
790                 status_1000 =
791                     mii_rw(nic, np->phyaddr, MII_1000BT_SR, MII_READ);
792
793                 if ((control_1000 & ADVERTISE_1000FULL) &&
794                     (status_1000 & LPA_1000FULL)) {
795                         printf
796                             ("update_linkspeed: GBit ethernet detected.\n");
797                         newls =
798                             NVREG_LINKSPEED_FORCE | NVREG_LINKSPEED_1000;
799                         newdup = 1;
800                         goto set_speed;
801                 }
802         }
803
804         adv = mii_rw(nic, np->phyaddr, MII_ADVERTISE, MII_READ);
805         lpa = mii_rw(nic, np->phyaddr, MII_LPA, MII_READ);
806         dprintf(("update_linkspeed: PHY advertises 0x%hX, lpa 0x%hX.\n",
807                  adv, lpa));
808
809         /* FIXME: handle parallel detection properly, handle gigabit ethernet */
810         lpa = lpa & adv;
811         if (lpa & LPA_100FULL) {
812                 newls = NVREG_LINKSPEED_FORCE | NVREG_LINKSPEED_100;
813                 newdup = 1;
814         } else if (lpa & LPA_100HALF) {
815                 newls = NVREG_LINKSPEED_FORCE | NVREG_LINKSPEED_100;
816                 newdup = 0;
817         } else if (lpa & LPA_10FULL) {
818                 newls = NVREG_LINKSPEED_FORCE | NVREG_LINKSPEED_10;
819                 newdup = 1;
820         } else if (lpa & LPA_10HALF) {
821                 newls = NVREG_LINKSPEED_FORCE | NVREG_LINKSPEED_10;
822                 newdup = 0;
823         } else {
824                 printf("bad ability %hX - falling back to 10HD.\n", lpa);
825                 newls = NVREG_LINKSPEED_FORCE | NVREG_LINKSPEED_10;
826                 newdup = 0;
827         }
828
829       set_speed:
830         if (np->duplex == newdup && np->linkspeed == newls)
831                 return retval;
832
833         dprintf(("changing link setting from %d/%s to %d/%s.\n",
834                np->linkspeed, np->duplex ? "Full-Duplex": "Half-Duplex", newls, newdup ? "Full-Duplex": "Half-Duplex"));
835
836         np->duplex = newdup;
837         np->linkspeed = newls;
838
839         if (np->gigabit == PHY_GIGABIT) {
840                 phyreg = readl(base + NvRegRandomSeed);
841                 phyreg &= ~(0x3FF00);
842                 if ((np->linkspeed & 0xFFF) == NVREG_LINKSPEED_10)
843                         phyreg |= NVREG_RNDSEED_FORCE3;
844                 else if ((np->linkspeed & 0xFFF) == NVREG_LINKSPEED_100)
845                         phyreg |= NVREG_RNDSEED_FORCE2;
846                 else if ((np->linkspeed & 0xFFF) == NVREG_LINKSPEED_1000)
847                         phyreg |= NVREG_RNDSEED_FORCE;
848                 writel(phyreg, base + NvRegRandomSeed);
849         }
850
851         phyreg = readl(base + NvRegPhyInterface);
852         phyreg &= ~(PHY_HALF | PHY_100 | PHY_1000);
853         if (np->duplex == 0)
854                 phyreg |= PHY_HALF;
855         if ((np->linkspeed & 0xFFF) == NVREG_LINKSPEED_100)
856                 phyreg |= PHY_100;
857         else if ((np->linkspeed & 0xFFF) == NVREG_LINKSPEED_1000)
858                 phyreg |= PHY_1000;
859         writel(phyreg, base + NvRegPhyInterface);
860
861         writel(NVREG_MISC1_FORCE | (np->duplex ? 0 : NVREG_MISC1_HD),
862                base + NvRegMisc1);
863         pci_push(base);
864         writel(np->linkspeed, base + NvRegLinkSpeed);
865         pci_push(base);
866
867         return retval;
868 }
869
870 #if 0 /* Not used */
871 static void nv_linkchange(struct nic *nic)
872 {
873         if (update_linkspeed(nic)) {
874 //                if (netif_carrier_ok(nic)) {
875                 stop_rx();
876 //=                } else {
877                 //                      netif_carrier_on(dev);
878                 //                    printk(KERN_INFO "%s: link up.\n", dev->name);
879                 //          }
880                 start_rx(nic);
881         } else {
882                 //        if (netif_carrier_ok(dev)) {
883                 //              netif_carrier_off(dev);
884                 //            printk(KERN_INFO "%s: link down.\n", dev->name);
885                 stop_rx();
886                 //  }
887         }
888 }
889 #endif
890
891 static int init_ring(struct nic *nic)
892 {
893         int i;
894
895         np->next_tx = np->nic_tx = 0;
896         for (i = 0; i < TX_RING; i++)
897                 tx_ring[i].FlagLen = 0;
898
899         np->cur_rx = 0;
900         np->refill_rx = 0;
901         for (i = 0; i < RX_RING; i++)
902                 rx_ring[i].FlagLen = 0;
903         return alloc_rx(nic);
904 }
905
906 static void set_multicast(struct nic *nic)
907 {
908
909         u8 *base = (u8 *) BASE;
910         u32 addr[2];
911         u32 mask[2];
912         u32 pff;
913         u32 alwaysOff[2];
914         u32 alwaysOn[2];
915
916         memset(addr, 0, sizeof(addr));
917         memset(mask, 0, sizeof(mask));
918
919         pff = NVREG_PFF_MYADDR;
920
921         alwaysOn[0] = alwaysOn[1] = alwaysOff[0] = alwaysOff[1] = 0;
922
923         addr[0] = alwaysOn[0];
924         addr[1] = alwaysOn[1];
925         mask[0] = alwaysOn[0] | alwaysOff[0];
926         mask[1] = alwaysOn[1] | alwaysOff[1];
927
928         addr[0] |= NVREG_MCASTADDRA_FORCE;
929         pff |= NVREG_PFF_ALWAYS;
930         stop_rx();
931         writel(addr[0], base + NvRegMulticastAddrA);
932         writel(addr[1], base + NvRegMulticastAddrB);
933         writel(mask[0], base + NvRegMulticastMaskA);
934         writel(mask[1], base + NvRegMulticastMaskB);
935         writel(pff, base + NvRegPacketFilterFlags);
936         start_rx(nic);
937 }
938
939 /**************************************************************************
940 RESET - Reset the NIC to prepare for use
941 ***************************************************************************/
942 static int forcedeth_reset(struct nic *nic)
943 {
944         u8 *base = (u8 *) BASE;
945         int ret, oom, i;
946         ret = 0;
947         dprintf(("forcedeth: open\n"));
948
949         /* 1) erase previous misconfiguration */
950         /* 4.1-1: stop adapter: ignored, 4.3 seems to be overkill */
951         writel(NVREG_MCASTADDRA_FORCE, base + NvRegMulticastAddrA);
952         writel(0, base + NvRegMulticastAddrB);
953         writel(0, base + NvRegMulticastMaskA);
954         writel(0, base + NvRegMulticastMaskB);
955         writel(0, base + NvRegPacketFilterFlags);
956
957         writel(0, base + NvRegTransmitterControl);
958         writel(0, base + NvRegReceiverControl);
959
960         writel(0, base + NvRegAdapterControl);
961
962         /* 2) initialize descriptor rings */
963         oom = init_ring(nic);
964
965         writel(0, base + NvRegLinkSpeed);
966         writel(0, base + NvRegUnknownTransmitterReg);
967         txrx_reset(nic);
968         writel(0, base + NvRegUnknownSetupReg6);
969
970         np->in_shutdown = 0;
971
972         /* 3) set mac address */
973         {
974                 u32 mac[2];
975
976                 mac[0] =
977                     (nic->node_addr[0] << 0) + (nic->node_addr[1] << 8) +
978                     (nic->node_addr[2] << 16) + (nic->node_addr[3] << 24);
979                 mac[1] =
980                     (nic->node_addr[4] << 0) + (nic->node_addr[5] << 8);
981
982                 writel(mac[0], base + NvRegMacAddrA);
983                 writel(mac[1], base + NvRegMacAddrB);
984         }
985
986         /* 4) give hw rings */
987         writel((u32) virt_to_le32desc(&rx_ring[0]),
988                base + NvRegRxRingPhysAddr);
989         writel((u32) virt_to_le32desc(&tx_ring[0]),
990                base + NvRegTxRingPhysAddr);
991
992         writel(((RX_RING - 1) << NVREG_RINGSZ_RXSHIFT) +
993                ((TX_RING - 1) << NVREG_RINGSZ_TXSHIFT),
994                base + NvRegRingSizes);
995
996         /* 5) continue setup */
997         np->linkspeed = NVREG_LINKSPEED_FORCE | NVREG_LINKSPEED_10;
998         np->duplex = 0;
999         writel(np->linkspeed, base + NvRegLinkSpeed);
1000         writel(NVREG_UNKSETUP3_VAL1, base + NvRegUnknownSetupReg3);
1001         writel(np->desc_ver, base + NvRegTxRxControl);
1002         pci_push(base);
1003         writel(NVREG_TXRXCTL_BIT1 | np->desc_ver, base + NvRegTxRxControl);
1004         reg_delay(NvRegUnknownSetupReg5, NVREG_UNKSETUP5_BIT31,
1005                   NVREG_UNKSETUP5_BIT31, NV_SETUP5_DELAY,
1006                   NV_SETUP5_DELAYMAX,
1007                   "open: SetupReg5, Bit 31 remained off\n");
1008
1009         writel(0, base + NvRegUnknownSetupReg4);
1010 //       writel(NVREG_IRQSTAT_MASK, base + NvRegIrqStatus);
1011         writel(NVREG_MIISTAT_MASK2, base + NvRegMIIStatus);
1012 #if 0
1013         printf("%d-Mbs Link, %s-Duplex\n",
1014                np->linkspeed & NVREG_LINKSPEED_10 ? 10 : 100,
1015                np->duplex ? "Full" : "Half");
1016 #endif
1017
1018         /* 6) continue setup */
1019         writel(NVREG_MISC1_FORCE | NVREG_MISC1_HD, base + NvRegMisc1);
1020         writel(readl(base + NvRegTransmitterStatus),
1021                base + NvRegTransmitterStatus);
1022         writel(NVREG_PFF_ALWAYS, base + NvRegPacketFilterFlags);
1023         writel(NVREG_OFFLOAD_NORMAL, base + NvRegOffloadConfig);
1024
1025         writel(readl(base + NvRegReceiverStatus),
1026                base + NvRegReceiverStatus);
1027
1028         /* Get a random number */
1029         i = random();
1030         writel(NVREG_RNDSEED_FORCE | (i & NVREG_RNDSEED_MASK),
1031                base + NvRegRandomSeed);
1032         writel(NVREG_UNKSETUP1_VAL, base + NvRegUnknownSetupReg1);
1033         writel(NVREG_UNKSETUP2_VAL, base + NvRegUnknownSetupReg2);
1034         writel(NVREG_POLL_DEFAULT, base + NvRegPollingInterval);
1035         writel(NVREG_UNKSETUP6_VAL, base + NvRegUnknownSetupReg6);
1036         writel((np->
1037                 phyaddr << NVREG_ADAPTCTL_PHYSHIFT) |
1038                NVREG_ADAPTCTL_PHYVALID | NVREG_ADAPTCTL_RUNNING,
1039                base + NvRegAdapterControl);
1040         writel(NVREG_MIISPEED_BIT8 | NVREG_MIIDELAY, base + NvRegMIISpeed);
1041         writel(NVREG_UNKSETUP4_VAL, base + NvRegUnknownSetupReg4);
1042         writel(NVREG_WAKEUPFLAGS_VAL, base + NvRegWakeUpFlags);
1043
1044         i = readl(base + NvRegPowerState);
1045         if ((i & NVREG_POWERSTATE_POWEREDUP) == 0)
1046                 writel(NVREG_POWERSTATE_POWEREDUP | i,
1047                        base + NvRegPowerState);
1048
1049         pci_push(base);
1050         udelay(10);
1051         writel(readl(base + NvRegPowerState) | NVREG_POWERSTATE_VALID,
1052                base + NvRegPowerState);
1053
1054         writel(0, base + NvRegIrqMask);
1055         pci_push(base);
1056         writel(NVREG_MIISTAT_MASK2, base + NvRegMIIStatus);
1057         writel(NVREG_IRQSTAT_MASK, base + NvRegIrqStatus);
1058         pci_push(base);
1059 /*
1060         writel(np->irqmask, base + NvRegIrqMask);
1061 */
1062         writel(NVREG_MCASTADDRA_FORCE, base + NvRegMulticastAddrA);
1063         writel(0, base + NvRegMulticastAddrB);
1064         writel(0, base + NvRegMulticastMaskA);
1065         writel(0, base + NvRegMulticastMaskB);
1066         writel(NVREG_PFF_ALWAYS | NVREG_PFF_MYADDR,
1067                base + NvRegPacketFilterFlags);
1068
1069         set_multicast(nic);
1070         /* One manual link speed update: Interrupts are enabled, future link
1071          * speed changes cause interrupts and are handled by nv_link_irq().
1072          */
1073         {
1074                 u32 miistat;
1075                 miistat = readl(base + NvRegMIIStatus);
1076                 writel(NVREG_MIISTAT_MASK, base + NvRegMIIStatus);
1077                 dprintf(("startup: got 0x%hX.\n", miistat));
1078         }
1079         ret = update_linkspeed(nic);
1080
1081         //start_rx(nic);
1082         start_tx(nic);
1083
1084         if (ret) {
1085                 //Start Connection netif_carrier_on(dev);
1086         } else {
1087                 printf("no link during initialization.\n");
1088         }
1089
1090         return ret;
1091 }
1092
1093 /* 
1094  * extern void hex_dump(const char *data, const unsigned int len);
1095 */
1096 /**************************************************************************
1097 POLL - Wait for a frame
1098 ***************************************************************************/
1099 static int forcedeth_poll(struct nic *nic, int retrieve)
1100 {
1101         /* return true if there's an ethernet packet ready to read */
1102         /* nic->packet should contain data on return */
1103         /* nic->packetlen should contain length of data */
1104
1105         int len;
1106         int i;
1107         u32 Flags;
1108
1109         i = np->cur_rx % RX_RING;
1110
1111         Flags = le32_to_cpu(rx_ring[i].FlagLen);
1112         len = nv_descr_getlength(&rx_ring[i], np->desc_ver);
1113
1114         if (Flags & NV_RX_AVAIL)
1115                 return 0;       /* still owned by hardware, */
1116
1117         if (np->desc_ver == DESC_VER_1) {
1118                 if (!(Flags & NV_RX_DESCRIPTORVALID))
1119                         return 0;
1120         } else {
1121                 if (!(Flags & NV_RX2_DESCRIPTORVALID))
1122                         return 0;
1123         }
1124
1125         if (!retrieve)
1126                 return 1;
1127
1128         /* got a valid packet - forward it to the network core */
1129         nic->packetlen = len;
1130         memcpy(nic->packet, rxb + (i * RX_NIC_BUFSIZE), nic->packetlen);
1131 /*
1132  *      hex_dump(rxb + (i * RX_NIC_BUFSIZE), len);
1133 */
1134         wmb();
1135         np->cur_rx++;
1136         alloc_rx(nic);
1137         return 1;
1138 }
1139
1140
1141 /**************************************************************************
1142 TRANSMIT - Transmit a frame
1143 ***************************************************************************/
1144 static void forcedeth_transmit(struct nic *nic, const char *d,  /* Destination */
1145                                unsigned int t,  /* Type */
1146                                unsigned int s,  /* size */
1147                                const char *p)
1148 {                               /* Packet */
1149         /* send the packet to destination */
1150         u8 *ptxb;
1151         u16 nstype;
1152         u8 *base = (u8 *) BASE;
1153         int nr = np->next_tx % TX_RING;
1154
1155         /* point to the current txb incase multiple tx_rings are used */
1156         ptxb = txb + (nr * RX_NIC_BUFSIZE);
1157         //np->tx_skbuff[nr] = ptxb;
1158
1159         /* copy the packet to ring buffer */
1160         memcpy(ptxb, d, ETH_ALEN);      /* dst */
1161         memcpy(ptxb + ETH_ALEN, nic->node_addr, ETH_ALEN);      /* src */
1162         nstype = htons((u16) t);        /* type */
1163         memcpy(ptxb + 2 * ETH_ALEN, (u8 *) & nstype, 2);        /* type */
1164         memcpy(ptxb + ETH_HLEN, p, s);
1165
1166         s += ETH_HLEN;
1167         while (s < ETH_ZLEN)    /* pad to min length */
1168                 ptxb[s++] = '\0';
1169
1170         tx_ring[nr].PacketBuffer = (u32) virt_to_le32desc(ptxb);
1171
1172         wmb();
1173         tx_ring[nr].FlagLen = cpu_to_le32((s - 1) | np->tx_flags);
1174
1175         writel(NVREG_TXRXCTL_KICK | np->desc_ver, base + NvRegTxRxControl);
1176         pci_push(base);
1177         np->next_tx++;
1178 }
1179
1180 /**************************************************************************
1181 DISABLE - Turn off ethernet interface
1182 ***************************************************************************/
1183 static void forcedeth_disable ( struct nic *nic __unused ) {
1184         /* put the card in its initial state */
1185         /* This function serves 3 purposes.
1186          * This disables DMA and interrupts so we don't receive
1187          *  unexpected packets or interrupts from the card after
1188          *  etherboot has finished. 
1189          * This frees resources so etherboot may use
1190          *  this driver on another interface
1191          * This allows etherboot to reinitialize the interface
1192          *  if something is something goes wrong.
1193          */
1194         u8 *base = (u8 *) BASE;
1195         np->in_shutdown = 1;
1196         stop_tx();
1197         stop_rx();
1198
1199         /* disable interrupts on the nic or we will lock up */
1200         writel(0, base + NvRegIrqMask);
1201         pci_push(base);
1202         dprintf(("Irqmask is zero again\n"));
1203
1204         /* specia op:o write back the misordered MAC address - otherwise
1205          * the next probe_nic would see a wrong address.
1206          */
1207         writel(np->orig_mac[0], base + NvRegMacAddrA);
1208         writel(np->orig_mac[1], base + NvRegMacAddrB);
1209 }
1210
1211 /**************************************************************************
1212 IRQ - Enable, Disable, or Force interrupts
1213 ***************************************************************************/
1214 static void forcedeth_irq(struct nic *nic __unused,
1215                           irq_action_t action __unused)
1216 {
1217         switch (action) {
1218         case DISABLE:
1219                 break;
1220         case ENABLE:
1221                 break;
1222         case FORCE:
1223                 break;
1224         }
1225 }
1226
1227 static struct nic_operations forcedeth_operations = {
1228         .connect        = dummy_connect,
1229         .poll           = forcedeth_poll,
1230         .transmit       = forcedeth_transmit,
1231         .irq            = forcedeth_irq,
1232
1233 };
1234
1235 /**************************************************************************
1236 PROBE - Look for an adapter, this routine's visible to the outside
1237 ***************************************************************************/
1238 #define IORESOURCE_MEM 0x00000200
1239 #define board_found 1
1240 #define valid_link 0
1241 static int forcedeth_probe ( struct nic *nic, struct pci_device *pci ) {
1242
1243         unsigned long addr;
1244         int sz;
1245         u8 *base;
1246         int i;
1247         struct pci_device_id *ids = pci->driver->ids;
1248         int id_count = pci->driver->id_count;
1249         unsigned int flags = 0;
1250
1251         if (pci->ioaddr == 0)
1252                 return 0;
1253
1254         printf("forcedeth.c: Found %s, vendor=0x%hX, device=0x%hX\n",
1255                pci->driver_name, pci->vendor, pci->device);
1256
1257         nic->ioaddr = pci->ioaddr;
1258         nic->irqno = 0;
1259
1260         /* point to private storage */
1261         np = &npx;
1262
1263         adjust_pci_device(pci);
1264
1265         addr = pci_bar_start(pci, PCI_BASE_ADDRESS_0);
1266         sz = pci_bar_size(pci, PCI_BASE_ADDRESS_0);
1267
1268         /* BASE is used throughout to address the card */
1269         BASE = (unsigned long) ioremap(addr, sz);
1270         if (!BASE)
1271                 return 0;
1272
1273         /* handle different descriptor versions */
1274         if (pci->device == PCI_DEVICE_ID_NVIDIA_NVENET_1 ||
1275             pci->device == PCI_DEVICE_ID_NVIDIA_NVENET_2 ||
1276             pci->device == PCI_DEVICE_ID_NVIDIA_NVENET_3)
1277                 np->desc_ver = DESC_VER_1;
1278         else
1279                 np->desc_ver = DESC_VER_2;
1280
1281         //rx_ring[0] = rx_ring;
1282         //tx_ring[0] = tx_ring; 
1283
1284         /* read the mac address */
1285         base = (u8 *) BASE;
1286         np->orig_mac[0] = readl(base + NvRegMacAddrA);
1287         np->orig_mac[1] = readl(base + NvRegMacAddrB);
1288
1289         /* lookup the flags from pci_device_id */
1290         for(i = 0; i < id_count; i++) {
1291                 if(pci->vendor == ids[i].vendor &&
1292                    pci->device == ids[i].device) {
1293                         flags = ids[i].driver_data;
1294                         break;
1295                    }
1296         }
1297
1298         /* read MAC address */
1299         if(flags & MAC_ADDR_CORRECT) {
1300                 nic->node_addr[0] = (np->orig_mac[0] >>  0) & 0xff;
1301                 nic->node_addr[1] = (np->orig_mac[0] >>  8) & 0xff;
1302                 nic->node_addr[2] = (np->orig_mac[0] >> 16) & 0xff;
1303                 nic->node_addr[3] = (np->orig_mac[0] >> 24) & 0xff;
1304                 nic->node_addr[4] = (np->orig_mac[1] >>  0) & 0xff;
1305                 nic->node_addr[5] = (np->orig_mac[1] >>  8) & 0xff;
1306         } else {
1307                 nic->node_addr[0] = (np->orig_mac[1] >>  8) & 0xff;
1308                 nic->node_addr[1] = (np->orig_mac[1] >>  0) & 0xff;
1309                 nic->node_addr[2] = (np->orig_mac[0] >> 24) & 0xff;
1310                 nic->node_addr[3] = (np->orig_mac[0] >> 16) & 0xff;
1311                 nic->node_addr[4] = (np->orig_mac[0] >>  8) & 0xff;
1312                 nic->node_addr[5] = (np->orig_mac[0] >>  0) & 0xff;
1313         }
1314 #ifdef LINUX
1315         if (!is_valid_ether_addr(dev->dev_addr)) {
1316                 /*
1317                  * Bad mac address. At least one bios sets the mac address
1318                  * to 01:23:45:67:89:ab
1319                  */
1320                 printk(KERN_ERR
1321                        "%s: Invalid Mac address detected: %02x:%02x:%02x:%02x:%02x:%02x\n",
1322                        pci_name(pci_dev), dev->dev_addr[0],
1323                        dev->dev_addr[1], dev->dev_addr[2],
1324                        dev->dev_addr[3], dev->dev_addr[4],
1325                        dev->dev_addr[5]);
1326                 printk(KERN_ERR
1327                        "Please complain to your hardware vendor. Switching to a random MAC.\n");
1328                 dev->dev_addr[0] = 0x00;
1329                 dev->dev_addr[1] = 0x00;
1330                 dev->dev_addr[2] = 0x6c;
1331                 get_random_bytes(&dev->dev_addr[3], 3);
1332         }
1333 #endif
1334
1335         DBG ( "%s: MAC Address %s\n", pci->driver_name, eth_ntoa ( nic->node_addr ) );
1336
1337         /* disable WOL */
1338         writel(0, base + NvRegWakeUpFlags);
1339         np->wolenabled = 0;
1340         
1341         if (np->desc_ver == DESC_VER_1) {
1342                 np->tx_flags = NV_TX_LASTPACKET | NV_TX_VALID;
1343         } else {
1344                 np->tx_flags = NV_TX2_LASTPACKET | NV_TX2_VALID;
1345         }
1346
1347         switch (pci->device) {
1348         case 0x01C3:            // nforce
1349                 // DEV_IRQMASK_1|DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER,
1350                 np->irqmask = NVREG_IRQMASK_WANTED_2 | NVREG_IRQ_TIMER;
1351                 //              np->need_linktimer = 1;
1352                 //              np->link_timeout = jiffies + LINK_TIMEOUT;
1353                 break;
1354         case 0x0066:
1355                 /* Fall Through */
1356         case 0x00D6:
1357                 // DEV_NEED_LASTPACKET1|DEV_IRQMASK_2|DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER
1358                 np->irqmask = NVREG_IRQMASK_WANTED_2;
1359                 np->irqmask |= NVREG_IRQ_TIMER;
1360                 //              np->need_linktimer = 1;
1361                 //              np->link_timeout = jiffies + LINK_TIMEOUT;
1362                 if (np->desc_ver == DESC_VER_1)
1363                         np->tx_flags |= NV_TX_LASTPACKET1;
1364                 else
1365                         np->tx_flags |= NV_TX2_LASTPACKET1;
1366                 break;
1367         case 0x0373:
1368                 /* Fall Through */
1369         case 0x0086:
1370                 /* Fall Through */
1371         case 0x008c:
1372                 /* Fall Through */
1373         case 0x00e6:
1374                 /* Fall Through */
1375         case 0x00df:
1376                 /* Fall Through */
1377         case 0x0056:
1378                 /* Fall Through */
1379         case 0x0057:
1380                 /* Fall Through */
1381         case 0x0037:
1382                 /* Fall Through */
1383         case 0x0038:
1384                 //DEV_NEED_LASTPACKET1|DEV_IRQMASK_2|DEV_NEED_TIMERIRQ
1385                 np->irqmask = NVREG_IRQMASK_WANTED_2;
1386                 np->irqmask |= NVREG_IRQ_TIMER;
1387                 //              np->need_linktimer = 1;
1388                 //              np->link_timeout = jiffies + LINK_TIMEOUT;
1389                 if (np->desc_ver == DESC_VER_1)
1390                         np->tx_flags |= NV_TX_LASTPACKET1;
1391                 else
1392                         np->tx_flags |= NV_TX2_LASTPACKET1;
1393                 break;
1394         default:
1395                 printf
1396                         ("Your card was undefined in this driver.  Review driver_data in Linux driver and send a patch\n");
1397         }
1398         
1399         /* find a suitable phy */
1400         for (i = 1; i < 32; i++) {
1401                 int id1, id2;
1402                 id1 = mii_rw(nic, i, MII_PHYSID1, MII_READ);
1403                 if (id1 < 0 || id1 == 0xffff)
1404                         continue;
1405                 id2 = mii_rw(nic, i, MII_PHYSID2, MII_READ);
1406                 if (id2 < 0 || id2 == 0xffff)
1407                         continue;
1408                 id1 = (id1 & PHYID1_OUI_MASK) << PHYID1_OUI_SHFT;
1409                 id2 = (id2 & PHYID2_OUI_MASK) >> PHYID2_OUI_SHFT;
1410                 dprintf
1411                         (("%s: open: Found PHY %hX:%hX at address %d.\n",
1412                           pci->driver_name, id1, id2, i));
1413                 np->phyaddr = i;
1414                 np->phy_oui = id1 | id2;
1415                 break;
1416         }
1417         if (i == 32) {
1418                 /* PHY in isolate mode? No phy attached and user wants to
1419                  * test loopback? Very odd, but can be correct.
1420                  */
1421                 printf
1422                         ("%s: open: Could not find a valid PHY.\n", pci->driver_name);
1423         }
1424         
1425         if (i != 32) {
1426                 /* reset it */
1427                 phy_init(nic);
1428         }
1429         
1430         dprintf(("%s: forcedeth.c: subsystem: %hX:%hX bound to %s\n",
1431                  pci->driver_name, pci->vendor, pci->dev_id, pci->driver_name));
1432         if(!forcedeth_reset(nic)) return 0; // no valid link
1433
1434         /* point to NIC specific routines */
1435         nic->nic_op     = &forcedeth_operations;
1436         return 1;
1437 }
1438
1439 static struct pci_device_id forcedeth_nics[] = {
1440 PCI_ROM(0x10de, 0x01C3, "nforce", "nForce NVENET_1 Ethernet Controller", 0),
1441 PCI_ROM(0x10de, 0x0066, "nforce2", "nForce NVENET_2 Ethernet Controller", 0),
1442 PCI_ROM(0x10de, 0x00D6, "nforce3", "nForce NVENET_3 Ethernet Controller", 0),
1443 PCI_ROM(0x10de, 0x0086, "nforce4", "nForce NVENET_4 Ethernet Controller", 0),
1444 PCI_ROM(0x10de, 0x008c, "nforce5", "nForce NVENET_5 Ethernet Controller", 0),
1445 PCI_ROM(0x10de, 0x00e6, "nforce6", "nForce NVENET_6 Ethernet Controller", 0),
1446 PCI_ROM(0x10de, 0x00df, "nforce7", "nForce NVENET_7 Ethernet Controller", 0),
1447 PCI_ROM(0x10de, 0x0056, "nforce8", "nForce NVENET_8 Ethernet Controller", 0),
1448 PCI_ROM(0x10de, 0x0057, "nforce9", "nForce NVENET_9 Ethernet Controller", 0),
1449 PCI_ROM(0x10de, 0x0037, "nforce10", "nForce NVENET_10 Ethernet Controller", 0),
1450 PCI_ROM(0x10de, 0x0038, "nforce11", "nForce NVENET_11 Ethernet Controller", 0),
1451 PCI_ROM(0x10de, 0x0373, "nforce15", "nForce NVENET_15 Ethernet Controller", 0),
1452 PCI_ROM(0x10de, 0x0269, "nforce16", "nForce NVENET_16 Ethernet Controller", 0),
1453 PCI_ROM(0x10de, 0x0760, "nforce17", "nForce NVENET_17 Ethernet Controller", MAC_ADDR_CORRECT),
1454 };
1455
1456 PCI_DRIVER ( forcedeth_driver, forcedeth_nics, PCI_NO_CLASS );
1457
1458 DRIVER ( "forcedeth", nic_driver, pci_driver, forcedeth_driver,
1459          forcedeth_probe, forcedeth_disable );
1460
1461 /*
1462  * Local variables:
1463  *  c-basic-offset: 8
1464  *  c-indent-level: 8
1465  *  tab-width: 8
1466  * End:
1467  */