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