Overview

Request 4601 (accepted)

- (Re)add #!BuildIgnore: enough-build-resources

- Update to new version 8.047.04

- Update to new version 8.047.01

Submit package home:bitstreamout:Essentials / r8168 to package Essentials / r8168

r8168.changes Changed
x
 
1
@@ -1,4 +1,14 @@
2
 -------------------------------------------------------------------
3
+Thu Oct 24 05:49:20 UTC 2019 - Werner Fink <werner@suse.de>
4
+
5
+- (Re)add #!BuildIgnore: enough-build-resources 
6
+
7
+-------------------------------------------------------------------
8
+Tue Oct 22 06:36:13 UTC 2019 - Werner Fink <werner@suse.de>
9
+
10
+- Update to new version 8.047.04
11
+
12
+-------------------------------------------------------------------
13
 Wed Jun  5 13:54:42 UTC 2019 - Luigi Baldoni <aloisio@gmx.com>
14
 
15
 - Spec cleanup
16
@@ -6,7 +16,7 @@
17
 -------------------------------------------------------------------
18
 Fri May 24 07:49:59 UTC 2019 - Werner Fink <werner@suse.de>
19
 
20
-- Update to new version 8.047.01 
21
+- Update to new version 8.047.01
22
 - Remove patch r8168-kernel-4.15-2.patch as now upstream
23
 - Modify patch kernel_version.patch
24
 
25
r8168.spec Changed
21
 
1
@@ -18,7 +18,7 @@
2
 
3
 #!BuildIgnore: enough-build-resources
4
 Name:           r8168
5
-Version:        8.047.01
6
+Version:        8.047.04
7
 Release:        0
8
 Summary:        Device driver for RealTek Gigabit Ethernet controllers
9
 License:        GPL-2.0-or-later
10
@@ -59,8 +59,8 @@
11
 %setup -q
12
 %patch0 -b .p0
13
 %patch1 -b .p1
14
-cp %{SOURCE1} .
15
-cp %{SOURCE2} .
16
+cp %{S:1} .
17
+cp %{S:2} .
18
 
19
 %build
20
 ln -sf $(type -p kmod) modinfo
21
r8168-kernel_version.patch Changed
10
 
1
@@ -18,7 +18,7 @@
2
  #define vlan_tx_tag_present skb_vlan_tag_present
3
 --- src/r8168_n.c
4
 +++ src/r8168_n.c  2018-01-10 14:33:25.348444039 +0000
5
-@@ -28069,7 +28069,7 @@ process_pkt:
6
+@@ -28476,7 +28476,7 @@ process_pkt:
7
  
8
                          if (rtl8168_rx_vlan_skb(tp, desc, skb) < 0)
9
                                  rtl8168_rx_skb(tp, skb);
10
r8168-8.047.01.tar.bz2/src/r8168.h -> r8168-8.047.04.tar.bz2/src/r8168.h Changed
38
 
1
@@ -327,7 +327,7 @@
2
 #define DASH_SUFFIX ""
3
 #endif
4
 
5
-#define RTL8168_VERSION "8.047.01" NAPI_SUFFIX FIBER_SUFFIX REALWOW_SUFFIX DASH_SUFFIX
6
+#define RTL8168_VERSION "8.047.04" NAPI_SUFFIX FIBER_SUFFIX REALWOW_SUFFIX DASH_SUFFIX
7
 #define MODULENAME "r8168"
8
 #define PFX MODULENAME ": "
9
 
10
@@ -1576,6 +1576,8 @@
11
 
12
         u16 phy_reg_anlpar;
13
 
14
+        u32 HwPcieSNOffset;
15
+
16
         //Dash+++++++++++++++++
17
         u8 HwSuppDashVer;
18
         u8 DASH;
19
@@ -1665,6 +1667,9 @@
20
         //Realwow--------------
21
 #endif //ENABLE_REALWOW_SUPPORT
22
 
23
+        u32 eee_adv_t;
24
+        u8 eee_enabled;
25
+
26
 #ifdef ENABLE_R8168_PROCFS
27
         //Procfs support
28
         struct proc_dir_entry *proc_dir;
29
@@ -1749,7 +1754,7 @@
30
 #define NIC_RAMCODE_VERSION_CFG_METHOD_23 (0x0015)
31
 #define NIC_RAMCODE_VERSION_CFG_METHOD_26 (0x0012)
32
 #define NIC_RAMCODE_VERSION_CFG_METHOD_28 (0x0019)
33
-#define NIC_RAMCODE_VERSION_CFG_METHOD_29 (0x0018)
34
+#define NIC_RAMCODE_VERSION_CFG_METHOD_29 (0x0055)
35
 #define NIC_RAMCODE_VERSION_CFG_METHOD_31 (0x0003)
36
 
37
 //hwoptimize
38
r8168-8.047.01.tar.bz2/src/r8168_n.c -> r8168-8.047.04.tar.bz2/src/r8168_n.c Changed
1469
 
1
@@ -2743,7 +2743,7 @@
2
 }
3
 
4
 static void
5
-rtl8168_clear_and_aet_other_fun_pci_bit(struct rtl8168_private *tp,
6
+rtl8168_clear_and_set_other_fun_pci_bit(struct rtl8168_private *tp,
7
                                         u8 multi_fun_sel_bit,
8
                                         u32 addr,
9
                                         u32 clearmask,
10
@@ -2776,7 +2776,7 @@
11
                 //0: UMAC, 1: TCR1, 2: TCR2, 3: KCS, 4: EHCI(Control by EHCI Driver)
12
                 for (i = 0; i < 8; i++) {
13
                         if (FunBit & multi_fun_sel_bit)
14
-                                rtl8168_clear_and_aet_other_fun_pci_bit(tp, i, addr, clearmask, setmask);
15
+                                rtl8168_clear_and_set_other_fun_pci_bit(tp, i, addr, clearmask, setmask);
16
 
17
                         FunBit <<= 1;
18
                 }
19
@@ -2797,7 +2797,7 @@
20
                                                 set_other_fun = FALSE;
21
                                 } else if (i == 5 || i == 6) {
22
                                         if (tp->DASH) {
23
-                                                TmpUlong = rtl8168_mac_ocp_read(tp, 0x184);
24
+                                                TmpUlong = rtl8168_ocp_read(tp, 0x184, 4);
25
 
26
                                                 if (TmpUlong & BIT_26)
27
                                                         set_other_fun = FALSE;
28
@@ -2807,7 +2807,7 @@
29
                                 }
30
 
31
                                 if (set_other_fun)
32
-                                        rtl8168_clear_and_aet_other_fun_pci_bit(tp, i, addr, clearmask, setmask);
33
+                                        rtl8168_clear_and_set_other_fun_pci_bit(tp, i, addr, clearmask, setmask);
34
                         }
35
 
36
                         FunBit <<= 1;
37
@@ -4316,6 +4316,10 @@
38
                 break;
39
         }
40
 
41
+#ifdef ENABLE_REALWOW_SUPPORT
42
+        rtl8168_set_realwow_d3_para(dev);
43
+#endif
44
+
45
         if (tp->mcfg == CFG_METHOD_18 || tp->mcfg == CFG_METHOD_19 || tp->mcfg == CFG_METHOD_20) {
46
                 rtl8168_eri_write(ioaddr, 0x1bc, 4, 0x0000001f, ERIAR_ExGMAC);
47
                 rtl8168_eri_write(ioaddr, 0x1dc, 4, 0x0000002d, ERIAR_ExGMAC);
48
@@ -4355,6 +4359,7 @@
49
                         rtl8168_mdio_write(tp, 0x1F, 0x0000);
50
                 }
51
         }
52
+
53
         if (tp->mcfg == CFG_METHOD_31 || tp->mcfg == CFG_METHOD_32) {
54
                 rtl8168_set_dash_other_fun_dev_state_change(tp, 3, 0xFD);
55
         }
56
@@ -4366,7 +4371,8 @@
57
             tp->mcfg == CFG_METHOD_27 || tp->mcfg == CFG_METHOD_28 ||
58
             tp->mcfg == CFG_METHOD_29 || tp->mcfg == CFG_METHOD_30 ||
59
             tp->mcfg == CFG_METHOD_31 || tp->mcfg == CFG_METHOD_32)
60
-                rtl8168_disable_ocp_phy_power_saving(dev);
61
+                if (!tp->dash_printer_enabled)
62
+                        rtl8168_disable_ocp_phy_power_saving(dev);
63
 
64
         rtl8168_disable_rxdvgate(dev);
65
 }
66
@@ -4645,8 +4651,10 @@
67
         }
68
 
69
         switch (tp->mcfg) {
70
-        case CFG_METHOD_29:
71
-        case CFG_METHOD_30:
72
+        case CFG_METHOD_14 ... CFG_METHOD_15:
73
+                RTL_W8(0xD0, RTL_R8(0xD0) & ~BIT_6);
74
+                break;
75
+        case CFG_METHOD_16 ... CFG_METHOD_32:
76
                 RTL_W8(0xD0, RTL_R8(0xD0) & ~BIT_6);
77
                 RTL_W8(0xF2, RTL_R8(0xF2) & ~BIT_6);
78
                 break;
79
@@ -5203,7 +5211,7 @@
80
                     SUPPORTED_1000baseT_Full |
81
                     SUPPORTED_Autoneg |
82
                     SUPPORTED_TP |
83
-                    SUPPORTED_Pause    |
84
+                    SUPPORTED_Pause |
85
                     SUPPORTED_Asym_Pause;
86
 
87
         advertising = ADVERTISED_TP;
88
@@ -5595,192 +5603,6 @@
89
 }
90
 #endif
91
 
