diff --git a/sys/cpu/x86_64/include/bus_dma.h b/sys/cpu/x86_64/include/bus_dma.h
index 4e5b133445..c99fbab336 100644
--- a/sys/cpu/x86_64/include/bus_dma.h
+++ b/sys/cpu/x86_64/include/bus_dma.h
@@ -57,33 +57,13 @@ typedef uint64_t bus_space_handle_t;
 /*
  * Map a region of device bus space into CPU virtual address space.
  */
-
-static __inline int bus_space_map(bus_space_tag_t t, bus_addr_t addr,
-				  bus_size_t size, int flags,
-				  bus_space_handle_t *bshp);
-
-static __inline int
-bus_space_map(bus_space_tag_t t __unused, bus_addr_t addr,
-	      bus_size_t size __unused, int flags __unused,
-	      bus_space_handle_t *bshp)
-{
-
-	*bshp = addr;
-	return (0);
-}
+int bus_space_map(bus_space_tag_t, bus_addr_t, bus_size_t, int,
+		  bus_space_handle_t *);
 
 /*
  * Unmap a region of device bus space.
  */
-
-static __inline void bus_space_unmap(bus_space_tag_t t, bus_space_handle_t bsh,
-				     bus_size_t size);
-
-static __inline void
-bus_space_unmap(bus_space_tag_t t __unused, bus_space_handle_t bsh __unused,
-		bus_size_t size __unused)
-{
-}
+void bus_space_unmap(bus_space_tag_t, bus_space_handle_t, bus_size_t);
 
 /*
  * Get a new handle for a subregion of an already-mapped area of bus space.
diff --git a/sys/dev/netif/re/if_re.c b/sys/dev/netif/re/if_re.c
index 60b5b983e7..901544a023 100644
--- a/sys/dev/netif/re/if_re.c
+++ b/sys/dev/netif/re/if_re.c
@@ -871,6 +871,7 @@ re_detach(device_t dev)
 		bus_release_resource(dev, sc->re_res_type, sc->re_res_rid,
 		    sc->re_res);
 	}
+	rtl_cmac_unmap(sc);
 
 	/* Free DMA stuffs */
 	re_freemem(dev);
diff --git a/sys/dev/netif/re/if_revar.h b/sys/dev/netif/re/if_revar.h
index 3de265e216..4d53630109 100644
--- a/sys/dev/netif/re/if_revar.h
+++ b/sys/dev/netif/re/if_revar.h
@@ -180,6 +180,17 @@ struct re_softc {
 	struct ifmedia		media;
 	u_int16_t		cur_page;
 	u_int8_t		re_unit;
+	u_int8_t		re_efuse_ver;
+	u_int16_t		re_sw_ram_code_ver;
+	u_int16_t		re_hw_ram_code_ver;
+	u_int8_t		RequiredSecLanDonglePatch;
+	u_int8_t		HwSuppDashVer;
+	u_int8_t		re_dash;
+	bus_space_handle_t	re_mapped_cmac_handle;	/* bus space tag */
+	bus_space_tag_t		re_mapped_cmac_tag;	/* bus space tag */
+	bus_space_handle_t	re_cmac_handle;		/* bus space handle */
+	bus_space_tag_t		re_cmac_tag;		/* bus space tag */
+	u_int8_t		HwPkgDet;
 };
 
 #define RE_C_HWIM		0x4	/* hardware interrupt moderation */
diff --git a/sys/dev/netif/re/re.c b/sys/dev/netif/re/re.c
index dfe6b3a706..16958e8335 100644
--- a/sys/dev/netif/re/re.c
+++ b/sys/dev/netif/re/re.c
@@ -42,7 +42,7 @@
 
 #ifndef __DragonFly__
 #include <sys/cdefs.h>
-__FBSDID("$FreeBSD: src/sys/dev/re/if_re.c,v 1.93 " __DATE__ " " __TIME__ "  wpaul Exp $");
+__FBSDID("$FreeBSD: src/sys/dev/re/if_re.c,v 1.94.01 " __DATE__ " " __TIME__ "  wpaul Exp $");
 
 /*
 * This driver also support Realtek 8139C+, 8110S/SB/SC, RTL8111B/C/CP/D and RTL8101E/8102E/8103E.
@@ -56,6 +56,7 @@ __FBSDID("$FreeBSD: src/sys/dev/re/if_re.c,v 1.93 " __DATE__ " " __TIME__ "  wpa
 #include <sys/kernel.h>
 #include <sys/socket.h>
 #include <sys/taskqueue.h>
+#include <sys/random.h>
 
 #include <net/if.h>
 #include <net/if_var.h>
@@ -184,11 +185,15 @@ static void MP_WritePhyOcpRegWord       __P((struct re_softc*, u_int16_t, u_int8
 static u_int16_t MP_ReadPhyOcpRegWord   __P((struct re_softc*, u_int16_t, u_int8_t));
 static void MP_WriteMcuAccessRegWord    __P((struct re_softc*, u_int16_t, u_int16_t));
 static u_int16_t MP_ReadMcuAccessRegWord  __P((struct re_softc*, u_int16_t));
+static void MP_WriteOtherFunPciEConfigSpace    __P((struct re_softc *, u_int8_t, u_int16_t, u_int32_t Regata));
+static u_int32_t MP_ReadOtherFunPciEConfigSpace   __P((struct re_softc *, u_int8_t, u_int16_t));
 static void MP_WritePciEConfigSpace     __P((struct re_softc*, u_int16_t, u_int32_t));
 static u_int32_t MP_ReadPciEConfigSpace __P((struct re_softc*, u_int16_t));
+#endif	/* !__DragonFly__ */
 
 static int re_check_dash  __P((struct re_softc *));
 
+#ifndef __DragonFly__
 static void re_driver_start             __P((struct re_softc*));
 static void re_driver_stop         	__P((struct re_softc*));
 
@@ -200,9 +205,9 @@ static void re_stop			__P((struct re_softc *));
 static void re_setwol			__P((struct re_softc *));
 #endif	/* !__DragonFly__ */
 static void re_clrwol			__P((struct re_softc *));
-#ifndef __DragonFly__
 static void re_set_wol_linkspeed 	__P((struct re_softc *));
 
+#ifndef __DragonFly__
 static void re_start				__P((struct ifnet *));
 static int re_encap				__P((struct re_softc *, struct mbuf *));
 static void WritePacket				__P((struct re_softc *, caddr_t, int, int, int, uint32_t, uint32_t));
@@ -264,8 +269,8 @@ static void set_rxbufsize(struct re_softc*);
 static void re_release_rx_buf(struct re_softc *);
 static void re_release_tx_buf(struct re_softc *);
 #endif	/* !__DragonFly__ */
-static u_int32_t re_eri_read(struct re_softc *, int , int , int);
-static int re_eri_write(struct re_softc *, int , int , u_int32_t, int);
+static u_int32_t re_eri_read(struct re_softc *, int, int, int);
+static int re_eri_write(struct re_softc *, int, int, u_int32_t, int);
 static void OOB_mutex_lock(struct re_softc *);
 static void OOB_mutex_unlock(struct re_softc *);
 
@@ -281,6 +286,10 @@ u_int16_t MP_ReadPhyUshort(struct re_softc *, u_int8_t);
 
 u_int32_t MP_ReadPciEConfigSpace(struct re_softc *, u_int16_t);
 void MP_WritePciEConfigSpace(struct re_softc *, u_int16_t, u_int32_t);
+u_int32_t MP_ReadOtherFunPciEConfigSpace(struct re_softc *, u_int8_t,
+    u_int16_t);
+void MP_WriteOtherFunPciEConfigSpace(struct re_softc *, u_int8_t, u_int16_t,
+    u_int32_t);
 
 u_int16_t MP_ReadEPhyUshort(struct re_softc *, u_int8_t);
 void MP_WriteEPhyUshort(struct re_softc *, u_int8_t, u_int16_t);
@@ -310,12 +319,12 @@ TUNABLE_INT("hw.re.phy_mdix_mode", &phy_mdix_mode);
 #ifndef __DragonFly__
 static device_method_t re_methods[] = {
         /* Device interface */
-        DEVMETHOD(device_probe,		re_probe),
-        DEVMETHOD(device_attach,	re_attach),
-        DEVMETHOD(device_detach,	re_detach),
-        DEVMETHOD(device_suspend,   re_suspend),
-        DEVMETHOD(device_resume,    re_resume),
-        DEVMETHOD(device_shutdown,	re_shutdown),
+        DEVMETHOD(device_probe, re_probe),
+        DEVMETHOD(device_attach, re_attach),
+        DEVMETHOD(device_detach, re_detach),
+        DEVMETHOD(device_suspend, re_suspend),
+        DEVMETHOD(device_resume, re_resume),
+        DEVMETHOD(device_shutdown, re_shutdown),
         { 0, 0 }
 };
 
@@ -414,6 +423,8 @@ static void re_phy_power_up(device_t dev)
         switch(sc->re_type) {
         case MACFG_68:
         case MACFG_69:
+        case MACFG_70:
+        case MACFG_71:
                 re_wait_phy_ups_resume(sc, 3);
                 break;
         };
@@ -426,6 +437,11 @@ static void re_phy_power_down(device_t dev)
 
         sc = device_get_softc(dev);
 
+        if (sc->re_dash) {
+                re_set_wol_linkspeed(sc);
+                return;
+        }
+
         MP_WritePhyUshort(sc, 0x1F, 0x0000);
 
         switch (sc->re_type) {
@@ -559,10 +575,11 @@ device_t		dev;
 #endif	/* !__DragonFly__ */
 
 
-static u_int32_t re_eri_read(struct re_softc *sc, int addr, int len, int type)
+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)
 {
         int i, val_shift, shift = 0;
         u_int32_t value1 = 0, value2 = 0, mask;
+        const u_int32_t transformed_base_address = ((base_address & 0x00FFF000) << 6) | (base_address & 0x000FFF);
 
         if (len > 4 || len <= 0)
                 return -1;
@@ -573,6 +590,7 @@ static u_int32_t re_eri_read(struct re_softc *sc, int addr, int len, int type)
 
                 CSR_WRITE_4(sc,RE_ERIAR,
                             ERIAR_Read |
+                            transformed_base_address |
                             type << ERIAR_Type_shift |
                             ERIAR_ByteEn << ERIAR_ByteEn_shift |
                             addr);
@@ -605,11 +623,17 @@ static u_int32_t re_eri_read(struct re_softc *sc, int addr, int len, int type)
         return value2;
 }
 
-static int re_eri_write(struct re_softc *sc, int addr, int len, u_int32_t value, int type)
+static u_int32_t re_eri_read(struct re_softc *sc, int addr, int len, int type)
+{
+        return re_eri_read_with_oob_base_address(sc, addr, len, type, 0);
+}
+
+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)
 {
 
         int i, val_shift, shift = 0;
         u_int32_t value1 = 0, mask;
+        const u_int32_t transformed_base_address = ((base_address & 0x00FFF000) << 6) | (base_address & 0x000FFF);
 
         if (len > 4 || len <= 0)
                 return -1;
@@ -623,12 +647,13 @@ static int re_eri_write(struct re_softc *sc, int addr, int len, u_int32_t value,
                 else if (len == 3)	mask = (0xFFFFFF << (val_shift * 8)) & 0xFFFFFFFF;
                 else			mask = (0xFFFFFFFF << (val_shift * 8)) & 0xFFFFFFFF;
 
-                value1 = re_eri_read(sc, addr, 4, type) & ~mask;
+                value1 = re_eri_read_with_oob_base_address(sc, addr, 4, type, base_address) & ~mask;
                 value1 |= ((value << val_shift * 8) >> shift * 8);
 
                 CSR_WRITE_4(sc,RE_ERIDR, value1);
                 CSR_WRITE_4(sc,RE_ERIAR,
                             ERIAR_Write |
+                            transformed_base_address |
                             type << ERIAR_Type_shift |
                             ERIAR_ByteEn << ERIAR_ByteEn_shift |
                             addr);
@@ -653,6 +678,11 @@ static int re_eri_write(struct re_softc *sc, int addr, int len, u_int32_t value,
         return 0;
 }
 
+static int re_eri_write(struct re_softc *sc, int addr, int len, u_int32_t value, int type)
+{
+        return re_eri_write_with_oob_base_address(sc, addr, len, value, type, 0);
+}
+
 static void
 ClearAndSetEthPhyBit(
         struct re_softc *sc,
@@ -848,9 +878,28 @@ static void set_rxbufsize(struct re_softc *sc)
 }
 #endif	/* !__DragonFly__ */
 
+static void re_enable_cfg9346_write(struct re_softc *sc)
+{
+        EE_SET(RE_EEMODE_WRITECFG);
+}
+
+static void re_disable_cfg9346_write(struct re_softc *sc)
+{
+        EE_CLR(RE_EEMODE_WRITECFG);
+}
+
 static void DisableMcuBPs(struct re_softc *sc)
 {
         switch(sc->re_type) {
+        case MACFG_68:
+        case MACFG_69:
+        case MACFG_70:
+        case MACFG_71:
+                MP_WriteMcuAccessRegWord(sc, 0xFC38, 0x0000);
+                break;
+        }
+
+        switch(sc->re_type) {
         case MACFG_56:
         case MACFG_57:
         case MACFG_58:
@@ -861,10 +910,12 @@ static void DisableMcuBPs(struct re_softc *sc)
         case MACFG_67:
         case MACFG_68:
         case MACFG_69:
-                CSR_WRITE_1(sc, RE_EECMD, RE_EEMODE_WRITECFG);
+        case MACFG_70:
+        case MACFG_71:
+                re_enable_cfg9346_write(sc);
                 CSR_WRITE_1(sc, RE_CFG5, CSR_READ_1(sc, RE_CFG5) & ~BIT_0);
                 CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2) & ~BIT_7);
-                CSR_WRITE_1(sc, RE_EECMD, RE_EEMODE_OFF);
+                re_disable_cfg9346_write(sc);
 
                 MP_WriteMcuAccessRegWord(sc, 0xFC28, 0x0000);
                 MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x0000);
@@ -880,1364 +931,2110 @@ static void DisableMcuBPs(struct re_softc *sc)
                 MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x0000);
                 break;
         }
+}
+
+static void re_set_mac_mcu_8168g_1(struct re_softc *sc)
+{
+        MP_WriteMcuAccessRegWord(sc, 0xE43C, 0x0000);
+        MP_WriteMcuAccessRegWord(sc, 0xE43E, 0x0000);
+
+        MP_WriteMcuAccessRegWord(sc, 0xE434, 0x0004);
+        MP_WriteMcuAccessRegWord(sc, 0xE43C, 0x0004);
+
+        DisableMcuBPs(sc);
+
+        MP_WriteMcuAccessRegWord(sc, 0xF800, 0xE008);
+        MP_WriteMcuAccessRegWord(sc, 0xF802, 0xE01B);
+        MP_WriteMcuAccessRegWord(sc, 0xF804, 0xE022);
+        MP_WriteMcuAccessRegWord(sc, 0xF806, 0xE094);
+        MP_WriteMcuAccessRegWord(sc, 0xF808, 0xE097);
+        MP_WriteMcuAccessRegWord(sc, 0xF80A, 0xE09A);
+        MP_WriteMcuAccessRegWord(sc, 0xF80C, 0xE0B3);
+        MP_WriteMcuAccessRegWord(sc, 0xF80E, 0xE0BA);
+        MP_WriteMcuAccessRegWord(sc, 0xF810, 0x49D2);
+        MP_WriteMcuAccessRegWord(sc, 0xF812, 0xF10D);
+        MP_WriteMcuAccessRegWord(sc, 0xF814, 0x766C);
+        MP_WriteMcuAccessRegWord(sc, 0xF816, 0x49E2);
+        MP_WriteMcuAccessRegWord(sc, 0xF818, 0xF00A);
+        MP_WriteMcuAccessRegWord(sc, 0xF81A, 0x1EC0);
+        MP_WriteMcuAccessRegWord(sc, 0xF81C, 0x8EE1);
+        MP_WriteMcuAccessRegWord(sc, 0xF81E, 0xC60A);
+        MP_WriteMcuAccessRegWord(sc, 0xF820, 0x77C0);
+        MP_WriteMcuAccessRegWord(sc, 0xF822, 0x4870);
+        MP_WriteMcuAccessRegWord(sc, 0xF824, 0x9FC0);
+        MP_WriteMcuAccessRegWord(sc, 0xF826, 0x1EA0);
+        MP_WriteMcuAccessRegWord(sc, 0xF828, 0xC707);
+        MP_WriteMcuAccessRegWord(sc, 0xF82A, 0x8EE1);
+        MP_WriteMcuAccessRegWord(sc, 0xF82C, 0x9D6C);
+        MP_WriteMcuAccessRegWord(sc, 0xF82E, 0xC603);
+        MP_WriteMcuAccessRegWord(sc, 0xF830, 0xBE00);
+        MP_WriteMcuAccessRegWord(sc, 0xF832, 0xB416);
+        MP_WriteMcuAccessRegWord(sc, 0xF834, 0x0076);
+        MP_WriteMcuAccessRegWord(sc, 0xF836, 0xE86C);
+        MP_WriteMcuAccessRegWord(sc, 0xF838, 0xC406);
+        MP_WriteMcuAccessRegWord(sc, 0xF83A, 0x7580);
+        MP_WriteMcuAccessRegWord(sc, 0xF83C, 0x4852);
+        MP_WriteMcuAccessRegWord(sc, 0xF83E, 0x8D80);
+        MP_WriteMcuAccessRegWord(sc, 0xF840, 0xC403);
+        MP_WriteMcuAccessRegWord(sc, 0xF842, 0xBC00);
+        MP_WriteMcuAccessRegWord(sc, 0xF844, 0xD3E0);
+        MP_WriteMcuAccessRegWord(sc, 0xF846, 0x02C8);
+        MP_WriteMcuAccessRegWord(sc, 0xF848, 0x8918);
+        MP_WriteMcuAccessRegWord(sc, 0xF84A, 0xE815);
+        MP_WriteMcuAccessRegWord(sc, 0xF84C, 0x1100);
+        MP_WriteMcuAccessRegWord(sc, 0xF84E, 0xF011);
+        MP_WriteMcuAccessRegWord(sc, 0xF850, 0xE812);
+        MP_WriteMcuAccessRegWord(sc, 0xF852, 0x4990);
+        MP_WriteMcuAccessRegWord(sc, 0xF854, 0xF002);
+        MP_WriteMcuAccessRegWord(sc, 0xF856, 0xE817);
+        MP_WriteMcuAccessRegWord(sc, 0xF858, 0xE80E);
+        MP_WriteMcuAccessRegWord(sc, 0xF85A, 0x4992);
+        MP_WriteMcuAccessRegWord(sc, 0xF85C, 0xF002);
+        MP_WriteMcuAccessRegWord(sc, 0xF85E, 0xE80E);
+        MP_WriteMcuAccessRegWord(sc, 0xF860, 0xE80A);
+        MP_WriteMcuAccessRegWord(sc, 0xF862, 0x4993);
+        MP_WriteMcuAccessRegWord(sc, 0xF864, 0xF002);
+        MP_WriteMcuAccessRegWord(sc, 0xF866, 0xE818);
+        MP_WriteMcuAccessRegWord(sc, 0xF868, 0xE806);
+        MP_WriteMcuAccessRegWord(sc, 0xF86A, 0x4991);
+        MP_WriteMcuAccessRegWord(sc, 0xF86C, 0xF002);
+        MP_WriteMcuAccessRegWord(sc, 0xF86E, 0xE838);
+        MP_WriteMcuAccessRegWord(sc, 0xF870, 0xC25E);
+        MP_WriteMcuAccessRegWord(sc, 0xF872, 0xBA00);
+        MP_WriteMcuAccessRegWord(sc, 0xF874, 0xC056);
+        MP_WriteMcuAccessRegWord(sc, 0xF876, 0x7100);
+        MP_WriteMcuAccessRegWord(sc, 0xF878, 0xFF80);
+        MP_WriteMcuAccessRegWord(sc, 0xF87A, 0x7100);
+        MP_WriteMcuAccessRegWord(sc, 0xF87C, 0x4892);
+        MP_WriteMcuAccessRegWord(sc, 0xF87E, 0x4813);
+        MP_WriteMcuAccessRegWord(sc, 0xF880, 0x8900);
+        MP_WriteMcuAccessRegWord(sc, 0xF882, 0xE00A);
+        MP_WriteMcuAccessRegWord(sc, 0xF884, 0x7100);
+        MP_WriteMcuAccessRegWord(sc, 0xF886, 0x4890);
+        MP_WriteMcuAccessRegWord(sc, 0xF888, 0x4813);
+        MP_WriteMcuAccessRegWord(sc, 0xF88A, 0x8900);
+        MP_WriteMcuAccessRegWord(sc, 0xF88C, 0xC74B);
+        MP_WriteMcuAccessRegWord(sc, 0xF88E, 0x74F8);
+        MP_WriteMcuAccessRegWord(sc, 0xF890, 0x48C2);
+        MP_WriteMcuAccessRegWord(sc, 0xF892, 0x4841);
+        MP_WriteMcuAccessRegWord(sc, 0xF894, 0x8CF8);
+        MP_WriteMcuAccessRegWord(sc, 0xF896, 0xC746);
+        MP_WriteMcuAccessRegWord(sc, 0xF898, 0x74FC);
+        MP_WriteMcuAccessRegWord(sc, 0xF89A, 0x49C0);
+        MP_WriteMcuAccessRegWord(sc, 0xF89C, 0xF120);
+        MP_WriteMcuAccessRegWord(sc, 0xF89E, 0x49C1);
+        MP_WriteMcuAccessRegWord(sc, 0xF8A0, 0xF11E);
+        MP_WriteMcuAccessRegWord(sc, 0xF8A2, 0x74F8);
+        MP_WriteMcuAccessRegWord(sc, 0xF8A4, 0x49C0);
+        MP_WriteMcuAccessRegWord(sc, 0xF8A6, 0xF01B);
+        MP_WriteMcuAccessRegWord(sc, 0xF8A8, 0x49C6);
+        MP_WriteMcuAccessRegWord(sc, 0xF8AA, 0xF119);
+        MP_WriteMcuAccessRegWord(sc, 0xF8AC, 0x74F8);
+        MP_WriteMcuAccessRegWord(sc, 0xF8AE, 0x49C4);
+        MP_WriteMcuAccessRegWord(sc, 0xF8B0, 0xF013);
+        MP_WriteMcuAccessRegWord(sc, 0xF8B2, 0xC536);
+        MP_WriteMcuAccessRegWord(sc, 0xF8B4, 0x74B0);
+        MP_WriteMcuAccessRegWord(sc, 0xF8B6, 0x49C1);
+        MP_WriteMcuAccessRegWord(sc, 0xF8B8, 0xF1FD);
+        MP_WriteMcuAccessRegWord(sc, 0xF8BA, 0xC537);
+        MP_WriteMcuAccessRegWord(sc, 0xF8BC, 0xC434);
+        MP_WriteMcuAccessRegWord(sc, 0xF8BE, 0x9CA0);
+        MP_WriteMcuAccessRegWord(sc, 0xF8C0, 0xC435);
+        MP_WriteMcuAccessRegWord(sc, 0xF8C2, 0x1C13);
+        MP_WriteMcuAccessRegWord(sc, 0xF8C4, 0x484F);
+        MP_WriteMcuAccessRegWord(sc, 0xF8C6, 0x9CA2);
+        MP_WriteMcuAccessRegWord(sc, 0xF8C8, 0xC52B);
+        MP_WriteMcuAccessRegWord(sc, 0xF8CA, 0x74B0);
+        MP_WriteMcuAccessRegWord(sc, 0xF8CC, 0x49C1);
+        MP_WriteMcuAccessRegWord(sc, 0xF8CE, 0xF1FD);
+        MP_WriteMcuAccessRegWord(sc, 0xF8D0, 0x74F8);
+        MP_WriteMcuAccessRegWord(sc, 0xF8D2, 0x48C4);
+        MP_WriteMcuAccessRegWord(sc, 0xF8D4, 0x8CF8);
+        MP_WriteMcuAccessRegWord(sc, 0xF8D6, 0x7100);
+        MP_WriteMcuAccessRegWord(sc, 0xF8D8, 0x4893);
+        MP_WriteMcuAccessRegWord(sc, 0xF8DA, 0x8900);
+        MP_WriteMcuAccessRegWord(sc, 0xF8DC, 0xFF80);
+        MP_WriteMcuAccessRegWord(sc, 0xF8DE, 0xC520);
+        MP_WriteMcuAccessRegWord(sc, 0xF8E0, 0x74B0);
+        MP_WriteMcuAccessRegWord(sc, 0xF8E2, 0x49C1);
+        MP_WriteMcuAccessRegWord(sc, 0xF8E4, 0xF11C);
+        MP_WriteMcuAccessRegWord(sc, 0xF8E6, 0xC71E);
+        MP_WriteMcuAccessRegWord(sc, 0xF8E8, 0x74FC);
+        MP_WriteMcuAccessRegWord(sc, 0xF8EA, 0x49C1);
+        MP_WriteMcuAccessRegWord(sc, 0xF8EC, 0xF118);
+        MP_WriteMcuAccessRegWord(sc, 0xF8EE, 0x49C0);
+        MP_WriteMcuAccessRegWord(sc, 0xF8F0, 0xF116);
+        MP_WriteMcuAccessRegWord(sc, 0xF8F2, 0x74F8);
+        MP_WriteMcuAccessRegWord(sc, 0xF8F4, 0x49C0);
+        MP_WriteMcuAccessRegWord(sc, 0xF8F6, 0xF013);
+        MP_WriteMcuAccessRegWord(sc, 0xF8F8, 0x48C3);
+        MP_WriteMcuAccessRegWord(sc, 0xF8FA, 0x8CF8);
+        MP_WriteMcuAccessRegWord(sc, 0xF8FC, 0xC516);
+        MP_WriteMcuAccessRegWord(sc, 0xF8FE, 0x74A2);
+        MP_WriteMcuAccessRegWord(sc, 0xF900, 0x49CE);
+        MP_WriteMcuAccessRegWord(sc, 0xF902, 0xF1FE);
+        MP_WriteMcuAccessRegWord(sc, 0xF904, 0xC411);
+        MP_WriteMcuAccessRegWord(sc, 0xF906, 0x9CA0);
+        MP_WriteMcuAccessRegWord(sc, 0xF908, 0xC411);
+        MP_WriteMcuAccessRegWord(sc, 0xF90A, 0x1C13);
+        MP_WriteMcuAccessRegWord(sc, 0xF90C, 0x484F);
+        MP_WriteMcuAccessRegWord(sc, 0xF90E, 0x9CA2);
+        MP_WriteMcuAccessRegWord(sc, 0xF910, 0x74A2);
+        MP_WriteMcuAccessRegWord(sc, 0xF912, 0x49CF);
+        MP_WriteMcuAccessRegWord(sc, 0xF914, 0xF1FE);
+        MP_WriteMcuAccessRegWord(sc, 0xF916, 0x7100);
+        MP_WriteMcuAccessRegWord(sc, 0xF918, 0x4891);
+        MP_WriteMcuAccessRegWord(sc, 0xF91A, 0x8900);
+        MP_WriteMcuAccessRegWord(sc, 0xF91C, 0xFF80);
+        MP_WriteMcuAccessRegWord(sc, 0xF91E, 0xE400);
+        MP_WriteMcuAccessRegWord(sc, 0xF920, 0xD3E0);
+        MP_WriteMcuAccessRegWord(sc, 0xF922, 0xE000);
+        MP_WriteMcuAccessRegWord(sc, 0xF924, 0x0481);
+        MP_WriteMcuAccessRegWord(sc, 0xF926, 0x0C81);
+        MP_WriteMcuAccessRegWord(sc, 0xF928, 0xDE20);
+        MP_WriteMcuAccessRegWord(sc, 0xF92A, 0x0000);
+        MP_WriteMcuAccessRegWord(sc, 0xF92C, 0x0992);
+        MP_WriteMcuAccessRegWord(sc, 0xF92E, 0x1B76);
+        MP_WriteMcuAccessRegWord(sc, 0xF930, 0xC602);
+        MP_WriteMcuAccessRegWord(sc, 0xF932, 0xBE00);
+        MP_WriteMcuAccessRegWord(sc, 0xF934, 0x059C);
+        MP_WriteMcuAccessRegWord(sc, 0xF936, 0x1B76);
+        MP_WriteMcuAccessRegWord(sc, 0xF938, 0xC602);
+        MP_WriteMcuAccessRegWord(sc, 0xF93A, 0xBE00);
+        MP_WriteMcuAccessRegWord(sc, 0xF93C, 0x065A);
+        MP_WriteMcuAccessRegWord(sc, 0xF93E, 0xB400);
+        MP_WriteMcuAccessRegWord(sc, 0xF940, 0x18DE);
+        MP_WriteMcuAccessRegWord(sc, 0xF942, 0x2008);
+        MP_WriteMcuAccessRegWord(sc, 0xF944, 0x4001);
+        MP_WriteMcuAccessRegWord(sc, 0xF946, 0xF10F);
+        MP_WriteMcuAccessRegWord(sc, 0xF948, 0x7342);
+        MP_WriteMcuAccessRegWord(sc, 0xF94A, 0x1880);
+        MP_WriteMcuAccessRegWord(sc, 0xF94C, 0x2008);
+        MP_WriteMcuAccessRegWord(sc, 0xF94E, 0x0009);
+        MP_WriteMcuAccessRegWord(sc, 0xF950, 0x4018);
+        MP_WriteMcuAccessRegWord(sc, 0xF952, 0xF109);
+        MP_WriteMcuAccessRegWord(sc, 0xF954, 0x7340);
+        MP_WriteMcuAccessRegWord(sc, 0xF956, 0x25BC);
+        MP_WriteMcuAccessRegWord(sc, 0xF958, 0x130F);
+        MP_WriteMcuAccessRegWord(sc, 0xF95A, 0xF105);
+        MP_WriteMcuAccessRegWord(sc, 0xF95C, 0xC00A);
+        MP_WriteMcuAccessRegWord(sc, 0xF95E, 0x7300);
+        MP_WriteMcuAccessRegWord(sc, 0xF960, 0x4831);
+        MP_WriteMcuAccessRegWord(sc, 0xF962, 0x9B00);
+        MP_WriteMcuAccessRegWord(sc, 0xF964, 0xB000);
+        MP_WriteMcuAccessRegWord(sc, 0xF966, 0x7340);
+        MP_WriteMcuAccessRegWord(sc, 0xF968, 0x8320);
+        MP_WriteMcuAccessRegWord(sc, 0xF96A, 0xC302);
+        MP_WriteMcuAccessRegWord(sc, 0xF96C, 0xBB00);
+        MP_WriteMcuAccessRegWord(sc, 0xF96E, 0x0C12);
+        MP_WriteMcuAccessRegWord(sc, 0xF970, 0xE860);
+        MP_WriteMcuAccessRegWord(sc, 0xF972, 0xC406);
+        MP_WriteMcuAccessRegWord(sc, 0xF974, 0x7580);
+        MP_WriteMcuAccessRegWord(sc, 0xF976, 0x4851);
+        MP_WriteMcuAccessRegWord(sc, 0xF978, 0x8D80);
+        MP_WriteMcuAccessRegWord(sc, 0xF97A, 0xC403);
+        MP_WriteMcuAccessRegWord(sc, 0xF97C, 0xBC00);
+        MP_WriteMcuAccessRegWord(sc, 0xF97E, 0xD3E0);
+        MP_WriteMcuAccessRegWord(sc, 0xF980, 0x02C8);
+        MP_WriteMcuAccessRegWord(sc, 0xF982, 0xC406);
+        MP_WriteMcuAccessRegWord(sc, 0xF984, 0x7580);
+        MP_WriteMcuAccessRegWord(sc, 0xF986, 0x4850);
+        MP_WriteMcuAccessRegWord(sc, 0xF988, 0x8D80);
+        MP_WriteMcuAccessRegWord(sc, 0xF98A, 0xC403);
+        MP_WriteMcuAccessRegWord(sc, 0xF98C, 0xBC00);
+        MP_WriteMcuAccessRegWord(sc, 0xF98E, 0xD3E0);
+        MP_WriteMcuAccessRegWord(sc, 0xF990, 0x0298);
+
+        MP_WriteMcuAccessRegWord(sc, 0xDE30, 0x0080);
+
+        MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000);
+
+        MP_WriteMcuAccessRegWord(sc, 0xFC28, 0x0075);
+        MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x02B1);
+        MP_WriteMcuAccessRegWord(sc, 0xFC2C, 0x0991);
+        MP_WriteMcuAccessRegWord(sc, 0xFC2E, 0x059B);
+        MP_WriteMcuAccessRegWord(sc, 0xFC30, 0x0659);
+        MP_WriteMcuAccessRegWord(sc, 0xFC32, 0x0000);
+        MP_WriteMcuAccessRegWord(sc, 0xFC34, 0x02BB);
+        MP_WriteMcuAccessRegWord(sc, 0xFC36, 0x0279);
+}
 
+static void re_set_mac_mcu_8168gu_1(struct re_softc *sc)
+{
+        DisableMcuBPs(sc);
+
+        MP_WriteMcuAccessRegWord(sc, 0xF800, 0xE008);
+        MP_WriteMcuAccessRegWord(sc, 0xF802, 0xE011);
+        MP_WriteMcuAccessRegWord(sc, 0xF804, 0xE015);
+        MP_WriteMcuAccessRegWord(sc, 0xF806, 0xE018);
+        MP_WriteMcuAccessRegWord(sc, 0xF808, 0xE01B);
+        MP_WriteMcuAccessRegWord(sc, 0xF80A, 0xE027);
+        MP_WriteMcuAccessRegWord(sc, 0xF80C, 0xE043);
+        MP_WriteMcuAccessRegWord(sc, 0xF80E, 0xE065);
+        MP_WriteMcuAccessRegWord(sc, 0xF810, 0x49E2);
+        MP_WriteMcuAccessRegWord(sc, 0xF812, 0xF005);
+        MP_WriteMcuAccessRegWord(sc, 0xF814, 0x49EA);
+        MP_WriteMcuAccessRegWord(sc, 0xF816, 0xF003);
+        MP_WriteMcuAccessRegWord(sc, 0xF818, 0xC404);
+        MP_WriteMcuAccessRegWord(sc, 0xF81A, 0xBC00);
+        MP_WriteMcuAccessRegWord(sc, 0xF81C, 0xC403);
+        MP_WriteMcuAccessRegWord(sc, 0xF81E, 0xBC00);
+        MP_WriteMcuAccessRegWord(sc, 0xF820, 0x0496);
+        MP_WriteMcuAccessRegWord(sc, 0xF822, 0x051A);
+        MP_WriteMcuAccessRegWord(sc, 0xF824, 0x1D01);
+        MP_WriteMcuAccessRegWord(sc, 0xF826, 0x8DE8);
+        MP_WriteMcuAccessRegWord(sc, 0xF828, 0xC602);
+        MP_WriteMcuAccessRegWord(sc, 0xF82A, 0xBE00);
+        MP_WriteMcuAccessRegWord(sc, 0xF82C, 0x0206);
+        MP_WriteMcuAccessRegWord(sc, 0xF82E, 0x1B76);
+        MP_WriteMcuAccessRegWord(sc, 0xF830, 0xC202);
+        MP_WriteMcuAccessRegWord(sc, 0xF832, 0xBA00);
+        MP_WriteMcuAccessRegWord(sc, 0xF834, 0x058A);
+        MP_WriteMcuAccessRegWord(sc, 0xF836, 0x1B76);
+        MP_WriteMcuAccessRegWord(sc, 0xF838, 0xC602);
+        MP_WriteMcuAccessRegWord(sc, 0xF83A, 0xBE00);
+        MP_WriteMcuAccessRegWord(sc, 0xF83C, 0x0648);
+        MP_WriteMcuAccessRegWord(sc, 0xF83E, 0x74E6);
+        MP_WriteMcuAccessRegWord(sc, 0xF840, 0x1B78);
+        MP_WriteMcuAccessRegWord(sc, 0xF842, 0x46DC);
+        MP_WriteMcuAccessRegWord(sc, 0xF844, 0x1300);
+        MP_WriteMcuAccessRegWord(sc, 0xF846, 0xF005);
+        MP_WriteMcuAccessRegWord(sc, 0xF848, 0x74F8);
+        MP_WriteMcuAccessRegWord(sc, 0xF84A, 0x48C3);
+        MP_WriteMcuAccessRegWord(sc, 0xF84C, 0x48C4);
+        MP_WriteMcuAccessRegWord(sc, 0xF84E, 0x8CF8);
+        MP_WriteMcuAccessRegWord(sc, 0xF850, 0x64E7);
+        MP_WriteMcuAccessRegWord(sc, 0xF852, 0xC302);
+        MP_WriteMcuAccessRegWord(sc, 0xF854, 0xBB00);
+        MP_WriteMcuAccessRegWord(sc, 0xF856, 0x068E);
+        MP_WriteMcuAccessRegWord(sc, 0xF858, 0x74E4);
+        MP_WriteMcuAccessRegWord(sc, 0xF85A, 0x49C5);
+        MP_WriteMcuAccessRegWord(sc, 0xF85C, 0xF106);
+        MP_WriteMcuAccessRegWord(sc, 0xF85E, 0x49C6);
+        MP_WriteMcuAccessRegWord(sc, 0xF860, 0xF107);
+        MP_WriteMcuAccessRegWord(sc, 0xF862, 0x48C8);
+        MP_WriteMcuAccessRegWord(sc, 0xF864, 0x48C9);
+        MP_WriteMcuAccessRegWord(sc, 0xF866, 0xE011);
+        MP_WriteMcuAccessRegWord(sc, 0xF868, 0x48C9);
+        MP_WriteMcuAccessRegWord(sc, 0xF86A, 0x4848);
+        MP_WriteMcuAccessRegWord(sc, 0xF86C, 0xE00E);
+        MP_WriteMcuAccessRegWord(sc, 0xF86E, 0x4848);
+        MP_WriteMcuAccessRegWord(sc, 0xF870, 0x49C7);
+        MP_WriteMcuAccessRegWord(sc, 0xF872, 0xF00A);
+        MP_WriteMcuAccessRegWord(sc, 0xF874, 0x48C9);
+        MP_WriteMcuAccessRegWord(sc, 0xF876, 0xC60D);
+        MP_WriteMcuAccessRegWord(sc, 0xF878, 0x1D1F);
+        MP_WriteMcuAccessRegWord(sc, 0xF87A, 0x8DC2);
+        MP_WriteMcuAccessRegWord(sc, 0xF87C, 0x1D00);
+        MP_WriteMcuAccessRegWord(sc, 0xF87E, 0x8DC3);
+        MP_WriteMcuAccessRegWord(sc, 0xF880, 0x1D11);
+        MP_WriteMcuAccessRegWord(sc, 0xF882, 0x8DC0);
+        MP_WriteMcuAccessRegWord(sc, 0xF884, 0xE002);
+        MP_WriteMcuAccessRegWord(sc, 0xF886, 0x4849);
+        MP_WriteMcuAccessRegWord(sc, 0xF888, 0x94E5);
+        MP_WriteMcuAccessRegWord(sc, 0xF88A, 0xC602);
+        MP_WriteMcuAccessRegWord(sc, 0xF88C, 0xBE00);
+        MP_WriteMcuAccessRegWord(sc, 0xF88E, 0x0238);
+        MP_WriteMcuAccessRegWord(sc, 0xF890, 0xE434);
+        MP_WriteMcuAccessRegWord(sc, 0xF892, 0x49D9);
+        MP_WriteMcuAccessRegWord(sc, 0xF894, 0xF01B);
+        MP_WriteMcuAccessRegWord(sc, 0xF896, 0xC31E);
+        MP_WriteMcuAccessRegWord(sc, 0xF898, 0x7464);
+        MP_WriteMcuAccessRegWord(sc, 0xF89A, 0x49C4);
+        MP_WriteMcuAccessRegWord(sc, 0xF89C, 0xF114);
+        MP_WriteMcuAccessRegWord(sc, 0xF89E, 0xC31B);
+        MP_WriteMcuAccessRegWord(sc, 0xF8A0, 0x6460);
+        MP_WriteMcuAccessRegWord(sc, 0xF8A2, 0x14FA);
+        MP_WriteMcuAccessRegWord(sc, 0xF8A4, 0xFA02);
+        MP_WriteMcuAccessRegWord(sc, 0xF8A6, 0xE00F);
+        MP_WriteMcuAccessRegWord(sc, 0xF8A8, 0xC317);
+        MP_WriteMcuAccessRegWord(sc, 0xF8AA, 0x7460);
+        MP_WriteMcuAccessRegWord(sc, 0xF8AC, 0x49C0);
+        MP_WriteMcuAccessRegWord(sc, 0xF8AE, 0xF10B);
+        MP_WriteMcuAccessRegWord(sc, 0xF8B0, 0xC311);
+        MP_WriteMcuAccessRegWord(sc, 0xF8B2, 0x7462);
+        MP_WriteMcuAccessRegWord(sc, 0xF8B4, 0x48C1);
+        MP_WriteMcuAccessRegWord(sc, 0xF8B6, 0x9C62);
+        MP_WriteMcuAccessRegWord(sc, 0xF8B8, 0x4841);
+        MP_WriteMcuAccessRegWord(sc, 0xF8BA, 0x9C62);
+        MP_WriteMcuAccessRegWord(sc, 0xF8BC, 0xC30A);
+        MP_WriteMcuAccessRegWord(sc, 0xF8BE, 0x1C04);
+        MP_WriteMcuAccessRegWord(sc, 0xF8C0, 0x8C60);
+        MP_WriteMcuAccessRegWord(sc, 0xF8C2, 0xE004);
+        MP_WriteMcuAccessRegWord(sc, 0xF8C4, 0x1C15);
+        MP_WriteMcuAccessRegWord(sc, 0xF8C6, 0xC305);
+        MP_WriteMcuAccessRegWord(sc, 0xF8C8, 0x8C60);
+        MP_WriteMcuAccessRegWord(sc, 0xF8CA, 0xC602);
+        MP_WriteMcuAccessRegWord(sc, 0xF8CC, 0xBE00);
+        MP_WriteMcuAccessRegWord(sc, 0xF8CE, 0x0374);
+        MP_WriteMcuAccessRegWord(sc, 0xF8D0, 0xE434);
+        MP_WriteMcuAccessRegWord(sc, 0xF8D2, 0xE030);
+        MP_WriteMcuAccessRegWord(sc, 0xF8D4, 0xE61C);
+        MP_WriteMcuAccessRegWord(sc, 0xF8D6, 0xE906);
+        MP_WriteMcuAccessRegWord(sc, 0xF8D8, 0xC602);
+        MP_WriteMcuAccessRegWord(sc, 0xF8DA, 0xBE00);
+        MP_WriteMcuAccessRegWord(sc, 0xF8DC, 0x0000);
+
+        MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000);
+
+        MP_WriteMcuAccessRegWord(sc, 0xFC28, 0x0493);
+        MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x0205);
+        MP_WriteMcuAccessRegWord(sc, 0xFC2C, 0x0589);
+        MP_WriteMcuAccessRegWord(sc, 0xFC2E, 0x0647);
+        MP_WriteMcuAccessRegWord(sc, 0xFC30, 0x0000);
+        MP_WriteMcuAccessRegWord(sc, 0xFC32, 0x0215);
+        MP_WriteMcuAccessRegWord(sc, 0xFC34, 0x0285);
+}
 
+static void re_set_mac_mcu_8168gu_2(struct re_softc *sc)
+{
+        DisableMcuBPs(sc);
+
+        MP_WriteMcuAccessRegWord(sc, 0xF800, 0xE008);
+        MP_WriteMcuAccessRegWord(sc, 0xF802, 0xE00A);
+        MP_WriteMcuAccessRegWord(sc, 0xF804, 0xE00D);
+        MP_WriteMcuAccessRegWord(sc, 0xF806, 0xE02F);
+        MP_WriteMcuAccessRegWord(sc, 0xF808, 0xE031);
+        MP_WriteMcuAccessRegWord(sc, 0xF80A, 0xE038);
+        MP_WriteMcuAccessRegWord(sc, 0xF80C, 0xE03A);
+        MP_WriteMcuAccessRegWord(sc, 0xF80E, 0xE051);
+        MP_WriteMcuAccessRegWord(sc, 0xF810, 0xC202);
+        MP_WriteMcuAccessRegWord(sc, 0xF812, 0xBA00);
+        MP_WriteMcuAccessRegWord(sc, 0xF814, 0x0DFC);
+        MP_WriteMcuAccessRegWord(sc, 0xF816, 0x7444);
+        MP_WriteMcuAccessRegWord(sc, 0xF818, 0xC502);
+        MP_WriteMcuAccessRegWord(sc, 0xF81A, 0xBD00);
+        MP_WriteMcuAccessRegWord(sc, 0xF81C, 0x0A30);
+        MP_WriteMcuAccessRegWord(sc, 0xF81E, 0x49D9);
+        MP_WriteMcuAccessRegWord(sc, 0xF820, 0xF019);
+        MP_WriteMcuAccessRegWord(sc, 0xF822, 0xC520);
+        MP_WriteMcuAccessRegWord(sc, 0xF824, 0x64A5);
+        MP_WriteMcuAccessRegWord(sc, 0xF826, 0x1400);
+        MP_WriteMcuAccessRegWord(sc, 0xF828, 0xF007);
+        MP_WriteMcuAccessRegWord(sc, 0xF82A, 0x0C01);
+        MP_WriteMcuAccessRegWord(sc, 0xF82C, 0x8CA5);
+        MP_WriteMcuAccessRegWord(sc, 0xF82E, 0x1C15);
+        MP_WriteMcuAccessRegWord(sc, 0xF830, 0xC515);
+        MP_WriteMcuAccessRegWord(sc, 0xF832, 0x9CA0);
+        MP_WriteMcuAccessRegWord(sc, 0xF834, 0xE00F);
+        MP_WriteMcuAccessRegWord(sc, 0xF836, 0xC513);
+        MP_WriteMcuAccessRegWord(sc, 0xF838, 0x74A0);
+        MP_WriteMcuAccessRegWord(sc, 0xF83A, 0x48C8);
+        MP_WriteMcuAccessRegWord(sc, 0xF83C, 0x48CA);
+        MP_WriteMcuAccessRegWord(sc, 0xF83E, 0x9CA0);
+        MP_WriteMcuAccessRegWord(sc, 0xF840, 0xC510);
+        MP_WriteMcuAccessRegWord(sc, 0xF842, 0x1B00);
+        MP_WriteMcuAccessRegWord(sc, 0xF844, 0x9BA0);
+        MP_WriteMcuAccessRegWord(sc, 0xF846, 0x1B1C);
+        MP_WriteMcuAccessRegWord(sc, 0xF848, 0x483F);
+        MP_WriteMcuAccessRegWord(sc, 0xF84A, 0x9BA2);
+        MP_WriteMcuAccessRegWord(sc, 0xF84C, 0x1B04);
+        MP_WriteMcuAccessRegWord(sc, 0xF84E, 0xC506);
+        MP_WriteMcuAccessRegWord(sc, 0xF850, 0x9BA0);
+        MP_WriteMcuAccessRegWord(sc, 0xF852, 0xC603);
+        MP_WriteMcuAccessRegWord(sc, 0xF854, 0xBE00);
+        MP_WriteMcuAccessRegWord(sc, 0xF856, 0x0298);
+        MP_WriteMcuAccessRegWord(sc, 0xF858, 0x03DE);
+        MP_WriteMcuAccessRegWord(sc, 0xF85A, 0xE434);
+        MP_WriteMcuAccessRegWord(sc, 0xF85C, 0xE096);
+        MP_WriteMcuAccessRegWord(sc, 0xF85E, 0xE860);
+        MP_WriteMcuAccessRegWord(sc, 0xF860, 0xDE20);
+        MP_WriteMcuAccessRegWord(sc, 0xF862, 0xD3C0);
+        MP_WriteMcuAccessRegWord(sc, 0xF864, 0xC602);
+        MP_WriteMcuAccessRegWord(sc, 0xF866, 0xBE00);
+        MP_WriteMcuAccessRegWord(sc, 0xF868, 0x0A64);
+        MP_WriteMcuAccessRegWord(sc, 0xF86A, 0xC707);
+        MP_WriteMcuAccessRegWord(sc, 0xF86C, 0x1D00);
+        MP_WriteMcuAccessRegWord(sc, 0xF86E, 0x8DE2);
+        MP_WriteMcuAccessRegWord(sc, 0xF870, 0x48C1);
+        MP_WriteMcuAccessRegWord(sc, 0xF872, 0xC502);
+        MP_WriteMcuAccessRegWord(sc, 0xF874, 0xBD00);
+        MP_WriteMcuAccessRegWord(sc, 0xF876, 0x00AA);
+        MP_WriteMcuAccessRegWord(sc, 0xF878, 0xE0C0);
+        MP_WriteMcuAccessRegWord(sc, 0xF87A, 0xC502);
+        MP_WriteMcuAccessRegWord(sc, 0xF87C, 0xBD00);
+        MP_WriteMcuAccessRegWord(sc, 0xF87E, 0x0132);
+        MP_WriteMcuAccessRegWord(sc, 0xF880, 0xC50C);
+        MP_WriteMcuAccessRegWord(sc, 0xF882, 0x74A2);
+        MP_WriteMcuAccessRegWord(sc, 0xF884, 0x49CE);
+        MP_WriteMcuAccessRegWord(sc, 0xF886, 0xF1FE);
+        MP_WriteMcuAccessRegWord(sc, 0xF888, 0x1C00);
+        MP_WriteMcuAccessRegWord(sc, 0xF88A, 0x9EA0);
+        MP_WriteMcuAccessRegWord(sc, 0xF88C, 0x1C1C);
+        MP_WriteMcuAccessRegWord(sc, 0xF88E, 0x484F);
+        MP_WriteMcuAccessRegWord(sc, 0xF890, 0x9CA2);
+        MP_WriteMcuAccessRegWord(sc, 0xF892, 0xC402);
+        MP_WriteMcuAccessRegWord(sc, 0xF894, 0xBC00);
+        MP_WriteMcuAccessRegWord(sc, 0xF896, 0x0AFA);
+        MP_WriteMcuAccessRegWord(sc, 0xF898, 0xDE20);
+        MP_WriteMcuAccessRegWord(sc, 0xF89A, 0xE000);
+        MP_WriteMcuAccessRegWord(sc, 0xF89C, 0xE092);
+        MP_WriteMcuAccessRegWord(sc, 0xF89E, 0xE430);
+        MP_WriteMcuAccessRegWord(sc, 0xF8A0, 0xDE20);
+        MP_WriteMcuAccessRegWord(sc, 0xF8A2, 0xE0C0);
+        MP_WriteMcuAccessRegWord(sc, 0xF8A4, 0xE860);
+        MP_WriteMcuAccessRegWord(sc, 0xF8A6, 0xE84C);
+        MP_WriteMcuAccessRegWord(sc, 0xF8A8, 0xB400);
+        MP_WriteMcuAccessRegWord(sc, 0xF8AA, 0xB430);
+        MP_WriteMcuAccessRegWord(sc, 0xF8AC, 0xE410);
+        MP_WriteMcuAccessRegWord(sc, 0xF8AE, 0xC0AE);
+        MP_WriteMcuAccessRegWord(sc, 0xF8B0, 0xB407);
+        MP_WriteMcuAccessRegWord(sc, 0xF8B2, 0xB406);
+        MP_WriteMcuAccessRegWord(sc, 0xF8B4, 0xB405);
+        MP_WriteMcuAccessRegWord(sc, 0xF8B6, 0xB404);
+        MP_WriteMcuAccessRegWord(sc, 0xF8B8, 0xB403);
+        MP_WriteMcuAccessRegWord(sc, 0xF8BA, 0xB402);
+        MP_WriteMcuAccessRegWord(sc, 0xF8BC, 0xB401);
+        MP_WriteMcuAccessRegWord(sc, 0xF8BE, 0xC7EE);
+        MP_WriteMcuAccessRegWord(sc, 0xF8C0, 0x76F4);
+        MP_WriteMcuAccessRegWord(sc, 0xF8C2, 0xC2ED);
+        MP_WriteMcuAccessRegWord(sc, 0xF8C4, 0xC3ED);
+        MP_WriteMcuAccessRegWord(sc, 0xF8C6, 0xC1EF);
+        MP_WriteMcuAccessRegWord(sc, 0xF8C8, 0xC5F3);
+        MP_WriteMcuAccessRegWord(sc, 0xF8CA, 0x74A0);
+        MP_WriteMcuAccessRegWord(sc, 0xF8CC, 0x49CD);
+        MP_WriteMcuAccessRegWord(sc, 0xF8CE, 0xF001);
+        MP_WriteMcuAccessRegWord(sc, 0xF8D0, 0xC5EE);
+        MP_WriteMcuAccessRegWord(sc, 0xF8D2, 0x74A0);
+        MP_WriteMcuAccessRegWord(sc, 0xF8D4, 0x49C1);
+        MP_WriteMcuAccessRegWord(sc, 0xF8D6, 0xF105);
+        MP_WriteMcuAccessRegWord(sc, 0xF8D8, 0xC5E4);
+        MP_WriteMcuAccessRegWord(sc, 0xF8DA, 0x74A2);
+        MP_WriteMcuAccessRegWord(sc, 0xF8DC, 0x49CE);
+        MP_WriteMcuAccessRegWord(sc, 0xF8DE, 0xF00B);
+        MP_WriteMcuAccessRegWord(sc, 0xF8E0, 0x7444);
+        MP_WriteMcuAccessRegWord(sc, 0xF8E2, 0x484B);
+        MP_WriteMcuAccessRegWord(sc, 0xF8E4, 0x9C44);
+        MP_WriteMcuAccessRegWord(sc, 0xF8E6, 0x1C10);
+        MP_WriteMcuAccessRegWord(sc, 0xF8E8, 0x9C62);
+        MP_WriteMcuAccessRegWord(sc, 0xF8EA, 0x1C11);
+        MP_WriteMcuAccessRegWord(sc, 0xF8EC, 0x8C60);
+        MP_WriteMcuAccessRegWord(sc, 0xF8EE, 0x1C00);
+        MP_WriteMcuAccessRegWord(sc, 0xF8F0, 0x9CF6);
+        MP_WriteMcuAccessRegWord(sc, 0xF8F2, 0xE0EC);
+        MP_WriteMcuAccessRegWord(sc, 0xF8F4, 0x49E7);
+        MP_WriteMcuAccessRegWord(sc, 0xF8F6, 0xF016);
+        MP_WriteMcuAccessRegWord(sc, 0xF8F8, 0x1D80);
+        MP_WriteMcuAccessRegWord(sc, 0xF8FA, 0x8DF4);
+        MP_WriteMcuAccessRegWord(sc, 0xF8FC, 0x74F8);
+        MP_WriteMcuAccessRegWord(sc, 0xF8FE, 0x4843);
+        MP_WriteMcuAccessRegWord(sc, 0xF900, 0x8CF8);
+        MP_WriteMcuAccessRegWord(sc, 0xF902, 0x74F8);
+        MP_WriteMcuAccessRegWord(sc, 0xF904, 0x74F8);
+        MP_WriteMcuAccessRegWord(sc, 0xF906, 0x7444);
+        MP_WriteMcuAccessRegWord(sc, 0xF908, 0x48C8);
+        MP_WriteMcuAccessRegWord(sc, 0xF90A, 0x48C9);
+        MP_WriteMcuAccessRegWord(sc, 0xF90C, 0x48CA);
+        MP_WriteMcuAccessRegWord(sc, 0xF90E, 0x9C44);
+        MP_WriteMcuAccessRegWord(sc, 0xF910, 0x74F8);
+        MP_WriteMcuAccessRegWord(sc, 0xF912, 0x4844);
+        MP_WriteMcuAccessRegWord(sc, 0xF914, 0x8CF8);
+        MP_WriteMcuAccessRegWord(sc, 0xF916, 0x1E01);
+        MP_WriteMcuAccessRegWord(sc, 0xF918, 0xE8DB);
+        MP_WriteMcuAccessRegWord(sc, 0xF91A, 0x7420);
+        MP_WriteMcuAccessRegWord(sc, 0xF91C, 0x48C1);
+        MP_WriteMcuAccessRegWord(sc, 0xF91E, 0x9C20);
+        MP_WriteMcuAccessRegWord(sc, 0xF920, 0xE0D5);
+        MP_WriteMcuAccessRegWord(sc, 0xF922, 0x49E6);
+        MP_WriteMcuAccessRegWord(sc, 0xF924, 0xF02A);
+        MP_WriteMcuAccessRegWord(sc, 0xF926, 0x1D40);
+        MP_WriteMcuAccessRegWord(sc, 0xF928, 0x8DF4);
+        MP_WriteMcuAccessRegWord(sc, 0xF92A, 0x74FC);
+        MP_WriteMcuAccessRegWord(sc, 0xF92C, 0x49C0);
+        MP_WriteMcuAccessRegWord(sc, 0xF92E, 0xF124);
+        MP_WriteMcuAccessRegWord(sc, 0xF930, 0x49C1);
+        MP_WriteMcuAccessRegWord(sc, 0xF932, 0xF122);
+        MP_WriteMcuAccessRegWord(sc, 0xF934, 0x74F8);
+        MP_WriteMcuAccessRegWord(sc, 0xF936, 0x49C0);
+        MP_WriteMcuAccessRegWord(sc, 0xF938, 0xF01F);
+        MP_WriteMcuAccessRegWord(sc, 0xF93A, 0xE8D3);
+        MP_WriteMcuAccessRegWord(sc, 0xF93C, 0x48C4);
+        MP_WriteMcuAccessRegWord(sc, 0xF93E, 0x8CF8);
+        MP_WriteMcuAccessRegWord(sc, 0xF940, 0x1E00);
+        MP_WriteMcuAccessRegWord(sc, 0xF942, 0xE8C6);
+        MP_WriteMcuAccessRegWord(sc, 0xF944, 0xC5B1);
+        MP_WriteMcuAccessRegWord(sc, 0xF946, 0x74A0);
+        MP_WriteMcuAccessRegWord(sc, 0xF948, 0x49C3);
+        MP_WriteMcuAccessRegWord(sc, 0xF94A, 0xF016);
+        MP_WriteMcuAccessRegWord(sc, 0xF94C, 0xC5AF);
+        MP_WriteMcuAccessRegWord(sc, 0xF94E, 0x74A4);
+        MP_WriteMcuAccessRegWord(sc, 0xF950, 0x49C2);
+        MP_WriteMcuAccessRegWord(sc, 0xF952, 0xF005);
+        MP_WriteMcuAccessRegWord(sc, 0xF954, 0xC5AA);
+        MP_WriteMcuAccessRegWord(sc, 0xF956, 0x74B2);
+        MP_WriteMcuAccessRegWord(sc, 0xF958, 0x49C9);
+        MP_WriteMcuAccessRegWord(sc, 0xF95A, 0xF10E);
+        MP_WriteMcuAccessRegWord(sc, 0xF95C, 0xC5A6);
+        MP_WriteMcuAccessRegWord(sc, 0xF95E, 0x74A8);
+        MP_WriteMcuAccessRegWord(sc, 0xF960, 0x4845);
+        MP_WriteMcuAccessRegWord(sc, 0xF962, 0x4846);
+        MP_WriteMcuAccessRegWord(sc, 0xF964, 0x4847);
+        MP_WriteMcuAccessRegWord(sc, 0xF966, 0x4848);
+        MP_WriteMcuAccessRegWord(sc, 0xF968, 0x9CA8);
+        MP_WriteMcuAccessRegWord(sc, 0xF96A, 0x74B2);
+        MP_WriteMcuAccessRegWord(sc, 0xF96C, 0x4849);
+        MP_WriteMcuAccessRegWord(sc, 0xF96E, 0x9CB2);
+        MP_WriteMcuAccessRegWord(sc, 0xF970, 0x74A0);
+        MP_WriteMcuAccessRegWord(sc, 0xF972, 0x484F);
+        MP_WriteMcuAccessRegWord(sc, 0xF974, 0x9CA0);
+        MP_WriteMcuAccessRegWord(sc, 0xF976, 0xE0AA);
+        MP_WriteMcuAccessRegWord(sc, 0xF978, 0x49E4);
+        MP_WriteMcuAccessRegWord(sc, 0xF97A, 0xF018);
+        MP_WriteMcuAccessRegWord(sc, 0xF97C, 0x1D10);
+        MP_WriteMcuAccessRegWord(sc, 0xF97E, 0x8DF4);
+        MP_WriteMcuAccessRegWord(sc, 0xF980, 0x74F8);
+        MP_WriteMcuAccessRegWord(sc, 0xF982, 0x74F8);
+        MP_WriteMcuAccessRegWord(sc, 0xF984, 0x74F8);
+        MP_WriteMcuAccessRegWord(sc, 0xF986, 0x4843);
+        MP_WriteMcuAccessRegWord(sc, 0xF988, 0x8CF8);
+        MP_WriteMcuAccessRegWord(sc, 0xF98A, 0x74F8);
+        MP_WriteMcuAccessRegWord(sc, 0xF98C, 0x74F8);
+        MP_WriteMcuAccessRegWord(sc, 0xF98E, 0x74F8);
+        MP_WriteMcuAccessRegWord(sc, 0xF990, 0x4844);
+        MP_WriteMcuAccessRegWord(sc, 0xF992, 0x4842);
+        MP_WriteMcuAccessRegWord(sc, 0xF994, 0x4841);
+        MP_WriteMcuAccessRegWord(sc, 0xF996, 0x8CF8);
+        MP_WriteMcuAccessRegWord(sc, 0xF998, 0x1E01);
+        MP_WriteMcuAccessRegWord(sc, 0xF99A, 0xE89A);
+        MP_WriteMcuAccessRegWord(sc, 0xF99C, 0x7420);
+        MP_WriteMcuAccessRegWord(sc, 0xF99E, 0x4841);
+        MP_WriteMcuAccessRegWord(sc, 0xF9A0, 0x9C20);
+        MP_WriteMcuAccessRegWord(sc, 0xF9A2, 0x7444);
+        MP_WriteMcuAccessRegWord(sc, 0xF9A4, 0x4848);
+        MP_WriteMcuAccessRegWord(sc, 0xF9A6, 0x9C44);
+        MP_WriteMcuAccessRegWord(sc, 0xF9A8, 0xE091);
+        MP_WriteMcuAccessRegWord(sc, 0xF9AA, 0x49E5);
+        MP_WriteMcuAccessRegWord(sc, 0xF9AC, 0xF03E);
+        MP_WriteMcuAccessRegWord(sc, 0xF9AE, 0x1D20);
+        MP_WriteMcuAccessRegWord(sc, 0xF9B0, 0x8DF4);
+        MP_WriteMcuAccessRegWord(sc, 0xF9B2, 0x74F8);
+        MP_WriteMcuAccessRegWord(sc, 0xF9B4, 0x48C2);
+        MP_WriteMcuAccessRegWord(sc, 0xF9B6, 0x4841);
+        MP_WriteMcuAccessRegWord(sc, 0xF9B8, 0x8CF8);
+        MP_WriteMcuAccessRegWord(sc, 0xF9BA, 0x1E01);
+        MP_WriteMcuAccessRegWord(sc, 0xF9BC, 0x7444);
+        MP_WriteMcuAccessRegWord(sc, 0xF9BE, 0x49CA);
+        MP_WriteMcuAccessRegWord(sc, 0xF9C0, 0xF103);
+        MP_WriteMcuAccessRegWord(sc, 0xF9C2, 0x49C2);
+        MP_WriteMcuAccessRegWord(sc, 0xF9C4, 0xF00C);
+        MP_WriteMcuAccessRegWord(sc, 0xF9C6, 0x49C1);
+        MP_WriteMcuAccessRegWord(sc, 0xF9C8, 0xF004);
+        MP_WriteMcuAccessRegWord(sc, 0xF9CA, 0x6447);
+        MP_WriteMcuAccessRegWord(sc, 0xF9CC, 0x2244);
+        MP_WriteMcuAccessRegWord(sc, 0xF9CE, 0xE002);
+        MP_WriteMcuAccessRegWord(sc, 0xF9D0, 0x1C01);
+        MP_WriteMcuAccessRegWord(sc, 0xF9D2, 0x9C62);
+        MP_WriteMcuAccessRegWord(sc, 0xF9D4, 0x1C11);
+        MP_WriteMcuAccessRegWord(sc, 0xF9D6, 0x8C60);
+        MP_WriteMcuAccessRegWord(sc, 0xF9D8, 0x1C00);
+        MP_WriteMcuAccessRegWord(sc, 0xF9DA, 0x9CF6);
+        MP_WriteMcuAccessRegWord(sc, 0xF9DC, 0x7444);
+        MP_WriteMcuAccessRegWord(sc, 0xF9DE, 0x49C8);
+        MP_WriteMcuAccessRegWord(sc, 0xF9E0, 0xF01D);
+        MP_WriteMcuAccessRegWord(sc, 0xF9E2, 0x74FC);
+        MP_WriteMcuAccessRegWord(sc, 0xF9E4, 0x49C0);
+        MP_WriteMcuAccessRegWord(sc, 0xF9E6, 0xF11A);
+        MP_WriteMcuAccessRegWord(sc, 0xF9E8, 0x49C1);
+        MP_WriteMcuAccessRegWord(sc, 0xF9EA, 0xF118);
+        MP_WriteMcuAccessRegWord(sc, 0xF9EC, 0x74F8);
+        MP_WriteMcuAccessRegWord(sc, 0xF9EE, 0x49C0);
+        MP_WriteMcuAccessRegWord(sc, 0xF9F0, 0xF015);
+        MP_WriteMcuAccessRegWord(sc, 0xF9F2, 0x49C6);
+        MP_WriteMcuAccessRegWord(sc, 0xF9F4, 0xF113);
+        MP_WriteMcuAccessRegWord(sc, 0xF9F6, 0xE875);
+        MP_WriteMcuAccessRegWord(sc, 0xF9F8, 0x48C4);
+        MP_WriteMcuAccessRegWord(sc, 0xF9FA, 0x8CF8);
+        MP_WriteMcuAccessRegWord(sc, 0xF9FC, 0x7420);
+        MP_WriteMcuAccessRegWord(sc, 0xF9FE, 0x48C1);
+        MP_WriteMcuAccessRegWord(sc, 0xFA00, 0x9C20);
+        MP_WriteMcuAccessRegWord(sc, 0xFA02, 0xC50A);
+        MP_WriteMcuAccessRegWord(sc, 0xFA04, 0x74A2);
+        MP_WriteMcuAccessRegWord(sc, 0xFA06, 0x8CA5);
+        MP_WriteMcuAccessRegWord(sc, 0xFA08, 0x74A0);
+        MP_WriteMcuAccessRegWord(sc, 0xFA0A, 0xC505);
+        MP_WriteMcuAccessRegWord(sc, 0xFA0C, 0x9CA2);
+        MP_WriteMcuAccessRegWord(sc, 0xFA0E, 0x1C11);
+        MP_WriteMcuAccessRegWord(sc, 0xFA10, 0x9CA0);
+        MP_WriteMcuAccessRegWord(sc, 0xFA12, 0xE00A);
+        MP_WriteMcuAccessRegWord(sc, 0xFA14, 0xE434);
+        MP_WriteMcuAccessRegWord(sc, 0xFA16, 0xD3C0);
+        MP_WriteMcuAccessRegWord(sc, 0xFA18, 0xDC00);
+        MP_WriteMcuAccessRegWord(sc, 0xFA1A, 0x7444);
+        MP_WriteMcuAccessRegWord(sc, 0xFA1C, 0x49CA);
+        MP_WriteMcuAccessRegWord(sc, 0xFA1E, 0xF004);
+        MP_WriteMcuAccessRegWord(sc, 0xFA20, 0x48CA);
+        MP_WriteMcuAccessRegWord(sc, 0xFA22, 0x9C44);
+        MP_WriteMcuAccessRegWord(sc, 0xFA24, 0xE855);
+        MP_WriteMcuAccessRegWord(sc, 0xFA26, 0xE052);
+        MP_WriteMcuAccessRegWord(sc, 0xFA28, 0x49E8);
+        MP_WriteMcuAccessRegWord(sc, 0xFA2A, 0xF024);
+        MP_WriteMcuAccessRegWord(sc, 0xFA2C, 0x1D01);
+        MP_WriteMcuAccessRegWord(sc, 0xFA2E, 0x8DF5);
+        MP_WriteMcuAccessRegWord(sc, 0xFA30, 0x7440);
+        MP_WriteMcuAccessRegWord(sc, 0xFA32, 0x49C0);
+        MP_WriteMcuAccessRegWord(sc, 0xFA34, 0xF11E);
+        MP_WriteMcuAccessRegWord(sc, 0xFA36, 0x7444);
+        MP_WriteMcuAccessRegWord(sc, 0xFA38, 0x49C8);
+        MP_WriteMcuAccessRegWord(sc, 0xFA3A, 0xF01B);
+        MP_WriteMcuAccessRegWord(sc, 0xFA3C, 0x49CA);
+        MP_WriteMcuAccessRegWord(sc, 0xFA3E, 0xF119);
+        MP_WriteMcuAccessRegWord(sc, 0xFA40, 0xC5EC);
+        MP_WriteMcuAccessRegWord(sc, 0xFA42, 0x76A4);
+        MP_WriteMcuAccessRegWord(sc, 0xFA44, 0x49E3);
+        MP_WriteMcuAccessRegWord(sc, 0xFA46, 0xF015);
+        MP_WriteMcuAccessRegWord(sc, 0xFA48, 0x49C0);
+        MP_WriteMcuAccessRegWord(sc, 0xFA4A, 0xF103);
+        MP_WriteMcuAccessRegWord(sc, 0xFA4C, 0x49C1);
+        MP_WriteMcuAccessRegWord(sc, 0xFA4E, 0xF011);
+        MP_WriteMcuAccessRegWord(sc, 0xFA50, 0x4849);
+        MP_WriteMcuAccessRegWord(sc, 0xFA52, 0x9C44);
+        MP_WriteMcuAccessRegWord(sc, 0xFA54, 0x1C00);
+        MP_WriteMcuAccessRegWord(sc, 0xFA56, 0x9CF6);
+        MP_WriteMcuAccessRegWord(sc, 0xFA58, 0x7444);
+        MP_WriteMcuAccessRegWord(sc, 0xFA5A, 0x49C1);
+        MP_WriteMcuAccessRegWord(sc, 0xFA5C, 0xF004);
+        MP_WriteMcuAccessRegWord(sc, 0xFA5E, 0x6446);
+        MP_WriteMcuAccessRegWord(sc, 0xFA60, 0x1E07);
+        MP_WriteMcuAccessRegWord(sc, 0xFA62, 0xE003);
+        MP_WriteMcuAccessRegWord(sc, 0xFA64, 0x1C01);
+        MP_WriteMcuAccessRegWord(sc, 0xFA66, 0x1E03);
+        MP_WriteMcuAccessRegWord(sc, 0xFA68, 0x9C62);
+        MP_WriteMcuAccessRegWord(sc, 0xFA6A, 0x1C11);
+        MP_WriteMcuAccessRegWord(sc, 0xFA6C, 0x8C60);
+        MP_WriteMcuAccessRegWord(sc, 0xFA6E, 0xE830);
+        MP_WriteMcuAccessRegWord(sc, 0xFA70, 0xE02D);
+        MP_WriteMcuAccessRegWord(sc, 0xFA72, 0x49E9);
+        MP_WriteMcuAccessRegWord(sc, 0xFA74, 0xF004);
+        MP_WriteMcuAccessRegWord(sc, 0xFA76, 0x1D02);
+        MP_WriteMcuAccessRegWord(sc, 0xFA78, 0x8DF5);
+        MP_WriteMcuAccessRegWord(sc, 0xFA7A, 0xE79C);
+        MP_WriteMcuAccessRegWord(sc, 0xFA7C, 0x49E3);
+        MP_WriteMcuAccessRegWord(sc, 0xFA7E, 0xF006);
+        MP_WriteMcuAccessRegWord(sc, 0xFA80, 0x1D08);
+        MP_WriteMcuAccessRegWord(sc, 0xFA82, 0x8DF4);
+        MP_WriteMcuAccessRegWord(sc, 0xFA84, 0x74F8);
+        MP_WriteMcuAccessRegWord(sc, 0xFA86, 0x74F8);
+        MP_WriteMcuAccessRegWord(sc, 0xFA88, 0xE73A);
+        MP_WriteMcuAccessRegWord(sc, 0xFA8A, 0x49E1);
+        MP_WriteMcuAccessRegWord(sc, 0xFA8C, 0xF007);
+        MP_WriteMcuAccessRegWord(sc, 0xFA8E, 0x1D02);
+        MP_WriteMcuAccessRegWord(sc, 0xFA90, 0x8DF4);
+        MP_WriteMcuAccessRegWord(sc, 0xFA92, 0x1E01);
+        MP_WriteMcuAccessRegWord(sc, 0xFA94, 0xE7A7);
+        MP_WriteMcuAccessRegWord(sc, 0xFA96, 0xDE20);
+        MP_WriteMcuAccessRegWord(sc, 0xFA98, 0xE410);
+        MP_WriteMcuAccessRegWord(sc, 0xFA9A, 0x49E0);
+        MP_WriteMcuAccessRegWord(sc, 0xFA9C, 0xF017);
+        MP_WriteMcuAccessRegWord(sc, 0xFA9E, 0x1D01);
+        MP_WriteMcuAccessRegWord(sc, 0xFAA0, 0x8DF4);
+        MP_WriteMcuAccessRegWord(sc, 0xFAA2, 0xC5FA);
+        MP_WriteMcuAccessRegWord(sc, 0xFAA4, 0x1C00);
+        MP_WriteMcuAccessRegWord(sc, 0xFAA6, 0x8CA0);
+        MP_WriteMcuAccessRegWord(sc, 0xFAA8, 0x1C1B);
+        MP_WriteMcuAccessRegWord(sc, 0xFAAA, 0x9CA2);
+        MP_WriteMcuAccessRegWord(sc, 0xFAAC, 0x74A2);
+        MP_WriteMcuAccessRegWord(sc, 0xFAAE, 0x49CF);
+        MP_WriteMcuAccessRegWord(sc, 0xFAB0, 0xF0FE);
+        MP_WriteMcuAccessRegWord(sc, 0xFAB2, 0xC5F3);
+        MP_WriteMcuAccessRegWord(sc, 0xFAB4, 0x74A0);
+        MP_WriteMcuAccessRegWord(sc, 0xFAB6, 0x4849);
+        MP_WriteMcuAccessRegWord(sc, 0xFAB8, 0x9CA0);
+        MP_WriteMcuAccessRegWord(sc, 0xFABA, 0x74F8);
+        MP_WriteMcuAccessRegWord(sc, 0xFABC, 0x49C0);
+        MP_WriteMcuAccessRegWord(sc, 0xFABE, 0xF006);
+        MP_WriteMcuAccessRegWord(sc, 0xFAC0, 0x48C3);
+        MP_WriteMcuAccessRegWord(sc, 0xFAC2, 0x8CF8);
+        MP_WriteMcuAccessRegWord(sc, 0xFAC4, 0xE820);
+        MP_WriteMcuAccessRegWord(sc, 0xFAC6, 0x74F8);
+        MP_WriteMcuAccessRegWord(sc, 0xFAC8, 0x74F8);
+        MP_WriteMcuAccessRegWord(sc, 0xFACA, 0xC432);
+        MP_WriteMcuAccessRegWord(sc, 0xFACC, 0xBC00);
+        MP_WriteMcuAccessRegWord(sc, 0xFACE, 0xC5E4);
+        MP_WriteMcuAccessRegWord(sc, 0xFAD0, 0x74A2);
+        MP_WriteMcuAccessRegWord(sc, 0xFAD2, 0x49CE);
+        MP_WriteMcuAccessRegWord(sc, 0xFAD4, 0xF1FE);
+        MP_WriteMcuAccessRegWord(sc, 0xFAD6, 0x9EA0);
+        MP_WriteMcuAccessRegWord(sc, 0xFAD8, 0x1C1C);
+        MP_WriteMcuAccessRegWord(sc, 0xFADA, 0x484F);
+        MP_WriteMcuAccessRegWord(sc, 0xFADC, 0x9CA2);
+        MP_WriteMcuAccessRegWord(sc, 0xFADE, 0xFF80);
+        MP_WriteMcuAccessRegWord(sc, 0xFAE0, 0xB404);
+        MP_WriteMcuAccessRegWord(sc, 0xFAE2, 0xB405);
+        MP_WriteMcuAccessRegWord(sc, 0xFAE4, 0xC5D9);
+        MP_WriteMcuAccessRegWord(sc, 0xFAE6, 0x74A2);
+        MP_WriteMcuAccessRegWord(sc, 0xFAE8, 0x49CE);
+        MP_WriteMcuAccessRegWord(sc, 0xFAEA, 0xF1FE);
+        MP_WriteMcuAccessRegWord(sc, 0xFAEC, 0xC41F);
+        MP_WriteMcuAccessRegWord(sc, 0xFAEE, 0x9CA0);
+        MP_WriteMcuAccessRegWord(sc, 0xFAF0, 0xC41C);
+        MP_WriteMcuAccessRegWord(sc, 0xFAF2, 0x1C13);
+        MP_WriteMcuAccessRegWord(sc, 0xFAF4, 0x484F);
+        MP_WriteMcuAccessRegWord(sc, 0xFAF6, 0x9CA2);
+        MP_WriteMcuAccessRegWord(sc, 0xFAF8, 0x74A2);
+        MP_WriteMcuAccessRegWord(sc, 0xFAFA, 0x49CF);
+        MP_WriteMcuAccessRegWord(sc, 0xFAFC, 0xF1FE);
+        MP_WriteMcuAccessRegWord(sc, 0xFAFE, 0xB005);
+        MP_WriteMcuAccessRegWord(sc, 0xFB00, 0xB004);
+        MP_WriteMcuAccessRegWord(sc, 0xFB02, 0xFF80);
+        MP_WriteMcuAccessRegWord(sc, 0xFB04, 0xB404);
+        MP_WriteMcuAccessRegWord(sc, 0xFB06, 0xB405);
+        MP_WriteMcuAccessRegWord(sc, 0xFB08, 0xC5C7);
+        MP_WriteMcuAccessRegWord(sc, 0xFB0A, 0x74A2);
+        MP_WriteMcuAccessRegWord(sc, 0xFB0C, 0x49CE);
+        MP_WriteMcuAccessRegWord(sc, 0xFB0E, 0xF1FE);
+        MP_WriteMcuAccessRegWord(sc, 0xFB10, 0xC40E);
+        MP_WriteMcuAccessRegWord(sc, 0xFB12, 0x9CA0);
+        MP_WriteMcuAccessRegWord(sc, 0xFB14, 0xC40A);
+        MP_WriteMcuAccessRegWord(sc, 0xFB16, 0x1C13);
+        MP_WriteMcuAccessRegWord(sc, 0xFB18, 0x484F);
+        MP_WriteMcuAccessRegWord(sc, 0xFB1A, 0x9CA2);
+        MP_WriteMcuAccessRegWord(sc, 0xFB1C, 0x74A2);
+        MP_WriteMcuAccessRegWord(sc, 0xFB1E, 0x49CF);
+        MP_WriteMcuAccessRegWord(sc, 0xFB20, 0xF1FE);
+        MP_WriteMcuAccessRegWord(sc, 0xFB22, 0xB005);
+        MP_WriteMcuAccessRegWord(sc, 0xFB24, 0xB004);
+        MP_WriteMcuAccessRegWord(sc, 0xFB26, 0xFF80);
+        MP_WriteMcuAccessRegWord(sc, 0xFB28, 0x0000);
+        MP_WriteMcuAccessRegWord(sc, 0xFB2A, 0x0481);
+        MP_WriteMcuAccessRegWord(sc, 0xFB2C, 0x0C81);
+        MP_WriteMcuAccessRegWord(sc, 0xFB2E, 0x0AE0);
+
+        MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000);
+
+        MP_WriteMcuAccessRegWord(sc, 0xFC28, 0x0000);
+        MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x0000);
+        MP_WriteMcuAccessRegWord(sc, 0xFC2C, 0x0297);
+        MP_WriteMcuAccessRegWord(sc, 0xFC2E, 0x0000);
+        MP_WriteMcuAccessRegWord(sc, 0xFC30, 0x00A9);
+        MP_WriteMcuAccessRegWord(sc, 0xFC32, 0x012D);
+        MP_WriteMcuAccessRegWord(sc, 0xFC34, 0x0000);
+        MP_WriteMcuAccessRegWord(sc, 0xFC36, 0x08DF);
 }
 
-static void re_hw_mac_mcu_config(struct re_softc *sc)
+static void re_set_mac_mcu_8411b_1(struct re_softc *sc)
 {
-        switch(sc->re_type) {
-        case MACFG_56:
-                MP_WriteMcuAccessRegWord(sc, 0xE43C, 0x0000);
-                MP_WriteMcuAccessRegWord(sc, 0xE43E, 0x0000);
+        DisableMcuBPs(sc);
+
+        MP_WriteMcuAccessRegWord(sc, 0xF800, 0xE008);
+        MP_WriteMcuAccessRegWord(sc, 0xF802, 0xE00A);
+        MP_WriteMcuAccessRegWord(sc, 0xF804, 0xE00C);
+        MP_WriteMcuAccessRegWord(sc, 0xF806, 0xE00E);
+        MP_WriteMcuAccessRegWord(sc, 0xF808, 0xE027);
+        MP_WriteMcuAccessRegWord(sc, 0xF80A, 0xE04F);
+        MP_WriteMcuAccessRegWord(sc, 0xF80C, 0xE05E);
+        MP_WriteMcuAccessRegWord(sc, 0xF80E, 0xE065);
+        MP_WriteMcuAccessRegWord(sc, 0xF810, 0xC602);
+        MP_WriteMcuAccessRegWord(sc, 0xF812, 0xBE00);
+        MP_WriteMcuAccessRegWord(sc, 0xF814, 0x0000);
+        MP_WriteMcuAccessRegWord(sc, 0xF816, 0xC502);
+        MP_WriteMcuAccessRegWord(sc, 0xF818, 0xBD00);
+        MP_WriteMcuAccessRegWord(sc, 0xF81A, 0x074C);
+        MP_WriteMcuAccessRegWord(sc, 0xF81C, 0xC302);
+        MP_WriteMcuAccessRegWord(sc, 0xF81E, 0xBB00);
+        MP_WriteMcuAccessRegWord(sc, 0xF820, 0x080A);
+        MP_WriteMcuAccessRegWord(sc, 0xF822, 0x6420);
+        MP_WriteMcuAccessRegWord(sc, 0xF824, 0x48C2);
+        MP_WriteMcuAccessRegWord(sc, 0xF826, 0x8C20);
+        MP_WriteMcuAccessRegWord(sc, 0xF828, 0xC516);
+        MP_WriteMcuAccessRegWord(sc, 0xF82A, 0x64A4);
+        MP_WriteMcuAccessRegWord(sc, 0xF82C, 0x49C0);
+        MP_WriteMcuAccessRegWord(sc, 0xF82E, 0xF009);
+        MP_WriteMcuAccessRegWord(sc, 0xF830, 0x74A2);
+        MP_WriteMcuAccessRegWord(sc, 0xF832, 0x8CA5);
+        MP_WriteMcuAccessRegWord(sc, 0xF834, 0x74A0);
+        MP_WriteMcuAccessRegWord(sc, 0xF836, 0xC50E);
+        MP_WriteMcuAccessRegWord(sc, 0xF838, 0x9CA2);
+        MP_WriteMcuAccessRegWord(sc, 0xF83A, 0x1C11);
+        MP_WriteMcuAccessRegWord(sc, 0xF83C, 0x9CA0);
+        MP_WriteMcuAccessRegWord(sc, 0xF83E, 0xE006);
+        MP_WriteMcuAccessRegWord(sc, 0xF840, 0x74F8);
+        MP_WriteMcuAccessRegWord(sc, 0xF842, 0x48C4);
+        MP_WriteMcuAccessRegWord(sc, 0xF844, 0x8CF8);
+        MP_WriteMcuAccessRegWord(sc, 0xF846, 0xC404);
+        MP_WriteMcuAccessRegWord(sc, 0xF848, 0xBC00);
+        MP_WriteMcuAccessRegWord(sc, 0xF84A, 0xC403);
+        MP_WriteMcuAccessRegWord(sc, 0xF84C, 0xBC00);
+        MP_WriteMcuAccessRegWord(sc, 0xF84E, 0x0BF2);
+        MP_WriteMcuAccessRegWord(sc, 0xF850, 0x0C0A);
+        MP_WriteMcuAccessRegWord(sc, 0xF852, 0xE434);
+        MP_WriteMcuAccessRegWord(sc, 0xF854, 0xD3C0);
+        MP_WriteMcuAccessRegWord(sc, 0xF856, 0x49D9);
+        MP_WriteMcuAccessRegWord(sc, 0xF858, 0xF01F);
+        MP_WriteMcuAccessRegWord(sc, 0xF85A, 0xC526);
+        MP_WriteMcuAccessRegWord(sc, 0xF85C, 0x64A5);
+        MP_WriteMcuAccessRegWord(sc, 0xF85E, 0x1400);
+        MP_WriteMcuAccessRegWord(sc, 0xF860, 0xF007);
+        MP_WriteMcuAccessRegWord(sc, 0xF862, 0x0C01);
+        MP_WriteMcuAccessRegWord(sc, 0xF864, 0x8CA5);
+        MP_WriteMcuAccessRegWord(sc, 0xF866, 0x1C15);
+        MP_WriteMcuAccessRegWord(sc, 0xF868, 0xC51B);
+        MP_WriteMcuAccessRegWord(sc, 0xF86A, 0x9CA0);
+        MP_WriteMcuAccessRegWord(sc, 0xF86C, 0xE013);
+        MP_WriteMcuAccessRegWord(sc, 0xF86E, 0xC519);
+        MP_WriteMcuAccessRegWord(sc, 0xF870, 0x74A0);
+        MP_WriteMcuAccessRegWord(sc, 0xF872, 0x48C4);
+        MP_WriteMcuAccessRegWord(sc, 0xF874, 0x8CA0);
+        MP_WriteMcuAccessRegWord(sc, 0xF876, 0xC516);
+        MP_WriteMcuAccessRegWord(sc, 0xF878, 0x74A4);
+        MP_WriteMcuAccessRegWord(sc, 0xF87A, 0x48C8);
+        MP_WriteMcuAccessRegWord(sc, 0xF87C, 0x48CA);
+        MP_WriteMcuAccessRegWord(sc, 0xF87E, 0x9CA4);
+        MP_WriteMcuAccessRegWord(sc, 0xF880, 0xC512);
+        MP_WriteMcuAccessRegWord(sc, 0xF882, 0x1B00);
+        MP_WriteMcuAccessRegWord(sc, 0xF884, 0x9BA0);
+        MP_WriteMcuAccessRegWord(sc, 0xF886, 0x1B1C);
+        MP_WriteMcuAccessRegWord(sc, 0xF888, 0x483F);
+        MP_WriteMcuAccessRegWord(sc, 0xF88A, 0x9BA2);
+        MP_WriteMcuAccessRegWord(sc, 0xF88C, 0x1B04);
+        MP_WriteMcuAccessRegWord(sc, 0xF88E, 0xC508);
+        MP_WriteMcuAccessRegWord(sc, 0xF890, 0x9BA0);
+        MP_WriteMcuAccessRegWord(sc, 0xF892, 0xC505);
+        MP_WriteMcuAccessRegWord(sc, 0xF894, 0xBD00);
+        MP_WriteMcuAccessRegWord(sc, 0xF896, 0xC502);
+        MP_WriteMcuAccessRegWord(sc, 0xF898, 0xBD00);
+        MP_WriteMcuAccessRegWord(sc, 0xF89A, 0x0300);
+        MP_WriteMcuAccessRegWord(sc, 0xF89C, 0x051E);
+        MP_WriteMcuAccessRegWord(sc, 0xF89E, 0xE434);
+        MP_WriteMcuAccessRegWord(sc, 0xF8A0, 0xE018);
+        MP_WriteMcuAccessRegWord(sc, 0xF8A2, 0xE092);
+        MP_WriteMcuAccessRegWord(sc, 0xF8A4, 0xDE20);
+        MP_WriteMcuAccessRegWord(sc, 0xF8A6, 0xD3C0);
+        MP_WriteMcuAccessRegWord(sc, 0xF8A8, 0xC50F);
+        MP_WriteMcuAccessRegWord(sc, 0xF8AA, 0x76A4);
+        MP_WriteMcuAccessRegWord(sc, 0xF8AC, 0x49E3);
+        MP_WriteMcuAccessRegWord(sc, 0xF8AE, 0xF007);
+        MP_WriteMcuAccessRegWord(sc, 0xF8B0, 0x49C0);
+        MP_WriteMcuAccessRegWord(sc, 0xF8B2, 0xF103);
+        MP_WriteMcuAccessRegWord(sc, 0xF8B4, 0xC607);
+        MP_WriteMcuAccessRegWord(sc, 0xF8B6, 0xBE00);
+        MP_WriteMcuAccessRegWord(sc, 0xF8B8, 0xC606);
+        MP_WriteMcuAccessRegWord(sc, 0xF8BA, 0xBE00);
+        MP_WriteMcuAccessRegWord(sc, 0xF8BC, 0xC602);
+        MP_WriteMcuAccessRegWord(sc, 0xF8BE, 0xBE00);
+        MP_WriteMcuAccessRegWord(sc, 0xF8C0, 0x0C4C);
+        MP_WriteMcuAccessRegWord(sc, 0xF8C2, 0x0C28);
+        MP_WriteMcuAccessRegWord(sc, 0xF8C4, 0x0C2C);
+        MP_WriteMcuAccessRegWord(sc, 0xF8C6, 0xDC00);
+        MP_WriteMcuAccessRegWord(sc, 0xF8C8, 0xC707);
+        MP_WriteMcuAccessRegWord(sc, 0xF8CA, 0x1D00);
+        MP_WriteMcuAccessRegWord(sc, 0xF8CC, 0x8DE2);
+        MP_WriteMcuAccessRegWord(sc, 0xF8CE, 0x48C1);
+        MP_WriteMcuAccessRegWord(sc, 0xF8D0, 0xC502);
+        MP_WriteMcuAccessRegWord(sc, 0xF8D2, 0xBD00);
+        MP_WriteMcuAccessRegWord(sc, 0xF8D4, 0x00AA);
+        MP_WriteMcuAccessRegWord(sc, 0xF8D6, 0xE0C0);
+        MP_WriteMcuAccessRegWord(sc, 0xF8D8, 0xC502);
+        MP_WriteMcuAccessRegWord(sc, 0xF8DA, 0xBD00);
+        MP_WriteMcuAccessRegWord(sc, 0xF8DC, 0x0132);
+
+        MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000);
+
+        MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x0743);
+        MP_WriteMcuAccessRegWord(sc, 0xFC2C, 0x0801);
+        MP_WriteMcuAccessRegWord(sc, 0xFC2E, 0x0BE9);
+        MP_WriteMcuAccessRegWord(sc, 0xFC30, 0x02FD);
+        MP_WriteMcuAccessRegWord(sc, 0xFC32, 0x0C25);
+        MP_WriteMcuAccessRegWord(sc, 0xFC34, 0x00A9);
+        MP_WriteMcuAccessRegWord(sc, 0xFC36, 0x012D);
+}
 
-                MP_WriteMcuAccessRegWord(sc, 0xE434, 0x0004);
-                MP_WriteMcuAccessRegWord(sc, 0xE43C, 0x0004);
+static void re_set_mac_mcu_8168ep_1(struct re_softc *sc)
+{
+        DisableMcuBPs(sc);
+
+        MP_WriteMcuAccessRegWord(sc, 0xF800, 0xE008);
+        MP_WriteMcuAccessRegWord(sc, 0xF802, 0xE0D3);
+        MP_WriteMcuAccessRegWord(sc, 0xF804, 0xE0D6);
+        MP_WriteMcuAccessRegWord(sc, 0xF806, 0xE0D9);
+        MP_WriteMcuAccessRegWord(sc, 0xF808, 0xE0DB);
+        MP_WriteMcuAccessRegWord(sc, 0xF80A, 0xE0DD);
+        MP_WriteMcuAccessRegWord(sc, 0xF80C, 0xE0DF);
+        MP_WriteMcuAccessRegWord(sc, 0xF80E, 0xE0E1);
+        MP_WriteMcuAccessRegWord(sc, 0xF810, 0xC251);
+        MP_WriteMcuAccessRegWord(sc, 0xF812, 0x7340);
+        MP_WriteMcuAccessRegWord(sc, 0xF814, 0x49B1);
+        MP_WriteMcuAccessRegWord(sc, 0xF816, 0xF010);
+        MP_WriteMcuAccessRegWord(sc, 0xF818, 0x1D02);
+        MP_WriteMcuAccessRegWord(sc, 0xF81A, 0x8D40);
+        MP_WriteMcuAccessRegWord(sc, 0xF81C, 0xC202);
+        MP_WriteMcuAccessRegWord(sc, 0xF81E, 0xBA00);
+        MP_WriteMcuAccessRegWord(sc, 0xF820, 0x2C3A);
+        MP_WriteMcuAccessRegWord(sc, 0xF822, 0xC0F0);
+        MP_WriteMcuAccessRegWord(sc, 0xF824, 0xE8DE);
+        MP_WriteMcuAccessRegWord(sc, 0xF826, 0x2000);
+        MP_WriteMcuAccessRegWord(sc, 0xF828, 0x8000);
+        MP_WriteMcuAccessRegWord(sc, 0xF82A, 0xC0B6);
+        MP_WriteMcuAccessRegWord(sc, 0xF82C, 0x268C);
+        MP_WriteMcuAccessRegWord(sc, 0xF82E, 0x752C);
+        MP_WriteMcuAccessRegWord(sc, 0xF830, 0x49D4);
+        MP_WriteMcuAccessRegWord(sc, 0xF832, 0xF112);
+        MP_WriteMcuAccessRegWord(sc, 0xF834, 0xE025);
+        MP_WriteMcuAccessRegWord(sc, 0xF836, 0xC2F6);
+        MP_WriteMcuAccessRegWord(sc, 0xF838, 0x7146);
+        MP_WriteMcuAccessRegWord(sc, 0xF83A, 0xC2F5);
+        MP_WriteMcuAccessRegWord(sc, 0xF83C, 0x7340);
+        MP_WriteMcuAccessRegWord(sc, 0xF83E, 0x49BE);
+        MP_WriteMcuAccessRegWord(sc, 0xF840, 0xF103);
+        MP_WriteMcuAccessRegWord(sc, 0xF842, 0xC7F2);
+        MP_WriteMcuAccessRegWord(sc, 0xF844, 0xE002);
+        MP_WriteMcuAccessRegWord(sc, 0xF846, 0xC7F1);
+        MP_WriteMcuAccessRegWord(sc, 0xF848, 0x304F);
+        MP_WriteMcuAccessRegWord(sc, 0xF84A, 0x6226);
+        MP_WriteMcuAccessRegWord(sc, 0xF84C, 0x49A1);
+        MP_WriteMcuAccessRegWord(sc, 0xF84E, 0xF1F0);
+        MP_WriteMcuAccessRegWord(sc, 0xF850, 0x7222);
+        MP_WriteMcuAccessRegWord(sc, 0xF852, 0x49A0);
+        MP_WriteMcuAccessRegWord(sc, 0xF854, 0xF1ED);
+        MP_WriteMcuAccessRegWord(sc, 0xF856, 0x2525);
+        MP_WriteMcuAccessRegWord(sc, 0xF858, 0x1F28);
+        MP_WriteMcuAccessRegWord(sc, 0xF85A, 0x3097);
+        MP_WriteMcuAccessRegWord(sc, 0xF85C, 0x3091);
+        MP_WriteMcuAccessRegWord(sc, 0xF85E, 0x9A36);
+        MP_WriteMcuAccessRegWord(sc, 0xF860, 0x752C);
+        MP_WriteMcuAccessRegWord(sc, 0xF862, 0x21DC);
+        MP_WriteMcuAccessRegWord(sc, 0xF864, 0x25BC);
+        MP_WriteMcuAccessRegWord(sc, 0xF866, 0xC6E2);
+        MP_WriteMcuAccessRegWord(sc, 0xF868, 0x77C0);
+        MP_WriteMcuAccessRegWord(sc, 0xF86A, 0x1304);
+        MP_WriteMcuAccessRegWord(sc, 0xF86C, 0xF014);
+        MP_WriteMcuAccessRegWord(sc, 0xF86E, 0x1303);
+        MP_WriteMcuAccessRegWord(sc, 0xF870, 0xF014);
+        MP_WriteMcuAccessRegWord(sc, 0xF872, 0x1302);
+        MP_WriteMcuAccessRegWord(sc, 0xF874, 0xF014);
+        MP_WriteMcuAccessRegWord(sc, 0xF876, 0x1301);
+        MP_WriteMcuAccessRegWord(sc, 0xF878, 0xF014);
+        MP_WriteMcuAccessRegWord(sc, 0xF87A, 0x49D4);
+        MP_WriteMcuAccessRegWord(sc, 0xF87C, 0xF103);
+        MP_WriteMcuAccessRegWord(sc, 0xF87E, 0xC3D7);
+        MP_WriteMcuAccessRegWord(sc, 0xF880, 0xBB00);
+        MP_WriteMcuAccessRegWord(sc, 0xF882, 0xC618);
+        MP_WriteMcuAccessRegWord(sc, 0xF884, 0x67C6);
+        MP_WriteMcuAccessRegWord(sc, 0xF886, 0x752E);
+        MP_WriteMcuAccessRegWord(sc, 0xF888, 0x22D7);
+        MP_WriteMcuAccessRegWord(sc, 0xF88A, 0x26DD);
+        MP_WriteMcuAccessRegWord(sc, 0xF88C, 0x1505);
+        MP_WriteMcuAccessRegWord(sc, 0xF88E, 0xF013);
+        MP_WriteMcuAccessRegWord(sc, 0xF890, 0xC60A);
+        MP_WriteMcuAccessRegWord(sc, 0xF892, 0xBE00);
+        MP_WriteMcuAccessRegWord(sc, 0xF894, 0xC309);
+        MP_WriteMcuAccessRegWord(sc, 0xF896, 0xBB00);
+        MP_WriteMcuAccessRegWord(sc, 0xF898, 0xC308);
+        MP_WriteMcuAccessRegWord(sc, 0xF89A, 0xBB00);
+        MP_WriteMcuAccessRegWord(sc, 0xF89C, 0xC307);
+        MP_WriteMcuAccessRegWord(sc, 0xF89E, 0xBB00);
+        MP_WriteMcuAccessRegWord(sc, 0xF8A0, 0xC306);
+        MP_WriteMcuAccessRegWord(sc, 0xF8A2, 0xBB00);
+        MP_WriteMcuAccessRegWord(sc, 0xF8A4, 0x25C8);
+        MP_WriteMcuAccessRegWord(sc, 0xF8A6, 0x25A6);
+        MP_WriteMcuAccessRegWord(sc, 0xF8A8, 0x25AC);
+        MP_WriteMcuAccessRegWord(sc, 0xF8AA, 0x25B2);
+        MP_WriteMcuAccessRegWord(sc, 0xF8AC, 0x25B8);
+        MP_WriteMcuAccessRegWord(sc, 0xF8AE, 0xCD08);
+        MP_WriteMcuAccessRegWord(sc, 0xF8B0, 0x0000);
+        MP_WriteMcuAccessRegWord(sc, 0xF8B2, 0xC0BC);
+        MP_WriteMcuAccessRegWord(sc, 0xF8B4, 0xC2FF);
+        MP_WriteMcuAccessRegWord(sc, 0xF8B6, 0x7340);
+        MP_WriteMcuAccessRegWord(sc, 0xF8B8, 0x49B0);
+        MP_WriteMcuAccessRegWord(sc, 0xF8BA, 0xF04E);
+        MP_WriteMcuAccessRegWord(sc, 0xF8BC, 0x1F46);
+        MP_WriteMcuAccessRegWord(sc, 0xF8BE, 0x308F);
+        MP_WriteMcuAccessRegWord(sc, 0xF8C0, 0xC3F7);
+        MP_WriteMcuAccessRegWord(sc, 0xF8C2, 0x1C04);
+        MP_WriteMcuAccessRegWord(sc, 0xF8C4, 0xE84D);
+        MP_WriteMcuAccessRegWord(sc, 0xF8C6, 0x1401);
+        MP_WriteMcuAccessRegWord(sc, 0xF8C8, 0xF147);
+        MP_WriteMcuAccessRegWord(sc, 0xF8CA, 0x7226);
+        MP_WriteMcuAccessRegWord(sc, 0xF8CC, 0x49A7);
+        MP_WriteMcuAccessRegWord(sc, 0xF8CE, 0xF044);
+        MP_WriteMcuAccessRegWord(sc, 0xF8D0, 0x7222);
+        MP_WriteMcuAccessRegWord(sc, 0xF8D2, 0x2525);
+        MP_WriteMcuAccessRegWord(sc, 0xF8D4, 0x1F30);
+        MP_WriteMcuAccessRegWord(sc, 0xF8D6, 0x3097);
+        MP_WriteMcuAccessRegWord(sc, 0xF8D8, 0x3091);
+        MP_WriteMcuAccessRegWord(sc, 0xF8DA, 0x7340);
+        MP_WriteMcuAccessRegWord(sc, 0xF8DC, 0xC4EA);
+        MP_WriteMcuAccessRegWord(sc, 0xF8DE, 0x401C);
+        MP_WriteMcuAccessRegWord(sc, 0xF8E0, 0xF006);
+        MP_WriteMcuAccessRegWord(sc, 0xF8E2, 0xC6E8);
+        MP_WriteMcuAccessRegWord(sc, 0xF8E4, 0x75C0);
+        MP_WriteMcuAccessRegWord(sc, 0xF8E6, 0x49D7);
+        MP_WriteMcuAccessRegWord(sc, 0xF8E8, 0xF105);
+        MP_WriteMcuAccessRegWord(sc, 0xF8EA, 0xE036);
+        MP_WriteMcuAccessRegWord(sc, 0xF8EC, 0x1D08);
+        MP_WriteMcuAccessRegWord(sc, 0xF8EE, 0x8DC1);
+        MP_WriteMcuAccessRegWord(sc, 0xF8F0, 0x0208);
+        MP_WriteMcuAccessRegWord(sc, 0xF8F2, 0x6640);
+        MP_WriteMcuAccessRegWord(sc, 0xF8F4, 0x2764);
+        MP_WriteMcuAccessRegWord(sc, 0xF8F6, 0x1606);
+        MP_WriteMcuAccessRegWord(sc, 0xF8F8, 0xF12F);
+        MP_WriteMcuAccessRegWord(sc, 0xF8FA, 0x6346);
+        MP_WriteMcuAccessRegWord(sc, 0xF8FC, 0x133B);
+        MP_WriteMcuAccessRegWord(sc, 0xF8FE, 0xF12C);
+        MP_WriteMcuAccessRegWord(sc, 0xF900, 0x9B34);
+        MP_WriteMcuAccessRegWord(sc, 0xF902, 0x1B18);
+        MP_WriteMcuAccessRegWord(sc, 0xF904, 0x3093);
+        MP_WriteMcuAccessRegWord(sc, 0xF906, 0xC32A);
+        MP_WriteMcuAccessRegWord(sc, 0xF908, 0x1C10);
+        MP_WriteMcuAccessRegWord(sc, 0xF90A, 0xE82A);
+        MP_WriteMcuAccessRegWord(sc, 0xF90C, 0x1401);
+        MP_WriteMcuAccessRegWord(sc, 0xF90E, 0xF124);
+        MP_WriteMcuAccessRegWord(sc, 0xF910, 0x1A36);
+        MP_WriteMcuAccessRegWord(sc, 0xF912, 0x308A);
+        MP_WriteMcuAccessRegWord(sc, 0xF914, 0x7322);
+        MP_WriteMcuAccessRegWord(sc, 0xF916, 0x25B5);
+        MP_WriteMcuAccessRegWord(sc, 0xF918, 0x0B0E);
+        MP_WriteMcuAccessRegWord(sc, 0xF91A, 0x1C00);
+        MP_WriteMcuAccessRegWord(sc, 0xF91C, 0xE82C);
+        MP_WriteMcuAccessRegWord(sc, 0xF91E, 0xC71F);
+        MP_WriteMcuAccessRegWord(sc, 0xF920, 0x4027);
+        MP_WriteMcuAccessRegWord(sc, 0xF922, 0xF11A);
+        MP_WriteMcuAccessRegWord(sc, 0xF924, 0xE838);
+        MP_WriteMcuAccessRegWord(sc, 0xF926, 0x1F42);
+        MP_WriteMcuAccessRegWord(sc, 0xF928, 0x308F);
+        MP_WriteMcuAccessRegWord(sc, 0xF92A, 0x1B08);
+        MP_WriteMcuAccessRegWord(sc, 0xF92C, 0xE824);
+        MP_WriteMcuAccessRegWord(sc, 0xF92E, 0x7236);
+        MP_WriteMcuAccessRegWord(sc, 0xF930, 0x7746);
+        MP_WriteMcuAccessRegWord(sc, 0xF932, 0x1700);
+        MP_WriteMcuAccessRegWord(sc, 0xF934, 0xF00D);
+        MP_WriteMcuAccessRegWord(sc, 0xF936, 0xC313);
+        MP_WriteMcuAccessRegWord(sc, 0xF938, 0x401F);
+        MP_WriteMcuAccessRegWord(sc, 0xF93A, 0xF103);
+        MP_WriteMcuAccessRegWord(sc, 0xF93C, 0x1F00);
+        MP_WriteMcuAccessRegWord(sc, 0xF93E, 0x9F46);
+        MP_WriteMcuAccessRegWord(sc, 0xF940, 0x7744);
+        MP_WriteMcuAccessRegWord(sc, 0xF942, 0x449F);
+        MP_WriteMcuAccessRegWord(sc, 0xF944, 0x445F);
+        MP_WriteMcuAccessRegWord(sc, 0xF946, 0xE817);
+        MP_WriteMcuAccessRegWord(sc, 0xF948, 0xC70A);
+        MP_WriteMcuAccessRegWord(sc, 0xF94A, 0x4027);
+        MP_WriteMcuAccessRegWord(sc, 0xF94C, 0xF105);
+        MP_WriteMcuAccessRegWord(sc, 0xF94E, 0xC302);
+        MP_WriteMcuAccessRegWord(sc, 0xF950, 0xBB00);
+        MP_WriteMcuAccessRegWord(sc, 0xF952, 0x2E08);
+        MP_WriteMcuAccessRegWord(sc, 0xF954, 0x2DC2);
+        MP_WriteMcuAccessRegWord(sc, 0xF956, 0xC7FF);
+        MP_WriteMcuAccessRegWord(sc, 0xF958, 0xBF00);
+        MP_WriteMcuAccessRegWord(sc, 0xF95A, 0xCDB8);
+        MP_WriteMcuAccessRegWord(sc, 0xF95C, 0xFFFF);
+        MP_WriteMcuAccessRegWord(sc, 0xF95E, 0x0C02);
+        MP_WriteMcuAccessRegWord(sc, 0xF960, 0xA554);
+        MP_WriteMcuAccessRegWord(sc, 0xF962, 0xA5DC);
+        MP_WriteMcuAccessRegWord(sc, 0xF964, 0x402F);
+        MP_WriteMcuAccessRegWord(sc, 0xF966, 0xF105);
+        MP_WriteMcuAccessRegWord(sc, 0xF968, 0x1400);
+        MP_WriteMcuAccessRegWord(sc, 0xF96A, 0xF1FA);
+        MP_WriteMcuAccessRegWord(sc, 0xF96C, 0x1C01);
+        MP_WriteMcuAccessRegWord(sc, 0xF96E, 0xE002);
+        MP_WriteMcuAccessRegWord(sc, 0xF970, 0x1C00);
+        MP_WriteMcuAccessRegWord(sc, 0xF972, 0xFF80);
+        MP_WriteMcuAccessRegWord(sc, 0xF974, 0x49B0);
+        MP_WriteMcuAccessRegWord(sc, 0xF976, 0xF004);
+        MP_WriteMcuAccessRegWord(sc, 0xF978, 0x0B01);
+        MP_WriteMcuAccessRegWord(sc, 0xF97A, 0xA1D3);
+        MP_WriteMcuAccessRegWord(sc, 0xF97C, 0xE003);
+        MP_WriteMcuAccessRegWord(sc, 0xF97E, 0x0B02);
+        MP_WriteMcuAccessRegWord(sc, 0xF980, 0xA5D3);
+        MP_WriteMcuAccessRegWord(sc, 0xF982, 0x3127);
+        MP_WriteMcuAccessRegWord(sc, 0xF984, 0x3720);
+        MP_WriteMcuAccessRegWord(sc, 0xF986, 0x0B02);
+        MP_WriteMcuAccessRegWord(sc, 0xF988, 0xA5D3);
+        MP_WriteMcuAccessRegWord(sc, 0xF98A, 0x3127);
+        MP_WriteMcuAccessRegWord(sc, 0xF98C, 0x3720);
+        MP_WriteMcuAccessRegWord(sc, 0xF98E, 0x1300);
+        MP_WriteMcuAccessRegWord(sc, 0xF990, 0xF1FB);
+        MP_WriteMcuAccessRegWord(sc, 0xF992, 0xFF80);
+        MP_WriteMcuAccessRegWord(sc, 0xF994, 0x7322);
+        MP_WriteMcuAccessRegWord(sc, 0xF996, 0x25B5);
+        MP_WriteMcuAccessRegWord(sc, 0xF998, 0x1E28);
+        MP_WriteMcuAccessRegWord(sc, 0xF99A, 0x30DE);
+        MP_WriteMcuAccessRegWord(sc, 0xF99C, 0x30D9);
+        MP_WriteMcuAccessRegWord(sc, 0xF99E, 0x7264);
+        MP_WriteMcuAccessRegWord(sc, 0xF9A0, 0x1E11);
+        MP_WriteMcuAccessRegWord(sc, 0xF9A2, 0x2368);
+        MP_WriteMcuAccessRegWord(sc, 0xF9A4, 0x3116);
+        MP_WriteMcuAccessRegWord(sc, 0xF9A6, 0xFF80);
+        MP_WriteMcuAccessRegWord(sc, 0xF9A8, 0x1B7E);
+        MP_WriteMcuAccessRegWord(sc, 0xF9AA, 0xC602);
+        MP_WriteMcuAccessRegWord(sc, 0xF9AC, 0xBE00);
+        MP_WriteMcuAccessRegWord(sc, 0xF9AE, 0x06A6);
+        MP_WriteMcuAccessRegWord(sc, 0xF9B0, 0x1B7E);
+        MP_WriteMcuAccessRegWord(sc, 0xF9B2, 0xC602);
+        MP_WriteMcuAccessRegWord(sc, 0xF9B4, 0xBE00);
+        MP_WriteMcuAccessRegWord(sc, 0xF9B6, 0x0764);
+        MP_WriteMcuAccessRegWord(sc, 0xF9B8, 0xC602);
+        MP_WriteMcuAccessRegWord(sc, 0xF9BA, 0xBE00);
+        MP_WriteMcuAccessRegWord(sc, 0xF9BC, 0x0000);
+        MP_WriteMcuAccessRegWord(sc, 0xF9BE, 0xC602);
+        MP_WriteMcuAccessRegWord(sc, 0xF9C0, 0xBE00);
+        MP_WriteMcuAccessRegWord(sc, 0xF9C2, 0x0000);
+        MP_WriteMcuAccessRegWord(sc, 0xF9C4, 0xC602);
+        MP_WriteMcuAccessRegWord(sc, 0xF9C6, 0xBE00);
+        MP_WriteMcuAccessRegWord(sc, 0xF9C8, 0x0000);
+        MP_WriteMcuAccessRegWord(sc, 0xF9CA, 0xC602);
+        MP_WriteMcuAccessRegWord(sc, 0xF9CC, 0xBE00);
+        MP_WriteMcuAccessRegWord(sc, 0xF9CE, 0x0000);
+        MP_WriteMcuAccessRegWord(sc, 0xF9D0, 0xC602);
+        MP_WriteMcuAccessRegWord(sc, 0xF9D2, 0xBE00);
+        MP_WriteMcuAccessRegWord(sc, 0xF9D4, 0x0000);
+
+        MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000);
+
+        MP_WriteMcuAccessRegWord(sc, 0xFC28, 0x2549);
+        MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x06A5);
+        MP_WriteMcuAccessRegWord(sc, 0xFC2C, 0x0763);
+}
 
-                DisableMcuBPs(sc);
+static void re_set_mac_mcu_8168ep_2(struct re_softc *sc)
+{
+        DisableMcuBPs(sc);
+
+        MP_WriteMcuAccessRegWord(sc, 0xF800, 0xE008);
+        MP_WriteMcuAccessRegWord(sc, 0xF802, 0xE017);
+        MP_WriteMcuAccessRegWord(sc, 0xF804, 0xE019);
+        MP_WriteMcuAccessRegWord(sc, 0xF806, 0xE01B);
+        MP_WriteMcuAccessRegWord(sc, 0xF808, 0xE01D);
+        MP_WriteMcuAccessRegWord(sc, 0xF80A, 0xE01F);
+        MP_WriteMcuAccessRegWord(sc, 0xF80C, 0xE021);
+        MP_WriteMcuAccessRegWord(sc, 0xF80E, 0xE023);
+        MP_WriteMcuAccessRegWord(sc, 0xF810, 0xC50F);
+        MP_WriteMcuAccessRegWord(sc, 0xF812, 0x76A4);
+        MP_WriteMcuAccessRegWord(sc, 0xF814, 0x49E3);
+        MP_WriteMcuAccessRegWord(sc, 0xF816, 0xF007);
+        MP_WriteMcuAccessRegWord(sc, 0xF818, 0x49C0);
+        MP_WriteMcuAccessRegWord(sc, 0xF81A, 0xF103);
+        MP_WriteMcuAccessRegWord(sc, 0xF81C, 0xC607);
+        MP_WriteMcuAccessRegWord(sc, 0xF81E, 0xBE00);
+        MP_WriteMcuAccessRegWord(sc, 0xF820, 0xC606);
+        MP_WriteMcuAccessRegWord(sc, 0xF822, 0xBE00);
+        MP_WriteMcuAccessRegWord(sc, 0xF824, 0xC602);
+        MP_WriteMcuAccessRegWord(sc, 0xF826, 0xBE00);
+        MP_WriteMcuAccessRegWord(sc, 0xF828, 0x0BDA);
+        MP_WriteMcuAccessRegWord(sc, 0xF82A, 0x0BB0);
+        MP_WriteMcuAccessRegWord(sc, 0xF82C, 0x0BBA);
+        MP_WriteMcuAccessRegWord(sc, 0xF82E, 0xDC00);
+        MP_WriteMcuAccessRegWord(sc, 0xF830, 0xC602);
+        MP_WriteMcuAccessRegWord(sc, 0xF832, 0xBE00);
+        MP_WriteMcuAccessRegWord(sc, 0xF834, 0x0000);
+        MP_WriteMcuAccessRegWord(sc, 0xF836, 0xC602);
+        MP_WriteMcuAccessRegWord(sc, 0xF838, 0xBE00);
+        MP_WriteMcuAccessRegWord(sc, 0xF83A, 0x0000);
+        MP_WriteMcuAccessRegWord(sc, 0xF83C, 0xC602);
+        MP_WriteMcuAccessRegWord(sc, 0xF83E, 0xBE00);
+        MP_WriteMcuAccessRegWord(sc, 0xF840, 0x0000);
+        MP_WriteMcuAccessRegWord(sc, 0xF842, 0xC602);
+        MP_WriteMcuAccessRegWord(sc, 0xF844, 0xBE00);
+        MP_WriteMcuAccessRegWord(sc, 0xF846, 0x0000);
+        MP_WriteMcuAccessRegWord(sc, 0xF848, 0xC602);
+        MP_WriteMcuAccessRegWord(sc, 0xF84A, 0xBE00);
+        MP_WriteMcuAccessRegWord(sc, 0xF84C, 0x0000);
+        MP_WriteMcuAccessRegWord(sc, 0xF84E, 0xC602);
+        MP_WriteMcuAccessRegWord(sc, 0xF850, 0xBE00);
+        MP_WriteMcuAccessRegWord(sc, 0xF852, 0x0000);
+        MP_WriteMcuAccessRegWord(sc, 0xF854, 0xC602);
+        MP_WriteMcuAccessRegWord(sc, 0xF856, 0xBE00);
+        MP_WriteMcuAccessRegWord(sc, 0xF858, 0x0000);
+
+        MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000);
+
+        MP_WriteMcuAccessRegWord(sc, 0xFC28, 0x0BB3);
+}
 
-                MP_WriteMcuAccessRegWord(sc, 0xF800, 0xE008);
-                MP_WriteMcuAccessRegWord(sc, 0xF802, 0xE01B);
-                MP_WriteMcuAccessRegWord(sc, 0xF804, 0xE022);
-                MP_WriteMcuAccessRegWord(sc, 0xF806, 0xE094);
-                MP_WriteMcuAccessRegWord(sc, 0xF808, 0xE097);
-                MP_WriteMcuAccessRegWord(sc, 0xF80A, 0xE09A);
-                MP_WriteMcuAccessRegWord(sc, 0xF80C, 0xE0B3);
-                MP_WriteMcuAccessRegWord(sc, 0xF80E, 0xE0BA);
-                MP_WriteMcuAccessRegWord(sc, 0xF810, 0x49D2);
-                MP_WriteMcuAccessRegWord(sc, 0xF812, 0xF10D);
-                MP_WriteMcuAccessRegWord(sc, 0xF814, 0x766C);
-                MP_WriteMcuAccessRegWord(sc, 0xF816, 0x49E2);
-                MP_WriteMcuAccessRegWord(sc, 0xF818, 0xF00A);
-                MP_WriteMcuAccessRegWord(sc, 0xF81A, 0x1EC0);
-                MP_WriteMcuAccessRegWord(sc, 0xF81C, 0x8EE1);
-                MP_WriteMcuAccessRegWord(sc, 0xF81E, 0xC60A);
-                MP_WriteMcuAccessRegWord(sc, 0xF820, 0x77C0);
-                MP_WriteMcuAccessRegWord(sc, 0xF822, 0x4870);
-                MP_WriteMcuAccessRegWord(sc, 0xF824, 0x9FC0);
-                MP_WriteMcuAccessRegWord(sc, 0xF826, 0x1EA0);
-                MP_WriteMcuAccessRegWord(sc, 0xF828, 0xC707);
-                MP_WriteMcuAccessRegWord(sc, 0xF82A, 0x8EE1);
-                MP_WriteMcuAccessRegWord(sc, 0xF82C, 0x9D6C);
-                MP_WriteMcuAccessRegWord(sc, 0xF82E, 0xC603);
-                MP_WriteMcuAccessRegWord(sc, 0xF830, 0xBE00);
-                MP_WriteMcuAccessRegWord(sc, 0xF832, 0xB416);
-                MP_WriteMcuAccessRegWord(sc, 0xF834, 0x0076);
-                MP_WriteMcuAccessRegWord(sc, 0xF836, 0xE86C);
-                MP_WriteMcuAccessRegWord(sc, 0xF838, 0xC406);
-                MP_WriteMcuAccessRegWord(sc, 0xF83A, 0x7580);
-                MP_WriteMcuAccessRegWord(sc, 0xF83C, 0x4852);
-                MP_WriteMcuAccessRegWord(sc, 0xF83E, 0x8D80);
-                MP_WriteMcuAccessRegWord(sc, 0xF840, 0xC403);
-                MP_WriteMcuAccessRegWord(sc, 0xF842, 0xBC00);
-                MP_WriteMcuAccessRegWord(sc, 0xF844, 0xD3E0);
-                MP_WriteMcuAccessRegWord(sc, 0xF846, 0x02C8);
-                MP_WriteMcuAccessRegWord(sc, 0xF848, 0x8918);
-                MP_WriteMcuAccessRegWord(sc, 0xF84A, 0xE815);
-                MP_WriteMcuAccessRegWord(sc, 0xF84C, 0x1100);
-                MP_WriteMcuAccessRegWord(sc, 0xF84E, 0xF011);
-                MP_WriteMcuAccessRegWord(sc, 0xF850, 0xE812);
-                MP_WriteMcuAccessRegWord(sc, 0xF852, 0x4990);
-                MP_WriteMcuAccessRegWord(sc, 0xF854, 0xF002);
-                MP_WriteMcuAccessRegWord(sc, 0xF856, 0xE817);
-                MP_WriteMcuAccessRegWord(sc, 0xF858, 0xE80E);
-                MP_WriteMcuAccessRegWord(sc, 0xF85A, 0x4992);
-                MP_WriteMcuAccessRegWord(sc, 0xF85C, 0xF002);
-                MP_WriteMcuAccessRegWord(sc, 0xF85E, 0xE80E);
-                MP_WriteMcuAccessRegWord(sc, 0xF860, 0xE80A);
-                MP_WriteMcuAccessRegWord(sc, 0xF862, 0x4993);
-                MP_WriteMcuAccessRegWord(sc, 0xF864, 0xF002);
-                MP_WriteMcuAccessRegWord(sc, 0xF866, 0xE818);
-                MP_WriteMcuAccessRegWord(sc, 0xF868, 0xE806);
-                MP_WriteMcuAccessRegWord(sc, 0xF86A, 0x4991);
-                MP_WriteMcuAccessRegWord(sc, 0xF86C, 0xF002);
-                MP_WriteMcuAccessRegWord(sc, 0xF86E, 0xE838);
-                MP_WriteMcuAccessRegWord(sc, 0xF870, 0xC25E);
-                MP_WriteMcuAccessRegWord(sc, 0xF872, 0xBA00);
-                MP_WriteMcuAccessRegWord(sc, 0xF874, 0xC056);
-                MP_WriteMcuAccessRegWord(sc, 0xF876, 0x7100);
-                MP_WriteMcuAccessRegWord(sc, 0xF878, 0xFF80);
-                MP_WriteMcuAccessRegWord(sc, 0xF87A, 0x7100);
-                MP_WriteMcuAccessRegWord(sc, 0xF87C, 0x4892);
-                MP_WriteMcuAccessRegWord(sc, 0xF87E, 0x4813);
-                MP_WriteMcuAccessRegWord(sc, 0xF880, 0x8900);
-                MP_WriteMcuAccessRegWord(sc, 0xF882, 0xE00A);
-                MP_WriteMcuAccessRegWord(sc, 0xF884, 0x7100);
-                MP_WriteMcuAccessRegWord(sc, 0xF886, 0x4890);
-                MP_WriteMcuAccessRegWord(sc, 0xF888, 0x4813);
-                MP_WriteMcuAccessRegWord(sc, 0xF88A, 0x8900);
-                MP_WriteMcuAccessRegWord(sc, 0xF88C, 0xC74B);
-                MP_WriteMcuAccessRegWord(sc, 0xF88E, 0x74F8);
-                MP_WriteMcuAccessRegWord(sc, 0xF890, 0x48C2);
-                MP_WriteMcuAccessRegWord(sc, 0xF892, 0x4841);
-                MP_WriteMcuAccessRegWord(sc, 0xF894, 0x8CF8);
-                MP_WriteMcuAccessRegWord(sc, 0xF896, 0xC746);
-                MP_WriteMcuAccessRegWord(sc, 0xF898, 0x74FC);
-                MP_WriteMcuAccessRegWord(sc, 0xF89A, 0x49C0);
-                MP_WriteMcuAccessRegWord(sc, 0xF89C, 0xF120);
-                MP_WriteMcuAccessRegWord(sc, 0xF89E, 0x49C1);
-                MP_WriteMcuAccessRegWord(sc, 0xF8A0, 0xF11E);
-                MP_WriteMcuAccessRegWord(sc, 0xF8A2, 0x74F8);
-                MP_WriteMcuAccessRegWord(sc, 0xF8A4, 0x49C0);
-                MP_WriteMcuAccessRegWord(sc, 0xF8A6, 0xF01B);
-                MP_WriteMcuAccessRegWord(sc, 0xF8A8, 0x49C6);
-                MP_WriteMcuAccessRegWord(sc, 0xF8AA, 0xF119);
-                MP_WriteMcuAccessRegWord(sc, 0xF8AC, 0x74F8);
-                MP_WriteMcuAccessRegWord(sc, 0xF8AE, 0x49C4);
-                MP_WriteMcuAccessRegWord(sc, 0xF8B0, 0xF013);
-                MP_WriteMcuAccessRegWord(sc, 0xF8B2, 0xC536);
-                MP_WriteMcuAccessRegWord(sc, 0xF8B4, 0x74B0);
-                MP_WriteMcuAccessRegWord(sc, 0xF8B6, 0x49C1);
-                MP_WriteMcuAccessRegWord(sc, 0xF8B8, 0xF1FD);
-                MP_WriteMcuAccessRegWord(sc, 0xF8BA, 0xC537);
-                MP_WriteMcuAccessRegWord(sc, 0xF8BC, 0xC434);
-                MP_WriteMcuAccessRegWord(sc, 0xF8BE, 0x9CA0);
-                MP_WriteMcuAccessRegWord(sc, 0xF8C0, 0xC435);
-                MP_WriteMcuAccessRegWord(sc, 0xF8C2, 0x1C13);
-                MP_WriteMcuAccessRegWord(sc, 0xF8C4, 0x484F);
-                MP_WriteMcuAccessRegWord(sc, 0xF8C6, 0x9CA2);
-                MP_WriteMcuAccessRegWord(sc, 0xF8C8, 0xC52B);
-                MP_WriteMcuAccessRegWord(sc, 0xF8CA, 0x74B0);
-                MP_WriteMcuAccessRegWord(sc, 0xF8CC, 0x49C1);
-                MP_WriteMcuAccessRegWord(sc, 0xF8CE, 0xF1FD);
-                MP_WriteMcuAccessRegWord(sc, 0xF8D0, 0x74F8);
-                MP_WriteMcuAccessRegWord(sc, 0xF8D2, 0x48C4);
-                MP_WriteMcuAccessRegWord(sc, 0xF8D4, 0x8CF8);
-                MP_WriteMcuAccessRegWord(sc, 0xF8D6, 0x7100);
-                MP_WriteMcuAccessRegWord(sc, 0xF8D8, 0x4893);
-                MP_WriteMcuAccessRegWord(sc, 0xF8DA, 0x8900);
-                MP_WriteMcuAccessRegWord(sc, 0xF8DC, 0xFF80);
-                MP_WriteMcuAccessRegWord(sc, 0xF8DE, 0xC520);
-                MP_WriteMcuAccessRegWord(sc, 0xF8E0, 0x74B0);
-                MP_WriteMcuAccessRegWord(sc, 0xF8E2, 0x49C1);
-                MP_WriteMcuAccessRegWord(sc, 0xF8E4, 0xF11C);
-                MP_WriteMcuAccessRegWord(sc, 0xF8E6, 0xC71E);
-                MP_WriteMcuAccessRegWord(sc, 0xF8E8, 0x74FC);
-                MP_WriteMcuAccessRegWord(sc, 0xF8EA, 0x49C1);
-                MP_WriteMcuAccessRegWord(sc, 0xF8EC, 0xF118);
-                MP_WriteMcuAccessRegWord(sc, 0xF8EE, 0x49C0);
-                MP_WriteMcuAccessRegWord(sc, 0xF8F0, 0xF116);
-                MP_WriteMcuAccessRegWord(sc, 0xF8F2, 0x74F8);
-                MP_WriteMcuAccessRegWord(sc, 0xF8F4, 0x49C0);
-                MP_WriteMcuAccessRegWord(sc, 0xF8F6, 0xF013);
-                MP_WriteMcuAccessRegWord(sc, 0xF8F8, 0x48C3);
-                MP_WriteMcuAccessRegWord(sc, 0xF8FA, 0x8CF8);
-                MP_WriteMcuAccessRegWord(sc, 0xF8FC, 0xC516);
-                MP_WriteMcuAccessRegWord(sc, 0xF8FE, 0x74A2);
-                MP_WriteMcuAccessRegWord(sc, 0xF900, 0x49CE);
-                MP_WriteMcuAccessRegWord(sc, 0xF902, 0xF1FE);
-                MP_WriteMcuAccessRegWord(sc, 0xF904, 0xC411);
-                MP_WriteMcuAccessRegWord(sc, 0xF906, 0x9CA0);
-                MP_WriteMcuAccessRegWord(sc, 0xF908, 0xC411);
-                MP_WriteMcuAccessRegWord(sc, 0xF90A, 0x1C13);
-                MP_WriteMcuAccessRegWord(sc, 0xF90C, 0x484F);
-                MP_WriteMcuAccessRegWord(sc, 0xF90E, 0x9CA2);
-                MP_WriteMcuAccessRegWord(sc, 0xF910, 0x74A2);
-                MP_WriteMcuAccessRegWord(sc, 0xF912, 0x49CF);
-                MP_WriteMcuAccessRegWord(sc, 0xF914, 0xF1FE);
-                MP_WriteMcuAccessRegWord(sc, 0xF916, 0x7100);
-                MP_WriteMcuAccessRegWord(sc, 0xF918, 0x4891);
-                MP_WriteMcuAccessRegWord(sc, 0xF91A, 0x8900);
-                MP_WriteMcuAccessRegWord(sc, 0xF91C, 0xFF80);
-                MP_WriteMcuAccessRegWord(sc, 0xF91E, 0xE400);
-                MP_WriteMcuAccessRegWord(sc, 0xF920, 0xD3E0);
-                MP_WriteMcuAccessRegWord(sc, 0xF922, 0xE000);
-                MP_WriteMcuAccessRegWord(sc, 0xF924, 0x0481);
-                MP_WriteMcuAccessRegWord(sc, 0xF926, 0x0C81);
-                MP_WriteMcuAccessRegWord(sc, 0xF928, 0xDE20);
-                MP_WriteMcuAccessRegWord(sc, 0xF92A, 0x0000);
-                MP_WriteMcuAccessRegWord(sc, 0xF92C, 0x0992);
-                MP_WriteMcuAccessRegWord(sc, 0xF92E, 0x1B76);
-                MP_WriteMcuAccessRegWord(sc, 0xF930, 0xC602);
-                MP_WriteMcuAccessRegWord(sc, 0xF932, 0xBE00);
-                MP_WriteMcuAccessRegWord(sc, 0xF934, 0x059C);
-                MP_WriteMcuAccessRegWord(sc, 0xF936, 0x1B76);
-                MP_WriteMcuAccessRegWord(sc, 0xF938, 0xC602);
-                MP_WriteMcuAccessRegWord(sc, 0xF93A, 0xBE00);
-                MP_WriteMcuAccessRegWord(sc, 0xF93C, 0x065A);
-                MP_WriteMcuAccessRegWord(sc, 0xF93E, 0xB400);
-                MP_WriteMcuAccessRegWord(sc, 0xF940, 0x18DE);
-                MP_WriteMcuAccessRegWord(sc, 0xF942, 0x2008);
-                MP_WriteMcuAccessRegWord(sc, 0xF944, 0x4001);
-                MP_WriteMcuAccessRegWord(sc, 0xF946, 0xF10F);
-                MP_WriteMcuAccessRegWord(sc, 0xF948, 0x7342);
-                MP_WriteMcuAccessRegWord(sc, 0xF94A, 0x1880);
-                MP_WriteMcuAccessRegWord(sc, 0xF94C, 0x2008);
-                MP_WriteMcuAccessRegWord(sc, 0xF94E, 0x0009);
-                MP_WriteMcuAccessRegWord(sc, 0xF950, 0x4018);
-                MP_WriteMcuAccessRegWord(sc, 0xF952, 0xF109);
-                MP_WriteMcuAccessRegWord(sc, 0xF954, 0x7340);
-                MP_WriteMcuAccessRegWord(sc, 0xF956, 0x25BC);
-                MP_WriteMcuAccessRegWord(sc, 0xF958, 0x130F);
-                MP_WriteMcuAccessRegWord(sc, 0xF95A, 0xF105);
-                MP_WriteMcuAccessRegWord(sc, 0xF95C, 0xC00A);
-                MP_WriteMcuAccessRegWord(sc, 0xF95E, 0x7300);
-                MP_WriteMcuAccessRegWord(sc, 0xF960, 0x4831);
-                MP_WriteMcuAccessRegWord(sc, 0xF962, 0x9B00);
-                MP_WriteMcuAccessRegWord(sc, 0xF964, 0xB000);
-                MP_WriteMcuAccessRegWord(sc, 0xF966, 0x7340);
-                MP_WriteMcuAccessRegWord(sc, 0xF968, 0x8320);
-                MP_WriteMcuAccessRegWord(sc, 0xF96A, 0xC302);
-                MP_WriteMcuAccessRegWord(sc, 0xF96C, 0xBB00);
-                MP_WriteMcuAccessRegWord(sc, 0xF96E, 0x0C12);
-                MP_WriteMcuAccessRegWord(sc, 0xF970, 0xE860);
-                MP_WriteMcuAccessRegWord(sc, 0xF972, 0xC406);
-                MP_WriteMcuAccessRegWord(sc, 0xF974, 0x7580);
-                MP_WriteMcuAccessRegWord(sc, 0xF976, 0x4851);
-                MP_WriteMcuAccessRegWord(sc, 0xF978, 0x8D80);
-                MP_WriteMcuAccessRegWord(sc, 0xF97A, 0xC403);
-                MP_WriteMcuAccessRegWord(sc, 0xF97C, 0xBC00);
-                MP_WriteMcuAccessRegWord(sc, 0xF97E, 0xD3E0);
-                MP_WriteMcuAccessRegWord(sc, 0xF980, 0x02C8);
-                MP_WriteMcuAccessRegWord(sc, 0xF982, 0xC406);
-                MP_WriteMcuAccessRegWord(sc, 0xF984, 0x7580);
-                MP_WriteMcuAccessRegWord(sc, 0xF986, 0x4850);
-                MP_WriteMcuAccessRegWord(sc, 0xF988, 0x8D80);
-                MP_WriteMcuAccessRegWord(sc, 0xF98A, 0xC403);
-                MP_WriteMcuAccessRegWord(sc, 0xF98C, 0xBC00);
-                MP_WriteMcuAccessRegWord(sc, 0xF98E, 0xD3E0);
-                MP_WriteMcuAccessRegWord(sc, 0xF990, 0x0298);
-
-                MP_WriteMcuAccessRegWord(sc, 0xDE30, 0x0080);
-
-                MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000);
-
-                MP_WriteMcuAccessRegWord(sc, 0xFC28, 0x0075);
-                MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x02B1);
-                MP_WriteMcuAccessRegWord(sc, 0xFC2C, 0x0991);
-                MP_WriteMcuAccessRegWord(sc, 0xFC2E, 0x059B);
-                MP_WriteMcuAccessRegWord(sc, 0xFC30, 0x0659);
-                MP_WriteMcuAccessRegWord(sc, 0xFC32, 0x0000);
-                MP_WriteMcuAccessRegWord(sc, 0xFC34, 0x02BB);
-                MP_WriteMcuAccessRegWord(sc, 0xFC36, 0x0279);
+static void re_set_mac_mcu_8168h_1(struct re_softc *sc)
+{
+        DisableMcuBPs(sc);
+
+        MP_WriteMcuAccessRegWord(sc, 0xF800, 0xE008);
+        MP_WriteMcuAccessRegWord(sc, 0xF802, 0xE00F);
+        MP_WriteMcuAccessRegWord(sc, 0xF804, 0xE011);
+        MP_WriteMcuAccessRegWord(sc, 0xF806, 0xE047);
+        MP_WriteMcuAccessRegWord(sc, 0xF808, 0xE049);
+        MP_WriteMcuAccessRegWord(sc, 0xF80A, 0xE073);
+        MP_WriteMcuAccessRegWord(sc, 0xF80C, 0xE075);
+        MP_WriteMcuAccessRegWord(sc, 0xF80E, 0xE077);
+        MP_WriteMcuAccessRegWord(sc, 0xF810, 0xC707);
+        MP_WriteMcuAccessRegWord(sc, 0xF812, 0x1D00);
+        MP_WriteMcuAccessRegWord(sc, 0xF814, 0x8DE2);
+        MP_WriteMcuAccessRegWord(sc, 0xF816, 0x48C1);
+        MP_WriteMcuAccessRegWord(sc, 0xF818, 0xC502);
+        MP_WriteMcuAccessRegWord(sc, 0xF81A, 0xBD00);
+        MP_WriteMcuAccessRegWord(sc, 0xF81C, 0x00E4);
+        MP_WriteMcuAccessRegWord(sc, 0xF81E, 0xE0C0);
+        MP_WriteMcuAccessRegWord(sc, 0xF820, 0xC502);
+        MP_WriteMcuAccessRegWord(sc, 0xF822, 0xBD00);
+        MP_WriteMcuAccessRegWord(sc, 0xF824, 0x0216);
+        MP_WriteMcuAccessRegWord(sc, 0xF826, 0xC634);
+        MP_WriteMcuAccessRegWord(sc, 0xF828, 0x75C0);
+        MP_WriteMcuAccessRegWord(sc, 0xF82A, 0x49D3);
+        MP_WriteMcuAccessRegWord(sc, 0xF82C, 0xF027);
+        MP_WriteMcuAccessRegWord(sc, 0xF82E, 0xC631);
+        MP_WriteMcuAccessRegWord(sc, 0xF830, 0x75C0);
+        MP_WriteMcuAccessRegWord(sc, 0xF832, 0x49D3);
+        MP_WriteMcuAccessRegWord(sc, 0xF834, 0xF123);
+        MP_WriteMcuAccessRegWord(sc, 0xF836, 0xC627);
+        MP_WriteMcuAccessRegWord(sc, 0xF838, 0x75C0);
+        MP_WriteMcuAccessRegWord(sc, 0xF83A, 0xB405);
+        MP_WriteMcuAccessRegWord(sc, 0xF83C, 0xC525);
+        MP_WriteMcuAccessRegWord(sc, 0xF83E, 0x9DC0);
+        MP_WriteMcuAccessRegWord(sc, 0xF840, 0xC621);
+        MP_WriteMcuAccessRegWord(sc, 0xF842, 0x75C8);
+        MP_WriteMcuAccessRegWord(sc, 0xF844, 0x49D5);
+        MP_WriteMcuAccessRegWord(sc, 0xF846, 0xF00A);
+        MP_WriteMcuAccessRegWord(sc, 0xF848, 0x49D6);
+        MP_WriteMcuAccessRegWord(sc, 0xF84A, 0xF008);
+        MP_WriteMcuAccessRegWord(sc, 0xF84C, 0x49D7);
+        MP_WriteMcuAccessRegWord(sc, 0xF84E, 0xF006);
+        MP_WriteMcuAccessRegWord(sc, 0xF850, 0x49D8);
+        MP_WriteMcuAccessRegWord(sc, 0xF852, 0xF004);
+        MP_WriteMcuAccessRegWord(sc, 0xF854, 0x75D2);
+        MP_WriteMcuAccessRegWord(sc, 0xF856, 0x49D9);
+        MP_WriteMcuAccessRegWord(sc, 0xF858, 0xF111);
+        MP_WriteMcuAccessRegWord(sc, 0xF85A, 0xC517);
+        MP_WriteMcuAccessRegWord(sc, 0xF85C, 0x9DC8);
+        MP_WriteMcuAccessRegWord(sc, 0xF85E, 0xC516);
+        MP_WriteMcuAccessRegWord(sc, 0xF860, 0x9DD2);
+        MP_WriteMcuAccessRegWord(sc, 0xF862, 0xC618);
+        MP_WriteMcuAccessRegWord(sc, 0xF864, 0x75C0);
+        MP_WriteMcuAccessRegWord(sc, 0xF866, 0x49D4);
+        MP_WriteMcuAccessRegWord(sc, 0xF868, 0xF003);
+        MP_WriteMcuAccessRegWord(sc, 0xF86A, 0x49D0);
+        MP_WriteMcuAccessRegWord(sc, 0xF86C, 0xF104);
+        MP_WriteMcuAccessRegWord(sc, 0xF86E, 0xC60A);
+        MP_WriteMcuAccessRegWord(sc, 0xF870, 0xC50E);
+        MP_WriteMcuAccessRegWord(sc, 0xF872, 0x9DC0);
+        MP_WriteMcuAccessRegWord(sc, 0xF874, 0xB005);
+        MP_WriteMcuAccessRegWord(sc, 0xF876, 0xC607);
+        MP_WriteMcuAccessRegWord(sc, 0xF878, 0x9DC0);
+        MP_WriteMcuAccessRegWord(sc, 0xF87A, 0xB007);
+        MP_WriteMcuAccessRegWord(sc, 0xF87C, 0xC602);
+        MP_WriteMcuAccessRegWord(sc, 0xF87E, 0xBE00);
+        MP_WriteMcuAccessRegWord(sc, 0xF880, 0x1A06);
+        MP_WriteMcuAccessRegWord(sc, 0xF882, 0xB400);
+        MP_WriteMcuAccessRegWord(sc, 0xF884, 0xE86C);
+        MP_WriteMcuAccessRegWord(sc, 0xF886, 0xA000);
+        MP_WriteMcuAccessRegWord(sc, 0xF888, 0x01E1);
+        MP_WriteMcuAccessRegWord(sc, 0xF88A, 0x0200);
+        MP_WriteMcuAccessRegWord(sc, 0xF88C, 0x9200);
+        MP_WriteMcuAccessRegWord(sc, 0xF88E, 0xE84C);
+        MP_WriteMcuAccessRegWord(sc, 0xF890, 0xE004);
+        MP_WriteMcuAccessRegWord(sc, 0xF892, 0xE908);
+        MP_WriteMcuAccessRegWord(sc, 0xF894, 0xC502);
+        MP_WriteMcuAccessRegWord(sc, 0xF896, 0xBD00);
+        MP_WriteMcuAccessRegWord(sc, 0xF898, 0x0B58);
+        MP_WriteMcuAccessRegWord(sc, 0xF89A, 0xB407);
+        MP_WriteMcuAccessRegWord(sc, 0xF89C, 0xB404);
+        MP_WriteMcuAccessRegWord(sc, 0xF89E, 0x2195);
+        MP_WriteMcuAccessRegWord(sc, 0xF8A0, 0x25BD);
+        MP_WriteMcuAccessRegWord(sc, 0xF8A2, 0x9BE0);
+        MP_WriteMcuAccessRegWord(sc, 0xF8A4, 0x1C1C);
+        MP_WriteMcuAccessRegWord(sc, 0xF8A6, 0x484F);
+        MP_WriteMcuAccessRegWord(sc, 0xF8A8, 0x9CE2);
+        MP_WriteMcuAccessRegWord(sc, 0xF8AA, 0x72E2);
+        MP_WriteMcuAccessRegWord(sc, 0xF8AC, 0x49AE);
+        MP_WriteMcuAccessRegWord(sc, 0xF8AE, 0xF1FE);
+        MP_WriteMcuAccessRegWord(sc, 0xF8B0, 0x0B00);
+        MP_WriteMcuAccessRegWord(sc, 0xF8B2, 0xF116);
+        MP_WriteMcuAccessRegWord(sc, 0xF8B4, 0xC71C);
+        MP_WriteMcuAccessRegWord(sc, 0xF8B6, 0xC419);
+        MP_WriteMcuAccessRegWord(sc, 0xF8B8, 0x9CE0);
+        MP_WriteMcuAccessRegWord(sc, 0xF8BA, 0x1C13);
+        MP_WriteMcuAccessRegWord(sc, 0xF8BC, 0x484F);
+        MP_WriteMcuAccessRegWord(sc, 0xF8BE, 0x9CE2);
+        MP_WriteMcuAccessRegWord(sc, 0xF8C0, 0x74E2);
+        MP_WriteMcuAccessRegWord(sc, 0xF8C2, 0x49CE);
+        MP_WriteMcuAccessRegWord(sc, 0xF8C4, 0xF1FE);
+        MP_WriteMcuAccessRegWord(sc, 0xF8C6, 0xC412);
+        MP_WriteMcuAccessRegWord(sc, 0xF8C8, 0x9CE0);
+        MP_WriteMcuAccessRegWord(sc, 0xF8CA, 0x1C13);
+        MP_WriteMcuAccessRegWord(sc, 0xF8CC, 0x484F);
+        MP_WriteMcuAccessRegWord(sc, 0xF8CE, 0x9CE2);
+        MP_WriteMcuAccessRegWord(sc, 0xF8D0, 0x74E2);
+        MP_WriteMcuAccessRegWord(sc, 0xF8D2, 0x49CE);
+        MP_WriteMcuAccessRegWord(sc, 0xF8D4, 0xF1FE);
+        MP_WriteMcuAccessRegWord(sc, 0xF8D6, 0xC70C);
+        MP_WriteMcuAccessRegWord(sc, 0xF8D8, 0x74F8);
+        MP_WriteMcuAccessRegWord(sc, 0xF8DA, 0x48C3);
+        MP_WriteMcuAccessRegWord(sc, 0xF8DC, 0x8CF8);
+        MP_WriteMcuAccessRegWord(sc, 0xF8DE, 0xB004);
+        MP_WriteMcuAccessRegWord(sc, 0xF8E0, 0xB007);
+        MP_WriteMcuAccessRegWord(sc, 0xF8E2, 0xC502);
+        MP_WriteMcuAccessRegWord(sc, 0xF8E4, 0xBD00);
+        MP_WriteMcuAccessRegWord(sc, 0xF8E6, 0x0F24);
+        MP_WriteMcuAccessRegWord(sc, 0xF8E8, 0x0481);
+        MP_WriteMcuAccessRegWord(sc, 0xF8EA, 0x0C81);
+        MP_WriteMcuAccessRegWord(sc, 0xF8EC, 0xDE24);
+        MP_WriteMcuAccessRegWord(sc, 0xF8EE, 0xE000);
+        MP_WriteMcuAccessRegWord(sc, 0xF8F0, 0xC602);
+        MP_WriteMcuAccessRegWord(sc, 0xF8F2, 0xBE00);
+        MP_WriteMcuAccessRegWord(sc, 0xF8F4, 0x0CA4);
+        MP_WriteMcuAccessRegWord(sc, 0xF8F6, 0xC502);
+        MP_WriteMcuAccessRegWord(sc, 0xF8F8, 0xBD00);
+        MP_WriteMcuAccessRegWord(sc, 0xF8FA, 0x0000);
+        MP_WriteMcuAccessRegWord(sc, 0xF8FC, 0xC602);
+        MP_WriteMcuAccessRegWord(sc, 0xF8FE, 0xBE00);
+        MP_WriteMcuAccessRegWord(sc, 0xF900, 0x0000);
+
+        MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000);
+
+        MP_WriteMcuAccessRegWord(sc, 0xFC28, 0x00E2);
+        MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x0210);
+        MP_WriteMcuAccessRegWord(sc, 0xFC2C, 0x1A04);
+        MP_WriteMcuAccessRegWord(sc, 0xFC2E, 0x0B26);
+        MP_WriteMcuAccessRegWord(sc, 0xFC30, 0x0F02);
+        MP_WriteMcuAccessRegWord(sc, 0xFC32, 0x0CA0);
+
+        if (sc->re_device_id == RT_DEVICEID_8136)
+                MP_WriteMcuAccessRegWord(sc, 0xFC38, 0x0033);
+        else
+                MP_WriteMcuAccessRegWord(sc, 0xFC38, 0x003F);
+}
+
+static void re_set_mac_mcu_8168fp_1(struct re_softc *sc)
+{
+        DisableMcuBPs(sc);
+
+        MP_WriteMcuAccessRegWord(sc, 0xF800, 0xE00A);
+        MP_WriteMcuAccessRegWord(sc, 0xF802, 0xE0C1);
+        MP_WriteMcuAccessRegWord(sc, 0xF804, 0xE104);
+        MP_WriteMcuAccessRegWord(sc, 0xF806, 0xE108);
+        MP_WriteMcuAccessRegWord(sc, 0xF808, 0xE10D);
+        MP_WriteMcuAccessRegWord(sc, 0xF80A, 0xE112);
+        MP_WriteMcuAccessRegWord(sc, 0xF80C, 0xE11C);
+        MP_WriteMcuAccessRegWord(sc, 0xF80E, 0xE121);
+        MP_WriteMcuAccessRegWord(sc, 0xF810, 0xE000);
+        MP_WriteMcuAccessRegWord(sc, 0xF812, 0xE0C8);
+        MP_WriteMcuAccessRegWord(sc, 0xF814, 0xB400);
+        MP_WriteMcuAccessRegWord(sc, 0xF816, 0xC1FE);
+        MP_WriteMcuAccessRegWord(sc, 0xF818, 0x49E2);
+        MP_WriteMcuAccessRegWord(sc, 0xF81A, 0xF04C);
+        MP_WriteMcuAccessRegWord(sc, 0xF81C, 0x49EA);
+        MP_WriteMcuAccessRegWord(sc, 0xF81E, 0xF04A);
+        MP_WriteMcuAccessRegWord(sc, 0xF820, 0x74E6);
+        MP_WriteMcuAccessRegWord(sc, 0xF822, 0xC246);
+        MP_WriteMcuAccessRegWord(sc, 0xF824, 0x7542);
+        MP_WriteMcuAccessRegWord(sc, 0xF826, 0x73EC);
+        MP_WriteMcuAccessRegWord(sc, 0xF828, 0x1800);
+        MP_WriteMcuAccessRegWord(sc, 0xF82A, 0x49C0);
+        MP_WriteMcuAccessRegWord(sc, 0xF82C, 0xF10D);
+        MP_WriteMcuAccessRegWord(sc, 0xF82E, 0x49C1);
+        MP_WriteMcuAccessRegWord(sc, 0xF830, 0xF10B);
+        MP_WriteMcuAccessRegWord(sc, 0xF832, 0x49C2);
+        MP_WriteMcuAccessRegWord(sc, 0xF834, 0xF109);
+        MP_WriteMcuAccessRegWord(sc, 0xF836, 0x49B0);
+        MP_WriteMcuAccessRegWord(sc, 0xF838, 0xF107);
+        MP_WriteMcuAccessRegWord(sc, 0xF83A, 0x49B1);
+        MP_WriteMcuAccessRegWord(sc, 0xF83C, 0xF105);
+        MP_WriteMcuAccessRegWord(sc, 0xF83E, 0x7220);
+        MP_WriteMcuAccessRegWord(sc, 0xF840, 0x49A2);
+        MP_WriteMcuAccessRegWord(sc, 0xF842, 0xF102);
+        MP_WriteMcuAccessRegWord(sc, 0xF844, 0xE002);
+        MP_WriteMcuAccessRegWord(sc, 0xF846, 0x4800);
+        MP_WriteMcuAccessRegWord(sc, 0xF848, 0x49D0);
+        MP_WriteMcuAccessRegWord(sc, 0xF84A, 0xF10A);
+        MP_WriteMcuAccessRegWord(sc, 0xF84C, 0x49D1);
+        MP_WriteMcuAccessRegWord(sc, 0xF84E, 0xF108);
+        MP_WriteMcuAccessRegWord(sc, 0xF850, 0x49D2);
+        MP_WriteMcuAccessRegWord(sc, 0xF852, 0xF106);
+        MP_WriteMcuAccessRegWord(sc, 0xF854, 0x49D3);
+        MP_WriteMcuAccessRegWord(sc, 0xF856, 0xF104);
+        MP_WriteMcuAccessRegWord(sc, 0xF858, 0x49DF);
+        MP_WriteMcuAccessRegWord(sc, 0xF85A, 0xF102);
+        MP_WriteMcuAccessRegWord(sc, 0xF85C, 0xE00C);
+        MP_WriteMcuAccessRegWord(sc, 0xF85E, 0x4801);
+        MP_WriteMcuAccessRegWord(sc, 0xF860, 0x72E4);
+        MP_WriteMcuAccessRegWord(sc, 0xF862, 0x49AD);
+        MP_WriteMcuAccessRegWord(sc, 0xF864, 0xF108);
+        MP_WriteMcuAccessRegWord(sc, 0xF866, 0xC225);
+        MP_WriteMcuAccessRegWord(sc, 0xF868, 0x6741);
+        MP_WriteMcuAccessRegWord(sc, 0xF86A, 0x48F0);
+        MP_WriteMcuAccessRegWord(sc, 0xF86C, 0x8F41);
+        MP_WriteMcuAccessRegWord(sc, 0xF86E, 0x4870);
+        MP_WriteMcuAccessRegWord(sc, 0xF870, 0x8F41);
+        MP_WriteMcuAccessRegWord(sc, 0xF872, 0xC7CF);
+        MP_WriteMcuAccessRegWord(sc, 0xF874, 0x49B5);
+        MP_WriteMcuAccessRegWord(sc, 0xF876, 0xF01F);
+        MP_WriteMcuAccessRegWord(sc, 0xF878, 0x49B2);
+        MP_WriteMcuAccessRegWord(sc, 0xF87A, 0xF00B);
+        MP_WriteMcuAccessRegWord(sc, 0xF87C, 0x4980);
+        MP_WriteMcuAccessRegWord(sc, 0xF87E, 0xF003);
+        MP_WriteMcuAccessRegWord(sc, 0xF880, 0x484E);
+        MP_WriteMcuAccessRegWord(sc, 0xF882, 0x94E7);
+        MP_WriteMcuAccessRegWord(sc, 0xF884, 0x4981);
+        MP_WriteMcuAccessRegWord(sc, 0xF886, 0xF004);
+        MP_WriteMcuAccessRegWord(sc, 0xF888, 0x485E);
+        MP_WriteMcuAccessRegWord(sc, 0xF88A, 0xC212);
+        MP_WriteMcuAccessRegWord(sc, 0xF88C, 0x9543);
+        MP_WriteMcuAccessRegWord(sc, 0xF88E, 0xE071);
+        MP_WriteMcuAccessRegWord(sc, 0xF890, 0x49B6);
+        MP_WriteMcuAccessRegWord(sc, 0xF892, 0xF003);
+        MP_WriteMcuAccessRegWord(sc, 0xF894, 0x49B3);
+        MP_WriteMcuAccessRegWord(sc, 0xF896, 0xF10F);
+        MP_WriteMcuAccessRegWord(sc, 0xF898, 0x4980);
+        MP_WriteMcuAccessRegWord(sc, 0xF89A, 0xF003);
+        MP_WriteMcuAccessRegWord(sc, 0xF89C, 0x484E);
+        MP_WriteMcuAccessRegWord(sc, 0xF89E, 0x94E7);
+        MP_WriteMcuAccessRegWord(sc, 0xF8A0, 0x4981);
+        MP_WriteMcuAccessRegWord(sc, 0xF8A2, 0xF004);
+        MP_WriteMcuAccessRegWord(sc, 0xF8A4, 0x485E);
+        MP_WriteMcuAccessRegWord(sc, 0xF8A6, 0xC204);
+        MP_WriteMcuAccessRegWord(sc, 0xF8A8, 0x9543);
+        MP_WriteMcuAccessRegWord(sc, 0xF8AA, 0xE005);
+        MP_WriteMcuAccessRegWord(sc, 0xF8AC, 0xE000);
+        MP_WriteMcuAccessRegWord(sc, 0xF8AE, 0xE0FC);
+        MP_WriteMcuAccessRegWord(sc, 0xF8B0, 0xE0FA);
+        MP_WriteMcuAccessRegWord(sc, 0xF8B2, 0xE065);
+        MP_WriteMcuAccessRegWord(sc, 0xF8B4, 0x49B7);
+        MP_WriteMcuAccessRegWord(sc, 0xF8B6, 0xF007);
+        MP_WriteMcuAccessRegWord(sc, 0xF8B8, 0x4980);
+        MP_WriteMcuAccessRegWord(sc, 0xF8BA, 0xF005);
+        MP_WriteMcuAccessRegWord(sc, 0xF8BC, 0x1A38);
+        MP_WriteMcuAccessRegWord(sc, 0xF8BE, 0x46D4);
+        MP_WriteMcuAccessRegWord(sc, 0xF8C0, 0x1200);
+        MP_WriteMcuAccessRegWord(sc, 0xF8C2, 0xF109);
+        MP_WriteMcuAccessRegWord(sc, 0xF8C4, 0x4981);
+        MP_WriteMcuAccessRegWord(sc, 0xF8C6, 0xF055);
+        MP_WriteMcuAccessRegWord(sc, 0xF8C8, 0x49C3);
+        MP_WriteMcuAccessRegWord(sc, 0xF8CA, 0xF105);
+        MP_WriteMcuAccessRegWord(sc, 0xF8CC, 0x1A30);
+        MP_WriteMcuAccessRegWord(sc, 0xF8CE, 0x46D5);
+        MP_WriteMcuAccessRegWord(sc, 0xF8D0, 0x1200);
+        MP_WriteMcuAccessRegWord(sc, 0xF8D2, 0xF04F);
+        MP_WriteMcuAccessRegWord(sc, 0xF8D4, 0x7220);
+        MP_WriteMcuAccessRegWord(sc, 0xF8D6, 0x49A2);
+        MP_WriteMcuAccessRegWord(sc, 0xF8D8, 0xF130);
+        MP_WriteMcuAccessRegWord(sc, 0xF8DA, 0x49C1);
+        MP_WriteMcuAccessRegWord(sc, 0xF8DC, 0xF12E);
+        MP_WriteMcuAccessRegWord(sc, 0xF8DE, 0x49B0);
+        MP_WriteMcuAccessRegWord(sc, 0xF8E0, 0xF12C);
+        MP_WriteMcuAccessRegWord(sc, 0xF8E2, 0xC2E6);
+        MP_WriteMcuAccessRegWord(sc, 0xF8E4, 0x7240);
+        MP_WriteMcuAccessRegWord(sc, 0xF8E6, 0x49A8);
+        MP_WriteMcuAccessRegWord(sc, 0xF8E8, 0xF003);
+        MP_WriteMcuAccessRegWord(sc, 0xF8EA, 0x49D0);
+        MP_WriteMcuAccessRegWord(sc, 0xF8EC, 0xF126);
+        MP_WriteMcuAccessRegWord(sc, 0xF8EE, 0x49A9);
+        MP_WriteMcuAccessRegWord(sc, 0xF8F0, 0xF003);
+        MP_WriteMcuAccessRegWord(sc, 0xF8F2, 0x49D1);
+        MP_WriteMcuAccessRegWord(sc, 0xF8F4, 0xF122);
+        MP_WriteMcuAccessRegWord(sc, 0xF8F6, 0x49AA);
+        MP_WriteMcuAccessRegWord(sc, 0xF8F8, 0xF003);
+        MP_WriteMcuAccessRegWord(sc, 0xF8FA, 0x49D2);
+        MP_WriteMcuAccessRegWord(sc, 0xF8FC, 0xF11E);
+        MP_WriteMcuAccessRegWord(sc, 0xF8FE, 0x49AB);
+        MP_WriteMcuAccessRegWord(sc, 0xF900, 0xF003);
+        MP_WriteMcuAccessRegWord(sc, 0xF902, 0x49DF);
+        MP_WriteMcuAccessRegWord(sc, 0xF904, 0xF11A);
+        MP_WriteMcuAccessRegWord(sc, 0xF906, 0x49AC);
+        MP_WriteMcuAccessRegWord(sc, 0xF908, 0xF003);
+        MP_WriteMcuAccessRegWord(sc, 0xF90A, 0x49D3);
+        MP_WriteMcuAccessRegWord(sc, 0xF90C, 0xF116);
+        MP_WriteMcuAccessRegWord(sc, 0xF90E, 0x4980);
+        MP_WriteMcuAccessRegWord(sc, 0xF910, 0xF003);
+        MP_WriteMcuAccessRegWord(sc, 0xF912, 0x49C7);
+        MP_WriteMcuAccessRegWord(sc, 0xF914, 0xF105);
+        MP_WriteMcuAccessRegWord(sc, 0xF916, 0x4981);
+        MP_WriteMcuAccessRegWord(sc, 0xF918, 0xF02C);
+        MP_WriteMcuAccessRegWord(sc, 0xF91A, 0x49D7);
+        MP_WriteMcuAccessRegWord(sc, 0xF91C, 0xF02A);
+        MP_WriteMcuAccessRegWord(sc, 0xF91E, 0x49C0);
+        MP_WriteMcuAccessRegWord(sc, 0xF920, 0xF00C);
+        MP_WriteMcuAccessRegWord(sc, 0xF922, 0xC721);
+        MP_WriteMcuAccessRegWord(sc, 0xF924, 0x62F4);
+        MP_WriteMcuAccessRegWord(sc, 0xF926, 0x49A0);
+        MP_WriteMcuAccessRegWord(sc, 0xF928, 0xF008);
+        MP_WriteMcuAccessRegWord(sc, 0xF92A, 0x49A4);
+        MP_WriteMcuAccessRegWord(sc, 0xF92C, 0xF106);
+        MP_WriteMcuAccessRegWord(sc, 0xF92E, 0x4824);
+        MP_WriteMcuAccessRegWord(sc, 0xF930, 0x8AF4);
+        MP_WriteMcuAccessRegWord(sc, 0xF932, 0xC71A);
+        MP_WriteMcuAccessRegWord(sc, 0xF934, 0x1A40);
+        MP_WriteMcuAccessRegWord(sc, 0xF936, 0x9AE0);
+        MP_WriteMcuAccessRegWord(sc, 0xF938, 0x49B6);
+        MP_WriteMcuAccessRegWord(sc, 0xF93A, 0xF017);
+        MP_WriteMcuAccessRegWord(sc, 0xF93C, 0x200E);
+        MP_WriteMcuAccessRegWord(sc, 0xF93E, 0xC7B8);
+        MP_WriteMcuAccessRegWord(sc, 0xF940, 0x72E0);
+        MP_WriteMcuAccessRegWord(sc, 0xF942, 0x4710);
+        MP_WriteMcuAccessRegWord(sc, 0xF944, 0x92E1);
+        MP_WriteMcuAccessRegWord(sc, 0xF946, 0xC70E);
+        MP_WriteMcuAccessRegWord(sc, 0xF948, 0x77E0);
+        MP_WriteMcuAccessRegWord(sc, 0xF94A, 0x49F0);
+        MP_WriteMcuAccessRegWord(sc, 0xF94C, 0xF112);
+        MP_WriteMcuAccessRegWord(sc, 0xF94E, 0xC70B);
+        MP_WriteMcuAccessRegWord(sc, 0xF950, 0x77E0);
+        MP_WriteMcuAccessRegWord(sc, 0xF952, 0x27FE);
+        MP_WriteMcuAccessRegWord(sc, 0xF954, 0x1AFA);
+        MP_WriteMcuAccessRegWord(sc, 0xF956, 0x4317);
+        MP_WriteMcuAccessRegWord(sc, 0xF958, 0xC705);
+        MP_WriteMcuAccessRegWord(sc, 0xF95A, 0x9AE2);
+        MP_WriteMcuAccessRegWord(sc, 0xF95C, 0x1A11);
+        MP_WriteMcuAccessRegWord(sc, 0xF95E, 0x8AE0);
+        MP_WriteMcuAccessRegWord(sc, 0xF960, 0xE008);
+        MP_WriteMcuAccessRegWord(sc, 0xF962, 0xE41C);
+        MP_WriteMcuAccessRegWord(sc, 0xF964, 0xC0AE);
+        MP_WriteMcuAccessRegWord(sc, 0xF966, 0xD23A);
+        MP_WriteMcuAccessRegWord(sc, 0xF968, 0xC7A2);
+        MP_WriteMcuAccessRegWord(sc, 0xF96A, 0x74E6);
+        MP_WriteMcuAccessRegWord(sc, 0xF96C, 0x484F);
+        MP_WriteMcuAccessRegWord(sc, 0xF96E, 0x94E7);
+        MP_WriteMcuAccessRegWord(sc, 0xF970, 0xC79E);
+        MP_WriteMcuAccessRegWord(sc, 0xF972, 0x8CE6);
+        MP_WriteMcuAccessRegWord(sc, 0xF974, 0x8BEC);
+        MP_WriteMcuAccessRegWord(sc, 0xF976, 0xC29C);
+        MP_WriteMcuAccessRegWord(sc, 0xF978, 0x8D42);
+        MP_WriteMcuAccessRegWord(sc, 0xF97A, 0x7220);
+        MP_WriteMcuAccessRegWord(sc, 0xF97C, 0xB000);
+        MP_WriteMcuAccessRegWord(sc, 0xF97E, 0xC502);
+        MP_WriteMcuAccessRegWord(sc, 0xF980, 0xBD00);
+        MP_WriteMcuAccessRegWord(sc, 0xF982, 0x0932);
+        MP_WriteMcuAccessRegWord(sc, 0xF984, 0xB400);
+        MP_WriteMcuAccessRegWord(sc, 0xF986, 0xC240);
+        MP_WriteMcuAccessRegWord(sc, 0xF988, 0xC340);
+        MP_WriteMcuAccessRegWord(sc, 0xF98A, 0x7060);
+        MP_WriteMcuAccessRegWord(sc, 0xF98C, 0x498F);
+        MP_WriteMcuAccessRegWord(sc, 0xF98E, 0xF014);
+        MP_WriteMcuAccessRegWord(sc, 0xF990, 0x488F);
+        MP_WriteMcuAccessRegWord(sc, 0xF992, 0x9061);
+        MP_WriteMcuAccessRegWord(sc, 0xF994, 0x744C);
+        MP_WriteMcuAccessRegWord(sc, 0xF996, 0x49C3);
+        MP_WriteMcuAccessRegWord(sc, 0xF998, 0xF004);
+        MP_WriteMcuAccessRegWord(sc, 0xF99A, 0x7562);
+        MP_WriteMcuAccessRegWord(sc, 0xF99C, 0x485E);
+        MP_WriteMcuAccessRegWord(sc, 0xF99E, 0x9563);
+        MP_WriteMcuAccessRegWord(sc, 0xF9A0, 0x7446);
+        MP_WriteMcuAccessRegWord(sc, 0xF9A2, 0x49C3);
+        MP_WriteMcuAccessRegWord(sc, 0xF9A4, 0xF106);
+        MP_WriteMcuAccessRegWord(sc, 0xF9A6, 0x7562);
+        MP_WriteMcuAccessRegWord(sc, 0xF9A8, 0x1C30);
+        MP_WriteMcuAccessRegWord(sc, 0xF9AA, 0x46E5);
+        MP_WriteMcuAccessRegWord(sc, 0xF9AC, 0x1200);
+        MP_WriteMcuAccessRegWord(sc, 0xF9AE, 0xF004);
+        MP_WriteMcuAccessRegWord(sc, 0xF9B0, 0x7446);
+        MP_WriteMcuAccessRegWord(sc, 0xF9B2, 0x484F);
+        MP_WriteMcuAccessRegWord(sc, 0xF9B4, 0x9447);
+        MP_WriteMcuAccessRegWord(sc, 0xF9B6, 0xC32A);
+        MP_WriteMcuAccessRegWord(sc, 0xF9B8, 0x7466);
+        MP_WriteMcuAccessRegWord(sc, 0xF9BA, 0x49C0);
+        MP_WriteMcuAccessRegWord(sc, 0xF9BC, 0xF00F);
+        MP_WriteMcuAccessRegWord(sc, 0xF9BE, 0x48C0);
+        MP_WriteMcuAccessRegWord(sc, 0xF9C0, 0x9C66);
+        MP_WriteMcuAccessRegWord(sc, 0xF9C2, 0x7446);
+        MP_WriteMcuAccessRegWord(sc, 0xF9C4, 0x4840);
+        MP_WriteMcuAccessRegWord(sc, 0xF9C6, 0x4841);
+        MP_WriteMcuAccessRegWord(sc, 0xF9C8, 0x4842);
+        MP_WriteMcuAccessRegWord(sc, 0xF9CA, 0x9C46);
+        MP_WriteMcuAccessRegWord(sc, 0xF9CC, 0x744C);
+        MP_WriteMcuAccessRegWord(sc, 0xF9CE, 0x4840);
+        MP_WriteMcuAccessRegWord(sc, 0xF9D0, 0x9C4C);
+        MP_WriteMcuAccessRegWord(sc, 0xF9D2, 0x744A);
+        MP_WriteMcuAccessRegWord(sc, 0xF9D4, 0x484A);
+        MP_WriteMcuAccessRegWord(sc, 0xF9D6, 0x9C4A);
+        MP_WriteMcuAccessRegWord(sc, 0xF9D8, 0xE013);
+        MP_WriteMcuAccessRegWord(sc, 0xF9DA, 0x498E);
+        MP_WriteMcuAccessRegWord(sc, 0xF9DC, 0xF011);
+        MP_WriteMcuAccessRegWord(sc, 0xF9DE, 0x488E);
+        MP_WriteMcuAccessRegWord(sc, 0xF9E0, 0x9061);
+        MP_WriteMcuAccessRegWord(sc, 0xF9E2, 0x744C);
+        MP_WriteMcuAccessRegWord(sc, 0xF9E4, 0x49C3);
+        MP_WriteMcuAccessRegWord(sc, 0xF9E6, 0xF004);
+        MP_WriteMcuAccessRegWord(sc, 0xF9E8, 0x7446);
+        MP_WriteMcuAccessRegWord(sc, 0xF9EA, 0x484E);
+        MP_WriteMcuAccessRegWord(sc, 0xF9EC, 0x9447);
+        MP_WriteMcuAccessRegWord(sc, 0xF9EE, 0x7446);
+        MP_WriteMcuAccessRegWord(sc, 0xF9F0, 0x1D38);
+        MP_WriteMcuAccessRegWord(sc, 0xF9F2, 0x46EC);
+        MP_WriteMcuAccessRegWord(sc, 0xF9F4, 0x1500);
+        MP_WriteMcuAccessRegWord(sc, 0xF9F6, 0xF004);
+        MP_WriteMcuAccessRegWord(sc, 0xF9F8, 0x7446);
+        MP_WriteMcuAccessRegWord(sc, 0xF9FA, 0x484F);
+        MP_WriteMcuAccessRegWord(sc, 0xF9FC, 0x9447);
+        MP_WriteMcuAccessRegWord(sc, 0xF9FE, 0xB000);
+        MP_WriteMcuAccessRegWord(sc, 0xFA00, 0xC502);
+        MP_WriteMcuAccessRegWord(sc, 0xFA02, 0xBD00);
+        MP_WriteMcuAccessRegWord(sc, 0xFA04, 0x074C);
+        MP_WriteMcuAccessRegWord(sc, 0xFA06, 0xE000);
+        MP_WriteMcuAccessRegWord(sc, 0xFA08, 0xE0FC);
+        MP_WriteMcuAccessRegWord(sc, 0xFA0A, 0xE0C0);
+        MP_WriteMcuAccessRegWord(sc, 0xFA0C, 0x4830);
+        MP_WriteMcuAccessRegWord(sc, 0xFA0E, 0x4837);
+        MP_WriteMcuAccessRegWord(sc, 0xFA10, 0xC502);
+        MP_WriteMcuAccessRegWord(sc, 0xFA12, 0xBD00);
+        MP_WriteMcuAccessRegWord(sc, 0xFA14, 0x0978);
+        MP_WriteMcuAccessRegWord(sc, 0xFA16, 0x63E2);
+        MP_WriteMcuAccessRegWord(sc, 0xFA18, 0x4830);
+        MP_WriteMcuAccessRegWord(sc, 0xFA1A, 0x4837);
+        MP_WriteMcuAccessRegWord(sc, 0xFA1C, 0xC502);
+        MP_WriteMcuAccessRegWord(sc, 0xFA1E, 0xBD00);
+        MP_WriteMcuAccessRegWord(sc, 0xFA20, 0x09FE);
+        MP_WriteMcuAccessRegWord(sc, 0xFA22, 0x73E2);
+        MP_WriteMcuAccessRegWord(sc, 0xFA24, 0x4830);
+        MP_WriteMcuAccessRegWord(sc, 0xFA26, 0x8BE2);
+        MP_WriteMcuAccessRegWord(sc, 0xFA28, 0xC302);
+        MP_WriteMcuAccessRegWord(sc, 0xFA2A, 0xBB00);
+        MP_WriteMcuAccessRegWord(sc, 0xFA2C, 0x0A12);
+        MP_WriteMcuAccessRegWord(sc, 0xFA2E, 0x73E2);
+        MP_WriteMcuAccessRegWord(sc, 0xFA30, 0x48B0);
+        MP_WriteMcuAccessRegWord(sc, 0xFA32, 0x48B3);
+        MP_WriteMcuAccessRegWord(sc, 0xFA34, 0x48B4);
+        MP_WriteMcuAccessRegWord(sc, 0xFA36, 0x48B5);
+        MP_WriteMcuAccessRegWord(sc, 0xFA38, 0x48B6);
+        MP_WriteMcuAccessRegWord(sc, 0xFA3A, 0x48B7);
+        MP_WriteMcuAccessRegWord(sc, 0xFA3C, 0x8BE2);
+        MP_WriteMcuAccessRegWord(sc, 0xFA3E, 0xC302);
+        MP_WriteMcuAccessRegWord(sc, 0xFA40, 0xBB00);
+        MP_WriteMcuAccessRegWord(sc, 0xFA42, 0x0A5A);
+        MP_WriteMcuAccessRegWord(sc, 0xFA44, 0x73E2);
+        MP_WriteMcuAccessRegWord(sc, 0xFA46, 0x4830);
+        MP_WriteMcuAccessRegWord(sc, 0xFA48, 0x8BE2);
+        MP_WriteMcuAccessRegWord(sc, 0xFA4A, 0xC302);
+        MP_WriteMcuAccessRegWord(sc, 0xFA4C, 0xBB00);
+        MP_WriteMcuAccessRegWord(sc, 0xFA4E, 0x0A6C);
+        MP_WriteMcuAccessRegWord(sc, 0xFA50, 0x73E2);
+        MP_WriteMcuAccessRegWord(sc, 0xFA52, 0x4830);
+        MP_WriteMcuAccessRegWord(sc, 0xFA54, 0x4837);
+        MP_WriteMcuAccessRegWord(sc, 0xFA56, 0xC502);
+        MP_WriteMcuAccessRegWord(sc, 0xFA58, 0xBD00);
+        MP_WriteMcuAccessRegWord(sc, 0xFA5A, 0x0A86);
+
+        MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000);
+
+        MP_WriteMcuAccessRegWord(sc, 0xFC28, 0x0890);
+        MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x0712);
+        MP_WriteMcuAccessRegWord(sc, 0xFC2C, 0x0974);
+        MP_WriteMcuAccessRegWord(sc, 0xFC2E, 0x09FC);
+        MP_WriteMcuAccessRegWord(sc, 0xFC30, 0x0A0E);
+        MP_WriteMcuAccessRegWord(sc, 0xFC32, 0x0A56);
+        MP_WriteMcuAccessRegWord(sc, 0xFC34, 0x0A68);
+        MP_WriteMcuAccessRegWord(sc, 0xFC36, 0x0A84);
+
+        if (sc->HwPkgDet == 0x0)
+                MP_WriteMcuAccessRegWord(sc, 0xFC38, 0x00FC);
+        else if(sc->HwPkgDet == 0xF)
+                MP_WriteMcuAccessRegWord(sc, 0xFC38, 0x00FF);
+}
+
+static void re_set_mac_mcu_8168fp_2(struct re_softc *sc)
+{
+        DisableMcuBPs(sc);
+
+        MP_WriteMcuAccessRegWord(sc, 0xF800, 0xE008);
+        MP_WriteMcuAccessRegWord(sc, 0xF802, 0xE00A);
+        MP_WriteMcuAccessRegWord(sc, 0xF804, 0xE031);
+        MP_WriteMcuAccessRegWord(sc, 0xF806, 0xE033);
+        MP_WriteMcuAccessRegWord(sc, 0xF808, 0xE035);
+        MP_WriteMcuAccessRegWord(sc, 0xF80A, 0xE144);
+        MP_WriteMcuAccessRegWord(sc, 0xF80C, 0xE166);
+        MP_WriteMcuAccessRegWord(sc, 0xF80E, 0xE168);
+        MP_WriteMcuAccessRegWord(sc, 0xF810, 0xC502);
+        MP_WriteMcuAccessRegWord(sc, 0xF812, 0xBD00);
+        MP_WriteMcuAccessRegWord(sc, 0xF814, 0x0000);
+        MP_WriteMcuAccessRegWord(sc, 0xF816, 0xC725);
+        MP_WriteMcuAccessRegWord(sc, 0xF818, 0x75E0);
+        MP_WriteMcuAccessRegWord(sc, 0xF81A, 0x48D0);
+        MP_WriteMcuAccessRegWord(sc, 0xF81C, 0x9DE0);
+        MP_WriteMcuAccessRegWord(sc, 0xF81E, 0xC722);
+        MP_WriteMcuAccessRegWord(sc, 0xF820, 0x75E0);
+        MP_WriteMcuAccessRegWord(sc, 0xF822, 0x1C78);
+        MP_WriteMcuAccessRegWord(sc, 0xF824, 0x416C);
+        MP_WriteMcuAccessRegWord(sc, 0xF826, 0x1530);
+        MP_WriteMcuAccessRegWord(sc, 0xF828, 0xF111);
+        MP_WriteMcuAccessRegWord(sc, 0xF82A, 0xC71D);
+        MP_WriteMcuAccessRegWord(sc, 0xF82C, 0x75F6);
+        MP_WriteMcuAccessRegWord(sc, 0xF82E, 0x49D1);
+        MP_WriteMcuAccessRegWord(sc, 0xF830, 0xF00D);
+        MP_WriteMcuAccessRegWord(sc, 0xF832, 0x75E0);
+        MP_WriteMcuAccessRegWord(sc, 0xF834, 0x1C1F);
+        MP_WriteMcuAccessRegWord(sc, 0xF836, 0x416C);
+        MP_WriteMcuAccessRegWord(sc, 0xF838, 0x1502);
+        MP_WriteMcuAccessRegWord(sc, 0xF83A, 0xF108);
+        MP_WriteMcuAccessRegWord(sc, 0xF83C, 0x75FA);
+        MP_WriteMcuAccessRegWord(sc, 0xF83E, 0x49D3);
+        MP_WriteMcuAccessRegWord(sc, 0xF840, 0xF005);
+        MP_WriteMcuAccessRegWord(sc, 0xF842, 0x75EC);
+        MP_WriteMcuAccessRegWord(sc, 0xF844, 0x9DE4);
+        MP_WriteMcuAccessRegWord(sc, 0xF846, 0x4853);
+        MP_WriteMcuAccessRegWord(sc, 0xF848, 0x9DFA);
+        MP_WriteMcuAccessRegWord(sc, 0xF84A, 0xC70B);
+        MP_WriteMcuAccessRegWord(sc, 0xF84C, 0x75E0);
+        MP_WriteMcuAccessRegWord(sc, 0xF84E, 0x4852);
+        MP_WriteMcuAccessRegWord(sc, 0xF850, 0x4850);
+        MP_WriteMcuAccessRegWord(sc, 0xF852, 0x9DE0);
+        MP_WriteMcuAccessRegWord(sc, 0xF854, 0xC602);
+        MP_WriteMcuAccessRegWord(sc, 0xF856, 0xBE00);
+        MP_WriteMcuAccessRegWord(sc, 0xF858, 0x04B8);
+        MP_WriteMcuAccessRegWord(sc, 0xF85A, 0xE420);
+        MP_WriteMcuAccessRegWord(sc, 0xF85C, 0xE000);
+        MP_WriteMcuAccessRegWord(sc, 0xF85E, 0xE0FC);
+        MP_WriteMcuAccessRegWord(sc, 0xF860, 0xE43C);
+        MP_WriteMcuAccessRegWord(sc, 0xF862, 0xDC00);
+        MP_WriteMcuAccessRegWord(sc, 0xF864, 0xEB00);
+        MP_WriteMcuAccessRegWord(sc, 0xF866, 0xC202);
+        MP_WriteMcuAccessRegWord(sc, 0xF868, 0xBA00);
+        MP_WriteMcuAccessRegWord(sc, 0xF86A, 0x0000);
+        MP_WriteMcuAccessRegWord(sc, 0xF86C, 0xC002);
+        MP_WriteMcuAccessRegWord(sc, 0xF86E, 0xB800);
+        MP_WriteMcuAccessRegWord(sc, 0xF870, 0x0000);
+        MP_WriteMcuAccessRegWord(sc, 0xF872, 0xB401);
+        MP_WriteMcuAccessRegWord(sc, 0xF874, 0xB402);
+        MP_WriteMcuAccessRegWord(sc, 0xF876, 0xB403);
+        MP_WriteMcuAccessRegWord(sc, 0xF878, 0xB404);
+        MP_WriteMcuAccessRegWord(sc, 0xF87A, 0xB405);
+        MP_WriteMcuAccessRegWord(sc, 0xF87C, 0xB406);
+        MP_WriteMcuAccessRegWord(sc, 0xF87E, 0xC44D);
+        MP_WriteMcuAccessRegWord(sc, 0xF880, 0xC54D);
+        MP_WriteMcuAccessRegWord(sc, 0xF882, 0x1867);
+        MP_WriteMcuAccessRegWord(sc, 0xF884, 0xE8A2);
+        MP_WriteMcuAccessRegWord(sc, 0xF886, 0x2318);
+        MP_WriteMcuAccessRegWord(sc, 0xF888, 0x276E);
+        MP_WriteMcuAccessRegWord(sc, 0xF88A, 0x1601);
+        MP_WriteMcuAccessRegWord(sc, 0xF88C, 0xF106);
+        MP_WriteMcuAccessRegWord(sc, 0xF88E, 0x1A07);
+        MP_WriteMcuAccessRegWord(sc, 0xF890, 0xE861);
+        MP_WriteMcuAccessRegWord(sc, 0xF892, 0xE86B);
+        MP_WriteMcuAccessRegWord(sc, 0xF894, 0xE873);
+        MP_WriteMcuAccessRegWord(sc, 0xF896, 0xE037);
+        MP_WriteMcuAccessRegWord(sc, 0xF898, 0x231E);
+        MP_WriteMcuAccessRegWord(sc, 0xF89A, 0x276E);
+        MP_WriteMcuAccessRegWord(sc, 0xF89C, 0x1602);
+        MP_WriteMcuAccessRegWord(sc, 0xF89E, 0xF10B);
+        MP_WriteMcuAccessRegWord(sc, 0xF8A0, 0x1A07);
+        MP_WriteMcuAccessRegWord(sc, 0xF8A2, 0xE858);
+        MP_WriteMcuAccessRegWord(sc, 0xF8A4, 0xE862);
+        MP_WriteMcuAccessRegWord(sc, 0xF8A6, 0xC247);
+        MP_WriteMcuAccessRegWord(sc, 0xF8A8, 0xC344);
+        MP_WriteMcuAccessRegWord(sc, 0xF8AA, 0xE8E3);
+        MP_WriteMcuAccessRegWord(sc, 0xF8AC, 0xC73B);
+        MP_WriteMcuAccessRegWord(sc, 0xF8AE, 0x66E0);
+        MP_WriteMcuAccessRegWord(sc, 0xF8B0, 0xE8B5);
+        MP_WriteMcuAccessRegWord(sc, 0xF8B2, 0xE029);
+        MP_WriteMcuAccessRegWord(sc, 0xF8B4, 0x231A);
+        MP_WriteMcuAccessRegWord(sc, 0xF8B6, 0x276C);
+        MP_WriteMcuAccessRegWord(sc, 0xF8B8, 0xC733);
+        MP_WriteMcuAccessRegWord(sc, 0xF8BA, 0x9EE0);
+        MP_WriteMcuAccessRegWord(sc, 0xF8BC, 0x1866);
+        MP_WriteMcuAccessRegWord(sc, 0xF8BE, 0xE885);
+        MP_WriteMcuAccessRegWord(sc, 0xF8C0, 0x251C);
+        MP_WriteMcuAccessRegWord(sc, 0xF8C2, 0x120F);
+        MP_WriteMcuAccessRegWord(sc, 0xF8C4, 0xF011);
+        MP_WriteMcuAccessRegWord(sc, 0xF8C6, 0x1209);
+        MP_WriteMcuAccessRegWord(sc, 0xF8C8, 0xF011);
+        MP_WriteMcuAccessRegWord(sc, 0xF8CA, 0x2014);
+        MP_WriteMcuAccessRegWord(sc, 0xF8CC, 0x240E);
+        MP_WriteMcuAccessRegWord(sc, 0xF8CE, 0x1000);
+        MP_WriteMcuAccessRegWord(sc, 0xF8D0, 0xF007);
+        MP_WriteMcuAccessRegWord(sc, 0xF8D2, 0x120C);
+        MP_WriteMcuAccessRegWord(sc, 0xF8D4, 0xF00D);
+        MP_WriteMcuAccessRegWord(sc, 0xF8D6, 0x1203);
+        MP_WriteMcuAccessRegWord(sc, 0xF8D8, 0xF00D);
+        MP_WriteMcuAccessRegWord(sc, 0xF8DA, 0x1200);
+        MP_WriteMcuAccessRegWord(sc, 0xF8DC, 0xF00D);
+        MP_WriteMcuAccessRegWord(sc, 0xF8DE, 0x120C);
+        MP_WriteMcuAccessRegWord(sc, 0xF8E0, 0xF00D);
+        MP_WriteMcuAccessRegWord(sc, 0xF8E2, 0x1203);
+        MP_WriteMcuAccessRegWord(sc, 0xF8E4, 0xF00D);
+        MP_WriteMcuAccessRegWord(sc, 0xF8E6, 0x1A03);
+        MP_WriteMcuAccessRegWord(sc, 0xF8E8, 0xE00C);
+        MP_WriteMcuAccessRegWord(sc, 0xF8EA, 0x1A07);
+        MP_WriteMcuAccessRegWord(sc, 0xF8EC, 0xE00A);
+        MP_WriteMcuAccessRegWord(sc, 0xF8EE, 0x1A00);
+        MP_WriteMcuAccessRegWord(sc, 0xF8F0, 0xE008);
+        MP_WriteMcuAccessRegWord(sc, 0xF8F2, 0x1A01);
+        MP_WriteMcuAccessRegWord(sc, 0xF8F4, 0xE006);
+        MP_WriteMcuAccessRegWord(sc, 0xF8F6, 0x1A02);
+        MP_WriteMcuAccessRegWord(sc, 0xF8F8, 0xE004);
+        MP_WriteMcuAccessRegWord(sc, 0xF8FA, 0x1A04);
+        MP_WriteMcuAccessRegWord(sc, 0xF8FC, 0xE002);
+        MP_WriteMcuAccessRegWord(sc, 0xF8FE, 0x1A05);
+        MP_WriteMcuAccessRegWord(sc, 0xF900, 0xE829);
+        MP_WriteMcuAccessRegWord(sc, 0xF902, 0xE833);
+        MP_WriteMcuAccessRegWord(sc, 0xF904, 0xB006);
+        MP_WriteMcuAccessRegWord(sc, 0xF906, 0xB005);
+        MP_WriteMcuAccessRegWord(sc, 0xF908, 0xB004);
+        MP_WriteMcuAccessRegWord(sc, 0xF90A, 0xB003);
+        MP_WriteMcuAccessRegWord(sc, 0xF90C, 0xB002);
+        MP_WriteMcuAccessRegWord(sc, 0xF90E, 0xB001);
+        MP_WriteMcuAccessRegWord(sc, 0xF910, 0x60C4);
+        MP_WriteMcuAccessRegWord(sc, 0xF912, 0xC702);
+        MP_WriteMcuAccessRegWord(sc, 0xF914, 0xBF00);
+        MP_WriteMcuAccessRegWord(sc, 0xF916, 0x2786);
+        MP_WriteMcuAccessRegWord(sc, 0xF918, 0xDD00);
+        MP_WriteMcuAccessRegWord(sc, 0xF91A, 0xD030);
+        MP_WriteMcuAccessRegWord(sc, 0xF91C, 0xE0C4);
+        MP_WriteMcuAccessRegWord(sc, 0xF91E, 0xE0F8);
+        MP_WriteMcuAccessRegWord(sc, 0xF920, 0xDC42);
+        MP_WriteMcuAccessRegWord(sc, 0xF922, 0xD3F0);
+        MP_WriteMcuAccessRegWord(sc, 0xF924, 0x0000);
+        MP_WriteMcuAccessRegWord(sc, 0xF926, 0x0004);
+        MP_WriteMcuAccessRegWord(sc, 0xF928, 0x0007);
+        MP_WriteMcuAccessRegWord(sc, 0xF92A, 0x0014);
+        MP_WriteMcuAccessRegWord(sc, 0xF92C, 0x0090);
+        MP_WriteMcuAccessRegWord(sc, 0xF92E, 0x1000);
+        MP_WriteMcuAccessRegWord(sc, 0xF930, 0x0F00);
+        MP_WriteMcuAccessRegWord(sc, 0xF932, 0x1004);
+        MP_WriteMcuAccessRegWord(sc, 0xF934, 0x1008);
+        MP_WriteMcuAccessRegWord(sc, 0xF936, 0x3000);
+        MP_WriteMcuAccessRegWord(sc, 0xF938, 0x3004);
+        MP_WriteMcuAccessRegWord(sc, 0xF93A, 0x3008);
+        MP_WriteMcuAccessRegWord(sc, 0xF93C, 0x4000);
+        MP_WriteMcuAccessRegWord(sc, 0xF93E, 0x7777);
+        MP_WriteMcuAccessRegWord(sc, 0xF940, 0x8000);
+        MP_WriteMcuAccessRegWord(sc, 0xF942, 0x8001);
+        MP_WriteMcuAccessRegWord(sc, 0xF944, 0x8008);
+        MP_WriteMcuAccessRegWord(sc, 0xF946, 0x8003);
+        MP_WriteMcuAccessRegWord(sc, 0xF948, 0x8004);
+        MP_WriteMcuAccessRegWord(sc, 0xF94A, 0xC000);
+        MP_WriteMcuAccessRegWord(sc, 0xF94C, 0xC004);
+        MP_WriteMcuAccessRegWord(sc, 0xF94E, 0xF004);
+        MP_WriteMcuAccessRegWord(sc, 0xF950, 0xFFFF);
+        MP_WriteMcuAccessRegWord(sc, 0xF952, 0xB406);
+        MP_WriteMcuAccessRegWord(sc, 0xF954, 0xB407);
+        MP_WriteMcuAccessRegWord(sc, 0xF956, 0xC6E5);
+        MP_WriteMcuAccessRegWord(sc, 0xF958, 0x77C0);
+        MP_WriteMcuAccessRegWord(sc, 0xF95A, 0x27F3);
+        MP_WriteMcuAccessRegWord(sc, 0xF95C, 0x23F3);
+        MP_WriteMcuAccessRegWord(sc, 0xF95E, 0x47FA);
+        MP_WriteMcuAccessRegWord(sc, 0xF960, 0x9FC0);
+        MP_WriteMcuAccessRegWord(sc, 0xF962, 0xB007);
+        MP_WriteMcuAccessRegWord(sc, 0xF964, 0xB006);
+        MP_WriteMcuAccessRegWord(sc, 0xF966, 0xFF80);
+        MP_WriteMcuAccessRegWord(sc, 0xF968, 0xB405);
+        MP_WriteMcuAccessRegWord(sc, 0xF96A, 0xB407);
+        MP_WriteMcuAccessRegWord(sc, 0xF96C, 0xC7D8);
+        MP_WriteMcuAccessRegWord(sc, 0xF96E, 0x75E0);
+        MP_WriteMcuAccessRegWord(sc, 0xF970, 0x48D0);
+        MP_WriteMcuAccessRegWord(sc, 0xF972, 0x9DE0);
+        MP_WriteMcuAccessRegWord(sc, 0xF974, 0xB007);
+        MP_WriteMcuAccessRegWord(sc, 0xF976, 0xB005);
+        MP_WriteMcuAccessRegWord(sc, 0xF978, 0xFF80);
+        MP_WriteMcuAccessRegWord(sc, 0xF97A, 0xB401);
+        MP_WriteMcuAccessRegWord(sc, 0xF97C, 0xC0EA);
+        MP_WriteMcuAccessRegWord(sc, 0xF97E, 0xC2DC);
+        MP_WriteMcuAccessRegWord(sc, 0xF980, 0xC3D8);
+        MP_WriteMcuAccessRegWord(sc, 0xF982, 0xE865);
+        MP_WriteMcuAccessRegWord(sc, 0xF984, 0xC0D3);
+        MP_WriteMcuAccessRegWord(sc, 0xF986, 0xC1E0);
+        MP_WriteMcuAccessRegWord(sc, 0xF988, 0xC2E3);
+        MP_WriteMcuAccessRegWord(sc, 0xF98A, 0xE861);
+        MP_WriteMcuAccessRegWord(sc, 0xF98C, 0xE817);
+        MP_WriteMcuAccessRegWord(sc, 0xF98E, 0xC0CD);
+        MP_WriteMcuAccessRegWord(sc, 0xF990, 0xC2CF);
+        MP_WriteMcuAccessRegWord(sc, 0xF992, 0xE85D);
+        MP_WriteMcuAccessRegWord(sc, 0xF994, 0xC0C9);
+        MP_WriteMcuAccessRegWord(sc, 0xF996, 0xC1D6);
+        MP_WriteMcuAccessRegWord(sc, 0xF998, 0xC2DB);
+        MP_WriteMcuAccessRegWord(sc, 0xF99A, 0xE859);
+        MP_WriteMcuAccessRegWord(sc, 0xF99C, 0xE80F);
+        MP_WriteMcuAccessRegWord(sc, 0xF99E, 0xC1C7);
+        MP_WriteMcuAccessRegWord(sc, 0xF9A0, 0xC2CE);
+        MP_WriteMcuAccessRegWord(sc, 0xF9A2, 0xE855);
+        MP_WriteMcuAccessRegWord(sc, 0xF9A4, 0xC0C0);
+        MP_WriteMcuAccessRegWord(sc, 0xF9A6, 0xC1D1);
+        MP_WriteMcuAccessRegWord(sc, 0xF9A8, 0xC2D3);
+        MP_WriteMcuAccessRegWord(sc, 0xF9AA, 0xE851);
+        MP_WriteMcuAccessRegWord(sc, 0xF9AC, 0xE807);
+        MP_WriteMcuAccessRegWord(sc, 0xF9AE, 0xC0BE);
+        MP_WriteMcuAccessRegWord(sc, 0xF9B0, 0xC2C2);
+        MP_WriteMcuAccessRegWord(sc, 0xF9B2, 0xE84D);
+        MP_WriteMcuAccessRegWord(sc, 0xF9B4, 0xE803);
+        MP_WriteMcuAccessRegWord(sc, 0xF9B6, 0xB001);
+        MP_WriteMcuAccessRegWord(sc, 0xF9B8, 0xFF80);
+        MP_WriteMcuAccessRegWord(sc, 0xF9BA, 0xB402);
+        MP_WriteMcuAccessRegWord(sc, 0xF9BC, 0xC2C6);
+        MP_WriteMcuAccessRegWord(sc, 0xF9BE, 0xE859);
+        MP_WriteMcuAccessRegWord(sc, 0xF9C0, 0x499F);
+        MP_WriteMcuAccessRegWord(sc, 0xF9C2, 0xF1FE);
+        MP_WriteMcuAccessRegWord(sc, 0xF9C4, 0xB002);
+        MP_WriteMcuAccessRegWord(sc, 0xF9C6, 0xFF80);
+        MP_WriteMcuAccessRegWord(sc, 0xF9C8, 0xB402);
+        MP_WriteMcuAccessRegWord(sc, 0xF9CA, 0xB403);
+        MP_WriteMcuAccessRegWord(sc, 0xF9CC, 0xB407);
+        MP_WriteMcuAccessRegWord(sc, 0xF9CE, 0xE821);
+        MP_WriteMcuAccessRegWord(sc, 0xF9D0, 0x8882);
+        MP_WriteMcuAccessRegWord(sc, 0xF9D2, 0x1980);
+        MP_WriteMcuAccessRegWord(sc, 0xF9D4, 0x8983);
+        MP_WriteMcuAccessRegWord(sc, 0xF9D6, 0xE81D);
+        MP_WriteMcuAccessRegWord(sc, 0xF9D8, 0x7180);
+        MP_WriteMcuAccessRegWord(sc, 0xF9DA, 0x218B);
+        MP_WriteMcuAccessRegWord(sc, 0xF9DC, 0x25BB);
+        MP_WriteMcuAccessRegWord(sc, 0xF9DE, 0x1310);
+        MP_WriteMcuAccessRegWord(sc, 0xF9E0, 0xF014);
+        MP_WriteMcuAccessRegWord(sc, 0xF9E2, 0x1310);
+        MP_WriteMcuAccessRegWord(sc, 0xF9E4, 0xFB03);
+        MP_WriteMcuAccessRegWord(sc, 0xF9E6, 0x1F20);
+        MP_WriteMcuAccessRegWord(sc, 0xF9E8, 0x38FB);
+        MP_WriteMcuAccessRegWord(sc, 0xF9EA, 0x3288);
+        MP_WriteMcuAccessRegWord(sc, 0xF9EC, 0x434B);
+        MP_WriteMcuAccessRegWord(sc, 0xF9EE, 0x2491);
+        MP_WriteMcuAccessRegWord(sc, 0xF9F0, 0x430B);
+        MP_WriteMcuAccessRegWord(sc, 0xF9F2, 0x1F0F);
+        MP_WriteMcuAccessRegWord(sc, 0xF9F4, 0x38FB);
+        MP_WriteMcuAccessRegWord(sc, 0xF9F6, 0x4313);
+        MP_WriteMcuAccessRegWord(sc, 0xF9F8, 0x2121);
+        MP_WriteMcuAccessRegWord(sc, 0xF9FA, 0x4353);
+        MP_WriteMcuAccessRegWord(sc, 0xF9FC, 0x2521);
+        MP_WriteMcuAccessRegWord(sc, 0xF9FE, 0x418A);
+        MP_WriteMcuAccessRegWord(sc, 0xFA00, 0x6282);
+        MP_WriteMcuAccessRegWord(sc, 0xFA02, 0x2527);
+        MP_WriteMcuAccessRegWord(sc, 0xFA04, 0x212F);
+        MP_WriteMcuAccessRegWord(sc, 0xFA06, 0x418A);
+        MP_WriteMcuAccessRegWord(sc, 0xFA08, 0xB007);
+        MP_WriteMcuAccessRegWord(sc, 0xFA0A, 0xB003);
+        MP_WriteMcuAccessRegWord(sc, 0xFA0C, 0xB002);
+        MP_WriteMcuAccessRegWord(sc, 0xFA0E, 0xFF80);
+        MP_WriteMcuAccessRegWord(sc, 0xFA10, 0x6183);
+        MP_WriteMcuAccessRegWord(sc, 0xFA12, 0x2496);
+        MP_WriteMcuAccessRegWord(sc, 0xFA14, 0x1100);
+        MP_WriteMcuAccessRegWord(sc, 0xFA16, 0xF1FD);
+        MP_WriteMcuAccessRegWord(sc, 0xFA18, 0xFF80);
+        MP_WriteMcuAccessRegWord(sc, 0xFA1A, 0x4800);
+        MP_WriteMcuAccessRegWord(sc, 0xFA1C, 0x4801);
+        MP_WriteMcuAccessRegWord(sc, 0xFA1E, 0xC213);
+        MP_WriteMcuAccessRegWord(sc, 0xFA20, 0xC313);
+        MP_WriteMcuAccessRegWord(sc, 0xFA22, 0xE815);
+        MP_WriteMcuAccessRegWord(sc, 0xFA24, 0x4860);
+        MP_WriteMcuAccessRegWord(sc, 0xFA26, 0x8EE0);
+        MP_WriteMcuAccessRegWord(sc, 0xFA28, 0xC210);
+        MP_WriteMcuAccessRegWord(sc, 0xFA2A, 0xC310);
+        MP_WriteMcuAccessRegWord(sc, 0xFA2C, 0xE822);
+        MP_WriteMcuAccessRegWord(sc, 0xFA2E, 0x481E);
+        MP_WriteMcuAccessRegWord(sc, 0xFA30, 0xC20C);
+        MP_WriteMcuAccessRegWord(sc, 0xFA32, 0xC30C);
+        MP_WriteMcuAccessRegWord(sc, 0xFA34, 0xE80C);
+        MP_WriteMcuAccessRegWord(sc, 0xFA36, 0xC206);
+        MP_WriteMcuAccessRegWord(sc, 0xFA38, 0x7358);
+        MP_WriteMcuAccessRegWord(sc, 0xFA3A, 0x483A);
+        MP_WriteMcuAccessRegWord(sc, 0xFA3C, 0x9B58);
+        MP_WriteMcuAccessRegWord(sc, 0xFA3E, 0xFF80);
+        MP_WriteMcuAccessRegWord(sc, 0xFA40, 0xE8E0);
+        MP_WriteMcuAccessRegWord(sc, 0xFA42, 0xE000);
+        MP_WriteMcuAccessRegWord(sc, 0xFA44, 0x1008);
+        MP_WriteMcuAccessRegWord(sc, 0xFA46, 0x0F00);
+        MP_WriteMcuAccessRegWord(sc, 0xFA48, 0x800C);
+        MP_WriteMcuAccessRegWord(sc, 0xFA4A, 0x0F00);
+        MP_WriteMcuAccessRegWord(sc, 0xFA4C, 0xB407);
+        MP_WriteMcuAccessRegWord(sc, 0xFA4E, 0xB406);
+        MP_WriteMcuAccessRegWord(sc, 0xFA50, 0xB403);
+        MP_WriteMcuAccessRegWord(sc, 0xFA52, 0xC7F7);
+        MP_WriteMcuAccessRegWord(sc, 0xFA54, 0x98E0);
+        MP_WriteMcuAccessRegWord(sc, 0xFA56, 0x99E2);
+        MP_WriteMcuAccessRegWord(sc, 0xFA58, 0x9AE4);
+        MP_WriteMcuAccessRegWord(sc, 0xFA5A, 0x21B2);
+        MP_WriteMcuAccessRegWord(sc, 0xFA5C, 0x4831);
+        MP_WriteMcuAccessRegWord(sc, 0xFA5E, 0x483F);
+        MP_WriteMcuAccessRegWord(sc, 0xFA60, 0x9BE6);
+        MP_WriteMcuAccessRegWord(sc, 0xFA62, 0x66E7);
+        MP_WriteMcuAccessRegWord(sc, 0xFA64, 0x49E6);
+        MP_WriteMcuAccessRegWord(sc, 0xFA66, 0xF1FE);
+        MP_WriteMcuAccessRegWord(sc, 0xFA68, 0xB003);
+        MP_WriteMcuAccessRegWord(sc, 0xFA6A, 0xB006);
+        MP_WriteMcuAccessRegWord(sc, 0xFA6C, 0xB007);
+        MP_WriteMcuAccessRegWord(sc, 0xFA6E, 0xFF80);
+        MP_WriteMcuAccessRegWord(sc, 0xFA70, 0xB407);
+        MP_WriteMcuAccessRegWord(sc, 0xFA72, 0xB406);
+        MP_WriteMcuAccessRegWord(sc, 0xFA74, 0xB403);
+        MP_WriteMcuAccessRegWord(sc, 0xFA76, 0xC7E5);
+        MP_WriteMcuAccessRegWord(sc, 0xFA78, 0x9AE4);
+        MP_WriteMcuAccessRegWord(sc, 0xFA7A, 0x21B2);
+        MP_WriteMcuAccessRegWord(sc, 0xFA7C, 0x4831);
+        MP_WriteMcuAccessRegWord(sc, 0xFA7E, 0x9BE6);
+        MP_WriteMcuAccessRegWord(sc, 0xFA80, 0x66E7);
+        MP_WriteMcuAccessRegWord(sc, 0xFA82, 0x49E6);
+        MP_WriteMcuAccessRegWord(sc, 0xFA84, 0xF1FE);
+        MP_WriteMcuAccessRegWord(sc, 0xFA86, 0x70E0);
+        MP_WriteMcuAccessRegWord(sc, 0xFA88, 0x71E2);
+        MP_WriteMcuAccessRegWord(sc, 0xFA8A, 0xB003);
+        MP_WriteMcuAccessRegWord(sc, 0xFA8C, 0xB006);
+        MP_WriteMcuAccessRegWord(sc, 0xFA8E, 0xB007);
+        MP_WriteMcuAccessRegWord(sc, 0xFA90, 0xFF80);
+        MP_WriteMcuAccessRegWord(sc, 0xFA92, 0x4882);
+        MP_WriteMcuAccessRegWord(sc, 0xFA94, 0xB406);
+        MP_WriteMcuAccessRegWord(sc, 0xFA96, 0xB405);
+        MP_WriteMcuAccessRegWord(sc, 0xFA98, 0xC71E);
+        MP_WriteMcuAccessRegWord(sc, 0xFA9A, 0x76E0);
+        MP_WriteMcuAccessRegWord(sc, 0xFA9C, 0x1D78);
+        MP_WriteMcuAccessRegWord(sc, 0xFA9E, 0x4175);
+        MP_WriteMcuAccessRegWord(sc, 0xFAA0, 0x1630);
+        MP_WriteMcuAccessRegWord(sc, 0xFAA2, 0xF10C);
+        MP_WriteMcuAccessRegWord(sc, 0xFAA4, 0xC715);
+        MP_WriteMcuAccessRegWord(sc, 0xFAA6, 0x76E0);
+        MP_WriteMcuAccessRegWord(sc, 0xFAA8, 0x4861);
+        MP_WriteMcuAccessRegWord(sc, 0xFAAA, 0x9EE0);
+        MP_WriteMcuAccessRegWord(sc, 0xFAAC, 0xC713);
+        MP_WriteMcuAccessRegWord(sc, 0xFAAE, 0x1EFF);
+        MP_WriteMcuAccessRegWord(sc, 0xFAB0, 0x9EE2);
+        MP_WriteMcuAccessRegWord(sc, 0xFAB2, 0x75E0);
+        MP_WriteMcuAccessRegWord(sc, 0xFAB4, 0x4850);
+        MP_WriteMcuAccessRegWord(sc, 0xFAB6, 0x9DE0);
+        MP_WriteMcuAccessRegWord(sc, 0xFAB8, 0xE005);
+        MP_WriteMcuAccessRegWord(sc, 0xFABA, 0xC70B);
+        MP_WriteMcuAccessRegWord(sc, 0xFABC, 0x76E0);
+        MP_WriteMcuAccessRegWord(sc, 0xFABE, 0x4865);
+        MP_WriteMcuAccessRegWord(sc, 0xFAC0, 0x9EE0);
+        MP_WriteMcuAccessRegWord(sc, 0xFAC2, 0xB005);
+        MP_WriteMcuAccessRegWord(sc, 0xFAC4, 0xB006);
+        MP_WriteMcuAccessRegWord(sc, 0xFAC6, 0xC708);
+        MP_WriteMcuAccessRegWord(sc, 0xFAC8, 0xC102);
+        MP_WriteMcuAccessRegWord(sc, 0xFACA, 0xB900);
+        MP_WriteMcuAccessRegWord(sc, 0xFACC, 0x279E);
+        MP_WriteMcuAccessRegWord(sc, 0xFACE, 0xEB16);
+        MP_WriteMcuAccessRegWord(sc, 0xFAD0, 0xEB00);
+        MP_WriteMcuAccessRegWord(sc, 0xFAD2, 0xE43C);
+        MP_WriteMcuAccessRegWord(sc, 0xFAD4, 0xDC00);
+        MP_WriteMcuAccessRegWord(sc, 0xFAD6, 0xD3EC);
+        MP_WriteMcuAccessRegWord(sc, 0xFAD8, 0xC602);
+        MP_WriteMcuAccessRegWord(sc, 0xFADA, 0xBE00);
+        MP_WriteMcuAccessRegWord(sc, 0xFADC, 0x0000);
+        MP_WriteMcuAccessRegWord(sc, 0xFADE, 0xC602);
+        MP_WriteMcuAccessRegWord(sc, 0xFAE0, 0xBE00);
+        MP_WriteMcuAccessRegWord(sc, 0xFAE2, 0x0000);
+
+        MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000);
+
+        MP_WriteMcuAccessRegWord(sc, 0xFC28, 0x0000);
+        MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x04B4);
+        MP_WriteMcuAccessRegWord(sc, 0xFC2C, 0x0000);
+        MP_WriteMcuAccessRegWord(sc, 0xFC2E, 0x0000);
+        MP_WriteMcuAccessRegWord(sc, 0xFC30, 0x0000);
+        MP_WriteMcuAccessRegWord(sc, 0xFC32, 0x279C);
+        MP_WriteMcuAccessRegWord(sc, 0xFC34, 0x0000);
+        MP_WriteMcuAccessRegWord(sc, 0xFC36, 0x0000);
+
+        MP_WriteMcuAccessRegWord(sc, 0xFC38, 0x0022);
+}
+
+static void re_hw_mac_mcu_config(struct re_softc *sc)
+{
+        switch(sc->re_type) {
+        case MACFG_56:
+                re_set_mac_mcu_8168g_1(sc);
                 break;
         case MACFG_58:
-                DisableMcuBPs(sc);
-
-                MP_WriteMcuAccessRegWord(sc, 0xF800, 0xE008);
-                MP_WriteMcuAccessRegWord(sc, 0xF802, 0xE011);
-                MP_WriteMcuAccessRegWord(sc, 0xF804, 0xE015);
-                MP_WriteMcuAccessRegWord(sc, 0xF806, 0xE018);
-                MP_WriteMcuAccessRegWord(sc, 0xF808, 0xE01B);
-                MP_WriteMcuAccessRegWord(sc, 0xF80A, 0xE027);
-                MP_WriteMcuAccessRegWord(sc, 0xF80C, 0xE043);
-                MP_WriteMcuAccessRegWord(sc, 0xF80E, 0xE065);
-                MP_WriteMcuAccessRegWord(sc, 0xF810, 0x49E2);
-                MP_WriteMcuAccessRegWord(sc, 0xF812, 0xF005);
-                MP_WriteMcuAccessRegWord(sc, 0xF814, 0x49EA);
-                MP_WriteMcuAccessRegWord(sc, 0xF816, 0xF003);
-                MP_WriteMcuAccessRegWord(sc, 0xF818, 0xC404);
-                MP_WriteMcuAccessRegWord(sc, 0xF81A, 0xBC00);
-                MP_WriteMcuAccessRegWord(sc, 0xF81C, 0xC403);
-                MP_WriteMcuAccessRegWord(sc, 0xF81E, 0xBC00);
-                MP_WriteMcuAccessRegWord(sc, 0xF820, 0x0496);
-                MP_WriteMcuAccessRegWord(sc, 0xF822, 0x051A);
-                MP_WriteMcuAccessRegWord(sc, 0xF824, 0x1D01);
-                MP_WriteMcuAccessRegWord(sc, 0xF826, 0x8DE8);
-                MP_WriteMcuAccessRegWord(sc, 0xF828, 0xC602);
-                MP_WriteMcuAccessRegWord(sc, 0xF82A, 0xBE00);
-                MP_WriteMcuAccessRegWord(sc, 0xF82C, 0x0206);
-                MP_WriteMcuAccessRegWord(sc, 0xF82E, 0x1B76);
-                MP_WriteMcuAccessRegWord(sc, 0xF830, 0xC202);
-                MP_WriteMcuAccessRegWord(sc, 0xF832, 0xBA00);
-                MP_WriteMcuAccessRegWord(sc, 0xF834, 0x058A);
-                MP_WriteMcuAccessRegWord(sc, 0xF836, 0x1B76);
-                MP_WriteMcuAccessRegWord(sc, 0xF838, 0xC602);
-                MP_WriteMcuAccessRegWord(sc, 0xF83A, 0xBE00);
-                MP_WriteMcuAccessRegWord(sc, 0xF83C, 0x0648);
-                MP_WriteMcuAccessRegWord(sc, 0xF83E, 0x74E6);
-                MP_WriteMcuAccessRegWord(sc, 0xF840, 0x1B78);
-                MP_WriteMcuAccessRegWord(sc, 0xF842, 0x46DC);
-                MP_WriteMcuAccessRegWord(sc, 0xF844, 0x1300);
-                MP_WriteMcuAccessRegWord(sc, 0xF846, 0xF005);
-                MP_WriteMcuAccessRegWord(sc, 0xF848, 0x74F8);
-                MP_WriteMcuAccessRegWord(sc, 0xF84A, 0x48C3);
-                MP_WriteMcuAccessRegWord(sc, 0xF84C, 0x48C4);
-                MP_WriteMcuAccessRegWord(sc, 0xF84E, 0x8CF8);
-                MP_WriteMcuAccessRegWord(sc, 0xF850, 0x64E7);
-                MP_WriteMcuAccessRegWord(sc, 0xF852, 0xC302);
-                MP_WriteMcuAccessRegWord(sc, 0xF854, 0xBB00);
-                MP_WriteMcuAccessRegWord(sc, 0xF856, 0x068E);
-                MP_WriteMcuAccessRegWord(sc, 0xF858, 0x74E4);
-                MP_WriteMcuAccessRegWord(sc, 0xF85A, 0x49C5);
-                MP_WriteMcuAccessRegWord(sc, 0xF85C, 0xF106);
-                MP_WriteMcuAccessRegWord(sc, 0xF85E, 0x49C6);
-                MP_WriteMcuAccessRegWord(sc, 0xF860, 0xF107);
-                MP_WriteMcuAccessRegWord(sc, 0xF862, 0x48C8);
-                MP_WriteMcuAccessRegWord(sc, 0xF864, 0x48C9);
-                MP_WriteMcuAccessRegWord(sc, 0xF866, 0xE011);
-                MP_WriteMcuAccessRegWord(sc, 0xF868, 0x48C9);
-                MP_WriteMcuAccessRegWord(sc, 0xF86A, 0x4848);
-                MP_WriteMcuAccessRegWord(sc, 0xF86C, 0xE00E);
-                MP_WriteMcuAccessRegWord(sc, 0xF86E, 0x4848);
-                MP_WriteMcuAccessRegWord(sc, 0xF870, 0x49C7);
-                MP_WriteMcuAccessRegWord(sc, 0xF872, 0xF00A);
-                MP_WriteMcuAccessRegWord(sc, 0xF874, 0x48C9);
-                MP_WriteMcuAccessRegWord(sc, 0xF876, 0xC60D);
-                MP_WriteMcuAccessRegWord(sc, 0xF878, 0x1D1F);
-                MP_WriteMcuAccessRegWord(sc, 0xF87A, 0x8DC2);
-                MP_WriteMcuAccessRegWord(sc, 0xF87C, 0x1D00);
-                MP_WriteMcuAccessRegWord(sc, 0xF87E, 0x8DC3);
-                MP_WriteMcuAccessRegWord(sc, 0xF880, 0x1D11);
-                MP_WriteMcuAccessRegWord(sc, 0xF882, 0x8DC0);
-                MP_WriteMcuAccessRegWord(sc, 0xF884, 0xE002);
-                MP_WriteMcuAccessRegWord(sc, 0xF886, 0x4849);
-                MP_WriteMcuAccessRegWord(sc, 0xF888, 0x94E5);
-                MP_WriteMcuAccessRegWord(sc, 0xF88A, 0xC602);
-                MP_WriteMcuAccessRegWord(sc, 0xF88C, 0xBE00);
-                MP_WriteMcuAccessRegWord(sc, 0xF88E, 0x0238);
-                MP_WriteMcuAccessRegWord(sc, 0xF890, 0xE434);
-                MP_WriteMcuAccessRegWord(sc, 0xF892, 0x49D9);
-                MP_WriteMcuAccessRegWord(sc, 0xF894, 0xF01B);
-                MP_WriteMcuAccessRegWord(sc, 0xF896, 0xC31E);
-                MP_WriteMcuAccessRegWord(sc, 0xF898, 0x7464);
-                MP_WriteMcuAccessRegWord(sc, 0xF89A, 0x49C4);
-                MP_WriteMcuAccessRegWord(sc, 0xF89C, 0xF114);
-                MP_WriteMcuAccessRegWord(sc, 0xF89E, 0xC31B);
-                MP_WriteMcuAccessRegWord(sc, 0xF8A0, 0x6460);
-                MP_WriteMcuAccessRegWord(sc, 0xF8A2, 0x14FA);
-                MP_WriteMcuAccessRegWord(sc, 0xF8A4, 0xFA02);
-                MP_WriteMcuAccessRegWord(sc, 0xF8A6, 0xE00F);
-                MP_WriteMcuAccessRegWord(sc, 0xF8A8, 0xC317);
-                MP_WriteMcuAccessRegWord(sc, 0xF8AA, 0x7460);
-                MP_WriteMcuAccessRegWord(sc, 0xF8AC, 0x49C0);
-                MP_WriteMcuAccessRegWord(sc, 0xF8AE, 0xF10B);
-                MP_WriteMcuAccessRegWord(sc, 0xF8B0, 0xC311);
-                MP_WriteMcuAccessRegWord(sc, 0xF8B2, 0x7462);
-                MP_WriteMcuAccessRegWord(sc, 0xF8B4, 0x48C1);
-                MP_WriteMcuAccessRegWord(sc, 0xF8B6, 0x9C62);
-                MP_WriteMcuAccessRegWord(sc, 0xF8B8, 0x4841);
-                MP_WriteMcuAccessRegWord(sc, 0xF8BA, 0x9C62);
-                MP_WriteMcuAccessRegWord(sc, 0xF8BC, 0xC30A);
-                MP_WriteMcuAccessRegWord(sc, 0xF8BE, 0x1C04);
-                MP_WriteMcuAccessRegWord(sc, 0xF8C0, 0x8C60);
-                MP_WriteMcuAccessRegWord(sc, 0xF8C2, 0xE004);
-                MP_WriteMcuAccessRegWord(sc, 0xF8C4, 0x1C15);
-                MP_WriteMcuAccessRegWord(sc, 0xF8C6, 0xC305);
-                MP_WriteMcuAccessRegWord(sc, 0xF8C8, 0x8C60);
-                MP_WriteMcuAccessRegWord(sc, 0xF8CA, 0xC602);
-                MP_WriteMcuAccessRegWord(sc, 0xF8CC, 0xBE00);
-                MP_WriteMcuAccessRegWord(sc, 0xF8CE, 0x0374);
-                MP_WriteMcuAccessRegWord(sc, 0xF8D0, 0xE434);
-                MP_WriteMcuAccessRegWord(sc, 0xF8D2, 0xE030);
-                MP_WriteMcuAccessRegWord(sc, 0xF8D4, 0xE61C);
-                MP_WriteMcuAccessRegWord(sc, 0xF8D6, 0xE906);
-                MP_WriteMcuAccessRegWord(sc, 0xF8D8, 0xC602);
-                MP_WriteMcuAccessRegWord(sc, 0xF8DA, 0xBE00);
-                MP_WriteMcuAccessRegWord(sc, 0xF8DC, 0x0000);
-
-                MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000);
-
-                MP_WriteMcuAccessRegWord(sc, 0xFC28, 0x0493);
-                MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x0205);
-                MP_WriteMcuAccessRegWord(sc, 0xFC2C, 0x0589);
-                MP_WriteMcuAccessRegWord(sc, 0xFC2E, 0x0647);
-                MP_WriteMcuAccessRegWord(sc, 0xFC30, 0x0000);
-                MP_WriteMcuAccessRegWord(sc, 0xFC32, 0x0215);
-                MP_WriteMcuAccessRegWord(sc, 0xFC34, 0x0285);
+                re_set_mac_mcu_8168gu_1(sc);
                 break;
         case MACFG_59:
-                DisableMcuBPs(sc);
-
-                MP_WriteMcuAccessRegWord(sc, 0xF800, 0xE008);
-                MP_WriteMcuAccessRegWord(sc, 0xF802, 0xE00A);
-                MP_WriteMcuAccessRegWord(sc, 0xF804, 0xE01B);
-                MP_WriteMcuAccessRegWord(sc, 0xF806, 0xE03D);
-                MP_WriteMcuAccessRegWord(sc, 0xF808, 0xE04C);
-                MP_WriteMcuAccessRegWord(sc, 0xF80A, 0xE053);
-                MP_WriteMcuAccessRegWord(sc, 0xF80C, 0xE055);
-                MP_WriteMcuAccessRegWord(sc, 0xF80E, 0xE06C);
-                MP_WriteMcuAccessRegWord(sc, 0xF810, 0xC202);
-                MP_WriteMcuAccessRegWord(sc, 0xF812, 0xBA00);
-                MP_WriteMcuAccessRegWord(sc, 0xF814, 0x0DFC);
-                MP_WriteMcuAccessRegWord(sc, 0xF816, 0xC511);
-                MP_WriteMcuAccessRegWord(sc, 0xF818, 0x74A2);
-                MP_WriteMcuAccessRegWord(sc, 0xF81A, 0x8CA5);
-                MP_WriteMcuAccessRegWord(sc, 0xF81C, 0x74A0);
-                MP_WriteMcuAccessRegWord(sc, 0xF81E, 0xC50B);
-                MP_WriteMcuAccessRegWord(sc, 0xF820, 0x9CA2);
-                MP_WriteMcuAccessRegWord(sc, 0xF822, 0x1C11);
-                MP_WriteMcuAccessRegWord(sc, 0xF824, 0x9CA0);
-                MP_WriteMcuAccessRegWord(sc, 0xF826, 0xC506);
-                MP_WriteMcuAccessRegWord(sc, 0xF828, 0xBD00);
-                MP_WriteMcuAccessRegWord(sc, 0xF82A, 0x7444);
-                MP_WriteMcuAccessRegWord(sc, 0xF82C, 0xC502);
-                MP_WriteMcuAccessRegWord(sc, 0xF82E, 0xBD00);
-                MP_WriteMcuAccessRegWord(sc, 0xF830, 0x0A30);
-                MP_WriteMcuAccessRegWord(sc, 0xF832, 0x0A46);
-                MP_WriteMcuAccessRegWord(sc, 0xF834, 0xE434);
-                MP_WriteMcuAccessRegWord(sc, 0xF836, 0xE096);
-                MP_WriteMcuAccessRegWord(sc, 0xF838, 0xD3C0);
-                MP_WriteMcuAccessRegWord(sc, 0xF83A, 0x49D9);
-                MP_WriteMcuAccessRegWord(sc, 0xF83C, 0xF019);
-                MP_WriteMcuAccessRegWord(sc, 0xF83E, 0xC520);
-                MP_WriteMcuAccessRegWord(sc, 0xF840, 0x64A5);
-                MP_WriteMcuAccessRegWord(sc, 0xF842, 0x1400);
-                MP_WriteMcuAccessRegWord(sc, 0xF844, 0xF007);
-                MP_WriteMcuAccessRegWord(sc, 0xF846, 0x0C01);
-                MP_WriteMcuAccessRegWord(sc, 0xF848, 0x8CA5);
-                MP_WriteMcuAccessRegWord(sc, 0xF84A, 0x1C15);
-                MP_WriteMcuAccessRegWord(sc, 0xF84C, 0xC515);
-                MP_WriteMcuAccessRegWord(sc, 0xF84E, 0x9CA0);
-                MP_WriteMcuAccessRegWord(sc, 0xF850, 0xE00F);
-                MP_WriteMcuAccessRegWord(sc, 0xF852, 0xC513);
-                MP_WriteMcuAccessRegWord(sc, 0xF854, 0x74A0);
-                MP_WriteMcuAccessRegWord(sc, 0xF856, 0x48C8);
-                MP_WriteMcuAccessRegWord(sc, 0xF858, 0x48CA);
-                MP_WriteMcuAccessRegWord(sc, 0xF85A, 0x9CA0);
-                MP_WriteMcuAccessRegWord(sc, 0xF85C, 0xC510);
-                MP_WriteMcuAccessRegWord(sc, 0xF85E, 0x1B00);
-                MP_WriteMcuAccessRegWord(sc, 0xF860, 0x9BA0);
-                MP_WriteMcuAccessRegWord(sc, 0xF862, 0x1B1C);
-                MP_WriteMcuAccessRegWord(sc, 0xF864, 0x483F);
-                MP_WriteMcuAccessRegWord(sc, 0xF866, 0x9BA2);
-                MP_WriteMcuAccessRegWord(sc, 0xF868, 0x1B04);
-                MP_WriteMcuAccessRegWord(sc, 0xF86A, 0xC506);
-                MP_WriteMcuAccessRegWord(sc, 0xF86C, 0x9BA0);
-                MP_WriteMcuAccessRegWord(sc, 0xF86E, 0xC603);
-                MP_WriteMcuAccessRegWord(sc, 0xF870, 0xBE00);
-                MP_WriteMcuAccessRegWord(sc, 0xF872, 0x0298);
-                MP_WriteMcuAccessRegWord(sc, 0xF874, 0x03DE);
-                MP_WriteMcuAccessRegWord(sc, 0xF876, 0xE434);
-                MP_WriteMcuAccessRegWord(sc, 0xF878, 0xE096);
-                MP_WriteMcuAccessRegWord(sc, 0xF87A, 0xE860);
-                MP_WriteMcuAccessRegWord(sc, 0xF87C, 0xDE20);
-                MP_WriteMcuAccessRegWord(sc, 0xF87E, 0xD3C0);
-                MP_WriteMcuAccessRegWord(sc, 0xF880, 0xC50F);
-                MP_WriteMcuAccessRegWord(sc, 0xF882, 0x76A4);
-                MP_WriteMcuAccessRegWord(sc, 0xF884, 0x49E3);
-                MP_WriteMcuAccessRegWord(sc, 0xF886, 0xF007);
-                MP_WriteMcuAccessRegWord(sc, 0xF888, 0x49C0);
-                MP_WriteMcuAccessRegWord(sc, 0xF88A, 0xF103);
-                MP_WriteMcuAccessRegWord(sc, 0xF88C, 0xC607);
-                MP_WriteMcuAccessRegWord(sc, 0xF88E, 0xBE00);
-                MP_WriteMcuAccessRegWord(sc, 0xF890, 0xC606);
-                MP_WriteMcuAccessRegWord(sc, 0xF892, 0xBE00);
-                MP_WriteMcuAccessRegWord(sc, 0xF894, 0xC602);
-                MP_WriteMcuAccessRegWord(sc, 0xF896, 0xBE00);
-                MP_WriteMcuAccessRegWord(sc, 0xF898, 0x0A88);
-                MP_WriteMcuAccessRegWord(sc, 0xF89A, 0x0A64);
-                MP_WriteMcuAccessRegWord(sc, 0xF89C, 0x0A68);
-                MP_WriteMcuAccessRegWord(sc, 0xF89E, 0xDC00);
-                MP_WriteMcuAccessRegWord(sc, 0xF8A0, 0xC707);
-                MP_WriteMcuAccessRegWord(sc, 0xF8A2, 0x1D00);
-                MP_WriteMcuAccessRegWord(sc, 0xF8A4, 0x8DE2);
-                MP_WriteMcuAccessRegWord(sc, 0xF8A6, 0x48C1);
-                MP_WriteMcuAccessRegWord(sc, 0xF8A8, 0xC502);
-                MP_WriteMcuAccessRegWord(sc, 0xF8AA, 0xBD00);
-                MP_WriteMcuAccessRegWord(sc, 0xF8AC, 0x00AA);
-                MP_WriteMcuAccessRegWord(sc, 0xF8AE, 0xE0C0);
-                MP_WriteMcuAccessRegWord(sc, 0xF8B0, 0xC502);
-                MP_WriteMcuAccessRegWord(sc, 0xF8B2, 0xBD00);
-                MP_WriteMcuAccessRegWord(sc, 0xF8B4, 0x0132);
-                MP_WriteMcuAccessRegWord(sc, 0xF8B6, 0xC50C);
-                MP_WriteMcuAccessRegWord(sc, 0xF8B8, 0x74A2);
-                MP_WriteMcuAccessRegWord(sc, 0xF8BA, 0x49CE);
-                MP_WriteMcuAccessRegWord(sc, 0xF8BC, 0xF1FE);
-                MP_WriteMcuAccessRegWord(sc, 0xF8BE, 0x1C00);
-                MP_WriteMcuAccessRegWord(sc, 0xF8C0, 0x9EA0);
-                MP_WriteMcuAccessRegWord(sc, 0xF8C2, 0x1C1C);
-                MP_WriteMcuAccessRegWord(sc, 0xF8C4, 0x484F);
-                MP_WriteMcuAccessRegWord(sc, 0xF8C6, 0x9CA2);
-                MP_WriteMcuAccessRegWord(sc, 0xF8C8, 0xC402);
-                MP_WriteMcuAccessRegWord(sc, 0xF8CA, 0xBC00);
-                MP_WriteMcuAccessRegWord(sc, 0xF8CC, 0x0AFA);
-                MP_WriteMcuAccessRegWord(sc, 0xF8CE, 0xDE20);
-                MP_WriteMcuAccessRegWord(sc, 0xF8D0, 0xE000);
-                MP_WriteMcuAccessRegWord(sc, 0xF8D2, 0xE092);
-                MP_WriteMcuAccessRegWord(sc, 0xF8D4, 0xE430);
-                MP_WriteMcuAccessRegWord(sc, 0xF8D6, 0xDE20);
-                MP_WriteMcuAccessRegWord(sc, 0xF8D8, 0xE0C0);
-                MP_WriteMcuAccessRegWord(sc, 0xF8DA, 0xE860);
-                MP_WriteMcuAccessRegWord(sc, 0xF8DC, 0xE84C);
-                MP_WriteMcuAccessRegWord(sc, 0xF8DE, 0xB400);
-                MP_WriteMcuAccessRegWord(sc, 0xF8E0, 0xB430);
-                MP_WriteMcuAccessRegWord(sc, 0xF8E2, 0xE410);
-                MP_WriteMcuAccessRegWord(sc, 0xF8E4, 0xC0AE);
-                MP_WriteMcuAccessRegWord(sc, 0xF8E6, 0xB407);
-                MP_WriteMcuAccessRegWord(sc, 0xF8E8, 0xB406);
-                MP_WriteMcuAccessRegWord(sc, 0xF8EA, 0xB405);
-                MP_WriteMcuAccessRegWord(sc, 0xF8EC, 0xB404);
-                MP_WriteMcuAccessRegWord(sc, 0xF8EE, 0xB403);
-                MP_WriteMcuAccessRegWord(sc, 0xF8F0, 0xB402);
-                MP_WriteMcuAccessRegWord(sc, 0xF8F2, 0xB401);
-                MP_WriteMcuAccessRegWord(sc, 0xF8F4, 0xC7EE);
-                MP_WriteMcuAccessRegWord(sc, 0xF8F6, 0x76F4);
-                MP_WriteMcuAccessRegWord(sc, 0xF8F8, 0xC2ED);
-                MP_WriteMcuAccessRegWord(sc, 0xF8FA, 0xC3ED);
-                MP_WriteMcuAccessRegWord(sc, 0xF8FC, 0xC1EF);
-                MP_WriteMcuAccessRegWord(sc, 0xF8FE, 0xC5F3);
-                MP_WriteMcuAccessRegWord(sc, 0xF900, 0x74A0);
-                MP_WriteMcuAccessRegWord(sc, 0xF902, 0x49CD);
-                MP_WriteMcuAccessRegWord(sc, 0xF904, 0xF001);
-                MP_WriteMcuAccessRegWord(sc, 0xF906, 0xC5EE);
-                MP_WriteMcuAccessRegWord(sc, 0xF908, 0x74A0);
-                MP_WriteMcuAccessRegWord(sc, 0xF90A, 0x49C1);
-                MP_WriteMcuAccessRegWord(sc, 0xF90C, 0xF105);
-                MP_WriteMcuAccessRegWord(sc, 0xF90E, 0xC5E4);
-                MP_WriteMcuAccessRegWord(sc, 0xF910, 0x74A2);
-                MP_WriteMcuAccessRegWord(sc, 0xF912, 0x49CE);
-                MP_WriteMcuAccessRegWord(sc, 0xF914, 0xF00B);
-                MP_WriteMcuAccessRegWord(sc, 0xF916, 0x7444);
-                MP_WriteMcuAccessRegWord(sc, 0xF918, 0x484B);
-                MP_WriteMcuAccessRegWord(sc, 0xF91A, 0x9C44);
-                MP_WriteMcuAccessRegWord(sc, 0xF91C, 0x1C10);
-                MP_WriteMcuAccessRegWord(sc, 0xF91E, 0x9C62);
-                MP_WriteMcuAccessRegWord(sc, 0xF920, 0x1C11);
-                MP_WriteMcuAccessRegWord(sc, 0xF922, 0x8C60);
-                MP_WriteMcuAccessRegWord(sc, 0xF924, 0x1C00);
-                MP_WriteMcuAccessRegWord(sc, 0xF926, 0x9CF6);
-                MP_WriteMcuAccessRegWord(sc, 0xF928, 0xE0E1);
-                MP_WriteMcuAccessRegWord(sc, 0xF92A, 0x49E7);
-                MP_WriteMcuAccessRegWord(sc, 0xF92C, 0xF016);
-                MP_WriteMcuAccessRegWord(sc, 0xF92E, 0x1D80);
-                MP_WriteMcuAccessRegWord(sc, 0xF930, 0x8DF4);
-                MP_WriteMcuAccessRegWord(sc, 0xF932, 0x74F8);
-                MP_WriteMcuAccessRegWord(sc, 0xF934, 0x4843);
-                MP_WriteMcuAccessRegWord(sc, 0xF936, 0x8CF8);
-                MP_WriteMcuAccessRegWord(sc, 0xF938, 0x74F8);
-                MP_WriteMcuAccessRegWord(sc, 0xF93A, 0x74F8);
-                MP_WriteMcuAccessRegWord(sc, 0xF93C, 0x7444);
-                MP_WriteMcuAccessRegWord(sc, 0xF93E, 0x48C8);
-                MP_WriteMcuAccessRegWord(sc, 0xF940, 0x48C9);
-                MP_WriteMcuAccessRegWord(sc, 0xF942, 0x48CA);
-                MP_WriteMcuAccessRegWord(sc, 0xF944, 0x9C44);
-                MP_WriteMcuAccessRegWord(sc, 0xF946, 0x74F8);
-                MP_WriteMcuAccessRegWord(sc, 0xF948, 0x4844);
-                MP_WriteMcuAccessRegWord(sc, 0xF94A, 0x8CF8);
-                MP_WriteMcuAccessRegWord(sc, 0xF94C, 0x1E01);
-                MP_WriteMcuAccessRegWord(sc, 0xF94E, 0xE8D0);
-                MP_WriteMcuAccessRegWord(sc, 0xF950, 0x7420);
-                MP_WriteMcuAccessRegWord(sc, 0xF952, 0x48C1);
-                MP_WriteMcuAccessRegWord(sc, 0xF954, 0x9C20);
-                MP_WriteMcuAccessRegWord(sc, 0xF956, 0xE0CA);
-                MP_WriteMcuAccessRegWord(sc, 0xF958, 0x49E6);
-                MP_WriteMcuAccessRegWord(sc, 0xF95A, 0xF029);
-                MP_WriteMcuAccessRegWord(sc, 0xF95C, 0x1D40);
-                MP_WriteMcuAccessRegWord(sc, 0xF95E, 0x8DF4);
-                MP_WriteMcuAccessRegWord(sc, 0xF960, 0x74FC);
-                MP_WriteMcuAccessRegWord(sc, 0xF962, 0x49C0);
-                MP_WriteMcuAccessRegWord(sc, 0xF964, 0xF123);
-                MP_WriteMcuAccessRegWord(sc, 0xF966, 0x49C1);
-                MP_WriteMcuAccessRegWord(sc, 0xF968, 0xF121);
-                MP_WriteMcuAccessRegWord(sc, 0xF96A, 0x74F8);
-                MP_WriteMcuAccessRegWord(sc, 0xF96C, 0x49C0);
-                MP_WriteMcuAccessRegWord(sc, 0xF96E, 0xF01E);
-                MP_WriteMcuAccessRegWord(sc, 0xF970, 0x48C4);
-                MP_WriteMcuAccessRegWord(sc, 0xF972, 0x8CF8);
-                MP_WriteMcuAccessRegWord(sc, 0xF974, 0x1E00);
-                MP_WriteMcuAccessRegWord(sc, 0xF976, 0xE8BC);
-                MP_WriteMcuAccessRegWord(sc, 0xF978, 0xC5B2);
-                MP_WriteMcuAccessRegWord(sc, 0xF97A, 0x74A0);
-                MP_WriteMcuAccessRegWord(sc, 0xF97C, 0x49C3);
-                MP_WriteMcuAccessRegWord(sc, 0xF97E, 0xF016);
-                MP_WriteMcuAccessRegWord(sc, 0xF980, 0xC5B0);
-                MP_WriteMcuAccessRegWord(sc, 0xF982, 0x74A4);
-                MP_WriteMcuAccessRegWord(sc, 0xF984, 0x49C2);
-                MP_WriteMcuAccessRegWord(sc, 0xF986, 0xF005);
-                MP_WriteMcuAccessRegWord(sc, 0xF988, 0xC5AB);
-                MP_WriteMcuAccessRegWord(sc, 0xF98A, 0x74B2);
-                MP_WriteMcuAccessRegWord(sc, 0xF98C, 0x49C9);
-                MP_WriteMcuAccessRegWord(sc, 0xF98E, 0xF10E);
-                MP_WriteMcuAccessRegWord(sc, 0xF990, 0xC5A7);
-                MP_WriteMcuAccessRegWord(sc, 0xF992, 0x74A8);
-                MP_WriteMcuAccessRegWord(sc, 0xF994, 0x4845);
-                MP_WriteMcuAccessRegWord(sc, 0xF996, 0x4846);
-                MP_WriteMcuAccessRegWord(sc, 0xF998, 0x4847);
-                MP_WriteMcuAccessRegWord(sc, 0xF99A, 0x4848);
-                MP_WriteMcuAccessRegWord(sc, 0xF99C, 0x9CA8);
-                MP_WriteMcuAccessRegWord(sc, 0xF99E, 0x74B2);
-                MP_WriteMcuAccessRegWord(sc, 0xF9A0, 0x4849);
-                MP_WriteMcuAccessRegWord(sc, 0xF9A2, 0x9CB2);
-                MP_WriteMcuAccessRegWord(sc, 0xF9A4, 0x74A0);
-                MP_WriteMcuAccessRegWord(sc, 0xF9A6, 0x484F);
-                MP_WriteMcuAccessRegWord(sc, 0xF9A8, 0x9CA0);
-                MP_WriteMcuAccessRegWord(sc, 0xF9AA, 0xE0A0);
-                MP_WriteMcuAccessRegWord(sc, 0xF9AC, 0x49E4);
-                MP_WriteMcuAccessRegWord(sc, 0xF9AE, 0xF018);
-                MP_WriteMcuAccessRegWord(sc, 0xF9B0, 0x1D10);
-                MP_WriteMcuAccessRegWord(sc, 0xF9B2, 0x8DF4);
-                MP_WriteMcuAccessRegWord(sc, 0xF9B4, 0x74F8);
-                MP_WriteMcuAccessRegWord(sc, 0xF9B6, 0x74F8);
-                MP_WriteMcuAccessRegWord(sc, 0xF9B8, 0x74F8);
-                MP_WriteMcuAccessRegWord(sc, 0xF9BA, 0x4843);
-                MP_WriteMcuAccessRegWord(sc, 0xF9BC, 0x8CF8);
-                MP_WriteMcuAccessRegWord(sc, 0xF9BE, 0x74F8);
-                MP_WriteMcuAccessRegWord(sc, 0xF9C0, 0x74F8);
-                MP_WriteMcuAccessRegWord(sc, 0xF9C2, 0x74F8);
-                MP_WriteMcuAccessRegWord(sc, 0xF9C4, 0x4844);
-                MP_WriteMcuAccessRegWord(sc, 0xF9C6, 0x4842);
-                MP_WriteMcuAccessRegWord(sc, 0xF9C8, 0x4841);
-                MP_WriteMcuAccessRegWord(sc, 0xF9CA, 0x8CF8);
-                MP_WriteMcuAccessRegWord(sc, 0xF9CC, 0x1E01);
-                MP_WriteMcuAccessRegWord(sc, 0xF9CE, 0xE890);
-                MP_WriteMcuAccessRegWord(sc, 0xF9D0, 0x7420);
-                MP_WriteMcuAccessRegWord(sc, 0xF9D2, 0x4841);
-                MP_WriteMcuAccessRegWord(sc, 0xF9D4, 0x9C20);
-                MP_WriteMcuAccessRegWord(sc, 0xF9D6, 0x7444);
-                MP_WriteMcuAccessRegWord(sc, 0xF9D8, 0x4848);
-                MP_WriteMcuAccessRegWord(sc, 0xF9DA, 0x9C44);
-                MP_WriteMcuAccessRegWord(sc, 0xF9DC, 0xE087);
-                MP_WriteMcuAccessRegWord(sc, 0xF9DE, 0x49E5);
-                MP_WriteMcuAccessRegWord(sc, 0xF9E0, 0xF038);
-                MP_WriteMcuAccessRegWord(sc, 0xF9E2, 0x1D20);
-                MP_WriteMcuAccessRegWord(sc, 0xF9E4, 0x8DF4);
-                MP_WriteMcuAccessRegWord(sc, 0xF9E6, 0x74F8);
-                MP_WriteMcuAccessRegWord(sc, 0xF9E8, 0x48C2);
-                MP_WriteMcuAccessRegWord(sc, 0xF9EA, 0x4841);
-                MP_WriteMcuAccessRegWord(sc, 0xF9EC, 0x8CF8);
-                MP_WriteMcuAccessRegWord(sc, 0xF9EE, 0x1E01);
-                MP_WriteMcuAccessRegWord(sc, 0xF9F0, 0x7444);
-                MP_WriteMcuAccessRegWord(sc, 0xF9F2, 0x49CA);
-                MP_WriteMcuAccessRegWord(sc, 0xF9F4, 0xF103);
-                MP_WriteMcuAccessRegWord(sc, 0xF9F6, 0x49C2);
-                MP_WriteMcuAccessRegWord(sc, 0xF9F8, 0xF00C);
-                MP_WriteMcuAccessRegWord(sc, 0xF9FA, 0x49C1);
-                MP_WriteMcuAccessRegWord(sc, 0xF9FC, 0xF004);
-                MP_WriteMcuAccessRegWord(sc, 0xF9FE, 0x6447);
-                MP_WriteMcuAccessRegWord(sc, 0xFA00, 0x2244);
-                MP_WriteMcuAccessRegWord(sc, 0xFA02, 0xE002);
-                MP_WriteMcuAccessRegWord(sc, 0xFA04, 0x1C01);
-                MP_WriteMcuAccessRegWord(sc, 0xFA06, 0x9C62);
-                MP_WriteMcuAccessRegWord(sc, 0xFA08, 0x1C11);
-                MP_WriteMcuAccessRegWord(sc, 0xFA0A, 0x8C60);
-                MP_WriteMcuAccessRegWord(sc, 0xFA0C, 0x1C00);
-                MP_WriteMcuAccessRegWord(sc, 0xFA0E, 0x9CF6);
-                MP_WriteMcuAccessRegWord(sc, 0xFA10, 0x7444);
-                MP_WriteMcuAccessRegWord(sc, 0xFA12, 0x49C8);
-                MP_WriteMcuAccessRegWord(sc, 0xFA14, 0xF017);
-                MP_WriteMcuAccessRegWord(sc, 0xFA16, 0x74FC);
-                MP_WriteMcuAccessRegWord(sc, 0xFA18, 0x49C0);
-                MP_WriteMcuAccessRegWord(sc, 0xFA1A, 0xF114);
-                MP_WriteMcuAccessRegWord(sc, 0xFA1C, 0x49C1);
-                MP_WriteMcuAccessRegWord(sc, 0xFA1E, 0xF112);
-                MP_WriteMcuAccessRegWord(sc, 0xFA20, 0x74F8);
-                MP_WriteMcuAccessRegWord(sc, 0xFA22, 0x49C0);
-                MP_WriteMcuAccessRegWord(sc, 0xFA24, 0xF00F);
-                MP_WriteMcuAccessRegWord(sc, 0xFA26, 0x49C6);
-                MP_WriteMcuAccessRegWord(sc, 0xFA28, 0xF10D);
-                MP_WriteMcuAccessRegWord(sc, 0xFA2A, 0xE86B);
-                MP_WriteMcuAccessRegWord(sc, 0xFA2C, 0x48C4);
-                MP_WriteMcuAccessRegWord(sc, 0xFA2E, 0x8CF8);
-                MP_WriteMcuAccessRegWord(sc, 0xFA30, 0x7420);
-                MP_WriteMcuAccessRegWord(sc, 0xFA32, 0x48C1);
-                MP_WriteMcuAccessRegWord(sc, 0xFA34, 0x9C20);
-                MP_WriteMcuAccessRegWord(sc, 0xFA36, 0x7444);
-                MP_WriteMcuAccessRegWord(sc, 0xFA38, 0x48C8);
-                MP_WriteMcuAccessRegWord(sc, 0xFA3A, 0x48CA);
-                MP_WriteMcuAccessRegWord(sc, 0xFA3C, 0x9C44);
-                MP_WriteMcuAccessRegWord(sc, 0xFA3E, 0x48E0);
-                MP_WriteMcuAccessRegWord(sc, 0xFA40, 0xE006);
-                MP_WriteMcuAccessRegWord(sc, 0xFA42, 0x7444);
-                MP_WriteMcuAccessRegWord(sc, 0xFA44, 0x49CA);
-                MP_WriteMcuAccessRegWord(sc, 0xFA46, 0xF004);
-                MP_WriteMcuAccessRegWord(sc, 0xFA48, 0x48CA);
-                MP_WriteMcuAccessRegWord(sc, 0xFA4A, 0x9C44);
-                MP_WriteMcuAccessRegWord(sc, 0xFA4C, 0xE851);
-                MP_WriteMcuAccessRegWord(sc, 0xFA4E, 0xE04E);
-                MP_WriteMcuAccessRegWord(sc, 0xFA50, 0x49E8);
-                MP_WriteMcuAccessRegWord(sc, 0xFA52, 0xF020);
-                MP_WriteMcuAccessRegWord(sc, 0xFA54, 0x1D01);
-                MP_WriteMcuAccessRegWord(sc, 0xFA56, 0x8DF5);
-                MP_WriteMcuAccessRegWord(sc, 0xFA58, 0x7440);
-                MP_WriteMcuAccessRegWord(sc, 0xFA5A, 0x49C0);
-                MP_WriteMcuAccessRegWord(sc, 0xFA5C, 0xF11A);
-                MP_WriteMcuAccessRegWord(sc, 0xFA5E, 0x7444);
-                MP_WriteMcuAccessRegWord(sc, 0xFA60, 0x49C8);
-                MP_WriteMcuAccessRegWord(sc, 0xFA62, 0xF017);
-                MP_WriteMcuAccessRegWord(sc, 0xFA64, 0x49CA);
-                MP_WriteMcuAccessRegWord(sc, 0xFA66, 0xF115);
-                MP_WriteMcuAccessRegWord(sc, 0xFA68, 0x49C0);
-                MP_WriteMcuAccessRegWord(sc, 0xFA6A, 0xF103);
-                MP_WriteMcuAccessRegWord(sc, 0xFA6C, 0x49C1);
-                MP_WriteMcuAccessRegWord(sc, 0xFA6E, 0xF011);
-                MP_WriteMcuAccessRegWord(sc, 0xFA70, 0x4849);
-                MP_WriteMcuAccessRegWord(sc, 0xFA72, 0x9C44);
-                MP_WriteMcuAccessRegWord(sc, 0xFA74, 0x1C00);
-                MP_WriteMcuAccessRegWord(sc, 0xFA76, 0x9CF6);
-                MP_WriteMcuAccessRegWord(sc, 0xFA78, 0x7444);
-                MP_WriteMcuAccessRegWord(sc, 0xFA7A, 0x49C1);
-                MP_WriteMcuAccessRegWord(sc, 0xFA7C, 0xF004);
-                MP_WriteMcuAccessRegWord(sc, 0xFA7E, 0x6446);
-                MP_WriteMcuAccessRegWord(sc, 0xFA80, 0x1E07);
-                MP_WriteMcuAccessRegWord(sc, 0xFA82, 0xE003);
-                MP_WriteMcuAccessRegWord(sc, 0xFA84, 0x1C01);
-                MP_WriteMcuAccessRegWord(sc, 0xFA86, 0x1E03);
-                MP_WriteMcuAccessRegWord(sc, 0xFA88, 0x9C62);
-                MP_WriteMcuAccessRegWord(sc, 0xFA8A, 0x1C11);
-                MP_WriteMcuAccessRegWord(sc, 0xFA8C, 0x8C60);
-                MP_WriteMcuAccessRegWord(sc, 0xFA8E, 0xE830);
-                MP_WriteMcuAccessRegWord(sc, 0xFA90, 0xE02D);
-                MP_WriteMcuAccessRegWord(sc, 0xFA92, 0x49E9);
-                MP_WriteMcuAccessRegWord(sc, 0xFA94, 0xF004);
-                MP_WriteMcuAccessRegWord(sc, 0xFA96, 0x1D02);
-                MP_WriteMcuAccessRegWord(sc, 0xFA98, 0x8DF5);
-                MP_WriteMcuAccessRegWord(sc, 0xFA9A, 0xE7A6);
-                MP_WriteMcuAccessRegWord(sc, 0xFA9C, 0x49E3);
-                MP_WriteMcuAccessRegWord(sc, 0xFA9E, 0xF006);
-                MP_WriteMcuAccessRegWord(sc, 0xFAA0, 0x1D08);
-                MP_WriteMcuAccessRegWord(sc, 0xFAA2, 0x8DF4);
-                MP_WriteMcuAccessRegWord(sc, 0xFAA4, 0x74F8);
-                MP_WriteMcuAccessRegWord(sc, 0xFAA6, 0x74F8);
-                MP_WriteMcuAccessRegWord(sc, 0xFAA8, 0xE745);
-                MP_WriteMcuAccessRegWord(sc, 0xFAAA, 0x49E1);
-                MP_WriteMcuAccessRegWord(sc, 0xFAAC, 0xF007);
-                MP_WriteMcuAccessRegWord(sc, 0xFAAE, 0x1D02);
-                MP_WriteMcuAccessRegWord(sc, 0xFAB0, 0x8DF4);
-                MP_WriteMcuAccessRegWord(sc, 0xFAB2, 0x1E01);
-                MP_WriteMcuAccessRegWord(sc, 0xFAB4, 0xE7B1);
-                MP_WriteMcuAccessRegWord(sc, 0xFAB6, 0xDE20);
-                MP_WriteMcuAccessRegWord(sc, 0xFAB8, 0xE410);
-                MP_WriteMcuAccessRegWord(sc, 0xFABA, 0x49E0);
-                MP_WriteMcuAccessRegWord(sc, 0xFABC, 0xF017);
-                MP_WriteMcuAccessRegWord(sc, 0xFABE, 0x1D01);
-                MP_WriteMcuAccessRegWord(sc, 0xFAC0, 0x8DF4);
-                MP_WriteMcuAccessRegWord(sc, 0xFAC2, 0xC5FA);
-                MP_WriteMcuAccessRegWord(sc, 0xFAC4, 0x1C00);
-                MP_WriteMcuAccessRegWord(sc, 0xFAC6, 0x8CA0);
-                MP_WriteMcuAccessRegWord(sc, 0xFAC8, 0x1C1B);
-                MP_WriteMcuAccessRegWord(sc, 0xFACA, 0x9CA2);
-                MP_WriteMcuAccessRegWord(sc, 0xFACC, 0x74A2);
-                MP_WriteMcuAccessRegWord(sc, 0xFACE, 0x49CF);
-                MP_WriteMcuAccessRegWord(sc, 0xFAD0, 0xF0FE);
-                MP_WriteMcuAccessRegWord(sc, 0xFAD2, 0xC5F3);
-                MP_WriteMcuAccessRegWord(sc, 0xFAD4, 0x74A0);
-                MP_WriteMcuAccessRegWord(sc, 0xFAD6, 0x4849);
-                MP_WriteMcuAccessRegWord(sc, 0xFAD8, 0x9CA0);
-                MP_WriteMcuAccessRegWord(sc, 0xFADA, 0x74F8);
-                MP_WriteMcuAccessRegWord(sc, 0xFADC, 0x49C0);
-                MP_WriteMcuAccessRegWord(sc, 0xFADE, 0xF006);
-                MP_WriteMcuAccessRegWord(sc, 0xFAE0, 0x48C3);
-                MP_WriteMcuAccessRegWord(sc, 0xFAE2, 0x8CF8);
-                MP_WriteMcuAccessRegWord(sc, 0xFAE4, 0xE81C);
-                MP_WriteMcuAccessRegWord(sc, 0xFAE6, 0x74F8);
-                MP_WriteMcuAccessRegWord(sc, 0xFAE8, 0x74F8);
-                MP_WriteMcuAccessRegWord(sc, 0xFAEA, 0xC42A);
-                MP_WriteMcuAccessRegWord(sc, 0xFAEC, 0xBC00);
-                MP_WriteMcuAccessRegWord(sc, 0xFAEE, 0xC5E4);
-                MP_WriteMcuAccessRegWord(sc, 0xFAF0, 0x74A2);
-                MP_WriteMcuAccessRegWord(sc, 0xFAF2, 0x49CE);
-                MP_WriteMcuAccessRegWord(sc, 0xFAF4, 0xF1FE);
-                MP_WriteMcuAccessRegWord(sc, 0xFAF6, 0x9EA0);
-                MP_WriteMcuAccessRegWord(sc, 0xFAF8, 0x1C1C);
-                MP_WriteMcuAccessRegWord(sc, 0xFAFA, 0x484F);
-                MP_WriteMcuAccessRegWord(sc, 0xFAFC, 0x9CA2);
-                MP_WriteMcuAccessRegWord(sc, 0xFAFE, 0xFF80);
-                MP_WriteMcuAccessRegWord(sc, 0xFB00, 0xC5DB);
-                MP_WriteMcuAccessRegWord(sc, 0xFB02, 0x74A2);
-                MP_WriteMcuAccessRegWord(sc, 0xFB04, 0x49CE);
-                MP_WriteMcuAccessRegWord(sc, 0xFB06, 0xF1FE);
-                MP_WriteMcuAccessRegWord(sc, 0xFB08, 0xC419);
-                MP_WriteMcuAccessRegWord(sc, 0xFB0A, 0x9CA0);
-                MP_WriteMcuAccessRegWord(sc, 0xFB0C, 0xC416);
-                MP_WriteMcuAccessRegWord(sc, 0xFB0E, 0x1C13);
-                MP_WriteMcuAccessRegWord(sc, 0xFB10, 0x484F);
-                MP_WriteMcuAccessRegWord(sc, 0xFB12, 0x9CA2);
-                MP_WriteMcuAccessRegWord(sc, 0xFB14, 0x74A2);
-                MP_WriteMcuAccessRegWord(sc, 0xFB16, 0x49CF);
-                MP_WriteMcuAccessRegWord(sc, 0xFB18, 0xF1FE);
-                MP_WriteMcuAccessRegWord(sc, 0xFB1A, 0xFF80);
-                MP_WriteMcuAccessRegWord(sc, 0xFB1C, 0xC5CD);
-                MP_WriteMcuAccessRegWord(sc, 0xFB1E, 0x74A2);
-                MP_WriteMcuAccessRegWord(sc, 0xFB20, 0x49CE);
-                MP_WriteMcuAccessRegWord(sc, 0xFB22, 0xF1FE);
-                MP_WriteMcuAccessRegWord(sc, 0xFB24, 0xC40C);
-                MP_WriteMcuAccessRegWord(sc, 0xFB26, 0x9CA0);
-                MP_WriteMcuAccessRegWord(sc, 0xFB28, 0xC408);
-                MP_WriteMcuAccessRegWord(sc, 0xFB2A, 0x1C13);
-                MP_WriteMcuAccessRegWord(sc, 0xFB2C, 0x484F);
-                MP_WriteMcuAccessRegWord(sc, 0xFB2E, 0x9CA2);
-                MP_WriteMcuAccessRegWord(sc, 0xFB30, 0x74A2);
-                MP_WriteMcuAccessRegWord(sc, 0xFB32, 0x49CF);
-                MP_WriteMcuAccessRegWord(sc, 0xFB34, 0xF1FE);
-                MP_WriteMcuAccessRegWord(sc, 0xFB36, 0xFF80);
-                MP_WriteMcuAccessRegWord(sc, 0xFB38, 0x0000);
-                MP_WriteMcuAccessRegWord(sc, 0xFB3A, 0x0481);
-                MP_WriteMcuAccessRegWord(sc, 0xFB3C, 0x0C81);
-                MP_WriteMcuAccessRegWord(sc, 0xFB3E, 0x0AE0);
-
-                MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000);
-
-                MP_WriteMcuAccessRegWord(sc, 0xFC28, 0x0000);
-                MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x0A2F);
-                MP_WriteMcuAccessRegWord(sc, 0xFC2C, 0x0297);
-                MP_WriteMcuAccessRegWord(sc, 0xFC2E, 0x0A61);
-                MP_WriteMcuAccessRegWord(sc, 0xFC30, 0x00A9);
-                MP_WriteMcuAccessRegWord(sc, 0xFC32, 0x012D);
-                MP_WriteMcuAccessRegWord(sc, 0xFC34, 0x0000);
-                MP_WriteMcuAccessRegWord(sc, 0xFC36, 0x08DF);
+                re_set_mac_mcu_8168gu_2(sc);
                 break;
         case MACFG_60:
-                DisableMcuBPs(sc);
-
-                MP_WriteMcuAccessRegWord(sc, 0xF800, 0xE008);
-                MP_WriteMcuAccessRegWord(sc, 0xF802, 0xE00A);
-                MP_WriteMcuAccessRegWord(sc, 0xF804, 0xE00C);
-                MP_WriteMcuAccessRegWord(sc, 0xF806, 0xE00E);
-                MP_WriteMcuAccessRegWord(sc, 0xF808, 0xE027);
-                MP_WriteMcuAccessRegWord(sc, 0xF80A, 0xE04F);
-                MP_WriteMcuAccessRegWord(sc, 0xF80C, 0xE05E);
-                MP_WriteMcuAccessRegWord(sc, 0xF80E, 0xE065);
-                MP_WriteMcuAccessRegWord(sc, 0xF810, 0xC602);
-                MP_WriteMcuAccessRegWord(sc, 0xF812, 0xBE00);
-                MP_WriteMcuAccessRegWord(sc, 0xF814, 0x0000);
-                MP_WriteMcuAccessRegWord(sc, 0xF816, 0xC502);
-                MP_WriteMcuAccessRegWord(sc, 0xF818, 0xBD00);
-                MP_WriteMcuAccessRegWord(sc, 0xF81A, 0x074C);
-                MP_WriteMcuAccessRegWord(sc, 0xF81C, 0xC302);
-                MP_WriteMcuAccessRegWord(sc, 0xF81E, 0xBB00);
-                MP_WriteMcuAccessRegWord(sc, 0xF820, 0x080A);
-                MP_WriteMcuAccessRegWord(sc, 0xF822, 0x6420);
-                MP_WriteMcuAccessRegWord(sc, 0xF824, 0x48C2);
-                MP_WriteMcuAccessRegWord(sc, 0xF826, 0x8C20);
-                MP_WriteMcuAccessRegWord(sc, 0xF828, 0xC516);
-                MP_WriteMcuAccessRegWord(sc, 0xF82A, 0x64A4);
-                MP_WriteMcuAccessRegWord(sc, 0xF82C, 0x49C0);
-                MP_WriteMcuAccessRegWord(sc, 0xF82E, 0xF009);
-                MP_WriteMcuAccessRegWord(sc, 0xF830, 0x74A2);
-                MP_WriteMcuAccessRegWord(sc, 0xF832, 0x8CA5);
-                MP_WriteMcuAccessRegWord(sc, 0xF834, 0x74A0);
-                MP_WriteMcuAccessRegWord(sc, 0xF836, 0xC50E);
-                MP_WriteMcuAccessRegWord(sc, 0xF838, 0x9CA2);
-                MP_WriteMcuAccessRegWord(sc, 0xF83A, 0x1C11);
-                MP_WriteMcuAccessRegWord(sc, 0xF83C, 0x9CA0);
-                MP_WriteMcuAccessRegWord(sc, 0xF83E, 0xE006);
-                MP_WriteMcuAccessRegWord(sc, 0xF840, 0x74F8);
-                MP_WriteMcuAccessRegWord(sc, 0xF842, 0x48C4);
-                MP_WriteMcuAccessRegWord(sc, 0xF844, 0x8CF8);
-                MP_WriteMcuAccessRegWord(sc, 0xF846, 0xC404);
-                MP_WriteMcuAccessRegWord(sc, 0xF848, 0xBC00);
-                MP_WriteMcuAccessRegWord(sc, 0xF84A, 0xC403);
-                MP_WriteMcuAccessRegWord(sc, 0xF84C, 0xBC00);
-                MP_WriteMcuAccessRegWord(sc, 0xF84E, 0x0BF2);
-                MP_WriteMcuAccessRegWord(sc, 0xF850, 0x0C0A);
-                MP_WriteMcuAccessRegWord(sc, 0xF852, 0xE434);
-                MP_WriteMcuAccessRegWord(sc, 0xF854, 0xD3C0);
-                MP_WriteMcuAccessRegWord(sc, 0xF856, 0x49D9);
-                MP_WriteMcuAccessRegWord(sc, 0xF858, 0xF01F);
-                MP_WriteMcuAccessRegWord(sc, 0xF85A, 0xC526);
-                MP_WriteMcuAccessRegWord(sc, 0xF85C, 0x64A5);
-                MP_WriteMcuAccessRegWord(sc, 0xF85E, 0x1400);
-                MP_WriteMcuAccessRegWord(sc, 0xF860, 0xF007);
-                MP_WriteMcuAccessRegWord(sc, 0xF862, 0x0C01);
-                MP_WriteMcuAccessRegWord(sc, 0xF864, 0x8CA5);
-                MP_WriteMcuAccessRegWord(sc, 0xF866, 0x1C15);
-                MP_WriteMcuAccessRegWord(sc, 0xF868, 0xC51B);
-                MP_WriteMcuAccessRegWord(sc, 0xF86A, 0x9CA0);
-                MP_WriteMcuAccessRegWord(sc, 0xF86C, 0xE013);
-                MP_WriteMcuAccessRegWord(sc, 0xF86E, 0xC519);
-                MP_WriteMcuAccessRegWord(sc, 0xF870, 0x74A0);
-                MP_WriteMcuAccessRegWord(sc, 0xF872, 0x48C4);
-                MP_WriteMcuAccessRegWord(sc, 0xF874, 0x8CA0);
-                MP_WriteMcuAccessRegWord(sc, 0xF876, 0xC516);
-                MP_WriteMcuAccessRegWord(sc, 0xF878, 0x74A4);
-                MP_WriteMcuAccessRegWord(sc, 0xF87A, 0x48C8);
-                MP_WriteMcuAccessRegWord(sc, 0xF87C, 0x48CA);
-                MP_WriteMcuAccessRegWord(sc, 0xF87E, 0x9CA4);
-                MP_WriteMcuAccessRegWord(sc, 0xF880, 0xC512);
-                MP_WriteMcuAccessRegWord(sc, 0xF882, 0x1B00);
-                MP_WriteMcuAccessRegWord(sc, 0xF884, 0x9BA0);
-                MP_WriteMcuAccessRegWord(sc, 0xF886, 0x1B1C);
-                MP_WriteMcuAccessRegWord(sc, 0xF888, 0x483F);
-                MP_WriteMcuAccessRegWord(sc, 0xF88A, 0x9BA2);
-                MP_WriteMcuAccessRegWord(sc, 0xF88C, 0x1B04);
-                MP_WriteMcuAccessRegWord(sc, 0xF88E, 0xC508);
-                MP_WriteMcuAccessRegWord(sc, 0xF890, 0x9BA0);
-                MP_WriteMcuAccessRegWord(sc, 0xF892, 0xC505);
-                MP_WriteMcuAccessRegWord(sc, 0xF894, 0xBD00);
-                MP_WriteMcuAccessRegWord(sc, 0xF896, 0xC502);
-                MP_WriteMcuAccessRegWord(sc, 0xF898, 0xBD00);
-                MP_WriteMcuAccessRegWord(sc, 0xF89A, 0x0300);
-                MP_WriteMcuAccessRegWord(sc, 0xF89C, 0x051E);
-                MP_WriteMcuAccessRegWord(sc, 0xF89E, 0xE434);
-                MP_WriteMcuAccessRegWord(sc, 0xF8A0, 0xE018);
-                MP_WriteMcuAccessRegWord(sc, 0xF8A2, 0xE092);
-                MP_WriteMcuAccessRegWord(sc, 0xF8A4, 0xDE20);
-                MP_WriteMcuAccessRegWord(sc, 0xF8A6, 0xD3C0);
-                MP_WriteMcuAccessRegWord(sc, 0xF8A8, 0xC50F);
-                MP_WriteMcuAccessRegWord(sc, 0xF8AA, 0x76A4);
-                MP_WriteMcuAccessRegWord(sc, 0xF8AC, 0x49E3);
-                MP_WriteMcuAccessRegWord(sc, 0xF8AE, 0xF007);
-                MP_WriteMcuAccessRegWord(sc, 0xF8B0, 0x49C0);
-                MP_WriteMcuAccessRegWord(sc, 0xF8B2, 0xF103);
-                MP_WriteMcuAccessRegWord(sc, 0xF8B4, 0xC607);
-                MP_WriteMcuAccessRegWord(sc, 0xF8B6, 0xBE00);
-                MP_WriteMcuAccessRegWord(sc, 0xF8B8, 0xC606);
-                MP_WriteMcuAccessRegWord(sc, 0xF8BA, 0xBE00);
-                MP_WriteMcuAccessRegWord(sc, 0xF8BC, 0xC602);
-                MP_WriteMcuAccessRegWord(sc, 0xF8BE, 0xBE00);
-                MP_WriteMcuAccessRegWord(sc, 0xF8C0, 0x0C4C);
-                MP_WriteMcuAccessRegWord(sc, 0xF8C2, 0x0C28);
-                MP_WriteMcuAccessRegWord(sc, 0xF8C4, 0x0C2C);
-                MP_WriteMcuAccessRegWord(sc, 0xF8C6, 0xDC00);
-                MP_WriteMcuAccessRegWord(sc, 0xF8C8, 0xC707);
-                MP_WriteMcuAccessRegWord(sc, 0xF8CA, 0x1D00);
-                MP_WriteMcuAccessRegWord(sc, 0xF8CC, 0x8DE2);
-                MP_WriteMcuAccessRegWord(sc, 0xF8CE, 0x48C1);
-                MP_WriteMcuAccessRegWord(sc, 0xF8D0, 0xC502);
-                MP_WriteMcuAccessRegWord(sc, 0xF8D2, 0xBD00);
-                MP_WriteMcuAccessRegWord(sc, 0xF8D4, 0x00AA);
-                MP_WriteMcuAccessRegWord(sc, 0xF8D6, 0xE0C0);
-                MP_WriteMcuAccessRegWord(sc, 0xF8D8, 0xC502);
-                MP_WriteMcuAccessRegWord(sc, 0xF8DA, 0xBD00);
-                MP_WriteMcuAccessRegWord(sc, 0xF8DC, 0x0132);
-
-                MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000);
-
-                MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x0743);
-                MP_WriteMcuAccessRegWord(sc, 0xFC2C, 0x0801);
-                MP_WriteMcuAccessRegWord(sc, 0xFC2E, 0x0BE9);
-                MP_WriteMcuAccessRegWord(sc, 0xFC30, 0x02FD);
-                MP_WriteMcuAccessRegWord(sc, 0xFC32, 0x0C25);
-                MP_WriteMcuAccessRegWord(sc, 0xFC34, 0x00A9);
-                MP_WriteMcuAccessRegWord(sc, 0xFC36, 0x012D);
+                re_set_mac_mcu_8411b_1(sc);
                 break;
         case MACFG_62:
-                DisableMcuBPs(sc);
-
-                MP_WriteMcuAccessRegWord(sc, 0xF800, 0xE008);
-                MP_WriteMcuAccessRegWord(sc, 0xF802, 0xE0D3);
-                MP_WriteMcuAccessRegWord(sc, 0xF804, 0xE0D6);
-                MP_WriteMcuAccessRegWord(sc, 0xF806, 0xE0D9);
-                MP_WriteMcuAccessRegWord(sc, 0xF808, 0xE0DB);
-                MP_WriteMcuAccessRegWord(sc, 0xF80A, 0xE0DD);
-                MP_WriteMcuAccessRegWord(sc, 0xF80C, 0xE0DF);
-                MP_WriteMcuAccessRegWord(sc, 0xF80E, 0xE0E1);
-                MP_WriteMcuAccessRegWord(sc, 0xF810, 0xC251);
-                MP_WriteMcuAccessRegWord(sc, 0xF812, 0x7340);
-                MP_WriteMcuAccessRegWord(sc, 0xF814, 0x49B1);
-                MP_WriteMcuAccessRegWord(sc, 0xF816, 0xF010);
-                MP_WriteMcuAccessRegWord(sc, 0xF818, 0x1D02);
-                MP_WriteMcuAccessRegWord(sc, 0xF81A, 0x8D40);
-                MP_WriteMcuAccessRegWord(sc, 0xF81C, 0xC202);
-                MP_WriteMcuAccessRegWord(sc, 0xF81E, 0xBA00);
-                MP_WriteMcuAccessRegWord(sc, 0xF820, 0x2C3A);
-                MP_WriteMcuAccessRegWord(sc, 0xF822, 0xC0F0);
-                MP_WriteMcuAccessRegWord(sc, 0xF824, 0xE8DE);
-                MP_WriteMcuAccessRegWord(sc, 0xF826, 0x2000);
-                MP_WriteMcuAccessRegWord(sc, 0xF828, 0x8000);
-                MP_WriteMcuAccessRegWord(sc, 0xF82A, 0xC0B6);
-                MP_WriteMcuAccessRegWord(sc, 0xF82C, 0x268C);
-                MP_WriteMcuAccessRegWord(sc, 0xF82E, 0x752C);
-                MP_WriteMcuAccessRegWord(sc, 0xF830, 0x49D4);
-                MP_WriteMcuAccessRegWord(sc, 0xF832, 0xF112);
-                MP_WriteMcuAccessRegWord(sc, 0xF834, 0xE025);
-                MP_WriteMcuAccessRegWord(sc, 0xF836, 0xC2F6);
-                MP_WriteMcuAccessRegWord(sc, 0xF838, 0x7146);
-                MP_WriteMcuAccessRegWord(sc, 0xF83A, 0xC2F5);
-                MP_WriteMcuAccessRegWord(sc, 0xF83C, 0x7340);
-                MP_WriteMcuAccessRegWord(sc, 0xF83E, 0x49BE);
-                MP_WriteMcuAccessRegWord(sc, 0xF840, 0xF103);
-                MP_WriteMcuAccessRegWord(sc, 0xF842, 0xC7F2);
-                MP_WriteMcuAccessRegWord(sc, 0xF844, 0xE002);
-                MP_WriteMcuAccessRegWord(sc, 0xF846, 0xC7F1);
-                MP_WriteMcuAccessRegWord(sc, 0xF848, 0x304F);
-                MP_WriteMcuAccessRegWord(sc, 0xF84A, 0x6226);
-                MP_WriteMcuAccessRegWord(sc, 0xF84C, 0x49A1);
-                MP_WriteMcuAccessRegWord(sc, 0xF84E, 0xF1F0);
-                MP_WriteMcuAccessRegWord(sc, 0xF850, 0x7222);
-                MP_WriteMcuAccessRegWord(sc, 0xF852, 0x49A0);
-                MP_WriteMcuAccessRegWord(sc, 0xF854, 0xF1ED);
-                MP_WriteMcuAccessRegWord(sc, 0xF856, 0x2525);
-                MP_WriteMcuAccessRegWord(sc, 0xF858, 0x1F28);
-                MP_WriteMcuAccessRegWord(sc, 0xF85A, 0x3097);
-                MP_WriteMcuAccessRegWord(sc, 0xF85C, 0x3091);
-                MP_WriteMcuAccessRegWord(sc, 0xF85E, 0x9A36);
-                MP_WriteMcuAccessRegWord(sc, 0xF860, 0x752C);
-                MP_WriteMcuAccessRegWord(sc, 0xF862, 0x21DC);
-                MP_WriteMcuAccessRegWord(sc, 0xF864, 0x25BC);
-                MP_WriteMcuAccessRegWord(sc, 0xF866, 0xC6E2);
-                MP_WriteMcuAccessRegWord(sc, 0xF868, 0x77C0);
-                MP_WriteMcuAccessRegWord(sc, 0xF86A, 0x1304);
-                MP_WriteMcuAccessRegWord(sc, 0xF86C, 0xF014);
-                MP_WriteMcuAccessRegWord(sc, 0xF86E, 0x1303);
-                MP_WriteMcuAccessRegWord(sc, 0xF870, 0xF014);
-                MP_WriteMcuAccessRegWord(sc, 0xF872, 0x1302);
-                MP_WriteMcuAccessRegWord(sc, 0xF874, 0xF014);
-                MP_WriteMcuAccessRegWord(sc, 0xF876, 0x1301);
-                MP_WriteMcuAccessRegWord(sc, 0xF878, 0xF014);
-                MP_WriteMcuAccessRegWord(sc, 0xF87A, 0x49D4);
-                MP_WriteMcuAccessRegWord(sc, 0xF87C, 0xF103);
-                MP_WriteMcuAccessRegWord(sc, 0xF87E, 0xC3D7);
-                MP_WriteMcuAccessRegWord(sc, 0xF880, 0xBB00);
-                MP_WriteMcuAccessRegWord(sc, 0xF882, 0xC618);
-                MP_WriteMcuAccessRegWord(sc, 0xF884, 0x67C6);
-                MP_WriteMcuAccessRegWord(sc, 0xF886, 0x752E);
-                MP_WriteMcuAccessRegWord(sc, 0xF888, 0x22D7);
-                MP_WriteMcuAccessRegWord(sc, 0xF88A, 0x26DD);
-                MP_WriteMcuAccessRegWord(sc, 0xF88C, 0x1505);
-                MP_WriteMcuAccessRegWord(sc, 0xF88E, 0xF013);
-                MP_WriteMcuAccessRegWord(sc, 0xF890, 0xC60A);
-                MP_WriteMcuAccessRegWord(sc, 0xF892, 0xBE00);
-                MP_WriteMcuAccessRegWord(sc, 0xF894, 0xC309);
-                MP_WriteMcuAccessRegWord(sc, 0xF896, 0xBB00);
-                MP_WriteMcuAccessRegWord(sc, 0xF898, 0xC308);
-                MP_WriteMcuAccessRegWord(sc, 0xF89A, 0xBB00);
-                MP_WriteMcuAccessRegWord(sc, 0xF89C, 0xC307);
-                MP_WriteMcuAccessRegWord(sc, 0xF89E, 0xBB00);
-                MP_WriteMcuAccessRegWord(sc, 0xF8A0, 0xC306);
-                MP_WriteMcuAccessRegWord(sc, 0xF8A2, 0xBB00);
-                MP_WriteMcuAccessRegWord(sc, 0xF8A4, 0x25C8);
-                MP_WriteMcuAccessRegWord(sc, 0xF8A6, 0x25A6);
-                MP_WriteMcuAccessRegWord(sc, 0xF8A8, 0x25AC);
-                MP_WriteMcuAccessRegWord(sc, 0xF8AA, 0x25B2);
-                MP_WriteMcuAccessRegWord(sc, 0xF8AC, 0x25B8);
-                MP_WriteMcuAccessRegWord(sc, 0xF8AE, 0xCD08);
-                MP_WriteMcuAccessRegWord(sc, 0xF8B0, 0x0000);
-                MP_WriteMcuAccessRegWord(sc, 0xF8B2, 0xC0BC);
-                MP_WriteMcuAccessRegWord(sc, 0xF8B4, 0xC2FF);
-                MP_WriteMcuAccessRegWord(sc, 0xF8B6, 0x7340);
-                MP_WriteMcuAccessRegWord(sc, 0xF8B8, 0x49B0);
-                MP_WriteMcuAccessRegWord(sc, 0xF8BA, 0xF04E);
-                MP_WriteMcuAccessRegWord(sc, 0xF8BC, 0x1F46);
-                MP_WriteMcuAccessRegWord(sc, 0xF8BE, 0x308F);
-                MP_WriteMcuAccessRegWord(sc, 0xF8C0, 0xC3F7);
-                MP_WriteMcuAccessRegWord(sc, 0xF8C2, 0x1C04);
-                MP_WriteMcuAccessRegWord(sc, 0xF8C4, 0xE84D);
-                MP_WriteMcuAccessRegWord(sc, 0xF8C6, 0x1401);
-                MP_WriteMcuAccessRegWord(sc, 0xF8C8, 0xF147);
-                MP_WriteMcuAccessRegWord(sc, 0xF8CA, 0x7226);
-                MP_WriteMcuAccessRegWord(sc, 0xF8CC, 0x49A7);
-                MP_WriteMcuAccessRegWord(sc, 0xF8CE, 0xF044);
-                MP_WriteMcuAccessRegWord(sc, 0xF8D0, 0x7222);
-                MP_WriteMcuAccessRegWord(sc, 0xF8D2, 0x2525);
-                MP_WriteMcuAccessRegWord(sc, 0xF8D4, 0x1F30);
-                MP_WriteMcuAccessRegWord(sc, 0xF8D6, 0x3097);
-                MP_WriteMcuAccessRegWord(sc, 0xF8D8, 0x3091);
-                MP_WriteMcuAccessRegWord(sc, 0xF8DA, 0x7340);
-                MP_WriteMcuAccessRegWord(sc, 0xF8DC, 0xC4EA);
-                MP_WriteMcuAccessRegWord(sc, 0xF8DE, 0x401C);
-                MP_WriteMcuAccessRegWord(sc, 0xF8E0, 0xF006);
-                MP_WriteMcuAccessRegWord(sc, 0xF8E2, 0xC6E8);
-                MP_WriteMcuAccessRegWord(sc, 0xF8E4, 0x75C0);
-                MP_WriteMcuAccessRegWord(sc, 0xF8E6, 0x49D7);
-                MP_WriteMcuAccessRegWord(sc, 0xF8E8, 0xF105);
-                MP_WriteMcuAccessRegWord(sc, 0xF8EA, 0xE036);
-                MP_WriteMcuAccessRegWord(sc, 0xF8EC, 0x1D08);
-                MP_WriteMcuAccessRegWord(sc, 0xF8EE, 0x8DC1);
-                MP_WriteMcuAccessRegWord(sc, 0xF8F0, 0x0208);
-                MP_WriteMcuAccessRegWord(sc, 0xF8F2, 0x6640);
-                MP_WriteMcuAccessRegWord(sc, 0xF8F4, 0x2764);
-                MP_WriteMcuAccessRegWord(sc, 0xF8F6, 0x1606);
-                MP_WriteMcuAccessRegWord(sc, 0xF8F8, 0xF12F);
-                MP_WriteMcuAccessRegWord(sc, 0xF8FA, 0x6346);
-                MP_WriteMcuAccessRegWord(sc, 0xF8FC, 0x133B);
-                MP_WriteMcuAccessRegWord(sc, 0xF8FE, 0xF12C);
-                MP_WriteMcuAccessRegWord(sc, 0xF900, 0x9B34);
-                MP_WriteMcuAccessRegWord(sc, 0xF902, 0x1B18);
-                MP_WriteMcuAccessRegWord(sc, 0xF904, 0x3093);
-                MP_WriteMcuAccessRegWord(sc, 0xF906, 0xC32A);
-                MP_WriteMcuAccessRegWord(sc, 0xF908, 0x1C10);
-                MP_WriteMcuAccessRegWord(sc, 0xF90A, 0xE82A);
-                MP_WriteMcuAccessRegWord(sc, 0xF90C, 0x1401);
-                MP_WriteMcuAccessRegWord(sc, 0xF90E, 0xF124);
-                MP_WriteMcuAccessRegWord(sc, 0xF910, 0x1A36);
-                MP_WriteMcuAccessRegWord(sc, 0xF912, 0x308A);
-                MP_WriteMcuAccessRegWord(sc, 0xF914, 0x7322);
-                MP_WriteMcuAccessRegWord(sc, 0xF916, 0x25B5);
-                MP_WriteMcuAccessRegWord(sc, 0xF918, 0x0B0E);
-                MP_WriteMcuAccessRegWord(sc, 0xF91A, 0x1C00);
-                MP_WriteMcuAccessRegWord(sc, 0xF91C, 0xE82C);
-                MP_WriteMcuAccessRegWord(sc, 0xF91E, 0xC71F);
-                MP_WriteMcuAccessRegWord(sc, 0xF920, 0x4027);
-                MP_WriteMcuAccessRegWord(sc, 0xF922, 0xF11A);
-                MP_WriteMcuAccessRegWord(sc, 0xF924, 0xE838);
-                MP_WriteMcuAccessRegWord(sc, 0xF926, 0x1F42);
-                MP_WriteMcuAccessRegWord(sc, 0xF928, 0x308F);
-                MP_WriteMcuAccessRegWord(sc, 0xF92A, 0x1B08);
-                MP_WriteMcuAccessRegWord(sc, 0xF92C, 0xE824);
-                MP_WriteMcuAccessRegWord(sc, 0xF92E, 0x7236);
-                MP_WriteMcuAccessRegWord(sc, 0xF930, 0x7746);
-                MP_WriteMcuAccessRegWord(sc, 0xF932, 0x1700);
-                MP_WriteMcuAccessRegWord(sc, 0xF934, 0xF00D);
-                MP_WriteMcuAccessRegWord(sc, 0xF936, 0xC313);
-                MP_WriteMcuAccessRegWord(sc, 0xF938, 0x401F);
-                MP_WriteMcuAccessRegWord(sc, 0xF93A, 0xF103);
-                MP_WriteMcuAccessRegWord(sc, 0xF93C, 0x1F00);
-                MP_WriteMcuAccessRegWord(sc, 0xF93E, 0x9F46);
-                MP_WriteMcuAccessRegWord(sc, 0xF940, 0x7744);
-                MP_WriteMcuAccessRegWord(sc, 0xF942, 0x449F);
-                MP_WriteMcuAccessRegWord(sc, 0xF944, 0x445F);
-                MP_WriteMcuAccessRegWord(sc, 0xF946, 0xE817);
-                MP_WriteMcuAccessRegWord(sc, 0xF948, 0xC70A);
-                MP_WriteMcuAccessRegWord(sc, 0xF94A, 0x4027);
-                MP_WriteMcuAccessRegWord(sc, 0xF94C, 0xF105);
-                MP_WriteMcuAccessRegWord(sc, 0xF94E, 0xC302);
-                MP_WriteMcuAccessRegWord(sc, 0xF950, 0xBB00);
-                MP_WriteMcuAccessRegWord(sc, 0xF952, 0x2E08);
-                MP_WriteMcuAccessRegWord(sc, 0xF954, 0x2DC2);
-                MP_WriteMcuAccessRegWord(sc, 0xF956, 0xC7FF);
-                MP_WriteMcuAccessRegWord(sc, 0xF958, 0xBF00);
-                MP_WriteMcuAccessRegWord(sc, 0xF95A, 0xCDB8);
-                MP_WriteMcuAccessRegWord(sc, 0xF95C, 0xFFFF);
-                MP_WriteMcuAccessRegWord(sc, 0xF95E, 0x0C02);
-                MP_WriteMcuAccessRegWord(sc, 0xF960, 0xA554);
-                MP_WriteMcuAccessRegWord(sc, 0xF962, 0xA5DC);
-                MP_WriteMcuAccessRegWord(sc, 0xF964, 0x402F);
-                MP_WriteMcuAccessRegWord(sc, 0xF966, 0xF105);
-                MP_WriteMcuAccessRegWord(sc, 0xF968, 0x1400);
-                MP_WriteMcuAccessRegWord(sc, 0xF96A, 0xF1FA);
-                MP_WriteMcuAccessRegWord(sc, 0xF96C, 0x1C01);
-                MP_WriteMcuAccessRegWord(sc, 0xF96E, 0xE002);
-                MP_WriteMcuAccessRegWord(sc, 0xF970, 0x1C00);
-                MP_WriteMcuAccessRegWord(sc, 0xF972, 0xFF80);
-                MP_WriteMcuAccessRegWord(sc, 0xF974, 0x49B0);
-                MP_WriteMcuAccessRegWord(sc, 0xF976, 0xF004);
-                MP_WriteMcuAccessRegWord(sc, 0xF978, 0x0B01);
-                MP_WriteMcuAccessRegWord(sc, 0xF97A, 0xA1D3);
-                MP_WriteMcuAccessRegWord(sc, 0xF97C, 0xE003);
-                MP_WriteMcuAccessRegWord(sc, 0xF97E, 0x0B02);
-                MP_WriteMcuAccessRegWord(sc, 0xF980, 0xA5D3);
-                MP_WriteMcuAccessRegWord(sc, 0xF982, 0x3127);
-                MP_WriteMcuAccessRegWord(sc, 0xF984, 0x3720);
-                MP_WriteMcuAccessRegWord(sc, 0xF986, 0x0B02);
-                MP_WriteMcuAccessRegWord(sc, 0xF988, 0xA5D3);
-                MP_WriteMcuAccessRegWord(sc, 0xF98A, 0x3127);
-                MP_WriteMcuAccessRegWord(sc, 0xF98C, 0x3720);
-                MP_WriteMcuAccessRegWord(sc, 0xF98E, 0x1300);
-                MP_WriteMcuAccessRegWord(sc, 0xF990, 0xF1FB);
-                MP_WriteMcuAccessRegWord(sc, 0xF992, 0xFF80);
-                MP_WriteMcuAccessRegWord(sc, 0xF994, 0x7322);
-                MP_WriteMcuAccessRegWord(sc, 0xF996, 0x25B5);
-                MP_WriteMcuAccessRegWord(sc, 0xF998, 0x1E28);
-                MP_WriteMcuAccessRegWord(sc, 0xF99A, 0x30DE);
-                MP_WriteMcuAccessRegWord(sc, 0xF99C, 0x30D9);
-                MP_WriteMcuAccessRegWord(sc, 0xF99E, 0x7264);
-                MP_WriteMcuAccessRegWord(sc, 0xF9A0, 0x1E11);
-                MP_WriteMcuAccessRegWord(sc, 0xF9A2, 0x2368);
-                MP_WriteMcuAccessRegWord(sc, 0xF9A4, 0x3116);
-                MP_WriteMcuAccessRegWord(sc, 0xF9A6, 0xFF80);
-                MP_WriteMcuAccessRegWord(sc, 0xF9A8, 0x1B7E);
-                MP_WriteMcuAccessRegWord(sc, 0xF9AA, 0xC602);
-                MP_WriteMcuAccessRegWord(sc, 0xF9AC, 0xBE00);
-                MP_WriteMcuAccessRegWord(sc, 0xF9AE, 0x06A6);
-                MP_WriteMcuAccessRegWord(sc, 0xF9B0, 0x1B7E);
-                MP_WriteMcuAccessRegWord(sc, 0xF9B2, 0xC602);
-                MP_WriteMcuAccessRegWord(sc, 0xF9B4, 0xBE00);
-                MP_WriteMcuAccessRegWord(sc, 0xF9B6, 0x0764);
-                MP_WriteMcuAccessRegWord(sc, 0xF9B8, 0xC602);
-                MP_WriteMcuAccessRegWord(sc, 0xF9BA, 0xBE00);
-                MP_WriteMcuAccessRegWord(sc, 0xF9BC, 0x0000);
-                MP_WriteMcuAccessRegWord(sc, 0xF9BE, 0xC602);
-                MP_WriteMcuAccessRegWord(sc, 0xF9C0, 0xBE00);
-                MP_WriteMcuAccessRegWord(sc, 0xF9C2, 0x0000);
-                MP_WriteMcuAccessRegWord(sc, 0xF9C4, 0xC602);
-                MP_WriteMcuAccessRegWord(sc, 0xF9C6, 0xBE00);
-                MP_WriteMcuAccessRegWord(sc, 0xF9C8, 0x0000);
-                MP_WriteMcuAccessRegWord(sc, 0xF9CA, 0xC602);
-                MP_WriteMcuAccessRegWord(sc, 0xF9CC, 0xBE00);
-                MP_WriteMcuAccessRegWord(sc, 0xF9CE, 0x0000);
-                MP_WriteMcuAccessRegWord(sc, 0xF9D0, 0xC602);
-                MP_WriteMcuAccessRegWord(sc, 0xF9D2, 0xBE00);
-                MP_WriteMcuAccessRegWord(sc, 0xF9D4, 0x0000);
-
-                MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000);
-
-                MP_WriteMcuAccessRegWord(sc, 0xFC28, 0x2549);
-                MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x06A5);
-                MP_WriteMcuAccessRegWord(sc, 0xFC2C, 0x0763);
+                re_set_mac_mcu_8168ep_1(sc);
                 break;
         case MACFG_67:
-                DisableMcuBPs(sc);
-
-                MP_WriteMcuAccessRegWord(sc, 0xF800, 0xE008);
-                MP_WriteMcuAccessRegWord(sc, 0xF802, 0xE017);
-                MP_WriteMcuAccessRegWord(sc, 0xF804, 0xE019);
-                MP_WriteMcuAccessRegWord(sc, 0xF806, 0xE01B);
-                MP_WriteMcuAccessRegWord(sc, 0xF808, 0xE01D);
-                MP_WriteMcuAccessRegWord(sc, 0xF80A, 0xE01F);
-                MP_WriteMcuAccessRegWord(sc, 0xF80C, 0xE021);
-                MP_WriteMcuAccessRegWord(sc, 0xF80E, 0xE023);
-                MP_WriteMcuAccessRegWord(sc, 0xF810, 0xC50F);
-                MP_WriteMcuAccessRegWord(sc, 0xF812, 0x76A4);
-                MP_WriteMcuAccessRegWord(sc, 0xF814, 0x49E3);
-                MP_WriteMcuAccessRegWord(sc, 0xF816, 0xF007);
-                MP_WriteMcuAccessRegWord(sc, 0xF818, 0x49C0);
-                MP_WriteMcuAccessRegWord(sc, 0xF81A, 0xF103);
-                MP_WriteMcuAccessRegWord(sc, 0xF81C, 0xC607);
-                MP_WriteMcuAccessRegWord(sc, 0xF81E, 0xBE00);
-                MP_WriteMcuAccessRegWord(sc, 0xF820, 0xC606);
-                MP_WriteMcuAccessRegWord(sc, 0xF822, 0xBE00);
-                MP_WriteMcuAccessRegWord(sc, 0xF824, 0xC602);
-                MP_WriteMcuAccessRegWord(sc, 0xF826, 0xBE00);
-                MP_WriteMcuAccessRegWord(sc, 0xF828, 0x0BDA);
-                MP_WriteMcuAccessRegWord(sc, 0xF82A, 0x0BB0);
-                MP_WriteMcuAccessRegWord(sc, 0xF82C, 0x0BBA);
-                MP_WriteMcuAccessRegWord(sc, 0xF82E, 0xDC00);
-                MP_WriteMcuAccessRegWord(sc, 0xF830, 0xC602);
-                MP_WriteMcuAccessRegWord(sc, 0xF832, 0xBE00);
-                MP_WriteMcuAccessRegWord(sc, 0xF834, 0x0000);
-                MP_WriteMcuAccessRegWord(sc, 0xF836, 0xC602);
-                MP_WriteMcuAccessRegWord(sc, 0xF838, 0xBE00);
-                MP_WriteMcuAccessRegWord(sc, 0xF83A, 0x0000);
-                MP_WriteMcuAccessRegWord(sc, 0xF83C, 0xC602);
-                MP_WriteMcuAccessRegWord(sc, 0xF83E, 0xBE00);
-                MP_WriteMcuAccessRegWord(sc, 0xF840, 0x0000);
-                MP_WriteMcuAccessRegWord(sc, 0xF842, 0xC602);
-                MP_WriteMcuAccessRegWord(sc, 0xF844, 0xBE00);
-                MP_WriteMcuAccessRegWord(sc, 0xF846, 0x0000);
-                MP_WriteMcuAccessRegWord(sc, 0xF848, 0xC602);
-                MP_WriteMcuAccessRegWord(sc, 0xF84A, 0xBE00);
-                MP_WriteMcuAccessRegWord(sc, 0xF84C, 0x0000);
-                MP_WriteMcuAccessRegWord(sc, 0xF84E, 0xC602);
-                MP_WriteMcuAccessRegWord(sc, 0xF850, 0xBE00);
-                MP_WriteMcuAccessRegWord(sc, 0xF852, 0x0000);
-                MP_WriteMcuAccessRegWord(sc, 0xF854, 0xC602);
-                MP_WriteMcuAccessRegWord(sc, 0xF856, 0xBE00);
-                MP_WriteMcuAccessRegWord(sc, 0xF858, 0x0000);
-
-                MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000);
-
-                MP_WriteMcuAccessRegWord(sc, 0xFC28, 0x0BB3);
+                re_set_mac_mcu_8168ep_2(sc);
                 break;
         case MACFG_68:
         case MACFG_69:
+                re_set_mac_mcu_8168h_1(sc);
+                break;
+        case MACFG_70:
+                if (sc->HwPkgDet == 0x00 || sc->HwPkgDet == 0x0F)
+                        re_set_mac_mcu_8168fp_1(sc);
+                else if (sc->HwPkgDet == 0x06)
+                        re_set_mac_mcu_8168fp_2(sc);
+                break;
+        case MACFG_71:
                 DisableMcuBPs(sc);
-
-                MP_WriteMcuAccessRegWord(sc, 0xF800, 0xE008);
-                MP_WriteMcuAccessRegWord(sc, 0xF802, 0xE00F);
-                MP_WriteMcuAccessRegWord(sc, 0xF804, 0xE011);
-                MP_WriteMcuAccessRegWord(sc, 0xF806, 0xE047);
-                MP_WriteMcuAccessRegWord(sc, 0xF808, 0xE049);
-                MP_WriteMcuAccessRegWord(sc, 0xF80A, 0xE073);
-                MP_WriteMcuAccessRegWord(sc, 0xF80C, 0xE075);
-                MP_WriteMcuAccessRegWord(sc, 0xF80E, 0xE077);
-                MP_WriteMcuAccessRegWord(sc, 0xF810, 0xC707);
-                MP_WriteMcuAccessRegWord(sc, 0xF812, 0x1D00);
-                MP_WriteMcuAccessRegWord(sc, 0xF814, 0x8DE2);
-                MP_WriteMcuAccessRegWord(sc, 0xF816, 0x48C1);
-                MP_WriteMcuAccessRegWord(sc, 0xF818, 0xC502);
-                MP_WriteMcuAccessRegWord(sc, 0xF81A, 0xBD00);
-                MP_WriteMcuAccessRegWord(sc, 0xF81C, 0x00E4);
-                MP_WriteMcuAccessRegWord(sc, 0xF81E, 0xE0C0);
-                MP_WriteMcuAccessRegWord(sc, 0xF820, 0xC502);
-                MP_WriteMcuAccessRegWord(sc, 0xF822, 0xBD00);
-                MP_WriteMcuAccessRegWord(sc, 0xF824, 0x0216);
-                MP_WriteMcuAccessRegWord(sc, 0xF826, 0xC634);
-                MP_WriteMcuAccessRegWord(sc, 0xF828, 0x75C0);
-                MP_WriteMcuAccessRegWord(sc, 0xF82A, 0x49D3);
-                MP_WriteMcuAccessRegWord(sc, 0xF82C, 0xF027);
-                MP_WriteMcuAccessRegWord(sc, 0xF82E, 0xC631);
-                MP_WriteMcuAccessRegWord(sc, 0xF830, 0x75C0);
-                MP_WriteMcuAccessRegWord(sc, 0xF832, 0x49D3);
-                MP_WriteMcuAccessRegWord(sc, 0xF834, 0xF123);
-                MP_WriteMcuAccessRegWord(sc, 0xF836, 0xC627);
-                MP_WriteMcuAccessRegWord(sc, 0xF838, 0x75C0);
-                MP_WriteMcuAccessRegWord(sc, 0xF83A, 0xB405);
-                MP_WriteMcuAccessRegWord(sc, 0xF83C, 0xC525);
-                MP_WriteMcuAccessRegWord(sc, 0xF83E, 0x9DC0);
-                MP_WriteMcuAccessRegWord(sc, 0xF840, 0xC621);
-                MP_WriteMcuAccessRegWord(sc, 0xF842, 0x75C8);
-                MP_WriteMcuAccessRegWord(sc, 0xF844, 0x49D5);
-                MP_WriteMcuAccessRegWord(sc, 0xF846, 0xF00A);
-                MP_WriteMcuAccessRegWord(sc, 0xF848, 0x49D6);
-                MP_WriteMcuAccessRegWord(sc, 0xF84A, 0xF008);
-                MP_WriteMcuAccessRegWord(sc, 0xF84C, 0x49D7);
-                MP_WriteMcuAccessRegWord(sc, 0xF84E, 0xF006);
-                MP_WriteMcuAccessRegWord(sc, 0xF850, 0x49D8);
-                MP_WriteMcuAccessRegWord(sc, 0xF852, 0xF004);
-                MP_WriteMcuAccessRegWord(sc, 0xF854, 0x75D2);
-                MP_WriteMcuAccessRegWord(sc, 0xF856, 0x49D9);
-                MP_WriteMcuAccessRegWord(sc, 0xF858, 0xF111);
-                MP_WriteMcuAccessRegWord(sc, 0xF85A, 0xC517);
-                MP_WriteMcuAccessRegWord(sc, 0xF85C, 0x9DC8);
-                MP_WriteMcuAccessRegWord(sc, 0xF85E, 0xC516);
-                MP_WriteMcuAccessRegWord(sc, 0xF860, 0x9DD2);
-                MP_WriteMcuAccessRegWord(sc, 0xF862, 0xC618);
-                MP_WriteMcuAccessRegWord(sc, 0xF864, 0x75C0);
-                MP_WriteMcuAccessRegWord(sc, 0xF866, 0x49D4);
-                MP_WriteMcuAccessRegWord(sc, 0xF868, 0xF003);
-                MP_WriteMcuAccessRegWord(sc, 0xF86A, 0x49D0);
-                MP_WriteMcuAccessRegWord(sc, 0xF86C, 0xF104);
-                MP_WriteMcuAccessRegWord(sc, 0xF86E, 0xC60A);
-                MP_WriteMcuAccessRegWord(sc, 0xF870, 0xC50E);
-                MP_WriteMcuAccessRegWord(sc, 0xF872, 0x9DC0);
-                MP_WriteMcuAccessRegWord(sc, 0xF874, 0xB005);
-                MP_WriteMcuAccessRegWord(sc, 0xF876, 0xC607);
-                MP_WriteMcuAccessRegWord(sc, 0xF878, 0x9DC0);
-                MP_WriteMcuAccessRegWord(sc, 0xF87A, 0xB007);
-                MP_WriteMcuAccessRegWord(sc, 0xF87C, 0xC602);
-                MP_WriteMcuAccessRegWord(sc, 0xF87E, 0xBE00);
-                MP_WriteMcuAccessRegWord(sc, 0xF880, 0x1A06);
-                MP_WriteMcuAccessRegWord(sc, 0xF882, 0xB400);
-                MP_WriteMcuAccessRegWord(sc, 0xF884, 0xE86C);
-                MP_WriteMcuAccessRegWord(sc, 0xF886, 0xA000);
-                MP_WriteMcuAccessRegWord(sc, 0xF888, 0x01E1);
-                MP_WriteMcuAccessRegWord(sc, 0xF88A, 0x0200);
-                MP_WriteMcuAccessRegWord(sc, 0xF88C, 0x9200);
-                MP_WriteMcuAccessRegWord(sc, 0xF88E, 0xE84C);
-                MP_WriteMcuAccessRegWord(sc, 0xF890, 0xE004);
-                MP_WriteMcuAccessRegWord(sc, 0xF892, 0xE908);
-                MP_WriteMcuAccessRegWord(sc, 0xF894, 0xC502);
-                MP_WriteMcuAccessRegWord(sc, 0xF896, 0xBD00);
-                MP_WriteMcuAccessRegWord(sc, 0xF898, 0x0B58);
-                MP_WriteMcuAccessRegWord(sc, 0xF89A, 0xB407);
-                MP_WriteMcuAccessRegWord(sc, 0xF89C, 0xB404);
-                MP_WriteMcuAccessRegWord(sc, 0xF89E, 0x2195);
-                MP_WriteMcuAccessRegWord(sc, 0xF8A0, 0x25BD);
-                MP_WriteMcuAccessRegWord(sc, 0xF8A2, 0x9BE0);
-                MP_WriteMcuAccessRegWord(sc, 0xF8A4, 0x1C1C);
-                MP_WriteMcuAccessRegWord(sc, 0xF8A6, 0x484F);
-                MP_WriteMcuAccessRegWord(sc, 0xF8A8, 0x9CE2);
-                MP_WriteMcuAccessRegWord(sc, 0xF8AA, 0x72E2);
-                MP_WriteMcuAccessRegWord(sc, 0xF8AC, 0x49AE);
-                MP_WriteMcuAccessRegWord(sc, 0xF8AE, 0xF1FE);
-                MP_WriteMcuAccessRegWord(sc, 0xF8B0, 0x0B00);
-                MP_WriteMcuAccessRegWord(sc, 0xF8B2, 0xF116);
-                MP_WriteMcuAccessRegWord(sc, 0xF8B4, 0xC71C);
-                MP_WriteMcuAccessRegWord(sc, 0xF8B6, 0xC419);
-                MP_WriteMcuAccessRegWord(sc, 0xF8B8, 0x9CE0);
-                MP_WriteMcuAccessRegWord(sc, 0xF8BA, 0x1C13);
-                MP_WriteMcuAccessRegWord(sc, 0xF8BC, 0x484F);
-                MP_WriteMcuAccessRegWord(sc, 0xF8BE, 0x9CE2);
-                MP_WriteMcuAccessRegWord(sc, 0xF8C0, 0x74E2);
-                MP_WriteMcuAccessRegWord(sc, 0xF8C2, 0x49CE);
-                MP_WriteMcuAccessRegWord(sc, 0xF8C4, 0xF1FE);
-                MP_WriteMcuAccessRegWord(sc, 0xF8C6, 0xC412);
-                MP_WriteMcuAccessRegWord(sc, 0xF8C8, 0x9CE0);
-                MP_WriteMcuAccessRegWord(sc, 0xF8CA, 0x1C13);
-                MP_WriteMcuAccessRegWord(sc, 0xF8CC, 0x484F);
-                MP_WriteMcuAccessRegWord(sc, 0xF8CE, 0x9CE2);
-                MP_WriteMcuAccessRegWord(sc, 0xF8D0, 0x74E2);
-                MP_WriteMcuAccessRegWord(sc, 0xF8D2, 0x49CE);
-                MP_WriteMcuAccessRegWord(sc, 0xF8D4, 0xF1FE);
-                MP_WriteMcuAccessRegWord(sc, 0xF8D6, 0xC70C);
-                MP_WriteMcuAccessRegWord(sc, 0xF8D8, 0x74F8);
-                MP_WriteMcuAccessRegWord(sc, 0xF8DA, 0x48C3);
-                MP_WriteMcuAccessRegWord(sc, 0xF8DC, 0x8CF8);
-                MP_WriteMcuAccessRegWord(sc, 0xF8DE, 0xB004);
-                MP_WriteMcuAccessRegWord(sc, 0xF8E0, 0xB007);
-                MP_WriteMcuAccessRegWord(sc, 0xF8E2, 0xC502);
-                MP_WriteMcuAccessRegWord(sc, 0xF8E4, 0xBD00);
-                MP_WriteMcuAccessRegWord(sc, 0xF8E6, 0x0F24);
-                MP_WriteMcuAccessRegWord(sc, 0xF8E8, 0x0481);
-                MP_WriteMcuAccessRegWord(sc, 0xF8EA, 0x0C81);
-                MP_WriteMcuAccessRegWord(sc, 0xF8EC, 0xDE24);
-                MP_WriteMcuAccessRegWord(sc, 0xF8EE, 0xE000);
-                MP_WriteMcuAccessRegWord(sc, 0xF8F0, 0xC602);
-                MP_WriteMcuAccessRegWord(sc, 0xF8F2, 0xBE00);
-                MP_WriteMcuAccessRegWord(sc, 0xF8F4, 0x0CA4);
-                MP_WriteMcuAccessRegWord(sc, 0xF8F6, 0xC502);
-                MP_WriteMcuAccessRegWord(sc, 0xF8F8, 0xBD00);
-                MP_WriteMcuAccessRegWord(sc, 0xF8FA, 0x0000);
-                MP_WriteMcuAccessRegWord(sc, 0xF8FC, 0xC602);
-                MP_WriteMcuAccessRegWord(sc, 0xF8FE, 0xBE00);
-                MP_WriteMcuAccessRegWord(sc, 0xF900, 0x0000);
-
-                MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000);
-
-                MP_WriteMcuAccessRegWord(sc, 0xFC28, 0x00E2);
-                MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x0210);
-                MP_WriteMcuAccessRegWord(sc, 0xFC2C, 0x1A04);
-                MP_WriteMcuAccessRegWord(sc, 0xFC2E, 0x0B26);
-                MP_WriteMcuAccessRegWord(sc, 0xFC30, 0x0F02);
-                MP_WriteMcuAccessRegWord(sc, 0xFC32, 0x0CA0);
-
-                if (sc->re_device_id == RT_DEVICEID_8136)
-                        MP_WriteMcuAccessRegWord(sc, 0xFC38, 0x0033);
-                else
-                        MP_WriteMcuAccessRegWord(sc, 0xFC38, 0x003F);
-
                 break;
         }
 }
@@ -2245,20 +3042,19 @@ static void re_hw_mac_mcu_config(struct re_softc *sc)
 #define ISRIMR_DASH_TYPE2_TX_DISABLE_IDLE BIT_5
 static void Dash2DisableTx(struct re_softc *sc)
 {
-        //if (!re_check_dash(sc)) return;
+        //if (!sc->re_dash) return;
 
-        if (sc->re_type == MACFG_61 || sc->re_type == MACFG_62 ||
-            sc->re_type == MACFG_67) {
+        if (HW_DASH_SUPPORT_TYPE_2(sc) || HW_DASH_SUPPORT_TYPE_3(sc)) {
                 u_int16_t WaitCnt;
                 u_int8_t TmpUchar;
 
                 //Disable oob Tx
-                CSR_WRITE_1(sc, RE_IBCR2, CSR_READ_1(sc, RE_IBCR2) & ~(BIT_0));
+                RE_CMAC_WRITE_1(sc, RE_CMAC_IBCR2, RE_CMAC_READ_1(sc, RE_CMAC_IBCR2) & ~(BIT_0));
                 WaitCnt = 0;
 
                 //wait oob tx disable
                 do {
-                        TmpUchar = CSR_READ_1(sc, RE_IBISR0);
+                        TmpUchar = RE_CMAC_READ_1(sc, RE_CMAC_IBISR0);
 
                         if (TmpUchar & ISRIMR_DASH_TYPE2_TX_DISABLE_IDLE) {
                                 break;
@@ -2269,28 +3065,67 @@ static void Dash2DisableTx(struct re_softc *sc)
                 } while(WaitCnt < 2000);
 
                 //Clear ISRIMR_DASH_TYPE2_TX_DISABLE_IDLE
-                CSR_WRITE_1(sc, RE_IBISR0, CSR_READ_1(sc, RE_IBISR0) | ISRIMR_DASH_TYPE2_TX_DISABLE_IDLE);
+                RE_CMAC_WRITE_1(sc, RE_CMAC_IBISR0, RE_CMAC_READ_1(sc, RE_CMAC_IBISR0) | ISRIMR_DASH_TYPE2_TX_DISABLE_IDLE);
         }
 }
 
 static void Dash2DisableRx(struct re_softc *sc)
 {
-        //if (!re_check_dash(sc)) return;
+        //if (!sc->re_dash) return;
 
-        if (sc->re_type == MACFG_61 || sc->re_type == MACFG_62 ||
-            sc->re_type == MACFG_67)
-                CSR_WRITE_1(sc, RE_IBCR0, CSR_READ_1(sc, RE_IBCR0) & ~(BIT_0));
+        if (HW_DASH_SUPPORT_TYPE_2(sc) || HW_DASH_SUPPORT_TYPE_3(sc)) {
+                RE_CMAC_WRITE_1(sc, RE_CMAC_IBCR0, RE_CMAC_READ_1(sc, RE_CMAC_IBCR0) & ~(BIT_0));
+        }
 }
 
 static void Dash2DisableTxRx(struct re_softc *sc)
 {
-        if (sc->re_type == MACFG_61 || sc->re_type == MACFG_62 ||
-            sc->re_type == MACFG_67) {
+        if (HW_DASH_SUPPORT_TYPE_2(sc) || HW_DASH_SUPPORT_TYPE_3(sc)) {
                 Dash2DisableTx(sc);
                 Dash2DisableRx(sc);
         }
 }
 
+static inline bool
+is_zero_ether_addr(const u_int8_t * addr)
+{
+        return ((addr[0] + addr[1] + addr[2] + addr[3] + addr[4] + addr[5]) == 0x00);
+}
+
+static inline bool
+is_multicast_ether_addr(const u_int8_t * addr)
+{
+        return (0x01 & addr[0]);
+}
+
+/*
+static inline bool
+is_broadcast_ether_addr(const u_int8_t * addr)
+{
+        return ((addr[0] + addr[1] + addr[2] + addr[3] + addr[4] + addr[5]) == (6 * 0xff));
+}
+*/
+
+static inline bool
+is_valid_ether_addr(const u_int8_t * addr)
+{
+        return !is_multicast_ether_addr(addr) && !is_zero_ether_addr(addr);
+}
+
+static inline void
+random_ether_addr(u_int8_t * dst)
+{
+#ifndef __DragonFly__
+        if (read_random(dst, 6) == 0)
+                arc4rand(dst, 6, 0);
+#else
+	karc4rand(dst, 6);
+#endif
+
+        dst[0] &= 0xfe;
+        dst[0] |= 0x02;
+}
+
 static void re_disable_now_is_oob(struct re_softc *sc)
 {
         if (sc->re_hw_supp_now_is_oob_ver == 1)
@@ -2302,27 +3137,20 @@ static void re_exit_oob(struct re_softc *sc)
         u_int16_t data16;
         int i;
 
-        CSR_WRITE_1(sc, RE_EECMD, RE_EEMODE_OFF);
+        re_disable_cfg9346_write(sc);
 
         switch(sc->re_type) {
         case MACFG_61:
         case MACFG_62:
         case MACFG_67:
+        case MACFG_70:
+        case MACFG_71:
                 Dash2DisableTxRx(sc);
                 break;
         }
 
-        switch(sc->re_type) {
-        case MACFG_61:
-        case MACFG_62:
-        case MACFG_67:
-        case MACFG_63:
-        case MACFG_64:
-        case MACFG_65:
-        case MACFG_66:
+        if (sc->re_dash)
                 re_driver_start(sc);
-                break;
-        }
 
         switch(sc->re_type) {
         case MACFG_56:
@@ -2335,6 +3163,8 @@ static void re_exit_oob(struct re_softc *sc)
         case MACFG_67:
         case MACFG_68:
         case MACFG_69:
+        case MACFG_70:
+        case MACFG_71:
                 CSR_WRITE_1(sc, 0xF2, CSR_READ_1(sc, 0xF2) | BIT_3);
                 DELAY(2000);
 
@@ -2414,6 +3244,8 @@ static void re_exit_oob(struct re_softc *sc)
         case MACFG_67:
         case MACFG_68:
         case MACFG_69:
+        case MACFG_70:
+        case MACFG_71:
                 data16 = MP_ReadMcuAccessRegWord(sc, 0xE8DE) & ~BIT_14;
                 MP_WriteMcuAccessRegWord(sc, 0xE8DE, data16);
                 for (i = 0; i < 10; i++) {
@@ -2437,6 +3269,8 @@ static void re_exit_oob(struct re_softc *sc)
         switch(sc->re_type) {
         case MACFG_68:
         case MACFG_69:
+        case MACFG_70:
+        case MACFG_71:
                 if (re_is_ups_resume(sc)) {
                         re_wait_phy_ups_resume(sc, 2);
                         re_clear_ups_resume_bit(sc);
@@ -2525,11 +3359,14 @@ static void re_hw_init(struct re_softc *sc)
         case MACFG_67:
         case MACFG_68:
         case MACFG_69:
-                CSR_WRITE_1(sc, RE_EECMD, RE_EEMODE_WRITECFG);
+        case MACFG_70:
+        case MACFG_71:
+                re_enable_cfg9346_write(sc);
                 CSR_WRITE_1(sc, RE_CFG5, CSR_READ_1(sc, RE_CFG5) & ~BIT_0);
                 CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2) & ~BIT_7);
+                CSR_WRITE_1(sc, 0xF1, CSR_READ_1(sc, 0xF1) & ~ BIT_7);
                 CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2) | BIT_5);
-                CSR_WRITE_1(sc, RE_EECMD, RE_EEMODE_OFF);
+                re_disable_cfg9346_write(sc);
                 break;
         }
 
@@ -2542,12 +3379,49 @@ static void re_hw_init(struct re_softc *sc)
         }
 }
 
+static void re_rar_set(struct re_softc *sc, u_int8_t *eaddr)
+{
+        re_enable_cfg9346_write(sc);
+
+        CSR_WRITE_4(sc, RE_IDR0,
+                    htole32(*(u_int32_t *)(&eaddr[0])));
+        CSR_WRITE_2(sc, RE_IDR4,
+                    htole16(*(u_int32_t *)(&eaddr[4])));
+
+        switch (sc->re_type) {
+        case MACFG_36:
+        case MACFG_37:
+        case MACFG_42:
+        case MACFG_43:
+        case MACFG_54:
+        case MACFG_55:
+                CSR_WRITE_4(sc, RE_SecMAC0,
+                            htole32(*(u_int32_t *)(&eaddr[0])));
+                CSR_WRITE_2(sc, RE_SecMAC4,
+                            htole16(*(u_int16_t *)(&eaddr[4])));
+                break;
+        }
+
+        switch (sc->re_type) {
+        case MACFG_38:
+        case MACFG_39:
+                re_eri_write(sc, 0xF0, 4, *(u_int16_t *)(&eaddr[0])<<16, ERIAR_ExGMAC);
+                re_eri_write(sc, 0xF4, 4, *(u_int32_t *)(&eaddr[2]), ERIAR_ExGMAC);
+                break;
+        }
+
+        re_disable_cfg9346_write(sc);
+}
+
 static void re_get_hw_mac_address(struct re_softc *sc, u_int8_t *eaddr)
 {
+        device_t dev = sc->dev;
         u_int16_t re_eeid = 0;
-        u_int8_t read_from_macio = 0;
         int i;
 
+        for (i = 0; i < ETHER_ADDR_LEN; i++)
+                eaddr[i] = CSR_READ_1(sc, RE_IDR0 + i);
+
         switch(sc->re_type) {
         case MACFG_50:
         case MACFG_51:
@@ -2563,58 +3437,42 @@ static void re_get_hw_mac_address(struct re_softc *sc, u_int8_t *eaddr)
         case MACFG_67:
         case MACFG_68:
         case MACFG_69:
-                *(u_int32_t *)&eaddr[0]= re_eri_read(sc, 0xE0, 4, ERIAR_ExGMAC);
+        case MACFG_70:
+        case MACFG_71:
+                *(u_int32_t *)&eaddr[0] = re_eri_read(sc, 0xE0, 4, ERIAR_ExGMAC);
                 *(u_int16_t *)&eaddr[4] = (u_int16_t)re_eri_read(sc, 0xE4, 4, ERIAR_ExGMAC);
                 break;
         case MACFG_63:
         case MACFG_64:
         case MACFG_65:
         case MACFG_66:
-                read_from_macio = 1;
                 break;
         default:
                 re_read_eeprom(sc, (caddr_t)&re_eeid, RE_EE_ID, 1, 0);
                 if (re_eeid == 0x8129)
                         re_read_eeprom(sc, (caddr_t)&eaddr[0], RE_EE_EADDR, 3, 0);
-                else
-                        read_from_macio = 1;
                 break;
         }
 
-        if (eaddr[0] == 0x00 &&
-            eaddr[1] == 0x00 &&
-            eaddr[2] == 0x00 &&
-            eaddr[3] == 0x00 &&
-            eaddr[4] == 0x00 &&
-            eaddr[5] == 0x00) {
-                read_from_macio = 1;
-        }
-
-        if (eaddr[0] == 0xFF &&
-            eaddr[1] == 0xFF &&
-            eaddr[2] == 0xFF &&
-            eaddr[3] == 0xFF &&
-            eaddr[4] == 0xFF &&
-            eaddr[5] == 0xFF) {
-                read_from_macio = 1;
-        }
-
-        if (read_from_macio) {
-                for (i = 0; i < ETHER_ADDR_LEN; i++)
-                        eaddr[i] = CSR_READ_1(sc, RE_IDR0 + i);
+        if (!is_valid_ether_addr(eaddr)) {
+#ifndef __DragonFly__
+                device_printf(dev,"Invalid ether addr: %6D\n", eaddr, ":");
+#else
+		device_printf(dev, "Invalid ether addr: "
+		    "%02x:%02x:%02x:%02x:%02x:%02x\n",
+		    eaddr[0], eaddr[1], eaddr[2], eaddr[3], eaddr[4], eaddr[5]);
+#endif
+                random_ether_addr(eaddr);
+#ifndef __DragonFly__
+                device_printf(dev,"Random ether addr: %6D\n", eaddr, ":");
+#else
+		device_printf(dev, "Random ether addr: "
+		    "%02x:%02x:%02x:%02x:%02x:%02x\n",
+		    eaddr[0], eaddr[1], eaddr[2], eaddr[3], eaddr[4], eaddr[5]);
+#endif
         }
 
-        switch (sc->re_type) {
-        case MACFG_36:
-        case MACFG_37:
-        case MACFG_42:
-        case MACFG_43:
-        case MACFG_54:
-        case MACFG_55:
-                for (i = 0; i < ETHER_ADDR_LEN; i++)
-                        CSR_WRITE_1(sc, RE_SecMAC0 + i, eaddr[i]);
-                break;
-        }
+        re_rar_set(sc, eaddr);
 }
 
 static int re_check_mac_version(struct re_softc *sc)
@@ -2797,13 +3655,13 @@ static int re_check_mac_version(struct re_softc *sc)
         case 0x24000000:
                 sc->re_type = MACFG_41;
                 sc->max_jumbo_frame_size = ETHERMTU;
-                sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM ;
+                sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
                 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
                 break;
         case 0x40900000:
                 sc->re_type = MACFG_42;
                 sc->max_jumbo_frame_size = ETHERMTU;
-                sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM ;
+                sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
                 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
                 break;
         case 0x40A00000:
@@ -2811,7 +3669,7 @@ static int re_check_mac_version(struct re_softc *sc)
         case 0x40C00000:
                 sc->re_type = MACFG_43;
                 sc->max_jumbo_frame_size = ETHERMTU;
-                sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM ;
+                sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
                 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
                 break;
         case 0x48000000:
@@ -2934,6 +3792,18 @@ static int re_check_mac_version(struct re_softc *sc)
                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
                 CSR_WRITE_4(sc, RE_RXCFG, 0xCF00);
                 break;
+        case 0x54900000:
+                sc->re_type = MACFG_70;
+                sc->max_jumbo_frame_size = Jumbo_Frame_9k;
+                sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
+                CSR_WRITE_4(sc, RE_RXCFG, 0xCF00);
+                break;
+        case 0x54A00000:
+                sc->re_type = MACFG_71;
+                sc->max_jumbo_frame_size = Jumbo_Frame_9k;
+                sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
+                CSR_WRITE_4(sc, RE_RXCFG, 0xCF00);
+                break;
         default:
                 device_printf(dev,"unknown device\n");
                 sc->re_type = MACFG_FF;
@@ -2974,6 +3844,133 @@ static void re_init_software_variable(struct re_softc *sc)
         }
 
         switch(sc->re_type) {
+        case MACFG_63:
+        case MACFG_64:
+        case MACFG_65:
+        case MACFG_66:
+                sc->HwSuppDashVer = 1;
+                break;
+        case MACFG_61:
+        case MACFG_62:
+        case MACFG_67:
+                sc->HwSuppDashVer = 2;
+                break;
+        case MACFG_70:
+        case MACFG_71:
+                sc->HwSuppDashVer = 3;
+                break;
+        default:
+                sc->HwSuppDashVer = 0;
+                break;
+        }
+
+        switch(sc->re_type) {
+        case MACFG_70:
+        case MACFG_71:
+                sc->HwPkgDet = MP_ReadMcuAccessRegWord(sc, 0xDC00);
+                sc->HwPkgDet = (sc->HwPkgDet >> 3) & 0x0F;
+                //printf("Realtek PCIe GBE Family Controller HwPkgDet = 0x%02X\n",
+                //       sc->HwPkgDet);
+                break;
+        }
+
+        if (HW_DASH_SUPPORT_TYPE_3(sc) && sc->HwPkgDet == 0x06)
+                eee_enable = 0;
+
+        if (HW_DASH_SUPPORT_DASH(sc))
+                sc->re_dash = re_check_dash(sc);
+
+        if (sc->re_dash) {
+                if (HW_DASH_SUPPORT_TYPE_3(sc)) {
+                        u_int64_t CmacMemPhysAddress;
+                        bus_space_handle_t cmac_ioaddr;
+
+                        CmacMemPhysAddress = MP_ReadOtherFunPciEConfigSpace(sc, 0, 0xf018);
+                        if (!(CmacMemPhysAddress & BIT_0)) {
+                                if (CmacMemPhysAddress & BIT_2)
+                                        CmacMemPhysAddress |=  MP_ReadOtherFunPciEConfigSpace(sc, 0, 0xf01c) << 16;
+
+                                CmacMemPhysAddress &=  0xFFFFFFF0;
+                                /* ioremap MMIO region */
+#ifndef __DragonFly__
+                                sc->re_mapped_cmac_tag = X86_BUS_SPACE_MEM;
+#else
+				sc->re_mapped_cmac_tag = X86_64_BUS_SPACE_MEM;
+#endif
+                                if (bus_space_map(sc->re_mapped_cmac_tag, CmacMemPhysAddress, RE_REGS_SIZE, 0,
+                                                  &cmac_ioaddr))
+                                        sc->re_dash = 0;
+                                else
+                                        sc->re_mapped_cmac_handle = cmac_ioaddr;
+                        }
+                }
+        }
+
+        switch(sc->re_type) {
+        case MACFG_61:
+        case MACFG_62:
+        case MACFG_67:
+                sc->re_cmac_handle = sc->re_bhandle;
+                sc->re_cmac_tag = sc->re_btag;
+                break;
+        case MACFG_70:
+        case MACFG_71:
+                sc->re_cmac_handle = sc->re_mapped_cmac_handle;
+                sc->re_cmac_tag = sc->re_mapped_cmac_tag;
+                break;
+        }
+
+        switch(sc->re_type) {
+        case MACFG_14:
+        case MACFG_15:
+        case MACFG_16:
+        case MACFG_17:
+        case MACFG_18:
+        case MACFG_19:
+        case MACFG_31:
+        case MACFG_32:
+        case MACFG_33:
+        case MACFG_41:
+        case MACFG_63:
+        case MACFG_64:
+        case MACFG_65:
+        case MACFG_66:
+                sc->re_efuse_ver = EFUSE_SUPPORT_V1;
+                break;
+        case MACFG_36:
+        case MACFG_37:
+        case MACFG_42:
+        case MACFG_43:
+        case MACFG_54:
+        case MACFG_55:
+                sc->re_efuse_ver = EFUSE_SUPPORT_V2;
+                break;
+        case MACFG_38:
+        case MACFG_39:
+        case MACFG_50:
+        case MACFG_51:
+        case MACFG_52:
+        case MACFG_53:
+        case MACFG_56:
+        case MACFG_57:
+        case MACFG_58:
+        case MACFG_59:
+        case MACFG_60:
+        case MACFG_61:
+        case MACFG_62:
+        case MACFG_67:
+        case MACFG_68:
+        case MACFG_69:
+        case MACFG_70:
+        case MACFG_71:
+                sc->re_efuse_ver = EFUSE_SUPPORT_V3;
+                break;
+        default:
+                sc->re_efuse_ver = EFUSE_NOT_SUPPORT;
+                break;
+        }
+
+        switch(sc->re_type) {
         case MACFG_69: {
                 u_int16_t ioffset_p3, ioffset_p2, ioffset_p1, ioffset_p0;
                 u_int16_t TmpUshort;
@@ -3006,7 +4003,9 @@ static void re_init_software_variable(struct re_softc *sc)
 
         switch(sc->re_type) {
         case MACFG_68:
-        case MACFG_69: {
+        case MACFG_69:
+        case MACFG_70:
+        case MACFG_71: {
                 u_int16_t rg_saw_cnt;
 
                 MP_WritePhyUshort(sc, 0x1F, 0x0C42);
@@ -3054,6 +4053,8 @@ static void re_init_software_variable(struct re_softc *sc)
         case MACFG_67:
         case MACFG_68:
         case MACFG_69:
+        case MACFG_70:
+        case MACFG_71:
                 sc->re_hw_enable_msi_msix = TRUE;
                 break;
         }
@@ -3106,12 +4107,56 @@ static void re_init_software_variable(struct re_softc *sc)
         case MACFG_67:
         case MACFG_68:
         case MACFG_69:
+        case MACFG_70:
+        case MACFG_71:
                 sc->re_hw_supp_now_is_oob_ver = 1;
                 break;
         }
 
-        sc->re_8169_MacVersion=(CSR_READ_4(sc, RE_TXCFG)&0x7c800000)>>25;		/* Get bit 26~30 	*/
-        sc->re_8169_MacVersion|=((CSR_READ_4(sc, RE_TXCFG)&0x00800000)!=0 ? 1:0);	/* Get bit 23 		*/
+        switch (sc->re_type) {
+        case MACFG_36:
+        case MACFG_37:
+                sc->re_sw_ram_code_ver = NIC_RAMCODE_VERSION_8168E;
+                break;
+        case MACFG_38:
+        case MACFG_39:
+                sc->re_sw_ram_code_ver = NIC_RAMCODE_VERSION_8168EVL;
+                break;
+        case MACFG_50:
+        case MACFG_51:
+                sc->re_sw_ram_code_ver = NIC_RAMCODE_VERSION_8168F;
+                break;
+        case MACFG_52:
+                sc->re_sw_ram_code_ver = NIC_RAMCODE_VERSION_8411;
+                break;
+        case MACFG_56:
+        case MACFG_57:
+                sc->re_sw_ram_code_ver = NIC_RAMCODE_VERSION_8168G;
+                break;
+        case MACFG_58:
+        case MACFG_59:
+                sc->re_sw_ram_code_ver = NIC_RAMCODE_VERSION_8168GU;
+                break;
+        case MACFG_60:
+                sc->re_sw_ram_code_ver = NIC_RAMCODE_VERSION_8411B;
+                break;
+        case MACFG_61:
+        case MACFG_62:
+        case MACFG_67:
+                sc->re_sw_ram_code_ver = NIC_RAMCODE_VERSION_8168EP;
+                break;
+        case MACFG_68:
+        case MACFG_69:
+                sc->re_sw_ram_code_ver = NIC_RAMCODE_VERSION_8168H;
+                break;
+        case MACFG_70:
+        case MACFG_71:
+                sc->re_sw_ram_code_ver = NIC_RAMCODE_VERSION_8168FP;
+                break;
+        }
+
+        sc->re_8169_MacVersion=(CSR_READ_4(sc, RE_TXCFG)&0x7c800000)>>25;		/* Get bit 26~30 	*/
+        sc->re_8169_MacVersion|=((CSR_READ_4(sc, RE_TXCFG)&0x00800000)!=0 ? 1:0);	/* Get bit 23 		*/
         DBGPRINT1(sc->re_unit,"8169 Mac Version %d",sc->re_8169_MacVersion);
 
         /* Rtl8169s single chip detected */
@@ -3131,7 +4176,8 @@ static void re_hw_d3_para(struct re_softc *sc)
 {
         if (sc->re_type == MACFG_59 || sc->re_type == MACFG_60 ||
             sc->re_type == MACFG_62 || sc->re_type == MACFG_67 ||
-            sc->re_type == MACFG_68 || sc->re_type == MACFG_69) {
+            sc->re_type == MACFG_68 || sc->re_type == MACFG_69 ||
+            sc->re_type == MACFG_70 || sc->re_type == MACFG_71) {
                 MP_WritePhyOcpRegWord(sc, 0x0C41, 0x13, 0x0000);
                 MP_WritePhyOcpRegWord(sc, 0x0C41, 0x13, 0x0500);
         }
@@ -3346,12 +4392,14 @@ static int re_attach(device_t dev)
         RE_UNLOCK(sc);
 
         /* Get station address. */
+        RE_LOCK(sc);
         re_get_hw_mac_address(sc, eaddr);
+        RE_UNLOCK(sc);
 
         /*
          * A RealTek chip was detected. Inform the world.
          */
-        device_printf(dev,"version:1.93\n");
+        device_printf(dev,"version:1.94.01\n");
         device_printf(dev,"Ethernet address: %6D\n", eaddr, ":");
         printf("\nThis product is covered by one or more of the following patents: \
            \nUS6,570,884, US6,115,776, and US6,327,625.\n");
@@ -3643,6 +4691,9 @@ static int re_detach(device_t dev)
         if (sc->re_res)
                 bus_release_resource(dev, sc->re_res_type, sc->re_res_id, sc->re_res);
 
+        if (HW_DASH_SUPPORT_TYPE_3(sc) && sc->re_dash)
+                bus_space_unmap(sc->re_cmac_tag, sc->re_mapped_cmac_handle, RE_REGS_SIZE);
+
         if (sc->re_desc.re_rx_mtag) {
                 for (i = 0; i < RE_RX_BUF_NUM; i++) {
                         if (sc->re_desc.rx_buf[i]!=NULL) {
@@ -3850,17 +4901,8 @@ device_t		dev;
 
         sc = device_get_softc(dev);
 
-        switch(sc->re_type) {
-        case MACFG_61:
-        case MACFG_62:
-        case MACFG_67:
-        case MACFG_63:
-        case MACFG_64:
-        case MACFG_65:
-        case MACFG_66:
+        if (sc->re_dash)
                 re_driver_stop(sc);
-                break;
-        }
 
         RE_LOCK(sc);
         sc->re_link_chg_det = 0;
@@ -3891,7 +4933,38 @@ static void re_hw_start_unlock(struct re_softc *sc)
         re_var_init(sc);
 #endif
 
-        CSR_WRITE_1(sc, RE_EECMD, RE_EEMODE_WRITECFG);
+        re_enable_cfg9346_write(sc);
+
+        switch(sc->re_type) {
+        case MACFG_36:
+        case MACFG_37:
+        case MACFG_38:
+        case MACFG_39:
+        case MACFG_42:
+        case MACFG_43:
+        case MACFG_50:
+        case MACFG_51:
+        case MACFG_52:
+        case MACFG_53:
+        case MACFG_54:
+        case MACFG_55:
+        case MACFG_56:
+        case MACFG_57:
+        case MACFG_58:
+        case MACFG_59:
+        case MACFG_60:
+        case MACFG_61:
+        case MACFG_62:
+        case MACFG_67:
+        case MACFG_68:
+        case MACFG_69:
+        case MACFG_70:
+        case MACFG_71:
+                CSR_WRITE_1(sc, RE_CFG5, CSR_READ_1(sc, RE_CFG5) & ~BIT_0);
+                CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2) & ~BIT_7);
+                CSR_WRITE_1(sc, 0xF1, CSR_READ_1(sc, 0xF1) & ~ BIT_7);
+                break;
+        }
 
         /*disable Link Down Power Saving(non-LDPS)*/
         /*CSR_WRITE_1(sc, RE_LDPS, 0x05);*/
@@ -4001,6 +5074,9 @@ static void re_hw_start_unlock(struct re_softc *sc)
                         MP_WriteEPhyUshort(sc, 0x06, 0xAF35);
                 }
         } else if (macver == 0x3C000000) {
+                //disable clock request.
+                pci_write_config(sc->dev, 0x81, 0, 1);
+
                 /*set configuration space offset 0x70f to 0x27*/
                 Data32 = MP_ReadPciEConfigSpace(sc, 0x870c);
                 Data32 &=0xC0FFFFFF;
@@ -4025,9 +5101,6 @@ static void re_hw_start_unlock(struct re_softc *sc)
                         data16 = MP_ReadEPhyUshort(sc, 0x06) & ~0x0080;
                         MP_WriteEPhyUshort(sc, 0x06, data16);
 
-                        //disable clock request.
-                        pci_write_config(sc->dev, 0x81, 0, 1);
-
                         if (ifp->if_mtu > ETHERMTU) {
                                 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) | BIT_2); //Jumbo_en0
                                 CSR_WRITE_1(sc, RE_CFG4, CSR_READ_1(sc, RE_CFG4) | (1 << 1)); //Jumbo_en1
@@ -4059,8 +5132,6 @@ static void re_hw_start_unlock(struct re_softc *sc)
                                         CSR_WRITE_2 (sc, RE_CPlusCmd,CSR_READ_2(sc, RE_CPlusCmd) |RL_RxChkSum);
                                 }
                         }
-
-
                 } else if (sc->re_type == MACFG_25) {
                         data16 = MP_ReadEPhyUshort(sc, 0x01) | 0x0001;
                         MP_WriteEPhyUshort(sc, 0x01, data16);
@@ -4069,9 +5140,6 @@ static void re_hw_start_unlock(struct re_softc *sc)
                         data16 |= 0x0220;
                         MP_WriteEPhyUshort(sc, 0x03, data16);
 
-                        //disable clock request.
-                        pci_write_config(sc->dev, 0x81, 0, 1);
-
                         if (ifp->if_mtu > ETHERMTU) {
                                 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) | BIT_2); //Jumbo_en0
                                 CSR_WRITE_1(sc, RE_CFG4, CSR_READ_1(sc, RE_CFG4) | (1<<1)); //Jumbo_en1
@@ -4105,11 +5173,7 @@ static void re_hw_start_unlock(struct re_softc *sc)
 
 
                         }
-
                 } else if (sc->re_type == MACFG_26) {
-                        //disable clock request.
-                        pci_write_config(sc->dev, 0x81, 0, 1);
-
                         if (ifp->if_mtu > ETHERMTU) {
                                 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) | BIT_2); //Jumbo_en0
                                 CSR_WRITE_1(sc, RE_CFG4, CSR_READ_1(sc, RE_CFG4) | (1<<1)); //Jumbo_en1
@@ -4142,6 +5206,9 @@ static void re_hw_start_unlock(struct re_softc *sc)
                         }
                 }
         } else if (macver == 0x3C800000) {
+                //disable clock request.
+                pci_write_config(sc->dev, 0x81, 0x00, 1);
+
                 /*set configuration space offset 0x70f to 0x27*/
                 Data32 = MP_ReadPciEConfigSpace(sc, 0x870c);
                 Data32 &=0xC0FFFFFF;
@@ -4150,9 +5217,6 @@ static void re_hw_start_unlock(struct re_softc *sc)
 
                 re_eri_write(sc, 0x1EC, 1, 0x07, ERIAR_ASF);
 
-                //disable clock request.
-                pci_write_config(sc->dev, 0x81, 0x00, 1);
-
                 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0);
                 CSR_WRITE_2 (sc, RE_CPlusCmd, 0x2060);
                 if (sc->re_type == MACFG_28)
@@ -4185,17 +5249,17 @@ static void re_hw_start_unlock(struct re_softc *sc)
                                 CSR_WRITE_2 (sc, RE_CPlusCmd,CSR_READ_2(sc, RE_CPlusCmd) |RL_RxChkSum);
                         }
                 }
-
-
         } else if (macver == 0x28000000) {
+                //disable clock request.
+                pci_write_config(sc->dev, 0x81, 0x00, 1);
+
                 /*set configuration space offset 0x70f to 0x13*/
                 Data32 = MP_ReadPciEConfigSpace(sc, 0x870c);
                 Data32 &=0xC0FFFFFF;
-                Data32 |= (0x13 << 24);
+                Data32 |= (0x27 << 24);
                 MP_WritePciEConfigSpace(sc, 0x870c, Data32);
 
-                /* disable clock request. */
-                pci_write_config(sc->dev, 0x81, 0x00, 1);
+                CSR_WRITE_1(sc, RE_TDFNR, 0x8);
 
                 CSR_WRITE_1(sc, 0xD1, CSR_READ_1(sc, 0xD1) | 0x02);
 
@@ -4263,14 +5327,19 @@ static void re_hw_start_unlock(struct re_softc *sc)
                         MP_WriteEPhyUshort(sc, 0x0A, 0x8100);
                 }
         } else if (macver == 0x28800000) {
+                /* disable clock request. */
+                pci_write_config(sc->dev, 0x81, 0x00, 1);
+
                 /*set configuration space offset 0x70f to 0x17*/
                 Data32 = MP_ReadPciEConfigSpace(sc, 0x870c);
                 Data32 &=0xC0FFFFFF;
-                Data32 |= (0x17 << 24);
+                Data32 |= (0x27 << 24);
                 MP_WritePciEConfigSpace(sc, 0x870c, Data32);
 
-                /* disable clock request. */
-                pci_write_config(sc->dev, 0x81, 0x00, 1);
+                CSR_WRITE_1(sc, RE_TDFNR, 0x8);
+                if (sc->re_dash &&
+                    (sc->re_type == MACFG_63 || sc->re_type == MACFG_64))
+                        CSR_WRITE_1(sc, RE_TDFNR, 0x1);
 
                 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0);
                 CSR_WRITE_1(sc, RE_DBG_reg, CSR_READ_1(sc, RE_DBG_reg)|0x82);
@@ -4324,21 +5393,25 @@ static void re_hw_start_unlock(struct re_softc *sc)
                         ClearPCIePhyBit(sc, 0x10, (BIT_2));
                 }
         } else if (macver == 0x2C000000) {
+                /* disable clock request. */
+                pci_write_config(sc->dev, 0x81, 0x00, 1);
+
                 /*set configuration space offset 0x70f to 0x20*/
                 Data32 = MP_ReadPciEConfigSpace(sc, 0x870c);
                 Data32 &=0xC0FFFFFF;
-                Data32 |= (0x20 << 24);
+                Data32 |= (0x27 << 24);
                 MP_WritePciEConfigSpace(sc, 0x870c, Data32);
 
                 CSR_WRITE_1(sc, 0xF3, CSR_READ_1(sc, 0xF3)|0x20);
                 CSR_WRITE_1(sc, 0xF3, CSR_READ_1(sc, 0xF3)& ~0x20);
 
                 CSR_WRITE_1(sc, 0xD0, CSR_READ_1(sc, 0xD0)|0xC0);
-                CSR_WRITE_1(sc, 0xF1, CSR_READ_1(sc, 0xF1)|0xF3);
-                CSR_WRITE_1(sc, RE_CFG5, (CSR_READ_1(sc, RE_CFG5)& ~0x08)|0x01);
-                CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2)|0x80);
+                CSR_WRITE_1(sc, 0xF1, CSR_READ_1(sc, 0xF1)|0x73);
+                CSR_WRITE_1(sc, RE_CFG5, (CSR_READ_1(sc, RE_CFG5)& ~0x08));
                 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0);
 
+                CSR_WRITE_1(sc, RE_TDFNR, 0x8);
+
                 if (sc->re_type == MACFG_36 || sc->re_type == MACFG_37) {
                         /* set EPHY registers */
                         data16 = MP_ReadEPhyUshort(sc, 0x00) & ~0x0200;
@@ -4420,11 +5493,11 @@ static void re_hw_start_unlock(struct re_softc *sc)
                                         CSR_WRITE_2 (sc, RE_CPlusCmd,CSR_READ_2(sc, RE_CPlusCmd) |RL_RxChkSum);
                                 }
                         }
-
-                        //disable clock request.
-                        pci_write_config(sc->dev, 0x81, 1, 1);
                 }
         } else if (macver == 0x2C800000) {
+                /* disable clock request. */
+                pci_write_config(sc->dev, 0x81, 0x00, 1);
+
                 /*set configuration space offset 0x70f to 0x27*/
                 Data32 = MP_ReadPciEConfigSpace(sc, 0x870c);
                 Data32 &=0xC0FFFFFF;
@@ -4436,14 +5509,7 @@ static void re_hw_start_unlock(struct re_softc *sc)
                 data8 |= 0x50;
                 pci_write_config(sc->dev, 0x79, data8, 1);
 
-                Data32 = CSR_READ_2(sc, RE_IDR0);
-                Data32 <<= 16;
-                Data32 &= 0xFFFF0000;
-                re_eri_write(sc, 0xF0, 4, Data32, ERIAR_ExGMAC);
-                Data32 = CSR_READ_2(sc, RE_IDR4);
-                Data32 <<= 16;
-                Data32 += CSR_READ_2(sc, RE_IDR2);
-                re_eri_write(sc, 0xF4, 4, Data32, ERIAR_ExGMAC);
+                CSR_WRITE_1(sc, RE_TDFNR, 0x8);
 
                 re_eri_write(sc, 0xC0, 2, 0x0000, ERIAR_ExGMAC);
                 re_eri_write(sc, 0xB8, 4, 0x00000000, ERIAR_ExGMAC);
@@ -4469,7 +5535,6 @@ static void re_hw_start_unlock(struct re_softc *sc)
                 CSR_WRITE_4(sc, RE_TXCFG, CSR_READ_4(sc, RE_TXCFG) |BIT_7);
                 CSR_WRITE_1(sc, 0xD3, CSR_READ_1(sc, 0xD3) & ~BIT_7);
                 CSR_WRITE_1(sc, 0x1B, CSR_READ_1(sc, 0x1B) & ~0x07);
-                CSR_WRITE_1(sc, 0xF1,CSR_READ_1(sc, 0xF1) & ~ BIT_7);
 
                 CSR_WRITE_2 (sc, RE_CPlusCmd, 0x2060);
 
@@ -4503,19 +5568,15 @@ static void re_hw_start_unlock(struct re_softc *sc)
                                       BIT_9
                                      );
 
-                CSR_WRITE_1(sc, RE_CFG5, CSR_READ_1(sc, RE_CFG5) | BIT_0);
-                CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2) | BIT_5 |BIT_7);
+                CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2) | BIT_5);
                 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0);
 
                 CSR_WRITE_1(sc, 0xD0, CSR_READ_1(sc, 0xD0) | BIT_6);
                 CSR_WRITE_1(sc, 0xF2, CSR_READ_1(sc, 0xF2) | BIT_6);
 
                 CSR_WRITE_1 (sc, RE_MTPS, 0x27);
-                ifp->if_capenable &= ~IFCAP_HWCSUM ;
+                ifp->if_capenable &= ~IFCAP_HWCSUM;
                 ifp->if_hwassist &= ~RE_CSUM_FEATURES;
-
-                /* disable clock request. */
-                pci_write_config(sc->dev, 0x81, 0x00, 1);
         } else if (macver == 0x24000000) {
                 if (pci_read_config(sc->dev, 0x81, 1)==1) {
                         CSR_WRITE_1(sc, RE_DBG_reg, 0x98);
@@ -4541,12 +5602,7 @@ static void re_hw_start_unlock(struct re_softc *sc)
                 MP_WriteEPhyUshort(sc, 0x06, 0xAF25);
                 MP_WriteEPhyUshort(sc, 0x07, 0x8E68);
         } else if (macver == 0x40800000) {
-                if (pci_read_config(sc->dev, 0x80, 1) & 0x03) {
-                        CSR_WRITE_1(sc, RE_CFG5, CSR_READ_1(sc, RE_CFG5) | 1);
-                        CSR_WRITE_1(sc, 0xF1, CSR_READ_1(sc, 0xF1) | 0x80);
-                        CSR_WRITE_1(sc, 0xF2, CSR_READ_1(sc, 0xF2) | 0x80);
-                        CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2) | 0x80);
-                }
+                CSR_WRITE_1(sc, 0xF2, CSR_READ_1(sc, 0xF2) | 0x80);
                 CSR_WRITE_1(sc, 0xF1, CSR_READ_1(sc, 0xF1) | 0x28);
                 CSR_WRITE_1(sc, 0xD3, CSR_READ_1(sc, 0xD3) | 0x0C);
                 CSR_WRITE_1(sc, 0xD3, CSR_READ_1(sc, 0xD3) & ~BIT_7);
@@ -4609,6 +5665,8 @@ static void re_hw_start_unlock(struct re_softc *sc)
                 data8 |= 0x50;
                 pci_write_config(sc->dev, 0x79, data8, 1);
 
+                CSR_WRITE_1(sc, RE_TDFNR, 0x8);
+
                 Data32 = re_eri_read(sc, 0xD4, 4, ERIAR_ExGMAC);
                 Data32 |= BIT_11 | BIT_10;
                 re_eri_write(sc, 0xD4, 4, Data32, ERIAR_ExGMAC);
@@ -4663,8 +5721,6 @@ static void re_hw_start_unlock(struct re_softc *sc)
                                       BIT_9
                                      );
 
-                CSR_WRITE_1(sc, RE_CFG5, CSR_READ_1(sc, RE_CFG5) | BIT_0);
-                CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2) | BIT_7);
                 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0);
 
                 CSR_WRITE_1(sc, 0xD0, CSR_READ_1(sc, 0xD0) | BIT_6);
@@ -4673,7 +5729,7 @@ static void re_hw_start_unlock(struct re_softc *sc)
                 CSR_WRITE_1 (sc, RE_MTPS, 0x27);
 
                 if (ifp->if_mtu > ETHERMTU) {
-                        ifp->if_capenable &= ~IFCAP_HWCSUM ;
+                        ifp->if_capenable &= ~IFCAP_HWCSUM;
                         ifp->if_hwassist &= ~RE_CSUM_FEATURES;
                 } else {
                         if (sc->re_tx_cstag) {
@@ -4684,9 +5740,6 @@ static void re_hw_start_unlock(struct re_softc *sc)
                                 ifp->if_capenable |= IFCAP_RXCSUM;
                         }
                 }
-
-                /* disable clock request. */
-                pci_write_config(sc->dev, 0x81, 0x00, 1);
         } else if (macver == 0x48800000) {
                 /*set configuration space offset 0x70f to 0x27*/
                 Data32 = MP_ReadPciEConfigSpace(sc, 0x870c);
@@ -4699,6 +5752,8 @@ static void re_hw_start_unlock(struct re_softc *sc)
                 data8 |= 0x50;
                 pci_write_config(sc->dev, 0x79, data8, 1);
 
+                CSR_WRITE_1(sc, RE_TDFNR, 0x8);
+
                 Data32 = re_eri_read(sc, 0xD4, 4, ERIAR_ExGMAC);
                 Data32 |= BIT_11 | BIT_10;
                 re_eri_write(sc, 0xD4, 4, Data32, ERIAR_ExGMAC);
@@ -4748,8 +5803,6 @@ static void re_hw_start_unlock(struct re_softc *sc)
                                       BIT_9
                                      );
 
-                CSR_WRITE_1(sc, RE_CFG5, CSR_READ_1(sc, RE_CFG5) | BIT_0);
-                CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2) | BIT_7);
                 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0);
 
                 CSR_WRITE_1(sc, 0xD0, CSR_READ_1(sc, 0xD0) | BIT_6);
@@ -4758,7 +5811,7 @@ static void re_hw_start_unlock(struct re_softc *sc)
                 CSR_WRITE_1 (sc, RE_MTPS, 0x27);
 
                 if (ifp->if_mtu > ETHERMTU) {
-                        ifp->if_capenable &= ~IFCAP_HWCSUM ;
+                        ifp->if_capenable &= ~IFCAP_HWCSUM;
                         ifp->if_hwassist &= ~RE_CSUM_FEATURES;
                 } else {
                         if (sc->re_tx_cstag) {
@@ -4769,16 +5822,8 @@ static void re_hw_start_unlock(struct re_softc *sc)
                                 ifp->if_capenable |= IFCAP_RXCSUM;
                         }
                 }
-
-                /* disable clock request. */
-                pci_write_config(sc->dev, 0x81, 0x00, 1);
         } else if (macver == 0x44800000) {
-                if (pci_read_config(sc->dev, 0x80, 1) & 0x03) {
-                        CSR_WRITE_1(sc, RE_CFG5, CSR_READ_1(sc, RE_CFG5) | 1);
-                        CSR_WRITE_1(sc, 0xF1, CSR_READ_1(sc, 0xF1) | 0x80);
-                        CSR_WRITE_1(sc, 0xF2, CSR_READ_1(sc, 0xF2) | 0x80);
-                        CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2) | 0x80);
-                }
+                CSR_WRITE_1(sc, 0xF2, CSR_READ_1(sc, 0xF2) | 0x80);
                 CSR_WRITE_1(sc, 0xF1, CSR_READ_1(sc, 0xF1) | 0x28);
                 CSR_WRITE_1(sc, 0xD3, CSR_READ_1(sc, 0xD3) | 0x0C);
                 CSR_WRITE_1(sc, 0xD3, CSR_READ_1(sc, 0xD3) & ~BIT_7);
@@ -4788,8 +5833,6 @@ static void re_hw_start_unlock(struct re_softc *sc)
                 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0);
         } else if (macver == 0x4C000000 || macver == 0x50800000 ||
                    macver == 0x5C800000 || macver == 0x54000000) {
-                CSR_WRITE_1(sc, RE_CFG5, CSR_READ_1(sc, RE_CFG5) & ~BIT_0);
-                CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2) & ~BIT_7);
                 CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2) | BIT_5);
 
                 if (sc->re_type == MACFG_59) {
@@ -4816,7 +5859,7 @@ static void re_hw_start_unlock(struct re_softc *sc)
                 /*set configuration space offset 0x70f to 0x17*/
                 Data32 = MP_ReadPciEConfigSpace(sc, 0x870c);
                 Data32 &=0xC0FFFFFF;
-                Data32 |= (0x17 << 24);
+                Data32 |= (0x27 << 24);
                 MP_WritePciEConfigSpace(sc, 0x870c, Data32);
 
                 data8 = pci_read_config(sc->dev, 0x79, 1);
@@ -4824,6 +5867,8 @@ static void re_hw_start_unlock(struct re_softc *sc)
                 data8 |= 0x50;
                 pci_write_config(sc->dev, 0x79, data8, 1);
 
+                CSR_WRITE_1(sc, RE_TDFNR, 0x4);
+
                 if (sc->re_type == MACFG_56 || sc->re_type == MACFG_57) {
                         Data32 = MP_ReadPciEConfigSpace(sc, 0x2710);
                         Data32 &=0xFFFF0FFF;
@@ -4850,6 +5895,9 @@ static void re_hw_start_unlock(struct re_softc *sc)
                 re_eri_write(sc, 0xD0, 1, 0x48, ERIAR_ExGMAC);
                 re_eri_write(sc, 0xE8, 4, 0x00100006, ERIAR_ExGMAC);
 
+                if (sc->re_type == MACFG_68 || sc->re_type == MACFG_69)
+                        MP_WriteMcuAccessRegWord(sc, 0xE054, 0xFC01);
+
                 re_eri_write(sc, 0x5F0, 4, 0x4F87, ERIAR_ExGMAC);
 
                 Data32 = re_eri_read(sc, 0xdc, 4, ERIAR_ExGMAC);
@@ -4905,6 +5953,9 @@ static void re_hw_start_unlock(struct re_softc *sc)
                         MP_WriteEPhyUshort(sc, 0x00, 0x10A3);
 
                         MP_WriteEPhyUshort(sc, 0x06, 0xF050);
+
+                        SetPCIePhyBit(sc, 0x04, BIT_4);
+                        ClearPCIePhyBit(sc, 0x1D, BIT_14);
                 } else if (sc->re_type == MACFG_60) {
                         ClearPCIePhyBit(sc, 0x00, BIT_3);
                         ClearAndSetPCIePhyBit(sc,
@@ -4923,6 +5974,9 @@ static void re_hw_start_unlock(struct re_softc *sc)
                         SetPCIePhyBit(sc, 0x00, BIT_7);
 
                         SetPCIePhyBit(sc, 0x06, BIT_4);
+
+                        SetPCIePhyBit(sc, 0x04, BIT_4);
+                        SetPCIePhyBit(sc, 0x1D, BIT_14);
                 } else if (sc->re_type == MACFG_68 || sc->re_type == MACFG_69) {
                         ClearPCIePhyBit(sc, 0x1E, BIT_11);
 
@@ -4932,7 +5986,7 @@ static void re_hw_start_unlock(struct re_softc *sc)
                         MP_WriteEPhyUshort(sc, 0x05, 0x2089);
                         MP_WriteEPhyUshort(sc, 0x06, 0x5881);
 
-                        MP_WriteEPhyUshort(sc, 0x04, 0x154A);
+                        MP_WriteEPhyUshort(sc, 0x04, 0x854A);
                         MP_WriteEPhyUshort(sc, 0x01, 0x068B);
                 }
 
@@ -4953,7 +6007,7 @@ static void re_hw_start_unlock(struct re_softc *sc)
                         if (sc->RequireAdjustUpsTxLinkPulseTiming) {
                                 data16 = MP_ReadMcuAccessRegWord(sc, 0xD412);
                                 data16 &= ~(0x0FFF);
-                                data16 |= sc->SwrCnt1msIni ;
+                                data16 |= sc->SwrCnt1msIni;
                                 MP_WriteMcuAccessRegWord(sc, 0xD412, data16);
                         }
 
@@ -4979,9 +6033,6 @@ static void re_hw_start_unlock(struct re_softc *sc)
                         MP_WriteMcuAccessRegWord(sc, 0xE0D6, data16);
                 }
 
-
-                CSR_WRITE_1(sc, RE_CFG5, CSR_READ_1(sc, RE_CFG5) | BIT_0);
-                CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2) | BIT_7);
                 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0);
 
                 CSR_WRITE_1(sc, 0xD0, CSR_READ_1(sc, 0xD0) | BIT_6);
@@ -5000,7 +6051,7 @@ static void re_hw_start_unlock(struct re_softc *sc)
                 }
 
                 if (ifp->if_mtu > ETHERMTU) {
-                        ifp->if_capenable &= ~IFCAP_HWCSUM ;
+                        ifp->if_capenable &= ~IFCAP_HWCSUM;
                         ifp->if_hwassist &= ~RE_CSUM_FEATURES;
                 } else {
                         if (sc->re_tx_cstag) {
@@ -5011,18 +6062,11 @@ static void re_hw_start_unlock(struct re_softc *sc)
                                 ifp->if_capenable |= IFCAP_RXCSUM;
                         }
                 }
-
-                /* disable clock request. */
-                pci_write_config(sc->dev, 0x81, 0x00, 1);
         } else if (macver == 0x50000000) {
-
-                CSR_WRITE_1(sc, RE_CFG5, CSR_READ_1(sc, RE_CFG5) & ~BIT_0);
-                CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2) & ~BIT_7);
-
                 /*set configuration space offset 0x70f to 0x17*/
                 Data32 = MP_ReadPciEConfigSpace(sc, 0x870c);
                 Data32 &=0xC0FFFFFF;
-                Data32 |= (0x17 << 24);
+                Data32 |= (0x27 << 24);
                 MP_WritePciEConfigSpace(sc, 0x870c, Data32);
 
                 data8 = pci_read_config(sc->dev, 0x79, 1);
@@ -5087,9 +6131,6 @@ static void re_hw_start_unlock(struct re_softc *sc)
                         SetPCIePhyBit(sc, 0x1E, BIT_13);
                 }
 
-
-                CSR_WRITE_1(sc, RE_CFG5, CSR_READ_1(sc, RE_CFG5) | BIT_0);
-                CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2) | BIT_7);
                 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0);
 
                 CSR_WRITE_1(sc, 0xD0, CSR_READ_1(sc, 0xD0) | BIT_6);
@@ -5118,7 +6159,7 @@ static void re_hw_start_unlock(struct re_softc *sc)
                 MP_WriteMcuAccessRegWord(sc, 0xC142, 0xFFFF);
 
                 if (ifp->if_mtu > ETHERMTU) {
-                        ifp->if_capenable &= ~IFCAP_HWCSUM ;
+                        ifp->if_capenable &= ~IFCAP_HWCSUM;
                         ifp->if_hwassist &= ~RE_CSUM_FEATURES;
                 } else {
                         if (sc->re_tx_cstag) {
@@ -5129,9 +6170,143 @@ static void re_hw_start_unlock(struct re_softc *sc)
                                 ifp->if_capenable |= IFCAP_RXCSUM;
                         }
                 }
+        } else if (macver == 0x54800000) {
+                MP_WriteMcuAccessRegWord(sc, 0xD400, MP_ReadMcuAccessRegWord(sc, 0xD400) & ~(BIT_0));
+
+                if (sc->RequireAdjustUpsTxLinkPulseTiming) {
+                        data16 = MP_ReadMcuAccessRegWord(sc, 0xD412);
+                        data16 &= ~(0x0FFF);
+                        data16 |= sc->SwrCnt1msIni;
+                        MP_WriteMcuAccessRegWord(sc, 0xD412, data16);
+                }
 
-                /* disable clock request. */
-                pci_write_config(sc->dev, 0x81, 0x00, 1);
+                data16 = MP_ReadMcuAccessRegWord(sc, 0xE056);
+                data16 &= ~(BIT_7 | BIT_6 | BIT_5 | BIT_4);
+                data16 |= (BIT_6 | BIT_5 | BIT_4);
+                MP_WriteMcuAccessRegWord(sc, 0xE056, data16);
+
+                OOB_mutex_lock(sc);
+                data16 = MP_ReadMcuAccessRegWord(sc, 0xE052);
+                if (sc->re_type == MACFG_71)
+                        data16 |= BIT_3;
+                else
+                        data16 &= ~BIT_3;
+                MP_WriteMcuAccessRegWord(sc, 0xE052, data16);
+                OOB_mutex_unlock(sc);
+
+                data16 = MP_ReadMcuAccessRegWord(sc, 0xD420);
+                data16 &= ~(BIT_11 | BIT_10 | BIT_9 | BIT_8 | BIT_7 | BIT_6 | BIT_5 | BIT_4 | BIT_3 | BIT_2 | BIT_1 | BIT_0);
+                data16 |= 0x47F;
+                MP_WriteMcuAccessRegWord(sc, 0xD420, data16);
+
+                CSR_WRITE_1(sc, RE_TDFNR, 0x4);
+
+                data16 = MP_ReadMcuAccessRegWord(sc, 0xE63E);
+                data16 &= ~(BIT_3 | BIT_2 | BIT_1);
+                MP_WriteMcuAccessRegWord(sc, 0xE63E, data16);
+                data16 |= (BIT_0);
+                MP_WriteMcuAccessRegWord(sc, 0xE63E, data16);
+                data16 &= ~(BIT_0);
+                MP_WriteMcuAccessRegWord(sc, 0xE63E, data16);
+                MP_WriteMcuAccessRegWord(sc, 0xC094, 0x0);
+                MP_WriteMcuAccessRegWord(sc, 0xC09E, 0x0);
+
+                /*set configuration space offset 0x70f to 0x27*/
+                Data32 = MP_ReadPciEConfigSpace(sc, 0x870c);
+                Data32 &=0xC0FFFFFF;
+                Data32 |= (0x27 << 24);
+                MP_WritePciEConfigSpace(sc, 0x870c, Data32);
+
+                data8 = pci_read_config(sc->dev, 0x79, 1);
+                data8 &= ~0x70;
+                data8 |= 0x50;
+                pci_write_config(sc->dev, 0x79, data8, 1);
+
+                Data32 = re_eri_read(sc, 0xD4, 4, ERIAR_ExGMAC);
+                Data32 |= BIT_7 | BIT_8 | BIT_9 | BIT_10 | BIT_11 | BIT_12;
+                re_eri_write(sc, 0xD4, 4, Data32, ERIAR_ExGMAC);
+
+                re_eri_write(sc, 0xC8, 4, 0x00080002, ERIAR_ExGMAC);
+                re_eri_write(sc, 0xCC, 1, 0x2F, ERIAR_ExGMAC);
+                re_eri_write(sc, 0xD0, 1, 0x5F, ERIAR_ExGMAC);
+                re_eri_write(sc, 0xE8, 4, 0x00100006, ERIAR_ExGMAC);
+
+                MP_WriteMcuAccessRegWord(sc, 0xE054, 0xFC01);
+
+                OOB_mutex_lock(sc);
+                Data32 = re_eri_read(sc, 0x5F0, 4, ERIAR_ExGMAC);
+                Data32 |= (BIT_8 | BIT_9 | BIT_10 | BIT_11);
+                re_eri_write(sc, 0x5F0, 4, Data32, ERIAR_ExGMAC);
+                OOB_mutex_unlock(sc);
+
+                Data32 = re_eri_read(sc, 0xdc, 4, ERIAR_ExGMAC);
+                Data32 &= ~BIT_0;
+                re_eri_write(sc, 0xdc, 1, Data32, ERIAR_ExGMAC);
+                Data32 |= BIT_0;
+                re_eri_write(sc, 0xdc, 1, Data32, ERIAR_ExGMAC);
+
+                Data32 = re_eri_read(sc, 0x2FC, 4, ERIAR_ExGMAC);
+                Data32 &= ~(BIT_0 | BIT_1 | BIT_2);
+                Data32 |= (BIT_0);
+                re_eri_write(sc, 0x2FC, 4, Data32, ERIAR_ExGMAC);
+
+                Data32 = re_eri_read(sc, 0x1B0, 4, ERIAR_ExGMAC);
+                Data32 &= ~BIT_12;
+                re_eri_write(sc, 0x1B0, 4, Data32, ERIAR_ExGMAC);
+
+                Data32 = re_eri_read(sc, 0x1D0, 1, ERIAR_ExGMAC);
+                Data32 &= ~BIT_1;
+                re_eri_write(sc, 0x1D0, 1, Data32, ERIAR_ExGMAC);
+
+                re_eri_write(sc, 0xC0, 2, 0x0000, ERIAR_ExGMAC);
+                re_eri_write(sc, 0xB8, 4, 0x00000000, ERIAR_ExGMAC);
+
+                CSR_WRITE_4(sc, RE_TXCFG, CSR_READ_4(sc, RE_TXCFG) | BIT_7);
+                CSR_WRITE_1(sc, 0xD3, CSR_READ_1(sc, 0xD3) & ~BIT_7);
+                CSR_WRITE_1(sc, 0x1B, CSR_READ_1(sc, 0x1B) & ~0x07);
+
+                CSR_WRITE_2 (sc, RE_CPlusCmd, 0x2060);
+
+                CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0);
+
+                CSR_WRITE_1(sc, 0xD0, CSR_READ_1(sc, 0xD0) | BIT_6);
+                CSR_WRITE_1(sc, 0xF2, CSR_READ_1(sc, 0xF2) | BIT_6);
+
+                CSR_WRITE_1(sc, 0xD0, CSR_READ_1(sc, 0xD0) | BIT_7);
+
+                CSR_WRITE_1(sc, 0xF2, CSR_READ_1(sc, 0xF2) & ~BIT_3);
+
+                if (ifp->if_mtu > ETHERMTU)
+                        CSR_WRITE_1 (sc, RE_MTPS, 0x27);
+
+                data16 = MP_ReadMcuAccessRegWord(sc, 0xD3E2);
+                data16 &= 0xF000;
+                data16 |= 0x3A9;
+                MP_WriteMcuAccessRegWord(sc, 0xD3E2, data16);
+
+                data16 = MP_ReadMcuAccessRegWord(sc, 0xD3E4);
+                data16 &= 0xFF00;
+                MP_WriteMcuAccessRegWord(sc, 0xD3E4, data16);
+
+                data16 = MP_ReadMcuAccessRegWord(sc, 0xE860);
+                data16 |= BIT_7;
+                MP_WriteMcuAccessRegWord(sc, 0xE860, data16);
+
+                MP_WriteMcuAccessRegWord(sc, 0xC140, 0xFFFF);
+                MP_WriteMcuAccessRegWord(sc, 0xC142, 0xFFFF);
+
+                if (ifp->if_mtu > ETHERMTU) {
+                        ifp->if_capenable &= ~IFCAP_HWCSUM;
+                        ifp->if_hwassist &= ~RE_CSUM_FEATURES;
+                } else {
+                        if (sc->re_tx_cstag) {
+                                ifp->if_capenable |= IFCAP_TXCSUM;
+                                ifp->if_hwassist |= RE_CSUM_FEATURES;
+                        }
+                        if (sc->re_rx_cstag) {
+                                ifp->if_capenable |= IFCAP_RXCSUM;
+                        }
+                }
         }
 
         //clear io_rdy_l23
@@ -5152,26 +6327,59 @@ static void re_hw_start_unlock(struct re_softc *sc)
         case MACFG_67:
         case MACFG_68:
         case MACFG_69:
+        case MACFG_70:
+        case MACFG_71:
                 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_1);
                 break;
         }
 
-        //clear wol
-        re_clrwol(sc);
-
-        data16 = CSR_READ_2(sc, RE_CPlusCmd);
-        if ((ifp->if_capenable & IFCAP_VLAN_HWTAGGING) != 0)
-                data16 |= RL_CPLUSCMD_VLANSTRIP;
-        else
-                data16 &= ~RL_CPLUSCMD_VLANSTRIP;
-
-        if ((ifp->if_capenable & IFCAP_RXCSUM) != 0)
+        switch(sc->re_type) {
+        case MACFG_36:
+        case MACFG_37:
+        case MACFG_38:
+        case MACFG_39:
+        case MACFG_42:
+        case MACFG_43:
+        case MACFG_50:
+        case MACFG_51:
+        case MACFG_52:
+        case MACFG_53:
+        case MACFG_54:
+        case MACFG_55:
+        case MACFG_56:
+        case MACFG_57:
+        case MACFG_58:
+        case MACFG_59:
+        case MACFG_60:
+        case MACFG_61:
+        case MACFG_62:
+        case MACFG_67:
+        case MACFG_68:
+        case MACFG_69:
+        case MACFG_70:
+        case MACFG_71:
+                CSR_WRITE_1(sc, RE_CFG5, CSR_READ_1(sc, RE_CFG5) | BIT_0);
+                CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2) | BIT_7);
+                CSR_WRITE_1(sc, 0xF1, CSR_READ_1(sc, 0xF1) | BIT_7);
+                break;
+        }
+
+        //clear wol
+        re_clrwol(sc);
+
+        data16 = CSR_READ_2(sc, RE_CPlusCmd);
+        if ((ifp->if_capenable & IFCAP_VLAN_HWTAGGING) != 0)
+                data16 |= RL_CPLUSCMD_VLANSTRIP;
+        else
+                data16 &= ~RL_CPLUSCMD_VLANSTRIP;
+
+        if ((ifp->if_capenable & IFCAP_RXCSUM) != 0)
                 data16 |= RL_RxChkSum;
         else
                 data16 &= ~RL_RxChkSum;
         CSR_WRITE_2 (sc, RE_CPlusCmd, data16);
 
-        CSR_WRITE_1(sc, RE_EECMD, RE_EEMODE_OFF);
+        re_disable_cfg9346_write(sc);
         //CSR_WRITE_1(sc, 0xec, 0x3f);
 
         if (sc->re_device_id == RT_DEVICEID_8169 || sc->re_device_id == RT_DEVICEID_8169SC) {
@@ -5245,25 +6453,7 @@ static void re_init_unlock(void *xsc)  	/* Software & Hardware Initialize */
 #endif	/* !__DragonFly__ */
 
         /* Init our MAC address */
-        CSR_WRITE_1(sc, RE_EECMD, RE_EEMODE_WRITECFG);
-        CSR_WRITE_4(sc, RE_IDR0,
-                    htole32(*(u_int32_t *)(&eaddr.eaddr[0])));
-        CSR_WRITE_4(sc, RE_IDR4,
-                    htole32(*(u_int32_t *)(&eaddr.eaddr[4])));
-
-        switch (sc->re_type) {
-        case MACFG_36:
-        case MACFG_37:
-        case MACFG_54:
-        case MACFG_55:
-                CSR_WRITE_4(sc, RE_SecMAC0,
-                            htole32(*(u_int32_t *)(&eaddr.eaddr[0])));
-                CSR_WRITE_2(sc, RE_SecMAC4,
-                            htole16(*(u_int16_t *)(&eaddr.eaddr[4])));
-                break;
-        }
-
-        CSR_WRITE_1(sc, RE_EECMD, RE_EEMODE_OFF);
+        re_rar_set(sc, eaddr.eaddr);
 
 #ifndef __DragonFly__
         re_hw_start_unlock(sc);
@@ -5425,6 +6615,8 @@ static void re_reset(struct re_softc *sc)
         case MACFG_67:
         case MACFG_68:
         case MACFG_69:
+        case MACFG_70:
+        case MACFG_71:
                 DELAY(2000);
                 break;
         default:
@@ -5455,7 +6647,6 @@ static u_int8_t re_link_ok(struct re_softc *sc)
         return retval;
 }
 
-#ifndef __DragonFly__
 static void
 re_set_wol_linkspeed(struct re_softc *sc)
 {
@@ -5465,7 +6656,7 @@ re_set_wol_linkspeed(struct re_softc *sc)
         MP_WritePhyUshort(sc, 0x1F, 0x0000);
 
         wol_link_speed = RE_WOL_LINK_SPEED_100M_FIRST;
-        if (!re_check_dash(sc)) {
+        if (!sc->re_dash) {
                 if (re_link_ok(sc)) {
                         u_int16_t anlpar;
 
@@ -5501,6 +6692,7 @@ re_set_wol_linkspeed(struct re_softc *sc)
         }
 }
 
+#ifndef __DragonFly__
 static void
 re_setwol(struct re_softc *sc)
 {
@@ -5522,7 +6714,7 @@ re_setwol(struct re_softc *sc)
                 return;
 
         /* Enable config register write. */
-        CSR_WRITE_1(sc, RE_EECMD, RE_EEMODE_WRITECFG);
+        re_enable_cfg9346_write(sc);
 
         /* Enable PME. */
         if (sc->re_device_id==RT_DEVICEID_8169 || sc->re_device_id==RT_DEVICEID_8169SC) {
@@ -5562,7 +6754,7 @@ re_setwol(struct re_softc *sc)
         CSR_WRITE_1(sc, RE_CFG5, v);
 
         /* Config register write done. */
-        CSR_WRITE_1(sc, RE_EECMD, RE_EEMODE_OFF);
+        re_disable_cfg9346_write(sc);
 
         /*
          * It seems that hardware resets its link speed to 100Mbps in
@@ -5610,7 +6802,7 @@ re_clrwol(struct re_softc *sc)
         pci_write_config(sc->dev, pmc + PCIR_POWER_STATUS, pmstat, 2);
 
         /* Enable config register write. */
-        CSR_WRITE_1(sc, RE_EECMD, RE_EEMODE_WRITECFG);
+        re_enable_cfg9346_write(sc);
 
         if (sc->re_device_id==RT_DEVICEID_8169 || sc->re_device_id==RT_DEVICEID_8169SC) {
                 v = CSR_READ_1(sc, RE_CFG1);
@@ -5640,7 +6832,7 @@ re_clrwol(struct re_softc *sc)
         CSR_WRITE_1(sc, RE_CFG5, v);
 
         /* Config register write done. */
-        CSR_WRITE_1(sc, RE_EECMD, RE_EEMODE_OFF);
+        re_disable_cfg9346_write(sc);
 }
 
 /*
@@ -5792,7 +6984,7 @@ static void re_start(struct ifnet *ifp)  	/* Transmit Packet*/
 
                 //vlan
                 if (m_head->m_flags & M_VLANTAG)
-                        opts2 |= bswap16(m_head->m_pkthdr.ether_vtag) | RL_TDESC_VLANCTL_TAG ;
+                        opts2 |= bswap16(m_head->m_pkthdr.ether_vtag) | RL_TDESC_VLANCTL_TAG;
                 ptr = m_head;
                 PktLen = ptr->m_pkthdr.len;
 #ifdef _DEBUG_
@@ -6338,11 +7530,11 @@ static void re_set_multicast_reg(struct re_softc *sc, u_int32_t mask0, u_int32_t
                 enable_cfg_reg_write = 1;
 
         if (enable_cfg_reg_write)
-                CSR_WRITE_1(sc, RE_EECMD, RE_EEMODE_WRITECFG);
+                re_enable_cfg9346_write(sc);
         CSR_WRITE_4(sc, RE_MAR0, mask0);
         CSR_WRITE_4(sc, RE_MAR4, mask4);
         if (enable_cfg_reg_write)
-                CSR_WRITE_1(sc, RE_EECMD, RE_EEMODE_OFF);
+                re_disable_cfg9346_write(sc);
 
         return;
 }
@@ -6440,7 +7632,7 @@ static void re_setmulti(struct re_softc *sc)
         TAILQ_FOREACH(ifma,&ifp->if_multiaddrs,ifma_link)
 #endif
 #else	/* __DragonFly__ */
-        TAILQ_FOREACH(ifma,&ifp->if_multiaddrs,ifma_link)
+	TAILQ_FOREACH(ifma,&ifp->if_multiaddrs,ifma_link)
 #endif	/* !__DragonFly__ */
         {
                 if (ifma->ifma_addr->sa_family != AF_LINK)
@@ -6677,7 +7869,8 @@ static void re_link_on_patch(struct re_softc *sc)
                     sc->re_type == MACFG_58 || sc->re_type == MACFG_59 ||
                     sc->re_type == MACFG_60 || sc->re_type == MACFG_61 ||
                     sc->re_type == MACFG_62 || sc->re_type == MACFG_67 ||
-                    sc->re_type == MACFG_68 || sc->re_type == MACFG_69) &&
+                    sc->re_type == MACFG_68 || sc->re_type == MACFG_69 ||
+                    sc->re_type == MACFG_70 || sc->re_type == MACFG_71) &&
                    (ifp->if_flags & IFF_UP)) {
                 if (CSR_READ_1(sc, RE_PHY_STATUS) & RL_PHY_STATUS_FULL_DUP)
                         CSR_WRITE_4(sc, RE_TXCFG, (CSR_READ_4(sc, RE_TXCFG) | (BIT_24 | BIT_25)) & ~BIT_19);
@@ -6694,6 +7887,15 @@ static void re_link_on_patch(struct re_softc *sc)
                 }
         }
 
+        if ((sc->re_type == MACFG_70 || sc->re_type == MACFG_71) &&
+            (CSR_READ_1(sc, RE_PHY_STATUS) & RL_PHY_STATUS_10M)) {
+                uint32_t Data32;
+
+                Data32 = re_eri_read(sc, 0x1D0, 1, ERIAR_ExGMAC);
+                Data32 |= BIT_1;
+                re_eri_write(sc, 0x1D0, 1, Data32, ERIAR_ExGMAC);
+        }
+
 #ifndef __DragonFly__
         re_init_unlock(sc);
 #endif
@@ -6834,7 +8036,8 @@ static int re_ifmedia_upd(struct ifnet *ifp)
         if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER)
                 return(EINVAL);
 
-        if (sc->re_type == MACFG_68 || sc->re_type == MACFG_69) {
+        if (sc->re_type == MACFG_68 || sc->re_type == MACFG_69 ||
+            sc->re_type == MACFG_70 || sc->re_type == MACFG_71) {
                 //Disable Giga Lite
                 MP_WritePhyUshort(sc, 0x1F, 0x0A42);
                 ClearEthPhyBit(sc, 0x14, BIT_9);
@@ -6983,7 +8186,7 @@ static int re_enable_EEE(struct re_softc *sc)
         case MACFG_43:
                 re_eri_write(sc, 0x1B0, 2, 0xED03, ERIAR_ExGMAC);
                 MP_WritePhyUshort(sc, 0x1F, 0x0004);
-                if (CSR_READ_1(sc,0xEF) & 0x02) {
+                if (CSR_READ_1(sc, 0xEF) & 0x02) {
                         MP_WritePhyUshort(sc, 0x10, 0x731F);
                         MP_WritePhyUshort(sc, 0x19, 0x7630);
                 } else {
@@ -7056,27 +8259,27 @@ static int re_enable_EEE(struct re_softc *sc)
         case MACFG_50:
         case MACFG_51:
         case MACFG_52:
-                data = re_eri_read(sc, 0x1B0 ,4,ERIAR_ExGMAC) | 0x0003;
+                data = re_eri_read(sc, 0x1B0, 4, ERIAR_ExGMAC) | 0x0003;
                 re_eri_write(sc, 0x1B0, 4, data, ERIAR_ExGMAC);
-                MP_WritePhyUshort(sc,0x1F , 0x0007);
-                MP_WritePhyUshort(sc,0x1E , 0x0020);
+                MP_WritePhyUshort(sc, 0x1F, 0x0007);
+                MP_WritePhyUshort(sc, 0x1E, 0x0020);
                 data = MP_ReadPhyUshort(sc, 0x15)|0x0100;
-                MP_WritePhyUshort(sc,0x15 , data);
-                MP_WritePhyUshort(sc,0x1F , 0x0005);
-                MP_WritePhyUshort(sc,0x05 , 0x8B85);
+                MP_WritePhyUshort(sc, 0x15, data);
+                MP_WritePhyUshort(sc, 0x1F, 0x0005);
+                MP_WritePhyUshort(sc, 0x05, 0x8B85);
                 data = MP_ReadPhyUshort(sc, 0x06)|0x2000;
-                MP_WritePhyUshort(sc,0x06 , data);
-                MP_WritePhyUshort(sc,0x1F , 0x0000);
-                MP_WritePhyUshort(sc,0x0D , 0x0007);
-                MP_WritePhyUshort(sc,0x0E , 0x003C);
-                MP_WritePhyUshort(sc,0x0D , 0x4007);
-                MP_WritePhyUshort(sc,0x0E , 0x0006);
-                MP_WritePhyUshort(sc,0x1D , 0x0000);
+                MP_WritePhyUshort(sc, 0x06, data);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+                MP_WritePhyUshort(sc, 0x0D, 0x0007);
+                MP_WritePhyUshort(sc, 0x0E, 0x003C);
+                MP_WritePhyUshort(sc, 0x0D, 0x4007);
+                MP_WritePhyUshort(sc, 0x0E, 0x0006);
+                MP_WritePhyUshort(sc, 0x1D, 0x0000);
                 break;
 
         case MACFG_38:
         case MACFG_39:
-                data = re_eri_read(sc, 0x1B0 ,4,ERIAR_ExGMAC);
+                data = re_eri_read(sc, 0x1B0, 4, ERIAR_ExGMAC);
                 data |= BIT_1 | BIT_0;
                 re_eri_write(sc, 0x1B0, 4, data, ERIAR_ExGMAC);
                 MP_WritePhyUshort(sc, 0x1F, 0x0004);
@@ -7109,6 +8312,8 @@ static int re_enable_EEE(struct re_softc *sc)
         case MACFG_67:
         case MACFG_68:
         case MACFG_69:
+        case MACFG_70:
+        case MACFG_71:
                 data = re_eri_read(sc, 0x1B0, 4, ERIAR_ExGMAC);
                 data |= BIT_1 | BIT_0;
                 re_eri_write(sc, 0x1B0, 4, data, ERIAR_ExGMAC);
@@ -7147,7 +8352,7 @@ static int re_enable_EEE(struct re_softc *sc)
                 SetEthPhyBit(sc, 0x10, BIT_4);
                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
 
-                MP_WritePhyUshort(sc,0x1F, 0x0B80);
+                MP_WritePhyUshort(sc, 0x1F, 0x0B80);
                 WaitCnt = 0;
                 do {
                         PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
@@ -7217,6 +8422,19 @@ static int re_enable_EEE(struct re_softc *sc)
                 data |= (BIT_4 | BIT_5 | BIT_6);
                 MP_WriteMcuAccessRegWord(sc, 0xE056, data);
                 break;
+        case MACFG_70:
+        case MACFG_71:
+                OOB_mutex_lock(sc);
+                data = MP_ReadMcuAccessRegWord(sc, 0xE052);
+                data &= ~BIT_0;
+                MP_WriteMcuAccessRegWord(sc, 0xE052, data);
+                OOB_mutex_unlock(sc);
+                data = MP_ReadMcuAccessRegWord(sc, 0xE056);
+                data &= 0xFF0F;
+                data |= (BIT_4 | BIT_5 | BIT_6);
+                MP_WriteMcuAccessRegWord(sc, 0xE056, data);
+                MP_WriteMcuAccessRegWord(sc, 0xEA80, 0x0003);
+                break;
         case MACFG_68:
         case MACFG_69:
                 data = MP_ReadMcuAccessRegWord(sc, 0xE052);
@@ -7240,7 +8458,7 @@ static int re_enable_EEE(struct re_softc *sc)
         case MACFG_60:
         case MACFG_68:
         case MACFG_69:
-                MP_WritePhyUshort(sc,0x1F, 0x0B82);
+                MP_WritePhyUshort(sc, 0x1F, 0x0B82);
                 ClearEthPhyBit(sc, 0x10, BIT_4);
                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
                 break;
@@ -7344,7 +8562,7 @@ static int re_disable_EEE(struct re_softc *sc)
         case MACFG_50:
         case MACFG_51:
         case MACFG_52:
-                data = re_eri_read(sc,0x1B0 ,4,ERIAR_ExGMAC)& ~0x0003;
+                data = re_eri_read(sc, 0x1B0, 4, ERIAR_ExGMAC)& ~0x0003;
                 re_eri_write(sc, 0x1B0, 4, data, ERIAR_ExGMAC);
                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
                 MP_WritePhyUshort(sc, 0x05, 0x8B85);
@@ -7353,7 +8571,7 @@ static int re_disable_EEE(struct re_softc *sc)
                 MP_WritePhyUshort(sc, 0x1F, 0x0007);
                 MP_WritePhyUshort(sc, 0x1E, 0x0020);
                 data = MP_ReadPhyUshort(sc, 0x15) & ~0x0100;
-                MP_WritePhyUshort(sc,0x15 , data);
+                MP_WritePhyUshort(sc, 0x15, data);
                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
                 MP_WritePhyUshort(sc, 0x0D, 0x0007);
                 MP_WritePhyUshort(sc, 0x0E, 0x003C);
@@ -7365,7 +8583,7 @@ static int re_disable_EEE(struct re_softc *sc)
 
         case MACFG_38:
         case MACFG_39:
-                data = re_eri_read(sc,0x1B0 ,4,ERIAR_ExGMAC);
+                data = re_eri_read(sc, 0x1B0, 4, ERIAR_ExGMAC);
                 data &= ~(BIT_1 | BIT_0);
                 re_eri_write(sc, 0x1B0, 4, data, ERIAR_ExGMAC);
                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
@@ -7399,6 +8617,8 @@ static int re_disable_EEE(struct re_softc *sc)
         case MACFG_67:
         case MACFG_68:
         case MACFG_69:
+        case MACFG_70:
+        case MACFG_71:
                 data = re_eri_read(sc, 0x1B0, 4, ERIAR_ExGMAC);
                 data &= ~(BIT_1 | BIT_0);
                 re_eri_write(sc, 0x1B0, 4, data, ERIAR_ExGMAC);
@@ -7437,7 +8657,7 @@ static int re_disable_EEE(struct re_softc *sc)
                 SetEthPhyBit(sc, 0x10, BIT_4);
                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
 
-                MP_WritePhyUshort(sc,0x1F, 0x0B80);
+                MP_WritePhyUshort(sc, 0x1F, 0x0B80);
                 WaitCnt = 0;
                 do {
                         PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
@@ -7475,6 +8695,8 @@ static int re_disable_EEE(struct re_softc *sc)
         case MACFG_61:
         case MACFG_62:
         case MACFG_67:
+        case MACFG_70:
+        case MACFG_71:
                 data = MP_ReadMcuAccessRegWord(sc, 0xE052);
                 data &= ~(BIT_0);
                 MP_WriteMcuAccessRegWord(sc, 0xE052, data);
@@ -7501,7 +8723,7 @@ static int re_disable_EEE(struct re_softc *sc)
         case MACFG_60:
         case MACFG_68:
         case MACFG_69:
-                MP_WritePhyUshort(sc,0x1F, 0x0B82);
+                MP_WritePhyUshort(sc, 0x1F, 0x0B82);
                 ClearEthPhyBit(sc, 0x10, BIT_4);
                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
                 break;
@@ -7535,12 +8757,12 @@ static int re_phy_ram_code_check(struct re_softc *sc)
                 PhyRegValue &= ~(BIT_11);
                 MP_WritePhyUshort(sc, 0x14, PhyRegValue);
 
-                MP_WritePhyUshort(sc,0x1f, 0x0B82);
+                MP_WritePhyUshort(sc, 0x1f, 0x0B82);
                 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
                 PhyRegValue |= BIT_4;
-                MP_WritePhyUshort(sc,0x10, PhyRegValue);
+                MP_WritePhyUshort(sc, 0x10, PhyRegValue);
 
-                MP_WritePhyUshort(sc,0x1f, 0x0B80);
+                MP_WritePhyUshort(sc, 0x1f, 0x0B80);
                 WaitCnt = 0;
                 do {
                         PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
@@ -7551,7 +8773,7 @@ static int re_phy_ram_code_check(struct re_softc *sc)
                 } while(PhyRegValue != 0x0040 && WaitCnt <1000);
 
                 if (WaitCnt == 1000) {
-                        retval = FALSE ;
+                        retval = FALSE;
                 }
 
                 MP_WritePhyUshort(sc, 0x1f, 0x0A40);
@@ -7578,7 +8800,7 @@ static int re_phy_ram_code_check(struct re_softc *sc)
                 PhyRegValue &= ~(BIT_4);
                 MP_WritePhyUshort(sc, 0x10, PhyRegValue);
 
-                MP_WritePhyUshort(sc,0x1f, 0x0A22);
+                MP_WritePhyUshort(sc, 0x1f, 0x0A22);
                 WaitCnt = 0;
                 do {
                         PhyRegValue = MP_ReadPhyUshort(sc, 0x12);
@@ -7616,12 +8838,12 @@ static int re_phy_ram_code_check(struct re_softc *sc)
                 PhyRegValue |= (BIT_11);
                 MP_WritePhyUshort(sc, 0x14, PhyRegValue);
 
-                MP_WritePhyUshort(sc,0x1f, 0x0B82);
+                MP_WritePhyUshort(sc, 0x1f, 0x0B82);
                 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
                 PhyRegValue |= BIT_4;
-                MP_WritePhyUshort(sc,0x10, PhyRegValue);
+                MP_WritePhyUshort(sc, 0x10, PhyRegValue);
 
-                MP_WritePhyUshort(sc,0x1f, 0x0B80);
+                MP_WritePhyUshort(sc, 0x1f, 0x0B80);
                 WaitCnt = 0;
                 do {
                         PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
@@ -7673,7988 +8895,3446 @@ static void re_set_phy_ram_code_check_fail_flag(struct re_softc *sc)
         }
 }
 
-static void re_hw_phy_config(struct re_softc *sc)
+static int re_hw_phy_mcu_code_ver_matched(struct re_softc *sc)
 {
-        u_int16_t Data, PhyRegValue, TmpUshort;
-        u_int32_t Data_u32;
-        u_int16_t dout_tapbin;
-        int	i;
-        u_int32_t WaitCnt;
+        int ram_code_ver_match = 0;
 
-        if (sc->re_type == MACFG_59 || sc->re_type == MACFG_60 ||
-            sc->re_type == MACFG_62 || sc->re_type == MACFG_67 ||
-            sc->re_type == MACFG_68 || sc->re_type == MACFG_69) {
-                MP_WritePhyOcpRegWord(sc, 0x0C41, 0x13, 0x0000);
-                MP_WritePhyOcpRegWord(sc, 0x0C41, 0x13, 0x0500);
+        switch (sc->re_type) {
+        case MACFG_36:
+        case MACFG_37:
+                MP_WritePhyUshort(sc, 0x1F, 0x0005);
+                MP_WritePhyUshort(sc, 0x05, 0x8B60);
+                sc->re_hw_ram_code_ver = MP_ReadPhyUshort(sc, 0x06);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+                break;
+        case MACFG_38:
+        case MACFG_39:
+        case MACFG_50:
+        case MACFG_51:
+        case MACFG_52:
+                MP_WritePhyUshort(sc, 0x1F, 0x0005);
+                MP_WritePhyUshort(sc, 0x05, 0x8B30);
+                sc->re_hw_ram_code_ver = MP_ReadPhyUshort(sc, 0x06);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+                break;
+        case MACFG_56:
+        case MACFG_57:
+        case MACFG_58:
+        case MACFG_59:
+        case MACFG_60:
+        case MACFG_61:
+        case MACFG_62:
+        case MACFG_67:
+        case MACFG_68:
+        case MACFG_69:
+        case MACFG_70:
+        case MACFG_71:
+                MP_WritePhyUshort(sc, 0x1F, 0x0A43);
+                MP_WritePhyUshort(sc, 0x13, 0x801E);
+                sc->re_hw_ram_code_ver = MP_ReadPhyUshort(sc, 0x14);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+                break;
+        default:
+                sc->re_hw_ram_code_ver = ~0;
+                break;
         }
 
-        if (FALSE == re_phy_ram_code_check(sc)) {
-                re_set_phy_ram_code_check_fail_flag(sc);
-                return;
-        }
+        if (sc->re_hw_ram_code_ver == sc->re_sw_ram_code_ver)
+                ram_code_ver_match = 1;
 
-        MP_WritePhyUshort(sc, 0x1F, 0x0000);
+        return ram_code_ver_match;
+}
 
-        if (sc->re_type == MACFG_3) {
-                CSR_WRITE_1(sc, 0x82, CSR_READ_1(sc, 0x82)|BIT_0);
+static void re_write_hw_phy_mcu_code_ver(struct re_softc *sc)
+{
+        switch (sc->re_type) {
+        case MACFG_36:
+        case MACFG_37:
+                MP_WritePhyUshort(sc, 0x1F, 0x0005);
+                MP_WritePhyUshort(sc, 0x05, 0x8B60);
+                MP_WritePhyUshort(sc, 0x06, sc->re_sw_ram_code_ver);
                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
-                MP_WritePhyUshort(sc, 0x0b, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1f, 0x0001);
-                MP_WritePhyUshort(sc, 0x06, 0x006e);
-                MP_WritePhyUshort(sc, 0x08, 0x0708);
-                MP_WritePhyUshort(sc, 0x15, 0x4000);
-                MP_WritePhyUshort(sc, 0x18, 0x65c7);
-
-                MP_WritePhyUshort(sc, 0x1f, 0x0001);
-                MP_WritePhyUshort(sc, 0x03, 0x00a1);
-                MP_WritePhyUshort(sc, 0x02, 0x0008);
-                MP_WritePhyUshort(sc, 0x01, 0x0120);
-                MP_WritePhyUshort(sc, 0x00, 0x1000);
-                MP_WritePhyUshort(sc, 0x04, 0x0800);
-                MP_WritePhyUshort(sc, 0x04, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x03, 0xff41);
-                MP_WritePhyUshort(sc, 0x02, 0xdf60);
-                MP_WritePhyUshort(sc, 0x01, 0x0140);
-                MP_WritePhyUshort(sc, 0x00, 0x0077);
-                MP_WritePhyUshort(sc, 0x04, 0x7800);
-                MP_WritePhyUshort(sc, 0x04, 0x7000);
-
-                MP_WritePhyUshort(sc, 0x03, 0x802f);
-                MP_WritePhyUshort(sc, 0x02, 0x4f02);
-                MP_WritePhyUshort(sc, 0x01, 0x0409);
-                MP_WritePhyUshort(sc, 0x00, 0xf0f9);
-                MP_WritePhyUshort(sc, 0x04, 0x9800);
-                MP_WritePhyUshort(sc, 0x04, 0x9000);
+                sc->re_hw_ram_code_ver = sc->re_sw_ram_code_ver;
+                break;
+        case MACFG_38:
+        case MACFG_39:
+        case MACFG_50:
+        case MACFG_51:
+        case MACFG_52:
+                MP_WritePhyUshort(sc, 0x1F, 0x0005);
+                MP_WritePhyUshort(sc, 0x05, 0x8B30);
+                MP_WritePhyUshort(sc, 0x06, sc->re_sw_ram_code_ver);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+                sc->re_hw_ram_code_ver = sc->re_sw_ram_code_ver;
+                break;
+        case MACFG_56:
+        case MACFG_57:
+        case MACFG_58:
+        case MACFG_59:
+        case MACFG_60:
+        case MACFG_61:
+        case MACFG_62:
+        case MACFG_67:
+        case MACFG_68:
+        case MACFG_69:
+        case MACFG_70:
+        case MACFG_71:
+                MP_WritePhyUshort(sc, 0x1F, 0x0A43);
+                MP_WritePhyUshort(sc, 0x13, 0x801E);
+                MP_WritePhyUshort(sc, 0x14, sc->re_sw_ram_code_ver);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+                sc->re_hw_ram_code_ver = sc->re_sw_ram_code_ver;
+                break;
+        }
+}
 
-                MP_WritePhyUshort(sc, 0x03, 0xdf01);
-                MP_WritePhyUshort(sc, 0x02, 0xdf20);
-                MP_WritePhyUshort(sc, 0x01, 0xff95);
-                MP_WritePhyUshort(sc, 0x00, 0xba00);
-                MP_WritePhyUshort(sc, 0x04, 0xa800);
-                MP_WritePhyUshort(sc, 0x04, 0xa000);
+static void re_set_phy_mcu_8168e_1(struct re_softc *sc)
+{
+        u_int16_t PhyRegValue;
+        int i;
 
-                MP_WritePhyUshort(sc, 0x03, 0xff41);
-                MP_WritePhyUshort(sc, 0x02, 0xdf20);
-                MP_WritePhyUshort(sc, 0x01, 0x0140);
-                MP_WritePhyUshort(sc, 0x00, 0x00bb);
-                MP_WritePhyUshort(sc, 0x04, 0xb800);
-                MP_WritePhyUshort(sc, 0x04, 0xb000);
+        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+        MP_WritePhyUshort(sc, 0x00, 0x1800);
+        MP_WritePhyUshort(sc, 0x1f, 0x0007);
+        MP_WritePhyUshort(sc, 0x1e, 0x0023);
+        MP_WritePhyUshort(sc, 0x17, 0x0117);
+        MP_WritePhyUshort(sc, 0x1f, 0x0007);
+        MP_WritePhyUshort(sc, 0x1E, 0x002C);
+        MP_WritePhyUshort(sc, 0x1B, 0x5000);
+        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+        MP_WritePhyUshort(sc, 0x16, 0x4104);
+        for (i=0; i<200; i++) {
+                DELAY(100);
+                PhyRegValue = MP_ReadPhyUshort(sc, 0x1E);
+                PhyRegValue &= 0x03FF;
+                if (PhyRegValue== 0x000C)
+                        break;
+        }
+        MP_WritePhyUshort(sc, 0x1f, 0x0005);
+        for (i=0; i<200; i++) {
+                DELAY(100);
+                PhyRegValue = MP_ReadPhyUshort(sc, 0x07);
+                if ((PhyRegValue&0x0020)==0)
+                        break;
+        }
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x07);
+        if (PhyRegValue & 0x0020) {
+                MP_WritePhyUshort(sc, 0x1f, 0x0007);
+                MP_WritePhyUshort(sc, 0x1e, 0x00a1);
+                MP_WritePhyUshort(sc, 0x17, 0x1000);
+                MP_WritePhyUshort(sc, 0x17, 0x0000);
+                MP_WritePhyUshort(sc, 0x17, 0x2000);
+                MP_WritePhyUshort(sc, 0x1e, 0x002f);
+                MP_WritePhyUshort(sc, 0x18, 0x9bfb);
+                MP_WritePhyUshort(sc, 0x1f, 0x0005);
+                MP_WritePhyUshort(sc, 0x07, 0x0000);
+                MP_WritePhyUshort(sc, 0x1f, 0x0000);
+        }
 
-                MP_WritePhyUshort(sc, 0x03, 0xdf41);
-                MP_WritePhyUshort(sc, 0x02, 0xdc60);
-                MP_WritePhyUshort(sc, 0x01, 0x6340);
-                MP_WritePhyUshort(sc, 0x00, 0x007d);
-                MP_WritePhyUshort(sc, 0x04, 0xd800);
-                MP_WritePhyUshort(sc, 0x04, 0xd000);
+        MP_WritePhyUshort(sc, 0x1f, 0x0005);
+        MP_WritePhyUshort(sc, 0x05, 0xfff6);
+        MP_WritePhyUshort(sc, 0x06, 0x0080);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x00);
+        PhyRegValue &= ~(BIT_7);
+        MP_WritePhyUshort(sc, 0x00, PhyRegValue);
+        MP_WritePhyUshort(sc, 0x1f, 0x0002);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x08);
+        PhyRegValue &= ~(BIT_7);
+        MP_WritePhyUshort(sc, 0x08, PhyRegValue);
+        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+        MP_WritePhyUshort(sc, 0x1f, 0x0007);
+        MP_WritePhyUshort(sc, 0x1e, 0x0023);
+        MP_WritePhyUshort(sc, 0x16, 0x0306);
+        MP_WritePhyUshort(sc, 0x16, 0x0307);
+        MP_WritePhyUshort(sc, 0x15, 0x000e);
+        MP_WritePhyUshort(sc, 0x19, 0x000a);
+        MP_WritePhyUshort(sc, 0x15, 0x0010);
+        MP_WritePhyUshort(sc, 0x19, 0x0008);
+        MP_WritePhyUshort(sc, 0x15, 0x0018);
+        MP_WritePhyUshort(sc, 0x19, 0x4801);
+        MP_WritePhyUshort(sc, 0x15, 0x0019);
+        MP_WritePhyUshort(sc, 0x19, 0x6801);
+        MP_WritePhyUshort(sc, 0x15, 0x001a);
+        MP_WritePhyUshort(sc, 0x19, 0x66a1);
+        MP_WritePhyUshort(sc, 0x15, 0x001f);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0020);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0021);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0022);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0023);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0024);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0025);
+        MP_WritePhyUshort(sc, 0x19, 0x64a1);
+        MP_WritePhyUshort(sc, 0x15, 0x0026);
+        MP_WritePhyUshort(sc, 0x19, 0x40ea);
+        MP_WritePhyUshort(sc, 0x15, 0x0027);
+        MP_WritePhyUshort(sc, 0x19, 0x4503);
+        MP_WritePhyUshort(sc, 0x15, 0x0028);
+        MP_WritePhyUshort(sc, 0x19, 0x9f00);
+        MP_WritePhyUshort(sc, 0x15, 0x0029);
+        MP_WritePhyUshort(sc, 0x19, 0xa631);
+        MP_WritePhyUshort(sc, 0x15, 0x002a);
+        MP_WritePhyUshort(sc, 0x19, 0x9717);
+        MP_WritePhyUshort(sc, 0x15, 0x002b);
+        MP_WritePhyUshort(sc, 0x19, 0x302c);
+        MP_WritePhyUshort(sc, 0x15, 0x002c);
+        MP_WritePhyUshort(sc, 0x19, 0x4802);
+        MP_WritePhyUshort(sc, 0x15, 0x002d);
+        MP_WritePhyUshort(sc, 0x19, 0x58da);
+        MP_WritePhyUshort(sc, 0x15, 0x002e);
+        MP_WritePhyUshort(sc, 0x19, 0x400d);
+        MP_WritePhyUshort(sc, 0x15, 0x002f);
+        MP_WritePhyUshort(sc, 0x19, 0x4488);
+        MP_WritePhyUshort(sc, 0x15, 0x0030);
+        MP_WritePhyUshort(sc, 0x19, 0x9e00);
+        MP_WritePhyUshort(sc, 0x15, 0x0031);
+        MP_WritePhyUshort(sc, 0x19, 0x63c8);
+        MP_WritePhyUshort(sc, 0x15, 0x0032);
+        MP_WritePhyUshort(sc, 0x19, 0x6481);
+        MP_WritePhyUshort(sc, 0x15, 0x0033);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0034);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0035);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0036);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0037);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0038);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0039);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x003a);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x003b);
+        MP_WritePhyUshort(sc, 0x19, 0x63e8);
+        MP_WritePhyUshort(sc, 0x15, 0x003c);
+        MP_WritePhyUshort(sc, 0x19, 0x7d00);
+        MP_WritePhyUshort(sc, 0x15, 0x003d);
+        MP_WritePhyUshort(sc, 0x19, 0x59d4);
+        MP_WritePhyUshort(sc, 0x15, 0x003e);
+        MP_WritePhyUshort(sc, 0x19, 0x63f8);
+        MP_WritePhyUshort(sc, 0x15, 0x0040);
+        MP_WritePhyUshort(sc, 0x19, 0x64a1);
+        MP_WritePhyUshort(sc, 0x15, 0x0041);
+        MP_WritePhyUshort(sc, 0x19, 0x30de);
+        MP_WritePhyUshort(sc, 0x15, 0x0044);
+        MP_WritePhyUshort(sc, 0x19, 0x480f);
+        MP_WritePhyUshort(sc, 0x15, 0x0045);
+        MP_WritePhyUshort(sc, 0x19, 0x6800);
+        MP_WritePhyUshort(sc, 0x15, 0x0046);
+        MP_WritePhyUshort(sc, 0x19, 0x6680);
+        MP_WritePhyUshort(sc, 0x15, 0x0047);
+        MP_WritePhyUshort(sc, 0x19, 0x7c10);
+        MP_WritePhyUshort(sc, 0x15, 0x0048);
+        MP_WritePhyUshort(sc, 0x19, 0x63c8);
+        MP_WritePhyUshort(sc, 0x15, 0x0049);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x004a);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x004b);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x004c);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x004d);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x004e);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x004f);
+        MP_WritePhyUshort(sc, 0x19, 0x40ea);
+        MP_WritePhyUshort(sc, 0x15, 0x0050);
+        MP_WritePhyUshort(sc, 0x19, 0x4503);
+        MP_WritePhyUshort(sc, 0x15, 0x0051);
+        MP_WritePhyUshort(sc, 0x19, 0x58ca);
+        MP_WritePhyUshort(sc, 0x15, 0x0052);
+        MP_WritePhyUshort(sc, 0x19, 0x63c8);
+        MP_WritePhyUshort(sc, 0x15, 0x0053);
+        MP_WritePhyUshort(sc, 0x19, 0x63d8);
+        MP_WritePhyUshort(sc, 0x15, 0x0054);
+        MP_WritePhyUshort(sc, 0x19, 0x66a0);
+        MP_WritePhyUshort(sc, 0x15, 0x0055);
+        MP_WritePhyUshort(sc, 0x19, 0x9f00);
+        MP_WritePhyUshort(sc, 0x15, 0x0056);
+        MP_WritePhyUshort(sc, 0x19, 0x3000);
+        MP_WritePhyUshort(sc, 0x15, 0x006E);
+        MP_WritePhyUshort(sc, 0x19, 0x9afa);
+        MP_WritePhyUshort(sc, 0x15, 0x00a1);
+        MP_WritePhyUshort(sc, 0x19, 0x3044);
+        MP_WritePhyUshort(sc, 0x15, 0x00ab);
+        MP_WritePhyUshort(sc, 0x19, 0x5820);
+        MP_WritePhyUshort(sc, 0x15, 0x00ac);
+        MP_WritePhyUshort(sc, 0x19, 0x5e04);
+        MP_WritePhyUshort(sc, 0x15, 0x00ad);
+        MP_WritePhyUshort(sc, 0x19, 0xb60c);
+        MP_WritePhyUshort(sc, 0x15, 0x00af);
+        MP_WritePhyUshort(sc, 0x19, 0x000a);
+        MP_WritePhyUshort(sc, 0x15, 0x00b2);
+        MP_WritePhyUshort(sc, 0x19, 0x30b9);
+        MP_WritePhyUshort(sc, 0x15, 0x00b9);
+        MP_WritePhyUshort(sc, 0x19, 0x4408);
+        MP_WritePhyUshort(sc, 0x15, 0x00ba);
+        MP_WritePhyUshort(sc, 0x19, 0x480b);
+        MP_WritePhyUshort(sc, 0x15, 0x00bb);
+        MP_WritePhyUshort(sc, 0x19, 0x5e00);
+        MP_WritePhyUshort(sc, 0x15, 0x00bc);
+        MP_WritePhyUshort(sc, 0x19, 0x405f);
+        MP_WritePhyUshort(sc, 0x15, 0x00bd);
+        MP_WritePhyUshort(sc, 0x19, 0x4448);
+        MP_WritePhyUshort(sc, 0x15, 0x00be);
+        MP_WritePhyUshort(sc, 0x19, 0x4020);
+        MP_WritePhyUshort(sc, 0x15, 0x00bf);
+        MP_WritePhyUshort(sc, 0x19, 0x4468);
+        MP_WritePhyUshort(sc, 0x15, 0x00c0);
+        MP_WritePhyUshort(sc, 0x19, 0x9c02);
+        MP_WritePhyUshort(sc, 0x15, 0x00c1);
+        MP_WritePhyUshort(sc, 0x19, 0x58a0);
+        MP_WritePhyUshort(sc, 0x15, 0x00c2);
+        MP_WritePhyUshort(sc, 0x19, 0xb605);
+        MP_WritePhyUshort(sc, 0x15, 0x00c3);
+        MP_WritePhyUshort(sc, 0x19, 0xc0d3);
+        MP_WritePhyUshort(sc, 0x15, 0x00c4);
+        MP_WritePhyUshort(sc, 0x19, 0x00e6);
+        MP_WritePhyUshort(sc, 0x15, 0x00c5);
+        MP_WritePhyUshort(sc, 0x19, 0xdaec);
+        MP_WritePhyUshort(sc, 0x15, 0x00c6);
+        MP_WritePhyUshort(sc, 0x19, 0x00fa);
+        MP_WritePhyUshort(sc, 0x15, 0x00c7);
+        MP_WritePhyUshort(sc, 0x19, 0x9df9);
+        MP_WritePhyUshort(sc, 0x15, 0x00c8);
+        MP_WritePhyUshort(sc, 0x19, 0x307a);
+        MP_WritePhyUshort(sc, 0x15, 0x0112);
+        MP_WritePhyUshort(sc, 0x19, 0x6421);
+        MP_WritePhyUshort(sc, 0x15, 0x0113);
+        MP_WritePhyUshort(sc, 0x19, 0x7c08);
+        MP_WritePhyUshort(sc, 0x15, 0x0114);
+        MP_WritePhyUshort(sc, 0x19, 0x63f0);
+        MP_WritePhyUshort(sc, 0x15, 0x0115);
+        MP_WritePhyUshort(sc, 0x19, 0x4003);
+        MP_WritePhyUshort(sc, 0x15, 0x0116);
+        MP_WritePhyUshort(sc, 0x19, 0x4418);
+        MP_WritePhyUshort(sc, 0x15, 0x0117);
+        MP_WritePhyUshort(sc, 0x19, 0x9b00);
+        MP_WritePhyUshort(sc, 0x15, 0x0118);
+        MP_WritePhyUshort(sc, 0x19, 0x6461);
+        MP_WritePhyUshort(sc, 0x15, 0x0119);
+        MP_WritePhyUshort(sc, 0x19, 0x64e1);
+        MP_WritePhyUshort(sc, 0x15, 0x011a);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0150);
+        MP_WritePhyUshort(sc, 0x19, 0x7c80);
+        MP_WritePhyUshort(sc, 0x15, 0x0151);
+        MP_WritePhyUshort(sc, 0x19, 0x6461);
+        MP_WritePhyUshort(sc, 0x15, 0x0152);
+        MP_WritePhyUshort(sc, 0x19, 0x4003);
+        MP_WritePhyUshort(sc, 0x15, 0x0153);
+        MP_WritePhyUshort(sc, 0x19, 0x4540);
+        MP_WritePhyUshort(sc, 0x15, 0x0154);
+        MP_WritePhyUshort(sc, 0x19, 0x9f00);
+        MP_WritePhyUshort(sc, 0x15, 0x0155);
+        MP_WritePhyUshort(sc, 0x19, 0x9d00);
+        MP_WritePhyUshort(sc, 0x15, 0x0156);
+        MP_WritePhyUshort(sc, 0x19, 0x7c40);
+        MP_WritePhyUshort(sc, 0x15, 0x0157);
+        MP_WritePhyUshort(sc, 0x19, 0x6421);
+        MP_WritePhyUshort(sc, 0x15, 0x0158);
+        MP_WritePhyUshort(sc, 0x19, 0x7c80);
+        MP_WritePhyUshort(sc, 0x15, 0x0159);
+        MP_WritePhyUshort(sc, 0x19, 0x64a1);
+        MP_WritePhyUshort(sc, 0x15, 0x015a);
+        MP_WritePhyUshort(sc, 0x19, 0x30fe);
+        MP_WritePhyUshort(sc, 0x15, 0x021e);
+        MP_WritePhyUshort(sc, 0x19, 0x5410);
+        MP_WritePhyUshort(sc, 0x15, 0x0225);
+        MP_WritePhyUshort(sc, 0x19, 0x5400);
+        MP_WritePhyUshort(sc, 0x15, 0x023D);
+        MP_WritePhyUshort(sc, 0x19, 0x4050);
+        MP_WritePhyUshort(sc, 0x15, 0x0295);
+        MP_WritePhyUshort(sc, 0x19, 0x6c08);
+        MP_WritePhyUshort(sc, 0x15, 0x02bd);
+        MP_WritePhyUshort(sc, 0x19, 0xa523);
+        MP_WritePhyUshort(sc, 0x15, 0x02be);
+        MP_WritePhyUshort(sc, 0x19, 0x32ca);
+        MP_WritePhyUshort(sc, 0x15, 0x02ca);
+        MP_WritePhyUshort(sc, 0x19, 0x48b3);
+        MP_WritePhyUshort(sc, 0x15, 0x02cb);
+        MP_WritePhyUshort(sc, 0x19, 0x4020);
+        MP_WritePhyUshort(sc, 0x15, 0x02cc);
+        MP_WritePhyUshort(sc, 0x19, 0x4823);
+        MP_WritePhyUshort(sc, 0x15, 0x02cd);
+        MP_WritePhyUshort(sc, 0x19, 0x4510);
+        MP_WritePhyUshort(sc, 0x15, 0x02ce);
+        MP_WritePhyUshort(sc, 0x19, 0xb63a);
+        MP_WritePhyUshort(sc, 0x15, 0x02cf);
+        MP_WritePhyUshort(sc, 0x19, 0x7dc8);
+        MP_WritePhyUshort(sc, 0x15, 0x02d6);
+        MP_WritePhyUshort(sc, 0x19, 0x9bf8);
+        MP_WritePhyUshort(sc, 0x15, 0x02d8);
+        MP_WritePhyUshort(sc, 0x19, 0x85f6);
+        MP_WritePhyUshort(sc, 0x15, 0x02d9);
+        MP_WritePhyUshort(sc, 0x19, 0x32e0);
+        MP_WritePhyUshort(sc, 0x15, 0x02e0);
+        MP_WritePhyUshort(sc, 0x19, 0x4834);
+        MP_WritePhyUshort(sc, 0x15, 0x02e1);
+        MP_WritePhyUshort(sc, 0x19, 0x6c08);
+        MP_WritePhyUshort(sc, 0x15, 0x02e2);
+        MP_WritePhyUshort(sc, 0x19, 0x4020);
+        MP_WritePhyUshort(sc, 0x15, 0x02e3);
+        MP_WritePhyUshort(sc, 0x19, 0x4824);
+        MP_WritePhyUshort(sc, 0x15, 0x02e4);
+        MP_WritePhyUshort(sc, 0x19, 0x4520);
+        MP_WritePhyUshort(sc, 0x15, 0x02e5);
+        MP_WritePhyUshort(sc, 0x19, 0x4008);
+        MP_WritePhyUshort(sc, 0x15, 0x02e6);
+        MP_WritePhyUshort(sc, 0x19, 0x4560);
+        MP_WritePhyUshort(sc, 0x15, 0x02e7);
+        MP_WritePhyUshort(sc, 0x19, 0x9d04);
+        MP_WritePhyUshort(sc, 0x15, 0x02e8);
+        MP_WritePhyUshort(sc, 0x19, 0x48c4);
+        MP_WritePhyUshort(sc, 0x15, 0x02e9);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x02ea);
+        MP_WritePhyUshort(sc, 0x19, 0x4844);
+        MP_WritePhyUshort(sc, 0x15, 0x02eb);
+        MP_WritePhyUshort(sc, 0x19, 0x7dc8);
+        MP_WritePhyUshort(sc, 0x15, 0x02f0);
+        MP_WritePhyUshort(sc, 0x19, 0x9cf7);
+        MP_WritePhyUshort(sc, 0x15, 0x02f1);
+        MP_WritePhyUshort(sc, 0x19, 0xdf94);
+        MP_WritePhyUshort(sc, 0x15, 0x02f2);
+        MP_WritePhyUshort(sc, 0x19, 0x0002);
+        MP_WritePhyUshort(sc, 0x15, 0x02f3);
+        MP_WritePhyUshort(sc, 0x19, 0x6810);
+        MP_WritePhyUshort(sc, 0x15, 0x02f4);
+        MP_WritePhyUshort(sc, 0x19, 0xb614);
+        MP_WritePhyUshort(sc, 0x15, 0x02f5);
+        MP_WritePhyUshort(sc, 0x19, 0xc42b);
+        MP_WritePhyUshort(sc, 0x15, 0x02f6);
+        MP_WritePhyUshort(sc, 0x19, 0x00d4);
+        MP_WritePhyUshort(sc, 0x15, 0x02f7);
+        MP_WritePhyUshort(sc, 0x19, 0xc455);
+        MP_WritePhyUshort(sc, 0x15, 0x02f8);
+        MP_WritePhyUshort(sc, 0x19, 0x0093);
+        MP_WritePhyUshort(sc, 0x15, 0x02f9);
+        MP_WritePhyUshort(sc, 0x19, 0x92ee);
+        MP_WritePhyUshort(sc, 0x15, 0x02fa);
+        MP_WritePhyUshort(sc, 0x19, 0xefed);
+        MP_WritePhyUshort(sc, 0x15, 0x02fb);
+        MP_WritePhyUshort(sc, 0x19, 0x3312);
+        MP_WritePhyUshort(sc, 0x15, 0x0312);
+        MP_WritePhyUshort(sc, 0x19, 0x49b5);
+        MP_WritePhyUshort(sc, 0x15, 0x0313);
+        MP_WritePhyUshort(sc, 0x19, 0x7d00);
+        MP_WritePhyUshort(sc, 0x15, 0x0314);
+        MP_WritePhyUshort(sc, 0x19, 0x4d00);
+        MP_WritePhyUshort(sc, 0x15, 0x0315);
+        MP_WritePhyUshort(sc, 0x19, 0x6810);
+        MP_WritePhyUshort(sc, 0x15, 0x031e);
+        MP_WritePhyUshort(sc, 0x19, 0x404f);
+        MP_WritePhyUshort(sc, 0x15, 0x031f);
+        MP_WritePhyUshort(sc, 0x19, 0x44c8);
+        MP_WritePhyUshort(sc, 0x15, 0x0320);
+        MP_WritePhyUshort(sc, 0x19, 0xd64f);
+        MP_WritePhyUshort(sc, 0x15, 0x0321);
+        MP_WritePhyUshort(sc, 0x19, 0x00e7);
+        MP_WritePhyUshort(sc, 0x15, 0x0322);
+        MP_WritePhyUshort(sc, 0x19, 0x7c08);
+        MP_WritePhyUshort(sc, 0x15, 0x0323);
+        MP_WritePhyUshort(sc, 0x19, 0x8203);
+        MP_WritePhyUshort(sc, 0x15, 0x0324);
+        MP_WritePhyUshort(sc, 0x19, 0x4d48);
+        MP_WritePhyUshort(sc, 0x15, 0x0325);
+        MP_WritePhyUshort(sc, 0x19, 0x3327);
+        MP_WritePhyUshort(sc, 0x15, 0x0326);
+        MP_WritePhyUshort(sc, 0x19, 0x4d40);
+        MP_WritePhyUshort(sc, 0x15, 0x0327);
+        MP_WritePhyUshort(sc, 0x19, 0xc8d7);
+        MP_WritePhyUshort(sc, 0x15, 0x0328);
+        MP_WritePhyUshort(sc, 0x19, 0x0003);
+        MP_WritePhyUshort(sc, 0x15, 0x0329);
+        MP_WritePhyUshort(sc, 0x19, 0x7c20);
+        MP_WritePhyUshort(sc, 0x15, 0x032a);
+        MP_WritePhyUshort(sc, 0x19, 0x4c20);
+        MP_WritePhyUshort(sc, 0x15, 0x032b);
+        MP_WritePhyUshort(sc, 0x19, 0xc8ed);
+        MP_WritePhyUshort(sc, 0x15, 0x032c);
+        MP_WritePhyUshort(sc, 0x19, 0x00f4);
+        MP_WritePhyUshort(sc, 0x15, 0x032d);
+        MP_WritePhyUshort(sc, 0x19, 0x82b3);
+        MP_WritePhyUshort(sc, 0x15, 0x032e);
+        MP_WritePhyUshort(sc, 0x19, 0xd11d);
+        MP_WritePhyUshort(sc, 0x15, 0x032f);
+        MP_WritePhyUshort(sc, 0x19, 0x00b1);
+        MP_WritePhyUshort(sc, 0x15, 0x0330);
+        MP_WritePhyUshort(sc, 0x19, 0xde18);
+        MP_WritePhyUshort(sc, 0x15, 0x0331);
+        MP_WritePhyUshort(sc, 0x19, 0x0008);
+        MP_WritePhyUshort(sc, 0x15, 0x0332);
+        MP_WritePhyUshort(sc, 0x19, 0x91ee);
+        MP_WritePhyUshort(sc, 0x15, 0x0333);
+        MP_WritePhyUshort(sc, 0x19, 0x3339);
+        MP_WritePhyUshort(sc, 0x15, 0x033a);
+        MP_WritePhyUshort(sc, 0x19, 0x4064);
+        MP_WritePhyUshort(sc, 0x15, 0x0340);
+        MP_WritePhyUshort(sc, 0x19, 0x9e06);
+        MP_WritePhyUshort(sc, 0x15, 0x0341);
+        MP_WritePhyUshort(sc, 0x19, 0x7c08);
+        MP_WritePhyUshort(sc, 0x15, 0x0342);
+        MP_WritePhyUshort(sc, 0x19, 0x8203);
+        MP_WritePhyUshort(sc, 0x15, 0x0343);
+        MP_WritePhyUshort(sc, 0x19, 0x4d48);
+        MP_WritePhyUshort(sc, 0x15, 0x0344);
+        MP_WritePhyUshort(sc, 0x19, 0x3346);
+        MP_WritePhyUshort(sc, 0x15, 0x0345);
+        MP_WritePhyUshort(sc, 0x19, 0x4d40);
+        MP_WritePhyUshort(sc, 0x15, 0x0346);
+        MP_WritePhyUshort(sc, 0x19, 0xd11d);
+        MP_WritePhyUshort(sc, 0x15, 0x0347);
+        MP_WritePhyUshort(sc, 0x19, 0x0099);
+        MP_WritePhyUshort(sc, 0x15, 0x0348);
+        MP_WritePhyUshort(sc, 0x19, 0xbb17);
+        MP_WritePhyUshort(sc, 0x15, 0x0349);
+        MP_WritePhyUshort(sc, 0x19, 0x8102);
+        MP_WritePhyUshort(sc, 0x15, 0x034a);
+        MP_WritePhyUshort(sc, 0x19, 0x334d);
+        MP_WritePhyUshort(sc, 0x15, 0x034b);
+        MP_WritePhyUshort(sc, 0x19, 0xa22c);
+        MP_WritePhyUshort(sc, 0x15, 0x034c);
+        MP_WritePhyUshort(sc, 0x19, 0x3397);
+        MP_WritePhyUshort(sc, 0x15, 0x034d);
+        MP_WritePhyUshort(sc, 0x19, 0x91f2);
+        MP_WritePhyUshort(sc, 0x15, 0x034e);
+        MP_WritePhyUshort(sc, 0x19, 0xc218);
+        MP_WritePhyUshort(sc, 0x15, 0x034f);
+        MP_WritePhyUshort(sc, 0x19, 0x00f0);
+        MP_WritePhyUshort(sc, 0x15, 0x0350);
+        MP_WritePhyUshort(sc, 0x19, 0x3397);
+        MP_WritePhyUshort(sc, 0x15, 0x0351);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0364);
+        MP_WritePhyUshort(sc, 0x19, 0xbc05);
+        MP_WritePhyUshort(sc, 0x15, 0x0367);
+        MP_WritePhyUshort(sc, 0x19, 0xa1fc);
+        MP_WritePhyUshort(sc, 0x15, 0x0368);
+        MP_WritePhyUshort(sc, 0x19, 0x3377);
+        MP_WritePhyUshort(sc, 0x15, 0x0369);
+        MP_WritePhyUshort(sc, 0x19, 0x328b);
+        MP_WritePhyUshort(sc, 0x15, 0x036a);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0377);
+        MP_WritePhyUshort(sc, 0x19, 0x4b97);
+        MP_WritePhyUshort(sc, 0x15, 0x0378);
+        MP_WritePhyUshort(sc, 0x19, 0x6818);
+        MP_WritePhyUshort(sc, 0x15, 0x0379);
+        MP_WritePhyUshort(sc, 0x19, 0x4b07);
+        MP_WritePhyUshort(sc, 0x15, 0x037a);
+        MP_WritePhyUshort(sc, 0x19, 0x40ac);
+        MP_WritePhyUshort(sc, 0x15, 0x037b);
+        MP_WritePhyUshort(sc, 0x19, 0x4445);
+        MP_WritePhyUshort(sc, 0x15, 0x037c);
+        MP_WritePhyUshort(sc, 0x19, 0x404e);
+        MP_WritePhyUshort(sc, 0x15, 0x037d);
+        MP_WritePhyUshort(sc, 0x19, 0x4461);
+        MP_WritePhyUshort(sc, 0x15, 0x037e);
+        MP_WritePhyUshort(sc, 0x19, 0x9c09);
+        MP_WritePhyUshort(sc, 0x15, 0x037f);
+        MP_WritePhyUshort(sc, 0x19, 0x63da);
+        MP_WritePhyUshort(sc, 0x15, 0x0380);
+        MP_WritePhyUshort(sc, 0x19, 0x5440);
+        MP_WritePhyUshort(sc, 0x15, 0x0381);
+        MP_WritePhyUshort(sc, 0x19, 0x4b98);
+        MP_WritePhyUshort(sc, 0x15, 0x0382);
+        MP_WritePhyUshort(sc, 0x19, 0x7c60);
+        MP_WritePhyUshort(sc, 0x15, 0x0383);
+        MP_WritePhyUshort(sc, 0x19, 0x4c00);
+        MP_WritePhyUshort(sc, 0x15, 0x0384);
+        MP_WritePhyUshort(sc, 0x19, 0x4b08);
+        MP_WritePhyUshort(sc, 0x15, 0x0385);
+        MP_WritePhyUshort(sc, 0x19, 0x63d8);
+        MP_WritePhyUshort(sc, 0x15, 0x0386);
+        MP_WritePhyUshort(sc, 0x19, 0x338d);
+        MP_WritePhyUshort(sc, 0x15, 0x0387);
+        MP_WritePhyUshort(sc, 0x19, 0xd64f);
+        MP_WritePhyUshort(sc, 0x15, 0x0388);
+        MP_WritePhyUshort(sc, 0x19, 0x0080);
+        MP_WritePhyUshort(sc, 0x15, 0x0389);
+        MP_WritePhyUshort(sc, 0x19, 0x820c);
+        MP_WritePhyUshort(sc, 0x15, 0x038a);
+        MP_WritePhyUshort(sc, 0x19, 0xa10b);
+        MP_WritePhyUshort(sc, 0x15, 0x038b);
+        MP_WritePhyUshort(sc, 0x19, 0x9df3);
+        MP_WritePhyUshort(sc, 0x15, 0x038c);
+        MP_WritePhyUshort(sc, 0x19, 0x3395);
+        MP_WritePhyUshort(sc, 0x15, 0x038d);
+        MP_WritePhyUshort(sc, 0x19, 0xd64f);
+        MP_WritePhyUshort(sc, 0x15, 0x038e);
+        MP_WritePhyUshort(sc, 0x19, 0x00f9);
+        MP_WritePhyUshort(sc, 0x15, 0x038f);
+        MP_WritePhyUshort(sc, 0x19, 0xc017);
+        MP_WritePhyUshort(sc, 0x15, 0x0390);
+        MP_WritePhyUshort(sc, 0x19, 0x0005);
+        MP_WritePhyUshort(sc, 0x15, 0x0391);
+        MP_WritePhyUshort(sc, 0x19, 0x6c0b);
+        MP_WritePhyUshort(sc, 0x15, 0x0392);
+        MP_WritePhyUshort(sc, 0x19, 0xa103);
+        MP_WritePhyUshort(sc, 0x15, 0x0393);
+        MP_WritePhyUshort(sc, 0x19, 0x6c08);
+        MP_WritePhyUshort(sc, 0x15, 0x0394);
+        MP_WritePhyUshort(sc, 0x19, 0x9df9);
+        MP_WritePhyUshort(sc, 0x15, 0x0395);
+        MP_WritePhyUshort(sc, 0x19, 0x6c08);
+        MP_WritePhyUshort(sc, 0x15, 0x0396);
+        MP_WritePhyUshort(sc, 0x19, 0x3397);
+        MP_WritePhyUshort(sc, 0x15, 0x0399);
+        MP_WritePhyUshort(sc, 0x19, 0x6810);
+        MP_WritePhyUshort(sc, 0x15, 0x03a4);
+        MP_WritePhyUshort(sc, 0x19, 0x7c08);
+        MP_WritePhyUshort(sc, 0x15, 0x03a5);
+        MP_WritePhyUshort(sc, 0x19, 0x8203);
+        MP_WritePhyUshort(sc, 0x15, 0x03a6);
+        MP_WritePhyUshort(sc, 0x19, 0x4d08);
+        MP_WritePhyUshort(sc, 0x15, 0x03a7);
+        MP_WritePhyUshort(sc, 0x19, 0x33a9);
+        MP_WritePhyUshort(sc, 0x15, 0x03a8);
+        MP_WritePhyUshort(sc, 0x19, 0x4d00);
+        MP_WritePhyUshort(sc, 0x15, 0x03a9);
+        MP_WritePhyUshort(sc, 0x19, 0x9bfa);
+        MP_WritePhyUshort(sc, 0x15, 0x03aa);
+        MP_WritePhyUshort(sc, 0x19, 0x33b6);
+        MP_WritePhyUshort(sc, 0x15, 0x03bb);
+        MP_WritePhyUshort(sc, 0x19, 0x4056);
+        MP_WritePhyUshort(sc, 0x15, 0x03bc);
+        MP_WritePhyUshort(sc, 0x19, 0x44e9);
+        MP_WritePhyUshort(sc, 0x15, 0x03bd);
+        MP_WritePhyUshort(sc, 0x19, 0x405e);
+        MP_WritePhyUshort(sc, 0x15, 0x03be);
+        MP_WritePhyUshort(sc, 0x19, 0x44f8);
+        MP_WritePhyUshort(sc, 0x15, 0x03bf);
+        MP_WritePhyUshort(sc, 0x19, 0xd64f);
+        MP_WritePhyUshort(sc, 0x15, 0x03c0);
+        MP_WritePhyUshort(sc, 0x19, 0x0037);
+        MP_WritePhyUshort(sc, 0x15, 0x03c1);
+        MP_WritePhyUshort(sc, 0x19, 0xbd37);
+        MP_WritePhyUshort(sc, 0x15, 0x03c2);
+        MP_WritePhyUshort(sc, 0x19, 0x9cfd);
+        MP_WritePhyUshort(sc, 0x15, 0x03c3);
+        MP_WritePhyUshort(sc, 0x19, 0xc639);
+        MP_WritePhyUshort(sc, 0x15, 0x03c4);
+        MP_WritePhyUshort(sc, 0x19, 0x0011);
+        MP_WritePhyUshort(sc, 0x15, 0x03c5);
+        MP_WritePhyUshort(sc, 0x19, 0x9b03);
+        MP_WritePhyUshort(sc, 0x15, 0x03c6);
+        MP_WritePhyUshort(sc, 0x19, 0x7c01);
+        MP_WritePhyUshort(sc, 0x15, 0x03c7);
+        MP_WritePhyUshort(sc, 0x19, 0x4c01);
+        MP_WritePhyUshort(sc, 0x15, 0x03c8);
+        MP_WritePhyUshort(sc, 0x19, 0x9e03);
+        MP_WritePhyUshort(sc, 0x15, 0x03c9);
+        MP_WritePhyUshort(sc, 0x19, 0x7c20);
+        MP_WritePhyUshort(sc, 0x15, 0x03ca);
+        MP_WritePhyUshort(sc, 0x19, 0x4c20);
+        MP_WritePhyUshort(sc, 0x15, 0x03cb);
+        MP_WritePhyUshort(sc, 0x19, 0x9af4);
+        MP_WritePhyUshort(sc, 0x15, 0x03cc);
+        MP_WritePhyUshort(sc, 0x19, 0x7c12);
+        MP_WritePhyUshort(sc, 0x15, 0x03cd);
+        MP_WritePhyUshort(sc, 0x19, 0x4c52);
+        MP_WritePhyUshort(sc, 0x15, 0x03ce);
+        MP_WritePhyUshort(sc, 0x19, 0x4470);
+        MP_WritePhyUshort(sc, 0x15, 0x03cf);
+        MP_WritePhyUshort(sc, 0x19, 0x7c12);
+        MP_WritePhyUshort(sc, 0x15, 0x03d0);
+        MP_WritePhyUshort(sc, 0x19, 0x4c40);
+        MP_WritePhyUshort(sc, 0x15, 0x03d1);
+        MP_WritePhyUshort(sc, 0x19, 0x33bf);
+        MP_WritePhyUshort(sc, 0x15, 0x03d6);
+        MP_WritePhyUshort(sc, 0x19, 0x4047);
+        MP_WritePhyUshort(sc, 0x15, 0x03d7);
+        MP_WritePhyUshort(sc, 0x19, 0x4469);
+        MP_WritePhyUshort(sc, 0x15, 0x03d8);
+        MP_WritePhyUshort(sc, 0x19, 0x492b);
+        MP_WritePhyUshort(sc, 0x15, 0x03d9);
+        MP_WritePhyUshort(sc, 0x19, 0x4479);
+        MP_WritePhyUshort(sc, 0x15, 0x03da);
+        MP_WritePhyUshort(sc, 0x19, 0x7c09);
+        MP_WritePhyUshort(sc, 0x15, 0x03db);
+        MP_WritePhyUshort(sc, 0x19, 0x8203);
+        MP_WritePhyUshort(sc, 0x15, 0x03dc);
+        MP_WritePhyUshort(sc, 0x19, 0x4d48);
+        MP_WritePhyUshort(sc, 0x15, 0x03dd);
+        MP_WritePhyUshort(sc, 0x19, 0x33df);
+        MP_WritePhyUshort(sc, 0x15, 0x03de);
+        MP_WritePhyUshort(sc, 0x19, 0x4d40);
+        MP_WritePhyUshort(sc, 0x15, 0x03df);
+        MP_WritePhyUshort(sc, 0x19, 0xd64f);
+        MP_WritePhyUshort(sc, 0x15, 0x03e0);
+        MP_WritePhyUshort(sc, 0x19, 0x0017);
+        MP_WritePhyUshort(sc, 0x15, 0x03e1);
+        MP_WritePhyUshort(sc, 0x19, 0xbd17);
+        MP_WritePhyUshort(sc, 0x15, 0x03e2);
+        MP_WritePhyUshort(sc, 0x19, 0x9b03);
+        MP_WritePhyUshort(sc, 0x15, 0x03e3);
+        MP_WritePhyUshort(sc, 0x19, 0x7c20);
+        MP_WritePhyUshort(sc, 0x15, 0x03e4);
+        MP_WritePhyUshort(sc, 0x19, 0x4c20);
+        MP_WritePhyUshort(sc, 0x15, 0x03e5);
+        MP_WritePhyUshort(sc, 0x19, 0x88f5);
+        MP_WritePhyUshort(sc, 0x15, 0x03e6);
+        MP_WritePhyUshort(sc, 0x19, 0xc428);
+        MP_WritePhyUshort(sc, 0x15, 0x03e7);
+        MP_WritePhyUshort(sc, 0x19, 0x0008);
+        MP_WritePhyUshort(sc, 0x15, 0x03e8);
+        MP_WritePhyUshort(sc, 0x19, 0x9af2);
+        MP_WritePhyUshort(sc, 0x15, 0x03e9);
+        MP_WritePhyUshort(sc, 0x19, 0x7c12);
+        MP_WritePhyUshort(sc, 0x15, 0x03ea);
+        MP_WritePhyUshort(sc, 0x19, 0x4c52);
+        MP_WritePhyUshort(sc, 0x15, 0x03eb);
+        MP_WritePhyUshort(sc, 0x19, 0x4470);
+        MP_WritePhyUshort(sc, 0x15, 0x03ec);
+        MP_WritePhyUshort(sc, 0x19, 0x7c12);
+        MP_WritePhyUshort(sc, 0x15, 0x03ed);
+        MP_WritePhyUshort(sc, 0x19, 0x4c40);
+        MP_WritePhyUshort(sc, 0x15, 0x03ee);
+        MP_WritePhyUshort(sc, 0x19, 0x33da);
+        MP_WritePhyUshort(sc, 0x15, 0x03ef);
+        MP_WritePhyUshort(sc, 0x19, 0x3312);
+        MP_WritePhyUshort(sc, 0x16, 0x0306);
+        MP_WritePhyUshort(sc, 0x16, 0x0300);
+        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+        MP_WritePhyUshort(sc, 0x17, 0x2179);
+        MP_WritePhyUshort(sc, 0x1f, 0x0007);
+        MP_WritePhyUshort(sc, 0x1e, 0x0040);
+        MP_WritePhyUshort(sc, 0x18, 0x0645);
+        MP_WritePhyUshort(sc, 0x19, 0xe200);
+        MP_WritePhyUshort(sc, 0x18, 0x0655);
+        MP_WritePhyUshort(sc, 0x19, 0x9000);
+        MP_WritePhyUshort(sc, 0x18, 0x0d05);
+        MP_WritePhyUshort(sc, 0x19, 0xbe00);
+        MP_WritePhyUshort(sc, 0x18, 0x0d15);
+        MP_WritePhyUshort(sc, 0x19, 0xd300);
+        MP_WritePhyUshort(sc, 0x18, 0x0d25);
+        MP_WritePhyUshort(sc, 0x19, 0xfe00);
+        MP_WritePhyUshort(sc, 0x18, 0x0d35);
+        MP_WritePhyUshort(sc, 0x19, 0x4000);
+        MP_WritePhyUshort(sc, 0x18, 0x0d45);
+        MP_WritePhyUshort(sc, 0x19, 0x7f00);
+        MP_WritePhyUshort(sc, 0x18, 0x0d55);
+        MP_WritePhyUshort(sc, 0x19, 0x1000);
+        MP_WritePhyUshort(sc, 0x18, 0x0d65);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x18, 0x0d75);
+        MP_WritePhyUshort(sc, 0x19, 0x8200);
+        MP_WritePhyUshort(sc, 0x18, 0x0d85);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x18, 0x0d95);
+        MP_WritePhyUshort(sc, 0x19, 0x7000);
+        MP_WritePhyUshort(sc, 0x18, 0x0da5);
+        MP_WritePhyUshort(sc, 0x19, 0x0f00);
+        MP_WritePhyUshort(sc, 0x18, 0x0db5);
+        MP_WritePhyUshort(sc, 0x19, 0x0100);
+        MP_WritePhyUshort(sc, 0x18, 0x0dc5);
+        MP_WritePhyUshort(sc, 0x19, 0x9b00);
+        MP_WritePhyUshort(sc, 0x18, 0x0dd5);
+        MP_WritePhyUshort(sc, 0x19, 0x7f00);
+        MP_WritePhyUshort(sc, 0x18, 0x0de5);
+        MP_WritePhyUshort(sc, 0x19, 0xe000);
+        MP_WritePhyUshort(sc, 0x18, 0x0df5);
+        MP_WritePhyUshort(sc, 0x19, 0xef00);
+        MP_WritePhyUshort(sc, 0x18, 0x16d5);
+        MP_WritePhyUshort(sc, 0x19, 0xe200);
+        MP_WritePhyUshort(sc, 0x18, 0x16e5);
+        MP_WritePhyUshort(sc, 0x19, 0xab00);
+        MP_WritePhyUshort(sc, 0x18, 0x2904);
+        MP_WritePhyUshort(sc, 0x19, 0x4000);
+        MP_WritePhyUshort(sc, 0x18, 0x2914);
+        MP_WritePhyUshort(sc, 0x19, 0x7f00);
+        MP_WritePhyUshort(sc, 0x18, 0x2924);
+        MP_WritePhyUshort(sc, 0x19, 0x0100);
+        MP_WritePhyUshort(sc, 0x18, 0x2934);
+        MP_WritePhyUshort(sc, 0x19, 0x2000);
+        MP_WritePhyUshort(sc, 0x18, 0x2944);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x18, 0x2954);
+        MP_WritePhyUshort(sc, 0x19, 0x4600);
+        MP_WritePhyUshort(sc, 0x18, 0x2964);
+        MP_WritePhyUshort(sc, 0x19, 0xfc00);
+        MP_WritePhyUshort(sc, 0x18, 0x2974);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x18, 0x2984);
+        MP_WritePhyUshort(sc, 0x19, 0x5000);
+        MP_WritePhyUshort(sc, 0x18, 0x2994);
+        MP_WritePhyUshort(sc, 0x19, 0x9d00);
+        MP_WritePhyUshort(sc, 0x18, 0x29a4);
+        MP_WritePhyUshort(sc, 0x19, 0xff00);
+        MP_WritePhyUshort(sc, 0x18, 0x29b4);
+        MP_WritePhyUshort(sc, 0x19, 0x4000);
+        MP_WritePhyUshort(sc, 0x18, 0x29c4);
+        MP_WritePhyUshort(sc, 0x19, 0x7f00);
+        MP_WritePhyUshort(sc, 0x18, 0x29d4);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x18, 0x29e4);
+        MP_WritePhyUshort(sc, 0x19, 0x2000);
+        MP_WritePhyUshort(sc, 0x18, 0x29f4);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x18, 0x2a04);
+        MP_WritePhyUshort(sc, 0x19, 0xe600);
+        MP_WritePhyUshort(sc, 0x18, 0x2a14);
+        MP_WritePhyUshort(sc, 0x19, 0xff00);
+        MP_WritePhyUshort(sc, 0x18, 0x2a24);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x18, 0x2a34);
+        MP_WritePhyUshort(sc, 0x19, 0x5000);
+        MP_WritePhyUshort(sc, 0x18, 0x2a44);
+        MP_WritePhyUshort(sc, 0x19, 0x8500);
+        MP_WritePhyUshort(sc, 0x18, 0x2a54);
+        MP_WritePhyUshort(sc, 0x19, 0x7f00);
+        MP_WritePhyUshort(sc, 0x18, 0x2a64);
+        MP_WritePhyUshort(sc, 0x19, 0xac00);
+        MP_WritePhyUshort(sc, 0x18, 0x2a74);
+        MP_WritePhyUshort(sc, 0x19, 0x0800);
+        MP_WritePhyUshort(sc, 0x18, 0x2a84);
+        MP_WritePhyUshort(sc, 0x19, 0xfc00);
+        MP_WritePhyUshort(sc, 0x18, 0x2a94);
+        MP_WritePhyUshort(sc, 0x19, 0xe000);
+        MP_WritePhyUshort(sc, 0x18, 0x2aa4);
+        MP_WritePhyUshort(sc, 0x19, 0x7400);
+        MP_WritePhyUshort(sc, 0x18, 0x2ab4);
+        MP_WritePhyUshort(sc, 0x19, 0x4000);
+        MP_WritePhyUshort(sc, 0x18, 0x2ac4);
+        MP_WritePhyUshort(sc, 0x19, 0x7f00);
+        MP_WritePhyUshort(sc, 0x18, 0x2ad4);
+        MP_WritePhyUshort(sc, 0x19, 0x0100);
+        MP_WritePhyUshort(sc, 0x18, 0x2ae4);
+        MP_WritePhyUshort(sc, 0x19, 0xff00);
+        MP_WritePhyUshort(sc, 0x18, 0x2af4);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x18, 0x2b04);
+        MP_WritePhyUshort(sc, 0x19, 0x4400);
+        MP_WritePhyUshort(sc, 0x18, 0x2b14);
+        MP_WritePhyUshort(sc, 0x19, 0xfc00);
+        MP_WritePhyUshort(sc, 0x18, 0x2b24);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x18, 0x2b34);
+        MP_WritePhyUshort(sc, 0x19, 0x4000);
+        MP_WritePhyUshort(sc, 0x18, 0x2b44);
+        MP_WritePhyUshort(sc, 0x19, 0x9d00);
+        MP_WritePhyUshort(sc, 0x18, 0x2b54);
+        MP_WritePhyUshort(sc, 0x19, 0xff00);
+        MP_WritePhyUshort(sc, 0x18, 0x2b64);
+        MP_WritePhyUshort(sc, 0x19, 0x4000);
+        MP_WritePhyUshort(sc, 0x18, 0x2b74);
+        MP_WritePhyUshort(sc, 0x19, 0x7f00);
+        MP_WritePhyUshort(sc, 0x18, 0x2b84);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x18, 0x2b94);
+        MP_WritePhyUshort(sc, 0x19, 0xff00);
+        MP_WritePhyUshort(sc, 0x18, 0x2ba4);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x18, 0x2bb4);
+        MP_WritePhyUshort(sc, 0x19, 0xfc00);
+        MP_WritePhyUshort(sc, 0x18, 0x2bc4);
+        MP_WritePhyUshort(sc, 0x19, 0xff00);
+        MP_WritePhyUshort(sc, 0x18, 0x2bd4);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x18, 0x2be4);
+        MP_WritePhyUshort(sc, 0x19, 0x4000);
+        MP_WritePhyUshort(sc, 0x18, 0x2bf4);
+        MP_WritePhyUshort(sc, 0x19, 0x8900);
+        MP_WritePhyUshort(sc, 0x18, 0x2c04);
+        MP_WritePhyUshort(sc, 0x19, 0x8300);
+        MP_WritePhyUshort(sc, 0x18, 0x2c14);
+        MP_WritePhyUshort(sc, 0x19, 0xe000);
+        MP_WritePhyUshort(sc, 0x18, 0x2c24);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x18, 0x2c34);
+        MP_WritePhyUshort(sc, 0x19, 0xac00);
+        MP_WritePhyUshort(sc, 0x18, 0x2c44);
+        MP_WritePhyUshort(sc, 0x19, 0x0800);
+        MP_WritePhyUshort(sc, 0x18, 0x2c54);
+        MP_WritePhyUshort(sc, 0x19, 0xfa00);
+        MP_WritePhyUshort(sc, 0x18, 0x2c64);
+        MP_WritePhyUshort(sc, 0x19, 0xe100);
+        MP_WritePhyUshort(sc, 0x18, 0x2c74);
+        MP_WritePhyUshort(sc, 0x19, 0x7f00);
+        MP_WritePhyUshort(sc, 0x18, 0x0001);
+        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+        MP_WritePhyUshort(sc, 0x17, 0x2100);
+        MP_WritePhyUshort(sc, 0x1f, 0x0005);
+        MP_WritePhyUshort(sc, 0x05, 0xfff6);
+        MP_WritePhyUshort(sc, 0x06, 0x0080);
+        MP_WritePhyUshort(sc, 0x05, 0x8b88);
+        MP_WritePhyUshort(sc, 0x06, 0x0000);
+        MP_WritePhyUshort(sc, 0x06, 0x0000);
+        MP_WritePhyUshort(sc, 0x06, 0x0000);
+        MP_WritePhyUshort(sc, 0x06, 0x0000);
+        MP_WritePhyUshort(sc, 0x05, 0x8000);
+        MP_WritePhyUshort(sc, 0x06, 0xd480);
+        MP_WritePhyUshort(sc, 0x06, 0xc1e4);
+        MP_WritePhyUshort(sc, 0x06, 0x8b9a);
+        MP_WritePhyUshort(sc, 0x06, 0xe58b);
+        MP_WritePhyUshort(sc, 0x06, 0x9bee);
+        MP_WritePhyUshort(sc, 0x06, 0x8b83);
+        MP_WritePhyUshort(sc, 0x06, 0x41bf);
+        MP_WritePhyUshort(sc, 0x06, 0x8b88);
+        MP_WritePhyUshort(sc, 0x06, 0xec00);
+        MP_WritePhyUshort(sc, 0x06, 0x19a9);
+        MP_WritePhyUshort(sc, 0x06, 0x8b90);
+        MP_WritePhyUshort(sc, 0x06, 0xf9ee);
+        MP_WritePhyUshort(sc, 0x06, 0xfff6);
+        MP_WritePhyUshort(sc, 0x06, 0x00ee);
+        MP_WritePhyUshort(sc, 0x06, 0xfff7);
+        MP_WritePhyUshort(sc, 0x06, 0xffe0);
+        MP_WritePhyUshort(sc, 0x06, 0xe140);
+        MP_WritePhyUshort(sc, 0x06, 0xe1e1);
+        MP_WritePhyUshort(sc, 0x06, 0x41f7);
+        MP_WritePhyUshort(sc, 0x06, 0x2ff6);
+        MP_WritePhyUshort(sc, 0x06, 0x28e4);
+        MP_WritePhyUshort(sc, 0x06, 0xe140);
+        MP_WritePhyUshort(sc, 0x06, 0xe5e1);
+        MP_WritePhyUshort(sc, 0x06, 0x41f7);
+        MP_WritePhyUshort(sc, 0x06, 0x0002);
+        MP_WritePhyUshort(sc, 0x06, 0x020c);
+        MP_WritePhyUshort(sc, 0x06, 0x0202);
+        MP_WritePhyUshort(sc, 0x06, 0x1d02);
+        MP_WritePhyUshort(sc, 0x06, 0x0230);
+        MP_WritePhyUshort(sc, 0x06, 0x0202);
+        MP_WritePhyUshort(sc, 0x06, 0x4002);
+        MP_WritePhyUshort(sc, 0x06, 0x028b);
+        MP_WritePhyUshort(sc, 0x06, 0x0280);
+        MP_WritePhyUshort(sc, 0x06, 0x6c02);
+        MP_WritePhyUshort(sc, 0x06, 0x8085);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x88e1);
+        MP_WritePhyUshort(sc, 0x06, 0x8b89);
+        MP_WritePhyUshort(sc, 0x06, 0x1e01);
+        MP_WritePhyUshort(sc, 0x06, 0xe18b);
+        MP_WritePhyUshort(sc, 0x06, 0x8a1e);
+        MP_WritePhyUshort(sc, 0x06, 0x01e1);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8b);
+        MP_WritePhyUshort(sc, 0x06, 0x1e01);
+        MP_WritePhyUshort(sc, 0x06, 0xe18b);
+        MP_WritePhyUshort(sc, 0x06, 0x8c1e);
+        MP_WritePhyUshort(sc, 0x06, 0x01e1);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8d);
+        MP_WritePhyUshort(sc, 0x06, 0x1e01);
+        MP_WritePhyUshort(sc, 0x06, 0xe18b);
+        MP_WritePhyUshort(sc, 0x06, 0x8e1e);
+        MP_WritePhyUshort(sc, 0x06, 0x01a0);
+        MP_WritePhyUshort(sc, 0x06, 0x00c7);
+        MP_WritePhyUshort(sc, 0x06, 0xaec3);
+        MP_WritePhyUshort(sc, 0x06, 0xf8e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8d);
+        MP_WritePhyUshort(sc, 0x06, 0xad20);
+        MP_WritePhyUshort(sc, 0x06, 0x10ee);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8d);
+        MP_WritePhyUshort(sc, 0x06, 0x0002);
+        MP_WritePhyUshort(sc, 0x06, 0x1310);
+        MP_WritePhyUshort(sc, 0x06, 0x021f);
+        MP_WritePhyUshort(sc, 0x06, 0x9d02);
+        MP_WritePhyUshort(sc, 0x06, 0x1f0c);
+        MP_WritePhyUshort(sc, 0x06, 0x0227);
+        MP_WritePhyUshort(sc, 0x06, 0x49fc);
+        MP_WritePhyUshort(sc, 0x06, 0x04f8);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x8ead);
+        MP_WritePhyUshort(sc, 0x06, 0x200b);
+        MP_WritePhyUshort(sc, 0x06, 0xf620);
+        MP_WritePhyUshort(sc, 0x06, 0xe48b);
+        MP_WritePhyUshort(sc, 0x06, 0x8e02);
+        MP_WritePhyUshort(sc, 0x06, 0x830e);
+        MP_WritePhyUshort(sc, 0x06, 0x021b);
+        MP_WritePhyUshort(sc, 0x06, 0x67ad);
+        MP_WritePhyUshort(sc, 0x06, 0x2211);
+        MP_WritePhyUshort(sc, 0x06, 0xf622);
+        MP_WritePhyUshort(sc, 0x06, 0xe48b);
+        MP_WritePhyUshort(sc, 0x06, 0x8e02);
+        MP_WritePhyUshort(sc, 0x06, 0x2ba5);
+        MP_WritePhyUshort(sc, 0x06, 0x022a);
+        MP_WritePhyUshort(sc, 0x06, 0x2402);
+        MP_WritePhyUshort(sc, 0x06, 0x80c6);
+        MP_WritePhyUshort(sc, 0x06, 0x022a);
+        MP_WritePhyUshort(sc, 0x06, 0xf0ad);
+        MP_WritePhyUshort(sc, 0x06, 0x2511);
+        MP_WritePhyUshort(sc, 0x06, 0xf625);
+        MP_WritePhyUshort(sc, 0x06, 0xe48b);
+        MP_WritePhyUshort(sc, 0x06, 0x8e02);
+        MP_WritePhyUshort(sc, 0x06, 0x8226);
+        MP_WritePhyUshort(sc, 0x06, 0x0204);
+        MP_WritePhyUshort(sc, 0x06, 0x0302);
+        MP_WritePhyUshort(sc, 0x06, 0x19cc);
+        MP_WritePhyUshort(sc, 0x06, 0x022b);
+        MP_WritePhyUshort(sc, 0x06, 0x5bfc);
+        MP_WritePhyUshort(sc, 0x06, 0x04ee);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8d);
+        MP_WritePhyUshort(sc, 0x06, 0x0105);
+        MP_WritePhyUshort(sc, 0x06, 0xf8e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b83);
+        MP_WritePhyUshort(sc, 0x06, 0xad24);
+        MP_WritePhyUshort(sc, 0x06, 0x44e0);
+        MP_WritePhyUshort(sc, 0x06, 0xe022);
+        MP_WritePhyUshort(sc, 0x06, 0xe1e0);
+        MP_WritePhyUshort(sc, 0x06, 0x23ad);
+        MP_WritePhyUshort(sc, 0x06, 0x223b);
+        MP_WritePhyUshort(sc, 0x06, 0xe08a);
+        MP_WritePhyUshort(sc, 0x06, 0xbea0);
+        MP_WritePhyUshort(sc, 0x06, 0x0005);
+        MP_WritePhyUshort(sc, 0x06, 0x0228);
+        MP_WritePhyUshort(sc, 0x06, 0xdeae);
+        MP_WritePhyUshort(sc, 0x06, 0x42a0);
+        MP_WritePhyUshort(sc, 0x06, 0x0105);
+        MP_WritePhyUshort(sc, 0x06, 0x0228);
+        MP_WritePhyUshort(sc, 0x06, 0xf1ae);
+        MP_WritePhyUshort(sc, 0x06, 0x3aa0);
+        MP_WritePhyUshort(sc, 0x06, 0x0205);
+        MP_WritePhyUshort(sc, 0x06, 0x0281);
+        MP_WritePhyUshort(sc, 0x06, 0x25ae);
+        MP_WritePhyUshort(sc, 0x06, 0x32a0);
+        MP_WritePhyUshort(sc, 0x06, 0x0305);
+        MP_WritePhyUshort(sc, 0x06, 0x0229);
+        MP_WritePhyUshort(sc, 0x06, 0x9aae);
+        MP_WritePhyUshort(sc, 0x06, 0x2aa0);
+        MP_WritePhyUshort(sc, 0x06, 0x0405);
+        MP_WritePhyUshort(sc, 0x06, 0x0229);
+        MP_WritePhyUshort(sc, 0x06, 0xaeae);
+        MP_WritePhyUshort(sc, 0x06, 0x22a0);
+        MP_WritePhyUshort(sc, 0x06, 0x0505);
+        MP_WritePhyUshort(sc, 0x06, 0x0229);
+        MP_WritePhyUshort(sc, 0x06, 0xd7ae);
+        MP_WritePhyUshort(sc, 0x06, 0x1aa0);
+        MP_WritePhyUshort(sc, 0x06, 0x0605);
+        MP_WritePhyUshort(sc, 0x06, 0x0229);
+        MP_WritePhyUshort(sc, 0x06, 0xfeae);
+        MP_WritePhyUshort(sc, 0x06, 0x12ee);
+        MP_WritePhyUshort(sc, 0x06, 0x8ac0);
+        MP_WritePhyUshort(sc, 0x06, 0x00ee);
+        MP_WritePhyUshort(sc, 0x06, 0x8ac1);
+        MP_WritePhyUshort(sc, 0x06, 0x00ee);
+        MP_WritePhyUshort(sc, 0x06, 0x8ac6);
+        MP_WritePhyUshort(sc, 0x06, 0x00ee);
+        MP_WritePhyUshort(sc, 0x06, 0x8abe);
+        MP_WritePhyUshort(sc, 0x06, 0x00ae);
+        MP_WritePhyUshort(sc, 0x06, 0x00fc);
+        MP_WritePhyUshort(sc, 0x06, 0x04f8);
+        MP_WritePhyUshort(sc, 0x06, 0x022a);
+        MP_WritePhyUshort(sc, 0x06, 0x67e0);
+        MP_WritePhyUshort(sc, 0x06, 0xe022);
+        MP_WritePhyUshort(sc, 0x06, 0xe1e0);
+        MP_WritePhyUshort(sc, 0x06, 0x230d);
+        MP_WritePhyUshort(sc, 0x06, 0x0658);
+        MP_WritePhyUshort(sc, 0x06, 0x03a0);
+        MP_WritePhyUshort(sc, 0x06, 0x0202);
+        MP_WritePhyUshort(sc, 0x06, 0xae2d);
+        MP_WritePhyUshort(sc, 0x06, 0xa001);
+        MP_WritePhyUshort(sc, 0x06, 0x02ae);
+        MP_WritePhyUshort(sc, 0x06, 0x2da0);
+        MP_WritePhyUshort(sc, 0x06, 0x004d);
+        MP_WritePhyUshort(sc, 0x06, 0xe0e2);
+        MP_WritePhyUshort(sc, 0x06, 0x00e1);
+        MP_WritePhyUshort(sc, 0x06, 0xe201);
+        MP_WritePhyUshort(sc, 0x06, 0xad24);
+        MP_WritePhyUshort(sc, 0x06, 0x44e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8ac2);
+        MP_WritePhyUshort(sc, 0x06, 0xe48a);
+        MP_WritePhyUshort(sc, 0x06, 0xc4e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8ac3);
+        MP_WritePhyUshort(sc, 0x06, 0xe48a);
+        MP_WritePhyUshort(sc, 0x06, 0xc5ee);
+        MP_WritePhyUshort(sc, 0x06, 0x8abe);
+        MP_WritePhyUshort(sc, 0x06, 0x03e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b83);
+        MP_WritePhyUshort(sc, 0x06, 0xad25);
+        MP_WritePhyUshort(sc, 0x06, 0x3aee);
+        MP_WritePhyUshort(sc, 0x06, 0x8abe);
+        MP_WritePhyUshort(sc, 0x06, 0x05ae);
+        MP_WritePhyUshort(sc, 0x06, 0x34e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8ace);
+        MP_WritePhyUshort(sc, 0x06, 0xae03);
+        MP_WritePhyUshort(sc, 0x06, 0xe08a);
+        MP_WritePhyUshort(sc, 0x06, 0xcfe1);
+        MP_WritePhyUshort(sc, 0x06, 0x8ac2);
+        MP_WritePhyUshort(sc, 0x06, 0x4905);
+        MP_WritePhyUshort(sc, 0x06, 0xe58a);
+        MP_WritePhyUshort(sc, 0x06, 0xc4e1);
+        MP_WritePhyUshort(sc, 0x06, 0x8ac3);
+        MP_WritePhyUshort(sc, 0x06, 0x4905);
+        MP_WritePhyUshort(sc, 0x06, 0xe58a);
+        MP_WritePhyUshort(sc, 0x06, 0xc5ee);
+        MP_WritePhyUshort(sc, 0x06, 0x8abe);
+        MP_WritePhyUshort(sc, 0x06, 0x0502);
+        MP_WritePhyUshort(sc, 0x06, 0x2ab6);
+        MP_WritePhyUshort(sc, 0x06, 0xac20);
+        MP_WritePhyUshort(sc, 0x06, 0x1202);
+        MP_WritePhyUshort(sc, 0x06, 0x819b);
+        MP_WritePhyUshort(sc, 0x06, 0xac20);
+        MP_WritePhyUshort(sc, 0x06, 0x0cee);
+        MP_WritePhyUshort(sc, 0x06, 0x8ac1);
+        MP_WritePhyUshort(sc, 0x06, 0x00ee);
+        MP_WritePhyUshort(sc, 0x06, 0x8ac6);
+        MP_WritePhyUshort(sc, 0x06, 0x00ee);
+        MP_WritePhyUshort(sc, 0x06, 0x8abe);
+        MP_WritePhyUshort(sc, 0x06, 0x02fc);
+        MP_WritePhyUshort(sc, 0x06, 0x04d0);
+        MP_WritePhyUshort(sc, 0x06, 0x0002);
+        MP_WritePhyUshort(sc, 0x06, 0x81ad);
+        MP_WritePhyUshort(sc, 0x06, 0x590f);
+        MP_WritePhyUshort(sc, 0x06, 0x3902);
+        MP_WritePhyUshort(sc, 0x06, 0xaa04);
+        MP_WritePhyUshort(sc, 0x06, 0xd001);
+        MP_WritePhyUshort(sc, 0x06, 0xae02);
+        MP_WritePhyUshort(sc, 0x06, 0xd000);
+        MP_WritePhyUshort(sc, 0x06, 0x04f9);
+        MP_WritePhyUshort(sc, 0x06, 0xfae2);
+        MP_WritePhyUshort(sc, 0x06, 0xe2d2);
+        MP_WritePhyUshort(sc, 0x06, 0xe3e2);
+        MP_WritePhyUshort(sc, 0x06, 0xd3f9);
+        MP_WritePhyUshort(sc, 0x06, 0x5af7);
+        MP_WritePhyUshort(sc, 0x06, 0xe6e2);
+        MP_WritePhyUshort(sc, 0x06, 0xd2e7);
+        MP_WritePhyUshort(sc, 0x06, 0xe2d3);
+        MP_WritePhyUshort(sc, 0x06, 0xe2e0);
+        MP_WritePhyUshort(sc, 0x06, 0x2ce3);
+        MP_WritePhyUshort(sc, 0x06, 0xe02d);
+        MP_WritePhyUshort(sc, 0x06, 0xf95b);
+        MP_WritePhyUshort(sc, 0x06, 0xe01e);
+        MP_WritePhyUshort(sc, 0x06, 0x30e6);
+        MP_WritePhyUshort(sc, 0x06, 0xe02c);
+        MP_WritePhyUshort(sc, 0x06, 0xe7e0);
+        MP_WritePhyUshort(sc, 0x06, 0x2de2);
+        MP_WritePhyUshort(sc, 0x06, 0xe2cc);
+        MP_WritePhyUshort(sc, 0x06, 0xe3e2);
+        MP_WritePhyUshort(sc, 0x06, 0xcdf9);
+        MP_WritePhyUshort(sc, 0x06, 0x5a0f);
+        MP_WritePhyUshort(sc, 0x06, 0x6a50);
+        MP_WritePhyUshort(sc, 0x06, 0xe6e2);
+        MP_WritePhyUshort(sc, 0x06, 0xcce7);
+        MP_WritePhyUshort(sc, 0x06, 0xe2cd);
+        MP_WritePhyUshort(sc, 0x06, 0xe0e0);
+        MP_WritePhyUshort(sc, 0x06, 0x3ce1);
+        MP_WritePhyUshort(sc, 0x06, 0xe03d);
+        MP_WritePhyUshort(sc, 0x06, 0xef64);
+        MP_WritePhyUshort(sc, 0x06, 0xfde0);
+        MP_WritePhyUshort(sc, 0x06, 0xe2cc);
+        MP_WritePhyUshort(sc, 0x06, 0xe1e2);
+        MP_WritePhyUshort(sc, 0x06, 0xcd58);
+        MP_WritePhyUshort(sc, 0x06, 0x0f5a);
+        MP_WritePhyUshort(sc, 0x06, 0xf01e);
+        MP_WritePhyUshort(sc, 0x06, 0x02e4);
+        MP_WritePhyUshort(sc, 0x06, 0xe2cc);
+        MP_WritePhyUshort(sc, 0x06, 0xe5e2);
+        MP_WritePhyUshort(sc, 0x06, 0xcdfd);
+        MP_WritePhyUshort(sc, 0x06, 0xe0e0);
+        MP_WritePhyUshort(sc, 0x06, 0x2ce1);
+        MP_WritePhyUshort(sc, 0x06, 0xe02d);
+        MP_WritePhyUshort(sc, 0x06, 0x59e0);
+        MP_WritePhyUshort(sc, 0x06, 0x5b1f);
+        MP_WritePhyUshort(sc, 0x06, 0x1e13);
+        MP_WritePhyUshort(sc, 0x06, 0xe4e0);
+        MP_WritePhyUshort(sc, 0x06, 0x2ce5);
+        MP_WritePhyUshort(sc, 0x06, 0xe02d);
+        MP_WritePhyUshort(sc, 0x06, 0xfde0);
+        MP_WritePhyUshort(sc, 0x06, 0xe2d2);
+        MP_WritePhyUshort(sc, 0x06, 0xe1e2);
+        MP_WritePhyUshort(sc, 0x06, 0xd358);
+        MP_WritePhyUshort(sc, 0x06, 0xf75a);
+        MP_WritePhyUshort(sc, 0x06, 0x081e);
+        MP_WritePhyUshort(sc, 0x06, 0x02e4);
+        MP_WritePhyUshort(sc, 0x06, 0xe2d2);
+        MP_WritePhyUshort(sc, 0x06, 0xe5e2);
+        MP_WritePhyUshort(sc, 0x06, 0xd3ef);
+        MP_WritePhyUshort(sc, 0x06, 0x46fe);
+        MP_WritePhyUshort(sc, 0x06, 0xfd04);
+        MP_WritePhyUshort(sc, 0x06, 0xf8f9);
+        MP_WritePhyUshort(sc, 0x06, 0xfaef);
+        MP_WritePhyUshort(sc, 0x06, 0x69e0);
+        MP_WritePhyUshort(sc, 0x06, 0xe022);
+        MP_WritePhyUshort(sc, 0x06, 0xe1e0);
+        MP_WritePhyUshort(sc, 0x06, 0x2358);
+        MP_WritePhyUshort(sc, 0x06, 0xc4e1);
+        MP_WritePhyUshort(sc, 0x06, 0x8b6e);
+        MP_WritePhyUshort(sc, 0x06, 0x1f10);
+        MP_WritePhyUshort(sc, 0x06, 0x9e58);
+        MP_WritePhyUshort(sc, 0x06, 0xe48b);
+        MP_WritePhyUshort(sc, 0x06, 0x6ead);
+        MP_WritePhyUshort(sc, 0x06, 0x2222);
+        MP_WritePhyUshort(sc, 0x06, 0xac27);
+        MP_WritePhyUshort(sc, 0x06, 0x55ac);
+        MP_WritePhyUshort(sc, 0x06, 0x2602);
+        MP_WritePhyUshort(sc, 0x06, 0xae1a);
+        MP_WritePhyUshort(sc, 0x06, 0xd106);
+        MP_WritePhyUshort(sc, 0x06, 0xbf3b);
+        MP_WritePhyUshort(sc, 0x06, 0xba02);
+        MP_WritePhyUshort(sc, 0x06, 0x2dc1);
+        MP_WritePhyUshort(sc, 0x06, 0xd107);
+        MP_WritePhyUshort(sc, 0x06, 0xbf3b);
+        MP_WritePhyUshort(sc, 0x06, 0xbd02);
+        MP_WritePhyUshort(sc, 0x06, 0x2dc1);
+        MP_WritePhyUshort(sc, 0x06, 0xd107);
+        MP_WritePhyUshort(sc, 0x06, 0xbf3b);
+        MP_WritePhyUshort(sc, 0x06, 0xc002);
+        MP_WritePhyUshort(sc, 0x06, 0x2dc1);
+        MP_WritePhyUshort(sc, 0x06, 0xae30);
+        MP_WritePhyUshort(sc, 0x06, 0xd103);
+        MP_WritePhyUshort(sc, 0x06, 0xbf3b);
+        MP_WritePhyUshort(sc, 0x06, 0xc302);
+        MP_WritePhyUshort(sc, 0x06, 0x2dc1);
+        MP_WritePhyUshort(sc, 0x06, 0xd100);
+        MP_WritePhyUshort(sc, 0x06, 0xbf3b);
+        MP_WritePhyUshort(sc, 0x06, 0xc602);
+        MP_WritePhyUshort(sc, 0x06, 0x2dc1);
+        MP_WritePhyUshort(sc, 0x06, 0xd100);
+        MP_WritePhyUshort(sc, 0x06, 0xbf82);
+        MP_WritePhyUshort(sc, 0x06, 0xca02);
+        MP_WritePhyUshort(sc, 0x06, 0x2dc1);
+        MP_WritePhyUshort(sc, 0x06, 0xd10f);
+        MP_WritePhyUshort(sc, 0x06, 0xbf3b);
+        MP_WritePhyUshort(sc, 0x06, 0xba02);
+        MP_WritePhyUshort(sc, 0x06, 0x2dc1);
+        MP_WritePhyUshort(sc, 0x06, 0xd101);
+        MP_WritePhyUshort(sc, 0x06, 0xbf3b);
+        MP_WritePhyUshort(sc, 0x06, 0xbd02);
+        MP_WritePhyUshort(sc, 0x06, 0x2dc1);
+        MP_WritePhyUshort(sc, 0x06, 0xd101);
+        MP_WritePhyUshort(sc, 0x06, 0xbf3b);
+        MP_WritePhyUshort(sc, 0x06, 0xc002);
+        MP_WritePhyUshort(sc, 0x06, 0x2dc1);
+        MP_WritePhyUshort(sc, 0x06, 0xef96);
+        MP_WritePhyUshort(sc, 0x06, 0xfefd);
+        MP_WritePhyUshort(sc, 0x06, 0xfc04);
+        MP_WritePhyUshort(sc, 0x06, 0xd100);
+        MP_WritePhyUshort(sc, 0x06, 0xbf3b);
+        MP_WritePhyUshort(sc, 0x06, 0xc302);
+        MP_WritePhyUshort(sc, 0x06, 0x2dc1);
+        MP_WritePhyUshort(sc, 0x06, 0xd011);
+        MP_WritePhyUshort(sc, 0x06, 0x022b);
+        MP_WritePhyUshort(sc, 0x06, 0xfb59);
+        MP_WritePhyUshort(sc, 0x06, 0x03ef);
+        MP_WritePhyUshort(sc, 0x06, 0x01d1);
+        MP_WritePhyUshort(sc, 0x06, 0x00a0);
+        MP_WritePhyUshort(sc, 0x06, 0x0002);
+        MP_WritePhyUshort(sc, 0x06, 0xd101);
+        MP_WritePhyUshort(sc, 0x06, 0xbf3b);
+        MP_WritePhyUshort(sc, 0x06, 0xc602);
+        MP_WritePhyUshort(sc, 0x06, 0x2dc1);
+        MP_WritePhyUshort(sc, 0x06, 0xd111);
+        MP_WritePhyUshort(sc, 0x06, 0xad20);
+        MP_WritePhyUshort(sc, 0x06, 0x020c);
+        MP_WritePhyUshort(sc, 0x06, 0x11ad);
+        MP_WritePhyUshort(sc, 0x06, 0x2102);
+        MP_WritePhyUshort(sc, 0x06, 0x0c12);
+        MP_WritePhyUshort(sc, 0x06, 0xbf82);
+        MP_WritePhyUshort(sc, 0x06, 0xca02);
+        MP_WritePhyUshort(sc, 0x06, 0x2dc1);
+        MP_WritePhyUshort(sc, 0x06, 0xaec8);
+        MP_WritePhyUshort(sc, 0x06, 0x70e4);
+        MP_WritePhyUshort(sc, 0x06, 0x2602);
+        MP_WritePhyUshort(sc, 0x06, 0x82d1);
+        MP_WritePhyUshort(sc, 0x06, 0x05f8);
+        MP_WritePhyUshort(sc, 0x06, 0xfaef);
+        MP_WritePhyUshort(sc, 0x06, 0x69e0);
+        MP_WritePhyUshort(sc, 0x06, 0xe2fe);
+        MP_WritePhyUshort(sc, 0x06, 0xe1e2);
+        MP_WritePhyUshort(sc, 0x06, 0xffad);
+        MP_WritePhyUshort(sc, 0x06, 0x2d1a);
+        MP_WritePhyUshort(sc, 0x06, 0xe0e1);
+        MP_WritePhyUshort(sc, 0x06, 0x4ee1);
+        MP_WritePhyUshort(sc, 0x06, 0xe14f);
+        MP_WritePhyUshort(sc, 0x06, 0xac2d);
+        MP_WritePhyUshort(sc, 0x06, 0x22f6);
+        MP_WritePhyUshort(sc, 0x06, 0x0302);
+        MP_WritePhyUshort(sc, 0x06, 0x033b);
+        MP_WritePhyUshort(sc, 0x06, 0xf703);
+        MP_WritePhyUshort(sc, 0x06, 0xf706);
+        MP_WritePhyUshort(sc, 0x06, 0xbf84);
+        MP_WritePhyUshort(sc, 0x06, 0x4402);
+        MP_WritePhyUshort(sc, 0x06, 0x2d21);
+        MP_WritePhyUshort(sc, 0x06, 0xae11);
+        MP_WritePhyUshort(sc, 0x06, 0xe0e1);
+        MP_WritePhyUshort(sc, 0x06, 0x4ee1);
+        MP_WritePhyUshort(sc, 0x06, 0xe14f);
+        MP_WritePhyUshort(sc, 0x06, 0xad2d);
+        MP_WritePhyUshort(sc, 0x06, 0x08bf);
+        MP_WritePhyUshort(sc, 0x06, 0x844f);
+        MP_WritePhyUshort(sc, 0x06, 0x022d);
+        MP_WritePhyUshort(sc, 0x06, 0x21f6);
+        MP_WritePhyUshort(sc, 0x06, 0x06ef);
+        MP_WritePhyUshort(sc, 0x06, 0x96fe);
+        MP_WritePhyUshort(sc, 0x06, 0xfc04);
+        MP_WritePhyUshort(sc, 0x06, 0xf8fa);
+        MP_WritePhyUshort(sc, 0x06, 0xef69);
+        MP_WritePhyUshort(sc, 0x06, 0x0283);
+        MP_WritePhyUshort(sc, 0x06, 0x4502);
+        MP_WritePhyUshort(sc, 0x06, 0x83a2);
+        MP_WritePhyUshort(sc, 0x06, 0xe0e0);
+        MP_WritePhyUshort(sc, 0x06, 0x00e1);
+        MP_WritePhyUshort(sc, 0x06, 0xe001);
+        MP_WritePhyUshort(sc, 0x06, 0xad27);
+        MP_WritePhyUshort(sc, 0x06, 0x1fd1);
+        MP_WritePhyUshort(sc, 0x06, 0x01bf);
+        MP_WritePhyUshort(sc, 0x06, 0x843b);
+        MP_WritePhyUshort(sc, 0x06, 0x022d);
+        MP_WritePhyUshort(sc, 0x06, 0xc1e0);
+        MP_WritePhyUshort(sc, 0x06, 0xe020);
+        MP_WritePhyUshort(sc, 0x06, 0xe1e0);
+        MP_WritePhyUshort(sc, 0x06, 0x21ad);
+        MP_WritePhyUshort(sc, 0x06, 0x200e);
+        MP_WritePhyUshort(sc, 0x06, 0xd100);
+        MP_WritePhyUshort(sc, 0x06, 0xbf84);
+        MP_WritePhyUshort(sc, 0x06, 0x3b02);
+        MP_WritePhyUshort(sc, 0x06, 0x2dc1);
+        MP_WritePhyUshort(sc, 0x06, 0xbf3b);
+        MP_WritePhyUshort(sc, 0x06, 0x9602);
+        MP_WritePhyUshort(sc, 0x06, 0x2d21);
+        MP_WritePhyUshort(sc, 0x06, 0xef96);
+        MP_WritePhyUshort(sc, 0x06, 0xfefc);
+        MP_WritePhyUshort(sc, 0x06, 0x04f8);
+        MP_WritePhyUshort(sc, 0x06, 0xf9fa);
+        MP_WritePhyUshort(sc, 0x06, 0xef69);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x87ad);
+        MP_WritePhyUshort(sc, 0x06, 0x204c);
+        MP_WritePhyUshort(sc, 0x06, 0xd200);
+        MP_WritePhyUshort(sc, 0x06, 0xe0e2);
+        MP_WritePhyUshort(sc, 0x06, 0x0058);
+        MP_WritePhyUshort(sc, 0x06, 0x010c);
+        MP_WritePhyUshort(sc, 0x06, 0x021e);
+        MP_WritePhyUshort(sc, 0x06, 0x20e0);
+        MP_WritePhyUshort(sc, 0x06, 0xe000);
+        MP_WritePhyUshort(sc, 0x06, 0x5810);
+        MP_WritePhyUshort(sc, 0x06, 0x1e20);
+        MP_WritePhyUshort(sc, 0x06, 0xe0e0);
+        MP_WritePhyUshort(sc, 0x06, 0x3658);
+        MP_WritePhyUshort(sc, 0x06, 0x031e);
+        MP_WritePhyUshort(sc, 0x06, 0x20e0);
+        MP_WritePhyUshort(sc, 0x06, 0xe022);
+        MP_WritePhyUshort(sc, 0x06, 0xe1e0);
+        MP_WritePhyUshort(sc, 0x06, 0x2358);
+        MP_WritePhyUshort(sc, 0x06, 0xe01e);
+        MP_WritePhyUshort(sc, 0x06, 0x20e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b64);
+        MP_WritePhyUshort(sc, 0x06, 0x1f02);
+        MP_WritePhyUshort(sc, 0x06, 0x9e22);
+        MP_WritePhyUshort(sc, 0x06, 0xe68b);
+        MP_WritePhyUshort(sc, 0x06, 0x64ad);
+        MP_WritePhyUshort(sc, 0x06, 0x3214);
+        MP_WritePhyUshort(sc, 0x06, 0xad34);
+        MP_WritePhyUshort(sc, 0x06, 0x11ef);
+        MP_WritePhyUshort(sc, 0x06, 0x0258);
+        MP_WritePhyUshort(sc, 0x06, 0x039e);
+        MP_WritePhyUshort(sc, 0x06, 0x07ad);
+        MP_WritePhyUshort(sc, 0x06, 0x3508);
+        MP_WritePhyUshort(sc, 0x06, 0x5ac0);
+        MP_WritePhyUshort(sc, 0x06, 0x9f04);
+        MP_WritePhyUshort(sc, 0x06, 0xd101);
+        MP_WritePhyUshort(sc, 0x06, 0xae02);
+        MP_WritePhyUshort(sc, 0x06, 0xd100);
+        MP_WritePhyUshort(sc, 0x06, 0xbf84);
+        MP_WritePhyUshort(sc, 0x06, 0x3e02);
+        MP_WritePhyUshort(sc, 0x06, 0x2dc1);
+        MP_WritePhyUshort(sc, 0x06, 0xef96);
+        MP_WritePhyUshort(sc, 0x06, 0xfefd);
+        MP_WritePhyUshort(sc, 0x06, 0xfc04);
+        MP_WritePhyUshort(sc, 0x06, 0xf8f9);
+        MP_WritePhyUshort(sc, 0x06, 0xfbe0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b85);
+        MP_WritePhyUshort(sc, 0x06, 0xad25);
+        MP_WritePhyUshort(sc, 0x06, 0x22e0);
+        MP_WritePhyUshort(sc, 0x06, 0xe022);
+        MP_WritePhyUshort(sc, 0x06, 0xe1e0);
+        MP_WritePhyUshort(sc, 0x06, 0x23e2);
+        MP_WritePhyUshort(sc, 0x06, 0xe036);
+        MP_WritePhyUshort(sc, 0x06, 0xe3e0);
+        MP_WritePhyUshort(sc, 0x06, 0x375a);
+        MP_WritePhyUshort(sc, 0x06, 0xc40d);
+        MP_WritePhyUshort(sc, 0x06, 0x0158);
+        MP_WritePhyUshort(sc, 0x06, 0x021e);
+        MP_WritePhyUshort(sc, 0x06, 0x20e3);
+        MP_WritePhyUshort(sc, 0x06, 0x8ae7);
+        MP_WritePhyUshort(sc, 0x06, 0xac31);
+        MP_WritePhyUshort(sc, 0x06, 0x60ac);
+        MP_WritePhyUshort(sc, 0x06, 0x3a08);
+        MP_WritePhyUshort(sc, 0x06, 0xac3e);
+        MP_WritePhyUshort(sc, 0x06, 0x26ae);
+        MP_WritePhyUshort(sc, 0x06, 0x67af);
+        MP_WritePhyUshort(sc, 0x06, 0x8437);
+        MP_WritePhyUshort(sc, 0x06, 0xad37);
+        MP_WritePhyUshort(sc, 0x06, 0x61e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8ae8);
+        MP_WritePhyUshort(sc, 0x06, 0x10e4);
+        MP_WritePhyUshort(sc, 0x06, 0x8ae8);
+        MP_WritePhyUshort(sc, 0x06, 0xe18a);
+        MP_WritePhyUshort(sc, 0x06, 0xe91b);
+        MP_WritePhyUshort(sc, 0x06, 0x109e);
+        MP_WritePhyUshort(sc, 0x06, 0x02ae);
+        MP_WritePhyUshort(sc, 0x06, 0x51d1);
+        MP_WritePhyUshort(sc, 0x06, 0x00bf);
+        MP_WritePhyUshort(sc, 0x06, 0x8441);
+        MP_WritePhyUshort(sc, 0x06, 0x022d);
+        MP_WritePhyUshort(sc, 0x06, 0xc1ee);
+        MP_WritePhyUshort(sc, 0x06, 0x8ae8);
+        MP_WritePhyUshort(sc, 0x06, 0x00ae);
+        MP_WritePhyUshort(sc, 0x06, 0x43ad);
+        MP_WritePhyUshort(sc, 0x06, 0x3627);
+        MP_WritePhyUshort(sc, 0x06, 0xe08a);
+        MP_WritePhyUshort(sc, 0x06, 0xeee1);
+        MP_WritePhyUshort(sc, 0x06, 0x8aef);
+        MP_WritePhyUshort(sc, 0x06, 0xef74);
+        MP_WritePhyUshort(sc, 0x06, 0xe08a);
+        MP_WritePhyUshort(sc, 0x06, 0xeae1);
+        MP_WritePhyUshort(sc, 0x06, 0x8aeb);
+        MP_WritePhyUshort(sc, 0x06, 0x1b74);
+        MP_WritePhyUshort(sc, 0x06, 0x9e2e);
+        MP_WritePhyUshort(sc, 0x06, 0x14e4);
+        MP_WritePhyUshort(sc, 0x06, 0x8aea);
+        MP_WritePhyUshort(sc, 0x06, 0xe58a);
+        MP_WritePhyUshort(sc, 0x06, 0xebef);
+        MP_WritePhyUshort(sc, 0x06, 0x74e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8aee);
+        MP_WritePhyUshort(sc, 0x06, 0xe18a);
+        MP_WritePhyUshort(sc, 0x06, 0xef1b);
+        MP_WritePhyUshort(sc, 0x06, 0x479e);
+        MP_WritePhyUshort(sc, 0x06, 0x0fae);
+        MP_WritePhyUshort(sc, 0x06, 0x19ee);
+        MP_WritePhyUshort(sc, 0x06, 0x8aea);
+        MP_WritePhyUshort(sc, 0x06, 0x00ee);
+        MP_WritePhyUshort(sc, 0x06, 0x8aeb);
+        MP_WritePhyUshort(sc, 0x06, 0x00ae);
+        MP_WritePhyUshort(sc, 0x06, 0x0fac);
+        MP_WritePhyUshort(sc, 0x06, 0x390c);
+        MP_WritePhyUshort(sc, 0x06, 0xd101);
+        MP_WritePhyUshort(sc, 0x06, 0xbf84);
+        MP_WritePhyUshort(sc, 0x06, 0x4102);
+        MP_WritePhyUshort(sc, 0x06, 0x2dc1);
+        MP_WritePhyUshort(sc, 0x06, 0xee8a);
+        MP_WritePhyUshort(sc, 0x06, 0xe800);
+        MP_WritePhyUshort(sc, 0x06, 0xe68a);
+        MP_WritePhyUshort(sc, 0x06, 0xe7ff);
+        MP_WritePhyUshort(sc, 0x06, 0xfdfc);
+        MP_WritePhyUshort(sc, 0x06, 0x0400);
+        MP_WritePhyUshort(sc, 0x06, 0xe234);
+        MP_WritePhyUshort(sc, 0x06, 0xcce2);
+        MP_WritePhyUshort(sc, 0x06, 0x0088);
+        MP_WritePhyUshort(sc, 0x06, 0xe200);
+        MP_WritePhyUshort(sc, 0x06, 0xa725);
+        MP_WritePhyUshort(sc, 0x06, 0xe50a);
+        MP_WritePhyUshort(sc, 0x06, 0x1de5);
+        MP_WritePhyUshort(sc, 0x06, 0x0a2c);
+        MP_WritePhyUshort(sc, 0x06, 0xe50a);
+        MP_WritePhyUshort(sc, 0x06, 0x6de5);
+        MP_WritePhyUshort(sc, 0x06, 0x0a1d);
+        MP_WritePhyUshort(sc, 0x06, 0xe50a);
+        MP_WritePhyUshort(sc, 0x06, 0x1ce5);
+        MP_WritePhyUshort(sc, 0x06, 0x0a2d);
+        MP_WritePhyUshort(sc, 0x06, 0xa755);
+        MP_WritePhyUshort(sc, 0x05, 0x8b64);
+        MP_WritePhyUshort(sc, 0x06, 0x0000);
+        MP_WritePhyUshort(sc, 0x05, 0x8b94);
+        MP_WritePhyUshort(sc, 0x06, 0x82cd);
+        MP_WritePhyUshort(sc, 0x05, 0x8b85);
+        MP_WritePhyUshort(sc, 0x06, 0x2000);
+        MP_WritePhyUshort(sc, 0x05, 0x8aee);
+        MP_WritePhyUshort(sc, 0x06, 0x03b8);
+        MP_WritePhyUshort(sc, 0x05, 0x8ae8);
+        MP_WritePhyUshort(sc, 0x06, 0x0002);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x01);
+        PhyRegValue |= BIT_0;
+        MP_WritePhyUshort(sc, 0x01, PhyRegValue);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x00);
+        PhyRegValue |= BIT_0;
+        MP_WritePhyUshort(sc, 0x00, PhyRegValue);
+        MP_WritePhyUshort(sc, 0x1f, 0x0);
+        MP_WritePhyUshort(sc, 0x1f, 0x0005);
+        for (i=0; i<200; i++) {
+                DELAY(100);
+                PhyRegValue = MP_ReadPhyUshort(sc, 0x00);
+                if (PhyRegValue&0x0080)
+                        break;
+        }
+        MP_WritePhyUshort(sc, 0x1f, 0x0007);
+        MP_WritePhyUshort(sc, 0x1e, 0x0023);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
+        PhyRegValue &= ~(BIT_0);
+        if (sc->RequiredSecLanDonglePatch)
+                PhyRegValue &= ~(BIT_2);
+        MP_WritePhyUshort(sc, 0x17, PhyRegValue);
+        MP_WritePhyUshort(sc, 0x1f, 0x0007);
+        MP_WritePhyUshort(sc, 0x1e, 0x0028);
+        MP_WritePhyUshort(sc, 0x15, 0x0010);
+        MP_WritePhyUshort(sc, 0x1f, 0x0007);
+        MP_WritePhyUshort(sc, 0x1e, 0x0041);
+        MP_WritePhyUshort(sc, 0x15, 0x0802);
+        MP_WritePhyUshort(sc, 0x16, 0x2185);
+        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+}
 
-                MP_WritePhyUshort(sc, 0x03, 0xdf01);
-                MP_WritePhyUshort(sc, 0x02, 0xdf20);
-                MP_WritePhyUshort(sc, 0x01, 0x100a);
-                MP_WritePhyUshort(sc, 0x00, 0xa0ff);
-                MP_WritePhyUshort(sc, 0x04, 0xf800);
-                MP_WritePhyUshort(sc, 0x04, 0xf000);
+static void re_set_phy_mcu_8168e_2(struct re_softc *sc)
+{
+        u_int16_t PhyRegValue;
+        int	i;
 
+        if (MP_ReadEfuse(sc, 0x22) == 0x0c) {
                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                MP_WritePhyUshort(sc, 0x0b, 0x0000);
-                MP_WritePhyUshort(sc, 0x00, 0x9200);
-
-                CSR_WRITE_1(sc, 0x82, 0x0d);
-        } else if (sc->re_type == MACFG_4) {
-                MP_WritePhyUshort(sc, 0x1f, 0x0002);
-                MP_WritePhyUshort(sc, 0x01, 0x90D0);
+                MP_WritePhyUshort(sc, 0x00, 0x1800);
+                MP_WritePhyUshort(sc, 0x1f, 0x0007);
+                MP_WritePhyUshort(sc, 0x1e, 0x0023);
+                MP_WritePhyUshort(sc, 0x17, 0x0117);
+                MP_WritePhyUshort(sc, 0x1f, 0x0007);
+                MP_WritePhyUshort(sc, 0x1E, 0x002C);
+                MP_WritePhyUshort(sc, 0x1B, 0x5000);
                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                // MP_WritePhyUshort(sc, 0x1e, 0x8c00); /* PHY link down with some Giga switch */
-        } else if (sc->re_type == MACFG_5) {
-                MP_WritePhyUshort(sc, 0x1f, 0x0001);
-                MP_WritePhyUshort(sc, 0x04, 0x0000);
-                MP_WritePhyUshort(sc, 0x03, 0x00a1);
-                MP_WritePhyUshort(sc, 0x02, 0x0008);
-                MP_WritePhyUshort(sc, 0x01, 0x0120);
-                MP_WritePhyUshort(sc, 0x00, 0x1000);
-                MP_WritePhyUshort(sc, 0x04, 0x0800);
-
-                MP_WritePhyUshort(sc, 0x04, 0x9000);
-                MP_WritePhyUshort(sc, 0x03, 0x802f);
-                MP_WritePhyUshort(sc, 0x02, 0x4f02);
-                MP_WritePhyUshort(sc, 0x01, 0x0409);
-                MP_WritePhyUshort(sc, 0x00, 0xf099);
-                MP_WritePhyUshort(sc, 0x04, 0x9800);
-
-                MP_WritePhyUshort(sc, 0x04, 0xa000);
-                MP_WritePhyUshort(sc, 0x03, 0xdf01);
-                MP_WritePhyUshort(sc, 0x02, 0xdf20);
-                MP_WritePhyUshort(sc, 0x01, 0xff95);
-                MP_WritePhyUshort(sc, 0x00, 0xba00);
-                MP_WritePhyUshort(sc, 0x04, 0xa800);
-
-                MP_WritePhyUshort(sc, 0x04, 0xf000);
-                MP_WritePhyUshort(sc, 0x03, 0xdf01);
-                MP_WritePhyUshort(sc, 0x02, 0xdf20);
-                MP_WritePhyUshort(sc, 0x01, 0x101a);
-                MP_WritePhyUshort(sc, 0x00, 0xa0ff);
-                MP_WritePhyUshort(sc, 0x04, 0xf800);
-                MP_WritePhyUshort(sc, 0x04, 0x0000);
-                MP_WritePhyUshort(sc, 0x1f, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1f, 0x0001);
-                MP_WritePhyUshort(sc, 0x10, 0xf41b);
-                MP_WritePhyUshort(sc, 0x14, 0xfb54);
-                MP_WritePhyUshort(sc, 0x18, 0xf5c7);
-                MP_WritePhyUshort(sc, 0x1f, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1f, 0x0001);
-                MP_WritePhyUshort(sc, 0x17, 0x0CC0);
-                MP_WritePhyUshort(sc, 0x1f, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1f, 0x0001);
-                MP_WritePhyUshort(sc, 0x10, 0xf01b);
-
-        } else if (sc->re_type == MACFG_6) {
-                MP_WritePhyUshort(sc, 0x1f, 0x0001);
-                MP_WritePhyUshort(sc, 0x04, 0x0000);
-                MP_WritePhyUshort(sc, 0x03, 0x00a1);
-                MP_WritePhyUshort(sc, 0x02, 0x0008);
-                MP_WritePhyUshort(sc, 0x01, 0x0120);
-                MP_WritePhyUshort(sc, 0x00, 0x1000);
-                MP_WritePhyUshort(sc, 0x04, 0x0800);
-
-                MP_WritePhyUshort(sc, 0x04, 0x9000);
-                MP_WritePhyUshort(sc, 0x03, 0x802f);
-                MP_WritePhyUshort(sc, 0x02, 0x4f02);
-                MP_WritePhyUshort(sc, 0x01, 0x0409);
-                MP_WritePhyUshort(sc, 0x00, 0xf099);
-                MP_WritePhyUshort(sc, 0x04, 0x9800);
-
-                MP_WritePhyUshort(sc, 0x04, 0xa000);
-                MP_WritePhyUshort(sc, 0x03, 0xdf01);
-                MP_WritePhyUshort(sc, 0x02, 0xdf20);
-                MP_WritePhyUshort(sc, 0x01, 0xff95);
-                MP_WritePhyUshort(sc, 0x00, 0xba00);
-                MP_WritePhyUshort(sc, 0x04, 0xa800);
-
-                MP_WritePhyUshort(sc, 0x04, 0xf000);
-                MP_WritePhyUshort(sc, 0x03, 0xdf01);
-                MP_WritePhyUshort(sc, 0x02, 0xdf20);
-                MP_WritePhyUshort(sc, 0x01, 0x101a);
-                MP_WritePhyUshort(sc, 0x00, 0xa0ff);
-                MP_WritePhyUshort(sc, 0x04, 0xf800);
-                MP_WritePhyUshort(sc, 0x04, 0x0000);
-                MP_WritePhyUshort(sc, 0x1f, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1f, 0x0001);
-                MP_WritePhyUshort(sc, 0x0b, 0x8480);
-                MP_WritePhyUshort(sc, 0x1f, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1f, 0x0001);
-                MP_WritePhyUshort(sc, 0x18, 0x67c7);
-                MP_WritePhyUshort(sc, 0x04, 0x2000);
-                MP_WritePhyUshort(sc, 0x03, 0x002f);
-                MP_WritePhyUshort(sc, 0x02, 0x4360);
-                MP_WritePhyUshort(sc, 0x01, 0x0109);
-                MP_WritePhyUshort(sc, 0x00, 0x3022);
-                MP_WritePhyUshort(sc, 0x04, 0x2800);
-                MP_WritePhyUshort(sc, 0x1f, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1f, 0x0001);
-                MP_WritePhyUshort(sc, 0x17, 0x0CC0);
-        } else if (sc->re_type == MACFG_14) {
-                MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                MP_WritePhyUshort(sc, 0x11, MP_ReadPhyUshort(sc, 0x11) | 0x1000);
-                MP_WritePhyUshort(sc, 0x19, MP_ReadPhyUshort(sc, 0x19) | 0x2000);
-                MP_WritePhyUshort(sc, 0x10, MP_ReadPhyUshort(sc, 0x10) | 0x8000);
-
-                MP_WritePhyUshort(sc, 0x1f, 0x0003);
-                MP_WritePhyUshort(sc, 0x08, 0x441D);
-                MP_WritePhyUshort(sc, 0x01, 0x9100);
-        } else if (sc->re_type == MACFG_15) {
-                MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                MP_WritePhyUshort(sc, 0x11, MP_ReadPhyUshort(sc, 0x11) | 0x1000);
-                MP_WritePhyUshort(sc, 0x19, MP_ReadPhyUshort(sc, 0x19) | 0x2000);
-                MP_WritePhyUshort(sc, 0x10, MP_ReadPhyUshort(sc, 0x10) | 0x8000);
-
-                MP_WritePhyUshort(sc, 0x1f, 0x0003);
-                MP_WritePhyUshort(sc, 0x08, 0x441D);
-                MP_WritePhyUshort(sc, 0x01, 0x9100);
-        } else if (sc->re_type == MACFG_17) {
-                MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                MP_WritePhyUshort(sc, 0x11, MP_ReadPhyUshort(sc, 0x11) | 0x1000);
-                MP_WritePhyUshort(sc, 0x19, MP_ReadPhyUshort(sc, 0x19) | 0x2000);
-                MP_WritePhyUshort(sc, 0x10, MP_ReadPhyUshort(sc, 0x10) | 0x8000);
-
-                MP_WritePhyUshort(sc, 0x1f, 0x0003);
-                MP_WritePhyUshort(sc, 0x08, 0x441D);
-
+                MP_WritePhyUshort(sc, 0x16, 0x4104);
+                for (i=0; i<200; i++) {
+                        DELAY(100);
+                        PhyRegValue = MP_ReadPhyUshort(sc, 0x1E);
+                        PhyRegValue &= 0x03FF;
+                        if (PhyRegValue== 0x000C)
+                                break;
+                }
+                MP_WritePhyUshort(sc, 0x1f, 0x0005);
+                for (i=0; i<200; i++) {
+                        DELAY(100);
+                        PhyRegValue = MP_ReadPhyUshort(sc, 0x07);
+                        if ((PhyRegValue&0x0020)==0)
+                                break;
+                }
+                PhyRegValue = MP_ReadPhyUshort(sc, 0x07);
+                if (PhyRegValue & 0x0020) {
+                        MP_WritePhyUshort(sc, 0x1f, 0x0007);
+                        MP_WritePhyUshort(sc, 0x1e, 0x00a1);
+                        MP_WritePhyUshort(sc, 0x17, 0x1000);
+                        MP_WritePhyUshort(sc, 0x17, 0x0000);
+                        MP_WritePhyUshort(sc, 0x17, 0x2000);
+                        MP_WritePhyUshort(sc, 0x1e, 0x002f);
+                        MP_WritePhyUshort(sc, 0x18, 0x9bfb);
+                        MP_WritePhyUshort(sc, 0x1f, 0x0005);
+                        MP_WritePhyUshort(sc, 0x07, 0x0000);
+                        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+                }
+                MP_WritePhyUshort(sc, 0x1f, 0x0005);
+                MP_WritePhyUshort(sc, 0x05, 0xfff6);
+                MP_WritePhyUshort(sc, 0x06, 0x0080);
+                PhyRegValue = MP_ReadPhyUshort(sc, 0x00);
+                PhyRegValue &= ~(BIT_7);
+                MP_WritePhyUshort(sc, 0x00, PhyRegValue);
+                MP_WritePhyUshort(sc, 0x1f, 0x0002);
+                PhyRegValue = MP_ReadPhyUshort(sc, 0x08);
+                PhyRegValue &= ~(BIT_7);
+                MP_WritePhyUshort(sc, 0x08, PhyRegValue);
                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
-        } else if (sc->re_type == MACFG_21) {
-                MP_WritePhyUshort(sc, 0x1F, 0x0001);
-                MP_WritePhyUshort(sc, 0x0B, 0x94B0);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0003);
-                MP_WritePhyUshort(sc, 0x12, 0x6096);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-        } else if (sc->re_type == MACFG_22) {
-                MP_WritePhyUshort(sc, 0x1F, 0x0001);
-                MP_WritePhyUshort(sc, 0x0B, 0x94B0);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0003);
-                MP_WritePhyUshort(sc, 0x12, 0x6096);
-        } else if (sc->re_type == MACFG_23) {
-                MP_WritePhyUshort(sc, 0x1F, 0x0001);
-                MP_WritePhyUshort(sc, 0x0B, 0x94B0);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0003);
-                MP_WritePhyUshort(sc, 0x12, 0x6096);
-        } else if (sc->re_type == MACFG_24) {
-                MP_WritePhyUshort(sc, 0x1F, 0x0001);
-                MP_WritePhyUshort(sc, 0x12, 0x2300);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-                MP_WritePhyUshort(sc, 0x1F, 0x0003);
-                MP_WritePhyUshort(sc, 0x16, 0x000A);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0003);
-                MP_WritePhyUshort(sc, 0x12, 0xC096);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0002);
-                MP_WritePhyUshort(sc, 0x00, 0x88DE);
-                MP_WritePhyUshort(sc, 0x01, 0x82B1);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0002);
-                MP_WritePhyUshort(sc, 0x08, 0x9E30);
-                MP_WritePhyUshort(sc, 0x09, 0x01F0);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0002);
-                MP_WritePhyUshort(sc, 0x0A, 0x5500);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0002);
-                MP_WritePhyUshort(sc, 0x03, 0x7002);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-                MP_WritePhyUshort(sc, 0x14, MP_ReadPhyUshort(sc, 0x14) | BIT_5);
-                MP_WritePhyUshort(sc, 0x0d, MP_ReadPhyUshort(sc, 0x0d) | BIT_5);
-        } else if (sc->re_type == MACFG_25) {
-                MP_WritePhyUshort(sc, 0x1F, 0x0001);
-                MP_WritePhyUshort(sc, 0x12, 0x2300);
-                MP_WritePhyUshort(sc, 0x1F, 0x0003);
-                MP_WritePhyUshort(sc, 0x16, 0x0F0A);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0002);
-                MP_WritePhyUshort(sc, 0x00, 0x88DE);
-                MP_WritePhyUshort(sc, 0x01, 0x82B1);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0002);
-                MP_WritePhyUshort(sc, 0x0C, 0x7EB8);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0002);
-                MP_WritePhyUshort(sc, 0x06, 0x0761);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0001);
-                MP_WritePhyUshort(sc, 0x03, 0x802F);
-                MP_WritePhyUshort(sc, 0x02, 0x4F02);
-                MP_WritePhyUshort(sc, 0x01, 0x0409);
-                MP_WritePhyUshort(sc, 0x00, 0xF099);
-                MP_WritePhyUshort(sc, 0x04, 0x9800);
-                MP_WritePhyUshort(sc, 0x04, 0x9000);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-                MP_WritePhyUshort(sc, 0x16, MP_ReadPhyUshort(sc , 0x16) | BIT_0);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-                MP_WritePhyUshort(sc, 0x14, MP_ReadPhyUshort(sc , 0x14) | BIT_5);
-                MP_WritePhyUshort(sc, 0x0D, MP_ReadPhyUshort(sc , 0x0D) & ~BIT_5);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0001);
-                MP_WritePhyUshort(sc, 0x1D, 0x3D98);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0001);
-                MP_WritePhyUshort(sc, 0x17, 0x0CC0);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-        } else if (sc->re_type == MACFG_26) {
-                MP_WritePhyUshort(sc, 0x1F, 0x0001);
-                MP_WritePhyUshort(sc, 0x12, 0x2300);
-                MP_WritePhyUshort(sc, 0x1F, 0x0003);
-                MP_WritePhyUshort(sc, 0x16, 0x0F0A);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0002);
-                MP_WritePhyUshort(sc, 0x00, 0x88DE);
-                MP_WritePhyUshort(sc, 0x01, 0x82B1);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0002);
-                MP_WritePhyUshort(sc, 0x0C, 0x7EB8);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0002);
-                MP_WritePhyUshort(sc, 0x06, 0x5461);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0002);
-                MP_WritePhyUshort(sc, 0x06, 0x5461);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-                MP_WritePhyUshort(sc, 0x16, MP_ReadPhyUshort(sc, 0x16) | BIT_0);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-                MP_WritePhyUshort(sc, 0x14, MP_ReadPhyUshort(sc, 0x14) | BIT_5);
-                MP_WritePhyUshort(sc, 0x0D, MP_ReadPhyUshort(sc, 0x0D) & ~BIT_5);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0001);
-                MP_WritePhyUshort(sc, 0x1D, 0x3D98);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1f, 0x0001);
-                MP_WritePhyUshort(sc, 0x17, 0x0CC0);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-        } else if (sc->re_type == MACFG_27) {
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-                MP_WritePhyUshort(sc, 0x0d, MP_ReadPhyUshort(sc, 0x0d) | BIT_5);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0001);
-                MP_WritePhyUshort(sc, 0x1D, 0x3D98);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0001);
-                MP_WritePhyUshort(sc, 0x14, 0xCAA3);
-                MP_WritePhyUshort(sc, 0x1C, 0x000A);
-                MP_WritePhyUshort(sc, 0x18, 0x65D0);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0003);
-                MP_WritePhyUshort(sc, 0x17, 0xB580);
-                MP_WritePhyUshort(sc, 0x18, 0xFF54);
-                MP_WritePhyUshort(sc, 0x19, 0x3954);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0002);
-                MP_WritePhyUshort(sc, 0x0D, 0x310C);
-                MP_WritePhyUshort(sc, 0x0E, 0x310C);
-                MP_WritePhyUshort(sc, 0x0F, 0x311C);
-                MP_WritePhyUshort(sc, 0x06, 0x0761);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0003);
-                MP_WritePhyUshort(sc, 0x18, 0xFF55);
-                MP_WritePhyUshort(sc, 0x19, 0x3955);
-                MP_WritePhyUshort(sc, 0x18, 0xFF54);
-                MP_WritePhyUshort(sc, 0x19, 0x3954);
-
-                MP_WritePhyUshort(sc, 0x1f, 0x0001);
-                MP_WritePhyUshort(sc, 0x17, 0x0CC0);
-        } else if (sc->re_type == MACFG_28) {
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-                MP_WritePhyUshort(sc, 0x14, MP_ReadPhyUshort(sc, 0x14) | BIT_5);
-                MP_WritePhyUshort(sc, 0x0d, MP_ReadPhyUshort(sc, 0x0d) | BIT_5);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0001);
-                MP_WritePhyUshort(sc, 0x14, 0xCAA3);
-                MP_WritePhyUshort(sc, 0x1C, 0x000A);
-                MP_WritePhyUshort(sc, 0x18, 0x65D0);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0003);
-                MP_WritePhyUshort(sc, 0x17, 0xB580);
-                MP_WritePhyUshort(sc, 0x18, 0xFF54);
-                MP_WritePhyUshort(sc, 0x19, 0x3954);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0002);
-                MP_WritePhyUshort(sc, 0x0D, 0x310C);
-                MP_WritePhyUshort(sc, 0x0E, 0x310C);
-                MP_WritePhyUshort(sc, 0x0F, 0x311C);
-                MP_WritePhyUshort(sc, 0x06, 0x0761);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0003);
-                MP_WritePhyUshort(sc, 0x18, 0xFF55);
-                MP_WritePhyUshort(sc, 0x19, 0x3955);
-                MP_WritePhyUshort(sc, 0x18, 0xFF54);
-                MP_WritePhyUshort(sc, 0x19, 0x3954);
-
-                MP_WritePhyUshort(sc, 0x1f, 0x0001);
-                MP_WritePhyUshort(sc, 0x17, 0x0CC0);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-                MP_WritePhyUshort(sc, 0x16, MP_ReadPhyUshort(sc, 0x16) | BIT_0);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-        } else if (sc->re_type == MACFG_31) {
-                MP_WritePhyUshort(sc, 0x1F, 0x0001);
-                MP_WritePhyUshort(sc, 0x06, 0x4064);
-                MP_WritePhyUshort(sc, 0x07, 0x2863);
-                MP_WritePhyUshort(sc, 0x08, 0x059C);
-                MP_WritePhyUshort(sc, 0x09, 0x26B4);
-                MP_WritePhyUshort(sc, 0x0A, 0x6A19);
-                MP_WritePhyUshort(sc, 0x0B, 0xDCC8);
-                MP_WritePhyUshort(sc, 0x10, 0xF06D);
-                MP_WritePhyUshort(sc, 0x14, 0x7F68);
-                MP_WritePhyUshort(sc, 0x18, 0x7FD9);
-                MP_WritePhyUshort(sc, 0x1C, 0xF0FF);
-                MP_WritePhyUshort(sc, 0x1D, 0x3D9C);
-                MP_WritePhyUshort(sc, 0x1F, 0x0003);
-                MP_WritePhyUshort(sc, 0x12, 0xF49F);
-                MP_WritePhyUshort(sc, 0x13, 0x070B);
-                MP_WritePhyUshort(sc, 0x1A, 0x05AD);
-                MP_WritePhyUshort(sc, 0x14, 0x94C0);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0002);
-                Data = MP_ReadPhyUshort(sc, 0x0B) & 0xFF00;
-                Data |= 0x10;
-                MP_WritePhyUshort(sc, 0x0B, Data);
-                Data = MP_ReadPhyUshort(sc, 0x0C) & 0x00FF;
-                Data |= 0xA200;
-                MP_WritePhyUshort(sc, 0x0C, Data);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0002);
-                MP_WritePhyUshort(sc, 0x06, 0x5561);
-                MP_WritePhyUshort(sc, 0x1F, 0x0005);
-                MP_WritePhyUshort(sc, 0x05, 0x8332);
-                MP_WritePhyUshort(sc, 0x06, 0x5561);
-
-                if (MP_ReadEfuse(sc, 0x01) == 0xb1) {
-                        MP_WritePhyUshort(sc, 0x1F, 0x0002);
-                        MP_WritePhyUshort(sc, 0x05, 0x669A);
-                        MP_WritePhyUshort(sc, 0x1F, 0x0005);
-                        MP_WritePhyUshort(sc, 0x05, 0x8330);
-                        MP_WritePhyUshort(sc, 0x06, 0x669A);
-
-                        MP_WritePhyUshort(sc, 0x1F, 0x0002);
-                        Data = MP_ReadPhyUshort(sc, 0x0D);
-                        if ((Data & 0x00FF) != 0x006C) {
-                                Data &= 0xFF00;
-                                MP_WritePhyUshort(sc, 0x1F, 0x0002);
-                                MP_WritePhyUshort(sc, 0x0D, Data | 0x0065);
-                                MP_WritePhyUshort(sc, 0x0D, Data | 0x0066);
-                                MP_WritePhyUshort(sc, 0x0D, Data | 0x0067);
-                                MP_WritePhyUshort(sc, 0x0D, Data | 0x0068);
-                                MP_WritePhyUshort(sc, 0x0D, Data | 0x0069);
-                                MP_WritePhyUshort(sc, 0x0D, Data | 0x006A);
-                                MP_WritePhyUshort(sc, 0x0D, Data | 0x006B);
-                                MP_WritePhyUshort(sc, 0x0D, Data | 0x006C);
-                        }
-                } else {
-                        MP_WritePhyUshort(sc, 0x1F, 0x0002);
-                        MP_WritePhyUshort(sc, 0x05, 0x6662);
-                        MP_WritePhyUshort(sc, 0x1F, 0x0005);
-                        MP_WritePhyUshort(sc, 0x05, 0x8330);
-                        MP_WritePhyUshort(sc, 0x06, 0x6662);
-                }
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0002);
-                Data = MP_ReadPhyUshort(sc, 0x0D);
-                Data |= 0x300;
-                MP_WritePhyUshort(sc, 0x0D, Data);
-                Data = MP_ReadPhyUshort(sc, 0x0F);
-                Data |= 0x10;
-                MP_WritePhyUshort(sc, 0x0F, Data);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0002);
-                Data = MP_ReadPhyUshort(sc, 0x02);
-                Data &= ~0x600;
-                Data |= 0x100;
-                MP_WritePhyUshort(sc, 0x02, Data);
-                Data = MP_ReadPhyUshort(sc, 0x03);
-                Data &= ~0xE000;
-                MP_WritePhyUshort(sc, 0x03, Data);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0001);
-                MP_WritePhyUshort(sc, 0x17, 0x0CC0);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0005);
-                MP_WritePhyUshort(sc, 0x05, 0x001B);
-                if (MP_ReadPhyUshort(sc, 0x06) == 0xBF00) {
-                        MP_WritePhyUshort(sc, 0x1f, 0x0005);
-                        MP_WritePhyUshort(sc, 0x05, 0xfff6);
-                        MP_WritePhyUshort(sc, 0x06, 0x0080);
-                        MP_WritePhyUshort(sc, 0x05, 0x8000);
-                        MP_WritePhyUshort(sc, 0x06, 0xf8f9);
-                        MP_WritePhyUshort(sc, 0x06, 0xfaef);
-                        MP_WritePhyUshort(sc, 0x06, 0x59ee);
-                        MP_WritePhyUshort(sc, 0x06, 0xf8ea);
-                        MP_WritePhyUshort(sc, 0x06, 0x00ee);
-                        MP_WritePhyUshort(sc, 0x06, 0xf8eb);
-                        MP_WritePhyUshort(sc, 0x06, 0x00e0);
-                        MP_WritePhyUshort(sc, 0x06, 0xf87c);
-                        MP_WritePhyUshort(sc, 0x06, 0xe1f8);
-                        MP_WritePhyUshort(sc, 0x06, 0x7d59);
-                        MP_WritePhyUshort(sc, 0x06, 0x0fef);
-                        MP_WritePhyUshort(sc, 0x06, 0x0139);
-                        MP_WritePhyUshort(sc, 0x06, 0x029e);
-                        MP_WritePhyUshort(sc, 0x06, 0x06ef);
-                        MP_WritePhyUshort(sc, 0x06, 0x1039);
-                        MP_WritePhyUshort(sc, 0x06, 0x089f);
-                        MP_WritePhyUshort(sc, 0x06, 0x2aee);
-                        MP_WritePhyUshort(sc, 0x06, 0xf8ea);
-                        MP_WritePhyUshort(sc, 0x06, 0x00ee);
-                        MP_WritePhyUshort(sc, 0x06, 0xf8eb);
-                        MP_WritePhyUshort(sc, 0x06, 0x01e0);
-                        MP_WritePhyUshort(sc, 0x06, 0xf87c);
-                        MP_WritePhyUshort(sc, 0x06, 0xe1f8);
-                        MP_WritePhyUshort(sc, 0x06, 0x7d58);
-                        MP_WritePhyUshort(sc, 0x06, 0x409e);
-                        MP_WritePhyUshort(sc, 0x06, 0x0f39);
-                        MP_WritePhyUshort(sc, 0x06, 0x46aa);
-                        MP_WritePhyUshort(sc, 0x06, 0x0bbf);
-                        MP_WritePhyUshort(sc, 0x06, 0x8290);
-                        MP_WritePhyUshort(sc, 0x06, 0xd682);
-                        MP_WritePhyUshort(sc, 0x06, 0x9802);
-                        MP_WritePhyUshort(sc, 0x06, 0x014f);
-                        MP_WritePhyUshort(sc, 0x06, 0xae09);
-                        MP_WritePhyUshort(sc, 0x06, 0xbf82);
-                        MP_WritePhyUshort(sc, 0x06, 0x98d6);
-                        MP_WritePhyUshort(sc, 0x06, 0x82a0);
-                        MP_WritePhyUshort(sc, 0x06, 0x0201);
-                        MP_WritePhyUshort(sc, 0x06, 0x4fef);
-                        MP_WritePhyUshort(sc, 0x06, 0x95fe);
-                        MP_WritePhyUshort(sc, 0x06, 0xfdfc);
-                        MP_WritePhyUshort(sc, 0x06, 0x05f8);
-                        MP_WritePhyUshort(sc, 0x06, 0xf9fa);
-                        MP_WritePhyUshort(sc, 0x06, 0xeef8);
-                        MP_WritePhyUshort(sc, 0x06, 0xea00);
-                        MP_WritePhyUshort(sc, 0x06, 0xeef8);
-                        MP_WritePhyUshort(sc, 0x06, 0xeb00);
-                        MP_WritePhyUshort(sc, 0x06, 0xe2f8);
-                        MP_WritePhyUshort(sc, 0x06, 0x7ce3);
-                        MP_WritePhyUshort(sc, 0x06, 0xf87d);
-                        MP_WritePhyUshort(sc, 0x06, 0xa511);
-                        MP_WritePhyUshort(sc, 0x06, 0x1112);
-                        MP_WritePhyUshort(sc, 0x06, 0xd240);
-                        MP_WritePhyUshort(sc, 0x06, 0xd644);
-                        MP_WritePhyUshort(sc, 0x06, 0x4402);
-                        MP_WritePhyUshort(sc, 0x06, 0x8217);
-                        MP_WritePhyUshort(sc, 0x06, 0xd2a0);
-                        MP_WritePhyUshort(sc, 0x06, 0xd6aa);
-                        MP_WritePhyUshort(sc, 0x06, 0xaa02);
-                        MP_WritePhyUshort(sc, 0x06, 0x8217);
-                        MP_WritePhyUshort(sc, 0x06, 0xae0f);
-                        MP_WritePhyUshort(sc, 0x06, 0xa544);
-                        MP_WritePhyUshort(sc, 0x06, 0x4402);
-                        MP_WritePhyUshort(sc, 0x06, 0xae4d);
-                        MP_WritePhyUshort(sc, 0x06, 0xa5aa);
-                        MP_WritePhyUshort(sc, 0x06, 0xaa02);
-                        MP_WritePhyUshort(sc, 0x06, 0xae47);
-                        MP_WritePhyUshort(sc, 0x06, 0xaf82);
-                        MP_WritePhyUshort(sc, 0x06, 0x13ee);
-                        MP_WritePhyUshort(sc, 0x06, 0x834e);
-                        MP_WritePhyUshort(sc, 0x06, 0x00ee);
-                        MP_WritePhyUshort(sc, 0x06, 0x834d);
-                        MP_WritePhyUshort(sc, 0x06, 0x0fee);
-                        MP_WritePhyUshort(sc, 0x06, 0x834c);
-                        MP_WritePhyUshort(sc, 0x06, 0x0fee);
-                        MP_WritePhyUshort(sc, 0x06, 0x834f);
-                        MP_WritePhyUshort(sc, 0x06, 0x00ee);
-                        MP_WritePhyUshort(sc, 0x06, 0x8351);
-                        MP_WritePhyUshort(sc, 0x06, 0x00ee);
-                        MP_WritePhyUshort(sc, 0x06, 0x834a);
-                        MP_WritePhyUshort(sc, 0x06, 0xffee);
-                        MP_WritePhyUshort(sc, 0x06, 0x834b);
-                        MP_WritePhyUshort(sc, 0x06, 0xffe0);
-                        MP_WritePhyUshort(sc, 0x06, 0x8330);
-                        MP_WritePhyUshort(sc, 0x06, 0xe183);
-                        MP_WritePhyUshort(sc, 0x06, 0x3158);
-                        MP_WritePhyUshort(sc, 0x06, 0xfee4);
-                        MP_WritePhyUshort(sc, 0x06, 0xf88a);
-                        MP_WritePhyUshort(sc, 0x06, 0xe5f8);
-                        MP_WritePhyUshort(sc, 0x06, 0x8be0);
-                        MP_WritePhyUshort(sc, 0x06, 0x8332);
-                        MP_WritePhyUshort(sc, 0x06, 0xe183);
-                        MP_WritePhyUshort(sc, 0x06, 0x3359);
-                        MP_WritePhyUshort(sc, 0x06, 0x0fe2);
-                        MP_WritePhyUshort(sc, 0x06, 0x834d);
-                        MP_WritePhyUshort(sc, 0x06, 0x0c24);
-                        MP_WritePhyUshort(sc, 0x06, 0x5af0);
-                        MP_WritePhyUshort(sc, 0x06, 0x1e12);
-                        MP_WritePhyUshort(sc, 0x06, 0xe4f8);
-                        MP_WritePhyUshort(sc, 0x06, 0x8ce5);
-                        MP_WritePhyUshort(sc, 0x06, 0xf88d);
-                        MP_WritePhyUshort(sc, 0x06, 0xaf82);
-                        MP_WritePhyUshort(sc, 0x06, 0x13e0);
-                        MP_WritePhyUshort(sc, 0x06, 0x834f);
-                        MP_WritePhyUshort(sc, 0x06, 0x10e4);
-                        MP_WritePhyUshort(sc, 0x06, 0x834f);
-                        MP_WritePhyUshort(sc, 0x06, 0xe083);
-                        MP_WritePhyUshort(sc, 0x06, 0x4e78);
-                        MP_WritePhyUshort(sc, 0x06, 0x009f);
-                        MP_WritePhyUshort(sc, 0x06, 0x0ae0);
-                        MP_WritePhyUshort(sc, 0x06, 0x834f);
-                        MP_WritePhyUshort(sc, 0x06, 0xa010);
-                        MP_WritePhyUshort(sc, 0x06, 0xa5ee);
-                        MP_WritePhyUshort(sc, 0x06, 0x834e);
-                        MP_WritePhyUshort(sc, 0x06, 0x01e0);
-                        MP_WritePhyUshort(sc, 0x06, 0x834e);
-                        MP_WritePhyUshort(sc, 0x06, 0x7805);
-                        MP_WritePhyUshort(sc, 0x06, 0x9e9a);
-                        MP_WritePhyUshort(sc, 0x06, 0xe083);
-                        MP_WritePhyUshort(sc, 0x06, 0x4e78);
-                        MP_WritePhyUshort(sc, 0x06, 0x049e);
-                        MP_WritePhyUshort(sc, 0x06, 0x10e0);
-                        MP_WritePhyUshort(sc, 0x06, 0x834e);
-                        MP_WritePhyUshort(sc, 0x06, 0x7803);
-                        MP_WritePhyUshort(sc, 0x06, 0x9e0f);
-                        MP_WritePhyUshort(sc, 0x06, 0xe083);
-                        MP_WritePhyUshort(sc, 0x06, 0x4e78);
-                        MP_WritePhyUshort(sc, 0x06, 0x019e);
-                        MP_WritePhyUshort(sc, 0x06, 0x05ae);
-                        MP_WritePhyUshort(sc, 0x06, 0x0caf);
-                        MP_WritePhyUshort(sc, 0x06, 0x81f8);
-                        MP_WritePhyUshort(sc, 0x06, 0xaf81);
-                        MP_WritePhyUshort(sc, 0x06, 0xa3af);
-                        MP_WritePhyUshort(sc, 0x06, 0x81dc);
-                        MP_WritePhyUshort(sc, 0x06, 0xaf82);
-                        MP_WritePhyUshort(sc, 0x06, 0x13ee);
-                        MP_WritePhyUshort(sc, 0x06, 0x8348);
-                        MP_WritePhyUshort(sc, 0x06, 0x00ee);
-                        MP_WritePhyUshort(sc, 0x06, 0x8349);
-                        MP_WritePhyUshort(sc, 0x06, 0x00e0);
-                        MP_WritePhyUshort(sc, 0x06, 0x8351);
-                        MP_WritePhyUshort(sc, 0x06, 0x10e4);
-                        MP_WritePhyUshort(sc, 0x06, 0x8351);
-                        MP_WritePhyUshort(sc, 0x06, 0x5801);
-                        MP_WritePhyUshort(sc, 0x06, 0x9fea);
-                        MP_WritePhyUshort(sc, 0x06, 0xd000);
-                        MP_WritePhyUshort(sc, 0x06, 0xd180);
-                        MP_WritePhyUshort(sc, 0x06, 0x1f66);
-                        MP_WritePhyUshort(sc, 0x06, 0xe2f8);
-                        MP_WritePhyUshort(sc, 0x06, 0xeae3);
-                        MP_WritePhyUshort(sc, 0x06, 0xf8eb);
-                        MP_WritePhyUshort(sc, 0x06, 0x5af8);
-                        MP_WritePhyUshort(sc, 0x06, 0x1e20);
-                        MP_WritePhyUshort(sc, 0x06, 0xe6f8);
-                        MP_WritePhyUshort(sc, 0x06, 0xeae5);
-                        MP_WritePhyUshort(sc, 0x06, 0xf8eb);
-                        MP_WritePhyUshort(sc, 0x06, 0xd302);
-                        MP_WritePhyUshort(sc, 0x06, 0xb3fe);
-                        MP_WritePhyUshort(sc, 0x06, 0xe2f8);
-                        MP_WritePhyUshort(sc, 0x06, 0x7cef);
-                        MP_WritePhyUshort(sc, 0x06, 0x325b);
-                        MP_WritePhyUshort(sc, 0x06, 0x80e3);
-                        MP_WritePhyUshort(sc, 0x06, 0xf87d);
-                        MP_WritePhyUshort(sc, 0x06, 0x9e03);
-                        MP_WritePhyUshort(sc, 0x06, 0x7dff);
-                        MP_WritePhyUshort(sc, 0x06, 0xff0d);
-                        MP_WritePhyUshort(sc, 0x06, 0x581c);
-                        MP_WritePhyUshort(sc, 0x06, 0x551a);
-                        MP_WritePhyUshort(sc, 0x06, 0x6511);
-                        MP_WritePhyUshort(sc, 0x06, 0xa190);
-                        MP_WritePhyUshort(sc, 0x06, 0xd3e2);
-                        MP_WritePhyUshort(sc, 0x06, 0x8348);
-                        MP_WritePhyUshort(sc, 0x06, 0xe383);
-                        MP_WritePhyUshort(sc, 0x06, 0x491b);
-                        MP_WritePhyUshort(sc, 0x06, 0x56ab);
-                        MP_WritePhyUshort(sc, 0x06, 0x08ef);
-                        MP_WritePhyUshort(sc, 0x06, 0x56e6);
-                        MP_WritePhyUshort(sc, 0x06, 0x8348);
-                        MP_WritePhyUshort(sc, 0x06, 0xe783);
-                        MP_WritePhyUshort(sc, 0x06, 0x4910);
-                        MP_WritePhyUshort(sc, 0x06, 0xd180);
-                        MP_WritePhyUshort(sc, 0x06, 0x1f66);
-                        MP_WritePhyUshort(sc, 0x06, 0xa004);
-                        MP_WritePhyUshort(sc, 0x06, 0xb9e2);
-                        MP_WritePhyUshort(sc, 0x06, 0x8348);
-                        MP_WritePhyUshort(sc, 0x06, 0xe383);
-                        MP_WritePhyUshort(sc, 0x06, 0x49ef);
-                        MP_WritePhyUshort(sc, 0x06, 0x65e2);
-                        MP_WritePhyUshort(sc, 0x06, 0x834a);
-                        MP_WritePhyUshort(sc, 0x06, 0xe383);
-                        MP_WritePhyUshort(sc, 0x06, 0x4b1b);
-                        MP_WritePhyUshort(sc, 0x06, 0x56aa);
-                        MP_WritePhyUshort(sc, 0x06, 0x0eef);
-                        MP_WritePhyUshort(sc, 0x06, 0x56e6);
-                        MP_WritePhyUshort(sc, 0x06, 0x834a);
-                        MP_WritePhyUshort(sc, 0x06, 0xe783);
-                        MP_WritePhyUshort(sc, 0x06, 0x4be2);
-                        MP_WritePhyUshort(sc, 0x06, 0x834d);
-                        MP_WritePhyUshort(sc, 0x06, 0xe683);
-                        MP_WritePhyUshort(sc, 0x06, 0x4ce0);
-                        MP_WritePhyUshort(sc, 0x06, 0x834d);
-                        MP_WritePhyUshort(sc, 0x06, 0xa000);
-                        MP_WritePhyUshort(sc, 0x06, 0x0caf);
-                        MP_WritePhyUshort(sc, 0x06, 0x81dc);
-                        MP_WritePhyUshort(sc, 0x06, 0xe083);
-                        MP_WritePhyUshort(sc, 0x06, 0x4d10);
-                        MP_WritePhyUshort(sc, 0x06, 0xe483);
-                        MP_WritePhyUshort(sc, 0x06, 0x4dae);
-                        MP_WritePhyUshort(sc, 0x06, 0x0480);
-                        MP_WritePhyUshort(sc, 0x06, 0xe483);
-                        MP_WritePhyUshort(sc, 0x06, 0x4de0);
-                        MP_WritePhyUshort(sc, 0x06, 0x834e);
-                        MP_WritePhyUshort(sc, 0x06, 0x7803);
-                        MP_WritePhyUshort(sc, 0x06, 0x9e0b);
-                        MP_WritePhyUshort(sc, 0x06, 0xe083);
-                        MP_WritePhyUshort(sc, 0x06, 0x4e78);
-                        MP_WritePhyUshort(sc, 0x06, 0x049e);
-                        MP_WritePhyUshort(sc, 0x06, 0x04ee);
-                        MP_WritePhyUshort(sc, 0x06, 0x834e);
-                        MP_WritePhyUshort(sc, 0x06, 0x02e0);
-                        MP_WritePhyUshort(sc, 0x06, 0x8332);
-                        MP_WritePhyUshort(sc, 0x06, 0xe183);
-                        MP_WritePhyUshort(sc, 0x06, 0x3359);
-                        MP_WritePhyUshort(sc, 0x06, 0x0fe2);
-                        MP_WritePhyUshort(sc, 0x06, 0x834d);
-                        MP_WritePhyUshort(sc, 0x06, 0x0c24);
-                        MP_WritePhyUshort(sc, 0x06, 0x5af0);
-                        MP_WritePhyUshort(sc, 0x06, 0x1e12);
-                        MP_WritePhyUshort(sc, 0x06, 0xe4f8);
-                        MP_WritePhyUshort(sc, 0x06, 0x8ce5);
-                        MP_WritePhyUshort(sc, 0x06, 0xf88d);
-                        MP_WritePhyUshort(sc, 0x06, 0xe083);
-                        MP_WritePhyUshort(sc, 0x06, 0x30e1);
-                        MP_WritePhyUshort(sc, 0x06, 0x8331);
-                        MP_WritePhyUshort(sc, 0x06, 0x6801);
-                        MP_WritePhyUshort(sc, 0x06, 0xe4f8);
-                        MP_WritePhyUshort(sc, 0x06, 0x8ae5);
-                        MP_WritePhyUshort(sc, 0x06, 0xf88b);
-                        MP_WritePhyUshort(sc, 0x06, 0xae37);
-                        MP_WritePhyUshort(sc, 0x06, 0xee83);
-                        MP_WritePhyUshort(sc, 0x06, 0x4e03);
-                        MP_WritePhyUshort(sc, 0x06, 0xe083);
-                        MP_WritePhyUshort(sc, 0x06, 0x4ce1);
-                        MP_WritePhyUshort(sc, 0x06, 0x834d);
-                        MP_WritePhyUshort(sc, 0x06, 0x1b01);
-                        MP_WritePhyUshort(sc, 0x06, 0x9e04);
-                        MP_WritePhyUshort(sc, 0x06, 0xaaa1);
-                        MP_WritePhyUshort(sc, 0x06, 0xaea8);
-                        MP_WritePhyUshort(sc, 0x06, 0xee83);
-                        MP_WritePhyUshort(sc, 0x06, 0x4e04);
-                        MP_WritePhyUshort(sc, 0x06, 0xee83);
-                        MP_WritePhyUshort(sc, 0x06, 0x4f00);
-                        MP_WritePhyUshort(sc, 0x06, 0xaeab);
-                        MP_WritePhyUshort(sc, 0x06, 0xe083);
-                        MP_WritePhyUshort(sc, 0x06, 0x4f78);
-                        MP_WritePhyUshort(sc, 0x06, 0x039f);
-                        MP_WritePhyUshort(sc, 0x06, 0x14ee);
-                        MP_WritePhyUshort(sc, 0x06, 0x834e);
-                        MP_WritePhyUshort(sc, 0x06, 0x05d2);
-                        MP_WritePhyUshort(sc, 0x06, 0x40d6);
-                        MP_WritePhyUshort(sc, 0x06, 0x5554);
-                        MP_WritePhyUshort(sc, 0x06, 0x0282);
-                        MP_WritePhyUshort(sc, 0x06, 0x17d2);
-                        MP_WritePhyUshort(sc, 0x06, 0xa0d6);
-                        MP_WritePhyUshort(sc, 0x06, 0xba00);
-                        MP_WritePhyUshort(sc, 0x06, 0x0282);
-                        MP_WritePhyUshort(sc, 0x06, 0x17fe);
-                        MP_WritePhyUshort(sc, 0x06, 0xfdfc);
-                        MP_WritePhyUshort(sc, 0x06, 0x05f8);
-                        MP_WritePhyUshort(sc, 0x06, 0xe0f8);
-                        MP_WritePhyUshort(sc, 0x06, 0x60e1);
-                        MP_WritePhyUshort(sc, 0x06, 0xf861);
-                        MP_WritePhyUshort(sc, 0x06, 0x6802);
-                        MP_WritePhyUshort(sc, 0x06, 0xe4f8);
-                        MP_WritePhyUshort(sc, 0x06, 0x60e5);
-                        MP_WritePhyUshort(sc, 0x06, 0xf861);
-                        MP_WritePhyUshort(sc, 0x06, 0xe0f8);
-                        MP_WritePhyUshort(sc, 0x06, 0x48e1);
-                        MP_WritePhyUshort(sc, 0x06, 0xf849);
-                        MP_WritePhyUshort(sc, 0x06, 0x580f);
-                        MP_WritePhyUshort(sc, 0x06, 0x1e02);
-                        MP_WritePhyUshort(sc, 0x06, 0xe4f8);
-                        MP_WritePhyUshort(sc, 0x06, 0x48e5);
-                        MP_WritePhyUshort(sc, 0x06, 0xf849);
-                        MP_WritePhyUshort(sc, 0x06, 0xd000);
-                        MP_WritePhyUshort(sc, 0x06, 0x0282);
-                        MP_WritePhyUshort(sc, 0x06, 0x5bbf);
-                        MP_WritePhyUshort(sc, 0x06, 0x8350);
-                        MP_WritePhyUshort(sc, 0x06, 0xef46);
-                        MP_WritePhyUshort(sc, 0x06, 0xdc19);
-                        MP_WritePhyUshort(sc, 0x06, 0xddd0);
-                        MP_WritePhyUshort(sc, 0x06, 0x0102);
-                        MP_WritePhyUshort(sc, 0x06, 0x825b);
-                        MP_WritePhyUshort(sc, 0x06, 0x0282);
-                        MP_WritePhyUshort(sc, 0x06, 0x77e0);
-                        MP_WritePhyUshort(sc, 0x06, 0xf860);
-                        MP_WritePhyUshort(sc, 0x06, 0xe1f8);
-                        MP_WritePhyUshort(sc, 0x06, 0x6158);
-                        MP_WritePhyUshort(sc, 0x06, 0xfde4);
-                        MP_WritePhyUshort(sc, 0x06, 0xf860);
-                        MP_WritePhyUshort(sc, 0x06, 0xe5f8);
-                        MP_WritePhyUshort(sc, 0x06, 0x61fc);
-                        MP_WritePhyUshort(sc, 0x06, 0x04f9);
-                        MP_WritePhyUshort(sc, 0x06, 0xfafb);
-                        MP_WritePhyUshort(sc, 0x06, 0xc6bf);
-                        MP_WritePhyUshort(sc, 0x06, 0xf840);
-                        MP_WritePhyUshort(sc, 0x06, 0xbe83);
-                        MP_WritePhyUshort(sc, 0x06, 0x50a0);
-                        MP_WritePhyUshort(sc, 0x06, 0x0101);
-                        MP_WritePhyUshort(sc, 0x06, 0x071b);
-                        MP_WritePhyUshort(sc, 0x06, 0x89cf);
-                        MP_WritePhyUshort(sc, 0x06, 0xd208);
-                        MP_WritePhyUshort(sc, 0x06, 0xebdb);
-                        MP_WritePhyUshort(sc, 0x06, 0x19b2);
-                        MP_WritePhyUshort(sc, 0x06, 0xfbff);
-                        MP_WritePhyUshort(sc, 0x06, 0xfefd);
-                        MP_WritePhyUshort(sc, 0x06, 0x04f8);
-                        MP_WritePhyUshort(sc, 0x06, 0xe0f8);
-                        MP_WritePhyUshort(sc, 0x06, 0x48e1);
-                        MP_WritePhyUshort(sc, 0x06, 0xf849);
-                        MP_WritePhyUshort(sc, 0x06, 0x6808);
-                        MP_WritePhyUshort(sc, 0x06, 0xe4f8);
-                        MP_WritePhyUshort(sc, 0x06, 0x48e5);
-                        MP_WritePhyUshort(sc, 0x06, 0xf849);
-                        MP_WritePhyUshort(sc, 0x06, 0x58f7);
-                        MP_WritePhyUshort(sc, 0x06, 0xe4f8);
-                        MP_WritePhyUshort(sc, 0x06, 0x48e5);
-                        MP_WritePhyUshort(sc, 0x06, 0xf849);
-                        MP_WritePhyUshort(sc, 0x06, 0xfc04);
-                        MP_WritePhyUshort(sc, 0x06, 0x4d20);
-                        MP_WritePhyUshort(sc, 0x06, 0x0002);
-                        MP_WritePhyUshort(sc, 0x06, 0x4e22);
-                        MP_WritePhyUshort(sc, 0x06, 0x0002);
-                        MP_WritePhyUshort(sc, 0x06, 0x4ddf);
-                        MP_WritePhyUshort(sc, 0x06, 0xff01);
-                        MP_WritePhyUshort(sc, 0x06, 0x4edd);
-                        MP_WritePhyUshort(sc, 0x06, 0xff01);
-                        MP_WritePhyUshort(sc, 0x06, 0xf8fa);
-                        MP_WritePhyUshort(sc, 0x06, 0xfbef);
-                        MP_WritePhyUshort(sc, 0x06, 0x79bf);
-                        MP_WritePhyUshort(sc, 0x06, 0xf822);
-                        MP_WritePhyUshort(sc, 0x06, 0xd819);
-                        MP_WritePhyUshort(sc, 0x06, 0xd958);
-                        MP_WritePhyUshort(sc, 0x06, 0x849f);
-                        MP_WritePhyUshort(sc, 0x06, 0x09bf);
-                        MP_WritePhyUshort(sc, 0x06, 0x82be);
-                        MP_WritePhyUshort(sc, 0x06, 0xd682);
-                        MP_WritePhyUshort(sc, 0x06, 0xc602);
-                        MP_WritePhyUshort(sc, 0x06, 0x014f);
-                        MP_WritePhyUshort(sc, 0x06, 0xef97);
-                        MP_WritePhyUshort(sc, 0x06, 0xfffe);
-                        MP_WritePhyUshort(sc, 0x06, 0xfc05);
-                        MP_WritePhyUshort(sc, 0x06, 0x17ff);
-                        MP_WritePhyUshort(sc, 0x06, 0xfe01);
-                        MP_WritePhyUshort(sc, 0x06, 0x1700);
-                        MP_WritePhyUshort(sc, 0x06, 0x0102);
-                        MP_WritePhyUshort(sc, 0x05, 0x83d8);
-                        MP_WritePhyUshort(sc, 0x06, 0x8051);
-                        MP_WritePhyUshort(sc, 0x05, 0x83d6);
-                        MP_WritePhyUshort(sc, 0x06, 0x82a0);
-                        MP_WritePhyUshort(sc, 0x05, 0x83d4);
-                        MP_WritePhyUshort(sc, 0x06, 0x8000);
-                        MP_WritePhyUshort(sc, 0x02, 0x2010);
-                        MP_WritePhyUshort(sc, 0x03, 0xdc00);
-                        MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                        MP_WritePhyUshort(sc, 0x0b, 0x0600);
-                        MP_WritePhyUshort(sc, 0x1f, 0x0005);
-                        MP_WritePhyUshort(sc, 0x05, 0xfff6);
-                        MP_WritePhyUshort(sc, 0x06, 0x00fc);
-                        MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                }
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-                MP_WritePhyUshort(sc, 0x0D, 0xF880);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-        } else if (sc->re_type == MACFG_32) {
-                MP_WritePhyUshort(sc, 0x1F, 0x0001);
-                MP_WritePhyUshort(sc, 0x06, 0x4064);
-                MP_WritePhyUshort(sc, 0x07, 0x2863);
-                MP_WritePhyUshort(sc, 0x08, 0x059C);
-                MP_WritePhyUshort(sc, 0x09, 0x26B4);
-                MP_WritePhyUshort(sc, 0x0A, 0x6A19);
-                MP_WritePhyUshort(sc, 0x0B, 0xBCC0);
-                MP_WritePhyUshort(sc, 0x10, 0xF06D);
-                MP_WritePhyUshort(sc, 0x14, 0x7F68);
-                MP_WritePhyUshort(sc, 0x18, 0x7FD9);
-                MP_WritePhyUshort(sc, 0x1C, 0xF0FF);
-                MP_WritePhyUshort(sc, 0x1D, 0x3D9C);
-                MP_WritePhyUshort(sc, 0x1F, 0x0003);
-                MP_WritePhyUshort(sc, 0x12, 0xF49F);
-                MP_WritePhyUshort(sc, 0x13, 0x070B);
-                MP_WritePhyUshort(sc, 0x1A, 0x05AD);
-                MP_WritePhyUshort(sc, 0x14, 0x94C0);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0002);
-                MP_WritePhyUshort(sc, 0x06, 0x5571);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0002);
-                MP_WritePhyUshort(sc, 0x05, 0x2642);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0002);
-                MP_WritePhyUshort(sc, 0x02, 0xC107);
-                MP_WritePhyUshort(sc, 0x03, 0x1002);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0001);
-                MP_WritePhyUshort(sc, 0x16, 0x0CC0);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0002);
-                MP_WritePhyUshort(sc, 0x0F, 0x0017);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0005);
-                MP_WritePhyUshort(sc, 0x05, 0x8200);
-                MP_WritePhyUshort(sc, 0x06, 0xF8F9);
-                MP_WritePhyUshort(sc, 0x06, 0xFAEF);
-                MP_WritePhyUshort(sc, 0x06, 0x59EE);
-                MP_WritePhyUshort(sc, 0x06, 0xF8EA);
-                MP_WritePhyUshort(sc, 0x06, 0x00EE);
-                MP_WritePhyUshort(sc, 0x06, 0xF8EB);
-                MP_WritePhyUshort(sc, 0x06, 0x00E0);
-                MP_WritePhyUshort(sc, 0x06, 0xF87C);
-                MP_WritePhyUshort(sc, 0x06, 0xE1F8);
-                MP_WritePhyUshort(sc, 0x06, 0x7D59);
-                MP_WritePhyUshort(sc, 0x06, 0x0FEF);
-                MP_WritePhyUshort(sc, 0x06, 0x0139);
-                MP_WritePhyUshort(sc, 0x06, 0x029E);
-                MP_WritePhyUshort(sc, 0x06, 0x06EF);
-                MP_WritePhyUshort(sc, 0x06, 0x1039);
-                MP_WritePhyUshort(sc, 0x06, 0x089F);
-                MP_WritePhyUshort(sc, 0x06, 0x2AEE);
-                MP_WritePhyUshort(sc, 0x06, 0xF8EA);
-                MP_WritePhyUshort(sc, 0x06, 0x00EE);
-                MP_WritePhyUshort(sc, 0x06, 0xF8EB);
-                MP_WritePhyUshort(sc, 0x06, 0x01E0);
-                MP_WritePhyUshort(sc, 0x06, 0xF87C);
-                MP_WritePhyUshort(sc, 0x06, 0xE1F8);
-                MP_WritePhyUshort(sc, 0x06, 0x7D58);
-                MP_WritePhyUshort(sc, 0x06, 0x409E);
-                MP_WritePhyUshort(sc, 0x06, 0x0F39);
-                MP_WritePhyUshort(sc, 0x06, 0x46AA);
-                MP_WritePhyUshort(sc, 0x06, 0x0BBF);
-                MP_WritePhyUshort(sc, 0x06, 0x8251);
-                MP_WritePhyUshort(sc, 0x06, 0xD682);
-                MP_WritePhyUshort(sc, 0x06, 0x5902);
-                MP_WritePhyUshort(sc, 0x06, 0x014F);
-                MP_WritePhyUshort(sc, 0x06, 0xAE09);
-                MP_WritePhyUshort(sc, 0x06, 0xBF82);
-                MP_WritePhyUshort(sc, 0x06, 0x59D6);
-                MP_WritePhyUshort(sc, 0x06, 0x8261);
-                MP_WritePhyUshort(sc, 0x06, 0x0201);
-                MP_WritePhyUshort(sc, 0x06, 0x4FEF);
-                MP_WritePhyUshort(sc, 0x06, 0x95FE);
-                MP_WritePhyUshort(sc, 0x06, 0xFDFC);
-                MP_WritePhyUshort(sc, 0x06, 0x054D);
-                MP_WritePhyUshort(sc, 0x06, 0x2000);
-                MP_WritePhyUshort(sc, 0x06, 0x024E);
-                MP_WritePhyUshort(sc, 0x06, 0x2200);
-                MP_WritePhyUshort(sc, 0x06, 0x024D);
-                MP_WritePhyUshort(sc, 0x06, 0xDFFF);
-                MP_WritePhyUshort(sc, 0x06, 0x014E);
-                MP_WritePhyUshort(sc, 0x06, 0xDDFF);
-                MP_WritePhyUshort(sc, 0x06, 0x0100);
-                MP_WritePhyUshort(sc, 0x02, 0x6010);
-                MP_WritePhyUshort(sc, 0x05, 0xFFF6);
-                MP_WritePhyUshort(sc, 0x06, 0x00EC);
-                MP_WritePhyUshort(sc, 0x05, 0x83D4);
-                MP_WritePhyUshort(sc, 0x06, 0x8200);
-
-        } else if (sc->re_type == MACFG_33) {
-                MP_WritePhyUshort(sc, 0x1F, 0x0001);
-                MP_WritePhyUshort(sc, 0x06, 0x4064);
-                MP_WritePhyUshort(sc, 0x07, 0x2863);
-                MP_WritePhyUshort(sc, 0x08, 0x059C);
-                MP_WritePhyUshort(sc, 0x09, 0x26B4);
-                MP_WritePhyUshort(sc, 0x0A, 0x6A19);
-                MP_WritePhyUshort(sc, 0x0B, 0xDCC8);
-                MP_WritePhyUshort(sc, 0x10, 0xF06D);
-                MP_WritePhyUshort(sc, 0x14, 0x7F68);
-                MP_WritePhyUshort(sc, 0x18, 0x7FD9);
-                MP_WritePhyUshort(sc, 0x1C, 0xF0FF);
-                MP_WritePhyUshort(sc, 0x1D, 0x3D9C);
-                MP_WritePhyUshort(sc, 0x1F, 0x0003);
-                MP_WritePhyUshort(sc, 0x12, 0xF49F);
-                MP_WritePhyUshort(sc, 0x13, 0x070B);
-                MP_WritePhyUshort(sc, 0x1A, 0x05AD);
-                MP_WritePhyUshort(sc, 0x14, 0x94C0);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0002);
-                MP_WritePhyUshort(sc, 0x06, 0x5561);
-                MP_WritePhyUshort(sc, 0x1F, 0x0005);
-                MP_WritePhyUshort(sc, 0x05, 0x8332);
-                MP_WritePhyUshort(sc, 0x06, 0x5561);
-
-                if (MP_ReadEfuse(sc, 0x01) == 0xb1) {
-                        MP_WritePhyUshort(sc, 0x1F, 0x0002);
-                        MP_WritePhyUshort(sc, 0x05, 0x669A);
-                        MP_WritePhyUshort(sc, 0x1F, 0x0005);
-                        MP_WritePhyUshort(sc, 0x05, 0x8330);
-                        MP_WritePhyUshort(sc, 0x06, 0x669A);
-
-                        MP_WritePhyUshort(sc, 0x1F, 0x0002);
-                        Data = MP_ReadPhyUshort(sc, 0x0D);
-                        if ((Data & 0x00FF) != 0x006C) {
-                                Data &= 0xFF00;
-                                MP_WritePhyUshort(sc, 0x1F, 0x0002);
-                                MP_WritePhyUshort(sc, 0x0D, Data | 0x0065);
-                                MP_WritePhyUshort(sc, 0x0D, Data | 0x0066);
-                                MP_WritePhyUshort(sc, 0x0D, Data | 0x0067);
-                                MP_WritePhyUshort(sc, 0x0D, Data | 0x0068);
-                                MP_WritePhyUshort(sc, 0x0D, Data | 0x0069);
-                                MP_WritePhyUshort(sc, 0x0D, Data | 0x006A);
-                                MP_WritePhyUshort(sc, 0x0D, Data | 0x006B);
-                                MP_WritePhyUshort(sc, 0x0D, Data | 0x006C);
-                        }
-                } else {
-                        MP_WritePhyUshort(sc, 0x1F, 0x0002);
-                        MP_WritePhyUshort(sc, 0x05, 0x2642);
-                        MP_WritePhyUshort(sc, 0x1F, 0x0005);
-                        MP_WritePhyUshort(sc, 0x05, 0x8330);
-                        MP_WritePhyUshort(sc, 0x06, 0x2642);
-                }
-
-                if (MP_ReadEfuse(sc, 0x30) == 0x98) {
-                        MP_WritePhyUshort(sc, 0x1F, 0x0000);
-                        MP_WritePhyUshort(sc, 0x11, MP_ReadPhyUshort(sc, 0x11) & ~0x02);
-                        MP_WritePhyUshort(sc, 0x1F, 0x0005);
-                        MP_WritePhyUshort(sc, 0x01, MP_ReadPhyUshort(sc, 0x01) | 0x200);
-                } else if (MP_ReadEfuse(sc, 0x30) == 0x90) {
-                        MP_WritePhyUshort(sc, 0x1F, 0x0005);
-                        MP_WritePhyUshort(sc, 0x01, MP_ReadPhyUshort(sc, 0x01) & ~0x200);
-                        MP_WritePhyUshort(sc, 0x1F, 0x0000);
-                        MP_WritePhyUshort(sc, 0x16, 0x5101);
-                }
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0002);
-                Data = MP_ReadPhyUshort(sc, 0x02);
-                Data &= ~0x600;
-                Data |= 0x100;
-                MP_WritePhyUshort(sc, 0x02, Data);
-                Data = MP_ReadPhyUshort(sc, 0x03);
-                Data &= ~0xE000;
-                MP_WritePhyUshort(sc, 0x03, Data);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0001);
-                MP_WritePhyUshort(sc, 0x17, 0x0CC0);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0002);
-                Data = MP_ReadPhyUshort(sc, 0x0F);
-                Data |= 0x17;
-                MP_WritePhyUshort(sc, 0x0F, Data);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0005);
-                MP_WritePhyUshort(sc, 0x05, 0x001B);
-                if (MP_ReadPhyUshort(sc, 0x06) == 0xB300) {
-                        MP_WritePhyUshort(sc, 0x1f, 0x0005);
-                        MP_WritePhyUshort(sc, 0x05, 0xfff6);
-                        MP_WritePhyUshort(sc, 0x06, 0x0080);
-                        MP_WritePhyUshort(sc, 0x05, 0x8000);
-                        MP_WritePhyUshort(sc, 0x06, 0xf8f9);
-                        MP_WritePhyUshort(sc, 0x06, 0xfaee);
-                        MP_WritePhyUshort(sc, 0x06, 0xf8ea);
-                        MP_WritePhyUshort(sc, 0x06, 0x00ee);
-                        MP_WritePhyUshort(sc, 0x06, 0xf8eb);
-                        MP_WritePhyUshort(sc, 0x06, 0x00e2);
-                        MP_WritePhyUshort(sc, 0x06, 0xf87c);
-                        MP_WritePhyUshort(sc, 0x06, 0xe3f8);
-                        MP_WritePhyUshort(sc, 0x06, 0x7da5);
-                        MP_WritePhyUshort(sc, 0x06, 0x1111);
-                        MP_WritePhyUshort(sc, 0x06, 0x12d2);
-                        MP_WritePhyUshort(sc, 0x06, 0x40d6);
-                        MP_WritePhyUshort(sc, 0x06, 0x4444);
-                        MP_WritePhyUshort(sc, 0x06, 0x0281);
-                        MP_WritePhyUshort(sc, 0x06, 0xc6d2);
-                        MP_WritePhyUshort(sc, 0x06, 0xa0d6);
-                        MP_WritePhyUshort(sc, 0x06, 0xaaaa);
-                        MP_WritePhyUshort(sc, 0x06, 0x0281);
-                        MP_WritePhyUshort(sc, 0x06, 0xc6ae);
-                        MP_WritePhyUshort(sc, 0x06, 0x0fa5);
-                        MP_WritePhyUshort(sc, 0x06, 0x4444);
-                        MP_WritePhyUshort(sc, 0x06, 0x02ae);
-                        MP_WritePhyUshort(sc, 0x06, 0x4da5);
-                        MP_WritePhyUshort(sc, 0x06, 0xaaaa);
-                        MP_WritePhyUshort(sc, 0x06, 0x02ae);
-                        MP_WritePhyUshort(sc, 0x06, 0x47af);
-                        MP_WritePhyUshort(sc, 0x06, 0x81c2);
-                        MP_WritePhyUshort(sc, 0x06, 0xee83);
-                        MP_WritePhyUshort(sc, 0x06, 0x4e00);
-                        MP_WritePhyUshort(sc, 0x06, 0xee83);
-                        MP_WritePhyUshort(sc, 0x06, 0x4d0f);
-                        MP_WritePhyUshort(sc, 0x06, 0xee83);
-                        MP_WritePhyUshort(sc, 0x06, 0x4c0f);
-                        MP_WritePhyUshort(sc, 0x06, 0xee83);
-                        MP_WritePhyUshort(sc, 0x06, 0x4f00);
-                        MP_WritePhyUshort(sc, 0x06, 0xee83);
-                        MP_WritePhyUshort(sc, 0x06, 0x5100);
-                        MP_WritePhyUshort(sc, 0x06, 0xee83);
-                        MP_WritePhyUshort(sc, 0x06, 0x4aff);
-                        MP_WritePhyUshort(sc, 0x06, 0xee83);
-                        MP_WritePhyUshort(sc, 0x06, 0x4bff);
-                        MP_WritePhyUshort(sc, 0x06, 0xe083);
-                        MP_WritePhyUshort(sc, 0x06, 0x30e1);
-                        MP_WritePhyUshort(sc, 0x06, 0x8331);
-                        MP_WritePhyUshort(sc, 0x06, 0x58fe);
-                        MP_WritePhyUshort(sc, 0x06, 0xe4f8);
-                        MP_WritePhyUshort(sc, 0x06, 0x8ae5);
-                        MP_WritePhyUshort(sc, 0x06, 0xf88b);
-                        MP_WritePhyUshort(sc, 0x06, 0xe083);
-                        MP_WritePhyUshort(sc, 0x06, 0x32e1);
-                        MP_WritePhyUshort(sc, 0x06, 0x8333);
-                        MP_WritePhyUshort(sc, 0x06, 0x590f);
-                        MP_WritePhyUshort(sc, 0x06, 0xe283);
-                        MP_WritePhyUshort(sc, 0x06, 0x4d0c);
-                        MP_WritePhyUshort(sc, 0x06, 0x245a);
-                        MP_WritePhyUshort(sc, 0x06, 0xf01e);
-                        MP_WritePhyUshort(sc, 0x06, 0x12e4);
-                        MP_WritePhyUshort(sc, 0x06, 0xf88c);
-                        MP_WritePhyUshort(sc, 0x06, 0xe5f8);
-                        MP_WritePhyUshort(sc, 0x06, 0x8daf);
-                        MP_WritePhyUshort(sc, 0x06, 0x81c2);
-                        MP_WritePhyUshort(sc, 0x06, 0xe083);
-                        MP_WritePhyUshort(sc, 0x06, 0x4f10);
-                        MP_WritePhyUshort(sc, 0x06, 0xe483);
-                        MP_WritePhyUshort(sc, 0x06, 0x4fe0);
-                        MP_WritePhyUshort(sc, 0x06, 0x834e);
-                        MP_WritePhyUshort(sc, 0x06, 0x7800);
-                        MP_WritePhyUshort(sc, 0x06, 0x9f0a);
-                        MP_WritePhyUshort(sc, 0x06, 0xe083);
-                        MP_WritePhyUshort(sc, 0x06, 0x4fa0);
-                        MP_WritePhyUshort(sc, 0x06, 0x10a5);
-                        MP_WritePhyUshort(sc, 0x06, 0xee83);
-                        MP_WritePhyUshort(sc, 0x06, 0x4e01);
-                        MP_WritePhyUshort(sc, 0x06, 0xe083);
-                        MP_WritePhyUshort(sc, 0x06, 0x4e78);
-                        MP_WritePhyUshort(sc, 0x06, 0x059e);
-                        MP_WritePhyUshort(sc, 0x06, 0x9ae0);
-                        MP_WritePhyUshort(sc, 0x06, 0x834e);
-                        MP_WritePhyUshort(sc, 0x06, 0x7804);
-                        MP_WritePhyUshort(sc, 0x06, 0x9e10);
-                        MP_WritePhyUshort(sc, 0x06, 0xe083);
-                        MP_WritePhyUshort(sc, 0x06, 0x4e78);
-                        MP_WritePhyUshort(sc, 0x06, 0x039e);
-                        MP_WritePhyUshort(sc, 0x06, 0x0fe0);
-                        MP_WritePhyUshort(sc, 0x06, 0x834e);
-                        MP_WritePhyUshort(sc, 0x06, 0x7801);
-                        MP_WritePhyUshort(sc, 0x06, 0x9e05);
-                        MP_WritePhyUshort(sc, 0x06, 0xae0c);
-                        MP_WritePhyUshort(sc, 0x06, 0xaf81);
-                        MP_WritePhyUshort(sc, 0x06, 0xa7af);
-                        MP_WritePhyUshort(sc, 0x06, 0x8152);
-                        MP_WritePhyUshort(sc, 0x06, 0xaf81);
-                        MP_WritePhyUshort(sc, 0x06, 0x8baf);
-                        MP_WritePhyUshort(sc, 0x06, 0x81c2);
-                        MP_WritePhyUshort(sc, 0x06, 0xee83);
-                        MP_WritePhyUshort(sc, 0x06, 0x4800);
-                        MP_WritePhyUshort(sc, 0x06, 0xee83);
-                        MP_WritePhyUshort(sc, 0x06, 0x4900);
-                        MP_WritePhyUshort(sc, 0x06, 0xe083);
-                        MP_WritePhyUshort(sc, 0x06, 0x5110);
-                        MP_WritePhyUshort(sc, 0x06, 0xe483);
-                        MP_WritePhyUshort(sc, 0x06, 0x5158);
-                        MP_WritePhyUshort(sc, 0x06, 0x019f);
-                        MP_WritePhyUshort(sc, 0x06, 0xead0);
-                        MP_WritePhyUshort(sc, 0x06, 0x00d1);
-                        MP_WritePhyUshort(sc, 0x06, 0x801f);
-                        MP_WritePhyUshort(sc, 0x06, 0x66e2);
-                        MP_WritePhyUshort(sc, 0x06, 0xf8ea);
-                        MP_WritePhyUshort(sc, 0x06, 0xe3f8);
-                        MP_WritePhyUshort(sc, 0x06, 0xeb5a);
-                        MP_WritePhyUshort(sc, 0x06, 0xf81e);
-                        MP_WritePhyUshort(sc, 0x06, 0x20e6);
-                        MP_WritePhyUshort(sc, 0x06, 0xf8ea);
-                        MP_WritePhyUshort(sc, 0x06, 0xe5f8);
-                        MP_WritePhyUshort(sc, 0x06, 0xebd3);
-                        MP_WritePhyUshort(sc, 0x06, 0x02b3);
-                        MP_WritePhyUshort(sc, 0x06, 0xfee2);
-                        MP_WritePhyUshort(sc, 0x06, 0xf87c);
-                        MP_WritePhyUshort(sc, 0x06, 0xef32);
-                        MP_WritePhyUshort(sc, 0x06, 0x5b80);
-                        MP_WritePhyUshort(sc, 0x06, 0xe3f8);
-                        MP_WritePhyUshort(sc, 0x06, 0x7d9e);
-                        MP_WritePhyUshort(sc, 0x06, 0x037d);
-                        MP_WritePhyUshort(sc, 0x06, 0xffff);
-                        MP_WritePhyUshort(sc, 0x06, 0x0d58);
-                        MP_WritePhyUshort(sc, 0x06, 0x1c55);
-                        MP_WritePhyUshort(sc, 0x06, 0x1a65);
-                        MP_WritePhyUshort(sc, 0x06, 0x11a1);
-                        MP_WritePhyUshort(sc, 0x06, 0x90d3);
-                        MP_WritePhyUshort(sc, 0x06, 0xe283);
-                        MP_WritePhyUshort(sc, 0x06, 0x48e3);
-                        MP_WritePhyUshort(sc, 0x06, 0x8349);
-                        MP_WritePhyUshort(sc, 0x06, 0x1b56);
-                        MP_WritePhyUshort(sc, 0x06, 0xab08);
-                        MP_WritePhyUshort(sc, 0x06, 0xef56);
-                        MP_WritePhyUshort(sc, 0x06, 0xe683);
-                        MP_WritePhyUshort(sc, 0x06, 0x48e7);
-                        MP_WritePhyUshort(sc, 0x06, 0x8349);
-                        MP_WritePhyUshort(sc, 0x06, 0x10d1);
-                        MP_WritePhyUshort(sc, 0x06, 0x801f);
-                        MP_WritePhyUshort(sc, 0x06, 0x66a0);
-                        MP_WritePhyUshort(sc, 0x06, 0x04b9);
-                        MP_WritePhyUshort(sc, 0x06, 0xe283);
-                        MP_WritePhyUshort(sc, 0x06, 0x48e3);
-                        MP_WritePhyUshort(sc, 0x06, 0x8349);
-                        MP_WritePhyUshort(sc, 0x06, 0xef65);
-                        MP_WritePhyUshort(sc, 0x06, 0xe283);
-                        MP_WritePhyUshort(sc, 0x06, 0x4ae3);
-                        MP_WritePhyUshort(sc, 0x06, 0x834b);
-                        MP_WritePhyUshort(sc, 0x06, 0x1b56);
-                        MP_WritePhyUshort(sc, 0x06, 0xaa0e);
-                        MP_WritePhyUshort(sc, 0x06, 0xef56);
-                        MP_WritePhyUshort(sc, 0x06, 0xe683);
-                        MP_WritePhyUshort(sc, 0x06, 0x4ae7);
-                        MP_WritePhyUshort(sc, 0x06, 0x834b);
-                        MP_WritePhyUshort(sc, 0x06, 0xe283);
-                        MP_WritePhyUshort(sc, 0x06, 0x4de6);
-                        MP_WritePhyUshort(sc, 0x06, 0x834c);
-                        MP_WritePhyUshort(sc, 0x06, 0xe083);
-                        MP_WritePhyUshort(sc, 0x06, 0x4da0);
-                        MP_WritePhyUshort(sc, 0x06, 0x000c);
-                        MP_WritePhyUshort(sc, 0x06, 0xaf81);
-                        MP_WritePhyUshort(sc, 0x06, 0x8be0);
-                        MP_WritePhyUshort(sc, 0x06, 0x834d);
-                        MP_WritePhyUshort(sc, 0x06, 0x10e4);
-                        MP_WritePhyUshort(sc, 0x06, 0x834d);
-                        MP_WritePhyUshort(sc, 0x06, 0xae04);
-                        MP_WritePhyUshort(sc, 0x06, 0x80e4);
-                        MP_WritePhyUshort(sc, 0x06, 0x834d);
-                        MP_WritePhyUshort(sc, 0x06, 0xe083);
-                        MP_WritePhyUshort(sc, 0x06, 0x4e78);
-                        MP_WritePhyUshort(sc, 0x06, 0x039e);
-                        MP_WritePhyUshort(sc, 0x06, 0x0be0);
-                        MP_WritePhyUshort(sc, 0x06, 0x834e);
-                        MP_WritePhyUshort(sc, 0x06, 0x7804);
-                        MP_WritePhyUshort(sc, 0x06, 0x9e04);
-                        MP_WritePhyUshort(sc, 0x06, 0xee83);
-                        MP_WritePhyUshort(sc, 0x06, 0x4e02);
-                        MP_WritePhyUshort(sc, 0x06, 0xe083);
-                        MP_WritePhyUshort(sc, 0x06, 0x32e1);
-                        MP_WritePhyUshort(sc, 0x06, 0x8333);
-                        MP_WritePhyUshort(sc, 0x06, 0x590f);
-                        MP_WritePhyUshort(sc, 0x06, 0xe283);
-                        MP_WritePhyUshort(sc, 0x06, 0x4d0c);
-                        MP_WritePhyUshort(sc, 0x06, 0x245a);
-                        MP_WritePhyUshort(sc, 0x06, 0xf01e);
-                        MP_WritePhyUshort(sc, 0x06, 0x12e4);
-                        MP_WritePhyUshort(sc, 0x06, 0xf88c);
-                        MP_WritePhyUshort(sc, 0x06, 0xe5f8);
-                        MP_WritePhyUshort(sc, 0x06, 0x8de0);
-                        MP_WritePhyUshort(sc, 0x06, 0x8330);
-                        MP_WritePhyUshort(sc, 0x06, 0xe183);
-                        MP_WritePhyUshort(sc, 0x06, 0x3168);
-                        MP_WritePhyUshort(sc, 0x06, 0x01e4);
-                        MP_WritePhyUshort(sc, 0x06, 0xf88a);
-                        MP_WritePhyUshort(sc, 0x06, 0xe5f8);
-                        MP_WritePhyUshort(sc, 0x06, 0x8bae);
-                        MP_WritePhyUshort(sc, 0x06, 0x37ee);
-                        MP_WritePhyUshort(sc, 0x06, 0x834e);
-                        MP_WritePhyUshort(sc, 0x06, 0x03e0);
-                        MP_WritePhyUshort(sc, 0x06, 0x834c);
-                        MP_WritePhyUshort(sc, 0x06, 0xe183);
-                        MP_WritePhyUshort(sc, 0x06, 0x4d1b);
-                        MP_WritePhyUshort(sc, 0x06, 0x019e);
-                        MP_WritePhyUshort(sc, 0x06, 0x04aa);
-                        MP_WritePhyUshort(sc, 0x06, 0xa1ae);
-                        MP_WritePhyUshort(sc, 0x06, 0xa8ee);
-                        MP_WritePhyUshort(sc, 0x06, 0x834e);
-                        MP_WritePhyUshort(sc, 0x06, 0x04ee);
-                        MP_WritePhyUshort(sc, 0x06, 0x834f);
-                        MP_WritePhyUshort(sc, 0x06, 0x00ae);
-                        MP_WritePhyUshort(sc, 0x06, 0xabe0);
-                        MP_WritePhyUshort(sc, 0x06, 0x834f);
-                        MP_WritePhyUshort(sc, 0x06, 0x7803);
-                        MP_WritePhyUshort(sc, 0x06, 0x9f14);
-                        MP_WritePhyUshort(sc, 0x06, 0xee83);
-                        MP_WritePhyUshort(sc, 0x06, 0x4e05);
-                        MP_WritePhyUshort(sc, 0x06, 0xd240);
-                        MP_WritePhyUshort(sc, 0x06, 0xd655);
-                        MP_WritePhyUshort(sc, 0x06, 0x5402);
-                        MP_WritePhyUshort(sc, 0x06, 0x81c6);
-                        MP_WritePhyUshort(sc, 0x06, 0xd2a0);
-                        MP_WritePhyUshort(sc, 0x06, 0xd6ba);
-                        MP_WritePhyUshort(sc, 0x06, 0x0002);
-                        MP_WritePhyUshort(sc, 0x06, 0x81c6);
-                        MP_WritePhyUshort(sc, 0x06, 0xfefd);
-                        MP_WritePhyUshort(sc, 0x06, 0xfc05);
-                        MP_WritePhyUshort(sc, 0x06, 0xf8e0);
-                        MP_WritePhyUshort(sc, 0x06, 0xf860);
-                        MP_WritePhyUshort(sc, 0x06, 0xe1f8);
-                        MP_WritePhyUshort(sc, 0x06, 0x6168);
-                        MP_WritePhyUshort(sc, 0x06, 0x02e4);
-                        MP_WritePhyUshort(sc, 0x06, 0xf860);
-                        MP_WritePhyUshort(sc, 0x06, 0xe5f8);
-                        MP_WritePhyUshort(sc, 0x06, 0x61e0);
-                        MP_WritePhyUshort(sc, 0x06, 0xf848);
-                        MP_WritePhyUshort(sc, 0x06, 0xe1f8);
-                        MP_WritePhyUshort(sc, 0x06, 0x4958);
-                        MP_WritePhyUshort(sc, 0x06, 0x0f1e);
-                        MP_WritePhyUshort(sc, 0x06, 0x02e4);
-                        MP_WritePhyUshort(sc, 0x06, 0xf848);
-                        MP_WritePhyUshort(sc, 0x06, 0xe5f8);
-                        MP_WritePhyUshort(sc, 0x06, 0x49d0);
-                        MP_WritePhyUshort(sc, 0x06, 0x0002);
-                        MP_WritePhyUshort(sc, 0x06, 0x820a);
-                        MP_WritePhyUshort(sc, 0x06, 0xbf83);
-                        MP_WritePhyUshort(sc, 0x06, 0x50ef);
-                        MP_WritePhyUshort(sc, 0x06, 0x46dc);
-                        MP_WritePhyUshort(sc, 0x06, 0x19dd);
-                        MP_WritePhyUshort(sc, 0x06, 0xd001);
-                        MP_WritePhyUshort(sc, 0x06, 0x0282);
-                        MP_WritePhyUshort(sc, 0x06, 0x0a02);
-                        MP_WritePhyUshort(sc, 0x06, 0x8226);
-                        MP_WritePhyUshort(sc, 0x06, 0xe0f8);
-                        MP_WritePhyUshort(sc, 0x06, 0x60e1);
-                        MP_WritePhyUshort(sc, 0x06, 0xf861);
-                        MP_WritePhyUshort(sc, 0x06, 0x58fd);
-                        MP_WritePhyUshort(sc, 0x06, 0xe4f8);
-                        MP_WritePhyUshort(sc, 0x06, 0x60e5);
-                        MP_WritePhyUshort(sc, 0x06, 0xf861);
-                        MP_WritePhyUshort(sc, 0x06, 0xfc04);
-                        MP_WritePhyUshort(sc, 0x06, 0xf9fa);
-                        MP_WritePhyUshort(sc, 0x06, 0xfbc6);
-                        MP_WritePhyUshort(sc, 0x06, 0xbff8);
-                        MP_WritePhyUshort(sc, 0x06, 0x40be);
-                        MP_WritePhyUshort(sc, 0x06, 0x8350);
-                        MP_WritePhyUshort(sc, 0x06, 0xa001);
-                        MP_WritePhyUshort(sc, 0x06, 0x0107);
-                        MP_WritePhyUshort(sc, 0x06, 0x1b89);
-                        MP_WritePhyUshort(sc, 0x06, 0xcfd2);
-                        MP_WritePhyUshort(sc, 0x06, 0x08eb);
-                        MP_WritePhyUshort(sc, 0x06, 0xdb19);
-                        MP_WritePhyUshort(sc, 0x06, 0xb2fb);
-                        MP_WritePhyUshort(sc, 0x06, 0xfffe);
-                        MP_WritePhyUshort(sc, 0x06, 0xfd04);
-                        MP_WritePhyUshort(sc, 0x06, 0xf8e0);
-                        MP_WritePhyUshort(sc, 0x06, 0xf848);
-                        MP_WritePhyUshort(sc, 0x06, 0xe1f8);
-                        MP_WritePhyUshort(sc, 0x06, 0x4968);
-                        MP_WritePhyUshort(sc, 0x06, 0x08e4);
-                        MP_WritePhyUshort(sc, 0x06, 0xf848);
-                        MP_WritePhyUshort(sc, 0x06, 0xe5f8);
-                        MP_WritePhyUshort(sc, 0x06, 0x4958);
-                        MP_WritePhyUshort(sc, 0x06, 0xf7e4);
-                        MP_WritePhyUshort(sc, 0x06, 0xf848);
-                        MP_WritePhyUshort(sc, 0x06, 0xe5f8);
-                        MP_WritePhyUshort(sc, 0x06, 0x49fc);
-                        MP_WritePhyUshort(sc, 0x06, 0x044d);
-                        MP_WritePhyUshort(sc, 0x06, 0x2000);
-                        MP_WritePhyUshort(sc, 0x06, 0x024e);
-                        MP_WritePhyUshort(sc, 0x06, 0x2200);
-                        MP_WritePhyUshort(sc, 0x06, 0x024d);
-                        MP_WritePhyUshort(sc, 0x06, 0xdfff);
-                        MP_WritePhyUshort(sc, 0x06, 0x014e);
-                        MP_WritePhyUshort(sc, 0x06, 0xddff);
-                        MP_WritePhyUshort(sc, 0x06, 0x01f8);
-                        MP_WritePhyUshort(sc, 0x06, 0xfafb);
-                        MP_WritePhyUshort(sc, 0x06, 0xef79);
-                        MP_WritePhyUshort(sc, 0x06, 0xbff8);
-                        MP_WritePhyUshort(sc, 0x06, 0x22d8);
-                        MP_WritePhyUshort(sc, 0x06, 0x19d9);
-                        MP_WritePhyUshort(sc, 0x06, 0x5884);
-                        MP_WritePhyUshort(sc, 0x06, 0x9f09);
-                        MP_WritePhyUshort(sc, 0x06, 0xbf82);
-                        MP_WritePhyUshort(sc, 0x06, 0x6dd6);
-                        MP_WritePhyUshort(sc, 0x06, 0x8275);
-                        MP_WritePhyUshort(sc, 0x06, 0x0201);
-                        MP_WritePhyUshort(sc, 0x06, 0x4fef);
-                        MP_WritePhyUshort(sc, 0x06, 0x97ff);
-                        MP_WritePhyUshort(sc, 0x06, 0xfefc);
-                        MP_WritePhyUshort(sc, 0x06, 0x0517);
-                        MP_WritePhyUshort(sc, 0x06, 0xfffe);
-                        MP_WritePhyUshort(sc, 0x06, 0x0117);
-                        MP_WritePhyUshort(sc, 0x06, 0x0001);
-                        MP_WritePhyUshort(sc, 0x06, 0x0200);
-                        MP_WritePhyUshort(sc, 0x05, 0x83d8);
-                        MP_WritePhyUshort(sc, 0x06, 0x8000);
-                        MP_WritePhyUshort(sc, 0x05, 0x83d6);
-                        MP_WritePhyUshort(sc, 0x06, 0x824f);
-                        MP_WritePhyUshort(sc, 0x02, 0x2010);
-                        MP_WritePhyUshort(sc, 0x03, 0xdc00);
-                        MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                        MP_WritePhyUshort(sc, 0x0b, 0x0600);
-                        MP_WritePhyUshort(sc, 0x1f, 0x0005);
-                        MP_WritePhyUshort(sc, 0x05, 0xfff6);
-                        MP_WritePhyUshort(sc, 0x06, 0x00fc);
-                        MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                }
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-                MP_WritePhyUshort(sc, 0x0D, 0xF880);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-        } else if (sc->re_type == MACFG_36 || sc->re_type == MACFG_37) {
-                if (sc->re_type == MACFG_36) {
-                        MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                        MP_WritePhyUshort(sc, 0x00, 0x1800);
-                        MP_WritePhyUshort(sc, 0x1f, 0x0007);
-                        MP_WritePhyUshort(sc, 0x1e, 0x0023);
-                        MP_WritePhyUshort(sc, 0x17, 0x0117);
-                        MP_WritePhyUshort(sc, 0x1f, 0x0007);
-                        MP_WritePhyUshort(sc, 0x1E, 0x002C);
-                        MP_WritePhyUshort(sc, 0x1B, 0x5000);
-                        MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                        MP_WritePhyUshort(sc, 0x16, 0x4104);
-                        for (i = 0; i < 200; i++) {
-                                DELAY(100);
-                                Data = MP_ReadPhyUshort(sc, 0x1E);
-                                Data &= 0x03FF;
-                                if (Data== 0x000C)
-                                        break;
-                        }
-                        MP_WritePhyUshort(sc, 0x1f, 0x0005);
-                        for (i = 0; i < 200; i++) {
-                                DELAY(100);
-                                Data = MP_ReadPhyUshort(sc, 0x07);
-                                if ((Data & 0x0020)==0)
-                                        break;
-                        }
-                        Data = MP_ReadPhyUshort(sc, 0x07);
-                        if (Data & 0x0020) {
-                                MP_WritePhyUshort(sc, 0x1f, 0x0007);
-                                MP_WritePhyUshort(sc, 0x1e, 0x00a1);
-                                MP_WritePhyUshort(sc, 0x17, 0x1000);
-                                MP_WritePhyUshort(sc, 0x17, 0x0000);
-                                MP_WritePhyUshort(sc, 0x17, 0x2000);
-                                MP_WritePhyUshort(sc, 0x1e, 0x002f);
-                                MP_WritePhyUshort(sc, 0x18, 0x9bfb);
-                                MP_WritePhyUshort(sc, 0x1f, 0x0005);
-                                MP_WritePhyUshort(sc, 0x07, 0x0000);
-                                MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                        }
-                        MP_WritePhyUshort(sc, 0x1f, 0x0005);
-                        MP_WritePhyUshort(sc, 0x05, 0xfff6);
-                        MP_WritePhyUshort(sc, 0x06, 0x0080);
-                        Data = MP_ReadPhyUshort(sc, 0x00);
-                        Data &= ~(0x0080);
-                        MP_WritePhyUshort(sc, 0x00, Data);
-                        MP_WritePhyUshort(sc, 0x1f, 0x0002);
-                        Data = MP_ReadPhyUshort(sc, 0x08);
-                        Data &= ~(0x0080);
-                        MP_WritePhyUshort(sc, 0x08, Data);
-                        MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                        MP_WritePhyUshort(sc, 0x1f, 0x0007);
-                        MP_WritePhyUshort(sc, 0x1e, 0x0023);
-                        MP_WritePhyUshort(sc, 0x16, 0x0306);
-                        MP_WritePhyUshort(sc, 0x16, 0x0307);
-                        MP_WritePhyUshort(sc, 0x15, 0x000e);
-                        MP_WritePhyUshort(sc, 0x19, 0x000a);
-                        MP_WritePhyUshort(sc, 0x15, 0x0010);
-                        MP_WritePhyUshort(sc, 0x19, 0x0008);
-                        MP_WritePhyUshort(sc, 0x15, 0x0018);
-                        MP_WritePhyUshort(sc, 0x19, 0x4801);
-                        MP_WritePhyUshort(sc, 0x15, 0x0019);
-                        MP_WritePhyUshort(sc, 0x19, 0x6801);
-                        MP_WritePhyUshort(sc, 0x15, 0x001a);
-                        MP_WritePhyUshort(sc, 0x19, 0x66a1);
-                        MP_WritePhyUshort(sc, 0x15, 0x001f);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x15, 0x0020);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x15, 0x0021);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x15, 0x0022);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x15, 0x0023);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x15, 0x0024);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x15, 0x0025);
-                        MP_WritePhyUshort(sc, 0x19, 0x64a1);
-                        MP_WritePhyUshort(sc, 0x15, 0x0026);
-                        MP_WritePhyUshort(sc, 0x19, 0x40ea);
-                        MP_WritePhyUshort(sc, 0x15, 0x0027);
-                        MP_WritePhyUshort(sc, 0x19, 0x4503);
-                        MP_WritePhyUshort(sc, 0x15, 0x0028);
-                        MP_WritePhyUshort(sc, 0x19, 0x9f00);
-                        MP_WritePhyUshort(sc, 0x15, 0x0029);
-                        MP_WritePhyUshort(sc, 0x19, 0xa631);
-                        MP_WritePhyUshort(sc, 0x15, 0x002a);
-                        MP_WritePhyUshort(sc, 0x19, 0x9717);
-                        MP_WritePhyUshort(sc, 0x15, 0x002b);
-                        MP_WritePhyUshort(sc, 0x19, 0x302c);
-                        MP_WritePhyUshort(sc, 0x15, 0x002c);
-                        MP_WritePhyUshort(sc, 0x19, 0x4802);
-                        MP_WritePhyUshort(sc, 0x15, 0x002d);
-                        MP_WritePhyUshort(sc, 0x19, 0x58da);
-                        MP_WritePhyUshort(sc, 0x15, 0x002e);
-                        MP_WritePhyUshort(sc, 0x19, 0x400d);
-                        MP_WritePhyUshort(sc, 0x15, 0x002f);
-                        MP_WritePhyUshort(sc, 0x19, 0x4488);
-                        MP_WritePhyUshort(sc, 0x15, 0x0030);
-                        MP_WritePhyUshort(sc, 0x19, 0x9e00);
-                        MP_WritePhyUshort(sc, 0x15, 0x0031);
-                        MP_WritePhyUshort(sc, 0x19, 0x63c8);
-                        MP_WritePhyUshort(sc, 0x15, 0x0032);
-                        MP_WritePhyUshort(sc, 0x19, 0x6481);
-                        MP_WritePhyUshort(sc, 0x15, 0x0033);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x15, 0x0034);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x15, 0x0035);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x15, 0x0036);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x15, 0x0037);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x15, 0x0038);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x15, 0x0039);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x15, 0x003a);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x15, 0x003b);
-                        MP_WritePhyUshort(sc, 0x19, 0x63e8);
-                        MP_WritePhyUshort(sc, 0x15, 0x003c);
-                        MP_WritePhyUshort(sc, 0x19, 0x7d00);
-                        MP_WritePhyUshort(sc, 0x15, 0x003d);
-                        MP_WritePhyUshort(sc, 0x19, 0x59d4);
-                        MP_WritePhyUshort(sc, 0x15, 0x003e);
-                        MP_WritePhyUshort(sc, 0x19, 0x63f8);
-                        MP_WritePhyUshort(sc, 0x15, 0x0040);
-                        MP_WritePhyUshort(sc, 0x19, 0x64a1);
-                        MP_WritePhyUshort(sc, 0x15, 0x0041);
-                        MP_WritePhyUshort(sc, 0x19, 0x30de);
-                        MP_WritePhyUshort(sc, 0x15, 0x0044);
-                        MP_WritePhyUshort(sc, 0x19, 0x480f);
-                        MP_WritePhyUshort(sc, 0x15, 0x0045);
-                        MP_WritePhyUshort(sc, 0x19, 0x6800);
-                        MP_WritePhyUshort(sc, 0x15, 0x0046);
-                        MP_WritePhyUshort(sc, 0x19, 0x6680);
-                        MP_WritePhyUshort(sc, 0x15, 0x0047);
-                        MP_WritePhyUshort(sc, 0x19, 0x7c10);
-                        MP_WritePhyUshort(sc, 0x15, 0x0048);
-                        MP_WritePhyUshort(sc, 0x19, 0x63c8);
-                        MP_WritePhyUshort(sc, 0x15, 0x0049);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x15, 0x004a);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x15, 0x004b);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x15, 0x004c);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x15, 0x004d);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x15, 0x004e);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x15, 0x004f);
-                        MP_WritePhyUshort(sc, 0x19, 0x40ea);
-                        MP_WritePhyUshort(sc, 0x15, 0x0050);
-                        MP_WritePhyUshort(sc, 0x19, 0x4503);
-                        MP_WritePhyUshort(sc, 0x15, 0x0051);
-                        MP_WritePhyUshort(sc, 0x19, 0x58ca);
-                        MP_WritePhyUshort(sc, 0x15, 0x0052);
-                        MP_WritePhyUshort(sc, 0x19, 0x63c8);
-                        MP_WritePhyUshort(sc, 0x15, 0x0053);
-                        MP_WritePhyUshort(sc, 0x19, 0x63d8);
-                        MP_WritePhyUshort(sc, 0x15, 0x0054);
-                        MP_WritePhyUshort(sc, 0x19, 0x66a0);
-                        MP_WritePhyUshort(sc, 0x15, 0x0055);
-                        MP_WritePhyUshort(sc, 0x19, 0x9f00);
-                        MP_WritePhyUshort(sc, 0x15, 0x0056);
-                        MP_WritePhyUshort(sc, 0x19, 0x3000);
-                        MP_WritePhyUshort(sc, 0x15, 0x006E);
-                        MP_WritePhyUshort(sc, 0x19, 0x9afa);
-                        MP_WritePhyUshort(sc, 0x15, 0x00a1);
-                        MP_WritePhyUshort(sc, 0x19, 0x3044);
-                        MP_WritePhyUshort(sc, 0x15, 0x00ab);
-                        MP_WritePhyUshort(sc, 0x19, 0x5820);
-                        MP_WritePhyUshort(sc, 0x15, 0x00ac);
-                        MP_WritePhyUshort(sc, 0x19, 0x5e04);
-                        MP_WritePhyUshort(sc, 0x15, 0x00ad);
-                        MP_WritePhyUshort(sc, 0x19, 0xb60c);
-                        MP_WritePhyUshort(sc, 0x15, 0x00af);
-                        MP_WritePhyUshort(sc, 0x19, 0x000a);
-                        MP_WritePhyUshort(sc, 0x15, 0x00b2);
-                        MP_WritePhyUshort(sc, 0x19, 0x30b9);
-                        MP_WritePhyUshort(sc, 0x15, 0x00b9);
-                        MP_WritePhyUshort(sc, 0x19, 0x4408);
-                        MP_WritePhyUshort(sc, 0x15, 0x00ba);
-                        MP_WritePhyUshort(sc, 0x19, 0x480b);
-                        MP_WritePhyUshort(sc, 0x15, 0x00bb);
-                        MP_WritePhyUshort(sc, 0x19, 0x5e00);
-                        MP_WritePhyUshort(sc, 0x15, 0x00bc);
-                        MP_WritePhyUshort(sc, 0x19, 0x405f);
-                        MP_WritePhyUshort(sc, 0x15, 0x00bd);
-                        MP_WritePhyUshort(sc, 0x19, 0x4448);
-                        MP_WritePhyUshort(sc, 0x15, 0x00be);
-                        MP_WritePhyUshort(sc, 0x19, 0x4020);
-                        MP_WritePhyUshort(sc, 0x15, 0x00bf);
-                        MP_WritePhyUshort(sc, 0x19, 0x4468);
-                        MP_WritePhyUshort(sc, 0x15, 0x00c0);
-                        MP_WritePhyUshort(sc, 0x19, 0x9c02);
-                        MP_WritePhyUshort(sc, 0x15, 0x00c1);
-                        MP_WritePhyUshort(sc, 0x19, 0x58a0);
-                        MP_WritePhyUshort(sc, 0x15, 0x00c2);
-                        MP_WritePhyUshort(sc, 0x19, 0xb605);
-                        MP_WritePhyUshort(sc, 0x15, 0x00c3);
-                        MP_WritePhyUshort(sc, 0x19, 0xc0d3);
-                        MP_WritePhyUshort(sc, 0x15, 0x00c4);
-                        MP_WritePhyUshort(sc, 0x19, 0x00e6);
-                        MP_WritePhyUshort(sc, 0x15, 0x00c5);
-                        MP_WritePhyUshort(sc, 0x19, 0xdaec);
-                        MP_WritePhyUshort(sc, 0x15, 0x00c6);
-                        MP_WritePhyUshort(sc, 0x19, 0x00fa);
-                        MP_WritePhyUshort(sc, 0x15, 0x00c7);
-                        MP_WritePhyUshort(sc, 0x19, 0x9df9);
-                        MP_WritePhyUshort(sc, 0x15, 0x00c8);
-                        MP_WritePhyUshort(sc, 0x19, 0x307a);
-                        MP_WritePhyUshort(sc, 0x15, 0x0112);
-                        MP_WritePhyUshort(sc, 0x19, 0x6421);
-                        MP_WritePhyUshort(sc, 0x15, 0x0113);
-                        MP_WritePhyUshort(sc, 0x19, 0x7c08);
-                        MP_WritePhyUshort(sc, 0x15, 0x0114);
-                        MP_WritePhyUshort(sc, 0x19, 0x63f0);
-                        MP_WritePhyUshort(sc, 0x15, 0x0115);
-                        MP_WritePhyUshort(sc, 0x19, 0x4003);
-                        MP_WritePhyUshort(sc, 0x15, 0x0116);
-                        MP_WritePhyUshort(sc, 0x19, 0x4418);
-                        MP_WritePhyUshort(sc, 0x15, 0x0117);
-                        MP_WritePhyUshort(sc, 0x19, 0x9b00);
-                        MP_WritePhyUshort(sc, 0x15, 0x0118);
-                        MP_WritePhyUshort(sc, 0x19, 0x6461);
-                        MP_WritePhyUshort(sc, 0x15, 0x0119);
-                        MP_WritePhyUshort(sc, 0x19, 0x64e1);
-                        MP_WritePhyUshort(sc, 0x15, 0x011a);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x15, 0x0150);
-                        MP_WritePhyUshort(sc, 0x19, 0x7c80);
-                        MP_WritePhyUshort(sc, 0x15, 0x0151);
-                        MP_WritePhyUshort(sc, 0x19, 0x6461);
-                        MP_WritePhyUshort(sc, 0x15, 0x0152);
-                        MP_WritePhyUshort(sc, 0x19, 0x4003);
-                        MP_WritePhyUshort(sc, 0x15, 0x0153);
-                        MP_WritePhyUshort(sc, 0x19, 0x4540);
-                        MP_WritePhyUshort(sc, 0x15, 0x0154);
-                        MP_WritePhyUshort(sc, 0x19, 0x9f00);
-                        MP_WritePhyUshort(sc, 0x15, 0x0155);
-                        MP_WritePhyUshort(sc, 0x19, 0x9d00);
-                        MP_WritePhyUshort(sc, 0x15, 0x0156);
-                        MP_WritePhyUshort(sc, 0x19, 0x7c40);
-                        MP_WritePhyUshort(sc, 0x15, 0x0157);
-                        MP_WritePhyUshort(sc, 0x19, 0x6421);
-                        MP_WritePhyUshort(sc, 0x15, 0x0158);
-                        MP_WritePhyUshort(sc, 0x19, 0x7c80);
-                        MP_WritePhyUshort(sc, 0x15, 0x0159);
-                        MP_WritePhyUshort(sc, 0x19, 0x64a1);
-                        MP_WritePhyUshort(sc, 0x15, 0x015a);
-                        MP_WritePhyUshort(sc, 0x19, 0x30fe);
-                        MP_WritePhyUshort(sc, 0x15, 0x021e);
-                        MP_WritePhyUshort(sc, 0x19, 0x5410);
-                        MP_WritePhyUshort(sc, 0x15, 0x0225);
-                        MP_WritePhyUshort(sc, 0x19, 0x5400);
-                        MP_WritePhyUshort(sc, 0x15, 0x023D);
-                        MP_WritePhyUshort(sc, 0x19, 0x4050);
-                        MP_WritePhyUshort(sc, 0x15, 0x0295);
-                        MP_WritePhyUshort(sc, 0x19, 0x6c08);
-                        MP_WritePhyUshort(sc, 0x15, 0x02bd);
-                        MP_WritePhyUshort(sc, 0x19, 0xa523);
-                        MP_WritePhyUshort(sc, 0x15, 0x02be);
-                        MP_WritePhyUshort(sc, 0x19, 0x32ca);
-                        MP_WritePhyUshort(sc, 0x15, 0x02ca);
-                        MP_WritePhyUshort(sc, 0x19, 0x48b3);
-                        MP_WritePhyUshort(sc, 0x15, 0x02cb);
-                        MP_WritePhyUshort(sc, 0x19, 0x4020);
-                        MP_WritePhyUshort(sc, 0x15, 0x02cc);
-                        MP_WritePhyUshort(sc, 0x19, 0x4823);
-                        MP_WritePhyUshort(sc, 0x15, 0x02cd);
-                        MP_WritePhyUshort(sc, 0x19, 0x4510);
-                        MP_WritePhyUshort(sc, 0x15, 0x02ce);
-                        MP_WritePhyUshort(sc, 0x19, 0xb63a);
-                        MP_WritePhyUshort(sc, 0x15, 0x02cf);
-                        MP_WritePhyUshort(sc, 0x19, 0x7dc8);
-                        MP_WritePhyUshort(sc, 0x15, 0x02d6);
-                        MP_WritePhyUshort(sc, 0x19, 0x9bf8);
-                        MP_WritePhyUshort(sc, 0x15, 0x02d8);
-                        MP_WritePhyUshort(sc, 0x19, 0x85f6);
-                        MP_WritePhyUshort(sc, 0x15, 0x02d9);
-                        MP_WritePhyUshort(sc, 0x19, 0x32e0);
-                        MP_WritePhyUshort(sc, 0x15, 0x02e0);
-                        MP_WritePhyUshort(sc, 0x19, 0x4834);
-                        MP_WritePhyUshort(sc, 0x15, 0x02e1);
-                        MP_WritePhyUshort(sc, 0x19, 0x6c08);
-                        MP_WritePhyUshort(sc, 0x15, 0x02e2);
-                        MP_WritePhyUshort(sc, 0x19, 0x4020);
-                        MP_WritePhyUshort(sc, 0x15, 0x02e3);
-                        MP_WritePhyUshort(sc, 0x19, 0x4824);
-                        MP_WritePhyUshort(sc, 0x15, 0x02e4);
-                        MP_WritePhyUshort(sc, 0x19, 0x4520);
-                        MP_WritePhyUshort(sc, 0x15, 0x02e5);
-                        MP_WritePhyUshort(sc, 0x19, 0x4008);
-                        MP_WritePhyUshort(sc, 0x15, 0x02e6);
-                        MP_WritePhyUshort(sc, 0x19, 0x4560);
-                        MP_WritePhyUshort(sc, 0x15, 0x02e7);
-                        MP_WritePhyUshort(sc, 0x19, 0x9d04);
-                        MP_WritePhyUshort(sc, 0x15, 0x02e8);
-                        MP_WritePhyUshort(sc, 0x19, 0x48c4);
-                        MP_WritePhyUshort(sc, 0x15, 0x02e9);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x15, 0x02ea);
-                        MP_WritePhyUshort(sc, 0x19, 0x4844);
-                        MP_WritePhyUshort(sc, 0x15, 0x02eb);
-                        MP_WritePhyUshort(sc, 0x19, 0x7dc8);
-                        MP_WritePhyUshort(sc, 0x15, 0x02f0);
-                        MP_WritePhyUshort(sc, 0x19, 0x9cf7);
-                        MP_WritePhyUshort(sc, 0x15, 0x02f1);
-                        MP_WritePhyUshort(sc, 0x19, 0xdf94);
-                        MP_WritePhyUshort(sc, 0x15, 0x02f2);
-                        MP_WritePhyUshort(sc, 0x19, 0x0002);
-                        MP_WritePhyUshort(sc, 0x15, 0x02f3);
-                        MP_WritePhyUshort(sc, 0x19, 0x6810);
-                        MP_WritePhyUshort(sc, 0x15, 0x02f4);
-                        MP_WritePhyUshort(sc, 0x19, 0xb614);
-                        MP_WritePhyUshort(sc, 0x15, 0x02f5);
-                        MP_WritePhyUshort(sc, 0x19, 0xc42b);
-                        MP_WritePhyUshort(sc, 0x15, 0x02f6);
-                        MP_WritePhyUshort(sc, 0x19, 0x00d4);
-                        MP_WritePhyUshort(sc, 0x15, 0x02f7);
-                        MP_WritePhyUshort(sc, 0x19, 0xc455);
-                        MP_WritePhyUshort(sc, 0x15, 0x02f8);
-                        MP_WritePhyUshort(sc, 0x19, 0x0093);
-                        MP_WritePhyUshort(sc, 0x15, 0x02f9);
-                        MP_WritePhyUshort(sc, 0x19, 0x92ee);
-                        MP_WritePhyUshort(sc, 0x15, 0x02fa);
-                        MP_WritePhyUshort(sc, 0x19, 0xefed);
-                        MP_WritePhyUshort(sc, 0x15, 0x02fb);
-                        MP_WritePhyUshort(sc, 0x19, 0x3312);
-                        MP_WritePhyUshort(sc, 0x15, 0x0312);
-                        MP_WritePhyUshort(sc, 0x19, 0x49b5);
-                        MP_WritePhyUshort(sc, 0x15, 0x0313);
-                        MP_WritePhyUshort(sc, 0x19, 0x7d00);
-                        MP_WritePhyUshort(sc, 0x15, 0x0314);
-                        MP_WritePhyUshort(sc, 0x19, 0x4d00);
-                        MP_WritePhyUshort(sc, 0x15, 0x0315);
-                        MP_WritePhyUshort(sc, 0x19, 0x6810);
-                        MP_WritePhyUshort(sc, 0x15, 0x031e);
-                        MP_WritePhyUshort(sc, 0x19, 0x404f);
-                        MP_WritePhyUshort(sc, 0x15, 0x031f);
-                        MP_WritePhyUshort(sc, 0x19, 0x44c8);
-                        MP_WritePhyUshort(sc, 0x15, 0x0320);
-                        MP_WritePhyUshort(sc, 0x19, 0xd64f);
-                        MP_WritePhyUshort(sc, 0x15, 0x0321);
-                        MP_WritePhyUshort(sc, 0x19, 0x00e7);
-                        MP_WritePhyUshort(sc, 0x15, 0x0322);
-                        MP_WritePhyUshort(sc, 0x19, 0x7c08);
-                        MP_WritePhyUshort(sc, 0x15, 0x0323);
-                        MP_WritePhyUshort(sc, 0x19, 0x8203);
-                        MP_WritePhyUshort(sc, 0x15, 0x0324);
-                        MP_WritePhyUshort(sc, 0x19, 0x4d48);
-                        MP_WritePhyUshort(sc, 0x15, 0x0325);
-                        MP_WritePhyUshort(sc, 0x19, 0x3327);
-                        MP_WritePhyUshort(sc, 0x15, 0x0326);
-                        MP_WritePhyUshort(sc, 0x19, 0x4d40);
-                        MP_WritePhyUshort(sc, 0x15, 0x0327);
-                        MP_WritePhyUshort(sc, 0x19, 0xc8d7);
-                        MP_WritePhyUshort(sc, 0x15, 0x0328);
-                        MP_WritePhyUshort(sc, 0x19, 0x0003);
-                        MP_WritePhyUshort(sc, 0x15, 0x0329);
-                        MP_WritePhyUshort(sc, 0x19, 0x7c20);
-                        MP_WritePhyUshort(sc, 0x15, 0x032a);
-                        MP_WritePhyUshort(sc, 0x19, 0x4c20);
-                        MP_WritePhyUshort(sc, 0x15, 0x032b);
-                        MP_WritePhyUshort(sc, 0x19, 0xc8ed);
-                        MP_WritePhyUshort(sc, 0x15, 0x032c);
-                        MP_WritePhyUshort(sc, 0x19, 0x00f4);
-                        MP_WritePhyUshort(sc, 0x15, 0x032d);
-                        MP_WritePhyUshort(sc, 0x19, 0x82b3);
-                        MP_WritePhyUshort(sc, 0x15, 0x032e);
-                        MP_WritePhyUshort(sc, 0x19, 0xd11d);
-                        MP_WritePhyUshort(sc, 0x15, 0x032f);
-                        MP_WritePhyUshort(sc, 0x19, 0x00b1);
-                        MP_WritePhyUshort(sc, 0x15, 0x0330);
-                        MP_WritePhyUshort(sc, 0x19, 0xde18);
-                        MP_WritePhyUshort(sc, 0x15, 0x0331);
-                        MP_WritePhyUshort(sc, 0x19, 0x0008);
-                        MP_WritePhyUshort(sc, 0x15, 0x0332);
-                        MP_WritePhyUshort(sc, 0x19, 0x91ee);
-                        MP_WritePhyUshort(sc, 0x15, 0x0333);
-                        MP_WritePhyUshort(sc, 0x19, 0x3339);
-                        MP_WritePhyUshort(sc, 0x15, 0x033a);
-                        MP_WritePhyUshort(sc, 0x19, 0x4064);
-                        MP_WritePhyUshort(sc, 0x15, 0x0340);
-                        MP_WritePhyUshort(sc, 0x19, 0x9e06);
-                        MP_WritePhyUshort(sc, 0x15, 0x0341);
-                        MP_WritePhyUshort(sc, 0x19, 0x7c08);
-                        MP_WritePhyUshort(sc, 0x15, 0x0342);
-                        MP_WritePhyUshort(sc, 0x19, 0x8203);
-                        MP_WritePhyUshort(sc, 0x15, 0x0343);
-                        MP_WritePhyUshort(sc, 0x19, 0x4d48);
-                        MP_WritePhyUshort(sc, 0x15, 0x0344);
-                        MP_WritePhyUshort(sc, 0x19, 0x3346);
-                        MP_WritePhyUshort(sc, 0x15, 0x0345);
-                        MP_WritePhyUshort(sc, 0x19, 0x4d40);
-                        MP_WritePhyUshort(sc, 0x15, 0x0346);
-                        MP_WritePhyUshort(sc, 0x19, 0xd11d);
-                        MP_WritePhyUshort(sc, 0x15, 0x0347);
-                        MP_WritePhyUshort(sc, 0x19, 0x0099);
-                        MP_WritePhyUshort(sc, 0x15, 0x0348);
-                        MP_WritePhyUshort(sc, 0x19, 0xbb17);
-                        MP_WritePhyUshort(sc, 0x15, 0x0349);
-                        MP_WritePhyUshort(sc, 0x19, 0x8102);
-                        MP_WritePhyUshort(sc, 0x15, 0x034a);
-                        MP_WritePhyUshort(sc, 0x19, 0x334d);
-                        MP_WritePhyUshort(sc, 0x15, 0x034b);
-                        MP_WritePhyUshort(sc, 0x19, 0xa22c);
-                        MP_WritePhyUshort(sc, 0x15, 0x034c);
-                        MP_WritePhyUshort(sc, 0x19, 0x3397);
-                        MP_WritePhyUshort(sc, 0x15, 0x034d);
-                        MP_WritePhyUshort(sc, 0x19, 0x91f2);
-                        MP_WritePhyUshort(sc, 0x15, 0x034e);
-                        MP_WritePhyUshort(sc, 0x19, 0xc218);
-                        MP_WritePhyUshort(sc, 0x15, 0x034f);
-                        MP_WritePhyUshort(sc, 0x19, 0x00f0);
-                        MP_WritePhyUshort(sc, 0x15, 0x0350);
-                        MP_WritePhyUshort(sc, 0x19, 0x3397);
-                        MP_WritePhyUshort(sc, 0x15, 0x0351);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x15, 0x0364);
-                        MP_WritePhyUshort(sc, 0x19, 0xbc05);
-                        MP_WritePhyUshort(sc, 0x15, 0x0367);
-                        MP_WritePhyUshort(sc, 0x19, 0xa1fc);
-                        MP_WritePhyUshort(sc, 0x15, 0x0368);
-                        MP_WritePhyUshort(sc, 0x19, 0x3377);
-                        MP_WritePhyUshort(sc, 0x15, 0x0369);
-                        MP_WritePhyUshort(sc, 0x19, 0x328b);
-                        MP_WritePhyUshort(sc, 0x15, 0x036a);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x15, 0x0377);
-                        MP_WritePhyUshort(sc, 0x19, 0x4b97);
-                        MP_WritePhyUshort(sc, 0x15, 0x0378);
-                        MP_WritePhyUshort(sc, 0x19, 0x6818);
-                        MP_WritePhyUshort(sc, 0x15, 0x0379);
-                        MP_WritePhyUshort(sc, 0x19, 0x4b07);
-                        MP_WritePhyUshort(sc, 0x15, 0x037a);
-                        MP_WritePhyUshort(sc, 0x19, 0x40ac);
-                        MP_WritePhyUshort(sc, 0x15, 0x037b);
-                        MP_WritePhyUshort(sc, 0x19, 0x4445);
-                        MP_WritePhyUshort(sc, 0x15, 0x037c);
-                        MP_WritePhyUshort(sc, 0x19, 0x404e);
-                        MP_WritePhyUshort(sc, 0x15, 0x037d);
-                        MP_WritePhyUshort(sc, 0x19, 0x4461);
-                        MP_WritePhyUshort(sc, 0x15, 0x037e);
-                        MP_WritePhyUshort(sc, 0x19, 0x9c09);
-                        MP_WritePhyUshort(sc, 0x15, 0x037f);
-                        MP_WritePhyUshort(sc, 0x19, 0x63da);
-                        MP_WritePhyUshort(sc, 0x15, 0x0380);
-                        MP_WritePhyUshort(sc, 0x19, 0x5440);
-                        MP_WritePhyUshort(sc, 0x15, 0x0381);
-                        MP_WritePhyUshort(sc, 0x19, 0x4b98);
-                        MP_WritePhyUshort(sc, 0x15, 0x0382);
-                        MP_WritePhyUshort(sc, 0x19, 0x7c60);
-                        MP_WritePhyUshort(sc, 0x15, 0x0383);
-                        MP_WritePhyUshort(sc, 0x19, 0x4c00);
-                        MP_WritePhyUshort(sc, 0x15, 0x0384);
-                        MP_WritePhyUshort(sc, 0x19, 0x4b08);
-                        MP_WritePhyUshort(sc, 0x15, 0x0385);
-                        MP_WritePhyUshort(sc, 0x19, 0x63d8);
-                        MP_WritePhyUshort(sc, 0x15, 0x0386);
-                        MP_WritePhyUshort(sc, 0x19, 0x338d);
-                        MP_WritePhyUshort(sc, 0x15, 0x0387);
-                        MP_WritePhyUshort(sc, 0x19, 0xd64f);
-                        MP_WritePhyUshort(sc, 0x15, 0x0388);
-                        MP_WritePhyUshort(sc, 0x19, 0x0080);
-                        MP_WritePhyUshort(sc, 0x15, 0x0389);
-                        MP_WritePhyUshort(sc, 0x19, 0x820c);
-                        MP_WritePhyUshort(sc, 0x15, 0x038a);
-                        MP_WritePhyUshort(sc, 0x19, 0xa10b);
-                        MP_WritePhyUshort(sc, 0x15, 0x038b);
-                        MP_WritePhyUshort(sc, 0x19, 0x9df3);
-                        MP_WritePhyUshort(sc, 0x15, 0x038c);
-                        MP_WritePhyUshort(sc, 0x19, 0x3395);
-                        MP_WritePhyUshort(sc, 0x15, 0x038d);
-                        MP_WritePhyUshort(sc, 0x19, 0xd64f);
-                        MP_WritePhyUshort(sc, 0x15, 0x038e);
-                        MP_WritePhyUshort(sc, 0x19, 0x00f9);
-                        MP_WritePhyUshort(sc, 0x15, 0x038f);
-                        MP_WritePhyUshort(sc, 0x19, 0xc017);
-                        MP_WritePhyUshort(sc, 0x15, 0x0390);
-                        MP_WritePhyUshort(sc, 0x19, 0x0005);
-                        MP_WritePhyUshort(sc, 0x15, 0x0391);
-                        MP_WritePhyUshort(sc, 0x19, 0x6c0b);
-                        MP_WritePhyUshort(sc, 0x15, 0x0392);
-                        MP_WritePhyUshort(sc, 0x19, 0xa103);
-                        MP_WritePhyUshort(sc, 0x15, 0x0393);
-                        MP_WritePhyUshort(sc, 0x19, 0x6c08);
-                        MP_WritePhyUshort(sc, 0x15, 0x0394);
-                        MP_WritePhyUshort(sc, 0x19, 0x9df9);
-                        MP_WritePhyUshort(sc, 0x15, 0x0395);
-                        MP_WritePhyUshort(sc, 0x19, 0x6c08);
-                        MP_WritePhyUshort(sc, 0x15, 0x0396);
-                        MP_WritePhyUshort(sc, 0x19, 0x3397);
-                        MP_WritePhyUshort(sc, 0x15, 0x0399);
-                        MP_WritePhyUshort(sc, 0x19, 0x6810);
-                        MP_WritePhyUshort(sc, 0x15, 0x03a4);
-                        MP_WritePhyUshort(sc, 0x19, 0x7c08);
-                        MP_WritePhyUshort(sc, 0x15, 0x03a5);
-                        MP_WritePhyUshort(sc, 0x19, 0x8203);
-                        MP_WritePhyUshort(sc, 0x15, 0x03a6);
-                        MP_WritePhyUshort(sc, 0x19, 0x4d08);
-                        MP_WritePhyUshort(sc, 0x15, 0x03a7);
-                        MP_WritePhyUshort(sc, 0x19, 0x33a9);
-                        MP_WritePhyUshort(sc, 0x15, 0x03a8);
-                        MP_WritePhyUshort(sc, 0x19, 0x4d00);
-                        MP_WritePhyUshort(sc, 0x15, 0x03a9);
-                        MP_WritePhyUshort(sc, 0x19, 0x9bfa);
-                        MP_WritePhyUshort(sc, 0x15, 0x03aa);
-                        MP_WritePhyUshort(sc, 0x19, 0x33b6);
-                        MP_WritePhyUshort(sc, 0x15, 0x03bb);
-                        MP_WritePhyUshort(sc, 0x19, 0x4056);
-                        MP_WritePhyUshort(sc, 0x15, 0x03bc);
-                        MP_WritePhyUshort(sc, 0x19, 0x44e9);
-                        MP_WritePhyUshort(sc, 0x15, 0x03bd);
-                        MP_WritePhyUshort(sc, 0x19, 0x405e);
-                        MP_WritePhyUshort(sc, 0x15, 0x03be);
-                        MP_WritePhyUshort(sc, 0x19, 0x44f8);
-                        MP_WritePhyUshort(sc, 0x15, 0x03bf);
-                        MP_WritePhyUshort(sc, 0x19, 0xd64f);
-                        MP_WritePhyUshort(sc, 0x15, 0x03c0);
-                        MP_WritePhyUshort(sc, 0x19, 0x0037);
-                        MP_WritePhyUshort(sc, 0x15, 0x03c1);
-                        MP_WritePhyUshort(sc, 0x19, 0xbd37);
-                        MP_WritePhyUshort(sc, 0x15, 0x03c2);
-                        MP_WritePhyUshort(sc, 0x19, 0x9cfd);
-                        MP_WritePhyUshort(sc, 0x15, 0x03c3);
-                        MP_WritePhyUshort(sc, 0x19, 0xc639);
-                        MP_WritePhyUshort(sc, 0x15, 0x03c4);
-                        MP_WritePhyUshort(sc, 0x19, 0x0011);
-                        MP_WritePhyUshort(sc, 0x15, 0x03c5);
-                        MP_WritePhyUshort(sc, 0x19, 0x9b03);
-                        MP_WritePhyUshort(sc, 0x15, 0x03c6);
-                        MP_WritePhyUshort(sc, 0x19, 0x7c01);
-                        MP_WritePhyUshort(sc, 0x15, 0x03c7);
-                        MP_WritePhyUshort(sc, 0x19, 0x4c01);
-                        MP_WritePhyUshort(sc, 0x15, 0x03c8);
-                        MP_WritePhyUshort(sc, 0x19, 0x9e03);
-                        MP_WritePhyUshort(sc, 0x15, 0x03c9);
-                        MP_WritePhyUshort(sc, 0x19, 0x7c20);
-                        MP_WritePhyUshort(sc, 0x15, 0x03ca);
-                        MP_WritePhyUshort(sc, 0x19, 0x4c20);
-                        MP_WritePhyUshort(sc, 0x15, 0x03cb);
-                        MP_WritePhyUshort(sc, 0x19, 0x9af4);
-                        MP_WritePhyUshort(sc, 0x15, 0x03cc);
-                        MP_WritePhyUshort(sc, 0x19, 0x7c12);
-                        MP_WritePhyUshort(sc, 0x15, 0x03cd);
-                        MP_WritePhyUshort(sc, 0x19, 0x4c52);
-                        MP_WritePhyUshort(sc, 0x15, 0x03ce);
-                        MP_WritePhyUshort(sc, 0x19, 0x4470);
-                        MP_WritePhyUshort(sc, 0x15, 0x03cf);
-                        MP_WritePhyUshort(sc, 0x19, 0x7c12);
-                        MP_WritePhyUshort(sc, 0x15, 0x03d0);
-                        MP_WritePhyUshort(sc, 0x19, 0x4c40);
-                        MP_WritePhyUshort(sc, 0x15, 0x03d1);
-                        MP_WritePhyUshort(sc, 0x19, 0x33bf);
-                        MP_WritePhyUshort(sc, 0x15, 0x03d6);
-                        MP_WritePhyUshort(sc, 0x19, 0x4047);
-                        MP_WritePhyUshort(sc, 0x15, 0x03d7);
-                        MP_WritePhyUshort(sc, 0x19, 0x4469);
-                        MP_WritePhyUshort(sc, 0x15, 0x03d8);
-                        MP_WritePhyUshort(sc, 0x19, 0x492b);
-                        MP_WritePhyUshort(sc, 0x15, 0x03d9);
-                        MP_WritePhyUshort(sc, 0x19, 0x4479);
-                        MP_WritePhyUshort(sc, 0x15, 0x03da);
-                        MP_WritePhyUshort(sc, 0x19, 0x7c09);
-                        MP_WritePhyUshort(sc, 0x15, 0x03db);
-                        MP_WritePhyUshort(sc, 0x19, 0x8203);
-                        MP_WritePhyUshort(sc, 0x15, 0x03dc);
-                        MP_WritePhyUshort(sc, 0x19, 0x4d48);
-                        MP_WritePhyUshort(sc, 0x15, 0x03dd);
-                        MP_WritePhyUshort(sc, 0x19, 0x33df);
-                        MP_WritePhyUshort(sc, 0x15, 0x03de);
-                        MP_WritePhyUshort(sc, 0x19, 0x4d40);
-                        MP_WritePhyUshort(sc, 0x15, 0x03df);
-                        MP_WritePhyUshort(sc, 0x19, 0xd64f);
-                        MP_WritePhyUshort(sc, 0x15, 0x03e0);
-                        MP_WritePhyUshort(sc, 0x19, 0x0017);
-                        MP_WritePhyUshort(sc, 0x15, 0x03e1);
-                        MP_WritePhyUshort(sc, 0x19, 0xbd17);
-                        MP_WritePhyUshort(sc, 0x15, 0x03e2);
-                        MP_WritePhyUshort(sc, 0x19, 0x9b03);
-                        MP_WritePhyUshort(sc, 0x15, 0x03e3);
-                        MP_WritePhyUshort(sc, 0x19, 0x7c20);
-                        MP_WritePhyUshort(sc, 0x15, 0x03e4);
-                        MP_WritePhyUshort(sc, 0x19, 0x4c20);
-                        MP_WritePhyUshort(sc, 0x15, 0x03e5);
-                        MP_WritePhyUshort(sc, 0x19, 0x88f5);
-                        MP_WritePhyUshort(sc, 0x15, 0x03e6);
-                        MP_WritePhyUshort(sc, 0x19, 0xc428);
-                        MP_WritePhyUshort(sc, 0x15, 0x03e7);
-                        MP_WritePhyUshort(sc, 0x19, 0x0008);
-                        MP_WritePhyUshort(sc, 0x15, 0x03e8);
-                        MP_WritePhyUshort(sc, 0x19, 0x9af2);
-                        MP_WritePhyUshort(sc, 0x15, 0x03e9);
-                        MP_WritePhyUshort(sc, 0x19, 0x7c12);
-                        MP_WritePhyUshort(sc, 0x15, 0x03ea);
-                        MP_WritePhyUshort(sc, 0x19, 0x4c52);
-                        MP_WritePhyUshort(sc, 0x15, 0x03eb);
-                        MP_WritePhyUshort(sc, 0x19, 0x4470);
-                        MP_WritePhyUshort(sc, 0x15, 0x03ec);
-                        MP_WritePhyUshort(sc, 0x19, 0x7c12);
-                        MP_WritePhyUshort(sc, 0x15, 0x03ed);
-                        MP_WritePhyUshort(sc, 0x19, 0x4c40);
-                        MP_WritePhyUshort(sc, 0x15, 0x03ee);
-                        MP_WritePhyUshort(sc, 0x19, 0x33da);
-                        MP_WritePhyUshort(sc, 0x15, 0x03ef);
-                        MP_WritePhyUshort(sc, 0x19, 0x3312);
-                        MP_WritePhyUshort(sc, 0x16, 0x0306);
-                        MP_WritePhyUshort(sc, 0x16, 0x0300);
-                        MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                        MP_WritePhyUshort(sc, 0x17, 0x2179);
-                        MP_WritePhyUshort(sc, 0x1f, 0x0007);
-                        MP_WritePhyUshort(sc, 0x1e, 0x0040);
-                        MP_WritePhyUshort(sc, 0x18, 0x0645);
-                        MP_WritePhyUshort(sc, 0x19, 0xe200);
-                        MP_WritePhyUshort(sc, 0x18, 0x0655);
-                        MP_WritePhyUshort(sc, 0x19, 0x9000);
-                        MP_WritePhyUshort(sc, 0x18, 0x0d05);
-                        MP_WritePhyUshort(sc, 0x19, 0xbe00);
-                        MP_WritePhyUshort(sc, 0x18, 0x0d15);
-                        MP_WritePhyUshort(sc, 0x19, 0xd300);
-                        MP_WritePhyUshort(sc, 0x18, 0x0d25);
-                        MP_WritePhyUshort(sc, 0x19, 0xfe00);
-                        MP_WritePhyUshort(sc, 0x18, 0x0d35);
-                        MP_WritePhyUshort(sc, 0x19, 0x4000);
-                        MP_WritePhyUshort(sc, 0x18, 0x0d45);
-                        MP_WritePhyUshort(sc, 0x19, 0x7f00);
-                        MP_WritePhyUshort(sc, 0x18, 0x0d55);
-                        MP_WritePhyUshort(sc, 0x19, 0x1000);
-                        MP_WritePhyUshort(sc, 0x18, 0x0d65);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x18, 0x0d75);
-                        MP_WritePhyUshort(sc, 0x19, 0x8200);
-                        MP_WritePhyUshort(sc, 0x18, 0x0d85);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x18, 0x0d95);
-                        MP_WritePhyUshort(sc, 0x19, 0x7000);
-                        MP_WritePhyUshort(sc, 0x18, 0x0da5);
-                        MP_WritePhyUshort(sc, 0x19, 0x0f00);
-                        MP_WritePhyUshort(sc, 0x18, 0x0db5);
-                        MP_WritePhyUshort(sc, 0x19, 0x0100);
-                        MP_WritePhyUshort(sc, 0x18, 0x0dc5);
-                        MP_WritePhyUshort(sc, 0x19, 0x9b00);
-                        MP_WritePhyUshort(sc, 0x18, 0x0dd5);
-                        MP_WritePhyUshort(sc, 0x19, 0x7f00);
-                        MP_WritePhyUshort(sc, 0x18, 0x0de5);
-                        MP_WritePhyUshort(sc, 0x19, 0xe000);
-                        MP_WritePhyUshort(sc, 0x18, 0x0df5);
-                        MP_WritePhyUshort(sc, 0x19, 0xef00);
-                        MP_WritePhyUshort(sc, 0x18, 0x16d5);
-                        MP_WritePhyUshort(sc, 0x19, 0xe200);
-                        MP_WritePhyUshort(sc, 0x18, 0x16e5);
-                        MP_WritePhyUshort(sc, 0x19, 0xab00);
-                        MP_WritePhyUshort(sc, 0x18, 0x2904);
-                        MP_WritePhyUshort(sc, 0x19, 0x4000);
-                        MP_WritePhyUshort(sc, 0x18, 0x2914);
-                        MP_WritePhyUshort(sc, 0x19, 0x7f00);
-                        MP_WritePhyUshort(sc, 0x18, 0x2924);
-                        MP_WritePhyUshort(sc, 0x19, 0x0100);
-                        MP_WritePhyUshort(sc, 0x18, 0x2934);
-                        MP_WritePhyUshort(sc, 0x19, 0x2000);
-                        MP_WritePhyUshort(sc, 0x18, 0x2944);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x18, 0x2954);
-                        MP_WritePhyUshort(sc, 0x19, 0x4600);
-                        MP_WritePhyUshort(sc, 0x18, 0x2964);
-                        MP_WritePhyUshort(sc, 0x19, 0xfc00);
-                        MP_WritePhyUshort(sc, 0x18, 0x2974);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x18, 0x2984);
-                        MP_WritePhyUshort(sc, 0x19, 0x5000);
-                        MP_WritePhyUshort(sc, 0x18, 0x2994);
-                        MP_WritePhyUshort(sc, 0x19, 0x9d00);
-                        MP_WritePhyUshort(sc, 0x18, 0x29a4);
-                        MP_WritePhyUshort(sc, 0x19, 0xff00);
-                        MP_WritePhyUshort(sc, 0x18, 0x29b4);
-                        MP_WritePhyUshort(sc, 0x19, 0x4000);
-                        MP_WritePhyUshort(sc, 0x18, 0x29c4);
-                        MP_WritePhyUshort(sc, 0x19, 0x7f00);
-                        MP_WritePhyUshort(sc, 0x18, 0x29d4);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x18, 0x29e4);
-                        MP_WritePhyUshort(sc, 0x19, 0x2000);
-                        MP_WritePhyUshort(sc, 0x18, 0x29f4);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x18, 0x2a04);
-                        MP_WritePhyUshort(sc, 0x19, 0xe600);
-                        MP_WritePhyUshort(sc, 0x18, 0x2a14);
-                        MP_WritePhyUshort(sc, 0x19, 0xff00);
-                        MP_WritePhyUshort(sc, 0x18, 0x2a24);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x18, 0x2a34);
-                        MP_WritePhyUshort(sc, 0x19, 0x5000);
-                        MP_WritePhyUshort(sc, 0x18, 0x2a44);
-                        MP_WritePhyUshort(sc, 0x19, 0x8500);
-                        MP_WritePhyUshort(sc, 0x18, 0x2a54);
-                        MP_WritePhyUshort(sc, 0x19, 0x7f00);
-                        MP_WritePhyUshort(sc, 0x18, 0x2a64);
-                        MP_WritePhyUshort(sc, 0x19, 0xac00);
-                        MP_WritePhyUshort(sc, 0x18, 0x2a74);
-                        MP_WritePhyUshort(sc, 0x19, 0x0800);
-                        MP_WritePhyUshort(sc, 0x18, 0x2a84);
-                        MP_WritePhyUshort(sc, 0x19, 0xfc00);
-                        MP_WritePhyUshort(sc, 0x18, 0x2a94);
-                        MP_WritePhyUshort(sc, 0x19, 0xe000);
-                        MP_WritePhyUshort(sc, 0x18, 0x2aa4);
-                        MP_WritePhyUshort(sc, 0x19, 0x7400);
-                        MP_WritePhyUshort(sc, 0x18, 0x2ab4);
-                        MP_WritePhyUshort(sc, 0x19, 0x4000);
-                        MP_WritePhyUshort(sc, 0x18, 0x2ac4);
-                        MP_WritePhyUshort(sc, 0x19, 0x7f00);
-                        MP_WritePhyUshort(sc, 0x18, 0x2ad4);
-                        MP_WritePhyUshort(sc, 0x19, 0x0100);
-                        MP_WritePhyUshort(sc, 0x18, 0x2ae4);
-                        MP_WritePhyUshort(sc, 0x19, 0xff00);
-                        MP_WritePhyUshort(sc, 0x18, 0x2af4);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x18, 0x2b04);
-                        MP_WritePhyUshort(sc, 0x19, 0x4400);
-                        MP_WritePhyUshort(sc, 0x18, 0x2b14);
-                        MP_WritePhyUshort(sc, 0x19, 0xfc00);
-                        MP_WritePhyUshort(sc, 0x18, 0x2b24);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x18, 0x2b34);
-                        MP_WritePhyUshort(sc, 0x19, 0x4000);
-                        MP_WritePhyUshort(sc, 0x18, 0x2b44);
-                        MP_WritePhyUshort(sc, 0x19, 0x9d00);
-                        MP_WritePhyUshort(sc, 0x18, 0x2b54);
-                        MP_WritePhyUshort(sc, 0x19, 0xff00);
-                        MP_WritePhyUshort(sc, 0x18, 0x2b64);
-                        MP_WritePhyUshort(sc, 0x19, 0x4000);
-                        MP_WritePhyUshort(sc, 0x18, 0x2b74);
-                        MP_WritePhyUshort(sc, 0x19, 0x7f00);
-                        MP_WritePhyUshort(sc, 0x18, 0x2b84);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x18, 0x2b94);
-                        MP_WritePhyUshort(sc, 0x19, 0xff00);
-                        MP_WritePhyUshort(sc, 0x18, 0x2ba4);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x18, 0x2bb4);
-                        MP_WritePhyUshort(sc, 0x19, 0xfc00);
-                        MP_WritePhyUshort(sc, 0x18, 0x2bc4);
-                        MP_WritePhyUshort(sc, 0x19, 0xff00);
-                        MP_WritePhyUshort(sc, 0x18, 0x2bd4);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x18, 0x2be4);
-                        MP_WritePhyUshort(sc, 0x19, 0x4000);
-                        MP_WritePhyUshort(sc, 0x18, 0x2bf4);
-                        MP_WritePhyUshort(sc, 0x19, 0x8900);
-                        MP_WritePhyUshort(sc, 0x18, 0x2c04);
-                        MP_WritePhyUshort(sc, 0x19, 0x8300);
-                        MP_WritePhyUshort(sc, 0x18, 0x2c14);
-                        MP_WritePhyUshort(sc, 0x19, 0xe000);
-                        MP_WritePhyUshort(sc, 0x18, 0x2c24);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x18, 0x2c34);
-                        MP_WritePhyUshort(sc, 0x19, 0xac00);
-                        MP_WritePhyUshort(sc, 0x18, 0x2c44);
-                        MP_WritePhyUshort(sc, 0x19, 0x0800);
-                        MP_WritePhyUshort(sc, 0x18, 0x2c54);
-                        MP_WritePhyUshort(sc, 0x19, 0xfa00);
-                        MP_WritePhyUshort(sc, 0x18, 0x2c64);
-                        MP_WritePhyUshort(sc, 0x19, 0xe100);
-                        MP_WritePhyUshort(sc, 0x18, 0x2c74);
-                        MP_WritePhyUshort(sc, 0x19, 0x7f00);
-                        MP_WritePhyUshort(sc, 0x18, 0x0001);
-                        MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                        MP_WritePhyUshort(sc, 0x17, 0x2100);
-                        MP_WritePhyUshort(sc, 0x1f, 0x0005);
-                        MP_WritePhyUshort(sc, 0x05, 0xfff6);
-                        MP_WritePhyUshort(sc, 0x06, 0x0080);
-                        MP_WritePhyUshort(sc, 0x05, 0x8b88);
-                        MP_WritePhyUshort(sc, 0x06, 0x0000);
-                        MP_WritePhyUshort(sc, 0x06, 0x0000);
-                        MP_WritePhyUshort(sc, 0x06, 0x0000);
-                        MP_WritePhyUshort(sc, 0x06, 0x0000);
-                        MP_WritePhyUshort(sc, 0x05, 0x8000);
-                        MP_WritePhyUshort(sc, 0x06, 0xd480);
-                        MP_WritePhyUshort(sc, 0x06, 0xc1e4);
-                        MP_WritePhyUshort(sc, 0x06, 0x8b9a);
-                        MP_WritePhyUshort(sc, 0x06, 0xe58b);
-                        MP_WritePhyUshort(sc, 0x06, 0x9bee);
-                        MP_WritePhyUshort(sc, 0x06, 0x8b83);
-                        MP_WritePhyUshort(sc, 0x06, 0x41bf);
-                        MP_WritePhyUshort(sc, 0x06, 0x8b88);
-                        MP_WritePhyUshort(sc, 0x06, 0xec00);
-                        MP_WritePhyUshort(sc, 0x06, 0x19a9);
-                        MP_WritePhyUshort(sc, 0x06, 0x8b90);
-                        MP_WritePhyUshort(sc, 0x06, 0xf9ee);
-                        MP_WritePhyUshort(sc, 0x06, 0xfff6);
-                        MP_WritePhyUshort(sc, 0x06, 0x00ee);
-                        MP_WritePhyUshort(sc, 0x06, 0xfff7);
-                        MP_WritePhyUshort(sc, 0x06, 0xffe0);
-                        MP_WritePhyUshort(sc, 0x06, 0xe140);
-                        MP_WritePhyUshort(sc, 0x06, 0xe1e1);
-                        MP_WritePhyUshort(sc, 0x06, 0x41f7);
-                        MP_WritePhyUshort(sc, 0x06, 0x2ff6);
-                        MP_WritePhyUshort(sc, 0x06, 0x28e4);
-                        MP_WritePhyUshort(sc, 0x06, 0xe140);
-                        MP_WritePhyUshort(sc, 0x06, 0xe5e1);
-                        MP_WritePhyUshort(sc, 0x06, 0x41f7);
-                        MP_WritePhyUshort(sc, 0x06, 0x0002);
-                        MP_WritePhyUshort(sc, 0x06, 0x020c);
-                        MP_WritePhyUshort(sc, 0x06, 0x0202);
-                        MP_WritePhyUshort(sc, 0x06, 0x1d02);
-                        MP_WritePhyUshort(sc, 0x06, 0x0230);
-                        MP_WritePhyUshort(sc, 0x06, 0x0202);
-                        MP_WritePhyUshort(sc, 0x06, 0x4002);
-                        MP_WritePhyUshort(sc, 0x06, 0x028b);
-                        MP_WritePhyUshort(sc, 0x06, 0x0280);
-                        MP_WritePhyUshort(sc, 0x06, 0x6c02);
-                        MP_WritePhyUshort(sc, 0x06, 0x8085);
-                        MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                        MP_WritePhyUshort(sc, 0x06, 0x88e1);
-                        MP_WritePhyUshort(sc, 0x06, 0x8b89);
-                        MP_WritePhyUshort(sc, 0x06, 0x1e01);
-                        MP_WritePhyUshort(sc, 0x06, 0xe18b);
-                        MP_WritePhyUshort(sc, 0x06, 0x8a1e);
-                        MP_WritePhyUshort(sc, 0x06, 0x01e1);
-                        MP_WritePhyUshort(sc, 0x06, 0x8b8b);
-                        MP_WritePhyUshort(sc, 0x06, 0x1e01);
-                        MP_WritePhyUshort(sc, 0x06, 0xe18b);
-                        MP_WritePhyUshort(sc, 0x06, 0x8c1e);
-                        MP_WritePhyUshort(sc, 0x06, 0x01e1);
-                        MP_WritePhyUshort(sc, 0x06, 0x8b8d);
-                        MP_WritePhyUshort(sc, 0x06, 0x1e01);
-                        MP_WritePhyUshort(sc, 0x06, 0xe18b);
-                        MP_WritePhyUshort(sc, 0x06, 0x8e1e);
-                        MP_WritePhyUshort(sc, 0x06, 0x01a0);
-                        MP_WritePhyUshort(sc, 0x06, 0x00c7);
-                        MP_WritePhyUshort(sc, 0x06, 0xaec3);
-                        MP_WritePhyUshort(sc, 0x06, 0xf8e0);
-                        MP_WritePhyUshort(sc, 0x06, 0x8b8d);
-                        MP_WritePhyUshort(sc, 0x06, 0xad20);
-                        MP_WritePhyUshort(sc, 0x06, 0x10ee);
-                        MP_WritePhyUshort(sc, 0x06, 0x8b8d);
-                        MP_WritePhyUshort(sc, 0x06, 0x0002);
-                        MP_WritePhyUshort(sc, 0x06, 0x1310);
-                        MP_WritePhyUshort(sc, 0x06, 0x0280);
-                        MP_WritePhyUshort(sc, 0x06, 0xc602);
-                        MP_WritePhyUshort(sc, 0x06, 0x1f0c);
-                        MP_WritePhyUshort(sc, 0x06, 0x0227);
-                        MP_WritePhyUshort(sc, 0x06, 0x49fc);
-                        MP_WritePhyUshort(sc, 0x06, 0x04f8);
-                        MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                        MP_WritePhyUshort(sc, 0x06, 0x8ead);
-                        MP_WritePhyUshort(sc, 0x06, 0x200b);
-                        MP_WritePhyUshort(sc, 0x06, 0xf620);
-                        MP_WritePhyUshort(sc, 0x06, 0xe48b);
-                        MP_WritePhyUshort(sc, 0x06, 0x8e02);
-                        MP_WritePhyUshort(sc, 0x06, 0x852d);
-                        MP_WritePhyUshort(sc, 0x06, 0x021b);
-                        MP_WritePhyUshort(sc, 0x06, 0x67ad);
-                        MP_WritePhyUshort(sc, 0x06, 0x2211);
-                        MP_WritePhyUshort(sc, 0x06, 0xf622);
-                        MP_WritePhyUshort(sc, 0x06, 0xe48b);
-                        MP_WritePhyUshort(sc, 0x06, 0x8e02);
-                        MP_WritePhyUshort(sc, 0x06, 0x2ba5);
-                        MP_WritePhyUshort(sc, 0x06, 0x022a);
-                        MP_WritePhyUshort(sc, 0x06, 0x2402);
-                        MP_WritePhyUshort(sc, 0x06, 0x82e5);
-                        MP_WritePhyUshort(sc, 0x06, 0x022a);
-                        MP_WritePhyUshort(sc, 0x06, 0xf0ad);
-                        MP_WritePhyUshort(sc, 0x06, 0x2511);
-                        MP_WritePhyUshort(sc, 0x06, 0xf625);
-                        MP_WritePhyUshort(sc, 0x06, 0xe48b);
-                        MP_WritePhyUshort(sc, 0x06, 0x8e02);
-                        MP_WritePhyUshort(sc, 0x06, 0x8445);
-                        MP_WritePhyUshort(sc, 0x06, 0x0204);
-                        MP_WritePhyUshort(sc, 0x06, 0x0302);
-                        MP_WritePhyUshort(sc, 0x06, 0x19cc);
-                        MP_WritePhyUshort(sc, 0x06, 0x022b);
-                        MP_WritePhyUshort(sc, 0x06, 0x5bfc);
-                        MP_WritePhyUshort(sc, 0x06, 0x04ee);
-                        MP_WritePhyUshort(sc, 0x06, 0x8b8d);
-                        MP_WritePhyUshort(sc, 0x06, 0x0105);
-                        MP_WritePhyUshort(sc, 0x06, 0xf8f9);
-                        MP_WritePhyUshort(sc, 0x06, 0xfae0);
-                        MP_WritePhyUshort(sc, 0x06, 0x8b81);
-                        MP_WritePhyUshort(sc, 0x06, 0xac26);
-                        MP_WritePhyUshort(sc, 0x06, 0x08e0);
-                        MP_WritePhyUshort(sc, 0x06, 0x8b81);
-                        MP_WritePhyUshort(sc, 0x06, 0xac21);
-                        MP_WritePhyUshort(sc, 0x06, 0x02ae);
-                        MP_WritePhyUshort(sc, 0x06, 0x6bee);
-                        MP_WritePhyUshort(sc, 0x06, 0xe0ea);
-                        MP_WritePhyUshort(sc, 0x06, 0x00ee);
-                        MP_WritePhyUshort(sc, 0x06, 0xe0eb);
-                        MP_WritePhyUshort(sc, 0x06, 0x00e2);
-                        MP_WritePhyUshort(sc, 0x06, 0xe07c);
-                        MP_WritePhyUshort(sc, 0x06, 0xe3e0);
-                        MP_WritePhyUshort(sc, 0x06, 0x7da5);
-                        MP_WritePhyUshort(sc, 0x06, 0x1111);
-                        MP_WritePhyUshort(sc, 0x06, 0x15d2);
-                        MP_WritePhyUshort(sc, 0x06, 0x60d6);
-                        MP_WritePhyUshort(sc, 0x06, 0x6666);
-                        MP_WritePhyUshort(sc, 0x06, 0x0207);
-                        MP_WritePhyUshort(sc, 0x06, 0x6cd2);
-                        MP_WritePhyUshort(sc, 0x06, 0xa0d6);
-                        MP_WritePhyUshort(sc, 0x06, 0xaaaa);
-                        MP_WritePhyUshort(sc, 0x06, 0x0207);
-                        MP_WritePhyUshort(sc, 0x06, 0x6c02);
-                        MP_WritePhyUshort(sc, 0x06, 0x201d);
-                        MP_WritePhyUshort(sc, 0x06, 0xae44);
-                        MP_WritePhyUshort(sc, 0x06, 0xa566);
-                        MP_WritePhyUshort(sc, 0x06, 0x6602);
-                        MP_WritePhyUshort(sc, 0x06, 0xae38);
-                        MP_WritePhyUshort(sc, 0x06, 0xa5aa);
-                        MP_WritePhyUshort(sc, 0x06, 0xaa02);
-                        MP_WritePhyUshort(sc, 0x06, 0xae32);
-                        MP_WritePhyUshort(sc, 0x06, 0xeee0);
-                        MP_WritePhyUshort(sc, 0x06, 0xea04);
-                        MP_WritePhyUshort(sc, 0x06, 0xeee0);
-                        MP_WritePhyUshort(sc, 0x06, 0xeb06);
-                        MP_WritePhyUshort(sc, 0x06, 0xe2e0);
-                        MP_WritePhyUshort(sc, 0x06, 0x7ce3);
-                        MP_WritePhyUshort(sc, 0x06, 0xe07d);
-                        MP_WritePhyUshort(sc, 0x06, 0xe0e0);
-                        MP_WritePhyUshort(sc, 0x06, 0x38e1);
-                        MP_WritePhyUshort(sc, 0x06, 0xe039);
-                        MP_WritePhyUshort(sc, 0x06, 0xad2e);
-                        MP_WritePhyUshort(sc, 0x06, 0x21ad);
-                        MP_WritePhyUshort(sc, 0x06, 0x3f13);
-                        MP_WritePhyUshort(sc, 0x06, 0xe0e4);
-                        MP_WritePhyUshort(sc, 0x06, 0x14e1);
-                        MP_WritePhyUshort(sc, 0x06, 0xe415);
-                        MP_WritePhyUshort(sc, 0x06, 0x6880);
-                        MP_WritePhyUshort(sc, 0x06, 0xe4e4);
-                        MP_WritePhyUshort(sc, 0x06, 0x14e5);
-                        MP_WritePhyUshort(sc, 0x06, 0xe415);
-                        MP_WritePhyUshort(sc, 0x06, 0x0220);
-                        MP_WritePhyUshort(sc, 0x06, 0x1dae);
-                        MP_WritePhyUshort(sc, 0x06, 0x0bac);
-                        MP_WritePhyUshort(sc, 0x06, 0x3e02);
-                        MP_WritePhyUshort(sc, 0x06, 0xae06);
-                        MP_WritePhyUshort(sc, 0x06, 0x0281);
-                        MP_WritePhyUshort(sc, 0x06, 0x4602);
-                        MP_WritePhyUshort(sc, 0x06, 0x2057);
-                        MP_WritePhyUshort(sc, 0x06, 0xfefd);
-                        MP_WritePhyUshort(sc, 0x06, 0xfc04);
-                        MP_WritePhyUshort(sc, 0x06, 0xf8e0);
-                        MP_WritePhyUshort(sc, 0x06, 0x8b81);
-                        MP_WritePhyUshort(sc, 0x06, 0xad26);
-                        MP_WritePhyUshort(sc, 0x06, 0x0302);
-                        MP_WritePhyUshort(sc, 0x06, 0x20a7);
-                        MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                        MP_WritePhyUshort(sc, 0x06, 0x81ad);
-                        MP_WritePhyUshort(sc, 0x06, 0x2109);
-                        MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                        MP_WritePhyUshort(sc, 0x06, 0x2eac);
-                        MP_WritePhyUshort(sc, 0x06, 0x2003);
-                        MP_WritePhyUshort(sc, 0x06, 0x0281);
-                        MP_WritePhyUshort(sc, 0x06, 0x61fc);
-                        MP_WritePhyUshort(sc, 0x06, 0x04f8);
-                        MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                        MP_WritePhyUshort(sc, 0x06, 0x81ac);
-                        MP_WritePhyUshort(sc, 0x06, 0x2505);
-                        MP_WritePhyUshort(sc, 0x06, 0x0222);
-                        MP_WritePhyUshort(sc, 0x06, 0xaeae);
-                        MP_WritePhyUshort(sc, 0x06, 0x0302);
-                        MP_WritePhyUshort(sc, 0x06, 0x8172);
-                        MP_WritePhyUshort(sc, 0x06, 0xfc04);
-                        MP_WritePhyUshort(sc, 0x06, 0xf8f9);
-                        MP_WritePhyUshort(sc, 0x06, 0xfaef);
-                        MP_WritePhyUshort(sc, 0x06, 0x69fa);
-                        MP_WritePhyUshort(sc, 0x06, 0xe086);
-                        MP_WritePhyUshort(sc, 0x06, 0x20a0);
-                        MP_WritePhyUshort(sc, 0x06, 0x8016);
-                        MP_WritePhyUshort(sc, 0x06, 0xe086);
-                        MP_WritePhyUshort(sc, 0x06, 0x21e1);
-                        MP_WritePhyUshort(sc, 0x06, 0x8b33);
-                        MP_WritePhyUshort(sc, 0x06, 0x1b10);
-                        MP_WritePhyUshort(sc, 0x06, 0x9e06);
-                        MP_WritePhyUshort(sc, 0x06, 0x0223);
-                        MP_WritePhyUshort(sc, 0x06, 0x91af);
-                        MP_WritePhyUshort(sc, 0x06, 0x8252);
-                        MP_WritePhyUshort(sc, 0x06, 0xee86);
-                        MP_WritePhyUshort(sc, 0x06, 0x2081);
-                        MP_WritePhyUshort(sc, 0x06, 0xaee4);
-                        MP_WritePhyUshort(sc, 0x06, 0xa081);
-                        MP_WritePhyUshort(sc, 0x06, 0x1402);
-                        MP_WritePhyUshort(sc, 0x06, 0x2399);
-                        MP_WritePhyUshort(sc, 0x06, 0xbf25);
-                        MP_WritePhyUshort(sc, 0x06, 0xcc02);
-                        MP_WritePhyUshort(sc, 0x06, 0x2d21);
-                        MP_WritePhyUshort(sc, 0x06, 0xee86);
-                        MP_WritePhyUshort(sc, 0x06, 0x2100);
-                        MP_WritePhyUshort(sc, 0x06, 0xee86);
-                        MP_WritePhyUshort(sc, 0x06, 0x2082);
-                        MP_WritePhyUshort(sc, 0x06, 0xaf82);
-                        MP_WritePhyUshort(sc, 0x06, 0x52a0);
-                        MP_WritePhyUshort(sc, 0x06, 0x8232);
-                        MP_WritePhyUshort(sc, 0x06, 0xe086);
-                        MP_WritePhyUshort(sc, 0x06, 0x21e1);
-                        MP_WritePhyUshort(sc, 0x06, 0x8b32);
-                        MP_WritePhyUshort(sc, 0x06, 0x1b10);
-                        MP_WritePhyUshort(sc, 0x06, 0x9e06);
-                        MP_WritePhyUshort(sc, 0x06, 0x0223);
-                        MP_WritePhyUshort(sc, 0x06, 0x91af);
-                        MP_WritePhyUshort(sc, 0x06, 0x8252);
-                        MP_WritePhyUshort(sc, 0x06, 0xee86);
-                        MP_WritePhyUshort(sc, 0x06, 0x2100);
-                        MP_WritePhyUshort(sc, 0x06, 0xd000);
-                        MP_WritePhyUshort(sc, 0x06, 0x0282);
-                        MP_WritePhyUshort(sc, 0x06, 0x5910);
-                        MP_WritePhyUshort(sc, 0x06, 0xa004);
-                        MP_WritePhyUshort(sc, 0x06, 0xf9e0);
-                        MP_WritePhyUshort(sc, 0x06, 0x861f);
-                        MP_WritePhyUshort(sc, 0x06, 0xa000);
-                        MP_WritePhyUshort(sc, 0x06, 0x07ee);
-                        MP_WritePhyUshort(sc, 0x06, 0x8620);
-                        MP_WritePhyUshort(sc, 0x06, 0x83af);
-                        MP_WritePhyUshort(sc, 0x06, 0x8178);
-                        MP_WritePhyUshort(sc, 0x06, 0x0224);
-                        MP_WritePhyUshort(sc, 0x06, 0x0102);
-                        MP_WritePhyUshort(sc, 0x06, 0x2399);
-                        MP_WritePhyUshort(sc, 0x06, 0xae72);
-                        MP_WritePhyUshort(sc, 0x06, 0xa083);
-                        MP_WritePhyUshort(sc, 0x06, 0x4b1f);
-                        MP_WritePhyUshort(sc, 0x06, 0x55d0);
-                        MP_WritePhyUshort(sc, 0x06, 0x04bf);
-                        MP_WritePhyUshort(sc, 0x06, 0x8615);
-                        MP_WritePhyUshort(sc, 0x06, 0x1a90);
-                        MP_WritePhyUshort(sc, 0x06, 0x0c54);
-                        MP_WritePhyUshort(sc, 0x06, 0xd91e);
-                        MP_WritePhyUshort(sc, 0x06, 0x31b0);
-                        MP_WritePhyUshort(sc, 0x06, 0xf4e0);
-                        MP_WritePhyUshort(sc, 0x06, 0xe022);
-                        MP_WritePhyUshort(sc, 0x06, 0xe1e0);
-                        MP_WritePhyUshort(sc, 0x06, 0x23ad);
-                        MP_WritePhyUshort(sc, 0x06, 0x2e0c);
-                        MP_WritePhyUshort(sc, 0x06, 0xef02);
-                        MP_WritePhyUshort(sc, 0x06, 0xef12);
-                        MP_WritePhyUshort(sc, 0x06, 0x0e44);
-                        MP_WritePhyUshort(sc, 0x06, 0xef23);
-                        MP_WritePhyUshort(sc, 0x06, 0x0e54);
-                        MP_WritePhyUshort(sc, 0x06, 0xef21);
-                        MP_WritePhyUshort(sc, 0x06, 0xe6e4);
-                        MP_WritePhyUshort(sc, 0x06, 0x2ae7);
-                        MP_WritePhyUshort(sc, 0x06, 0xe42b);
-                        MP_WritePhyUshort(sc, 0x06, 0xe2e4);
-                        MP_WritePhyUshort(sc, 0x06, 0x28e3);
-                        MP_WritePhyUshort(sc, 0x06, 0xe429);
-                        MP_WritePhyUshort(sc, 0x06, 0x6d20);
-                        MP_WritePhyUshort(sc, 0x06, 0x00e6);
-                        MP_WritePhyUshort(sc, 0x06, 0xe428);
-                        MP_WritePhyUshort(sc, 0x06, 0xe7e4);
-                        MP_WritePhyUshort(sc, 0x06, 0x29bf);
-                        MP_WritePhyUshort(sc, 0x06, 0x25ca);
-                        MP_WritePhyUshort(sc, 0x06, 0x022d);
-                        MP_WritePhyUshort(sc, 0x06, 0x21ee);
-                        MP_WritePhyUshort(sc, 0x06, 0x8620);
-                        MP_WritePhyUshort(sc, 0x06, 0x84ee);
-                        MP_WritePhyUshort(sc, 0x06, 0x8621);
-                        MP_WritePhyUshort(sc, 0x06, 0x00af);
-                        MP_WritePhyUshort(sc, 0x06, 0x8178);
-                        MP_WritePhyUshort(sc, 0x06, 0xa084);
-                        MP_WritePhyUshort(sc, 0x06, 0x19e0);
-                        MP_WritePhyUshort(sc, 0x06, 0x8621);
-                        MP_WritePhyUshort(sc, 0x06, 0xe18b);
-                        MP_WritePhyUshort(sc, 0x06, 0x341b);
-                        MP_WritePhyUshort(sc, 0x06, 0x109e);
-                        MP_WritePhyUshort(sc, 0x06, 0x0602);
-                        MP_WritePhyUshort(sc, 0x06, 0x2391);
-                        MP_WritePhyUshort(sc, 0x06, 0xaf82);
-                        MP_WritePhyUshort(sc, 0x06, 0x5202);
-                        MP_WritePhyUshort(sc, 0x06, 0x241f);
-                        MP_WritePhyUshort(sc, 0x06, 0xee86);
-                        MP_WritePhyUshort(sc, 0x06, 0x2085);
-                        MP_WritePhyUshort(sc, 0x06, 0xae08);
-                        MP_WritePhyUshort(sc, 0x06, 0xa085);
-                        MP_WritePhyUshort(sc, 0x06, 0x02ae);
-                        MP_WritePhyUshort(sc, 0x06, 0x0302);
-                        MP_WritePhyUshort(sc, 0x06, 0x2442);
-                        MP_WritePhyUshort(sc, 0x06, 0xfeef);
-                        MP_WritePhyUshort(sc, 0x06, 0x96fe);
-                        MP_WritePhyUshort(sc, 0x06, 0xfdfc);
-                        MP_WritePhyUshort(sc, 0x06, 0x04f8);
-                        MP_WritePhyUshort(sc, 0x06, 0xf9fa);
-                        MP_WritePhyUshort(sc, 0x06, 0xef69);
-                        MP_WritePhyUshort(sc, 0x06, 0xfad1);
-                        MP_WritePhyUshort(sc, 0x06, 0x801f);
-                        MP_WritePhyUshort(sc, 0x06, 0x66e2);
-                        MP_WritePhyUshort(sc, 0x06, 0xe0ea);
-                        MP_WritePhyUshort(sc, 0x06, 0xe3e0);
-                        MP_WritePhyUshort(sc, 0x06, 0xeb5a);
-                        MP_WritePhyUshort(sc, 0x06, 0xf81e);
-                        MP_WritePhyUshort(sc, 0x06, 0x20e6);
-                        MP_WritePhyUshort(sc, 0x06, 0xe0ea);
-                        MP_WritePhyUshort(sc, 0x06, 0xe5e0);
-                        MP_WritePhyUshort(sc, 0x06, 0xebd3);
-                        MP_WritePhyUshort(sc, 0x06, 0x05b3);
-                        MP_WritePhyUshort(sc, 0x06, 0xfee2);
-                        MP_WritePhyUshort(sc, 0x06, 0xe07c);
-                        MP_WritePhyUshort(sc, 0x06, 0xe3e0);
-                        MP_WritePhyUshort(sc, 0x06, 0x7dad);
-                        MP_WritePhyUshort(sc, 0x06, 0x3703);
-                        MP_WritePhyUshort(sc, 0x06, 0x7dff);
-                        MP_WritePhyUshort(sc, 0x06, 0xff0d);
-                        MP_WritePhyUshort(sc, 0x06, 0x581c);
-                        MP_WritePhyUshort(sc, 0x06, 0x55f8);
-                        MP_WritePhyUshort(sc, 0x06, 0xef46);
-                        MP_WritePhyUshort(sc, 0x06, 0x0282);
-                        MP_WritePhyUshort(sc, 0x06, 0xc7ef);
-                        MP_WritePhyUshort(sc, 0x06, 0x65ef);
-                        MP_WritePhyUshort(sc, 0x06, 0x54fc);
-                        MP_WritePhyUshort(sc, 0x06, 0xac30);
-                        MP_WritePhyUshort(sc, 0x06, 0x2b11);
-                        MP_WritePhyUshort(sc, 0x06, 0xa188);
-                        MP_WritePhyUshort(sc, 0x06, 0xcabf);
-                        MP_WritePhyUshort(sc, 0x06, 0x860e);
-                        MP_WritePhyUshort(sc, 0x06, 0xef10);
-                        MP_WritePhyUshort(sc, 0x06, 0x0c11);
-                        MP_WritePhyUshort(sc, 0x06, 0x1a91);
-                        MP_WritePhyUshort(sc, 0x06, 0xda19);
-                        MP_WritePhyUshort(sc, 0x06, 0xdbf8);
-                        MP_WritePhyUshort(sc, 0x06, 0xef46);
-                        MP_WritePhyUshort(sc, 0x06, 0x021e);
-                        MP_WritePhyUshort(sc, 0x06, 0x17ef);
-                        MP_WritePhyUshort(sc, 0x06, 0x54fc);
-                        MP_WritePhyUshort(sc, 0x06, 0xad30);
-                        MP_WritePhyUshort(sc, 0x06, 0x0fef);
-                        MP_WritePhyUshort(sc, 0x06, 0x5689);
-                        MP_WritePhyUshort(sc, 0x06, 0xde19);
-                        MP_WritePhyUshort(sc, 0x06, 0xdfe2);
-                        MP_WritePhyUshort(sc, 0x06, 0x861f);
-                        MP_WritePhyUshort(sc, 0x06, 0xbf86);
-                        MP_WritePhyUshort(sc, 0x06, 0x161a);
-                        MP_WritePhyUshort(sc, 0x06, 0x90de);
-                        MP_WritePhyUshort(sc, 0x06, 0xfeef);
-                        MP_WritePhyUshort(sc, 0x06, 0x96fe);
-                        MP_WritePhyUshort(sc, 0x06, 0xfdfc);
-                        MP_WritePhyUshort(sc, 0x06, 0x04ac);
-                        MP_WritePhyUshort(sc, 0x06, 0x2707);
-                        MP_WritePhyUshort(sc, 0x06, 0xac37);
-                        MP_WritePhyUshort(sc, 0x06, 0x071a);
-                        MP_WritePhyUshort(sc, 0x06, 0x54ae);
-                        MP_WritePhyUshort(sc, 0x06, 0x11ac);
-                        MP_WritePhyUshort(sc, 0x06, 0x3707);
-                        MP_WritePhyUshort(sc, 0x06, 0xae00);
-                        MP_WritePhyUshort(sc, 0x06, 0x1a54);
-                        MP_WritePhyUshort(sc, 0x06, 0xac37);
-                        MP_WritePhyUshort(sc, 0x06, 0x07d0);
-                        MP_WritePhyUshort(sc, 0x06, 0x01d5);
-                        MP_WritePhyUshort(sc, 0x06, 0xffff);
-                        MP_WritePhyUshort(sc, 0x06, 0xae02);
-                        MP_WritePhyUshort(sc, 0x06, 0xd000);
-                        MP_WritePhyUshort(sc, 0x06, 0x04f8);
-                        MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                        MP_WritePhyUshort(sc, 0x06, 0x83ad);
-                        MP_WritePhyUshort(sc, 0x06, 0x2444);
-                        MP_WritePhyUshort(sc, 0x06, 0xe0e0);
-                        MP_WritePhyUshort(sc, 0x06, 0x22e1);
-                        MP_WritePhyUshort(sc, 0x06, 0xe023);
-                        MP_WritePhyUshort(sc, 0x06, 0xad22);
-                        MP_WritePhyUshort(sc, 0x06, 0x3be0);
-                        MP_WritePhyUshort(sc, 0x06, 0x8abe);
-                        MP_WritePhyUshort(sc, 0x06, 0xa000);
-                        MP_WritePhyUshort(sc, 0x06, 0x0502);
-                        MP_WritePhyUshort(sc, 0x06, 0x28de);
-                        MP_WritePhyUshort(sc, 0x06, 0xae42);
-                        MP_WritePhyUshort(sc, 0x06, 0xa001);
-                        MP_WritePhyUshort(sc, 0x06, 0x0502);
-                        MP_WritePhyUshort(sc, 0x06, 0x28f1);
-                        MP_WritePhyUshort(sc, 0x06, 0xae3a);
-                        MP_WritePhyUshort(sc, 0x06, 0xa002);
-                        MP_WritePhyUshort(sc, 0x06, 0x0502);
-                        MP_WritePhyUshort(sc, 0x06, 0x8344);
-                        MP_WritePhyUshort(sc, 0x06, 0xae32);
-                        MP_WritePhyUshort(sc, 0x06, 0xa003);
-                        MP_WritePhyUshort(sc, 0x06, 0x0502);
-                        MP_WritePhyUshort(sc, 0x06, 0x299a);
-                        MP_WritePhyUshort(sc, 0x06, 0xae2a);
-                        MP_WritePhyUshort(sc, 0x06, 0xa004);
-                        MP_WritePhyUshort(sc, 0x06, 0x0502);
-                        MP_WritePhyUshort(sc, 0x06, 0x29ae);
-                        MP_WritePhyUshort(sc, 0x06, 0xae22);
-                        MP_WritePhyUshort(sc, 0x06, 0xa005);
-                        MP_WritePhyUshort(sc, 0x06, 0x0502);
-                        MP_WritePhyUshort(sc, 0x06, 0x29d7);
-                        MP_WritePhyUshort(sc, 0x06, 0xae1a);
-                        MP_WritePhyUshort(sc, 0x06, 0xa006);
-                        MP_WritePhyUshort(sc, 0x06, 0x0502);
-                        MP_WritePhyUshort(sc, 0x06, 0x29fe);
-                        MP_WritePhyUshort(sc, 0x06, 0xae12);
-                        MP_WritePhyUshort(sc, 0x06, 0xee8a);
-                        MP_WritePhyUshort(sc, 0x06, 0xc000);
-                        MP_WritePhyUshort(sc, 0x06, 0xee8a);
-                        MP_WritePhyUshort(sc, 0x06, 0xc100);
-                        MP_WritePhyUshort(sc, 0x06, 0xee8a);
-                        MP_WritePhyUshort(sc, 0x06, 0xc600);
-                        MP_WritePhyUshort(sc, 0x06, 0xee8a);
-                        MP_WritePhyUshort(sc, 0x06, 0xbe00);
-                        MP_WritePhyUshort(sc, 0x06, 0xae00);
-                        MP_WritePhyUshort(sc, 0x06, 0xfc04);
-                        MP_WritePhyUshort(sc, 0x06, 0xf802);
-                        MP_WritePhyUshort(sc, 0x06, 0x2a67);
-                        MP_WritePhyUshort(sc, 0x06, 0xe0e0);
-                        MP_WritePhyUshort(sc, 0x06, 0x22e1);
-                        MP_WritePhyUshort(sc, 0x06, 0xe023);
-                        MP_WritePhyUshort(sc, 0x06, 0x0d06);
-                        MP_WritePhyUshort(sc, 0x06, 0x5803);
-                        MP_WritePhyUshort(sc, 0x06, 0xa002);
-                        MP_WritePhyUshort(sc, 0x06, 0x02ae);
-                        MP_WritePhyUshort(sc, 0x06, 0x2da0);
-                        MP_WritePhyUshort(sc, 0x06, 0x0102);
-                        MP_WritePhyUshort(sc, 0x06, 0xae2d);
-                        MP_WritePhyUshort(sc, 0x06, 0xa000);
-                        MP_WritePhyUshort(sc, 0x06, 0x4de0);
-                        MP_WritePhyUshort(sc, 0x06, 0xe200);
-                        MP_WritePhyUshort(sc, 0x06, 0xe1e2);
-                        MP_WritePhyUshort(sc, 0x06, 0x01ad);
-                        MP_WritePhyUshort(sc, 0x06, 0x2444);
-                        MP_WritePhyUshort(sc, 0x06, 0xe08a);
-                        MP_WritePhyUshort(sc, 0x06, 0xc2e4);
-                        MP_WritePhyUshort(sc, 0x06, 0x8ac4);
-                        MP_WritePhyUshort(sc, 0x06, 0xe08a);
-                        MP_WritePhyUshort(sc, 0x06, 0xc3e4);
-                        MP_WritePhyUshort(sc, 0x06, 0x8ac5);
-                        MP_WritePhyUshort(sc, 0x06, 0xee8a);
-                        MP_WritePhyUshort(sc, 0x06, 0xbe03);
-                        MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                        MP_WritePhyUshort(sc, 0x06, 0x83ad);
-                        MP_WritePhyUshort(sc, 0x06, 0x253a);
-                        MP_WritePhyUshort(sc, 0x06, 0xee8a);
-                        MP_WritePhyUshort(sc, 0x06, 0xbe05);
-                        MP_WritePhyUshort(sc, 0x06, 0xae34);
-                        MP_WritePhyUshort(sc, 0x06, 0xe08a);
-                        MP_WritePhyUshort(sc, 0x06, 0xceae);
-                        MP_WritePhyUshort(sc, 0x06, 0x03e0);
-                        MP_WritePhyUshort(sc, 0x06, 0x8acf);
-                        MP_WritePhyUshort(sc, 0x06, 0xe18a);
-                        MP_WritePhyUshort(sc, 0x06, 0xc249);
-                        MP_WritePhyUshort(sc, 0x06, 0x05e5);
-                        MP_WritePhyUshort(sc, 0x06, 0x8ac4);
-                        MP_WritePhyUshort(sc, 0x06, 0xe18a);
-                        MP_WritePhyUshort(sc, 0x06, 0xc349);
-                        MP_WritePhyUshort(sc, 0x06, 0x05e5);
-                        MP_WritePhyUshort(sc, 0x06, 0x8ac5);
-                        MP_WritePhyUshort(sc, 0x06, 0xee8a);
-                        MP_WritePhyUshort(sc, 0x06, 0xbe05);
-                        MP_WritePhyUshort(sc, 0x06, 0x022a);
-                        MP_WritePhyUshort(sc, 0x06, 0xb6ac);
-                        MP_WritePhyUshort(sc, 0x06, 0x2012);
-                        MP_WritePhyUshort(sc, 0x06, 0x0283);
-                        MP_WritePhyUshort(sc, 0x06, 0xbaac);
-                        MP_WritePhyUshort(sc, 0x06, 0x200c);
-                        MP_WritePhyUshort(sc, 0x06, 0xee8a);
-                        MP_WritePhyUshort(sc, 0x06, 0xc100);
-                        MP_WritePhyUshort(sc, 0x06, 0xee8a);
-                        MP_WritePhyUshort(sc, 0x06, 0xc600);
-                        MP_WritePhyUshort(sc, 0x06, 0xee8a);
-                        MP_WritePhyUshort(sc, 0x06, 0xbe02);
-                        MP_WritePhyUshort(sc, 0x06, 0xfc04);
-                        MP_WritePhyUshort(sc, 0x06, 0xd000);
-                        MP_WritePhyUshort(sc, 0x06, 0x0283);
-                        MP_WritePhyUshort(sc, 0x06, 0xcc59);
-                        MP_WritePhyUshort(sc, 0x06, 0x0f39);
-                        MP_WritePhyUshort(sc, 0x06, 0x02aa);
-                        MP_WritePhyUshort(sc, 0x06, 0x04d0);
-                        MP_WritePhyUshort(sc, 0x06, 0x01ae);
-                        MP_WritePhyUshort(sc, 0x06, 0x02d0);
-                        MP_WritePhyUshort(sc, 0x06, 0x0004);
-                        MP_WritePhyUshort(sc, 0x06, 0xf9fa);
-                        MP_WritePhyUshort(sc, 0x06, 0xe2e2);
-                        MP_WritePhyUshort(sc, 0x06, 0xd2e3);
-                        MP_WritePhyUshort(sc, 0x06, 0xe2d3);
-                        MP_WritePhyUshort(sc, 0x06, 0xf95a);
-                        MP_WritePhyUshort(sc, 0x06, 0xf7e6);
-                        MP_WritePhyUshort(sc, 0x06, 0xe2d2);
-                        MP_WritePhyUshort(sc, 0x06, 0xe7e2);
-                        MP_WritePhyUshort(sc, 0x06, 0xd3e2);
-                        MP_WritePhyUshort(sc, 0x06, 0xe02c);
-                        MP_WritePhyUshort(sc, 0x06, 0xe3e0);
-                        MP_WritePhyUshort(sc, 0x06, 0x2df9);
-                        MP_WritePhyUshort(sc, 0x06, 0x5be0);
-                        MP_WritePhyUshort(sc, 0x06, 0x1e30);
-                        MP_WritePhyUshort(sc, 0x06, 0xe6e0);
-                        MP_WritePhyUshort(sc, 0x06, 0x2ce7);
-                        MP_WritePhyUshort(sc, 0x06, 0xe02d);
-                        MP_WritePhyUshort(sc, 0x06, 0xe2e2);
-                        MP_WritePhyUshort(sc, 0x06, 0xcce3);
-                        MP_WritePhyUshort(sc, 0x06, 0xe2cd);
-                        MP_WritePhyUshort(sc, 0x06, 0xf95a);
-                        MP_WritePhyUshort(sc, 0x06, 0x0f6a);
-                        MP_WritePhyUshort(sc, 0x06, 0x50e6);
-                        MP_WritePhyUshort(sc, 0x06, 0xe2cc);
-                        MP_WritePhyUshort(sc, 0x06, 0xe7e2);
-                        MP_WritePhyUshort(sc, 0x06, 0xcde0);
-                        MP_WritePhyUshort(sc, 0x06, 0xe03c);
-                        MP_WritePhyUshort(sc, 0x06, 0xe1e0);
-                        MP_WritePhyUshort(sc, 0x06, 0x3def);
-                        MP_WritePhyUshort(sc, 0x06, 0x64fd);
-                        MP_WritePhyUshort(sc, 0x06, 0xe0e2);
-                        MP_WritePhyUshort(sc, 0x06, 0xcce1);
-                        MP_WritePhyUshort(sc, 0x06, 0xe2cd);
-                        MP_WritePhyUshort(sc, 0x06, 0x580f);
-                        MP_WritePhyUshort(sc, 0x06, 0x5af0);
-                        MP_WritePhyUshort(sc, 0x06, 0x1e02);
-                        MP_WritePhyUshort(sc, 0x06, 0xe4e2);
-                        MP_WritePhyUshort(sc, 0x06, 0xcce5);
-                        MP_WritePhyUshort(sc, 0x06, 0xe2cd);
-                        MP_WritePhyUshort(sc, 0x06, 0xfde0);
-                        MP_WritePhyUshort(sc, 0x06, 0xe02c);
-                        MP_WritePhyUshort(sc, 0x06, 0xe1e0);
-                        MP_WritePhyUshort(sc, 0x06, 0x2d59);
-                        MP_WritePhyUshort(sc, 0x06, 0xe05b);
-                        MP_WritePhyUshort(sc, 0x06, 0x1f1e);
-                        MP_WritePhyUshort(sc, 0x06, 0x13e4);
-                        MP_WritePhyUshort(sc, 0x06, 0xe02c);
-                        MP_WritePhyUshort(sc, 0x06, 0xe5e0);
-                        MP_WritePhyUshort(sc, 0x06, 0x2dfd);
-                        MP_WritePhyUshort(sc, 0x06, 0xe0e2);
-                        MP_WritePhyUshort(sc, 0x06, 0xd2e1);
-                        MP_WritePhyUshort(sc, 0x06, 0xe2d3);
-                        MP_WritePhyUshort(sc, 0x06, 0x58f7);
-                        MP_WritePhyUshort(sc, 0x06, 0x5a08);
-                        MP_WritePhyUshort(sc, 0x06, 0x1e02);
-                        MP_WritePhyUshort(sc, 0x06, 0xe4e2);
-                        MP_WritePhyUshort(sc, 0x06, 0xd2e5);
-                        MP_WritePhyUshort(sc, 0x06, 0xe2d3);
-                        MP_WritePhyUshort(sc, 0x06, 0xef46);
-                        MP_WritePhyUshort(sc, 0x06, 0xfefd);
-                        MP_WritePhyUshort(sc, 0x06, 0x04f8);
-                        MP_WritePhyUshort(sc, 0x06, 0xf9fa);
-                        MP_WritePhyUshort(sc, 0x06, 0xef69);
-                        MP_WritePhyUshort(sc, 0x06, 0xe0e0);
-                        MP_WritePhyUshort(sc, 0x06, 0x22e1);
-                        MP_WritePhyUshort(sc, 0x06, 0xe023);
-                        MP_WritePhyUshort(sc, 0x06, 0x58c4);
-                        MP_WritePhyUshort(sc, 0x06, 0xe18b);
-                        MP_WritePhyUshort(sc, 0x06, 0x6e1f);
-                        MP_WritePhyUshort(sc, 0x06, 0x109e);
-                        MP_WritePhyUshort(sc, 0x06, 0x58e4);
-                        MP_WritePhyUshort(sc, 0x06, 0x8b6e);
-                        MP_WritePhyUshort(sc, 0x06, 0xad22);
-                        MP_WritePhyUshort(sc, 0x06, 0x22ac);
-                        MP_WritePhyUshort(sc, 0x06, 0x2755);
-                        MP_WritePhyUshort(sc, 0x06, 0xac26);
-                        MP_WritePhyUshort(sc, 0x06, 0x02ae);
-                        MP_WritePhyUshort(sc, 0x06, 0x1ad1);
-                        MP_WritePhyUshort(sc, 0x06, 0x06bf);
-                        MP_WritePhyUshort(sc, 0x06, 0x3bba);
-                        MP_WritePhyUshort(sc, 0x06, 0x022d);
-                        MP_WritePhyUshort(sc, 0x06, 0xc1d1);
-                        MP_WritePhyUshort(sc, 0x06, 0x07bf);
-                        MP_WritePhyUshort(sc, 0x06, 0x3bbd);
-                        MP_WritePhyUshort(sc, 0x06, 0x022d);
-                        MP_WritePhyUshort(sc, 0x06, 0xc1d1);
-                        MP_WritePhyUshort(sc, 0x06, 0x07bf);
-                        MP_WritePhyUshort(sc, 0x06, 0x3bc0);
-                        MP_WritePhyUshort(sc, 0x06, 0x022d);
-                        MP_WritePhyUshort(sc, 0x06, 0xc1ae);
-                        MP_WritePhyUshort(sc, 0x06, 0x30d1);
-                        MP_WritePhyUshort(sc, 0x06, 0x03bf);
-                        MP_WritePhyUshort(sc, 0x06, 0x3bc3);
-                        MP_WritePhyUshort(sc, 0x06, 0x022d);
-                        MP_WritePhyUshort(sc, 0x06, 0xc1d1);
-                        MP_WritePhyUshort(sc, 0x06, 0x00bf);
-                        MP_WritePhyUshort(sc, 0x06, 0x3bc6);
-                        MP_WritePhyUshort(sc, 0x06, 0x022d);
-                        MP_WritePhyUshort(sc, 0x06, 0xc1d1);
-                        MP_WritePhyUshort(sc, 0x06, 0x00bf);
-                        MP_WritePhyUshort(sc, 0x06, 0x84e9);
-                        MP_WritePhyUshort(sc, 0x06, 0x022d);
-                        MP_WritePhyUshort(sc, 0x06, 0xc1d1);
-                        MP_WritePhyUshort(sc, 0x06, 0x0fbf);
-                        MP_WritePhyUshort(sc, 0x06, 0x3bba);
-                        MP_WritePhyUshort(sc, 0x06, 0x022d);
-                        MP_WritePhyUshort(sc, 0x06, 0xc1d1);
-                        MP_WritePhyUshort(sc, 0x06, 0x01bf);
-                        MP_WritePhyUshort(sc, 0x06, 0x3bbd);
-                        MP_WritePhyUshort(sc, 0x06, 0x022d);
-                        MP_WritePhyUshort(sc, 0x06, 0xc1d1);
-                        MP_WritePhyUshort(sc, 0x06, 0x01bf);
-                        MP_WritePhyUshort(sc, 0x06, 0x3bc0);
-                        MP_WritePhyUshort(sc, 0x06, 0x022d);
-                        MP_WritePhyUshort(sc, 0x06, 0xc1ef);
-                        MP_WritePhyUshort(sc, 0x06, 0x96fe);
-                        MP_WritePhyUshort(sc, 0x06, 0xfdfc);
-                        MP_WritePhyUshort(sc, 0x06, 0x04d1);
-                        MP_WritePhyUshort(sc, 0x06, 0x00bf);
-                        MP_WritePhyUshort(sc, 0x06, 0x3bc3);
-                        MP_WritePhyUshort(sc, 0x06, 0x022d);
-                        MP_WritePhyUshort(sc, 0x06, 0xc1d0);
-                        MP_WritePhyUshort(sc, 0x06, 0x1102);
-                        MP_WritePhyUshort(sc, 0x06, 0x2bfb);
-                        MP_WritePhyUshort(sc, 0x06, 0x5903);
-                        MP_WritePhyUshort(sc, 0x06, 0xef01);
-                        MP_WritePhyUshort(sc, 0x06, 0xd100);
-                        MP_WritePhyUshort(sc, 0x06, 0xa000);
-                        MP_WritePhyUshort(sc, 0x06, 0x02d1);
-                        MP_WritePhyUshort(sc, 0x06, 0x01bf);
-                        MP_WritePhyUshort(sc, 0x06, 0x3bc6);
-                        MP_WritePhyUshort(sc, 0x06, 0x022d);
-                        MP_WritePhyUshort(sc, 0x06, 0xc1d1);
-                        MP_WritePhyUshort(sc, 0x06, 0x11ad);
-                        MP_WritePhyUshort(sc, 0x06, 0x2002);
-                        MP_WritePhyUshort(sc, 0x06, 0x0c11);
-                        MP_WritePhyUshort(sc, 0x06, 0xad21);
-                        MP_WritePhyUshort(sc, 0x06, 0x020c);
-                        MP_WritePhyUshort(sc, 0x06, 0x12bf);
-                        MP_WritePhyUshort(sc, 0x06, 0x84e9);
-                        MP_WritePhyUshort(sc, 0x06, 0x022d);
-                        MP_WritePhyUshort(sc, 0x06, 0xc1ae);
-                        MP_WritePhyUshort(sc, 0x06, 0xc870);
-                        MP_WritePhyUshort(sc, 0x06, 0xe426);
-                        MP_WritePhyUshort(sc, 0x06, 0x0284);
-                        MP_WritePhyUshort(sc, 0x06, 0xf005);
-                        MP_WritePhyUshort(sc, 0x06, 0xf8fa);
-                        MP_WritePhyUshort(sc, 0x06, 0xef69);
-                        MP_WritePhyUshort(sc, 0x06, 0xe0e2);
-                        MP_WritePhyUshort(sc, 0x06, 0xfee1);
-                        MP_WritePhyUshort(sc, 0x06, 0xe2ff);
-                        MP_WritePhyUshort(sc, 0x06, 0xad2d);
-                        MP_WritePhyUshort(sc, 0x06, 0x1ae0);
-                        MP_WritePhyUshort(sc, 0x06, 0xe14e);
-                        MP_WritePhyUshort(sc, 0x06, 0xe1e1);
-                        MP_WritePhyUshort(sc, 0x06, 0x4fac);
-                        MP_WritePhyUshort(sc, 0x06, 0x2d22);
-                        MP_WritePhyUshort(sc, 0x06, 0xf603);
-                        MP_WritePhyUshort(sc, 0x06, 0x0203);
-                        MP_WritePhyUshort(sc, 0x06, 0x3bf7);
-                        MP_WritePhyUshort(sc, 0x06, 0x03f7);
-                        MP_WritePhyUshort(sc, 0x06, 0x06bf);
-                        MP_WritePhyUshort(sc, 0x06, 0x85c4);
-                        MP_WritePhyUshort(sc, 0x06, 0x022d);
-                        MP_WritePhyUshort(sc, 0x06, 0x21ae);
-                        MP_WritePhyUshort(sc, 0x06, 0x11e0);
-                        MP_WritePhyUshort(sc, 0x06, 0xe14e);
-                        MP_WritePhyUshort(sc, 0x06, 0xe1e1);
-                        MP_WritePhyUshort(sc, 0x06, 0x4fad);
-                        MP_WritePhyUshort(sc, 0x06, 0x2d08);
-                        MP_WritePhyUshort(sc, 0x06, 0xbf85);
-                        MP_WritePhyUshort(sc, 0x06, 0xcf02);
-                        MP_WritePhyUshort(sc, 0x06, 0x2d21);
-                        MP_WritePhyUshort(sc, 0x06, 0xf606);
-                        MP_WritePhyUshort(sc, 0x06, 0xef96);
-                        MP_WritePhyUshort(sc, 0x06, 0xfefc);
-                        MP_WritePhyUshort(sc, 0x06, 0x04f8);
-                        MP_WritePhyUshort(sc, 0x06, 0xfaef);
-                        MP_WritePhyUshort(sc, 0x06, 0x6902);
-                        MP_WritePhyUshort(sc, 0x06, 0x8561);
-                        MP_WritePhyUshort(sc, 0x06, 0xe0e0);
-                        MP_WritePhyUshort(sc, 0x06, 0x00e1);
-                        MP_WritePhyUshort(sc, 0x06, 0xe001);
-                        MP_WritePhyUshort(sc, 0x06, 0xad27);
-                        MP_WritePhyUshort(sc, 0x06, 0x1fd1);
-                        MP_WritePhyUshort(sc, 0x06, 0x01bf);
-                        MP_WritePhyUshort(sc, 0x06, 0x85be);
-                        MP_WritePhyUshort(sc, 0x06, 0x022d);
-                        MP_WritePhyUshort(sc, 0x06, 0xc1e0);
-                        MP_WritePhyUshort(sc, 0x06, 0xe020);
-                        MP_WritePhyUshort(sc, 0x06, 0xe1e0);
-                        MP_WritePhyUshort(sc, 0x06, 0x21ad);
-                        MP_WritePhyUshort(sc, 0x06, 0x200e);
-                        MP_WritePhyUshort(sc, 0x06, 0xd100);
-                        MP_WritePhyUshort(sc, 0x06, 0xbf85);
-                        MP_WritePhyUshort(sc, 0x06, 0xbe02);
-                        MP_WritePhyUshort(sc, 0x06, 0x2dc1);
-                        MP_WritePhyUshort(sc, 0x06, 0xbf3b);
-                        MP_WritePhyUshort(sc, 0x06, 0x9602);
-                        MP_WritePhyUshort(sc, 0x06, 0x2d21);
-                        MP_WritePhyUshort(sc, 0x06, 0xef96);
-                        MP_WritePhyUshort(sc, 0x06, 0xfefc);
-                        MP_WritePhyUshort(sc, 0x06, 0x04f8);
-                        MP_WritePhyUshort(sc, 0x06, 0xf9fa);
-                        MP_WritePhyUshort(sc, 0x06, 0xef69);
-                        MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                        MP_WritePhyUshort(sc, 0x06, 0x87ad);
-                        MP_WritePhyUshort(sc, 0x06, 0x204c);
-                        MP_WritePhyUshort(sc, 0x06, 0xd200);
-                        MP_WritePhyUshort(sc, 0x06, 0xe0e2);
-                        MP_WritePhyUshort(sc, 0x06, 0x0058);
-                        MP_WritePhyUshort(sc, 0x06, 0x010c);
-                        MP_WritePhyUshort(sc, 0x06, 0x021e);
-                        MP_WritePhyUshort(sc, 0x06, 0x20e0);
-                        MP_WritePhyUshort(sc, 0x06, 0xe000);
-                        MP_WritePhyUshort(sc, 0x06, 0x5810);
-                        MP_WritePhyUshort(sc, 0x06, 0x1e20);
-                        MP_WritePhyUshort(sc, 0x06, 0xe0e0);
-                        MP_WritePhyUshort(sc, 0x06, 0x3658);
-                        MP_WritePhyUshort(sc, 0x06, 0x031e);
-                        MP_WritePhyUshort(sc, 0x06, 0x20e0);
-                        MP_WritePhyUshort(sc, 0x06, 0xe022);
-                        MP_WritePhyUshort(sc, 0x06, 0xe1e0);
-                        MP_WritePhyUshort(sc, 0x06, 0x2358);
-                        MP_WritePhyUshort(sc, 0x06, 0xe01e);
-                        MP_WritePhyUshort(sc, 0x06, 0x20e0);
-                        MP_WritePhyUshort(sc, 0x06, 0x8b64);
-                        MP_WritePhyUshort(sc, 0x06, 0x1f02);
-                        MP_WritePhyUshort(sc, 0x06, 0x9e22);
-                        MP_WritePhyUshort(sc, 0x06, 0xe68b);
-                        MP_WritePhyUshort(sc, 0x06, 0x64ad);
-                        MP_WritePhyUshort(sc, 0x06, 0x3214);
-                        MP_WritePhyUshort(sc, 0x06, 0xad34);
-                        MP_WritePhyUshort(sc, 0x06, 0x11ef);
-                        MP_WritePhyUshort(sc, 0x06, 0x0258);
-                        MP_WritePhyUshort(sc, 0x06, 0x039e);
-                        MP_WritePhyUshort(sc, 0x06, 0x07ad);
-                        MP_WritePhyUshort(sc, 0x06, 0x3508);
-                        MP_WritePhyUshort(sc, 0x06, 0x5ac0);
-                        MP_WritePhyUshort(sc, 0x06, 0x9f04);
-                        MP_WritePhyUshort(sc, 0x06, 0xd101);
-                        MP_WritePhyUshort(sc, 0x06, 0xae02);
-                        MP_WritePhyUshort(sc, 0x06, 0xd100);
-                        MP_WritePhyUshort(sc, 0x06, 0xbf85);
-                        MP_WritePhyUshort(sc, 0x06, 0xc102);
-                        MP_WritePhyUshort(sc, 0x06, 0x2dc1);
-                        MP_WritePhyUshort(sc, 0x06, 0xef96);
-                        MP_WritePhyUshort(sc, 0x06, 0xfefd);
-                        MP_WritePhyUshort(sc, 0x06, 0xfc04);
-                        MP_WritePhyUshort(sc, 0x06, 0x00e2);
-                        MP_WritePhyUshort(sc, 0x06, 0x34cc);
-                        MP_WritePhyUshort(sc, 0x06, 0xe200);
-                        MP_WritePhyUshort(sc, 0x06, 0xa725);
-                        MP_WritePhyUshort(sc, 0x06, 0xe50a);
-                        MP_WritePhyUshort(sc, 0x06, 0x1de5);
-                        MP_WritePhyUshort(sc, 0x06, 0x0a2c);
-                        MP_WritePhyUshort(sc, 0x06, 0xe50a);
-                        MP_WritePhyUshort(sc, 0x06, 0x6de5);
-                        MP_WritePhyUshort(sc, 0x06, 0x0a1d);
-                        MP_WritePhyUshort(sc, 0x06, 0xe50a);
-                        MP_WritePhyUshort(sc, 0x06, 0x1ce5);
-                        MP_WritePhyUshort(sc, 0x06, 0x0a2d);
-                        MP_WritePhyUshort(sc, 0x06, 0xa755);
-                        MP_WritePhyUshort(sc, 0x05, 0x8b64);
-                        MP_WritePhyUshort(sc, 0x06, 0x0000);
-                        MP_WritePhyUshort(sc, 0x05, 0x8b94);
-                        MP_WritePhyUshort(sc, 0x06, 0x84ec);
-                        Data = MP_ReadPhyUshort(sc, 0x01);
-                        Data |= 0x0001;
-                        MP_WritePhyUshort(sc, 0x01, Data);
-                        MP_WritePhyUshort(sc, 0x00, 0x0005);
-                        MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                        MP_WritePhyUshort(sc, 0x1f, 0x0005);
-                        for (i = 0; i < 200; i++) {
-                                DELAY(100);
-                                Data = MP_ReadPhyUshort(sc, 0x00);
-                                if (Data & 0x0080)
-                                        break;
-                        }
-                        MP_WritePhyUshort(sc, 0x1f, 0x0007);
-                        MP_WritePhyUshort(sc, 0x1e, 0x0023);
-                        MP_WritePhyUshort(sc, 0x17, 0x0116);
-                        MP_WritePhyUshort(sc, 0x1f, 0x0007);
-                        MP_WritePhyUshort(sc, 0x1e, 0x0028);
-                        MP_WritePhyUshort(sc, 0x15, 0x0010);
-                        MP_WritePhyUshort(sc, 0x1f, 0x0007);
-                        //MP_WritePhyUshort(sc, 0x1e, 0x0020);
-                        //MP_WritePhyUshort(sc, 0x15, 0x0100);
-                        MP_WritePhyUshort(sc, 0x1f, 0x0007);
-                        MP_WritePhyUshort(sc, 0x1e, 0x0041);
-                        MP_WritePhyUshort(sc, 0x15, 0x0802);
-                        MP_WritePhyUshort(sc, 0x16, 0x2185);
-                        MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                } else if (sc->re_type == MACFG_37) {
-                        MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                        MP_WritePhyUshort(sc, 0x00, 0x1800);
-                        MP_WritePhyUshort(sc, 0x1f, 0x0007);
-                        MP_WritePhyUshort(sc, 0x1e, 0x0023);
-                        MP_WritePhyUshort(sc, 0x17, 0x0117);
-                        MP_WritePhyUshort(sc, 0x1f, 0x0007);
-                        MP_WritePhyUshort(sc, 0x1E, 0x002C);
-                        MP_WritePhyUshort(sc, 0x1B, 0x5000);
-                        MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                        MP_WritePhyUshort(sc, 0x16, 0x4104);
-                        for (i=0; i<200; i++) {
-                                DELAY(100);
-                                Data = MP_ReadPhyUshort(sc, 0x1E);
-                                Data &= 0x03FF;
-                                if (Data== 0x000C)
-                                        break;
-                        }
-                        MP_WritePhyUshort(sc, 0x1f, 0x0005);
-                        for (i=0; i<200; i++) {
-                                DELAY(100);
-                                Data = MP_ReadPhyUshort(sc, 0x07);
-                                if ((Data&0x0020)==0)
-                                        break;
-                        }
-                        Data = MP_ReadPhyUshort(sc, 0x07);
-                        if (Data & 0x0020) {
-                                MP_WritePhyUshort(sc, 0x1f, 0x0007);
-                                MP_WritePhyUshort(sc, 0x1e, 0x00a1);
-                                MP_WritePhyUshort(sc, 0x17, 0x1000);
-                                MP_WritePhyUshort(sc, 0x17, 0x0000);
-                                MP_WritePhyUshort(sc, 0x17, 0x2000);
-                                MP_WritePhyUshort(sc, 0x1e, 0x002f);
-                                MP_WritePhyUshort(sc, 0x18, 0x9bfb);
-                                MP_WritePhyUshort(sc, 0x1f, 0x0005);
-                                MP_WritePhyUshort(sc, 0x07, 0x0000);
-                                MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                        }
-                        MP_WritePhyUshort(sc, 0x1f, 0x0005);
-                        MP_WritePhyUshort(sc, 0x05, 0xfff6);
-                        MP_WritePhyUshort(sc, 0x06, 0x0080);
-                        Data = MP_ReadPhyUshort(sc, 0x00);
-                        Data &= ~0x0080;
-                        MP_WritePhyUshort(sc, 0x00, Data);
-                        MP_WritePhyUshort(sc, 0x1f, 0x0002);
-                        Data = MP_ReadPhyUshort(sc, 0x08);
-                        Data &= ~0x0080;
-                        MP_WritePhyUshort(sc, 0x08, Data);
-                        MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                        MP_WritePhyUshort(sc, 0x1f, 0x0007);
-                        MP_WritePhyUshort(sc, 0x1e, 0x0023);
-                        MP_WritePhyUshort(sc, 0x16, 0x0306);
-                        MP_WritePhyUshort(sc, 0x16, 0x0307);
-                        MP_WritePhyUshort(sc, 0x15, 0x000e);
-                        MP_WritePhyUshort(sc, 0x19, 0x000a);
-                        MP_WritePhyUshort(sc, 0x15, 0x0010);
-                        MP_WritePhyUshort(sc, 0x19, 0x0008);
-                        MP_WritePhyUshort(sc, 0x15, 0x0018);
-                        MP_WritePhyUshort(sc, 0x19, 0x4801);
-                        MP_WritePhyUshort(sc, 0x15, 0x0019);
-                        MP_WritePhyUshort(sc, 0x19, 0x6801);
-                        MP_WritePhyUshort(sc, 0x15, 0x001a);
-                        MP_WritePhyUshort(sc, 0x19, 0x66a1);
-                        MP_WritePhyUshort(sc, 0x15, 0x001f);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x15, 0x0020);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x15, 0x0021);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x15, 0x0022);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x15, 0x0023);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x15, 0x0024);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x15, 0x0025);
-                        MP_WritePhyUshort(sc, 0x19, 0x64a1);
-                        MP_WritePhyUshort(sc, 0x15, 0x0026);
-                        MP_WritePhyUshort(sc, 0x19, 0x40ea);
-                        MP_WritePhyUshort(sc, 0x15, 0x0027);
-                        MP_WritePhyUshort(sc, 0x19, 0x4503);
-                        MP_WritePhyUshort(sc, 0x15, 0x0028);
-                        MP_WritePhyUshort(sc, 0x19, 0x9f00);
-                        MP_WritePhyUshort(sc, 0x15, 0x0029);
-                        MP_WritePhyUshort(sc, 0x19, 0xa631);
-                        MP_WritePhyUshort(sc, 0x15, 0x002a);
-                        MP_WritePhyUshort(sc, 0x19, 0x9717);
-                        MP_WritePhyUshort(sc, 0x15, 0x002b);
-                        MP_WritePhyUshort(sc, 0x19, 0x302c);
-                        MP_WritePhyUshort(sc, 0x15, 0x002c);
-                        MP_WritePhyUshort(sc, 0x19, 0x4802);
-                        MP_WritePhyUshort(sc, 0x15, 0x002d);
-                        MP_WritePhyUshort(sc, 0x19, 0x58da);
-                        MP_WritePhyUshort(sc, 0x15, 0x002e);
-                        MP_WritePhyUshort(sc, 0x19, 0x400d);
-                        MP_WritePhyUshort(sc, 0x15, 0x002f);
-                        MP_WritePhyUshort(sc, 0x19, 0x4488);
-                        MP_WritePhyUshort(sc, 0x15, 0x0030);
-                        MP_WritePhyUshort(sc, 0x19, 0x9e00);
-                        MP_WritePhyUshort(sc, 0x15, 0x0031);
-                        MP_WritePhyUshort(sc, 0x19, 0x63c8);
-                        MP_WritePhyUshort(sc, 0x15, 0x0032);
-                        MP_WritePhyUshort(sc, 0x19, 0x6481);
-                        MP_WritePhyUshort(sc, 0x15, 0x0033);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x15, 0x0034);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x15, 0x0035);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x15, 0x0036);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x15, 0x0037);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x15, 0x0038);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x15, 0x0039);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x15, 0x003a);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x15, 0x003b);
-                        MP_WritePhyUshort(sc, 0x19, 0x63e8);
-                        MP_WritePhyUshort(sc, 0x15, 0x003c);
-                        MP_WritePhyUshort(sc, 0x19, 0x7d00);
-                        MP_WritePhyUshort(sc, 0x15, 0x003d);
-                        MP_WritePhyUshort(sc, 0x19, 0x59d4);
-                        MP_WritePhyUshort(sc, 0x15, 0x003e);
-                        MP_WritePhyUshort(sc, 0x19, 0x63f8);
-                        MP_WritePhyUshort(sc, 0x15, 0x0040);
-                        MP_WritePhyUshort(sc, 0x19, 0x64a1);
-                        MP_WritePhyUshort(sc, 0x15, 0x0041);
-                        MP_WritePhyUshort(sc, 0x19, 0x30de);
-                        MP_WritePhyUshort(sc, 0x15, 0x0044);
-                        MP_WritePhyUshort(sc, 0x19, 0x480f);
-                        MP_WritePhyUshort(sc, 0x15, 0x0045);
-                        MP_WritePhyUshort(sc, 0x19, 0x6800);
-                        MP_WritePhyUshort(sc, 0x15, 0x0046);
-                        MP_WritePhyUshort(sc, 0x19, 0x6680);
-                        MP_WritePhyUshort(sc, 0x15, 0x0047);
-                        MP_WritePhyUshort(sc, 0x19, 0x7c10);
-                        MP_WritePhyUshort(sc, 0x15, 0x0048);
-                        MP_WritePhyUshort(sc, 0x19, 0x63c8);
-                        MP_WritePhyUshort(sc, 0x15, 0x0049);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x15, 0x004a);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x15, 0x004b);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x15, 0x004c);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x15, 0x004d);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x15, 0x004e);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x15, 0x004f);
-                        MP_WritePhyUshort(sc, 0x19, 0x40ea);
-                        MP_WritePhyUshort(sc, 0x15, 0x0050);
-                        MP_WritePhyUshort(sc, 0x19, 0x4503);
-                        MP_WritePhyUshort(sc, 0x15, 0x0051);
-                        MP_WritePhyUshort(sc, 0x19, 0x58ca);
-                        MP_WritePhyUshort(sc, 0x15, 0x0052);
-                        MP_WritePhyUshort(sc, 0x19, 0x63c8);
-                        MP_WritePhyUshort(sc, 0x15, 0x0053);
-                        MP_WritePhyUshort(sc, 0x19, 0x63d8);
-                        MP_WritePhyUshort(sc, 0x15, 0x0054);
-                        MP_WritePhyUshort(sc, 0x19, 0x66a0);
-                        MP_WritePhyUshort(sc, 0x15, 0x0055);
-                        MP_WritePhyUshort(sc, 0x19, 0x9f00);
-                        MP_WritePhyUshort(sc, 0x15, 0x0056);
-                        MP_WritePhyUshort(sc, 0x19, 0x3000);
-                        MP_WritePhyUshort(sc, 0x15, 0x00a1);
-                        MP_WritePhyUshort(sc, 0x19, 0x3044);
-                        MP_WritePhyUshort(sc, 0x15, 0x00ab);
-                        MP_WritePhyUshort(sc, 0x19, 0x5820);
-                        MP_WritePhyUshort(sc, 0x15, 0x00ac);
-                        MP_WritePhyUshort(sc, 0x19, 0x5e04);
-                        MP_WritePhyUshort(sc, 0x15, 0x00ad);
-                        MP_WritePhyUshort(sc, 0x19, 0xb60c);
-                        MP_WritePhyUshort(sc, 0x15, 0x00af);
-                        MP_WritePhyUshort(sc, 0x19, 0x000a);
-                        MP_WritePhyUshort(sc, 0x15, 0x00b2);
-                        MP_WritePhyUshort(sc, 0x19, 0x30b9);
-                        MP_WritePhyUshort(sc, 0x15, 0x00b9);
-                        MP_WritePhyUshort(sc, 0x19, 0x4408);
-                        MP_WritePhyUshort(sc, 0x15, 0x00ba);
-                        MP_WritePhyUshort(sc, 0x19, 0x480b);
-                        MP_WritePhyUshort(sc, 0x15, 0x00bb);
-                        MP_WritePhyUshort(sc, 0x19, 0x5e00);
-                        MP_WritePhyUshort(sc, 0x15, 0x00bc);
-                        MP_WritePhyUshort(sc, 0x19, 0x405f);
-                        MP_WritePhyUshort(sc, 0x15, 0x00bd);
-                        MP_WritePhyUshort(sc, 0x19, 0x4448);
-                        MP_WritePhyUshort(sc, 0x15, 0x00be);
-                        MP_WritePhyUshort(sc, 0x19, 0x4020);
-                        MP_WritePhyUshort(sc, 0x15, 0x00bf);
-                        MP_WritePhyUshort(sc, 0x19, 0x4468);
-                        MP_WritePhyUshort(sc, 0x15, 0x00c0);
-                        MP_WritePhyUshort(sc, 0x19, 0x9c02);
-                        MP_WritePhyUshort(sc, 0x15, 0x00c1);
-                        MP_WritePhyUshort(sc, 0x19, 0x58a0);
-                        MP_WritePhyUshort(sc, 0x15, 0x00c2);
-                        MP_WritePhyUshort(sc, 0x19, 0xb605);
-                        MP_WritePhyUshort(sc, 0x15, 0x00c3);
-                        MP_WritePhyUshort(sc, 0x19, 0xc0d3);
-                        MP_WritePhyUshort(sc, 0x15, 0x00c4);
-                        MP_WritePhyUshort(sc, 0x19, 0x00e6);
-                        MP_WritePhyUshort(sc, 0x15, 0x00c5);
-                        MP_WritePhyUshort(sc, 0x19, 0xdaec);
-                        MP_WritePhyUshort(sc, 0x15, 0x00c6);
-                        MP_WritePhyUshort(sc, 0x19, 0x00fa);
-                        MP_WritePhyUshort(sc, 0x15, 0x00c7);
-                        MP_WritePhyUshort(sc, 0x19, 0x9df9);
-                        MP_WritePhyUshort(sc, 0x15, 0x0112);
-                        MP_WritePhyUshort(sc, 0x19, 0x6421);
-                        MP_WritePhyUshort(sc, 0x15, 0x0113);
-                        MP_WritePhyUshort(sc, 0x19, 0x7c08);
-                        MP_WritePhyUshort(sc, 0x15, 0x0114);
-                        MP_WritePhyUshort(sc, 0x19, 0x63f0);
-                        MP_WritePhyUshort(sc, 0x15, 0x0115);
-                        MP_WritePhyUshort(sc, 0x19, 0x4003);
-                        MP_WritePhyUshort(sc, 0x15, 0x0116);
-                        MP_WritePhyUshort(sc, 0x19, 0x4418);
-                        MP_WritePhyUshort(sc, 0x15, 0x0117);
-                        MP_WritePhyUshort(sc, 0x19, 0x9b00);
-                        MP_WritePhyUshort(sc, 0x15, 0x0118);
-                        MP_WritePhyUshort(sc, 0x19, 0x6461);
-                        MP_WritePhyUshort(sc, 0x15, 0x0119);
-                        MP_WritePhyUshort(sc, 0x19, 0x64e1);
-                        MP_WritePhyUshort(sc, 0x15, 0x011a);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x15, 0x0150);
-                        MP_WritePhyUshort(sc, 0x19, 0x7c80);
-                        MP_WritePhyUshort(sc, 0x15, 0x0151);
-                        MP_WritePhyUshort(sc, 0x19, 0x6461);
-                        MP_WritePhyUshort(sc, 0x15, 0x0152);
-                        MP_WritePhyUshort(sc, 0x19, 0x4003);
-                        MP_WritePhyUshort(sc, 0x15, 0x0153);
-                        MP_WritePhyUshort(sc, 0x19, 0x4540);
-                        MP_WritePhyUshort(sc, 0x15, 0x0154);
-                        MP_WritePhyUshort(sc, 0x19, 0x9f00);
-                        MP_WritePhyUshort(sc, 0x15, 0x0155);
-                        MP_WritePhyUshort(sc, 0x19, 0x9d00);
-                        MP_WritePhyUshort(sc, 0x15, 0x0156);
-                        MP_WritePhyUshort(sc, 0x19, 0x7c40);
-                        MP_WritePhyUshort(sc, 0x15, 0x0157);
-                        MP_WritePhyUshort(sc, 0x19, 0x6421);
-                        MP_WritePhyUshort(sc, 0x15, 0x0158);
-                        MP_WritePhyUshort(sc, 0x19, 0x7c80);
-                        MP_WritePhyUshort(sc, 0x15, 0x0159);
-                        MP_WritePhyUshort(sc, 0x19, 0x64a1);
-                        MP_WritePhyUshort(sc, 0x15, 0x015a);
-                        MP_WritePhyUshort(sc, 0x19, 0x30fe);
-                        MP_WritePhyUshort(sc, 0x15, 0x02e7);
-                        MP_WritePhyUshort(sc, 0x19, 0x0000);
-                        MP_WritePhyUshort(sc, 0x15, 0x0329);
-                        MP_WritePhyUshort(sc, 0x19, 0x7c00);
-                        MP_WritePhyUshort(sc, 0x15, 0x0382);
-                        MP_WritePhyUshort(sc, 0x19, 0x7c40);
-                        MP_WritePhyUshort(sc, 0x15, 0x03bd);
-                        MP_WritePhyUshort(sc, 0x19, 0x405e);
-                        MP_WritePhyUshort(sc, 0x15, 0x03c9);
-                        MP_WritePhyUshort(sc, 0x19, 0x7c00);
-                        MP_WritePhyUshort(sc, 0x15, 0x03e3);
-                        MP_WritePhyUshort(sc, 0x19, 0x7c00);
-                        MP_WritePhyUshort(sc, 0x16, 0x0306);
-                        MP_WritePhyUshort(sc, 0x16, 0x0300);
-                        MP_WritePhyUshort(sc, 0x1f, 0x0005);
-                        MP_WritePhyUshort(sc, 0x05, 0xfff6);
-                        MP_WritePhyUshort(sc, 0x06, 0x0080);
-                        MP_WritePhyUshort(sc, 0x05, 0x8000);
-                        MP_WritePhyUshort(sc, 0x06, 0x0280);
-                        MP_WritePhyUshort(sc, 0x06, 0x48f7);
-                        MP_WritePhyUshort(sc, 0x06, 0x00e0);
-                        MP_WritePhyUshort(sc, 0x06, 0xfff7);
-                        MP_WritePhyUshort(sc, 0x06, 0xa080);
-                        MP_WritePhyUshort(sc, 0x06, 0x02ae);
-                        MP_WritePhyUshort(sc, 0x06, 0xf602);
-                        MP_WritePhyUshort(sc, 0x06, 0x0200);
-                        MP_WritePhyUshort(sc, 0x06, 0x0202);
-                        MP_WritePhyUshort(sc, 0x06, 0x1102);
-                        MP_WritePhyUshort(sc, 0x06, 0x0224);
-                        MP_WritePhyUshort(sc, 0x06, 0x0202);
-                        MP_WritePhyUshort(sc, 0x06, 0x3402);
-                        MP_WritePhyUshort(sc, 0x06, 0x027f);
-                        MP_WritePhyUshort(sc, 0x06, 0x0202);
-                        MP_WritePhyUshort(sc, 0x06, 0x9202);
-                        MP_WritePhyUshort(sc, 0x06, 0x8078);
-                        MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                        MP_WritePhyUshort(sc, 0x06, 0x88e1);
-                        MP_WritePhyUshort(sc, 0x06, 0x8b89);
-                        MP_WritePhyUshort(sc, 0x06, 0x1e01);
-                        MP_WritePhyUshort(sc, 0x06, 0xe18b);
-                        MP_WritePhyUshort(sc, 0x06, 0x8a1e);
-                        MP_WritePhyUshort(sc, 0x06, 0x01e1);
-                        MP_WritePhyUshort(sc, 0x06, 0x8b8b);
-                        MP_WritePhyUshort(sc, 0x06, 0x1e01);
-                        MP_WritePhyUshort(sc, 0x06, 0xe18b);
-                        MP_WritePhyUshort(sc, 0x06, 0x8c1e);
-                        MP_WritePhyUshort(sc, 0x06, 0x01e1);
-                        MP_WritePhyUshort(sc, 0x06, 0x8b8d);
-                        MP_WritePhyUshort(sc, 0x06, 0x1e01);
-                        MP_WritePhyUshort(sc, 0x06, 0xe18b);
-                        MP_WritePhyUshort(sc, 0x06, 0x8e1e);
-                        MP_WritePhyUshort(sc, 0x06, 0x01a0);
-                        MP_WritePhyUshort(sc, 0x06, 0x00c7);
-                        MP_WritePhyUshort(sc, 0x06, 0xaebb);
-                        MP_WritePhyUshort(sc, 0x06, 0xee85);
-                        MP_WritePhyUshort(sc, 0x06, 0x0000);
-                        MP_WritePhyUshort(sc, 0x06, 0xd480);
-                        MP_WritePhyUshort(sc, 0x06, 0xebe4);
-                        MP_WritePhyUshort(sc, 0x06, 0x8b94);
-                        MP_WritePhyUshort(sc, 0x06, 0xe58b);
-                        MP_WritePhyUshort(sc, 0x06, 0x95bf);
-                        MP_WritePhyUshort(sc, 0x06, 0x8b88);
-                        MP_WritePhyUshort(sc, 0x06, 0xec00);
-                        MP_WritePhyUshort(sc, 0x06, 0x19a9);
-                        MP_WritePhyUshort(sc, 0x06, 0x8b90);
-                        MP_WritePhyUshort(sc, 0x06, 0xf9ee);
-                        MP_WritePhyUshort(sc, 0x06, 0xfff6);
-                        MP_WritePhyUshort(sc, 0x06, 0x00ee);
-                        MP_WritePhyUshort(sc, 0x06, 0xfff7);
-                        MP_WritePhyUshort(sc, 0x06, 0xffe0);
-                        MP_WritePhyUshort(sc, 0x06, 0xe140);
-                        MP_WritePhyUshort(sc, 0x06, 0xe1e1);
-                        MP_WritePhyUshort(sc, 0x06, 0x41f7);
-                        MP_WritePhyUshort(sc, 0x06, 0x2ff6);
-                        MP_WritePhyUshort(sc, 0x06, 0x28e4);
-                        MP_WritePhyUshort(sc, 0x06, 0xe140);
-                        MP_WritePhyUshort(sc, 0x06, 0xe5e1);
-                        MP_WritePhyUshort(sc, 0x06, 0x4104);
-                        MP_WritePhyUshort(sc, 0x06, 0xf8e0);
-                        MP_WritePhyUshort(sc, 0x06, 0x8b8e);
-                        MP_WritePhyUshort(sc, 0x06, 0xad20);
-                        MP_WritePhyUshort(sc, 0x06, 0x11f6);
-                        MP_WritePhyUshort(sc, 0x06, 0x20e4);
-                        MP_WritePhyUshort(sc, 0x06, 0x8b8e);
-                        MP_WritePhyUshort(sc, 0x06, 0x0280);
-                        MP_WritePhyUshort(sc, 0x06, 0xba02);
-                        MP_WritePhyUshort(sc, 0x06, 0x1bf4);
-                        MP_WritePhyUshort(sc, 0x06, 0x022c);
-                        MP_WritePhyUshort(sc, 0x06, 0x9c02);
-                        MP_WritePhyUshort(sc, 0x06, 0x812c);
-                        MP_WritePhyUshort(sc, 0x06, 0xad22);
-                        MP_WritePhyUshort(sc, 0x06, 0x11f6);
-                        MP_WritePhyUshort(sc, 0x06, 0x22e4);
-                        MP_WritePhyUshort(sc, 0x06, 0x8b8e);
-                        MP_WritePhyUshort(sc, 0x06, 0x022c);
-                        MP_WritePhyUshort(sc, 0x06, 0x4602);
-                        MP_WritePhyUshort(sc, 0x06, 0x2ac5);
-                        MP_WritePhyUshort(sc, 0x06, 0x0229);
-                        MP_WritePhyUshort(sc, 0x06, 0x2002);
-                        MP_WritePhyUshort(sc, 0x06, 0x2b91);
-                        MP_WritePhyUshort(sc, 0x06, 0xad25);
-                        MP_WritePhyUshort(sc, 0x06, 0x11f6);
-                        MP_WritePhyUshort(sc, 0x06, 0x25e4);
-                        MP_WritePhyUshort(sc, 0x06, 0x8b8e);
-                        MP_WritePhyUshort(sc, 0x06, 0x0203);
-                        MP_WritePhyUshort(sc, 0x06, 0x5a02);
-                        MP_WritePhyUshort(sc, 0x06, 0x043a);
-                        MP_WritePhyUshort(sc, 0x06, 0x021a);
-                        MP_WritePhyUshort(sc, 0x06, 0x5902);
-                        MP_WritePhyUshort(sc, 0x06, 0x2bfc);
-                        MP_WritePhyUshort(sc, 0x06, 0xfc04);
-                        MP_WritePhyUshort(sc, 0x06, 0xf8fa);
-                        MP_WritePhyUshort(sc, 0x06, 0xef69);
-                        MP_WritePhyUshort(sc, 0x06, 0xe0e0);
-                        MP_WritePhyUshort(sc, 0x06, 0x00e1);
-                        MP_WritePhyUshort(sc, 0x06, 0xe001);
-                        MP_WritePhyUshort(sc, 0x06, 0xad27);
-                        MP_WritePhyUshort(sc, 0x06, 0x1fd1);
-                        MP_WritePhyUshort(sc, 0x06, 0x01bf);
-                        MP_WritePhyUshort(sc, 0x06, 0x819f);
-                        MP_WritePhyUshort(sc, 0x06, 0x022f);
-                        MP_WritePhyUshort(sc, 0x06, 0x50e0);
-                        MP_WritePhyUshort(sc, 0x06, 0xe020);
-                        MP_WritePhyUshort(sc, 0x06, 0xe1e0);
-                        MP_WritePhyUshort(sc, 0x06, 0x21ad);
-                        MP_WritePhyUshort(sc, 0x06, 0x200e);
-                        MP_WritePhyUshort(sc, 0x06, 0xd100);
-                        MP_WritePhyUshort(sc, 0x06, 0xbf81);
-                        MP_WritePhyUshort(sc, 0x06, 0x9f02);
-                        MP_WritePhyUshort(sc, 0x06, 0x2f50);
-                        MP_WritePhyUshort(sc, 0x06, 0xbf3d);
-                        MP_WritePhyUshort(sc, 0x06, 0x3902);
-                        MP_WritePhyUshort(sc, 0x06, 0x2eb0);
-                        MP_WritePhyUshort(sc, 0x06, 0xef96);
-                        MP_WritePhyUshort(sc, 0x06, 0xfefc);
-                        MP_WritePhyUshort(sc, 0x06, 0x0402);
-                        MP_WritePhyUshort(sc, 0x06, 0x80ef);
-                        MP_WritePhyUshort(sc, 0x06, 0x05f8);
-                        MP_WritePhyUshort(sc, 0x06, 0xfaef);
-                        MP_WritePhyUshort(sc, 0x06, 0x69e0);
-                        MP_WritePhyUshort(sc, 0x06, 0xe2fe);
-                        MP_WritePhyUshort(sc, 0x06, 0xe1e2);
-                        MP_WritePhyUshort(sc, 0x06, 0xffad);
-                        MP_WritePhyUshort(sc, 0x06, 0x2d1a);
-                        MP_WritePhyUshort(sc, 0x06, 0xe0e1);
-                        MP_WritePhyUshort(sc, 0x06, 0x4ee1);
-                        MP_WritePhyUshort(sc, 0x06, 0xe14f);
-                        MP_WritePhyUshort(sc, 0x06, 0xac2d);
-                        MP_WritePhyUshort(sc, 0x06, 0x22f6);
-                        MP_WritePhyUshort(sc, 0x06, 0x0302);
-                        MP_WritePhyUshort(sc, 0x06, 0x0336);
-                        MP_WritePhyUshort(sc, 0x06, 0xf703);
-                        MP_WritePhyUshort(sc, 0x06, 0xf706);
-                        MP_WritePhyUshort(sc, 0x06, 0xbf81);
-                        MP_WritePhyUshort(sc, 0x06, 0x8902);
-                        MP_WritePhyUshort(sc, 0x06, 0x2eb0);
-                        MP_WritePhyUshort(sc, 0x06, 0xae11);
-                        MP_WritePhyUshort(sc, 0x06, 0xe0e1);
-                        MP_WritePhyUshort(sc, 0x06, 0x4ee1);
-                        MP_WritePhyUshort(sc, 0x06, 0xe14f);
-                        MP_WritePhyUshort(sc, 0x06, 0xad2d);
-                        MP_WritePhyUshort(sc, 0x06, 0x08bf);
-                        MP_WritePhyUshort(sc, 0x06, 0x8194);
-                        MP_WritePhyUshort(sc, 0x06, 0x022e);
-                        MP_WritePhyUshort(sc, 0x06, 0xb0f6);
-                        MP_WritePhyUshort(sc, 0x06, 0x06ef);
-                        MP_WritePhyUshort(sc, 0x06, 0x96fe);
-                        MP_WritePhyUshort(sc, 0x06, 0xfc04);
-                        MP_WritePhyUshort(sc, 0x06, 0xf8f9);
-                        MP_WritePhyUshort(sc, 0x06, 0xfaef);
-                        MP_WritePhyUshort(sc, 0x06, 0x69e0);
-                        MP_WritePhyUshort(sc, 0x06, 0x8b87);
-                        MP_WritePhyUshort(sc, 0x06, 0xad20);
-                        MP_WritePhyUshort(sc, 0x06, 0x4cd2);
-                        MP_WritePhyUshort(sc, 0x06, 0x00e0);
-                        MP_WritePhyUshort(sc, 0x06, 0xe200);
-                        MP_WritePhyUshort(sc, 0x06, 0x5801);
-                        MP_WritePhyUshort(sc, 0x06, 0x0c02);
-                        MP_WritePhyUshort(sc, 0x06, 0x1e20);
-                        MP_WritePhyUshort(sc, 0x06, 0xe0e0);
-                        MP_WritePhyUshort(sc, 0x06, 0x0058);
-                        MP_WritePhyUshort(sc, 0x06, 0x101e);
-                        MP_WritePhyUshort(sc, 0x06, 0x20e0);
-                        MP_WritePhyUshort(sc, 0x06, 0xe036);
-                        MP_WritePhyUshort(sc, 0x06, 0x5803);
-                        MP_WritePhyUshort(sc, 0x06, 0x1e20);
-                        MP_WritePhyUshort(sc, 0x06, 0xe0e0);
-                        MP_WritePhyUshort(sc, 0x06, 0x22e1);
-                        MP_WritePhyUshort(sc, 0x06, 0xe023);
-                        MP_WritePhyUshort(sc, 0x06, 0x58e0);
-                        MP_WritePhyUshort(sc, 0x06, 0x1e20);
-                        MP_WritePhyUshort(sc, 0x06, 0xe085);
-                        MP_WritePhyUshort(sc, 0x06, 0x001f);
-                        MP_WritePhyUshort(sc, 0x06, 0x029e);
-                        MP_WritePhyUshort(sc, 0x06, 0x22e6);
-                        MP_WritePhyUshort(sc, 0x06, 0x8500);
-                        MP_WritePhyUshort(sc, 0x06, 0xad32);
-                        MP_WritePhyUshort(sc, 0x06, 0x14ad);
-                        MP_WritePhyUshort(sc, 0x06, 0x3411);
-                        MP_WritePhyUshort(sc, 0x06, 0xef02);
-                        MP_WritePhyUshort(sc, 0x06, 0x5803);
-                        MP_WritePhyUshort(sc, 0x06, 0x9e07);
-                        MP_WritePhyUshort(sc, 0x06, 0xad35);
-                        MP_WritePhyUshort(sc, 0x06, 0x085a);
-                        MP_WritePhyUshort(sc, 0x06, 0xc09f);
-                        MP_WritePhyUshort(sc, 0x06, 0x04d1);
-                        MP_WritePhyUshort(sc, 0x06, 0x01ae);
-                        MP_WritePhyUshort(sc, 0x06, 0x02d1);
-                        MP_WritePhyUshort(sc, 0x06, 0x00bf);
-                        MP_WritePhyUshort(sc, 0x06, 0x81a5);
-                        MP_WritePhyUshort(sc, 0x06, 0x022f);
-                        MP_WritePhyUshort(sc, 0x06, 0x50ef);
-                        MP_WritePhyUshort(sc, 0x06, 0x96fe);
-                        MP_WritePhyUshort(sc, 0x06, 0xfdfc);
-                        MP_WritePhyUshort(sc, 0x06, 0x04a7);
-                        MP_WritePhyUshort(sc, 0x06, 0x25e5);
-                        MP_WritePhyUshort(sc, 0x06, 0x0a1d);
-                        MP_WritePhyUshort(sc, 0x06, 0xe50a);
-                        MP_WritePhyUshort(sc, 0x06, 0x2ce5);
-                        MP_WritePhyUshort(sc, 0x06, 0x0a6d);
-                        MP_WritePhyUshort(sc, 0x06, 0xe50a);
-                        MP_WritePhyUshort(sc, 0x06, 0x1de5);
-                        MP_WritePhyUshort(sc, 0x06, 0x0a1c);
-                        MP_WritePhyUshort(sc, 0x06, 0xe50a);
-                        MP_WritePhyUshort(sc, 0x06, 0x2da7);
-                        MP_WritePhyUshort(sc, 0x06, 0x5500);
-                        MP_WritePhyUshort(sc, 0x06, 0xe234);
-                        MP_WritePhyUshort(sc, 0x06, 0x88e2);
-                        MP_WritePhyUshort(sc, 0x06, 0x00cc);
-                        MP_WritePhyUshort(sc, 0x06, 0xe200);
-                        MP_WritePhyUshort(sc, 0x05, 0x8b86);
-                        MP_WritePhyUshort(sc, 0x06, 0x0001);
-                        Data = MP_ReadPhyUshort(sc, 0x01);
-                        Data |= 0x0001;
-                        MP_WritePhyUshort(sc, 0x01, Data);
-                        MP_WritePhyUshort(sc, 0x00, 0x0005);
-                        MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                        MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                        MP_WritePhyUshort(sc, 0x17, 0x2179);
-                        MP_WritePhyUshort(sc, 0x1f, 0x0001);
-                        MP_WritePhyUshort(sc, 0x10, 0xf274);
-                        MP_WritePhyUshort(sc, 0x1f, 0x0007);
-                        MP_WritePhyUshort(sc, 0x1e, 0x0042);
-                        MP_WritePhyUshort(sc, 0x15, 0x0f00);
-                        MP_WritePhyUshort(sc, 0x15, 0x0f00);
-                        MP_WritePhyUshort(sc, 0x16, 0x7408);
-                        MP_WritePhyUshort(sc, 0x15, 0x0e00);
-                        MP_WritePhyUshort(sc, 0x15, 0x0f00);
-                        MP_WritePhyUshort(sc, 0x15, 0x0f01);
-                        MP_WritePhyUshort(sc, 0x16, 0x4000);
-                        MP_WritePhyUshort(sc, 0x15, 0x0e01);
-                        MP_WritePhyUshort(sc, 0x15, 0x0f01);
-                        MP_WritePhyUshort(sc, 0x15, 0x0f02);
-                        MP_WritePhyUshort(sc, 0x16, 0x9400);
-                        MP_WritePhyUshort(sc, 0x15, 0x0e02);
-                        MP_WritePhyUshort(sc, 0x15, 0x0f02);
-                        MP_WritePhyUshort(sc, 0x15, 0x0f03);
-                        MP_WritePhyUshort(sc, 0x16, 0x7408);
-                        MP_WritePhyUshort(sc, 0x15, 0x0e03);
-                        MP_WritePhyUshort(sc, 0x15, 0x0f03);
-                        MP_WritePhyUshort(sc, 0x15, 0x0f04);
-                        MP_WritePhyUshort(sc, 0x16, 0x4008);
-                        MP_WritePhyUshort(sc, 0x15, 0x0e04);
-                        MP_WritePhyUshort(sc, 0x15, 0x0f04);
-                        MP_WritePhyUshort(sc, 0x15, 0x0f05);
-                        MP_WritePhyUshort(sc, 0x16, 0x9400);
-                        MP_WritePhyUshort(sc, 0x15, 0x0e05);
-                        MP_WritePhyUshort(sc, 0x15, 0x0f05);
-                        MP_WritePhyUshort(sc, 0x15, 0x0f06);
-                        MP_WritePhyUshort(sc, 0x16, 0x0803);
-                        MP_WritePhyUshort(sc, 0x15, 0x0e06);
-                        MP_WritePhyUshort(sc, 0x15, 0x0f06);
-                        MP_WritePhyUshort(sc, 0x15, 0x0d00);
-                        MP_WritePhyUshort(sc, 0x15, 0x0100);
-                        MP_WritePhyUshort(sc, 0x1f, 0x0001);
-                        MP_WritePhyUshort(sc, 0x10, 0xf074);
-                        MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                        MP_WritePhyUshort(sc, 0x17, 0x2149);
-                        MP_WritePhyUshort(sc, 0x1f, 0x0005);
-                        for (i=0; i<200; i++) {
-                                DELAY(100);
-                                Data = MP_ReadPhyUshort(sc, 0x00);
-                                if (Data&0x0080)
-                                        break;
-                        }
-                        MP_WritePhyUshort(sc, 0x1f, 0x0007);
-                        MP_WritePhyUshort(sc, 0x1e, 0x0023);
-                        MP_WritePhyUshort(sc, 0x17, 0x0116);
-                        MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                        MP_WritePhyUshort(sc, 0x1f, 0x0007);
-                        MP_WritePhyUshort(sc, 0x1e, 0x0023);
-                        Data = MP_ReadPhyUshort(sc, 0x17);
-                        Data |= 0x4000;
-                        MP_WritePhyUshort(sc, 0x17, Data);
-                        MP_WritePhyUshort(sc, 0x1e, 0x0020);
-                        Data = MP_ReadPhyUshort(sc, 0x1b);
-                        Data |= 0x0080;
-                        MP_WritePhyUshort(sc, 0x1b, Data);
-                        MP_WritePhyUshort(sc, 0x1e, 0x0041);
-                        MP_WritePhyUshort(sc, 0x15, 0x0e02);
-                        MP_WritePhyUshort(sc, 0x1e, 0x0028);
-                        Data = MP_ReadPhyUshort(sc, 0x19);
-                        Data |= 0x8000;
-                        MP_WritePhyUshort(sc, 0x19, Data);
-                        MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                }
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0007);
-                MP_WritePhyUshort(sc, 0x1E, 0x0023);
-                Data = MP_ReadPhyUshort(sc, 0x17) | 0x0006;
-                MP_WritePhyUshort(sc, 0x17, Data);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1f, 0x0005);
-                MP_WritePhyUshort(sc, 0x05, 0x8b80);
-                MP_WritePhyUshort(sc, 0x06, 0xc896);
-                MP_WritePhyUshort(sc, 0x1f, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0001);
-                MP_WritePhyUshort(sc, 0x0B, 0x6C20);
-                MP_WritePhyUshort(sc, 0x07, 0x2872);
-                MP_WritePhyUshort(sc, 0x1C, 0xEFFF);
-                MP_WritePhyUshort(sc, 0x1F, 0x0003);
-                MP_WritePhyUshort(sc, 0x14, 0x6420);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0002);
-                Data = MP_ReadPhyUshort(sc, 0x08) & 0x00FF;
-                MP_WritePhyUshort(sc, 0x08, Data | 0x8000);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0007);
-                MP_WritePhyUshort(sc, 0x1E, 0x002D);
-                Data = MP_ReadPhyUshort(sc, 0x18);
-                MP_WritePhyUshort(sc, 0x18, Data | 0x0050);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-                Data = MP_ReadPhyUshort(sc, 0x14);
-                MP_WritePhyUshort(sc, 0x14, Data | 0x8000);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0002);
-                MP_WritePhyUshort(sc, 0x00, 0x080B);
-                MP_WritePhyUshort(sc, 0x0B, 0x09D7);
-                MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x1006);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0007);
-                MP_WritePhyUshort(sc, 0x1E, 0x002F);
-                MP_WritePhyUshort(sc, 0x15, 0x1919);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0003);
-                MP_WritePhyUshort(sc, 0x19, 0x7F46);
-                MP_WritePhyUshort(sc, 0x1F, 0x0005);
-                MP_WritePhyUshort(sc, 0x05, 0x8AD2);
-                MP_WritePhyUshort(sc, 0x06, 0x6810);
-                MP_WritePhyUshort(sc, 0x05, 0x8AD4);
-                MP_WritePhyUshort(sc, 0x06, 0x8002);
-                MP_WritePhyUshort(sc, 0x05, 0x8ADE);
-                MP_WritePhyUshort(sc, 0x06, 0x8025);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-        } else if (sc->re_type == MACFG_38) {
-                CSR_WRITE_1(sc, 0x6E, CSR_READ_1(sc, 0x6E)| (1<<6));
-
-                Data_u32 = re_eri_read(sc, 0x1D0, 4, ERIAR_ExGMAC);
-                Data_u32 &= ~BIT_1;
-                re_eri_write(sc, 0x1D0, 4, Data_u32, ERIAR_ExGMAC);
-
-                MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                MP_WritePhyUshort(sc, 0x00, 0x1800);
-                Data= MP_ReadPhyUshort(sc, 0x15);
-                Data &= ~BIT_12;
-                MP_WritePhyUshort(sc, 0x15, Data);
-                DELAY(200);
-                DELAY(200);
-                MP_WritePhyUshort(sc, 0x1f, 0x0004);
-                MP_WritePhyUshort(sc, 0x1f, 0x0007);
-                MP_WritePhyUshort(sc, 0x1e, 0x0023);
-                Data = MP_ReadPhyUshort(sc, 0x17);
-                if ((Data & BIT_11) == 0x0000) {
-                        Data |= BIT_0;
-                        MP_WritePhyUshort(sc, 0x17, Data);
-                        for (i = 0; i < 200; i++) {
-                                DELAY(100);
-                                Data = MP_ReadPhyUshort(sc, 0x17);
-                                if (Data & BIT_11)
-                                        break;
-                        }
-                }
-                Data = MP_ReadPhyUshort(sc, 0x17);
-                Data |= BIT_11;
-                MP_WritePhyUshort(sc, 0x17,Data);
-                MP_WritePhyUshort(sc, 0x1f, 0x0004);
-                MP_WritePhyUshort(sc, 0x1f, 0x0007);
-                MP_WritePhyUshort(sc, 0x1E, 0x002C);
-                MP_WritePhyUshort(sc, 0x1B, 0x5000);
-                MP_WritePhyUshort(sc, 0x1E, 0x002d);
-                MP_WritePhyUshort(sc, 0x19, 0x0004);
-                MP_WritePhyUshort(sc, 0x1f, 0x0002);
-                MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                for (i = 0; i < 200; i++) {
-                        DELAY(100);
-                        Data= MP_ReadPhyUshort(sc, 0x1E);
-                        if ((Data& 0x03FF) == 0x0014)
-                                break;
-                }
-                MP_WritePhyUshort(sc, 0x1f, 0x0005);
-                for (i = 0; i < 200; i++) {
-                        DELAY(100);
-                        Data= MP_ReadPhyUshort(sc, 0x07);
-                        if ((Data& BIT_5) == 0)
-                                break;
-                }
-                Data = MP_ReadPhyUshort(sc, 0x07);
-                if (Data & BIT_5) {
-                        MP_WritePhyUshort(sc, 0x1f, 0x0004);
-                        MP_WritePhyUshort(sc, 0x1f, 0x0007);
-                        MP_WritePhyUshort(sc, 0x1e, 0x00a1);
-                        MP_WritePhyUshort(sc, 0x17, 0x1000);
-                        MP_WritePhyUshort(sc, 0x17, 0x0000);
-                        MP_WritePhyUshort(sc, 0x17, 0x2000);
-                        MP_WritePhyUshort(sc, 0x1e, 0x002f);
-                        MP_WritePhyUshort(sc, 0x18, 0x9bfb);
-                        MP_WritePhyUshort(sc, 0x1f, 0x0005);
-                        MP_WritePhyUshort(sc, 0x07, 0x0000);
-                        MP_WritePhyUshort(sc, 0x1f, 0x0002);
-                        MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                }
-                MP_WritePhyUshort(sc, 0x1f, 0x0005);
-                MP_WritePhyUshort(sc, 0x05, 0xfff6);
-                MP_WritePhyUshort(sc, 0x06, 0x0080);
-                Data = MP_ReadPhyUshort(sc, 0x00);
-                Data &= ~BIT_7;
-                MP_WritePhyUshort(sc, 0x00, Data);
-                MP_WritePhyUshort(sc, 0x1f, 0x0004);
-                MP_WritePhyUshort(sc, 0x1f, 0x0007);
-                MP_WritePhyUshort(sc, 0x1e, 0x0023);
-                MP_WritePhyUshort(sc, 0x16, 0x0306);
-                MP_WritePhyUshort(sc, 0x16, 0x0307);
-                MP_WritePhyUshort(sc, 0x15, 0x0000);
-                MP_WritePhyUshort(sc, 0x19, 0x407d);
-                MP_WritePhyUshort(sc, 0x15, 0x0001);
-                MP_WritePhyUshort(sc, 0x19, 0x440f);
-                MP_WritePhyUshort(sc, 0x15, 0x0002);
-                MP_WritePhyUshort(sc, 0x19, 0x7c03);
-                MP_WritePhyUshort(sc, 0x15, 0x0003);
-                MP_WritePhyUshort(sc, 0x19, 0x6c03);
-                MP_WritePhyUshort(sc, 0x15, 0x0004);
-                MP_WritePhyUshort(sc, 0x19, 0xc4d5);
-                MP_WritePhyUshort(sc, 0x15, 0x0005);
-                MP_WritePhyUshort(sc, 0x19, 0x00ff);
-                MP_WritePhyUshort(sc, 0x15, 0x0006);
-                MP_WritePhyUshort(sc, 0x19, 0x74f0);
-                MP_WritePhyUshort(sc, 0x15, 0x0007);
-                MP_WritePhyUshort(sc, 0x19, 0x4880);
-                MP_WritePhyUshort(sc, 0x15, 0x0008);
-                MP_WritePhyUshort(sc, 0x19, 0x4c00);
-                MP_WritePhyUshort(sc, 0x15, 0x0009);
-                MP_WritePhyUshort(sc, 0x19, 0x4800);
-                MP_WritePhyUshort(sc, 0x15, 0x000a);
-                MP_WritePhyUshort(sc, 0x19, 0x5000);
-                MP_WritePhyUshort(sc, 0x15, 0x000b);
-                MP_WritePhyUshort(sc, 0x19, 0x4400);
-                MP_WritePhyUshort(sc, 0x15, 0x000c);
-                MP_WritePhyUshort(sc, 0x19, 0x7801);
-                MP_WritePhyUshort(sc, 0x15, 0x000d);
-                MP_WritePhyUshort(sc, 0x19, 0x4000);
-                MP_WritePhyUshort(sc, 0x15, 0x000e);
-                MP_WritePhyUshort(sc, 0x19, 0x7800);
-                MP_WritePhyUshort(sc, 0x15, 0x000f);
-                MP_WritePhyUshort(sc, 0x19, 0x7010);
-                MP_WritePhyUshort(sc, 0x15, 0x0010);
-                MP_WritePhyUshort(sc, 0x19, 0x6804);
-                MP_WritePhyUshort(sc, 0x15, 0x0011);
-                MP_WritePhyUshort(sc, 0x19, 0x64a0);
-                MP_WritePhyUshort(sc, 0x15, 0x0012);
-                MP_WritePhyUshort(sc, 0x19, 0x63da);
-                MP_WritePhyUshort(sc, 0x15, 0x0013);
-                MP_WritePhyUshort(sc, 0x19, 0x63d8);
-                MP_WritePhyUshort(sc, 0x15, 0x0014);
-                MP_WritePhyUshort(sc, 0x19, 0x6f05);
-                MP_WritePhyUshort(sc, 0x15, 0x0015);
-                MP_WritePhyUshort(sc, 0x19, 0x5420);
-                MP_WritePhyUshort(sc, 0x15, 0x0016);
-                MP_WritePhyUshort(sc, 0x19, 0x58ce);
-                MP_WritePhyUshort(sc, 0x15, 0x0017);
-                MP_WritePhyUshort(sc, 0x19, 0x5cf3);
-                MP_WritePhyUshort(sc, 0x15, 0x0018);
-                MP_WritePhyUshort(sc, 0x19, 0xb600);
-                MP_WritePhyUshort(sc, 0x15, 0x0019);
-                MP_WritePhyUshort(sc, 0x19, 0xc659);
-                MP_WritePhyUshort(sc, 0x15, 0x001a);
-                MP_WritePhyUshort(sc, 0x19, 0x0018);
-                MP_WritePhyUshort(sc, 0x15, 0x001b);
-                MP_WritePhyUshort(sc, 0x19, 0xc403);
-                MP_WritePhyUshort(sc, 0x15, 0x001c);
-                MP_WritePhyUshort(sc, 0x19, 0x0016);
-                MP_WritePhyUshort(sc, 0x15, 0x001d);
-                MP_WritePhyUshort(sc, 0x19, 0xaa05);
-                MP_WritePhyUshort(sc, 0x15, 0x001e);
-                MP_WritePhyUshort(sc, 0x19, 0xc503);
-                MP_WritePhyUshort(sc, 0x15, 0x001f);
-                MP_WritePhyUshort(sc, 0x19, 0x0003);
-                MP_WritePhyUshort(sc, 0x15, 0x0020);
-                MP_WritePhyUshort(sc, 0x19, 0x89f8);
-                MP_WritePhyUshort(sc, 0x15, 0x0021);
-                MP_WritePhyUshort(sc, 0x19, 0x32ae);
-                MP_WritePhyUshort(sc, 0x15, 0x0022);
-                MP_WritePhyUshort(sc, 0x19, 0x7c03);
-                MP_WritePhyUshort(sc, 0x15, 0x0023);
-                MP_WritePhyUshort(sc, 0x19, 0x6c03);
-                MP_WritePhyUshort(sc, 0x15, 0x0024);
-                MP_WritePhyUshort(sc, 0x19, 0x7c03);
-                MP_WritePhyUshort(sc, 0x15, 0x0025);
-                MP_WritePhyUshort(sc, 0x19, 0x6801);
-                MP_WritePhyUshort(sc, 0x15, 0x0026);
-                MP_WritePhyUshort(sc, 0x19, 0x66a0);
-                MP_WritePhyUshort(sc, 0x15, 0x0027);
-                MP_WritePhyUshort(sc, 0x19, 0xa300);
-                MP_WritePhyUshort(sc, 0x15, 0x0028);
-                MP_WritePhyUshort(sc, 0x19, 0x64a0);
-                MP_WritePhyUshort(sc, 0x15, 0x0029);
-                MP_WritePhyUshort(sc, 0x19, 0x76f0);
-                MP_WritePhyUshort(sc, 0x15, 0x002a);
-                MP_WritePhyUshort(sc, 0x19, 0x7670);
-                MP_WritePhyUshort(sc, 0x15, 0x002b);
-                MP_WritePhyUshort(sc, 0x19, 0x7630);
-                MP_WritePhyUshort(sc, 0x15, 0x002c);
-                MP_WritePhyUshort(sc, 0x19, 0x31a6);
-                MP_WritePhyUshort(sc, 0x15, 0x002d);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x002e);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x002f);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x0030);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x0031);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x0032);
-                MP_WritePhyUshort(sc, 0x19, 0x4801);
-                MP_WritePhyUshort(sc, 0x15, 0x0033);
-                MP_WritePhyUshort(sc, 0x19, 0x6803);
-                MP_WritePhyUshort(sc, 0x15, 0x0034);
-                MP_WritePhyUshort(sc, 0x19, 0x66a1);
-                MP_WritePhyUshort(sc, 0x15, 0x0035);
-                MP_WritePhyUshort(sc, 0x19, 0x7c03);
-                MP_WritePhyUshort(sc, 0x15, 0x0036);
-                MP_WritePhyUshort(sc, 0x19, 0x6c03);
-                MP_WritePhyUshort(sc, 0x15, 0x0037);
-                MP_WritePhyUshort(sc, 0x19, 0xa300);
-                MP_WritePhyUshort(sc, 0x15, 0x0038);
-                MP_WritePhyUshort(sc, 0x19, 0x64a1);
-                MP_WritePhyUshort(sc, 0x15, 0x0039);
-                MP_WritePhyUshort(sc, 0x19, 0x7c08);
-                MP_WritePhyUshort(sc, 0x15, 0x003a);
-                MP_WritePhyUshort(sc, 0x19, 0x74f8);
-                MP_WritePhyUshort(sc, 0x15, 0x003b);
-                MP_WritePhyUshort(sc, 0x19, 0x63d0);
-                MP_WritePhyUshort(sc, 0x15, 0x003c);
-                MP_WritePhyUshort(sc, 0x19, 0x7ff0);
-                MP_WritePhyUshort(sc, 0x15, 0x003d);
-                MP_WritePhyUshort(sc, 0x19, 0x77f0);
-                MP_WritePhyUshort(sc, 0x15, 0x003e);
-                MP_WritePhyUshort(sc, 0x19, 0x7ff0);
-                MP_WritePhyUshort(sc, 0x15, 0x003f);
-                MP_WritePhyUshort(sc, 0x19, 0x7750);
-                MP_WritePhyUshort(sc, 0x15, 0x0040);
-                MP_WritePhyUshort(sc, 0x19, 0x63d8);
-                MP_WritePhyUshort(sc, 0x15, 0x0041);
-                MP_WritePhyUshort(sc, 0x19, 0x7cf0);
-                MP_WritePhyUshort(sc, 0x15, 0x0042);
-                MP_WritePhyUshort(sc, 0x19, 0x7708);
-                MP_WritePhyUshort(sc, 0x15, 0x0043);
-                MP_WritePhyUshort(sc, 0x19, 0xa654);
-                MP_WritePhyUshort(sc, 0x15, 0x0044);
-                MP_WritePhyUshort(sc, 0x19, 0x304a);
-                MP_WritePhyUshort(sc, 0x15, 0x0045);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x0046);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x0047);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x0048);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x0049);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x004a);
-                MP_WritePhyUshort(sc, 0x19, 0x4802);
-                MP_WritePhyUshort(sc, 0x15, 0x004b);
-                MP_WritePhyUshort(sc, 0x19, 0x4003);
-                MP_WritePhyUshort(sc, 0x15, 0x004c);
-                MP_WritePhyUshort(sc, 0x19, 0x4440);
-                MP_WritePhyUshort(sc, 0x15, 0x004d);
-                MP_WritePhyUshort(sc, 0x19, 0x63c8);
-                MP_WritePhyUshort(sc, 0x15, 0x004e);
-                MP_WritePhyUshort(sc, 0x19, 0x6481);
-                MP_WritePhyUshort(sc, 0x15, 0x004f);
-                MP_WritePhyUshort(sc, 0x19, 0x9d00);
-                MP_WritePhyUshort(sc, 0x15, 0x0050);
-                MP_WritePhyUshort(sc, 0x19, 0x63e8);
-                MP_WritePhyUshort(sc, 0x15, 0x0051);
-                MP_WritePhyUshort(sc, 0x19, 0x7d00);
-                MP_WritePhyUshort(sc, 0x15, 0x0052);
-                MP_WritePhyUshort(sc, 0x19, 0x5900);
-                MP_WritePhyUshort(sc, 0x15, 0x0053);
-                MP_WritePhyUshort(sc, 0x19, 0x63f8);
-                MP_WritePhyUshort(sc, 0x15, 0x0054);
-                MP_WritePhyUshort(sc, 0x19, 0x64a1);
-                MP_WritePhyUshort(sc, 0x15, 0x0055);
-                MP_WritePhyUshort(sc, 0x19, 0x3116);
-                MP_WritePhyUshort(sc, 0x15, 0x0056);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x0057);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x0058);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x0059);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x005a);
-                MP_WritePhyUshort(sc, 0x19, 0x7c03);
-                MP_WritePhyUshort(sc, 0x15, 0x005b);
-                MP_WritePhyUshort(sc, 0x19, 0x6c03);
-                MP_WritePhyUshort(sc, 0x15, 0x005c);
-                MP_WritePhyUshort(sc, 0x19, 0x7c08);
-                MP_WritePhyUshort(sc, 0x15, 0x005d);
-                MP_WritePhyUshort(sc, 0x19, 0x6000);
-                MP_WritePhyUshort(sc, 0x15, 0x005e);
-                MP_WritePhyUshort(sc, 0x19, 0x59ce);
-                MP_WritePhyUshort(sc, 0x15, 0x005f);
-                MP_WritePhyUshort(sc, 0x19, 0x4400);
-                MP_WritePhyUshort(sc, 0x15, 0x0060);
-                MP_WritePhyUshort(sc, 0x19, 0x7d00);
-                MP_WritePhyUshort(sc, 0x15, 0x0061);
-                MP_WritePhyUshort(sc, 0x19, 0x72b0);
-                MP_WritePhyUshort(sc, 0x15, 0x0062);
-                MP_WritePhyUshort(sc, 0x19, 0x400e);
-                MP_WritePhyUshort(sc, 0x15, 0x0063);
-                MP_WritePhyUshort(sc, 0x19, 0x4440);
-                MP_WritePhyUshort(sc, 0x15, 0x0064);
-                MP_WritePhyUshort(sc, 0x19, 0x9d00);
-                MP_WritePhyUshort(sc, 0x15, 0x0065);
-                MP_WritePhyUshort(sc, 0x19, 0x7f00);
-                MP_WritePhyUshort(sc, 0x15, 0x0066);
-                MP_WritePhyUshort(sc, 0x19, 0x70b0);
-                MP_WritePhyUshort(sc, 0x15, 0x0067);
-                MP_WritePhyUshort(sc, 0x19, 0x7c08);
-                MP_WritePhyUshort(sc, 0x15, 0x0068);
-                MP_WritePhyUshort(sc, 0x19, 0x6008);
-                MP_WritePhyUshort(sc, 0x15, 0x0069);
-                MP_WritePhyUshort(sc, 0x19, 0x7cf0);
-                MP_WritePhyUshort(sc, 0x15, 0x006a);
-                MP_WritePhyUshort(sc, 0x19, 0x7750);
-                MP_WritePhyUshort(sc, 0x15, 0x006b);
-                MP_WritePhyUshort(sc, 0x19, 0x4007);
-                MP_WritePhyUshort(sc, 0x15, 0x006c);
-                MP_WritePhyUshort(sc, 0x19, 0x4500);
-                MP_WritePhyUshort(sc, 0x15, 0x006d);
-                MP_WritePhyUshort(sc, 0x19, 0x4023);
-                MP_WritePhyUshort(sc, 0x15, 0x006e);
-                MP_WritePhyUshort(sc, 0x19, 0x4580);
-                MP_WritePhyUshort(sc, 0x15, 0x006f);
-                MP_WritePhyUshort(sc, 0x19, 0x9f00);
-                MP_WritePhyUshort(sc, 0x15, 0x0070);
-                MP_WritePhyUshort(sc, 0x19, 0xcd78);
-                MP_WritePhyUshort(sc, 0x15, 0x0071);
-                MP_WritePhyUshort(sc, 0x19, 0x0003);
-                MP_WritePhyUshort(sc, 0x15, 0x0072);
-                MP_WritePhyUshort(sc, 0x19, 0xbe02);
-                MP_WritePhyUshort(sc, 0x15, 0x0073);
-                MP_WritePhyUshort(sc, 0x19, 0x3070);
-                MP_WritePhyUshort(sc, 0x15, 0x0074);
-                MP_WritePhyUshort(sc, 0x19, 0x7cf0);
-                MP_WritePhyUshort(sc, 0x15, 0x0075);
-                MP_WritePhyUshort(sc, 0x19, 0x77f0);
-                MP_WritePhyUshort(sc, 0x15, 0x0076);
-                MP_WritePhyUshort(sc, 0x19, 0x4400);
-                MP_WritePhyUshort(sc, 0x15, 0x0077);
-                MP_WritePhyUshort(sc, 0x19, 0x4007);
-                MP_WritePhyUshort(sc, 0x15, 0x0078);
-                MP_WritePhyUshort(sc, 0x19, 0x4500);
-                MP_WritePhyUshort(sc, 0x15, 0x0079);
-                MP_WritePhyUshort(sc, 0x19, 0x4023);
-                MP_WritePhyUshort(sc, 0x15, 0x007a);
-                MP_WritePhyUshort(sc, 0x19, 0x4580);
-                MP_WritePhyUshort(sc, 0x15, 0x007b);
-                MP_WritePhyUshort(sc, 0x19, 0x9f00);
-                MP_WritePhyUshort(sc, 0x15, 0x007c);
-                MP_WritePhyUshort(sc, 0x19, 0xce80);
-                MP_WritePhyUshort(sc, 0x15, 0x007d);
-                MP_WritePhyUshort(sc, 0x19, 0x0004);
-                MP_WritePhyUshort(sc, 0x15, 0x007e);
-                MP_WritePhyUshort(sc, 0x19, 0xce80);
-                MP_WritePhyUshort(sc, 0x15, 0x007f);
-                MP_WritePhyUshort(sc, 0x19, 0x0002);
-                MP_WritePhyUshort(sc, 0x15, 0x0080);
-                MP_WritePhyUshort(sc, 0x19, 0x307c);
-                MP_WritePhyUshort(sc, 0x15, 0x0081);
-                MP_WritePhyUshort(sc, 0x19, 0x4400);
-                MP_WritePhyUshort(sc, 0x15, 0x0082);
-                MP_WritePhyUshort(sc, 0x19, 0x480f);
-                MP_WritePhyUshort(sc, 0x15, 0x0083);
-                MP_WritePhyUshort(sc, 0x19, 0x6802);
-                MP_WritePhyUshort(sc, 0x15, 0x0084);
-                MP_WritePhyUshort(sc, 0x19, 0x6680);
-                MP_WritePhyUshort(sc, 0x15, 0x0085);
-                MP_WritePhyUshort(sc, 0x19, 0x7c10);
-                MP_WritePhyUshort(sc, 0x15, 0x0086);
-                MP_WritePhyUshort(sc, 0x19, 0x6010);
-                MP_WritePhyUshort(sc, 0x15, 0x0087);
-                MP_WritePhyUshort(sc, 0x19, 0x400a);
-                MP_WritePhyUshort(sc, 0x15, 0x0088);
-                MP_WritePhyUshort(sc, 0x19, 0x4580);
-                MP_WritePhyUshort(sc, 0x15, 0x0089);
-                MP_WritePhyUshort(sc, 0x19, 0x9e00);
-                MP_WritePhyUshort(sc, 0x15, 0x008a);
-                MP_WritePhyUshort(sc, 0x19, 0x7d00);
-                MP_WritePhyUshort(sc, 0x15, 0x008b);
-                MP_WritePhyUshort(sc, 0x19, 0x5800);
-                MP_WritePhyUshort(sc, 0x15, 0x008c);
-                MP_WritePhyUshort(sc, 0x19, 0x63c8);
-                MP_WritePhyUshort(sc, 0x15, 0x008d);
-                MP_WritePhyUshort(sc, 0x19, 0x63d8);
-                MP_WritePhyUshort(sc, 0x15, 0x008e);
-                MP_WritePhyUshort(sc, 0x19, 0x66a0);
-                MP_WritePhyUshort(sc, 0x15, 0x008f);
-                MP_WritePhyUshort(sc, 0x19, 0x8300);
-                MP_WritePhyUshort(sc, 0x15, 0x0090);
-                MP_WritePhyUshort(sc, 0x19, 0x7ff0);
-                MP_WritePhyUshort(sc, 0x15, 0x0091);
-                MP_WritePhyUshort(sc, 0x19, 0x74f0);
-                MP_WritePhyUshort(sc, 0x15, 0x0092);
-                MP_WritePhyUshort(sc, 0x19, 0x3006);
-                MP_WritePhyUshort(sc, 0x15, 0x0093);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x0094);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x0095);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x0096);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x0097);
-                MP_WritePhyUshort(sc, 0x19, 0x4803);
-                MP_WritePhyUshort(sc, 0x15, 0x0098);
-                MP_WritePhyUshort(sc, 0x19, 0x7c03);
-                MP_WritePhyUshort(sc, 0x15, 0x0099);
-                MP_WritePhyUshort(sc, 0x19, 0x6c03);
-                MP_WritePhyUshort(sc, 0x15, 0x009a);
-                MP_WritePhyUshort(sc, 0x19, 0xa203);
-                MP_WritePhyUshort(sc, 0x15, 0x009b);
-                MP_WritePhyUshort(sc, 0x19, 0x64b1);
-                MP_WritePhyUshort(sc, 0x15, 0x009c);
-                MP_WritePhyUshort(sc, 0x19, 0x309e);
-                MP_WritePhyUshort(sc, 0x15, 0x009d);
-                MP_WritePhyUshort(sc, 0x19, 0x64b3);
-                MP_WritePhyUshort(sc, 0x15, 0x009e);
-                MP_WritePhyUshort(sc, 0x19, 0x4030);
-                MP_WritePhyUshort(sc, 0x15, 0x009f);
-                MP_WritePhyUshort(sc, 0x19, 0x440e);
-                MP_WritePhyUshort(sc, 0x15, 0x00a0);
-                MP_WritePhyUshort(sc, 0x19, 0x4020);
-                MP_WritePhyUshort(sc, 0x15, 0x00a1);
-                MP_WritePhyUshort(sc, 0x19, 0x4419);
-                MP_WritePhyUshort(sc, 0x15, 0x00a2);
-                MP_WritePhyUshort(sc, 0x19, 0x7801);
-                MP_WritePhyUshort(sc, 0x15, 0x00a3);
-                MP_WritePhyUshort(sc, 0x19, 0xc520);
-                MP_WritePhyUshort(sc, 0x15, 0x00a4);
-                MP_WritePhyUshort(sc, 0x19, 0x000b);
-                MP_WritePhyUshort(sc, 0x15, 0x00a5);
-                MP_WritePhyUshort(sc, 0x19, 0x4020);
-                MP_WritePhyUshort(sc, 0x15, 0x00a6);
-                MP_WritePhyUshort(sc, 0x19, 0x7800);
-                MP_WritePhyUshort(sc, 0x15, 0x00a7);
-                MP_WritePhyUshort(sc, 0x19, 0x58a4);
-                MP_WritePhyUshort(sc, 0x15, 0x00a8);
-                MP_WritePhyUshort(sc, 0x19, 0x63da);
-                MP_WritePhyUshort(sc, 0x15, 0x00a9);
-                MP_WritePhyUshort(sc, 0x19, 0x5cb0);
-                MP_WritePhyUshort(sc, 0x15, 0x00aa);
-                MP_WritePhyUshort(sc, 0x19, 0x7d00);
-                MP_WritePhyUshort(sc, 0x15, 0x00ab);
-                MP_WritePhyUshort(sc, 0x19, 0x72b0);
-                MP_WritePhyUshort(sc, 0x15, 0x00ac);
-                MP_WritePhyUshort(sc, 0x19, 0x7f00);
-                MP_WritePhyUshort(sc, 0x15, 0x00ad);
-                MP_WritePhyUshort(sc, 0x19, 0x70b0);
-                MP_WritePhyUshort(sc, 0x15, 0x00ae);
-                MP_WritePhyUshort(sc, 0x19, 0x30b8);
-                MP_WritePhyUshort(sc, 0x15, 0x00AF);
-                MP_WritePhyUshort(sc, 0x19, 0x4060);
-                MP_WritePhyUshort(sc, 0x15, 0x00B0);
-                MP_WritePhyUshort(sc, 0x19, 0x7800);
-                MP_WritePhyUshort(sc, 0x15, 0x00B1);
-                MP_WritePhyUshort(sc, 0x19, 0x7e00);
-                MP_WritePhyUshort(sc, 0x15, 0x00B2);
-                MP_WritePhyUshort(sc, 0x19, 0x72B0);
-                MP_WritePhyUshort(sc, 0x15, 0x00B3);
-                MP_WritePhyUshort(sc, 0x19, 0x7F00);
-                MP_WritePhyUshort(sc, 0x15, 0x00B4);
-                MP_WritePhyUshort(sc, 0x19, 0x73B0);
-                MP_WritePhyUshort(sc, 0x15, 0x00b5);
-                MP_WritePhyUshort(sc, 0x19, 0x58a0);
-                MP_WritePhyUshort(sc, 0x15, 0x00b6);
-                MP_WritePhyUshort(sc, 0x19, 0x63d2);
-                MP_WritePhyUshort(sc, 0x15, 0x00b7);
-                MP_WritePhyUshort(sc, 0x19, 0x5c00);
-                MP_WritePhyUshort(sc, 0x15, 0x00b8);
-                MP_WritePhyUshort(sc, 0x19, 0x5780);
-                MP_WritePhyUshort(sc, 0x15, 0x00b9);
-                MP_WritePhyUshort(sc, 0x19, 0xb60d);
-                MP_WritePhyUshort(sc, 0x15, 0x00ba);
-                MP_WritePhyUshort(sc, 0x19, 0x9bff);
-                MP_WritePhyUshort(sc, 0x15, 0x00bb);
-                MP_WritePhyUshort(sc, 0x19, 0x7c03);
-                MP_WritePhyUshort(sc, 0x15, 0x00bc);
-                MP_WritePhyUshort(sc, 0x19, 0x6001);
-                MP_WritePhyUshort(sc, 0x15, 0x00bd);
-                MP_WritePhyUshort(sc, 0x19, 0xc020);
-                MP_WritePhyUshort(sc, 0x15, 0x00be);
-                MP_WritePhyUshort(sc, 0x19, 0x002b);
-                MP_WritePhyUshort(sc, 0x15, 0x00bf);
-                MP_WritePhyUshort(sc, 0x19, 0xc137);
-                MP_WritePhyUshort(sc, 0x15, 0x00c0);
-                MP_WritePhyUshort(sc, 0x19, 0x0006);
-                MP_WritePhyUshort(sc, 0x15, 0x00c1);
-                MP_WritePhyUshort(sc, 0x19, 0x9af8);
-                MP_WritePhyUshort(sc, 0x15, 0x00c2);
-                MP_WritePhyUshort(sc, 0x19, 0x30c6);
-                MP_WritePhyUshort(sc, 0x15, 0x00c3);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x00c4);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x00c5);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x00c6);
-                MP_WritePhyUshort(sc, 0x19, 0x7d00);
-                MP_WritePhyUshort(sc, 0x15, 0x00c7);
-                MP_WritePhyUshort(sc, 0x19, 0x70b0);
-                MP_WritePhyUshort(sc, 0x15, 0x00c8);
-                MP_WritePhyUshort(sc, 0x19, 0x4400);
-                MP_WritePhyUshort(sc, 0x15, 0x00c9);
-                MP_WritePhyUshort(sc, 0x19, 0x4804);
-                MP_WritePhyUshort(sc, 0x15, 0x00ca);
-                MP_WritePhyUshort(sc, 0x19, 0x7c80);
-                MP_WritePhyUshort(sc, 0x15, 0x00cb);
-                MP_WritePhyUshort(sc, 0x19, 0x5c80);
-                MP_WritePhyUshort(sc, 0x15, 0x00cc);
-                MP_WritePhyUshort(sc, 0x19, 0x4010);
-                MP_WritePhyUshort(sc, 0x15, 0x00cd);
-                MP_WritePhyUshort(sc, 0x19, 0x4415);
-                MP_WritePhyUshort(sc, 0x15, 0x00ce);
-                MP_WritePhyUshort(sc, 0x19, 0x9b00);
-                MP_WritePhyUshort(sc, 0x15, 0x00cf);
-                MP_WritePhyUshort(sc, 0x19, 0x7f00);
-                MP_WritePhyUshort(sc, 0x15, 0x00d0);
-                MP_WritePhyUshort(sc, 0x19, 0x70b0);
-                MP_WritePhyUshort(sc, 0x15, 0x00d1);
-                MP_WritePhyUshort(sc, 0x19, 0x3177);
-                MP_WritePhyUshort(sc, 0x15, 0x00d2);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x00d3);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x00d4);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x00d5);
-                MP_WritePhyUshort(sc, 0x19, 0x4808);
-                MP_WritePhyUshort(sc, 0x15, 0x00d6);
-                MP_WritePhyUshort(sc, 0x19, 0x4007);
-                MP_WritePhyUshort(sc, 0x15, 0x00d7);
-                MP_WritePhyUshort(sc, 0x19, 0x4420);
-                MP_WritePhyUshort(sc, 0x15, 0x00d8);
-                MP_WritePhyUshort(sc, 0x19, 0x63d8);
-                MP_WritePhyUshort(sc, 0x15, 0x00d9);
-                MP_WritePhyUshort(sc, 0x19, 0xb608);
-                MP_WritePhyUshort(sc, 0x15, 0x00da);
-                MP_WritePhyUshort(sc, 0x19, 0xbcbd);
-                MP_WritePhyUshort(sc, 0x15, 0x00db);
-                MP_WritePhyUshort(sc, 0x19, 0xc60b);
-                MP_WritePhyUshort(sc, 0x15, 0x00dc);
-                MP_WritePhyUshort(sc, 0x19, 0x00fd);
-                MP_WritePhyUshort(sc, 0x15, 0x00dd);
-                MP_WritePhyUshort(sc, 0x19, 0x30e1);
-                MP_WritePhyUshort(sc, 0x15, 0x00de);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x00df);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x00e0);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x00e1);
-                MP_WritePhyUshort(sc, 0x19, 0x4809);
-                MP_WritePhyUshort(sc, 0x15, 0x00e2);
-                MP_WritePhyUshort(sc, 0x19, 0x7e40);
-                MP_WritePhyUshort(sc, 0x15, 0x00e3);
-                MP_WritePhyUshort(sc, 0x19, 0x5a40);
-                MP_WritePhyUshort(sc, 0x15, 0x00e4);
-                MP_WritePhyUshort(sc, 0x19, 0x305a);
-                MP_WritePhyUshort(sc, 0x15, 0x00e5);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x00e6);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x00e7);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x00e8);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x00e9);
-                MP_WritePhyUshort(sc, 0x19, 0x480a);
-                MP_WritePhyUshort(sc, 0x15, 0x00ea);
-                MP_WritePhyUshort(sc, 0x19, 0x5820);
-                MP_WritePhyUshort(sc, 0x15, 0x00eb);
-                MP_WritePhyUshort(sc, 0x19, 0x6c03);
-                MP_WritePhyUshort(sc, 0x15, 0x00ec);
-                MP_WritePhyUshort(sc, 0x19, 0xb60a);
-                MP_WritePhyUshort(sc, 0x15, 0x00ed);
-                MP_WritePhyUshort(sc, 0x19, 0xda07);
-                MP_WritePhyUshort(sc, 0x15, 0x00ee);
-                MP_WritePhyUshort(sc, 0x19, 0x0008);
-                MP_WritePhyUshort(sc, 0x15, 0x00ef);
-                MP_WritePhyUshort(sc, 0x19, 0xc60b);
-                MP_WritePhyUshort(sc, 0x15, 0x00f0);
-                MP_WritePhyUshort(sc, 0x19, 0x00fc);
-                MP_WritePhyUshort(sc, 0x15, 0x00f1);
-                MP_WritePhyUshort(sc, 0x19, 0x30f6);
-                MP_WritePhyUshort(sc, 0x15, 0x00f2);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x00f3);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x00f4);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x00f5);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x00f6);
-                MP_WritePhyUshort(sc, 0x19, 0x4408);
-                MP_WritePhyUshort(sc, 0x15, 0x00f7);
-                MP_WritePhyUshort(sc, 0x19, 0x480b);
-                MP_WritePhyUshort(sc, 0x15, 0x00f8);
-                MP_WritePhyUshort(sc, 0x19, 0x6f03);
-                MP_WritePhyUshort(sc, 0x15, 0x00f9);
-                MP_WritePhyUshort(sc, 0x19, 0x405f);
-                MP_WritePhyUshort(sc, 0x15, 0x00fa);
-                MP_WritePhyUshort(sc, 0x19, 0x4448);
-                MP_WritePhyUshort(sc, 0x15, 0x00fb);
-                MP_WritePhyUshort(sc, 0x19, 0x4020);
-                MP_WritePhyUshort(sc, 0x15, 0x00fc);
-                MP_WritePhyUshort(sc, 0x19, 0x4468);
-                MP_WritePhyUshort(sc, 0x15, 0x00fd);
-                MP_WritePhyUshort(sc, 0x19, 0x9c03);
-                MP_WritePhyUshort(sc, 0x15, 0x00fe);
-                MP_WritePhyUshort(sc, 0x19, 0x6f07);
-                MP_WritePhyUshort(sc, 0x15, 0x00ff);
-                MP_WritePhyUshort(sc, 0x19, 0x58a0);
-                MP_WritePhyUshort(sc, 0x15, 0x0100);
-                MP_WritePhyUshort(sc, 0x19, 0xd6d1);
-                MP_WritePhyUshort(sc, 0x15, 0x0101);
-                MP_WritePhyUshort(sc, 0x19, 0x0004);
-                MP_WritePhyUshort(sc, 0x15, 0x0102);
-                MP_WritePhyUshort(sc, 0x19, 0xc137);
-                MP_WritePhyUshort(sc, 0x15, 0x0103);
-                MP_WritePhyUshort(sc, 0x19, 0x0002);
-                MP_WritePhyUshort(sc, 0x15, 0x0104);
-                MP_WritePhyUshort(sc, 0x19, 0xa0e5);
-                MP_WritePhyUshort(sc, 0x15, 0x0105);
-                MP_WritePhyUshort(sc, 0x19, 0x9df8);
-                MP_WritePhyUshort(sc, 0x15, 0x0106);
-                MP_WritePhyUshort(sc, 0x19, 0x30c6);
-                MP_WritePhyUshort(sc, 0x15, 0x0107);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x0108);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x0109);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x010a);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x010b);
-                MP_WritePhyUshort(sc, 0x19, 0x4808);
-                MP_WritePhyUshort(sc, 0x15, 0x010c);
-                MP_WritePhyUshort(sc, 0x19, 0xc32d);
-                MP_WritePhyUshort(sc, 0x15, 0x010d);
-                MP_WritePhyUshort(sc, 0x19, 0x0003);
-                MP_WritePhyUshort(sc, 0x15, 0x010e);
-                MP_WritePhyUshort(sc, 0x19, 0xc8b3);
-                MP_WritePhyUshort(sc, 0x15, 0x010f);
-                MP_WritePhyUshort(sc, 0x19, 0x00fc);
-                MP_WritePhyUshort(sc, 0x15, 0x0110);
-                MP_WritePhyUshort(sc, 0x19, 0x4400);
-                MP_WritePhyUshort(sc, 0x15, 0x0111);
-                MP_WritePhyUshort(sc, 0x19, 0x3116);
-                MP_WritePhyUshort(sc, 0x15, 0x0112);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x0113);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x0114);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x0115);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x0116);
-                MP_WritePhyUshort(sc, 0x19, 0x4803);
-                MP_WritePhyUshort(sc, 0x15, 0x0117);
-                MP_WritePhyUshort(sc, 0x19, 0x7c03);
-                MP_WritePhyUshort(sc, 0x15, 0x0118);
-                MP_WritePhyUshort(sc, 0x19, 0x6c02);
-                MP_WritePhyUshort(sc, 0x15, 0x0119);
-                MP_WritePhyUshort(sc, 0x19, 0x7c04);
-                MP_WritePhyUshort(sc, 0x15, 0x011a);
-                MP_WritePhyUshort(sc, 0x19, 0x6000);
-                MP_WritePhyUshort(sc, 0x15, 0x011b);
-                MP_WritePhyUshort(sc, 0x19, 0x5cf7);
-                MP_WritePhyUshort(sc, 0x15, 0x011c);
-                MP_WritePhyUshort(sc, 0x19, 0x7c2a);
-                MP_WritePhyUshort(sc, 0x15, 0x011d);
-                MP_WritePhyUshort(sc, 0x19, 0x5800);
-                MP_WritePhyUshort(sc, 0x15, 0x011e);
-                MP_WritePhyUshort(sc, 0x19, 0x5400);
-                MP_WritePhyUshort(sc, 0x15, 0x011f);
-                MP_WritePhyUshort(sc, 0x19, 0x7c08);
-                MP_WritePhyUshort(sc, 0x15, 0x0120);
-                MP_WritePhyUshort(sc, 0x19, 0x74f0);
-                MP_WritePhyUshort(sc, 0x15, 0x0121);
-                MP_WritePhyUshort(sc, 0x19, 0x4019);
-                MP_WritePhyUshort(sc, 0x15, 0x0122);
-                MP_WritePhyUshort(sc, 0x19, 0x440d);
-                MP_WritePhyUshort(sc, 0x15, 0x0123);
-                MP_WritePhyUshort(sc, 0x19, 0xb6c1);
-                MP_WritePhyUshort(sc, 0x15, 0x0124);
-                MP_WritePhyUshort(sc, 0x19, 0xc05b);
-                MP_WritePhyUshort(sc, 0x15, 0x0125);
-                MP_WritePhyUshort(sc, 0x19, 0x00bf);
-                MP_WritePhyUshort(sc, 0x15, 0x0126);
-                MP_WritePhyUshort(sc, 0x19, 0xc025);
-                MP_WritePhyUshort(sc, 0x15, 0x0127);
-                MP_WritePhyUshort(sc, 0x19, 0x00bd);
-                MP_WritePhyUshort(sc, 0x15, 0x0128);
-                MP_WritePhyUshort(sc, 0x19, 0xc603);
-                MP_WritePhyUshort(sc, 0x15, 0x0129);
-                MP_WritePhyUshort(sc, 0x19, 0x00bb);
-                MP_WritePhyUshort(sc, 0x15, 0x012a);
-                MP_WritePhyUshort(sc, 0x19, 0x8805);
-                MP_WritePhyUshort(sc, 0x15, 0x012b);
-                MP_WritePhyUshort(sc, 0x19, 0x7801);
-                MP_WritePhyUshort(sc, 0x15, 0x012c);
-                MP_WritePhyUshort(sc, 0x19, 0x4001);
-                MP_WritePhyUshort(sc, 0x15, 0x012d);
-                MP_WritePhyUshort(sc, 0x19, 0x7800);
-                MP_WritePhyUshort(sc, 0x15, 0x012e);
-                MP_WritePhyUshort(sc, 0x19, 0xa3dd);
-                MP_WritePhyUshort(sc, 0x15, 0x012f);
-                MP_WritePhyUshort(sc, 0x19, 0x7c03);
-                MP_WritePhyUshort(sc, 0x15, 0x0130);
-                MP_WritePhyUshort(sc, 0x19, 0x6c03);
-                MP_WritePhyUshort(sc, 0x15, 0x0131);
-                MP_WritePhyUshort(sc, 0x19, 0x8407);
-                MP_WritePhyUshort(sc, 0x15, 0x0132);
-                MP_WritePhyUshort(sc, 0x19, 0x7c03);
-                MP_WritePhyUshort(sc, 0x15, 0x0133);
-                MP_WritePhyUshort(sc, 0x19, 0x6c02);
-                MP_WritePhyUshort(sc, 0x15, 0x0134);
-                MP_WritePhyUshort(sc, 0x19, 0xd9b8);
-                MP_WritePhyUshort(sc, 0x15, 0x0135);
-                MP_WritePhyUshort(sc, 0x19, 0x0003);
-                MP_WritePhyUshort(sc, 0x15, 0x0136);
-                MP_WritePhyUshort(sc, 0x19, 0xc240);
-                MP_WritePhyUshort(sc, 0x15, 0x0137);
-                MP_WritePhyUshort(sc, 0x19, 0x0015);
-                MP_WritePhyUshort(sc, 0x15, 0x0138);
-                MP_WritePhyUshort(sc, 0x19, 0x7c03);
-                MP_WritePhyUshort(sc, 0x15, 0x0139);
-                MP_WritePhyUshort(sc, 0x19, 0x6c02);
-                MP_WritePhyUshort(sc, 0x15, 0x013a);
-                MP_WritePhyUshort(sc, 0x19, 0x9ae9);
-                MP_WritePhyUshort(sc, 0x15, 0x013b);
-                MP_WritePhyUshort(sc, 0x19, 0x3140);
-                MP_WritePhyUshort(sc, 0x15, 0x013c);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x013d);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x013e);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x013f);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x0140);
-                MP_WritePhyUshort(sc, 0x19, 0x4807);
-                MP_WritePhyUshort(sc, 0x15, 0x0141);
-                MP_WritePhyUshort(sc, 0x19, 0x4004);
-                MP_WritePhyUshort(sc, 0x15, 0x0142);
-                MP_WritePhyUshort(sc, 0x19, 0x4410);
-                MP_WritePhyUshort(sc, 0x15, 0x0143);
-                MP_WritePhyUshort(sc, 0x19, 0x7c0c);
-                MP_WritePhyUshort(sc, 0x15, 0x0144);
-                MP_WritePhyUshort(sc, 0x19, 0x600c);
-                MP_WritePhyUshort(sc, 0x15, 0x0145);
-                MP_WritePhyUshort(sc, 0x19, 0x9b00);
-                MP_WritePhyUshort(sc, 0x15, 0x0146);
-                MP_WritePhyUshort(sc, 0x19, 0xa68f);
-                MP_WritePhyUshort(sc, 0x15, 0x0147);
-                MP_WritePhyUshort(sc, 0x19, 0x3116);
-                MP_WritePhyUshort(sc, 0x15, 0x0148);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x0149);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x014a);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x014b);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x014c);
-                MP_WritePhyUshort(sc, 0x19, 0x4804);
-                MP_WritePhyUshort(sc, 0x15, 0x014d);
-                MP_WritePhyUshort(sc, 0x19, 0x54c0);
-                MP_WritePhyUshort(sc, 0x15, 0x014e);
-                MP_WritePhyUshort(sc, 0x19, 0xb703);
-                MP_WritePhyUshort(sc, 0x15, 0x014f);
-                MP_WritePhyUshort(sc, 0x19, 0x5cff);
-                MP_WritePhyUshort(sc, 0x15, 0x0150);
-                MP_WritePhyUshort(sc, 0x19, 0x315f);
-                MP_WritePhyUshort(sc, 0x15, 0x0151);
-                MP_WritePhyUshort(sc, 0x19, 0x7c08);
-                MP_WritePhyUshort(sc, 0x15, 0x0152);
-                MP_WritePhyUshort(sc, 0x19, 0x74f8);
-                MP_WritePhyUshort(sc, 0x15, 0x0153);
-                MP_WritePhyUshort(sc, 0x19, 0x6421);
-                MP_WritePhyUshort(sc, 0x15, 0x0154);
-                MP_WritePhyUshort(sc, 0x19, 0x7c08);
-                MP_WritePhyUshort(sc, 0x15, 0x0155);
-                MP_WritePhyUshort(sc, 0x19, 0x6000);
-                MP_WritePhyUshort(sc, 0x15, 0x0156);
-                MP_WritePhyUshort(sc, 0x19, 0x4003);
-                MP_WritePhyUshort(sc, 0x15, 0x0157);
-                MP_WritePhyUshort(sc, 0x19, 0x4418);
-                MP_WritePhyUshort(sc, 0x15, 0x0158);
-                MP_WritePhyUshort(sc, 0x19, 0x9b00);
-                MP_WritePhyUshort(sc, 0x15, 0x0159);
-                MP_WritePhyUshort(sc, 0x19, 0x6461);
-                MP_WritePhyUshort(sc, 0x15, 0x015a);
-                MP_WritePhyUshort(sc, 0x19, 0x64e1);
-                MP_WritePhyUshort(sc, 0x15, 0x015b);
-                MP_WritePhyUshort(sc, 0x19, 0x7c20);
-                MP_WritePhyUshort(sc, 0x15, 0x015c);
-                MP_WritePhyUshort(sc, 0x19, 0x5820);
-                MP_WritePhyUshort(sc, 0x15, 0x015d);
-                MP_WritePhyUshort(sc, 0x19, 0x5ccf);
-                MP_WritePhyUshort(sc, 0x15, 0x015e);
-                MP_WritePhyUshort(sc, 0x19, 0x7050);
-                MP_WritePhyUshort(sc, 0x15, 0x015f);
-                MP_WritePhyUshort(sc, 0x19, 0xd9b8);
-                MP_WritePhyUshort(sc, 0x15, 0x0160);
-                MP_WritePhyUshort(sc, 0x19, 0x0008);
-                MP_WritePhyUshort(sc, 0x15, 0x0161);
-                MP_WritePhyUshort(sc, 0x19, 0xdab1);
-                MP_WritePhyUshort(sc, 0x15, 0x0162);
-                MP_WritePhyUshort(sc, 0x19, 0x0015);
-                MP_WritePhyUshort(sc, 0x15, 0x0163);
-                MP_WritePhyUshort(sc, 0x19, 0xc244);
-                MP_WritePhyUshort(sc, 0x15, 0x0164);
-                MP_WritePhyUshort(sc, 0x19, 0x0013);
-                MP_WritePhyUshort(sc, 0x15, 0x0165);
-                MP_WritePhyUshort(sc, 0x19, 0xc021);
-                MP_WritePhyUshort(sc, 0x15, 0x0166);
-                MP_WritePhyUshort(sc, 0x19, 0x00f9);
-                MP_WritePhyUshort(sc, 0x15, 0x0167);
-                MP_WritePhyUshort(sc, 0x19, 0x3177);
-                MP_WritePhyUshort(sc, 0x15, 0x0168);
-                MP_WritePhyUshort(sc, 0x19, 0x5cf7);
-                MP_WritePhyUshort(sc, 0x15, 0x0169);
-                MP_WritePhyUshort(sc, 0x19, 0x4010);
-                MP_WritePhyUshort(sc, 0x15, 0x016a);
-                MP_WritePhyUshort(sc, 0x19, 0x4428);
-                MP_WritePhyUshort(sc, 0x15, 0x016b);
-                MP_WritePhyUshort(sc, 0x19, 0x9c00);
-                MP_WritePhyUshort(sc, 0x15, 0x016c);
-                MP_WritePhyUshort(sc, 0x19, 0x7c08);
-                MP_WritePhyUshort(sc, 0x15, 0x016d);
-                MP_WritePhyUshort(sc, 0x19, 0x6008);
-                MP_WritePhyUshort(sc, 0x15, 0x016e);
-                MP_WritePhyUshort(sc, 0x19, 0x7c08);
-                MP_WritePhyUshort(sc, 0x15, 0x016f);
-                MP_WritePhyUshort(sc, 0x19, 0x74f0);
-                MP_WritePhyUshort(sc, 0x15, 0x0170);
-                MP_WritePhyUshort(sc, 0x19, 0x6461);
-                MP_WritePhyUshort(sc, 0x15, 0x0171);
-                MP_WritePhyUshort(sc, 0x19, 0x6421);
-                MP_WritePhyUshort(sc, 0x15, 0x0172);
-                MP_WritePhyUshort(sc, 0x19, 0x64a1);
-                MP_WritePhyUshort(sc, 0x15, 0x0173);
-                MP_WritePhyUshort(sc, 0x19, 0x3116);
-                MP_WritePhyUshort(sc, 0x15, 0x0174);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x0175);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x0176);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x0177);
-                MP_WritePhyUshort(sc, 0x19, 0x4805);
-                MP_WritePhyUshort(sc, 0x15, 0x0178);
-                MP_WritePhyUshort(sc, 0x19, 0xa103);
-                MP_WritePhyUshort(sc, 0x15, 0x0179);
-                MP_WritePhyUshort(sc, 0x19, 0x7c02);
-                MP_WritePhyUshort(sc, 0x15, 0x017a);
-                MP_WritePhyUshort(sc, 0x19, 0x6002);
-                MP_WritePhyUshort(sc, 0x15, 0x017b);
-                MP_WritePhyUshort(sc, 0x19, 0x7e00);
-                MP_WritePhyUshort(sc, 0x15, 0x017c);
-                MP_WritePhyUshort(sc, 0x19, 0x5400);
-                MP_WritePhyUshort(sc, 0x15, 0x017d);
-                MP_WritePhyUshort(sc, 0x19, 0x7c6b);
-                MP_WritePhyUshort(sc, 0x15, 0x017e);
-                MP_WritePhyUshort(sc, 0x19, 0x5c63);
-                MP_WritePhyUshort(sc, 0x15, 0x017f);
-                MP_WritePhyUshort(sc, 0x19, 0x407d);
-                MP_WritePhyUshort(sc, 0x15, 0x0180);
-                MP_WritePhyUshort(sc, 0x19, 0xa602);
-                MP_WritePhyUshort(sc, 0x15, 0x0181);
-                MP_WritePhyUshort(sc, 0x19, 0x4001);
-                MP_WritePhyUshort(sc, 0x15, 0x0182);
-                MP_WritePhyUshort(sc, 0x19, 0x4420);
-                MP_WritePhyUshort(sc, 0x15, 0x0183);
-                MP_WritePhyUshort(sc, 0x19, 0x4020);
-                MP_WritePhyUshort(sc, 0x15, 0x0184);
-                MP_WritePhyUshort(sc, 0x19, 0x44a1);
-                MP_WritePhyUshort(sc, 0x15, 0x0185);
-                MP_WritePhyUshort(sc, 0x19, 0xd6e0);
-                MP_WritePhyUshort(sc, 0x15, 0x0186);
-                MP_WritePhyUshort(sc, 0x19, 0x0009);
-                MP_WritePhyUshort(sc, 0x15, 0x0187);
-                MP_WritePhyUshort(sc, 0x19, 0x9efe);
-                MP_WritePhyUshort(sc, 0x15, 0x0188);
-                MP_WritePhyUshort(sc, 0x19, 0x7c02);
-                MP_WritePhyUshort(sc, 0x15, 0x0189);
-                MP_WritePhyUshort(sc, 0x19, 0x6000);
-                MP_WritePhyUshort(sc, 0x15, 0x018a);
-                MP_WritePhyUshort(sc, 0x19, 0x9c00);
-                MP_WritePhyUshort(sc, 0x15, 0x018b);
-                MP_WritePhyUshort(sc, 0x19, 0x318f);
-                MP_WritePhyUshort(sc, 0x15, 0x018c);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x018d);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x018e);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x018f);
-                MP_WritePhyUshort(sc, 0x19, 0x4806);
-                MP_WritePhyUshort(sc, 0x15, 0x0190);
-                MP_WritePhyUshort(sc, 0x19, 0x7c10);
-                MP_WritePhyUshort(sc, 0x15, 0x0191);
-                MP_WritePhyUshort(sc, 0x19, 0x5c10);
-                MP_WritePhyUshort(sc, 0x15, 0x0192);
-                MP_WritePhyUshort(sc, 0x19, 0x40fa);
-                MP_WritePhyUshort(sc, 0x15, 0x0193);
-                MP_WritePhyUshort(sc, 0x19, 0xa602);
-                MP_WritePhyUshort(sc, 0x15, 0x0194);
-                MP_WritePhyUshort(sc, 0x19, 0x4010);
-                MP_WritePhyUshort(sc, 0x15, 0x0195);
-                MP_WritePhyUshort(sc, 0x19, 0x4440);
-                MP_WritePhyUshort(sc, 0x15, 0x0196);
-                MP_WritePhyUshort(sc, 0x19, 0x9d00);
-                MP_WritePhyUshort(sc, 0x15, 0x0197);
-                MP_WritePhyUshort(sc, 0x19, 0x7c80);
-                MP_WritePhyUshort(sc, 0x15, 0x0198);
-                MP_WritePhyUshort(sc, 0x19, 0x6400);
-                MP_WritePhyUshort(sc, 0x15, 0x0199);
-                MP_WritePhyUshort(sc, 0x19, 0x4003);
-                MP_WritePhyUshort(sc, 0x15, 0x019a);
-                MP_WritePhyUshort(sc, 0x19, 0x4540);
-                MP_WritePhyUshort(sc, 0x15, 0x019b);
-                MP_WritePhyUshort(sc, 0x19, 0x7c08);
-                MP_WritePhyUshort(sc, 0x15, 0x019c);
-                MP_WritePhyUshort(sc, 0x19, 0x6008);
-                MP_WritePhyUshort(sc, 0x15, 0x019d);
-                MP_WritePhyUshort(sc, 0x19, 0x9f00);
-                MP_WritePhyUshort(sc, 0x15, 0x019e);
-                MP_WritePhyUshort(sc, 0x19, 0x7c40);
-                MP_WritePhyUshort(sc, 0x15, 0x019f);
-                MP_WritePhyUshort(sc, 0x19, 0x6400);
-                MP_WritePhyUshort(sc, 0x15, 0x01a0);
-                MP_WritePhyUshort(sc, 0x19, 0x7c80);
-                MP_WritePhyUshort(sc, 0x15, 0x01a1);
-                MP_WritePhyUshort(sc, 0x19, 0x6480);
-                MP_WritePhyUshort(sc, 0x15, 0x01a2);
-                MP_WritePhyUshort(sc, 0x19, 0x3140);
-                MP_WritePhyUshort(sc, 0x15, 0x01a3);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x01a4);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x01a5);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x01a6);
-                MP_WritePhyUshort(sc, 0x19, 0x4400);
-                MP_WritePhyUshort(sc, 0x15, 0x01a7);
-                MP_WritePhyUshort(sc, 0x19, 0x7c0b);
-                MP_WritePhyUshort(sc, 0x15, 0x01a8);
-                MP_WritePhyUshort(sc, 0x19, 0x6c01);
-                MP_WritePhyUshort(sc, 0x15, 0x01a9);
-                MP_WritePhyUshort(sc, 0x19, 0x64a8);
-                MP_WritePhyUshort(sc, 0x15, 0x01aa);
-                MP_WritePhyUshort(sc, 0x19, 0x6800);
-                MP_WritePhyUshort(sc, 0x15, 0x01ab);
-                MP_WritePhyUshort(sc, 0x19, 0x5cf0);
-                MP_WritePhyUshort(sc, 0x15, 0x01ac);
-                MP_WritePhyUshort(sc, 0x19, 0x588f);
-                MP_WritePhyUshort(sc, 0x15, 0x01ad);
-                MP_WritePhyUshort(sc, 0x19, 0xb628);
-                MP_WritePhyUshort(sc, 0x15, 0x01ae);
-                MP_WritePhyUshort(sc, 0x19, 0xc053);
-                MP_WritePhyUshort(sc, 0x15, 0x01af);
-                MP_WritePhyUshort(sc, 0x19, 0x0026);
-                MP_WritePhyUshort(sc, 0x15, 0x01b0);
-                MP_WritePhyUshort(sc, 0x19, 0xc02d);
-                MP_WritePhyUshort(sc, 0x15, 0x01b1);
-                MP_WritePhyUshort(sc, 0x19, 0x0024);
-                MP_WritePhyUshort(sc, 0x15, 0x01b2);
-                MP_WritePhyUshort(sc, 0x19, 0xc603);
-                MP_WritePhyUshort(sc, 0x15, 0x01b3);
-                MP_WritePhyUshort(sc, 0x19, 0x0022);
-                MP_WritePhyUshort(sc, 0x15, 0x01b4);
-                MP_WritePhyUshort(sc, 0x19, 0x8cf9);
-                MP_WritePhyUshort(sc, 0x15, 0x01b5);
-                MP_WritePhyUshort(sc, 0x19, 0x31ba);
-                MP_WritePhyUshort(sc, 0x15, 0x01b6);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x01b7);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x01b8);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x01b9);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x01ba);
-                MP_WritePhyUshort(sc, 0x19, 0x4400);
-                MP_WritePhyUshort(sc, 0x15, 0x01bb);
-                MP_WritePhyUshort(sc, 0x19, 0x5420);
-                MP_WritePhyUshort(sc, 0x15, 0x01bc);
-                MP_WritePhyUshort(sc, 0x19, 0x4811);
-                MP_WritePhyUshort(sc, 0x15, 0x01bd);
-                MP_WritePhyUshort(sc, 0x19, 0x5000);
-                MP_WritePhyUshort(sc, 0x15, 0x01be);
-                MP_WritePhyUshort(sc, 0x19, 0x4801);
-                MP_WritePhyUshort(sc, 0x15, 0x01bf);
-                MP_WritePhyUshort(sc, 0x19, 0x6800);
-                MP_WritePhyUshort(sc, 0x15, 0x01c0);
-                MP_WritePhyUshort(sc, 0x19, 0x31f5);
-                MP_WritePhyUshort(sc, 0x15, 0x01c1);
-                MP_WritePhyUshort(sc, 0x19, 0xb614);
-                MP_WritePhyUshort(sc, 0x15, 0x01c2);
-                MP_WritePhyUshort(sc, 0x19, 0x8ce4);
-                MP_WritePhyUshort(sc, 0x15, 0x01c3);
-                MP_WritePhyUshort(sc, 0x19, 0xb30c);
-                MP_WritePhyUshort(sc, 0x15, 0x01c4);
-                MP_WritePhyUshort(sc, 0x19, 0x7c03);
-                MP_WritePhyUshort(sc, 0x15, 0x01c5);
-                MP_WritePhyUshort(sc, 0x19, 0x6c02);
-                MP_WritePhyUshort(sc, 0x15, 0x01c6);
-                MP_WritePhyUshort(sc, 0x19, 0x8206);
-                MP_WritePhyUshort(sc, 0x15, 0x01c7);
-                MP_WritePhyUshort(sc, 0x19, 0x7c03);
-                MP_WritePhyUshort(sc, 0x15, 0x01c8);
-                MP_WritePhyUshort(sc, 0x19, 0x6c00);
-                MP_WritePhyUshort(sc, 0x15, 0x01c9);
-                MP_WritePhyUshort(sc, 0x19, 0x7c04);
-                MP_WritePhyUshort(sc, 0x15, 0x01ca);
-                MP_WritePhyUshort(sc, 0x19, 0x7404);
-                MP_WritePhyUshort(sc, 0x15, 0x01cb);
-                MP_WritePhyUshort(sc, 0x19, 0x31c0);
-                MP_WritePhyUshort(sc, 0x15, 0x01cc);
-                MP_WritePhyUshort(sc, 0x19, 0x7c04);
-                MP_WritePhyUshort(sc, 0x15, 0x01cd);
-                MP_WritePhyUshort(sc, 0x19, 0x7400);
-                MP_WritePhyUshort(sc, 0x15, 0x01ce);
-                MP_WritePhyUshort(sc, 0x19, 0x31c0);
-                MP_WritePhyUshort(sc, 0x15, 0x01cf);
-                MP_WritePhyUshort(sc, 0x19, 0x8df1);
-                MP_WritePhyUshort(sc, 0x15, 0x01d0);
-                MP_WritePhyUshort(sc, 0x19, 0x3248);
-                MP_WritePhyUshort(sc, 0x15, 0x01d1);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x01d2);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x01d3);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x01d4);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x01d5);
-                MP_WritePhyUshort(sc, 0x19, 0x4400);
-                MP_WritePhyUshort(sc, 0x15, 0x01d6);
-                MP_WritePhyUshort(sc, 0x19, 0x7c03);
-                MP_WritePhyUshort(sc, 0x15, 0x01d7);
-                MP_WritePhyUshort(sc, 0x19, 0x6c03);
-                MP_WritePhyUshort(sc, 0x15, 0x01d8);
-                MP_WritePhyUshort(sc, 0x19, 0x7670);
-                MP_WritePhyUshort(sc, 0x15, 0x01d9);
-                MP_WritePhyUshort(sc, 0x19, 0x4023);
-                MP_WritePhyUshort(sc, 0x15, 0x01da);
-                MP_WritePhyUshort(sc, 0x19, 0x4500);
-                MP_WritePhyUshort(sc, 0x15, 0x01db);
-                MP_WritePhyUshort(sc, 0x19, 0x4069);
-                MP_WritePhyUshort(sc, 0x15, 0x01dc);
-                MP_WritePhyUshort(sc, 0x19, 0x4580);
-                MP_WritePhyUshort(sc, 0x15, 0x01dd);
-                MP_WritePhyUshort(sc, 0x19, 0x9f00);
-                MP_WritePhyUshort(sc, 0x15, 0x01de);
-                MP_WritePhyUshort(sc, 0x19, 0xcff5);
-                MP_WritePhyUshort(sc, 0x15, 0x01df);
-                MP_WritePhyUshort(sc, 0x19, 0x00ff);
-                MP_WritePhyUshort(sc, 0x15, 0x01e0);
-                MP_WritePhyUshort(sc, 0x19, 0x76f0);
-                MP_WritePhyUshort(sc, 0x15, 0x01e1);
-                MP_WritePhyUshort(sc, 0x19, 0x4400);
-                MP_WritePhyUshort(sc, 0x15, 0x01e2);
-                MP_WritePhyUshort(sc, 0x19, 0x4023);
-                MP_WritePhyUshort(sc, 0x15, 0x01e3);
-                MP_WritePhyUshort(sc, 0x19, 0x4500);
-                MP_WritePhyUshort(sc, 0x15, 0x01e4);
-                MP_WritePhyUshort(sc, 0x19, 0x4069);
-                MP_WritePhyUshort(sc, 0x15, 0x01e5);
-                MP_WritePhyUshort(sc, 0x19, 0x4580);
-                MP_WritePhyUshort(sc, 0x15, 0x01e6);
-                MP_WritePhyUshort(sc, 0x19, 0x9f00);
-                MP_WritePhyUshort(sc, 0x15, 0x01e7);
-                MP_WritePhyUshort(sc, 0x19, 0xd0f5);
-                MP_WritePhyUshort(sc, 0x15, 0x01e8);
-                MP_WritePhyUshort(sc, 0x19, 0x00ff);
-                MP_WritePhyUshort(sc, 0x15, 0x01e9);
-                MP_WritePhyUshort(sc, 0x19, 0x4400);
-                MP_WritePhyUshort(sc, 0x15, 0x01ea);
-                MP_WritePhyUshort(sc, 0x19, 0x7c03);
-                MP_WritePhyUshort(sc, 0x15, 0x01eb);
-                MP_WritePhyUshort(sc, 0x19, 0x6800);
-                MP_WritePhyUshort(sc, 0x15, 0x01ec);
-                MP_WritePhyUshort(sc, 0x19, 0x66a0);
-                MP_WritePhyUshort(sc, 0x15, 0x01ed);
-                MP_WritePhyUshort(sc, 0x19, 0x8300);
-                MP_WritePhyUshort(sc, 0x15, 0x01ee);
-                MP_WritePhyUshort(sc, 0x19, 0x74f0);
-                MP_WritePhyUshort(sc, 0x15, 0x01ef);
-                MP_WritePhyUshort(sc, 0x19, 0x3006);
-                MP_WritePhyUshort(sc, 0x15, 0x01f0);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x01f1);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x01f2);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x01f3);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x01f4);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x01f5);
-                MP_WritePhyUshort(sc, 0x19, 0x7c03);
-                MP_WritePhyUshort(sc, 0x15, 0x01f6);
-                MP_WritePhyUshort(sc, 0x19, 0x6c02);
-                MP_WritePhyUshort(sc, 0x15, 0x01f7);
-                MP_WritePhyUshort(sc, 0x19, 0x409d);
-                MP_WritePhyUshort(sc, 0x15, 0x01f8);
-                MP_WritePhyUshort(sc, 0x19, 0x7c87);
-                MP_WritePhyUshort(sc, 0x15, 0x01f9);
-                MP_WritePhyUshort(sc, 0x19, 0xae14);
-                MP_WritePhyUshort(sc, 0x15, 0x01fa);
-                MP_WritePhyUshort(sc, 0x19, 0x4400);
-                MP_WritePhyUshort(sc, 0x15, 0x01fb);
-                MP_WritePhyUshort(sc, 0x19, 0x7c40);
-                MP_WritePhyUshort(sc, 0x15, 0x01fc);
-                MP_WritePhyUshort(sc, 0x19, 0x6800);
-                MP_WritePhyUshort(sc, 0x15, 0x01fd);
-                MP_WritePhyUshort(sc, 0x19, 0x7801);
-                MP_WritePhyUshort(sc, 0x15, 0x01fe);
-                MP_WritePhyUshort(sc, 0x19, 0x980e);
-                MP_WritePhyUshort(sc, 0x15, 0x01ff);
-                MP_WritePhyUshort(sc, 0x19, 0x930c);
-                MP_WritePhyUshort(sc, 0x15, 0x0200);
-                MP_WritePhyUshort(sc, 0x19, 0x9206);
-                MP_WritePhyUshort(sc, 0x15, 0x0201);
-                MP_WritePhyUshort(sc, 0x19, 0x4002);
-                MP_WritePhyUshort(sc, 0x15, 0x0202);
-                MP_WritePhyUshort(sc, 0x19, 0x7800);
-                MP_WritePhyUshort(sc, 0x15, 0x0203);
-                MP_WritePhyUshort(sc, 0x19, 0x588f);
-                MP_WritePhyUshort(sc, 0x15, 0x0204);
-                MP_WritePhyUshort(sc, 0x19, 0x5520);
-                MP_WritePhyUshort(sc, 0x15, 0x0205);
-                MP_WritePhyUshort(sc, 0x19, 0x320c);
-                MP_WritePhyUshort(sc, 0x15, 0x0206);
-                MP_WritePhyUshort(sc, 0x19, 0x4000);
-                MP_WritePhyUshort(sc, 0x15, 0x0207);
-                MP_WritePhyUshort(sc, 0x19, 0x7800);
-                MP_WritePhyUshort(sc, 0x15, 0x0208);
-                MP_WritePhyUshort(sc, 0x19, 0x588d);
-                MP_WritePhyUshort(sc, 0x15, 0x0209);
-                MP_WritePhyUshort(sc, 0x19, 0x5500);
-                MP_WritePhyUshort(sc, 0x15, 0x020a);
-                MP_WritePhyUshort(sc, 0x19, 0x320c);
-                MP_WritePhyUshort(sc, 0x15, 0x020b);
-                MP_WritePhyUshort(sc, 0x19, 0x4002);
-                MP_WritePhyUshort(sc, 0x15, 0x020c);
-                MP_WritePhyUshort(sc, 0x19, 0x3220);
-                MP_WritePhyUshort(sc, 0x15, 0x020d);
-                MP_WritePhyUshort(sc, 0x19, 0x4480);
-                MP_WritePhyUshort(sc, 0x15, 0x020e);
-                MP_WritePhyUshort(sc, 0x19, 0x9e03);
-                MP_WritePhyUshort(sc, 0x15, 0x020f);
-                MP_WritePhyUshort(sc, 0x19, 0x7c40);
-                MP_WritePhyUshort(sc, 0x15, 0x0210);
-                MP_WritePhyUshort(sc, 0x19, 0x6840);
-                MP_WritePhyUshort(sc, 0x15, 0x0211);
-                MP_WritePhyUshort(sc, 0x19, 0x7801);
-                MP_WritePhyUshort(sc, 0x15, 0x0212);
-                MP_WritePhyUshort(sc, 0x19, 0x980e);
-                MP_WritePhyUshort(sc, 0x15, 0x0213);
-                MP_WritePhyUshort(sc, 0x19, 0x930c);
-                MP_WritePhyUshort(sc, 0x15, 0x0214);
-                MP_WritePhyUshort(sc, 0x19, 0x9206);
-                MP_WritePhyUshort(sc, 0x15, 0x0215);
-                MP_WritePhyUshort(sc, 0x19, 0x4000);
-                MP_WritePhyUshort(sc, 0x15, 0x0216);
-                MP_WritePhyUshort(sc, 0x19, 0x7800);
-                MP_WritePhyUshort(sc, 0x15, 0x0217);
-                MP_WritePhyUshort(sc, 0x19, 0x588f);
-                MP_WritePhyUshort(sc, 0x15, 0x0218);
-                MP_WritePhyUshort(sc, 0x19, 0x5520);
-                MP_WritePhyUshort(sc, 0x15, 0x0219);
-                MP_WritePhyUshort(sc, 0x19, 0x3220);
-                MP_WritePhyUshort(sc, 0x15, 0x021a);
-                MP_WritePhyUshort(sc, 0x19, 0x4002);
-                MP_WritePhyUshort(sc, 0x15, 0x021b);
-                MP_WritePhyUshort(sc, 0x19, 0x7800);
-                MP_WritePhyUshort(sc, 0x15, 0x021c);
-                MP_WritePhyUshort(sc, 0x19, 0x588d);
-                MP_WritePhyUshort(sc, 0x15, 0x021d);
-                MP_WritePhyUshort(sc, 0x19, 0x5540);
-                MP_WritePhyUshort(sc, 0x15, 0x021e);
-                MP_WritePhyUshort(sc, 0x19, 0x3220);
-                MP_WritePhyUshort(sc, 0x15, 0x021f);
-                MP_WritePhyUshort(sc, 0x19, 0x4000);
-                MP_WritePhyUshort(sc, 0x15, 0x0220);
-                MP_WritePhyUshort(sc, 0x19, 0x7800);
-                MP_WritePhyUshort(sc, 0x15, 0x0221);
-                MP_WritePhyUshort(sc, 0x19, 0x7c03);
-                MP_WritePhyUshort(sc, 0x15, 0x0222);
-                MP_WritePhyUshort(sc, 0x19, 0x6c00);
-                MP_WritePhyUshort(sc, 0x15, 0x0223);
-                MP_WritePhyUshort(sc, 0x19, 0x3231);
-                MP_WritePhyUshort(sc, 0x15, 0x0224);
-                MP_WritePhyUshort(sc, 0x19, 0xab06);
-                MP_WritePhyUshort(sc, 0x15, 0x0225);
-                MP_WritePhyUshort(sc, 0x19, 0xbf08);
-                MP_WritePhyUshort(sc, 0x15, 0x0226);
-                MP_WritePhyUshort(sc, 0x19, 0x4076);
-                MP_WritePhyUshort(sc, 0x15, 0x0227);
-                MP_WritePhyUshort(sc, 0x19, 0x7d07);
-                MP_WritePhyUshort(sc, 0x15, 0x0228);
-                MP_WritePhyUshort(sc, 0x19, 0x4502);
-                MP_WritePhyUshort(sc, 0x15, 0x0229);
-                MP_WritePhyUshort(sc, 0x19, 0x3231);
-                MP_WritePhyUshort(sc, 0x15, 0x022a);
-                MP_WritePhyUshort(sc, 0x19, 0x7d80);
-                MP_WritePhyUshort(sc, 0x15, 0x022b);
-                MP_WritePhyUshort(sc, 0x19, 0x5180);
-                MP_WritePhyUshort(sc, 0x15, 0x022c);
-                MP_WritePhyUshort(sc, 0x19, 0x322f);
-                MP_WritePhyUshort(sc, 0x15, 0x022d);
-                MP_WritePhyUshort(sc, 0x19, 0x7d80);
-                MP_WritePhyUshort(sc, 0x15, 0x022e);
-                MP_WritePhyUshort(sc, 0x19, 0x5000);
-                MP_WritePhyUshort(sc, 0x15, 0x022f);
-                MP_WritePhyUshort(sc, 0x19, 0x7d07);
-                MP_WritePhyUshort(sc, 0x15, 0x0230);
-                MP_WritePhyUshort(sc, 0x19, 0x4402);
-                MP_WritePhyUshort(sc, 0x15, 0x0231);
-                MP_WritePhyUshort(sc, 0x19, 0x7c03);
-                MP_WritePhyUshort(sc, 0x15, 0x0232);
-                MP_WritePhyUshort(sc, 0x19, 0x6c02);
-                MP_WritePhyUshort(sc, 0x15, 0x0233);
-                MP_WritePhyUshort(sc, 0x19, 0x7c03);
-                MP_WritePhyUshort(sc, 0x15, 0x0234);
-                MP_WritePhyUshort(sc, 0x19, 0xb309);
-                MP_WritePhyUshort(sc, 0x15, 0x0235);
-                MP_WritePhyUshort(sc, 0x19, 0xb204);
-                MP_WritePhyUshort(sc, 0x15, 0x0236);
-                MP_WritePhyUshort(sc, 0x19, 0xb105);
-                MP_WritePhyUshort(sc, 0x15, 0x0237);
-                MP_WritePhyUshort(sc, 0x19, 0x6c00);
-                MP_WritePhyUshort(sc, 0x15, 0x0238);
-                MP_WritePhyUshort(sc, 0x19, 0x31c1);
-                MP_WritePhyUshort(sc, 0x15, 0x0239);
-                MP_WritePhyUshort(sc, 0x19, 0x6c00);
-                MP_WritePhyUshort(sc, 0x15, 0x023a);
-                MP_WritePhyUshort(sc, 0x19, 0x3261);
-                MP_WritePhyUshort(sc, 0x15, 0x023b);
-                MP_WritePhyUshort(sc, 0x19, 0x6c00);
-                MP_WritePhyUshort(sc, 0x15, 0x023c);
-                MP_WritePhyUshort(sc, 0x19, 0x3250);
-                MP_WritePhyUshort(sc, 0x15, 0x023d);
-                MP_WritePhyUshort(sc, 0x19, 0xb203);
-                MP_WritePhyUshort(sc, 0x15, 0x023e);
-                MP_WritePhyUshort(sc, 0x19, 0x6c00);
-                MP_WritePhyUshort(sc, 0x15, 0x023f);
-                MP_WritePhyUshort(sc, 0x19, 0x327a);
-                MP_WritePhyUshort(sc, 0x15, 0x0240);
-                MP_WritePhyUshort(sc, 0x19, 0x6c00);
-                MP_WritePhyUshort(sc, 0x15, 0x0241);
-                MP_WritePhyUshort(sc, 0x19, 0x3293);
-                MP_WritePhyUshort(sc, 0x15, 0x0242);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x0243);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x0244);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x0245);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x0246);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x0247);
-                MP_WritePhyUshort(sc, 0x19, 0x32a3);
-                MP_WritePhyUshort(sc, 0x15, 0x0248);
-                MP_WritePhyUshort(sc, 0x19, 0x5520);
-                MP_WritePhyUshort(sc, 0x15, 0x0249);
-                MP_WritePhyUshort(sc, 0x19, 0x403d);
-                MP_WritePhyUshort(sc, 0x15, 0x024a);
-                MP_WritePhyUshort(sc, 0x19, 0x440c);
-                MP_WritePhyUshort(sc, 0x15, 0x024b);
-                MP_WritePhyUshort(sc, 0x19, 0x4812);
-                MP_WritePhyUshort(sc, 0x15, 0x024c);
-                MP_WritePhyUshort(sc, 0x19, 0x5001);
-                MP_WritePhyUshort(sc, 0x15, 0x024d);
-                MP_WritePhyUshort(sc, 0x19, 0x4802);
-                MP_WritePhyUshort(sc, 0x15, 0x024e);
-                MP_WritePhyUshort(sc, 0x19, 0x6880);
-                MP_WritePhyUshort(sc, 0x15, 0x024f);
-                MP_WritePhyUshort(sc, 0x19, 0x31f5);
-                MP_WritePhyUshort(sc, 0x15, 0x0250);
-                MP_WritePhyUshort(sc, 0x19, 0xb685);
-                MP_WritePhyUshort(sc, 0x15, 0x0251);
-                MP_WritePhyUshort(sc, 0x19, 0x801c);
-                MP_WritePhyUshort(sc, 0x15, 0x0252);
-                MP_WritePhyUshort(sc, 0x19, 0xbaf5);
-                MP_WritePhyUshort(sc, 0x15, 0x0253);
-                MP_WritePhyUshort(sc, 0x19, 0xc07c);
-                MP_WritePhyUshort(sc, 0x15, 0x0254);
-                MP_WritePhyUshort(sc, 0x19, 0x00fb);
-                MP_WritePhyUshort(sc, 0x15, 0x0255);
-                MP_WritePhyUshort(sc, 0x19, 0x325a);
-                MP_WritePhyUshort(sc, 0x15, 0x0256);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x0257);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x0258);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x0259);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x025a);
-                MP_WritePhyUshort(sc, 0x19, 0x481a);
-                MP_WritePhyUshort(sc, 0x15, 0x025b);
-                MP_WritePhyUshort(sc, 0x19, 0x5001);
-                MP_WritePhyUshort(sc, 0x15, 0x025c);
-                MP_WritePhyUshort(sc, 0x19, 0x401b);
-                MP_WritePhyUshort(sc, 0x15, 0x025d);
-                MP_WritePhyUshort(sc, 0x19, 0x480a);
-                MP_WritePhyUshort(sc, 0x15, 0x025e);
-                MP_WritePhyUshort(sc, 0x19, 0x4418);
-                MP_WritePhyUshort(sc, 0x15, 0x025f);
-                MP_WritePhyUshort(sc, 0x19, 0x6900);
-                MP_WritePhyUshort(sc, 0x15, 0x0260);
-                MP_WritePhyUshort(sc, 0x19, 0x31f5);
-                MP_WritePhyUshort(sc, 0x15, 0x0261);
-                MP_WritePhyUshort(sc, 0x19, 0xb64b);
-                MP_WritePhyUshort(sc, 0x15, 0x0262);
-                MP_WritePhyUshort(sc, 0x19, 0xdb00);
-                MP_WritePhyUshort(sc, 0x15, 0x0263);
-                MP_WritePhyUshort(sc, 0x19, 0x0048);
-                MP_WritePhyUshort(sc, 0x15, 0x0264);
-                MP_WritePhyUshort(sc, 0x19, 0xdb7d);
-                MP_WritePhyUshort(sc, 0x15, 0x0265);
-                MP_WritePhyUshort(sc, 0x19, 0x0002);
-                MP_WritePhyUshort(sc, 0x15, 0x0266);
-                MP_WritePhyUshort(sc, 0x19, 0xa0fa);
-                MP_WritePhyUshort(sc, 0x15, 0x0267);
-                MP_WritePhyUshort(sc, 0x19, 0x4408);
-                MP_WritePhyUshort(sc, 0x15, 0x0268);
-                MP_WritePhyUshort(sc, 0x19, 0x3248);
-                MP_WritePhyUshort(sc, 0x15, 0x0269);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x026a);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x026b);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x026c);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x026d);
-                MP_WritePhyUshort(sc, 0x19, 0xb806);
-                MP_WritePhyUshort(sc, 0x15, 0x026e);
-                MP_WritePhyUshort(sc, 0x19, 0x588d);
-                MP_WritePhyUshort(sc, 0x15, 0x026f);
-                MP_WritePhyUshort(sc, 0x19, 0x5500);
-                MP_WritePhyUshort(sc, 0x15, 0x0270);
-                MP_WritePhyUshort(sc, 0x19, 0x7801);
-                MP_WritePhyUshort(sc, 0x15, 0x0271);
-                MP_WritePhyUshort(sc, 0x19, 0x4002);
-                MP_WritePhyUshort(sc, 0x15, 0x0272);
-                MP_WritePhyUshort(sc, 0x19, 0x7800);
-                MP_WritePhyUshort(sc, 0x15, 0x0273);
-                MP_WritePhyUshort(sc, 0x19, 0x4814);
-                MP_WritePhyUshort(sc, 0x15, 0x0274);
-                MP_WritePhyUshort(sc, 0x19, 0x500b);
-                MP_WritePhyUshort(sc, 0x15, 0x0275);
-                MP_WritePhyUshort(sc, 0x19, 0x4804);
-                MP_WritePhyUshort(sc, 0x15, 0x0276);
-                MP_WritePhyUshort(sc, 0x19, 0x40c4);
-                MP_WritePhyUshort(sc, 0x15, 0x0277);
-                MP_WritePhyUshort(sc, 0x19, 0x4425);
-                MP_WritePhyUshort(sc, 0x15, 0x0278);
-                MP_WritePhyUshort(sc, 0x19, 0x6a00);
-                MP_WritePhyUshort(sc, 0x15, 0x0279);
-                MP_WritePhyUshort(sc, 0x19, 0x31f5);
-                MP_WritePhyUshort(sc, 0x15, 0x027a);
-                MP_WritePhyUshort(sc, 0x19, 0xb632);
-                MP_WritePhyUshort(sc, 0x15, 0x027b);
-                MP_WritePhyUshort(sc, 0x19, 0xdc03);
-                MP_WritePhyUshort(sc, 0x15, 0x027c);
-                MP_WritePhyUshort(sc, 0x19, 0x0027);
-                MP_WritePhyUshort(sc, 0x15, 0x027d);
-                MP_WritePhyUshort(sc, 0x19, 0x80fc);
-                MP_WritePhyUshort(sc, 0x15, 0x027e);
-                MP_WritePhyUshort(sc, 0x19, 0x3283);
-                MP_WritePhyUshort(sc, 0x15, 0x027f);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x0280);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x0281);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x0282);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x0283);
-                MP_WritePhyUshort(sc, 0x19, 0xb806);
-                MP_WritePhyUshort(sc, 0x15, 0x0284);
-                MP_WritePhyUshort(sc, 0x19, 0x588f);
-                MP_WritePhyUshort(sc, 0x15, 0x0285);
-                MP_WritePhyUshort(sc, 0x19, 0x5520);
-                MP_WritePhyUshort(sc, 0x15, 0x0286);
-                MP_WritePhyUshort(sc, 0x19, 0x7801);
-                MP_WritePhyUshort(sc, 0x15, 0x0287);
-                MP_WritePhyUshort(sc, 0x19, 0x4000);
-                MP_WritePhyUshort(sc, 0x15, 0x0288);
-                MP_WritePhyUshort(sc, 0x19, 0x7800);
-                MP_WritePhyUshort(sc, 0x15, 0x0289);
-                MP_WritePhyUshort(sc, 0x19, 0x4818);
-                MP_WritePhyUshort(sc, 0x15, 0x028a);
-                MP_WritePhyUshort(sc, 0x19, 0x5051);
-                MP_WritePhyUshort(sc, 0x15, 0x028b);
-                MP_WritePhyUshort(sc, 0x19, 0x4808);
-                MP_WritePhyUshort(sc, 0x15, 0x028c);
-                MP_WritePhyUshort(sc, 0x19, 0x4050);
-                MP_WritePhyUshort(sc, 0x15, 0x028d);
-                MP_WritePhyUshort(sc, 0x19, 0x4462);
-                MP_WritePhyUshort(sc, 0x15, 0x028e);
-                MP_WritePhyUshort(sc, 0x19, 0x40c4);
-                MP_WritePhyUshort(sc, 0x15, 0x028f);
-                MP_WritePhyUshort(sc, 0x19, 0x4473);
-                MP_WritePhyUshort(sc, 0x15, 0x0290);
-                MP_WritePhyUshort(sc, 0x19, 0x5041);
-                MP_WritePhyUshort(sc, 0x15, 0x0291);
-                MP_WritePhyUshort(sc, 0x19, 0x6b00);
-                MP_WritePhyUshort(sc, 0x15, 0x0292);
-                MP_WritePhyUshort(sc, 0x19, 0x31f5);
-                MP_WritePhyUshort(sc, 0x15, 0x0293);
-                MP_WritePhyUshort(sc, 0x19, 0xb619);
-                MP_WritePhyUshort(sc, 0x15, 0x0294);
-                MP_WritePhyUshort(sc, 0x19, 0x80d9);
-                MP_WritePhyUshort(sc, 0x15, 0x0295);
-                MP_WritePhyUshort(sc, 0x19, 0xbd06);
-                MP_WritePhyUshort(sc, 0x15, 0x0296);
-                MP_WritePhyUshort(sc, 0x19, 0xbb0d);
-                MP_WritePhyUshort(sc, 0x15, 0x0297);
-                MP_WritePhyUshort(sc, 0x19, 0xaf14);
-                MP_WritePhyUshort(sc, 0x15, 0x0298);
-                MP_WritePhyUshort(sc, 0x19, 0x8efa);
-                MP_WritePhyUshort(sc, 0x15, 0x0299);
-                MP_WritePhyUshort(sc, 0x19, 0x5049);
-                MP_WritePhyUshort(sc, 0x15, 0x029a);
-                MP_WritePhyUshort(sc, 0x19, 0x3248);
-                MP_WritePhyUshort(sc, 0x15, 0x029b);
-                MP_WritePhyUshort(sc, 0x19, 0x4c10);
-                MP_WritePhyUshort(sc, 0x15, 0x029c);
-                MP_WritePhyUshort(sc, 0x19, 0x44b0);
-                MP_WritePhyUshort(sc, 0x15, 0x029d);
-                MP_WritePhyUshort(sc, 0x19, 0x4c00);
-                MP_WritePhyUshort(sc, 0x15, 0x029e);
-                MP_WritePhyUshort(sc, 0x19, 0x3292);
-                MP_WritePhyUshort(sc, 0x15, 0x029f);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x02a0);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x02a1);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x02a2);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x02a3);
-                MP_WritePhyUshort(sc, 0x19, 0x481f);
-                MP_WritePhyUshort(sc, 0x15, 0x02a4);
-                MP_WritePhyUshort(sc, 0x19, 0x5005);
-                MP_WritePhyUshort(sc, 0x15, 0x02a5);
-                MP_WritePhyUshort(sc, 0x19, 0x480f);
-                MP_WritePhyUshort(sc, 0x15, 0x02a6);
-                MP_WritePhyUshort(sc, 0x19, 0xac00);
-                MP_WritePhyUshort(sc, 0x15, 0x02a7);
-                MP_WritePhyUshort(sc, 0x19, 0x31a6);
-                MP_WritePhyUshort(sc, 0x15, 0x02a8);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x02a9);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x02aa);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x02ab);
-                MP_WritePhyUshort(sc, 0x19, 0x31ba);
-                MP_WritePhyUshort(sc, 0x15, 0x02ac);
-                MP_WritePhyUshort(sc, 0x19, 0x31d5);
-                MP_WritePhyUshort(sc, 0x15, 0x02ad);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x02ae);
-                MP_WritePhyUshort(sc, 0x19, 0x5cf0);
-                MP_WritePhyUshort(sc, 0x15, 0x02af);
-                MP_WritePhyUshort(sc, 0x19, 0x588c);
-                MP_WritePhyUshort(sc, 0x15, 0x02b0);
-                MP_WritePhyUshort(sc, 0x19, 0x542f);
-                MP_WritePhyUshort(sc, 0x15, 0x02b1);
-                MP_WritePhyUshort(sc, 0x19, 0x7ffb);
-                MP_WritePhyUshort(sc, 0x15, 0x02b2);
-                MP_WritePhyUshort(sc, 0x19, 0x6ff8);
-                MP_WritePhyUshort(sc, 0x15, 0x02b3);
-                MP_WritePhyUshort(sc, 0x19, 0x64a4);
-                MP_WritePhyUshort(sc, 0x15, 0x02b4);
-                MP_WritePhyUshort(sc, 0x19, 0x64a0);
-                MP_WritePhyUshort(sc, 0x15, 0x02b5);
-                MP_WritePhyUshort(sc, 0x19, 0x6800);
-                MP_WritePhyUshort(sc, 0x15, 0x02b6);
-                MP_WritePhyUshort(sc, 0x19, 0x4400);
-                MP_WritePhyUshort(sc, 0x15, 0x02b7);
-                MP_WritePhyUshort(sc, 0x19, 0x4020);
-                MP_WritePhyUshort(sc, 0x15, 0x02b8);
-                MP_WritePhyUshort(sc, 0x19, 0x4480);
-                MP_WritePhyUshort(sc, 0x15, 0x02b9);
-                MP_WritePhyUshort(sc, 0x19, 0x9e00);
-                MP_WritePhyUshort(sc, 0x15, 0x02ba);
-                MP_WritePhyUshort(sc, 0x19, 0x4891);
-                MP_WritePhyUshort(sc, 0x15, 0x02bb);
-                MP_WritePhyUshort(sc, 0x19, 0x4cc0);
-                MP_WritePhyUshort(sc, 0x15, 0x02bc);
-                MP_WritePhyUshort(sc, 0x19, 0x4801);
-                MP_WritePhyUshort(sc, 0x15, 0x02bd);
-                MP_WritePhyUshort(sc, 0x19, 0xa609);
-                MP_WritePhyUshort(sc, 0x15, 0x02be);
-                MP_WritePhyUshort(sc, 0x19, 0xd64f);
-                MP_WritePhyUshort(sc, 0x15, 0x02bf);
-                MP_WritePhyUshort(sc, 0x19, 0x004e);
-                MP_WritePhyUshort(sc, 0x15, 0x02c0);
-                MP_WritePhyUshort(sc, 0x19, 0x87fe);
-                MP_WritePhyUshort(sc, 0x15, 0x02c1);
-                MP_WritePhyUshort(sc, 0x19, 0x32c6);
-                MP_WritePhyUshort(sc, 0x15, 0x02c2);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x02c3);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x02c4);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x02c5);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x02c6);
-                MP_WritePhyUshort(sc, 0x19, 0x48b2);
-                MP_WritePhyUshort(sc, 0x15, 0x02c7);
-                MP_WritePhyUshort(sc, 0x19, 0x4020);
-                MP_WritePhyUshort(sc, 0x15, 0x02c8);
-                MP_WritePhyUshort(sc, 0x19, 0x4822);
-                MP_WritePhyUshort(sc, 0x15, 0x02c9);
-                MP_WritePhyUshort(sc, 0x19, 0x4488);
-                MP_WritePhyUshort(sc, 0x15, 0x02ca);
-                MP_WritePhyUshort(sc, 0x19, 0xd64f);
-                MP_WritePhyUshort(sc, 0x15, 0x02cb);
-                MP_WritePhyUshort(sc, 0x19, 0x0042);
-                MP_WritePhyUshort(sc, 0x15, 0x02cc);
-                MP_WritePhyUshort(sc, 0x19, 0x8203);
-                MP_WritePhyUshort(sc, 0x15, 0x02cd);
-                MP_WritePhyUshort(sc, 0x19, 0x4cc8);
-                MP_WritePhyUshort(sc, 0x15, 0x02ce);
-                MP_WritePhyUshort(sc, 0x19, 0x32d0);
-                MP_WritePhyUshort(sc, 0x15, 0x02cf);
-                MP_WritePhyUshort(sc, 0x19, 0x4cc0);
-                MP_WritePhyUshort(sc, 0x15, 0x02d0);
-                MP_WritePhyUshort(sc, 0x19, 0xc4d4);
-                MP_WritePhyUshort(sc, 0x15, 0x02d1);
-                MP_WritePhyUshort(sc, 0x19, 0x00f9);
-                MP_WritePhyUshort(sc, 0x15, 0x02d2);
-                MP_WritePhyUshort(sc, 0x19, 0xa51a);
-                MP_WritePhyUshort(sc, 0x15, 0x02d3);
-                MP_WritePhyUshort(sc, 0x19, 0x32d9);
-                MP_WritePhyUshort(sc, 0x15, 0x02d4);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x02d5);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x02d6);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x02d7);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x02d8);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x02d9);
-                MP_WritePhyUshort(sc, 0x19, 0x48b3);
-                MP_WritePhyUshort(sc, 0x15, 0x02da);
-                MP_WritePhyUshort(sc, 0x19, 0x4020);
-                MP_WritePhyUshort(sc, 0x15, 0x02db);
-                MP_WritePhyUshort(sc, 0x19, 0x4823);
-                MP_WritePhyUshort(sc, 0x15, 0x02dc);
-                MP_WritePhyUshort(sc, 0x19, 0x4410);
-                MP_WritePhyUshort(sc, 0x15, 0x02dd);
-                MP_WritePhyUshort(sc, 0x19, 0xb630);
-                MP_WritePhyUshort(sc, 0x15, 0x02de);
-                MP_WritePhyUshort(sc, 0x19, 0x7dc8);
-                MP_WritePhyUshort(sc, 0x15, 0x02df);
-                MP_WritePhyUshort(sc, 0x19, 0x8203);
-                MP_WritePhyUshort(sc, 0x15, 0x02e0);
-                MP_WritePhyUshort(sc, 0x19, 0x4c48);
-                MP_WritePhyUshort(sc, 0x15, 0x02e1);
-                MP_WritePhyUshort(sc, 0x19, 0x32e3);
-                MP_WritePhyUshort(sc, 0x15, 0x02e2);
-                MP_WritePhyUshort(sc, 0x19, 0x4c40);
-                MP_WritePhyUshort(sc, 0x15, 0x02e3);
-                MP_WritePhyUshort(sc, 0x19, 0x9bfa);
-                MP_WritePhyUshort(sc, 0x15, 0x02e4);
-                MP_WritePhyUshort(sc, 0x19, 0x84ca);
-                MP_WritePhyUshort(sc, 0x15, 0x02e5);
-                MP_WritePhyUshort(sc, 0x19, 0x85f8);
-                MP_WritePhyUshort(sc, 0x15, 0x02e6);
-                MP_WritePhyUshort(sc, 0x19, 0x32ec);
-                MP_WritePhyUshort(sc, 0x15, 0x02e7);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x02e8);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x02e9);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x02ea);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x02eb);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x02ec);
-                MP_WritePhyUshort(sc, 0x19, 0x48d4);
-                MP_WritePhyUshort(sc, 0x15, 0x02ed);
-                MP_WritePhyUshort(sc, 0x19, 0x4020);
-                MP_WritePhyUshort(sc, 0x15, 0x02ee);
-                MP_WritePhyUshort(sc, 0x19, 0x4844);
-                MP_WritePhyUshort(sc, 0x15, 0x02ef);
-                MP_WritePhyUshort(sc, 0x19, 0x4420);
-                MP_WritePhyUshort(sc, 0x15, 0x02f0);
-                MP_WritePhyUshort(sc, 0x19, 0x6800);
-                MP_WritePhyUshort(sc, 0x15, 0x02f1);
-                MP_WritePhyUshort(sc, 0x19, 0x7dc0);
-                MP_WritePhyUshort(sc, 0x15, 0x02f2);
-                MP_WritePhyUshort(sc, 0x19, 0x4c40);
-                MP_WritePhyUshort(sc, 0x15, 0x02f3);
-                MP_WritePhyUshort(sc, 0x19, 0x7c0b);
-                MP_WritePhyUshort(sc, 0x15, 0x02f4);
-                MP_WritePhyUshort(sc, 0x19, 0x6c08);
-                MP_WritePhyUshort(sc, 0x15, 0x02f5);
-                MP_WritePhyUshort(sc, 0x19, 0x3311);
-                MP_WritePhyUshort(sc, 0x15, 0x02f6);
-                MP_WritePhyUshort(sc, 0x19, 0x9cfd);
-                MP_WritePhyUshort(sc, 0x15, 0x02f7);
-                MP_WritePhyUshort(sc, 0x19, 0xb616);
-                MP_WritePhyUshort(sc, 0x15, 0x02f8);
-                MP_WritePhyUshort(sc, 0x19, 0xc42b);
-                MP_WritePhyUshort(sc, 0x15, 0x02f9);
-                MP_WritePhyUshort(sc, 0x19, 0x00e0);
-                MP_WritePhyUshort(sc, 0x15, 0x02fa);
-                MP_WritePhyUshort(sc, 0x19, 0xc455);
-                MP_WritePhyUshort(sc, 0x15, 0x02fb);
-                MP_WritePhyUshort(sc, 0x19, 0x00b3);
-                MP_WritePhyUshort(sc, 0x15, 0x02fc);
-                MP_WritePhyUshort(sc, 0x19, 0xb20a);
-                MP_WritePhyUshort(sc, 0x15, 0x02fd);
-                MP_WritePhyUshort(sc, 0x19, 0x7c03);
-                MP_WritePhyUshort(sc, 0x15, 0x02fe);
-                MP_WritePhyUshort(sc, 0x19, 0x6c02);
-                MP_WritePhyUshort(sc, 0x15, 0x02ff);
-                MP_WritePhyUshort(sc, 0x19, 0x8204);
-                MP_WritePhyUshort(sc, 0x15, 0x0300);
-                MP_WritePhyUshort(sc, 0x19, 0x7c04);
-                MP_WritePhyUshort(sc, 0x15, 0x0301);
-                MP_WritePhyUshort(sc, 0x19, 0x7404);
-                MP_WritePhyUshort(sc, 0x15, 0x0302);
-                MP_WritePhyUshort(sc, 0x19, 0x32f3);
-                MP_WritePhyUshort(sc, 0x15, 0x0303);
-                MP_WritePhyUshort(sc, 0x19, 0x7c04);
-                MP_WritePhyUshort(sc, 0x15, 0x0304);
-                MP_WritePhyUshort(sc, 0x19, 0x7400);
-                MP_WritePhyUshort(sc, 0x15, 0x0305);
-                MP_WritePhyUshort(sc, 0x19, 0x32f3);
-                MP_WritePhyUshort(sc, 0x15, 0x0306);
-                MP_WritePhyUshort(sc, 0x19, 0xefed);
-                MP_WritePhyUshort(sc, 0x15, 0x0307);
-                MP_WritePhyUshort(sc, 0x19, 0x3342);
-                MP_WritePhyUshort(sc, 0x15, 0x0308);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x0309);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x030a);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x030b);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x030c);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x030d);
-                MP_WritePhyUshort(sc, 0x19, 0x3006);
-                MP_WritePhyUshort(sc, 0x15, 0x030e);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x030f);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x0310);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x0311);
-                MP_WritePhyUshort(sc, 0x19, 0x7c08);
-                MP_WritePhyUshort(sc, 0x15, 0x0312);
-                MP_WritePhyUshort(sc, 0x19, 0xa207);
-                MP_WritePhyUshort(sc, 0x15, 0x0313);
-                MP_WritePhyUshort(sc, 0x19, 0x4c00);
-                MP_WritePhyUshort(sc, 0x15, 0x0314);
-                MP_WritePhyUshort(sc, 0x19, 0x3322);
-                MP_WritePhyUshort(sc, 0x15, 0x0315);
-                MP_WritePhyUshort(sc, 0x19, 0x4041);
-                MP_WritePhyUshort(sc, 0x15, 0x0316);
-                MP_WritePhyUshort(sc, 0x19, 0x7d07);
-                MP_WritePhyUshort(sc, 0x15, 0x0317);
-                MP_WritePhyUshort(sc, 0x19, 0x4502);
-                MP_WritePhyUshort(sc, 0x15, 0x0318);
-                MP_WritePhyUshort(sc, 0x19, 0x3322);
-                MP_WritePhyUshort(sc, 0x15, 0x0319);
-                MP_WritePhyUshort(sc, 0x19, 0x4c08);
-                MP_WritePhyUshort(sc, 0x15, 0x031a);
-                MP_WritePhyUshort(sc, 0x19, 0x3322);
-                MP_WritePhyUshort(sc, 0x15, 0x031b);
-                MP_WritePhyUshort(sc, 0x19, 0x7d80);
-                MP_WritePhyUshort(sc, 0x15, 0x031c);
-                MP_WritePhyUshort(sc, 0x19, 0x5180);
-                MP_WritePhyUshort(sc, 0x15, 0x031d);
-                MP_WritePhyUshort(sc, 0x19, 0x3320);
-                MP_WritePhyUshort(sc, 0x15, 0x031e);
-                MP_WritePhyUshort(sc, 0x19, 0x7d80);
-                MP_WritePhyUshort(sc, 0x15, 0x031f);
-                MP_WritePhyUshort(sc, 0x19, 0x5000);
-                MP_WritePhyUshort(sc, 0x15, 0x0320);
-                MP_WritePhyUshort(sc, 0x19, 0x7d07);
-                MP_WritePhyUshort(sc, 0x15, 0x0321);
-                MP_WritePhyUshort(sc, 0x19, 0x4402);
-                MP_WritePhyUshort(sc, 0x15, 0x0322);
-                MP_WritePhyUshort(sc, 0x19, 0x7c03);
-                MP_WritePhyUshort(sc, 0x15, 0x0323);
-                MP_WritePhyUshort(sc, 0x19, 0x6c02);
-                MP_WritePhyUshort(sc, 0x15, 0x0324);
-                MP_WritePhyUshort(sc, 0x19, 0x7c03);
-                MP_WritePhyUshort(sc, 0x15, 0x0325);
-                MP_WritePhyUshort(sc, 0x19, 0xb30c);
-                MP_WritePhyUshort(sc, 0x15, 0x0326);
-                MP_WritePhyUshort(sc, 0x19, 0xb206);
-                MP_WritePhyUshort(sc, 0x15, 0x0327);
-                MP_WritePhyUshort(sc, 0x19, 0xb103);
-                MP_WritePhyUshort(sc, 0x15, 0x0328);
-                MP_WritePhyUshort(sc, 0x19, 0x6c00);
-                MP_WritePhyUshort(sc, 0x15, 0x0329);
-                MP_WritePhyUshort(sc, 0x19, 0x32f6);
-                MP_WritePhyUshort(sc, 0x15, 0x032a);
-                MP_WritePhyUshort(sc, 0x19, 0x6c00);
-                MP_WritePhyUshort(sc, 0x15, 0x032b);
-                MP_WritePhyUshort(sc, 0x19, 0x3352);
-                MP_WritePhyUshort(sc, 0x15, 0x032c);
-                MP_WritePhyUshort(sc, 0x19, 0xb103);
-                MP_WritePhyUshort(sc, 0x15, 0x032d);
-                MP_WritePhyUshort(sc, 0x19, 0x6c00);
-                MP_WritePhyUshort(sc, 0x15, 0x032e);
-                MP_WritePhyUshort(sc, 0x19, 0x336a);
-                MP_WritePhyUshort(sc, 0x15, 0x032f);
-                MP_WritePhyUshort(sc, 0x19, 0x6c00);
-                MP_WritePhyUshort(sc, 0x15, 0x0330);
-                MP_WritePhyUshort(sc, 0x19, 0x3382);
-                MP_WritePhyUshort(sc, 0x15, 0x0331);
-                MP_WritePhyUshort(sc, 0x19, 0xb206);
-                MP_WritePhyUshort(sc, 0x15, 0x0332);
-                MP_WritePhyUshort(sc, 0x19, 0xb103);
-                MP_WritePhyUshort(sc, 0x15, 0x0333);
-                MP_WritePhyUshort(sc, 0x19, 0x6c00);
-                MP_WritePhyUshort(sc, 0x15, 0x0334);
-                MP_WritePhyUshort(sc, 0x19, 0x3395);
-                MP_WritePhyUshort(sc, 0x15, 0x0335);
-                MP_WritePhyUshort(sc, 0x19, 0x6c00);
-                MP_WritePhyUshort(sc, 0x15, 0x0336);
-                MP_WritePhyUshort(sc, 0x19, 0x33c6);
-                MP_WritePhyUshort(sc, 0x15, 0x0337);
-                MP_WritePhyUshort(sc, 0x19, 0xb103);
-                MP_WritePhyUshort(sc, 0x15, 0x0338);
-                MP_WritePhyUshort(sc, 0x19, 0x6c00);
-                MP_WritePhyUshort(sc, 0x15, 0x0339);
-                MP_WritePhyUshort(sc, 0x19, 0x33d7);
-                MP_WritePhyUshort(sc, 0x15, 0x033a);
-                MP_WritePhyUshort(sc, 0x19, 0x6c00);
-                MP_WritePhyUshort(sc, 0x15, 0x033b);
-                MP_WritePhyUshort(sc, 0x19, 0x33f2);
-                MP_WritePhyUshort(sc, 0x15, 0x033c);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x033d);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x033e);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x033f);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x0340);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x0341);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x0342);
-                MP_WritePhyUshort(sc, 0x19, 0x49b5);
-                MP_WritePhyUshort(sc, 0x15, 0x0343);
-                MP_WritePhyUshort(sc, 0x19, 0x7d00);
-                MP_WritePhyUshort(sc, 0x15, 0x0344);
-                MP_WritePhyUshort(sc, 0x19, 0x4d00);
-                MP_WritePhyUshort(sc, 0x15, 0x0345);
-                MP_WritePhyUshort(sc, 0x19, 0x6880);
-                MP_WritePhyUshort(sc, 0x15, 0x0346);
-                MP_WritePhyUshort(sc, 0x19, 0x7c08);
-                MP_WritePhyUshort(sc, 0x15, 0x0347);
-                MP_WritePhyUshort(sc, 0x19, 0x6c08);
-                MP_WritePhyUshort(sc, 0x15, 0x0348);
-                MP_WritePhyUshort(sc, 0x19, 0x4925);
-                MP_WritePhyUshort(sc, 0x15, 0x0349);
-                MP_WritePhyUshort(sc, 0x19, 0x403b);
-                MP_WritePhyUshort(sc, 0x15, 0x034a);
-                MP_WritePhyUshort(sc, 0x19, 0xa602);
-                MP_WritePhyUshort(sc, 0x15, 0x034b);
-                MP_WritePhyUshort(sc, 0x19, 0x402f);
-                MP_WritePhyUshort(sc, 0x15, 0x034c);
-                MP_WritePhyUshort(sc, 0x19, 0x4484);
-                MP_WritePhyUshort(sc, 0x15, 0x034d);
-                MP_WritePhyUshort(sc, 0x19, 0x40c8);
-                MP_WritePhyUshort(sc, 0x15, 0x034e);
-                MP_WritePhyUshort(sc, 0x19, 0x44c4);
-                MP_WritePhyUshort(sc, 0x15, 0x034f);
-                MP_WritePhyUshort(sc, 0x19, 0xd64f);
-                MP_WritePhyUshort(sc, 0x15, 0x0350);
-                MP_WritePhyUshort(sc, 0x19, 0x00bd);
-                MP_WritePhyUshort(sc, 0x15, 0x0351);
-                MP_WritePhyUshort(sc, 0x19, 0x3311);
-                MP_WritePhyUshort(sc, 0x15, 0x0352);
-                MP_WritePhyUshort(sc, 0x19, 0xc8ed);
-                MP_WritePhyUshort(sc, 0x15, 0x0353);
-                MP_WritePhyUshort(sc, 0x19, 0x00fc);
-                MP_WritePhyUshort(sc, 0x15, 0x0354);
-                MP_WritePhyUshort(sc, 0x19, 0x8221);
-                MP_WritePhyUshort(sc, 0x15, 0x0355);
-                MP_WritePhyUshort(sc, 0x19, 0xd11d);
-                MP_WritePhyUshort(sc, 0x15, 0x0356);
-                MP_WritePhyUshort(sc, 0x19, 0x001f);
-                MP_WritePhyUshort(sc, 0x15, 0x0357);
-                MP_WritePhyUshort(sc, 0x19, 0xde18);
-                MP_WritePhyUshort(sc, 0x15, 0x0358);
-                MP_WritePhyUshort(sc, 0x19, 0x0008);
-                MP_WritePhyUshort(sc, 0x15, 0x0359);
-                MP_WritePhyUshort(sc, 0x19, 0x91f6);
-                MP_WritePhyUshort(sc, 0x15, 0x035a);
-                MP_WritePhyUshort(sc, 0x19, 0x3360);
-                MP_WritePhyUshort(sc, 0x15, 0x035b);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x035c);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x035d);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x035e);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x035f);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x0360);
-                MP_WritePhyUshort(sc, 0x19, 0x4bb6);
-                MP_WritePhyUshort(sc, 0x15, 0x0361);
-                MP_WritePhyUshort(sc, 0x19, 0x4064);
-                MP_WritePhyUshort(sc, 0x15, 0x0362);
-                MP_WritePhyUshort(sc, 0x19, 0x4b26);
-                MP_WritePhyUshort(sc, 0x15, 0x0363);
-                MP_WritePhyUshort(sc, 0x19, 0x4410);
-                MP_WritePhyUshort(sc, 0x15, 0x0364);
-                MP_WritePhyUshort(sc, 0x19, 0x4006);
-                MP_WritePhyUshort(sc, 0x15, 0x0365);
-                MP_WritePhyUshort(sc, 0x19, 0x4490);
-                MP_WritePhyUshort(sc, 0x15, 0x0366);
-                MP_WritePhyUshort(sc, 0x19, 0x6900);
-                MP_WritePhyUshort(sc, 0x15, 0x0367);
-                MP_WritePhyUshort(sc, 0x19, 0xb6a6);
-                MP_WritePhyUshort(sc, 0x15, 0x0368);
-                MP_WritePhyUshort(sc, 0x19, 0x9e02);
-                MP_WritePhyUshort(sc, 0x15, 0x0369);
-                MP_WritePhyUshort(sc, 0x19, 0x3311);
-                MP_WritePhyUshort(sc, 0x15, 0x036a);
-                MP_WritePhyUshort(sc, 0x19, 0xd11d);
-                MP_WritePhyUshort(sc, 0x15, 0x036b);
-                MP_WritePhyUshort(sc, 0x19, 0x000a);
-                MP_WritePhyUshort(sc, 0x15, 0x036c);
-                MP_WritePhyUshort(sc, 0x19, 0xbb0f);
-                MP_WritePhyUshort(sc, 0x15, 0x036d);
-                MP_WritePhyUshort(sc, 0x19, 0x8102);
-                MP_WritePhyUshort(sc, 0x15, 0x036e);
-                MP_WritePhyUshort(sc, 0x19, 0x3371);
-                MP_WritePhyUshort(sc, 0x15, 0x036f);
-                MP_WritePhyUshort(sc, 0x19, 0xa21e);
-                MP_WritePhyUshort(sc, 0x15, 0x0370);
-                MP_WritePhyUshort(sc, 0x19, 0x33b6);
-                MP_WritePhyUshort(sc, 0x15, 0x0371);
-                MP_WritePhyUshort(sc, 0x19, 0x91f6);
-                MP_WritePhyUshort(sc, 0x15, 0x0372);
-                MP_WritePhyUshort(sc, 0x19, 0xc218);
-                MP_WritePhyUshort(sc, 0x15, 0x0373);
-                MP_WritePhyUshort(sc, 0x19, 0x00f4);
-                MP_WritePhyUshort(sc, 0x15, 0x0374);
-                MP_WritePhyUshort(sc, 0x19, 0x33b6);
-                MP_WritePhyUshort(sc, 0x15, 0x0375);
-                MP_WritePhyUshort(sc, 0x19, 0x32ec);
-                MP_WritePhyUshort(sc, 0x15, 0x0376);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x0377);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x0378);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x0379);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x037a);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x037b);
-                MP_WritePhyUshort(sc, 0x19, 0x4b97);
-                MP_WritePhyUshort(sc, 0x15, 0x037c);
-                MP_WritePhyUshort(sc, 0x19, 0x402b);
-                MP_WritePhyUshort(sc, 0x15, 0x037d);
-                MP_WritePhyUshort(sc, 0x19, 0x4b07);
-                MP_WritePhyUshort(sc, 0x15, 0x037e);
-                MP_WritePhyUshort(sc, 0x19, 0x4422);
-                MP_WritePhyUshort(sc, 0x15, 0x037f);
-                MP_WritePhyUshort(sc, 0x19, 0x6980);
-                MP_WritePhyUshort(sc, 0x15, 0x0380);
-                MP_WritePhyUshort(sc, 0x19, 0xb608);
-                MP_WritePhyUshort(sc, 0x15, 0x0381);
-                MP_WritePhyUshort(sc, 0x19, 0x3311);
-                MP_WritePhyUshort(sc, 0x15, 0x0382);
-                MP_WritePhyUshort(sc, 0x19, 0xbc05);
-                MP_WritePhyUshort(sc, 0x15, 0x0383);
-                MP_WritePhyUshort(sc, 0x19, 0xc21c);
-                MP_WritePhyUshort(sc, 0x15, 0x0384);
-                MP_WritePhyUshort(sc, 0x19, 0x0032);
-                MP_WritePhyUshort(sc, 0x15, 0x0385);
-                MP_WritePhyUshort(sc, 0x19, 0xa1fb);
-                MP_WritePhyUshort(sc, 0x15, 0x0386);
-                MP_WritePhyUshort(sc, 0x19, 0x338d);
-                MP_WritePhyUshort(sc, 0x15, 0x0387);
-                MP_WritePhyUshort(sc, 0x19, 0x32ae);
-                MP_WritePhyUshort(sc, 0x15, 0x0388);
-                MP_WritePhyUshort(sc, 0x19, 0x330d);
-                MP_WritePhyUshort(sc, 0x15, 0x0389);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x038a);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x038b);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x038c);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x038d);
-                MP_WritePhyUshort(sc, 0x19, 0x4b97);
-                MP_WritePhyUshort(sc, 0x15, 0x038e);
-                MP_WritePhyUshort(sc, 0x19, 0x6a08);
-                MP_WritePhyUshort(sc, 0x15, 0x038f);
-                MP_WritePhyUshort(sc, 0x19, 0x4b07);
-                MP_WritePhyUshort(sc, 0x15, 0x0390);
-                MP_WritePhyUshort(sc, 0x19, 0x40ac);
-                MP_WritePhyUshort(sc, 0x15, 0x0391);
-                MP_WritePhyUshort(sc, 0x19, 0x4445);
-                MP_WritePhyUshort(sc, 0x15, 0x0392);
-                MP_WritePhyUshort(sc, 0x19, 0x404e);
-                MP_WritePhyUshort(sc, 0x15, 0x0393);
-                MP_WritePhyUshort(sc, 0x19, 0x4461);
-                MP_WritePhyUshort(sc, 0x15, 0x0394);
-                MP_WritePhyUshort(sc, 0x19, 0x3311);
-                MP_WritePhyUshort(sc, 0x15, 0x0395);
-                MP_WritePhyUshort(sc, 0x19, 0x9c0a);
-                MP_WritePhyUshort(sc, 0x15, 0x0396);
-                MP_WritePhyUshort(sc, 0x19, 0x63da);
-                MP_WritePhyUshort(sc, 0x15, 0x0397);
-                MP_WritePhyUshort(sc, 0x19, 0x6f0c);
-                MP_WritePhyUshort(sc, 0x15, 0x0398);
-                MP_WritePhyUshort(sc, 0x19, 0x5440);
-                MP_WritePhyUshort(sc, 0x15, 0x0399);
-                MP_WritePhyUshort(sc, 0x19, 0x4b98);
-                MP_WritePhyUshort(sc, 0x15, 0x039a);
-                MP_WritePhyUshort(sc, 0x19, 0x7c40);
-                MP_WritePhyUshort(sc, 0x15, 0x039b);
-                MP_WritePhyUshort(sc, 0x19, 0x4c00);
-                MP_WritePhyUshort(sc, 0x15, 0x039c);
-                MP_WritePhyUshort(sc, 0x19, 0x4b08);
-                MP_WritePhyUshort(sc, 0x15, 0x039d);
-                MP_WritePhyUshort(sc, 0x19, 0x63d8);
-                MP_WritePhyUshort(sc, 0x15, 0x039e);
-                MP_WritePhyUshort(sc, 0x19, 0x33a5);
-                MP_WritePhyUshort(sc, 0x15, 0x039f);
-                MP_WritePhyUshort(sc, 0x19, 0xd64f);
-                MP_WritePhyUshort(sc, 0x15, 0x03a0);
-                MP_WritePhyUshort(sc, 0x19, 0x00e8);
-                MP_WritePhyUshort(sc, 0x15, 0x03a1);
-                MP_WritePhyUshort(sc, 0x19, 0x820e);
-                MP_WritePhyUshort(sc, 0x15, 0x03a2);
-                MP_WritePhyUshort(sc, 0x19, 0xa10d);
-                MP_WritePhyUshort(sc, 0x15, 0x03a3);
-                MP_WritePhyUshort(sc, 0x19, 0x9df1);
-                MP_WritePhyUshort(sc, 0x15, 0x03a4);
-                MP_WritePhyUshort(sc, 0x19, 0x33af);
-                MP_WritePhyUshort(sc, 0x15, 0x03a5);
-                MP_WritePhyUshort(sc, 0x19, 0xd64f);
-                MP_WritePhyUshort(sc, 0x15, 0x03a6);
-                MP_WritePhyUshort(sc, 0x19, 0x00f9);
-                MP_WritePhyUshort(sc, 0x15, 0x03a7);
-                MP_WritePhyUshort(sc, 0x19, 0xc017);
-                MP_WritePhyUshort(sc, 0x15, 0x03a8);
-                MP_WritePhyUshort(sc, 0x19, 0x0007);
-                MP_WritePhyUshort(sc, 0x15, 0x03a9);
-                MP_WritePhyUshort(sc, 0x19, 0x7c03);
-                MP_WritePhyUshort(sc, 0x15, 0x03aa);
-                MP_WritePhyUshort(sc, 0x19, 0x6c03);
-                MP_WritePhyUshort(sc, 0x15, 0x03ab);
-                MP_WritePhyUshort(sc, 0x19, 0xa104);
-                MP_WritePhyUshort(sc, 0x15, 0x03ac);
-                MP_WritePhyUshort(sc, 0x19, 0x7c03);
-                MP_WritePhyUshort(sc, 0x15, 0x03ad);
-                MP_WritePhyUshort(sc, 0x19, 0x6c00);
-                MP_WritePhyUshort(sc, 0x15, 0x03ae);
-                MP_WritePhyUshort(sc, 0x19, 0x9df7);
-                MP_WritePhyUshort(sc, 0x15, 0x03af);
-                MP_WritePhyUshort(sc, 0x19, 0x7c03);
-                MP_WritePhyUshort(sc, 0x15, 0x03b0);
-                MP_WritePhyUshort(sc, 0x19, 0x6c08);
-                MP_WritePhyUshort(sc, 0x15, 0x03b1);
-                MP_WritePhyUshort(sc, 0x19, 0x33b6);
-                MP_WritePhyUshort(sc, 0x15, 0x03b2);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x03b3);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x03b4);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x03b5);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x03b6);
-                MP_WritePhyUshort(sc, 0x19, 0x55af);
-                MP_WritePhyUshort(sc, 0x15, 0x03b7);
-                MP_WritePhyUshort(sc, 0x19, 0x7ff0);
-                MP_WritePhyUshort(sc, 0x15, 0x03b8);
-                MP_WritePhyUshort(sc, 0x19, 0x6ff0);
-                MP_WritePhyUshort(sc, 0x15, 0x03b9);
-                MP_WritePhyUshort(sc, 0x19, 0x4bb9);
-                MP_WritePhyUshort(sc, 0x15, 0x03ba);
-                MP_WritePhyUshort(sc, 0x19, 0x6a80);
-                MP_WritePhyUshort(sc, 0x15, 0x03bb);
-                MP_WritePhyUshort(sc, 0x19, 0x4b29);
-                MP_WritePhyUshort(sc, 0x15, 0x03bc);
-                MP_WritePhyUshort(sc, 0x19, 0x4041);
-                MP_WritePhyUshort(sc, 0x15, 0x03bd);
-                MP_WritePhyUshort(sc, 0x19, 0x440a);
-                MP_WritePhyUshort(sc, 0x15, 0x03be);
-                MP_WritePhyUshort(sc, 0x19, 0x4029);
-                MP_WritePhyUshort(sc, 0x15, 0x03bf);
-                MP_WritePhyUshort(sc, 0x19, 0x4418);
-                MP_WritePhyUshort(sc, 0x15, 0x03c0);
-                MP_WritePhyUshort(sc, 0x19, 0x4090);
-                MP_WritePhyUshort(sc, 0x15, 0x03c1);
-                MP_WritePhyUshort(sc, 0x19, 0x4438);
-                MP_WritePhyUshort(sc, 0x15, 0x03c2);
-                MP_WritePhyUshort(sc, 0x19, 0x40c4);
-                MP_WritePhyUshort(sc, 0x15, 0x03c3);
-                MP_WritePhyUshort(sc, 0x19, 0x447b);
-                MP_WritePhyUshort(sc, 0x15, 0x03c4);
-                MP_WritePhyUshort(sc, 0x19, 0xb6c4);
-                MP_WritePhyUshort(sc, 0x15, 0x03c5);
-                MP_WritePhyUshort(sc, 0x19, 0x3311);
-                MP_WritePhyUshort(sc, 0x15, 0x03c6);
-                MP_WritePhyUshort(sc, 0x19, 0x9bfe);
-                MP_WritePhyUshort(sc, 0x15, 0x03c7);
-                MP_WritePhyUshort(sc, 0x19, 0x33cc);
-                MP_WritePhyUshort(sc, 0x15, 0x03c8);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x03c9);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x03ca);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x03cb);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x03cc);
-                MP_WritePhyUshort(sc, 0x19, 0x542f);
-                MP_WritePhyUshort(sc, 0x15, 0x03cd);
-                MP_WritePhyUshort(sc, 0x19, 0x499a);
-                MP_WritePhyUshort(sc, 0x15, 0x03ce);
-                MP_WritePhyUshort(sc, 0x19, 0x7c40);
-                MP_WritePhyUshort(sc, 0x15, 0x03cf);
-                MP_WritePhyUshort(sc, 0x19, 0x4c40);
-                MP_WritePhyUshort(sc, 0x15, 0x03d0);
-                MP_WritePhyUshort(sc, 0x19, 0x490a);
-                MP_WritePhyUshort(sc, 0x15, 0x03d1);
-                MP_WritePhyUshort(sc, 0x19, 0x405e);
-                MP_WritePhyUshort(sc, 0x15, 0x03d2);
-                MP_WritePhyUshort(sc, 0x19, 0x44f8);
-                MP_WritePhyUshort(sc, 0x15, 0x03d3);
-                MP_WritePhyUshort(sc, 0x19, 0x6b00);
-                MP_WritePhyUshort(sc, 0x15, 0x03d4);
-                MP_WritePhyUshort(sc, 0x19, 0xd64f);
-                MP_WritePhyUshort(sc, 0x15, 0x03d5);
-                MP_WritePhyUshort(sc, 0x19, 0x0028);
-                MP_WritePhyUshort(sc, 0x15, 0x03d6);
-                MP_WritePhyUshort(sc, 0x19, 0x3311);
-                MP_WritePhyUshort(sc, 0x15, 0x03d7);
-                MP_WritePhyUshort(sc, 0x19, 0xbd27);
-                MP_WritePhyUshort(sc, 0x15, 0x03d8);
-                MP_WritePhyUshort(sc, 0x19, 0x9cfc);
-                MP_WritePhyUshort(sc, 0x15, 0x03d9);
-                MP_WritePhyUshort(sc, 0x19, 0xc639);
-                MP_WritePhyUshort(sc, 0x15, 0x03da);
-                MP_WritePhyUshort(sc, 0x19, 0x000f);
-                MP_WritePhyUshort(sc, 0x15, 0x03db);
-                MP_WritePhyUshort(sc, 0x19, 0x9e03);
-                MP_WritePhyUshort(sc, 0x15, 0x03dc);
-                MP_WritePhyUshort(sc, 0x19, 0x7c01);
-                MP_WritePhyUshort(sc, 0x15, 0x03dd);
-                MP_WritePhyUshort(sc, 0x19, 0x4c01);
-                MP_WritePhyUshort(sc, 0x15, 0x03de);
-                MP_WritePhyUshort(sc, 0x19, 0x9af6);
-                MP_WritePhyUshort(sc, 0x15, 0x03df);
-                MP_WritePhyUshort(sc, 0x19, 0x7c12);
-                MP_WritePhyUshort(sc, 0x15, 0x03e0);
-                MP_WritePhyUshort(sc, 0x19, 0x4c52);
-                MP_WritePhyUshort(sc, 0x15, 0x03e1);
-                MP_WritePhyUshort(sc, 0x19, 0x4470);
-                MP_WritePhyUshort(sc, 0x15, 0x03e2);
-                MP_WritePhyUshort(sc, 0x19, 0x7c12);
-                MP_WritePhyUshort(sc, 0x15, 0x03e3);
-                MP_WritePhyUshort(sc, 0x19, 0x4c40);
-                MP_WritePhyUshort(sc, 0x15, 0x03e4);
-                MP_WritePhyUshort(sc, 0x19, 0x33d4);
-                MP_WritePhyUshort(sc, 0x15, 0x03e5);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x03e6);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x03e7);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x03e8);
-                MP_WritePhyUshort(sc, 0x19, 0x0000);
-                MP_WritePhyUshort(sc, 0x15, 0x03e9);
-                MP_WritePhyUshort(sc, 0x19, 0x49bb);
-                MP_WritePhyUshort(sc, 0x15, 0x03ea);
-                MP_WritePhyUshort(sc, 0x19, 0x4478);
-                MP_WritePhyUshort(sc, 0x15, 0x03eb);
-                MP_WritePhyUshort(sc, 0x19, 0x492b);
-                MP_WritePhyUshort(sc, 0x15, 0x03ec);
-                MP_WritePhyUshort(sc, 0x19, 0x6b80);
-                MP_WritePhyUshort(sc, 0x15, 0x03ed);
-                MP_WritePhyUshort(sc, 0x19, 0x7c01);
-                MP_WritePhyUshort(sc, 0x15, 0x03ee);
-                MP_WritePhyUshort(sc, 0x19, 0x4c00);
-                MP_WritePhyUshort(sc, 0x15, 0x03ef);
-                MP_WritePhyUshort(sc, 0x19, 0xd64f);
-                MP_WritePhyUshort(sc, 0x15, 0x03f0);
-                MP_WritePhyUshort(sc, 0x19, 0x000d);
-                MP_WritePhyUshort(sc, 0x15, 0x03f1);
-                MP_WritePhyUshort(sc, 0x19, 0x3311);
-                MP_WritePhyUshort(sc, 0x15, 0x03f2);
-                MP_WritePhyUshort(sc, 0x19, 0xbd0c);
-                MP_WritePhyUshort(sc, 0x15, 0x03f3);
-                MP_WritePhyUshort(sc, 0x19, 0xc428);
-                MP_WritePhyUshort(sc, 0x15, 0x03f4);
-                MP_WritePhyUshort(sc, 0x19, 0x0008);
-                MP_WritePhyUshort(sc, 0x15, 0x03f5);
-                MP_WritePhyUshort(sc, 0x19, 0x9afa);
-                MP_WritePhyUshort(sc, 0x15, 0x03f6);
-                MP_WritePhyUshort(sc, 0x19, 0x7c12);
-                MP_WritePhyUshort(sc, 0x15, 0x03f7);
-                MP_WritePhyUshort(sc, 0x19, 0x4c52);
-                MP_WritePhyUshort(sc, 0x15, 0x03f8);
-                MP_WritePhyUshort(sc, 0x19, 0x4470);
-                MP_WritePhyUshort(sc, 0x15, 0x03f9);
-                MP_WritePhyUshort(sc, 0x19, 0x7c12);
-                MP_WritePhyUshort(sc, 0x15, 0x03fa);
-                MP_WritePhyUshort(sc, 0x19, 0x4c40);
-                MP_WritePhyUshort(sc, 0x15, 0x03fb);
-                MP_WritePhyUshort(sc, 0x19, 0x33ef);
-                MP_WritePhyUshort(sc, 0x15, 0x03fc);
-                MP_WritePhyUshort(sc, 0x19, 0x3342);
-                MP_WritePhyUshort(sc, 0x15, 0x03fd);
-                MP_WritePhyUshort(sc, 0x19, 0x330d);
-                MP_WritePhyUshort(sc, 0x15, 0x03fe);
-                MP_WritePhyUshort(sc, 0x19, 0x32ae);
-                MP_WritePhyUshort(sc, 0x15, 0x0000);
-                MP_WritePhyUshort(sc, 0x16, 0x0306);
-                MP_WritePhyUshort(sc, 0x16, 0x0300);
-                MP_WritePhyUshort(sc, 0x1f, 0x0002);
-                MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                MP_WritePhyUshort(sc, 0x1f, 0x0005);
-                MP_WritePhyUshort(sc, 0x05, 0xfff6);
-                MP_WritePhyUshort(sc, 0x06, 0x0080);
-                MP_WritePhyUshort(sc, 0x05, 0x8000);
-                MP_WritePhyUshort(sc, 0x06, 0x0280);
-                MP_WritePhyUshort(sc, 0x06, 0x48f7);
-                MP_WritePhyUshort(sc, 0x06, 0x00e0);
-                MP_WritePhyUshort(sc, 0x06, 0xfff7);
-                MP_WritePhyUshort(sc, 0x06, 0xa080);
-                MP_WritePhyUshort(sc, 0x06, 0x02ae);
-                MP_WritePhyUshort(sc, 0x06, 0xf602);
-                MP_WritePhyUshort(sc, 0x06, 0x0112);
-                MP_WritePhyUshort(sc, 0x06, 0x0201);
-                MP_WritePhyUshort(sc, 0x06, 0x1f02);
-                MP_WritePhyUshort(sc, 0x06, 0x012c);
-                MP_WritePhyUshort(sc, 0x06, 0x0201);
-                MP_WritePhyUshort(sc, 0x06, 0x3c02);
-                MP_WritePhyUshort(sc, 0x06, 0x0156);
-                MP_WritePhyUshort(sc, 0x06, 0x0201);
-                MP_WritePhyUshort(sc, 0x06, 0x6d02);
-                MP_WritePhyUshort(sc, 0x06, 0x809d);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x88e1);
-                MP_WritePhyUshort(sc, 0x06, 0x8b89);
-                MP_WritePhyUshort(sc, 0x06, 0x1e01);
-                MP_WritePhyUshort(sc, 0x06, 0xe18b);
-                MP_WritePhyUshort(sc, 0x06, 0x8a1e);
-                MP_WritePhyUshort(sc, 0x06, 0x01e1);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8b);
-                MP_WritePhyUshort(sc, 0x06, 0x1e01);
-                MP_WritePhyUshort(sc, 0x06, 0xe18b);
-                MP_WritePhyUshort(sc, 0x06, 0x8c1e);
-                MP_WritePhyUshort(sc, 0x06, 0x01e1);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8d);
-                MP_WritePhyUshort(sc, 0x06, 0x1e01);
-                MP_WritePhyUshort(sc, 0x06, 0xe18b);
-                MP_WritePhyUshort(sc, 0x06, 0x8e1e);
-                MP_WritePhyUshort(sc, 0x06, 0x01a0);
-                MP_WritePhyUshort(sc, 0x06, 0x00c7);
-                MP_WritePhyUshort(sc, 0x06, 0xaebb);
-                MP_WritePhyUshort(sc, 0x06, 0xd100);
-                MP_WritePhyUshort(sc, 0x06, 0xbf82);
-                MP_WritePhyUshort(sc, 0x06, 0xc702);
-                MP_WritePhyUshort(sc, 0x06, 0x320a);
-                MP_WritePhyUshort(sc, 0x06, 0xd105);
-                MP_WritePhyUshort(sc, 0x06, 0xbf82);
-                MP_WritePhyUshort(sc, 0x06, 0xcd02);
-                MP_WritePhyUshort(sc, 0x06, 0x320a);
-                MP_WritePhyUshort(sc, 0x06, 0xd100);
-                MP_WritePhyUshort(sc, 0x06, 0xbf82);
-                MP_WritePhyUshort(sc, 0x06, 0xca02);
-                MP_WritePhyUshort(sc, 0x06, 0x320a);
-                MP_WritePhyUshort(sc, 0x06, 0xd105);
-                MP_WritePhyUshort(sc, 0x06, 0xbf82);
-                MP_WritePhyUshort(sc, 0x06, 0xd002);
-                MP_WritePhyUshort(sc, 0x06, 0x320a);
-                MP_WritePhyUshort(sc, 0x06, 0xd481);
-                MP_WritePhyUshort(sc, 0x06, 0xc9e4);
-                MP_WritePhyUshort(sc, 0x06, 0x8b90);
-                MP_WritePhyUshort(sc, 0x06, 0xe58b);
-                MP_WritePhyUshort(sc, 0x06, 0x91d4);
-                MP_WritePhyUshort(sc, 0x06, 0x81b8);
-                MP_WritePhyUshort(sc, 0x06, 0xe48b);
-                MP_WritePhyUshort(sc, 0x06, 0x92e5);
-                MP_WritePhyUshort(sc, 0x06, 0x8b93);
-                MP_WritePhyUshort(sc, 0x06, 0xbf8b);
-                MP_WritePhyUshort(sc, 0x06, 0x88ec);
-                MP_WritePhyUshort(sc, 0x06, 0x0019);
-                MP_WritePhyUshort(sc, 0x06, 0xa98b);
-                MP_WritePhyUshort(sc, 0x06, 0x90f9);
-                MP_WritePhyUshort(sc, 0x06, 0xeeff);
-                MP_WritePhyUshort(sc, 0x06, 0xf600);
-                MP_WritePhyUshort(sc, 0x06, 0xeeff);
-                MP_WritePhyUshort(sc, 0x06, 0xf7fc);
-                MP_WritePhyUshort(sc, 0x06, 0xd100);
-                MP_WritePhyUshort(sc, 0x06, 0xbf82);
-                MP_WritePhyUshort(sc, 0x06, 0xc102);
-                MP_WritePhyUshort(sc, 0x06, 0x320a);
-                MP_WritePhyUshort(sc, 0x06, 0xd101);
-                MP_WritePhyUshort(sc, 0x06, 0xbf82);
-                MP_WritePhyUshort(sc, 0x06, 0xc402);
-                MP_WritePhyUshort(sc, 0x06, 0x320a);
-                MP_WritePhyUshort(sc, 0x06, 0x04f8);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x8ead);
-                MP_WritePhyUshort(sc, 0x06, 0x201a);
-                MP_WritePhyUshort(sc, 0x06, 0xf620);
-                MP_WritePhyUshort(sc, 0x06, 0xe48b);
-                MP_WritePhyUshort(sc, 0x06, 0x8e02);
-                MP_WritePhyUshort(sc, 0x06, 0x824b);
-                MP_WritePhyUshort(sc, 0x06, 0x0281);
-                MP_WritePhyUshort(sc, 0x06, 0x1902);
-                MP_WritePhyUshort(sc, 0x06, 0x2c9d);
-                MP_WritePhyUshort(sc, 0x06, 0x0203);
-                MP_WritePhyUshort(sc, 0x06, 0x9602);
-                MP_WritePhyUshort(sc, 0x06, 0x0473);
-                MP_WritePhyUshort(sc, 0x06, 0x022e);
-                MP_WritePhyUshort(sc, 0x06, 0x3902);
-                MP_WritePhyUshort(sc, 0x06, 0x044d);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x8ead);
-                MP_WritePhyUshort(sc, 0x06, 0x210b);
-                MP_WritePhyUshort(sc, 0x06, 0xf621);
-                MP_WritePhyUshort(sc, 0x06, 0xe48b);
-                MP_WritePhyUshort(sc, 0x06, 0x8e02);
-                MP_WritePhyUshort(sc, 0x06, 0x0416);
-                MP_WritePhyUshort(sc, 0x06, 0x021b);
-                MP_WritePhyUshort(sc, 0x06, 0xa4e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8e);
-                MP_WritePhyUshort(sc, 0x06, 0xad22);
-                MP_WritePhyUshort(sc, 0x06, 0x05f6);
-                MP_WritePhyUshort(sc, 0x06, 0x22e4);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8e);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x8ead);
-                MP_WritePhyUshort(sc, 0x06, 0x2305);
-                MP_WritePhyUshort(sc, 0x06, 0xf623);
-                MP_WritePhyUshort(sc, 0x06, 0xe48b);
-                MP_WritePhyUshort(sc, 0x06, 0x8ee0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8e);
-                MP_WritePhyUshort(sc, 0x06, 0xad24);
-                MP_WritePhyUshort(sc, 0x06, 0x05f6);
-                MP_WritePhyUshort(sc, 0x06, 0x24e4);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8e);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x8ead);
-                MP_WritePhyUshort(sc, 0x06, 0x2505);
-                MP_WritePhyUshort(sc, 0x06, 0xf625);
-                MP_WritePhyUshort(sc, 0x06, 0xe48b);
-                MP_WritePhyUshort(sc, 0x06, 0x8ee0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8e);
-                MP_WritePhyUshort(sc, 0x06, 0xad26);
-                MP_WritePhyUshort(sc, 0x06, 0x08f6);
-                MP_WritePhyUshort(sc, 0x06, 0x26e4);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8e);
-                MP_WritePhyUshort(sc, 0x06, 0x0281);
-                MP_WritePhyUshort(sc, 0x06, 0xdae0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8e);
-                MP_WritePhyUshort(sc, 0x06, 0xad27);
-                MP_WritePhyUshort(sc, 0x06, 0x05f6);
-                MP_WritePhyUshort(sc, 0x06, 0x27e4);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8e);
-                MP_WritePhyUshort(sc, 0x06, 0x0203);
-                MP_WritePhyUshort(sc, 0x06, 0x5cfc);
-                MP_WritePhyUshort(sc, 0x06, 0x04f8);
-                MP_WritePhyUshort(sc, 0x06, 0xfaef);
-                MP_WritePhyUshort(sc, 0x06, 0x69e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b85);
-                MP_WritePhyUshort(sc, 0x06, 0xad21);
-                MP_WritePhyUshort(sc, 0x06, 0x57e0);
-                MP_WritePhyUshort(sc, 0x06, 0xe022);
-                MP_WritePhyUshort(sc, 0x06, 0xe1e0);
-                MP_WritePhyUshort(sc, 0x06, 0x2358);
-                MP_WritePhyUshort(sc, 0x06, 0xc059);
-                MP_WritePhyUshort(sc, 0x06, 0x021e);
-                MP_WritePhyUshort(sc, 0x06, 0x01e1);
-                MP_WritePhyUshort(sc, 0x06, 0x8b3c);
-                MP_WritePhyUshort(sc, 0x06, 0x1f10);
-                MP_WritePhyUshort(sc, 0x06, 0x9e44);
-                MP_WritePhyUshort(sc, 0x06, 0xe48b);
-                MP_WritePhyUshort(sc, 0x06, 0x3cad);
-                MP_WritePhyUshort(sc, 0x06, 0x211d);
-                MP_WritePhyUshort(sc, 0x06, 0xe18b);
-                MP_WritePhyUshort(sc, 0x06, 0x84f7);
-                MP_WritePhyUshort(sc, 0x06, 0x29e5);
-                MP_WritePhyUshort(sc, 0x06, 0x8b84);
-                MP_WritePhyUshort(sc, 0x06, 0xac27);
-                MP_WritePhyUshort(sc, 0x06, 0x0dac);
-                MP_WritePhyUshort(sc, 0x06, 0x2605);
-                MP_WritePhyUshort(sc, 0x06, 0x0281);
-                MP_WritePhyUshort(sc, 0x06, 0x7fae);
-                MP_WritePhyUshort(sc, 0x06, 0x2b02);
-                MP_WritePhyUshort(sc, 0x06, 0x2c23);
-                MP_WritePhyUshort(sc, 0x06, 0xae26);
-                MP_WritePhyUshort(sc, 0x06, 0x022c);
-                MP_WritePhyUshort(sc, 0x06, 0x41ae);
-                MP_WritePhyUshort(sc, 0x06, 0x21e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b87);
-                MP_WritePhyUshort(sc, 0x06, 0xad22);
-                MP_WritePhyUshort(sc, 0x06, 0x18e0);
-                MP_WritePhyUshort(sc, 0x06, 0xfff7);
-                MP_WritePhyUshort(sc, 0x06, 0x58fc);
-                MP_WritePhyUshort(sc, 0x06, 0xe4ff);
-                MP_WritePhyUshort(sc, 0x06, 0xf7d1);
-                MP_WritePhyUshort(sc, 0x06, 0x00bf);
-                MP_WritePhyUshort(sc, 0x06, 0x2eee);
-                MP_WritePhyUshort(sc, 0x06, 0x0232);
-                MP_WritePhyUshort(sc, 0x06, 0x0ad1);
-                MP_WritePhyUshort(sc, 0x06, 0x00bf);
-                MP_WritePhyUshort(sc, 0x06, 0x82e8);
-                MP_WritePhyUshort(sc, 0x06, 0x0232);
-                MP_WritePhyUshort(sc, 0x06, 0x0a02);
-                MP_WritePhyUshort(sc, 0x06, 0x2bdf);
-                MP_WritePhyUshort(sc, 0x06, 0xef96);
-                MP_WritePhyUshort(sc, 0x06, 0xfefc);
-                MP_WritePhyUshort(sc, 0x06, 0x04d0);
-                MP_WritePhyUshort(sc, 0x06, 0x0202);
-                MP_WritePhyUshort(sc, 0x06, 0x1e97);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x87ad);
-                MP_WritePhyUshort(sc, 0x06, 0x2228);
-                MP_WritePhyUshort(sc, 0x06, 0xd100);
-                MP_WritePhyUshort(sc, 0x06, 0xbf82);
-                MP_WritePhyUshort(sc, 0x06, 0xd302);
-                MP_WritePhyUshort(sc, 0x06, 0x320a);
-                MP_WritePhyUshort(sc, 0x06, 0xd10c);
-                MP_WritePhyUshort(sc, 0x06, 0xbf82);
-                MP_WritePhyUshort(sc, 0x06, 0xd602);
-                MP_WritePhyUshort(sc, 0x06, 0x320a);
-                MP_WritePhyUshort(sc, 0x06, 0xd104);
-                MP_WritePhyUshort(sc, 0x06, 0xbf82);
-                MP_WritePhyUshort(sc, 0x06, 0xd902);
-                MP_WritePhyUshort(sc, 0x06, 0x320a);
-                MP_WritePhyUshort(sc, 0x06, 0xd101);
-                MP_WritePhyUshort(sc, 0x06, 0xbf82);
-                MP_WritePhyUshort(sc, 0x06, 0xe802);
-                MP_WritePhyUshort(sc, 0x06, 0x320a);
-                MP_WritePhyUshort(sc, 0x06, 0xe0ff);
-                MP_WritePhyUshort(sc, 0x06, 0xf768);
-                MP_WritePhyUshort(sc, 0x06, 0x03e4);
-                MP_WritePhyUshort(sc, 0x06, 0xfff7);
-                MP_WritePhyUshort(sc, 0x06, 0xd004);
-                MP_WritePhyUshort(sc, 0x06, 0x0228);
-                MP_WritePhyUshort(sc, 0x06, 0x7a04);
-                MP_WritePhyUshort(sc, 0x06, 0xf8e0);
-                MP_WritePhyUshort(sc, 0x06, 0xe234);
-                MP_WritePhyUshort(sc, 0x06, 0xe1e2);
-                MP_WritePhyUshort(sc, 0x06, 0x35f6);
-                MP_WritePhyUshort(sc, 0x06, 0x2be4);
-                MP_WritePhyUshort(sc, 0x06, 0xe234);
-                MP_WritePhyUshort(sc, 0x06, 0xe5e2);
-                MP_WritePhyUshort(sc, 0x06, 0x35fc);
-                MP_WritePhyUshort(sc, 0x06, 0x05f8);
-                MP_WritePhyUshort(sc, 0x06, 0xe0e2);
-                MP_WritePhyUshort(sc, 0x06, 0x34e1);
-                MP_WritePhyUshort(sc, 0x06, 0xe235);
-                MP_WritePhyUshort(sc, 0x06, 0xf72b);
-                MP_WritePhyUshort(sc, 0x06, 0xe4e2);
-                MP_WritePhyUshort(sc, 0x06, 0x34e5);
-                MP_WritePhyUshort(sc, 0x06, 0xe235);
-                MP_WritePhyUshort(sc, 0x06, 0xfc05);
-                MP_WritePhyUshort(sc, 0x06, 0xf8f9);
-                MP_WritePhyUshort(sc, 0x06, 0xfaef);
-                MP_WritePhyUshort(sc, 0x06, 0x69ac);
-                MP_WritePhyUshort(sc, 0x06, 0x1b4c);
-                MP_WritePhyUshort(sc, 0x06, 0xbf2e);
-                MP_WritePhyUshort(sc, 0x06, 0x3002);
-                MP_WritePhyUshort(sc, 0x06, 0x31dd);
-                MP_WritePhyUshort(sc, 0x06, 0xef01);
-                MP_WritePhyUshort(sc, 0x06, 0xe28a);
-                MP_WritePhyUshort(sc, 0x06, 0x76e4);
-                MP_WritePhyUshort(sc, 0x06, 0x8a76);
-                MP_WritePhyUshort(sc, 0x06, 0x1f12);
-                MP_WritePhyUshort(sc, 0x06, 0x9e3a);
-                MP_WritePhyUshort(sc, 0x06, 0xef12);
-                MP_WritePhyUshort(sc, 0x06, 0x5907);
-                MP_WritePhyUshort(sc, 0x06, 0x9f12);
-                MP_WritePhyUshort(sc, 0x06, 0xf8e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b40);
-                MP_WritePhyUshort(sc, 0x06, 0xf721);
-                MP_WritePhyUshort(sc, 0x06, 0xe48b);
-                MP_WritePhyUshort(sc, 0x06, 0x40d0);
-                MP_WritePhyUshort(sc, 0x06, 0x0302);
-                MP_WritePhyUshort(sc, 0x06, 0x287a);
-                MP_WritePhyUshort(sc, 0x06, 0x0282);
-                MP_WritePhyUshort(sc, 0x06, 0x34fc);
-                MP_WritePhyUshort(sc, 0x06, 0xa000);
-                MP_WritePhyUshort(sc, 0x06, 0x1002);
-                MP_WritePhyUshort(sc, 0x06, 0x2dc3);
-                MP_WritePhyUshort(sc, 0x06, 0x022e);
-                MP_WritePhyUshort(sc, 0x06, 0x21e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b40);
-                MP_WritePhyUshort(sc, 0x06, 0xf621);
-                MP_WritePhyUshort(sc, 0x06, 0xe48b);
-                MP_WritePhyUshort(sc, 0x06, 0x40ae);
-                MP_WritePhyUshort(sc, 0x06, 0x0fbf);
-                MP_WritePhyUshort(sc, 0x06, 0x3fa5);
-                MP_WritePhyUshort(sc, 0x06, 0x0231);
-                MP_WritePhyUshort(sc, 0x06, 0x6cbf);
-                MP_WritePhyUshort(sc, 0x06, 0x3fa2);
-                MP_WritePhyUshort(sc, 0x06, 0x0231);
-                MP_WritePhyUshort(sc, 0x06, 0x6c02);
-                MP_WritePhyUshort(sc, 0x06, 0x2dc3);
-                MP_WritePhyUshort(sc, 0x06, 0xef96);
-                MP_WritePhyUshort(sc, 0x06, 0xfefd);
-                MP_WritePhyUshort(sc, 0x06, 0xfc04);
-                MP_WritePhyUshort(sc, 0x06, 0xf8e0);
-                MP_WritePhyUshort(sc, 0x06, 0xe2f4);
-                MP_WritePhyUshort(sc, 0x06, 0xe1e2);
-                MP_WritePhyUshort(sc, 0x06, 0xf5e4);
-                MP_WritePhyUshort(sc, 0x06, 0x8a78);
-                MP_WritePhyUshort(sc, 0x06, 0xe58a);
-                MP_WritePhyUshort(sc, 0x06, 0x79ee);
-                MP_WritePhyUshort(sc, 0x06, 0xe2f4);
-                MP_WritePhyUshort(sc, 0x06, 0xd8ee);
-                MP_WritePhyUshort(sc, 0x06, 0xe2f5);
-                MP_WritePhyUshort(sc, 0x06, 0x20fc);
-                MP_WritePhyUshort(sc, 0x06, 0x04f8);
-                MP_WritePhyUshort(sc, 0x06, 0xf9fa);
-                MP_WritePhyUshort(sc, 0x06, 0xef69);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x87ad);
-                MP_WritePhyUshort(sc, 0x06, 0x2065);
-                MP_WritePhyUshort(sc, 0x06, 0xd200);
-                MP_WritePhyUshort(sc, 0x06, 0xbf2e);
-                MP_WritePhyUshort(sc, 0x06, 0xe802);
-                MP_WritePhyUshort(sc, 0x06, 0x31dd);
-                MP_WritePhyUshort(sc, 0x06, 0x1e21);
-                MP_WritePhyUshort(sc, 0x06, 0xbf82);
-                MP_WritePhyUshort(sc, 0x06, 0xdf02);
-                MP_WritePhyUshort(sc, 0x06, 0x31dd);
-                MP_WritePhyUshort(sc, 0x06, 0x0c11);
-                MP_WritePhyUshort(sc, 0x06, 0x1e21);
-                MP_WritePhyUshort(sc, 0x06, 0xbf82);
-                MP_WritePhyUshort(sc, 0x06, 0xe202);
-                MP_WritePhyUshort(sc, 0x06, 0x31dd);
-                MP_WritePhyUshort(sc, 0x06, 0x0c12);
-                MP_WritePhyUshort(sc, 0x06, 0x1e21);
-                MP_WritePhyUshort(sc, 0x06, 0xbf82);
-                MP_WritePhyUshort(sc, 0x06, 0xe502);
-                MP_WritePhyUshort(sc, 0x06, 0x31dd);
-                MP_WritePhyUshort(sc, 0x06, 0x0c13);
-                MP_WritePhyUshort(sc, 0x06, 0x1e21);
-                MP_WritePhyUshort(sc, 0x06, 0xbf1f);
-                MP_WritePhyUshort(sc, 0x06, 0x5302);
-                MP_WritePhyUshort(sc, 0x06, 0x31dd);
-                MP_WritePhyUshort(sc, 0x06, 0x0c14);
-                MP_WritePhyUshort(sc, 0x06, 0x1e21);
-                MP_WritePhyUshort(sc, 0x06, 0xbf82);
-                MP_WritePhyUshort(sc, 0x06, 0xeb02);
-                MP_WritePhyUshort(sc, 0x06, 0x31dd);
-                MP_WritePhyUshort(sc, 0x06, 0x0c16);
-                MP_WritePhyUshort(sc, 0x06, 0x1e21);
-                MP_WritePhyUshort(sc, 0x06, 0xe083);
-                MP_WritePhyUshort(sc, 0x06, 0xe01f);
-                MP_WritePhyUshort(sc, 0x06, 0x029e);
-                MP_WritePhyUshort(sc, 0x06, 0x22e6);
-                MP_WritePhyUshort(sc, 0x06, 0x83e0);
-                MP_WritePhyUshort(sc, 0x06, 0xad31);
-                MP_WritePhyUshort(sc, 0x06, 0x14ad);
-                MP_WritePhyUshort(sc, 0x06, 0x3011);
-                MP_WritePhyUshort(sc, 0x06, 0xef02);
-                MP_WritePhyUshort(sc, 0x06, 0x580c);
-                MP_WritePhyUshort(sc, 0x06, 0x9e07);
-                MP_WritePhyUshort(sc, 0x06, 0xad36);
-                MP_WritePhyUshort(sc, 0x06, 0x085a);
-                MP_WritePhyUshort(sc, 0x06, 0x309f);
-                MP_WritePhyUshort(sc, 0x06, 0x04d1);
-                MP_WritePhyUshort(sc, 0x06, 0x01ae);
-                MP_WritePhyUshort(sc, 0x06, 0x02d1);
-                MP_WritePhyUshort(sc, 0x06, 0x00bf);
-                MP_WritePhyUshort(sc, 0x06, 0x82dc);
-                MP_WritePhyUshort(sc, 0x06, 0x0232);
-                MP_WritePhyUshort(sc, 0x06, 0x0aef);
-                MP_WritePhyUshort(sc, 0x06, 0x96fe);
-                MP_WritePhyUshort(sc, 0x06, 0xfdfc);
-                MP_WritePhyUshort(sc, 0x06, 0x0400);
-                MP_WritePhyUshort(sc, 0x06, 0xe140);
-                MP_WritePhyUshort(sc, 0x06, 0x77e1);
-                MP_WritePhyUshort(sc, 0x06, 0x4010);
-                MP_WritePhyUshort(sc, 0x06, 0xe150);
-                MP_WritePhyUshort(sc, 0x06, 0x32e1);
-                MP_WritePhyUshort(sc, 0x06, 0x5030);
-                MP_WritePhyUshort(sc, 0x06, 0xe144);
-                MP_WritePhyUshort(sc, 0x06, 0x74e1);
-                MP_WritePhyUshort(sc, 0x06, 0x44bb);
-                MP_WritePhyUshort(sc, 0x06, 0xe2d2);
-                MP_WritePhyUshort(sc, 0x06, 0x40e0);
-                MP_WritePhyUshort(sc, 0x06, 0x2cfc);
-                MP_WritePhyUshort(sc, 0x06, 0xe2cc);
-                MP_WritePhyUshort(sc, 0x06, 0xcce2);
-                MP_WritePhyUshort(sc, 0x06, 0x00cc);
-                MP_WritePhyUshort(sc, 0x06, 0xe000);
-                MP_WritePhyUshort(sc, 0x06, 0x99e0);
-                MP_WritePhyUshort(sc, 0x06, 0x3688);
-                MP_WritePhyUshort(sc, 0x06, 0xe036);
-                MP_WritePhyUshort(sc, 0x06, 0x99e1);
-                MP_WritePhyUshort(sc, 0x06, 0x40dd);
-                MP_WritePhyUshort(sc, 0x06, 0xe022);
-                MP_WritePhyUshort(sc, 0x05, 0xe142);
-                Data = MP_ReadPhyUshort(sc, 0x06);
-                Data |= BIT_0;
-                MP_WritePhyUshort(sc, 0x06, Data);
-                MP_WritePhyUshort(sc, 0x05, 0xe140);
-                Data = MP_ReadPhyUshort(sc, 0x06);
-                Data |= BIT_0;
-                MP_WritePhyUshort(sc, 0x06, Data);
-                MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                MP_WritePhyUshort(sc, 0x1f, 0x0005);
-                for (i = 0; i < 200; i++) {
-                        DELAY(100);
-                        Data = MP_ReadPhyUshort(sc, 0x00);
-                        if (Data & BIT_7)
-                                break;
-                }
-                MP_WritePhyUshort(sc, 0x1f, 0x0004);
-                MP_WritePhyUshort(sc, 0x1f, 0x0007);
-                MP_WritePhyUshort(sc, 0x1e, 0x0023);
-                Data = MP_ReadPhyUshort(sc, 0x17);
-                Data &= ~BIT_0;
-                Data |= BIT_2;
-                MP_WritePhyUshort(sc, 0x17, Data);
-                MP_WritePhyUshort(sc, 0x1f, 0x0002);
-                MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                MP_WritePhyUshort(sc, 0x1F, 0x0003);
-                MP_WritePhyUshort(sc, 0x09, 0xA20F);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-                MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                MP_WritePhyUshort(sc, 0x00, 0x9200);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0005);
-                MP_WritePhyUshort(sc, 0x05, 0x8B80);
-                Data = MP_ReadPhyUshort(sc, 0x06);
-                Data |= BIT_2 | BIT_1;
-                MP_WritePhyUshort(sc, 0x06, Data);
-                MP_WritePhyUshort(sc, 0x1f, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1f, 0x0004);
-                MP_WritePhyUshort(sc, 0x1f, 0x0007);
-                MP_WritePhyUshort(sc, 0x1e, 0x002D);
-                Data = MP_ReadPhyUshort(sc, 0x18);
-                Data |= BIT_4;
-                MP_WritePhyUshort(sc, 0x18, Data);
-                MP_WritePhyUshort(sc, 0x1f, 0x0002);
-                MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                Data = MP_ReadPhyUshort(sc, 0x14);
-                Data |= BIT_15;
-                MP_WritePhyUshort(sc, 0x14, Data);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0005);
-                MP_WritePhyUshort(sc, 0x05, 0x8B86);
-                Data = MP_ReadPhyUshort(sc, 0x06);
-                Data |= BIT_0;
-                MP_WritePhyUshort(sc, 0x06, Data);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0001);
-                MP_WritePhyUshort(sc, 0x0B, 0x6C14);
-                MP_WritePhyUshort(sc, 0x14, 0x7F3D);
-                MP_WritePhyUshort(sc, 0x1C, 0xFAFE);
-                MP_WritePhyUshort(sc, 0x08, 0x07C5);
-                MP_WritePhyUshort(sc, 0x10, 0xF090);
-                MP_WritePhyUshort(sc, 0x1F, 0x0003);
-                MP_WritePhyUshort(sc, 0x14, 0x641A);
-                MP_WritePhyUshort(sc, 0x1A, 0x0606);
-                MP_WritePhyUshort(sc, 0x12, 0xF480);
-                MP_WritePhyUshort(sc, 0x13, 0x0747);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0004);
-                MP_WritePhyUshort(sc, 0x1F, 0x0007);
-                MP_WritePhyUshort(sc, 0x1E, 0x0078);
-                MP_WritePhyUshort(sc, 0x15, 0xA408);
-                MP_WritePhyUshort(sc, 0x17, 0x5100);
-                MP_WritePhyUshort(sc, 0x19, 0x0008);
-                MP_WritePhyUshort(sc, 0x1F, 0x0002);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0003);
-                MP_WritePhyUshort(sc, 0x0D, 0x0207);
-                MP_WritePhyUshort(sc, 0x02, 0x5FD0);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0004);
-                MP_WritePhyUshort(sc, 0x1F, 0x0007);
-                MP_WritePhyUshort(sc, 0x1E, 0x00A1);
-                Data = MP_ReadPhyUshort(sc, 0x1A);
-                Data &= ~BIT_2;
-                MP_WritePhyUshort(sc, 0x1A, Data);
-                MP_WritePhyUshort(sc, 0x1F, 0x0002);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0004);
-                MP_WritePhyUshort(sc, 0x1F, 0x0007);
-                MP_WritePhyUshort(sc, 0x1E, 0x002D);
-                Data = MP_ReadPhyUshort(sc, 0x16);
-                Data |= BIT_5;
-                MP_WritePhyUshort(sc, 0x16, Data);
-                MP_WritePhyUshort(sc, 0x1F, 0x0002);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0004);
-                MP_WritePhyUshort(sc, 0x1F, 0x0007);
-                MP_WritePhyUshort(sc, 0x1E, 0x00AC);
-                MP_WritePhyUshort(sc, 0x18, 0x0006);
-                MP_WritePhyUshort(sc, 0x1F, 0x0002);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0003);
-                MP_WritePhyUshort(sc, 0x09, 0xA20F);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0005);
-                MP_WritePhyUshort(sc, 0x05, 0x8B85);
-                Data = MP_ReadPhyUshort(sc, 0x06);
-                Data |= BIT_14;
-                MP_WritePhyUshort(sc, 0x06, Data);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0005);
-                MP_WritePhyUshort(sc, 0x05, 0x8B54);
-                Data = MP_ReadPhyUshort(sc, 0x06);
-                Data &= ~BIT_11;
-                MP_WritePhyUshort(sc, 0x06, Data);
-                MP_WritePhyUshort(sc, 0x05, 0x8B5D);
-                Data = MP_ReadPhyUshort(sc, 0x06);
-                Data &= ~BIT_11;
-                MP_WritePhyUshort(sc, 0x06, Data);
-                MP_WritePhyUshort(sc, 0x05, 0x8A7C);
-                Data = MP_ReadPhyUshort(sc, 0x06);
-                Data &= ~BIT_8;
-                MP_WritePhyUshort(sc, 0x06, Data);
-                MP_WritePhyUshort(sc, 0x05, 0x8A7F);
-                Data = MP_ReadPhyUshort(sc, 0x06);
-                Data |= BIT_8;
-                MP_WritePhyUshort(sc, 0x06, Data);
-                MP_WritePhyUshort(sc, 0x05, 0x8A82);
-                Data = MP_ReadPhyUshort(sc, 0x06);
-                Data &= ~BIT_8;
-                MP_WritePhyUshort(sc, 0x06, Data);
-                MP_WritePhyUshort(sc, 0x05, 0x8A85);
-                Data = MP_ReadPhyUshort(sc, 0x06);
-                Data &= ~BIT_8;
-                MP_WritePhyUshort(sc, 0x06, Data);
-                MP_WritePhyUshort(sc, 0x05, 0x8A88);
-                Data = MP_ReadPhyUshort(sc, 0x06);
-                Data &= ~BIT_8;
-                MP_WritePhyUshort(sc, 0x06, Data);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0005);
-                MP_WritePhyUshort(sc, 0x05, 0x8B85);
-                Data = MP_ReadPhyUshort(sc, 0x06);
-                Data |= BIT_15;
-                MP_WritePhyUshort(sc, 0x06, Data);
-                MP_WritePhyUshort(sc, 0x1f, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1f, 0x0003);
-                Data = MP_ReadPhyUshort(sc, 0x19);
-                Data &= ~BIT_0;
-                MP_WritePhyUshort(sc, 0x19, Data);
-                Data = MP_ReadPhyUshort(sc, 0x10);
-                Data &= ~BIT_10;
-                MP_WritePhyUshort(sc, 0x10, Data);
-                MP_WritePhyUshort(sc, 0x1f, 0x0000);
-        } else if (sc->re_type == MACFG_39) {
-                Data_u32 = re_eri_read(sc, 0x1D0, 4, ERIAR_ExGMAC);
-                Data_u32 &= ~BIT_1;
-                re_eri_write(sc, 0x1D0, 4, Data_u32, ERIAR_ExGMAC);
-
-                MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                MP_WritePhyUshort(sc, 0x00, 0x1800);
-                Data = MP_ReadPhyUshort(sc, 0x15);
-                Data &= ~(BIT_12);
-                MP_WritePhyUshort(sc, 0x15, Data);
-                MP_WritePhyUshort(sc, 0x00, 0x4800);
-                MP_WritePhyUshort(sc, 0x1f, 0x0007);
-                MP_WritePhyUshort(sc, 0x1e, 0x002f);
-                for (i = 0; i < 1000; i++) {
-                        if (MP_ReadPhyUshort(sc, 0x1c) & BIT_7)
-                                break;
-                        DELAY(100);
-                }
-                MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                MP_WritePhyUshort(sc, 0x00, 0x1800);
-                MP_WritePhyUshort(sc, 0x1f, 0x0007);
-                MP_WritePhyUshort(sc, 0x1e, 0x0023);
-                for (i = 0; i < 200; i++) {
-                        if ((MP_ReadPhyUshort(sc, 0x17) & BIT_0) == 0)
-                                break;
-                        DELAY(100);
-                }
-                MP_WritePhyUshort(sc, 0x1f, 0x0005);
-                MP_WritePhyUshort(sc, 0x05, 0xfff6);
-                MP_WritePhyUshort(sc, 0x06, 0x0080);
-                MP_WritePhyUshort(sc, 0x1f, 0x0007);
-                MP_WritePhyUshort(sc, 0x1e, 0x0023);
-                MP_WritePhyUshort(sc, 0x16, 0x0306);
-                MP_WritePhyUshort(sc, 0x16, 0x0307);
-                MP_WritePhyUshort(sc, 0x15, 0x00AF);
-                MP_WritePhyUshort(sc, 0x19, 0x4060);
-                MP_WritePhyUshort(sc, 0x15, 0x00B0);
-                MP_WritePhyUshort(sc, 0x19, 0x7800);
-                MP_WritePhyUshort(sc, 0x15, 0x00B1);
-                MP_WritePhyUshort(sc, 0x19, 0x7e00);
-                MP_WritePhyUshort(sc, 0x15, 0x00B2);
-                MP_WritePhyUshort(sc, 0x19, 0x72B0);
-                MP_WritePhyUshort(sc, 0x15, 0x00B3);
-                MP_WritePhyUshort(sc, 0x19, 0x7F00);
-                MP_WritePhyUshort(sc, 0x15, 0x00B4);
-                MP_WritePhyUshort(sc, 0x19, 0x73B0);
-                MP_WritePhyUshort(sc, 0x15, 0x0101);
-                MP_WritePhyUshort(sc, 0x19, 0x0005);
-                MP_WritePhyUshort(sc, 0x15, 0x0103);
-                MP_WritePhyUshort(sc, 0x19, 0x0003);
-                MP_WritePhyUshort(sc, 0x15, 0x0105);
-                MP_WritePhyUshort(sc, 0x19, 0x30FD);
-                MP_WritePhyUshort(sc, 0x15, 0x0106);
-                MP_WritePhyUshort(sc, 0x19, 0x9DF7);
-                MP_WritePhyUshort(sc, 0x15, 0x0107);
-                MP_WritePhyUshort(sc, 0x19, 0x30C6);
-                MP_WritePhyUshort(sc, 0x15, 0x0098);
-                MP_WritePhyUshort(sc, 0x19, 0x7c0b);
-                MP_WritePhyUshort(sc, 0x15, 0x0099);
-                MP_WritePhyUshort(sc, 0x19, 0x6c0b);
-                MP_WritePhyUshort(sc, 0x15, 0x00eb);
-                MP_WritePhyUshort(sc, 0x19, 0x6c0b);
-                MP_WritePhyUshort(sc, 0x15, 0x00f8);
-                MP_WritePhyUshort(sc, 0x19, 0x6f0b);
-                MP_WritePhyUshort(sc, 0x15, 0x00fe);
-                MP_WritePhyUshort(sc, 0x19, 0x6f0f);
-                MP_WritePhyUshort(sc, 0x15, 0x00db);
-                MP_WritePhyUshort(sc, 0x19, 0x6f09);
-                MP_WritePhyUshort(sc, 0x15, 0x00dc);
-                MP_WritePhyUshort(sc, 0x19, 0xaefd);
-                MP_WritePhyUshort(sc, 0x15, 0x00dd);
-                MP_WritePhyUshort(sc, 0x19, 0x6f0b);
-                MP_WritePhyUshort(sc, 0x15, 0x00de);
-                MP_WritePhyUshort(sc, 0x19, 0xc60b);
-                MP_WritePhyUshort(sc, 0x15, 0x00df);
-                MP_WritePhyUshort(sc, 0x19, 0x00fa);
-                MP_WritePhyUshort(sc, 0x15, 0x00e0);
-                MP_WritePhyUshort(sc, 0x19, 0x30e1);
-                MP_WritePhyUshort(sc, 0x15, 0x020c);
-                MP_WritePhyUshort(sc, 0x19, 0x3224);
-                MP_WritePhyUshort(sc, 0x15, 0x020e);
-                MP_WritePhyUshort(sc, 0x19, 0x9813);
-                MP_WritePhyUshort(sc, 0x15, 0x020f);
-                MP_WritePhyUshort(sc, 0x19, 0x7801);
-                MP_WritePhyUshort(sc, 0x15, 0x0210);
-                MP_WritePhyUshort(sc, 0x19, 0x930f);
-                MP_WritePhyUshort(sc, 0x15, 0x0211);
-                MP_WritePhyUshort(sc, 0x19, 0x9206);
-                MP_WritePhyUshort(sc, 0x15, 0x0212);
-                MP_WritePhyUshort(sc, 0x19, 0x4002);
-                MP_WritePhyUshort(sc, 0x15, 0x0213);
-                MP_WritePhyUshort(sc, 0x19, 0x7800);
-                MP_WritePhyUshort(sc, 0x15, 0x0214);
-                MP_WritePhyUshort(sc, 0x19, 0x588f);
-                MP_WritePhyUshort(sc, 0x15, 0x0215);
-                MP_WritePhyUshort(sc, 0x19, 0x5520);
-                MP_WritePhyUshort(sc, 0x15, 0x0216);
-                MP_WritePhyUshort(sc, 0x19, 0x3224);
-                MP_WritePhyUshort(sc, 0x15, 0x0217);
-                MP_WritePhyUshort(sc, 0x19, 0x4002);
-                MP_WritePhyUshort(sc, 0x15, 0x0218);
-                MP_WritePhyUshort(sc, 0x19, 0x7800);
-                MP_WritePhyUshort(sc, 0x15, 0x0219);
-                MP_WritePhyUshort(sc, 0x19, 0x588d);
-                MP_WritePhyUshort(sc, 0x15, 0x021a);
-                MP_WritePhyUshort(sc, 0x19, 0x5540);
-                MP_WritePhyUshort(sc, 0x15, 0x021b);
-                MP_WritePhyUshort(sc, 0x19, 0x9e03);
-                MP_WritePhyUshort(sc, 0x15, 0x021c);
-                MP_WritePhyUshort(sc, 0x19, 0x7c40);
-                MP_WritePhyUshort(sc, 0x15, 0x021d);
-                MP_WritePhyUshort(sc, 0x19, 0x6840);
-                MP_WritePhyUshort(sc, 0x15, 0x021e);
-                MP_WritePhyUshort(sc, 0x19, 0x3224);
-                MP_WritePhyUshort(sc, 0x15, 0x021f);
-                MP_WritePhyUshort(sc, 0x19, 0x4002);
-                MP_WritePhyUshort(sc, 0x15, 0x0220);
-                MP_WritePhyUshort(sc, 0x19, 0x3224);
-                MP_WritePhyUshort(sc, 0x15, 0x0221);
-                MP_WritePhyUshort(sc, 0x19, 0x9e03);
-                MP_WritePhyUshort(sc, 0x15, 0x0222);
-                MP_WritePhyUshort(sc, 0x19, 0x7c40);
-                MP_WritePhyUshort(sc, 0x15, 0x0223);
-                MP_WritePhyUshort(sc, 0x19, 0x6840);
-                MP_WritePhyUshort(sc, 0x15, 0x0224);
-                MP_WritePhyUshort(sc, 0x19, 0x7800);
-                MP_WritePhyUshort(sc, 0x15, 0x0225);
-                MP_WritePhyUshort(sc, 0x19, 0x3231);
-                MP_WritePhyUshort(sc, 0x15, 0x0000);
-                MP_WritePhyUshort(sc, 0x16, 0x0306);
-                MP_WritePhyUshort(sc, 0x16, 0x0300);
-                MP_WritePhyUshort(sc, 0x1f, 0x0002);
-                MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                MP_WritePhyUshort(sc, 0x17, 0x2160);
-                MP_WritePhyUshort(sc, 0x1f, 0x0007);
-                MP_WritePhyUshort(sc, 0x1e, 0x0040);
-                MP_WritePhyUshort(sc, 0x18, 0x0004);
-                MP_WritePhyUshort(sc, 0x18, 0x09d4);
-                MP_WritePhyUshort(sc, 0x19, 0x4000);
-                MP_WritePhyUshort(sc, 0x18, 0x09e4);
-                MP_WritePhyUshort(sc, 0x19, 0x0800);
-                MP_WritePhyUshort(sc, 0x18, 0x09f4);
-                MP_WritePhyUshort(sc, 0x19, 0xff00);
-                MP_WritePhyUshort(sc, 0x18, 0x0a04);
-                MP_WritePhyUshort(sc, 0x19, 0x4000);
-                MP_WritePhyUshort(sc, 0x18, 0x0a14);
-                MP_WritePhyUshort(sc, 0x19, 0x0c00);
-                MP_WritePhyUshort(sc, 0x18, 0x0a24);
-                MP_WritePhyUshort(sc, 0x19, 0xff00);
-                MP_WritePhyUshort(sc, 0x18, 0x0a74);
-                MP_WritePhyUshort(sc, 0x19, 0xf600);
-                MP_WritePhyUshort(sc, 0x18, 0x1a24);
-                MP_WritePhyUshort(sc, 0x19, 0x7d00);
-                MP_WritePhyUshort(sc, 0x18, 0x1a64);
-                MP_WritePhyUshort(sc, 0x19, 0x0500);
-                MP_WritePhyUshort(sc, 0x18, 0x1a74);
-                MP_WritePhyUshort(sc, 0x19, 0x9500);
-                MP_WritePhyUshort(sc, 0x18, 0x1a84);
-                MP_WritePhyUshort(sc, 0x19, 0x8000);
-                MP_WritePhyUshort(sc, 0x18, 0x1a94);
-                MP_WritePhyUshort(sc, 0x19, 0x7d00);
-                MP_WritePhyUshort(sc, 0x18, 0x1aa4);
-                MP_WritePhyUshort(sc, 0x19, 0x9600);
-                MP_WritePhyUshort(sc, 0x18, 0x1ac4);
-                MP_WritePhyUshort(sc, 0x19, 0x4000);
-                MP_WritePhyUshort(sc, 0x18, 0x1ad4);
-                MP_WritePhyUshort(sc, 0x19, 0x0800);
-                MP_WritePhyUshort(sc, 0x18, 0x1af4);
-                MP_WritePhyUshort(sc, 0x19, 0xc400);
-                MP_WritePhyUshort(sc, 0x18, 0x1b04);
-                MP_WritePhyUshort(sc, 0x19, 0x4000);
-                MP_WritePhyUshort(sc, 0x18, 0x1b14);
-                MP_WritePhyUshort(sc, 0x19, 0x0800);
-                MP_WritePhyUshort(sc, 0x18, 0x1b24);
-                MP_WritePhyUshort(sc, 0x19, 0xfd00);
-                MP_WritePhyUshort(sc, 0x18, 0x1b34);
-                MP_WritePhyUshort(sc, 0x19, 0x4000);
-                MP_WritePhyUshort(sc, 0x18, 0x1b44);
-                MP_WritePhyUshort(sc, 0x19, 0x0400);
-                MP_WritePhyUshort(sc, 0x18, 0x1b94);
-                MP_WritePhyUshort(sc, 0x19, 0xf100);
-                MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                MP_WritePhyUshort(sc, 0x17, 0x2100);
-                MP_WritePhyUshort(sc, 0x1f, 0x0007);
-                MP_WritePhyUshort(sc, 0x1e, 0x0040);
-                MP_WritePhyUshort(sc, 0x18, 0x0000);
-                MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                MP_WritePhyUshort(sc, 0x1f, 0x0005);
-                MP_WritePhyUshort(sc, 0x05, 0xfff6);
-                MP_WritePhyUshort(sc, 0x06, 0x0080);
-                MP_WritePhyUshort(sc, 0x05, 0x8000);
-                MP_WritePhyUshort(sc, 0x06, 0x0280);
-                MP_WritePhyUshort(sc, 0x06, 0x48f7);
-                MP_WritePhyUshort(sc, 0x06, 0x00e0);
-                MP_WritePhyUshort(sc, 0x06, 0xfff7);
-                MP_WritePhyUshort(sc, 0x06, 0xa080);
-                MP_WritePhyUshort(sc, 0x06, 0x02ae);
-                MP_WritePhyUshort(sc, 0x06, 0xf602);
-                MP_WritePhyUshort(sc, 0x06, 0x0115);
-                MP_WritePhyUshort(sc, 0x06, 0x0201);
-                MP_WritePhyUshort(sc, 0x06, 0x2202);
-                MP_WritePhyUshort(sc, 0x06, 0x80a0);
-                MP_WritePhyUshort(sc, 0x06, 0x0201);
-                MP_WritePhyUshort(sc, 0x06, 0x3f02);
-                MP_WritePhyUshort(sc, 0x06, 0x0159);
-                MP_WritePhyUshort(sc, 0x06, 0x0280);
-                MP_WritePhyUshort(sc, 0x06, 0xbd02);
-                MP_WritePhyUshort(sc, 0x06, 0x80da);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x88e1);
-                MP_WritePhyUshort(sc, 0x06, 0x8b89);
-                MP_WritePhyUshort(sc, 0x06, 0x1e01);
-                MP_WritePhyUshort(sc, 0x06, 0xe18b);
-                MP_WritePhyUshort(sc, 0x06, 0x8a1e);
-                MP_WritePhyUshort(sc, 0x06, 0x01e1);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8b);
-                MP_WritePhyUshort(sc, 0x06, 0x1e01);
-                MP_WritePhyUshort(sc, 0x06, 0xe18b);
-                MP_WritePhyUshort(sc, 0x06, 0x8c1e);
-                MP_WritePhyUshort(sc, 0x06, 0x01e1);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8d);
-                MP_WritePhyUshort(sc, 0x06, 0x1e01);
-                MP_WritePhyUshort(sc, 0x06, 0xe18b);
-                MP_WritePhyUshort(sc, 0x06, 0x8e1e);
-                MP_WritePhyUshort(sc, 0x06, 0x01a0);
-                MP_WritePhyUshort(sc, 0x06, 0x00c7);
-                MP_WritePhyUshort(sc, 0x06, 0xaebb);
-                MP_WritePhyUshort(sc, 0x06, 0xd481);
-                MP_WritePhyUshort(sc, 0x06, 0xd2e4);
-                MP_WritePhyUshort(sc, 0x06, 0x8b92);
-                MP_WritePhyUshort(sc, 0x06, 0xe58b);
-                MP_WritePhyUshort(sc, 0x06, 0x93d1);
-                MP_WritePhyUshort(sc, 0x06, 0x03bf);
-                MP_WritePhyUshort(sc, 0x06, 0x859e);
-                MP_WritePhyUshort(sc, 0x06, 0x0237);
-                MP_WritePhyUshort(sc, 0x06, 0x23d1);
-                MP_WritePhyUshort(sc, 0x06, 0x02bf);
-                MP_WritePhyUshort(sc, 0x06, 0x85a1);
-                MP_WritePhyUshort(sc, 0x06, 0x0237);
-                MP_WritePhyUshort(sc, 0x06, 0x23ee);
-                MP_WritePhyUshort(sc, 0x06, 0x8608);
-                MP_WritePhyUshort(sc, 0x06, 0x03ee);
-                MP_WritePhyUshort(sc, 0x06, 0x860a);
-                MP_WritePhyUshort(sc, 0x06, 0x60ee);
-                MP_WritePhyUshort(sc, 0x06, 0x8610);
-                MP_WritePhyUshort(sc, 0x06, 0x00ee);
-                MP_WritePhyUshort(sc, 0x06, 0x8611);
-                MP_WritePhyUshort(sc, 0x06, 0x00ee);
-                MP_WritePhyUshort(sc, 0x06, 0x8abe);
-                MP_WritePhyUshort(sc, 0x06, 0x07ee);
-                MP_WritePhyUshort(sc, 0x06, 0x8abf);
-                MP_WritePhyUshort(sc, 0x06, 0x73ee);
-                MP_WritePhyUshort(sc, 0x06, 0x8a95);
-                MP_WritePhyUshort(sc, 0x06, 0x02bf);
-                MP_WritePhyUshort(sc, 0x06, 0x8b88);
-                MP_WritePhyUshort(sc, 0x06, 0xec00);
-                MP_WritePhyUshort(sc, 0x06, 0x19a9);
-                MP_WritePhyUshort(sc, 0x06, 0x8b90);
-                MP_WritePhyUshort(sc, 0x06, 0xf9ee);
-                MP_WritePhyUshort(sc, 0x06, 0xfff6);
-                MP_WritePhyUshort(sc, 0x06, 0x00ee);
-                MP_WritePhyUshort(sc, 0x06, 0xfff7);
-                MP_WritePhyUshort(sc, 0x06, 0xfed1);
-                MP_WritePhyUshort(sc, 0x06, 0x00bf);
-                MP_WritePhyUshort(sc, 0x06, 0x8595);
-                MP_WritePhyUshort(sc, 0x06, 0x0237);
-                MP_WritePhyUshort(sc, 0x06, 0x23d1);
-                MP_WritePhyUshort(sc, 0x06, 0x01bf);
-                MP_WritePhyUshort(sc, 0x06, 0x8598);
-                MP_WritePhyUshort(sc, 0x06, 0x0237);
-                MP_WritePhyUshort(sc, 0x06, 0x2304);
-                MP_WritePhyUshort(sc, 0x06, 0xf8e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8a);
-                MP_WritePhyUshort(sc, 0x06, 0xad20);
-                MP_WritePhyUshort(sc, 0x06, 0x14ee);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8a);
-                MP_WritePhyUshort(sc, 0x06, 0x0002);
-                MP_WritePhyUshort(sc, 0x06, 0x1f9a);
-                MP_WritePhyUshort(sc, 0x06, 0xe0e4);
-                MP_WritePhyUshort(sc, 0x06, 0x26e1);
-                MP_WritePhyUshort(sc, 0x06, 0xe427);
-                MP_WritePhyUshort(sc, 0x06, 0xeee4);
-                MP_WritePhyUshort(sc, 0x06, 0x2623);
-                MP_WritePhyUshort(sc, 0x06, 0xe5e4);
-                MP_WritePhyUshort(sc, 0x06, 0x27fc);
-                MP_WritePhyUshort(sc, 0x06, 0x04f8);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x8dad);
-                MP_WritePhyUshort(sc, 0x06, 0x2014);
-                MP_WritePhyUshort(sc, 0x06, 0xee8b);
-                MP_WritePhyUshort(sc, 0x06, 0x8d00);
-                MP_WritePhyUshort(sc, 0x06, 0xe08a);
-                MP_WritePhyUshort(sc, 0x06, 0x5a78);
-                MP_WritePhyUshort(sc, 0x06, 0x039e);
-                MP_WritePhyUshort(sc, 0x06, 0x0902);
-                MP_WritePhyUshort(sc, 0x06, 0x05db);
-                MP_WritePhyUshort(sc, 0x06, 0x0282);
-                MP_WritePhyUshort(sc, 0x06, 0x7b02);
-                MP_WritePhyUshort(sc, 0x06, 0x3231);
-                MP_WritePhyUshort(sc, 0x06, 0xfc04);
-                MP_WritePhyUshort(sc, 0x06, 0xf8e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8e);
-                MP_WritePhyUshort(sc, 0x06, 0xad20);
-                MP_WritePhyUshort(sc, 0x06, 0x1df6);
-                MP_WritePhyUshort(sc, 0x06, 0x20e4);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8e);
-                MP_WritePhyUshort(sc, 0x06, 0x0281);
-                MP_WritePhyUshort(sc, 0x06, 0x5c02);
-                MP_WritePhyUshort(sc, 0x06, 0x2bcb);
-                MP_WritePhyUshort(sc, 0x06, 0x022d);
-                MP_WritePhyUshort(sc, 0x06, 0x2902);
-                MP_WritePhyUshort(sc, 0x06, 0x03b4);
-                MP_WritePhyUshort(sc, 0x06, 0x0285);
-                MP_WritePhyUshort(sc, 0x06, 0x6402);
-                MP_WritePhyUshort(sc, 0x06, 0x2eca);
-                MP_WritePhyUshort(sc, 0x06, 0x0284);
-                MP_WritePhyUshort(sc, 0x06, 0xcd02);
-                MP_WritePhyUshort(sc, 0x06, 0x046f);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x8ead);
-                MP_WritePhyUshort(sc, 0x06, 0x210b);
-                MP_WritePhyUshort(sc, 0x06, 0xf621);
-                MP_WritePhyUshort(sc, 0x06, 0xe48b);
-                MP_WritePhyUshort(sc, 0x06, 0x8e02);
-                MP_WritePhyUshort(sc, 0x06, 0x8520);
-                MP_WritePhyUshort(sc, 0x06, 0x021b);
-                MP_WritePhyUshort(sc, 0x06, 0xe8e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8e);
-                MP_WritePhyUshort(sc, 0x06, 0xad22);
-                MP_WritePhyUshort(sc, 0x06, 0x05f6);
-                MP_WritePhyUshort(sc, 0x06, 0x22e4);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8e);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x8ead);
-                MP_WritePhyUshort(sc, 0x06, 0x2308);
-                MP_WritePhyUshort(sc, 0x06, 0xf623);
-                MP_WritePhyUshort(sc, 0x06, 0xe48b);
-                MP_WritePhyUshort(sc, 0x06, 0x8e02);
-                MP_WritePhyUshort(sc, 0x06, 0x311c);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x8ead);
-                MP_WritePhyUshort(sc, 0x06, 0x2405);
-                MP_WritePhyUshort(sc, 0x06, 0xf624);
-                MP_WritePhyUshort(sc, 0x06, 0xe48b);
-                MP_WritePhyUshort(sc, 0x06, 0x8ee0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8e);
-                MP_WritePhyUshort(sc, 0x06, 0xad25);
-                MP_WritePhyUshort(sc, 0x06, 0x05f6);
-                MP_WritePhyUshort(sc, 0x06, 0x25e4);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8e);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x8ead);
-                MP_WritePhyUshort(sc, 0x06, 0x2608);
-                MP_WritePhyUshort(sc, 0x06, 0xf626);
-                MP_WritePhyUshort(sc, 0x06, 0xe48b);
-                MP_WritePhyUshort(sc, 0x06, 0x8e02);
-                MP_WritePhyUshort(sc, 0x06, 0x2df5);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x8ead);
-                MP_WritePhyUshort(sc, 0x06, 0x2705);
-                MP_WritePhyUshort(sc, 0x06, 0xf627);
-                MP_WritePhyUshort(sc, 0x06, 0xe48b);
-                MP_WritePhyUshort(sc, 0x06, 0x8e02);
-                MP_WritePhyUshort(sc, 0x06, 0x037a);
-                MP_WritePhyUshort(sc, 0x06, 0xfc04);
-                MP_WritePhyUshort(sc, 0x06, 0xf8f9);
-                MP_WritePhyUshort(sc, 0x06, 0xfaef);
-                MP_WritePhyUshort(sc, 0x06, 0x69e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b87);
-                MP_WritePhyUshort(sc, 0x06, 0xad20);
-                MP_WritePhyUshort(sc, 0x06, 0x65d2);
-                MP_WritePhyUshort(sc, 0x06, 0x00bf);
-                MP_WritePhyUshort(sc, 0x06, 0x2fe9);
-                MP_WritePhyUshort(sc, 0x06, 0x0236);
-                MP_WritePhyUshort(sc, 0x06, 0xf61e);
-                MP_WritePhyUshort(sc, 0x06, 0x21bf);
-                MP_WritePhyUshort(sc, 0x06, 0x2ff5);
-                MP_WritePhyUshort(sc, 0x06, 0x0236);
-                MP_WritePhyUshort(sc, 0x06, 0xf60c);
-                MP_WritePhyUshort(sc, 0x06, 0x111e);
-                MP_WritePhyUshort(sc, 0x06, 0x21bf);
-                MP_WritePhyUshort(sc, 0x06, 0x2ff8);
-                MP_WritePhyUshort(sc, 0x06, 0x0236);
-                MP_WritePhyUshort(sc, 0x06, 0xf60c);
-                MP_WritePhyUshort(sc, 0x06, 0x121e);
-                MP_WritePhyUshort(sc, 0x06, 0x21bf);
-                MP_WritePhyUshort(sc, 0x06, 0x2ffb);
-                MP_WritePhyUshort(sc, 0x06, 0x0236);
-                MP_WritePhyUshort(sc, 0x06, 0xf60c);
-                MP_WritePhyUshort(sc, 0x06, 0x131e);
-                MP_WritePhyUshort(sc, 0x06, 0x21bf);
-                MP_WritePhyUshort(sc, 0x06, 0x1f97);
-                MP_WritePhyUshort(sc, 0x06, 0x0236);
-                MP_WritePhyUshort(sc, 0x06, 0xf60c);
-                MP_WritePhyUshort(sc, 0x06, 0x141e);
-                MP_WritePhyUshort(sc, 0x06, 0x21bf);
-                MP_WritePhyUshort(sc, 0x06, 0x859b);
-                MP_WritePhyUshort(sc, 0x06, 0x0236);
-                MP_WritePhyUshort(sc, 0x06, 0xf60c);
-                MP_WritePhyUshort(sc, 0x06, 0x161e);
-                MP_WritePhyUshort(sc, 0x06, 0x21e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8a8c);
-                MP_WritePhyUshort(sc, 0x06, 0x1f02);
-                MP_WritePhyUshort(sc, 0x06, 0x9e22);
-                MP_WritePhyUshort(sc, 0x06, 0xe68a);
-                MP_WritePhyUshort(sc, 0x06, 0x8cad);
-                MP_WritePhyUshort(sc, 0x06, 0x3114);
-                MP_WritePhyUshort(sc, 0x06, 0xad30);
-                MP_WritePhyUshort(sc, 0x06, 0x11ef);
-                MP_WritePhyUshort(sc, 0x06, 0x0258);
-                MP_WritePhyUshort(sc, 0x06, 0x0c9e);
-                MP_WritePhyUshort(sc, 0x06, 0x07ad);
-                MP_WritePhyUshort(sc, 0x06, 0x3608);
-                MP_WritePhyUshort(sc, 0x06, 0x5a30);
-                MP_WritePhyUshort(sc, 0x06, 0x9f04);
-                MP_WritePhyUshort(sc, 0x06, 0xd101);
-                MP_WritePhyUshort(sc, 0x06, 0xae02);
-                MP_WritePhyUshort(sc, 0x06, 0xd100);
-                MP_WritePhyUshort(sc, 0x06, 0xbf2f);
-                MP_WritePhyUshort(sc, 0x06, 0xf202);
-                MP_WritePhyUshort(sc, 0x06, 0x3723);
-                MP_WritePhyUshort(sc, 0x06, 0xef96);
-                MP_WritePhyUshort(sc, 0x06, 0xfefd);
-                MP_WritePhyUshort(sc, 0x06, 0xfc04);
-                MP_WritePhyUshort(sc, 0x06, 0xf8f9);
-                MP_WritePhyUshort(sc, 0x06, 0xface);
-                MP_WritePhyUshort(sc, 0x06, 0xfaef);
-                MP_WritePhyUshort(sc, 0x06, 0x69fa);
-                MP_WritePhyUshort(sc, 0x06, 0xd401);
-                MP_WritePhyUshort(sc, 0x06, 0x55b4);
-                MP_WritePhyUshort(sc, 0x06, 0xfebf);
-                MP_WritePhyUshort(sc, 0x06, 0x85a7);
-                MP_WritePhyUshort(sc, 0x06, 0x0236);
-                MP_WritePhyUshort(sc, 0x06, 0xf6ac);
-                MP_WritePhyUshort(sc, 0x06, 0x280b);
-                MP_WritePhyUshort(sc, 0x06, 0xbf85);
-                MP_WritePhyUshort(sc, 0x06, 0xa402);
-                MP_WritePhyUshort(sc, 0x06, 0x36f6);
-                MP_WritePhyUshort(sc, 0x06, 0xac28);
-                MP_WritePhyUshort(sc, 0x06, 0x49ae);
-                MP_WritePhyUshort(sc, 0x06, 0x64bf);
-                MP_WritePhyUshort(sc, 0x06, 0x85a4);
-                MP_WritePhyUshort(sc, 0x06, 0x0236);
-                MP_WritePhyUshort(sc, 0x06, 0xf6ac);
-                MP_WritePhyUshort(sc, 0x06, 0x285b);
-                MP_WritePhyUshort(sc, 0x06, 0xd000);
-                MP_WritePhyUshort(sc, 0x06, 0x0282);
-                MP_WritePhyUshort(sc, 0x06, 0x60ac);
-                MP_WritePhyUshort(sc, 0x06, 0x2105);
-                MP_WritePhyUshort(sc, 0x06, 0xac22);
-                MP_WritePhyUshort(sc, 0x06, 0x02ae);
-                MP_WritePhyUshort(sc, 0x06, 0x4ebf);
-                MP_WritePhyUshort(sc, 0x06, 0xe0c4);
-                MP_WritePhyUshort(sc, 0x06, 0xbe86);
-                MP_WritePhyUshort(sc, 0x06, 0x14d2);
-                MP_WritePhyUshort(sc, 0x06, 0x04d8);
-                MP_WritePhyUshort(sc, 0x06, 0x19d9);
-                MP_WritePhyUshort(sc, 0x06, 0x1907);
-                MP_WritePhyUshort(sc, 0x06, 0xdc19);
-                MP_WritePhyUshort(sc, 0x06, 0xdd19);
-                MP_WritePhyUshort(sc, 0x06, 0x0789);
-                MP_WritePhyUshort(sc, 0x06, 0x89ef);
-                MP_WritePhyUshort(sc, 0x06, 0x645e);
-                MP_WritePhyUshort(sc, 0x06, 0x07ff);
-                MP_WritePhyUshort(sc, 0x06, 0x0d65);
-                MP_WritePhyUshort(sc, 0x06, 0x5cf8);
-                MP_WritePhyUshort(sc, 0x06, 0x001e);
-                MP_WritePhyUshort(sc, 0x06, 0x46dc);
-                MP_WritePhyUshort(sc, 0x06, 0x19dd);
-                MP_WritePhyUshort(sc, 0x06, 0x19b2);
-                MP_WritePhyUshort(sc, 0x06, 0xe2d4);
-                MP_WritePhyUshort(sc, 0x06, 0x0001);
-                MP_WritePhyUshort(sc, 0x06, 0xbf85);
-                MP_WritePhyUshort(sc, 0x06, 0xa402);
-                MP_WritePhyUshort(sc, 0x06, 0x3723);
-                MP_WritePhyUshort(sc, 0x06, 0xae1d);
-                MP_WritePhyUshort(sc, 0x06, 0xbee0);
-                MP_WritePhyUshort(sc, 0x06, 0xc4bf);
-                MP_WritePhyUshort(sc, 0x06, 0x8614);
-                MP_WritePhyUshort(sc, 0x06, 0xd204);
-                MP_WritePhyUshort(sc, 0x06, 0xd819);
-                MP_WritePhyUshort(sc, 0x06, 0xd919);
-                MP_WritePhyUshort(sc, 0x06, 0x07dc);
-                MP_WritePhyUshort(sc, 0x06, 0x19dd);
-                MP_WritePhyUshort(sc, 0x06, 0x1907);
-                MP_WritePhyUshort(sc, 0x06, 0xb2f4);
-                MP_WritePhyUshort(sc, 0x06, 0xd400);
-                MP_WritePhyUshort(sc, 0x06, 0x00bf);
-                MP_WritePhyUshort(sc, 0x06, 0x85a4);
-                MP_WritePhyUshort(sc, 0x06, 0x0237);
-                MP_WritePhyUshort(sc, 0x06, 0x23fe);
-                MP_WritePhyUshort(sc, 0x06, 0xef96);
-                MP_WritePhyUshort(sc, 0x06, 0xfec6);
-                MP_WritePhyUshort(sc, 0x06, 0xfefd);
-                MP_WritePhyUshort(sc, 0x06, 0xfc05);
-                MP_WritePhyUshort(sc, 0x06, 0xf9e2);
-                MP_WritePhyUshort(sc, 0x06, 0xe0ea);
-                MP_WritePhyUshort(sc, 0x06, 0xe3e0);
-                MP_WritePhyUshort(sc, 0x06, 0xeb5a);
-                MP_WritePhyUshort(sc, 0x06, 0x070c);
-                MP_WritePhyUshort(sc, 0x06, 0x031e);
-                MP_WritePhyUshort(sc, 0x06, 0x20e6);
-                MP_WritePhyUshort(sc, 0x06, 0xe0ea);
-                MP_WritePhyUshort(sc, 0x06, 0xe7e0);
-                MP_WritePhyUshort(sc, 0x06, 0xebe0);
-                MP_WritePhyUshort(sc, 0x06, 0xe0fc);
-                MP_WritePhyUshort(sc, 0x06, 0xe1e0);
-                MP_WritePhyUshort(sc, 0x06, 0xfdfd);
-                MP_WritePhyUshort(sc, 0x06, 0x04f8);
-                MP_WritePhyUshort(sc, 0x06, 0xf9e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b81);
-                MP_WritePhyUshort(sc, 0x06, 0xac26);
-                MP_WritePhyUshort(sc, 0x06, 0x1ae0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b81);
-                MP_WritePhyUshort(sc, 0x06, 0xac21);
-                MP_WritePhyUshort(sc, 0x06, 0x14e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b85);
-                MP_WritePhyUshort(sc, 0x06, 0xac20);
-                MP_WritePhyUshort(sc, 0x06, 0x0ee0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b85);
-                MP_WritePhyUshort(sc, 0x06, 0xac23);
-                MP_WritePhyUshort(sc, 0x06, 0x08e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b87);
-                MP_WritePhyUshort(sc, 0x06, 0xac24);
-                MP_WritePhyUshort(sc, 0x06, 0x02ae);
-                MP_WritePhyUshort(sc, 0x06, 0x3802);
-                MP_WritePhyUshort(sc, 0x06, 0x1ab5);
-                MP_WritePhyUshort(sc, 0x06, 0xeee4);
-                MP_WritePhyUshort(sc, 0x06, 0x1c04);
-                MP_WritePhyUshort(sc, 0x06, 0xeee4);
-                MP_WritePhyUshort(sc, 0x06, 0x1d04);
-                MP_WritePhyUshort(sc, 0x06, 0xe2e0);
-                MP_WritePhyUshort(sc, 0x06, 0x7ce3);
-                MP_WritePhyUshort(sc, 0x06, 0xe07d);
-                MP_WritePhyUshort(sc, 0x06, 0xe0e0);
-                MP_WritePhyUshort(sc, 0x06, 0x38e1);
-                MP_WritePhyUshort(sc, 0x06, 0xe039);
-                MP_WritePhyUshort(sc, 0x06, 0xad2e);
-                MP_WritePhyUshort(sc, 0x06, 0x1bad);
-                MP_WritePhyUshort(sc, 0x06, 0x390d);
-                MP_WritePhyUshort(sc, 0x06, 0xd101);
-                MP_WritePhyUshort(sc, 0x06, 0xbf21);
-                MP_WritePhyUshort(sc, 0x06, 0xd502);
-                MP_WritePhyUshort(sc, 0x06, 0x3723);
-                MP_WritePhyUshort(sc, 0x06, 0x0282);
-                MP_WritePhyUshort(sc, 0x06, 0xd8ae);
-                MP_WritePhyUshort(sc, 0x06, 0x0bac);
-                MP_WritePhyUshort(sc, 0x06, 0x3802);
-                MP_WritePhyUshort(sc, 0x06, 0xae06);
-                MP_WritePhyUshort(sc, 0x06, 0x0283);
-                MP_WritePhyUshort(sc, 0x06, 0x1802);
-                MP_WritePhyUshort(sc, 0x06, 0x8360);
-                MP_WritePhyUshort(sc, 0x06, 0x021a);
-                MP_WritePhyUshort(sc, 0x06, 0xc6fd);
-                MP_WritePhyUshort(sc, 0x06, 0xfc04);
-                MP_WritePhyUshort(sc, 0x06, 0xf8e1);
-                MP_WritePhyUshort(sc, 0x06, 0x8af4);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x81ad);
-                MP_WritePhyUshort(sc, 0x06, 0x2605);
-                MP_WritePhyUshort(sc, 0x06, 0x0222);
-                MP_WritePhyUshort(sc, 0x06, 0xa4f7);
-                MP_WritePhyUshort(sc, 0x06, 0x28e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b81);
-                MP_WritePhyUshort(sc, 0x06, 0xad21);
-                MP_WritePhyUshort(sc, 0x06, 0x0502);
-                MP_WritePhyUshort(sc, 0x06, 0x23a9);
-                MP_WritePhyUshort(sc, 0x06, 0xf729);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x85ad);
-                MP_WritePhyUshort(sc, 0x06, 0x2005);
-                MP_WritePhyUshort(sc, 0x06, 0x0214);
-                MP_WritePhyUshort(sc, 0x06, 0xabf7);
-                MP_WritePhyUshort(sc, 0x06, 0x2ae0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b85);
-                MP_WritePhyUshort(sc, 0x06, 0xad23);
-                MP_WritePhyUshort(sc, 0x06, 0x0502);
-                MP_WritePhyUshort(sc, 0x06, 0x12e7);
-                MP_WritePhyUshort(sc, 0x06, 0xf72b);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x87ad);
-                MP_WritePhyUshort(sc, 0x06, 0x2405);
-                MP_WritePhyUshort(sc, 0x06, 0x0283);
-                MP_WritePhyUshort(sc, 0x06, 0xbcf7);
-                MP_WritePhyUshort(sc, 0x06, 0x2ce5);
-                MP_WritePhyUshort(sc, 0x06, 0x8af4);
-                MP_WritePhyUshort(sc, 0x06, 0xfc04);
-                MP_WritePhyUshort(sc, 0x06, 0xf8e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b81);
-                MP_WritePhyUshort(sc, 0x06, 0xad26);
-                MP_WritePhyUshort(sc, 0x06, 0x0302);
-                MP_WritePhyUshort(sc, 0x06, 0x21e5);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x81ad);
-                MP_WritePhyUshort(sc, 0x06, 0x2109);
-                MP_WritePhyUshort(sc, 0x06, 0xe08a);
-                MP_WritePhyUshort(sc, 0x06, 0xf4ac);
-                MP_WritePhyUshort(sc, 0x06, 0x2003);
-                MP_WritePhyUshort(sc, 0x06, 0x0223);
-                MP_WritePhyUshort(sc, 0x06, 0x98e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b85);
-                MP_WritePhyUshort(sc, 0x06, 0xad20);
-                MP_WritePhyUshort(sc, 0x06, 0x09e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8af4);
-                MP_WritePhyUshort(sc, 0x06, 0xac21);
-                MP_WritePhyUshort(sc, 0x06, 0x0302);
-                MP_WritePhyUshort(sc, 0x06, 0x13fb);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x85ad);
-                MP_WritePhyUshort(sc, 0x06, 0x2309);
-                MP_WritePhyUshort(sc, 0x06, 0xe08a);
-                MP_WritePhyUshort(sc, 0x06, 0xf4ac);
-                MP_WritePhyUshort(sc, 0x06, 0x2203);
-                MP_WritePhyUshort(sc, 0x06, 0x0212);
-                MP_WritePhyUshort(sc, 0x06, 0xfae0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b87);
-                MP_WritePhyUshort(sc, 0x06, 0xad24);
-                MP_WritePhyUshort(sc, 0x06, 0x09e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8af4);
-                MP_WritePhyUshort(sc, 0x06, 0xac23);
-                MP_WritePhyUshort(sc, 0x06, 0x0302);
-                MP_WritePhyUshort(sc, 0x06, 0x83c1);
-                MP_WritePhyUshort(sc, 0x06, 0xfc04);
-                MP_WritePhyUshort(sc, 0x06, 0xf8e1);
-                MP_WritePhyUshort(sc, 0x06, 0x8af4);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x81ad);
-                MP_WritePhyUshort(sc, 0x06, 0x2608);
-                MP_WritePhyUshort(sc, 0x06, 0xe083);
-                MP_WritePhyUshort(sc, 0x06, 0xd2ad);
-                MP_WritePhyUshort(sc, 0x06, 0x2502);
-                MP_WritePhyUshort(sc, 0x06, 0xf628);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x81ad);
-                MP_WritePhyUshort(sc, 0x06, 0x210a);
-                MP_WritePhyUshort(sc, 0x06, 0xe084);
-                MP_WritePhyUshort(sc, 0x06, 0x0af6);
-                MP_WritePhyUshort(sc, 0x06, 0x27a0);
-                MP_WritePhyUshort(sc, 0x06, 0x0502);
-                MP_WritePhyUshort(sc, 0x06, 0xf629);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x85ad);
-                MP_WritePhyUshort(sc, 0x06, 0x2008);
-                MP_WritePhyUshort(sc, 0x06, 0xe08a);
-                MP_WritePhyUshort(sc, 0x06, 0xe8ad);
-                MP_WritePhyUshort(sc, 0x06, 0x2102);
-                MP_WritePhyUshort(sc, 0x06, 0xf62a);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x85ad);
-                MP_WritePhyUshort(sc, 0x06, 0x2308);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x20a0);
-                MP_WritePhyUshort(sc, 0x06, 0x0302);
-                MP_WritePhyUshort(sc, 0x06, 0xf62b);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x87ad);
-                MP_WritePhyUshort(sc, 0x06, 0x2408);
-                MP_WritePhyUshort(sc, 0x06, 0xe086);
-                MP_WritePhyUshort(sc, 0x06, 0x02a0);
-                MP_WritePhyUshort(sc, 0x06, 0x0302);
-                MP_WritePhyUshort(sc, 0x06, 0xf62c);
-                MP_WritePhyUshort(sc, 0x06, 0xe58a);
-                MP_WritePhyUshort(sc, 0x06, 0xf4a1);
-                MP_WritePhyUshort(sc, 0x06, 0x0008);
-                MP_WritePhyUshort(sc, 0x06, 0xd100);
-                MP_WritePhyUshort(sc, 0x06, 0xbf21);
-                MP_WritePhyUshort(sc, 0x06, 0xd502);
-                MP_WritePhyUshort(sc, 0x06, 0x3723);
-                MP_WritePhyUshort(sc, 0x06, 0xfc04);
-                MP_WritePhyUshort(sc, 0x06, 0xee86);
-                MP_WritePhyUshort(sc, 0x06, 0x0200);
-                MP_WritePhyUshort(sc, 0x06, 0x04f8);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x87ad);
-                MP_WritePhyUshort(sc, 0x06, 0x241e);
-                MP_WritePhyUshort(sc, 0x06, 0xe086);
-                MP_WritePhyUshort(sc, 0x06, 0x02a0);
-                MP_WritePhyUshort(sc, 0x06, 0x0005);
-                MP_WritePhyUshort(sc, 0x06, 0x0283);
-                MP_WritePhyUshort(sc, 0x06, 0xe8ae);
-                MP_WritePhyUshort(sc, 0x06, 0xf5a0);
-                MP_WritePhyUshort(sc, 0x06, 0x0105);
-                MP_WritePhyUshort(sc, 0x06, 0x0283);
-                MP_WritePhyUshort(sc, 0x06, 0xf8ae);
-                MP_WritePhyUshort(sc, 0x06, 0x0ba0);
-                MP_WritePhyUshort(sc, 0x06, 0x0205);
-                MP_WritePhyUshort(sc, 0x06, 0x0284);
-                MP_WritePhyUshort(sc, 0x06, 0x14ae);
-                MP_WritePhyUshort(sc, 0x06, 0x03a0);
-                MP_WritePhyUshort(sc, 0x06, 0x0300);
-                MP_WritePhyUshort(sc, 0x06, 0xfc04);
-                MP_WritePhyUshort(sc, 0x06, 0xf8fa);
-                MP_WritePhyUshort(sc, 0x06, 0xef69);
-                MP_WritePhyUshort(sc, 0x06, 0x0284);
-                MP_WritePhyUshort(sc, 0x06, 0x2bee);
-                MP_WritePhyUshort(sc, 0x06, 0x8602);
-                MP_WritePhyUshort(sc, 0x06, 0x01ef);
-                MP_WritePhyUshort(sc, 0x06, 0x96fe);
-                MP_WritePhyUshort(sc, 0x06, 0xfc04);
-                MP_WritePhyUshort(sc, 0x06, 0xf8ee);
-                MP_WritePhyUshort(sc, 0x06, 0x8609);
-                MP_WritePhyUshort(sc, 0x06, 0x0002);
-                MP_WritePhyUshort(sc, 0x06, 0x8461);
-                MP_WritePhyUshort(sc, 0x06, 0xfc04);
-                MP_WritePhyUshort(sc, 0x06, 0xae10);
-                MP_WritePhyUshort(sc, 0x06, 0x0000);
-                MP_WritePhyUshort(sc, 0x06, 0x0000);
-                MP_WritePhyUshort(sc, 0x06, 0x0000);
-                MP_WritePhyUshort(sc, 0x06, 0x0000);
-                MP_WritePhyUshort(sc, 0x06, 0x0000);
-                MP_WritePhyUshort(sc, 0x06, 0x0000);
-                MP_WritePhyUshort(sc, 0x06, 0x0000);
-                MP_WritePhyUshort(sc, 0x06, 0x0000);
-                MP_WritePhyUshort(sc, 0x06, 0xf8e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8608);
-                MP_WritePhyUshort(sc, 0x06, 0xe186);
-                MP_WritePhyUshort(sc, 0x06, 0x091f);
-                MP_WritePhyUshort(sc, 0x06, 0x019e);
-                MP_WritePhyUshort(sc, 0x06, 0x0611);
-                MP_WritePhyUshort(sc, 0x06, 0xe586);
-                MP_WritePhyUshort(sc, 0x06, 0x09ae);
-                MP_WritePhyUshort(sc, 0x06, 0x04ee);
-                MP_WritePhyUshort(sc, 0x06, 0x8602);
-                MP_WritePhyUshort(sc, 0x06, 0x01fc);
-                MP_WritePhyUshort(sc, 0x06, 0x04f8);
-                MP_WritePhyUshort(sc, 0x06, 0xf9fa);
-                MP_WritePhyUshort(sc, 0x06, 0xef69);
-                MP_WritePhyUshort(sc, 0x06, 0xfbbf);
-                MP_WritePhyUshort(sc, 0x06, 0x8604);
-                MP_WritePhyUshort(sc, 0x06, 0xef79);
-                MP_WritePhyUshort(sc, 0x06, 0xd200);
-                MP_WritePhyUshort(sc, 0x06, 0xd400);
-                MP_WritePhyUshort(sc, 0x06, 0x221e);
-                MP_WritePhyUshort(sc, 0x06, 0x02bf);
-                MP_WritePhyUshort(sc, 0x06, 0x2fec);
-                MP_WritePhyUshort(sc, 0x06, 0x0237);
-                MP_WritePhyUshort(sc, 0x06, 0x23bf);
-                MP_WritePhyUshort(sc, 0x06, 0x13f2);
-                MP_WritePhyUshort(sc, 0x06, 0x0236);
-                MP_WritePhyUshort(sc, 0x06, 0xf60d);
-                MP_WritePhyUshort(sc, 0x06, 0x4559);
-                MP_WritePhyUshort(sc, 0x06, 0x1fef);
-                MP_WritePhyUshort(sc, 0x06, 0x97dd);
-                MP_WritePhyUshort(sc, 0x06, 0xd308);
-                MP_WritePhyUshort(sc, 0x06, 0x1a93);
-                MP_WritePhyUshort(sc, 0x06, 0xdd12);
-                MP_WritePhyUshort(sc, 0x06, 0x17a2);
-                MP_WritePhyUshort(sc, 0x06, 0x04de);
-                MP_WritePhyUshort(sc, 0x06, 0xffef);
-                MP_WritePhyUshort(sc, 0x06, 0x96fe);
-                MP_WritePhyUshort(sc, 0x06, 0xfdfc);
-                MP_WritePhyUshort(sc, 0x06, 0x04f8);
-                MP_WritePhyUshort(sc, 0x06, 0xf9fa);
-                MP_WritePhyUshort(sc, 0x06, 0xef69);
-                MP_WritePhyUshort(sc, 0x06, 0xfbee);
-                MP_WritePhyUshort(sc, 0x06, 0x8602);
-                MP_WritePhyUshort(sc, 0x06, 0x03d5);
-                MP_WritePhyUshort(sc, 0x06, 0x0080);
-                MP_WritePhyUshort(sc, 0x06, 0xbf86);
-                MP_WritePhyUshort(sc, 0x06, 0x04ef);
-                MP_WritePhyUshort(sc, 0x06, 0x79ef);
-                MP_WritePhyUshort(sc, 0x06, 0x45bf);
-                MP_WritePhyUshort(sc, 0x06, 0x2fec);
-                MP_WritePhyUshort(sc, 0x06, 0x0237);
-                MP_WritePhyUshort(sc, 0x06, 0x23bf);
-                MP_WritePhyUshort(sc, 0x06, 0x13f2);
-                MP_WritePhyUshort(sc, 0x06, 0x0236);
-                MP_WritePhyUshort(sc, 0x06, 0xf6ad);
-                MP_WritePhyUshort(sc, 0x06, 0x2702);
-                MP_WritePhyUshort(sc, 0x06, 0x78ff);
-                MP_WritePhyUshort(sc, 0x06, 0xe186);
-                MP_WritePhyUshort(sc, 0x06, 0x0a1b);
-                MP_WritePhyUshort(sc, 0x06, 0x01aa);
-                MP_WritePhyUshort(sc, 0x06, 0x2eef);
-                MP_WritePhyUshort(sc, 0x06, 0x97d9);
-                MP_WritePhyUshort(sc, 0x06, 0x7900);
-                MP_WritePhyUshort(sc, 0x06, 0x9e2b);
-                MP_WritePhyUshort(sc, 0x06, 0x81dd);
-                MP_WritePhyUshort(sc, 0x06, 0xbf85);
-                MP_WritePhyUshort(sc, 0x06, 0xad02);
-                MP_WritePhyUshort(sc, 0x06, 0x3723);
-                MP_WritePhyUshort(sc, 0x06, 0xd101);
-                MP_WritePhyUshort(sc, 0x06, 0xef02);
-                MP_WritePhyUshort(sc, 0x06, 0x100c);
-                MP_WritePhyUshort(sc, 0x06, 0x11b0);
-                MP_WritePhyUshort(sc, 0x06, 0xfc0d);
-                MP_WritePhyUshort(sc, 0x06, 0x11bf);
-                MP_WritePhyUshort(sc, 0x06, 0x85aa);
-                MP_WritePhyUshort(sc, 0x06, 0x0237);
-                MP_WritePhyUshort(sc, 0x06, 0x23d1);
-                MP_WritePhyUshort(sc, 0x06, 0x00bf);
-                MP_WritePhyUshort(sc, 0x06, 0x85aa);
-                MP_WritePhyUshort(sc, 0x06, 0x0237);
-                MP_WritePhyUshort(sc, 0x06, 0x23ee);
-                MP_WritePhyUshort(sc, 0x06, 0x8602);
-                MP_WritePhyUshort(sc, 0x06, 0x02ae);
-                MP_WritePhyUshort(sc, 0x06, 0x0413);
-                MP_WritePhyUshort(sc, 0x06, 0xa38b);
-                MP_WritePhyUshort(sc, 0x06, 0xb4d3);
-                MP_WritePhyUshort(sc, 0x06, 0x8012);
-                MP_WritePhyUshort(sc, 0x06, 0x17a2);
-                MP_WritePhyUshort(sc, 0x06, 0x04ad);
-                MP_WritePhyUshort(sc, 0x06, 0xffef);
-                MP_WritePhyUshort(sc, 0x06, 0x96fe);
-                MP_WritePhyUshort(sc, 0x06, 0xfdfc);
-                MP_WritePhyUshort(sc, 0x06, 0x04f8);
-                MP_WritePhyUshort(sc, 0x06, 0xf9e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b85);
-                MP_WritePhyUshort(sc, 0x06, 0xad25);
-                MP_WritePhyUshort(sc, 0x06, 0x48e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8a96);
-                MP_WritePhyUshort(sc, 0x06, 0xe18a);
-                MP_WritePhyUshort(sc, 0x06, 0x977c);
-                MP_WritePhyUshort(sc, 0x06, 0x0000);
-                MP_WritePhyUshort(sc, 0x06, 0x9e35);
-                MP_WritePhyUshort(sc, 0x06, 0xee8a);
-                MP_WritePhyUshort(sc, 0x06, 0x9600);
-                MP_WritePhyUshort(sc, 0x06, 0xee8a);
-                MP_WritePhyUshort(sc, 0x06, 0x9700);
-                MP_WritePhyUshort(sc, 0x06, 0xe08a);
-                MP_WritePhyUshort(sc, 0x06, 0xbee1);
-                MP_WritePhyUshort(sc, 0x06, 0x8abf);
-                MP_WritePhyUshort(sc, 0x06, 0xe286);
-                MP_WritePhyUshort(sc, 0x06, 0x10e3);
-                MP_WritePhyUshort(sc, 0x06, 0x8611);
-                MP_WritePhyUshort(sc, 0x06, 0x0236);
-                MP_WritePhyUshort(sc, 0x06, 0x1aad);
-                MP_WritePhyUshort(sc, 0x06, 0x2012);
-                MP_WritePhyUshort(sc, 0x06, 0xee8a);
-                MP_WritePhyUshort(sc, 0x06, 0x9603);
-                MP_WritePhyUshort(sc, 0x06, 0xee8a);
-                MP_WritePhyUshort(sc, 0x06, 0x97b7);
-                MP_WritePhyUshort(sc, 0x06, 0xee86);
-                MP_WritePhyUshort(sc, 0x06, 0x1000);
-                MP_WritePhyUshort(sc, 0x06, 0xee86);
-                MP_WritePhyUshort(sc, 0x06, 0x1100);
-                MP_WritePhyUshort(sc, 0x06, 0xae11);
-                MP_WritePhyUshort(sc, 0x06, 0x15e6);
-                MP_WritePhyUshort(sc, 0x06, 0x8610);
-                MP_WritePhyUshort(sc, 0x06, 0xe786);
-                MP_WritePhyUshort(sc, 0x06, 0x11ae);
-                MP_WritePhyUshort(sc, 0x06, 0x08ee);
-                MP_WritePhyUshort(sc, 0x06, 0x8610);
-                MP_WritePhyUshort(sc, 0x06, 0x00ee);
-                MP_WritePhyUshort(sc, 0x06, 0x8611);
-                MP_WritePhyUshort(sc, 0x06, 0x00fd);
-                MP_WritePhyUshort(sc, 0x06, 0xfc04);
-                MP_WritePhyUshort(sc, 0x06, 0xf8fa);
-                MP_WritePhyUshort(sc, 0x06, 0xef69);
-                MP_WritePhyUshort(sc, 0x06, 0xe0e0);
-                MP_WritePhyUshort(sc, 0x06, 0x00e1);
-                MP_WritePhyUshort(sc, 0x06, 0xe001);
-                MP_WritePhyUshort(sc, 0x06, 0xad27);
-                MP_WritePhyUshort(sc, 0x06, 0x32e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b40);
-                MP_WritePhyUshort(sc, 0x06, 0xf720);
-                MP_WritePhyUshort(sc, 0x06, 0xe48b);
-                MP_WritePhyUshort(sc, 0x06, 0x40bf);
-                MP_WritePhyUshort(sc, 0x06, 0x31f5);
-                MP_WritePhyUshort(sc, 0x06, 0x0236);
-                MP_WritePhyUshort(sc, 0x06, 0xf6ad);
-                MP_WritePhyUshort(sc, 0x06, 0x2821);
-                MP_WritePhyUshort(sc, 0x06, 0xe0e0);
-                MP_WritePhyUshort(sc, 0x06, 0x20e1);
-                MP_WritePhyUshort(sc, 0x06, 0xe021);
-                MP_WritePhyUshort(sc, 0x06, 0xad20);
-                MP_WritePhyUshort(sc, 0x06, 0x18e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b40);
-                MP_WritePhyUshort(sc, 0x06, 0xf620);
-                MP_WritePhyUshort(sc, 0x06, 0xe48b);
-                MP_WritePhyUshort(sc, 0x06, 0x40ee);
-                MP_WritePhyUshort(sc, 0x06, 0x8b3b);
-                MP_WritePhyUshort(sc, 0x06, 0xffe0);
-                MP_WritePhyUshort(sc, 0x06, 0x8a8a);
-                MP_WritePhyUshort(sc, 0x06, 0xe18a);
-                MP_WritePhyUshort(sc, 0x06, 0x8be4);
-                MP_WritePhyUshort(sc, 0x06, 0xe000);
-                MP_WritePhyUshort(sc, 0x06, 0xe5e0);
-                MP_WritePhyUshort(sc, 0x06, 0x01ef);
-                MP_WritePhyUshort(sc, 0x06, 0x96fe);
-                MP_WritePhyUshort(sc, 0x06, 0xfc04);
-                MP_WritePhyUshort(sc, 0x06, 0xf8fa);
-                MP_WritePhyUshort(sc, 0x06, 0xef69);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x80ad);
-                MP_WritePhyUshort(sc, 0x06, 0x2722);
-                MP_WritePhyUshort(sc, 0x06, 0xbf44);
-                MP_WritePhyUshort(sc, 0x06, 0xfc02);
-                MP_WritePhyUshort(sc, 0x06, 0x36f6);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x441f);
-                MP_WritePhyUshort(sc, 0x06, 0x019e);
-                MP_WritePhyUshort(sc, 0x06, 0x15e5);
-                MP_WritePhyUshort(sc, 0x06, 0x8b44);
-                MP_WritePhyUshort(sc, 0x06, 0xad29);
-                MP_WritePhyUshort(sc, 0x06, 0x07ac);
-                MP_WritePhyUshort(sc, 0x06, 0x2804);
-                MP_WritePhyUshort(sc, 0x06, 0xd101);
-                MP_WritePhyUshort(sc, 0x06, 0xae02);
-                MP_WritePhyUshort(sc, 0x06, 0xd100);
-                MP_WritePhyUshort(sc, 0x06, 0xbf85);
-                MP_WritePhyUshort(sc, 0x06, 0xb002);
-                MP_WritePhyUshort(sc, 0x06, 0x3723);
-                MP_WritePhyUshort(sc, 0x06, 0xef96);
-                MP_WritePhyUshort(sc, 0x06, 0xfefc);
-                MP_WritePhyUshort(sc, 0x06, 0x0400);
-                MP_WritePhyUshort(sc, 0x06, 0xe140);
-                MP_WritePhyUshort(sc, 0x06, 0x77e1);
-                MP_WritePhyUshort(sc, 0x06, 0x40dd);
-                MP_WritePhyUshort(sc, 0x06, 0xe022);
-                MP_WritePhyUshort(sc, 0x06, 0x32e1);
-                MP_WritePhyUshort(sc, 0x06, 0x5074);
-                MP_WritePhyUshort(sc, 0x06, 0xe144);
-                MP_WritePhyUshort(sc, 0x06, 0xffe0);
-                MP_WritePhyUshort(sc, 0x06, 0xdaff);
-                MP_WritePhyUshort(sc, 0x06, 0xe0c0);
-                MP_WritePhyUshort(sc, 0x06, 0x52e0);
-                MP_WritePhyUshort(sc, 0x06, 0xeed9);
-                MP_WritePhyUshort(sc, 0x06, 0xe04c);
-                MP_WritePhyUshort(sc, 0x06, 0xbbe0);
-                MP_WritePhyUshort(sc, 0x06, 0x2a00);
-                MP_WritePhyUshort(sc, 0x05, 0xe142);
-                Data = MP_ReadPhyUshort(sc, 0x06);
-                Data |= BIT_0;
-                MP_WritePhyUshort(sc, 0x06, Data);
-                MP_WritePhyUshort(sc, 0x05, 0xe140);
-                Data = MP_ReadPhyUshort(sc, 0x06);
-                Data |= BIT_0;
-                MP_WritePhyUshort(sc, 0x06, Data);
-                MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                MP_WritePhyUshort(sc, 0x1f, 0x0005);
-                for (i = 0; i < 200; i++) {
-                        DELAY(100);
-                        Data = MP_ReadPhyUshort(sc, 0x00);
-                        if (Data & BIT_7)
-                                break;
-                }
-                MP_WritePhyUshort(sc, 0x1f, 0x0007);
-                MP_WritePhyUshort(sc, 0x1e, 0x0042);
-                MP_WritePhyUshort(sc, 0x18, 0x2300);
-                MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                MP_WritePhyUshort(sc, 0x1f, 0x0007);
-                MP_WritePhyUshort(sc, 0x1e, 0x0023);
-                Data = MP_ReadPhyUshort(sc, 0x17);
-                MP_WritePhyUshort(sc, 0x17, Data);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0003);
-                MP_WritePhyUshort(sc, 0x09, 0xA20F);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-                MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                MP_WritePhyUshort(sc, 0x00, 0x9200);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0005);
-                MP_WritePhyUshort(sc, 0x05, 0x8B80);
-                Data = MP_ReadPhyUshort(sc, 0x06);
-                Data |= BIT_2 | BIT_1;
-                MP_WritePhyUshort(sc, 0x06, Data);
-                MP_WritePhyUshort(sc, 0x1f, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0005);
-                MP_WritePhyUshort(sc, 0x05, 0x8B85);
-                Data = MP_ReadPhyUshort(sc, 0x06);
-                Data |= BIT_15;
-                MP_WritePhyUshort(sc, 0x06, Data);
-                MP_WritePhyUshort(sc, 0x1f, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1f, 0x0004);
-                MP_WritePhyUshort(sc, 0x1f, 0x0007);
-                MP_WritePhyUshort(sc, 0x1e, 0x002D);
-                Data = MP_ReadPhyUshort(sc, 0x18);
-                Data |= BIT_4;
-                MP_WritePhyUshort(sc, 0x18, Data);
-                MP_WritePhyUshort(sc, 0x1f, 0x0002);
-                MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                Data = MP_ReadPhyUshort(sc, 0x14);
-                Data |= BIT_15;
-                MP_WritePhyUshort(sc, 0x14, Data);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0005);
-                MP_WritePhyUshort(sc, 0x05, 0x8B86);
-                Data = MP_ReadPhyUshort(sc, 0x06);
-                Data |= BIT_0;
-                MP_WritePhyUshort(sc, 0x06, Data);
-                MP_WritePhyUshort(sc, 0x1f, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0004);
-                MP_WritePhyUshort(sc, 0x1F, 0x0007);
-                MP_WritePhyUshort(sc, 0x1E, 0x00AC);
-                MP_WritePhyUshort(sc, 0x18, 0x0006);
-                MP_WritePhyUshort(sc, 0x1F, 0x0002);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0003);
-                MP_WritePhyUshort(sc, 0x09, 0xA20F);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0005);
-                MP_WritePhyUshort(sc, 0x05, 0x8B85);
-                Data = MP_ReadPhyUshort(sc, 0x06);
-                Data |= BIT_14;
-                MP_WritePhyUshort(sc, 0x06, Data);
-                MP_WritePhyUshort(sc, 0x1f, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0005);
-                MP_WritePhyUshort(sc, 0x05, 0x8B54);
-                Data = MP_ReadPhyUshort(sc, 0x06);
-                Data &= ~BIT_11;
-                MP_WritePhyUshort(sc, 0x06, Data);
-                MP_WritePhyUshort(sc, 0x05, 0x8B5D);
-                Data = MP_ReadPhyUshort(sc, 0x06);
-                Data &= ~BIT_11;
-                MP_WritePhyUshort(sc, 0x06, Data);
-                MP_WritePhyUshort(sc, 0x05, 0x8A7C);
-                Data = MP_ReadPhyUshort(sc, 0x06);
-                Data &= ~BIT_8;
-                MP_WritePhyUshort(sc, 0x06, Data);
-                MP_WritePhyUshort(sc, 0x05, 0x8A7F);
-                Data = MP_ReadPhyUshort(sc, 0x06);
-                Data |= BIT_8;
-                MP_WritePhyUshort(sc, 0x06, Data);
-                MP_WritePhyUshort(sc, 0x05, 0x8A82);
-                Data = MP_ReadPhyUshort(sc, 0x06);
-                Data &= ~BIT_8;
-                MP_WritePhyUshort(sc, 0x06, Data);
-                MP_WritePhyUshort(sc, 0x05, 0x8A85);
-                Data = MP_ReadPhyUshort(sc, 0x06);
-                Data &= ~BIT_8;
-                MP_WritePhyUshort(sc, 0x06, Data);
-                MP_WritePhyUshort(sc, 0x05, 0x8A88);
-                Data = MP_ReadPhyUshort(sc, 0x06);
-                Data &= ~BIT_8;
-                MP_WritePhyUshort(sc, 0x06, Data);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1f, 0x0003);
-                Data = MP_ReadPhyUshort(sc, 0x19);
-                Data &= ~BIT_0;
-                MP_WritePhyUshort(sc, 0x19, Data);
-                Data = MP_ReadPhyUshort(sc, 0x10);
-                Data &= ~BIT_10;
-                MP_WritePhyUshort(sc, 0x10, Data);
-                MP_WritePhyUshort(sc, 0x1f, 0x0000);
-        } else if (sc->re_type == MACFG_41) {
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-                MP_WritePhyUshort(sc, 0x11, MP_ReadPhyUshort(sc, 0x11) | 0x1000);
-                MP_WritePhyUshort(sc, 0x1F, 0x0002);
-                MP_WritePhyUshort(sc, 0x0F, MP_ReadPhyUshort(sc, 0x0F) | 0x0003);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-
-                for (Data_u32=0x800E0068; Data_u32<0x800E006D; Data_u32++) {
-                        CSR_WRITE_4(sc, 0xF8, Data_u32);
-                        for (i=0; i<10; i++) {
-                                DELAY(400);
-                                if ((CSR_READ_4(sc, 0xF8)&0x80000000)==0)
-                                        break;
-                        }
-                }
-        } else if (sc->re_type == MACFG_42 || sc->re_type == MACFG_43) {
-                Data_u32 = re_eri_read(sc, 0x1D0, 4, ERIAR_ExGMAC);
-                Data_u32 &= 0xFFFF0000;
-                re_eri_write(sc, 0x1D0, 4, Data_u32, ERIAR_ExGMAC);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-                MP_WritePhyUshort(sc, 0x18, 0x0310);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1f, 0x0004);
-                MP_WritePhyUshort(sc, 0x1f, 0x0004);
-                MP_WritePhyUshort(sc, 0x19, 0x7070);
-                MP_WritePhyUshort(sc, 0x1c, 0x0600);
-                MP_WritePhyUshort(sc, 0x1d, 0x9700);
-                MP_WritePhyUshort(sc, 0x1d, 0x7d00);
-                MP_WritePhyUshort(sc, 0x1d, 0x6900);
-                MP_WritePhyUshort(sc, 0x1d, 0x7d00);
-                MP_WritePhyUshort(sc, 0x1d, 0x6800);
-                MP_WritePhyUshort(sc, 0x1d, 0x4899);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
-                MP_WritePhyUshort(sc, 0x1d, 0x4c00);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
-                MP_WritePhyUshort(sc, 0x1d, 0x4c01);
-                MP_WritePhyUshort(sc, 0x1d, 0x8000);
-                MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
-                MP_WritePhyUshort(sc, 0x1d, 0x4c00);
-                MP_WritePhyUshort(sc, 0x1d, 0x4007);
-                MP_WritePhyUshort(sc, 0x1d, 0x4400);
-                MP_WritePhyUshort(sc, 0x1d, 0x4800);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
-                MP_WritePhyUshort(sc, 0x1d, 0x4c00);
-                MP_WritePhyUshort(sc, 0x1d, 0x5310);
-                MP_WritePhyUshort(sc, 0x1d, 0x6000);
-                MP_WritePhyUshort(sc, 0x1d, 0x6800);
-                MP_WritePhyUshort(sc, 0x1d, 0x6736);
-                MP_WritePhyUshort(sc, 0x1d, 0x0000);
-                MP_WritePhyUshort(sc, 0x1d, 0x0000);
-                MP_WritePhyUshort(sc, 0x1d, 0x571f);
-                MP_WritePhyUshort(sc, 0x1d, 0x5ffb);
-                MP_WritePhyUshort(sc, 0x1d, 0xaa03);
-                MP_WritePhyUshort(sc, 0x1d, 0x5b58);
-                MP_WritePhyUshort(sc, 0x1d, 0x301e);
-                MP_WritePhyUshort(sc, 0x1d, 0x5b64);
-                MP_WritePhyUshort(sc, 0x1d, 0xa6fc);
-                MP_WritePhyUshort(sc, 0x1d, 0xdcdb);
-                MP_WritePhyUshort(sc, 0x1d, 0x0014);
-                MP_WritePhyUshort(sc, 0x1d, 0xd9a9);
-                MP_WritePhyUshort(sc, 0x1d, 0x0013);
-                MP_WritePhyUshort(sc, 0x1d, 0xd16b);
-                MP_WritePhyUshort(sc, 0x1d, 0x0011);
-                MP_WritePhyUshort(sc, 0x1d, 0xb40e);
-                MP_WritePhyUshort(sc, 0x1d, 0xd06b);
-                MP_WritePhyUshort(sc, 0x1d, 0x000c);
-                MP_WritePhyUshort(sc, 0x1d, 0xb206);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c01);
-                MP_WritePhyUshort(sc, 0x1d, 0x5800);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c04);
-                MP_WritePhyUshort(sc, 0x1d, 0x5c00);
-                MP_WritePhyUshort(sc, 0x1d, 0x301a);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c01);
-                MP_WritePhyUshort(sc, 0x1d, 0x5801);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c04);
-                MP_WritePhyUshort(sc, 0x1d, 0x5c04);
-                MP_WritePhyUshort(sc, 0x1d, 0x301e);
-                MP_WritePhyUshort(sc, 0x1d, 0x314d);
-                MP_WritePhyUshort(sc, 0x1d, 0x31f0);
-                MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
-                MP_WritePhyUshort(sc, 0x1d, 0x4c20);
-                MP_WritePhyUshort(sc, 0x1d, 0x6004);
-                MP_WritePhyUshort(sc, 0x1d, 0x5310);
-                MP_WritePhyUshort(sc, 0x1d, 0x4833);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
-                MP_WritePhyUshort(sc, 0x1d, 0x4c00);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
-                MP_WritePhyUshort(sc, 0x1d, 0x4c08);
-                MP_WritePhyUshort(sc, 0x1d, 0x8300);
-                MP_WritePhyUshort(sc, 0x1d, 0x6800);
-                MP_WritePhyUshort(sc, 0x1d, 0x6600);
-                MP_WritePhyUshort(sc, 0x1d, 0x0000);
-                MP_WritePhyUshort(sc, 0x1d, 0x0000);
-                MP_WritePhyUshort(sc, 0x1d, 0xb90c);
-                MP_WritePhyUshort(sc, 0x1d, 0x30d3);
-                MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
-                MP_WritePhyUshort(sc, 0x1d, 0x4de0);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c04);
-                MP_WritePhyUshort(sc, 0x1d, 0x6000);
-                MP_WritePhyUshort(sc, 0x1d, 0x6800);
-                MP_WritePhyUshort(sc, 0x1d, 0x6736);
-                MP_WritePhyUshort(sc, 0x1d, 0x0000);
-                MP_WritePhyUshort(sc, 0x1d, 0x0000);
-                MP_WritePhyUshort(sc, 0x1d, 0x5310);
-                MP_WritePhyUshort(sc, 0x1d, 0x300b);
-                MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
-                MP_WritePhyUshort(sc, 0x1d, 0x4c60);
-                MP_WritePhyUshort(sc, 0x1d, 0x6803);
-                MP_WritePhyUshort(sc, 0x1d, 0x6520);
-                MP_WritePhyUshort(sc, 0x1d, 0x0000);
-                MP_WritePhyUshort(sc, 0x1d, 0x0000);
-                MP_WritePhyUshort(sc, 0x1d, 0xaf03);
-                MP_WritePhyUshort(sc, 0x1d, 0x6015);
-                MP_WritePhyUshort(sc, 0x1d, 0x3059);
-                MP_WritePhyUshort(sc, 0x1d, 0x6017);
-                MP_WritePhyUshort(sc, 0x1d, 0x57e0);
-                MP_WritePhyUshort(sc, 0x1d, 0x580c);
-                MP_WritePhyUshort(sc, 0x1d, 0x588c);
-                MP_WritePhyUshort(sc, 0x1d, 0x7ffc);
-                MP_WritePhyUshort(sc, 0x1d, 0x5fa3);
-                MP_WritePhyUshort(sc, 0x1d, 0x4827);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
-                MP_WritePhyUshort(sc, 0x1d, 0x4c00);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
-                MP_WritePhyUshort(sc, 0x1d, 0x4c10);
-                MP_WritePhyUshort(sc, 0x1d, 0x8400);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c30);
-                MP_WritePhyUshort(sc, 0x1d, 0x6020);
-                MP_WritePhyUshort(sc, 0x1d, 0x48bf);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
-                MP_WritePhyUshort(sc, 0x1d, 0x4c00);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
-                MP_WritePhyUshort(sc, 0x1d, 0x4c01);
-                MP_WritePhyUshort(sc, 0x1d, 0xad09);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c03);
-                MP_WritePhyUshort(sc, 0x1d, 0x5c03);
-                MP_WritePhyUshort(sc, 0x1d, 0x0000);
-                MP_WritePhyUshort(sc, 0x1d, 0x0000);
-                MP_WritePhyUshort(sc, 0x1d, 0x0000);
-                MP_WritePhyUshort(sc, 0x1d, 0x0000);
-                MP_WritePhyUshort(sc, 0x1d, 0x0000);
-                MP_WritePhyUshort(sc, 0x1d, 0x4400);
-                MP_WritePhyUshort(sc, 0x1d, 0xad2c);
-                MP_WritePhyUshort(sc, 0x1d, 0xd6cf);
-                MP_WritePhyUshort(sc, 0x1d, 0x0002);
-                MP_WritePhyUshort(sc, 0x1d, 0x80f4);
-                MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
-                MP_WritePhyUshort(sc, 0x1d, 0x4c80);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c20);
-                MP_WritePhyUshort(sc, 0x1d, 0x5c20);
-                MP_WritePhyUshort(sc, 0x1d, 0x481e);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
-                MP_WritePhyUshort(sc, 0x1d, 0x4c00);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
-                MP_WritePhyUshort(sc, 0x1d, 0x4c02);
-                MP_WritePhyUshort(sc, 0x1d, 0xad0a);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c03);
-                MP_WritePhyUshort(sc, 0x1d, 0x5c03);
-                MP_WritePhyUshort(sc, 0x1d, 0x0000);
-                MP_WritePhyUshort(sc, 0x1d, 0x0000);
-                MP_WritePhyUshort(sc, 0x1d, 0x0000);
-                MP_WritePhyUshort(sc, 0x1d, 0x0000);
-                MP_WritePhyUshort(sc, 0x1d, 0x0000);
-                MP_WritePhyUshort(sc, 0x1d, 0x4400);
-                MP_WritePhyUshort(sc, 0x1d, 0x5310);
-                MP_WritePhyUshort(sc, 0x1d, 0x8d02);
-                MP_WritePhyUshort(sc, 0x1d, 0x4401);
-                MP_WritePhyUshort(sc, 0x1d, 0x81f4);
-                MP_WritePhyUshort(sc, 0x1d, 0x3114);
-                MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
-                MP_WritePhyUshort(sc, 0x1d, 0x4d00);
-                MP_WritePhyUshort(sc, 0x1d, 0x4832);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
-                MP_WritePhyUshort(sc, 0x1d, 0x4c00);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
-                MP_WritePhyUshort(sc, 0x1d, 0x4c10);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c08);
-                MP_WritePhyUshort(sc, 0x1d, 0x6000);
-                MP_WritePhyUshort(sc, 0x1d, 0xa4b7);
-                MP_WritePhyUshort(sc, 0x1d, 0xd9b3);
-                MP_WritePhyUshort(sc, 0x1d, 0xfffe);
-                MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
-                MP_WritePhyUshort(sc, 0x1d, 0x4d20);
-                MP_WritePhyUshort(sc, 0x1d, 0x7e00);
-                MP_WritePhyUshort(sc, 0x1d, 0x6200);
-                MP_WritePhyUshort(sc, 0x1d, 0x3045);
-                MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
-                MP_WritePhyUshort(sc, 0x1d, 0x4d40);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c40);
-                MP_WritePhyUshort(sc, 0x1d, 0x6000);
-                MP_WritePhyUshort(sc, 0x1d, 0x4401);
-                MP_WritePhyUshort(sc, 0x1d, 0x5210);
-                MP_WritePhyUshort(sc, 0x1d, 0x4833);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c08);
-                MP_WritePhyUshort(sc, 0x1d, 0x4c00);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c08);
-                MP_WritePhyUshort(sc, 0x1d, 0x4c08);
-                MP_WritePhyUshort(sc, 0x1d, 0x8300);
-                MP_WritePhyUshort(sc, 0x1d, 0x5f80);
-                MP_WritePhyUshort(sc, 0x1d, 0x55e0);
-                MP_WritePhyUshort(sc, 0x1d, 0xc06f);
-                MP_WritePhyUshort(sc, 0x1d, 0x0005);
-                MP_WritePhyUshort(sc, 0x1d, 0xd9b3);
-                MP_WritePhyUshort(sc, 0x1d, 0xfffd);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c40);
-                MP_WritePhyUshort(sc, 0x1d, 0x6040);
-                MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
-                MP_WritePhyUshort(sc, 0x1d, 0x4d60);
-                MP_WritePhyUshort(sc, 0x1d, 0x57e0);
-                MP_WritePhyUshort(sc, 0x1d, 0x4814);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c04);
-                MP_WritePhyUshort(sc, 0x1d, 0x4c00);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c04);
-                MP_WritePhyUshort(sc, 0x1d, 0x4c04);
-                MP_WritePhyUshort(sc, 0x1d, 0x8200);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c03);
-                MP_WritePhyUshort(sc, 0x1d, 0x5c03);
-                MP_WritePhyUshort(sc, 0x1d, 0x0000);
-                MP_WritePhyUshort(sc, 0x1d, 0x0000);
-                MP_WritePhyUshort(sc, 0x1d, 0x0000);
-                MP_WritePhyUshort(sc, 0x1d, 0x0000);
-                MP_WritePhyUshort(sc, 0x1d, 0x0000);
-                MP_WritePhyUshort(sc, 0x1d, 0xad02);
-                MP_WritePhyUshort(sc, 0x1d, 0x4400);
-                MP_WritePhyUshort(sc, 0x1d, 0xc0e9);
-                MP_WritePhyUshort(sc, 0x1d, 0x0003);
-                MP_WritePhyUshort(sc, 0x1d, 0xadd8);
-                MP_WritePhyUshort(sc, 0x1d, 0x30c6);
-                MP_WritePhyUshort(sc, 0x1d, 0x3078);
-                MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
-                MP_WritePhyUshort(sc, 0x1d, 0x4dc0);
-                MP_WritePhyUshort(sc, 0x1d, 0x6730);
-                MP_WritePhyUshort(sc, 0x1d, 0x0000);
-                MP_WritePhyUshort(sc, 0x1d, 0x0000);
-                MP_WritePhyUshort(sc, 0x1d, 0xd09d);
-                MP_WritePhyUshort(sc, 0x1d, 0x0002);
-                MP_WritePhyUshort(sc, 0x1d, 0xb4fe);
-                MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
-                MP_WritePhyUshort(sc, 0x1d, 0x4d80);
-                MP_WritePhyUshort(sc, 0x1d, 0x6802);
-                MP_WritePhyUshort(sc, 0x1d, 0x6600);
-                MP_WritePhyUshort(sc, 0x1d, 0x0000);
-                MP_WritePhyUshort(sc, 0x1d, 0x0000);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c08);
-                MP_WritePhyUshort(sc, 0x1d, 0x6000);
-                MP_WritePhyUshort(sc, 0x1d, 0x486c);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
-                MP_WritePhyUshort(sc, 0x1d, 0x4c00);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
-                MP_WritePhyUshort(sc, 0x1d, 0x4c01);
-                MP_WritePhyUshort(sc, 0x1d, 0x9503);
-                MP_WritePhyUshort(sc, 0x1d, 0x7e00);
-                MP_WritePhyUshort(sc, 0x1d, 0x6200);
-                MP_WritePhyUshort(sc, 0x1d, 0x571f);
-                MP_WritePhyUshort(sc, 0x1d, 0x5fbb);
-                MP_WritePhyUshort(sc, 0x1d, 0xaa03);
-                MP_WritePhyUshort(sc, 0x1d, 0x5b58);
-                MP_WritePhyUshort(sc, 0x1d, 0x30e9);
-                MP_WritePhyUshort(sc, 0x1d, 0x5b64);
-                MP_WritePhyUshort(sc, 0x1d, 0xcdab);
-                MP_WritePhyUshort(sc, 0x1d, 0xff5b);
-                MP_WritePhyUshort(sc, 0x1d, 0xcd8d);
-                MP_WritePhyUshort(sc, 0x1d, 0xff59);
-                MP_WritePhyUshort(sc, 0x1d, 0xd96b);
-                MP_WritePhyUshort(sc, 0x1d, 0xff57);
-                MP_WritePhyUshort(sc, 0x1d, 0xd0a0);
-                MP_WritePhyUshort(sc, 0x1d, 0xffdb);
-                MP_WritePhyUshort(sc, 0x1d, 0xcba0);
-                MP_WritePhyUshort(sc, 0x1d, 0x0003);
-                MP_WritePhyUshort(sc, 0x1d, 0x80f0);
-                MP_WritePhyUshort(sc, 0x1d, 0x30f6);
-                MP_WritePhyUshort(sc, 0x1d, 0x3109);
-                MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
-                MP_WritePhyUshort(sc, 0x1d, 0x4ce0);
-                MP_WritePhyUshort(sc, 0x1d, 0x7d30);
-                MP_WritePhyUshort(sc, 0x1d, 0x6530);
-                MP_WritePhyUshort(sc, 0x1d, 0x0000);
-                MP_WritePhyUshort(sc, 0x1d, 0x0000);
-                MP_WritePhyUshort(sc, 0x1d, 0x7ce0);
-                MP_WritePhyUshort(sc, 0x1d, 0x5400);
-                MP_WritePhyUshort(sc, 0x1d, 0x4832);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
-                MP_WritePhyUshort(sc, 0x1d, 0x4c00);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
-                MP_WritePhyUshort(sc, 0x1d, 0x4c08);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c08);
-                MP_WritePhyUshort(sc, 0x1d, 0x6008);
-                MP_WritePhyUshort(sc, 0x1d, 0x8300);
-                MP_WritePhyUshort(sc, 0x1d, 0xb902);
-                MP_WritePhyUshort(sc, 0x1d, 0x30d3);
-                MP_WritePhyUshort(sc, 0x1d, 0x308f);
-                MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
-                MP_WritePhyUshort(sc, 0x1d, 0x4da0);
-                MP_WritePhyUshort(sc, 0x1d, 0x57a0);
-                MP_WritePhyUshort(sc, 0x1d, 0x590c);
-                MP_WritePhyUshort(sc, 0x1d, 0x5fa2);
-                MP_WritePhyUshort(sc, 0x1d, 0xcba4);
-                MP_WritePhyUshort(sc, 0x1d, 0x0005);
-                MP_WritePhyUshort(sc, 0x1d, 0xcd8d);
-                MP_WritePhyUshort(sc, 0x1d, 0x0003);
-                MP_WritePhyUshort(sc, 0x1d, 0x80fc);
-                MP_WritePhyUshort(sc, 0x1d, 0x0000);
-                MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
-                MP_WritePhyUshort(sc, 0x1d, 0x4ca0);
-                MP_WritePhyUshort(sc, 0x1d, 0xb603);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c10);
-                MP_WritePhyUshort(sc, 0x1d, 0x6010);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
-                MP_WritePhyUshort(sc, 0x1d, 0x541f);
-                MP_WritePhyUshort(sc, 0x1d, 0x7ffc);
-                MP_WritePhyUshort(sc, 0x1d, 0x5fb3);
-                MP_WritePhyUshort(sc, 0x1d, 0x9403);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c03);
-                MP_WritePhyUshort(sc, 0x1d, 0x5c03);
-                MP_WritePhyUshort(sc, 0x1d, 0xaa05);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c80);
-                MP_WritePhyUshort(sc, 0x1d, 0x5800);
-                MP_WritePhyUshort(sc, 0x1d, 0x5b58);
-                MP_WritePhyUshort(sc, 0x1d, 0x3128);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c80);
-                MP_WritePhyUshort(sc, 0x1d, 0x5800);
-                MP_WritePhyUshort(sc, 0x1d, 0x5b64);
-                MP_WritePhyUshort(sc, 0x1d, 0x4827);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
-                MP_WritePhyUshort(sc, 0x1d, 0x4c00);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
-                MP_WritePhyUshort(sc, 0x1d, 0x4c10);
-                MP_WritePhyUshort(sc, 0x1d, 0x8400);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c10);
-                MP_WritePhyUshort(sc, 0x1d, 0x6000);
-                MP_WritePhyUshort(sc, 0x1d, 0x4824);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
-                MP_WritePhyUshort(sc, 0x1d, 0x4c00);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
-                MP_WritePhyUshort(sc, 0x1d, 0x4c04);
-                MP_WritePhyUshort(sc, 0x1d, 0x8200);
-                MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
-                MP_WritePhyUshort(sc, 0x1d, 0x4cc0);
-                MP_WritePhyUshort(sc, 0x1d, 0x7d00);
-                MP_WritePhyUshort(sc, 0x1d, 0x6400);
-                MP_WritePhyUshort(sc, 0x1d, 0x7ffc);
-                MP_WritePhyUshort(sc, 0x1d, 0x5fbb);
-                MP_WritePhyUshort(sc, 0x1d, 0x4824);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
-                MP_WritePhyUshort(sc, 0x1d, 0x4c00);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
-                MP_WritePhyUshort(sc, 0x1d, 0x4c04);
-                MP_WritePhyUshort(sc, 0x1d, 0x8200);
-                MP_WritePhyUshort(sc, 0x1d, 0x7e00);
-                MP_WritePhyUshort(sc, 0x1d, 0x6a00);
-                MP_WritePhyUshort(sc, 0x1d, 0x4824);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
-                MP_WritePhyUshort(sc, 0x1d, 0x4c00);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
-                MP_WritePhyUshort(sc, 0x1d, 0x4c04);
-                MP_WritePhyUshort(sc, 0x1d, 0x8200);
-                MP_WritePhyUshort(sc, 0x1d, 0x7e00);
-                MP_WritePhyUshort(sc, 0x1d, 0x6800);
-                MP_WritePhyUshort(sc, 0x1d, 0x30f6);
-                MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
-                MP_WritePhyUshort(sc, 0x1d, 0x4e00);
-                MP_WritePhyUshort(sc, 0x1d, 0x4007);
-                MP_WritePhyUshort(sc, 0x1d, 0x4400);
-                MP_WritePhyUshort(sc, 0x1d, 0x5310);
-                MP_WritePhyUshort(sc, 0x1d, 0x6800);
-                MP_WritePhyUshort(sc, 0x1d, 0x6736);
-                MP_WritePhyUshort(sc, 0x1d, 0x0000);
-                MP_WritePhyUshort(sc, 0x1d, 0x0000);
-                MP_WritePhyUshort(sc, 0x1d, 0x570f);
-                MP_WritePhyUshort(sc, 0x1d, 0x5fff);
-                MP_WritePhyUshort(sc, 0x1d, 0xaa03);
-                MP_WritePhyUshort(sc, 0x1d, 0x585b);
-                MP_WritePhyUshort(sc, 0x1d, 0x315c);
-                MP_WritePhyUshort(sc, 0x1d, 0x5867);
-                MP_WritePhyUshort(sc, 0x1d, 0x9402);
-                MP_WritePhyUshort(sc, 0x1d, 0x6200);
-                MP_WritePhyUshort(sc, 0x1d, 0xcda3);
-                MP_WritePhyUshort(sc, 0x1d, 0x009d);
-                MP_WritePhyUshort(sc, 0x1d, 0xcd85);
-                MP_WritePhyUshort(sc, 0x1d, 0x009b);
-                MP_WritePhyUshort(sc, 0x1d, 0xd96b);
-                MP_WritePhyUshort(sc, 0x1d, 0x0099);
-                MP_WritePhyUshort(sc, 0x1d, 0x96e9);
-                MP_WritePhyUshort(sc, 0x1d, 0x6800);
-                MP_WritePhyUshort(sc, 0x1d, 0x6736);
-                MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
-                MP_WritePhyUshort(sc, 0x1d, 0x4e20);
-                MP_WritePhyUshort(sc, 0x1d, 0x96e4);
-                MP_WritePhyUshort(sc, 0x1d, 0x8b04);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c08);
-                MP_WritePhyUshort(sc, 0x1d, 0x5008);
-                MP_WritePhyUshort(sc, 0x1d, 0xab03);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c08);
-                MP_WritePhyUshort(sc, 0x1d, 0x5000);
-                MP_WritePhyUshort(sc, 0x1d, 0x6801);
-                MP_WritePhyUshort(sc, 0x1d, 0x6776);
-                MP_WritePhyUshort(sc, 0x1d, 0x0000);
-                MP_WritePhyUshort(sc, 0x1d, 0x0000);
-                MP_WritePhyUshort(sc, 0x1d, 0xdb7c);
-                MP_WritePhyUshort(sc, 0x1d, 0xfff0);
-                MP_WritePhyUshort(sc, 0x1d, 0x0000);
-                MP_WritePhyUshort(sc, 0x1d, 0x7fe1);
-                MP_WritePhyUshort(sc, 0x1d, 0x4e40);
-                MP_WritePhyUshort(sc, 0x1d, 0x4837);
-                MP_WritePhyUshort(sc, 0x1d, 0x4418);
-                MP_WritePhyUshort(sc, 0x1d, 0x41c7);
-                MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
-                MP_WritePhyUshort(sc, 0x1d, 0x4e40);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c40);
-                MP_WritePhyUshort(sc, 0x1d, 0x5400);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
-                MP_WritePhyUshort(sc, 0x1d, 0x4c01);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
-                MP_WritePhyUshort(sc, 0x1d, 0x4c01);
-                MP_WritePhyUshort(sc, 0x1d, 0x8fc9);
-                MP_WritePhyUshort(sc, 0x1d, 0xd2a0);
-                MP_WritePhyUshort(sc, 0x1d, 0x004a);
-                MP_WritePhyUshort(sc, 0x1d, 0x9203);
-                MP_WritePhyUshort(sc, 0x1d, 0xa041);
-                MP_WritePhyUshort(sc, 0x1d, 0x3184);
-                MP_WritePhyUshort(sc, 0x1d, 0x7fe1);
-                MP_WritePhyUshort(sc, 0x1d, 0x4e60);
-                MP_WritePhyUshort(sc, 0x1d, 0x489c);
-                MP_WritePhyUshort(sc, 0x1d, 0x4628);
-                MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
-                MP_WritePhyUshort(sc, 0x1d, 0x4e60);
-                MP_WritePhyUshort(sc, 0x1d, 0x7e28);
-                MP_WritePhyUshort(sc, 0x1d, 0x4628);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c40);
-                MP_WritePhyUshort(sc, 0x1d, 0x5400);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c01);
-                MP_WritePhyUshort(sc, 0x1d, 0x5800);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c04);
-                MP_WritePhyUshort(sc, 0x1d, 0x5c00);
-                MP_WritePhyUshort(sc, 0x1d, 0x41e8);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
-                MP_WritePhyUshort(sc, 0x1d, 0x4c01);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
-                MP_WritePhyUshort(sc, 0x1d, 0x4c01);
-                MP_WritePhyUshort(sc, 0x1d, 0x8fb0);
-                MP_WritePhyUshort(sc, 0x1d, 0xb241);
-                MP_WritePhyUshort(sc, 0x1d, 0xa02a);
-                MP_WritePhyUshort(sc, 0x1d, 0x319d);
-                MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
-                MP_WritePhyUshort(sc, 0x1d, 0x4ea0);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c02);
-                MP_WritePhyUshort(sc, 0x1d, 0x4402);
-                MP_WritePhyUshort(sc, 0x1d, 0x4448);
-                MP_WritePhyUshort(sc, 0x1d, 0x4894);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
-                MP_WritePhyUshort(sc, 0x1d, 0x4c01);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
-                MP_WritePhyUshort(sc, 0x1d, 0x4c03);
-                MP_WritePhyUshort(sc, 0x1d, 0x4824);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
-                MP_WritePhyUshort(sc, 0x1d, 0x4c07);
-                MP_WritePhyUshort(sc, 0x1d, 0x41ef);
-                MP_WritePhyUshort(sc, 0x1d, 0x41ff);
-                MP_WritePhyUshort(sc, 0x1d, 0x4891);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
-                MP_WritePhyUshort(sc, 0x1d, 0x4c07);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
-                MP_WritePhyUshort(sc, 0x1d, 0x4c17);
-                MP_WritePhyUshort(sc, 0x1d, 0x8400);
-                MP_WritePhyUshort(sc, 0x1d, 0x8ef8);
-                MP_WritePhyUshort(sc, 0x1d, 0x41c7);
-                MP_WritePhyUshort(sc, 0x1d, 0x8f95);
-                MP_WritePhyUshort(sc, 0x1d, 0x92d5);
-                MP_WritePhyUshort(sc, 0x1d, 0xa10f);
-                MP_WritePhyUshort(sc, 0x1d, 0xd480);
-                MP_WritePhyUshort(sc, 0x1d, 0x0008);
-                MP_WritePhyUshort(sc, 0x1d, 0xd580);
-                MP_WritePhyUshort(sc, 0x1d, 0xffb9);
-                MP_WritePhyUshort(sc, 0x1d, 0xa202);
-                MP_WritePhyUshort(sc, 0x1d, 0x31b8);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c04);
-                MP_WritePhyUshort(sc, 0x1d, 0x4404);
-                MP_WritePhyUshort(sc, 0x1d, 0x31b8);
-                MP_WritePhyUshort(sc, 0x1d, 0xd484);
-                MP_WritePhyUshort(sc, 0x1d, 0xfff3);
-                MP_WritePhyUshort(sc, 0x1d, 0xd484);
-                MP_WritePhyUshort(sc, 0x1d, 0xfff1);
-                MP_WritePhyUshort(sc, 0x1d, 0x314d);
-                MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
-                MP_WritePhyUshort(sc, 0x1d, 0x4ee0);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c40);
-                MP_WritePhyUshort(sc, 0x1d, 0x5400);
-                MP_WritePhyUshort(sc, 0x1d, 0x4488);
-                MP_WritePhyUshort(sc, 0x1d, 0x41cf);
-                MP_WritePhyUshort(sc, 0x1d, 0x314d);
-                MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
-                MP_WritePhyUshort(sc, 0x1d, 0x4ec0);
-                MP_WritePhyUshort(sc, 0x1d, 0x48f3);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
-                MP_WritePhyUshort(sc, 0x1d, 0x4c01);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
-                MP_WritePhyUshort(sc, 0x1d, 0x4c09);
-                MP_WritePhyUshort(sc, 0x1d, 0x4508);
-                MP_WritePhyUshort(sc, 0x1d, 0x41c7);
-                MP_WritePhyUshort(sc, 0x1d, 0x8f24);
-                MP_WritePhyUshort(sc, 0x1d, 0xd218);
-                MP_WritePhyUshort(sc, 0x1d, 0x0022);
-                MP_WritePhyUshort(sc, 0x1d, 0xd2a4);
-                MP_WritePhyUshort(sc, 0x1d, 0xff9f);
-                MP_WritePhyUshort(sc, 0x1d, 0x31d9);
-                MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
-                MP_WritePhyUshort(sc, 0x1d, 0x4e80);
-                MP_WritePhyUshort(sc, 0x1d, 0x4832);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
-                MP_WritePhyUshort(sc, 0x1d, 0x4c01);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
-                MP_WritePhyUshort(sc, 0x1d, 0x4c11);
-                MP_WritePhyUshort(sc, 0x1d, 0x4428);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c40);
-                MP_WritePhyUshort(sc, 0x1d, 0x5440);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c01);
-                MP_WritePhyUshort(sc, 0x1d, 0x5801);
-                MP_WritePhyUshort(sc, 0x1d, 0x7c04);
-                MP_WritePhyUshort(sc, 0x1d, 0x5c04);
-                MP_WritePhyUshort(sc, 0x1d, 0x41e8);
-                MP_WritePhyUshort(sc, 0x1d, 0xa4b3);
-                MP_WritePhyUshort(sc, 0x1d, 0x31ee);
-                MP_WritePhyUshort(sc, 0x1d, 0x6800);
-                MP_WritePhyUshort(sc, 0x1d, 0x6736);
-                MP_WritePhyUshort(sc, 0x1d, 0x0000);
-                MP_WritePhyUshort(sc, 0x1d, 0x0000);
-                MP_WritePhyUshort(sc, 0x1d, 0x570f);
-                MP_WritePhyUshort(sc, 0x1d, 0x5fff);
-                MP_WritePhyUshort(sc, 0x1d, 0xaa03);
-                MP_WritePhyUshort(sc, 0x1d, 0x585b);
-                MP_WritePhyUshort(sc, 0x1d, 0x31fa);
-                MP_WritePhyUshort(sc, 0x1d, 0x5867);
-                MP_WritePhyUshort(sc, 0x1d, 0xbcf6);
-                MP_WritePhyUshort(sc, 0x1d, 0x300b);
-                MP_WritePhyUshort(sc, 0x1d, 0x300b);
-                MP_WritePhyUshort(sc, 0x1d, 0x314d);
-                MP_WritePhyUshort(sc, 0x1f, 0x0004);
-                MP_WritePhyUshort(sc, 0x1c, 0x0200);
-                MP_WritePhyUshort(sc, 0x19, 0x7030);
+                MP_WritePhyUshort(sc, 0x1f, 0x0007);
+                MP_WritePhyUshort(sc, 0x1e, 0x0023);
+                MP_WritePhyUshort(sc, 0x16, 0x0306);
+                MP_WritePhyUshort(sc, 0x16, 0x0307);
+                MP_WritePhyUshort(sc, 0x15, 0x000e);
+                MP_WritePhyUshort(sc, 0x19, 0x000a);
+                MP_WritePhyUshort(sc, 0x15, 0x0010);
+                MP_WritePhyUshort(sc, 0x19, 0x0008);
+                MP_WritePhyUshort(sc, 0x15, 0x0018);
+                MP_WritePhyUshort(sc, 0x19, 0x4801);
+                MP_WritePhyUshort(sc, 0x15, 0x0019);
+                MP_WritePhyUshort(sc, 0x19, 0x6801);
+                MP_WritePhyUshort(sc, 0x15, 0x001a);
+                MP_WritePhyUshort(sc, 0x19, 0x66a1);
+                MP_WritePhyUshort(sc, 0x15, 0x001f);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x0020);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x0021);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x0022);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x0023);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x0024);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x0025);
+                MP_WritePhyUshort(sc, 0x19, 0x64a1);
+                MP_WritePhyUshort(sc, 0x15, 0x0026);
+                MP_WritePhyUshort(sc, 0x19, 0x40ea);
+                MP_WritePhyUshort(sc, 0x15, 0x0027);
+                MP_WritePhyUshort(sc, 0x19, 0x4503);
+                MP_WritePhyUshort(sc, 0x15, 0x0028);
+                MP_WritePhyUshort(sc, 0x19, 0x9f00);
+                MP_WritePhyUshort(sc, 0x15, 0x0029);
+                MP_WritePhyUshort(sc, 0x19, 0xa631);
+                MP_WritePhyUshort(sc, 0x15, 0x002a);
+                MP_WritePhyUshort(sc, 0x19, 0x9717);
+                MP_WritePhyUshort(sc, 0x15, 0x002b);
+                MP_WritePhyUshort(sc, 0x19, 0x302c);
+                MP_WritePhyUshort(sc, 0x15, 0x002c);
+                MP_WritePhyUshort(sc, 0x19, 0x4802);
+                MP_WritePhyUshort(sc, 0x15, 0x002d);
+                MP_WritePhyUshort(sc, 0x19, 0x58da);
+                MP_WritePhyUshort(sc, 0x15, 0x002e);
+                MP_WritePhyUshort(sc, 0x19, 0x400d);
+                MP_WritePhyUshort(sc, 0x15, 0x002f);
+                MP_WritePhyUshort(sc, 0x19, 0x4488);
+                MP_WritePhyUshort(sc, 0x15, 0x0030);
+                MP_WritePhyUshort(sc, 0x19, 0x9e00);
+                MP_WritePhyUshort(sc, 0x15, 0x0031);
+                MP_WritePhyUshort(sc, 0x19, 0x63c8);
+                MP_WritePhyUshort(sc, 0x15, 0x0032);
+                MP_WritePhyUshort(sc, 0x19, 0x6481);
+                MP_WritePhyUshort(sc, 0x15, 0x0033);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x0034);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x0035);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x0036);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x0037);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x0038);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x0039);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x003a);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x003b);
+                MP_WritePhyUshort(sc, 0x19, 0x63e8);
+                MP_WritePhyUshort(sc, 0x15, 0x003c);
+                MP_WritePhyUshort(sc, 0x19, 0x7d00);
+                MP_WritePhyUshort(sc, 0x15, 0x003d);
+                MP_WritePhyUshort(sc, 0x19, 0x59d4);
+                MP_WritePhyUshort(sc, 0x15, 0x003e);
+                MP_WritePhyUshort(sc, 0x19, 0x63f8);
+                MP_WritePhyUshort(sc, 0x15, 0x0040);
+                MP_WritePhyUshort(sc, 0x19, 0x64a1);
+                MP_WritePhyUshort(sc, 0x15, 0x0041);
+                MP_WritePhyUshort(sc, 0x19, 0x30de);
+                MP_WritePhyUshort(sc, 0x15, 0x0044);
+                MP_WritePhyUshort(sc, 0x19, 0x480f);
+                MP_WritePhyUshort(sc, 0x15, 0x0045);
+                MP_WritePhyUshort(sc, 0x19, 0x6800);
+                MP_WritePhyUshort(sc, 0x15, 0x0046);
+                MP_WritePhyUshort(sc, 0x19, 0x6680);
+                MP_WritePhyUshort(sc, 0x15, 0x0047);
+                MP_WritePhyUshort(sc, 0x19, 0x7c10);
+                MP_WritePhyUshort(sc, 0x15, 0x0048);
+                MP_WritePhyUshort(sc, 0x19, 0x63c8);
+                MP_WritePhyUshort(sc, 0x15, 0x0049);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x004a);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x004b);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x004c);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x004d);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x004e);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x004f);
+                MP_WritePhyUshort(sc, 0x19, 0x40ea);
+                MP_WritePhyUshort(sc, 0x15, 0x0050);
+                MP_WritePhyUshort(sc, 0x19, 0x4503);
+                MP_WritePhyUshort(sc, 0x15, 0x0051);
+                MP_WritePhyUshort(sc, 0x19, 0x58ca);
+                MP_WritePhyUshort(sc, 0x15, 0x0052);
+                MP_WritePhyUshort(sc, 0x19, 0x63c8);
+                MP_WritePhyUshort(sc, 0x15, 0x0053);
+                MP_WritePhyUshort(sc, 0x19, 0x63d8);
+                MP_WritePhyUshort(sc, 0x15, 0x0054);
+                MP_WritePhyUshort(sc, 0x19, 0x66a0);
+                MP_WritePhyUshort(sc, 0x15, 0x0055);
+                MP_WritePhyUshort(sc, 0x19, 0x9f00);
+                MP_WritePhyUshort(sc, 0x15, 0x0056);
+                MP_WritePhyUshort(sc, 0x19, 0x3000);
+                MP_WritePhyUshort(sc, 0x15, 0x00a1);
+                MP_WritePhyUshort(sc, 0x19, 0x3044);
+                MP_WritePhyUshort(sc, 0x15, 0x00ab);
+                MP_WritePhyUshort(sc, 0x19, 0x5820);
+                MP_WritePhyUshort(sc, 0x15, 0x00ac);
+                MP_WritePhyUshort(sc, 0x19, 0x5e04);
+                MP_WritePhyUshort(sc, 0x15, 0x00ad);
+                MP_WritePhyUshort(sc, 0x19, 0xb60c);
+                MP_WritePhyUshort(sc, 0x15, 0x00af);
+                MP_WritePhyUshort(sc, 0x19, 0x000a);
+                MP_WritePhyUshort(sc, 0x15, 0x00b2);
+                MP_WritePhyUshort(sc, 0x19, 0x30b9);
+                MP_WritePhyUshort(sc, 0x15, 0x00b9);
+                MP_WritePhyUshort(sc, 0x19, 0x4408);
+                MP_WritePhyUshort(sc, 0x15, 0x00ba);
+                MP_WritePhyUshort(sc, 0x19, 0x480b);
+                MP_WritePhyUshort(sc, 0x15, 0x00bb);
+                MP_WritePhyUshort(sc, 0x19, 0x5e00);
+                MP_WritePhyUshort(sc, 0x15, 0x00bc);
+                MP_WritePhyUshort(sc, 0x19, 0x405f);
+                MP_WritePhyUshort(sc, 0x15, 0x00bd);
+                MP_WritePhyUshort(sc, 0x19, 0x4448);
+                MP_WritePhyUshort(sc, 0x15, 0x00be);
+                MP_WritePhyUshort(sc, 0x19, 0x4020);
+                MP_WritePhyUshort(sc, 0x15, 0x00bf);
+                MP_WritePhyUshort(sc, 0x19, 0x4468);
+                MP_WritePhyUshort(sc, 0x15, 0x00c0);
+                MP_WritePhyUshort(sc, 0x19, 0x9c02);
+                MP_WritePhyUshort(sc, 0x15, 0x00c1);
+                MP_WritePhyUshort(sc, 0x19, 0x58a0);
+                MP_WritePhyUshort(sc, 0x15, 0x00c2);
+                MP_WritePhyUshort(sc, 0x19, 0xb605);
+                MP_WritePhyUshort(sc, 0x15, 0x00c3);
+                MP_WritePhyUshort(sc, 0x19, 0xc0d3);
+                MP_WritePhyUshort(sc, 0x15, 0x00c4);
+                MP_WritePhyUshort(sc, 0x19, 0x00e6);
+                MP_WritePhyUshort(sc, 0x15, 0x00c5);
+                MP_WritePhyUshort(sc, 0x19, 0xdaec);
+                MP_WritePhyUshort(sc, 0x15, 0x00c6);
+                MP_WritePhyUshort(sc, 0x19, 0x00fa);
+                MP_WritePhyUshort(sc, 0x15, 0x00c7);
+                MP_WritePhyUshort(sc, 0x19, 0x9df9);
+                MP_WritePhyUshort(sc, 0x15, 0x0112);
+                MP_WritePhyUshort(sc, 0x19, 0x6421);
+                MP_WritePhyUshort(sc, 0x15, 0x0113);
+                MP_WritePhyUshort(sc, 0x19, 0x7c08);
+                MP_WritePhyUshort(sc, 0x15, 0x0114);
+                MP_WritePhyUshort(sc, 0x19, 0x63f0);
+                MP_WritePhyUshort(sc, 0x15, 0x0115);
+                MP_WritePhyUshort(sc, 0x19, 0x4003);
+                MP_WritePhyUshort(sc, 0x15, 0x0116);
+                MP_WritePhyUshort(sc, 0x19, 0x4418);
+                MP_WritePhyUshort(sc, 0x15, 0x0117);
+                MP_WritePhyUshort(sc, 0x19, 0x9b00);
+                MP_WritePhyUshort(sc, 0x15, 0x0118);
+                MP_WritePhyUshort(sc, 0x19, 0x6461);
+                MP_WritePhyUshort(sc, 0x15, 0x0119);
+                MP_WritePhyUshort(sc, 0x19, 0x64e1);
+                MP_WritePhyUshort(sc, 0x15, 0x011a);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x0150);
+                MP_WritePhyUshort(sc, 0x19, 0x7c80);
+                MP_WritePhyUshort(sc, 0x15, 0x0151);
+                MP_WritePhyUshort(sc, 0x19, 0x6461);
+                MP_WritePhyUshort(sc, 0x15, 0x0152);
+                MP_WritePhyUshort(sc, 0x19, 0x4003);
+                MP_WritePhyUshort(sc, 0x15, 0x0153);
+                MP_WritePhyUshort(sc, 0x19, 0x4540);
+                MP_WritePhyUshort(sc, 0x15, 0x0154);
+                MP_WritePhyUshort(sc, 0x19, 0x9f00);
+                MP_WritePhyUshort(sc, 0x15, 0x0155);
+                MP_WritePhyUshort(sc, 0x19, 0x9d00);
+                MP_WritePhyUshort(sc, 0x15, 0x0156);
+                MP_WritePhyUshort(sc, 0x19, 0x7c40);
+                MP_WritePhyUshort(sc, 0x15, 0x0157);
+                MP_WritePhyUshort(sc, 0x19, 0x6421);
+                MP_WritePhyUshort(sc, 0x15, 0x0158);
+                MP_WritePhyUshort(sc, 0x19, 0x7c80);
+                MP_WritePhyUshort(sc, 0x15, 0x0159);
+                MP_WritePhyUshort(sc, 0x19, 0x64a1);
+                MP_WritePhyUshort(sc, 0x15, 0x015a);
+                MP_WritePhyUshort(sc, 0x19, 0x30fe);
+                MP_WritePhyUshort(sc, 0x15, 0x029c);
+                MP_WritePhyUshort(sc, 0x19, 0x0070);
+                MP_WritePhyUshort(sc, 0x15, 0x02b2);
+                MP_WritePhyUshort(sc, 0x19, 0x005a);
+                MP_WritePhyUshort(sc, 0x15, 0x02bd);
+                MP_WritePhyUshort(sc, 0x19, 0xa522);
+                MP_WritePhyUshort(sc, 0x15, 0x02ce);
+                MP_WritePhyUshort(sc, 0x19, 0xb63e);
+                MP_WritePhyUshort(sc, 0x15, 0x02d9);
+                MP_WritePhyUshort(sc, 0x19, 0x32df);
+                MP_WritePhyUshort(sc, 0x15, 0x02df);
+                MP_WritePhyUshort(sc, 0x19, 0x4500);
+                MP_WritePhyUshort(sc, 0x15, 0x02e7);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x02f4);
+                MP_WritePhyUshort(sc, 0x19, 0xb618);
+                MP_WritePhyUshort(sc, 0x15, 0x02fb);
+                MP_WritePhyUshort(sc, 0x19, 0xb900);
+                MP_WritePhyUshort(sc, 0x15, 0x02fc);
+                MP_WritePhyUshort(sc, 0x19, 0x49b5);
+                MP_WritePhyUshort(sc, 0x15, 0x02fd);
+                MP_WritePhyUshort(sc, 0x19, 0x6812);
+                MP_WritePhyUshort(sc, 0x15, 0x02fe);
+                MP_WritePhyUshort(sc, 0x19, 0x66a0);
+                MP_WritePhyUshort(sc, 0x15, 0x02ff);
+                MP_WritePhyUshort(sc, 0x19, 0x9900);
+                MP_WritePhyUshort(sc, 0x15, 0x0300);
+                MP_WritePhyUshort(sc, 0x19, 0x64a0);
+                MP_WritePhyUshort(sc, 0x15, 0x0301);
+                MP_WritePhyUshort(sc, 0x19, 0x3316);
+                MP_WritePhyUshort(sc, 0x15, 0x0308);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x030c);
+                MP_WritePhyUshort(sc, 0x19, 0x3000);
+                MP_WritePhyUshort(sc, 0x15, 0x0312);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x0313);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x0314);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x0315);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x0316);
+                MP_WritePhyUshort(sc, 0x19, 0x49b5);
+                MP_WritePhyUshort(sc, 0x15, 0x0317);
+                MP_WritePhyUshort(sc, 0x19, 0x7d00);
+                MP_WritePhyUshort(sc, 0x15, 0x0318);
+                MP_WritePhyUshort(sc, 0x19, 0x4d00);
+                MP_WritePhyUshort(sc, 0x15, 0x0319);
+                MP_WritePhyUshort(sc, 0x19, 0x6810);
+                MP_WritePhyUshort(sc, 0x15, 0x031a);
+                MP_WritePhyUshort(sc, 0x19, 0x6c08);
+                MP_WritePhyUshort(sc, 0x15, 0x031b);
+                MP_WritePhyUshort(sc, 0x19, 0x4925);
+                MP_WritePhyUshort(sc, 0x15, 0x031c);
+                MP_WritePhyUshort(sc, 0x19, 0x403b);
+                MP_WritePhyUshort(sc, 0x15, 0x031d);
+                MP_WritePhyUshort(sc, 0x19, 0xa602);
+                MP_WritePhyUshort(sc, 0x15, 0x031e);
+                MP_WritePhyUshort(sc, 0x19, 0x402f);
+                MP_WritePhyUshort(sc, 0x15, 0x031f);
+                MP_WritePhyUshort(sc, 0x19, 0x4484);
+                MP_WritePhyUshort(sc, 0x15, 0x0320);
+                MP_WritePhyUshort(sc, 0x19, 0x40c8);
+                MP_WritePhyUshort(sc, 0x15, 0x0321);
+                MP_WritePhyUshort(sc, 0x19, 0x44c4);
+                MP_WritePhyUshort(sc, 0x15, 0x0322);
+                MP_WritePhyUshort(sc, 0x19, 0x404f);
+                MP_WritePhyUshort(sc, 0x15, 0x0323);
+                MP_WritePhyUshort(sc, 0x19, 0x44c8);
+                MP_WritePhyUshort(sc, 0x15, 0x0324);
+                MP_WritePhyUshort(sc, 0x19, 0xd64f);
+                MP_WritePhyUshort(sc, 0x15, 0x0325);
+                MP_WritePhyUshort(sc, 0x19, 0x00e7);
+                MP_WritePhyUshort(sc, 0x15, 0x0326);
+                MP_WritePhyUshort(sc, 0x19, 0x7c08);
+                MP_WritePhyUshort(sc, 0x15, 0x0327);
+                MP_WritePhyUshort(sc, 0x19, 0x8203);
+                MP_WritePhyUshort(sc, 0x15, 0x0328);
+                MP_WritePhyUshort(sc, 0x19, 0x4d48);
+                MP_WritePhyUshort(sc, 0x15, 0x0329);
+                MP_WritePhyUshort(sc, 0x19, 0x332b);
+                MP_WritePhyUshort(sc, 0x15, 0x032a);
+                MP_WritePhyUshort(sc, 0x19, 0x4d40);
+                MP_WritePhyUshort(sc, 0x15, 0x032c);
+                MP_WritePhyUshort(sc, 0x19, 0x00f8);
+                MP_WritePhyUshort(sc, 0x15, 0x032d);
+                MP_WritePhyUshort(sc, 0x19, 0x82b2);
+                MP_WritePhyUshort(sc, 0x15, 0x032f);
+                MP_WritePhyUshort(sc, 0x19, 0x00b0);
+                MP_WritePhyUshort(sc, 0x15, 0x0332);
+                MP_WritePhyUshort(sc, 0x19, 0x91f2);
+                MP_WritePhyUshort(sc, 0x15, 0x033f);
+                MP_WritePhyUshort(sc, 0x19, 0xb6cd);
+                MP_WritePhyUshort(sc, 0x15, 0x0340);
+                MP_WritePhyUshort(sc, 0x19, 0x9e01);
+                MP_WritePhyUshort(sc, 0x15, 0x0341);
+                MP_WritePhyUshort(sc, 0x19, 0xd11d);
+                MP_WritePhyUshort(sc, 0x15, 0x0342);
+                MP_WritePhyUshort(sc, 0x19, 0x009d);
+                MP_WritePhyUshort(sc, 0x15, 0x0343);
+                MP_WritePhyUshort(sc, 0x19, 0xbb1c);
+                MP_WritePhyUshort(sc, 0x15, 0x0344);
+                MP_WritePhyUshort(sc, 0x19, 0x8102);
+                MP_WritePhyUshort(sc, 0x15, 0x0345);
+                MP_WritePhyUshort(sc, 0x19, 0x3348);
+                MP_WritePhyUshort(sc, 0x15, 0x0346);
+                MP_WritePhyUshort(sc, 0x19, 0xa231);
+                MP_WritePhyUshort(sc, 0x15, 0x0347);
+                MP_WritePhyUshort(sc, 0x19, 0x335b);
+                MP_WritePhyUshort(sc, 0x15, 0x0348);
+                MP_WritePhyUshort(sc, 0x19, 0x91f7);
+                MP_WritePhyUshort(sc, 0x15, 0x0349);
+                MP_WritePhyUshort(sc, 0x19, 0xc218);
+                MP_WritePhyUshort(sc, 0x15, 0x034a);
+                MP_WritePhyUshort(sc, 0x19, 0x00f5);
+                MP_WritePhyUshort(sc, 0x15, 0x034b);
+                MP_WritePhyUshort(sc, 0x19, 0x335b);
+                MP_WritePhyUshort(sc, 0x15, 0x034c);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x034d);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x034e);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x034f);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x0350);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x035b);
+                MP_WritePhyUshort(sc, 0x19, 0xa23c);
+                MP_WritePhyUshort(sc, 0x15, 0x035c);
+                MP_WritePhyUshort(sc, 0x19, 0x7c08);
+                MP_WritePhyUshort(sc, 0x15, 0x035d);
+                MP_WritePhyUshort(sc, 0x19, 0x4c00);
+                MP_WritePhyUshort(sc, 0x15, 0x035e);
+                MP_WritePhyUshort(sc, 0x19, 0x3397);
+                MP_WritePhyUshort(sc, 0x15, 0x0363);
+                MP_WritePhyUshort(sc, 0x19, 0xb6a9);
+                MP_WritePhyUshort(sc, 0x15, 0x0366);
+                MP_WritePhyUshort(sc, 0x19, 0x00f5);
+                MP_WritePhyUshort(sc, 0x15, 0x0382);
+                MP_WritePhyUshort(sc, 0x19, 0x7c40);
+                MP_WritePhyUshort(sc, 0x15, 0x0388);
+                MP_WritePhyUshort(sc, 0x19, 0x0084);
+                MP_WritePhyUshort(sc, 0x15, 0x0389);
+                MP_WritePhyUshort(sc, 0x19, 0xdd17);
+                MP_WritePhyUshort(sc, 0x15, 0x038a);
+                MP_WritePhyUshort(sc, 0x19, 0x000b);
+                MP_WritePhyUshort(sc, 0x15, 0x038b);
+                MP_WritePhyUshort(sc, 0x19, 0xa10a);
+                MP_WritePhyUshort(sc, 0x15, 0x038c);
+                MP_WritePhyUshort(sc, 0x19, 0x337e);
+                MP_WritePhyUshort(sc, 0x15, 0x038d);
+                MP_WritePhyUshort(sc, 0x19, 0x6c0b);
+                MP_WritePhyUshort(sc, 0x15, 0x038e);
+                MP_WritePhyUshort(sc, 0x19, 0xa107);
+                MP_WritePhyUshort(sc, 0x15, 0x038f);
+                MP_WritePhyUshort(sc, 0x19, 0x6c08);
+                MP_WritePhyUshort(sc, 0x15, 0x0390);
+                MP_WritePhyUshort(sc, 0x19, 0xc017);
+                MP_WritePhyUshort(sc, 0x15, 0x0391);
+                MP_WritePhyUshort(sc, 0x19, 0x0004);
+                MP_WritePhyUshort(sc, 0x15, 0x0392);
+                MP_WritePhyUshort(sc, 0x19, 0xd64f);
+                MP_WritePhyUshort(sc, 0x15, 0x0393);
+                MP_WritePhyUshort(sc, 0x19, 0x00f4);
+                MP_WritePhyUshort(sc, 0x15, 0x0397);
+                MP_WritePhyUshort(sc, 0x19, 0x4098);
+                MP_WritePhyUshort(sc, 0x15, 0x0398);
+                MP_WritePhyUshort(sc, 0x19, 0x4408);
+                MP_WritePhyUshort(sc, 0x15, 0x0399);
+                MP_WritePhyUshort(sc, 0x19, 0x55bf);
+                MP_WritePhyUshort(sc, 0x15, 0x039a);
+                MP_WritePhyUshort(sc, 0x19, 0x4bb9);
+                MP_WritePhyUshort(sc, 0x15, 0x039b);
+                MP_WritePhyUshort(sc, 0x19, 0x6810);
+                MP_WritePhyUshort(sc, 0x15, 0x039c);
+                MP_WritePhyUshort(sc, 0x19, 0x4b29);
+                MP_WritePhyUshort(sc, 0x15, 0x039d);
+                MP_WritePhyUshort(sc, 0x19, 0x4041);
+                MP_WritePhyUshort(sc, 0x15, 0x039e);
+                MP_WritePhyUshort(sc, 0x19, 0x442a);
+                MP_WritePhyUshort(sc, 0x15, 0x039f);
+                MP_WritePhyUshort(sc, 0x19, 0x4029);
+                MP_WritePhyUshort(sc, 0x15, 0x03aa);
+                MP_WritePhyUshort(sc, 0x19, 0x33b8);
+                MP_WritePhyUshort(sc, 0x15, 0x03b6);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x03b7);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x03b8);
+                MP_WritePhyUshort(sc, 0x19, 0x543f);
+                MP_WritePhyUshort(sc, 0x15, 0x03b9);
+                MP_WritePhyUshort(sc, 0x19, 0x499a);
+                MP_WritePhyUshort(sc, 0x15, 0x03ba);
+                MP_WritePhyUshort(sc, 0x19, 0x7c40);
+                MP_WritePhyUshort(sc, 0x15, 0x03bb);
+                MP_WritePhyUshort(sc, 0x19, 0x4c40);
+                MP_WritePhyUshort(sc, 0x15, 0x03bc);
+                MP_WritePhyUshort(sc, 0x19, 0x490a);
+                MP_WritePhyUshort(sc, 0x15, 0x03bd);
+                MP_WritePhyUshort(sc, 0x19, 0x405e);
+                MP_WritePhyUshort(sc, 0x15, 0x03c2);
+                MP_WritePhyUshort(sc, 0x19, 0x9a03);
+                MP_WritePhyUshort(sc, 0x15, 0x03c4);
+                MP_WritePhyUshort(sc, 0x19, 0x0015);
+                MP_WritePhyUshort(sc, 0x15, 0x03c5);
+                MP_WritePhyUshort(sc, 0x19, 0x9e03);
+                MP_WritePhyUshort(sc, 0x15, 0x03c8);
+                MP_WritePhyUshort(sc, 0x19, 0x9cf7);
+                MP_WritePhyUshort(sc, 0x15, 0x03c9);
+                MP_WritePhyUshort(sc, 0x19, 0x7c12);
+                MP_WritePhyUshort(sc, 0x15, 0x03ca);
+                MP_WritePhyUshort(sc, 0x19, 0x4c52);
+                MP_WritePhyUshort(sc, 0x15, 0x03cb);
+                MP_WritePhyUshort(sc, 0x19, 0x4458);
+                MP_WritePhyUshort(sc, 0x15, 0x03cd);
+                MP_WritePhyUshort(sc, 0x19, 0x4c40);
+                MP_WritePhyUshort(sc, 0x15, 0x03ce);
+                MP_WritePhyUshort(sc, 0x19, 0x33bf);
+                MP_WritePhyUshort(sc, 0x15, 0x03cf);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x03d0);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x03d1);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x03d5);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x03d6);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x03d7);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x03d8);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x03d9);
+                MP_WritePhyUshort(sc, 0x19, 0x49bb);
+                MP_WritePhyUshort(sc, 0x15, 0x03da);
+                MP_WritePhyUshort(sc, 0x19, 0x4478);
+                MP_WritePhyUshort(sc, 0x15, 0x03db);
+                MP_WritePhyUshort(sc, 0x19, 0x492b);
+                MP_WritePhyUshort(sc, 0x15, 0x03dc);
+                MP_WritePhyUshort(sc, 0x19, 0x7c01);
+                MP_WritePhyUshort(sc, 0x15, 0x03dd);
+                MP_WritePhyUshort(sc, 0x19, 0x4c00);
+                MP_WritePhyUshort(sc, 0x15, 0x03de);
+                MP_WritePhyUshort(sc, 0x19, 0xbd1a);
+                MP_WritePhyUshort(sc, 0x15, 0x03df);
+                MP_WritePhyUshort(sc, 0x19, 0xc428);
+                MP_WritePhyUshort(sc, 0x15, 0x03e0);
+                MP_WritePhyUshort(sc, 0x19, 0x0008);
+                MP_WritePhyUshort(sc, 0x15, 0x03e1);
+                MP_WritePhyUshort(sc, 0x19, 0x9cfd);
+                MP_WritePhyUshort(sc, 0x15, 0x03e2);
+                MP_WritePhyUshort(sc, 0x19, 0x7c12);
+                MP_WritePhyUshort(sc, 0x15, 0x03e3);
+                MP_WritePhyUshort(sc, 0x19, 0x4c52);
+                MP_WritePhyUshort(sc, 0x15, 0x03e4);
+                MP_WritePhyUshort(sc, 0x19, 0x4458);
+                MP_WritePhyUshort(sc, 0x15, 0x03e5);
+                MP_WritePhyUshort(sc, 0x19, 0x7c12);
+                MP_WritePhyUshort(sc, 0x15, 0x03e6);
+                MP_WritePhyUshort(sc, 0x19, 0x4c40);
+                MP_WritePhyUshort(sc, 0x15, 0x03e7);
+                MP_WritePhyUshort(sc, 0x19, 0x33de);
+                MP_WritePhyUshort(sc, 0x15, 0x03e8);
+                MP_WritePhyUshort(sc, 0x19, 0xc218);
+                MP_WritePhyUshort(sc, 0x15, 0x03e9);
+                MP_WritePhyUshort(sc, 0x19, 0x0002);
+                MP_WritePhyUshort(sc, 0x15, 0x03ea);
+                MP_WritePhyUshort(sc, 0x19, 0x32df);
+                MP_WritePhyUshort(sc, 0x15, 0x03eb);
+                MP_WritePhyUshort(sc, 0x19, 0x3316);
+                MP_WritePhyUshort(sc, 0x15, 0x03ec);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x03ed);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x03ee);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x03ef);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x03f7);
+                MP_WritePhyUshort(sc, 0x19, 0x330c);
+                MP_WritePhyUshort(sc, 0x16, 0x0306);
+                MP_WritePhyUshort(sc, 0x16, 0x0300);
+                MP_WritePhyUshort(sc, 0x1f, 0x0005);
+                MP_WritePhyUshort(sc, 0x05, 0xfff6);
+                MP_WritePhyUshort(sc, 0x06, 0x0080);
+                MP_WritePhyUshort(sc, 0x05, 0x8000);
+                MP_WritePhyUshort(sc, 0x06, 0x0280);
+                MP_WritePhyUshort(sc, 0x06, 0x48f7);
+                MP_WritePhyUshort(sc, 0x06, 0x00e0);
+                MP_WritePhyUshort(sc, 0x06, 0xfff7);
+                MP_WritePhyUshort(sc, 0x06, 0xa080);
+                MP_WritePhyUshort(sc, 0x06, 0x02ae);
+                MP_WritePhyUshort(sc, 0x06, 0xf602);
+                MP_WritePhyUshort(sc, 0x06, 0x0200);
+                MP_WritePhyUshort(sc, 0x06, 0x0280);
+                MP_WritePhyUshort(sc, 0x06, 0x9002);
+                MP_WritePhyUshort(sc, 0x06, 0x0224);
+                MP_WritePhyUshort(sc, 0x06, 0x0202);
+                MP_WritePhyUshort(sc, 0x06, 0x3402);
+                MP_WritePhyUshort(sc, 0x06, 0x027f);
+                MP_WritePhyUshort(sc, 0x06, 0x0280);
+                MP_WritePhyUshort(sc, 0x06, 0xa602);
+                MP_WritePhyUshort(sc, 0x06, 0x80bf);
+                MP_WritePhyUshort(sc, 0x06, 0xe08b);
+                MP_WritePhyUshort(sc, 0x06, 0x88e1);
+                MP_WritePhyUshort(sc, 0x06, 0x8b89);
+                MP_WritePhyUshort(sc, 0x06, 0x1e01);
+                MP_WritePhyUshort(sc, 0x06, 0xe18b);
+                MP_WritePhyUshort(sc, 0x06, 0x8a1e);
+                MP_WritePhyUshort(sc, 0x06, 0x01e1);
+                MP_WritePhyUshort(sc, 0x06, 0x8b8b);
+                MP_WritePhyUshort(sc, 0x06, 0x1e01);
+                MP_WritePhyUshort(sc, 0x06, 0xe18b);
+                MP_WritePhyUshort(sc, 0x06, 0x8c1e);
+                MP_WritePhyUshort(sc, 0x06, 0x01e1);
+                MP_WritePhyUshort(sc, 0x06, 0x8b8d);
+                MP_WritePhyUshort(sc, 0x06, 0x1e01);
+                MP_WritePhyUshort(sc, 0x06, 0xe18b);
+                MP_WritePhyUshort(sc, 0x06, 0x8e1e);
+                MP_WritePhyUshort(sc, 0x06, 0x01a0);
+                MP_WritePhyUshort(sc, 0x06, 0x00c7);
+                MP_WritePhyUshort(sc, 0x06, 0xaebb);
+                MP_WritePhyUshort(sc, 0x06, 0xee8a);
+                MP_WritePhyUshort(sc, 0x06, 0xe600);
+                MP_WritePhyUshort(sc, 0x06, 0xee8a);
+                MP_WritePhyUshort(sc, 0x06, 0xee03);
+                MP_WritePhyUshort(sc, 0x06, 0xee8a);
+                MP_WritePhyUshort(sc, 0x06, 0xefb8);
+                MP_WritePhyUshort(sc, 0x06, 0xee8a);
+                MP_WritePhyUshort(sc, 0x06, 0xe902);
+                MP_WritePhyUshort(sc, 0x06, 0xee8b);
+                MP_WritePhyUshort(sc, 0x06, 0x8285);
+                MP_WritePhyUshort(sc, 0x06, 0xee8b);
+                MP_WritePhyUshort(sc, 0x06, 0x8520);
+                MP_WritePhyUshort(sc, 0x06, 0xee8b);
+                MP_WritePhyUshort(sc, 0x06, 0x8701);
+                MP_WritePhyUshort(sc, 0x06, 0xd481);
+                MP_WritePhyUshort(sc, 0x06, 0x35e4);
+                MP_WritePhyUshort(sc, 0x06, 0x8b94);
+                MP_WritePhyUshort(sc, 0x06, 0xe58b);
+                MP_WritePhyUshort(sc, 0x06, 0x95bf);
+                MP_WritePhyUshort(sc, 0x06, 0x8b88);
+                MP_WritePhyUshort(sc, 0x06, 0xec00);
+                MP_WritePhyUshort(sc, 0x06, 0x19a9);
+                MP_WritePhyUshort(sc, 0x06, 0x8b90);
+                MP_WritePhyUshort(sc, 0x06, 0xf9ee);
+                MP_WritePhyUshort(sc, 0x06, 0xfff6);
+                MP_WritePhyUshort(sc, 0x06, 0x00ee);
+                MP_WritePhyUshort(sc, 0x06, 0xfff7);
+                MP_WritePhyUshort(sc, 0x06, 0xffe0);
+                MP_WritePhyUshort(sc, 0x06, 0xe140);
+                MP_WritePhyUshort(sc, 0x06, 0xe1e1);
+                MP_WritePhyUshort(sc, 0x06, 0x41f7);
+                MP_WritePhyUshort(sc, 0x06, 0x2ff6);
+                MP_WritePhyUshort(sc, 0x06, 0x28e4);
+                MP_WritePhyUshort(sc, 0x06, 0xe140);
+                MP_WritePhyUshort(sc, 0x06, 0xe5e1);
+                MP_WritePhyUshort(sc, 0x06, 0x4104);
+                MP_WritePhyUshort(sc, 0x06, 0xf8e0);
+                MP_WritePhyUshort(sc, 0x06, 0x8b89);
+                MP_WritePhyUshort(sc, 0x06, 0xad20);
+                MP_WritePhyUshort(sc, 0x06, 0x0dee);
+                MP_WritePhyUshort(sc, 0x06, 0x8b89);
+                MP_WritePhyUshort(sc, 0x06, 0x0002);
+                MP_WritePhyUshort(sc, 0x06, 0x82f4);
+                MP_WritePhyUshort(sc, 0x06, 0x021f);
+                MP_WritePhyUshort(sc, 0x06, 0x4102);
+                MP_WritePhyUshort(sc, 0x06, 0x2812);
+                MP_WritePhyUshort(sc, 0x06, 0xfc04);
+                MP_WritePhyUshort(sc, 0x06, 0xf8e0);
+                MP_WritePhyUshort(sc, 0x06, 0x8b8d);
+                MP_WritePhyUshort(sc, 0x06, 0xad20);
+                MP_WritePhyUshort(sc, 0x06, 0x10ee);
+                MP_WritePhyUshort(sc, 0x06, 0x8b8d);
+                MP_WritePhyUshort(sc, 0x06, 0x0002);
+                MP_WritePhyUshort(sc, 0x06, 0x139d);
+                MP_WritePhyUshort(sc, 0x06, 0x0281);
+                MP_WritePhyUshort(sc, 0x06, 0xd602);
+                MP_WritePhyUshort(sc, 0x06, 0x1f99);
+                MP_WritePhyUshort(sc, 0x06, 0x0227);
+                MP_WritePhyUshort(sc, 0x06, 0xeafc);
+                MP_WritePhyUshort(sc, 0x06, 0x04f8);
+                MP_WritePhyUshort(sc, 0x06, 0xe08b);
+                MP_WritePhyUshort(sc, 0x06, 0x8ead);
+                MP_WritePhyUshort(sc, 0x06, 0x2014);
+                MP_WritePhyUshort(sc, 0x06, 0xf620);
+                MP_WritePhyUshort(sc, 0x06, 0xe48b);
+                MP_WritePhyUshort(sc, 0x06, 0x8e02);
+                MP_WritePhyUshort(sc, 0x06, 0x8104);
+                MP_WritePhyUshort(sc, 0x06, 0x021b);
+                MP_WritePhyUshort(sc, 0x06, 0xf402);
+                MP_WritePhyUshort(sc, 0x06, 0x2c9c);
+                MP_WritePhyUshort(sc, 0x06, 0x0281);
+                MP_WritePhyUshort(sc, 0x06, 0x7902);
+                MP_WritePhyUshort(sc, 0x06, 0x8443);
+                MP_WritePhyUshort(sc, 0x06, 0xad22);
+                MP_WritePhyUshort(sc, 0x06, 0x11f6);
+                MP_WritePhyUshort(sc, 0x06, 0x22e4);
+                MP_WritePhyUshort(sc, 0x06, 0x8b8e);
+                MP_WritePhyUshort(sc, 0x06, 0x022c);
+                MP_WritePhyUshort(sc, 0x06, 0x4602);
+                MP_WritePhyUshort(sc, 0x06, 0x2ac5);
+                MP_WritePhyUshort(sc, 0x06, 0x0229);
+                MP_WritePhyUshort(sc, 0x06, 0x2002);
+                MP_WritePhyUshort(sc, 0x06, 0x2b91);
+                MP_WritePhyUshort(sc, 0x06, 0xad25);
+                MP_WritePhyUshort(sc, 0x06, 0x11f6);
+                MP_WritePhyUshort(sc, 0x06, 0x25e4);
+                MP_WritePhyUshort(sc, 0x06, 0x8b8e);
+                MP_WritePhyUshort(sc, 0x06, 0x0284);
+                MP_WritePhyUshort(sc, 0x06, 0xe202);
+                MP_WritePhyUshort(sc, 0x06, 0x043a);
+                MP_WritePhyUshort(sc, 0x06, 0x021a);
+                MP_WritePhyUshort(sc, 0x06, 0x5902);
+                MP_WritePhyUshort(sc, 0x06, 0x2bfc);
+                MP_WritePhyUshort(sc, 0x06, 0xfc04);
+                MP_WritePhyUshort(sc, 0x06, 0xf8fa);
+                MP_WritePhyUshort(sc, 0x06, 0xef69);
+                MP_WritePhyUshort(sc, 0x06, 0xe0e0);
+                MP_WritePhyUshort(sc, 0x06, 0x00e1);
+                MP_WritePhyUshort(sc, 0x06, 0xe001);
+                MP_WritePhyUshort(sc, 0x06, 0xad27);
+                MP_WritePhyUshort(sc, 0x06, 0x1fd1);
+                MP_WritePhyUshort(sc, 0x06, 0x01bf);
+                MP_WritePhyUshort(sc, 0x06, 0x8638);
+                MP_WritePhyUshort(sc, 0x06, 0x022f);
+                MP_WritePhyUshort(sc, 0x06, 0x50e0);
+                MP_WritePhyUshort(sc, 0x06, 0xe020);
+                MP_WritePhyUshort(sc, 0x06, 0xe1e0);
+                MP_WritePhyUshort(sc, 0x06, 0x21ad);
+                MP_WritePhyUshort(sc, 0x06, 0x200e);
+                MP_WritePhyUshort(sc, 0x06, 0xd100);
+                MP_WritePhyUshort(sc, 0x06, 0xbf86);
+                MP_WritePhyUshort(sc, 0x06, 0x3802);
+                MP_WritePhyUshort(sc, 0x06, 0x2f50);
+                MP_WritePhyUshort(sc, 0x06, 0xbf3d);
+                MP_WritePhyUshort(sc, 0x06, 0x3902);
+                MP_WritePhyUshort(sc, 0x06, 0x2eb0);
+                MP_WritePhyUshort(sc, 0x06, 0xef96);
+                MP_WritePhyUshort(sc, 0x06, 0xfefc);
+                MP_WritePhyUshort(sc, 0x06, 0x0402);
+                MP_WritePhyUshort(sc, 0x06, 0x8591);
+                MP_WritePhyUshort(sc, 0x06, 0x0281);
+                MP_WritePhyUshort(sc, 0x06, 0x3c05);
+                MP_WritePhyUshort(sc, 0x06, 0xf8fa);
+                MP_WritePhyUshort(sc, 0x06, 0xef69);
+                MP_WritePhyUshort(sc, 0x06, 0xe0e2);
+                MP_WritePhyUshort(sc, 0x06, 0xfee1);
+                MP_WritePhyUshort(sc, 0x06, 0xe2ff);
+                MP_WritePhyUshort(sc, 0x06, 0xad2d);
+                MP_WritePhyUshort(sc, 0x06, 0x1ae0);
+                MP_WritePhyUshort(sc, 0x06, 0xe14e);
+                MP_WritePhyUshort(sc, 0x06, 0xe1e1);
+                MP_WritePhyUshort(sc, 0x06, 0x4fac);
+                MP_WritePhyUshort(sc, 0x06, 0x2d22);
+                MP_WritePhyUshort(sc, 0x06, 0xf603);
+                MP_WritePhyUshort(sc, 0x06, 0x0203);
+                MP_WritePhyUshort(sc, 0x06, 0x36f7);
+                MP_WritePhyUshort(sc, 0x06, 0x03f7);
+                MP_WritePhyUshort(sc, 0x06, 0x06bf);
+                MP_WritePhyUshort(sc, 0x06, 0x8622);
+                MP_WritePhyUshort(sc, 0x06, 0x022e);
+                MP_WritePhyUshort(sc, 0x06, 0xb0ae);
+                MP_WritePhyUshort(sc, 0x06, 0x11e0);
+                MP_WritePhyUshort(sc, 0x06, 0xe14e);
+                MP_WritePhyUshort(sc, 0x06, 0xe1e1);
+                MP_WritePhyUshort(sc, 0x06, 0x4fad);
+                MP_WritePhyUshort(sc, 0x06, 0x2d08);
+                MP_WritePhyUshort(sc, 0x06, 0xbf86);
+                MP_WritePhyUshort(sc, 0x06, 0x2d02);
+                MP_WritePhyUshort(sc, 0x06, 0x2eb0);
+                MP_WritePhyUshort(sc, 0x06, 0xf606);
+                MP_WritePhyUshort(sc, 0x06, 0xef96);
+                MP_WritePhyUshort(sc, 0x06, 0xfefc);
+                MP_WritePhyUshort(sc, 0x06, 0x04f8);
+                MP_WritePhyUshort(sc, 0x06, 0xf9fa);
+                MP_WritePhyUshort(sc, 0x06, 0xef69);
+                MP_WritePhyUshort(sc, 0x06, 0xe08b);
+                MP_WritePhyUshort(sc, 0x06, 0x87ad);
+                MP_WritePhyUshort(sc, 0x06, 0x204c);
+                MP_WritePhyUshort(sc, 0x06, 0xd200);
+                MP_WritePhyUshort(sc, 0x06, 0xe0e2);
+                MP_WritePhyUshort(sc, 0x06, 0x0058);
+                MP_WritePhyUshort(sc, 0x06, 0x010c);
+                MP_WritePhyUshort(sc, 0x06, 0x021e);
+                MP_WritePhyUshort(sc, 0x06, 0x20e0);
+                MP_WritePhyUshort(sc, 0x06, 0xe000);
+                MP_WritePhyUshort(sc, 0x06, 0x5810);
+                MP_WritePhyUshort(sc, 0x06, 0x1e20);
+                MP_WritePhyUshort(sc, 0x06, 0xe0e0);
+                MP_WritePhyUshort(sc, 0x06, 0x3658);
+                MP_WritePhyUshort(sc, 0x06, 0x031e);
+                MP_WritePhyUshort(sc, 0x06, 0x20e0);
+                MP_WritePhyUshort(sc, 0x06, 0xe022);
+                MP_WritePhyUshort(sc, 0x06, 0xe1e0);
+                MP_WritePhyUshort(sc, 0x06, 0x2358);
+                MP_WritePhyUshort(sc, 0x06, 0xe01e);
+                MP_WritePhyUshort(sc, 0x06, 0x20e0);
+                MP_WritePhyUshort(sc, 0x06, 0x8ae6);
+                MP_WritePhyUshort(sc, 0x06, 0x1f02);
+                MP_WritePhyUshort(sc, 0x06, 0x9e22);
+                MP_WritePhyUshort(sc, 0x06, 0xe68a);
+                MP_WritePhyUshort(sc, 0x06, 0xe6ad);
+                MP_WritePhyUshort(sc, 0x06, 0x3214);
+                MP_WritePhyUshort(sc, 0x06, 0xad34);
+                MP_WritePhyUshort(sc, 0x06, 0x11ef);
+                MP_WritePhyUshort(sc, 0x06, 0x0258);
+                MP_WritePhyUshort(sc, 0x06, 0x039e);
+                MP_WritePhyUshort(sc, 0x06, 0x07ad);
+                MP_WritePhyUshort(sc, 0x06, 0x3508);
+                MP_WritePhyUshort(sc, 0x06, 0x5ac0);
+                MP_WritePhyUshort(sc, 0x06, 0x9f04);
+                MP_WritePhyUshort(sc, 0x06, 0xd101);
+                MP_WritePhyUshort(sc, 0x06, 0xae02);
+                MP_WritePhyUshort(sc, 0x06, 0xd100);
+                MP_WritePhyUshort(sc, 0x06, 0xbf86);
+                MP_WritePhyUshort(sc, 0x06, 0x3e02);
+                MP_WritePhyUshort(sc, 0x06, 0x2f50);
+                MP_WritePhyUshort(sc, 0x06, 0xef96);
+                MP_WritePhyUshort(sc, 0x06, 0xfefd);
+                MP_WritePhyUshort(sc, 0x06, 0xfc04);
+                MP_WritePhyUshort(sc, 0x06, 0xf8f9);
+                MP_WritePhyUshort(sc, 0x06, 0xfae0);
+                MP_WritePhyUshort(sc, 0x06, 0x8b81);
+                MP_WritePhyUshort(sc, 0x06, 0xac26);
+                MP_WritePhyUshort(sc, 0x06, 0x0ee0);
+                MP_WritePhyUshort(sc, 0x06, 0x8b81);
+                MP_WritePhyUshort(sc, 0x06, 0xac21);
+                MP_WritePhyUshort(sc, 0x06, 0x08e0);
+                MP_WritePhyUshort(sc, 0x06, 0x8b87);
+                MP_WritePhyUshort(sc, 0x06, 0xac24);
+                MP_WritePhyUshort(sc, 0x06, 0x02ae);
+                MP_WritePhyUshort(sc, 0x06, 0x6bee);
+                MP_WritePhyUshort(sc, 0x06, 0xe0ea);
+                MP_WritePhyUshort(sc, 0x06, 0x00ee);
+                MP_WritePhyUshort(sc, 0x06, 0xe0eb);
+                MP_WritePhyUshort(sc, 0x06, 0x00e2);
+                MP_WritePhyUshort(sc, 0x06, 0xe07c);
+                MP_WritePhyUshort(sc, 0x06, 0xe3e0);
+                MP_WritePhyUshort(sc, 0x06, 0x7da5);
+                MP_WritePhyUshort(sc, 0x06, 0x1111);
+                MP_WritePhyUshort(sc, 0x06, 0x15d2);
+                MP_WritePhyUshort(sc, 0x06, 0x60d6);
+                MP_WritePhyUshort(sc, 0x06, 0x6666);
+                MP_WritePhyUshort(sc, 0x06, 0x0207);
+                MP_WritePhyUshort(sc, 0x06, 0xf9d2);
+                MP_WritePhyUshort(sc, 0x06, 0xa0d6);
+                MP_WritePhyUshort(sc, 0x06, 0xaaaa);
+                MP_WritePhyUshort(sc, 0x06, 0x0207);
+                MP_WritePhyUshort(sc, 0x06, 0xf902);
+                MP_WritePhyUshort(sc, 0x06, 0x825c);
+                MP_WritePhyUshort(sc, 0x06, 0xae44);
+                MP_WritePhyUshort(sc, 0x06, 0xa566);
+                MP_WritePhyUshort(sc, 0x06, 0x6602);
+                MP_WritePhyUshort(sc, 0x06, 0xae38);
+                MP_WritePhyUshort(sc, 0x06, 0xa5aa);
+                MP_WritePhyUshort(sc, 0x06, 0xaa02);
+                MP_WritePhyUshort(sc, 0x06, 0xae32);
+                MP_WritePhyUshort(sc, 0x06, 0xeee0);
+                MP_WritePhyUshort(sc, 0x06, 0xea04);
+                MP_WritePhyUshort(sc, 0x06, 0xeee0);
+                MP_WritePhyUshort(sc, 0x06, 0xeb06);
+                MP_WritePhyUshort(sc, 0x06, 0xe2e0);
+                MP_WritePhyUshort(sc, 0x06, 0x7ce3);
+                MP_WritePhyUshort(sc, 0x06, 0xe07d);
+                MP_WritePhyUshort(sc, 0x06, 0xe0e0);
+                MP_WritePhyUshort(sc, 0x06, 0x38e1);
+                MP_WritePhyUshort(sc, 0x06, 0xe039);
+                MP_WritePhyUshort(sc, 0x06, 0xad2e);
+                MP_WritePhyUshort(sc, 0x06, 0x21ad);
+                MP_WritePhyUshort(sc, 0x06, 0x3f13);
+                MP_WritePhyUshort(sc, 0x06, 0xe0e4);
+                MP_WritePhyUshort(sc, 0x06, 0x14e1);
+                MP_WritePhyUshort(sc, 0x06, 0xe415);
+                MP_WritePhyUshort(sc, 0x06, 0x6880);
+                MP_WritePhyUshort(sc, 0x06, 0xe4e4);
+                MP_WritePhyUshort(sc, 0x06, 0x14e5);
+                MP_WritePhyUshort(sc, 0x06, 0xe415);
+                MP_WritePhyUshort(sc, 0x06, 0x0282);
+                MP_WritePhyUshort(sc, 0x06, 0x5cae);
+                MP_WritePhyUshort(sc, 0x06, 0x0bac);
+                MP_WritePhyUshort(sc, 0x06, 0x3e02);
+                MP_WritePhyUshort(sc, 0x06, 0xae06);
+                MP_WritePhyUshort(sc, 0x06, 0x0282);
+                MP_WritePhyUshort(sc, 0x06, 0x8602);
+                MP_WritePhyUshort(sc, 0x06, 0x82b0);
+                MP_WritePhyUshort(sc, 0x06, 0xfefd);
+                MP_WritePhyUshort(sc, 0x06, 0xfc04);
+                MP_WritePhyUshort(sc, 0x06, 0xf8e1);
+                MP_WritePhyUshort(sc, 0x06, 0x8b2e);
+                MP_WritePhyUshort(sc, 0x06, 0xe08b);
+                MP_WritePhyUshort(sc, 0x06, 0x81ad);
+                MP_WritePhyUshort(sc, 0x06, 0x2605);
+                MP_WritePhyUshort(sc, 0x06, 0x0221);
+                MP_WritePhyUshort(sc, 0x06, 0xf3f7);
+                MP_WritePhyUshort(sc, 0x06, 0x28e0);
+                MP_WritePhyUshort(sc, 0x06, 0x8b81);
+                MP_WritePhyUshort(sc, 0x06, 0xad21);
+                MP_WritePhyUshort(sc, 0x06, 0x0502);
+                MP_WritePhyUshort(sc, 0x06, 0x22f8);
+                MP_WritePhyUshort(sc, 0x06, 0xf729);
+                MP_WritePhyUshort(sc, 0x06, 0xe08b);
+                MP_WritePhyUshort(sc, 0x06, 0x87ad);
+                MP_WritePhyUshort(sc, 0x06, 0x2405);
+                MP_WritePhyUshort(sc, 0x06, 0x0282);
+                MP_WritePhyUshort(sc, 0x06, 0xebf7);
+                MP_WritePhyUshort(sc, 0x06, 0x2ae5);
+                MP_WritePhyUshort(sc, 0x06, 0x8b2e);
+                MP_WritePhyUshort(sc, 0x06, 0xfc04);
+                MP_WritePhyUshort(sc, 0x06, 0xf8e0);
+                MP_WritePhyUshort(sc, 0x06, 0x8b81);
+                MP_WritePhyUshort(sc, 0x06, 0xad26);
+                MP_WritePhyUshort(sc, 0x06, 0x0302);
+                MP_WritePhyUshort(sc, 0x06, 0x2134);
+                MP_WritePhyUshort(sc, 0x06, 0xe08b);
+                MP_WritePhyUshort(sc, 0x06, 0x81ad);
+                MP_WritePhyUshort(sc, 0x06, 0x2109);
+                MP_WritePhyUshort(sc, 0x06, 0xe08b);
+                MP_WritePhyUshort(sc, 0x06, 0x2eac);
+                MP_WritePhyUshort(sc, 0x06, 0x2003);
+                MP_WritePhyUshort(sc, 0x06, 0x0283);
+                MP_WritePhyUshort(sc, 0x06, 0x52e0);
+                MP_WritePhyUshort(sc, 0x06, 0x8b87);
+                MP_WritePhyUshort(sc, 0x06, 0xad24);
+                MP_WritePhyUshort(sc, 0x06, 0x09e0);
+                MP_WritePhyUshort(sc, 0x06, 0x8b2e);
+                MP_WritePhyUshort(sc, 0x06, 0xac21);
+                MP_WritePhyUshort(sc, 0x06, 0x0302);
+                MP_WritePhyUshort(sc, 0x06, 0x8337);
+                MP_WritePhyUshort(sc, 0x06, 0xfc04);
+                MP_WritePhyUshort(sc, 0x06, 0xf8e1);
+                MP_WritePhyUshort(sc, 0x06, 0x8b2e);
+                MP_WritePhyUshort(sc, 0x06, 0xe08b);
+                MP_WritePhyUshort(sc, 0x06, 0x81ad);
+                MP_WritePhyUshort(sc, 0x06, 0x2608);
+                MP_WritePhyUshort(sc, 0x06, 0xe085);
+                MP_WritePhyUshort(sc, 0x06, 0xd2ad);
+                MP_WritePhyUshort(sc, 0x06, 0x2502);
+                MP_WritePhyUshort(sc, 0x06, 0xf628);
+                MP_WritePhyUshort(sc, 0x06, 0xe08b);
+                MP_WritePhyUshort(sc, 0x06, 0x81ad);
+                MP_WritePhyUshort(sc, 0x06, 0x210a);
+                MP_WritePhyUshort(sc, 0x06, 0xe086);
+                MP_WritePhyUshort(sc, 0x06, 0x0af6);
+                MP_WritePhyUshort(sc, 0x06, 0x27a0);
+                MP_WritePhyUshort(sc, 0x06, 0x0502);
+                MP_WritePhyUshort(sc, 0x06, 0xf629);
+                MP_WritePhyUshort(sc, 0x06, 0xe08b);
+                MP_WritePhyUshort(sc, 0x06, 0x87ad);
+                MP_WritePhyUshort(sc, 0x06, 0x2408);
+                MP_WritePhyUshort(sc, 0x06, 0xe08a);
+                MP_WritePhyUshort(sc, 0x06, 0xedad);
+                MP_WritePhyUshort(sc, 0x06, 0x2002);
+                MP_WritePhyUshort(sc, 0x06, 0xf62a);
+                MP_WritePhyUshort(sc, 0x06, 0xe58b);
+                MP_WritePhyUshort(sc, 0x06, 0x2ea1);
+                MP_WritePhyUshort(sc, 0x06, 0x0003);
+                MP_WritePhyUshort(sc, 0x06, 0x0221);
+                MP_WritePhyUshort(sc, 0x06, 0x11fc);
+                MP_WritePhyUshort(sc, 0x06, 0x04ee);
+                MP_WritePhyUshort(sc, 0x06, 0x8aed);
+                MP_WritePhyUshort(sc, 0x06, 0x00ee);
+                MP_WritePhyUshort(sc, 0x06, 0x8aec);
+                MP_WritePhyUshort(sc, 0x06, 0x0004);
+                MP_WritePhyUshort(sc, 0x06, 0xf8e0);
+                MP_WritePhyUshort(sc, 0x06, 0x8b87);
+                MP_WritePhyUshort(sc, 0x06, 0xad24);
+                MP_WritePhyUshort(sc, 0x06, 0x3ae0);
+                MP_WritePhyUshort(sc, 0x06, 0xe0ea);
+                MP_WritePhyUshort(sc, 0x06, 0xe1e0);
+                MP_WritePhyUshort(sc, 0x06, 0xeb58);
+                MP_WritePhyUshort(sc, 0x06, 0xf8d1);
+                MP_WritePhyUshort(sc, 0x06, 0x01e4);
+                MP_WritePhyUshort(sc, 0x06, 0xe0ea);
+                MP_WritePhyUshort(sc, 0x06, 0xe5e0);
+                MP_WritePhyUshort(sc, 0x06, 0xebe0);
+                MP_WritePhyUshort(sc, 0x06, 0xe07c);
+                MP_WritePhyUshort(sc, 0x06, 0xe1e0);
+                MP_WritePhyUshort(sc, 0x06, 0x7d5c);
+                MP_WritePhyUshort(sc, 0x06, 0x00ff);
+                MP_WritePhyUshort(sc, 0x06, 0x3c00);
+                MP_WritePhyUshort(sc, 0x06, 0x1eab);
+                MP_WritePhyUshort(sc, 0x06, 0x1ce0);
+                MP_WritePhyUshort(sc, 0x06, 0xe04c);
+                MP_WritePhyUshort(sc, 0x06, 0xe1e0);
+                MP_WritePhyUshort(sc, 0x06, 0x4d58);
+                MP_WritePhyUshort(sc, 0x06, 0xc1e4);
+                MP_WritePhyUshort(sc, 0x06, 0xe04c);
+                MP_WritePhyUshort(sc, 0x06, 0xe5e0);
+                MP_WritePhyUshort(sc, 0x06, 0x4de0);
+                MP_WritePhyUshort(sc, 0x06, 0xe0ee);
+                MP_WritePhyUshort(sc, 0x06, 0xe1e0);
+                MP_WritePhyUshort(sc, 0x06, 0xef69);
+                MP_WritePhyUshort(sc, 0x06, 0x3ce4);
+                MP_WritePhyUshort(sc, 0x06, 0xe0ee);
+                MP_WritePhyUshort(sc, 0x06, 0xe5e0);
+                MP_WritePhyUshort(sc, 0x06, 0xeffc);
+                MP_WritePhyUshort(sc, 0x06, 0x04f8);
+                MP_WritePhyUshort(sc, 0x06, 0xe08b);
+                MP_WritePhyUshort(sc, 0x06, 0x87ad);
+                MP_WritePhyUshort(sc, 0x06, 0x2412);
+                MP_WritePhyUshort(sc, 0x06, 0xe0e0);
+                MP_WritePhyUshort(sc, 0x06, 0xeee1);
+                MP_WritePhyUshort(sc, 0x06, 0xe0ef);
+                MP_WritePhyUshort(sc, 0x06, 0x59c3);
+                MP_WritePhyUshort(sc, 0x06, 0xe4e0);
+                MP_WritePhyUshort(sc, 0x06, 0xeee5);
+                MP_WritePhyUshort(sc, 0x06, 0xe0ef);
+                MP_WritePhyUshort(sc, 0x06, 0xee8a);
+                MP_WritePhyUshort(sc, 0x06, 0xed01);
+                MP_WritePhyUshort(sc, 0x06, 0xfc04);
+                MP_WritePhyUshort(sc, 0x06, 0xf8e0);
+                MP_WritePhyUshort(sc, 0x06, 0x8b81);
+                MP_WritePhyUshort(sc, 0x06, 0xac25);
+                MP_WritePhyUshort(sc, 0x06, 0x0502);
+                MP_WritePhyUshort(sc, 0x06, 0x8363);
+                MP_WritePhyUshort(sc, 0x06, 0xae03);
+                MP_WritePhyUshort(sc, 0x06, 0x0225);
+                MP_WritePhyUshort(sc, 0x06, 0x16fc);
+                MP_WritePhyUshort(sc, 0x06, 0x04f8);
+                MP_WritePhyUshort(sc, 0x06, 0xf9fa);
+                MP_WritePhyUshort(sc, 0x06, 0xef69);
+                MP_WritePhyUshort(sc, 0x06, 0xfae0);
+                MP_WritePhyUshort(sc, 0x06, 0x860a);
+                MP_WritePhyUshort(sc, 0x06, 0xa000);
+                MP_WritePhyUshort(sc, 0x06, 0x19e0);
+                MP_WritePhyUshort(sc, 0x06, 0x860b);
+                MP_WritePhyUshort(sc, 0x06, 0xe18b);
+                MP_WritePhyUshort(sc, 0x06, 0x331b);
+                MP_WritePhyUshort(sc, 0x06, 0x109e);
+                MP_WritePhyUshort(sc, 0x06, 0x04aa);
+                MP_WritePhyUshort(sc, 0x06, 0x02ae);
+                MP_WritePhyUshort(sc, 0x06, 0x06ee);
+                MP_WritePhyUshort(sc, 0x06, 0x860a);
+                MP_WritePhyUshort(sc, 0x06, 0x01ae);
+                MP_WritePhyUshort(sc, 0x06, 0xe602);
+                MP_WritePhyUshort(sc, 0x06, 0x241e);
+                MP_WritePhyUshort(sc, 0x06, 0xae14);
+                MP_WritePhyUshort(sc, 0x06, 0xa001);
+                MP_WritePhyUshort(sc, 0x06, 0x1402);
+                MP_WritePhyUshort(sc, 0x06, 0x2426);
+                MP_WritePhyUshort(sc, 0x06, 0xbf26);
+                MP_WritePhyUshort(sc, 0x06, 0x6d02);
+                MP_WritePhyUshort(sc, 0x06, 0x2eb0);
+                MP_WritePhyUshort(sc, 0x06, 0xee86);
+                MP_WritePhyUshort(sc, 0x06, 0x0b00);
+                MP_WritePhyUshort(sc, 0x06, 0xee86);
+                MP_WritePhyUshort(sc, 0x06, 0x0a02);
+                MP_WritePhyUshort(sc, 0x06, 0xaf84);
+                MP_WritePhyUshort(sc, 0x06, 0x3ca0);
+                MP_WritePhyUshort(sc, 0x06, 0x0252);
+                MP_WritePhyUshort(sc, 0x06, 0xee86);
+                MP_WritePhyUshort(sc, 0x06, 0x0400);
+                MP_WritePhyUshort(sc, 0x06, 0xee86);
+                MP_WritePhyUshort(sc, 0x06, 0x0500);
+                MP_WritePhyUshort(sc, 0x06, 0xe086);
+                MP_WritePhyUshort(sc, 0x06, 0x0be1);
+                MP_WritePhyUshort(sc, 0x06, 0x8b32);
+                MP_WritePhyUshort(sc, 0x06, 0x1b10);
+                MP_WritePhyUshort(sc, 0x06, 0x9e04);
+                MP_WritePhyUshort(sc, 0x06, 0xaa02);
+                MP_WritePhyUshort(sc, 0x06, 0xaecb);
+                MP_WritePhyUshort(sc, 0x06, 0xee86);
+                MP_WritePhyUshort(sc, 0x06, 0x0b00);
+                MP_WritePhyUshort(sc, 0x06, 0x0224);
+                MP_WritePhyUshort(sc, 0x06, 0x3ae2);
+                MP_WritePhyUshort(sc, 0x06, 0x8604);
+                MP_WritePhyUshort(sc, 0x06, 0xe386);
+                MP_WritePhyUshort(sc, 0x06, 0x05ef);
+                MP_WritePhyUshort(sc, 0x06, 0x65e2);
+                MP_WritePhyUshort(sc, 0x06, 0x8606);
+                MP_WritePhyUshort(sc, 0x06, 0xe386);
+                MP_WritePhyUshort(sc, 0x06, 0x071b);
+                MP_WritePhyUshort(sc, 0x06, 0x56aa);
+                MP_WritePhyUshort(sc, 0x06, 0x0eef);
+                MP_WritePhyUshort(sc, 0x06, 0x56e6);
+                MP_WritePhyUshort(sc, 0x06, 0x8606);
+                MP_WritePhyUshort(sc, 0x06, 0xe786);
+                MP_WritePhyUshort(sc, 0x06, 0x07e2);
+                MP_WritePhyUshort(sc, 0x06, 0x8609);
+                MP_WritePhyUshort(sc, 0x06, 0xe686);
+                MP_WritePhyUshort(sc, 0x06, 0x08e0);
+                MP_WritePhyUshort(sc, 0x06, 0x8609);
+                MP_WritePhyUshort(sc, 0x06, 0xa000);
+                MP_WritePhyUshort(sc, 0x06, 0x07ee);
+                MP_WritePhyUshort(sc, 0x06, 0x860a);
+                MP_WritePhyUshort(sc, 0x06, 0x03af);
+                MP_WritePhyUshort(sc, 0x06, 0x8369);
+                MP_WritePhyUshort(sc, 0x06, 0x0224);
+                MP_WritePhyUshort(sc, 0x06, 0x8e02);
+                MP_WritePhyUshort(sc, 0x06, 0x2426);
+                MP_WritePhyUshort(sc, 0x06, 0xae48);
+                MP_WritePhyUshort(sc, 0x06, 0xa003);
+                MP_WritePhyUshort(sc, 0x06, 0x21e0);
+                MP_WritePhyUshort(sc, 0x06, 0x8608);
+                MP_WritePhyUshort(sc, 0x06, 0xe186);
+                MP_WritePhyUshort(sc, 0x06, 0x091b);
+                MP_WritePhyUshort(sc, 0x06, 0x019e);
+                MP_WritePhyUshort(sc, 0x06, 0x0caa);
+                MP_WritePhyUshort(sc, 0x06, 0x0502);
+                MP_WritePhyUshort(sc, 0x06, 0x249d);
+                MP_WritePhyUshort(sc, 0x06, 0xaee7);
+                MP_WritePhyUshort(sc, 0x06, 0x0224);
+                MP_WritePhyUshort(sc, 0x06, 0x8eae);
+                MP_WritePhyUshort(sc, 0x06, 0xe2ee);
+                MP_WritePhyUshort(sc, 0x06, 0x860a);
+                MP_WritePhyUshort(sc, 0x06, 0x04ee);
+                MP_WritePhyUshort(sc, 0x06, 0x860b);
+                MP_WritePhyUshort(sc, 0x06, 0x00af);
+                MP_WritePhyUshort(sc, 0x06, 0x8369);
+                MP_WritePhyUshort(sc, 0x06, 0xa004);
+                MP_WritePhyUshort(sc, 0x06, 0x15e0);
+                MP_WritePhyUshort(sc, 0x06, 0x860b);
+                MP_WritePhyUshort(sc, 0x06, 0xe18b);
+                MP_WritePhyUshort(sc, 0x06, 0x341b);
+                MP_WritePhyUshort(sc, 0x06, 0x109e);
+                MP_WritePhyUshort(sc, 0x06, 0x05aa);
+                MP_WritePhyUshort(sc, 0x06, 0x03af);
+                MP_WritePhyUshort(sc, 0x06, 0x8383);
+                MP_WritePhyUshort(sc, 0x06, 0xee86);
+                MP_WritePhyUshort(sc, 0x06, 0x0a05);
+                MP_WritePhyUshort(sc, 0x06, 0xae0c);
+                MP_WritePhyUshort(sc, 0x06, 0xa005);
+                MP_WritePhyUshort(sc, 0x06, 0x02ae);
+                MP_WritePhyUshort(sc, 0x06, 0x0702);
+                MP_WritePhyUshort(sc, 0x06, 0x2309);
+                MP_WritePhyUshort(sc, 0x06, 0xee86);
+                MP_WritePhyUshort(sc, 0x06, 0x0a00);
+                MP_WritePhyUshort(sc, 0x06, 0xfeef);
+                MP_WritePhyUshort(sc, 0x06, 0x96fe);
+                MP_WritePhyUshort(sc, 0x06, 0xfdfc);
+                MP_WritePhyUshort(sc, 0x06, 0x04f8);
+                MP_WritePhyUshort(sc, 0x06, 0xf9fa);
+                MP_WritePhyUshort(sc, 0x06, 0xef69);
+                MP_WritePhyUshort(sc, 0x06, 0xfbe0);
+                MP_WritePhyUshort(sc, 0x06, 0x8b85);
+                MP_WritePhyUshort(sc, 0x06, 0xad25);
+                MP_WritePhyUshort(sc, 0x06, 0x22e0);
+                MP_WritePhyUshort(sc, 0x06, 0xe022);
+                MP_WritePhyUshort(sc, 0x06, 0xe1e0);
+                MP_WritePhyUshort(sc, 0x06, 0x23e2);
+                MP_WritePhyUshort(sc, 0x06, 0xe036);
+                MP_WritePhyUshort(sc, 0x06, 0xe3e0);
+                MP_WritePhyUshort(sc, 0x06, 0x375a);
+                MP_WritePhyUshort(sc, 0x06, 0xc40d);
+                MP_WritePhyUshort(sc, 0x06, 0x0158);
+                MP_WritePhyUshort(sc, 0x06, 0x021e);
+                MP_WritePhyUshort(sc, 0x06, 0x20e3);
+                MP_WritePhyUshort(sc, 0x06, 0x8ae7);
+                MP_WritePhyUshort(sc, 0x06, 0xac31);
+                MP_WritePhyUshort(sc, 0x06, 0x60ac);
+                MP_WritePhyUshort(sc, 0x06, 0x3a08);
+                MP_WritePhyUshort(sc, 0x06, 0xac3e);
+                MP_WritePhyUshort(sc, 0x06, 0x26ae);
+                MP_WritePhyUshort(sc, 0x06, 0x67af);
+                MP_WritePhyUshort(sc, 0x06, 0x84db);
+                MP_WritePhyUshort(sc, 0x06, 0xad37);
+                MP_WritePhyUshort(sc, 0x06, 0x61e0);
+                MP_WritePhyUshort(sc, 0x06, 0x8ae8);
+                MP_WritePhyUshort(sc, 0x06, 0x10e4);
+                MP_WritePhyUshort(sc, 0x06, 0x8ae8);
+                MP_WritePhyUshort(sc, 0x06, 0xe18a);
+                MP_WritePhyUshort(sc, 0x06, 0xe91b);
+                MP_WritePhyUshort(sc, 0x06, 0x109e);
+                MP_WritePhyUshort(sc, 0x06, 0x02ae);
+                MP_WritePhyUshort(sc, 0x06, 0x51d1);
+                MP_WritePhyUshort(sc, 0x06, 0x00bf);
+                MP_WritePhyUshort(sc, 0x06, 0x863b);
+                MP_WritePhyUshort(sc, 0x06, 0x022f);
+                MP_WritePhyUshort(sc, 0x06, 0x50ee);
+                MP_WritePhyUshort(sc, 0x06, 0x8ae8);
+                MP_WritePhyUshort(sc, 0x06, 0x00ae);
+                MP_WritePhyUshort(sc, 0x06, 0x43ad);
+                MP_WritePhyUshort(sc, 0x06, 0x3627);
+                MP_WritePhyUshort(sc, 0x06, 0xe08a);
+                MP_WritePhyUshort(sc, 0x06, 0xeee1);
+                MP_WritePhyUshort(sc, 0x06, 0x8aef);
+                MP_WritePhyUshort(sc, 0x06, 0xef74);
+                MP_WritePhyUshort(sc, 0x06, 0xe08a);
+                MP_WritePhyUshort(sc, 0x06, 0xeae1);
+                MP_WritePhyUshort(sc, 0x06, 0x8aeb);
+                MP_WritePhyUshort(sc, 0x06, 0x1b74);
+                MP_WritePhyUshort(sc, 0x06, 0x9e2e);
+                MP_WritePhyUshort(sc, 0x06, 0x14e4);
+                MP_WritePhyUshort(sc, 0x06, 0x8aea);
+                MP_WritePhyUshort(sc, 0x06, 0xe58a);
+                MP_WritePhyUshort(sc, 0x06, 0xebef);
+                MP_WritePhyUshort(sc, 0x06, 0x74e0);
+                MP_WritePhyUshort(sc, 0x06, 0x8aee);
+                MP_WritePhyUshort(sc, 0x06, 0xe18a);
+                MP_WritePhyUshort(sc, 0x06, 0xef1b);
+                MP_WritePhyUshort(sc, 0x06, 0x479e);
+                MP_WritePhyUshort(sc, 0x06, 0x0fae);
+                MP_WritePhyUshort(sc, 0x06, 0x19ee);
+                MP_WritePhyUshort(sc, 0x06, 0x8aea);
+                MP_WritePhyUshort(sc, 0x06, 0x00ee);
+                MP_WritePhyUshort(sc, 0x06, 0x8aeb);
+                MP_WritePhyUshort(sc, 0x06, 0x00ae);
+                MP_WritePhyUshort(sc, 0x06, 0x0fac);
+                MP_WritePhyUshort(sc, 0x06, 0x390c);
+                MP_WritePhyUshort(sc, 0x06, 0xd101);
+                MP_WritePhyUshort(sc, 0x06, 0xbf86);
+                MP_WritePhyUshort(sc, 0x06, 0x3b02);
+                MP_WritePhyUshort(sc, 0x06, 0x2f50);
+                MP_WritePhyUshort(sc, 0x06, 0xee8a);
+                MP_WritePhyUshort(sc, 0x06, 0xe800);
+                MP_WritePhyUshort(sc, 0x06, 0xe68a);
+                MP_WritePhyUshort(sc, 0x06, 0xe7ff);
+                MP_WritePhyUshort(sc, 0x06, 0xef96);
+                MP_WritePhyUshort(sc, 0x06, 0xfefd);
+                MP_WritePhyUshort(sc, 0x06, 0xfc04);
+                MP_WritePhyUshort(sc, 0x06, 0xf8f9);
+                MP_WritePhyUshort(sc, 0x06, 0xfaef);
+                MP_WritePhyUshort(sc, 0x06, 0x69e0);
+                MP_WritePhyUshort(sc, 0x06, 0xe022);
+                MP_WritePhyUshort(sc, 0x06, 0xe1e0);
+                MP_WritePhyUshort(sc, 0x06, 0x2358);
+                MP_WritePhyUshort(sc, 0x06, 0xc4e1);
+                MP_WritePhyUshort(sc, 0x06, 0x8b6e);
+                MP_WritePhyUshort(sc, 0x06, 0x1f10);
+                MP_WritePhyUshort(sc, 0x06, 0x9e24);
+                MP_WritePhyUshort(sc, 0x06, 0xe48b);
+                MP_WritePhyUshort(sc, 0x06, 0x6ead);
+                MP_WritePhyUshort(sc, 0x06, 0x2218);
+                MP_WritePhyUshort(sc, 0x06, 0xac27);
+                MP_WritePhyUshort(sc, 0x06, 0x0dac);
+                MP_WritePhyUshort(sc, 0x06, 0x2605);
+                MP_WritePhyUshort(sc, 0x06, 0x0203);
+                MP_WritePhyUshort(sc, 0x06, 0x8fae);
+                MP_WritePhyUshort(sc, 0x06, 0x1302);
+                MP_WritePhyUshort(sc, 0x06, 0x03c8);
+                MP_WritePhyUshort(sc, 0x06, 0xae0e);
+                MP_WritePhyUshort(sc, 0x06, 0x0203);
+                MP_WritePhyUshort(sc, 0x06, 0xe102);
+                MP_WritePhyUshort(sc, 0x06, 0x8520);
+                MP_WritePhyUshort(sc, 0x06, 0xae06);
+                MP_WritePhyUshort(sc, 0x06, 0x0203);
+                MP_WritePhyUshort(sc, 0x06, 0x8f02);
+                MP_WritePhyUshort(sc, 0x06, 0x8566);
+                MP_WritePhyUshort(sc, 0x06, 0xef96);
+                MP_WritePhyUshort(sc, 0x06, 0xfefd);
+                MP_WritePhyUshort(sc, 0x06, 0xfc04);
+                MP_WritePhyUshort(sc, 0x06, 0xf8fa);
+                MP_WritePhyUshort(sc, 0x06, 0xef69);
+                MP_WritePhyUshort(sc, 0x06, 0xe08b);
+                MP_WritePhyUshort(sc, 0x06, 0x82ad);
+                MP_WritePhyUshort(sc, 0x06, 0x2737);
+                MP_WritePhyUshort(sc, 0x06, 0xbf86);
+                MP_WritePhyUshort(sc, 0x06, 0x4402);
+                MP_WritePhyUshort(sc, 0x06, 0x2f23);
+                MP_WritePhyUshort(sc, 0x06, 0xac28);
+                MP_WritePhyUshort(sc, 0x06, 0x2ed1);
+                MP_WritePhyUshort(sc, 0x06, 0x01bf);
+                MP_WritePhyUshort(sc, 0x06, 0x8647);
+                MP_WritePhyUshort(sc, 0x06, 0x022f);
+                MP_WritePhyUshort(sc, 0x06, 0x50bf);
+                MP_WritePhyUshort(sc, 0x06, 0x8641);
+                MP_WritePhyUshort(sc, 0x06, 0x022f);
+                MP_WritePhyUshort(sc, 0x06, 0x23e5);
+                MP_WritePhyUshort(sc, 0x06, 0x8af0);
+                MP_WritePhyUshort(sc, 0x06, 0xe0e0);
+                MP_WritePhyUshort(sc, 0x06, 0x22e1);
+                MP_WritePhyUshort(sc, 0x06, 0xe023);
+                MP_WritePhyUshort(sc, 0x06, 0xac2e);
+                MP_WritePhyUshort(sc, 0x06, 0x04d1);
+                MP_WritePhyUshort(sc, 0x06, 0x01ae);
+                MP_WritePhyUshort(sc, 0x06, 0x02d1);
+                MP_WritePhyUshort(sc, 0x06, 0x00bf);
+                MP_WritePhyUshort(sc, 0x06, 0x8641);
+                MP_WritePhyUshort(sc, 0x06, 0x022f);
+                MP_WritePhyUshort(sc, 0x06, 0x50d1);
+                MP_WritePhyUshort(sc, 0x06, 0x01bf);
+                MP_WritePhyUshort(sc, 0x06, 0x8644);
+                MP_WritePhyUshort(sc, 0x06, 0x022f);
+                MP_WritePhyUshort(sc, 0x06, 0x50ef);
+                MP_WritePhyUshort(sc, 0x06, 0x96fe);
+                MP_WritePhyUshort(sc, 0x06, 0xfc04);
+                MP_WritePhyUshort(sc, 0x06, 0xf8fa);
+                MP_WritePhyUshort(sc, 0x06, 0xef69);
+                MP_WritePhyUshort(sc, 0x06, 0xbf86);
+                MP_WritePhyUshort(sc, 0x06, 0x4702);
+                MP_WritePhyUshort(sc, 0x06, 0x2f23);
+                MP_WritePhyUshort(sc, 0x06, 0xad28);
+                MP_WritePhyUshort(sc, 0x06, 0x19d1);
+                MP_WritePhyUshort(sc, 0x06, 0x00bf);
+                MP_WritePhyUshort(sc, 0x06, 0x8644);
+                MP_WritePhyUshort(sc, 0x06, 0x022f);
+                MP_WritePhyUshort(sc, 0x06, 0x50e1);
+                MP_WritePhyUshort(sc, 0x06, 0x8af0);
+                MP_WritePhyUshort(sc, 0x06, 0xbf86);
+                MP_WritePhyUshort(sc, 0x06, 0x4102);
+                MP_WritePhyUshort(sc, 0x06, 0x2f50);
+                MP_WritePhyUshort(sc, 0x06, 0xd100);
+                MP_WritePhyUshort(sc, 0x06, 0xbf86);
+                MP_WritePhyUshort(sc, 0x06, 0x4702);
+                MP_WritePhyUshort(sc, 0x06, 0x2f50);
+                MP_WritePhyUshort(sc, 0x06, 0xef96);
+                MP_WritePhyUshort(sc, 0x06, 0xfefc);
+                MP_WritePhyUshort(sc, 0x06, 0x04f8);
+                MP_WritePhyUshort(sc, 0x06, 0xe0e2);
+                MP_WritePhyUshort(sc, 0x06, 0xfee1);
+                MP_WritePhyUshort(sc, 0x06, 0xe2ff);
+                MP_WritePhyUshort(sc, 0x06, 0xad2e);
+                MP_WritePhyUshort(sc, 0x06, 0x63e0);
+                MP_WritePhyUshort(sc, 0x06, 0xe038);
+                MP_WritePhyUshort(sc, 0x06, 0xe1e0);
+                MP_WritePhyUshort(sc, 0x06, 0x39ad);
+                MP_WritePhyUshort(sc, 0x06, 0x2f10);
+                MP_WritePhyUshort(sc, 0x06, 0xe0e0);
+                MP_WritePhyUshort(sc, 0x06, 0x34e1);
+                MP_WritePhyUshort(sc, 0x06, 0xe035);
+                MP_WritePhyUshort(sc, 0x06, 0xf726);
+                MP_WritePhyUshort(sc, 0x06, 0xe4e0);
+                MP_WritePhyUshort(sc, 0x06, 0x34e5);
+                MP_WritePhyUshort(sc, 0x06, 0xe035);
+                MP_WritePhyUshort(sc, 0x06, 0xae0e);
+                MP_WritePhyUshort(sc, 0x06, 0xe0e2);
+                MP_WritePhyUshort(sc, 0x06, 0xd6e1);
+                MP_WritePhyUshort(sc, 0x06, 0xe2d7);
+                MP_WritePhyUshort(sc, 0x06, 0xf728);
+                MP_WritePhyUshort(sc, 0x06, 0xe4e2);
+                MP_WritePhyUshort(sc, 0x06, 0xd6e5);
+                MP_WritePhyUshort(sc, 0x06, 0xe2d7);
+                MP_WritePhyUshort(sc, 0x06, 0xe0e2);
+                MP_WritePhyUshort(sc, 0x06, 0x34e1);
+                MP_WritePhyUshort(sc, 0x06, 0xe235);
+                MP_WritePhyUshort(sc, 0x06, 0xf72b);
+                MP_WritePhyUshort(sc, 0x06, 0xe4e2);
+                MP_WritePhyUshort(sc, 0x06, 0x34e5);
+                MP_WritePhyUshort(sc, 0x06, 0xe235);
+                MP_WritePhyUshort(sc, 0x06, 0xd07d);
+                MP_WritePhyUshort(sc, 0x06, 0xb0fe);
+                MP_WritePhyUshort(sc, 0x06, 0xe0e2);
+                MP_WritePhyUshort(sc, 0x06, 0x34e1);
+                MP_WritePhyUshort(sc, 0x06, 0xe235);
+                MP_WritePhyUshort(sc, 0x06, 0xf62b);
+                MP_WritePhyUshort(sc, 0x06, 0xe4e2);
+                MP_WritePhyUshort(sc, 0x06, 0x34e5);
+                MP_WritePhyUshort(sc, 0x06, 0xe235);
+                MP_WritePhyUshort(sc, 0x06, 0xe0e0);
+                MP_WritePhyUshort(sc, 0x06, 0x34e1);
+                MP_WritePhyUshort(sc, 0x06, 0xe035);
+                MP_WritePhyUshort(sc, 0x06, 0xf626);
+                MP_WritePhyUshort(sc, 0x06, 0xe4e0);
+                MP_WritePhyUshort(sc, 0x06, 0x34e5);
+                MP_WritePhyUshort(sc, 0x06, 0xe035);
+                MP_WritePhyUshort(sc, 0x06, 0xe0e2);
+                MP_WritePhyUshort(sc, 0x06, 0xd6e1);
+                MP_WritePhyUshort(sc, 0x06, 0xe2d7);
+                MP_WritePhyUshort(sc, 0x06, 0xf628);
+                MP_WritePhyUshort(sc, 0x06, 0xe4e2);
+                MP_WritePhyUshort(sc, 0x06, 0xd6e5);
+                MP_WritePhyUshort(sc, 0x06, 0xe2d7);
+                MP_WritePhyUshort(sc, 0x06, 0xfc04);
+                MP_WritePhyUshort(sc, 0x06, 0xae20);
+                MP_WritePhyUshort(sc, 0x06, 0x0000);
+                MP_WritePhyUshort(sc, 0x06, 0x0000);
+                MP_WritePhyUshort(sc, 0x06, 0x0000);
+                MP_WritePhyUshort(sc, 0x06, 0x0000);
+                MP_WritePhyUshort(sc, 0x06, 0x0000);
+                MP_WritePhyUshort(sc, 0x06, 0x0000);
+                MP_WritePhyUshort(sc, 0x06, 0x0000);
+                MP_WritePhyUshort(sc, 0x06, 0x0000);
+                MP_WritePhyUshort(sc, 0x06, 0x0000);
+                MP_WritePhyUshort(sc, 0x06, 0x0000);
+                MP_WritePhyUshort(sc, 0x06, 0x0000);
+                MP_WritePhyUshort(sc, 0x06, 0x0000);
+                MP_WritePhyUshort(sc, 0x06, 0x0000);
+                MP_WritePhyUshort(sc, 0x06, 0x0000);
+                MP_WritePhyUshort(sc, 0x06, 0x0000);
+                MP_WritePhyUshort(sc, 0x06, 0x0000);
+                MP_WritePhyUshort(sc, 0x06, 0xa725);
+                MP_WritePhyUshort(sc, 0x06, 0xe50a);
+                MP_WritePhyUshort(sc, 0x06, 0x1de5);
+                MP_WritePhyUshort(sc, 0x06, 0x0a2c);
+                MP_WritePhyUshort(sc, 0x06, 0xe50a);
+                MP_WritePhyUshort(sc, 0x06, 0x6de5);
+                MP_WritePhyUshort(sc, 0x06, 0x0a1d);
+                MP_WritePhyUshort(sc, 0x06, 0xe50a);
+                MP_WritePhyUshort(sc, 0x06, 0x1ce5);
+                MP_WritePhyUshort(sc, 0x06, 0x0a2d);
+                MP_WritePhyUshort(sc, 0x06, 0xa755);
+                MP_WritePhyUshort(sc, 0x06, 0x00e2);
+                MP_WritePhyUshort(sc, 0x06, 0x3488);
+                MP_WritePhyUshort(sc, 0x06, 0xe200);
+                MP_WritePhyUshort(sc, 0x06, 0xcce2);
+                MP_WritePhyUshort(sc, 0x06, 0x0055);
+                MP_WritePhyUshort(sc, 0x06, 0xe020);
+                MP_WritePhyUshort(sc, 0x06, 0x55e2);
+                MP_WritePhyUshort(sc, 0x06, 0xd600);
+                MP_WritePhyUshort(sc, 0x06, 0xe24a);
+                PhyRegValue = MP_ReadPhyUshort(sc, 0x01);
+                PhyRegValue |= BIT_0;
+                MP_WritePhyUshort(sc, 0x01, PhyRegValue);
+                PhyRegValue = MP_ReadPhyUshort(sc, 0x00);
+                PhyRegValue |= BIT_0;
+                MP_WritePhyUshort(sc, 0x00, PhyRegValue);
                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
-
-                if (CSR_READ_1(sc, 0xEF)&0x08) {
-                        MP_WritePhyUshort(sc, 0x1F, 0x0005);
-                        MP_WritePhyUshort(sc, 0x1A, 0x0004);
-                        MP_WritePhyUshort(sc, 0x1F, 0x0000);
-                } else {
-                        MP_WritePhyUshort(sc, 0x1F, 0x0005);
-                        MP_WritePhyUshort(sc, 0x1A, 0x0000);
-                        MP_WritePhyUshort(sc, 0x1F, 0x0000);
-                }
-
-                if (CSR_READ_1(sc, 0xEF)&0x10) {
-                        MP_WritePhyUshort(sc, 0x1F, 0x0004);
-                        MP_WritePhyUshort(sc, 0x1C, 0x0000);
-                        MP_WritePhyUshort(sc, 0x1F, 0x0000);
-                } else {
-                        MP_WritePhyUshort(sc, 0x1F, 0x0004);
-                        MP_WritePhyUshort(sc, 0x1C, 0x0200);
-                        MP_WritePhyUshort(sc, 0x1F, 0x0000);
-                }
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0001);
-                MP_WritePhyUshort(sc, 0x15, 0x7701);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-                ClearEthPhyBit(sc, 0x1A, BIT_14);
-
-                if (phy_power_saving == 1) {
-                        MP_WritePhyUshort(sc, 0x1F, 0x0000);
-                        MP_WritePhyUshort(sc, 0x18, 0x8310);
-                        MP_WritePhyUshort(sc, 0x1F, 0x0000);
-                } else {
-                        MP_WritePhyUshort(sc, 0x1F, 0x0000);
-                        MP_WritePhyUshort(sc, 0x18, 0x0310);
-                        MP_WritePhyUshort(sc, 0x1F, 0x0000);
-                        DELAY(20000);
+                MP_WritePhyUshort(sc, 0x1f, 0x0000);
+                MP_WritePhyUshort(sc, 0x17, 0x2179);
+                MP_WritePhyUshort(sc, 0x1f, 0x0001);
+                MP_WritePhyUshort(sc, 0x10, 0xf274);
+                MP_WritePhyUshort(sc, 0x1f, 0x0007);
+                MP_WritePhyUshort(sc, 0x1e, 0x0042);
+                MP_WritePhyUshort(sc, 0x15, 0x0f00);
+                MP_WritePhyUshort(sc, 0x15, 0x0f00);
+                MP_WritePhyUshort(sc, 0x16, 0x7408);
+                MP_WritePhyUshort(sc, 0x15, 0x0e00);
+                MP_WritePhyUshort(sc, 0x15, 0x0f00);
+                MP_WritePhyUshort(sc, 0x15, 0x0f01);
+                MP_WritePhyUshort(sc, 0x16, 0x4000);
+                MP_WritePhyUshort(sc, 0x15, 0x0e01);
+                MP_WritePhyUshort(sc, 0x15, 0x0f01);
+                MP_WritePhyUshort(sc, 0x15, 0x0f02);
+                MP_WritePhyUshort(sc, 0x16, 0x9400);
+                MP_WritePhyUshort(sc, 0x15, 0x0e02);
+                MP_WritePhyUshort(sc, 0x15, 0x0f02);
+                MP_WritePhyUshort(sc, 0x15, 0x0f03);
+                MP_WritePhyUshort(sc, 0x16, 0x7408);
+                MP_WritePhyUshort(sc, 0x15, 0x0e03);
+                MP_WritePhyUshort(sc, 0x15, 0x0f03);
+                MP_WritePhyUshort(sc, 0x15, 0x0f04);
+                MP_WritePhyUshort(sc, 0x16, 0x4008);
+                MP_WritePhyUshort(sc, 0x15, 0x0e04);
+                MP_WritePhyUshort(sc, 0x15, 0x0f04);
+                MP_WritePhyUshort(sc, 0x15, 0x0f05);
+                MP_WritePhyUshort(sc, 0x16, 0x9400);
+                MP_WritePhyUshort(sc, 0x15, 0x0e05);
+                MP_WritePhyUshort(sc, 0x15, 0x0f05);
+                MP_WritePhyUshort(sc, 0x15, 0x0f06);
+                MP_WritePhyUshort(sc, 0x16, 0x0803);
+                MP_WritePhyUshort(sc, 0x15, 0x0e06);
+                MP_WritePhyUshort(sc, 0x15, 0x0f06);
+                MP_WritePhyUshort(sc, 0x15, 0x0d00);
+                MP_WritePhyUshort(sc, 0x15, 0x0100);
+                MP_WritePhyUshort(sc, 0x1f, 0x0001);
+                MP_WritePhyUshort(sc, 0x10, 0xf074);
+                MP_WritePhyUshort(sc, 0x1f, 0x0000);
+                MP_WritePhyUshort(sc, 0x17, 0x2149);
+                MP_WritePhyUshort(sc, 0x1f, 0x0005);
+                for (i=0; i<200; i++) {
+                        DELAY(100);
+                        PhyRegValue = MP_ReadPhyUshort(sc, 0x00);
+                        if (PhyRegValue&0x0080)
+                                break;
                 }
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-                MP_WritePhyUshort(sc, 0x0D, 0x0007);
-                MP_WritePhyUshort(sc, 0x0E, 0x003C);
-                MP_WritePhyUshort(sc, 0x0D, 0x4007);
-                MP_WritePhyUshort(sc, 0x0E, 0x0000);
-                MP_WritePhyUshort(sc, 0x0D, 0x0000);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
-                MP_WritePhyUshort(sc, 0x0D, 0x0003);
-                MP_WritePhyUshort(sc, 0x0E, 0x0015);
-                MP_WritePhyUshort(sc, 0x0D, 0x4003);
-                MP_WritePhyUshort(sc, 0x0E, 0x0000);
-                MP_WritePhyUshort(sc, 0x0D, 0x0000);
-
-        } else if (sc->re_type == MACFG_50) {
-                MP_WritePhyUshort(sc,0x1f, 0x0000);
-                MP_WritePhyUshort(sc,0x00, 0x1800);
-                Data = MP_ReadPhyUshort(sc, 0x15);
-                Data &= ~(BIT_12);
-                MP_WritePhyUshort(sc,0x15, Data);
-                MP_WritePhyUshort(sc,0x00, 0x4800);
-                MP_WritePhyUshort(sc,0x1f, 0x0007);
-                MP_WritePhyUshort(sc,0x1e, 0x002f);
-                for (i = 0; i < 1000; i++) {
+                MP_WritePhyUshort(sc, 0x1f, 0x0007);
+                MP_WritePhyUshort(sc, 0x1e, 0x0023);
+                PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
+                PhyRegValue &= ~(BIT_0);
+                if (sc->RequiredSecLanDonglePatch)
+                        PhyRegValue &= ~(BIT_2);
+                MP_WritePhyUshort(sc, 0x17, PhyRegValue);
+                MP_WritePhyUshort(sc, 0x1f, 0x0000);
+                MP_WritePhyUshort(sc, 0x1f, 0x0007);
+                MP_WritePhyUshort(sc, 0x1e, 0x0023);
+                PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
+                PhyRegValue |= BIT_14;
+                MP_WritePhyUshort(sc, 0x17, PhyRegValue);
+                MP_WritePhyUshort(sc, 0x1e, 0x0020);
+                PhyRegValue = MP_ReadPhyUshort(sc, 0x1b);
+                PhyRegValue |= BIT_7;
+                MP_WritePhyUshort(sc, 0x1b, PhyRegValue);
+                MP_WritePhyUshort(sc, 0x1e, 0x0041);
+                MP_WritePhyUshort(sc, 0x15, 0x0e02);
+                MP_WritePhyUshort(sc, 0x1e, 0x0028);
+                PhyRegValue = MP_ReadPhyUshort(sc, 0x19);
+                PhyRegValue |= BIT_15;
+                MP_WritePhyUshort(sc, 0x19, PhyRegValue);
+                MP_WritePhyUshort(sc, 0x1f, 0x0000);
+        } else {
+                MP_WritePhyUshort(sc, 0x1f, 0x0000);
+                MP_WritePhyUshort(sc, 0x00, 0x1800);
+                MP_WritePhyUshort(sc, 0x1f, 0x0007);
+                MP_WritePhyUshort(sc, 0x1e, 0x0023);
+                MP_WritePhyUshort(sc, 0x17, 0x0117);
+                MP_WritePhyUshort(sc, 0x1f, 0x0007);
+                MP_WritePhyUshort(sc, 0x1E, 0x002C);
+                MP_WritePhyUshort(sc, 0x1B, 0x5000);
+                MP_WritePhyUshort(sc, 0x1f, 0x0000);
+                MP_WritePhyUshort(sc, 0x16, 0x4104);
+                for (i = 0; i < 200; i++) {
                         DELAY(100);
-                        Data = MP_ReadPhyUshort(sc, 0x1c);
-                        if (Data & BIT_7)
+                        PhyRegValue = MP_ReadPhyUshort(sc, 0x1E);
+                        PhyRegValue &= 0x03FF;
+                        if (PhyRegValue==0x000C)
                                 break;
                 }
-                MP_WritePhyUshort(sc,0x1f, 0x0000);
-                MP_WritePhyUshort(sc,0x00, 0x1800);
-                MP_WritePhyUshort(sc,0x1f, 0x0007);
-                MP_WritePhyUshort(sc,0x1e, 0x0023);
+                MP_WritePhyUshort(sc, 0x1f, 0x0005);
                 for (i = 0; i < 200; i++) {
                         DELAY(100);
-                        Data = MP_ReadPhyUshort(sc, 0x18);
-                        if (!(Data & BIT_0))
+                        PhyRegValue = MP_ReadPhyUshort(sc, 0x07);
+                        if ((PhyRegValue & BIT_5) == 0)
                                 break;
                 }
+                PhyRegValue = MP_ReadPhyUshort(sc, 0x07);
+                if (PhyRegValue & BIT_5) {
+                        MP_WritePhyUshort(sc, 0x1f, 0x0007);
+                        MP_WritePhyUshort(sc, 0x1e, 0x00a1);
+                        MP_WritePhyUshort(sc, 0x17, 0x1000);
+                        MP_WritePhyUshort(sc, 0x17, 0x0000);
+                        MP_WritePhyUshort(sc, 0x17, 0x2000);
+                        MP_WritePhyUshort(sc, 0x1e, 0x002f);
+                        MP_WritePhyUshort(sc, 0x18, 0x9bfb);
+                        MP_WritePhyUshort(sc, 0x1f, 0x0005);
+                        MP_WritePhyUshort(sc, 0x07, 0x0000);
+                        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+                }
                 MP_WritePhyUshort(sc, 0x1f, 0x0005);
                 MP_WritePhyUshort(sc, 0x05, 0xfff6);
                 MP_WritePhyUshort(sc, 0x06, 0x0080);
+                PhyRegValue = MP_ReadPhyUshort(sc, 0x00);
+                PhyRegValue &= ~(BIT_7);
+                MP_WritePhyUshort(sc, 0x00, PhyRegValue);
+                MP_WritePhyUshort(sc, 0x1f, 0x0002);
+                PhyRegValue = MP_ReadPhyUshort(sc, 0x08);
+                PhyRegValue &= ~(BIT_7);
+                MP_WritePhyUshort(sc, 0x08, PhyRegValue);
+                MP_WritePhyUshort(sc, 0x1f, 0x0000);
+
                 MP_WritePhyUshort(sc, 0x1f, 0x0007);
                 MP_WritePhyUshort(sc, 0x1e, 0x0023);
                 MP_WritePhyUshort(sc, 0x16, 0x0306);
                 MP_WritePhyUshort(sc, 0x16, 0x0307);
-                MP_WritePhyUshort(sc, 0x15, 0x0194);
-                MP_WritePhyUshort(sc, 0x19, 0x407D);
-                MP_WritePhyUshort(sc, 0x15, 0x0098);
-                MP_WritePhyUshort(sc, 0x19, 0x7c0b);
-                MP_WritePhyUshort(sc, 0x15, 0x0099);
-                MP_WritePhyUshort(sc, 0x19, 0x6c0b);
-                MP_WritePhyUshort(sc, 0x15, 0x00eb);
+                MP_WritePhyUshort(sc, 0x15, 0x000e);
+                MP_WritePhyUshort(sc, 0x19, 0x000a);
+                MP_WritePhyUshort(sc, 0x15, 0x0010);
+                MP_WritePhyUshort(sc, 0x19, 0x0008);
+                MP_WritePhyUshort(sc, 0x15, 0x0018);
+                MP_WritePhyUshort(sc, 0x19, 0x4801);
+                MP_WritePhyUshort(sc, 0x15, 0x0019);
+                MP_WritePhyUshort(sc, 0x19, 0x6801);
+                MP_WritePhyUshort(sc, 0x15, 0x001a);
+                MP_WritePhyUshort(sc, 0x19, 0x66a1);
+                MP_WritePhyUshort(sc, 0x15, 0x001f);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x0020);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x0021);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x0022);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x0023);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x0024);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x0025);
+                MP_WritePhyUshort(sc, 0x19, 0x64a1);
+                MP_WritePhyUshort(sc, 0x15, 0x0026);
+                MP_WritePhyUshort(sc, 0x19, 0x40ea);
+                MP_WritePhyUshort(sc, 0x15, 0x0027);
+                MP_WritePhyUshort(sc, 0x19, 0x4503);
+                MP_WritePhyUshort(sc, 0x15, 0x0028);
+                MP_WritePhyUshort(sc, 0x19, 0x9f00);
+                MP_WritePhyUshort(sc, 0x15, 0x0029);
+                MP_WritePhyUshort(sc, 0x19, 0xa631);
+                MP_WritePhyUshort(sc, 0x15, 0x002a);
+                MP_WritePhyUshort(sc, 0x19, 0x9717);
+                MP_WritePhyUshort(sc, 0x15, 0x002b);
+                MP_WritePhyUshort(sc, 0x19, 0x302c);
+                MP_WritePhyUshort(sc, 0x15, 0x002c);
+                MP_WritePhyUshort(sc, 0x19, 0x4802);
+                MP_WritePhyUshort(sc, 0x15, 0x002d);
+                MP_WritePhyUshort(sc, 0x19, 0x58da);
+                MP_WritePhyUshort(sc, 0x15, 0x002e);
+                MP_WritePhyUshort(sc, 0x19, 0x400d);
+                MP_WritePhyUshort(sc, 0x15, 0x002f);
+                MP_WritePhyUshort(sc, 0x19, 0x4488);
+                MP_WritePhyUshort(sc, 0x15, 0x0030);
+                MP_WritePhyUshort(sc, 0x19, 0x9e00);
+                MP_WritePhyUshort(sc, 0x15, 0x0031);
+                MP_WritePhyUshort(sc, 0x19, 0x63c8);
+                MP_WritePhyUshort(sc, 0x15, 0x0032);
+                MP_WritePhyUshort(sc, 0x19, 0x6481);
+                MP_WritePhyUshort(sc, 0x15, 0x0033);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x0034);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x0035);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x0036);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x0037);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x0038);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x0039);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x003a);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x003b);
+                MP_WritePhyUshort(sc, 0x19, 0x63e8);
+                MP_WritePhyUshort(sc, 0x15, 0x003c);
+                MP_WritePhyUshort(sc, 0x19, 0x7d00);
+                MP_WritePhyUshort(sc, 0x15, 0x003d);
+                MP_WritePhyUshort(sc, 0x19, 0x59d4);
+                MP_WritePhyUshort(sc, 0x15, 0x003e);
+                MP_WritePhyUshort(sc, 0x19, 0x63f8);
+                MP_WritePhyUshort(sc, 0x15, 0x0040);
+                MP_WritePhyUshort(sc, 0x19, 0x64a1);
+                MP_WritePhyUshort(sc, 0x15, 0x0041);
+                MP_WritePhyUshort(sc, 0x19, 0x30de);
+                MP_WritePhyUshort(sc, 0x15, 0x0044);
+                MP_WritePhyUshort(sc, 0x19, 0x480f);
+                MP_WritePhyUshort(sc, 0x15, 0x0045);
+                MP_WritePhyUshort(sc, 0x19, 0x6800);
+                MP_WritePhyUshort(sc, 0x15, 0x0046);
+                MP_WritePhyUshort(sc, 0x19, 0x6680);
+                MP_WritePhyUshort(sc, 0x15, 0x0047);
+                MP_WritePhyUshort(sc, 0x19, 0x7c10);
+                MP_WritePhyUshort(sc, 0x15, 0x0048);
+                MP_WritePhyUshort(sc, 0x19, 0x63c8);
+                MP_WritePhyUshort(sc, 0x15, 0x0049);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x004a);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x004b);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x004c);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x004d);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x004e);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x004f);
+                MP_WritePhyUshort(sc, 0x19, 0x40ea);
+                MP_WritePhyUshort(sc, 0x15, 0x0050);
+                MP_WritePhyUshort(sc, 0x19, 0x4503);
+                MP_WritePhyUshort(sc, 0x15, 0x0051);
+                MP_WritePhyUshort(sc, 0x19, 0x58ca);
+                MP_WritePhyUshort(sc, 0x15, 0x0052);
+                MP_WritePhyUshort(sc, 0x19, 0x63c8);
+                MP_WritePhyUshort(sc, 0x15, 0x0053);
+                MP_WritePhyUshort(sc, 0x19, 0x63d8);
+                MP_WritePhyUshort(sc, 0x15, 0x0054);
+                MP_WritePhyUshort(sc, 0x19, 0x66a0);
+                MP_WritePhyUshort(sc, 0x15, 0x0055);
+                MP_WritePhyUshort(sc, 0x19, 0x9f00);
+                MP_WritePhyUshort(sc, 0x15, 0x0056);
+                MP_WritePhyUshort(sc, 0x19, 0x3000);
+                MP_WritePhyUshort(sc, 0x15, 0x00a1);
+                MP_WritePhyUshort(sc, 0x19, 0x3044);
+                MP_WritePhyUshort(sc, 0x15, 0x00ab);
+                MP_WritePhyUshort(sc, 0x19, 0x5820);
+                MP_WritePhyUshort(sc, 0x15, 0x00ac);
+                MP_WritePhyUshort(sc, 0x19, 0x5e04);
+                MP_WritePhyUshort(sc, 0x15, 0x00ad);
+                MP_WritePhyUshort(sc, 0x19, 0xb60c);
+                MP_WritePhyUshort(sc, 0x15, 0x00af);
+                MP_WritePhyUshort(sc, 0x19, 0x000a);
+                MP_WritePhyUshort(sc, 0x15, 0x00b2);
+                MP_WritePhyUshort(sc, 0x19, 0x30b9);
+                MP_WritePhyUshort(sc, 0x15, 0x00b9);
+                MP_WritePhyUshort(sc, 0x19, 0x4408);
+                MP_WritePhyUshort(sc, 0x15, 0x00ba);
+                MP_WritePhyUshort(sc, 0x19, 0x480b);
+                MP_WritePhyUshort(sc, 0x15, 0x00bb);
+                MP_WritePhyUshort(sc, 0x19, 0x5e00);
+                MP_WritePhyUshort(sc, 0x15, 0x00bc);
+                MP_WritePhyUshort(sc, 0x19, 0x405f);
+                MP_WritePhyUshort(sc, 0x15, 0x00bd);
+                MP_WritePhyUshort(sc, 0x19, 0x4448);
+                MP_WritePhyUshort(sc, 0x15, 0x00be);
+                MP_WritePhyUshort(sc, 0x19, 0x4020);
+                MP_WritePhyUshort(sc, 0x15, 0x00bf);
+                MP_WritePhyUshort(sc, 0x19, 0x4468);
+                MP_WritePhyUshort(sc, 0x15, 0x00c0);
+                MP_WritePhyUshort(sc, 0x19, 0x9c02);
+                MP_WritePhyUshort(sc, 0x15, 0x00c1);
+                MP_WritePhyUshort(sc, 0x19, 0x58a0);
+                MP_WritePhyUshort(sc, 0x15, 0x00c2);
+                MP_WritePhyUshort(sc, 0x19, 0xb605);
+                MP_WritePhyUshort(sc, 0x15, 0x00c3);
+                MP_WritePhyUshort(sc, 0x19, 0xc0d3);
+                MP_WritePhyUshort(sc, 0x15, 0x00c4);
+                MP_WritePhyUshort(sc, 0x19, 0x00e6);
+                MP_WritePhyUshort(sc, 0x15, 0x00c5);
+                MP_WritePhyUshort(sc, 0x19, 0xdaec);
+                MP_WritePhyUshort(sc, 0x15, 0x00c6);
+                MP_WritePhyUshort(sc, 0x19, 0x00fa);
+                MP_WritePhyUshort(sc, 0x15, 0x00c7);
+                MP_WritePhyUshort(sc, 0x19, 0x9df9);
+                MP_WritePhyUshort(sc, 0x15, 0x0112);
+                MP_WritePhyUshort(sc, 0x19, 0x6421);
+                MP_WritePhyUshort(sc, 0x15, 0x0113);
+                MP_WritePhyUshort(sc, 0x19, 0x7c08);
+                MP_WritePhyUshort(sc, 0x15, 0x0114);
+                MP_WritePhyUshort(sc, 0x19, 0x63f0);
+                MP_WritePhyUshort(sc, 0x15, 0x0115);
+                MP_WritePhyUshort(sc, 0x19, 0x4003);
+                MP_WritePhyUshort(sc, 0x15, 0x0116);
+                MP_WritePhyUshort(sc, 0x19, 0x4418);
+                MP_WritePhyUshort(sc, 0x15, 0x0117);
+                MP_WritePhyUshort(sc, 0x19, 0x9b00);
+                MP_WritePhyUshort(sc, 0x15, 0x0118);
+                MP_WritePhyUshort(sc, 0x19, 0x6461);
+                MP_WritePhyUshort(sc, 0x15, 0x0119);
+                MP_WritePhyUshort(sc, 0x19, 0x64e1);
+                MP_WritePhyUshort(sc, 0x15, 0x011a);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x0150);
+                MP_WritePhyUshort(sc, 0x19, 0x7c80);
+                MP_WritePhyUshort(sc, 0x15, 0x0151);
+                MP_WritePhyUshort(sc, 0x19, 0x6461);
+                MP_WritePhyUshort(sc, 0x15, 0x0152);
+                MP_WritePhyUshort(sc, 0x19, 0x4003);
+                MP_WritePhyUshort(sc, 0x15, 0x0153);
+                MP_WritePhyUshort(sc, 0x19, 0x4540);
+                MP_WritePhyUshort(sc, 0x15, 0x0154);
+                MP_WritePhyUshort(sc, 0x19, 0x9f00);
+                MP_WritePhyUshort(sc, 0x15, 0x0155);
+                MP_WritePhyUshort(sc, 0x19, 0x9d00);
+                MP_WritePhyUshort(sc, 0x15, 0x0156);
+                MP_WritePhyUshort(sc, 0x19, 0x7c40);
+                MP_WritePhyUshort(sc, 0x15, 0x0157);
+                MP_WritePhyUshort(sc, 0x19, 0x6421);
+                MP_WritePhyUshort(sc, 0x15, 0x0158);
+                MP_WritePhyUshort(sc, 0x19, 0x7c80);
+                MP_WritePhyUshort(sc, 0x15, 0x0159);
+                MP_WritePhyUshort(sc, 0x19, 0x64a1);
+                MP_WritePhyUshort(sc, 0x15, 0x015a);
+                MP_WritePhyUshort(sc, 0x19, 0x30fe);
+                MP_WritePhyUshort(sc, 0x15, 0x029c);
+                MP_WritePhyUshort(sc, 0x19, 0x0070);
+                MP_WritePhyUshort(sc, 0x15, 0x02b2);
+                MP_WritePhyUshort(sc, 0x19, 0x005a);
+                MP_WritePhyUshort(sc, 0x15, 0x02bd);
+                MP_WritePhyUshort(sc, 0x19, 0xa522);
+                MP_WritePhyUshort(sc, 0x15, 0x02ce);
+                MP_WritePhyUshort(sc, 0x19, 0xb63e);
+                MP_WritePhyUshort(sc, 0x15, 0x02d9);
+                MP_WritePhyUshort(sc, 0x19, 0x32df);
+                MP_WritePhyUshort(sc, 0x15, 0x02df);
+                MP_WritePhyUshort(sc, 0x19, 0x4500);
+                MP_WritePhyUshort(sc, 0x15, 0x02f4);
+                MP_WritePhyUshort(sc, 0x19, 0xb618);
+                MP_WritePhyUshort(sc, 0x15, 0x02fb);
+                MP_WritePhyUshort(sc, 0x19, 0xb900);
+                MP_WritePhyUshort(sc, 0x15, 0x02fc);
+                MP_WritePhyUshort(sc, 0x19, 0x49b5);
+                MP_WritePhyUshort(sc, 0x15, 0x02fd);
+                MP_WritePhyUshort(sc, 0x19, 0x6812);
+                MP_WritePhyUshort(sc, 0x15, 0x02fe);
+                MP_WritePhyUshort(sc, 0x19, 0x66a0);
+                MP_WritePhyUshort(sc, 0x15, 0x02ff);
+                MP_WritePhyUshort(sc, 0x19, 0x9900);
+                MP_WritePhyUshort(sc, 0x15, 0x0300);
+                MP_WritePhyUshort(sc, 0x19, 0x64a0);
+                MP_WritePhyUshort(sc, 0x15, 0x0301);
+                MP_WritePhyUshort(sc, 0x19, 0x3316);
+                MP_WritePhyUshort(sc, 0x15, 0x0308);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x030c);
+                MP_WritePhyUshort(sc, 0x19, 0x3000);
+                MP_WritePhyUshort(sc, 0x15, 0x0312);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x0313);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x0314);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x0315);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x0316);
+                MP_WritePhyUshort(sc, 0x19, 0x49b5);
+                MP_WritePhyUshort(sc, 0x15, 0x0317);
+                MP_WritePhyUshort(sc, 0x19, 0x7d00);
+                MP_WritePhyUshort(sc, 0x15, 0x0318);
+                MP_WritePhyUshort(sc, 0x19, 0x4d00);
+                MP_WritePhyUshort(sc, 0x15, 0x0319);
+                MP_WritePhyUshort(sc, 0x19, 0x6810);
+                MP_WritePhyUshort(sc, 0x15, 0x031a);
+                MP_WritePhyUshort(sc, 0x19, 0x6c08);
+                MP_WritePhyUshort(sc, 0x15, 0x031b);
+                MP_WritePhyUshort(sc, 0x19, 0x4925);
+                MP_WritePhyUshort(sc, 0x15, 0x031c);
+                MP_WritePhyUshort(sc, 0x19, 0x403b);
+                MP_WritePhyUshort(sc, 0x15, 0x031d);
+                MP_WritePhyUshort(sc, 0x19, 0xa602);
+                MP_WritePhyUshort(sc, 0x15, 0x031e);
+                MP_WritePhyUshort(sc, 0x19, 0x402f);
+                MP_WritePhyUshort(sc, 0x15, 0x031f);
+                MP_WritePhyUshort(sc, 0x19, 0x4484);
+                MP_WritePhyUshort(sc, 0x15, 0x0320);
+                MP_WritePhyUshort(sc, 0x19, 0x40c8);
+                MP_WritePhyUshort(sc, 0x15, 0x0321);
+                MP_WritePhyUshort(sc, 0x19, 0x44c4);
+                MP_WritePhyUshort(sc, 0x15, 0x0322);
+                MP_WritePhyUshort(sc, 0x19, 0x404f);
+                MP_WritePhyUshort(sc, 0x15, 0x0323);
+                MP_WritePhyUshort(sc, 0x19, 0x44c8);
+                MP_WritePhyUshort(sc, 0x15, 0x0324);
+                MP_WritePhyUshort(sc, 0x19, 0xd64f);
+                MP_WritePhyUshort(sc, 0x15, 0x0325);
+                MP_WritePhyUshort(sc, 0x19, 0x00e7);
+                MP_WritePhyUshort(sc, 0x15, 0x0326);
+                MP_WritePhyUshort(sc, 0x19, 0x7c08);
+                MP_WritePhyUshort(sc, 0x15, 0x0327);
+                MP_WritePhyUshort(sc, 0x19, 0x8203);
+                MP_WritePhyUshort(sc, 0x15, 0x0328);
+                MP_WritePhyUshort(sc, 0x19, 0x4d48);
+                MP_WritePhyUshort(sc, 0x15, 0x0329);
+                MP_WritePhyUshort(sc, 0x19, 0x332b);
+                MP_WritePhyUshort(sc, 0x15, 0x032a);
+                MP_WritePhyUshort(sc, 0x19, 0x4d40);
+                MP_WritePhyUshort(sc, 0x15, 0x032c);
+                MP_WritePhyUshort(sc, 0x19, 0x00f8);
+                MP_WritePhyUshort(sc, 0x15, 0x032d);
+                MP_WritePhyUshort(sc, 0x19, 0x82b2);
+                MP_WritePhyUshort(sc, 0x15, 0x032f);
+                MP_WritePhyUshort(sc, 0x19, 0x00b0);
+                MP_WritePhyUshort(sc, 0x15, 0x0332);
+                MP_WritePhyUshort(sc, 0x19, 0x91f2);
+                MP_WritePhyUshort(sc, 0x15, 0x033f);
+                MP_WritePhyUshort(sc, 0x19, 0xb6cd);
+                MP_WritePhyUshort(sc, 0x15, 0x0340);
+                MP_WritePhyUshort(sc, 0x19, 0x9e01);
+                MP_WritePhyUshort(sc, 0x15, 0x0341);
+                MP_WritePhyUshort(sc, 0x19, 0xd11d);
+                MP_WritePhyUshort(sc, 0x15, 0x0342);
+                MP_WritePhyUshort(sc, 0x19, 0x009d);
+                MP_WritePhyUshort(sc, 0x15, 0x0343);
+                MP_WritePhyUshort(sc, 0x19, 0xbb1c);
+                MP_WritePhyUshort(sc, 0x15, 0x0344);
+                MP_WritePhyUshort(sc, 0x19, 0x8102);
+                MP_WritePhyUshort(sc, 0x15, 0x0345);
+                MP_WritePhyUshort(sc, 0x19, 0x3348);
+                MP_WritePhyUshort(sc, 0x15, 0x0346);
+                MP_WritePhyUshort(sc, 0x19, 0xa231);
+                MP_WritePhyUshort(sc, 0x15, 0x0347);
+                MP_WritePhyUshort(sc, 0x19, 0x335b);
+                MP_WritePhyUshort(sc, 0x15, 0x0348);
+                MP_WritePhyUshort(sc, 0x19, 0x91f7);
+                MP_WritePhyUshort(sc, 0x15, 0x0349);
+                MP_WritePhyUshort(sc, 0x19, 0xc218);
+                MP_WritePhyUshort(sc, 0x15, 0x034a);
+                MP_WritePhyUshort(sc, 0x19, 0x00f5);
+                MP_WritePhyUshort(sc, 0x15, 0x034b);
+                MP_WritePhyUshort(sc, 0x19, 0x335b);
+                MP_WritePhyUshort(sc, 0x15, 0x034c);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x034d);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x034e);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x034f);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x0350);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x035b);
+                MP_WritePhyUshort(sc, 0x19, 0xa23c);
+                MP_WritePhyUshort(sc, 0x15, 0x035c);
+                MP_WritePhyUshort(sc, 0x19, 0x7c08);
+                MP_WritePhyUshort(sc, 0x15, 0x035d);
+                MP_WritePhyUshort(sc, 0x19, 0x4c00);
+                MP_WritePhyUshort(sc, 0x15, 0x035e);
+                MP_WritePhyUshort(sc, 0x19, 0x3397);
+                MP_WritePhyUshort(sc, 0x15, 0x0363);
+                MP_WritePhyUshort(sc, 0x19, 0xb6a9);
+                MP_WritePhyUshort(sc, 0x15, 0x0366);
+                MP_WritePhyUshort(sc, 0x19, 0x00f5);
+                MP_WritePhyUshort(sc, 0x15, 0x0382);
+                MP_WritePhyUshort(sc, 0x19, 0x7c40);
+                MP_WritePhyUshort(sc, 0x15, 0x0388);
+                MP_WritePhyUshort(sc, 0x19, 0x0084);
+                MP_WritePhyUshort(sc, 0x15, 0x0389);
+                MP_WritePhyUshort(sc, 0x19, 0xdd17);
+                MP_WritePhyUshort(sc, 0x15, 0x038a);
+                MP_WritePhyUshort(sc, 0x19, 0x000b);
+                MP_WritePhyUshort(sc, 0x15, 0x038b);
+                MP_WritePhyUshort(sc, 0x19, 0xa10a);
+                MP_WritePhyUshort(sc, 0x15, 0x038c);
+                MP_WritePhyUshort(sc, 0x19, 0x337e);
+                MP_WritePhyUshort(sc, 0x15, 0x038d);
                 MP_WritePhyUshort(sc, 0x19, 0x6c0b);
-                MP_WritePhyUshort(sc, 0x15, 0x00f8);
-                MP_WritePhyUshort(sc, 0x19, 0x6f0b);
-                MP_WritePhyUshort(sc, 0x15, 0x00fe);
-                MP_WritePhyUshort(sc, 0x19, 0x6f0f);
-                MP_WritePhyUshort(sc, 0x15, 0x00db);
-                MP_WritePhyUshort(sc, 0x19, 0x6f09);
-                MP_WritePhyUshort(sc, 0x15, 0x00dc);
-                MP_WritePhyUshort(sc, 0x19, 0xaefd);
-                MP_WritePhyUshort(sc, 0x15, 0x00dd);
-                MP_WritePhyUshort(sc, 0x19, 0x6f0b);
-                MP_WritePhyUshort(sc, 0x15, 0x00de);
-                MP_WritePhyUshort(sc, 0x19, 0xc60b);
-                MP_WritePhyUshort(sc, 0x15, 0x00df);
-                MP_WritePhyUshort(sc, 0x19, 0x00fa);
-                MP_WritePhyUshort(sc, 0x15, 0x00e0);
-                MP_WritePhyUshort(sc, 0x19, 0x30e1);
-                MP_WritePhyUshort(sc, 0x15, 0x020c);
-                MP_WritePhyUshort(sc, 0x19, 0x3224);
-                MP_WritePhyUshort(sc, 0x15, 0x020e);
-                MP_WritePhyUshort(sc, 0x19, 0x9813);
-                MP_WritePhyUshort(sc, 0x15, 0x020f);
-                MP_WritePhyUshort(sc, 0x19, 0x7801);
-                MP_WritePhyUshort(sc, 0x15, 0x0210);
-                MP_WritePhyUshort(sc, 0x19, 0x930f);
-                MP_WritePhyUshort(sc, 0x15, 0x0211);
-                MP_WritePhyUshort(sc, 0x19, 0x9206);
-                MP_WritePhyUshort(sc, 0x15, 0x0212);
-                MP_WritePhyUshort(sc, 0x19, 0x4002);
-                MP_WritePhyUshort(sc, 0x15, 0x0213);
-                MP_WritePhyUshort(sc, 0x19, 0x7800);
-                MP_WritePhyUshort(sc, 0x15, 0x0214);
-                MP_WritePhyUshort(sc, 0x19, 0x588f);
-                MP_WritePhyUshort(sc, 0x15, 0x0215);
-                MP_WritePhyUshort(sc, 0x19, 0x5520);
-                MP_WritePhyUshort(sc, 0x15, 0x0216);
-                MP_WritePhyUshort(sc, 0x19, 0x3224);
-                MP_WritePhyUshort(sc, 0x15, 0x0217);
-                MP_WritePhyUshort(sc, 0x19, 0x4002);
-                MP_WritePhyUshort(sc, 0x15, 0x0218);
-                MP_WritePhyUshort(sc, 0x19, 0x7800);
-                MP_WritePhyUshort(sc, 0x15, 0x0219);
-                MP_WritePhyUshort(sc, 0x19, 0x588d);
-                MP_WritePhyUshort(sc, 0x15, 0x021a);
-                MP_WritePhyUshort(sc, 0x19, 0x5540);
-                MP_WritePhyUshort(sc, 0x15, 0x021b);
-                MP_WritePhyUshort(sc, 0x19, 0x9e03);
-                MP_WritePhyUshort(sc, 0x15, 0x021c);
+                MP_WritePhyUshort(sc, 0x15, 0x038e);
+                MP_WritePhyUshort(sc, 0x19, 0xa107);
+                MP_WritePhyUshort(sc, 0x15, 0x038f);
+                MP_WritePhyUshort(sc, 0x19, 0x6c08);
+                MP_WritePhyUshort(sc, 0x15, 0x0390);
+                MP_WritePhyUshort(sc, 0x19, 0xc017);
+                MP_WritePhyUshort(sc, 0x15, 0x0391);
+                MP_WritePhyUshort(sc, 0x19, 0x0004);
+                MP_WritePhyUshort(sc, 0x15, 0x0392);
+                MP_WritePhyUshort(sc, 0x19, 0xd64f);
+                MP_WritePhyUshort(sc, 0x15, 0x0393);
+                MP_WritePhyUshort(sc, 0x19, 0x00f4);
+                MP_WritePhyUshort(sc, 0x15, 0x0397);
+                MP_WritePhyUshort(sc, 0x19, 0x4098);
+                MP_WritePhyUshort(sc, 0x15, 0x0398);
+                MP_WritePhyUshort(sc, 0x19, 0x4408);
+                MP_WritePhyUshort(sc, 0x15, 0x0399);
+                MP_WritePhyUshort(sc, 0x19, 0x55bf);
+                MP_WritePhyUshort(sc, 0x15, 0x039a);
+                MP_WritePhyUshort(sc, 0x19, 0x4bb9);
+                MP_WritePhyUshort(sc, 0x15, 0x039b);
+                MP_WritePhyUshort(sc, 0x19, 0x6810);
+                MP_WritePhyUshort(sc, 0x15, 0x039c);
+                MP_WritePhyUshort(sc, 0x19, 0x4b29);
+                MP_WritePhyUshort(sc, 0x15, 0x039d);
+                MP_WritePhyUshort(sc, 0x19, 0x4041);
+                MP_WritePhyUshort(sc, 0x15, 0x039e);
+                MP_WritePhyUshort(sc, 0x19, 0x442a);
+                MP_WritePhyUshort(sc, 0x15, 0x039f);
+                MP_WritePhyUshort(sc, 0x19, 0x4029);
+                MP_WritePhyUshort(sc, 0x15, 0x03aa);
+                MP_WritePhyUshort(sc, 0x19, 0x33b8);
+                MP_WritePhyUshort(sc, 0x15, 0x03b6);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x03b7);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x03b8);
+                MP_WritePhyUshort(sc, 0x19, 0x543f);
+                MP_WritePhyUshort(sc, 0x15, 0x03b9);
+                MP_WritePhyUshort(sc, 0x19, 0x499a);
+                MP_WritePhyUshort(sc, 0x15, 0x03ba);
                 MP_WritePhyUshort(sc, 0x19, 0x7c40);
-                MP_WritePhyUshort(sc, 0x15, 0x021d);
-                MP_WritePhyUshort(sc, 0x19, 0x6840);
-                MP_WritePhyUshort(sc, 0x15, 0x021e);
-                MP_WritePhyUshort(sc, 0x19, 0x3224);
-                MP_WritePhyUshort(sc, 0x15, 0x021f);
-                MP_WritePhyUshort(sc, 0x19, 0x4002);
-                MP_WritePhyUshort(sc, 0x15, 0x0220);
-                MP_WritePhyUshort(sc, 0x19, 0x3224);
-                MP_WritePhyUshort(sc, 0x15, 0x0221);
+                MP_WritePhyUshort(sc, 0x15, 0x03bb);
+                MP_WritePhyUshort(sc, 0x19, 0x4c40);
+                MP_WritePhyUshort(sc, 0x15, 0x03bc);
+                MP_WritePhyUshort(sc, 0x19, 0x490a);
+                MP_WritePhyUshort(sc, 0x15, 0x03bd);
+                MP_WritePhyUshort(sc, 0x19, 0x405e);
+                MP_WritePhyUshort(sc, 0x15, 0x03c2);
+                MP_WritePhyUshort(sc, 0x19, 0x9a03);
+                MP_WritePhyUshort(sc, 0x15, 0x03c4);
+                MP_WritePhyUshort(sc, 0x19, 0x0015);
+                MP_WritePhyUshort(sc, 0x15, 0x03c5);
                 MP_WritePhyUshort(sc, 0x19, 0x9e03);
-                MP_WritePhyUshort(sc, 0x15, 0x0222);
-                MP_WritePhyUshort(sc, 0x19, 0x7c40);
-                MP_WritePhyUshort(sc, 0x15, 0x0223);
-                MP_WritePhyUshort(sc, 0x19, 0x6840);
-                MP_WritePhyUshort(sc, 0x15, 0x0224);
-                MP_WritePhyUshort(sc, 0x19, 0x7800);
-                MP_WritePhyUshort(sc, 0x15, 0x0225);
-                MP_WritePhyUshort(sc, 0x19, 0x3231);
-                MP_WritePhyUshort(sc, 0x15, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x03c8);
+                MP_WritePhyUshort(sc, 0x19, 0x9cf7);
+                MP_WritePhyUshort(sc, 0x15, 0x03c9);
+                MP_WritePhyUshort(sc, 0x19, 0x7c12);
+                MP_WritePhyUshort(sc, 0x15, 0x03ca);
+                MP_WritePhyUshort(sc, 0x19, 0x4c52);
+                MP_WritePhyUshort(sc, 0x15, 0x03cb);
+                MP_WritePhyUshort(sc, 0x19, 0x4458);
+                MP_WritePhyUshort(sc, 0x15, 0x03cd);
+                MP_WritePhyUshort(sc, 0x19, 0x4c40);
+                MP_WritePhyUshort(sc, 0x15, 0x03ce);
+                MP_WritePhyUshort(sc, 0x19, 0x33bf);
+                MP_WritePhyUshort(sc, 0x15, 0x03cf);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x03d0);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x03d1);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x03d5);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x03d6);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x03d7);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x03d8);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x03d9);
+                MP_WritePhyUshort(sc, 0x19, 0x49bb);
+                MP_WritePhyUshort(sc, 0x15, 0x03da);
+                MP_WritePhyUshort(sc, 0x19, 0x4478);
+                MP_WritePhyUshort(sc, 0x15, 0x03db);
+                MP_WritePhyUshort(sc, 0x19, 0x492b);
+                MP_WritePhyUshort(sc, 0x15, 0x03dc);
+                MP_WritePhyUshort(sc, 0x19, 0x7c01);
+                MP_WritePhyUshort(sc, 0x15, 0x03dd);
+                MP_WritePhyUshort(sc, 0x19, 0x4c00);
+                MP_WritePhyUshort(sc, 0x15, 0x03de);
+                MP_WritePhyUshort(sc, 0x19, 0xbd1a);
+                MP_WritePhyUshort(sc, 0x15, 0x03df);
+                MP_WritePhyUshort(sc, 0x19, 0xc428);
+                MP_WritePhyUshort(sc, 0x15, 0x03e0);
+                MP_WritePhyUshort(sc, 0x19, 0x0008);
+                MP_WritePhyUshort(sc, 0x15, 0x03e1);
+                MP_WritePhyUshort(sc, 0x19, 0x9cfd);
+                MP_WritePhyUshort(sc, 0x15, 0x03e2);
+                MP_WritePhyUshort(sc, 0x19, 0x7c12);
+                MP_WritePhyUshort(sc, 0x15, 0x03e3);
+                MP_WritePhyUshort(sc, 0x19, 0x4c52);
+                MP_WritePhyUshort(sc, 0x15, 0x03e4);
+                MP_WritePhyUshort(sc, 0x19, 0x4458);
+                MP_WritePhyUshort(sc, 0x15, 0x03e5);
+                MP_WritePhyUshort(sc, 0x19, 0x7c12);
+                MP_WritePhyUshort(sc, 0x15, 0x03e6);
+                MP_WritePhyUshort(sc, 0x19, 0x4c40);
+                MP_WritePhyUshort(sc, 0x15, 0x03e7);
+                MP_WritePhyUshort(sc, 0x19, 0x33de);
+                MP_WritePhyUshort(sc, 0x15, 0x03e8);
+                MP_WritePhyUshort(sc, 0x19, 0xc218);
+                MP_WritePhyUshort(sc, 0x15, 0x03e9);
+                MP_WritePhyUshort(sc, 0x19, 0x0002);
+                MP_WritePhyUshort(sc, 0x15, 0x03ea);
+                MP_WritePhyUshort(sc, 0x19, 0x32df);
+                MP_WritePhyUshort(sc, 0x15, 0x03eb);
+                MP_WritePhyUshort(sc, 0x19, 0x3316);
+                MP_WritePhyUshort(sc, 0x15, 0x03ec);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x03ed);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x03ee);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x03ef);
+                MP_WritePhyUshort(sc, 0x19, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x03f7);
+                MP_WritePhyUshort(sc, 0x19, 0x330c);
                 MP_WritePhyUshort(sc, 0x16, 0x0306);
                 MP_WritePhyUshort(sc, 0x16, 0x0300);
-                MP_WritePhyUshort(sc, 0x1f, 0x0000);
+
                 MP_WritePhyUshort(sc, 0x1f, 0x0005);
                 MP_WritePhyUshort(sc, 0x05, 0xfff6);
                 MP_WritePhyUshort(sc, 0x06, 0x0080);
@@ -15666,16 +12346,16 @@ static void re_hw_phy_config(struct re_softc *sc)
                 MP_WritePhyUshort(sc, 0x06, 0xa080);
                 MP_WritePhyUshort(sc, 0x06, 0x02ae);
                 MP_WritePhyUshort(sc, 0x06, 0xf602);
-                MP_WritePhyUshort(sc, 0x06, 0x0118);
-                MP_WritePhyUshort(sc, 0x06, 0x0201);
-                MP_WritePhyUshort(sc, 0x06, 0x2502);
-                MP_WritePhyUshort(sc, 0x06, 0x8090);
-                MP_WritePhyUshort(sc, 0x06, 0x0201);
-                MP_WritePhyUshort(sc, 0x06, 0x4202);
-                MP_WritePhyUshort(sc, 0x06, 0x015c);
+                MP_WritePhyUshort(sc, 0x06, 0x0200);
+                MP_WritePhyUshort(sc, 0x06, 0x0280);
+                MP_WritePhyUshort(sc, 0x06, 0x9002);
+                MP_WritePhyUshort(sc, 0x06, 0x0224);
+                MP_WritePhyUshort(sc, 0x06, 0x0202);
+                MP_WritePhyUshort(sc, 0x06, 0x3402);
+                MP_WritePhyUshort(sc, 0x06, 0x027f);
                 MP_WritePhyUshort(sc, 0x06, 0x0280);
-                MP_WritePhyUshort(sc, 0x06, 0xad02);
-                MP_WritePhyUshort(sc, 0x06, 0x80ca);
+                MP_WritePhyUshort(sc, 0x06, 0xa602);
+                MP_WritePhyUshort(sc, 0x06, 0x80bf);
                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
                 MP_WritePhyUshort(sc, 0x06, 0x88e1);
                 MP_WritePhyUshort(sc, 0x06, 0x8b89);
@@ -15695,25 +12375,25 @@ static void re_hw_phy_config(struct re_softc *sc)
                 MP_WritePhyUshort(sc, 0x06, 0x01a0);
                 MP_WritePhyUshort(sc, 0x06, 0x00c7);
                 MP_WritePhyUshort(sc, 0x06, 0xaebb);
-                MP_WritePhyUshort(sc, 0x06, 0xd484);
-                MP_WritePhyUshort(sc, 0x06, 0x3ce4);
-                MP_WritePhyUshort(sc, 0x06, 0x8b92);
+                MP_WritePhyUshort(sc, 0x06, 0xee8a);
+                MP_WritePhyUshort(sc, 0x06, 0xe600);
+                MP_WritePhyUshort(sc, 0x06, 0xee8a);
+                MP_WritePhyUshort(sc, 0x06, 0xee03);
+                MP_WritePhyUshort(sc, 0x06, 0xee8a);
+                MP_WritePhyUshort(sc, 0x06, 0xefb8);
+                MP_WritePhyUshort(sc, 0x06, 0xee8a);
+                MP_WritePhyUshort(sc, 0x06, 0xe902);
+                MP_WritePhyUshort(sc, 0x06, 0xee8b);
+                MP_WritePhyUshort(sc, 0x06, 0x8285);
+                MP_WritePhyUshort(sc, 0x06, 0xee8b);
+                MP_WritePhyUshort(sc, 0x06, 0x8520);
+                MP_WritePhyUshort(sc, 0x06, 0xee8b);
+                MP_WritePhyUshort(sc, 0x06, 0x8701);
+                MP_WritePhyUshort(sc, 0x06, 0xd481);
+                MP_WritePhyUshort(sc, 0x06, 0x35e4);
+                MP_WritePhyUshort(sc, 0x06, 0x8b94);
                 MP_WritePhyUshort(sc, 0x06, 0xe58b);
-                MP_WritePhyUshort(sc, 0x06, 0x93ee);
-                MP_WritePhyUshort(sc, 0x06, 0x8ac8);
-                MP_WritePhyUshort(sc, 0x06, 0x03ee);
-                MP_WritePhyUshort(sc, 0x06, 0x8aca);
-                MP_WritePhyUshort(sc, 0x06, 0x60ee);
-                MP_WritePhyUshort(sc, 0x06, 0x8ac0);
-                MP_WritePhyUshort(sc, 0x06, 0x00ee);
-                MP_WritePhyUshort(sc, 0x06, 0x8ac1);
-                MP_WritePhyUshort(sc, 0x06, 0x00ee);
-                MP_WritePhyUshort(sc, 0x06, 0x8abe);
-                MP_WritePhyUshort(sc, 0x06, 0x07ee);
-                MP_WritePhyUshort(sc, 0x06, 0x8abf);
-                MP_WritePhyUshort(sc, 0x06, 0x73ee);
-                MP_WritePhyUshort(sc, 0x06, 0x8a95);
-                MP_WritePhyUshort(sc, 0x06, 0x02bf);
+                MP_WritePhyUshort(sc, 0x06, 0x95bf);
                 MP_WritePhyUshort(sc, 0x06, 0x8b88);
                 MP_WritePhyUshort(sc, 0x06, 0xec00);
                 MP_WritePhyUshort(sc, 0x06, 0x19a9);
@@ -15722,133 +12402,219 @@ static void re_hw_phy_config(struct re_softc *sc)
                 MP_WritePhyUshort(sc, 0x06, 0xfff6);
                 MP_WritePhyUshort(sc, 0x06, 0x00ee);
                 MP_WritePhyUshort(sc, 0x06, 0xfff7);
-                MP_WritePhyUshort(sc, 0x06, 0xfed1);
-                MP_WritePhyUshort(sc, 0x06, 0x00bf);
-                MP_WritePhyUshort(sc, 0x06, 0x85a4);
-                MP_WritePhyUshort(sc, 0x06, 0x0238);
-                MP_WritePhyUshort(sc, 0x06, 0x7dd1);
-                MP_WritePhyUshort(sc, 0x06, 0x01bf);
-                MP_WritePhyUshort(sc, 0x06, 0x85a7);
-                MP_WritePhyUshort(sc, 0x06, 0x0238);
-                MP_WritePhyUshort(sc, 0x06, 0x7d04);
+                MP_WritePhyUshort(sc, 0x06, 0xffe0);
+                MP_WritePhyUshort(sc, 0x06, 0xe140);
+                MP_WritePhyUshort(sc, 0x06, 0xe1e1);
+                MP_WritePhyUshort(sc, 0x06, 0x41f7);
+                MP_WritePhyUshort(sc, 0x06, 0x2ff6);
+                MP_WritePhyUshort(sc, 0x06, 0x28e4);
+                MP_WritePhyUshort(sc, 0x06, 0xe140);
+                MP_WritePhyUshort(sc, 0x06, 0xe5e1);
+                MP_WritePhyUshort(sc, 0x06, 0x4104);
                 MP_WritePhyUshort(sc, 0x06, 0xf8e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8a);
+                MP_WritePhyUshort(sc, 0x06, 0x8b89);
                 MP_WritePhyUshort(sc, 0x06, 0xad20);
-                MP_WritePhyUshort(sc, 0x06, 0x14ee);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8a);
+                MP_WritePhyUshort(sc, 0x06, 0x0dee);
+                MP_WritePhyUshort(sc, 0x06, 0x8b89);
                 MP_WritePhyUshort(sc, 0x06, 0x0002);
-                MP_WritePhyUshort(sc, 0x06, 0x204b);
-                MP_WritePhyUshort(sc, 0x06, 0xe0e4);
-                MP_WritePhyUshort(sc, 0x06, 0x26e1);
-                MP_WritePhyUshort(sc, 0x06, 0xe427);
-                MP_WritePhyUshort(sc, 0x06, 0xeee4);
-                MP_WritePhyUshort(sc, 0x06, 0x2623);
-                MP_WritePhyUshort(sc, 0x06, 0xe5e4);
-                MP_WritePhyUshort(sc, 0x06, 0x27fc);
-                MP_WritePhyUshort(sc, 0x06, 0x04f8);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x8dad);
-                MP_WritePhyUshort(sc, 0x06, 0x2014);
-                MP_WritePhyUshort(sc, 0x06, 0xee8b);
-                MP_WritePhyUshort(sc, 0x06, 0x8d00);
-                MP_WritePhyUshort(sc, 0x06, 0xe08a);
-                MP_WritePhyUshort(sc, 0x06, 0x5a78);
-                MP_WritePhyUshort(sc, 0x06, 0x039e);
-                MP_WritePhyUshort(sc, 0x06, 0x0902);
-                MP_WritePhyUshort(sc, 0x06, 0x05e8);
-                MP_WritePhyUshort(sc, 0x06, 0x0281);
-                MP_WritePhyUshort(sc, 0x06, 0x4f02);
-                MP_WritePhyUshort(sc, 0x06, 0x326c);
+                MP_WritePhyUshort(sc, 0x06, 0x82f4);
+                MP_WritePhyUshort(sc, 0x06, 0x021f);
+                MP_WritePhyUshort(sc, 0x06, 0x4102);
+                MP_WritePhyUshort(sc, 0x06, 0x2812);
                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
                 MP_WritePhyUshort(sc, 0x06, 0xf8e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8e);
+                MP_WritePhyUshort(sc, 0x06, 0x8b8d);
                 MP_WritePhyUshort(sc, 0x06, 0xad20);
-                MP_WritePhyUshort(sc, 0x06, 0x1df6);
-                MP_WritePhyUshort(sc, 0x06, 0x20e4);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8e);
-                MP_WritePhyUshort(sc, 0x06, 0x022f);
-                MP_WritePhyUshort(sc, 0x06, 0x0902);
-                MP_WritePhyUshort(sc, 0x06, 0x2ab0);
-                MP_WritePhyUshort(sc, 0x06, 0x0285);
-                MP_WritePhyUshort(sc, 0x06, 0x1602);
-                MP_WritePhyUshort(sc, 0x06, 0x03ba);
-                MP_WritePhyUshort(sc, 0x06, 0x0284);
-                MP_WritePhyUshort(sc, 0x06, 0xe502);
-                MP_WritePhyUshort(sc, 0x06, 0x2df1);
-                MP_WritePhyUshort(sc, 0x06, 0x0283);
-                MP_WritePhyUshort(sc, 0x06, 0x8302);
-                MP_WritePhyUshort(sc, 0x06, 0x0475);
+                MP_WritePhyUshort(sc, 0x06, 0x10ee);
+                MP_WritePhyUshort(sc, 0x06, 0x8b8d);
+                MP_WritePhyUshort(sc, 0x06, 0x0002);
+                MP_WritePhyUshort(sc, 0x06, 0x139d);
+                MP_WritePhyUshort(sc, 0x06, 0x0281);
+                MP_WritePhyUshort(sc, 0x06, 0xd602);
+                MP_WritePhyUshort(sc, 0x06, 0x1f99);
+                MP_WritePhyUshort(sc, 0x06, 0x0227);
+                MP_WritePhyUshort(sc, 0x06, 0xeafc);
+                MP_WritePhyUshort(sc, 0x06, 0x04f8);
                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
                 MP_WritePhyUshort(sc, 0x06, 0x8ead);
-                MP_WritePhyUshort(sc, 0x06, 0x210b);
-                MP_WritePhyUshort(sc, 0x06, 0xf621);
+                MP_WritePhyUshort(sc, 0x06, 0x2014);
+                MP_WritePhyUshort(sc, 0x06, 0xf620);
                 MP_WritePhyUshort(sc, 0x06, 0xe48b);
                 MP_WritePhyUshort(sc, 0x06, 0x8e02);
-                MP_WritePhyUshort(sc, 0x06, 0x83f8);
-                MP_WritePhyUshort(sc, 0x06, 0x021c);
-                MP_WritePhyUshort(sc, 0x06, 0x99e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8e);
+                MP_WritePhyUshort(sc, 0x06, 0x8104);
+                MP_WritePhyUshort(sc, 0x06, 0x021b);
+                MP_WritePhyUshort(sc, 0x06, 0xf402);
+                MP_WritePhyUshort(sc, 0x06, 0x2c9c);
+                MP_WritePhyUshort(sc, 0x06, 0x0281);
+                MP_WritePhyUshort(sc, 0x06, 0x7902);
+                MP_WritePhyUshort(sc, 0x06, 0x8443);
                 MP_WritePhyUshort(sc, 0x06, 0xad22);
-                MP_WritePhyUshort(sc, 0x06, 0x08f6);
+                MP_WritePhyUshort(sc, 0x06, 0x11f6);
                 MP_WritePhyUshort(sc, 0x06, 0x22e4);
                 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
-                MP_WritePhyUshort(sc, 0x06, 0x0235);
-                MP_WritePhyUshort(sc, 0x06, 0x63e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8e);
-                MP_WritePhyUshort(sc, 0x06, 0xad23);
-                MP_WritePhyUshort(sc, 0x06, 0x08f6);
-                MP_WritePhyUshort(sc, 0x06, 0x23e4);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8e);
-                MP_WritePhyUshort(sc, 0x06, 0x0231);
-                MP_WritePhyUshort(sc, 0x06, 0x57e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8e);
-                MP_WritePhyUshort(sc, 0x06, 0xad24);
-                MP_WritePhyUshort(sc, 0x06, 0x05f6);
-                MP_WritePhyUshort(sc, 0x06, 0x24e4);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8e);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x8ead);
-                MP_WritePhyUshort(sc, 0x06, 0x2505);
-                MP_WritePhyUshort(sc, 0x06, 0xf625);
-                MP_WritePhyUshort(sc, 0x06, 0xe48b);
-                MP_WritePhyUshort(sc, 0x06, 0x8ee0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8e);
-                MP_WritePhyUshort(sc, 0x06, 0xad26);
-                MP_WritePhyUshort(sc, 0x06, 0x08f6);
-                MP_WritePhyUshort(sc, 0x06, 0x26e4);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8e);
-                MP_WritePhyUshort(sc, 0x06, 0x022d);
-                MP_WritePhyUshort(sc, 0x06, 0x1ce0);
+                MP_WritePhyUshort(sc, 0x06, 0x022c);
+                MP_WritePhyUshort(sc, 0x06, 0x4602);
+                MP_WritePhyUshort(sc, 0x06, 0x2ac5);
+                MP_WritePhyUshort(sc, 0x06, 0x0229);
+                MP_WritePhyUshort(sc, 0x06, 0x2002);
+                MP_WritePhyUshort(sc, 0x06, 0x2b91);
+                MP_WritePhyUshort(sc, 0x06, 0xad25);
+                MP_WritePhyUshort(sc, 0x06, 0x11f6);
+                MP_WritePhyUshort(sc, 0x06, 0x25e4);
                 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
+                MP_WritePhyUshort(sc, 0x06, 0x0284);
+                MP_WritePhyUshort(sc, 0x06, 0xe202);
+                MP_WritePhyUshort(sc, 0x06, 0x043a);
+                MP_WritePhyUshort(sc, 0x06, 0x021a);
+                MP_WritePhyUshort(sc, 0x06, 0x5902);
+                MP_WritePhyUshort(sc, 0x06, 0x2bfc);
+                MP_WritePhyUshort(sc, 0x06, 0xfc04);
+                MP_WritePhyUshort(sc, 0x06, 0xf8fa);
+                MP_WritePhyUshort(sc, 0x06, 0xef69);
+                MP_WritePhyUshort(sc, 0x06, 0xe0e0);
+                MP_WritePhyUshort(sc, 0x06, 0x00e1);
+                MP_WritePhyUshort(sc, 0x06, 0xe001);
                 MP_WritePhyUshort(sc, 0x06, 0xad27);
-                MP_WritePhyUshort(sc, 0x06, 0x05f6);
-                MP_WritePhyUshort(sc, 0x06, 0x27e4);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8e);
+                MP_WritePhyUshort(sc, 0x06, 0x1fd1);
+                MP_WritePhyUshort(sc, 0x06, 0x01bf);
+                MP_WritePhyUshort(sc, 0x06, 0x8638);
+                MP_WritePhyUshort(sc, 0x06, 0x022f);
+                MP_WritePhyUshort(sc, 0x06, 0x50e0);
+                MP_WritePhyUshort(sc, 0x06, 0xe020);
+                MP_WritePhyUshort(sc, 0x06, 0xe1e0);
+                MP_WritePhyUshort(sc, 0x06, 0x21ad);
+                MP_WritePhyUshort(sc, 0x06, 0x200e);
+                MP_WritePhyUshort(sc, 0x06, 0xd100);
+                MP_WritePhyUshort(sc, 0x06, 0xbf86);
+                MP_WritePhyUshort(sc, 0x06, 0x3802);
+                MP_WritePhyUshort(sc, 0x06, 0x2f50);
+                MP_WritePhyUshort(sc, 0x06, 0xbf3d);
+                MP_WritePhyUshort(sc, 0x06, 0x3902);
+                MP_WritePhyUshort(sc, 0x06, 0x2eb0);
+                MP_WritePhyUshort(sc, 0x06, 0xef96);
+                MP_WritePhyUshort(sc, 0x06, 0xfefc);
+                MP_WritePhyUshort(sc, 0x06, 0x0402);
+                MP_WritePhyUshort(sc, 0x06, 0x8591);
+                MP_WritePhyUshort(sc, 0x06, 0x0281);
+                MP_WritePhyUshort(sc, 0x06, 0x3c05);
+                MP_WritePhyUshort(sc, 0x06, 0xf8fa);
+                MP_WritePhyUshort(sc, 0x06, 0xef69);
+                MP_WritePhyUshort(sc, 0x06, 0xe0e2);
+                MP_WritePhyUshort(sc, 0x06, 0xfee1);
+                MP_WritePhyUshort(sc, 0x06, 0xe2ff);
+                MP_WritePhyUshort(sc, 0x06, 0xad2d);
+                MP_WritePhyUshort(sc, 0x06, 0x1ae0);
+                MP_WritePhyUshort(sc, 0x06, 0xe14e);
+                MP_WritePhyUshort(sc, 0x06, 0xe1e1);
+                MP_WritePhyUshort(sc, 0x06, 0x4fac);
+                MP_WritePhyUshort(sc, 0x06, 0x2d22);
+                MP_WritePhyUshort(sc, 0x06, 0xf603);
                 MP_WritePhyUshort(sc, 0x06, 0x0203);
-                MP_WritePhyUshort(sc, 0x06, 0x80fc);
+                MP_WritePhyUshort(sc, 0x06, 0x36f7);
+                MP_WritePhyUshort(sc, 0x06, 0x03f7);
+                MP_WritePhyUshort(sc, 0x06, 0x06bf);
+                MP_WritePhyUshort(sc, 0x06, 0x8622);
+                MP_WritePhyUshort(sc, 0x06, 0x022e);
+                MP_WritePhyUshort(sc, 0x06, 0xb0ae);
+                MP_WritePhyUshort(sc, 0x06, 0x11e0);
+                MP_WritePhyUshort(sc, 0x06, 0xe14e);
+                MP_WritePhyUshort(sc, 0x06, 0xe1e1);
+                MP_WritePhyUshort(sc, 0x06, 0x4fad);
+                MP_WritePhyUshort(sc, 0x06, 0x2d08);
+                MP_WritePhyUshort(sc, 0x06, 0xbf86);
+                MP_WritePhyUshort(sc, 0x06, 0x2d02);
+                MP_WritePhyUshort(sc, 0x06, 0x2eb0);
+                MP_WritePhyUshort(sc, 0x06, 0xf606);
+                MP_WritePhyUshort(sc, 0x06, 0xef96);
+                MP_WritePhyUshort(sc, 0x06, 0xfefc);
                 MP_WritePhyUshort(sc, 0x06, 0x04f8);
-                MP_WritePhyUshort(sc, 0x06, 0xf9e0);
+                MP_WritePhyUshort(sc, 0x06, 0xf9fa);
+                MP_WritePhyUshort(sc, 0x06, 0xef69);
+                MP_WritePhyUshort(sc, 0x06, 0xe08b);
+                MP_WritePhyUshort(sc, 0x06, 0x87ad);
+                MP_WritePhyUshort(sc, 0x06, 0x204c);
+                MP_WritePhyUshort(sc, 0x06, 0xd200);
+                MP_WritePhyUshort(sc, 0x06, 0xe0e2);
+                MP_WritePhyUshort(sc, 0x06, 0x0058);
+                MP_WritePhyUshort(sc, 0x06, 0x010c);
+                MP_WritePhyUshort(sc, 0x06, 0x021e);
+                MP_WritePhyUshort(sc, 0x06, 0x20e0);
+                MP_WritePhyUshort(sc, 0x06, 0xe000);
+                MP_WritePhyUshort(sc, 0x06, 0x5810);
+                MP_WritePhyUshort(sc, 0x06, 0x1e20);
+                MP_WritePhyUshort(sc, 0x06, 0xe0e0);
+                MP_WritePhyUshort(sc, 0x06, 0x3658);
+                MP_WritePhyUshort(sc, 0x06, 0x031e);
+                MP_WritePhyUshort(sc, 0x06, 0x20e0);
+                MP_WritePhyUshort(sc, 0x06, 0xe022);
+                MP_WritePhyUshort(sc, 0x06, 0xe1e0);
+                MP_WritePhyUshort(sc, 0x06, 0x2358);
+                MP_WritePhyUshort(sc, 0x06, 0xe01e);
+                MP_WritePhyUshort(sc, 0x06, 0x20e0);
+                MP_WritePhyUshort(sc, 0x06, 0x8ae6);
+                MP_WritePhyUshort(sc, 0x06, 0x1f02);
+                MP_WritePhyUshort(sc, 0x06, 0x9e22);
+                MP_WritePhyUshort(sc, 0x06, 0xe68a);
+                MP_WritePhyUshort(sc, 0x06, 0xe6ad);
+                MP_WritePhyUshort(sc, 0x06, 0x3214);
+                MP_WritePhyUshort(sc, 0x06, 0xad34);
+                MP_WritePhyUshort(sc, 0x06, 0x11ef);
+                MP_WritePhyUshort(sc, 0x06, 0x0258);
+                MP_WritePhyUshort(sc, 0x06, 0x039e);
+                MP_WritePhyUshort(sc, 0x06, 0x07ad);
+                MP_WritePhyUshort(sc, 0x06, 0x3508);
+                MP_WritePhyUshort(sc, 0x06, 0x5ac0);
+                MP_WritePhyUshort(sc, 0x06, 0x9f04);
+                MP_WritePhyUshort(sc, 0x06, 0xd101);
+                MP_WritePhyUshort(sc, 0x06, 0xae02);
+                MP_WritePhyUshort(sc, 0x06, 0xd100);
+                MP_WritePhyUshort(sc, 0x06, 0xbf86);
+                MP_WritePhyUshort(sc, 0x06, 0x3e02);
+                MP_WritePhyUshort(sc, 0x06, 0x2f50);
+                MP_WritePhyUshort(sc, 0x06, 0xef96);
+                MP_WritePhyUshort(sc, 0x06, 0xfefd);
+                MP_WritePhyUshort(sc, 0x06, 0xfc04);
+                MP_WritePhyUshort(sc, 0x06, 0xf8f9);
+                MP_WritePhyUshort(sc, 0x06, 0xfae0);
                 MP_WritePhyUshort(sc, 0x06, 0x8b81);
                 MP_WritePhyUshort(sc, 0x06, 0xac26);
-                MP_WritePhyUshort(sc, 0x06, 0x1ae0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b81);
-                MP_WritePhyUshort(sc, 0x06, 0xac21);
-                MP_WritePhyUshort(sc, 0x06, 0x14e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b85);
-                MP_WritePhyUshort(sc, 0x06, 0xac20);
                 MP_WritePhyUshort(sc, 0x06, 0x0ee0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b85);
-                MP_WritePhyUshort(sc, 0x06, 0xac23);
+                MP_WritePhyUshort(sc, 0x06, 0x8b81);
+                MP_WritePhyUshort(sc, 0x06, 0xac21);
                 MP_WritePhyUshort(sc, 0x06, 0x08e0);
                 MP_WritePhyUshort(sc, 0x06, 0x8b87);
                 MP_WritePhyUshort(sc, 0x06, 0xac24);
                 MP_WritePhyUshort(sc, 0x06, 0x02ae);
-                MP_WritePhyUshort(sc, 0x06, 0x3802);
-                MP_WritePhyUshort(sc, 0x06, 0x1ac2);
-                MP_WritePhyUshort(sc, 0x06, 0xeee4);
-                MP_WritePhyUshort(sc, 0x06, 0x1c04);
-                MP_WritePhyUshort(sc, 0x06, 0xeee4);
-                MP_WritePhyUshort(sc, 0x06, 0x1d04);
+                MP_WritePhyUshort(sc, 0x06, 0x6bee);
+                MP_WritePhyUshort(sc, 0x06, 0xe0ea);
+                MP_WritePhyUshort(sc, 0x06, 0x00ee);
+                MP_WritePhyUshort(sc, 0x06, 0xe0eb);
+                MP_WritePhyUshort(sc, 0x06, 0x00e2);
+                MP_WritePhyUshort(sc, 0x06, 0xe07c);
+                MP_WritePhyUshort(sc, 0x06, 0xe3e0);
+                MP_WritePhyUshort(sc, 0x06, 0x7da5);
+                MP_WritePhyUshort(sc, 0x06, 0x1111);
+                MP_WritePhyUshort(sc, 0x06, 0x15d2);
+                MP_WritePhyUshort(sc, 0x06, 0x60d6);
+                MP_WritePhyUshort(sc, 0x06, 0x6666);
+                MP_WritePhyUshort(sc, 0x06, 0x0207);
+                MP_WritePhyUshort(sc, 0x06, 0xf9d2);
+                MP_WritePhyUshort(sc, 0x06, 0xa0d6);
+                MP_WritePhyUshort(sc, 0x06, 0xaaaa);
+                MP_WritePhyUshort(sc, 0x06, 0x0207);
+                MP_WritePhyUshort(sc, 0x06, 0xf902);
+                MP_WritePhyUshort(sc, 0x06, 0x825c);
+                MP_WritePhyUshort(sc, 0x06, 0xae44);
+                MP_WritePhyUshort(sc, 0x06, 0xa566);
+                MP_WritePhyUshort(sc, 0x06, 0x6602);
+                MP_WritePhyUshort(sc, 0x06, 0xae38);
+                MP_WritePhyUshort(sc, 0x06, 0xa5aa);
+                MP_WritePhyUshort(sc, 0x06, 0xaa02);
+                MP_WritePhyUshort(sc, 0x06, 0xae32);
+                MP_WritePhyUshort(sc, 0x06, 0xeee0);
+                MP_WritePhyUshort(sc, 0x06, 0xea04);
+                MP_WritePhyUshort(sc, 0x06, 0xeee0);
+                MP_WritePhyUshort(sc, 0x06, 0xeb06);
                 MP_WritePhyUshort(sc, 0x06, 0xe2e0);
                 MP_WritePhyUshort(sc, 0x06, 0x7ce3);
                 MP_WritePhyUshort(sc, 0x06, 0xe07d);
@@ -15856,299 +12622,490 @@ static void re_hw_phy_config(struct re_softc *sc)
                 MP_WritePhyUshort(sc, 0x06, 0x38e1);
                 MP_WritePhyUshort(sc, 0x06, 0xe039);
                 MP_WritePhyUshort(sc, 0x06, 0xad2e);
-                MP_WritePhyUshort(sc, 0x06, 0x1bad);
-                MP_WritePhyUshort(sc, 0x06, 0x390d);
-                MP_WritePhyUshort(sc, 0x06, 0xd101);
-                MP_WritePhyUshort(sc, 0x06, 0xbf22);
-                MP_WritePhyUshort(sc, 0x06, 0x7a02);
-                MP_WritePhyUshort(sc, 0x06, 0x387d);
-                MP_WritePhyUshort(sc, 0x06, 0x0281);
-                MP_WritePhyUshort(sc, 0x06, 0xacae);
+                MP_WritePhyUshort(sc, 0x06, 0x21ad);
+                MP_WritePhyUshort(sc, 0x06, 0x3f13);
+                MP_WritePhyUshort(sc, 0x06, 0xe0e4);
+                MP_WritePhyUshort(sc, 0x06, 0x14e1);
+                MP_WritePhyUshort(sc, 0x06, 0xe415);
+                MP_WritePhyUshort(sc, 0x06, 0x6880);
+                MP_WritePhyUshort(sc, 0x06, 0xe4e4);
+                MP_WritePhyUshort(sc, 0x06, 0x14e5);
+                MP_WritePhyUshort(sc, 0x06, 0xe415);
+                MP_WritePhyUshort(sc, 0x06, 0x0282);
+                MP_WritePhyUshort(sc, 0x06, 0x5cae);
                 MP_WritePhyUshort(sc, 0x06, 0x0bac);
-                MP_WritePhyUshort(sc, 0x06, 0x3802);
+                MP_WritePhyUshort(sc, 0x06, 0x3e02);
                 MP_WritePhyUshort(sc, 0x06, 0xae06);
-                MP_WritePhyUshort(sc, 0x06, 0x0281);
-                MP_WritePhyUshort(sc, 0x06, 0xe902);
-                MP_WritePhyUshort(sc, 0x06, 0x822e);
-                MP_WritePhyUshort(sc, 0x06, 0x021a);
-                MP_WritePhyUshort(sc, 0x06, 0xd3fd);
+                MP_WritePhyUshort(sc, 0x06, 0x0282);
+                MP_WritePhyUshort(sc, 0x06, 0x8602);
+                MP_WritePhyUshort(sc, 0x06, 0x82b0);
+                MP_WritePhyUshort(sc, 0x06, 0xfefd);
                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
                 MP_WritePhyUshort(sc, 0x06, 0xf8e1);
-                MP_WritePhyUshort(sc, 0x06, 0x8af4);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x81ad);
-                MP_WritePhyUshort(sc, 0x06, 0x2602);
-                MP_WritePhyUshort(sc, 0x06, 0xf728);
+                MP_WritePhyUshort(sc, 0x06, 0x8b2e);
                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
                 MP_WritePhyUshort(sc, 0x06, 0x81ad);
-                MP_WritePhyUshort(sc, 0x06, 0x2105);
-                MP_WritePhyUshort(sc, 0x06, 0x0222);
-                MP_WritePhyUshort(sc, 0x06, 0x8ef7);
-                MP_WritePhyUshort(sc, 0x06, 0x29e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b85);
-                MP_WritePhyUshort(sc, 0x06, 0xad20);
-                MP_WritePhyUshort(sc, 0x06, 0x0502);
-                MP_WritePhyUshort(sc, 0x06, 0x14b8);
-                MP_WritePhyUshort(sc, 0x06, 0xf72a);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x85ad);
-                MP_WritePhyUshort(sc, 0x06, 0x2305);
-                MP_WritePhyUshort(sc, 0x06, 0x0212);
-                MP_WritePhyUshort(sc, 0x06, 0xf4f7);
-                MP_WritePhyUshort(sc, 0x06, 0x2be0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b87);
-                MP_WritePhyUshort(sc, 0x06, 0xad24);
+                MP_WritePhyUshort(sc, 0x06, 0x2605);
+                MP_WritePhyUshort(sc, 0x06, 0x0221);
+                MP_WritePhyUshort(sc, 0x06, 0xf3f7);
+                MP_WritePhyUshort(sc, 0x06, 0x28e0);
+                MP_WritePhyUshort(sc, 0x06, 0x8b81);
+                MP_WritePhyUshort(sc, 0x06, 0xad21);
                 MP_WritePhyUshort(sc, 0x06, 0x0502);
-                MP_WritePhyUshort(sc, 0x06, 0x8284);
-                MP_WritePhyUshort(sc, 0x06, 0xf72c);
-                MP_WritePhyUshort(sc, 0x06, 0xe58a);
-                MP_WritePhyUshort(sc, 0x06, 0xf4fc);
-                MP_WritePhyUshort(sc, 0x06, 0x04f8);
+                MP_WritePhyUshort(sc, 0x06, 0x22f8);
+                MP_WritePhyUshort(sc, 0x06, 0xf729);
                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x81ad);
-                MP_WritePhyUshort(sc, 0x06, 0x2600);
+                MP_WritePhyUshort(sc, 0x06, 0x87ad);
+                MP_WritePhyUshort(sc, 0x06, 0x2405);
+                MP_WritePhyUshort(sc, 0x06, 0x0282);
+                MP_WritePhyUshort(sc, 0x06, 0xebf7);
+                MP_WritePhyUshort(sc, 0x06, 0x2ae5);
+                MP_WritePhyUshort(sc, 0x06, 0x8b2e);
+                MP_WritePhyUshort(sc, 0x06, 0xfc04);
+                MP_WritePhyUshort(sc, 0x06, 0xf8e0);
+                MP_WritePhyUshort(sc, 0x06, 0x8b81);
+                MP_WritePhyUshort(sc, 0x06, 0xad26);
+                MP_WritePhyUshort(sc, 0x06, 0x0302);
+                MP_WritePhyUshort(sc, 0x06, 0x2134);
                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
                 MP_WritePhyUshort(sc, 0x06, 0x81ad);
                 MP_WritePhyUshort(sc, 0x06, 0x2109);
-                MP_WritePhyUshort(sc, 0x06, 0xe08a);
-                MP_WritePhyUshort(sc, 0x06, 0xf4ac);
-                MP_WritePhyUshort(sc, 0x06, 0x2003);
-                MP_WritePhyUshort(sc, 0x06, 0x0222);
-                MP_WritePhyUshort(sc, 0x06, 0x7de0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b85);
-                MP_WritePhyUshort(sc, 0x06, 0xad20);
-                MP_WritePhyUshort(sc, 0x06, 0x09e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8af4);
-                MP_WritePhyUshort(sc, 0x06, 0xac21);
-                MP_WritePhyUshort(sc, 0x06, 0x0302);
-                MP_WritePhyUshort(sc, 0x06, 0x1408);
                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x85ad);
-                MP_WritePhyUshort(sc, 0x06, 0x2309);
-                MP_WritePhyUshort(sc, 0x06, 0xe08a);
-                MP_WritePhyUshort(sc, 0x06, 0xf4ac);
-                MP_WritePhyUshort(sc, 0x06, 0x2203);
-                MP_WritePhyUshort(sc, 0x06, 0x0213);
-                MP_WritePhyUshort(sc, 0x06, 0x07e0);
+                MP_WritePhyUshort(sc, 0x06, 0x2eac);
+                MP_WritePhyUshort(sc, 0x06, 0x2003);
+                MP_WritePhyUshort(sc, 0x06, 0x0283);
+                MP_WritePhyUshort(sc, 0x06, 0x52e0);
                 MP_WritePhyUshort(sc, 0x06, 0x8b87);
                 MP_WritePhyUshort(sc, 0x06, 0xad24);
                 MP_WritePhyUshort(sc, 0x06, 0x09e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8af4);
-                MP_WritePhyUshort(sc, 0x06, 0xac23);
+                MP_WritePhyUshort(sc, 0x06, 0x8b2e);
+                MP_WritePhyUshort(sc, 0x06, 0xac21);
                 MP_WritePhyUshort(sc, 0x06, 0x0302);
-                MP_WritePhyUshort(sc, 0x06, 0x8289);
+                MP_WritePhyUshort(sc, 0x06, 0x8337);
                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
                 MP_WritePhyUshort(sc, 0x06, 0xf8e1);
-                MP_WritePhyUshort(sc, 0x06, 0x8af4);
+                MP_WritePhyUshort(sc, 0x06, 0x8b2e);
                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
                 MP_WritePhyUshort(sc, 0x06, 0x81ad);
-                MP_WritePhyUshort(sc, 0x06, 0x2602);
+                MP_WritePhyUshort(sc, 0x06, 0x2608);
+                MP_WritePhyUshort(sc, 0x06, 0xe085);
+                MP_WritePhyUshort(sc, 0x06, 0xd2ad);
+                MP_WritePhyUshort(sc, 0x06, 0x2502);
                 MP_WritePhyUshort(sc, 0x06, 0xf628);
                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
                 MP_WritePhyUshort(sc, 0x06, 0x81ad);
                 MP_WritePhyUshort(sc, 0x06, 0x210a);
-                MP_WritePhyUshort(sc, 0x06, 0xe083);
-                MP_WritePhyUshort(sc, 0x06, 0xecf6);
+                MP_WritePhyUshort(sc, 0x06, 0xe086);
+                MP_WritePhyUshort(sc, 0x06, 0x0af6);
                 MP_WritePhyUshort(sc, 0x06, 0x27a0);
                 MP_WritePhyUshort(sc, 0x06, 0x0502);
                 MP_WritePhyUshort(sc, 0x06, 0xf629);
                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x85ad);
-                MP_WritePhyUshort(sc, 0x06, 0x2008);
-                MP_WritePhyUshort(sc, 0x06, 0xe08a);
-                MP_WritePhyUshort(sc, 0x06, 0xe8ad);
-                MP_WritePhyUshort(sc, 0x06, 0x2102);
-                MP_WritePhyUshort(sc, 0x06, 0xf62a);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x85ad);
-                MP_WritePhyUshort(sc, 0x06, 0x2308);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x20a0);
-                MP_WritePhyUshort(sc, 0x06, 0x0302);
-                MP_WritePhyUshort(sc, 0x06, 0xf62b);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
                 MP_WritePhyUshort(sc, 0x06, 0x87ad);
                 MP_WritePhyUshort(sc, 0x06, 0x2408);
                 MP_WritePhyUshort(sc, 0x06, 0xe08a);
-                MP_WritePhyUshort(sc, 0x06, 0xc2a0);
-                MP_WritePhyUshort(sc, 0x06, 0x0302);
-                MP_WritePhyUshort(sc, 0x06, 0xf62c);
-                MP_WritePhyUshort(sc, 0x06, 0xe58a);
-                MP_WritePhyUshort(sc, 0x06, 0xf4a1);
-                MP_WritePhyUshort(sc, 0x06, 0x0008);
-                MP_WritePhyUshort(sc, 0x06, 0xd100);
-                MP_WritePhyUshort(sc, 0x06, 0xbf22);
-                MP_WritePhyUshort(sc, 0x06, 0x7a02);
-                MP_WritePhyUshort(sc, 0x06, 0x387d);
-                MP_WritePhyUshort(sc, 0x06, 0xfc04);
-                MP_WritePhyUshort(sc, 0x06, 0xee8a);
-                MP_WritePhyUshort(sc, 0x06, 0xc200);
+                MP_WritePhyUshort(sc, 0x06, 0xedad);
+                MP_WritePhyUshort(sc, 0x06, 0x2002);
+                MP_WritePhyUshort(sc, 0x06, 0xf62a);
+                MP_WritePhyUshort(sc, 0x06, 0xe58b);
+                MP_WritePhyUshort(sc, 0x06, 0x2ea1);
+                MP_WritePhyUshort(sc, 0x06, 0x0003);
+                MP_WritePhyUshort(sc, 0x06, 0x0221);
+                MP_WritePhyUshort(sc, 0x06, 0x11fc);
+                MP_WritePhyUshort(sc, 0x06, 0x04ee);
+                MP_WritePhyUshort(sc, 0x06, 0x8aed);
+                MP_WritePhyUshort(sc, 0x06, 0x00ee);
+                MP_WritePhyUshort(sc, 0x06, 0x8aec);
+                MP_WritePhyUshort(sc, 0x06, 0x0004);
+                MP_WritePhyUshort(sc, 0x06, 0xf8e0);
+                MP_WritePhyUshort(sc, 0x06, 0x8b87);
+                MP_WritePhyUshort(sc, 0x06, 0xad24);
+                MP_WritePhyUshort(sc, 0x06, 0x3ae0);
+                MP_WritePhyUshort(sc, 0x06, 0xe0ea);
+                MP_WritePhyUshort(sc, 0x06, 0xe1e0);
+                MP_WritePhyUshort(sc, 0x06, 0xeb58);
+                MP_WritePhyUshort(sc, 0x06, 0xf8d1);
+                MP_WritePhyUshort(sc, 0x06, 0x01e4);
+                MP_WritePhyUshort(sc, 0x06, 0xe0ea);
+                MP_WritePhyUshort(sc, 0x06, 0xe5e0);
+                MP_WritePhyUshort(sc, 0x06, 0xebe0);
+                MP_WritePhyUshort(sc, 0x06, 0xe07c);
+                MP_WritePhyUshort(sc, 0x06, 0xe1e0);
+                MP_WritePhyUshort(sc, 0x06, 0x7d5c);
+                MP_WritePhyUshort(sc, 0x06, 0x00ff);
+                MP_WritePhyUshort(sc, 0x06, 0x3c00);
+                MP_WritePhyUshort(sc, 0x06, 0x1eab);
+                MP_WritePhyUshort(sc, 0x06, 0x1ce0);
+                MP_WritePhyUshort(sc, 0x06, 0xe04c);
+                MP_WritePhyUshort(sc, 0x06, 0xe1e0);
+                MP_WritePhyUshort(sc, 0x06, 0x4d58);
+                MP_WritePhyUshort(sc, 0x06, 0xc1e4);
+                MP_WritePhyUshort(sc, 0x06, 0xe04c);
+                MP_WritePhyUshort(sc, 0x06, 0xe5e0);
+                MP_WritePhyUshort(sc, 0x06, 0x4de0);
+                MP_WritePhyUshort(sc, 0x06, 0xe0ee);
+                MP_WritePhyUshort(sc, 0x06, 0xe1e0);
+                MP_WritePhyUshort(sc, 0x06, 0xef69);
+                MP_WritePhyUshort(sc, 0x06, 0x3ce4);
+                MP_WritePhyUshort(sc, 0x06, 0xe0ee);
+                MP_WritePhyUshort(sc, 0x06, 0xe5e0);
+                MP_WritePhyUshort(sc, 0x06, 0xeffc);
                 MP_WritePhyUshort(sc, 0x06, 0x04f8);
                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
                 MP_WritePhyUshort(sc, 0x06, 0x87ad);
-                MP_WritePhyUshort(sc, 0x06, 0x241e);
-                MP_WritePhyUshort(sc, 0x06, 0xe08a);
-                MP_WritePhyUshort(sc, 0x06, 0xc2a0);
-                MP_WritePhyUshort(sc, 0x06, 0x0005);
-                MP_WritePhyUshort(sc, 0x06, 0x0282);
-                MP_WritePhyUshort(sc, 0x06, 0xb0ae);
-                MP_WritePhyUshort(sc, 0x06, 0xf5a0);
-                MP_WritePhyUshort(sc, 0x06, 0x0105);
-                MP_WritePhyUshort(sc, 0x06, 0x0282);
-                MP_WritePhyUshort(sc, 0x06, 0xc0ae);
-                MP_WritePhyUshort(sc, 0x06, 0x0ba0);
-                MP_WritePhyUshort(sc, 0x06, 0x0205);
-                MP_WritePhyUshort(sc, 0x06, 0x0282);
-                MP_WritePhyUshort(sc, 0x06, 0xcaae);
-                MP_WritePhyUshort(sc, 0x06, 0x03a0);
-                MP_WritePhyUshort(sc, 0x06, 0x0300);
-                MP_WritePhyUshort(sc, 0x06, 0xfc04);
-                MP_WritePhyUshort(sc, 0x06, 0xf8fa);
-                MP_WritePhyUshort(sc, 0x06, 0xef69);
-                MP_WritePhyUshort(sc, 0x06, 0x0282);
-                MP_WritePhyUshort(sc, 0x06, 0xe1ee);
-                MP_WritePhyUshort(sc, 0x06, 0x8ac2);
-                MP_WritePhyUshort(sc, 0x06, 0x01ef);
-                MP_WritePhyUshort(sc, 0x06, 0x96fe);
-                MP_WritePhyUshort(sc, 0x06, 0xfc04);
-                MP_WritePhyUshort(sc, 0x06, 0xf8ee);
-                MP_WritePhyUshort(sc, 0x06, 0x8ac9);
-                MP_WritePhyUshort(sc, 0x06, 0x0002);
-                MP_WritePhyUshort(sc, 0x06, 0x8317);
+                MP_WritePhyUshort(sc, 0x06, 0x2412);
+                MP_WritePhyUshort(sc, 0x06, 0xe0e0);
+                MP_WritePhyUshort(sc, 0x06, 0xeee1);
+                MP_WritePhyUshort(sc, 0x06, 0xe0ef);
+                MP_WritePhyUshort(sc, 0x06, 0x59c3);
+                MP_WritePhyUshort(sc, 0x06, 0xe4e0);
+                MP_WritePhyUshort(sc, 0x06, 0xeee5);
+                MP_WritePhyUshort(sc, 0x06, 0xe0ef);
+                MP_WritePhyUshort(sc, 0x06, 0xee8a);
+                MP_WritePhyUshort(sc, 0x06, 0xed01);
                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
                 MP_WritePhyUshort(sc, 0x06, 0xf8e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8ac8);
-                MP_WritePhyUshort(sc, 0x06, 0xe18a);
-                MP_WritePhyUshort(sc, 0x06, 0xc91f);
-                MP_WritePhyUshort(sc, 0x06, 0x019e);
-                MP_WritePhyUshort(sc, 0x06, 0x0611);
-                MP_WritePhyUshort(sc, 0x06, 0xe58a);
-                MP_WritePhyUshort(sc, 0x06, 0xc9ae);
-                MP_WritePhyUshort(sc, 0x06, 0x04ee);
-                MP_WritePhyUshort(sc, 0x06, 0x8ac2);
-                MP_WritePhyUshort(sc, 0x06, 0x01fc);
+                MP_WritePhyUshort(sc, 0x06, 0x8b81);
+                MP_WritePhyUshort(sc, 0x06, 0xac25);
+                MP_WritePhyUshort(sc, 0x06, 0x0502);
+                MP_WritePhyUshort(sc, 0x06, 0x8363);
+                MP_WritePhyUshort(sc, 0x06, 0xae03);
+                MP_WritePhyUshort(sc, 0x06, 0x0225);
+                MP_WritePhyUshort(sc, 0x06, 0x16fc);
                 MP_WritePhyUshort(sc, 0x06, 0x04f8);
                 MP_WritePhyUshort(sc, 0x06, 0xf9fa);
                 MP_WritePhyUshort(sc, 0x06, 0xef69);
-                MP_WritePhyUshort(sc, 0x06, 0xfbbf);
-                MP_WritePhyUshort(sc, 0x06, 0x8ac4);
-                MP_WritePhyUshort(sc, 0x06, 0xef79);
-                MP_WritePhyUshort(sc, 0x06, 0xd200);
-                MP_WritePhyUshort(sc, 0x06, 0xd400);
-                MP_WritePhyUshort(sc, 0x06, 0x221e);
-                MP_WritePhyUshort(sc, 0x06, 0x02bf);
-                MP_WritePhyUshort(sc, 0x06, 0x3024);
-                MP_WritePhyUshort(sc, 0x06, 0x0238);
-                MP_WritePhyUshort(sc, 0x06, 0x7dbf);
-                MP_WritePhyUshort(sc, 0x06, 0x13ff);
-                MP_WritePhyUshort(sc, 0x06, 0x0238);
-                MP_WritePhyUshort(sc, 0x06, 0x500d);
-                MP_WritePhyUshort(sc, 0x06, 0x4559);
-                MP_WritePhyUshort(sc, 0x06, 0x1fef);
-                MP_WritePhyUshort(sc, 0x06, 0x97dd);
-                MP_WritePhyUshort(sc, 0x06, 0xd308);
-                MP_WritePhyUshort(sc, 0x06, 0x1a93);
-                MP_WritePhyUshort(sc, 0x06, 0xdd12);
-                MP_WritePhyUshort(sc, 0x06, 0x17a2);
-                MP_WritePhyUshort(sc, 0x06, 0x04de);
-                MP_WritePhyUshort(sc, 0x06, 0xffef);
+                MP_WritePhyUshort(sc, 0x06, 0xfae0);
+                MP_WritePhyUshort(sc, 0x06, 0x860a);
+                MP_WritePhyUshort(sc, 0x06, 0xa000);
+                MP_WritePhyUshort(sc, 0x06, 0x19e0);
+                MP_WritePhyUshort(sc, 0x06, 0x860b);
+                MP_WritePhyUshort(sc, 0x06, 0xe18b);
+                MP_WritePhyUshort(sc, 0x06, 0x331b);
+                MP_WritePhyUshort(sc, 0x06, 0x109e);
+                MP_WritePhyUshort(sc, 0x06, 0x04aa);
+                MP_WritePhyUshort(sc, 0x06, 0x02ae);
+                MP_WritePhyUshort(sc, 0x06, 0x06ee);
+                MP_WritePhyUshort(sc, 0x06, 0x860a);
+                MP_WritePhyUshort(sc, 0x06, 0x01ae);
+                MP_WritePhyUshort(sc, 0x06, 0xe602);
+                MP_WritePhyUshort(sc, 0x06, 0x241e);
+                MP_WritePhyUshort(sc, 0x06, 0xae14);
+                MP_WritePhyUshort(sc, 0x06, 0xa001);
+                MP_WritePhyUshort(sc, 0x06, 0x1402);
+                MP_WritePhyUshort(sc, 0x06, 0x2426);
+                MP_WritePhyUshort(sc, 0x06, 0xbf26);
+                MP_WritePhyUshort(sc, 0x06, 0x6d02);
+                MP_WritePhyUshort(sc, 0x06, 0x2eb0);
+                MP_WritePhyUshort(sc, 0x06, 0xee86);
+                MP_WritePhyUshort(sc, 0x06, 0x0b00);
+                MP_WritePhyUshort(sc, 0x06, 0xee86);
+                MP_WritePhyUshort(sc, 0x06, 0x0a02);
+                MP_WritePhyUshort(sc, 0x06, 0xaf84);
+                MP_WritePhyUshort(sc, 0x06, 0x3ca0);
+                MP_WritePhyUshort(sc, 0x06, 0x0252);
+                MP_WritePhyUshort(sc, 0x06, 0xee86);
+                MP_WritePhyUshort(sc, 0x06, 0x0400);
+                MP_WritePhyUshort(sc, 0x06, 0xee86);
+                MP_WritePhyUshort(sc, 0x06, 0x0500);
+                MP_WritePhyUshort(sc, 0x06, 0xe086);
+                MP_WritePhyUshort(sc, 0x06, 0x0be1);
+                MP_WritePhyUshort(sc, 0x06, 0x8b32);
+                MP_WritePhyUshort(sc, 0x06, 0x1b10);
+                MP_WritePhyUshort(sc, 0x06, 0x9e04);
+                MP_WritePhyUshort(sc, 0x06, 0xaa02);
+                MP_WritePhyUshort(sc, 0x06, 0xaecb);
+                MP_WritePhyUshort(sc, 0x06, 0xee86);
+                MP_WritePhyUshort(sc, 0x06, 0x0b00);
+                MP_WritePhyUshort(sc, 0x06, 0x0224);
+                MP_WritePhyUshort(sc, 0x06, 0x3ae2);
+                MP_WritePhyUshort(sc, 0x06, 0x8604);
+                MP_WritePhyUshort(sc, 0x06, 0xe386);
+                MP_WritePhyUshort(sc, 0x06, 0x05ef);
+                MP_WritePhyUshort(sc, 0x06, 0x65e2);
+                MP_WritePhyUshort(sc, 0x06, 0x8606);
+                MP_WritePhyUshort(sc, 0x06, 0xe386);
+                MP_WritePhyUshort(sc, 0x06, 0x071b);
+                MP_WritePhyUshort(sc, 0x06, 0x56aa);
+                MP_WritePhyUshort(sc, 0x06, 0x0eef);
+                MP_WritePhyUshort(sc, 0x06, 0x56e6);
+                MP_WritePhyUshort(sc, 0x06, 0x8606);
+                MP_WritePhyUshort(sc, 0x06, 0xe786);
+                MP_WritePhyUshort(sc, 0x06, 0x07e2);
+                MP_WritePhyUshort(sc, 0x06, 0x8609);
+                MP_WritePhyUshort(sc, 0x06, 0xe686);
+                MP_WritePhyUshort(sc, 0x06, 0x08e0);
+                MP_WritePhyUshort(sc, 0x06, 0x8609);
+                MP_WritePhyUshort(sc, 0x06, 0xa000);
+                MP_WritePhyUshort(sc, 0x06, 0x07ee);
+                MP_WritePhyUshort(sc, 0x06, 0x860a);
+                MP_WritePhyUshort(sc, 0x06, 0x03af);
+                MP_WritePhyUshort(sc, 0x06, 0x8369);
+                MP_WritePhyUshort(sc, 0x06, 0x0224);
+                MP_WritePhyUshort(sc, 0x06, 0x8e02);
+                MP_WritePhyUshort(sc, 0x06, 0x2426);
+                MP_WritePhyUshort(sc, 0x06, 0xae48);
+                MP_WritePhyUshort(sc, 0x06, 0xa003);
+                MP_WritePhyUshort(sc, 0x06, 0x21e0);
+                MP_WritePhyUshort(sc, 0x06, 0x8608);
+                MP_WritePhyUshort(sc, 0x06, 0xe186);
+                MP_WritePhyUshort(sc, 0x06, 0x091b);
+                MP_WritePhyUshort(sc, 0x06, 0x019e);
+                MP_WritePhyUshort(sc, 0x06, 0x0caa);
+                MP_WritePhyUshort(sc, 0x06, 0x0502);
+                MP_WritePhyUshort(sc, 0x06, 0x249d);
+                MP_WritePhyUshort(sc, 0x06, 0xaee7);
+                MP_WritePhyUshort(sc, 0x06, 0x0224);
+                MP_WritePhyUshort(sc, 0x06, 0x8eae);
+                MP_WritePhyUshort(sc, 0x06, 0xe2ee);
+                MP_WritePhyUshort(sc, 0x06, 0x860a);
+                MP_WritePhyUshort(sc, 0x06, 0x04ee);
+                MP_WritePhyUshort(sc, 0x06, 0x860b);
+                MP_WritePhyUshort(sc, 0x06, 0x00af);
+                MP_WritePhyUshort(sc, 0x06, 0x8369);
+                MP_WritePhyUshort(sc, 0x06, 0xa004);
+                MP_WritePhyUshort(sc, 0x06, 0x15e0);
+                MP_WritePhyUshort(sc, 0x06, 0x860b);
+                MP_WritePhyUshort(sc, 0x06, 0xe18b);
+                MP_WritePhyUshort(sc, 0x06, 0x341b);
+                MP_WritePhyUshort(sc, 0x06, 0x109e);
+                MP_WritePhyUshort(sc, 0x06, 0x05aa);
+                MP_WritePhyUshort(sc, 0x06, 0x03af);
+                MP_WritePhyUshort(sc, 0x06, 0x8383);
+                MP_WritePhyUshort(sc, 0x06, 0xee86);
+                MP_WritePhyUshort(sc, 0x06, 0x0a05);
+                MP_WritePhyUshort(sc, 0x06, 0xae0c);
+                MP_WritePhyUshort(sc, 0x06, 0xa005);
+                MP_WritePhyUshort(sc, 0x06, 0x02ae);
+                MP_WritePhyUshort(sc, 0x06, 0x0702);
+                MP_WritePhyUshort(sc, 0x06, 0x2309);
+                MP_WritePhyUshort(sc, 0x06, 0xee86);
+                MP_WritePhyUshort(sc, 0x06, 0x0a00);
+                MP_WritePhyUshort(sc, 0x06, 0xfeef);
                 MP_WritePhyUshort(sc, 0x06, 0x96fe);
                 MP_WritePhyUshort(sc, 0x06, 0xfdfc);
                 MP_WritePhyUshort(sc, 0x06, 0x04f8);
                 MP_WritePhyUshort(sc, 0x06, 0xf9fa);
                 MP_WritePhyUshort(sc, 0x06, 0xef69);
-                MP_WritePhyUshort(sc, 0x06, 0xfbee);
-                MP_WritePhyUshort(sc, 0x06, 0x8ac2);
-                MP_WritePhyUshort(sc, 0x06, 0x03d5);
-                MP_WritePhyUshort(sc, 0x06, 0x0080);
-                MP_WritePhyUshort(sc, 0x06, 0xbf8a);
-                MP_WritePhyUshort(sc, 0x06, 0xc4ef);
-                MP_WritePhyUshort(sc, 0x06, 0x79ef);
-                MP_WritePhyUshort(sc, 0x06, 0x45bf);
-                MP_WritePhyUshort(sc, 0x06, 0x3024);
-                MP_WritePhyUshort(sc, 0x06, 0x0238);
-                MP_WritePhyUshort(sc, 0x06, 0x7dbf);
-                MP_WritePhyUshort(sc, 0x06, 0x13ff);
-                MP_WritePhyUshort(sc, 0x06, 0x0238);
-                MP_WritePhyUshort(sc, 0x06, 0x50ad);
-                MP_WritePhyUshort(sc, 0x06, 0x2702);
-                MP_WritePhyUshort(sc, 0x06, 0x78ff);
-                MP_WritePhyUshort(sc, 0x06, 0xe18a);
-                MP_WritePhyUshort(sc, 0x06, 0xca1b);
-                MP_WritePhyUshort(sc, 0x06, 0x01aa);
-                MP_WritePhyUshort(sc, 0x06, 0x2eef);
-                MP_WritePhyUshort(sc, 0x06, 0x97d9);
-                MP_WritePhyUshort(sc, 0x06, 0x7900);
-                MP_WritePhyUshort(sc, 0x06, 0x9e2b);
-                MP_WritePhyUshort(sc, 0x06, 0x81dd);
-                MP_WritePhyUshort(sc, 0x06, 0xbf85);
-                MP_WritePhyUshort(sc, 0x06, 0xad02);
-                MP_WritePhyUshort(sc, 0x06, 0x387d);
-                MP_WritePhyUshort(sc, 0x06, 0xd101);
-                MP_WritePhyUshort(sc, 0x06, 0xef02);
-                MP_WritePhyUshort(sc, 0x06, 0x100c);
-                MP_WritePhyUshort(sc, 0x06, 0x11b0);
-                MP_WritePhyUshort(sc, 0x06, 0xfc0d);
-                MP_WritePhyUshort(sc, 0x06, 0x11bf);
-                MP_WritePhyUshort(sc, 0x06, 0x85aa);
-                MP_WritePhyUshort(sc, 0x06, 0x0238);
-                MP_WritePhyUshort(sc, 0x06, 0x7dd1);
-                MP_WritePhyUshort(sc, 0x06, 0x00bf);
-                MP_WritePhyUshort(sc, 0x06, 0x85aa);
-                MP_WritePhyUshort(sc, 0x06, 0x0238);
-                MP_WritePhyUshort(sc, 0x06, 0x7dee);
-                MP_WritePhyUshort(sc, 0x06, 0x8ac2);
-                MP_WritePhyUshort(sc, 0x06, 0x02ae);
-                MP_WritePhyUshort(sc, 0x06, 0x0413);
-                MP_WritePhyUshort(sc, 0x06, 0xa38b);
-                MP_WritePhyUshort(sc, 0x06, 0xb4d3);
-                MP_WritePhyUshort(sc, 0x06, 0x8012);
-                MP_WritePhyUshort(sc, 0x06, 0x17a2);
-                MP_WritePhyUshort(sc, 0x06, 0x04ad);
-                MP_WritePhyUshort(sc, 0x06, 0xffef);
-                MP_WritePhyUshort(sc, 0x06, 0x96fe);
-                MP_WritePhyUshort(sc, 0x06, 0xfdfc);
-                MP_WritePhyUshort(sc, 0x06, 0x04f8);
-                MP_WritePhyUshort(sc, 0x06, 0xf9e0);
+                MP_WritePhyUshort(sc, 0x06, 0xfbe0);
                 MP_WritePhyUshort(sc, 0x06, 0x8b85);
                 MP_WritePhyUshort(sc, 0x06, 0xad25);
-                MP_WritePhyUshort(sc, 0x06, 0x48e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8a96);
+                MP_WritePhyUshort(sc, 0x06, 0x22e0);
+                MP_WritePhyUshort(sc, 0x06, 0xe022);
+                MP_WritePhyUshort(sc, 0x06, 0xe1e0);
+                MP_WritePhyUshort(sc, 0x06, 0x23e2);
+                MP_WritePhyUshort(sc, 0x06, 0xe036);
+                MP_WritePhyUshort(sc, 0x06, 0xe3e0);
+                MP_WritePhyUshort(sc, 0x06, 0x375a);
+                MP_WritePhyUshort(sc, 0x06, 0xc40d);
+                MP_WritePhyUshort(sc, 0x06, 0x0158);
+                MP_WritePhyUshort(sc, 0x06, 0x021e);
+                MP_WritePhyUshort(sc, 0x06, 0x20e3);
+                MP_WritePhyUshort(sc, 0x06, 0x8ae7);
+                MP_WritePhyUshort(sc, 0x06, 0xac31);
+                MP_WritePhyUshort(sc, 0x06, 0x60ac);
+                MP_WritePhyUshort(sc, 0x06, 0x3a08);
+                MP_WritePhyUshort(sc, 0x06, 0xac3e);
+                MP_WritePhyUshort(sc, 0x06, 0x26ae);
+                MP_WritePhyUshort(sc, 0x06, 0x67af);
+                MP_WritePhyUshort(sc, 0x06, 0x84db);
+                MP_WritePhyUshort(sc, 0x06, 0xad37);
+                MP_WritePhyUshort(sc, 0x06, 0x61e0);
+                MP_WritePhyUshort(sc, 0x06, 0x8ae8);
+                MP_WritePhyUshort(sc, 0x06, 0x10e4);
+                MP_WritePhyUshort(sc, 0x06, 0x8ae8);
                 MP_WritePhyUshort(sc, 0x06, 0xe18a);
-                MP_WritePhyUshort(sc, 0x06, 0x977c);
-                MP_WritePhyUshort(sc, 0x06, 0x0000);
-                MP_WritePhyUshort(sc, 0x06, 0x9e35);
-                MP_WritePhyUshort(sc, 0x06, 0xee8a);
-                MP_WritePhyUshort(sc, 0x06, 0x9600);
-                MP_WritePhyUshort(sc, 0x06, 0xee8a);
-                MP_WritePhyUshort(sc, 0x06, 0x9700);
+                MP_WritePhyUshort(sc, 0x06, 0xe91b);
+                MP_WritePhyUshort(sc, 0x06, 0x109e);
+                MP_WritePhyUshort(sc, 0x06, 0x02ae);
+                MP_WritePhyUshort(sc, 0x06, 0x51d1);
+                MP_WritePhyUshort(sc, 0x06, 0x00bf);
+                MP_WritePhyUshort(sc, 0x06, 0x863b);
+                MP_WritePhyUshort(sc, 0x06, 0x022f);
+                MP_WritePhyUshort(sc, 0x06, 0x50ee);
+                MP_WritePhyUshort(sc, 0x06, 0x8ae8);
+                MP_WritePhyUshort(sc, 0x06, 0x00ae);
+                MP_WritePhyUshort(sc, 0x06, 0x43ad);
+                MP_WritePhyUshort(sc, 0x06, 0x3627);
                 MP_WritePhyUshort(sc, 0x06, 0xe08a);
-                MP_WritePhyUshort(sc, 0x06, 0xbee1);
-                MP_WritePhyUshort(sc, 0x06, 0x8abf);
-                MP_WritePhyUshort(sc, 0x06, 0xe28a);
-                MP_WritePhyUshort(sc, 0x06, 0xc0e3);
-                MP_WritePhyUshort(sc, 0x06, 0x8ac1);
-                MP_WritePhyUshort(sc, 0x06, 0x0237);
-                MP_WritePhyUshort(sc, 0x06, 0x74ad);
-                MP_WritePhyUshort(sc, 0x06, 0x2012);
-                MP_WritePhyUshort(sc, 0x06, 0xee8a);
-                MP_WritePhyUshort(sc, 0x06, 0x9603);
-                MP_WritePhyUshort(sc, 0x06, 0xee8a);
-                MP_WritePhyUshort(sc, 0x06, 0x97b7);
-                MP_WritePhyUshort(sc, 0x06, 0xee8a);
-                MP_WritePhyUshort(sc, 0x06, 0xc000);
-                MP_WritePhyUshort(sc, 0x06, 0xee8a);
-                MP_WritePhyUshort(sc, 0x06, 0xc100);
-                MP_WritePhyUshort(sc, 0x06, 0xae11);
-                MP_WritePhyUshort(sc, 0x06, 0x15e6);
-                MP_WritePhyUshort(sc, 0x06, 0x8ac0);
-                MP_WritePhyUshort(sc, 0x06, 0xe78a);
-                MP_WritePhyUshort(sc, 0x06, 0xc1ae);
-                MP_WritePhyUshort(sc, 0x06, 0x08ee);
-                MP_WritePhyUshort(sc, 0x06, 0x8ac0);
+                MP_WritePhyUshort(sc, 0x06, 0xeee1);
+                MP_WritePhyUshort(sc, 0x06, 0x8aef);
+                MP_WritePhyUshort(sc, 0x06, 0xef74);
+                MP_WritePhyUshort(sc, 0x06, 0xe08a);
+                MP_WritePhyUshort(sc, 0x06, 0xeae1);
+                MP_WritePhyUshort(sc, 0x06, 0x8aeb);
+                MP_WritePhyUshort(sc, 0x06, 0x1b74);
+                MP_WritePhyUshort(sc, 0x06, 0x9e2e);
+                MP_WritePhyUshort(sc, 0x06, 0x14e4);
+                MP_WritePhyUshort(sc, 0x06, 0x8aea);
+                MP_WritePhyUshort(sc, 0x06, 0xe58a);
+                MP_WritePhyUshort(sc, 0x06, 0xebef);
+                MP_WritePhyUshort(sc, 0x06, 0x74e0);
+                MP_WritePhyUshort(sc, 0x06, 0x8aee);
+                MP_WritePhyUshort(sc, 0x06, 0xe18a);
+                MP_WritePhyUshort(sc, 0x06, 0xef1b);
+                MP_WritePhyUshort(sc, 0x06, 0x479e);
+                MP_WritePhyUshort(sc, 0x06, 0x0fae);
+                MP_WritePhyUshort(sc, 0x06, 0x19ee);
+                MP_WritePhyUshort(sc, 0x06, 0x8aea);
                 MP_WritePhyUshort(sc, 0x06, 0x00ee);
-                MP_WritePhyUshort(sc, 0x06, 0x8ac1);
-                MP_WritePhyUshort(sc, 0x06, 0x00fd);
+                MP_WritePhyUshort(sc, 0x06, 0x8aeb);
+                MP_WritePhyUshort(sc, 0x06, 0x00ae);
+                MP_WritePhyUshort(sc, 0x06, 0x0fac);
+                MP_WritePhyUshort(sc, 0x06, 0x390c);
+                MP_WritePhyUshort(sc, 0x06, 0xd101);
+                MP_WritePhyUshort(sc, 0x06, 0xbf86);
+                MP_WritePhyUshort(sc, 0x06, 0x3b02);
+                MP_WritePhyUshort(sc, 0x06, 0x2f50);
+                MP_WritePhyUshort(sc, 0x06, 0xee8a);
+                MP_WritePhyUshort(sc, 0x06, 0xe800);
+                MP_WritePhyUshort(sc, 0x06, 0xe68a);
+                MP_WritePhyUshort(sc, 0x06, 0xe7ff);
+                MP_WritePhyUshort(sc, 0x06, 0xef96);
+                MP_WritePhyUshort(sc, 0x06, 0xfefd);
+                MP_WritePhyUshort(sc, 0x06, 0xfc04);
+                MP_WritePhyUshort(sc, 0x06, 0xf8f9);
+                MP_WritePhyUshort(sc, 0x06, 0xfaef);
+                MP_WritePhyUshort(sc, 0x06, 0x69e0);
+                MP_WritePhyUshort(sc, 0x06, 0xe022);
+                MP_WritePhyUshort(sc, 0x06, 0xe1e0);
+                MP_WritePhyUshort(sc, 0x06, 0x2358);
+                MP_WritePhyUshort(sc, 0x06, 0xc4e1);
+                MP_WritePhyUshort(sc, 0x06, 0x8b6e);
+                MP_WritePhyUshort(sc, 0x06, 0x1f10);
+                MP_WritePhyUshort(sc, 0x06, 0x9e24);
+                MP_WritePhyUshort(sc, 0x06, 0xe48b);
+                MP_WritePhyUshort(sc, 0x06, 0x6ead);
+                MP_WritePhyUshort(sc, 0x06, 0x2218);
+                MP_WritePhyUshort(sc, 0x06, 0xac27);
+                MP_WritePhyUshort(sc, 0x06, 0x0dac);
+                MP_WritePhyUshort(sc, 0x06, 0x2605);
+                MP_WritePhyUshort(sc, 0x06, 0x0203);
+                MP_WritePhyUshort(sc, 0x06, 0x8fae);
+                MP_WritePhyUshort(sc, 0x06, 0x1302);
+                MP_WritePhyUshort(sc, 0x06, 0x03c8);
+                MP_WritePhyUshort(sc, 0x06, 0xae0e);
+                MP_WritePhyUshort(sc, 0x06, 0x0203);
+                MP_WritePhyUshort(sc, 0x06, 0xe102);
+                MP_WritePhyUshort(sc, 0x06, 0x8520);
+                MP_WritePhyUshort(sc, 0x06, 0xae06);
+                MP_WritePhyUshort(sc, 0x06, 0x0203);
+                MP_WritePhyUshort(sc, 0x06, 0x8f02);
+                MP_WritePhyUshort(sc, 0x06, 0x8566);
+                MP_WritePhyUshort(sc, 0x06, 0xef96);
+                MP_WritePhyUshort(sc, 0x06, 0xfefd);
+                MP_WritePhyUshort(sc, 0x06, 0xfc04);
+                MP_WritePhyUshort(sc, 0x06, 0xf8fa);
+                MP_WritePhyUshort(sc, 0x06, 0xef69);
+                MP_WritePhyUshort(sc, 0x06, 0xe08b);
+                MP_WritePhyUshort(sc, 0x06, 0x82ad);
+                MP_WritePhyUshort(sc, 0x06, 0x2737);
+                MP_WritePhyUshort(sc, 0x06, 0xbf86);
+                MP_WritePhyUshort(sc, 0x06, 0x4402);
+                MP_WritePhyUshort(sc, 0x06, 0x2f23);
+                MP_WritePhyUshort(sc, 0x06, 0xac28);
+                MP_WritePhyUshort(sc, 0x06, 0x2ed1);
+                MP_WritePhyUshort(sc, 0x06, 0x01bf);
+                MP_WritePhyUshort(sc, 0x06, 0x8647);
+                MP_WritePhyUshort(sc, 0x06, 0x022f);
+                MP_WritePhyUshort(sc, 0x06, 0x50bf);
+                MP_WritePhyUshort(sc, 0x06, 0x8641);
+                MP_WritePhyUshort(sc, 0x06, 0x022f);
+                MP_WritePhyUshort(sc, 0x06, 0x23e5);
+                MP_WritePhyUshort(sc, 0x06, 0x8af0);
+                MP_WritePhyUshort(sc, 0x06, 0xe0e0);
+                MP_WritePhyUshort(sc, 0x06, 0x22e1);
+                MP_WritePhyUshort(sc, 0x06, 0xe023);
+                MP_WritePhyUshort(sc, 0x06, 0xac2e);
+                MP_WritePhyUshort(sc, 0x06, 0x04d1);
+                MP_WritePhyUshort(sc, 0x06, 0x01ae);
+                MP_WritePhyUshort(sc, 0x06, 0x02d1);
+                MP_WritePhyUshort(sc, 0x06, 0x00bf);
+                MP_WritePhyUshort(sc, 0x06, 0x8641);
+                MP_WritePhyUshort(sc, 0x06, 0x022f);
+                MP_WritePhyUshort(sc, 0x06, 0x50d1);
+                MP_WritePhyUshort(sc, 0x06, 0x01bf);
+                MP_WritePhyUshort(sc, 0x06, 0x8644);
+                MP_WritePhyUshort(sc, 0x06, 0x022f);
+                MP_WritePhyUshort(sc, 0x06, 0x50ef);
+                MP_WritePhyUshort(sc, 0x06, 0x96fe);
+                MP_WritePhyUshort(sc, 0x06, 0xfc04);
+                MP_WritePhyUshort(sc, 0x06, 0xf8fa);
+                MP_WritePhyUshort(sc, 0x06, 0xef69);
+                MP_WritePhyUshort(sc, 0x06, 0xbf86);
+                MP_WritePhyUshort(sc, 0x06, 0x4702);
+                MP_WritePhyUshort(sc, 0x06, 0x2f23);
+                MP_WritePhyUshort(sc, 0x06, 0xad28);
+                MP_WritePhyUshort(sc, 0x06, 0x19d1);
+                MP_WritePhyUshort(sc, 0x06, 0x00bf);
+                MP_WritePhyUshort(sc, 0x06, 0x8644);
+                MP_WritePhyUshort(sc, 0x06, 0x022f);
+                MP_WritePhyUshort(sc, 0x06, 0x50e1);
+                MP_WritePhyUshort(sc, 0x06, 0x8af0);
+                MP_WritePhyUshort(sc, 0x06, 0xbf86);
+                MP_WritePhyUshort(sc, 0x06, 0x4102);
+                MP_WritePhyUshort(sc, 0x06, 0x2f50);
+                MP_WritePhyUshort(sc, 0x06, 0xd100);
+                MP_WritePhyUshort(sc, 0x06, 0xbf86);
+                MP_WritePhyUshort(sc, 0x06, 0x4702);
+                MP_WritePhyUshort(sc, 0x06, 0x2f50);
+                MP_WritePhyUshort(sc, 0x06, 0xef96);
+                MP_WritePhyUshort(sc, 0x06, 0xfefc);
+                MP_WritePhyUshort(sc, 0x06, 0x04f8);
+                MP_WritePhyUshort(sc, 0x06, 0xe0e2);
+                MP_WritePhyUshort(sc, 0x06, 0xfee1);
+                MP_WritePhyUshort(sc, 0x06, 0xe2ff);
+                MP_WritePhyUshort(sc, 0x06, 0xad2e);
+                MP_WritePhyUshort(sc, 0x06, 0x63e0);
+                MP_WritePhyUshort(sc, 0x06, 0xe038);
+                MP_WritePhyUshort(sc, 0x06, 0xe1e0);
+                MP_WritePhyUshort(sc, 0x06, 0x39ad);
+                MP_WritePhyUshort(sc, 0x06, 0x2f10);
+                MP_WritePhyUshort(sc, 0x06, 0xe0e0);
+                MP_WritePhyUshort(sc, 0x06, 0x34e1);
+                MP_WritePhyUshort(sc, 0x06, 0xe035);
+                MP_WritePhyUshort(sc, 0x06, 0xf726);
+                MP_WritePhyUshort(sc, 0x06, 0xe4e0);
+                MP_WritePhyUshort(sc, 0x06, 0x34e5);
+                MP_WritePhyUshort(sc, 0x06, 0xe035);
+                MP_WritePhyUshort(sc, 0x06, 0xae0e);
+                MP_WritePhyUshort(sc, 0x06, 0xe0e2);
+                MP_WritePhyUshort(sc, 0x06, 0xd6e1);
+                MP_WritePhyUshort(sc, 0x06, 0xe2d7);
+                MP_WritePhyUshort(sc, 0x06, 0xf728);
+                MP_WritePhyUshort(sc, 0x06, 0xe4e2);
+                MP_WritePhyUshort(sc, 0x06, 0xd6e5);
+                MP_WritePhyUshort(sc, 0x06, 0xe2d7);
+                MP_WritePhyUshort(sc, 0x06, 0xe0e2);
+                MP_WritePhyUshort(sc, 0x06, 0x34e1);
+                MP_WritePhyUshort(sc, 0x06, 0xe235);
+                MP_WritePhyUshort(sc, 0x06, 0xf72b);
+                MP_WritePhyUshort(sc, 0x06, 0xe4e2);
+                MP_WritePhyUshort(sc, 0x06, 0x34e5);
+                MP_WritePhyUshort(sc, 0x06, 0xe235);
+                MP_WritePhyUshort(sc, 0x06, 0xd07d);
+                MP_WritePhyUshort(sc, 0x06, 0xb0fe);
+                MP_WritePhyUshort(sc, 0x06, 0xe0e2);
+                MP_WritePhyUshort(sc, 0x06, 0x34e1);
+                MP_WritePhyUshort(sc, 0x06, 0xe235);
+                MP_WritePhyUshort(sc, 0x06, 0xf62b);
+                MP_WritePhyUshort(sc, 0x06, 0xe4e2);
+                MP_WritePhyUshort(sc, 0x06, 0x34e5);
+                MP_WritePhyUshort(sc, 0x06, 0xe235);
+                MP_WritePhyUshort(sc, 0x06, 0xe0e0);
+                MP_WritePhyUshort(sc, 0x06, 0x34e1);
+                MP_WritePhyUshort(sc, 0x06, 0xe035);
+                MP_WritePhyUshort(sc, 0x06, 0xf626);
+                MP_WritePhyUshort(sc, 0x06, 0xe4e0);
+                MP_WritePhyUshort(sc, 0x06, 0x34e5);
+                MP_WritePhyUshort(sc, 0x06, 0xe035);
+                MP_WritePhyUshort(sc, 0x06, 0xe0e2);
+                MP_WritePhyUshort(sc, 0x06, 0xd6e1);
+                MP_WritePhyUshort(sc, 0x06, 0xe2d7);
+                MP_WritePhyUshort(sc, 0x06, 0xf628);
+                MP_WritePhyUshort(sc, 0x06, 0xe4e2);
+                MP_WritePhyUshort(sc, 0x06, 0xd6e5);
+                MP_WritePhyUshort(sc, 0x06, 0xe2d7);
                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
                 MP_WritePhyUshort(sc, 0x06, 0xae20);
                 MP_WritePhyUshort(sc, 0x06, 0x0000);
@@ -16167,256 +13124,9431 @@ static void re_hw_phy_config(struct re_softc *sc)
                 MP_WritePhyUshort(sc, 0x06, 0x0000);
                 MP_WritePhyUshort(sc, 0x06, 0x0000);
                 MP_WritePhyUshort(sc, 0x06, 0x0000);
-                MP_WritePhyUshort(sc, 0x06, 0xf8fa);
-                MP_WritePhyUshort(sc, 0x06, 0xef69);
-                MP_WritePhyUshort(sc, 0x06, 0xe0e0);
-                MP_WritePhyUshort(sc, 0x06, 0x00e1);
-                MP_WritePhyUshort(sc, 0x06, 0xe001);
-                MP_WritePhyUshort(sc, 0x06, 0xad27);
-                MP_WritePhyUshort(sc, 0x06, 0x32e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b40);
-                MP_WritePhyUshort(sc, 0x06, 0xf720);
-                MP_WritePhyUshort(sc, 0x06, 0xe48b);
-                MP_WritePhyUshort(sc, 0x06, 0x40bf);
-                MP_WritePhyUshort(sc, 0x06, 0x3230);
-                MP_WritePhyUshort(sc, 0x06, 0x0238);
-                MP_WritePhyUshort(sc, 0x06, 0x50ad);
-                MP_WritePhyUshort(sc, 0x06, 0x2821);
-                MP_WritePhyUshort(sc, 0x06, 0xe0e0);
-                MP_WritePhyUshort(sc, 0x06, 0x20e1);
-                MP_WritePhyUshort(sc, 0x06, 0xe021);
-                MP_WritePhyUshort(sc, 0x06, 0xad20);
-                MP_WritePhyUshort(sc, 0x06, 0x18e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b40);
-                MP_WritePhyUshort(sc, 0x06, 0xf620);
-                MP_WritePhyUshort(sc, 0x06, 0xe48b);
-                MP_WritePhyUshort(sc, 0x06, 0x40ee);
-                MP_WritePhyUshort(sc, 0x06, 0x8b3b);
-                MP_WritePhyUshort(sc, 0x06, 0xffe0);
-                MP_WritePhyUshort(sc, 0x06, 0x8a8a);
-                MP_WritePhyUshort(sc, 0x06, 0xe18a);
-                MP_WritePhyUshort(sc, 0x06, 0x8be4);
-                MP_WritePhyUshort(sc, 0x06, 0xe000);
-                MP_WritePhyUshort(sc, 0x06, 0xe5e0);
-                MP_WritePhyUshort(sc, 0x06, 0x01ef);
-                MP_WritePhyUshort(sc, 0x06, 0x96fe);
-                MP_WritePhyUshort(sc, 0x06, 0xfc04);
-                MP_WritePhyUshort(sc, 0x06, 0xf8f9);
-                MP_WritePhyUshort(sc, 0x06, 0xface);
-                MP_WritePhyUshort(sc, 0x06, 0xfaef);
-                MP_WritePhyUshort(sc, 0x06, 0x69fa);
-                MP_WritePhyUshort(sc, 0x06, 0xd401);
-                MP_WritePhyUshort(sc, 0x06, 0x55b4);
-                MP_WritePhyUshort(sc, 0x06, 0xfebf);
-                MP_WritePhyUshort(sc, 0x06, 0x1c1e);
-                MP_WritePhyUshort(sc, 0x06, 0x0238);
-                MP_WritePhyUshort(sc, 0x06, 0x50ac);
-                MP_WritePhyUshort(sc, 0x06, 0x280b);
-                MP_WritePhyUshort(sc, 0x06, 0xbf1c);
-                MP_WritePhyUshort(sc, 0x06, 0x1b02);
-                MP_WritePhyUshort(sc, 0x06, 0x3850);
-                MP_WritePhyUshort(sc, 0x06, 0xac28);
-                MP_WritePhyUshort(sc, 0x06, 0x49ae);
-                MP_WritePhyUshort(sc, 0x06, 0x64bf);
-                MP_WritePhyUshort(sc, 0x06, 0x1c1b);
-                MP_WritePhyUshort(sc, 0x06, 0x0238);
-                MP_WritePhyUshort(sc, 0x06, 0x50ac);
-                MP_WritePhyUshort(sc, 0x06, 0x285b);
-                MP_WritePhyUshort(sc, 0x06, 0xd000);
-                MP_WritePhyUshort(sc, 0x06, 0x0284);
-                MP_WritePhyUshort(sc, 0x06, 0xcaac);
-                MP_WritePhyUshort(sc, 0x06, 0x2105);
-                MP_WritePhyUshort(sc, 0x06, 0xac22);
-                MP_WritePhyUshort(sc, 0x06, 0x02ae);
-                MP_WritePhyUshort(sc, 0x06, 0x4ebf);
-                MP_WritePhyUshort(sc, 0x06, 0xe0c4);
-                MP_WritePhyUshort(sc, 0x06, 0xbe85);
-                MP_WritePhyUshort(sc, 0x06, 0xf6d2);
-                MP_WritePhyUshort(sc, 0x06, 0x04d8);
-                MP_WritePhyUshort(sc, 0x06, 0x19d9);
-                MP_WritePhyUshort(sc, 0x06, 0x1907);
-                MP_WritePhyUshort(sc, 0x06, 0xdc19);
-                MP_WritePhyUshort(sc, 0x06, 0xdd19);
-                MP_WritePhyUshort(sc, 0x06, 0x0789);
-                MP_WritePhyUshort(sc, 0x06, 0x89ef);
-                MP_WritePhyUshort(sc, 0x06, 0x645e);
-                MP_WritePhyUshort(sc, 0x06, 0x07ff);
-                MP_WritePhyUshort(sc, 0x06, 0x0d65);
-                MP_WritePhyUshort(sc, 0x06, 0x5cf8);
-                MP_WritePhyUshort(sc, 0x06, 0x001e);
-                MP_WritePhyUshort(sc, 0x06, 0x46dc);
-                MP_WritePhyUshort(sc, 0x06, 0x19dd);
-                MP_WritePhyUshort(sc, 0x06, 0x19b2);
-                MP_WritePhyUshort(sc, 0x06, 0xe2d4);
-                MP_WritePhyUshort(sc, 0x06, 0x0001);
-                MP_WritePhyUshort(sc, 0x06, 0xbf1c);
-                MP_WritePhyUshort(sc, 0x06, 0x1b02);
-                MP_WritePhyUshort(sc, 0x06, 0x387d);
-                MP_WritePhyUshort(sc, 0x06, 0xae1d);
-                MP_WritePhyUshort(sc, 0x06, 0xbee0);
-                MP_WritePhyUshort(sc, 0x06, 0xc4bf);
-                MP_WritePhyUshort(sc, 0x06, 0x85f6);
-                MP_WritePhyUshort(sc, 0x06, 0xd204);
-                MP_WritePhyUshort(sc, 0x06, 0xd819);
-                MP_WritePhyUshort(sc, 0x06, 0xd919);
-                MP_WritePhyUshort(sc, 0x06, 0x07dc);
-                MP_WritePhyUshort(sc, 0x06, 0x19dd);
-                MP_WritePhyUshort(sc, 0x06, 0x1907);
-                MP_WritePhyUshort(sc, 0x06, 0xb2f4);
-                MP_WritePhyUshort(sc, 0x06, 0xd400);
-                MP_WritePhyUshort(sc, 0x06, 0x00bf);
-                MP_WritePhyUshort(sc, 0x06, 0x1c1b);
-                MP_WritePhyUshort(sc, 0x06, 0x0238);
-                MP_WritePhyUshort(sc, 0x06, 0x7dfe);
-                MP_WritePhyUshort(sc, 0x06, 0xef96);
-                MP_WritePhyUshort(sc, 0x06, 0xfec6);
-                MP_WritePhyUshort(sc, 0x06, 0xfefd);
-                MP_WritePhyUshort(sc, 0x06, 0xfc05);
-                MP_WritePhyUshort(sc, 0x06, 0xf9e2);
-                MP_WritePhyUshort(sc, 0x06, 0xe0ea);
-                MP_WritePhyUshort(sc, 0x06, 0xe3e0);
-                MP_WritePhyUshort(sc, 0x06, 0xeb5a);
-                MP_WritePhyUshort(sc, 0x06, 0x070c);
-                MP_WritePhyUshort(sc, 0x06, 0x031e);
-                MP_WritePhyUshort(sc, 0x06, 0x20e6);
-                MP_WritePhyUshort(sc, 0x06, 0xe0ea);
-                MP_WritePhyUshort(sc, 0x06, 0xe7e0);
-                MP_WritePhyUshort(sc, 0x06, 0xebe0);
-                MP_WritePhyUshort(sc, 0x06, 0xe0fc);
-                MP_WritePhyUshort(sc, 0x06, 0xe1e0);
-                MP_WritePhyUshort(sc, 0x06, 0xfdfd);
-                MP_WritePhyUshort(sc, 0x06, 0x04f8);
-                MP_WritePhyUshort(sc, 0x06, 0xfaef);
-                MP_WritePhyUshort(sc, 0x06, 0x69e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b80);
-                MP_WritePhyUshort(sc, 0x06, 0xad27);
-                MP_WritePhyUshort(sc, 0x06, 0x22bf);
-                MP_WritePhyUshort(sc, 0x06, 0x4616);
-                MP_WritePhyUshort(sc, 0x06, 0x0238);
-                MP_WritePhyUshort(sc, 0x06, 0x50e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b44);
-                MP_WritePhyUshort(sc, 0x06, 0x1f01);
-                MP_WritePhyUshort(sc, 0x06, 0x9e15);
-                MP_WritePhyUshort(sc, 0x06, 0xe58b);
-                MP_WritePhyUshort(sc, 0x06, 0x44ad);
-                MP_WritePhyUshort(sc, 0x06, 0x2907);
-                MP_WritePhyUshort(sc, 0x06, 0xac28);
-                MP_WritePhyUshort(sc, 0x06, 0x04d1);
-                MP_WritePhyUshort(sc, 0x06, 0x01ae);
-                MP_WritePhyUshort(sc, 0x06, 0x02d1);
-                MP_WritePhyUshort(sc, 0x06, 0x00bf);
-                MP_WritePhyUshort(sc, 0x06, 0x85b0);
-                MP_WritePhyUshort(sc, 0x06, 0x0238);
-                MP_WritePhyUshort(sc, 0x06, 0x7def);
-                MP_WritePhyUshort(sc, 0x06, 0x96fe);
-                MP_WritePhyUshort(sc, 0x06, 0xfc04);
-                MP_WritePhyUshort(sc, 0x06, 0xf8e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b85);
-                MP_WritePhyUshort(sc, 0x06, 0xad26);
-                MP_WritePhyUshort(sc, 0x06, 0x30e0);
-                MP_WritePhyUshort(sc, 0x06, 0xe036);
-                MP_WritePhyUshort(sc, 0x06, 0xe1e0);
-                MP_WritePhyUshort(sc, 0x06, 0x37e1);
-                MP_WritePhyUshort(sc, 0x06, 0x8b3f);
-                MP_WritePhyUshort(sc, 0x06, 0x1f10);
-                MP_WritePhyUshort(sc, 0x06, 0x9e23);
-                MP_WritePhyUshort(sc, 0x06, 0xe48b);
-                MP_WritePhyUshort(sc, 0x06, 0x3fac);
-                MP_WritePhyUshort(sc, 0x06, 0x200b);
-                MP_WritePhyUshort(sc, 0x06, 0xac21);
-                MP_WritePhyUshort(sc, 0x06, 0x0dac);
-                MP_WritePhyUshort(sc, 0x06, 0x250f);
-                MP_WritePhyUshort(sc, 0x06, 0xac27);
-                MP_WritePhyUshort(sc, 0x06, 0x11ae);
-                MP_WritePhyUshort(sc, 0x06, 0x1202);
-                MP_WritePhyUshort(sc, 0x06, 0x2c47);
-                MP_WritePhyUshort(sc, 0x06, 0xae0d);
-                MP_WritePhyUshort(sc, 0x06, 0x0285);
-                MP_WritePhyUshort(sc, 0x06, 0x4fae);
-                MP_WritePhyUshort(sc, 0x06, 0x0802);
-                MP_WritePhyUshort(sc, 0x06, 0x2c69);
-                MP_WritePhyUshort(sc, 0x06, 0xae03);
-                MP_WritePhyUshort(sc, 0x06, 0x022c);
-                MP_WritePhyUshort(sc, 0x06, 0x7cfc);
-                MP_WritePhyUshort(sc, 0x06, 0x04f8);
-                MP_WritePhyUshort(sc, 0x06, 0xfaef);
-                MP_WritePhyUshort(sc, 0x06, 0x6902);
-                MP_WritePhyUshort(sc, 0x06, 0x856c);
-                MP_WritePhyUshort(sc, 0x06, 0xe0e0);
-                MP_WritePhyUshort(sc, 0x06, 0x14e1);
-                MP_WritePhyUshort(sc, 0x06, 0xe015);
-                MP_WritePhyUshort(sc, 0x06, 0xad26);
-                MP_WritePhyUshort(sc, 0x06, 0x08d1);
-                MP_WritePhyUshort(sc, 0x06, 0x1ebf);
-                MP_WritePhyUshort(sc, 0x06, 0x2cd9);
-                MP_WritePhyUshort(sc, 0x06, 0x0238);
-                MP_WritePhyUshort(sc, 0x06, 0x7def);
-                MP_WritePhyUshort(sc, 0x06, 0x96fe);
-                MP_WritePhyUshort(sc, 0x06, 0xfc04);
-                MP_WritePhyUshort(sc, 0x06, 0xf8e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b85);
-                MP_WritePhyUshort(sc, 0x06, 0xad27);
-                MP_WritePhyUshort(sc, 0x06, 0x2fd0);
-                MP_WritePhyUshort(sc, 0x06, 0x0b02);
-                MP_WritePhyUshort(sc, 0x06, 0x3682);
-                MP_WritePhyUshort(sc, 0x06, 0x5882);
-                MP_WritePhyUshort(sc, 0x06, 0x7882);
-                MP_WritePhyUshort(sc, 0x06, 0x9f24);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x32e1);
-                MP_WritePhyUshort(sc, 0x06, 0x8b33);
-                MP_WritePhyUshort(sc, 0x06, 0x1f10);
-                MP_WritePhyUshort(sc, 0x06, 0x9e1a);
-                MP_WritePhyUshort(sc, 0x06, 0x10e4);
-                MP_WritePhyUshort(sc, 0x06, 0x8b32);
-                MP_WritePhyUshort(sc, 0x06, 0xe0e0);
-                MP_WritePhyUshort(sc, 0x06, 0x28e1);
-                MP_WritePhyUshort(sc, 0x06, 0xe029);
-                MP_WritePhyUshort(sc, 0x06, 0xf72c);
-                MP_WritePhyUshort(sc, 0x06, 0xe4e0);
-                MP_WritePhyUshort(sc, 0x06, 0x28e5);
-                MP_WritePhyUshort(sc, 0x06, 0xe029);
-                MP_WritePhyUshort(sc, 0x06, 0xf62c);
-                MP_WritePhyUshort(sc, 0x06, 0xe4e0);
-                MP_WritePhyUshort(sc, 0x06, 0x28e5);
-                MP_WritePhyUshort(sc, 0x06, 0xe029);
-                MP_WritePhyUshort(sc, 0x06, 0xfc04);
-                MP_WritePhyUshort(sc, 0x06, 0x00e1);
-                MP_WritePhyUshort(sc, 0x06, 0x4077);
-                MP_WritePhyUshort(sc, 0x06, 0xe140);
-                MP_WritePhyUshort(sc, 0x06, 0x52e0);
-                MP_WritePhyUshort(sc, 0x06, 0xeed9);
-                MP_WritePhyUshort(sc, 0x06, 0xe04c);
-                MP_WritePhyUshort(sc, 0x06, 0xbbe0);
-                MP_WritePhyUshort(sc, 0x06, 0x2a00);
-                MP_WritePhyUshort(sc, 0x05, 0xe142);
-                Data = MP_ReadPhyUshort(sc, 0x06);
-                Data |= BIT_0;
-                MP_WritePhyUshort(sc,0x06, Data);
-                MP_WritePhyUshort(sc, 0x05, 0xe140);
+                MP_WritePhyUshort(sc, 0x06, 0xa725);
+                MP_WritePhyUshort(sc, 0x06, 0xe50a);
+                MP_WritePhyUshort(sc, 0x06, 0x1de5);
+                MP_WritePhyUshort(sc, 0x06, 0x0a2c);
+                MP_WritePhyUshort(sc, 0x06, 0xe50a);
+                MP_WritePhyUshort(sc, 0x06, 0x6de5);
+                MP_WritePhyUshort(sc, 0x06, 0x0a1d);
+                MP_WritePhyUshort(sc, 0x06, 0xe50a);
+                MP_WritePhyUshort(sc, 0x06, 0x1ce5);
+                MP_WritePhyUshort(sc, 0x06, 0x0a2d);
+                MP_WritePhyUshort(sc, 0x06, 0xa755);
+                MP_WritePhyUshort(sc, 0x06, 0x00e2);
+                MP_WritePhyUshort(sc, 0x06, 0x3488);
+                MP_WritePhyUshort(sc, 0x06, 0xe200);
+                MP_WritePhyUshort(sc, 0x06, 0xcce2);
+                MP_WritePhyUshort(sc, 0x06, 0x0055);
+                MP_WritePhyUshort(sc, 0x06, 0xe020);
+                MP_WritePhyUshort(sc, 0x06, 0x55e2);
+                MP_WritePhyUshort(sc, 0x06, 0xd600);
+                MP_WritePhyUshort(sc, 0x06, 0xe24a);
+                PhyRegValue = MP_ReadPhyUshort(sc, 0x01);
+                PhyRegValue |= BIT_0;
+                MP_WritePhyUshort(sc, 0x01, PhyRegValue);
+                PhyRegValue = MP_ReadPhyUshort(sc, 0x00);
+                PhyRegValue |= BIT_0;
+                MP_WritePhyUshort(sc, 0x00, PhyRegValue);
+                MP_WritePhyUshort(sc, 0x1f, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1f, 0x0005);
+                for (i = 0; i < 200; i++) {
+                        DELAY(100);
+                        PhyRegValue = MP_ReadPhyUshort(sc, 0x00);
+                        if (PhyRegValue & BIT_7)
+                                break;
+                }
+                MP_WritePhyUshort(sc, 0x1f, 0x0007);
+                MP_WritePhyUshort(sc, 0x1e, 0x0023);
+                PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
+                PhyRegValue &= ~(BIT_0);
+                if (sc->RequiredSecLanDonglePatch)
+                        PhyRegValue &= ~(BIT_2);
+                MP_WritePhyUshort(sc, 0x17, PhyRegValue);
+                MP_WritePhyUshort(sc, 0x1f, 0x0000);
+        }
+}
+
+static void re_set_phy_mcu_8168evl_1(struct re_softc *sc)
+{
+        u_int16_t PhyRegValue;
+        int i;
+
+        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+        MP_WritePhyUshort(sc, 0x00, 0x1800);
+        PhyRegValue= MP_ReadPhyUshort(sc, 0x15);
+        PhyRegValue &= ~BIT_12;
+        MP_WritePhyUshort(sc, 0x15, PhyRegValue);
+        DELAY(200);
+        DELAY(200);
+        MP_WritePhyUshort(sc, 0x1f, 0x0004);
+        MP_WritePhyUshort(sc, 0x1f, 0x0007);
+        MP_WritePhyUshort(sc, 0x1e, 0x0023);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
+        if ((PhyRegValue & BIT_11) == 0x0000) {
+                PhyRegValue |= BIT_0;
+                MP_WritePhyUshort(sc, 0x17, PhyRegValue);
+                for (i = 0; i < 200; i++) {
+                        DELAY(100);
+                        PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
+                        if (PhyRegValue & BIT_11)
+                                break;
+                }
+        }
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
+        PhyRegValue |= BIT_11;
+        MP_WritePhyUshort(sc, 0x17,PhyRegValue);
+        MP_WritePhyUshort(sc, 0x1f, 0x0004);
+        MP_WritePhyUshort(sc, 0x1f, 0x0007);
+        MP_WritePhyUshort(sc, 0x1E, 0x002C);
+        MP_WritePhyUshort(sc, 0x1B, 0x5000);
+        MP_WritePhyUshort(sc, 0x1E, 0x002d);
+        MP_WritePhyUshort(sc, 0x19, 0x0004);
+        MP_WritePhyUshort(sc, 0x1f, 0x0002);
+        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+        for (i = 0; i < 200; i++) {
+                DELAY(100);
+                PhyRegValue= MP_ReadPhyUshort(sc, 0x1E);
+                if ((PhyRegValue& 0x03FF) == 0x0014)
+                        break;
+        }
+        MP_WritePhyUshort(sc, 0x1f, 0x0005);
+        for (i = 0; i < 200; i++) {
+                DELAY(100);
+                PhyRegValue= MP_ReadPhyUshort(sc, 0x07);
+                if ((PhyRegValue& BIT_5) == 0)
+                        break;
+        }
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x07);
+        if (PhyRegValue & BIT_5) {
+                MP_WritePhyUshort(sc, 0x1f, 0x0004);
+                MP_WritePhyUshort(sc, 0x1f, 0x0007);
+                MP_WritePhyUshort(sc, 0x1e, 0x00a1);
+                MP_WritePhyUshort(sc, 0x17, 0x1000);
+                MP_WritePhyUshort(sc, 0x17, 0x0000);
+                MP_WritePhyUshort(sc, 0x17, 0x2000);
+                MP_WritePhyUshort(sc, 0x1e, 0x002f);
+                MP_WritePhyUshort(sc, 0x18, 0x9bfb);
+                MP_WritePhyUshort(sc, 0x1f, 0x0005);
+                MP_WritePhyUshort(sc, 0x07, 0x0000);
+                MP_WritePhyUshort(sc, 0x1f, 0x0002);
+                MP_WritePhyUshort(sc, 0x1f, 0x0000);
+        }
+        MP_WritePhyUshort(sc, 0x1f, 0x0005);
+        MP_WritePhyUshort(sc, 0x05, 0xfff6);
+        MP_WritePhyUshort(sc, 0x06, 0x0080);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x00);
+        PhyRegValue &= ~BIT_7;
+        MP_WritePhyUshort(sc, 0x00, PhyRegValue);
+        MP_WritePhyUshort(sc, 0x1f, 0x0004);
+        MP_WritePhyUshort(sc, 0x1f, 0x0007);
+        MP_WritePhyUshort(sc, 0x1e, 0x0023);
+        MP_WritePhyUshort(sc, 0x16, 0x0306);
+        MP_WritePhyUshort(sc, 0x16, 0x0307);
+        MP_WritePhyUshort(sc, 0x15, 0x0000);
+        MP_WritePhyUshort(sc, 0x19, 0x407d);
+        MP_WritePhyUshort(sc, 0x15, 0x0001);
+        MP_WritePhyUshort(sc, 0x19, 0x440f);
+        MP_WritePhyUshort(sc, 0x15, 0x0002);
+        MP_WritePhyUshort(sc, 0x19, 0x7c03);
+        MP_WritePhyUshort(sc, 0x15, 0x0003);
+        MP_WritePhyUshort(sc, 0x19, 0x6c03);
+        MP_WritePhyUshort(sc, 0x15, 0x0004);
+        MP_WritePhyUshort(sc, 0x19, 0xc4d5);
+        MP_WritePhyUshort(sc, 0x15, 0x0005);
+        MP_WritePhyUshort(sc, 0x19, 0x00ff);
+        MP_WritePhyUshort(sc, 0x15, 0x0006);
+        MP_WritePhyUshort(sc, 0x19, 0x74f0);
+        MP_WritePhyUshort(sc, 0x15, 0x0007);
+        MP_WritePhyUshort(sc, 0x19, 0x4880);
+        MP_WritePhyUshort(sc, 0x15, 0x0008);
+        MP_WritePhyUshort(sc, 0x19, 0x4c00);
+        MP_WritePhyUshort(sc, 0x15, 0x0009);
+        MP_WritePhyUshort(sc, 0x19, 0x4800);
+        MP_WritePhyUshort(sc, 0x15, 0x000a);
+        MP_WritePhyUshort(sc, 0x19, 0x5000);
+        MP_WritePhyUshort(sc, 0x15, 0x000b);
+        MP_WritePhyUshort(sc, 0x19, 0x4400);
+        MP_WritePhyUshort(sc, 0x15, 0x000c);
+        MP_WritePhyUshort(sc, 0x19, 0x7801);
+        MP_WritePhyUshort(sc, 0x15, 0x000d);
+        MP_WritePhyUshort(sc, 0x19, 0x4000);
+        MP_WritePhyUshort(sc, 0x15, 0x000e);
+        MP_WritePhyUshort(sc, 0x19, 0x7800);
+        MP_WritePhyUshort(sc, 0x15, 0x000f);
+        MP_WritePhyUshort(sc, 0x19, 0x7010);
+        MP_WritePhyUshort(sc, 0x15, 0x0010);
+        MP_WritePhyUshort(sc, 0x19, 0x6804);
+        MP_WritePhyUshort(sc, 0x15, 0x0011);
+        MP_WritePhyUshort(sc, 0x19, 0x64a0);
+        MP_WritePhyUshort(sc, 0x15, 0x0012);
+        MP_WritePhyUshort(sc, 0x19, 0x63da);
+        MP_WritePhyUshort(sc, 0x15, 0x0013);
+        MP_WritePhyUshort(sc, 0x19, 0x63d8);
+        MP_WritePhyUshort(sc, 0x15, 0x0014);
+        MP_WritePhyUshort(sc, 0x19, 0x6f05);
+        MP_WritePhyUshort(sc, 0x15, 0x0015);
+        MP_WritePhyUshort(sc, 0x19, 0x5420);
+        MP_WritePhyUshort(sc, 0x15, 0x0016);
+        MP_WritePhyUshort(sc, 0x19, 0x58ce);
+        MP_WritePhyUshort(sc, 0x15, 0x0017);
+        MP_WritePhyUshort(sc, 0x19, 0x5cf3);
+        MP_WritePhyUshort(sc, 0x15, 0x0018);
+        MP_WritePhyUshort(sc, 0x19, 0xb600);
+        MP_WritePhyUshort(sc, 0x15, 0x0019);
+        MP_WritePhyUshort(sc, 0x19, 0xc659);
+        MP_WritePhyUshort(sc, 0x15, 0x001a);
+        MP_WritePhyUshort(sc, 0x19, 0x0018);
+        MP_WritePhyUshort(sc, 0x15, 0x001b);
+        MP_WritePhyUshort(sc, 0x19, 0xc403);
+        MP_WritePhyUshort(sc, 0x15, 0x001c);
+        MP_WritePhyUshort(sc, 0x19, 0x0016);
+        MP_WritePhyUshort(sc, 0x15, 0x001d);
+        MP_WritePhyUshort(sc, 0x19, 0xaa05);
+        MP_WritePhyUshort(sc, 0x15, 0x001e);
+        MP_WritePhyUshort(sc, 0x19, 0xc503);
+        MP_WritePhyUshort(sc, 0x15, 0x001f);
+        MP_WritePhyUshort(sc, 0x19, 0x0003);
+        MP_WritePhyUshort(sc, 0x15, 0x0020);
+        MP_WritePhyUshort(sc, 0x19, 0x89f8);
+        MP_WritePhyUshort(sc, 0x15, 0x0021);
+        MP_WritePhyUshort(sc, 0x19, 0x32ae);
+        MP_WritePhyUshort(sc, 0x15, 0x0022);
+        MP_WritePhyUshort(sc, 0x19, 0x7c03);
+        MP_WritePhyUshort(sc, 0x15, 0x0023);
+        MP_WritePhyUshort(sc, 0x19, 0x6c03);
+        MP_WritePhyUshort(sc, 0x15, 0x0024);
+        MP_WritePhyUshort(sc, 0x19, 0x7c03);
+        MP_WritePhyUshort(sc, 0x15, 0x0025);
+        MP_WritePhyUshort(sc, 0x19, 0x6801);
+        MP_WritePhyUshort(sc, 0x15, 0x0026);
+        MP_WritePhyUshort(sc, 0x19, 0x66a0);
+        MP_WritePhyUshort(sc, 0x15, 0x0027);
+        MP_WritePhyUshort(sc, 0x19, 0xa300);
+        MP_WritePhyUshort(sc, 0x15, 0x0028);
+        MP_WritePhyUshort(sc, 0x19, 0x64a0);
+        MP_WritePhyUshort(sc, 0x15, 0x0029);
+        MP_WritePhyUshort(sc, 0x19, 0x76f0);
+        MP_WritePhyUshort(sc, 0x15, 0x002a);
+        MP_WritePhyUshort(sc, 0x19, 0x7670);
+        MP_WritePhyUshort(sc, 0x15, 0x002b);
+        MP_WritePhyUshort(sc, 0x19, 0x7630);
+        MP_WritePhyUshort(sc, 0x15, 0x002c);
+        MP_WritePhyUshort(sc, 0x19, 0x31a6);
+        MP_WritePhyUshort(sc, 0x15, 0x002d);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x002e);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x002f);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0030);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0031);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0032);
+        MP_WritePhyUshort(sc, 0x19, 0x4801);
+        MP_WritePhyUshort(sc, 0x15, 0x0033);
+        MP_WritePhyUshort(sc, 0x19, 0x6803);
+        MP_WritePhyUshort(sc, 0x15, 0x0034);
+        MP_WritePhyUshort(sc, 0x19, 0x66a1);
+        MP_WritePhyUshort(sc, 0x15, 0x0035);
+        MP_WritePhyUshort(sc, 0x19, 0x7c03);
+        MP_WritePhyUshort(sc, 0x15, 0x0036);
+        MP_WritePhyUshort(sc, 0x19, 0x6c03);
+        MP_WritePhyUshort(sc, 0x15, 0x0037);
+        MP_WritePhyUshort(sc, 0x19, 0xa300);
+        MP_WritePhyUshort(sc, 0x15, 0x0038);
+        MP_WritePhyUshort(sc, 0x19, 0x64a1);
+        MP_WritePhyUshort(sc, 0x15, 0x0039);
+        MP_WritePhyUshort(sc, 0x19, 0x7c08);
+        MP_WritePhyUshort(sc, 0x15, 0x003a);
+        MP_WritePhyUshort(sc, 0x19, 0x74f8);
+        MP_WritePhyUshort(sc, 0x15, 0x003b);
+        MP_WritePhyUshort(sc, 0x19, 0x63d0);
+        MP_WritePhyUshort(sc, 0x15, 0x003c);
+        MP_WritePhyUshort(sc, 0x19, 0x7ff0);
+        MP_WritePhyUshort(sc, 0x15, 0x003d);
+        MP_WritePhyUshort(sc, 0x19, 0x77f0);
+        MP_WritePhyUshort(sc, 0x15, 0x003e);
+        MP_WritePhyUshort(sc, 0x19, 0x7ff0);
+        MP_WritePhyUshort(sc, 0x15, 0x003f);
+        MP_WritePhyUshort(sc, 0x19, 0x7750);
+        MP_WritePhyUshort(sc, 0x15, 0x0040);
+        MP_WritePhyUshort(sc, 0x19, 0x63d8);
+        MP_WritePhyUshort(sc, 0x15, 0x0041);
+        MP_WritePhyUshort(sc, 0x19, 0x7cf0);
+        MP_WritePhyUshort(sc, 0x15, 0x0042);
+        MP_WritePhyUshort(sc, 0x19, 0x7708);
+        MP_WritePhyUshort(sc, 0x15, 0x0043);
+        MP_WritePhyUshort(sc, 0x19, 0xa654);
+        MP_WritePhyUshort(sc, 0x15, 0x0044);
+        MP_WritePhyUshort(sc, 0x19, 0x304a);
+        MP_WritePhyUshort(sc, 0x15, 0x0045);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0046);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0047);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0048);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0049);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x004a);
+        MP_WritePhyUshort(sc, 0x19, 0x4802);
+        MP_WritePhyUshort(sc, 0x15, 0x004b);
+        MP_WritePhyUshort(sc, 0x19, 0x4003);
+        MP_WritePhyUshort(sc, 0x15, 0x004c);
+        MP_WritePhyUshort(sc, 0x19, 0x4440);
+        MP_WritePhyUshort(sc, 0x15, 0x004d);
+        MP_WritePhyUshort(sc, 0x19, 0x63c8);
+        MP_WritePhyUshort(sc, 0x15, 0x004e);
+        MP_WritePhyUshort(sc, 0x19, 0x6481);
+        MP_WritePhyUshort(sc, 0x15, 0x004f);
+        MP_WritePhyUshort(sc, 0x19, 0x9d00);
+        MP_WritePhyUshort(sc, 0x15, 0x0050);
+        MP_WritePhyUshort(sc, 0x19, 0x63e8);
+        MP_WritePhyUshort(sc, 0x15, 0x0051);
+        MP_WritePhyUshort(sc, 0x19, 0x7d00);
+        MP_WritePhyUshort(sc, 0x15, 0x0052);
+        MP_WritePhyUshort(sc, 0x19, 0x5900);
+        MP_WritePhyUshort(sc, 0x15, 0x0053);
+        MP_WritePhyUshort(sc, 0x19, 0x63f8);
+        MP_WritePhyUshort(sc, 0x15, 0x0054);
+        MP_WritePhyUshort(sc, 0x19, 0x64a1);
+        MP_WritePhyUshort(sc, 0x15, 0x0055);
+        MP_WritePhyUshort(sc, 0x19, 0x3116);
+        MP_WritePhyUshort(sc, 0x15, 0x0056);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0057);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0058);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0059);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x005a);
+        MP_WritePhyUshort(sc, 0x19, 0x7c03);
+        MP_WritePhyUshort(sc, 0x15, 0x005b);
+        MP_WritePhyUshort(sc, 0x19, 0x6c03);
+        MP_WritePhyUshort(sc, 0x15, 0x005c);
+        MP_WritePhyUshort(sc, 0x19, 0x7c08);
+        MP_WritePhyUshort(sc, 0x15, 0x005d);
+        MP_WritePhyUshort(sc, 0x19, 0x6000);
+        MP_WritePhyUshort(sc, 0x15, 0x005e);
+        MP_WritePhyUshort(sc, 0x19, 0x59ce);
+        MP_WritePhyUshort(sc, 0x15, 0x005f);
+        MP_WritePhyUshort(sc, 0x19, 0x4400);
+        MP_WritePhyUshort(sc, 0x15, 0x0060);
+        MP_WritePhyUshort(sc, 0x19, 0x7d00);
+        MP_WritePhyUshort(sc, 0x15, 0x0061);
+        MP_WritePhyUshort(sc, 0x19, 0x72b0);
+        MP_WritePhyUshort(sc, 0x15, 0x0062);
+        MP_WritePhyUshort(sc, 0x19, 0x400e);
+        MP_WritePhyUshort(sc, 0x15, 0x0063);
+        MP_WritePhyUshort(sc, 0x19, 0x4440);
+        MP_WritePhyUshort(sc, 0x15, 0x0064);
+        MP_WritePhyUshort(sc, 0x19, 0x9d00);
+        MP_WritePhyUshort(sc, 0x15, 0x0065);
+        MP_WritePhyUshort(sc, 0x19, 0x7f00);
+        MP_WritePhyUshort(sc, 0x15, 0x0066);
+        MP_WritePhyUshort(sc, 0x19, 0x70b0);
+        MP_WritePhyUshort(sc, 0x15, 0x0067);
+        MP_WritePhyUshort(sc, 0x19, 0x7c08);
+        MP_WritePhyUshort(sc, 0x15, 0x0068);
+        MP_WritePhyUshort(sc, 0x19, 0x6008);
+        MP_WritePhyUshort(sc, 0x15, 0x0069);
+        MP_WritePhyUshort(sc, 0x19, 0x7cf0);
+        MP_WritePhyUshort(sc, 0x15, 0x006a);
+        MP_WritePhyUshort(sc, 0x19, 0x7750);
+        MP_WritePhyUshort(sc, 0x15, 0x006b);
+        MP_WritePhyUshort(sc, 0x19, 0x4007);
+        MP_WritePhyUshort(sc, 0x15, 0x006c);
+        MP_WritePhyUshort(sc, 0x19, 0x4500);
+        MP_WritePhyUshort(sc, 0x15, 0x006d);
+        MP_WritePhyUshort(sc, 0x19, 0x4023);
+        MP_WritePhyUshort(sc, 0x15, 0x006e);
+        MP_WritePhyUshort(sc, 0x19, 0x4580);
+        MP_WritePhyUshort(sc, 0x15, 0x006f);
+        MP_WritePhyUshort(sc, 0x19, 0x9f00);
+        MP_WritePhyUshort(sc, 0x15, 0x0070);
+        MP_WritePhyUshort(sc, 0x19, 0xcd78);
+        MP_WritePhyUshort(sc, 0x15, 0x0071);
+        MP_WritePhyUshort(sc, 0x19, 0x0003);
+        MP_WritePhyUshort(sc, 0x15, 0x0072);
+        MP_WritePhyUshort(sc, 0x19, 0xbe02);
+        MP_WritePhyUshort(sc, 0x15, 0x0073);
+        MP_WritePhyUshort(sc, 0x19, 0x3070);
+        MP_WritePhyUshort(sc, 0x15, 0x0074);
+        MP_WritePhyUshort(sc, 0x19, 0x7cf0);
+        MP_WritePhyUshort(sc, 0x15, 0x0075);
+        MP_WritePhyUshort(sc, 0x19, 0x77f0);
+        MP_WritePhyUshort(sc, 0x15, 0x0076);
+        MP_WritePhyUshort(sc, 0x19, 0x4400);
+        MP_WritePhyUshort(sc, 0x15, 0x0077);
+        MP_WritePhyUshort(sc, 0x19, 0x4007);
+        MP_WritePhyUshort(sc, 0x15, 0x0078);
+        MP_WritePhyUshort(sc, 0x19, 0x4500);
+        MP_WritePhyUshort(sc, 0x15, 0x0079);
+        MP_WritePhyUshort(sc, 0x19, 0x4023);
+        MP_WritePhyUshort(sc, 0x15, 0x007a);
+        MP_WritePhyUshort(sc, 0x19, 0x4580);
+        MP_WritePhyUshort(sc, 0x15, 0x007b);
+        MP_WritePhyUshort(sc, 0x19, 0x9f00);
+        MP_WritePhyUshort(sc, 0x15, 0x007c);
+        MP_WritePhyUshort(sc, 0x19, 0xce80);
+        MP_WritePhyUshort(sc, 0x15, 0x007d);
+        MP_WritePhyUshort(sc, 0x19, 0x0004);
+        MP_WritePhyUshort(sc, 0x15, 0x007e);
+        MP_WritePhyUshort(sc, 0x19, 0xce80);
+        MP_WritePhyUshort(sc, 0x15, 0x007f);
+        MP_WritePhyUshort(sc, 0x19, 0x0002);
+        MP_WritePhyUshort(sc, 0x15, 0x0080);
+        MP_WritePhyUshort(sc, 0x19, 0x307c);
+        MP_WritePhyUshort(sc, 0x15, 0x0081);
+        MP_WritePhyUshort(sc, 0x19, 0x4400);
+        MP_WritePhyUshort(sc, 0x15, 0x0082);
+        MP_WritePhyUshort(sc, 0x19, 0x480f);
+        MP_WritePhyUshort(sc, 0x15, 0x0083);
+        MP_WritePhyUshort(sc, 0x19, 0x6802);
+        MP_WritePhyUshort(sc, 0x15, 0x0084);
+        MP_WritePhyUshort(sc, 0x19, 0x6680);
+        MP_WritePhyUshort(sc, 0x15, 0x0085);
+        MP_WritePhyUshort(sc, 0x19, 0x7c10);
+        MP_WritePhyUshort(sc, 0x15, 0x0086);
+        MP_WritePhyUshort(sc, 0x19, 0x6010);
+        MP_WritePhyUshort(sc, 0x15, 0x0087);
+        MP_WritePhyUshort(sc, 0x19, 0x400a);
+        MP_WritePhyUshort(sc, 0x15, 0x0088);
+        MP_WritePhyUshort(sc, 0x19, 0x4580);
+        MP_WritePhyUshort(sc, 0x15, 0x0089);
+        MP_WritePhyUshort(sc, 0x19, 0x9e00);
+        MP_WritePhyUshort(sc, 0x15, 0x008a);
+        MP_WritePhyUshort(sc, 0x19, 0x7d00);
+        MP_WritePhyUshort(sc, 0x15, 0x008b);
+        MP_WritePhyUshort(sc, 0x19, 0x5800);
+        MP_WritePhyUshort(sc, 0x15, 0x008c);
+        MP_WritePhyUshort(sc, 0x19, 0x63c8);
+        MP_WritePhyUshort(sc, 0x15, 0x008d);
+        MP_WritePhyUshort(sc, 0x19, 0x63d8);
+        MP_WritePhyUshort(sc, 0x15, 0x008e);
+        MP_WritePhyUshort(sc, 0x19, 0x66a0);
+        MP_WritePhyUshort(sc, 0x15, 0x008f);
+        MP_WritePhyUshort(sc, 0x19, 0x8300);
+        MP_WritePhyUshort(sc, 0x15, 0x0090);
+        MP_WritePhyUshort(sc, 0x19, 0x7ff0);
+        MP_WritePhyUshort(sc, 0x15, 0x0091);
+        MP_WritePhyUshort(sc, 0x19, 0x74f0);
+        MP_WritePhyUshort(sc, 0x15, 0x0092);
+        MP_WritePhyUshort(sc, 0x19, 0x3006);
+        MP_WritePhyUshort(sc, 0x15, 0x0093);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0094);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0095);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0096);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0097);
+        MP_WritePhyUshort(sc, 0x19, 0x4803);
+        MP_WritePhyUshort(sc, 0x15, 0x0098);
+        MP_WritePhyUshort(sc, 0x19, 0x7c03);
+        MP_WritePhyUshort(sc, 0x15, 0x0099);
+        MP_WritePhyUshort(sc, 0x19, 0x6c03);
+        MP_WritePhyUshort(sc, 0x15, 0x009a);
+        MP_WritePhyUshort(sc, 0x19, 0xa203);
+        MP_WritePhyUshort(sc, 0x15, 0x009b);
+        MP_WritePhyUshort(sc, 0x19, 0x64b1);
+        MP_WritePhyUshort(sc, 0x15, 0x009c);
+        MP_WritePhyUshort(sc, 0x19, 0x309e);
+        MP_WritePhyUshort(sc, 0x15, 0x009d);
+        MP_WritePhyUshort(sc, 0x19, 0x64b3);
+        MP_WritePhyUshort(sc, 0x15, 0x009e);
+        MP_WritePhyUshort(sc, 0x19, 0x4030);
+        MP_WritePhyUshort(sc, 0x15, 0x009f);
+        MP_WritePhyUshort(sc, 0x19, 0x440e);
+        MP_WritePhyUshort(sc, 0x15, 0x00a0);
+        MP_WritePhyUshort(sc, 0x19, 0x4020);
+        MP_WritePhyUshort(sc, 0x15, 0x00a1);
+        MP_WritePhyUshort(sc, 0x19, 0x4419);
+        MP_WritePhyUshort(sc, 0x15, 0x00a2);
+        MP_WritePhyUshort(sc, 0x19, 0x7801);
+        MP_WritePhyUshort(sc, 0x15, 0x00a3);
+        MP_WritePhyUshort(sc, 0x19, 0xc520);
+        MP_WritePhyUshort(sc, 0x15, 0x00a4);
+        MP_WritePhyUshort(sc, 0x19, 0x000b);
+        MP_WritePhyUshort(sc, 0x15, 0x00a5);
+        MP_WritePhyUshort(sc, 0x19, 0x4020);
+        MP_WritePhyUshort(sc, 0x15, 0x00a6);
+        MP_WritePhyUshort(sc, 0x19, 0x7800);
+        MP_WritePhyUshort(sc, 0x15, 0x00a7);
+        MP_WritePhyUshort(sc, 0x19, 0x58a4);
+        MP_WritePhyUshort(sc, 0x15, 0x00a8);
+        MP_WritePhyUshort(sc, 0x19, 0x63da);
+        MP_WritePhyUshort(sc, 0x15, 0x00a9);
+        MP_WritePhyUshort(sc, 0x19, 0x5cb0);
+        MP_WritePhyUshort(sc, 0x15, 0x00aa);
+        MP_WritePhyUshort(sc, 0x19, 0x7d00);
+        MP_WritePhyUshort(sc, 0x15, 0x00ab);
+        MP_WritePhyUshort(sc, 0x19, 0x72b0);
+        MP_WritePhyUshort(sc, 0x15, 0x00ac);
+        MP_WritePhyUshort(sc, 0x19, 0x7f00);
+        MP_WritePhyUshort(sc, 0x15, 0x00ad);
+        MP_WritePhyUshort(sc, 0x19, 0x70b0);
+        MP_WritePhyUshort(sc, 0x15, 0x00ae);
+        MP_WritePhyUshort(sc, 0x19, 0x30b8);
+        MP_WritePhyUshort(sc, 0x15, 0x00AF);
+        MP_WritePhyUshort(sc, 0x19, 0x4060);
+        MP_WritePhyUshort(sc, 0x15, 0x00B0);
+        MP_WritePhyUshort(sc, 0x19, 0x7800);
+        MP_WritePhyUshort(sc, 0x15, 0x00B1);
+        MP_WritePhyUshort(sc, 0x19, 0x7e00);
+        MP_WritePhyUshort(sc, 0x15, 0x00B2);
+        MP_WritePhyUshort(sc, 0x19, 0x72B0);
+        MP_WritePhyUshort(sc, 0x15, 0x00B3);
+        MP_WritePhyUshort(sc, 0x19, 0x7F00);
+        MP_WritePhyUshort(sc, 0x15, 0x00B4);
+        MP_WritePhyUshort(sc, 0x19, 0x73B0);
+        MP_WritePhyUshort(sc, 0x15, 0x00b5);
+        MP_WritePhyUshort(sc, 0x19, 0x58a0);
+        MP_WritePhyUshort(sc, 0x15, 0x00b6);
+        MP_WritePhyUshort(sc, 0x19, 0x63d2);
+        MP_WritePhyUshort(sc, 0x15, 0x00b7);
+        MP_WritePhyUshort(sc, 0x19, 0x5c00);
+        MP_WritePhyUshort(sc, 0x15, 0x00b8);
+        MP_WritePhyUshort(sc, 0x19, 0x5780);
+        MP_WritePhyUshort(sc, 0x15, 0x00b9);
+        MP_WritePhyUshort(sc, 0x19, 0xb60d);
+        MP_WritePhyUshort(sc, 0x15, 0x00ba);
+        MP_WritePhyUshort(sc, 0x19, 0x9bff);
+        MP_WritePhyUshort(sc, 0x15, 0x00bb);
+        MP_WritePhyUshort(sc, 0x19, 0x7c03);
+        MP_WritePhyUshort(sc, 0x15, 0x00bc);
+        MP_WritePhyUshort(sc, 0x19, 0x6001);
+        MP_WritePhyUshort(sc, 0x15, 0x00bd);
+        MP_WritePhyUshort(sc, 0x19, 0xc020);
+        MP_WritePhyUshort(sc, 0x15, 0x00be);
+        MP_WritePhyUshort(sc, 0x19, 0x002b);
+        MP_WritePhyUshort(sc, 0x15, 0x00bf);
+        MP_WritePhyUshort(sc, 0x19, 0xc137);
+        MP_WritePhyUshort(sc, 0x15, 0x00c0);
+        MP_WritePhyUshort(sc, 0x19, 0x0006);
+        MP_WritePhyUshort(sc, 0x15, 0x00c1);
+        MP_WritePhyUshort(sc, 0x19, 0x9af8);
+        MP_WritePhyUshort(sc, 0x15, 0x00c2);
+        MP_WritePhyUshort(sc, 0x19, 0x30c6);
+        MP_WritePhyUshort(sc, 0x15, 0x00c3);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x00c4);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x00c5);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x00c6);
+        MP_WritePhyUshort(sc, 0x19, 0x7d00);
+        MP_WritePhyUshort(sc, 0x15, 0x00c7);
+        MP_WritePhyUshort(sc, 0x19, 0x70b0);
+        MP_WritePhyUshort(sc, 0x15, 0x00c8);
+        MP_WritePhyUshort(sc, 0x19, 0x4400);
+        MP_WritePhyUshort(sc, 0x15, 0x00c9);
+        MP_WritePhyUshort(sc, 0x19, 0x4804);
+        MP_WritePhyUshort(sc, 0x15, 0x00ca);
+        MP_WritePhyUshort(sc, 0x19, 0x7c80);
+        MP_WritePhyUshort(sc, 0x15, 0x00cb);
+        MP_WritePhyUshort(sc, 0x19, 0x5c80);
+        MP_WritePhyUshort(sc, 0x15, 0x00cc);
+        MP_WritePhyUshort(sc, 0x19, 0x4010);
+        MP_WritePhyUshort(sc, 0x15, 0x00cd);
+        MP_WritePhyUshort(sc, 0x19, 0x4415);
+        MP_WritePhyUshort(sc, 0x15, 0x00ce);
+        MP_WritePhyUshort(sc, 0x19, 0x9b00);
+        MP_WritePhyUshort(sc, 0x15, 0x00cf);
+        MP_WritePhyUshort(sc, 0x19, 0x7f00);
+        MP_WritePhyUshort(sc, 0x15, 0x00d0);
+        MP_WritePhyUshort(sc, 0x19, 0x70b0);
+        MP_WritePhyUshort(sc, 0x15, 0x00d1);
+        MP_WritePhyUshort(sc, 0x19, 0x3177);
+        MP_WritePhyUshort(sc, 0x15, 0x00d2);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x00d3);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x00d4);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x00d5);
+        MP_WritePhyUshort(sc, 0x19, 0x4808);
+        MP_WritePhyUshort(sc, 0x15, 0x00d6);
+        MP_WritePhyUshort(sc, 0x19, 0x4007);
+        MP_WritePhyUshort(sc, 0x15, 0x00d7);
+        MP_WritePhyUshort(sc, 0x19, 0x4420);
+        MP_WritePhyUshort(sc, 0x15, 0x00d8);
+        MP_WritePhyUshort(sc, 0x19, 0x63d8);
+        MP_WritePhyUshort(sc, 0x15, 0x00d9);
+        MP_WritePhyUshort(sc, 0x19, 0xb608);
+        MP_WritePhyUshort(sc, 0x15, 0x00da);
+        MP_WritePhyUshort(sc, 0x19, 0xbcbd);
+        MP_WritePhyUshort(sc, 0x15, 0x00db);
+        MP_WritePhyUshort(sc, 0x19, 0xc60b);
+        MP_WritePhyUshort(sc, 0x15, 0x00dc);
+        MP_WritePhyUshort(sc, 0x19, 0x00fd);
+        MP_WritePhyUshort(sc, 0x15, 0x00dd);
+        MP_WritePhyUshort(sc, 0x19, 0x30e1);
+        MP_WritePhyUshort(sc, 0x15, 0x00de);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x00df);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x00e0);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x00e1);
+        MP_WritePhyUshort(sc, 0x19, 0x4809);
+        MP_WritePhyUshort(sc, 0x15, 0x00e2);
+        MP_WritePhyUshort(sc, 0x19, 0x7e40);
+        MP_WritePhyUshort(sc, 0x15, 0x00e3);
+        MP_WritePhyUshort(sc, 0x19, 0x5a40);
+        MP_WritePhyUshort(sc, 0x15, 0x00e4);
+        MP_WritePhyUshort(sc, 0x19, 0x305a);
+        MP_WritePhyUshort(sc, 0x15, 0x00e5);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x00e6);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x00e7);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x00e8);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x00e9);
+        MP_WritePhyUshort(sc, 0x19, 0x480a);
+        MP_WritePhyUshort(sc, 0x15, 0x00ea);
+        MP_WritePhyUshort(sc, 0x19, 0x5820);
+        MP_WritePhyUshort(sc, 0x15, 0x00eb);
+        MP_WritePhyUshort(sc, 0x19, 0x6c03);
+        MP_WritePhyUshort(sc, 0x15, 0x00ec);
+        MP_WritePhyUshort(sc, 0x19, 0xb60a);
+        MP_WritePhyUshort(sc, 0x15, 0x00ed);
+        MP_WritePhyUshort(sc, 0x19, 0xda07);
+        MP_WritePhyUshort(sc, 0x15, 0x00ee);
+        MP_WritePhyUshort(sc, 0x19, 0x0008);
+        MP_WritePhyUshort(sc, 0x15, 0x00ef);
+        MP_WritePhyUshort(sc, 0x19, 0xc60b);
+        MP_WritePhyUshort(sc, 0x15, 0x00f0);
+        MP_WritePhyUshort(sc, 0x19, 0x00fc);
+        MP_WritePhyUshort(sc, 0x15, 0x00f1);
+        MP_WritePhyUshort(sc, 0x19, 0x30f6);
+        MP_WritePhyUshort(sc, 0x15, 0x00f2);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x00f3);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x00f4);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x00f5);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x00f6);
+        MP_WritePhyUshort(sc, 0x19, 0x4408);
+        MP_WritePhyUshort(sc, 0x15, 0x00f7);
+        MP_WritePhyUshort(sc, 0x19, 0x480b);
+        MP_WritePhyUshort(sc, 0x15, 0x00f8);
+        MP_WritePhyUshort(sc, 0x19, 0x6f03);
+        MP_WritePhyUshort(sc, 0x15, 0x00f9);
+        MP_WritePhyUshort(sc, 0x19, 0x405f);
+        MP_WritePhyUshort(sc, 0x15, 0x00fa);
+        MP_WritePhyUshort(sc, 0x19, 0x4448);
+        MP_WritePhyUshort(sc, 0x15, 0x00fb);
+        MP_WritePhyUshort(sc, 0x19, 0x4020);
+        MP_WritePhyUshort(sc, 0x15, 0x00fc);
+        MP_WritePhyUshort(sc, 0x19, 0x4468);
+        MP_WritePhyUshort(sc, 0x15, 0x00fd);
+        MP_WritePhyUshort(sc, 0x19, 0x9c03);
+        MP_WritePhyUshort(sc, 0x15, 0x00fe);
+        MP_WritePhyUshort(sc, 0x19, 0x6f07);
+        MP_WritePhyUshort(sc, 0x15, 0x00ff);
+        MP_WritePhyUshort(sc, 0x19, 0x58a0);
+        MP_WritePhyUshort(sc, 0x15, 0x0100);
+        MP_WritePhyUshort(sc, 0x19, 0xd6d1);
+        MP_WritePhyUshort(sc, 0x15, 0x0101);
+        MP_WritePhyUshort(sc, 0x19, 0x0004);
+        MP_WritePhyUshort(sc, 0x15, 0x0102);
+        MP_WritePhyUshort(sc, 0x19, 0xc137);
+        MP_WritePhyUshort(sc, 0x15, 0x0103);
+        MP_WritePhyUshort(sc, 0x19, 0x0002);
+        MP_WritePhyUshort(sc, 0x15, 0x0104);
+        MP_WritePhyUshort(sc, 0x19, 0xa0e5);
+        MP_WritePhyUshort(sc, 0x15, 0x0105);
+        MP_WritePhyUshort(sc, 0x19, 0x9df8);
+        MP_WritePhyUshort(sc, 0x15, 0x0106);
+        MP_WritePhyUshort(sc, 0x19, 0x30c6);
+        MP_WritePhyUshort(sc, 0x15, 0x0107);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0108);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0109);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x010a);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x010b);
+        MP_WritePhyUshort(sc, 0x19, 0x4808);
+        MP_WritePhyUshort(sc, 0x15, 0x010c);
+        MP_WritePhyUshort(sc, 0x19, 0xc32d);
+        MP_WritePhyUshort(sc, 0x15, 0x010d);
+        MP_WritePhyUshort(sc, 0x19, 0x0003);
+        MP_WritePhyUshort(sc, 0x15, 0x010e);
+        MP_WritePhyUshort(sc, 0x19, 0xc8b3);
+        MP_WritePhyUshort(sc, 0x15, 0x010f);
+        MP_WritePhyUshort(sc, 0x19, 0x00fc);
+        MP_WritePhyUshort(sc, 0x15, 0x0110);
+        MP_WritePhyUshort(sc, 0x19, 0x4400);
+        MP_WritePhyUshort(sc, 0x15, 0x0111);
+        MP_WritePhyUshort(sc, 0x19, 0x3116);
+        MP_WritePhyUshort(sc, 0x15, 0x0112);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0113);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0114);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0115);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0116);
+        MP_WritePhyUshort(sc, 0x19, 0x4803);
+        MP_WritePhyUshort(sc, 0x15, 0x0117);
+        MP_WritePhyUshort(sc, 0x19, 0x7c03);
+        MP_WritePhyUshort(sc, 0x15, 0x0118);
+        MP_WritePhyUshort(sc, 0x19, 0x6c02);
+        MP_WritePhyUshort(sc, 0x15, 0x0119);
+        MP_WritePhyUshort(sc, 0x19, 0x7c04);
+        MP_WritePhyUshort(sc, 0x15, 0x011a);
+        MP_WritePhyUshort(sc, 0x19, 0x6000);
+        MP_WritePhyUshort(sc, 0x15, 0x011b);
+        MP_WritePhyUshort(sc, 0x19, 0x5cf7);
+        MP_WritePhyUshort(sc, 0x15, 0x011c);
+        MP_WritePhyUshort(sc, 0x19, 0x7c2a);
+        MP_WritePhyUshort(sc, 0x15, 0x011d);
+        MP_WritePhyUshort(sc, 0x19, 0x5800);
+        MP_WritePhyUshort(sc, 0x15, 0x011e);
+        MP_WritePhyUshort(sc, 0x19, 0x5400);
+        MP_WritePhyUshort(sc, 0x15, 0x011f);
+        MP_WritePhyUshort(sc, 0x19, 0x7c08);
+        MP_WritePhyUshort(sc, 0x15, 0x0120);
+        MP_WritePhyUshort(sc, 0x19, 0x74f0);
+        MP_WritePhyUshort(sc, 0x15, 0x0121);
+        MP_WritePhyUshort(sc, 0x19, 0x4019);
+        MP_WritePhyUshort(sc, 0x15, 0x0122);
+        MP_WritePhyUshort(sc, 0x19, 0x440d);
+        MP_WritePhyUshort(sc, 0x15, 0x0123);
+        MP_WritePhyUshort(sc, 0x19, 0xb6c1);
+        MP_WritePhyUshort(sc, 0x15, 0x0124);
+        MP_WritePhyUshort(sc, 0x19, 0xc05b);
+        MP_WritePhyUshort(sc, 0x15, 0x0125);
+        MP_WritePhyUshort(sc, 0x19, 0x00bf);
+        MP_WritePhyUshort(sc, 0x15, 0x0126);
+        MP_WritePhyUshort(sc, 0x19, 0xc025);
+        MP_WritePhyUshort(sc, 0x15, 0x0127);
+        MP_WritePhyUshort(sc, 0x19, 0x00bd);
+        MP_WritePhyUshort(sc, 0x15, 0x0128);
+        MP_WritePhyUshort(sc, 0x19, 0xc603);
+        MP_WritePhyUshort(sc, 0x15, 0x0129);
+        MP_WritePhyUshort(sc, 0x19, 0x00bb);
+        MP_WritePhyUshort(sc, 0x15, 0x012a);
+        MP_WritePhyUshort(sc, 0x19, 0x8805);
+        MP_WritePhyUshort(sc, 0x15, 0x012b);
+        MP_WritePhyUshort(sc, 0x19, 0x7801);
+        MP_WritePhyUshort(sc, 0x15, 0x012c);
+        MP_WritePhyUshort(sc, 0x19, 0x4001);
+        MP_WritePhyUshort(sc, 0x15, 0x012d);
+        MP_WritePhyUshort(sc, 0x19, 0x7800);
+        MP_WritePhyUshort(sc, 0x15, 0x012e);
+        MP_WritePhyUshort(sc, 0x19, 0xa3dd);
+        MP_WritePhyUshort(sc, 0x15, 0x012f);
+        MP_WritePhyUshort(sc, 0x19, 0x7c03);
+        MP_WritePhyUshort(sc, 0x15, 0x0130);
+        MP_WritePhyUshort(sc, 0x19, 0x6c03);
+        MP_WritePhyUshort(sc, 0x15, 0x0131);
+        MP_WritePhyUshort(sc, 0x19, 0x8407);
+        MP_WritePhyUshort(sc, 0x15, 0x0132);
+        MP_WritePhyUshort(sc, 0x19, 0x7c03);
+        MP_WritePhyUshort(sc, 0x15, 0x0133);
+        MP_WritePhyUshort(sc, 0x19, 0x6c02);
+        MP_WritePhyUshort(sc, 0x15, 0x0134);
+        MP_WritePhyUshort(sc, 0x19, 0xd9b8);
+        MP_WritePhyUshort(sc, 0x15, 0x0135);
+        MP_WritePhyUshort(sc, 0x19, 0x0003);
+        MP_WritePhyUshort(sc, 0x15, 0x0136);
+        MP_WritePhyUshort(sc, 0x19, 0xc240);
+        MP_WritePhyUshort(sc, 0x15, 0x0137);
+        MP_WritePhyUshort(sc, 0x19, 0x0015);
+        MP_WritePhyUshort(sc, 0x15, 0x0138);
+        MP_WritePhyUshort(sc, 0x19, 0x7c03);
+        MP_WritePhyUshort(sc, 0x15, 0x0139);
+        MP_WritePhyUshort(sc, 0x19, 0x6c02);
+        MP_WritePhyUshort(sc, 0x15, 0x013a);
+        MP_WritePhyUshort(sc, 0x19, 0x9ae9);
+        MP_WritePhyUshort(sc, 0x15, 0x013b);
+        MP_WritePhyUshort(sc, 0x19, 0x3140);
+        MP_WritePhyUshort(sc, 0x15, 0x013c);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x013d);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x013e);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x013f);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0140);
+        MP_WritePhyUshort(sc, 0x19, 0x4807);
+        MP_WritePhyUshort(sc, 0x15, 0x0141);
+        MP_WritePhyUshort(sc, 0x19, 0x4004);
+        MP_WritePhyUshort(sc, 0x15, 0x0142);
+        MP_WritePhyUshort(sc, 0x19, 0x4410);
+        MP_WritePhyUshort(sc, 0x15, 0x0143);
+        MP_WritePhyUshort(sc, 0x19, 0x7c0c);
+        MP_WritePhyUshort(sc, 0x15, 0x0144);
+        MP_WritePhyUshort(sc, 0x19, 0x600c);
+        MP_WritePhyUshort(sc, 0x15, 0x0145);
+        MP_WritePhyUshort(sc, 0x19, 0x9b00);
+        MP_WritePhyUshort(sc, 0x15, 0x0146);
+        MP_WritePhyUshort(sc, 0x19, 0xa68f);
+        MP_WritePhyUshort(sc, 0x15, 0x0147);
+        MP_WritePhyUshort(sc, 0x19, 0x3116);
+        MP_WritePhyUshort(sc, 0x15, 0x0148);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0149);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x014a);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x014b);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x014c);
+        MP_WritePhyUshort(sc, 0x19, 0x4804);
+        MP_WritePhyUshort(sc, 0x15, 0x014d);
+        MP_WritePhyUshort(sc, 0x19, 0x54c0);
+        MP_WritePhyUshort(sc, 0x15, 0x014e);
+        MP_WritePhyUshort(sc, 0x19, 0xb703);
+        MP_WritePhyUshort(sc, 0x15, 0x014f);
+        MP_WritePhyUshort(sc, 0x19, 0x5cff);
+        MP_WritePhyUshort(sc, 0x15, 0x0150);
+        MP_WritePhyUshort(sc, 0x19, 0x315f);
+        MP_WritePhyUshort(sc, 0x15, 0x0151);
+        MP_WritePhyUshort(sc, 0x19, 0x7c08);
+        MP_WritePhyUshort(sc, 0x15, 0x0152);
+        MP_WritePhyUshort(sc, 0x19, 0x74f8);
+        MP_WritePhyUshort(sc, 0x15, 0x0153);
+        MP_WritePhyUshort(sc, 0x19, 0x6421);
+        MP_WritePhyUshort(sc, 0x15, 0x0154);
+        MP_WritePhyUshort(sc, 0x19, 0x7c08);
+        MP_WritePhyUshort(sc, 0x15, 0x0155);
+        MP_WritePhyUshort(sc, 0x19, 0x6000);
+        MP_WritePhyUshort(sc, 0x15, 0x0156);
+        MP_WritePhyUshort(sc, 0x19, 0x4003);
+        MP_WritePhyUshort(sc, 0x15, 0x0157);
+        MP_WritePhyUshort(sc, 0x19, 0x4418);
+        MP_WritePhyUshort(sc, 0x15, 0x0158);
+        MP_WritePhyUshort(sc, 0x19, 0x9b00);
+        MP_WritePhyUshort(sc, 0x15, 0x0159);
+        MP_WritePhyUshort(sc, 0x19, 0x6461);
+        MP_WritePhyUshort(sc, 0x15, 0x015a);
+        MP_WritePhyUshort(sc, 0x19, 0x64e1);
+        MP_WritePhyUshort(sc, 0x15, 0x015b);
+        MP_WritePhyUshort(sc, 0x19, 0x7c20);
+        MP_WritePhyUshort(sc, 0x15, 0x015c);
+        MP_WritePhyUshort(sc, 0x19, 0x5820);
+        MP_WritePhyUshort(sc, 0x15, 0x015d);
+        MP_WritePhyUshort(sc, 0x19, 0x5ccf);
+        MP_WritePhyUshort(sc, 0x15, 0x015e);
+        MP_WritePhyUshort(sc, 0x19, 0x7050);
+        MP_WritePhyUshort(sc, 0x15, 0x015f);
+        MP_WritePhyUshort(sc, 0x19, 0xd9b8);
+        MP_WritePhyUshort(sc, 0x15, 0x0160);
+        MP_WritePhyUshort(sc, 0x19, 0x0008);
+        MP_WritePhyUshort(sc, 0x15, 0x0161);
+        MP_WritePhyUshort(sc, 0x19, 0xdab1);
+        MP_WritePhyUshort(sc, 0x15, 0x0162);
+        MP_WritePhyUshort(sc, 0x19, 0x0015);
+        MP_WritePhyUshort(sc, 0x15, 0x0163);
+        MP_WritePhyUshort(sc, 0x19, 0xc244);
+        MP_WritePhyUshort(sc, 0x15, 0x0164);
+        MP_WritePhyUshort(sc, 0x19, 0x0013);
+        MP_WritePhyUshort(sc, 0x15, 0x0165);
+        MP_WritePhyUshort(sc, 0x19, 0xc021);
+        MP_WritePhyUshort(sc, 0x15, 0x0166);
+        MP_WritePhyUshort(sc, 0x19, 0x00f9);
+        MP_WritePhyUshort(sc, 0x15, 0x0167);
+        MP_WritePhyUshort(sc, 0x19, 0x3177);
+        MP_WritePhyUshort(sc, 0x15, 0x0168);
+        MP_WritePhyUshort(sc, 0x19, 0x5cf7);
+        MP_WritePhyUshort(sc, 0x15, 0x0169);
+        MP_WritePhyUshort(sc, 0x19, 0x4010);
+        MP_WritePhyUshort(sc, 0x15, 0x016a);
+        MP_WritePhyUshort(sc, 0x19, 0x4428);
+        MP_WritePhyUshort(sc, 0x15, 0x016b);
+        MP_WritePhyUshort(sc, 0x19, 0x9c00);
+        MP_WritePhyUshort(sc, 0x15, 0x016c);
+        MP_WritePhyUshort(sc, 0x19, 0x7c08);
+        MP_WritePhyUshort(sc, 0x15, 0x016d);
+        MP_WritePhyUshort(sc, 0x19, 0x6008);
+        MP_WritePhyUshort(sc, 0x15, 0x016e);
+        MP_WritePhyUshort(sc, 0x19, 0x7c08);
+        MP_WritePhyUshort(sc, 0x15, 0x016f);
+        MP_WritePhyUshort(sc, 0x19, 0x74f0);
+        MP_WritePhyUshort(sc, 0x15, 0x0170);
+        MP_WritePhyUshort(sc, 0x19, 0x6461);
+        MP_WritePhyUshort(sc, 0x15, 0x0171);
+        MP_WritePhyUshort(sc, 0x19, 0x6421);
+        MP_WritePhyUshort(sc, 0x15, 0x0172);
+        MP_WritePhyUshort(sc, 0x19, 0x64a1);
+        MP_WritePhyUshort(sc, 0x15, 0x0173);
+        MP_WritePhyUshort(sc, 0x19, 0x3116);
+        MP_WritePhyUshort(sc, 0x15, 0x0174);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0175);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0176);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0177);
+        MP_WritePhyUshort(sc, 0x19, 0x4805);
+        MP_WritePhyUshort(sc, 0x15, 0x0178);
+        MP_WritePhyUshort(sc, 0x19, 0xa103);
+        MP_WritePhyUshort(sc, 0x15, 0x0179);
+        MP_WritePhyUshort(sc, 0x19, 0x7c02);
+        MP_WritePhyUshort(sc, 0x15, 0x017a);
+        MP_WritePhyUshort(sc, 0x19, 0x6002);
+        MP_WritePhyUshort(sc, 0x15, 0x017b);
+        MP_WritePhyUshort(sc, 0x19, 0x7e00);
+        MP_WritePhyUshort(sc, 0x15, 0x017c);
+        MP_WritePhyUshort(sc, 0x19, 0x5400);
+        MP_WritePhyUshort(sc, 0x15, 0x017d);
+        MP_WritePhyUshort(sc, 0x19, 0x7c6b);
+        MP_WritePhyUshort(sc, 0x15, 0x017e);
+        MP_WritePhyUshort(sc, 0x19, 0x5c63);
+        MP_WritePhyUshort(sc, 0x15, 0x017f);
+        MP_WritePhyUshort(sc, 0x19, 0x407d);
+        MP_WritePhyUshort(sc, 0x15, 0x0180);
+        MP_WritePhyUshort(sc, 0x19, 0xa602);
+        MP_WritePhyUshort(sc, 0x15, 0x0181);
+        MP_WritePhyUshort(sc, 0x19, 0x4001);
+        MP_WritePhyUshort(sc, 0x15, 0x0182);
+        MP_WritePhyUshort(sc, 0x19, 0x4420);
+        MP_WritePhyUshort(sc, 0x15, 0x0183);
+        MP_WritePhyUshort(sc, 0x19, 0x4020);
+        MP_WritePhyUshort(sc, 0x15, 0x0184);
+        MP_WritePhyUshort(sc, 0x19, 0x44a1);
+        MP_WritePhyUshort(sc, 0x15, 0x0185);
+        MP_WritePhyUshort(sc, 0x19, 0xd6e0);
+        MP_WritePhyUshort(sc, 0x15, 0x0186);
+        MP_WritePhyUshort(sc, 0x19, 0x0009);
+        MP_WritePhyUshort(sc, 0x15, 0x0187);
+        MP_WritePhyUshort(sc, 0x19, 0x9efe);
+        MP_WritePhyUshort(sc, 0x15, 0x0188);
+        MP_WritePhyUshort(sc, 0x19, 0x7c02);
+        MP_WritePhyUshort(sc, 0x15, 0x0189);
+        MP_WritePhyUshort(sc, 0x19, 0x6000);
+        MP_WritePhyUshort(sc, 0x15, 0x018a);
+        MP_WritePhyUshort(sc, 0x19, 0x9c00);
+        MP_WritePhyUshort(sc, 0x15, 0x018b);
+        MP_WritePhyUshort(sc, 0x19, 0x318f);
+        MP_WritePhyUshort(sc, 0x15, 0x018c);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x018d);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x018e);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x018f);
+        MP_WritePhyUshort(sc, 0x19, 0x4806);
+        MP_WritePhyUshort(sc, 0x15, 0x0190);
+        MP_WritePhyUshort(sc, 0x19, 0x7c10);
+        MP_WritePhyUshort(sc, 0x15, 0x0191);
+        MP_WritePhyUshort(sc, 0x19, 0x5c10);
+        MP_WritePhyUshort(sc, 0x15, 0x0192);
+        MP_WritePhyUshort(sc, 0x19, 0x40fa);
+        MP_WritePhyUshort(sc, 0x15, 0x0193);
+        MP_WritePhyUshort(sc, 0x19, 0xa602);
+        MP_WritePhyUshort(sc, 0x15, 0x0194);
+        MP_WritePhyUshort(sc, 0x19, 0x4010);
+        MP_WritePhyUshort(sc, 0x15, 0x0195);
+        MP_WritePhyUshort(sc, 0x19, 0x4440);
+        MP_WritePhyUshort(sc, 0x15, 0x0196);
+        MP_WritePhyUshort(sc, 0x19, 0x9d00);
+        MP_WritePhyUshort(sc, 0x15, 0x0197);
+        MP_WritePhyUshort(sc, 0x19, 0x7c80);
+        MP_WritePhyUshort(sc, 0x15, 0x0198);
+        MP_WritePhyUshort(sc, 0x19, 0x6400);
+        MP_WritePhyUshort(sc, 0x15, 0x0199);
+        MP_WritePhyUshort(sc, 0x19, 0x4003);
+        MP_WritePhyUshort(sc, 0x15, 0x019a);
+        MP_WritePhyUshort(sc, 0x19, 0x4540);
+        MP_WritePhyUshort(sc, 0x15, 0x019b);
+        MP_WritePhyUshort(sc, 0x19, 0x7c08);
+        MP_WritePhyUshort(sc, 0x15, 0x019c);
+        MP_WritePhyUshort(sc, 0x19, 0x6008);
+        MP_WritePhyUshort(sc, 0x15, 0x019d);
+        MP_WritePhyUshort(sc, 0x19, 0x9f00);
+        MP_WritePhyUshort(sc, 0x15, 0x019e);
+        MP_WritePhyUshort(sc, 0x19, 0x7c40);
+        MP_WritePhyUshort(sc, 0x15, 0x019f);
+        MP_WritePhyUshort(sc, 0x19, 0x6400);
+        MP_WritePhyUshort(sc, 0x15, 0x01a0);
+        MP_WritePhyUshort(sc, 0x19, 0x7c80);
+        MP_WritePhyUshort(sc, 0x15, 0x01a1);
+        MP_WritePhyUshort(sc, 0x19, 0x6480);
+        MP_WritePhyUshort(sc, 0x15, 0x01a2);
+        MP_WritePhyUshort(sc, 0x19, 0x3140);
+        MP_WritePhyUshort(sc, 0x15, 0x01a3);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x01a4);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x01a5);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x01a6);
+        MP_WritePhyUshort(sc, 0x19, 0x4400);
+        MP_WritePhyUshort(sc, 0x15, 0x01a7);
+        MP_WritePhyUshort(sc, 0x19, 0x7c0b);
+        MP_WritePhyUshort(sc, 0x15, 0x01a8);
+        MP_WritePhyUshort(sc, 0x19, 0x6c01);
+        MP_WritePhyUshort(sc, 0x15, 0x01a9);
+        MP_WritePhyUshort(sc, 0x19, 0x64a8);
+        MP_WritePhyUshort(sc, 0x15, 0x01aa);
+        MP_WritePhyUshort(sc, 0x19, 0x6800);
+        MP_WritePhyUshort(sc, 0x15, 0x01ab);
+        MP_WritePhyUshort(sc, 0x19, 0x5cf0);
+        MP_WritePhyUshort(sc, 0x15, 0x01ac);
+        MP_WritePhyUshort(sc, 0x19, 0x588f);
+        MP_WritePhyUshort(sc, 0x15, 0x01ad);
+        MP_WritePhyUshort(sc, 0x19, 0xb628);
+        MP_WritePhyUshort(sc, 0x15, 0x01ae);
+        MP_WritePhyUshort(sc, 0x19, 0xc053);
+        MP_WritePhyUshort(sc, 0x15, 0x01af);
+        MP_WritePhyUshort(sc, 0x19, 0x0026);
+        MP_WritePhyUshort(sc, 0x15, 0x01b0);
+        MP_WritePhyUshort(sc, 0x19, 0xc02d);
+        MP_WritePhyUshort(sc, 0x15, 0x01b1);
+        MP_WritePhyUshort(sc, 0x19, 0x0024);
+        MP_WritePhyUshort(sc, 0x15, 0x01b2);
+        MP_WritePhyUshort(sc, 0x19, 0xc603);
+        MP_WritePhyUshort(sc, 0x15, 0x01b3);
+        MP_WritePhyUshort(sc, 0x19, 0x0022);
+        MP_WritePhyUshort(sc, 0x15, 0x01b4);
+        MP_WritePhyUshort(sc, 0x19, 0x8cf9);
+        MP_WritePhyUshort(sc, 0x15, 0x01b5);
+        MP_WritePhyUshort(sc, 0x19, 0x31ba);
+        MP_WritePhyUshort(sc, 0x15, 0x01b6);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x01b7);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x01b8);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x01b9);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x01ba);
+        MP_WritePhyUshort(sc, 0x19, 0x4400);
+        MP_WritePhyUshort(sc, 0x15, 0x01bb);
+        MP_WritePhyUshort(sc, 0x19, 0x5420);
+        MP_WritePhyUshort(sc, 0x15, 0x01bc);
+        MP_WritePhyUshort(sc, 0x19, 0x4811);
+        MP_WritePhyUshort(sc, 0x15, 0x01bd);
+        MP_WritePhyUshort(sc, 0x19, 0x5000);
+        MP_WritePhyUshort(sc, 0x15, 0x01be);
+        MP_WritePhyUshort(sc, 0x19, 0x4801);
+        MP_WritePhyUshort(sc, 0x15, 0x01bf);
+        MP_WritePhyUshort(sc, 0x19, 0x6800);
+        MP_WritePhyUshort(sc, 0x15, 0x01c0);
+        MP_WritePhyUshort(sc, 0x19, 0x31f5);
+        MP_WritePhyUshort(sc, 0x15, 0x01c1);
+        MP_WritePhyUshort(sc, 0x19, 0xb614);
+        MP_WritePhyUshort(sc, 0x15, 0x01c2);
+        MP_WritePhyUshort(sc, 0x19, 0x8ce4);
+        MP_WritePhyUshort(sc, 0x15, 0x01c3);
+        MP_WritePhyUshort(sc, 0x19, 0xb30c);
+        MP_WritePhyUshort(sc, 0x15, 0x01c4);
+        MP_WritePhyUshort(sc, 0x19, 0x7c03);
+        MP_WritePhyUshort(sc, 0x15, 0x01c5);
+        MP_WritePhyUshort(sc, 0x19, 0x6c02);
+        MP_WritePhyUshort(sc, 0x15, 0x01c6);
+        MP_WritePhyUshort(sc, 0x19, 0x8206);
+        MP_WritePhyUshort(sc, 0x15, 0x01c7);
+        MP_WritePhyUshort(sc, 0x19, 0x7c03);
+        MP_WritePhyUshort(sc, 0x15, 0x01c8);
+        MP_WritePhyUshort(sc, 0x19, 0x6c00);
+        MP_WritePhyUshort(sc, 0x15, 0x01c9);
+        MP_WritePhyUshort(sc, 0x19, 0x7c04);
+        MP_WritePhyUshort(sc, 0x15, 0x01ca);
+        MP_WritePhyUshort(sc, 0x19, 0x7404);
+        MP_WritePhyUshort(sc, 0x15, 0x01cb);
+        MP_WritePhyUshort(sc, 0x19, 0x31c0);
+        MP_WritePhyUshort(sc, 0x15, 0x01cc);
+        MP_WritePhyUshort(sc, 0x19, 0x7c04);
+        MP_WritePhyUshort(sc, 0x15, 0x01cd);
+        MP_WritePhyUshort(sc, 0x19, 0x7400);
+        MP_WritePhyUshort(sc, 0x15, 0x01ce);
+        MP_WritePhyUshort(sc, 0x19, 0x31c0);
+        MP_WritePhyUshort(sc, 0x15, 0x01cf);
+        MP_WritePhyUshort(sc, 0x19, 0x8df1);
+        MP_WritePhyUshort(sc, 0x15, 0x01d0);
+        MP_WritePhyUshort(sc, 0x19, 0x3248);
+        MP_WritePhyUshort(sc, 0x15, 0x01d1);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x01d2);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x01d3);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x01d4);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x01d5);
+        MP_WritePhyUshort(sc, 0x19, 0x4400);
+        MP_WritePhyUshort(sc, 0x15, 0x01d6);
+        MP_WritePhyUshort(sc, 0x19, 0x7c03);
+        MP_WritePhyUshort(sc, 0x15, 0x01d7);
+        MP_WritePhyUshort(sc, 0x19, 0x6c03);
+        MP_WritePhyUshort(sc, 0x15, 0x01d8);
+        MP_WritePhyUshort(sc, 0x19, 0x7670);
+        MP_WritePhyUshort(sc, 0x15, 0x01d9);
+        MP_WritePhyUshort(sc, 0x19, 0x4023);
+        MP_WritePhyUshort(sc, 0x15, 0x01da);
+        MP_WritePhyUshort(sc, 0x19, 0x4500);
+        MP_WritePhyUshort(sc, 0x15, 0x01db);
+        MP_WritePhyUshort(sc, 0x19, 0x4069);
+        MP_WritePhyUshort(sc, 0x15, 0x01dc);
+        MP_WritePhyUshort(sc, 0x19, 0x4580);
+        MP_WritePhyUshort(sc, 0x15, 0x01dd);
+        MP_WritePhyUshort(sc, 0x19, 0x9f00);
+        MP_WritePhyUshort(sc, 0x15, 0x01de);
+        MP_WritePhyUshort(sc, 0x19, 0xcff5);
+        MP_WritePhyUshort(sc, 0x15, 0x01df);
+        MP_WritePhyUshort(sc, 0x19, 0x00ff);
+        MP_WritePhyUshort(sc, 0x15, 0x01e0);
+        MP_WritePhyUshort(sc, 0x19, 0x76f0);
+        MP_WritePhyUshort(sc, 0x15, 0x01e1);
+        MP_WritePhyUshort(sc, 0x19, 0x4400);
+        MP_WritePhyUshort(sc, 0x15, 0x01e2);
+        MP_WritePhyUshort(sc, 0x19, 0x4023);
+        MP_WritePhyUshort(sc, 0x15, 0x01e3);
+        MP_WritePhyUshort(sc, 0x19, 0x4500);
+        MP_WritePhyUshort(sc, 0x15, 0x01e4);
+        MP_WritePhyUshort(sc, 0x19, 0x4069);
+        MP_WritePhyUshort(sc, 0x15, 0x01e5);
+        MP_WritePhyUshort(sc, 0x19, 0x4580);
+        MP_WritePhyUshort(sc, 0x15, 0x01e6);
+        MP_WritePhyUshort(sc, 0x19, 0x9f00);
+        MP_WritePhyUshort(sc, 0x15, 0x01e7);
+        MP_WritePhyUshort(sc, 0x19, 0xd0f5);
+        MP_WritePhyUshort(sc, 0x15, 0x01e8);
+        MP_WritePhyUshort(sc, 0x19, 0x00ff);
+        MP_WritePhyUshort(sc, 0x15, 0x01e9);
+        MP_WritePhyUshort(sc, 0x19, 0x4400);
+        MP_WritePhyUshort(sc, 0x15, 0x01ea);
+        MP_WritePhyUshort(sc, 0x19, 0x7c03);
+        MP_WritePhyUshort(sc, 0x15, 0x01eb);
+        MP_WritePhyUshort(sc, 0x19, 0x6800);
+        MP_WritePhyUshort(sc, 0x15, 0x01ec);
+        MP_WritePhyUshort(sc, 0x19, 0x66a0);
+        MP_WritePhyUshort(sc, 0x15, 0x01ed);
+        MP_WritePhyUshort(sc, 0x19, 0x8300);
+        MP_WritePhyUshort(sc, 0x15, 0x01ee);
+        MP_WritePhyUshort(sc, 0x19, 0x74f0);
+        MP_WritePhyUshort(sc, 0x15, 0x01ef);
+        MP_WritePhyUshort(sc, 0x19, 0x3006);
+        MP_WritePhyUshort(sc, 0x15, 0x01f0);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x01f1);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x01f2);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x01f3);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x01f4);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x01f5);
+        MP_WritePhyUshort(sc, 0x19, 0x7c03);
+        MP_WritePhyUshort(sc, 0x15, 0x01f6);
+        MP_WritePhyUshort(sc, 0x19, 0x6c02);
+        MP_WritePhyUshort(sc, 0x15, 0x01f7);
+        MP_WritePhyUshort(sc, 0x19, 0x409d);
+        MP_WritePhyUshort(sc, 0x15, 0x01f8);
+        MP_WritePhyUshort(sc, 0x19, 0x7c87);
+        MP_WritePhyUshort(sc, 0x15, 0x01f9);
+        MP_WritePhyUshort(sc, 0x19, 0xae14);
+        MP_WritePhyUshort(sc, 0x15, 0x01fa);
+        MP_WritePhyUshort(sc, 0x19, 0x4400);
+        MP_WritePhyUshort(sc, 0x15, 0x01fb);
+        MP_WritePhyUshort(sc, 0x19, 0x7c40);
+        MP_WritePhyUshort(sc, 0x15, 0x01fc);
+        MP_WritePhyUshort(sc, 0x19, 0x6800);
+        MP_WritePhyUshort(sc, 0x15, 0x01fd);
+        MP_WritePhyUshort(sc, 0x19, 0x7801);
+        MP_WritePhyUshort(sc, 0x15, 0x01fe);
+        MP_WritePhyUshort(sc, 0x19, 0x980e);
+        MP_WritePhyUshort(sc, 0x15, 0x01ff);
+        MP_WritePhyUshort(sc, 0x19, 0x930c);
+        MP_WritePhyUshort(sc, 0x15, 0x0200);
+        MP_WritePhyUshort(sc, 0x19, 0x9206);
+        MP_WritePhyUshort(sc, 0x15, 0x0201);
+        MP_WritePhyUshort(sc, 0x19, 0x4002);
+        MP_WritePhyUshort(sc, 0x15, 0x0202);
+        MP_WritePhyUshort(sc, 0x19, 0x7800);
+        MP_WritePhyUshort(sc, 0x15, 0x0203);
+        MP_WritePhyUshort(sc, 0x19, 0x588f);
+        MP_WritePhyUshort(sc, 0x15, 0x0204);
+        MP_WritePhyUshort(sc, 0x19, 0x5520);
+        MP_WritePhyUshort(sc, 0x15, 0x0205);
+        MP_WritePhyUshort(sc, 0x19, 0x320c);
+        MP_WritePhyUshort(sc, 0x15, 0x0206);
+        MP_WritePhyUshort(sc, 0x19, 0x4000);
+        MP_WritePhyUshort(sc, 0x15, 0x0207);
+        MP_WritePhyUshort(sc, 0x19, 0x7800);
+        MP_WritePhyUshort(sc, 0x15, 0x0208);
+        MP_WritePhyUshort(sc, 0x19, 0x588d);
+        MP_WritePhyUshort(sc, 0x15, 0x0209);
+        MP_WritePhyUshort(sc, 0x19, 0x5500);
+        MP_WritePhyUshort(sc, 0x15, 0x020a);
+        MP_WritePhyUshort(sc, 0x19, 0x320c);
+        MP_WritePhyUshort(sc, 0x15, 0x020b);
+        MP_WritePhyUshort(sc, 0x19, 0x4002);
+        MP_WritePhyUshort(sc, 0x15, 0x020c);
+        MP_WritePhyUshort(sc, 0x19, 0x3220);
+        MP_WritePhyUshort(sc, 0x15, 0x020d);
+        MP_WritePhyUshort(sc, 0x19, 0x4480);
+        MP_WritePhyUshort(sc, 0x15, 0x020e);
+        MP_WritePhyUshort(sc, 0x19, 0x9e03);
+        MP_WritePhyUshort(sc, 0x15, 0x020f);
+        MP_WritePhyUshort(sc, 0x19, 0x7c40);
+        MP_WritePhyUshort(sc, 0x15, 0x0210);
+        MP_WritePhyUshort(sc, 0x19, 0x6840);
+        MP_WritePhyUshort(sc, 0x15, 0x0211);
+        MP_WritePhyUshort(sc, 0x19, 0x7801);
+        MP_WritePhyUshort(sc, 0x15, 0x0212);
+        MP_WritePhyUshort(sc, 0x19, 0x980e);
+        MP_WritePhyUshort(sc, 0x15, 0x0213);
+        MP_WritePhyUshort(sc, 0x19, 0x930c);
+        MP_WritePhyUshort(sc, 0x15, 0x0214);
+        MP_WritePhyUshort(sc, 0x19, 0x9206);
+        MP_WritePhyUshort(sc, 0x15, 0x0215);
+        MP_WritePhyUshort(sc, 0x19, 0x4000);
+        MP_WritePhyUshort(sc, 0x15, 0x0216);
+        MP_WritePhyUshort(sc, 0x19, 0x7800);
+        MP_WritePhyUshort(sc, 0x15, 0x0217);
+        MP_WritePhyUshort(sc, 0x19, 0x588f);
+        MP_WritePhyUshort(sc, 0x15, 0x0218);
+        MP_WritePhyUshort(sc, 0x19, 0x5520);
+        MP_WritePhyUshort(sc, 0x15, 0x0219);
+        MP_WritePhyUshort(sc, 0x19, 0x3220);
+        MP_WritePhyUshort(sc, 0x15, 0x021a);
+        MP_WritePhyUshort(sc, 0x19, 0x4002);
+        MP_WritePhyUshort(sc, 0x15, 0x021b);
+        MP_WritePhyUshort(sc, 0x19, 0x7800);
+        MP_WritePhyUshort(sc, 0x15, 0x021c);
+        MP_WritePhyUshort(sc, 0x19, 0x588d);
+        MP_WritePhyUshort(sc, 0x15, 0x021d);
+        MP_WritePhyUshort(sc, 0x19, 0x5540);
+        MP_WritePhyUshort(sc, 0x15, 0x021e);
+        MP_WritePhyUshort(sc, 0x19, 0x3220);
+        MP_WritePhyUshort(sc, 0x15, 0x021f);
+        MP_WritePhyUshort(sc, 0x19, 0x4000);
+        MP_WritePhyUshort(sc, 0x15, 0x0220);
+        MP_WritePhyUshort(sc, 0x19, 0x7800);
+        MP_WritePhyUshort(sc, 0x15, 0x0221);
+        MP_WritePhyUshort(sc, 0x19, 0x7c03);
+        MP_WritePhyUshort(sc, 0x15, 0x0222);
+        MP_WritePhyUshort(sc, 0x19, 0x6c00);
+        MP_WritePhyUshort(sc, 0x15, 0x0223);
+        MP_WritePhyUshort(sc, 0x19, 0x3231);
+        MP_WritePhyUshort(sc, 0x15, 0x0224);
+        MP_WritePhyUshort(sc, 0x19, 0xab06);
+        MP_WritePhyUshort(sc, 0x15, 0x0225);
+        MP_WritePhyUshort(sc, 0x19, 0xbf08);
+        MP_WritePhyUshort(sc, 0x15, 0x0226);
+        MP_WritePhyUshort(sc, 0x19, 0x4076);
+        MP_WritePhyUshort(sc, 0x15, 0x0227);
+        MP_WritePhyUshort(sc, 0x19, 0x7d07);
+        MP_WritePhyUshort(sc, 0x15, 0x0228);
+        MP_WritePhyUshort(sc, 0x19, 0x4502);
+        MP_WritePhyUshort(sc, 0x15, 0x0229);
+        MP_WritePhyUshort(sc, 0x19, 0x3231);
+        MP_WritePhyUshort(sc, 0x15, 0x022a);
+        MP_WritePhyUshort(sc, 0x19, 0x7d80);
+        MP_WritePhyUshort(sc, 0x15, 0x022b);
+        MP_WritePhyUshort(sc, 0x19, 0x5180);
+        MP_WritePhyUshort(sc, 0x15, 0x022c);
+        MP_WritePhyUshort(sc, 0x19, 0x322f);
+        MP_WritePhyUshort(sc, 0x15, 0x022d);
+        MP_WritePhyUshort(sc, 0x19, 0x7d80);
+        MP_WritePhyUshort(sc, 0x15, 0x022e);
+        MP_WritePhyUshort(sc, 0x19, 0x5000);
+        MP_WritePhyUshort(sc, 0x15, 0x022f);
+        MP_WritePhyUshort(sc, 0x19, 0x7d07);
+        MP_WritePhyUshort(sc, 0x15, 0x0230);
+        MP_WritePhyUshort(sc, 0x19, 0x4402);
+        MP_WritePhyUshort(sc, 0x15, 0x0231);
+        MP_WritePhyUshort(sc, 0x19, 0x7c03);
+        MP_WritePhyUshort(sc, 0x15, 0x0232);
+        MP_WritePhyUshort(sc, 0x19, 0x6c02);
+        MP_WritePhyUshort(sc, 0x15, 0x0233);
+        MP_WritePhyUshort(sc, 0x19, 0x7c03);
+        MP_WritePhyUshort(sc, 0x15, 0x0234);
+        MP_WritePhyUshort(sc, 0x19, 0xb309);
+        MP_WritePhyUshort(sc, 0x15, 0x0235);
+        MP_WritePhyUshort(sc, 0x19, 0xb204);
+        MP_WritePhyUshort(sc, 0x15, 0x0236);
+        MP_WritePhyUshort(sc, 0x19, 0xb105);
+        MP_WritePhyUshort(sc, 0x15, 0x0237);
+        MP_WritePhyUshort(sc, 0x19, 0x6c00);
+        MP_WritePhyUshort(sc, 0x15, 0x0238);
+        MP_WritePhyUshort(sc, 0x19, 0x31c1);
+        MP_WritePhyUshort(sc, 0x15, 0x0239);
+        MP_WritePhyUshort(sc, 0x19, 0x6c00);
+        MP_WritePhyUshort(sc, 0x15, 0x023a);
+        MP_WritePhyUshort(sc, 0x19, 0x3261);
+        MP_WritePhyUshort(sc, 0x15, 0x023b);
+        MP_WritePhyUshort(sc, 0x19, 0x6c00);
+        MP_WritePhyUshort(sc, 0x15, 0x023c);
+        MP_WritePhyUshort(sc, 0x19, 0x3250);
+        MP_WritePhyUshort(sc, 0x15, 0x023d);
+        MP_WritePhyUshort(sc, 0x19, 0xb203);
+        MP_WritePhyUshort(sc, 0x15, 0x023e);
+        MP_WritePhyUshort(sc, 0x19, 0x6c00);
+        MP_WritePhyUshort(sc, 0x15, 0x023f);
+        MP_WritePhyUshort(sc, 0x19, 0x327a);
+        MP_WritePhyUshort(sc, 0x15, 0x0240);
+        MP_WritePhyUshort(sc, 0x19, 0x6c00);
+        MP_WritePhyUshort(sc, 0x15, 0x0241);
+        MP_WritePhyUshort(sc, 0x19, 0x3293);
+        MP_WritePhyUshort(sc, 0x15, 0x0242);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0243);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0244);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0245);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0246);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0247);
+        MP_WritePhyUshort(sc, 0x19, 0x32a3);
+        MP_WritePhyUshort(sc, 0x15, 0x0248);
+        MP_WritePhyUshort(sc, 0x19, 0x5520);
+        MP_WritePhyUshort(sc, 0x15, 0x0249);
+        MP_WritePhyUshort(sc, 0x19, 0x403d);
+        MP_WritePhyUshort(sc, 0x15, 0x024a);
+        MP_WritePhyUshort(sc, 0x19, 0x440c);
+        MP_WritePhyUshort(sc, 0x15, 0x024b);
+        MP_WritePhyUshort(sc, 0x19, 0x4812);
+        MP_WritePhyUshort(sc, 0x15, 0x024c);
+        MP_WritePhyUshort(sc, 0x19, 0x5001);
+        MP_WritePhyUshort(sc, 0x15, 0x024d);
+        MP_WritePhyUshort(sc, 0x19, 0x4802);
+        MP_WritePhyUshort(sc, 0x15, 0x024e);
+        MP_WritePhyUshort(sc, 0x19, 0x6880);
+        MP_WritePhyUshort(sc, 0x15, 0x024f);
+        MP_WritePhyUshort(sc, 0x19, 0x31f5);
+        MP_WritePhyUshort(sc, 0x15, 0x0250);
+        MP_WritePhyUshort(sc, 0x19, 0xb685);
+        MP_WritePhyUshort(sc, 0x15, 0x0251);
+        MP_WritePhyUshort(sc, 0x19, 0x801c);
+        MP_WritePhyUshort(sc, 0x15, 0x0252);
+        MP_WritePhyUshort(sc, 0x19, 0xbaf5);
+        MP_WritePhyUshort(sc, 0x15, 0x0253);
+        MP_WritePhyUshort(sc, 0x19, 0xc07c);
+        MP_WritePhyUshort(sc, 0x15, 0x0254);
+        MP_WritePhyUshort(sc, 0x19, 0x00fb);
+        MP_WritePhyUshort(sc, 0x15, 0x0255);
+        MP_WritePhyUshort(sc, 0x19, 0x325a);
+        MP_WritePhyUshort(sc, 0x15, 0x0256);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0257);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0258);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0259);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x025a);
+        MP_WritePhyUshort(sc, 0x19, 0x481a);
+        MP_WritePhyUshort(sc, 0x15, 0x025b);
+        MP_WritePhyUshort(sc, 0x19, 0x5001);
+        MP_WritePhyUshort(sc, 0x15, 0x025c);
+        MP_WritePhyUshort(sc, 0x19, 0x401b);
+        MP_WritePhyUshort(sc, 0x15, 0x025d);
+        MP_WritePhyUshort(sc, 0x19, 0x480a);
+        MP_WritePhyUshort(sc, 0x15, 0x025e);
+        MP_WritePhyUshort(sc, 0x19, 0x4418);
+        MP_WritePhyUshort(sc, 0x15, 0x025f);
+        MP_WritePhyUshort(sc, 0x19, 0x6900);
+        MP_WritePhyUshort(sc, 0x15, 0x0260);
+        MP_WritePhyUshort(sc, 0x19, 0x31f5);
+        MP_WritePhyUshort(sc, 0x15, 0x0261);
+        MP_WritePhyUshort(sc, 0x19, 0xb64b);
+        MP_WritePhyUshort(sc, 0x15, 0x0262);
+        MP_WritePhyUshort(sc, 0x19, 0xdb00);
+        MP_WritePhyUshort(sc, 0x15, 0x0263);
+        MP_WritePhyUshort(sc, 0x19, 0x0048);
+        MP_WritePhyUshort(sc, 0x15, 0x0264);
+        MP_WritePhyUshort(sc, 0x19, 0xdb7d);
+        MP_WritePhyUshort(sc, 0x15, 0x0265);
+        MP_WritePhyUshort(sc, 0x19, 0x0002);
+        MP_WritePhyUshort(sc, 0x15, 0x0266);
+        MP_WritePhyUshort(sc, 0x19, 0xa0fa);
+        MP_WritePhyUshort(sc, 0x15, 0x0267);
+        MP_WritePhyUshort(sc, 0x19, 0x4408);
+        MP_WritePhyUshort(sc, 0x15, 0x0268);
+        MP_WritePhyUshort(sc, 0x19, 0x3248);
+        MP_WritePhyUshort(sc, 0x15, 0x0269);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x026a);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x026b);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x026c);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x026d);
+        MP_WritePhyUshort(sc, 0x19, 0xb806);
+        MP_WritePhyUshort(sc, 0x15, 0x026e);
+        MP_WritePhyUshort(sc, 0x19, 0x588d);
+        MP_WritePhyUshort(sc, 0x15, 0x026f);
+        MP_WritePhyUshort(sc, 0x19, 0x5500);
+        MP_WritePhyUshort(sc, 0x15, 0x0270);
+        MP_WritePhyUshort(sc, 0x19, 0x7801);
+        MP_WritePhyUshort(sc, 0x15, 0x0271);
+        MP_WritePhyUshort(sc, 0x19, 0x4002);
+        MP_WritePhyUshort(sc, 0x15, 0x0272);
+        MP_WritePhyUshort(sc, 0x19, 0x7800);
+        MP_WritePhyUshort(sc, 0x15, 0x0273);
+        MP_WritePhyUshort(sc, 0x19, 0x4814);
+        MP_WritePhyUshort(sc, 0x15, 0x0274);
+        MP_WritePhyUshort(sc, 0x19, 0x500b);
+        MP_WritePhyUshort(sc, 0x15, 0x0275);
+        MP_WritePhyUshort(sc, 0x19, 0x4804);
+        MP_WritePhyUshort(sc, 0x15, 0x0276);
+        MP_WritePhyUshort(sc, 0x19, 0x40c4);
+        MP_WritePhyUshort(sc, 0x15, 0x0277);
+        MP_WritePhyUshort(sc, 0x19, 0x4425);
+        MP_WritePhyUshort(sc, 0x15, 0x0278);
+        MP_WritePhyUshort(sc, 0x19, 0x6a00);
+        MP_WritePhyUshort(sc, 0x15, 0x0279);
+        MP_WritePhyUshort(sc, 0x19, 0x31f5);
+        MP_WritePhyUshort(sc, 0x15, 0x027a);
+        MP_WritePhyUshort(sc, 0x19, 0xb632);
+        MP_WritePhyUshort(sc, 0x15, 0x027b);
+        MP_WritePhyUshort(sc, 0x19, 0xdc03);
+        MP_WritePhyUshort(sc, 0x15, 0x027c);
+        MP_WritePhyUshort(sc, 0x19, 0x0027);
+        MP_WritePhyUshort(sc, 0x15, 0x027d);
+        MP_WritePhyUshort(sc, 0x19, 0x80fc);
+        MP_WritePhyUshort(sc, 0x15, 0x027e);
+        MP_WritePhyUshort(sc, 0x19, 0x3283);
+        MP_WritePhyUshort(sc, 0x15, 0x027f);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0280);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0281);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0282);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0283);
+        MP_WritePhyUshort(sc, 0x19, 0xb806);
+        MP_WritePhyUshort(sc, 0x15, 0x0284);
+        MP_WritePhyUshort(sc, 0x19, 0x588f);
+        MP_WritePhyUshort(sc, 0x15, 0x0285);
+        MP_WritePhyUshort(sc, 0x19, 0x5520);
+        MP_WritePhyUshort(sc, 0x15, 0x0286);
+        MP_WritePhyUshort(sc, 0x19, 0x7801);
+        MP_WritePhyUshort(sc, 0x15, 0x0287);
+        MP_WritePhyUshort(sc, 0x19, 0x4000);
+        MP_WritePhyUshort(sc, 0x15, 0x0288);
+        MP_WritePhyUshort(sc, 0x19, 0x7800);
+        MP_WritePhyUshort(sc, 0x15, 0x0289);
+        MP_WritePhyUshort(sc, 0x19, 0x4818);
+        MP_WritePhyUshort(sc, 0x15, 0x028a);
+        MP_WritePhyUshort(sc, 0x19, 0x5051);
+        MP_WritePhyUshort(sc, 0x15, 0x028b);
+        MP_WritePhyUshort(sc, 0x19, 0x4808);
+        MP_WritePhyUshort(sc, 0x15, 0x028c);
+        MP_WritePhyUshort(sc, 0x19, 0x4050);
+        MP_WritePhyUshort(sc, 0x15, 0x028d);
+        MP_WritePhyUshort(sc, 0x19, 0x4462);
+        MP_WritePhyUshort(sc, 0x15, 0x028e);
+        MP_WritePhyUshort(sc, 0x19, 0x40c4);
+        MP_WritePhyUshort(sc, 0x15, 0x028f);
+        MP_WritePhyUshort(sc, 0x19, 0x4473);
+        MP_WritePhyUshort(sc, 0x15, 0x0290);
+        MP_WritePhyUshort(sc, 0x19, 0x5041);
+        MP_WritePhyUshort(sc, 0x15, 0x0291);
+        MP_WritePhyUshort(sc, 0x19, 0x6b00);
+        MP_WritePhyUshort(sc, 0x15, 0x0292);
+        MP_WritePhyUshort(sc, 0x19, 0x31f5);
+        MP_WritePhyUshort(sc, 0x15, 0x0293);
+        MP_WritePhyUshort(sc, 0x19, 0xb619);
+        MP_WritePhyUshort(sc, 0x15, 0x0294);
+        MP_WritePhyUshort(sc, 0x19, 0x80d9);
+        MP_WritePhyUshort(sc, 0x15, 0x0295);
+        MP_WritePhyUshort(sc, 0x19, 0xbd06);
+        MP_WritePhyUshort(sc, 0x15, 0x0296);
+        MP_WritePhyUshort(sc, 0x19, 0xbb0d);
+        MP_WritePhyUshort(sc, 0x15, 0x0297);
+        MP_WritePhyUshort(sc, 0x19, 0xaf14);
+        MP_WritePhyUshort(sc, 0x15, 0x0298);
+        MP_WritePhyUshort(sc, 0x19, 0x8efa);
+        MP_WritePhyUshort(sc, 0x15, 0x0299);
+        MP_WritePhyUshort(sc, 0x19, 0x5049);
+        MP_WritePhyUshort(sc, 0x15, 0x029a);
+        MP_WritePhyUshort(sc, 0x19, 0x3248);
+        MP_WritePhyUshort(sc, 0x15, 0x029b);
+        MP_WritePhyUshort(sc, 0x19, 0x4c10);
+        MP_WritePhyUshort(sc, 0x15, 0x029c);
+        MP_WritePhyUshort(sc, 0x19, 0x44b0);
+        MP_WritePhyUshort(sc, 0x15, 0x029d);
+        MP_WritePhyUshort(sc, 0x19, 0x4c00);
+        MP_WritePhyUshort(sc, 0x15, 0x029e);
+        MP_WritePhyUshort(sc, 0x19, 0x3292);
+        MP_WritePhyUshort(sc, 0x15, 0x029f);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x02a0);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x02a1);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x02a2);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x02a3);
+        MP_WritePhyUshort(sc, 0x19, 0x481f);
+        MP_WritePhyUshort(sc, 0x15, 0x02a4);
+        MP_WritePhyUshort(sc, 0x19, 0x5005);
+        MP_WritePhyUshort(sc, 0x15, 0x02a5);
+        MP_WritePhyUshort(sc, 0x19, 0x480f);
+        MP_WritePhyUshort(sc, 0x15, 0x02a6);
+        MP_WritePhyUshort(sc, 0x19, 0xac00);
+        MP_WritePhyUshort(sc, 0x15, 0x02a7);
+        MP_WritePhyUshort(sc, 0x19, 0x31a6);
+        MP_WritePhyUshort(sc, 0x15, 0x02a8);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x02a9);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x02aa);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x02ab);
+        MP_WritePhyUshort(sc, 0x19, 0x31ba);
+        MP_WritePhyUshort(sc, 0x15, 0x02ac);
+        MP_WritePhyUshort(sc, 0x19, 0x31d5);
+        MP_WritePhyUshort(sc, 0x15, 0x02ad);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x02ae);
+        MP_WritePhyUshort(sc, 0x19, 0x5cf0);
+        MP_WritePhyUshort(sc, 0x15, 0x02af);
+        MP_WritePhyUshort(sc, 0x19, 0x588c);
+        MP_WritePhyUshort(sc, 0x15, 0x02b0);
+        MP_WritePhyUshort(sc, 0x19, 0x542f);
+        MP_WritePhyUshort(sc, 0x15, 0x02b1);
+        MP_WritePhyUshort(sc, 0x19, 0x7ffb);
+        MP_WritePhyUshort(sc, 0x15, 0x02b2);
+        MP_WritePhyUshort(sc, 0x19, 0x6ff8);
+        MP_WritePhyUshort(sc, 0x15, 0x02b3);
+        MP_WritePhyUshort(sc, 0x19, 0x64a4);
+        MP_WritePhyUshort(sc, 0x15, 0x02b4);
+        MP_WritePhyUshort(sc, 0x19, 0x64a0);
+        MP_WritePhyUshort(sc, 0x15, 0x02b5);
+        MP_WritePhyUshort(sc, 0x19, 0x6800);
+        MP_WritePhyUshort(sc, 0x15, 0x02b6);
+        MP_WritePhyUshort(sc, 0x19, 0x4400);
+        MP_WritePhyUshort(sc, 0x15, 0x02b7);
+        MP_WritePhyUshort(sc, 0x19, 0x4020);
+        MP_WritePhyUshort(sc, 0x15, 0x02b8);
+        MP_WritePhyUshort(sc, 0x19, 0x4480);
+        MP_WritePhyUshort(sc, 0x15, 0x02b9);
+        MP_WritePhyUshort(sc, 0x19, 0x9e00);
+        MP_WritePhyUshort(sc, 0x15, 0x02ba);
+        MP_WritePhyUshort(sc, 0x19, 0x4891);
+        MP_WritePhyUshort(sc, 0x15, 0x02bb);
+        MP_WritePhyUshort(sc, 0x19, 0x4cc0);
+        MP_WritePhyUshort(sc, 0x15, 0x02bc);
+        MP_WritePhyUshort(sc, 0x19, 0x4801);
+        MP_WritePhyUshort(sc, 0x15, 0x02bd);
+        MP_WritePhyUshort(sc, 0x19, 0xa609);
+        MP_WritePhyUshort(sc, 0x15, 0x02be);
+        MP_WritePhyUshort(sc, 0x19, 0xd64f);
+        MP_WritePhyUshort(sc, 0x15, 0x02bf);
+        MP_WritePhyUshort(sc, 0x19, 0x004e);
+        MP_WritePhyUshort(sc, 0x15, 0x02c0);
+        MP_WritePhyUshort(sc, 0x19, 0x87fe);
+        MP_WritePhyUshort(sc, 0x15, 0x02c1);
+        MP_WritePhyUshort(sc, 0x19, 0x32c6);
+        MP_WritePhyUshort(sc, 0x15, 0x02c2);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x02c3);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x02c4);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x02c5);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x02c6);
+        MP_WritePhyUshort(sc, 0x19, 0x48b2);
+        MP_WritePhyUshort(sc, 0x15, 0x02c7);
+        MP_WritePhyUshort(sc, 0x19, 0x4020);
+        MP_WritePhyUshort(sc, 0x15, 0x02c8);
+        MP_WritePhyUshort(sc, 0x19, 0x4822);
+        MP_WritePhyUshort(sc, 0x15, 0x02c9);
+        MP_WritePhyUshort(sc, 0x19, 0x4488);
+        MP_WritePhyUshort(sc, 0x15, 0x02ca);
+        MP_WritePhyUshort(sc, 0x19, 0xd64f);
+        MP_WritePhyUshort(sc, 0x15, 0x02cb);
+        MP_WritePhyUshort(sc, 0x19, 0x0042);
+        MP_WritePhyUshort(sc, 0x15, 0x02cc);
+        MP_WritePhyUshort(sc, 0x19, 0x8203);
+        MP_WritePhyUshort(sc, 0x15, 0x02cd);
+        MP_WritePhyUshort(sc, 0x19, 0x4cc8);
+        MP_WritePhyUshort(sc, 0x15, 0x02ce);
+        MP_WritePhyUshort(sc, 0x19, 0x32d0);
+        MP_WritePhyUshort(sc, 0x15, 0x02cf);
+        MP_WritePhyUshort(sc, 0x19, 0x4cc0);
+        MP_WritePhyUshort(sc, 0x15, 0x02d0);
+        MP_WritePhyUshort(sc, 0x19, 0xc4d4);
+        MP_WritePhyUshort(sc, 0x15, 0x02d1);
+        MP_WritePhyUshort(sc, 0x19, 0x00f9);
+        MP_WritePhyUshort(sc, 0x15, 0x02d2);
+        MP_WritePhyUshort(sc, 0x19, 0xa51a);
+        MP_WritePhyUshort(sc, 0x15, 0x02d3);
+        MP_WritePhyUshort(sc, 0x19, 0x32d9);
+        MP_WritePhyUshort(sc, 0x15, 0x02d4);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x02d5);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x02d6);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x02d7);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x02d8);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x02d9);
+        MP_WritePhyUshort(sc, 0x19, 0x48b3);
+        MP_WritePhyUshort(sc, 0x15, 0x02da);
+        MP_WritePhyUshort(sc, 0x19, 0x4020);
+        MP_WritePhyUshort(sc, 0x15, 0x02db);
+        MP_WritePhyUshort(sc, 0x19, 0x4823);
+        MP_WritePhyUshort(sc, 0x15, 0x02dc);
+        MP_WritePhyUshort(sc, 0x19, 0x4410);
+        MP_WritePhyUshort(sc, 0x15, 0x02dd);
+        MP_WritePhyUshort(sc, 0x19, 0xb630);
+        MP_WritePhyUshort(sc, 0x15, 0x02de);
+        MP_WritePhyUshort(sc, 0x19, 0x7dc8);
+        MP_WritePhyUshort(sc, 0x15, 0x02df);
+        MP_WritePhyUshort(sc, 0x19, 0x8203);
+        MP_WritePhyUshort(sc, 0x15, 0x02e0);
+        MP_WritePhyUshort(sc, 0x19, 0x4c48);
+        MP_WritePhyUshort(sc, 0x15, 0x02e1);
+        MP_WritePhyUshort(sc, 0x19, 0x32e3);
+        MP_WritePhyUshort(sc, 0x15, 0x02e2);
+        MP_WritePhyUshort(sc, 0x19, 0x4c40);
+        MP_WritePhyUshort(sc, 0x15, 0x02e3);
+        MP_WritePhyUshort(sc, 0x19, 0x9bfa);
+        MP_WritePhyUshort(sc, 0x15, 0x02e4);
+        MP_WritePhyUshort(sc, 0x19, 0x84ca);
+        MP_WritePhyUshort(sc, 0x15, 0x02e5);
+        MP_WritePhyUshort(sc, 0x19, 0x85f8);
+        MP_WritePhyUshort(sc, 0x15, 0x02e6);
+        MP_WritePhyUshort(sc, 0x19, 0x32ec);
+        MP_WritePhyUshort(sc, 0x15, 0x02e7);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x02e8);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x02e9);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x02ea);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x02eb);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x02ec);
+        MP_WritePhyUshort(sc, 0x19, 0x48d4);
+        MP_WritePhyUshort(sc, 0x15, 0x02ed);
+        MP_WritePhyUshort(sc, 0x19, 0x4020);
+        MP_WritePhyUshort(sc, 0x15, 0x02ee);
+        MP_WritePhyUshort(sc, 0x19, 0x4844);
+        MP_WritePhyUshort(sc, 0x15, 0x02ef);
+        MP_WritePhyUshort(sc, 0x19, 0x4420);
+        MP_WritePhyUshort(sc, 0x15, 0x02f0);
+        MP_WritePhyUshort(sc, 0x19, 0x6800);
+        MP_WritePhyUshort(sc, 0x15, 0x02f1);
+        MP_WritePhyUshort(sc, 0x19, 0x7dc0);
+        MP_WritePhyUshort(sc, 0x15, 0x02f2);
+        MP_WritePhyUshort(sc, 0x19, 0x4c40);
+        MP_WritePhyUshort(sc, 0x15, 0x02f3);
+        MP_WritePhyUshort(sc, 0x19, 0x7c0b);
+        MP_WritePhyUshort(sc, 0x15, 0x02f4);
+        MP_WritePhyUshort(sc, 0x19, 0x6c08);
+        MP_WritePhyUshort(sc, 0x15, 0x02f5);
+        MP_WritePhyUshort(sc, 0x19, 0x3311);
+        MP_WritePhyUshort(sc, 0x15, 0x02f6);
+        MP_WritePhyUshort(sc, 0x19, 0x9cfd);
+        MP_WritePhyUshort(sc, 0x15, 0x02f7);
+        MP_WritePhyUshort(sc, 0x19, 0xb616);
+        MP_WritePhyUshort(sc, 0x15, 0x02f8);
+        MP_WritePhyUshort(sc, 0x19, 0xc42b);
+        MP_WritePhyUshort(sc, 0x15, 0x02f9);
+        MP_WritePhyUshort(sc, 0x19, 0x00e0);
+        MP_WritePhyUshort(sc, 0x15, 0x02fa);
+        MP_WritePhyUshort(sc, 0x19, 0xc455);
+        MP_WritePhyUshort(sc, 0x15, 0x02fb);
+        MP_WritePhyUshort(sc, 0x19, 0x00b3);
+        MP_WritePhyUshort(sc, 0x15, 0x02fc);
+        MP_WritePhyUshort(sc, 0x19, 0xb20a);
+        MP_WritePhyUshort(sc, 0x15, 0x02fd);
+        MP_WritePhyUshort(sc, 0x19, 0x7c03);
+        MP_WritePhyUshort(sc, 0x15, 0x02fe);
+        MP_WritePhyUshort(sc, 0x19, 0x6c02);
+        MP_WritePhyUshort(sc, 0x15, 0x02ff);
+        MP_WritePhyUshort(sc, 0x19, 0x8204);
+        MP_WritePhyUshort(sc, 0x15, 0x0300);
+        MP_WritePhyUshort(sc, 0x19, 0x7c04);
+        MP_WritePhyUshort(sc, 0x15, 0x0301);
+        MP_WritePhyUshort(sc, 0x19, 0x7404);
+        MP_WritePhyUshort(sc, 0x15, 0x0302);
+        MP_WritePhyUshort(sc, 0x19, 0x32f3);
+        MP_WritePhyUshort(sc, 0x15, 0x0303);
+        MP_WritePhyUshort(sc, 0x19, 0x7c04);
+        MP_WritePhyUshort(sc, 0x15, 0x0304);
+        MP_WritePhyUshort(sc, 0x19, 0x7400);
+        MP_WritePhyUshort(sc, 0x15, 0x0305);
+        MP_WritePhyUshort(sc, 0x19, 0x32f3);
+        MP_WritePhyUshort(sc, 0x15, 0x0306);
+        MP_WritePhyUshort(sc, 0x19, 0xefed);
+        MP_WritePhyUshort(sc, 0x15, 0x0307);
+        MP_WritePhyUshort(sc, 0x19, 0x3342);
+        MP_WritePhyUshort(sc, 0x15, 0x0308);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0309);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x030a);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x030b);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x030c);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x030d);
+        MP_WritePhyUshort(sc, 0x19, 0x3006);
+        MP_WritePhyUshort(sc, 0x15, 0x030e);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x030f);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0310);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0311);
+        MP_WritePhyUshort(sc, 0x19, 0x7c08);
+        MP_WritePhyUshort(sc, 0x15, 0x0312);
+        MP_WritePhyUshort(sc, 0x19, 0xa207);
+        MP_WritePhyUshort(sc, 0x15, 0x0313);
+        MP_WritePhyUshort(sc, 0x19, 0x4c00);
+        MP_WritePhyUshort(sc, 0x15, 0x0314);
+        MP_WritePhyUshort(sc, 0x19, 0x3322);
+        MP_WritePhyUshort(sc, 0x15, 0x0315);
+        MP_WritePhyUshort(sc, 0x19, 0x4041);
+        MP_WritePhyUshort(sc, 0x15, 0x0316);
+        MP_WritePhyUshort(sc, 0x19, 0x7d07);
+        MP_WritePhyUshort(sc, 0x15, 0x0317);
+        MP_WritePhyUshort(sc, 0x19, 0x4502);
+        MP_WritePhyUshort(sc, 0x15, 0x0318);
+        MP_WritePhyUshort(sc, 0x19, 0x3322);
+        MP_WritePhyUshort(sc, 0x15, 0x0319);
+        MP_WritePhyUshort(sc, 0x19, 0x4c08);
+        MP_WritePhyUshort(sc, 0x15, 0x031a);
+        MP_WritePhyUshort(sc, 0x19, 0x3322);
+        MP_WritePhyUshort(sc, 0x15, 0x031b);
+        MP_WritePhyUshort(sc, 0x19, 0x7d80);
+        MP_WritePhyUshort(sc, 0x15, 0x031c);
+        MP_WritePhyUshort(sc, 0x19, 0x5180);
+        MP_WritePhyUshort(sc, 0x15, 0x031d);
+        MP_WritePhyUshort(sc, 0x19, 0x3320);
+        MP_WritePhyUshort(sc, 0x15, 0x031e);
+        MP_WritePhyUshort(sc, 0x19, 0x7d80);
+        MP_WritePhyUshort(sc, 0x15, 0x031f);
+        MP_WritePhyUshort(sc, 0x19, 0x5000);
+        MP_WritePhyUshort(sc, 0x15, 0x0320);
+        MP_WritePhyUshort(sc, 0x19, 0x7d07);
+        MP_WritePhyUshort(sc, 0x15, 0x0321);
+        MP_WritePhyUshort(sc, 0x19, 0x4402);
+        MP_WritePhyUshort(sc, 0x15, 0x0322);
+        MP_WritePhyUshort(sc, 0x19, 0x7c03);
+        MP_WritePhyUshort(sc, 0x15, 0x0323);
+        MP_WritePhyUshort(sc, 0x19, 0x6c02);
+        MP_WritePhyUshort(sc, 0x15, 0x0324);
+        MP_WritePhyUshort(sc, 0x19, 0x7c03);
+        MP_WritePhyUshort(sc, 0x15, 0x0325);
+        MP_WritePhyUshort(sc, 0x19, 0xb30c);
+        MP_WritePhyUshort(sc, 0x15, 0x0326);
+        MP_WritePhyUshort(sc, 0x19, 0xb206);
+        MP_WritePhyUshort(sc, 0x15, 0x0327);
+        MP_WritePhyUshort(sc, 0x19, 0xb103);
+        MP_WritePhyUshort(sc, 0x15, 0x0328);
+        MP_WritePhyUshort(sc, 0x19, 0x6c00);
+        MP_WritePhyUshort(sc, 0x15, 0x0329);
+        MP_WritePhyUshort(sc, 0x19, 0x32f6);
+        MP_WritePhyUshort(sc, 0x15, 0x032a);
+        MP_WritePhyUshort(sc, 0x19, 0x6c00);
+        MP_WritePhyUshort(sc, 0x15, 0x032b);
+        MP_WritePhyUshort(sc, 0x19, 0x3352);
+        MP_WritePhyUshort(sc, 0x15, 0x032c);
+        MP_WritePhyUshort(sc, 0x19, 0xb103);
+        MP_WritePhyUshort(sc, 0x15, 0x032d);
+        MP_WritePhyUshort(sc, 0x19, 0x6c00);
+        MP_WritePhyUshort(sc, 0x15, 0x032e);
+        MP_WritePhyUshort(sc, 0x19, 0x336a);
+        MP_WritePhyUshort(sc, 0x15, 0x032f);
+        MP_WritePhyUshort(sc, 0x19, 0x6c00);
+        MP_WritePhyUshort(sc, 0x15, 0x0330);
+        MP_WritePhyUshort(sc, 0x19, 0x3382);
+        MP_WritePhyUshort(sc, 0x15, 0x0331);
+        MP_WritePhyUshort(sc, 0x19, 0xb206);
+        MP_WritePhyUshort(sc, 0x15, 0x0332);
+        MP_WritePhyUshort(sc, 0x19, 0xb103);
+        MP_WritePhyUshort(sc, 0x15, 0x0333);
+        MP_WritePhyUshort(sc, 0x19, 0x6c00);
+        MP_WritePhyUshort(sc, 0x15, 0x0334);
+        MP_WritePhyUshort(sc, 0x19, 0x3395);
+        MP_WritePhyUshort(sc, 0x15, 0x0335);
+        MP_WritePhyUshort(sc, 0x19, 0x6c00);
+        MP_WritePhyUshort(sc, 0x15, 0x0336);
+        MP_WritePhyUshort(sc, 0x19, 0x33c6);
+        MP_WritePhyUshort(sc, 0x15, 0x0337);
+        MP_WritePhyUshort(sc, 0x19, 0xb103);
+        MP_WritePhyUshort(sc, 0x15, 0x0338);
+        MP_WritePhyUshort(sc, 0x19, 0x6c00);
+        MP_WritePhyUshort(sc, 0x15, 0x0339);
+        MP_WritePhyUshort(sc, 0x19, 0x33d7);
+        MP_WritePhyUshort(sc, 0x15, 0x033a);
+        MP_WritePhyUshort(sc, 0x19, 0x6c00);
+        MP_WritePhyUshort(sc, 0x15, 0x033b);
+        MP_WritePhyUshort(sc, 0x19, 0x33f2);
+        MP_WritePhyUshort(sc, 0x15, 0x033c);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x033d);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x033e);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x033f);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0340);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0341);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0342);
+        MP_WritePhyUshort(sc, 0x19, 0x49b5);
+        MP_WritePhyUshort(sc, 0x15, 0x0343);
+        MP_WritePhyUshort(sc, 0x19, 0x7d00);
+        MP_WritePhyUshort(sc, 0x15, 0x0344);
+        MP_WritePhyUshort(sc, 0x19, 0x4d00);
+        MP_WritePhyUshort(sc, 0x15, 0x0345);
+        MP_WritePhyUshort(sc, 0x19, 0x6880);
+        MP_WritePhyUshort(sc, 0x15, 0x0346);
+        MP_WritePhyUshort(sc, 0x19, 0x7c08);
+        MP_WritePhyUshort(sc, 0x15, 0x0347);
+        MP_WritePhyUshort(sc, 0x19, 0x6c08);
+        MP_WritePhyUshort(sc, 0x15, 0x0348);
+        MP_WritePhyUshort(sc, 0x19, 0x4925);
+        MP_WritePhyUshort(sc, 0x15, 0x0349);
+        MP_WritePhyUshort(sc, 0x19, 0x403b);
+        MP_WritePhyUshort(sc, 0x15, 0x034a);
+        MP_WritePhyUshort(sc, 0x19, 0xa602);
+        MP_WritePhyUshort(sc, 0x15, 0x034b);
+        MP_WritePhyUshort(sc, 0x19, 0x402f);
+        MP_WritePhyUshort(sc, 0x15, 0x034c);
+        MP_WritePhyUshort(sc, 0x19, 0x4484);
+        MP_WritePhyUshort(sc, 0x15, 0x034d);
+        MP_WritePhyUshort(sc, 0x19, 0x40c8);
+        MP_WritePhyUshort(sc, 0x15, 0x034e);
+        MP_WritePhyUshort(sc, 0x19, 0x44c4);
+        MP_WritePhyUshort(sc, 0x15, 0x034f);
+        MP_WritePhyUshort(sc, 0x19, 0xd64f);
+        MP_WritePhyUshort(sc, 0x15, 0x0350);
+        MP_WritePhyUshort(sc, 0x19, 0x00bd);
+        MP_WritePhyUshort(sc, 0x15, 0x0351);
+        MP_WritePhyUshort(sc, 0x19, 0x3311);
+        MP_WritePhyUshort(sc, 0x15, 0x0352);
+        MP_WritePhyUshort(sc, 0x19, 0xc8ed);
+        MP_WritePhyUshort(sc, 0x15, 0x0353);
+        MP_WritePhyUshort(sc, 0x19, 0x00fc);
+        MP_WritePhyUshort(sc, 0x15, 0x0354);
+        MP_WritePhyUshort(sc, 0x19, 0x8221);
+        MP_WritePhyUshort(sc, 0x15, 0x0355);
+        MP_WritePhyUshort(sc, 0x19, 0xd11d);
+        MP_WritePhyUshort(sc, 0x15, 0x0356);
+        MP_WritePhyUshort(sc, 0x19, 0x001f);
+        MP_WritePhyUshort(sc, 0x15, 0x0357);
+        MP_WritePhyUshort(sc, 0x19, 0xde18);
+        MP_WritePhyUshort(sc, 0x15, 0x0358);
+        MP_WritePhyUshort(sc, 0x19, 0x0008);
+        MP_WritePhyUshort(sc, 0x15, 0x0359);
+        MP_WritePhyUshort(sc, 0x19, 0x91f6);
+        MP_WritePhyUshort(sc, 0x15, 0x035a);
+        MP_WritePhyUshort(sc, 0x19, 0x3360);
+        MP_WritePhyUshort(sc, 0x15, 0x035b);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x035c);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x035d);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x035e);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x035f);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0360);
+        MP_WritePhyUshort(sc, 0x19, 0x4bb6);
+        MP_WritePhyUshort(sc, 0x15, 0x0361);
+        MP_WritePhyUshort(sc, 0x19, 0x4064);
+        MP_WritePhyUshort(sc, 0x15, 0x0362);
+        MP_WritePhyUshort(sc, 0x19, 0x4b26);
+        MP_WritePhyUshort(sc, 0x15, 0x0363);
+        MP_WritePhyUshort(sc, 0x19, 0x4410);
+        MP_WritePhyUshort(sc, 0x15, 0x0364);
+        MP_WritePhyUshort(sc, 0x19, 0x4006);
+        MP_WritePhyUshort(sc, 0x15, 0x0365);
+        MP_WritePhyUshort(sc, 0x19, 0x4490);
+        MP_WritePhyUshort(sc, 0x15, 0x0366);
+        MP_WritePhyUshort(sc, 0x19, 0x6900);
+        MP_WritePhyUshort(sc, 0x15, 0x0367);
+        MP_WritePhyUshort(sc, 0x19, 0xb6a6);
+        MP_WritePhyUshort(sc, 0x15, 0x0368);
+        MP_WritePhyUshort(sc, 0x19, 0x9e02);
+        MP_WritePhyUshort(sc, 0x15, 0x0369);
+        MP_WritePhyUshort(sc, 0x19, 0x3311);
+        MP_WritePhyUshort(sc, 0x15, 0x036a);
+        MP_WritePhyUshort(sc, 0x19, 0xd11d);
+        MP_WritePhyUshort(sc, 0x15, 0x036b);
+        MP_WritePhyUshort(sc, 0x19, 0x000a);
+        MP_WritePhyUshort(sc, 0x15, 0x036c);
+        MP_WritePhyUshort(sc, 0x19, 0xbb0f);
+        MP_WritePhyUshort(sc, 0x15, 0x036d);
+        MP_WritePhyUshort(sc, 0x19, 0x8102);
+        MP_WritePhyUshort(sc, 0x15, 0x036e);
+        MP_WritePhyUshort(sc, 0x19, 0x3371);
+        MP_WritePhyUshort(sc, 0x15, 0x036f);
+        MP_WritePhyUshort(sc, 0x19, 0xa21e);
+        MP_WritePhyUshort(sc, 0x15, 0x0370);
+        MP_WritePhyUshort(sc, 0x19, 0x33b6);
+        MP_WritePhyUshort(sc, 0x15, 0x0371);
+        MP_WritePhyUshort(sc, 0x19, 0x91f6);
+        MP_WritePhyUshort(sc, 0x15, 0x0372);
+        MP_WritePhyUshort(sc, 0x19, 0xc218);
+        MP_WritePhyUshort(sc, 0x15, 0x0373);
+        MP_WritePhyUshort(sc, 0x19, 0x00f4);
+        MP_WritePhyUshort(sc, 0x15, 0x0374);
+        MP_WritePhyUshort(sc, 0x19, 0x33b6);
+        MP_WritePhyUshort(sc, 0x15, 0x0375);
+        MP_WritePhyUshort(sc, 0x19, 0x32ec);
+        MP_WritePhyUshort(sc, 0x15, 0x0376);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0377);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0378);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x0379);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x037a);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x037b);
+        MP_WritePhyUshort(sc, 0x19, 0x4b97);
+        MP_WritePhyUshort(sc, 0x15, 0x037c);
+        MP_WritePhyUshort(sc, 0x19, 0x402b);
+        MP_WritePhyUshort(sc, 0x15, 0x037d);
+        MP_WritePhyUshort(sc, 0x19, 0x4b07);
+        MP_WritePhyUshort(sc, 0x15, 0x037e);
+        MP_WritePhyUshort(sc, 0x19, 0x4422);
+        MP_WritePhyUshort(sc, 0x15, 0x037f);
+        MP_WritePhyUshort(sc, 0x19, 0x6980);
+        MP_WritePhyUshort(sc, 0x15, 0x0380);
+        MP_WritePhyUshort(sc, 0x19, 0xb608);
+        MP_WritePhyUshort(sc, 0x15, 0x0381);
+        MP_WritePhyUshort(sc, 0x19, 0x3311);
+        MP_WritePhyUshort(sc, 0x15, 0x0382);
+        MP_WritePhyUshort(sc, 0x19, 0xbc05);
+        MP_WritePhyUshort(sc, 0x15, 0x0383);
+        MP_WritePhyUshort(sc, 0x19, 0xc21c);
+        MP_WritePhyUshort(sc, 0x15, 0x0384);
+        MP_WritePhyUshort(sc, 0x19, 0x0032);
+        MP_WritePhyUshort(sc, 0x15, 0x0385);
+        MP_WritePhyUshort(sc, 0x19, 0xa1fb);
+        MP_WritePhyUshort(sc, 0x15, 0x0386);
+        MP_WritePhyUshort(sc, 0x19, 0x338d);
+        MP_WritePhyUshort(sc, 0x15, 0x0387);
+        MP_WritePhyUshort(sc, 0x19, 0x32ae);
+        MP_WritePhyUshort(sc, 0x15, 0x0388);
+        MP_WritePhyUshort(sc, 0x19, 0x330d);
+        MP_WritePhyUshort(sc, 0x15, 0x0389);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x038a);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x038b);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x038c);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x038d);
+        MP_WritePhyUshort(sc, 0x19, 0x4b97);
+        MP_WritePhyUshort(sc, 0x15, 0x038e);
+        MP_WritePhyUshort(sc, 0x19, 0x6a08);
+        MP_WritePhyUshort(sc, 0x15, 0x038f);
+        MP_WritePhyUshort(sc, 0x19, 0x4b07);
+        MP_WritePhyUshort(sc, 0x15, 0x0390);
+        MP_WritePhyUshort(sc, 0x19, 0x40ac);
+        MP_WritePhyUshort(sc, 0x15, 0x0391);
+        MP_WritePhyUshort(sc, 0x19, 0x4445);
+        MP_WritePhyUshort(sc, 0x15, 0x0392);
+        MP_WritePhyUshort(sc, 0x19, 0x404e);
+        MP_WritePhyUshort(sc, 0x15, 0x0393);
+        MP_WritePhyUshort(sc, 0x19, 0x4461);
+        MP_WritePhyUshort(sc, 0x15, 0x0394);
+        MP_WritePhyUshort(sc, 0x19, 0x3311);
+        MP_WritePhyUshort(sc, 0x15, 0x0395);
+        MP_WritePhyUshort(sc, 0x19, 0x9c0a);
+        MP_WritePhyUshort(sc, 0x15, 0x0396);
+        MP_WritePhyUshort(sc, 0x19, 0x63da);
+        MP_WritePhyUshort(sc, 0x15, 0x0397);
+        MP_WritePhyUshort(sc, 0x19, 0x6f0c);
+        MP_WritePhyUshort(sc, 0x15, 0x0398);
+        MP_WritePhyUshort(sc, 0x19, 0x5440);
+        MP_WritePhyUshort(sc, 0x15, 0x0399);
+        MP_WritePhyUshort(sc, 0x19, 0x4b98);
+        MP_WritePhyUshort(sc, 0x15, 0x039a);
+        MP_WritePhyUshort(sc, 0x19, 0x7c40);
+        MP_WritePhyUshort(sc, 0x15, 0x039b);
+        MP_WritePhyUshort(sc, 0x19, 0x4c00);
+        MP_WritePhyUshort(sc, 0x15, 0x039c);
+        MP_WritePhyUshort(sc, 0x19, 0x4b08);
+        MP_WritePhyUshort(sc, 0x15, 0x039d);
+        MP_WritePhyUshort(sc, 0x19, 0x63d8);
+        MP_WritePhyUshort(sc, 0x15, 0x039e);
+        MP_WritePhyUshort(sc, 0x19, 0x33a5);
+        MP_WritePhyUshort(sc, 0x15, 0x039f);
+        MP_WritePhyUshort(sc, 0x19, 0xd64f);
+        MP_WritePhyUshort(sc, 0x15, 0x03a0);
+        MP_WritePhyUshort(sc, 0x19, 0x00e8);
+        MP_WritePhyUshort(sc, 0x15, 0x03a1);
+        MP_WritePhyUshort(sc, 0x19, 0x820e);
+        MP_WritePhyUshort(sc, 0x15, 0x03a2);
+        MP_WritePhyUshort(sc, 0x19, 0xa10d);
+        MP_WritePhyUshort(sc, 0x15, 0x03a3);
+        MP_WritePhyUshort(sc, 0x19, 0x9df1);
+        MP_WritePhyUshort(sc, 0x15, 0x03a4);
+        MP_WritePhyUshort(sc, 0x19, 0x33af);
+        MP_WritePhyUshort(sc, 0x15, 0x03a5);
+        MP_WritePhyUshort(sc, 0x19, 0xd64f);
+        MP_WritePhyUshort(sc, 0x15, 0x03a6);
+        MP_WritePhyUshort(sc, 0x19, 0x00f9);
+        MP_WritePhyUshort(sc, 0x15, 0x03a7);
+        MP_WritePhyUshort(sc, 0x19, 0xc017);
+        MP_WritePhyUshort(sc, 0x15, 0x03a8);
+        MP_WritePhyUshort(sc, 0x19, 0x0007);
+        MP_WritePhyUshort(sc, 0x15, 0x03a9);
+        MP_WritePhyUshort(sc, 0x19, 0x7c03);
+        MP_WritePhyUshort(sc, 0x15, 0x03aa);
+        MP_WritePhyUshort(sc, 0x19, 0x6c03);
+        MP_WritePhyUshort(sc, 0x15, 0x03ab);
+        MP_WritePhyUshort(sc, 0x19, 0xa104);
+        MP_WritePhyUshort(sc, 0x15, 0x03ac);
+        MP_WritePhyUshort(sc, 0x19, 0x7c03);
+        MP_WritePhyUshort(sc, 0x15, 0x03ad);
+        MP_WritePhyUshort(sc, 0x19, 0x6c00);
+        MP_WritePhyUshort(sc, 0x15, 0x03ae);
+        MP_WritePhyUshort(sc, 0x19, 0x9df7);
+        MP_WritePhyUshort(sc, 0x15, 0x03af);
+        MP_WritePhyUshort(sc, 0x19, 0x7c03);
+        MP_WritePhyUshort(sc, 0x15, 0x03b0);
+        MP_WritePhyUshort(sc, 0x19, 0x6c08);
+        MP_WritePhyUshort(sc, 0x15, 0x03b1);
+        MP_WritePhyUshort(sc, 0x19, 0x33b6);
+        MP_WritePhyUshort(sc, 0x15, 0x03b2);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x03b3);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x03b4);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x03b5);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x03b6);
+        MP_WritePhyUshort(sc, 0x19, 0x55af);
+        MP_WritePhyUshort(sc, 0x15, 0x03b7);
+        MP_WritePhyUshort(sc, 0x19, 0x7ff0);
+        MP_WritePhyUshort(sc, 0x15, 0x03b8);
+        MP_WritePhyUshort(sc, 0x19, 0x6ff0);
+        MP_WritePhyUshort(sc, 0x15, 0x03b9);
+        MP_WritePhyUshort(sc, 0x19, 0x4bb9);
+        MP_WritePhyUshort(sc, 0x15, 0x03ba);
+        MP_WritePhyUshort(sc, 0x19, 0x6a80);
+        MP_WritePhyUshort(sc, 0x15, 0x03bb);
+        MP_WritePhyUshort(sc, 0x19, 0x4b29);
+        MP_WritePhyUshort(sc, 0x15, 0x03bc);
+        MP_WritePhyUshort(sc, 0x19, 0x4041);
+        MP_WritePhyUshort(sc, 0x15, 0x03bd);
+        MP_WritePhyUshort(sc, 0x19, 0x440a);
+        MP_WritePhyUshort(sc, 0x15, 0x03be);
+        MP_WritePhyUshort(sc, 0x19, 0x4029);
+        MP_WritePhyUshort(sc, 0x15, 0x03bf);
+        MP_WritePhyUshort(sc, 0x19, 0x4418);
+        MP_WritePhyUshort(sc, 0x15, 0x03c0);
+        MP_WritePhyUshort(sc, 0x19, 0x4090);
+        MP_WritePhyUshort(sc, 0x15, 0x03c1);
+        MP_WritePhyUshort(sc, 0x19, 0x4438);
+        MP_WritePhyUshort(sc, 0x15, 0x03c2);
+        MP_WritePhyUshort(sc, 0x19, 0x40c4);
+        MP_WritePhyUshort(sc, 0x15, 0x03c3);
+        MP_WritePhyUshort(sc, 0x19, 0x447b);
+        MP_WritePhyUshort(sc, 0x15, 0x03c4);
+        MP_WritePhyUshort(sc, 0x19, 0xb6c4);
+        MP_WritePhyUshort(sc, 0x15, 0x03c5);
+        MP_WritePhyUshort(sc, 0x19, 0x3311);
+        MP_WritePhyUshort(sc, 0x15, 0x03c6);
+        MP_WritePhyUshort(sc, 0x19, 0x9bfe);
+        MP_WritePhyUshort(sc, 0x15, 0x03c7);
+        MP_WritePhyUshort(sc, 0x19, 0x33cc);
+        MP_WritePhyUshort(sc, 0x15, 0x03c8);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x03c9);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x03ca);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x03cb);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x03cc);
+        MP_WritePhyUshort(sc, 0x19, 0x542f);
+        MP_WritePhyUshort(sc, 0x15, 0x03cd);
+        MP_WritePhyUshort(sc, 0x19, 0x499a);
+        MP_WritePhyUshort(sc, 0x15, 0x03ce);
+        MP_WritePhyUshort(sc, 0x19, 0x7c40);
+        MP_WritePhyUshort(sc, 0x15, 0x03cf);
+        MP_WritePhyUshort(sc, 0x19, 0x4c40);
+        MP_WritePhyUshort(sc, 0x15, 0x03d0);
+        MP_WritePhyUshort(sc, 0x19, 0x490a);
+        MP_WritePhyUshort(sc, 0x15, 0x03d1);
+        MP_WritePhyUshort(sc, 0x19, 0x405e);
+        MP_WritePhyUshort(sc, 0x15, 0x03d2);
+        MP_WritePhyUshort(sc, 0x19, 0x44f8);
+        MP_WritePhyUshort(sc, 0x15, 0x03d3);
+        MP_WritePhyUshort(sc, 0x19, 0x6b00);
+        MP_WritePhyUshort(sc, 0x15, 0x03d4);
+        MP_WritePhyUshort(sc, 0x19, 0xd64f);
+        MP_WritePhyUshort(sc, 0x15, 0x03d5);
+        MP_WritePhyUshort(sc, 0x19, 0x0028);
+        MP_WritePhyUshort(sc, 0x15, 0x03d6);
+        MP_WritePhyUshort(sc, 0x19, 0x3311);
+        MP_WritePhyUshort(sc, 0x15, 0x03d7);
+        MP_WritePhyUshort(sc, 0x19, 0xbd27);
+        MP_WritePhyUshort(sc, 0x15, 0x03d8);
+        MP_WritePhyUshort(sc, 0x19, 0x9cfc);
+        MP_WritePhyUshort(sc, 0x15, 0x03d9);
+        MP_WritePhyUshort(sc, 0x19, 0xc639);
+        MP_WritePhyUshort(sc, 0x15, 0x03da);
+        MP_WritePhyUshort(sc, 0x19, 0x000f);
+        MP_WritePhyUshort(sc, 0x15, 0x03db);
+        MP_WritePhyUshort(sc, 0x19, 0x9e03);
+        MP_WritePhyUshort(sc, 0x15, 0x03dc);
+        MP_WritePhyUshort(sc, 0x19, 0x7c01);
+        MP_WritePhyUshort(sc, 0x15, 0x03dd);
+        MP_WritePhyUshort(sc, 0x19, 0x4c01);
+        MP_WritePhyUshort(sc, 0x15, 0x03de);
+        MP_WritePhyUshort(sc, 0x19, 0x9af6);
+        MP_WritePhyUshort(sc, 0x15, 0x03df);
+        MP_WritePhyUshort(sc, 0x19, 0x7c12);
+        MP_WritePhyUshort(sc, 0x15, 0x03e0);
+        MP_WritePhyUshort(sc, 0x19, 0x4c52);
+        MP_WritePhyUshort(sc, 0x15, 0x03e1);
+        MP_WritePhyUshort(sc, 0x19, 0x4470);
+        MP_WritePhyUshort(sc, 0x15, 0x03e2);
+        MP_WritePhyUshort(sc, 0x19, 0x7c12);
+        MP_WritePhyUshort(sc, 0x15, 0x03e3);
+        MP_WritePhyUshort(sc, 0x19, 0x4c40);
+        MP_WritePhyUshort(sc, 0x15, 0x03e4);
+        MP_WritePhyUshort(sc, 0x19, 0x33d4);
+        MP_WritePhyUshort(sc, 0x15, 0x03e5);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x03e6);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x03e7);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x03e8);
+        MP_WritePhyUshort(sc, 0x19, 0x0000);
+        MP_WritePhyUshort(sc, 0x15, 0x03e9);
+        MP_WritePhyUshort(sc, 0x19, 0x49bb);
+        MP_WritePhyUshort(sc, 0x15, 0x03ea);
+        MP_WritePhyUshort(sc, 0x19, 0x4478);
+        MP_WritePhyUshort(sc, 0x15, 0x03eb);
+        MP_WritePhyUshort(sc, 0x19, 0x492b);
+        MP_WritePhyUshort(sc, 0x15, 0x03ec);
+        MP_WritePhyUshort(sc, 0x19, 0x6b80);
+        MP_WritePhyUshort(sc, 0x15, 0x03ed);
+        MP_WritePhyUshort(sc, 0x19, 0x7c01);
+        MP_WritePhyUshort(sc, 0x15, 0x03ee);
+        MP_WritePhyUshort(sc, 0x19, 0x4c00);
+        MP_WritePhyUshort(sc, 0x15, 0x03ef);
+        MP_WritePhyUshort(sc, 0x19, 0xd64f);
+        MP_WritePhyUshort(sc, 0x15, 0x03f0);
+        MP_WritePhyUshort(sc, 0x19, 0x000d);
+        MP_WritePhyUshort(sc, 0x15, 0x03f1);
+        MP_WritePhyUshort(sc, 0x19, 0x3311);
+        MP_WritePhyUshort(sc, 0x15, 0x03f2);
+        MP_WritePhyUshort(sc, 0x19, 0xbd0c);
+        MP_WritePhyUshort(sc, 0x15, 0x03f3);
+        MP_WritePhyUshort(sc, 0x19, 0xc428);
+        MP_WritePhyUshort(sc, 0x15, 0x03f4);
+        MP_WritePhyUshort(sc, 0x19, 0x0008);
+        MP_WritePhyUshort(sc, 0x15, 0x03f5);
+        MP_WritePhyUshort(sc, 0x19, 0x9afa);
+        MP_WritePhyUshort(sc, 0x15, 0x03f6);
+        MP_WritePhyUshort(sc, 0x19, 0x7c12);
+        MP_WritePhyUshort(sc, 0x15, 0x03f7);
+        MP_WritePhyUshort(sc, 0x19, 0x4c52);
+        MP_WritePhyUshort(sc, 0x15, 0x03f8);
+        MP_WritePhyUshort(sc, 0x19, 0x4470);
+        MP_WritePhyUshort(sc, 0x15, 0x03f9);
+        MP_WritePhyUshort(sc, 0x19, 0x7c12);
+        MP_WritePhyUshort(sc, 0x15, 0x03fa);
+        MP_WritePhyUshort(sc, 0x19, 0x4c40);
+        MP_WritePhyUshort(sc, 0x15, 0x03fb);
+        MP_WritePhyUshort(sc, 0x19, 0x33ef);
+        MP_WritePhyUshort(sc, 0x15, 0x03fc);
+        MP_WritePhyUshort(sc, 0x19, 0x3342);
+        MP_WritePhyUshort(sc, 0x15, 0x03fd);
+        MP_WritePhyUshort(sc, 0x19, 0x330d);
+        MP_WritePhyUshort(sc, 0x15, 0x03fe);
+        MP_WritePhyUshort(sc, 0x19, 0x32ae);
+        MP_WritePhyUshort(sc, 0x15, 0x0000);
+        MP_WritePhyUshort(sc, 0x16, 0x0306);
+        MP_WritePhyUshort(sc, 0x16, 0x0300);
+        MP_WritePhyUshort(sc, 0x1f, 0x0002);
+        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+        MP_WritePhyUshort(sc, 0x1f, 0x0005);
+        MP_WritePhyUshort(sc, 0x05, 0xfff6);
+        MP_WritePhyUshort(sc, 0x06, 0x0080);
+        MP_WritePhyUshort(sc, 0x05, 0x8000);
+        MP_WritePhyUshort(sc, 0x06, 0x0280);
+        MP_WritePhyUshort(sc, 0x06, 0x48f7);
+        MP_WritePhyUshort(sc, 0x06, 0x00e0);
+        MP_WritePhyUshort(sc, 0x06, 0xfff7);
+        MP_WritePhyUshort(sc, 0x06, 0xa080);
+        MP_WritePhyUshort(sc, 0x06, 0x02ae);
+        MP_WritePhyUshort(sc, 0x06, 0xf602);
+        MP_WritePhyUshort(sc, 0x06, 0x0112);
+        MP_WritePhyUshort(sc, 0x06, 0x0201);
+        MP_WritePhyUshort(sc, 0x06, 0x1f02);
+        MP_WritePhyUshort(sc, 0x06, 0x012c);
+        MP_WritePhyUshort(sc, 0x06, 0x0201);
+        MP_WritePhyUshort(sc, 0x06, 0x3c02);
+        MP_WritePhyUshort(sc, 0x06, 0x0156);
+        MP_WritePhyUshort(sc, 0x06, 0x0201);
+        MP_WritePhyUshort(sc, 0x06, 0x6d02);
+        MP_WritePhyUshort(sc, 0x06, 0x809d);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x88e1);
+        MP_WritePhyUshort(sc, 0x06, 0x8b89);
+        MP_WritePhyUshort(sc, 0x06, 0x1e01);
+        MP_WritePhyUshort(sc, 0x06, 0xe18b);
+        MP_WritePhyUshort(sc, 0x06, 0x8a1e);
+        MP_WritePhyUshort(sc, 0x06, 0x01e1);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8b);
+        MP_WritePhyUshort(sc, 0x06, 0x1e01);
+        MP_WritePhyUshort(sc, 0x06, 0xe18b);
+        MP_WritePhyUshort(sc, 0x06, 0x8c1e);
+        MP_WritePhyUshort(sc, 0x06, 0x01e1);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8d);
+        MP_WritePhyUshort(sc, 0x06, 0x1e01);
+        MP_WritePhyUshort(sc, 0x06, 0xe18b);
+        MP_WritePhyUshort(sc, 0x06, 0x8e1e);
+        MP_WritePhyUshort(sc, 0x06, 0x01a0);
+        MP_WritePhyUshort(sc, 0x06, 0x00c7);
+        MP_WritePhyUshort(sc, 0x06, 0xaebb);
+        MP_WritePhyUshort(sc, 0x06, 0xd100);
+        MP_WritePhyUshort(sc, 0x06, 0xbf82);
+        MP_WritePhyUshort(sc, 0x06, 0xc702);
+        MP_WritePhyUshort(sc, 0x06, 0x320a);
+        MP_WritePhyUshort(sc, 0x06, 0xd105);
+        MP_WritePhyUshort(sc, 0x06, 0xbf82);
+        MP_WritePhyUshort(sc, 0x06, 0xcd02);
+        MP_WritePhyUshort(sc, 0x06, 0x320a);
+        MP_WritePhyUshort(sc, 0x06, 0xd100);
+        MP_WritePhyUshort(sc, 0x06, 0xbf82);
+        MP_WritePhyUshort(sc, 0x06, 0xca02);
+        MP_WritePhyUshort(sc, 0x06, 0x320a);
+        MP_WritePhyUshort(sc, 0x06, 0xd105);
+        MP_WritePhyUshort(sc, 0x06, 0xbf82);
+        MP_WritePhyUshort(sc, 0x06, 0xd002);
+        MP_WritePhyUshort(sc, 0x06, 0x320a);
+        MP_WritePhyUshort(sc, 0x06, 0xd481);
+        MP_WritePhyUshort(sc, 0x06, 0xc9e4);
+        MP_WritePhyUshort(sc, 0x06, 0x8b90);
+        MP_WritePhyUshort(sc, 0x06, 0xe58b);
+        MP_WritePhyUshort(sc, 0x06, 0x91d4);
+        MP_WritePhyUshort(sc, 0x06, 0x81b8);
+        MP_WritePhyUshort(sc, 0x06, 0xe48b);
+        MP_WritePhyUshort(sc, 0x06, 0x92e5);
+        MP_WritePhyUshort(sc, 0x06, 0x8b93);
+        MP_WritePhyUshort(sc, 0x06, 0xbf8b);
+        MP_WritePhyUshort(sc, 0x06, 0x88ec);
+        MP_WritePhyUshort(sc, 0x06, 0x0019);
+        MP_WritePhyUshort(sc, 0x06, 0xa98b);
+        MP_WritePhyUshort(sc, 0x06, 0x90f9);
+        MP_WritePhyUshort(sc, 0x06, 0xeeff);
+        MP_WritePhyUshort(sc, 0x06, 0xf600);
+        MP_WritePhyUshort(sc, 0x06, 0xeeff);
+        MP_WritePhyUshort(sc, 0x06, 0xf7fc);
+        MP_WritePhyUshort(sc, 0x06, 0xd100);
+        MP_WritePhyUshort(sc, 0x06, 0xbf82);
+        MP_WritePhyUshort(sc, 0x06, 0xc102);
+        MP_WritePhyUshort(sc, 0x06, 0x320a);
+        MP_WritePhyUshort(sc, 0x06, 0xd101);
+        MP_WritePhyUshort(sc, 0x06, 0xbf82);
+        MP_WritePhyUshort(sc, 0x06, 0xc402);
+        MP_WritePhyUshort(sc, 0x06, 0x320a);
+        MP_WritePhyUshort(sc, 0x06, 0x04f8);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x8ead);
+        MP_WritePhyUshort(sc, 0x06, 0x201a);
+        MP_WritePhyUshort(sc, 0x06, 0xf620);
+        MP_WritePhyUshort(sc, 0x06, 0xe48b);
+        MP_WritePhyUshort(sc, 0x06, 0x8e02);
+        MP_WritePhyUshort(sc, 0x06, 0x824b);
+        MP_WritePhyUshort(sc, 0x06, 0x0281);
+        MP_WritePhyUshort(sc, 0x06, 0x1902);
+        MP_WritePhyUshort(sc, 0x06, 0x2c9d);
+        MP_WritePhyUshort(sc, 0x06, 0x0203);
+        MP_WritePhyUshort(sc, 0x06, 0x9602);
+        MP_WritePhyUshort(sc, 0x06, 0x0473);
+        MP_WritePhyUshort(sc, 0x06, 0x022e);
+        MP_WritePhyUshort(sc, 0x06, 0x3902);
+        MP_WritePhyUshort(sc, 0x06, 0x044d);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x8ead);
+        MP_WritePhyUshort(sc, 0x06, 0x210b);
+        MP_WritePhyUshort(sc, 0x06, 0xf621);
+        MP_WritePhyUshort(sc, 0x06, 0xe48b);
+        MP_WritePhyUshort(sc, 0x06, 0x8e02);
+        MP_WritePhyUshort(sc, 0x06, 0x0416);
+        MP_WritePhyUshort(sc, 0x06, 0x021b);
+        MP_WritePhyUshort(sc, 0x06, 0xa4e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8e);
+        MP_WritePhyUshort(sc, 0x06, 0xad22);
+        MP_WritePhyUshort(sc, 0x06, 0x05f6);
+        MP_WritePhyUshort(sc, 0x06, 0x22e4);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8e);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x8ead);
+        MP_WritePhyUshort(sc, 0x06, 0x2305);
+        MP_WritePhyUshort(sc, 0x06, 0xf623);
+        MP_WritePhyUshort(sc, 0x06, 0xe48b);
+        MP_WritePhyUshort(sc, 0x06, 0x8ee0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8e);
+        MP_WritePhyUshort(sc, 0x06, 0xad24);
+        MP_WritePhyUshort(sc, 0x06, 0x05f6);
+        MP_WritePhyUshort(sc, 0x06, 0x24e4);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8e);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x8ead);
+        MP_WritePhyUshort(sc, 0x06, 0x2505);
+        MP_WritePhyUshort(sc, 0x06, 0xf625);
+        MP_WritePhyUshort(sc, 0x06, 0xe48b);
+        MP_WritePhyUshort(sc, 0x06, 0x8ee0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8e);
+        MP_WritePhyUshort(sc, 0x06, 0xad26);
+        MP_WritePhyUshort(sc, 0x06, 0x08f6);
+        MP_WritePhyUshort(sc, 0x06, 0x26e4);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8e);
+        MP_WritePhyUshort(sc, 0x06, 0x0281);
+        MP_WritePhyUshort(sc, 0x06, 0xdae0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8e);
+        MP_WritePhyUshort(sc, 0x06, 0xad27);
+        MP_WritePhyUshort(sc, 0x06, 0x05f6);
+        MP_WritePhyUshort(sc, 0x06, 0x27e4);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8e);
+        MP_WritePhyUshort(sc, 0x06, 0x0203);
+        MP_WritePhyUshort(sc, 0x06, 0x5cfc);
+        MP_WritePhyUshort(sc, 0x06, 0x04f8);
+        MP_WritePhyUshort(sc, 0x06, 0xfaef);
+        MP_WritePhyUshort(sc, 0x06, 0x69e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b85);
+        MP_WritePhyUshort(sc, 0x06, 0xad21);
+        MP_WritePhyUshort(sc, 0x06, 0x57e0);
+        MP_WritePhyUshort(sc, 0x06, 0xe022);
+        MP_WritePhyUshort(sc, 0x06, 0xe1e0);
+        MP_WritePhyUshort(sc, 0x06, 0x2358);
+        MP_WritePhyUshort(sc, 0x06, 0xc059);
+        MP_WritePhyUshort(sc, 0x06, 0x021e);
+        MP_WritePhyUshort(sc, 0x06, 0x01e1);
+        MP_WritePhyUshort(sc, 0x06, 0x8b3c);
+        MP_WritePhyUshort(sc, 0x06, 0x1f10);
+        MP_WritePhyUshort(sc, 0x06, 0x9e44);
+        MP_WritePhyUshort(sc, 0x06, 0xe48b);
+        MP_WritePhyUshort(sc, 0x06, 0x3cad);
+        MP_WritePhyUshort(sc, 0x06, 0x211d);
+        MP_WritePhyUshort(sc, 0x06, 0xe18b);
+        MP_WritePhyUshort(sc, 0x06, 0x84f7);
+        MP_WritePhyUshort(sc, 0x06, 0x29e5);
+        MP_WritePhyUshort(sc, 0x06, 0x8b84);
+        MP_WritePhyUshort(sc, 0x06, 0xac27);
+        MP_WritePhyUshort(sc, 0x06, 0x0dac);
+        MP_WritePhyUshort(sc, 0x06, 0x2605);
+        MP_WritePhyUshort(sc, 0x06, 0x0281);
+        MP_WritePhyUshort(sc, 0x06, 0x7fae);
+        MP_WritePhyUshort(sc, 0x06, 0x2b02);
+        MP_WritePhyUshort(sc, 0x06, 0x2c23);
+        MP_WritePhyUshort(sc, 0x06, 0xae26);
+        MP_WritePhyUshort(sc, 0x06, 0x022c);
+        MP_WritePhyUshort(sc, 0x06, 0x41ae);
+        MP_WritePhyUshort(sc, 0x06, 0x21e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b87);
+        MP_WritePhyUshort(sc, 0x06, 0xad22);
+        MP_WritePhyUshort(sc, 0x06, 0x18e0);
+        MP_WritePhyUshort(sc, 0x06, 0xfff7);
+        MP_WritePhyUshort(sc, 0x06, 0x58fc);
+        MP_WritePhyUshort(sc, 0x06, 0xe4ff);
+        MP_WritePhyUshort(sc, 0x06, 0xf7d1);
+        MP_WritePhyUshort(sc, 0x06, 0x00bf);
+        MP_WritePhyUshort(sc, 0x06, 0x2eee);
+        MP_WritePhyUshort(sc, 0x06, 0x0232);
+        MP_WritePhyUshort(sc, 0x06, 0x0ad1);
+        MP_WritePhyUshort(sc, 0x06, 0x00bf);
+        MP_WritePhyUshort(sc, 0x06, 0x82e8);
+        MP_WritePhyUshort(sc, 0x06, 0x0232);
+        MP_WritePhyUshort(sc, 0x06, 0x0a02);
+        MP_WritePhyUshort(sc, 0x06, 0x2bdf);
+        MP_WritePhyUshort(sc, 0x06, 0xef96);
+        MP_WritePhyUshort(sc, 0x06, 0xfefc);
+        MP_WritePhyUshort(sc, 0x06, 0x04d0);
+        MP_WritePhyUshort(sc, 0x06, 0x0202);
+        MP_WritePhyUshort(sc, 0x06, 0x1e97);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x87ad);
+        MP_WritePhyUshort(sc, 0x06, 0x2228);
+        MP_WritePhyUshort(sc, 0x06, 0xd100);
+        MP_WritePhyUshort(sc, 0x06, 0xbf82);
+        MP_WritePhyUshort(sc, 0x06, 0xd302);
+        MP_WritePhyUshort(sc, 0x06, 0x320a);
+        MP_WritePhyUshort(sc, 0x06, 0xd10c);
+        MP_WritePhyUshort(sc, 0x06, 0xbf82);
+        MP_WritePhyUshort(sc, 0x06, 0xd602);
+        MP_WritePhyUshort(sc, 0x06, 0x320a);
+        MP_WritePhyUshort(sc, 0x06, 0xd104);
+        MP_WritePhyUshort(sc, 0x06, 0xbf82);
+        MP_WritePhyUshort(sc, 0x06, 0xd902);
+        MP_WritePhyUshort(sc, 0x06, 0x320a);
+        MP_WritePhyUshort(sc, 0x06, 0xd101);
+        MP_WritePhyUshort(sc, 0x06, 0xbf82);
+        MP_WritePhyUshort(sc, 0x06, 0xe802);
+        MP_WritePhyUshort(sc, 0x06, 0x320a);
+        MP_WritePhyUshort(sc, 0x06, 0xe0ff);
+        MP_WritePhyUshort(sc, 0x06, 0xf768);
+        MP_WritePhyUshort(sc, 0x06, 0x03e4);
+        MP_WritePhyUshort(sc, 0x06, 0xfff7);
+        MP_WritePhyUshort(sc, 0x06, 0xd004);
+        MP_WritePhyUshort(sc, 0x06, 0x0228);
+        MP_WritePhyUshort(sc, 0x06, 0x7a04);
+        MP_WritePhyUshort(sc, 0x06, 0xf8e0);
+        MP_WritePhyUshort(sc, 0x06, 0xe234);
+        MP_WritePhyUshort(sc, 0x06, 0xe1e2);
+        MP_WritePhyUshort(sc, 0x06, 0x35f6);
+        MP_WritePhyUshort(sc, 0x06, 0x2be4);
+        MP_WritePhyUshort(sc, 0x06, 0xe234);
+        MP_WritePhyUshort(sc, 0x06, 0xe5e2);
+        MP_WritePhyUshort(sc, 0x06, 0x35fc);
+        MP_WritePhyUshort(sc, 0x06, 0x05f8);
+        MP_WritePhyUshort(sc, 0x06, 0xe0e2);
+        MP_WritePhyUshort(sc, 0x06, 0x34e1);
+        MP_WritePhyUshort(sc, 0x06, 0xe235);
+        MP_WritePhyUshort(sc, 0x06, 0xf72b);
+        MP_WritePhyUshort(sc, 0x06, 0xe4e2);
+        MP_WritePhyUshort(sc, 0x06, 0x34e5);
+        MP_WritePhyUshort(sc, 0x06, 0xe235);
+        MP_WritePhyUshort(sc, 0x06, 0xfc05);
+        MP_WritePhyUshort(sc, 0x06, 0xf8f9);
+        MP_WritePhyUshort(sc, 0x06, 0xfaef);
+        MP_WritePhyUshort(sc, 0x06, 0x69ac);
+        MP_WritePhyUshort(sc, 0x06, 0x1b4c);
+        MP_WritePhyUshort(sc, 0x06, 0xbf2e);
+        MP_WritePhyUshort(sc, 0x06, 0x3002);
+        MP_WritePhyUshort(sc, 0x06, 0x31dd);
+        MP_WritePhyUshort(sc, 0x06, 0xef01);
+        MP_WritePhyUshort(sc, 0x06, 0xe28a);
+        MP_WritePhyUshort(sc, 0x06, 0x76e4);
+        MP_WritePhyUshort(sc, 0x06, 0x8a76);
+        MP_WritePhyUshort(sc, 0x06, 0x1f12);
+        MP_WritePhyUshort(sc, 0x06, 0x9e3a);
+        MP_WritePhyUshort(sc, 0x06, 0xef12);
+        MP_WritePhyUshort(sc, 0x06, 0x5907);
+        MP_WritePhyUshort(sc, 0x06, 0x9f12);
+        MP_WritePhyUshort(sc, 0x06, 0xf8e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b40);
+        MP_WritePhyUshort(sc, 0x06, 0xf721);
+        MP_WritePhyUshort(sc, 0x06, 0xe48b);
+        MP_WritePhyUshort(sc, 0x06, 0x40d0);
+        MP_WritePhyUshort(sc, 0x06, 0x0302);
+        MP_WritePhyUshort(sc, 0x06, 0x287a);
+        MP_WritePhyUshort(sc, 0x06, 0x0282);
+        MP_WritePhyUshort(sc, 0x06, 0x34fc);
+        MP_WritePhyUshort(sc, 0x06, 0xa000);
+        MP_WritePhyUshort(sc, 0x06, 0x1002);
+        MP_WritePhyUshort(sc, 0x06, 0x2dc3);
+        MP_WritePhyUshort(sc, 0x06, 0x022e);
+        MP_WritePhyUshort(sc, 0x06, 0x21e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b40);
+        MP_WritePhyUshort(sc, 0x06, 0xf621);
+        MP_WritePhyUshort(sc, 0x06, 0xe48b);
+        MP_WritePhyUshort(sc, 0x06, 0x40ae);
+        MP_WritePhyUshort(sc, 0x06, 0x0fbf);
+        MP_WritePhyUshort(sc, 0x06, 0x3fa5);
+        MP_WritePhyUshort(sc, 0x06, 0x0231);
+        MP_WritePhyUshort(sc, 0x06, 0x6cbf);
+        MP_WritePhyUshort(sc, 0x06, 0x3fa2);
+        MP_WritePhyUshort(sc, 0x06, 0x0231);
+        MP_WritePhyUshort(sc, 0x06, 0x6c02);
+        MP_WritePhyUshort(sc, 0x06, 0x2dc3);
+        MP_WritePhyUshort(sc, 0x06, 0xef96);
+        MP_WritePhyUshort(sc, 0x06, 0xfefd);
+        MP_WritePhyUshort(sc, 0x06, 0xfc04);
+        MP_WritePhyUshort(sc, 0x06, 0xf8e0);
+        MP_WritePhyUshort(sc, 0x06, 0xe2f4);
+        MP_WritePhyUshort(sc, 0x06, 0xe1e2);
+        MP_WritePhyUshort(sc, 0x06, 0xf5e4);
+        MP_WritePhyUshort(sc, 0x06, 0x8a78);
+        MP_WritePhyUshort(sc, 0x06, 0xe58a);
+        MP_WritePhyUshort(sc, 0x06, 0x79ee);
+        MP_WritePhyUshort(sc, 0x06, 0xe2f4);
+        MP_WritePhyUshort(sc, 0x06, 0xd8ee);
+        MP_WritePhyUshort(sc, 0x06, 0xe2f5);
+        MP_WritePhyUshort(sc, 0x06, 0x20fc);
+        MP_WritePhyUshort(sc, 0x06, 0x04f8);
+        MP_WritePhyUshort(sc, 0x06, 0xf9fa);
+        MP_WritePhyUshort(sc, 0x06, 0xef69);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x87ad);
+        MP_WritePhyUshort(sc, 0x06, 0x2065);
+        MP_WritePhyUshort(sc, 0x06, 0xd200);
+        MP_WritePhyUshort(sc, 0x06, 0xbf2e);
+        MP_WritePhyUshort(sc, 0x06, 0xe802);
+        MP_WritePhyUshort(sc, 0x06, 0x31dd);
+        MP_WritePhyUshort(sc, 0x06, 0x1e21);
+        MP_WritePhyUshort(sc, 0x06, 0xbf82);
+        MP_WritePhyUshort(sc, 0x06, 0xdf02);
+        MP_WritePhyUshort(sc, 0x06, 0x31dd);
+        MP_WritePhyUshort(sc, 0x06, 0x0c11);
+        MP_WritePhyUshort(sc, 0x06, 0x1e21);
+        MP_WritePhyUshort(sc, 0x06, 0xbf82);
+        MP_WritePhyUshort(sc, 0x06, 0xe202);
+        MP_WritePhyUshort(sc, 0x06, 0x31dd);
+        MP_WritePhyUshort(sc, 0x06, 0x0c12);
+        MP_WritePhyUshort(sc, 0x06, 0x1e21);
+        MP_WritePhyUshort(sc, 0x06, 0xbf82);
+        MP_WritePhyUshort(sc, 0x06, 0xe502);
+        MP_WritePhyUshort(sc, 0x06, 0x31dd);
+        MP_WritePhyUshort(sc, 0x06, 0x0c13);
+        MP_WritePhyUshort(sc, 0x06, 0x1e21);
+        MP_WritePhyUshort(sc, 0x06, 0xbf1f);
+        MP_WritePhyUshort(sc, 0x06, 0x5302);
+        MP_WritePhyUshort(sc, 0x06, 0x31dd);
+        MP_WritePhyUshort(sc, 0x06, 0x0c14);
+        MP_WritePhyUshort(sc, 0x06, 0x1e21);
+        MP_WritePhyUshort(sc, 0x06, 0xbf82);
+        MP_WritePhyUshort(sc, 0x06, 0xeb02);
+        MP_WritePhyUshort(sc, 0x06, 0x31dd);
+        MP_WritePhyUshort(sc, 0x06, 0x0c16);
+        MP_WritePhyUshort(sc, 0x06, 0x1e21);
+        MP_WritePhyUshort(sc, 0x06, 0xe083);
+        MP_WritePhyUshort(sc, 0x06, 0xe01f);
+        MP_WritePhyUshort(sc, 0x06, 0x029e);
+        MP_WritePhyUshort(sc, 0x06, 0x22e6);
+        MP_WritePhyUshort(sc, 0x06, 0x83e0);
+        MP_WritePhyUshort(sc, 0x06, 0xad31);
+        MP_WritePhyUshort(sc, 0x06, 0x14ad);
+        MP_WritePhyUshort(sc, 0x06, 0x3011);
+        MP_WritePhyUshort(sc, 0x06, 0xef02);
+        MP_WritePhyUshort(sc, 0x06, 0x580c);
+        MP_WritePhyUshort(sc, 0x06, 0x9e07);
+        MP_WritePhyUshort(sc, 0x06, 0xad36);
+        MP_WritePhyUshort(sc, 0x06, 0x085a);
+        MP_WritePhyUshort(sc, 0x06, 0x309f);
+        MP_WritePhyUshort(sc, 0x06, 0x04d1);
+        MP_WritePhyUshort(sc, 0x06, 0x01ae);
+        MP_WritePhyUshort(sc, 0x06, 0x02d1);
+        MP_WritePhyUshort(sc, 0x06, 0x00bf);
+        MP_WritePhyUshort(sc, 0x06, 0x82dc);
+        MP_WritePhyUshort(sc, 0x06, 0x0232);
+        MP_WritePhyUshort(sc, 0x06, 0x0aef);
+        MP_WritePhyUshort(sc, 0x06, 0x96fe);
+        MP_WritePhyUshort(sc, 0x06, 0xfdfc);
+        MP_WritePhyUshort(sc, 0x06, 0x0400);
+        MP_WritePhyUshort(sc, 0x06, 0xe140);
+        MP_WritePhyUshort(sc, 0x06, 0x77e1);
+        MP_WritePhyUshort(sc, 0x06, 0x4010);
+        MP_WritePhyUshort(sc, 0x06, 0xe150);
+        MP_WritePhyUshort(sc, 0x06, 0x32e1);
+        MP_WritePhyUshort(sc, 0x06, 0x5030);
+        MP_WritePhyUshort(sc, 0x06, 0xe144);
+        MP_WritePhyUshort(sc, 0x06, 0x74e1);
+        MP_WritePhyUshort(sc, 0x06, 0x44bb);
+        MP_WritePhyUshort(sc, 0x06, 0xe2d2);
+        MP_WritePhyUshort(sc, 0x06, 0x40e0);
+        MP_WritePhyUshort(sc, 0x06, 0x2cfc);
+        MP_WritePhyUshort(sc, 0x06, 0xe2cc);
+        MP_WritePhyUshort(sc, 0x06, 0xcce2);
+        MP_WritePhyUshort(sc, 0x06, 0x00cc);
+        MP_WritePhyUshort(sc, 0x06, 0xe000);
+        MP_WritePhyUshort(sc, 0x06, 0x99e0);
+        MP_WritePhyUshort(sc, 0x06, 0x3688);
+        MP_WritePhyUshort(sc, 0x06, 0xe036);
+        MP_WritePhyUshort(sc, 0x06, 0x99e1);
+        MP_WritePhyUshort(sc, 0x06, 0x40dd);
+        MP_WritePhyUshort(sc, 0x06, 0xe022);
+        MP_WritePhyUshort(sc, 0x05, 0xe142);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x06);
+        PhyRegValue |= BIT_0;
+        MP_WritePhyUshort(sc, 0x06, PhyRegValue);
+        MP_WritePhyUshort(sc, 0x05, 0xe140);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x06);
+        PhyRegValue |= BIT_0;
+        MP_WritePhyUshort(sc, 0x06, PhyRegValue);
+        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+        MP_WritePhyUshort(sc, 0x1f, 0x0005);
+        for (i = 0; i < 200; i++) {
+                DELAY(100);
+                PhyRegValue = MP_ReadPhyUshort(sc, 0x00);
+                if (PhyRegValue & BIT_7)
+                        break;
+        }
+
+        MP_WritePhyUshort(sc, 0x1F, 0x0001);
+        MP_WritePhyUshort(sc, 0x0B, 0x6C14);
+        MP_WritePhyUshort(sc, 0x14, 0x7F3D);
+        MP_WritePhyUshort(sc, 0x1C, 0xFAFE);
+        MP_WritePhyUshort(sc, 0x08, 0x07C5);
+        MP_WritePhyUshort(sc, 0x10, 0xF090);
+        MP_WritePhyUshort(sc, 0x1F, 0x0003);
+        MP_WritePhyUshort(sc, 0x14, 0x641A);
+        MP_WritePhyUshort(sc, 0x1A, 0x0606);
+        MP_WritePhyUshort(sc, 0x12, 0xF480);
+        MP_WritePhyUshort(sc, 0x13, 0x0747);
+        MP_WritePhyUshort(sc, 0x1F, 0x0000);
+
+        MP_WritePhyUshort(sc, 0x1F, 0x0003);
+        MP_WritePhyUshort(sc, 0x0D, 0x0207);
+        MP_WritePhyUshort(sc, 0x02, 0x5FD0);
+        MP_WritePhyUshort(sc, 0x1F, 0x0000);
+
+        MP_WritePhyUshort(sc, 0x1F, 0x0003);
+        MP_WritePhyUshort(sc, 0x09, 0xA20F);
+        MP_WritePhyUshort(sc, 0x1F, 0x0000);
+
+        MP_WritePhyUshort(sc, 0x1f, 0x0003);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x19);
+        PhyRegValue &= ~BIT_0;
+        MP_WritePhyUshort(sc, 0x19, PhyRegValue);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
+        PhyRegValue &= ~BIT_10;
+        MP_WritePhyUshort(sc, 0x10, PhyRegValue);
+        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+
+        MP_WritePhyUshort(sc, 0x1f, 0x0004);
+        MP_WritePhyUshort(sc, 0x1f, 0x0007);
+        MP_WritePhyUshort(sc, 0x1e, 0x0023);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
+        PhyRegValue &= ~BIT_0;
+        PhyRegValue |= BIT_2;
+        MP_WritePhyUshort(sc, 0x17, PhyRegValue);
+        MP_WritePhyUshort(sc, 0x1f, 0x0002);
+        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+}
+
+static void re_set_phy_mcu_8168evl_2(struct re_softc *sc)
+{
+        u_int16_t PhyRegValue;
+        int i;
+
+        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+        MP_WritePhyUshort(sc, 0x00, 0x1800);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x15);
+        PhyRegValue &= ~(BIT_12);
+        MP_WritePhyUshort(sc, 0x15, PhyRegValue);
+        MP_WritePhyUshort(sc, 0x00, 0x4800);
+        MP_WritePhyUshort(sc, 0x1f, 0x0007);
+        MP_WritePhyUshort(sc, 0x1e, 0x002f);
+        for (i = 0; i < 1000; i++) {
+                if (MP_ReadPhyUshort(sc, 0x1c) & BIT_7)
+                        break;
+                DELAY(100);
+        }
+        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+        MP_WritePhyUshort(sc, 0x00, 0x1800);
+        MP_WritePhyUshort(sc, 0x1f, 0x0007);
+        MP_WritePhyUshort(sc, 0x1e, 0x0023);
+        for (i = 0; i < 200; i++) {
+                if ((MP_ReadPhyUshort(sc, 0x17) & BIT_0) == 0)
+                        break;
+                DELAY(100);
+        }
+        MP_WritePhyUshort(sc, 0x1f, 0x0005);
+        MP_WritePhyUshort(sc, 0x05, 0xfff6);
+        MP_WritePhyUshort(sc, 0x06, 0x0080);
+        MP_WritePhyUshort(sc, 0x1f, 0x0007);
+        MP_WritePhyUshort(sc, 0x1e, 0x0023);
+        MP_WritePhyUshort(sc, 0x16, 0x0306);
+        MP_WritePhyUshort(sc, 0x16, 0x0307);
+        MP_WritePhyUshort(sc, 0x15, 0x00AF);
+        MP_WritePhyUshort(sc, 0x19, 0x4060);
+        MP_WritePhyUshort(sc, 0x15, 0x00B0);
+        MP_WritePhyUshort(sc, 0x19, 0x7800);
+        MP_WritePhyUshort(sc, 0x15, 0x00B1);
+        MP_WritePhyUshort(sc, 0x19, 0x7e00);
+        MP_WritePhyUshort(sc, 0x15, 0x00B2);
+        MP_WritePhyUshort(sc, 0x19, 0x72B0);
+        MP_WritePhyUshort(sc, 0x15, 0x00B3);
+        MP_WritePhyUshort(sc, 0x19, 0x7F00);
+        MP_WritePhyUshort(sc, 0x15, 0x00B4);
+        MP_WritePhyUshort(sc, 0x19, 0x73B0);
+        MP_WritePhyUshort(sc, 0x15, 0x0101);
+        MP_WritePhyUshort(sc, 0x19, 0x0005);
+        MP_WritePhyUshort(sc, 0x15, 0x0103);
+        MP_WritePhyUshort(sc, 0x19, 0x0003);
+        MP_WritePhyUshort(sc, 0x15, 0x0105);
+        MP_WritePhyUshort(sc, 0x19, 0x30FD);
+        MP_WritePhyUshort(sc, 0x15, 0x0106);
+        MP_WritePhyUshort(sc, 0x19, 0x9DF7);
+        MP_WritePhyUshort(sc, 0x15, 0x0107);
+        MP_WritePhyUshort(sc, 0x19, 0x30C6);
+        MP_WritePhyUshort(sc, 0x15, 0x0098);
+        MP_WritePhyUshort(sc, 0x19, 0x7c0b);
+        MP_WritePhyUshort(sc, 0x15, 0x0099);
+        MP_WritePhyUshort(sc, 0x19, 0x6c0b);
+        MP_WritePhyUshort(sc, 0x15, 0x00eb);
+        MP_WritePhyUshort(sc, 0x19, 0x6c0b);
+        MP_WritePhyUshort(sc, 0x15, 0x00f8);
+        MP_WritePhyUshort(sc, 0x19, 0x6f0b);
+        MP_WritePhyUshort(sc, 0x15, 0x00fe);
+        MP_WritePhyUshort(sc, 0x19, 0x6f0f);
+        MP_WritePhyUshort(sc, 0x15, 0x00db);
+        MP_WritePhyUshort(sc, 0x19, 0x6f09);
+        MP_WritePhyUshort(sc, 0x15, 0x00dc);
+        MP_WritePhyUshort(sc, 0x19, 0xaefd);
+        MP_WritePhyUshort(sc, 0x15, 0x00dd);
+        MP_WritePhyUshort(sc, 0x19, 0x6f0b);
+        MP_WritePhyUshort(sc, 0x15, 0x00de);
+        MP_WritePhyUshort(sc, 0x19, 0xc60b);
+        MP_WritePhyUshort(sc, 0x15, 0x00df);
+        MP_WritePhyUshort(sc, 0x19, 0x00fa);
+        MP_WritePhyUshort(sc, 0x15, 0x00e0);
+        MP_WritePhyUshort(sc, 0x19, 0x30e1);
+        MP_WritePhyUshort(sc, 0x15, 0x020c);
+        MP_WritePhyUshort(sc, 0x19, 0x3224);
+        MP_WritePhyUshort(sc, 0x15, 0x020e);
+        MP_WritePhyUshort(sc, 0x19, 0x9813);
+        MP_WritePhyUshort(sc, 0x15, 0x020f);
+        MP_WritePhyUshort(sc, 0x19, 0x7801);
+        MP_WritePhyUshort(sc, 0x15, 0x0210);
+        MP_WritePhyUshort(sc, 0x19, 0x930f);
+        MP_WritePhyUshort(sc, 0x15, 0x0211);
+        MP_WritePhyUshort(sc, 0x19, 0x9206);
+        MP_WritePhyUshort(sc, 0x15, 0x0212);
+        MP_WritePhyUshort(sc, 0x19, 0x4002);
+        MP_WritePhyUshort(sc, 0x15, 0x0213);
+        MP_WritePhyUshort(sc, 0x19, 0x7800);
+        MP_WritePhyUshort(sc, 0x15, 0x0214);
+        MP_WritePhyUshort(sc, 0x19, 0x588f);
+        MP_WritePhyUshort(sc, 0x15, 0x0215);
+        MP_WritePhyUshort(sc, 0x19, 0x5520);
+        MP_WritePhyUshort(sc, 0x15, 0x0216);
+        MP_WritePhyUshort(sc, 0x19, 0x3224);
+        MP_WritePhyUshort(sc, 0x15, 0x0217);
+        MP_WritePhyUshort(sc, 0x19, 0x4002);
+        MP_WritePhyUshort(sc, 0x15, 0x0218);
+        MP_WritePhyUshort(sc, 0x19, 0x7800);
+        MP_WritePhyUshort(sc, 0x15, 0x0219);
+        MP_WritePhyUshort(sc, 0x19, 0x588d);
+        MP_WritePhyUshort(sc, 0x15, 0x021a);
+        MP_WritePhyUshort(sc, 0x19, 0x5540);
+        MP_WritePhyUshort(sc, 0x15, 0x021b);
+        MP_WritePhyUshort(sc, 0x19, 0x9e03);
+        MP_WritePhyUshort(sc, 0x15, 0x021c);
+        MP_WritePhyUshort(sc, 0x19, 0x7c40);
+        MP_WritePhyUshort(sc, 0x15, 0x021d);
+        MP_WritePhyUshort(sc, 0x19, 0x6840);
+        MP_WritePhyUshort(sc, 0x15, 0x021e);
+        MP_WritePhyUshort(sc, 0x19, 0x3224);
+        MP_WritePhyUshort(sc, 0x15, 0x021f);
+        MP_WritePhyUshort(sc, 0x19, 0x4002);
+        MP_WritePhyUshort(sc, 0x15, 0x0220);
+        MP_WritePhyUshort(sc, 0x19, 0x3224);
+        MP_WritePhyUshort(sc, 0x15, 0x0221);
+        MP_WritePhyUshort(sc, 0x19, 0x9e03);
+        MP_WritePhyUshort(sc, 0x15, 0x0222);
+        MP_WritePhyUshort(sc, 0x19, 0x7c40);
+        MP_WritePhyUshort(sc, 0x15, 0x0223);
+        MP_WritePhyUshort(sc, 0x19, 0x6840);
+        MP_WritePhyUshort(sc, 0x15, 0x0224);
+        MP_WritePhyUshort(sc, 0x19, 0x7800);
+        MP_WritePhyUshort(sc, 0x15, 0x0225);
+        MP_WritePhyUshort(sc, 0x19, 0x3231);
+        MP_WritePhyUshort(sc, 0x15, 0x0000);
+        MP_WritePhyUshort(sc, 0x16, 0x0306);
+        MP_WritePhyUshort(sc, 0x16, 0x0300);
+        MP_WritePhyUshort(sc, 0x1f, 0x0002);
+        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+        MP_WritePhyUshort(sc, 0x17, 0x2160);
+        MP_WritePhyUshort(sc, 0x1f, 0x0007);
+        MP_WritePhyUshort(sc, 0x1e, 0x0040);
+        MP_WritePhyUshort(sc, 0x18, 0x0004);
+        MP_WritePhyUshort(sc, 0x18, 0x09d4);
+        MP_WritePhyUshort(sc, 0x19, 0x4000);
+        MP_WritePhyUshort(sc, 0x18, 0x09e4);
+        MP_WritePhyUshort(sc, 0x19, 0x0800);
+        MP_WritePhyUshort(sc, 0x18, 0x09f4);
+        MP_WritePhyUshort(sc, 0x19, 0xff00);
+        MP_WritePhyUshort(sc, 0x18, 0x0a04);
+        MP_WritePhyUshort(sc, 0x19, 0x4000);
+        MP_WritePhyUshort(sc, 0x18, 0x0a14);
+        MP_WritePhyUshort(sc, 0x19, 0x0c00);
+        MP_WritePhyUshort(sc, 0x18, 0x0a24);
+        MP_WritePhyUshort(sc, 0x19, 0xff00);
+        MP_WritePhyUshort(sc, 0x18, 0x0a74);
+        MP_WritePhyUshort(sc, 0x19, 0xf600);
+        MP_WritePhyUshort(sc, 0x18, 0x1a24);
+        MP_WritePhyUshort(sc, 0x19, 0x7d00);
+        MP_WritePhyUshort(sc, 0x18, 0x1a64);
+        MP_WritePhyUshort(sc, 0x19, 0x0500);
+        MP_WritePhyUshort(sc, 0x18, 0x1a74);
+        MP_WritePhyUshort(sc, 0x19, 0x9500);
+        MP_WritePhyUshort(sc, 0x18, 0x1a84);
+        MP_WritePhyUshort(sc, 0x19, 0x8000);
+        MP_WritePhyUshort(sc, 0x18, 0x1a94);
+        MP_WritePhyUshort(sc, 0x19, 0x7d00);
+        MP_WritePhyUshort(sc, 0x18, 0x1aa4);
+        MP_WritePhyUshort(sc, 0x19, 0x9600);
+        MP_WritePhyUshort(sc, 0x18, 0x1ac4);
+        MP_WritePhyUshort(sc, 0x19, 0x4000);
+        MP_WritePhyUshort(sc, 0x18, 0x1ad4);
+        MP_WritePhyUshort(sc, 0x19, 0x0800);
+        MP_WritePhyUshort(sc, 0x18, 0x1af4);
+        MP_WritePhyUshort(sc, 0x19, 0xc400);
+        MP_WritePhyUshort(sc, 0x18, 0x1b04);
+        MP_WritePhyUshort(sc, 0x19, 0x4000);
+        MP_WritePhyUshort(sc, 0x18, 0x1b14);
+        MP_WritePhyUshort(sc, 0x19, 0x0800);
+        MP_WritePhyUshort(sc, 0x18, 0x1b24);
+        MP_WritePhyUshort(sc, 0x19, 0xfd00);
+        MP_WritePhyUshort(sc, 0x18, 0x1b34);
+        MP_WritePhyUshort(sc, 0x19, 0x4000);
+        MP_WritePhyUshort(sc, 0x18, 0x1b44);
+        MP_WritePhyUshort(sc, 0x19, 0x0400);
+        MP_WritePhyUshort(sc, 0x18, 0x1b94);
+        MP_WritePhyUshort(sc, 0x19, 0xf100);
+        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+        MP_WritePhyUshort(sc, 0x17, 0x2100);
+        MP_WritePhyUshort(sc, 0x1f, 0x0007);
+        MP_WritePhyUshort(sc, 0x1e, 0x0040);
+        MP_WritePhyUshort(sc, 0x18, 0x0000);
+        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+        MP_WritePhyUshort(sc, 0x1f, 0x0005);
+        MP_WritePhyUshort(sc, 0x05, 0xfff6);
+        MP_WritePhyUshort(sc, 0x06, 0x0080);
+        MP_WritePhyUshort(sc, 0x05, 0x8000);
+        MP_WritePhyUshort(sc, 0x06, 0x0280);
+        MP_WritePhyUshort(sc, 0x06, 0x48f7);
+        MP_WritePhyUshort(sc, 0x06, 0x00e0);
+        MP_WritePhyUshort(sc, 0x06, 0xfff7);
+        MP_WritePhyUshort(sc, 0x06, 0xa080);
+        MP_WritePhyUshort(sc, 0x06, 0x02ae);
+        MP_WritePhyUshort(sc, 0x06, 0xf602);
+        MP_WritePhyUshort(sc, 0x06, 0x0115);
+        MP_WritePhyUshort(sc, 0x06, 0x0201);
+        MP_WritePhyUshort(sc, 0x06, 0x2202);
+        MP_WritePhyUshort(sc, 0x06, 0x80a0);
+        MP_WritePhyUshort(sc, 0x06, 0x0201);
+        MP_WritePhyUshort(sc, 0x06, 0x3f02);
+        MP_WritePhyUshort(sc, 0x06, 0x0159);
+        MP_WritePhyUshort(sc, 0x06, 0x0280);
+        MP_WritePhyUshort(sc, 0x06, 0xbd02);
+        MP_WritePhyUshort(sc, 0x06, 0x80da);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x88e1);
+        MP_WritePhyUshort(sc, 0x06, 0x8b89);
+        MP_WritePhyUshort(sc, 0x06, 0x1e01);
+        MP_WritePhyUshort(sc, 0x06, 0xe18b);
+        MP_WritePhyUshort(sc, 0x06, 0x8a1e);
+        MP_WritePhyUshort(sc, 0x06, 0x01e1);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8b);
+        MP_WritePhyUshort(sc, 0x06, 0x1e01);
+        MP_WritePhyUshort(sc, 0x06, 0xe18b);
+        MP_WritePhyUshort(sc, 0x06, 0x8c1e);
+        MP_WritePhyUshort(sc, 0x06, 0x01e1);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8d);
+        MP_WritePhyUshort(sc, 0x06, 0x1e01);
+        MP_WritePhyUshort(sc, 0x06, 0xe18b);
+        MP_WritePhyUshort(sc, 0x06, 0x8e1e);
+        MP_WritePhyUshort(sc, 0x06, 0x01a0);
+        MP_WritePhyUshort(sc, 0x06, 0x00c7);
+        MP_WritePhyUshort(sc, 0x06, 0xaebb);
+        MP_WritePhyUshort(sc, 0x06, 0xd481);
+        MP_WritePhyUshort(sc, 0x06, 0xd2e4);
+        MP_WritePhyUshort(sc, 0x06, 0x8b92);
+        MP_WritePhyUshort(sc, 0x06, 0xe58b);
+        MP_WritePhyUshort(sc, 0x06, 0x93d1);
+        MP_WritePhyUshort(sc, 0x06, 0x03bf);
+        MP_WritePhyUshort(sc, 0x06, 0x859e);
+        MP_WritePhyUshort(sc, 0x06, 0x0237);
+        MP_WritePhyUshort(sc, 0x06, 0x23d1);
+        MP_WritePhyUshort(sc, 0x06, 0x02bf);
+        MP_WritePhyUshort(sc, 0x06, 0x85a1);
+        MP_WritePhyUshort(sc, 0x06, 0x0237);
+        MP_WritePhyUshort(sc, 0x06, 0x23ee);
+        MP_WritePhyUshort(sc, 0x06, 0x8608);
+        MP_WritePhyUshort(sc, 0x06, 0x03ee);
+        MP_WritePhyUshort(sc, 0x06, 0x860a);
+        MP_WritePhyUshort(sc, 0x06, 0x60ee);
+        MP_WritePhyUshort(sc, 0x06, 0x8610);
+        MP_WritePhyUshort(sc, 0x06, 0x00ee);
+        MP_WritePhyUshort(sc, 0x06, 0x8611);
+        MP_WritePhyUshort(sc, 0x06, 0x00ee);
+        MP_WritePhyUshort(sc, 0x06, 0x8abe);
+        MP_WritePhyUshort(sc, 0x06, 0x07ee);
+        MP_WritePhyUshort(sc, 0x06, 0x8abf);
+        MP_WritePhyUshort(sc, 0x06, 0x73ee);
+        MP_WritePhyUshort(sc, 0x06, 0x8a95);
+        MP_WritePhyUshort(sc, 0x06, 0x02bf);
+        MP_WritePhyUshort(sc, 0x06, 0x8b88);
+        MP_WritePhyUshort(sc, 0x06, 0xec00);
+        MP_WritePhyUshort(sc, 0x06, 0x19a9);
+        MP_WritePhyUshort(sc, 0x06, 0x8b90);
+        MP_WritePhyUshort(sc, 0x06, 0xf9ee);
+        MP_WritePhyUshort(sc, 0x06, 0xfff6);
+        MP_WritePhyUshort(sc, 0x06, 0x00ee);
+        MP_WritePhyUshort(sc, 0x06, 0xfff7);
+        MP_WritePhyUshort(sc, 0x06, 0xfed1);
+        MP_WritePhyUshort(sc, 0x06, 0x00bf);
+        MP_WritePhyUshort(sc, 0x06, 0x8595);
+        MP_WritePhyUshort(sc, 0x06, 0x0237);
+        MP_WritePhyUshort(sc, 0x06, 0x23d1);
+        MP_WritePhyUshort(sc, 0x06, 0x01bf);
+        MP_WritePhyUshort(sc, 0x06, 0x8598);
+        MP_WritePhyUshort(sc, 0x06, 0x0237);
+        MP_WritePhyUshort(sc, 0x06, 0x2304);
+        MP_WritePhyUshort(sc, 0x06, 0xf8e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8a);
+        MP_WritePhyUshort(sc, 0x06, 0xad20);
+        MP_WritePhyUshort(sc, 0x06, 0x14ee);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8a);
+        MP_WritePhyUshort(sc, 0x06, 0x0002);
+        MP_WritePhyUshort(sc, 0x06, 0x1f9a);
+        MP_WritePhyUshort(sc, 0x06, 0xe0e4);
+        MP_WritePhyUshort(sc, 0x06, 0x26e1);
+        MP_WritePhyUshort(sc, 0x06, 0xe427);
+        MP_WritePhyUshort(sc, 0x06, 0xeee4);
+        MP_WritePhyUshort(sc, 0x06, 0x2623);
+        MP_WritePhyUshort(sc, 0x06, 0xe5e4);
+        MP_WritePhyUshort(sc, 0x06, 0x27fc);
+        MP_WritePhyUshort(sc, 0x06, 0x04f8);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x8dad);
+        MP_WritePhyUshort(sc, 0x06, 0x2014);
+        MP_WritePhyUshort(sc, 0x06, 0xee8b);
+        MP_WritePhyUshort(sc, 0x06, 0x8d00);
+        MP_WritePhyUshort(sc, 0x06, 0xe08a);
+        MP_WritePhyUshort(sc, 0x06, 0x5a78);
+        MP_WritePhyUshort(sc, 0x06, 0x039e);
+        MP_WritePhyUshort(sc, 0x06, 0x0902);
+        MP_WritePhyUshort(sc, 0x06, 0x05db);
+        MP_WritePhyUshort(sc, 0x06, 0x0282);
+        MP_WritePhyUshort(sc, 0x06, 0x7b02);
+        MP_WritePhyUshort(sc, 0x06, 0x3231);
+        MP_WritePhyUshort(sc, 0x06, 0xfc04);
+        MP_WritePhyUshort(sc, 0x06, 0xf8e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8e);
+        MP_WritePhyUshort(sc, 0x06, 0xad20);
+        MP_WritePhyUshort(sc, 0x06, 0x1df6);
+        MP_WritePhyUshort(sc, 0x06, 0x20e4);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8e);
+        MP_WritePhyUshort(sc, 0x06, 0x0281);
+        MP_WritePhyUshort(sc, 0x06, 0x5c02);
+        MP_WritePhyUshort(sc, 0x06, 0x2bcb);
+        MP_WritePhyUshort(sc, 0x06, 0x022d);
+        MP_WritePhyUshort(sc, 0x06, 0x2902);
+        MP_WritePhyUshort(sc, 0x06, 0x03b4);
+        MP_WritePhyUshort(sc, 0x06, 0x0285);
+        MP_WritePhyUshort(sc, 0x06, 0x6402);
+        MP_WritePhyUshort(sc, 0x06, 0x2eca);
+        MP_WritePhyUshort(sc, 0x06, 0x0284);
+        MP_WritePhyUshort(sc, 0x06, 0xcd02);
+        MP_WritePhyUshort(sc, 0x06, 0x046f);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x8ead);
+        MP_WritePhyUshort(sc, 0x06, 0x210b);
+        MP_WritePhyUshort(sc, 0x06, 0xf621);
+        MP_WritePhyUshort(sc, 0x06, 0xe48b);
+        MP_WritePhyUshort(sc, 0x06, 0x8e02);
+        MP_WritePhyUshort(sc, 0x06, 0x8520);
+        MP_WritePhyUshort(sc, 0x06, 0x021b);
+        MP_WritePhyUshort(sc, 0x06, 0xe8e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8e);
+        MP_WritePhyUshort(sc, 0x06, 0xad22);
+        MP_WritePhyUshort(sc, 0x06, 0x05f6);
+        MP_WritePhyUshort(sc, 0x06, 0x22e4);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8e);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x8ead);
+        MP_WritePhyUshort(sc, 0x06, 0x2308);
+        MP_WritePhyUshort(sc, 0x06, 0xf623);
+        MP_WritePhyUshort(sc, 0x06, 0xe48b);
+        MP_WritePhyUshort(sc, 0x06, 0x8e02);
+        MP_WritePhyUshort(sc, 0x06, 0x311c);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x8ead);
+        MP_WritePhyUshort(sc, 0x06, 0x2405);
+        MP_WritePhyUshort(sc, 0x06, 0xf624);
+        MP_WritePhyUshort(sc, 0x06, 0xe48b);
+        MP_WritePhyUshort(sc, 0x06, 0x8ee0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8e);
+        MP_WritePhyUshort(sc, 0x06, 0xad25);
+        MP_WritePhyUshort(sc, 0x06, 0x05f6);
+        MP_WritePhyUshort(sc, 0x06, 0x25e4);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8e);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x8ead);
+        MP_WritePhyUshort(sc, 0x06, 0x2608);
+        MP_WritePhyUshort(sc, 0x06, 0xf626);
+        MP_WritePhyUshort(sc, 0x06, 0xe48b);
+        MP_WritePhyUshort(sc, 0x06, 0x8e02);
+        MP_WritePhyUshort(sc, 0x06, 0x2df5);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x8ead);
+        MP_WritePhyUshort(sc, 0x06, 0x2705);
+        MP_WritePhyUshort(sc, 0x06, 0xf627);
+        MP_WritePhyUshort(sc, 0x06, 0xe48b);
+        MP_WritePhyUshort(sc, 0x06, 0x8e02);
+        MP_WritePhyUshort(sc, 0x06, 0x037a);
+        MP_WritePhyUshort(sc, 0x06, 0xfc04);
+        MP_WritePhyUshort(sc, 0x06, 0xf8f9);
+        MP_WritePhyUshort(sc, 0x06, 0xfaef);
+        MP_WritePhyUshort(sc, 0x06, 0x69e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b87);
+        MP_WritePhyUshort(sc, 0x06, 0xad20);
+        MP_WritePhyUshort(sc, 0x06, 0x65d2);
+        MP_WritePhyUshort(sc, 0x06, 0x00bf);
+        MP_WritePhyUshort(sc, 0x06, 0x2fe9);
+        MP_WritePhyUshort(sc, 0x06, 0x0236);
+        MP_WritePhyUshort(sc, 0x06, 0xf61e);
+        MP_WritePhyUshort(sc, 0x06, 0x21bf);
+        MP_WritePhyUshort(sc, 0x06, 0x2ff5);
+        MP_WritePhyUshort(sc, 0x06, 0x0236);
+        MP_WritePhyUshort(sc, 0x06, 0xf60c);
+        MP_WritePhyUshort(sc, 0x06, 0x111e);
+        MP_WritePhyUshort(sc, 0x06, 0x21bf);
+        MP_WritePhyUshort(sc, 0x06, 0x2ff8);
+        MP_WritePhyUshort(sc, 0x06, 0x0236);
+        MP_WritePhyUshort(sc, 0x06, 0xf60c);
+        MP_WritePhyUshort(sc, 0x06, 0x121e);
+        MP_WritePhyUshort(sc, 0x06, 0x21bf);
+        MP_WritePhyUshort(sc, 0x06, 0x2ffb);
+        MP_WritePhyUshort(sc, 0x06, 0x0236);
+        MP_WritePhyUshort(sc, 0x06, 0xf60c);
+        MP_WritePhyUshort(sc, 0x06, 0x131e);
+        MP_WritePhyUshort(sc, 0x06, 0x21bf);
+        MP_WritePhyUshort(sc, 0x06, 0x1f97);
+        MP_WritePhyUshort(sc, 0x06, 0x0236);
+        MP_WritePhyUshort(sc, 0x06, 0xf60c);
+        MP_WritePhyUshort(sc, 0x06, 0x141e);
+        MP_WritePhyUshort(sc, 0x06, 0x21bf);
+        MP_WritePhyUshort(sc, 0x06, 0x859b);
+        MP_WritePhyUshort(sc, 0x06, 0x0236);
+        MP_WritePhyUshort(sc, 0x06, 0xf60c);
+        MP_WritePhyUshort(sc, 0x06, 0x161e);
+        MP_WritePhyUshort(sc, 0x06, 0x21e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8a8c);
+        MP_WritePhyUshort(sc, 0x06, 0x1f02);
+        MP_WritePhyUshort(sc, 0x06, 0x9e22);
+        MP_WritePhyUshort(sc, 0x06, 0xe68a);
+        MP_WritePhyUshort(sc, 0x06, 0x8cad);
+        MP_WritePhyUshort(sc, 0x06, 0x3114);
+        MP_WritePhyUshort(sc, 0x06, 0xad30);
+        MP_WritePhyUshort(sc, 0x06, 0x11ef);
+        MP_WritePhyUshort(sc, 0x06, 0x0258);
+        MP_WritePhyUshort(sc, 0x06, 0x0c9e);
+        MP_WritePhyUshort(sc, 0x06, 0x07ad);
+        MP_WritePhyUshort(sc, 0x06, 0x3608);
+        MP_WritePhyUshort(sc, 0x06, 0x5a30);
+        MP_WritePhyUshort(sc, 0x06, 0x9f04);
+        MP_WritePhyUshort(sc, 0x06, 0xd101);
+        MP_WritePhyUshort(sc, 0x06, 0xae02);
+        MP_WritePhyUshort(sc, 0x06, 0xd100);
+        MP_WritePhyUshort(sc, 0x06, 0xbf2f);
+        MP_WritePhyUshort(sc, 0x06, 0xf202);
+        MP_WritePhyUshort(sc, 0x06, 0x3723);
+        MP_WritePhyUshort(sc, 0x06, 0xef96);
+        MP_WritePhyUshort(sc, 0x06, 0xfefd);
+        MP_WritePhyUshort(sc, 0x06, 0xfc04);
+        MP_WritePhyUshort(sc, 0x06, 0xf8f9);
+        MP_WritePhyUshort(sc, 0x06, 0xface);
+        MP_WritePhyUshort(sc, 0x06, 0xfaef);
+        MP_WritePhyUshort(sc, 0x06, 0x69fa);
+        MP_WritePhyUshort(sc, 0x06, 0xd401);
+        MP_WritePhyUshort(sc, 0x06, 0x55b4);
+        MP_WritePhyUshort(sc, 0x06, 0xfebf);
+        MP_WritePhyUshort(sc, 0x06, 0x85a7);
+        MP_WritePhyUshort(sc, 0x06, 0x0236);
+        MP_WritePhyUshort(sc, 0x06, 0xf6ac);
+        MP_WritePhyUshort(sc, 0x06, 0x280b);
+        MP_WritePhyUshort(sc, 0x06, 0xbf85);
+        MP_WritePhyUshort(sc, 0x06, 0xa402);
+        MP_WritePhyUshort(sc, 0x06, 0x36f6);
+        MP_WritePhyUshort(sc, 0x06, 0xac28);
+        MP_WritePhyUshort(sc, 0x06, 0x49ae);
+        MP_WritePhyUshort(sc, 0x06, 0x64bf);
+        MP_WritePhyUshort(sc, 0x06, 0x85a4);
+        MP_WritePhyUshort(sc, 0x06, 0x0236);
+        MP_WritePhyUshort(sc, 0x06, 0xf6ac);
+        MP_WritePhyUshort(sc, 0x06, 0x285b);
+        MP_WritePhyUshort(sc, 0x06, 0xd000);
+        MP_WritePhyUshort(sc, 0x06, 0x0282);
+        MP_WritePhyUshort(sc, 0x06, 0x60ac);
+        MP_WritePhyUshort(sc, 0x06, 0x2105);
+        MP_WritePhyUshort(sc, 0x06, 0xac22);
+        MP_WritePhyUshort(sc, 0x06, 0x02ae);
+        MP_WritePhyUshort(sc, 0x06, 0x4ebf);
+        MP_WritePhyUshort(sc, 0x06, 0xe0c4);
+        MP_WritePhyUshort(sc, 0x06, 0xbe86);
+        MP_WritePhyUshort(sc, 0x06, 0x14d2);
+        MP_WritePhyUshort(sc, 0x06, 0x04d8);
+        MP_WritePhyUshort(sc, 0x06, 0x19d9);
+        MP_WritePhyUshort(sc, 0x06, 0x1907);
+        MP_WritePhyUshort(sc, 0x06, 0xdc19);
+        MP_WritePhyUshort(sc, 0x06, 0xdd19);
+        MP_WritePhyUshort(sc, 0x06, 0x0789);
+        MP_WritePhyUshort(sc, 0x06, 0x89ef);
+        MP_WritePhyUshort(sc, 0x06, 0x645e);
+        MP_WritePhyUshort(sc, 0x06, 0x07ff);
+        MP_WritePhyUshort(sc, 0x06, 0x0d65);
+        MP_WritePhyUshort(sc, 0x06, 0x5cf8);
+        MP_WritePhyUshort(sc, 0x06, 0x001e);
+        MP_WritePhyUshort(sc, 0x06, 0x46dc);
+        MP_WritePhyUshort(sc, 0x06, 0x19dd);
+        MP_WritePhyUshort(sc, 0x06, 0x19b2);
+        MP_WritePhyUshort(sc, 0x06, 0xe2d4);
+        MP_WritePhyUshort(sc, 0x06, 0x0001);
+        MP_WritePhyUshort(sc, 0x06, 0xbf85);
+        MP_WritePhyUshort(sc, 0x06, 0xa402);
+        MP_WritePhyUshort(sc, 0x06, 0x3723);
+        MP_WritePhyUshort(sc, 0x06, 0xae1d);
+        MP_WritePhyUshort(sc, 0x06, 0xbee0);
+        MP_WritePhyUshort(sc, 0x06, 0xc4bf);
+        MP_WritePhyUshort(sc, 0x06, 0x8614);
+        MP_WritePhyUshort(sc, 0x06, 0xd204);
+        MP_WritePhyUshort(sc, 0x06, 0xd819);
+        MP_WritePhyUshort(sc, 0x06, 0xd919);
+        MP_WritePhyUshort(sc, 0x06, 0x07dc);
+        MP_WritePhyUshort(sc, 0x06, 0x19dd);
+        MP_WritePhyUshort(sc, 0x06, 0x1907);
+        MP_WritePhyUshort(sc, 0x06, 0xb2f4);
+        MP_WritePhyUshort(sc, 0x06, 0xd400);
+        MP_WritePhyUshort(sc, 0x06, 0x00bf);
+        MP_WritePhyUshort(sc, 0x06, 0x85a4);
+        MP_WritePhyUshort(sc, 0x06, 0x0237);
+        MP_WritePhyUshort(sc, 0x06, 0x23fe);
+        MP_WritePhyUshort(sc, 0x06, 0xef96);
+        MP_WritePhyUshort(sc, 0x06, 0xfec6);
+        MP_WritePhyUshort(sc, 0x06, 0xfefd);
+        MP_WritePhyUshort(sc, 0x06, 0xfc05);
+        MP_WritePhyUshort(sc, 0x06, 0xf9e2);
+        MP_WritePhyUshort(sc, 0x06, 0xe0ea);
+        MP_WritePhyUshort(sc, 0x06, 0xe3e0);
+        MP_WritePhyUshort(sc, 0x06, 0xeb5a);
+        MP_WritePhyUshort(sc, 0x06, 0x070c);
+        MP_WritePhyUshort(sc, 0x06, 0x031e);
+        MP_WritePhyUshort(sc, 0x06, 0x20e6);
+        MP_WritePhyUshort(sc, 0x06, 0xe0ea);
+        MP_WritePhyUshort(sc, 0x06, 0xe7e0);
+        MP_WritePhyUshort(sc, 0x06, 0xebe0);
+        MP_WritePhyUshort(sc, 0x06, 0xe0fc);
+        MP_WritePhyUshort(sc, 0x06, 0xe1e0);
+        MP_WritePhyUshort(sc, 0x06, 0xfdfd);
+        MP_WritePhyUshort(sc, 0x06, 0x04f8);
+        MP_WritePhyUshort(sc, 0x06, 0xf9e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b81);
+        MP_WritePhyUshort(sc, 0x06, 0xac26);
+        MP_WritePhyUshort(sc, 0x06, 0x1ae0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b81);
+        MP_WritePhyUshort(sc, 0x06, 0xac21);
+        MP_WritePhyUshort(sc, 0x06, 0x14e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b85);
+        MP_WritePhyUshort(sc, 0x06, 0xac20);
+        MP_WritePhyUshort(sc, 0x06, 0x0ee0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b85);
+        MP_WritePhyUshort(sc, 0x06, 0xac23);
+        MP_WritePhyUshort(sc, 0x06, 0x08e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b87);
+        MP_WritePhyUshort(sc, 0x06, 0xac24);
+        MP_WritePhyUshort(sc, 0x06, 0x02ae);
+        MP_WritePhyUshort(sc, 0x06, 0x3802);
+        MP_WritePhyUshort(sc, 0x06, 0x1ab5);
+        MP_WritePhyUshort(sc, 0x06, 0xeee4);
+        MP_WritePhyUshort(sc, 0x06, 0x1c04);
+        MP_WritePhyUshort(sc, 0x06, 0xeee4);
+        MP_WritePhyUshort(sc, 0x06, 0x1d04);
+        MP_WritePhyUshort(sc, 0x06, 0xe2e0);
+        MP_WritePhyUshort(sc, 0x06, 0x7ce3);
+        MP_WritePhyUshort(sc, 0x06, 0xe07d);
+        MP_WritePhyUshort(sc, 0x06, 0xe0e0);
+        MP_WritePhyUshort(sc, 0x06, 0x38e1);
+        MP_WritePhyUshort(sc, 0x06, 0xe039);
+        MP_WritePhyUshort(sc, 0x06, 0xad2e);
+        MP_WritePhyUshort(sc, 0x06, 0x1bad);
+        MP_WritePhyUshort(sc, 0x06, 0x390d);
+        MP_WritePhyUshort(sc, 0x06, 0xd101);
+        MP_WritePhyUshort(sc, 0x06, 0xbf21);
+        MP_WritePhyUshort(sc, 0x06, 0xd502);
+        MP_WritePhyUshort(sc, 0x06, 0x3723);
+        MP_WritePhyUshort(sc, 0x06, 0x0282);
+        MP_WritePhyUshort(sc, 0x06, 0xd8ae);
+        MP_WritePhyUshort(sc, 0x06, 0x0bac);
+        MP_WritePhyUshort(sc, 0x06, 0x3802);
+        MP_WritePhyUshort(sc, 0x06, 0xae06);
+        MP_WritePhyUshort(sc, 0x06, 0x0283);
+        MP_WritePhyUshort(sc, 0x06, 0x1802);
+        MP_WritePhyUshort(sc, 0x06, 0x8360);
+        MP_WritePhyUshort(sc, 0x06, 0x021a);
+        MP_WritePhyUshort(sc, 0x06, 0xc6fd);
+        MP_WritePhyUshort(sc, 0x06, 0xfc04);
+        MP_WritePhyUshort(sc, 0x06, 0xf8e1);
+        MP_WritePhyUshort(sc, 0x06, 0x8af4);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x81ad);
+        MP_WritePhyUshort(sc, 0x06, 0x2605);
+        MP_WritePhyUshort(sc, 0x06, 0x0222);
+        MP_WritePhyUshort(sc, 0x06, 0xa4f7);
+        MP_WritePhyUshort(sc, 0x06, 0x28e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b81);
+        MP_WritePhyUshort(sc, 0x06, 0xad21);
+        MP_WritePhyUshort(sc, 0x06, 0x0502);
+        MP_WritePhyUshort(sc, 0x06, 0x23a9);
+        MP_WritePhyUshort(sc, 0x06, 0xf729);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x85ad);
+        MP_WritePhyUshort(sc, 0x06, 0x2005);
+        MP_WritePhyUshort(sc, 0x06, 0x0214);
+        MP_WritePhyUshort(sc, 0x06, 0xabf7);
+        MP_WritePhyUshort(sc, 0x06, 0x2ae0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b85);
+        MP_WritePhyUshort(sc, 0x06, 0xad23);
+        MP_WritePhyUshort(sc, 0x06, 0x0502);
+        MP_WritePhyUshort(sc, 0x06, 0x12e7);
+        MP_WritePhyUshort(sc, 0x06, 0xf72b);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x87ad);
+        MP_WritePhyUshort(sc, 0x06, 0x2405);
+        MP_WritePhyUshort(sc, 0x06, 0x0283);
+        MP_WritePhyUshort(sc, 0x06, 0xbcf7);
+        MP_WritePhyUshort(sc, 0x06, 0x2ce5);
+        MP_WritePhyUshort(sc, 0x06, 0x8af4);
+        MP_WritePhyUshort(sc, 0x06, 0xfc04);
+        MP_WritePhyUshort(sc, 0x06, 0xf8e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b81);
+        MP_WritePhyUshort(sc, 0x06, 0xad26);
+        MP_WritePhyUshort(sc, 0x06, 0x0302);
+        MP_WritePhyUshort(sc, 0x06, 0x21e5);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x81ad);
+        MP_WritePhyUshort(sc, 0x06, 0x2109);
+        MP_WritePhyUshort(sc, 0x06, 0xe08a);
+        MP_WritePhyUshort(sc, 0x06, 0xf4ac);
+        MP_WritePhyUshort(sc, 0x06, 0x2003);
+        MP_WritePhyUshort(sc, 0x06, 0x0223);
+        MP_WritePhyUshort(sc, 0x06, 0x98e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b85);
+        MP_WritePhyUshort(sc, 0x06, 0xad20);
+        MP_WritePhyUshort(sc, 0x06, 0x09e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8af4);
+        MP_WritePhyUshort(sc, 0x06, 0xac21);
+        MP_WritePhyUshort(sc, 0x06, 0x0302);
+        MP_WritePhyUshort(sc, 0x06, 0x13fb);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x85ad);
+        MP_WritePhyUshort(sc, 0x06, 0x2309);
+        MP_WritePhyUshort(sc, 0x06, 0xe08a);
+        MP_WritePhyUshort(sc, 0x06, 0xf4ac);
+        MP_WritePhyUshort(sc, 0x06, 0x2203);
+        MP_WritePhyUshort(sc, 0x06, 0x0212);
+        MP_WritePhyUshort(sc, 0x06, 0xfae0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b87);
+        MP_WritePhyUshort(sc, 0x06, 0xad24);
+        MP_WritePhyUshort(sc, 0x06, 0x09e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8af4);
+        MP_WritePhyUshort(sc, 0x06, 0xac23);
+        MP_WritePhyUshort(sc, 0x06, 0x0302);
+        MP_WritePhyUshort(sc, 0x06, 0x83c1);
+        MP_WritePhyUshort(sc, 0x06, 0xfc04);
+        MP_WritePhyUshort(sc, 0x06, 0xf8e1);
+        MP_WritePhyUshort(sc, 0x06, 0x8af4);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x81ad);
+        MP_WritePhyUshort(sc, 0x06, 0x2608);
+        MP_WritePhyUshort(sc, 0x06, 0xe083);
+        MP_WritePhyUshort(sc, 0x06, 0xd2ad);
+        MP_WritePhyUshort(sc, 0x06, 0x2502);
+        MP_WritePhyUshort(sc, 0x06, 0xf628);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x81ad);
+        MP_WritePhyUshort(sc, 0x06, 0x210a);
+        MP_WritePhyUshort(sc, 0x06, 0xe084);
+        MP_WritePhyUshort(sc, 0x06, 0x0af6);
+        MP_WritePhyUshort(sc, 0x06, 0x27a0);
+        MP_WritePhyUshort(sc, 0x06, 0x0502);
+        MP_WritePhyUshort(sc, 0x06, 0xf629);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x85ad);
+        MP_WritePhyUshort(sc, 0x06, 0x2008);
+        MP_WritePhyUshort(sc, 0x06, 0xe08a);
+        MP_WritePhyUshort(sc, 0x06, 0xe8ad);
+        MP_WritePhyUshort(sc, 0x06, 0x2102);
+        MP_WritePhyUshort(sc, 0x06, 0xf62a);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x85ad);
+        MP_WritePhyUshort(sc, 0x06, 0x2308);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x20a0);
+        MP_WritePhyUshort(sc, 0x06, 0x0302);
+        MP_WritePhyUshort(sc, 0x06, 0xf62b);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x87ad);
+        MP_WritePhyUshort(sc, 0x06, 0x2408);
+        MP_WritePhyUshort(sc, 0x06, 0xe086);
+        MP_WritePhyUshort(sc, 0x06, 0x02a0);
+        MP_WritePhyUshort(sc, 0x06, 0x0302);
+        MP_WritePhyUshort(sc, 0x06, 0xf62c);
+        MP_WritePhyUshort(sc, 0x06, 0xe58a);
+        MP_WritePhyUshort(sc, 0x06, 0xf4a1);
+        MP_WritePhyUshort(sc, 0x06, 0x0008);
+        MP_WritePhyUshort(sc, 0x06, 0xd100);
+        MP_WritePhyUshort(sc, 0x06, 0xbf21);
+        MP_WritePhyUshort(sc, 0x06, 0xd502);
+        MP_WritePhyUshort(sc, 0x06, 0x3723);
+        MP_WritePhyUshort(sc, 0x06, 0xfc04);
+        MP_WritePhyUshort(sc, 0x06, 0xee86);
+        MP_WritePhyUshort(sc, 0x06, 0x0200);
+        MP_WritePhyUshort(sc, 0x06, 0x04f8);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x87ad);
+        MP_WritePhyUshort(sc, 0x06, 0x241e);
+        MP_WritePhyUshort(sc, 0x06, 0xe086);
+        MP_WritePhyUshort(sc, 0x06, 0x02a0);
+        MP_WritePhyUshort(sc, 0x06, 0x0005);
+        MP_WritePhyUshort(sc, 0x06, 0x0283);
+        MP_WritePhyUshort(sc, 0x06, 0xe8ae);
+        MP_WritePhyUshort(sc, 0x06, 0xf5a0);
+        MP_WritePhyUshort(sc, 0x06, 0x0105);
+        MP_WritePhyUshort(sc, 0x06, 0x0283);
+        MP_WritePhyUshort(sc, 0x06, 0xf8ae);
+        MP_WritePhyUshort(sc, 0x06, 0x0ba0);
+        MP_WritePhyUshort(sc, 0x06, 0x0205);
+        MP_WritePhyUshort(sc, 0x06, 0x0284);
+        MP_WritePhyUshort(sc, 0x06, 0x14ae);
+        MP_WritePhyUshort(sc, 0x06, 0x03a0);
+        MP_WritePhyUshort(sc, 0x06, 0x0300);
+        MP_WritePhyUshort(sc, 0x06, 0xfc04);
+        MP_WritePhyUshort(sc, 0x06, 0xf8fa);
+        MP_WritePhyUshort(sc, 0x06, 0xef69);
+        MP_WritePhyUshort(sc, 0x06, 0x0284);
+        MP_WritePhyUshort(sc, 0x06, 0x2bee);
+        MP_WritePhyUshort(sc, 0x06, 0x8602);
+        MP_WritePhyUshort(sc, 0x06, 0x01ef);
+        MP_WritePhyUshort(sc, 0x06, 0x96fe);
+        MP_WritePhyUshort(sc, 0x06, 0xfc04);
+        MP_WritePhyUshort(sc, 0x06, 0xf8ee);
+        MP_WritePhyUshort(sc, 0x06, 0x8609);
+        MP_WritePhyUshort(sc, 0x06, 0x0002);
+        MP_WritePhyUshort(sc, 0x06, 0x8461);
+        MP_WritePhyUshort(sc, 0x06, 0xfc04);
+        MP_WritePhyUshort(sc, 0x06, 0xae10);
+        MP_WritePhyUshort(sc, 0x06, 0x0000);
+        MP_WritePhyUshort(sc, 0x06, 0x0000);
+        MP_WritePhyUshort(sc, 0x06, 0x0000);
+        MP_WritePhyUshort(sc, 0x06, 0x0000);
+        MP_WritePhyUshort(sc, 0x06, 0x0000);
+        MP_WritePhyUshort(sc, 0x06, 0x0000);
+        MP_WritePhyUshort(sc, 0x06, 0x0000);
+        MP_WritePhyUshort(sc, 0x06, 0x0000);
+        MP_WritePhyUshort(sc, 0x06, 0xf8e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8608);
+        MP_WritePhyUshort(sc, 0x06, 0xe186);
+        MP_WritePhyUshort(sc, 0x06, 0x091f);
+        MP_WritePhyUshort(sc, 0x06, 0x019e);
+        MP_WritePhyUshort(sc, 0x06, 0x0611);
+        MP_WritePhyUshort(sc, 0x06, 0xe586);
+        MP_WritePhyUshort(sc, 0x06, 0x09ae);
+        MP_WritePhyUshort(sc, 0x06, 0x04ee);
+        MP_WritePhyUshort(sc, 0x06, 0x8602);
+        MP_WritePhyUshort(sc, 0x06, 0x01fc);
+        MP_WritePhyUshort(sc, 0x06, 0x04f8);
+        MP_WritePhyUshort(sc, 0x06, 0xf9fa);
+        MP_WritePhyUshort(sc, 0x06, 0xef69);
+        MP_WritePhyUshort(sc, 0x06, 0xfbbf);
+        MP_WritePhyUshort(sc, 0x06, 0x8604);
+        MP_WritePhyUshort(sc, 0x06, 0xef79);
+        MP_WritePhyUshort(sc, 0x06, 0xd200);
+        MP_WritePhyUshort(sc, 0x06, 0xd400);
+        MP_WritePhyUshort(sc, 0x06, 0x221e);
+        MP_WritePhyUshort(sc, 0x06, 0x02bf);
+        MP_WritePhyUshort(sc, 0x06, 0x2fec);
+        MP_WritePhyUshort(sc, 0x06, 0x0237);
+        MP_WritePhyUshort(sc, 0x06, 0x23bf);
+        MP_WritePhyUshort(sc, 0x06, 0x13f2);
+        MP_WritePhyUshort(sc, 0x06, 0x0236);
+        MP_WritePhyUshort(sc, 0x06, 0xf60d);
+        MP_WritePhyUshort(sc, 0x06, 0x4559);
+        MP_WritePhyUshort(sc, 0x06, 0x1fef);
+        MP_WritePhyUshort(sc, 0x06, 0x97dd);
+        MP_WritePhyUshort(sc, 0x06, 0xd308);
+        MP_WritePhyUshort(sc, 0x06, 0x1a93);
+        MP_WritePhyUshort(sc, 0x06, 0xdd12);
+        MP_WritePhyUshort(sc, 0x06, 0x17a2);
+        MP_WritePhyUshort(sc, 0x06, 0x04de);
+        MP_WritePhyUshort(sc, 0x06, 0xffef);
+        MP_WritePhyUshort(sc, 0x06, 0x96fe);
+        MP_WritePhyUshort(sc, 0x06, 0xfdfc);
+        MP_WritePhyUshort(sc, 0x06, 0x04f8);
+        MP_WritePhyUshort(sc, 0x06, 0xf9fa);
+        MP_WritePhyUshort(sc, 0x06, 0xef69);
+        MP_WritePhyUshort(sc, 0x06, 0xfbee);
+        MP_WritePhyUshort(sc, 0x06, 0x8602);
+        MP_WritePhyUshort(sc, 0x06, 0x03d5);
+        MP_WritePhyUshort(sc, 0x06, 0x0080);
+        MP_WritePhyUshort(sc, 0x06, 0xbf86);
+        MP_WritePhyUshort(sc, 0x06, 0x04ef);
+        MP_WritePhyUshort(sc, 0x06, 0x79ef);
+        MP_WritePhyUshort(sc, 0x06, 0x45bf);
+        MP_WritePhyUshort(sc, 0x06, 0x2fec);
+        MP_WritePhyUshort(sc, 0x06, 0x0237);
+        MP_WritePhyUshort(sc, 0x06, 0x23bf);
+        MP_WritePhyUshort(sc, 0x06, 0x13f2);
+        MP_WritePhyUshort(sc, 0x06, 0x0236);
+        MP_WritePhyUshort(sc, 0x06, 0xf6ad);
+        MP_WritePhyUshort(sc, 0x06, 0x2702);
+        MP_WritePhyUshort(sc, 0x06, 0x78ff);
+        MP_WritePhyUshort(sc, 0x06, 0xe186);
+        MP_WritePhyUshort(sc, 0x06, 0x0a1b);
+        MP_WritePhyUshort(sc, 0x06, 0x01aa);
+        MP_WritePhyUshort(sc, 0x06, 0x2eef);
+        MP_WritePhyUshort(sc, 0x06, 0x97d9);
+        MP_WritePhyUshort(sc, 0x06, 0x7900);
+        MP_WritePhyUshort(sc, 0x06, 0x9e2b);
+        MP_WritePhyUshort(sc, 0x06, 0x81dd);
+        MP_WritePhyUshort(sc, 0x06, 0xbf85);
+        MP_WritePhyUshort(sc, 0x06, 0xad02);
+        MP_WritePhyUshort(sc, 0x06, 0x3723);
+        MP_WritePhyUshort(sc, 0x06, 0xd101);
+        MP_WritePhyUshort(sc, 0x06, 0xef02);
+        MP_WritePhyUshort(sc, 0x06, 0x100c);
+        MP_WritePhyUshort(sc, 0x06, 0x11b0);
+        MP_WritePhyUshort(sc, 0x06, 0xfc0d);
+        MP_WritePhyUshort(sc, 0x06, 0x11bf);
+        MP_WritePhyUshort(sc, 0x06, 0x85aa);
+        MP_WritePhyUshort(sc, 0x06, 0x0237);
+        MP_WritePhyUshort(sc, 0x06, 0x23d1);
+        MP_WritePhyUshort(sc, 0x06, 0x00bf);
+        MP_WritePhyUshort(sc, 0x06, 0x85aa);
+        MP_WritePhyUshort(sc, 0x06, 0x0237);
+        MP_WritePhyUshort(sc, 0x06, 0x23ee);
+        MP_WritePhyUshort(sc, 0x06, 0x8602);
+        MP_WritePhyUshort(sc, 0x06, 0x02ae);
+        MP_WritePhyUshort(sc, 0x06, 0x0413);
+        MP_WritePhyUshort(sc, 0x06, 0xa38b);
+        MP_WritePhyUshort(sc, 0x06, 0xb4d3);
+        MP_WritePhyUshort(sc, 0x06, 0x8012);
+        MP_WritePhyUshort(sc, 0x06, 0x17a2);
+        MP_WritePhyUshort(sc, 0x06, 0x04ad);
+        MP_WritePhyUshort(sc, 0x06, 0xffef);
+        MP_WritePhyUshort(sc, 0x06, 0x96fe);
+        MP_WritePhyUshort(sc, 0x06, 0xfdfc);
+        MP_WritePhyUshort(sc, 0x06, 0x04f8);
+        MP_WritePhyUshort(sc, 0x06, 0xf9e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b85);
+        MP_WritePhyUshort(sc, 0x06, 0xad25);
+        MP_WritePhyUshort(sc, 0x06, 0x48e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8a96);
+        MP_WritePhyUshort(sc, 0x06, 0xe18a);
+        MP_WritePhyUshort(sc, 0x06, 0x977c);
+        MP_WritePhyUshort(sc, 0x06, 0x0000);
+        MP_WritePhyUshort(sc, 0x06, 0x9e35);
+        MP_WritePhyUshort(sc, 0x06, 0xee8a);
+        MP_WritePhyUshort(sc, 0x06, 0x9600);
+        MP_WritePhyUshort(sc, 0x06, 0xee8a);
+        MP_WritePhyUshort(sc, 0x06, 0x9700);
+        MP_WritePhyUshort(sc, 0x06, 0xe08a);
+        MP_WritePhyUshort(sc, 0x06, 0xbee1);
+        MP_WritePhyUshort(sc, 0x06, 0x8abf);
+        MP_WritePhyUshort(sc, 0x06, 0xe286);
+        MP_WritePhyUshort(sc, 0x06, 0x10e3);
+        MP_WritePhyUshort(sc, 0x06, 0x8611);
+        MP_WritePhyUshort(sc, 0x06, 0x0236);
+        MP_WritePhyUshort(sc, 0x06, 0x1aad);
+        MP_WritePhyUshort(sc, 0x06, 0x2012);
+        MP_WritePhyUshort(sc, 0x06, 0xee8a);
+        MP_WritePhyUshort(sc, 0x06, 0x9603);
+        MP_WritePhyUshort(sc, 0x06, 0xee8a);
+        MP_WritePhyUshort(sc, 0x06, 0x97b7);
+        MP_WritePhyUshort(sc, 0x06, 0xee86);
+        MP_WritePhyUshort(sc, 0x06, 0x1000);
+        MP_WritePhyUshort(sc, 0x06, 0xee86);
+        MP_WritePhyUshort(sc, 0x06, 0x1100);
+        MP_WritePhyUshort(sc, 0x06, 0xae11);
+        MP_WritePhyUshort(sc, 0x06, 0x15e6);
+        MP_WritePhyUshort(sc, 0x06, 0x8610);
+        MP_WritePhyUshort(sc, 0x06, 0xe786);
+        MP_WritePhyUshort(sc, 0x06, 0x11ae);
+        MP_WritePhyUshort(sc, 0x06, 0x08ee);
+        MP_WritePhyUshort(sc, 0x06, 0x8610);
+        MP_WritePhyUshort(sc, 0x06, 0x00ee);
+        MP_WritePhyUshort(sc, 0x06, 0x8611);
+        MP_WritePhyUshort(sc, 0x06, 0x00fd);
+        MP_WritePhyUshort(sc, 0x06, 0xfc04);
+        MP_WritePhyUshort(sc, 0x06, 0xf8fa);
+        MP_WritePhyUshort(sc, 0x06, 0xef69);
+        MP_WritePhyUshort(sc, 0x06, 0xe0e0);
+        MP_WritePhyUshort(sc, 0x06, 0x00e1);
+        MP_WritePhyUshort(sc, 0x06, 0xe001);
+        MP_WritePhyUshort(sc, 0x06, 0xad27);
+        MP_WritePhyUshort(sc, 0x06, 0x32e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b40);
+        MP_WritePhyUshort(sc, 0x06, 0xf720);
+        MP_WritePhyUshort(sc, 0x06, 0xe48b);
+        MP_WritePhyUshort(sc, 0x06, 0x40bf);
+        MP_WritePhyUshort(sc, 0x06, 0x31f5);
+        MP_WritePhyUshort(sc, 0x06, 0x0236);
+        MP_WritePhyUshort(sc, 0x06, 0xf6ad);
+        MP_WritePhyUshort(sc, 0x06, 0x2821);
+        MP_WritePhyUshort(sc, 0x06, 0xe0e0);
+        MP_WritePhyUshort(sc, 0x06, 0x20e1);
+        MP_WritePhyUshort(sc, 0x06, 0xe021);
+        MP_WritePhyUshort(sc, 0x06, 0xad20);
+        MP_WritePhyUshort(sc, 0x06, 0x18e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b40);
+        MP_WritePhyUshort(sc, 0x06, 0xf620);
+        MP_WritePhyUshort(sc, 0x06, 0xe48b);
+        MP_WritePhyUshort(sc, 0x06, 0x40ee);
+        MP_WritePhyUshort(sc, 0x06, 0x8b3b);
+        MP_WritePhyUshort(sc, 0x06, 0xffe0);
+        MP_WritePhyUshort(sc, 0x06, 0x8a8a);
+        MP_WritePhyUshort(sc, 0x06, 0xe18a);
+        MP_WritePhyUshort(sc, 0x06, 0x8be4);
+        MP_WritePhyUshort(sc, 0x06, 0xe000);
+        MP_WritePhyUshort(sc, 0x06, 0xe5e0);
+        MP_WritePhyUshort(sc, 0x06, 0x01ef);
+        MP_WritePhyUshort(sc, 0x06, 0x96fe);
+        MP_WritePhyUshort(sc, 0x06, 0xfc04);
+        MP_WritePhyUshort(sc, 0x06, 0xf8fa);
+        MP_WritePhyUshort(sc, 0x06, 0xef69);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x80ad);
+        MP_WritePhyUshort(sc, 0x06, 0x2722);
+        MP_WritePhyUshort(sc, 0x06, 0xbf44);
+        MP_WritePhyUshort(sc, 0x06, 0xfc02);
+        MP_WritePhyUshort(sc, 0x06, 0x36f6);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x441f);
+        MP_WritePhyUshort(sc, 0x06, 0x019e);
+        MP_WritePhyUshort(sc, 0x06, 0x15e5);
+        MP_WritePhyUshort(sc, 0x06, 0x8b44);
+        MP_WritePhyUshort(sc, 0x06, 0xad29);
+        MP_WritePhyUshort(sc, 0x06, 0x07ac);
+        MP_WritePhyUshort(sc, 0x06, 0x2804);
+        MP_WritePhyUshort(sc, 0x06, 0xd101);
+        MP_WritePhyUshort(sc, 0x06, 0xae02);
+        MP_WritePhyUshort(sc, 0x06, 0xd100);
+        MP_WritePhyUshort(sc, 0x06, 0xbf85);
+        MP_WritePhyUshort(sc, 0x06, 0xb002);
+        MP_WritePhyUshort(sc, 0x06, 0x3723);
+        MP_WritePhyUshort(sc, 0x06, 0xef96);
+        MP_WritePhyUshort(sc, 0x06, 0xfefc);
+        MP_WritePhyUshort(sc, 0x06, 0x0400);
+        MP_WritePhyUshort(sc, 0x06, 0xe140);
+        MP_WritePhyUshort(sc, 0x06, 0x77e1);
+        MP_WritePhyUshort(sc, 0x06, 0x40dd);
+        MP_WritePhyUshort(sc, 0x06, 0xe022);
+        MP_WritePhyUshort(sc, 0x06, 0x32e1);
+        MP_WritePhyUshort(sc, 0x06, 0x5074);
+        MP_WritePhyUshort(sc, 0x06, 0xe144);
+        MP_WritePhyUshort(sc, 0x06, 0xffe0);
+        MP_WritePhyUshort(sc, 0x06, 0xdaff);
+        MP_WritePhyUshort(sc, 0x06, 0xe0c0);
+        MP_WritePhyUshort(sc, 0x06, 0x52e0);
+        MP_WritePhyUshort(sc, 0x06, 0xeed9);
+        MP_WritePhyUshort(sc, 0x06, 0xe04c);
+        MP_WritePhyUshort(sc, 0x06, 0xbbe0);
+        MP_WritePhyUshort(sc, 0x06, 0x2a00);
+        MP_WritePhyUshort(sc, 0x05, 0xe142);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x06);
+        PhyRegValue |= BIT_0;
+        MP_WritePhyUshort(sc, 0x06, PhyRegValue);
+        MP_WritePhyUshort(sc, 0x05, 0xe140);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x06);
+        PhyRegValue |= BIT_0;
+        MP_WritePhyUshort(sc, 0x06, PhyRegValue);
+        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+        MP_WritePhyUshort(sc, 0x1f, 0x0005);
+        for (i = 0; i < 200; i++) {
+                DELAY(100);
+                PhyRegValue = MP_ReadPhyUshort(sc, 0x00);
+                if (PhyRegValue & BIT_7)
+                        break;
+        }
+
+        MP_WritePhyUshort(sc, 0x1F, 0x0003);
+        MP_WritePhyUshort(sc, 0x09, 0xA20F);
+        MP_WritePhyUshort(sc, 0x1F, 0x0000);
+
+        MP_WritePhyUshort(sc, 0x1f, 0x0003);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x19);
+        PhyRegValue &= ~BIT_0;
+        MP_WritePhyUshort(sc, 0x19, PhyRegValue);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
+        PhyRegValue &= ~BIT_10;
+        MP_WritePhyUshort(sc, 0x10, PhyRegValue);
+        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+
+        MP_WritePhyUshort(sc, 0x1f, 0x0007);
+        MP_WritePhyUshort(sc, 0x1e, 0x0042);
+        MP_WritePhyUshort(sc, 0x18, 0x2300);
+        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+        MP_WritePhyUshort(sc, 0x1f, 0x0007);
+        MP_WritePhyUshort(sc, 0x1e, 0x0023);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
+        if (sc->RequiredSecLanDonglePatch)
+                PhyRegValue &= ~(BIT_2);
+        MP_WritePhyUshort(sc, 0x17, PhyRegValue);
+        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+        MP_WritePhyUshort(sc, 0x00, 0x9200);
+}
+
+static void re_set_phy_mcu_8168f_1(struct re_softc *sc)
+{
+        u_int16_t PhyRegValue;
+        int i;
+
+        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+        MP_WritePhyUshort(sc, 0x00, 0x1800);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x15);
+        PhyRegValue &= ~(BIT_12);
+        MP_WritePhyUshort(sc, 0x15, PhyRegValue);
+        MP_WritePhyUshort(sc, 0x00, 0x4800);
+        MP_WritePhyUshort(sc, 0x1f, 0x0007);
+        MP_WritePhyUshort(sc, 0x1e, 0x002f);
+        for (i = 0; i < 1000; i++) {
+                DELAY(100);
+                PhyRegValue = MP_ReadPhyUshort(sc, 0x1c);
+                if (PhyRegValue & BIT_7)
+                        break;
+        }
+        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+        MP_WritePhyUshort(sc, 0x00, 0x1800);
+        MP_WritePhyUshort(sc, 0x1f, 0x0007);
+        MP_WritePhyUshort(sc, 0x1e, 0x0023);
+        for (i = 0; i < 200; i++) {
+                DELAY(100);
+                PhyRegValue = MP_ReadPhyUshort(sc, 0x18);
+                if (!(PhyRegValue & BIT_0))
+                        break;
+        }
+        MP_WritePhyUshort(sc, 0x1f, 0x0005);
+        MP_WritePhyUshort(sc, 0x05, 0xfff6);
+        MP_WritePhyUshort(sc, 0x06, 0x0080);
+        MP_WritePhyUshort(sc, 0x1f, 0x0007);
+        MP_WritePhyUshort(sc, 0x1e, 0x0023);
+        MP_WritePhyUshort(sc, 0x16, 0x0306);
+        MP_WritePhyUshort(sc, 0x16, 0x0307);
+        MP_WritePhyUshort(sc, 0x15, 0x0194);
+        MP_WritePhyUshort(sc, 0x19, 0x407D);
+        MP_WritePhyUshort(sc, 0x15, 0x0098);
+        MP_WritePhyUshort(sc, 0x19, 0x7c0b);
+        MP_WritePhyUshort(sc, 0x15, 0x0099);
+        MP_WritePhyUshort(sc, 0x19, 0x6c0b);
+        MP_WritePhyUshort(sc, 0x15, 0x00eb);
+        MP_WritePhyUshort(sc, 0x19, 0x6c0b);
+        MP_WritePhyUshort(sc, 0x15, 0x00f8);
+        MP_WritePhyUshort(sc, 0x19, 0x6f0b);
+        MP_WritePhyUshort(sc, 0x15, 0x00fe);
+        MP_WritePhyUshort(sc, 0x19, 0x6f0f);
+        MP_WritePhyUshort(sc, 0x15, 0x00db);
+        MP_WritePhyUshort(sc, 0x19, 0x6f09);
+        MP_WritePhyUshort(sc, 0x15, 0x00dc);
+        MP_WritePhyUshort(sc, 0x19, 0xaefd);
+        MP_WritePhyUshort(sc, 0x15, 0x00dd);
+        MP_WritePhyUshort(sc, 0x19, 0x6f0b);
+        MP_WritePhyUshort(sc, 0x15, 0x00de);
+        MP_WritePhyUshort(sc, 0x19, 0xc60b);
+        MP_WritePhyUshort(sc, 0x15, 0x00df);
+        MP_WritePhyUshort(sc, 0x19, 0x00fa);
+        MP_WritePhyUshort(sc, 0x15, 0x00e0);
+        MP_WritePhyUshort(sc, 0x19, 0x30e1);
+        MP_WritePhyUshort(sc, 0x15, 0x020c);
+        MP_WritePhyUshort(sc, 0x19, 0x3224);
+        MP_WritePhyUshort(sc, 0x15, 0x020e);
+        MP_WritePhyUshort(sc, 0x19, 0x9813);
+        MP_WritePhyUshort(sc, 0x15, 0x020f);
+        MP_WritePhyUshort(sc, 0x19, 0x7801);
+        MP_WritePhyUshort(sc, 0x15, 0x0210);
+        MP_WritePhyUshort(sc, 0x19, 0x930f);
+        MP_WritePhyUshort(sc, 0x15, 0x0211);
+        MP_WritePhyUshort(sc, 0x19, 0x9206);
+        MP_WritePhyUshort(sc, 0x15, 0x0212);
+        MP_WritePhyUshort(sc, 0x19, 0x4002);
+        MP_WritePhyUshort(sc, 0x15, 0x0213);
+        MP_WritePhyUshort(sc, 0x19, 0x7800);
+        MP_WritePhyUshort(sc, 0x15, 0x0214);
+        MP_WritePhyUshort(sc, 0x19, 0x588f);
+        MP_WritePhyUshort(sc, 0x15, 0x0215);
+        MP_WritePhyUshort(sc, 0x19, 0x5520);
+        MP_WritePhyUshort(sc, 0x15, 0x0216);
+        MP_WritePhyUshort(sc, 0x19, 0x3224);
+        MP_WritePhyUshort(sc, 0x15, 0x0217);
+        MP_WritePhyUshort(sc, 0x19, 0x4002);
+        MP_WritePhyUshort(sc, 0x15, 0x0218);
+        MP_WritePhyUshort(sc, 0x19, 0x7800);
+        MP_WritePhyUshort(sc, 0x15, 0x0219);
+        MP_WritePhyUshort(sc, 0x19, 0x588d);
+        MP_WritePhyUshort(sc, 0x15, 0x021a);
+        MP_WritePhyUshort(sc, 0x19, 0x5540);
+        MP_WritePhyUshort(sc, 0x15, 0x021b);
+        MP_WritePhyUshort(sc, 0x19, 0x9e03);
+        MP_WritePhyUshort(sc, 0x15, 0x021c);
+        MP_WritePhyUshort(sc, 0x19, 0x7c40);
+        MP_WritePhyUshort(sc, 0x15, 0x021d);
+        MP_WritePhyUshort(sc, 0x19, 0x6840);
+        MP_WritePhyUshort(sc, 0x15, 0x021e);
+        MP_WritePhyUshort(sc, 0x19, 0x3224);
+        MP_WritePhyUshort(sc, 0x15, 0x021f);
+        MP_WritePhyUshort(sc, 0x19, 0x4002);
+        MP_WritePhyUshort(sc, 0x15, 0x0220);
+        MP_WritePhyUshort(sc, 0x19, 0x3224);
+        MP_WritePhyUshort(sc, 0x15, 0x0221);
+        MP_WritePhyUshort(sc, 0x19, 0x9e03);
+        MP_WritePhyUshort(sc, 0x15, 0x0222);
+        MP_WritePhyUshort(sc, 0x19, 0x7c40);
+        MP_WritePhyUshort(sc, 0x15, 0x0223);
+        MP_WritePhyUshort(sc, 0x19, 0x6840);
+        MP_WritePhyUshort(sc, 0x15, 0x0224);
+        MP_WritePhyUshort(sc, 0x19, 0x7800);
+        MP_WritePhyUshort(sc, 0x15, 0x0225);
+        MP_WritePhyUshort(sc, 0x19, 0x3231);
+        MP_WritePhyUshort(sc, 0x15, 0x0000);
+        MP_WritePhyUshort(sc, 0x16, 0x0306);
+        MP_WritePhyUshort(sc, 0x16, 0x0300);
+        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+        MP_WritePhyUshort(sc, 0x1f, 0x0005);
+        MP_WritePhyUshort(sc, 0x05, 0xfff6);
+        MP_WritePhyUshort(sc, 0x06, 0x0080);
+        MP_WritePhyUshort(sc, 0x05, 0x8000);
+        MP_WritePhyUshort(sc, 0x06, 0x0280);
+        MP_WritePhyUshort(sc, 0x06, 0x48f7);
+        MP_WritePhyUshort(sc, 0x06, 0x00e0);
+        MP_WritePhyUshort(sc, 0x06, 0xfff7);
+        MP_WritePhyUshort(sc, 0x06, 0xa080);
+        MP_WritePhyUshort(sc, 0x06, 0x02ae);
+        MP_WritePhyUshort(sc, 0x06, 0xf602);
+        MP_WritePhyUshort(sc, 0x06, 0x0118);
+        MP_WritePhyUshort(sc, 0x06, 0x0201);
+        MP_WritePhyUshort(sc, 0x06, 0x2502);
+        MP_WritePhyUshort(sc, 0x06, 0x8090);
+        MP_WritePhyUshort(sc, 0x06, 0x0201);
+        MP_WritePhyUshort(sc, 0x06, 0x4202);
+        MP_WritePhyUshort(sc, 0x06, 0x015c);
+        MP_WritePhyUshort(sc, 0x06, 0x0280);
+        MP_WritePhyUshort(sc, 0x06, 0xad02);
+        MP_WritePhyUshort(sc, 0x06, 0x80ca);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x88e1);
+        MP_WritePhyUshort(sc, 0x06, 0x8b89);
+        MP_WritePhyUshort(sc, 0x06, 0x1e01);
+        MP_WritePhyUshort(sc, 0x06, 0xe18b);
+        MP_WritePhyUshort(sc, 0x06, 0x8a1e);
+        MP_WritePhyUshort(sc, 0x06, 0x01e1);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8b);
+        MP_WritePhyUshort(sc, 0x06, 0x1e01);
+        MP_WritePhyUshort(sc, 0x06, 0xe18b);
+        MP_WritePhyUshort(sc, 0x06, 0x8c1e);
+        MP_WritePhyUshort(sc, 0x06, 0x01e1);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8d);
+        MP_WritePhyUshort(sc, 0x06, 0x1e01);
+        MP_WritePhyUshort(sc, 0x06, 0xe18b);
+        MP_WritePhyUshort(sc, 0x06, 0x8e1e);
+        MP_WritePhyUshort(sc, 0x06, 0x01a0);
+        MP_WritePhyUshort(sc, 0x06, 0x00c7);
+        MP_WritePhyUshort(sc, 0x06, 0xaebb);
+        MP_WritePhyUshort(sc, 0x06, 0xd484);
+        MP_WritePhyUshort(sc, 0x06, 0x3ce4);
+        MP_WritePhyUshort(sc, 0x06, 0x8b92);
+        MP_WritePhyUshort(sc, 0x06, 0xe58b);
+        MP_WritePhyUshort(sc, 0x06, 0x93ee);
+        MP_WritePhyUshort(sc, 0x06, 0x8ac8);
+        MP_WritePhyUshort(sc, 0x06, 0x03ee);
+        MP_WritePhyUshort(sc, 0x06, 0x8aca);
+        MP_WritePhyUshort(sc, 0x06, 0x60ee);
+        MP_WritePhyUshort(sc, 0x06, 0x8ac0);
+        MP_WritePhyUshort(sc, 0x06, 0x00ee);
+        MP_WritePhyUshort(sc, 0x06, 0x8ac1);
+        MP_WritePhyUshort(sc, 0x06, 0x00ee);
+        MP_WritePhyUshort(sc, 0x06, 0x8abe);
+        MP_WritePhyUshort(sc, 0x06, 0x07ee);
+        MP_WritePhyUshort(sc, 0x06, 0x8abf);
+        MP_WritePhyUshort(sc, 0x06, 0x73ee);
+        MP_WritePhyUshort(sc, 0x06, 0x8a95);
+        MP_WritePhyUshort(sc, 0x06, 0x02bf);
+        MP_WritePhyUshort(sc, 0x06, 0x8b88);
+        MP_WritePhyUshort(sc, 0x06, 0xec00);
+        MP_WritePhyUshort(sc, 0x06, 0x19a9);
+        MP_WritePhyUshort(sc, 0x06, 0x8b90);
+        MP_WritePhyUshort(sc, 0x06, 0xf9ee);
+        MP_WritePhyUshort(sc, 0x06, 0xfff6);
+        MP_WritePhyUshort(sc, 0x06, 0x00ee);
+        MP_WritePhyUshort(sc, 0x06, 0xfff7);
+        MP_WritePhyUshort(sc, 0x06, 0xfed1);
+        MP_WritePhyUshort(sc, 0x06, 0x00bf);
+        MP_WritePhyUshort(sc, 0x06, 0x85a4);
+        MP_WritePhyUshort(sc, 0x06, 0x0238);
+        MP_WritePhyUshort(sc, 0x06, 0x7dd1);
+        MP_WritePhyUshort(sc, 0x06, 0x01bf);
+        MP_WritePhyUshort(sc, 0x06, 0x85a7);
+        MP_WritePhyUshort(sc, 0x06, 0x0238);
+        MP_WritePhyUshort(sc, 0x06, 0x7d04);
+        MP_WritePhyUshort(sc, 0x06, 0xf8e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8a);
+        MP_WritePhyUshort(sc, 0x06, 0xad20);
+        MP_WritePhyUshort(sc, 0x06, 0x14ee);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8a);
+        MP_WritePhyUshort(sc, 0x06, 0x0002);
+        MP_WritePhyUshort(sc, 0x06, 0x204b);
+        MP_WritePhyUshort(sc, 0x06, 0xe0e4);
+        MP_WritePhyUshort(sc, 0x06, 0x26e1);
+        MP_WritePhyUshort(sc, 0x06, 0xe427);
+        MP_WritePhyUshort(sc, 0x06, 0xeee4);
+        MP_WritePhyUshort(sc, 0x06, 0x2623);
+        MP_WritePhyUshort(sc, 0x06, 0xe5e4);
+        MP_WritePhyUshort(sc, 0x06, 0x27fc);
+        MP_WritePhyUshort(sc, 0x06, 0x04f8);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x8dad);
+        MP_WritePhyUshort(sc, 0x06, 0x2014);
+        MP_WritePhyUshort(sc, 0x06, 0xee8b);
+        MP_WritePhyUshort(sc, 0x06, 0x8d00);
+        MP_WritePhyUshort(sc, 0x06, 0xe08a);
+        MP_WritePhyUshort(sc, 0x06, 0x5a78);
+        MP_WritePhyUshort(sc, 0x06, 0x039e);
+        MP_WritePhyUshort(sc, 0x06, 0x0902);
+        MP_WritePhyUshort(sc, 0x06, 0x05e8);
+        MP_WritePhyUshort(sc, 0x06, 0x0281);
+        MP_WritePhyUshort(sc, 0x06, 0x4f02);
+        MP_WritePhyUshort(sc, 0x06, 0x326c);
+        MP_WritePhyUshort(sc, 0x06, 0xfc04);
+        MP_WritePhyUshort(sc, 0x06, 0xf8e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8e);
+        MP_WritePhyUshort(sc, 0x06, 0xad20);
+        MP_WritePhyUshort(sc, 0x06, 0x1df6);
+        MP_WritePhyUshort(sc, 0x06, 0x20e4);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8e);
+        MP_WritePhyUshort(sc, 0x06, 0x022f);
+        MP_WritePhyUshort(sc, 0x06, 0x0902);
+        MP_WritePhyUshort(sc, 0x06, 0x2ab0);
+        MP_WritePhyUshort(sc, 0x06, 0x0285);
+        MP_WritePhyUshort(sc, 0x06, 0x1602);
+        MP_WritePhyUshort(sc, 0x06, 0x03ba);
+        MP_WritePhyUshort(sc, 0x06, 0x0284);
+        MP_WritePhyUshort(sc, 0x06, 0xe502);
+        MP_WritePhyUshort(sc, 0x06, 0x2df1);
+        MP_WritePhyUshort(sc, 0x06, 0x0283);
+        MP_WritePhyUshort(sc, 0x06, 0x8302);
+        MP_WritePhyUshort(sc, 0x06, 0x0475);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x8ead);
+        MP_WritePhyUshort(sc, 0x06, 0x210b);
+        MP_WritePhyUshort(sc, 0x06, 0xf621);
+        MP_WritePhyUshort(sc, 0x06, 0xe48b);
+        MP_WritePhyUshort(sc, 0x06, 0x8e02);
+        MP_WritePhyUshort(sc, 0x06, 0x83f8);
+        MP_WritePhyUshort(sc, 0x06, 0x021c);
+        MP_WritePhyUshort(sc, 0x06, 0x99e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8e);
+        MP_WritePhyUshort(sc, 0x06, 0xad22);
+        MP_WritePhyUshort(sc, 0x06, 0x08f6);
+        MP_WritePhyUshort(sc, 0x06, 0x22e4);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8e);
+        MP_WritePhyUshort(sc, 0x06, 0x0235);
+        MP_WritePhyUshort(sc, 0x06, 0x63e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8e);
+        MP_WritePhyUshort(sc, 0x06, 0xad23);
+        MP_WritePhyUshort(sc, 0x06, 0x08f6);
+        MP_WritePhyUshort(sc, 0x06, 0x23e4);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8e);
+        MP_WritePhyUshort(sc, 0x06, 0x0231);
+        MP_WritePhyUshort(sc, 0x06, 0x57e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8e);
+        MP_WritePhyUshort(sc, 0x06, 0xad24);
+        MP_WritePhyUshort(sc, 0x06, 0x05f6);
+        MP_WritePhyUshort(sc, 0x06, 0x24e4);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8e);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x8ead);
+        MP_WritePhyUshort(sc, 0x06, 0x2505);
+        MP_WritePhyUshort(sc, 0x06, 0xf625);
+        MP_WritePhyUshort(sc, 0x06, 0xe48b);
+        MP_WritePhyUshort(sc, 0x06, 0x8ee0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8e);
+        MP_WritePhyUshort(sc, 0x06, 0xad26);
+        MP_WritePhyUshort(sc, 0x06, 0x08f6);
+        MP_WritePhyUshort(sc, 0x06, 0x26e4);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8e);
+        MP_WritePhyUshort(sc, 0x06, 0x022d);
+        MP_WritePhyUshort(sc, 0x06, 0x1ce0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8e);
+        MP_WritePhyUshort(sc, 0x06, 0xad27);
+        MP_WritePhyUshort(sc, 0x06, 0x05f6);
+        MP_WritePhyUshort(sc, 0x06, 0x27e4);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8e);
+        MP_WritePhyUshort(sc, 0x06, 0x0203);
+        MP_WritePhyUshort(sc, 0x06, 0x80fc);
+        MP_WritePhyUshort(sc, 0x06, 0x04f8);
+        MP_WritePhyUshort(sc, 0x06, 0xf9e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b81);
+        MP_WritePhyUshort(sc, 0x06, 0xac26);
+        MP_WritePhyUshort(sc, 0x06, 0x1ae0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b81);
+        MP_WritePhyUshort(sc, 0x06, 0xac21);
+        MP_WritePhyUshort(sc, 0x06, 0x14e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b85);
+        MP_WritePhyUshort(sc, 0x06, 0xac20);
+        MP_WritePhyUshort(sc, 0x06, 0x0ee0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b85);
+        MP_WritePhyUshort(sc, 0x06, 0xac23);
+        MP_WritePhyUshort(sc, 0x06, 0x08e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b87);
+        MP_WritePhyUshort(sc, 0x06, 0xac24);
+        MP_WritePhyUshort(sc, 0x06, 0x02ae);
+        MP_WritePhyUshort(sc, 0x06, 0x3802);
+        MP_WritePhyUshort(sc, 0x06, 0x1ac2);
+        MP_WritePhyUshort(sc, 0x06, 0xeee4);
+        MP_WritePhyUshort(sc, 0x06, 0x1c04);
+        MP_WritePhyUshort(sc, 0x06, 0xeee4);
+        MP_WritePhyUshort(sc, 0x06, 0x1d04);
+        MP_WritePhyUshort(sc, 0x06, 0xe2e0);
+        MP_WritePhyUshort(sc, 0x06, 0x7ce3);
+        MP_WritePhyUshort(sc, 0x06, 0xe07d);
+        MP_WritePhyUshort(sc, 0x06, 0xe0e0);
+        MP_WritePhyUshort(sc, 0x06, 0x38e1);
+        MP_WritePhyUshort(sc, 0x06, 0xe039);
+        MP_WritePhyUshort(sc, 0x06, 0xad2e);
+        MP_WritePhyUshort(sc, 0x06, 0x1bad);
+        MP_WritePhyUshort(sc, 0x06, 0x390d);
+        MP_WritePhyUshort(sc, 0x06, 0xd101);
+        MP_WritePhyUshort(sc, 0x06, 0xbf22);
+        MP_WritePhyUshort(sc, 0x06, 0x7a02);
+        MP_WritePhyUshort(sc, 0x06, 0x387d);
+        MP_WritePhyUshort(sc, 0x06, 0x0281);
+        MP_WritePhyUshort(sc, 0x06, 0xacae);
+        MP_WritePhyUshort(sc, 0x06, 0x0bac);
+        MP_WritePhyUshort(sc, 0x06, 0x3802);
+        MP_WritePhyUshort(sc, 0x06, 0xae06);
+        MP_WritePhyUshort(sc, 0x06, 0x0281);
+        MP_WritePhyUshort(sc, 0x06, 0xe902);
+        MP_WritePhyUshort(sc, 0x06, 0x822e);
+        MP_WritePhyUshort(sc, 0x06, 0x021a);
+        MP_WritePhyUshort(sc, 0x06, 0xd3fd);
+        MP_WritePhyUshort(sc, 0x06, 0xfc04);
+        MP_WritePhyUshort(sc, 0x06, 0xf8e1);
+        MP_WritePhyUshort(sc, 0x06, 0x8af4);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x81ad);
+        MP_WritePhyUshort(sc, 0x06, 0x2602);
+        MP_WritePhyUshort(sc, 0x06, 0xf728);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x81ad);
+        MP_WritePhyUshort(sc, 0x06, 0x2105);
+        MP_WritePhyUshort(sc, 0x06, 0x0222);
+        MP_WritePhyUshort(sc, 0x06, 0x8ef7);
+        MP_WritePhyUshort(sc, 0x06, 0x29e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b85);
+        MP_WritePhyUshort(sc, 0x06, 0xad20);
+        MP_WritePhyUshort(sc, 0x06, 0x0502);
+        MP_WritePhyUshort(sc, 0x06, 0x14b8);
+        MP_WritePhyUshort(sc, 0x06, 0xf72a);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x85ad);
+        MP_WritePhyUshort(sc, 0x06, 0x2305);
+        MP_WritePhyUshort(sc, 0x06, 0x0212);
+        MP_WritePhyUshort(sc, 0x06, 0xf4f7);
+        MP_WritePhyUshort(sc, 0x06, 0x2be0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b87);
+        MP_WritePhyUshort(sc, 0x06, 0xad24);
+        MP_WritePhyUshort(sc, 0x06, 0x0502);
+        MP_WritePhyUshort(sc, 0x06, 0x8284);
+        MP_WritePhyUshort(sc, 0x06, 0xf72c);
+        MP_WritePhyUshort(sc, 0x06, 0xe58a);
+        MP_WritePhyUshort(sc, 0x06, 0xf4fc);
+        MP_WritePhyUshort(sc, 0x06, 0x04f8);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x81ad);
+        MP_WritePhyUshort(sc, 0x06, 0x2600);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x81ad);
+        MP_WritePhyUshort(sc, 0x06, 0x2109);
+        MP_WritePhyUshort(sc, 0x06, 0xe08a);
+        MP_WritePhyUshort(sc, 0x06, 0xf4ac);
+        MP_WritePhyUshort(sc, 0x06, 0x2003);
+        MP_WritePhyUshort(sc, 0x06, 0x0222);
+        MP_WritePhyUshort(sc, 0x06, 0x7de0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b85);
+        MP_WritePhyUshort(sc, 0x06, 0xad20);
+        MP_WritePhyUshort(sc, 0x06, 0x09e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8af4);
+        MP_WritePhyUshort(sc, 0x06, 0xac21);
+        MP_WritePhyUshort(sc, 0x06, 0x0302);
+        MP_WritePhyUshort(sc, 0x06, 0x1408);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x85ad);
+        MP_WritePhyUshort(sc, 0x06, 0x2309);
+        MP_WritePhyUshort(sc, 0x06, 0xe08a);
+        MP_WritePhyUshort(sc, 0x06, 0xf4ac);
+        MP_WritePhyUshort(sc, 0x06, 0x2203);
+        MP_WritePhyUshort(sc, 0x06, 0x0213);
+        MP_WritePhyUshort(sc, 0x06, 0x07e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b87);
+        MP_WritePhyUshort(sc, 0x06, 0xad24);
+        MP_WritePhyUshort(sc, 0x06, 0x09e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8af4);
+        MP_WritePhyUshort(sc, 0x06, 0xac23);
+        MP_WritePhyUshort(sc, 0x06, 0x0302);
+        MP_WritePhyUshort(sc, 0x06, 0x8289);
+        MP_WritePhyUshort(sc, 0x06, 0xfc04);
+        MP_WritePhyUshort(sc, 0x06, 0xf8e1);
+        MP_WritePhyUshort(sc, 0x06, 0x8af4);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x81ad);
+        MP_WritePhyUshort(sc, 0x06, 0x2602);
+        MP_WritePhyUshort(sc, 0x06, 0xf628);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x81ad);
+        MP_WritePhyUshort(sc, 0x06, 0x210a);
+        MP_WritePhyUshort(sc, 0x06, 0xe083);
+        MP_WritePhyUshort(sc, 0x06, 0xecf6);
+        MP_WritePhyUshort(sc, 0x06, 0x27a0);
+        MP_WritePhyUshort(sc, 0x06, 0x0502);
+        MP_WritePhyUshort(sc, 0x06, 0xf629);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x85ad);
+        MP_WritePhyUshort(sc, 0x06, 0x2008);
+        MP_WritePhyUshort(sc, 0x06, 0xe08a);
+        MP_WritePhyUshort(sc, 0x06, 0xe8ad);
+        MP_WritePhyUshort(sc, 0x06, 0x2102);
+        MP_WritePhyUshort(sc, 0x06, 0xf62a);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x85ad);
+        MP_WritePhyUshort(sc, 0x06, 0x2308);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x20a0);
+        MP_WritePhyUshort(sc, 0x06, 0x0302);
+        MP_WritePhyUshort(sc, 0x06, 0xf62b);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x87ad);
+        MP_WritePhyUshort(sc, 0x06, 0x2408);
+        MP_WritePhyUshort(sc, 0x06, 0xe08a);
+        MP_WritePhyUshort(sc, 0x06, 0xc2a0);
+        MP_WritePhyUshort(sc, 0x06, 0x0302);
+        MP_WritePhyUshort(sc, 0x06, 0xf62c);
+        MP_WritePhyUshort(sc, 0x06, 0xe58a);
+        MP_WritePhyUshort(sc, 0x06, 0xf4a1);
+        MP_WritePhyUshort(sc, 0x06, 0x0008);
+        MP_WritePhyUshort(sc, 0x06, 0xd100);
+        MP_WritePhyUshort(sc, 0x06, 0xbf22);
+        MP_WritePhyUshort(sc, 0x06, 0x7a02);
+        MP_WritePhyUshort(sc, 0x06, 0x387d);
+        MP_WritePhyUshort(sc, 0x06, 0xfc04);
+        MP_WritePhyUshort(sc, 0x06, 0xee8a);
+        MP_WritePhyUshort(sc, 0x06, 0xc200);
+        MP_WritePhyUshort(sc, 0x06, 0x04f8);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x87ad);
+        MP_WritePhyUshort(sc, 0x06, 0x241e);
+        MP_WritePhyUshort(sc, 0x06, 0xe08a);
+        MP_WritePhyUshort(sc, 0x06, 0xc2a0);
+        MP_WritePhyUshort(sc, 0x06, 0x0005);
+        MP_WritePhyUshort(sc, 0x06, 0x0282);
+        MP_WritePhyUshort(sc, 0x06, 0xb0ae);
+        MP_WritePhyUshort(sc, 0x06, 0xf5a0);
+        MP_WritePhyUshort(sc, 0x06, 0x0105);
+        MP_WritePhyUshort(sc, 0x06, 0x0282);
+        MP_WritePhyUshort(sc, 0x06, 0xc0ae);
+        MP_WritePhyUshort(sc, 0x06, 0x0ba0);
+        MP_WritePhyUshort(sc, 0x06, 0x0205);
+        MP_WritePhyUshort(sc, 0x06, 0x0282);
+        MP_WritePhyUshort(sc, 0x06, 0xcaae);
+        MP_WritePhyUshort(sc, 0x06, 0x03a0);
+        MP_WritePhyUshort(sc, 0x06, 0x0300);
+        MP_WritePhyUshort(sc, 0x06, 0xfc04);
+        MP_WritePhyUshort(sc, 0x06, 0xf8fa);
+        MP_WritePhyUshort(sc, 0x06, 0xef69);
+        MP_WritePhyUshort(sc, 0x06, 0x0282);
+        MP_WritePhyUshort(sc, 0x06, 0xe1ee);
+        MP_WritePhyUshort(sc, 0x06, 0x8ac2);
+        MP_WritePhyUshort(sc, 0x06, 0x01ef);
+        MP_WritePhyUshort(sc, 0x06, 0x96fe);
+        MP_WritePhyUshort(sc, 0x06, 0xfc04);
+        MP_WritePhyUshort(sc, 0x06, 0xf8ee);
+        MP_WritePhyUshort(sc, 0x06, 0x8ac9);
+        MP_WritePhyUshort(sc, 0x06, 0x0002);
+        MP_WritePhyUshort(sc, 0x06, 0x8317);
+        MP_WritePhyUshort(sc, 0x06, 0xfc04);
+        MP_WritePhyUshort(sc, 0x06, 0xf8e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8ac8);
+        MP_WritePhyUshort(sc, 0x06, 0xe18a);
+        MP_WritePhyUshort(sc, 0x06, 0xc91f);
+        MP_WritePhyUshort(sc, 0x06, 0x019e);
+        MP_WritePhyUshort(sc, 0x06, 0x0611);
+        MP_WritePhyUshort(sc, 0x06, 0xe58a);
+        MP_WritePhyUshort(sc, 0x06, 0xc9ae);
+        MP_WritePhyUshort(sc, 0x06, 0x04ee);
+        MP_WritePhyUshort(sc, 0x06, 0x8ac2);
+        MP_WritePhyUshort(sc, 0x06, 0x01fc);
+        MP_WritePhyUshort(sc, 0x06, 0x04f8);
+        MP_WritePhyUshort(sc, 0x06, 0xf9fa);
+        MP_WritePhyUshort(sc, 0x06, 0xef69);
+        MP_WritePhyUshort(sc, 0x06, 0xfbbf);
+        MP_WritePhyUshort(sc, 0x06, 0x8ac4);
+        MP_WritePhyUshort(sc, 0x06, 0xef79);
+        MP_WritePhyUshort(sc, 0x06, 0xd200);
+        MP_WritePhyUshort(sc, 0x06, 0xd400);
+        MP_WritePhyUshort(sc, 0x06, 0x221e);
+        MP_WritePhyUshort(sc, 0x06, 0x02bf);
+        MP_WritePhyUshort(sc, 0x06, 0x3024);
+        MP_WritePhyUshort(sc, 0x06, 0x0238);
+        MP_WritePhyUshort(sc, 0x06, 0x7dbf);
+        MP_WritePhyUshort(sc, 0x06, 0x13ff);
+        MP_WritePhyUshort(sc, 0x06, 0x0238);
+        MP_WritePhyUshort(sc, 0x06, 0x500d);
+        MP_WritePhyUshort(sc, 0x06, 0x4559);
+        MP_WritePhyUshort(sc, 0x06, 0x1fef);
+        MP_WritePhyUshort(sc, 0x06, 0x97dd);
+        MP_WritePhyUshort(sc, 0x06, 0xd308);
+        MP_WritePhyUshort(sc, 0x06, 0x1a93);
+        MP_WritePhyUshort(sc, 0x06, 0xdd12);
+        MP_WritePhyUshort(sc, 0x06, 0x17a2);
+        MP_WritePhyUshort(sc, 0x06, 0x04de);
+        MP_WritePhyUshort(sc, 0x06, 0xffef);
+        MP_WritePhyUshort(sc, 0x06, 0x96fe);
+        MP_WritePhyUshort(sc, 0x06, 0xfdfc);
+        MP_WritePhyUshort(sc, 0x06, 0x04f8);
+        MP_WritePhyUshort(sc, 0x06, 0xf9fa);
+        MP_WritePhyUshort(sc, 0x06, 0xef69);
+        MP_WritePhyUshort(sc, 0x06, 0xfbee);
+        MP_WritePhyUshort(sc, 0x06, 0x8ac2);
+        MP_WritePhyUshort(sc, 0x06, 0x03d5);
+        MP_WritePhyUshort(sc, 0x06, 0x0080);
+        MP_WritePhyUshort(sc, 0x06, 0xbf8a);
+        MP_WritePhyUshort(sc, 0x06, 0xc4ef);
+        MP_WritePhyUshort(sc, 0x06, 0x79ef);
+        MP_WritePhyUshort(sc, 0x06, 0x45bf);
+        MP_WritePhyUshort(sc, 0x06, 0x3024);
+        MP_WritePhyUshort(sc, 0x06, 0x0238);
+        MP_WritePhyUshort(sc, 0x06, 0x7dbf);
+        MP_WritePhyUshort(sc, 0x06, 0x13ff);
+        MP_WritePhyUshort(sc, 0x06, 0x0238);
+        MP_WritePhyUshort(sc, 0x06, 0x50ad);
+        MP_WritePhyUshort(sc, 0x06, 0x2702);
+        MP_WritePhyUshort(sc, 0x06, 0x78ff);
+        MP_WritePhyUshort(sc, 0x06, 0xe18a);
+        MP_WritePhyUshort(sc, 0x06, 0xca1b);
+        MP_WritePhyUshort(sc, 0x06, 0x01aa);
+        MP_WritePhyUshort(sc, 0x06, 0x2eef);
+        MP_WritePhyUshort(sc, 0x06, 0x97d9);
+        MP_WritePhyUshort(sc, 0x06, 0x7900);
+        MP_WritePhyUshort(sc, 0x06, 0x9e2b);
+        MP_WritePhyUshort(sc, 0x06, 0x81dd);
+        MP_WritePhyUshort(sc, 0x06, 0xbf85);
+        MP_WritePhyUshort(sc, 0x06, 0xad02);
+        MP_WritePhyUshort(sc, 0x06, 0x387d);
+        MP_WritePhyUshort(sc, 0x06, 0xd101);
+        MP_WritePhyUshort(sc, 0x06, 0xef02);
+        MP_WritePhyUshort(sc, 0x06, 0x100c);
+        MP_WritePhyUshort(sc, 0x06, 0x11b0);
+        MP_WritePhyUshort(sc, 0x06, 0xfc0d);
+        MP_WritePhyUshort(sc, 0x06, 0x11bf);
+        MP_WritePhyUshort(sc, 0x06, 0x85aa);
+        MP_WritePhyUshort(sc, 0x06, 0x0238);
+        MP_WritePhyUshort(sc, 0x06, 0x7dd1);
+        MP_WritePhyUshort(sc, 0x06, 0x00bf);
+        MP_WritePhyUshort(sc, 0x06, 0x85aa);
+        MP_WritePhyUshort(sc, 0x06, 0x0238);
+        MP_WritePhyUshort(sc, 0x06, 0x7dee);
+        MP_WritePhyUshort(sc, 0x06, 0x8ac2);
+        MP_WritePhyUshort(sc, 0x06, 0x02ae);
+        MP_WritePhyUshort(sc, 0x06, 0x0413);
+        MP_WritePhyUshort(sc, 0x06, 0xa38b);
+        MP_WritePhyUshort(sc, 0x06, 0xb4d3);
+        MP_WritePhyUshort(sc, 0x06, 0x8012);
+        MP_WritePhyUshort(sc, 0x06, 0x17a2);
+        MP_WritePhyUshort(sc, 0x06, 0x04ad);
+        MP_WritePhyUshort(sc, 0x06, 0xffef);
+        MP_WritePhyUshort(sc, 0x06, 0x96fe);
+        MP_WritePhyUshort(sc, 0x06, 0xfdfc);
+        MP_WritePhyUshort(sc, 0x06, 0x04f8);
+        MP_WritePhyUshort(sc, 0x06, 0xf9e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b85);
+        MP_WritePhyUshort(sc, 0x06, 0xad25);
+        MP_WritePhyUshort(sc, 0x06, 0x48e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8a96);
+        MP_WritePhyUshort(sc, 0x06, 0xe18a);
+        MP_WritePhyUshort(sc, 0x06, 0x977c);
+        MP_WritePhyUshort(sc, 0x06, 0x0000);
+        MP_WritePhyUshort(sc, 0x06, 0x9e35);
+        MP_WritePhyUshort(sc, 0x06, 0xee8a);
+        MP_WritePhyUshort(sc, 0x06, 0x9600);
+        MP_WritePhyUshort(sc, 0x06, 0xee8a);
+        MP_WritePhyUshort(sc, 0x06, 0x9700);
+        MP_WritePhyUshort(sc, 0x06, 0xe08a);
+        MP_WritePhyUshort(sc, 0x06, 0xbee1);
+        MP_WritePhyUshort(sc, 0x06, 0x8abf);
+        MP_WritePhyUshort(sc, 0x06, 0xe28a);
+        MP_WritePhyUshort(sc, 0x06, 0xc0e3);
+        MP_WritePhyUshort(sc, 0x06, 0x8ac1);
+        MP_WritePhyUshort(sc, 0x06, 0x0237);
+        MP_WritePhyUshort(sc, 0x06, 0x74ad);
+        MP_WritePhyUshort(sc, 0x06, 0x2012);
+        MP_WritePhyUshort(sc, 0x06, 0xee8a);
+        MP_WritePhyUshort(sc, 0x06, 0x9603);
+        MP_WritePhyUshort(sc, 0x06, 0xee8a);
+        MP_WritePhyUshort(sc, 0x06, 0x97b7);
+        MP_WritePhyUshort(sc, 0x06, 0xee8a);
+        MP_WritePhyUshort(sc, 0x06, 0xc000);
+        MP_WritePhyUshort(sc, 0x06, 0xee8a);
+        MP_WritePhyUshort(sc, 0x06, 0xc100);
+        MP_WritePhyUshort(sc, 0x06, 0xae11);
+        MP_WritePhyUshort(sc, 0x06, 0x15e6);
+        MP_WritePhyUshort(sc, 0x06, 0x8ac0);
+        MP_WritePhyUshort(sc, 0x06, 0xe78a);
+        MP_WritePhyUshort(sc, 0x06, 0xc1ae);
+        MP_WritePhyUshort(sc, 0x06, 0x08ee);
+        MP_WritePhyUshort(sc, 0x06, 0x8ac0);
+        MP_WritePhyUshort(sc, 0x06, 0x00ee);
+        MP_WritePhyUshort(sc, 0x06, 0x8ac1);
+        MP_WritePhyUshort(sc, 0x06, 0x00fd);
+        MP_WritePhyUshort(sc, 0x06, 0xfc04);
+        MP_WritePhyUshort(sc, 0x06, 0xae20);
+        MP_WritePhyUshort(sc, 0x06, 0x0000);
+        MP_WritePhyUshort(sc, 0x06, 0x0000);
+        MP_WritePhyUshort(sc, 0x06, 0x0000);
+        MP_WritePhyUshort(sc, 0x06, 0x0000);
+        MP_WritePhyUshort(sc, 0x06, 0x0000);
+        MP_WritePhyUshort(sc, 0x06, 0x0000);
+        MP_WritePhyUshort(sc, 0x06, 0x0000);
+        MP_WritePhyUshort(sc, 0x06, 0x0000);
+        MP_WritePhyUshort(sc, 0x06, 0x0000);
+        MP_WritePhyUshort(sc, 0x06, 0x0000);
+        MP_WritePhyUshort(sc, 0x06, 0x0000);
+        MP_WritePhyUshort(sc, 0x06, 0x0000);
+        MP_WritePhyUshort(sc, 0x06, 0x0000);
+        MP_WritePhyUshort(sc, 0x06, 0x0000);
+        MP_WritePhyUshort(sc, 0x06, 0x0000);
+        MP_WritePhyUshort(sc, 0x06, 0x0000);
+        MP_WritePhyUshort(sc, 0x06, 0xf8fa);
+        MP_WritePhyUshort(sc, 0x06, 0xef69);
+        MP_WritePhyUshort(sc, 0x06, 0xe0e0);
+        MP_WritePhyUshort(sc, 0x06, 0x00e1);
+        MP_WritePhyUshort(sc, 0x06, 0xe001);
+        MP_WritePhyUshort(sc, 0x06, 0xad27);
+        MP_WritePhyUshort(sc, 0x06, 0x32e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b40);
+        MP_WritePhyUshort(sc, 0x06, 0xf720);
+        MP_WritePhyUshort(sc, 0x06, 0xe48b);
+        MP_WritePhyUshort(sc, 0x06, 0x40bf);
+        MP_WritePhyUshort(sc, 0x06, 0x3230);
+        MP_WritePhyUshort(sc, 0x06, 0x0238);
+        MP_WritePhyUshort(sc, 0x06, 0x50ad);
+        MP_WritePhyUshort(sc, 0x06, 0x2821);
+        MP_WritePhyUshort(sc, 0x06, 0xe0e0);
+        MP_WritePhyUshort(sc, 0x06, 0x20e1);
+        MP_WritePhyUshort(sc, 0x06, 0xe021);
+        MP_WritePhyUshort(sc, 0x06, 0xad20);
+        MP_WritePhyUshort(sc, 0x06, 0x18e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b40);
+        MP_WritePhyUshort(sc, 0x06, 0xf620);
+        MP_WritePhyUshort(sc, 0x06, 0xe48b);
+        MP_WritePhyUshort(sc, 0x06, 0x40ee);
+        MP_WritePhyUshort(sc, 0x06, 0x8b3b);
+        MP_WritePhyUshort(sc, 0x06, 0xffe0);
+        MP_WritePhyUshort(sc, 0x06, 0x8a8a);
+        MP_WritePhyUshort(sc, 0x06, 0xe18a);
+        MP_WritePhyUshort(sc, 0x06, 0x8be4);
+        MP_WritePhyUshort(sc, 0x06, 0xe000);
+        MP_WritePhyUshort(sc, 0x06, 0xe5e0);
+        MP_WritePhyUshort(sc, 0x06, 0x01ef);
+        MP_WritePhyUshort(sc, 0x06, 0x96fe);
+        MP_WritePhyUshort(sc, 0x06, 0xfc04);
+        MP_WritePhyUshort(sc, 0x06, 0xf8f9);
+        MP_WritePhyUshort(sc, 0x06, 0xface);
+        MP_WritePhyUshort(sc, 0x06, 0xfaef);
+        MP_WritePhyUshort(sc, 0x06, 0x69fa);
+        MP_WritePhyUshort(sc, 0x06, 0xd401);
+        MP_WritePhyUshort(sc, 0x06, 0x55b4);
+        MP_WritePhyUshort(sc, 0x06, 0xfebf);
+        MP_WritePhyUshort(sc, 0x06, 0x1c1e);
+        MP_WritePhyUshort(sc, 0x06, 0x0238);
+        MP_WritePhyUshort(sc, 0x06, 0x50ac);
+        MP_WritePhyUshort(sc, 0x06, 0x280b);
+        MP_WritePhyUshort(sc, 0x06, 0xbf1c);
+        MP_WritePhyUshort(sc, 0x06, 0x1b02);
+        MP_WritePhyUshort(sc, 0x06, 0x3850);
+        MP_WritePhyUshort(sc, 0x06, 0xac28);
+        MP_WritePhyUshort(sc, 0x06, 0x49ae);
+        MP_WritePhyUshort(sc, 0x06, 0x64bf);
+        MP_WritePhyUshort(sc, 0x06, 0x1c1b);
+        MP_WritePhyUshort(sc, 0x06, 0x0238);
+        MP_WritePhyUshort(sc, 0x06, 0x50ac);
+        MP_WritePhyUshort(sc, 0x06, 0x285b);
+        MP_WritePhyUshort(sc, 0x06, 0xd000);
+        MP_WritePhyUshort(sc, 0x06, 0x0284);
+        MP_WritePhyUshort(sc, 0x06, 0xcaac);
+        MP_WritePhyUshort(sc, 0x06, 0x2105);
+        MP_WritePhyUshort(sc, 0x06, 0xac22);
+        MP_WritePhyUshort(sc, 0x06, 0x02ae);
+        MP_WritePhyUshort(sc, 0x06, 0x4ebf);
+        MP_WritePhyUshort(sc, 0x06, 0xe0c4);
+        MP_WritePhyUshort(sc, 0x06, 0xbe85);
+        MP_WritePhyUshort(sc, 0x06, 0xf6d2);
+        MP_WritePhyUshort(sc, 0x06, 0x04d8);
+        MP_WritePhyUshort(sc, 0x06, 0x19d9);
+        MP_WritePhyUshort(sc, 0x06, 0x1907);
+        MP_WritePhyUshort(sc, 0x06, 0xdc19);
+        MP_WritePhyUshort(sc, 0x06, 0xdd19);
+        MP_WritePhyUshort(sc, 0x06, 0x0789);
+        MP_WritePhyUshort(sc, 0x06, 0x89ef);
+        MP_WritePhyUshort(sc, 0x06, 0x645e);
+        MP_WritePhyUshort(sc, 0x06, 0x07ff);
+        MP_WritePhyUshort(sc, 0x06, 0x0d65);
+        MP_WritePhyUshort(sc, 0x06, 0x5cf8);
+        MP_WritePhyUshort(sc, 0x06, 0x001e);
+        MP_WritePhyUshort(sc, 0x06, 0x46dc);
+        MP_WritePhyUshort(sc, 0x06, 0x19dd);
+        MP_WritePhyUshort(sc, 0x06, 0x19b2);
+        MP_WritePhyUshort(sc, 0x06, 0xe2d4);
+        MP_WritePhyUshort(sc, 0x06, 0x0001);
+        MP_WritePhyUshort(sc, 0x06, 0xbf1c);
+        MP_WritePhyUshort(sc, 0x06, 0x1b02);
+        MP_WritePhyUshort(sc, 0x06, 0x387d);
+        MP_WritePhyUshort(sc, 0x06, 0xae1d);
+        MP_WritePhyUshort(sc, 0x06, 0xbee0);
+        MP_WritePhyUshort(sc, 0x06, 0xc4bf);
+        MP_WritePhyUshort(sc, 0x06, 0x85f6);
+        MP_WritePhyUshort(sc, 0x06, 0xd204);
+        MP_WritePhyUshort(sc, 0x06, 0xd819);
+        MP_WritePhyUshort(sc, 0x06, 0xd919);
+        MP_WritePhyUshort(sc, 0x06, 0x07dc);
+        MP_WritePhyUshort(sc, 0x06, 0x19dd);
+        MP_WritePhyUshort(sc, 0x06, 0x1907);
+        MP_WritePhyUshort(sc, 0x06, 0xb2f4);
+        MP_WritePhyUshort(sc, 0x06, 0xd400);
+        MP_WritePhyUshort(sc, 0x06, 0x00bf);
+        MP_WritePhyUshort(sc, 0x06, 0x1c1b);
+        MP_WritePhyUshort(sc, 0x06, 0x0238);
+        MP_WritePhyUshort(sc, 0x06, 0x7dfe);
+        MP_WritePhyUshort(sc, 0x06, 0xef96);
+        MP_WritePhyUshort(sc, 0x06, 0xfec6);
+        MP_WritePhyUshort(sc, 0x06, 0xfefd);
+        MP_WritePhyUshort(sc, 0x06, 0xfc05);
+        MP_WritePhyUshort(sc, 0x06, 0xf9e2);
+        MP_WritePhyUshort(sc, 0x06, 0xe0ea);
+        MP_WritePhyUshort(sc, 0x06, 0xe3e0);
+        MP_WritePhyUshort(sc, 0x06, 0xeb5a);
+        MP_WritePhyUshort(sc, 0x06, 0x070c);
+        MP_WritePhyUshort(sc, 0x06, 0x031e);
+        MP_WritePhyUshort(sc, 0x06, 0x20e6);
+        MP_WritePhyUshort(sc, 0x06, 0xe0ea);
+        MP_WritePhyUshort(sc, 0x06, 0xe7e0);
+        MP_WritePhyUshort(sc, 0x06, 0xebe0);
+        MP_WritePhyUshort(sc, 0x06, 0xe0fc);
+        MP_WritePhyUshort(sc, 0x06, 0xe1e0);
+        MP_WritePhyUshort(sc, 0x06, 0xfdfd);
+        MP_WritePhyUshort(sc, 0x06, 0x04f8);
+        MP_WritePhyUshort(sc, 0x06, 0xfaef);
+        MP_WritePhyUshort(sc, 0x06, 0x69e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b80);
+        MP_WritePhyUshort(sc, 0x06, 0xad27);
+        MP_WritePhyUshort(sc, 0x06, 0x22bf);
+        MP_WritePhyUshort(sc, 0x06, 0x4616);
+        MP_WritePhyUshort(sc, 0x06, 0x0238);
+        MP_WritePhyUshort(sc, 0x06, 0x50e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b44);
+        MP_WritePhyUshort(sc, 0x06, 0x1f01);
+        MP_WritePhyUshort(sc, 0x06, 0x9e15);
+        MP_WritePhyUshort(sc, 0x06, 0xe58b);
+        MP_WritePhyUshort(sc, 0x06, 0x44ad);
+        MP_WritePhyUshort(sc, 0x06, 0x2907);
+        MP_WritePhyUshort(sc, 0x06, 0xac28);
+        MP_WritePhyUshort(sc, 0x06, 0x04d1);
+        MP_WritePhyUshort(sc, 0x06, 0x01ae);
+        MP_WritePhyUshort(sc, 0x06, 0x02d1);
+        MP_WritePhyUshort(sc, 0x06, 0x00bf);
+        MP_WritePhyUshort(sc, 0x06, 0x85b0);
+        MP_WritePhyUshort(sc, 0x06, 0x0238);
+        MP_WritePhyUshort(sc, 0x06, 0x7def);
+        MP_WritePhyUshort(sc, 0x06, 0x96fe);
+        MP_WritePhyUshort(sc, 0x06, 0xfc04);
+        MP_WritePhyUshort(sc, 0x06, 0xf8e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b85);
+        MP_WritePhyUshort(sc, 0x06, 0xad26);
+        MP_WritePhyUshort(sc, 0x06, 0x30e0);
+        MP_WritePhyUshort(sc, 0x06, 0xe036);
+        MP_WritePhyUshort(sc, 0x06, 0xe1e0);
+        MP_WritePhyUshort(sc, 0x06, 0x37e1);
+        MP_WritePhyUshort(sc, 0x06, 0x8b3f);
+        MP_WritePhyUshort(sc, 0x06, 0x1f10);
+        MP_WritePhyUshort(sc, 0x06, 0x9e23);
+        MP_WritePhyUshort(sc, 0x06, 0xe48b);
+        MP_WritePhyUshort(sc, 0x06, 0x3fac);
+        MP_WritePhyUshort(sc, 0x06, 0x200b);
+        MP_WritePhyUshort(sc, 0x06, 0xac21);
+        MP_WritePhyUshort(sc, 0x06, 0x0dac);
+        MP_WritePhyUshort(sc, 0x06, 0x250f);
+        MP_WritePhyUshort(sc, 0x06, 0xac27);
+        MP_WritePhyUshort(sc, 0x06, 0x11ae);
+        MP_WritePhyUshort(sc, 0x06, 0x1202);
+        MP_WritePhyUshort(sc, 0x06, 0x2c47);
+        MP_WritePhyUshort(sc, 0x06, 0xae0d);
+        MP_WritePhyUshort(sc, 0x06, 0x0285);
+        MP_WritePhyUshort(sc, 0x06, 0x4fae);
+        MP_WritePhyUshort(sc, 0x06, 0x0802);
+        MP_WritePhyUshort(sc, 0x06, 0x2c69);
+        MP_WritePhyUshort(sc, 0x06, 0xae03);
+        MP_WritePhyUshort(sc, 0x06, 0x022c);
+        MP_WritePhyUshort(sc, 0x06, 0x7cfc);
+        MP_WritePhyUshort(sc, 0x06, 0x04f8);
+        MP_WritePhyUshort(sc, 0x06, 0xfaef);
+        MP_WritePhyUshort(sc, 0x06, 0x6902);
+        MP_WritePhyUshort(sc, 0x06, 0x856c);
+        MP_WritePhyUshort(sc, 0x06, 0xe0e0);
+        MP_WritePhyUshort(sc, 0x06, 0x14e1);
+        MP_WritePhyUshort(sc, 0x06, 0xe015);
+        MP_WritePhyUshort(sc, 0x06, 0xad26);
+        MP_WritePhyUshort(sc, 0x06, 0x08d1);
+        MP_WritePhyUshort(sc, 0x06, 0x1ebf);
+        MP_WritePhyUshort(sc, 0x06, 0x2cd9);
+        MP_WritePhyUshort(sc, 0x06, 0x0238);
+        MP_WritePhyUshort(sc, 0x06, 0x7def);
+        MP_WritePhyUshort(sc, 0x06, 0x96fe);
+        MP_WritePhyUshort(sc, 0x06, 0xfc04);
+        MP_WritePhyUshort(sc, 0x06, 0xf8e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b85);
+        MP_WritePhyUshort(sc, 0x06, 0xad27);
+        MP_WritePhyUshort(sc, 0x06, 0x2fd0);
+        MP_WritePhyUshort(sc, 0x06, 0x0b02);
+        MP_WritePhyUshort(sc, 0x06, 0x3682);
+        MP_WritePhyUshort(sc, 0x06, 0x5882);
+        MP_WritePhyUshort(sc, 0x06, 0x7882);
+        MP_WritePhyUshort(sc, 0x06, 0x9f24);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x32e1);
+        MP_WritePhyUshort(sc, 0x06, 0x8b33);
+        MP_WritePhyUshort(sc, 0x06, 0x1f10);
+        MP_WritePhyUshort(sc, 0x06, 0x9e1a);
+        MP_WritePhyUshort(sc, 0x06, 0x10e4);
+        MP_WritePhyUshort(sc, 0x06, 0x8b32);
+        MP_WritePhyUshort(sc, 0x06, 0xe0e0);
+        MP_WritePhyUshort(sc, 0x06, 0x28e1);
+        MP_WritePhyUshort(sc, 0x06, 0xe029);
+        MP_WritePhyUshort(sc, 0x06, 0xf72c);
+        MP_WritePhyUshort(sc, 0x06, 0xe4e0);
+        MP_WritePhyUshort(sc, 0x06, 0x28e5);
+        MP_WritePhyUshort(sc, 0x06, 0xe029);
+        MP_WritePhyUshort(sc, 0x06, 0xf62c);
+        MP_WritePhyUshort(sc, 0x06, 0xe4e0);
+        MP_WritePhyUshort(sc, 0x06, 0x28e5);
+        MP_WritePhyUshort(sc, 0x06, 0xe029);
+        MP_WritePhyUshort(sc, 0x06, 0xfc04);
+        MP_WritePhyUshort(sc, 0x06, 0x00e1);
+        MP_WritePhyUshort(sc, 0x06, 0x4077);
+        MP_WritePhyUshort(sc, 0x06, 0xe140);
+        MP_WritePhyUshort(sc, 0x06, 0x52e0);
+        MP_WritePhyUshort(sc, 0x06, 0xeed9);
+        MP_WritePhyUshort(sc, 0x06, 0xe04c);
+        MP_WritePhyUshort(sc, 0x06, 0xbbe0);
+        MP_WritePhyUshort(sc, 0x06, 0x2a00);
+        MP_WritePhyUshort(sc, 0x05, 0xe142);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x06);
+        PhyRegValue |= BIT_0;
+        MP_WritePhyUshort(sc, 0x06, PhyRegValue);
+        MP_WritePhyUshort(sc, 0x05, 0xe140);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x06);
+        PhyRegValue |= BIT_0;
+        MP_WritePhyUshort(sc, 0x06, PhyRegValue);
+        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+        MP_WritePhyUshort(sc, 0x1f, 0x0005);
+        for (i = 0; i < 200; i++) {
+                DELAY(100);
+                PhyRegValue = MP_ReadPhyUshort(sc, 0x00);
+                if (PhyRegValue & BIT_7)
+                        break;
+        }
+
+        MP_WritePhyUshort(sc, 0x1f, 0x0007);
+        MP_WritePhyUshort(sc, 0x1e, 0x0023);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
+        PhyRegValue |= BIT_1;
+        if (sc->RequiredSecLanDonglePatch)
+                PhyRegValue &= ~(BIT_2);
+        MP_WritePhyUshort(sc, 0x17, PhyRegValue);
+        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+
+        MP_WritePhyUshort(sc, 0x1f, 0x0003);
+        MP_WritePhyUshort(sc, 0x09, 0xA20F);
+        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+
+        MP_WritePhyUshort(sc, 0x1f, 0x0003);
+        MP_WritePhyUshort(sc, 0x01, 0x328A);
+        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+
+        MP_WritePhyUshort(sc, 0x1f, 0x0003);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x19);
+        PhyRegValue &= ~BIT_0;
+        MP_WritePhyUshort(sc, 0x19, PhyRegValue);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
+        PhyRegValue &= ~BIT_10;
+        MP_WritePhyUshort(sc, 0x10, PhyRegValue);
+        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+
+
+        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+        MP_WritePhyUshort(sc, 0x00, 0x9200);
+}
+
+static void re_set_phy_mcu_8168f_2(struct re_softc *sc)
+{
+        u_int16_t PhyRegValue;
+        int i;
+
+        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+        MP_WritePhyUshort(sc, 0x00, 0x1800);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x15);
+        PhyRegValue &= ~(BIT_12);
+        MP_WritePhyUshort(sc, 0x15, PhyRegValue);
+        MP_WritePhyUshort(sc, 0x00, 0x9800);
+        MP_WritePhyUshort(sc, 0x1f, 0x0007);
+        MP_WritePhyUshort(sc, 0x1e, 0x002f);
+        for (i = 0; i < 1000; i++) {
+                DELAY(100);
+                PhyRegValue = MP_ReadPhyUshort(sc, 0x1c);
+                if (PhyRegValue & BIT_7)
+                        break;
+        }
+        MP_WritePhyUshort(sc, 0x1f, 0x0007);
+        MP_WritePhyUshort(sc, 0x1e, 0x0023);
+        MP_WritePhyUshort(sc, 0x16, 0x0306);
+        MP_WritePhyUshort(sc, 0x16, 0x0307);
+        MP_WritePhyUshort(sc, 0x15, 0x0098);
+        MP_WritePhyUshort(sc, 0x19, 0x7c0b);
+        MP_WritePhyUshort(sc, 0x15, 0x0099);
+        MP_WritePhyUshort(sc, 0x19, 0x6c0b);
+        MP_WritePhyUshort(sc, 0x15, 0x00eb);
+        MP_WritePhyUshort(sc, 0x19, 0x6c0b);
+        MP_WritePhyUshort(sc, 0x15, 0x00f8);
+        MP_WritePhyUshort(sc, 0x19, 0x6f0b);
+        MP_WritePhyUshort(sc, 0x15, 0x00fe);
+        MP_WritePhyUshort(sc, 0x19, 0x6f0f);
+        MP_WritePhyUshort(sc, 0x15, 0x00db);
+        MP_WritePhyUshort(sc, 0x19, 0x6f09);
+        MP_WritePhyUshort(sc, 0x15, 0x00dc);
+        MP_WritePhyUshort(sc, 0x19, 0xaefd);
+        MP_WritePhyUshort(sc, 0x15, 0x00dd);
+        MP_WritePhyUshort(sc, 0x19, 0x6f0b);
+        MP_WritePhyUshort(sc, 0x15, 0x00de);
+        MP_WritePhyUshort(sc, 0x19, 0xc60b);
+        MP_WritePhyUshort(sc, 0x15, 0x00df);
+        MP_WritePhyUshort(sc, 0x19, 0x00fa);
+        MP_WritePhyUshort(sc, 0x15, 0x00e0);
+        MP_WritePhyUshort(sc, 0x19, 0x30e1);
+        MP_WritePhyUshort(sc, 0x15, 0x020c);
+        MP_WritePhyUshort(sc, 0x19, 0x3224);
+        MP_WritePhyUshort(sc, 0x15, 0x020e);
+        MP_WritePhyUshort(sc, 0x19, 0x9813);
+        MP_WritePhyUshort(sc, 0x15, 0x020f);
+        MP_WritePhyUshort(sc, 0x19, 0x7801);
+        MP_WritePhyUshort(sc, 0x15, 0x0210);
+        MP_WritePhyUshort(sc, 0x19, 0x930f);
+        MP_WritePhyUshort(sc, 0x15, 0x0211);
+        MP_WritePhyUshort(sc, 0x19, 0x9206);
+        MP_WritePhyUshort(sc, 0x15, 0x0212);
+        MP_WritePhyUshort(sc, 0x19, 0x4002);
+        MP_WritePhyUshort(sc, 0x15, 0x0213);
+        MP_WritePhyUshort(sc, 0x19, 0x7800);
+        MP_WritePhyUshort(sc, 0x15, 0x0214);
+        MP_WritePhyUshort(sc, 0x19, 0x588f);
+        MP_WritePhyUshort(sc, 0x15, 0x0215);
+        MP_WritePhyUshort(sc, 0x19, 0x5520);
+        MP_WritePhyUshort(sc, 0x15, 0x0216);
+        MP_WritePhyUshort(sc, 0x19, 0x3224);
+        MP_WritePhyUshort(sc, 0x15, 0x0217);
+        MP_WritePhyUshort(sc, 0x19, 0x4002);
+        MP_WritePhyUshort(sc, 0x15, 0x0218);
+        MP_WritePhyUshort(sc, 0x19, 0x7800);
+        MP_WritePhyUshort(sc, 0x15, 0x0219);
+        MP_WritePhyUshort(sc, 0x19, 0x588d);
+        MP_WritePhyUshort(sc, 0x15, 0x021a);
+        MP_WritePhyUshort(sc, 0x19, 0x5540);
+        MP_WritePhyUshort(sc, 0x15, 0x021b);
+        MP_WritePhyUshort(sc, 0x19, 0x9e03);
+        MP_WritePhyUshort(sc, 0x15, 0x021c);
+        MP_WritePhyUshort(sc, 0x19, 0x7c40);
+        MP_WritePhyUshort(sc, 0x15, 0x021d);
+        MP_WritePhyUshort(sc, 0x19, 0x6840);
+        MP_WritePhyUshort(sc, 0x15, 0x021e);
+        MP_WritePhyUshort(sc, 0x19, 0x3224);
+        MP_WritePhyUshort(sc, 0x15, 0x021f);
+        MP_WritePhyUshort(sc, 0x19, 0x4002);
+        MP_WritePhyUshort(sc, 0x15, 0x0220);
+        MP_WritePhyUshort(sc, 0x19, 0x3224);
+        MP_WritePhyUshort(sc, 0x15, 0x0221);
+        MP_WritePhyUshort(sc, 0x19, 0x9e03);
+        MP_WritePhyUshort(sc, 0x15, 0x0222);
+        MP_WritePhyUshort(sc, 0x19, 0x7c40);
+        MP_WritePhyUshort(sc, 0x15, 0x0223);
+        MP_WritePhyUshort(sc, 0x19, 0x6840);
+        MP_WritePhyUshort(sc, 0x15, 0x0224);
+        MP_WritePhyUshort(sc, 0x19, 0x7800);
+        MP_WritePhyUshort(sc, 0x15, 0x0225);
+        MP_WritePhyUshort(sc, 0x19, 0x3231);
+        MP_WritePhyUshort(sc, 0x15, 0x0000);
+        MP_WritePhyUshort(sc, 0x16, 0x0306);
+        MP_WritePhyUshort(sc, 0x16, 0x0300);
+        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+        MP_WritePhyUshort(sc, 0x1f, 0x0005);
+        MP_WritePhyUshort(sc, 0x05, 0xfff6);
+        MP_WritePhyUshort(sc, 0x06, 0x0080);
+        MP_WritePhyUshort(sc, 0x05, 0x8000);
+        MP_WritePhyUshort(sc, 0x06, 0x0280);
+        MP_WritePhyUshort(sc, 0x06, 0x48f7);
+        MP_WritePhyUshort(sc, 0x06, 0x00e0);
+        MP_WritePhyUshort(sc, 0x06, 0xfff7);
+        MP_WritePhyUshort(sc, 0x06, 0xa080);
+        MP_WritePhyUshort(sc, 0x06, 0x02ae);
+        MP_WritePhyUshort(sc, 0x06, 0xf602);
+        MP_WritePhyUshort(sc, 0x06, 0x011b);
+        MP_WritePhyUshort(sc, 0x06, 0x0201);
+        MP_WritePhyUshort(sc, 0x06, 0x2802);
+        MP_WritePhyUshort(sc, 0x06, 0x0135);
+        MP_WritePhyUshort(sc, 0x06, 0x0201);
+        MP_WritePhyUshort(sc, 0x06, 0x4502);
+        MP_WritePhyUshort(sc, 0x06, 0x015f);
+        MP_WritePhyUshort(sc, 0x06, 0x0280);
+        MP_WritePhyUshort(sc, 0x06, 0x6b02);
+        MP_WritePhyUshort(sc, 0x06, 0x80e5);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x88e1);
+        MP_WritePhyUshort(sc, 0x06, 0x8b89);
+        MP_WritePhyUshort(sc, 0x06, 0x1e01);
+        MP_WritePhyUshort(sc, 0x06, 0xe18b);
+        MP_WritePhyUshort(sc, 0x06, 0x8a1e);
+        MP_WritePhyUshort(sc, 0x06, 0x01e1);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8b);
+        MP_WritePhyUshort(sc, 0x06, 0x1e01);
+        MP_WritePhyUshort(sc, 0x06, 0xe18b);
+        MP_WritePhyUshort(sc, 0x06, 0x8c1e);
+        MP_WritePhyUshort(sc, 0x06, 0x01e1);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8d);
+        MP_WritePhyUshort(sc, 0x06, 0x1e01);
+        MP_WritePhyUshort(sc, 0x06, 0xe18b);
+        MP_WritePhyUshort(sc, 0x06, 0x8e1e);
+        MP_WritePhyUshort(sc, 0x06, 0x01a0);
+        MP_WritePhyUshort(sc, 0x06, 0x00c7);
+        MP_WritePhyUshort(sc, 0x06, 0xaebb);
+        MP_WritePhyUshort(sc, 0x06, 0xbf8b);
+        MP_WritePhyUshort(sc, 0x06, 0x88ec);
+        MP_WritePhyUshort(sc, 0x06, 0x0019);
+        MP_WritePhyUshort(sc, 0x06, 0xa98b);
+        MP_WritePhyUshort(sc, 0x06, 0x90f9);
+        MP_WritePhyUshort(sc, 0x06, 0xeeff);
+        MP_WritePhyUshort(sc, 0x06, 0xf600);
+        MP_WritePhyUshort(sc, 0x06, 0xeeff);
+        MP_WritePhyUshort(sc, 0x06, 0xf7fe);
+        MP_WritePhyUshort(sc, 0x06, 0xd100);
+        MP_WritePhyUshort(sc, 0x06, 0xbf81);
+        MP_WritePhyUshort(sc, 0x06, 0x9802);
+        MP_WritePhyUshort(sc, 0x06, 0x39f3);
+        MP_WritePhyUshort(sc, 0x06, 0xd101);
+        MP_WritePhyUshort(sc, 0x06, 0xbf81);
+        MP_WritePhyUshort(sc, 0x06, 0x9b02);
+        MP_WritePhyUshort(sc, 0x06, 0x39f3);
+        MP_WritePhyUshort(sc, 0x06, 0x04f8);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x8dad);
+        MP_WritePhyUshort(sc, 0x06, 0x2014);
+        MP_WritePhyUshort(sc, 0x06, 0xee8b);
+        MP_WritePhyUshort(sc, 0x06, 0x8d00);
+        MP_WritePhyUshort(sc, 0x06, 0xe08a);
+        MP_WritePhyUshort(sc, 0x06, 0x5a78);
+        MP_WritePhyUshort(sc, 0x06, 0x039e);
+        MP_WritePhyUshort(sc, 0x06, 0x0902);
+        MP_WritePhyUshort(sc, 0x06, 0x05fc);
+        MP_WritePhyUshort(sc, 0x06, 0x0280);
+        MP_WritePhyUshort(sc, 0x06, 0x8802);
+        MP_WritePhyUshort(sc, 0x06, 0x32dd);
+        MP_WritePhyUshort(sc, 0x06, 0xfc04);
+        MP_WritePhyUshort(sc, 0x06, 0xf8f9);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x81ac);
+        MP_WritePhyUshort(sc, 0x06, 0x261a);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x81ac);
+        MP_WritePhyUshort(sc, 0x06, 0x2114);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x85ac);
+        MP_WritePhyUshort(sc, 0x06, 0x200e);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x85ac);
+        MP_WritePhyUshort(sc, 0x06, 0x2308);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x87ac);
+        MP_WritePhyUshort(sc, 0x06, 0x2402);
+        MP_WritePhyUshort(sc, 0x06, 0xae38);
+        MP_WritePhyUshort(sc, 0x06, 0x021a);
+        MP_WritePhyUshort(sc, 0x06, 0xd6ee);
+        MP_WritePhyUshort(sc, 0x06, 0xe41c);
+        MP_WritePhyUshort(sc, 0x06, 0x04ee);
+        MP_WritePhyUshort(sc, 0x06, 0xe41d);
+        MP_WritePhyUshort(sc, 0x06, 0x04e2);
+        MP_WritePhyUshort(sc, 0x06, 0xe07c);
+        MP_WritePhyUshort(sc, 0x06, 0xe3e0);
+        MP_WritePhyUshort(sc, 0x06, 0x7de0);
+        MP_WritePhyUshort(sc, 0x06, 0xe038);
+        MP_WritePhyUshort(sc, 0x06, 0xe1e0);
+        MP_WritePhyUshort(sc, 0x06, 0x39ad);
+        MP_WritePhyUshort(sc, 0x06, 0x2e1b);
+        MP_WritePhyUshort(sc, 0x06, 0xad39);
+        MP_WritePhyUshort(sc, 0x06, 0x0dd1);
+        MP_WritePhyUshort(sc, 0x06, 0x01bf);
+        MP_WritePhyUshort(sc, 0x06, 0x22c8);
+        MP_WritePhyUshort(sc, 0x06, 0x0239);
+        MP_WritePhyUshort(sc, 0x06, 0xf302);
+        MP_WritePhyUshort(sc, 0x06, 0x21f0);
+        MP_WritePhyUshort(sc, 0x06, 0xae0b);
+        MP_WritePhyUshort(sc, 0x06, 0xac38);
+        MP_WritePhyUshort(sc, 0x06, 0x02ae);
+        MP_WritePhyUshort(sc, 0x06, 0x0602);
+        MP_WritePhyUshort(sc, 0x06, 0x222d);
+        MP_WritePhyUshort(sc, 0x06, 0x0222);
+        MP_WritePhyUshort(sc, 0x06, 0x7202);
+        MP_WritePhyUshort(sc, 0x06, 0x1ae7);
+        MP_WritePhyUshort(sc, 0x06, 0xfdfc);
+        MP_WritePhyUshort(sc, 0x06, 0x04f8);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x8ead);
+        MP_WritePhyUshort(sc, 0x06, 0x201a);
+        MP_WritePhyUshort(sc, 0x06, 0xf620);
+        MP_WritePhyUshort(sc, 0x06, 0xe48b);
+        MP_WritePhyUshort(sc, 0x06, 0x8e02);
+        MP_WritePhyUshort(sc, 0x06, 0x2afe);
+        MP_WritePhyUshort(sc, 0x06, 0x022c);
+        MP_WritePhyUshort(sc, 0x06, 0x5c02);
+        MP_WritePhyUshort(sc, 0x06, 0x03c5);
+        MP_WritePhyUshort(sc, 0x06, 0x0281);
+        MP_WritePhyUshort(sc, 0x06, 0x6702);
+        MP_WritePhyUshort(sc, 0x06, 0x2e4f);
+        MP_WritePhyUshort(sc, 0x06, 0x0204);
+        MP_WritePhyUshort(sc, 0x06, 0x8902);
+        MP_WritePhyUshort(sc, 0x06, 0x2f7a);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x8ead);
+        MP_WritePhyUshort(sc, 0x06, 0x210b);
+        MP_WritePhyUshort(sc, 0x06, 0xf621);
+        MP_WritePhyUshort(sc, 0x06, 0xe48b);
+        MP_WritePhyUshort(sc, 0x06, 0x8e02);
+        MP_WritePhyUshort(sc, 0x06, 0x0445);
+        MP_WritePhyUshort(sc, 0x06, 0x021c);
+        MP_WritePhyUshort(sc, 0x06, 0xb8e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8e);
+        MP_WritePhyUshort(sc, 0x06, 0xad22);
+        MP_WritePhyUshort(sc, 0x06, 0x08f6);
+        MP_WritePhyUshort(sc, 0x06, 0x22e4);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8e);
+        MP_WritePhyUshort(sc, 0x06, 0x0235);
+        MP_WritePhyUshort(sc, 0x06, 0xd4e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8e);
+        MP_WritePhyUshort(sc, 0x06, 0xad23);
+        MP_WritePhyUshort(sc, 0x06, 0x08f6);
+        MP_WritePhyUshort(sc, 0x06, 0x23e4);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8e);
+        MP_WritePhyUshort(sc, 0x06, 0x0231);
+        MP_WritePhyUshort(sc, 0x06, 0xc8e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8e);
+        MP_WritePhyUshort(sc, 0x06, 0xad24);
+        MP_WritePhyUshort(sc, 0x06, 0x05f6);
+        MP_WritePhyUshort(sc, 0x06, 0x24e4);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8e);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x8ead);
+        MP_WritePhyUshort(sc, 0x06, 0x2505);
+        MP_WritePhyUshort(sc, 0x06, 0xf625);
+        MP_WritePhyUshort(sc, 0x06, 0xe48b);
+        MP_WritePhyUshort(sc, 0x06, 0x8ee0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8e);
+        MP_WritePhyUshort(sc, 0x06, 0xad26);
+        MP_WritePhyUshort(sc, 0x06, 0x08f6);
+        MP_WritePhyUshort(sc, 0x06, 0x26e4);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8e);
+        MP_WritePhyUshort(sc, 0x06, 0x022d);
+        MP_WritePhyUshort(sc, 0x06, 0x6ae0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8e);
+        MP_WritePhyUshort(sc, 0x06, 0xad27);
+        MP_WritePhyUshort(sc, 0x06, 0x05f6);
+        MP_WritePhyUshort(sc, 0x06, 0x27e4);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8e);
+        MP_WritePhyUshort(sc, 0x06, 0x0203);
+        MP_WritePhyUshort(sc, 0x06, 0x8bfc);
+        MP_WritePhyUshort(sc, 0x06, 0x04f8);
+        MP_WritePhyUshort(sc, 0x06, 0xfaef);
+        MP_WritePhyUshort(sc, 0x06, 0x69e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b80);
+        MP_WritePhyUshort(sc, 0x06, 0xad27);
+        MP_WritePhyUshort(sc, 0x06, 0x22bf);
+        MP_WritePhyUshort(sc, 0x06, 0x479a);
+        MP_WritePhyUshort(sc, 0x06, 0x0239);
+        MP_WritePhyUshort(sc, 0x06, 0xc6e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b44);
+        MP_WritePhyUshort(sc, 0x06, 0x1f01);
+        MP_WritePhyUshort(sc, 0x06, 0x9e15);
+        MP_WritePhyUshort(sc, 0x06, 0xe58b);
+        MP_WritePhyUshort(sc, 0x06, 0x44ad);
+        MP_WritePhyUshort(sc, 0x06, 0x2907);
+        MP_WritePhyUshort(sc, 0x06, 0xac28);
+        MP_WritePhyUshort(sc, 0x06, 0x04d1);
+        MP_WritePhyUshort(sc, 0x06, 0x01ae);
+        MP_WritePhyUshort(sc, 0x06, 0x02d1);
+        MP_WritePhyUshort(sc, 0x06, 0x00bf);
+        MP_WritePhyUshort(sc, 0x06, 0x819e);
+        MP_WritePhyUshort(sc, 0x06, 0x0239);
+        MP_WritePhyUshort(sc, 0x06, 0xf3ef);
+        MP_WritePhyUshort(sc, 0x06, 0x96fe);
+        MP_WritePhyUshort(sc, 0x06, 0xfc04);
+        MP_WritePhyUshort(sc, 0x06, 0x00e1);
+        MP_WritePhyUshort(sc, 0x06, 0x4077);
+        MP_WritePhyUshort(sc, 0x06, 0xe140);
+        MP_WritePhyUshort(sc, 0x06, 0xbbe0);
+        MP_WritePhyUshort(sc, 0x06, 0x2a00);
+        MP_WritePhyUshort(sc, 0x05, 0xe142);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x06);
+        PhyRegValue |= BIT_0;
+        MP_WritePhyUshort(sc, 0x06, PhyRegValue);
+        MP_WritePhyUshort(sc, 0x05, 0xe140);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x06);
+        PhyRegValue |= BIT_0;
+        MP_WritePhyUshort(sc, 0x06, PhyRegValue);
+        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+        MP_WritePhyUshort(sc, 0x1f, 0x0007);
+        MP_WritePhyUshort(sc, 0x1e, 0x0023);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
+        PhyRegValue |= BIT_1;
+        if (sc->RequiredSecLanDonglePatch)
+                PhyRegValue &= ~(BIT_2);
+        MP_WritePhyUshort(sc, 0x17, PhyRegValue);
+        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+
+        MP_WritePhyUshort(sc, 0x1f, 0x0003);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x19);
+        PhyRegValue &= ~BIT_0;
+        MP_WritePhyUshort(sc, 0x19, PhyRegValue);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
+        PhyRegValue &= ~BIT_10;
+        MP_WritePhyUshort(sc, 0x10, PhyRegValue);
+
+        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+        MP_WritePhyUshort(sc, 0x00, 0x9200);
+}
+
+static void re_set_phy_mcu_8411_1(struct re_softc *sc)
+{
+        u_int16_t PhyRegValue;
+        int i;
+
+        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+        MP_WritePhyUshort(sc, 0x00, 0x1800);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x15);
+        PhyRegValue &= ~(BIT_12);
+        MP_WritePhyUshort(sc, 0x15, PhyRegValue);
+        MP_WritePhyUshort(sc, 0x00, 0x4800);
+        MP_WritePhyUshort(sc, 0x1f, 0x0007);
+        MP_WritePhyUshort(sc, 0x1e, 0x002f);
+        for (i = 0; i < 1000; i++) {
+                DELAY(100);
+                PhyRegValue = MP_ReadPhyUshort(sc, 0x1c);
+                if (PhyRegValue & BIT_7)
+                        break;
+        }
+        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+        MP_WritePhyUshort(sc, 0x00, 0x1800);
+        MP_WritePhyUshort(sc, 0x1f, 0x0007);
+        MP_WritePhyUshort(sc, 0x1e, 0x0023);
+        for (i = 0; i < 200; i++) {
+                DELAY(100);
+                PhyRegValue = MP_ReadPhyUshort(sc, 0x18);
+                if (!(PhyRegValue & BIT_0))
+                        break;
+        }
+        MP_WritePhyUshort(sc, 0x1f, 0x0005);
+        MP_WritePhyUshort(sc, 0x05, 0xfff6);
+        MP_WritePhyUshort(sc, 0x06, 0x0080);
+        MP_WritePhyUshort(sc, 0x1f, 0x0007);
+        MP_WritePhyUshort(sc, 0x1e, 0x0023);
+        MP_WritePhyUshort(sc, 0x16, 0x0306);
+        MP_WritePhyUshort(sc, 0x16, 0x0307);
+        MP_WritePhyUshort(sc, 0x15, 0x0098);
+        MP_WritePhyUshort(sc, 0x19, 0x7c0b);
+        MP_WritePhyUshort(sc, 0x15, 0x0099);
+        MP_WritePhyUshort(sc, 0x19, 0x6c0b);
+        MP_WritePhyUshort(sc, 0x15, 0x00eb);
+        MP_WritePhyUshort(sc, 0x19, 0x6c0b);
+        MP_WritePhyUshort(sc, 0x15, 0x00f8);
+        MP_WritePhyUshort(sc, 0x19, 0x6f0b);
+        MP_WritePhyUshort(sc, 0x15, 0x00fe);
+        MP_WritePhyUshort(sc, 0x19, 0x6f0f);
+        MP_WritePhyUshort(sc, 0x15, 0x00db);
+        MP_WritePhyUshort(sc, 0x19, 0x6f09);
+        MP_WritePhyUshort(sc, 0x15, 0x00dc);
+        MP_WritePhyUshort(sc, 0x19, 0xaefd);
+        MP_WritePhyUshort(sc, 0x15, 0x00dd);
+        MP_WritePhyUshort(sc, 0x19, 0x6f0b);
+        MP_WritePhyUshort(sc, 0x15, 0x00de);
+        MP_WritePhyUshort(sc, 0x19, 0xc60b);
+        MP_WritePhyUshort(sc, 0x15, 0x00df);
+        MP_WritePhyUshort(sc, 0x19, 0x00fa);
+        MP_WritePhyUshort(sc, 0x15, 0x00e0);
+        MP_WritePhyUshort(sc, 0x19, 0x30e1);
+        MP_WritePhyUshort(sc, 0x15, 0x020c);
+        MP_WritePhyUshort(sc, 0x19, 0x3224);
+        MP_WritePhyUshort(sc, 0x15, 0x020e);
+        MP_WritePhyUshort(sc, 0x19, 0x9813);
+        MP_WritePhyUshort(sc, 0x15, 0x020f);
+        MP_WritePhyUshort(sc, 0x19, 0x7801);
+        MP_WritePhyUshort(sc, 0x15, 0x0210);
+        MP_WritePhyUshort(sc, 0x19, 0x930f);
+        MP_WritePhyUshort(sc, 0x15, 0x0211);
+        MP_WritePhyUshort(sc, 0x19, 0x9206);
+        MP_WritePhyUshort(sc, 0x15, 0x0212);
+        MP_WritePhyUshort(sc, 0x19, 0x4002);
+        MP_WritePhyUshort(sc, 0x15, 0x0213);
+        MP_WritePhyUshort(sc, 0x19, 0x7800);
+        MP_WritePhyUshort(sc, 0x15, 0x0214);
+        MP_WritePhyUshort(sc, 0x19, 0x588f);
+        MP_WritePhyUshort(sc, 0x15, 0x0215);
+        MP_WritePhyUshort(sc, 0x19, 0x5520);
+        MP_WritePhyUshort(sc, 0x15, 0x0216);
+        MP_WritePhyUshort(sc, 0x19, 0x3224);
+        MP_WritePhyUshort(sc, 0x15, 0x0217);
+        MP_WritePhyUshort(sc, 0x19, 0x4002);
+        MP_WritePhyUshort(sc, 0x15, 0x0218);
+        MP_WritePhyUshort(sc, 0x19, 0x7800);
+        MP_WritePhyUshort(sc, 0x15, 0x0219);
+        MP_WritePhyUshort(sc, 0x19, 0x588d);
+        MP_WritePhyUshort(sc, 0x15, 0x021a);
+        MP_WritePhyUshort(sc, 0x19, 0x5540);
+        MP_WritePhyUshort(sc, 0x15, 0x021b);
+        MP_WritePhyUshort(sc, 0x19, 0x9e03);
+        MP_WritePhyUshort(sc, 0x15, 0x021c);
+        MP_WritePhyUshort(sc, 0x19, 0x7c40);
+        MP_WritePhyUshort(sc, 0x15, 0x021d);
+        MP_WritePhyUshort(sc, 0x19, 0x6840);
+        MP_WritePhyUshort(sc, 0x15, 0x021e);
+        MP_WritePhyUshort(sc, 0x19, 0x3224);
+        MP_WritePhyUshort(sc, 0x15, 0x021f);
+        MP_WritePhyUshort(sc, 0x19, 0x4002);
+        MP_WritePhyUshort(sc, 0x15, 0x0220);
+        MP_WritePhyUshort(sc, 0x19, 0x3224);
+        MP_WritePhyUshort(sc, 0x15, 0x0221);
+        MP_WritePhyUshort(sc, 0x19, 0x9e03);
+        MP_WritePhyUshort(sc, 0x15, 0x0222);
+        MP_WritePhyUshort(sc, 0x19, 0x7c40);
+        MP_WritePhyUshort(sc, 0x15, 0x0223);
+        MP_WritePhyUshort(sc, 0x19, 0x6840);
+        MP_WritePhyUshort(sc, 0x15, 0x0224);
+        MP_WritePhyUshort(sc, 0x19, 0x7800);
+        MP_WritePhyUshort(sc, 0x15, 0x0225);
+        MP_WritePhyUshort(sc, 0x19, 0x3231);
+        MP_WritePhyUshort(sc, 0x15, 0x0000);
+        MP_WritePhyUshort(sc, 0x16, 0x0306);
+        MP_WritePhyUshort(sc, 0x16, 0x0300);
+        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+        MP_WritePhyUshort(sc, 0x1f, 0x0005);
+        MP_WritePhyUshort(sc, 0x05, 0xfff6);
+        MP_WritePhyUshort(sc, 0x06, 0x0080);
+        MP_WritePhyUshort(sc, 0x05, 0x8000);
+        MP_WritePhyUshort(sc, 0x06, 0x0280);
+        MP_WritePhyUshort(sc, 0x06, 0x48f7);
+        MP_WritePhyUshort(sc, 0x06, 0x00e0);
+        MP_WritePhyUshort(sc, 0x06, 0xfff7);
+        MP_WritePhyUshort(sc, 0x06, 0xa080);
+        MP_WritePhyUshort(sc, 0x06, 0x02ae);
+        MP_WritePhyUshort(sc, 0x06, 0xf602);
+        MP_WritePhyUshort(sc, 0x06, 0x011e);
+        MP_WritePhyUshort(sc, 0x06, 0x0201);
+        MP_WritePhyUshort(sc, 0x06, 0x2b02);
+        MP_WritePhyUshort(sc, 0x06, 0x8077);
+        MP_WritePhyUshort(sc, 0x06, 0x0201);
+        MP_WritePhyUshort(sc, 0x06, 0x4802);
+        MP_WritePhyUshort(sc, 0x06, 0x0162);
+        MP_WritePhyUshort(sc, 0x06, 0x0280);
+        MP_WritePhyUshort(sc, 0x06, 0x9402);
+        MP_WritePhyUshort(sc, 0x06, 0x810e);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x88e1);
+        MP_WritePhyUshort(sc, 0x06, 0x8b89);
+        MP_WritePhyUshort(sc, 0x06, 0x1e01);
+        MP_WritePhyUshort(sc, 0x06, 0xe18b);
+        MP_WritePhyUshort(sc, 0x06, 0x8a1e);
+        MP_WritePhyUshort(sc, 0x06, 0x01e1);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8b);
+        MP_WritePhyUshort(sc, 0x06, 0x1e01);
+        MP_WritePhyUshort(sc, 0x06, 0xe18b);
+        MP_WritePhyUshort(sc, 0x06, 0x8c1e);
+        MP_WritePhyUshort(sc, 0x06, 0x01e1);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8d);
+        MP_WritePhyUshort(sc, 0x06, 0x1e01);
+        MP_WritePhyUshort(sc, 0x06, 0xe18b);
+        MP_WritePhyUshort(sc, 0x06, 0x8e1e);
+        MP_WritePhyUshort(sc, 0x06, 0x01a0);
+        MP_WritePhyUshort(sc, 0x06, 0x00c7);
+        MP_WritePhyUshort(sc, 0x06, 0xaebb);
+        MP_WritePhyUshort(sc, 0x06, 0xd481);
+        MP_WritePhyUshort(sc, 0x06, 0xd4e4);
+        MP_WritePhyUshort(sc, 0x06, 0x8b92);
+        MP_WritePhyUshort(sc, 0x06, 0xe58b);
+        MP_WritePhyUshort(sc, 0x06, 0x9302);
+        MP_WritePhyUshort(sc, 0x06, 0x2e5a);
+        MP_WritePhyUshort(sc, 0x06, 0xbf8b);
+        MP_WritePhyUshort(sc, 0x06, 0x88ec);
+        MP_WritePhyUshort(sc, 0x06, 0x0019);
+        MP_WritePhyUshort(sc, 0x06, 0xa98b);
+        MP_WritePhyUshort(sc, 0x06, 0x90f9);
+        MP_WritePhyUshort(sc, 0x06, 0xeeff);
+        MP_WritePhyUshort(sc, 0x06, 0xf600);
+        MP_WritePhyUshort(sc, 0x06, 0xeeff);
+        MP_WritePhyUshort(sc, 0x06, 0xf7fc);
+        MP_WritePhyUshort(sc, 0x06, 0xd100);
+        MP_WritePhyUshort(sc, 0x06, 0xbf83);
+        MP_WritePhyUshort(sc, 0x06, 0x3c02);
+        MP_WritePhyUshort(sc, 0x06, 0x3a21);
+        MP_WritePhyUshort(sc, 0x06, 0xd101);
+        MP_WritePhyUshort(sc, 0x06, 0xbf83);
+        MP_WritePhyUshort(sc, 0x06, 0x3f02);
+        MP_WritePhyUshort(sc, 0x06, 0x3a21);
+        MP_WritePhyUshort(sc, 0x06, 0x04f8);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x8aad);
+        MP_WritePhyUshort(sc, 0x06, 0x2014);
+        MP_WritePhyUshort(sc, 0x06, 0xee8b);
+        MP_WritePhyUshort(sc, 0x06, 0x8a00);
+        MP_WritePhyUshort(sc, 0x06, 0x0220);
+        MP_WritePhyUshort(sc, 0x06, 0x8be0);
+        MP_WritePhyUshort(sc, 0x06, 0xe426);
+        MP_WritePhyUshort(sc, 0x06, 0xe1e4);
+        MP_WritePhyUshort(sc, 0x06, 0x27ee);
+        MP_WritePhyUshort(sc, 0x06, 0xe426);
+        MP_WritePhyUshort(sc, 0x06, 0x23e5);
+        MP_WritePhyUshort(sc, 0x06, 0xe427);
+        MP_WritePhyUshort(sc, 0x06, 0xfc04);
+        MP_WritePhyUshort(sc, 0x06, 0xf8e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8d);
+        MP_WritePhyUshort(sc, 0x06, 0xad20);
+        MP_WritePhyUshort(sc, 0x06, 0x14ee);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8d);
+        MP_WritePhyUshort(sc, 0x06, 0x00e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8a5a);
+        MP_WritePhyUshort(sc, 0x06, 0x7803);
+        MP_WritePhyUshort(sc, 0x06, 0x9e09);
+        MP_WritePhyUshort(sc, 0x06, 0x0206);
+        MP_WritePhyUshort(sc, 0x06, 0x2802);
+        MP_WritePhyUshort(sc, 0x06, 0x80b1);
+        MP_WritePhyUshort(sc, 0x06, 0x0232);
+        MP_WritePhyUshort(sc, 0x06, 0xfdfc);
+        MP_WritePhyUshort(sc, 0x06, 0x04f8);
+        MP_WritePhyUshort(sc, 0x06, 0xf9e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b81);
+        MP_WritePhyUshort(sc, 0x06, 0xac26);
+        MP_WritePhyUshort(sc, 0x06, 0x1ae0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b81);
+        MP_WritePhyUshort(sc, 0x06, 0xac21);
+        MP_WritePhyUshort(sc, 0x06, 0x14e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b85);
+        MP_WritePhyUshort(sc, 0x06, 0xac20);
+        MP_WritePhyUshort(sc, 0x06, 0x0ee0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b85);
+        MP_WritePhyUshort(sc, 0x06, 0xac23);
+        MP_WritePhyUshort(sc, 0x06, 0x08e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b87);
+        MP_WritePhyUshort(sc, 0x06, 0xac24);
+        MP_WritePhyUshort(sc, 0x06, 0x02ae);
+        MP_WritePhyUshort(sc, 0x06, 0x3802);
+        MP_WritePhyUshort(sc, 0x06, 0x1b02);
+        MP_WritePhyUshort(sc, 0x06, 0xeee4);
+        MP_WritePhyUshort(sc, 0x06, 0x1c04);
+        MP_WritePhyUshort(sc, 0x06, 0xeee4);
+        MP_WritePhyUshort(sc, 0x06, 0x1d04);
+        MP_WritePhyUshort(sc, 0x06, 0xe2e0);
+        MP_WritePhyUshort(sc, 0x06, 0x7ce3);
+        MP_WritePhyUshort(sc, 0x06, 0xe07d);
+        MP_WritePhyUshort(sc, 0x06, 0xe0e0);
+        MP_WritePhyUshort(sc, 0x06, 0x38e1);
+        MP_WritePhyUshort(sc, 0x06, 0xe039);
+        MP_WritePhyUshort(sc, 0x06, 0xad2e);
+        MP_WritePhyUshort(sc, 0x06, 0x1bad);
+        MP_WritePhyUshort(sc, 0x06, 0x390d);
+        MP_WritePhyUshort(sc, 0x06, 0xd101);
+        MP_WritePhyUshort(sc, 0x06, 0xbf22);
+        MP_WritePhyUshort(sc, 0x06, 0xe802);
+        MP_WritePhyUshort(sc, 0x06, 0x3a21);
+        MP_WritePhyUshort(sc, 0x06, 0x0222);
+        MP_WritePhyUshort(sc, 0x06, 0x10ae);
+        MP_WritePhyUshort(sc, 0x06, 0x0bac);
+        MP_WritePhyUshort(sc, 0x06, 0x3802);
+        MP_WritePhyUshort(sc, 0x06, 0xae06);
+        MP_WritePhyUshort(sc, 0x06, 0x0222);
+        MP_WritePhyUshort(sc, 0x06, 0x4d02);
+        MP_WritePhyUshort(sc, 0x06, 0x2292);
+        MP_WritePhyUshort(sc, 0x06, 0x021b);
+        MP_WritePhyUshort(sc, 0x06, 0x13fd);
+        MP_WritePhyUshort(sc, 0x06, 0xfc04);
+        MP_WritePhyUshort(sc, 0x06, 0xf8e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8e);
+        MP_WritePhyUshort(sc, 0x06, 0xad20);
+        MP_WritePhyUshort(sc, 0x06, 0x1af6);
+        MP_WritePhyUshort(sc, 0x06, 0x20e4);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8e);
+        MP_WritePhyUshort(sc, 0x06, 0x022b);
+        MP_WritePhyUshort(sc, 0x06, 0x1e02);
+        MP_WritePhyUshort(sc, 0x06, 0x82ae);
+        MP_WritePhyUshort(sc, 0x06, 0x0203);
+        MP_WritePhyUshort(sc, 0x06, 0xc002);
+        MP_WritePhyUshort(sc, 0x06, 0x827d);
+        MP_WritePhyUshort(sc, 0x06, 0x022e);
+        MP_WritePhyUshort(sc, 0x06, 0x6f02);
+        MP_WritePhyUshort(sc, 0x06, 0x047b);
+        MP_WritePhyUshort(sc, 0x06, 0x022f);
+        MP_WritePhyUshort(sc, 0x06, 0x9ae0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8e);
+        MP_WritePhyUshort(sc, 0x06, 0xad21);
+        MP_WritePhyUshort(sc, 0x06, 0x0bf6);
+        MP_WritePhyUshort(sc, 0x06, 0x21e4);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8e);
+        MP_WritePhyUshort(sc, 0x06, 0x0281);
+        MP_WritePhyUshort(sc, 0x06, 0x9002);
+        MP_WritePhyUshort(sc, 0x06, 0x1cd9);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x8ead);
+        MP_WritePhyUshort(sc, 0x06, 0x2208);
+        MP_WritePhyUshort(sc, 0x06, 0xf622);
+        MP_WritePhyUshort(sc, 0x06, 0xe48b);
+        MP_WritePhyUshort(sc, 0x06, 0x8e02);
+        MP_WritePhyUshort(sc, 0x06, 0x35f4);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x8ead);
+        MP_WritePhyUshort(sc, 0x06, 0x2308);
+        MP_WritePhyUshort(sc, 0x06, 0xf623);
+        MP_WritePhyUshort(sc, 0x06, 0xe48b);
+        MP_WritePhyUshort(sc, 0x06, 0x8e02);
+        MP_WritePhyUshort(sc, 0x06, 0x31e8);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x8ead);
+        MP_WritePhyUshort(sc, 0x06, 0x2405);
+        MP_WritePhyUshort(sc, 0x06, 0xf624);
+        MP_WritePhyUshort(sc, 0x06, 0xe48b);
+        MP_WritePhyUshort(sc, 0x06, 0x8ee0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8e);
+        MP_WritePhyUshort(sc, 0x06, 0xad25);
+        MP_WritePhyUshort(sc, 0x06, 0x05f6);
+        MP_WritePhyUshort(sc, 0x06, 0x25e4);
+        MP_WritePhyUshort(sc, 0x06, 0x8b8e);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x8ead);
+        MP_WritePhyUshort(sc, 0x06, 0x2608);
+        MP_WritePhyUshort(sc, 0x06, 0xf626);
+        MP_WritePhyUshort(sc, 0x06, 0xe48b);
+        MP_WritePhyUshort(sc, 0x06, 0x8e02);
+        MP_WritePhyUshort(sc, 0x06, 0x2d8a);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x8ead);
+        MP_WritePhyUshort(sc, 0x06, 0x2705);
+        MP_WritePhyUshort(sc, 0x06, 0xf627);
+        MP_WritePhyUshort(sc, 0x06, 0xe48b);
+        MP_WritePhyUshort(sc, 0x06, 0x8e02);
+        MP_WritePhyUshort(sc, 0x06, 0x0386);
+        MP_WritePhyUshort(sc, 0x06, 0xfc04);
+        MP_WritePhyUshort(sc, 0x06, 0xf8fa);
+        MP_WritePhyUshort(sc, 0x06, 0xef69);
+        MP_WritePhyUshort(sc, 0x06, 0xe0e0);
+        MP_WritePhyUshort(sc, 0x06, 0x00e1);
+        MP_WritePhyUshort(sc, 0x06, 0xe001);
+        MP_WritePhyUshort(sc, 0x06, 0xad27);
+        MP_WritePhyUshort(sc, 0x06, 0x32e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b40);
+        MP_WritePhyUshort(sc, 0x06, 0xf720);
+        MP_WritePhyUshort(sc, 0x06, 0xe48b);
+        MP_WritePhyUshort(sc, 0x06, 0x40bf);
+        MP_WritePhyUshort(sc, 0x06, 0x32c1);
+        MP_WritePhyUshort(sc, 0x06, 0x0239);
+        MP_WritePhyUshort(sc, 0x06, 0xf4ad);
+        MP_WritePhyUshort(sc, 0x06, 0x2821);
+        MP_WritePhyUshort(sc, 0x06, 0xe0e0);
+        MP_WritePhyUshort(sc, 0x06, 0x20e1);
+        MP_WritePhyUshort(sc, 0x06, 0xe021);
+        MP_WritePhyUshort(sc, 0x06, 0xad20);
+        MP_WritePhyUshort(sc, 0x06, 0x18e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b40);
+        MP_WritePhyUshort(sc, 0x06, 0xf620);
+        MP_WritePhyUshort(sc, 0x06, 0xe48b);
+        MP_WritePhyUshort(sc, 0x06, 0x40ee);
+        MP_WritePhyUshort(sc, 0x06, 0x8b3b);
+        MP_WritePhyUshort(sc, 0x06, 0xffe0);
+        MP_WritePhyUshort(sc, 0x06, 0x8a8a);
+        MP_WritePhyUshort(sc, 0x06, 0xe18a);
+        MP_WritePhyUshort(sc, 0x06, 0x8be4);
+        MP_WritePhyUshort(sc, 0x06, 0xe000);
+        MP_WritePhyUshort(sc, 0x06, 0xe5e0);
+        MP_WritePhyUshort(sc, 0x06, 0x01ef);
+        MP_WritePhyUshort(sc, 0x06, 0x96fe);
+        MP_WritePhyUshort(sc, 0x06, 0xfc04);
+        MP_WritePhyUshort(sc, 0x06, 0xf8f9);
+        MP_WritePhyUshort(sc, 0x06, 0xface);
+        MP_WritePhyUshort(sc, 0x06, 0xfaef);
+        MP_WritePhyUshort(sc, 0x06, 0x69fa);
+        MP_WritePhyUshort(sc, 0x06, 0xd401);
+        MP_WritePhyUshort(sc, 0x06, 0x55b4);
+        MP_WritePhyUshort(sc, 0x06, 0xfebf);
+        MP_WritePhyUshort(sc, 0x06, 0x1c5e);
+        MP_WritePhyUshort(sc, 0x06, 0x0239);
+        MP_WritePhyUshort(sc, 0x06, 0xf4ac);
+        MP_WritePhyUshort(sc, 0x06, 0x280b);
+        MP_WritePhyUshort(sc, 0x06, 0xbf1c);
+        MP_WritePhyUshort(sc, 0x06, 0x5b02);
+        MP_WritePhyUshort(sc, 0x06, 0x39f4);
+        MP_WritePhyUshort(sc, 0x06, 0xac28);
+        MP_WritePhyUshort(sc, 0x06, 0x49ae);
+        MP_WritePhyUshort(sc, 0x06, 0x64bf);
+        MP_WritePhyUshort(sc, 0x06, 0x1c5b);
+        MP_WritePhyUshort(sc, 0x06, 0x0239);
+        MP_WritePhyUshort(sc, 0x06, 0xf4ac);
+        MP_WritePhyUshort(sc, 0x06, 0x285b);
+        MP_WritePhyUshort(sc, 0x06, 0xd000);
+        MP_WritePhyUshort(sc, 0x06, 0x0282);
+        MP_WritePhyUshort(sc, 0x06, 0x62ac);
+        MP_WritePhyUshort(sc, 0x06, 0x2105);
+        MP_WritePhyUshort(sc, 0x06, 0xac22);
+        MP_WritePhyUshort(sc, 0x06, 0x02ae);
+        MP_WritePhyUshort(sc, 0x06, 0x4ebf);
+        MP_WritePhyUshort(sc, 0x06, 0xe0c4);
+        MP_WritePhyUshort(sc, 0x06, 0xbe85);
+        MP_WritePhyUshort(sc, 0x06, 0xecd2);
+        MP_WritePhyUshort(sc, 0x06, 0x04d8);
+        MP_WritePhyUshort(sc, 0x06, 0x19d9);
+        MP_WritePhyUshort(sc, 0x06, 0x1907);
+        MP_WritePhyUshort(sc, 0x06, 0xdc19);
+        MP_WritePhyUshort(sc, 0x06, 0xdd19);
+        MP_WritePhyUshort(sc, 0x06, 0x0789);
+        MP_WritePhyUshort(sc, 0x06, 0x89ef);
+        MP_WritePhyUshort(sc, 0x06, 0x645e);
+        MP_WritePhyUshort(sc, 0x06, 0x07ff);
+        MP_WritePhyUshort(sc, 0x06, 0x0d65);
+        MP_WritePhyUshort(sc, 0x06, 0x5cf8);
+        MP_WritePhyUshort(sc, 0x06, 0x001e);
+        MP_WritePhyUshort(sc, 0x06, 0x46dc);
+        MP_WritePhyUshort(sc, 0x06, 0x19dd);
+        MP_WritePhyUshort(sc, 0x06, 0x19b2);
+        MP_WritePhyUshort(sc, 0x06, 0xe2d4);
+        MP_WritePhyUshort(sc, 0x06, 0x0001);
+        MP_WritePhyUshort(sc, 0x06, 0xbf1c);
+        MP_WritePhyUshort(sc, 0x06, 0x5b02);
+        MP_WritePhyUshort(sc, 0x06, 0x3a21);
+        MP_WritePhyUshort(sc, 0x06, 0xae1d);
+        MP_WritePhyUshort(sc, 0x06, 0xbee0);
+        MP_WritePhyUshort(sc, 0x06, 0xc4bf);
+        MP_WritePhyUshort(sc, 0x06, 0x85ec);
+        MP_WritePhyUshort(sc, 0x06, 0xd204);
+        MP_WritePhyUshort(sc, 0x06, 0xd819);
+        MP_WritePhyUshort(sc, 0x06, 0xd919);
+        MP_WritePhyUshort(sc, 0x06, 0x07dc);
+        MP_WritePhyUshort(sc, 0x06, 0x19dd);
+        MP_WritePhyUshort(sc, 0x06, 0x1907);
+        MP_WritePhyUshort(sc, 0x06, 0xb2f4);
+        MP_WritePhyUshort(sc, 0x06, 0xd400);
+        MP_WritePhyUshort(sc, 0x06, 0x00bf);
+        MP_WritePhyUshort(sc, 0x06, 0x1c5b);
+        MP_WritePhyUshort(sc, 0x06, 0x023a);
+        MP_WritePhyUshort(sc, 0x06, 0x21fe);
+        MP_WritePhyUshort(sc, 0x06, 0xef96);
+        MP_WritePhyUshort(sc, 0x06, 0xfec6);
+        MP_WritePhyUshort(sc, 0x06, 0xfefd);
+        MP_WritePhyUshort(sc, 0x06, 0xfc05);
+        MP_WritePhyUshort(sc, 0x06, 0xf9e2);
+        MP_WritePhyUshort(sc, 0x06, 0xe0ea);
+        MP_WritePhyUshort(sc, 0x06, 0xe3e0);
+        MP_WritePhyUshort(sc, 0x06, 0xeb5a);
+        MP_WritePhyUshort(sc, 0x06, 0x070c);
+        MP_WritePhyUshort(sc, 0x06, 0x031e);
+        MP_WritePhyUshort(sc, 0x06, 0x20e6);
+        MP_WritePhyUshort(sc, 0x06, 0xe0ea);
+        MP_WritePhyUshort(sc, 0x06, 0xe7e0);
+        MP_WritePhyUshort(sc, 0x06, 0xebe0);
+        MP_WritePhyUshort(sc, 0x06, 0xe0fc);
+        MP_WritePhyUshort(sc, 0x06, 0xe1e0);
+        MP_WritePhyUshort(sc, 0x06, 0xfdfd);
+        MP_WritePhyUshort(sc, 0x06, 0x04f8);
+        MP_WritePhyUshort(sc, 0x06, 0xfaef);
+        MP_WritePhyUshort(sc, 0x06, 0x69e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b80);
+        MP_WritePhyUshort(sc, 0x06, 0xad27);
+        MP_WritePhyUshort(sc, 0x06, 0x22bf);
+        MP_WritePhyUshort(sc, 0x06, 0x47ba);
+        MP_WritePhyUshort(sc, 0x06, 0x0239);
+        MP_WritePhyUshort(sc, 0x06, 0xf4e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b44);
+        MP_WritePhyUshort(sc, 0x06, 0x1f01);
+        MP_WritePhyUshort(sc, 0x06, 0x9e15);
+        MP_WritePhyUshort(sc, 0x06, 0xe58b);
+        MP_WritePhyUshort(sc, 0x06, 0x44ad);
+        MP_WritePhyUshort(sc, 0x06, 0x2907);
+        MP_WritePhyUshort(sc, 0x06, 0xac28);
+        MP_WritePhyUshort(sc, 0x06, 0x04d1);
+        MP_WritePhyUshort(sc, 0x06, 0x01ae);
+        MP_WritePhyUshort(sc, 0x06, 0x02d1);
+        MP_WritePhyUshort(sc, 0x06, 0x00bf);
+        MP_WritePhyUshort(sc, 0x06, 0x8342);
+        MP_WritePhyUshort(sc, 0x06, 0x023a);
+        MP_WritePhyUshort(sc, 0x06, 0x21ef);
+        MP_WritePhyUshort(sc, 0x06, 0x96fe);
+        MP_WritePhyUshort(sc, 0x06, 0xfc04);
+        MP_WritePhyUshort(sc, 0x06, 0xf8e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b85);
+        MP_WritePhyUshort(sc, 0x06, 0xad26);
+        MP_WritePhyUshort(sc, 0x06, 0x30e0);
+        MP_WritePhyUshort(sc, 0x06, 0xe036);
+        MP_WritePhyUshort(sc, 0x06, 0xe1e0);
+        MP_WritePhyUshort(sc, 0x06, 0x37e1);
+        MP_WritePhyUshort(sc, 0x06, 0x8b3f);
+        MP_WritePhyUshort(sc, 0x06, 0x1f10);
+        MP_WritePhyUshort(sc, 0x06, 0x9e23);
+        MP_WritePhyUshort(sc, 0x06, 0xe48b);
+        MP_WritePhyUshort(sc, 0x06, 0x3fac);
+        MP_WritePhyUshort(sc, 0x06, 0x200b);
+        MP_WritePhyUshort(sc, 0x06, 0xac21);
+        MP_WritePhyUshort(sc, 0x06, 0x0dac);
+        MP_WritePhyUshort(sc, 0x06, 0x250f);
+        MP_WritePhyUshort(sc, 0x06, 0xac27);
+        MP_WritePhyUshort(sc, 0x06, 0x11ae);
+        MP_WritePhyUshort(sc, 0x06, 0x1202);
+        MP_WritePhyUshort(sc, 0x06, 0x2cb5);
+        MP_WritePhyUshort(sc, 0x06, 0xae0d);
+        MP_WritePhyUshort(sc, 0x06, 0x0282);
+        MP_WritePhyUshort(sc, 0x06, 0xe7ae);
+        MP_WritePhyUshort(sc, 0x06, 0x0802);
+        MP_WritePhyUshort(sc, 0x06, 0x2cd7);
+        MP_WritePhyUshort(sc, 0x06, 0xae03);
+        MP_WritePhyUshort(sc, 0x06, 0x022c);
+        MP_WritePhyUshort(sc, 0x06, 0xeafc);
+        MP_WritePhyUshort(sc, 0x06, 0x04f8);
+        MP_WritePhyUshort(sc, 0x06, 0xfaef);
+        MP_WritePhyUshort(sc, 0x06, 0x6902);
+        MP_WritePhyUshort(sc, 0x06, 0x8304);
+        MP_WritePhyUshort(sc, 0x06, 0xe0e0);
+        MP_WritePhyUshort(sc, 0x06, 0x14e1);
+        MP_WritePhyUshort(sc, 0x06, 0xe015);
+        MP_WritePhyUshort(sc, 0x06, 0xad26);
+        MP_WritePhyUshort(sc, 0x06, 0x08d1);
+        MP_WritePhyUshort(sc, 0x06, 0x1ebf);
+        MP_WritePhyUshort(sc, 0x06, 0x2d47);
+        MP_WritePhyUshort(sc, 0x06, 0x023a);
+        MP_WritePhyUshort(sc, 0x06, 0x21ef);
+        MP_WritePhyUshort(sc, 0x06, 0x96fe);
+        MP_WritePhyUshort(sc, 0x06, 0xfc04);
+        MP_WritePhyUshort(sc, 0x06, 0xf8e0);
+        MP_WritePhyUshort(sc, 0x06, 0x8b85);
+        MP_WritePhyUshort(sc, 0x06, 0xad27);
+        MP_WritePhyUshort(sc, 0x06, 0x2fd0);
+        MP_WritePhyUshort(sc, 0x06, 0x0b02);
+        MP_WritePhyUshort(sc, 0x06, 0x3826);
+        MP_WritePhyUshort(sc, 0x06, 0x5882);
+        MP_WritePhyUshort(sc, 0x06, 0x7882);
+        MP_WritePhyUshort(sc, 0x06, 0x9f24);
+        MP_WritePhyUshort(sc, 0x06, 0xe08b);
+        MP_WritePhyUshort(sc, 0x06, 0x32e1);
+        MP_WritePhyUshort(sc, 0x06, 0x8b33);
+        MP_WritePhyUshort(sc, 0x06, 0x1f10);
+        MP_WritePhyUshort(sc, 0x06, 0x9e1a);
+        MP_WritePhyUshort(sc, 0x06, 0x10e4);
+        MP_WritePhyUshort(sc, 0x06, 0x8b32);
+        MP_WritePhyUshort(sc, 0x06, 0xe0e0);
+        MP_WritePhyUshort(sc, 0x06, 0x28e1);
+        MP_WritePhyUshort(sc, 0x06, 0xe029);
+        MP_WritePhyUshort(sc, 0x06, 0xf72c);
+        MP_WritePhyUshort(sc, 0x06, 0xe4e0);
+        MP_WritePhyUshort(sc, 0x06, 0x28e5);
+        MP_WritePhyUshort(sc, 0x06, 0xe029);
+        MP_WritePhyUshort(sc, 0x06, 0xf62c);
+        MP_WritePhyUshort(sc, 0x06, 0xe4e0);
+        MP_WritePhyUshort(sc, 0x06, 0x28e5);
+        MP_WritePhyUshort(sc, 0x06, 0xe029);
+        MP_WritePhyUshort(sc, 0x06, 0xfc04);
+        MP_WritePhyUshort(sc, 0x06, 0x00e1);
+        MP_WritePhyUshort(sc, 0x06, 0x4077);
+        MP_WritePhyUshort(sc, 0x06, 0xe140);
+        MP_WritePhyUshort(sc, 0x06, 0xbbe0);
+        MP_WritePhyUshort(sc, 0x06, 0x2a00);
+        MP_WritePhyUshort(sc, 0x05, 0xe142);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x06);
+        PhyRegValue |= BIT_0;
+        MP_WritePhyUshort(sc, 0x06,PhyRegValue);
+        MP_WritePhyUshort(sc, 0x05, 0xe140);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x06);
+        PhyRegValue |= BIT_0;
+        MP_WritePhyUshort(sc, 0x06, PhyRegValue);
+        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+        MP_WritePhyUshort(sc, 0x1f, 0x0005);
+        for (i = 0; i < 200; i++) {
+                DELAY(100);
+                PhyRegValue = MP_ReadPhyUshort(sc, 0x00);
+                if (PhyRegValue & BIT_7)
+                        break;
+        }
+        MP_WritePhyUshort(sc, 0x1f, 0x0007);
+        MP_WritePhyUshort(sc, 0x1e, 0x0023);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
+        PhyRegValue |= BIT_1;
+        if (sc->RequiredSecLanDonglePatch)
+                PhyRegValue &= ~(BIT_2);
+        MP_WritePhyUshort(sc, 0x17, PhyRegValue);
+        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+        MP_WritePhyUshort(sc, 0x1f, 0x0003);
+        MP_WritePhyUshort(sc, 0x09, 0xA20F);
+        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+        MP_WritePhyUshort(sc, 0x1f, 0x0003);
+        MP_WritePhyUshort(sc, 0x01, 0x328A);
+        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+        MP_WritePhyUshort(sc, 0x1f, 0x0003);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x19);
+        PhyRegValue &= ~BIT_0;
+        MP_WritePhyUshort(sc, 0x19, PhyRegValue);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
+        PhyRegValue &= ~BIT_10;
+        MP_WritePhyUshort(sc, 0x10, PhyRegValue);
+        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+        MP_WritePhyUshort(sc, 0x00, 0x9200);
+}
+
+static void re_set_phy_mcu_8168g_1(struct re_softc *sc)
+{
+        u_int16_t PhyRegValue;
+        u_int32_t WaitCnt;
+
+        MP_WritePhyUshort(sc, 0x1f, 0x0B82);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
+        PhyRegValue |= BIT_4;
+        MP_WritePhyUshort(sc, 0x10, PhyRegValue);
+
+        MP_WritePhyUshort(sc, 0x1f, 0x0B80);
+        WaitCnt = 0;
+        do {
+                PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
+                PhyRegValue &= 0x0040;
+                DELAY(50);
+                DELAY(50);
+                WaitCnt++;
+        } while(PhyRegValue != 0x0040 && WaitCnt <1000);
+
+        MP_WritePhyUshort(sc, 0x1f, 0x0A43);
+        MP_WritePhyUshort(sc, 0x13, 0x8146);
+        MP_WritePhyUshort(sc, 0x14, 0x2300);
+        MP_WritePhyUshort(sc, 0x13, 0xB820);
+        MP_WritePhyUshort(sc, 0x14, 0x0210);
+
+        MP_WritePhyUshort(sc, 0x1F, 0x0A43);
+        MP_WritePhyUshort(sc, 0x13, 0xB820);
+        MP_WritePhyUshort(sc, 0x14, 0x0290);
+        MP_WritePhyUshort(sc, 0x13, 0xA012);
+        MP_WritePhyUshort(sc, 0x14, 0x0000);
+        MP_WritePhyUshort(sc, 0x13, 0xA014);
+        MP_WritePhyUshort(sc, 0x14, 0x2c04);
+        MP_WritePhyUshort(sc, 0x14, 0x2c0c);
+        MP_WritePhyUshort(sc, 0x14, 0x2c6c);
+        MP_WritePhyUshort(sc, 0x14, 0x2d0d);
+        MP_WritePhyUshort(sc, 0x14, 0x31ce);
+        MP_WritePhyUshort(sc, 0x14, 0x506d);
+        MP_WritePhyUshort(sc, 0x14, 0xd708);
+        MP_WritePhyUshort(sc, 0x14, 0x3108);
+        MP_WritePhyUshort(sc, 0x14, 0x106d);
+        MP_WritePhyUshort(sc, 0x14, 0x1560);
+        MP_WritePhyUshort(sc, 0x14, 0x15a9);
+        MP_WritePhyUshort(sc, 0x14, 0x206e);
+        MP_WritePhyUshort(sc, 0x14, 0x175b);
+        MP_WritePhyUshort(sc, 0x14, 0x6062);
+        MP_WritePhyUshort(sc, 0x14, 0xd700);
+        MP_WritePhyUshort(sc, 0x14, 0x5fae);
+        MP_WritePhyUshort(sc, 0x14, 0xd708);
+        MP_WritePhyUshort(sc, 0x14, 0x3107);
+        MP_WritePhyUshort(sc, 0x14, 0x4c1e);
+        MP_WritePhyUshort(sc, 0x14, 0x4169);
+        MP_WritePhyUshort(sc, 0x14, 0x316a);
+        MP_WritePhyUshort(sc, 0x14, 0x0c19);
+        MP_WritePhyUshort(sc, 0x14, 0x31aa);
+        MP_WritePhyUshort(sc, 0x14, 0x0c19);
+        MP_WritePhyUshort(sc, 0x14, 0x2c1b);
+        MP_WritePhyUshort(sc, 0x14, 0x5e62);
+        MP_WritePhyUshort(sc, 0x14, 0x26b5);
+        MP_WritePhyUshort(sc, 0x14, 0x31ab);
+        MP_WritePhyUshort(sc, 0x14, 0x5c1e);
+        MP_WritePhyUshort(sc, 0x14, 0x2c0c);
+        MP_WritePhyUshort(sc, 0x14, 0xc040);
+        MP_WritePhyUshort(sc, 0x14, 0x8808);
+        MP_WritePhyUshort(sc, 0x14, 0xc520);
+        MP_WritePhyUshort(sc, 0x14, 0xc421);
+        MP_WritePhyUshort(sc, 0x14, 0xd05a);
+        MP_WritePhyUshort(sc, 0x14, 0xd19a);
+        MP_WritePhyUshort(sc, 0x14, 0xd709);
+        MP_WritePhyUshort(sc, 0x14, 0x608f);
+        MP_WritePhyUshort(sc, 0x14, 0xd06b);
+        MP_WritePhyUshort(sc, 0x14, 0xd18a);
+        MP_WritePhyUshort(sc, 0x14, 0x2c2c);
+        MP_WritePhyUshort(sc, 0x14, 0xd0be);
+        MP_WritePhyUshort(sc, 0x14, 0xd188);
+        MP_WritePhyUshort(sc, 0x14, 0x2c2c);
+        MP_WritePhyUshort(sc, 0x14, 0xd708);
+        MP_WritePhyUshort(sc, 0x14, 0x4072);
+        MP_WritePhyUshort(sc, 0x14, 0xc104);
+        MP_WritePhyUshort(sc, 0x14, 0x2c3e);
+        MP_WritePhyUshort(sc, 0x14, 0x4076);
+        MP_WritePhyUshort(sc, 0x14, 0xc110);
+        MP_WritePhyUshort(sc, 0x14, 0x2c3e);
+        MP_WritePhyUshort(sc, 0x14, 0x4071);
+        MP_WritePhyUshort(sc, 0x14, 0xc102);
+        MP_WritePhyUshort(sc, 0x14, 0x2c3e);
+        MP_WritePhyUshort(sc, 0x14, 0x4070);
+        MP_WritePhyUshort(sc, 0x14, 0xc101);
+        MP_WritePhyUshort(sc, 0x14, 0x2c3e);
+        MP_WritePhyUshort(sc, 0x14, 0x175b);
+        MP_WritePhyUshort(sc, 0x14, 0xd709);
+        MP_WritePhyUshort(sc, 0x14, 0x3390);
+        MP_WritePhyUshort(sc, 0x14, 0x5c39);
+        MP_WritePhyUshort(sc, 0x14, 0x2c4e);
+        MP_WritePhyUshort(sc, 0x14, 0x175b);
+        MP_WritePhyUshort(sc, 0x14, 0xd708);
+        MP_WritePhyUshort(sc, 0x14, 0x6193);
+        MP_WritePhyUshort(sc, 0x14, 0xd709);
+        MP_WritePhyUshort(sc, 0x14, 0x5f9d);
+        MP_WritePhyUshort(sc, 0x14, 0x408b);
+        MP_WritePhyUshort(sc, 0x14, 0xd71e);
+        MP_WritePhyUshort(sc, 0x14, 0x6042);
+        MP_WritePhyUshort(sc, 0x14, 0xb401);
+        MP_WritePhyUshort(sc, 0x14, 0x175b);
+        MP_WritePhyUshort(sc, 0x14, 0xd708);
+        MP_WritePhyUshort(sc, 0x14, 0x6073);
+        MP_WritePhyUshort(sc, 0x14, 0x5fbc);
+        MP_WritePhyUshort(sc, 0x14, 0x2c4d);
+        MP_WritePhyUshort(sc, 0x14, 0x26ed);
+        MP_WritePhyUshort(sc, 0x14, 0xb280);
+        MP_WritePhyUshort(sc, 0x14, 0xa841);
+        MP_WritePhyUshort(sc, 0x14, 0x9420);
+        MP_WritePhyUshort(sc, 0x14, 0x8710);
+        MP_WritePhyUshort(sc, 0x14, 0xd709);
+        MP_WritePhyUshort(sc, 0x14, 0x42ec);
+        MP_WritePhyUshort(sc, 0x14, 0x606d);
+        MP_WritePhyUshort(sc, 0x14, 0xd207);
+        MP_WritePhyUshort(sc, 0x14, 0x2c57);
+        MP_WritePhyUshort(sc, 0x14, 0xd203);
+        MP_WritePhyUshort(sc, 0x14, 0x33ff);
+        MP_WritePhyUshort(sc, 0x14, 0x563b);
+        MP_WritePhyUshort(sc, 0x14, 0x3275);
+        MP_WritePhyUshort(sc, 0x14, 0x7c5e);
+        MP_WritePhyUshort(sc, 0x14, 0xb240);
+        MP_WritePhyUshort(sc, 0x14, 0xb402);
+        MP_WritePhyUshort(sc, 0x14, 0x263b);
+        MP_WritePhyUshort(sc, 0x14, 0x6096);
+        MP_WritePhyUshort(sc, 0x14, 0xb240);
+        MP_WritePhyUshort(sc, 0x14, 0xb406);
+        MP_WritePhyUshort(sc, 0x14, 0x263b);
+        MP_WritePhyUshort(sc, 0x14, 0x31d7);
+        MP_WritePhyUshort(sc, 0x14, 0x7c67);
+        MP_WritePhyUshort(sc, 0x14, 0xb240);
+        MP_WritePhyUshort(sc, 0x14, 0xb40e);
+        MP_WritePhyUshort(sc, 0x14, 0x263b);
+        MP_WritePhyUshort(sc, 0x14, 0xb410);
+        MP_WritePhyUshort(sc, 0x14, 0x8802);
+        MP_WritePhyUshort(sc, 0x14, 0xb240);
+        MP_WritePhyUshort(sc, 0x14, 0x940e);
+        MP_WritePhyUshort(sc, 0x14, 0x263b);
+        MP_WritePhyUshort(sc, 0x14, 0xba04);
+        MP_WritePhyUshort(sc, 0x14, 0x1cd6);
+        MP_WritePhyUshort(sc, 0x14, 0xa902);
+        MP_WritePhyUshort(sc, 0x14, 0xd711);
+        MP_WritePhyUshort(sc, 0x14, 0x4045);
+        MP_WritePhyUshort(sc, 0x14, 0xa980);
+        MP_WritePhyUshort(sc, 0x14, 0x3003);
+        MP_WritePhyUshort(sc, 0x14, 0x59b1);
+        MP_WritePhyUshort(sc, 0x14, 0xa540);
+        MP_WritePhyUshort(sc, 0x14, 0xa601);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x4043);
+        MP_WritePhyUshort(sc, 0x14, 0xa910);
+        MP_WritePhyUshort(sc, 0x14, 0xd711);
+        MP_WritePhyUshort(sc, 0x14, 0x60a0);
+        MP_WritePhyUshort(sc, 0x14, 0xca33);
+        MP_WritePhyUshort(sc, 0x14, 0xcb33);
+        MP_WritePhyUshort(sc, 0x14, 0xa941);
+        MP_WritePhyUshort(sc, 0x14, 0x2c82);
+        MP_WritePhyUshort(sc, 0x14, 0xcaff);
+        MP_WritePhyUshort(sc, 0x14, 0xcbff);
+        MP_WritePhyUshort(sc, 0x14, 0xa921);
+        MP_WritePhyUshort(sc, 0x14, 0xce02);
+        MP_WritePhyUshort(sc, 0x14, 0xe070);
+        MP_WritePhyUshort(sc, 0x14, 0x0f10);
+        MP_WritePhyUshort(sc, 0x14, 0xaf01);
+        MP_WritePhyUshort(sc, 0x14, 0x8f01);
+        MP_WritePhyUshort(sc, 0x14, 0x1766);
+        MP_WritePhyUshort(sc, 0x14, 0x8e02);
+        MP_WritePhyUshort(sc, 0x14, 0x1787);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x609c);
+        MP_WritePhyUshort(sc, 0x14, 0xd71e);
+        MP_WritePhyUshort(sc, 0x14, 0x7fa4);
+        MP_WritePhyUshort(sc, 0x14, 0x2cd4);
+        MP_WritePhyUshort(sc, 0x14, 0x1ce9);
+        MP_WritePhyUshort(sc, 0x14, 0xce04);
+        MP_WritePhyUshort(sc, 0x14, 0xe070);
+        MP_WritePhyUshort(sc, 0x14, 0x0f20);
+        MP_WritePhyUshort(sc, 0x14, 0xaf01);
+        MP_WritePhyUshort(sc, 0x14, 0x8f01);
+        MP_WritePhyUshort(sc, 0x14, 0x1766);
+        MP_WritePhyUshort(sc, 0x14, 0x8e04);
+        MP_WritePhyUshort(sc, 0x14, 0x6044);
+        MP_WritePhyUshort(sc, 0x14, 0x2cd4);
+        MP_WritePhyUshort(sc, 0x14, 0xa520);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x4043);
+        MP_WritePhyUshort(sc, 0x14, 0x2cc1);
+        MP_WritePhyUshort(sc, 0x14, 0xe00f);
+        MP_WritePhyUshort(sc, 0x14, 0x0501);
+        MP_WritePhyUshort(sc, 0x14, 0x1cef);
+        MP_WritePhyUshort(sc, 0x14, 0xb801);
+        MP_WritePhyUshort(sc, 0x14, 0xd71e);
+        MP_WritePhyUshort(sc, 0x14, 0x4060);
+        MP_WritePhyUshort(sc, 0x14, 0x7fc4);
+        MP_WritePhyUshort(sc, 0x14, 0x2cd4);
+        MP_WritePhyUshort(sc, 0x14, 0x1cf5);
+        MP_WritePhyUshort(sc, 0x14, 0xe00f);
+        MP_WritePhyUshort(sc, 0x14, 0x0502);
+        MP_WritePhyUshort(sc, 0x14, 0x1cef);
+        MP_WritePhyUshort(sc, 0x14, 0xb802);
+        MP_WritePhyUshort(sc, 0x14, 0xd71e);
+        MP_WritePhyUshort(sc, 0x14, 0x4061);
+        MP_WritePhyUshort(sc, 0x14, 0x7fc4);
+        MP_WritePhyUshort(sc, 0x14, 0x2cd4);
+        MP_WritePhyUshort(sc, 0x14, 0x1cf5);
+        MP_WritePhyUshort(sc, 0x14, 0xe00f);
+        MP_WritePhyUshort(sc, 0x14, 0x0504);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x6099);
+        MP_WritePhyUshort(sc, 0x14, 0xd71e);
+        MP_WritePhyUshort(sc, 0x14, 0x7fa4);
+        MP_WritePhyUshort(sc, 0x14, 0x2cd4);
+        MP_WritePhyUshort(sc, 0x14, 0xc17f);
+        MP_WritePhyUshort(sc, 0x14, 0xc200);
+        MP_WritePhyUshort(sc, 0x14, 0xc43f);
+        MP_WritePhyUshort(sc, 0x14, 0xcc03);
+        MP_WritePhyUshort(sc, 0x14, 0xa701);
+        MP_WritePhyUshort(sc, 0x14, 0xa510);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x4018);
+        MP_WritePhyUshort(sc, 0x14, 0x9910);
+        MP_WritePhyUshort(sc, 0x14, 0x8510);
+        MP_WritePhyUshort(sc, 0x14, 0x2860);
+        MP_WritePhyUshort(sc, 0x14, 0xe00f);
+        MP_WritePhyUshort(sc, 0x14, 0x0504);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x6099);
+        MP_WritePhyUshort(sc, 0x14, 0xd71e);
+        MP_WritePhyUshort(sc, 0x14, 0x7fa4);
+        MP_WritePhyUshort(sc, 0x14, 0x2cd4);
+        MP_WritePhyUshort(sc, 0x14, 0xa608);
+        MP_WritePhyUshort(sc, 0x14, 0xc17d);
+        MP_WritePhyUshort(sc, 0x14, 0xc200);
+        MP_WritePhyUshort(sc, 0x14, 0xc43f);
+        MP_WritePhyUshort(sc, 0x14, 0xcc03);
+        MP_WritePhyUshort(sc, 0x14, 0xa701);
+        MP_WritePhyUshort(sc, 0x14, 0xa510);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x4018);
+        MP_WritePhyUshort(sc, 0x14, 0x9910);
+        MP_WritePhyUshort(sc, 0x14, 0x8510);
+        MP_WritePhyUshort(sc, 0x14, 0x2926);
+        MP_WritePhyUshort(sc, 0x14, 0x1792);
+        MP_WritePhyUshort(sc, 0x14, 0x27db);
+        MP_WritePhyUshort(sc, 0x14, 0xc000);
+        MP_WritePhyUshort(sc, 0x14, 0xc100);
+        MP_WritePhyUshort(sc, 0x14, 0xc200);
+        MP_WritePhyUshort(sc, 0x14, 0xc300);
+        MP_WritePhyUshort(sc, 0x14, 0xc400);
+        MP_WritePhyUshort(sc, 0x14, 0xc500);
+        MP_WritePhyUshort(sc, 0x14, 0xc600);
+        MP_WritePhyUshort(sc, 0x14, 0xc7c1);
+        MP_WritePhyUshort(sc, 0x14, 0xc800);
+        MP_WritePhyUshort(sc, 0x14, 0xcc00);
+        MP_WritePhyUshort(sc, 0x14, 0x0800);
+        MP_WritePhyUshort(sc, 0x14, 0xca0f);
+        MP_WritePhyUshort(sc, 0x14, 0xcbff);
+        MP_WritePhyUshort(sc, 0x14, 0xa901);
+        MP_WritePhyUshort(sc, 0x14, 0x8902);
+        MP_WritePhyUshort(sc, 0x14, 0xc900);
+        MP_WritePhyUshort(sc, 0x14, 0xca00);
+        MP_WritePhyUshort(sc, 0x14, 0xcb00);
+        MP_WritePhyUshort(sc, 0x14, 0x0800);
+        MP_WritePhyUshort(sc, 0x14, 0xb804);
+        MP_WritePhyUshort(sc, 0x14, 0x0800);
+        MP_WritePhyUshort(sc, 0x14, 0xd71e);
+        MP_WritePhyUshort(sc, 0x14, 0x6044);
+        MP_WritePhyUshort(sc, 0x14, 0x9804);
+        MP_WritePhyUshort(sc, 0x14, 0x0800);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x6099);
+        MP_WritePhyUshort(sc, 0x14, 0xd71e);
+        MP_WritePhyUshort(sc, 0x14, 0x7fa4);
+        MP_WritePhyUshort(sc, 0x14, 0x2cd4);
+        MP_WritePhyUshort(sc, 0x14, 0x0800);
+        MP_WritePhyUshort(sc, 0x14, 0xa510);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x6098);
+        MP_WritePhyUshort(sc, 0x14, 0xd71e);
+        MP_WritePhyUshort(sc, 0x14, 0x7fa4);
+        MP_WritePhyUshort(sc, 0x14, 0x2cd4);
+        MP_WritePhyUshort(sc, 0x14, 0x8510);
+        MP_WritePhyUshort(sc, 0x14, 0x0800);
+        MP_WritePhyUshort(sc, 0x14, 0xd711);
+        MP_WritePhyUshort(sc, 0x14, 0x3003);
+        MP_WritePhyUshort(sc, 0x14, 0x1d01);
+        MP_WritePhyUshort(sc, 0x14, 0x2d0b);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x60be);
+        MP_WritePhyUshort(sc, 0x14, 0xe060);
+        MP_WritePhyUshort(sc, 0x14, 0x0920);
+        MP_WritePhyUshort(sc, 0x14, 0x1cd6);
+        MP_WritePhyUshort(sc, 0x14, 0x2c89);
+        MP_WritePhyUshort(sc, 0x14, 0xd71e);
+        MP_WritePhyUshort(sc, 0x14, 0x3063);
+        MP_WritePhyUshort(sc, 0x14, 0x1948);
+        MP_WritePhyUshort(sc, 0x14, 0x288a);
+        MP_WritePhyUshort(sc, 0x14, 0x1cd6);
+        MP_WritePhyUshort(sc, 0x14, 0x29bd);
+        MP_WritePhyUshort(sc, 0x14, 0xa802);
+        MP_WritePhyUshort(sc, 0x14, 0xa303);
+        MP_WritePhyUshort(sc, 0x14, 0x843f);
+        MP_WritePhyUshort(sc, 0x14, 0x81ff);
+        MP_WritePhyUshort(sc, 0x14, 0x8208);
+        MP_WritePhyUshort(sc, 0x14, 0xa201);
+        MP_WritePhyUshort(sc, 0x14, 0xc001);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x30a0);
+        MP_WritePhyUshort(sc, 0x14, 0x0d1c);
+        MP_WritePhyUshort(sc, 0x14, 0x30a0);
+        MP_WritePhyUshort(sc, 0x14, 0x3d13);
+        MP_WritePhyUshort(sc, 0x14, 0xd71e);
+        MP_WritePhyUshort(sc, 0x14, 0x7f4c);
+        MP_WritePhyUshort(sc, 0x14, 0x2ab6);
+        MP_WritePhyUshort(sc, 0x14, 0xe003);
+        MP_WritePhyUshort(sc, 0x14, 0x0202);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x6090);
+        MP_WritePhyUshort(sc, 0x14, 0xd71e);
+        MP_WritePhyUshort(sc, 0x14, 0x7fac);
+        MP_WritePhyUshort(sc, 0x14, 0x2ab6);
+        MP_WritePhyUshort(sc, 0x14, 0xa20c);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x6091);
+        MP_WritePhyUshort(sc, 0x14, 0xd71e);
+        MP_WritePhyUshort(sc, 0x14, 0x7fac);
+        MP_WritePhyUshort(sc, 0x14, 0x2ab6);
+        MP_WritePhyUshort(sc, 0x14, 0x820e);
+        MP_WritePhyUshort(sc, 0x14, 0xa3e0);
+        MP_WritePhyUshort(sc, 0x14, 0xa520);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x609d);
+        MP_WritePhyUshort(sc, 0x14, 0xd71e);
+        MP_WritePhyUshort(sc, 0x14, 0x7fac);
+        MP_WritePhyUshort(sc, 0x14, 0x2ab6);
+        MP_WritePhyUshort(sc, 0x14, 0x8520);
+        MP_WritePhyUshort(sc, 0x14, 0x6703);
+        MP_WritePhyUshort(sc, 0x14, 0x2d34);
+        MP_WritePhyUshort(sc, 0x14, 0xa13e);
+        MP_WritePhyUshort(sc, 0x14, 0xc001);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x4000);
+        MP_WritePhyUshort(sc, 0x14, 0x6046);
+        MP_WritePhyUshort(sc, 0x14, 0x2d0d);
+        MP_WritePhyUshort(sc, 0x14, 0xa43f);
+        MP_WritePhyUshort(sc, 0x14, 0xa101);
+        MP_WritePhyUshort(sc, 0x14, 0xc020);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x3121);
+        MP_WritePhyUshort(sc, 0x14, 0x0d45);
+        MP_WritePhyUshort(sc, 0x14, 0x30c0);
+        MP_WritePhyUshort(sc, 0x14, 0x3d0d);
+        MP_WritePhyUshort(sc, 0x14, 0xd71e);
+        MP_WritePhyUshort(sc, 0x14, 0x7f4c);
+        MP_WritePhyUshort(sc, 0x14, 0x2ab6);
+        MP_WritePhyUshort(sc, 0x14, 0xa540);
+        MP_WritePhyUshort(sc, 0x14, 0xc001);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x4001);
+        MP_WritePhyUshort(sc, 0x14, 0xe00f);
+        MP_WritePhyUshort(sc, 0x14, 0x0501);
+        MP_WritePhyUshort(sc, 0x14, 0x1dac);
+        MP_WritePhyUshort(sc, 0x14, 0xc1c4);
+        MP_WritePhyUshort(sc, 0x14, 0xa268);
+        MP_WritePhyUshort(sc, 0x14, 0xa303);
+        MP_WritePhyUshort(sc, 0x14, 0x8420);
+        MP_WritePhyUshort(sc, 0x14, 0xe00f);
+        MP_WritePhyUshort(sc, 0x14, 0x0502);
+        MP_WritePhyUshort(sc, 0x14, 0x1dac);
+        MP_WritePhyUshort(sc, 0x14, 0xc002);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x4000);
+        MP_WritePhyUshort(sc, 0x14, 0x8208);
+        MP_WritePhyUshort(sc, 0x14, 0x8410);
+        MP_WritePhyUshort(sc, 0x14, 0xa121);
+        MP_WritePhyUshort(sc, 0x14, 0xc002);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x4000);
+        MP_WritePhyUshort(sc, 0x14, 0x8120);
+        MP_WritePhyUshort(sc, 0x14, 0x8180);
+        MP_WritePhyUshort(sc, 0x14, 0x1d97);
+        MP_WritePhyUshort(sc, 0x14, 0xa180);
+        MP_WritePhyUshort(sc, 0x14, 0xa13a);
+        MP_WritePhyUshort(sc, 0x14, 0x8240);
+        MP_WritePhyUshort(sc, 0x14, 0xa430);
+        MP_WritePhyUshort(sc, 0x14, 0xc010);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x30e1);
+        MP_WritePhyUshort(sc, 0x14, 0x0abc);
+        MP_WritePhyUshort(sc, 0x14, 0xd71e);
+        MP_WritePhyUshort(sc, 0x14, 0x7f8c);
+        MP_WritePhyUshort(sc, 0x14, 0x2ab6);
+        MP_WritePhyUshort(sc, 0x14, 0xa480);
+        MP_WritePhyUshort(sc, 0x14, 0xa230);
+        MP_WritePhyUshort(sc, 0x14, 0xa303);
+        MP_WritePhyUshort(sc, 0x14, 0xc001);
+        MP_WritePhyUshort(sc, 0x14, 0xd70c);
+        MP_WritePhyUshort(sc, 0x14, 0x4124);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x6120);
+        MP_WritePhyUshort(sc, 0x14, 0xd711);
+        MP_WritePhyUshort(sc, 0x14, 0x3128);
+        MP_WritePhyUshort(sc, 0x14, 0x3d76);
+        MP_WritePhyUshort(sc, 0x14, 0x2d70);
+        MP_WritePhyUshort(sc, 0x14, 0xa801);
+        MP_WritePhyUshort(sc, 0x14, 0x2d6c);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x4000);
+        MP_WritePhyUshort(sc, 0x14, 0xe018);
+        MP_WritePhyUshort(sc, 0x14, 0x0208);
+        MP_WritePhyUshort(sc, 0x14, 0xa1f8);
+        MP_WritePhyUshort(sc, 0x14, 0x8480);
+        MP_WritePhyUshort(sc, 0x14, 0xc004);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x4000);
+        MP_WritePhyUshort(sc, 0x14, 0x6046);
+        MP_WritePhyUshort(sc, 0x14, 0x2d0d);
+        MP_WritePhyUshort(sc, 0x14, 0xa43f);
+        MP_WritePhyUshort(sc, 0x14, 0xa105);
+        MP_WritePhyUshort(sc, 0x14, 0x8228);
+        MP_WritePhyUshort(sc, 0x14, 0xc004);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x4000);
+        MP_WritePhyUshort(sc, 0x14, 0x81bc);
+        MP_WritePhyUshort(sc, 0x14, 0xa220);
+        MP_WritePhyUshort(sc, 0x14, 0x1d97);
+        MP_WritePhyUshort(sc, 0x14, 0x8220);
+        MP_WritePhyUshort(sc, 0x14, 0xa1bc);
+        MP_WritePhyUshort(sc, 0x14, 0xc040);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x30e1);
+        MP_WritePhyUshort(sc, 0x14, 0x0abc);
+        MP_WritePhyUshort(sc, 0x14, 0x30e1);
+        MP_WritePhyUshort(sc, 0x14, 0x3d0d);
+        MP_WritePhyUshort(sc, 0x14, 0xd71e);
+        MP_WritePhyUshort(sc, 0x14, 0x7f4c);
+        MP_WritePhyUshort(sc, 0x14, 0x2ab6);
+        MP_WritePhyUshort(sc, 0x14, 0xa802);
+        MP_WritePhyUshort(sc, 0x14, 0xd70c);
+        MP_WritePhyUshort(sc, 0x14, 0x4244);
+        MP_WritePhyUshort(sc, 0x14, 0xa301);
+        MP_WritePhyUshort(sc, 0x14, 0xc004);
+        MP_WritePhyUshort(sc, 0x14, 0xd711);
+        MP_WritePhyUshort(sc, 0x14, 0x3128);
+        MP_WritePhyUshort(sc, 0x14, 0x3da5);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x5f80);
+        MP_WritePhyUshort(sc, 0x14, 0xd711);
+        MP_WritePhyUshort(sc, 0x14, 0x3109);
+        MP_WritePhyUshort(sc, 0x14, 0x3da7);
+        MP_WritePhyUshort(sc, 0x14, 0x2dab);
+        MP_WritePhyUshort(sc, 0x14, 0xa801);
+        MP_WritePhyUshort(sc, 0x14, 0x2d9a);
+        MP_WritePhyUshort(sc, 0x14, 0xa802);
+        MP_WritePhyUshort(sc, 0x14, 0xc004);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x4000);
+        MP_WritePhyUshort(sc, 0x14, 0x0800);
+        MP_WritePhyUshort(sc, 0x14, 0xa510);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x609a);
+        MP_WritePhyUshort(sc, 0x14, 0xd71e);
+        MP_WritePhyUshort(sc, 0x14, 0x7fac);
+        MP_WritePhyUshort(sc, 0x14, 0x2ab6);
+        MP_WritePhyUshort(sc, 0x14, 0x8510);
+        MP_WritePhyUshort(sc, 0x14, 0x0800);
+        MP_WritePhyUshort(sc, 0x13, 0xA01A);
+        MP_WritePhyUshort(sc, 0x14, 0x0000);
+        MP_WritePhyUshort(sc, 0x13, 0xA006);
+        MP_WritePhyUshort(sc, 0x14, 0x0ad6);
+        MP_WritePhyUshort(sc, 0x13, 0xA004);
+        MP_WritePhyUshort(sc, 0x14, 0x07f5);
+        MP_WritePhyUshort(sc, 0x13, 0xA002);
+        MP_WritePhyUshort(sc, 0x14, 0x06a9);
+        MP_WritePhyUshort(sc, 0x13, 0xA000);
+        MP_WritePhyUshort(sc, 0x14, 0xf069);
+        MP_WritePhyUshort(sc, 0x13, 0xB820);
+        MP_WritePhyUshort(sc, 0x14, 0x0210);
+
+        MP_WritePhyUshort(sc, 0x1F, 0x0A43);
+        MP_WritePhyUshort(sc, 0x13, 0x83a0);
+        MP_WritePhyUshort(sc, 0x14, 0xaf83);
+        MP_WritePhyUshort(sc, 0x14, 0xacaf);
+        MP_WritePhyUshort(sc, 0x14, 0x83b8);
+        MP_WritePhyUshort(sc, 0x14, 0xaf83);
+        MP_WritePhyUshort(sc, 0x14, 0xcdaf);
+        MP_WritePhyUshort(sc, 0x14, 0x83d3);
+        MP_WritePhyUshort(sc, 0x14, 0x0204);
+        MP_WritePhyUshort(sc, 0x14, 0x9a02);
+        MP_WritePhyUshort(sc, 0x14, 0x09a9);
+        MP_WritePhyUshort(sc, 0x14, 0x0284);
+        MP_WritePhyUshort(sc, 0x14, 0x61af);
+        MP_WritePhyUshort(sc, 0x14, 0x02fc);
+        MP_WritePhyUshort(sc, 0x14, 0xad20);
+        MP_WritePhyUshort(sc, 0x14, 0x0302);
+        MP_WritePhyUshort(sc, 0x14, 0x867c);
+        MP_WritePhyUshort(sc, 0x14, 0xad21);
+        MP_WritePhyUshort(sc, 0x14, 0x0302);
+        MP_WritePhyUshort(sc, 0x14, 0x85c9);
+        MP_WritePhyUshort(sc, 0x14, 0xad22);
+        MP_WritePhyUshort(sc, 0x14, 0x0302);
+        MP_WritePhyUshort(sc, 0x14, 0x1bc0);
+        MP_WritePhyUshort(sc, 0x14, 0xaf17);
+        MP_WritePhyUshort(sc, 0x14, 0xe302);
+        MP_WritePhyUshort(sc, 0x14, 0x8703);
+        MP_WritePhyUshort(sc, 0x14, 0xaf18);
+        MP_WritePhyUshort(sc, 0x14, 0x6201);
+        MP_WritePhyUshort(sc, 0x14, 0x06e0);
+        MP_WritePhyUshort(sc, 0x14, 0x8148);
+        MP_WritePhyUshort(sc, 0x14, 0xaf3c);
+        MP_WritePhyUshort(sc, 0x14, 0x69f8);
+        MP_WritePhyUshort(sc, 0x14, 0xf9fa);
+        MP_WritePhyUshort(sc, 0x14, 0xef69);
+        MP_WritePhyUshort(sc, 0x14, 0xee80);
+        MP_WritePhyUshort(sc, 0x14, 0x10f7);
+        MP_WritePhyUshort(sc, 0x14, 0xee80);
+        MP_WritePhyUshort(sc, 0x14, 0x131f);
+        MP_WritePhyUshort(sc, 0x14, 0xd104);
+        MP_WritePhyUshort(sc, 0x14, 0xbf87);
+        MP_WritePhyUshort(sc, 0x14, 0xf302);
+        MP_WritePhyUshort(sc, 0x14, 0x4259);
+        MP_WritePhyUshort(sc, 0x14, 0x0287);
+        MP_WritePhyUshort(sc, 0x14, 0x88bf);
+        MP_WritePhyUshort(sc, 0x14, 0x87cf);
+        MP_WritePhyUshort(sc, 0x14, 0xd7b8);
+        MP_WritePhyUshort(sc, 0x14, 0x22d0);
+        MP_WritePhyUshort(sc, 0x14, 0x0c02);
+        MP_WritePhyUshort(sc, 0x14, 0x4252);
+        MP_WritePhyUshort(sc, 0x14, 0xee80);
+        MP_WritePhyUshort(sc, 0x14, 0xcda0);
+        MP_WritePhyUshort(sc, 0x14, 0xee80);
+        MP_WritePhyUshort(sc, 0x14, 0xce8b);
+        MP_WritePhyUshort(sc, 0x14, 0xee80);
+        MP_WritePhyUshort(sc, 0x14, 0xd1f5);
+        MP_WritePhyUshort(sc, 0x14, 0xee80);
+        MP_WritePhyUshort(sc, 0x14, 0xd2a9);
+        MP_WritePhyUshort(sc, 0x14, 0xee80);
+        MP_WritePhyUshort(sc, 0x14, 0xd30a);
+        MP_WritePhyUshort(sc, 0x14, 0xee80);
+        MP_WritePhyUshort(sc, 0x14, 0xf010);
+        MP_WritePhyUshort(sc, 0x14, 0xee80);
+        MP_WritePhyUshort(sc, 0x14, 0xf38f);
+        MP_WritePhyUshort(sc, 0x14, 0xee81);
+        MP_WritePhyUshort(sc, 0x14, 0x011e);
+        MP_WritePhyUshort(sc, 0x14, 0xee81);
+        MP_WritePhyUshort(sc, 0x14, 0x0b4a);
+        MP_WritePhyUshort(sc, 0x14, 0xee81);
+        MP_WritePhyUshort(sc, 0x14, 0x0c7c);
+        MP_WritePhyUshort(sc, 0x14, 0xee81);
+        MP_WritePhyUshort(sc, 0x14, 0x127f);
+        MP_WritePhyUshort(sc, 0x14, 0xd100);
+        MP_WritePhyUshort(sc, 0x14, 0x0210);
+        MP_WritePhyUshort(sc, 0x14, 0xb5ee);
+        MP_WritePhyUshort(sc, 0x14, 0x8088);
+        MP_WritePhyUshort(sc, 0x14, 0xa4ee);
+        MP_WritePhyUshort(sc, 0x14, 0x8089);
+        MP_WritePhyUshort(sc, 0x14, 0x44ee);
+        MP_WritePhyUshort(sc, 0x14, 0x809a);
+        MP_WritePhyUshort(sc, 0x14, 0xa4ee);
+        MP_WritePhyUshort(sc, 0x14, 0x809b);
+        MP_WritePhyUshort(sc, 0x14, 0x44ee);
+        MP_WritePhyUshort(sc, 0x14, 0x809c);
+        MP_WritePhyUshort(sc, 0x14, 0xa7ee);
+        MP_WritePhyUshort(sc, 0x14, 0x80a5);
+        MP_WritePhyUshort(sc, 0x14, 0xa7d2);
+        MP_WritePhyUshort(sc, 0x14, 0x0002);
+        MP_WritePhyUshort(sc, 0x14, 0x0e66);
+        MP_WritePhyUshort(sc, 0x14, 0x0285);
+        MP_WritePhyUshort(sc, 0x14, 0xc0ee);
+        MP_WritePhyUshort(sc, 0x14, 0x87fc);
+        MP_WritePhyUshort(sc, 0x14, 0x00e0);
+        MP_WritePhyUshort(sc, 0x14, 0x8245);
+        MP_WritePhyUshort(sc, 0x14, 0xf622);
+        MP_WritePhyUshort(sc, 0x14, 0xe482);
+        MP_WritePhyUshort(sc, 0x14, 0x45ef);
+        MP_WritePhyUshort(sc, 0x14, 0x96fe);
+        MP_WritePhyUshort(sc, 0x14, 0xfdfc);
+        MP_WritePhyUshort(sc, 0x14, 0x0402);
+        MP_WritePhyUshort(sc, 0x14, 0x847a);
+        MP_WritePhyUshort(sc, 0x14, 0x0284);
+        MP_WritePhyUshort(sc, 0x14, 0xb302);
+        MP_WritePhyUshort(sc, 0x14, 0x0cab);
+        MP_WritePhyUshort(sc, 0x14, 0x020c);
+        MP_WritePhyUshort(sc, 0x14, 0xc402);
+        MP_WritePhyUshort(sc, 0x14, 0x0cef);
+        MP_WritePhyUshort(sc, 0x14, 0x020d);
+        MP_WritePhyUshort(sc, 0x14, 0x0802);
+        MP_WritePhyUshort(sc, 0x14, 0x0d33);
+        MP_WritePhyUshort(sc, 0x14, 0x020c);
+        MP_WritePhyUshort(sc, 0x14, 0x3d04);
+        MP_WritePhyUshort(sc, 0x14, 0xf8fa);
+        MP_WritePhyUshort(sc, 0x14, 0xef69);
+        MP_WritePhyUshort(sc, 0x14, 0xe182);
+        MP_WritePhyUshort(sc, 0x14, 0x2fac);
+        MP_WritePhyUshort(sc, 0x14, 0x291a);
+        MP_WritePhyUshort(sc, 0x14, 0xe082);
+        MP_WritePhyUshort(sc, 0x14, 0x24ac);
+        MP_WritePhyUshort(sc, 0x14, 0x2102);
+        MP_WritePhyUshort(sc, 0x14, 0xae22);
+        MP_WritePhyUshort(sc, 0x14, 0x0210);
+        MP_WritePhyUshort(sc, 0x14, 0x57f6);
+        MP_WritePhyUshort(sc, 0x14, 0x21e4);
+        MP_WritePhyUshort(sc, 0x14, 0x8224);
+        MP_WritePhyUshort(sc, 0x14, 0xd101);
+        MP_WritePhyUshort(sc, 0x14, 0xbf44);
+        MP_WritePhyUshort(sc, 0x14, 0xd202);
+        MP_WritePhyUshort(sc, 0x14, 0x4259);
+        MP_WritePhyUshort(sc, 0x14, 0xae10);
+        MP_WritePhyUshort(sc, 0x14, 0x0212);
+        MP_WritePhyUshort(sc, 0x14, 0x4cf6);
+        MP_WritePhyUshort(sc, 0x14, 0x29e5);
+        MP_WritePhyUshort(sc, 0x14, 0x822f);
+        MP_WritePhyUshort(sc, 0x14, 0xe082);
+        MP_WritePhyUshort(sc, 0x14, 0x24f6);
+        MP_WritePhyUshort(sc, 0x14, 0x21e4);
+        MP_WritePhyUshort(sc, 0x14, 0x8224);
+        MP_WritePhyUshort(sc, 0x14, 0xef96);
+        MP_WritePhyUshort(sc, 0x14, 0xfefc);
+        MP_WritePhyUshort(sc, 0x14, 0x04f8);
+        MP_WritePhyUshort(sc, 0x14, 0xe182);
+        MP_WritePhyUshort(sc, 0x14, 0x2fac);
+        MP_WritePhyUshort(sc, 0x14, 0x2a18);
+        MP_WritePhyUshort(sc, 0x14, 0xe082);
+        MP_WritePhyUshort(sc, 0x14, 0x24ac);
+        MP_WritePhyUshort(sc, 0x14, 0x2202);
+        MP_WritePhyUshort(sc, 0x14, 0xae26);
+        MP_WritePhyUshort(sc, 0x14, 0x0284);
+        MP_WritePhyUshort(sc, 0x14, 0xf802);
+        MP_WritePhyUshort(sc, 0x14, 0x8565);
+        MP_WritePhyUshort(sc, 0x14, 0xd101);
+        MP_WritePhyUshort(sc, 0x14, 0xbf44);
+        MP_WritePhyUshort(sc, 0x14, 0xd502);
+        MP_WritePhyUshort(sc, 0x14, 0x4259);
+        MP_WritePhyUshort(sc, 0x14, 0xae0e);
+        MP_WritePhyUshort(sc, 0x14, 0x0284);
+        MP_WritePhyUshort(sc, 0x14, 0xea02);
+        MP_WritePhyUshort(sc, 0x14, 0x85a9);
+        MP_WritePhyUshort(sc, 0x14, 0xe182);
+        MP_WritePhyUshort(sc, 0x14, 0x2ff6);
+        MP_WritePhyUshort(sc, 0x14, 0x2ae5);
+        MP_WritePhyUshort(sc, 0x14, 0x822f);
+        MP_WritePhyUshort(sc, 0x14, 0xe082);
+        MP_WritePhyUshort(sc, 0x14, 0x24f6);
+        MP_WritePhyUshort(sc, 0x14, 0x22e4);
+        MP_WritePhyUshort(sc, 0x14, 0x8224);
+        MP_WritePhyUshort(sc, 0x14, 0xfc04);
+        MP_WritePhyUshort(sc, 0x14, 0xf9e2);
+        MP_WritePhyUshort(sc, 0x14, 0x8011);
+        MP_WritePhyUshort(sc, 0x14, 0xad31);
+        MP_WritePhyUshort(sc, 0x14, 0x05d2);
+        MP_WritePhyUshort(sc, 0x14, 0x0002);
+        MP_WritePhyUshort(sc, 0x14, 0x0e66);
+        MP_WritePhyUshort(sc, 0x14, 0xfd04);
+        MP_WritePhyUshort(sc, 0x14, 0xf8f9);
+        MP_WritePhyUshort(sc, 0x14, 0xfaef);
+        MP_WritePhyUshort(sc, 0x14, 0x69e0);
+        MP_WritePhyUshort(sc, 0x14, 0x8011);
+        MP_WritePhyUshort(sc, 0x14, 0xad21);
+        MP_WritePhyUshort(sc, 0x14, 0x5cbf);
+        MP_WritePhyUshort(sc, 0x14, 0x43be);
+        MP_WritePhyUshort(sc, 0x14, 0x0242);
+        MP_WritePhyUshort(sc, 0x14, 0x97ac);
+        MP_WritePhyUshort(sc, 0x14, 0x281b);
+        MP_WritePhyUshort(sc, 0x14, 0xbf43);
+        MP_WritePhyUshort(sc, 0x14, 0xc102);
+        MP_WritePhyUshort(sc, 0x14, 0x4297);
+        MP_WritePhyUshort(sc, 0x14, 0xac28);
+        MP_WritePhyUshort(sc, 0x14, 0x12bf);
+        MP_WritePhyUshort(sc, 0x14, 0x43c7);
+        MP_WritePhyUshort(sc, 0x14, 0x0242);
+        MP_WritePhyUshort(sc, 0x14, 0x97ac);
+        MP_WritePhyUshort(sc, 0x14, 0x2804);
+        MP_WritePhyUshort(sc, 0x14, 0xd300);
+        MP_WritePhyUshort(sc, 0x14, 0xae07);
+        MP_WritePhyUshort(sc, 0x14, 0xd306);
+        MP_WritePhyUshort(sc, 0x14, 0xaf85);
+        MP_WritePhyUshort(sc, 0x14, 0x56d3);
+        MP_WritePhyUshort(sc, 0x14, 0x03e0);
+        MP_WritePhyUshort(sc, 0x14, 0x8011);
+        MP_WritePhyUshort(sc, 0x14, 0xad26);
+        MP_WritePhyUshort(sc, 0x14, 0x25bf);
+        MP_WritePhyUshort(sc, 0x14, 0x4559);
+        MP_WritePhyUshort(sc, 0x14, 0x0242);
+        MP_WritePhyUshort(sc, 0x14, 0x97e2);
+        MP_WritePhyUshort(sc, 0x14, 0x8073);
+        MP_WritePhyUshort(sc, 0x14, 0x0d21);
+        MP_WritePhyUshort(sc, 0x14, 0xf637);
+        MP_WritePhyUshort(sc, 0x14, 0x0d11);
+        MP_WritePhyUshort(sc, 0x14, 0xf62f);
+        MP_WritePhyUshort(sc, 0x14, 0x1b21);
+        MP_WritePhyUshort(sc, 0x14, 0xaa02);
+        MP_WritePhyUshort(sc, 0x14, 0xae10);
+        MP_WritePhyUshort(sc, 0x14, 0xe280);
+        MP_WritePhyUshort(sc, 0x14, 0x740d);
+        MP_WritePhyUshort(sc, 0x14, 0x21f6);
+        MP_WritePhyUshort(sc, 0x14, 0x371b);
+        MP_WritePhyUshort(sc, 0x14, 0x21aa);
+        MP_WritePhyUshort(sc, 0x14, 0x0313);
+        MP_WritePhyUshort(sc, 0x14, 0xae02);
+        MP_WritePhyUshort(sc, 0x14, 0x2b02);
+        MP_WritePhyUshort(sc, 0x14, 0x020e);
+        MP_WritePhyUshort(sc, 0x14, 0x5102);
+        MP_WritePhyUshort(sc, 0x14, 0x0e66);
+        MP_WritePhyUshort(sc, 0x14, 0x020f);
+        MP_WritePhyUshort(sc, 0x14, 0xa3ef);
+        MP_WritePhyUshort(sc, 0x14, 0x96fe);
+        MP_WritePhyUshort(sc, 0x14, 0xfdfc);
+        MP_WritePhyUshort(sc, 0x14, 0x04f8);
+        MP_WritePhyUshort(sc, 0x14, 0xf9fa);
+        MP_WritePhyUshort(sc, 0x14, 0xef69);
+        MP_WritePhyUshort(sc, 0x14, 0xe080);
+        MP_WritePhyUshort(sc, 0x14, 0x12ad);
+        MP_WritePhyUshort(sc, 0x14, 0x2733);
+        MP_WritePhyUshort(sc, 0x14, 0xbf43);
+        MP_WritePhyUshort(sc, 0x14, 0xbe02);
+        MP_WritePhyUshort(sc, 0x14, 0x4297);
+        MP_WritePhyUshort(sc, 0x14, 0xac28);
+        MP_WritePhyUshort(sc, 0x14, 0x09bf);
+        MP_WritePhyUshort(sc, 0x14, 0x43c1);
+        MP_WritePhyUshort(sc, 0x14, 0x0242);
+        MP_WritePhyUshort(sc, 0x14, 0x97ad);
+        MP_WritePhyUshort(sc, 0x14, 0x2821);
+        MP_WritePhyUshort(sc, 0x14, 0xbf45);
+        MP_WritePhyUshort(sc, 0x14, 0x5902);
+        MP_WritePhyUshort(sc, 0x14, 0x4297);
+        MP_WritePhyUshort(sc, 0x14, 0xe387);
+        MP_WritePhyUshort(sc, 0x14, 0xffd2);
+        MP_WritePhyUshort(sc, 0x14, 0x001b);
+        MP_WritePhyUshort(sc, 0x14, 0x45ac);
+        MP_WritePhyUshort(sc, 0x14, 0x2711);
+        MP_WritePhyUshort(sc, 0x14, 0xe187);
+        MP_WritePhyUshort(sc, 0x14, 0xfebf);
+        MP_WritePhyUshort(sc, 0x14, 0x87e4);
+        MP_WritePhyUshort(sc, 0x14, 0x0242);
+        MP_WritePhyUshort(sc, 0x14, 0x590d);
+        MP_WritePhyUshort(sc, 0x14, 0x11bf);
+        MP_WritePhyUshort(sc, 0x14, 0x87e7);
+        MP_WritePhyUshort(sc, 0x14, 0x0242);
+        MP_WritePhyUshort(sc, 0x14, 0x59ef);
+        MP_WritePhyUshort(sc, 0x14, 0x96fe);
+        MP_WritePhyUshort(sc, 0x14, 0xfdfc);
+        MP_WritePhyUshort(sc, 0x14, 0x04f8);
+        MP_WritePhyUshort(sc, 0x14, 0xfaef);
+        MP_WritePhyUshort(sc, 0x14, 0x69d1);
+        MP_WritePhyUshort(sc, 0x14, 0x00bf);
+        MP_WritePhyUshort(sc, 0x14, 0x87e4);
+        MP_WritePhyUshort(sc, 0x14, 0x0242);
+        MP_WritePhyUshort(sc, 0x14, 0x59bf);
+        MP_WritePhyUshort(sc, 0x14, 0x87e7);
+        MP_WritePhyUshort(sc, 0x14, 0x0242);
+        MP_WritePhyUshort(sc, 0x14, 0x59ef);
+        MP_WritePhyUshort(sc, 0x14, 0x96fe);
+        MP_WritePhyUshort(sc, 0x14, 0xfc04);
+        MP_WritePhyUshort(sc, 0x14, 0xee87);
+        MP_WritePhyUshort(sc, 0x14, 0xff46);
+        MP_WritePhyUshort(sc, 0x14, 0xee87);
+        MP_WritePhyUshort(sc, 0x14, 0xfe01);
+        MP_WritePhyUshort(sc, 0x14, 0x04f8);
+        MP_WritePhyUshort(sc, 0x14, 0xfaef);
+        MP_WritePhyUshort(sc, 0x14, 0x69e0);
+        MP_WritePhyUshort(sc, 0x14, 0x8241);
+        MP_WritePhyUshort(sc, 0x14, 0xa000);
+        MP_WritePhyUshort(sc, 0x14, 0x0502);
+        MP_WritePhyUshort(sc, 0x14, 0x85eb);
+        MP_WritePhyUshort(sc, 0x14, 0xae0e);
+        MP_WritePhyUshort(sc, 0x14, 0xa001);
+        MP_WritePhyUshort(sc, 0x14, 0x0502);
+        MP_WritePhyUshort(sc, 0x14, 0x1a5a);
+        MP_WritePhyUshort(sc, 0x14, 0xae06);
+        MP_WritePhyUshort(sc, 0x14, 0xa002);
+        MP_WritePhyUshort(sc, 0x14, 0x0302);
+        MP_WritePhyUshort(sc, 0x14, 0x1ae6);
+        MP_WritePhyUshort(sc, 0x14, 0xef96);
+        MP_WritePhyUshort(sc, 0x14, 0xfefc);
+        MP_WritePhyUshort(sc, 0x14, 0x04f8);
+        MP_WritePhyUshort(sc, 0x14, 0xf9fa);
+        MP_WritePhyUshort(sc, 0x14, 0xef69);
+        MP_WritePhyUshort(sc, 0x14, 0xe082);
+        MP_WritePhyUshort(sc, 0x14, 0x29f6);
+        MP_WritePhyUshort(sc, 0x14, 0x21e4);
+        MP_WritePhyUshort(sc, 0x14, 0x8229);
+        MP_WritePhyUshort(sc, 0x14, 0xe080);
+        MP_WritePhyUshort(sc, 0x14, 0x10ac);
+        MP_WritePhyUshort(sc, 0x14, 0x2202);
+        MP_WritePhyUshort(sc, 0x14, 0xae76);
+        MP_WritePhyUshort(sc, 0x14, 0xe082);
+        MP_WritePhyUshort(sc, 0x14, 0x27f7);
+        MP_WritePhyUshort(sc, 0x14, 0x21e4);
+        MP_WritePhyUshort(sc, 0x14, 0x8227);
+        MP_WritePhyUshort(sc, 0x14, 0xbf43);
+        MP_WritePhyUshort(sc, 0x14, 0x1302);
+        MP_WritePhyUshort(sc, 0x14, 0x4297);
+        MP_WritePhyUshort(sc, 0x14, 0xef21);
+        MP_WritePhyUshort(sc, 0x14, 0xbf43);
+        MP_WritePhyUshort(sc, 0x14, 0x1602);
+        MP_WritePhyUshort(sc, 0x14, 0x4297);
+        MP_WritePhyUshort(sc, 0x14, 0x0c11);
+        MP_WritePhyUshort(sc, 0x14, 0x1e21);
+        MP_WritePhyUshort(sc, 0x14, 0xbf43);
+        MP_WritePhyUshort(sc, 0x14, 0x1902);
+        MP_WritePhyUshort(sc, 0x14, 0x4297);
+        MP_WritePhyUshort(sc, 0x14, 0x0c12);
+        MP_WritePhyUshort(sc, 0x14, 0x1e21);
+        MP_WritePhyUshort(sc, 0x14, 0xe682);
+        MP_WritePhyUshort(sc, 0x14, 0x43a2);
+        MP_WritePhyUshort(sc, 0x14, 0x000a);
+        MP_WritePhyUshort(sc, 0x14, 0xe182);
+        MP_WritePhyUshort(sc, 0x14, 0x27f6);
+        MP_WritePhyUshort(sc, 0x14, 0x29e5);
+        MP_WritePhyUshort(sc, 0x14, 0x8227);
+        MP_WritePhyUshort(sc, 0x14, 0xae42);
+        MP_WritePhyUshort(sc, 0x14, 0xe082);
+        MP_WritePhyUshort(sc, 0x14, 0x44f7);
+        MP_WritePhyUshort(sc, 0x14, 0x21e4);
+        MP_WritePhyUshort(sc, 0x14, 0x8244);
+        MP_WritePhyUshort(sc, 0x14, 0x0246);
+        MP_WritePhyUshort(sc, 0x14, 0xaebf);
+        MP_WritePhyUshort(sc, 0x14, 0x4325);
+        MP_WritePhyUshort(sc, 0x14, 0x0242);
+        MP_WritePhyUshort(sc, 0x14, 0x97ef);
+        MP_WritePhyUshort(sc, 0x14, 0x21bf);
+        MP_WritePhyUshort(sc, 0x14, 0x431c);
+        MP_WritePhyUshort(sc, 0x14, 0x0242);
+        MP_WritePhyUshort(sc, 0x14, 0x970c);
+        MP_WritePhyUshort(sc, 0x14, 0x121e);
+        MP_WritePhyUshort(sc, 0x14, 0x21bf);
+        MP_WritePhyUshort(sc, 0x14, 0x431f);
+        MP_WritePhyUshort(sc, 0x14, 0x0242);
+        MP_WritePhyUshort(sc, 0x14, 0x970c);
+        MP_WritePhyUshort(sc, 0x14, 0x131e);
+        MP_WritePhyUshort(sc, 0x14, 0x21bf);
+        MP_WritePhyUshort(sc, 0x14, 0x4328);
+        MP_WritePhyUshort(sc, 0x14, 0x0242);
+        MP_WritePhyUshort(sc, 0x14, 0x970c);
+        MP_WritePhyUshort(sc, 0x14, 0x141e);
+        MP_WritePhyUshort(sc, 0x14, 0x21bf);
+        MP_WritePhyUshort(sc, 0x14, 0x44b1);
+        MP_WritePhyUshort(sc, 0x14, 0x0242);
+        MP_WritePhyUshort(sc, 0x14, 0x970c);
+        MP_WritePhyUshort(sc, 0x14, 0x161e);
+        MP_WritePhyUshort(sc, 0x14, 0x21e6);
+        MP_WritePhyUshort(sc, 0x14, 0x8242);
+        MP_WritePhyUshort(sc, 0x14, 0xee82);
+        MP_WritePhyUshort(sc, 0x14, 0x4101);
+        MP_WritePhyUshort(sc, 0x14, 0xef96);
+        MP_WritePhyUshort(sc, 0x14, 0xfefd);
+        MP_WritePhyUshort(sc, 0x14, 0xfc04);
+        MP_WritePhyUshort(sc, 0x14, 0xf8fa);
+        MP_WritePhyUshort(sc, 0x14, 0xef69);
+        MP_WritePhyUshort(sc, 0x14, 0xe082);
+        MP_WritePhyUshort(sc, 0x14, 0x46a0);
+        MP_WritePhyUshort(sc, 0x14, 0x0005);
+        MP_WritePhyUshort(sc, 0x14, 0x0286);
+        MP_WritePhyUshort(sc, 0x14, 0x96ae);
+        MP_WritePhyUshort(sc, 0x14, 0x06a0);
+        MP_WritePhyUshort(sc, 0x14, 0x0103);
+        MP_WritePhyUshort(sc, 0x14, 0x0219);
+        MP_WritePhyUshort(sc, 0x14, 0x19ef);
+        MP_WritePhyUshort(sc, 0x14, 0x96fe);
+        MP_WritePhyUshort(sc, 0x14, 0xfc04);
+        MP_WritePhyUshort(sc, 0x14, 0xf8fa);
+        MP_WritePhyUshort(sc, 0x14, 0xef69);
+        MP_WritePhyUshort(sc, 0x14, 0xe082);
+        MP_WritePhyUshort(sc, 0x14, 0x29f6);
+        MP_WritePhyUshort(sc, 0x14, 0x20e4);
+        MP_WritePhyUshort(sc, 0x14, 0x8229);
+        MP_WritePhyUshort(sc, 0x14, 0xe080);
+        MP_WritePhyUshort(sc, 0x14, 0x10ac);
+        MP_WritePhyUshort(sc, 0x14, 0x2102);
+        MP_WritePhyUshort(sc, 0x14, 0xae54);
+        MP_WritePhyUshort(sc, 0x14, 0xe082);
+        MP_WritePhyUshort(sc, 0x14, 0x27f7);
+        MP_WritePhyUshort(sc, 0x14, 0x20e4);
+        MP_WritePhyUshort(sc, 0x14, 0x8227);
+        MP_WritePhyUshort(sc, 0x14, 0xbf42);
+        MP_WritePhyUshort(sc, 0x14, 0xe602);
+        MP_WritePhyUshort(sc, 0x14, 0x4297);
+        MP_WritePhyUshort(sc, 0x14, 0xac28);
+        MP_WritePhyUshort(sc, 0x14, 0x22bf);
+        MP_WritePhyUshort(sc, 0x14, 0x430d);
+        MP_WritePhyUshort(sc, 0x14, 0x0242);
+        MP_WritePhyUshort(sc, 0x14, 0x97e5);
+        MP_WritePhyUshort(sc, 0x14, 0x8247);
+        MP_WritePhyUshort(sc, 0x14, 0xac28);
+        MP_WritePhyUshort(sc, 0x14, 0x20d1);
+        MP_WritePhyUshort(sc, 0x14, 0x03bf);
+        MP_WritePhyUshort(sc, 0x14, 0x4307);
+        MP_WritePhyUshort(sc, 0x14, 0x0242);
+        MP_WritePhyUshort(sc, 0x14, 0x59ee);
+        MP_WritePhyUshort(sc, 0x14, 0x8246);
+        MP_WritePhyUshort(sc, 0x14, 0x00e1);
+        MP_WritePhyUshort(sc, 0x14, 0x8227);
+        MP_WritePhyUshort(sc, 0x14, 0xf628);
+        MP_WritePhyUshort(sc, 0x14, 0xe582);
+        MP_WritePhyUshort(sc, 0x14, 0x27ae);
+        MP_WritePhyUshort(sc, 0x14, 0x21d1);
+        MP_WritePhyUshort(sc, 0x14, 0x04bf);
+        MP_WritePhyUshort(sc, 0x14, 0x4307);
+        MP_WritePhyUshort(sc, 0x14, 0x0242);
+        MP_WritePhyUshort(sc, 0x14, 0x59ae);
+        MP_WritePhyUshort(sc, 0x14, 0x08d1);
+        MP_WritePhyUshort(sc, 0x14, 0x05bf);
+        MP_WritePhyUshort(sc, 0x14, 0x4307);
+        MP_WritePhyUshort(sc, 0x14, 0x0242);
+        MP_WritePhyUshort(sc, 0x14, 0x59e0);
+        MP_WritePhyUshort(sc, 0x14, 0x8244);
+        MP_WritePhyUshort(sc, 0x14, 0xf720);
+        MP_WritePhyUshort(sc, 0x14, 0xe482);
+        MP_WritePhyUshort(sc, 0x14, 0x4402);
+        MP_WritePhyUshort(sc, 0x14, 0x46ae);
+        MP_WritePhyUshort(sc, 0x14, 0xee82);
+        MP_WritePhyUshort(sc, 0x14, 0x4601);
+        MP_WritePhyUshort(sc, 0x14, 0xef96);
+        MP_WritePhyUshort(sc, 0x14, 0xfefc);
+        MP_WritePhyUshort(sc, 0x14, 0x04f8);
+        MP_WritePhyUshort(sc, 0x14, 0xfaef);
+        MP_WritePhyUshort(sc, 0x14, 0x69e0);
+        MP_WritePhyUshort(sc, 0x14, 0x8013);
+        MP_WritePhyUshort(sc, 0x14, 0xad24);
+        MP_WritePhyUshort(sc, 0x14, 0x1cbf);
+        MP_WritePhyUshort(sc, 0x14, 0x87f0);
+        MP_WritePhyUshort(sc, 0x14, 0x0242);
+        MP_WritePhyUshort(sc, 0x14, 0x97ad);
+        MP_WritePhyUshort(sc, 0x14, 0x2813);
+        MP_WritePhyUshort(sc, 0x14, 0xe087);
+        MP_WritePhyUshort(sc, 0x14, 0xfca0);
+        MP_WritePhyUshort(sc, 0x14, 0x0005);
+        MP_WritePhyUshort(sc, 0x14, 0x0287);
+        MP_WritePhyUshort(sc, 0x14, 0x36ae);
+        MP_WritePhyUshort(sc, 0x14, 0x10a0);
+        MP_WritePhyUshort(sc, 0x14, 0x0105);
+        MP_WritePhyUshort(sc, 0x14, 0x0287);
+        MP_WritePhyUshort(sc, 0x14, 0x48ae);
+        MP_WritePhyUshort(sc, 0x14, 0x08e0);
+        MP_WritePhyUshort(sc, 0x14, 0x8230);
+        MP_WritePhyUshort(sc, 0x14, 0xf626);
+        MP_WritePhyUshort(sc, 0x14, 0xe482);
+        MP_WritePhyUshort(sc, 0x14, 0x30ef);
+        MP_WritePhyUshort(sc, 0x14, 0x96fe);
+        MP_WritePhyUshort(sc, 0x14, 0xfc04);
+        MP_WritePhyUshort(sc, 0x14, 0xf8e0);
+        MP_WritePhyUshort(sc, 0x14, 0x8245);
+        MP_WritePhyUshort(sc, 0x14, 0xf722);
+        MP_WritePhyUshort(sc, 0x14, 0xe482);
+        MP_WritePhyUshort(sc, 0x14, 0x4502);
+        MP_WritePhyUshort(sc, 0x14, 0x46ae);
+        MP_WritePhyUshort(sc, 0x14, 0xee87);
+        MP_WritePhyUshort(sc, 0x14, 0xfc01);
+        MP_WritePhyUshort(sc, 0x14, 0xfc04);
+        MP_WritePhyUshort(sc, 0x14, 0xf8fa);
+        MP_WritePhyUshort(sc, 0x14, 0xef69);
+        MP_WritePhyUshort(sc, 0x14, 0xfb02);
+        MP_WritePhyUshort(sc, 0x14, 0x46d3);
+        MP_WritePhyUshort(sc, 0x14, 0xad50);
+        MP_WritePhyUshort(sc, 0x14, 0x2fbf);
+        MP_WritePhyUshort(sc, 0x14, 0x87ed);
+        MP_WritePhyUshort(sc, 0x14, 0xd101);
+        MP_WritePhyUshort(sc, 0x14, 0x0242);
+        MP_WritePhyUshort(sc, 0x14, 0x59bf);
+        MP_WritePhyUshort(sc, 0x14, 0x87ed);
+        MP_WritePhyUshort(sc, 0x14, 0xd100);
+        MP_WritePhyUshort(sc, 0x14, 0x0242);
+        MP_WritePhyUshort(sc, 0x14, 0x59e0);
+        MP_WritePhyUshort(sc, 0x14, 0x8245);
+        MP_WritePhyUshort(sc, 0x14, 0xf622);
+        MP_WritePhyUshort(sc, 0x14, 0xe482);
+        MP_WritePhyUshort(sc, 0x14, 0x4502);
+        MP_WritePhyUshort(sc, 0x14, 0x46ae);
+        MP_WritePhyUshort(sc, 0x14, 0xd100);
+        MP_WritePhyUshort(sc, 0x14, 0xbf87);
+        MP_WritePhyUshort(sc, 0x14, 0xf002);
+        MP_WritePhyUshort(sc, 0x14, 0x4259);
+        MP_WritePhyUshort(sc, 0x14, 0xee87);
+        MP_WritePhyUshort(sc, 0x14, 0xfc00);
+        MP_WritePhyUshort(sc, 0x14, 0xe082);
+        MP_WritePhyUshort(sc, 0x14, 0x30f6);
+        MP_WritePhyUshort(sc, 0x14, 0x26e4);
+        MP_WritePhyUshort(sc, 0x14, 0x8230);
+        MP_WritePhyUshort(sc, 0x14, 0xffef);
+        MP_WritePhyUshort(sc, 0x14, 0x96fe);
+        MP_WritePhyUshort(sc, 0x14, 0xfc04);
+        MP_WritePhyUshort(sc, 0x14, 0xf8f9);
+        MP_WritePhyUshort(sc, 0x14, 0xface);
+        MP_WritePhyUshort(sc, 0x14, 0xfaef);
+        MP_WritePhyUshort(sc, 0x14, 0x69fb);
+        MP_WritePhyUshort(sc, 0x14, 0xbf87);
+        MP_WritePhyUshort(sc, 0x14, 0xb3d7);
+        MP_WritePhyUshort(sc, 0x14, 0x001c);
+        MP_WritePhyUshort(sc, 0x14, 0xd819);
+        MP_WritePhyUshort(sc, 0x14, 0xd919);
+        MP_WritePhyUshort(sc, 0x14, 0xda19);
+        MP_WritePhyUshort(sc, 0x14, 0xdb19);
+        MP_WritePhyUshort(sc, 0x14, 0x07ef);
+        MP_WritePhyUshort(sc, 0x14, 0x9502);
+        MP_WritePhyUshort(sc, 0x14, 0x4259);
+        MP_WritePhyUshort(sc, 0x14, 0x073f);
+        MP_WritePhyUshort(sc, 0x14, 0x0004);
+        MP_WritePhyUshort(sc, 0x14, 0x9fec);
+        MP_WritePhyUshort(sc, 0x14, 0xffef);
+        MP_WritePhyUshort(sc, 0x14, 0x96fe);
+        MP_WritePhyUshort(sc, 0x14, 0xc6fe);
+        MP_WritePhyUshort(sc, 0x14, 0xfdfc);
+        MP_WritePhyUshort(sc, 0x14, 0x0400);
+        MP_WritePhyUshort(sc, 0x14, 0x0145);
+        MP_WritePhyUshort(sc, 0x14, 0x7d00);
+        MP_WritePhyUshort(sc, 0x14, 0x0345);
+        MP_WritePhyUshort(sc, 0x14, 0x5c00);
+        MP_WritePhyUshort(sc, 0x14, 0x0143);
+        MP_WritePhyUshort(sc, 0x14, 0x4f00);
+        MP_WritePhyUshort(sc, 0x14, 0x0387);
+        MP_WritePhyUshort(sc, 0x14, 0xdb00);
+        MP_WritePhyUshort(sc, 0x14, 0x0987);
+        MP_WritePhyUshort(sc, 0x14, 0xde00);
+        MP_WritePhyUshort(sc, 0x14, 0x0987);
+        MP_WritePhyUshort(sc, 0x14, 0xe100);
+        MP_WritePhyUshort(sc, 0x14, 0x0087);
+        MP_WritePhyUshort(sc, 0x14, 0xeaa4);
+        MP_WritePhyUshort(sc, 0x14, 0x00b8);
+        MP_WritePhyUshort(sc, 0x14, 0x20c4);
+        MP_WritePhyUshort(sc, 0x14, 0x1600);
+        MP_WritePhyUshort(sc, 0x14, 0x000f);
+        MP_WritePhyUshort(sc, 0x14, 0xf800);
+        MP_WritePhyUshort(sc, 0x14, 0x7098);
+        MP_WritePhyUshort(sc, 0x14, 0xa58a);
+        MP_WritePhyUshort(sc, 0x14, 0xb6a8);
+        MP_WritePhyUshort(sc, 0x14, 0x3e50);
+        MP_WritePhyUshort(sc, 0x14, 0xa83e);
+        MP_WritePhyUshort(sc, 0x14, 0x33bc);
+        MP_WritePhyUshort(sc, 0x14, 0xc622);
+        MP_WritePhyUshort(sc, 0x14, 0xbcc6);
+        MP_WritePhyUshort(sc, 0x14, 0xaaa4);
+        MP_WritePhyUshort(sc, 0x14, 0x42ff);
+        MP_WritePhyUshort(sc, 0x14, 0xc408);
+        MP_WritePhyUshort(sc, 0x14, 0x00c4);
+        MP_WritePhyUshort(sc, 0x14, 0x16a8);
+        MP_WritePhyUshort(sc, 0x14, 0xbcc0);
+        MP_WritePhyUshort(sc, 0x13, 0xb818);
+        MP_WritePhyUshort(sc, 0x14, 0x02f3);
+        MP_WritePhyUshort(sc, 0x13, 0xb81a);
+        MP_WritePhyUshort(sc, 0x14, 0x17d1);
+        MP_WritePhyUshort(sc, 0x13, 0xb81c);
+        MP_WritePhyUshort(sc, 0x14, 0x185a);
+        MP_WritePhyUshort(sc, 0x13, 0xb81e);
+        MP_WritePhyUshort(sc, 0x14, 0x3c66);
+        MP_WritePhyUshort(sc, 0x13, 0xb820);
+        MP_WritePhyUshort(sc, 0x14, 0x021f);
+        MP_WritePhyUshort(sc, 0x13, 0xc416);
+        MP_WritePhyUshort(sc, 0x14, 0x0500);
+        MP_WritePhyUshort(sc, 0x13, 0xb82e);
+        MP_WritePhyUshort(sc, 0x14, 0xfffc);
+
+        MP_WritePhyUshort(sc, 0x1F, 0x0A43);
+        MP_WritePhyUshort(sc, 0x13, 0x0000);
+        MP_WritePhyUshort(sc, 0x14, 0x0000);
+        MP_WritePhyUshort(sc, 0x1f, 0x0B82);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
+        PhyRegValue &= ~(BIT_9);
+        MP_WritePhyUshort(sc, 0x10, PhyRegValue);
+        MP_WritePhyUshort(sc, 0x1f, 0x0A43);
+        MP_WritePhyUshort(sc, 0x13, 0x8146);
+        MP_WritePhyUshort(sc, 0x14, 0x0000);
+
+        MP_WritePhyUshort(sc, 0x1f, 0x0B82);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
+        PhyRegValue &= ~(BIT_4);
+        MP_WritePhyUshort(sc, 0x10, PhyRegValue);
+        if (sc->RequiredSecLanDonglePatch) {
+                MP_WritePhyUshort(sc, 0x1F, 0x0A43);
+                PhyRegValue = MP_ReadPhyUshort(sc, 0x11);
+                PhyRegValue &= ~(BIT_6);
+                MP_WritePhyUshort(sc, 0x11, PhyRegValue);
+        }
+}
+
+static void re_set_phy_mcu_8168gu_2(struct re_softc *sc)
+{
+        u_int16_t PhyRegValue;
+        u_int32_t WaitCnt;
+
+        MP_WritePhyUshort(sc, 0x1f, 0x0B82);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
+        PhyRegValue |= BIT_4;
+        MP_WritePhyUshort(sc, 0x10, PhyRegValue);
+
+        MP_WritePhyUshort(sc, 0x1f, 0x0B80);
+        WaitCnt = 0;
+        do {
+                PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
+                PhyRegValue &= 0x0040;
+                DELAY(50);
+                DELAY(50);
+                WaitCnt++;
+        } while(PhyRegValue != 0x0040 && WaitCnt <1000);
+
+        MP_WritePhyUshort(sc, 0x1f, 0x0A43);
+        MP_WritePhyUshort(sc, 0x13, 0x8146);
+        MP_WritePhyUshort(sc, 0x14, 0x0300);
+        MP_WritePhyUshort(sc, 0x13, 0xB82E);
+        MP_WritePhyUshort(sc, 0x14, 0x0001);
+
+        MP_WritePhyUshort(sc, 0x1F, 0x0A43);
+        MP_WritePhyUshort(sc, 0x13, 0xb820);
+        MP_WritePhyUshort(sc, 0x14, 0x0290);
+        MP_WritePhyUshort(sc, 0x13, 0xa012);
+        MP_WritePhyUshort(sc, 0x14, 0x0000);
+        MP_WritePhyUshort(sc, 0x13, 0xa014);
+        MP_WritePhyUshort(sc, 0x14, 0x2c04);
+        MP_WritePhyUshort(sc, 0x14, 0x2c07);
+        MP_WritePhyUshort(sc, 0x14, 0x2c07);
+        MP_WritePhyUshort(sc, 0x14, 0x2c07);
+        MP_WritePhyUshort(sc, 0x14, 0xa304);
+        MP_WritePhyUshort(sc, 0x14, 0xa301);
+        MP_WritePhyUshort(sc, 0x14, 0x207e);
+        MP_WritePhyUshort(sc, 0x13, 0xa01a);
+        MP_WritePhyUshort(sc, 0x14, 0x0000);
+        MP_WritePhyUshort(sc, 0x13, 0xa006);
+        MP_WritePhyUshort(sc, 0x14, 0x0fff);
+        MP_WritePhyUshort(sc, 0x13, 0xa004);
+        MP_WritePhyUshort(sc, 0x14, 0x0fff);
+        MP_WritePhyUshort(sc, 0x13, 0xa002);
+        MP_WritePhyUshort(sc, 0x14, 0x0fff);
+        MP_WritePhyUshort(sc, 0x13, 0xa000);
+        MP_WritePhyUshort(sc, 0x14, 0x107c);
+        MP_WritePhyUshort(sc, 0x13, 0xb820);
+        MP_WritePhyUshort(sc, 0x14, 0x0210);
+
+        MP_WritePhyUshort(sc, 0x1F, 0x0A43);
+        MP_WritePhyUshort(sc, 0x13, 0x0000);
+        MP_WritePhyUshort(sc, 0x14, 0x0000);
+        MP_WritePhyUshort(sc, 0x1f, 0x0B82);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
+        PhyRegValue &= ~(BIT_0);
+        MP_WritePhyUshort(sc, 0x17, PhyRegValue);
+        MP_WritePhyUshort(sc, 0x1f, 0x0A43);
+        MP_WritePhyUshort(sc, 0x13, 0x8146);
+        MP_WritePhyUshort(sc, 0x14, 0x0000);
+
+        MP_WritePhyUshort(sc, 0x1f, 0x0B82);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
+        PhyRegValue &= ~(BIT_4);
+        MP_WritePhyUshort(sc, 0x10, PhyRegValue);
+        if (sc->RequiredSecLanDonglePatch) {
+                MP_WritePhyUshort(sc, 0x1F, 0x0A43);
+                PhyRegValue = MP_ReadPhyUshort(sc, 0x11);
+                PhyRegValue &= ~(BIT_6);
+                MP_WritePhyUshort(sc, 0x11, PhyRegValue);
+        }
+}
+
+static void re_set_phy_mcu_8411b_1(struct re_softc *sc)
+{
+        u_int16_t PhyRegValue;
+        u_int32_t WaitCnt;
+
+        MP_WritePhyUshort(sc, 0x1f, 0x0B82);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
+        PhyRegValue |= BIT_4;
+        MP_WritePhyUshort(sc, 0x10, PhyRegValue);
+
+        MP_WritePhyUshort(sc, 0x1f, 0x0B80);
+        WaitCnt = 0;
+        do {
+                PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
+                PhyRegValue &= 0x0040;
+                DELAY(50);
+                DELAY(50);
+                WaitCnt++;
+        } while(PhyRegValue != 0x0040 && WaitCnt <1000);
+
+        MP_WritePhyUshort(sc, 0x1f, 0x0A43);
+        MP_WritePhyUshort(sc, 0x13, 0x8146);
+        MP_WritePhyUshort(sc, 0x14, 0x0100);
+        MP_WritePhyUshort(sc, 0x13, 0xB82E);
+        MP_WritePhyUshort(sc, 0x14, 0x0001);
+
+        MP_WritePhyUshort(sc, 0x1F, 0x0A43);
+        MP_WritePhyUshort(sc, 0x13, 0xb820);
+        MP_WritePhyUshort(sc, 0x14, 0x0290);
+        MP_WritePhyUshort(sc, 0x13, 0xa012);
+        MP_WritePhyUshort(sc, 0x14, 0x0000);
+        MP_WritePhyUshort(sc, 0x13, 0xa014);
+        MP_WritePhyUshort(sc, 0x14, 0x2c04);
+        MP_WritePhyUshort(sc, 0x14, 0x2c07);
+        MP_WritePhyUshort(sc, 0x14, 0x2c07);
+        MP_WritePhyUshort(sc, 0x14, 0x2c07);
+        MP_WritePhyUshort(sc, 0x14, 0xa304);
+        MP_WritePhyUshort(sc, 0x14, 0xa301);
+        MP_WritePhyUshort(sc, 0x14, 0x207e);
+        MP_WritePhyUshort(sc, 0x13, 0xa01a);
+        MP_WritePhyUshort(sc, 0x14, 0x0000);
+        MP_WritePhyUshort(sc, 0x13, 0xa006);
+        MP_WritePhyUshort(sc, 0x14, 0x0fff);
+        MP_WritePhyUshort(sc, 0x13, 0xa004);
+        MP_WritePhyUshort(sc, 0x14, 0x0fff);
+        MP_WritePhyUshort(sc, 0x13, 0xa002);
+        MP_WritePhyUshort(sc, 0x14, 0x0fff);
+        MP_WritePhyUshort(sc, 0x13, 0xa000);
+        MP_WritePhyUshort(sc, 0x14, 0x107c);
+        MP_WritePhyUshort(sc, 0x13, 0xb820);
+        MP_WritePhyUshort(sc, 0x14, 0x0210);
+
+        MP_WritePhyUshort(sc, 0x1F, 0x0A43);
+        MP_WritePhyUshort(sc, 0x13, 0x0000);
+        MP_WritePhyUshort(sc, 0x14, 0x0000);
+        MP_WritePhyUshort(sc, 0x1f, 0x0B82);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
+        PhyRegValue &= ~(BIT_0);
+        MP_WritePhyUshort(sc, 0x17, PhyRegValue);
+        MP_WritePhyUshort(sc, 0x1f, 0x0A43);
+        MP_WritePhyUshort(sc, 0x13, 0x8146);
+        MP_WritePhyUshort(sc, 0x14, 0x0000);
+
+        MP_WritePhyUshort(sc, 0x1f, 0x0B82);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
+        PhyRegValue &= ~(BIT_4);
+        MP_WritePhyUshort(sc, 0x10, PhyRegValue);
+        if (sc->RequiredSecLanDonglePatch) {
+                MP_WritePhyUshort(sc, 0x1F, 0x0A43);
+                PhyRegValue = MP_ReadPhyUshort(sc, 0x11);
+                PhyRegValue &= ~(BIT_6);
+                MP_WritePhyUshort(sc, 0x11, PhyRegValue);
+        }
+}
+
+static void re_set_phy_mcu_8168h_1(struct re_softc *sc)
+{
+        u_int16_t PhyRegValue;
+        u_int32_t WaitCnt;
+
+        MP_WritePhyUshort(sc, 0x1f, 0x0B82);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
+        PhyRegValue |= BIT_4;
+        MP_WritePhyUshort(sc, 0x10, PhyRegValue);
+
+        MP_WritePhyUshort(sc, 0x1f, 0x0B80);
+        WaitCnt = 0;
+        do {
+                PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
+                PhyRegValue &= 0x0040;
+                DELAY(50);
+                DELAY(50);
+                WaitCnt++;
+        } while(PhyRegValue != 0x0040 && WaitCnt <1000);
+
+        MP_WritePhyUshort(sc, 0x1f, 0x0A43);
+        MP_WritePhyUshort(sc, 0x13, 0x8028);
+        MP_WritePhyUshort(sc, 0x14, 0x6200);
+        MP_WritePhyUshort(sc, 0x13, 0xB82E);
+        MP_WritePhyUshort(sc, 0x14, 0x0001);
+
+        MP_WritePhyUshort(sc, 0x1F, 0x0A43);
+        MP_WritePhyUshort(sc, 0x13, 0xB820);
+        MP_WritePhyUshort(sc, 0x14, 0x0290);
+        MP_WritePhyUshort(sc, 0x13, 0xA012);
+        MP_WritePhyUshort(sc, 0x14, 0x0000);
+        MP_WritePhyUshort(sc, 0x13, 0xA014);
+        MP_WritePhyUshort(sc, 0x14, 0x2c04);
+        MP_WritePhyUshort(sc, 0x14, 0x2c10);
+        MP_WritePhyUshort(sc, 0x14, 0x2c10);
+        MP_WritePhyUshort(sc, 0x14, 0x2c10);
+        MP_WritePhyUshort(sc, 0x14, 0xa210);
+        MP_WritePhyUshort(sc, 0x14, 0xa101);
+        MP_WritePhyUshort(sc, 0x14, 0xce10);
+        MP_WritePhyUshort(sc, 0x14, 0xe070);
+        MP_WritePhyUshort(sc, 0x14, 0x0f40);
+        MP_WritePhyUshort(sc, 0x14, 0xaf01);
+        MP_WritePhyUshort(sc, 0x14, 0x8f01);
+        MP_WritePhyUshort(sc, 0x14, 0x183e);
+        MP_WritePhyUshort(sc, 0x14, 0x8e10);
+        MP_WritePhyUshort(sc, 0x14, 0x8101);
+        MP_WritePhyUshort(sc, 0x14, 0x8210);
+        MP_WritePhyUshort(sc, 0x14, 0x28da);
+        MP_WritePhyUshort(sc, 0x13, 0xA01A);
+        MP_WritePhyUshort(sc, 0x14, 0x0000);
+        MP_WritePhyUshort(sc, 0x13, 0xA006);
+        MP_WritePhyUshort(sc, 0x14, 0x0017);
+        MP_WritePhyUshort(sc, 0x13, 0xA004);
+        MP_WritePhyUshort(sc, 0x14, 0x0015);
+        MP_WritePhyUshort(sc, 0x13, 0xA002);
+        MP_WritePhyUshort(sc, 0x14, 0x0013);
+        MP_WritePhyUshort(sc, 0x13, 0xA000);
+        MP_WritePhyUshort(sc, 0x14, 0x18d1);
+        MP_WritePhyUshort(sc, 0x13, 0xB820);
+        MP_WritePhyUshort(sc, 0x14, 0x0210);
+
+        MP_WritePhyUshort(sc, 0x1F, 0x0A43);
+        MP_WritePhyUshort(sc, 0x13, 0x0000);
+        MP_WritePhyUshort(sc, 0x14, 0x0000);
+        MP_WritePhyUshort(sc, 0x1f, 0x0B82);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
+        PhyRegValue &= ~(BIT_0);
+        MP_WritePhyUshort(sc, 0x17, PhyRegValue);
+        MP_WritePhyUshort(sc, 0x1f, 0x0A43);
+        MP_WritePhyUshort(sc, 0x13, 0x8028);
+        MP_WritePhyUshort(sc, 0x14, 0x0000);
+
+        MP_WritePhyUshort(sc, 0x1f, 0x0B82);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
+        PhyRegValue &= ~(BIT_4);
+        MP_WritePhyUshort(sc, 0x10, PhyRegValue);
+        if (sc->RequiredSecLanDonglePatch) {
+                MP_WritePhyUshort(sc, 0x1F, 0x0A43);
+                PhyRegValue = MP_ReadPhyUshort(sc, 0x11);
+                PhyRegValue &= ~(BIT_6);
+                MP_WritePhyUshort(sc, 0x11, PhyRegValue);
+        }
+}
+
+static void re_set_phy_mcu_8168h_2(struct re_softc *sc)
+{
+        u_int16_t PhyRegValue;
+        u_int32_t WaitCnt;
+
+        MP_WritePhyUshort(sc, 0x1f, 0x0B82);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
+        PhyRegValue |= BIT_4;
+        MP_WritePhyUshort(sc, 0x10, PhyRegValue);
+
+        MP_WritePhyUshort(sc, 0x1f, 0x0B80);
+        WaitCnt = 0;
+        do {
+                PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
+                PhyRegValue &= 0x0040;
+                DELAY(50);
+                DELAY(50);
+                WaitCnt++;
+        } while(PhyRegValue != 0x0040 && WaitCnt <1000);
+
+        MP_WritePhyUshort(sc, 0x1f, 0x0A43);
+        MP_WritePhyUshort(sc, 0x13, 0x8028);
+        MP_WritePhyUshort(sc, 0x14, 0x6201);
+        MP_WritePhyUshort(sc, 0x13, 0xB82E);
+        MP_WritePhyUshort(sc, 0x14, 0x0001);
+
+        MP_WritePhyUshort(sc, 0x1F, 0x0A43);
+        MP_WritePhyUshort(sc, 0x13, 0xB820);
+        MP_WritePhyUshort(sc, 0x14, 0x0290);
+        MP_WritePhyUshort(sc, 0x13, 0xA012);
+        MP_WritePhyUshort(sc, 0x14, 0x0000);
+        MP_WritePhyUshort(sc, 0x13, 0xA014);
+        MP_WritePhyUshort(sc, 0x14, 0x2c04);
+        MP_WritePhyUshort(sc, 0x14, 0x2c09);
+        MP_WritePhyUshort(sc, 0x14, 0x2c09);
+        MP_WritePhyUshort(sc, 0x14, 0x2c09);
+        MP_WritePhyUshort(sc, 0x14, 0xad01);
+        MP_WritePhyUshort(sc, 0x14, 0xad01);
+        MP_WritePhyUshort(sc, 0x14, 0xad01);
+        MP_WritePhyUshort(sc, 0x14, 0xad01);
+        MP_WritePhyUshort(sc, 0x14, 0x236c);
+        MP_WritePhyUshort(sc, 0x13, 0xA01A);
+        MP_WritePhyUshort(sc, 0x14, 0x0000);
+        MP_WritePhyUshort(sc, 0x13, 0xA006);
+        MP_WritePhyUshort(sc, 0x14, 0x0fff);
+        MP_WritePhyUshort(sc, 0x13, 0xA004);
+        MP_WritePhyUshort(sc, 0x14, 0x0fff);
+        MP_WritePhyUshort(sc, 0x13, 0xA002);
+        MP_WritePhyUshort(sc, 0x14, 0x0fff);
+        MP_WritePhyUshort(sc, 0x13, 0xA000);
+        MP_WritePhyUshort(sc, 0x14, 0x136b);
+        MP_WritePhyUshort(sc, 0x13, 0xB820);
+        MP_WritePhyUshort(sc, 0x14, 0x0210);
+
+        MP_WritePhyUshort(sc, 0x1F, 0x0A43);
+        MP_WritePhyUshort(sc, 0x13, 0x0000);
+        MP_WritePhyUshort(sc, 0x14, 0x0000);
+        MP_WritePhyUshort(sc, 0x1f, 0x0B82);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
+        PhyRegValue &= ~(BIT_0);
+        MP_WritePhyUshort(sc, 0x17, PhyRegValue);
+        MP_WritePhyUshort(sc, 0x1f, 0x0A43);
+        MP_WritePhyUshort(sc, 0x13, 0x8028);
+        MP_WritePhyUshort(sc, 0x14, 0x0000);
+
+        MP_WritePhyUshort(sc, 0x1f, 0x0B82);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
+        PhyRegValue &= ~(BIT_4);
+        MP_WritePhyUshort(sc, 0x10, PhyRegValue);
+        if (sc->RequiredSecLanDonglePatch) {
+                MP_WritePhyUshort(sc, 0x1F, 0x0A43);
+                PhyRegValue = MP_ReadPhyUshort(sc, 0x11);
+                PhyRegValue &= ~(BIT_6);
+                MP_WritePhyUshort(sc, 0x11, PhyRegValue);
+        }
+}
+
+static void re_set_phy_mcu_8168ep_1(struct re_softc *sc)
+{
+        u_int16_t PhyRegValue;
+        u_int32_t WaitCnt;
+
+        MP_WritePhyUshort(sc, 0x1f, 0x0B82);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
+        PhyRegValue |= BIT_4;
+        MP_WritePhyUshort(sc, 0x10, PhyRegValue);
+
+        MP_WritePhyUshort(sc, 0x1f, 0x0B80);
+        WaitCnt = 0;
+        do {
+                PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
+                PhyRegValue &= 0x0040;
+                DELAY(50);
+                DELAY(50);
+                WaitCnt++;
+        } while(PhyRegValue != 0x0040 && WaitCnt <1000);
+
+        MP_WritePhyUshort(sc, 0x1f, 0x0A43);
+        MP_WritePhyUshort(sc, 0x13, 0x8146);
+        MP_WritePhyUshort(sc, 0x14, 0x2700);
+        MP_WritePhyUshort(sc, 0x13, 0xB82E);
+        MP_WritePhyUshort(sc, 0x14, 0x0001);
+
+        MP_WritePhyUshort(sc, 0x1F, 0x0A43);
+        MP_WritePhyUshort(sc, 0x13, 0xb820);
+        MP_WritePhyUshort(sc, 0x14, 0x0090);
+        MP_WritePhyUshort(sc, 0x13, 0xa012);
+        MP_WritePhyUshort(sc, 0x14, 0x0000);
+        MP_WritePhyUshort(sc, 0x13, 0xa014);
+        MP_WritePhyUshort(sc, 0x14, 0x2c04);
+        MP_WritePhyUshort(sc, 0x14, 0x2c1b);
+        MP_WritePhyUshort(sc, 0x14, 0x2c65);
+        MP_WritePhyUshort(sc, 0x14, 0x2d14);
+        MP_WritePhyUshort(sc, 0x14, 0xd71e);
+        MP_WritePhyUshort(sc, 0x14, 0x4092);
+        MP_WritePhyUshort(sc, 0x14, 0xba04);
+        MP_WritePhyUshort(sc, 0x14, 0x3084);
+        MP_WritePhyUshort(sc, 0x14, 0x1d04);
+        MP_WritePhyUshort(sc, 0x14, 0x1cdd);
+        MP_WritePhyUshort(sc, 0x14, 0x1ce8);
+        MP_WritePhyUshort(sc, 0x14, 0xaeff);
+        MP_WritePhyUshort(sc, 0x14, 0xaf02);
+        MP_WritePhyUshort(sc, 0x14, 0x8f02);
+        MP_WritePhyUshort(sc, 0x14, 0x8eff);
+        MP_WritePhyUshort(sc, 0x14, 0xce01);
+        MP_WritePhyUshort(sc, 0x14, 0xe070);
+        MP_WritePhyUshort(sc, 0x14, 0x0f00);
+        MP_WritePhyUshort(sc, 0x14, 0xaf01);
+        MP_WritePhyUshort(sc, 0x14, 0x8f01);
+        MP_WritePhyUshort(sc, 0x14, 0xd712);
+        MP_WritePhyUshort(sc, 0x14, 0x5fe8);
+        MP_WritePhyUshort(sc, 0x14, 0xaf02);
+        MP_WritePhyUshort(sc, 0x14, 0x8f02);
+        MP_WritePhyUshort(sc, 0x14, 0x8e01);
+        MP_WritePhyUshort(sc, 0x14, 0x1cf2);
+        MP_WritePhyUshort(sc, 0x14, 0x2825);
+        MP_WritePhyUshort(sc, 0x14, 0xd05a);
+        MP_WritePhyUshort(sc, 0x14, 0xd19a);
+        MP_WritePhyUshort(sc, 0x14, 0xd709);
+        MP_WritePhyUshort(sc, 0x14, 0x608f);
+        MP_WritePhyUshort(sc, 0x14, 0xd06b);
+        MP_WritePhyUshort(sc, 0x14, 0xd18a);
+        MP_WritePhyUshort(sc, 0x14, 0x2c25);
+        MP_WritePhyUshort(sc, 0x14, 0xd0be);
+        MP_WritePhyUshort(sc, 0x14, 0xd188);
+        MP_WritePhyUshort(sc, 0x14, 0x2c25);
+        MP_WritePhyUshort(sc, 0x14, 0xd708);
+        MP_WritePhyUshort(sc, 0x14, 0x4072);
+        MP_WritePhyUshort(sc, 0x14, 0xc104);
+        MP_WritePhyUshort(sc, 0x14, 0x2c37);
+        MP_WritePhyUshort(sc, 0x14, 0x4076);
+        MP_WritePhyUshort(sc, 0x14, 0xc110);
+        MP_WritePhyUshort(sc, 0x14, 0x2c37);
+        MP_WritePhyUshort(sc, 0x14, 0x4071);
+        MP_WritePhyUshort(sc, 0x14, 0xc102);
+        MP_WritePhyUshort(sc, 0x14, 0x2c37);
+        MP_WritePhyUshort(sc, 0x14, 0x4070);
+        MP_WritePhyUshort(sc, 0x14, 0xc101);
+        MP_WritePhyUshort(sc, 0x14, 0x2c37);
+        MP_WritePhyUshort(sc, 0x14, 0x1786);
+        MP_WritePhyUshort(sc, 0x14, 0xd709);
+        MP_WritePhyUshort(sc, 0x14, 0x3390);
+        MP_WritePhyUshort(sc, 0x14, 0x5c32);
+        MP_WritePhyUshort(sc, 0x14, 0x2c47);
+        MP_WritePhyUshort(sc, 0x14, 0x1786);
+        MP_WritePhyUshort(sc, 0x14, 0xd708);
+        MP_WritePhyUshort(sc, 0x14, 0x6193);
+        MP_WritePhyUshort(sc, 0x14, 0xd709);
+        MP_WritePhyUshort(sc, 0x14, 0x5f9d);
+        MP_WritePhyUshort(sc, 0x14, 0x408b);
+        MP_WritePhyUshort(sc, 0x14, 0xd71e);
+        MP_WritePhyUshort(sc, 0x14, 0x6042);
+        MP_WritePhyUshort(sc, 0x14, 0xb401);
+        MP_WritePhyUshort(sc, 0x14, 0x1786);
+        MP_WritePhyUshort(sc, 0x14, 0xd708);
+        MP_WritePhyUshort(sc, 0x14, 0x6073);
+        MP_WritePhyUshort(sc, 0x14, 0x5fbc);
+        MP_WritePhyUshort(sc, 0x14, 0x2c46);
+        MP_WritePhyUshort(sc, 0x14, 0x26fe);
+        MP_WritePhyUshort(sc, 0x14, 0xb280);
+        MP_WritePhyUshort(sc, 0x14, 0xa841);
+        MP_WritePhyUshort(sc, 0x14, 0x94e0);
+        MP_WritePhyUshort(sc, 0x14, 0x8710);
+        MP_WritePhyUshort(sc, 0x14, 0xd709);
+        MP_WritePhyUshort(sc, 0x14, 0x42ec);
+        MP_WritePhyUshort(sc, 0x14, 0x606d);
+        MP_WritePhyUshort(sc, 0x14, 0xd207);
+        MP_WritePhyUshort(sc, 0x14, 0x2c50);
+        MP_WritePhyUshort(sc, 0x14, 0xd203);
+        MP_WritePhyUshort(sc, 0x14, 0x33ff);
+        MP_WritePhyUshort(sc, 0x14, 0x5647);
+        MP_WritePhyUshort(sc, 0x14, 0x3275);
+        MP_WritePhyUshort(sc, 0x14, 0x7c57);
+        MP_WritePhyUshort(sc, 0x14, 0xb240);
+        MP_WritePhyUshort(sc, 0x14, 0xb402);
+        MP_WritePhyUshort(sc, 0x14, 0x2647);
+        MP_WritePhyUshort(sc, 0x14, 0x6096);
+        MP_WritePhyUshort(sc, 0x14, 0xb240);
+        MP_WritePhyUshort(sc, 0x14, 0xb406);
+        MP_WritePhyUshort(sc, 0x14, 0x2647);
+        MP_WritePhyUshort(sc, 0x14, 0x31d7);
+        MP_WritePhyUshort(sc, 0x14, 0x7c60);
+        MP_WritePhyUshort(sc, 0x14, 0xb240);
+        MP_WritePhyUshort(sc, 0x14, 0xb40e);
+        MP_WritePhyUshort(sc, 0x14, 0x2647);
+        MP_WritePhyUshort(sc, 0x14, 0xb410);
+        MP_WritePhyUshort(sc, 0x14, 0x8802);
+        MP_WritePhyUshort(sc, 0x14, 0xb240);
+        MP_WritePhyUshort(sc, 0x14, 0x940e);
+        MP_WritePhyUshort(sc, 0x14, 0x2647);
+        MP_WritePhyUshort(sc, 0x14, 0xba04);
+        MP_WritePhyUshort(sc, 0x14, 0x1cdd);
+        MP_WritePhyUshort(sc, 0x14, 0xa902);
+        MP_WritePhyUshort(sc, 0x14, 0xd711);
+        MP_WritePhyUshort(sc, 0x14, 0x4045);
+        MP_WritePhyUshort(sc, 0x14, 0xa980);
+        MP_WritePhyUshort(sc, 0x14, 0x3003);
+        MP_WritePhyUshort(sc, 0x14, 0x5a19);
+        MP_WritePhyUshort(sc, 0x14, 0xa540);
+        MP_WritePhyUshort(sc, 0x14, 0xa601);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x4043);
+        MP_WritePhyUshort(sc, 0x14, 0xa910);
+        MP_WritePhyUshort(sc, 0x14, 0xd711);
+        MP_WritePhyUshort(sc, 0x14, 0x60a0);
+        MP_WritePhyUshort(sc, 0x14, 0xca33);
+        MP_WritePhyUshort(sc, 0x14, 0xcb33);
+        MP_WritePhyUshort(sc, 0x14, 0xa941);
+        MP_WritePhyUshort(sc, 0x14, 0x2c7b);
+        MP_WritePhyUshort(sc, 0x14, 0xcaff);
+        MP_WritePhyUshort(sc, 0x14, 0xcbff);
+        MP_WritePhyUshort(sc, 0x14, 0xa921);
+        MP_WritePhyUshort(sc, 0x14, 0xce02);
+        MP_WritePhyUshort(sc, 0x14, 0xe070);
+        MP_WritePhyUshort(sc, 0x14, 0x0f10);
+        MP_WritePhyUshort(sc, 0x14, 0xaf01);
+        MP_WritePhyUshort(sc, 0x14, 0x8f01);
+        MP_WritePhyUshort(sc, 0x14, 0x1791);
+        MP_WritePhyUshort(sc, 0x14, 0x8e02);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x41a3);
+        MP_WritePhyUshort(sc, 0x14, 0xa140);
+        MP_WritePhyUshort(sc, 0x14, 0xa220);
+        MP_WritePhyUshort(sc, 0x14, 0xce10);
+        MP_WritePhyUshort(sc, 0x14, 0xe070);
+        MP_WritePhyUshort(sc, 0x14, 0x0f40);
+        MP_WritePhyUshort(sc, 0x14, 0xaf01);
+        MP_WritePhyUshort(sc, 0x14, 0x8f01);
+        MP_WritePhyUshort(sc, 0x14, 0x1791);
+        MP_WritePhyUshort(sc, 0x14, 0x8e10);
+        MP_WritePhyUshort(sc, 0x14, 0x8140);
+        MP_WritePhyUshort(sc, 0x14, 0x8220);
+        MP_WritePhyUshort(sc, 0x14, 0xa301);
+        MP_WritePhyUshort(sc, 0x14, 0x17b2);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x609c);
+        MP_WritePhyUshort(sc, 0x14, 0xd71e);
+        MP_WritePhyUshort(sc, 0x14, 0x7fa4);
+        MP_WritePhyUshort(sc, 0x14, 0x2cdb);
+        MP_WritePhyUshort(sc, 0x14, 0x1cf0);
+        MP_WritePhyUshort(sc, 0x14, 0xce04);
+        MP_WritePhyUshort(sc, 0x14, 0xe070);
+        MP_WritePhyUshort(sc, 0x14, 0x0f20);
+        MP_WritePhyUshort(sc, 0x14, 0xaf01);
+        MP_WritePhyUshort(sc, 0x14, 0x8f01);
+        MP_WritePhyUshort(sc, 0x14, 0x1791);
+        MP_WritePhyUshort(sc, 0x14, 0x8e04);
+        MP_WritePhyUshort(sc, 0x14, 0x6044);
+        MP_WritePhyUshort(sc, 0x14, 0x2cdb);
+        MP_WritePhyUshort(sc, 0x14, 0xa520);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x4043);
+        MP_WritePhyUshort(sc, 0x14, 0x2cc8);
+        MP_WritePhyUshort(sc, 0x14, 0xe00f);
+        MP_WritePhyUshort(sc, 0x14, 0x0501);
+        MP_WritePhyUshort(sc, 0x14, 0x1cf6);
+        MP_WritePhyUshort(sc, 0x14, 0xb801);
+        MP_WritePhyUshort(sc, 0x14, 0xd71e);
+        MP_WritePhyUshort(sc, 0x14, 0x4060);
+        MP_WritePhyUshort(sc, 0x14, 0x7fc4);
+        MP_WritePhyUshort(sc, 0x14, 0x2cdb);
+        MP_WritePhyUshort(sc, 0x14, 0x1cfc);
+        MP_WritePhyUshort(sc, 0x14, 0xe00f);
+        MP_WritePhyUshort(sc, 0x14, 0x0502);
+        MP_WritePhyUshort(sc, 0x14, 0x1cf6);
+        MP_WritePhyUshort(sc, 0x14, 0xb802);
+        MP_WritePhyUshort(sc, 0x14, 0xd71e);
+        MP_WritePhyUshort(sc, 0x14, 0x4061);
+        MP_WritePhyUshort(sc, 0x14, 0x7fc4);
+        MP_WritePhyUshort(sc, 0x14, 0x2cdb);
+        MP_WritePhyUshort(sc, 0x14, 0x1cfc);
+        MP_WritePhyUshort(sc, 0x14, 0xe00f);
+        MP_WritePhyUshort(sc, 0x14, 0x0504);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x6099);
+        MP_WritePhyUshort(sc, 0x14, 0xd71e);
+        MP_WritePhyUshort(sc, 0x14, 0x7fa4);
+        MP_WritePhyUshort(sc, 0x14, 0x2cdb);
+        MP_WritePhyUshort(sc, 0x14, 0xc17f);
+        MP_WritePhyUshort(sc, 0x14, 0xc200);
+        MP_WritePhyUshort(sc, 0x14, 0xc43f);
+        MP_WritePhyUshort(sc, 0x14, 0xcc03);
+        MP_WritePhyUshort(sc, 0x14, 0xa701);
+        MP_WritePhyUshort(sc, 0x14, 0xa510);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x4018);
+        MP_WritePhyUshort(sc, 0x14, 0x9910);
+        MP_WritePhyUshort(sc, 0x14, 0x8510);
+        MP_WritePhyUshort(sc, 0x14, 0x28a1);
+        MP_WritePhyUshort(sc, 0x14, 0xe00f);
+        MP_WritePhyUshort(sc, 0x14, 0x0504);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x6099);
+        MP_WritePhyUshort(sc, 0x14, 0xd71e);
+        MP_WritePhyUshort(sc, 0x14, 0x7fa4);
+        MP_WritePhyUshort(sc, 0x14, 0x2cdb);
+        MP_WritePhyUshort(sc, 0x14, 0xa608);
+        MP_WritePhyUshort(sc, 0x14, 0xc17d);
+        MP_WritePhyUshort(sc, 0x14, 0xc200);
+        MP_WritePhyUshort(sc, 0x14, 0xc43f);
+        MP_WritePhyUshort(sc, 0x14, 0xcc03);
+        MP_WritePhyUshort(sc, 0x14, 0xa701);
+        MP_WritePhyUshort(sc, 0x14, 0xa510);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x4018);
+        MP_WritePhyUshort(sc, 0x14, 0x9910);
+        MP_WritePhyUshort(sc, 0x14, 0x8510);
+        MP_WritePhyUshort(sc, 0x14, 0x298e);
+        MP_WritePhyUshort(sc, 0x14, 0x17bd);
+        MP_WritePhyUshort(sc, 0x14, 0x2815);
+        MP_WritePhyUshort(sc, 0x14, 0xc000);
+        MP_WritePhyUshort(sc, 0x14, 0xc100);
+        MP_WritePhyUshort(sc, 0x14, 0xc200);
+        MP_WritePhyUshort(sc, 0x14, 0xc300);
+        MP_WritePhyUshort(sc, 0x14, 0xc400);
+        MP_WritePhyUshort(sc, 0x14, 0xc500);
+        MP_WritePhyUshort(sc, 0x14, 0xc600);
+        MP_WritePhyUshort(sc, 0x14, 0xc7c1);
+        MP_WritePhyUshort(sc, 0x14, 0xc800);
+        MP_WritePhyUshort(sc, 0x14, 0xcc00);
+        MP_WritePhyUshort(sc, 0x14, 0x0800);
+        MP_WritePhyUshort(sc, 0x14, 0xca0f);
+        MP_WritePhyUshort(sc, 0x14, 0xcbff);
+        MP_WritePhyUshort(sc, 0x14, 0xa901);
+        MP_WritePhyUshort(sc, 0x14, 0x8902);
+        MP_WritePhyUshort(sc, 0x14, 0xc900);
+        MP_WritePhyUshort(sc, 0x14, 0xca00);
+        MP_WritePhyUshort(sc, 0x14, 0xcb00);
+        MP_WritePhyUshort(sc, 0x14, 0x0800);
+        MP_WritePhyUshort(sc, 0x14, 0xb804);
+        MP_WritePhyUshort(sc, 0x14, 0x0800);
+        MP_WritePhyUshort(sc, 0x14, 0xd71e);
+        MP_WritePhyUshort(sc, 0x14, 0x6044);
+        MP_WritePhyUshort(sc, 0x14, 0x9804);
+        MP_WritePhyUshort(sc, 0x14, 0x0800);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x6099);
+        MP_WritePhyUshort(sc, 0x14, 0xd71e);
+        MP_WritePhyUshort(sc, 0x14, 0x7fa4);
+        MP_WritePhyUshort(sc, 0x14, 0x2cdb);
+        MP_WritePhyUshort(sc, 0x14, 0x0800);
+        MP_WritePhyUshort(sc, 0x14, 0xa510);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x6098);
+        MP_WritePhyUshort(sc, 0x14, 0xd71e);
+        MP_WritePhyUshort(sc, 0x14, 0x7fa4);
+        MP_WritePhyUshort(sc, 0x14, 0x2cdb);
+        MP_WritePhyUshort(sc, 0x14, 0x8510);
+        MP_WritePhyUshort(sc, 0x14, 0x0800);
+        MP_WritePhyUshort(sc, 0x14, 0xd711);
+        MP_WritePhyUshort(sc, 0x14, 0x3003);
+        MP_WritePhyUshort(sc, 0x14, 0x1d08);
+        MP_WritePhyUshort(sc, 0x14, 0x2d12);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x60be);
+        MP_WritePhyUshort(sc, 0x14, 0xe060);
+        MP_WritePhyUshort(sc, 0x14, 0x0920);
+        MP_WritePhyUshort(sc, 0x14, 0x1cdd);
+        MP_WritePhyUshort(sc, 0x14, 0x2c90);
+        MP_WritePhyUshort(sc, 0x14, 0xd71e);
+        MP_WritePhyUshort(sc, 0x14, 0x3063);
+        MP_WritePhyUshort(sc, 0x14, 0x19b0);
+        MP_WritePhyUshort(sc, 0x14, 0x28d5);
+        MP_WritePhyUshort(sc, 0x14, 0x1cdd);
+        MP_WritePhyUshort(sc, 0x14, 0x2a25);
+        MP_WritePhyUshort(sc, 0x14, 0xa802);
+        MP_WritePhyUshort(sc, 0x14, 0xa303);
+        MP_WritePhyUshort(sc, 0x14, 0x843f);
+        MP_WritePhyUshort(sc, 0x14, 0x81ff);
+        MP_WritePhyUshort(sc, 0x14, 0x8208);
+        MP_WritePhyUshort(sc, 0x14, 0xa201);
+        MP_WritePhyUshort(sc, 0x14, 0xc001);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x30a0);
+        MP_WritePhyUshort(sc, 0x14, 0x0d23);
+        MP_WritePhyUshort(sc, 0x14, 0x30a0);
+        MP_WritePhyUshort(sc, 0x14, 0x3d1a);
+        MP_WritePhyUshort(sc, 0x14, 0xd71e);
+        MP_WritePhyUshort(sc, 0x14, 0x7f4c);
+        MP_WritePhyUshort(sc, 0x14, 0x2b1e);
+        MP_WritePhyUshort(sc, 0x14, 0xe003);
+        MP_WritePhyUshort(sc, 0x14, 0x0202);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x6090);
+        MP_WritePhyUshort(sc, 0x14, 0xd71e);
+        MP_WritePhyUshort(sc, 0x14, 0x7fac);
+        MP_WritePhyUshort(sc, 0x14, 0x2b1e);
+        MP_WritePhyUshort(sc, 0x14, 0xa20c);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x6091);
+        MP_WritePhyUshort(sc, 0x14, 0xd71e);
+        MP_WritePhyUshort(sc, 0x14, 0x7fac);
+        MP_WritePhyUshort(sc, 0x14, 0x2b1e);
+        MP_WritePhyUshort(sc, 0x14, 0x820e);
+        MP_WritePhyUshort(sc, 0x14, 0xa3e0);
+        MP_WritePhyUshort(sc, 0x14, 0xa520);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x609d);
+        MP_WritePhyUshort(sc, 0x14, 0xd71e);
+        MP_WritePhyUshort(sc, 0x14, 0x7fac);
+        MP_WritePhyUshort(sc, 0x14, 0x2b1e);
+        MP_WritePhyUshort(sc, 0x14, 0x8520);
+        MP_WritePhyUshort(sc, 0x14, 0x6703);
+        MP_WritePhyUshort(sc, 0x14, 0x2d3b);
+        MP_WritePhyUshort(sc, 0x14, 0xa13e);
+        MP_WritePhyUshort(sc, 0x14, 0xc001);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x4000);
+        MP_WritePhyUshort(sc, 0x14, 0x6046);
+        MP_WritePhyUshort(sc, 0x14, 0x2d14);
+        MP_WritePhyUshort(sc, 0x14, 0xa43f);
+        MP_WritePhyUshort(sc, 0x14, 0xa101);
+        MP_WritePhyUshort(sc, 0x14, 0xc020);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x3121);
+        MP_WritePhyUshort(sc, 0x14, 0x0d4c);
+        MP_WritePhyUshort(sc, 0x14, 0x30c0);
+        MP_WritePhyUshort(sc, 0x14, 0x3d14);
+        MP_WritePhyUshort(sc, 0x14, 0xd71e);
+        MP_WritePhyUshort(sc, 0x14, 0x7f4c);
+        MP_WritePhyUshort(sc, 0x14, 0x2b1e);
+        MP_WritePhyUshort(sc, 0x14, 0xa540);
+        MP_WritePhyUshort(sc, 0x14, 0xc001);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x4001);
+        MP_WritePhyUshort(sc, 0x14, 0xe00f);
+        MP_WritePhyUshort(sc, 0x14, 0x0501);
+        MP_WritePhyUshort(sc, 0x14, 0x1db3);
+        MP_WritePhyUshort(sc, 0x14, 0xc1c4);
+        MP_WritePhyUshort(sc, 0x14, 0xa268);
+        MP_WritePhyUshort(sc, 0x14, 0xa303);
+        MP_WritePhyUshort(sc, 0x14, 0x8420);
+        MP_WritePhyUshort(sc, 0x14, 0xe00f);
+        MP_WritePhyUshort(sc, 0x14, 0x0502);
+        MP_WritePhyUshort(sc, 0x14, 0x1db3);
+        MP_WritePhyUshort(sc, 0x14, 0xc002);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x4000);
+        MP_WritePhyUshort(sc, 0x14, 0x8208);
+        MP_WritePhyUshort(sc, 0x14, 0x8410);
+        MP_WritePhyUshort(sc, 0x14, 0xa121);
+        MP_WritePhyUshort(sc, 0x14, 0xc002);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x4000);
+        MP_WritePhyUshort(sc, 0x14, 0x8120);
+        MP_WritePhyUshort(sc, 0x14, 0x8180);
+        MP_WritePhyUshort(sc, 0x14, 0x1d9e);
+        MP_WritePhyUshort(sc, 0x14, 0xa180);
+        MP_WritePhyUshort(sc, 0x14, 0xa13a);
+        MP_WritePhyUshort(sc, 0x14, 0x8240);
+        MP_WritePhyUshort(sc, 0x14, 0xa430);
+        MP_WritePhyUshort(sc, 0x14, 0xc010);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x30e1);
+        MP_WritePhyUshort(sc, 0x14, 0x0b24);
+        MP_WritePhyUshort(sc, 0x14, 0xd71e);
+        MP_WritePhyUshort(sc, 0x14, 0x7f8c);
+        MP_WritePhyUshort(sc, 0x14, 0x2b1e);
+        MP_WritePhyUshort(sc, 0x14, 0xa480);
+        MP_WritePhyUshort(sc, 0x14, 0xa230);
+        MP_WritePhyUshort(sc, 0x14, 0xa303);
+        MP_WritePhyUshort(sc, 0x14, 0xc001);
+        MP_WritePhyUshort(sc, 0x14, 0xd70c);
+        MP_WritePhyUshort(sc, 0x14, 0x4124);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x6120);
+        MP_WritePhyUshort(sc, 0x14, 0xd711);
+        MP_WritePhyUshort(sc, 0x14, 0x3128);
+        MP_WritePhyUshort(sc, 0x14, 0x3d7d);
+        MP_WritePhyUshort(sc, 0x14, 0x2d77);
+        MP_WritePhyUshort(sc, 0x14, 0xa801);
+        MP_WritePhyUshort(sc, 0x14, 0x2d73);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x4000);
+        MP_WritePhyUshort(sc, 0x14, 0xe018);
+        MP_WritePhyUshort(sc, 0x14, 0x0208);
+        MP_WritePhyUshort(sc, 0x14, 0xa1f8);
+        MP_WritePhyUshort(sc, 0x14, 0x8480);
+        MP_WritePhyUshort(sc, 0x14, 0xc004);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x4000);
+        MP_WritePhyUshort(sc, 0x14, 0x6046);
+        MP_WritePhyUshort(sc, 0x14, 0x2d14);
+        MP_WritePhyUshort(sc, 0x14, 0xa43f);
+        MP_WritePhyUshort(sc, 0x14, 0xa105);
+        MP_WritePhyUshort(sc, 0x14, 0x8228);
+        MP_WritePhyUshort(sc, 0x14, 0xc004);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x4000);
+        MP_WritePhyUshort(sc, 0x14, 0x81bc);
+        MP_WritePhyUshort(sc, 0x14, 0xa220);
+        MP_WritePhyUshort(sc, 0x14, 0x1d9e);
+        MP_WritePhyUshort(sc, 0x14, 0x8220);
+        MP_WritePhyUshort(sc, 0x14, 0xa1bc);
+        MP_WritePhyUshort(sc, 0x14, 0xc040);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x30e1);
+        MP_WritePhyUshort(sc, 0x14, 0x0b24);
+        MP_WritePhyUshort(sc, 0x14, 0x30e1);
+        MP_WritePhyUshort(sc, 0x14, 0x3d14);
+        MP_WritePhyUshort(sc, 0x14, 0xd71e);
+        MP_WritePhyUshort(sc, 0x14, 0x7f4c);
+        MP_WritePhyUshort(sc, 0x14, 0x2b1e);
+        MP_WritePhyUshort(sc, 0x14, 0xa802);
+        MP_WritePhyUshort(sc, 0x14, 0xd70c);
+        MP_WritePhyUshort(sc, 0x14, 0x4244);
+        MP_WritePhyUshort(sc, 0x14, 0xa301);
+        MP_WritePhyUshort(sc, 0x14, 0xc004);
+        MP_WritePhyUshort(sc, 0x14, 0xd711);
+        MP_WritePhyUshort(sc, 0x14, 0x3128);
+        MP_WritePhyUshort(sc, 0x14, 0x3dac);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x5f80);
+        MP_WritePhyUshort(sc, 0x14, 0xd711);
+        MP_WritePhyUshort(sc, 0x14, 0x3109);
+        MP_WritePhyUshort(sc, 0x14, 0x3dae);
+        MP_WritePhyUshort(sc, 0x14, 0x2db2);
+        MP_WritePhyUshort(sc, 0x14, 0xa801);
+        MP_WritePhyUshort(sc, 0x14, 0x2da1);
+        MP_WritePhyUshort(sc, 0x14, 0xa802);
+        MP_WritePhyUshort(sc, 0x14, 0xc004);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x4000);
+        MP_WritePhyUshort(sc, 0x14, 0x0800);
+        MP_WritePhyUshort(sc, 0x14, 0xa510);
+        MP_WritePhyUshort(sc, 0x14, 0xd710);
+        MP_WritePhyUshort(sc, 0x14, 0x609a);
+        MP_WritePhyUshort(sc, 0x14, 0xd71e);
+        MP_WritePhyUshort(sc, 0x14, 0x7fac);
+        MP_WritePhyUshort(sc, 0x14, 0x2b1e);
+        MP_WritePhyUshort(sc, 0x14, 0x8510);
+        MP_WritePhyUshort(sc, 0x14, 0x0800);
+        MP_WritePhyUshort(sc, 0x13, 0xa01a);
+        MP_WritePhyUshort(sc, 0x14, 0x0000);
+        MP_WritePhyUshort(sc, 0x13, 0xa006);
+        MP_WritePhyUshort(sc, 0x14, 0x0b3e);
+        MP_WritePhyUshort(sc, 0x13, 0xa004);
+        MP_WritePhyUshort(sc, 0x14, 0x0828);
+        MP_WritePhyUshort(sc, 0x13, 0xa002);
+        MP_WritePhyUshort(sc, 0x14, 0x06dd);
+        MP_WritePhyUshort(sc, 0x13, 0xa000);
+        MP_WritePhyUshort(sc, 0x14, 0xf815);
+        MP_WritePhyUshort(sc, 0x13, 0xb820);
+        MP_WritePhyUshort(sc, 0x14, 0x0010);
+
+        MP_WritePhyUshort(sc, 0x1F, 0x0A43);
+        MP_WritePhyUshort(sc, 0x13, 0x83b0);
+        MP_WritePhyUshort(sc, 0x14, 0xaf83);
+        MP_WritePhyUshort(sc, 0x14, 0xbcaf);
+        MP_WritePhyUshort(sc, 0x14, 0x83c8);
+        MP_WritePhyUshort(sc, 0x14, 0xaf83);
+        MP_WritePhyUshort(sc, 0x14, 0xddaf);
+        MP_WritePhyUshort(sc, 0x14, 0x83e0);
+        MP_WritePhyUshort(sc, 0x14, 0x0204);
+        MP_WritePhyUshort(sc, 0x14, 0xa102);
+        MP_WritePhyUshort(sc, 0x14, 0x09b4);
+        MP_WritePhyUshort(sc, 0x14, 0x0284);
+        MP_WritePhyUshort(sc, 0x14, 0x62af);
+        MP_WritePhyUshort(sc, 0x14, 0x02ec);
+        MP_WritePhyUshort(sc, 0x14, 0xad20);
+        MP_WritePhyUshort(sc, 0x14, 0x0302);
+        MP_WritePhyUshort(sc, 0x14, 0x867d);
+        MP_WritePhyUshort(sc, 0x14, 0xad21);
+        MP_WritePhyUshort(sc, 0x14, 0x0302);
+        MP_WritePhyUshort(sc, 0x14, 0x85ca);
+        MP_WritePhyUshort(sc, 0x14, 0xad22);
+        MP_WritePhyUshort(sc, 0x14, 0x0302);
+        MP_WritePhyUshort(sc, 0x14, 0x1bce);
+        MP_WritePhyUshort(sc, 0x14, 0xaf18);
+        MP_WritePhyUshort(sc, 0x14, 0x11af);
+        MP_WritePhyUshort(sc, 0x14, 0x1811);
+        MP_WritePhyUshort(sc, 0x14, 0x0106);
+        MP_WritePhyUshort(sc, 0x14, 0xe081);
+        MP_WritePhyUshort(sc, 0x14, 0x48af);
+        MP_WritePhyUshort(sc, 0x14, 0x3b1f);
+        MP_WritePhyUshort(sc, 0x14, 0xf8f9);
+        MP_WritePhyUshort(sc, 0x14, 0xfaef);
+        MP_WritePhyUshort(sc, 0x14, 0x69ee);
+        MP_WritePhyUshort(sc, 0x14, 0x8010);
+        MP_WritePhyUshort(sc, 0x14, 0xf7d1);
+        MP_WritePhyUshort(sc, 0x14, 0x04bf);
+        MP_WritePhyUshort(sc, 0x14, 0x8776);
+        MP_WritePhyUshort(sc, 0x14, 0x0241);
+        MP_WritePhyUshort(sc, 0x14, 0x0a02);
+        MP_WritePhyUshort(sc, 0x14, 0x8704);
+        MP_WritePhyUshort(sc, 0x14, 0xbf87);
+        MP_WritePhyUshort(sc, 0x14, 0x4fd7);
+        MP_WritePhyUshort(sc, 0x14, 0xb822);
+        MP_WritePhyUshort(sc, 0x14, 0xd00c);
+        MP_WritePhyUshort(sc, 0x14, 0x0241);
+        MP_WritePhyUshort(sc, 0x14, 0x03ee);
+        MP_WritePhyUshort(sc, 0x14, 0x80cd);
+        MP_WritePhyUshort(sc, 0x14, 0xa0ee);
+        MP_WritePhyUshort(sc, 0x14, 0x80ce);
+        MP_WritePhyUshort(sc, 0x14, 0x8bee);
+        MP_WritePhyUshort(sc, 0x14, 0x80d1);
+        MP_WritePhyUshort(sc, 0x14, 0xf5ee);
+        MP_WritePhyUshort(sc, 0x14, 0x80d2);
+        MP_WritePhyUshort(sc, 0x14, 0xa9ee);
+        MP_WritePhyUshort(sc, 0x14, 0x80d3);
+        MP_WritePhyUshort(sc, 0x14, 0x0aee);
+        MP_WritePhyUshort(sc, 0x14, 0x80f0);
+        MP_WritePhyUshort(sc, 0x14, 0x10ee);
+        MP_WritePhyUshort(sc, 0x14, 0x80f3);
+        MP_WritePhyUshort(sc, 0x14, 0x8fee);
+        MP_WritePhyUshort(sc, 0x14, 0x8101);
+        MP_WritePhyUshort(sc, 0x14, 0x1eee);
+        MP_WritePhyUshort(sc, 0x14, 0x810b);
+        MP_WritePhyUshort(sc, 0x14, 0x4aee);
+        MP_WritePhyUshort(sc, 0x14, 0x810c);
+        MP_WritePhyUshort(sc, 0x14, 0x7cee);
+        MP_WritePhyUshort(sc, 0x14, 0x8112);
+        MP_WritePhyUshort(sc, 0x14, 0x7fd1);
+        MP_WritePhyUshort(sc, 0x14, 0x0002);
+        MP_WritePhyUshort(sc, 0x14, 0x10e3);
+        MP_WritePhyUshort(sc, 0x14, 0xee80);
+        MP_WritePhyUshort(sc, 0x14, 0x8892);
+        MP_WritePhyUshort(sc, 0x14, 0xee80);
+        MP_WritePhyUshort(sc, 0x14, 0x8922);
+        MP_WritePhyUshort(sc, 0x14, 0xee80);
+        MP_WritePhyUshort(sc, 0x14, 0x9a80);
+        MP_WritePhyUshort(sc, 0x14, 0xee80);
+        MP_WritePhyUshort(sc, 0x14, 0x9b22);
+        MP_WritePhyUshort(sc, 0x14, 0xee80);
+        MP_WritePhyUshort(sc, 0x14, 0x9ca7);
+        MP_WritePhyUshort(sc, 0x14, 0xee80);
+        MP_WritePhyUshort(sc, 0x14, 0xa010);
+        MP_WritePhyUshort(sc, 0x14, 0xee80);
+        MP_WritePhyUshort(sc, 0x14, 0xa5a7);
+        MP_WritePhyUshort(sc, 0x14, 0xd200);
+        MP_WritePhyUshort(sc, 0x14, 0x020e);
+        MP_WritePhyUshort(sc, 0x14, 0x4b02);
+        MP_WritePhyUshort(sc, 0x14, 0x85c1);
+        MP_WritePhyUshort(sc, 0x14, 0xef96);
+        MP_WritePhyUshort(sc, 0x14, 0xfefd);
+        MP_WritePhyUshort(sc, 0x14, 0xfc04);
+        MP_WritePhyUshort(sc, 0x14, 0x0284);
+        MP_WritePhyUshort(sc, 0x14, 0x7b02);
+        MP_WritePhyUshort(sc, 0x14, 0x84b4);
+        MP_WritePhyUshort(sc, 0x14, 0x020c);
+        MP_WritePhyUshort(sc, 0x14, 0x9202);
+        MP_WritePhyUshort(sc, 0x14, 0x0cab);
+        MP_WritePhyUshort(sc, 0x14, 0x020c);
+        MP_WritePhyUshort(sc, 0x14, 0xd602);
+        MP_WritePhyUshort(sc, 0x14, 0x0cef);
+        MP_WritePhyUshort(sc, 0x14, 0x020d);
+        MP_WritePhyUshort(sc, 0x14, 0x1a02);
+        MP_WritePhyUshort(sc, 0x14, 0x0c24);
+        MP_WritePhyUshort(sc, 0x14, 0x04f8);
+        MP_WritePhyUshort(sc, 0x14, 0xfaef);
+        MP_WritePhyUshort(sc, 0x14, 0x69e1);
+        MP_WritePhyUshort(sc, 0x14, 0x8234);
+        MP_WritePhyUshort(sc, 0x14, 0xac29);
+        MP_WritePhyUshort(sc, 0x14, 0x1ae0);
+        MP_WritePhyUshort(sc, 0x14, 0x8229);
+        MP_WritePhyUshort(sc, 0x14, 0xac21);
+        MP_WritePhyUshort(sc, 0x14, 0x02ae);
+        MP_WritePhyUshort(sc, 0x14, 0x2202);
+        MP_WritePhyUshort(sc, 0x14, 0x1085);
+        MP_WritePhyUshort(sc, 0x14, 0xf621);
+        MP_WritePhyUshort(sc, 0x14, 0xe482);
+        MP_WritePhyUshort(sc, 0x14, 0x29d1);
+        MP_WritePhyUshort(sc, 0x14, 0x01bf);
+        MP_WritePhyUshort(sc, 0x14, 0x4364);
+        MP_WritePhyUshort(sc, 0x14, 0x0241);
+        MP_WritePhyUshort(sc, 0x14, 0x0aae);
+        MP_WritePhyUshort(sc, 0x14, 0x1002);
+        MP_WritePhyUshort(sc, 0x14, 0x127a);
+        MP_WritePhyUshort(sc, 0x14, 0xf629);
+        MP_WritePhyUshort(sc, 0x14, 0xe582);
+        MP_WritePhyUshort(sc, 0x14, 0x34e0);
+        MP_WritePhyUshort(sc, 0x14, 0x8229);
+        MP_WritePhyUshort(sc, 0x14, 0xf621);
+        MP_WritePhyUshort(sc, 0x14, 0xe482);
+        MP_WritePhyUshort(sc, 0x14, 0x29ef);
+        MP_WritePhyUshort(sc, 0x14, 0x96fe);
+        MP_WritePhyUshort(sc, 0x14, 0xfc04);
+        MP_WritePhyUshort(sc, 0x14, 0xf8e1);
+        MP_WritePhyUshort(sc, 0x14, 0x8234);
+        MP_WritePhyUshort(sc, 0x14, 0xac2a);
+        MP_WritePhyUshort(sc, 0x14, 0x18e0);
+        MP_WritePhyUshort(sc, 0x14, 0x8229);
+        MP_WritePhyUshort(sc, 0x14, 0xac22);
+        MP_WritePhyUshort(sc, 0x14, 0x02ae);
+        MP_WritePhyUshort(sc, 0x14, 0x2602);
+        MP_WritePhyUshort(sc, 0x14, 0x84f9);
+        MP_WritePhyUshort(sc, 0x14, 0x0285);
+        MP_WritePhyUshort(sc, 0x14, 0x66d1);
+        MP_WritePhyUshort(sc, 0x14, 0x01bf);
+        MP_WritePhyUshort(sc, 0x14, 0x4367);
+        MP_WritePhyUshort(sc, 0x14, 0x0241);
+        MP_WritePhyUshort(sc, 0x14, 0x0aae);
+        MP_WritePhyUshort(sc, 0x14, 0x0e02);
+        MP_WritePhyUshort(sc, 0x14, 0x84eb);
+        MP_WritePhyUshort(sc, 0x14, 0x0285);
+        MP_WritePhyUshort(sc, 0x14, 0xaae1);
+        MP_WritePhyUshort(sc, 0x14, 0x8234);
+        MP_WritePhyUshort(sc, 0x14, 0xf62a);
+        MP_WritePhyUshort(sc, 0x14, 0xe582);
+        MP_WritePhyUshort(sc, 0x14, 0x34e0);
+        MP_WritePhyUshort(sc, 0x14, 0x8229);
+        MP_WritePhyUshort(sc, 0x14, 0xf622);
+        MP_WritePhyUshort(sc, 0x14, 0xe482);
+        MP_WritePhyUshort(sc, 0x14, 0x29fc);
+        MP_WritePhyUshort(sc, 0x14, 0x04f9);
+        MP_WritePhyUshort(sc, 0x14, 0xe280);
+        MP_WritePhyUshort(sc, 0x14, 0x11ad);
+        MP_WritePhyUshort(sc, 0x14, 0x3105);
+        MP_WritePhyUshort(sc, 0x14, 0xd200);
+        MP_WritePhyUshort(sc, 0x14, 0x020e);
+        MP_WritePhyUshort(sc, 0x14, 0x4bfd);
+        MP_WritePhyUshort(sc, 0x14, 0x04f8);
+        MP_WritePhyUshort(sc, 0x14, 0xf9fa);
+        MP_WritePhyUshort(sc, 0x14, 0xef69);
+        MP_WritePhyUshort(sc, 0x14, 0xe080);
+        MP_WritePhyUshort(sc, 0x14, 0x11ad);
+        MP_WritePhyUshort(sc, 0x14, 0x215c);
+        MP_WritePhyUshort(sc, 0x14, 0xbf42);
+        MP_WritePhyUshort(sc, 0x14, 0x5002);
+        MP_WritePhyUshort(sc, 0x14, 0x4148);
+        MP_WritePhyUshort(sc, 0x14, 0xac28);
+        MP_WritePhyUshort(sc, 0x14, 0x1bbf);
+        MP_WritePhyUshort(sc, 0x14, 0x4253);
+        MP_WritePhyUshort(sc, 0x14, 0x0241);
+        MP_WritePhyUshort(sc, 0x14, 0x48ac);
+        MP_WritePhyUshort(sc, 0x14, 0x2812);
+        MP_WritePhyUshort(sc, 0x14, 0xbf42);
+        MP_WritePhyUshort(sc, 0x14, 0x5902);
+        MP_WritePhyUshort(sc, 0x14, 0x4148);
+        MP_WritePhyUshort(sc, 0x14, 0xac28);
+        MP_WritePhyUshort(sc, 0x14, 0x04d3);
+        MP_WritePhyUshort(sc, 0x14, 0x00ae);
+        MP_WritePhyUshort(sc, 0x14, 0x07d3);
+        MP_WritePhyUshort(sc, 0x14, 0x06af);
+        MP_WritePhyUshort(sc, 0x14, 0x8557);
+        MP_WritePhyUshort(sc, 0x14, 0xd303);
+        MP_WritePhyUshort(sc, 0x14, 0xe080);
+        MP_WritePhyUshort(sc, 0x14, 0x11ad);
+        MP_WritePhyUshort(sc, 0x14, 0x2625);
+        MP_WritePhyUshort(sc, 0x14, 0xbf43);
+        MP_WritePhyUshort(sc, 0x14, 0xeb02);
+        MP_WritePhyUshort(sc, 0x14, 0x4148);
+        MP_WritePhyUshort(sc, 0x14, 0xe280);
+        MP_WritePhyUshort(sc, 0x14, 0x730d);
+        MP_WritePhyUshort(sc, 0x14, 0x21f6);
+        MP_WritePhyUshort(sc, 0x14, 0x370d);
+        MP_WritePhyUshort(sc, 0x14, 0x11f6);
+        MP_WritePhyUshort(sc, 0x14, 0x2f1b);
+        MP_WritePhyUshort(sc, 0x14, 0x21aa);
+        MP_WritePhyUshort(sc, 0x14, 0x02ae);
+        MP_WritePhyUshort(sc, 0x14, 0x10e2);
+        MP_WritePhyUshort(sc, 0x14, 0x8074);
+        MP_WritePhyUshort(sc, 0x14, 0x0d21);
+        MP_WritePhyUshort(sc, 0x14, 0xf637);
+        MP_WritePhyUshort(sc, 0x14, 0x1b21);
+        MP_WritePhyUshort(sc, 0x14, 0xaa03);
+        MP_WritePhyUshort(sc, 0x14, 0x13ae);
+        MP_WritePhyUshort(sc, 0x14, 0x022b);
+        MP_WritePhyUshort(sc, 0x14, 0x0202);
+        MP_WritePhyUshort(sc, 0x14, 0x0e36);
+        MP_WritePhyUshort(sc, 0x14, 0x020e);
+        MP_WritePhyUshort(sc, 0x14, 0x4b02);
+        MP_WritePhyUshort(sc, 0x14, 0x0f91);
+        MP_WritePhyUshort(sc, 0x14, 0xef96);
+        MP_WritePhyUshort(sc, 0x14, 0xfefd);
+        MP_WritePhyUshort(sc, 0x14, 0xfc04);
+        MP_WritePhyUshort(sc, 0x14, 0xf8f9);
+        MP_WritePhyUshort(sc, 0x14, 0xfaef);
+        MP_WritePhyUshort(sc, 0x14, 0x69e0);
+        MP_WritePhyUshort(sc, 0x14, 0x8012);
+        MP_WritePhyUshort(sc, 0x14, 0xad27);
+        MP_WritePhyUshort(sc, 0x14, 0x33bf);
+        MP_WritePhyUshort(sc, 0x14, 0x4250);
+        MP_WritePhyUshort(sc, 0x14, 0x0241);
+        MP_WritePhyUshort(sc, 0x14, 0x48ac);
+        MP_WritePhyUshort(sc, 0x14, 0x2809);
+        MP_WritePhyUshort(sc, 0x14, 0xbf42);
+        MP_WritePhyUshort(sc, 0x14, 0x5302);
+        MP_WritePhyUshort(sc, 0x14, 0x4148);
+        MP_WritePhyUshort(sc, 0x14, 0xad28);
+        MP_WritePhyUshort(sc, 0x14, 0x21bf);
+        MP_WritePhyUshort(sc, 0x14, 0x43eb);
+        MP_WritePhyUshort(sc, 0x14, 0x0241);
+        MP_WritePhyUshort(sc, 0x14, 0x48e3);
+        MP_WritePhyUshort(sc, 0x14, 0x87ff);
+        MP_WritePhyUshort(sc, 0x14, 0xd200);
+        MP_WritePhyUshort(sc, 0x14, 0x1b45);
+        MP_WritePhyUshort(sc, 0x14, 0xac27);
+        MP_WritePhyUshort(sc, 0x14, 0x11e1);
+        MP_WritePhyUshort(sc, 0x14, 0x87fe);
+        MP_WritePhyUshort(sc, 0x14, 0xbf87);
+        MP_WritePhyUshort(sc, 0x14, 0x6702);
+        MP_WritePhyUshort(sc, 0x14, 0x410a);
+        MP_WritePhyUshort(sc, 0x14, 0x0d11);
+        MP_WritePhyUshort(sc, 0x14, 0xbf87);
+        MP_WritePhyUshort(sc, 0x14, 0x6a02);
+        MP_WritePhyUshort(sc, 0x14, 0x410a);
+        MP_WritePhyUshort(sc, 0x14, 0xef96);
+        MP_WritePhyUshort(sc, 0x14, 0xfefd);
+        MP_WritePhyUshort(sc, 0x14, 0xfc04);
+        MP_WritePhyUshort(sc, 0x14, 0xf8fa);
+        MP_WritePhyUshort(sc, 0x14, 0xef69);
+        MP_WritePhyUshort(sc, 0x14, 0xd100);
+        MP_WritePhyUshort(sc, 0x14, 0xbf87);
+        MP_WritePhyUshort(sc, 0x14, 0x6702);
+        MP_WritePhyUshort(sc, 0x14, 0x410a);
+        MP_WritePhyUshort(sc, 0x14, 0xbf87);
+        MP_WritePhyUshort(sc, 0x14, 0x6a02);
+        MP_WritePhyUshort(sc, 0x14, 0x410a);
+        MP_WritePhyUshort(sc, 0x14, 0xef96);
+        MP_WritePhyUshort(sc, 0x14, 0xfefc);
+        MP_WritePhyUshort(sc, 0x14, 0x04ee);
+        MP_WritePhyUshort(sc, 0x14, 0x87ff);
+        MP_WritePhyUshort(sc, 0x14, 0x46ee);
+        MP_WritePhyUshort(sc, 0x14, 0x87fe);
+        MP_WritePhyUshort(sc, 0x14, 0x0104);
+        MP_WritePhyUshort(sc, 0x14, 0xf8fa);
+        MP_WritePhyUshort(sc, 0x14, 0xef69);
+        MP_WritePhyUshort(sc, 0x14, 0xe082);
+        MP_WritePhyUshort(sc, 0x14, 0x46a0);
+        MP_WritePhyUshort(sc, 0x14, 0x0005);
+        MP_WritePhyUshort(sc, 0x14, 0x0285);
+        MP_WritePhyUshort(sc, 0x14, 0xecae);
+        MP_WritePhyUshort(sc, 0x14, 0x0ea0);
+        MP_WritePhyUshort(sc, 0x14, 0x0105);
+        MP_WritePhyUshort(sc, 0x14, 0x021a);
+        MP_WritePhyUshort(sc, 0x14, 0x68ae);
+        MP_WritePhyUshort(sc, 0x14, 0x06a0);
+        MP_WritePhyUshort(sc, 0x14, 0x0203);
+        MP_WritePhyUshort(sc, 0x14, 0x021a);
+        MP_WritePhyUshort(sc, 0x14, 0xf4ef);
+        MP_WritePhyUshort(sc, 0x14, 0x96fe);
+        MP_WritePhyUshort(sc, 0x14, 0xfc04);
+        MP_WritePhyUshort(sc, 0x14, 0xf8f9);
+        MP_WritePhyUshort(sc, 0x14, 0xfaef);
+        MP_WritePhyUshort(sc, 0x14, 0x69e0);
+        MP_WritePhyUshort(sc, 0x14, 0x822e);
+        MP_WritePhyUshort(sc, 0x14, 0xf621);
+        MP_WritePhyUshort(sc, 0x14, 0xe482);
+        MP_WritePhyUshort(sc, 0x14, 0x2ee0);
+        MP_WritePhyUshort(sc, 0x14, 0x8010);
+        MP_WritePhyUshort(sc, 0x14, 0xac22);
+        MP_WritePhyUshort(sc, 0x14, 0x02ae);
+        MP_WritePhyUshort(sc, 0x14, 0x76e0);
+        MP_WritePhyUshort(sc, 0x14, 0x822c);
+        MP_WritePhyUshort(sc, 0x14, 0xf721);
+        MP_WritePhyUshort(sc, 0x14, 0xe482);
+        MP_WritePhyUshort(sc, 0x14, 0x2cbf);
+        MP_WritePhyUshort(sc, 0x14, 0x41a5);
+        MP_WritePhyUshort(sc, 0x14, 0x0241);
+        MP_WritePhyUshort(sc, 0x14, 0x48ef);
+        MP_WritePhyUshort(sc, 0x14, 0x21bf);
+        MP_WritePhyUshort(sc, 0x14, 0x41a8);
+        MP_WritePhyUshort(sc, 0x14, 0x0241);
+        MP_WritePhyUshort(sc, 0x14, 0x480c);
+        MP_WritePhyUshort(sc, 0x14, 0x111e);
+        MP_WritePhyUshort(sc, 0x14, 0x21bf);
+        MP_WritePhyUshort(sc, 0x14, 0x41ab);
+        MP_WritePhyUshort(sc, 0x14, 0x0241);
+        MP_WritePhyUshort(sc, 0x14, 0x480c);
+        MP_WritePhyUshort(sc, 0x14, 0x121e);
+        MP_WritePhyUshort(sc, 0x14, 0x21e6);
+        MP_WritePhyUshort(sc, 0x14, 0x8248);
+        MP_WritePhyUshort(sc, 0x14, 0xa200);
+        MP_WritePhyUshort(sc, 0x14, 0x0ae1);
+        MP_WritePhyUshort(sc, 0x14, 0x822c);
+        MP_WritePhyUshort(sc, 0x14, 0xf629);
+        MP_WritePhyUshort(sc, 0x14, 0xe582);
+        MP_WritePhyUshort(sc, 0x14, 0x2cae);
+        MP_WritePhyUshort(sc, 0x14, 0x42e0);
+        MP_WritePhyUshort(sc, 0x14, 0x8249);
+        MP_WritePhyUshort(sc, 0x14, 0xf721);
+        MP_WritePhyUshort(sc, 0x14, 0xe482);
+        MP_WritePhyUshort(sc, 0x14, 0x4902);
+        MP_WritePhyUshort(sc, 0x14, 0x4520);
+        MP_WritePhyUshort(sc, 0x14, 0xbf41);
+        MP_WritePhyUshort(sc, 0x14, 0xb702);
+        MP_WritePhyUshort(sc, 0x14, 0x4148);
+        MP_WritePhyUshort(sc, 0x14, 0xef21);
+        MP_WritePhyUshort(sc, 0x14, 0xbf41);
+        MP_WritePhyUshort(sc, 0x14, 0xae02);
+        MP_WritePhyUshort(sc, 0x14, 0x4148);
+        MP_WritePhyUshort(sc, 0x14, 0x0c12);
+        MP_WritePhyUshort(sc, 0x14, 0x1e21);
+        MP_WritePhyUshort(sc, 0x14, 0xbf41);
+        MP_WritePhyUshort(sc, 0x14, 0xb102);
+        MP_WritePhyUshort(sc, 0x14, 0x4148);
+        MP_WritePhyUshort(sc, 0x14, 0x0c13);
+        MP_WritePhyUshort(sc, 0x14, 0x1e21);
+        MP_WritePhyUshort(sc, 0x14, 0xbf41);
+        MP_WritePhyUshort(sc, 0x14, 0xba02);
+        MP_WritePhyUshort(sc, 0x14, 0x4148);
+        MP_WritePhyUshort(sc, 0x14, 0x0c14);
+        MP_WritePhyUshort(sc, 0x14, 0x1e21);
+        MP_WritePhyUshort(sc, 0x14, 0xbf43);
+        MP_WritePhyUshort(sc, 0x14, 0x4602);
+        MP_WritePhyUshort(sc, 0x14, 0x4148);
+        MP_WritePhyUshort(sc, 0x14, 0x0c16);
+        MP_WritePhyUshort(sc, 0x14, 0x1e21);
+        MP_WritePhyUshort(sc, 0x14, 0xe682);
+        MP_WritePhyUshort(sc, 0x14, 0x47ee);
+        MP_WritePhyUshort(sc, 0x14, 0x8246);
+        MP_WritePhyUshort(sc, 0x14, 0x01ef);
+        MP_WritePhyUshort(sc, 0x14, 0x96fe);
+        MP_WritePhyUshort(sc, 0x14, 0xfdfc);
+        MP_WritePhyUshort(sc, 0x14, 0x04f8);
+        MP_WritePhyUshort(sc, 0x14, 0xfaef);
+        MP_WritePhyUshort(sc, 0x14, 0x69e0);
+        MP_WritePhyUshort(sc, 0x14, 0x824b);
+        MP_WritePhyUshort(sc, 0x14, 0xa000);
+        MP_WritePhyUshort(sc, 0x14, 0x0502);
+        MP_WritePhyUshort(sc, 0x14, 0x8697);
+        MP_WritePhyUshort(sc, 0x14, 0xae06);
+        MP_WritePhyUshort(sc, 0x14, 0xa001);
+        MP_WritePhyUshort(sc, 0x14, 0x0302);
+        MP_WritePhyUshort(sc, 0x14, 0x1937);
+        MP_WritePhyUshort(sc, 0x14, 0xef96);
+        MP_WritePhyUshort(sc, 0x14, 0xfefc);
+        MP_WritePhyUshort(sc, 0x14, 0x04f8);
+        MP_WritePhyUshort(sc, 0x14, 0xfaef);
+        MP_WritePhyUshort(sc, 0x14, 0x69e0);
+        MP_WritePhyUshort(sc, 0x14, 0x822e);
+        MP_WritePhyUshort(sc, 0x14, 0xf620);
+        MP_WritePhyUshort(sc, 0x14, 0xe482);
+        MP_WritePhyUshort(sc, 0x14, 0x2ee0);
+        MP_WritePhyUshort(sc, 0x14, 0x8010);
+        MP_WritePhyUshort(sc, 0x14, 0xac21);
+        MP_WritePhyUshort(sc, 0x14, 0x02ae);
+        MP_WritePhyUshort(sc, 0x14, 0x54e0);
+        MP_WritePhyUshort(sc, 0x14, 0x822c);
+        MP_WritePhyUshort(sc, 0x14, 0xf720);
+        MP_WritePhyUshort(sc, 0x14, 0xe482);
+        MP_WritePhyUshort(sc, 0x14, 0x2cbf);
+        MP_WritePhyUshort(sc, 0x14, 0x4175);
+        MP_WritePhyUshort(sc, 0x14, 0x0241);
+        MP_WritePhyUshort(sc, 0x14, 0x48ac);
+        MP_WritePhyUshort(sc, 0x14, 0x2822);
+        MP_WritePhyUshort(sc, 0x14, 0xbf41);
+        MP_WritePhyUshort(sc, 0x14, 0x9f02);
+        MP_WritePhyUshort(sc, 0x14, 0x4148);
+        MP_WritePhyUshort(sc, 0x14, 0xe582);
+        MP_WritePhyUshort(sc, 0x14, 0x4cac);
+        MP_WritePhyUshort(sc, 0x14, 0x2820);
+        MP_WritePhyUshort(sc, 0x14, 0xd103);
+        MP_WritePhyUshort(sc, 0x14, 0xbf41);
+        MP_WritePhyUshort(sc, 0x14, 0x9902);
+        MP_WritePhyUshort(sc, 0x14, 0x410a);
+        MP_WritePhyUshort(sc, 0x14, 0xee82);
+        MP_WritePhyUshort(sc, 0x14, 0x4b00);
+        MP_WritePhyUshort(sc, 0x14, 0xe182);
+        MP_WritePhyUshort(sc, 0x14, 0x2cf6);
+        MP_WritePhyUshort(sc, 0x14, 0x28e5);
+        MP_WritePhyUshort(sc, 0x14, 0x822c);
+        MP_WritePhyUshort(sc, 0x14, 0xae21);
+        MP_WritePhyUshort(sc, 0x14, 0xd104);
+        MP_WritePhyUshort(sc, 0x14, 0xbf41);
+        MP_WritePhyUshort(sc, 0x14, 0x9902);
+        MP_WritePhyUshort(sc, 0x14, 0x410a);
+        MP_WritePhyUshort(sc, 0x14, 0xae08);
+        MP_WritePhyUshort(sc, 0x14, 0xd105);
+        MP_WritePhyUshort(sc, 0x14, 0xbf41);
+        MP_WritePhyUshort(sc, 0x14, 0x9902);
+        MP_WritePhyUshort(sc, 0x14, 0x410a);
+        MP_WritePhyUshort(sc, 0x14, 0xe082);
+        MP_WritePhyUshort(sc, 0x14, 0x49f7);
+        MP_WritePhyUshort(sc, 0x14, 0x20e4);
+        MP_WritePhyUshort(sc, 0x14, 0x8249);
+        MP_WritePhyUshort(sc, 0x14, 0x0245);
+        MP_WritePhyUshort(sc, 0x14, 0x20ee);
+        MP_WritePhyUshort(sc, 0x14, 0x824b);
+        MP_WritePhyUshort(sc, 0x14, 0x01ef);
+        MP_WritePhyUshort(sc, 0x14, 0x96fe);
+        MP_WritePhyUshort(sc, 0x14, 0xfc04);
+        MP_WritePhyUshort(sc, 0x14, 0xf8f9);
+        MP_WritePhyUshort(sc, 0x14, 0xface);
+        MP_WritePhyUshort(sc, 0x14, 0xfaef);
+        MP_WritePhyUshort(sc, 0x14, 0x69fb);
+        MP_WritePhyUshort(sc, 0x14, 0xbf87);
+        MP_WritePhyUshort(sc, 0x14, 0x2fd7);
+        MP_WritePhyUshort(sc, 0x14, 0x0020);
+        MP_WritePhyUshort(sc, 0x14, 0xd819);
+        MP_WritePhyUshort(sc, 0x14, 0xd919);
+        MP_WritePhyUshort(sc, 0x14, 0xda19);
+        MP_WritePhyUshort(sc, 0x14, 0xdb19);
+        MP_WritePhyUshort(sc, 0x14, 0x07ef);
+        MP_WritePhyUshort(sc, 0x14, 0x9502);
+        MP_WritePhyUshort(sc, 0x14, 0x410a);
+        MP_WritePhyUshort(sc, 0x14, 0x073f);
+        MP_WritePhyUshort(sc, 0x14, 0x0004);
+        MP_WritePhyUshort(sc, 0x14, 0x9fec);
+        MP_WritePhyUshort(sc, 0x14, 0xffef);
+        MP_WritePhyUshort(sc, 0x14, 0x96fe);
+        MP_WritePhyUshort(sc, 0x14, 0xc6fe);
+        MP_WritePhyUshort(sc, 0x14, 0xfdfc);
+        MP_WritePhyUshort(sc, 0x14, 0x0400);
+        MP_WritePhyUshort(sc, 0x14, 0x0144);
+        MP_WritePhyUshort(sc, 0x14, 0x0000);
+        MP_WritePhyUshort(sc, 0x14, 0x0343);
+        MP_WritePhyUshort(sc, 0x14, 0xee00);
+        MP_WritePhyUshort(sc, 0x14, 0x0087);
+        MP_WritePhyUshort(sc, 0x14, 0x5b00);
+        MP_WritePhyUshort(sc, 0x14, 0x0141);
+        MP_WritePhyUshort(sc, 0x14, 0xe100);
+        MP_WritePhyUshort(sc, 0x14, 0x0387);
+        MP_WritePhyUshort(sc, 0x14, 0x5e00);
+        MP_WritePhyUshort(sc, 0x14, 0x0987);
+        MP_WritePhyUshort(sc, 0x14, 0x6100);
+        MP_WritePhyUshort(sc, 0x14, 0x0987);
+        MP_WritePhyUshort(sc, 0x14, 0x6400);
+        MP_WritePhyUshort(sc, 0x14, 0x0087);
+        MP_WritePhyUshort(sc, 0x14, 0x6da4);
+        MP_WritePhyUshort(sc, 0x14, 0x00b8);
+        MP_WritePhyUshort(sc, 0x14, 0x20c4);
+        MP_WritePhyUshort(sc, 0x14, 0x1600);
+        MP_WritePhyUshort(sc, 0x14, 0x000f);
+        MP_WritePhyUshort(sc, 0x14, 0xf800);
+        MP_WritePhyUshort(sc, 0x14, 0x7000);
+        MP_WritePhyUshort(sc, 0x14, 0xb82e);
+        MP_WritePhyUshort(sc, 0x14, 0x98a5);
+        MP_WritePhyUshort(sc, 0x14, 0x8ab6);
+        MP_WritePhyUshort(sc, 0x14, 0xa83e);
+        MP_WritePhyUshort(sc, 0x14, 0x50a8);
+        MP_WritePhyUshort(sc, 0x14, 0x3e33);
+        MP_WritePhyUshort(sc, 0x14, 0xbcc6);
+        MP_WritePhyUshort(sc, 0x14, 0x22bc);
+        MP_WritePhyUshort(sc, 0x14, 0xc6aa);
+        MP_WritePhyUshort(sc, 0x14, 0xa442);
+        MP_WritePhyUshort(sc, 0x14, 0xffc4);
+        MP_WritePhyUshort(sc, 0x14, 0x0800);
+        MP_WritePhyUshort(sc, 0x14, 0xc416);
+        MP_WritePhyUshort(sc, 0x14, 0xa8bc);
+        MP_WritePhyUshort(sc, 0x14, 0xc000);
+        MP_WritePhyUshort(sc, 0x13, 0xb818);
+        MP_WritePhyUshort(sc, 0x14, 0x02e3);
+        MP_WritePhyUshort(sc, 0x13, 0xb81a);
+        MP_WritePhyUshort(sc, 0x14, 0x17ff);
+        MP_WritePhyUshort(sc, 0x13, 0xb81e);
+        MP_WritePhyUshort(sc, 0x14, 0x3b1c);
+        MP_WritePhyUshort(sc, 0x13, 0xb820);
+        MP_WritePhyUshort(sc, 0x14, 0x021b);
+        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+
+        MP_WritePhyUshort(sc, 0x1F, 0x0A43);
+        MP_WritePhyUshort(sc, 0x13, 0x0000);
+        MP_WritePhyUshort(sc, 0x14, 0x0000);
+        MP_WritePhyUshort(sc, 0x1f, 0x0B82);
+        PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
+        PhyRegValue &= ~(BIT_0);
+        MP_WritePhyUshort(sc, 0x17, PhyRegValue);
+        if (sc->RequiredSecLanDonglePatch)
+                PhyRegValue &= ~(BIT_2);
+        MP_WritePhyUshort(sc,0x1f, 0x0000);
+
+        MP_WritePhyUshort(sc, 0x1F, 0x0003);
+        MP_WritePhyUshort(sc, 0x09, 0xA20F);
+        MP_WritePhyUshort(sc, 0x1F, 0x0000);
+        MP_WritePhyUshort(sc, 0x1F, 0x0003);
+        MP_WritePhyUshort(sc, 0x01, 0x328A);
+        MP_WritePhyUshort(sc, 0x1F, 0x0000);
+        MP_WritePhyUshort(sc, 0x1F, 0x0A43);
+        MP_WritePhyUshort(sc, 0x13, 0x8011);
+        ClearEthPhyBit(sc, 0x14, BIT_14);
+        MP_WritePhyUshort(sc, 0x1F, 0x0A40);
+        MP_WritePhyUshort(sc, 0x1F, 0x0000);
+        MP_WritePhyUshort(sc,0x1f, 0x0000);
+        MP_WritePhyUshort(sc,0x00, 0x9200);
+}
+
+static void re_init_hw_phy_mcu(struct re_softc *sc)
+{
+        if (re_hw_phy_mcu_code_ver_matched(sc)) return;
+
+        switch (sc->re_type) {
+        case MACFG_36:
+                re_set_phy_mcu_8168e_1(sc);
+                break;
+        case MACFG_37:
+                re_set_phy_mcu_8168e_2(sc);
+                break;
+        case MACFG_38:
+                re_set_phy_mcu_8168evl_1(sc);
+                break;
+        case MACFG_39:
+                re_set_phy_mcu_8168evl_2(sc);
+                break;
+        case MACFG_50:
+                re_set_phy_mcu_8168f_1(sc);
+                break;
+        case MACFG_51:
+                re_set_phy_mcu_8168f_2(sc);
+                break;
+        case MACFG_52:
+                re_set_phy_mcu_8411_1(sc);
+                break;
+        case MACFG_56:
+                re_set_phy_mcu_8168g_1(sc);
+                break;
+        case MACFG_59:
+                re_set_phy_mcu_8168gu_2(sc);
+                break;
+        case MACFG_60:
+                re_set_phy_mcu_8411b_1(sc);
+                break;
+        case MACFG_61:
+                re_set_phy_mcu_8168ep_1(sc);
+                break;
+        case MACFG_68:
+                re_set_phy_mcu_8168h_1(sc);
+                break;
+        case MACFG_69:
+                re_set_phy_mcu_8168h_2(sc);
+                break;
+        }
+
+        re_write_hw_phy_mcu_code_ver(sc);
+
+        MP_WritePhyUshort(sc, 0x1F, 0x0000);
+}
+
+static void re_hw_phy_config(struct re_softc *sc)
+{
+        u_int16_t Data, PhyRegValue, TmpUshort;
+        u_int32_t Data_u32;
+        u_int16_t dout_tapbin;
+        int	i;
+
+        if (sc->re_type == MACFG_59 || sc->re_type == MACFG_60 ||
+            sc->re_type == MACFG_62 || sc->re_type == MACFG_67 ||
+            sc->re_type == MACFG_68 || sc->re_type == MACFG_69 ||
+            sc->re_type == MACFG_70 || sc->re_type == MACFG_71) {
+                MP_WritePhyOcpRegWord(sc, 0x0C41, 0x13, 0x0000);
+                MP_WritePhyOcpRegWord(sc, 0x0C41, 0x13, 0x0500);
+        }
+
+        if (HW_DASH_SUPPORT_TYPE_3(sc) && sc->HwPkgDet == 0x06) return;
+
+        if (FALSE == re_phy_ram_code_check(sc)) {
+                re_set_phy_ram_code_check_fail_flag(sc);
+                return;
+        }
+
+        re_init_hw_phy_mcu(sc);
+
+        MP_WritePhyUshort(sc, 0x1F, 0x0000);
+
+        if (sc->re_type == MACFG_3) {
+                CSR_WRITE_1(sc, 0x82, CSR_READ_1(sc, 0x82)|BIT_0);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+                MP_WritePhyUshort(sc, 0x0b, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1f, 0x0001);
+                MP_WritePhyUshort(sc, 0x06, 0x006e);
+                MP_WritePhyUshort(sc, 0x08, 0x0708);
+                MP_WritePhyUshort(sc, 0x15, 0x4000);
+                MP_WritePhyUshort(sc, 0x18, 0x65c7);
+
+                MP_WritePhyUshort(sc, 0x1f, 0x0001);
+                MP_WritePhyUshort(sc, 0x03, 0x00a1);
+                MP_WritePhyUshort(sc, 0x02, 0x0008);
+                MP_WritePhyUshort(sc, 0x01, 0x0120);
+                MP_WritePhyUshort(sc, 0x00, 0x1000);
+                MP_WritePhyUshort(sc, 0x04, 0x0800);
+                MP_WritePhyUshort(sc, 0x04, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x03, 0xff41);
+                MP_WritePhyUshort(sc, 0x02, 0xdf60);
+                MP_WritePhyUshort(sc, 0x01, 0x0140);
+                MP_WritePhyUshort(sc, 0x00, 0x0077);
+                MP_WritePhyUshort(sc, 0x04, 0x7800);
+                MP_WritePhyUshort(sc, 0x04, 0x7000);
+
+                MP_WritePhyUshort(sc, 0x03, 0x802f);
+                MP_WritePhyUshort(sc, 0x02, 0x4f02);
+                MP_WritePhyUshort(sc, 0x01, 0x0409);
+                MP_WritePhyUshort(sc, 0x00, 0xf0f9);
+                MP_WritePhyUshort(sc, 0x04, 0x9800);
+                MP_WritePhyUshort(sc, 0x04, 0x9000);
+
+                MP_WritePhyUshort(sc, 0x03, 0xdf01);
+                MP_WritePhyUshort(sc, 0x02, 0xdf20);
+                MP_WritePhyUshort(sc, 0x01, 0xff95);
+                MP_WritePhyUshort(sc, 0x00, 0xba00);
+                MP_WritePhyUshort(sc, 0x04, 0xa800);
+                MP_WritePhyUshort(sc, 0x04, 0xa000);
+
+                MP_WritePhyUshort(sc, 0x03, 0xff41);
+                MP_WritePhyUshort(sc, 0x02, 0xdf20);
+                MP_WritePhyUshort(sc, 0x01, 0x0140);
+                MP_WritePhyUshort(sc, 0x00, 0x00bb);
+                MP_WritePhyUshort(sc, 0x04, 0xb800);
+                MP_WritePhyUshort(sc, 0x04, 0xb000);
+
+                MP_WritePhyUshort(sc, 0x03, 0xdf41);
+                MP_WritePhyUshort(sc, 0x02, 0xdc60);
+                MP_WritePhyUshort(sc, 0x01, 0x6340);
+                MP_WritePhyUshort(sc, 0x00, 0x007d);
+                MP_WritePhyUshort(sc, 0x04, 0xd800);
+                MP_WritePhyUshort(sc, 0x04, 0xd000);
+
+                MP_WritePhyUshort(sc, 0x03, 0xdf01);
+                MP_WritePhyUshort(sc, 0x02, 0xdf20);
+                MP_WritePhyUshort(sc, 0x01, 0x100a);
+                MP_WritePhyUshort(sc, 0x00, 0xa0ff);
+                MP_WritePhyUshort(sc, 0x04, 0xf800);
+                MP_WritePhyUshort(sc, 0x04, 0xf000);
+
+                MP_WritePhyUshort(sc, 0x1f, 0x0000);
+                MP_WritePhyUshort(sc, 0x0b, 0x0000);
+                MP_WritePhyUshort(sc, 0x00, 0x9200);
+
+                CSR_WRITE_1(sc, 0x82, 0x0d);
+        } else if (sc->re_type == MACFG_4) {
+                MP_WritePhyUshort(sc, 0x1f, 0x0002);
+                MP_WritePhyUshort(sc, 0x01, 0x90D0);
+                MP_WritePhyUshort(sc, 0x1f, 0x0000);
+                // MP_WritePhyUshort(sc, 0x1e, 0x8c00); /* PHY link down with some Giga switch */
+        } else if (sc->re_type == MACFG_5) {
+                MP_WritePhyUshort(sc, 0x1f, 0x0001);
+                MP_WritePhyUshort(sc, 0x04, 0x0000);
+                MP_WritePhyUshort(sc, 0x03, 0x00a1);
+                MP_WritePhyUshort(sc, 0x02, 0x0008);
+                MP_WritePhyUshort(sc, 0x01, 0x0120);
+                MP_WritePhyUshort(sc, 0x00, 0x1000);
+                MP_WritePhyUshort(sc, 0x04, 0x0800);
+
+                MP_WritePhyUshort(sc, 0x04, 0x9000);
+                MP_WritePhyUshort(sc, 0x03, 0x802f);
+                MP_WritePhyUshort(sc, 0x02, 0x4f02);
+                MP_WritePhyUshort(sc, 0x01, 0x0409);
+                MP_WritePhyUshort(sc, 0x00, 0xf099);
+                MP_WritePhyUshort(sc, 0x04, 0x9800);
+
+                MP_WritePhyUshort(sc, 0x04, 0xa000);
+                MP_WritePhyUshort(sc, 0x03, 0xdf01);
+                MP_WritePhyUshort(sc, 0x02, 0xdf20);
+                MP_WritePhyUshort(sc, 0x01, 0xff95);
+                MP_WritePhyUshort(sc, 0x00, 0xba00);
+                MP_WritePhyUshort(sc, 0x04, 0xa800);
+
+                MP_WritePhyUshort(sc, 0x04, 0xf000);
+                MP_WritePhyUshort(sc, 0x03, 0xdf01);
+                MP_WritePhyUshort(sc, 0x02, 0xdf20);
+                MP_WritePhyUshort(sc, 0x01, 0x101a);
+                MP_WritePhyUshort(sc, 0x00, 0xa0ff);
+                MP_WritePhyUshort(sc, 0x04, 0xf800);
+                MP_WritePhyUshort(sc, 0x04, 0x0000);
+                MP_WritePhyUshort(sc, 0x1f, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1f, 0x0001);
+                MP_WritePhyUshort(sc, 0x10, 0xf41b);
+                MP_WritePhyUshort(sc, 0x14, 0xfb54);
+                MP_WritePhyUshort(sc, 0x18, 0xf5c7);
+                MP_WritePhyUshort(sc, 0x1f, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1f, 0x0001);
+                MP_WritePhyUshort(sc, 0x17, 0x0CC0);
+                MP_WritePhyUshort(sc, 0x1f, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1f, 0x0001);
+                MP_WritePhyUshort(sc, 0x10, 0xf01b);
+
+        } else if (sc->re_type == MACFG_6) {
+                MP_WritePhyUshort(sc, 0x1f, 0x0001);
+                MP_WritePhyUshort(sc, 0x04, 0x0000);
+                MP_WritePhyUshort(sc, 0x03, 0x00a1);
+                MP_WritePhyUshort(sc, 0x02, 0x0008);
+                MP_WritePhyUshort(sc, 0x01, 0x0120);
+                MP_WritePhyUshort(sc, 0x00, 0x1000);
+                MP_WritePhyUshort(sc, 0x04, 0x0800);
+
+                MP_WritePhyUshort(sc, 0x04, 0x9000);
+                MP_WritePhyUshort(sc, 0x03, 0x802f);
+                MP_WritePhyUshort(sc, 0x02, 0x4f02);
+                MP_WritePhyUshort(sc, 0x01, 0x0409);
+                MP_WritePhyUshort(sc, 0x00, 0xf099);
+                MP_WritePhyUshort(sc, 0x04, 0x9800);
+
+                MP_WritePhyUshort(sc, 0x04, 0xa000);
+                MP_WritePhyUshort(sc, 0x03, 0xdf01);
+                MP_WritePhyUshort(sc, 0x02, 0xdf20);
+                MP_WritePhyUshort(sc, 0x01, 0xff95);
+                MP_WritePhyUshort(sc, 0x00, 0xba00);
+                MP_WritePhyUshort(sc, 0x04, 0xa800);
+
+                MP_WritePhyUshort(sc, 0x04, 0xf000);
+                MP_WritePhyUshort(sc, 0x03, 0xdf01);
+                MP_WritePhyUshort(sc, 0x02, 0xdf20);
+                MP_WritePhyUshort(sc, 0x01, 0x101a);
+                MP_WritePhyUshort(sc, 0x00, 0xa0ff);
+                MP_WritePhyUshort(sc, 0x04, 0xf800);
+                MP_WritePhyUshort(sc, 0x04, 0x0000);
+                MP_WritePhyUshort(sc, 0x1f, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1f, 0x0001);
+                MP_WritePhyUshort(sc, 0x0b, 0x8480);
+                MP_WritePhyUshort(sc, 0x1f, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1f, 0x0001);
+                MP_WritePhyUshort(sc, 0x18, 0x67c7);
+                MP_WritePhyUshort(sc, 0x04, 0x2000);
+                MP_WritePhyUshort(sc, 0x03, 0x002f);
+                MP_WritePhyUshort(sc, 0x02, 0x4360);
+                MP_WritePhyUshort(sc, 0x01, 0x0109);
+                MP_WritePhyUshort(sc, 0x00, 0x3022);
+                MP_WritePhyUshort(sc, 0x04, 0x2800);
+                MP_WritePhyUshort(sc, 0x1f, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1f, 0x0001);
+                MP_WritePhyUshort(sc, 0x17, 0x0CC0);
+        } else if (sc->re_type == MACFG_14) {
+                MP_WritePhyUshort(sc, 0x1f, 0x0000);
+                MP_WritePhyUshort(sc, 0x11, MP_ReadPhyUshort(sc, 0x11) | 0x1000);
+                MP_WritePhyUshort(sc, 0x19, MP_ReadPhyUshort(sc, 0x19) | 0x2000);
+                MP_WritePhyUshort(sc, 0x10, MP_ReadPhyUshort(sc, 0x10) | 0x8000);
+
+                MP_WritePhyUshort(sc, 0x1f, 0x0003);
+                MP_WritePhyUshort(sc, 0x08, 0x441D);
+                MP_WritePhyUshort(sc, 0x01, 0x9100);
+        } else if (sc->re_type == MACFG_15) {
+                MP_WritePhyUshort(sc, 0x1f, 0x0000);
+                MP_WritePhyUshort(sc, 0x11, MP_ReadPhyUshort(sc, 0x11) | 0x1000);
+                MP_WritePhyUshort(sc, 0x19, MP_ReadPhyUshort(sc, 0x19) | 0x2000);
+                MP_WritePhyUshort(sc, 0x10, MP_ReadPhyUshort(sc, 0x10) | 0x8000);
+
+                MP_WritePhyUshort(sc, 0x1f, 0x0003);
+                MP_WritePhyUshort(sc, 0x08, 0x441D);
+                MP_WritePhyUshort(sc, 0x01, 0x9100);
+        } else if (sc->re_type == MACFG_17) {
+                MP_WritePhyUshort(sc, 0x1f, 0x0000);
+                MP_WritePhyUshort(sc, 0x11, MP_ReadPhyUshort(sc, 0x11) | 0x1000);
+                MP_WritePhyUshort(sc, 0x19, MP_ReadPhyUshort(sc, 0x19) | 0x2000);
+                MP_WritePhyUshort(sc, 0x10, MP_ReadPhyUshort(sc, 0x10) | 0x8000);
+
+                MP_WritePhyUshort(sc, 0x1f, 0x0003);
+                MP_WritePhyUshort(sc, 0x08, 0x441D);
+
+                MP_WritePhyUshort(sc, 0x1f, 0x0000);
+        } else if (sc->re_type == MACFG_21) {
+                MP_WritePhyUshort(sc, 0x1F, 0x0001);
+                MP_WritePhyUshort(sc, 0x0B, 0x94B0);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0003);
+                MP_WritePhyUshort(sc, 0x12, 0x6096);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+        } else if (sc->re_type == MACFG_22) {
+                MP_WritePhyUshort(sc, 0x1F, 0x0001);
+                MP_WritePhyUshort(sc, 0x0B, 0x94B0);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0003);
+                MP_WritePhyUshort(sc, 0x12, 0x6096);
+        } else if (sc->re_type == MACFG_23) {
+                MP_WritePhyUshort(sc, 0x1F, 0x0001);
+                MP_WritePhyUshort(sc, 0x0B, 0x94B0);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0003);
+                MP_WritePhyUshort(sc, 0x12, 0x6096);
+        } else if (sc->re_type == MACFG_24) {
+                MP_WritePhyUshort(sc, 0x1F, 0x0001);
+                MP_WritePhyUshort(sc, 0x12, 0x2300);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+                MP_WritePhyUshort(sc, 0x1F, 0x0003);
+                MP_WritePhyUshort(sc, 0x16, 0x000A);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0003);
+                MP_WritePhyUshort(sc, 0x12, 0xC096);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0002);
+                MP_WritePhyUshort(sc, 0x00, 0x88DE);
+                MP_WritePhyUshort(sc, 0x01, 0x82B1);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0002);
+                MP_WritePhyUshort(sc, 0x08, 0x9E30);
+                MP_WritePhyUshort(sc, 0x09, 0x01F0);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0002);
+                MP_WritePhyUshort(sc, 0x0A, 0x5500);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0002);
+                MP_WritePhyUshort(sc, 0x03, 0x7002);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+                MP_WritePhyUshort(sc, 0x14, MP_ReadPhyUshort(sc, 0x14) | BIT_5);
+                MP_WritePhyUshort(sc, 0x0d, MP_ReadPhyUshort(sc, 0x0d) | BIT_5);
+        } else if (sc->re_type == MACFG_25) {
+                MP_WritePhyUshort(sc, 0x1F, 0x0001);
+                MP_WritePhyUshort(sc, 0x12, 0x2300);
+                MP_WritePhyUshort(sc, 0x1F, 0x0003);
+                MP_WritePhyUshort(sc, 0x16, 0x0F0A);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0002);
+                MP_WritePhyUshort(sc, 0x00, 0x88DE);
+                MP_WritePhyUshort(sc, 0x01, 0x82B1);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0002);
+                MP_WritePhyUshort(sc, 0x0C, 0x7EB8);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0002);
+                MP_WritePhyUshort(sc, 0x06, 0x0761);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0001);
+                MP_WritePhyUshort(sc, 0x03, 0x802F);
+                MP_WritePhyUshort(sc, 0x02, 0x4F02);
+                MP_WritePhyUshort(sc, 0x01, 0x0409);
+                MP_WritePhyUshort(sc, 0x00, 0xF099);
+                MP_WritePhyUshort(sc, 0x04, 0x9800);
+                MP_WritePhyUshort(sc, 0x04, 0x9000);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+                MP_WritePhyUshort(sc, 0x16, MP_ReadPhyUshort(sc, 0x16) | BIT_0);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+                MP_WritePhyUshort(sc, 0x14, MP_ReadPhyUshort(sc, 0x14) | BIT_5);
+                MP_WritePhyUshort(sc, 0x0D, MP_ReadPhyUshort(sc, 0x0D) & ~BIT_5);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0001);
+                MP_WritePhyUshort(sc, 0x1D, 0x3D98);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0001);
+                MP_WritePhyUshort(sc, 0x17, 0x0CC0);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+        } else if (sc->re_type == MACFG_26) {
+                MP_WritePhyUshort(sc, 0x1F, 0x0001);
+                MP_WritePhyUshort(sc, 0x12, 0x2300);
+                MP_WritePhyUshort(sc, 0x1F, 0x0003);
+                MP_WritePhyUshort(sc, 0x16, 0x0F0A);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0002);
+                MP_WritePhyUshort(sc, 0x00, 0x88DE);
+                MP_WritePhyUshort(sc, 0x01, 0x82B1);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0002);
+                MP_WritePhyUshort(sc, 0x0C, 0x7EB8);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0002);
+                MP_WritePhyUshort(sc, 0x06, 0x5461);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0002);
+                MP_WritePhyUshort(sc, 0x06, 0x5461);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+                MP_WritePhyUshort(sc, 0x16, MP_ReadPhyUshort(sc, 0x16) | BIT_0);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+                MP_WritePhyUshort(sc, 0x14, MP_ReadPhyUshort(sc, 0x14) | BIT_5);
+                MP_WritePhyUshort(sc, 0x0D, MP_ReadPhyUshort(sc, 0x0D) & ~BIT_5);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0001);
+                MP_WritePhyUshort(sc, 0x1D, 0x3D98);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1f, 0x0001);
+                MP_WritePhyUshort(sc, 0x17, 0x0CC0);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+        } else if (sc->re_type == MACFG_27) {
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+                MP_WritePhyUshort(sc, 0x0d, MP_ReadPhyUshort(sc, 0x0d) | BIT_5);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0001);
+                MP_WritePhyUshort(sc, 0x1D, 0x3D98);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0001);
+                MP_WritePhyUshort(sc, 0x14, 0xCAA3);
+                MP_WritePhyUshort(sc, 0x1C, 0x000A);
+                MP_WritePhyUshort(sc, 0x18, 0x65D0);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0003);
+                MP_WritePhyUshort(sc, 0x17, 0xB580);
+                MP_WritePhyUshort(sc, 0x18, 0xFF54);
+                MP_WritePhyUshort(sc, 0x19, 0x3954);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0002);
+                MP_WritePhyUshort(sc, 0x0D, 0x310C);
+                MP_WritePhyUshort(sc, 0x0E, 0x310C);
+                MP_WritePhyUshort(sc, 0x0F, 0x311C);
+                MP_WritePhyUshort(sc, 0x06, 0x0761);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0003);
+                MP_WritePhyUshort(sc, 0x18, 0xFF55);
+                MP_WritePhyUshort(sc, 0x19, 0x3955);
+                MP_WritePhyUshort(sc, 0x18, 0xFF54);
+                MP_WritePhyUshort(sc, 0x19, 0x3954);
+
+                MP_WritePhyUshort(sc, 0x1f, 0x0001);
+                MP_WritePhyUshort(sc, 0x17, 0x0CC0);
+        } else if (sc->re_type == MACFG_28) {
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+                MP_WritePhyUshort(sc, 0x14, MP_ReadPhyUshort(sc, 0x14) | BIT_5);
+                MP_WritePhyUshort(sc, 0x0d, MP_ReadPhyUshort(sc, 0x0d) | BIT_5);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0001);
+                MP_WritePhyUshort(sc, 0x14, 0xCAA3);
+                MP_WritePhyUshort(sc, 0x1C, 0x000A);
+                MP_WritePhyUshort(sc, 0x18, 0x65D0);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0003);
+                MP_WritePhyUshort(sc, 0x17, 0xB580);
+                MP_WritePhyUshort(sc, 0x18, 0xFF54);
+                MP_WritePhyUshort(sc, 0x19, 0x3954);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0002);
+                MP_WritePhyUshort(sc, 0x0D, 0x310C);
+                MP_WritePhyUshort(sc, 0x0E, 0x310C);
+                MP_WritePhyUshort(sc, 0x0F, 0x311C);
+                MP_WritePhyUshort(sc, 0x06, 0x0761);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0003);
+                MP_WritePhyUshort(sc, 0x18, 0xFF55);
+                MP_WritePhyUshort(sc, 0x19, 0x3955);
+                MP_WritePhyUshort(sc, 0x18, 0xFF54);
+                MP_WritePhyUshort(sc, 0x19, 0x3954);
+
+                MP_WritePhyUshort(sc, 0x1f, 0x0001);
+                MP_WritePhyUshort(sc, 0x17, 0x0CC0);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+                MP_WritePhyUshort(sc, 0x16, MP_ReadPhyUshort(sc, 0x16) | BIT_0);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+        } else if (sc->re_type == MACFG_31) {
+                MP_WritePhyUshort(sc, 0x1F, 0x0001);
+                MP_WritePhyUshort(sc, 0x06, 0x4064);
+                MP_WritePhyUshort(sc, 0x07, 0x2863);
+                MP_WritePhyUshort(sc, 0x08, 0x059C);
+                MP_WritePhyUshort(sc, 0x09, 0x26B4);
+                MP_WritePhyUshort(sc, 0x0A, 0x6A19);
+                MP_WritePhyUshort(sc, 0x0B, 0xDCC8);
+                MP_WritePhyUshort(sc, 0x10, 0xF06D);
+                MP_WritePhyUshort(sc, 0x14, 0x7F68);
+                MP_WritePhyUshort(sc, 0x18, 0x7FD9);
+                MP_WritePhyUshort(sc, 0x1C, 0xF0FF);
+                MP_WritePhyUshort(sc, 0x1D, 0x3D9C);
+                MP_WritePhyUshort(sc, 0x1F, 0x0003);
+                MP_WritePhyUshort(sc, 0x12, 0xF49F);
+                MP_WritePhyUshort(sc, 0x13, 0x070B);
+                MP_WritePhyUshort(sc, 0x1A, 0x05AD);
+                MP_WritePhyUshort(sc, 0x14, 0x94C0);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0002);
+                Data = MP_ReadPhyUshort(sc, 0x0B) & 0xFF00;
+                Data |= 0x10;
+                MP_WritePhyUshort(sc, 0x0B, Data);
+                Data = MP_ReadPhyUshort(sc, 0x0C) & 0x00FF;
+                Data |= 0xA200;
+                MP_WritePhyUshort(sc, 0x0C, Data);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0002);
+                MP_WritePhyUshort(sc, 0x06, 0x5561);
+                MP_WritePhyUshort(sc, 0x1F, 0x0005);
+                MP_WritePhyUshort(sc, 0x05, 0x8332);
+                MP_WritePhyUshort(sc, 0x06, 0x5561);
+
+                if (MP_ReadEfuse(sc, 0x01) == 0xb1) {
+                        MP_WritePhyUshort(sc, 0x1F, 0x0002);
+                        MP_WritePhyUshort(sc, 0x05, 0x669A);
+                        MP_WritePhyUshort(sc, 0x1F, 0x0005);
+                        MP_WritePhyUshort(sc, 0x05, 0x8330);
+                        MP_WritePhyUshort(sc, 0x06, 0x669A);
+
+                        MP_WritePhyUshort(sc, 0x1F, 0x0002);
+                        Data = MP_ReadPhyUshort(sc, 0x0D);
+                        if ((Data & 0x00FF) != 0x006C) {
+                                Data &= 0xFF00;
+                                MP_WritePhyUshort(sc, 0x1F, 0x0002);
+                                MP_WritePhyUshort(sc, 0x0D, Data | 0x0065);
+                                MP_WritePhyUshort(sc, 0x0D, Data | 0x0066);
+                                MP_WritePhyUshort(sc, 0x0D, Data | 0x0067);
+                                MP_WritePhyUshort(sc, 0x0D, Data | 0x0068);
+                                MP_WritePhyUshort(sc, 0x0D, Data | 0x0069);
+                                MP_WritePhyUshort(sc, 0x0D, Data | 0x006A);
+                                MP_WritePhyUshort(sc, 0x0D, Data | 0x006B);
+                                MP_WritePhyUshort(sc, 0x0D, Data | 0x006C);
+                        }
+                } else {
+                        MP_WritePhyUshort(sc, 0x1F, 0x0002);
+                        MP_WritePhyUshort(sc, 0x05, 0x6662);
+                        MP_WritePhyUshort(sc, 0x1F, 0x0005);
+                        MP_WritePhyUshort(sc, 0x05, 0x8330);
+                        MP_WritePhyUshort(sc, 0x06, 0x6662);
+                }
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0002);
+                Data = MP_ReadPhyUshort(sc, 0x0D);
+                Data |= 0x300;
+                MP_WritePhyUshort(sc, 0x0D, Data);
+                Data = MP_ReadPhyUshort(sc, 0x0F);
+                Data |= 0x10;
+                MP_WritePhyUshort(sc, 0x0F, Data);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0002);
+                Data = MP_ReadPhyUshort(sc, 0x02);
+                Data &= ~0x600;
+                Data |= 0x100;
+                MP_WritePhyUshort(sc, 0x02, Data);
+                Data = MP_ReadPhyUshort(sc, 0x03);
+                Data &= ~0xE000;
+                MP_WritePhyUshort(sc, 0x03, Data);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0001);
+                MP_WritePhyUshort(sc, 0x17, 0x0CC0);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0005);
+                MP_WritePhyUshort(sc, 0x05, 0x001B);
+                if (MP_ReadPhyUshort(sc, 0x06) == 0xBF00) {
+                        MP_WritePhyUshort(sc, 0x1f, 0x0005);
+                        MP_WritePhyUshort(sc, 0x05, 0xfff6);
+                        MP_WritePhyUshort(sc, 0x06, 0x0080);
+                        MP_WritePhyUshort(sc, 0x05, 0x8000);
+                        MP_WritePhyUshort(sc, 0x06, 0xf8f9);
+                        MP_WritePhyUshort(sc, 0x06, 0xfaef);
+                        MP_WritePhyUshort(sc, 0x06, 0x59ee);
+                        MP_WritePhyUshort(sc, 0x06, 0xf8ea);
+                        MP_WritePhyUshort(sc, 0x06, 0x00ee);
+                        MP_WritePhyUshort(sc, 0x06, 0xf8eb);
+                        MP_WritePhyUshort(sc, 0x06, 0x00e0);
+                        MP_WritePhyUshort(sc, 0x06, 0xf87c);
+                        MP_WritePhyUshort(sc, 0x06, 0xe1f8);
+                        MP_WritePhyUshort(sc, 0x06, 0x7d59);
+                        MP_WritePhyUshort(sc, 0x06, 0x0fef);
+                        MP_WritePhyUshort(sc, 0x06, 0x0139);
+                        MP_WritePhyUshort(sc, 0x06, 0x029e);
+                        MP_WritePhyUshort(sc, 0x06, 0x06ef);
+                        MP_WritePhyUshort(sc, 0x06, 0x1039);
+                        MP_WritePhyUshort(sc, 0x06, 0x089f);
+                        MP_WritePhyUshort(sc, 0x06, 0x2aee);
+                        MP_WritePhyUshort(sc, 0x06, 0xf8ea);
+                        MP_WritePhyUshort(sc, 0x06, 0x00ee);
+                        MP_WritePhyUshort(sc, 0x06, 0xf8eb);
+                        MP_WritePhyUshort(sc, 0x06, 0x01e0);
+                        MP_WritePhyUshort(sc, 0x06, 0xf87c);
+                        MP_WritePhyUshort(sc, 0x06, 0xe1f8);
+                        MP_WritePhyUshort(sc, 0x06, 0x7d58);
+                        MP_WritePhyUshort(sc, 0x06, 0x409e);
+                        MP_WritePhyUshort(sc, 0x06, 0x0f39);
+                        MP_WritePhyUshort(sc, 0x06, 0x46aa);
+                        MP_WritePhyUshort(sc, 0x06, 0x0bbf);
+                        MP_WritePhyUshort(sc, 0x06, 0x8290);
+                        MP_WritePhyUshort(sc, 0x06, 0xd682);
+                        MP_WritePhyUshort(sc, 0x06, 0x9802);
+                        MP_WritePhyUshort(sc, 0x06, 0x014f);
+                        MP_WritePhyUshort(sc, 0x06, 0xae09);
+                        MP_WritePhyUshort(sc, 0x06, 0xbf82);
+                        MP_WritePhyUshort(sc, 0x06, 0x98d6);
+                        MP_WritePhyUshort(sc, 0x06, 0x82a0);
+                        MP_WritePhyUshort(sc, 0x06, 0x0201);
+                        MP_WritePhyUshort(sc, 0x06, 0x4fef);
+                        MP_WritePhyUshort(sc, 0x06, 0x95fe);
+                        MP_WritePhyUshort(sc, 0x06, 0xfdfc);
+                        MP_WritePhyUshort(sc, 0x06, 0x05f8);
+                        MP_WritePhyUshort(sc, 0x06, 0xf9fa);
+                        MP_WritePhyUshort(sc, 0x06, 0xeef8);
+                        MP_WritePhyUshort(sc, 0x06, 0xea00);
+                        MP_WritePhyUshort(sc, 0x06, 0xeef8);
+                        MP_WritePhyUshort(sc, 0x06, 0xeb00);
+                        MP_WritePhyUshort(sc, 0x06, 0xe2f8);
+                        MP_WritePhyUshort(sc, 0x06, 0x7ce3);
+                        MP_WritePhyUshort(sc, 0x06, 0xf87d);
+                        MP_WritePhyUshort(sc, 0x06, 0xa511);
+                        MP_WritePhyUshort(sc, 0x06, 0x1112);
+                        MP_WritePhyUshort(sc, 0x06, 0xd240);
+                        MP_WritePhyUshort(sc, 0x06, 0xd644);
+                        MP_WritePhyUshort(sc, 0x06, 0x4402);
+                        MP_WritePhyUshort(sc, 0x06, 0x8217);
+                        MP_WritePhyUshort(sc, 0x06, 0xd2a0);
+                        MP_WritePhyUshort(sc, 0x06, 0xd6aa);
+                        MP_WritePhyUshort(sc, 0x06, 0xaa02);
+                        MP_WritePhyUshort(sc, 0x06, 0x8217);
+                        MP_WritePhyUshort(sc, 0x06, 0xae0f);
+                        MP_WritePhyUshort(sc, 0x06, 0xa544);
+                        MP_WritePhyUshort(sc, 0x06, 0x4402);
+                        MP_WritePhyUshort(sc, 0x06, 0xae4d);
+                        MP_WritePhyUshort(sc, 0x06, 0xa5aa);
+                        MP_WritePhyUshort(sc, 0x06, 0xaa02);
+                        MP_WritePhyUshort(sc, 0x06, 0xae47);
+                        MP_WritePhyUshort(sc, 0x06, 0xaf82);
+                        MP_WritePhyUshort(sc, 0x06, 0x13ee);
+                        MP_WritePhyUshort(sc, 0x06, 0x834e);
+                        MP_WritePhyUshort(sc, 0x06, 0x00ee);
+                        MP_WritePhyUshort(sc, 0x06, 0x834d);
+                        MP_WritePhyUshort(sc, 0x06, 0x0fee);
+                        MP_WritePhyUshort(sc, 0x06, 0x834c);
+                        MP_WritePhyUshort(sc, 0x06, 0x0fee);
+                        MP_WritePhyUshort(sc, 0x06, 0x834f);
+                        MP_WritePhyUshort(sc, 0x06, 0x00ee);
+                        MP_WritePhyUshort(sc, 0x06, 0x8351);
+                        MP_WritePhyUshort(sc, 0x06, 0x00ee);
+                        MP_WritePhyUshort(sc, 0x06, 0x834a);
+                        MP_WritePhyUshort(sc, 0x06, 0xffee);
+                        MP_WritePhyUshort(sc, 0x06, 0x834b);
+                        MP_WritePhyUshort(sc, 0x06, 0xffe0);
+                        MP_WritePhyUshort(sc, 0x06, 0x8330);
+                        MP_WritePhyUshort(sc, 0x06, 0xe183);
+                        MP_WritePhyUshort(sc, 0x06, 0x3158);
+                        MP_WritePhyUshort(sc, 0x06, 0xfee4);
+                        MP_WritePhyUshort(sc, 0x06, 0xf88a);
+                        MP_WritePhyUshort(sc, 0x06, 0xe5f8);
+                        MP_WritePhyUshort(sc, 0x06, 0x8be0);
+                        MP_WritePhyUshort(sc, 0x06, 0x8332);
+                        MP_WritePhyUshort(sc, 0x06, 0xe183);
+                        MP_WritePhyUshort(sc, 0x06, 0x3359);
+                        MP_WritePhyUshort(sc, 0x06, 0x0fe2);
+                        MP_WritePhyUshort(sc, 0x06, 0x834d);
+                        MP_WritePhyUshort(sc, 0x06, 0x0c24);
+                        MP_WritePhyUshort(sc, 0x06, 0x5af0);
+                        MP_WritePhyUshort(sc, 0x06, 0x1e12);
+                        MP_WritePhyUshort(sc, 0x06, 0xe4f8);
+                        MP_WritePhyUshort(sc, 0x06, 0x8ce5);
+                        MP_WritePhyUshort(sc, 0x06, 0xf88d);
+                        MP_WritePhyUshort(sc, 0x06, 0xaf82);
+                        MP_WritePhyUshort(sc, 0x06, 0x13e0);
+                        MP_WritePhyUshort(sc, 0x06, 0x834f);
+                        MP_WritePhyUshort(sc, 0x06, 0x10e4);
+                        MP_WritePhyUshort(sc, 0x06, 0x834f);
+                        MP_WritePhyUshort(sc, 0x06, 0xe083);
+                        MP_WritePhyUshort(sc, 0x06, 0x4e78);
+                        MP_WritePhyUshort(sc, 0x06, 0x009f);
+                        MP_WritePhyUshort(sc, 0x06, 0x0ae0);
+                        MP_WritePhyUshort(sc, 0x06, 0x834f);
+                        MP_WritePhyUshort(sc, 0x06, 0xa010);
+                        MP_WritePhyUshort(sc, 0x06, 0xa5ee);
+                        MP_WritePhyUshort(sc, 0x06, 0x834e);
+                        MP_WritePhyUshort(sc, 0x06, 0x01e0);
+                        MP_WritePhyUshort(sc, 0x06, 0x834e);
+                        MP_WritePhyUshort(sc, 0x06, 0x7805);
+                        MP_WritePhyUshort(sc, 0x06, 0x9e9a);
+                        MP_WritePhyUshort(sc, 0x06, 0xe083);
+                        MP_WritePhyUshort(sc, 0x06, 0x4e78);
+                        MP_WritePhyUshort(sc, 0x06, 0x049e);
+                        MP_WritePhyUshort(sc, 0x06, 0x10e0);
+                        MP_WritePhyUshort(sc, 0x06, 0x834e);
+                        MP_WritePhyUshort(sc, 0x06, 0x7803);
+                        MP_WritePhyUshort(sc, 0x06, 0x9e0f);
+                        MP_WritePhyUshort(sc, 0x06, 0xe083);
+                        MP_WritePhyUshort(sc, 0x06, 0x4e78);
+                        MP_WritePhyUshort(sc, 0x06, 0x019e);
+                        MP_WritePhyUshort(sc, 0x06, 0x05ae);
+                        MP_WritePhyUshort(sc, 0x06, 0x0caf);
+                        MP_WritePhyUshort(sc, 0x06, 0x81f8);
+                        MP_WritePhyUshort(sc, 0x06, 0xaf81);
+                        MP_WritePhyUshort(sc, 0x06, 0xa3af);
+                        MP_WritePhyUshort(sc, 0x06, 0x81dc);
+                        MP_WritePhyUshort(sc, 0x06, 0xaf82);
+                        MP_WritePhyUshort(sc, 0x06, 0x13ee);
+                        MP_WritePhyUshort(sc, 0x06, 0x8348);
+                        MP_WritePhyUshort(sc, 0x06, 0x00ee);
+                        MP_WritePhyUshort(sc, 0x06, 0x8349);
+                        MP_WritePhyUshort(sc, 0x06, 0x00e0);
+                        MP_WritePhyUshort(sc, 0x06, 0x8351);
+                        MP_WritePhyUshort(sc, 0x06, 0x10e4);
+                        MP_WritePhyUshort(sc, 0x06, 0x8351);
+                        MP_WritePhyUshort(sc, 0x06, 0x5801);
+                        MP_WritePhyUshort(sc, 0x06, 0x9fea);
+                        MP_WritePhyUshort(sc, 0x06, 0xd000);
+                        MP_WritePhyUshort(sc, 0x06, 0xd180);
+                        MP_WritePhyUshort(sc, 0x06, 0x1f66);
+                        MP_WritePhyUshort(sc, 0x06, 0xe2f8);
+                        MP_WritePhyUshort(sc, 0x06, 0xeae3);
+                        MP_WritePhyUshort(sc, 0x06, 0xf8eb);
+                        MP_WritePhyUshort(sc, 0x06, 0x5af8);
+                        MP_WritePhyUshort(sc, 0x06, 0x1e20);
+                        MP_WritePhyUshort(sc, 0x06, 0xe6f8);
+                        MP_WritePhyUshort(sc, 0x06, 0xeae5);
+                        MP_WritePhyUshort(sc, 0x06, 0xf8eb);
+                        MP_WritePhyUshort(sc, 0x06, 0xd302);
+                        MP_WritePhyUshort(sc, 0x06, 0xb3fe);
+                        MP_WritePhyUshort(sc, 0x06, 0xe2f8);
+                        MP_WritePhyUshort(sc, 0x06, 0x7cef);
+                        MP_WritePhyUshort(sc, 0x06, 0x325b);
+                        MP_WritePhyUshort(sc, 0x06, 0x80e3);
+                        MP_WritePhyUshort(sc, 0x06, 0xf87d);
+                        MP_WritePhyUshort(sc, 0x06, 0x9e03);
+                        MP_WritePhyUshort(sc, 0x06, 0x7dff);
+                        MP_WritePhyUshort(sc, 0x06, 0xff0d);
+                        MP_WritePhyUshort(sc, 0x06, 0x581c);
+                        MP_WritePhyUshort(sc, 0x06, 0x551a);
+                        MP_WritePhyUshort(sc, 0x06, 0x6511);
+                        MP_WritePhyUshort(sc, 0x06, 0xa190);
+                        MP_WritePhyUshort(sc, 0x06, 0xd3e2);
+                        MP_WritePhyUshort(sc, 0x06, 0x8348);
+                        MP_WritePhyUshort(sc, 0x06, 0xe383);
+                        MP_WritePhyUshort(sc, 0x06, 0x491b);
+                        MP_WritePhyUshort(sc, 0x06, 0x56ab);
+                        MP_WritePhyUshort(sc, 0x06, 0x08ef);
+                        MP_WritePhyUshort(sc, 0x06, 0x56e6);
+                        MP_WritePhyUshort(sc, 0x06, 0x8348);
+                        MP_WritePhyUshort(sc, 0x06, 0xe783);
+                        MP_WritePhyUshort(sc, 0x06, 0x4910);
+                        MP_WritePhyUshort(sc, 0x06, 0xd180);
+                        MP_WritePhyUshort(sc, 0x06, 0x1f66);
+                        MP_WritePhyUshort(sc, 0x06, 0xa004);
+                        MP_WritePhyUshort(sc, 0x06, 0xb9e2);
+                        MP_WritePhyUshort(sc, 0x06, 0x8348);
+                        MP_WritePhyUshort(sc, 0x06, 0xe383);
+                        MP_WritePhyUshort(sc, 0x06, 0x49ef);
+                        MP_WritePhyUshort(sc, 0x06, 0x65e2);
+                        MP_WritePhyUshort(sc, 0x06, 0x834a);
+                        MP_WritePhyUshort(sc, 0x06, 0xe383);
+                        MP_WritePhyUshort(sc, 0x06, 0x4b1b);
+                        MP_WritePhyUshort(sc, 0x06, 0x56aa);
+                        MP_WritePhyUshort(sc, 0x06, 0x0eef);
+                        MP_WritePhyUshort(sc, 0x06, 0x56e6);
+                        MP_WritePhyUshort(sc, 0x06, 0x834a);
+                        MP_WritePhyUshort(sc, 0x06, 0xe783);
+                        MP_WritePhyUshort(sc, 0x06, 0x4be2);
+                        MP_WritePhyUshort(sc, 0x06, 0x834d);
+                        MP_WritePhyUshort(sc, 0x06, 0xe683);
+                        MP_WritePhyUshort(sc, 0x06, 0x4ce0);
+                        MP_WritePhyUshort(sc, 0x06, 0x834d);
+                        MP_WritePhyUshort(sc, 0x06, 0xa000);
+                        MP_WritePhyUshort(sc, 0x06, 0x0caf);
+                        MP_WritePhyUshort(sc, 0x06, 0x81dc);
+                        MP_WritePhyUshort(sc, 0x06, 0xe083);
+                        MP_WritePhyUshort(sc, 0x06, 0x4d10);
+                        MP_WritePhyUshort(sc, 0x06, 0xe483);
+                        MP_WritePhyUshort(sc, 0x06, 0x4dae);
+                        MP_WritePhyUshort(sc, 0x06, 0x0480);
+                        MP_WritePhyUshort(sc, 0x06, 0xe483);
+                        MP_WritePhyUshort(sc, 0x06, 0x4de0);
+                        MP_WritePhyUshort(sc, 0x06, 0x834e);
+                        MP_WritePhyUshort(sc, 0x06, 0x7803);
+                        MP_WritePhyUshort(sc, 0x06, 0x9e0b);
+                        MP_WritePhyUshort(sc, 0x06, 0xe083);
+                        MP_WritePhyUshort(sc, 0x06, 0x4e78);
+                        MP_WritePhyUshort(sc, 0x06, 0x049e);
+                        MP_WritePhyUshort(sc, 0x06, 0x04ee);
+                        MP_WritePhyUshort(sc, 0x06, 0x834e);
+                        MP_WritePhyUshort(sc, 0x06, 0x02e0);
+                        MP_WritePhyUshort(sc, 0x06, 0x8332);
+                        MP_WritePhyUshort(sc, 0x06, 0xe183);
+                        MP_WritePhyUshort(sc, 0x06, 0x3359);
+                        MP_WritePhyUshort(sc, 0x06, 0x0fe2);
+                        MP_WritePhyUshort(sc, 0x06, 0x834d);
+                        MP_WritePhyUshort(sc, 0x06, 0x0c24);
+                        MP_WritePhyUshort(sc, 0x06, 0x5af0);
+                        MP_WritePhyUshort(sc, 0x06, 0x1e12);
+                        MP_WritePhyUshort(sc, 0x06, 0xe4f8);
+                        MP_WritePhyUshort(sc, 0x06, 0x8ce5);
+                        MP_WritePhyUshort(sc, 0x06, 0xf88d);
+                        MP_WritePhyUshort(sc, 0x06, 0xe083);
+                        MP_WritePhyUshort(sc, 0x06, 0x30e1);
+                        MP_WritePhyUshort(sc, 0x06, 0x8331);
+                        MP_WritePhyUshort(sc, 0x06, 0x6801);
+                        MP_WritePhyUshort(sc, 0x06, 0xe4f8);
+                        MP_WritePhyUshort(sc, 0x06, 0x8ae5);
+                        MP_WritePhyUshort(sc, 0x06, 0xf88b);
+                        MP_WritePhyUshort(sc, 0x06, 0xae37);
+                        MP_WritePhyUshort(sc, 0x06, 0xee83);
+                        MP_WritePhyUshort(sc, 0x06, 0x4e03);
+                        MP_WritePhyUshort(sc, 0x06, 0xe083);
+                        MP_WritePhyUshort(sc, 0x06, 0x4ce1);
+                        MP_WritePhyUshort(sc, 0x06, 0x834d);
+                        MP_WritePhyUshort(sc, 0x06, 0x1b01);
+                        MP_WritePhyUshort(sc, 0x06, 0x9e04);
+                        MP_WritePhyUshort(sc, 0x06, 0xaaa1);
+                        MP_WritePhyUshort(sc, 0x06, 0xaea8);
+                        MP_WritePhyUshort(sc, 0x06, 0xee83);
+                        MP_WritePhyUshort(sc, 0x06, 0x4e04);
+                        MP_WritePhyUshort(sc, 0x06, 0xee83);
+                        MP_WritePhyUshort(sc, 0x06, 0x4f00);
+                        MP_WritePhyUshort(sc, 0x06, 0xaeab);
+                        MP_WritePhyUshort(sc, 0x06, 0xe083);
+                        MP_WritePhyUshort(sc, 0x06, 0x4f78);
+                        MP_WritePhyUshort(sc, 0x06, 0x039f);
+                        MP_WritePhyUshort(sc, 0x06, 0x14ee);
+                        MP_WritePhyUshort(sc, 0x06, 0x834e);
+                        MP_WritePhyUshort(sc, 0x06, 0x05d2);
+                        MP_WritePhyUshort(sc, 0x06, 0x40d6);
+                        MP_WritePhyUshort(sc, 0x06, 0x5554);
+                        MP_WritePhyUshort(sc, 0x06, 0x0282);
+                        MP_WritePhyUshort(sc, 0x06, 0x17d2);
+                        MP_WritePhyUshort(sc, 0x06, 0xa0d6);
+                        MP_WritePhyUshort(sc, 0x06, 0xba00);
+                        MP_WritePhyUshort(sc, 0x06, 0x0282);
+                        MP_WritePhyUshort(sc, 0x06, 0x17fe);
+                        MP_WritePhyUshort(sc, 0x06, 0xfdfc);
+                        MP_WritePhyUshort(sc, 0x06, 0x05f8);
+                        MP_WritePhyUshort(sc, 0x06, 0xe0f8);
+                        MP_WritePhyUshort(sc, 0x06, 0x60e1);
+                        MP_WritePhyUshort(sc, 0x06, 0xf861);
+                        MP_WritePhyUshort(sc, 0x06, 0x6802);
+                        MP_WritePhyUshort(sc, 0x06, 0xe4f8);
+                        MP_WritePhyUshort(sc, 0x06, 0x60e5);
+                        MP_WritePhyUshort(sc, 0x06, 0xf861);
+                        MP_WritePhyUshort(sc, 0x06, 0xe0f8);
+                        MP_WritePhyUshort(sc, 0x06, 0x48e1);
+                        MP_WritePhyUshort(sc, 0x06, 0xf849);
+                        MP_WritePhyUshort(sc, 0x06, 0x580f);
+                        MP_WritePhyUshort(sc, 0x06, 0x1e02);
+                        MP_WritePhyUshort(sc, 0x06, 0xe4f8);
+                        MP_WritePhyUshort(sc, 0x06, 0x48e5);
+                        MP_WritePhyUshort(sc, 0x06, 0xf849);
+                        MP_WritePhyUshort(sc, 0x06, 0xd000);
+                        MP_WritePhyUshort(sc, 0x06, 0x0282);
+                        MP_WritePhyUshort(sc, 0x06, 0x5bbf);
+                        MP_WritePhyUshort(sc, 0x06, 0x8350);
+                        MP_WritePhyUshort(sc, 0x06, 0xef46);
+                        MP_WritePhyUshort(sc, 0x06, 0xdc19);
+                        MP_WritePhyUshort(sc, 0x06, 0xddd0);
+                        MP_WritePhyUshort(sc, 0x06, 0x0102);
+                        MP_WritePhyUshort(sc, 0x06, 0x825b);
+                        MP_WritePhyUshort(sc, 0x06, 0x0282);
+                        MP_WritePhyUshort(sc, 0x06, 0x77e0);
+                        MP_WritePhyUshort(sc, 0x06, 0xf860);
+                        MP_WritePhyUshort(sc, 0x06, 0xe1f8);
+                        MP_WritePhyUshort(sc, 0x06, 0x6158);
+                        MP_WritePhyUshort(sc, 0x06, 0xfde4);
+                        MP_WritePhyUshort(sc, 0x06, 0xf860);
+                        MP_WritePhyUshort(sc, 0x06, 0xe5f8);
+                        MP_WritePhyUshort(sc, 0x06, 0x61fc);
+                        MP_WritePhyUshort(sc, 0x06, 0x04f9);
+                        MP_WritePhyUshort(sc, 0x06, 0xfafb);
+                        MP_WritePhyUshort(sc, 0x06, 0xc6bf);
+                        MP_WritePhyUshort(sc, 0x06, 0xf840);
+                        MP_WritePhyUshort(sc, 0x06, 0xbe83);
+                        MP_WritePhyUshort(sc, 0x06, 0x50a0);
+                        MP_WritePhyUshort(sc, 0x06, 0x0101);
+                        MP_WritePhyUshort(sc, 0x06, 0x071b);
+                        MP_WritePhyUshort(sc, 0x06, 0x89cf);
+                        MP_WritePhyUshort(sc, 0x06, 0xd208);
+                        MP_WritePhyUshort(sc, 0x06, 0xebdb);
+                        MP_WritePhyUshort(sc, 0x06, 0x19b2);
+                        MP_WritePhyUshort(sc, 0x06, 0xfbff);
+                        MP_WritePhyUshort(sc, 0x06, 0xfefd);
+                        MP_WritePhyUshort(sc, 0x06, 0x04f8);
+                        MP_WritePhyUshort(sc, 0x06, 0xe0f8);
+                        MP_WritePhyUshort(sc, 0x06, 0x48e1);
+                        MP_WritePhyUshort(sc, 0x06, 0xf849);
+                        MP_WritePhyUshort(sc, 0x06, 0x6808);
+                        MP_WritePhyUshort(sc, 0x06, 0xe4f8);
+                        MP_WritePhyUshort(sc, 0x06, 0x48e5);
+                        MP_WritePhyUshort(sc, 0x06, 0xf849);
+                        MP_WritePhyUshort(sc, 0x06, 0x58f7);
+                        MP_WritePhyUshort(sc, 0x06, 0xe4f8);
+                        MP_WritePhyUshort(sc, 0x06, 0x48e5);
+                        MP_WritePhyUshort(sc, 0x06, 0xf849);
+                        MP_WritePhyUshort(sc, 0x06, 0xfc04);
+                        MP_WritePhyUshort(sc, 0x06, 0x4d20);
+                        MP_WritePhyUshort(sc, 0x06, 0x0002);
+                        MP_WritePhyUshort(sc, 0x06, 0x4e22);
+                        MP_WritePhyUshort(sc, 0x06, 0x0002);
+                        MP_WritePhyUshort(sc, 0x06, 0x4ddf);
+                        MP_WritePhyUshort(sc, 0x06, 0xff01);
+                        MP_WritePhyUshort(sc, 0x06, 0x4edd);
+                        MP_WritePhyUshort(sc, 0x06, 0xff01);
+                        MP_WritePhyUshort(sc, 0x06, 0xf8fa);
+                        MP_WritePhyUshort(sc, 0x06, 0xfbef);
+                        MP_WritePhyUshort(sc, 0x06, 0x79bf);
+                        MP_WritePhyUshort(sc, 0x06, 0xf822);
+                        MP_WritePhyUshort(sc, 0x06, 0xd819);
+                        MP_WritePhyUshort(sc, 0x06, 0xd958);
+                        MP_WritePhyUshort(sc, 0x06, 0x849f);
+                        MP_WritePhyUshort(sc, 0x06, 0x09bf);
+                        MP_WritePhyUshort(sc, 0x06, 0x82be);
+                        MP_WritePhyUshort(sc, 0x06, 0xd682);
+                        MP_WritePhyUshort(sc, 0x06, 0xc602);
+                        MP_WritePhyUshort(sc, 0x06, 0x014f);
+                        MP_WritePhyUshort(sc, 0x06, 0xef97);
+                        MP_WritePhyUshort(sc, 0x06, 0xfffe);
+                        MP_WritePhyUshort(sc, 0x06, 0xfc05);
+                        MP_WritePhyUshort(sc, 0x06, 0x17ff);
+                        MP_WritePhyUshort(sc, 0x06, 0xfe01);
+                        MP_WritePhyUshort(sc, 0x06, 0x1700);
+                        MP_WritePhyUshort(sc, 0x06, 0x0102);
+                        MP_WritePhyUshort(sc, 0x05, 0x83d8);
+                        MP_WritePhyUshort(sc, 0x06, 0x8051);
+                        MP_WritePhyUshort(sc, 0x05, 0x83d6);
+                        MP_WritePhyUshort(sc, 0x06, 0x82a0);
+                        MP_WritePhyUshort(sc, 0x05, 0x83d4);
+                        MP_WritePhyUshort(sc, 0x06, 0x8000);
+                        MP_WritePhyUshort(sc, 0x02, 0x2010);
+                        MP_WritePhyUshort(sc, 0x03, 0xdc00);
+                        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+                        MP_WritePhyUshort(sc, 0x0b, 0x0600);
+                        MP_WritePhyUshort(sc, 0x1f, 0x0005);
+                        MP_WritePhyUshort(sc, 0x05, 0xfff6);
+                        MP_WritePhyUshort(sc, 0x06, 0x00fc);
+                        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+                }
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+                MP_WritePhyUshort(sc, 0x0D, 0xF880);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+        } else if (sc->re_type == MACFG_32) {
+                MP_WritePhyUshort(sc, 0x1F, 0x0001);
+                MP_WritePhyUshort(sc, 0x06, 0x4064);
+                MP_WritePhyUshort(sc, 0x07, 0x2863);
+                MP_WritePhyUshort(sc, 0x08, 0x059C);
+                MP_WritePhyUshort(sc, 0x09, 0x26B4);
+                MP_WritePhyUshort(sc, 0x0A, 0x6A19);
+                MP_WritePhyUshort(sc, 0x0B, 0xBCC0);
+                MP_WritePhyUshort(sc, 0x10, 0xF06D);
+                MP_WritePhyUshort(sc, 0x14, 0x7F68);
+                MP_WritePhyUshort(sc, 0x18, 0x7FD9);
+                MP_WritePhyUshort(sc, 0x1C, 0xF0FF);
+                MP_WritePhyUshort(sc, 0x1D, 0x3D9C);
+                MP_WritePhyUshort(sc, 0x1F, 0x0003);
+                MP_WritePhyUshort(sc, 0x12, 0xF49F);
+                MP_WritePhyUshort(sc, 0x13, 0x070B);
+                MP_WritePhyUshort(sc, 0x1A, 0x05AD);
+                MP_WritePhyUshort(sc, 0x14, 0x94C0);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0002);
+                MP_WritePhyUshort(sc, 0x06, 0x5571);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0002);
+                MP_WritePhyUshort(sc, 0x05, 0x2642);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0002);
+                MP_WritePhyUshort(sc, 0x02, 0xC107);
+                MP_WritePhyUshort(sc, 0x03, 0x1002);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0001);
+                MP_WritePhyUshort(sc, 0x16, 0x0CC0);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0002);
+                MP_WritePhyUshort(sc, 0x0F, 0x0017);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0005);
+                MP_WritePhyUshort(sc, 0x05, 0x8200);
+                MP_WritePhyUshort(sc, 0x06, 0xF8F9);
+                MP_WritePhyUshort(sc, 0x06, 0xFAEF);
+                MP_WritePhyUshort(sc, 0x06, 0x59EE);
+                MP_WritePhyUshort(sc, 0x06, 0xF8EA);
+                MP_WritePhyUshort(sc, 0x06, 0x00EE);
+                MP_WritePhyUshort(sc, 0x06, 0xF8EB);
+                MP_WritePhyUshort(sc, 0x06, 0x00E0);
+                MP_WritePhyUshort(sc, 0x06, 0xF87C);
+                MP_WritePhyUshort(sc, 0x06, 0xE1F8);
+                MP_WritePhyUshort(sc, 0x06, 0x7D59);
+                MP_WritePhyUshort(sc, 0x06, 0x0FEF);
+                MP_WritePhyUshort(sc, 0x06, 0x0139);
+                MP_WritePhyUshort(sc, 0x06, 0x029E);
+                MP_WritePhyUshort(sc, 0x06, 0x06EF);
+                MP_WritePhyUshort(sc, 0x06, 0x1039);
+                MP_WritePhyUshort(sc, 0x06, 0x089F);
+                MP_WritePhyUshort(sc, 0x06, 0x2AEE);
+                MP_WritePhyUshort(sc, 0x06, 0xF8EA);
+                MP_WritePhyUshort(sc, 0x06, 0x00EE);
+                MP_WritePhyUshort(sc, 0x06, 0xF8EB);
+                MP_WritePhyUshort(sc, 0x06, 0x01E0);
+                MP_WritePhyUshort(sc, 0x06, 0xF87C);
+                MP_WritePhyUshort(sc, 0x06, 0xE1F8);
+                MP_WritePhyUshort(sc, 0x06, 0x7D58);
+                MP_WritePhyUshort(sc, 0x06, 0x409E);
+                MP_WritePhyUshort(sc, 0x06, 0x0F39);
+                MP_WritePhyUshort(sc, 0x06, 0x46AA);
+                MP_WritePhyUshort(sc, 0x06, 0x0BBF);
+                MP_WritePhyUshort(sc, 0x06, 0x8251);
+                MP_WritePhyUshort(sc, 0x06, 0xD682);
+                MP_WritePhyUshort(sc, 0x06, 0x5902);
+                MP_WritePhyUshort(sc, 0x06, 0x014F);
+                MP_WritePhyUshort(sc, 0x06, 0xAE09);
+                MP_WritePhyUshort(sc, 0x06, 0xBF82);
+                MP_WritePhyUshort(sc, 0x06, 0x59D6);
+                MP_WritePhyUshort(sc, 0x06, 0x8261);
+                MP_WritePhyUshort(sc, 0x06, 0x0201);
+                MP_WritePhyUshort(sc, 0x06, 0x4FEF);
+                MP_WritePhyUshort(sc, 0x06, 0x95FE);
+                MP_WritePhyUshort(sc, 0x06, 0xFDFC);
+                MP_WritePhyUshort(sc, 0x06, 0x054D);
+                MP_WritePhyUshort(sc, 0x06, 0x2000);
+                MP_WritePhyUshort(sc, 0x06, 0x024E);
+                MP_WritePhyUshort(sc, 0x06, 0x2200);
+                MP_WritePhyUshort(sc, 0x06, 0x024D);
+                MP_WritePhyUshort(sc, 0x06, 0xDFFF);
+                MP_WritePhyUshort(sc, 0x06, 0x014E);
+                MP_WritePhyUshort(sc, 0x06, 0xDDFF);
+                MP_WritePhyUshort(sc, 0x06, 0x0100);
+                MP_WritePhyUshort(sc, 0x02, 0x6010);
+                MP_WritePhyUshort(sc, 0x05, 0xFFF6);
+                MP_WritePhyUshort(sc, 0x06, 0x00EC);
+                MP_WritePhyUshort(sc, 0x05, 0x83D4);
+                MP_WritePhyUshort(sc, 0x06, 0x8200);
+
+        } else if (sc->re_type == MACFG_33) {
+                MP_WritePhyUshort(sc, 0x1F, 0x0001);
+                MP_WritePhyUshort(sc, 0x06, 0x4064);
+                MP_WritePhyUshort(sc, 0x07, 0x2863);
+                MP_WritePhyUshort(sc, 0x08, 0x059C);
+                MP_WritePhyUshort(sc, 0x09, 0x26B4);
+                MP_WritePhyUshort(sc, 0x0A, 0x6A19);
+                MP_WritePhyUshort(sc, 0x0B, 0xDCC8);
+                MP_WritePhyUshort(sc, 0x10, 0xF06D);
+                MP_WritePhyUshort(sc, 0x14, 0x7F68);
+                MP_WritePhyUshort(sc, 0x18, 0x7FD9);
+                MP_WritePhyUshort(sc, 0x1C, 0xF0FF);
+                MP_WritePhyUshort(sc, 0x1D, 0x3D9C);
+                MP_WritePhyUshort(sc, 0x1F, 0x0003);
+                MP_WritePhyUshort(sc, 0x12, 0xF49F);
+                MP_WritePhyUshort(sc, 0x13, 0x070B);
+                MP_WritePhyUshort(sc, 0x1A, 0x05AD);
+                MP_WritePhyUshort(sc, 0x14, 0x94C0);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0002);
+                MP_WritePhyUshort(sc, 0x06, 0x5561);
+                MP_WritePhyUshort(sc, 0x1F, 0x0005);
+                MP_WritePhyUshort(sc, 0x05, 0x8332);
+                MP_WritePhyUshort(sc, 0x06, 0x5561);
+
+                if (MP_ReadEfuse(sc, 0x01) == 0xb1) {
+                        MP_WritePhyUshort(sc, 0x1F, 0x0002);
+                        MP_WritePhyUshort(sc, 0x05, 0x669A);
+                        MP_WritePhyUshort(sc, 0x1F, 0x0005);
+                        MP_WritePhyUshort(sc, 0x05, 0x8330);
+                        MP_WritePhyUshort(sc, 0x06, 0x669A);
+
+                        MP_WritePhyUshort(sc, 0x1F, 0x0002);
+                        Data = MP_ReadPhyUshort(sc, 0x0D);
+                        if ((Data & 0x00FF) != 0x006C) {
+                                Data &= 0xFF00;
+                                MP_WritePhyUshort(sc, 0x1F, 0x0002);
+                                MP_WritePhyUshort(sc, 0x0D, Data | 0x0065);
+                                MP_WritePhyUshort(sc, 0x0D, Data | 0x0066);
+                                MP_WritePhyUshort(sc, 0x0D, Data | 0x0067);
+                                MP_WritePhyUshort(sc, 0x0D, Data | 0x0068);
+                                MP_WritePhyUshort(sc, 0x0D, Data | 0x0069);
+                                MP_WritePhyUshort(sc, 0x0D, Data | 0x006A);
+                                MP_WritePhyUshort(sc, 0x0D, Data | 0x006B);
+                                MP_WritePhyUshort(sc, 0x0D, Data | 0x006C);
+                        }
+                } else {
+                        MP_WritePhyUshort(sc, 0x1F, 0x0002);
+                        MP_WritePhyUshort(sc, 0x05, 0x2642);
+                        MP_WritePhyUshort(sc, 0x1F, 0x0005);
+                        MP_WritePhyUshort(sc, 0x05, 0x8330);
+                        MP_WritePhyUshort(sc, 0x06, 0x2642);
+                }
+
+                if (MP_ReadEfuse(sc, 0x30) == 0x98) {
+                        MP_WritePhyUshort(sc, 0x1F, 0x0000);
+                        MP_WritePhyUshort(sc, 0x11, MP_ReadPhyUshort(sc, 0x11) & ~0x02);
+                        MP_WritePhyUshort(sc, 0x1F, 0x0005);
+                        MP_WritePhyUshort(sc, 0x01, MP_ReadPhyUshort(sc, 0x01) | 0x200);
+                } else if (MP_ReadEfuse(sc, 0x30) == 0x90) {
+                        MP_WritePhyUshort(sc, 0x1F, 0x0005);
+                        MP_WritePhyUshort(sc, 0x01, MP_ReadPhyUshort(sc, 0x01) & ~0x200);
+                        MP_WritePhyUshort(sc, 0x1F, 0x0000);
+                        MP_WritePhyUshort(sc, 0x16, 0x5101);
+                }
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0002);
+                Data = MP_ReadPhyUshort(sc, 0x02);
+                Data &= ~0x600;
+                Data |= 0x100;
+                MP_WritePhyUshort(sc, 0x02, Data);
+                Data = MP_ReadPhyUshort(sc, 0x03);
+                Data &= ~0xE000;
+                MP_WritePhyUshort(sc, 0x03, Data);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0001);
+                MP_WritePhyUshort(sc, 0x17, 0x0CC0);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0002);
+                Data = MP_ReadPhyUshort(sc, 0x0F);
+                Data |= 0x17;
+                MP_WritePhyUshort(sc, 0x0F, Data);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0005);
+                MP_WritePhyUshort(sc, 0x05, 0x001B);
+                if (MP_ReadPhyUshort(sc, 0x06) == 0xB300) {
+                        MP_WritePhyUshort(sc, 0x1f, 0x0005);
+                        MP_WritePhyUshort(sc, 0x05, 0xfff6);
+                        MP_WritePhyUshort(sc, 0x06, 0x0080);
+                        MP_WritePhyUshort(sc, 0x05, 0x8000);
+                        MP_WritePhyUshort(sc, 0x06, 0xf8f9);
+                        MP_WritePhyUshort(sc, 0x06, 0xfaee);
+                        MP_WritePhyUshort(sc, 0x06, 0xf8ea);
+                        MP_WritePhyUshort(sc, 0x06, 0x00ee);
+                        MP_WritePhyUshort(sc, 0x06, 0xf8eb);
+                        MP_WritePhyUshort(sc, 0x06, 0x00e2);
+                        MP_WritePhyUshort(sc, 0x06, 0xf87c);
+                        MP_WritePhyUshort(sc, 0x06, 0xe3f8);
+                        MP_WritePhyUshort(sc, 0x06, 0x7da5);
+                        MP_WritePhyUshort(sc, 0x06, 0x1111);
+                        MP_WritePhyUshort(sc, 0x06, 0x12d2);
+                        MP_WritePhyUshort(sc, 0x06, 0x40d6);
+                        MP_WritePhyUshort(sc, 0x06, 0x4444);
+                        MP_WritePhyUshort(sc, 0x06, 0x0281);
+                        MP_WritePhyUshort(sc, 0x06, 0xc6d2);
+                        MP_WritePhyUshort(sc, 0x06, 0xa0d6);
+                        MP_WritePhyUshort(sc, 0x06, 0xaaaa);
+                        MP_WritePhyUshort(sc, 0x06, 0x0281);
+                        MP_WritePhyUshort(sc, 0x06, 0xc6ae);
+                        MP_WritePhyUshort(sc, 0x06, 0x0fa5);
+                        MP_WritePhyUshort(sc, 0x06, 0x4444);
+                        MP_WritePhyUshort(sc, 0x06, 0x02ae);
+                        MP_WritePhyUshort(sc, 0x06, 0x4da5);
+                        MP_WritePhyUshort(sc, 0x06, 0xaaaa);
+                        MP_WritePhyUshort(sc, 0x06, 0x02ae);
+                        MP_WritePhyUshort(sc, 0x06, 0x47af);
+                        MP_WritePhyUshort(sc, 0x06, 0x81c2);
+                        MP_WritePhyUshort(sc, 0x06, 0xee83);
+                        MP_WritePhyUshort(sc, 0x06, 0x4e00);
+                        MP_WritePhyUshort(sc, 0x06, 0xee83);
+                        MP_WritePhyUshort(sc, 0x06, 0x4d0f);
+                        MP_WritePhyUshort(sc, 0x06, 0xee83);
+                        MP_WritePhyUshort(sc, 0x06, 0x4c0f);
+                        MP_WritePhyUshort(sc, 0x06, 0xee83);
+                        MP_WritePhyUshort(sc, 0x06, 0x4f00);
+                        MP_WritePhyUshort(sc, 0x06, 0xee83);
+                        MP_WritePhyUshort(sc, 0x06, 0x5100);
+                        MP_WritePhyUshort(sc, 0x06, 0xee83);
+                        MP_WritePhyUshort(sc, 0x06, 0x4aff);
+                        MP_WritePhyUshort(sc, 0x06, 0xee83);
+                        MP_WritePhyUshort(sc, 0x06, 0x4bff);
+                        MP_WritePhyUshort(sc, 0x06, 0xe083);
+                        MP_WritePhyUshort(sc, 0x06, 0x30e1);
+                        MP_WritePhyUshort(sc, 0x06, 0x8331);
+                        MP_WritePhyUshort(sc, 0x06, 0x58fe);
+                        MP_WritePhyUshort(sc, 0x06, 0xe4f8);
+                        MP_WritePhyUshort(sc, 0x06, 0x8ae5);
+                        MP_WritePhyUshort(sc, 0x06, 0xf88b);
+                        MP_WritePhyUshort(sc, 0x06, 0xe083);
+                        MP_WritePhyUshort(sc, 0x06, 0x32e1);
+                        MP_WritePhyUshort(sc, 0x06, 0x8333);
+                        MP_WritePhyUshort(sc, 0x06, 0x590f);
+                        MP_WritePhyUshort(sc, 0x06, 0xe283);
+                        MP_WritePhyUshort(sc, 0x06, 0x4d0c);
+                        MP_WritePhyUshort(sc, 0x06, 0x245a);
+                        MP_WritePhyUshort(sc, 0x06, 0xf01e);
+                        MP_WritePhyUshort(sc, 0x06, 0x12e4);
+                        MP_WritePhyUshort(sc, 0x06, 0xf88c);
+                        MP_WritePhyUshort(sc, 0x06, 0xe5f8);
+                        MP_WritePhyUshort(sc, 0x06, 0x8daf);
+                        MP_WritePhyUshort(sc, 0x06, 0x81c2);
+                        MP_WritePhyUshort(sc, 0x06, 0xe083);
+                        MP_WritePhyUshort(sc, 0x06, 0x4f10);
+                        MP_WritePhyUshort(sc, 0x06, 0xe483);
+                        MP_WritePhyUshort(sc, 0x06, 0x4fe0);
+                        MP_WritePhyUshort(sc, 0x06, 0x834e);
+                        MP_WritePhyUshort(sc, 0x06, 0x7800);
+                        MP_WritePhyUshort(sc, 0x06, 0x9f0a);
+                        MP_WritePhyUshort(sc, 0x06, 0xe083);
+                        MP_WritePhyUshort(sc, 0x06, 0x4fa0);
+                        MP_WritePhyUshort(sc, 0x06, 0x10a5);
+                        MP_WritePhyUshort(sc, 0x06, 0xee83);
+                        MP_WritePhyUshort(sc, 0x06, 0x4e01);
+                        MP_WritePhyUshort(sc, 0x06, 0xe083);
+                        MP_WritePhyUshort(sc, 0x06, 0x4e78);
+                        MP_WritePhyUshort(sc, 0x06, 0x059e);
+                        MP_WritePhyUshort(sc, 0x06, 0x9ae0);
+                        MP_WritePhyUshort(sc, 0x06, 0x834e);
+                        MP_WritePhyUshort(sc, 0x06, 0x7804);
+                        MP_WritePhyUshort(sc, 0x06, 0x9e10);
+                        MP_WritePhyUshort(sc, 0x06, 0xe083);
+                        MP_WritePhyUshort(sc, 0x06, 0x4e78);
+                        MP_WritePhyUshort(sc, 0x06, 0x039e);
+                        MP_WritePhyUshort(sc, 0x06, 0x0fe0);
+                        MP_WritePhyUshort(sc, 0x06, 0x834e);
+                        MP_WritePhyUshort(sc, 0x06, 0x7801);
+                        MP_WritePhyUshort(sc, 0x06, 0x9e05);
+                        MP_WritePhyUshort(sc, 0x06, 0xae0c);
+                        MP_WritePhyUshort(sc, 0x06, 0xaf81);
+                        MP_WritePhyUshort(sc, 0x06, 0xa7af);
+                        MP_WritePhyUshort(sc, 0x06, 0x8152);
+                        MP_WritePhyUshort(sc, 0x06, 0xaf81);
+                        MP_WritePhyUshort(sc, 0x06, 0x8baf);
+                        MP_WritePhyUshort(sc, 0x06, 0x81c2);
+                        MP_WritePhyUshort(sc, 0x06, 0xee83);
+                        MP_WritePhyUshort(sc, 0x06, 0x4800);
+                        MP_WritePhyUshort(sc, 0x06, 0xee83);
+                        MP_WritePhyUshort(sc, 0x06, 0x4900);
+                        MP_WritePhyUshort(sc, 0x06, 0xe083);
+                        MP_WritePhyUshort(sc, 0x06, 0x5110);
+                        MP_WritePhyUshort(sc, 0x06, 0xe483);
+                        MP_WritePhyUshort(sc, 0x06, 0x5158);
+                        MP_WritePhyUshort(sc, 0x06, 0x019f);
+                        MP_WritePhyUshort(sc, 0x06, 0xead0);
+                        MP_WritePhyUshort(sc, 0x06, 0x00d1);
+                        MP_WritePhyUshort(sc, 0x06, 0x801f);
+                        MP_WritePhyUshort(sc, 0x06, 0x66e2);
+                        MP_WritePhyUshort(sc, 0x06, 0xf8ea);
+                        MP_WritePhyUshort(sc, 0x06, 0xe3f8);
+                        MP_WritePhyUshort(sc, 0x06, 0xeb5a);
+                        MP_WritePhyUshort(sc, 0x06, 0xf81e);
+                        MP_WritePhyUshort(sc, 0x06, 0x20e6);
+                        MP_WritePhyUshort(sc, 0x06, 0xf8ea);
+                        MP_WritePhyUshort(sc, 0x06, 0xe5f8);
+                        MP_WritePhyUshort(sc, 0x06, 0xebd3);
+                        MP_WritePhyUshort(sc, 0x06, 0x02b3);
+                        MP_WritePhyUshort(sc, 0x06, 0xfee2);
+                        MP_WritePhyUshort(sc, 0x06, 0xf87c);
+                        MP_WritePhyUshort(sc, 0x06, 0xef32);
+                        MP_WritePhyUshort(sc, 0x06, 0x5b80);
+                        MP_WritePhyUshort(sc, 0x06, 0xe3f8);
+                        MP_WritePhyUshort(sc, 0x06, 0x7d9e);
+                        MP_WritePhyUshort(sc, 0x06, 0x037d);
+                        MP_WritePhyUshort(sc, 0x06, 0xffff);
+                        MP_WritePhyUshort(sc, 0x06, 0x0d58);
+                        MP_WritePhyUshort(sc, 0x06, 0x1c55);
+                        MP_WritePhyUshort(sc, 0x06, 0x1a65);
+                        MP_WritePhyUshort(sc, 0x06, 0x11a1);
+                        MP_WritePhyUshort(sc, 0x06, 0x90d3);
+                        MP_WritePhyUshort(sc, 0x06, 0xe283);
+                        MP_WritePhyUshort(sc, 0x06, 0x48e3);
+                        MP_WritePhyUshort(sc, 0x06, 0x8349);
+                        MP_WritePhyUshort(sc, 0x06, 0x1b56);
+                        MP_WritePhyUshort(sc, 0x06, 0xab08);
+                        MP_WritePhyUshort(sc, 0x06, 0xef56);
+                        MP_WritePhyUshort(sc, 0x06, 0xe683);
+                        MP_WritePhyUshort(sc, 0x06, 0x48e7);
+                        MP_WritePhyUshort(sc, 0x06, 0x8349);
+                        MP_WritePhyUshort(sc, 0x06, 0x10d1);
+                        MP_WritePhyUshort(sc, 0x06, 0x801f);
+                        MP_WritePhyUshort(sc, 0x06, 0x66a0);
+                        MP_WritePhyUshort(sc, 0x06, 0x04b9);
+                        MP_WritePhyUshort(sc, 0x06, 0xe283);
+                        MP_WritePhyUshort(sc, 0x06, 0x48e3);
+                        MP_WritePhyUshort(sc, 0x06, 0x8349);
+                        MP_WritePhyUshort(sc, 0x06, 0xef65);
+                        MP_WritePhyUshort(sc, 0x06, 0xe283);
+                        MP_WritePhyUshort(sc, 0x06, 0x4ae3);
+                        MP_WritePhyUshort(sc, 0x06, 0x834b);
+                        MP_WritePhyUshort(sc, 0x06, 0x1b56);
+                        MP_WritePhyUshort(sc, 0x06, 0xaa0e);
+                        MP_WritePhyUshort(sc, 0x06, 0xef56);
+                        MP_WritePhyUshort(sc, 0x06, 0xe683);
+                        MP_WritePhyUshort(sc, 0x06, 0x4ae7);
+                        MP_WritePhyUshort(sc, 0x06, 0x834b);
+                        MP_WritePhyUshort(sc, 0x06, 0xe283);
+                        MP_WritePhyUshort(sc, 0x06, 0x4de6);
+                        MP_WritePhyUshort(sc, 0x06, 0x834c);
+                        MP_WritePhyUshort(sc, 0x06, 0xe083);
+                        MP_WritePhyUshort(sc, 0x06, 0x4da0);
+                        MP_WritePhyUshort(sc, 0x06, 0x000c);
+                        MP_WritePhyUshort(sc, 0x06, 0xaf81);
+                        MP_WritePhyUshort(sc, 0x06, 0x8be0);
+                        MP_WritePhyUshort(sc, 0x06, 0x834d);
+                        MP_WritePhyUshort(sc, 0x06, 0x10e4);
+                        MP_WritePhyUshort(sc, 0x06, 0x834d);
+                        MP_WritePhyUshort(sc, 0x06, 0xae04);
+                        MP_WritePhyUshort(sc, 0x06, 0x80e4);
+                        MP_WritePhyUshort(sc, 0x06, 0x834d);
+                        MP_WritePhyUshort(sc, 0x06, 0xe083);
+                        MP_WritePhyUshort(sc, 0x06, 0x4e78);
+                        MP_WritePhyUshort(sc, 0x06, 0x039e);
+                        MP_WritePhyUshort(sc, 0x06, 0x0be0);
+                        MP_WritePhyUshort(sc, 0x06, 0x834e);
+                        MP_WritePhyUshort(sc, 0x06, 0x7804);
+                        MP_WritePhyUshort(sc, 0x06, 0x9e04);
+                        MP_WritePhyUshort(sc, 0x06, 0xee83);
+                        MP_WritePhyUshort(sc, 0x06, 0x4e02);
+                        MP_WritePhyUshort(sc, 0x06, 0xe083);
+                        MP_WritePhyUshort(sc, 0x06, 0x32e1);
+                        MP_WritePhyUshort(sc, 0x06, 0x8333);
+                        MP_WritePhyUshort(sc, 0x06, 0x590f);
+                        MP_WritePhyUshort(sc, 0x06, 0xe283);
+                        MP_WritePhyUshort(sc, 0x06, 0x4d0c);
+                        MP_WritePhyUshort(sc, 0x06, 0x245a);
+                        MP_WritePhyUshort(sc, 0x06, 0xf01e);
+                        MP_WritePhyUshort(sc, 0x06, 0x12e4);
+                        MP_WritePhyUshort(sc, 0x06, 0xf88c);
+                        MP_WritePhyUshort(sc, 0x06, 0xe5f8);
+                        MP_WritePhyUshort(sc, 0x06, 0x8de0);
+                        MP_WritePhyUshort(sc, 0x06, 0x8330);
+                        MP_WritePhyUshort(sc, 0x06, 0xe183);
+                        MP_WritePhyUshort(sc, 0x06, 0x3168);
+                        MP_WritePhyUshort(sc, 0x06, 0x01e4);
+                        MP_WritePhyUshort(sc, 0x06, 0xf88a);
+                        MP_WritePhyUshort(sc, 0x06, 0xe5f8);
+                        MP_WritePhyUshort(sc, 0x06, 0x8bae);
+                        MP_WritePhyUshort(sc, 0x06, 0x37ee);
+                        MP_WritePhyUshort(sc, 0x06, 0x834e);
+                        MP_WritePhyUshort(sc, 0x06, 0x03e0);
+                        MP_WritePhyUshort(sc, 0x06, 0x834c);
+                        MP_WritePhyUshort(sc, 0x06, 0xe183);
+                        MP_WritePhyUshort(sc, 0x06, 0x4d1b);
+                        MP_WritePhyUshort(sc, 0x06, 0x019e);
+                        MP_WritePhyUshort(sc, 0x06, 0x04aa);
+                        MP_WritePhyUshort(sc, 0x06, 0xa1ae);
+                        MP_WritePhyUshort(sc, 0x06, 0xa8ee);
+                        MP_WritePhyUshort(sc, 0x06, 0x834e);
+                        MP_WritePhyUshort(sc, 0x06, 0x04ee);
+                        MP_WritePhyUshort(sc, 0x06, 0x834f);
+                        MP_WritePhyUshort(sc, 0x06, 0x00ae);
+                        MP_WritePhyUshort(sc, 0x06, 0xabe0);
+                        MP_WritePhyUshort(sc, 0x06, 0x834f);
+                        MP_WritePhyUshort(sc, 0x06, 0x7803);
+                        MP_WritePhyUshort(sc, 0x06, 0x9f14);
+                        MP_WritePhyUshort(sc, 0x06, 0xee83);
+                        MP_WritePhyUshort(sc, 0x06, 0x4e05);
+                        MP_WritePhyUshort(sc, 0x06, 0xd240);
+                        MP_WritePhyUshort(sc, 0x06, 0xd655);
+                        MP_WritePhyUshort(sc, 0x06, 0x5402);
+                        MP_WritePhyUshort(sc, 0x06, 0x81c6);
+                        MP_WritePhyUshort(sc, 0x06, 0xd2a0);
+                        MP_WritePhyUshort(sc, 0x06, 0xd6ba);
+                        MP_WritePhyUshort(sc, 0x06, 0x0002);
+                        MP_WritePhyUshort(sc, 0x06, 0x81c6);
+                        MP_WritePhyUshort(sc, 0x06, 0xfefd);
+                        MP_WritePhyUshort(sc, 0x06, 0xfc05);
+                        MP_WritePhyUshort(sc, 0x06, 0xf8e0);
+                        MP_WritePhyUshort(sc, 0x06, 0xf860);
+                        MP_WritePhyUshort(sc, 0x06, 0xe1f8);
+                        MP_WritePhyUshort(sc, 0x06, 0x6168);
+                        MP_WritePhyUshort(sc, 0x06, 0x02e4);
+                        MP_WritePhyUshort(sc, 0x06, 0xf860);
+                        MP_WritePhyUshort(sc, 0x06, 0xe5f8);
+                        MP_WritePhyUshort(sc, 0x06, 0x61e0);
+                        MP_WritePhyUshort(sc, 0x06, 0xf848);
+                        MP_WritePhyUshort(sc, 0x06, 0xe1f8);
+                        MP_WritePhyUshort(sc, 0x06, 0x4958);
+                        MP_WritePhyUshort(sc, 0x06, 0x0f1e);
+                        MP_WritePhyUshort(sc, 0x06, 0x02e4);
+                        MP_WritePhyUshort(sc, 0x06, 0xf848);
+                        MP_WritePhyUshort(sc, 0x06, 0xe5f8);
+                        MP_WritePhyUshort(sc, 0x06, 0x49d0);
+                        MP_WritePhyUshort(sc, 0x06, 0x0002);
+                        MP_WritePhyUshort(sc, 0x06, 0x820a);
+                        MP_WritePhyUshort(sc, 0x06, 0xbf83);
+                        MP_WritePhyUshort(sc, 0x06, 0x50ef);
+                        MP_WritePhyUshort(sc, 0x06, 0x46dc);
+                        MP_WritePhyUshort(sc, 0x06, 0x19dd);
+                        MP_WritePhyUshort(sc, 0x06, 0xd001);
+                        MP_WritePhyUshort(sc, 0x06, 0x0282);
+                        MP_WritePhyUshort(sc, 0x06, 0x0a02);
+                        MP_WritePhyUshort(sc, 0x06, 0x8226);
+                        MP_WritePhyUshort(sc, 0x06, 0xe0f8);
+                        MP_WritePhyUshort(sc, 0x06, 0x60e1);
+                        MP_WritePhyUshort(sc, 0x06, 0xf861);
+                        MP_WritePhyUshort(sc, 0x06, 0x58fd);
+                        MP_WritePhyUshort(sc, 0x06, 0xe4f8);
+                        MP_WritePhyUshort(sc, 0x06, 0x60e5);
+                        MP_WritePhyUshort(sc, 0x06, 0xf861);
+                        MP_WritePhyUshort(sc, 0x06, 0xfc04);
+                        MP_WritePhyUshort(sc, 0x06, 0xf9fa);
+                        MP_WritePhyUshort(sc, 0x06, 0xfbc6);
+                        MP_WritePhyUshort(sc, 0x06, 0xbff8);
+                        MP_WritePhyUshort(sc, 0x06, 0x40be);
+                        MP_WritePhyUshort(sc, 0x06, 0x8350);
+                        MP_WritePhyUshort(sc, 0x06, 0xa001);
+                        MP_WritePhyUshort(sc, 0x06, 0x0107);
+                        MP_WritePhyUshort(sc, 0x06, 0x1b89);
+                        MP_WritePhyUshort(sc, 0x06, 0xcfd2);
+                        MP_WritePhyUshort(sc, 0x06, 0x08eb);
+                        MP_WritePhyUshort(sc, 0x06, 0xdb19);
+                        MP_WritePhyUshort(sc, 0x06, 0xb2fb);
+                        MP_WritePhyUshort(sc, 0x06, 0xfffe);
+                        MP_WritePhyUshort(sc, 0x06, 0xfd04);
+                        MP_WritePhyUshort(sc, 0x06, 0xf8e0);
+                        MP_WritePhyUshort(sc, 0x06, 0xf848);
+                        MP_WritePhyUshort(sc, 0x06, 0xe1f8);
+                        MP_WritePhyUshort(sc, 0x06, 0x4968);
+                        MP_WritePhyUshort(sc, 0x06, 0x08e4);
+                        MP_WritePhyUshort(sc, 0x06, 0xf848);
+                        MP_WritePhyUshort(sc, 0x06, 0xe5f8);
+                        MP_WritePhyUshort(sc, 0x06, 0x4958);
+                        MP_WritePhyUshort(sc, 0x06, 0xf7e4);
+                        MP_WritePhyUshort(sc, 0x06, 0xf848);
+                        MP_WritePhyUshort(sc, 0x06, 0xe5f8);
+                        MP_WritePhyUshort(sc, 0x06, 0x49fc);
+                        MP_WritePhyUshort(sc, 0x06, 0x044d);
+                        MP_WritePhyUshort(sc, 0x06, 0x2000);
+                        MP_WritePhyUshort(sc, 0x06, 0x024e);
+                        MP_WritePhyUshort(sc, 0x06, 0x2200);
+                        MP_WritePhyUshort(sc, 0x06, 0x024d);
+                        MP_WritePhyUshort(sc, 0x06, 0xdfff);
+                        MP_WritePhyUshort(sc, 0x06, 0x014e);
+                        MP_WritePhyUshort(sc, 0x06, 0xddff);
+                        MP_WritePhyUshort(sc, 0x06, 0x01f8);
+                        MP_WritePhyUshort(sc, 0x06, 0xfafb);
+                        MP_WritePhyUshort(sc, 0x06, 0xef79);
+                        MP_WritePhyUshort(sc, 0x06, 0xbff8);
+                        MP_WritePhyUshort(sc, 0x06, 0x22d8);
+                        MP_WritePhyUshort(sc, 0x06, 0x19d9);
+                        MP_WritePhyUshort(sc, 0x06, 0x5884);
+                        MP_WritePhyUshort(sc, 0x06, 0x9f09);
+                        MP_WritePhyUshort(sc, 0x06, 0xbf82);
+                        MP_WritePhyUshort(sc, 0x06, 0x6dd6);
+                        MP_WritePhyUshort(sc, 0x06, 0x8275);
+                        MP_WritePhyUshort(sc, 0x06, 0x0201);
+                        MP_WritePhyUshort(sc, 0x06, 0x4fef);
+                        MP_WritePhyUshort(sc, 0x06, 0x97ff);
+                        MP_WritePhyUshort(sc, 0x06, 0xfefc);
+                        MP_WritePhyUshort(sc, 0x06, 0x0517);
+                        MP_WritePhyUshort(sc, 0x06, 0xfffe);
+                        MP_WritePhyUshort(sc, 0x06, 0x0117);
+                        MP_WritePhyUshort(sc, 0x06, 0x0001);
+                        MP_WritePhyUshort(sc, 0x06, 0x0200);
+                        MP_WritePhyUshort(sc, 0x05, 0x83d8);
+                        MP_WritePhyUshort(sc, 0x06, 0x8000);
+                        MP_WritePhyUshort(sc, 0x05, 0x83d6);
+                        MP_WritePhyUshort(sc, 0x06, 0x824f);
+                        MP_WritePhyUshort(sc, 0x02, 0x2010);
+                        MP_WritePhyUshort(sc, 0x03, 0xdc00);
+                        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+                        MP_WritePhyUshort(sc, 0x0b, 0x0600);
+                        MP_WritePhyUshort(sc, 0x1f, 0x0005);
+                        MP_WritePhyUshort(sc, 0x05, 0xfff6);
+                        MP_WritePhyUshort(sc, 0x06, 0x00fc);
+                        MP_WritePhyUshort(sc, 0x1f, 0x0000);
+                }
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+                MP_WritePhyUshort(sc, 0x0D, 0xF880);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+        } else if (sc->re_type == MACFG_36 || sc->re_type == MACFG_37) {
+                MP_WritePhyUshort(sc, 0x1F, 0x0007);
+                MP_WritePhyUshort(sc, 0x1E, 0x0023);
+                Data = MP_ReadPhyUshort(sc, 0x17) | 0x0006;
+                if (sc->RequiredSecLanDonglePatch)
+                        Data &= ~(BIT_2);
+                else
+                        Data |= (BIT_2);
+                MP_WritePhyUshort(sc, 0x17, Data);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1f, 0x0005);
+                MP_WritePhyUshort(sc, 0x05, 0x8b80);
+                MP_WritePhyUshort(sc, 0x06, 0xc896);
+                MP_WritePhyUshort(sc, 0x1f, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0001);
+                MP_WritePhyUshort(sc, 0x0B, 0x6C20);
+                MP_WritePhyUshort(sc, 0x07, 0x2872);
+                MP_WritePhyUshort(sc, 0x1C, 0xEFFF);
+                MP_WritePhyUshort(sc, 0x1F, 0x0003);
+                MP_WritePhyUshort(sc, 0x14, 0x6420);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0002);
+                Data = MP_ReadPhyUshort(sc, 0x08) & 0x00FF;
+                MP_WritePhyUshort(sc, 0x08, Data | 0x8000);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0007);
+                MP_WritePhyUshort(sc, 0x1E, 0x002D);
+                Data = MP_ReadPhyUshort(sc, 0x18);
+                MP_WritePhyUshort(sc, 0x18, Data | 0x0050);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+                Data = MP_ReadPhyUshort(sc, 0x14);
+                MP_WritePhyUshort(sc, 0x14, Data | 0x8000);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0002);
+                MP_WritePhyUshort(sc, 0x00, 0x080B);
+                MP_WritePhyUshort(sc, 0x0B, 0x09D7);
+                MP_WritePhyUshort(sc, 0x1f, 0x0000);
+                MP_WritePhyUshort(sc, 0x15, 0x1006);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0007);
+                MP_WritePhyUshort(sc, 0x1E, 0x002F);
+                MP_WritePhyUshort(sc, 0x15, 0x1919);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0003);
+                MP_WritePhyUshort(sc, 0x19, 0x7F46);
+                MP_WritePhyUshort(sc, 0x1F, 0x0005);
+                MP_WritePhyUshort(sc, 0x05, 0x8AD2);
+                MP_WritePhyUshort(sc, 0x06, 0x6810);
+                MP_WritePhyUshort(sc, 0x05, 0x8AD4);
+                MP_WritePhyUshort(sc, 0x06, 0x8002);
+                MP_WritePhyUshort(sc, 0x05, 0x8ADE);
+                MP_WritePhyUshort(sc, 0x06, 0x8025);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+        } else if (sc->re_type == MACFG_38) {
+                CSR_WRITE_1(sc, 0x6E, CSR_READ_1(sc, 0x6E)| (1<<6));
+
+                Data_u32 = re_eri_read(sc, 0x1D0, 4, ERIAR_ExGMAC);
+                Data_u32 &= ~BIT_1;
+                re_eri_write(sc, 0x1D0, 4, Data_u32, ERIAR_ExGMAC);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0005);
+                MP_WritePhyUshort(sc, 0x05, 0x8B80);
                 Data = MP_ReadPhyUshort(sc, 0x06);
-                Data |= BIT_0;
-                MP_WritePhyUshort(sc,0x06, Data);
+                Data |= BIT_2 | BIT_1;
+                MP_WritePhyUshort(sc, 0x06, Data);
                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                MP_WritePhyUshort(sc,0x1f, 0x0005);
-                for (i = 0; i < 200; i++) {
-                        DELAY(100);
-                        Data = MP_ReadPhyUshort(sc, 0x00);
-                        if (Data & BIT_7)
-                                break;
-                }
+
+                MP_WritePhyUshort(sc, 0x1f, 0x0004);
                 MP_WritePhyUshort(sc, 0x1f, 0x0007);
-                MP_WritePhyUshort(sc, 0x1e, 0x0023);
-                Data = MP_ReadPhyUshort(sc, 0x17);
-                Data |= BIT_1;
-                MP_WritePhyUshort(sc, 0x17, Data);
+                MP_WritePhyUshort(sc, 0x1e, 0x002D);
+                Data = MP_ReadPhyUshort(sc, 0x18);
+                Data |= BIT_4;
+                MP_WritePhyUshort(sc, 0x18, Data);
+                MP_WritePhyUshort(sc, 0x1f, 0x0002);
                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                MP_WritePhyUshort(sc, 0x1f, 0x0003);
+                Data = MP_ReadPhyUshort(sc, 0x14);
+                Data |= BIT_15;
+                MP_WritePhyUshort(sc, 0x14, Data);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0005);
+                MP_WritePhyUshort(sc, 0x05, 0x8B86);
+                Data = MP_ReadPhyUshort(sc, 0x06);
+                Data |= BIT_0;
+                MP_WritePhyUshort(sc, 0x06, Data);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0001);
+                MP_WritePhyUshort(sc, 0x0B, 0x6C14);
+                MP_WritePhyUshort(sc, 0x14, 0x7F3D);
+                MP_WritePhyUshort(sc, 0x1C, 0xFAFE);
+                MP_WritePhyUshort(sc, 0x08, 0x07C5);
+                MP_WritePhyUshort(sc, 0x10, 0xF090);
+                MP_WritePhyUshort(sc, 0x1F, 0x0003);
+                MP_WritePhyUshort(sc, 0x14, 0x641A);
+                MP_WritePhyUshort(sc, 0x1A, 0x0606);
+                MP_WritePhyUshort(sc, 0x12, 0xF480);
+                MP_WritePhyUshort(sc, 0x13, 0x0747);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0004);
+                MP_WritePhyUshort(sc, 0x1F, 0x0007);
+                MP_WritePhyUshort(sc, 0x1E, 0x0078);
+                MP_WritePhyUshort(sc, 0x15, 0xA408);
+                MP_WritePhyUshort(sc, 0x17, 0x5100);
+                MP_WritePhyUshort(sc, 0x19, 0x0008);
+                MP_WritePhyUshort(sc, 0x1F, 0x0002);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0003);
+                MP_WritePhyUshort(sc, 0x0D, 0x0207);
+                MP_WritePhyUshort(sc, 0x02, 0x5FD0);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0004);
+                MP_WritePhyUshort(sc, 0x1F, 0x0007);
+                MP_WritePhyUshort(sc, 0x1E, 0x00A1);
+                Data = MP_ReadPhyUshort(sc, 0x1A);
+                Data &= ~BIT_2;
+                MP_WritePhyUshort(sc, 0x1A, Data);
+                MP_WritePhyUshort(sc, 0x1F, 0x0002);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0004);
+                MP_WritePhyUshort(sc, 0x1F, 0x0007);
+                MP_WritePhyUshort(sc, 0x1E, 0x002D);
+                Data = MP_ReadPhyUshort(sc, 0x16);
+                Data |= BIT_5;
+                MP_WritePhyUshort(sc, 0x16, Data);
+                MP_WritePhyUshort(sc, 0x1F, 0x0002);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0004);
+                MP_WritePhyUshort(sc, 0x1F, 0x0007);
+                MP_WritePhyUshort(sc, 0x1E, 0x00AC);
+                MP_WritePhyUshort(sc, 0x18, 0x0006);
+                MP_WritePhyUshort(sc, 0x1F, 0x0002);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0003);
                 MP_WritePhyUshort(sc, 0x09, 0xA20F);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0005);
+                MP_WritePhyUshort(sc, 0x05, 0x8B85);
+                Data = MP_ReadPhyUshort(sc, 0x06);
+                Data |= BIT_14;
+                MP_WritePhyUshort(sc, 0x06, Data);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0005);
+                MP_WritePhyUshort(sc, 0x05, 0x8B54);
+                Data = MP_ReadPhyUshort(sc, 0x06);
+                Data &= ~BIT_11;
+                MP_WritePhyUshort(sc, 0x06, Data);
+                MP_WritePhyUshort(sc, 0x05, 0x8B5D);
+                Data = MP_ReadPhyUshort(sc, 0x06);
+                Data &= ~BIT_11;
+                MP_WritePhyUshort(sc, 0x06, Data);
+                MP_WritePhyUshort(sc, 0x05, 0x8A7C);
+                Data = MP_ReadPhyUshort(sc, 0x06);
+                Data &= ~BIT_8;
+                MP_WritePhyUshort(sc, 0x06, Data);
+                MP_WritePhyUshort(sc, 0x05, 0x8A7F);
+                Data = MP_ReadPhyUshort(sc, 0x06);
+                Data |= BIT_8;
+                MP_WritePhyUshort(sc, 0x06, Data);
+                MP_WritePhyUshort(sc, 0x05, 0x8A82);
+                Data = MP_ReadPhyUshort(sc, 0x06);
+                Data &= ~BIT_8;
+                MP_WritePhyUshort(sc, 0x06, Data);
+                MP_WritePhyUshort(sc, 0x05, 0x8A85);
+                Data = MP_ReadPhyUshort(sc, 0x06);
+                Data &= ~BIT_8;
+                MP_WritePhyUshort(sc, 0x06, Data);
+                MP_WritePhyUshort(sc, 0x05, 0x8A88);
+                Data = MP_ReadPhyUshort(sc, 0x06);
+                Data &= ~BIT_8;
+                MP_WritePhyUshort(sc, 0x06, Data);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0005);
+                MP_WritePhyUshort(sc, 0x05, 0x8B85);
+                Data = MP_ReadPhyUshort(sc, 0x06);
+                Data |= BIT_15;
+                MP_WritePhyUshort(sc, 0x06, Data);
                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                MP_WritePhyUshort(sc, 0x1f, 0x0003);
-                MP_WritePhyUshort(sc, 0x01, 0x328A);
-                MP_WritePhyUshort(sc, 0x1f, 0x0000);
+
                 MP_WritePhyUshort(sc, 0x1f, 0x0003);
                 Data = MP_ReadPhyUshort(sc, 0x19);
                 Data &= ~BIT_0;
@@ -16425,7 +22557,10 @@ static void re_hw_phy_config(struct re_softc *sc)
                 Data &= ~BIT_10;
                 MP_WritePhyUshort(sc, 0x10, Data);
                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                MP_WritePhyUshort(sc, 0x00, 0x9200);
+        } else if (sc->re_type == MACFG_39) {
+                Data_u32 = re_eri_read(sc, 0x1D0, 4, ERIAR_ExGMAC);
+                Data_u32 &= ~BIT_1;
+                re_eri_write(sc, 0x1D0, 4, Data_u32, ERIAR_ExGMAC);
 
                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
                 MP_WritePhyUshort(sc, 0x05, 0x8B80);
@@ -16434,11 +22569,20 @@ static void re_hw_phy_config(struct re_softc *sc)
                 MP_WritePhyUshort(sc, 0x06, Data);
                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
 
-                MP_WritePhyUshort(sc, 0x1F, 0x0007);
-                MP_WritePhyUshort(sc, 0x1E, 0x002D);
+                MP_WritePhyUshort(sc, 0x1F, 0x0005);
+                MP_WritePhyUshort(sc, 0x05, 0x8B85);
+                Data = MP_ReadPhyUshort(sc, 0x06);
+                Data |= BIT_15;
+                MP_WritePhyUshort(sc, 0x06, Data);
+                MP_WritePhyUshort(sc, 0x1f, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1f, 0x0004);
+                MP_WritePhyUshort(sc, 0x1f, 0x0007);
+                MP_WritePhyUshort(sc, 0x1e, 0x002D);
                 Data = MP_ReadPhyUshort(sc, 0x18);
                 Data |= BIT_4;
                 MP_WritePhyUshort(sc, 0x18, Data);
+                MP_WritePhyUshort(sc, 0x1f, 0x0002);
                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
                 Data = MP_ReadPhyUshort(sc, 0x14);
                 Data |= BIT_15;
@@ -16451,6 +22595,17 @@ static void re_hw_phy_config(struct re_softc *sc)
                 MP_WritePhyUshort(sc, 0x06, Data);
                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
 
+                MP_WritePhyUshort(sc, 0x1F, 0x0004);
+                MP_WritePhyUshort(sc, 0x1F, 0x0007);
+                MP_WritePhyUshort(sc, 0x1E, 0x00AC);
+                MP_WritePhyUshort(sc, 0x18, 0x0006);
+                MP_WritePhyUshort(sc, 0x1F, 0x0002);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0003);
+                MP_WritePhyUshort(sc, 0x09, 0xA20F);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+
                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
                 MP_WritePhyUshort(sc, 0x05, 0x8B85);
                 Data = MP_ReadPhyUshort(sc, 0x06);
@@ -16458,414 +22613,640 @@ static void re_hw_phy_config(struct re_softc *sc)
                 MP_WritePhyUshort(sc, 0x06, Data);
                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
 
-                MP_WritePhyUshort(sc, 0x1F, 0x0003);
-                MP_WritePhyUshort(sc, 0x09, 0xA20F);
+                MP_WritePhyUshort(sc, 0x1F, 0x0005);
+                MP_WritePhyUshort(sc, 0x05, 0x8B54);
+                Data = MP_ReadPhyUshort(sc, 0x06);
+                Data &= ~BIT_11;
+                MP_WritePhyUshort(sc, 0x06, Data);
+                MP_WritePhyUshort(sc, 0x05, 0x8B5D);
+                Data = MP_ReadPhyUshort(sc, 0x06);
+                Data &= ~BIT_11;
+                MP_WritePhyUshort(sc, 0x06, Data);
+                MP_WritePhyUshort(sc, 0x05, 0x8A7C);
+                Data = MP_ReadPhyUshort(sc, 0x06);
+                Data &= ~BIT_8;
+                MP_WritePhyUshort(sc, 0x06, Data);
+                MP_WritePhyUshort(sc, 0x05, 0x8A7F);
+                Data = MP_ReadPhyUshort(sc, 0x06);
+                Data |= BIT_8;
+                MP_WritePhyUshort(sc, 0x06, Data);
+                MP_WritePhyUshort(sc, 0x05, 0x8A82);
+                Data = MP_ReadPhyUshort(sc, 0x06);
+                Data &= ~BIT_8;
+                MP_WritePhyUshort(sc, 0x06, Data);
+                MP_WritePhyUshort(sc, 0x05, 0x8A85);
+                Data = MP_ReadPhyUshort(sc, 0x06);
+                Data &= ~BIT_8;
+                MP_WritePhyUshort(sc, 0x06, Data);
+                MP_WritePhyUshort(sc, 0x05, 0x8A88);
+                Data = MP_ReadPhyUshort(sc, 0x06);
+                Data &= ~BIT_8;
+                MP_WritePhyUshort(sc, 0x06, Data);
                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
 
-                MP_WritePhyUshort(sc, 0x1F, 0x0005);
-                MP_WritePhyUshort(sc, 0x05, 0x8B55);
-                MP_WritePhyUshort(sc, 0x06, 0x0000);
-                MP_WritePhyUshort(sc, 0x05, 0x8B5E);
-                MP_WritePhyUshort(sc, 0x06, 0x0000);
-                MP_WritePhyUshort(sc, 0x05, 0x8B67);
-                MP_WritePhyUshort(sc, 0x06, 0x0000);
-                MP_WritePhyUshort(sc, 0x05, 0x8B70);
-                MP_WritePhyUshort(sc, 0x06, 0x0000);
+                MP_WritePhyUshort(sc, 0x1f, 0x0003);
+                Data = MP_ReadPhyUshort(sc, 0x19);
+                Data &= ~BIT_0;
+                MP_WritePhyUshort(sc, 0x19, Data);
+                Data = MP_ReadPhyUshort(sc, 0x10);
+                Data &= ~BIT_10;
+                MP_WritePhyUshort(sc, 0x10, Data);
                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                MP_WritePhyUshort(sc, 0x1F, 0x0007);
-                MP_WritePhyUshort(sc, 0x1E, 0x0078);
-                MP_WritePhyUshort(sc, 0x17, 0x0000);
-                MP_WritePhyUshort(sc, 0x19, 0x00FB);
+        } else if (sc->re_type == MACFG_41) {
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+                MP_WritePhyUshort(sc, 0x11, MP_ReadPhyUshort(sc, 0x11) | 0x1000);
+                MP_WritePhyUshort(sc, 0x1F, 0x0002);
+                MP_WritePhyUshort(sc, 0x0F, MP_ReadPhyUshort(sc, 0x0F) | 0x0003);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+
+                for (Data_u32=0x800E0068; Data_u32<0x800E006D; Data_u32++) {
+                        CSR_WRITE_4(sc, 0xF8, Data_u32);
+                        for (i=0; i<10; i++) {
+                                DELAY(400);
+                                if ((CSR_READ_4(sc, 0xF8)&0x80000000)==0)
+                                        break;
+                        }
+                }
+        } else if (sc->re_type == MACFG_42 || sc->re_type == MACFG_43) {
+                Data_u32 = re_eri_read(sc, 0x1D0, 4, ERIAR_ExGMAC);
+                Data_u32 &= 0xFFFF0000;
+                re_eri_write(sc, 0x1D0, 4, Data_u32, ERIAR_ExGMAC);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+                MP_WritePhyUshort(sc, 0x18, 0x0310);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1f, 0x0004);
+                MP_WritePhyUshort(sc, 0x1f, 0x0004);
+                MP_WritePhyUshort(sc, 0x19, 0x7070);
+                MP_WritePhyUshort(sc, 0x1c, 0x0600);
+                MP_WritePhyUshort(sc, 0x1d, 0x9700);
+                MP_WritePhyUshort(sc, 0x1d, 0x7d00);
+                MP_WritePhyUshort(sc, 0x1d, 0x6900);
+                MP_WritePhyUshort(sc, 0x1d, 0x7d00);
+                MP_WritePhyUshort(sc, 0x1d, 0x6800);
+                MP_WritePhyUshort(sc, 0x1d, 0x4899);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
+                MP_WritePhyUshort(sc, 0x1d, 0x4c00);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
+                MP_WritePhyUshort(sc, 0x1d, 0x4c01);
+                MP_WritePhyUshort(sc, 0x1d, 0x8000);
+                MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
+                MP_WritePhyUshort(sc, 0x1d, 0x4c00);
+                MP_WritePhyUshort(sc, 0x1d, 0x4007);
+                MP_WritePhyUshort(sc, 0x1d, 0x4400);
+                MP_WritePhyUshort(sc, 0x1d, 0x4800);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
+                MP_WritePhyUshort(sc, 0x1d, 0x4c00);
+                MP_WritePhyUshort(sc, 0x1d, 0x5310);
+                MP_WritePhyUshort(sc, 0x1d, 0x6000);
+                MP_WritePhyUshort(sc, 0x1d, 0x6800);
+                MP_WritePhyUshort(sc, 0x1d, 0x6736);
+                MP_WritePhyUshort(sc, 0x1d, 0x0000);
+                MP_WritePhyUshort(sc, 0x1d, 0x0000);
+                MP_WritePhyUshort(sc, 0x1d, 0x571f);
+                MP_WritePhyUshort(sc, 0x1d, 0x5ffb);
+                MP_WritePhyUshort(sc, 0x1d, 0xaa03);
+                MP_WritePhyUshort(sc, 0x1d, 0x5b58);
+                MP_WritePhyUshort(sc, 0x1d, 0x301e);
+                MP_WritePhyUshort(sc, 0x1d, 0x5b64);
+                MP_WritePhyUshort(sc, 0x1d, 0xa6fc);
+                MP_WritePhyUshort(sc, 0x1d, 0xdcdb);
+                MP_WritePhyUshort(sc, 0x1d, 0x0014);
+                MP_WritePhyUshort(sc, 0x1d, 0xd9a9);
+                MP_WritePhyUshort(sc, 0x1d, 0x0013);
+                MP_WritePhyUshort(sc, 0x1d, 0xd16b);
+                MP_WritePhyUshort(sc, 0x1d, 0x0011);
+                MP_WritePhyUshort(sc, 0x1d, 0xb40e);
+                MP_WritePhyUshort(sc, 0x1d, 0xd06b);
+                MP_WritePhyUshort(sc, 0x1d, 0x000c);
+                MP_WritePhyUshort(sc, 0x1d, 0xb206);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c01);
+                MP_WritePhyUshort(sc, 0x1d, 0x5800);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c04);
+                MP_WritePhyUshort(sc, 0x1d, 0x5c00);
+                MP_WritePhyUshort(sc, 0x1d, 0x301a);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c01);
+                MP_WritePhyUshort(sc, 0x1d, 0x5801);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c04);
+                MP_WritePhyUshort(sc, 0x1d, 0x5c04);
+                MP_WritePhyUshort(sc, 0x1d, 0x301e);
+                MP_WritePhyUshort(sc, 0x1d, 0x314d);
+                MP_WritePhyUshort(sc, 0x1d, 0x31f0);
+                MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
+                MP_WritePhyUshort(sc, 0x1d, 0x4c20);
+                MP_WritePhyUshort(sc, 0x1d, 0x6004);
+                MP_WritePhyUshort(sc, 0x1d, 0x5310);
+                MP_WritePhyUshort(sc, 0x1d, 0x4833);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
+                MP_WritePhyUshort(sc, 0x1d, 0x4c00);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
+                MP_WritePhyUshort(sc, 0x1d, 0x4c08);
+                MP_WritePhyUshort(sc, 0x1d, 0x8300);
+                MP_WritePhyUshort(sc, 0x1d, 0x6800);
+                MP_WritePhyUshort(sc, 0x1d, 0x6600);
+                MP_WritePhyUshort(sc, 0x1d, 0x0000);
+                MP_WritePhyUshort(sc, 0x1d, 0x0000);
+                MP_WritePhyUshort(sc, 0x1d, 0xb90c);
+                MP_WritePhyUshort(sc, 0x1d, 0x30d3);
+                MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
+                MP_WritePhyUshort(sc, 0x1d, 0x4de0);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c04);
+                MP_WritePhyUshort(sc, 0x1d, 0x6000);
+                MP_WritePhyUshort(sc, 0x1d, 0x6800);
+                MP_WritePhyUshort(sc, 0x1d, 0x6736);
+                MP_WritePhyUshort(sc, 0x1d, 0x0000);
+                MP_WritePhyUshort(sc, 0x1d, 0x0000);
+                MP_WritePhyUshort(sc, 0x1d, 0x5310);
+                MP_WritePhyUshort(sc, 0x1d, 0x300b);
+                MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
+                MP_WritePhyUshort(sc, 0x1d, 0x4c60);
+                MP_WritePhyUshort(sc, 0x1d, 0x6803);
+                MP_WritePhyUshort(sc, 0x1d, 0x6520);
+                MP_WritePhyUshort(sc, 0x1d, 0x0000);
+                MP_WritePhyUshort(sc, 0x1d, 0x0000);
+                MP_WritePhyUshort(sc, 0x1d, 0xaf03);
+                MP_WritePhyUshort(sc, 0x1d, 0x6015);
+                MP_WritePhyUshort(sc, 0x1d, 0x3059);
+                MP_WritePhyUshort(sc, 0x1d, 0x6017);
+                MP_WritePhyUshort(sc, 0x1d, 0x57e0);
+                MP_WritePhyUshort(sc, 0x1d, 0x580c);
+                MP_WritePhyUshort(sc, 0x1d, 0x588c);
+                MP_WritePhyUshort(sc, 0x1d, 0x7ffc);
+                MP_WritePhyUshort(sc, 0x1d, 0x5fa3);
+                MP_WritePhyUshort(sc, 0x1d, 0x4827);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
+                MP_WritePhyUshort(sc, 0x1d, 0x4c00);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
+                MP_WritePhyUshort(sc, 0x1d, 0x4c10);
+                MP_WritePhyUshort(sc, 0x1d, 0x8400);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c30);
+                MP_WritePhyUshort(sc, 0x1d, 0x6020);
+                MP_WritePhyUshort(sc, 0x1d, 0x48bf);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
+                MP_WritePhyUshort(sc, 0x1d, 0x4c00);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
+                MP_WritePhyUshort(sc, 0x1d, 0x4c01);
+                MP_WritePhyUshort(sc, 0x1d, 0xad09);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c03);
+                MP_WritePhyUshort(sc, 0x1d, 0x5c03);
+                MP_WritePhyUshort(sc, 0x1d, 0x0000);
+                MP_WritePhyUshort(sc, 0x1d, 0x0000);
+                MP_WritePhyUshort(sc, 0x1d, 0x0000);
+                MP_WritePhyUshort(sc, 0x1d, 0x0000);
+                MP_WritePhyUshort(sc, 0x1d, 0x0000);
+                MP_WritePhyUshort(sc, 0x1d, 0x4400);
+                MP_WritePhyUshort(sc, 0x1d, 0xad2c);
+                MP_WritePhyUshort(sc, 0x1d, 0xd6cf);
+                MP_WritePhyUshort(sc, 0x1d, 0x0002);
+                MP_WritePhyUshort(sc, 0x1d, 0x80f4);
+                MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
+                MP_WritePhyUshort(sc, 0x1d, 0x4c80);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c20);
+                MP_WritePhyUshort(sc, 0x1d, 0x5c20);
+                MP_WritePhyUshort(sc, 0x1d, 0x481e);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
+                MP_WritePhyUshort(sc, 0x1d, 0x4c00);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
+                MP_WritePhyUshort(sc, 0x1d, 0x4c02);
+                MP_WritePhyUshort(sc, 0x1d, 0xad0a);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c03);
+                MP_WritePhyUshort(sc, 0x1d, 0x5c03);
+                MP_WritePhyUshort(sc, 0x1d, 0x0000);
+                MP_WritePhyUshort(sc, 0x1d, 0x0000);
+                MP_WritePhyUshort(sc, 0x1d, 0x0000);
+                MP_WritePhyUshort(sc, 0x1d, 0x0000);
+                MP_WritePhyUshort(sc, 0x1d, 0x0000);
+                MP_WritePhyUshort(sc, 0x1d, 0x4400);
+                MP_WritePhyUshort(sc, 0x1d, 0x5310);
+                MP_WritePhyUshort(sc, 0x1d, 0x8d02);
+                MP_WritePhyUshort(sc, 0x1d, 0x4401);
+                MP_WritePhyUshort(sc, 0x1d, 0x81f4);
+                MP_WritePhyUshort(sc, 0x1d, 0x3114);
+                MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
+                MP_WritePhyUshort(sc, 0x1d, 0x4d00);
+                MP_WritePhyUshort(sc, 0x1d, 0x4832);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
+                MP_WritePhyUshort(sc, 0x1d, 0x4c00);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
+                MP_WritePhyUshort(sc, 0x1d, 0x4c10);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c08);
+                MP_WritePhyUshort(sc, 0x1d, 0x6000);
+                MP_WritePhyUshort(sc, 0x1d, 0xa4b7);
+                MP_WritePhyUshort(sc, 0x1d, 0xd9b3);
+                MP_WritePhyUshort(sc, 0x1d, 0xfffe);
+                MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
+                MP_WritePhyUshort(sc, 0x1d, 0x4d20);
+                MP_WritePhyUshort(sc, 0x1d, 0x7e00);
+                MP_WritePhyUshort(sc, 0x1d, 0x6200);
+                MP_WritePhyUshort(sc, 0x1d, 0x3045);
+                MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
+                MP_WritePhyUshort(sc, 0x1d, 0x4d40);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c40);
+                MP_WritePhyUshort(sc, 0x1d, 0x6000);
+                MP_WritePhyUshort(sc, 0x1d, 0x4401);
+                MP_WritePhyUshort(sc, 0x1d, 0x5210);
+                MP_WritePhyUshort(sc, 0x1d, 0x4833);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c08);
+                MP_WritePhyUshort(sc, 0x1d, 0x4c00);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c08);
+                MP_WritePhyUshort(sc, 0x1d, 0x4c08);
+                MP_WritePhyUshort(sc, 0x1d, 0x8300);
+                MP_WritePhyUshort(sc, 0x1d, 0x5f80);
+                MP_WritePhyUshort(sc, 0x1d, 0x55e0);
+                MP_WritePhyUshort(sc, 0x1d, 0xc06f);
+                MP_WritePhyUshort(sc, 0x1d, 0x0005);
+                MP_WritePhyUshort(sc, 0x1d, 0xd9b3);
+                MP_WritePhyUshort(sc, 0x1d, 0xfffd);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c40);
+                MP_WritePhyUshort(sc, 0x1d, 0x6040);
+                MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
+                MP_WritePhyUshort(sc, 0x1d, 0x4d60);
+                MP_WritePhyUshort(sc, 0x1d, 0x57e0);
+                MP_WritePhyUshort(sc, 0x1d, 0x4814);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c04);
+                MP_WritePhyUshort(sc, 0x1d, 0x4c00);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c04);
+                MP_WritePhyUshort(sc, 0x1d, 0x4c04);
+                MP_WritePhyUshort(sc, 0x1d, 0x8200);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c03);
+                MP_WritePhyUshort(sc, 0x1d, 0x5c03);
+                MP_WritePhyUshort(sc, 0x1d, 0x0000);
+                MP_WritePhyUshort(sc, 0x1d, 0x0000);
+                MP_WritePhyUshort(sc, 0x1d, 0x0000);
+                MP_WritePhyUshort(sc, 0x1d, 0x0000);
+                MP_WritePhyUshort(sc, 0x1d, 0x0000);
+                MP_WritePhyUshort(sc, 0x1d, 0xad02);
+                MP_WritePhyUshort(sc, 0x1d, 0x4400);
+                MP_WritePhyUshort(sc, 0x1d, 0xc0e9);
+                MP_WritePhyUshort(sc, 0x1d, 0x0003);
+                MP_WritePhyUshort(sc, 0x1d, 0xadd8);
+                MP_WritePhyUshort(sc, 0x1d, 0x30c6);
+                MP_WritePhyUshort(sc, 0x1d, 0x3078);
+                MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
+                MP_WritePhyUshort(sc, 0x1d, 0x4dc0);
+                MP_WritePhyUshort(sc, 0x1d, 0x6730);
+                MP_WritePhyUshort(sc, 0x1d, 0x0000);
+                MP_WritePhyUshort(sc, 0x1d, 0x0000);
+                MP_WritePhyUshort(sc, 0x1d, 0xd09d);
+                MP_WritePhyUshort(sc, 0x1d, 0x0002);
+                MP_WritePhyUshort(sc, 0x1d, 0xb4fe);
+                MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
+                MP_WritePhyUshort(sc, 0x1d, 0x4d80);
+                MP_WritePhyUshort(sc, 0x1d, 0x6802);
+                MP_WritePhyUshort(sc, 0x1d, 0x6600);
+                MP_WritePhyUshort(sc, 0x1d, 0x0000);
+                MP_WritePhyUshort(sc, 0x1d, 0x0000);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c08);
+                MP_WritePhyUshort(sc, 0x1d, 0x6000);
+                MP_WritePhyUshort(sc, 0x1d, 0x486c);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
+                MP_WritePhyUshort(sc, 0x1d, 0x4c00);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
+                MP_WritePhyUshort(sc, 0x1d, 0x4c01);
+                MP_WritePhyUshort(sc, 0x1d, 0x9503);
+                MP_WritePhyUshort(sc, 0x1d, 0x7e00);
+                MP_WritePhyUshort(sc, 0x1d, 0x6200);
+                MP_WritePhyUshort(sc, 0x1d, 0x571f);
+                MP_WritePhyUshort(sc, 0x1d, 0x5fbb);
+                MP_WritePhyUshort(sc, 0x1d, 0xaa03);
+                MP_WritePhyUshort(sc, 0x1d, 0x5b58);
+                MP_WritePhyUshort(sc, 0x1d, 0x30e9);
+                MP_WritePhyUshort(sc, 0x1d, 0x5b64);
+                MP_WritePhyUshort(sc, 0x1d, 0xcdab);
+                MP_WritePhyUshort(sc, 0x1d, 0xff5b);
+                MP_WritePhyUshort(sc, 0x1d, 0xcd8d);
+                MP_WritePhyUshort(sc, 0x1d, 0xff59);
+                MP_WritePhyUshort(sc, 0x1d, 0xd96b);
+                MP_WritePhyUshort(sc, 0x1d, 0xff57);
+                MP_WritePhyUshort(sc, 0x1d, 0xd0a0);
+                MP_WritePhyUshort(sc, 0x1d, 0xffdb);
+                MP_WritePhyUshort(sc, 0x1d, 0xcba0);
+                MP_WritePhyUshort(sc, 0x1d, 0x0003);
+                MP_WritePhyUshort(sc, 0x1d, 0x80f0);
+                MP_WritePhyUshort(sc, 0x1d, 0x30f6);
+                MP_WritePhyUshort(sc, 0x1d, 0x3109);
+                MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
+                MP_WritePhyUshort(sc, 0x1d, 0x4ce0);
+                MP_WritePhyUshort(sc, 0x1d, 0x7d30);
+                MP_WritePhyUshort(sc, 0x1d, 0x6530);
+                MP_WritePhyUshort(sc, 0x1d, 0x0000);
+                MP_WritePhyUshort(sc, 0x1d, 0x0000);
+                MP_WritePhyUshort(sc, 0x1d, 0x7ce0);
+                MP_WritePhyUshort(sc, 0x1d, 0x5400);
+                MP_WritePhyUshort(sc, 0x1d, 0x4832);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
+                MP_WritePhyUshort(sc, 0x1d, 0x4c00);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
+                MP_WritePhyUshort(sc, 0x1d, 0x4c08);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c08);
+                MP_WritePhyUshort(sc, 0x1d, 0x6008);
+                MP_WritePhyUshort(sc, 0x1d, 0x8300);
+                MP_WritePhyUshort(sc, 0x1d, 0xb902);
+                MP_WritePhyUshort(sc, 0x1d, 0x30d3);
+                MP_WritePhyUshort(sc, 0x1d, 0x308f);
+                MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
+                MP_WritePhyUshort(sc, 0x1d, 0x4da0);
+                MP_WritePhyUshort(sc, 0x1d, 0x57a0);
+                MP_WritePhyUshort(sc, 0x1d, 0x590c);
+                MP_WritePhyUshort(sc, 0x1d, 0x5fa2);
+                MP_WritePhyUshort(sc, 0x1d, 0xcba4);
+                MP_WritePhyUshort(sc, 0x1d, 0x0005);
+                MP_WritePhyUshort(sc, 0x1d, 0xcd8d);
+                MP_WritePhyUshort(sc, 0x1d, 0x0003);
+                MP_WritePhyUshort(sc, 0x1d, 0x80fc);
+                MP_WritePhyUshort(sc, 0x1d, 0x0000);
+                MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
+                MP_WritePhyUshort(sc, 0x1d, 0x4ca0);
+                MP_WritePhyUshort(sc, 0x1d, 0xb603);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c10);
+                MP_WritePhyUshort(sc, 0x1d, 0x6010);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
+                MP_WritePhyUshort(sc, 0x1d, 0x541f);
+                MP_WritePhyUshort(sc, 0x1d, 0x7ffc);
+                MP_WritePhyUshort(sc, 0x1d, 0x5fb3);
+                MP_WritePhyUshort(sc, 0x1d, 0x9403);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c03);
+                MP_WritePhyUshort(sc, 0x1d, 0x5c03);
+                MP_WritePhyUshort(sc, 0x1d, 0xaa05);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c80);
+                MP_WritePhyUshort(sc, 0x1d, 0x5800);
+                MP_WritePhyUshort(sc, 0x1d, 0x5b58);
+                MP_WritePhyUshort(sc, 0x1d, 0x3128);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c80);
+                MP_WritePhyUshort(sc, 0x1d, 0x5800);
+                MP_WritePhyUshort(sc, 0x1d, 0x5b64);
+                MP_WritePhyUshort(sc, 0x1d, 0x4827);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
+                MP_WritePhyUshort(sc, 0x1d, 0x4c00);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
+                MP_WritePhyUshort(sc, 0x1d, 0x4c10);
+                MP_WritePhyUshort(sc, 0x1d, 0x8400);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c10);
+                MP_WritePhyUshort(sc, 0x1d, 0x6000);
+                MP_WritePhyUshort(sc, 0x1d, 0x4824);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
+                MP_WritePhyUshort(sc, 0x1d, 0x4c00);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
+                MP_WritePhyUshort(sc, 0x1d, 0x4c04);
+                MP_WritePhyUshort(sc, 0x1d, 0x8200);
+                MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
+                MP_WritePhyUshort(sc, 0x1d, 0x4cc0);
+                MP_WritePhyUshort(sc, 0x1d, 0x7d00);
+                MP_WritePhyUshort(sc, 0x1d, 0x6400);
+                MP_WritePhyUshort(sc, 0x1d, 0x7ffc);
+                MP_WritePhyUshort(sc, 0x1d, 0x5fbb);
+                MP_WritePhyUshort(sc, 0x1d, 0x4824);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
+                MP_WritePhyUshort(sc, 0x1d, 0x4c00);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
+                MP_WritePhyUshort(sc, 0x1d, 0x4c04);
+                MP_WritePhyUshort(sc, 0x1d, 0x8200);
+                MP_WritePhyUshort(sc, 0x1d, 0x7e00);
+                MP_WritePhyUshort(sc, 0x1d, 0x6a00);
+                MP_WritePhyUshort(sc, 0x1d, 0x4824);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
+                MP_WritePhyUshort(sc, 0x1d, 0x4c00);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
+                MP_WritePhyUshort(sc, 0x1d, 0x4c04);
+                MP_WritePhyUshort(sc, 0x1d, 0x8200);
+                MP_WritePhyUshort(sc, 0x1d, 0x7e00);
+                MP_WritePhyUshort(sc, 0x1d, 0x6800);
+                MP_WritePhyUshort(sc, 0x1d, 0x30f6);
+                MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
+                MP_WritePhyUshort(sc, 0x1d, 0x4e00);
+                MP_WritePhyUshort(sc, 0x1d, 0x4007);
+                MP_WritePhyUshort(sc, 0x1d, 0x4400);
+                MP_WritePhyUshort(sc, 0x1d, 0x5310);
+                MP_WritePhyUshort(sc, 0x1d, 0x6800);
+                MP_WritePhyUshort(sc, 0x1d, 0x6736);
+                MP_WritePhyUshort(sc, 0x1d, 0x0000);
+                MP_WritePhyUshort(sc, 0x1d, 0x0000);
+                MP_WritePhyUshort(sc, 0x1d, 0x570f);
+                MP_WritePhyUshort(sc, 0x1d, 0x5fff);
+                MP_WritePhyUshort(sc, 0x1d, 0xaa03);
+                MP_WritePhyUshort(sc, 0x1d, 0x585b);
+                MP_WritePhyUshort(sc, 0x1d, 0x315c);
+                MP_WritePhyUshort(sc, 0x1d, 0x5867);
+                MP_WritePhyUshort(sc, 0x1d, 0x9402);
+                MP_WritePhyUshort(sc, 0x1d, 0x6200);
+                MP_WritePhyUshort(sc, 0x1d, 0xcda3);
+                MP_WritePhyUshort(sc, 0x1d, 0x009d);
+                MP_WritePhyUshort(sc, 0x1d, 0xcd85);
+                MP_WritePhyUshort(sc, 0x1d, 0x009b);
+                MP_WritePhyUshort(sc, 0x1d, 0xd96b);
+                MP_WritePhyUshort(sc, 0x1d, 0x0099);
+                MP_WritePhyUshort(sc, 0x1d, 0x96e9);
+                MP_WritePhyUshort(sc, 0x1d, 0x6800);
+                MP_WritePhyUshort(sc, 0x1d, 0x6736);
+                MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
+                MP_WritePhyUshort(sc, 0x1d, 0x4e20);
+                MP_WritePhyUshort(sc, 0x1d, 0x96e4);
+                MP_WritePhyUshort(sc, 0x1d, 0x8b04);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c08);
+                MP_WritePhyUshort(sc, 0x1d, 0x5008);
+                MP_WritePhyUshort(sc, 0x1d, 0xab03);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c08);
+                MP_WritePhyUshort(sc, 0x1d, 0x5000);
+                MP_WritePhyUshort(sc, 0x1d, 0x6801);
+                MP_WritePhyUshort(sc, 0x1d, 0x6776);
+                MP_WritePhyUshort(sc, 0x1d, 0x0000);
+                MP_WritePhyUshort(sc, 0x1d, 0x0000);
+                MP_WritePhyUshort(sc, 0x1d, 0xdb7c);
+                MP_WritePhyUshort(sc, 0x1d, 0xfff0);
+                MP_WritePhyUshort(sc, 0x1d, 0x0000);
+                MP_WritePhyUshort(sc, 0x1d, 0x7fe1);
+                MP_WritePhyUshort(sc, 0x1d, 0x4e40);
+                MP_WritePhyUshort(sc, 0x1d, 0x4837);
+                MP_WritePhyUshort(sc, 0x1d, 0x4418);
+                MP_WritePhyUshort(sc, 0x1d, 0x41c7);
+                MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
+                MP_WritePhyUshort(sc, 0x1d, 0x4e40);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c40);
+                MP_WritePhyUshort(sc, 0x1d, 0x5400);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
+                MP_WritePhyUshort(sc, 0x1d, 0x4c01);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
+                MP_WritePhyUshort(sc, 0x1d, 0x4c01);
+                MP_WritePhyUshort(sc, 0x1d, 0x8fc9);
+                MP_WritePhyUshort(sc, 0x1d, 0xd2a0);
+                MP_WritePhyUshort(sc, 0x1d, 0x004a);
+                MP_WritePhyUshort(sc, 0x1d, 0x9203);
+                MP_WritePhyUshort(sc, 0x1d, 0xa041);
+                MP_WritePhyUshort(sc, 0x1d, 0x3184);
+                MP_WritePhyUshort(sc, 0x1d, 0x7fe1);
+                MP_WritePhyUshort(sc, 0x1d, 0x4e60);
+                MP_WritePhyUshort(sc, 0x1d, 0x489c);
+                MP_WritePhyUshort(sc, 0x1d, 0x4628);
+                MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
+                MP_WritePhyUshort(sc, 0x1d, 0x4e60);
+                MP_WritePhyUshort(sc, 0x1d, 0x7e28);
+                MP_WritePhyUshort(sc, 0x1d, 0x4628);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c40);
+                MP_WritePhyUshort(sc, 0x1d, 0x5400);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c01);
+                MP_WritePhyUshort(sc, 0x1d, 0x5800);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c04);
+                MP_WritePhyUshort(sc, 0x1d, 0x5c00);
+                MP_WritePhyUshort(sc, 0x1d, 0x41e8);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
+                MP_WritePhyUshort(sc, 0x1d, 0x4c01);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
+                MP_WritePhyUshort(sc, 0x1d, 0x4c01);
+                MP_WritePhyUshort(sc, 0x1d, 0x8fb0);
+                MP_WritePhyUshort(sc, 0x1d, 0xb241);
+                MP_WritePhyUshort(sc, 0x1d, 0xa02a);
+                MP_WritePhyUshort(sc, 0x1d, 0x319d);
+                MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
+                MP_WritePhyUshort(sc, 0x1d, 0x4ea0);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c02);
+                MP_WritePhyUshort(sc, 0x1d, 0x4402);
+                MP_WritePhyUshort(sc, 0x1d, 0x4448);
+                MP_WritePhyUshort(sc, 0x1d, 0x4894);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
+                MP_WritePhyUshort(sc, 0x1d, 0x4c01);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
+                MP_WritePhyUshort(sc, 0x1d, 0x4c03);
+                MP_WritePhyUshort(sc, 0x1d, 0x4824);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
+                MP_WritePhyUshort(sc, 0x1d, 0x4c07);
+                MP_WritePhyUshort(sc, 0x1d, 0x41ef);
+                MP_WritePhyUshort(sc, 0x1d, 0x41ff);
+                MP_WritePhyUshort(sc, 0x1d, 0x4891);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
+                MP_WritePhyUshort(sc, 0x1d, 0x4c07);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
+                MP_WritePhyUshort(sc, 0x1d, 0x4c17);
+                MP_WritePhyUshort(sc, 0x1d, 0x8400);
+                MP_WritePhyUshort(sc, 0x1d, 0x8ef8);
+                MP_WritePhyUshort(sc, 0x1d, 0x41c7);
+                MP_WritePhyUshort(sc, 0x1d, 0x8f95);
+                MP_WritePhyUshort(sc, 0x1d, 0x92d5);
+                MP_WritePhyUshort(sc, 0x1d, 0xa10f);
+                MP_WritePhyUshort(sc, 0x1d, 0xd480);
+                MP_WritePhyUshort(sc, 0x1d, 0x0008);
+                MP_WritePhyUshort(sc, 0x1d, 0xd580);
+                MP_WritePhyUshort(sc, 0x1d, 0xffb9);
+                MP_WritePhyUshort(sc, 0x1d, 0xa202);
+                MP_WritePhyUshort(sc, 0x1d, 0x31b8);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c04);
+                MP_WritePhyUshort(sc, 0x1d, 0x4404);
+                MP_WritePhyUshort(sc, 0x1d, 0x31b8);
+                MP_WritePhyUshort(sc, 0x1d, 0xd484);
+                MP_WritePhyUshort(sc, 0x1d, 0xfff3);
+                MP_WritePhyUshort(sc, 0x1d, 0xd484);
+                MP_WritePhyUshort(sc, 0x1d, 0xfff1);
+                MP_WritePhyUshort(sc, 0x1d, 0x314d);
+                MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
+                MP_WritePhyUshort(sc, 0x1d, 0x4ee0);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c40);
+                MP_WritePhyUshort(sc, 0x1d, 0x5400);
+                MP_WritePhyUshort(sc, 0x1d, 0x4488);
+                MP_WritePhyUshort(sc, 0x1d, 0x41cf);
+                MP_WritePhyUshort(sc, 0x1d, 0x314d);
+                MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
+                MP_WritePhyUshort(sc, 0x1d, 0x4ec0);
+                MP_WritePhyUshort(sc, 0x1d, 0x48f3);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
+                MP_WritePhyUshort(sc, 0x1d, 0x4c01);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
+                MP_WritePhyUshort(sc, 0x1d, 0x4c09);
+                MP_WritePhyUshort(sc, 0x1d, 0x4508);
+                MP_WritePhyUshort(sc, 0x1d, 0x41c7);
+                MP_WritePhyUshort(sc, 0x1d, 0x8f24);
+                MP_WritePhyUshort(sc, 0x1d, 0xd218);
+                MP_WritePhyUshort(sc, 0x1d, 0x0022);
+                MP_WritePhyUshort(sc, 0x1d, 0xd2a4);
+                MP_WritePhyUshort(sc, 0x1d, 0xff9f);
+                MP_WritePhyUshort(sc, 0x1d, 0x31d9);
+                MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
+                MP_WritePhyUshort(sc, 0x1d, 0x4e80);
+                MP_WritePhyUshort(sc, 0x1d, 0x4832);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
+                MP_WritePhyUshort(sc, 0x1d, 0x4c01);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
+                MP_WritePhyUshort(sc, 0x1d, 0x4c11);
+                MP_WritePhyUshort(sc, 0x1d, 0x4428);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c40);
+                MP_WritePhyUshort(sc, 0x1d, 0x5440);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c01);
+                MP_WritePhyUshort(sc, 0x1d, 0x5801);
+                MP_WritePhyUshort(sc, 0x1d, 0x7c04);
+                MP_WritePhyUshort(sc, 0x1d, 0x5c04);
+                MP_WritePhyUshort(sc, 0x1d, 0x41e8);
+                MP_WritePhyUshort(sc, 0x1d, 0xa4b3);
+                MP_WritePhyUshort(sc, 0x1d, 0x31ee);
+                MP_WritePhyUshort(sc, 0x1d, 0x6800);
+                MP_WritePhyUshort(sc, 0x1d, 0x6736);
+                MP_WritePhyUshort(sc, 0x1d, 0x0000);
+                MP_WritePhyUshort(sc, 0x1d, 0x0000);
+                MP_WritePhyUshort(sc, 0x1d, 0x570f);
+                MP_WritePhyUshort(sc, 0x1d, 0x5fff);
+                MP_WritePhyUshort(sc, 0x1d, 0xaa03);
+                MP_WritePhyUshort(sc, 0x1d, 0x585b);
+                MP_WritePhyUshort(sc, 0x1d, 0x31fa);
+                MP_WritePhyUshort(sc, 0x1d, 0x5867);
+                MP_WritePhyUshort(sc, 0x1d, 0xbcf6);
+                MP_WritePhyUshort(sc, 0x1d, 0x300b);
+                MP_WritePhyUshort(sc, 0x1d, 0x300b);
+                MP_WritePhyUshort(sc, 0x1d, 0x314d);
+                MP_WritePhyUshort(sc, 0x1f, 0x0004);
+                MP_WritePhyUshort(sc, 0x1c, 0x0200);
+                MP_WritePhyUshort(sc, 0x19, 0x7030);
                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
 
-                MP_WritePhyUshort(sc, 0x1F, 0x0005);
-                MP_WritePhyUshort(sc, 0x05, 0x8B79);
-                MP_WritePhyUshort(sc, 0x06, 0xAA00);
-                MP_WritePhyUshort(sc, 0x1f, 0x0000);
+                if (CSR_READ_1(sc, 0xEF)&0x08) {
+                        MP_WritePhyUshort(sc, 0x1F, 0x0005);
+                        MP_WritePhyUshort(sc, 0x1A, 0x0004);
+                        MP_WritePhyUshort(sc, 0x1F, 0x0000);
+                } else {
+                        MP_WritePhyUshort(sc, 0x1F, 0x0005);
+                        MP_WritePhyUshort(sc, 0x1A, 0x0000);
+                        MP_WritePhyUshort(sc, 0x1F, 0x0000);
+                }
 
-                MP_WritePhyUshort(sc, 0x1F, 0x0003);
-                MP_WritePhyUshort(sc, 0x01, 0x328A);
-                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+                if (CSR_READ_1(sc, 0xEF)&0x10) {
+                        MP_WritePhyUshort(sc, 0x1F, 0x0004);
+                        MP_WritePhyUshort(sc, 0x1C, 0x0000);
+                        MP_WritePhyUshort(sc, 0x1F, 0x0000);
+                } else {
+                        MP_WritePhyUshort(sc, 0x1F, 0x0004);
+                        MP_WritePhyUshort(sc, 0x1C, 0x0200);
+                        MP_WritePhyUshort(sc, 0x1F, 0x0000);
+                }
 
-                MP_WritePhyUshort(sc, 0x1F, 0x0005);
-                MP_WritePhyUshort(sc, 0x05, 0x8B54);
-                Data = MP_ReadPhyUshort(sc, 0x06);
-                Data &= ~BIT_11;
-                MP_WritePhyUshort(sc, 0x06, Data);
-                MP_WritePhyUshort(sc, 0x05, 0x8B5D);
-                Data = MP_ReadPhyUshort(sc, 0x06);
-                Data &= ~BIT_11;
-                MP_WritePhyUshort(sc, 0x06, Data);
-                MP_WritePhyUshort(sc, 0x05, 0x8A7C);
-                Data = MP_ReadPhyUshort(sc, 0x06);
-                Data &= ~BIT_8;
-                MP_WritePhyUshort(sc, 0x06, Data);
-                MP_WritePhyUshort(sc, 0x05, 0x8A7F);
-                Data = MP_ReadPhyUshort(sc, 0x06);
-                Data |= BIT_8;
-                MP_WritePhyUshort(sc, 0x06, Data);
-                MP_WritePhyUshort(sc, 0x05, 0x8A82);
-                Data = MP_ReadPhyUshort(sc, 0x06);
-                Data &= ~BIT_8;
-                MP_WritePhyUshort(sc, 0x06, Data);
-                MP_WritePhyUshort(sc, 0x05, 0x8A85);
-                Data = MP_ReadPhyUshort(sc, 0x06);
-                Data &= ~BIT_8;
-                MP_WritePhyUshort(sc, 0x06, Data);
-                MP_WritePhyUshort(sc, 0x05, 0x8A88);
-                Data = MP_ReadPhyUshort(sc, 0x06);
-                Data &= ~BIT_8;
-                MP_WritePhyUshort(sc, 0x06, Data);
+                MP_WritePhyUshort(sc, 0x1F, 0x0001);
+                MP_WritePhyUshort(sc, 0x15, 0x7701);
                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
 
-                MP_WritePhyUshort(sc, 0x1F, 0x0005);
-                MP_WritePhyUshort(sc, 0x05, 0x8B85);
-                Data = MP_ReadPhyUshort(sc, 0x06);
-                Data |= BIT_15;
-                MP_WritePhyUshort(sc, 0x06, Data);
-                MP_WritePhyUshort(sc, 0x1f, 0x0000);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+                ClearEthPhyBit(sc, 0x1A, BIT_14);
 
-                MP_WritePhyUshort(sc, 0x1f, 0x0003);
-                Data = MP_ReadPhyUshort(sc, 0x19);
-                Data &= ~BIT_0;
-                MP_WritePhyUshort(sc, 0x19, Data);
-                Data = MP_ReadPhyUshort(sc, 0x10);
-                Data &= ~BIT_10;
-                MP_WritePhyUshort(sc, 0x10, Data);
-                MP_WritePhyUshort(sc, 0x1f, 0x0000);
-        } else if (sc->re_type == MACFG_51) {
-                MP_WritePhyUshort(sc,0x1f, 0x0000);
-                MP_WritePhyUshort(sc,0x00, 0x1800);
-                Data = MP_ReadPhyUshort(sc, 0x15);
-                Data &= ~(BIT_12);
-                MP_WritePhyUshort(sc,0x15, Data);
-                MP_WritePhyUshort(sc,0x00, 0x9800);
-                MP_WritePhyUshort(sc,0x1f, 0x0007);
-                MP_WritePhyUshort(sc,0x1e, 0x002f);
-                for (i = 0; i < 1000; i++) {
-                        DELAY(100);
-                        Data = MP_ReadPhyUshort(sc, 0x1c);
-                        if (Data & BIT_7)
-                                break;
+                if (phy_power_saving == 1) {
+                        MP_WritePhyUshort(sc, 0x1F, 0x0000);
+                        MP_WritePhyUshort(sc, 0x18, 0x8310);
+                        MP_WritePhyUshort(sc, 0x1F, 0x0000);
+                } else {
+                        MP_WritePhyUshort(sc, 0x1F, 0x0000);
+                        MP_WritePhyUshort(sc, 0x18, 0x0310);
+                        MP_WritePhyUshort(sc, 0x1F, 0x0000);
+                        DELAY(20000);
                 }
-                MP_WritePhyUshort(sc, 0x1f, 0x0007);
-                MP_WritePhyUshort(sc, 0x1e, 0x0023);
-                MP_WritePhyUshort(sc, 0x16, 0x0306);
-                MP_WritePhyUshort(sc, 0x16, 0x0307);
-                MP_WritePhyUshort(sc, 0x15, 0x0098);
-                MP_WritePhyUshort(sc, 0x19, 0x7c0b);
-                MP_WritePhyUshort(sc, 0x15, 0x0099);
-                MP_WritePhyUshort(sc, 0x19, 0x6c0b);
-                MP_WritePhyUshort(sc, 0x15, 0x00eb);
-                MP_WritePhyUshort(sc, 0x19, 0x6c0b);
-                MP_WritePhyUshort(sc, 0x15, 0x00f8);
-                MP_WritePhyUshort(sc, 0x19, 0x6f0b);
-                MP_WritePhyUshort(sc, 0x15, 0x00fe);
-                MP_WritePhyUshort(sc, 0x19, 0x6f0f);
-                MP_WritePhyUshort(sc, 0x15, 0x00db);
-                MP_WritePhyUshort(sc, 0x19, 0x6f09);
-                MP_WritePhyUshort(sc, 0x15, 0x00dc);
-                MP_WritePhyUshort(sc, 0x19, 0xaefd);
-                MP_WritePhyUshort(sc, 0x15, 0x00dd);
-                MP_WritePhyUshort(sc, 0x19, 0x6f0b);
-                MP_WritePhyUshort(sc, 0x15, 0x00de);
-                MP_WritePhyUshort(sc, 0x19, 0xc60b);
-                MP_WritePhyUshort(sc, 0x15, 0x00df);
-                MP_WritePhyUshort(sc, 0x19, 0x00fa);
-                MP_WritePhyUshort(sc, 0x15, 0x00e0);
-                MP_WritePhyUshort(sc, 0x19, 0x30e1);
-                MP_WritePhyUshort(sc, 0x15, 0x020c);
-                MP_WritePhyUshort(sc, 0x19, 0x3224);
-                MP_WritePhyUshort(sc, 0x15, 0x020e);
-                MP_WritePhyUshort(sc, 0x19, 0x9813);
-                MP_WritePhyUshort(sc, 0x15, 0x020f);
-                MP_WritePhyUshort(sc, 0x19, 0x7801);
-                MP_WritePhyUshort(sc, 0x15, 0x0210);
-                MP_WritePhyUshort(sc, 0x19, 0x930f);
-                MP_WritePhyUshort(sc, 0x15, 0x0211);
-                MP_WritePhyUshort(sc, 0x19, 0x9206);
-                MP_WritePhyUshort(sc, 0x15, 0x0212);
-                MP_WritePhyUshort(sc, 0x19, 0x4002);
-                MP_WritePhyUshort(sc, 0x15, 0x0213);
-                MP_WritePhyUshort(sc, 0x19, 0x7800);
-                MP_WritePhyUshort(sc, 0x15, 0x0214);
-                MP_WritePhyUshort(sc, 0x19, 0x588f);
-                MP_WritePhyUshort(sc, 0x15, 0x0215);
-                MP_WritePhyUshort(sc, 0x19, 0x5520);
-                MP_WritePhyUshort(sc, 0x15, 0x0216);
-                MP_WritePhyUshort(sc, 0x19, 0x3224);
-                MP_WritePhyUshort(sc, 0x15, 0x0217);
-                MP_WritePhyUshort(sc, 0x19, 0x4002);
-                MP_WritePhyUshort(sc, 0x15, 0x0218);
-                MP_WritePhyUshort(sc, 0x19, 0x7800);
-                MP_WritePhyUshort(sc, 0x15, 0x0219);
-                MP_WritePhyUshort(sc, 0x19, 0x588d);
-                MP_WritePhyUshort(sc, 0x15, 0x021a);
-                MP_WritePhyUshort(sc, 0x19, 0x5540);
-                MP_WritePhyUshort(sc, 0x15, 0x021b);
-                MP_WritePhyUshort(sc, 0x19, 0x9e03);
-                MP_WritePhyUshort(sc, 0x15, 0x021c);
-                MP_WritePhyUshort(sc, 0x19, 0x7c40);
-                MP_WritePhyUshort(sc, 0x15, 0x021d);
-                MP_WritePhyUshort(sc, 0x19, 0x6840);
-                MP_WritePhyUshort(sc, 0x15, 0x021e);
-                MP_WritePhyUshort(sc, 0x19, 0x3224);
-                MP_WritePhyUshort(sc, 0x15, 0x021f);
-                MP_WritePhyUshort(sc, 0x19, 0x4002);
-                MP_WritePhyUshort(sc, 0x15, 0x0220);
-                MP_WritePhyUshort(sc, 0x19, 0x3224);
-                MP_WritePhyUshort(sc, 0x15, 0x0221);
-                MP_WritePhyUshort(sc, 0x19, 0x9e03);
-                MP_WritePhyUshort(sc, 0x15, 0x0222);
-                MP_WritePhyUshort(sc, 0x19, 0x7c40);
-                MP_WritePhyUshort(sc, 0x15, 0x0223);
-                MP_WritePhyUshort(sc, 0x19, 0x6840);
-                MP_WritePhyUshort(sc, 0x15, 0x0224);
-                MP_WritePhyUshort(sc, 0x19, 0x7800);
-                MP_WritePhyUshort(sc, 0x15, 0x0225);
-                MP_WritePhyUshort(sc, 0x19, 0x3231);
-                MP_WritePhyUshort(sc, 0x15, 0x0000);
-                MP_WritePhyUshort(sc, 0x16, 0x0306);
-                MP_WritePhyUshort(sc, 0x16, 0x0300);
-                MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                MP_WritePhyUshort(sc, 0x1f, 0x0005);
-                MP_WritePhyUshort(sc, 0x05, 0xfff6);
-                MP_WritePhyUshort(sc, 0x06, 0x0080);
-                MP_WritePhyUshort(sc, 0x05, 0x8000);
-                MP_WritePhyUshort(sc, 0x06, 0x0280);
-                MP_WritePhyUshort(sc, 0x06, 0x48f7);
-                MP_WritePhyUshort(sc, 0x06, 0x00e0);
-                MP_WritePhyUshort(sc, 0x06, 0xfff7);
-                MP_WritePhyUshort(sc, 0x06, 0xa080);
-                MP_WritePhyUshort(sc, 0x06, 0x02ae);
-                MP_WritePhyUshort(sc, 0x06, 0xf602);
-                MP_WritePhyUshort(sc, 0x06, 0x011b);
-                MP_WritePhyUshort(sc, 0x06, 0x0201);
-                MP_WritePhyUshort(sc, 0x06, 0x2802);
-                MP_WritePhyUshort(sc, 0x06, 0x0135);
-                MP_WritePhyUshort(sc, 0x06, 0x0201);
-                MP_WritePhyUshort(sc, 0x06, 0x4502);
-                MP_WritePhyUshort(sc, 0x06, 0x015f);
-                MP_WritePhyUshort(sc, 0x06, 0x0280);
-                MP_WritePhyUshort(sc, 0x06, 0x6b02);
-                MP_WritePhyUshort(sc, 0x06, 0x80e5);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x88e1);
-                MP_WritePhyUshort(sc, 0x06, 0x8b89);
-                MP_WritePhyUshort(sc, 0x06, 0x1e01);
-                MP_WritePhyUshort(sc, 0x06, 0xe18b);
-                MP_WritePhyUshort(sc, 0x06, 0x8a1e);
-                MP_WritePhyUshort(sc, 0x06, 0x01e1);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8b);
-                MP_WritePhyUshort(sc, 0x06, 0x1e01);
-                MP_WritePhyUshort(sc, 0x06, 0xe18b);
-                MP_WritePhyUshort(sc, 0x06, 0x8c1e);
-                MP_WritePhyUshort(sc, 0x06, 0x01e1);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8d);
-                MP_WritePhyUshort(sc, 0x06, 0x1e01);
-                MP_WritePhyUshort(sc, 0x06, 0xe18b);
-                MP_WritePhyUshort(sc, 0x06, 0x8e1e);
-                MP_WritePhyUshort(sc, 0x06, 0x01a0);
-                MP_WritePhyUshort(sc, 0x06, 0x00c7);
-                MP_WritePhyUshort(sc, 0x06, 0xaebb);
-                MP_WritePhyUshort(sc, 0x06, 0xbf8b);
-                MP_WritePhyUshort(sc, 0x06, 0x88ec);
-                MP_WritePhyUshort(sc, 0x06, 0x0019);
-                MP_WritePhyUshort(sc, 0x06, 0xa98b);
-                MP_WritePhyUshort(sc, 0x06, 0x90f9);
-                MP_WritePhyUshort(sc, 0x06, 0xeeff);
-                MP_WritePhyUshort(sc, 0x06, 0xf600);
-                MP_WritePhyUshort(sc, 0x06, 0xeeff);
-                MP_WritePhyUshort(sc, 0x06, 0xf7fe);
-                MP_WritePhyUshort(sc, 0x06, 0xd100);
-                MP_WritePhyUshort(sc, 0x06, 0xbf81);
-                MP_WritePhyUshort(sc, 0x06, 0x9802);
-                MP_WritePhyUshort(sc, 0x06, 0x39f3);
-                MP_WritePhyUshort(sc, 0x06, 0xd101);
-                MP_WritePhyUshort(sc, 0x06, 0xbf81);
-                MP_WritePhyUshort(sc, 0x06, 0x9b02);
-                MP_WritePhyUshort(sc, 0x06, 0x39f3);
-                MP_WritePhyUshort(sc, 0x06, 0x04f8);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x8dad);
-                MP_WritePhyUshort(sc, 0x06, 0x2014);
-                MP_WritePhyUshort(sc, 0x06, 0xee8b);
-                MP_WritePhyUshort(sc, 0x06, 0x8d00);
-                MP_WritePhyUshort(sc, 0x06, 0xe08a);
-                MP_WritePhyUshort(sc, 0x06, 0x5a78);
-                MP_WritePhyUshort(sc, 0x06, 0x039e);
-                MP_WritePhyUshort(sc, 0x06, 0x0902);
-                MP_WritePhyUshort(sc, 0x06, 0x05fc);
-                MP_WritePhyUshort(sc, 0x06, 0x0280);
-                MP_WritePhyUshort(sc, 0x06, 0x8802);
-                MP_WritePhyUshort(sc, 0x06, 0x32dd);
-                MP_WritePhyUshort(sc, 0x06, 0xfc04);
-                MP_WritePhyUshort(sc, 0x06, 0xf8f9);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x81ac);
-                MP_WritePhyUshort(sc, 0x06, 0x261a);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x81ac);
-                MP_WritePhyUshort(sc, 0x06, 0x2114);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x85ac);
-                MP_WritePhyUshort(sc, 0x06, 0x200e);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x85ac);
-                MP_WritePhyUshort(sc, 0x06, 0x2308);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x87ac);
-                MP_WritePhyUshort(sc, 0x06, 0x2402);
-                MP_WritePhyUshort(sc, 0x06, 0xae38);
-                MP_WritePhyUshort(sc, 0x06, 0x021a);
-                MP_WritePhyUshort(sc, 0x06, 0xd6ee);
-                MP_WritePhyUshort(sc, 0x06, 0xe41c);
-                MP_WritePhyUshort(sc, 0x06, 0x04ee);
-                MP_WritePhyUshort(sc, 0x06, 0xe41d);
-                MP_WritePhyUshort(sc, 0x06, 0x04e2);
-                MP_WritePhyUshort(sc, 0x06, 0xe07c);
-                MP_WritePhyUshort(sc, 0x06, 0xe3e0);
-                MP_WritePhyUshort(sc, 0x06, 0x7de0);
-                MP_WritePhyUshort(sc, 0x06, 0xe038);
-                MP_WritePhyUshort(sc, 0x06, 0xe1e0);
-                MP_WritePhyUshort(sc, 0x06, 0x39ad);
-                MP_WritePhyUshort(sc, 0x06, 0x2e1b);
-                MP_WritePhyUshort(sc, 0x06, 0xad39);
-                MP_WritePhyUshort(sc, 0x06, 0x0dd1);
-                MP_WritePhyUshort(sc, 0x06, 0x01bf);
-                MP_WritePhyUshort(sc, 0x06, 0x22c8);
-                MP_WritePhyUshort(sc, 0x06, 0x0239);
-                MP_WritePhyUshort(sc, 0x06, 0xf302);
-                MP_WritePhyUshort(sc, 0x06, 0x21f0);
-                MP_WritePhyUshort(sc, 0x06, 0xae0b);
-                MP_WritePhyUshort(sc, 0x06, 0xac38);
-                MP_WritePhyUshort(sc, 0x06, 0x02ae);
-                MP_WritePhyUshort(sc, 0x06, 0x0602);
-                MP_WritePhyUshort(sc, 0x06, 0x222d);
-                MP_WritePhyUshort(sc, 0x06, 0x0222);
-                MP_WritePhyUshort(sc, 0x06, 0x7202);
-                MP_WritePhyUshort(sc, 0x06, 0x1ae7);
-                MP_WritePhyUshort(sc, 0x06, 0xfdfc);
-                MP_WritePhyUshort(sc, 0x06, 0x04f8);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x8ead);
-                MP_WritePhyUshort(sc, 0x06, 0x201a);
-                MP_WritePhyUshort(sc, 0x06, 0xf620);
-                MP_WritePhyUshort(sc, 0x06, 0xe48b);
-                MP_WritePhyUshort(sc, 0x06, 0x8e02);
-                MP_WritePhyUshort(sc, 0x06, 0x2afe);
-                MP_WritePhyUshort(sc, 0x06, 0x022c);
-                MP_WritePhyUshort(sc, 0x06, 0x5c02);
-                MP_WritePhyUshort(sc, 0x06, 0x03c5);
-                MP_WritePhyUshort(sc, 0x06, 0x0281);
-                MP_WritePhyUshort(sc, 0x06, 0x6702);
-                MP_WritePhyUshort(sc, 0x06, 0x2e4f);
-                MP_WritePhyUshort(sc, 0x06, 0x0204);
-                MP_WritePhyUshort(sc, 0x06, 0x8902);
-                MP_WritePhyUshort(sc, 0x06, 0x2f7a);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x8ead);
-                MP_WritePhyUshort(sc, 0x06, 0x210b);
-                MP_WritePhyUshort(sc, 0x06, 0xf621);
-                MP_WritePhyUshort(sc, 0x06, 0xe48b);
-                MP_WritePhyUshort(sc, 0x06, 0x8e02);
-                MP_WritePhyUshort(sc, 0x06, 0x0445);
-                MP_WritePhyUshort(sc, 0x06, 0x021c);
-                MP_WritePhyUshort(sc, 0x06, 0xb8e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8e);
-                MP_WritePhyUshort(sc, 0x06, 0xad22);
-                MP_WritePhyUshort(sc, 0x06, 0x08f6);
-                MP_WritePhyUshort(sc, 0x06, 0x22e4);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8e);
-                MP_WritePhyUshort(sc, 0x06, 0x0235);
-                MP_WritePhyUshort(sc, 0x06, 0xd4e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8e);
-                MP_WritePhyUshort(sc, 0x06, 0xad23);
-                MP_WritePhyUshort(sc, 0x06, 0x08f6);
-                MP_WritePhyUshort(sc, 0x06, 0x23e4);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8e);
-                MP_WritePhyUshort(sc, 0x06, 0x0231);
-                MP_WritePhyUshort(sc, 0x06, 0xc8e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8e);
-                MP_WritePhyUshort(sc, 0x06, 0xad24);
-                MP_WritePhyUshort(sc, 0x06, 0x05f6);
-                MP_WritePhyUshort(sc, 0x06, 0x24e4);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8e);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x8ead);
-                MP_WritePhyUshort(sc, 0x06, 0x2505);
-                MP_WritePhyUshort(sc, 0x06, 0xf625);
-                MP_WritePhyUshort(sc, 0x06, 0xe48b);
-                MP_WritePhyUshort(sc, 0x06, 0x8ee0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8e);
-                MP_WritePhyUshort(sc, 0x06, 0xad26);
-                MP_WritePhyUshort(sc, 0x06, 0x08f6);
-                MP_WritePhyUshort(sc, 0x06, 0x26e4);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8e);
-                MP_WritePhyUshort(sc, 0x06, 0x022d);
-                MP_WritePhyUshort(sc, 0x06, 0x6ae0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8e);
-                MP_WritePhyUshort(sc, 0x06, 0xad27);
-                MP_WritePhyUshort(sc, 0x06, 0x05f6);
-                MP_WritePhyUshort(sc, 0x06, 0x27e4);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8e);
-                MP_WritePhyUshort(sc, 0x06, 0x0203);
-                MP_WritePhyUshort(sc, 0x06, 0x8bfc);
-                MP_WritePhyUshort(sc, 0x06, 0x04f8);
-                MP_WritePhyUshort(sc, 0x06, 0xfaef);
-                MP_WritePhyUshort(sc, 0x06, 0x69e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b80);
-                MP_WritePhyUshort(sc, 0x06, 0xad27);
-                MP_WritePhyUshort(sc, 0x06, 0x22bf);
-                MP_WritePhyUshort(sc, 0x06, 0x479a);
-                MP_WritePhyUshort(sc, 0x06, 0x0239);
-                MP_WritePhyUshort(sc, 0x06, 0xc6e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b44);
-                MP_WritePhyUshort(sc, 0x06, 0x1f01);
-                MP_WritePhyUshort(sc, 0x06, 0x9e15);
-                MP_WritePhyUshort(sc, 0x06, 0xe58b);
-                MP_WritePhyUshort(sc, 0x06, 0x44ad);
-                MP_WritePhyUshort(sc, 0x06, 0x2907);
-                MP_WritePhyUshort(sc, 0x06, 0xac28);
-                MP_WritePhyUshort(sc, 0x06, 0x04d1);
-                MP_WritePhyUshort(sc, 0x06, 0x01ae);
-                MP_WritePhyUshort(sc, 0x06, 0x02d1);
-                MP_WritePhyUshort(sc, 0x06, 0x00bf);
-                MP_WritePhyUshort(sc, 0x06, 0x819e);
-                MP_WritePhyUshort(sc, 0x06, 0x0239);
-                MP_WritePhyUshort(sc, 0x06, 0xf3ef);
-                MP_WritePhyUshort(sc, 0x06, 0x96fe);
-                MP_WritePhyUshort(sc, 0x06, 0xfc04);
-                MP_WritePhyUshort(sc, 0x06, 0x00e1);
-                MP_WritePhyUshort(sc, 0x06, 0x4077);
-                MP_WritePhyUshort(sc, 0x06, 0xe140);
-                MP_WritePhyUshort(sc, 0x06, 0xbbe0);
-                MP_WritePhyUshort(sc, 0x06, 0x2a00);
-                MP_WritePhyUshort(sc, 0x05, 0xe142);
-                Data = MP_ReadPhyUshort(sc, 0x06);
-                Data |= BIT_0;
-                MP_WritePhyUshort(sc, 0x06, Data);
-                MP_WritePhyUshort(sc, 0x05, 0xe140);
-                Data = MP_ReadPhyUshort(sc, 0x06);
-                Data |= BIT_0;
-                MP_WritePhyUshort(sc, 0x06, Data);
-                MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                MP_WritePhyUshort(sc, 0x1f, 0x0007);
-                MP_WritePhyUshort(sc, 0x1e, 0x0023);
-                Data = MP_ReadPhyUshort(sc, 0x17);
-                Data |= BIT_1;
-                MP_WritePhyUshort(sc, 0x17, Data);
-                MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                MP_WritePhyUshort(sc, 0x1f, 0x0003);
-                Data = MP_ReadPhyUshort(sc, 0x19);
-                Data &= ~BIT_0;
-                MP_WritePhyUshort(sc, 0x19, Data);
-                Data = MP_ReadPhyUshort(sc, 0x10);
-                Data &= ~BIT_10;
-                MP_WritePhyUshort(sc, 0x10, Data);
-                MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                MP_WritePhyUshort(sc, 0x00, 0x9200);
 
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+                MP_WritePhyUshort(sc, 0x0D, 0x0007);
+                MP_WritePhyUshort(sc, 0x0E, 0x003C);
+                MP_WritePhyUshort(sc, 0x0D, 0x4007);
+                MP_WritePhyUshort(sc, 0x0E, 0x0000);
+                MP_WritePhyUshort(sc, 0x0D, 0x0000);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+                MP_WritePhyUshort(sc, 0x0D, 0x0003);
+                MP_WritePhyUshort(sc, 0x0E, 0x0015);
+                MP_WritePhyUshort(sc, 0x0D, 0x4003);
+                MP_WritePhyUshort(sc, 0x0E, 0x0000);
+                MP_WritePhyUshort(sc, 0x0D, 0x0000);
+
+        } else if (sc->re_type == MACFG_50) {
                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
                 MP_WritePhyUshort(sc, 0x05, 0x8B80);
                 Data = MP_ReadPhyUshort(sc, 0x06);
@@ -16891,615 +23272,150 @@ static void re_hw_phy_config(struct re_softc *sc)
                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
 
                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
-                MP_WritePhyUshort(sc, 0x05, 0x8B54);
-                Data = MP_ReadPhyUshort(sc, 0x06);
-                Data &= ~BIT_11;
-                MP_WritePhyUshort(sc, 0x06, Data);
-                MP_WritePhyUshort(sc, 0x05, 0x8B5D);
-                Data = MP_ReadPhyUshort(sc, 0x06);
-                Data &= ~BIT_11;
-                MP_WritePhyUshort(sc, 0x06, Data);
-                MP_WritePhyUshort(sc, 0x05, 0x8A7C);
-                Data = MP_ReadPhyUshort(sc, 0x06);
-                Data &= ~BIT_8;
-                MP_WritePhyUshort(sc, 0x06, Data);
-                MP_WritePhyUshort(sc, 0x05, 0x8A7F);
-                Data = MP_ReadPhyUshort(sc, 0x06);
-                Data |= BIT_8;
-                MP_WritePhyUshort(sc, 0x06, Data);
-                MP_WritePhyUshort(sc, 0x05, 0x8A82);
-                Data = MP_ReadPhyUshort(sc, 0x06);
-                Data &= ~BIT_8;
-                MP_WritePhyUshort(sc, 0x06, Data);
-                MP_WritePhyUshort(sc, 0x05, 0x8A85);
-                Data = MP_ReadPhyUshort(sc, 0x06);
-                Data &= ~BIT_8;
-                MP_WritePhyUshort(sc, 0x06, Data);
-                MP_WritePhyUshort(sc, 0x05, 0x8A88);
+                MP_WritePhyUshort(sc, 0x05, 0x8B85);
                 Data = MP_ReadPhyUshort(sc, 0x06);
-                Data &= ~BIT_8;
+                Data |= BIT_14;
                 MP_WritePhyUshort(sc, 0x06, Data);
+                MP_WritePhyUshort(sc, 0x1f, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0003);
+                MP_WritePhyUshort(sc, 0x09, 0xA20F);
                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
 
                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
-                MP_WritePhyUshort(sc, 0x05, 0x8B85);
-                Data = MP_ReadPhyUshort(sc, 0x06);
-                Data |= BIT_15;
-                MP_WritePhyUshort(sc, 0x06, Data);
+                MP_WritePhyUshort(sc, 0x05, 0x8B55);
+                MP_WritePhyUshort(sc, 0x06, 0x0000);
+                MP_WritePhyUshort(sc, 0x05, 0x8B5E);
+                MP_WritePhyUshort(sc, 0x06, 0x0000);
+                MP_WritePhyUshort(sc, 0x05, 0x8B67);
+                MP_WritePhyUshort(sc, 0x06, 0x0000);
+                MP_WritePhyUshort(sc, 0x05, 0x8B70);
+                MP_WritePhyUshort(sc, 0x06, 0x0000);
                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1f, 0x0003);
-                Data = MP_ReadPhyUshort(sc, 0x19);
-                Data &= ~BIT_0;
-                MP_WritePhyUshort(sc, 0x19, Data);
-                Data = MP_ReadPhyUshort(sc, 0x10);
-                Data &= ~BIT_10;
-                MP_WritePhyUshort(sc, 0x10, Data);
+                MP_WritePhyUshort(sc, 0x1F, 0x0007);
+                MP_WritePhyUshort(sc, 0x1E, 0x0078);
+                MP_WritePhyUshort(sc, 0x17, 0x0000);
+                MP_WritePhyUshort(sc, 0x19, 0x00FB);
                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
-        } else if (sc->re_type == MACFG_52) {
-                Data_u32 = re_eri_read(sc, 0x1D0, 4, ERIAR_ExGMAC);
-                Data_u32 &= ~BIT_1;
-                re_eri_write(sc, 0x1D0, 4, Data_u32, ERIAR_ExGMAC);
 
-                MP_WritePhyUshort(sc,0x1f, 0x0000);
-                MP_WritePhyUshort(sc,0x00, 0x1800);
-                Data = MP_ReadPhyUshort(sc, 0x15);
-                Data &= ~(BIT_12);
-                MP_WritePhyUshort(sc,0x15, Data);
-                MP_WritePhyUshort(sc,0x00, 0x4800);
-                MP_WritePhyUshort(sc,0x1f, 0x0007);
-                MP_WritePhyUshort(sc,0x1e, 0x002f);
-                for (i = 0; i < 1000; i++) {
-                        DELAY(100);
-                        Data = MP_ReadPhyUshort(sc, 0x1c);
-                        if (Data & BIT_7)
-                                break;
-                }
-                MP_WritePhyUshort(sc,0x1f, 0x0000);
-                MP_WritePhyUshort(sc,0x00, 0x1800);
-                MP_WritePhyUshort(sc,0x1f, 0x0007);
-                MP_WritePhyUshort(sc,0x1e, 0x0023);
-                for (i = 0; i < 200; i++) {
-                        DELAY(100);
-                        Data = MP_ReadPhyUshort(sc, 0x18);
-                        if (!(Data & BIT_0))
-                                break;
-                }
-                MP_WritePhyUshort(sc,0x1f, 0x0005);
-                MP_WritePhyUshort(sc,0x05, 0xfff6);
-                MP_WritePhyUshort(sc,0x06, 0x0080);
-                MP_WritePhyUshort(sc, 0x1f, 0x0007);
-                MP_WritePhyUshort(sc, 0x1e, 0x0023);
-                MP_WritePhyUshort(sc, 0x16, 0x0306);
-                MP_WritePhyUshort(sc, 0x16, 0x0307);
-                MP_WritePhyUshort(sc, 0x15, 0x0098);
-                MP_WritePhyUshort(sc, 0x19, 0x7c0b);
-                MP_WritePhyUshort(sc, 0x15, 0x0099);
-                MP_WritePhyUshort(sc, 0x19, 0x6c0b);
-                MP_WritePhyUshort(sc, 0x15, 0x00eb);
-                MP_WritePhyUshort(sc, 0x19, 0x6c0b);
-                MP_WritePhyUshort(sc, 0x15, 0x00f8);
-                MP_WritePhyUshort(sc, 0x19, 0x6f0b);
-                MP_WritePhyUshort(sc, 0x15, 0x00fe);
-                MP_WritePhyUshort(sc, 0x19, 0x6f0f);
-                MP_WritePhyUshort(sc, 0x15, 0x00db);
-                MP_WritePhyUshort(sc, 0x19, 0x6f09);
-                MP_WritePhyUshort(sc, 0x15, 0x00dc);
-                MP_WritePhyUshort(sc, 0x19, 0xaefd);
-                MP_WritePhyUshort(sc, 0x15, 0x00dd);
-                MP_WritePhyUshort(sc, 0x19, 0x6f0b);
-                MP_WritePhyUshort(sc, 0x15, 0x00de);
-                MP_WritePhyUshort(sc, 0x19, 0xc60b);
-                MP_WritePhyUshort(sc, 0x15, 0x00df);
-                MP_WritePhyUshort(sc, 0x19, 0x00fa);
-                MP_WritePhyUshort(sc, 0x15, 0x00e0);
-                MP_WritePhyUshort(sc, 0x19, 0x30e1);
-                MP_WritePhyUshort(sc, 0x15, 0x020c);
-                MP_WritePhyUshort(sc, 0x19, 0x3224);
-                MP_WritePhyUshort(sc, 0x15, 0x020e);
-                MP_WritePhyUshort(sc, 0x19, 0x9813);
-                MP_WritePhyUshort(sc, 0x15, 0x020f);
-                MP_WritePhyUshort(sc, 0x19, 0x7801);
-                MP_WritePhyUshort(sc, 0x15, 0x0210);
-                MP_WritePhyUshort(sc, 0x19, 0x930f);
-                MP_WritePhyUshort(sc, 0x15, 0x0211);
-                MP_WritePhyUshort(sc, 0x19, 0x9206);
-                MP_WritePhyUshort(sc, 0x15, 0x0212);
-                MP_WritePhyUshort(sc, 0x19, 0x4002);
-                MP_WritePhyUshort(sc, 0x15, 0x0213);
-                MP_WritePhyUshort(sc, 0x19, 0x7800);
-                MP_WritePhyUshort(sc, 0x15, 0x0214);
-                MP_WritePhyUshort(sc, 0x19, 0x588f);
-                MP_WritePhyUshort(sc, 0x15, 0x0215);
-                MP_WritePhyUshort(sc, 0x19, 0x5520);
-                MP_WritePhyUshort(sc, 0x15, 0x0216);
-                MP_WritePhyUshort(sc, 0x19, 0x3224);
-                MP_WritePhyUshort(sc, 0x15, 0x0217);
-                MP_WritePhyUshort(sc, 0x19, 0x4002);
-                MP_WritePhyUshort(sc, 0x15, 0x0218);
-                MP_WritePhyUshort(sc, 0x19, 0x7800);
-                MP_WritePhyUshort(sc, 0x15, 0x0219);
-                MP_WritePhyUshort(sc, 0x19, 0x588d);
-                MP_WritePhyUshort(sc, 0x15, 0x021a);
-                MP_WritePhyUshort(sc, 0x19, 0x5540);
-                MP_WritePhyUshort(sc, 0x15, 0x021b);
-                MP_WritePhyUshort(sc, 0x19, 0x9e03);
-                MP_WritePhyUshort(sc, 0x15, 0x021c);
-                MP_WritePhyUshort(sc, 0x19, 0x7c40);
-                MP_WritePhyUshort(sc, 0x15, 0x021d);
-                MP_WritePhyUshort(sc, 0x19, 0x6840);
-                MP_WritePhyUshort(sc, 0x15, 0x021e);
-                MP_WritePhyUshort(sc, 0x19, 0x3224);
-                MP_WritePhyUshort(sc, 0x15, 0x021f);
-                MP_WritePhyUshort(sc, 0x19, 0x4002);
-                MP_WritePhyUshort(sc, 0x15, 0x0220);
-                MP_WritePhyUshort(sc, 0x19, 0x3224);
-                MP_WritePhyUshort(sc, 0x15, 0x0221);
-                MP_WritePhyUshort(sc, 0x19, 0x9e03);
-                MP_WritePhyUshort(sc, 0x15, 0x0222);
-                MP_WritePhyUshort(sc, 0x19, 0x7c40);
-                MP_WritePhyUshort(sc, 0x15, 0x0223);
-                MP_WritePhyUshort(sc, 0x19, 0x6840);
-                MP_WritePhyUshort(sc, 0x15, 0x0224);
-                MP_WritePhyUshort(sc, 0x19, 0x7800);
-                MP_WritePhyUshort(sc, 0x15, 0x0225);
-                MP_WritePhyUshort(sc, 0x19, 0x3231);
-                MP_WritePhyUshort(sc, 0x15, 0x0000);
-                MP_WritePhyUshort(sc, 0x16, 0x0306);
-                MP_WritePhyUshort(sc, 0x16, 0x0300);
+                MP_WritePhyUshort(sc, 0x1F, 0x0005);
+                MP_WritePhyUshort(sc, 0x05, 0x8B79);
+                MP_WritePhyUshort(sc, 0x06, 0xAA00);
                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                MP_WritePhyUshort(sc, 0x1f, 0x0005);
-                MP_WritePhyUshort(sc, 0x05, 0xfff6);
-                MP_WritePhyUshort(sc, 0x06, 0x0080);
-                MP_WritePhyUshort(sc, 0x05, 0x8000);
-                MP_WritePhyUshort(sc, 0x06, 0x0280);
-                MP_WritePhyUshort(sc, 0x06, 0x48f7);
-                MP_WritePhyUshort(sc, 0x06, 0x00e0);
-                MP_WritePhyUshort(sc, 0x06, 0xfff7);
-                MP_WritePhyUshort(sc, 0x06, 0xa080);
-                MP_WritePhyUshort(sc, 0x06, 0x02ae);
-                MP_WritePhyUshort(sc, 0x06, 0xf602);
-                MP_WritePhyUshort(sc, 0x06, 0x011e);
-                MP_WritePhyUshort(sc, 0x06, 0x0201);
-                MP_WritePhyUshort(sc, 0x06, 0x2b02);
-                MP_WritePhyUshort(sc, 0x06, 0x8077);
-                MP_WritePhyUshort(sc, 0x06, 0x0201);
-                MP_WritePhyUshort(sc, 0x06, 0x4802);
-                MP_WritePhyUshort(sc, 0x06, 0x0162);
-                MP_WritePhyUshort(sc, 0x06, 0x0280);
-                MP_WritePhyUshort(sc, 0x06, 0x9402);
-                MP_WritePhyUshort(sc, 0x06, 0x810e);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x88e1);
-                MP_WritePhyUshort(sc, 0x06, 0x8b89);
-                MP_WritePhyUshort(sc, 0x06, 0x1e01);
-                MP_WritePhyUshort(sc, 0x06, 0xe18b);
-                MP_WritePhyUshort(sc, 0x06, 0x8a1e);
-                MP_WritePhyUshort(sc, 0x06, 0x01e1);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8b);
-                MP_WritePhyUshort(sc, 0x06, 0x1e01);
-                MP_WritePhyUshort(sc, 0x06, 0xe18b);
-                MP_WritePhyUshort(sc, 0x06, 0x8c1e);
-                MP_WritePhyUshort(sc, 0x06, 0x01e1);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8d);
-                MP_WritePhyUshort(sc, 0x06, 0x1e01);
-                MP_WritePhyUshort(sc, 0x06, 0xe18b);
-                MP_WritePhyUshort(sc, 0x06, 0x8e1e);
-                MP_WritePhyUshort(sc, 0x06, 0x01a0);
-                MP_WritePhyUshort(sc, 0x06, 0x00c7);
-                MP_WritePhyUshort(sc, 0x06, 0xaebb);
-                MP_WritePhyUshort(sc, 0x06, 0xd481);
-                MP_WritePhyUshort(sc, 0x06, 0xd4e4);
-                MP_WritePhyUshort(sc, 0x06, 0x8b92);
-                MP_WritePhyUshort(sc, 0x06, 0xe58b);
-                MP_WritePhyUshort(sc, 0x06, 0x9302);
-                MP_WritePhyUshort(sc, 0x06, 0x2e5a);
-                MP_WritePhyUshort(sc, 0x06, 0xbf8b);
-                MP_WritePhyUshort(sc, 0x06, 0x88ec);
-                MP_WritePhyUshort(sc, 0x06, 0x0019);
-                MP_WritePhyUshort(sc, 0x06, 0xa98b);
-                MP_WritePhyUshort(sc, 0x06, 0x90f9);
-                MP_WritePhyUshort(sc, 0x06, 0xeeff);
-                MP_WritePhyUshort(sc, 0x06, 0xf600);
-                MP_WritePhyUshort(sc, 0x06, 0xeeff);
-                MP_WritePhyUshort(sc, 0x06, 0xf7fc);
-                MP_WritePhyUshort(sc, 0x06, 0xd100);
-                MP_WritePhyUshort(sc, 0x06, 0xbf83);
-                MP_WritePhyUshort(sc, 0x06, 0x3c02);
-                MP_WritePhyUshort(sc, 0x06, 0x3a21);
-                MP_WritePhyUshort(sc, 0x06, 0xd101);
-                MP_WritePhyUshort(sc, 0x06, 0xbf83);
-                MP_WritePhyUshort(sc, 0x06, 0x3f02);
-                MP_WritePhyUshort(sc, 0x06, 0x3a21);
-                MP_WritePhyUshort(sc, 0x06, 0x04f8);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x8aad);
-                MP_WritePhyUshort(sc, 0x06, 0x2014);
-                MP_WritePhyUshort(sc, 0x06, 0xee8b);
-                MP_WritePhyUshort(sc, 0x06, 0x8a00);
-                MP_WritePhyUshort(sc, 0x06, 0x0220);
-                MP_WritePhyUshort(sc, 0x06, 0x8be0);
-                MP_WritePhyUshort(sc, 0x06, 0xe426);
-                MP_WritePhyUshort(sc, 0x06, 0xe1e4);
-                MP_WritePhyUshort(sc, 0x06, 0x27ee);
-                MP_WritePhyUshort(sc, 0x06, 0xe426);
-                MP_WritePhyUshort(sc, 0x06, 0x23e5);
-                MP_WritePhyUshort(sc, 0x06, 0xe427);
-                MP_WritePhyUshort(sc, 0x06, 0xfc04);
-                MP_WritePhyUshort(sc, 0x06, 0xf8e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8d);
-                MP_WritePhyUshort(sc, 0x06, 0xad20);
-                MP_WritePhyUshort(sc, 0x06, 0x14ee);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8d);
-                MP_WritePhyUshort(sc, 0x06, 0x00e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8a5a);
-                MP_WritePhyUshort(sc, 0x06, 0x7803);
-                MP_WritePhyUshort(sc, 0x06, 0x9e09);
-                MP_WritePhyUshort(sc, 0x06, 0x0206);
-                MP_WritePhyUshort(sc, 0x06, 0x2802);
-                MP_WritePhyUshort(sc, 0x06, 0x80b1);
-                MP_WritePhyUshort(sc, 0x06, 0x0232);
-                MP_WritePhyUshort(sc, 0x06, 0xfdfc);
-                MP_WritePhyUshort(sc, 0x06, 0x04f8);
-                MP_WritePhyUshort(sc, 0x06, 0xf9e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b81);
-                MP_WritePhyUshort(sc, 0x06, 0xac26);
-                MP_WritePhyUshort(sc, 0x06, 0x1ae0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b81);
-                MP_WritePhyUshort(sc, 0x06, 0xac21);
-                MP_WritePhyUshort(sc, 0x06, 0x14e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b85);
-                MP_WritePhyUshort(sc, 0x06, 0xac20);
-                MP_WritePhyUshort(sc, 0x06, 0x0ee0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b85);
-                MP_WritePhyUshort(sc, 0x06, 0xac23);
-                MP_WritePhyUshort(sc, 0x06, 0x08e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b87);
-                MP_WritePhyUshort(sc, 0x06, 0xac24);
-                MP_WritePhyUshort(sc, 0x06, 0x02ae);
-                MP_WritePhyUshort(sc, 0x06, 0x3802);
-                MP_WritePhyUshort(sc, 0x06, 0x1b02);
-                MP_WritePhyUshort(sc, 0x06, 0xeee4);
-                MP_WritePhyUshort(sc, 0x06, 0x1c04);
-                MP_WritePhyUshort(sc, 0x06, 0xeee4);
-                MP_WritePhyUshort(sc, 0x06, 0x1d04);
-                MP_WritePhyUshort(sc, 0x06, 0xe2e0);
-                MP_WritePhyUshort(sc, 0x06, 0x7ce3);
-                MP_WritePhyUshort(sc, 0x06, 0xe07d);
-                MP_WritePhyUshort(sc, 0x06, 0xe0e0);
-                MP_WritePhyUshort(sc, 0x06, 0x38e1);
-                MP_WritePhyUshort(sc, 0x06, 0xe039);
-                MP_WritePhyUshort(sc, 0x06, 0xad2e);
-                MP_WritePhyUshort(sc, 0x06, 0x1bad);
-                MP_WritePhyUshort(sc, 0x06, 0x390d);
-                MP_WritePhyUshort(sc, 0x06, 0xd101);
-                MP_WritePhyUshort(sc, 0x06, 0xbf22);
-                MP_WritePhyUshort(sc, 0x06, 0xe802);
-                MP_WritePhyUshort(sc, 0x06, 0x3a21);
-                MP_WritePhyUshort(sc, 0x06, 0x0222);
-                MP_WritePhyUshort(sc, 0x06, 0x10ae);
-                MP_WritePhyUshort(sc, 0x06, 0x0bac);
-                MP_WritePhyUshort(sc, 0x06, 0x3802);
-                MP_WritePhyUshort(sc, 0x06, 0xae06);
-                MP_WritePhyUshort(sc, 0x06, 0x0222);
-                MP_WritePhyUshort(sc, 0x06, 0x4d02);
-                MP_WritePhyUshort(sc, 0x06, 0x2292);
-                MP_WritePhyUshort(sc, 0x06, 0x021b);
-                MP_WritePhyUshort(sc, 0x06, 0x13fd);
-                MP_WritePhyUshort(sc, 0x06, 0xfc04);
-                MP_WritePhyUshort(sc, 0x06, 0xf8e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8e);
-                MP_WritePhyUshort(sc, 0x06, 0xad20);
-                MP_WritePhyUshort(sc, 0x06, 0x1af6);
-                MP_WritePhyUshort(sc, 0x06, 0x20e4);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8e);
-                MP_WritePhyUshort(sc, 0x06, 0x022b);
-                MP_WritePhyUshort(sc, 0x06, 0x1e02);
-                MP_WritePhyUshort(sc, 0x06, 0x82ae);
-                MP_WritePhyUshort(sc, 0x06, 0x0203);
-                MP_WritePhyUshort(sc, 0x06, 0xc002);
-                MP_WritePhyUshort(sc, 0x06, 0x827d);
-                MP_WritePhyUshort(sc, 0x06, 0x022e);
-                MP_WritePhyUshort(sc, 0x06, 0x6f02);
-                MP_WritePhyUshort(sc, 0x06, 0x047b);
-                MP_WritePhyUshort(sc, 0x06, 0x022f);
-                MP_WritePhyUshort(sc, 0x06, 0x9ae0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8e);
-                MP_WritePhyUshort(sc, 0x06, 0xad21);
-                MP_WritePhyUshort(sc, 0x06, 0x0bf6);
-                MP_WritePhyUshort(sc, 0x06, 0x21e4);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8e);
-                MP_WritePhyUshort(sc, 0x06, 0x0281);
-                MP_WritePhyUshort(sc, 0x06, 0x9002);
-                MP_WritePhyUshort(sc, 0x06, 0x1cd9);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x8ead);
-                MP_WritePhyUshort(sc, 0x06, 0x2208);
-                MP_WritePhyUshort(sc, 0x06, 0xf622);
-                MP_WritePhyUshort(sc, 0x06, 0xe48b);
-                MP_WritePhyUshort(sc, 0x06, 0x8e02);
-                MP_WritePhyUshort(sc, 0x06, 0x35f4);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x8ead);
-                MP_WritePhyUshort(sc, 0x06, 0x2308);
-                MP_WritePhyUshort(sc, 0x06, 0xf623);
-                MP_WritePhyUshort(sc, 0x06, 0xe48b);
-                MP_WritePhyUshort(sc, 0x06, 0x8e02);
-                MP_WritePhyUshort(sc, 0x06, 0x31e8);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x8ead);
-                MP_WritePhyUshort(sc, 0x06, 0x2405);
-                MP_WritePhyUshort(sc, 0x06, 0xf624);
-                MP_WritePhyUshort(sc, 0x06, 0xe48b);
-                MP_WritePhyUshort(sc, 0x06, 0x8ee0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8e);
-                MP_WritePhyUshort(sc, 0x06, 0xad25);
-                MP_WritePhyUshort(sc, 0x06, 0x05f6);
-                MP_WritePhyUshort(sc, 0x06, 0x25e4);
-                MP_WritePhyUshort(sc, 0x06, 0x8b8e);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x8ead);
-                MP_WritePhyUshort(sc, 0x06, 0x2608);
-                MP_WritePhyUshort(sc, 0x06, 0xf626);
-                MP_WritePhyUshort(sc, 0x06, 0xe48b);
-                MP_WritePhyUshort(sc, 0x06, 0x8e02);
-                MP_WritePhyUshort(sc, 0x06, 0x2d8a);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x8ead);
-                MP_WritePhyUshort(sc, 0x06, 0x2705);
-                MP_WritePhyUshort(sc, 0x06, 0xf627);
-                MP_WritePhyUshort(sc, 0x06, 0xe48b);
-                MP_WritePhyUshort(sc, 0x06, 0x8e02);
-                MP_WritePhyUshort(sc, 0x06, 0x0386);
-                MP_WritePhyUshort(sc, 0x06, 0xfc04);
-                MP_WritePhyUshort(sc, 0x06, 0xf8fa);
-                MP_WritePhyUshort(sc, 0x06, 0xef69);
-                MP_WritePhyUshort(sc, 0x06, 0xe0e0);
-                MP_WritePhyUshort(sc, 0x06, 0x00e1);
-                MP_WritePhyUshort(sc, 0x06, 0xe001);
-                MP_WritePhyUshort(sc, 0x06, 0xad27);
-                MP_WritePhyUshort(sc, 0x06, 0x32e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b40);
-                MP_WritePhyUshort(sc, 0x06, 0xf720);
-                MP_WritePhyUshort(sc, 0x06, 0xe48b);
-                MP_WritePhyUshort(sc, 0x06, 0x40bf);
-                MP_WritePhyUshort(sc, 0x06, 0x32c1);
-                MP_WritePhyUshort(sc, 0x06, 0x0239);
-                MP_WritePhyUshort(sc, 0x06, 0xf4ad);
-                MP_WritePhyUshort(sc, 0x06, 0x2821);
-                MP_WritePhyUshort(sc, 0x06, 0xe0e0);
-                MP_WritePhyUshort(sc, 0x06, 0x20e1);
-                MP_WritePhyUshort(sc, 0x06, 0xe021);
-                MP_WritePhyUshort(sc, 0x06, 0xad20);
-                MP_WritePhyUshort(sc, 0x06, 0x18e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b40);
-                MP_WritePhyUshort(sc, 0x06, 0xf620);
-                MP_WritePhyUshort(sc, 0x06, 0xe48b);
-                MP_WritePhyUshort(sc, 0x06, 0x40ee);
-                MP_WritePhyUshort(sc, 0x06, 0x8b3b);
-                MP_WritePhyUshort(sc, 0x06, 0xffe0);
-                MP_WritePhyUshort(sc, 0x06, 0x8a8a);
-                MP_WritePhyUshort(sc, 0x06, 0xe18a);
-                MP_WritePhyUshort(sc, 0x06, 0x8be4);
-                MP_WritePhyUshort(sc, 0x06, 0xe000);
-                MP_WritePhyUshort(sc, 0x06, 0xe5e0);
-                MP_WritePhyUshort(sc, 0x06, 0x01ef);
-                MP_WritePhyUshort(sc, 0x06, 0x96fe);
-                MP_WritePhyUshort(sc, 0x06, 0xfc04);
-                MP_WritePhyUshort(sc, 0x06, 0xf8f9);
-                MP_WritePhyUshort(sc, 0x06, 0xface);
-                MP_WritePhyUshort(sc, 0x06, 0xfaef);
-                MP_WritePhyUshort(sc, 0x06, 0x69fa);
-                MP_WritePhyUshort(sc, 0x06, 0xd401);
-                MP_WritePhyUshort(sc, 0x06, 0x55b4);
-                MP_WritePhyUshort(sc, 0x06, 0xfebf);
-                MP_WritePhyUshort(sc, 0x06, 0x1c5e);
-                MP_WritePhyUshort(sc, 0x06, 0x0239);
-                MP_WritePhyUshort(sc, 0x06, 0xf4ac);
-                MP_WritePhyUshort(sc, 0x06, 0x280b);
-                MP_WritePhyUshort(sc, 0x06, 0xbf1c);
-                MP_WritePhyUshort(sc, 0x06, 0x5b02);
-                MP_WritePhyUshort(sc, 0x06, 0x39f4);
-                MP_WritePhyUshort(sc, 0x06, 0xac28);
-                MP_WritePhyUshort(sc, 0x06, 0x49ae);
-                MP_WritePhyUshort(sc, 0x06, 0x64bf);
-                MP_WritePhyUshort(sc, 0x06, 0x1c5b);
-                MP_WritePhyUshort(sc, 0x06, 0x0239);
-                MP_WritePhyUshort(sc, 0x06, 0xf4ac);
-                MP_WritePhyUshort(sc, 0x06, 0x285b);
-                MP_WritePhyUshort(sc, 0x06, 0xd000);
-                MP_WritePhyUshort(sc, 0x06, 0x0282);
-                MP_WritePhyUshort(sc, 0x06, 0x62ac);
-                MP_WritePhyUshort(sc, 0x06, 0x2105);
-                MP_WritePhyUshort(sc, 0x06, 0xac22);
-                MP_WritePhyUshort(sc, 0x06, 0x02ae);
-                MP_WritePhyUshort(sc, 0x06, 0x4ebf);
-                MP_WritePhyUshort(sc, 0x06, 0xe0c4);
-                MP_WritePhyUshort(sc, 0x06, 0xbe85);
-                MP_WritePhyUshort(sc, 0x06, 0xecd2);
-                MP_WritePhyUshort(sc, 0x06, 0x04d8);
-                MP_WritePhyUshort(sc, 0x06, 0x19d9);
-                MP_WritePhyUshort(sc, 0x06, 0x1907);
-                MP_WritePhyUshort(sc, 0x06, 0xdc19);
-                MP_WritePhyUshort(sc, 0x06, 0xdd19);
-                MP_WritePhyUshort(sc, 0x06, 0x0789);
-                MP_WritePhyUshort(sc, 0x06, 0x89ef);
-                MP_WritePhyUshort(sc, 0x06, 0x645e);
-                MP_WritePhyUshort(sc, 0x06, 0x07ff);
-                MP_WritePhyUshort(sc, 0x06, 0x0d65);
-                MP_WritePhyUshort(sc, 0x06, 0x5cf8);
-                MP_WritePhyUshort(sc, 0x06, 0x001e);
-                MP_WritePhyUshort(sc, 0x06, 0x46dc);
-                MP_WritePhyUshort(sc, 0x06, 0x19dd);
-                MP_WritePhyUshort(sc, 0x06, 0x19b2);
-                MP_WritePhyUshort(sc, 0x06, 0xe2d4);
-                MP_WritePhyUshort(sc, 0x06, 0x0001);
-                MP_WritePhyUshort(sc, 0x06, 0xbf1c);
-                MP_WritePhyUshort(sc, 0x06, 0x5b02);
-                MP_WritePhyUshort(sc, 0x06, 0x3a21);
-                MP_WritePhyUshort(sc, 0x06, 0xae1d);
-                MP_WritePhyUshort(sc, 0x06, 0xbee0);
-                MP_WritePhyUshort(sc, 0x06, 0xc4bf);
-                MP_WritePhyUshort(sc, 0x06, 0x85ec);
-                MP_WritePhyUshort(sc, 0x06, 0xd204);
-                MP_WritePhyUshort(sc, 0x06, 0xd819);
-                MP_WritePhyUshort(sc, 0x06, 0xd919);
-                MP_WritePhyUshort(sc, 0x06, 0x07dc);
-                MP_WritePhyUshort(sc, 0x06, 0x19dd);
-                MP_WritePhyUshort(sc, 0x06, 0x1907);
-                MP_WritePhyUshort(sc, 0x06, 0xb2f4);
-                MP_WritePhyUshort(sc, 0x06, 0xd400);
-                MP_WritePhyUshort(sc, 0x06, 0x00bf);
-                MP_WritePhyUshort(sc, 0x06, 0x1c5b);
-                MP_WritePhyUshort(sc, 0x06, 0x023a);
-                MP_WritePhyUshort(sc, 0x06, 0x21fe);
-                MP_WritePhyUshort(sc, 0x06, 0xef96);
-                MP_WritePhyUshort(sc, 0x06, 0xfec6);
-                MP_WritePhyUshort(sc, 0x06, 0xfefd);
-                MP_WritePhyUshort(sc, 0x06, 0xfc05);
-                MP_WritePhyUshort(sc, 0x06, 0xf9e2);
-                MP_WritePhyUshort(sc, 0x06, 0xe0ea);
-                MP_WritePhyUshort(sc, 0x06, 0xe3e0);
-                MP_WritePhyUshort(sc, 0x06, 0xeb5a);
-                MP_WritePhyUshort(sc, 0x06, 0x070c);
-                MP_WritePhyUshort(sc, 0x06, 0x031e);
-                MP_WritePhyUshort(sc, 0x06, 0x20e6);
-                MP_WritePhyUshort(sc, 0x06, 0xe0ea);
-                MP_WritePhyUshort(sc, 0x06, 0xe7e0);
-                MP_WritePhyUshort(sc, 0x06, 0xebe0);
-                MP_WritePhyUshort(sc, 0x06, 0xe0fc);
-                MP_WritePhyUshort(sc, 0x06, 0xe1e0);
-                MP_WritePhyUshort(sc, 0x06, 0xfdfd);
-                MP_WritePhyUshort(sc, 0x06, 0x04f8);
-                MP_WritePhyUshort(sc, 0x06, 0xfaef);
-                MP_WritePhyUshort(sc, 0x06, 0x69e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b80);
-                MP_WritePhyUshort(sc, 0x06, 0xad27);
-                MP_WritePhyUshort(sc, 0x06, 0x22bf);
-                MP_WritePhyUshort(sc, 0x06, 0x47ba);
-                MP_WritePhyUshort(sc, 0x06, 0x0239);
-                MP_WritePhyUshort(sc, 0x06, 0xf4e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b44);
-                MP_WritePhyUshort(sc, 0x06, 0x1f01);
-                MP_WritePhyUshort(sc, 0x06, 0x9e15);
-                MP_WritePhyUshort(sc, 0x06, 0xe58b);
-                MP_WritePhyUshort(sc, 0x06, 0x44ad);
-                MP_WritePhyUshort(sc, 0x06, 0x2907);
-                MP_WritePhyUshort(sc, 0x06, 0xac28);
-                MP_WritePhyUshort(sc, 0x06, 0x04d1);
-                MP_WritePhyUshort(sc, 0x06, 0x01ae);
-                MP_WritePhyUshort(sc, 0x06, 0x02d1);
-                MP_WritePhyUshort(sc, 0x06, 0x00bf);
-                MP_WritePhyUshort(sc, 0x06, 0x8342);
-                MP_WritePhyUshort(sc, 0x06, 0x023a);
-                MP_WritePhyUshort(sc, 0x06, 0x21ef);
-                MP_WritePhyUshort(sc, 0x06, 0x96fe);
-                MP_WritePhyUshort(sc, 0x06, 0xfc04);
-                MP_WritePhyUshort(sc, 0x06, 0xf8e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b85);
-                MP_WritePhyUshort(sc, 0x06, 0xad26);
-                MP_WritePhyUshort(sc, 0x06, 0x30e0);
-                MP_WritePhyUshort(sc, 0x06, 0xe036);
-                MP_WritePhyUshort(sc, 0x06, 0xe1e0);
-                MP_WritePhyUshort(sc, 0x06, 0x37e1);
-                MP_WritePhyUshort(sc, 0x06, 0x8b3f);
-                MP_WritePhyUshort(sc, 0x06, 0x1f10);
-                MP_WritePhyUshort(sc, 0x06, 0x9e23);
-                MP_WritePhyUshort(sc, 0x06, 0xe48b);
-                MP_WritePhyUshort(sc, 0x06, 0x3fac);
-                MP_WritePhyUshort(sc, 0x06, 0x200b);
-                MP_WritePhyUshort(sc, 0x06, 0xac21);
-                MP_WritePhyUshort(sc, 0x06, 0x0dac);
-                MP_WritePhyUshort(sc, 0x06, 0x250f);
-                MP_WritePhyUshort(sc, 0x06, 0xac27);
-                MP_WritePhyUshort(sc, 0x06, 0x11ae);
-                MP_WritePhyUshort(sc, 0x06, 0x1202);
-                MP_WritePhyUshort(sc, 0x06, 0x2cb5);
-                MP_WritePhyUshort(sc, 0x06, 0xae0d);
-                MP_WritePhyUshort(sc, 0x06, 0x0282);
-                MP_WritePhyUshort(sc, 0x06, 0xe7ae);
-                MP_WritePhyUshort(sc, 0x06, 0x0802);
-                MP_WritePhyUshort(sc, 0x06, 0x2cd7);
-                MP_WritePhyUshort(sc, 0x06, 0xae03);
-                MP_WritePhyUshort(sc, 0x06, 0x022c);
-                MP_WritePhyUshort(sc, 0x06, 0xeafc);
-                MP_WritePhyUshort(sc, 0x06, 0x04f8);
-                MP_WritePhyUshort(sc, 0x06, 0xfaef);
-                MP_WritePhyUshort(sc, 0x06, 0x6902);
-                MP_WritePhyUshort(sc, 0x06, 0x8304);
-                MP_WritePhyUshort(sc, 0x06, 0xe0e0);
-                MP_WritePhyUshort(sc, 0x06, 0x14e1);
-                MP_WritePhyUshort(sc, 0x06, 0xe015);
-                MP_WritePhyUshort(sc, 0x06, 0xad26);
-                MP_WritePhyUshort(sc, 0x06, 0x08d1);
-                MP_WritePhyUshort(sc, 0x06, 0x1ebf);
-                MP_WritePhyUshort(sc, 0x06, 0x2d47);
-                MP_WritePhyUshort(sc, 0x06, 0x023a);
-                MP_WritePhyUshort(sc, 0x06, 0x21ef);
-                MP_WritePhyUshort(sc, 0x06, 0x96fe);
-                MP_WritePhyUshort(sc, 0x06, 0xfc04);
-                MP_WritePhyUshort(sc, 0x06, 0xf8e0);
-                MP_WritePhyUshort(sc, 0x06, 0x8b85);
-                MP_WritePhyUshort(sc, 0x06, 0xad27);
-                MP_WritePhyUshort(sc, 0x06, 0x2fd0);
-                MP_WritePhyUshort(sc, 0x06, 0x0b02);
-                MP_WritePhyUshort(sc, 0x06, 0x3826);
-                MP_WritePhyUshort(sc, 0x06, 0x5882);
-                MP_WritePhyUshort(sc, 0x06, 0x7882);
-                MP_WritePhyUshort(sc, 0x06, 0x9f24);
-                MP_WritePhyUshort(sc, 0x06, 0xe08b);
-                MP_WritePhyUshort(sc, 0x06, 0x32e1);
-                MP_WritePhyUshort(sc, 0x06, 0x8b33);
-                MP_WritePhyUshort(sc, 0x06, 0x1f10);
-                MP_WritePhyUshort(sc, 0x06, 0x9e1a);
-                MP_WritePhyUshort(sc, 0x06, 0x10e4);
-                MP_WritePhyUshort(sc, 0x06, 0x8b32);
-                MP_WritePhyUshort(sc, 0x06, 0xe0e0);
-                MP_WritePhyUshort(sc, 0x06, 0x28e1);
-                MP_WritePhyUshort(sc, 0x06, 0xe029);
-                MP_WritePhyUshort(sc, 0x06, 0xf72c);
-                MP_WritePhyUshort(sc, 0x06, 0xe4e0);
-                MP_WritePhyUshort(sc, 0x06, 0x28e5);
-                MP_WritePhyUshort(sc, 0x06, 0xe029);
-                MP_WritePhyUshort(sc, 0x06, 0xf62c);
-                MP_WritePhyUshort(sc, 0x06, 0xe4e0);
-                MP_WritePhyUshort(sc, 0x06, 0x28e5);
-                MP_WritePhyUshort(sc, 0x06, 0xe029);
-                MP_WritePhyUshort(sc, 0x06, 0xfc04);
-                MP_WritePhyUshort(sc, 0x06, 0x00e1);
-                MP_WritePhyUshort(sc, 0x06, 0x4077);
-                MP_WritePhyUshort(sc, 0x06, 0xe140);
-                MP_WritePhyUshort(sc, 0x06, 0xbbe0);
-                MP_WritePhyUshort(sc, 0x06, 0x2a00);
-                MP_WritePhyUshort(sc, 0x05, 0xe142);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0003);
+                MP_WritePhyUshort(sc, 0x01, 0x328A);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0005);
+                MP_WritePhyUshort(sc, 0x05, 0x8B54);
+                Data = MP_ReadPhyUshort(sc, 0x06);
+                Data &= ~BIT_11;
+                MP_WritePhyUshort(sc, 0x06, Data);
+                MP_WritePhyUshort(sc, 0x05, 0x8B5D);
                 Data = MP_ReadPhyUshort(sc, 0x06);
-                Data |= BIT_0;
-                MP_WritePhyUshort(sc,0x06, Data);
-                MP_WritePhyUshort(sc, 0x05, 0xe140);
+                Data &= ~BIT_11;
+                MP_WritePhyUshort(sc, 0x06, Data);
+                MP_WritePhyUshort(sc, 0x05, 0x8A7C);
                 Data = MP_ReadPhyUshort(sc, 0x06);
-                Data |= BIT_0;
-                MP_WritePhyUshort(sc,0x06, Data);
-                MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                MP_WritePhyUshort(sc,0x1f, 0x0005);
-                WaitCnt = 0;
-                for (i = 0; i < 200; i++) {
-                        DELAY(100);
-                        Data = MP_ReadPhyUshort(sc, 0x00);
-                        if (Data & BIT_7)
-                                break;
-                }
-                MP_WritePhyUshort(sc,0x1f, 0x0007);
-                MP_WritePhyUshort(sc,0x1e, 0x0023);
-                Data = MP_ReadPhyUshort(sc, 0x17);
-                Data |= BIT_1;
-                MP_WritePhyUshort(sc, 0x17, Data);
+                Data &= ~BIT_8;
+                MP_WritePhyUshort(sc, 0x06, Data);
+                MP_WritePhyUshort(sc, 0x05, 0x8A7F);
+                Data = MP_ReadPhyUshort(sc, 0x06);
+                Data |= BIT_8;
+                MP_WritePhyUshort(sc, 0x06, Data);
+                MP_WritePhyUshort(sc, 0x05, 0x8A82);
+                Data = MP_ReadPhyUshort(sc, 0x06);
+                Data &= ~BIT_8;
+                MP_WritePhyUshort(sc, 0x06, Data);
+                MP_WritePhyUshort(sc, 0x05, 0x8A85);
+                Data = MP_ReadPhyUshort(sc, 0x06);
+                Data &= ~BIT_8;
+                MP_WritePhyUshort(sc, 0x06, Data);
+                MP_WritePhyUshort(sc, 0x05, 0x8A88);
+                Data = MP_ReadPhyUshort(sc, 0x06);
+                Data &= ~BIT_8;
+                MP_WritePhyUshort(sc, 0x06, Data);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0005);
+                MP_WritePhyUshort(sc, 0x05, 0x8B85);
+                Data = MP_ReadPhyUshort(sc, 0x06);
+                Data |= BIT_15;
+                MP_WritePhyUshort(sc, 0x06, Data);
                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
+
                 MP_WritePhyUshort(sc, 0x1f, 0x0003);
-                MP_WritePhyUshort(sc, 0x09, 0xA20F);
+                Data = MP_ReadPhyUshort(sc, 0x19);
+                Data &= ~BIT_0;
+                MP_WritePhyUshort(sc, 0x19, Data);
+                Data = MP_ReadPhyUshort(sc, 0x10);
+                Data &= ~BIT_10;
+                MP_WritePhyUshort(sc, 0x10, Data);
                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                MP_WritePhyUshort(sc, 0x1f, 0x0003);
-                MP_WritePhyUshort(sc, 0x01, 0x328A);
+        } else if (sc->re_type == MACFG_51) {
+                MP_WritePhyUshort(sc, 0x1F, 0x0005);
+                MP_WritePhyUshort(sc, 0x05, 0x8B80);
+                Data = MP_ReadPhyUshort(sc, 0x06);
+                Data |= BIT_2 | BIT_1;
+                MP_WritePhyUshort(sc, 0x06, Data);
+                MP_WritePhyUshort(sc, 0x1f, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0007);
+                MP_WritePhyUshort(sc, 0x1E, 0x002D);
+                Data = MP_ReadPhyUshort(sc, 0x18);
+                Data |= BIT_4;
+                MP_WritePhyUshort(sc, 0x18, Data);
+                MP_WritePhyUshort(sc, 0x1f, 0x0000);
+                Data = MP_ReadPhyUshort(sc, 0x14);
+                Data |= BIT_15;
+                MP_WritePhyUshort(sc, 0x14, Data);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0005);
+                MP_WritePhyUshort(sc, 0x05, 0x8B86);
+                Data = MP_ReadPhyUshort(sc, 0x06);
+                Data |= BIT_0;
+                MP_WritePhyUshort(sc, 0x06, Data);
+                MP_WritePhyUshort(sc, 0x1f, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0005);
+                MP_WritePhyUshort(sc, 0x05, 0x8B54);
+                Data = MP_ReadPhyUshort(sc, 0x06);
+                Data &= ~BIT_11;
+                MP_WritePhyUshort(sc, 0x06, Data);
+                MP_WritePhyUshort(sc, 0x05, 0x8B5D);
+                Data = MP_ReadPhyUshort(sc, 0x06);
+                Data &= ~BIT_11;
+                MP_WritePhyUshort(sc, 0x06, Data);
+                MP_WritePhyUshort(sc, 0x05, 0x8A7C);
+                Data = MP_ReadPhyUshort(sc, 0x06);
+                Data &= ~BIT_8;
+                MP_WritePhyUshort(sc, 0x06, Data);
+                MP_WritePhyUshort(sc, 0x05, 0x8A7F);
+                Data = MP_ReadPhyUshort(sc, 0x06);
+                Data |= BIT_8;
+                MP_WritePhyUshort(sc, 0x06, Data);
+                MP_WritePhyUshort(sc, 0x05, 0x8A82);
+                Data = MP_ReadPhyUshort(sc, 0x06);
+                Data &= ~BIT_8;
+                MP_WritePhyUshort(sc, 0x06, Data);
+                MP_WritePhyUshort(sc, 0x05, 0x8A85);
+                Data = MP_ReadPhyUshort(sc, 0x06);
+                Data &= ~BIT_8;
+                MP_WritePhyUshort(sc, 0x06, Data);
+                MP_WritePhyUshort(sc, 0x05, 0x8A88);
+                Data = MP_ReadPhyUshort(sc, 0x06);
+                Data &= ~BIT_8;
+                MP_WritePhyUshort(sc, 0x06, Data);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0005);
+                MP_WritePhyUshort(sc, 0x05, 0x8B85);
+                Data = MP_ReadPhyUshort(sc, 0x06);
+                Data |= BIT_15;
+                MP_WritePhyUshort(sc, 0x06, Data);
                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
+
                 MP_WritePhyUshort(sc, 0x1f, 0x0003);
                 Data = MP_ReadPhyUshort(sc, 0x19);
                 Data &= ~BIT_0;
@@ -17508,7 +23424,10 @@ static void re_hw_phy_config(struct re_softc *sc)
                 Data &= ~BIT_10;
                 MP_WritePhyUshort(sc, 0x10, Data);
                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
-                MP_WritePhyUshort(sc, 0x00, 0x9200);
+        } else if (sc->re_type == MACFG_52) {
+                Data_u32 = re_eri_read(sc, 0x1D0, 4, ERIAR_ExGMAC);
+                Data_u32 &= ~BIT_1;
+                re_eri_write(sc, 0x1D0, 4, Data_u32, ERIAR_ExGMAC);
 
                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
                 MP_WritePhyUshort(sc, 0x05, 0x8B80);
@@ -18558,1071 +24477,6 @@ static void re_hw_phy_config(struct re_softc *sc)
                 MP_WritePhyUshort(sc, 0x0E, 0x0000);
                 MP_WritePhyUshort(sc, 0x0D, 0x0000);
         } else if (sc->re_type == MACFG_56) {
-                MP_WritePhyUshort(sc, 0x1f, 0x0B82);
-                PhyRegValue = MP_ReadPhyUshort(sc,  0x10);
-                PhyRegValue |= BIT_4;
-                MP_WritePhyUshort(sc, 0x10, PhyRegValue);
-
-                MP_WritePhyUshort(sc, 0x1f, 0x0B80);
-                WaitCnt = 0;
-                do {
-                        PhyRegValue = MP_ReadPhyUshort(sc,  0x10);
-                        PhyRegValue &= 0x0040;
-                        DELAY(50);
-                        DELAY(50);
-                        WaitCnt++;
-                } while(PhyRegValue != 0x0040 && WaitCnt <1000);
-
-                MP_WritePhyUshort(sc, 0x1f, 0x0A43);
-                MP_WritePhyUshort(sc, 0x13, 0x8146);
-                MP_WritePhyUshort(sc, 0x14, 0x2300);
-                MP_WritePhyUshort(sc, 0x13, 0xB820);
-                MP_WritePhyUshort(sc, 0x14, 0x0210);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0A43);
-                MP_WritePhyUshort(sc, 0x13, 0xB820);
-                MP_WritePhyUshort(sc, 0x14, 0x0290);
-                MP_WritePhyUshort(sc, 0x13, 0xA012);
-                MP_WritePhyUshort(sc, 0x14, 0x0000);
-                MP_WritePhyUshort(sc, 0x13, 0xA014);
-                MP_WritePhyUshort(sc, 0x14, 0x2c04);
-                MP_WritePhyUshort(sc, 0x14, 0x2c0c);
-                MP_WritePhyUshort(sc, 0x14, 0x2c6c);
-                MP_WritePhyUshort(sc, 0x14, 0x2d0d);
-                MP_WritePhyUshort(sc, 0x14, 0x31ce);
-                MP_WritePhyUshort(sc, 0x14, 0x506d);
-                MP_WritePhyUshort(sc, 0x14, 0xd708);
-                MP_WritePhyUshort(sc, 0x14, 0x3108);
-                MP_WritePhyUshort(sc, 0x14, 0x106d);
-                MP_WritePhyUshort(sc, 0x14, 0x1560);
-                MP_WritePhyUshort(sc, 0x14, 0x15a9);
-                MP_WritePhyUshort(sc, 0x14, 0x206e);
-                MP_WritePhyUshort(sc, 0x14, 0x175b);
-                MP_WritePhyUshort(sc, 0x14, 0x6062);
-                MP_WritePhyUshort(sc, 0x14, 0xd700);
-                MP_WritePhyUshort(sc, 0x14, 0x5fae);
-                MP_WritePhyUshort(sc, 0x14, 0xd708);
-                MP_WritePhyUshort(sc, 0x14, 0x3107);
-                MP_WritePhyUshort(sc, 0x14, 0x4c1e);
-                MP_WritePhyUshort(sc, 0x14, 0x4169);
-                MP_WritePhyUshort(sc, 0x14, 0x316a);
-                MP_WritePhyUshort(sc, 0x14, 0x0c19);
-                MP_WritePhyUshort(sc, 0x14, 0x31aa);
-                MP_WritePhyUshort(sc, 0x14, 0x0c19);
-                MP_WritePhyUshort(sc, 0x14, 0x2c1b);
-                MP_WritePhyUshort(sc, 0x14, 0x5e62);
-                MP_WritePhyUshort(sc, 0x14, 0x26b5);
-                MP_WritePhyUshort(sc, 0x14, 0x31ab);
-                MP_WritePhyUshort(sc, 0x14, 0x5c1e);
-                MP_WritePhyUshort(sc, 0x14, 0x2c0c);
-                MP_WritePhyUshort(sc, 0x14, 0xc040);
-                MP_WritePhyUshort(sc, 0x14, 0x8808);
-                MP_WritePhyUshort(sc, 0x14, 0xc520);
-                MP_WritePhyUshort(sc, 0x14, 0xc421);
-                MP_WritePhyUshort(sc, 0x14, 0xd05a);
-                MP_WritePhyUshort(sc, 0x14, 0xd19a);
-                MP_WritePhyUshort(sc, 0x14, 0xd709);
-                MP_WritePhyUshort(sc, 0x14, 0x608f);
-                MP_WritePhyUshort(sc, 0x14, 0xd06b);
-                MP_WritePhyUshort(sc, 0x14, 0xd18a);
-                MP_WritePhyUshort(sc, 0x14, 0x2c2c);
-                MP_WritePhyUshort(sc, 0x14, 0xd0be);
-                MP_WritePhyUshort(sc, 0x14, 0xd188);
-                MP_WritePhyUshort(sc, 0x14, 0x2c2c);
-                MP_WritePhyUshort(sc, 0x14, 0xd708);
-                MP_WritePhyUshort(sc, 0x14, 0x4072);
-                MP_WritePhyUshort(sc, 0x14, 0xc104);
-                MP_WritePhyUshort(sc, 0x14, 0x2c3e);
-                MP_WritePhyUshort(sc, 0x14, 0x4076);
-                MP_WritePhyUshort(sc, 0x14, 0xc110);
-                MP_WritePhyUshort(sc, 0x14, 0x2c3e);
-                MP_WritePhyUshort(sc, 0x14, 0x4071);
-                MP_WritePhyUshort(sc, 0x14, 0xc102);
-                MP_WritePhyUshort(sc, 0x14, 0x2c3e);
-                MP_WritePhyUshort(sc, 0x14, 0x4070);
-                MP_WritePhyUshort(sc, 0x14, 0xc101);
-                MP_WritePhyUshort(sc, 0x14, 0x2c3e);
-                MP_WritePhyUshort(sc, 0x14, 0x175b);
-                MP_WritePhyUshort(sc, 0x14, 0xd709);
-                MP_WritePhyUshort(sc, 0x14, 0x3390);
-                MP_WritePhyUshort(sc, 0x14, 0x5c39);
-                MP_WritePhyUshort(sc, 0x14, 0x2c4e);
-                MP_WritePhyUshort(sc, 0x14, 0x175b);
-                MP_WritePhyUshort(sc, 0x14, 0xd708);
-                MP_WritePhyUshort(sc, 0x14, 0x6193);
-                MP_WritePhyUshort(sc, 0x14, 0xd709);
-                MP_WritePhyUshort(sc, 0x14, 0x5f9d);
-                MP_WritePhyUshort(sc, 0x14, 0x408b);
-                MP_WritePhyUshort(sc, 0x14, 0xd71e);
-                MP_WritePhyUshort(sc, 0x14, 0x6042);
-                MP_WritePhyUshort(sc, 0x14, 0xb401);
-                MP_WritePhyUshort(sc, 0x14, 0x175b);
-                MP_WritePhyUshort(sc, 0x14, 0xd708);
-                MP_WritePhyUshort(sc, 0x14, 0x6073);
-                MP_WritePhyUshort(sc, 0x14, 0x5fbc);
-                MP_WritePhyUshort(sc, 0x14, 0x2c4d);
-                MP_WritePhyUshort(sc, 0x14, 0x26ed);
-                MP_WritePhyUshort(sc, 0x14, 0xb280);
-                MP_WritePhyUshort(sc, 0x14, 0xa841);
-                MP_WritePhyUshort(sc, 0x14, 0x9420);
-                MP_WritePhyUshort(sc, 0x14, 0x8710);
-                MP_WritePhyUshort(sc, 0x14, 0xd709);
-                MP_WritePhyUshort(sc, 0x14, 0x42ec);
-                MP_WritePhyUshort(sc, 0x14, 0x606d);
-                MP_WritePhyUshort(sc, 0x14, 0xd207);
-                MP_WritePhyUshort(sc, 0x14, 0x2c57);
-                MP_WritePhyUshort(sc, 0x14, 0xd203);
-                MP_WritePhyUshort(sc, 0x14, 0x33ff);
-                MP_WritePhyUshort(sc, 0x14, 0x563b);
-                MP_WritePhyUshort(sc, 0x14, 0x3275);
-                MP_WritePhyUshort(sc, 0x14, 0x7c5e);
-                MP_WritePhyUshort(sc, 0x14, 0xb240);
-                MP_WritePhyUshort(sc, 0x14, 0xb402);
-                MP_WritePhyUshort(sc, 0x14, 0x263b);
-                MP_WritePhyUshort(sc, 0x14, 0x6096);
-                MP_WritePhyUshort(sc, 0x14, 0xb240);
-                MP_WritePhyUshort(sc, 0x14, 0xb406);
-                MP_WritePhyUshort(sc, 0x14, 0x263b);
-                MP_WritePhyUshort(sc, 0x14, 0x31d7);
-                MP_WritePhyUshort(sc, 0x14, 0x7c67);
-                MP_WritePhyUshort(sc, 0x14, 0xb240);
-                MP_WritePhyUshort(sc, 0x14, 0xb40e);
-                MP_WritePhyUshort(sc, 0x14, 0x263b);
-                MP_WritePhyUshort(sc, 0x14, 0xb410);
-                MP_WritePhyUshort(sc, 0x14, 0x8802);
-                MP_WritePhyUshort(sc, 0x14, 0xb240);
-                MP_WritePhyUshort(sc, 0x14, 0x940e);
-                MP_WritePhyUshort(sc, 0x14, 0x263b);
-                MP_WritePhyUshort(sc, 0x14, 0xba04);
-                MP_WritePhyUshort(sc, 0x14, 0x1cd6);
-                MP_WritePhyUshort(sc, 0x14, 0xa902);
-                MP_WritePhyUshort(sc, 0x14, 0xd711);
-                MP_WritePhyUshort(sc, 0x14, 0x4045);
-                MP_WritePhyUshort(sc, 0x14, 0xa980);
-                MP_WritePhyUshort(sc, 0x14, 0x3003);
-                MP_WritePhyUshort(sc, 0x14, 0x59b1);
-                MP_WritePhyUshort(sc, 0x14, 0xa540);
-                MP_WritePhyUshort(sc, 0x14, 0xa601);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x4043);
-                MP_WritePhyUshort(sc, 0x14, 0xa910);
-                MP_WritePhyUshort(sc, 0x14, 0xd711);
-                MP_WritePhyUshort(sc, 0x14, 0x60a0);
-                MP_WritePhyUshort(sc, 0x14, 0xca33);
-                MP_WritePhyUshort(sc, 0x14, 0xcb33);
-                MP_WritePhyUshort(sc, 0x14, 0xa941);
-                MP_WritePhyUshort(sc, 0x14, 0x2c82);
-                MP_WritePhyUshort(sc, 0x14, 0xcaff);
-                MP_WritePhyUshort(sc, 0x14, 0xcbff);
-                MP_WritePhyUshort(sc, 0x14, 0xa921);
-                MP_WritePhyUshort(sc, 0x14, 0xce02);
-                MP_WritePhyUshort(sc, 0x14, 0xe070);
-                MP_WritePhyUshort(sc, 0x14, 0x0f10);
-                MP_WritePhyUshort(sc, 0x14, 0xaf01);
-                MP_WritePhyUshort(sc, 0x14, 0x8f01);
-                MP_WritePhyUshort(sc, 0x14, 0x1766);
-                MP_WritePhyUshort(sc, 0x14, 0x8e02);
-                MP_WritePhyUshort(sc, 0x14, 0x1787);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x609c);
-                MP_WritePhyUshort(sc, 0x14, 0xd71e);
-                MP_WritePhyUshort(sc, 0x14, 0x7fa4);
-                MP_WritePhyUshort(sc, 0x14, 0x2cd4);
-                MP_WritePhyUshort(sc, 0x14, 0x1ce9);
-                MP_WritePhyUshort(sc, 0x14, 0xce04);
-                MP_WritePhyUshort(sc, 0x14, 0xe070);
-                MP_WritePhyUshort(sc, 0x14, 0x0f20);
-                MP_WritePhyUshort(sc, 0x14, 0xaf01);
-                MP_WritePhyUshort(sc, 0x14, 0x8f01);
-                MP_WritePhyUshort(sc, 0x14, 0x1766);
-                MP_WritePhyUshort(sc, 0x14, 0x8e04);
-                MP_WritePhyUshort(sc, 0x14, 0x6044);
-                MP_WritePhyUshort(sc, 0x14, 0x2cd4);
-                MP_WritePhyUshort(sc, 0x14, 0xa520);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x4043);
-                MP_WritePhyUshort(sc, 0x14, 0x2cc1);
-                MP_WritePhyUshort(sc, 0x14, 0xe00f);
-                MP_WritePhyUshort(sc, 0x14, 0x0501);
-                MP_WritePhyUshort(sc, 0x14, 0x1cef);
-                MP_WritePhyUshort(sc, 0x14, 0xb801);
-                MP_WritePhyUshort(sc, 0x14, 0xd71e);
-                MP_WritePhyUshort(sc, 0x14, 0x4060);
-                MP_WritePhyUshort(sc, 0x14, 0x7fc4);
-                MP_WritePhyUshort(sc, 0x14, 0x2cd4);
-                MP_WritePhyUshort(sc, 0x14, 0x1cf5);
-                MP_WritePhyUshort(sc, 0x14, 0xe00f);
-                MP_WritePhyUshort(sc, 0x14, 0x0502);
-                MP_WritePhyUshort(sc, 0x14, 0x1cef);
-                MP_WritePhyUshort(sc, 0x14, 0xb802);
-                MP_WritePhyUshort(sc, 0x14, 0xd71e);
-                MP_WritePhyUshort(sc, 0x14, 0x4061);
-                MP_WritePhyUshort(sc, 0x14, 0x7fc4);
-                MP_WritePhyUshort(sc, 0x14, 0x2cd4);
-                MP_WritePhyUshort(sc, 0x14, 0x1cf5);
-                MP_WritePhyUshort(sc, 0x14, 0xe00f);
-                MP_WritePhyUshort(sc, 0x14, 0x0504);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x6099);
-                MP_WritePhyUshort(sc, 0x14, 0xd71e);
-                MP_WritePhyUshort(sc, 0x14, 0x7fa4);
-                MP_WritePhyUshort(sc, 0x14, 0x2cd4);
-                MP_WritePhyUshort(sc, 0x14, 0xc17f);
-                MP_WritePhyUshort(sc, 0x14, 0xc200);
-                MP_WritePhyUshort(sc, 0x14, 0xc43f);
-                MP_WritePhyUshort(sc, 0x14, 0xcc03);
-                MP_WritePhyUshort(sc, 0x14, 0xa701);
-                MP_WritePhyUshort(sc, 0x14, 0xa510);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x4018);
-                MP_WritePhyUshort(sc, 0x14, 0x9910);
-                MP_WritePhyUshort(sc, 0x14, 0x8510);
-                MP_WritePhyUshort(sc, 0x14, 0x2860);
-                MP_WritePhyUshort(sc, 0x14, 0xe00f);
-                MP_WritePhyUshort(sc, 0x14, 0x0504);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x6099);
-                MP_WritePhyUshort(sc, 0x14, 0xd71e);
-                MP_WritePhyUshort(sc, 0x14, 0x7fa4);
-                MP_WritePhyUshort(sc, 0x14, 0x2cd4);
-                MP_WritePhyUshort(sc, 0x14, 0xa608);
-                MP_WritePhyUshort(sc, 0x14, 0xc17d);
-                MP_WritePhyUshort(sc, 0x14, 0xc200);
-                MP_WritePhyUshort(sc, 0x14, 0xc43f);
-                MP_WritePhyUshort(sc, 0x14, 0xcc03);
-                MP_WritePhyUshort(sc, 0x14, 0xa701);
-                MP_WritePhyUshort(sc, 0x14, 0xa510);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x4018);
-                MP_WritePhyUshort(sc, 0x14, 0x9910);
-                MP_WritePhyUshort(sc, 0x14, 0x8510);
-                MP_WritePhyUshort(sc, 0x14, 0x2926);
-                MP_WritePhyUshort(sc, 0x14, 0x1792);
-                MP_WritePhyUshort(sc, 0x14, 0x27db);
-                MP_WritePhyUshort(sc, 0x14, 0xc000);
-                MP_WritePhyUshort(sc, 0x14, 0xc100);
-                MP_WritePhyUshort(sc, 0x14, 0xc200);
-                MP_WritePhyUshort(sc, 0x14, 0xc300);
-                MP_WritePhyUshort(sc, 0x14, 0xc400);
-                MP_WritePhyUshort(sc, 0x14, 0xc500);
-                MP_WritePhyUshort(sc, 0x14, 0xc600);
-                MP_WritePhyUshort(sc, 0x14, 0xc7c1);
-                MP_WritePhyUshort(sc, 0x14, 0xc800);
-                MP_WritePhyUshort(sc, 0x14, 0xcc00);
-                MP_WritePhyUshort(sc, 0x14, 0x0800);
-                MP_WritePhyUshort(sc, 0x14, 0xca0f);
-                MP_WritePhyUshort(sc, 0x14, 0xcbff);
-                MP_WritePhyUshort(sc, 0x14, 0xa901);
-                MP_WritePhyUshort(sc, 0x14, 0x8902);
-                MP_WritePhyUshort(sc, 0x14, 0xc900);
-                MP_WritePhyUshort(sc, 0x14, 0xca00);
-                MP_WritePhyUshort(sc, 0x14, 0xcb00);
-                MP_WritePhyUshort(sc, 0x14, 0x0800);
-                MP_WritePhyUshort(sc, 0x14, 0xb804);
-                MP_WritePhyUshort(sc, 0x14, 0x0800);
-                MP_WritePhyUshort(sc, 0x14, 0xd71e);
-                MP_WritePhyUshort(sc, 0x14, 0x6044);
-                MP_WritePhyUshort(sc, 0x14, 0x9804);
-                MP_WritePhyUshort(sc, 0x14, 0x0800);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x6099);
-                MP_WritePhyUshort(sc, 0x14, 0xd71e);
-                MP_WritePhyUshort(sc, 0x14, 0x7fa4);
-                MP_WritePhyUshort(sc, 0x14, 0x2cd4);
-                MP_WritePhyUshort(sc, 0x14, 0x0800);
-                MP_WritePhyUshort(sc, 0x14, 0xa510);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x6098);
-                MP_WritePhyUshort(sc, 0x14, 0xd71e);
-                MP_WritePhyUshort(sc, 0x14, 0x7fa4);
-                MP_WritePhyUshort(sc, 0x14, 0x2cd4);
-                MP_WritePhyUshort(sc, 0x14, 0x8510);
-                MP_WritePhyUshort(sc, 0x14, 0x0800);
-                MP_WritePhyUshort(sc, 0x14, 0xd711);
-                MP_WritePhyUshort(sc, 0x14, 0x3003);
-                MP_WritePhyUshort(sc, 0x14, 0x1d01);
-                MP_WritePhyUshort(sc, 0x14, 0x2d0b);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x60be);
-                MP_WritePhyUshort(sc, 0x14, 0xe060);
-                MP_WritePhyUshort(sc, 0x14, 0x0920);
-                MP_WritePhyUshort(sc, 0x14, 0x1cd6);
-                MP_WritePhyUshort(sc, 0x14, 0x2c89);
-                MP_WritePhyUshort(sc, 0x14, 0xd71e);
-                MP_WritePhyUshort(sc, 0x14, 0x3063);
-                MP_WritePhyUshort(sc, 0x14, 0x1948);
-                MP_WritePhyUshort(sc, 0x14, 0x288a);
-                MP_WritePhyUshort(sc, 0x14, 0x1cd6);
-                MP_WritePhyUshort(sc, 0x14, 0x29bd);
-                MP_WritePhyUshort(sc, 0x14, 0xa802);
-                MP_WritePhyUshort(sc, 0x14, 0xa303);
-                MP_WritePhyUshort(sc, 0x14, 0x843f);
-                MP_WritePhyUshort(sc, 0x14, 0x81ff);
-                MP_WritePhyUshort(sc, 0x14, 0x8208);
-                MP_WritePhyUshort(sc, 0x14, 0xa201);
-                MP_WritePhyUshort(sc, 0x14, 0xc001);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x30a0);
-                MP_WritePhyUshort(sc, 0x14, 0x0d1c);
-                MP_WritePhyUshort(sc, 0x14, 0x30a0);
-                MP_WritePhyUshort(sc, 0x14, 0x3d13);
-                MP_WritePhyUshort(sc, 0x14, 0xd71e);
-                MP_WritePhyUshort(sc, 0x14, 0x7f4c);
-                MP_WritePhyUshort(sc, 0x14, 0x2ab6);
-                MP_WritePhyUshort(sc, 0x14, 0xe003);
-                MP_WritePhyUshort(sc, 0x14, 0x0202);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x6090);
-                MP_WritePhyUshort(sc, 0x14, 0xd71e);
-                MP_WritePhyUshort(sc, 0x14, 0x7fac);
-                MP_WritePhyUshort(sc, 0x14, 0x2ab6);
-                MP_WritePhyUshort(sc, 0x14, 0xa20c);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x6091);
-                MP_WritePhyUshort(sc, 0x14, 0xd71e);
-                MP_WritePhyUshort(sc, 0x14, 0x7fac);
-                MP_WritePhyUshort(sc, 0x14, 0x2ab6);
-                MP_WritePhyUshort(sc, 0x14, 0x820e);
-                MP_WritePhyUshort(sc, 0x14, 0xa3e0);
-                MP_WritePhyUshort(sc, 0x14, 0xa520);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x609d);
-                MP_WritePhyUshort(sc, 0x14, 0xd71e);
-                MP_WritePhyUshort(sc, 0x14, 0x7fac);
-                MP_WritePhyUshort(sc, 0x14, 0x2ab6);
-                MP_WritePhyUshort(sc, 0x14, 0x8520);
-                MP_WritePhyUshort(sc, 0x14, 0x6703);
-                MP_WritePhyUshort(sc, 0x14, 0x2d34);
-                MP_WritePhyUshort(sc, 0x14, 0xa13e);
-                MP_WritePhyUshort(sc, 0x14, 0xc001);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x4000);
-                MP_WritePhyUshort(sc, 0x14, 0x6046);
-                MP_WritePhyUshort(sc, 0x14, 0x2d0d);
-                MP_WritePhyUshort(sc, 0x14, 0xa43f);
-                MP_WritePhyUshort(sc, 0x14, 0xa101);
-                MP_WritePhyUshort(sc, 0x14, 0xc020);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x3121);
-                MP_WritePhyUshort(sc, 0x14, 0x0d45);
-                MP_WritePhyUshort(sc, 0x14, 0x30c0);
-                MP_WritePhyUshort(sc, 0x14, 0x3d0d);
-                MP_WritePhyUshort(sc, 0x14, 0xd71e);
-                MP_WritePhyUshort(sc, 0x14, 0x7f4c);
-                MP_WritePhyUshort(sc, 0x14, 0x2ab6);
-                MP_WritePhyUshort(sc, 0x14, 0xa540);
-                MP_WritePhyUshort(sc, 0x14, 0xc001);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x4001);
-                MP_WritePhyUshort(sc, 0x14, 0xe00f);
-                MP_WritePhyUshort(sc, 0x14, 0x0501);
-                MP_WritePhyUshort(sc, 0x14, 0x1dac);
-                MP_WritePhyUshort(sc, 0x14, 0xc1c4);
-                MP_WritePhyUshort(sc, 0x14, 0xa268);
-                MP_WritePhyUshort(sc, 0x14, 0xa303);
-                MP_WritePhyUshort(sc, 0x14, 0x8420);
-                MP_WritePhyUshort(sc, 0x14, 0xe00f);
-                MP_WritePhyUshort(sc, 0x14, 0x0502);
-                MP_WritePhyUshort(sc, 0x14, 0x1dac);
-                MP_WritePhyUshort(sc, 0x14, 0xc002);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x4000);
-                MP_WritePhyUshort(sc, 0x14, 0x8208);
-                MP_WritePhyUshort(sc, 0x14, 0x8410);
-                MP_WritePhyUshort(sc, 0x14, 0xa121);
-                MP_WritePhyUshort(sc, 0x14, 0xc002);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x4000);
-                MP_WritePhyUshort(sc, 0x14, 0x8120);
-                MP_WritePhyUshort(sc, 0x14, 0x8180);
-                MP_WritePhyUshort(sc, 0x14, 0x1d97);
-                MP_WritePhyUshort(sc, 0x14, 0xa180);
-                MP_WritePhyUshort(sc, 0x14, 0xa13a);
-                MP_WritePhyUshort(sc, 0x14, 0x8240);
-                MP_WritePhyUshort(sc, 0x14, 0xa430);
-                MP_WritePhyUshort(sc, 0x14, 0xc010);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x30e1);
-                MP_WritePhyUshort(sc, 0x14, 0x0abc);
-                MP_WritePhyUshort(sc, 0x14, 0xd71e);
-                MP_WritePhyUshort(sc, 0x14, 0x7f8c);
-                MP_WritePhyUshort(sc, 0x14, 0x2ab6);
-                MP_WritePhyUshort(sc, 0x14, 0xa480);
-                MP_WritePhyUshort(sc, 0x14, 0xa230);
-                MP_WritePhyUshort(sc, 0x14, 0xa303);
-                MP_WritePhyUshort(sc, 0x14, 0xc001);
-                MP_WritePhyUshort(sc, 0x14, 0xd70c);
-                MP_WritePhyUshort(sc, 0x14, 0x4124);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x6120);
-                MP_WritePhyUshort(sc, 0x14, 0xd711);
-                MP_WritePhyUshort(sc, 0x14, 0x3128);
-                MP_WritePhyUshort(sc, 0x14, 0x3d76);
-                MP_WritePhyUshort(sc, 0x14, 0x2d70);
-                MP_WritePhyUshort(sc, 0x14, 0xa801);
-                MP_WritePhyUshort(sc, 0x14, 0x2d6c);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x4000);
-                MP_WritePhyUshort(sc, 0x14, 0xe018);
-                MP_WritePhyUshort(sc, 0x14, 0x0208);
-                MP_WritePhyUshort(sc, 0x14, 0xa1f8);
-                MP_WritePhyUshort(sc, 0x14, 0x8480);
-                MP_WritePhyUshort(sc, 0x14, 0xc004);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x4000);
-                MP_WritePhyUshort(sc, 0x14, 0x6046);
-                MP_WritePhyUshort(sc, 0x14, 0x2d0d);
-                MP_WritePhyUshort(sc, 0x14, 0xa43f);
-                MP_WritePhyUshort(sc, 0x14, 0xa105);
-                MP_WritePhyUshort(sc, 0x14, 0x8228);
-                MP_WritePhyUshort(sc, 0x14, 0xc004);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x4000);
-                MP_WritePhyUshort(sc, 0x14, 0x81bc);
-                MP_WritePhyUshort(sc, 0x14, 0xa220);
-                MP_WritePhyUshort(sc, 0x14, 0x1d97);
-                MP_WritePhyUshort(sc, 0x14, 0x8220);
-                MP_WritePhyUshort(sc, 0x14, 0xa1bc);
-                MP_WritePhyUshort(sc, 0x14, 0xc040);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x30e1);
-                MP_WritePhyUshort(sc, 0x14, 0x0abc);
-                MP_WritePhyUshort(sc, 0x14, 0x30e1);
-                MP_WritePhyUshort(sc, 0x14, 0x3d0d);
-                MP_WritePhyUshort(sc, 0x14, 0xd71e);
-                MP_WritePhyUshort(sc, 0x14, 0x7f4c);
-                MP_WritePhyUshort(sc, 0x14, 0x2ab6);
-                MP_WritePhyUshort(sc, 0x14, 0xa802);
-                MP_WritePhyUshort(sc, 0x14, 0xd70c);
-                MP_WritePhyUshort(sc, 0x14, 0x4244);
-                MP_WritePhyUshort(sc, 0x14, 0xa301);
-                MP_WritePhyUshort(sc, 0x14, 0xc004);
-                MP_WritePhyUshort(sc, 0x14, 0xd711);
-                MP_WritePhyUshort(sc, 0x14, 0x3128);
-                MP_WritePhyUshort(sc, 0x14, 0x3da5);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x5f80);
-                MP_WritePhyUshort(sc, 0x14, 0xd711);
-                MP_WritePhyUshort(sc, 0x14, 0x3109);
-                MP_WritePhyUshort(sc, 0x14, 0x3da7);
-                MP_WritePhyUshort(sc, 0x14, 0x2dab);
-                MP_WritePhyUshort(sc, 0x14, 0xa801);
-                MP_WritePhyUshort(sc, 0x14, 0x2d9a);
-                MP_WritePhyUshort(sc, 0x14, 0xa802);
-                MP_WritePhyUshort(sc, 0x14, 0xc004);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x4000);
-                MP_WritePhyUshort(sc, 0x14, 0x0800);
-                MP_WritePhyUshort(sc, 0x14, 0xa510);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x609a);
-                MP_WritePhyUshort(sc, 0x14, 0xd71e);
-                MP_WritePhyUshort(sc, 0x14, 0x7fac);
-                MP_WritePhyUshort(sc, 0x14, 0x2ab6);
-                MP_WritePhyUshort(sc, 0x14, 0x8510);
-                MP_WritePhyUshort(sc, 0x14, 0x0800);
-                MP_WritePhyUshort(sc, 0x13, 0xA01A);
-                MP_WritePhyUshort(sc, 0x14, 0x0000);
-                MP_WritePhyUshort(sc, 0x13, 0xA006);
-                MP_WritePhyUshort(sc, 0x14, 0x0ad6);
-                MP_WritePhyUshort(sc, 0x13, 0xA004);
-                MP_WritePhyUshort(sc, 0x14, 0x07f5);
-                MP_WritePhyUshort(sc, 0x13, 0xA002);
-                MP_WritePhyUshort(sc, 0x14, 0x06a9);
-                MP_WritePhyUshort(sc, 0x13, 0xA000);
-                MP_WritePhyUshort(sc, 0x14, 0xf069);
-                MP_WritePhyUshort(sc, 0x13, 0xB820);
-                MP_WritePhyUshort(sc, 0x14, 0x0210);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0A43);
-                MP_WritePhyUshort(sc, 0x13, 0x83a0);
-                MP_WritePhyUshort(sc, 0x14, 0xaf83);
-                MP_WritePhyUshort(sc, 0x14, 0xacaf);
-                MP_WritePhyUshort(sc, 0x14, 0x83b8);
-                MP_WritePhyUshort(sc, 0x14, 0xaf83);
-                MP_WritePhyUshort(sc, 0x14, 0xcdaf);
-                MP_WritePhyUshort(sc, 0x14, 0x83d3);
-                MP_WritePhyUshort(sc, 0x14, 0x0204);
-                MP_WritePhyUshort(sc, 0x14, 0x9a02);
-                MP_WritePhyUshort(sc, 0x14, 0x09a9);
-                MP_WritePhyUshort(sc, 0x14, 0x0284);
-                MP_WritePhyUshort(sc, 0x14, 0x61af);
-                MP_WritePhyUshort(sc, 0x14, 0x02fc);
-                MP_WritePhyUshort(sc, 0x14, 0xad20);
-                MP_WritePhyUshort(sc, 0x14, 0x0302);
-                MP_WritePhyUshort(sc, 0x14, 0x867c);
-                MP_WritePhyUshort(sc, 0x14, 0xad21);
-                MP_WritePhyUshort(sc, 0x14, 0x0302);
-                MP_WritePhyUshort(sc, 0x14, 0x85c9);
-                MP_WritePhyUshort(sc, 0x14, 0xad22);
-                MP_WritePhyUshort(sc, 0x14, 0x0302);
-                MP_WritePhyUshort(sc, 0x14, 0x1bc0);
-                MP_WritePhyUshort(sc, 0x14, 0xaf17);
-                MP_WritePhyUshort(sc, 0x14, 0xe302);
-                MP_WritePhyUshort(sc, 0x14, 0x8703);
-                MP_WritePhyUshort(sc, 0x14, 0xaf18);
-                MP_WritePhyUshort(sc, 0x14, 0x6201);
-                MP_WritePhyUshort(sc, 0x14, 0x06e0);
-                MP_WritePhyUshort(sc, 0x14, 0x8148);
-                MP_WritePhyUshort(sc, 0x14, 0xaf3c);
-                MP_WritePhyUshort(sc, 0x14, 0x69f8);
-                MP_WritePhyUshort(sc, 0x14, 0xf9fa);
-                MP_WritePhyUshort(sc, 0x14, 0xef69);
-                MP_WritePhyUshort(sc, 0x14, 0xee80);
-                MP_WritePhyUshort(sc, 0x14, 0x10f7);
-                MP_WritePhyUshort(sc, 0x14, 0xee80);
-                MP_WritePhyUshort(sc, 0x14, 0x131f);
-                MP_WritePhyUshort(sc, 0x14, 0xd104);
-                MP_WritePhyUshort(sc, 0x14, 0xbf87);
-                MP_WritePhyUshort(sc, 0x14, 0xf302);
-                MP_WritePhyUshort(sc, 0x14, 0x4259);
-                MP_WritePhyUshort(sc, 0x14, 0x0287);
-                MP_WritePhyUshort(sc, 0x14, 0x88bf);
-                MP_WritePhyUshort(sc, 0x14, 0x87cf);
-                MP_WritePhyUshort(sc, 0x14, 0xd7b8);
-                MP_WritePhyUshort(sc, 0x14, 0x22d0);
-                MP_WritePhyUshort(sc, 0x14, 0x0c02);
-                MP_WritePhyUshort(sc, 0x14, 0x4252);
-                MP_WritePhyUshort(sc, 0x14, 0xee80);
-                MP_WritePhyUshort(sc, 0x14, 0xcda0);
-                MP_WritePhyUshort(sc, 0x14, 0xee80);
-                MP_WritePhyUshort(sc, 0x14, 0xce8b);
-                MP_WritePhyUshort(sc, 0x14, 0xee80);
-                MP_WritePhyUshort(sc, 0x14, 0xd1f5);
-                MP_WritePhyUshort(sc, 0x14, 0xee80);
-                MP_WritePhyUshort(sc, 0x14, 0xd2a9);
-                MP_WritePhyUshort(sc, 0x14, 0xee80);
-                MP_WritePhyUshort(sc, 0x14, 0xd30a);
-                MP_WritePhyUshort(sc, 0x14, 0xee80);
-                MP_WritePhyUshort(sc, 0x14, 0xf010);
-                MP_WritePhyUshort(sc, 0x14, 0xee80);
-                MP_WritePhyUshort(sc, 0x14, 0xf38f);
-                MP_WritePhyUshort(sc, 0x14, 0xee81);
-                MP_WritePhyUshort(sc, 0x14, 0x011e);
-                MP_WritePhyUshort(sc, 0x14, 0xee81);
-                MP_WritePhyUshort(sc, 0x14, 0x0b4a);
-                MP_WritePhyUshort(sc, 0x14, 0xee81);
-                MP_WritePhyUshort(sc, 0x14, 0x0c7c);
-                MP_WritePhyUshort(sc, 0x14, 0xee81);
-                MP_WritePhyUshort(sc, 0x14, 0x127f);
-                MP_WritePhyUshort(sc, 0x14, 0xd100);
-                MP_WritePhyUshort(sc, 0x14, 0x0210);
-                MP_WritePhyUshort(sc, 0x14, 0xb5ee);
-                MP_WritePhyUshort(sc, 0x14, 0x8088);
-                MP_WritePhyUshort(sc, 0x14, 0xa4ee);
-                MP_WritePhyUshort(sc, 0x14, 0x8089);
-                MP_WritePhyUshort(sc, 0x14, 0x44ee);
-                MP_WritePhyUshort(sc, 0x14, 0x809a);
-                MP_WritePhyUshort(sc, 0x14, 0xa4ee);
-                MP_WritePhyUshort(sc, 0x14, 0x809b);
-                MP_WritePhyUshort(sc, 0x14, 0x44ee);
-                MP_WritePhyUshort(sc, 0x14, 0x809c);
-                MP_WritePhyUshort(sc, 0x14, 0xa7ee);
-                MP_WritePhyUshort(sc, 0x14, 0x80a5);
-                MP_WritePhyUshort(sc, 0x14, 0xa7d2);
-                MP_WritePhyUshort(sc, 0x14, 0x0002);
-                MP_WritePhyUshort(sc, 0x14, 0x0e66);
-                MP_WritePhyUshort(sc, 0x14, 0x0285);
-                MP_WritePhyUshort(sc, 0x14, 0xc0ee);
-                MP_WritePhyUshort(sc, 0x14, 0x87fc);
-                MP_WritePhyUshort(sc, 0x14, 0x00e0);
-                MP_WritePhyUshort(sc, 0x14, 0x8245);
-                MP_WritePhyUshort(sc, 0x14, 0xf622);
-                MP_WritePhyUshort(sc, 0x14, 0xe482);
-                MP_WritePhyUshort(sc, 0x14, 0x45ef);
-                MP_WritePhyUshort(sc, 0x14, 0x96fe);
-                MP_WritePhyUshort(sc, 0x14, 0xfdfc);
-                MP_WritePhyUshort(sc, 0x14, 0x0402);
-                MP_WritePhyUshort(sc, 0x14, 0x847a);
-                MP_WritePhyUshort(sc, 0x14, 0x0284);
-                MP_WritePhyUshort(sc, 0x14, 0xb302);
-                MP_WritePhyUshort(sc, 0x14, 0x0cab);
-                MP_WritePhyUshort(sc, 0x14, 0x020c);
-                MP_WritePhyUshort(sc, 0x14, 0xc402);
-                MP_WritePhyUshort(sc, 0x14, 0x0cef);
-                MP_WritePhyUshort(sc, 0x14, 0x020d);
-                MP_WritePhyUshort(sc, 0x14, 0x0802);
-                MP_WritePhyUshort(sc, 0x14, 0x0d33);
-                MP_WritePhyUshort(sc, 0x14, 0x020c);
-                MP_WritePhyUshort(sc, 0x14, 0x3d04);
-                MP_WritePhyUshort(sc, 0x14, 0xf8fa);
-                MP_WritePhyUshort(sc, 0x14, 0xef69);
-                MP_WritePhyUshort(sc, 0x14, 0xe182);
-                MP_WritePhyUshort(sc, 0x14, 0x2fac);
-                MP_WritePhyUshort(sc, 0x14, 0x291a);
-                MP_WritePhyUshort(sc, 0x14, 0xe082);
-                MP_WritePhyUshort(sc, 0x14, 0x24ac);
-                MP_WritePhyUshort(sc, 0x14, 0x2102);
-                MP_WritePhyUshort(sc, 0x14, 0xae22);
-                MP_WritePhyUshort(sc, 0x14, 0x0210);
-                MP_WritePhyUshort(sc, 0x14, 0x57f6);
-                MP_WritePhyUshort(sc, 0x14, 0x21e4);
-                MP_WritePhyUshort(sc, 0x14, 0x8224);
-                MP_WritePhyUshort(sc, 0x14, 0xd101);
-                MP_WritePhyUshort(sc, 0x14, 0xbf44);
-                MP_WritePhyUshort(sc, 0x14, 0xd202);
-                MP_WritePhyUshort(sc, 0x14, 0x4259);
-                MP_WritePhyUshort(sc, 0x14, 0xae10);
-                MP_WritePhyUshort(sc, 0x14, 0x0212);
-                MP_WritePhyUshort(sc, 0x14, 0x4cf6);
-                MP_WritePhyUshort(sc, 0x14, 0x29e5);
-                MP_WritePhyUshort(sc, 0x14, 0x822f);
-                MP_WritePhyUshort(sc, 0x14, 0xe082);
-                MP_WritePhyUshort(sc, 0x14, 0x24f6);
-                MP_WritePhyUshort(sc, 0x14, 0x21e4);
-                MP_WritePhyUshort(sc, 0x14, 0x8224);
-                MP_WritePhyUshort(sc, 0x14, 0xef96);
-                MP_WritePhyUshort(sc, 0x14, 0xfefc);
-                MP_WritePhyUshort(sc, 0x14, 0x04f8);
-                MP_WritePhyUshort(sc, 0x14, 0xe182);
-                MP_WritePhyUshort(sc, 0x14, 0x2fac);
-                MP_WritePhyUshort(sc, 0x14, 0x2a18);
-                MP_WritePhyUshort(sc, 0x14, 0xe082);
-                MP_WritePhyUshort(sc, 0x14, 0x24ac);
-                MP_WritePhyUshort(sc, 0x14, 0x2202);
-                MP_WritePhyUshort(sc, 0x14, 0xae26);
-                MP_WritePhyUshort(sc, 0x14, 0x0284);
-                MP_WritePhyUshort(sc, 0x14, 0xf802);
-                MP_WritePhyUshort(sc, 0x14, 0x8565);
-                MP_WritePhyUshort(sc, 0x14, 0xd101);
-                MP_WritePhyUshort(sc, 0x14, 0xbf44);
-                MP_WritePhyUshort(sc, 0x14, 0xd502);
-                MP_WritePhyUshort(sc, 0x14, 0x4259);
-                MP_WritePhyUshort(sc, 0x14, 0xae0e);
-                MP_WritePhyUshort(sc, 0x14, 0x0284);
-                MP_WritePhyUshort(sc, 0x14, 0xea02);
-                MP_WritePhyUshort(sc, 0x14, 0x85a9);
-                MP_WritePhyUshort(sc, 0x14, 0xe182);
-                MP_WritePhyUshort(sc, 0x14, 0x2ff6);
-                MP_WritePhyUshort(sc, 0x14, 0x2ae5);
-                MP_WritePhyUshort(sc, 0x14, 0x822f);
-                MP_WritePhyUshort(sc, 0x14, 0xe082);
-                MP_WritePhyUshort(sc, 0x14, 0x24f6);
-                MP_WritePhyUshort(sc, 0x14, 0x22e4);
-                MP_WritePhyUshort(sc, 0x14, 0x8224);
-                MP_WritePhyUshort(sc, 0x14, 0xfc04);
-                MP_WritePhyUshort(sc, 0x14, 0xf9e2);
-                MP_WritePhyUshort(sc, 0x14, 0x8011);
-                MP_WritePhyUshort(sc, 0x14, 0xad31);
-                MP_WritePhyUshort(sc, 0x14, 0x05d2);
-                MP_WritePhyUshort(sc, 0x14, 0x0002);
-                MP_WritePhyUshort(sc, 0x14, 0x0e66);
-                MP_WritePhyUshort(sc, 0x14, 0xfd04);
-                MP_WritePhyUshort(sc, 0x14, 0xf8f9);
-                MP_WritePhyUshort(sc, 0x14, 0xfaef);
-                MP_WritePhyUshort(sc, 0x14, 0x69e0);
-                MP_WritePhyUshort(sc, 0x14, 0x8011);
-                MP_WritePhyUshort(sc, 0x14, 0xad21);
-                MP_WritePhyUshort(sc, 0x14, 0x5cbf);
-                MP_WritePhyUshort(sc, 0x14, 0x43be);
-                MP_WritePhyUshort(sc, 0x14, 0x0242);
-                MP_WritePhyUshort(sc, 0x14, 0x97ac);
-                MP_WritePhyUshort(sc, 0x14, 0x281b);
-                MP_WritePhyUshort(sc, 0x14, 0xbf43);
-                MP_WritePhyUshort(sc, 0x14, 0xc102);
-                MP_WritePhyUshort(sc, 0x14, 0x4297);
-                MP_WritePhyUshort(sc, 0x14, 0xac28);
-                MP_WritePhyUshort(sc, 0x14, 0x12bf);
-                MP_WritePhyUshort(sc, 0x14, 0x43c7);
-                MP_WritePhyUshort(sc, 0x14, 0x0242);
-                MP_WritePhyUshort(sc, 0x14, 0x97ac);
-                MP_WritePhyUshort(sc, 0x14, 0x2804);
-                MP_WritePhyUshort(sc, 0x14, 0xd300);
-                MP_WritePhyUshort(sc, 0x14, 0xae07);
-                MP_WritePhyUshort(sc, 0x14, 0xd306);
-                MP_WritePhyUshort(sc, 0x14, 0xaf85);
-                MP_WritePhyUshort(sc, 0x14, 0x56d3);
-                MP_WritePhyUshort(sc, 0x14, 0x03e0);
-                MP_WritePhyUshort(sc, 0x14, 0x8011);
-                MP_WritePhyUshort(sc, 0x14, 0xad26);
-                MP_WritePhyUshort(sc, 0x14, 0x25bf);
-                MP_WritePhyUshort(sc, 0x14, 0x4559);
-                MP_WritePhyUshort(sc, 0x14, 0x0242);
-                MP_WritePhyUshort(sc, 0x14, 0x97e2);
-                MP_WritePhyUshort(sc, 0x14, 0x8073);
-                MP_WritePhyUshort(sc, 0x14, 0x0d21);
-                MP_WritePhyUshort(sc, 0x14, 0xf637);
-                MP_WritePhyUshort(sc, 0x14, 0x0d11);
-                MP_WritePhyUshort(sc, 0x14, 0xf62f);
-                MP_WritePhyUshort(sc, 0x14, 0x1b21);
-                MP_WritePhyUshort(sc, 0x14, 0xaa02);
-                MP_WritePhyUshort(sc, 0x14, 0xae10);
-                MP_WritePhyUshort(sc, 0x14, 0xe280);
-                MP_WritePhyUshort(sc, 0x14, 0x740d);
-                MP_WritePhyUshort(sc, 0x14, 0x21f6);
-                MP_WritePhyUshort(sc, 0x14, 0x371b);
-                MP_WritePhyUshort(sc, 0x14, 0x21aa);
-                MP_WritePhyUshort(sc, 0x14, 0x0313);
-                MP_WritePhyUshort(sc, 0x14, 0xae02);
-                MP_WritePhyUshort(sc, 0x14, 0x2b02);
-                MP_WritePhyUshort(sc, 0x14, 0x020e);
-                MP_WritePhyUshort(sc, 0x14, 0x5102);
-                MP_WritePhyUshort(sc, 0x14, 0x0e66);
-                MP_WritePhyUshort(sc, 0x14, 0x020f);
-                MP_WritePhyUshort(sc, 0x14, 0xa3ef);
-                MP_WritePhyUshort(sc, 0x14, 0x96fe);
-                MP_WritePhyUshort(sc, 0x14, 0xfdfc);
-                MP_WritePhyUshort(sc, 0x14, 0x04f8);
-                MP_WritePhyUshort(sc, 0x14, 0xf9fa);
-                MP_WritePhyUshort(sc, 0x14, 0xef69);
-                MP_WritePhyUshort(sc, 0x14, 0xe080);
-                MP_WritePhyUshort(sc, 0x14, 0x12ad);
-                MP_WritePhyUshort(sc, 0x14, 0x2733);
-                MP_WritePhyUshort(sc, 0x14, 0xbf43);
-                MP_WritePhyUshort(sc, 0x14, 0xbe02);
-                MP_WritePhyUshort(sc, 0x14, 0x4297);
-                MP_WritePhyUshort(sc, 0x14, 0xac28);
-                MP_WritePhyUshort(sc, 0x14, 0x09bf);
-                MP_WritePhyUshort(sc, 0x14, 0x43c1);
-                MP_WritePhyUshort(sc, 0x14, 0x0242);
-                MP_WritePhyUshort(sc, 0x14, 0x97ad);
-                MP_WritePhyUshort(sc, 0x14, 0x2821);
-                MP_WritePhyUshort(sc, 0x14, 0xbf45);
-                MP_WritePhyUshort(sc, 0x14, 0x5902);
-                MP_WritePhyUshort(sc, 0x14, 0x4297);
-                MP_WritePhyUshort(sc, 0x14, 0xe387);
-                MP_WritePhyUshort(sc, 0x14, 0xffd2);
-                MP_WritePhyUshort(sc, 0x14, 0x001b);
-                MP_WritePhyUshort(sc, 0x14, 0x45ac);
-                MP_WritePhyUshort(sc, 0x14, 0x2711);
-                MP_WritePhyUshort(sc, 0x14, 0xe187);
-                MP_WritePhyUshort(sc, 0x14, 0xfebf);
-                MP_WritePhyUshort(sc, 0x14, 0x87e4);
-                MP_WritePhyUshort(sc, 0x14, 0x0242);
-                MP_WritePhyUshort(sc, 0x14, 0x590d);
-                MP_WritePhyUshort(sc, 0x14, 0x11bf);
-                MP_WritePhyUshort(sc, 0x14, 0x87e7);
-                MP_WritePhyUshort(sc, 0x14, 0x0242);
-                MP_WritePhyUshort(sc, 0x14, 0x59ef);
-                MP_WritePhyUshort(sc, 0x14, 0x96fe);
-                MP_WritePhyUshort(sc, 0x14, 0xfdfc);
-                MP_WritePhyUshort(sc, 0x14, 0x04f8);
-                MP_WritePhyUshort(sc, 0x14, 0xfaef);
-                MP_WritePhyUshort(sc, 0x14, 0x69d1);
-                MP_WritePhyUshort(sc, 0x14, 0x00bf);
-                MP_WritePhyUshort(sc, 0x14, 0x87e4);
-                MP_WritePhyUshort(sc, 0x14, 0x0242);
-                MP_WritePhyUshort(sc, 0x14, 0x59bf);
-                MP_WritePhyUshort(sc, 0x14, 0x87e7);
-                MP_WritePhyUshort(sc, 0x14, 0x0242);
-                MP_WritePhyUshort(sc, 0x14, 0x59ef);
-                MP_WritePhyUshort(sc, 0x14, 0x96fe);
-                MP_WritePhyUshort(sc, 0x14, 0xfc04);
-                MP_WritePhyUshort(sc, 0x14, 0xee87);
-                MP_WritePhyUshort(sc, 0x14, 0xff46);
-                MP_WritePhyUshort(sc, 0x14, 0xee87);
-                MP_WritePhyUshort(sc, 0x14, 0xfe01);
-                MP_WritePhyUshort(sc, 0x14, 0x04f8);
-                MP_WritePhyUshort(sc, 0x14, 0xfaef);
-                MP_WritePhyUshort(sc, 0x14, 0x69e0);
-                MP_WritePhyUshort(sc, 0x14, 0x8241);
-                MP_WritePhyUshort(sc, 0x14, 0xa000);
-                MP_WritePhyUshort(sc, 0x14, 0x0502);
-                MP_WritePhyUshort(sc, 0x14, 0x85eb);
-                MP_WritePhyUshort(sc, 0x14, 0xae0e);
-                MP_WritePhyUshort(sc, 0x14, 0xa001);
-                MP_WritePhyUshort(sc, 0x14, 0x0502);
-                MP_WritePhyUshort(sc, 0x14, 0x1a5a);
-                MP_WritePhyUshort(sc, 0x14, 0xae06);
-                MP_WritePhyUshort(sc, 0x14, 0xa002);
-                MP_WritePhyUshort(sc, 0x14, 0x0302);
-                MP_WritePhyUshort(sc, 0x14, 0x1ae6);
-                MP_WritePhyUshort(sc, 0x14, 0xef96);
-                MP_WritePhyUshort(sc, 0x14, 0xfefc);
-                MP_WritePhyUshort(sc, 0x14, 0x04f8);
-                MP_WritePhyUshort(sc, 0x14, 0xf9fa);
-                MP_WritePhyUshort(sc, 0x14, 0xef69);
-                MP_WritePhyUshort(sc, 0x14, 0xe082);
-                MP_WritePhyUshort(sc, 0x14, 0x29f6);
-                MP_WritePhyUshort(sc, 0x14, 0x21e4);
-                MP_WritePhyUshort(sc, 0x14, 0x8229);
-                MP_WritePhyUshort(sc, 0x14, 0xe080);
-                MP_WritePhyUshort(sc, 0x14, 0x10ac);
-                MP_WritePhyUshort(sc, 0x14, 0x2202);
-                MP_WritePhyUshort(sc, 0x14, 0xae76);
-                MP_WritePhyUshort(sc, 0x14, 0xe082);
-                MP_WritePhyUshort(sc, 0x14, 0x27f7);
-                MP_WritePhyUshort(sc, 0x14, 0x21e4);
-                MP_WritePhyUshort(sc, 0x14, 0x8227);
-                MP_WritePhyUshort(sc, 0x14, 0xbf43);
-                MP_WritePhyUshort(sc, 0x14, 0x1302);
-                MP_WritePhyUshort(sc, 0x14, 0x4297);
-                MP_WritePhyUshort(sc, 0x14, 0xef21);
-                MP_WritePhyUshort(sc, 0x14, 0xbf43);
-                MP_WritePhyUshort(sc, 0x14, 0x1602);
-                MP_WritePhyUshort(sc, 0x14, 0x4297);
-                MP_WritePhyUshort(sc, 0x14, 0x0c11);
-                MP_WritePhyUshort(sc, 0x14, 0x1e21);
-                MP_WritePhyUshort(sc, 0x14, 0xbf43);
-                MP_WritePhyUshort(sc, 0x14, 0x1902);
-                MP_WritePhyUshort(sc, 0x14, 0x4297);
-                MP_WritePhyUshort(sc, 0x14, 0x0c12);
-                MP_WritePhyUshort(sc, 0x14, 0x1e21);
-                MP_WritePhyUshort(sc, 0x14, 0xe682);
-                MP_WritePhyUshort(sc, 0x14, 0x43a2);
-                MP_WritePhyUshort(sc, 0x14, 0x000a);
-                MP_WritePhyUshort(sc, 0x14, 0xe182);
-                MP_WritePhyUshort(sc, 0x14, 0x27f6);
-                MP_WritePhyUshort(sc, 0x14, 0x29e5);
-                MP_WritePhyUshort(sc, 0x14, 0x8227);
-                MP_WritePhyUshort(sc, 0x14, 0xae42);
-                MP_WritePhyUshort(sc, 0x14, 0xe082);
-                MP_WritePhyUshort(sc, 0x14, 0x44f7);
-                MP_WritePhyUshort(sc, 0x14, 0x21e4);
-                MP_WritePhyUshort(sc, 0x14, 0x8244);
-                MP_WritePhyUshort(sc, 0x14, 0x0246);
-                MP_WritePhyUshort(sc, 0x14, 0xaebf);
-                MP_WritePhyUshort(sc, 0x14, 0x4325);
-                MP_WritePhyUshort(sc, 0x14, 0x0242);
-                MP_WritePhyUshort(sc, 0x14, 0x97ef);
-                MP_WritePhyUshort(sc, 0x14, 0x21bf);
-                MP_WritePhyUshort(sc, 0x14, 0x431c);
-                MP_WritePhyUshort(sc, 0x14, 0x0242);
-                MP_WritePhyUshort(sc, 0x14, 0x970c);
-                MP_WritePhyUshort(sc, 0x14, 0x121e);
-                MP_WritePhyUshort(sc, 0x14, 0x21bf);
-                MP_WritePhyUshort(sc, 0x14, 0x431f);
-                MP_WritePhyUshort(sc, 0x14, 0x0242);
-                MP_WritePhyUshort(sc, 0x14, 0x970c);
-                MP_WritePhyUshort(sc, 0x14, 0x131e);
-                MP_WritePhyUshort(sc, 0x14, 0x21bf);
-                MP_WritePhyUshort(sc, 0x14, 0x4328);
-                MP_WritePhyUshort(sc, 0x14, 0x0242);
-                MP_WritePhyUshort(sc, 0x14, 0x970c);
-                MP_WritePhyUshort(sc, 0x14, 0x141e);
-                MP_WritePhyUshort(sc, 0x14, 0x21bf);
-                MP_WritePhyUshort(sc, 0x14, 0x44b1);
-                MP_WritePhyUshort(sc, 0x14, 0x0242);
-                MP_WritePhyUshort(sc, 0x14, 0x970c);
-                MP_WritePhyUshort(sc, 0x14, 0x161e);
-                MP_WritePhyUshort(sc, 0x14, 0x21e6);
-                MP_WritePhyUshort(sc, 0x14, 0x8242);
-                MP_WritePhyUshort(sc, 0x14, 0xee82);
-                MP_WritePhyUshort(sc, 0x14, 0x4101);
-                MP_WritePhyUshort(sc, 0x14, 0xef96);
-                MP_WritePhyUshort(sc, 0x14, 0xfefd);
-                MP_WritePhyUshort(sc, 0x14, 0xfc04);
-                MP_WritePhyUshort(sc, 0x14, 0xf8fa);
-                MP_WritePhyUshort(sc, 0x14, 0xef69);
-                MP_WritePhyUshort(sc, 0x14, 0xe082);
-                MP_WritePhyUshort(sc, 0x14, 0x46a0);
-                MP_WritePhyUshort(sc, 0x14, 0x0005);
-                MP_WritePhyUshort(sc, 0x14, 0x0286);
-                MP_WritePhyUshort(sc, 0x14, 0x96ae);
-                MP_WritePhyUshort(sc, 0x14, 0x06a0);
-                MP_WritePhyUshort(sc, 0x14, 0x0103);
-                MP_WritePhyUshort(sc, 0x14, 0x0219);
-                MP_WritePhyUshort(sc, 0x14, 0x19ef);
-                MP_WritePhyUshort(sc, 0x14, 0x96fe);
-                MP_WritePhyUshort(sc, 0x14, 0xfc04);
-                MP_WritePhyUshort(sc, 0x14, 0xf8fa);
-                MP_WritePhyUshort(sc, 0x14, 0xef69);
-                MP_WritePhyUshort(sc, 0x14, 0xe082);
-                MP_WritePhyUshort(sc, 0x14, 0x29f6);
-                MP_WritePhyUshort(sc, 0x14, 0x20e4);
-                MP_WritePhyUshort(sc, 0x14, 0x8229);
-                MP_WritePhyUshort(sc, 0x14, 0xe080);
-                MP_WritePhyUshort(sc, 0x14, 0x10ac);
-                MP_WritePhyUshort(sc, 0x14, 0x2102);
-                MP_WritePhyUshort(sc, 0x14, 0xae54);
-                MP_WritePhyUshort(sc, 0x14, 0xe082);
-                MP_WritePhyUshort(sc, 0x14, 0x27f7);
-                MP_WritePhyUshort(sc, 0x14, 0x20e4);
-                MP_WritePhyUshort(sc, 0x14, 0x8227);
-                MP_WritePhyUshort(sc, 0x14, 0xbf42);
-                MP_WritePhyUshort(sc, 0x14, 0xe602);
-                MP_WritePhyUshort(sc, 0x14, 0x4297);
-                MP_WritePhyUshort(sc, 0x14, 0xac28);
-                MP_WritePhyUshort(sc, 0x14, 0x22bf);
-                MP_WritePhyUshort(sc, 0x14, 0x430d);
-                MP_WritePhyUshort(sc, 0x14, 0x0242);
-                MP_WritePhyUshort(sc, 0x14, 0x97e5);
-                MP_WritePhyUshort(sc, 0x14, 0x8247);
-                MP_WritePhyUshort(sc, 0x14, 0xac28);
-                MP_WritePhyUshort(sc, 0x14, 0x20d1);
-                MP_WritePhyUshort(sc, 0x14, 0x03bf);
-                MP_WritePhyUshort(sc, 0x14, 0x4307);
-                MP_WritePhyUshort(sc, 0x14, 0x0242);
-                MP_WritePhyUshort(sc, 0x14, 0x59ee);
-                MP_WritePhyUshort(sc, 0x14, 0x8246);
-                MP_WritePhyUshort(sc, 0x14, 0x00e1);
-                MP_WritePhyUshort(sc, 0x14, 0x8227);
-                MP_WritePhyUshort(sc, 0x14, 0xf628);
-                MP_WritePhyUshort(sc, 0x14, 0xe582);
-                MP_WritePhyUshort(sc, 0x14, 0x27ae);
-                MP_WritePhyUshort(sc, 0x14, 0x21d1);
-                MP_WritePhyUshort(sc, 0x14, 0x04bf);
-                MP_WritePhyUshort(sc, 0x14, 0x4307);
-                MP_WritePhyUshort(sc, 0x14, 0x0242);
-                MP_WritePhyUshort(sc, 0x14, 0x59ae);
-                MP_WritePhyUshort(sc, 0x14, 0x08d1);
-                MP_WritePhyUshort(sc, 0x14, 0x05bf);
-                MP_WritePhyUshort(sc, 0x14, 0x4307);
-                MP_WritePhyUshort(sc, 0x14, 0x0242);
-                MP_WritePhyUshort(sc, 0x14, 0x59e0);
-                MP_WritePhyUshort(sc, 0x14, 0x8244);
-                MP_WritePhyUshort(sc, 0x14, 0xf720);
-                MP_WritePhyUshort(sc, 0x14, 0xe482);
-                MP_WritePhyUshort(sc, 0x14, 0x4402);
-                MP_WritePhyUshort(sc, 0x14, 0x46ae);
-                MP_WritePhyUshort(sc, 0x14, 0xee82);
-                MP_WritePhyUshort(sc, 0x14, 0x4601);
-                MP_WritePhyUshort(sc, 0x14, 0xef96);
-                MP_WritePhyUshort(sc, 0x14, 0xfefc);
-                MP_WritePhyUshort(sc, 0x14, 0x04f8);
-                MP_WritePhyUshort(sc, 0x14, 0xfaef);
-                MP_WritePhyUshort(sc, 0x14, 0x69e0);
-                MP_WritePhyUshort(sc, 0x14, 0x8013);
-                MP_WritePhyUshort(sc, 0x14, 0xad24);
-                MP_WritePhyUshort(sc, 0x14, 0x1cbf);
-                MP_WritePhyUshort(sc, 0x14, 0x87f0);
-                MP_WritePhyUshort(sc, 0x14, 0x0242);
-                MP_WritePhyUshort(sc, 0x14, 0x97ad);
-                MP_WritePhyUshort(sc, 0x14, 0x2813);
-                MP_WritePhyUshort(sc, 0x14, 0xe087);
-                MP_WritePhyUshort(sc, 0x14, 0xfca0);
-                MP_WritePhyUshort(sc, 0x14, 0x0005);
-                MP_WritePhyUshort(sc, 0x14, 0x0287);
-                MP_WritePhyUshort(sc, 0x14, 0x36ae);
-                MP_WritePhyUshort(sc, 0x14, 0x10a0);
-                MP_WritePhyUshort(sc, 0x14, 0x0105);
-                MP_WritePhyUshort(sc, 0x14, 0x0287);
-                MP_WritePhyUshort(sc, 0x14, 0x48ae);
-                MP_WritePhyUshort(sc, 0x14, 0x08e0);
-                MP_WritePhyUshort(sc, 0x14, 0x8230);
-                MP_WritePhyUshort(sc, 0x14, 0xf626);
-                MP_WritePhyUshort(sc, 0x14, 0xe482);
-                MP_WritePhyUshort(sc, 0x14, 0x30ef);
-                MP_WritePhyUshort(sc, 0x14, 0x96fe);
-                MP_WritePhyUshort(sc, 0x14, 0xfc04);
-                MP_WritePhyUshort(sc, 0x14, 0xf8e0);
-                MP_WritePhyUshort(sc, 0x14, 0x8245);
-                MP_WritePhyUshort(sc, 0x14, 0xf722);
-                MP_WritePhyUshort(sc, 0x14, 0xe482);
-                MP_WritePhyUshort(sc, 0x14, 0x4502);
-                MP_WritePhyUshort(sc, 0x14, 0x46ae);
-                MP_WritePhyUshort(sc, 0x14, 0xee87);
-                MP_WritePhyUshort(sc, 0x14, 0xfc01);
-                MP_WritePhyUshort(sc, 0x14, 0xfc04);
-                MP_WritePhyUshort(sc, 0x14, 0xf8fa);
-                MP_WritePhyUshort(sc, 0x14, 0xef69);
-                MP_WritePhyUshort(sc, 0x14, 0xfb02);
-                MP_WritePhyUshort(sc, 0x14, 0x46d3);
-                MP_WritePhyUshort(sc, 0x14, 0xad50);
-                MP_WritePhyUshort(sc, 0x14, 0x2fbf);
-                MP_WritePhyUshort(sc, 0x14, 0x87ed);
-                MP_WritePhyUshort(sc, 0x14, 0xd101);
-                MP_WritePhyUshort(sc, 0x14, 0x0242);
-                MP_WritePhyUshort(sc, 0x14, 0x59bf);
-                MP_WritePhyUshort(sc, 0x14, 0x87ed);
-                MP_WritePhyUshort(sc, 0x14, 0xd100);
-                MP_WritePhyUshort(sc, 0x14, 0x0242);
-                MP_WritePhyUshort(sc, 0x14, 0x59e0);
-                MP_WritePhyUshort(sc, 0x14, 0x8245);
-                MP_WritePhyUshort(sc, 0x14, 0xf622);
-                MP_WritePhyUshort(sc, 0x14, 0xe482);
-                MP_WritePhyUshort(sc, 0x14, 0x4502);
-                MP_WritePhyUshort(sc, 0x14, 0x46ae);
-                MP_WritePhyUshort(sc, 0x14, 0xd100);
-                MP_WritePhyUshort(sc, 0x14, 0xbf87);
-                MP_WritePhyUshort(sc, 0x14, 0xf002);
-                MP_WritePhyUshort(sc, 0x14, 0x4259);
-                MP_WritePhyUshort(sc, 0x14, 0xee87);
-                MP_WritePhyUshort(sc, 0x14, 0xfc00);
-                MP_WritePhyUshort(sc, 0x14, 0xe082);
-                MP_WritePhyUshort(sc, 0x14, 0x30f6);
-                MP_WritePhyUshort(sc, 0x14, 0x26e4);
-                MP_WritePhyUshort(sc, 0x14, 0x8230);
-                MP_WritePhyUshort(sc, 0x14, 0xffef);
-                MP_WritePhyUshort(sc, 0x14, 0x96fe);
-                MP_WritePhyUshort(sc, 0x14, 0xfc04);
-                MP_WritePhyUshort(sc, 0x14, 0xf8f9);
-                MP_WritePhyUshort(sc, 0x14, 0xface);
-                MP_WritePhyUshort(sc, 0x14, 0xfaef);
-                MP_WritePhyUshort(sc, 0x14, 0x69fb);
-                MP_WritePhyUshort(sc, 0x14, 0xbf87);
-                MP_WritePhyUshort(sc, 0x14, 0xb3d7);
-                MP_WritePhyUshort(sc, 0x14, 0x001c);
-                MP_WritePhyUshort(sc, 0x14, 0xd819);
-                MP_WritePhyUshort(sc, 0x14, 0xd919);
-                MP_WritePhyUshort(sc, 0x14, 0xda19);
-                MP_WritePhyUshort(sc, 0x14, 0xdb19);
-                MP_WritePhyUshort(sc, 0x14, 0x07ef);
-                MP_WritePhyUshort(sc, 0x14, 0x9502);
-                MP_WritePhyUshort(sc, 0x14, 0x4259);
-                MP_WritePhyUshort(sc, 0x14, 0x073f);
-                MP_WritePhyUshort(sc, 0x14, 0x0004);
-                MP_WritePhyUshort(sc, 0x14, 0x9fec);
-                MP_WritePhyUshort(sc, 0x14, 0xffef);
-                MP_WritePhyUshort(sc, 0x14, 0x96fe);
-                MP_WritePhyUshort(sc, 0x14, 0xc6fe);
-                MP_WritePhyUshort(sc, 0x14, 0xfdfc);
-                MP_WritePhyUshort(sc, 0x14, 0x0400);
-                MP_WritePhyUshort(sc, 0x14, 0x0145);
-                MP_WritePhyUshort(sc, 0x14, 0x7d00);
-                MP_WritePhyUshort(sc, 0x14, 0x0345);
-                MP_WritePhyUshort(sc, 0x14, 0x5c00);
-                MP_WritePhyUshort(sc, 0x14, 0x0143);
-                MP_WritePhyUshort(sc, 0x14, 0x4f00);
-                MP_WritePhyUshort(sc, 0x14, 0x0387);
-                MP_WritePhyUshort(sc, 0x14, 0xdb00);
-                MP_WritePhyUshort(sc, 0x14, 0x0987);
-                MP_WritePhyUshort(sc, 0x14, 0xde00);
-                MP_WritePhyUshort(sc, 0x14, 0x0987);
-                MP_WritePhyUshort(sc, 0x14, 0xe100);
-                MP_WritePhyUshort(sc, 0x14, 0x0087);
-                MP_WritePhyUshort(sc, 0x14, 0xeaa4);
-                MP_WritePhyUshort(sc, 0x14, 0x00b8);
-                MP_WritePhyUshort(sc, 0x14, 0x20c4);
-                MP_WritePhyUshort(sc, 0x14, 0x1600);
-                MP_WritePhyUshort(sc, 0x14, 0x000f);
-                MP_WritePhyUshort(sc, 0x14, 0xf800);
-                MP_WritePhyUshort(sc, 0x14, 0x7098);
-                MP_WritePhyUshort(sc, 0x14, 0xa58a);
-                MP_WritePhyUshort(sc, 0x14, 0xb6a8);
-                MP_WritePhyUshort(sc, 0x14, 0x3e50);
-                MP_WritePhyUshort(sc, 0x14, 0xa83e);
-                MP_WritePhyUshort(sc, 0x14, 0x33bc);
-                MP_WritePhyUshort(sc, 0x14, 0xc622);
-                MP_WritePhyUshort(sc, 0x14, 0xbcc6);
-                MP_WritePhyUshort(sc, 0x14, 0xaaa4);
-                MP_WritePhyUshort(sc, 0x14, 0x42ff);
-                MP_WritePhyUshort(sc, 0x14, 0xc408);
-                MP_WritePhyUshort(sc, 0x14, 0x00c4);
-                MP_WritePhyUshort(sc, 0x14, 0x16a8);
-                MP_WritePhyUshort(sc, 0x14, 0xbcc0);
-                MP_WritePhyUshort(sc, 0x13, 0xb818);
-                MP_WritePhyUshort(sc, 0x14, 0x02f3);
-                MP_WritePhyUshort(sc, 0x13, 0xb81a);
-                MP_WritePhyUshort(sc, 0x14, 0x17d1);
-                MP_WritePhyUshort(sc, 0x13, 0xb81c);
-                MP_WritePhyUshort(sc, 0x14, 0x185a);
-                MP_WritePhyUshort(sc, 0x13, 0xb81e);
-                MP_WritePhyUshort(sc, 0x14, 0x3c66);
-                MP_WritePhyUshort(sc, 0x13, 0xb820);
-                MP_WritePhyUshort(sc, 0x14, 0x021f);
-                MP_WritePhyUshort(sc, 0x13, 0xc416);
-                MP_WritePhyUshort(sc, 0x14, 0x0500);
-                MP_WritePhyUshort(sc, 0x13, 0xb82e);
-                MP_WritePhyUshort(sc, 0x14, 0xfffc);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0A43);
-                MP_WritePhyUshort(sc, 0x13, 0x0000);
-                MP_WritePhyUshort(sc, 0x14, 0x0000);
-                MP_WritePhyUshort(sc, 0x1f, 0x0B82);
-                PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
-                PhyRegValue &= ~(BIT_9);
-                MP_WritePhyUshort(sc, 0x10, PhyRegValue);
-                MP_WritePhyUshort(sc, 0x1f, 0x0A43);
-                MP_WritePhyUshort(sc, 0x13, 0x8146);
-                MP_WritePhyUshort(sc, 0x14, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1f, 0x0B82);
-                PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
-                PhyRegValue &= ~(BIT_4);
-                MP_WritePhyUshort(sc, 0x10, PhyRegValue); // release patch request
-
-
                 MP_WritePhyUshort(sc, 0x1F, 0x0A46);
                 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
                 TmpUshort = (PhyRegValue & BIT_8) ? 0 : BIT_15;
@@ -19675,7 +24529,7 @@ static void re_hw_phy_config(struct re_softc *sc)
                 MP_WritePhyUshort(sc, 0x1F, 0x0C42);
                 ClearAndSetEthPhyBit(sc,
                                      0x11,
-                                     BIT_13 ,
+                                     BIT_13,
                                      BIT_14
                                     );
                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
@@ -19732,7 +24586,7 @@ static void re_hw_phy_config(struct re_softc *sc)
                 MP_WritePhyUshort(sc, 0x1F, 0x0C42);
                 ClearAndSetEthPhyBit(sc,
                                      0x11,
-                                     BIT_13 ,
+                                     BIT_13,
                                      BIT_14
                                     );
                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
@@ -19755,69 +24609,6 @@ static void re_hw_phy_config(struct re_softc *sc)
                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
                 MP_WritePhyUshort(sc, 0x00, 0x9200);
         } else if (sc->re_type == MACFG_59) {
-                MP_WritePhyUshort(sc, 0x1f, 0x0B82);
-                PhyRegValue = MP_ReadPhyUshort(sc,  0x10);
-                PhyRegValue |= BIT_4;
-                MP_WritePhyUshort(sc, 0x10, PhyRegValue);
-
-                MP_WritePhyUshort(sc, 0x1f, 0x0B80);
-                WaitCnt = 0;
-                do {
-                        PhyRegValue = MP_ReadPhyUshort(sc,  0x10);
-                        PhyRegValue &= 0x0040;
-                        DELAY(50);
-                        DELAY(50);
-                        WaitCnt++;
-                } while(PhyRegValue != 0x0040 && WaitCnt <1000);
-
-                MP_WritePhyUshort(sc, 0x1f, 0x0A43);
-                MP_WritePhyUshort(sc, 0x13, 0x8146);
-                MP_WritePhyUshort(sc, 0x14, 0x0300);
-                MP_WritePhyUshort(sc, 0x13, 0xB82E);
-                MP_WritePhyUshort(sc, 0x14, 0x0001);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0A43);
-                MP_WritePhyUshort(sc, 0x13, 0xb820);
-                MP_WritePhyUshort(sc, 0x14, 0x0290);
-                MP_WritePhyUshort(sc, 0x13, 0xa012);
-                MP_WritePhyUshort(sc, 0x14, 0x0000);
-                MP_WritePhyUshort(sc, 0x13, 0xa014);
-                MP_WritePhyUshort(sc, 0x14, 0x2c04);
-                MP_WritePhyUshort(sc, 0x14, 0x2c07);
-                MP_WritePhyUshort(sc, 0x14, 0x2c07);
-                MP_WritePhyUshort(sc, 0x14, 0x2c07);
-                MP_WritePhyUshort(sc, 0x14, 0xa304);
-                MP_WritePhyUshort(sc, 0x14, 0xa301);
-                MP_WritePhyUshort(sc, 0x14, 0x207e);
-                MP_WritePhyUshort(sc, 0x13, 0xa01a);
-                MP_WritePhyUshort(sc, 0x14, 0x0000);
-                MP_WritePhyUshort(sc, 0x13, 0xa006);
-                MP_WritePhyUshort(sc, 0x14, 0x0fff);
-                MP_WritePhyUshort(sc, 0x13, 0xa004);
-                MP_WritePhyUshort(sc, 0x14, 0x0fff);
-                MP_WritePhyUshort(sc, 0x13, 0xa002);
-                MP_WritePhyUshort(sc, 0x14, 0x0fff);
-                MP_WritePhyUshort(sc, 0x13, 0xa000);
-                MP_WritePhyUshort(sc, 0x14, 0x107c);
-                MP_WritePhyUshort(sc, 0x13, 0xb820);
-                MP_WritePhyUshort(sc, 0x14, 0x0210);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0A43);
-                MP_WritePhyUshort(sc, 0x13, 0x0000);
-                MP_WritePhyUshort(sc, 0x14, 0x0000);
-                MP_WritePhyUshort(sc, 0x1f, 0x0B82);
-                PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
-                PhyRegValue &= ~(BIT_0);
-                MP_WritePhyUshort(sc, 0x17, PhyRegValue);
-                MP_WritePhyUshort(sc, 0x1f, 0x0A43);
-                MP_WritePhyUshort(sc, 0x13, 0x8146);
-                MP_WritePhyUshort(sc, 0x14, 0x0000);
-
-                MP_WritePhyUshort(sc, 0x1f, 0x0B82);
-                PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
-                PhyRegValue &= ~(BIT_4);
-                MP_WritePhyUshort(sc, 0x10, PhyRegValue);
-
                 MP_WritePhyUshort(sc, 0x1F, 0x0BCC);
                 ClearEthPhyBit(sc, 0x14, BIT_8);
                 MP_WritePhyUshort(sc, 0x1F, 0x0A44);
@@ -19844,49 +24635,49 @@ static void re_hw_phy_config(struct re_softc *sc)
                 MP_WritePhyUshort(sc, 0x13, 0x80F3);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x8B00
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x80F0);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x3A00
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x80EF);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x0500
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x80F6);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x6E00
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x80EC);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x6800
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x80ED);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x7C00
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x80F2);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0xF400
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x80F4);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x8500
                                     );
 
@@ -19894,49 +24685,49 @@ static void re_hw_phy_config(struct re_softc *sc)
                 MP_WritePhyUshort(sc, 0x13, 0x8110);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0xA800
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x810F);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x1D00
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x8111);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0xF500
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x8113);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x6100
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x8115);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x9200
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x810E);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x0400
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x810C);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x7C00
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x810B);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x5A00
                                     );
 
@@ -19944,31 +24735,31 @@ static void re_hw_phy_config(struct re_softc *sc)
                 MP_WritePhyUshort(sc, 0x13, 0x80D1);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0xFF00
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x80CD);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x9E00
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x80D3);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x0E00
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x80D5);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0xCA00
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x80D7);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x8400
                                     );
 
@@ -19990,69 +24781,6 @@ static void re_hw_phy_config(struct re_softc *sc)
                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
                 MP_WritePhyUshort(sc, 0x00, 0x9200);
         } else if (sc->re_type == MACFG_60) {
-                MP_WritePhyUshort(sc, 0x1f, 0x0B82);
-                PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
-                PhyRegValue |= BIT_4;
-                MP_WritePhyUshort(sc, 0x10, PhyRegValue);
-
-                MP_WritePhyUshort(sc, 0x1f, 0x0B80);
-                WaitCnt = 0;
-                do {
-                        PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
-                        PhyRegValue &= 0x0040;
-                        DELAY(50);
-                        DELAY(50);
-                        WaitCnt++;
-                } while(PhyRegValue != 0x0040 && WaitCnt <1000);
-
-                MP_WritePhyUshort(sc, 0x1f, 0x0A43);
-                MP_WritePhyUshort(sc, 0x13, 0x8146);
-                MP_WritePhyUshort(sc, 0x14, 0x0100);
-                MP_WritePhyUshort(sc, 0x13, 0xB82E);
-                MP_WritePhyUshort(sc, 0x14, 0x0001);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0A43);
-                MP_WritePhyUshort(sc, 0x13, 0xb820);
-                MP_WritePhyUshort(sc, 0x14, 0x0290);
-                MP_WritePhyUshort(sc, 0x13, 0xa012);
-                MP_WritePhyUshort(sc, 0x14, 0x0000);
-                MP_WritePhyUshort(sc, 0x13, 0xa014);
-                MP_WritePhyUshort(sc, 0x14, 0x2c04);
-                MP_WritePhyUshort(sc, 0x14, 0x2c07);
-                MP_WritePhyUshort(sc, 0x14, 0x2c07);
-                MP_WritePhyUshort(sc, 0x14, 0x2c07);
-                MP_WritePhyUshort(sc, 0x14, 0xa304);
-                MP_WritePhyUshort(sc, 0x14, 0xa301);
-                MP_WritePhyUshort(sc, 0x14, 0x207e);
-                MP_WritePhyUshort(sc, 0x13, 0xa01a);
-                MP_WritePhyUshort(sc, 0x14, 0x0000);
-                MP_WritePhyUshort(sc, 0x13, 0xa006);
-                MP_WritePhyUshort(sc, 0x14, 0x0fff);
-                MP_WritePhyUshort(sc, 0x13, 0xa004);
-                MP_WritePhyUshort(sc, 0x14, 0x0fff);
-                MP_WritePhyUshort(sc, 0x13, 0xa002);
-                MP_WritePhyUshort(sc, 0x14, 0x0fff);
-                MP_WritePhyUshort(sc, 0x13, 0xa000);
-                MP_WritePhyUshort(sc, 0x14, 0x107c);
-                MP_WritePhyUshort(sc, 0x13, 0xb820);
-                MP_WritePhyUshort(sc, 0x14, 0x0210);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0A43);
-                MP_WritePhyUshort(sc, 0x13, 0x0000);
-                MP_WritePhyUshort(sc, 0x14, 0x0000);
-                MP_WritePhyUshort(sc, 0x1f, 0x0B82);
-                PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
-                PhyRegValue &= ~(BIT_0);
-                MP_WritePhyUshort(sc, 0x17, PhyRegValue);
-                MP_WritePhyUshort(sc, 0x1f, 0x0A43);
-                MP_WritePhyUshort(sc, 0x13, 0x8146);
-                MP_WritePhyUshort(sc, 0x14, 0x0000);
-
-                MP_WritePhyUshort(sc,0x1f, 0x0B82);
-                PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
-                PhyRegValue &= ~(BIT_4);
-                MP_WritePhyUshort(sc,0x10, PhyRegValue);
-
                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
                 MP_WritePhyUshort(sc, 0x13, 0x8012);
                 SetEthPhyBit(sc, 0x14, BIT_15);
@@ -20066,49 +24794,49 @@ static void re_hw_phy_config(struct re_softc *sc)
                 MP_WritePhyUshort(sc, 0x13, 0x80F3);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x8B00
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x80F0);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x3A00
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x80EF);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x0500
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x80F6);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x6E00
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x80EC);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x6800
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x80ED);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x7C00
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x80F2);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0xF400
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x80F4);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x8500
                                     );
 
@@ -20116,49 +24844,49 @@ static void re_hw_phy_config(struct re_softc *sc)
                 MP_WritePhyUshort(sc, 0x13, 0x8110);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0xA800
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x810F);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x1D00
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x8111);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0xF500
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x8113);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x6100
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x8115);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x9200
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x810E);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x0400
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x810C);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x7C00
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x810B);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x5A00
                                     );
 
@@ -20166,31 +24894,31 @@ static void re_hw_phy_config(struct re_softc *sc)
                 MP_WritePhyUshort(sc, 0x13, 0x80D1);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0xFF00
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x80CD);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x9E00
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x80D3);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x0E00
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x80D5);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0xCA00
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x80D7);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x8400
                                     );
 
@@ -20212,1001 +24940,14 @@ static void re_hw_phy_config(struct re_softc *sc)
                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
                 MP_WritePhyUshort(sc, 0x00, 0x9200);
         } else if (sc->re_type == MACFG_61) {
-                MP_WritePhyUshort(sc,0x1f, 0x0B82);
-                PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
-                PhyRegValue |= BIT_4;
-                MP_WritePhyUshort(sc,0x10, PhyRegValue);
-
-                MP_WritePhyUshort(sc,0x1f, 0x0B80);
-                WaitCnt = 0;
-                do {
-                        PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
-                        PhyRegValue &= 0x0040;
-                        DELAY(50);
-                        DELAY(50);
-                        WaitCnt++;
-                } while(PhyRegValue != 0x0040 && WaitCnt <1000);
-
-                MP_WritePhyUshort(sc,0x1f, 0x0A43);
-                MP_WritePhyUshort(sc,0x13, 0x8146);
-                MP_WritePhyUshort(sc,0x14, 0x2700);
-                MP_WritePhyUshort(sc,0x13, 0xB82E);
-                MP_WritePhyUshort(sc,0x14, 0x0001);
-
-                MP_WritePhyUshort(sc,0x1F, 0x0A43);
-                MP_WritePhyUshort(sc, 0x13, 0xb820);
-                MP_WritePhyUshort(sc, 0x14, 0x0090);
-                MP_WritePhyUshort(sc, 0x13, 0xa012);
-                MP_WritePhyUshort(sc, 0x14, 0x0000);
-                MP_WritePhyUshort(sc, 0x13, 0xa014);
-                MP_WritePhyUshort(sc, 0x14, 0x2c04);
-                MP_WritePhyUshort(sc, 0x14, 0x2c1b);
-                MP_WritePhyUshort(sc, 0x14, 0x2c65);
-                MP_WritePhyUshort(sc, 0x14, 0x2d14);
-                MP_WritePhyUshort(sc, 0x14, 0xd71e);
-                MP_WritePhyUshort(sc, 0x14, 0x4092);
-                MP_WritePhyUshort(sc, 0x14, 0xba04);
-                MP_WritePhyUshort(sc, 0x14, 0x3084);
-                MP_WritePhyUshort(sc, 0x14, 0x1d04);
-                MP_WritePhyUshort(sc, 0x14, 0x1cdd);
-                MP_WritePhyUshort(sc, 0x14, 0x1ce8);
-                MP_WritePhyUshort(sc, 0x14, 0xaeff);
-                MP_WritePhyUshort(sc, 0x14, 0xaf02);
-                MP_WritePhyUshort(sc, 0x14, 0x8f02);
-                MP_WritePhyUshort(sc, 0x14, 0x8eff);
-                MP_WritePhyUshort(sc, 0x14, 0xce01);
-                MP_WritePhyUshort(sc, 0x14, 0xe070);
-                MP_WritePhyUshort(sc, 0x14, 0x0f00);
-                MP_WritePhyUshort(sc, 0x14, 0xaf01);
-                MP_WritePhyUshort(sc, 0x14, 0x8f01);
-                MP_WritePhyUshort(sc, 0x14, 0xd712);
-                MP_WritePhyUshort(sc, 0x14, 0x5fe8);
-                MP_WritePhyUshort(sc, 0x14, 0xaf02);
-                MP_WritePhyUshort(sc, 0x14, 0x8f02);
-                MP_WritePhyUshort(sc, 0x14, 0x8e01);
-                MP_WritePhyUshort(sc, 0x14, 0x1cf2);
-                MP_WritePhyUshort(sc, 0x14, 0x2825);
-                MP_WritePhyUshort(sc, 0x14, 0xd05a);
-                MP_WritePhyUshort(sc, 0x14, 0xd19a);
-                MP_WritePhyUshort(sc, 0x14, 0xd709);
-                MP_WritePhyUshort(sc, 0x14, 0x608f);
-                MP_WritePhyUshort(sc, 0x14, 0xd06b);
-                MP_WritePhyUshort(sc, 0x14, 0xd18a);
-                MP_WritePhyUshort(sc, 0x14, 0x2c25);
-                MP_WritePhyUshort(sc, 0x14, 0xd0be);
-                MP_WritePhyUshort(sc, 0x14, 0xd188);
-                MP_WritePhyUshort(sc, 0x14, 0x2c25);
-                MP_WritePhyUshort(sc, 0x14, 0xd708);
-                MP_WritePhyUshort(sc, 0x14, 0x4072);
-                MP_WritePhyUshort(sc, 0x14, 0xc104);
-                MP_WritePhyUshort(sc, 0x14, 0x2c37);
-                MP_WritePhyUshort(sc, 0x14, 0x4076);
-                MP_WritePhyUshort(sc, 0x14, 0xc110);
-                MP_WritePhyUshort(sc, 0x14, 0x2c37);
-                MP_WritePhyUshort(sc, 0x14, 0x4071);
-                MP_WritePhyUshort(sc, 0x14, 0xc102);
-                MP_WritePhyUshort(sc, 0x14, 0x2c37);
-                MP_WritePhyUshort(sc, 0x14, 0x4070);
-                MP_WritePhyUshort(sc, 0x14, 0xc101);
-                MP_WritePhyUshort(sc, 0x14, 0x2c37);
-                MP_WritePhyUshort(sc, 0x14, 0x1786);
-                MP_WritePhyUshort(sc, 0x14, 0xd709);
-                MP_WritePhyUshort(sc, 0x14, 0x3390);
-                MP_WritePhyUshort(sc, 0x14, 0x5c32);
-                MP_WritePhyUshort(sc, 0x14, 0x2c47);
-                MP_WritePhyUshort(sc, 0x14, 0x1786);
-                MP_WritePhyUshort(sc, 0x14, 0xd708);
-                MP_WritePhyUshort(sc, 0x14, 0x6193);
-                MP_WritePhyUshort(sc, 0x14, 0xd709);
-                MP_WritePhyUshort(sc, 0x14, 0x5f9d);
-                MP_WritePhyUshort(sc, 0x14, 0x408b);
-                MP_WritePhyUshort(sc, 0x14, 0xd71e);
-                MP_WritePhyUshort(sc, 0x14, 0x6042);
-                MP_WritePhyUshort(sc, 0x14, 0xb401);
-                MP_WritePhyUshort(sc, 0x14, 0x1786);
-                MP_WritePhyUshort(sc, 0x14, 0xd708);
-                MP_WritePhyUshort(sc, 0x14, 0x6073);
-                MP_WritePhyUshort(sc, 0x14, 0x5fbc);
-                MP_WritePhyUshort(sc, 0x14, 0x2c46);
-                MP_WritePhyUshort(sc, 0x14, 0x26fe);
-                MP_WritePhyUshort(sc, 0x14, 0xb280);
-                MP_WritePhyUshort(sc, 0x14, 0xa841);
-                MP_WritePhyUshort(sc, 0x14, 0x94e0);
-                MP_WritePhyUshort(sc, 0x14, 0x8710);
-                MP_WritePhyUshort(sc, 0x14, 0xd709);
-                MP_WritePhyUshort(sc, 0x14, 0x42ec);
-                MP_WritePhyUshort(sc, 0x14, 0x606d);
-                MP_WritePhyUshort(sc, 0x14, 0xd207);
-                MP_WritePhyUshort(sc, 0x14, 0x2c50);
-                MP_WritePhyUshort(sc, 0x14, 0xd203);
-                MP_WritePhyUshort(sc, 0x14, 0x33ff);
-                MP_WritePhyUshort(sc, 0x14, 0x5647);
-                MP_WritePhyUshort(sc, 0x14, 0x3275);
-                MP_WritePhyUshort(sc, 0x14, 0x7c57);
-                MP_WritePhyUshort(sc, 0x14, 0xb240);
-                MP_WritePhyUshort(sc, 0x14, 0xb402);
-                MP_WritePhyUshort(sc, 0x14, 0x2647);
-                MP_WritePhyUshort(sc, 0x14, 0x6096);
-                MP_WritePhyUshort(sc, 0x14, 0xb240);
-                MP_WritePhyUshort(sc, 0x14, 0xb406);
-                MP_WritePhyUshort(sc, 0x14, 0x2647);
-                MP_WritePhyUshort(sc, 0x14, 0x31d7);
-                MP_WritePhyUshort(sc, 0x14, 0x7c60);
-                MP_WritePhyUshort(sc, 0x14, 0xb240);
-                MP_WritePhyUshort(sc, 0x14, 0xb40e);
-                MP_WritePhyUshort(sc, 0x14, 0x2647);
-                MP_WritePhyUshort(sc, 0x14, 0xb410);
-                MP_WritePhyUshort(sc, 0x14, 0x8802);
-                MP_WritePhyUshort(sc, 0x14, 0xb240);
-                MP_WritePhyUshort(sc, 0x14, 0x940e);
-                MP_WritePhyUshort(sc, 0x14, 0x2647);
-                MP_WritePhyUshort(sc, 0x14, 0xba04);
-                MP_WritePhyUshort(sc, 0x14, 0x1cdd);
-                MP_WritePhyUshort(sc, 0x14, 0xa902);
-                MP_WritePhyUshort(sc, 0x14, 0xd711);
-                MP_WritePhyUshort(sc, 0x14, 0x4045);
-                MP_WritePhyUshort(sc, 0x14, 0xa980);
-                MP_WritePhyUshort(sc, 0x14, 0x3003);
-                MP_WritePhyUshort(sc, 0x14, 0x5a19);
-                MP_WritePhyUshort(sc, 0x14, 0xa540);
-                MP_WritePhyUshort(sc, 0x14, 0xa601);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x4043);
-                MP_WritePhyUshort(sc, 0x14, 0xa910);
-                MP_WritePhyUshort(sc, 0x14, 0xd711);
-                MP_WritePhyUshort(sc, 0x14, 0x60a0);
-                MP_WritePhyUshort(sc, 0x14, 0xca33);
-                MP_WritePhyUshort(sc, 0x14, 0xcb33);
-                MP_WritePhyUshort(sc, 0x14, 0xa941);
-                MP_WritePhyUshort(sc, 0x14, 0x2c7b);
-                MP_WritePhyUshort(sc, 0x14, 0xcaff);
-                MP_WritePhyUshort(sc, 0x14, 0xcbff);
-                MP_WritePhyUshort(sc, 0x14, 0xa921);
-                MP_WritePhyUshort(sc, 0x14, 0xce02);
-                MP_WritePhyUshort(sc, 0x14, 0xe070);
-                MP_WritePhyUshort(sc, 0x14, 0x0f10);
-                MP_WritePhyUshort(sc, 0x14, 0xaf01);
-                MP_WritePhyUshort(sc, 0x14, 0x8f01);
-                MP_WritePhyUshort(sc, 0x14, 0x1791);
-                MP_WritePhyUshort(sc, 0x14, 0x8e02);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x41a3);
-                MP_WritePhyUshort(sc, 0x14, 0xa140);
-                MP_WritePhyUshort(sc, 0x14, 0xa220);
-                MP_WritePhyUshort(sc, 0x14, 0xce10);
-                MP_WritePhyUshort(sc, 0x14, 0xe070);
-                MP_WritePhyUshort(sc, 0x14, 0x0f40);
-                MP_WritePhyUshort(sc, 0x14, 0xaf01);
-                MP_WritePhyUshort(sc, 0x14, 0x8f01);
-                MP_WritePhyUshort(sc, 0x14, 0x1791);
-                MP_WritePhyUshort(sc, 0x14, 0x8e10);
-                MP_WritePhyUshort(sc, 0x14, 0x8140);
-                MP_WritePhyUshort(sc, 0x14, 0x8220);
-                MP_WritePhyUshort(sc, 0x14, 0xa301);
-                MP_WritePhyUshort(sc, 0x14, 0x17b2);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x609c);
-                MP_WritePhyUshort(sc, 0x14, 0xd71e);
-                MP_WritePhyUshort(sc, 0x14, 0x7fa4);
-                MP_WritePhyUshort(sc, 0x14, 0x2cdb);
-                MP_WritePhyUshort(sc, 0x14, 0x1cf0);
-                MP_WritePhyUshort(sc, 0x14, 0xce04);
-                MP_WritePhyUshort(sc, 0x14, 0xe070);
-                MP_WritePhyUshort(sc, 0x14, 0x0f20);
-                MP_WritePhyUshort(sc, 0x14, 0xaf01);
-                MP_WritePhyUshort(sc, 0x14, 0x8f01);
-                MP_WritePhyUshort(sc, 0x14, 0x1791);
-                MP_WritePhyUshort(sc, 0x14, 0x8e04);
-                MP_WritePhyUshort(sc, 0x14, 0x6044);
-                MP_WritePhyUshort(sc, 0x14, 0x2cdb);
-                MP_WritePhyUshort(sc, 0x14, 0xa520);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x4043);
-                MP_WritePhyUshort(sc, 0x14, 0x2cc8);
-                MP_WritePhyUshort(sc, 0x14, 0xe00f);
-                MP_WritePhyUshort(sc, 0x14, 0x0501);
-                MP_WritePhyUshort(sc, 0x14, 0x1cf6);
-                MP_WritePhyUshort(sc, 0x14, 0xb801);
-                MP_WritePhyUshort(sc, 0x14, 0xd71e);
-                MP_WritePhyUshort(sc, 0x14, 0x4060);
-                MP_WritePhyUshort(sc, 0x14, 0x7fc4);
-                MP_WritePhyUshort(sc, 0x14, 0x2cdb);
-                MP_WritePhyUshort(sc, 0x14, 0x1cfc);
-                MP_WritePhyUshort(sc, 0x14, 0xe00f);
-                MP_WritePhyUshort(sc, 0x14, 0x0502);
-                MP_WritePhyUshort(sc, 0x14, 0x1cf6);
-                MP_WritePhyUshort(sc, 0x14, 0xb802);
-                MP_WritePhyUshort(sc, 0x14, 0xd71e);
-                MP_WritePhyUshort(sc, 0x14, 0x4061);
-                MP_WritePhyUshort(sc, 0x14, 0x7fc4);
-                MP_WritePhyUshort(sc, 0x14, 0x2cdb);
-                MP_WritePhyUshort(sc, 0x14, 0x1cfc);
-                MP_WritePhyUshort(sc, 0x14, 0xe00f);
-                MP_WritePhyUshort(sc, 0x14, 0x0504);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x6099);
-                MP_WritePhyUshort(sc, 0x14, 0xd71e);
-                MP_WritePhyUshort(sc, 0x14, 0x7fa4);
-                MP_WritePhyUshort(sc, 0x14, 0x2cdb);
-                MP_WritePhyUshort(sc, 0x14, 0xc17f);
-                MP_WritePhyUshort(sc, 0x14, 0xc200);
-                MP_WritePhyUshort(sc, 0x14, 0xc43f);
-                MP_WritePhyUshort(sc, 0x14, 0xcc03);
-                MP_WritePhyUshort(sc, 0x14, 0xa701);
-                MP_WritePhyUshort(sc, 0x14, 0xa510);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x4018);
-                MP_WritePhyUshort(sc, 0x14, 0x9910);
-                MP_WritePhyUshort(sc, 0x14, 0x8510);
-                MP_WritePhyUshort(sc, 0x14, 0x28a1);
-                MP_WritePhyUshort(sc, 0x14, 0xe00f);
-                MP_WritePhyUshort(sc, 0x14, 0x0504);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x6099);
-                MP_WritePhyUshort(sc, 0x14, 0xd71e);
-                MP_WritePhyUshort(sc, 0x14, 0x7fa4);
-                MP_WritePhyUshort(sc, 0x14, 0x2cdb);
-                MP_WritePhyUshort(sc, 0x14, 0xa608);
-                MP_WritePhyUshort(sc, 0x14, 0xc17d);
-                MP_WritePhyUshort(sc, 0x14, 0xc200);
-                MP_WritePhyUshort(sc, 0x14, 0xc43f);
-                MP_WritePhyUshort(sc, 0x14, 0xcc03);
-                MP_WritePhyUshort(sc, 0x14, 0xa701);
-                MP_WritePhyUshort(sc, 0x14, 0xa510);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x4018);
-                MP_WritePhyUshort(sc, 0x14, 0x9910);
-                MP_WritePhyUshort(sc, 0x14, 0x8510);
-                MP_WritePhyUshort(sc, 0x14, 0x298e);
-                MP_WritePhyUshort(sc, 0x14, 0x17bd);
-                MP_WritePhyUshort(sc, 0x14, 0x2815);
-                MP_WritePhyUshort(sc, 0x14, 0xc000);
-                MP_WritePhyUshort(sc, 0x14, 0xc100);
-                MP_WritePhyUshort(sc, 0x14, 0xc200);
-                MP_WritePhyUshort(sc, 0x14, 0xc300);
-                MP_WritePhyUshort(sc, 0x14, 0xc400);
-                MP_WritePhyUshort(sc, 0x14, 0xc500);
-                MP_WritePhyUshort(sc, 0x14, 0xc600);
-                MP_WritePhyUshort(sc, 0x14, 0xc7c1);
-                MP_WritePhyUshort(sc, 0x14, 0xc800);
-                MP_WritePhyUshort(sc, 0x14, 0xcc00);
-                MP_WritePhyUshort(sc, 0x14, 0x0800);
-                MP_WritePhyUshort(sc, 0x14, 0xca0f);
-                MP_WritePhyUshort(sc, 0x14, 0xcbff);
-                MP_WritePhyUshort(sc, 0x14, 0xa901);
-                MP_WritePhyUshort(sc, 0x14, 0x8902);
-                MP_WritePhyUshort(sc, 0x14, 0xc900);
-                MP_WritePhyUshort(sc, 0x14, 0xca00);
-                MP_WritePhyUshort(sc, 0x14, 0xcb00);
-                MP_WritePhyUshort(sc, 0x14, 0x0800);
-                MP_WritePhyUshort(sc, 0x14, 0xb804);
-                MP_WritePhyUshort(sc, 0x14, 0x0800);
-                MP_WritePhyUshort(sc, 0x14, 0xd71e);
-                MP_WritePhyUshort(sc, 0x14, 0x6044);
-                MP_WritePhyUshort(sc, 0x14, 0x9804);
-                MP_WritePhyUshort(sc, 0x14, 0x0800);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x6099);
-                MP_WritePhyUshort(sc, 0x14, 0xd71e);
-                MP_WritePhyUshort(sc, 0x14, 0x7fa4);
-                MP_WritePhyUshort(sc, 0x14, 0x2cdb);
-                MP_WritePhyUshort(sc, 0x14, 0x0800);
-                MP_WritePhyUshort(sc, 0x14, 0xa510);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x6098);
-                MP_WritePhyUshort(sc, 0x14, 0xd71e);
-                MP_WritePhyUshort(sc, 0x14, 0x7fa4);
-                MP_WritePhyUshort(sc, 0x14, 0x2cdb);
-                MP_WritePhyUshort(sc, 0x14, 0x8510);
-                MP_WritePhyUshort(sc, 0x14, 0x0800);
-                MP_WritePhyUshort(sc, 0x14, 0xd711);
-                MP_WritePhyUshort(sc, 0x14, 0x3003);
-                MP_WritePhyUshort(sc, 0x14, 0x1d08);
-                MP_WritePhyUshort(sc, 0x14, 0x2d12);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x60be);
-                MP_WritePhyUshort(sc, 0x14, 0xe060);
-                MP_WritePhyUshort(sc, 0x14, 0x0920);
-                MP_WritePhyUshort(sc, 0x14, 0x1cdd);
-                MP_WritePhyUshort(sc, 0x14, 0x2c90);
-                MP_WritePhyUshort(sc, 0x14, 0xd71e);
-                MP_WritePhyUshort(sc, 0x14, 0x3063);
-                MP_WritePhyUshort(sc, 0x14, 0x19b0);
-                MP_WritePhyUshort(sc, 0x14, 0x28d5);
-                MP_WritePhyUshort(sc, 0x14, 0x1cdd);
-                MP_WritePhyUshort(sc, 0x14, 0x2a25);
-                MP_WritePhyUshort(sc, 0x14, 0xa802);
-                MP_WritePhyUshort(sc, 0x14, 0xa303);
-                MP_WritePhyUshort(sc, 0x14, 0x843f);
-                MP_WritePhyUshort(sc, 0x14, 0x81ff);
-                MP_WritePhyUshort(sc, 0x14, 0x8208);
-                MP_WritePhyUshort(sc, 0x14, 0xa201);
-                MP_WritePhyUshort(sc, 0x14, 0xc001);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x30a0);
-                MP_WritePhyUshort(sc, 0x14, 0x0d23);
-                MP_WritePhyUshort(sc, 0x14, 0x30a0);
-                MP_WritePhyUshort(sc, 0x14, 0x3d1a);
-                MP_WritePhyUshort(sc, 0x14, 0xd71e);
-                MP_WritePhyUshort(sc, 0x14, 0x7f4c);
-                MP_WritePhyUshort(sc, 0x14, 0x2b1e);
-                MP_WritePhyUshort(sc, 0x14, 0xe003);
-                MP_WritePhyUshort(sc, 0x14, 0x0202);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x6090);
-                MP_WritePhyUshort(sc, 0x14, 0xd71e);
-                MP_WritePhyUshort(sc, 0x14, 0x7fac);
-                MP_WritePhyUshort(sc, 0x14, 0x2b1e);
-                MP_WritePhyUshort(sc, 0x14, 0xa20c);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x6091);
-                MP_WritePhyUshort(sc, 0x14, 0xd71e);
-                MP_WritePhyUshort(sc, 0x14, 0x7fac);
-                MP_WritePhyUshort(sc, 0x14, 0x2b1e);
-                MP_WritePhyUshort(sc, 0x14, 0x820e);
-                MP_WritePhyUshort(sc, 0x14, 0xa3e0);
-                MP_WritePhyUshort(sc, 0x14, 0xa520);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x609d);
-                MP_WritePhyUshort(sc, 0x14, 0xd71e);
-                MP_WritePhyUshort(sc, 0x14, 0x7fac);
-                MP_WritePhyUshort(sc, 0x14, 0x2b1e);
-                MP_WritePhyUshort(sc, 0x14, 0x8520);
-                MP_WritePhyUshort(sc, 0x14, 0x6703);
-                MP_WritePhyUshort(sc, 0x14, 0x2d3b);
-                MP_WritePhyUshort(sc, 0x14, 0xa13e);
-                MP_WritePhyUshort(sc, 0x14, 0xc001);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x4000);
-                MP_WritePhyUshort(sc, 0x14, 0x6046);
-                MP_WritePhyUshort(sc, 0x14, 0x2d14);
-                MP_WritePhyUshort(sc, 0x14, 0xa43f);
-                MP_WritePhyUshort(sc, 0x14, 0xa101);
-                MP_WritePhyUshort(sc, 0x14, 0xc020);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x3121);
-                MP_WritePhyUshort(sc, 0x14, 0x0d4c);
-                MP_WritePhyUshort(sc, 0x14, 0x30c0);
-                MP_WritePhyUshort(sc, 0x14, 0x3d14);
-                MP_WritePhyUshort(sc, 0x14, 0xd71e);
-                MP_WritePhyUshort(sc, 0x14, 0x7f4c);
-                MP_WritePhyUshort(sc, 0x14, 0x2b1e);
-                MP_WritePhyUshort(sc, 0x14, 0xa540);
-                MP_WritePhyUshort(sc, 0x14, 0xc001);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x4001);
-                MP_WritePhyUshort(sc, 0x14, 0xe00f);
-                MP_WritePhyUshort(sc, 0x14, 0x0501);
-                MP_WritePhyUshort(sc, 0x14, 0x1db3);
-                MP_WritePhyUshort(sc, 0x14, 0xc1c4);
-                MP_WritePhyUshort(sc, 0x14, 0xa268);
-                MP_WritePhyUshort(sc, 0x14, 0xa303);
-                MP_WritePhyUshort(sc, 0x14, 0x8420);
-                MP_WritePhyUshort(sc, 0x14, 0xe00f);
-                MP_WritePhyUshort(sc, 0x14, 0x0502);
-                MP_WritePhyUshort(sc, 0x14, 0x1db3);
-                MP_WritePhyUshort(sc, 0x14, 0xc002);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x4000);
-                MP_WritePhyUshort(sc, 0x14, 0x8208);
-                MP_WritePhyUshort(sc, 0x14, 0x8410);
-                MP_WritePhyUshort(sc, 0x14, 0xa121);
-                MP_WritePhyUshort(sc, 0x14, 0xc002);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x4000);
-                MP_WritePhyUshort(sc, 0x14, 0x8120);
-                MP_WritePhyUshort(sc, 0x14, 0x8180);
-                MP_WritePhyUshort(sc, 0x14, 0x1d9e);
-                MP_WritePhyUshort(sc, 0x14, 0xa180);
-                MP_WritePhyUshort(sc, 0x14, 0xa13a);
-                MP_WritePhyUshort(sc, 0x14, 0x8240);
-                MP_WritePhyUshort(sc, 0x14, 0xa430);
-                MP_WritePhyUshort(sc, 0x14, 0xc010);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x30e1);
-                MP_WritePhyUshort(sc, 0x14, 0x0b24);
-                MP_WritePhyUshort(sc, 0x14, 0xd71e);
-                MP_WritePhyUshort(sc, 0x14, 0x7f8c);
-                MP_WritePhyUshort(sc, 0x14, 0x2b1e);
-                MP_WritePhyUshort(sc, 0x14, 0xa480);
-                MP_WritePhyUshort(sc, 0x14, 0xa230);
-                MP_WritePhyUshort(sc, 0x14, 0xa303);
-                MP_WritePhyUshort(sc, 0x14, 0xc001);
-                MP_WritePhyUshort(sc, 0x14, 0xd70c);
-                MP_WritePhyUshort(sc, 0x14, 0x4124);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x6120);
-                MP_WritePhyUshort(sc, 0x14, 0xd711);
-                MP_WritePhyUshort(sc, 0x14, 0x3128);
-                MP_WritePhyUshort(sc, 0x14, 0x3d7d);
-                MP_WritePhyUshort(sc, 0x14, 0x2d77);
-                MP_WritePhyUshort(sc, 0x14, 0xa801);
-                MP_WritePhyUshort(sc, 0x14, 0x2d73);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x4000);
-                MP_WritePhyUshort(sc, 0x14, 0xe018);
-                MP_WritePhyUshort(sc, 0x14, 0x0208);
-                MP_WritePhyUshort(sc, 0x14, 0xa1f8);
-                MP_WritePhyUshort(sc, 0x14, 0x8480);
-                MP_WritePhyUshort(sc, 0x14, 0xc004);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x4000);
-                MP_WritePhyUshort(sc, 0x14, 0x6046);
-                MP_WritePhyUshort(sc, 0x14, 0x2d14);
-                MP_WritePhyUshort(sc, 0x14, 0xa43f);
-                MP_WritePhyUshort(sc, 0x14, 0xa105);
-                MP_WritePhyUshort(sc, 0x14, 0x8228);
-                MP_WritePhyUshort(sc, 0x14, 0xc004);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x4000);
-                MP_WritePhyUshort(sc, 0x14, 0x81bc);
-                MP_WritePhyUshort(sc, 0x14, 0xa220);
-                MP_WritePhyUshort(sc, 0x14, 0x1d9e);
-                MP_WritePhyUshort(sc, 0x14, 0x8220);
-                MP_WritePhyUshort(sc, 0x14, 0xa1bc);
-                MP_WritePhyUshort(sc, 0x14, 0xc040);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x30e1);
-                MP_WritePhyUshort(sc, 0x14, 0x0b24);
-                MP_WritePhyUshort(sc, 0x14, 0x30e1);
-                MP_WritePhyUshort(sc, 0x14, 0x3d14);
-                MP_WritePhyUshort(sc, 0x14, 0xd71e);
-                MP_WritePhyUshort(sc, 0x14, 0x7f4c);
-                MP_WritePhyUshort(sc, 0x14, 0x2b1e);
-                MP_WritePhyUshort(sc, 0x14, 0xa802);
-                MP_WritePhyUshort(sc, 0x14, 0xd70c);
-                MP_WritePhyUshort(sc, 0x14, 0x4244);
-                MP_WritePhyUshort(sc, 0x14, 0xa301);
-                MP_WritePhyUshort(sc, 0x14, 0xc004);
-                MP_WritePhyUshort(sc, 0x14, 0xd711);
-                MP_WritePhyUshort(sc, 0x14, 0x3128);
-                MP_WritePhyUshort(sc, 0x14, 0x3dac);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x5f80);
-                MP_WritePhyUshort(sc, 0x14, 0xd711);
-                MP_WritePhyUshort(sc, 0x14, 0x3109);
-                MP_WritePhyUshort(sc, 0x14, 0x3dae);
-                MP_WritePhyUshort(sc, 0x14, 0x2db2);
-                MP_WritePhyUshort(sc, 0x14, 0xa801);
-                MP_WritePhyUshort(sc, 0x14, 0x2da1);
-                MP_WritePhyUshort(sc, 0x14, 0xa802);
-                MP_WritePhyUshort(sc, 0x14, 0xc004);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x4000);
-                MP_WritePhyUshort(sc, 0x14, 0x0800);
-                MP_WritePhyUshort(sc, 0x14, 0xa510);
-                MP_WritePhyUshort(sc, 0x14, 0xd710);
-                MP_WritePhyUshort(sc, 0x14, 0x609a);
-                MP_WritePhyUshort(sc, 0x14, 0xd71e);
-                MP_WritePhyUshort(sc, 0x14, 0x7fac);
-                MP_WritePhyUshort(sc, 0x14, 0x2b1e);
-                MP_WritePhyUshort(sc, 0x14, 0x8510);
-                MP_WritePhyUshort(sc, 0x14, 0x0800);
-                MP_WritePhyUshort(sc, 0x13, 0xa01a);
-                MP_WritePhyUshort(sc, 0x14, 0x0000);
-                MP_WritePhyUshort(sc, 0x13, 0xa006);
-                MP_WritePhyUshort(sc, 0x14, 0x0b3e);
-                MP_WritePhyUshort(sc, 0x13, 0xa004);
-                MP_WritePhyUshort(sc, 0x14, 0x0828);
-                MP_WritePhyUshort(sc, 0x13, 0xa002);
-                MP_WritePhyUshort(sc, 0x14, 0x06dd);
-                MP_WritePhyUshort(sc, 0x13, 0xa000);
-                MP_WritePhyUshort(sc, 0x14, 0xf815);
-                MP_WritePhyUshort(sc, 0x13, 0xb820);
-                MP_WritePhyUshort(sc, 0x14, 0x0010);
-
-                MP_WritePhyUshort(sc,0x1F, 0x0A43);
-                MP_WritePhyUshort(sc, 0x13, 0x83b0);
-                MP_WritePhyUshort(sc, 0x14, 0xaf83);
-                MP_WritePhyUshort(sc, 0x14, 0xbcaf);
-                MP_WritePhyUshort(sc, 0x14, 0x83c8);
-                MP_WritePhyUshort(sc, 0x14, 0xaf83);
-                MP_WritePhyUshort(sc, 0x14, 0xddaf);
-                MP_WritePhyUshort(sc, 0x14, 0x83e0);
-                MP_WritePhyUshort(sc, 0x14, 0x0204);
-                MP_WritePhyUshort(sc, 0x14, 0xa102);
-                MP_WritePhyUshort(sc, 0x14, 0x09b4);
-                MP_WritePhyUshort(sc, 0x14, 0x0284);
-                MP_WritePhyUshort(sc, 0x14, 0x62af);
-                MP_WritePhyUshort(sc, 0x14, 0x02ec);
-                MP_WritePhyUshort(sc, 0x14, 0xad20);
-                MP_WritePhyUshort(sc, 0x14, 0x0302);
-                MP_WritePhyUshort(sc, 0x14, 0x867d);
-                MP_WritePhyUshort(sc, 0x14, 0xad21);
-                MP_WritePhyUshort(sc, 0x14, 0x0302);
-                MP_WritePhyUshort(sc, 0x14, 0x85ca);
-                MP_WritePhyUshort(sc, 0x14, 0xad22);
-                MP_WritePhyUshort(sc, 0x14, 0x0302);
-                MP_WritePhyUshort(sc, 0x14, 0x1bce);
-                MP_WritePhyUshort(sc, 0x14, 0xaf18);
-                MP_WritePhyUshort(sc, 0x14, 0x11af);
-                MP_WritePhyUshort(sc, 0x14, 0x1811);
-                MP_WritePhyUshort(sc, 0x14, 0x0106);
-                MP_WritePhyUshort(sc, 0x14, 0xe081);
-                MP_WritePhyUshort(sc, 0x14, 0x48af);
-                MP_WritePhyUshort(sc, 0x14, 0x3b1f);
-                MP_WritePhyUshort(sc, 0x14, 0xf8f9);
-                MP_WritePhyUshort(sc, 0x14, 0xfaef);
-                MP_WritePhyUshort(sc, 0x14, 0x69ee);
-                MP_WritePhyUshort(sc, 0x14, 0x8010);
-                MP_WritePhyUshort(sc, 0x14, 0xf7d1);
-                MP_WritePhyUshort(sc, 0x14, 0x04bf);
-                MP_WritePhyUshort(sc, 0x14, 0x8776);
-                MP_WritePhyUshort(sc, 0x14, 0x0241);
-                MP_WritePhyUshort(sc, 0x14, 0x0a02);
-                MP_WritePhyUshort(sc, 0x14, 0x8704);
-                MP_WritePhyUshort(sc, 0x14, 0xbf87);
-                MP_WritePhyUshort(sc, 0x14, 0x4fd7);
-                MP_WritePhyUshort(sc, 0x14, 0xb822);
-                MP_WritePhyUshort(sc, 0x14, 0xd00c);
-                MP_WritePhyUshort(sc, 0x14, 0x0241);
-                MP_WritePhyUshort(sc, 0x14, 0x03ee);
-                MP_WritePhyUshort(sc, 0x14, 0x80cd);
-                MP_WritePhyUshort(sc, 0x14, 0xa0ee);
-                MP_WritePhyUshort(sc, 0x14, 0x80ce);
-                MP_WritePhyUshort(sc, 0x14, 0x8bee);
-                MP_WritePhyUshort(sc, 0x14, 0x80d1);
-                MP_WritePhyUshort(sc, 0x14, 0xf5ee);
-                MP_WritePhyUshort(sc, 0x14, 0x80d2);
-                MP_WritePhyUshort(sc, 0x14, 0xa9ee);
-                MP_WritePhyUshort(sc, 0x14, 0x80d3);
-                MP_WritePhyUshort(sc, 0x14, 0x0aee);
-                MP_WritePhyUshort(sc, 0x14, 0x80f0);
-                MP_WritePhyUshort(sc, 0x14, 0x10ee);
-                MP_WritePhyUshort(sc, 0x14, 0x80f3);
-                MP_WritePhyUshort(sc, 0x14, 0x8fee);
-                MP_WritePhyUshort(sc, 0x14, 0x8101);
-                MP_WritePhyUshort(sc, 0x14, 0x1eee);
-                MP_WritePhyUshort(sc, 0x14, 0x810b);
-                MP_WritePhyUshort(sc, 0x14, 0x4aee);
-                MP_WritePhyUshort(sc, 0x14, 0x810c);
-                MP_WritePhyUshort(sc, 0x14, 0x7cee);
-                MP_WritePhyUshort(sc, 0x14, 0x8112);
-                MP_WritePhyUshort(sc, 0x14, 0x7fd1);
-                MP_WritePhyUshort(sc, 0x14, 0x0002);
-                MP_WritePhyUshort(sc, 0x14, 0x10e3);
-                MP_WritePhyUshort(sc, 0x14, 0xee80);
-                MP_WritePhyUshort(sc, 0x14, 0x8892);
-                MP_WritePhyUshort(sc, 0x14, 0xee80);
-                MP_WritePhyUshort(sc, 0x14, 0x8922);
-                MP_WritePhyUshort(sc, 0x14, 0xee80);
-                MP_WritePhyUshort(sc, 0x14, 0x9a80);
-                MP_WritePhyUshort(sc, 0x14, 0xee80);
-                MP_WritePhyUshort(sc, 0x14, 0x9b22);
-                MP_WritePhyUshort(sc, 0x14, 0xee80);
-                MP_WritePhyUshort(sc, 0x14, 0x9ca7);
-                MP_WritePhyUshort(sc, 0x14, 0xee80);
-                MP_WritePhyUshort(sc, 0x14, 0xa010);
-                MP_WritePhyUshort(sc, 0x14, 0xee80);
-                MP_WritePhyUshort(sc, 0x14, 0xa5a7);
-                MP_WritePhyUshort(sc, 0x14, 0xd200);
-                MP_WritePhyUshort(sc, 0x14, 0x020e);
-                MP_WritePhyUshort(sc, 0x14, 0x4b02);
-                MP_WritePhyUshort(sc, 0x14, 0x85c1);
-                MP_WritePhyUshort(sc, 0x14, 0xef96);
-                MP_WritePhyUshort(sc, 0x14, 0xfefd);
-                MP_WritePhyUshort(sc, 0x14, 0xfc04);
-                MP_WritePhyUshort(sc, 0x14, 0x0284);
-                MP_WritePhyUshort(sc, 0x14, 0x7b02);
-                MP_WritePhyUshort(sc, 0x14, 0x84b4);
-                MP_WritePhyUshort(sc, 0x14, 0x020c);
-                MP_WritePhyUshort(sc, 0x14, 0x9202);
-                MP_WritePhyUshort(sc, 0x14, 0x0cab);
-                MP_WritePhyUshort(sc, 0x14, 0x020c);
-                MP_WritePhyUshort(sc, 0x14, 0xd602);
-                MP_WritePhyUshort(sc, 0x14, 0x0cef);
-                MP_WritePhyUshort(sc, 0x14, 0x020d);
-                MP_WritePhyUshort(sc, 0x14, 0x1a02);
-                MP_WritePhyUshort(sc, 0x14, 0x0c24);
-                MP_WritePhyUshort(sc, 0x14, 0x04f8);
-                MP_WritePhyUshort(sc, 0x14, 0xfaef);
-                MP_WritePhyUshort(sc, 0x14, 0x69e1);
-                MP_WritePhyUshort(sc, 0x14, 0x8234);
-                MP_WritePhyUshort(sc, 0x14, 0xac29);
-                MP_WritePhyUshort(sc, 0x14, 0x1ae0);
-                MP_WritePhyUshort(sc, 0x14, 0x8229);
-                MP_WritePhyUshort(sc, 0x14, 0xac21);
-                MP_WritePhyUshort(sc, 0x14, 0x02ae);
-                MP_WritePhyUshort(sc, 0x14, 0x2202);
-                MP_WritePhyUshort(sc, 0x14, 0x1085);
-                MP_WritePhyUshort(sc, 0x14, 0xf621);
-                MP_WritePhyUshort(sc, 0x14, 0xe482);
-                MP_WritePhyUshort(sc, 0x14, 0x29d1);
-                MP_WritePhyUshort(sc, 0x14, 0x01bf);
-                MP_WritePhyUshort(sc, 0x14, 0x4364);
-                MP_WritePhyUshort(sc, 0x14, 0x0241);
-                MP_WritePhyUshort(sc, 0x14, 0x0aae);
-                MP_WritePhyUshort(sc, 0x14, 0x1002);
-                MP_WritePhyUshort(sc, 0x14, 0x127a);
-                MP_WritePhyUshort(sc, 0x14, 0xf629);
-                MP_WritePhyUshort(sc, 0x14, 0xe582);
-                MP_WritePhyUshort(sc, 0x14, 0x34e0);
-                MP_WritePhyUshort(sc, 0x14, 0x8229);
-                MP_WritePhyUshort(sc, 0x14, 0xf621);
-                MP_WritePhyUshort(sc, 0x14, 0xe482);
-                MP_WritePhyUshort(sc, 0x14, 0x29ef);
-                MP_WritePhyUshort(sc, 0x14, 0x96fe);
-                MP_WritePhyUshort(sc, 0x14, 0xfc04);
-                MP_WritePhyUshort(sc, 0x14, 0xf8e1);
-                MP_WritePhyUshort(sc, 0x14, 0x8234);
-                MP_WritePhyUshort(sc, 0x14, 0xac2a);
-                MP_WritePhyUshort(sc, 0x14, 0x18e0);
-                MP_WritePhyUshort(sc, 0x14, 0x8229);
-                MP_WritePhyUshort(sc, 0x14, 0xac22);
-                MP_WritePhyUshort(sc, 0x14, 0x02ae);
-                MP_WritePhyUshort(sc, 0x14, 0x2602);
-                MP_WritePhyUshort(sc, 0x14, 0x84f9);
-                MP_WritePhyUshort(sc, 0x14, 0x0285);
-                MP_WritePhyUshort(sc, 0x14, 0x66d1);
-                MP_WritePhyUshort(sc, 0x14, 0x01bf);
-                MP_WritePhyUshort(sc, 0x14, 0x4367);
-                MP_WritePhyUshort(sc, 0x14, 0x0241);
-                MP_WritePhyUshort(sc, 0x14, 0x0aae);
-                MP_WritePhyUshort(sc, 0x14, 0x0e02);
-                MP_WritePhyUshort(sc, 0x14, 0x84eb);
-                MP_WritePhyUshort(sc, 0x14, 0x0285);
-                MP_WritePhyUshort(sc, 0x14, 0xaae1);
-                MP_WritePhyUshort(sc, 0x14, 0x8234);
-                MP_WritePhyUshort(sc, 0x14, 0xf62a);
-                MP_WritePhyUshort(sc, 0x14, 0xe582);
-                MP_WritePhyUshort(sc, 0x14, 0x34e0);
-                MP_WritePhyUshort(sc, 0x14, 0x8229);
-                MP_WritePhyUshort(sc, 0x14, 0xf622);
-                MP_WritePhyUshort(sc, 0x14, 0xe482);
-                MP_WritePhyUshort(sc, 0x14, 0x29fc);
-                MP_WritePhyUshort(sc, 0x14, 0x04f9);
-                MP_WritePhyUshort(sc, 0x14, 0xe280);
-                MP_WritePhyUshort(sc, 0x14, 0x11ad);
-                MP_WritePhyUshort(sc, 0x14, 0x3105);
-                MP_WritePhyUshort(sc, 0x14, 0xd200);
-                MP_WritePhyUshort(sc, 0x14, 0x020e);
-                MP_WritePhyUshort(sc, 0x14, 0x4bfd);
-                MP_WritePhyUshort(sc, 0x14, 0x04f8);
-                MP_WritePhyUshort(sc, 0x14, 0xf9fa);
-                MP_WritePhyUshort(sc, 0x14, 0xef69);
-                MP_WritePhyUshort(sc, 0x14, 0xe080);
-                MP_WritePhyUshort(sc, 0x14, 0x11ad);
-                MP_WritePhyUshort(sc, 0x14, 0x215c);
-                MP_WritePhyUshort(sc, 0x14, 0xbf42);
-                MP_WritePhyUshort(sc, 0x14, 0x5002);
-                MP_WritePhyUshort(sc, 0x14, 0x4148);
-                MP_WritePhyUshort(sc, 0x14, 0xac28);
-                MP_WritePhyUshort(sc, 0x14, 0x1bbf);
-                MP_WritePhyUshort(sc, 0x14, 0x4253);
-                MP_WritePhyUshort(sc, 0x14, 0x0241);
-                MP_WritePhyUshort(sc, 0x14, 0x48ac);
-                MP_WritePhyUshort(sc, 0x14, 0x2812);
-                MP_WritePhyUshort(sc, 0x14, 0xbf42);
-                MP_WritePhyUshort(sc, 0x14, 0x5902);
-                MP_WritePhyUshort(sc, 0x14, 0x4148);
-                MP_WritePhyUshort(sc, 0x14, 0xac28);
-                MP_WritePhyUshort(sc, 0x14, 0x04d3);
-                MP_WritePhyUshort(sc, 0x14, 0x00ae);
-                MP_WritePhyUshort(sc, 0x14, 0x07d3);
-                MP_WritePhyUshort(sc, 0x14, 0x06af);
-                MP_WritePhyUshort(sc, 0x14, 0x8557);
-                MP_WritePhyUshort(sc, 0x14, 0xd303);
-                MP_WritePhyUshort(sc, 0x14, 0xe080);
-                MP_WritePhyUshort(sc, 0x14, 0x11ad);
-                MP_WritePhyUshort(sc, 0x14, 0x2625);
-                MP_WritePhyUshort(sc, 0x14, 0xbf43);
-                MP_WritePhyUshort(sc, 0x14, 0xeb02);
-                MP_WritePhyUshort(sc, 0x14, 0x4148);
-                MP_WritePhyUshort(sc, 0x14, 0xe280);
-                MP_WritePhyUshort(sc, 0x14, 0x730d);
-                MP_WritePhyUshort(sc, 0x14, 0x21f6);
-                MP_WritePhyUshort(sc, 0x14, 0x370d);
-                MP_WritePhyUshort(sc, 0x14, 0x11f6);
-                MP_WritePhyUshort(sc, 0x14, 0x2f1b);
-                MP_WritePhyUshort(sc, 0x14, 0x21aa);
-                MP_WritePhyUshort(sc, 0x14, 0x02ae);
-                MP_WritePhyUshort(sc, 0x14, 0x10e2);
-                MP_WritePhyUshort(sc, 0x14, 0x8074);
-                MP_WritePhyUshort(sc, 0x14, 0x0d21);
-                MP_WritePhyUshort(sc, 0x14, 0xf637);
-                MP_WritePhyUshort(sc, 0x14, 0x1b21);
-                MP_WritePhyUshort(sc, 0x14, 0xaa03);
-                MP_WritePhyUshort(sc, 0x14, 0x13ae);
-                MP_WritePhyUshort(sc, 0x14, 0x022b);
-                MP_WritePhyUshort(sc, 0x14, 0x0202);
-                MP_WritePhyUshort(sc, 0x14, 0x0e36);
-                MP_WritePhyUshort(sc, 0x14, 0x020e);
-                MP_WritePhyUshort(sc, 0x14, 0x4b02);
-                MP_WritePhyUshort(sc, 0x14, 0x0f91);
-                MP_WritePhyUshort(sc, 0x14, 0xef96);
-                MP_WritePhyUshort(sc, 0x14, 0xfefd);
-                MP_WritePhyUshort(sc, 0x14, 0xfc04);
-                MP_WritePhyUshort(sc, 0x14, 0xf8f9);
-                MP_WritePhyUshort(sc, 0x14, 0xfaef);
-                MP_WritePhyUshort(sc, 0x14, 0x69e0);
-                MP_WritePhyUshort(sc, 0x14, 0x8012);
-                MP_WritePhyUshort(sc, 0x14, 0xad27);
-                MP_WritePhyUshort(sc, 0x14, 0x33bf);
-                MP_WritePhyUshort(sc, 0x14, 0x4250);
-                MP_WritePhyUshort(sc, 0x14, 0x0241);
-                MP_WritePhyUshort(sc, 0x14, 0x48ac);
-                MP_WritePhyUshort(sc, 0x14, 0x2809);
-                MP_WritePhyUshort(sc, 0x14, 0xbf42);
-                MP_WritePhyUshort(sc, 0x14, 0x5302);
-                MP_WritePhyUshort(sc, 0x14, 0x4148);
-                MP_WritePhyUshort(sc, 0x14, 0xad28);
-                MP_WritePhyUshort(sc, 0x14, 0x21bf);
-                MP_WritePhyUshort(sc, 0x14, 0x43eb);
-                MP_WritePhyUshort(sc, 0x14, 0x0241);
-                MP_WritePhyUshort(sc, 0x14, 0x48e3);
-                MP_WritePhyUshort(sc, 0x14, 0x87ff);
-                MP_WritePhyUshort(sc, 0x14, 0xd200);
-                MP_WritePhyUshort(sc, 0x14, 0x1b45);
-                MP_WritePhyUshort(sc, 0x14, 0xac27);
-                MP_WritePhyUshort(sc, 0x14, 0x11e1);
-                MP_WritePhyUshort(sc, 0x14, 0x87fe);
-                MP_WritePhyUshort(sc, 0x14, 0xbf87);
-                MP_WritePhyUshort(sc, 0x14, 0x6702);
-                MP_WritePhyUshort(sc, 0x14, 0x410a);
-                MP_WritePhyUshort(sc, 0x14, 0x0d11);
-                MP_WritePhyUshort(sc, 0x14, 0xbf87);
-                MP_WritePhyUshort(sc, 0x14, 0x6a02);
-                MP_WritePhyUshort(sc, 0x14, 0x410a);
-                MP_WritePhyUshort(sc, 0x14, 0xef96);
-                MP_WritePhyUshort(sc, 0x14, 0xfefd);
-                MP_WritePhyUshort(sc, 0x14, 0xfc04);
-                MP_WritePhyUshort(sc, 0x14, 0xf8fa);
-                MP_WritePhyUshort(sc, 0x14, 0xef69);
-                MP_WritePhyUshort(sc, 0x14, 0xd100);
-                MP_WritePhyUshort(sc, 0x14, 0xbf87);
-                MP_WritePhyUshort(sc, 0x14, 0x6702);
-                MP_WritePhyUshort(sc, 0x14, 0x410a);
-                MP_WritePhyUshort(sc, 0x14, 0xbf87);
-                MP_WritePhyUshort(sc, 0x14, 0x6a02);
-                MP_WritePhyUshort(sc, 0x14, 0x410a);
-                MP_WritePhyUshort(sc, 0x14, 0xef96);
-                MP_WritePhyUshort(sc, 0x14, 0xfefc);
-                MP_WritePhyUshort(sc, 0x14, 0x04ee);
-                MP_WritePhyUshort(sc, 0x14, 0x87ff);
-                MP_WritePhyUshort(sc, 0x14, 0x46ee);
-                MP_WritePhyUshort(sc, 0x14, 0x87fe);
-                MP_WritePhyUshort(sc, 0x14, 0x0104);
-                MP_WritePhyUshort(sc, 0x14, 0xf8fa);
-                MP_WritePhyUshort(sc, 0x14, 0xef69);
-                MP_WritePhyUshort(sc, 0x14, 0xe082);
-                MP_WritePhyUshort(sc, 0x14, 0x46a0);
-                MP_WritePhyUshort(sc, 0x14, 0x0005);
-                MP_WritePhyUshort(sc, 0x14, 0x0285);
-                MP_WritePhyUshort(sc, 0x14, 0xecae);
-                MP_WritePhyUshort(sc, 0x14, 0x0ea0);
-                MP_WritePhyUshort(sc, 0x14, 0x0105);
-                MP_WritePhyUshort(sc, 0x14, 0x021a);
-                MP_WritePhyUshort(sc, 0x14, 0x68ae);
-                MP_WritePhyUshort(sc, 0x14, 0x06a0);
-                MP_WritePhyUshort(sc, 0x14, 0x0203);
-                MP_WritePhyUshort(sc, 0x14, 0x021a);
-                MP_WritePhyUshort(sc, 0x14, 0xf4ef);
-                MP_WritePhyUshort(sc, 0x14, 0x96fe);
-                MP_WritePhyUshort(sc, 0x14, 0xfc04);
-                MP_WritePhyUshort(sc, 0x14, 0xf8f9);
-                MP_WritePhyUshort(sc, 0x14, 0xfaef);
-                MP_WritePhyUshort(sc, 0x14, 0x69e0);
-                MP_WritePhyUshort(sc, 0x14, 0x822e);
-                MP_WritePhyUshort(sc, 0x14, 0xf621);
-                MP_WritePhyUshort(sc, 0x14, 0xe482);
-                MP_WritePhyUshort(sc, 0x14, 0x2ee0);
-                MP_WritePhyUshort(sc, 0x14, 0x8010);
-                MP_WritePhyUshort(sc, 0x14, 0xac22);
-                MP_WritePhyUshort(sc, 0x14, 0x02ae);
-                MP_WritePhyUshort(sc, 0x14, 0x76e0);
-                MP_WritePhyUshort(sc, 0x14, 0x822c);
-                MP_WritePhyUshort(sc, 0x14, 0xf721);
-                MP_WritePhyUshort(sc, 0x14, 0xe482);
-                MP_WritePhyUshort(sc, 0x14, 0x2cbf);
-                MP_WritePhyUshort(sc, 0x14, 0x41a5);
-                MP_WritePhyUshort(sc, 0x14, 0x0241);
-                MP_WritePhyUshort(sc, 0x14, 0x48ef);
-                MP_WritePhyUshort(sc, 0x14, 0x21bf);
-                MP_WritePhyUshort(sc, 0x14, 0x41a8);
-                MP_WritePhyUshort(sc, 0x14, 0x0241);
-                MP_WritePhyUshort(sc, 0x14, 0x480c);
-                MP_WritePhyUshort(sc, 0x14, 0x111e);
-                MP_WritePhyUshort(sc, 0x14, 0x21bf);
-                MP_WritePhyUshort(sc, 0x14, 0x41ab);
-                MP_WritePhyUshort(sc, 0x14, 0x0241);
-                MP_WritePhyUshort(sc, 0x14, 0x480c);
-                MP_WritePhyUshort(sc, 0x14, 0x121e);
-                MP_WritePhyUshort(sc, 0x14, 0x21e6);
-                MP_WritePhyUshort(sc, 0x14, 0x8248);
-                MP_WritePhyUshort(sc, 0x14, 0xa200);
-                MP_WritePhyUshort(sc, 0x14, 0x0ae1);
-                MP_WritePhyUshort(sc, 0x14, 0x822c);
-                MP_WritePhyUshort(sc, 0x14, 0xf629);
-                MP_WritePhyUshort(sc, 0x14, 0xe582);
-                MP_WritePhyUshort(sc, 0x14, 0x2cae);
-                MP_WritePhyUshort(sc, 0x14, 0x42e0);
-                MP_WritePhyUshort(sc, 0x14, 0x8249);
-                MP_WritePhyUshort(sc, 0x14, 0xf721);
-                MP_WritePhyUshort(sc, 0x14, 0xe482);
-                MP_WritePhyUshort(sc, 0x14, 0x4902);
-                MP_WritePhyUshort(sc, 0x14, 0x4520);
-                MP_WritePhyUshort(sc, 0x14, 0xbf41);
-                MP_WritePhyUshort(sc, 0x14, 0xb702);
-                MP_WritePhyUshort(sc, 0x14, 0x4148);
-                MP_WritePhyUshort(sc, 0x14, 0xef21);
-                MP_WritePhyUshort(sc, 0x14, 0xbf41);
-                MP_WritePhyUshort(sc, 0x14, 0xae02);
-                MP_WritePhyUshort(sc, 0x14, 0x4148);
-                MP_WritePhyUshort(sc, 0x14, 0x0c12);
-                MP_WritePhyUshort(sc, 0x14, 0x1e21);
-                MP_WritePhyUshort(sc, 0x14, 0xbf41);
-                MP_WritePhyUshort(sc, 0x14, 0xb102);
-                MP_WritePhyUshort(sc, 0x14, 0x4148);
-                MP_WritePhyUshort(sc, 0x14, 0x0c13);
-                MP_WritePhyUshort(sc, 0x14, 0x1e21);
-                MP_WritePhyUshort(sc, 0x14, 0xbf41);
-                MP_WritePhyUshort(sc, 0x14, 0xba02);
-                MP_WritePhyUshort(sc, 0x14, 0x4148);
-                MP_WritePhyUshort(sc, 0x14, 0x0c14);
-                MP_WritePhyUshort(sc, 0x14, 0x1e21);
-                MP_WritePhyUshort(sc, 0x14, 0xbf43);
-                MP_WritePhyUshort(sc, 0x14, 0x4602);
-                MP_WritePhyUshort(sc, 0x14, 0x4148);
-                MP_WritePhyUshort(sc, 0x14, 0x0c16);
-                MP_WritePhyUshort(sc, 0x14, 0x1e21);
-                MP_WritePhyUshort(sc, 0x14, 0xe682);
-                MP_WritePhyUshort(sc, 0x14, 0x47ee);
-                MP_WritePhyUshort(sc, 0x14, 0x8246);
-                MP_WritePhyUshort(sc, 0x14, 0x01ef);
-                MP_WritePhyUshort(sc, 0x14, 0x96fe);
-                MP_WritePhyUshort(sc, 0x14, 0xfdfc);
-                MP_WritePhyUshort(sc, 0x14, 0x04f8);
-                MP_WritePhyUshort(sc, 0x14, 0xfaef);
-                MP_WritePhyUshort(sc, 0x14, 0x69e0);
-                MP_WritePhyUshort(sc, 0x14, 0x824b);
-                MP_WritePhyUshort(sc, 0x14, 0xa000);
-                MP_WritePhyUshort(sc, 0x14, 0x0502);
-                MP_WritePhyUshort(sc, 0x14, 0x8697);
-                MP_WritePhyUshort(sc, 0x14, 0xae06);
-                MP_WritePhyUshort(sc, 0x14, 0xa001);
-                MP_WritePhyUshort(sc, 0x14, 0x0302);
-                MP_WritePhyUshort(sc, 0x14, 0x1937);
-                MP_WritePhyUshort(sc, 0x14, 0xef96);
-                MP_WritePhyUshort(sc, 0x14, 0xfefc);
-                MP_WritePhyUshort(sc, 0x14, 0x04f8);
-                MP_WritePhyUshort(sc, 0x14, 0xfaef);
-                MP_WritePhyUshort(sc, 0x14, 0x69e0);
-                MP_WritePhyUshort(sc, 0x14, 0x822e);
-                MP_WritePhyUshort(sc, 0x14, 0xf620);
-                MP_WritePhyUshort(sc, 0x14, 0xe482);
-                MP_WritePhyUshort(sc, 0x14, 0x2ee0);
-                MP_WritePhyUshort(sc, 0x14, 0x8010);
-                MP_WritePhyUshort(sc, 0x14, 0xac21);
-                MP_WritePhyUshort(sc, 0x14, 0x02ae);
-                MP_WritePhyUshort(sc, 0x14, 0x54e0);
-                MP_WritePhyUshort(sc, 0x14, 0x822c);
-                MP_WritePhyUshort(sc, 0x14, 0xf720);
-                MP_WritePhyUshort(sc, 0x14, 0xe482);
-                MP_WritePhyUshort(sc, 0x14, 0x2cbf);
-                MP_WritePhyUshort(sc, 0x14, 0x4175);
-                MP_WritePhyUshort(sc, 0x14, 0x0241);
-                MP_WritePhyUshort(sc, 0x14, 0x48ac);
-                MP_WritePhyUshort(sc, 0x14, 0x2822);
-                MP_WritePhyUshort(sc, 0x14, 0xbf41);
-                MP_WritePhyUshort(sc, 0x14, 0x9f02);
-                MP_WritePhyUshort(sc, 0x14, 0x4148);
-                MP_WritePhyUshort(sc, 0x14, 0xe582);
-                MP_WritePhyUshort(sc, 0x14, 0x4cac);
-                MP_WritePhyUshort(sc, 0x14, 0x2820);
-                MP_WritePhyUshort(sc, 0x14, 0xd103);
-                MP_WritePhyUshort(sc, 0x14, 0xbf41);
-                MP_WritePhyUshort(sc, 0x14, 0x9902);
-                MP_WritePhyUshort(sc, 0x14, 0x410a);
-                MP_WritePhyUshort(sc, 0x14, 0xee82);
-                MP_WritePhyUshort(sc, 0x14, 0x4b00);
-                MP_WritePhyUshort(sc, 0x14, 0xe182);
-                MP_WritePhyUshort(sc, 0x14, 0x2cf6);
-                MP_WritePhyUshort(sc, 0x14, 0x28e5);
-                MP_WritePhyUshort(sc, 0x14, 0x822c);
-                MP_WritePhyUshort(sc, 0x14, 0xae21);
-                MP_WritePhyUshort(sc, 0x14, 0xd104);
-                MP_WritePhyUshort(sc, 0x14, 0xbf41);
-                MP_WritePhyUshort(sc, 0x14, 0x9902);
-                MP_WritePhyUshort(sc, 0x14, 0x410a);
-                MP_WritePhyUshort(sc, 0x14, 0xae08);
-                MP_WritePhyUshort(sc, 0x14, 0xd105);
-                MP_WritePhyUshort(sc, 0x14, 0xbf41);
-                MP_WritePhyUshort(sc, 0x14, 0x9902);
-                MP_WritePhyUshort(sc, 0x14, 0x410a);
-                MP_WritePhyUshort(sc, 0x14, 0xe082);
-                MP_WritePhyUshort(sc, 0x14, 0x49f7);
-                MP_WritePhyUshort(sc, 0x14, 0x20e4);
-                MP_WritePhyUshort(sc, 0x14, 0x8249);
-                MP_WritePhyUshort(sc, 0x14, 0x0245);
-                MP_WritePhyUshort(sc, 0x14, 0x20ee);
-                MP_WritePhyUshort(sc, 0x14, 0x824b);
-                MP_WritePhyUshort(sc, 0x14, 0x01ef);
-                MP_WritePhyUshort(sc, 0x14, 0x96fe);
-                MP_WritePhyUshort(sc, 0x14, 0xfc04);
-                MP_WritePhyUshort(sc, 0x14, 0xf8f9);
-                MP_WritePhyUshort(sc, 0x14, 0xface);
-                MP_WritePhyUshort(sc, 0x14, 0xfaef);
-                MP_WritePhyUshort(sc, 0x14, 0x69fb);
-                MP_WritePhyUshort(sc, 0x14, 0xbf87);
-                MP_WritePhyUshort(sc, 0x14, 0x2fd7);
-                MP_WritePhyUshort(sc, 0x14, 0x0020);
-                MP_WritePhyUshort(sc, 0x14, 0xd819);
-                MP_WritePhyUshort(sc, 0x14, 0xd919);
-                MP_WritePhyUshort(sc, 0x14, 0xda19);
-                MP_WritePhyUshort(sc, 0x14, 0xdb19);
-                MP_WritePhyUshort(sc, 0x14, 0x07ef);
-                MP_WritePhyUshort(sc, 0x14, 0x9502);
-                MP_WritePhyUshort(sc, 0x14, 0x410a);
-                MP_WritePhyUshort(sc, 0x14, 0x073f);
-                MP_WritePhyUshort(sc, 0x14, 0x0004);
-                MP_WritePhyUshort(sc, 0x14, 0x9fec);
-                MP_WritePhyUshort(sc, 0x14, 0xffef);
-                MP_WritePhyUshort(sc, 0x14, 0x96fe);
-                MP_WritePhyUshort(sc, 0x14, 0xc6fe);
-                MP_WritePhyUshort(sc, 0x14, 0xfdfc);
-                MP_WritePhyUshort(sc, 0x14, 0x0400);
-                MP_WritePhyUshort(sc, 0x14, 0x0144);
+                MP_WritePhyUshort(sc, 0x1f, 0x0A43);
+                MP_WritePhyUshort(sc, 0x13, 0x8146);
                 MP_WritePhyUshort(sc, 0x14, 0x0000);
-                MP_WritePhyUshort(sc, 0x14, 0x0343);
-                MP_WritePhyUshort(sc, 0x14, 0xee00);
-                MP_WritePhyUshort(sc, 0x14, 0x0087);
-                MP_WritePhyUshort(sc, 0x14, 0x5b00);
-                MP_WritePhyUshort(sc, 0x14, 0x0141);
-                MP_WritePhyUshort(sc, 0x14, 0xe100);
-                MP_WritePhyUshort(sc, 0x14, 0x0387);
-                MP_WritePhyUshort(sc, 0x14, 0x5e00);
-                MP_WritePhyUshort(sc, 0x14, 0x0987);
-                MP_WritePhyUshort(sc, 0x14, 0x6100);
-                MP_WritePhyUshort(sc, 0x14, 0x0987);
-                MP_WritePhyUshort(sc, 0x14, 0x6400);
-                MP_WritePhyUshort(sc, 0x14, 0x0087);
-                MP_WritePhyUshort(sc, 0x14, 0x6da4);
-                MP_WritePhyUshort(sc, 0x14, 0x00b8);
-                MP_WritePhyUshort(sc, 0x14, 0x20c4);
-                MP_WritePhyUshort(sc, 0x14, 0x1600);
-                MP_WritePhyUshort(sc, 0x14, 0x000f);
-                MP_WritePhyUshort(sc, 0x14, 0xf800);
-                MP_WritePhyUshort(sc, 0x14, 0x7000);
-                MP_WritePhyUshort(sc, 0x14, 0xb82e);
-                MP_WritePhyUshort(sc, 0x14, 0x98a5);
-                MP_WritePhyUshort(sc, 0x14, 0x8ab6);
-                MP_WritePhyUshort(sc, 0x14, 0xa83e);
-                MP_WritePhyUshort(sc, 0x14, 0x50a8);
-                MP_WritePhyUshort(sc, 0x14, 0x3e33);
-                MP_WritePhyUshort(sc, 0x14, 0xbcc6);
-                MP_WritePhyUshort(sc, 0x14, 0x22bc);
-                MP_WritePhyUshort(sc, 0x14, 0xc6aa);
-                MP_WritePhyUshort(sc, 0x14, 0xa442);
-                MP_WritePhyUshort(sc, 0x14, 0xffc4);
-                MP_WritePhyUshort(sc, 0x14, 0x0800);
-                MP_WritePhyUshort(sc, 0x14, 0xc416);
-                MP_WritePhyUshort(sc, 0x14, 0xa8bc);
-                MP_WritePhyUshort(sc, 0x14, 0xc000);
-                MP_WritePhyUshort(sc, 0x13, 0xb818);
-                MP_WritePhyUshort(sc, 0x14, 0x02e3);
-                MP_WritePhyUshort(sc, 0x13, 0xb81a);
-                MP_WritePhyUshort(sc, 0x14, 0x17ff);
-                MP_WritePhyUshort(sc, 0x13, 0xb81e);
-                MP_WritePhyUshort(sc, 0x14, 0x3b1c);
-                MP_WritePhyUshort(sc, 0x13, 0xb820);
-                MP_WritePhyUshort(sc, 0x14, 0x021b);
-                MP_WritePhyUshort(sc, 0x1f, 0x0000);
 
-                MP_WritePhyUshort(sc,0x1F, 0x0A43);
-                MP_WritePhyUshort(sc,0x13, 0x0000);
-                MP_WritePhyUshort(sc,0x14, 0x0000);
-                MP_WritePhyUshort(sc,0x1f, 0x0B82);
-                PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
-                PhyRegValue &= ~(BIT_0);
-                MP_WritePhyUshort(sc,0x17, PhyRegValue);
-                MP_WritePhyUshort(sc,0x1f, 0x0A43);
-                MP_WritePhyUshort(sc,0x13, 0x8146);
-                MP_WritePhyUshort(sc,0x14, 0x0000);
-
-                MP_WritePhyUshort(sc,0x1f, 0x0B82);
+                MP_WritePhyUshort(sc, 0x1f, 0x0B82);
                 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
                 PhyRegValue &= ~(BIT_4);
-                MP_WritePhyUshort(sc,0x10, PhyRegValue);
+                MP_WritePhyUshort(sc, 0x10, PhyRegValue);
 
                 MP_WritePhyUshort(sc, 0x1F, 0x0A44);
                 SetEthPhyBit(sc, 0x11, (BIT_3 | BIT_2));
@@ -21238,7 +24979,7 @@ static void re_hw_phy_config(struct re_softc *sc)
                 MP_WritePhyUshort(sc, 0x1F, 0x0C42);
                 ClearAndSetEthPhyBit(sc,
                                      0x11,
-                                     BIT_13 ,
+                                     BIT_13,
                                      BIT_14
                                     );
                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
@@ -21282,7 +25023,7 @@ static void re_hw_phy_config(struct re_softc *sc)
                 MP_WritePhyUshort(sc, 0x1F, 0x0C42);
                 ClearAndSetEthPhyBit(sc,
                                      0x11,
-                                     BIT_13 ,
+                                     BIT_13,
                                      BIT_14
                                     );
                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
@@ -21291,49 +25032,49 @@ static void re_hw_phy_config(struct re_softc *sc)
                 MP_WritePhyUshort(sc, 0x13, 0x80F3);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x8B00
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x80F0);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x3A00
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x80EF);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x0500
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x80F6);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x6E00
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x80EC);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x6800
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x80ED);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x7C00
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x80F2);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0xF400
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x80F4);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x8500
                                     );
 
@@ -21341,49 +25082,49 @@ static void re_hw_phy_config(struct re_softc *sc)
                 MP_WritePhyUshort(sc, 0x13, 0x8110);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0xA800
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x810F);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x1D00
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x8111);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0xF500
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x8113);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x6100
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x8115);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x9200
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x810E);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x0400
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x810C);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x7C00
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x810B);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x5A00
                                     );
 
@@ -21391,31 +25132,31 @@ static void re_hw_phy_config(struct re_softc *sc)
                 MP_WritePhyUshort(sc, 0x13, 0x80D1);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0xFF00
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x80CD);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x9E00
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x80D3);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x0E00
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x80D5);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0xCA00
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x80D7);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x8400
                                     );
 
@@ -21572,103 +25313,29 @@ static void re_hw_phy_config(struct re_softc *sc)
                 MP_WritePhyUshort(sc, 0x0C, PhyRegValue);
                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
         } else if (sc->re_type == MACFG_68) {
-                MP_WritePhyUshort(sc,0x1f, 0x0B82);
-                PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
-                PhyRegValue |= BIT_4;
-                MP_WritePhyUshort(sc,0x10, PhyRegValue);
-
-                MP_WritePhyUshort(sc,0x1f, 0x0B80);
-                WaitCnt = 0;
-                do {
-                        PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
-                        PhyRegValue &= 0x0040;
-                        DELAY(50);
-                        DELAY(50);
-                        WaitCnt++;
-                } while(PhyRegValue != 0x0040 && WaitCnt <1000);
-
-                MP_WritePhyUshort(sc,0x1f, 0x0A43);
-                MP_WritePhyUshort(sc,0x13, 0x8028);
-                MP_WritePhyUshort(sc,0x14, 0x6200);
-                MP_WritePhyUshort(sc,0x13, 0xB82E);
-                MP_WritePhyUshort(sc,0x14, 0x0001);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0A43);
-                MP_WritePhyUshort(sc, 0x13, 0xB820);
-                MP_WritePhyUshort(sc, 0x14, 0x0290);
-                MP_WritePhyUshort(sc, 0x13, 0xA012);
-                MP_WritePhyUshort(sc, 0x14, 0x0000);
-                MP_WritePhyUshort(sc, 0x13, 0xA014);
-                MP_WritePhyUshort(sc, 0x14, 0x2c04);
-                MP_WritePhyUshort(sc, 0x14, 0x2c10);
-                MP_WritePhyUshort(sc, 0x14, 0x2c10);
-                MP_WritePhyUshort(sc, 0x14, 0x2c10);
-                MP_WritePhyUshort(sc, 0x14, 0xa210);
-                MP_WritePhyUshort(sc, 0x14, 0xa101);
-                MP_WritePhyUshort(sc, 0x14, 0xce10);
-                MP_WritePhyUshort(sc, 0x14, 0xe070);
-                MP_WritePhyUshort(sc, 0x14, 0x0f40);
-                MP_WritePhyUshort(sc, 0x14, 0xaf01);
-                MP_WritePhyUshort(sc, 0x14, 0x8f01);
-                MP_WritePhyUshort(sc, 0x14, 0x183e);
-                MP_WritePhyUshort(sc, 0x14, 0x8e10);
-                MP_WritePhyUshort(sc, 0x14, 0x8101);
-                MP_WritePhyUshort(sc, 0x14, 0x8210);
-                MP_WritePhyUshort(sc, 0x14, 0x28da);
-                MP_WritePhyUshort(sc, 0x13, 0xA01A);
-                MP_WritePhyUshort(sc, 0x14, 0x0000);
-                MP_WritePhyUshort(sc, 0x13, 0xA006);
-                MP_WritePhyUshort(sc, 0x14, 0x0017);
-                MP_WritePhyUshort(sc, 0x13, 0xA004);
-                MP_WritePhyUshort(sc, 0x14, 0x0015);
-                MP_WritePhyUshort(sc, 0x13, 0xA002);
-                MP_WritePhyUshort(sc, 0x14, 0x0013);
-                MP_WritePhyUshort(sc, 0x13, 0xA000);
-                MP_WritePhyUshort(sc, 0x14, 0x18d1);
-                MP_WritePhyUshort(sc, 0x13, 0xB820);
-                MP_WritePhyUshort(sc, 0x14, 0x0210);
-
-                MP_WritePhyUshort(sc,0x1F, 0x0A43);
-                MP_WritePhyUshort(sc,0x13, 0x0000);
-                MP_WritePhyUshort(sc,0x14, 0x0000);
-                MP_WritePhyUshort(sc,0x1f, 0x0B82);
-                PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
-                PhyRegValue &= ~(BIT_0);
-                MP_WritePhyUshort(sc,0x17, PhyRegValue);
-                MP_WritePhyUshort(sc,0x1f, 0x0A43);
-                MP_WritePhyUshort(sc,0x13, 0x8028);
-                MP_WritePhyUshort(sc,0x14, 0x0000);
-
-                MP_WritePhyUshort(sc,0x1f, 0x0B82);
-                PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
-                PhyRegValue &= ~(BIT_4);
-                MP_WritePhyUshort(sc,0x10, PhyRegValue);
-
-
-
                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
                 MP_WritePhyUshort(sc, 0x13, 0x809b);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xF800 ,
+                                     0xF800,
                                      0x8000
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x80A2);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x8000
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x80A4);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x8500
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x809C);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0xbd00
                                     );
                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
@@ -21677,19 +25344,19 @@ static void re_hw_phy_config(struct re_softc *sc)
                 MP_WritePhyUshort(sc, 0x13, 0x80AD);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xF800 ,
+                                     0xF800,
                                      0x7000
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x80B4);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x5000
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x80AC);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x4000
                                     );
                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
@@ -21698,19 +25365,19 @@ static void re_hw_phy_config(struct re_softc *sc)
                 MP_WritePhyUshort(sc, 0x13, 0x808E);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x1200
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x8090);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0xE500
                                     );
                 MP_WritePhyUshort(sc, 0x13, 0x8092);
                 ClearAndSetEthPhyBit(sc,
                                      0x14,
-                                     0xFF00 ,
+                                     0xFF00,
                                      0x9F00
                                     );
                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
@@ -21777,7 +25444,7 @@ static void re_hw_phy_config(struct re_softc *sc)
                 MP_WritePhyUshort(sc, 0x1F, 0x0BCA);
                 ClearAndSetEthPhyBit(sc,
                                      0x17,
-                                     (BIT_13 | BIT_12) ,
+                                     (BIT_13 | BIT_12),
                                      BIT_14
                                     );
                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
@@ -21811,78 +25478,18 @@ static void re_hw_phy_config(struct re_softc *sc)
                 }
 
                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
+                MP_WritePhyUshort(sc, 0x13, 0x8045);
+                MP_WritePhyUshort(sc, 0x14, 0x2444);
+                MP_WritePhyUshort(sc, 0x13, 0x804d);
+                MP_WritePhyUshort(sc, 0x14, 0x2444);
+                MP_WritePhyUshort(sc, 0x13, 0x805d);
+                MP_WritePhyUshort(sc, 0x14, 0x2444);
                 MP_WritePhyUshort(sc, 0x13, 0x8011);
-                ClearEthPhyBit(sc, 0x14, BIT_15);
+                SetEthPhyBit(sc, 0x14, BIT_15);
                 MP_WritePhyUshort(sc, 0x1F, 0x0A40);
                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
                 MP_WritePhyUshort(sc, 0x00, 0x9200);
         } else if (sc->re_type == MACFG_69) {
-                MP_WritePhyUshort(sc,0x1f, 0x0B82);
-                PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
-                PhyRegValue |= BIT_4;
-                MP_WritePhyUshort(sc,0x10, PhyRegValue);
-
-                MP_WritePhyUshort(sc,0x1f, 0x0B80);
-                WaitCnt = 0;
-                do {
-                        PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
-                        PhyRegValue &= 0x0040;
-                        DELAY(50);
-                        DELAY(50);
-                        WaitCnt++;
-                } while(PhyRegValue != 0x0040 && WaitCnt <1000);
-
-                MP_WritePhyUshort(sc,0x1f, 0x0A43);
-                MP_WritePhyUshort(sc,0x13, 0x8028);
-                MP_WritePhyUshort(sc,0x14, 0x6201);
-                MP_WritePhyUshort(sc,0x13, 0xB82E);
-                MP_WritePhyUshort(sc,0x14, 0x0001);
-
-                MP_WritePhyUshort(sc, 0x1F, 0x0A43);
-                MP_WritePhyUshort(sc, 0x13, 0xB820);
-                MP_WritePhyUshort(sc, 0x14, 0x0290);
-                MP_WritePhyUshort(sc, 0x13, 0xA012);
-                MP_WritePhyUshort(sc, 0x14, 0x0000);
-                MP_WritePhyUshort(sc, 0x13, 0xA014);
-                MP_WritePhyUshort(sc, 0x14, 0x2c04);
-                MP_WritePhyUshort(sc, 0x14, 0x2c09);
-                MP_WritePhyUshort(sc, 0x14, 0x2c09);
-                MP_WritePhyUshort(sc, 0x14, 0x2c09);
-                MP_WritePhyUshort(sc, 0x14, 0xad01);
-                MP_WritePhyUshort(sc, 0x14, 0xad01);
-                MP_WritePhyUshort(sc, 0x14, 0xad01);
-                MP_WritePhyUshort(sc, 0x14, 0xad01);
-                MP_WritePhyUshort(sc, 0x14, 0x236c);
-                MP_WritePhyUshort(sc, 0x13, 0xA01A);
-                MP_WritePhyUshort(sc, 0x14, 0x0000);
-                MP_WritePhyUshort(sc, 0x13, 0xA006);
-                MP_WritePhyUshort(sc, 0x14, 0x0fff);
-                MP_WritePhyUshort(sc, 0x13, 0xA004);
-                MP_WritePhyUshort(sc, 0x14, 0x0fff);
-                MP_WritePhyUshort(sc, 0x13, 0xA002);
-                MP_WritePhyUshort(sc, 0x14, 0x0fff);
-                MP_WritePhyUshort(sc, 0x13, 0xA000);
-                MP_WritePhyUshort(sc, 0x14, 0x136b);
-                MP_WritePhyUshort(sc, 0x13, 0xB820);
-                MP_WritePhyUshort(sc, 0x14, 0x0210);
-
-                MP_WritePhyUshort(sc,0x1F, 0x0A43);
-                MP_WritePhyUshort(sc,0x13, 0x0000);
-                MP_WritePhyUshort(sc,0x14, 0x0000);
-                MP_WritePhyUshort(sc,0x1f, 0x0B82);
-                PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
-                PhyRegValue &= ~(BIT_0);
-                MP_WritePhyUshort(sc,0x17, PhyRegValue);
-                MP_WritePhyUshort(sc,0x1f, 0x0A43);
-                MP_WritePhyUshort(sc,0x13, 0x8028);
-                MP_WritePhyUshort(sc,0x14, 0x0000);
-
-                MP_WritePhyUshort(sc,0x1f, 0x0B82);
-                PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
-                PhyRegValue &= ~(BIT_4);
-                MP_WritePhyUshort(sc,0x10, PhyRegValue);
-
-
                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
                 MP_WritePhyUshort(sc, 0x13, 0x808A);
                 ClearAndSetEthPhyBit(sc,
@@ -21938,8 +25545,179 @@ static void re_hw_phy_config(struct re_softc *sc)
                 }
 
                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
+                MP_WritePhyUshort(sc, 0x13, 0x8045);
+                MP_WritePhyUshort(sc, 0x14, 0x2444);
+                MP_WritePhyUshort(sc, 0x13, 0x804d);
+                MP_WritePhyUshort(sc, 0x14, 0x2444);
+                MP_WritePhyUshort(sc, 0x13, 0x805d);
+                MP_WritePhyUshort(sc, 0x14, 0x2444);
+                MP_WritePhyUshort(sc, 0x13, 0x8011);
+                SetEthPhyBit(sc, 0x14, BIT_15);
+                MP_WritePhyUshort(sc, 0x1F, 0x0A40);
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+                MP_WritePhyUshort(sc, 0x00, 0x9200);
+        }  else if (sc->re_type == MACFG_70 || sc->re_type == MACFG_71) {
+                MP_WritePhyUshort(sc, 0x1F, 0x0A43);
+                MP_WritePhyUshort(sc, 0x13, 0x808E);
+                ClearAndSetEthPhyBit( sc,
+                                      0x14,
+                                      0xFF00,
+                                      0x4000
+                                    );
+                MP_WritePhyUshort(sc, 0x13, 0x8090);
+                ClearAndSetEthPhyBit( sc,
+                                      0x14,
+                                      0xFF00,
+                                      0xCC00
+                                    );
+                MP_WritePhyUshort(sc, 0x13, 0x8092);
+                ClearAndSetEthPhyBit( sc,
+                                      0x14,
+                                      0xFF00,
+                                      0xB000
+                                    );
+                MP_WritePhyUshort(sc, 0x13, 0x8088);
+                ClearAndSetEthPhyBit( sc,
+                                      0x14,
+                                      0xFF00,
+                                      0x8000
+                                    );
+                MP_WritePhyUshort(sc, 0x13, 0x808B);
+                ClearAndSetEthPhyBit( sc,
+                                      0x14,
+                                      0x3F00,
+                                      0x0B00
+                                    );
+                MP_WritePhyUshort(sc, 0x13, 0x808D);
+                ClearAndSetEthPhyBit( sc,
+                                      0x14,
+                                      0x1F00,
+                                      0x0600
+                                    );
+                MP_WritePhyUshort(sc, 0x13, 0x808C);
+                ClearAndSetEthPhyBit( sc,
+                                      0x14,
+                                      0xFF00,
+                                      0xB000
+                                    );
+
+                MP_WritePhyUshort(sc, 0x13, 0x80A0);
+                ClearAndSetEthPhyBit( sc,
+                                      0x14,
+                                      0xFF00,
+                                      0x2000
+                                    );
+                MP_WritePhyUshort(sc, 0x13, 0x80A2);
+                ClearAndSetEthPhyBit( sc,
+                                      0x14,
+                                      0xFF00,
+                                      0x5000
+                                    );
+                MP_WritePhyUshort(sc, 0x13, 0x809B);
+                ClearAndSetEthPhyBit( sc,
+                                      0x14,
+                                      0xF800,
+                                      0xB000
+                                    );
+                MP_WritePhyUshort(sc, 0x13, 0x809A);
+                ClearAndSetEthPhyBit( sc,
+                                      0x14,
+                                      0xFF00,
+                                      0x4B00
+                                    );
+                MP_WritePhyUshort(sc, 0x13, 0x809D);
+                ClearAndSetEthPhyBit( sc,
+                                      0x14,
+                                      0x3F00,
+                                      0x0800
+                                    );
+                MP_WritePhyUshort(sc, 0x13, 0x80A1);
+                ClearAndSetEthPhyBit( sc,
+                                      0x14,
+                                      0xFF00,
+                                      0x7000
+                                    );
+                MP_WritePhyUshort(sc, 0x13, 0x809F);
+                ClearAndSetEthPhyBit( sc,
+                                      0x14,
+                                      0x1F00,
+                                      0x0300
+                                    );
+                MP_WritePhyUshort(sc, 0x13, 0x809E);
+                ClearAndSetEthPhyBit( sc,
+                                      0x14,
+                                      0xFF00,
+                                      0x8800
+                                    );
+
+                MP_WritePhyUshort(sc, 0x13, 0x80B2);
+                ClearAndSetEthPhyBit( sc,
+                                      0x14,
+                                      0xFF00,
+                                      0x2200
+                                    );
+                MP_WritePhyUshort(sc, 0x13, 0x80AD);
+                ClearAndSetEthPhyBit( sc,
+                                      0x14,
+                                      0xF800,
+                                      0x9800
+                                    );
+                MP_WritePhyUshort(sc, 0x13, 0x80AF);
+                ClearAndSetEthPhyBit( sc,
+                                      0x14,
+                                      0x3F00,
+                                      0x0800
+                                    );
+                MP_WritePhyUshort(sc, 0x13, 0x80B3);
+                ClearAndSetEthPhyBit( sc,
+                                      0x14,
+                                      0xFF00,
+                                      0x6F00
+                                    );
+                MP_WritePhyUshort(sc, 0x13, 0x80B1);
+                ClearAndSetEthPhyBit( sc,
+                                      0x14,
+                                      0x1F00,
+                                      0x0300
+                                    );
+                MP_WritePhyUshort(sc, 0x13, 0x80B0);
+                ClearAndSetEthPhyBit( sc,
+                                      0x14,
+                                      0xFF00,
+                                      0x9300
+                                    );
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0A43);
+                MP_WritePhyUshort(sc, 0x13, 0x8011);
+                SetEthPhyBit(sc, 0x14, BIT_11);
+                MP_WritePhyUshort(sc, 0x1F, 0x0A42);
+                SetEthPhyBit(sc, 0x16, BIT_1);
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0A44);
+                SetEthPhyBit( sc, 0x11, BIT_11 );
+                MP_WritePhyUshort(sc, 0x1F, 0x0000);
+
+                if (phy_power_saving == 1) {
+                        MP_WritePhyUshort(sc, 0x1F, 0x0A43);
+                        SetEthPhyBit(sc, 0x10, BIT_2);
+                        MP_WritePhyUshort(sc, 0x1F, 0x0000);
+                } else {
+                        MP_WritePhyUshort(sc, 0x1F, 0x0A43);
+                        ClearEthPhyBit(sc, 0x10, BIT_2);
+                        MP_WritePhyUshort(sc, 0x1F, 0x0000);
+                        DELAY(20000);
+                }
+
+                MP_WritePhyUshort(sc, 0x1F, 0x0A43);
+                MP_WritePhyUshort(sc, 0x13, 0x8045);
+                MP_WritePhyUshort(sc, 0x14, 0x2444);
+                MP_WritePhyUshort(sc, 0x13, 0x804d);
+                MP_WritePhyUshort(sc, 0x14, 0x2444);
+                MP_WritePhyUshort(sc, 0x13, 0x805d);
+                MP_WritePhyUshort(sc, 0x14, 0x2444);
                 MP_WritePhyUshort(sc, 0x13, 0x8011);
-                ClearEthPhyBit(sc, 0x14, BIT_15);
+                SetEthPhyBit(sc, 0x14, BIT_15);
                 MP_WritePhyUshort(sc, 0x1F, 0x0A40);
                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
                 MP_WritePhyUshort(sc, 0x00, 0x9200);
@@ -21977,6 +25755,8 @@ static void re_hw_phy_config(struct re_softc *sc)
         case MACFG_67:
         case MACFG_68:
         case MACFG_69:
+        case MACFG_70:
+        case MACFG_71:
                 if (phy_mdix_mode == RE_ETH_PHY_FORCE_MDI) {
                         //Force MDI
                         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
@@ -22001,7 +25781,8 @@ static void re_hw_phy_config(struct re_softc *sc)
         if (phy_power_saving == 1) {
                 if (sc->re_type == MACFG_59 || sc->re_type == MACFG_60 ||
                     sc->re_type == MACFG_62 || sc->re_type == MACFG_67 ||
-                    sc->re_type == MACFG_68 || sc->re_type == MACFG_69) {
+                    sc->re_type == MACFG_68 || sc->re_type == MACFG_69 ||
+                    sc->re_type == MACFG_70 || sc->re_type == MACFG_71) {
                         MP_WritePhyOcpRegWord(sc, 0x0C41, 0x13, 0x0000);
                         MP_WritePhyOcpRegWord(sc, 0x0C41, 0x13, 0x0050);
                 }
@@ -22041,7 +25822,8 @@ void MP_WritePhyUshort(struct re_softc *sc,u_int8_t RegAddr,u_int16_t RegData)
                    sc->re_type == MACFG_58 || sc->re_type == MACFG_59 ||
                    sc->re_type == MACFG_60 || sc->re_type == MACFG_61 ||
                    sc->re_type == MACFG_62 || sc->re_type == MACFG_67 ||
-                   sc->re_type == MACFG_69 || sc->re_type == MACFG_69) {
+                   sc->re_type == MACFG_69 || sc->re_type == MACFG_69 ||
+                   sc->re_type == MACFG_70 || sc->re_type == MACFG_71) {
                 if (RegAddr == 0x1F) {
                         return;
                 }
@@ -22049,7 +25831,7 @@ void MP_WritePhyUshort(struct re_softc *sc,u_int8_t RegAddr,u_int16_t RegData)
                 MP_WritePhyOcpRegWord(sc, sc->cur_page, RegAddr, RegData);
         } else {
                 if (sc->re_type == MACFG_65 || sc->re_type == MACFG_66)
-                        CSR_WRITE_4(sc, 0xD0, CSR_READ_4(sc,0xD0) & ~0x00020000);
+                        CSR_WRITE_4(sc, 0xD0, CSR_READ_4(sc, 0xD0) & ~0x00020000);
 
                 TmpUlong |= (((u_int32_t)RegAddr)<<16 | (u_int32_t)RegData);
 
@@ -22063,7 +25845,7 @@ void MP_WritePhyUshort(struct re_softc *sc,u_int8_t RegAddr,u_int16_t RegData)
                 }
 
                 if (sc->re_type == MACFG_65 || sc->re_type == MACFG_66)
-                        CSR_WRITE_4(sc, 0xD0, CSR_READ_4(sc,0xD0) | 0x00020000);
+                        CSR_WRITE_4(sc, 0xD0, CSR_READ_4(sc, 0xD0) | 0x00020000);
         }
 }
 
@@ -22101,12 +25883,13 @@ u_int16_t MP_ReadPhyUshort(struct re_softc *sc,u_int8_t RegAddr)
                    sc->re_type == MACFG_58 || sc->re_type == MACFG_59 ||
                    sc->re_type == MACFG_60 || sc->re_type == MACFG_61 ||
                    sc->re_type == MACFG_62 || sc->re_type == MACFG_67 ||
-                   sc->re_type == MACFG_69 || sc->re_type == MACFG_69) {
+                   sc->re_type == MACFG_69 || sc->re_type == MACFG_69 ||
+                   sc->re_type == MACFG_70 || sc->re_type == MACFG_71) {
                 RegData= MP_ReadPhyOcpRegWord(sc, sc->cur_page, RegAddr);
 
         } else {
                 if (sc->re_type == MACFG_65 || sc->re_type == MACFG_66)
-                        CSR_WRITE_4(sc, 0xD0, CSR_READ_4(sc,0xD0) & ~0x00020000);
+                        CSR_WRITE_4(sc, 0xD0, CSR_READ_4(sc, 0xD0) & ~0x00020000);
 
                 TmpUlong = ((u_int32_t)RegAddr << 16);
                 CSR_WRITE_4(sc, RE_PHYAR, TmpUlong);
@@ -22122,7 +25905,7 @@ u_int16_t MP_ReadPhyUshort(struct re_softc *sc,u_int8_t RegAddr)
                 RegData = (u_int16_t)(TmpUlong & 0x0000ffff);
 
                 if (sc->re_type == MACFG_65 || sc->re_type == MACFG_66)
-                        CSR_WRITE_4(sc, 0xD0, CSR_READ_4(sc,0xD0) | 0x00020000);
+                        CSR_WRITE_4(sc, 0xD0, CSR_READ_4(sc, 0xD0) | 0x00020000);
         }
 
         return RegData;
@@ -22167,30 +25950,147 @@ u_int16_t MP_ReadEPhyUshort(struct re_softc *sc, u_int8_t RegAddr)
         return RegData;
 }
 
-u_int8_t MP_ReadEfuse(struct re_softc *sc, u_int16_t RegAddr)
+static u_int8_t re_calc_efuse_dummy_bit(u_int16_t reg)
 {
-        u_int8_t		RegData;
-        u_int32_t		TmpUlong;
-        u_int32_t		Timeout=0;
+        int s,a,b;
+        u_int8_t dummyBitPos = 0;
 
-        RegAddr &= 0x3FF;
-        TmpUlong = ((u_int32_t)RegAddr << 8);
-        CSR_WRITE_4(sc, 0xDC, TmpUlong);
 
-        /* Wait for writing to Phy ok */
-        for (Timeout=0; Timeout<5; Timeout++) {
-                DELAY(1000);
-                TmpUlong = CSR_READ_4(sc, 0xDC);
-                if ((TmpUlong&PHYAR_Flag)!=0)
-                        break;
+        s=reg% 32;
+        a=s % 16;
+        b=s/16;
+
+        if (s/16) {
+                dummyBitPos = (u_int8_t)(16-a);
+        } else {
+                dummyBitPos = (u_int8_t)a;
         }
 
-        RegData = (u_int8_t)(TmpUlong & 0x000000ff);
+        return dummyBitPos;
+}
 
-        return RegData;
+static u_int32_t re_decode_efuse_cmd(struct re_softc *sc, u_int32_t DwCmd)
+{
+        u_int16_t reg = (u_int16_t)((DwCmd & 0x00FE0000) >> 17);
+        u_int32_t DummyPos = re_calc_efuse_dummy_bit(reg);
+        u_int32_t DeCodeDwCmd = DwCmd;
+        u_int32_t Dw17BitData;
+
+
+        if (sc->re_efuse_ver < 3) {
+                DeCodeDwCmd = (DwCmd>>(DummyPos+1))<<DummyPos;
+                if (DummyPos > 0) {
+                        DeCodeDwCmd |= ((DwCmd<<(32-DummyPos))>>(32-DummyPos));
+                }
+        } else {
+                reg = (u_int16_t)((DwCmd & 0x007F0000) >> 16);
+                DummyPos = re_calc_efuse_dummy_bit(reg);
+                Dw17BitData = ((DwCmd & BIT_23) >> 23);
+                Dw17BitData <<= 16;
+                Dw17BitData |= (DwCmd & 0x0000FFFF);
+                DeCodeDwCmd = (Dw17BitData>>(DummyPos+1))<<DummyPos;
+                if (DummyPos > 0) {
+                        DeCodeDwCmd |= ((Dw17BitData<<(32-DummyPos))>>(32-DummyPos));
+                }
+        }
+
+        return DeCodeDwCmd;
+}
+
+#define EFUSE_WRITE 0x80000000
+#define EFUSE_WRITE_OK  0x00000000
+#define EFUSE_READ  0x00000000
+#define EFUSE_READ_OK  0x80000000
+#define EFUSE_Reg_Mask 0x03FF
+#define EFUSE_Reg_Shift 8
+#define EFUSE_Check_Cnt 300
+#define EFUSE_READ_FAIL 0xFF
+#define EFUSE_Data_Mask 0x000000FF
+
+u_int8_t MP_ReadEfuse(struct re_softc *sc, u_int16_t reg)
+{
+        u_int8_t efuse_data = 0;
+        u_int32_t temp;
+        u_int32_t cnt;
+
+        if (sc->re_efuse_ver == EFUSE_NOT_SUPPORT)
+                return EFUSE_READ_FAIL;
+
+        if (sc->re_efuse_ver == EFUSE_SUPPORT_V1) {
+                temp = EFUSE_READ | ((reg & EFUSE_Reg_Mask) << EFUSE_Reg_Shift);
+                CSR_WRITE_4(sc, RE_EFUSEAR, temp);
+
+                cnt = 0;
+                do {
+                        DELAY(100);
+                        temp = CSR_READ_4(sc, RE_EFUSEAR);
+                        cnt++;
+                } while (!(temp & EFUSE_READ_OK) && (cnt < EFUSE_Check_Cnt));
+
+                if (cnt == EFUSE_Check_Cnt)
+                        efuse_data = EFUSE_READ_FAIL;
+                else
+                        efuse_data = (u_int8_t)(CSR_READ_4(sc, RE_EFUSEAR) & EFUSE_Data_Mask);
+        } else  if (sc->re_efuse_ver == EFUSE_SUPPORT_V2) {
+                temp = (reg/2) & 0x03ff;
+                temp <<= 17;
+                temp |= EFUSE_READ;
+                CSR_WRITE_4(sc, RE_EFUSEAR, temp);
+
+                cnt = 0;
+                do {
+                        DELAY(100);
+                        temp = CSR_READ_4(sc, RE_EFUSEAR);
+                        cnt++;
+                } while (!(temp & EFUSE_READ_OK) && (cnt < EFUSE_Check_Cnt));
+
+                if (cnt == EFUSE_Check_Cnt) {
+                        efuse_data = EFUSE_READ_FAIL;
+                } else {
+                        temp = CSR_READ_4(sc, RE_EFUSEAR);
+                        temp = re_decode_efuse_cmd(sc, temp);
+
+                        if (reg%2) {
+                                temp >>= 8;
+                                efuse_data = (u_int8_t)temp;
+                        } else {
+                                efuse_data = (u_int8_t)temp;
+                        }
+                }
+        } else  if (sc->re_efuse_ver == EFUSE_SUPPORT_V3) {
+                temp = (reg/2) & 0x03ff;
+                temp <<= 16;
+                temp |= EFUSE_READ;
+                CSR_WRITE_4(sc, RE_EFUSEAR, temp);
+
+                cnt = 0;
+                do {
+                        DELAY(100);
+                        temp = CSR_READ_4(sc, RE_EFUSEAR);
+                        cnt++;
+                } while (!(temp & EFUSE_READ_OK) && (cnt < EFUSE_Check_Cnt));
+
+                if (cnt == EFUSE_Check_Cnt) {
+                        efuse_data = EFUSE_READ_FAIL;
+                } else {
+                        temp = CSR_READ_4(sc, RE_EFUSEAR);
+                        temp = re_decode_efuse_cmd(sc, temp);
+
+                        if (reg%2) {
+                                temp >>= 8;
+                                efuse_data = (u_int8_t)temp;
+                        } else {
+                                efuse_data = (u_int8_t)temp;
+                        }
+                }
+        }
+
+        DELAY(20);
+
+        return efuse_data;
 }
 
-static void MP_WriteOtherFunPciEConfigSpace(
+void MP_WriteOtherFunPciEConfigSpace(
         struct re_softc *sc,
         u_int8_t MultiFunSelBit,
         u_int16_t ByteEnAndAddr,
@@ -22221,7 +26121,7 @@ static void MP_WriteOtherFunPciEConfigSpace(
         DELAY(50);
 }
 
-static u_int32_t MP_ReadOtherFunPciEConfigSpace(
+u_int32_t MP_ReadOtherFunPciEConfigSpace(
         struct re_softc *sc,
         u_int8_t MultiFunSelBit,
         u_int16_t ByteEnAndAddr)
@@ -22499,16 +26399,21 @@ static u_int32_t real_ocp_read(struct re_softc *sc, u_int16_t addr, u_int8_t len
         return value2;
 }
 
+static u_int32_t OCP_read_with_oob_base_address(struct re_softc *sc, u_int16_t addr, u_int8_t len, const u_int32_t base_address)
+{
+        return re_eri_read_with_oob_base_address(sc, addr, len, ERIAR_OOB, base_address);
+}
+
 static u_int32_t OCP_read(struct re_softc *sc, u_int16_t addr, u_int8_t len)
 {
         u_int32_t value = 0;
 
-        if (sc->re_type == MACFG_61 || sc->re_type == MACFG_62 ||
-            sc->re_type == MACFG_67) {
+        if (HW_DASH_SUPPORT_TYPE_2(sc))
                 value = re_eri_read(sc, addr, len, ERIAR_OOB);
-        } else {
+        else if (HW_DASH_SUPPORT_TYPE_3(sc))
+                value = OCP_read_with_oob_base_address(sc, addr, len, RTL8168FP_OOBMAC_BASE);
+        else
                 value = real_ocp_read(sc, addr, len);
-        }
 
         return value;
 }
@@ -22558,14 +26463,19 @@ static int real_ocp_write(struct re_softc *sc, u_int16_t addr, u_int8_t len, u_i
         return 0;
 }
 
+static int OCP_write_with_oob_base_address(struct re_softc *sc, u_int16_t addr, u_int8_t len, u_int32_t value, const u_int32_t base_address)
+{
+        return re_eri_write_with_oob_base_address(sc, addr, len, value, ERIAR_OOB, base_address);
+}
+
 static void OCP_write(struct re_softc *sc, u_int16_t addr, u_int8_t len, u_int32_t value)
 {
-        if (sc->re_type == MACFG_61 || sc->re_type == MACFG_62 ||
-            sc->re_type == MACFG_67) {
+        if (HW_DASH_SUPPORT_TYPE_2(sc))
                 re_eri_write(sc, addr, len, value, ERIAR_OOB);
-        } else {
+        else if (HW_DASH_SUPPORT_TYPE_3(sc))
+                OCP_write_with_oob_base_address(sc, addr, len, value, RTL8168FP_OOBMAC_BASE);
+        else
                 real_ocp_write(sc, addr, len, value);
-        }
 }
 
 static void OOB_mutex_lock(struct re_softc *sc)
@@ -22592,6 +26502,8 @@ static void OOB_mutex_lock(struct re_softc *sc)
         case MACFG_61:
         case MACFG_62:
         case MACFG_67:
+        case MACFG_70:
+        case MACFG_71:
         default:
                 ocp_reg_mutex_oob = 0x110;
                 ocp_reg_mutex_ib = 0x114;
@@ -22650,6 +26562,8 @@ static void OOB_mutex_unlock(struct re_softc *sc)
         case MACFG_61:
         case MACFG_62:
         case MACFG_67:
+        case MACFG_70:
+        case MACFG_71:
         default:
                 ocp_reg_mutex_oob = 0x110;
                 ocp_reg_mutex_ib = 0x114;
@@ -22663,24 +26577,37 @@ static void OOB_mutex_unlock(struct re_softc *sc)
 
 static int re_check_dash(struct re_softc *sc)
 {
-        if (sc->re_type == MACFG_61 || sc->re_type == MACFG_62 ||
-            sc->re_type == MACFG_67) {
-                if (OCP_read(sc, 0x128, 1) & BIT_0)
-                        return 1;
-                else
-                        return 0;
-        } else {
-                u_int32_t reg;
+        switch(sc->re_type) {
+        case MACFG_61:
+        case MACFG_62:
+        case MACFG_67:
+        case MACFG_63:
+        case MACFG_64:
+        case MACFG_65:
+        case MACFG_66:
+        case MACFG_70:
+        case MACFG_71:
+                if (HW_DASH_SUPPORT_TYPE_2(sc) || HW_DASH_SUPPORT_TYPE_3(sc)) {
+                        if (OCP_read(sc, 0x128, 1) & BIT_0)
+                                return 1;
+                        else
+                                return 0;
+                } else {
+                        u_int32_t reg;
 
-                if (sc->re_type == MACFG_66)
-                        reg = 0xb8;
-                else
-                        reg = 0x10;
+                        if (sc->re_type == MACFG_66)
+                                reg = 0xb8;
+                        else
+                                reg = 0x10;
 
-                if (OCP_read(sc, reg, 2) & 0x00008000)
-                        return 1;
-                else
-                        return 0;
+                        if (OCP_read(sc, reg, 2) & 0x00008000)
+                                return 1;
+                        else
+                                return 0;
+                }
+                break;
+        default:
+                return 0;
         }
 }
 
@@ -22702,11 +26629,10 @@ static void OOB_notify(struct re_softc *sc, u_int8_t cmd)
 
 void re_driver_start(struct re_softc *sc)
 {
-        if (sc->re_type == MACFG_61 || sc->re_type == MACFG_62 ||
-            sc->re_type == MACFG_67) {
+        if (HW_DASH_SUPPORT_TYPE_2(sc) || HW_DASH_SUPPORT_TYPE_3(sc)) {
                 u_int32_t tmp_value;
 
-                if (!re_check_dash(sc))
+                if (!sc->re_dash)
                         return;
 
                 OCP_write(sc, 0x180, 1, OOB_CMD_DRIVER_START);
@@ -22738,11 +26664,10 @@ void re_driver_start(struct re_softc *sc)
 
 void re_driver_stop(struct re_softc *sc)
 {
-        if (sc->re_type == MACFG_61 || sc->re_type == MACFG_62 ||
-            sc->re_type == MACFG_67) {
+        if (HW_DASH_SUPPORT_TYPE_2(sc) || HW_DASH_SUPPORT_TYPE_3(sc)) {
                 u_int32_t tmp_value;
 
-                if (!re_check_dash(sc))
+                if (!sc->re_dash)
                         return;
 
                 Dash2DisableTxRx(sc);
@@ -23071,4 +26996,15 @@ rtl_phy_power_down(struct re_softc *sc)
 	re_phy_power_down(sc->dev);
 }
 
+void
+rtl_cmac_unmap(struct re_softc *sc)
+{
+
+	if (HW_DASH_SUPPORT_TYPE_3(sc) && sc->re_dash &&
+	    sc->re_mapped_cmac_handle != 0) {
+		bus_space_unmap(sc->re_cmac_tag, sc->re_mapped_cmac_handle,
+		    RE_REGS_SIZE);
+	}
+}
+
 #endif	/* __DragonFly__ */
diff --git a/sys/dev/netif/re/re.h b/sys/dev/netif/re/re.h
index db4b0f3a91..c845d73f46 100644
--- a/sys/dev/netif/re/re.h
+++ b/sys/dev/netif/re/re.h
@@ -117,6 +117,7 @@
 #define RE_CFG4		0x0055		/* config register #4 */
 #define RE_CFG5		0x0056		/* config register #5 */
 /* 0053-0057 reserved */
+#define RE_TDFNR	0x0057		/* Tx descriptor fetch number */
 #define RE_MEDIASTAT	0x0058		/* media status register (8139) */
 /* 0059-005A reserved */
 #define RE_MII		0x005A		/* 8129 chip only */
@@ -144,12 +145,13 @@
 #define RE_TwiCmdReg	0x00D2
 #define RE_MCU_CMD	0x00D3
 #define RE_RxMaxSize	0x00DA
+#define RE_EFUSEAR	0x00DC
 #define RE_CPlusCmd	0x00E0
 #define	RE_MTPS		0x00EC
-#define	RE_IBCR0     	0x00F8
-#define	RE_IBCR2     	0x00F9
-#define	RE_IBIMR0    	0x00FA
-#define	RE_IBISR0   	0x00FB
+#define	RE_CMAC_IBCR0     	0x00F8
+#define	RE_CMAC_IBCR2     	0x00F9
+#define	RE_CMAC_IBIMR0    	0x00FA
+#define	RE_CMAC_IBISR0   	0x00FB
 
 /* ERI access */
 #define	ERIAR_Flag   0x80000000
@@ -781,6 +783,13 @@ struct re_mii_frame {
 
 #define RL_RxChkSum (1<<5)
 
+enum  {
+        EFUSE_NOT_SUPPORT = 0,
+        EFUSE_SUPPORT_V1,
+        EFUSE_SUPPORT_V2,
+        EFUSE_SUPPORT_V3,
+};
+
 enum {
         MACFG_3 = 3,
         MACFG_4,
@@ -839,6 +848,8 @@ enum {
         MACFG_67,
         MACFG_68,
         MACFG_69,
+        MACFG_70,
+        MACFG_71,
 
         MACFG_FF = 0xFF
 };
@@ -902,6 +913,13 @@ struct re_softc {
 
         u_int8_t RequireAdjustUpsTxLinkPulseTiming;
         u_int16_t SwrCnt1msIni;
+
+        u_int8_t RequiredSecLanDonglePatch;
+
+        u_int8_t  re_efuse_ver;
+
+        u_int16_t re_sw_ram_code_ver;
+        u_int16_t re_hw_ram_code_ver;
 #if OS_VER>=VERSION(7,0)
         struct task		re_inttask;
 #endif
@@ -916,6 +934,14 @@ struct re_softc {
         u_int8_t	prohibit_access_reg;
 
         u_int8_t	re_hw_supp_now_is_oob_ver;
+
+        u_int8_t HwSuppDashVer;
+        u_int8_t	re_dash;
+        bus_space_handle_t	re_mapped_cmac_handle;			/* bus space tag */
+        bus_space_tag_t		re_mapped_cmac_tag;			/* bus space tag */
+        bus_space_handle_t	re_cmac_handle;		/* bus space handle */
+        bus_space_tag_t		re_cmac_tag;			/* bus space tag */
+        u_int8_t HwPkgDet;
 };
 #endif	/* !__DragonFly__ */
 
@@ -975,6 +1001,14 @@ enum bits {
 #define CSR_READ_4(sc, reg)	((sc->prohibit_access_reg)?0xFFFFFFFF:bus_space_read_4(sc->re_btag, sc->re_bhandle, reg))
 #define CSR_READ_2(sc, reg)	((sc->prohibit_access_reg)?0xFFFF:bus_space_read_2(sc->re_btag, sc->re_bhandle, reg))
 #define CSR_READ_1(sc, reg)	((sc->prohibit_access_reg)?0xFF:bus_space_read_1(sc->re_btag, sc->re_bhandle, reg))
+
+/* cmac write/read MMIO register */
+#define RE_CMAC_WRITE_1(sc, reg, val) ((sc->prohibit_access_reg)?:bus_space_write_1(sc->re_cmac_tag, sc->re_cmac_handle, reg, val))
+#define RE_CMAC_WRITE_2(sc, reg, val) ((sc->prohibit_access_reg)?:bus_space_write_2(sc->re_cmac_tag, sc->re_cmac_handle, reg, val))
+#define RE_CMAC_WRITE_4(sc, reg, val) ((sc->prohibit_access_reg)?:bus_space_write_4(sc->re_cmac_tag, sc->re_cmac_handle, reg, val))
+#define RE_CMAC_READ_1(sc, reg) ((sc->prohibit_access_reg)?0xFF:bus_space_read_1(sc->re_cmac_tag, sc->re_cmac_handle, reg))
+#define RE_CMAC_READ_2(sc, reg) ((sc->prohibit_access_reg)?0xFFFF:bus_space_read_2(sc->re_cmac_tag, sc->re_cmac_handle, reg))
+#define RE_CMAC_READ_4(sc, reg) (sc->prohibit_access_reg)?0xFFFFFFFF:bus_space_read_4(sc->re_cmac_tag, sc->re_cmac_handle, reg))
 #endif	/* !__DragonFly__ */
 
 #define RE_TIMEOUT		1000
@@ -1074,6 +1108,18 @@ enum bits {
 #define RE_WOL_LINK_SPEED_10M_FIRST ( 0 )
 #define RE_WOL_LINK_SPEED_100M_FIRST ( 1 )
 
+//Ram Code Version
+#define NIC_RAMCODE_VERSION_8168E (0x0057)
+#define NIC_RAMCODE_VERSION_8168EVL (0x0055)
+#define NIC_RAMCODE_VERSION_8168F (0x0044)
+#define NIC_RAMCODE_VERSION_8411 (0x0044)
+#define NIC_RAMCODE_VERSION_8168G (0x0042)
+#define NIC_RAMCODE_VERSION_8168GU (0x0001)
+#define NIC_RAMCODE_VERSION_8168EP (0x0015)
+#define NIC_RAMCODE_VERSION_8411B (0x0012)
+#define NIC_RAMCODE_VERSION_8168H (0x0018)
+#define NIC_RAMCODE_VERSION_8168FP (0x0003)
+
 #ifdef __alpha__
 #undef vtophys
 #define vtophys(va)     alpha_XXX_dmamap((vm_offset_t)va)
@@ -1093,6 +1139,14 @@ enum bits {
 /* the minimum value is 1 */
 #define	INTR_MAX_LOOP	1
 
+#define RE_REGS_SIZE     (256)
+
+#define RTL8168FP_OOBMAC_BASE 0xBAF70000
+#define HW_DASH_SUPPORT_DASH(_M)        ((_M)->HwSuppDashVer > 0 )
+#define HW_DASH_SUPPORT_TYPE_1(_M)        ((_M)->HwSuppDashVer == 1 )
+#define HW_DASH_SUPPORT_TYPE_2(_M)        ((_M)->HwSuppDashVer == 2 )
+#define HW_DASH_SUPPORT_TYPE_3(_M)        ((_M)->HwSuppDashVer == 3 )
+
 /*#define RE_DBG*/
 
 #ifdef RE_DBG
diff --git a/sys/dev/netif/re/re_dragonfly.h b/sys/dev/netif/re/re_dragonfly.h
index 417a3897f1..69152eaada 100644
--- a/sys/dev/netif/re/re_dragonfly.h
+++ b/sys/dev/netif/re/re_dragonfly.h
@@ -39,6 +39,20 @@
 	((RE_INTRS & ~(RE_ISR_TX_OK | RE_ISR_RX_OK | RE_ISR_RX_OVERRUN |\
 	  RE_ISR_PKT_UNDERRUN | RE_ISR_TDU)) | RE_ISR_PCS_TIMEOUT)
 
+/* cmac write/read MMIO register */
+#define RE_CMAC_WRITE_1(sc, reg, val)	\
+	bus_space_write_1(sc->re_cmac_tag, sc->re_cmac_handle, reg, val)
+#define RE_CMAC_WRITE_2(sc, reg, val)	\
+	bus_space_write_2(sc->re_cmac_tag, sc->re_cmac_handle, reg, val)
+#define RE_CMAC_WRITE_4(sc, reg, val)	\
+	bus_space_write_4(sc->re_cmac_tag, sc->re_cmac_handle, reg, val)
+#define RE_CMAC_READ_1(sc, reg)		\
+	bus_space_read_1(sc->re_cmac_tag, sc->re_cmac_handle, reg)
+#define RE_CMAC_READ_2(sc, reg)		\
+	bus_space_read_2(sc->re_cmac_tag, sc->re_cmac_handle, reg)
+#define RE_CMAC_READ_4(sc, reg)		\
+	bus_space_read_4(sc->re_cmac_tag, sc->re_cmac_handle, reg)
+
 int		rtl_check_mac_version(struct re_softc *);
 void		rtl_init_software_variable(struct re_softc *);
 void		rtl_exit_oob(struct re_softc *);
@@ -58,5 +72,6 @@ void		rtl_hw_start(struct re_softc *);
 void		rtl_set_rx_packet_filter(struct re_softc *);
 void		rtl_hw_d3_para(struct re_softc *);
 void		rtl_phy_power_down(struct re_softc *);
+void		rtl_cmac_unmap(struct re_softc *);
 
 #endif	/* !_RE_DRAGONFLY_H_ */
diff --git a/sys/platform/pc64/x86_64/busdma_machdep.c b/sys/platform/pc64/x86_64/busdma_machdep.c
index 884b3ffbb2..62e1163589 100644
--- a/sys/platform/pc64/x86_64/busdma_machdep.c
+++ b/sys/platform/pc64/x86_64/busdma_machdep.c
@@ -48,6 +48,7 @@
 #include <vm/vm_map.h>
 
 #include <machine/md_var.h>
+#include <machine/pmap.h>
 
 #include <bus/cam/cam.h>
 #include <bus/cam/cam_ccb.h>
@@ -1478,3 +1479,22 @@ busdma_swi(void)
 	}
 	spin_unlock(&bounce_map_list_spin);
 }
+
+int
+bus_space_map(bus_space_tag_t t __unused, bus_addr_t addr, bus_size_t size,
+    int flags __unused, bus_space_handle_t *bshp)
+{
+
+	if (t == X86_64_BUS_SPACE_MEM)
+		*bshp = (uintptr_t)pmap_mapdev(addr, size);
+	else
+		*bshp = addr;
+	return (0);
+}
+
+void
+bus_space_unmap(bus_space_tag_t t, bus_space_handle_t bsh, bus_size_t size)
+{
+	if (t == X86_64_BUS_SPACE_MEM)
+		pmap_unmapdev(bsh, size);
+}
