[pci] Add driver_data field to struct pci_device_id
[people/lynusvaz/gpxe.git] / src / drivers / net / r8169.c
1 /*
2  * Copyright (c) 2008 Marty Connor <mdc@etherboot.org>
3  * Copyright (c) 2008 Entity Cyber, Inc.
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License as
7  * published by the Free Software Foundation; either version 2 of the
8  * License, or any later version.
9  *
10  * This program is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18  *
19  * This driver is based on rtl8169 data sheets and work by:
20  *
21  * Copyright (c) 2002 ShuChen <shuchen@realtek.com.tw>
22  * Copyright (c) 2003 - 2007 Francois Romieu <romieu@fr.zoreil.com>
23  * Copyright (c) a lot of people too. Please respect their work.
24  */
25
26 #include <stdint.h>
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <string.h>
30 #include <unistd.h>
31 #include <assert.h>
32 #include <byteswap.h>
33 #include <errno.h>
34 #include <gpxe/ethernet.h>
35 #include <gpxe/if_ether.h>
36 #include <gpxe/io.h>
37 #include <gpxe/iobuf.h>
38 #include <gpxe/malloc.h>
39 #include <gpxe/netdevice.h>
40 #include <gpxe/pci.h>
41 #include <gpxe/timer.h>
42
43 #include "r8169.h"
44
45 /*** Low level hardware routines ***/
46
47 static void mdio_write(void *ioaddr, int reg_addr, int value)
48 {
49         int i;
50
51         DBGP ( "mdio_write\n" );
52
53         RTL_W32(PHYAR, 0x80000000 | (reg_addr & 0x1f) << 16 | (value & 0xffff));
54
55         for (i = 20; i > 0; i--) {
56                 /*
57                  * Check if the RTL8169 has completed writing to the specified
58                  * MII register.
59                  */
60                 if (!(RTL_R32(PHYAR) & 0x80000000))
61                         break;
62                 udelay(25);
63         }
64 }
65
66 static int mdio_read(void *ioaddr, int reg_addr)
67 {
68         int i, value = -1;
69
70         DBGP ( "mdio_read\n" );
71
72         RTL_W32(PHYAR, 0x0 | (reg_addr & 0x1f) << 16);
73
74         for (i = 20; i > 0; i--) {
75                 /*
76                  * Check if the RTL8169 has completed retrieving data from
77                  * the specified MII register.
78                  */
79                 if (RTL_R32(PHYAR) & 0x80000000) {
80                         value = RTL_R32(PHYAR) & 0xffff;
81                         break;
82                 }
83                 udelay(25);
84         }
85         return value;
86 }
87
88 static void mdio_patch(void *ioaddr, int reg_addr, int value)
89 {
90         DBGP ( "mdio_patch\n" );
91
92         mdio_write(ioaddr, reg_addr, mdio_read(ioaddr, reg_addr) | value);
93 }
94
95 static void rtl_ephy_write(void *ioaddr, int reg_addr, int value)
96 {
97         unsigned int i;
98
99         DBGP ( "rtl_ephy_write\n" );
100
101         RTL_W32(EPHYAR, EPHYAR_WRITE_CMD | (value & EPHYAR_DATA_MASK) |
102                 (reg_addr & EPHYAR_REG_MASK) << EPHYAR_REG_SHIFT);
103
104         for (i = 0; i < 100; i++) {
105                 if (!(RTL_R32(EPHYAR) & EPHYAR_FLAG))
106                         break;
107                 udelay(10);
108         }
109 }
110
111 static u16 rtl_ephy_read(void *ioaddr, int reg_addr)
112 {
113         u16 value = 0xffff;
114         unsigned int i;
115
116         DBGP ( "rtl_ephy_read\n" );
117
118         RTL_W32(EPHYAR, (reg_addr & EPHYAR_REG_MASK) << EPHYAR_REG_SHIFT);
119
120         for (i = 0; i < 100; i++) {
121                 if (RTL_R32(EPHYAR) & EPHYAR_FLAG) {
122                         value = RTL_R32(EPHYAR) & EPHYAR_DATA_MASK;
123                         break;
124                 }
125                 udelay(10);
126         }
127
128         return value;
129 }
130
131 static void rtl_csi_write(void *ioaddr, int addr, int value)
132 {
133         unsigned int i;
134
135         DBGP ( "rtl_csi_write\n" );
136
137         RTL_W32(CSIDR, value);
138         RTL_W32(CSIAR, CSIAR_WRITE_CMD | (addr & CSIAR_ADDR_MASK) |
139                 CSIAR_BYTE_ENABLE << CSIAR_BYTE_ENABLE_SHIFT);
140
141         for (i = 0; i < 100; i++) {
142                 if (!(RTL_R32(CSIAR) & CSIAR_FLAG))
143                         break;
144                 udelay(10);
145         }
146 }
147
148 static u32 rtl_csi_read(void *ioaddr, int addr)
149 {
150         u32 value = ~0x00;
151         unsigned int i;
152
153         DBGP ( "rtl_csi_read\n" );
154
155         RTL_W32(CSIAR, (addr & CSIAR_ADDR_MASK) |
156                 CSIAR_BYTE_ENABLE << CSIAR_BYTE_ENABLE_SHIFT);
157
158         for (i = 0; i < 100; i++) {
159                 if (RTL_R32(CSIAR) & CSIAR_FLAG) {
160                         value = RTL_R32(CSIDR);
161                         break;
162                 }
163                 udelay(10);
164         }
165
166         return value;
167 }
168
169 static void rtl8169_irq_mask_and_ack(void *ioaddr)
170 {
171         DBGP ( "rtl8169_irq_mask_and_ack\n" );
172
173         RTL_W16(IntrMask, 0x0000);
174
175         RTL_W16(IntrStatus, 0xffff);
176 }
177
178 static unsigned int rtl8169_tbi_reset_pending(void *ioaddr)
179 {
180         DBGP ( "rtl8169_tbi_reset_pending\n" );
181
182         return RTL_R32(TBICSR) & TBIReset;
183 }
184
185 static unsigned int rtl8169_xmii_reset_pending(void *ioaddr)
186 {
187         DBGP ( "rtl8169_xmii_reset_pending\n" );
188
189         return mdio_read(ioaddr, MII_BMCR) & BMCR_RESET;
190 }
191
192 static unsigned int rtl8169_tbi_link_ok(void *ioaddr)
193 {
194         DBGP ( "rtl8169_tbi_link_ok\n" );
195
196         return RTL_R32(TBICSR) & TBILinkOk;
197 }
198
199 static unsigned int rtl8169_xmii_link_ok(void *ioaddr)
200 {
201         DBGP ( "rtl8169_xmii_link_ok\n" );
202
203         return RTL_R8(PHYstatus) & LinkStatus;
204 }
205
206 static void rtl8169_tbi_reset_enable(void *ioaddr)
207 {
208         DBGP ( "rtl8169_tbi_reset_enable\n" );
209
210         RTL_W32(TBICSR, RTL_R32(TBICSR) | TBIReset);
211 }
212
213 static void rtl8169_xmii_reset_enable(void *ioaddr)
214 {
215         unsigned int val;
216
217         DBGP ( "rtl8169_xmii_reset_enable\n" );
218
219         val = mdio_read(ioaddr, MII_BMCR) | BMCR_RESET;
220         mdio_write(ioaddr, MII_BMCR, val & 0xffff);
221 }
222
223 static int rtl8169_set_speed_tbi(struct net_device *dev,
224                                  u8 autoneg, u16 speed, u8 duplex)
225 {
226         struct rtl8169_private *tp = netdev_priv(dev);
227         void *ioaddr = tp->mmio_addr;
228         int ret = 0;
229         u32 reg;
230
231         DBGP ( "rtl8169_set_speed_tbi\n" );
232
233         reg = RTL_R32(TBICSR);
234         if ((autoneg == AUTONEG_DISABLE) && (speed == SPEED_1000) &&
235             (duplex == DUPLEX_FULL)) {
236                 RTL_W32(TBICSR, reg & ~(TBINwEnable | TBINwRestart));
237         } else if (autoneg == AUTONEG_ENABLE)
238                 RTL_W32(TBICSR, reg | TBINwEnable | TBINwRestart);
239         else {
240                 DBG ( "incorrect speed setting refused in TBI mode\n" );
241                 ret = -EOPNOTSUPP;
242         }
243         return ret;
244 }
245
246 static int rtl8169_set_speed_xmii(struct net_device *dev,
247                                   u8 autoneg, u16 speed, u8 duplex)
248 {
249         struct rtl8169_private *tp = netdev_priv(dev);
250         void *ioaddr = tp->mmio_addr;
251         int auto_nego, giga_ctrl;
252
253         DBGP ( "rtl8169_set_speed_xmii\n" );
254
255         auto_nego = mdio_read(ioaddr, MII_ADVERTISE);
256         auto_nego &= ~(ADVERTISE_10HALF | ADVERTISE_10FULL |
257                        ADVERTISE_100HALF | ADVERTISE_100FULL);
258         giga_ctrl = mdio_read(ioaddr, MII_CTRL1000);
259         giga_ctrl &= ~(ADVERTISE_1000FULL | ADVERTISE_1000HALF);
260
261         if (autoneg == AUTONEG_ENABLE) {
262                 auto_nego |= (ADVERTISE_10HALF | ADVERTISE_10FULL |
263                               ADVERTISE_100HALF | ADVERTISE_100FULL);
264                 giga_ctrl |= ADVERTISE_1000FULL | ADVERTISE_1000HALF;
265         } else {
266                 if (speed == SPEED_10)
267                         auto_nego |= ADVERTISE_10HALF | ADVERTISE_10FULL;
268                 else if (speed == SPEED_100)
269                         auto_nego |= ADVERTISE_100HALF | ADVERTISE_100FULL;
270                 else if (speed == SPEED_1000)
271                         giga_ctrl |= ADVERTISE_1000FULL | ADVERTISE_1000HALF;
272
273                 if (duplex == DUPLEX_HALF)
274                         auto_nego &= ~(ADVERTISE_10FULL | ADVERTISE_100FULL);
275
276                 if (duplex == DUPLEX_FULL)
277                         auto_nego &= ~(ADVERTISE_10HALF | ADVERTISE_100HALF);
278
279                 /* This tweak comes straight from Realtek's driver. */
280                 if ((speed == SPEED_100) && (duplex == DUPLEX_HALF) &&
281                     ((tp->mac_version == RTL_GIGA_MAC_VER_13) ||
282                      (tp->mac_version == RTL_GIGA_MAC_VER_16))) {
283                         auto_nego = ADVERTISE_100HALF | ADVERTISE_CSMA;
284                 }
285         }
286
287         /* The 8100e/8101e/8102e do Fast Ethernet only. */
288         if ((tp->mac_version == RTL_GIGA_MAC_VER_07) ||
289             (tp->mac_version == RTL_GIGA_MAC_VER_08) ||
290             (tp->mac_version == RTL_GIGA_MAC_VER_09) ||
291             (tp->mac_version == RTL_GIGA_MAC_VER_10) ||
292             (tp->mac_version == RTL_GIGA_MAC_VER_13) ||
293             (tp->mac_version == RTL_GIGA_MAC_VER_14) ||
294             (tp->mac_version == RTL_GIGA_MAC_VER_15) ||
295             (tp->mac_version == RTL_GIGA_MAC_VER_16)) {
296                 if ((giga_ctrl & (ADVERTISE_1000FULL | ADVERTISE_1000HALF))) {
297                         DBG ( "PHY does not support 1000Mbps.\n" );
298                 }
299                 giga_ctrl &= ~(ADVERTISE_1000FULL | ADVERTISE_1000HALF);
300         }
301
302         auto_nego |= ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM;
303
304         if ((tp->mac_version == RTL_GIGA_MAC_VER_11) ||
305             (tp->mac_version == RTL_GIGA_MAC_VER_12) ||
306             (tp->mac_version >= RTL_GIGA_MAC_VER_17)) {
307                 /*
308                  * Wake up the PHY.
309                  * Vendor specific (0x1f) and reserved (0x0e) MII registers.
310                  */
311                 mdio_write(ioaddr, 0x1f, 0x0000);
312                 mdio_write(ioaddr, 0x0e, 0x0000);
313         }
314
315         tp->phy_auto_nego_reg = auto_nego;
316         tp->phy_1000_ctrl_reg = giga_ctrl;
317
318         mdio_write(ioaddr, MII_ADVERTISE, auto_nego);
319         mdio_write(ioaddr, MII_CTRL1000, giga_ctrl);
320         mdio_write(ioaddr, MII_BMCR, BMCR_ANENABLE | BMCR_ANRESTART);
321         return 0;
322 }
323
324 static int rtl8169_set_speed(struct net_device *dev,
325                              u8 autoneg, u16 speed, u8 duplex)
326 {
327         struct rtl8169_private *tp = netdev_priv(dev);
328         int ret;
329
330         DBGP ( "rtl8169_set_speed\n" );
331
332         ret = tp->set_speed(dev, autoneg, speed, duplex);
333
334         return ret;
335 }
336
337 static void rtl8169_write_gmii_reg_bit(void *ioaddr, int reg,
338                                        int bitnum, int bitval)
339 {
340         int val;
341
342         DBGP ( "rtl8169_write_gmii_reg_bit\n" );
343
344         val = mdio_read(ioaddr, reg);
345         val = (bitval == 1) ?
346                 val | (bitval << bitnum) :  val & ~(0x0001 << bitnum);
347         mdio_write(ioaddr, reg, val & 0xffff);
348 }
349
350 static void rtl8169_get_mac_version(struct rtl8169_private *tp,
351                                     void *ioaddr)
352 {
353         /*
354          * The driver currently handles the 8168Bf and the 8168Be identically
355          * but they can be identified more specifically through the test below
356          * if needed:
357          *
358          * (RTL_R32(TxConfig) & 0x700000) == 0x500000 ? 8168Bf : 8168Be
359          *
360          * Same thing for the 8101Eb and the 8101Ec:
361          *
362          * (RTL_R32(TxConfig) & 0x700000) == 0x200000 ? 8101Eb : 8101Ec
363          */
364         const struct {
365                 u32 mask;
366                 u32 val;
367                 int mac_version;
368         } mac_info[] = {
369                 /* 8168D family. */
370                 { 0x7c800000, 0x28000000,       RTL_GIGA_MAC_VER_25 },
371
372                 /* 8168C family. */
373                 { 0x7cf00000, 0x3ca00000,       RTL_GIGA_MAC_VER_24 },
374                 { 0x7cf00000, 0x3c900000,       RTL_GIGA_MAC_VER_23 },
375                 { 0x7cf00000, 0x3c800000,       RTL_GIGA_MAC_VER_18 },
376                 { 0x7c800000, 0x3c800000,       RTL_GIGA_MAC_VER_24 },
377                 { 0x7cf00000, 0x3c000000,       RTL_GIGA_MAC_VER_19 },
378                 { 0x7cf00000, 0x3c200000,       RTL_GIGA_MAC_VER_20 },
379                 { 0x7cf00000, 0x3c300000,       RTL_GIGA_MAC_VER_21 },
380                 { 0x7cf00000, 0x3c400000,       RTL_GIGA_MAC_VER_22 },
381                 { 0x7c800000, 0x3c000000,       RTL_GIGA_MAC_VER_22 },
382
383                 /* 8168B family. */
384                 { 0x7cf00000, 0x38000000,       RTL_GIGA_MAC_VER_12 },
385                 { 0x7cf00000, 0x38500000,       RTL_GIGA_MAC_VER_17 },
386                 { 0x7c800000, 0x38000000,       RTL_GIGA_MAC_VER_17 },
387                 { 0x7c800000, 0x30000000,       RTL_GIGA_MAC_VER_11 },
388
389                 /* 8101 family. */
390                 { 0x7cf00000, 0x34a00000,       RTL_GIGA_MAC_VER_09 },
391                 { 0x7cf00000, 0x24a00000,       RTL_GIGA_MAC_VER_09 },
392                 { 0x7cf00000, 0x34900000,       RTL_GIGA_MAC_VER_08 },
393                 { 0x7cf00000, 0x24900000,       RTL_GIGA_MAC_VER_08 },
394                 { 0x7cf00000, 0x34800000,       RTL_GIGA_MAC_VER_07 },
395                 { 0x7cf00000, 0x24800000,       RTL_GIGA_MAC_VER_07 },
396                 { 0x7cf00000, 0x34000000,       RTL_GIGA_MAC_VER_13 },
397                 { 0x7cf00000, 0x34300000,       RTL_GIGA_MAC_VER_10 },
398                 { 0x7cf00000, 0x34200000,       RTL_GIGA_MAC_VER_16 },
399                 { 0x7c800000, 0x34800000,       RTL_GIGA_MAC_VER_09 },
400                 { 0x7c800000, 0x24800000,       RTL_GIGA_MAC_VER_09 },
401                 { 0x7c800000, 0x34000000,       RTL_GIGA_MAC_VER_16 },
402                 /* FIXME: where did these entries come from ? -- FR */
403                 { 0xfc800000, 0x38800000,       RTL_GIGA_MAC_VER_15 },
404                 { 0xfc800000, 0x30800000,       RTL_GIGA_MAC_VER_14 },
405
406                 /* 8110 family. */
407                 { 0xfc800000, 0x98000000,       RTL_GIGA_MAC_VER_06 },
408                 { 0xfc800000, 0x18000000,       RTL_GIGA_MAC_VER_05 },
409                 { 0xfc800000, 0x10000000,       RTL_GIGA_MAC_VER_04 },
410                 { 0xfc800000, 0x04000000,       RTL_GIGA_MAC_VER_03 },
411                 { 0xfc800000, 0x00800000,       RTL_GIGA_MAC_VER_02 },
412                 { 0xfc800000, 0x00000000,       RTL_GIGA_MAC_VER_01 },
413
414                 { 0x00000000, 0x00000000,       RTL_GIGA_MAC_VER_01 }   /* Catch-all */
415         }, *p = mac_info;
416         u32 reg;
417
418         DBGP ( "rtl8169_get_mac_version\n" );
419
420         reg = RTL_R32(TxConfig);
421         while ((reg & p->mask) != p->val)
422                 p++;
423         tp->mac_version = p->mac_version;
424
425         DBG ( "tp->mac_version = %d\n", tp->mac_version );
426
427         if (p->mask == 0x00000000) {
428                 DBG ( "unknown MAC (%08x)\n", reg );
429         }
430 }
431
432 struct phy_reg {
433         u16 reg;
434         u16 val;
435 };
436
437 static void rtl_phy_write(void *ioaddr, struct phy_reg *regs, int len)
438 {
439         DBGP ( "rtl_phy_write\n" );
440
441         while (len-- > 0) {
442                 mdio_write(ioaddr, regs->reg, regs->val);
443                 regs++;
444         }
445 }
446
447 static void rtl8169s_hw_phy_config(void *ioaddr)
448 {
449         struct {
450                 u16 regs[5]; /* Beware of bit-sign propagation */
451         } phy_magic[5] = { {
452                 { 0x0000,       //w 4 15 12 0
453                   0x00a1,       //w 3 15 0 00a1
454                   0x0008,       //w 2 15 0 0008
455                   0x1020,       //w 1 15 0 1020
456                   0x1000 } },{  //w 0 15 0 1000
457                 { 0x7000,       //w 4 15 12 7
458                   0xff41,       //w 3 15 0 ff41
459                   0xde60,       //w 2 15 0 de60
460                   0x0140,       //w 1 15 0 0140
461                   0x0077 } },{  //w 0 15 0 0077
462                 { 0xa000,       //w 4 15 12 a
463                   0xdf01,       //w 3 15 0 df01
464                   0xdf20,       //w 2 15 0 df20
465                   0xff95,       //w 1 15 0 ff95
466                   0xfa00 } },{  //w 0 15 0 fa00
467                 { 0xb000,       //w 4 15 12 b
468                   0xff41,       //w 3 15 0 ff41
469                   0xde20,       //w 2 15 0 de20
470                   0x0140,       //w 1 15 0 0140
471                   0x00bb } },{  //w 0 15 0 00bb
472                 { 0xf000,       //w 4 15 12 f
473                   0xdf01,       //w 3 15 0 df01
474                   0xdf20,       //w 2 15 0 df20
475                   0xff95,       //w 1 15 0 ff95
476                   0xbf00 }      //w 0 15 0 bf00
477                 }
478         }, *p = phy_magic;
479         unsigned int i;
480
481         DBGP ( "rtl8169s_hw_phy_config\n" );
482
483         mdio_write(ioaddr, 0x1f, 0x0001);               //w 31 2 0 1
484         mdio_write(ioaddr, 0x15, 0x1000);               //w 21 15 0 1000
485         mdio_write(ioaddr, 0x18, 0x65c7);               //w 24 15 0 65c7
486         rtl8169_write_gmii_reg_bit(ioaddr, 4, 11, 0);   //w 4 11 11 0
487
488         for (i = 0; i < ARRAY_SIZE(phy_magic); i++, p++) {
489                 int val, pos = 4;
490
491                 val = (mdio_read(ioaddr, pos) & 0x0fff) | (p->regs[0] & 0xffff);
492                 mdio_write(ioaddr, pos, val);
493                 while (--pos >= 0)
494                         mdio_write(ioaddr, pos, p->regs[4 - pos] & 0xffff);
495                 rtl8169_write_gmii_reg_bit(ioaddr, 4, 11, 1); //w 4 11 11 1
496                 rtl8169_write_gmii_reg_bit(ioaddr, 4, 11, 0); //w 4 11 11 0
497         }
498         mdio_write(ioaddr, 0x1f, 0x0000); //w 31 2 0 0
499 }
500
501 static void rtl8169sb_hw_phy_config(void *ioaddr)
502 {
503         struct phy_reg phy_reg_init[] = {
504                 { 0x1f, 0x0002 },
505                 { 0x01, 0x90d0 },
506                 { 0x1f, 0x0000 }
507         };
508
509         DBGP ( "rtl8169sb_hw_phy_config\n" );
510
511         rtl_phy_write(ioaddr, phy_reg_init, ARRAY_SIZE(phy_reg_init));
512 }
513
514 static void rtl8168bb_hw_phy_config(void *ioaddr)
515 {
516         struct phy_reg phy_reg_init[] = {
517                 { 0x10, 0xf41b },
518                 { 0x1f, 0x0000 }
519         };
520
521         mdio_write(ioaddr, 0x1f, 0x0001);
522         mdio_patch(ioaddr, 0x16, 1 << 0);
523
524         DBGP ( "rtl8168bb_hw_phy_config\n" );
525
526         rtl_phy_write(ioaddr, phy_reg_init, ARRAY_SIZE(phy_reg_init));
527 }
528
529 static void rtl8168bef_hw_phy_config(void *ioaddr)
530 {
531         struct phy_reg phy_reg_init[] = {
532                 { 0x1f, 0x0001 },
533                 { 0x10, 0xf41b },
534                 { 0x1f, 0x0000 }
535         };
536
537         DBGP ( "rtl8168bef_hw_phy_config\n" );
538
539         rtl_phy_write(ioaddr, phy_reg_init, ARRAY_SIZE(phy_reg_init));
540 }
541
542 static void rtl8168cp_1_hw_phy_config(void *ioaddr)
543 {
544         struct phy_reg phy_reg_init[] = {
545                 { 0x1f, 0x0000 },
546                 { 0x1d, 0x0f00 },
547                 { 0x1f, 0x0002 },
548                 { 0x0c, 0x1ec8 },
549                 { 0x1f, 0x0000 }
550         };
551
552         DBGP ( "rtl8168cp_1_hw_phy_config\n" );
553
554         rtl_phy_write(ioaddr, phy_reg_init, ARRAY_SIZE(phy_reg_init));
555 }
556
557 static void rtl8168cp_2_hw_phy_config(void *ioaddr)
558 {
559         struct phy_reg phy_reg_init[] = {
560                 { 0x1f, 0x0001 },
561                 { 0x1d, 0x3d98 },
562                 { 0x1f, 0x0000 }
563         };
564
565         DBGP ( "rtl8168cp_2_hw_phy_config\n" );
566
567         mdio_write(ioaddr, 0x1f, 0x0000);
568         mdio_patch(ioaddr, 0x14, 1 << 5);
569         mdio_patch(ioaddr, 0x0d, 1 << 5);
570
571         rtl_phy_write(ioaddr, phy_reg_init, ARRAY_SIZE(phy_reg_init));
572 }
573
574 static void rtl8168c_1_hw_phy_config(void *ioaddr)
575 {
576         struct phy_reg phy_reg_init[] = {
577                 { 0x1f, 0x0001 },
578                 { 0x12, 0x2300 },
579                 { 0x1f, 0x0002 },
580                 { 0x00, 0x88d4 },
581                 { 0x01, 0x82b1 },
582                 { 0x03, 0x7002 },
583                 { 0x08, 0x9e30 },
584                 { 0x09, 0x01f0 },
585                 { 0x0a, 0x5500 },
586                 { 0x0c, 0x00c8 },
587                 { 0x1f, 0x0003 },
588                 { 0x12, 0xc096 },
589                 { 0x16, 0x000a },
590                 { 0x1f, 0x0000 },
591                 { 0x1f, 0x0000 },
592                 { 0x09, 0x2000 },
593                 { 0x09, 0x0000 }
594         };
595
596         DBGP ( "rtl8168c_1_hw_phy_config\n" );
597
598         rtl_phy_write(ioaddr, phy_reg_init, ARRAY_SIZE(phy_reg_init));
599
600         mdio_patch(ioaddr, 0x14, 1 << 5);
601         mdio_patch(ioaddr, 0x0d, 1 << 5);
602         mdio_write(ioaddr, 0x1f, 0x0000);
603 }
604
605 static void rtl8168c_2_hw_phy_config(void *ioaddr)
606 {
607         struct phy_reg phy_reg_init[] = {
608                 { 0x1f, 0x0001 },
609                 { 0x12, 0x2300 },
610                 { 0x03, 0x802f },
611                 { 0x02, 0x4f02 },
612                 { 0x01, 0x0409 },
613                 { 0x00, 0xf099 },
614                 { 0x04, 0x9800 },
615                 { 0x04, 0x9000 },
616                 { 0x1d, 0x3d98 },
617                 { 0x1f, 0x0002 },
618                 { 0x0c, 0x7eb8 },
619                 { 0x06, 0x0761 },
620                 { 0x1f, 0x0003 },
621                 { 0x16, 0x0f0a },
622                 { 0x1f, 0x0000 }
623         };
624
625         DBGP ( "rtl8168c_2_hw_phy_config\n" );
626
627         rtl_phy_write(ioaddr, phy_reg_init, ARRAY_SIZE(phy_reg_init));
628
629         mdio_patch(ioaddr, 0x16, 1 << 0);
630         mdio_patch(ioaddr, 0x14, 1 << 5);
631         mdio_patch(ioaddr, 0x0d, 1 << 5);
632         mdio_write(ioaddr, 0x1f, 0x0000);
633 }
634
635 static void rtl8168c_3_hw_phy_config(void *ioaddr)
636 {
637         struct phy_reg phy_reg_init[] = {
638                 { 0x1f, 0x0001 },
639                 { 0x12, 0x2300 },
640                 { 0x1d, 0x3d98 },
641                 { 0x1f, 0x0002 },
642                 { 0x0c, 0x7eb8 },
643                 { 0x06, 0x5461 },
644                 { 0x1f, 0x0003 },
645                 { 0x16, 0x0f0a },
646                 { 0x1f, 0x0000 }
647         };
648
649         DBGP ( "rtl8168c_3_hw_phy_config\n" );
650
651         rtl_phy_write(ioaddr, phy_reg_init, ARRAY_SIZE(phy_reg_init));
652
653         mdio_patch(ioaddr, 0x16, 1 << 0);
654         mdio_patch(ioaddr, 0x14, 1 << 5);
655         mdio_patch(ioaddr, 0x0d, 1 << 5);
656         mdio_write(ioaddr, 0x1f, 0x0000);
657 }
658
659 static void rtl8168c_4_hw_phy_config(void *ioaddr)
660 {
661         DBGP ( "rtl8168c_4_hw_phy_config\n" );
662
663         rtl8168c_3_hw_phy_config(ioaddr);
664 }
665
666 static void rtl8168d_hw_phy_config(void *ioaddr)
667 {
668         struct phy_reg phy_reg_init_0[] = {
669                 { 0x1f, 0x0001 },
670                 { 0x09, 0x2770 },
671                 { 0x08, 0x04d0 },
672                 { 0x0b, 0xad15 },
673                 { 0x0c, 0x5bf0 },
674                 { 0x1c, 0xf101 },
675                 { 0x1f, 0x0003 },
676                 { 0x14, 0x94d7 },
677                 { 0x12, 0xf4d6 },
678                 { 0x09, 0xca0f },
679                 { 0x1f, 0x0002 },
680                 { 0x0b, 0x0b10 },
681                 { 0x0c, 0xd1f7 },
682                 { 0x1f, 0x0002 },
683                 { 0x06, 0x5461 },
684                 { 0x1f, 0x0002 },
685                 { 0x05, 0x6662 },
686                 { 0x1f, 0x0000 },
687                 { 0x14, 0x0060 },
688                 { 0x1f, 0x0000 },
689                 { 0x0d, 0xf8a0 },
690                 { 0x1f, 0x0005 },
691                 { 0x05, 0xffc2 }
692         };
693
694         DBGP ( "rtl8168d_hw_phy_config\n" );
695
696         rtl_phy_write(ioaddr, phy_reg_init_0, ARRAY_SIZE(phy_reg_init_0));
697
698         if (mdio_read(ioaddr, 0x06) == 0xc400) {
699                 struct phy_reg phy_reg_init_1[] = {
700                         { 0x1f, 0x0005 },
701                         { 0x01, 0x0300 },
702                         { 0x1f, 0x0000 },
703                         { 0x11, 0x401c },
704                         { 0x16, 0x4100 },
705                         { 0x1f, 0x0005 },
706                         { 0x07, 0x0010 },
707                         { 0x05, 0x83dc },
708                         { 0x06, 0x087d },
709                         { 0x05, 0x8300 },
710                         { 0x06, 0x0101 },
711                         { 0x06, 0x05f8 },
712                         { 0x06, 0xf9fa },
713                         { 0x06, 0xfbef },
714                         { 0x06, 0x79e2 },
715                         { 0x06, 0x835f },
716                         { 0x06, 0xe0f8 },
717                         { 0x06, 0x9ae1 },
718                         { 0x06, 0xf89b },
719                         { 0x06, 0xef31 },
720                         { 0x06, 0x3b65 },
721                         { 0x06, 0xaa07 },
722                         { 0x06, 0x81e4 },
723                         { 0x06, 0xf89a },
724                         { 0x06, 0xe5f8 },
725                         { 0x06, 0x9baf },
726                         { 0x06, 0x06ae },
727                         { 0x05, 0x83dc },
728                         { 0x06, 0x8300 },
729                 };
730
731                 rtl_phy_write(ioaddr, phy_reg_init_1,
732                               ARRAY_SIZE(phy_reg_init_1));
733         }
734
735         mdio_write(ioaddr, 0x1f, 0x0000);
736 }
737
738 static void rtl8102e_hw_phy_config(void *ioaddr)
739 {
740         struct phy_reg phy_reg_init[] = {
741                 { 0x1f, 0x0003 },
742                 { 0x08, 0x441d },
743                 { 0x01, 0x9100 },
744                 { 0x1f, 0x0000 }
745         };
746
747         DBGP ( "rtl8102e_hw_phy_config\n" );
748
749         mdio_write(ioaddr, 0x1f, 0x0000);
750         mdio_patch(ioaddr, 0x11, 1 << 12);
751         mdio_patch(ioaddr, 0x19, 1 << 13);
752
753         rtl_phy_write(ioaddr, phy_reg_init, ARRAY_SIZE(phy_reg_init));
754 }
755
756 static void rtl_hw_phy_config(struct net_device *dev)
757 {
758         struct rtl8169_private *tp = netdev_priv(dev);
759         void *ioaddr = tp->mmio_addr;
760
761         DBGP ( "rtl_hw_phy_config\n" );
762
763         DBG ( "mac_version = 0x%02x\n", tp->mac_version );
764
765         switch (tp->mac_version) {
766         case RTL_GIGA_MAC_VER_01:
767                 break;
768         case RTL_GIGA_MAC_VER_02:
769         case RTL_GIGA_MAC_VER_03:
770                 rtl8169s_hw_phy_config(ioaddr);
771                 break;
772         case RTL_GIGA_MAC_VER_04:
773                 rtl8169sb_hw_phy_config(ioaddr);
774                 break;
775         case RTL_GIGA_MAC_VER_07:
776         case RTL_GIGA_MAC_VER_08:
777         case RTL_GIGA_MAC_VER_09:
778                 rtl8102e_hw_phy_config(ioaddr);
779                 break;
780         case RTL_GIGA_MAC_VER_11:
781                 rtl8168bb_hw_phy_config(ioaddr);
782                 break;
783         case RTL_GIGA_MAC_VER_12:
784                 rtl8168bef_hw_phy_config(ioaddr);
785                 break;
786         case RTL_GIGA_MAC_VER_17:
787                 rtl8168bef_hw_phy_config(ioaddr);
788                 break;
789         case RTL_GIGA_MAC_VER_18:
790                 rtl8168cp_1_hw_phy_config(ioaddr);
791                 break;
792         case RTL_GIGA_MAC_VER_19:
793                 rtl8168c_1_hw_phy_config(ioaddr);
794                 break;
795         case RTL_GIGA_MAC_VER_20:
796                 rtl8168c_2_hw_phy_config(ioaddr);
797                 break;
798         case RTL_GIGA_MAC_VER_21:
799                 rtl8168c_3_hw_phy_config(ioaddr);
800                 break;
801         case RTL_GIGA_MAC_VER_22:
802                 rtl8168c_4_hw_phy_config(ioaddr);
803                 break;
804         case RTL_GIGA_MAC_VER_23:
805         case RTL_GIGA_MAC_VER_24:
806                 rtl8168cp_2_hw_phy_config(ioaddr);
807                 break;
808         case RTL_GIGA_MAC_VER_25:
809                 rtl8168d_hw_phy_config(ioaddr);
810                 break;
811
812         default:
813                 break;
814         }
815 }
816
817 static void rtl8169_phy_reset(struct net_device *dev __unused,
818                               struct rtl8169_private *tp)
819 {
820         void *ioaddr = tp->mmio_addr;
821         unsigned int i;
822
823         DBGP ( "rtl8169_phy_reset\n" );
824
825         tp->phy_reset_enable(ioaddr);
826         for (i = 0; i < 100; i++) {
827                 if (!tp->phy_reset_pending(ioaddr))
828                         return;
829                 mdelay ( 1 );
830         }
831         DBG ( "PHY reset failed.\n" );
832 }
833
834 static void rtl8169_init_phy(struct net_device *dev, struct rtl8169_private *tp)
835 {
836         void *ioaddr = tp->mmio_addr;
837
838         DBGP ( "rtl8169_init_phy\n" );
839
840         rtl_hw_phy_config(dev);
841
842         if (tp->mac_version <= RTL_GIGA_MAC_VER_06) {
843                 DBG ( "Set MAC Reg C+CR Offset 0x82h = 0x01h\n" );
844                 RTL_W8(0x82, 0x01);
845         }
846
847         pci_write_config_byte(tp->pci_dev, PCI_LATENCY_TIMER, 0x40);
848
849         if (tp->mac_version <= RTL_GIGA_MAC_VER_06)
850                 pci_write_config_byte(tp->pci_dev, PCI_CACHE_LINE_SIZE, 0x08);
851
852         if (tp->mac_version == RTL_GIGA_MAC_VER_02) {
853                 DBG ( "Set MAC Reg C+CR Offset 0x82h = 0x01h\n" );
854                 RTL_W8(0x82, 0x01);
855                 DBG ( "Set PHY Reg 0x0bh = 0x00h\n" );
856                 mdio_write(ioaddr, 0x0b, 0x0000); //w 0x0b 15 0 0
857         }
858
859         rtl8169_phy_reset(dev, tp);
860
861         /*
862          * rtl8169_set_speed_xmii takes good care of the Fast Ethernet
863          * only 8101. Don't panic.
864          */
865         rtl8169_set_speed(dev, AUTONEG_ENABLE, SPEED_1000, DUPLEX_FULL);
866
867         if ((RTL_R8(PHYstatus) & TBI_Enable))
868                 DBG ( "TBI auto-negotiating\n" );
869 }
870
871 static const struct rtl_cfg_info {
872         void (*hw_start)(struct net_device *);
873         unsigned int region;
874         unsigned int align;
875         u16 intr_event;
876         u16 napi_event;
877         unsigned features;
878 } rtl_cfg_infos [] = {
879         [RTL_CFG_0] = {
880                 .hw_start       = rtl_hw_start_8169,
881                 .region         = 1,
882                 .align          = 0,
883                 .intr_event     = SYSErr | LinkChg | RxOverflow |
884                                   RxFIFOOver | TxErr | TxOK | RxOK | RxErr,
885                 .napi_event     = RxFIFOOver | TxErr | TxOK | RxOK | RxOverflow,
886                 .features       = RTL_FEATURE_GMII
887         },
888         [RTL_CFG_1] = {
889                 .hw_start       = rtl_hw_start_8168,
890                 .region         = 2,
891                 .align          = 8,
892                 .intr_event     = SYSErr | LinkChg | RxOverflow |
893                                   TxErr | TxOK | RxOK | RxErr,
894                 .napi_event     = TxErr | TxOK | RxOK | RxOverflow,
895                 .features       = RTL_FEATURE_GMII
896         },
897         [RTL_CFG_2] = {
898                 .hw_start       = rtl_hw_start_8101,
899                 .region         = 2,
900                 .align          = 8,
901                 .intr_event     = SYSErr | LinkChg | RxOverflow | PCSTimeout |
902                                   RxFIFOOver | TxErr | TxOK | RxOK | RxErr,
903                 .napi_event     = RxFIFOOver | TxErr | TxOK | RxOK | RxOverflow,
904         }
905 };
906
907 static void rtl8169_hw_reset(void *ioaddr)
908 {
909         DBGP ( "rtl8169_hw_reset\n" );
910
911         /* Disable interrupts */
912         rtl8169_irq_mask_and_ack(ioaddr);
913
914         /* Reset the chipset */
915         RTL_W8(ChipCmd, CmdReset);
916
917         /* PCI commit */
918         RTL_R8(ChipCmd);
919 }
920
921 static void rtl_set_rx_tx_config_registers(struct rtl8169_private *tp)
922 {
923         void *ioaddr = tp->mmio_addr;
924         u32 cfg = rtl8169_rx_config;
925
926         DBGP ( "rtl_set_rx_tx_config_registers\n" );
927
928         cfg |= (RTL_R32(RxConfig) & rtl_chip_info[tp->chipset].RxConfigMask);
929         RTL_W32(RxConfig, cfg);
930
931         /* Set DMA burst size and Interframe Gap Time */
932         RTL_W32(TxConfig, (TX_DMA_BURST << TxDMAShift) |
933                 (InterFrameGap << TxInterFrameGapShift));
934 }
935
936 static void rtl_soft_reset ( struct net_device *dev )
937 {
938         struct rtl8169_private *tp = netdev_priv(dev);
939         void *ioaddr = tp->mmio_addr;
940         unsigned int i;
941
942         DBGP ( "rtl_hw_soft_reset\n" );
943
944         /* Soft reset the chip. */
945         RTL_W8(ChipCmd, CmdReset);
946
947         /* Check that the chip has finished the reset. */
948         for (i = 0; i < 100; i++) {
949                 if ((RTL_R8(ChipCmd) & CmdReset) == 0)
950                         break;
951                 mdelay ( 1 );
952         }
953
954         if ( i == 100 ) {
955                 DBG ( "Reset Failed! (> 100 iterations)\n" );
956         }
957 }
958
959 static void rtl_hw_start ( struct net_device *dev )
960 {
961         struct rtl8169_private *tp = netdev_priv ( dev );
962
963         DBGP ( "rtl_hw_start\n" );
964
965         /* Soft reset NIC */
966         rtl_soft_reset ( dev );
967
968         tp->hw_start ( dev );
969 }
970
971 static void rtl_set_rx_tx_desc_registers(struct rtl8169_private *tp,
972                                          void *ioaddr)
973 {
974         DBGP ( "rtl_set_rx_tx_desc_registers\n" );
975
976         /*
977          * Magic spell: some iop3xx ARM board needs the TxDescAddrHigh
978          * register to be written before TxDescAddrLow to work.
979          * Switching from MMIO to I/O access fixes the issue as well.
980          */
981         RTL_W32 ( TxDescStartAddrHigh, 0 );
982         RTL_W32 ( TxDescStartAddrLow, virt_to_bus ( tp->tx_base ) );
983         RTL_W32 ( RxDescAddrHigh, 0 );
984         RTL_W32 ( RxDescAddrLow, virt_to_bus ( tp->rx_base ) );
985 }
986
987 static u16 rtl_rw_cpluscmd(void *ioaddr)
988 {
989         u16 cmd;
990
991         DBGP ( "rtl_rw_cpluscmd\n" );
992
993         cmd = RTL_R16(CPlusCmd);
994         RTL_W16(CPlusCmd, cmd);
995         return cmd;
996 }
997
998 static void rtl_set_rx_max_size(void *ioaddr)
999 {
1000         DBGP ( "rtl_set_rx_max_size\n" );
1001
1002         RTL_W16 ( RxMaxSize, RX_BUF_SIZE );
1003 }
1004
1005 static void rtl8169_set_magic_reg(void *ioaddr, unsigned mac_version)
1006 {
1007         struct {
1008                 u32 mac_version;
1009                 u32 clk;
1010                 u32 val;
1011         } cfg2_info [] = {
1012                 { RTL_GIGA_MAC_VER_05, PCI_Clock_33MHz, 0x000fff00 }, // 8110SCd
1013                 { RTL_GIGA_MAC_VER_05, PCI_Clock_66MHz, 0x000fffff },
1014                 { RTL_GIGA_MAC_VER_06, PCI_Clock_33MHz, 0x00ffff00 }, // 8110SCe
1015                 { RTL_GIGA_MAC_VER_06, PCI_Clock_66MHz, 0x00ffffff }
1016         }, *p = cfg2_info;
1017         unsigned int i;
1018         u32 clk;
1019
1020         DBGP ( "rtl8169_set_magic_reg\n" );
1021
1022         clk = RTL_R8(Config2) & PCI_Clock_66MHz;
1023         for (i = 0; i < ARRAY_SIZE(cfg2_info); i++, p++) {
1024                 if ((p->mac_version == mac_version) && (p->clk == clk)) {
1025                         RTL_W32(0x7c, p->val);
1026                         break;
1027                 }
1028         }
1029 }
1030
1031 static void rtl_set_rx_mode ( struct net_device *netdev )
1032 {
1033         struct rtl8169_private *tp = netdev_priv ( netdev );
1034         void *ioaddr = tp->mmio_addr;
1035         u32 tmp;
1036
1037         DBGP ( "rtl_set_rx_mode\n" );
1038
1039         /* Accept all Multicast Packets */
1040
1041         RTL_W32 ( MAR0 + 0, 0xffffffff );
1042         RTL_W32 ( MAR0 + 4, 0xffffffff );
1043
1044         tmp = rtl8169_rx_config | AcceptBroadcast | AcceptMulticast | AcceptMyPhys |
1045               ( RTL_R32 ( RxConfig ) & rtl_chip_info[tp->chipset].RxConfigMask );
1046
1047         RTL_W32 ( RxConfig, tmp );
1048 }
1049
1050 static void rtl_hw_start_8169(struct net_device *dev)
1051 {
1052         struct rtl8169_private *tp = netdev_priv(dev);
1053         void *ioaddr = tp->mmio_addr;
1054         struct pci_device *pdev = tp->pci_dev;
1055
1056         DBGP ( "rtl_hw_start_8169\n" );
1057
1058         if (tp->mac_version == RTL_GIGA_MAC_VER_05) {
1059                 RTL_W16(CPlusCmd, RTL_R16(CPlusCmd) | PCIMulRW);
1060                 pci_write_config_byte(pdev, PCI_CACHE_LINE_SIZE, 0x08);
1061         }
1062
1063         RTL_W8(Cfg9346, Cfg9346_Unlock);
1064
1065         if ((tp->mac_version == RTL_GIGA_MAC_VER_01) ||
1066             (tp->mac_version == RTL_GIGA_MAC_VER_02) ||
1067             (tp->mac_version == RTL_GIGA_MAC_VER_03) ||
1068             (tp->mac_version == RTL_GIGA_MAC_VER_04))
1069                 RTL_W8(ChipCmd, CmdTxEnb | CmdRxEnb);
1070
1071         RTL_W8(EarlyTxThres, EarlyTxThld);
1072
1073         rtl_set_rx_max_size(ioaddr);
1074
1075         if ((tp->mac_version == RTL_GIGA_MAC_VER_01) ||
1076             (tp->mac_version == RTL_GIGA_MAC_VER_02) ||
1077             (tp->mac_version == RTL_GIGA_MAC_VER_03) ||
1078             (tp->mac_version == RTL_GIGA_MAC_VER_04))
1079                 rtl_set_rx_tx_config_registers(tp);
1080
1081         tp->cp_cmd |= rtl_rw_cpluscmd(ioaddr) | PCIMulRW;
1082
1083         if ((tp->mac_version == RTL_GIGA_MAC_VER_02) ||
1084             (tp->mac_version == RTL_GIGA_MAC_VER_03)) {
1085                 DBG ( "Set MAC Reg C+CR Offset 0xE0. "
1086                         "Bit-3 and bit-14 MUST be 1\n" );
1087                 tp->cp_cmd |= (1 << 14);
1088         }
1089
1090         RTL_W16(CPlusCmd, tp->cp_cmd);
1091
1092         rtl8169_set_magic_reg(ioaddr, tp->mac_version);
1093
1094         /*
1095          * Undocumented corner. Supposedly:
1096          * (TxTimer << 12) | (TxPackets << 8) | (RxTimer << 4) | RxPackets
1097          */
1098         RTL_W16(IntrMitigate, 0x0000);
1099
1100         rtl_set_rx_tx_desc_registers(tp, ioaddr);
1101
1102         if ((tp->mac_version != RTL_GIGA_MAC_VER_01) &&
1103             (tp->mac_version != RTL_GIGA_MAC_VER_02) &&
1104             (tp->mac_version != RTL_GIGA_MAC_VER_03) &&
1105             (tp->mac_version != RTL_GIGA_MAC_VER_04)) {
1106                 RTL_W8(ChipCmd, CmdTxEnb | CmdRxEnb);
1107                 rtl_set_rx_tx_config_registers(tp);
1108         }
1109
1110         RTL_W8(Cfg9346, Cfg9346_Lock);
1111
1112         /* Initially a 10 us delay. Turned it into a PCI commit. - FR */
1113         RTL_R8(IntrMask);
1114
1115         RTL_W32(RxMissed, 0);
1116
1117         rtl_set_rx_mode(dev);
1118
1119         /* no early-rx interrupts */
1120         RTL_W16(MultiIntr, RTL_R16(MultiIntr) & 0xF000);
1121
1122         //        RTL_W16(IntrMask, tp->intr_event);
1123 }
1124
1125 static void rtl_tx_performance_tweak(struct pci_device *pdev, u16 force)
1126 {
1127         struct net_device *dev = pci_get_drvdata(pdev);
1128         struct rtl8169_private *tp = netdev_priv(dev);
1129         int cap = tp->pcie_cap;
1130
1131         DBGP ( "rtl_tx_performance_tweak\n" );
1132
1133         if (cap) {
1134                 u16 ctl;
1135
1136                 pci_read_config_word(pdev, cap + PCI_EXP_DEVCTL, &ctl);
1137                 ctl = (ctl & ~PCI_EXP_DEVCTL_READRQ) | force;
1138                 pci_write_config_word(pdev, cap + PCI_EXP_DEVCTL, ctl);
1139         }
1140 }
1141
1142 static void rtl_csi_access_enable(void *ioaddr)
1143 {
1144         u32 csi;
1145
1146         DBGP ( "rtl_csi_access_enable\n" );
1147
1148         csi = rtl_csi_read(ioaddr, 0x070c) & 0x00ffffff;
1149         rtl_csi_write(ioaddr, 0x070c, csi | 0x27000000);
1150 }
1151
1152 struct ephy_info {
1153         unsigned int offset;
1154         u16 mask;
1155         u16 bits;
1156 };
1157
1158 static void rtl_ephy_init(void *ioaddr, struct ephy_info *e, int len)
1159 {
1160         u16 w;
1161
1162         DBGP ( "rtl_ephy_init\n" );
1163
1164         while (len-- > 0) {
1165                 w = (rtl_ephy_read(ioaddr, e->offset) & ~e->mask) | e->bits;
1166                 rtl_ephy_write(ioaddr, e->offset, w);
1167                 e++;
1168         }
1169 }
1170
1171 static void rtl_disable_clock_request(struct pci_device *pdev)
1172 {
1173         struct net_device *dev = pci_get_drvdata(pdev);
1174         struct rtl8169_private *tp = netdev_priv(dev);
1175         int cap = tp->pcie_cap;
1176
1177         DBGP ( "rtl_disable_clock_request\n" );
1178
1179         if (cap) {
1180                 u16 ctl;
1181
1182                 pci_read_config_word(pdev, cap + PCI_EXP_LNKCTL, &ctl);
1183                 ctl &= ~PCI_EXP_LNKCTL_CLKREQ_EN;
1184                 pci_write_config_word(pdev, cap + PCI_EXP_LNKCTL, ctl);
1185         }
1186 }
1187
1188 #define R8168_CPCMD_QUIRK_MASK (\
1189         EnableBist | \
1190         Mac_dbgo_oe | \
1191         Force_half_dup | \
1192         Force_rxflow_en | \
1193         Force_txflow_en | \
1194         Cxpl_dbg_sel | \
1195         ASF | \
1196         PktCntrDisable | \
1197         Mac_dbgo_sel)
1198
1199 static void rtl_hw_start_8168bb(void *ioaddr, struct pci_device *pdev)
1200 {
1201         DBGP ( "rtl_hw_start_8168bb\n" );
1202
1203         RTL_W8(Config3, RTL_R8(Config3) & ~Beacon_en);
1204
1205         RTL_W16(CPlusCmd, RTL_R16(CPlusCmd) & ~R8168_CPCMD_QUIRK_MASK);
1206
1207         rtl_tx_performance_tweak(pdev,
1208                 (0x5 << MAX_READ_REQUEST_SHIFT) | PCI_EXP_DEVCTL_NOSNOOP_EN);
1209 }
1210
1211 static void rtl_hw_start_8168bef(void *ioaddr, struct pci_device *pdev)
1212 {
1213         DBGP ( "rtl_hw_start_8168bef\n" );
1214
1215         rtl_hw_start_8168bb(ioaddr, pdev);
1216
1217         RTL_W8(EarlyTxThres, EarlyTxThld);
1218
1219         RTL_W8(Config4, RTL_R8(Config4) & ~(1 << 0));
1220 }
1221
1222 static void __rtl_hw_start_8168cp(void *ioaddr, struct pci_device *pdev)
1223 {
1224         DBGP ( "__rtl_hw_start_8168cp\n" );
1225
1226         RTL_W8(Config1, RTL_R8(Config1) | Speed_down);
1227
1228         RTL_W8(Config3, RTL_R8(Config3) & ~Beacon_en);
1229
1230         rtl_tx_performance_tweak(pdev, 0x5 << MAX_READ_REQUEST_SHIFT);
1231
1232         rtl_disable_clock_request(pdev);
1233
1234         RTL_W16(CPlusCmd, RTL_R16(CPlusCmd) & ~R8168_CPCMD_QUIRK_MASK);
1235 }
1236
1237 static void rtl_hw_start_8168cp_1(void *ioaddr, struct pci_device *pdev)
1238 {
1239         static struct ephy_info e_info_8168cp[] = {
1240                 { 0x01, 0,      0x0001 },
1241                 { 0x02, 0x0800, 0x1000 },
1242                 { 0x03, 0,      0x0042 },
1243                 { 0x06, 0x0080, 0x0000 },
1244                 { 0x07, 0,      0x2000 }
1245         };
1246
1247         DBGP ( "rtl_hw_start_8168cp_1\n" );
1248
1249         rtl_csi_access_enable(ioaddr);
1250
1251         rtl_ephy_init(ioaddr, e_info_8168cp, ARRAY_SIZE(e_info_8168cp));
1252
1253         __rtl_hw_start_8168cp(ioaddr, pdev);
1254 }
1255
1256 static void rtl_hw_start_8168cp_2(void *ioaddr, struct pci_device *pdev)
1257 {
1258         DBGP ( "rtl_hw_start_8168cp_2\n" );
1259
1260         rtl_csi_access_enable(ioaddr);
1261
1262         RTL_W8(Config3, RTL_R8(Config3) & ~Beacon_en);
1263
1264         rtl_tx_performance_tweak(pdev, 0x5 << MAX_READ_REQUEST_SHIFT);
1265
1266         RTL_W16(CPlusCmd, RTL_R16(CPlusCmd) & ~R8168_CPCMD_QUIRK_MASK);
1267 }
1268
1269 static void rtl_hw_start_8168cp_3(void *ioaddr, struct pci_device *pdev)
1270 {
1271         DBGP ( "rtl_hw_start_8168cp_3\n" );
1272
1273         rtl_csi_access_enable(ioaddr);
1274
1275         RTL_W8(Config3, RTL_R8(Config3) & ~Beacon_en);
1276
1277         /* Magic. */
1278         RTL_W8(DBG_REG, 0x20);
1279
1280         RTL_W8(EarlyTxThres, EarlyTxThld);
1281
1282         rtl_tx_performance_tweak(pdev, 0x5 << MAX_READ_REQUEST_SHIFT);
1283
1284         RTL_W16(CPlusCmd, RTL_R16(CPlusCmd) & ~R8168_CPCMD_QUIRK_MASK);
1285 }
1286
1287 static void rtl_hw_start_8168c_1(void *ioaddr, struct pci_device *pdev)
1288 {
1289         static struct ephy_info e_info_8168c_1[] = {
1290                 { 0x02, 0x0800, 0x1000 },
1291                 { 0x03, 0,      0x0002 },
1292                 { 0x06, 0x0080, 0x0000 }
1293         };
1294
1295         DBGP ( "rtl_hw_start_8168c_1\n" );
1296
1297         rtl_csi_access_enable(ioaddr);
1298
1299         RTL_W8(DBG_REG, 0x06 | FIX_NAK_1 | FIX_NAK_2);
1300
1301         rtl_ephy_init(ioaddr, e_info_8168c_1, ARRAY_SIZE(e_info_8168c_1));
1302
1303         __rtl_hw_start_8168cp(ioaddr, pdev);
1304 }
1305
1306 static void rtl_hw_start_8168c_2(void *ioaddr, struct pci_device *pdev)
1307 {
1308         static struct ephy_info e_info_8168c_2[] = {
1309                 { 0x01, 0,      0x0001 },
1310                 { 0x03, 0x0400, 0x0220 }
1311         };
1312
1313         DBGP ( "rtl_hw_start_8168c_2\n" );
1314
1315         rtl_csi_access_enable(ioaddr);
1316
1317         rtl_ephy_init(ioaddr, e_info_8168c_2, ARRAY_SIZE(e_info_8168c_2));
1318
1319         __rtl_hw_start_8168cp(ioaddr, pdev);
1320 }
1321
1322 static void rtl_hw_start_8168c_3(void *ioaddr, struct pci_device *pdev)
1323 {
1324         DBGP ( "rtl_hw_start_8168c_3\n" );
1325
1326         rtl_hw_start_8168c_2(ioaddr, pdev);
1327 }
1328
1329 static void rtl_hw_start_8168c_4(void *ioaddr, struct pci_device *pdev)
1330 {
1331         DBGP ( "rtl_hw_start_8168c_4\n" );
1332
1333         rtl_csi_access_enable(ioaddr);
1334
1335         __rtl_hw_start_8168cp(ioaddr, pdev);
1336 }
1337
1338 static void rtl_hw_start_8168d(void *ioaddr, struct pci_device *pdev)
1339 {
1340         DBGP ( "rtl_hw_start_8168d\n" );
1341
1342         rtl_csi_access_enable(ioaddr);
1343
1344         rtl_disable_clock_request(pdev);
1345
1346         RTL_W8(EarlyTxThres, EarlyTxThld);
1347
1348         rtl_tx_performance_tweak(pdev, 0x5 << MAX_READ_REQUEST_SHIFT);
1349
1350         RTL_W16(CPlusCmd, RTL_R16(CPlusCmd) & ~R8168_CPCMD_QUIRK_MASK);
1351 }
1352
1353 static void rtl_hw_start_8168(struct net_device *dev)
1354 {
1355         struct rtl8169_private *tp = netdev_priv(dev);
1356         void *ioaddr = tp->mmio_addr;
1357         struct pci_device *pdev = tp->pci_dev;
1358
1359         DBGP ( "rtl_hw_start_8168\n" );
1360
1361         RTL_W8(Cfg9346, Cfg9346_Unlock);
1362
1363         RTL_W8(EarlyTxThres, EarlyTxThld);
1364
1365         rtl_set_rx_max_size(ioaddr);
1366
1367         tp->cp_cmd |= RTL_R16(CPlusCmd) | PktCntrDisable | INTT_1;
1368
1369         RTL_W16(CPlusCmd, tp->cp_cmd);
1370
1371         RTL_W16(IntrMitigate, 0x5151);
1372
1373         /* Work around for RxFIFO overflow. */
1374         if (tp->mac_version == RTL_GIGA_MAC_VER_11) {
1375                 tp->intr_event |= RxFIFOOver | PCSTimeout;
1376                 tp->intr_event &= ~RxOverflow;
1377         }
1378
1379         rtl_set_rx_tx_desc_registers(tp, ioaddr);
1380
1381         rtl_set_rx_mode(dev);
1382
1383         RTL_W32(TxConfig, (TX_DMA_BURST << TxDMAShift) |
1384                 (InterFrameGap << TxInterFrameGapShift));
1385
1386         RTL_R8(IntrMask);
1387
1388         switch (tp->mac_version) {
1389         case RTL_GIGA_MAC_VER_11:
1390                 rtl_hw_start_8168bb(ioaddr, pdev);
1391         break;
1392
1393         case RTL_GIGA_MAC_VER_12:
1394         case RTL_GIGA_MAC_VER_17:
1395                 rtl_hw_start_8168bef(ioaddr, pdev);
1396         break;
1397
1398         case RTL_GIGA_MAC_VER_18:
1399                 rtl_hw_start_8168cp_1(ioaddr, pdev);
1400         break;
1401
1402         case RTL_GIGA_MAC_VER_19:
1403                 rtl_hw_start_8168c_1(ioaddr, pdev);
1404         break;
1405
1406         case RTL_GIGA_MAC_VER_20:
1407                 rtl_hw_start_8168c_2(ioaddr, pdev);
1408         break;
1409
1410         case RTL_GIGA_MAC_VER_21:
1411                 rtl_hw_start_8168c_3(ioaddr, pdev);
1412         break;
1413
1414         case RTL_GIGA_MAC_VER_22:
1415                 rtl_hw_start_8168c_4(ioaddr, pdev);
1416         break;
1417
1418         case RTL_GIGA_MAC_VER_23:
1419                 rtl_hw_start_8168cp_2(ioaddr, pdev);
1420         break;
1421
1422         case RTL_GIGA_MAC_VER_24:
1423                 rtl_hw_start_8168cp_3(ioaddr, pdev);
1424         break;
1425
1426         case RTL_GIGA_MAC_VER_25:
1427                 rtl_hw_start_8168d(ioaddr, pdev);
1428         break;
1429
1430         default:
1431                 DBG ( "Unknown chipset (mac_version = %d).\n",
1432                       tp->mac_version );
1433         break;
1434         }
1435
1436         RTL_W8(ChipCmd, CmdTxEnb | CmdRxEnb);
1437
1438         RTL_W8(Cfg9346, Cfg9346_Lock);
1439
1440         RTL_W16(MultiIntr, RTL_R16(MultiIntr) & 0xF000);
1441
1442         //        RTL_W16(IntrMask, tp->intr_event);
1443 }
1444
1445 #define R810X_CPCMD_QUIRK_MASK (\
1446         EnableBist | \
1447         Mac_dbgo_oe | \
1448         Force_half_dup | \
1449         Force_half_dup | \
1450         Force_txflow_en | \
1451         Cxpl_dbg_sel | \
1452         ASF | \
1453         PktCntrDisable | \
1454         PCIDAC | \
1455         PCIMulRW)
1456
1457 static void rtl_hw_start_8102e_1(void *ioaddr, struct pci_device *pdev)
1458 {
1459         static struct ephy_info e_info_8102e_1[] = {
1460                 { 0x01, 0, 0x6e65 },
1461                 { 0x02, 0, 0x091f },
1462                 { 0x03, 0, 0xc2f9 },
1463                 { 0x06, 0, 0xafb5 },
1464                 { 0x07, 0, 0x0e00 },
1465                 { 0x19, 0, 0xec80 },
1466                 { 0x01, 0, 0x2e65 },
1467                 { 0x01, 0, 0x6e65 }
1468         };
1469         u8 cfg1;
1470
1471         DBGP ( "rtl_hw_start_8102e_1\n" );
1472
1473         rtl_csi_access_enable(ioaddr);
1474
1475         RTL_W8(DBG_REG, FIX_NAK_1);
1476
1477         rtl_tx_performance_tweak(pdev, 0x5 << MAX_READ_REQUEST_SHIFT);
1478
1479         RTL_W8(Config1,
1480                LEDS1 | LEDS0 | Speed_down | MEMMAP | IOMAP | VPD | PMEnable);
1481         RTL_W8(Config3, RTL_R8(Config3) & ~Beacon_en);
1482
1483         cfg1 = RTL_R8(Config1);
1484         if ((cfg1 & LEDS0) && (cfg1 & LEDS1))
1485                 RTL_W8(Config1, cfg1 & ~LEDS0);
1486
1487         RTL_W16(CPlusCmd, RTL_R16(CPlusCmd) & ~R810X_CPCMD_QUIRK_MASK);
1488
1489         rtl_ephy_init(ioaddr, e_info_8102e_1, ARRAY_SIZE(e_info_8102e_1));
1490 }
1491
1492 static void rtl_hw_start_8102e_2(void *ioaddr, struct pci_device *pdev)
1493 {
1494         DBGP ( "rtl_hw_start_8102e_2\n" );
1495
1496         rtl_csi_access_enable(ioaddr);
1497
1498         rtl_tx_performance_tweak(pdev, 0x5 << MAX_READ_REQUEST_SHIFT);
1499
1500         RTL_W8(Config1, MEMMAP | IOMAP | VPD | PMEnable);
1501         RTL_W8(Config3, RTL_R8(Config3) & ~Beacon_en);
1502
1503         RTL_W16(CPlusCmd, RTL_R16(CPlusCmd) & ~R810X_CPCMD_QUIRK_MASK);
1504 }
1505
1506 static void rtl_hw_start_8102e_3(void *ioaddr, struct pci_device *pdev)
1507 {
1508         DBGP ( "rtl_hw_start_8102e_3\n" );
1509
1510         rtl_hw_start_8102e_2(ioaddr, pdev);
1511
1512         rtl_ephy_write(ioaddr, 0x03, 0xc2f9);
1513 }
1514
1515 static void rtl_hw_start_8101(struct net_device *dev)
1516 {
1517         struct rtl8169_private *tp = netdev_priv(dev);
1518         void *ioaddr = tp->mmio_addr;
1519         struct pci_device *pdev = tp->pci_dev;
1520
1521         DBGP ( "rtl_hw_start_8101\n" );
1522
1523         if ((tp->mac_version == RTL_GIGA_MAC_VER_13) ||
1524             (tp->mac_version == RTL_GIGA_MAC_VER_16)) {
1525                 int cap = tp->pcie_cap;
1526
1527                 if (cap) {
1528                         pci_write_config_word(pdev, cap + PCI_EXP_DEVCTL,
1529                                               PCI_EXP_DEVCTL_NOSNOOP_EN);
1530                 }
1531         }
1532
1533         switch (tp->mac_version) {
1534         case RTL_GIGA_MAC_VER_07:
1535                 rtl_hw_start_8102e_1(ioaddr, pdev);
1536                 break;
1537
1538         case RTL_GIGA_MAC_VER_08:
1539                 rtl_hw_start_8102e_3(ioaddr, pdev);
1540                 break;
1541
1542         case RTL_GIGA_MAC_VER_09:
1543                 rtl_hw_start_8102e_2(ioaddr, pdev);
1544                 break;
1545         }
1546
1547         RTL_W8(Cfg9346, Cfg9346_Unlock);
1548
1549         RTL_W8(EarlyTxThres, EarlyTxThld);
1550
1551         rtl_set_rx_max_size(ioaddr);
1552
1553         tp->cp_cmd |= rtl_rw_cpluscmd(ioaddr) | PCIMulRW;
1554
1555         RTL_W16(CPlusCmd, tp->cp_cmd);
1556
1557         RTL_W16(IntrMitigate, 0x0000);
1558
1559         rtl_set_rx_tx_desc_registers(tp, ioaddr);
1560
1561         RTL_W8(ChipCmd, CmdTxEnb | CmdRxEnb);
1562         rtl_set_rx_tx_config_registers(tp);
1563
1564         RTL_W8(Cfg9346, Cfg9346_Lock);
1565
1566         RTL_R8(IntrMask);
1567
1568         rtl_set_rx_mode(dev);
1569
1570         RTL_W8(ChipCmd, CmdTxEnb | CmdRxEnb);
1571
1572         RTL_W16(MultiIntr, RTL_R16(MultiIntr) & 0xf000);
1573
1574         //        RTL_W16(IntrMask, tp->intr_event);
1575 }
1576
1577 /*** gPXE API Support Routines ***/
1578
1579 /**
1580  * setup_tx_resources - allocate tx resources (descriptors)
1581  *
1582  * @v tp         Driver private storage
1583  *
1584  * @ret rc       Returns 0 on success, negative on failure
1585  **/
1586 static int
1587 rtl8169_setup_tx_resources ( struct rtl8169_private *tp )
1588 {
1589         DBGP ( "rtl8169_setup_tx_resources\n" );
1590
1591         tp->tx_base = malloc_dma ( R8169_TX_RING_BYTES, TX_RING_ALIGN );
1592
1593         if ( ! tp->tx_base ) {
1594                 return -ENOMEM;
1595         }
1596
1597         memset ( tp->tx_base, 0, R8169_TX_RING_BYTES );
1598
1599         DBG ( "tp->tx_base      = %#08lx\n", virt_to_bus ( tp->tx_base ) );
1600
1601         tp->tx_fill_ctr = 0;
1602         tp->tx_curr = 0;
1603         tp->tx_tail = 0;
1604
1605         return 0;
1606 }
1607
1608 static void
1609 rtl8169_process_tx_packets ( struct net_device *netdev )
1610 {
1611         struct rtl8169_private *tp = netdev_priv ( netdev );
1612
1613         uint32_t tx_status;
1614         struct TxDesc *tx_curr_desc;
1615
1616         DBGP ( "rtl8169_process_tx_packets\n" );
1617
1618         while ( tp->tx_tail != tp->tx_curr ) {
1619
1620                 tx_curr_desc = tp->tx_base  + tp->tx_tail;
1621
1622                 tx_status = tx_curr_desc->opts1;
1623
1624                 DBG2 ( "Before DescOwn check tx_status: %#08x\n", tx_status );
1625
1626                 /* if the packet at tx_tail is not owned by hardware it is for us */
1627                 if ( tx_status & DescOwn )
1628                         break;
1629
1630                 DBG ( "Transmitted packet.\n" );
1631                 DBG ( "tp->tx_fill_ctr     = %d\n", tp->tx_fill_ctr );
1632                 DBG ( "tp->tx_tail         = %d\n", tp->tx_tail );
1633                 DBG ( "tp->tx_curr         = %d\n", tp->tx_curr );
1634                 DBG ( "tx_status           = %d\n", tx_status );
1635                 DBG ( "tx_curr_desc        = %#08lx\n", virt_to_bus ( tx_curr_desc ) );
1636
1637                 /* Pass packet to core for processing */
1638                 netdev_tx_complete ( netdev, tp->tx_iobuf[tp->tx_tail] );
1639
1640                 memset ( tx_curr_desc, 0, sizeof ( *tx_curr_desc ) );
1641
1642                 /* Decrement count of used descriptors */
1643                 tp->tx_fill_ctr--;
1644
1645                 /* Increment sent packets index */
1646                 tp->tx_tail = ( tp->tx_tail + 1 ) % NUM_TX_DESC;
1647         }
1648 }
1649
1650 static void
1651 rtl8169_free_tx_resources ( struct rtl8169_private *tp )
1652 {
1653         DBGP ( "rtl8169_free_tx_resources\n" );
1654
1655         free_dma ( tp->tx_base, R8169_TX_RING_BYTES );
1656 }
1657
1658 static void
1659 rtl8169_populate_rx_descriptor ( struct rtl8169_private *tp, struct RxDesc *rx_desc, uint32_t index )
1660 {
1661         DBGP ( "rtl8169_populate_rx_descriptor\n" );
1662
1663         DBG ( "Populating rx descriptor %d\n", index );
1664
1665         memset ( rx_desc, 0, sizeof ( *rx_desc ) );
1666
1667         rx_desc->addr_hi = 0;
1668         rx_desc->addr_lo = virt_to_bus ( tp->rx_iobuf[index]->data );
1669         rx_desc->opts2 = 0;
1670         rx_desc->opts1 = ( index == ( NUM_RX_DESC - 1 ) ? RingEnd : 0 ) |
1671                 RX_BUF_SIZE;
1672         rx_desc->opts1 |= DescOwn;
1673 }
1674
1675 /**
1676  * Refill descriptor ring
1677  *
1678  * @v netdev            Net device
1679  */
1680 static void rtl8169_refill_rx_ring ( struct rtl8169_private *tp )
1681 {
1682         struct RxDesc *rx_curr_desc;
1683         int i;
1684
1685         DBGP ( "rtl8169_refill_rx_ring\n" );
1686
1687         for ( i = 0; i < NUM_RX_DESC; i++ ) {
1688
1689                 rx_curr_desc = ( tp->rx_base ) + i;
1690
1691                 /* Don't touch descriptors owned by the NIC */
1692                 if ( rx_curr_desc->opts1 & DescOwn )
1693                         continue;
1694
1695                 /* Don't touch descriptors with iobufs, they still need to be
1696                    processed by the poll routine */
1697                 if ( tp->rx_iobuf[tp->rx_curr] != NULL )
1698                         continue;
1699
1700                 /** If we can't get an iobuf for this descriptor
1701                     try again later (next poll).
1702                  */
1703                 if ( ! ( tp->rx_iobuf[i] = alloc_iob ( RX_BUF_SIZE ) ) ) {
1704                         DBG ( "Refill rx ring failed!!\n" );
1705                         break;
1706                 }
1707
1708                 rtl8169_populate_rx_descriptor ( tp, rx_curr_desc, i );
1709         }
1710 }
1711
1712 /**
1713  * setup_rx_resources - allocate Rx resources (Descriptors)
1714  *
1715  * @v tp:        Driver private structure
1716  *
1717  * @ret rc       Returns 0 on success, negative on failure
1718  *
1719  **/
1720 static int
1721 rtl8169_setup_rx_resources ( struct rtl8169_private *tp )
1722 {
1723         DBGP ( "rtl8169_setup_rx_resources\n" );
1724
1725         tp->rx_base = malloc_dma ( R8169_RX_RING_BYTES, RX_RING_ALIGN );
1726
1727         DBG ( "tp->rx_base      = %#08lx\n", virt_to_bus ( tp->rx_base ) );
1728
1729         if ( ! tp->rx_base ) {
1730                 return -ENOMEM;
1731         }
1732         memset ( tp->rx_base, 0, R8169_RX_RING_BYTES );
1733
1734         rtl8169_refill_rx_ring ( tp );
1735
1736         tp->rx_curr = 0;
1737
1738         return 0;
1739 }
1740
1741 static void
1742 rtl8169_process_rx_packets ( struct net_device *netdev )
1743 {
1744         struct rtl8169_private *tp = netdev_priv ( netdev );
1745         uint32_t rx_status;
1746         uint16_t rx_len;
1747         struct RxDesc *rx_curr_desc;
1748         int i;
1749
1750         DBGP ( "rtl8169_process_rx_packets\n" );
1751
1752         for ( i = 0; i < NUM_RX_DESC; i++ ) {
1753
1754                 rx_curr_desc = tp->rx_base  + tp->rx_curr;
1755
1756                 rx_status = rx_curr_desc->opts1;
1757
1758                 DBG2 ( "Before DescOwn check rx_status: %#08x\n", rx_status );
1759
1760                 /* Hardware still owns the descriptor */
1761                 if ( rx_status & DescOwn )
1762                         break;
1763
1764                 /* We own the descriptor, but it has not been refilled yet */
1765                 if ( tp->rx_iobuf[tp->rx_curr] == NULL )
1766                         break;
1767
1768                 rx_len = rx_status & 0x3fff;
1769
1770                 DBG ( "Received packet.\n" );
1771                 DBG ( "tp->rx_curr         = %d\n", tp->rx_curr );
1772                 DBG ( "rx_len              = %d\n", rx_len );
1773                 DBG ( "rx_status           = %#08x\n", rx_status );
1774                 DBG ( "rx_curr_desc        = %#08lx\n", virt_to_bus ( rx_curr_desc ) );
1775
1776                 if ( rx_status & RxRES ) {
1777
1778                         netdev_rx_err ( netdev, tp->rx_iobuf[tp->rx_curr], -EINVAL );
1779
1780                         DBG ( "rtl8169_poll: Corrupted packet received!\n"
1781                                " rx_status: %#08x\n", rx_status );
1782
1783                 } else  {
1784
1785                         /* Adjust size of the iobuf to reflect received data */
1786                         iob_put ( tp->rx_iobuf[tp->rx_curr], rx_len );
1787
1788                         /* Add this packet to the receive queue.  */
1789                         netdev_rx ( netdev, tp->rx_iobuf[tp->rx_curr] );
1790                 }
1791
1792                 /* Invalidate this iobuf and descriptor */
1793                 tp->rx_iobuf[tp->rx_curr] = NULL;
1794                 memset ( rx_curr_desc, 0, sizeof ( *rx_curr_desc ) );
1795
1796                 /* Update pointer to next available rx descriptor */
1797                 tp->rx_curr = ( tp->rx_curr + 1 ) % NUM_RX_DESC;
1798         }
1799         rtl8169_refill_rx_ring ( tp );
1800 }
1801
1802 static void
1803 rtl8169_free_rx_resources ( struct rtl8169_private *tp )
1804 {
1805         int i;
1806
1807         DBGP ( "rtl8169_free_rx_resources\n" );
1808
1809         free_dma ( tp->rx_base, R8169_RX_RING_BYTES );
1810
1811         for ( i = 0; i < NUM_RX_DESC; i++ ) {
1812                 free_iob ( tp->rx_iobuf[i] );
1813                 tp->rx_iobuf[i] = NULL;
1814         }
1815 }
1816
1817 /**
1818     FIXME: Because gPXE's pci_device_id structure does not contain a
1819     field to contain arbitrary data, we need the following table to
1820     associate PCI IDs with nic variants, because a lot of driver
1821     routines depend on knowing which kind of variant they are dealing
1822     with. --mdc
1823  **/
1824
1825 #define _R(VENDOR,DEVICE,INDEX) \
1826         { .vendor = VENDOR, .device = DEVICE, .index = INDEX }
1827
1828 static const struct {
1829         uint16_t vendor;
1830         uint16_t device;
1831         int index;
1832 } nic_variant_table[] = {
1833         _R(0x10ec, 0x8129, RTL_CFG_0),
1834         _R(0x10ec, 0x8136, RTL_CFG_2),
1835         _R(0x10ec, 0x8167, RTL_CFG_0),
1836         _R(0x10ec, 0x8168, RTL_CFG_1),
1837         _R(0x10ec, 0x8169, RTL_CFG_0),
1838         _R(0x1186, 0x4300, RTL_CFG_0),
1839         _R(0x1259, 0xc107, RTL_CFG_0),
1840         _R(0x16ec, 0x0116, RTL_CFG_0),
1841         _R(0x1737, 0x1032, RTL_CFG_0),
1842         _R(0x0001, 0x8168, RTL_CFG_2),
1843 };
1844 #undef _R
1845
1846 static int
1847 rtl8169_get_nic_variant ( uint16_t vendor, uint16_t device )
1848 {
1849         u32 i;
1850
1851         DBGP ( "rtl8169_get_nic_variant\n" );
1852
1853         for (i = 0; i < ARRAY_SIZE(nic_variant_table); i++) {
1854                 if ( ( nic_variant_table[i].vendor == vendor ) &&
1855                      ( nic_variant_table[i].device == device ) ) {
1856                         return ( nic_variant_table[i].index );
1857                 }
1858         }
1859         DBG ( "No matching NIC variant found!\n" );
1860         return ( RTL_CFG_0 );
1861 }
1862
1863 static void rtl8169_irq_enable ( struct rtl8169_private *tp )
1864 {
1865         void *ioaddr = tp->mmio_addr;
1866
1867         DBGP ( "rtl8169_irq_enable\n" );
1868
1869         RTL_W16 ( IntrMask, tp->intr_event );
1870 }
1871
1872 static void rtl8169_irq_disable ( struct rtl8169_private *tp )
1873 {
1874         void *ioaddr = tp->mmio_addr;
1875
1876         DBGP ( "rtl8169_irq_disable\n" );
1877
1878         rtl8169_irq_mask_and_ack ( ioaddr );
1879 }
1880
1881 /*** gPXE Core API Routines ***/
1882
1883 /**
1884  * open - Called when a network interface is made active
1885  *
1886  * @v netdev    network interface device structure
1887  * @ret rc      Return status code, 0 on success, negative value on failure
1888  *
1889  **/
1890 static int
1891 rtl8169_open ( struct net_device *netdev )
1892 {
1893         struct rtl8169_private *tp = netdev_priv ( netdev );
1894         void *ioaddr = tp->mmio_addr;
1895         int rc;
1896
1897         DBGP ( "rtl8169_open\n" );
1898
1899         /* allocate transmit descriptors */
1900         rc = rtl8169_setup_tx_resources ( tp );
1901         if ( rc ) {
1902                 DBG ( "Error setting up TX resources!\n" );
1903                 goto err_setup_tx;
1904         }
1905
1906         /* allocate receive descriptors */
1907         rc = rtl8169_setup_rx_resources ( tp );
1908         if ( rc ) {
1909                 DBG ( "Error setting up RX resources!\n" );
1910                 goto err_setup_rx;
1911         }
1912
1913         rtl_hw_start ( netdev );
1914
1915         DBG ( "TxDescStartAddrHigh   = %#08lx\n", RTL_R32 ( TxDescStartAddrHigh ) );
1916         DBG ( "TxDescStartAddrLow    = %#08lx\n", RTL_R32 ( TxDescStartAddrLow  ) );
1917         DBG ( "RxDescAddrHigh        = %#08lx\n", RTL_R32 ( RxDescAddrHigh ) );
1918         DBG ( "RxDescAddrLow         = %#08lx\n", RTL_R32 ( RxDescAddrLow  ) );
1919
1920         return 0;
1921
1922 err_setup_rx:
1923         rtl8169_free_tx_resources ( tp );
1924 err_setup_tx:
1925         rtl8169_hw_reset ( ioaddr );
1926
1927         return rc;
1928 }
1929
1930 /**
1931  * transmit - Transmit a packet
1932  *
1933  * @v netdev    Network device
1934  * @v iobuf     I/O buffer
1935  *
1936  * @ret rc       Returns 0 on success, negative on failure
1937  */
1938 static int
1939 rtl8169_transmit ( struct net_device *netdev, struct io_buffer *iobuf )
1940 {
1941         struct rtl8169_private *tp = netdev_priv ( netdev );
1942         void *ioaddr = tp->mmio_addr;
1943         uint32_t tx_len = iob_len ( iobuf );
1944
1945         struct TxDesc *tx_curr_desc;
1946
1947         DBGP ("rtl8169_transmit\n");
1948
1949         if ( tp->tx_fill_ctr == NUM_TX_DESC ) {
1950                 DBG ("TX overflow\n");
1951                 return -ENOBUFS;
1952         }
1953
1954         /**
1955          *  The rtl8169 family automatically pads short packets to a
1956          *  minimum size, but if it did not, like some older cards,
1957          *  we could do:
1958          *  iob_pad ( iobuf, ETH_ZLEN );
1959          */
1960
1961         /* Save pointer to this iobuf we have been given to transmit so
1962            we can pass it to netdev_tx_complete() later */
1963         tp->tx_iobuf[tp->tx_curr] = iobuf;
1964
1965         tx_curr_desc = tp->tx_base + tp->tx_curr;
1966
1967         DBG ( "tp->tx_fill_ctr = %d\n", tp->tx_fill_ctr );
1968         DBG ( "tp->tx_curr     = %d\n", tp->tx_curr );
1969         DBG ( "tx_curr_desc    = %#08lx\n", virt_to_bus ( tx_curr_desc ) );
1970         DBG ( "iobuf->data     = %#08lx\n", virt_to_bus ( iobuf->data ) );
1971         DBG ( "tx_len          = %d\n", tx_len );
1972
1973         /* Configure current descriptor to transmit supplied packet */
1974         tx_curr_desc->addr_hi = 0;
1975         tx_curr_desc->addr_lo = virt_to_bus ( iobuf->data );
1976         tx_curr_desc->opts2 = 0;
1977         tx_curr_desc->opts1 = FirstFrag | LastFrag |
1978                 ( tp->tx_curr == ( NUM_TX_DESC - 1 ) ? RingEnd : 0 ) |
1979                 tx_len;
1980
1981         /* Mark descriptor as owned by NIC */
1982         tx_curr_desc->opts1 |= DescOwn;
1983
1984         DBG ( "tx_curr_desc->opts1   = %#08x\n", tx_curr_desc->opts1 );
1985         DBG ( "tx_curr_desc->opts2   = %#08x\n", tx_curr_desc->opts2 );
1986         DBG ( "tx_curr_desc->addr_hi = %#08x\n", tx_curr_desc->addr_hi );
1987         DBG ( "tx_curr_desc->addr_lo = %#08x\n", tx_curr_desc->addr_lo );
1988
1989         RTL_W8 ( TxPoll, NPQ ); /* set polling bit */
1990
1991         /* Point to next free descriptor */
1992         tp->tx_curr = ( tp->tx_curr + 1 ) % NUM_TX_DESC;
1993
1994         /* Increment number of tx descriptors in use */
1995         tp->tx_fill_ctr++;
1996
1997         return 0;
1998 }
1999
2000 /**
2001  * poll - Poll for received packets
2002  *
2003  * @v netdev    Network device
2004  */
2005 static void
2006 rtl8169_poll ( struct net_device *netdev )
2007 {
2008         struct rtl8169_private *tp = netdev_priv ( netdev );
2009         void *ioaddr = tp->mmio_addr;
2010
2011         uint16_t intr_status;
2012         uint16_t intr_mask;
2013
2014         DBGP ( "rtl8169_poll\n" );
2015
2016         intr_status = RTL_R16 ( IntrStatus );
2017         intr_mask   = RTL_R16 ( IntrMask );
2018
2019         DBG2 ( "rtl8169_poll (before): intr_mask = %#04x  intr_status = %#04x\n",
2020               intr_mask, intr_status );
2021
2022         RTL_W16 ( IntrStatus, 0xffff );
2023
2024         /* hotplug / major error / no more work / shared irq */
2025         if ( intr_status == 0xffff )
2026                 return;
2027
2028         /* Process transmitted packets */
2029         rtl8169_process_tx_packets ( netdev );
2030
2031         /* Process received packets  */
2032         rtl8169_process_rx_packets ( netdev );
2033 }
2034
2035 /**
2036  * close - Disable network interface
2037  *
2038  * @v netdev    network interface device structure
2039  *
2040  **/
2041 static void
2042 rtl8169_close ( struct net_device *netdev )
2043 {
2044         struct rtl8169_private *tp = netdev_priv ( netdev );
2045         void *ioaddr = tp->mmio_addr;
2046
2047         DBGP ( "r8169_close\n" );
2048
2049         rtl8169_hw_reset ( ioaddr );
2050
2051         rtl8169_free_tx_resources ( tp );
2052         rtl8169_free_rx_resources ( tp );
2053 }
2054
2055 /**
2056  * irq - enable or Disable interrupts
2057  *
2058  * @v netdev    network adapter
2059  * @v action    requested interrupt action
2060  *
2061  **/
2062 static void
2063 rtl8169_irq ( struct net_device *netdev, int action )
2064 {
2065         struct rtl8169_private *tp = netdev_priv ( netdev );
2066
2067         DBGP ( "rtl8169_irq\n" );
2068
2069         switch ( action ) {
2070         case 0 :
2071                 rtl8169_irq_disable ( tp );
2072                 break;
2073         default :
2074                 rtl8169_irq_enable ( tp );
2075                 break;
2076         }
2077 }
2078
2079 static struct net_device_operations rtl8169_operations = {
2080         .open           = rtl8169_open,
2081         .transmit       = rtl8169_transmit,
2082         .poll           = rtl8169_poll,
2083         .close          = rtl8169_close,
2084         .irq            = rtl8169_irq,
2085 };
2086
2087 /**
2088  * probe - Initial configuration of NIC
2089  *
2090  * @v pci       PCI device
2091  * @v id        PCI IDs
2092  *
2093  * @ret rc      Return status code
2094  **/
2095 static int
2096 rtl8169_probe ( struct pci_device *pdev, const struct pci_device_id *ent )
2097 {
2098         int i, rc;
2099         struct net_device *netdev;
2100         struct rtl8169_private *tp;
2101         void *ioaddr;
2102
2103         /** FIXME: This lookup is necessary because gPXE does not have a "data"
2104             element in the structure pci_device_id which can pass an arbitrary
2105             piece of data to the driver.  It might be useful to add it. Then we
2106             could just use ent->data instead of having to look up cfg_index.
2107         **/
2108         int cfg_index = rtl8169_get_nic_variant ( ent->vendor, ent->device );
2109         const struct rtl_cfg_info *cfg = rtl_cfg_infos + cfg_index;
2110
2111         DBGP ( "rtl8169_probe\n" );
2112
2113         DBG ( "ent->vendor = %#04x, ent->device = %#04x\n", ent->vendor, ent->device );
2114
2115         DBG ( "cfg_index = %d\n", cfg_index );
2116         DBG ( "cfg->intr_event = %#04x\n", cfg->intr_event );
2117
2118         rc = -ENOMEM;
2119
2120         /* Allocate net device ( also allocates memory for netdev->priv
2121            and makes netdev-priv point to it )
2122          */
2123         netdev = alloc_etherdev ( sizeof ( *tp ) );
2124
2125         if ( ! netdev )
2126                 goto err_alloc_etherdev;
2127
2128         /* Associate driver-specific network operations with
2129            generic network device layer
2130          */
2131         netdev_init ( netdev, &rtl8169_operations );
2132
2133         /* Associate this network device with the given PCI device */
2134         pci_set_drvdata ( pdev, netdev );
2135         netdev->dev = &pdev->dev;
2136
2137         /* Initialize driver private storage */
2138         tp = netdev_priv ( netdev );
2139         memset ( tp, 0, ( sizeof ( *tp ) ) );
2140
2141         tp->pci_dev    = pdev;
2142         tp->irqno      = pdev->irq;
2143         tp->netdev     = netdev;
2144         tp->cfg_index  = cfg_index;
2145         tp->intr_event = cfg->intr_event;
2146         tp->cp_cmd     = PCIMulRW;
2147
2148         tp->hw_start = cfg->hw_start;
2149
2150         rc = -EIO;
2151
2152         adjust_pci_device ( pdev );
2153
2154         /* ioremap MMIO region */
2155         ioaddr = ioremap ( pdev->membase, R8169_REGS_SIZE );
2156
2157         if ( ! ioaddr ) {
2158                 DBG ( "cannot remap MMIO\n" );
2159                 rc = -EIO;
2160                 goto err_ioremap;
2161         }
2162
2163         tp->mmio_addr = ioaddr;
2164
2165         tp->pcie_cap = pci_find_capability ( pdev, PCI_CAP_ID_EXP );
2166         if ( tp->pcie_cap ) {
2167                 DBG (  "PCI Express capability\n" );
2168         } else {
2169                 DBG (  "No PCI Express capability\n" );
2170         }
2171
2172         /* Mask interrupts just in case */
2173         rtl8169_irq_mask_and_ack ( ioaddr );
2174
2175         /* Soft reset NIC */
2176         rtl_soft_reset ( netdev );
2177
2178         /* Identify chip attached to board */
2179         rtl8169_get_mac_version ( tp, ioaddr );
2180
2181         for ( i = 0; (u32) i < ARRAY_SIZE ( rtl_chip_info ); i++ ) {
2182                 if ( tp->mac_version == rtl_chip_info[i].mac_version )
2183                         break;
2184         }
2185         if ( i == ARRAY_SIZE(rtl_chip_info ) ) {
2186                 /* Unknown chip: assume array element #0, original RTL-8169 */
2187                 DBG ( "Unknown chip version, assuming %s\n", rtl_chip_info[0].name );
2188                 i = 0;
2189         }
2190         tp->chipset = i;
2191
2192         if ((tp->mac_version <= RTL_GIGA_MAC_VER_06) &&
2193             (RTL_R8(PHYstatus) & TBI_Enable)) {
2194                 tp->set_speed = rtl8169_set_speed_tbi;
2195                 tp->phy_reset_enable = rtl8169_tbi_reset_enable;
2196                 tp->phy_reset_pending = rtl8169_tbi_reset_pending;
2197                 tp->link_ok = rtl8169_tbi_link_ok;
2198
2199                 tp->phy_1000_ctrl_reg = ADVERTISE_1000FULL; /* Implied by TBI */
2200         } else {
2201                 tp->set_speed = rtl8169_set_speed_xmii;
2202                 tp->phy_reset_enable = rtl8169_xmii_reset_enable;
2203                 tp->phy_reset_pending = rtl8169_xmii_reset_pending;
2204                 tp->link_ok = rtl8169_xmii_link_ok;
2205         }
2206
2207         /* Get MAC address */
2208         for ( i = 0; i < MAC_ADDR_LEN; i++ )
2209                 netdev->ll_addr[i] = RTL_R8 ( MAC0 + i );
2210
2211         DBG ( "%s\n", eth_ntoa ( netdev->ll_addr ) );
2212
2213         rtl8169_init_phy ( netdev, tp );
2214
2215         if ( ( rc = register_netdev ( netdev ) ) != 0 )
2216                 goto err_register;
2217
2218         /* Mark as link up; we don't yet handle link state */
2219         netdev_link_up ( netdev );
2220
2221         DBG ( "rtl8169_probe succeeded!\n" );
2222
2223         /* No errors, return success */
2224         return 0;
2225
2226 /* Error return paths */
2227 err_register:
2228 err_ioremap:
2229         netdev_put ( netdev );
2230 err_alloc_etherdev:
2231         return rc;
2232 }
2233
2234 /**
2235  * remove - Device Removal Routine
2236  *
2237  * @v pdev PCI device information struct
2238  *
2239  **/
2240 static void
2241 rtl8169_remove ( struct pci_device *pdev )
2242 {
2243         struct net_device *netdev = pci_get_drvdata ( pdev );
2244         struct rtl8169_private *tp = netdev_priv ( netdev );
2245         void *ioaddr = tp->mmio_addr;
2246
2247         DBGP ( "rtl8169_remove\n" );
2248
2249         rtl8169_hw_reset ( ioaddr );
2250
2251         unregister_netdev ( netdev );
2252         netdev_nullify ( netdev );
2253         netdev_put ( netdev );
2254 }
2255
2256 static struct pci_device_id rtl8169_nics[] = {
2257         PCI_ROM(0x10ec, 0x8129, "rtl8169-0x8129", "rtl8169-0x8129", 0),
2258         PCI_ROM(0x10ec, 0x8136, "rtl8169-0x8136", "rtl8169-0x8136", 0),
2259         PCI_ROM(0x10ec, 0x8167, "rtl8169-0x8167", "rtl8169-0x8167", 0),
2260         PCI_ROM(0x10ec, 0x8168, "rtl8169-0x8168", "rtl8169-0x8168", 0),
2261         PCI_ROM(0x10ec, 0x8169, "rtl8169-0x8169", "rtl8169-0x8169", 0),
2262         PCI_ROM(0x1186, 0x4300, "rtl8169-0x4300", "rtl8169-0x4300", 0),
2263         PCI_ROM(0x1259, 0xc107, "rtl8169-0xc107", "rtl8169-0xc107", 0),
2264         PCI_ROM(0x16ec, 0x0116, "rtl8169-0x0116", "rtl8169-0x0116", 0),
2265         PCI_ROM(0x1737, 0x1032, "rtl8169-0x1032", "rtl8169-0x1032", 0),
2266         PCI_ROM(0x0001, 0x8168, "rtl8169-0x8168", "rtl8169-0x8168", 0),
2267 };
2268
2269 struct pci_driver rtl8169_driver __pci_driver = {
2270   .ids = rtl8169_nics,
2271   .id_count = ( sizeof ( rtl8169_nics ) / sizeof ( rtl8169_nics[0] ) ),
2272   .probe = rtl8169_probe,
2273   .remove = rtl8169_remove,
2274 };
2275
2276 /*
2277  * Local variables:
2278  *  c-basic-offset: 8
2279  *  c-indent-level: 8
2280  *  tab-width: 8
2281  * End:
2282  */