92
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,6,0)
93
-static int
94
-rtl_ethtool_get_eee(struct net_device *net, struct ethtool_eee *eee)
95
-{
96
-        struct rtl8168_private *tp = netdev_priv(net);
97
-        void __iomem *ioaddr = tp->mmio_addr;
98
-        u32 lp, adv, supported = 0;
99
-        unsigned long flags;
100
-        u16 val;
101
-
102
-        switch (tp->mcfg) {
103
-        case CFG_METHOD_27:
104
-        case CFG_METHOD_28:
105
-                break;
106
-        default:
107
-                return -EOPNOTSUPP;
108
-        }
109
-
110
-        if (unlikely(tp->rtk_enable_diag))
111
-                return -EBUSY;
112
-
113
-        spin_lock_irqsave(&tp->lock, flags);
114
-
115
-        rtl8168_mdio_write(tp, 0x1F, 0x0A5C);
116
-        val = rtl8168_mdio_read(tp, 0x12);
117
-        supported = mmd_eee_cap_to_ethtool_sup_t(val);
118
-
119
-        rtl8168_mdio_write(tp, 0x1F, 0x0A5D);
120
-        val = rtl8168_mdio_read(tp, 0x10);
121
-        adv = mmd_eee_adv_to_ethtool_adv_t(val);
122
-
123
-        val = rtl8168_mdio_read(tp, 0x11);
124
-        lp = mmd_eee_adv_to_ethtool_adv_t(val);
125
-
126
-        val = rtl8168_eri_read(ioaddr, 0x1B0, 2, ERIAR_ExGMAC);
127
-        val &= BIT_1 | BIT_0;
128
-
129
-        rtl8168_mdio_write(tp, 0x1F, 0x0000);
130
-
131
-        spin_unlock_irqrestore(&tp->lock, flags);
132
-
133
-        eee->eee_enabled = !!val;
134
-        eee->eee_active = !!(supported & adv & lp);
135
-        eee->supported = supported;
136
-        eee->advertised = adv;
137
-        eee->lp_advertised = lp;
138
-
139
-        return 0;
140
-}
141
-
142
-static int
143
-rtl_ethtool_set_eee(struct net_device *net, struct ethtool_eee *eee)
144
-{
145
-        struct rtl8168_private *tp = netdev_priv(net);
146
-        void __iomem *ioaddr = tp->mmio_addr;
147
-        unsigned long flags;
148
-        u32 data;
149
-
150
-        switch (tp->mcfg) {
151
-        case CFG_METHOD_27:
152
-        case CFG_METHOD_28:
153
-                break;
154
-        default:
155
-                return -EOPNOTSUPP;
156
-        }
157
-
158
-        spin_lock_irqsave(&tp->lock, flags);
159
-
160
-        if (unlikely(tp->rtk_enable_diag)) {
161
-                spin_unlock_irqrestore(&tp->lock, flags);
162
-                return -EBUSY;
163
-        }
164
-
165
-        data = rtl8168_eri_read(ioaddr, 0x1B0, 4, ERIAR_ExGMAC);
166
-        if (eee->eee_enabled) {
167
-                data |= BIT_1 | BIT_0;
168
-                rtl8168_eri_write(ioaddr, 0x1B0, 4, data, ERIAR_ExGMAC);
169
-                rtl8168_mdio_write(tp, 0x1F, 0x0A43);
170
-                data = rtl8168_mdio_read(tp, 0x11);
171
-                rtl8168_mdio_write(tp, 0x11, data | BIT_4);
172
-                data = ethtool_adv_to_mmd_eee_adv_t(eee->advertised);
173
-                rtl8168_mdio_write(tp, 0x1F, 0x0A5D);
174
-                rtl8168_mdio_write(tp, 0x10, data);
175
-        } else {
176
-                data &= ~(BIT_1 | BIT_0);
177
-                rtl8168_eri_write(ioaddr, 0x1B0, 4, data, ERIAR_ExGMAC);
178
-                rtl8168_mdio_write(tp, 0x1F, 0x0A43);
179
-                data = rtl8168_mdio_read(tp, 0x11);
180
-                rtl8168_mdio_write(tp, 0x11, data & ~BIT_4);
181
-                rtl8168_mdio_write(tp, 0x1F, 0x0A5D);
182
-                rtl8168_mdio_write(tp, 0x10, 0x0000);
183
-        }
184
-
185
-        rtl8168_mdio_write(tp, 0x1F, 0x0000);
186
-        data = rtl8168_mdio_read(tp, MII_BMCR);
187
-        data |= BMCR_RESET;
188
-        rtl8168_mdio_write(tp, MII_BMCR, data);
189
-
190
-        spin_unlock_irqrestore(&tp->lock, flags);
191
-
192
-        return 0;
193
-}
194
-#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(3,6,0) */
195
-
196
-static int rtl_nway_reset(struct net_device *dev)
197
-{
198
-        struct rtl8168_private *tp = netdev_priv(dev);
199
-        unsigned long flags;
200
-        int ret, bmcr;
201
-
202
-        if (unlikely(tp->rtk_enable_diag))
203
-                return -EBUSY;
204
-
205
-        spin_lock_irqsave(&tp->lock, flags);
206
-
207
-        /* if autoneg is off, it's an error */
208
-        rtl8168_mdio_write(tp, 0x1F, 0x0000);
209
-        bmcr = rtl8168_mdio_read(tp, MII_BMCR);
210
-
211
-        if (bmcr & BMCR_ANENABLE) {
212
-                bmcr |= BMCR_ANRESTART;
213
-                rtl8168_mdio_write(tp, MII_BMCR, bmcr);
214
-                ret = 0;
215
-        } else {
216
-                ret = -EINVAL;
217
-        }
218
-
219
-        spin_unlock_irqrestore(&tp->lock, flags);
220
-
221
-        return ret;
222
-}
223
-
224
-#if LINUX_VERSION_CODE > KERNEL_VERSION(2,4,22)
225
-static const struct ethtool_ops rtl8168_ethtool_ops = {
226
-        .get_drvinfo        = rtl8168_get_drvinfo,
227
-        .get_regs_len       = rtl8168_get_regs_len,
228
-        .get_link       = ethtool_op_get_link,
229
-#if LINUX_VERSION_CODE < KERNEL_VERSION(4,6,0)
230
-        .get_settings       = rtl8168_get_settings,
231
-        .set_settings       = rtl8168_set_settings,
232
-#else
233
-        .get_link_ksettings       = rtl8168_get_settings,
234
-        .set_link_ksettings       = rtl8168_set_settings,
235
-#endif
236
-        .get_msglevel       = rtl8168_get_msglevel,
237
-        .set_msglevel       = rtl8168_set_msglevel,
238
-#if LINUX_VERSION_CODE < KERNEL_VERSION(3,3,0)
239
-        .get_rx_csum        = rtl8168_get_rx_csum,
240
-        .set_rx_csum        = rtl8168_set_rx_csum,
241
-        .get_tx_csum        = rtl8168_get_tx_csum,
242
-        .set_tx_csum        = rtl8168_set_tx_csum,
243
-        .get_sg         = ethtool_op_get_sg,
244
-        .set_sg         = ethtool_op_set_sg,
245
-#ifdef NETIF_F_TSO
246
-        .get_tso        = ethtool_op_get_tso,
247
-        .set_tso        = ethtool_op_set_tso,
248
-#endif
249
-#endif
250
-        .get_regs       = rtl8168_get_regs,
251
-        .get_wol        = rtl8168_get_wol,
252
-        .set_wol        = rtl8168_set_wol,
253
-        .get_strings        = rtl8168_get_strings,
254
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,33)
255
-        .get_stats_count    = rtl8168_get_stats_count,
256
-#else
257
-        .get_sset_count     = rtl8168_get_sset_count,
258
-#endif
259
-        .get_ethtool_stats  = rtl8168_get_ethtool_stats,
260
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
261
-#ifdef ETHTOOL_GPERMADDR
262
-        .get_perm_addr      = ethtool_op_get_perm_addr,
263
-#endif
264
-#endif //LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
265
-        .get_eeprom     = rtl_get_eeprom,
266
-        .get_eeprom_len     = rtl_get_eeprom_len,
267
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,5,0)
268
-        .get_ts_info        = ethtool_op_get_ts_info,
269
-#endif //LINUX_VERSION_CODE >= KERNEL_VERSION(3,5,0)
270
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,6,0)
271
-        .get_eee = rtl_ethtool_get_eee,
272
-        .set_eee = rtl_ethtool_set_eee,
273
-#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(3,6,0) */
274
-        .nway_reset = rtl_nway_reset,
275
-};
276
-#endif //LINUX_VERSION_CODE > KERNEL_VERSION(2,4,22)
277
-
278
 static int rtl8168_enable_EEE(struct rtl8168_private *tp)
279
 {
280
         void __iomem *ioaddr = tp->mmio_addr;
281
@@ -5885,7 +5707,7 @@
282
                 data = rtl8168_mdio_read(tp, 0x11);
283
                 rtl8168_mdio_write(tp, 0x11, data | BIT_4);
284
                 rtl8168_mdio_write(tp, 0x1F, 0x0A5D);
285
-                rtl8168_mdio_write(tp, 0x10, 0x0006);
286
+                rtl8168_mdio_write(tp, 0x10, tp->eee_adv_t);
287
                 rtl8168_mdio_write(tp, 0x1F, 0x0000);
288
                 break;
289
 
290
@@ -5898,6 +5720,8 @@
291
         switch (tp->mcfg) {
292
         case CFG_METHOD_29:
293
         case CFG_METHOD_30:
294
+        case CFG_METHOD_31:
295
+        case CFG_METHOD_32:
296
                 rtl8168_mdio_write(tp, 0x1F, 0x0A4A);
297
                 rtl8168_set_eth_phy_bit(tp, 0x11, BIT_9);
298
                 rtl8168_mdio_write(tp, 0x1F, 0x0A42);
299
@@ -5908,6 +5732,16 @@
300
 
301
         /*Advanced EEE*/
302
         switch (tp->mcfg) {
303
+        case CFG_METHOD_23:
304
+        case CFG_METHOD_27:
305
+        case CFG_METHOD_28:
306
+        case CFG_METHOD_31:
307
+        case CFG_METHOD_32:
308
+                rtl8168_oob_mutex_lock(tp);
309
+                break;
310
+        }
311
+
312
+        switch (tp->mcfg) {
313
         case CFG_METHOD_24:
314
         case CFG_METHOD_25:
315
         case CFG_METHOD_26:
316
@@ -5916,8 +5750,6 @@
317
         case CFG_METHOD_31:
318
         case CFG_METHOD_32:
319
                 rtl8168_set_phy_mcu_patch_request(tp);
320
-
321
-                rtl8168_mdio_write(tp, 0x1F, 0x0000);
322
                 break;
323
         }
324
 
325
@@ -5966,11 +5798,9 @@
326
                 break;
327
         case CFG_METHOD_27:
328
         case CFG_METHOD_28:
329
-                rtl8168_oob_mutex_lock(tp);
330
                 data = rtl8168_mac_ocp_read(tp, 0xE052);
331
                 data &= ~BIT_0;
332
                 rtl8168_mac_ocp_write(tp, 0xE052, data);
333
-                rtl8168_oob_mutex_unlock(tp);
334
                 data = rtl8168_mac_ocp_read(tp, 0xE056);
335
                 data &= 0xFF0F;
336
                 data |= (BIT_4 | BIT_5 | BIT_6);
337
@@ -5990,14 +5820,13 @@
338
                 data = rtl8168_mdio_read(tp, 0x11) | BIT_13 | BIT_14;
339
                 data &= ~(BIT_12);
340
                 rtl8168_mdio_write(tp, 0x11, data);
341
+                rtl8168_mdio_write(tp, 0x1F, 0x0000);
342
                 break;
343
         case CFG_METHOD_31:
344
         case CFG_METHOD_32:
345
-                rtl8168_oob_mutex_lock(tp);
346
                 data = rtl8168_mac_ocp_read(tp, 0xE052);
347
                 data |= BIT_0;
348
                 rtl8168_mac_ocp_write(tp, 0xE052, data);
349
-                rtl8168_oob_mutex_unlock(tp);
350
 
351
                 rtl8168_mdio_write(tp, 0x1F, 0x0A43);
352
                 data = rtl8168_mdio_read(tp, 0x10) | BIT_15;
353
@@ -6007,6 +5836,7 @@
354
                 data = rtl8168_mdio_read(tp, 0x11) | BIT_13 | BIT_14;
355
                 data &= ~(BIT_12);
356
                 rtl8168_mdio_write(tp, 0x11, data);
357
+                rtl8168_mdio_write(tp, 0x1F, 0x0000);
358
                 break;
359
         }
360
 
361
@@ -6022,6 +5852,16 @@
362
                 break;
363
         }
364
 
365
+        switch (tp->mcfg) {
366
+        case CFG_METHOD_23:
367
+        case CFG_METHOD_27:
368
+        case CFG_METHOD_28:
369
+        case CFG_METHOD_31:
370
+        case CFG_METHOD_32:
371
+                rtl8168_oob_mutex_unlock(tp);
372
+                break;
373
+        }
374
+
375
         return ret;
376
 }
377
 
378
@@ -6153,6 +5993,16 @@
379
 
380
         /*Advanced EEE*/
381
         switch (tp->mcfg) {
382
+        case CFG_METHOD_23:
383
+        case CFG_METHOD_27:
384
+        case CFG_METHOD_28:
385
+        case CFG_METHOD_31:
386
+        case CFG_METHOD_32:
387
+                rtl8168_oob_mutex_lock(tp);
388
+                break;
389
+        }
390
+
391
+        switch (tp->mcfg) {
392
         case CFG_METHOD_24:
393
         case CFG_METHOD_25:
394
         case CFG_METHOD_26:
395
@@ -6206,6 +6056,7 @@
396
                 rtl8168_mdio_write(tp, 0x1F, 0x0A44);
397
                 data = rtl8168_mdio_read(tp, 0x11) & ~(BIT_12 | BIT_13 | BIT_14);
398
                 rtl8168_mdio_write(tp, 0x11, data);
399
+                rtl8168_mdio_write(tp, 0x1F, 0x0000);
400
                 break;
401
         }
402
 
403
@@ -6221,9 +6072,196 @@
404
                 break;
405
         }
406
 
407
+        switch (tp->mcfg) {
408
+        case CFG_METHOD_23:
409
+        case CFG_METHOD_27:
410
+        case CFG_METHOD_28:
411
+        case CFG_METHOD_31:
412
+        case CFG_METHOD_32:
413
+                rtl8168_oob_mutex_unlock(tp);
414
+                break;
415
+        }
416
+
417
         return ret;
418
 }
