netif/re: Sync with Realtek's re-1.95.
[dragonfly.git] / sys / dev / netif / re / re.c
1 /*
2  * Copyright (c) 1997, 1998
3  *      Bill Paul <wpaul@ctr.columbia.edu>.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. All advertising materials mentioning features or use of this software
14  *    must display the following acknowledgement:
15  *      This product includes software developed by Bill Paul.
16  * 4. Neither the name of the author nor the names of any co-contributors
17  *    may be used to endorse or promote products derived from this software
18  *    without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND
21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23  * ARE DISCLAIMED.  IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD
24  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
30  * THE POSSIBILITY OF SUCH DAMAGE.
31  *
32  * $FreeBSD: src/sys/dev/if_rl.c,v 1.38.2.7 2001/07/19 18:33:07 wpaul Exp $
33  */
34
35 /*
36  * RealTek 8129/8139 PCI NIC driver
37  *
38  * Written by Bill Paul <wpaul@ctr.columbia.edu>
39  * Electrical Engineering Department
40  * Columbia University, New York City
41  */
42
43 #ifndef __DragonFly__
44 #include <sys/cdefs.h>
45 __FBSDID("$FreeBSD: src/sys/dev/re/if_re.c,v 1.95.00 " __DATE__ " " __TIME__ "  wpaul Exp $");
46
47 /*
48 * This driver also support Realtek 8139C+, 8110S/SB/SC, RTL8111B/C/CP/D and RTL8101E/8102E/8103E.
49 */
50
51 #include <sys/param.h>
52 #include <sys/systm.h>
53 #include <sys/sockio.h>
54 #include <sys/mbuf.h>
55 #include <sys/malloc.h>
56 #include <sys/kernel.h>
57 #include <sys/socket.h>
58 #include <sys/taskqueue.h>
59 #include <sys/random.h>
60
61 #include <net/if.h>
62 #include <net/if_var.h>
63 #include <net/if_arp.h>
64 #include <net/ethernet.h>
65 #include <net/if_dl.h>
66 #include <net/if_media.h>
67
68 #include <net/bpf.h>
69
70 #include <vm/vm.h>              /* for vtophys */
71 #include <vm/pmap.h>            /* for vtophys */
72 #include <machine/clock.h>      /* for DELAY */
73
74 #include <machine/bus.h>
75 #include <machine/resource.h>
76 #include <sys/bus.h>
77 #include <sys/rman.h>
78 #include <sys/endian.h>
79
80 #include <dev/mii/mii.h>
81 #include <dev/re/if_rereg.h>
82
83 #if OS_VER < VERSION(5,3)
84 #include <pci/pcireg.h>
85 #include <pci/pcivar.h>
86 #include <machine/bus_pio.h>
87 #include <machine/bus_memio.h>
88 #else
89 #include <dev/pci/pcireg.h>
90 #include <dev/pci/pcivar.h>
91 #include <sys/module.h>
92 #endif
93
94 #if OS_VER > VERSION(5,9)
95 #include <sys/cdefs.h>
96 #include <sys/endian.h>
97 #include <net/if_types.h>
98 #include <net/if_vlan_var.h>
99 #endif
100 #else   /* __DragonFly__ */
101
102 #include <sys/param.h>
103 #include <sys/bus.h>
104 #include <sys/endian.h>
105 #include <sys/kernel.h>
106 #include <sys/systm.h>
107
108 #include <net/ethernet.h>
109 #include <net/if.h>
110 #include <net/if_arp.h>
111 #include <net/if_dl.h>
112 #include <net/if_media.h>
113 #include <net/if_poll.h>
114 #include <net/vlan/if_vlan_var.h>
115
116 #include <bus/pci/pcireg.h>
117 #include <bus/pci/pcivar.h>
118
119 #include <dev/netif/mii_layer/mii.h>
120 #include <dev/netif/re/if_revar.h>
121 #include <dev/netif/re/re.h>
122 #include <dev/netif/re/re_dragonfly.h>
123
124 #define RE_LOCK(sc)
125 #define RE_UNLOCK(sc)
126 #define RE_LOCK_ASSERT(sc)
127
128 #define RE_GET_IFNET(sc)        &(sc)->arpcom.ac_if
129
130 #endif  /* !__DragonFly__ */
131
132 #define EE_SET(x)                                       \
133         CSR_WRITE_1(sc, RE_EECMD,                       \
134                 CSR_READ_1(sc, RE_EECMD) | x)
135
136 #define EE_CLR(x)                                       \
137         CSR_WRITE_1(sc, RE_EECMD,                       \
138                 CSR_READ_1(sc, RE_EECMD) & ~x)
139
140 #ifndef __DragonFly__
141 /*
142  * Various supported device vendors/types and their names.
143  */
144 static struct re_type re_devs[] = {
145         {
146                 RT_VENDORID, RT_DEVICEID_8169,
147                 "Realtek PCI GBE Family Controller"
148         },
149         {
150                 RT_VENDORID, RT_DEVICEID_8169SC,
151                 "Realtek PCI GBE Family Controller"
152         },
153         {
154                 RT_VENDORID, RT_DEVICEID_8168,
155                 "Realtek PCIe GBE Family Controller"
156         },
157         {
158                 RT_VENDORID, RT_DEVICEID_8161,
159                 "Realtek PCIe GBE Family Controller"
160         },
161         {
162                 RT_VENDORID, RT_DEVICEID_8136,
163                 "Realtek PCIe FE Family Controller"
164         },
165         {
166                 DLINK_VENDORID, 0x4300,
167                 "Realtek PCI GBE Family Controller"
168         },
169         { 0, 0, NULL }
170 };
171
172 static int      re_probe                        __P((device_t));
173 static int      re_attach                       __P((device_t));
174 static int      re_detach                       __P((device_t));
175 static int      re_suspend                      __P((device_t));
176 static int      re_resume                       __P((device_t));
177 static int      re_shutdown                     __P((device_t));
178
179 static void MP_WritePhyUshort                   __P((struct re_softc*, u_int8_t, u_int16_t));
180 static u_int16_t MP_ReadPhyUshort               __P((struct re_softc*, u_int8_t));
181 static void MP_WriteEPhyUshort                  __P((struct re_softc*, u_int8_t, u_int16_t));
182 static u_int16_t MP_ReadEPhyUshort              __P((struct re_softc*, u_int8_t));
183 static u_int8_t MP_ReadEfuse                    __P((struct re_softc*, u_int16_t));
184 static void MP_WritePhyOcpRegWord       __P((struct re_softc*, u_int16_t, u_int8_t, u_int16_t));
185 static u_int16_t MP_ReadPhyOcpRegWord   __P((struct re_softc*, u_int16_t, u_int8_t));
186 static void MP_WriteMcuAccessRegWord    __P((struct re_softc*, u_int16_t, u_int16_t));
187 static u_int16_t MP_ReadMcuAccessRegWord  __P((struct re_softc*, u_int16_t));
188 static void MP_WriteOtherFunPciEConfigSpace    __P((struct re_softc *, u_int8_t, u_int16_t, u_int32_t Regata));
189 static u_int32_t MP_ReadOtherFunPciEConfigSpace   __P((struct re_softc *, u_int8_t, u_int16_t));
190 static void MP_WritePciEConfigSpace     __P((struct re_softc*, u_int16_t, u_int32_t));
191 static u_int32_t MP_ReadPciEConfigSpace __P((struct re_softc*, u_int16_t));
192 #endif  /* !__DragonFly__ */
193
194 static int re_check_dash  __P((struct re_softc *));
195
196 #ifndef __DragonFly__
197 static void re_driver_start             __P((struct re_softc*));
198 static void re_driver_stop              __P((struct re_softc*));
199
200 static void re_hw_phy_config            __P((struct re_softc *));
201 static void re_init                     __P((void *));
202 static int  re_var_init                 __P((struct re_softc *));
203 static void re_reset                    __P((struct re_softc *));
204 static void re_stop                     __P((struct re_softc *));
205 static void re_setwol                   __P((struct re_softc *));
206 #endif  /* !__DragonFly__ */
207 static void re_clrwol                   __P((struct re_softc *));
208 static void re_set_wol_linkspeed        __P((struct re_softc *));
209
210 #ifndef __DragonFly__
211 static void re_start                            __P((struct ifnet *));
212 static int re_encap                             __P((struct re_softc *, struct mbuf *));
213 static void WritePacket                         __P((struct re_softc *, caddr_t, int, int, int, uint32_t, uint32_t));
214 static int CountFreeTxDescNum                   __P((struct re_descriptor));
215 static int CountMbufNum                         __P((struct mbuf *));
216 #ifdef RE_FIXUP_RX
217 static __inline void re_fixup_rx                __P((struct mbuf *));
218 #endif
219 static void re_txeof                            __P((struct re_softc *));
220
221 static void re_rxeof                            __P((struct re_softc *));
222
223 #if OS_VER < VERSION(7,0)
224 static void re_intr                             __P((void *));
225 #else
226 static int re_intr                              __P((void *));
227 #endif //OS_VER < VERSION(7,0)
228 #endif  /* !__DragonFly__ */
229 static void re_set_multicast_reg        __P((struct re_softc *, u_int32_t, u_int32_t));
230 #ifndef __DragonFly__
231 static void re_set_rx_packet_filter_in_sleep_state      __P((struct re_softc *));
232 #endif
233 static void re_set_rx_packet_filter     __P((struct re_softc *));
234 static void re_setmulti                 __P((struct re_softc *));
235 #ifndef __DragonFly__
236 static int  re_ioctl                    __P((struct ifnet *, u_long, caddr_t));
237 #endif
238 static u_int8_t re_link_ok      __P((struct re_softc *));
239 static void re_link_on_patch    __P((struct re_softc *));
240 #ifndef __DragonFly__
241 static void re_link_down_patch  __P((struct re_softc *));
242 static void re_init_timer       __P((struct re_softc *));
243 static void re_stop_timer       __P((struct re_softc *));
244 static void re_start_timer      __P((struct re_softc *));
245 static void re_tick                             __P((void *));
246 #if OS_VER < VERSION(7,0)
247 static void re_watchdog                         __P((struct ifnet *));
248 #endif
249 #endif  /* !__DragonFly__ */
250
251 static int  re_ifmedia_upd                      __P((struct ifnet *));
252 static void re_ifmedia_sts                      __P((struct ifnet *, struct ifmediareq *));
253
254 static void re_eeprom_ShiftOutBits              __P((struct re_softc *, int, int));
255 static u_int16_t re_eeprom_ShiftInBits          __P((struct re_softc *));
256 static void re_eeprom_EEpromCleanup             __P((struct re_softc *));
257 static void re_eeprom_getword                   __P((struct re_softc *, int, u_int16_t *));
258 static void re_read_eeprom                      __P((struct re_softc *, caddr_t, int, int, int));
259 #ifndef __DragonFly__
260 static void re_int_task                         (void *, int);
261 #endif  /* !__DragonFly__ */
262
263 static void re_phy_power_up(device_t dev);
264 static void re_phy_power_down(device_t dev);
265 #ifndef __DragonFly__
266 static int re_alloc_buf(struct re_softc *);
267 static void re_release_buf(struct re_softc *);
268 static void set_rxbufsize(struct re_softc*);
269 static void re_release_rx_buf(struct re_softc *);
270 static void re_release_tx_buf(struct re_softc *);
271 #endif  /* !__DragonFly__ */
272 static u_int32_t re_eri_read(struct re_softc *, int, int, int);
273 static int re_eri_write(struct re_softc *, int, int, u_int32_t, int);
274 static void OOB_mutex_lock(struct re_softc *);
275 static void OOB_mutex_unlock(struct re_softc *);
276
277 #ifdef __DragonFly__
278 u_int16_t MP_ReadMcuAccessRegWord(struct re_softc *, u_int16_t);
279 void MP_WriteMcuAccessRegWord(struct re_softc *, u_int16_t, u_int16_t);
280
281 u_int16_t MP_ReadPhyOcpRegWord(struct re_softc *, u_int16_t, u_int8_t);
282 void MP_WritePhyOcpRegWord(struct re_softc *, u_int16_t, u_int8_t, u_int16_t);
283
284 void MP_WritePhyUshort(struct re_softc *, u_int8_t, u_int16_t);
285 u_int16_t MP_ReadPhyUshort(struct re_softc *, u_int8_t);
286
287 u_int32_t MP_ReadPciEConfigSpace(struct re_softc *, u_int16_t);
288 void MP_WritePciEConfigSpace(struct re_softc *, u_int16_t, u_int32_t);
289 u_int32_t MP_ReadOtherFunPciEConfigSpace(struct re_softc *, u_int8_t,
290     u_int16_t);
291 void MP_WriteOtherFunPciEConfigSpace(struct re_softc *, u_int8_t, u_int16_t,
292     u_int32_t);
293
294 u_int16_t MP_ReadEPhyUshort(struct re_softc *, u_int8_t);
295 void MP_WriteEPhyUshort(struct re_softc *, u_int8_t, u_int16_t);
296
297 u_int8_t MP_ReadEfuse(struct re_softc *, u_int16_t);
298
299 void re_driver_start(struct re_softc *);
300 void re_driver_stop(struct re_softc *);
301 #endif  /* __DragonFly__ */
302
303 /* Tunables. */
304 static int msi_disable = 1;
305 TUNABLE_INT("hw.re.msi_disable", &msi_disable);
306 static int msix_disable = 0;
307 TUNABLE_INT("hw.re.msix_disable", &msix_disable);
308 static int prefer_iomap = 0;
309 TUNABLE_INT("hw.re.prefer_iomap", &prefer_iomap);
310 static int eee_enable = 0;
311 TUNABLE_INT("hw.re.eee_enable", &eee_enable);
312 static int phy_power_saving = 1;
313 TUNABLE_INT("hw.re.phy_power_saving", &phy_power_saving);
314 static int phy_mdix_mode = RE_ETH_PHY_AUTO_MDI_MDIX;
315 TUNABLE_INT("hw.re.phy_mdix_mode", &phy_mdix_mode);
316
317 #define RE_CSUM_FEATURES    (CSUM_IP | CSUM_TCP | CSUM_UDP)
318
319 #ifndef __DragonFly__
320 static device_method_t re_methods[] = {
321         /* Device interface */
322         DEVMETHOD(device_probe, re_probe),
323         DEVMETHOD(device_attach, re_attach),
324         DEVMETHOD(device_detach, re_detach),
325         DEVMETHOD(device_suspend, re_suspend),
326         DEVMETHOD(device_resume, re_resume),
327         DEVMETHOD(device_shutdown, re_shutdown),
328         { 0, 0 }
329 };
330
331 static driver_t re_driver = {
332         "re",
333         re_methods,
334         sizeof(struct re_softc)
335 };
336
337 static devclass_t re_devclass;
338
339 DRIVER_MODULE(if_re, pci, re_driver, re_devclass, NULL, NULL);
340 #endif  /* !__DragonFly__ */
341
342 static int re_is_ups_resume(struct re_softc *sc)
343 {
344         return (MP_ReadMcuAccessRegWord(sc, 0xD408) & BIT_0);
345 }
346
347 static void re_clear_ups_resume_bit(struct re_softc *sc)
348 {
349         MP_WriteMcuAccessRegWord(sc, 0xD408, MP_ReadMcuAccessRegWord(sc, 0xD408) & ~(BIT_0));
350 }
351
352 static void re_wait_phy_ups_resume(struct re_softc *sc, u_int16_t PhyState)
353 {
354         u_int16_t TmpPhyState;
355         int i=0;
356
357         do {
358                 TmpPhyState = MP_ReadPhyOcpRegWord(sc, 0x0A42, 0x10);
359                 TmpPhyState &= 0x7;
360                 DELAY(1000);
361                 i++;
362         } while ((i < 100) && (TmpPhyState != 2));
363 }
364
365 static void re_phy_power_up(device_t dev)
366 {
367         struct re_softc         *sc;
368         u_int8_t Data8;
369
370         sc = device_get_softc(dev);
371
372         if ((sc->re_if_flags & RL_FLAG_PHYWAKE_PM) != 0)
373                 CSR_WRITE_1(sc, RE_PMCH, CSR_READ_1(sc, RE_PMCH) | (BIT_6|BIT_7));
374
375         MP_WritePhyUshort(sc, 0x1F, 0x0000);
376
377         switch (sc->re_type) {
378         case MACFG_4:
379         case MACFG_5:
380         case MACFG_6:
381         case MACFG_21:
382         case MACFG_22:
383         case MACFG_23:
384         case MACFG_24:
385         case MACFG_25:
386         case MACFG_26:
387         case MACFG_27:
388         case MACFG_28:
389         case MACFG_31:
390         case MACFG_32:
391         case MACFG_33:
392         case MACFG_63:
393         case MACFG_64:
394         case MACFG_65:
395         case MACFG_66:
396                 MP_WritePhyUshort(sc, 0x0e, 0x0000);
397                 break;
398         case MACFG_56:
399         case MACFG_57:
400         case MACFG_58:
401         case MACFG_61:
402                 Data8 = re_eri_read(sc, 0x1AB, 1, ERIAR_ExGMAC);
403                 Data8 |= (BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
404                 re_eri_write(sc, 0x1AB, 1, Data8, ERIAR_ExGMAC);
405                 break;
406         default:
407                 break;
408         };
409
410
411         MP_WritePhyUshort(sc, MII_BMCR, BMCR_AUTOEN);
412
413         //wait mdc/mdio ready
414         switch(sc->re_type) {
415         case MACFG_61:
416         case MACFG_62:
417         case MACFG_67:
418                 DELAY(10000);
419                 break;
420         }
421
422         //wait ups resume (phy state 3)
423         switch(sc->re_type) {
424         case MACFG_68:
425         case MACFG_69:
426         case MACFG_70:
427         case MACFG_71:
428                 re_wait_phy_ups_resume(sc, 3);
429                 break;
430         };
431 }
432
433 static void re_phy_power_down(device_t dev)
434 {
435         struct re_softc         *sc;
436         u_int8_t Data8;
437
438         sc = device_get_softc(dev);
439
440         if (sc->re_dash) {
441                 re_set_wol_linkspeed(sc);
442                 return;
443         }
444
445         MP_WritePhyUshort(sc, 0x1F, 0x0000);
446
447         switch (sc->re_type) {
448         case MACFG_21:
449         case MACFG_22:
450         case MACFG_23:
451         case MACFG_24:
452         case MACFG_25:
453         case MACFG_26:
454         case MACFG_27:
455         case MACFG_28:
456         case MACFG_31:
457         case MACFG_32:
458         case MACFG_33:
459         case MACFG_63:
460         case MACFG_64:
461         case MACFG_65:
462         case MACFG_66:
463                 MP_WritePhyUshort(sc, 0x0e, 0x0200);
464                 MP_WritePhyUshort(sc, MII_BMCR, (BMCR_AUTOEN|BMCR_PDOWN));
465                 break;
466         case MACFG_56:
467         case MACFG_57:
468         case MACFG_58:
469         case MACFG_61:
470                 Data8 = re_eri_read(sc, 0x1AB, 1, ERIAR_ExGMAC);
471                 Data8 &= ~(BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
472                 re_eri_write(sc, 0x1AB, 1, Data8, ERIAR_ExGMAC);
473
474                 MP_WritePhyUshort(sc, MII_BMCR, (BMCR_AUTOEN|BMCR_PDOWN));
475                 break;
476         default:
477                 MP_WritePhyUshort(sc, MII_BMCR, (BMCR_AUTOEN|BMCR_PDOWN));
478                 break;
479         }
480
481         switch (sc->re_type) {
482         case MACFG_56:
483         case MACFG_57:
484                 CSR_WRITE_1(sc, 0xD0, CSR_READ_1(sc, 0xD0) & ~BIT_6);
485                 break;
486         }
487
488         switch (sc->re_type) {
489         case MACFG_68:
490         case MACFG_69:
491                 CSR_WRITE_1(sc, 0xD0, CSR_READ_1(sc, 0xD0) & ~BIT_6);
492                 CSR_WRITE_1(sc, 0xF2, CSR_READ_1(sc, 0xF2) & ~BIT_6);
493                 break;
494         }
495
496         if ((sc->re_if_flags & RL_FLAG_PHYWAKE_PM) != 0)
497                 CSR_WRITE_1(sc, RE_PMCH, CSR_READ_1(sc, RE_PMCH) & ~(BIT_6|BIT_7));
498 }
499
500 #ifndef __DragonFly__
501 static void re_tx_dma_map_buf(void *arg, bus_dma_segment_t *segs, int nseg, int error)
502 {
503         union TxDesc *txptr = arg;
504
505         if (error) {
506                 txptr->ul[0] &= ~htole32(RL_TDESC_CMD_BUFLEN);
507                 txptr->so1.TxBuffL = 0;
508                 txptr->so1.TxBuffH = 0;
509                 return;
510         }
511
512         txptr->so1.TxBuffL = htole32(RL_ADDR_LO(segs->ds_addr));
513         txptr->so1.TxBuffH = htole32(RL_ADDR_HI(segs->ds_addr));
514 }
515
516 static void re_rx_dma_map_buf(void *arg, bus_dma_segment_t *segs, int nseg, int error)
517 {
518         union RxDesc *rxptr = arg;
519
520         if (error) {
521                 rxptr->ul[0] &= ~htole32(RL_RDESC_CMD_BUFLEN);
522                 rxptr->so0.RxBuffL = 0;
523                 rxptr->so0.RxBuffH = 0;
524                 return;
525         }
526
527         rxptr->so0.RxBuffL = htole32(RL_ADDR_LO(segs->ds_addr));
528         rxptr->so0.RxBuffH = htole32(RL_ADDR_HI(segs->ds_addr));
529 }
530
531 static void re_dma_map_rxdesc(void *arg, bus_dma_segment_t *segs, int nseg, int error)
532 {
533         struct re_softc *sc = arg;
534
535
536         if (error)
537                 return;
538
539         CSR_WRITE_4(sc, 0xe4, RL_ADDR_LO(segs->ds_addr));
540         CSR_WRITE_4(sc, 0xe8, RL_ADDR_HI(segs->ds_addr));
541 }
542
543 static void re_dma_map_txdesc(void *arg, bus_dma_segment_t *segs, int nseg, int error)
544 {
545         struct re_softc *sc = arg;
546
547
548         if (error)
549                 return;
550
551         CSR_WRITE_4(sc, 0x20, RL_ADDR_LO(segs->ds_addr));
552         CSR_WRITE_4(sc, 0x24, RL_ADDR_HI(segs->ds_addr));
553 }
554
555 /*
556  * Probe for a RealTek 8129/8139 chip. Check the PCI vendor and device
557  * IDs against our list and return a device name if we find a match.
558  */
559 static int re_probe(dev)        /* Search for Realtek NIC chip */
560 device_t                dev;
561 {
562         struct re_type          *t;
563         t = re_devs;
564         while (t->re_name != NULL) {
565                 if ((pci_get_vendor(dev) == t->re_vid) &&
566                     (pci_get_device(dev) == t->re_did)) {
567                         device_set_desc(dev, t->re_name);
568                         return(0);
569                 }
570                 t++;
571         }
572
573         return(ENXIO);
574 }
575 #endif  /* !__DragonFly__ */
576
577
578 static u_int32_t re_eri_read_with_oob_base_address(struct re_softc *sc, int addr, int len, int type, const u_int32_t base_address)
579 {
580         int i, val_shift, shift = 0;
581         u_int32_t value1 = 0, value2 = 0, mask;
582         const u_int32_t transformed_base_address = ((base_address & 0x00FFF000) << 6) | (base_address & 0x000FFF);
583
584         if (len > 4 || len <= 0)
585                 return -1;
586
587         while (len > 0) {
588                 val_shift = addr % ERIAR_Addr_Align;
589                 addr = addr & ~0x3;
590
591                 CSR_WRITE_4(sc,RE_ERIAR,
592                             ERIAR_Read |
593                             transformed_base_address |
594                             type << ERIAR_Type_shift |
595                             ERIAR_ByteEn << ERIAR_ByteEn_shift |
596                             addr);
597
598                 for (i = 0; i < 10; i++) {
599                         DELAY(100);
600
601                         /* Check if the RTL8168 has completed ERI read */
602                         if (CSR_READ_4(sc,RE_ERIAR) & ERIAR_Flag)
603                                 break;
604                 }
605
606                 if (len == 1)           mask = (0xFF << (val_shift * 8)) & 0xFFFFFFFF;
607                 else if (len == 2)      mask = (0xFFFF << (val_shift * 8)) & 0xFFFFFFFF;
608                 else if (len == 3)      mask = (0xFFFFFF << (val_shift * 8)) & 0xFFFFFFFF;
609                 else                    mask = (0xFFFFFFFF << (val_shift * 8)) & 0xFFFFFFFF;
610
611                 value1 = CSR_READ_4(sc,RE_ERIDR) & mask;
612                 value2 |= (value1 >> val_shift * 8) << shift * 8;
613
614                 if (len <= 4 - val_shift)
615                         len = 0;
616                 else {
617                         len -= (4 - val_shift);
618                         shift = 4 - val_shift;
619                         addr += 4;
620                 }
621         }
622
623         return value2;
624 }
625
626 static u_int32_t re_eri_read(struct re_softc *sc, int addr, int len, int type)
627 {
628         return re_eri_read_with_oob_base_address(sc, addr, len, type, 0);
629 }
630
631 static int re_eri_write_with_oob_base_address(struct re_softc *sc, int addr, int len, u_int32_t value, int type, const u_int32_t base_address)
632 {
633
634         int i, val_shift, shift = 0;
635         u_int32_t value1 = 0, mask;
636         const u_int32_t transformed_base_address = ((base_address & 0x00FFF000) << 6) | (base_address & 0x000FFF);
637
638         if (len > 4 || len <= 0)
639                 return -1;
640
641         while (len > 0) {
642                 val_shift = addr % ERIAR_Addr_Align;
643                 addr = addr & ~0x3;
644
645                 if (len == 1)           mask = (0xFF << (val_shift * 8)) & 0xFFFFFFFF;
646                 else if (len == 2)      mask = (0xFFFF << (val_shift * 8)) & 0xFFFFFFFF;
647                 else if (len == 3)      mask = (0xFFFFFF << (val_shift * 8)) & 0xFFFFFFFF;
648                 else                    mask = (0xFFFFFFFF << (val_shift * 8)) & 0xFFFFFFFF;
649
650                 value1 = re_eri_read_with_oob_base_address(sc, addr, 4, type, base_address) & ~mask;
651                 value1 |= ((value << val_shift * 8) >> shift * 8);
652
653                 CSR_WRITE_4(sc,RE_ERIDR, value1);
654                 CSR_WRITE_4(sc,RE_ERIAR,
655                             ERIAR_Write |
656                             transformed_base_address |
657                             type << ERIAR_Type_shift |
658                             ERIAR_ByteEn << ERIAR_ByteEn_shift |
659                             addr);
660
661                 for (i = 0; i < 10; i++) {
662                         DELAY(100);
663
664                         /* Check if the RTL8168 has completed ERI write */
665                         if (!(CSR_READ_4(sc,RE_ERIAR) & ERIAR_Flag))
666                                 break;
667                 }
668
669                 if (len <= 4 - val_shift)
670                         len = 0;
671                 else {
672                         len -= (4 - val_shift);
673                         shift = 4 - val_shift;
674                         addr += 4;
675                 }
676         }
677
678         return 0;
679 }
680
681 static int re_eri_write(struct re_softc *sc, int addr, int len, u_int32_t value, int type)
682 {
683         return re_eri_write_with_oob_base_address(sc, addr, len, value, type, 0);
684 }
685
686 static void
687 ClearAndSetEthPhyBit(
688         struct re_softc *sc,
689         u_int8_t   addr,
690         u_int16_t   clearmask,
691         u_int16_t   setmask
692 )
693 {
694         u_int16_t PhyRegValue;
695
696
697         PhyRegValue = MP_ReadPhyUshort(sc, addr);
698         PhyRegValue &= ~clearmask;
699         PhyRegValue |= setmask;
700         MP_WritePhyUshort(sc, addr, PhyRegValue);
701 }
702
703 static void
704 ClearEthPhyBit(
705         struct re_softc *sc,
706         u_int8_t   addr,
707         u_int16_t   mask
708 )
709 {
710         ClearAndSetEthPhyBit(sc,
711                              addr,
712                              mask,
713                              0
714                             );
715 }
716
717 static void
718 SetEthPhyBit(
719         struct re_softc *sc,
720         u_int8_t   addr,
721         u_int16_t   mask
722 )
723 {
724         ClearAndSetEthPhyBit(sc,
725                              addr,
726                              0,
727                              mask
728                             );
729 }
730
731 #ifndef __DragonFly__
732 static void re_release_rx_buf(struct re_softc *sc)
733 {
734         struct ifnet            *ifp;
735         int i;
736         ifp = RE_GET_IFNET(sc);
737
738         if (sc->re_desc.re_rx_mtag) {
739                 for (i = 0; i < RE_RX_BUF_NUM; i++) {
740                         if (sc->re_desc.rx_buf[i]!=NULL) {
741                                 bus_dmamap_sync(sc->re_desc.re_rx_mtag,
742                                                 sc->re_desc.re_rx_dmamap[i],
743                                                 BUS_DMASYNC_POSTREAD);
744                                 bus_dmamap_unload(sc->re_desc.re_rx_mtag,
745                                                   sc->re_desc.re_rx_dmamap[i]);
746                                 bus_dmamap_destroy(sc->re_desc.re_rx_mtag,
747                                                    sc->re_desc.re_rx_dmamap[i]);
748                                 m_freem(sc->re_desc.rx_buf[i]);
749                                 sc->re_desc.rx_buf[i] =NULL;
750                         }
751                 }
752                 bus_dma_tag_destroy(sc->re_desc.re_rx_mtag);
753                 sc->re_desc.re_rx_mtag =0;
754         }
755
756 }
757 static void re_release_tx_buf(struct re_softc *sc)
758 {
759         struct ifnet            *ifp;
760         int i;
761         ifp = RE_GET_IFNET(sc);
762
763         if (sc->re_desc.re_tx_mtag) {
764                 for (i = 0; i < RE_TX_BUF_NUM; i++) {
765
766                         bus_dmamap_destroy(sc->re_desc.re_tx_mtag,
767                                            sc->re_desc.re_tx_dmamap[i]);
768                         m_freem(sc->re_desc.tx_buf[i]);
769
770                 }
771                 bus_dma_tag_destroy(sc->re_desc.re_tx_mtag);
772                 sc->re_desc.re_tx_mtag = 0;
773         }
774
775
776 }
777 static void re_release_buf(struct re_softc *sc)
778 {
779         re_release_rx_buf(sc);
780         re_release_tx_buf(sc);
781 }
782
783
784
785 static int re_alloc_buf(struct re_softc *sc)
786 {
787         int error =0;
788         int i,size;
789
790         error = bus_dma_tag_create(sc->re_parent_tag, 1, 0,
791                                    BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR, NULL,
792                                    NULL, MCLBYTES* RE_NTXSEGS, RE_NTXSEGS, 4096, 0,
793                                    NULL, NULL, &sc->re_desc.re_tx_mtag);
794
795         if (error) {
796                 //device_printf(dev,"re_tx_mtag fail\n");
797                 //goto fail;
798                 return error;
799         }
800
801         error = bus_dma_tag_create(
802                         sc->re_parent_tag,
803                         RE_RX_BUFFER_ALIGN, 0,          /* alignment, boundary */
804                         BUS_SPACE_MAXADDR,              /* lowaddr */
805                         BUS_SPACE_MAXADDR,              /* highaddr */
806                         NULL, NULL,                     /* filter, filterarg */
807                         sc->re_rx_desc_buf_sz, 1,                       /* maxsize,nsegments */
808                         sc->re_rx_desc_buf_sz,                  /* maxsegsize */
809                         0,                              /* flags */
810                         NULL, NULL,                     /* lockfunc, lockarg */
811                         &sc->re_desc.re_rx_mtag);
812         if (error) {
813                 //device_printf(dev,"re_rx_mtag fail\n");
814                 //goto fail;
815                 return error;
816         }
817
818         if (sc->re_rx_mbuf_sz <= MCLBYTES)
819                 size = MCLBYTES;
820         else if (sc->re_rx_mbuf_sz <=  MJUMPAGESIZE)
821                 size = MJUMPAGESIZE;
822         else
823                 size =MJUM9BYTES;
824         for (i = 0; i < RE_RX_BUF_NUM; i++) {
825                 sc->re_desc.rx_buf[i] = m_getjcl(M_DONTWAIT, MT_DATA, M_PKTHDR, size);
826                 if (!sc->re_desc.rx_buf[i]) {
827                         //device_printf(dev, "m_getcl fail!!!\n");
828                         error = ENXIO;
829                         //goto fail;
830                         return error;
831                 }
832
833                 sc->re_desc.rx_buf[i]->m_len = sc->re_desc.rx_buf[i]->m_pkthdr.len = size;
834 #ifdef RE_FIXUP_RX
835                 /*
836                  * This is part of an evil trick to deal with non-x86 platforms.
837                  * The RealTek chip requires RX buffers to be aligned on 64-bit
838                  * boundaries, but that will hose non-x86 machines. To get around
839                  * this, we leave some empty space at the start of each buffer
840                  * and for non-x86 hosts, we copy the buffer back six bytes
841                  * to achieve word alignment. This is slightly more efficient
842                  * than allocating a new buffer, copying the contents, and
843                  * discarding the old buffer.
844                  */
845                 m_adj(sc->re_desc.rx_buf[i], RE_ETHER_ALIGN);
846 #endif
847
848                 error = bus_dmamap_create(sc->re_desc.re_rx_mtag, BUS_DMA_NOWAIT, &sc->re_desc.re_rx_dmamap[i]);
849                 if (error) {
850                         //device_printf(dev, "bus_dmamap_create fail!!!\n");
851                         //goto fail;
852                         return error;
853                 }
854         }
855
856         for (i = 0; i < RE_TX_BUF_NUM; i++) {
857                 error = bus_dmamap_create(sc->re_desc.re_tx_mtag, BUS_DMA_NOWAIT, &sc->re_desc.re_tx_dmamap[i]);
858                 if (error) {
859                         //device_printf(dev, "bus_dmamap_create fail!!!\n");
860                         //goto fail;
861                         return error;
862                 }
863         }
864
865         return 0;
866 }
867
868 static void set_rxbufsize(struct re_softc *sc)
869 {
870
871         //printf("set size\n");
872
873         struct ifnet            *ifp;
874         ifp = RE_GET_IFNET(sc);
875         sc->re_rx_desc_buf_sz = (ifp->if_mtu > ETHERMTU) ? ifp->if_mtu: ETHERMTU;
876         sc->re_rx_desc_buf_sz += (ETHER_VLAN_ENCAP_LEN + ETHER_HDR_LEN + ETHER_CRC_LEN + 1);
877         CSR_WRITE_2(sc, RE_RxMaxSize, sc->re_rx_desc_buf_sz);
878 }
879 #endif  /* !__DragonFly__ */
880
881 static void re_enable_cfg9346_write(struct re_softc *sc)
882 {
883         EE_SET(RE_EEMODE_WRITECFG);
884 }
885
886 static void re_disable_cfg9346_write(struct re_softc *sc)
887 {
888         EE_CLR(RE_EEMODE_WRITECFG);
889 }
890
891 static void DisableMcuBPs(struct re_softc *sc)
892 {
893         switch(sc->re_type) {
894         case MACFG_68:
895         case MACFG_69:
896         case MACFG_70:
897         case MACFG_71:
898                 MP_WriteMcuAccessRegWord(sc, 0xFC38, 0x0000);
899                 break;
900         }
901
902         switch(sc->re_type) {
903         case MACFG_56:
904         case MACFG_57:
905         case MACFG_58:
906         case MACFG_59:
907         case MACFG_60:
908         case MACFG_61:
909         case MACFG_62:
910         case MACFG_67:
911         case MACFG_68:
912         case MACFG_69:
913         case MACFG_70:
914         case MACFG_71:
915                 re_enable_cfg9346_write(sc);
916                 CSR_WRITE_1(sc, RE_CFG5, CSR_READ_1(sc, RE_CFG5) & ~BIT_0);
917                 CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2) & ~BIT_7);
918                 re_disable_cfg9346_write(sc);
919
920                 MP_WriteMcuAccessRegWord(sc, 0xFC28, 0x0000);
921                 MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x0000);
922                 MP_WriteMcuAccessRegWord(sc, 0xFC2C, 0x0000);
923                 MP_WriteMcuAccessRegWord(sc, 0xFC2E, 0x0000);
924                 MP_WriteMcuAccessRegWord(sc, 0xFC30, 0x0000);
925                 MP_WriteMcuAccessRegWord(sc, 0xFC32, 0x0000);
926                 MP_WriteMcuAccessRegWord(sc, 0xFC34, 0x0000);
927                 MP_WriteMcuAccessRegWord(sc, 0xFC36, 0x0000);
928
929                 DELAY(3000);
930
931                 MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x0000);
932                 break;
933         }
934 }
935
936 static void re_set_mac_mcu_8168g_1(struct re_softc *sc)
937 {
938         MP_WriteMcuAccessRegWord(sc, 0xE43C, 0x0000);
939         MP_WriteMcuAccessRegWord(sc, 0xE43E, 0x0000);
940
941         MP_WriteMcuAccessRegWord(sc, 0xE434, 0x0004);
942         MP_WriteMcuAccessRegWord(sc, 0xE43C, 0x0004);
943
944         DisableMcuBPs(sc);
945
946         MP_WriteMcuAccessRegWord(sc, 0xF800, 0xE008);
947         MP_WriteMcuAccessRegWord(sc, 0xF802, 0xE01B);
948         MP_WriteMcuAccessRegWord(sc, 0xF804, 0xE022);
949         MP_WriteMcuAccessRegWord(sc, 0xF806, 0xE094);
950         MP_WriteMcuAccessRegWord(sc, 0xF808, 0xE097);
951         MP_WriteMcuAccessRegWord(sc, 0xF80A, 0xE09A);
952         MP_WriteMcuAccessRegWord(sc, 0xF80C, 0xE0B3);
953         MP_WriteMcuAccessRegWord(sc, 0xF80E, 0xE0BA);
954         MP_WriteMcuAccessRegWord(sc, 0xF810, 0x49D2);
955         MP_WriteMcuAccessRegWord(sc, 0xF812, 0xF10D);
956         MP_WriteMcuAccessRegWord(sc, 0xF814, 0x766C);
957         MP_WriteMcuAccessRegWord(sc, 0xF816, 0x49E2);
958         MP_WriteMcuAccessRegWord(sc, 0xF818, 0xF00A);
959         MP_WriteMcuAccessRegWord(sc, 0xF81A, 0x1EC0);
960         MP_WriteMcuAccessRegWord(sc, 0xF81C, 0x8EE1);
961         MP_WriteMcuAccessRegWord(sc, 0xF81E, 0xC60A);
962         MP_WriteMcuAccessRegWord(sc, 0xF820, 0x77C0);
963         MP_WriteMcuAccessRegWord(sc, 0xF822, 0x4870);
964         MP_WriteMcuAccessRegWord(sc, 0xF824, 0x9FC0);
965         MP_WriteMcuAccessRegWord(sc, 0xF826, 0x1EA0);
966         MP_WriteMcuAccessRegWord(sc, 0xF828, 0xC707);
967         MP_WriteMcuAccessRegWord(sc, 0xF82A, 0x8EE1);
968         MP_WriteMcuAccessRegWord(sc, 0xF82C, 0x9D6C);
969         MP_WriteMcuAccessRegWord(sc, 0xF82E, 0xC603);
970         MP_WriteMcuAccessRegWord(sc, 0xF830, 0xBE00);
971         MP_WriteMcuAccessRegWord(sc, 0xF832, 0xB416);
972         MP_WriteMcuAccessRegWord(sc, 0xF834, 0x0076);
973         MP_WriteMcuAccessRegWord(sc, 0xF836, 0xE86C);
974         MP_WriteMcuAccessRegWord(sc, 0xF838, 0xC406);
975         MP_WriteMcuAccessRegWord(sc, 0xF83A, 0x7580);
976         MP_WriteMcuAccessRegWord(sc, 0xF83C, 0x4852);
977         MP_WriteMcuAccessRegWord(sc, 0xF83E, 0x8D80);
978         MP_WriteMcuAccessRegWord(sc, 0xF840, 0xC403);
979         MP_WriteMcuAccessRegWord(sc, 0xF842, 0xBC00);
980         MP_WriteMcuAccessRegWord(sc, 0xF844, 0xD3E0);
981         MP_WriteMcuAccessRegWord(sc, 0xF846, 0x02C8);
982         MP_WriteMcuAccessRegWord(sc, 0xF848, 0x8918);
983         MP_WriteMcuAccessRegWord(sc, 0xF84A, 0xE815);
984         MP_WriteMcuAccessRegWord(sc, 0xF84C, 0x1100);
985         MP_WriteMcuAccessRegWord(sc, 0xF84E, 0xF011);
986         MP_WriteMcuAccessRegWord(sc, 0xF850, 0xE812);
987         MP_WriteMcuAccessRegWord(sc, 0xF852, 0x4990);
988         MP_WriteMcuAccessRegWord(sc, 0xF854, 0xF002);
989         MP_WriteMcuAccessRegWord(sc, 0xF856, 0xE817);
990         MP_WriteMcuAccessRegWord(sc, 0xF858, 0xE80E);
991         MP_WriteMcuAccessRegWord(sc, 0xF85A, 0x4992);
992         MP_WriteMcuAccessRegWord(sc, 0xF85C, 0xF002);
993         MP_WriteMcuAccessRegWord(sc, 0xF85E, 0xE80E);
994         MP_WriteMcuAccessRegWord(sc, 0xF860, 0xE80A);
995         MP_WriteMcuAccessRegWord(sc, 0xF862, 0x4993);
996         MP_WriteMcuAccessRegWord(sc, 0xF864, 0xF002);
997         MP_WriteMcuAccessRegWord(sc, 0xF866, 0xE818);
998         MP_WriteMcuAccessRegWord(sc, 0xF868, 0xE806);
999         MP_WriteMcuAccessRegWord(sc, 0xF86A, 0x4991);
1000         MP_WriteMcuAccessRegWord(sc, 0xF86C, 0xF002);
1001         MP_WriteMcuAccessRegWord(sc, 0xF86E, 0xE838);
1002         MP_WriteMcuAccessRegWord(sc, 0xF870, 0xC25E);
1003         MP_WriteMcuAccessRegWord(sc, 0xF872, 0xBA00);
1004         MP_WriteMcuAccessRegWord(sc, 0xF874, 0xC056);
1005         MP_WriteMcuAccessRegWord(sc, 0xF876, 0x7100);
1006         MP_WriteMcuAccessRegWord(sc, 0xF878, 0xFF80);
1007         MP_WriteMcuAccessRegWord(sc, 0xF87A, 0x7100);
1008         MP_WriteMcuAccessRegWord(sc, 0xF87C, 0x4892);
1009         MP_WriteMcuAccessRegWord(sc, 0xF87E, 0x4813);
1010         MP_WriteMcuAccessRegWord(sc, 0xF880, 0x8900);
1011         MP_WriteMcuAccessRegWord(sc, 0xF882, 0xE00A);
1012         MP_WriteMcuAccessRegWord(sc, 0xF884, 0x7100);
1013         MP_WriteMcuAccessRegWord(sc, 0xF886, 0x4890);
1014         MP_WriteMcuAccessRegWord(sc, 0xF888, 0x4813);
1015         MP_WriteMcuAccessRegWord(sc, 0xF88A, 0x8900);
1016         MP_WriteMcuAccessRegWord(sc, 0xF88C, 0xC74B);
1017         MP_WriteMcuAccessRegWord(sc, 0xF88E, 0x74F8);
1018         MP_WriteMcuAccessRegWord(sc, 0xF890, 0x48C2);
1019         MP_WriteMcuAccessRegWord(sc, 0xF892, 0x4841);
1020         MP_WriteMcuAccessRegWord(sc, 0xF894, 0x8CF8);
1021         MP_WriteMcuAccessRegWord(sc, 0xF896, 0xC746);
1022         MP_WriteMcuAccessRegWord(sc, 0xF898, 0x74FC);
1023         MP_WriteMcuAccessRegWord(sc, 0xF89A, 0x49C0);
1024         MP_WriteMcuAccessRegWord(sc, 0xF89C, 0xF120);
1025         MP_WriteMcuAccessRegWord(sc, 0xF89E, 0x49C1);
1026         MP_WriteMcuAccessRegWord(sc, 0xF8A0, 0xF11E);
1027         MP_WriteMcuAccessRegWord(sc, 0xF8A2, 0x74F8);
1028         MP_WriteMcuAccessRegWord(sc, 0xF8A4, 0x49C0);
1029         MP_WriteMcuAccessRegWord(sc, 0xF8A6, 0xF01B);
1030         MP_WriteMcuAccessRegWord(sc, 0xF8A8, 0x49C6);
1031         MP_WriteMcuAccessRegWord(sc, 0xF8AA, 0xF119);
1032         MP_WriteMcuAccessRegWord(sc, 0xF8AC, 0x74F8);
1033         MP_WriteMcuAccessRegWord(sc, 0xF8AE, 0x49C4);
1034         MP_WriteMcuAccessRegWord(sc, 0xF8B0, 0xF013);
1035         MP_WriteMcuAccessRegWord(sc, 0xF8B2, 0xC536);
1036         MP_WriteMcuAccessRegWord(sc, 0xF8B4, 0x74B0);
1037         MP_WriteMcuAccessRegWord(sc, 0xF8B6, 0x49C1);
1038         MP_WriteMcuAccessRegWord(sc, 0xF8B8, 0xF1FD);
1039         MP_WriteMcuAccessRegWord(sc, 0xF8BA, 0xC537);
1040         MP_WriteMcuAccessRegWord(sc, 0xF8BC, 0xC434);
1041         MP_WriteMcuAccessRegWord(sc, 0xF8BE, 0x9CA0);
1042         MP_WriteMcuAccessRegWord(sc, 0xF8C0, 0xC435);
1043         MP_WriteMcuAccessRegWord(sc, 0xF8C2, 0x1C13);
1044         MP_WriteMcuAccessRegWord(sc, 0xF8C4, 0x484F);
1045         MP_WriteMcuAccessRegWord(sc, 0xF8C6, 0x9CA2);
1046         MP_WriteMcuAccessRegWord(sc, 0xF8C8, 0xC52B);
1047         MP_WriteMcuAccessRegWord(sc, 0xF8CA, 0x74B0);
1048         MP_WriteMcuAccessRegWord(sc, 0xF8CC, 0x49C1);
1049         MP_WriteMcuAccessRegWord(sc, 0xF8CE, 0xF1FD);
1050         MP_WriteMcuAccessRegWord(sc, 0xF8D0, 0x74F8);
1051         MP_WriteMcuAccessRegWord(sc, 0xF8D2, 0x48C4);
1052         MP_WriteMcuAccessRegWord(sc, 0xF8D4, 0x8CF8);
1053         MP_WriteMcuAccessRegWord(sc, 0xF8D6, 0x7100);
1054         MP_WriteMcuAccessRegWord(sc, 0xF8D8, 0x4893);
1055         MP_WriteMcuAccessRegWord(sc, 0xF8DA, 0x8900);
1056         MP_WriteMcuAccessRegWord(sc, 0xF8DC, 0xFF80);
1057         MP_WriteMcuAccessRegWord(sc, 0xF8DE, 0xC520);
1058         MP_WriteMcuAccessRegWord(sc, 0xF8E0, 0x74B0);
1059         MP_WriteMcuAccessRegWord(sc, 0xF8E2, 0x49C1);
1060         MP_WriteMcuAccessRegWord(sc, 0xF8E4, 0xF11C);
1061         MP_WriteMcuAccessRegWord(sc, 0xF8E6, 0xC71E);
1062         MP_WriteMcuAccessRegWord(sc, 0xF8E8, 0x74FC);
1063         MP_WriteMcuAccessRegWord(sc, 0xF8EA, 0x49C1);
1064         MP_WriteMcuAccessRegWord(sc, 0xF8EC, 0xF118);
1065         MP_WriteMcuAccessRegWord(sc, 0xF8EE, 0x49C0);
1066         MP_WriteMcuAccessRegWord(sc, 0xF8F0, 0xF116);
1067         MP_WriteMcuAccessRegWord(sc, 0xF8F2, 0x74F8);
1068         MP_WriteMcuAccessRegWord(sc, 0xF8F4, 0x49C0);
1069         MP_WriteMcuAccessRegWord(sc, 0xF8F6, 0xF013);
1070         MP_WriteMcuAccessRegWord(sc, 0xF8F8, 0x48C3);
1071         MP_WriteMcuAccessRegWord(sc, 0xF8FA, 0x8CF8);
1072         MP_WriteMcuAccessRegWord(sc, 0xF8FC, 0xC516);
1073         MP_WriteMcuAccessRegWord(sc, 0xF8FE, 0x74A2);
1074         MP_WriteMcuAccessRegWord(sc, 0xF900, 0x49CE);
1075         MP_WriteMcuAccessRegWord(sc, 0xF902, 0xF1FE);
1076         MP_WriteMcuAccessRegWord(sc, 0xF904, 0xC411);
1077         MP_WriteMcuAccessRegWord(sc, 0xF906, 0x9CA0);
1078         MP_WriteMcuAccessRegWord(sc, 0xF908, 0xC411);
1079         MP_WriteMcuAccessRegWord(sc, 0xF90A, 0x1C13);
1080         MP_WriteMcuAccessRegWord(sc, 0xF90C, 0x484F);
1081         MP_WriteMcuAccessRegWord(sc, 0xF90E, 0x9CA2);
1082         MP_WriteMcuAccessRegWord(sc, 0xF910, 0x74A2);
1083         MP_WriteMcuAccessRegWord(sc, 0xF912, 0x49CF);
1084         MP_WriteMcuAccessRegWord(sc, 0xF914, 0xF1FE);
1085         MP_WriteMcuAccessRegWord(sc, 0xF916, 0x7100);
1086         MP_WriteMcuAccessRegWord(sc, 0xF918, 0x4891);
1087         MP_WriteMcuAccessRegWord(sc, 0xF91A, 0x8900);
1088         MP_WriteMcuAccessRegWord(sc, 0xF91C, 0xFF80);
1089         MP_WriteMcuAccessRegWord(sc, 0xF91E, 0xE400);
1090         MP_WriteMcuAccessRegWord(sc, 0xF920, 0xD3E0);
1091         MP_WriteMcuAccessRegWord(sc, 0xF922, 0xE000);
1092         MP_WriteMcuAccessRegWord(sc, 0xF924, 0x0481);
1093         MP_WriteMcuAccessRegWord(sc, 0xF926, 0x0C81);
1094         MP_WriteMcuAccessRegWord(sc, 0xF928, 0xDE20);
1095         MP_WriteMcuAccessRegWord(sc, 0xF92A, 0x0000);
1096         MP_WriteMcuAccessRegWord(sc, 0xF92C, 0x0992);
1097         MP_WriteMcuAccessRegWord(sc, 0xF92E, 0x1B76);
1098         MP_WriteMcuAccessRegWord(sc, 0xF930, 0xC602);
1099         MP_WriteMcuAccessRegWord(sc, 0xF932, 0xBE00);
1100         MP_WriteMcuAccessRegWord(sc, 0xF934, 0x059C);
1101         MP_WriteMcuAccessRegWord(sc, 0xF936, 0x1B76);
1102         MP_WriteMcuAccessRegWord(sc, 0xF938, 0xC602);
1103         MP_WriteMcuAccessRegWord(sc, 0xF93A, 0xBE00);
1104         MP_WriteMcuAccessRegWord(sc, 0xF93C, 0x065A);
1105         MP_WriteMcuAccessRegWord(sc, 0xF93E, 0xB400);
1106         MP_WriteMcuAccessRegWord(sc, 0xF940, 0x18DE);
1107         MP_WriteMcuAccessRegWord(sc, 0xF942, 0x2008);
1108         MP_WriteMcuAccessRegWord(sc, 0xF944, 0x4001);
1109         MP_WriteMcuAccessRegWord(sc, 0xF946, 0xF10F);
1110         MP_WriteMcuAccessRegWord(sc, 0xF948, 0x7342);
1111         MP_WriteMcuAccessRegWord(sc, 0xF94A, 0x1880);
1112         MP_WriteMcuAccessRegWord(sc, 0xF94C, 0x2008);
1113         MP_WriteMcuAccessRegWord(sc, 0xF94E, 0x0009);
1114         MP_WriteMcuAccessRegWord(sc, 0xF950, 0x4018);
1115         MP_WriteMcuAccessRegWord(sc, 0xF952, 0xF109);
1116         MP_WriteMcuAccessRegWord(sc, 0xF954, 0x7340);
1117         MP_WriteMcuAccessRegWord(sc, 0xF956, 0x25BC);
1118         MP_WriteMcuAccessRegWord(sc, 0xF958, 0x130F);
1119         MP_WriteMcuAccessRegWord(sc, 0xF95A, 0xF105);
1120         MP_WriteMcuAccessRegWord(sc, 0xF95C, 0xC00A);
1121         MP_WriteMcuAccessRegWord(sc, 0xF95E, 0x7300);
1122         MP_WriteMcuAccessRegWord(sc, 0xF960, 0x4831);
1123         MP_WriteMcuAccessRegWord(sc, 0xF962, 0x9B00);
1124         MP_WriteMcuAccessRegWord(sc, 0xF964, 0xB000);
1125         MP_WriteMcuAccessRegWord(sc, 0xF966, 0x7340);
1126         MP_WriteMcuAccessRegWord(sc, 0xF968, 0x8320);
1127         MP_WriteMcuAccessRegWord(sc, 0xF96A, 0xC302);
1128         MP_WriteMcuAccessRegWord(sc, 0xF96C, 0xBB00);
1129         MP_WriteMcuAccessRegWord(sc, 0xF96E, 0x0C12);
1130         MP_WriteMcuAccessRegWord(sc, 0xF970, 0xE860);
1131         MP_WriteMcuAccessRegWord(sc, 0xF972, 0xC406);
1132         MP_WriteMcuAccessRegWord(sc, 0xF974, 0x7580);
1133         MP_WriteMcuAccessRegWord(sc, 0xF976, 0x4851);
1134         MP_WriteMcuAccessRegWord(sc, 0xF978, 0x8D80);
1135         MP_WriteMcuAccessRegWord(sc, 0xF97A, 0xC403);
1136         MP_WriteMcuAccessRegWord(sc, 0xF97C, 0xBC00);
1137         MP_WriteMcuAccessRegWord(sc, 0xF97E, 0xD3E0);
1138         MP_WriteMcuAccessRegWord(sc, 0xF980, 0x02C8);
1139         MP_WriteMcuAccessRegWord(sc, 0xF982, 0xC406);
1140         MP_WriteMcuAccessRegWord(sc, 0xF984, 0x7580);
1141         MP_WriteMcuAccessRegWord(sc, 0xF986, 0x4850);
1142         MP_WriteMcuAccessRegWord(sc, 0xF988, 0x8D80);
1143         MP_WriteMcuAccessRegWord(sc, 0xF98A, 0xC403);
1144         MP_WriteMcuAccessRegWord(sc, 0xF98C, 0xBC00);
1145         MP_WriteMcuAccessRegWord(sc, 0xF98E, 0xD3E0);
1146         MP_WriteMcuAccessRegWord(sc, 0xF990, 0x0298);
1147
1148         MP_WriteMcuAccessRegWord(sc, 0xDE30, 0x0080);
1149
1150         MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000);
1151
1152         MP_WriteMcuAccessRegWord(sc, 0xFC28, 0x0075);
1153         MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x02B1);
1154         MP_WriteMcuAccessRegWord(sc, 0xFC2C, 0x0991);
1155         MP_WriteMcuAccessRegWord(sc, 0xFC2E, 0x059B);
1156         MP_WriteMcuAccessRegWord(sc, 0xFC30, 0x0659);
1157         MP_WriteMcuAccessRegWord(sc, 0xFC32, 0x0000);
1158         MP_WriteMcuAccessRegWord(sc, 0xFC34, 0x02BB);
1159         MP_WriteMcuAccessRegWord(sc, 0xFC36, 0x0279);
1160 }
1161
1162 static void re_set_mac_mcu_8168gu_1(struct re_softc *sc)
1163 {
1164         DisableMcuBPs(sc);
1165
1166         MP_WriteMcuAccessRegWord(sc, 0xF800, 0xE008);
1167         MP_WriteMcuAccessRegWord(sc, 0xF802, 0xE011);
1168         MP_WriteMcuAccessRegWord(sc, 0xF804, 0xE015);
1169         MP_WriteMcuAccessRegWord(sc, 0xF806, 0xE018);
1170         MP_WriteMcuAccessRegWord(sc, 0xF808, 0xE01B);
1171         MP_WriteMcuAccessRegWord(sc, 0xF80A, 0xE027);
1172         MP_WriteMcuAccessRegWord(sc, 0xF80C, 0xE043);
1173         MP_WriteMcuAccessRegWord(sc, 0xF80E, 0xE065);
1174         MP_WriteMcuAccessRegWord(sc, 0xF810, 0x49E2);
1175         MP_WriteMcuAccessRegWord(sc, 0xF812, 0xF005);
1176         MP_WriteMcuAccessRegWord(sc, 0xF814, 0x49EA);
1177         MP_WriteMcuAccessRegWord(sc, 0xF816, 0xF003);
1178         MP_WriteMcuAccessRegWord(sc, 0xF818, 0xC404);
1179         MP_WriteMcuAccessRegWord(sc, 0xF81A, 0xBC00);
1180         MP_WriteMcuAccessRegWord(sc, 0xF81C, 0xC403);
1181         MP_WriteMcuAccessRegWord(sc, 0xF81E, 0xBC00);
1182         MP_WriteMcuAccessRegWord(sc, 0xF820, 0x0496);
1183         MP_WriteMcuAccessRegWord(sc, 0xF822, 0x051A);
1184         MP_WriteMcuAccessRegWord(sc, 0xF824, 0x1D01);
1185         MP_WriteMcuAccessRegWord(sc, 0xF826, 0x8DE8);
1186         MP_WriteMcuAccessRegWord(sc, 0xF828, 0xC602);
1187         MP_WriteMcuAccessRegWord(sc, 0xF82A, 0xBE00);
1188         MP_WriteMcuAccessRegWord(sc, 0xF82C, 0x0206);
1189         MP_WriteMcuAccessRegWord(sc, 0xF82E, 0x1B76);
1190         MP_WriteMcuAccessRegWord(sc, 0xF830, 0xC202);
1191         MP_WriteMcuAccessRegWord(sc, 0xF832, 0xBA00);
1192         MP_WriteMcuAccessRegWord(sc, 0xF834, 0x058A);
1193         MP_WriteMcuAccessRegWord(sc, 0xF836, 0x1B76);
1194         MP_WriteMcuAccessRegWord(sc, 0xF838, 0xC602);
1195         MP_WriteMcuAccessRegWord(sc, 0xF83A, 0xBE00);
1196         MP_WriteMcuAccessRegWord(sc, 0xF83C, 0x0648);
1197         MP_WriteMcuAccessRegWord(sc, 0xF83E, 0x74E6);
1198         MP_WriteMcuAccessRegWord(sc, 0xF840, 0x1B78);
1199         MP_WriteMcuAccessRegWord(sc, 0xF842, 0x46DC);
1200         MP_WriteMcuAccessRegWord(sc, 0xF844, 0x1300);
1201         MP_WriteMcuAccessRegWord(sc, 0xF846, 0xF005);
1202         MP_WriteMcuAccessRegWord(sc, 0xF848, 0x74F8);
1203         MP_WriteMcuAccessRegWord(sc, 0xF84A, 0x48C3);
1204         MP_WriteMcuAccessRegWord(sc, 0xF84C, 0x48C4);
1205         MP_WriteMcuAccessRegWord(sc, 0xF84E, 0x8CF8);
1206         MP_WriteMcuAccessRegWord(sc, 0xF850, 0x64E7);
1207         MP_WriteMcuAccessRegWord(sc, 0xF852, 0xC302);
1208         MP_WriteMcuAccessRegWord(sc, 0xF854, 0xBB00);
1209         MP_WriteMcuAccessRegWord(sc, 0xF856, 0x068E);
1210         MP_WriteMcuAccessRegWord(sc, 0xF858, 0x74E4);
1211         MP_WriteMcuAccessRegWord(sc, 0xF85A, 0x49C5);
1212         MP_WriteMcuAccessRegWord(sc, 0xF85C, 0xF106);
1213         MP_WriteMcuAccessRegWord(sc, 0xF85E, 0x49C6);
1214         MP_WriteMcuAccessRegWord(sc, 0xF860, 0xF107);
1215         MP_WriteMcuAccessRegWord(sc, 0xF862, 0x48C8);
1216         MP_WriteMcuAccessRegWord(sc, 0xF864, 0x48C9);
1217         MP_WriteMcuAccessRegWord(sc, 0xF866, 0xE011);
1218         MP_WriteMcuAccessRegWord(sc, 0xF868, 0x48C9);
1219         MP_WriteMcuAccessRegWord(sc, 0xF86A, 0x4848);
1220         MP_WriteMcuAccessRegWord(sc, 0xF86C, 0xE00E);
1221         MP_WriteMcuAccessRegWord(sc, 0xF86E, 0x4848);
1222         MP_WriteMcuAccessRegWord(sc, 0xF870, 0x49C7);
1223         MP_WriteMcuAccessRegWord(sc, 0xF872, 0xF00A);
1224         MP_WriteMcuAccessRegWord(sc, 0xF874, 0x48C9);
1225         MP_WriteMcuAccessRegWord(sc, 0xF876, 0xC60D);
1226         MP_WriteMcuAccessRegWord(sc, 0xF878, 0x1D1F);
1227         MP_WriteMcuAccessRegWord(sc, 0xF87A, 0x8DC2);
1228         MP_WriteMcuAccessRegWord(sc, 0xF87C, 0x1D00);
1229         MP_WriteMcuAccessRegWord(sc, 0xF87E, 0x8DC3);
1230         MP_WriteMcuAccessRegWord(sc, 0xF880, 0x1D11);
1231         MP_WriteMcuAccessRegWord(sc, 0xF882, 0x8DC0);
1232         MP_WriteMcuAccessRegWord(sc, 0xF884, 0xE002);
1233         MP_WriteMcuAccessRegWord(sc, 0xF886, 0x4849);
1234         MP_WriteMcuAccessRegWord(sc, 0xF888, 0x94E5);
1235         MP_WriteMcuAccessRegWord(sc, 0xF88A, 0xC602);
1236         MP_WriteMcuAccessRegWord(sc, 0xF88C, 0xBE00);
1237         MP_WriteMcuAccessRegWord(sc, 0xF88E, 0x0238);
1238         MP_WriteMcuAccessRegWord(sc, 0xF890, 0xE434);
1239         MP_WriteMcuAccessRegWord(sc, 0xF892, 0x49D9);
1240         MP_WriteMcuAccessRegWord(sc, 0xF894, 0xF01B);
1241         MP_WriteMcuAccessRegWord(sc, 0xF896, 0xC31E);
1242         MP_WriteMcuAccessRegWord(sc, 0xF898, 0x7464);
1243         MP_WriteMcuAccessRegWord(sc, 0xF89A, 0x49C4);
1244         MP_WriteMcuAccessRegWord(sc, 0xF89C, 0xF114);
1245         MP_WriteMcuAccessRegWord(sc, 0xF89E, 0xC31B);
1246         MP_WriteMcuAccessRegWord(sc, 0xF8A0, 0x6460);
1247         MP_WriteMcuAccessRegWord(sc, 0xF8A2, 0x14FA);
1248         MP_WriteMcuAccessRegWord(sc, 0xF8A4, 0xFA02);
1249         MP_WriteMcuAccessRegWord(sc, 0xF8A6, 0xE00F);
1250         MP_WriteMcuAccessRegWord(sc, 0xF8A8, 0xC317);
1251         MP_WriteMcuAccessRegWord(sc, 0xF8AA, 0x7460);
1252         MP_WriteMcuAccessRegWord(sc, 0xF8AC, 0x49C0);
1253         MP_WriteMcuAccessRegWord(sc, 0xF8AE, 0xF10B);
1254         MP_WriteMcuAccessRegWord(sc, 0xF8B0, 0xC311);
1255         MP_WriteMcuAccessRegWord(sc, 0xF8B2, 0x7462);
1256         MP_WriteMcuAccessRegWord(sc, 0xF8B4, 0x48C1);
1257         MP_WriteMcuAccessRegWord(sc, 0xF8B6, 0x9C62);
1258         MP_WriteMcuAccessRegWord(sc, 0xF8B8, 0x4841);
1259         MP_WriteMcuAccessRegWord(sc, 0xF8BA, 0x9C62);
1260         MP_WriteMcuAccessRegWord(sc, 0xF8BC, 0xC30A);
1261         MP_WriteMcuAccessRegWord(sc, 0xF8BE, 0x1C04);
1262         MP_WriteMcuAccessRegWord(sc, 0xF8C0, 0x8C60);
1263         MP_WriteMcuAccessRegWord(sc, 0xF8C2, 0xE004);
1264         MP_WriteMcuAccessRegWord(sc, 0xF8C4, 0x1C15);
1265         MP_WriteMcuAccessRegWord(sc, 0xF8C6, 0xC305);
1266         MP_WriteMcuAccessRegWord(sc, 0xF8C8, 0x8C60);
1267         MP_WriteMcuAccessRegWord(sc, 0xF8CA, 0xC602);
1268         MP_WriteMcuAccessRegWord(sc, 0xF8CC, 0xBE00);
1269         MP_WriteMcuAccessRegWord(sc, 0xF8CE, 0x0374);
1270         MP_WriteMcuAccessRegWord(sc, 0xF8D0, 0xE434);
1271         MP_WriteMcuAccessRegWord(sc, 0xF8D2, 0xE030);
1272         MP_WriteMcuAccessRegWord(sc, 0xF8D4, 0xE61C);
1273         MP_WriteMcuAccessRegWord(sc, 0xF8D6, 0xE906);
1274         MP_WriteMcuAccessRegWord(sc, 0xF8D8, 0xC602);
1275         MP_WriteMcuAccessRegWord(sc, 0xF8DA, 0xBE00);
1276         MP_WriteMcuAccessRegWord(sc, 0xF8DC, 0x0000);
1277
1278         MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000);
1279
1280         MP_WriteMcuAccessRegWord(sc, 0xFC28, 0x0493);
1281         MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x0205);
1282         MP_WriteMcuAccessRegWord(sc, 0xFC2C, 0x0589);
1283         MP_WriteMcuAccessRegWord(sc, 0xFC2E, 0x0647);
1284         MP_WriteMcuAccessRegWord(sc, 0xFC30, 0x0000);
1285         MP_WriteMcuAccessRegWord(sc, 0xFC32, 0x0215);
1286         MP_WriteMcuAccessRegWord(sc, 0xFC34, 0x0285);
1287 }
1288
1289 static void re_set_mac_mcu_8168gu_2(struct re_softc *sc)
1290 {
1291         DisableMcuBPs(sc);
1292
1293         MP_WriteMcuAccessRegWord(sc, 0xF800, 0xE008);
1294         MP_WriteMcuAccessRegWord(sc, 0xF802, 0xE00A);
1295         MP_WriteMcuAccessRegWord(sc, 0xF804, 0xE00D);
1296         MP_WriteMcuAccessRegWord(sc, 0xF806, 0xE02F);
1297         MP_WriteMcuAccessRegWord(sc, 0xF808, 0xE031);
1298         MP_WriteMcuAccessRegWord(sc, 0xF80A, 0xE038);
1299         MP_WriteMcuAccessRegWord(sc, 0xF80C, 0xE03A);
1300         MP_WriteMcuAccessRegWord(sc, 0xF80E, 0xE051);
1301         MP_WriteMcuAccessRegWord(sc, 0xF810, 0xC202);
1302         MP_WriteMcuAccessRegWord(sc, 0xF812, 0xBA00);
1303         MP_WriteMcuAccessRegWord(sc, 0xF814, 0x0DFC);
1304         MP_WriteMcuAccessRegWord(sc, 0xF816, 0x7444);
1305         MP_WriteMcuAccessRegWord(sc, 0xF818, 0xC502);
1306         MP_WriteMcuAccessRegWord(sc, 0xF81A, 0xBD00);
1307         MP_WriteMcuAccessRegWord(sc, 0xF81C, 0x0A30);
1308         MP_WriteMcuAccessRegWord(sc, 0xF81E, 0x49D9);
1309         MP_WriteMcuAccessRegWord(sc, 0xF820, 0xF019);
1310         MP_WriteMcuAccessRegWord(sc, 0xF822, 0xC520);
1311         MP_WriteMcuAccessRegWord(sc, 0xF824, 0x64A5);
1312         MP_WriteMcuAccessRegWord(sc, 0xF826, 0x1400);
1313         MP_WriteMcuAccessRegWord(sc, 0xF828, 0xF007);
1314         MP_WriteMcuAccessRegWord(sc, 0xF82A, 0x0C01);
1315         MP_WriteMcuAccessRegWord(sc, 0xF82C, 0x8CA5);
1316         MP_WriteMcuAccessRegWord(sc, 0xF82E, 0x1C15);
1317         MP_WriteMcuAccessRegWord(sc, 0xF830, 0xC515);
1318         MP_WriteMcuAccessRegWord(sc, 0xF832, 0x9CA0);
1319         MP_WriteMcuAccessRegWord(sc, 0xF834, 0xE00F);
1320         MP_WriteMcuAccessRegWord(sc, 0xF836, 0xC513);
1321         MP_WriteMcuAccessRegWord(sc, 0xF838, 0x74A0);
1322         MP_WriteMcuAccessRegWord(sc, 0xF83A, 0x48C8);
1323         MP_WriteMcuAccessRegWord(sc, 0xF83C, 0x48CA);
1324         MP_WriteMcuAccessRegWord(sc, 0xF83E, 0x9CA0);
1325         MP_WriteMcuAccessRegWord(sc, 0xF840, 0xC510);
1326         MP_WriteMcuAccessRegWord(sc, 0xF842, 0x1B00);
1327         MP_WriteMcuAccessRegWord(sc, 0xF844, 0x9BA0);
1328         MP_WriteMcuAccessRegWord(sc, 0xF846, 0x1B1C);
1329         MP_WriteMcuAccessRegWord(sc, 0xF848, 0x483F);
1330         MP_WriteMcuAccessRegWord(sc, 0xF84A, 0x9BA2);
1331         MP_WriteMcuAccessRegWord(sc, 0xF84C, 0x1B04);
1332         MP_WriteMcuAccessRegWord(sc, 0xF84E, 0xC506);
1333         MP_WriteMcuAccessRegWord(sc, 0xF850, 0x9BA0);
1334         MP_WriteMcuAccessRegWord(sc, 0xF852, 0xC603);
1335         MP_WriteMcuAccessRegWord(sc, 0xF854, 0xBE00);
1336         MP_WriteMcuAccessRegWord(sc, 0xF856, 0x0298);
1337         MP_WriteMcuAccessRegWord(sc, 0xF858, 0x03DE);
1338         MP_WriteMcuAccessRegWord(sc, 0xF85A, 0xE434);
1339         MP_WriteMcuAccessRegWord(sc, 0xF85C, 0xE096);
1340         MP_WriteMcuAccessRegWord(sc, 0xF85E, 0xE860);
1341         MP_WriteMcuAccessRegWord(sc, 0xF860, 0xDE20);
1342         MP_WriteMcuAccessRegWord(sc, 0xF862, 0xD3C0);
1343         MP_WriteMcuAccessRegWord(sc, 0xF864, 0xC602);
1344         MP_WriteMcuAccessRegWord(sc, 0xF866, 0xBE00);
1345         MP_WriteMcuAccessRegWord(sc, 0xF868, 0x0A64);
1346         MP_WriteMcuAccessRegWord(sc, 0xF86A, 0xC707);
1347         MP_WriteMcuAccessRegWord(sc, 0xF86C, 0x1D00);
1348         MP_WriteMcuAccessRegWord(sc, 0xF86E, 0x8DE2);
1349         MP_WriteMcuAccessRegWord(sc, 0xF870, 0x48C1);
1350         MP_WriteMcuAccessRegWord(sc, 0xF872, 0xC502);
1351         MP_WriteMcuAccessRegWord(sc, 0xF874, 0xBD00);
1352         MP_WriteMcuAccessRegWord(sc, 0xF876, 0x00AA);
1353         MP_WriteMcuAccessRegWord(sc, 0xF878, 0xE0C0);
1354         MP_WriteMcuAccessRegWord(sc, 0xF87A, 0xC502);
1355         MP_WriteMcuAccessRegWord(sc, 0xF87C, 0xBD00);
1356         MP_WriteMcuAccessRegWord(sc, 0xF87E, 0x0132);
1357         MP_WriteMcuAccessRegWord(sc, 0xF880, 0xC50C);
1358         MP_WriteMcuAccessRegWord(sc, 0xF882, 0x74A2);
1359         MP_WriteMcuAccessRegWord(sc, 0xF884, 0x49CE);
1360         MP_WriteMcuAccessRegWord(sc, 0xF886, 0xF1FE);
1361         MP_WriteMcuAccessRegWord(sc, 0xF888, 0x1C00);
1362         MP_WriteMcuAccessRegWord(sc, 0xF88A, 0x9EA0);
1363         MP_WriteMcuAccessRegWord(sc, 0xF88C, 0x1C1C);
1364         MP_WriteMcuAccessRegWord(sc, 0xF88E, 0x484F);
1365         MP_WriteMcuAccessRegWord(sc, 0xF890, 0x9CA2);
1366         MP_WriteMcuAccessRegWord(sc, 0xF892, 0xC402);
1367         MP_WriteMcuAccessRegWord(sc, 0xF894, 0xBC00);
1368         MP_WriteMcuAccessRegWord(sc, 0xF896, 0x0AFA);
1369         MP_WriteMcuAccessRegWord(sc, 0xF898, 0xDE20);
1370         MP_WriteMcuAccessRegWord(sc, 0xF89A, 0xE000);
1371         MP_WriteMcuAccessRegWord(sc, 0xF89C, 0xE092);
1372         MP_WriteMcuAccessRegWord(sc, 0xF89E, 0xE430);
1373         MP_WriteMcuAccessRegWord(sc, 0xF8A0, 0xDE20);
1374         MP_WriteMcuAccessRegWord(sc, 0xF8A2, 0xE0C0);
1375         MP_WriteMcuAccessRegWord(sc, 0xF8A4, 0xE860);
1376         MP_WriteMcuAccessRegWord(sc, 0xF8A6, 0xE84C);
1377         MP_WriteMcuAccessRegWord(sc, 0xF8A8, 0xB400);
1378         MP_WriteMcuAccessRegWord(sc, 0xF8AA, 0xB430);
1379         MP_WriteMcuAccessRegWord(sc, 0xF8AC, 0xE410);
1380         MP_WriteMcuAccessRegWord(sc, 0xF8AE, 0xC0AE);
1381         MP_WriteMcuAccessRegWord(sc, 0xF8B0, 0xB407);
1382         MP_WriteMcuAccessRegWord(sc, 0xF8B2, 0xB406);
1383         MP_WriteMcuAccessRegWord(sc, 0xF8B4, 0xB405);
1384         MP_WriteMcuAccessRegWord(sc, 0xF8B6, 0xB404);
1385         MP_WriteMcuAccessRegWord(sc, 0xF8B8, 0xB403);
1386         MP_WriteMcuAccessRegWord(sc, 0xF8BA, 0xB402);
1387         MP_WriteMcuAccessRegWord(sc, 0xF8BC, 0xB401);
1388         MP_WriteMcuAccessRegWord(sc, 0xF8BE, 0xC7EE);
1389         MP_WriteMcuAccessRegWord(sc, 0xF8C0, 0x76F4);
1390         MP_WriteMcuAccessRegWord(sc, 0xF8C2, 0xC2ED);
1391         MP_WriteMcuAccessRegWord(sc, 0xF8C4, 0xC3ED);
1392         MP_WriteMcuAccessRegWord(sc, 0xF8C6, 0xC1EF);
1393         MP_WriteMcuAccessRegWord(sc, 0xF8C8, 0xC5F3);
1394         MP_WriteMcuAccessRegWord(sc, 0xF8CA, 0x74A0);
1395         MP_WriteMcuAccessRegWord(sc, 0xF8CC, 0x49CD);
1396         MP_WriteMcuAccessRegWord(sc, 0xF8CE, 0xF001);
1397         MP_WriteMcuAccessRegWord(sc, 0xF8D0, 0xC5EE);
1398         MP_WriteMcuAccessRegWord(sc, 0xF8D2, 0x74A0);
1399         MP_WriteMcuAccessRegWord(sc, 0xF8D4, 0x49C1);
1400         MP_WriteMcuAccessRegWord(sc, 0xF8D6, 0xF105);
1401         MP_WriteMcuAccessRegWord(sc, 0xF8D8, 0xC5E4);
1402         MP_WriteMcuAccessRegWord(sc, 0xF8DA, 0x74A2);
1403         MP_WriteMcuAccessRegWord(sc, 0xF8DC, 0x49CE);
1404         MP_WriteMcuAccessRegWord(sc, 0xF8DE, 0xF00B);
1405         MP_WriteMcuAccessRegWord(sc, 0xF8E0, 0x7444);
1406         MP_WriteMcuAccessRegWord(sc, 0xF8E2, 0x484B);
1407         MP_WriteMcuAccessRegWord(sc, 0xF8E4, 0x9C44);
1408         MP_WriteMcuAccessRegWord(sc, 0xF8E6, 0x1C10);
1409         MP_WriteMcuAccessRegWord(sc, 0xF8E8, 0x9C62);
1410         MP_WriteMcuAccessRegWord(sc, 0xF8EA, 0x1C11);
1411         MP_WriteMcuAccessRegWord(sc, 0xF8EC, 0x8C60);
1412         MP_WriteMcuAccessRegWord(sc, 0xF8EE, 0x1C00);
1413         MP_WriteMcuAccessRegWord(sc, 0xF8F0, 0x9CF6);
1414         MP_WriteMcuAccessRegWord(sc, 0xF8F2, 0xE0EC);
1415         MP_WriteMcuAccessRegWord(sc, 0xF8F4, 0x49E7);
1416         MP_WriteMcuAccessRegWord(sc, 0xF8F6, 0xF016);
1417         MP_WriteMcuAccessRegWord(sc, 0xF8F8, 0x1D80);
1418         MP_WriteMcuAccessRegWord(sc, 0xF8FA, 0x8DF4);
1419         MP_WriteMcuAccessRegWord(sc, 0xF8FC, 0x74F8);
1420         MP_WriteMcuAccessRegWord(sc, 0xF8FE, 0x4843);
1421         MP_WriteMcuAccessRegWord(sc, 0xF900, 0x8CF8);
1422         MP_WriteMcuAccessRegWord(sc, 0xF902, 0x74F8);
1423         MP_WriteMcuAccessRegWord(sc, 0xF904, 0x74F8);
1424         MP_WriteMcuAccessRegWord(sc, 0xF906, 0x7444);
1425         MP_WriteMcuAccessRegWord(sc, 0xF908, 0x48C8);
1426         MP_WriteMcuAccessRegWord(sc, 0xF90A, 0x48C9);
1427         MP_WriteMcuAccessRegWord(sc, 0xF90C, 0x48CA);
1428         MP_WriteMcuAccessRegWord(sc, 0xF90E, 0x9C44);
1429         MP_WriteMcuAccessRegWord(sc, 0xF910, 0x74F8);
1430         MP_WriteMcuAccessRegWord(sc, 0xF912, 0x4844);
1431         MP_WriteMcuAccessRegWord(sc, 0xF914, 0x8CF8);
1432         MP_WriteMcuAccessRegWord(sc, 0xF916, 0x1E01);
1433         MP_WriteMcuAccessRegWord(sc, 0xF918, 0xE8DB);
1434         MP_WriteMcuAccessRegWord(sc, 0xF91A, 0x7420);
1435         MP_WriteMcuAccessRegWord(sc, 0xF91C, 0x48C1);
1436         MP_WriteMcuAccessRegWord(sc, 0xF91E, 0x9C20);
1437         MP_WriteMcuAccessRegWord(sc, 0xF920, 0xE0D5);
1438         MP_WriteMcuAccessRegWord(sc, 0xF922, 0x49E6);
1439         MP_WriteMcuAccessRegWord(sc, 0xF924, 0xF02A);
1440         MP_WriteMcuAccessRegWord(sc, 0xF926, 0x1D40);
1441         MP_WriteMcuAccessRegWord(sc, 0xF928, 0x8DF4);
1442         MP_WriteMcuAccessRegWord(sc, 0xF92A, 0x74FC);
1443         MP_WriteMcuAccessRegWord(sc, 0xF92C, 0x49C0);
1444         MP_WriteMcuAccessRegWord(sc, 0xF92E, 0xF124);
1445         MP_WriteMcuAccessRegWord(sc, 0xF930, 0x49C1);
1446         MP_WriteMcuAccessRegWord(sc, 0xF932, 0xF122);
1447         MP_WriteMcuAccessRegWord(sc, 0xF934, 0x74F8);
1448         MP_WriteMcuAccessRegWord(sc, 0xF936, 0x49C0);
1449         MP_WriteMcuAccessRegWord(sc, 0xF938, 0xF01F);
1450         MP_WriteMcuAccessRegWord(sc, 0xF93A, 0xE8D3);
1451         MP_WriteMcuAccessRegWord(sc, 0xF93C, 0x48C4);
1452         MP_WriteMcuAccessRegWord(sc, 0xF93E, 0x8CF8);
1453         MP_WriteMcuAccessRegWord(sc, 0xF940, 0x1E00);
1454         MP_WriteMcuAccessRegWord(sc, 0xF942, 0xE8C6);
1455         MP_WriteMcuAccessRegWord(sc, 0xF944, 0xC5B1);
1456         MP_WriteMcuAccessRegWord(sc, 0xF946, 0x74A0);
1457         MP_WriteMcuAccessRegWord(sc, 0xF948, 0x49C3);
1458         MP_WriteMcuAccessRegWord(sc, 0xF94A, 0xF016);
1459         MP_WriteMcuAccessRegWord(sc, 0xF94C, 0xC5AF);
1460         MP_WriteMcuAccessRegWord(sc, 0xF94E, 0x74A4);
1461         MP_WriteMcuAccessRegWord(sc, 0xF950, 0x49C2);
1462         MP_WriteMcuAccessRegWord(sc, 0xF952, 0xF005);
1463         MP_WriteMcuAccessRegWord(sc, 0xF954, 0xC5AA);
1464         MP_WriteMcuAccessRegWord(sc, 0xF956, 0x74B2);
1465         MP_WriteMcuAccessRegWord(sc, 0xF958, 0x49C9);
1466         MP_WriteMcuAccessRegWord(sc, 0xF95A, 0xF10E);
1467         MP_WriteMcuAccessRegWord(sc, 0xF95C, 0xC5A6);
1468         MP_WriteMcuAccessRegWord(sc, 0xF95E, 0x74A8);
1469         MP_WriteMcuAccessRegWord(sc, 0xF960, 0x4845);
1470         MP_WriteMcuAccessRegWord(sc, 0xF962, 0x4846);
1471         MP_WriteMcuAccessRegWord(sc, 0xF964, 0x4847);
1472         MP_WriteMcuAccessRegWord(sc, 0xF966, 0x4848);
1473         MP_WriteMcuAccessRegWord(sc, 0xF968, 0x9CA8);
1474         MP_WriteMcuAccessRegWord(sc, 0xF96A, 0x74B2);
1475         MP_WriteMcuAccessRegWord(sc, 0xF96C, 0x4849);
1476         MP_WriteMcuAccessRegWord(sc, 0xF96E, 0x9CB2);
1477         MP_WriteMcuAccessRegWord(sc, 0xF970, 0x74A0);
1478         MP_WriteMcuAccessRegWord(sc, 0xF972, 0x484F);
1479         MP_WriteMcuAccessRegWord(sc, 0xF974, 0x9CA0);
1480         MP_WriteMcuAccessRegWord(sc, 0xF976, 0xE0AA);
1481         MP_WriteMcuAccessRegWord(sc, 0xF978, 0x49E4);
1482         MP_WriteMcuAccessRegWord(sc, 0xF97A, 0xF018);
1483         MP_WriteMcuAccessRegWord(sc, 0xF97C, 0x1D10);
1484         MP_WriteMcuAccessRegWord(sc, 0xF97E, 0x8DF4);
1485         MP_WriteMcuAccessRegWord(sc, 0xF980, 0x74F8);
1486         MP_WriteMcuAccessRegWord(sc, 0xF982, 0x74F8);
1487         MP_WriteMcuAccessRegWord(sc, 0xF984, 0x74F8);
1488         MP_WriteMcuAccessRegWord(sc, 0xF986, 0x4843);
1489         MP_WriteMcuAccessRegWord(sc, 0xF988, 0x8CF8);
1490         MP_WriteMcuAccessRegWord(sc, 0xF98A, 0x74F8);
1491         MP_WriteMcuAccessRegWord(sc, 0xF98C, 0x74F8);
1492         MP_WriteMcuAccessRegWord(sc, 0xF98E, 0x74F8);
1493         MP_WriteMcuAccessRegWord(sc, 0xF990, 0x4844);
1494         MP_WriteMcuAccessRegWord(sc, 0xF992, 0x4842);
1495         MP_WriteMcuAccessRegWord(sc, 0xF994, 0x4841);
1496         MP_WriteMcuAccessRegWord(sc, 0xF996, 0x8CF8);
1497         MP_WriteMcuAccessRegWord(sc, 0xF998, 0x1E01);
1498         MP_WriteMcuAccessRegWord(sc, 0xF99A, 0xE89A);
1499         MP_WriteMcuAccessRegWord(sc, 0xF99C, 0x7420);
1500         MP_WriteMcuAccessRegWord(sc, 0xF99E, 0x4841);
1501         MP_WriteMcuAccessRegWord(sc, 0xF9A0, 0x9C20);
1502         MP_WriteMcuAccessRegWord(sc, 0xF9A2, 0x7444);
1503         MP_WriteMcuAccessRegWord(sc, 0xF9A4, 0x4848);
1504         MP_WriteMcuAccessRegWord(sc, 0xF9A6, 0x9C44);
1505         MP_WriteMcuAccessRegWord(sc, 0xF9A8, 0xE091);
1506         MP_WriteMcuAccessRegWord(sc, 0xF9AA, 0x49E5);
1507         MP_WriteMcuAccessRegWord(sc, 0xF9AC, 0xF03E);
1508         MP_WriteMcuAccessRegWord(sc, 0xF9AE, 0x1D20);
1509         MP_WriteMcuAccessRegWord(sc, 0xF9B0, 0x8DF4);
1510         MP_WriteMcuAccessRegWord(sc, 0xF9B2, 0x74F8);
1511         MP_WriteMcuAccessRegWord(sc, 0xF9B4, 0x48C2);
1512         MP_WriteMcuAccessRegWord(sc, 0xF9B6, 0x4841);
1513         MP_WriteMcuAccessRegWord(sc, 0xF9B8, 0x8CF8);
1514         MP_WriteMcuAccessRegWord(sc, 0xF9BA, 0x1E01);
1515         MP_WriteMcuAccessRegWord(sc, 0xF9BC, 0x7444);
1516         MP_WriteMcuAccessRegWord(sc, 0xF9BE, 0x49CA);
1517         MP_WriteMcuAccessRegWord(sc, 0xF9C0, 0xF103);
1518         MP_WriteMcuAccessRegWord(sc, 0xF9C2, 0x49C2);
1519         MP_WriteMcuAccessRegWord(sc, 0xF9C4, 0xF00C);
1520         MP_WriteMcuAccessRegWord(sc, 0xF9C6, 0x49C1);
1521         MP_WriteMcuAccessRegWord(sc, 0xF9C8, 0xF004);
1522         MP_WriteMcuAccessRegWord(sc, 0xF9CA, 0x6447);
1523         MP_WriteMcuAccessRegWord(sc, 0xF9CC, 0x2244);
1524         MP_WriteMcuAccessRegWord(sc, 0xF9CE, 0xE002);
1525         MP_WriteMcuAccessRegWord(sc, 0xF9D0, 0x1C01);
1526         MP_WriteMcuAccessRegWord(sc, 0xF9D2, 0x9C62);
1527         MP_WriteMcuAccessRegWord(sc, 0xF9D4, 0x1C11);
1528         MP_WriteMcuAccessRegWord(sc, 0xF9D6, 0x8C60);
1529         MP_WriteMcuAccessRegWord(sc, 0xF9D8, 0x1C00);
1530         MP_WriteMcuAccessRegWord(sc, 0xF9DA, 0x9CF6);
1531         MP_WriteMcuAccessRegWord(sc, 0xF9DC, 0x7444);
1532         MP_WriteMcuAccessRegWord(sc, 0xF9DE, 0x49C8);
1533         MP_WriteMcuAccessRegWord(sc, 0xF9E0, 0xF01D);
1534         MP_WriteMcuAccessRegWord(sc, 0xF9E2, 0x74FC);
1535         MP_WriteMcuAccessRegWord(sc, 0xF9E4, 0x49C0);
1536         MP_WriteMcuAccessRegWord(sc, 0xF9E6, 0xF11A);
1537         MP_WriteMcuAccessRegWord(sc, 0xF9E8, 0x49C1);
1538         MP_WriteMcuAccessRegWord(sc, 0xF9EA, 0xF118);
1539         MP_WriteMcuAccessRegWord(sc, 0xF9EC, 0x74F8);
1540         MP_WriteMcuAccessRegWord(sc, 0xF9EE, 0x49C0);
1541         MP_WriteMcuAccessRegWord(sc, 0xF9F0, 0xF015);
1542         MP_WriteMcuAccessRegWord(sc, 0xF9F2, 0x49C6);
1543         MP_WriteMcuAccessRegWord(sc, 0xF9F4, 0xF113);
1544         MP_WriteMcuAccessRegWord(sc, 0xF9F6, 0xE875);
1545         MP_WriteMcuAccessRegWord(sc, 0xF9F8, 0x48C4);
1546         MP_WriteMcuAccessRegWord(sc, 0xF9FA, 0x8CF8);
1547         MP_WriteMcuAccessRegWord(sc, 0xF9FC, 0x7420);
1548         MP_WriteMcuAccessRegWord(sc, 0xF9FE, 0x48C1);
1549         MP_WriteMcuAccessRegWord(sc, 0xFA00, 0x9C20);
1550         MP_WriteMcuAccessRegWord(sc, 0xFA02, 0xC50A);
1551         MP_WriteMcuAccessRegWord(sc, 0xFA04, 0x74A2);
1552         MP_WriteMcuAccessRegWord(sc, 0xFA06, 0x8CA5);
1553         MP_WriteMcuAccessRegWord(sc, 0xFA08, 0x74A0);
1554         MP_WriteMcuAccessRegWord(sc, 0xFA0A, 0xC505);
1555         MP_WriteMcuAccessRegWord(sc, 0xFA0C, 0x9CA2);
1556         MP_WriteMcuAccessRegWord(sc, 0xFA0E, 0x1C11);
1557         MP_WriteMcuAccessRegWord(sc, 0xFA10, 0x9CA0);
1558         MP_WriteMcuAccessRegWord(sc, 0xFA12, 0xE00A);
1559         MP_WriteMcuAccessRegWord(sc, 0xFA14, 0xE434);
1560         MP_WriteMcuAccessRegWord(sc, 0xFA16, 0xD3C0);
1561         MP_WriteMcuAccessRegWord(sc, 0xFA18, 0xDC00);
1562         MP_WriteMcuAccessRegWord(sc, 0xFA1A, 0x7444);
1563         MP_WriteMcuAccessRegWord(sc, 0xFA1C, 0x49CA);
1564         MP_WriteMcuAccessRegWord(sc, 0xFA1E, 0xF004);
1565         MP_WriteMcuAccessRegWord(sc, 0xFA20, 0x48CA);
1566         MP_WriteMcuAccessRegWord(sc, 0xFA22, 0x9C44);
1567         MP_WriteMcuAccessRegWord(sc, 0xFA24, 0xE855);
1568         MP_WriteMcuAccessRegWord(sc, 0xFA26, 0xE052);
1569         MP_WriteMcuAccessRegWord(sc, 0xFA28, 0x49E8);
1570         MP_WriteMcuAccessRegWord(sc, 0xFA2A, 0xF024);
1571         MP_WriteMcuAccessRegWord(sc, 0xFA2C, 0x1D01);
1572         MP_WriteMcuAccessRegWord(sc, 0xFA2E, 0x8DF5);
1573         MP_WriteMcuAccessRegWord(sc, 0xFA30, 0x7440);
1574         MP_WriteMcuAccessRegWord(sc, 0xFA32, 0x49C0);
1575         MP_WriteMcuAccessRegWord(sc, 0xFA34, 0xF11E);
1576         MP_WriteMcuAccessRegWord(sc, 0xFA36, 0x7444);
1577         MP_WriteMcuAccessRegWord(sc, 0xFA38, 0x49C8);
1578         MP_WriteMcuAccessRegWord(sc, 0xFA3A, 0xF01B);
1579         MP_WriteMcuAccessRegWord(sc, 0xFA3C, 0x49CA);
1580         MP_WriteMcuAccessRegWord(sc, 0xFA3E, 0xF119);
1581         MP_WriteMcuAccessRegWord(sc, 0xFA40, 0xC5EC);
1582         MP_WriteMcuAccessRegWord(sc, 0xFA42, 0x76A4);
1583         MP_WriteMcuAccessRegWord(sc, 0xFA44, 0x49E3);
1584         MP_WriteMcuAccessRegWord(sc, 0xFA46, 0xF015);
1585         MP_WriteMcuAccessRegWord(sc, 0xFA48, 0x49C0);
1586         MP_WriteMcuAccessRegWord(sc, 0xFA4A, 0xF103);
1587         MP_WriteMcuAccessRegWord(sc, 0xFA4C, 0x49C1);
1588         MP_WriteMcuAccessRegWord(sc, 0xFA4E, 0xF011);
1589         MP_WriteMcuAccessRegWord(sc, 0xFA50, 0x4849);
1590         MP_WriteMcuAccessRegWord(sc, 0xFA52, 0x9C44);
1591         MP_WriteMcuAccessRegWord(sc, 0xFA54, 0x1C00);
1592         MP_WriteMcuAccessRegWord(sc, 0xFA56, 0x9CF6);
1593         MP_WriteMcuAccessRegWord(sc, 0xFA58, 0x7444);
1594         MP_WriteMcuAccessRegWord(sc, 0xFA5A, 0x49C1);
1595         MP_WriteMcuAccessRegWord(sc, 0xFA5C, 0xF004);
1596         MP_WriteMcuAccessRegWord(sc, 0xFA5E, 0x6446);
1597         MP_WriteMcuAccessRegWord(sc, 0xFA60, 0x1E07);
1598         MP_WriteMcuAccessRegWord(sc, 0xFA62, 0xE003);
1599         MP_WriteMcuAccessRegWord(sc, 0xFA64, 0x1C01);
1600         MP_WriteMcuAccessRegWord(sc, 0xFA66, 0x1E03);
1601         MP_WriteMcuAccessRegWord(sc, 0xFA68, 0x9C62);
1602         MP_WriteMcuAccessRegWord(sc, 0xFA6A, 0x1C11);
1603         MP_WriteMcuAccessRegWord(sc, 0xFA6C, 0x8C60);
1604         MP_WriteMcuAccessRegWord(sc, 0xFA6E, 0xE830);
1605         MP_WriteMcuAccessRegWord(sc, 0xFA70, 0xE02D);
1606         MP_WriteMcuAccessRegWord(sc, 0xFA72, 0x49E9);
1607         MP_WriteMcuAccessRegWord(sc, 0xFA74, 0xF004);
1608         MP_WriteMcuAccessRegWord(sc, 0xFA76, 0x1D02);
1609         MP_WriteMcuAccessRegWord(sc, 0xFA78, 0x8DF5);
1610         MP_WriteMcuAccessRegWord(sc, 0xFA7A, 0xE79C);
1611         MP_WriteMcuAccessRegWord(sc, 0xFA7C, 0x49E3);
1612         MP_WriteMcuAccessRegWord(sc, 0xFA7E, 0xF006);
1613         MP_WriteMcuAccessRegWord(sc, 0xFA80, 0x1D08);
1614         MP_WriteMcuAccessRegWord(sc, 0xFA82, 0x8DF4);
1615         MP_WriteMcuAccessRegWord(sc, 0xFA84, 0x74F8);
1616         MP_WriteMcuAccessRegWord(sc, 0xFA86, 0x74F8);
1617         MP_WriteMcuAccessRegWord(sc, 0xFA88, 0xE73A);
1618         MP_WriteMcuAccessRegWord(sc, 0xFA8A, 0x49E1);
1619         MP_WriteMcuAccessRegWord(sc, 0xFA8C, 0xF007);
1620         MP_WriteMcuAccessRegWord(sc, 0xFA8E, 0x1D02);
1621         MP_WriteMcuAccessRegWord(sc, 0xFA90, 0x8DF4);
1622         MP_WriteMcuAccessRegWord(sc, 0xFA92, 0x1E01);
1623         MP_WriteMcuAccessRegWord(sc, 0xFA94, 0xE7A7);
1624         MP_WriteMcuAccessRegWord(sc, 0xFA96, 0xDE20);
1625         MP_WriteMcuAccessRegWord(sc, 0xFA98, 0xE410);
1626         MP_WriteMcuAccessRegWord(sc, 0xFA9A, 0x49E0);
1627         MP_WriteMcuAccessRegWord(sc, 0xFA9C, 0xF017);
1628         MP_WriteMcuAccessRegWord(sc, 0xFA9E, 0x1D01);
1629         MP_WriteMcuAccessRegWord(sc, 0xFAA0, 0x8DF4);
1630         MP_WriteMcuAccessRegWord(sc, 0xFAA2, 0xC5FA);
1631         MP_WriteMcuAccessRegWord(sc, 0xFAA4, 0x1C00);
1632         MP_WriteMcuAccessRegWord(sc, 0xFAA6, 0x8CA0);
1633         MP_WriteMcuAccessRegWord(sc, 0xFAA8, 0x1C1B);
1634         MP_WriteMcuAccessRegWord(sc, 0xFAAA, 0x9CA2);
1635         MP_WriteMcuAccessRegWord(sc, 0xFAAC, 0x74A2);
1636         MP_WriteMcuAccessRegWord(sc, 0xFAAE, 0x49CF);
1637         MP_WriteMcuAccessRegWord(sc, 0xFAB0, 0xF0FE);
1638         MP_WriteMcuAccessRegWord(sc, 0xFAB2, 0xC5F3);
1639         MP_WriteMcuAccessRegWord(sc, 0xFAB4, 0x74A0);
1640         MP_WriteMcuAccessRegWord(sc, 0xFAB6, 0x4849);
1641         MP_WriteMcuAccessRegWord(sc, 0xFAB8, 0x9CA0);
1642         MP_WriteMcuAccessRegWord(sc, 0xFABA, 0x74F8);
1643         MP_WriteMcuAccessRegWord(sc, 0xFABC, 0x49C0);
1644         MP_WriteMcuAccessRegWord(sc, 0xFABE, 0xF006);
1645         MP_WriteMcuAccessRegWord(sc, 0xFAC0, 0x48C3);
1646         MP_WriteMcuAccessRegWord(sc, 0xFAC2, 0x8CF8);
1647         MP_WriteMcuAccessRegWord(sc, 0xFAC4, 0xE820);
1648         MP_WriteMcuAccessRegWord(sc, 0xFAC6, 0x74F8);
1649         MP_WriteMcuAccessRegWord(sc, 0xFAC8, 0x74F8);
1650         MP_WriteMcuAccessRegWord(sc, 0xFACA, 0xC432);
1651         MP_WriteMcuAccessRegWord(sc, 0xFACC, 0xBC00);
1652         MP_WriteMcuAccessRegWord(sc, 0xFACE, 0xC5E4);
1653         MP_WriteMcuAccessRegWord(sc, 0xFAD0, 0x74A2);
1654         MP_WriteMcuAccessRegWord(sc, 0xFAD2, 0x49CE);
1655         MP_WriteMcuAccessRegWord(sc, 0xFAD4, 0xF1FE);
1656         MP_WriteMcuAccessRegWord(sc, 0xFAD6, 0x9EA0);
1657         MP_WriteMcuAccessRegWord(sc, 0xFAD8, 0x1C1C);
1658         MP_WriteMcuAccessRegWord(sc, 0xFADA, 0x484F);
1659         MP_WriteMcuAccessRegWord(sc, 0xFADC, 0x9CA2);
1660         MP_WriteMcuAccessRegWord(sc, 0xFADE, 0xFF80);
1661         MP_WriteMcuAccessRegWord(sc, 0xFAE0, 0xB404);
1662         MP_WriteMcuAccessRegWord(sc, 0xFAE2, 0xB405);
1663         MP_WriteMcuAccessRegWord(sc, 0xFAE4, 0xC5D9);
1664         MP_WriteMcuAccessRegWord(sc, 0xFAE6, 0x74A2);
1665         MP_WriteMcuAccessRegWord(sc, 0xFAE8, 0x49CE);
1666         MP_WriteMcuAccessRegWord(sc, 0xFAEA, 0xF1FE);
1667         MP_WriteMcuAccessRegWord(sc, 0xFAEC, 0xC41F);
1668         MP_WriteMcuAccessRegWord(sc, 0xFAEE, 0x9CA0);
1669         MP_WriteMcuAccessRegWord(sc, 0xFAF0, 0xC41C);
1670         MP_WriteMcuAccessRegWord(sc, 0xFAF2, 0x1C13);
1671         MP_WriteMcuAccessRegWord(sc, 0xFAF4, 0x484F);
1672         MP_WriteMcuAccessRegWord(sc, 0xFAF6, 0x9CA2);
1673         MP_WriteMcuAccessRegWord(sc, 0xFAF8, 0x74A2);
1674         MP_WriteMcuAccessRegWord(sc, 0xFAFA, 0x49CF);
1675         MP_WriteMcuAccessRegWord(sc, 0xFAFC, 0xF1FE);
1676         MP_WriteMcuAccessRegWord(sc, 0xFAFE, 0xB005);
1677         MP_WriteMcuAccessRegWord(sc, 0xFB00, 0xB004);
1678         MP_WriteMcuAccessRegWord(sc, 0xFB02, 0xFF80);
1679         MP_WriteMcuAccessRegWord(sc, 0xFB04, 0xB404);
1680         MP_WriteMcuAccessRegWord(sc, 0xFB06, 0xB405);
1681         MP_WriteMcuAccessRegWord(sc, 0xFB08, 0xC5C7);
1682         MP_WriteMcuAccessRegWord(sc, 0xFB0A, 0x74A2);
1683         MP_WriteMcuAccessRegWord(sc, 0xFB0C, 0x49CE);
1684         MP_WriteMcuAccessRegWord(sc, 0xFB0E, 0xF1FE);
1685         MP_WriteMcuAccessRegWord(sc, 0xFB10, 0xC40E);
1686         MP_WriteMcuAccessRegWord(sc, 0xFB12, 0x9CA0);
1687         MP_WriteMcuAccessRegWord(sc, 0xFB14, 0xC40A);
1688         MP_WriteMcuAccessRegWord(sc, 0xFB16, 0x1C13);
1689         MP_WriteMcuAccessRegWord(sc, 0xFB18, 0x484F);
1690         MP_WriteMcuAccessRegWord(sc, 0xFB1A, 0x9CA2);
1691         MP_WriteMcuAccessRegWord(sc, 0xFB1C, 0x74A2);
1692         MP_WriteMcuAccessRegWord(sc, 0xFB1E, 0x49CF);
1693         MP_WriteMcuAccessRegWord(sc, 0xFB20, 0xF1FE);
1694         MP_WriteMcuAccessRegWord(sc, 0xFB22, 0xB005);
1695         MP_WriteMcuAccessRegWord(sc, 0xFB24, 0xB004);
1696         MP_WriteMcuAccessRegWord(sc, 0xFB26, 0xFF80);
1697         MP_WriteMcuAccessRegWord(sc, 0xFB28, 0x0000);
1698         MP_WriteMcuAccessRegWord(sc, 0xFB2A, 0x0481);
1699         MP_WriteMcuAccessRegWord(sc, 0xFB2C, 0x0C81);
1700         MP_WriteMcuAccessRegWord(sc, 0xFB2E, 0x0AE0);
1701
1702         MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000);
1703
1704         MP_WriteMcuAccessRegWord(sc, 0xFC28, 0x0000);
1705         MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x0000);
1706         MP_WriteMcuAccessRegWord(sc, 0xFC2C, 0x0297);
1707         MP_WriteMcuAccessRegWord(sc, 0xFC2E, 0x0000);
1708         MP_WriteMcuAccessRegWord(sc, 0xFC30, 0x00A9);
1709         MP_WriteMcuAccessRegWord(sc, 0xFC32, 0x012D);
1710         MP_WriteMcuAccessRegWord(sc, 0xFC34, 0x0000);
1711         MP_WriteMcuAccessRegWord(sc, 0xFC36, 0x08DF);
1712 }
1713
1714 static void re_set_mac_mcu_8411b_1(struct re_softc *sc)
1715 {
1716         DisableMcuBPs(sc);
1717
1718         MP_WriteMcuAccessRegWord(sc, 0xF800, 0xE008);
1719         MP_WriteMcuAccessRegWord(sc, 0xF802, 0xE00A);
1720         MP_WriteMcuAccessRegWord(sc, 0xF804, 0xE00C);
1721         MP_WriteMcuAccessRegWord(sc, 0xF806, 0xE00E);
1722         MP_WriteMcuAccessRegWord(sc, 0xF808, 0xE027);
1723         MP_WriteMcuAccessRegWord(sc, 0xF80A, 0xE04F);
1724         MP_WriteMcuAccessRegWord(sc, 0xF80C, 0xE05E);
1725         MP_WriteMcuAccessRegWord(sc, 0xF80E, 0xE065);
1726         MP_WriteMcuAccessRegWord(sc, 0xF810, 0xC602);
1727         MP_WriteMcuAccessRegWord(sc, 0xF812, 0xBE00);
1728         MP_WriteMcuAccessRegWord(sc, 0xF814, 0x0000);
1729         MP_WriteMcuAccessRegWord(sc, 0xF816, 0xC502);
1730         MP_WriteMcuAccessRegWord(sc, 0xF818, 0xBD00);
1731         MP_WriteMcuAccessRegWord(sc, 0xF81A, 0x074C);
1732         MP_WriteMcuAccessRegWord(sc, 0xF81C, 0xC302);
1733         MP_WriteMcuAccessRegWord(sc, 0xF81E, 0xBB00);
1734         MP_WriteMcuAccessRegWord(sc, 0xF820, 0x080A);
1735         MP_WriteMcuAccessRegWord(sc, 0xF822, 0x6420);
1736         MP_WriteMcuAccessRegWord(sc, 0xF824, 0x48C2);
1737         MP_WriteMcuAccessRegWord(sc, 0xF826, 0x8C20);
1738         MP_WriteMcuAccessRegWord(sc, 0xF828, 0xC516);
1739         MP_WriteMcuAccessRegWord(sc, 0xF82A, 0x64A4);
1740         MP_WriteMcuAccessRegWord(sc, 0xF82C, 0x49C0);
1741         MP_WriteMcuAccessRegWord(sc, 0xF82E, 0xF009);
1742         MP_WriteMcuAccessRegWord(sc, 0xF830, 0x74A2);
1743         MP_WriteMcuAccessRegWord(sc, 0xF832, 0x8CA5);
1744         MP_WriteMcuAccessRegWord(sc, 0xF834, 0x74A0);
1745         MP_WriteMcuAccessRegWord(sc, 0xF836, 0xC50E);
1746         MP_WriteMcuAccessRegWord(sc, 0xF838, 0x9CA2);
1747         MP_WriteMcuAccessRegWord(sc, 0xF83A, 0x1C11);
1748         MP_WriteMcuAccessRegWord(sc, 0xF83C, 0x9CA0);
1749         MP_WriteMcuAccessRegWord(sc, 0xF83E, 0xE006);
1750         MP_WriteMcuAccessRegWord(sc, 0xF840, 0x74F8);
1751         MP_WriteMcuAccessRegWord(sc, 0xF842, 0x48C4);
1752         MP_WriteMcuAccessRegWord(sc, 0xF844, 0x8CF8);
1753         MP_WriteMcuAccessRegWord(sc, 0xF846, 0xC404);
1754         MP_WriteMcuAccessRegWord(sc, 0xF848, 0xBC00);
1755         MP_WriteMcuAccessRegWord(sc, 0xF84A, 0xC403);
1756         MP_WriteMcuAccessRegWord(sc, 0xF84C, 0xBC00);
1757         MP_WriteMcuAccessRegWord(sc, 0xF84E, 0x0BF2);
1758         MP_WriteMcuAccessRegWord(sc, 0xF850, 0x0C0A);
1759         MP_WriteMcuAccessRegWord(sc, 0xF852, 0xE434);
1760         MP_WriteMcuAccessRegWord(sc, 0xF854, 0xD3C0);
1761         MP_WriteMcuAccessRegWord(sc, 0xF856, 0x49D9);
1762         MP_WriteMcuAccessRegWord(sc, 0xF858, 0xF01F);
1763         MP_WriteMcuAccessRegWord(sc, 0xF85A, 0xC526);
1764         MP_WriteMcuAccessRegWord(sc, 0xF85C, 0x64A5);
1765         MP_WriteMcuAccessRegWord(sc, 0xF85E, 0x1400);
1766         MP_WriteMcuAccessRegWord(sc, 0xF860, 0xF007);
1767         MP_WriteMcuAccessRegWord(sc, 0xF862, 0x0C01);
1768         MP_WriteMcuAccessRegWord(sc, 0xF864, 0x8CA5);
1769         MP_WriteMcuAccessRegWord(sc, 0xF866, 0x1C15);
1770         MP_WriteMcuAccessRegWord(sc, 0xF868, 0xC51B);
1771         MP_WriteMcuAccessRegWord(sc, 0xF86A, 0x9CA0);
1772         MP_WriteMcuAccessRegWord(sc, 0xF86C, 0xE013);
1773         MP_WriteMcuAccessRegWord(sc, 0xF86E, 0xC519);
1774         MP_WriteMcuAccessRegWord(sc, 0xF870, 0x74A0);
1775         MP_WriteMcuAccessRegWord(sc, 0xF872, 0x48C4);
1776         MP_WriteMcuAccessRegWord(sc, 0xF874, 0x8CA0);
1777         MP_WriteMcuAccessRegWord(sc, 0xF876, 0xC516);
1778         MP_WriteMcuAccessRegWord(sc, 0xF878, 0x74A4);
1779         MP_WriteMcuAccessRegWord(sc, 0xF87A, 0x48C8);
1780         MP_WriteMcuAccessRegWord(sc, 0xF87C, 0x48CA);
1781         MP_WriteMcuAccessRegWord(sc, 0xF87E, 0x9CA4);
1782         MP_WriteMcuAccessRegWord(sc, 0xF880, 0xC512);
1783         MP_WriteMcuAccessRegWord(sc, 0xF882, 0x1B00);
1784         MP_WriteMcuAccessRegWord(sc, 0xF884, 0x9BA0);
1785         MP_WriteMcuAccessRegWord(sc, 0xF886, 0x1B1C);
1786         MP_WriteMcuAccessRegWord(sc, 0xF888, 0x483F);
1787         MP_WriteMcuAccessRegWord(sc, 0xF88A, 0x9BA2);
1788         MP_WriteMcuAccessRegWord(sc, 0xF88C, 0x1B04);
1789         MP_WriteMcuAccessRegWord(sc, 0xF88E, 0xC508);
1790         MP_WriteMcuAccessRegWord(sc, 0xF890, 0x9BA0);
1791         MP_WriteMcuAccessRegWord(sc, 0xF892, 0xC505);
1792         MP_WriteMcuAccessRegWord(sc, 0xF894, 0xBD00);
1793         MP_WriteMcuAccessRegWord(sc, 0xF896, 0xC502);
1794         MP_WriteMcuAccessRegWord(sc, 0xF898, 0xBD00);
1795         MP_WriteMcuAccessRegWord(sc, 0xF89A, 0x0300);
1796         MP_WriteMcuAccessRegWord(sc, 0xF89C, 0x051E);
1797         MP_WriteMcuAccessRegWord(sc, 0xF89E, 0xE434);
1798         MP_WriteMcuAccessRegWord(sc, 0xF8A0, 0xE018);
1799         MP_WriteMcuAccessRegWord(sc, 0xF8A2, 0xE092);
1800         MP_WriteMcuAccessRegWord(sc, 0xF8A4, 0xDE20);
1801         MP_WriteMcuAccessRegWord(sc, 0xF8A6, 0xD3C0);
1802         MP_WriteMcuAccessRegWord(sc, 0xF8A8, 0xC50F);
1803         MP_WriteMcuAccessRegWord(sc, 0xF8AA, 0x76A4);
1804         MP_WriteMcuAccessRegWord(sc, 0xF8AC, 0x49E3);
1805         MP_WriteMcuAccessRegWord(sc, 0xF8AE, 0xF007);
1806         MP_WriteMcuAccessRegWord(sc, 0xF8B0, 0x49C0);
1807         MP_WriteMcuAccessRegWord(sc, 0xF8B2, 0xF103);
1808         MP_WriteMcuAccessRegWord(sc, 0xF8B4, 0xC607);
1809         MP_WriteMcuAccessRegWord(sc, 0xF8B6, 0xBE00);
1810         MP_WriteMcuAccessRegWord(sc, 0xF8B8, 0xC606);
1811         MP_WriteMcuAccessRegWord(sc, 0xF8BA, 0xBE00);
1812         MP_WriteMcuAccessRegWord(sc, 0xF8BC, 0xC602);
1813         MP_WriteMcuAccessRegWord(sc, 0xF8BE, 0xBE00);
1814         MP_WriteMcuAccessRegWord(sc, 0xF8C0, 0x0C4C);
1815         MP_WriteMcuAccessRegWord(sc, 0xF8C2, 0x0C28);
1816         MP_WriteMcuAccessRegWord(sc, 0xF8C4, 0x0C2C);
1817         MP_WriteMcuAccessRegWord(sc, 0xF8C6, 0xDC00);
1818         MP_WriteMcuAccessRegWord(sc, 0xF8C8, 0xC707);
1819         MP_WriteMcuAccessRegWord(sc, 0xF8CA, 0x1D00);
1820         MP_WriteMcuAccessRegWord(sc, 0xF8CC, 0x8DE2);
1821         MP_WriteMcuAccessRegWord(sc, 0xF8CE, 0x48C1);
1822         MP_WriteMcuAccessRegWord(sc, 0xF8D0, 0xC502);
1823         MP_WriteMcuAccessRegWord(sc, 0xF8D2, 0xBD00);
1824         MP_WriteMcuAccessRegWord(sc, 0xF8D4, 0x00AA);
1825         MP_WriteMcuAccessRegWord(sc, 0xF8D6, 0xE0C0);
1826         MP_WriteMcuAccessRegWord(sc, 0xF8D8, 0xC502);
1827         MP_WriteMcuAccessRegWord(sc, 0xF8DA, 0xBD00);
1828         MP_WriteMcuAccessRegWord(sc, 0xF8DC, 0x0132);
1829
1830         MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000);
1831
1832         MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x0743);
1833         MP_WriteMcuAccessRegWord(sc, 0xFC2C, 0x0801);
1834         MP_WriteMcuAccessRegWord(sc, 0xFC2E, 0x0BE9);
1835         MP_WriteMcuAccessRegWord(sc, 0xFC30, 0x02FD);
1836         MP_WriteMcuAccessRegWord(sc, 0xFC32, 0x0C25);
1837         MP_WriteMcuAccessRegWord(sc, 0xFC34, 0x00A9);
1838         MP_WriteMcuAccessRegWord(sc, 0xFC36, 0x012D);
1839 }
1840
1841 static void re_set_mac_mcu_8168ep_1(struct re_softc *sc)
1842 {
1843         DisableMcuBPs(sc);
1844
1845         MP_WriteMcuAccessRegWord(sc, 0xF800, 0xE008);
1846         MP_WriteMcuAccessRegWord(sc, 0xF802, 0xE0D3);
1847         MP_WriteMcuAccessRegWord(sc, 0xF804, 0xE0D6);
1848         MP_WriteMcuAccessRegWord(sc, 0xF806, 0xE0D9);
1849         MP_WriteMcuAccessRegWord(sc, 0xF808, 0xE0DB);
1850         MP_WriteMcuAccessRegWord(sc, 0xF80A, 0xE0DD);
1851         MP_WriteMcuAccessRegWord(sc, 0xF80C, 0xE0DF);
1852         MP_WriteMcuAccessRegWord(sc, 0xF80E, 0xE0E1);
1853         MP_WriteMcuAccessRegWord(sc, 0xF810, 0xC251);
1854         MP_WriteMcuAccessRegWord(sc, 0xF812, 0x7340);
1855         MP_WriteMcuAccessRegWord(sc, 0xF814, 0x49B1);
1856         MP_WriteMcuAccessRegWord(sc, 0xF816, 0xF010);
1857         MP_WriteMcuAccessRegWord(sc, 0xF818, 0x1D02);
1858         MP_WriteMcuAccessRegWord(sc, 0xF81A, 0x8D40);
1859         MP_WriteMcuAccessRegWord(sc, 0xF81C, 0xC202);
1860         MP_WriteMcuAccessRegWord(sc, 0xF81E, 0xBA00);
1861         MP_WriteMcuAccessRegWord(sc, 0xF820, 0x2C3A);
1862         MP_WriteMcuAccessRegWord(sc, 0xF822, 0xC0F0);
1863         MP_WriteMcuAccessRegWord(sc, 0xF824, 0xE8DE);
1864         MP_WriteMcuAccessRegWord(sc, 0xF826, 0x2000);
1865         MP_WriteMcuAccessRegWord(sc, 0xF828, 0x8000);
1866         MP_WriteMcuAccessRegWord(sc, 0xF82A, 0xC0B6);
1867         MP_WriteMcuAccessRegWord(sc, 0xF82C, 0x268C);
1868         MP_WriteMcuAccessRegWord(sc, 0xF82E, 0x752C);
1869         MP_WriteMcuAccessRegWord(sc, 0xF830, 0x49D4);
1870         MP_WriteMcuAccessRegWord(sc, 0xF832, 0xF112);
1871         MP_WriteMcuAccessRegWord(sc, 0xF834, 0xE025);
1872         MP_WriteMcuAccessRegWord(sc, 0xF836, 0xC2F6);
1873         MP_WriteMcuAccessRegWord(sc, 0xF838, 0x7146);
1874         MP_WriteMcuAccessRegWord(sc, 0xF83A, 0xC2F5);
1875         MP_WriteMcuAccessRegWord(sc, 0xF83C, 0x7340);
1876         MP_WriteMcuAccessRegWord(sc, 0xF83E, 0x49BE);
1877         MP_WriteMcuAccessRegWord(sc, 0xF840, 0xF103);
1878         MP_WriteMcuAccessRegWord(sc, 0xF842, 0xC7F2);
1879         MP_WriteMcuAccessRegWord(sc, 0xF844, 0xE002);
1880         MP_WriteMcuAccessRegWord(sc, 0xF846, 0xC7F1);
1881         MP_WriteMcuAccessRegWord(sc, 0xF848, 0x304F);
1882         MP_WriteMcuAccessRegWord(sc, 0xF84A, 0x6226);
1883         MP_WriteMcuAccessRegWord(sc, 0xF84C, 0x49A1);
1884         MP_WriteMcuAccessRegWord(sc, 0xF84E, 0xF1F0);
1885         MP_WriteMcuAccessRegWord(sc, 0xF850, 0x7222);
1886         MP_WriteMcuAccessRegWord(sc, 0xF852, 0x49A0);
1887         MP_WriteMcuAccessRegWord(sc, 0xF854, 0xF1ED);
1888         MP_WriteMcuAccessRegWord(sc, 0xF856, 0x2525);
1889         MP_WriteMcuAccessRegWord(sc, 0xF858, 0x1F28);
1890         MP_WriteMcuAccessRegWord(sc, 0xF85A, 0x3097);
1891         MP_WriteMcuAccessRegWord(sc, 0xF85C, 0x3091);
1892         MP_WriteMcuAccessRegWord(sc, 0xF85E, 0x9A36);
1893         MP_WriteMcuAccessRegWord(sc, 0xF860, 0x752C);
1894         MP_WriteMcuAccessRegWord(sc, 0xF862, 0x21DC);
1895         MP_WriteMcuAccessRegWord(sc, 0xF864, 0x25BC);
1896         MP_WriteMcuAccessRegWord(sc, 0xF866, 0xC6E2);
1897         MP_WriteMcuAccessRegWord(sc, 0xF868, 0x77C0);
1898         MP_WriteMcuAccessRegWord(sc, 0xF86A, 0x1304);
1899         MP_WriteMcuAccessRegWord(sc, 0xF86C, 0xF014);
1900         MP_WriteMcuAccessRegWord(sc, 0xF86E, 0x1303);
1901         MP_WriteMcuAccessRegWord(sc, 0xF870, 0xF014);
1902         MP_WriteMcuAccessRegWord(sc, 0xF872, 0x1302);
1903         MP_WriteMcuAccessRegWord(sc, 0xF874, 0xF014);
1904         MP_WriteMcuAccessRegWord(sc, 0xF876, 0x1301);
1905         MP_WriteMcuAccessRegWord(sc, 0xF878, 0xF014);
1906         MP_WriteMcuAccessRegWord(sc, 0xF87A, 0x49D4);
1907         MP_WriteMcuAccessRegWord(sc, 0xF87C, 0xF103);
1908         MP_WriteMcuAccessRegWord(sc, 0xF87E, 0xC3D7);
1909         MP_WriteMcuAccessRegWord(sc, 0xF880, 0xBB00);
1910         MP_WriteMcuAccessRegWord(sc, 0xF882, 0xC618);
1911         MP_WriteMcuAccessRegWord(sc, 0xF884, 0x67C6);
1912         MP_WriteMcuAccessRegWord(sc, 0xF886, 0x752E);
1913         MP_WriteMcuAccessRegWord(sc, 0xF888, 0x22D7);
1914         MP_WriteMcuAccessRegWord(sc, 0xF88A, 0x26DD);
1915         MP_WriteMcuAccessRegWord(sc, 0xF88C, 0x1505);
1916         MP_WriteMcuAccessRegWord(sc, 0xF88E, 0xF013);
1917         MP_WriteMcuAccessRegWord(sc, 0xF890, 0xC60A);
1918         MP_WriteMcuAccessRegWord(sc, 0xF892, 0xBE00);
1919         MP_WriteMcuAccessRegWord(sc, 0xF894, 0xC309);
1920         MP_WriteMcuAccessRegWord(sc, 0xF896, 0xBB00);
1921         MP_WriteMcuAccessRegWord(sc, 0xF898, 0xC308);
1922         MP_WriteMcuAccessRegWord(sc, 0xF89A, 0xBB00);
1923         MP_WriteMcuAccessRegWord(sc, 0xF89C, 0xC307);
1924         MP_WriteMcuAccessRegWord(sc, 0xF89E, 0xBB00);
1925         MP_WriteMcuAccessRegWord(sc, 0xF8A0, 0xC306);
1926         MP_WriteMcuAccessRegWord(sc, 0xF8A2, 0xBB00);
1927         MP_WriteMcuAccessRegWord(sc, 0xF8A4, 0x25C8);
1928         MP_WriteMcuAccessRegWord(sc, 0xF8A6, 0x25A6);
1929         MP_WriteMcuAccessRegWord(sc, 0xF8A8, 0x25AC);
1930         MP_WriteMcuAccessRegWord(sc, 0xF8AA, 0x25B2);
1931         MP_WriteMcuAccessRegWord(sc, 0xF8AC, 0x25B8);
1932         MP_WriteMcuAccessRegWord(sc, 0xF8AE, 0xCD08);
1933         MP_WriteMcuAccessRegWord(sc, 0xF8B0, 0x0000);
1934         MP_WriteMcuAccessRegWord(sc, 0xF8B2, 0xC0BC);
1935         MP_WriteMcuAccessRegWord(sc, 0xF8B4, 0xC2FF);
1936         MP_WriteMcuAccessRegWord(sc, 0xF8B6, 0x7340);
1937         MP_WriteMcuAccessRegWord(sc, 0xF8B8, 0x49B0);
1938         MP_WriteMcuAccessRegWord(sc, 0xF8BA, 0xF04E);
1939         MP_WriteMcuAccessRegWord(sc, 0xF8BC, 0x1F46);
1940         MP_WriteMcuAccessRegWord(sc, 0xF8BE, 0x308F);
1941         MP_WriteMcuAccessRegWord(sc, 0xF8C0, 0xC3F7);
1942         MP_WriteMcuAccessRegWord(sc, 0xF8C2, 0x1C04);
1943         MP_WriteMcuAccessRegWord(sc, 0xF8C4, 0xE84D);
1944         MP_WriteMcuAccessRegWord(sc, 0xF8C6, 0x1401);
1945         MP_WriteMcuAccessRegWord(sc, 0xF8C8, 0xF147);
1946         MP_WriteMcuAccessRegWord(sc, 0xF8CA, 0x7226);
1947         MP_WriteMcuAccessRegWord(sc, 0xF8CC, 0x49A7);
1948         MP_WriteMcuAccessRegWord(sc, 0xF8CE, 0xF044);
1949         MP_WriteMcuAccessRegWord(sc, 0xF8D0, 0x7222);
1950         MP_WriteMcuAccessRegWord(sc, 0xF8D2, 0x2525);
1951         MP_WriteMcuAccessRegWord(sc, 0xF8D4, 0x1F30);
1952         MP_WriteMcuAccessRegWord(sc, 0xF8D6, 0x3097);
1953         MP_WriteMcuAccessRegWord(sc, 0xF8D8, 0x3091);
1954         MP_WriteMcuAccessRegWord(sc, 0xF8DA, 0x7340);
1955         MP_WriteMcuAccessRegWord(sc, 0xF8DC, 0xC4EA);
1956         MP_WriteMcuAccessRegWord(sc, 0xF8DE, 0x401C);
1957         MP_WriteMcuAccessRegWord(sc, 0xF8E0, 0xF006);
1958         MP_WriteMcuAccessRegWord(sc, 0xF8E2, 0xC6E8);
1959         MP_WriteMcuAccessRegWord(sc, 0xF8E4, 0x75C0);
1960         MP_WriteMcuAccessRegWord(sc, 0xF8E6, 0x49D7);
1961         MP_WriteMcuAccessRegWord(sc, 0xF8E8, 0xF105);
1962         MP_WriteMcuAccessRegWord(sc, 0xF8EA, 0xE036);
1963         MP_WriteMcuAccessRegWord(sc, 0xF8EC, 0x1D08);
1964         MP_WriteMcuAccessRegWord(sc, 0xF8EE, 0x8DC1);
1965         MP_WriteMcuAccessRegWord(sc, 0xF8F0, 0x0208);
1966         MP_WriteMcuAccessRegWord(sc, 0xF8F2, 0x6640);
1967         MP_WriteMcuAccessRegWord(sc, 0xF8F4, 0x2764);
1968         MP_WriteMcuAccessRegWord(sc, 0xF8F6, 0x1606);
1969         MP_WriteMcuAccessRegWord(sc, 0xF8F8, 0xF12F);
1970         MP_WriteMcuAccessRegWord(sc, 0xF8FA, 0x6346);
1971         MP_WriteMcuAccessRegWord(sc, 0xF8FC, 0x133B);
1972         MP_WriteMcuAccessRegWord(sc, 0xF8FE, 0xF12C);
1973         MP_WriteMcuAccessRegWord(sc, 0xF900, 0x9B34);
1974         MP_WriteMcuAccessRegWord(sc, 0xF902, 0x1B18);
1975         MP_WriteMcuAccessRegWord(sc, 0xF904, 0x3093);
1976         MP_WriteMcuAccessRegWord(sc, 0xF906, 0xC32A);
1977         MP_WriteMcuAccessRegWord(sc, 0xF908, 0x1C10);
1978         MP_WriteMcuAccessRegWord(sc, 0xF90A, 0xE82A);
1979         MP_WriteMcuAccessRegWord(sc, 0xF90C, 0x1401);
1980         MP_WriteMcuAccessRegWord(sc, 0xF90E, 0xF124);
1981         MP_WriteMcuAccessRegWord(sc, 0xF910, 0x1A36);
1982         MP_WriteMcuAccessRegWord(sc, 0xF912, 0x308A);
1983         MP_WriteMcuAccessRegWord(sc, 0xF914, 0x7322);
1984         MP_WriteMcuAccessRegWord(sc, 0xF916, 0x25B5);
1985         MP_WriteMcuAccessRegWord(sc, 0xF918, 0x0B0E);
1986         MP_WriteMcuAccessRegWord(sc, 0xF91A, 0x1C00);
1987         MP_WriteMcuAccessRegWord(sc, 0xF91C, 0xE82C);
1988         MP_WriteMcuAccessRegWord(sc, 0xF91E, 0xC71F);
1989         MP_WriteMcuAccessRegWord(sc, 0xF920, 0x4027);
1990         MP_WriteMcuAccessRegWord(sc, 0xF922, 0xF11A);
1991         MP_WriteMcuAccessRegWord(sc, 0xF924, 0xE838);
1992         MP_WriteMcuAccessRegWord(sc, 0xF926, 0x1F42);
1993         MP_WriteMcuAccessRegWord(sc, 0xF928, 0x308F);
1994         MP_WriteMcuAccessRegWord(sc, 0xF92A, 0x1B08);
1995         MP_WriteMcuAccessRegWord(sc, 0xF92C, 0xE824);
1996         MP_WriteMcuAccessRegWord(sc, 0xF92E, 0x7236);
1997         MP_WriteMcuAccessRegWord(sc, 0xF930, 0x7746);
1998         MP_WriteMcuAccessRegWord(sc, 0xF932, 0x1700);
1999         MP_WriteMcuAccessRegWord(sc, 0xF934, 0xF00D);
2000         MP_WriteMcuAccessRegWord(sc, 0xF936, 0xC313);
2001         MP_WriteMcuAccessRegWord(sc, 0xF938, 0x401F);
2002         MP_WriteMcuAccessRegWord(sc, 0xF93A, 0xF103);
2003         MP_WriteMcuAccessRegWord(sc, 0xF93C, 0x1F00);
2004         MP_WriteMcuAccessRegWord(sc, 0xF93E, 0x9F46);
2005         MP_WriteMcuAccessRegWord(sc, 0xF940, 0x7744);
2006         MP_WriteMcuAccessRegWord(sc, 0xF942, 0x449F);
2007         MP_WriteMcuAccessRegWord(sc, 0xF944, 0x445F);
2008         MP_WriteMcuAccessRegWord(sc, 0xF946, 0xE817);
2009         MP_WriteMcuAccessRegWord(sc, 0xF948, 0xC70A);
2010         MP_WriteMcuAccessRegWord(sc, 0xF94A, 0x4027);
2011         MP_WriteMcuAccessRegWord(sc, 0xF94C, 0xF105);
2012         MP_WriteMcuAccessRegWord(sc, 0xF94E, 0xC302);
2013         MP_WriteMcuAccessRegWord(sc, 0xF950, 0xBB00);
2014         MP_WriteMcuAccessRegWord(sc, 0xF952, 0x2E08);
2015         MP_WriteMcuAccessRegWord(sc, 0xF954, 0x2DC2);
2016         MP_WriteMcuAccessRegWord(sc, 0xF956, 0xC7FF);
2017         MP_WriteMcuAccessRegWord(sc, 0xF958, 0xBF00);
2018         MP_WriteMcuAccessRegWord(sc, 0xF95A, 0xCDB8);
2019         MP_WriteMcuAccessRegWord(sc, 0xF95C, 0xFFFF);
2020         MP_WriteMcuAccessRegWord(sc, 0xF95E, 0x0C02);
2021         MP_WriteMcuAccessRegWord(sc, 0xF960, 0xA554);
2022         MP_WriteMcuAccessRegWord(sc, 0xF962, 0xA5DC);
2023         MP_WriteMcuAccessRegWord(sc, 0xF964, 0x402F);
2024         MP_WriteMcuAccessRegWord(sc, 0xF966, 0xF105);
2025         MP_WriteMcuAccessRegWord(sc, 0xF968, 0x1400);
2026         MP_WriteMcuAccessRegWord(sc, 0xF96A, 0xF1FA);
2027         MP_WriteMcuAccessRegWord(sc, 0xF96C, 0x1C01);
2028         MP_WriteMcuAccessRegWord(sc, 0xF96E, 0xE002);
2029         MP_WriteMcuAccessRegWord(sc, 0xF970, 0x1C00);
2030         MP_WriteMcuAccessRegWord(sc, 0xF972, 0xFF80);
2031         MP_WriteMcuAccessRegWord(sc, 0xF974, 0x49B0);
2032         MP_WriteMcuAccessRegWord(sc, 0xF976, 0xF004);
2033         MP_WriteMcuAccessRegWord(sc, 0xF978, 0x0B01);
2034         MP_WriteMcuAccessRegWord(sc, 0xF97A, 0xA1D3);
2035         MP_WriteMcuAccessRegWord(sc, 0xF97C, 0xE003);
2036         MP_WriteMcuAccessRegWord(sc, 0xF97E, 0x0B02);
2037         MP_WriteMcuAccessRegWord(sc, 0xF980, 0xA5D3);
2038         MP_WriteMcuAccessRegWord(sc, 0xF982, 0x3127);
2039         MP_WriteMcuAccessRegWord(sc, 0xF984, 0x3720);
2040         MP_WriteMcuAccessRegWord(sc, 0xF986, 0x0B02);
2041         MP_WriteMcuAccessRegWord(sc, 0xF988, 0xA5D3);
2042         MP_WriteMcuAccessRegWord(sc, 0xF98A, 0x3127);
2043         MP_WriteMcuAccessRegWord(sc, 0xF98C, 0x3720);
2044         MP_WriteMcuAccessRegWord(sc, 0xF98E, 0x1300);
2045         MP_WriteMcuAccessRegWord(sc, 0xF990, 0xF1FB);
2046         MP_WriteMcuAccessRegWord(sc, 0xF992, 0xFF80);
2047         MP_WriteMcuAccessRegWord(sc, 0xF994, 0x7322);
2048         MP_WriteMcuAccessRegWord(sc, 0xF996, 0x25B5);
2049         MP_WriteMcuAccessRegWord(sc, 0xF998, 0x1E28);
2050         MP_WriteMcuAccessRegWord(sc, 0xF99A, 0x30DE);
2051         MP_WriteMcuAccessRegWord(sc, 0xF99C, 0x30D9);
2052         MP_WriteMcuAccessRegWord(sc, 0xF99E, 0x7264);
2053         MP_WriteMcuAccessRegWord(sc, 0xF9A0, 0x1E11);
2054         MP_WriteMcuAccessRegWord(sc, 0xF9A2, 0x2368);
2055         MP_WriteMcuAccessRegWord(sc, 0xF9A4, 0x3116);
2056         MP_WriteMcuAccessRegWord(sc, 0xF9A6, 0xFF80);
2057         MP_WriteMcuAccessRegWord(sc, 0xF9A8, 0x1B7E);
2058         MP_WriteMcuAccessRegWord(sc, 0xF9AA, 0xC602);
2059         MP_WriteMcuAccessRegWord(sc, 0xF9AC, 0xBE00);
2060         MP_WriteMcuAccessRegWord(sc, 0xF9AE, 0x06A6);
2061         MP_WriteMcuAccessRegWord(sc, 0xF9B0, 0x1B7E);
2062         MP_WriteMcuAccessRegWord(sc, 0xF9B2, 0xC602);
2063         MP_WriteMcuAccessRegWord(sc, 0xF9B4, 0xBE00);
2064         MP_WriteMcuAccessRegWord(sc, 0xF9B6, 0x0764);
2065         MP_WriteMcuAccessRegWord(sc, 0xF9B8, 0xC602);
2066         MP_WriteMcuAccessRegWord(sc, 0xF9BA, 0xBE00);
2067         MP_WriteMcuAccessRegWord(sc, 0xF9BC, 0x0000);
2068         MP_WriteMcuAccessRegWord(sc, 0xF9BE, 0xC602);
2069         MP_WriteMcuAccessRegWord(sc, 0xF9C0, 0xBE00);
2070         MP_WriteMcuAccessRegWord(sc, 0xF9C2, 0x0000);
2071         MP_WriteMcuAccessRegWord(sc, 0xF9C4, 0xC602);
2072         MP_WriteMcuAccessRegWord(sc, 0xF9C6, 0xBE00);
2073         MP_WriteMcuAccessRegWord(sc, 0xF9C8, 0x0000);
2074         MP_WriteMcuAccessRegWord(sc, 0xF9CA, 0xC602);
2075         MP_WriteMcuAccessRegWord(sc, 0xF9CC, 0xBE00);
2076         MP_WriteMcuAccessRegWord(sc, 0xF9CE, 0x0000);
2077         MP_WriteMcuAccessRegWord(sc, 0xF9D0, 0xC602);
2078         MP_WriteMcuAccessRegWord(sc, 0xF9D2, 0xBE00);
2079         MP_WriteMcuAccessRegWord(sc, 0xF9D4, 0x0000);
2080
2081         MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000);
2082
2083         MP_WriteMcuAccessRegWord(sc, 0xFC28, 0x2549);
2084         MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x06A5);
2085         MP_WriteMcuAccessRegWord(sc, 0xFC2C, 0x0763);
2086 }
2087
2088 static void re_set_mac_mcu_8168ep_2(struct re_softc *sc)
2089 {
2090         DisableMcuBPs(sc);
2091
2092         MP_WriteMcuAccessRegWord(sc, 0xF800, 0xE008);
2093         MP_WriteMcuAccessRegWord(sc, 0xF802, 0xE017);
2094         MP_WriteMcuAccessRegWord(sc, 0xF804, 0xE019);
2095         MP_WriteMcuAccessRegWord(sc, 0xF806, 0xE01B);
2096         MP_WriteMcuAccessRegWord(sc, 0xF808, 0xE01D);
2097         MP_WriteMcuAccessRegWord(sc, 0xF80A, 0xE01F);
2098         MP_WriteMcuAccessRegWord(sc, 0xF80C, 0xE021);
2099         MP_WriteMcuAccessRegWord(sc, 0xF80E, 0xE023);
2100         MP_WriteMcuAccessRegWord(sc, 0xF810, 0xC50F);
2101         MP_WriteMcuAccessRegWord(sc, 0xF812, 0x76A4);
2102         MP_WriteMcuAccessRegWord(sc, 0xF814, 0x49E3);
2103         MP_WriteMcuAccessRegWord(sc, 0xF816, 0xF007);
2104         MP_WriteMcuAccessRegWord(sc, 0xF818, 0x49C0);
2105         MP_WriteMcuAccessRegWord(sc, 0xF81A, 0xF103);
2106         MP_WriteMcuAccessRegWord(sc, 0xF81C, 0xC607);
2107         MP_WriteMcuAccessRegWord(sc, 0xF81E, 0xBE00);
2108         MP_WriteMcuAccessRegWord(sc, 0xF820, 0xC606);
2109         MP_WriteMcuAccessRegWord(sc, 0xF822, 0xBE00);
2110         MP_WriteMcuAccessRegWord(sc, 0xF824, 0xC602);
2111         MP_WriteMcuAccessRegWord(sc, 0xF826, 0xBE00);
2112         MP_WriteMcuAccessRegWord(sc, 0xF828, 0x0BDA);
2113         MP_WriteMcuAccessRegWord(sc, 0xF82A, 0x0BB0);
2114         MP_WriteMcuAccessRegWord(sc, 0xF82C, 0x0BBA);
2115         MP_WriteMcuAccessRegWord(sc, 0xF82E, 0xDC00);
2116         MP_WriteMcuAccessRegWord(sc, 0xF830, 0xC602);
2117         MP_WriteMcuAccessRegWord(sc, 0xF832, 0xBE00);
2118         MP_WriteMcuAccessRegWord(sc, 0xF834, 0x0000);
2119         MP_WriteMcuAccessRegWord(sc, 0xF836, 0xC602);
2120         MP_WriteMcuAccessRegWord(sc, 0xF838, 0xBE00);
2121         MP_WriteMcuAccessRegWord(sc, 0xF83A, 0x0000);
2122         MP_WriteMcuAccessRegWord(sc, 0xF83C, 0xC602);
2123         MP_WriteMcuAccessRegWord(sc, 0xF83E, 0xBE00);
2124         MP_WriteMcuAccessRegWord(sc, 0xF840, 0x0000);
2125         MP_WriteMcuAccessRegWord(sc, 0xF842, 0xC602);
2126         MP_WriteMcuAccessRegWord(sc, 0xF844, 0xBE00);
2127         MP_WriteMcuAccessRegWord(sc, 0xF846, 0x0000);
2128         MP_WriteMcuAccessRegWord(sc, 0xF848, 0xC602);
2129         MP_WriteMcuAccessRegWord(sc, 0xF84A, 0xBE00);
2130         MP_WriteMcuAccessRegWord(sc, 0xF84C, 0x0000);
2131         MP_WriteMcuAccessRegWord(sc, 0xF84E, 0xC602);
2132         MP_WriteMcuAccessRegWord(sc, 0xF850, 0xBE00);
2133         MP_WriteMcuAccessRegWord(sc, 0xF852, 0x0000);
2134         MP_WriteMcuAccessRegWord(sc, 0xF854, 0xC602);
2135         MP_WriteMcuAccessRegWord(sc, 0xF856, 0xBE00);
2136         MP_WriteMcuAccessRegWord(sc, 0xF858, 0x0000);
2137
2138         MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000);
2139
2140         MP_WriteMcuAccessRegWord(sc, 0xFC28, 0x0BB3);
2141 }
2142
2143 static void re_set_mac_mcu_8168h_1(struct re_softc *sc)
2144 {
2145         DisableMcuBPs(sc);
2146
2147         MP_WriteMcuAccessRegWord(sc, 0xF800, 0xE008);
2148         MP_WriteMcuAccessRegWord(sc, 0xF802, 0xE00F);
2149         MP_WriteMcuAccessRegWord(sc, 0xF804, 0xE011);
2150         MP_WriteMcuAccessRegWord(sc, 0xF806, 0xE047);
2151         MP_WriteMcuAccessRegWord(sc, 0xF808, 0xE049);
2152         MP_WriteMcuAccessRegWord(sc, 0xF80A, 0xE073);
2153         MP_WriteMcuAccessRegWord(sc, 0xF80C, 0xE075);
2154         MP_WriteMcuAccessRegWord(sc, 0xF80E, 0xE077);
2155         MP_WriteMcuAccessRegWord(sc, 0xF810, 0xC707);
2156         MP_WriteMcuAccessRegWord(sc, 0xF812, 0x1D00);
2157         MP_WriteMcuAccessRegWord(sc, 0xF814, 0x8DE2);
2158         MP_WriteMcuAccessRegWord(sc, 0xF816, 0x48C1);
2159         MP_WriteMcuAccessRegWord(sc, 0xF818, 0xC502);
2160         MP_WriteMcuAccessRegWord(sc, 0xF81A, 0xBD00);
2161         MP_WriteMcuAccessRegWord(sc, 0xF81C, 0x00E4);
2162         MP_WriteMcuAccessRegWord(sc, 0xF81E, 0xE0C0);
2163         MP_WriteMcuAccessRegWord(sc, 0xF820, 0xC502);
2164         MP_WriteMcuAccessRegWord(sc, 0xF822, 0xBD00);
2165         MP_WriteMcuAccessRegWord(sc, 0xF824, 0x0216);
2166         MP_WriteMcuAccessRegWord(sc, 0xF826, 0xC634);
2167         MP_WriteMcuAccessRegWord(sc, 0xF828, 0x75C0);
2168         MP_WriteMcuAccessRegWord(sc, 0xF82A, 0x49D3);
2169         MP_WriteMcuAccessRegWord(sc, 0xF82C, 0xF027);
2170         MP_WriteMcuAccessRegWord(sc, 0xF82E, 0xC631);
2171         MP_WriteMcuAccessRegWord(sc, 0xF830, 0x75C0);
2172         MP_WriteMcuAccessRegWord(sc, 0xF832, 0x49D3);
2173         MP_WriteMcuAccessRegWord(sc, 0xF834, 0xF123);
2174         MP_WriteMcuAccessRegWord(sc, 0xF836, 0xC627);
2175         MP_WriteMcuAccessRegWord(sc, 0xF838, 0x75C0);
2176         MP_WriteMcuAccessRegWord(sc, 0xF83A, 0xB405);
2177         MP_WriteMcuAccessRegWord(sc, 0xF83C, 0xC525);
2178         MP_WriteMcuAccessRegWord(sc, 0xF83E, 0x9DC0);
2179         MP_WriteMcuAccessRegWord(sc, 0xF840, 0xC621);
2180         MP_WriteMcuAccessRegWord(sc, 0xF842, 0x75C8);
2181         MP_WriteMcuAccessRegWord(sc, 0xF844, 0x49D5);
2182         MP_WriteMcuAccessRegWord(sc, 0xF846, 0xF00A);
2183         MP_WriteMcuAccessRegWord(sc, 0xF848, 0x49D6);
2184         MP_WriteMcuAccessRegWord(sc, 0xF84A, 0xF008);
2185         MP_WriteMcuAccessRegWord(sc, 0xF84C, 0x49D7);
2186         MP_WriteMcuAccessRegWord(sc, 0xF84E, 0xF006);
2187         MP_WriteMcuAccessRegWord(sc, 0xF850, 0x49D8);
2188         MP_WriteMcuAccessRegWord(sc, 0xF852, 0xF004);
2189         MP_WriteMcuAccessRegWord(sc, 0xF854, 0x75D2);
2190         MP_WriteMcuAccessRegWord(sc, 0xF856, 0x49D9);
2191         MP_WriteMcuAccessRegWord(sc, 0xF858, 0xF111);
2192         MP_WriteMcuAccessRegWord(sc, 0xF85A, 0xC517);
2193         MP_WriteMcuAccessRegWord(sc, 0xF85C, 0x9DC8);
2194         MP_WriteMcuAccessRegWord(sc, 0xF85E, 0xC516);
2195         MP_WriteMcuAccessRegWord(sc, 0xF860, 0x9DD2);
2196         MP_WriteMcuAccessRegWord(sc, 0xF862, 0xC618);
2197         MP_WriteMcuAccessRegWord(sc, 0xF864, 0x75C0);
2198         MP_WriteMcuAccessRegWord(sc, 0xF866, 0x49D4);
2199         MP_WriteMcuAccessRegWord(sc, 0xF868, 0xF003);
2200         MP_WriteMcuAccessRegWord(sc, 0xF86A, 0x49D0);
2201         MP_WriteMcuAccessRegWord(sc, 0xF86C, 0xF104);
2202         MP_WriteMcuAccessRegWord(sc, 0xF86E, 0xC60A);
2203         MP_WriteMcuAccessRegWord(sc, 0xF870, 0xC50E);
2204         MP_WriteMcuAccessRegWord(sc, 0xF872, 0x9DC0);
2205         MP_WriteMcuAccessRegWord(sc, 0xF874, 0xB005);
2206         MP_WriteMcuAccessRegWord(sc, 0xF876, 0xC607);
2207         MP_WriteMcuAccessRegWord(sc, 0xF878, 0x9DC0);
2208         MP_WriteMcuAccessRegWord(sc, 0xF87A, 0xB007);
2209         MP_WriteMcuAccessRegWord(sc, 0xF87C, 0xC602);
2210         MP_WriteMcuAccessRegWord(sc, 0xF87E, 0xBE00);
2211         MP_WriteMcuAccessRegWord(sc, 0xF880, 0x1A06);
2212         MP_WriteMcuAccessRegWord(sc, 0xF882, 0xB400);
2213         MP_WriteMcuAccessRegWord(sc, 0xF884, 0xE86C);
2214         MP_WriteMcuAccessRegWord(sc, 0xF886, 0xA000);
2215         MP_WriteMcuAccessRegWord(sc, 0xF888, 0x01E1);
2216         MP_WriteMcuAccessRegWord(sc, 0xF88A, 0x0200);
2217         MP_WriteMcuAccessRegWord(sc, 0xF88C, 0x9200);
2218         MP_WriteMcuAccessRegWord(sc, 0xF88E, 0xE84C);
2219         MP_WriteMcuAccessRegWord(sc, 0xF890, 0xE004);
2220         MP_WriteMcuAccessRegWord(sc, 0xF892, 0xE908);
2221         MP_WriteMcuAccessRegWord(sc, 0xF894, 0xC502);
2222         MP_WriteMcuAccessRegWord(sc, 0xF896, 0xBD00);
2223         MP_WriteMcuAccessRegWord(sc, 0xF898, 0x0B58);
2224         MP_WriteMcuAccessRegWord(sc, 0xF89A, 0xB407);
2225         MP_WriteMcuAccessRegWord(sc, 0xF89C, 0xB404);
2226         MP_WriteMcuAccessRegWord(sc, 0xF89E, 0x2195);
2227         MP_WriteMcuAccessRegWord(sc, 0xF8A0, 0x25BD);
2228         MP_WriteMcuAccessRegWord(sc, 0xF8A2, 0x9BE0);
2229         MP_WriteMcuAccessRegWord(sc, 0xF8A4, 0x1C1C);
2230         MP_WriteMcuAccessRegWord(sc, 0xF8A6, 0x484F);
2231         MP_WriteMcuAccessRegWord(sc, 0xF8A8, 0x9CE2);
2232         MP_WriteMcuAccessRegWord(sc, 0xF8AA, 0x72E2);
2233         MP_WriteMcuAccessRegWord(sc, 0xF8AC, 0x49AE);
2234         MP_WriteMcuAccessRegWord(sc, 0xF8AE, 0xF1FE);
2235         MP_WriteMcuAccessRegWord(sc, 0xF8B0, 0x0B00);
2236         MP_WriteMcuAccessRegWord(sc, 0xF8B2, 0xF116);
2237         MP_WriteMcuAccessRegWord(sc, 0xF8B4, 0xC71C);
2238         MP_WriteMcuAccessRegWord(sc, 0xF8B6, 0xC419);
2239         MP_WriteMcuAccessRegWord(sc, 0xF8B8, 0x9CE0);
2240         MP_WriteMcuAccessRegWord(sc, 0xF8BA, 0x1C13);
2241         MP_WriteMcuAccessRegWord(sc, 0xF8BC, 0x484F);
2242         MP_WriteMcuAccessRegWord(sc, 0xF8BE, 0x9CE2);
2243         MP_WriteMcuAccessRegWord(sc, 0xF8C0, 0x74E2);
2244         MP_WriteMcuAccessRegWord(sc, 0xF8C2, 0x49CE);
2245         MP_WriteMcuAccessRegWord(sc, 0xF8C4, 0xF1FE);
2246         MP_WriteMcuAccessRegWord(sc, 0xF8C6, 0xC412);
2247         MP_WriteMcuAccessRegWord(sc, 0xF8C8, 0x9CE0);
2248         MP_WriteMcuAccessRegWord(sc, 0xF8CA, 0x1C13);
2249         MP_WriteMcuAccessRegWord(sc, 0xF8CC, 0x484F);
2250         MP_WriteMcuAccessRegWord(sc, 0xF8CE, 0x9CE2);
2251         MP_WriteMcuAccessRegWord(sc, 0xF8D0, 0x74E2);
2252         MP_WriteMcuAccessRegWord(sc, 0xF8D2, 0x49CE);
2253         MP_WriteMcuAccessRegWord(sc, 0xF8D4, 0xF1FE);
2254         MP_WriteMcuAccessRegWord(sc, 0xF8D6, 0xC70C);
2255         MP_WriteMcuAccessRegWord(sc, 0xF8D8, 0x74F8);
2256         MP_WriteMcuAccessRegWord(sc, 0xF8DA, 0x48C3);
2257         MP_WriteMcuAccessRegWord(sc, 0xF8DC, 0x8CF8);
2258         MP_WriteMcuAccessRegWord(sc, 0xF8DE, 0xB004);
2259         MP_WriteMcuAccessRegWord(sc, 0xF8E0, 0xB007);
2260         MP_WriteMcuAccessRegWord(sc, 0xF8E2, 0xC502);
2261         MP_WriteMcuAccessRegWord(sc, 0xF8E4, 0xBD00);
2262         MP_WriteMcuAccessRegWord(sc, 0xF8E6, 0x0F24);
2263         MP_WriteMcuAccessRegWord(sc, 0xF8E8, 0x0481);
2264         MP_WriteMcuAccessRegWord(sc, 0xF8EA, 0x0C81);
2265         MP_WriteMcuAccessRegWord(sc, 0xF8EC, 0xDE24);
2266         MP_WriteMcuAccessRegWord(sc, 0xF8EE, 0xE000);
2267         MP_WriteMcuAccessRegWord(sc, 0xF8F0, 0xC602);
2268         MP_WriteMcuAccessRegWord(sc, 0xF8F2, 0xBE00);
2269         MP_WriteMcuAccessRegWord(sc, 0xF8F4, 0x0CA4);
2270         MP_WriteMcuAccessRegWord(sc, 0xF8F6, 0xC502);
2271         MP_WriteMcuAccessRegWord(sc, 0xF8F8, 0xBD00);
2272         MP_WriteMcuAccessRegWord(sc, 0xF8FA, 0x0000);
2273         MP_WriteMcuAccessRegWord(sc, 0xF8FC, 0xC602);
2274         MP_WriteMcuAccessRegWord(sc, 0xF8FE, 0xBE00);
2275         MP_WriteMcuAccessRegWord(sc, 0xF900, 0x0000);
2276
2277         MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000);
2278
2279         MP_WriteMcuAccessRegWord(sc, 0xFC28, 0x00E2);
2280         MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x0210);
2281         MP_WriteMcuAccessRegWord(sc, 0xFC2C, 0x1A04);
2282         MP_WriteMcuAccessRegWord(sc, 0xFC2E, 0x0B26);
2283         MP_WriteMcuAccessRegWord(sc, 0xFC30, 0x0F02);
2284         MP_WriteMcuAccessRegWord(sc, 0xFC32, 0x0CA0);
2285
2286         if (sc->re_device_id == RT_DEVICEID_8136)
2287                 MP_WriteMcuAccessRegWord(sc, 0xFC38, 0x0033);
2288         else
2289                 MP_WriteMcuAccessRegWord(sc, 0xFC38, 0x003F);
2290 }
2291
2292 static void re_set_mac_mcu_8168fp_1(struct re_softc *sc)
2293 {
2294         DisableMcuBPs(sc);
2295
2296         MP_WriteMcuAccessRegWord(sc, 0xF800, 0xE00A);
2297         MP_WriteMcuAccessRegWord(sc, 0xF802, 0xE0C1);
2298         MP_WriteMcuAccessRegWord(sc, 0xF804, 0xE104);
2299         MP_WriteMcuAccessRegWord(sc, 0xF806, 0xE108);
2300         MP_WriteMcuAccessRegWord(sc, 0xF808, 0xE10D);
2301         MP_WriteMcuAccessRegWord(sc, 0xF80A, 0xE112);
2302         MP_WriteMcuAccessRegWord(sc, 0xF80C, 0xE11C);
2303         MP_WriteMcuAccessRegWord(sc, 0xF80E, 0xE121);
2304         MP_WriteMcuAccessRegWord(sc, 0xF810, 0xE000);
2305         MP_WriteMcuAccessRegWord(sc, 0xF812, 0xE0C8);
2306         MP_WriteMcuAccessRegWord(sc, 0xF814, 0xB400);
2307         MP_WriteMcuAccessRegWord(sc, 0xF816, 0xC1FE);
2308         MP_WriteMcuAccessRegWord(sc, 0xF818, 0x49E2);
2309         MP_WriteMcuAccessRegWord(sc, 0xF81A, 0xF04C);
2310         MP_WriteMcuAccessRegWord(sc, 0xF81C, 0x49EA);
2311         MP_WriteMcuAccessRegWord(sc, 0xF81E, 0xF04A);
2312         MP_WriteMcuAccessRegWord(sc, 0xF820, 0x74E6);
2313         MP_WriteMcuAccessRegWord(sc, 0xF822, 0xC246);
2314         MP_WriteMcuAccessRegWord(sc, 0xF824, 0x7542);
2315         MP_WriteMcuAccessRegWord(sc, 0xF826, 0x73EC);
2316         MP_WriteMcuAccessRegWord(sc, 0xF828, 0x1800);
2317         MP_WriteMcuAccessRegWord(sc, 0xF82A, 0x49C0);
2318         MP_WriteMcuAccessRegWord(sc, 0xF82C, 0xF10D);
2319         MP_WriteMcuAccessRegWord(sc, 0xF82E, 0x49C1);
2320         MP_WriteMcuAccessRegWord(sc, 0xF830, 0xF10B);
2321         MP_WriteMcuAccessRegWord(sc, 0xF832, 0x49C2);
2322         MP_WriteMcuAccessRegWord(sc, 0xF834, 0xF109);
2323         MP_WriteMcuAccessRegWord(sc, 0xF836, 0x49B0);
2324         MP_WriteMcuAccessRegWord(sc, 0xF838, 0xF107);
2325         MP_WriteMcuAccessRegWord(sc, 0xF83A, 0x49B1);
2326         MP_WriteMcuAccessRegWord(sc, 0xF83C, 0xF105);
2327         MP_WriteMcuAccessRegWord(sc, 0xF83E, 0x7220);
2328         MP_WriteMcuAccessRegWord(sc, 0xF840, 0x49A2);
2329         MP_WriteMcuAccessRegWord(sc, 0xF842, 0xF102);
2330         MP_WriteMcuAccessRegWord(sc, 0xF844, 0xE002);
2331         MP_WriteMcuAccessRegWord(sc, 0xF846, 0x4800);
2332         MP_WriteMcuAccessRegWord(sc, 0xF848, 0x49D0);
2333         MP_WriteMcuAccessRegWord(sc, 0xF84A, 0xF10A);
2334         MP_WriteMcuAccessRegWord(sc, 0xF84C, 0x49D1);
2335         MP_WriteMcuAccessRegWord(sc, 0xF84E, 0xF108);
2336         MP_WriteMcuAccessRegWord(sc, 0xF850, 0x49D2);
2337         MP_WriteMcuAccessRegWord(sc, 0xF852, 0xF106);
2338         MP_WriteMcuAccessRegWord(sc, 0xF854, 0x49D3);
2339         MP_WriteMcuAccessRegWord(sc, 0xF856, 0xF104);
2340         MP_WriteMcuAccessRegWord(sc, 0xF858, 0x49DF);
2341         MP_WriteMcuAccessRegWord(sc, 0xF85A, 0xF102);
2342         MP_WriteMcuAccessRegWord(sc, 0xF85C, 0xE00C);
2343         MP_WriteMcuAccessRegWord(sc, 0xF85E, 0x4801);
2344         MP_WriteMcuAccessRegWord(sc, 0xF860, 0x72E4);
2345         MP_WriteMcuAccessRegWord(sc, 0xF862, 0x49AD);
2346         MP_WriteMcuAccessRegWord(sc, 0xF864, 0xF108);
2347         MP_WriteMcuAccessRegWord(sc, 0xF866, 0xC225);
2348         MP_WriteMcuAccessRegWord(sc, 0xF868, 0x6741);
2349         MP_WriteMcuAccessRegWord(sc, 0xF86A, 0x48F0);
2350         MP_WriteMcuAccessRegWord(sc, 0xF86C, 0x8F41);
2351         MP_WriteMcuAccessRegWord(sc, 0xF86E, 0x4870);
2352         MP_WriteMcuAccessRegWord(sc, 0xF870, 0x8F41);
2353         MP_WriteMcuAccessRegWord(sc, 0xF872, 0xC7CF);
2354         MP_WriteMcuAccessRegWord(sc, 0xF874, 0x49B5);
2355         MP_WriteMcuAccessRegWord(sc, 0xF876, 0xF01F);
2356         MP_WriteMcuAccessRegWord(sc, 0xF878, 0x49B2);
2357         MP_WriteMcuAccessRegWord(sc, 0xF87A, 0xF00B);
2358         MP_WriteMcuAccessRegWord(sc, 0xF87C, 0x4980);
2359         MP_WriteMcuAccessRegWord(sc, 0xF87E, 0xF003);
2360         MP_WriteMcuAccessRegWord(sc, 0xF880, 0x484E);
2361         MP_WriteMcuAccessRegWord(sc, 0xF882, 0x94E7);
2362         MP_WriteMcuAccessRegWord(sc, 0xF884, 0x4981);
2363         MP_WriteMcuAccessRegWord(sc, 0xF886, 0xF004);
2364         MP_WriteMcuAccessRegWord(sc, 0xF888, 0x485E);
2365         MP_WriteMcuAccessRegWord(sc, 0xF88A, 0xC212);
2366         MP_WriteMcuAccessRegWord(sc, 0xF88C, 0x9543);
2367         MP_WriteMcuAccessRegWord(sc, 0xF88E, 0xE071);
2368         MP_WriteMcuAccessRegWord(sc, 0xF890, 0x49B6);
2369         MP_WriteMcuAccessRegWord(sc, 0xF892, 0xF003);
2370         MP_WriteMcuAccessRegWord(sc, 0xF894, 0x49B3);
2371         MP_WriteMcuAccessRegWord(sc, 0xF896, 0xF10F);
2372         MP_WriteMcuAccessRegWord(sc, 0xF898, 0x4980);
2373         MP_WriteMcuAccessRegWord(sc, 0xF89A, 0xF003);
2374         MP_WriteMcuAccessRegWord(sc, 0xF89C, 0x484E);
2375         MP_WriteMcuAccessRegWord(sc, 0xF89E, 0x94E7);
2376         MP_WriteMcuAccessRegWord(sc, 0xF8A0, 0x4981);
2377         MP_WriteMcuAccessRegWord(sc, 0xF8A2, 0xF004);
2378         MP_WriteMcuAccessRegWord(sc, 0xF8A4, 0x485E);
2379         MP_WriteMcuAccessRegWord(sc, 0xF8A6, 0xC204);
2380         MP_WriteMcuAccessRegWord(sc, 0xF8A8, 0x9543);
2381         MP_WriteMcuAccessRegWord(sc, 0xF8AA, 0xE005);
2382         MP_WriteMcuAccessRegWord(sc, 0xF8AC, 0xE000);
2383         MP_WriteMcuAccessRegWord(sc, 0xF8AE, 0xE0FC);
2384         MP_WriteMcuAccessRegWord(sc, 0xF8B0, 0xE0FA);
2385         MP_WriteMcuAccessRegWord(sc, 0xF8B2, 0xE065);
2386         MP_WriteMcuAccessRegWord(sc, 0xF8B4, 0x49B7);
2387         MP_WriteMcuAccessRegWord(sc, 0xF8B6, 0xF007);
2388         MP_WriteMcuAccessRegWord(sc, 0xF8B8, 0x4980);
2389         MP_WriteMcuAccessRegWord(sc, 0xF8BA, 0xF005);
2390         MP_WriteMcuAccessRegWord(sc, 0xF8BC, 0x1A38);
2391         MP_WriteMcuAccessRegWord(sc, 0xF8BE, 0x46D4);
2392         MP_WriteMcuAccessRegWord(sc, 0xF8C0, 0x1200);
2393         MP_WriteMcuAccessRegWord(sc, 0xF8C2, 0xF109);
2394         MP_WriteMcuAccessRegWord(sc, 0xF8C4, 0x4981);
2395         MP_WriteMcuAccessRegWord(sc, 0xF8C6, 0xF055);
2396         MP_WriteMcuAccessRegWord(sc, 0xF8C8, 0x49C3);
2397         MP_WriteMcuAccessRegWord(sc, 0xF8CA, 0xF105);
2398         MP_WriteMcuAccessRegWord(sc, 0xF8CC, 0x1A30);
2399         MP_WriteMcuAccessRegWord(sc, 0xF8CE, 0x46D5);
2400         MP_WriteMcuAccessRegWord(sc, 0xF8D0, 0x1200);
2401         MP_WriteMcuAccessRegWord(sc, 0xF8D2, 0xF04F);
2402         MP_WriteMcuAccessRegWord(sc, 0xF8D4, 0x7220);
2403         MP_WriteMcuAccessRegWord(sc, 0xF8D6, 0x49A2);
2404         MP_WriteMcuAccessRegWord(sc, 0xF8D8, 0xF130);
2405         MP_WriteMcuAccessRegWord(sc, 0xF8DA, 0x49C1);
2406         MP_WriteMcuAccessRegWord(sc, 0xF8DC, 0xF12E);
2407         MP_WriteMcuAccessRegWord(sc, 0xF8DE, 0x49B0);
2408         MP_WriteMcuAccessRegWord(sc, 0xF8E0, 0xF12C);
2409         MP_WriteMcuAccessRegWord(sc, 0xF8E2, 0xC2E6);
2410         MP_WriteMcuAccessRegWord(sc, 0xF8E4, 0x7240);
2411         MP_WriteMcuAccessRegWord(sc, 0xF8E6, 0x49A8);
2412         MP_WriteMcuAccessRegWord(sc, 0xF8E8, 0xF003);
2413         MP_WriteMcuAccessRegWord(sc, 0xF8EA, 0x49D0);
2414         MP_WriteMcuAccessRegWord(sc, 0xF8EC, 0xF126);
2415         MP_WriteMcuAccessRegWord(sc, 0xF8EE, 0x49A9);
2416         MP_WriteMcuAccessRegWord(sc, 0xF8F0, 0xF003);
2417         MP_WriteMcuAccessRegWord(sc, 0xF8F2, 0x49D1);
2418         MP_WriteMcuAccessRegWord(sc, 0xF8F4, 0xF122);
2419         MP_WriteMcuAccessRegWord(sc, 0xF8F6, 0x49AA);
2420         MP_WriteMcuAccessRegWord(sc, 0xF8F8, 0xF003);
2421         MP_WriteMcuAccessRegWord(sc, 0xF8FA, 0x49D2);
2422         MP_WriteMcuAccessRegWord(sc, 0xF8FC, 0xF11E);
2423         MP_WriteMcuAccessRegWord(sc, 0xF8FE, 0x49AB);
2424         MP_WriteMcuAccessRegWord(sc, 0xF900, 0xF003);
2425         MP_WriteMcuAccessRegWord(sc, 0xF902, 0x49DF);
2426         MP_WriteMcuAccessRegWord(sc, 0xF904, 0xF11A);
2427         MP_WriteMcuAccessRegWord(sc, 0xF906, 0x49AC);
2428         MP_WriteMcuAccessRegWord(sc, 0xF908, 0xF003);
2429         MP_WriteMcuAccessRegWord(sc, 0xF90A, 0x49D3);
2430         MP_WriteMcuAccessRegWord(sc, 0xF90C, 0xF116);
2431         MP_WriteMcuAccessRegWord(sc, 0xF90E, 0x4980);
2432         MP_WriteMcuAccessRegWord(sc, 0xF910, 0xF003);
2433         MP_WriteMcuAccessRegWord(sc, 0xF912, 0x49C7);
2434         MP_WriteMcuAccessRegWord(sc, 0xF914, 0xF105);
2435         MP_WriteMcuAccessRegWord(sc, 0xF916, 0x4981);
2436         MP_WriteMcuAccessRegWord(sc, 0xF918, 0xF02C);
2437         MP_WriteMcuAccessRegWord(sc, 0xF91A, 0x49D7);
2438         MP_WriteMcuAccessRegWord(sc, 0xF91C, 0xF02A);
2439         MP_WriteMcuAccessRegWord(sc, 0xF91E, 0x49C0);
2440         MP_WriteMcuAccessRegWord(sc, 0xF920, 0xF00C);
2441         MP_WriteMcuAccessRegWord(sc, 0xF922, 0xC721);
2442         MP_WriteMcuAccessRegWord(sc, 0xF924, 0x62F4);
2443         MP_WriteMcuAccessRegWord(sc, 0xF926, 0x49A0);
2444         MP_WriteMcuAccessRegWord(sc, 0xF928, 0xF008);
2445         MP_WriteMcuAccessRegWord(sc, 0xF92A, 0x49A4);
2446         MP_WriteMcuAccessRegWord(sc, 0xF92C, 0xF106);
2447         MP_WriteMcuAccessRegWord(sc, 0xF92E, 0x4824);
2448         MP_WriteMcuAccessRegWord(sc, 0xF930, 0x8AF4);
2449         MP_WriteMcuAccessRegWord(sc, 0xF932, 0xC71A);
2450         MP_WriteMcuAccessRegWord(sc, 0xF934, 0x1A40);
2451         MP_WriteMcuAccessRegWord(sc, 0xF936, 0x9AE0);
2452         MP_WriteMcuAccessRegWord(sc, 0xF938, 0x49B6);
2453         MP_WriteMcuAccessRegWord(sc, 0xF93A, 0xF017);
2454         MP_WriteMcuAccessRegWord(sc, 0xF93C, 0x200E);
2455         MP_WriteMcuAccessRegWord(sc, 0xF93E, 0xC7B8);
2456         MP_WriteMcuAccessRegWord(sc, 0xF940, 0x72E0);
2457         MP_WriteMcuAccessRegWord(sc, 0xF942, 0x4710);
2458         MP_WriteMcuAccessRegWord(sc, 0xF944, 0x92E1);
2459         MP_WriteMcuAccessRegWord(sc, 0xF946, 0xC70E);
2460         MP_WriteMcuAccessRegWord(sc, 0xF948, 0x77E0);
2461         MP_WriteMcuAccessRegWord(sc, 0xF94A, 0x49F0);
2462         MP_WriteMcuAccessRegWord(sc, 0xF94C, 0xF112);
2463         MP_WriteMcuAccessRegWord(sc, 0xF94E, 0xC70B);
2464         MP_WriteMcuAccessRegWord(sc, 0xF950, 0x77E0);
2465         MP_WriteMcuAccessRegWord(sc, 0xF952, 0x27FE);
2466         MP_WriteMcuAccessRegWord(sc, 0xF954, 0x1AFA);
2467         MP_WriteMcuAccessRegWord(sc, 0xF956, 0x4317);
2468         MP_WriteMcuAccessRegWord(sc, 0xF958, 0xC705);
2469         MP_WriteMcuAccessRegWord(sc, 0xF95A, 0x9AE2);
2470         MP_WriteMcuAccessRegWord(sc, 0xF95C, 0x1A11);
2471         MP_WriteMcuAccessRegWord(sc, 0xF95E, 0x8AE0);
2472         MP_WriteMcuAccessRegWord(sc, 0xF960, 0xE008);
2473         MP_WriteMcuAccessRegWord(sc, 0xF962, 0xE41C);
2474         MP_WriteMcuAccessRegWord(sc, 0xF964, 0xC0AE);
2475         MP_WriteMcuAccessRegWord(sc, 0xF966, 0xD23A);
2476         MP_WriteMcuAccessRegWord(sc, 0xF968, 0xC7A2);
2477         MP_WriteMcuAccessRegWord(sc, 0xF96A, 0x74E6);
2478         MP_WriteMcuAccessRegWord(sc, 0xF96C, 0x484F);
2479         MP_WriteMcuAccessRegWord(sc, 0xF96E, 0x94E7);
2480         MP_WriteMcuAccessRegWord(sc, 0xF970, 0xC79E);
2481         MP_WriteMcuAccessRegWord(sc, 0xF972, 0x8CE6);
2482         MP_WriteMcuAccessRegWord(sc, 0xF974, 0x8BEC);
2483         MP_WriteMcuAccessRegWord(sc, 0xF976, 0xC29C);
2484         MP_WriteMcuAccessRegWord(sc, 0xF978, 0x8D42);
2485         MP_WriteMcuAccessRegWord(sc, 0xF97A, 0x7220);
2486         MP_WriteMcuAccessRegWord(sc, 0xF97C, 0xB000);
2487         MP_WriteMcuAccessRegWord(sc, 0xF97E, 0xC502);
2488         MP_WriteMcuAccessRegWord(sc, 0xF980, 0xBD00);
2489         MP_WriteMcuAccessRegWord(sc, 0xF982, 0x0932);
2490         MP_WriteMcuAccessRegWord(sc, 0xF984, 0xB400);
2491         MP_WriteMcuAccessRegWord(sc, 0xF986, 0xC240);
2492         MP_WriteMcuAccessRegWord(sc, 0xF988, 0xC340);
2493         MP_WriteMcuAccessRegWord(sc, 0xF98A, 0x7060);
2494         MP_WriteMcuAccessRegWord(sc, 0xF98C, 0x498F);
2495         MP_WriteMcuAccessRegWord(sc, 0xF98E, 0xF014);
2496         MP_WriteMcuAccessRegWord(sc, 0xF990, 0x488F);
2497         MP_WriteMcuAccessRegWord(sc, 0xF992, 0x9061);
2498         MP_WriteMcuAccessRegWord(sc, 0xF994, 0x744C);
2499         MP_WriteMcuAccessRegWord(sc, 0xF996, 0x49C3);
2500         MP_WriteMcuAccessRegWord(sc, 0xF998, 0xF004);
2501         MP_WriteMcuAccessRegWord(sc, 0xF99A, 0x7562);
2502         MP_WriteMcuAccessRegWord(sc, 0xF99C, 0x485E);
2503         MP_WriteMcuAccessRegWord(sc, 0xF99E, 0x9563);
2504         MP_WriteMcuAccessRegWord(sc, 0xF9A0, 0x7446);
2505         MP_WriteMcuAccessRegWord(sc, 0xF9A2, 0x49C3);
2506         MP_WriteMcuAccessRegWord(sc, 0xF9A4, 0xF106);
2507         MP_WriteMcuAccessRegWord(sc, 0xF9A6, 0x7562);
2508         MP_WriteMcuAccessRegWord(sc, 0xF9A8, 0x1C30);
2509         MP_WriteMcuAccessRegWord(sc, 0xF9AA, 0x46E5);
2510         MP_WriteMcuAccessRegWord(sc, 0xF9AC, 0x1200);
2511         MP_WriteMcuAccessRegWord(sc, 0xF9AE, 0xF004);
2512         MP_WriteMcuAccessRegWord(sc, 0xF9B0, 0x7446);
2513         MP_WriteMcuAccessRegWord(sc, 0xF9B2, 0x484F);
2514         MP_WriteMcuAccessRegWord(sc, 0xF9B4, 0x9447);
2515         MP_WriteMcuAccessRegWord(sc, 0xF9B6, 0xC32A);
2516         MP_WriteMcuAccessRegWord(sc, 0xF9B8, 0x7466);
2517         MP_WriteMcuAccessRegWord(sc, 0xF9BA, 0x49C0);
2518         MP_WriteMcuAccessRegWord(sc, 0xF9BC, 0xF00F);
2519         MP_WriteMcuAccessRegWord(sc, 0xF9BE, 0x48C0);
2520         MP_WriteMcuAccessRegWord(sc, 0xF9C0, 0x9C66);
2521         MP_WriteMcuAccessRegWord(sc, 0xF9C2, 0x7446);
2522         MP_WriteMcuAccessRegWord(sc, 0xF9C4, 0x4840);
2523         MP_WriteMcuAccessRegWord(sc, 0xF9C6, 0x4841);
2524         MP_WriteMcuAccessRegWord(sc, 0xF9C8, 0x4842);
2525         MP_WriteMcuAccessRegWord(sc, 0xF9CA, 0x9C46);
2526         MP_WriteMcuAccessRegWord(sc, 0xF9CC, 0x744C);
2527         MP_WriteMcuAccessRegWord(sc, 0xF9CE, 0x4840);
2528         MP_WriteMcuAccessRegWord(sc, 0xF9D0, 0x9C4C);
2529         MP_WriteMcuAccessRegWord(sc, 0xF9D2, 0x744A);
2530         MP_WriteMcuAccessRegWord(sc, 0xF9D4, 0x484A);
2531         MP_WriteMcuAccessRegWord(sc, 0xF9D6, 0x9C4A);
2532         MP_WriteMcuAccessRegWord(sc, 0xF9D8, 0xE013);
2533         MP_WriteMcuAccessRegWord(sc, 0xF9DA, 0x498E);
2534         MP_WriteMcuAccessRegWord(sc, 0xF9DC, 0xF011);
2535         MP_WriteMcuAccessRegWord(sc, 0xF9DE, 0x488E);
2536         MP_WriteMcuAccessRegWord(sc, 0xF9E0, 0x9061);
2537         MP_WriteMcuAccessRegWord(sc, 0xF9E2, 0x744C);
2538         MP_WriteMcuAccessRegWord(sc, 0xF9E4, 0x49C3);
2539         MP_WriteMcuAccessRegWord(sc, 0xF9E6, 0xF004);
2540         MP_WriteMcuAccessRegWord(sc, 0xF9E8, 0x7446);
2541         MP_WriteMcuAccessRegWord(sc, 0xF9EA, 0x484E);
2542         MP_WriteMcuAccessRegWord(sc, 0xF9EC, 0x9447);
2543         MP_WriteMcuAccessRegWord(sc, 0xF9EE, 0x7446);
2544         MP_WriteMcuAccessRegWord(sc, 0xF9F0, 0x1D38);
2545         MP_WriteMcuAccessRegWord(sc, 0xF9F2, 0x46EC);
2546         MP_WriteMcuAccessRegWord(sc, 0xF9F4, 0x1500);
2547         MP_WriteMcuAccessRegWord(sc, 0xF9F6, 0xF004);
2548         MP_WriteMcuAccessRegWord(sc, 0xF9F8, 0x7446);
2549         MP_WriteMcuAccessRegWord(sc, 0xF9FA, 0x484F);
2550         MP_WriteMcuAccessRegWord(sc, 0xF9FC, 0x9447);
2551         MP_WriteMcuAccessRegWord(sc, 0xF9FE, 0xB000);
2552         MP_WriteMcuAccessRegWord(sc, 0xFA00, 0xC502);
2553         MP_WriteMcuAccessRegWord(sc, 0xFA02, 0xBD00);
2554         MP_WriteMcuAccessRegWord(sc, 0xFA04, 0x074C);
2555         MP_WriteMcuAccessRegWord(sc, 0xFA06, 0xE000);
2556         MP_WriteMcuAccessRegWord(sc, 0xFA08, 0xE0FC);
2557         MP_WriteMcuAccessRegWord(sc, 0xFA0A, 0xE0C0);
2558         MP_WriteMcuAccessRegWord(sc, 0xFA0C, 0x4830);
2559         MP_WriteMcuAccessRegWord(sc, 0xFA0E, 0x4837);
2560         MP_WriteMcuAccessRegWord(sc, 0xFA10, 0xC502);
2561         MP_WriteMcuAccessRegWord(sc, 0xFA12, 0xBD00);
2562         MP_WriteMcuAccessRegWord(sc, 0xFA14, 0x0978);
2563         MP_WriteMcuAccessRegWord(sc, 0xFA16, 0x63E2);
2564         MP_WriteMcuAccessRegWord(sc, 0xFA18, 0x4830);
2565         MP_WriteMcuAccessRegWord(sc, 0xFA1A, 0x4837);
2566         MP_WriteMcuAccessRegWord(sc, 0xFA1C, 0xC502);
2567         MP_WriteMcuAccessRegWord(sc, 0xFA1E, 0xBD00);
2568         MP_WriteMcuAccessRegWord(sc, 0xFA20, 0x09FE);
2569         MP_WriteMcuAccessRegWord(sc, 0xFA22, 0x73E2);
2570         MP_WriteMcuAccessRegWord(sc, 0xFA24, 0x4830);
2571         MP_WriteMcuAccessRegWord(sc, 0xFA26, 0x8BE2);
2572         MP_WriteMcuAccessRegWord(sc, 0xFA28, 0xC302);
2573         MP_WriteMcuAccessRegWord(sc, 0xFA2A, 0xBB00);
2574         MP_WriteMcuAccessRegWord(sc, 0xFA2C, 0x0A12);
2575         MP_WriteMcuAccessRegWord(sc, 0xFA2E, 0x73E2);
2576         MP_WriteMcuAccessRegWord(sc, 0xFA30, 0x48B0);
2577         MP_WriteMcuAccessRegWord(sc, 0xFA32, 0x48B3);
2578         MP_WriteMcuAccessRegWord(sc, 0xFA34, 0x48B4);
2579         MP_WriteMcuAccessRegWord(sc, 0xFA36, 0x48B5);
2580         MP_WriteMcuAccessRegWord(sc, 0xFA38, 0x48B6);
2581         MP_WriteMcuAccessRegWord(sc, 0xFA3A, 0x48B7);
2582         MP_WriteMcuAccessRegWord(sc, 0xFA3C, 0x8BE2);
2583         MP_WriteMcuAccessRegWord(sc, 0xFA3E, 0xC302);
2584         MP_WriteMcuAccessRegWord(sc, 0xFA40, 0xBB00);
2585         MP_WriteMcuAccessRegWord(sc, 0xFA42, 0x0A5A);
2586         MP_WriteMcuAccessRegWord(sc, 0xFA44, 0x73E2);
2587         MP_WriteMcuAccessRegWord(sc, 0xFA46, 0x4830);
2588         MP_WriteMcuAccessRegWord(sc, 0xFA48, 0x8BE2);
2589         MP_WriteMcuAccessRegWord(sc, 0xFA4A, 0xC302);
2590         MP_WriteMcuAccessRegWord(sc, 0xFA4C, 0xBB00);
2591         MP_WriteMcuAccessRegWord(sc, 0xFA4E, 0x0A6C);
2592         MP_WriteMcuAccessRegWord(sc, 0xFA50, 0x73E2);
2593         MP_WriteMcuAccessRegWord(sc, 0xFA52, 0x4830);
2594         MP_WriteMcuAccessRegWord(sc, 0xFA54, 0x4837);
2595         MP_WriteMcuAccessRegWord(sc, 0xFA56, 0xC502);
2596         MP_WriteMcuAccessRegWord(sc, 0xFA58, 0xBD00);
2597         MP_WriteMcuAccessRegWord(sc, 0xFA5A, 0x0A86);
2598
2599         MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000);
2600
2601         MP_WriteMcuAccessRegWord(sc, 0xFC28, 0x0890);
2602         MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x0712);
2603         MP_WriteMcuAccessRegWord(sc, 0xFC2C, 0x0974);
2604         MP_WriteMcuAccessRegWord(sc, 0xFC2E, 0x09FC);
2605         MP_WriteMcuAccessRegWord(sc, 0xFC30, 0x0A0E);
2606         MP_WriteMcuAccessRegWord(sc, 0xFC32, 0x0A56);
2607         MP_WriteMcuAccessRegWord(sc, 0xFC34, 0x0A68);
2608         MP_WriteMcuAccessRegWord(sc, 0xFC36, 0x0A84);
2609
2610         if (sc->HwPkgDet == 0x0)
2611                 MP_WriteMcuAccessRegWord(sc, 0xFC38, 0x00FC);
2612         else if(sc->HwPkgDet == 0xF)
2613                 MP_WriteMcuAccessRegWord(sc, 0xFC38, 0x00FF);
2614 }
2615
2616 static void re_set_mac_mcu_8168fp_2(struct re_softc *sc)
2617 {
2618         DisableMcuBPs(sc);
2619
2620         MP_WriteMcuAccessRegWord(sc, 0xF800, 0xE008);
2621         MP_WriteMcuAccessRegWord(sc, 0xF802, 0xE00A);
2622         MP_WriteMcuAccessRegWord(sc, 0xF804, 0xE031);
2623         MP_WriteMcuAccessRegWord(sc, 0xF806, 0xE033);
2624         MP_WriteMcuAccessRegWord(sc, 0xF808, 0xE035);
2625         MP_WriteMcuAccessRegWord(sc, 0xF80A, 0xE144);
2626         MP_WriteMcuAccessRegWord(sc, 0xF80C, 0xE166);
2627         MP_WriteMcuAccessRegWord(sc, 0xF80E, 0xE168);
2628         MP_WriteMcuAccessRegWord(sc, 0xF810, 0xC502);
2629         MP_WriteMcuAccessRegWord(sc, 0xF812, 0xBD00);
2630         MP_WriteMcuAccessRegWord(sc, 0xF814, 0x0000);
2631         MP_WriteMcuAccessRegWord(sc, 0xF816, 0xC725);
2632         MP_WriteMcuAccessRegWord(sc, 0xF818, 0x75E0);
2633         MP_WriteMcuAccessRegWord(sc, 0xF81A, 0x48D0);
2634         MP_WriteMcuAccessRegWord(sc, 0xF81C, 0x9DE0);
2635         MP_WriteMcuAccessRegWord(sc, 0xF81E, 0xC722);
2636         MP_WriteMcuAccessRegWord(sc, 0xF820, 0x75E0);
2637         MP_WriteMcuAccessRegWord(sc, 0xF822, 0x1C78);
2638         MP_WriteMcuAccessRegWord(sc, 0xF824, 0x416C);
2639         MP_WriteMcuAccessRegWord(sc, 0xF826, 0x1530);
2640         MP_WriteMcuAccessRegWord(sc, 0xF828, 0xF111);
2641         MP_WriteMcuAccessRegWord(sc, 0xF82A, 0xC71D);
2642         MP_WriteMcuAccessRegWord(sc, 0xF82C, 0x75F6);
2643         MP_WriteMcuAccessRegWord(sc, 0xF82E, 0x49D1);
2644         MP_WriteMcuAccessRegWord(sc, 0xF830, 0xF00D);
2645         MP_WriteMcuAccessRegWord(sc, 0xF832, 0x75E0);
2646         MP_WriteMcuAccessRegWord(sc, 0xF834, 0x1C1F);
2647         MP_WriteMcuAccessRegWord(sc, 0xF836, 0x416C);
2648         MP_WriteMcuAccessRegWord(sc, 0xF838, 0x1502);
2649         MP_WriteMcuAccessRegWord(sc, 0xF83A, 0xF108);
2650         MP_WriteMcuAccessRegWord(sc, 0xF83C, 0x75FA);
2651         MP_WriteMcuAccessRegWord(sc, 0xF83E, 0x49D3);
2652         MP_WriteMcuAccessRegWord(sc, 0xF840, 0xF005);
2653         MP_WriteMcuAccessRegWord(sc, 0xF842, 0x75EC);
2654         MP_WriteMcuAccessRegWord(sc, 0xF844, 0x9DE4);
2655         MP_WriteMcuAccessRegWord(sc, 0xF846, 0x4853);
2656         MP_WriteMcuAccessRegWord(sc, 0xF848, 0x9DFA);
2657         MP_WriteMcuAccessRegWord(sc, 0xF84A, 0xC70B);
2658         MP_WriteMcuAccessRegWord(sc, 0xF84C, 0x75E0);
2659         MP_WriteMcuAccessRegWord(sc, 0xF84E, 0x4852);
2660         MP_WriteMcuAccessRegWord(sc, 0xF850, 0x4850);
2661         MP_WriteMcuAccessRegWord(sc, 0xF852, 0x9DE0);
2662         MP_WriteMcuAccessRegWord(sc, 0xF854, 0xC602);
2663         MP_WriteMcuAccessRegWord(sc, 0xF856, 0xBE00);
2664         MP_WriteMcuAccessRegWord(sc, 0xF858, 0x04B8);
2665         MP_WriteMcuAccessRegWord(sc, 0xF85A, 0xE420);
2666         MP_WriteMcuAccessRegWord(sc, 0xF85C, 0xE000);
2667         MP_WriteMcuAccessRegWord(sc, 0xF85E, 0xE0FC);
2668         MP_WriteMcuAccessRegWord(sc, 0xF860, 0xE43C);
2669         MP_WriteMcuAccessRegWord(sc, 0xF862, 0xDC00);
2670         MP_WriteMcuAccessRegWord(sc, 0xF864, 0xEB00);
2671         MP_WriteMcuAccessRegWord(sc, 0xF866, 0xC202);
2672         MP_WriteMcuAccessRegWord(sc, 0xF868, 0xBA00);
2673         MP_WriteMcuAccessRegWord(sc, 0xF86A, 0x0000);
2674         MP_WriteMcuAccessRegWord(sc, 0xF86C, 0xC002);
2675         MP_WriteMcuAccessRegWord(sc, 0xF86E, 0xB800);
2676         MP_WriteMcuAccessRegWord(sc, 0xF870, 0x0000);
2677         MP_WriteMcuAccessRegWord(sc, 0xF872, 0xB401);
2678         MP_WriteMcuAccessRegWord(sc, 0xF874, 0xB402);
2679         MP_WriteMcuAccessRegWord(sc, 0xF876, 0xB403);
2680         MP_WriteMcuAccessRegWord(sc, 0xF878, 0xB404);
2681         MP_WriteMcuAccessRegWord(sc, 0xF87A, 0xB405);
2682         MP_WriteMcuAccessRegWord(sc, 0xF87C, 0xB406);
2683         MP_WriteMcuAccessRegWord(sc, 0xF87E, 0xC44D);
2684         MP_WriteMcuAccessRegWord(sc, 0xF880, 0xC54D);
2685         MP_WriteMcuAccessRegWord(sc, 0xF882, 0x1867);
2686         MP_WriteMcuAccessRegWord(sc, 0xF884, 0xE8A2);
2687         MP_WriteMcuAccessRegWord(sc, 0xF886, 0x2318);
2688         MP_WriteMcuAccessRegWord(sc, 0xF888, 0x276E);
2689         MP_WriteMcuAccessRegWord(sc, 0xF88A, 0x1601);
2690         MP_WriteMcuAccessRegWord(sc, 0xF88C, 0xF106);
2691         MP_WriteMcuAccessRegWord(sc, 0xF88E, 0x1A07);
2692         MP_WriteMcuAccessRegWord(sc, 0xF890, 0xE861);
2693         MP_WriteMcuAccessRegWord(sc, 0xF892, 0xE86B);
2694         MP_WriteMcuAccessRegWord(sc, 0xF894, 0xE873);
2695         MP_WriteMcuAccessRegWord(sc, 0xF896, 0xE037);
2696         MP_WriteMcuAccessRegWord(sc, 0xF898, 0x231E);
2697         MP_WriteMcuAccessRegWord(sc, 0xF89A, 0x276E);
2698         MP_WriteMcuAccessRegWord(sc, 0xF89C, 0x1602);
2699         MP_WriteMcuAccessRegWord(sc, 0xF89E, 0xF10B);
2700         MP_WriteMcuAccessRegWord(sc, 0xF8A0, 0x1A07);
2701         MP_WriteMcuAccessRegWord(sc, 0xF8A2, 0xE858);
2702         MP_WriteMcuAccessRegWord(sc, 0xF8A4, 0xE862);
2703         MP_WriteMcuAccessRegWord(sc, 0xF8A6, 0xC247);
2704         MP_WriteMcuAccessRegWord(sc, 0xF8A8, 0xC344);
2705         MP_WriteMcuAccessRegWord(sc, 0xF8AA, 0xE8E3);
2706         MP_WriteMcuAccessRegWord(sc, 0xF8AC, 0xC73B);
2707         MP_WriteMcuAccessRegWord(sc, 0xF8AE, 0x66E0);
2708         MP_WriteMcuAccessRegWord(sc, 0xF8B0, 0xE8B5);
2709         MP_WriteMcuAccessRegWord(sc, 0xF8B2, 0xE029);
2710         MP_WriteMcuAccessRegWord(sc, 0xF8B4, 0x231A);
2711         MP_WriteMcuAccessRegWord(sc, 0xF8B6, 0x276C);
2712         MP_WriteMcuAccessRegWord(sc, 0xF8B8, 0xC733);
2713         MP_WriteMcuAccessRegWord(sc, 0xF8BA, 0x9EE0);
2714         MP_WriteMcuAccessRegWord(sc, 0xF8BC, 0x1866);
2715         MP_WriteMcuAccessRegWord(sc, 0xF8BE, 0xE885);
2716         MP_WriteMcuAccessRegWord(sc, 0xF8C0, 0x251C);
2717         MP_WriteMcuAccessRegWord(sc, 0xF8C2, 0x120F);
2718         MP_WriteMcuAccessRegWord(sc, 0xF8C4, 0xF011);
2719         MP_WriteMcuAccessRegWord(sc, 0xF8C6, 0x1209);
2720         MP_WriteMcuAccessRegWord(sc, 0xF8C8, 0xF011);
2721         MP_WriteMcuAccessRegWord(sc, 0xF8CA, 0x2014);
2722         MP_WriteMcuAccessRegWord(sc, 0xF8CC, 0x240E);
2723         MP_WriteMcuAccessRegWord(sc, 0xF8CE, 0x1000);
2724         MP_WriteMcuAccessRegWord(sc, 0xF8D0, 0xF007);
2725         MP_WriteMcuAccessRegWord(sc, 0xF8D2, 0x120C);
2726         MP_WriteMcuAccessRegWord(sc, 0xF8D4, 0xF00D);
2727         MP_WriteMcuAccessRegWord(sc, 0xF8D6, 0x1203);
2728         MP_WriteMcuAccessRegWord(sc, 0xF8D8, 0xF00D);
2729         MP_WriteMcuAccessRegWord(sc, 0xF8DA, 0x1200);
2730         MP_WriteMcuAccessRegWord(sc, 0xF8DC, 0xF00D);
2731         MP_WriteMcuAccessRegWord(sc, 0xF8DE, 0x120C);
2732         MP_WriteMcuAccessRegWord(sc, 0xF8E0, 0xF00D);
2733         MP_WriteMcuAccessRegWord(sc, 0xF8E2, 0x1203);
2734         MP_WriteMcuAccessRegWord(sc, 0xF8E4, 0xF00D);
2735         MP_WriteMcuAccessRegWord(sc, 0xF8E6, 0x1A03);
2736         MP_WriteMcuAccessRegWord(sc, 0xF8E8, 0xE00C);
2737         MP_WriteMcuAccessRegWord(sc, 0xF8EA, 0x1A07);
2738         MP_WriteMcuAccessRegWord(sc, 0xF8EC, 0xE00A);
2739         MP_WriteMcuAccessRegWord(sc, 0xF8EE, 0x1A00);
2740         MP_WriteMcuAccessRegWord(sc, 0xF8F0, 0xE008);
2741         MP_WriteMcuAccessRegWord(sc, 0xF8F2, 0x1A01);
2742         MP_WriteMcuAccessRegWord(sc, 0xF8F4, 0xE006);
2743         MP_WriteMcuAccessRegWord(sc, 0xF8F6, 0x1A02);
2744         MP_WriteMcuAccessRegWord(sc, 0xF8F8, 0xE004);
2745         MP_WriteMcuAccessRegWord(sc, 0xF8FA, 0x1A04);
2746         MP_WriteMcuAccessRegWord(sc, 0xF8FC, 0xE002);
2747         MP_WriteMcuAccessRegWord(sc, 0xF8FE, 0x1A05);
2748         MP_WriteMcuAccessRegWord(sc, 0xF900, 0xE829);
2749         MP_WriteMcuAccessRegWord(sc, 0xF902, 0xE833);
2750         MP_WriteMcuAccessRegWord(sc, 0xF904, 0xB006);
2751         MP_WriteMcuAccessRegWord(sc, 0xF906, 0xB005);
2752         MP_WriteMcuAccessRegWord(sc, 0xF908, 0xB004);
2753         MP_WriteMcuAccessRegWord(sc, 0xF90A, 0xB003);
2754         MP_WriteMcuAccessRegWord(sc, 0xF90C, 0xB002);
2755         MP_WriteMcuAccessRegWord(sc, 0xF90E, 0xB001);
2756         MP_WriteMcuAccessRegWord(sc, 0xF910, 0x60C4);
2757         MP_WriteMcuAccessRegWord(sc, 0xF912, 0xC702);
2758         MP_WriteMcuAccessRegWord(sc, 0xF914, 0xBF00);
2759         MP_WriteMcuAccessRegWord(sc, 0xF916, 0x2786);
2760         MP_WriteMcuAccessRegWord(sc, 0xF918, 0xDD00);
2761         MP_WriteMcuAccessRegWord(sc, 0xF91A, 0xD030);
2762         MP_WriteMcuAccessRegWord(sc, 0xF91C, 0xE0C4);
2763         MP_WriteMcuAccessRegWord(sc, 0xF91E, 0xE0F8);
2764         MP_WriteMcuAccessRegWord(sc, 0xF920, 0xDC42);
2765         MP_WriteMcuAccessRegWord(sc, 0xF922, 0xD3F0);
2766         MP_WriteMcuAccessRegWord(sc, 0xF924, 0x0000);
2767         MP_WriteMcuAccessRegWord(sc, 0xF926, 0x0004);
2768         MP_WriteMcuAccessRegWord(sc, 0xF928, 0x0007);
2769         MP_WriteMcuAccessRegWord(sc, 0xF92A, 0x0014);
2770         MP_WriteMcuAccessRegWord(sc, 0xF92C, 0x0090);
2771         MP_WriteMcuAccessRegWord(sc, 0xF92E, 0x1000);
2772         MP_WriteMcuAccessRegWord(sc, 0xF930, 0x0F00);
2773         MP_WriteMcuAccessRegWord(sc, 0xF932, 0x1004);
2774         MP_WriteMcuAccessRegWord(sc, 0xF934, 0x1008);
2775         MP_WriteMcuAccessRegWord(sc, 0xF936, 0x3000);
2776         MP_WriteMcuAccessRegWord(sc, 0xF938, 0x3004);
2777         MP_WriteMcuAccessRegWord(sc, 0xF93A, 0x3008);
2778         MP_WriteMcuAccessRegWord(sc, 0xF93C, 0x4000);
2779         MP_WriteMcuAccessRegWord(sc, 0xF93E, 0x7777);
2780         MP_WriteMcuAccessRegWord(sc, 0xF940, 0x8000);
2781         MP_WriteMcuAccessRegWord(sc, 0xF942, 0x8001);
2782         MP_WriteMcuAccessRegWord(sc, 0xF944, 0x8008);
2783         MP_WriteMcuAccessRegWord(sc, 0xF946, 0x8003);
2784         MP_WriteMcuAccessRegWord(sc, 0xF948, 0x8004);
2785         MP_WriteMcuAccessRegWord(sc, 0xF94A, 0xC000);
2786         MP_WriteMcuAccessRegWord(sc, 0xF94C, 0xC004);
2787         MP_WriteMcuAccessRegWord(sc, 0xF94E, 0xF004);
2788         MP_WriteMcuAccessRegWord(sc, 0xF950, 0xFFFF);
2789         MP_WriteMcuAccessRegWord(sc, 0xF952, 0xB406);
2790         MP_WriteMcuAccessRegWord(sc, 0xF954, 0xB407);
2791         MP_WriteMcuAccessRegWord(sc, 0xF956, 0xC6E5);
2792         MP_WriteMcuAccessRegWord(sc, 0xF958, 0x77C0);
2793         MP_WriteMcuAccessRegWord(sc, 0xF95A, 0x27F3);
2794         MP_WriteMcuAccessRegWord(sc, 0xF95C, 0x23F3);
2795         MP_WriteMcuAccessRegWord(sc, 0xF95E, 0x47FA);
2796         MP_WriteMcuAccessRegWord(sc, 0xF960, 0x9FC0);
2797         MP_WriteMcuAccessRegWord(sc, 0xF962, 0xB007);
2798         MP_WriteMcuAccessRegWord(sc, 0xF964, 0xB006);
2799         MP_WriteMcuAccessRegWord(sc, 0xF966, 0xFF80);
2800         MP_WriteMcuAccessRegWord(sc, 0xF968, 0xB405);
2801         MP_WriteMcuAccessRegWord(sc, 0xF96A, 0xB407);
2802         MP_WriteMcuAccessRegWord(sc, 0xF96C, 0xC7D8);
2803         MP_WriteMcuAccessRegWord(sc, 0xF96E, 0x75E0);
2804         MP_WriteMcuAccessRegWord(sc, 0xF970, 0x48D0);
2805         MP_WriteMcuAccessRegWord(sc, 0xF972, 0x9DE0);
2806         MP_WriteMcuAccessRegWord(sc, 0xF974, 0xB007);
2807         MP_WriteMcuAccessRegWord(sc, 0xF976, 0xB005);
2808         MP_WriteMcuAccessRegWord(sc, 0xF978, 0xFF80);
2809         MP_WriteMcuAccessRegWord(sc, 0xF97A, 0xB401);
2810         MP_WriteMcuAccessRegWord(sc, 0xF97C, 0xC0EA);
2811         MP_WriteMcuAccessRegWord(sc, 0xF97E, 0xC2DC);
2812         MP_WriteMcuAccessRegWord(sc, 0xF980, 0xC3D8);
2813         MP_WriteMcuAccessRegWord(sc, 0xF982, 0xE865);
2814         MP_WriteMcuAccessRegWord(sc, 0xF984, 0xC0D3);
2815         MP_WriteMcuAccessRegWord(sc, 0xF986, 0xC1E0);
2816         MP_WriteMcuAccessRegWord(sc, 0xF988, 0xC2E3);
2817         MP_WriteMcuAccessRegWord(sc, 0xF98A, 0xE861);
2818         MP_WriteMcuAccessRegWord(sc, 0xF98C, 0xE817);
2819         MP_WriteMcuAccessRegWord(sc, 0xF98E, 0xC0CD);
2820         MP_WriteMcuAccessRegWord(sc, 0xF990, 0xC2CF);
2821         MP_WriteMcuAccessRegWord(sc, 0xF992, 0xE85D);
2822         MP_WriteMcuAccessRegWord(sc, 0xF994, 0xC0C9);
2823         MP_WriteMcuAccessRegWord(sc, 0xF996, 0xC1D6);
2824         MP_WriteMcuAccessRegWord(sc, 0xF998, 0xC2DB);
2825         MP_WriteMcuAccessRegWord(sc, 0xF99A, 0xE859);
2826         MP_WriteMcuAccessRegWord(sc, 0xF99C, 0xE80F);
2827         MP_WriteMcuAccessRegWord(sc, 0xF99E, 0xC1C7);
2828         MP_WriteMcuAccessRegWord(sc, 0xF9A0, 0xC2CE);
2829         MP_WriteMcuAccessRegWord(sc, 0xF9A2, 0xE855);
2830         MP_WriteMcuAccessRegWord(sc, 0xF9A4, 0xC0C0);
2831         MP_WriteMcuAccessRegWord(sc, 0xF9A6, 0xC1D1);
2832         MP_WriteMcuAccessRegWord(sc, 0xF9A8, 0xC2D3);
2833         MP_WriteMcuAccessRegWord(sc, 0xF9AA, 0xE851);
2834         MP_WriteMcuAccessRegWord(sc, 0xF9AC, 0xE807);
2835         MP_WriteMcuAccessRegWord(sc, 0xF9AE, 0xC0BE);
2836         MP_WriteMcuAccessRegWord(sc, 0xF9B0, 0xC2C2);
2837         MP_WriteMcuAccessRegWord(sc, 0xF9B2, 0xE84D);
2838         MP_WriteMcuAccessRegWord(sc, 0xF9B4, 0xE803);
2839         MP_WriteMcuAccessRegWord(sc, 0xF9B6, 0xB001);
2840         MP_WriteMcuAccessRegWord(sc, 0xF9B8, 0xFF80);
2841         MP_WriteMcuAccessRegWord(sc, 0xF9BA, 0xB402);
2842         MP_WriteMcuAccessRegWord(sc, 0xF9BC, 0xC2C6);
2843         MP_WriteMcuAccessRegWord(sc, 0xF9BE, 0xE859);
2844         MP_WriteMcuAccessRegWord(sc, 0xF9C0, 0x499F);
2845         MP_WriteMcuAccessRegWord(sc, 0xF9C2, 0xF1FE);
2846         MP_WriteMcuAccessRegWord(sc, 0xF9C4, 0xB002);
2847         MP_WriteMcuAccessRegWord(sc, 0xF9C6, 0xFF80);
2848         MP_WriteMcuAccessRegWord(sc, 0xF9C8, 0xB402);
2849         MP_WriteMcuAccessRegWord(sc, 0xF9CA, 0xB403);
2850         MP_WriteMcuAccessRegWord(sc, 0xF9CC, 0xB407);
2851         MP_WriteMcuAccessRegWord(sc, 0xF9CE, 0xE821);
2852         MP_WriteMcuAccessRegWord(sc, 0xF9D0, 0x8882);
2853         MP_WriteMcuAccessRegWord(sc, 0xF9D2, 0x1980);
2854         MP_WriteMcuAccessRegWord(sc, 0xF9D4, 0x8983);
2855         MP_WriteMcuAccessRegWord(sc, 0xF9D6, 0xE81D);
2856         MP_WriteMcuAccessRegWord(sc, 0xF9D8, 0x7180);
2857         MP_WriteMcuAccessRegWord(sc, 0xF9DA, 0x218B);
2858         MP_WriteMcuAccessRegWord(sc, 0xF9DC, 0x25BB);
2859         MP_WriteMcuAccessRegWord(sc, 0xF9DE, 0x1310);
2860         MP_WriteMcuAccessRegWord(sc, 0xF9E0, 0xF014);
2861         MP_WriteMcuAccessRegWord(sc, 0xF9E2, 0x1310);
2862         MP_WriteMcuAccessRegWord(sc, 0xF9E4, 0xFB03);
2863         MP_WriteMcuAccessRegWord(sc, 0xF9E6, 0x1F20);
2864         MP_WriteMcuAccessRegWord(sc, 0xF9E8, 0x38FB);
2865         MP_WriteMcuAccessRegWord(sc, 0xF9EA, 0x3288);
2866         MP_WriteMcuAccessRegWord(sc, 0xF9EC, 0x434B);
2867         MP_WriteMcuAccessRegWord(sc, 0xF9EE, 0x2491);
2868         MP_WriteMcuAccessRegWord(sc, 0xF9F0, 0x430B);
2869         MP_WriteMcuAccessRegWord(sc, 0xF9F2, 0x1F0F);
2870         MP_WriteMcuAccessRegWord(sc, 0xF9F4, 0x38FB);
2871         MP_WriteMcuAccessRegWord(sc, 0xF9F6, 0x4313);
2872         MP_WriteMcuAccessRegWord(sc, 0xF9F8, 0x2121);
2873         MP_WriteMcuAccessRegWord(sc, 0xF9FA, 0x4353);
2874         MP_WriteMcuAccessRegWord(sc, 0xF9FC, 0x2521);
2875         MP_WriteMcuAccessRegWord(sc, 0xF9FE, 0x418A);
2876         MP_WriteMcuAccessRegWord(sc, 0xFA00, 0x6282);
2877         MP_WriteMcuAccessRegWord(sc, 0xFA02, 0x2527);
2878         MP_WriteMcuAccessRegWord(sc, 0xFA04, 0x212F);
2879         MP_WriteMcuAccessRegWord(sc, 0xFA06, 0x418A);
2880         MP_WriteMcuAccessRegWord(sc, 0xFA08, 0xB007);
2881         MP_WriteMcuAccessRegWord(sc, 0xFA0A, 0xB003);
2882         MP_WriteMcuAccessRegWord(sc, 0xFA0C, 0xB002);
2883         MP_WriteMcuAccessRegWord(sc, 0xFA0E, 0xFF80);
2884         MP_WriteMcuAccessRegWord(sc, 0xFA10, 0x6183);
2885         MP_WriteMcuAccessRegWord(sc, 0xFA12, 0x2496);
2886         MP_WriteMcuAccessRegWord(sc, 0xFA14, 0x1100);
2887         MP_WriteMcuAccessRegWord(sc, 0xFA16, 0xF1FD);
2888         MP_WriteMcuAccessRegWord(sc, 0xFA18, 0xFF80);
2889         MP_WriteMcuAccessRegWord(sc, 0xFA1A, 0x4800);
2890         MP_WriteMcuAccessRegWord(sc, 0xFA1C, 0x4801);
2891         MP_WriteMcuAccessRegWord(sc, 0xFA1E, 0xC213);
2892         MP_WriteMcuAccessRegWord(sc, 0xFA20, 0xC313);
2893         MP_WriteMcuAccessRegWord(sc, 0xFA22, 0xE815);
2894         MP_WriteMcuAccessRegWord(sc, 0xFA24, 0x4860);
2895         MP_WriteMcuAccessRegWord(sc, 0xFA26, 0x8EE0);
2896         MP_WriteMcuAccessRegWord(sc, 0xFA28, 0xC210);
2897         MP_WriteMcuAccessRegWord(sc, 0xFA2A, 0xC310);
2898         MP_WriteMcuAccessRegWord(sc, 0xFA2C, 0xE822);
2899         MP_WriteMcuAccessRegWord(sc, 0xFA2E, 0x481E);
2900         MP_WriteMcuAccessRegWord(sc, 0xFA30, 0xC20C);
2901         MP_WriteMcuAccessRegWord(sc, 0xFA32, 0xC30C);
2902         MP_WriteMcuAccessRegWord(sc, 0xFA34, 0xE80C);
2903         MP_WriteMcuAccessRegWord(sc, 0xFA36, 0xC206);
2904         MP_WriteMcuAccessRegWord(sc, 0xFA38, 0x7358);
2905         MP_WriteMcuAccessRegWord(sc, 0xFA3A, 0x483A);
2906         MP_WriteMcuAccessRegWord(sc, 0xFA3C, 0x9B58);
2907         MP_WriteMcuAccessRegWord(sc, 0xFA3E, 0xFF80);
2908         MP_WriteMcuAccessRegWord(sc, 0xFA40, 0xE8E0);
2909         MP_WriteMcuAccessRegWord(sc, 0xFA42, 0xE000);
2910         MP_WriteMcuAccessRegWord(sc, 0xFA44, 0x1008);
2911         MP_WriteMcuAccessRegWord(sc, 0xFA46, 0x0F00);
2912         MP_WriteMcuAccessRegWord(sc, 0xFA48, 0x800C);
2913         MP_WriteMcuAccessRegWord(sc, 0xFA4A, 0x0F00);
2914         MP_WriteMcuAccessRegWord(sc, 0xFA4C, 0xB407);
2915         MP_WriteMcuAccessRegWord(sc, 0xFA4E, 0xB406);
2916         MP_WriteMcuAccessRegWord(sc, 0xFA50, 0xB403);
2917         MP_WriteMcuAccessRegWord(sc, 0xFA52, 0xC7F7);
2918         MP_WriteMcuAccessRegWord(sc, 0xFA54, 0x98E0);
2919         MP_WriteMcuAccessRegWord(sc, 0xFA56, 0x99E2);
2920         MP_WriteMcuAccessRegWord(sc, 0xFA58, 0x9AE4);
2921         MP_WriteMcuAccessRegWord(sc, 0xFA5A, 0x21B2);
2922         MP_WriteMcuAccessRegWord(sc, 0xFA5C, 0x4831);
2923         MP_WriteMcuAccessRegWord(sc, 0xFA5E, 0x483F);
2924         MP_WriteMcuAccessRegWord(sc, 0xFA60, 0x9BE6);
2925         MP_WriteMcuAccessRegWord(sc, 0xFA62, 0x66E7);
2926         MP_WriteMcuAccessRegWord(sc, 0xFA64, 0x49E6);
2927         MP_WriteMcuAccessRegWord(sc, 0xFA66, 0xF1FE);
2928         MP_WriteMcuAccessRegWord(sc, 0xFA68, 0xB003);
2929         MP_WriteMcuAccessRegWord(sc, 0xFA6A, 0xB006);
2930         MP_WriteMcuAccessRegWord(sc, 0xFA6C, 0xB007);
2931         MP_WriteMcuAccessRegWord(sc, 0xFA6E, 0xFF80);
2932         MP_WriteMcuAccessRegWord(sc, 0xFA70, 0xB407);
2933         MP_WriteMcuAccessRegWord(sc, 0xFA72, 0xB406);
2934         MP_WriteMcuAccessRegWord(sc, 0xFA74, 0xB403);
2935         MP_WriteMcuAccessRegWord(sc, 0xFA76, 0xC7E5);
2936         MP_WriteMcuAccessRegWord(sc, 0xFA78, 0x9AE4);
2937         MP_WriteMcuAccessRegWord(sc, 0xFA7A, 0x21B2);
2938         MP_WriteMcuAccessRegWord(sc, 0xFA7C, 0x4831);
2939         MP_WriteMcuAccessRegWord(sc, 0xFA7E, 0x9BE6);
2940         MP_WriteMcuAccessRegWord(sc, 0xFA80, 0x66E7);
2941         MP_WriteMcuAccessRegWord(sc, 0xFA82, 0x49E6);
2942         MP_WriteMcuAccessRegWord(sc, 0xFA84, 0xF1FE);
2943         MP_WriteMcuAccessRegWord(sc, 0xFA86, 0x70E0);
2944         MP_WriteMcuAccessRegWord(sc, 0xFA88, 0x71E2);
2945         MP_WriteMcuAccessRegWord(sc, 0xFA8A, 0xB003);
2946         MP_WriteMcuAccessRegWord(sc, 0xFA8C, 0xB006);
2947         MP_WriteMcuAccessRegWord(sc, 0xFA8E, 0xB007);
2948         MP_WriteMcuAccessRegWord(sc, 0xFA90, 0xFF80);
2949         MP_WriteMcuAccessRegWord(sc, 0xFA92, 0x4882);
2950         MP_WriteMcuAccessRegWord(sc, 0xFA94, 0xB406);
2951         MP_WriteMcuAccessRegWord(sc, 0xFA96, 0xB405);
2952         MP_WriteMcuAccessRegWord(sc, 0xFA98, 0xC71E);
2953         MP_WriteMcuAccessRegWord(sc, 0xFA9A, 0x76E0);
2954         MP_WriteMcuAccessRegWord(sc, 0xFA9C, 0x1D78);
2955         MP_WriteMcuAccessRegWord(sc, 0xFA9E, 0x4175);
2956         MP_WriteMcuAccessRegWord(sc, 0xFAA0, 0x1630);
2957         MP_WriteMcuAccessRegWord(sc, 0xFAA2, 0xF10C);
2958         MP_WriteMcuAccessRegWord(sc, 0xFAA4, 0xC715);
2959         MP_WriteMcuAccessRegWord(sc, 0xFAA6, 0x76E0);
2960         MP_WriteMcuAccessRegWord(sc, 0xFAA8, 0x4861);
2961         MP_WriteMcuAccessRegWord(sc, 0xFAAA, 0x9EE0);
2962         MP_WriteMcuAccessRegWord(sc, 0xFAAC, 0xC713);
2963         MP_WriteMcuAccessRegWord(sc, 0xFAAE, 0x1EFF);
2964         MP_WriteMcuAccessRegWord(sc, 0xFAB0, 0x9EE2);
2965         MP_WriteMcuAccessRegWord(sc, 0xFAB2, 0x75E0);
2966         MP_WriteMcuAccessRegWord(sc, 0xFAB4, 0x4850);
2967         MP_WriteMcuAccessRegWord(sc, 0xFAB6, 0x9DE0);
2968         MP_WriteMcuAccessRegWord(sc, 0xFAB8, 0xE005);
2969         MP_WriteMcuAccessRegWord(sc, 0xFABA, 0xC70B);
2970         MP_WriteMcuAccessRegWord(sc, 0xFABC, 0x76E0);
2971         MP_WriteMcuAccessRegWord(sc, 0xFABE, 0x4865);
2972         MP_WriteMcuAccessRegWord(sc, 0xFAC0, 0x9EE0);
2973         MP_WriteMcuAccessRegWord(sc, 0xFAC2, 0xB005);
2974         MP_WriteMcuAccessRegWord(sc, 0xFAC4, 0xB006);
2975         MP_WriteMcuAccessRegWord(sc, 0xFAC6, 0xC708);
2976         MP_WriteMcuAccessRegWord(sc, 0xFAC8, 0xC102);
2977         MP_WriteMcuAccessRegWord(sc, 0xFACA, 0xB900);
2978         MP_WriteMcuAccessRegWord(sc, 0xFACC, 0x279E);
2979         MP_WriteMcuAccessRegWord(sc, 0xFACE, 0xEB16);
2980         MP_WriteMcuAccessRegWord(sc, 0xFAD0, 0xEB00);
2981         MP_WriteMcuAccessRegWord(sc, 0xFAD2, 0xE43C);
2982         MP_WriteMcuAccessRegWord(sc, 0xFAD4, 0xDC00);
2983         MP_WriteMcuAccessRegWord(sc, 0xFAD6, 0xD3EC);
2984         MP_WriteMcuAccessRegWord(sc, 0xFAD8, 0xC602);
2985         MP_WriteMcuAccessRegWord(sc, 0xFADA, 0xBE00);
2986         MP_WriteMcuAccessRegWord(sc, 0xFADC, 0x0000);
2987         MP_WriteMcuAccessRegWord(sc, 0xFADE, 0xC602);
2988         MP_WriteMcuAccessRegWord(sc, 0xFAE0, 0xBE00);
2989         MP_WriteMcuAccessRegWord(sc, 0xFAE2, 0x0000);
2990
2991         MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000);
2992
2993         MP_WriteMcuAccessRegWord(sc, 0xFC28, 0x0000);
2994         MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x04B4);
2995         MP_WriteMcuAccessRegWord(sc, 0xFC2C, 0x0000);
2996         MP_WriteMcuAccessRegWord(sc, 0xFC2E, 0x0000);
2997         MP_WriteMcuAccessRegWord(sc, 0xFC30, 0x0000);
2998         MP_WriteMcuAccessRegWord(sc, 0xFC32, 0x279C);
2999         MP_WriteMcuAccessRegWord(sc, 0xFC34, 0x0000);
3000         MP_WriteMcuAccessRegWord(sc, 0xFC36, 0x0000);
3001
3002         MP_WriteMcuAccessRegWord(sc, 0xFC38, 0x0022);
3003 }
3004
3005 static void re_hw_mac_mcu_config(struct re_softc *sc)
3006 {
3007         switch(sc->re_type) {
3008         case MACFG_56:
3009                 re_set_mac_mcu_8168g_1(sc);
3010                 break;
3011         case MACFG_58:
3012                 re_set_mac_mcu_8168gu_1(sc);
3013                 break;
3014         case MACFG_59:
3015                 re_set_mac_mcu_8168gu_2(sc);
3016                 break;
3017         case MACFG_60:
3018                 re_set_mac_mcu_8411b_1(sc);
3019                 break;
3020         case MACFG_62:
3021                 re_set_mac_mcu_8168ep_1(sc);
3022                 break;
3023         case MACFG_67:
3024                 re_set_mac_mcu_8168ep_2(sc);
3025                 break;
3026         case MACFG_68:
3027         case MACFG_69:
3028                 re_set_mac_mcu_8168h_1(sc);
3029                 break;
3030         case MACFG_70:
3031                 if (sc->HwPkgDet == 0x00 || sc->HwPkgDet == 0x0F)
3032                         re_set_mac_mcu_8168fp_1(sc);
3033                 else if (sc->HwPkgDet == 0x06)
3034                         re_set_mac_mcu_8168fp_2(sc);
3035                 break;
3036         case MACFG_71:
3037                 DisableMcuBPs(sc);
3038                 break;
3039         }
3040 }
3041
3042 #define ISRIMR_DASH_TYPE2_TX_DISABLE_IDLE BIT_5
3043 static void Dash2DisableTx(struct re_softc *sc)
3044 {
3045         //if (!sc->re_dash) return;
3046
3047         if (HW_DASH_SUPPORT_TYPE_2(sc) || HW_DASH_SUPPORT_TYPE_3(sc)) {
3048                 u_int16_t WaitCnt;
3049                 u_int8_t TmpUchar;
3050
3051                 //Disable oob Tx
3052                 RE_CMAC_WRITE_1(sc, RE_CMAC_IBCR2, RE_CMAC_READ_1(sc, RE_CMAC_IBCR2) & ~(BIT_0));
3053                 WaitCnt = 0;
3054
3055                 //wait oob tx disable
3056                 do {
3057                         TmpUchar = RE_CMAC_READ_1(sc, RE_CMAC_IBISR0);
3058
3059                         if (TmpUchar & ISRIMR_DASH_TYPE2_TX_DISABLE_IDLE) {
3060                                 break;
3061                         }
3062
3063                         DELAY(50);
3064                         WaitCnt++;
3065                 } while(WaitCnt < 2000);
3066
3067                 //Clear ISRIMR_DASH_TYPE2_TX_DISABLE_IDLE
3068                 RE_CMAC_WRITE_1(sc, RE_CMAC_IBISR0, RE_CMAC_READ_1(sc, RE_CMAC_IBISR0) | ISRIMR_DASH_TYPE2_TX_DISABLE_IDLE);
3069         }
3070 }
3071
3072 static void Dash2DisableRx(struct re_softc *sc)
3073 {
3074         //if (!sc->re_dash) return;
3075
3076         if (HW_DASH_SUPPORT_TYPE_2(sc) || HW_DASH_SUPPORT_TYPE_3(sc)) {
3077                 RE_CMAC_WRITE_1(sc, RE_CMAC_IBCR0, RE_CMAC_READ_1(sc, RE_CMAC_IBCR0) & ~(BIT_0));
3078         }
3079 }
3080
3081 static void Dash2DisableTxRx(struct re_softc *sc)
3082 {
3083         if (HW_DASH_SUPPORT_TYPE_2(sc) || HW_DASH_SUPPORT_TYPE_3(sc)) {
3084                 Dash2DisableTx(sc);
3085                 Dash2DisableRx(sc);
3086         }
3087 }
3088
3089 static inline bool
3090 is_zero_ether_addr(const u_int8_t * addr)
3091 {
3092         return ((addr[0] + addr[1] + addr[2] + addr[3] + addr[4] + addr[5]) == 0x00);
3093 }
3094
3095 static inline bool
3096 is_multicast_ether_addr(const u_int8_t * addr)
3097 {
3098         return (0x01 & addr[0]);
3099 }
3100
3101 /*
3102 static inline bool
3103 is_broadcast_ether_addr(const u_int8_t * addr)
3104 {
3105         return ((addr[0] + addr[1] + addr[2] + addr[3] + addr[4] + addr[5]) == (6 * 0xff));
3106 }
3107 */
3108
3109 static inline bool
3110 is_valid_ether_addr(const u_int8_t * addr)
3111 {
3112         return !is_multicast_ether_addr(addr) && !is_zero_ether_addr(addr);
3113 }
3114
3115 static inline void
3116 random_ether_addr(u_int8_t * dst)
3117 {
3118 #ifndef __DragonFly__
3119         if (read_random(dst, 6) == 0)
3120                 arc4rand(dst, 6, 0);
3121 #else
3122         karc4rand(dst, 6);
3123 #endif
3124
3125         dst[0] &= 0xfe;
3126         dst[0] |= 0x02;
3127 }
3128
3129 static void re_disable_now_is_oob(struct re_softc *sc)
3130 {
3131         if (sc->re_hw_supp_now_is_oob_ver == 1)
3132                 CSR_WRITE_1(sc, RE_MCU_CMD, CSR_READ_1(sc, RE_MCU_CMD) & ~RE_NOW_IS_OOB);
3133 }
3134
3135 static void re_exit_oob(struct re_softc *sc)
3136 {
3137         u_int16_t data16;
3138         int i;
3139
3140         re_disable_cfg9346_write(sc);
3141
3142         switch(sc->re_type) {
3143         case MACFG_61:
3144         case MACFG_62:
3145         case MACFG_67:
3146         case MACFG_70:
3147         case MACFG_71:
3148                 Dash2DisableTxRx(sc);
3149                 break;
3150         }
3151
3152         if (sc->re_dash)
3153                 re_driver_start(sc);
3154
3155         switch(sc->re_type) {
3156         case MACFG_56:
3157         case MACFG_57:
3158         case MACFG_58:
3159         case MACFG_59:
3160         case MACFG_60:
3161         case MACFG_61:
3162         case MACFG_62:
3163         case MACFG_67:
3164         case MACFG_68:
3165         case MACFG_69:
3166         case MACFG_70:
3167         case MACFG_71:
3168                 CSR_WRITE_1(sc, 0xF2, CSR_READ_1(sc, 0xF2) | BIT_3);
3169                 DELAY(2000);
3170
3171                 for (i = 0; i < 10; i++) {
3172                         DELAY(100);
3173                         if (CSR_READ_4(sc, RE_TXCFG) & BIT_11)
3174                                 break;
3175                 }
3176
3177                 if (CSR_READ_1(sc, RE_COMMAND) & (RE_CMD_TX_ENB | RE_CMD_RX_ENB)) {
3178                         DELAY(100);
3179                         CSR_WRITE_1(sc, RE_COMMAND, CSR_READ_1(sc, RE_COMMAND) & ~(RE_CMD_TX_ENB | RE_CMD_RX_ENB));
3180                 }
3181
3182                 for (i = 0; i < 10; i++) {
3183                         DELAY(100);
3184                         if ((CSR_READ_1(sc, RE_MCU_CMD) & (RE_TXFIFO_EMPTY | RE_RXFIFO_EMPTY)) == (RE_TXFIFO_EMPTY | RE_RXFIFO_EMPTY))
3185                                 break;
3186
3187                 }
3188                 break;
3189         }
3190
3191         //Disable realwow function
3192         switch (sc->re_type) {
3193         case MACFG_50:
3194         case MACFG_51:
3195                 CSR_WRITE_4(sc, RE_MCUACCESS, 0xE5A90000);
3196                 CSR_WRITE_4(sc, RE_MCUACCESS, 0xF2100010);
3197                 break;
3198         case MACFG_52:
3199                 CSR_WRITE_4(sc, RE_MCUACCESS, 0xE5A90000);
3200                 CSR_WRITE_4(sc, RE_MCUACCESS, 0xE4640000);
3201                 CSR_WRITE_4(sc, RE_MCUACCESS, 0xF2100010);
3202                 break;
3203         case MACFG_56:
3204         case MACFG_57:
3205                 CSR_WRITE_4(sc, RE_MCUACCESS, 0x605E0000);
3206                 CSR_WRITE_4(sc, RE_MCUACCESS, (0xE05E << 16) | (CSR_READ_4(sc, RE_MCUACCESS) & 0xFFFE));
3207                 CSR_WRITE_4(sc, RE_MCUACCESS, 0xE9720000);
3208                 CSR_WRITE_4(sc, RE_MCUACCESS, 0xF2140010);
3209                 break;
3210         case MACFG_60:
3211                 CSR_WRITE_4(sc, RE_MCUACCESS, 0xE05E00FF);
3212                 CSR_WRITE_4(sc, RE_MCUACCESS, 0xE9720000);
3213                 MP_WriteMcuAccessRegWord(sc, 0xE428, 0x0010);
3214                 break;
3215         }
3216
3217         if (sc->re_hw_supp_now_is_oob_ver >0)
3218                 re_disable_now_is_oob(sc);
3219
3220         switch(sc->re_type) {
3221         case MACFG_52:
3222                 for (i = 0; i < 10; i++) {
3223                         DELAY(100);
3224                         if (CSR_READ_2(sc, 0xD2) & BIT_9)
3225                                 break;
3226                 }
3227
3228                 data16 = MP_ReadMcuAccessRegWord(sc, 0xD4DE) | BIT_15;
3229                 MP_WriteMcuAccessRegWord(sc, 0xD4DE, data16);
3230
3231                 for (i = 0; i < 10; i++) {
3232                         DELAY(100);
3233                         if (CSR_READ_2(sc, 0xD2) & BIT_9)
3234                                 break;
3235                 }
3236                 break;
3237         case MACFG_56:
3238         case MACFG_57:
3239         case MACFG_58:
3240         case MACFG_59:
3241         case MACFG_60:
3242         case MACFG_61:
3243         case MACFG_62:
3244         case MACFG_67:
3245         case MACFG_68:
3246         case MACFG_69:
3247         case MACFG_70:
3248         case MACFG_71:
3249                 data16 = MP_ReadMcuAccessRegWord(sc, 0xE8DE) & ~BIT_14;
3250                 MP_WriteMcuAccessRegWord(sc, 0xE8DE, data16);
3251                 for (i = 0; i < 10; i++) {
3252                         DELAY(100);
3253                         if (CSR_READ_2(sc, 0xD2) & BIT_9)
3254                                 break;
3255                 }
3256
3257                 data16 = MP_ReadMcuAccessRegWord(sc, 0xE8DE) | BIT_15;
3258                 MP_WriteMcuAccessRegWord(sc, 0xE8DE, data16);
3259
3260                 for (i = 0; i < 10; i++) {
3261                         DELAY(100);
3262                         if (CSR_READ_2(sc, 0xD2) & BIT_9)
3263                                 break;
3264                 }
3265                 break;
3266         }
3267
3268         //wait ups resume (phy state 2)
3269         switch(sc->re_type) {
3270         case MACFG_68:
3271         case MACFG_69:
3272         case MACFG_70:
3273         case MACFG_71:
3274                 if (re_is_ups_resume(sc)) {
3275                         re_wait_phy_ups_resume(sc, 2);
3276                         re_clear_ups_resume_bit(sc);
3277                 }
3278                 break;
3279         };
3280
3281         /*
3282         * Config MAC MCU
3283         */
3284         re_hw_mac_mcu_config(sc);
3285 }
3286
3287 static void re_hw_init(struct re_softc *sc)
3288 {
3289         /*
3290         * disable EDT.
3291         */
3292         switch(sc->re_type) {
3293         case MACFG_16:
3294         case MACFG_17:
3295         case MACFG_18:
3296         case MACFG_19:
3297         case MACFG_41:
3298                 CSR_WRITE_1(sc, 0xF4, CSR_READ_1(sc, 0xF4) & ~(BIT_0|BIT_1));
3299                 break;
3300         case MACFG_36:
3301         case MACFG_37:
3302         case MACFG_38:
3303         case MACFG_39:
3304         case MACFG_42:
3305         case MACFG_43:
3306         case MACFG_50:
3307         case MACFG_51:
3308         case MACFG_54:
3309         case MACFG_55:
3310                 CSR_WRITE_1(sc, 0xF2, CSR_READ_1(sc, 0xF2) & ~(BIT_0|BIT_1|BIT_2));
3311                 break;
3312         }
3313
3314         switch(sc->re_type) {
3315         case MACFG_5:
3316                 if (CSR_READ_1(sc, RE_CFG2) & 1) {
3317                         CSR_WRITE_4(sc, 0x7C, 0x000FFFFF);
3318                 } else {
3319                         CSR_WRITE_4(sc, 0x7C, 0x000FFF00);
3320                 }
3321                 break;
3322         case MACFG_6:
3323                 if (CSR_READ_1(sc, RE_CFG2) & 1) {
3324                         CSR_WRITE_4(sc, 0x7C, 0x003FFFFF);
3325                 } else {
3326                         CSR_WRITE_4(sc, 0x7C, 0x003FFF00);
3327                 }
3328                 break;
3329         }
3330
3331         switch(sc->re_type) {
3332         case MACFG_33:
3333         case MACFG_36:
3334         case MACFG_37:
3335                 CSR_WRITE_1(sc, 0xF3, CSR_READ_1(sc, 0xF3) | BIT_2);
3336                 break;
3337         }
3338
3339         switch(sc->re_type) {
3340         case MACFG_36:
3341         case MACFG_37:
3342         case MACFG_38:
3343         case MACFG_39:
3344         case MACFG_42:
3345         case MACFG_43:
3346         case MACFG_50:
3347         case MACFG_51:
3348         case MACFG_52:
3349         case MACFG_53:
3350         case MACFG_54:
3351         case MACFG_55:
3352         case MACFG_56:
3353         case MACFG_57:
3354         case MACFG_58:
3355         case MACFG_59:
3356         case MACFG_60:
3357         case MACFG_61:
3358         case MACFG_62:
3359         case MACFG_67:
3360         case MACFG_68:
3361         case MACFG_69:
3362         case MACFG_70:
3363         case MACFG_71:
3364                 re_enable_cfg9346_write(sc);
3365                 CSR_WRITE_1(sc, RE_CFG5, CSR_READ_1(sc, RE_CFG5) & ~BIT_0);
3366                 CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2) & ~BIT_7);
3367                 CSR_WRITE_1(sc, 0xF1, CSR_READ_1(sc, 0xF1) & ~ BIT_7);
3368                 CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2) | BIT_5);
3369                 re_disable_cfg9346_write(sc);
3370                 break;
3371         }
3372
3373         if (sc->re_if_flags & RL_FLAG_PCIE) {
3374                 uint32_t Data32;
3375                 //Set PCIE uncorrectable error status mask pcie 0x108
3376                 Data32 = MP_ReadPciEConfigSpace(sc, 0xF108);
3377                 Data32 |= BIT_20;
3378                 MP_WritePciEConfigSpace(sc, 0xF108, Data32);
3379         }
3380 }
3381
3382 static void re_rar_set(struct re_softc *sc, u_int8_t *eaddr)
3383 {
3384         re_enable_cfg9346_write(sc);
3385
3386         CSR_WRITE_4(sc, RE_IDR0,
3387                     htole32(*(u_int32_t *)(&eaddr[0])));
3388         CSR_WRITE_2(sc, RE_IDR4,
3389                     htole16(*(u_int32_t *)(&eaddr[4])));
3390
3391         switch (sc->re_type) {
3392         case MACFG_36:
3393         case MACFG_37:
3394         case MACFG_42:
3395         case MACFG_43:
3396         case MACFG_54:
3397         case MACFG_55:
3398                 CSR_WRITE_4(sc, RE_SecMAC0,
3399                             htole32(*(u_int32_t *)(&eaddr[0])));
3400                 CSR_WRITE_2(sc, RE_SecMAC4,
3401                             htole16(*(u_int16_t *)(&eaddr[4])));
3402                 break;
3403         }
3404
3405         switch (sc->re_type) {
3406         case MACFG_38:
3407         case MACFG_39:
3408                 re_eri_write(sc, 0xF0, 4, *(u_int16_t *)(&eaddr[0])<<16, ERIAR_ExGMAC);
3409                 re_eri_write(sc, 0xF4, 4, *(u_int32_t *)(&eaddr[2]), ERIAR_ExGMAC);
3410                 break;
3411         }
3412
3413         re_disable_cfg9346_write(sc);
3414 }
3415
3416 static void re_get_hw_mac_address(struct re_softc *sc, u_int8_t *eaddr)
3417 {
3418         device_t dev = sc->dev;
3419         u_int16_t re_eeid = 0;
3420         int i;
3421
3422         for (i = 0; i < ETHER_ADDR_LEN; i++)
3423                 eaddr[i] = CSR_READ_1(sc, RE_IDR0 + i);
3424
3425         switch(sc->re_type) {
3426         case MACFG_50:
3427         case MACFG_51:
3428         case MACFG_52:
3429         case MACFG_53:
3430         case MACFG_56:
3431         case MACFG_57:
3432         case MACFG_58:
3433         case MACFG_59:
3434         case MACFG_60:
3435         case MACFG_61:
3436         case MACFG_62:
3437         case MACFG_67:
3438         case MACFG_68:
3439         case MACFG_69:
3440         case MACFG_70:
3441         case MACFG_71:
3442                 *(u_int32_t *)&eaddr[0] = re_eri_read(sc, 0xE0, 4, ERIAR_ExGMAC);
3443                 *(u_int16_t *)&eaddr[4] = (u_int16_t)re_eri_read(sc, 0xE4, 4, ERIAR_ExGMAC);
3444                 break;
3445         case MACFG_63:
3446         case MACFG_64:
3447         case MACFG_65:
3448         case MACFG_66:
3449                 break;
3450         default:
3451                 re_read_eeprom(sc, (caddr_t)&re_eeid, RE_EE_ID, 1, 0);
3452                 if (re_eeid == 0x8129)
3453                         re_read_eeprom(sc, (caddr_t)&eaddr[0], RE_EE_EADDR, 3, 0);
3454                 break;
3455         }
3456
3457         if (!is_valid_ether_addr(eaddr)) {
3458 #ifndef __DragonFly__
3459                 device_printf(dev,"Invalid ether addr: %6D\n", eaddr, ":");
3460 #else
3461                 device_printf(dev, "Invalid ether addr: "
3462                     "%02x:%02x:%02x:%02x:%02x:%02x\n",
3463                     eaddr[0], eaddr[1], eaddr[2], eaddr[3], eaddr[4], eaddr[5]);
3464 #endif
3465                 random_ether_addr(eaddr);
3466 #ifndef __DragonFly__
3467                 device_printf(dev,"Random ether addr: %6D\n", eaddr, ":");
3468 #else
3469                 device_printf(dev, "Random ether addr: "
3470                     "%02x:%02x:%02x:%02x:%02x:%02x\n",
3471                     eaddr[0], eaddr[1], eaddr[2], eaddr[3], eaddr[4], eaddr[5]);
3472 #endif
3473         }
3474
3475         re_rar_set(sc, eaddr);
3476 }
3477
3478 static int re_check_mac_version(struct re_softc *sc)
3479 {
3480         device_t dev = sc->dev;
3481         int error = 0;
3482
3483         switch(CSR_READ_4(sc, RE_TXCFG) & 0xFCF00000) {
3484         case 0x00800000:
3485         case 0x04000000:
3486                 sc->re_type = MACFG_3;
3487                 sc->max_jumbo_frame_size = Jumbo_Frame_7k;
3488                 CSR_WRITE_4(sc, RE_RXCFG, 0xFF00);
3489                 break;
3490         case 0x10000000:
3491                 sc->re_type = MACFG_4;
3492                 sc->max_jumbo_frame_size = Jumbo_Frame_7k;
3493                 CSR_WRITE_4(sc, RE_RXCFG, 0xFF00);
3494                 break;
3495         case 0x18000000:
3496                 sc->re_type = MACFG_5;
3497                 sc->max_jumbo_frame_size = Jumbo_Frame_7k;
3498                 CSR_WRITE_4(sc, RE_RXCFG, 0xFF00);
3499                 break;
3500         case 0x98000000:
3501                 sc->re_type = MACFG_6;
3502                 sc->max_jumbo_frame_size = Jumbo_Frame_7k;
3503                 CSR_WRITE_4(sc, RE_RXCFG, 0xFF00);
3504                 break;
3505         case 0x34000000:
3506         case 0xB4000000:
3507                 sc->re_type = MACFG_11;
3508                 sc->max_jumbo_frame_size = ETHERMTU;
3509                 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
3510                 break;
3511         case 0x34200000:
3512         case 0xB4200000:
3513                 sc->re_type = MACFG_12;
3514                 sc->max_jumbo_frame_size = ETHERMTU;
3515                 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
3516                 break;
3517         case 0x34300000:
3518         case 0xB4300000:
3519                 sc->re_type = MACFG_13;
3520                 sc->max_jumbo_frame_size = ETHERMTU;
3521                 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
3522                 break;
3523         case 0x34900000:
3524         case 0x24900000:
3525                 sc->re_type = MACFG_14;
3526                 sc->max_jumbo_frame_size = ETHERMTU;
3527                 sc->re_if_flags |= RL_FLAG_DESCV2;
3528                 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
3529                 break;
3530         case 0x34A00000:
3531         case 0x24A00000:
3532                 sc->re_type = MACFG_15;
3533                 sc->max_jumbo_frame_size = ETHERMTU;
3534                 sc->re_if_flags |= RL_FLAG_DESCV2;
3535                 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
3536                 break;
3537         case 0x34B00000:
3538         case 0x24B00000:
3539                 sc->re_type = MACFG_16;
3540                 sc->max_jumbo_frame_size = ETHERMTU;
3541                 sc->re_if_flags |= RL_FLAG_DESCV2;
3542                 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
3543                 break;
3544         case 0x34C00000:
3545         case 0x24C00000:
3546                 sc->re_type = MACFG_17;
3547                 sc->max_jumbo_frame_size = ETHERMTU;
3548                 sc->re_if_flags |= RL_FLAG_DESCV2;
3549                 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
3550                 break;
3551         case 0x34D00000:
3552         case 0x24D00000:
3553                 sc->re_type = MACFG_18;
3554                 sc->max_jumbo_frame_size = ETHERMTU;
3555                 sc->re_if_flags |= RL_FLAG_DESCV2;
3556                 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
3557                 break;
3558         case 0x34E00000:
3559         case 0x24E00000:
3560                 sc->re_type = MACFG_19;
3561                 sc->max_jumbo_frame_size = ETHERMTU;
3562                 sc->re_if_flags |= RL_FLAG_DESCV2;
3563                 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
3564                 break;
3565         case 0x30000000:
3566                 sc->re_type = MACFG_21;
3567                 sc->max_jumbo_frame_size = Jumbo_Frame_4k;
3568                 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
3569                 break;
3570         case 0x38000000:
3571                 sc->re_type = MACFG_22;
3572                 sc->max_jumbo_frame_size = Jumbo_Frame_4k;
3573                 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
3574                 break;
3575         case 0x38500000:
3576         case 0xB8500000:
3577         case 0x38700000:
3578         case 0xB8700000:
3579                 sc->re_type = MACFG_23;
3580                 sc->max_jumbo_frame_size = Jumbo_Frame_4k;
3581                 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
3582                 break;
3583         case 0x3C000000:
3584                 sc->re_type = MACFG_24;
3585                 sc->max_jumbo_frame_size = Jumbo_Frame_6k;
3586                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
3587                 CSR_WRITE_4(sc, RE_RXCFG, 0xC700);
3588                 break;
3589         case 0x3C200000:
3590                 sc->re_type = MACFG_25;
3591                 sc->max_jumbo_frame_size = Jumbo_Frame_6k;
3592                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
3593                 CSR_WRITE_4(sc, RE_RXCFG, 0xC700);
3594                 break;
3595         case 0x3C400000:
3596                 sc->re_type = MACFG_26;
3597                 sc->max_jumbo_frame_size = Jumbo_Frame_6k;
3598                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
3599                 CSR_WRITE_4(sc, RE_RXCFG, 0xC700);
3600                 break;
3601         case 0x3C900000:
3602                 sc->re_type = MACFG_27;
3603                 sc->max_jumbo_frame_size = Jumbo_Frame_6k;
3604                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
3605                 CSR_WRITE_4(sc, RE_RXCFG, 0xC700);
3606                 break;
3607         case 0x3CB00000:
3608                 sc->re_type = MACFG_28;
3609                 sc->max_jumbo_frame_size = Jumbo_Frame_6k;
3610                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
3611                 CSR_WRITE_4(sc, RE_RXCFG, 0xC700);
3612                 break;
3613         case 0x28100000:
3614                 sc->re_type = MACFG_31;
3615                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3616                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
3617                 CSR_WRITE_4(sc, RE_RXCFG, 0x8700);
3618                 break;
3619         case 0x28200000:
3620                 sc->re_type = MACFG_32;
3621                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3622                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
3623                 CSR_WRITE_4(sc, RE_RXCFG, 0x8700);
3624                 break;
3625         case 0x28300000:
3626                 sc->re_type = MACFG_33;
3627                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3628                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
3629                 CSR_WRITE_4(sc, RE_RXCFG, 0x8700);
3630                 break;
3631         case 0x2C100000:
3632                 sc->re_type = MACFG_36;
3633                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3634                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
3635                 CSR_WRITE_4(sc, RE_RXCFG, 0x8700);
3636                 break;
3637         case 0x2C200000:
3638                 sc->re_type = MACFG_37;
3639                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3640                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
3641                 CSR_WRITE_4(sc, RE_RXCFG, 0x8700);
3642                 break;
3643         case 0x2C800000:
3644                 sc->re_type = MACFG_38;
3645                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3646                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
3647                 CSR_WRITE_4(sc, RE_RXCFG, 0xBF00);
3648                 break;
3649         case 0x2C900000:
3650                 sc->re_type = MACFG_39;
3651                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3652                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
3653                 CSR_WRITE_4(sc, RE_RXCFG, 0xBF00);
3654                 break;
3655         case 0x24000000:
3656                 sc->re_type = MACFG_41;
3657                 sc->max_jumbo_frame_size = ETHERMTU;
3658                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
3659                 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
3660                 break;
3661         case 0x40900000:
3662                 sc->re_type = MACFG_42;
3663                 sc->max_jumbo_frame_size = ETHERMTU;
3664                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
3665                 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
3666                 break;
3667         case 0x40A00000:
3668         case 0x40B00000:
3669         case 0x40C00000:
3670                 sc->re_type = MACFG_43;
3671                 sc->max_jumbo_frame_size = ETHERMTU;
3672                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
3673                 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
3674                 break;
3675         case 0x48000000:
3676                 sc->re_type = MACFG_50;
3677                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3678                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
3679                 CSR_WRITE_4(sc, RE_RXCFG, 0xBF00);
3680                 break;
3681         case 0x48100000:
3682                 sc->re_type = MACFG_51;
3683                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3684                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
3685                 CSR_WRITE_4(sc, RE_RXCFG, 0xBF00);
3686                 break;
3687         case 0x48800000:
3688                 sc->re_type = MACFG_52;
3689                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3690                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
3691                 CSR_WRITE_4(sc, RE_RXCFG, 0xBF00);
3692                 break;
3693         case 0x44000000:
3694                 sc->re_type = MACFG_53;
3695                 sc->max_jumbo_frame_size = ETHERMTU;
3696                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
3697                 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
3698                 break;
3699         case 0x44800000:
3700                 sc->re_type = MACFG_54;
3701                 sc->max_jumbo_frame_size = ETHERMTU;
3702                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
3703                 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
3704                 break;
3705         case 0x44900000:
3706                 sc->re_type = MACFG_55;
3707                 sc->max_jumbo_frame_size = ETHERMTU;
3708                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
3709                 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
3710                 break;
3711         case 0x4C000000:
3712                 sc->re_type = MACFG_56;
3713                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3714                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
3715                 CSR_WRITE_4(sc, RE_RXCFG, 0xCF00);
3716                 break;
3717         case 0x4C100000:
3718                 sc->re_type = MACFG_57;
3719                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3720                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
3721                 CSR_WRITE_4(sc, RE_RXCFG, 0xCF00);
3722                 break;
3723         case 0x50800000:
3724                 sc->re_type = MACFG_58;
3725                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3726                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
3727                 CSR_WRITE_4(sc, RE_RXCFG, 0xCF00);
3728                 break;
3729         case 0x50900000:
3730                 sc->re_type = MACFG_59;
3731                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3732                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
3733                 CSR_WRITE_4(sc, RE_RXCFG, 0xCF00);
3734                 break;
3735         case 0x5C800000:
3736                 sc->re_type = MACFG_60;
3737                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3738                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
3739                 CSR_WRITE_4(sc, RE_RXCFG, 0xCF00);
3740                 break;
3741         case 0x50000000:
3742                 sc->re_type = MACFG_61;
3743                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3744                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
3745                 CSR_WRITE_4(sc, RE_RXCFG, 0xCF00);
3746                 break;
3747         case 0x50100000:
3748                 sc->re_type = MACFG_62;
3749                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3750                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
3751                 CSR_WRITE_4(sc, RE_RXCFG, 0xCF00);
3752                 break;
3753         case 0x50200000:
3754                 sc->re_type = MACFG_67;
3755                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3756                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
3757                 CSR_WRITE_4(sc, RE_RXCFG, 0xCF00);
3758                 break;
3759         case 0x28800000:
3760                 sc->re_type = MACFG_63;
3761                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3762                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
3763                 CSR_WRITE_4(sc, RE_RXCFG, 0x8700);
3764                 break;
3765         case 0x28900000:
3766                 sc->re_type = MACFG_64;
3767                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3768                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
3769                 CSR_WRITE_4(sc, RE_RXCFG, 0x8700);
3770                 break;
3771         case 0x28A00000:
3772                 sc->re_type = MACFG_65;
3773                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3774                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
3775                 CSR_WRITE_4(sc, RE_RXCFG, 0x8700);
3776                 break;
3777         case 0x28B00000:
3778                 sc->re_type = MACFG_66;
3779                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3780                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
3781                 CSR_WRITE_4(sc, RE_RXCFG, 0x8700);
3782                 break;
3783         case 0x54000000:
3784                 sc->re_type = MACFG_68;
3785                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3786                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
3787                 CSR_WRITE_4(sc, RE_RXCFG, 0xCF00);
3788                 break;
3789         case 0x54100000:
3790                 sc->re_type = MACFG_69;
3791                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3792                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
3793                 CSR_WRITE_4(sc, RE_RXCFG, 0xCF00);
3794                 break;
3795         case 0x54900000:
3796                 sc->re_type = MACFG_70;
3797                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3798                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
3799                 CSR_WRITE_4(sc, RE_RXCFG, 0xCF00);
3800                 break;
3801         case 0x54A00000:
3802                 sc->re_type = MACFG_71;
3803                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3804                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
3805                 CSR_WRITE_4(sc, RE_RXCFG, 0xCF00);
3806                 break;
3807         default:
3808                 device_printf(dev,"unknown device\n");
3809                 sc->re_type = MACFG_FF;
3810                 error = ENXIO;
3811                 break;
3812         }
3813
3814         switch(sc->re_device_id) {
3815         case RT_DEVICEID_8169:
3816         case RT_DEVICEID_8169SC:
3817         case RT_DEVICEID_8168:
3818         case RT_DEVICEID_8161:
3819                 //do nothing
3820                 break;
3821         default:
3822                 sc->max_jumbo_frame_size = ETHERMTU;
3823                 break;
3824         }
3825
3826         return error;
3827 }
3828
3829 static void re_init_software_variable(struct re_softc *sc)
3830 {
3831         switch(sc->re_device_id) {
3832         case RT_DEVICEID_8168:
3833         case RT_DEVICEID_8161:
3834         case RT_DEVICEID_8136:
3835                 sc->re_if_flags |= RL_FLAG_PCIE;
3836                 break;
3837         }
3838
3839         sc->re_rx_mbuf_sz = sc->max_jumbo_frame_size + ETHER_VLAN_ENCAP_LEN + ETHER_HDR_LEN + ETHER_CRC_LEN + RE_ETHER_ALIGN + 1;
3840
3841         if (sc->re_rx_mbuf_sz > MJUM9BYTES) {
3842                 sc->max_jumbo_frame_size -= (sc->re_rx_mbuf_sz - MJUM9BYTES);
3843                 sc->re_rx_mbuf_sz = MJUM9BYTES;
3844         }
3845
3846         switch(sc->re_type) {
3847         case MACFG_63:
3848         case MACFG_64:
3849         case MACFG_65:
3850         case MACFG_66:
3851                 sc->HwSuppDashVer = 1;
3852                 break;
3853         case MACFG_61:
3854         case MACFG_62:
3855         case MACFG_67:
3856                 sc->HwSuppDashVer = 2;
3857                 break;
3858         case MACFG_70:
3859         case MACFG_71:
3860                 sc->HwSuppDashVer = 3;
3861                 break;
3862         default:
3863                 sc->HwSuppDashVer = 0;
3864                 break;
3865         }
3866
3867         switch(sc->re_type) {
3868         case MACFG_70:
3869         case MACFG_71:
3870                 sc->HwPkgDet = MP_ReadMcuAccessRegWord(sc, 0xDC00);
3871                 sc->HwPkgDet = (sc->HwPkgDet >> 3) & 0x0F;
3872                 //printf("Realtek PCIe GBE Family Controller HwPkgDet = 0x%02X\n",
3873                 //       sc->HwPkgDet);
3874                 break;
3875         }
3876
3877         if (HW_DASH_SUPPORT_TYPE_3(sc) && sc->HwPkgDet == 0x06)
3878                 eee_enable = 0;
3879
3880         if (HW_DASH_SUPPORT_DASH(sc))
3881                 sc->re_dash = re_check_dash(sc);
3882
3883         if (sc->re_dash) {
3884                 if (HW_DASH_SUPPORT_TYPE_3(sc)) {
3885                         u_int64_t CmacMemPhysAddress;
3886                         bus_space_handle_t cmac_ioaddr;
3887
3888                         CmacMemPhysAddress = MP_ReadOtherFunPciEConfigSpace(sc, 0, 0xf018);
3889                         if (!(CmacMemPhysAddress & BIT_0)) {
3890                                 if (CmacMemPhysAddress & BIT_2)
3891                                         CmacMemPhysAddress |=  MP_ReadOtherFunPciEConfigSpace(sc, 0, 0xf01c) << 16;
3892
3893                                 CmacMemPhysAddress &=  0xFFFFFFF0;
3894                                 /* ioremap MMIO region */
3895 #ifndef __DragonFly__
3896                                 sc->re_mapped_cmac_tag = X86_BUS_SPACE_MEM;
3897 #else
3898                                 sc->re_mapped_cmac_tag = X86_64_BUS_SPACE_MEM;
3899 #endif
3900                                 if (bus_space_map(sc->re_mapped_cmac_tag, CmacMemPhysAddress, RE_REGS_SIZE, 0,
3901                                                   &cmac_ioaddr))
3902                                         sc->re_dash = 0;
3903                                 else
3904                                         sc->re_mapped_cmac_handle = cmac_ioaddr;
3905                         }
3906                 }
3907         }
3908
3909         switch(sc->re_type) {
3910         case MACFG_61:
3911         case MACFG_62:
3912         case MACFG_67:
3913                 sc->re_cmac_handle = sc->re_bhandle;
3914                 sc->re_cmac_tag = sc->re_btag;
3915                 break;
3916         case MACFG_70:
3917         case MACFG_71:
3918                 sc->re_cmac_handle = sc->re_mapped_cmac_handle;
3919                 sc->re_cmac_tag = sc->re_mapped_cmac_tag;
3920                 break;
3921         }
3922
3923         switch(sc->re_type) {
3924         case MACFG_14:
3925         case MACFG_15:
3926         case MACFG_16:
3927         case MACFG_17:
3928         case MACFG_18:
3929         case MACFG_19:
3930         case MACFG_31:
3931         case MACFG_32:
3932         case MACFG_33:
3933         case MACFG_41:
3934         case MACFG_63:
3935         case MACFG_64:
3936         case MACFG_65:
3937         case MACFG_66:
3938                 sc->re_efuse_ver = EFUSE_SUPPORT_V1;
3939                 break;
3940         case MACFG_36:
3941         case MACFG_37:
3942         case MACFG_42:
3943         case MACFG_43:
3944         case MACFG_54:
3945         case MACFG_55:
3946                 sc->re_efuse_ver = EFUSE_SUPPORT_V2;
3947                 break;
3948         case MACFG_38:
3949         case MACFG_39:
3950         case MACFG_50:
3951         case MACFG_51:
3952         case MACFG_52:
3953         case MACFG_53:
3954         case MACFG_56:
3955         case MACFG_57:
3956         case MACFG_58:
3957         case MACFG_59:
3958         case MACFG_60:
3959         case MACFG_61:
3960         case MACFG_62:
3961         case MACFG_67:
3962         case MACFG_68:
3963         case MACFG_69:
3964         case MACFG_70:
3965         case MACFG_71:
3966                 sc->re_efuse_ver = EFUSE_SUPPORT_V3;
3967                 break;
3968         default:
3969                 sc->re_efuse_ver = EFUSE_NOT_SUPPORT;
3970                 break;
3971         }
3972
3973         switch(sc->re_type) {
3974         case MACFG_69: {
3975                 u_int16_t ioffset_p3, ioffset_p2, ioffset_p1, ioffset_p0;
3976                 u_int16_t TmpUshort;
3977
3978                 MP_WriteMcuAccessRegWord(sc, 0xDD02, 0x807D);
3979
3980                 TmpUshort = MP_ReadMcuAccessRegWord(sc, 0xDD02);
3981                 ioffset_p3 = ((TmpUshort & BIT_7) >>7);