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