419
 
420
+static int rtl_nway_reset(struct net_device *dev)
421
+{
422
+        struct rtl8168_private *tp = netdev_priv(dev);
423
+        unsigned long flags;
424
+        int ret, bmcr;
425
+
426
+        if (unlikely(tp->rtk_enable_diag))
427
+                return -EBUSY;
428
+
429
+        spin_lock_irqsave(&tp->lock, flags);
430
+
431
+        /* if autoneg is off, it's an error */
432
+        rtl8168_mdio_write(tp, 0x1F, 0x0000);
433
+        bmcr = rtl8168_mdio_read(tp, MII_BMCR);
434
+
435
+        if (bmcr & BMCR_ANENABLE) {
436
+                bmcr |= BMCR_ANRESTART;
437
+                rtl8168_mdio_write(tp, MII_BMCR, bmcr);
438
+                ret = 0;
439
+        } else {
440
+                ret = -EINVAL;
441
+        }
442
+
443
+        spin_unlock_irqrestore(&tp->lock, flags);
444
+
445
+        return ret;
446
+}
447
+
448
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,6,0)
449
+static int
450
+rtl_ethtool_get_eee(struct net_device *net, struct ethtool_eee *eee)
451
+{
452
+        struct rtl8168_private *tp = netdev_priv(net);
453
+        void __iomem *ioaddr = tp->mmio_addr;
454
+        u32 lp, adv, supported = 0;
455
+        unsigned long flags;
456
+        u16 val;
457
+
458
+        switch (tp->mcfg) {
459
+        case CFG_METHOD_27:
460
+        case CFG_METHOD_28:
461
+        case CFG_METHOD_29:
462
+        case CFG_METHOD_30:
463
+        case CFG_METHOD_31:
464
+        case CFG_METHOD_32:
465
+                break;
466
+        default:
467
+                return -EOPNOTSUPP;
468
+        }
469
+
470
+        if (unlikely(tp->rtk_enable_diag))
471
+                return -EBUSY;
472
+
473
+        spin_lock_irqsave(&tp->lock, flags);
474
+
475
+        rtl8168_mdio_write(tp, 0x1F, 0x0A5C);
476
+        val = rtl8168_mdio_read(tp, 0x12);
477
+        supported = mmd_eee_cap_to_ethtool_sup_t(val);
478
+
479
+        rtl8168_mdio_write(tp, 0x1F, 0x0A5D);
480
+        val = rtl8168_mdio_read(tp, 0x10);
481
+        adv = mmd_eee_adv_to_ethtool_adv_t(val);
482
+
483
+        val = rtl8168_mdio_read(tp, 0x11);
484
+        lp = mmd_eee_adv_to_ethtool_adv_t(val);
485
+
486
+        val = rtl8168_eri_read(ioaddr, 0x1B0, 2, ERIAR_ExGMAC);
487
+        val &= BIT_1 | BIT_0;
488
+
489
+        rtl8168_mdio_write(tp, 0x1F, 0x0000);
490
+
491
+        spin_unlock_irqrestore(&tp->lock, flags);
492
+
493
+        eee->eee_enabled = !!val;
494
+        eee->eee_active = !!(supported & adv & lp);
495
+        eee->supported = supported;
496
+        eee->advertised = adv;
497
+        eee->lp_advertised = lp;
498
+
499
+        return 0;
500
+}
501
+
502
+static int
503
+rtl_ethtool_set_eee(struct net_device *net, struct ethtool_eee *eee)
504
+{
505
+        struct rtl8168_private *tp = netdev_priv(net);
506
+        unsigned long flags;
507
+
508
+        switch (tp->mcfg) {
509
+        case CFG_METHOD_27:
510
+        case CFG_METHOD_28:
511
+        case CFG_METHOD_29:
512
+        case CFG_METHOD_30:
513
+        case CFG_METHOD_31:
514
+        case CFG_METHOD_32:
515
+                break;
516
+        default:
517
+                return -EOPNOTSUPP;
518
+        }
519
+
520
+        spin_lock_irqsave(&tp->lock, flags);
521
+
522
+        if (unlikely(tp->rtk_enable_diag)) {
523
+                spin_unlock_irqrestore(&tp->lock, flags);
524
+                return -EBUSY;
525
+        }
526
+
527
+        tp->eee_enabled = eee->eee_enabled;
528
+        tp->eee_adv_t = ethtool_adv_to_mmd_eee_adv_t(eee->advertised);
529
+
530
+        if (tp->eee_enabled)
531
+                rtl8168_enable_EEE(tp);
532
+        else
533
+                rtl8168_disable_EEE(tp);
534
+
535
+        spin_unlock_irqrestore(&tp->lock, flags);
536
+
537
+        rtl_nway_reset(net);
538
+
539
+        return 0;
540
+}
541
+#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(3,6,0) */
542
+
543
+#if LINUX_VERSION_CODE > KERNEL_VERSION(2,4,22)
544
+static const struct ethtool_ops rtl8168_ethtool_ops = {
545
+        .get_drvinfo        = rtl8168_get_drvinfo,
546
+        .get_regs_len       = rtl8168_get_regs_len,
547
+        .get_link       = ethtool_op_get_link,
548
+#if LINUX_VERSION_CODE < KERNEL_VERSION(4,6,0)
549
+        .get_settings       = rtl8168_get_settings,
550
+        .set_settings       = rtl8168_set_settings,
551
+#else
552
+        .get_link_ksettings       = rtl8168_get_settings,
553
+        .set_link_ksettings       = rtl8168_set_settings,
554
+#endif
555
+        .get_msglevel       = rtl8168_get_msglevel,
556
+        .set_msglevel       = rtl8168_set_msglevel,
557
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3,3,0)
558
+        .get_rx_csum        = rtl8168_get_rx_csum,
559
+        .set_rx_csum        = rtl8168_set_rx_csum,
560
+        .get_tx_csum        = rtl8168_get_tx_csum,
561
+        .set_tx_csum        = rtl8168_set_tx_csum,
562
+        .get_sg         = ethtool_op_get_sg,
563
+        .set_sg         = ethtool_op_set_sg,
564
+#ifdef NETIF_F_TSO
565
+        .get_tso        = ethtool_op_get_tso,
566
+        .set_tso        = ethtool_op_set_tso,
567
+#endif
568
+#endif
569
+        .get_regs       = rtl8168_get_regs,
570
+        .get_wol        = rtl8168_get_wol,
571
+        .set_wol        = rtl8168_set_wol,
572
+        .get_strings        = rtl8168_get_strings,
573
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,33)
574
+        .get_stats_count    = rtl8168_get_stats_count,
575
+#else
576
+        .get_sset_count     = rtl8168_get_sset_count,
577
+#endif
578
+        .get_ethtool_stats  = rtl8168_get_ethtool_stats,
579
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
580
+#ifdef ETHTOOL_GPERMADDR
581
+        .get_perm_addr      = ethtool_op_get_perm_addr,
582
+#endif
583
+#endif //LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
584
+        .get_eeprom     = rtl_get_eeprom,
585
+        .get_eeprom_len     = rtl_get_eeprom_len,
586
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,5,0)
587
+        .get_ts_info        = ethtool_op_get_ts_info,
588
+#endif //LINUX_VERSION_CODE >= KERNEL_VERSION(3,5,0)
589
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,6,0)
590
+        .get_eee = rtl_ethtool_get_eee,
591
+        .set_eee = rtl_ethtool_set_eee,
592
+#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(3,6,0) */
593
+        .nway_reset = rtl_nway_reset,
594
+};
595
+#endif //LINUX_VERSION_CODE > KERNEL_VERSION(2,4,22)
596
+
597
 #if 0
598
 
599
 static int rtl8168_enable_green_feature(struct rtl8168_private *tp)
600
@@ -6861,7 +6899,7 @@
601
         }
602
 
603
 #ifdef ENABLE_REALWOW_SUPPORT
604
-        realwow_hw_init(dev);
605
+        rtl8168_realwow_hw_init(dev);
606
 #else
607
         switch (tp->mcfg) {
608
         case CFG_METHOD_21:
609
@@ -9105,6 +9143,61 @@
610
 }
611
 
612
 static void
613
+rtl8168_set_mac_mcu_8168fp_3(struct net_device *dev)
614
+{
615
+        struct rtl8168_private *tp = netdev_priv(dev);
616
+
617
+        rtl8168_hw_disable_mac_mcu_bps(dev);
618
+
619
+        rtl8168_mac_ocp_write(tp, 0xF800, 0xE008);
620
+        rtl8168_mac_ocp_write(tp, 0xF802, 0xE00A);
621
+        rtl8168_mac_ocp_write(tp, 0xF804, 0xE00F);
622
+        rtl8168_mac_ocp_write(tp, 0xF806, 0xE014);
623
+        rtl8168_mac_ocp_write(tp, 0xF808, 0xE016);
624
+        rtl8168_mac_ocp_write(tp, 0xF80A, 0xE018);
625
+        rtl8168_mac_ocp_write(tp, 0xF80C, 0xE01A);
626
+        rtl8168_mac_ocp_write(tp, 0xF80E, 0xE01C);
627
+        rtl8168_mac_ocp_write(tp, 0xF810, 0xC602);
628
+        rtl8168_mac_ocp_write(tp, 0xF812, 0xBE00);
629
+        rtl8168_mac_ocp_write(tp, 0xF814, 0x2AB2);
630
+        rtl8168_mac_ocp_write(tp, 0xF816, 0x1BC0);
631
+        rtl8168_mac_ocp_write(tp, 0xF818, 0x46EB);
632
+        rtl8168_mac_ocp_write(tp, 0xF81A, 0x1BFE);
633
+        rtl8168_mac_ocp_write(tp, 0xF81C, 0xC102);
634
+        rtl8168_mac_ocp_write(tp, 0xF81E, 0xB900);
635
+        rtl8168_mac_ocp_write(tp, 0xF820, 0x0B1A);
636
+        rtl8168_mac_ocp_write(tp, 0xF822, 0x1BC0);
637
+        rtl8168_mac_ocp_write(tp, 0xF824, 0x46EB);
638
+        rtl8168_mac_ocp_write(tp, 0xF826, 0x1B7E);
639
+        rtl8168_mac_ocp_write(tp, 0xF828, 0xC102);
640
+        rtl8168_mac_ocp_write(tp, 0xF82A, 0xB900);
641
+        rtl8168_mac_ocp_write(tp, 0xF82C, 0x0BEA);
642
+        rtl8168_mac_ocp_write(tp, 0xF82E, 0xC602);
643
+        rtl8168_mac_ocp_write(tp, 0xF830, 0xBE00);
644
+        rtl8168_mac_ocp_write(tp, 0xF832, 0x0000);
645
+        rtl8168_mac_ocp_write(tp, 0xF834, 0xC602);
646
+        rtl8168_mac_ocp_write(tp, 0xF836, 0xBE00);
647
+        rtl8168_mac_ocp_write(tp, 0xF838, 0x0000);
648
+        rtl8168_mac_ocp_write(tp, 0xF83A, 0xC602);
649
+        rtl8168_mac_ocp_write(tp, 0xF83C, 0xBE00);
650
+        rtl8168_mac_ocp_write(tp, 0xF83E, 0x0000);
651
+        rtl8168_mac_ocp_write(tp, 0xF840, 0xC602);
652
+        rtl8168_mac_ocp_write(tp, 0xF842, 0xBE00);
653
+        rtl8168_mac_ocp_write(tp, 0xF844, 0x0000);
654
+        rtl8168_mac_ocp_write(tp, 0xF846, 0xC602);
655
+        rtl8168_mac_ocp_write(tp, 0xF848, 0xBE00);
656
+        rtl8168_mac_ocp_write(tp, 0xF84A, 0x0000);
657
+
658
+        rtl8168_mac_ocp_write(tp, 0xFC26, 0x8000);
659
+
660
+        rtl8168_mac_ocp_write(tp, 0xFC28, 0x2AAC);
661
+        rtl8168_mac_ocp_write(tp, 0xFC2A, 0x0B14);
662
+        rtl8168_mac_ocp_write(tp, 0xFC2C, 0x0BE4);
663
+
664
+        rtl8168_mac_ocp_write(tp, 0xFC38, 0x0006);
665
+}
666
+
667
+static void
668
 rtl8168_hw_mac_mcu_config(struct net_device *dev)
