From 2e39d7d2736e32bb8035b3b4051a4ec3905d5c71 Mon Sep 17 00:00:00 2001 From: Franco Fichtner Date: Fri, 13 Oct 2017 07:39:43 +0200 Subject: [PATCH] re: update to vendor version 1.94 --- sys/dev/re/if_re.c | 26745 +++++++++++++++++++++++----------------- sys/dev/re/if_rereg.h | 62 +- 2 files changed, 15380 insertions(+), 11427 deletions(-) diff --git a/sys/dev/re/if_re.c b/sys/dev/re/if_re.c index 6e489d2f29c..c6488d503f0 100644 --- a/sys/dev/re/if_re.c +++ b/sys/dev/re/if_re.c @@ -41,7 +41,7 @@ */ #include -__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. @@ -55,6 +55,7 @@ __FBSDID("$FreeBSD: src/sys/dev/re/if_re.c,v 1.93 " __DATE__ " " __TIME__ " wpa #include #include #include +#include #include #include @@ -151,6 +152,8 @@ 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)); @@ -218,8 +221,8 @@ static void re_release_buf(struct re_softc *); 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 *); -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 *); @@ -241,12 +244,12 @@ TUNABLE_INT("hw.re.phy_mdix_mode", &phy_power_saving); 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 } }; @@ -345,6 +348,8 @@ 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; }; @@ -358,6 +363,11 @@ 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) { @@ -489,10 +499,11 @@ device_t dev; } -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; @@ -503,6 +514,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); @@ -535,11 +547,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; @@ -553,12 +571,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); @@ -583,6 +602,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, @@ -776,8 +800,27 @@ static void set_rxbufsize(struct re_softc *sc) CSR_WRITE_2(sc, RE_RxMaxSize, sc->re_rx_desc_buf_sz); } +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: @@ -789,10 +832,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); @@ -808,1364 +853,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_set_mac_mcu_8411b_1(struct re_softc *sc) +{ + 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); +} + +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); +} + +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); +} + +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: - 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); + 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; } } @@ -2173,20 +2964,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; @@ -2197,28 +2987,63 @@ 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) +{ + if (read_random(dst, 6) == 0) + arc4rand(dst, 6, 0); + + 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) @@ -2230,27 +3055,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: @@ -2263,6 +3081,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); @@ -2342,6 +3162,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++) { @@ -2365,6 +3187,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); @@ -2453,11 +3277,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; } @@ -2470,12 +3297,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: @@ -2491,58 +3355,30 @@ 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 (!is_valid_ether_addr(eaddr)) { + device_printf(dev,"Invalid ether addr: %6D\n", eaddr, ":"); + random_ether_addr(eaddr); + device_printf(dev,"Random ether addr: %6D\n", eaddr, ":"); } - 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); - } - - 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) @@ -2725,13 +3561,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: @@ -2739,7 +3575,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: @@ -2862,6 +3698,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; @@ -2901,6 +3749,129 @@ static void re_init_software_variable(struct re_softc *sc) sc->re_rx_mbuf_sz = MJUM9BYTES; } + 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 */ + sc->re_mapped_cmac_tag = X86_BUS_SPACE_MEM; + 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; @@ -2934,7 +3905,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); @@ -2982,6 +3955,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; } @@ -3034,10 +4009,54 @@ 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; } + 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); @@ -3057,7 +4076,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); } @@ -3271,12 +4291,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"); @@ -3568,6 +4590,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) { @@ -3771,17 +4796,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; @@ -3809,7 +4825,38 @@ static void re_hw_start_unlock(struct re_softc *sc) /* Init descriptors. */ re_var_init(sc); - 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);*/ @@ -3919,6 +4966,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; @@ -3943,9 +4993,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 @@ -3977,8 +5024,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); @@ -3987,9 +5032,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 @@ -4023,11 +5065,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 @@ -4060,6 +5098,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; @@ -4068,9 +5109,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) @@ -4103,17 +5141,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); @@ -4181,14 +5219,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); @@ -4242,21 +5285,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; @@ -4338,11 +5385,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; @@ -4354,14 +5401,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); @@ -4387,7 +5427,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); @@ -4421,19 +5460,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); @@ -4459,12 +5494,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); @@ -4527,6 +5557,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); @@ -4581,8 +5613,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); @@ -4591,7 +5621,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) { @@ -4602,9 +5632,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); @@ -4617,6 +5644,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); @@ -4666,8 +5695,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); @@ -4676,7 +5703,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) { @@ -4687,16 +5714,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); @@ -4706,8 +5725,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) { @@ -4734,7 +5751,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); @@ -4742,6 +5759,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; @@ -4768,6 +5787,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); @@ -4823,6 +5845,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, @@ -4841,6 +5866,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); @@ -4850,7 +5878,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); } @@ -4871,7 +5899,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); } @@ -4897,9 +5925,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); @@ -4918,7 +5943,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) { @@ -4929,18 +5954,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); @@ -5005,9 +6023,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); @@ -5036,7 +6051,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) { @@ -5047,9 +6062,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)); - /* disable clock request. */ - pci_write_config(sc->dev, 0x81, 0x00, 1); + if (sc->RequireAdjustUpsTxLinkPulseTiming) { + data16 = MP_ReadMcuAccessRegWord(sc, 0xD412); + data16 &= ~(0x0FFF); + data16 |= sc->SwrCnt1msIni; + MP_WriteMcuAccessRegWord(sc, 0xD412, data16); + } + + 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 @@ -5070,10 +6219,43 @@ 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; } + 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); @@ -5089,7 +6271,7 @@ static void re_hw_start_unlock(struct re_softc *sc) 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) { @@ -5153,25 +6335,7 @@ static void re_init_unlock(void *xsc) /* Software & Hardware Initialize */ #endif /* 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); re_hw_start_unlock(sc); @@ -5329,6 +6493,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: @@ -5368,7 +6534,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; @@ -5425,7 +6591,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) { @@ -5465,7 +6631,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 @@ -5507,7 +6673,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); @@ -5537,7 +6703,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); } /* @@ -5679,7 +6845,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_ @@ -6227,11 +7393,11 @@ u_int32_t mask4; 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; } @@ -6559,7 +7725,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); @@ -6576,6 +7743,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); + } + re_init_unlock(sc); } @@ -6712,7 +7888,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); @@ -6847,7 +8024,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 { @@ -6920,27 +8097,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); @@ -6973,6 +8150,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); @@ -7011,7 +8190,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); @@ -7081,6 +8260,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); @@ -7104,7 +8296,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; @@ -7208,7 +8400,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); @@ -7217,7 +8409,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); @@ -7229,7 +8421,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); @@ -7263,6 +8455,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); @@ -7301,7 +8495,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); @@ -7339,6 +8533,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); @@ -7365,7 +8561,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; @@ -7399,12 +8595,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); @@ -7415,7 +8611,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); @@ -7442,7 +8638,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); @@ -7480,12 +8676,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); @@ -7537,26 +8733,12099 @@ static void re_set_phy_ram_code_check_fail_flag(struct re_softc *sc) } } +static int re_hw_phy_mcu_code_ver_matched(struct re_softc *sc) +{ + int ram_code_ver_match = 0; + + 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 (sc->re_hw_ram_code_ver == sc->re_sw_ram_code_ver) + ram_code_ver_match = 1; + + return ram_code_ver_match; +} + +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); + 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; + } +} + +static void re_set_phy_mcu_8168e_1(struct re_softc *sc) +{ + u_int16_t PhyRegValue; + int i; + + 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, 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); +} + +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, 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, 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, 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); + 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, 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); + 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 & 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, 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, 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); + + 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; - u_int32_t WaitCnt; 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); } + 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) { @@ -7833,11 +21102,11 @@ static void re_hw_phy_config(struct re_softc *sc) MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0000); - MP_WritePhyUshort(sc, 0x16, MP_ReadPhyUshort(sc , 0x16) | BIT_0); + 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, 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); @@ -8928,2127 +22197,13 @@ static void re_hw_phy_config(struct re_softc *sc) 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; + if (sc->RequiredSecLanDonglePatch) + Data &= ~(BIT_2); + else + Data |= (BIT_2); MP_WritePhyUshort(sc, 0x17, Data); MP_WritePhyUshort(sc, 0x1F, 0x0000); @@ -11105,2538 +22260,6 @@ static void re_hw_phy_config(struct re_softc *sc) 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); @@ -13777,954 +22400,6 @@ static void re_hw_phy_config(struct re_softc *sc) 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); @@ -15410,887 +23085,6 @@ static void re_hw_phy_config(struct re_softc *sc) 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++) { - 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, 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); - 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, 0x0023); - Data = MP_ReadPhyUshort(sc, 0x17); - Data |= BIT_1; - MP_WritePhyUshort(sc, 0x17, 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, 0x0003); - MP_WritePhyUshort(sc, 0x01, 0x328A); - 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, 0x0005); MP_WritePhyUshort(sc, 0x05, 0x8B80); Data = MP_ReadPhyUshort(sc, 0x06); @@ -16398,338 +23192,6 @@ static void re_hw_phy_config(struct re_softc *sc) 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; - } - 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, 0x0005); MP_WritePhyUshort(sc, 0x05, 0x8B80); Data = MP_ReadPhyUshort(sc, 0x06); @@ -16805,575 +23267,6 @@ static void re_hw_phy_config(struct re_softc *sc) 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, 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); - 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); - 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); - 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); - 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, 0x0005); MP_WritePhyUshort(sc, 0x05, 0x8B80); Data = MP_ReadPhyUshort(sc, 0x06); @@ -18422,1071 +24315,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; @@ -19539,7 +24367,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); @@ -19596,7 +24424,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); @@ -19619,69 +24447,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); @@ -19708,49 +24473,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 ); @@ -19758,49 +24523,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 ); @@ -19808,31 +24573,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 ); @@ -19854,69 +24619,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); @@ -19930,49 +24632,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 ); @@ -19980,49 +24682,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 ); @@ -20030,31 +24732,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 ); @@ -20076,1001 +24778,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, 0x1f, 0x0A43); + MP_WritePhyUshort(sc, 0x13, 0x8146); 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); - 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)); @@ -21102,7 +24817,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); @@ -21146,7 +24861,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); @@ -21155,49 +24870,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 ); @@ -21205,49 +24920,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 ); @@ -21255,31 +24970,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 ); @@ -21436,103 +25151,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); @@ -21541,19 +25182,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); @@ -21562,19 +25203,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); @@ -21641,7 +25282,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); @@ -21675,78 +25316,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, @@ -21802,8 +25383,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); - 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_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); + SetEthPhyBit(sc, 0x14, BIT_15); MP_WritePhyUshort(sc, 0x1F, 0x0A40); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x00, 0x9200); @@ -21841,6 +25593,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); @@ -21865,7 +25619,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); } @@ -21905,7 +25660,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; } @@ -21913,7 +25669,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); @@ -21927,7 +25683,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); } } @@ -21965,12 +25721,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); @@ -21986,7 +25743,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; @@ -22031,30 +25788,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 RegData; + return dummyBitPos; } -static void MP_WriteOtherFunPciEConfigSpace( +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))< 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))< 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; +} + +void MP_WriteOtherFunPciEConfigSpace( struct re_softc *sc, u_int8_t MultiFunSelBit, u_int16_t ByteEnAndAddr, @@ -22085,7 +25959,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) @@ -22363,16 +26237,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; } @@ -22422,14 +26301,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) @@ -22456,6 +26340,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; @@ -22514,6 +26400,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; @@ -22527,24 +26415,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; } } @@ -22566,11 +26467,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); @@ -22602,11 +26502,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); diff --git a/sys/dev/re/if_rereg.h b/sys/dev/re/if_rereg.h index 7adf18cd826..629e8c3c981 100644 --- a/sys/dev/re/if_rereg.h +++ b/sys/dev/re/if_rereg.h @@ -115,6 +115,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 */ @@ -142,12 +143,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 @@ -771,6 +773,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 = 0x03, MACFG_4, @@ -829,6 +838,8 @@ enum { MACFG_67, MACFG_68, MACFG_69, + MACFG_70, + MACFG_71, MACFG_FF = 0xFF }; @@ -891,6 +902,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 @@ -905,6 +923,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; }; enum bits { @@ -963,6 +989,14 @@ enum bits { #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)) + #define RE_TIMEOUT 1000 /* @@ -1060,6 +1094,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) @@ -1079,6 +1125,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