669
 {
670
         struct rtl8168_private *tp = netdev_priv(dev);
671
@@ -9141,7 +9234,7 @@
672
                         rtl8168_set_mac_mcu_8168fp_2(dev);
673
                 break;
674
         case CFG_METHOD_32:
675
-                rtl8168_hw_disable_mac_mcu_bps(dev);
676
+                rtl8168_set_mac_mcu_8168fp_3(dev);
677
                 break;
678
         }
679
 }
680
@@ -9257,7 +9350,8 @@
681
             tp->mcfg == CFG_METHOD_27 || tp->mcfg == CFG_METHOD_28 ||
682
             tp->mcfg == CFG_METHOD_29 || tp->mcfg == CFG_METHOD_30 ||
683
             tp->mcfg == CFG_METHOD_31 || tp->mcfg == CFG_METHOD_32)
684
-                rtl8168_disable_ocp_phy_power_saving(dev);
685
+                if (!tp->dash_printer_enabled)
686
+                        rtl8168_disable_ocp_phy_power_saving(dev);
687
 
688
         //Set PCIE uncorrectable error status mask pcie 0x108
689
         csi_tmp = rtl8168_csi_read(tp, 0x108);
690
@@ -9650,6 +9744,8 @@
691
                 if (WaitCnt == 1000) {
692
                         retval = FALSE;
693
                 }
694
+
695
+                rtl8168_mdio_write(tp,0x1f, 0x0000);
696
                 break;
697
         }
698
 
699
@@ -9680,6 +9776,8 @@
700
                 if (WaitCnt == 1000) {
701
                         retval = FALSE;
702
                 }
703
+
704
+                rtl8168_mdio_write(tp,0x1f, 0x0000);
705
                 break;
706
         }
707
 
708
@@ -20727,6 +20825,289 @@
709
 
710
 
711
         rtl8168_mdio_write(tp, 0x1F, 0x0A43);
712
+        rtl8168_mdio_write(tp, 0x13, 0x8323);
713
+        rtl8168_mdio_write(tp, 0x14, 0xaf83);
714
+        rtl8168_mdio_write(tp, 0x14, 0x2faf);
715
+        rtl8168_mdio_write(tp, 0x14, 0x853d);
716
+        rtl8168_mdio_write(tp, 0x14, 0xaf85);
717
+        rtl8168_mdio_write(tp, 0x14, 0x3daf);
718
+        rtl8168_mdio_write(tp, 0x14, 0x853d);
719
+        rtl8168_mdio_write(tp, 0x14, 0xe082);
720
+        rtl8168_mdio_write(tp, 0x14, 0x45ad);
721
+        rtl8168_mdio_write(tp, 0x14, 0x2052);
722
+        rtl8168_mdio_write(tp, 0x14, 0xe082);
723
+        rtl8168_mdio_write(tp, 0x14, 0x7ae3);
724
+        rtl8168_mdio_write(tp, 0x14, 0x85fe);
725
+        rtl8168_mdio_write(tp, 0x14, 0x1a03);
726
+        rtl8168_mdio_write(tp, 0x14, 0x10e4);
727
+        rtl8168_mdio_write(tp, 0x14, 0x85f6);
728
+        rtl8168_mdio_write(tp, 0x14, 0xe082);
729
+        rtl8168_mdio_write(tp, 0x14, 0x7a1b);
730
+        rtl8168_mdio_write(tp, 0x14, 0x03e4);
731
+        rtl8168_mdio_write(tp, 0x14, 0x85fa);
732
+        rtl8168_mdio_write(tp, 0x14, 0xe082);
733
+        rtl8168_mdio_write(tp, 0x14, 0x7be3);
734
+        rtl8168_mdio_write(tp, 0x14, 0x85fe);
735
+        rtl8168_mdio_write(tp, 0x14, 0x1a03);
736
+        rtl8168_mdio_write(tp, 0x14, 0x10e4);
737
+        rtl8168_mdio_write(tp, 0x14, 0x85f7);
738
+        rtl8168_mdio_write(tp, 0x14, 0xe082);
739
+        rtl8168_mdio_write(tp, 0x14, 0x7b1b);
740
+        rtl8168_mdio_write(tp, 0x14, 0x03e4);
741
+        rtl8168_mdio_write(tp, 0x14, 0x85fb);
742
+        rtl8168_mdio_write(tp, 0x14, 0xe082);
743
+        rtl8168_mdio_write(tp, 0x14, 0x7ce3);
744
+        rtl8168_mdio_write(tp, 0x14, 0x85fe);
745
+        rtl8168_mdio_write(tp, 0x14, 0x1a03);
746
+        rtl8168_mdio_write(tp, 0x14, 0x10e4);
747
+        rtl8168_mdio_write(tp, 0x14, 0x85f8);
748
+        rtl8168_mdio_write(tp, 0x14, 0xe082);
749
+        rtl8168_mdio_write(tp, 0x14, 0x7c1b);
750
+        rtl8168_mdio_write(tp, 0x14, 0x03e4);
751
+        rtl8168_mdio_write(tp, 0x14, 0x85fc);
752
+        rtl8168_mdio_write(tp, 0x14, 0xe082);
753
+        rtl8168_mdio_write(tp, 0x14, 0x7de3);
754
+        rtl8168_mdio_write(tp, 0x14, 0x85fe);
755
+        rtl8168_mdio_write(tp, 0x14, 0x1a03);
756
+        rtl8168_mdio_write(tp, 0x14, 0x10e4);
757
+        rtl8168_mdio_write(tp, 0x14, 0x85f9);
758
+        rtl8168_mdio_write(tp, 0x14, 0xe082);
759
+        rtl8168_mdio_write(tp, 0x14, 0x7d1b);
760
+        rtl8168_mdio_write(tp, 0x14, 0x03e4);
761
+        rtl8168_mdio_write(tp, 0x14, 0x85fd);
762
+        rtl8168_mdio_write(tp, 0x14, 0xae50);
763
+        rtl8168_mdio_write(tp, 0x14, 0xe082);
764
+        rtl8168_mdio_write(tp, 0x14, 0x7ee3);
765
+        rtl8168_mdio_write(tp, 0x14, 0x85ff);
766
+        rtl8168_mdio_write(tp, 0x14, 0x1a03);
767
+        rtl8168_mdio_write(tp, 0x14, 0x10e4);
768
+        rtl8168_mdio_write(tp, 0x14, 0x85f6);
769
+        rtl8168_mdio_write(tp, 0x14, 0xe082);
770
+        rtl8168_mdio_write(tp, 0x14, 0x7e1b);
771
+        rtl8168_mdio_write(tp, 0x14, 0x03e4);
772
+        rtl8168_mdio_write(tp, 0x14, 0x85fa);
773
+        rtl8168_mdio_write(tp, 0x14, 0xe082);
774
+        rtl8168_mdio_write(tp, 0x14, 0x7fe3);
775
+        rtl8168_mdio_write(tp, 0x14, 0x85ff);
776
+        rtl8168_mdio_write(tp, 0x14, 0x1a03);
777
+        rtl8168_mdio_write(tp, 0x14, 0x10e4);
778
+        rtl8168_mdio_write(tp, 0x14, 0x85f7);
779
+        rtl8168_mdio_write(tp, 0x14, 0xe082);
780
+        rtl8168_mdio_write(tp, 0x14, 0x7f1b);
781
+        rtl8168_mdio_write(tp, 0x14, 0x03e4);
782
+        rtl8168_mdio_write(tp, 0x14, 0x85fb);
783
+        rtl8168_mdio_write(tp, 0x14, 0xe082);
784
+        rtl8168_mdio_write(tp, 0x14, 0x80e3);
785
+        rtl8168_mdio_write(tp, 0x14, 0x85ff);
786
+        rtl8168_mdio_write(tp, 0x14, 0x1a03);
787
+        rtl8168_mdio_write(tp, 0x14, 0x10e4);
788
+        rtl8168_mdio_write(tp, 0x14, 0x85f8);
789
+        rtl8168_mdio_write(tp, 0x14, 0xe082);
790
+        rtl8168_mdio_write(tp, 0x14, 0x801b);
791
+        rtl8168_mdio_write(tp, 0x14, 0x03e4);
792
+        rtl8168_mdio_write(tp, 0x14, 0x85fc);
793
+        rtl8168_mdio_write(tp, 0x14, 0xe082);
794
+        rtl8168_mdio_write(tp, 0x14, 0x81e3);
795
+        rtl8168_mdio_write(tp, 0x14, 0x85ff);
796
+        rtl8168_mdio_write(tp, 0x14, 0x1a03);
797
+        rtl8168_mdio_write(tp, 0x14, 0x10e4);
798
+        rtl8168_mdio_write(tp, 0x14, 0x85f9);
799
+        rtl8168_mdio_write(tp, 0x14, 0xe082);
800
+        rtl8168_mdio_write(tp, 0x14, 0x811b);
801
+        rtl8168_mdio_write(tp, 0x14, 0x03e4);
802
+        rtl8168_mdio_write(tp, 0x14, 0x85fd);
803
+        rtl8168_mdio_write(tp, 0x14, 0xe085);
804
+        rtl8168_mdio_write(tp, 0x14, 0xf6ad);
805
+        rtl8168_mdio_write(tp, 0x14, 0x2404);
806
+        rtl8168_mdio_write(tp, 0x14, 0xee85);
807
+        rtl8168_mdio_write(tp, 0x14, 0xf610);
808
+        rtl8168_mdio_write(tp, 0x14, 0xe085);
809
+        rtl8168_mdio_write(tp, 0x14, 0xf7ad);
810
+        rtl8168_mdio_write(tp, 0x14, 0x2404);
811
+        rtl8168_mdio_write(tp, 0x14, 0xee85);
812
+        rtl8168_mdio_write(tp, 0x14, 0xf710);
813
+        rtl8168_mdio_write(tp, 0x14, 0xe085);
814
+        rtl8168_mdio_write(tp, 0x14, 0xf8ad);
815
+        rtl8168_mdio_write(tp, 0x14, 0x2404);
816
+        rtl8168_mdio_write(tp, 0x14, 0xee85);
817
+        rtl8168_mdio_write(tp, 0x14, 0xf810);
818
+        rtl8168_mdio_write(tp, 0x14, 0xe085);
819
+        rtl8168_mdio_write(tp, 0x14, 0xf9ad);
820
+        rtl8168_mdio_write(tp, 0x14, 0x2404);
821
+        rtl8168_mdio_write(tp, 0x14, 0xee85);
822
+        rtl8168_mdio_write(tp, 0x14, 0xf910);
823
+        rtl8168_mdio_write(tp, 0x14, 0xe085);
824
+        rtl8168_mdio_write(tp, 0x14, 0xfaad);
825
+        rtl8168_mdio_write(tp, 0x14, 0x2704);
826
+        rtl8168_mdio_write(tp, 0x14, 0xee85);
827
+        rtl8168_mdio_write(tp, 0x14, 0xfa00);
828
+        rtl8168_mdio_write(tp, 0x14, 0xe085);
829
+        rtl8168_mdio_write(tp, 0x14, 0xfbad);
830
+        rtl8168_mdio_write(tp, 0x14, 0x2704);
831
+        rtl8168_mdio_write(tp, 0x14, 0xee85);
832
+        rtl8168_mdio_write(tp, 0x14, 0xfb00);
833
+        rtl8168_mdio_write(tp, 0x14, 0xe085);
834
+        rtl8168_mdio_write(tp, 0x14, 0xfcad);
835
+        rtl8168_mdio_write(tp, 0x14, 0x2704);
836
+        rtl8168_mdio_write(tp, 0x14, 0xee85);
837
+        rtl8168_mdio_write(tp, 0x14, 0xfc00);
838
+        rtl8168_mdio_write(tp, 0x14, 0xe085);
839
+        rtl8168_mdio_write(tp, 0x14, 0xfdad);
840
+        rtl8168_mdio_write(tp, 0x14, 0x2704);
841
+        rtl8168_mdio_write(tp, 0x14, 0xee85);
842
+        rtl8168_mdio_write(tp, 0x14, 0xfd00);
843
+        rtl8168_mdio_write(tp, 0x14, 0xe082);
844
+        rtl8168_mdio_write(tp, 0x14, 0x44ad);
845
+        rtl8168_mdio_write(tp, 0x14, 0x203f);
846
+        rtl8168_mdio_write(tp, 0x14, 0xe085);
847
+        rtl8168_mdio_write(tp, 0x14, 0xf6e4);
848
+        rtl8168_mdio_write(tp, 0x14, 0x8288);
849
+        rtl8168_mdio_write(tp, 0x14, 0xe085);
850
+        rtl8168_mdio_write(tp, 0x14, 0xfae4);
851
+        rtl8168_mdio_write(tp, 0x14, 0x8289);
852
+        rtl8168_mdio_write(tp, 0x14, 0xe082);
853
+        rtl8168_mdio_write(tp, 0x14, 0x440d);
854
+        rtl8168_mdio_write(tp, 0x14, 0x0458);
855
+        rtl8168_mdio_write(tp, 0x14, 0x01bf);
856
+        rtl8168_mdio_write(tp, 0x14, 0x8264);
857
+        rtl8168_mdio_write(tp, 0x14, 0x0215);
858
+        rtl8168_mdio_write(tp, 0x14, 0x38bf);
859
+        rtl8168_mdio_write(tp, 0x14, 0x824e);
860
+        rtl8168_mdio_write(tp, 0x14, 0x0213);
861
+        rtl8168_mdio_write(tp, 0x14, 0x06a0);
862
+        rtl8168_mdio_write(tp, 0x14, 0x010f);
863
+        rtl8168_mdio_write(tp, 0x14, 0xe082);
864
+        rtl8168_mdio_write(tp, 0x14, 0x44f6);
865
+        rtl8168_mdio_write(tp, 0x14, 0x20e4);
866
+        rtl8168_mdio_write(tp, 0x14, 0x8244);
867
+        rtl8168_mdio_write(tp, 0x14, 0x580f);
868
+        rtl8168_mdio_write(tp, 0x14, 0xe582);
869
+        rtl8168_mdio_write(tp, 0x14, 0x5aae);
870
+        rtl8168_mdio_write(tp, 0x14, 0x0ebf);
871
+        rtl8168_mdio_write(tp, 0x14, 0x825e);
872
+        rtl8168_mdio_write(tp, 0x14, 0xe382);
873
+        rtl8168_mdio_write(tp, 0x14, 0x44f7);
874
+        rtl8168_mdio_write(tp, 0x14, 0x3ce7);
875
+        rtl8168_mdio_write(tp, 0x14, 0x8244);
876
+        rtl8168_mdio_write(tp, 0x14, 0x0212);
877
+        rtl8168_mdio_write(tp, 0x14, 0xf0ad);
878
+        rtl8168_mdio_write(tp, 0x14, 0x213f);
879
+        rtl8168_mdio_write(tp, 0x14, 0xe085);
880
+        rtl8168_mdio_write(tp, 0x14, 0xf7e4);
881
+        rtl8168_mdio_write(tp, 0x14, 0x8288);
882
+        rtl8168_mdio_write(tp, 0x14, 0xe085);
883
+        rtl8168_mdio_write(tp, 0x14, 0xfbe4);
884
+        rtl8168_mdio_write(tp, 0x14, 0x8289);
885
+        rtl8168_mdio_write(tp, 0x14, 0xe082);
886
+        rtl8168_mdio_write(tp, 0x14, 0x440d);
887
+        rtl8168_mdio_write(tp, 0x14, 0x0558);
888
+        rtl8168_mdio_write(tp, 0x14, 0x01bf);
889
+        rtl8168_mdio_write(tp, 0x14, 0x826b);
890
+        rtl8168_mdio_write(tp, 0x14, 0x0215);
891
+        rtl8168_mdio_write(tp, 0x14, 0x38bf);
892
+        rtl8168_mdio_write(tp, 0x14, 0x824f);
893
+        rtl8168_mdio_write(tp, 0x14, 0x0213);
894
+        rtl8168_mdio_write(tp, 0x14, 0x06a0);
895
+        rtl8168_mdio_write(tp, 0x14, 0x010f);
896
+        rtl8168_mdio_write(tp, 0x14, 0xe082);
897
+        rtl8168_mdio_write(tp, 0x14, 0x44f6);
898
+        rtl8168_mdio_write(tp, 0x14, 0x21e4);
899
+        rtl8168_mdio_write(tp, 0x14, 0x8244);
900
+        rtl8168_mdio_write(tp, 0x14, 0x580f);
901
+        rtl8168_mdio_write(tp, 0x14, 0xe582);
902
+        rtl8168_mdio_write(tp, 0x14, 0x5bae);
903
+        rtl8168_mdio_write(tp, 0x14, 0x0ebf);
904
+        rtl8168_mdio_write(tp, 0x14, 0x8265);
905
+        rtl8168_mdio_write(tp, 0x14, 0xe382);
906
+        rtl8168_mdio_write(tp, 0x14, 0x44f7);
907
+        rtl8168_mdio_write(tp, 0x14, 0x3de7);
908
+        rtl8168_mdio_write(tp, 0x14, 0x8244);
909
+        rtl8168_mdio_write(tp, 0x14, 0x0212);
910
+        rtl8168_mdio_write(tp, 0x14, 0xf0ad);
911
+        rtl8168_mdio_write(tp, 0x14, 0x223f);
912
+        rtl8168_mdio_write(tp, 0x14, 0xe085);
913
+        rtl8168_mdio_write(tp, 0x14, 0xf8e4);
914
+        rtl8168_mdio_write(tp, 0x14, 0x8288);
915
+        rtl8168_mdio_write(tp, 0x14, 0xe085);
916
+        rtl8168_mdio_write(tp, 0x14, 0xfce4);
917
+        rtl8168_mdio_write(tp, 0x14, 0x8289);
918
+        rtl8168_mdio_write(tp, 0x14, 0xe082);
919
+        rtl8168_mdio_write(tp, 0x14, 0x440d);
920
+        rtl8168_mdio_write(tp, 0x14, 0x0658);
921
+        rtl8168_mdio_write(tp, 0x14, 0x01bf);
922
+        rtl8168_mdio_write(tp, 0x14, 0x8272);
923
+        rtl8168_mdio_write(tp, 0x14, 0x0215);
924
+        rtl8168_mdio_write(tp, 0x14, 0x38bf);
925
+        rtl8168_mdio_write(tp, 0x14, 0x8250);
926
+        rtl8168_mdio_write(tp, 0x14, 0x0213);
927
+        rtl8168_mdio_write(tp, 0x14, 0x06a0);
928
+        rtl8168_mdio_write(tp, 0x14, 0x010f);
929
+        rtl8168_mdio_write(tp, 0x14, 0xe082);
930
+        rtl8168_mdio_write(tp, 0x14, 0x44f6);
931
+        rtl8168_mdio_write(tp, 0x14, 0x22e4);
932
+        rtl8168_mdio_write(tp, 0x14, 0x8244);
933
+        rtl8168_mdio_write(tp, 0x14, 0x580f);
934
+        rtl8168_mdio_write(tp, 0x14, 0xe582);
935
+        rtl8168_mdio_write(tp, 0x14, 0x5cae);
936
+        rtl8168_mdio_write(tp, 0x14, 0x0ebf);
937
+        rtl8168_mdio_write(tp, 0x14, 0x826c);
938
+        rtl8168_mdio_write(tp, 0x14, 0xe382);
939
+        rtl8168_mdio_write(tp, 0x14, 0x44f7);
940
+        rtl8168_mdio_write(tp, 0x14, 0x3ee7);
941
+        rtl8168_mdio_write(tp, 0x14, 0x8244);
942
+        rtl8168_mdio_write(tp, 0x14, 0x0212);
943
+        rtl8168_mdio_write(tp, 0x14, 0xf0ad);
944
+        rtl8168_mdio_write(tp, 0x14, 0x233f);
945
+        rtl8168_mdio_write(tp, 0x14, 0xe085);
946
+        rtl8168_mdio_write(tp, 0x14, 0xf9e4);
947
+        rtl8168_mdio_write(tp, 0x14, 0x8288);
948
+        rtl8168_mdio_write(tp, 0x14, 0xe085);
949
+        rtl8168_mdio_write(tp, 0x14, 0xfde4);
950
+        rtl8168_mdio_write(tp, 0x14, 0x8289);
951
+        rtl8168_mdio_write(tp, 0x14, 0xe082);
952
+        rtl8168_mdio_write(tp, 0x14, 0x440d);
953
+        rtl8168_mdio_write(tp, 0x14, 0x0758);
954
+        rtl8168_mdio_write(tp, 0x14, 0x01bf);
955
+        rtl8168_mdio_write(tp, 0x14, 0x8279);
956
+        rtl8168_mdio_write(tp, 0x14, 0x0215);
957
+        rtl8168_mdio_write(tp, 0x14, 0x38bf);
958
+        rtl8168_mdio_write(tp, 0x14, 0x8251);
959
+        rtl8168_mdio_write(tp, 0x14, 0x0213);
960
+        rtl8168_mdio_write(tp, 0x14, 0x06a0);
961
+        rtl8168_mdio_write(tp, 0x14, 0x010f);
962
+        rtl8168_mdio_write(tp, 0x14, 0xe082);
963
+        rtl8168_mdio_write(tp, 0x14, 0x44f6);
964
+        rtl8168_mdio_write(tp, 0x14, 0x23e4);
965
+        rtl8168_mdio_write(tp, 0x14, 0x8244);
966
+        rtl8168_mdio_write(tp, 0x14, 0x580f);
967
+        rtl8168_mdio_write(tp, 0x14, 0xe582);
968
+        rtl8168_mdio_write(tp, 0x14, 0x5dae);
969
+        rtl8168_mdio_write(tp, 0x14, 0x0ebf);
970
+        rtl8168_mdio_write(tp, 0x14, 0x8273);
971
+        rtl8168_mdio_write(tp, 0x14, 0xe382);
972
+        rtl8168_mdio_write(tp, 0x14, 0x44f7);
973
+        rtl8168_mdio_write(tp, 0x14, 0x3fe7);
974
+        rtl8168_mdio_write(tp, 0x14, 0x8244);
975
+        rtl8168_mdio_write(tp, 0x14, 0x0212);
976
+        rtl8168_mdio_write(tp, 0x14, 0xf0ee);
977
+        rtl8168_mdio_write(tp, 0x14, 0x8288);
978
+        rtl8168_mdio_write(tp, 0x14, 0x10ee);
979
+        rtl8168_mdio_write(tp, 0x14, 0x8289);
980
+        rtl8168_mdio_write(tp, 0x14, 0x00af);
981
+        rtl8168_mdio_write(tp, 0x14, 0x14aa);
982
+        rtl8168_mdio_write(tp, 0x13, 0xb818);
983
+        rtl8168_mdio_write(tp, 0x14, 0x13cf);
984
+        rtl8168_mdio_write(tp, 0x13, 0xb81a);
985
+        rtl8168_mdio_write(tp, 0x14, 0xfffd);
986
+        rtl8168_mdio_write(tp, 0x13, 0xb81c);
987
+        rtl8168_mdio_write(tp, 0x14, 0xfffd);
988
+        rtl8168_mdio_write(tp, 0x13, 0xb81e);
989
+        rtl8168_mdio_write(tp, 0x14, 0xfffd);
990
+        rtl8168_mdio_write(tp, 0x13, 0xb832);
991
+        rtl8168_mdio_write(tp, 0x14, 0x0001);
992
+
993
+
994
+        rtl8168_mdio_write(tp, 0x1F, 0x0A43);
995
         rtl8168_mdio_write(tp, 0x13, 0x0000);
996
         rtl8168_mdio_write(tp, 0x14, 0x0000);
997
         rtl8168_mdio_write(tp, 0x1f, 0x0B82);
998
@@ -23070,7 +23451,7 @@
999
                 if (tp->HwHasWrRamCodeToMicroP) {
1000
                         rtl8168_mdio_write(tp, 0x1F, 0x0A43);
1001
                         rtl8168_mdio_write(tp, 0x13, 0x8011);
1002
-                        rtl8168_clear_eth_phy_bit(tp, 0x14, BIT_11);
1003
+                        rtl8168_set_eth_phy_bit(tp, 0x14, BIT_11);
1004
                         rtl8168_mdio_write(tp, 0x1F, 0x0A42);
1005
                         rtl8168_set_eth_phy_bit(tp, 0x16, BIT_1);
1006
                 }
1007
@@ -23105,6 +23486,28 @@
1008
                         rtl8168_mdio_write(tp, 0x1F, 0x0000);
1009
                 }
1010
 
1011
+                if (tp->HwHasWrRamCodeToMicroP) {
1012
+                        rtl8168_mdio_write(tp, 0x1F, 0x0A43);
1013
+                        rtl8168_mdio_write(tp, 0x13, 0x85FE);
1014
+                        ClearAndSetEthPhyBit(
1015
+                                tp,
1016
+                                0x14,
1017
+                                BIT_15|BIT_14|BIT_13|BIT_12|BIT_11|BIT_10|BIT_8,
1018
+                                BIT_9);
1019
+                        rtl8168_mdio_write(tp, 0x13, 0x85FF);
1020
+                        ClearAndSetEthPhyBit(
1021
+                                tp,
1022
+                                0x14,
1023
+                                BIT_15|BIT_14|BIT_13|BIT_12,
1024
+                                BIT_11|BIT_10|BIT_9|BIT_8);
1025
+                        rtl8168_mdio_write(tp, 0x13, 0x814B);
1026
+                        ClearAndSetEthPhyBit(
1027
+                                tp,
1028
+                                0x14,
1029
+                                BIT_15|BIT_14|BIT_13|BIT_11|BIT_10|BIT_9|BIT_8,
1030
+                                BIT_12);
1031
+                }
1032
+
1033
                 if (aspm) {
1034
                         if (tp->HwHasWrRamCodeToMicroP == TRUE) {
1035
                                 rtl8168_mdio_write(tp, 0x1F, 0x0A43);
1036
@@ -23262,6 +23665,7 @@
1037
                         if (tp->HwHasWrRamCodeToMicroP == TRUE) {
1038
                                 rtl8168_mdio_write(tp, 0x1F, 0x0A43);
1039
                                 rtl8168_set_eth_phy_bit( tp, 0x10, BIT_2 );
1040
+                                rtl8168_mdio_write(tp, 0x1F, 0x0000);
1041
                         }
1042
                 }
1043
         }
1044
@@ -23286,7 +23690,8 @@
1045
                 rtl8168_mdio_write(tp, 0x14, 0x9065);
1046
                 rtl8168_mdio_write(tp, 0x14, 0x1065);
1047
                 rtl8168_mdio_write(tp, 0x1F, 0x0000);
1048
-        } else if (tp->mcfg == CFG_METHOD_29 || tp->mcfg == CFG_METHOD_30) {
1049
+        } else if (tp->mcfg == CFG_METHOD_29 || tp->mcfg == CFG_METHOD_30 ||
1050
+                   tp->mcfg == CFG_METHOD_31 || tp->mcfg == CFG_METHOD_32) {
1051
                 //enable EthPhyPPSW
1052
                 rtl8168_mdio_write(tp, 0x1F, 0x0A44);
1053
                 rtl8168_set_eth_phy_bit( tp, 0x11, BIT_7 );
1054
@@ -23305,7 +23710,7 @@
1055
         rtl8168_mdio_write(tp, 0x1F, 0x0000);
1056
 
1057
         if (tp->HwHasWrRamCodeToMicroP == TRUE) {
1058
-                if (eee_enable == 1)
1059
+                if (tp->eee_enabled)
1060
                         rtl8168_enable_EEE(tp);
1061
                 else
1062
                         rtl8168_disable_EEE(tp);
1063
@@ -23498,8 +23903,21 @@
1064
                 break;
1065
         }
1066
 
1067
+        switch (tp->mcfg) {
1068
+        case CFG_METHOD_31:
1069
+        case CFG_METHOD_32:
1070
+                tp->HwPcieSNOffset = 0x16C;
1071
+                break;
1072
+        case CFG_METHOD_DEFAULT:
1073
+                tp->HwPcieSNOffset = 0;
1074
+                break;
1075
+        default:
1076
+                tp->HwPcieSNOffset = 0x164;
1077
+                break;
1078
+        }
1079
+
1080
 #ifdef ENABLE_REALWOW_SUPPORT
1081
-        get_realwow_hw_version(dev);
1082
+        rtl8168_get_realwow_hw_version(dev);
1083
 #endif //ENABLE_REALWOW_SUPPORT
1084
 
1085
         if (HW_DASH_SUPPORT_DASH(tp) && rtl8168_check_dash(tp))
1086
@@ -23551,7 +23969,7 @@
1087
 
1088
         if (HW_DASH_SUPPORT_TYPE_2(tp))
1089
                 tp->cmac_ioaddr = tp->mmio_addr;
1090
-        else if    (HW_DASH_SUPPORT_TYPE_3(tp))
1091
+        else if (HW_DASH_SUPPORT_TYPE_3(tp))
1092
                 tp->cmac_ioaddr = tp->mapped_cmac_ioaddr;
1093
 
1094
         switch (tp->mcfg) {
1095
@@ -23899,6 +24317,8 @@
1096
         dev->min_mtu = ETH_ZLEN;
1097
         dev->max_mtu = tp->max_jumbo_frame_size;
1098
 #endif //LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0)
1099
+        tp->eee_enabled = eee_enable;
1100
+        tp->eee_adv_t = MDIO_EEE_1000T | MDIO_EEE_100TX;
1101
 }
1102
 
1103
 static void
1104
@@ -24921,7 +25341,6 @@
1105
         case CFG_METHOD_21:
1106
         case CFG_METHOD_22:
1107
                 rtl8168_mdio_write(tp, MII_BMCR, BMCR_ANENABLE | BMCR_PDOWN);
1108
-                RTL_W8(0xD0, RTL_R8(0xD0) & ~BIT_6);
1109
                 break;
1110
         case CFG_METHOD_23:
1111
         case CFG_METHOD_24:
1112
@@ -25100,8 +25519,6 @@
1113
         goto out;
1114
 }
1115
 
1116
-#define PCI_DEVICE_SERIAL_NUMBER (0x0164)
1117
-
1118
 static void
1119
 #if LINUX_VERSION_CODE < KERNEL_VERSION(4,14,0)
1120
 rtl8168_esd_timer(unsigned long __opaque)
1121
@@ -25232,18 +25649,20 @@
1122
                 tp->esd_flag |= BIT_12;
1123
         }
1124
 
1125
-        pci_sn_l = rtl8168_csi_read(tp, PCI_DEVICE_SERIAL_NUMBER);
1126
-        if (pci_sn_l != tp->pci_cfg_space.pci_sn_l) {
1127
-                printk(KERN_ERR "%s: pci_sn_l = 0x%08x, should be 0x%08x \n.", dev->name, pci_sn_l, tp->pci_cfg_space.pci_sn_l);
1128
-                rtl8168_csi_write(tp, PCI_DEVICE_SERIAL_NUMBER, tp->pci_cfg_space.pci_sn_l);
1129
-                tp->esd_flag |= BIT_13;
1130
-        }
1131
+        if (tp->HwPcieSNOffset > 0) {
1132
+                pci_sn_l = rtl8168_csi_read(tp, tp->HwPcieSNOffset);
1133
+                if (pci_sn_l != tp->pci_cfg_space.pci_sn_l) {
1134
+                        printk(KERN_ERR "%s: pci_sn_l = 0x%08x, should be 0x%08x \n.", dev->name, pci_sn_l, tp->pci_cfg_space.pci_sn_l);
1135
+                        rtl8168_csi_write(tp, tp->HwPcieSNOffset, tp->pci_cfg_space.pci_sn_l);
1136
+                        tp->esd_flag |= BIT_13;
1137
+                }
1138
 
1139
-        pci_sn_h = rtl8168_csi_read(tp, PCI_DEVICE_SERIAL_NUMBER + 4);
1140
-        if (pci_sn_h != tp->pci_cfg_space.pci_sn_h) {
1141
-                printk(KERN_ERR "%s: pci_sn_h = 0x%08x, should be 0x%08x \n.", dev->name, pci_sn_h, tp->pci_cfg_space.pci_sn_h);
1142
-                rtl8168_csi_write(tp, PCI_DEVICE_SERIAL_NUMBER + 4, tp->pci_cfg_space.pci_sn_h);
1143
-                tp->esd_flag |= BIT_14;
1144
+                pci_sn_h = rtl8168_csi_read(tp, tp->HwPcieSNOffset + 4);
1145
+                if (pci_sn_h != tp->pci_cfg_space.pci_sn_h) {
1146
+                        printk(KERN_ERR "%s: pci_sn_h = 0x%08x, should be 0x%08x \n.", dev->name, pci_sn_h, tp->pci_cfg_space.pci_sn_h);
1147
+                        rtl8168_csi_write(tp, tp->HwPcieSNOffset + 4, tp->pci_cfg_space.pci_sn_h);
1148
+                        tp->esd_flag |= BIT_14;
1149
+                }
1150
         }
1151
 
1152
         if (tp->esd_flag != 0) {
1153
@@ -25430,7 +25849,7 @@
1154
                                    NETIF_F_RXCSUM | NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX;
1155
                 dev->vlan_features = NETIF_F_SG | NETIF_F_IP_CSUM |
1156
                                      NETIF_F_HIGHDMA;
1157
-                if ((tp->mcfg != CFG_METHOD_16) && (tp->mcfg == CFG_METHOD_17)) {
1158
+                if ((tp->mcfg != CFG_METHOD_16) && (tp->mcfg != CFG_METHOD_17)) {
1159
                         dev->features |= NETIF_F_TSO;
1160
                         dev->hw_features |= NETIF_F_TSO;
1161
                         dev->vlan_features |= NETIF_F_TSO;
1162
@@ -25453,7 +25872,7 @@
1163
                 } else {
1164
                         dev->hw_features |= NETIF_F_IPV6_CSUM;
1165
                         dev->features |=  NETIF_F_IPV6_CSUM;
1166
-                        if ((tp->mcfg != CFG_METHOD_16) && (tp->mcfg == CFG_METHOD_17)) {
1167
+                        if ((tp->mcfg != CFG_METHOD_16) && (tp->mcfg != CFG_METHOD_17)) {
1168
                                 dev->hw_features |= NETIF_F_TSO6;
1169
                                 dev->features |=  NETIF_F_TSO6;
1170
                         }
1171
@@ -25522,6 +25941,8 @@
1172
 
1173
         printk(KERN_INFO "%s: This product is covered by one or more of the following patents: US6,570,884, US6,115,776, and US6,327,625.\n", MODULENAME);
1174
 
1175
+        rtl8168_disable_rxdvgate(dev);
1176
+
1177
         device_set_wakeup_enable(&pdev->dev, tp->wol_enabled);
1178
 
1179
         netif_carrier_off(dev);
1180
@@ -25867,7 +26288,7 @@
1181
         void __iomem *ioaddr = tp->mmio_addr;
1182
         struct pci_dev *pdev = tp->pci_dev;
1183
         u8 device_control;
1184
-        u16 rtl8168_mac_ocp_data;
1185
+        u16 mac_ocp_data;
1186
         u32 csi_tmp;
1187
 
1188
 #if LINUX_VERSION_CODE < KERNEL_VERSION(3,0,0)
1189
@@ -26362,45 +26783,45 @@
1190
                 rtl8168_eri_write(ioaddr, 0xDC, 1, csi_tmp, ERIAR_ExGMAC);
1191
 
1192
                 if (tp->mcfg == CFG_METHOD_26) {
1193
-                        rtl8168_mac_ocp_data = rtl8168_mac_ocp_read(tp, 0xD3C0);
1194
-                        rtl8168_mac_ocp_data &= ~(BIT_11 | BIT_10 | BIT_9 | BIT_8 | BIT_7 | BIT_6 | BIT_5 | BIT_4 | BIT_3 | BIT_2 | BIT_1 | BIT_0);
1195
-                        rtl8168_mac_ocp_data |= 0x03A9;
1196
-                        rtl8168_mac_ocp_write(tp, 0xD3C0, rtl8168_mac_ocp_data);
1197
-                        rtl8168_mac_ocp_data = rtl8168_mac_ocp_read(tp, 0xD3C2);
1198
-                        rtl8168_mac_ocp_data &= ~(BIT_7 | BIT_6 | BIT_5 | BIT_4 | BIT_3 | BIT_2 | BIT_1 | BIT_0);
1199
-                        rtl8168_mac_ocp_write(tp, 0xD3C2, rtl8168_mac_ocp_data);
1200
-                        rtl8168_mac_ocp_data = rtl8168_mac_ocp_read(tp, 0xD3C4);
1201
-                        rtl8168_mac_ocp_data |= BIT_0;
1202
-                        rtl8168_mac_ocp_write(tp, 0xD3C4, rtl8168_mac_ocp_data);
1203
+                        mac_ocp_data = rtl8168_mac_ocp_read(tp, 0xD3C0);
1204
+                        mac_ocp_data &= ~(BIT_11 | BIT_10 | BIT_9 | BIT_8 | BIT_7 | BIT_6 | BIT_5 | BIT_4 | BIT_3 | BIT_2 | BIT_1 | BIT_0);
1205
+                        mac_ocp_data |= 0x03A9;
1206
+                        rtl8168_mac_ocp_write(tp, 0xD3C0, mac_ocp_data);
1207
+                        mac_ocp_data = rtl8168_mac_ocp_read(tp, 0xD3C2);
1208
+                        mac_ocp_data &= ~(BIT_7 | BIT_6 | BIT_5 | BIT_4 | BIT_3 | BIT_2 | BIT_1 | BIT_0);
1209
+                        rtl8168_mac_ocp_write(tp, 0xD3C2, mac_ocp_data);
1210
+                        mac_ocp_data = rtl8168_mac_ocp_read(tp, 0xD3C4);
1211
+                        mac_ocp_data |= BIT_0;
1212
+                        rtl8168_mac_ocp_write(tp, 0xD3C4, mac_ocp_data);
1213
                 } else if (tp->mcfg == CFG_METHOD_29 || tp->mcfg == CFG_METHOD_30) {
1214
 
1215
                         if (tp->RequireAdjustUpsTxLinkPulseTiming) {
1216
-                                rtl8168_mac_ocp_data = rtl8168_mac_ocp_read(tp, 0xD412);
1217
-                                rtl8168_mac_ocp_data &= ~(0x0FFF);
1218
-                                rtl8168_mac_ocp_data |= tp->SwrCnt1msIni;
1219
-                                rtl8168_mac_ocp_write(tp, 0xD412, rtl8168_mac_ocp_data);
1220
+                                mac_ocp_data = rtl8168_mac_ocp_read(tp, 0xD412);
1221
+                                mac_ocp_data &= ~(0x0FFF);
1222
+                                mac_ocp_data |= tp->SwrCnt1msIni;
1223
+                                rtl8168_mac_ocp_write(tp, 0xD412, mac_ocp_data);
1224
                         }
1225
 
1226
-                        rtl8168_mac_ocp_data = rtl8168_mac_ocp_read(tp, 0xE056);
1227
-                        rtl8168_mac_ocp_data &= ~(BIT_7 | BIT_6 | BIT_5 | BIT_4);
1228
-                        rtl8168_mac_ocp_data |= (BIT_6 | BIT_5 | BIT_4);
1229
-                        rtl8168_mac_ocp_write(tp, 0xE056, rtl8168_mac_ocp_data);
1230
-
1231
-                        rtl8168_mac_ocp_data = rtl8168_mac_ocp_read(tp, 0xE052);
1232
-                        rtl8168_mac_ocp_data &= ~( BIT_14 | BIT_13);
1233
-                        rtl8168_mac_ocp_data |= BIT_15;
1234
-                        rtl8168_mac_ocp_data |= BIT_3;
1235
-                        rtl8168_mac_ocp_write(tp, 0xE052, rtl8168_mac_ocp_data);
1236
-
1237
-                        rtl8168_mac_ocp_data = rtl8168_mac_ocp_read(tp, 0xD420);
1238
-                        rtl8168_mac_ocp_data &= ~(BIT_11 | BIT_10 | BIT_9 | BIT_8 | BIT_7 | BIT_6 | BIT_5 | BIT_4 | BIT_3 | BIT_2 | BIT_1 | BIT_0);
1239
-                        rtl8168_mac_ocp_data |= 0x47F;
1240
-                        rtl8168_mac_ocp_write(tp, 0xD420, rtl8168_mac_ocp_data);
1241
-
1242
-                        rtl8168_mac_ocp_data = rtl8168_mac_ocp_read(tp, 0xE0D6);
1243
-                        rtl8168_mac_ocp_data &= ~(BIT_8 | BIT_7 | BIT_6 | BIT_5 | BIT_4 | BIT_3 | BIT_2 | BIT_1 | BIT_0);
1244
-                        rtl8168_mac_ocp_data |= 0x17F;
1245
-                        rtl8168_mac_ocp_write(tp, 0xE0D6, rtl8168_mac_ocp_data);
1246
+                        mac_ocp_data = rtl8168_mac_ocp_read(tp, 0xE056);
1247
+                        mac_ocp_data &= ~(BIT_7 | BIT_6 | BIT_5 | BIT_4);
1248
+                        mac_ocp_data |= (BIT_6 | BIT_5 | BIT_4);
1249
+                        rtl8168_mac_ocp_write(tp, 0xE056, mac_ocp_data);
1250
+
1251
+                        mac_ocp_data = rtl8168_mac_ocp_read(tp, 0xE052);
1252
+                        mac_ocp_data &= ~( BIT_14 | BIT_13);
1253
+                        mac_ocp_data |= BIT_15;
1254
+                        mac_ocp_data |= BIT_3;
1255
+                        rtl8168_mac_ocp_write(tp, 0xE052, mac_ocp_data);
1256
+
1257
+                        mac_ocp_data = rtl8168_mac_ocp_read(tp, 0xD420);
1258
+                        mac_ocp_data &= ~(BIT_11 | BIT_10 | BIT_9 | BIT_8 | BIT_7 | BIT_6 | BIT_5 | BIT_4 | BIT_3 | BIT_2 | BIT_1 | BIT_0);
1259
+                        mac_ocp_data |= 0x47F;
1260
+                        rtl8168_mac_ocp_write(tp, 0xD420, mac_ocp_data);
1261
+
1262
+                        mac_ocp_data = rtl8168_mac_ocp_read(tp, 0xE0D6);
1263
+                        mac_ocp_data &= ~(BIT_8 | BIT_7 | BIT_6 | BIT_5 | BIT_4 | BIT_3 | BIT_2 | BIT_1 | BIT_0);
1264
+                        mac_ocp_data |= 0x17F;
1265
+                        rtl8168_mac_ocp_write(tp, 0xE0D6, mac_ocp_data);
1266
                 }
1267
 
1268
                 RTL_W8(Config3, RTL_R8(Config3) & ~Beacon_en);
1269
@@ -26534,18 +26955,18 @@
1270
                 rtl8168_mac_ocp_write(tp, 0xC142, 0xFFFF);
1271
 
1272
                 if (tp->mcfg == CFG_METHOD_28) {
1273
-                        rtl8168_mac_ocp_data = rtl8168_mac_ocp_read(tp, 0xD3E2);
1274
-                        rtl8168_mac_ocp_data &= 0xF000;
1275
-                        rtl8168_mac_ocp_data |= 0x3A9;
1276
-                        rtl8168_mac_ocp_write(tp, 0xD3E2, rtl8168_mac_ocp_data);
1277
-
1278
-                        rtl8168_mac_ocp_data = rtl8168_mac_ocp_read(tp, 0xD3E4);
1279
-                        rtl8168_mac_ocp_data &= 0xFF00;
1280
-                        rtl8168_mac_ocp_write(tp, 0xD3E4, rtl8168_mac_ocp_data);
1281
-
1282
-                        rtl8168_mac_ocp_data = rtl8168_mac_ocp_read(tp, 0xE860);
1283
-                        rtl8168_mac_ocp_data |= BIT_7;
1284
-                        rtl8168_mac_ocp_write(tp, 0xE860, rtl8168_mac_ocp_data);
1285
+                        mac_ocp_data = rtl8168_mac_ocp_read(tp, 0xD3E2);
1286
+                        mac_ocp_data &= 0xF000;
1287
+                        mac_ocp_data |= 0x3A9;
1288
+                        rtl8168_mac_ocp_write(tp, 0xD3E2, mac_ocp_data);
1289
+
1290
+                        mac_ocp_data = rtl8168_mac_ocp_read(tp, 0xD3E4);
1291
+                        mac_ocp_data &= 0xFF00;
1292
+                        rtl8168_mac_ocp_write(tp, 0xD3E4, mac_ocp_data);
1293
+
1294
+                        mac_ocp_data = rtl8168_mac_ocp_read(tp, 0xE860);
1295
+                        mac_ocp_data |= BIT_7;
1296
+                        rtl8168_mac_ocp_write(tp, 0xE860, mac_ocp_data);
1297
                 }
1298
 
1299
                 rtl8168_set_dash_other_fun_dev_pci_cmd_register(tp, 0x07, 0x0E);
1300
@@ -26569,31 +26990,32 @@
1301
                 rtl8168_eri_write(ioaddr, 0xDC, 1, csi_tmp, ERIAR_ExGMAC);
1302
 
1303
                 if (tp->RequireAdjustUpsTxLinkPulseTiming) {
1304
-                        rtl8168_mac_ocp_data = rtl8168_mac_ocp_read(tp, 0xD412);
1305
-                        rtl8168_mac_ocp_data &= ~(0x0FFF);
1306
-                        rtl8168_mac_ocp_data |= tp->SwrCnt1msIni;
1307
-                        rtl8168_mac_ocp_write(tp, 0xD412, rtl8168_mac_ocp_data);
1308
+                        mac_ocp_data = rtl8168_mac_ocp_read(tp, 0xD412);
1309
+                        mac_ocp_data &= ~(0x0FFF);
1310
+                        mac_ocp_data |= tp->SwrCnt1msIni;
1311
+                        rtl8168_mac_ocp_write(tp, 0xD412, mac_ocp_data);
1312
                 }
1313
 
1314
-                rtl8168_mac_ocp_data = rtl8168_mac_ocp_read(tp, 0xE056);
1315
-                rtl8168_mac_ocp_data &= ~(BIT_7 | BIT_6 | BIT_5 | BIT_4);
1316
-                rtl8168_mac_ocp_data |= (BIT_6 | BIT_5 | BIT_4);
1317
-                rtl8168_mac_ocp_write(tp, 0xE056, rtl8168_mac_ocp_data);
1318
+                mac_ocp_data = rtl8168_mac_ocp_read(tp, 0xE056);
1319
+                mac_ocp_data &= ~(BIT_7 | BIT_6 | BIT_5 | BIT_4);
1320
+                mac_ocp_data |= (BIT_6 | BIT_5 | BIT_4);
1321
+                rtl8168_mac_ocp_write(tp, 0xE056, mac_ocp_data);
1322
                 rtl8168_mac_ocp_write(tp, 0xEA80, 0x0003);
1323
 
1324
                 rtl8168_oob_mutex_lock(tp);
1325
-                rtl8168_mac_ocp_data = rtl8168_mac_ocp_read(tp, 0xE052);
1326
+                mac_ocp_data = rtl8168_mac_ocp_read(tp, 0xE052);
1327
+                mac_ocp_data |= BIT_0;
1328
                 if (tp->mcfg == CFG_METHOD_32)
1329
-                        rtl8168_mac_ocp_data |= BIT_3;
1330
+                        mac_ocp_data |= BIT_3;
1331
                 else
1332
-                        rtl8168_mac_ocp_data &= ~BIT_3;
1333
-                rtl8168_mac_ocp_write(tp, 0xE052, rtl8168_mac_ocp_data);
1334
+                        mac_ocp_data &= ~BIT_3;
1335
+                rtl8168_mac_ocp_write(tp, 0xE052, mac_ocp_data);
1336
                 rtl8168_oob_mutex_unlock(tp);
1337
 
1338
-                rtl8168_mac_ocp_data = rtl8168_mac_ocp_read(tp, 0xD420);
1339
-                rtl8168_mac_ocp_data &= ~(BIT_11 | BIT_10 | BIT_9 | BIT_8 | BIT_7 | BIT_6 | BIT_5 | BIT_4 | BIT_3 | BIT_2 | BIT_1 | BIT_0);
1340
-                rtl8168_mac_ocp_data |= 0x47F;
1341
-                rtl8168_mac_ocp_write(tp, 0xD420, rtl8168_mac_ocp_data);
1342
+                mac_ocp_data = rtl8168_mac_ocp_read(tp, 0xD420);
1343
+                mac_ocp_data &= ~(BIT_11 | BIT_10 | BIT_9 | BIT_8 | BIT_7 | BIT_6 | BIT_5 | BIT_4 | BIT_3 | BIT_2 | BIT_1 | BIT_0);
1344
+                mac_ocp_data |= 0x47F;
1345
+                rtl8168_mac_ocp_write(tp, 0xD420, mac_ocp_data);
1346
 
1347
                 RTL_W8(Config3, RTL_R8(Config3) & ~Beacon_en);
1348
 
1349
@@ -26617,12 +27039,8 @@
1350
                 rtl8168_eri_write(ioaddr, 0xC0, 2, 0x0000, ERIAR_ExGMAC);
1351
                 rtl8168_eri_write(ioaddr, 0xB8, 4, 0x00000000, ERIAR_ExGMAC);
1352
 
1353
-                rtl8168_mac_ocp_write(tp, 0xE054, 0xFC01);
1354
-
1355
                 rtl8168_oob_mutex_lock(tp);
1356
-                csi_tmp = rtl8168_eri_read(ioaddr, 0x5F0, 4, ERIAR_ExGMAC);
1357
-                csi_tmp |= (BIT_8 | BIT_9 | BIT_10 | BIT_11);
1358
-                rtl8168_eri_write(ioaddr, 0x5F0, 4, csi_tmp, ERIAR_ExGMAC);
1359
+                rtl8168_eri_write(ioaddr, 0x5F0, 2, 0x4F87, ERIAR_ExGMAC);
1360
                 rtl8168_oob_mutex_unlock(tp);
1361
 
1362
                 csi_tmp = rtl8168_eri_read(ioaddr, 0xD4, 4, ERIAR_ExGMAC);
1363
@@ -26638,7 +27056,7 @@
1364
                 rtl8168_eri_write(ioaddr, 0x1B0, 4, csi_tmp, ERIAR_ExGMAC);
1365
 
1366
                 csi_tmp = rtl8168_eri_read(ioaddr, 0x2FC, 1, ERIAR_ExGMAC);
1367
-                csi_tmp &= ~(BIT_0 | BIT_1 | BIT_2);
1368
+                csi_tmp &= ~(BIT_0 | BIT_1);
1369
                 csi_tmp |= BIT_0;
1370
                 rtl8168_eri_write(ioaddr, 0x2FC, 1, csi_tmp, ERIAR_ExGMAC);
1371
 
1372
@@ -26646,19 +27064,6 @@
1373
                 csi_tmp &= ~BIT_1;
1374
                 rtl8168_eri_write(ioaddr, 0x1D0, 1, csi_tmp, ERIAR_ExGMAC);
1375
 
1376
-                rtl8168_mac_ocp_data = rtl8168_mac_ocp_read(tp, 0xD3E2);
1377
-                rtl8168_mac_ocp_data &= 0xF000;
1378
-                rtl8168_mac_ocp_data |= 0x3A9;
1379
-                rtl8168_mac_ocp_write(tp, 0xD3E2, rtl8168_mac_ocp_data);
1380
-
1381
-                rtl8168_mac_ocp_data = rtl8168_mac_ocp_read(tp, 0xD3E4);
1382
-                rtl8168_mac_ocp_data &= 0xFF00;
1383
-                rtl8168_mac_ocp_write(tp, 0xD3E4, rtl8168_mac_ocp_data);
1384
-
1385
-                rtl8168_mac_ocp_data = rtl8168_mac_ocp_read(tp, 0xE860);
1386
-                rtl8168_mac_ocp_data |= BIT_7;
1387
-                rtl8168_mac_ocp_write(tp, 0xE860, rtl8168_mac_ocp_data);
1388
-
1389
                 rtl8168_set_dash_other_fun_dev_aspm_clkreq(tp, 2, 1, 0xED);
1390
                 rtl8168_set_dash_other_fun_dev_state_change(tp, 3, 0x78);
1391
                 if (tp->DASH) {
1392
@@ -26773,7 +27178,7 @@
1393
                 break;
1394
         case CFG_METHOD_31:
1395
         case CFG_METHOD_32:
1396
-                rtl8168_mac_ocp_write(tp, 0xE098, rtl8168_mac_ocp_read(tp, 0xE098) | (0x64 << 4));
1397
+                rtl8168_mac_ocp_write(tp, 0xE098, 0xC302);
1398
                 break;
1399
         }
1400
 
1401
@@ -26871,8 +27276,10 @@
1402
                 pci_read_config_word(pdev, PCI_BASE_ADDRESS_5 + 2, &tp->pci_cfg_space.resv_0x24_h);
1403
                 pci_read_config_word(pdev, PCI_SUBSYSTEM_VENDOR_ID, &tp->pci_cfg_space.resv_0x2c_l);
1404
                 pci_read_config_word(pdev, PCI_SUBSYSTEM_VENDOR_ID + 2, &tp->pci_cfg_space.resv_0x2c_h);
1405
-                tp->pci_cfg_space.pci_sn_l = rtl8168_csi_read(tp, PCI_DEVICE_SERIAL_NUMBER);
1406
-                tp->pci_cfg_space.pci_sn_h = rtl8168_csi_read(tp, PCI_DEVICE_SERIAL_NUMBER + 4);
1407
+                if (tp->HwPcieSNOffset > 0) {
1408
+                        tp->pci_cfg_space.pci_sn_l = rtl8168_csi_read(tp, tp->HwPcieSNOffset);
1409
+                        tp->pci_cfg_space.pci_sn_h = rtl8168_csi_read(tp, tp->HwPcieSNOffset + 4);
1410
+                }
1411
 
1412
                 tp->pci_cfg_is_read = 1;
1413
         }
1414
@@ -27356,7 +27763,7 @@
1415
         rtl8168_rx_interrupt(dev, tp, tp->mmio_addr, &budget);
1416
 #else
1417
         rtl8168_rx_interrupt(dev, tp, tp->mmio_addr, budget);
1418
-#endif //LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
1419
+#endif  //LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
1420
 
1421
         spin_lock_irqsave(&tp->lock, flags);
1422
 
1423
@@ -28244,7 +28651,7 @@
1424
                         rtl8168_rx_interrupt(dev, tp, tp->mmio_addr, &budget);
1425
 #else
1426
                         rtl8168_rx_interrupt(dev, tp, tp->mmio_addr, budget);
1427
-#endif //LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
1428
+#endif  //LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
1429
                         rtl8168_tx_interrupt(dev, tp, ioaddr);
1430
 
1431
 #ifdef ENABLE_DASH_SUPPORT
1432
@@ -28409,6 +28816,14 @@
1433
                                             tp->ShortPacketEmptyBufferPhy);
1434
                         tp->ShortPacketEmptyBuffer = NULL;
1435
                 }
1436
+        } else {
1437
+                spin_lock_irqsave(&tp->lock, flags);
1438
+
1439
+                rtl8168_hw_d3_para(dev);
1440
+
1441
+                rtl8168_powerdown_pll(dev);
1442
+
1443
+                spin_unlock_irqrestore(&tp->lock, flags);
1444
         }
1445
 
1446
         return 0;
1447
@@ -28427,10 +28842,6 @@
1448
         if (s5_keep_curr_mac == 0 && tp->random_mac == 0)
1449
                 rtl8168_rar_set(tp, tp->org_mac_addr);
1450
 
1451
-#ifdef ENABLE_REALWOW_SUPPORT
1452
-        set_realwow_d3_para(dev);
1453
-#endif
1454
-
1455
 #ifdef ENABLE_FIBER_SUPPORT
1456
         rtl8168_hw_fiber_nic_d3_para(dev);
1457
 #endif  //ENABLE_FIBER_SUPPORT
1458
@@ -28505,10 +28916,6 @@
1459
 
1460
         rtl8168_hw_d3_para(dev);
1461
 
1462
-#ifdef ENABLE_REALWOW_SUPPORT
1463
-        set_realwow_d3_para(dev);
1464
-#endif
1465
-
1466
 #ifdef ENABLE_FIBER_SUPPORT
1467
         rtl8168_hw_fiber_nic_d3_para(dev);
1468
 #endif  //ENABLE_FIBER_SUPPORT
1469
r8168-8.047.01.tar.bz2/src/r8168_realwow.h -> r8168-8.047.04.tar.bz2/src/r8168_realwow.h Changed
13
 
1
@@ -110,8 +110,8 @@
2
 } RealWoWWPInfo,*PRealWoWWPInfo;
3
 
4
 int rtl8168_realwow_ioctl(struct net_device *dev, struct ifreq *ifr);
5
-void realwow_hw_init(struct net_device *dev);
6
-void get_realwow_hw_version(struct net_device *dev);
7
-void set_realwow_d3_para(struct net_device *dev);
8
+void rtl8168_realwow_hw_init(struct net_device *dev);
9
+void rtl8168_get_realwow_hw_version(struct net_device *dev);
10
+void rtl8168_set_realwow_d3_para(struct net_device *dev);
11
 
12
 #endif /* _LINUX_R8168_REALWOW_H */
13
Refresh
============================ rpmlint session starts ============================
rpmlint: 2.6.1
configuration:
/opt/testing/lib64/python3.13/rpmlint/configdefaults.toml
/opt/testing/share/rpmlint/cron-whitelist.toml
/opt/testing/share/rpmlint/dbus-services.toml
/opt/testing/share/rpmlint/device-files-whitelist.toml
/opt/testing/share/rpmlint/licenses.toml
/opt/testing/share/rpmlint/opensuse.toml
/opt/testing/share/rpmlint/pam-modules.toml
/opt/testing/share/rpmlint/permissions-whitelist.toml
/opt/testing/share/rpmlint/pie-executables.toml
/opt/testing/share/rpmlint/polkit-rules-whitelist.toml
/opt/testing/share/rpmlint/scoring.toml
/opt/testing/share/rpmlint/security.toml
/opt/testing/share/rpmlint/sudoers-whitelist.toml
/opt/testing/share/rpmlint/sysctl-whitelist.toml
/opt/testing/share/rpmlint/systemd-tmpfiles.toml
/opt/testing/share/rpmlint/users-groups.toml
/opt/testing/share/rpmlint/world-writable-whitelist.toml
/opt/testing/share/rpmlint/zypper-plugins.toml
checks: 41, packages: 3

r8168-kmp-default.x86_64: E: suse-zypp-packageand packageand(kernel-default:r8168)
The 'packageand(package1:package2)' syntax is obsolete, please use boolean
dependencies like: 'Supplements: (package1 and package2)'

r8168.spec: W: no-%check-section
The spec file does not contain an %check section. Please check if the package
has a testsuite and what it takes to enable the testsuite as part of the
package build. If it is not possible to run it in the build environment
(OBS/koji) or no testsuite exists, then please ignore this warning. You should
not insert an empty %check section.

Check time report (&gt;1% &amp; &gt;0.1s):
Check                            Duration (in s)   Fraction (in %)  Checked files
ExtractRpm                                   0.3              86.9
TOTAL                                        0.4             100.0

3 packages and 0 specfiles checked; 1 errors, 1 warnings, 15 filtered, 1 badness; has taken 0.4 s
Request History
bitstreamout's avatar

bitstreamout created request over 5 years ago

- (Re)add #!BuildIgnore: enough-build-resources

- Update to new version 8.047.04

- Update to new version 8.047.01


Hillwood Yang's avatar

hillwood accepted request over 5 years ago