/* * Copyright (c) 1997, 1998 * Bill Paul . All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by Bill Paul. * 4. Neither the name of the author nor the names of any co-contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF * THE POSSIBILITY OF SUCH DAMAGE. * * $FreeBSD: src/sys/dev/if_rl.c,v 1.38.2.7 2001/07/19 18:33:07 wpaul Exp $ */ /* * RealTek 8129/8139 PCI NIC driver * * Written by Bill Paul * Electrical Engineering Department * Columbia University, New York City */ #ifndef __DragonFly__ #include #ifdef ENABLE_FIBER_SUPPORT #define FIBER_SUFFIX "-FIBER" #else #define FIBER_SUFFIX "" #endif #define RE_VERSION "1.96.04" FIBER_SUFFIX __FBSDID("$FreeBSD: src/sys/dev/re/if_re.c,v " RE_VERSION __DATE__ " " __TIME__ " wpaul Exp $"); /* * This driver also support Realtek RTL8110/RTL8169, RTL8111/RTL8168, RTL8125, and RTL8136/RTL810x. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include /* for vtophys */ #include /* for vtophys */ #include /* for DELAY */ #include #include #include #include #include #include #include #ifdef ENABLE_FIBER_SUPPORT #include #endif //ENABLE_FIBER_SUPPORT #if OS_VER < VERSION(5,3) #include #include #include #include #else #include #include #include #endif #if OS_VER > VERSION(5,9) #include #include #include #include #endif #else /* __DragonFly__ */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define RE_LOCK(sc) #define RE_UNLOCK(sc) #define RE_LOCK_ASSERT(sc) #define RE_GET_IFNET(sc) &(sc)->arpcom.ac_if #endif /* !__DragonFly__ */ #define EE_SET(x) \ CSR_WRITE_1(sc, RE_EECMD, \ CSR_READ_1(sc, RE_EECMD) | x) #define EE_CLR(x) \ CSR_WRITE_1(sc, RE_EECMD, \ CSR_READ_1(sc, RE_EECMD) & ~x) #ifndef __DragonFly__ /* * Various supported device vendors/types and their names. */ static struct re_type re_devs[] = { { RT_VENDORID, RT_DEVICEID_8169, "Realtek PCI GbE Family Controller" }, { RT_VENDORID, RT_DEVICEID_8169SC, "Realtek PCI GbE Family Controller" }, { RT_VENDORID, RT_DEVICEID_8168, "Realtek PCIe GbE Family Controller" }, { RT_VENDORID, RT_DEVICEID_8161, "Realtek PCIe GbE Family Controller" }, { RT_VENDORID, RT_DEVICEID_8136, "Realtek PCIe FE Family Controller" }, { DLINK_VENDORID, 0x4300, "Realtek PCI GbE Family Controller" }, { RT_VENDORID, RT_DEVICEID_8125, "Realtek PCIe 2.5GbE Family Controller" }, { 0, 0, NULL } }; static int re_probe __P((device_t)); static int re_attach __P((device_t)); static int re_detach __P((device_t)); static int re_suspend __P((device_t)); static int re_resume __P((device_t)); static int re_shutdown __P((device_t)); void MP_WritePhyUshort __P((struct re_softc*, u_int8_t, u_int16_t)); u_int16_t MP_ReadPhyUshort __P((struct re_softc*, u_int8_t)); static void MP_WriteEPhyUshort __P((struct re_softc*, u_int8_t, u_int16_t)); static u_int16_t MP_ReadEPhyUshort __P((struct re_softc*, u_int8_t)); static u_int8_t MP_ReadEfuse __P((struct re_softc*, u_int16_t)); static void MP_RealWritePhyOcpRegWord __P((struct re_softc*, u_int16_t, u_int16_t)); static u_int16_t MP_RealReadPhyOcpRegWord __P((struct re_softc*, u_int16_t)); static void MP_WritePhyOcpRegWord __P((struct re_softc*, u_int16_t, u_int8_t, u_int16_t)); static u_int16_t MP_ReadPhyOcpRegWord __P((struct re_softc*, u_int16_t, u_int8_t)); void MP_WriteMcuAccessRegWord __P((struct re_softc*, u_int16_t, u_int16_t)); 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)); static u_int8_t MP_ReadByteFun0PciEConfigSpace __P((struct re_softc*, u_int16_t)); static bool re_set_phy_mcu_patch_request __P((struct re_softc *)); static bool re_clear_phy_mcu_patch_request __P((struct re_softc *)); #endif /* !__DragonFly__ */ static int re_check_dash __P((struct re_softc *)); #ifndef __DragonFly__ static void re_driver_start __P((struct re_softc*)); static void re_driver_stop __P((struct re_softc*)); static void re_hw_phy_config __P((struct re_softc *)); static void re_init __P((void *)); static int re_var_init __P((struct re_softc *)); static void re_reset __P((struct re_softc *)); static void re_stop __P((struct re_softc *)); static void re_setwol __P((struct re_softc *)); #endif /* !__DragonFly__ */ static void re_clrwol __P((struct re_softc *)); static void re_set_wol_linkspeed __P((struct re_softc *)); #ifndef __DragonFly__ static void re_start __P((struct ifnet *)); static int re_encap __P((struct re_softc *, struct mbuf *)); static void WritePacket __P((struct re_softc *, caddr_t, int, int, int, uint32_t, uint32_t)); static int CountFreeTxDescNum __P((struct re_descriptor)); static int CountMbufNum __P((struct mbuf *)); #ifdef RE_FIXUP_RX static __inline void re_fixup_rx __P((struct mbuf *)); #endif static void re_txeof __P((struct re_softc *)); static void re_rxeof __P((struct re_softc *)); #if OS_VER < VERSION(7,0) static void re_intr __P((void *)); #else static int re_intr __P((void *)); #endif //OS_VER < VERSION(7,0) #if OS_VER < VERSION(7,0) static void re_intr_8125 __P((void *)); #else static int re_intr_8125 __P((void *)); #endif //OS_VER < VERSION(7,0) #endif /* !__DragonFly__ */ static void re_set_multicast_reg __P((struct re_softc *, u_int32_t, u_int32_t)); #ifndef __DragonFly__ static void re_set_rx_packet_filter_in_sleep_state __P((struct re_softc *)); #endif static void re_set_rx_packet_filter __P((struct re_softc *)); static void re_setmulti __P((struct re_softc *)); #ifndef __DragonFly__ static int re_ioctl __P((struct ifnet *, u_long, caddr_t)); #endif static u_int8_t re_link_ok __P((struct re_softc *)); static void re_link_on_patch __P((struct re_softc *)); #ifndef __DragonFly__ static void re_link_down_patch __P((struct re_softc *)); static void re_init_timer __P((struct re_softc *)); static void re_stop_timer __P((struct re_softc *)); static void re_start_timer __P((struct re_softc *)); static void re_tick __P((void *)); #if OS_VER < VERSION(7,0) static void re_watchdog __P((struct ifnet *)); #endif #endif /* !__DragonFly__ */ static int re_ifmedia_upd __P((struct ifnet *)); static void re_ifmedia_sts __P((struct ifnet *, struct ifmediareq *)); static int re_ifmedia_upd_8125 __P((struct ifnet *)); static void re_ifmedia_sts_8125 __P((struct ifnet *, struct ifmediareq *)); static void re_eeprom_ShiftOutBits __P((struct re_softc *, int, int)); static u_int16_t re_eeprom_ShiftInBits __P((struct re_softc *)); static void re_eeprom_EEpromCleanup __P((struct re_softc *)); static void re_eeprom_getword __P((struct re_softc *, int, u_int16_t *)); static void re_read_eeprom __P((struct re_softc *, caddr_t, int, int, int)); #ifndef __DragonFly__ static void re_int_task (void *, int); static void re_int_task_8125 (void *, int); #endif /* !__DragonFly__ */ static void re_phy_power_up(device_t dev); static void re_phy_power_down(device_t dev); #ifndef __DragonFly__ static int re_alloc_buf(struct re_softc *); 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 *); #endif /* !__DragonFly__ */ static u_int32_t re_eri_read(struct re_softc *, int, int, int); static int re_eri_write(struct re_softc *, int, int, u_int32_t, int); static void OOB_mutex_lock(struct re_softc *); static void OOB_mutex_unlock(struct re_softc *); #ifdef __DragonFly__ static u_int16_t MP_RealReadPhyOcpRegWord(struct re_softc*, u_int16_t); static void MP_RealWritePhyOcpRegWord(struct re_softc*, u_int16_t, u_int16_t); u_int16_t MP_ReadMcuAccessRegWord(struct re_softc *, u_int16_t); void MP_WriteMcuAccessRegWord(struct re_softc *, u_int16_t, u_int16_t); u_int16_t MP_ReadPhyOcpRegWord(struct re_softc *, u_int16_t, u_int8_t); void MP_WritePhyOcpRegWord(struct re_softc *, u_int16_t, u_int8_t, u_int16_t); void MP_WritePhyUshort(struct re_softc *, u_int8_t, u_int16_t); u_int16_t MP_ReadPhyUshort(struct re_softc *, u_int8_t); u_int32_t MP_ReadPciEConfigSpace(struct re_softc *, u_int16_t); void MP_WritePciEConfigSpace(struct re_softc *, u_int16_t, u_int32_t); u_int32_t MP_ReadOtherFunPciEConfigSpace(struct re_softc *, u_int8_t, u_int16_t); void MP_WriteOtherFunPciEConfigSpace(struct re_softc *, u_int8_t, u_int16_t, u_int32_t); static u_int8_t MP_ReadByteFun0PciEConfigSpace(struct re_softc*, u_int16_t); u_int16_t MP_ReadEPhyUshort(struct re_softc *, u_int8_t); void MP_WriteEPhyUshort(struct re_softc *, u_int8_t, u_int16_t); u_int8_t MP_ReadEfuse(struct re_softc *, u_int16_t); void re_driver_start(struct re_softc *); void re_driver_stop(struct re_softc *); static bool re_set_phy_mcu_patch_request(struct re_softc *); static bool re_clear_phy_mcu_patch_request(struct re_softc *); #endif /* __DragonFly__ */ static void re_hw_start_unlock(struct re_softc *sc); static void re_hw_start_unlock_8125(struct re_softc *sc); /* Tunables. */ static int msi_disable = 1; TUNABLE_INT("hw.re.msi_disable", &msi_disable); static int msix_disable = 0; TUNABLE_INT("hw.re.msix_disable", &msix_disable); static int prefer_iomap = 0; TUNABLE_INT("hw.re.prefer_iomap", &prefer_iomap); #ifdef ENABLE_EEE static int eee_enable = 1; #else static int eee_enable = 0; #endif TUNABLE_INT("hw.re.eee_enable", &eee_enable); static int phy_power_saving = 1; TUNABLE_INT("hw.re.phy_power_saving", &phy_power_saving); static int phy_mdix_mode = RE_ETH_PHY_AUTO_MDI_MDIX; TUNABLE_INT("hw.re.phy_mdix_mode", &phy_mdix_mode); #ifdef ENABLE_S5WOL static int s5wol = 1; #else static int s5wol = 0; TUNABLE_INT("hw.re.s5wol", &s5wol); #endif #ifdef ENABLE_S0_MAGIC_PACKET static int s0_magic_packet = 1; #else static int s0_magic_packet = 0; #endif TUNABLE_INT("hw.re.s0_magic_packet", &s0_magic_packet); #define RE_CSUM_FEATURES (CSUM_IP | CSUM_TCP | CSUM_UDP) #ifndef __DragonFly__ static device_method_t re_methods[] = { /* Device interface */ DEVMETHOD(device_probe, re_probe), DEVMETHOD(device_attach, re_attach), DEVMETHOD(device_detach, re_detach), DEVMETHOD(device_suspend, re_suspend), DEVMETHOD(device_resume, re_resume), DEVMETHOD(device_shutdown, re_shutdown), { 0, 0 } }; static driver_t re_driver = { "re", re_methods, sizeof(struct re_softc) }; static devclass_t re_devclass; DRIVER_MODULE(if_re, pci, re_driver, re_devclass, 0, 0); #endif /* !__DragonFly__ */ static void ClearAndSetEthPhyBit( struct re_softc *sc, u_int8_t addr, u_int16_t clearmask, u_int16_t setmask ) { u_int16_t PhyRegValue; PhyRegValue = MP_ReadPhyUshort(sc, addr); PhyRegValue &= ~clearmask; PhyRegValue |= setmask; MP_WritePhyUshort(sc, addr, PhyRegValue); } static void ClearEthPhyBit( struct re_softc *sc, u_int8_t addr, u_int16_t mask ) { ClearAndSetEthPhyBit(sc, addr, mask, 0 ); } static void SetEthPhyBit( struct re_softc *sc, u_int8_t addr, u_int16_t mask ) { ClearAndSetEthPhyBit(sc, addr, 0, mask ); } static void ClearAndSetEthPhyOcpBit( struct re_softc *sc, u_int16_t addr, u_int16_t clearmask, u_int16_t setmask ) { u_int16_t PhyRegValue; PhyRegValue = MP_RealReadPhyOcpRegWord(sc, addr); PhyRegValue &= ~clearmask; PhyRegValue |= setmask; MP_RealWritePhyOcpRegWord(sc, addr, PhyRegValue); } static void ClearEthPhyOcpBit( struct re_softc *sc, u_int16_t addr, u_int16_t mask ) { ClearAndSetEthPhyOcpBit(sc, addr, mask, 0 ); } static void SetEthPhyOcpBit( struct re_softc *sc, u_int16_t addr, u_int16_t mask ) { ClearAndSetEthPhyOcpBit(sc, addr, 0, mask ); } static void ClearAndSetMcuAccessRegBit( struct re_softc *sc, u_int16_t addr, u_int16_t clearmask, u_int16_t setmask ) { u_int16_t PhyRegValue; PhyRegValue = MP_ReadMcuAccessRegWord(sc, addr); PhyRegValue &= ~clearmask; PhyRegValue |= setmask; MP_WriteMcuAccessRegWord(sc, addr, PhyRegValue); } static void ClearMcuAccessRegBit( struct re_softc *sc, u_int16_t addr, u_int16_t mask ) { ClearAndSetMcuAccessRegBit(sc, addr, mask, 0 ); } static void SetMcuAccessRegBit( struct re_softc *sc, u_int16_t addr, u_int16_t mask ) { ClearAndSetMcuAccessRegBit(sc, addr, 0, mask ); } static void re_clear_phy_ups_reg(struct re_softc *sc) { switch(sc->re_type) { case MACFG_80: case MACFG_81: case MACFG_82: case MACFG_83: if (sc->re_type == MACFG_82 || sc->re_type == MACFG_83) ClearEthPhyOcpBit(sc, 0xA466, BIT_0); ClearEthPhyOcpBit(sc, 0xA468, BIT_3 | BIT_1); break; }; } static int re_is_ups_resume(struct re_softc *sc) { switch(sc->re_type) { case MACFG_80: case MACFG_81: case MACFG_82: case MACFG_83: return (MP_ReadMcuAccessRegWord(sc, 0xD42C) & BIT_8); default: return (MP_ReadMcuAccessRegWord(sc, 0xD408) & BIT_0); } } static void re_clear_ups_resume_bit(struct re_softc *sc) { switch(sc->re_type) { case MACFG_80: case MACFG_81: case MACFG_82: case MACFG_83: MP_WriteMcuAccessRegWord(sc, 0xD408, MP_ReadMcuAccessRegWord(sc, 0xD408) & ~(BIT_8)); break; default: MP_WriteMcuAccessRegWord(sc, 0xD408, MP_ReadMcuAccessRegWord(sc, 0xD408) & ~(BIT_0)); break; } } static void re_wait_phy_ups_resume(struct re_softc *sc, u_int16_t PhyState) { u_int16_t TmpPhyState; int i=0; switch(sc->re_type) { case MACFG_80: case MACFG_81: case MACFG_82: case MACFG_83: do { TmpPhyState = MP_RealReadPhyOcpRegWord(sc, 0xA420); TmpPhyState &= 0x7; DELAY(1000); i++; } while ((i < 100) && (TmpPhyState != 2)); break; default: do { TmpPhyState = MP_ReadPhyOcpRegWord(sc, 0x0A42, 0x10); TmpPhyState &= 0x7; DELAY(1000); i++; } while ((i < 100) && (TmpPhyState != 2)); break; }; } static void re_phy_power_up(device_t dev) { struct re_softc *sc; u_int8_t Data8; sc = device_get_softc(dev); if ((sc->re_if_flags & RL_FLAG_PHYWAKE_PM) != 0) CSR_WRITE_1(sc, RE_PMCH, CSR_READ_1(sc, RE_PMCH) | (BIT_6|BIT_7)); MP_WritePhyUshort(sc, 0x1F, 0x0000); switch (sc->re_type) { case MACFG_4: case MACFG_5: case MACFG_6: case MACFG_21: case MACFG_22: case MACFG_23: case MACFG_24: case MACFG_25: case MACFG_26: case MACFG_27: case MACFG_28: case MACFG_31: case MACFG_32: case MACFG_33: case MACFG_63: case MACFG_64: case MACFG_65: case MACFG_66: MP_WritePhyUshort(sc, 0x0e, 0x0000); break; case MACFG_56: case MACFG_57: case MACFG_58: case MACFG_61: Data8 = re_eri_read(sc, 0x1AB, 1, ERIAR_ExGMAC); Data8 |= (BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7); re_eri_write(sc, 0x1AB, 1, Data8, ERIAR_ExGMAC); break; default: break; }; MP_WritePhyUshort(sc, MII_BMCR, BMCR_AUTOEN); //wait mdc/mdio ready switch(sc->re_type) { case MACFG_61: case MACFG_62: case MACFG_67: DELAY(10000); break; } //wait ups resume (phy state 3) switch(sc->re_type) { case MACFG_68: case MACFG_69: case MACFG_70: case MACFG_71: case MACFG_72: case MACFG_80: case MACFG_81: case MACFG_82: case MACFG_83: re_wait_phy_ups_resume(sc, 3); break; }; } static u_int16_t re_get_phy_lp_ability(struct re_softc *sc) { u_int16_t anlpar; MP_WritePhyUshort(sc, 0x1F, 0x0000); anlpar = MP_ReadPhyUshort(sc, MII_ANLPAR); return anlpar; } static void re_phy_power_down(device_t dev) { struct re_softc *sc; u_int8_t Data8; sc = device_get_softc(dev); #ifdef ENABLE_FIBER_SUPPORT if (HW_FIBER_MODE_ENABLED(sc)) return; #endif //ENABLE_FIBER_SUPPORT if (sc->re_dash) { re_set_wol_linkspeed(sc); return; } MP_WritePhyUshort(sc, 0x1F, 0x0000); switch (sc->re_type) { case MACFG_21: case MACFG_22: case MACFG_23: case MACFG_24: case MACFG_25: case MACFG_26: case MACFG_27: case MACFG_28: case MACFG_31: case MACFG_32: case MACFG_33: case MACFG_63: case MACFG_64: case MACFG_65: case MACFG_66: MP_WritePhyUshort(sc, 0x0e, 0x0200); MP_WritePhyUshort(sc, MII_BMCR, (BMCR_AUTOEN|BMCR_PDOWN)); break; case MACFG_56: case MACFG_57: case MACFG_58: case MACFG_61: Data8 = re_eri_read(sc, 0x1AB, 1, ERIAR_ExGMAC); Data8 &= ~(BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7); re_eri_write(sc, 0x1AB, 1, Data8, ERIAR_ExGMAC); MP_WritePhyUshort(sc, MII_BMCR, (BMCR_AUTOEN|BMCR_PDOWN)); break; default: MP_WritePhyUshort(sc, MII_BMCR, (BMCR_AUTOEN|BMCR_PDOWN)); break; } switch (sc->re_type) { case MACFG_36: case MACFG_37: case MACFG_42: case MACFG_43: case MACFG_54: case MACFG_55: CSR_WRITE_1(sc, 0xD0, CSR_READ_1(sc, 0xD0) & ~BIT_6); break; case MACFG_38: case MACFG_39: case MACFG_50: case MACFG_51: case MACFG_52: 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: case MACFG_72: CSR_WRITE_1(sc, 0xD0, CSR_READ_1(sc, 0xD0) & ~BIT_6); CSR_WRITE_1(sc, 0xF2, CSR_READ_1(sc, 0xF2) & ~BIT_6); break; } if ((sc->re_if_flags & RL_FLAG_PHYWAKE_PM) != 0) CSR_WRITE_1(sc, RE_PMCH, CSR_READ_1(sc, RE_PMCH) & ~(BIT_6|BIT_7)); } #ifndef __DragonFly__ static void re_tx_dma_map_buf(void *arg, bus_dma_segment_t *segs, int nseg, int error) { union TxDesc *txptr = arg; if (error) { txptr->ul[0] &= ~htole32(RL_TDESC_CMD_BUFLEN); txptr->so1.TxBuffL = 0; txptr->so1.TxBuffH = 0; return; } txptr->so1.TxBuffL = htole32(RL_ADDR_LO(segs->ds_addr)); txptr->so1.TxBuffH = htole32(RL_ADDR_HI(segs->ds_addr)); } static void re_rx_dma_map_buf(void *arg, bus_dma_segment_t *segs, int nseg, int error) { union RxDesc *rxptr = arg; if (error) { rxptr->ul[0] &= ~htole32(RL_RDESC_CMD_BUFLEN); rxptr->so0.RxBuffL = 0; rxptr->so0.RxBuffH = 0; return; } rxptr->so0.RxBuffL = htole32(RL_ADDR_LO(segs->ds_addr)); rxptr->so0.RxBuffH = htole32(RL_ADDR_HI(segs->ds_addr)); } static void re_dma_map_rxdesc(void *arg, bus_dma_segment_t *segs, int nseg, int error) { struct re_softc *sc = arg; if (error) return; CSR_WRITE_4(sc, 0xe4, RL_ADDR_LO(segs->ds_addr)); CSR_WRITE_4(sc, 0xe8, RL_ADDR_HI(segs->ds_addr)); } static void re_dma_map_txdesc(void *arg, bus_dma_segment_t *segs, int nseg, int error) { struct re_softc *sc = arg; if (error) return; CSR_WRITE_4(sc, 0x20, RL_ADDR_LO(segs->ds_addr)); CSR_WRITE_4(sc, 0x24, RL_ADDR_HI(segs->ds_addr)); } /* * Probe for a RealTek 8129/8139 chip. Check the PCI vendor and device * IDs against our list and return a device name if we find a match. */ static int re_probe(dev) /* Search for Realtek NIC chip */ device_t dev; { struct re_type *t; t = re_devs; while (t->re_name != NULL) { if ((pci_get_vendor(dev) == t->re_vid) && (pci_get_device(dev) == t->re_did)) { device_set_desc(dev, t->re_name); return(0); } t++; } return(ENXIO); } #endif /* !__DragonFly__ */ 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; while (len > 0) { val_shift = addr % ERIAR_Addr_Align; addr = addr & ~0x3; CSR_WRITE_4(sc,RE_ERIAR, ERIAR_Read | transformed_base_address | type << ERIAR_Type_shift | ERIAR_ByteEn << ERIAR_ByteEn_shift | addr); for (i = 0; i < 10; i++) { DELAY(100); /* Check if the RTL8168 has completed ERI read */ if (CSR_READ_4(sc,RE_ERIAR) & ERIAR_Flag) break; } if (len == 1) mask = (0xFF << (val_shift * 8)) & 0xFFFFFFFF; else if (len == 2) mask = (0xFFFF << (val_shift * 8)) & 0xFFFFFFFF; else if (len == 3) mask = (0xFFFFFF << (val_shift * 8)) & 0xFFFFFFFF; else mask = (0xFFFFFFFF << (val_shift * 8)) & 0xFFFFFFFF; value1 = CSR_READ_4(sc,RE_ERIDR) & mask; value2 |= (value1 >> val_shift * 8) << shift * 8; if (len <= 4 - val_shift) len = 0; else { len -= (4 - val_shift); shift = 4 - val_shift; addr += 4; } } return value2; } 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; while (len > 0) { val_shift = addr % ERIAR_Addr_Align; addr = addr & ~0x3; if (len == 1) mask = (0xFF << (val_shift * 8)) & 0xFFFFFFFF; else if (len == 2) mask = (0xFFFF << (val_shift * 8)) & 0xFFFFFFFF; else if (len == 3) mask = (0xFFFFFF << (val_shift * 8)) & 0xFFFFFFFF; else mask = (0xFFFFFFFF << (val_shift * 8)) & 0xFFFFFFFF; 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); for (i = 0; i < 10; i++) { DELAY(100); /* Check if the RTL8168 has completed ERI write */ if (!(CSR_READ_4(sc,RE_ERIAR) & ERIAR_Flag)) break; } if (len <= 4 - val_shift) len = 0; else { len -= (4 - val_shift); shift = 4 - val_shift; addr += 4; } } 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); } #ifndef __DragonFly__ static void re_release_rx_buf(struct re_softc *sc) { struct ifnet *ifp; int i; ifp = RE_GET_IFNET(sc); if (sc->re_desc.re_rx_mtag) { for (i = 0; i < RE_RX_BUF_NUM; i++) { if (sc->re_desc.rx_buf[i]!=NULL) { bus_dmamap_sync(sc->re_desc.re_rx_mtag, sc->re_desc.re_rx_dmamap[i], BUS_DMASYNC_POSTREAD); bus_dmamap_unload(sc->re_desc.re_rx_mtag, sc->re_desc.re_rx_dmamap[i]); bus_dmamap_destroy(sc->re_desc.re_rx_mtag, sc->re_desc.re_rx_dmamap[i]); m_freem(sc->re_desc.rx_buf[i]); sc->re_desc.rx_buf[i] =NULL; } } bus_dma_tag_destroy(sc->re_desc.re_rx_mtag); sc->re_desc.re_rx_mtag =0; } } static void re_release_tx_buf(struct re_softc *sc) { struct ifnet *ifp; int i; ifp = RE_GET_IFNET(sc); if (sc->re_desc.re_tx_mtag) { for (i = 0; i < RE_TX_BUF_NUM; i++) { bus_dmamap_destroy(sc->re_desc.re_tx_mtag, sc->re_desc.re_tx_dmamap[i]); m_freem(sc->re_desc.tx_buf[i]); } bus_dma_tag_destroy(sc->re_desc.re_tx_mtag); sc->re_desc.re_tx_mtag = 0; } } static void re_release_buf(struct re_softc *sc) { re_release_rx_buf(sc); re_release_tx_buf(sc); } static int re_alloc_buf(struct re_softc *sc) { int error =0; int i,size; error = bus_dma_tag_create(sc->re_parent_tag, 1, 0, BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR, NULL, NULL, MCLBYTES * RE_NTXSEGS, RE_NTXSEGS, 4096, 0, NULL, NULL, &sc->re_desc.re_tx_mtag); if (error) { //device_printf(dev,"re_tx_mtag fail\n"); //goto fail; return error; } error = bus_dma_tag_create( sc->re_parent_tag, RE_RX_BUFFER_ALIGN, 0, /* alignment, boundary */ BUS_SPACE_MAXADDR, /* lowaddr */ BUS_SPACE_MAXADDR, /* highaddr */ NULL, NULL, /* filter, filterarg */ sc->re_rx_desc_buf_sz, 1, /* maxsize,nsegments */ sc->re_rx_desc_buf_sz, /* maxsegsize */ 0, /* flags */ NULL, NULL, /* lockfunc, lockarg */ &sc->re_desc.re_rx_mtag); if (error) { //device_printf(dev,"re_rx_mtag fail\n"); //goto fail; return error; } if (sc->re_rx_mbuf_sz <= MCLBYTES) size = MCLBYTES; else if (sc->re_rx_mbuf_sz <= MJUMPAGESIZE) size = MJUMPAGESIZE; else size =MJUM9BYTES; for (i = 0; i < RE_RX_BUF_NUM; i++) { sc->re_desc.rx_buf[i] = m_getjcl(M_DONTWAIT, MT_DATA, M_PKTHDR, size); if (!sc->re_desc.rx_buf[i]) { //device_printf(dev, "m_getcl fail!!!\n"); error = ENXIO; //goto fail; return error; } sc->re_desc.rx_buf[i]->m_len = sc->re_desc.rx_buf[i]->m_pkthdr.len = size; #ifdef RE_FIXUP_RX /* * This is part of an evil trick to deal with non-x86 platforms. * The RealTek chip requires RX buffers to be aligned on 64-bit * boundaries, but that will hose non-x86 machines. To get around * this, we leave some empty space at the start of each buffer * and for non-x86 hosts, we copy the buffer back six bytes * to achieve word alignment. This is slightly more efficient * than allocating a new buffer, copying the contents, and * discarding the old buffer. */ m_adj(sc->re_desc.rx_buf[i], RE_ETHER_ALIGN); #endif error = bus_dmamap_create(sc->re_desc.re_rx_mtag, BUS_DMA_NOWAIT, &sc->re_desc.re_rx_dmamap[i]); if (error) { //device_printf(dev, "bus_dmamap_create fail!!!\n"); //goto fail; return error; } } for (i = 0; i < RE_TX_BUF_NUM; i++) { error = bus_dmamap_create(sc->re_desc.re_tx_mtag, BUS_DMA_NOWAIT, &sc->re_desc.re_tx_dmamap[i]); if (error) { //device_printf(dev, "bus_dmamap_create fail!!!\n"); //goto fail; return error; } } return 0; } static void set_rxbufsize(struct re_softc *sc) { //printf("set size\n"); struct ifnet *ifp; ifp = RE_GET_IFNET(sc); sc->re_rx_desc_buf_sz = (ifp->if_mtu > ETHERMTU) ? ifp->if_mtu: ETHERMTU; sc->re_rx_desc_buf_sz += (ETHER_VLAN_ENCAP_LEN + ETHER_HDR_LEN + ETHER_CRC_LEN + 1); CSR_WRITE_2(sc, RE_RxMaxSize, sc->re_rx_desc_buf_sz); } #endif /* !__DragonFly__ */ static void re_enable_cfg9346_write(struct re_softc *sc) { EE_SET(RE_EEMODE_WRITECFG); } static void re_disable_cfg9346_write(struct re_softc *sc) { EE_CLR(RE_EEMODE_WRITECFG); } static void DisableMcuBPs(struct re_softc *sc) { switch(sc->re_type) { case MACFG_68: case MACFG_69: case MACFG_70: case MACFG_71: case MACFG_72: case MACFG_80: case MACFG_81: case MACFG_82: case MACFG_83: MP_WriteMcuAccessRegWord(sc, 0xFC38, 0x0000); break; } switch(sc->re_type) { 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: case MACFG_72: 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); re_disable_cfg9346_write(sc); MP_WriteMcuAccessRegWord(sc, 0xFC28, 0x0000); MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x0000); MP_WriteMcuAccessRegWord(sc, 0xFC2C, 0x0000); MP_WriteMcuAccessRegWord(sc, 0xFC2E, 0x0000); MP_WriteMcuAccessRegWord(sc, 0xFC30, 0x0000); MP_WriteMcuAccessRegWord(sc, 0xFC32, 0x0000); MP_WriteMcuAccessRegWord(sc, 0xFC34, 0x0000); MP_WriteMcuAccessRegWord(sc, 0xFC36, 0x0000); DELAY(3000); 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_set_mac_mcu_8168fp_3(struct re_softc *sc) { DisableMcuBPs(sc); MP_WriteMcuAccessRegWord(sc, 0xF800, 0xE008); MP_WriteMcuAccessRegWord(sc, 0xF802, 0xE00A); MP_WriteMcuAccessRegWord(sc, 0xF804, 0xE00F); MP_WriteMcuAccessRegWord(sc, 0xF806, 0xE014); MP_WriteMcuAccessRegWord(sc, 0xF808, 0xE016); MP_WriteMcuAccessRegWord(sc, 0xF80A, 0xE018); MP_WriteMcuAccessRegWord(sc, 0xF80C, 0xE01A); MP_WriteMcuAccessRegWord(sc, 0xF80E, 0xE01C); MP_WriteMcuAccessRegWord(sc, 0xF810, 0xC602); MP_WriteMcuAccessRegWord(sc, 0xF812, 0xBE00); MP_WriteMcuAccessRegWord(sc, 0xF814, 0x2AB2); MP_WriteMcuAccessRegWord(sc, 0xF816, 0x1BC0); MP_WriteMcuAccessRegWord(sc, 0xF818, 0x46EB); MP_WriteMcuAccessRegWord(sc, 0xF81A, 0x1BFE); MP_WriteMcuAccessRegWord(sc, 0xF81C, 0xC102); MP_WriteMcuAccessRegWord(sc, 0xF81E, 0xB900); MP_WriteMcuAccessRegWord(sc, 0xF820, 0x0B1A); MP_WriteMcuAccessRegWord(sc, 0xF822, 0x1BC0); MP_WriteMcuAccessRegWord(sc, 0xF824, 0x46EB); MP_WriteMcuAccessRegWord(sc, 0xF826, 0x1B7E); MP_WriteMcuAccessRegWord(sc, 0xF828, 0xC102); MP_WriteMcuAccessRegWord(sc, 0xF82A, 0xB900); MP_WriteMcuAccessRegWord(sc, 0xF82C, 0x0BEA); MP_WriteMcuAccessRegWord(sc, 0xF82E, 0xC602); MP_WriteMcuAccessRegWord(sc, 0xF830, 0xBE00); MP_WriteMcuAccessRegWord(sc, 0xF832, 0x0000); MP_WriteMcuAccessRegWord(sc, 0xF834, 0xC602); MP_WriteMcuAccessRegWord(sc, 0xF836, 0xBE00); MP_WriteMcuAccessRegWord(sc, 0xF838, 0x0000); MP_WriteMcuAccessRegWord(sc, 0xF83A, 0xC602); MP_WriteMcuAccessRegWord(sc, 0xF83C, 0xBE00); MP_WriteMcuAccessRegWord(sc, 0xF83E, 0x0000); MP_WriteMcuAccessRegWord(sc, 0xF840, 0xC602); MP_WriteMcuAccessRegWord(sc, 0xF842, 0xBE00); MP_WriteMcuAccessRegWord(sc, 0xF844, 0x0000); MP_WriteMcuAccessRegWord(sc, 0xF846, 0xC602); MP_WriteMcuAccessRegWord(sc, 0xF848, 0xBE00); MP_WriteMcuAccessRegWord(sc, 0xF84A, 0x0000); MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000); MP_WriteMcuAccessRegWord(sc, 0xFC28, 0x2AAC); MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x0B14); MP_WriteMcuAccessRegWord(sc, 0xFC2C, 0x0BE4); if (sc->hw_hw_supp_serdes_phy_ver == 1) { MP_WriteMcuAccessRegWord(sc, 0xFC38, 0x0007); } else { MP_WriteMcuAccessRegWord(sc, 0xFC38, 0x0006); } } static void re_set_mac_mcu_8168fp_4(struct re_softc *sc) { DisableMcuBPs(sc); } static void re_set_mac_mcu_8125a_1(struct re_softc *sc) { DisableMcuBPs(sc); } static void re_set_mac_mcu_8125a_2(struct re_softc *sc) { u_int16_t i; static const u_int16_t mcu_patch_code_8125a_2[] = { 0xE008, 0xE01E, 0xE02E, 0xE054, 0xE057, 0xE059, 0xE0C2, 0xE0CB, 0x9996, 0x49D1, 0xF005, 0x49D4, 0xF10A, 0x49D8, 0xF108, 0xC00F, 0x7100, 0x209C, 0x249C, 0xC009, 0x9900, 0xE004, 0xC006, 0x1900, 0x9900, 0xC602, 0xBE00, 0x5A48, 0xE0C2, 0x0004, 0xE10A, 0xC60F, 0x73C4, 0x49B3, 0xF106, 0x73C2, 0xC608, 0xB406, 0xC609, 0xFF80, 0xC605, 0xB406, 0xC605, 0xFF80, 0x0544, 0x0568, 0xE906, 0xCDE8, 0xC724, 0xC624, 0x9EE2, 0x1E01, 0x9EE0, 0x76E0, 0x49E0, 0xF1FE, 0x76E6, 0x486D, 0x4868, 0x9EE4, 0x1E03, 0x9EE0, 0x76E0, 0x49E0, 0xF1FE, 0xC615, 0x9EE2, 0x1E01, 0x9EE0, 0x76E0, 0x49E0, 0xF1FE, 0x76E6, 0x486F, 0x9EE4, 0x1E03, 0x9EE0, 0x76E0, 0x49E0, 0xF1FE, 0x7196, 0xC702, 0xBF00, 0x5A44, 0xEB0E, 0x0070, 0x00C3, 0x1BC0, 0xC602, 0xBE00, 0x0E26, 0xC602, 0xBE00, 0x0EBA, 0x1501, 0xF02A, 0x1500, 0xF15D, 0xC661, 0x75C8, 0x49D5, 0xF00A, 0x49D6, 0xF008, 0x49D7, 0xF006, 0x49D8, 0xF004, 0x75D2, 0x49D9, 0xF150, 0xC553, 0x77A0, 0x75C8, 0x4855, 0x4856, 0x4857, 0x4858, 0x48DA, 0x48DB, 0x49FE, 0xF002, 0x485A, 0x49FF, 0xF002, 0x485B, 0x9DC8, 0x75D2, 0x4859, 0x9DD2, 0xC643, 0x75C0, 0x49D4, 0xF033, 0x49D0, 0xF137, 0xE030, 0xC63A, 0x75C8, 0x49D5, 0xF00E, 0x49D6, 0xF00C, 0x49D7, 0xF00A, 0x49D8, 0xF008, 0x75D2, 0x49D9, 0xF005, 0xC62E, 0x75C0, 0x49D7, 0xF125, 0xC528, 0x77A0, 0xC627, 0x75C8, 0x4855, 0x4856, 0x4857, 0x4858, 0x48DA, 0x48DB, 0x49FE, 0xF002, 0x485A, 0x49FF, 0xF002, 0x485B, 0x9DC8, 0x75D2, 0x4859, 0x9DD2, 0xC616, 0x75C0, 0x4857, 0x9DC0, 0xC613, 0x75C0, 0x49DA, 0xF003, 0x49D0, 0xF107, 0xC60B, 0xC50E, 0x48D9, 0x9DC0, 0x4859, 0x9DC0, 0xC608, 0xC702, 0xBF00, 0x3AE0, 0xE860, 0xB400, 0xB5D4, 0xE908, 0xE86C, 0x1200, 0xC409, 0x6780, 0x48F1, 0x8F80, 0xC404, 0xC602, 0xBE00, 0x10AA, 0xC010, 0xEA7C, 0xC602, 0xBE00, 0x0000 }; DisableMcuBPs(sc); for (i = 0; i < ARRAY_SIZE(mcu_patch_code_8125a_2); i++) { MP_WriteMcuAccessRegWord(sc, 0xF800 + i * 2, mcu_patch_code_8125a_2[i]); } MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000); MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x0540); MP_WriteMcuAccessRegWord(sc, 0xFC2E, 0x0E24); MP_WriteMcuAccessRegWord(sc, 0xFC30, 0x0EB8); MP_WriteMcuAccessRegWord(sc, 0xFC32, 0x3A5C); MP_WriteMcuAccessRegWord(sc, 0xFC34, 0x10A8); MP_WriteMcuAccessRegWord(sc, 0xFC48, 0x007A); } static void re_set_mac_mcu_8125b_1(struct re_softc *sc) { DisableMcuBPs(sc); } static void re_set_mac_mcu_8125b_2(struct re_softc *sc) { u_int16_t i; static const u_int16_t mcu_patch_code_8125b_2[] = { 0xE008, 0xE013, 0xE01E, 0xE02F, 0xE035, 0xE04F, 0xE053, 0xE055, 0x740A, 0x4846, 0x4847, 0x9C0A, 0xC607, 0x74C0, 0x48C6, 0x9CC0, 0xC602, 0xBE00, 0x13F0, 0xE054, 0x72CA, 0x4826, 0x4827, 0x9ACA, 0xC607, 0x72C0, 0x48A6, 0x9AC0, 0xC602, 0xBE00, 0x081C, 0xE054, 0xC60F, 0x74C4, 0x49CC, 0xF109, 0xC60C, 0x74CA, 0x48C7, 0x9CCA, 0xC609, 0x74C0, 0x4846, 0x9CC0, 0xC602, 0xBE00, 0x2494, 0xE092, 0xE0C0, 0xE054, 0x7420, 0x48C0, 0x9C20, 0x7444, 0xC602, 0xBE00, 0x12DC, 0x733A, 0x21B5, 0x25BC, 0x1304, 0xF111, 0x1B12, 0x1D2A, 0x3168, 0x3ADA, 0x31AB, 0x1A00, 0x9AC0, 0x1300, 0xF1FB, 0x7620, 0x236E, 0x276F, 0x1A3C, 0x22A1, 0x41B5, 0x9EE2, 0x76E4, 0x486F, 0x9EE4, 0xC602, 0xBE00, 0x4A26, 0x733A, 0x49BB, 0xC602, 0xBE00, 0x47A2, 0xC602, 0xBE00, 0x0000, 0xC602, 0xBE00, 0x0000 }; DisableMcuBPs(sc); for (i = 0; i < ARRAY_SIZE(mcu_patch_code_8125b_2); i++) { MP_WriteMcuAccessRegWord(sc, 0xF800 + i * 2, mcu_patch_code_8125b_2[i]); } MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000); MP_WriteMcuAccessRegWord(sc, 0xFC28, 0x13E6); MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x0812); MP_WriteMcuAccessRegWord(sc, 0xFC2C, 0x248C); MP_WriteMcuAccessRegWord(sc, 0xFC2E, 0x12DA); MP_WriteMcuAccessRegWord(sc, 0xFC30, 0x4A20); MP_WriteMcuAccessRegWord(sc, 0xFC32, 0x47A0); MP_WriteMcuAccessRegWord(sc, 0xFC48, 0x003F); } static void re_hw_mac_mcu_config(struct re_softc *sc) { switch(sc->re_type) { case MACFG_56: re_set_mac_mcu_8168g_1(sc); break; case MACFG_58: re_set_mac_mcu_8168gu_1(sc); break; case MACFG_59: re_set_mac_mcu_8168gu_2(sc); break; case MACFG_60: re_set_mac_mcu_8411b_1(sc); break; case MACFG_62: re_set_mac_mcu_8168ep_1(sc); break; case MACFG_67: 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: re_set_mac_mcu_8168fp_3(sc); break; case MACFG_72: re_set_mac_mcu_8168fp_4(sc); break; case MACFG_80: re_set_mac_mcu_8125a_1(sc); break; case MACFG_81: re_set_mac_mcu_8125a_2(sc); break; case MACFG_82: re_set_mac_mcu_8125b_1(sc); break; case MACFG_83: re_set_mac_mcu_8125b_2(sc); break; } } #define ISRIMR_DASH_TYPE2_TX_DISABLE_IDLE BIT_5 static void Dash2DisableTx(struct re_softc *sc) { //if (!sc->re_dash) return; if (HW_DASH_SUPPORT_TYPE_2(sc) || HW_DASH_SUPPORT_TYPE_3(sc)) { u_int16_t WaitCnt; u_int8_t TmpUchar; //Disable oob Tx 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 = RE_CMAC_READ_1(sc, RE_CMAC_IBISR0); if (TmpUchar & ISRIMR_DASH_TYPE2_TX_DISABLE_IDLE) { break; } DELAY(50); WaitCnt++; } while(WaitCnt < 2000); //Clear 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 (!sc->re_dash) return; 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 (HW_DASH_SUPPORT_TYPE_2(sc) || HW_DASH_SUPPORT_TYPE_3(sc)) { Dash2DisableTx(sc); Dash2DisableRx(sc); } } static inline bool is_zero_ether_addr(const u_int8_t * addr) { return ((addr[0] + addr[1] + addr[2] + addr[3] + addr[4] + addr[5]) == 0x00); } static inline bool is_multicast_ether_addr(const u_int8_t * addr) { return (0x01 & addr[0]); } /* static inline bool is_broadcast_ether_addr(const u_int8_t * addr) { return ((addr[0] + addr[1] + addr[2] + addr[3] + addr[4] + addr[5]) == (6 * 0xff)); } */ static inline bool is_valid_ether_addr(const u_int8_t * addr) { return !is_multicast_ether_addr(addr) && !is_zero_ether_addr(addr); } static inline void random_ether_addr(u_int8_t * dst) { #ifndef __DragonFly__ if (read_random(dst, 6) == 0) arc4rand(dst, 6, 0); #else karc4random_buf(dst, 6); #endif dst[0] &= 0xfe; dst[0] |= 0x02; } static void re_disable_now_is_oob(struct re_softc *sc) { if (sc->re_hw_supp_now_is_oob_ver == 1) CSR_WRITE_1(sc, RE_MCU_CMD, CSR_READ_1(sc, RE_MCU_CMD) & ~RE_NOW_IS_OOB); } static void re_switch_to_sgmii_mode(struct re_softc *sc) { if (FALSE == HW_SUPP_SERDES_PHY(sc)) return; switch (sc->hw_hw_supp_serdes_phy_ver) { case 1: MP_WriteMcuAccessRegWord(sc, 0xEB00, 0x2); SetMcuAccessRegBit(sc, 0xEB16, BIT_1); break; } } static void re_enable_magic_packet(struct re_softc *sc) { if (sc->re_if_flags & RL_FLAG_MAGIC_PACKET_V3) SetMcuAccessRegBit(sc, 0xC0B6, BIT_0); else if (sc->re_if_flags & RL_FLAG_MAGIC_PACKET_V2) re_eri_write(sc, 0xDC, 4, re_eri_read(sc, 0xDC, 4, ERIAR_ExGMAC) | BIT_16, ERIAR_ExGMAC); else CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) | RL_CFG3_WOL_MAGIC); } static void re_disable_magic_packet(struct re_softc *sc) { if (sc->re_if_flags & RL_FLAG_MAGIC_PACKET_V3) ClearMcuAccessRegBit(sc, 0xC0B6, BIT_0); else if (sc->re_if_flags & RL_FLAG_MAGIC_PACKET_V2) re_eri_write(sc, 0xDC, 4, re_eri_read(sc, 0xDC, 4, ERIAR_ExGMAC) & ~BIT_16, ERIAR_ExGMAC); else CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~RL_CFG3_WOL_MAGIC); } static void re_exit_oob(struct re_softc *sc) { u_int16_t data16; int i; re_disable_cfg9346_write(sc); if (HW_SUPP_SERDES_PHY(sc)) { if (sc->hw_hw_supp_serdes_phy_ver == 1) { re_switch_to_sgmii_mode(sc); } } switch(sc->re_type) { case MACFG_61: case MACFG_62: case MACFG_67: case MACFG_70: case MACFG_71: case MACFG_72: Dash2DisableTxRx(sc); break; } if (sc->re_dash) re_driver_start(sc); switch(sc->re_type) { 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: case MACFG_72: CSR_WRITE_1(sc, 0xF2, CSR_READ_1(sc, 0xF2) | BIT_3); DELAY(2000); for (i = 0; i < 3000; i++) { DELAY(50); if (CSR_READ_4(sc, RE_TXCFG) & BIT_11) break; } if (CSR_READ_1(sc, RE_COMMAND) & (RE_CMD_TX_ENB | RE_CMD_RX_ENB)) { DELAY(100); CSR_WRITE_1(sc, RE_COMMAND, CSR_READ_1(sc, RE_COMMAND) & ~(RE_CMD_TX_ENB | RE_CMD_RX_ENB)); } for (i = 0; i < 3000; i++) { DELAY(50); if ((CSR_READ_1(sc, RE_MCU_CMD) & (RE_TXFIFO_EMPTY | RE_RXFIFO_EMPTY)) == (RE_TXFIFO_EMPTY | RE_RXFIFO_EMPTY)) break; } break; case MACFG_80: case MACFG_81: case MACFG_82: case MACFG_83: CSR_WRITE_1(sc, 0xF2, CSR_READ_1(sc, 0xF2) | BIT_3); DELAY(2000); if (CSR_READ_1(sc, RE_COMMAND) & (RE_CMD_TX_ENB | RE_CMD_RX_ENB)) { DELAY(100); CSR_WRITE_1(sc, RE_COMMAND, CSR_READ_1(sc, RE_COMMAND) & ~(RE_CMD_TX_ENB | RE_CMD_RX_ENB)); } for (i = 0; i < 3000; i++) { DELAY(50); if ((CSR_READ_1(sc, RE_MCU_CMD) & (RE_TXFIFO_EMPTY | RE_RXFIFO_EMPTY)) == (RE_TXFIFO_EMPTY | RE_RXFIFO_EMPTY)) break; } if (sc->re_type == MACFG_82 || sc->re_type == MACFG_83) { for (i = 0; i < 3000; i++) { DELAY(50); if ((CSR_READ_2(sc, RE_IntrMitigate) & (BIT_0 | BIT_1 | BIT_8)) == (BIT_0 | BIT_1 | BIT_8)) break; } } break; } //Disable realwow function switch (sc->re_type) { case MACFG_50: case MACFG_51: CSR_WRITE_4(sc, RE_MCUACCESS, 0xE5A90000); CSR_WRITE_4(sc, RE_MCUACCESS, 0xF2100010); break; case MACFG_52: CSR_WRITE_4(sc, RE_MCUACCESS, 0xE5A90000); CSR_WRITE_4(sc, RE_MCUACCESS, 0xE4640000); CSR_WRITE_4(sc, RE_MCUACCESS, 0xF2100010); break; case MACFG_56: case MACFG_57: CSR_WRITE_4(sc, RE_MCUACCESS, 0x605E0000); CSR_WRITE_4(sc, RE_MCUACCESS, (0xE05E << 16) | (CSR_READ_4(sc, RE_MCUACCESS) & 0xFFFE)); CSR_WRITE_4(sc, RE_MCUACCESS, 0xE9720000); CSR_WRITE_4(sc, RE_MCUACCESS, 0xF2140010); break; case MACFG_60: CSR_WRITE_4(sc, RE_MCUACCESS, 0xE05E00FF); CSR_WRITE_4(sc, RE_MCUACCESS, 0xE9720000); MP_WriteMcuAccessRegWord(sc, 0xE428, 0x0010); break; } if (sc->re_hw_supp_now_is_oob_ver >0) re_disable_now_is_oob(sc); switch(sc->re_type) { case MACFG_52: for (i = 0; i < 10; i++) { DELAY(100); if (CSR_READ_2(sc, 0xD2) & BIT_9) break; } data16 = MP_ReadMcuAccessRegWord(sc, 0xD4DE) | BIT_15; MP_WriteMcuAccessRegWord(sc, 0xD4DE, data16); for (i = 0; i < 10; i++) { DELAY(100); if (CSR_READ_2(sc, 0xD2) & BIT_9) break; } 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: case MACFG_72: data16 = MP_ReadMcuAccessRegWord(sc, 0xE8DE) & ~BIT_14; MP_WriteMcuAccessRegWord(sc, 0xE8DE, data16); for (i = 0; i < 10; i++) { DELAY(100); if (CSR_READ_2(sc, 0xD2) & BIT_9) break; } data16 = MP_ReadMcuAccessRegWord(sc, 0xE8DE) | BIT_15; MP_WriteMcuAccessRegWord(sc, 0xE8DE, data16); for (i = 0; i < 10; i++) { DELAY(100); if (CSR_READ_2(sc, 0xD2) & BIT_9) break; } break; case MACFG_80: case MACFG_81: case MACFG_82: case MACFG_83: data16 = MP_ReadMcuAccessRegWord(sc, 0xE8DE) & ~BIT_14; MP_WriteMcuAccessRegWord(sc, 0xE8DE, data16); for (i = 0; i < 10; i++) { DELAY(100); if (CSR_READ_2(sc, 0xD2) & BIT_9) break; } MP_WriteMcuAccessRegWord(sc, 0xC0AA, 0x07D0); MP_WriteMcuAccessRegWord(sc, 0xC0A6, 0x01B5); MP_WriteMcuAccessRegWord(sc, 0xC01E, 0x5555); for (i = 0; i < 10; i++) { DELAY(100); if (CSR_READ_2(sc, 0xD2) & BIT_9) break; } break; } //wait ups resume (phy state 2) switch(sc->re_type) { case MACFG_68: case MACFG_69: case MACFG_70: case MACFG_71: case MACFG_72: case MACFG_80: case MACFG_81: case MACFG_82: case MACFG_83: if (re_is_ups_resume(sc)) { re_wait_phy_ups_resume(sc, 2); re_clear_ups_resume_bit(sc); re_clear_phy_ups_reg(sc); } break; }; /* * Config MAC MCU */ re_hw_mac_mcu_config(sc); } static void re_hw_init(struct re_softc *sc) { /* * disable EDT. */ switch(sc->re_type) { case MACFG_16: case MACFG_17: case MACFG_18: case MACFG_19: case MACFG_41: CSR_WRITE_1(sc, 0xF4, CSR_READ_1(sc, 0xF4) & ~(BIT_0|BIT_1)); break; 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_54: case MACFG_55: CSR_WRITE_1(sc, 0xF2, CSR_READ_1(sc, 0xF2) & ~(BIT_0|BIT_1|BIT_2)); break; } if (s0_magic_packet == 0) re_disable_magic_packet(sc); else re_enable_magic_packet(sc); switch(sc->re_type) { case MACFG_5: if (CSR_READ_1(sc, RE_CFG2) & 1) { CSR_WRITE_4(sc, 0x7C, 0x000FFFFF); } else { CSR_WRITE_4(sc, 0x7C, 0x000FFF00); } break; case MACFG_6: if (CSR_READ_1(sc, RE_CFG2) & 1) { CSR_WRITE_4(sc, 0x7C, 0x003FFFFF); } else { CSR_WRITE_4(sc, 0x7C, 0x003FFF00); } break; } switch(sc->re_type) { case MACFG_33: case MACFG_36: case MACFG_37: CSR_WRITE_1(sc, 0xF3, CSR_READ_1(sc, 0xF3) | BIT_2); 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: case MACFG_72: case MACFG_80: case MACFG_81: case MACFG_82: case MACFG_83: 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); re_disable_cfg9346_write(sc); break; } if (sc->re_if_flags & RL_FLAG_PCIE) { uint32_t Data32; //Set PCIE uncorrectable error status mask pcie 0x108 Data32 = MP_ReadPciEConfigSpace(sc, 0xF108); Data32 |= BIT_20; MP_WritePciEConfigSpace(sc, 0xF108, Data32); } } 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; 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: 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: case MACFG_72: *(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_80: case MACFG_81: case MACFG_82: case MACFG_83: *(u_int32_t *)&eaddr[0] = CSR_READ_4(sc, RE_BACKUP_ADDR0_8125); *(u_int16_t *)&eaddr[4] = CSR_READ_2(sc, RE_BACKUP_ADDR4_8125); break; case MACFG_63: case MACFG_64: case MACFG_65: case MACFG_66: 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); break; } if (!is_valid_ether_addr(eaddr)) { #ifndef __DragonFly__ device_printf(dev,"Invalid ether addr: %6D\n", eaddr, ":"); #else device_printf(dev, "Invalid ether addr: " "%02x:%02x:%02x:%02x:%02x:%02x\n", eaddr[0], eaddr[1], eaddr[2], eaddr[3], eaddr[4], eaddr[5]); #endif random_ether_addr(eaddr); #ifndef __DragonFly__ device_printf(dev,"Random ether addr: %6D\n", eaddr, ":"); #else device_printf(dev, "Random ether addr: " "%02x:%02x:%02x:%02x:%02x:%02x\n", eaddr[0], eaddr[1], eaddr[2], eaddr[3], eaddr[4], eaddr[5]); #endif } re_rar_set(sc, eaddr); } static int re_check_mac_version(struct re_softc *sc) { device_t dev = sc->dev; int error = 0; switch(CSR_READ_4(sc, RE_TXCFG) & 0xFCF00000) { case 0x00800000: case 0x04000000: sc->re_type = MACFG_3; sc->max_jumbo_frame_size = Jumbo_Frame_7k; CSR_WRITE_4(sc, RE_RXCFG, 0xFF00); break; case 0x10000000: sc->re_type = MACFG_4; sc->max_jumbo_frame_size = Jumbo_Frame_7k; CSR_WRITE_4(sc, RE_RXCFG, 0xFF00); break; case 0x18000000: sc->re_type = MACFG_5; sc->max_jumbo_frame_size = Jumbo_Frame_7k; CSR_WRITE_4(sc, RE_RXCFG, 0xFF00); break; case 0x98000000: sc->re_type = MACFG_6; sc->max_jumbo_frame_size = Jumbo_Frame_7k; CSR_WRITE_4(sc, RE_RXCFG, 0xFF00); break; case 0x34000000: case 0xB4000000: sc->re_type = MACFG_11; sc->max_jumbo_frame_size = ETHERMTU; CSR_WRITE_4(sc, RE_RXCFG, 0xE700); break; case 0x34200000: case 0xB4200000: sc->re_type = MACFG_12; sc->max_jumbo_frame_size = ETHERMTU; CSR_WRITE_4(sc, RE_RXCFG, 0xE700); break; case 0x34300000: case 0xB4300000: sc->re_type = MACFG_13; sc->max_jumbo_frame_size = ETHERMTU; CSR_WRITE_4(sc, RE_RXCFG, 0xE700); break; case 0x34900000: case 0x24900000: sc->re_type = MACFG_14; sc->max_jumbo_frame_size = ETHERMTU; sc->re_if_flags |= RL_FLAG_DESCV2; CSR_WRITE_4(sc, RE_RXCFG, 0xE700); break; case 0x34A00000: case 0x24A00000: sc->re_type = MACFG_15; sc->max_jumbo_frame_size = ETHERMTU; sc->re_if_flags |= RL_FLAG_DESCV2; CSR_WRITE_4(sc, RE_RXCFG, 0xE700); break; case 0x34B00000: case 0x24B00000: sc->re_type = MACFG_16; sc->max_jumbo_frame_size = ETHERMTU; sc->re_if_flags |= RL_FLAG_DESCV2; CSR_WRITE_4(sc, RE_RXCFG, 0xE700); break; case 0x34C00000: case 0x24C00000: sc->re_type = MACFG_17; sc->max_jumbo_frame_size = ETHERMTU; sc->re_if_flags |= RL_FLAG_DESCV2; CSR_WRITE_4(sc, RE_RXCFG, 0xE700); break; case 0x34D00000: case 0x24D00000: sc->re_type = MACFG_18; sc->max_jumbo_frame_size = ETHERMTU; sc->re_if_flags |= RL_FLAG_DESCV2; CSR_WRITE_4(sc, RE_RXCFG, 0xE700); break; case 0x34E00000: case 0x24E00000: sc->re_type = MACFG_19; sc->max_jumbo_frame_size = ETHERMTU; sc->re_if_flags |= RL_FLAG_DESCV2; CSR_WRITE_4(sc, RE_RXCFG, 0xE700); break; case 0x30000000: sc->re_type = MACFG_21; sc->max_jumbo_frame_size = Jumbo_Frame_4k; CSR_WRITE_4(sc, RE_RXCFG, 0xE700); break; case 0x38000000: sc->re_type = MACFG_22; sc->max_jumbo_frame_size = Jumbo_Frame_4k; CSR_WRITE_4(sc, RE_RXCFG, 0xE700); break; case 0x38500000: case 0xB8500000: case 0x38700000: case 0xB8700000: sc->re_type = MACFG_23; sc->max_jumbo_frame_size = Jumbo_Frame_4k; CSR_WRITE_4(sc, RE_RXCFG, 0xE700); break; case 0x3C000000: sc->re_type = MACFG_24; sc->max_jumbo_frame_size = Jumbo_Frame_6k; sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM; CSR_WRITE_4(sc, RE_RXCFG, 0xC700); break; case 0x3C200000: sc->re_type = MACFG_25; sc->max_jumbo_frame_size = Jumbo_Frame_6k; sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM; CSR_WRITE_4(sc, RE_RXCFG, 0xC700); break; case 0x3C400000: sc->re_type = MACFG_26; sc->max_jumbo_frame_size = Jumbo_Frame_6k; sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM; CSR_WRITE_4(sc, RE_RXCFG, 0xC700); break; case 0x3C900000: sc->re_type = MACFG_27; sc->max_jumbo_frame_size = Jumbo_Frame_6k; sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM; CSR_WRITE_4(sc, RE_RXCFG, 0xC700); break; case 0x3CB00000: sc->re_type = MACFG_28; sc->max_jumbo_frame_size = Jumbo_Frame_6k; sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM; CSR_WRITE_4(sc, RE_RXCFG, 0xC700); break; case 0x28100000: sc->re_type = MACFG_31; sc->max_jumbo_frame_size = Jumbo_Frame_9k; sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM; CSR_WRITE_4(sc, RE_RXCFG, 0x8700); break; case 0x28200000: sc->re_type = MACFG_32; sc->max_jumbo_frame_size = Jumbo_Frame_9k; sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM; CSR_WRITE_4(sc, RE_RXCFG, 0x8700); break; case 0x28300000: sc->re_type = MACFG_33; sc->max_jumbo_frame_size = Jumbo_Frame_9k; sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM; CSR_WRITE_4(sc, RE_RXCFG, 0x8700); break; case 0x2C100000: sc->re_type = MACFG_36; sc->max_jumbo_frame_size = Jumbo_Frame_9k; sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM; CSR_WRITE_4(sc, RE_RXCFG, 0x8700); break; case 0x2C200000: sc->re_type = MACFG_37; sc->max_jumbo_frame_size = Jumbo_Frame_9k; sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM; CSR_WRITE_4(sc, RE_RXCFG, 0x8700); break; case 0x2C800000: sc->re_type = MACFG_38; 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, 0xBF00); break; case 0x2C900000: sc->re_type = MACFG_39; 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, 0xBF00); break; case 0x24000000: sc->re_type = MACFG_41; sc->max_jumbo_frame_size = ETHERMTU; 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; CSR_WRITE_4(sc, RE_RXCFG, 0xE700); break; case 0x40A00000: case 0x40B00000: case 0x40C00000: sc->re_type = MACFG_43; sc->max_jumbo_frame_size = ETHERMTU; sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM; CSR_WRITE_4(sc, RE_RXCFG, 0xE700); break; case 0x48000000: sc->re_type = MACFG_50; 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, 0xBF00); break; case 0x48100000: sc->re_type = MACFG_51; 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, 0xBF00); break; case 0x48800000: sc->re_type = MACFG_52; 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, 0xBF00); break; case 0x44000000: sc->re_type = MACFG_53; sc->max_jumbo_frame_size = ETHERMTU; sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2; CSR_WRITE_4(sc, RE_RXCFG, 0xE700); break; case 0x44800000: sc->re_type = MACFG_54; sc->max_jumbo_frame_size = ETHERMTU; sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM; CSR_WRITE_4(sc, RE_RXCFG, 0xE700); break; case 0x44900000: sc->re_type = MACFG_55; sc->max_jumbo_frame_size = ETHERMTU; sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM; CSR_WRITE_4(sc, RE_RXCFG, 0xE700); break; case 0x4C000000: sc->re_type = MACFG_56; 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 0x4C100000: sc->re_type = MACFG_57; 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 0x50800000: sc->re_type = MACFG_58; 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 0x50900000: sc->re_type = MACFG_59; 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 0x5C800000: sc->re_type = MACFG_60; 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 0x50000000: sc->re_type = MACFG_61; 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 0x50100000: sc->re_type = MACFG_62; 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 0x50200000: sc->re_type = MACFG_67; 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 0x28800000: sc->re_type = MACFG_63; sc->max_jumbo_frame_size = Jumbo_Frame_9k; sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM; CSR_WRITE_4(sc, RE_RXCFG, 0x8700); break; case 0x28900000: sc->re_type = MACFG_64; sc->max_jumbo_frame_size = Jumbo_Frame_9k; sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM; CSR_WRITE_4(sc, RE_RXCFG, 0x8700); break; case 0x28A00000: sc->re_type = MACFG_65; sc->max_jumbo_frame_size = Jumbo_Frame_9k; sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM; CSR_WRITE_4(sc, RE_RXCFG, 0x8700); break; case 0x28B00000: sc->re_type = MACFG_66; sc->max_jumbo_frame_size = Jumbo_Frame_9k; sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM; CSR_WRITE_4(sc, RE_RXCFG, 0x8700); break; case 0x54000000: sc->re_type = MACFG_68; 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 0x54100000: sc->re_type = MACFG_69; 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 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; case 0x54B00000: sc->re_type = MACFG_72; 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 0x60800000: sc->re_type = MACFG_80; sc->max_jumbo_frame_size = Jumbo_Frame_9k; sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V3; CSR_WRITE_4(sc, RE_RXCFG, 0x40C00000); break; case 0x60900000: sc->re_type = MACFG_81; sc->max_jumbo_frame_size = Jumbo_Frame_9k; sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V3; CSR_WRITE_4(sc, RE_RXCFG, 0x40C00000); break; case 0x64000000: sc->re_type = MACFG_82; sc->max_jumbo_frame_size = Jumbo_Frame_9k; sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V3; CSR_WRITE_4(sc, RE_RXCFG, 0x40C00000); break; case 0x64100000: sc->re_type = MACFG_83; sc->max_jumbo_frame_size = Jumbo_Frame_9k; sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V3; CSR_WRITE_4(sc, RE_RXCFG, 0x40C00000); break; default: device_printf(dev,"unknown device\n"); sc->re_type = MACFG_FF; error = ENXIO; break; } switch(sc->re_device_id) { case RT_DEVICEID_8169: case RT_DEVICEID_8169SC: case RT_DEVICEID_8168: case RT_DEVICEID_8161: case RT_DEVICEID_8125: //do nothing break; default: sc->max_jumbo_frame_size = ETHERMTU; break; } return error; } static void re_init_software_variable(struct re_softc *sc) { switch(sc->re_device_id) { case RT_DEVICEID_8168: case RT_DEVICEID_8161: case RT_DEVICEID_8136: case RT_DEVICEID_8125: sc->re_if_flags |= RL_FLAG_PCIE; break; } sc->re_rx_mbuf_sz = sc->max_jumbo_frame_size + ETHER_VLAN_ENCAP_LEN + ETHER_HDR_LEN + ETHER_CRC_LEN + RE_ETHER_ALIGN + 1; if (sc->re_rx_mbuf_sz > MJUM9BYTES) { sc->max_jumbo_frame_size -= (sc->re_rx_mbuf_sz - MJUM9BYTES); 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: case MACFG_72: sc->HwSuppDashVer = 3; break; default: sc->HwSuppDashVer = 0; break; } switch(sc->re_type) { case MACFG_70: case MACFG_71: case MACFG_72: sc->HwPkgDet = MP_ReadMcuAccessRegWord(sc, 0xDC00); sc->HwPkgDet = (sc->HwPkgDet >> 3) & 0x0F; break; } switch(sc->re_type) { case MACFG_71: case MACFG_72: if (sc->HwPkgDet == 0x06) { u_int8_t tmpUchar = re_eri_read(sc, 0xE6, 1, ERIAR_ExGMAC); if (tmpUchar == 0x02) sc->hw_hw_supp_serdes_phy_ver = 1; else if (tmpUchar == 0x00) sc->hw_hw_supp_serdes_phy_ver = 2; } break; } if (HW_SUPP_SERDES_PHY(sc)) eee_enable = 0; if (HW_DASH_SUPPORT_DASH(sc)) sc->re_dash = re_check_dash(sc); if (sc->re_dash) { if (HW_DASH_SUPPORT_TYPE_3(sc)) { u_int64_t CmacMemPhysAddress; bus_space_handle_t cmac_ioaddr; CmacMemPhysAddress = MP_ReadOtherFunPciEConfigSpace(sc, 0, 0xf018); if (!(CmacMemPhysAddress & BIT_0)) { if (CmacMemPhysAddress & BIT_2) CmacMemPhysAddress |= MP_ReadOtherFunPciEConfigSpace(sc, 0, 0xf01c) << 16; CmacMemPhysAddress &= 0xFFFFFFF0; /* ioremap MMIO region */ #ifndef __DragonFly__ sc->re_mapped_cmac_tag = X86_BUS_SPACE_MEM; #else sc->re_mapped_cmac_tag = X86_64_BUS_SPACE_MEM; #endif if (bus_space_map(sc->re_mapped_cmac_tag, CmacMemPhysAddress, RE_REGS_SIZE, 0, &cmac_ioaddr)) sc->re_dash = 0; else sc->re_mapped_cmac_handle = cmac_ioaddr; } } } switch(sc->re_type) { case MACFG_61: case MACFG_62: case MACFG_67: sc->re_cmac_handle = sc->re_bhandle; sc->re_cmac_tag = sc->re_btag; break; case MACFG_70: case MACFG_71: case MACFG_72: 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: case MACFG_72: sc->re_efuse_ver = EFUSE_SUPPORT_V3; break; case MACFG_80: case MACFG_81: case MACFG_82: case MACFG_83: sc->re_efuse_ver = EFUSE_SUPPORT_V4; break; default: sc->re_efuse_ver = EFUSE_NOT_SUPPORT; break; } switch(sc->re_type) { case MACFG_69: { u_int16_t ioffset_p3, ioffset_p2, ioffset_p1, ioffset_p0; u_int16_t TmpUshort; MP_WriteMcuAccessRegWord(sc, 0xDD02, 0x807D); TmpUshort = MP_ReadMcuAccessRegWord(sc, 0xDD02); ioffset_p3 = ((TmpUshort & BIT_7) >>7); ioffset_p3 <<= 3; TmpUshort = MP_ReadMcuAccessRegWord(sc, 0xDD00); ioffset_p3 |= ((TmpUshort & (BIT_15 | BIT_14 | BIT_13))>>13); ioffset_p2 = ((TmpUshort & (BIT_12|BIT_11|BIT_10|BIT_9))>>9); ioffset_p1 = ((TmpUshort & (BIT_8|BIT_7|BIT_6|BIT_5))>>5); ioffset_p0 = ((TmpUshort & BIT_4) >>4); ioffset_p0 <<= 3; ioffset_p0 |= (TmpUshort & (BIT_2| BIT_1 | BIT_0)); if ((ioffset_p3 == 0x0F) && (ioffset_p2 == 0x0F) && (ioffset_p1 == 0x0F) && (ioffset_p0 == 0x0F)) { sc->RequireAdcBiasPatch = FALSE; } else { sc->RequireAdcBiasPatch = TRUE; sc->AdcBiasPatchIoffset = (ioffset_p3<<12)|(ioffset_p2<<8)|(ioffset_p1<<4)|(ioffset_p0); } } break; } switch(sc->re_type) { case MACFG_68: case MACFG_69: case MACFG_70: case MACFG_71: case MACFG_72: { u_int16_t rg_saw_cnt; MP_WritePhyUshort(sc, 0x1F, 0x0C42); rg_saw_cnt = MP_ReadPhyUshort(sc, 0x13); rg_saw_cnt &= ~(BIT_15|BIT_14); MP_WritePhyUshort(sc, 0x1F, 0x0000); if (rg_saw_cnt > 0) { sc->SwrCnt1msIni = 16000000/rg_saw_cnt; sc->SwrCnt1msIni &= 0x0FFF; sc->RequireAdjustUpsTxLinkPulseTiming = TRUE; } } break; } #ifdef ENABLE_FIBER_SUPPORT re_check_hw_fiber_mode_support(sc); #endif //ENABLE_FIBER_SUPPORT switch(sc->re_type) { case MACFG_31: case MACFG_32: case MACFG_33: 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_63: case MACFG_64: case MACFG_65: case MACFG_66: case MACFG_67: case MACFG_68: case MACFG_69: case MACFG_70: case MACFG_71: case MACFG_72: case MACFG_80: case MACFG_81: case MACFG_82: case MACFG_83: sc->re_hw_enable_msi_msix = TRUE; break; } switch(sc->re_type) { case MACFG_3: case MACFG_4: case MACFG_5: case MACFG_6: case MACFG_11: case MACFG_12: case MACFG_13: case MACFG_21: case MACFG_22: case MACFG_23: case MACFG_24: case MACFG_25: case MACFG_26: case MACFG_27: case MACFG_28: case MACFG_41: case MACFG_42: case MACFG_43: #ifdef __DragonFly__ case MACFG_50: #endif case MACFG_54: case MACFG_55: sc->re_coalesce_tx_pkt = TRUE; #ifdef __DragonFly__ if (sc->re_type != MACFG_50) sc->re_pad_runt = TRUE; #endif 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: case MACFG_72: case MACFG_80: case MACFG_81: case MACFG_82: case MACFG_83: 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: case MACFG_72: sc->re_sw_ram_code_ver = NIC_RAMCODE_VERSION_8168FP; break; case MACFG_80: sc->re_sw_ram_code_ver = NIC_RAMCODE_VERSION_8125A_REV_A; break; case MACFG_81: sc->re_sw_ram_code_ver = NIC_RAMCODE_VERSION_8125A_REV_B; break; case MACFG_82: sc->re_sw_ram_code_ver = NIC_RAMCODE_VERSION_8125B_REV_A; break; case MACFG_83: sc->re_sw_ram_code_ver = NIC_RAMCODE_VERSION_8125B_REV_B; break; } switch (sc->re_type) { case MACFG_81: if ((MP_ReadMcuAccessRegWord(sc, 0xD442) & BIT_5) && (MP_RealReadPhyOcpRegWord(sc, 0xD068) & BIT_1) ) { sc->RequirePhyMdiSwapPatch = TRUE; } break; } sc->re_8169_MacVersion = (CSR_READ_4(sc, RE_TXCFG)&0x7c800000)>>25; /* Get bit 26~30 */ sc->re_8169_MacVersion |= ((CSR_READ_4(sc, RE_TXCFG)&0x00800000)!=0 ? 1:0); /* Get bit 23 */ DBGPRINT1(sc->re_unit,"8169 Mac Version %d",sc->re_8169_MacVersion); /* Rtl8169s single chip detected */ if (sc->re_type == MACFG_3) { RE_LOCK(sc); sc->re_8169_PhyVersion=(MP_ReadPhyUshort(sc, 0x03)&0x000f); DBGPRINT1(sc->re_unit,"8169 Phy Version %d",sc->re_8169_PhyVersion); RE_UNLOCK(sc); } #ifndef __DragonFly__ sc->link_state = LINK_STATE_UNKNOWN; #endif #ifdef ENABLE_FIBER_SUPPORT if (HW_FIBER_MODE_ENABLED(sc)) re_set_fiber_mode_software_variable(sc); #endif //ENABLE_FIBER_SUPPORT } static void re_enable_ocp_phy_power_saving(struct re_softc *sc) { u_int16_t val; if (sc->re_type == MACFG_59 || sc->re_type == MACFG_60 || sc->re_type == MACFG_62 || sc->re_type == MACFG_67 || sc->re_type == MACFG_68 || sc->re_type == MACFG_69 || sc->re_type == MACFG_70 || sc->re_type == MACFG_71 || sc->re_type == MACFG_72) { val = MP_ReadPhyOcpRegWord(sc, 0x0C41, 0x13); if (val != 0x0050) { re_set_phy_mcu_patch_request(sc); MP_WritePhyOcpRegWord(sc, 0x0C41, 0x13, 0x0000); MP_WritePhyOcpRegWord(sc, 0x0C41, 0x13, 0x0050); re_clear_phy_mcu_patch_request(sc); } } else if (sc->re_type == MACFG_80 || sc->re_type == MACFG_81 || sc->re_type == MACFG_82 || sc->re_type == MACFG_83) { val = MP_RealReadPhyOcpRegWord(sc, 0xC416); if (val != 0x0050) { re_set_phy_mcu_patch_request(sc); MP_RealWritePhyOcpRegWord(sc, 0xC416, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xC416, 0x0050); re_clear_phy_mcu_patch_request(sc); } } } static void re_disable_ocp_phy_power_saving(struct re_softc *sc) { u_int16_t val; if (sc->re_type == MACFG_59 || sc->re_type == MACFG_60 || sc->re_type == MACFG_62 || sc->re_type == MACFG_67 || sc->re_type == MACFG_68 || sc->re_type == MACFG_69 || sc->re_type == MACFG_70 || sc->re_type == MACFG_71 || sc->re_type == MACFG_72) { val = MP_ReadPhyOcpRegWord(sc, 0x0C41, 0x13); if (val != 0x0500) { re_set_phy_mcu_patch_request(sc); MP_WritePhyOcpRegWord(sc, 0x0C41, 0x13, 0x0000); MP_WritePhyOcpRegWord(sc, 0x0C41, 0x13, 0x0500); re_clear_phy_mcu_patch_request(sc); } } else if (sc->re_type == MACFG_80 || sc->re_type == MACFG_81 || sc->re_type == MACFG_82 || sc->re_type == MACFG_83) { val = MP_RealReadPhyOcpRegWord(sc, 0xC416); if (val != 0x0500) { re_set_phy_mcu_patch_request(sc); MP_RealWritePhyOcpRegWord(sc, 0xC416, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xC416, 0x0500); re_clear_phy_mcu_patch_request(sc); } } } static void re_hw_d3_para(struct re_softc *sc) { switch (sc->re_type) { case MACFG_59: case MACFG_60: case MACFG_62: case MACFG_67: case MACFG_68: case MACFG_69: case MACFG_70: case MACFG_71: case MACFG_72: case MACFG_80: case MACFG_81: case MACFG_82: case MACFG_83: re_disable_ocp_phy_power_saving(sc); break; } } #ifndef __DragonFly__ /* * Attach the interface. Allocate softc structures, do ifmedia * setup and ethernet/BPF attach. */ static int re_attach(device_t dev) { /*int s;*/ u_char eaddr[ETHER_ADDR_LEN]; u_int32_t command; struct re_softc *sc; struct ifnet *ifp; int unit, error = 0, rid, i; // int mac_version; // int mode; // u_int8_t data8; int reg; int msic=0, msixc=0; /*s = splimp();*/ sc = device_get_softc(dev); unit = device_get_unit(dev); bzero(sc, sizeof(struct re_softc)); RE_LOCK_INIT(sc,device_get_nameunit(dev)); sc->dev = dev; sc->driver_detach = 0; sc->re_vendor_id = pci_get_vendor(dev); sc->re_device_id = pci_get_device(dev); sc->re_subvendor_id = pci_get_subvendor(dev); sc->re_subdevice_id = pci_get_subdevice(dev); sc->re_revid = pci_get_revid(dev); pci_enable_busmaster(dev); /* * Map control/status registers. */ command = pci_read_config(dev, PCIR_COMMAND, 4); command |= (PCIM_CMD_PORTEN|PCIM_CMD_MEMEN|PCIM_CMD_BUSMASTEREN); pci_write_config(dev, PCIR_COMMAND, command, 4); command = pci_read_config(dev, PCIR_COMMAND, 4); if (prefer_iomap == 0) { sc->re_res_id = PCIR_BAR(1); sc->re_res_type = SYS_RES_MEMORY; /* PCIE NIC use different BARs. */ if (sc->re_device_id == RT_DEVICEID_8168 || sc->re_device_id == RT_DEVICEID_8161 || sc->re_device_id == RT_DEVICEID_8136 || sc->re_device_id == RT_DEVICEID_8125) sc->re_res_id = PCIR_BAR(2); } else { sc->re_res_id = PCIR_BAR(0); sc->re_res_type = SYS_RES_IOPORT; } sc->re_res = bus_alloc_resource(dev, sc->re_res_type, &sc->re_res_id, 0, ~0, 1, RF_ACTIVE); if (sc->re_res == NULL && prefer_iomap == 0) { sc->re_res_id = PCIR_BAR(0); sc->re_res_type = SYS_RES_IOPORT; sc->re_res = bus_alloc_resource(dev, sc->re_res_type, &sc->re_res_id, 0, ~0, 1, RF_ACTIVE); } if (sc->re_res == NULL) { device_printf(dev,"couldn't map ports/memory\n"); error = ENXIO; goto fail; } if (sc->re_res_type == SYS_RES_IOPORT) device_printf(dev, "Using I/O Ports\n"); else device_printf(dev, "Using Memory Mapping!\n"); sc->re_btag = rman_get_bustag(sc->re_res); sc->re_bhandle = rman_get_bushandle(sc->re_res); error = re_check_mac_version(sc); if (error) { goto fail; } re_init_software_variable(sc); #if OS_VER >= VERSION(7,0) msic = pci_msi_count(dev); msixc = pci_msix_count(dev); if (pci_find_cap(dev, PCIY_EXPRESS, ®) == 0) { sc->re_if_flags |= RL_FLAG_PCIE; sc->re_expcap = reg; } else { sc->re_if_flags &= ~RL_FLAG_PCIE; sc->re_expcap = 0; } //device_printf(dev, "MSI count : %d\n", msic); //device_printf(dev, "MSI-X count : %d\n", msixc); if (sc->re_hw_enable_msi_msix == FALSE) { msixc = 0; msic = 0; } if (msix_disable > 0) msixc = 0; if (msi_disable > 0) msic = 0; /* Prefer MSI-X to MSI. */ if (msixc > 0) { rid = PCIR_BAR(4); msixc = RL_MSI_MESSAGES; sc->re_res_pba = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid, RF_ACTIVE); if (sc->re_res_pba == NULL) { device_printf(dev, "could not allocate MSI-X PBA resource\n"); } if (sc->re_res_pba != NULL && pci_alloc_msix(dev, &msixc) == 0) { if (msixc == RL_MSI_MESSAGES) { device_printf(dev, "Using %d MSI-X message\n", msixc); sc->re_if_flags |= RL_FLAG_MSIX; } else pci_release_msi(dev); } if ((sc->re_if_flags & RL_FLAG_MSIX) == 0) { if (sc->re_res_pba != NULL) bus_release_resource(dev, SYS_RES_MEMORY, rid, sc->re_res_pba); sc->re_res_pba = NULL; msixc = 0; } } /* Prefer MSI to INTx. */ if (msixc == 0 && msic > 0) { msic = RL_MSI_MESSAGES; if (pci_alloc_msi(dev, &msic) == 0) { if (msic == RL_MSI_MESSAGES) { device_printf(dev, "Using %d MSI message\n", msic); sc->re_if_flags |= RL_FLAG_MSI; } else pci_release_msi(dev); } if ((sc->re_if_flags & RL_FLAG_MSI) == 0) msic = 0; } #endif //OS_VER >= VERSION(7,0) if ((sc->re_if_flags & (RL_FLAG_MSI | RL_FLAG_MSIX)) == 0) { rid = 0; sc->re_irq = bus_alloc_resource(dev, SYS_RES_IRQ, &rid, 0, ~0, 1, RF_SHAREABLE | RF_ACTIVE); if (sc->re_irq == NULL) { device_printf(dev,"couldn't map interrupt\n"); error = ENXIO; goto fail; } device_printf(dev, "Using line-based interrupt\n"); } else { rid = 1; sc->re_irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid, RF_ACTIVE); if (sc->re_irq == NULL) { device_printf(dev, "couldn't allocate IRQ resources for " "message %d\n", rid); error = ENXIO; goto fail; } } #if OS_VER >= VERSION(7,3) /* Disable ASPM L0S/L1 and Clock Request. */ if (sc->re_expcap != 0) { u_int32_t cap, ctl; cap = pci_read_config(dev, sc->re_expcap + RE_PCIER_LINK_CAP, 2); if ((cap & RE_PCIEM_LINK_CAP_ASPM) != 0) { ctl = pci_read_config(dev, sc->re_expcap + RE_PCIER_LINK_CTL, 2); if ((ctl & 0x0103) != 0) { ctl &= ~0x0103; pci_write_config(dev, sc->re_expcap + RE_PCIER_LINK_CTL, ctl, 2); device_printf(dev, "ASPM disabled\n"); } } else device_printf(dev, "no ASPM capability\n"); } #endif //OS_VER >= VERSION(7,3) re_init_timer(sc); RE_LOCK(sc); re_exit_oob(sc); re_hw_init(sc); RE_UNLOCK(sc); /* * Reset the adapter. Only take the lock here as it's needed in * order to call re_reset(). */ RE_LOCK(sc); re_reset(sc); 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:%s\n", RE_VERSION); 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"); sc->re_unit = unit; #if OS_VER < VERSION(6,0) bcopy(eaddr, (char *)&sc->arpcom.ac_enaddr, ETHER_ADDR_LEN); #endif if (sc->re_type == MACFG_3) { /* Change PCI Latency time*/ pci_write_config(dev, RE_PCI_LATENCY_TIMER, 0x40, 1); } error = bus_dma_tag_create( #if OS_VER < VERSION(7,0) NULL, #else bus_get_dma_tag(dev), /* parent */ #endif 1, 0, /* alignment, boundary */ BUS_SPACE_MAXADDR, /* lowaddr */ BUS_SPACE_MAXADDR, /* highaddr */ NULL, NULL, /* filter, filterarg */ BUS_SPACE_MAXSIZE_32BIT, /* maxsize */ 0, /* nsegments */ BUS_SPACE_MAXSIZE_32BIT, /* maxsegsize */ 0, /* flags */ NULL, NULL, /* lockfunc, lockarg */ &sc->re_parent_tag); i = roundup2(sizeof(union RxDesc)*RE_RX_BUF_NUM, RE_DESC_ALIGN); error = bus_dma_tag_create( sc->re_parent_tag, RE_DESC_ALIGN, 0, /* alignment, boundary */ BUS_SPACE_MAXADDR, /* lowaddr */ BUS_SPACE_MAXADDR, /* highaddr */ NULL, NULL, /* filter, filterarg */ i, /* maxsize */ 1, /* nsegments */ i, /* maxsegsize */ 0, /* flags */ NULL, NULL, /* lockfunc, lockarg */ &sc->re_desc.rx_desc_tag); if (error) { device_printf(dev,"bus_dma_tag_create fail\n"); goto fail; } error = bus_dmamem_alloc(sc->re_desc.rx_desc_tag, (void**) &sc->re_desc.rx_desc, BUS_DMA_WAITOK|BUS_DMA_COHERENT|BUS_DMA_ZERO, &sc->re_desc.rx_desc_dmamap); if (error) { device_printf(dev,"bus_dmamem_alloc fail\n"); goto fail; } i = roundup2(sizeof(union TxDesc)*RE_TX_BUF_NUM, RE_DESC_ALIGN); error = bus_dma_tag_create( sc->re_parent_tag, RE_DESC_ALIGN, 0, /* alignment, boundary */ BUS_SPACE_MAXADDR, /* lowaddr */ BUS_SPACE_MAXADDR, /* highaddr */ NULL, NULL, /* filter, filterarg */ i, /* maxsize */ 1, /* nsegments */ i, /* maxsegsize */ 0, /* flags */ NULL, NULL, /* lockfunc, lockarg */ &sc->re_desc.tx_desc_tag); if (error) { device_printf(dev,"bus_dma_tag_create fail\n"); goto fail; } error = bus_dmamem_alloc(sc->re_desc.tx_desc_tag, (void**) &sc->re_desc.tx_desc, BUS_DMA_WAITOK|BUS_DMA_COHERENT|BUS_DMA_ZERO, &sc->re_desc.tx_desc_dmamap); if (error) { device_printf(dev,"bus_dmamem_alloc fail\n"); goto fail; } sc->re_tx_cstag =1; sc->re_rx_cstag =1; #if OS_VER < VERSION(6,0) ifp = &sc->arpcom.ac_if; #else ifp = sc->re_ifp = if_alloc(IFT_ETHER); if (ifp == NULL) { device_printf(dev, "can not if_alloc()\n"); error = ENOSPC; goto fail; } #endif ifp->if_softc = sc; #if OS_VER < VERSION(5,3) ifp->if_unit = unit; ifp->if_name = "re"; #else if_initname(ifp, device_get_name(dev), device_get_unit(dev)); #endif ifp->if_mtu = ETHERMTU; ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; ifp->if_ioctl = re_ioctl; ifp->if_output = ether_output; ifp->if_start = re_start; #if OS_VER < VERSION(7,0) ifp->if_watchdog = re_watchdog; #endif if ((sc->re_type == MACFG_24) || (sc->re_type == MACFG_25) || (sc->re_type == MACFG_26)) ifp->if_hwassist |= CSUM_TCP | CSUM_UDP; else ifp->if_hwassist |= RE_CSUM_FEATURES; ifp->if_capabilities = IFCAP_HWCSUM; ifp->if_capenable = ifp->if_capabilities; ifp->if_init = re_init; /* VLAN capability setup */ ifp->if_capabilities |= IFCAP_VLAN_MTU | IFCAP_VLAN_HWTAGGING; ifp->if_capenable = ifp->if_capabilities; /* Enable WOL if PM is supported. */ if (pci_find_cap(sc->dev, PCIY_PMG, ®) == 0) ifp->if_capabilities |= IFCAP_WOL; ifp->if_capenable = ifp->if_capabilities; ifp->if_capenable &= ~(IFCAP_WOL_UCAST | IFCAP_WOL_MCAST); RE_LOCK(sc); re_phy_power_up(dev); re_hw_phy_config(sc); re_clrwol(sc); set_rxbufsize(sc); error =re_alloc_buf(sc); if (error) { RE_UNLOCK(sc); goto fail; } /* Init descriptors. */ re_var_init(sc); RE_UNLOCK(sc); switch(sc->re_device_id) { case RT_DEVICEID_8125: ifp->if_baudrate = 25000000000; break; case RT_DEVICEID_8169: case RT_DEVICEID_8169SC: case RT_DEVICEID_8168: case RT_DEVICEID_8161: ifp->if_baudrate = 1000000000; break; default: ifp->if_baudrate = 100000000; break; } IFQ_SET_MAXLEN(&ifp->if_snd, IFQ_MAXLEN); ifp->if_snd.ifq_drv_maxlen = IFQ_MAXLEN; IFQ_SET_READY(&ifp->if_snd); if (sc->re_device_id == RT_DEVICEID_8125) { sc->ifmedia_upd = re_ifmedia_upd_8125; sc->ifmedia_sts = re_ifmedia_sts_8125; sc->intr = re_intr_8125; sc->int_task = re_int_task_8125; sc->hw_start_unlock = re_hw_start_unlock_8125; } else { sc->ifmedia_upd = re_ifmedia_upd; sc->ifmedia_sts = re_ifmedia_sts; sc->intr = re_intr; sc->int_task = re_int_task; sc->hw_start_unlock = re_hw_start_unlock; } #if OS_VER>=VERSION(7,0) TASK_INIT(&sc->re_inttask, 0, sc->int_task, sc); #endif /* * Call MI attach routine. */ /*#if OS_VER < VERSION(5, 1)*/ #if OS_VER < VERSION(4,9) ether_ifattach(ifp, ETHER_BPF_SUPPORTED); #else ether_ifattach(ifp, eaddr); #endif #if OS_VER < VERSION(7,0) error = bus_setup_intr(dev, sc->re_irq, INTR_TYPE_NET, sc->intr, sc, &sc->re_intrhand); #else error = bus_setup_intr(dev, sc->re_irq, INTR_TYPE_NET|INTR_MPSAFE, sc->intr, NULL, sc, &sc->re_intrhand); #endif if (error) { #if OS_VER < VERSION(4,9) ether_ifdetach(ifp, ETHER_BPF_SUPPORTED); #else ether_ifdetach(ifp); #endif device_printf(dev,"couldn't set up irq\n"); goto fail; } /* * Specify the media types supported by this adapter and register * callbacks to update media and link information */ ifmedia_init(&sc->media, IFM_IMASK, sc->ifmedia_upd, sc->ifmedia_sts); ifmedia_add(&sc->media, IFM_ETHER | IFM_10_T, 0, NULL); ifmedia_add(&sc->media, IFM_ETHER | IFM_10_T | IFM_FDX, 0, NULL); ifmedia_add(&sc->media, IFM_ETHER | IFM_100_TX, 0, NULL); ifmedia_add(&sc->media, IFM_ETHER | IFM_100_TX | IFM_FDX, 0, NULL); switch(sc->re_device_id) { case RT_DEVICEID_8125: case RT_DEVICEID_8169: case RT_DEVICEID_8169SC: case RT_DEVICEID_8168: case RT_DEVICEID_8161: ifmedia_add(&sc->media, IFM_ETHER | IFM_1000_T | IFM_FDX, 0, NULL); //ifmedia_add(&sc->media, IFM_ETHER | IFM_1000_T, 0, NULL); break; default: break; } switch(sc->re_device_id) { case RT_DEVICEID_8125: ifmedia_add(&sc->media, IFM_ETHER | IFM_2500_T | IFM_FDX, 0, NULL); break; default: break; } ifmedia_add(&sc->media, IFM_ETHER | IFM_AUTO, 0, NULL); ifmedia_set(&sc->media, IFM_ETHER | IFM_AUTO); sc->media.ifm_media = IFM_ETHER | IFM_AUTO; sc->ifmedia_upd(ifp); fail: if (error) re_detach(dev); return(error); } static int re_detach(device_t dev) { struct re_softc *sc; struct ifnet *ifp; /*int s;*/ int i; int rid; /*s = splimp();*/ sc = device_get_softc(dev); ifp = RE_GET_IFNET(sc); /* These should only be active if attach succeeded */ if (device_is_attached(dev)) { RE_LOCK(sc); re_stop(sc); RE_UNLOCK(sc); #if OS_VER>=VERSION(7,0) taskqueue_drain(taskqueue_fast, &sc->re_inttask); #endif #if OS_VER < VERSION(4,9) ether_ifdetach(ifp, ETHER_BPF_SUPPORTED); #else ether_ifdetach(ifp); #endif } bus_generic_detach(dev); sc->driver_detach = 1; if (sc->re_intrhand) bus_teardown_intr(dev, sc->re_irq, sc->re_intrhand); #if OS_VER>=VERSION(6,0) if (ifp) if_free(ifp); #endif if ((sc->re_if_flags & (RL_FLAG_MSI | RL_FLAG_MSIX)) == 0) rid = 0; else rid = 1; if (sc->re_irq) { bus_release_resource(dev, SYS_RES_IRQ, rid, sc->re_irq); sc->re_irq = NULL; } if ((sc->re_if_flags & (RL_FLAG_MSI | RL_FLAG_MSIX)) != 0) pci_release_msi(dev); if (sc->re_res_pba) { rid = PCIR_BAR(4); bus_release_resource(dev, SYS_RES_MEMORY, rid, sc->re_res_pba); } 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) { bus_dmamap_sync(sc->re_desc.re_rx_mtag, sc->re_desc.re_rx_dmamap[i], BUS_DMASYNC_POSTREAD); bus_dmamap_unload(sc->re_desc.re_rx_mtag, sc->re_desc.re_rx_dmamap[i]); bus_dmamap_destroy(sc->re_desc.re_rx_mtag, sc->re_desc.re_rx_dmamap[i]); m_freem(sc->re_desc.rx_buf[i]); sc->re_desc.rx_buf[i] =NULL; } } bus_dma_tag_destroy(sc->re_desc.re_rx_mtag); sc->re_desc.re_rx_mtag =0; } if (sc->re_desc.re_tx_mtag) { for (i = 0; i < RE_TX_BUF_NUM; i++) { bus_dmamap_destroy(sc->re_desc.re_tx_mtag, sc->re_desc.re_tx_dmamap[i]); } bus_dma_tag_destroy(sc->re_desc.re_tx_mtag); sc->re_desc.re_tx_mtag =0; } if (sc->re_desc.rx_desc_tag) { bus_dmamap_sync(sc->re_desc.rx_desc_tag, sc->re_desc.rx_desc_dmamap, BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE); bus_dmamap_unload(sc->re_desc.rx_desc_tag, sc->re_desc.rx_desc_dmamap); bus_dmamem_free(sc->re_desc.rx_desc_tag, sc->re_desc.rx_desc, sc->re_desc.rx_desc_dmamap); bus_dma_tag_destroy(sc->re_desc.rx_desc_tag); } if (sc->re_desc.tx_desc_tag) { bus_dmamap_sync(sc->re_desc.tx_desc_tag, sc->re_desc.tx_desc_dmamap, BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE); bus_dmamap_unload(sc->re_desc.tx_desc_tag, sc->re_desc.tx_desc_dmamap); bus_dmamem_free(sc->re_desc.tx_desc_tag, sc->re_desc.tx_desc, sc->re_desc.tx_desc_dmamap); bus_dma_tag_destroy(sc->re_desc.tx_desc_tag); } if (sc->re_parent_tag) { bus_dma_tag_destroy(sc->re_parent_tag); } /*splx(s);*/ RE_LOCK_DESTROY(sc); return(0); } #endif /* !__DragonFly__ */ #ifndef __DragonFly__ static void re_link_state_change(struct ifnet *ifp, int link_state) { #if OS_VER>=VERSION(6,0) if_link_state_change(ifp, link_state); #else ifp->if_link_state = link_state #endif } /* * Device suspend routine. Stop the interface and save some PCI * settings in case the BIOS doesn't restore them properly on * resume. */ static int re_suspend(device_t dev) { struct re_softc *sc; struct ifnet *ifp; sc = device_get_softc(dev); RE_LOCK(sc); ifp = RE_GET_IFNET(sc); sc->re_link_chg_det = 0; sc->phy_reg_anlpar = re_get_phy_lp_ability(sc); re_stop(sc); re_hw_d3_para(sc); re_setwol(sc); sc->suspended = 1; sc->link_state = LINK_STATE_UNKNOWN; re_link_state_change(ifp, sc->link_state); sc->prohibit_access_reg = 1; RE_UNLOCK(sc); return (0); } /* * Device resume routine. Restore some PCI settings in case the BIOS * doesn't, re-enable busmastering, and restart the interface if * appropriate. */ static int re_resume(device_t dev) { struct re_softc *sc; struct ifnet *ifp; sc = device_get_softc(dev); RE_LOCK(sc); ifp = RE_GET_IFNET(sc); sc->prohibit_access_reg = 0; re_exit_oob(sc); re_hw_init(sc); re_reset(sc); re_phy_power_up(dev); re_hw_phy_config(sc); /* * Clear WOL matching such that normal Rx filtering * wouldn't interfere with WOL patterns. */ re_clrwol(sc); RE_UNLOCK(sc); RE_LOCK(sc); sc->ifmedia_upd(ifp); sc->suspended = 0; if (ifp->if_flags & IFF_UP) { sc->re_link_chg_det = 1; re_start_timer(sc); } RE_UNLOCK(sc); return (0); } #endif /* !__DragonFly__ */ static void ClearAndSetPCIePhyBit( struct re_softc *sc, u_int8_t addr, u_int16_t clearmask, u_int16_t setmask ) { u_int16_t EphyValue; EphyValue = MP_ReadEPhyUshort(sc, addr); EphyValue &= ~clearmask; EphyValue |= setmask; MP_WriteEPhyUshort(sc, addr, EphyValue); } static void ClearPCIePhyBit( struct re_softc *sc, u_int8_t addr, u_int16_t mask ) { ClearAndSetPCIePhyBit(sc, addr, mask, 0 ); } static void SetPCIePhyBit( struct re_softc *sc, u_int8_t addr, u_int16_t mask ) { ClearAndSetPCIePhyBit(sc, addr, 0, mask ); } #ifndef __DragonFly__ /* * Stop all chip I/O so that the kernel's probe routines don't * get confused by errant DMAs when rebooting. */ static int re_shutdown(dev) /* The same with re_stop(sc) */ device_t dev; { struct re_softc *sc; sc = device_get_softc(dev); if (sc->re_dash) re_driver_stop(sc); RE_LOCK(sc); sc->re_link_chg_det = 0; sc->phy_reg_anlpar = re_get_phy_lp_ability(sc); re_stop(sc); RE_UNLOCK(sc); RE_LOCK(sc); re_hw_d3_para(sc); if (s5wol == 0) { re_phy_power_down(dev); } else { struct ifnet *ifp; ifp = RE_GET_IFNET(sc); ifp->if_capenable = IFCAP_WOL_MAGIC; re_setwol(sc); } RE_UNLOCK(sc); return 0; } #endif /* !__DragonFly__ */ static void re_hw_start_unlock(struct re_softc *sc) { struct ifnet *ifp; u_int32_t macver; u_int8_t data8; u_int16_t data16 = 0; u_int32_t Data32; ifp = RE_GET_IFNET(sc); #ifndef __DragonFly__ /* Init descriptors. */ re_var_init(sc); #endif 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: case MACFG_72: 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);*/ /*ldps= CSR_READ_1(sc, RE_LDPS);*/ CSR_WRITE_2(sc, RE_CPlusCmd, 0x2060); CSR_WRITE_2(sc, RE_IM, 0x5151); CSR_WRITE_1(sc, RE_MTPS, 0x3f); if (sc->re_device_id == RT_DEVICEID_8169 || sc->re_device_id == RT_DEVICEID_8169SC) { //do nothing } else { /* Set the initial TX configuration.*/ CSR_WRITE_4(sc, RE_TXCFG, RE_TXCFG_CONFIG); } macver = CSR_READ_4(sc, RE_TXCFG) & 0xFC800000; if (macver == 0x00800000 || macver == 0x04000000 || macver == 0x10000000) { CSR_WRITE_2(sc, RE_CPlusCmd, 0x0063| ((sc->re_type == MACFG_3 && sc->re_8169_MacVersion==1) ? 0x4008:0)); } else if (macver == 0x18000000 || macver == 0x98000000) { CSR_WRITE_2(sc, RE_CPlusCmd, 0x0068); CSR_WRITE_2(sc, RE_IntrMitigate, 0x0000); } else if (macver == 0x30000000) { CSR_WRITE_2 (sc, RE_CPlusCmd, 0x2060); CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0); if (ifp->if_mtu > ETHERMTU) { data8 = pci_read_config(sc->dev, 0x69, 1); data8 &= ~0x70; data8 |= 0x28; pci_write_config(sc->dev, 0x69, data8, 1); } else { data8 = pci_read_config(sc->dev, 0x69, 1); data8 &= ~0x70; data8 |= 0x58; pci_write_config(sc->dev, 0x69, data8, 1); } } else if (macver == 0x38000000) { CSR_WRITE_2 (sc, RE_CPlusCmd, 0x2060); CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0); if (ifp->if_mtu > ETHERMTU) { data8 = pci_read_config(sc->dev, 0x69, 1); data8 &= ~0x70; data8 |= 0x28; pci_write_config(sc->dev, 0x69, data8, 1); CSR_WRITE_1(sc, RE_CFG4, CSR_READ_1(sc, RE_CFG4) | BIT_0); } else { data8 = pci_read_config(sc->dev, 0x69, 1); data8 &= ~0x70; data8 |= 0x58; pci_write_config(sc->dev, 0x69, data8, 1); CSR_WRITE_1(sc, RE_CFG4, CSR_READ_1(sc, RE_CFG4) & ~ BIT_0); } } else if (macver == 0x34000000 || macver == 0xB4000000) { CSR_WRITE_2 (sc, RE_CPlusCmd, 0x2060); } else if (macver == 0x34800000 || macver == 0x24800000) { if (pci_read_config(sc->dev, 0x81, 1) == 1) { CSR_WRITE_1(sc, RE_DBG_reg, 0x98); CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2) | 0x80); CSR_WRITE_1(sc, RE_CFG4, CSR_READ_1(sc, RE_CFG4) | 0x04); pci_write_config(sc->dev, 0x81, 1, 1); } data8 = pci_read_config(sc->dev, 0x79, 1); data8 &= ~0x70; data8 |= 0x50; pci_write_config(sc->dev, 0x79, data8, 1); /*set configuration space offset 0x70f to 0x3f*/ Data32 = MP_ReadPciEConfigSpace(sc, 0x870c); Data32 &=0xC0FFFFFF; Data32 |= (0x3F << 24); MP_WritePciEConfigSpace(sc, 0x870c, Data32); 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_14) { CSR_WRITE_1(sc,RE_CFG1, 0x0f); MP_WriteEPhyUshort(sc, 0x03, 0xC2F9); } else if (sc->re_type == MACFG_15) { CSR_WRITE_1(sc,RE_CFG1, 0x0f); MP_WriteEPhyUshort(sc, 0x01, 0x6FE5); MP_WriteEPhyUshort(sc, 0x03, 0x07D9); } else if (sc->re_type == MACFG_17) { MP_WriteEPhyUshort(sc, 0x06, 0xAF35); } else if (sc->re_type == MACFG_18) { CSR_WRITE_1(sc, 0xF5, CSR_READ_1(sc, 0xF5)|0x04); MP_WriteEPhyUshort(sc, 0x19, 0xEC90); MP_WriteEPhyUshort(sc, 0x01, 0x6FE5); MP_WriteEPhyUshort(sc, 0x03, 0x05D9); MP_WriteEPhyUshort(sc, 0x06, 0xAF35); } else if (sc->re_type == MACFG_19) { if (pci_read_config(sc->dev, 0x80, 1)&3) { MP_WriteEPhyUshort(sc, 0x02, 0x011F); } CSR_WRITE_1(sc, 0xF4, CSR_READ_1(sc, 0xF4)|0x08); CSR_WRITE_1(sc, 0xF5, CSR_READ_1(sc, 0xF5)|0x04); MP_WriteEPhyUshort(sc, 0x19, 0xEC90); MP_WriteEPhyUshort(sc, 0x01, 0x6FE5); MP_WriteEPhyUshort(sc, 0x03, 0x05D9); 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; Data32 |= (0x27 << 24); MP_WritePciEConfigSpace(sc, 0x870c, Data32); CSR_WRITE_1(sc, RE_CFG1, CSR_READ_1(sc, RE_CFG1)|0x10); 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_24) { /*set mac register offset 0xd1 to 0xf8*/ CSR_WRITE_1(sc, RE_DBG_reg, 0xF8); data16 = MP_ReadEPhyUshort(sc, 0x02) & ~0x1800; data16 |= 0x1000; MP_WriteEPhyUshort(sc, 0x02, data16); data16 = MP_ReadEPhyUshort(sc, 0x03) | 0x0002; MP_WriteEPhyUshort(sc, 0x03, data16); data16 = MP_ReadEPhyUshort(sc, 0x06) & ~0x0080; MP_WriteEPhyUshort(sc, 0x06, data16); 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 data8 = pci_read_config(sc->dev, 0x79, 1); data8 &= ~0x70; data8 |= 0x20; pci_write_config(sc->dev, 0x79, data8, 1); ifp->if_capenable &= ~IFCAP_HWCSUM; CSR_WRITE_2 (sc, RE_CPlusCmd,CSR_READ_2(sc, RE_CPlusCmd) & ~RL_RxChkSum); ifp->if_hwassist &= ~RE_CSUM_FEATURES; } else { 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 data8 = pci_read_config(sc->dev, 0x79, 1); data8 &= ~0x70; data8 |= 0x50; pci_write_config(sc->dev, 0x79, data8, 1); if (sc->re_tx_cstag) { ifp->if_capenable |= IFCAP_TXCSUM; if ((sc->re_type == MACFG_24) || (sc->re_type == MACFG_25) || (sc->re_type == MACFG_26)) ifp->if_hwassist |= CSUM_TCP | CSUM_UDP; else ifp->if_hwassist |= RE_CSUM_FEATURES; } if (sc->re_rx_cstag) { ifp->if_capenable |= IFCAP_RXCSUM; 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); data16 = MP_ReadEPhyUshort(sc, 0x03) & ~0x0620; data16 |= 0x0220; MP_WriteEPhyUshort(sc, 0x03, data16); 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 data8 = pci_read_config(sc->dev, 0x79, 1); data8 &= ~0x70; data8 |= 0x20; pci_write_config(sc->dev, 0x79, data8, 1); ifp->if_capenable &= ~IFCAP_HWCSUM; CSR_WRITE_2 (sc, RE_CPlusCmd,CSR_READ_2(sc, RE_CPlusCmd) & ~RL_RxChkSum); ifp->if_hwassist &= ~RE_CSUM_FEATURES; } else { 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 data8 = pci_read_config(sc->dev, 0x79, 1); data8 &= ~0x70; data8 |= 0x50; pci_write_config(sc->dev, 0x79, data8, 1); if (sc->re_tx_cstag) { ifp->if_capenable |= IFCAP_TXCSUM; if ((sc->re_type == MACFG_24) || (sc->re_type == MACFG_25) || (sc->re_type == MACFG_26)) ifp->if_hwassist |= CSUM_TCP | CSUM_UDP; else ifp->if_hwassist |= RE_CSUM_FEATURES; } if (sc->re_rx_cstag) { ifp->if_capenable |= IFCAP_RXCSUM; CSR_WRITE_2 (sc, RE_CPlusCmd,CSR_READ_2(sc, RE_CPlusCmd) |RL_RxChkSum); } } } else if (sc->re_type == MACFG_26) { 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 data8 = pci_read_config(sc->dev, 0x79, 1); data8 &= ~0x70; data8 |= 0x20; pci_write_config(sc->dev, 0x79, data8, 1); ifp->if_capenable &= ~IFCAP_HWCSUM; CSR_WRITE_2 (sc, RE_CPlusCmd,CSR_READ_2(sc, RE_CPlusCmd) & ~RL_RxChkSum); ifp->if_hwassist &= ~RE_CSUM_FEATURES; } else { 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 data8 = pci_read_config(sc->dev, 0x79, 1); data8 &= ~0x70; data8 |= 0x50; pci_write_config(sc->dev, 0x79, data8, 1); if (sc->re_tx_cstag) { ifp->if_capenable |= IFCAP_TXCSUM; if ((sc->re_type == MACFG_24) || (sc->re_type == MACFG_25) || (sc->re_type == MACFG_26)) ifp->if_hwassist |= CSUM_TCP | CSUM_UDP; else ifp->if_hwassist |= RE_CSUM_FEATURES; } if (sc->re_rx_cstag) { ifp->if_capenable |= IFCAP_RXCSUM; CSR_WRITE_2 (sc, RE_CPlusCmd,CSR_READ_2(sc, RE_CPlusCmd) |RL_RxChkSum); } } } } 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; Data32 |= (0x27 << 24); MP_WritePciEConfigSpace(sc, 0x870c, Data32); re_eri_write(sc, 0x1EC, 1, 0x07, ERIAR_ASF); 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) CSR_WRITE_1(sc, 0xD1, 0x20); 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 data8 = pci_read_config(sc->dev, 0x79, 1); data8 &= ~0x70; data8 |= 0x20; pci_write_config(sc->dev, 0x79, data8, 1); ifp->if_capenable &= ~IFCAP_HWCSUM; CSR_WRITE_2 (sc, RE_CPlusCmd,CSR_READ_2(sc, RE_CPlusCmd) & ~RL_RxChkSum); ifp->if_hwassist &= ~RE_CSUM_FEATURES; } else { 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 data8 = pci_read_config(sc->dev, 0x79, 1); data8 &= ~0x70; data8 |= 0x50; pci_write_config(sc->dev, 0x79, data8, 1); 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; 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 |= (0x27 << 24); MP_WritePciEConfigSpace(sc, 0x870c, Data32); CSR_WRITE_1(sc, RE_TDFNR, 0x8); CSR_WRITE_1(sc, 0xD1, CSR_READ_1(sc, 0xD1) | 0x02); 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); CSR_WRITE_2 (sc, RE_CPlusCmd, 0x2060); 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 data8 = pci_read_config(sc->dev, 0x79, 1); data8 &= ~0x70; data8 |= 0x20; pci_write_config(sc->dev, 0x79, data8, 1); ifp->if_capenable &= ~IFCAP_HWCSUM; CSR_WRITE_2 (sc, RE_CPlusCmd,CSR_READ_2(sc, RE_CPlusCmd) & ~RL_RxChkSum); ifp->if_hwassist &= ~RE_CSUM_FEATURES; } else { 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 data8 = pci_read_config(sc->dev, 0x79, 1); data8 &= ~0x70; data8 |= 0x50; pci_write_config(sc->dev, 0x79, data8, 1); 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; CSR_WRITE_2 (sc, RE_CPlusCmd,CSR_READ_2(sc, RE_CPlusCmd) |RL_RxChkSum); } } if (sc->re_type == MACFG_31) { CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~(1<<4)); MP_WriteEPhyUshort(sc, 0x01, 0x7C7F); MP_WriteEPhyUshort(sc, 0x02, 0x011F); MP_WriteEPhyUshort(sc, 0x06, 0xB271); MP_WriteEPhyUshort(sc, 0x07, 0xCE00); } else if (sc->re_type == MACFG_32) { MP_WriteEPhyUshort(sc, 0x01, 0x7C7D); MP_WriteEPhyUshort(sc, 0x02, 0x091F); MP_WriteEPhyUshort(sc, 0x03, 0xC5BA); MP_WriteEPhyUshort(sc, 0x06, 0xB279); MP_WriteEPhyUshort(sc, 0x07, 0xAF00); MP_WriteEPhyUshort(sc, 0x1E, 0xB8EB); } else if (sc->re_type == MACFG_33) { CSR_WRITE_1(sc, RE_CFG1, CSR_READ_1(sc, RE_CFG1)|0x10); MP_WriteEPhyUshort(sc, 0x01, 0x6C7F); MP_WriteEPhyUshort(sc, 0x02, 0x011F); ClearAndSetPCIePhyBit(sc, 0x03, 0xFFF0, 0x01B0 ); MP_WriteEPhyUshort(sc, 0x1A, 0x0546); MP_WriteEPhyUshort(sc, 0x1C, 0x80C4); MP_WriteEPhyUshort(sc, 0x1D, 0x78E5); 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 |= (0x27 << 24); MP_WritePciEConfigSpace(sc, 0x870c, Data32); 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); CSR_WRITE_2 (sc, RE_CPlusCmd, 0x2060); 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 data8 = pci_read_config(sc->dev, 0x79, 1); data8 &= ~0x70; data8 |= 0x20; pci_write_config(sc->dev, 0x79, data8, 1); ifp->if_capenable &= ~IFCAP_HWCSUM; CSR_WRITE_2 (sc, RE_CPlusCmd,CSR_READ_2(sc, RE_CPlusCmd) & ~RL_RxChkSum); ifp->if_hwassist &= ~RE_CSUM_FEATURES; } else { 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 data8 = pci_read_config(sc->dev, 0x79, 1); data8 &= ~0x70; data8 |= 0x50; pci_write_config(sc->dev, 0x79, data8, 1); 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; CSR_WRITE_2 (sc, RE_CPlusCmd,CSR_READ_2(sc, RE_CPlusCmd) |RL_RxChkSum); } } if (sc->re_type == MACFG_65 || sc->re_type == MACFG_66) { SetPCIePhyBit(sc, 0x0B, (BIT_3 | BIT_6)); ClearAndSetPCIePhyBit(sc, 0x19, BIT_5, (BIT_4 | BIT_6) ); ClearAndSetPCIePhyBit(sc, 0x0C, BIT_8, BIT_5 ); 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 |= (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)|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; data16 |= 0x0100; MP_WriteEPhyUshort(sc, 0x00, data16); data16 = MP_ReadEPhyUshort(sc, 0x00); data16 |= 0x0004; MP_WriteEPhyUshort(sc, 0x00, data16); data16 = MP_ReadEPhyUshort(sc, 0x06) & ~0x0002; data16 |= 0x0001; MP_WriteEPhyUshort(sc, 0x06, data16); data16 = MP_ReadEPhyUshort(sc, 0x06); data16 |= 0x0030; MP_WriteEPhyUshort(sc, 0x06, data16); data16 = MP_ReadEPhyUshort(sc, 0x07); data16 |= 0x2000; MP_WriteEPhyUshort(sc, 0x07, data16); data16 = MP_ReadEPhyUshort(sc, 0x00); data16 |= 0x0020; MP_WriteEPhyUshort(sc, 0x00, data16); data16 = MP_ReadEPhyUshort(sc, 0x03) & ~0x5800; data16 |= 0x2000; MP_WriteEPhyUshort(sc, 0x03, data16); data16 = MP_ReadEPhyUshort(sc, 0x03); data16 |= 0x0001; MP_WriteEPhyUshort(sc, 0x03, data16); data16 = MP_ReadEPhyUshort(sc, 0x01) & ~0x0800; data16 |= 0x1000; MP_WriteEPhyUshort(sc, 0x01, data16); data16 = MP_ReadEPhyUshort(sc, 0x07); data16 |= 0x4000; MP_WriteEPhyUshort(sc, 0x07, data16); data16 = MP_ReadEPhyUshort(sc, 0x1E); data16 |= 0x2000; MP_WriteEPhyUshort(sc, 0x1E, data16); MP_WriteEPhyUshort(sc, 0x19, 0xFE6C); data16 = MP_ReadEPhyUshort(sc, 0x0A); data16 |= 0x0040; MP_WriteEPhyUshort(sc, 0x0A, data16); if (ifp->if_mtu > ETHERMTU) { CSR_WRITE_1 (sc, RE_MTPS, 0x24); CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) | BIT_2); CSR_WRITE_1(sc, RE_CFG4, CSR_READ_1(sc, RE_CFG4) |0x01); data8 = pci_read_config(sc->dev, 0x79, 1); data8 &= ~0x70; data8 |= 0x20; pci_write_config(sc->dev, 0x79, data8, 1); ifp->if_capenable &= ~IFCAP_HWCSUM; CSR_WRITE_2 (sc, RE_CPlusCmd,CSR_READ_2(sc, RE_CPlusCmd) & ~RL_RxChkSum); ifp->if_hwassist &= ~RE_CSUM_FEATURES; } else { CSR_WRITE_1 (sc, RE_MTPS, 0x0c); CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_2); CSR_WRITE_1(sc, RE_CFG4, CSR_READ_1(sc, RE_CFG4) & ~0x01); data8 = pci_read_config(sc->dev, 0x79, 1); data8 &= ~0x70; data8 |= 0x50; pci_write_config(sc->dev, 0x79, data8, 1); 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; CSR_WRITE_2 (sc, RE_CPlusCmd,CSR_READ_2(sc, RE_CPlusCmd) |RL_RxChkSum); } } } } 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; 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); 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); re_eri_write(sc, 0xC8, 4, 0x00100002, ERIAR_ExGMAC); re_eri_write(sc, 0xE8, 4, 0x00100006, ERIAR_ExGMAC); 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, 0xD4, 4, ERIAR_ExGMAC); Data32 |= (BIT_8 | BIT_9 | BIT_10 | BIT_11 | BIT_12); re_eri_write(sc, 0xD4, 4, Data32, ERIAR_ExGMAC); if (sc ->re_type == MACFG_39) { Data32 = re_eri_read(sc, 0x1B0, 4, ERIAR_ExGMAC); Data32 |= BIT_4; re_eri_write(sc, 0x1B0, 4, Data32, ERIAR_ExGMAC); re_eri_write(sc, 0xCC, 4, 0x00000050, ERIAR_ExGMAC); re_eri_write(sc, 0xD0, 4, 0x07ff0060, 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); if (sc ->re_type == MACFG_38) { CSR_WRITE_4(sc, 0xB0, 0xEE480010); CSR_WRITE_1(sc, 0x1A, CSR_READ_1(sc, 0x1A) & ~(BIT_2 |BIT_3)); re_eri_write(sc, 0x1DC, 1, 0x64, ERIAR_ExGMAC); MP_WriteEPhyUshort(sc, 0x06, 0xF020); MP_WriteEPhyUshort(sc, 0x07, 0x01FF); MP_WriteEPhyUshort(sc, 0x00, 0x5027); MP_WriteEPhyUshort(sc, 0x01, 0x0003); MP_WriteEPhyUshort(sc, 0x02, 0x2D16); MP_WriteEPhyUshort(sc, 0x03, 0x6D49); MP_WriteEPhyUshort(sc, 0x08, 0x0006); MP_WriteEPhyUshort(sc, 0x0A, 0x00C8); } data16 = MP_ReadEPhyUshort(sc, 0x09); data16 |= BIT_7; MP_WriteEPhyUshort(sc, 0x09, data16); data16 = MP_ReadEPhyUshort(sc, 0x19); data16 |= (BIT_2 | BIT_5 | BIT_9); MP_WriteEPhyUshort(sc, 0x19, data16); SetPCIePhyBit(sc, 0x00, BIT_3); ClearAndSetPCIePhyBit(sc, 0x0C, (BIT_13|BIT_12|BIT_11|BIT_10|BIT_8|BIT_7|BIT_6|BIT_5|BIT_4), BIT_9 ); 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_hwassist &= ~RE_CSUM_FEATURES; } else if (macver == 0x24000000) { if (pci_read_config(sc->dev, 0x81, 1)==1) { CSR_WRITE_1(sc, RE_DBG_reg, 0x98); CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2) | 0x80); CSR_WRITE_1(sc, RE_CFG4, CSR_READ_1(sc, RE_CFG4) | 0x04); pci_write_config(sc->dev, 0x81, 1, 1); } data8 = pci_read_config(sc->dev, 0x79, 1); data8 &= ~0x70; data8 |= 0x50; pci_write_config(sc->dev, 0x79, data8, 1); /*set configuration space offset 0x70f to 0x3F*/ Data32 = MP_ReadPciEConfigSpace(sc, 0x870c); Data32 &=0xC0FFFFFF; Data32 |= (0x3F << 24); MP_WritePciEConfigSpace(sc, 0x870c, Data32); CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0); CSR_WRITE_2 (sc, RE_CPlusCmd, 0x2060); MP_WriteEPhyUshort(sc, 0x06, 0xAF25); MP_WriteEPhyUshort(sc, 0x07, 0x8E68); } else if (macver == 0x40800000) { 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); CSR_WRITE_1(sc, 0xD0, CSR_READ_1(sc, 0xD0) | 0x40); CSR_WRITE_2(sc, 0xE0, CSR_READ_2(sc, 0xE0) & ~0xDF9C); CSR_WRITE_1(sc, 0xD1, CSR_READ_1(sc, 0xD1) | 0x02); CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0); if (sc->re_type == MACFG_42) { /* set EPHY registers */ SetPCIePhyBit(sc, 0x07, BIT_14); SetPCIePhyBit(sc, 0x19, BIT_9); SetPCIePhyBit(sc, 0x19, BIT_5); SetPCIePhyBit(sc, 0x1E, BIT_13); SetPCIePhyBit(sc, 0x03, BIT_0); SetPCIePhyBit(sc, 0x19, BIT_8); SetPCIePhyBit(sc, 0x19, BIT_2); SetPCIePhyBit(sc, 0x0A, BIT_5); SetPCIePhyBit(sc, 0x05, BIT_13); } if (sc->re_type == MACFG_43) { SetPCIePhyBit(sc, 0x07, BIT_14); SetPCIePhyBit(sc, 0x19, BIT_9); SetPCIePhyBit(sc, 0x19, BIT_5); SetPCIePhyBit(sc, 0x1E, BIT_13); SetPCIePhyBit(sc, 0x03, BIT_0); SetPCIePhyBit(sc, 0x19, BIT_8); SetPCIePhyBit(sc, 0x19, BIT_2); SetPCIePhyBit(sc, 0x0A, BIT_5); SetPCIePhyBit(sc, 0x1E, BIT_15); SetPCIePhyBit(sc, 0x05, BIT_13); } } else if (macver == 0x44000000) { CSR_WRITE_2(sc, 0xE0, CSR_READ_2(sc, 0xE0) & ~0xDF9C); re_eri_write(sc, 0xC8, 4, 0x00000002, ERIAR_ExGMAC); re_eri_write(sc, 0xE8, 4, 0x00000006, ERIAR_ExGMAC); Data32 = re_eri_read(sc, 0xD4, 4, ERIAR_ExGMAC); Data32 |= BIT_11 | BIT_10; re_eri_write(sc, 0xD4, 4, Data32, ERIAR_ExGMAC); CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0); /* set EPHY registers */ MP_WriteEPhyUshort(sc, 0x19, 0xFF64); CSR_WRITE_1 (sc, RE_MTPS, 0x27); } else if (macver == 0x48000000) { /*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); CSR_WRITE_1(sc, RE_TDFNR, 0x8); Data32 = re_eri_read(sc, 0xD4, 4, ERIAR_ExGMAC); Data32 |= (BIT_8 | BIT_9 | BIT_10 | BIT_11 | BIT_12); re_eri_write(sc, 0xD4, 4, Data32, ERIAR_ExGMAC); re_eri_write(sc, 0xC0, 2, 0x0000, ERIAR_ExGMAC); re_eri_write(sc, 0xB8, 4, 0x00000000, ERIAR_ExGMAC); re_eri_write(sc, 0xC8, 4, 0x00100002, ERIAR_ExGMAC); re_eri_write(sc, 0xE8, 4, 0x00100006, ERIAR_ExGMAC); 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, 0x1B0, 4, ERIAR_ExGMAC); Data32 |= BIT_4; re_eri_write(sc, 0x1B0, 4, Data32, ERIAR_ExGMAC); re_eri_write(sc, 0xCC, 4, 0x00000050, ERIAR_ExGMAC); re_eri_write(sc, 0xD0, 4, 0x00000060, ERIAR_ExGMAC); Data32 = re_eri_read(sc, 0x1D0, 4, ERIAR_ExGMAC); Data32 |= BIT_4; re_eri_write(sc, 0x1D0, 4, Data32, 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); if (sc->re_type == MACFG_50) { data16 = MP_ReadEPhyUshort(sc, 0x06); data16 &= ~(BIT_7 | BIT_6); data16 |= BIT_5; MP_WriteEPhyUshort(sc, 0x06, data16); data16 = MP_ReadEPhyUshort(sc, 0x08); data16 &= ~BIT_0; data16 |= BIT_1; MP_WriteEPhyUshort(sc, 0x08, data16); } data16 = MP_ReadEPhyUshort(sc, 0x09); data16 |= BIT_7; MP_WriteEPhyUshort(sc, 0x09, data16); data16 = MP_ReadEPhyUshort(sc, 0x19); data16 |= (BIT_2 | BIT_5 | BIT_9); MP_WriteEPhyUshort(sc, 0x19, data16); SetPCIePhyBit(sc, 0x00, BIT_3); ClearAndSetPCIePhyBit(sc, 0x0C, (BIT_13|BIT_12|BIT_11|BIT_10|BIT_8|BIT_7|BIT_6|BIT_5|BIT_4), BIT_9 ); 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); 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; } } } else if (macver == 0x48800000) { /*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); 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); re_eri_write(sc, 0xC0, 2, 0x0000, ERIAR_ExGMAC); re_eri_write(sc, 0xB8, 4, 0x00000000, ERIAR_ExGMAC); re_eri_write(sc, 0xC8, 4, 0x00100002, ERIAR_ExGMAC); re_eri_write(sc, 0xE8, 4, 0x00100006, ERIAR_ExGMAC); 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, 0x1B0, 4, ERIAR_ExGMAC); Data32 |= BIT_4; re_eri_write(sc, 0x1B0, 4, Data32, ERIAR_ExGMAC); re_eri_write(sc, 0xCC, 4, 0x00000050, ERIAR_ExGMAC); re_eri_write(sc, 0xD0, 4, 0x00000060, ERIAR_ExGMAC); Data32 = re_eri_read(sc, 0x1D0, 4, ERIAR_ExGMAC); Data32 |= BIT_4; re_eri_write(sc, 0x1D0, 4, Data32, 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); data16 = MP_ReadEPhyUshort(sc, 0x06); data16 &= ~(BIT_7 | BIT_6); data16 |= BIT_5; MP_WriteEPhyUshort(sc, 0x06, data16); MP_WriteEPhyUshort(sc, 0x0f, 0x5200); data16 = MP_ReadEPhyUshort(sc, 0x1e); data16 |= BIT_14; MP_WriteEPhyUshort(sc, 0x1e, data16); data16 = MP_ReadEPhyUshort(sc, 0x19); data16 |= (BIT_2 | BIT_5 | BIT_9); MP_WriteEPhyUshort(sc, 0x19, data16); SetPCIePhyBit(sc, 0x00, BIT_3); ClearAndSetPCIePhyBit(sc, 0x0C, (BIT_13|BIT_12|BIT_11|BIT_10|BIT_8|BIT_7|BIT_6|BIT_5|BIT_4), BIT_9 ); 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); 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; } } } else if (macver == 0x44800000) { 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); CSR_WRITE_1(sc, 0xD0, CSR_READ_1(sc, 0xD0) | 0x40); CSR_WRITE_2(sc, 0xE0, CSR_READ_2(sc, 0xE0) & ~0xDF9C); 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_CFG2, CSR_READ_1(sc, RE_CFG2) | BIT_5); if (sc->re_type == MACFG_59) { MP_WriteMcuAccessRegWord(sc, 0xD3C0, 0x0B00); MP_WriteMcuAccessRegWord(sc, 0xD3C2, 0x0000); } if (sc->re_type == MACFG_68 || sc->re_type == MACFG_69) { MP_WriteMcuAccessRegWord(sc, 0xD400, MP_ReadMcuAccessRegWord(sc, 0xD400) & ~(BIT_0)); 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); MP_WriteMcuAccessRegWord(sc, 0xE098, 0x0AA2); } /*set configuration space offset 0x70f to 0x17*/ 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); 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; Data32 |= (0x04 << 12); MP_WritePciEConfigSpace(sc, 0x2710, Data32); } if (sc->re_type == MACFG_68 || sc->re_type == MACFG_69) { Data32 = re_eri_read(sc, 0xD4, 4, ERIAR_ExGMAC); Data32 |= (BIT_8 | BIT_9 | BIT_10 | BIT_11 | BIT_12); re_eri_write(sc, 0xD4, 4, Data32, ERIAR_ExGMAC); Data32 = re_eri_read(sc, 0xDC, 4, ERIAR_ExGMAC); Data32 |= (BIT_2| BIT_3 | BIT_4); re_eri_write(sc, 0xDC, 4, Data32, ERIAR_ExGMAC); } else { 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, 0x38, ERIAR_ExGMAC); 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); 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); 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); if (sc->re_type == MACFG_56 || sc->re_type == MACFG_57) { ClearPCIePhyBit(sc, 0x00, BIT_3); ClearAndSetPCIePhyBit(sc, 0x0C, (BIT_13|BIT_12|BIT_10|BIT_9|BIT_8|BIT_7|BIT_6|BIT_4), (BIT_11|BIT_5) ); SetPCIePhyBit(sc, 0x1E, BIT_0); ClearPCIePhyBit(sc, 0x19, BIT_15); } else if (sc->re_type == MACFG_58) { SetPCIePhyBit(sc, 0x00, (BIT_3)); ClearAndSetPCIePhyBit(sc, 0x0C, (BIT_13 | BIT_12 | BIT_11 | BIT_10 | BIT_8 | BIT_7 | BIT_6 | BIT_5 | BIT_4), BIT_9 ); } else if (sc->re_type == MACFG_59) { ClearPCIePhyBit(sc, 0x00, BIT_3); ClearAndSetPCIePhyBit(sc, 0x0C, (BIT_13 | BIT_12 | BIT_10 | BIT_9 | BIT_8 | BIT_7 | BIT_6 | BIT_4), (BIT_5 | BIT_11) ); SetPCIePhyBit(sc, 0x1E, BIT_0); ClearPCIePhyBit(sc, 0x19, BIT_15); MP_WriteEPhyUshort(sc, 0x19, 0x7C00); MP_WriteEPhyUshort(sc, 0x1E, 0x20EB); MP_WriteEPhyUshort(sc, 0x0D, 0x1666); 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, 0x0C, (BIT_13 | BIT_12 | BIT_10 | BIT_9 | BIT_8 | BIT_7 | BIT_6 | BIT_4), (BIT_5 | BIT_11) ); SetPCIePhyBit(sc, 0x1E, BIT_0); ClearPCIePhyBit(sc, 0x19, BIT_15); ClearPCIePhyBit(sc, 0x19, (BIT_5 | BIT_0)); SetPCIePhyBit(sc, 0x1E, BIT_13); ClearPCIePhyBit(sc, 0x0D, BIT_8); SetPCIePhyBit(sc, 0x0D, BIT_9); 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); SetPCIePhyBit(sc, 0x1E, BIT_0); SetPCIePhyBit(sc, 0x1D, BIT_11); MP_WriteEPhyUshort(sc, 0x05, 0x2089); MP_WriteEPhyUshort(sc, 0x06, 0x5881); MP_WriteEPhyUshort(sc, 0x04, 0x854A); MP_WriteEPhyUshort(sc, 0x01, 0x068B); } if (sc->re_type == MACFG_60) { data16 = MP_ReadMcuAccessRegWord(sc, 0xD3C0); data16 &= 0xF000; data16 |= 0x3A9; MP_WriteMcuAccessRegWord(sc, 0xD3C0, data16); data16 = MP_ReadMcuAccessRegWord(sc, 0xD3C2); data16 &= 0xFF00; MP_WriteMcuAccessRegWord(sc, 0xD3C2, data16); data16 = MP_ReadMcuAccessRegWord(sc, 0xD3C4); data16 |= (BIT_0); MP_WriteMcuAccessRegWord(sc, 0xD3C4, data16); } else if (sc->re_type == MACFG_68 || sc->re_type == MACFG_69) { 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); data16 = MP_ReadMcuAccessRegWord(sc, 0xE052); data16 &= ~(BIT_14 | BIT_13); data16 |= BIT_15; data16 |= BIT_3; MP_WriteMcuAccessRegWord(sc, 0xE052, data16); 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); data16 = MP_ReadMcuAccessRegWord(sc, 0xE0D6); data16 &= ~(BIT_8 | BIT_7 | BIT_6 | BIT_5 | BIT_4 | BIT_3 | BIT_2 | BIT_1 | BIT_0); data16 |= 0x17F; MP_WriteMcuAccessRegWord(sc, 0xE0D6, data16); } 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, 0xF2, CSR_READ_1(sc, 0xF2) & ~BIT_3); CSR_WRITE_1 (sc, RE_MTPS, 0x27); if (sc->re_type == MACFG_56 || sc->re_type == MACFG_57 || sc->re_type == MACFG_58 || sc->re_type == MACFG_59) { MP_WriteMcuAccessRegWord(sc, 0xC140, 0xFFFF); } else if (sc->re_type == MACFG_68 || sc->re_type == MACFG_69) { 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; } } } else if (macver == 0x50000000) { /*set configuration space offset 0x70f to 0x17*/ 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); if (sc->re_type == MACFG_62 || sc->re_type == MACFG_67) { OOB_mutex_lock(sc); re_eri_write(sc, 0x5F0, 4, 0x4F87, 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 | BIT_1); 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); 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); if (sc->re_type == MACFG_61) { MP_WriteEPhyUshort(sc, 0x00, 0x10AB); MP_WriteEPhyUshort(sc, 0x06, 0xF030); MP_WriteEPhyUshort(sc, 0x08, 0x2006); MP_WriteEPhyUshort(sc, 0x0D, 0x1666); ClearPCIePhyBit(sc, 0x0C, (BIT_13 | BIT_12 | BIT_11 | BIT_10 | BIT_9 | BIT_8 | BIT_7 | BIT_6 | BIT_5 | BIT_4)); } else if (sc->re_type == MACFG_62) { MP_WriteEPhyUshort(sc, 0x00, 0x10A3); MP_WriteEPhyUshort(sc, 0x19, 0xFC00); MP_WriteEPhyUshort(sc, 0x1E, 0x20EA); } else if (sc->re_type == MACFG_67) { MP_WriteEPhyUshort(sc, 0x00, 0x10AB); MP_WriteEPhyUshort(sc, 0x19, 0xFC00); MP_WriteEPhyUshort(sc, 0x1E, 0x20EB); MP_WriteEPhyUshort(sc, 0x0D, 0x1666); ClearPCIePhyBit(sc, 0x0B, BIT_0); SetPCIePhyBit(sc, 0x1D, BIT_14); ClearAndSetPCIePhyBit(sc, 0x0C, BIT_13 | BIT_12 | BIT_11 | BIT_10 | BIT_8 | BIT_7 | BIT_6 | BIT_5, BIT_9 | BIT_4 ); } 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, 0xF2, CSR_READ_1(sc, 0xF2) & ~BIT_3); CSR_WRITE_1 (sc, RE_MTPS, 0x27); if (sc->re_type == MACFG_67) { data16 = MP_ReadMcuAccessRegWord(sc, 0xD3E2); data16 &= 0xF000; data16 |= 0xAFD; 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; } } } else if (macver == 0x54800000) { MP_WriteMcuAccessRegWord(sc, 0xE098, 0xC302); MP_WriteMcuAccessRegWord(sc, 0xD400, MP_ReadMcuAccessRegWord(sc, 0xD400) & ~(BIT_0)); if (sc->RequireAdjustUpsTxLinkPulseTiming) { data16 = MP_ReadMcuAccessRegWord(sc, 0xD412); data16 &= ~(0x0FFF); data16 |= sc->SwrCnt1msIni; MP_WriteMcuAccessRegWord(sc, 0xD412, data16); } data16 = MP_ReadMcuAccessRegWord(sc, 0xE056); data16 &= ~(BIT_7 | BIT_6 | BIT_5 | BIT_4); if (FALSE == HW_SUPP_SERDES_PHY(sc)) data16 |= (BIT_6 | BIT_5 | BIT_4); MP_WriteMcuAccessRegWord(sc, 0xE056, data16); if (FALSE == HW_SUPP_SERDES_PHY(sc)) MP_WriteMcuAccessRegWord(sc, 0xEA80, 0x0003); else MP_WriteMcuAccessRegWord(sc, 0xEA80, 0x0000); OOB_mutex_lock(sc); data16 = MP_ReadMcuAccessRegWord(sc, 0xE052); data16 &= ~(BIT_3 | BIT_0); if (FALSE == HW_SUPP_SERDES_PHY(sc)) { data16 |= BIT_0; if (sc->re_type == MACFG_71 || sc->re_type == MACFG_72) 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; if (sc->re_type == MACFG_71 || sc->re_type == MACFG_72) Data32 |= BIT_4; 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); OOB_mutex_lock(sc); if (FALSE == HW_SUPP_SERDES_PHY(sc)) re_eri_write(sc, 0x5F0, 2, 0x4F87, ERIAR_ExGMAC); else re_eri_write(sc, 0x5F0, 2, 0x4080, 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); 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); ClearAndSetPCIePhyBit(sc, 0x19, BIT_6, (BIT_12| BIT_8) ); ClearAndSetPCIePhyBit(sc, 0x59, BIT_6, (BIT_12| BIT_8) ); ClearPCIePhyBit(sc, 0x0C, BIT_4); ClearPCIePhyBit(sc, 0x4C, BIT_4); ClearPCIePhyBit(sc, 0x0B, BIT_0); CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0); if (FALSE == HW_SUPP_SERDES_PHY(sc)) { 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); } else { 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); 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 switch (sc->re_type) { case MACFG_42: case MACFG_43: 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: case MACFG_72: 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: case MACFG_72: CSR_WRITE_1(sc, RE_CFG5, CSR_READ_1(sc, RE_CFG5) | BIT_0); CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2) | BIT_7); CSR_WRITE_1(sc, 0xF1, CSR_READ_1(sc, 0xF1) & ~BIT_7); break; } //clear wol re_clrwol(sc); data16 = CSR_READ_2(sc, RE_CPlusCmd); if ((ifp->if_capenable & IFCAP_VLAN_HWTAGGING) != 0) data16 |= RL_CPLUSCMD_VLANSTRIP; else data16 &= ~RL_CPLUSCMD_VLANSTRIP; if ((ifp->if_capenable & IFCAP_RXCSUM) != 0) data16 |= RL_RxChkSum; else data16 &= ~RL_RxChkSum; CSR_WRITE_2 (sc, RE_CPlusCmd, data16); 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) { /* Enable transmit and receive.*/ CSR_WRITE_1(sc, RE_COMMAND, RE_CMD_TX_ENB | RE_CMD_RX_ENB); /* Set the initial TX configuration.*/ CSR_WRITE_4(sc, RE_TXCFG, RE_TXCFG_CONFIG); /* Set the initial RX configuration.*/ /* * Program the multicast filter, if necessary. */ re_set_rx_packet_filter(sc); } else { /* Set the initial RX configuration.*/ /* * Program the multicast filter, if necessary. */ re_set_rx_packet_filter(sc); /* Enable transmit and receive.*/ CSR_WRITE_1(sc, RE_COMMAND, RE_CMD_TX_ENB | RE_CMD_RX_ENB); } #ifndef __DragonFly__ ifp->if_drv_flags |= IFF_DRV_RUNNING; ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; /* * Enable interrupts. */ CSR_WRITE_2(sc, RE_IMR, RE_INTRS); #endif } static void re_init_unlock(void *xsc) /* Software & Hardware Initialize */ { struct re_softc *sc = xsc; struct ifnet *ifp; #ifndef __DragonFly__ #if OS_VER < VERSION(6,0) int i; #endif #endif /* !__DragonFly__ */ union { uint32_t align_dummy; u_char eaddr[ETHER_ADDR_LEN]; } eaddr; ifp = RE_GET_IFNET(sc); #ifndef __DragonFly__ /* * Cancel pending I/O and free all RX/TX buffers. */ re_stop(sc); #endif /* !__DragonFly__ */ /* Copy MAC address on stack to align. */ #ifndef __DragonFly__ #if OS_VER < VERSION(6,0) bcopy((char *)&sc->arpcom.ac_enaddr, eaddr.eaddr, ETHER_ADDR_LEN); #elif OS_VER < VERSION(7,0) bcopy(IFP2ENADDR(ifp), eaddr.eaddr, ETHER_ADDR_LEN); #else bcopy(IF_LLADDR(ifp), eaddr.eaddr, ETHER_ADDR_LEN); #endif #else /* __DragonFly__ */ bcopy(IF_LLADDR(ifp), eaddr.eaddr, ETHER_ADDR_LEN); #endif /* !__DragonFly__ */ /* Init our MAC address */ re_rar_set(sc, eaddr.eaddr); #ifndef __DragonFly__ sc->hw_start_unlock(sc); #endif return; } #ifndef __DragonFly__ static void re_init(void *xsc) /* Software & Hardware Initialize */ { struct re_softc *sc = xsc; struct ifnet *ifp; RE_LOCK(sc); ifp = RE_GET_IFNET(sc); if (re_link_ok(sc)) { sc->link_state = LINK_STATE_UP; re_link_state_change(ifp, sc->link_state); re_link_on_patch(sc); } sc->re_link_chg_det = 1; re_start_timer(sc); RE_UNLOCK(sc); } #endif /* !__DragonFly__ */ static void re_hw_start_unlock_8125(struct re_softc *sc) { struct ifnet *ifp; u_int32_t macver; u_int8_t data8; u_int16_t data16 = 0; u_int32_t Data32; ifp = RE_GET_IFNET(sc); #ifndef __DragonFly__ /* Init descriptors. */ re_var_init(sc); #endif 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); //Interrupt Mitigation CSR_WRITE_4(sc, 0x0A00, 0x00630063); CSR_WRITE_2(sc, RE_CPlusCmd, 0x2060); /* Set the initial TX configuration.*/ CSR_WRITE_4(sc, RE_TXCFG, RE_TXCFG_CONFIG); macver = CSR_READ_4(sc, RE_TXCFG) & 0xFC800000; if (macver == 0x60800000 || macver == 0x64000000) { CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2) | BIT_5); MP_WriteMcuAccessRegWord(sc, 0xE098, 0xC302); /*set configuration space offset 0x70f to 0x17*/ 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); CSR_WRITE_2(sc, 0x382, 0x221B); CSR_WRITE_1(sc, 0x4500, 0x00); CSR_WRITE_2(sc, 0x4800, 0x0000); CSR_WRITE_1(sc, RE_CFG1, CSR_READ_1(sc, RE_CFG1) & ~0x10); CSR_WRITE_1(sc, 0xF2, CSR_READ_1(sc, 0xF2) & ~BIT_3); CSR_WRITE_1(sc, RE_TDFNR, 0x10); if (sc->re_type == MACFG_80) { MP_WriteEPhyUshort(sc, 0x01, 0xA812); MP_WriteEPhyUshort(sc, 0x09, 0x520C); MP_WriteEPhyUshort(sc, 0x04, 0xD000); MP_WriteEPhyUshort(sc, 0x0D, 0xF702); MP_WriteEPhyUshort(sc, 0x0A, 0x8653); MP_WriteEPhyUshort(sc, 0x06, 0x001E); MP_WriteEPhyUshort(sc, 0x08, 0x3595); MP_WriteEPhyUshort(sc, 0x20, 0x9455); MP_WriteEPhyUshort(sc, 0x21, 0x99FF); MP_WriteEPhyUshort(sc, 0x02, 0x6046); MP_WriteEPhyUshort(sc, 0x29, 0xFE00); MP_WriteEPhyUshort(sc, 0x23, 0xAB62); ClearPCIePhyBit(sc, 0x24, BIT_11); MP_WriteEPhyUshort(sc, 0x41, 0xA80C); MP_WriteEPhyUshort(sc, 0x49, 0x520C); MP_WriteEPhyUshort(sc, 0x44, 0xD000); MP_WriteEPhyUshort(sc, 0x4D, 0xF702); MP_WriteEPhyUshort(sc, 0x4A, 0x8653); MP_WriteEPhyUshort(sc, 0x46, 0x001E); MP_WriteEPhyUshort(sc, 0x48, 0x3595); MP_WriteEPhyUshort(sc, 0x60, 0x9455); MP_WriteEPhyUshort(sc, 0x61, 0x99FF); MP_WriteEPhyUshort(sc, 0x42, 0x6046); MP_WriteEPhyUshort(sc, 0x69, 0xFE00); MP_WriteEPhyUshort(sc, 0x63, 0xAB62); ClearPCIePhyBit(sc, 0x64, BIT_11); } else if (sc->re_type == MACFG_81) { MP_WriteEPhyUshort(sc, 0x04, 0xD000); MP_WriteEPhyUshort(sc, 0x0A, 0x8653); MP_WriteEPhyUshort(sc, 0x23, 0xAB66); MP_WriteEPhyUshort(sc, 0x20, 0x9455); MP_WriteEPhyUshort(sc, 0x21, 0x99FF); MP_WriteEPhyUshort(sc, 0x29, 0xFE04); MP_WriteEPhyUshort(sc, 0x44, 0xD000); MP_WriteEPhyUshort(sc, 0x4A, 0x8653); MP_WriteEPhyUshort(sc, 0x63, 0xAB66); MP_WriteEPhyUshort(sc, 0x60, 0x9455); MP_WriteEPhyUshort(sc, 0x61, 0x99FF); MP_WriteEPhyUshort(sc, 0x69, 0xFE04); ClearAndSetPCIePhyBit(sc, 0x2A, (BIT_14 | BIT_13 | BIT_12), (BIT_13 | BIT_12) ); ClearPCIePhyBit(sc, 0x19, BIT_6); SetPCIePhyBit(sc, 0x1B, (BIT_11 | BIT_10 | BIT_9)); ClearPCIePhyBit(sc, 0x1B, (BIT_14 | BIT_13 | BIT_12)); MP_WriteEPhyUshort(sc, 0x02, 0x6042); MP_WriteEPhyUshort(sc, 0x06, 0x0014); ClearAndSetPCIePhyBit(sc, 0x6A, (BIT_14 | BIT_13 | BIT_12), (BIT_13 | BIT_12) ); ClearPCIePhyBit(sc, 0x59, BIT_6); SetPCIePhyBit(sc, 0x5B, (BIT_11 | BIT_10 | BIT_9)); ClearPCIePhyBit(sc, 0x5B, (BIT_14 | BIT_13 | BIT_12)); MP_WriteEPhyUshort(sc, 0x42, 0x6042); MP_WriteEPhyUshort(sc, 0x46, 0x0014); } else if (sc->re_type == MACFG_82) { MP_WriteEPhyUshort(sc, 0x06, 0x001F); MP_WriteEPhyUshort(sc, 0x0A, 0xB66B); MP_WriteEPhyUshort(sc, 0x01, 0xA852); MP_WriteEPhyUshort(sc, 0x24, 0x0008); MP_WriteEPhyUshort(sc, 0x2F, 0x6052); MP_WriteEPhyUshort(sc, 0x0D, 0xF716); MP_WriteEPhyUshort(sc, 0x20, 0xD477); MP_WriteEPhyUshort(sc, 0x21, 0x4477); MP_WriteEPhyUshort(sc, 0x22, 0x0013); MP_WriteEPhyUshort(sc, 0x23, 0xBB66); MP_WriteEPhyUshort(sc, 0x0B, 0xA909); MP_WriteEPhyUshort(sc, 0x29, 0xFF04); MP_WriteEPhyUshort(sc, 0x1B, 0x1EA0); MP_WriteEPhyUshort(sc, 0x46, 0x001F); MP_WriteEPhyUshort(sc, 0x4A, 0xB66B); MP_WriteEPhyUshort(sc, 0x41, 0xA84A); MP_WriteEPhyUshort(sc, 0x64, 0x000C); MP_WriteEPhyUshort(sc, 0x6F, 0x604A); MP_WriteEPhyUshort(sc, 0x4D, 0xF716); MP_WriteEPhyUshort(sc, 0x60, 0xD477); MP_WriteEPhyUshort(sc, 0x61, 0x4477); MP_WriteEPhyUshort(sc, 0x62, 0x0013); MP_WriteEPhyUshort(sc, 0x63, 0xBB66); MP_WriteEPhyUshort(sc, 0x4B, 0xA909); MP_WriteEPhyUshort(sc, 0x69, 0xFF04); MP_WriteEPhyUshort(sc, 0x5B, 0x1EA0); } else if (sc->re_type == MACFG_83) { MP_WriteEPhyUshort(sc, 0x0B, 0xA908); MP_WriteEPhyUshort(sc, 0x1E, 0x20EB); MP_WriteEPhyUshort(sc, 0x4B, 0xA908); MP_WriteEPhyUshort(sc, 0x5E, 0x20EB); ClearAndSetPCIePhyBit(sc, 0x22, (BIT_5 | BIT_4), BIT_5 ); ClearAndSetPCIePhyBit(sc, 0x62, (BIT_5 | BIT_4), BIT_5 ); } MP_WriteMcuAccessRegWord(sc, 0xC140, 0xFFFF); MP_WriteMcuAccessRegWord(sc, 0xC142, 0xFFFF); //old tx desc format data16 = MP_ReadMcuAccessRegWord(sc, 0xEB58); data16 &= ~(BIT_0); MP_WriteMcuAccessRegWord(sc, 0xEB58, data16); data16 = MP_ReadMcuAccessRegWord(sc, 0xE614); data16 &= ~( BIT_10 | BIT_9 | BIT_8); if (sc->re_type == MACFG_82 || sc->re_type == MACFG_83) { data16 |= ((2 & 0x07) << 8); } else { if (sc->re_dash && !(MP_ReadByteFun0PciEConfigSpace(sc, 0x79) & BIT_0)) data16 |= ((3 & 0x07) << 8); else data16 |= ((4 & 0x07) << 8); } MP_WriteMcuAccessRegWord(sc, 0xE614, data16); data16 = MP_ReadMcuAccessRegWord(sc, 0xE63E); data16 &= ~(BIT_11 | BIT_10); data16 |= ((0 & 0x03) << 10); MP_WriteMcuAccessRegWord(sc, 0xE63E, data16); data16 = MP_ReadMcuAccessRegWord(sc, 0xE63E); data16 &= ~(BIT_5 | BIT_4); if (sc->re_type == MACFG_80 || sc->re_type == MACFG_81) data16 |= ((0x02 & 0x03) << 4); MP_WriteMcuAccessRegWord(sc, 0xE63E, data16); data16 = MP_ReadMcuAccessRegWord(sc, 0xC0B4); data16 |= (BIT_3|BIT_2); MP_WriteMcuAccessRegWord(sc, 0xC0B4, data16); data16 = MP_ReadMcuAccessRegWord(sc, 0xEB6A); data16 &= ~(BIT_7 | BIT_6 | BIT_5 | BIT_4 | BIT_3 | BIT_2 | BIT_1 | BIT_0); data16 |= (BIT_5 | BIT_4 | BIT_1 | BIT_0); MP_WriteMcuAccessRegWord(sc, 0xEB6A, data16); data16 = MP_ReadMcuAccessRegWord(sc, 0xEB50); data16 &= ~(BIT_9 | BIT_8 | BIT_7 | BIT_6 | BIT_5); data16 |= (BIT_6); MP_WriteMcuAccessRegWord(sc, 0xEB50, data16); data16 = MP_ReadMcuAccessRegWord(sc, 0xE056); data16 &= ~(BIT_7 | BIT_6 | BIT_5 | BIT_4); data16 |= (BIT_4 | BIT_5); MP_WriteMcuAccessRegWord(sc, 0xE056, data16); CSR_WRITE_1(sc, 0xD0, CSR_READ_1(sc, 0xD0) | BIT_7); data16 = MP_ReadMcuAccessRegWord(sc, 0xE040); data16 &= ~(BIT_12); MP_WriteMcuAccessRegWord(sc, 0xE040, data16); data16 = MP_ReadMcuAccessRegWord(sc, 0xEA1C); data16 &= ~(BIT_1 | BIT_0); data16 |= (BIT_0); MP_WriteMcuAccessRegWord(sc, 0xEA1C, data16); data16 = MP_ReadMcuAccessRegWord(sc, 0xE0C0); data16 &= ~(BIT_14 | BIT_11 | BIT_10 | BIT_9 | BIT_8 | BIT_3 | BIT_2 | BIT_1 | BIT_0); data16 |= (BIT_14 | BIT_10 | BIT_1 | BIT_0); MP_WriteMcuAccessRegWord(sc, 0xE0C0, data16); SetMcuAccessRegBit(sc, 0xE052, (BIT_6|BIT_5|BIT_3)); ClearMcuAccessRegBit(sc, 0xE052, BIT_7); data16 = MP_ReadMcuAccessRegWord(sc, 0xC0AC); data16 &= ~(BIT_7); data16 |= (BIT_8|BIT_9|BIT_10|BIT_11|BIT_12); MP_WriteMcuAccessRegWord(sc, 0xC0AC, data16); data16 = MP_ReadMcuAccessRegWord(sc, 0xD430); 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, 0xD430, data16); //MP_WriteMcuAccessRegWord(sc, 0xE0C0, 0x4F87); data16 = MP_ReadMcuAccessRegWord(sc, 0xE84C); data16 &= ~BIT_6; if (sc->re_type == MACFG_80 || sc->re_type == MACFG_81) data16 |= BIT_6; data16 |= BIT_7; MP_WriteMcuAccessRegWord(sc, 0xE84C, data16); CSR_WRITE_1(sc, 0xD0, CSR_READ_1(sc, 0xD0) | BIT_6); if (sc->re_type == MACFG_80 || sc->re_type == MACFG_81) CSR_WRITE_1(sc, 0xD3, CSR_READ_1(sc, 0xD3) | BIT_0); MP_WriteMcuAccessRegWord(sc, 0xE080, MP_ReadMcuAccessRegWord(sc, 0xE080)&~BIT_1); data16 = MP_ReadMcuAccessRegWord(sc, 0xEA1C); data16 &= ~(BIT_2); MP_WriteMcuAccessRegWord(sc, 0xEA1C, data16); SetMcuAccessRegBit(sc, 0xEB54, BIT_0); DELAY(1); ClearMcuAccessRegBit(sc, 0xEB54, BIT_0); CSR_WRITE_2(sc, 0x1880, CSR_READ_2(sc, 0x1880) & ~(BIT_4 | BIT_5)); 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 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_1); 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); //clear wol re_clrwol(sc); if ((ifp->if_capenable & IFCAP_VLAN_HWTAGGING) != 0) CSR_WRITE_4(sc, RE_RXCFG, CSR_READ_4(sc, RE_RXCFG) | (BIT_22 | BIT_23)); else CSR_WRITE_4(sc, RE_RXCFG, CSR_READ_4(sc, RE_RXCFG) & ~(BIT_22 | BIT_23)); data16 = CSR_READ_2(sc, RE_CPlusCmd); if ((ifp->if_capenable & IFCAP_RXCSUM) != 0) data16 |= RL_RxChkSum; else data16 &= ~RL_RxChkSum; CSR_WRITE_2 (sc, RE_CPlusCmd, data16); re_disable_cfg9346_write(sc); /* Set the initial RX configuration.*/ /* * Program the multicast filter, if necessary. */ re_set_rx_packet_filter(sc); /* Enable transmit and receive.*/ CSR_WRITE_1(sc, RE_COMMAND, RE_CMD_TX_ENB | RE_CMD_RX_ENB); #ifndef __DragonFly__ ifp->if_drv_flags |= IFF_DRV_RUNNING; ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; /* * Enable interrupts. */ CSR_WRITE_4(sc, RE_IMR0_8125, RE_INTRS); #endif /* !__DragonFly__ */ } #ifndef __DragonFly__ /* * Initialize the transmit descriptors. */ static int re_var_init(struct re_softc *sc) { int i; union RxDesc *rxptr; union TxDesc *txptr; sc->re_desc.rx_cur_index = 0; sc->re_desc.rx_last_index = 0; rxptr = sc->re_desc.rx_desc; for (i = 0; i < RE_RX_BUF_NUM; i++) { memset(&rxptr[i], 0, sizeof(union RxDesc)); /* Init the RX buffer pointer register. */ bus_dmamap_load(sc->re_desc.re_rx_mtag, sc->re_desc.re_rx_dmamap[i], sc->re_desc.rx_buf[i]->m_data, sc->re_rx_desc_buf_sz, re_rx_dma_map_buf, &rxptr[i], 0); bus_dmamap_sync(sc->re_desc.re_rx_mtag, sc->re_desc.re_rx_dmamap[i], BUS_DMASYNC_PREREAD); rxptr[i].ul[0] = htole32(sc->re_rx_desc_buf_sz); if (i == (RE_RX_BUF_NUM - 1)) rxptr[i].ul[0] |= htole32(RL_RDESC_CMD_EOR); rxptr[i].ul[0] |= htole32(RL_RDESC_CMD_OWN); } bus_dmamap_load(sc->re_desc.rx_desc_tag, sc->re_desc.rx_desc_dmamap, sc->re_desc.rx_desc, sizeof(union RxDesc)*RE_RX_BUF_NUM, re_dma_map_rxdesc, sc, 0); bus_dmamap_sync(sc->re_desc.rx_desc_tag, sc->re_desc.rx_desc_dmamap, BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE); sc->re_desc.tx_cur_index = 0; sc->re_desc.tx_last_index = 0; txptr = sc->re_desc.tx_desc; for (i = 0; i < RE_TX_BUF_NUM; i++) { memset(&txptr[i], 0, sizeof(union TxDesc)); if (i == (RE_TX_BUF_NUM - 1)) txptr[i].ul[0] = htole32(RL_TDESC_CMD_EOR); } bus_dmamap_load(sc->re_desc.tx_desc_tag, sc->re_desc.tx_desc_dmamap, sc->re_desc.tx_desc, sizeof(union RxDesc) * RE_TX_BUF_NUM, re_dma_map_txdesc, sc, 0); bus_dmamap_sync(sc->re_desc.tx_desc_tag, sc->re_desc.tx_desc_dmamap, BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE); return 0; } #endif /* !__DragonFly__ */ static void re_reset(struct re_softc *sc) { register int i; CSR_WRITE_4(sc, RE_RXCFG, CSR_READ_4(sc, RE_RXCFG)& ~0x3F); switch (sc->re_type) { case MACFG_3: case MACFG_4: case MACFG_5: case MACFG_6: DELAY(10000); break; case MACFG_11: case MACFG_12: case MACFG_13: case MACFG_14: case MACFG_15: case MACFG_16: case MACFG_17: case MACFG_18: case MACFG_19: case MACFG_21: case MACFG_22: case MACFG_23: case MACFG_24: case MACFG_25: case MACFG_26: case MACFG_27: case MACFG_28: case MACFG_31: case MACFG_32: case MACFG_33: case MACFG_36: case MACFG_37: case MACFG_41: case MACFG_42: case MACFG_43: case MACFG_54: case MACFG_55: case MACFG_63: case MACFG_64: case MACFG_65: case MACFG_66: CSR_WRITE_1(sc, RE_COMMAND, 0x8C); break; case MACFG_38: case MACFG_39: case MACFG_50: case MACFG_51: case MACFG_52: case MACFG_53: CSR_WRITE_1(sc, RE_COMMAND, 0x8C); while (!(CSR_READ_4(sc,RE_TXCFG) & BIT_11)) DELAY(100); 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: case MACFG_72: case MACFG_80: case MACFG_81: case MACFG_82: case MACFG_83: DELAY(2000); break; default: DELAY(10000); break; } DELAY(200); CSR_WRITE_1(sc, RE_COMMAND, RE_CMD_RESET); for (i = 0; i < RE_TIMEOUT; i++) { DELAY(10); if (!(CSR_READ_1(sc, RE_COMMAND) & RE_CMD_RESET)) break; } if (i == RE_TIMEOUT) device_printf(sc->dev,"reset never completed!\n"); return; } static u_int8_t re_link_ok(struct re_softc *sc) { u_int8_t retval; retval = (CSR_READ_1(sc, RE_PHY_STATUS) & RL_PHY_STATUS_LINK_STS) ? 1 : 0; return retval; } static void re_set_wol_linkspeed(struct re_softc *sc) { u_int8_t wol_link_speed; u_int16_t anar; if (HW_SUPP_SERDES_PHY(sc)) return; #ifdef ENABLE_FIBER_SUPPORT if (HW_FIBER_MODE_ENABLED(sc)) return; #endif //ENABLE_FIBER_SUPPORT MP_WritePhyUshort(sc, 0x1F, 0x0000); wol_link_speed = RE_WOL_LINK_SPEED_100M_FIRST; if (!sc->re_dash) { u_int16_t anlpar; anlpar = sc->phy_reg_anlpar; if ((anlpar & ANLPAR_10_FD) || (anlpar & ANLPAR_10)) { wol_link_speed = RE_WOL_LINK_SPEED_10M_FIRST; } else { wol_link_speed = RE_WOL_LINK_SPEED_100M_FIRST; } } anar = MP_ReadPhyUshort(sc,MII_ANAR); if (wol_link_speed == RE_WOL_LINK_SPEED_10M_FIRST) anar &= ~(ANAR_TX_FD | ANAR_TX); if (sc->re_device_id==RT_DEVICEID_8125) { u_int16_t gbcr; ClearEthPhyOcpBit(sc, 0xA5D4, RTK_ADVERTISE_2500FULL); gbcr = MP_ReadPhyUshort(sc,MII_100T2CR); gbcr &= ~(GTCR_ADV_1000TFDX|GTCR_ADV_1000THDX); MP_WritePhyUshort(sc, MII_100T2CR, gbcr); MP_WritePhyUshort(sc, MII_ANAR, anar); MP_WritePhyUshort(sc, MII_BMCR, BMCR_RESET | BMCR_AUTOEN | BMCR_STARTNEG); } else if (sc->re_device_id==RT_DEVICEID_8169 || sc->re_device_id==RT_DEVICEID_8169SC || sc->re_device_id==RT_DEVICEID_8168 || sc->re_device_id==RT_DEVICEID_8161) { u_int16_t gbcr; gbcr = MP_ReadPhyUshort(sc,MII_100T2CR); gbcr &= ~(GTCR_ADV_1000TFDX|GTCR_ADV_1000THDX); MP_WritePhyUshort(sc, MII_100T2CR, gbcr); MP_WritePhyUshort(sc, MII_ANAR, anar); MP_WritePhyUshort(sc, MII_BMCR, BMCR_RESET | BMCR_AUTOEN | BMCR_STARTNEG); } else if (sc->re_type == MACFG_36) { MP_WritePhyUshort(sc, MII_ANAR, anar); MP_WritePhyUshort(sc, MII_BMCR, BMCR_RESET | BMCR_AUTOEN | BMCR_STARTNEG); } else { MP_WritePhyUshort(sc, MII_ANAR, anar); MP_WritePhyUshort(sc, MII_BMCR, BMCR_AUTOEN | BMCR_STARTNEG); } } #ifndef __DragonFly__ static void re_setwol(struct re_softc *sc) { struct ifnet *ifp; int pmc; uint16_t pmstat; uint8_t v; RE_LOCK_ASSERT(sc); ifp = RE_GET_IFNET(sc); if ((ifp->if_capenable & IFCAP_WOL) == 0) { re_phy_power_down(sc->dev); return; } if (pci_find_cap(sc->dev, PCIY_PMG, &pmc) != 0) return; /* Enable config register write. */ re_enable_cfg9346_write(sc); /* Enable PME. */ if (sc->re_device_id==RT_DEVICEID_8169 || sc->re_device_id==RT_DEVICEID_8169SC) { v = CSR_READ_1(sc, RE_CFG1); v &= ~RE_CFG1_PME; if ((ifp->if_capenable & IFCAP_WOL) != 0) v |= RE_CFG1_PME; CSR_WRITE_1(sc, RE_CFG1, v); } if (ifp->if_capenable & IFCAP_WOL_MAGIC) re_enable_magic_packet(sc); else re_disable_magic_packet(sc); v = CSR_READ_1(sc, RE_CFG5); v &= ~(RL_CFG5_WOL_BCAST | RL_CFG5_WOL_MCAST | RL_CFG5_WOL_UCAST | RL_CFG5_WOL_LANWAKE); if ((ifp->if_capenable & IFCAP_WOL_UCAST) != 0) v |= RL_CFG5_WOL_UCAST; if ((ifp->if_capenable & IFCAP_WOL_MCAST) != 0) v |= RL_CFG5_WOL_MCAST | RL_CFG5_WOL_BCAST; if ((ifp->if_capenable & IFCAP_WOL) != 0) v |= RL_CFG5_WOL_LANWAKE; CSR_WRITE_1(sc, RE_CFG5, v); /* Config register write done. */ re_disable_cfg9346_write(sc); /* * It seems that hardware resets its link speed to 100Mbps in * power down mode so switching to 100Mbps in driver is not * needed. */ /* Request PME if WOL is requested. */ pmstat = pci_read_config(sc->dev, pmc + PCIR_POWER_STATUS, 2); pmstat &= ~(PCIM_PSTAT_PMEENABLE); if ((ifp->if_capenable & IFCAP_WOL) != 0) pmstat |= PCIM_PSTAT_PMEENABLE; pci_write_config(sc->dev, pmc + PCIR_POWER_STATUS, pmstat, 2); /* Put controller into sleep mode. */ if ((ifp->if_capenable & IFCAP_WOL) != 0) { re_set_rx_packet_filter_in_sleep_state(sc); re_set_wol_linkspeed(sc); if (sc->re_type == MACFG_21 || sc->re_type == MACFG_22) CSR_WRITE_1(sc, RE_COMMAND, RE_CMD_RX_ENB); } } #endif /* !__DragonFly__ */ static void re_clrwol(struct re_softc *sc) { int pmc; uint16_t pmstat; uint8_t v; RE_LOCK_ASSERT(sc); #ifndef __DragonFly__ if (pci_find_cap(sc->dev, PCIY_PMG, &pmc) != 0) return; #else if (pci_find_extcap(sc->dev, PCIY_PMG, &pmc) != 0) return; #endif /* Disable PME and clear PME status. */ pmstat = pci_read_config(sc->dev, pmc + PCIR_POWER_STATUS, 2); pmstat &= ~PCIM_PSTAT_PMEENABLE; pci_write_config(sc->dev, pmc + PCIR_POWER_STATUS, pmstat, 2); /* Enable config register write. */ 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); v &= ~RE_CFG1_PME; CSR_WRITE_1(sc, RE_CFG1, v); } v = CSR_READ_1(sc, RE_CFG3); v &= ~(RL_CFG3_WOL_LINK); CSR_WRITE_1(sc, RE_CFG3, v); re_disable_magic_packet(sc); v = CSR_READ_1(sc, RE_CFG5); v &= ~(RL_CFG5_WOL_BCAST | RL_CFG5_WOL_MCAST | RL_CFG5_WOL_UCAST); v &= ~RL_CFG5_WOL_LANWAKE; CSR_WRITE_1(sc, RE_CFG5, v); /* Config register write done. */ re_disable_cfg9346_write(sc); } /* * Stop the adapter and free any mbufs allocated to the * RX and TX lists. */ #ifndef __DragonFly__ static void re_stop(struct re_softc *sc) /* Stop Driver */ #else /* __DragonFly__ */ static void re_stop_rtl(struct re_softc *sc) #endif /* !__DragonFly__ */ { #ifndef __DragonFly__ struct ifnet *ifp; /* RE_LOCK_ASSERT(sc);*/ ifp = RE_GET_IFNET(sc); #if OS_VER < VERSION(9,0) ifp->if_timer = 0; #endif re_stop_timer(sc); #endif /* !__DragonFly__ */ /* * Disable accepting frames to put RX MAC into idle state. * Otherwise it's possible to get frames while stop command * execution is in progress and controller can DMA the frame * to already freed RX buffer during that period. */ CSR_WRITE_4(sc, RE_RXCFG, CSR_READ_4(sc, RE_RXCFG) & ~(RE_RXCFG_RX_ALLPHYS | RE_RXCFG_RX_INDIV | RE_RXCFG_RX_MULTI | RE_RXCFG_RX_BROAD | RE_RXCFG_RX_RUNT | RE_RXCFG_RX_ERRPKT)); if (sc->re_device_id==RT_DEVICEID_8125) { CSR_WRITE_4(sc, RE_IMR0_8125, 0x00000000); CSR_WRITE_4(sc, RE_ISR0_8125, 0xffffffff); } else { CSR_WRITE_2(sc, RE_IMR, 0x0000); CSR_WRITE_2(sc, RE_ISR, 0xffff); } if (sc->re_type == MACFG_50 || sc->re_type == MACFG_51 || sc->re_type == MACFG_52) { re_eri_write(sc, 0x1bc, 4, 0x0000001f, ERIAR_ExGMAC); re_eri_write(sc, 0x1dc, 4, 0x0000002d, ERIAR_ExGMAC); } else if (sc->re_type == MACFG_38) { re_eri_write(sc, 0x1bc, 4, 0x0000001f, ERIAR_ExGMAC); re_eri_write(sc, 0x1dc, 4, 0x0000003f, ERIAR_ExGMAC); } re_reset(sc); #ifndef __DragonFly__ /* * Free the TX list buffers. */ while (sc->re_desc.tx_last_index!=sc->re_desc.tx_cur_index) { if (sc->re_desc.re_tx_mtag) { bus_dmamap_sync(sc->re_desc.re_tx_mtag, sc->re_desc.re_tx_dmamap[sc->re_desc.tx_last_index], BUS_DMASYNC_POSTWRITE); bus_dmamap_unload(sc->re_desc.re_tx_mtag, sc->re_desc.re_tx_dmamap[sc->re_desc.tx_last_index]); } if (sc->re_desc.tx_buf[sc->re_desc.tx_last_index]!=NULL) { m_freem(sc->re_desc.tx_buf[sc->re_desc.tx_last_index]); sc->re_desc.tx_buf[sc->re_desc.tx_last_index] = NULL; } sc->re_desc.tx_last_index = (sc->re_desc.tx_last_index+1)%RE_TX_BUF_NUM; } ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE); return; #endif /* !__DragonFly__ */ } #ifndef __DragonFly__ /* * Main transmit routine. */ static void re_start(struct ifnet *ifp) /* Transmit Packet*/ { struct re_softc *sc; struct mbuf *m_head = NULL; sc = ifp->if_softc; /* Paste to ifp in function re_attach(dev) */ RE_LOCK(sc); /* RE_LOCK_ASSERT(sc);*/ if ((sc->driver_detach == 1) || (sc->rx_fifo_overflow != 0)) { RE_UNLOCK(sc); return; } while (1) { int fs = 1, ls = 0, TxLen = 0, PktLen; struct mbuf *ptr; uint32_t opts1 =0; uint32_t opts2 =0; IFQ_DRV_DEQUEUE(&ifp->if_snd, m_head); /* Remove(get) data from system transmit queue */ if (m_head == NULL) { break; } if (sc->re_coalesce_tx_pkt) { if (re_encap(sc, m_head)) { IFQ_DRV_PREPEND(&ifp->if_snd, m_head); ifp->if_drv_flags |= IFF_DRV_OACTIVE; break; } m_head = sc->re_desc.tx_buf[sc->re_desc.tx_cur_index]; } if (CountMbufNum(m_head) > CountFreeTxDescNum(sc->re_desc)) { /* No enough descriptor */ IFQ_DRV_PREPEND(&ifp->if_snd, m_head); ifp->if_drv_flags |= IFF_DRV_OACTIVE; break; } if (ifp->if_bpf) { /* If there's a BPF listener, bounce a copy of this frame to him. */ //printf("If there's a BPF listener, bounce a copy of this frame to him. \n"); /*#if OS_VER < VERSION(5, 1)*/ #if OS_VER < VERSION(4,9) bpf_mtap(ifp, m_head); #else bpf_mtap(ifp->if_bpf, m_head); #endif } //hw checksum if (ifp->if_capenable & IFCAP_TXCSUM) { if ((m_head->m_pkthdr.csum_flags & RE_CSUM_FEATURES) !=0) { if (!(sc->re_if_flags & RL_FLAG_DESCV2)) { opts1 |= RL_IPV4CS1; if ((m_head->m_pkthdr.csum_flags & CSUM_TCP)!=0) opts1 |=RL_TCPCS1; if ((m_head->m_pkthdr.csum_flags & CSUM_UDP)!=0) opts1 |=RL_UDPCS1; } else { opts2 |= RL_IPV4CS; if ((m_head->m_pkthdr.csum_flags & CSUM_TCP)!=0) opts2 |= RL_TCPCS; else if ((m_head->m_pkthdr.csum_flags & CSUM_UDP)!=0) opts2 |= RL_UDPCS; } } } //vlan if (m_head->m_flags & M_VLANTAG) opts2 |= bswap16(m_head->m_pkthdr.ether_vtag) | RL_TDESC_VLANCTL_TAG; ptr = m_head; PktLen = ptr->m_pkthdr.len; #ifdef _DEBUG_ printf("PktLen=%d",PktLen); #endif while (ptr!=NULL) { if (ptr->m_len >0) { #ifdef _DEBUG_ printf(", len=%d T=%d F=%d",ptr->m_len,ptr->m_type,ptr->m_flags); #endif TxLen += ptr->m_len; if (TxLen >= PktLen) { ls=1; sc->re_desc.tx_buf[sc->re_desc.tx_cur_index] = m_head; } else sc->re_desc.tx_buf[sc->re_desc.tx_cur_index] = NULL; //vlan WritePacket(sc,ptr->m_data,ptr->m_len,fs,ls,opts2,opts1); fs=0; } ptr = ptr->m_next; } #ifdef _DEBUG_ printf("\n"); #endif } #if OS_VER < VERSION(9,0) ifp->if_timer = 5; #endif RE_UNLOCK(sc); return; } /* * Encapsulate an mbuf chain in a descriptor by coupling the mbuf data * pointers to the fragment pointers. */ static int re_encap(struct re_softc *sc,struct mbuf *m_head) { struct mbuf *m_new = NULL; m_new = m_defrag(m_head, M_DONTWAIT); if (m_new == NULL) { printf("re%d: no memory for tx list", sc->re_unit); return (1); } m_head = m_new; /* Pad frames to at least 60 bytes. */ if (m_head->m_pkthdr.len < RE_MIN_FRAMELEN) { /* Case length < 60 bytes */ /* * Make security concious people happy: zero out the * bytes in the pad area, since we don't know what * this mbuf cluster buffer's previous user might * have left in it. */ bzero(mtod(m_head, char *) + m_head->m_pkthdr.len, RE_MIN_FRAMELEN - m_head->m_pkthdr.len); m_head->m_pkthdr.len = RE_MIN_FRAMELEN; m_head->m_len = m_head->m_pkthdr.len; } sc->re_desc.tx_buf[sc->re_desc.tx_cur_index] = m_head; return(0); } static void WritePacket(struct re_softc *sc, caddr_t addr, int len,int fs_flag,int ls_flag, uint32_t opts2,uint32_t opts1) { union TxDesc *txptr; uint32_t status; uint32_t tx_cur_index = sc->re_desc.tx_cur_index; txptr =&(sc->re_desc.tx_desc[tx_cur_index]); status = RL_TDESC_CMD_OWN | opts1 | len; if (fs_flag) status |= RL_TDESC_CMD_SOF; if (ls_flag) status |= RL_TDESC_CMD_EOF; if (tx_cur_index == (RE_TX_BUF_NUM - 1)) status |= RL_TDESC_CMD_EOR; bus_dmamap_load(sc->re_desc.re_tx_mtag, sc->re_desc.re_tx_dmamap[tx_cur_index], addr, len, re_tx_dma_map_buf, txptr, 0); bus_dmamap_sync(sc->re_desc.re_tx_mtag, sc->re_desc.re_tx_dmamap[tx_cur_index], BUS_DMASYNC_PREWRITE); txptr->ul[1] = htole32(opts2); txptr->ul[0] = htole32(status); bus_dmamap_sync(sc->re_desc.tx_desc_tag, sc->re_desc.tx_desc_dmamap, BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE); if (ls_flag) { if (sc->re_device_id==RT_DEVICEID_8125) { CSR_WRITE_2(sc, RE_TPPOLL_8125, RE_NPQ_8125); CSR_WRITE_2(sc, RE_TPPOLL_8125, RE_NPQ_8125); } else { CSR_WRITE_1(sc, RE_TPPOLL, RE_NPQ); CSR_WRITE_1(sc, RE_TPPOLL, RE_NPQ); } } sc->re_desc.tx_cur_index = (tx_cur_index+1)%RE_TX_BUF_NUM; } static int CountFreeTxDescNum(struct re_descriptor desc) { int ret=desc.tx_last_index-desc.tx_cur_index; if (ret<=0) ret+=RE_TX_BUF_NUM; ret--; return ret; } static int CountMbufNum(struct mbuf *m_head) { int ret=0; struct mbuf *ptr = m_head; while (ptr!=NULL) { if (ptr->m_len >0) ret++; ptr=ptr->m_next; } return ret; } #ifdef RE_FIXUP_RX static __inline void re_fixup_rx(struct mbuf *m) { int i; uint16_t *src, *dst; src = mtod(m, uint16_t *); dst = src - (RE_ETHER_ALIGN - ETHER_ALIGN) / sizeof *src; for (i = 0; i < (m->m_len / sizeof(uint16_t) + 1); i++) *dst++ = *src++; m->m_data -= RE_ETHER_ALIGN - ETHER_ALIGN; } #endif /* * A frame was downloaded to the chip. It's safe for us to clean up * the list buffers. */ static void re_txeof(struct re_softc *sc) /* Transmit OK/ERR handler */ { union TxDesc *txptr; struct ifnet *ifp; u_int32_t txstat; /* printf("X");*/ ifp = RE_GET_IFNET(sc); #if OS_VER < VERSION(9,0) /* Clear the timeout timer. */ ifp->if_timer = 0; #endif bus_dmamap_sync(sc->re_desc.tx_desc_tag, sc->re_desc.tx_desc_dmamap, BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE); while (sc->re_desc.tx_last_index!=sc->re_desc.tx_cur_index) { txptr=&(sc->re_desc.tx_desc[sc->re_desc.tx_last_index]); txstat = le32toh(txptr->ul[0]); if (txstat & RL_TDESC_STAT_OWN) break; #ifdef _DEBUG_ printf("**** Tx OK ****\n"); #endif bus_dmamap_sync(sc->re_desc.re_tx_mtag, sc->re_desc.re_tx_dmamap[sc->re_desc.tx_last_index], BUS_DMASYNC_POSTWRITE); bus_dmamap_unload(sc->re_desc.re_tx_mtag, sc->re_desc.re_tx_dmamap[sc->re_desc.tx_last_index]); if (sc->re_desc.tx_buf[sc->re_desc.tx_last_index]!=NULL) { m_freem(sc->re_desc.tx_buf[sc->re_desc.tx_last_index]); /* Free Current MBuf in a Mbuf list*/ sc->re_desc.tx_buf[sc->re_desc.tx_last_index] = NULL; } sc->re_desc.tx_last_index = (sc->re_desc.tx_last_index+1)%RE_TX_BUF_NUM; #if OS_VER < VERSION(11,0) if (txstat & (RL_TDESC_STAT_EXCESSCOL| RL_TDESC_STAT_COLCNT)) ifp->if_collisions++; if (txstat & RL_TDESC_STAT_TXERRSUM) ifp->if_oerrors++; else ifp->if_opackets++; #else if (txstat & (RL_TDESC_STAT_EXCESSCOL| RL_TDESC_STAT_COLCNT)) if_inc_counter(ifp, IFCOUNTER_COLLISIONS, 1); if (txstat & RL_TDESC_STAT_TXERRSUM) if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); else if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1); #endif ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; } return; } /* * A frame has been uploaded: pass the resulting mbuf chain up to * the higher level protocols. * * You know there's something wrong with a PCI bus-master chip design * when you have to use m_devget(). * * The receive operation is badly documented in the datasheet, so I'll * attempt to document it here. The driver provides a buffer area and * places its base address in the RX buffer start address register. * The chip then begins copying frames into the RX buffer. Each frame * is preceeded by a 32-bit RX status word which specifies the length * of the frame and certain other status bits. Each frame (starting with * the status word) is also 32-bit aligned. The frame length is in the * first 16 bits of the status word; the lower 15 bits correspond with * the 'rx status register' mentioned in the datasheet. * * Note: to make the Alpha happy, the frame payload needs to be aligned * on a 32-bit boundary. To achieve this, we cheat a bit by copying from * the ring buffer starting at an address two bytes before the actual * data location. We can then shave off the first two bytes using m_adj(). * The reason we do this is because m_devget() doesn't let us specify an * offset into the mbuf storage space, so we have to artificially create * one. The ring is allocated in such a way that there are a few unused * bytes of space preceecing it so that it will be safe for us to do the * 2-byte backstep even if reading from the ring at offset 0. */ static void re_rxeof(sc) /* Receive Data OK/ERR handler */ struct re_softc *sc; { struct ether_header *eh; struct mbuf *m; struct ifnet *ifp; union RxDesc *rxptr; int bError; struct mbuf *buf; int size; int maxpkt = RE_RX_BUF_NUM; u_int32_t rx_cur_index; u_int32_t opts2,opts1,status; /* RE_LOCK_ASSERT(sc);*/ ifp = RE_GET_IFNET(sc); bus_dmamap_sync(sc->re_desc.rx_desc_tag, sc->re_desc.rx_desc_dmamap, BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE); rx_cur_index = sc->re_desc.rx_cur_index; rxptr=&(sc->re_desc.rx_desc[rx_cur_index]); opts1 = le32toh(rxptr->ul[0]); while ((opts1&RL_RDESC_STAT_OWN)==0) { /* Receive OK */ bError = 0; sc->re_desc.rx_cur_index = (rx_cur_index+1)%RE_RX_BUF_NUM; /* Check if this packet is received correctly*/ if (opts1&0x200000) { /*Check RES bit*/ bError=1; #if OS_VER < VERSION(11,0) ifp->if_ierrors++; #else if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); #endif goto update_desc; } opts2 = le32toh(rxptr->ul[1]); //buf = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR); /* Alloc a new mbuf */ if (sc->re_rx_mbuf_sz <= MCLBYTES) size = MCLBYTES; else if (sc->re_rx_mbuf_sz <= MJUMPAGESIZE) size = MJUMPAGESIZE; else size = MJUM9BYTES; buf = m_getjcl(M_DONTWAIT, MT_DATA, M_PKTHDR, size); if (buf==NULL) { bError=1; #if OS_VER < VERSION(11,0) ifp->if_iqdrops++; #else if_inc_counter(ifp, IFCOUNTER_IQDROPS, 1); #endif goto update_desc; } buf->m_len = buf->m_pkthdr.len = size; #ifdef RE_FIXUP_RX /* * This is part of an evil trick to deal with non-x86 platforms. * The RealTek chip requires RX buffers to be aligned on 64-bit * boundaries, but that will hose non-x86 machines. To get around * this, we leave some empty space at the start of each buffer * and for non-x86 hosts, we copy the buffer back six bytes * to achieve word alignment. This is slightly more efficient * than allocating a new buffer, copying the contents, and * discarding the old buffer. */ m_adj(buf, RE_ETHER_ALIGN); #endif bus_dmamap_sync(sc->re_desc.re_rx_mtag, sc->re_desc.re_rx_dmamap[rx_cur_index], BUS_DMASYNC_POSTREAD); bus_dmamap_unload(sc->re_desc.re_rx_mtag, sc->re_desc.re_rx_dmamap[rx_cur_index]); m = sc->re_desc.rx_buf[rx_cur_index]; sc->re_desc.rx_buf[rx_cur_index] = buf; m->m_pkthdr.len = m->m_len = (opts1&RL_RDESC_STAT_GFRAGLEN)-ETHER_CRC_LEN; m->m_pkthdr.rcvif = ifp; #ifdef RE_FIXUP_RX re_fixup_rx(m); #endif //vlan if (opts2 & RL_RDESC_VLANCTL_TAG) { m->m_pkthdr.ether_vtag = bswap16((opts2 & RL_RDESC_VLANCTL_DATA)); m->m_flags |= M_VLANTAG; } if (ifp->if_capenable & IFCAP_RXCSUM) { if (!(sc->re_if_flags & RL_FLAG_DESCV2)) { if (opts1 & RL_ProtoIP) m->m_pkthdr.csum_flags |= CSUM_IP_CHECKED; if (!(opts1 & RL_IPF)) m->m_pkthdr.csum_flags |= CSUM_IP_VALID; if ((((opts1 & RL_ProtoIP)==(1<<17)) && !(opts1 & RL_TCPF)) || (((opts1 & RL_ProtoIP)==(1<<18)) && !(opts1 & RL_UDPF))) { m->m_pkthdr.csum_flags |= CSUM_DATA_VALID|CSUM_PSEUDO_HDR; m->m_pkthdr.csum_data = 0xffff; } } else { if ((opts1 & RL_ProtoIP) && (opts2 & RL_V4F)) m->m_pkthdr.csum_flags |= CSUM_IP_CHECKED; if (!(opts1 & RL_IPF) && (opts2 & RL_V4F)) m->m_pkthdr.csum_flags |= CSUM_IP_VALID; if (((opts1 & RL_TCPT) && !(opts2 & RL_TCPF)) || ((opts1 & RL_UDPT) && !(opts2 & RL_UDPF))) { m->m_pkthdr.csum_flags |= CSUM_DATA_VALID|CSUM_PSEUDO_HDR; m->m_pkthdr.csum_data = 0xffff; } } } eh = mtod(m, struct ether_header *); #if OS_VER < VERSION(11,0) ifp->if_ipackets++; #else if_inc_counter(ifp, IFCOUNTER_IPACKETS, 1); #endif #ifdef _DEBUG_ printf("Rcv Packet, Len=%d \n", m->m_len); #endif RE_UNLOCK(sc); /*#if OS_VER < VERSION(5, 1)*/ #if OS_VER < VERSION(4,9) /* Remove header from mbuf and pass it on. */ m_adj(m, sizeof(struct ether_header)); ether_input(ifp, eh, m); #else (*ifp->if_input)(ifp, m); #endif RE_LOCK(sc); update_desc: //rxptr->ul[0]&=htole32(0x40000000); /* keep EOR bit */ rxptr->ul[1]=0; status = RL_RDESC_CMD_OWN | sc->re_rx_desc_buf_sz; if (rx_cur_index == (RE_RX_BUF_NUM - 1)) status |= RL_RDESC_CMD_EOR; if (!bError) { bus_dmamap_load(sc->re_desc.re_rx_mtag, sc->re_desc.re_rx_dmamap[rx_cur_index], sc->re_desc.rx_buf[rx_cur_index]->m_data, sc->re_rx_desc_buf_sz, re_rx_dma_map_buf, rxptr, 0); bus_dmamap_sync(sc->re_desc.re_rx_mtag, sc->re_desc.re_rx_dmamap[rx_cur_index], BUS_DMASYNC_PREREAD); } rxptr->ul[0] = htole32(status); rx_cur_index = sc->re_desc.rx_cur_index; rxptr=&sc->re_desc.rx_desc[rx_cur_index]; opts1 = le32toh(rxptr->ul[0]); maxpkt--; if (maxpkt==0) break; } bus_dmamap_sync(sc->re_desc.rx_desc_tag, sc->re_desc.rx_desc_dmamap, BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE); return; } #if OS_VER < VERSION(7,0) static void re_intr(void *arg) /* Interrupt Handler */ #else static int re_intr(void *arg) /* Interrupt Handler */ #endif //OS_VER < VERSION(7,0) { struct re_softc *sc; sc = arg; if ((sc->re_if_flags & (RL_FLAG_MSI | RL_FLAG_MSIX)) == 0) { if ((CSR_READ_2(sc, RE_ISR) & RE_INTRS) == 0) { #if OS_VER < VERSION(7,0) return; #else return (FILTER_STRAY); #endif } } /* Disable interrupts. */ CSR_WRITE_2(sc, RE_IMR, 0x0000); #if OS_VER < VERSION(7,0) re_int_task(arg, 0); #else //OS_VER < VERSION(7,0) #if OS_VER < VERSION(11,0) taskqueue_enqueue_fast(taskqueue_fast, &sc->re_inttask); #else ////OS_VER < VERSION(11,0) taskqueue_enqueue(taskqueue_fast, &sc->re_inttask); #endif //OS_VER < VERSION(11,0) return (FILTER_HANDLED); #endif //OS_VER < VERSION(7,0) } #if OS_VER < VERSION(7,0) static void re_intr_8125(void *arg) /* Interrupt Handler */ #else static int re_intr_8125(void *arg) /* Interrupt Handler */ #endif //OS_VER < VERSION(7,0) { struct re_softc *sc; sc = arg; if ((sc->re_if_flags & (RL_FLAG_MSI | RL_FLAG_MSIX)) == 0) { if ((CSR_READ_4(sc, RE_ISR0_8125) & RE_INTRS) == 0) { #if OS_VER < VERSION(7,0) return; #else return (FILTER_STRAY); #endif } } /* Disable interrupts. */ CSR_WRITE_4(sc, RE_IMR0_8125, 0x00000000); #if OS_VER < VERSION(7,0) re_int_task_8125(arg, 0); #else //OS_VER < VERSION(7,0) #if OS_VER < VERSION(11,0) taskqueue_enqueue_fast(taskqueue_fast, &sc->re_inttask); #else ////OS_VER < VERSION(11,0) taskqueue_enqueue(taskqueue_fast, &sc->re_inttask); #endif //OS_VER < VERSION(11,0) return (FILTER_HANDLED); #endif //OS_VER < VERSION(7,0) } static void re_int_task(void *arg, int npending) { struct re_softc *sc; struct ifnet *ifp; u_int32_t status; sc = arg; RE_LOCK(sc); ifp = RE_GET_IFNET(sc); status = CSR_READ_2(sc, RE_ISR); if (status) { CSR_WRITE_2(sc, RE_ISR, status & ~RE_ISR_FIFO_OFLOW); } if (sc->suspended || (ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) { RE_UNLOCK(sc); return; } re_rxeof(sc); if (sc->re_type == MACFG_21) { if (status & RE_ISR_FIFO_OFLOW) { sc->rx_fifo_overflow = 1; CSR_WRITE_2(sc, RE_IntrMitigate, 0x0000); CSR_WRITE_4(sc, RE_TIMERCNT, 0x4000); CSR_WRITE_4(sc, RE_TIMERINT, 0x4000); } else { sc->rx_fifo_overflow = 0; CSR_WRITE_4(sc,RE_CPlusCmd, 0x51512082); } if (status & RE_ISR_PCS_TIMEOUT) { if ((status & RE_ISR_FIFO_OFLOW) && (!(status & (RE_ISR_RX_OK | RE_ISR_TX_OK | RE_ISR_RX_OVERRUN)))) { re_reset(sc); re_init(sc); sc->rx_fifo_overflow = 0; CSR_WRITE_2(sc, RE_ISR, RE_ISR_FIFO_OFLOW); } } } re_txeof(sc); if (status & RE_ISR_SYSTEM_ERR) { re_reset(sc); re_init(sc); } switch(sc->re_type) { case MACFG_21: case MACFG_22: case MACFG_23: case MACFG_24: CSR_WRITE_1(sc, RE_TPPOLL, RE_NPQ); break; default: break; } RE_UNLOCK(sc); if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd)) re_start(ifp); #if OS_VER>=VERSION(7,0) if (CSR_READ_2(sc, RE_ISR) & RE_INTRS) { #if OS_VER < VERSION(11,0) taskqueue_enqueue_fast(taskqueue_fast, &sc->re_inttask); #else ////OS_VER < VERSION(11,0) taskqueue_enqueue(taskqueue_fast, &sc->re_inttask); #endif //OS_VER < VERSION(11,0) return; } #endif //OS_VER>=VERSION(7,0) /* Re-enable interrupts. */ CSR_WRITE_2(sc, RE_IMR, RE_INTRS); } static void re_int_task_8125(void *arg, int npending) { struct re_softc *sc; struct ifnet *ifp; u_int32_t status; sc = arg; RE_LOCK(sc); ifp = RE_GET_IFNET(sc); status = CSR_READ_4(sc, RE_ISR0_8125); if (status) { CSR_WRITE_4(sc, RE_ISR0_8125, status & ~RE_ISR_FIFO_OFLOW); } if (sc->suspended || (ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) { RE_UNLOCK(sc); return; } re_rxeof(sc); re_txeof(sc); if (status & RE_ISR_SYSTEM_ERR) { re_reset(sc); re_init(sc); } RE_UNLOCK(sc); if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd)) re_start(ifp); #if OS_VER>=VERSION(7,0) if (CSR_READ_4(sc, RE_ISR0_8125) & RE_INTRS) { #if OS_VER < VERSION(11,0) taskqueue_enqueue_fast(taskqueue_fast, &sc->re_inttask); #else ////OS_VER < VERSION(11,0) taskqueue_enqueue(taskqueue_fast, &sc->re_inttask); #endif //OS_VER < VERSION(11,0) return; } #endif //OS_VER>=VERSION(7,0) /* Re-enable interrupts. */ CSR_WRITE_4(sc, RE_IMR0_8125, RE_INTRS); } #endif /* !__DragonFly__ */ static void re_set_multicast_reg(struct re_softc *sc, u_int32_t mask0, u_int32_t mask4) { u_int8_t enable_cfg_reg_write = 0; if (sc->re_type == MACFG_5 || sc->re_type == MACFG_6) enable_cfg_reg_write = 1; if (enable_cfg_reg_write) re_enable_cfg9346_write(sc); CSR_WRITE_4(sc, RE_MAR0, mask0); CSR_WRITE_4(sc, RE_MAR4, mask4); if (enable_cfg_reg_write) re_disable_cfg9346_write(sc); return; } #ifndef __DragonFly__ static void re_set_rx_packet_filter_in_sleep_state(sc) struct re_softc *sc; { struct ifnet *ifp; u_int32_t rxfilt; ifp = RE_GET_IFNET(sc); rxfilt = CSR_READ_4(sc, RE_RXCFG); rxfilt &= ~(RE_RXCFG_RX_ALLPHYS | RE_RXCFG_RX_INDIV | RE_RXCFG_RX_MULTI | RE_RXCFG_RX_BROAD | RE_RXCFG_RX_RUNT | RE_RXCFG_RX_ERRPKT); rxfilt |= (RE_RXCFG_RX_INDIV | RE_RXCFG_RX_MULTI | RE_RXCFG_RX_BROAD); CSR_WRITE_4(sc, RE_RXCFG, rxfilt); re_set_multicast_reg(sc, 0xFFFFFFFF, 0xFFFFFFFF); return; } #endif /* !__DragonFly__ */ static void re_set_rx_packet_filter(struct re_softc *sc) { struct ifnet *ifp; u_int32_t rxfilt; ifp = RE_GET_IFNET(sc); rxfilt = CSR_READ_4(sc, RE_RXCFG); rxfilt |= RE_RXCFG_RX_INDIV; if (ifp->if_flags & (IFF_MULTICAST | IFF_ALLMULTI | IFF_PROMISC)) { rxfilt |= (RE_RXCFG_RX_ALLPHYS | RE_RXCFG_RX_MULTI); } else { rxfilt &= ~(RE_RXCFG_RX_MULTI); } if (ifp->if_flags & IFF_PROMISC) { rxfilt |= (RE_RXCFG_RX_ALLPHYS | RE_RXCFG_RX_RUNT | RE_RXCFG_RX_ERRPKT); } else { rxfilt &= ~(RE_RXCFG_RX_ALLPHYS | RE_RXCFG_RX_RUNT | RE_RXCFG_RX_ERRPKT); } if (ifp->if_flags & (IFF_BROADCAST | IFF_PROMISC)) { rxfilt |= RE_RXCFG_RX_BROAD; } else { rxfilt &= ~RE_RXCFG_RX_BROAD; } CSR_WRITE_4(sc, RE_RXCFG, rxfilt); re_setmulti(sc); return; } /* * Program the 64-bit multicast hash filter. */ static void re_setmulti(struct re_softc *sc) { struct ifnet *ifp; int h = 0; u_int32_t hashes[2] = { 0, 0 }; struct ifmultiaddr *ifma; u_int32_t rxfilt; int mcnt = 0; ifp = RE_GET_IFNET(sc); rxfilt = CSR_READ_4(sc, RE_RXCFG); if (ifp->if_flags & IFF_ALLMULTI || ifp->if_flags & IFF_PROMISC) { rxfilt |= RE_RXCFG_RX_MULTI; CSR_WRITE_4(sc, RE_RXCFG, rxfilt); re_set_multicast_reg(sc, 0xFFFFFFFF, 0xFFFFFFFF); return; } #ifndef __DragonFly__ /* now program new ones */ #if OS_VER > VERSION(6,0) IF_ADDR_LOCK(ifp); #endif #if OS_VER < VERSION(4,9) for (ifma = ifp->if_multiaddrs.lh_first; ifma != NULL; ifma = ifma->ifma_link.le_next) #elif OS_VER < VERSION(12,0) TAILQ_FOREACH(ifma,&ifp->if_multiaddrs,ifma_link) #else CK_STAILQ_FOREACH(ifma,&ifp->if_multiaddrs,ifma_link) #endif #else /* __DragonFly__ */ TAILQ_FOREACH(ifma,&ifp->if_multiaddrs,ifma_link) #endif /* !__DragonFly__ */ { if (ifma->ifma_addr->sa_family != AF_LINK) continue; h = ether_crc32_be(LLADDR((struct sockaddr_dl *) ifma->ifma_addr), ETHER_ADDR_LEN) >> 26; if (h < 32) hashes[0] |= (1 << h); else hashes[1] |= (1 << (h - 32)); mcnt++; } #ifndef __DragonFly__ #if OS_VER > VERSION(6,0) IF_ADDR_UNLOCK(ifp); #endif #endif /* !__DragonFly__ */ if (mcnt) { if ((sc->re_if_flags & RL_FLAG_PCIE) != 0) { h = bswap32(hashes[0]); hashes[0] = bswap32(hashes[1]); hashes[1] = h; } rxfilt |= RE_RXCFG_RX_MULTI; } else rxfilt &= ~RE_RXCFG_RX_MULTI; CSR_WRITE_4(sc, RE_RXCFG, rxfilt); re_set_multicast_reg(sc, hashes[0], hashes[1]); return; } #ifndef __DragonFly__ static int re_ioctl(ifp, command, data) struct ifnet *ifp; u_long command; caddr_t data; { struct re_softc *sc = ifp->if_softc; struct ifreq *ifr = (struct ifreq *) data; /*int s;*/ int error = 0; int mask, reinit; /*s = splimp();*/ switch(command) { case SIOCSIFADDR: case SIOCGIFADDR: error = ether_ioctl(ifp, command, data); break; case SIOCSIFMTU: //printf("before mtu =%d\n",(int)ifp->if_mtu); if (ifr->ifr_mtu > sc->max_jumbo_frame_size) error = EINVAL; else { ifp->if_mtu = ifr->ifr_mtu; //if running if (ifp->if_drv_flags & IFF_DRV_RUNNING) { //printf("set mtu when running\n"); RE_LOCK(sc); re_stop(sc); re_release_buf(sc); set_rxbufsize(sc); error =re_alloc_buf(sc); if (error == 0) { re_init(sc); } RE_UNLOCK(sc); } else { //if not running RE_LOCK(sc); re_release_buf(sc); set_rxbufsize(sc); error =re_alloc_buf(sc); if (error == 0) { /* Init descriptors. */ re_var_init(sc); } RE_UNLOCK(sc); } } // printf("after mtu =%d\n",(int)ifp->if_mtu); break; case SIOCSIFFLAGS: RE_LOCK(sc); if (ifp->if_flags & IFF_UP) { re_init(sc); } else if (ifp->if_drv_flags & IFF_DRV_RUNNING) { re_stop(sc); } error = 0; RE_UNLOCK(sc); break; case SIOCADDMULTI: case SIOCDELMULTI: RE_LOCK(sc); re_set_rx_packet_filter(sc); RE_UNLOCK(sc); error = 0; break; case SIOCGIFMEDIA: case SIOCSIFMEDIA: error = ifmedia_ioctl(ifp, ifr, &sc->media, command); break; case SIOCSIFCAP: mask = ifr->ifr_reqcap ^ ifp->if_capenable; reinit = 0; if ((mask & IFCAP_TXCSUM) != 0 && (ifp->if_capabilities & IFCAP_TXCSUM) != 0) { ifp->if_capenable ^= IFCAP_TXCSUM; if ((ifp->if_capenable & IFCAP_TXCSUM) != 0) { if ((sc->re_type == MACFG_24) || (sc->re_type == MACFG_25) || (sc->re_type == MACFG_26)) ifp->if_hwassist |= CSUM_TCP | CSUM_UDP; else ifp->if_hwassist |= RE_CSUM_FEATURES; } else ifp->if_hwassist &= ~RE_CSUM_FEATURES; reinit = 1; } if ((mask & IFCAP_RXCSUM) != 0 && (ifp->if_capabilities & IFCAP_RXCSUM) != 0) { ifp->if_capenable ^= IFCAP_RXCSUM; reinit = 1; } if ((ifp->if_mtu <= ETHERMTU) || ((sc->re_type>= MACFG_3) &&(sc->re_type <=MACFG_6)) || ((sc->re_type>= MACFG_21) && (sc->re_type <=MACFG_23))) { if (ifp->if_capenable & IFCAP_TXCSUM) sc->re_tx_cstag = 1; else sc->re_tx_cstag = 0; if (ifp->if_capenable & IFCAP_RXCSUM) sc->re_rx_cstag = 1; else sc->re_rx_cstag = 0; } if ((mask & IFCAP_VLAN_HWTAGGING) != 0 && (ifp->if_capabilities & IFCAP_VLAN_HWTAGGING) != 0) { ifp->if_capenable ^= IFCAP_VLAN_HWTAGGING; /* TSO over VLAN requires VLAN hardware tagging. */ //if ((ifp->if_capenable & IFCAP_VLAN_HWTAGGING) == 0) // ifp->if_capenable &= ~IFCAP_VLAN_HWTSO; reinit = 1; } if ((mask & IFCAP_WOL) != 0 && (ifp->if_capabilities & IFCAP_WOL) != 0) { if ((mask & IFCAP_WOL_UCAST) != 0) ifp->if_capenable ^= IFCAP_WOL_UCAST; if ((mask & IFCAP_WOL_MCAST) != 0) ifp->if_capenable ^= IFCAP_WOL_MCAST; if ((mask & IFCAP_WOL_MAGIC) != 0) ifp->if_capenable ^= IFCAP_WOL_MAGIC; } if (reinit && ifp->if_drv_flags & IFF_DRV_RUNNING) { ifp->if_drv_flags &= ~IFF_DRV_RUNNING; re_init(sc); } VLAN_CAPABILITIES(ifp); break; default: error = EINVAL; break; } /*(void)splx(s);*/ return(error); } #endif /* !__DragonFly__ */ static void re_link_on_patch(struct re_softc *sc) { struct ifnet *ifp; ifp = RE_GET_IFNET(sc); if (sc->re_type == MACFG_50 || sc->re_type == MACFG_51 || sc->re_type == MACFG_52) { if (CSR_READ_1(sc, RE_PHY_STATUS) & RL_PHY_STATUS_1000MF) { re_eri_write(sc, 0x1bc, 4, 0x00000011, ERIAR_ExGMAC); re_eri_write(sc, 0x1dc, 4, 0x0000001f, ERIAR_ExGMAC); } else if (CSR_READ_1(sc, RE_PHY_STATUS) & RL_PHY_STATUS_100M) { re_eri_write(sc, 0x1bc, 4, 0x0000001f, ERIAR_ExGMAC); re_eri_write(sc, 0x1dc, 4, 0x0000001f, ERIAR_ExGMAC); } else { re_eri_write(sc, 0x1bc, 4, 0x0000001f, ERIAR_ExGMAC); re_eri_write(sc, 0x1dc, 4, 0x0000002d, ERIAR_ExGMAC); } } else if ((sc->re_type == MACFG_38 || sc->re_type == MACFG_39) && (ifp->if_flags & IFF_UP)) { if (sc->re_type == MACFG_38 && (CSR_READ_1(sc, RE_PHY_STATUS) & RL_PHY_STATUS_10M)) { CSR_WRITE_4(sc, RE_RXCFG, CSR_READ_4(sc, RE_RXCFG) | RE_RXCFG_RX_ALLPHYS); } else if (sc->re_type == MACFG_39) { if (CSR_READ_1(sc, RE_PHY_STATUS) & RL_PHY_STATUS_1000MF) { re_eri_write(sc, 0x1bc, 4, 0x00000011, ERIAR_ExGMAC); re_eri_write(sc, 0x1dc, 4, 0x00000005, ERIAR_ExGMAC); } else if (CSR_READ_1(sc, RE_PHY_STATUS) & RL_PHY_STATUS_100M) { re_eri_write(sc, 0x1bc, 4, 0x0000001f, ERIAR_ExGMAC); re_eri_write(sc, 0x1dc, 4, 0x00000005, ERIAR_ExGMAC); } else { re_eri_write(sc, 0x1bc, 4, 0x0000001f, ERIAR_ExGMAC); re_eri_write(sc, 0x1dc, 4, 0x0000003f, ERIAR_ExGMAC); } } } else if ((sc->re_type == MACFG_36 || sc->re_type == MACFG_37) && eee_enable == 1) { /*Full -Duplex mode*/ if (CSR_READ_1(sc, RE_PHY_STATUS) & RL_PHY_STATUS_FULL_DUP) { MP_WritePhyUshort(sc, 0x1F, 0x0006); MP_WritePhyUshort(sc, 0x00, 0x5a30); MP_WritePhyUshort(sc, 0x1F, 0x0000); if (CSR_READ_1(sc, RE_PHY_STATUS) & (RL_PHY_STATUS_10M | RL_PHY_STATUS_100M)) CSR_WRITE_4(sc, RE_TXCFG, (CSR_READ_4(sc, RE_TXCFG) & ~BIT_19) | BIT_25); } else { MP_WritePhyUshort(sc, 0x1F, 0x0006); MP_WritePhyUshort(sc, 0x00, 0x5a00); MP_WritePhyUshort(sc, 0x1F, 0x0000); if (CSR_READ_1(sc, RE_PHY_STATUS) & (RL_PHY_STATUS_10M | RL_PHY_STATUS_100M)) CSR_WRITE_4(sc, RE_TXCFG, (CSR_READ_4(sc, RE_TXCFG) & ~BIT_19) | RE_TXCFG_IFG); } } else if ((sc->re_type == MACFG_56 || sc->re_type == MACFG_57 || 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_70 || sc->re_type == MACFG_71 || sc->re_type == MACFG_72 || sc->re_type == MACFG_80 || sc->re_type == MACFG_81 || sc->re_type == MACFG_82 || sc->re_type == MACFG_83) && (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); else CSR_WRITE_4(sc, RE_TXCFG, (CSR_READ_4(sc, RE_TXCFG) | BIT_25) & ~(BIT_19 | BIT_24)); } if (sc->re_type == MACFG_56 || sc->re_type == MACFG_57 || sc->re_type == MACFG_61 || sc->re_type == MACFG_62) { /*half mode*/ if (!(CSR_READ_1(sc, RE_PHY_STATUS) & RL_PHY_STATUS_FULL_DUP)) { MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, MII_ANAR, MP_ReadPhyUshort(sc, MII_ANAR)&~(ANAR_PAUSE_SYM |ANAR_PAUSE_ASYM)); } } if (CSR_READ_1(sc, RE_PHY_STATUS) & RL_PHY_STATUS_10M) { if (sc->re_type == MACFG_70 || sc->re_type == MACFG_71 || sc->re_type == MACFG_72) { uint32_t Data32; Data32 = re_eri_read(sc, 0x1D0, 1, ERIAR_ExGMAC); Data32 |= BIT_1; re_eri_write(sc, 0x1D0, 1, Data32, ERIAR_ExGMAC); } else if (sc->re_type == MACFG_80 || sc->re_type == MACFG_81 || sc->re_type == MACFG_82 || sc->re_type == MACFG_83) { MP_WriteMcuAccessRegWord(sc, 0xE080, MP_ReadMcuAccessRegWord(sc, 0xE080)|BIT_1); } } #ifndef __DragonFly__ re_init_unlock(sc); #endif } #ifndef __DragonFly__ static void re_link_down_patch(struct re_softc *sc) { struct ifnet *ifp; ifp = RE_GET_IFNET(sc); re_txeof(sc); re_rxeof(sc); re_stop(sc); sc->ifmedia_upd(ifp); } /* * Check Link Status. */ static void re_check_link_status(struct re_softc *sc) { u_int8_t link_state; struct ifnet *ifp; ifp = RE_GET_IFNET(sc); if (re_link_ok(sc)) { link_state = LINK_STATE_UP; } else { link_state = LINK_STATE_DOWN; } if (link_state != sc->link_state) { sc->link_state = link_state; if (link_state == LINK_STATE_UP) { re_link_on_patch(sc); re_link_state_change(ifp, LINK_STATE_UP); } else { re_link_state_change(ifp, LINK_STATE_DOWN); re_link_down_patch(sc); } } } static void re_init_timer(struct re_softc *sc) { #ifdef RE_USE_NEW_CALLOUT_FUN callout_init(&sc->re_stat_ch, CALLOUT_MPSAFE); #else callout_handle_init(&sc->re_stat_ch); #endif } static void re_stop_timer(struct re_softc *sc) { #ifdef RE_USE_NEW_CALLOUT_FUN callout_stop(&sc->re_stat_ch); #else untimeout(re_tick, sc, sc->re_stat_ch); #endif } static void re_start_timer(struct re_softc *sc) { #ifdef RE_USE_NEW_CALLOUT_FUN callout_reset(&sc->re_stat_ch, hz, re_tick, sc); #else re_stop_timer(sc); sc->re_stat_ch = timeout(re_tick, sc, hz); #endif } static void re_tick(xsc) void *xsc; { /*called per second*/ struct re_softc *sc; int s; s = splimp(); sc = xsc; /*mii = device_get_softc(sc->re_miibus); mii_tick(mii);*/ splx(s); RE_LOCK(sc); if (sc->re_link_chg_det == 1) { re_check_link_status(sc); re_start_timer(sc); } RE_UNLOCK(sc); return; } #if OS_VER < VERSION(7,0) static void re_watchdog(ifp) struct ifnet *ifp; { struct re_softc *sc; sc = ifp->if_softc; printf("re%d: watchdog timeout\n", sc->re_unit); #if OS_VER < VERSION(11,0) ifp->if_oerrors++; #else if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); #endif re_txeof(sc); re_rxeof(sc); re_init(sc); return; } #endif #endif /* !__DragonFly__ */ /* * Set media options. */ static int re_ifmedia_upd(struct ifnet *ifp) { struct re_softc *sc = ifp->if_softc; struct ifmedia *ifm = &sc->media; int anar; int gbcr; if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER) return(EINVAL); if (sc->re_type == MACFG_68 || sc->re_type == MACFG_69 || sc->re_type == MACFG_70 || sc->re_type == MACFG_71 || sc->re_type == MACFG_72) { //Disable Giga Lite MP_WritePhyUshort(sc, 0x1F, 0x0A42); ClearEthPhyBit(sc, 0x14, BIT_9); if (sc->re_type == MACFG_70 || sc->re_type == MACFG_71 || sc->re_type == MACFG_72) ClearEthPhyBit(sc, 0x14, BIT_7); MP_WritePhyUshort(sc, 0x1F, 0x0A40); MP_WritePhyUshort(sc, 0x1F, 0x0000); } switch (IFM_SUBTYPE(ifm->ifm_media)) { case IFM_AUTO: anar = ANAR_TX_FD | ANAR_TX | ANAR_10_FD | ANAR_10; gbcr = GTCR_ADV_1000TFDX | GTCR_ADV_1000THDX; break; case IFM_1000_SX: #ifndef __DragonFly__ #if OS_VER < 500000 case IFM_1000_TX: #else case IFM_1000_T: #endif #else /* __DragonFly__ */ case IFM_1000_T: #endif /* !__DragonFly__ */ anar = ANAR_TX_FD | ANAR_TX | ANAR_10_FD | ANAR_10; gbcr = GTCR_ADV_1000TFDX | GTCR_ADV_1000THDX; break; case IFM_100_TX: gbcr = MP_ReadPhyUshort(sc, MII_100T2CR) & ~(GTCR_ADV_1000TFDX | GTCR_ADV_1000THDX); if ((ifm->ifm_media & IFM_GMASK) == IFM_FDX) { anar = ANAR_TX_FD | ANAR_TX | ANAR_10_FD | ANAR_10; } else { anar = ANAR_TX | ANAR_10_FD | ANAR_10; } break; case IFM_10_T: gbcr = MP_ReadPhyUshort(sc, MII_100T2CR) & ~(GTCR_ADV_1000TFDX | GTCR_ADV_1000THDX); if ((ifm->ifm_media & IFM_GMASK) == IFM_FDX) { anar = ANAR_10_FD | ANAR_10; } else { anar = ANAR_10; } if (sc->re_type == MACFG_13) { MP_WritePhyUshort(sc, MII_BMCR, 0x8000); } break; default: #ifndef __DragonFly__ printf("re%d: Unsupported media type\n", sc->re_unit); return(0); #else if_printf(ifp, "Unsupported media type\n"); return (EOPNOTSUPP); #endif } MP_WritePhyUshort(sc, 0x1F, 0x0000); if (sc->re_device_id==RT_DEVICEID_8169 || sc->re_device_id==RT_DEVICEID_8169SC || sc->re_device_id==RT_DEVICEID_8168 || sc->re_device_id==RT_DEVICEID_8161) { MP_WritePhyUshort(sc, MII_ANAR, anar | 0x0800 | ANAR_FC); MP_WritePhyUshort(sc, MII_100T2CR, gbcr); MP_WritePhyUshort(sc, MII_BMCR, BMCR_RESET | BMCR_AUTOEN | BMCR_STARTNEG); } else if (sc->re_type == MACFG_36) { MP_WritePhyUshort(sc, MII_ANAR, anar | 0x0800 | ANAR_FC); MP_WritePhyUshort(sc, MII_BMCR, BMCR_RESET | BMCR_AUTOEN | BMCR_STARTNEG); } else { MP_WritePhyUshort(sc, MII_ANAR, anar | 1); MP_WritePhyUshort(sc, MII_BMCR, BMCR_AUTOEN | BMCR_STARTNEG); } return(0); } static int re_ifmedia_upd_8125(struct ifnet *ifp) { struct re_softc *sc = ifp->if_softc; struct ifmedia *ifm = &sc->media; int anar; int gbcr; int cr2500 = 0; if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER) return(EINVAL); //Disable Giga Lite ClearEthPhyOcpBit(sc, 0xA428, BIT_9); ClearEthPhyOcpBit(sc, 0xA5EA, BIT_0); cr2500 = MP_RealReadPhyOcpRegWord(sc, 0xA5D4); cr2500 &= ~RTK_ADVERTISE_2500FULL; switch (IFM_SUBTYPE(ifm->ifm_media)) { case IFM_AUTO: cr2500 |= RTK_ADVERTISE_2500FULL; anar = ANAR_TX_FD | ANAR_TX | ANAR_10_FD | ANAR_10; gbcr = GTCR_ADV_1000TFDX | GTCR_ADV_1000THDX; break; case IFM_2500_SX: #ifndef __DragonFly__ case IFM_2500_X: #endif #ifdef IFM_2500_T case IFM_2500_T: #endif cr2500 |= RTK_ADVERTISE_2500FULL; anar = ANAR_TX_FD | ANAR_TX | ANAR_10_FD | ANAR_10; gbcr = GTCR_ADV_1000TFDX | GTCR_ADV_1000THDX; break; case IFM_1000_SX: #ifndef __DragonFly__ #if OS_VER < 500000 case IFM_1000_TX: #else case IFM_1000_T: #endif #else /* __DragonFly__ */ case IFM_1000_T: #endif /* !__DragonFly__ */ anar = ANAR_TX_FD | ANAR_TX | ANAR_10_FD | ANAR_10; gbcr = GTCR_ADV_1000TFDX | GTCR_ADV_1000THDX; break; case IFM_100_TX: gbcr = MP_ReadPhyUshort(sc, MII_100T2CR) & ~(GTCR_ADV_1000TFDX | GTCR_ADV_1000THDX); if ((ifm->ifm_media & IFM_GMASK) == IFM_FDX) { anar = ANAR_TX_FD | ANAR_TX | ANAR_10_FD | ANAR_10; } else { anar = ANAR_TX | ANAR_10_FD | ANAR_10; } break; case IFM_10_T: gbcr = MP_ReadPhyUshort(sc, MII_100T2CR) & ~(GTCR_ADV_1000TFDX | GTCR_ADV_1000THDX); if ((ifm->ifm_media & IFM_GMASK) == IFM_FDX) { anar = ANAR_10_FD | ANAR_10; } else { anar = ANAR_10; } if (sc->re_type == MACFG_13) { MP_WritePhyUshort(sc, MII_BMCR, 0x8000); } break; default: #ifndef __DragonFly__ printf("re%d: Unsupported media type\n", sc->re_unit); return(0); #else if_printf(ifp, "Unsupported media type\n"); return (EOPNOTSUPP); #endif } MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xA5D4, cr2500); MP_WritePhyUshort(sc, MII_ANAR, anar | 0x0800 | ANAR_FC); MP_WritePhyUshort(sc, MII_100T2CR, gbcr); MP_WritePhyUshort(sc, MII_BMCR, BMCR_RESET | BMCR_AUTOEN | BMCR_STARTNEG); return(0); } /* * Report current media status. */ static void re_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr) { struct re_softc *sc; sc = ifp->if_softc; RE_LOCK(sc); ifmr->ifm_status = IFM_AVALID; ifmr->ifm_active = IFM_ETHER; if (re_link_ok(sc)) { unsigned char msr; ifmr->ifm_status |= IFM_ACTIVE; msr = CSR_READ_1(sc, RE_PHY_STATUS); if (msr & RL_PHY_STATUS_FULL_DUP) ifmr->ifm_active |= IFM_FDX; else ifmr->ifm_active |= IFM_HDX; if (msr & RL_PHY_STATUS_10M) ifmr->ifm_active |= IFM_10_T; else if (msr & RL_PHY_STATUS_100M) ifmr->ifm_active |= IFM_100_TX; else if (msr & RL_PHY_STATUS_1000MF) ifmr->ifm_active |= IFM_1000_T; #ifdef __DragonFly__ } else { if (IFM_SUBTYPE(sc->media.ifm_media) == IFM_AUTO) ifmr->ifm_active |= IFM_NONE; else ifmr->ifm_active |= sc->media.ifm_media; #endif } RE_UNLOCK(sc); return; } static void re_ifmedia_sts_8125(struct ifnet *ifp, struct ifmediareq *ifmr) { struct re_softc *sc; sc = ifp->if_softc; RE_LOCK(sc); ifmr->ifm_status = IFM_AVALID; ifmr->ifm_active = IFM_ETHER; if (re_link_ok(sc)) { u_int32_t msr; ifmr->ifm_status |= IFM_ACTIVE; msr = CSR_READ_4(sc, RE_PHY_STATUS); if (msr & RL_PHY_STATUS_FULL_DUP) ifmr->ifm_active |= IFM_FDX; else ifmr->ifm_active |= IFM_HDX; if (msr & RL_PHY_STATUS_10M) ifmr->ifm_active |= IFM_10_T; else if (msr & RL_PHY_STATUS_100M) ifmr->ifm_active |= IFM_100_TX; else if (msr & RL_PHY_STATUS_1000MF) ifmr->ifm_active |= IFM_1000_T; else if (msr & RL_PHY_STATUS_500MF) ifmr->ifm_active |= IFM_1000_T; else if (msr & RL_PHY_STATUS_1250MF) ifmr->ifm_active |= IFM_1000_T; else if (msr & RL_PHY_STATUS_2500MF) #ifdef IFM_2500_T ifmr->ifm_active |= IFM_2500_T; #else ifmr->ifm_active |= IFM_2500_SX; #endif #ifdef __DragonFly__ } else { if (IFM_SUBTYPE(sc->media.ifm_media) == IFM_AUTO) ifmr->ifm_active |= IFM_NONE; else ifmr->ifm_active |= sc->media.ifm_media; #endif } RE_UNLOCK(sc); return; } static int re_enable_EEE(struct re_softc *sc) { int ret; u_int16_t data; ret = 0; switch (sc->re_type) { case MACFG_42: case MACFG_43: re_eri_write(sc, 0x1B0, 2, 0xED03, ERIAR_ExGMAC); MP_WritePhyUshort(sc, 0x1F, 0x0004); if (CSR_READ_1(sc, 0xEF) & 0x02) { MP_WritePhyUshort(sc, 0x10, 0x731F); MP_WritePhyUshort(sc, 0x19, 0x7630); } else { MP_WritePhyUshort(sc, 0x10, 0x711F); MP_WritePhyUshort(sc, 0x19, 0x7030); } MP_WritePhyUshort(sc, 0x1A, 0x1506); MP_WritePhyUshort(sc, 0x1B, 0x0551); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x0D, 0x0007); MP_WritePhyUshort(sc, 0x0E, 0x003C); MP_WritePhyUshort(sc, 0x0D, 0x4007); MP_WritePhyUshort(sc, 0x0E, 0x0002); MP_WritePhyUshort(sc, 0x0D, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x0D, 0x0003); MP_WritePhyUshort(sc, 0x0E, 0x0015); MP_WritePhyUshort(sc, 0x0D, 0x4003); MP_WritePhyUshort(sc, 0x0E, 0x0002); MP_WritePhyUshort(sc, 0x0D, 0x0000); MP_WritePhyUshort(sc, MII_BMCR, BMCR_AUTOEN | BMCR_STARTNEG); break; case MACFG_53: case MACFG_54: case MACFG_55: re_eri_write(sc, 0x1B0, 2, 0xED03, ERIAR_ExGMAC); MP_WritePhyUshort(sc, 0x1F, 0x0004); MP_WritePhyUshort(sc, 0x10, 0x731F); MP_WritePhyUshort(sc, 0x19, 0x7630); MP_WritePhyUshort(sc, 0x1A, 0x1506); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x0D, 0x0007); MP_WritePhyUshort(sc, 0x0E, 0x003C); MP_WritePhyUshort(sc, 0x0D, 0x4007); MP_WritePhyUshort(sc, 0x0E, 0x0002); MP_WritePhyUshort(sc, 0x0D, 0x0000); MP_WritePhyUshort(sc, MII_BMCR, BMCR_AUTOEN | BMCR_STARTNEG); break; case MACFG_36: case MACFG_37: 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, 0x0006); MP_WritePhyUshort(sc, 0x00, 0x5A30); 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, 0x0D, 0x0000); if ((CSR_READ_1(sc, RE_CFG4)&RL_CFG4_CUSTOMIZED_LED) && (CSR_READ_1(sc, RE_MACDBG) & BIT_7)) { MP_WritePhyUshort(sc, 0x1F, 0x0005); MP_WritePhyUshort(sc, 0x05, 0x8AC8); MP_WritePhyUshort(sc, 0x06, CSR_READ_1(sc, RE_CUSTOM_LED)); MP_WritePhyUshort(sc, 0x05, 0x8B82); data = MP_ReadPhyUshort(sc, 0x06) | 0x0010; MP_WritePhyUshort(sc, 0x05, 0x8B82); MP_WritePhyUshort(sc, 0x06, data); MP_WritePhyUshort(sc, 0x1F, 0x0000); } break; case MACFG_50: case MACFG_51: case MACFG_52: 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); data = MP_ReadPhyUshort(sc, 0x15)|0x0100; 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); break; case MACFG_38: case MACFG_39: 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); MP_WritePhyUshort(sc, 0x1F, 0x0007); MP_WritePhyUshort(sc, 0x1e, 0x0020); data = MP_ReadPhyUshort(sc, 0x15); data |= BIT_8; MP_WritePhyUshort(sc, 0x15, data); MP_WritePhyUshort(sc, 0x1F, 0x0002); MP_WritePhyUshort(sc, 0x1F, 0x0005); MP_WritePhyUshort(sc, 0x05, 0x8B85); data = MP_ReadPhyUshort(sc, 0x06); data |= BIT_13; 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, 0x0D, 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: case MACFG_72: 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, 0x0A43); data = MP_ReadPhyUshort(sc, 0x11); MP_WritePhyUshort(sc, 0x11, data | BIT_4); MP_WritePhyUshort(sc, 0x1F, 0x0A5D); MP_WritePhyUshort(sc, 0x10, 0x0006); MP_WritePhyUshort(sc, 0x1F, 0x0000); break; case MACFG_80: case MACFG_81: SetMcuAccessRegBit(sc, 0xE040, (BIT_1|BIT_0)); SetMcuAccessRegBit(sc, 0xEB62, (BIT_2|BIT_1)); SetEthPhyOcpBit(sc, 0xA432, BIT_4); SetEthPhyOcpBit(sc, 0xA5D0, (BIT_2 | BIT_1)); ClearEthPhyOcpBit(sc, 0xA6D4, BIT_0); ClearEthPhyOcpBit(sc, 0xA6D8, BIT_4); ClearEthPhyOcpBit(sc, 0xA428, BIT_7); ClearEthPhyOcpBit(sc, 0xA4A2, BIT_9); break; case MACFG_82: case MACFG_83: SetMcuAccessRegBit(sc, 0xE040, (BIT_1|BIT_0)); SetEthPhyOcpBit(sc, 0xA5D0, (BIT_2 | BIT_1)); ClearEthPhyOcpBit(sc, 0xA6D4, BIT_0); ClearEthPhyOcpBit(sc, 0xA6D8, BIT_4); ClearEthPhyOcpBit(sc, 0xA428, BIT_7); ClearEthPhyOcpBit(sc, 0xA4A2, BIT_9); break; default: ret = -EOPNOTSUPP; break; } switch (sc->re_type) { case MACFG_68: case MACFG_69: MP_WritePhyUshort(sc, 0x1F, 0x0A4A); SetEthPhyBit(sc, 0x11, BIT_9); MP_WritePhyUshort(sc, 0x1F, 0x0A42); SetEthPhyBit(sc, 0x14, BIT_7); MP_WritePhyUshort(sc, 0x1F, 0x0000); break; } /*Advanced EEE*/ switch (sc->re_type) { case MACFG_58: case MACFG_59: case MACFG_60: case MACFG_68: case MACFG_69: case MACFG_70: case MACFG_71: case MACFG_72: case MACFG_80: case MACFG_81: case MACFG_82: case MACFG_83: re_set_phy_mcu_patch_request(sc); break; } switch (sc->re_type) { case MACFG_59: re_eri_write(sc, 0x1EA, 1, 0xFA, ERIAR_ExGMAC); MP_WritePhyUshort(sc, 0x1F, 0x0A43); data = MP_ReadPhyUshort(sc, 0x10); if (data & BIT_10) { MP_WritePhyUshort(sc, 0x1F, 0x0A42); data = MP_ReadPhyUshort(sc, 0x16); data &= ~(BIT_1); MP_WritePhyUshort(sc, 0x16, data); } else { MP_WritePhyUshort(sc, 0x1F, 0x0A42); data = MP_ReadPhyUshort(sc, 0x16); data |= BIT_1; MP_WritePhyUshort(sc, 0x16, data); } MP_WritePhyUshort(sc, 0x1F, 0x0000); break; case MACFG_60: data = MP_ReadMcuAccessRegWord(sc, 0xE052); data |= BIT_0; MP_WriteMcuAccessRegWord(sc, 0xE052, data); data = MP_ReadMcuAccessRegWord(sc, 0xE056); data &= 0xFF0F; data |= (BIT_4 | BIT_5 | BIT_6); MP_WriteMcuAccessRegWord(sc, 0xE056, data); MP_WritePhyUshort(sc, 0x1F, 0x0A43); data = MP_ReadPhyUshort(sc, 0x10); if (data & BIT_10) { MP_WritePhyUshort(sc, 0x1F, 0x0A42); data = MP_ReadPhyUshort(sc, 0x16); data &= ~(BIT_1); MP_WritePhyUshort(sc, 0x16, data); } else { MP_WritePhyUshort(sc, 0x1F, 0x0A42); data = MP_ReadPhyUshort(sc, 0x16); data |= BIT_1; MP_WritePhyUshort(sc, 0x16, data); } MP_WritePhyUshort(sc, 0x1F, 0x0000); break; case MACFG_61: case MACFG_62: case MACFG_67: 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); break; case MACFG_70: case MACFG_71: case MACFG_72: 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); break; case MACFG_68: case MACFG_69: data = MP_ReadMcuAccessRegWord(sc, 0xE052); data |= BIT_0; MP_WriteMcuAccessRegWord(sc, 0xE052, data); MP_WritePhyUshort(sc, 0x1F, 0x0A43); data = MP_ReadPhyUshort(sc, 0x10) | BIT_15; MP_WritePhyUshort(sc, 0x10, data); MP_WritePhyUshort(sc, 0x1F, 0x0A44); data = MP_ReadPhyUshort(sc, 0x11) | BIT_13 | BIT_14; data &= ~(BIT_12); MP_WritePhyUshort(sc, 0x11, data); break; case MACFG_80: case MACFG_81: case MACFG_82: case MACFG_83: ClearMcuAccessRegBit(sc, 0xE052, BIT_0); ClearEthPhyOcpBit(sc, 0xA442, BIT_12 | BIT_13); ClearEthPhyOcpBit(sc, 0xA430, BIT_15); break; } switch (sc->re_type) { case MACFG_58: case MACFG_59: case MACFG_60: case MACFG_68: case MACFG_69: case MACFG_70: case MACFG_71: case MACFG_72: case MACFG_80: case MACFG_81: case MACFG_82: case MACFG_83: re_clear_phy_mcu_patch_request(sc); break; } return ret; } static int re_disable_EEE(struct re_softc *sc) { int ret; u_int16_t data; ret = 0; switch (sc->re_type) { case MACFG_42: case MACFG_43: re_eri_write(sc, 0x1B0, 2, 0, ERIAR_ExGMAC); MP_WritePhyUshort(sc, 0x1F, 0x0004); MP_WritePhyUshort(sc, 0x10, 0x401F); MP_WritePhyUshort(sc, 0x19, 0x7030); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x0D, 0x0007); MP_WritePhyUshort(sc, 0x0E, 0x003C); MP_WritePhyUshort(sc, 0x0D, 0x4007); MP_WritePhyUshort(sc, 0x0E, 0x0000); MP_WritePhyUshort(sc, 0x0D, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x0D, 0x0003); MP_WritePhyUshort(sc, 0x0E, 0x0015); MP_WritePhyUshort(sc, 0x0D, 0x4003); MP_WritePhyUshort(sc, 0x0E, 0x0000); MP_WritePhyUshort(sc, 0x0D, 0x0000); MP_WritePhyUshort(sc, MII_BMCR, BMCR_AUTOEN | BMCR_STARTNEG); break; case MACFG_53: re_eri_write(sc, 0x1B0, 2, 0, ERIAR_ExGMAC); MP_WritePhyUshort(sc, 0x1F, 0x0004); MP_WritePhyUshort(sc, 0x10, 0x401F); MP_WritePhyUshort(sc, 0x19, 0x7030); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x0D, 0x0007); MP_WritePhyUshort(sc, 0x0E, 0x003C); MP_WritePhyUshort(sc, 0x0D, 0x4007); MP_WritePhyUshort(sc, 0x0E, 0x0000); MP_WritePhyUshort(sc, 0x0D, 0x0000); MP_WritePhyUshort(sc, MII_BMCR, BMCR_AUTOEN | BMCR_STARTNEG); break; case MACFG_54: case MACFG_55: re_eri_write(sc, 0x1B0, 2, 0, ERIAR_ExGMAC); MP_WritePhyUshort(sc, 0x1F, 0x0004); MP_WritePhyUshort(sc, 0x10, 0xC07F); MP_WritePhyUshort(sc, 0x19, 0x7030); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x0D, 0x0007); MP_WritePhyUshort(sc, 0x0E, 0x003C); MP_WritePhyUshort(sc, 0x0D, 0x4007); MP_WritePhyUshort(sc, 0x0E, 0x0000); MP_WritePhyUshort(sc, 0x0D, 0x0000); MP_WritePhyUshort(sc, MII_BMCR, BMCR_AUTOEN | BMCR_STARTNEG); break; case MACFG_36: case MACFG_37: 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, 0x0006); MP_WritePhyUshort(sc, 0x00, 0x5A00); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x0D, 0x0007); MP_WritePhyUshort(sc, 0x0E, 0x003C); MP_WritePhyUshort(sc, 0x0D, 0x4007); MP_WritePhyUshort(sc, 0x0E, 0x0000); MP_WritePhyUshort(sc, 0x0D, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0000); if (CSR_READ_1(sc, RE_CFG4) & RL_CFG4_CUSTOMIZED_LED) { MP_WritePhyUshort(sc, 0x1F, 0x0005); MP_WritePhyUshort(sc, 0x05, 0x8B82); data = MP_ReadPhyUshort(sc, 0x06) & ~0x0010; MP_WritePhyUshort(sc, 0x05, 0x8B82); MP_WritePhyUshort(sc, 0x06, data); MP_WritePhyUshort(sc, 0x1F, 0x0000); } break; case MACFG_50: case MACFG_51: case MACFG_52: 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); data = MP_ReadPhyUshort(sc, 0x06) & ~0x2000; MP_WritePhyUshort(sc, 0x06, data); 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, 0x0000); MP_WritePhyUshort(sc, 0x0D, 0x0007); MP_WritePhyUshort(sc, 0x0E, 0x003C); MP_WritePhyUshort(sc, 0x0D, 0x4007); MP_WritePhyUshort(sc, 0x0E, 0x0000); MP_WritePhyUshort(sc, 0x0D, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0000); break; case MACFG_38: case MACFG_39: 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); MP_WritePhyUshort(sc, 0x05, 0x8B85); data = MP_ReadPhyUshort(sc, 0x06); data &= ~BIT_13; MP_WritePhyUshort(sc, 0x06, data); MP_WritePhyUshort(sc, 0x1F, 0x0004); MP_WritePhyUshort(sc, 0x1F, 0x0007); MP_WritePhyUshort(sc, 0x1e, 0x0020); data = MP_ReadPhyUshort(sc, 0x15); data &= ~BIT_8; MP_WritePhyUshort(sc, 0x15, data); MP_WritePhyUshort(sc, 0x1F, 0x0002); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x0D, 0x0007); MP_WritePhyUshort(sc, 0x0E, 0x003C); MP_WritePhyUshort(sc, 0x0D, 0x4007); MP_WritePhyUshort(sc, 0x0E, 0x0000); MP_WritePhyUshort(sc, 0x0D, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0000); 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: case MACFG_72: 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, 0x0A43); data = MP_ReadPhyUshort(sc, 0x11); MP_WritePhyUshort(sc, 0x11, data & ~BIT_4); MP_WritePhyUshort(sc, 0x1F, 0x0A5D); MP_WritePhyUshort(sc, 0x10, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0000); break; case MACFG_80: case MACFG_81: ClearMcuAccessRegBit(sc, 0xE040, (BIT_1|BIT_0)); ClearMcuAccessRegBit(sc, 0xEB62, (BIT_2|BIT_1)); ClearEthPhyOcpBit(sc, 0xA432, BIT_4); ClearEthPhyOcpBit(sc, 0xA5D0, (BIT_2 | BIT_1)); ClearEthPhyOcpBit(sc, 0xA6D4, BIT_0); ClearEthPhyOcpBit(sc, 0xA6D8, BIT_4); ClearEthPhyOcpBit(sc, 0xA428, BIT_7); ClearEthPhyOcpBit(sc, 0xA4A2, BIT_9); break; case MACFG_82: case MACFG_83: ClearMcuAccessRegBit(sc, 0xE040, (BIT_1|BIT_0)); ClearEthPhyOcpBit(sc, 0xA5D0, (BIT_2 | BIT_1)); ClearEthPhyOcpBit(sc, 0xA6D4, BIT_0); ClearEthPhyOcpBit(sc, 0xA6D8, BIT_4); ClearEthPhyOcpBit(sc, 0xA428, BIT_7); ClearEthPhyOcpBit(sc, 0xA4A2, BIT_9); break; default: ret = -EOPNOTSUPP; break; } switch (sc->re_type) { case MACFG_68: case MACFG_69: MP_WritePhyUshort(sc, 0x1F, 0x0A42); ClearEthPhyBit(sc, 0x14, BIT_7); MP_WritePhyUshort(sc, 0x1F, 0x0A4A); ClearEthPhyBit(sc, 0x11, BIT_9); MP_WritePhyUshort(sc, 0x1F, 0x0000); break; } /*Advanced EEE*/ switch (sc->re_type) { case MACFG_58: case MACFG_59: case MACFG_60: case MACFG_68: case MACFG_69: case MACFG_70: case MACFG_71: case MACFG_72: case MACFG_80: case MACFG_81: case MACFG_82: case MACFG_83: re_set_phy_mcu_patch_request(sc); break; } switch (sc->re_type) { case MACFG_59: re_eri_write(sc, 0x1EA, 1, 0x00, ERIAR_ExGMAC); MP_WritePhyUshort(sc, 0x1F, 0x0A42); data = MP_ReadPhyUshort(sc, 0x16); data &= ~(BIT_1); MP_WritePhyUshort(sc, 0x16, data); MP_WritePhyUshort(sc, 0x1F, 0x0000); break; case MACFG_60: data = MP_ReadMcuAccessRegWord(sc, 0xE052); data &= ~(BIT_0); MP_WriteMcuAccessRegWord(sc, 0xE052, data); MP_WritePhyUshort(sc, 0x1F, 0x0A42); data = MP_ReadPhyUshort(sc, 0x16); data &= ~(BIT_1); MP_WritePhyUshort(sc, 0x16, data); MP_WritePhyUshort(sc, 0x1F, 0x0000); break; case MACFG_61: case MACFG_62: case MACFG_67: case MACFG_70: case MACFG_71: case MACFG_72: data = MP_ReadMcuAccessRegWord(sc, 0xE052); data &= ~(BIT_0); MP_WriteMcuAccessRegWord(sc, 0xE052, data); break; case MACFG_68: case MACFG_69: data = MP_ReadMcuAccessRegWord(sc, 0xE052); data &= ~(BIT_0); MP_WriteMcuAccessRegWord(sc, 0xE052, data); MP_WritePhyUshort(sc, 0x1F, 0x0A43); data = MP_ReadPhyUshort(sc, 0x10) & ~(BIT_15); MP_WritePhyUshort(sc, 0x10, data); MP_WritePhyUshort(sc, 0x1F, 0x0A44); data = MP_ReadPhyUshort(sc, 0x11) & ~(BIT_12 | BIT_13 | BIT_14); MP_WritePhyUshort(sc, 0x11, data); MP_WritePhyUshort(sc, 0x1f, 0x0000); break; case MACFG_80: case MACFG_81: case MACFG_82: case MACFG_83: ClearMcuAccessRegBit(sc, 0xE052, BIT_0); ClearEthPhyOcpBit(sc, 0xA442, BIT_12 | BIT_13); ClearEthPhyOcpBit(sc, 0xA430, BIT_15); break; } switch (sc->re_type) { case MACFG_58: case MACFG_59: case MACFG_60: case MACFG_68: case MACFG_69: case MACFG_70: case MACFG_71: case MACFG_72: case MACFG_80: case MACFG_81: case MACFG_82: case MACFG_83: re_clear_phy_mcu_patch_request(sc); break; } return ret; } static int re_phy_ram_code_check(struct re_softc *sc) { u_int16_t PhyRegValue; int retval = TRUE; switch(sc->re_type) { case MACFG_56: MP_WritePhyUshort(sc, 0x1f, 0x0A40); PhyRegValue = MP_ReadPhyUshort(sc, 0x10); PhyRegValue &= ~(BIT_11); MP_WritePhyUshort(sc, 0x10, PhyRegValue); MP_WritePhyUshort(sc, 0x1f, 0x0A00); PhyRegValue = MP_ReadPhyUshort(sc, 0x10); PhyRegValue &= ~(BIT_12 | BIT_13 | BIT_14 | BIT_15); MP_WritePhyUshort(sc, 0x10, PhyRegValue); MP_WritePhyUshort(sc, 0x1f, 0x0A43); MP_WritePhyUshort(sc, 0x13, 0x8010); PhyRegValue = MP_ReadPhyUshort(sc, 0x14); PhyRegValue &= ~(BIT_11); MP_WritePhyUshort(sc, 0x14, PhyRegValue); retval = re_set_phy_mcu_patch_request(sc); MP_WritePhyUshort(sc, 0x1f, 0x0A40); MP_WritePhyUshort(sc, 0x10, 0x0140); MP_WritePhyUshort(sc, 0x1f, 0x0A4A); PhyRegValue = MP_ReadPhyUshort(sc, 0x13); PhyRegValue &= ~(BIT_6); PhyRegValue |= (BIT_7); MP_WritePhyUshort(sc, 0x13, PhyRegValue); MP_WritePhyUshort(sc, 0x1f, 0x0A44); PhyRegValue = MP_ReadPhyUshort(sc, 0x14); PhyRegValue |= (BIT_2); MP_WritePhyUshort(sc, 0x14, PhyRegValue); MP_WritePhyUshort(sc, 0x1f, 0x0A50); PhyRegValue = MP_ReadPhyUshort(sc, 0x11); PhyRegValue |= (BIT_11|BIT_12); MP_WritePhyUshort(sc, 0x11, PhyRegValue); retval = re_clear_phy_mcu_patch_request(sc); MP_WritePhyUshort(sc, 0x1f, 0x0A40); MP_WritePhyUshort(sc, 0x10, 0x1040); MP_WritePhyUshort(sc, 0x1f, 0x0A4A); PhyRegValue = MP_ReadPhyUshort(sc, 0x13); PhyRegValue &= ~(BIT_6|BIT_7); MP_WritePhyUshort(sc, 0x13, PhyRegValue); MP_WritePhyUshort(sc, 0x1f, 0x0A44); PhyRegValue = MP_ReadPhyUshort(sc, 0x14); PhyRegValue &= ~(BIT_2); MP_WritePhyUshort(sc, 0x14, PhyRegValue); MP_WritePhyUshort(sc, 0x1f, 0x0A50); PhyRegValue = MP_ReadPhyUshort(sc, 0x11); PhyRegValue &= ~(BIT_11|BIT_12); MP_WritePhyUshort(sc, 0x11, PhyRegValue); MP_WritePhyUshort(sc, 0x1f, 0x0A43); MP_WritePhyUshort(sc, 0x13, 0x8010); PhyRegValue = MP_ReadPhyUshort(sc, 0x14); PhyRegValue |= (BIT_11); MP_WritePhyUshort(sc, 0x14, PhyRegValue); retval = re_set_phy_mcu_patch_request(sc); MP_WritePhyUshort(sc, 0x1f, 0x0A20); PhyRegValue = MP_ReadPhyUshort(sc, 0x13); if (PhyRegValue & BIT_11) { if (PhyRegValue & BIT_10) { retval = FALSE; } } retval = re_clear_phy_mcu_patch_request(sc); //delay 2ms DELAY(2000); break; default: break; } MP_WritePhyUshort(sc, 0x1F, 0x0000); return retval; } static void re_set_phy_ram_code_check_fail_flag(struct re_softc *sc) { u_int16_t TmpUshort; switch(sc->re_type) { case MACFG_56: TmpUshort = MP_ReadMcuAccessRegWord(sc, 0xD3C0); TmpUshort |= BIT_0; MP_WriteMcuAccessRegWord(sc, 0xD3C0, TmpUshort); break; } } 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: case MACFG_72: 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; case MACFG_80: case MACFG_81: case MACFG_82: case MACFG_83: MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x801E); sc->re_hw_ram_code_ver = MP_RealReadPhyOcpRegWord(sc, 0xA438); 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: case MACFG_72: 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; case MACFG_80: case MACFG_81: case MACFG_82: case MACFG_83: MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x801E); MP_RealWritePhyOcpRegWord(sc, 0xA438, sc->re_sw_ram_code_ver); sc->re_hw_ram_code_ver = sc->re_sw_ram_code_ver; break; } } static void re_acquire_phy_mcu_patch_key_lock(struct re_softc *sc) { u_int16_t PatchKey; switch (sc->re_type) { case MACFG_80: PatchKey = 0x8600; break; case MACFG_81: PatchKey = 0x8601; break; case MACFG_82: PatchKey = 0x3700; break; case MACFG_83: PatchKey = 0x3701; break; default: return; } MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x8024); MP_RealWritePhyOcpRegWord(sc, 0xA438, PatchKey); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xB82E); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0001); } static void re_release_phy_mcu_patch_key_lock(struct re_softc *sc) { switch (sc->re_type) { case MACFG_80: case MACFG_81: case MACFG_82: case MACFG_83: MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0000); ClearEthPhyOcpBit(sc, 0xB82E, BIT_0); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x8024); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0000); break; default: break; } } bool re_set_phy_mcu_patch_request(struct re_softc *sc) { u_int16_t PhyRegValue; u_int16_t WaitCount = 0; int i; bool bSuccess = TRUE; switch (sc->re_type) { 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: case MACFG_72: MP_WritePhyUshort(sc, 0x1f, 0x0B82); SetEthPhyBit(sc, 0x10, BIT_4); MP_WritePhyUshort(sc, 0x1f, 0x0B80); WaitCount = 0; do { PhyRegValue = MP_ReadPhyUshort(sc, 0x10); PhyRegValue &= BIT_6; DELAY(50); DELAY(50); WaitCount++; } while(PhyRegValue != BIT_6 && WaitCount < 1000); if (PhyRegValue != BIT_6 && WaitCount == 1000) bSuccess = FALSE; MP_WritePhyUshort(sc, 0x1f, 0x0000); break; case MACFG_80: case MACFG_81: case MACFG_82: case MACFG_83: SetEthPhyOcpBit(sc, 0xB820, BIT_4); i = 0; do { PhyRegValue = MP_RealReadPhyOcpRegWord(sc, 0xB800); PhyRegValue &= BIT_6; DELAY(50); DELAY(50); i++; } while(PhyRegValue != BIT_6 && i < 1000); if (PhyRegValue != BIT_6 && WaitCount == 1000) bSuccess = FALSE; break; } return bSuccess; } bool re_clear_phy_mcu_patch_request(struct re_softc *sc) { u_int16_t PhyRegValue; u_int16_t WaitCount = 0; int i; bool bSuccess = TRUE; switch (sc->re_type) { 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: case MACFG_72: MP_WritePhyUshort(sc, 0x1f, 0x0B82); ClearEthPhyBit(sc, 0x10, BIT_4); MP_WritePhyUshort(sc, 0x1f, 0x0B80); WaitCount = 0; do { PhyRegValue = MP_ReadPhyUshort(sc, 0x10); PhyRegValue &= BIT_6; DELAY(50); DELAY(50); WaitCount++; } while(PhyRegValue != BIT_6 && WaitCount < 1000); if (PhyRegValue != BIT_6 && WaitCount == 1000) bSuccess = FALSE; MP_WritePhyUshort(sc, 0x1f, 0x0000); break; case MACFG_80: case MACFG_81: case MACFG_82: case MACFG_83: ClearEthPhyOcpBit(sc, 0xB820, BIT_4); i = 0; do { PhyRegValue = MP_RealReadPhyOcpRegWord(sc, 0xB800); PhyRegValue &= BIT_6; DELAY(50); DELAY(50); i++; } while(PhyRegValue != BIT_6 && i < 1000); if (PhyRegValue != BIT_6 && WaitCount == 1000) bSuccess = FALSE; break; } return bSuccess; } static void re_set_phy_mcu_ram_code(struct re_softc *sc, const u_int16_t *ramcode, u_int16_t codesize) { u_int16_t i; u_int16_t addr; u_int16_t val; if (ramcode == NULL || codesize % 2) { goto out; } for (i = 0; i < codesize; i += 2) { addr = ramcode[i]; val = ramcode[i + 1]; if (addr == 0xFFFF && val == 0xFFFF) { break; } MP_RealWritePhyOcpRegWord(sc, addr, val); } out: return; } 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, 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, 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, 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); 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; re_set_phy_mcu_patch_request(sc); 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); re_clear_phy_mcu_patch_request(sc); 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; re_set_phy_mcu_patch_request(sc); 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); re_clear_phy_mcu_patch_request(sc); 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; re_set_phy_mcu_patch_request(sc); 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); re_clear_phy_mcu_patch_request(sc); 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; re_set_phy_mcu_patch_request(sc); 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); re_clear_phy_mcu_patch_request(sc); 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; re_set_phy_mcu_patch_request(sc); 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, 0x8323); MP_WritePhyUshort(sc, 0x14, 0xaf83); MP_WritePhyUshort(sc, 0x14, 0x2faf); MP_WritePhyUshort(sc, 0x14, 0x853d); MP_WritePhyUshort(sc, 0x14, 0xaf85); MP_WritePhyUshort(sc, 0x14, 0x3daf); MP_WritePhyUshort(sc, 0x14, 0x853d); MP_WritePhyUshort(sc, 0x14, 0xe082); MP_WritePhyUshort(sc, 0x14, 0x45ad); MP_WritePhyUshort(sc, 0x14, 0x2052); MP_WritePhyUshort(sc, 0x14, 0xe082); MP_WritePhyUshort(sc, 0x14, 0x7ae3); MP_WritePhyUshort(sc, 0x14, 0x85fe); MP_WritePhyUshort(sc, 0x14, 0x1a03); MP_WritePhyUshort(sc, 0x14, 0x10e4); MP_WritePhyUshort(sc, 0x14, 0x85f6); MP_WritePhyUshort(sc, 0x14, 0xe082); MP_WritePhyUshort(sc, 0x14, 0x7a1b); MP_WritePhyUshort(sc, 0x14, 0x03e4); MP_WritePhyUshort(sc, 0x14, 0x85fa); MP_WritePhyUshort(sc, 0x14, 0xe082); MP_WritePhyUshort(sc, 0x14, 0x7be3); MP_WritePhyUshort(sc, 0x14, 0x85fe); MP_WritePhyUshort(sc, 0x14, 0x1a03); MP_WritePhyUshort(sc, 0x14, 0x10e4); MP_WritePhyUshort(sc, 0x14, 0x85f7); MP_WritePhyUshort(sc, 0x14, 0xe082); MP_WritePhyUshort(sc, 0x14, 0x7b1b); MP_WritePhyUshort(sc, 0x14, 0x03e4); MP_WritePhyUshort(sc, 0x14, 0x85fb); MP_WritePhyUshort(sc, 0x14, 0xe082); MP_WritePhyUshort(sc, 0x14, 0x7ce3); MP_WritePhyUshort(sc, 0x14, 0x85fe); MP_WritePhyUshort(sc, 0x14, 0x1a03); MP_WritePhyUshort(sc, 0x14, 0x10e4); MP_WritePhyUshort(sc, 0x14, 0x85f8); MP_WritePhyUshort(sc, 0x14, 0xe082); MP_WritePhyUshort(sc, 0x14, 0x7c1b); MP_WritePhyUshort(sc, 0x14, 0x03e4); MP_WritePhyUshort(sc, 0x14, 0x85fc); MP_WritePhyUshort(sc, 0x14, 0xe082); MP_WritePhyUshort(sc, 0x14, 0x7de3); MP_WritePhyUshort(sc, 0x14, 0x85fe); MP_WritePhyUshort(sc, 0x14, 0x1a03); MP_WritePhyUshort(sc, 0x14, 0x10e4); MP_WritePhyUshort(sc, 0x14, 0x85f9); MP_WritePhyUshort(sc, 0x14, 0xe082); MP_WritePhyUshort(sc, 0x14, 0x7d1b); MP_WritePhyUshort(sc, 0x14, 0x03e4); MP_WritePhyUshort(sc, 0x14, 0x85fd); MP_WritePhyUshort(sc, 0x14, 0xae50); MP_WritePhyUshort(sc, 0x14, 0xe082); MP_WritePhyUshort(sc, 0x14, 0x7ee3); MP_WritePhyUshort(sc, 0x14, 0x85ff); MP_WritePhyUshort(sc, 0x14, 0x1a03); MP_WritePhyUshort(sc, 0x14, 0x10e4); MP_WritePhyUshort(sc, 0x14, 0x85f6); MP_WritePhyUshort(sc, 0x14, 0xe082); MP_WritePhyUshort(sc, 0x14, 0x7e1b); MP_WritePhyUshort(sc, 0x14, 0x03e4); MP_WritePhyUshort(sc, 0x14, 0x85fa); MP_WritePhyUshort(sc, 0x14, 0xe082); MP_WritePhyUshort(sc, 0x14, 0x7fe3); MP_WritePhyUshort(sc, 0x14, 0x85ff); MP_WritePhyUshort(sc, 0x14, 0x1a03); MP_WritePhyUshort(sc, 0x14, 0x10e4); MP_WritePhyUshort(sc, 0x14, 0x85f7); MP_WritePhyUshort(sc, 0x14, 0xe082); MP_WritePhyUshort(sc, 0x14, 0x7f1b); MP_WritePhyUshort(sc, 0x14, 0x03e4); MP_WritePhyUshort(sc, 0x14, 0x85fb); MP_WritePhyUshort(sc, 0x14, 0xe082); MP_WritePhyUshort(sc, 0x14, 0x80e3); MP_WritePhyUshort(sc, 0x14, 0x85ff); MP_WritePhyUshort(sc, 0x14, 0x1a03); MP_WritePhyUshort(sc, 0x14, 0x10e4); MP_WritePhyUshort(sc, 0x14, 0x85f8); MP_WritePhyUshort(sc, 0x14, 0xe082); MP_WritePhyUshort(sc, 0x14, 0x801b); MP_WritePhyUshort(sc, 0x14, 0x03e4); MP_WritePhyUshort(sc, 0x14, 0x85fc); MP_WritePhyUshort(sc, 0x14, 0xe082); MP_WritePhyUshort(sc, 0x14, 0x81e3); MP_WritePhyUshort(sc, 0x14, 0x85ff); MP_WritePhyUshort(sc, 0x14, 0x1a03); MP_WritePhyUshort(sc, 0x14, 0x10e4); MP_WritePhyUshort(sc, 0x14, 0x85f9); MP_WritePhyUshort(sc, 0x14, 0xe082); MP_WritePhyUshort(sc, 0x14, 0x811b); MP_WritePhyUshort(sc, 0x14, 0x03e4); MP_WritePhyUshort(sc, 0x14, 0x85fd); MP_WritePhyUshort(sc, 0x14, 0xe085); MP_WritePhyUshort(sc, 0x14, 0xf6ad); MP_WritePhyUshort(sc, 0x14, 0x2404); MP_WritePhyUshort(sc, 0x14, 0xee85); MP_WritePhyUshort(sc, 0x14, 0xf610); MP_WritePhyUshort(sc, 0x14, 0xe085); MP_WritePhyUshort(sc, 0x14, 0xf7ad); MP_WritePhyUshort(sc, 0x14, 0x2404); MP_WritePhyUshort(sc, 0x14, 0xee85); MP_WritePhyUshort(sc, 0x14, 0xf710); MP_WritePhyUshort(sc, 0x14, 0xe085); MP_WritePhyUshort(sc, 0x14, 0xf8ad); MP_WritePhyUshort(sc, 0x14, 0x2404); MP_WritePhyUshort(sc, 0x14, 0xee85); MP_WritePhyUshort(sc, 0x14, 0xf810); MP_WritePhyUshort(sc, 0x14, 0xe085); MP_WritePhyUshort(sc, 0x14, 0xf9ad); MP_WritePhyUshort(sc, 0x14, 0x2404); MP_WritePhyUshort(sc, 0x14, 0xee85); MP_WritePhyUshort(sc, 0x14, 0xf910); MP_WritePhyUshort(sc, 0x14, 0xe085); MP_WritePhyUshort(sc, 0x14, 0xfaad); MP_WritePhyUshort(sc, 0x14, 0x2704); MP_WritePhyUshort(sc, 0x14, 0xee85); MP_WritePhyUshort(sc, 0x14, 0xfa00); MP_WritePhyUshort(sc, 0x14, 0xe085); MP_WritePhyUshort(sc, 0x14, 0xfbad); MP_WritePhyUshort(sc, 0x14, 0x2704); MP_WritePhyUshort(sc, 0x14, 0xee85); MP_WritePhyUshort(sc, 0x14, 0xfb00); MP_WritePhyUshort(sc, 0x14, 0xe085); MP_WritePhyUshort(sc, 0x14, 0xfcad); MP_WritePhyUshort(sc, 0x14, 0x2704); MP_WritePhyUshort(sc, 0x14, 0xee85); MP_WritePhyUshort(sc, 0x14, 0xfc00); MP_WritePhyUshort(sc, 0x14, 0xe085); MP_WritePhyUshort(sc, 0x14, 0xfdad); MP_WritePhyUshort(sc, 0x14, 0x2704); MP_WritePhyUshort(sc, 0x14, 0xee85); MP_WritePhyUshort(sc, 0x14, 0xfd00); MP_WritePhyUshort(sc, 0x14, 0xe082); MP_WritePhyUshort(sc, 0x14, 0x44ad); MP_WritePhyUshort(sc, 0x14, 0x203f); MP_WritePhyUshort(sc, 0x14, 0xe085); MP_WritePhyUshort(sc, 0x14, 0xf6e4); MP_WritePhyUshort(sc, 0x14, 0x8288); MP_WritePhyUshort(sc, 0x14, 0xe085); MP_WritePhyUshort(sc, 0x14, 0xfae4); MP_WritePhyUshort(sc, 0x14, 0x8289); MP_WritePhyUshort(sc, 0x14, 0xe082); MP_WritePhyUshort(sc, 0x14, 0x440d); MP_WritePhyUshort(sc, 0x14, 0x0458); MP_WritePhyUshort(sc, 0x14, 0x01bf); MP_WritePhyUshort(sc, 0x14, 0x8264); MP_WritePhyUshort(sc, 0x14, 0x0215); MP_WritePhyUshort(sc, 0x14, 0x38bf); MP_WritePhyUshort(sc, 0x14, 0x824e); MP_WritePhyUshort(sc, 0x14, 0x0213); MP_WritePhyUshort(sc, 0x14, 0x06a0); MP_WritePhyUshort(sc, 0x14, 0x010f); MP_WritePhyUshort(sc, 0x14, 0xe082); MP_WritePhyUshort(sc, 0x14, 0x44f6); MP_WritePhyUshort(sc, 0x14, 0x20e4); MP_WritePhyUshort(sc, 0x14, 0x8244); MP_WritePhyUshort(sc, 0x14, 0x580f); MP_WritePhyUshort(sc, 0x14, 0xe582); MP_WritePhyUshort(sc, 0x14, 0x5aae); MP_WritePhyUshort(sc, 0x14, 0x0ebf); MP_WritePhyUshort(sc, 0x14, 0x825e); MP_WritePhyUshort(sc, 0x14, 0xe382); MP_WritePhyUshort(sc, 0x14, 0x44f7); MP_WritePhyUshort(sc, 0x14, 0x3ce7); MP_WritePhyUshort(sc, 0x14, 0x8244); MP_WritePhyUshort(sc, 0x14, 0x0212); MP_WritePhyUshort(sc, 0x14, 0xf0ad); MP_WritePhyUshort(sc, 0x14, 0x213f); MP_WritePhyUshort(sc, 0x14, 0xe085); MP_WritePhyUshort(sc, 0x14, 0xf7e4); MP_WritePhyUshort(sc, 0x14, 0x8288); MP_WritePhyUshort(sc, 0x14, 0xe085); MP_WritePhyUshort(sc, 0x14, 0xfbe4); MP_WritePhyUshort(sc, 0x14, 0x8289); MP_WritePhyUshort(sc, 0x14, 0xe082); MP_WritePhyUshort(sc, 0x14, 0x440d); MP_WritePhyUshort(sc, 0x14, 0x0558); MP_WritePhyUshort(sc, 0x14, 0x01bf); MP_WritePhyUshort(sc, 0x14, 0x826b); MP_WritePhyUshort(sc, 0x14, 0x0215); MP_WritePhyUshort(sc, 0x14, 0x38bf); MP_WritePhyUshort(sc, 0x14, 0x824f); MP_WritePhyUshort(sc, 0x14, 0x0213); MP_WritePhyUshort(sc, 0x14, 0x06a0); MP_WritePhyUshort(sc, 0x14, 0x010f); MP_WritePhyUshort(sc, 0x14, 0xe082); MP_WritePhyUshort(sc, 0x14, 0x44f6); MP_WritePhyUshort(sc, 0x14, 0x21e4); MP_WritePhyUshort(sc, 0x14, 0x8244); MP_WritePhyUshort(sc, 0x14, 0x580f); MP_WritePhyUshort(sc, 0x14, 0xe582); MP_WritePhyUshort(sc, 0x14, 0x5bae); MP_WritePhyUshort(sc, 0x14, 0x0ebf); MP_WritePhyUshort(sc, 0x14, 0x8265); MP_WritePhyUshort(sc, 0x14, 0xe382); MP_WritePhyUshort(sc, 0x14, 0x44f7); MP_WritePhyUshort(sc, 0x14, 0x3de7); MP_WritePhyUshort(sc, 0x14, 0x8244); MP_WritePhyUshort(sc, 0x14, 0x0212); MP_WritePhyUshort(sc, 0x14, 0xf0ad); MP_WritePhyUshort(sc, 0x14, 0x223f); MP_WritePhyUshort(sc, 0x14, 0xe085); MP_WritePhyUshort(sc, 0x14, 0xf8e4); MP_WritePhyUshort(sc, 0x14, 0x8288); MP_WritePhyUshort(sc, 0x14, 0xe085); MP_WritePhyUshort(sc, 0x14, 0xfce4); MP_WritePhyUshort(sc, 0x14, 0x8289); MP_WritePhyUshort(sc, 0x14, 0xe082); MP_WritePhyUshort(sc, 0x14, 0x440d); MP_WritePhyUshort(sc, 0x14, 0x0658); MP_WritePhyUshort(sc, 0x14, 0x01bf); MP_WritePhyUshort(sc, 0x14, 0x8272); MP_WritePhyUshort(sc, 0x14, 0x0215); MP_WritePhyUshort(sc, 0x14, 0x38bf); MP_WritePhyUshort(sc, 0x14, 0x8250); MP_WritePhyUshort(sc, 0x14, 0x0213); MP_WritePhyUshort(sc, 0x14, 0x06a0); MP_WritePhyUshort(sc, 0x14, 0x010f); MP_WritePhyUshort(sc, 0x14, 0xe082); MP_WritePhyUshort(sc, 0x14, 0x44f6); MP_WritePhyUshort(sc, 0x14, 0x22e4); MP_WritePhyUshort(sc, 0x14, 0x8244); MP_WritePhyUshort(sc, 0x14, 0x580f); MP_WritePhyUshort(sc, 0x14, 0xe582); MP_WritePhyUshort(sc, 0x14, 0x5cae); MP_WritePhyUshort(sc, 0x14, 0x0ebf); MP_WritePhyUshort(sc, 0x14, 0x826c); MP_WritePhyUshort(sc, 0x14, 0xe382); MP_WritePhyUshort(sc, 0x14, 0x44f7); MP_WritePhyUshort(sc, 0x14, 0x3ee7); MP_WritePhyUshort(sc, 0x14, 0x8244); MP_WritePhyUshort(sc, 0x14, 0x0212); MP_WritePhyUshort(sc, 0x14, 0xf0ad); MP_WritePhyUshort(sc, 0x14, 0x233f); MP_WritePhyUshort(sc, 0x14, 0xe085); MP_WritePhyUshort(sc, 0x14, 0xf9e4); MP_WritePhyUshort(sc, 0x14, 0x8288); MP_WritePhyUshort(sc, 0x14, 0xe085); MP_WritePhyUshort(sc, 0x14, 0xfde4); MP_WritePhyUshort(sc, 0x14, 0x8289); MP_WritePhyUshort(sc, 0x14, 0xe082); MP_WritePhyUshort(sc, 0x14, 0x440d); MP_WritePhyUshort(sc, 0x14, 0x0758); MP_WritePhyUshort(sc, 0x14, 0x01bf); MP_WritePhyUshort(sc, 0x14, 0x8279); MP_WritePhyUshort(sc, 0x14, 0x0215); MP_WritePhyUshort(sc, 0x14, 0x38bf); MP_WritePhyUshort(sc, 0x14, 0x8251); MP_WritePhyUshort(sc, 0x14, 0x0213); MP_WritePhyUshort(sc, 0x14, 0x06a0); MP_WritePhyUshort(sc, 0x14, 0x010f); MP_WritePhyUshort(sc, 0x14, 0xe082); MP_WritePhyUshort(sc, 0x14, 0x44f6); MP_WritePhyUshort(sc, 0x14, 0x23e4); MP_WritePhyUshort(sc, 0x14, 0x8244); MP_WritePhyUshort(sc, 0x14, 0x580f); MP_WritePhyUshort(sc, 0x14, 0xe582); MP_WritePhyUshort(sc, 0x14, 0x5dae); MP_WritePhyUshort(sc, 0x14, 0x0ebf); MP_WritePhyUshort(sc, 0x14, 0x8273); MP_WritePhyUshort(sc, 0x14, 0xe382); MP_WritePhyUshort(sc, 0x14, 0x44f7); MP_WritePhyUshort(sc, 0x14, 0x3fe7); MP_WritePhyUshort(sc, 0x14, 0x8244); MP_WritePhyUshort(sc, 0x14, 0x0212); MP_WritePhyUshort(sc, 0x14, 0xf0ee); MP_WritePhyUshort(sc, 0x14, 0x8288); MP_WritePhyUshort(sc, 0x14, 0x10ee); MP_WritePhyUshort(sc, 0x14, 0x8289); MP_WritePhyUshort(sc, 0x14, 0x00af); MP_WritePhyUshort(sc, 0x14, 0x14aa); MP_WritePhyUshort(sc, 0x13, 0xb818); MP_WritePhyUshort(sc, 0x14, 0x13cf); MP_WritePhyUshort(sc, 0x13, 0xb81a); MP_WritePhyUshort(sc, 0x14, 0xfffd); MP_WritePhyUshort(sc, 0x13, 0xb81c); MP_WritePhyUshort(sc, 0x14, 0xfffd); MP_WritePhyUshort(sc, 0x13, 0xb81e); MP_WritePhyUshort(sc, 0x14, 0xfffd); MP_WritePhyUshort(sc, 0x13, 0xb832); MP_WritePhyUshort(sc, 0x14, 0x0001); 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); re_clear_phy_mcu_patch_request(sc); 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; re_set_phy_mcu_patch_request(sc); 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); MP_WritePhyUshort(sc,0x1f, 0x0A43); MP_WritePhyUshort(sc,0x13, 0x8146); MP_WritePhyUshort(sc,0x14, 0x0000); re_clear_phy_mcu_patch_request(sc); } static void re_set_phy_mcu_8168ep_2(struct re_softc *sc) { u_int16_t PhyRegValue; re_set_phy_mcu_patch_request(sc); MP_WritePhyUshort(sc,0x1f, 0x0A43); MP_WritePhyUshort(sc,0x13, 0x8146); MP_WritePhyUshort(sc,0x14, 0x8700); MP_WritePhyUshort(sc,0x13, 0xB82E); MP_WritePhyUshort(sc,0x14, 0x0001); MP_WritePhyUshort(sc, 0x1F, 0x0A43); MP_WritePhyUshort(sc, 0x13, 0x83DD); MP_WritePhyUshort(sc, 0x14, 0xAF83); MP_WritePhyUshort(sc, 0x14, 0xE9AF); MP_WritePhyUshort(sc, 0x14, 0x83EE); MP_WritePhyUshort(sc, 0x14, 0xAF83); MP_WritePhyUshort(sc, 0x14, 0xF1A1); MP_WritePhyUshort(sc, 0x14, 0x83F4); MP_WritePhyUshort(sc, 0x14, 0xD149); MP_WritePhyUshort(sc, 0x14, 0xAF06); MP_WritePhyUshort(sc, 0x14, 0x47AF); MP_WritePhyUshort(sc, 0x14, 0x0000); MP_WritePhyUshort(sc, 0x14, 0xAF00); MP_WritePhyUshort(sc, 0x14, 0x00AF); MP_WritePhyUshort(sc, 0x14, 0x0000); MP_WritePhyUshort(sc, 0x13, 0xB818); MP_WritePhyUshort(sc, 0x14, 0x0645); MP_WritePhyUshort(sc, 0x13, 0xB81A); MP_WritePhyUshort(sc, 0x14, 0x0000); MP_WritePhyUshort(sc, 0x13, 0xB81C); MP_WritePhyUshort(sc, 0x14, 0x0000); MP_WritePhyUshort(sc, 0x13, 0xB81E); MP_WritePhyUshort(sc, 0x14, 0x0000); MP_WritePhyUshort(sc, 0x13, 0xB832); MP_WritePhyUshort(sc, 0x14, 0x0001); 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); re_clear_phy_mcu_patch_request(sc); } static void re_real_set_phy_mcu_8125a_1(struct re_softc *sc) { re_acquire_phy_mcu_patch_key_lock(sc); SetEthPhyOcpBit(sc, 0xB820, BIT_7); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA016); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA012); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA014); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8010); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8013); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8021); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x802f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x803d); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8042); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8051); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8051); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa088); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0a50); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8008); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd014); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd1a3); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd700); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x401a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd707); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x40c2); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x60a6); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd700); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x5f8b); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0a86); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0a6c); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8080); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd019); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd1a2); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd700); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x401a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd707); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x40c4); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x60a6); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd700); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x5f8b); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0a86); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0a84); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd503); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8970); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0c07); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0901); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd500); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xce01); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xcf09); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd705); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x4000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xceff); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xaf0a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd504); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1213); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8401); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd500); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8580); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1253); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd064); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd181); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd704); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x4018); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd504); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xc50f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd706); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x2c59); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x804d); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xc60f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xf002); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xc605); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xae02); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x10fd); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA026); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xffff); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA024); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xffff); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA022); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x10f4); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA020); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1252); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA006); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1206); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA004); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0a78); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA002); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0a60); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0a4f); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA008); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x3f00); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA016); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0010); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA012); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA014); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8010); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8066); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x807c); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8089); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x808e); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x80a0); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x80b2); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x80c2); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd501); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xce01); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd700); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x62db); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x655c); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd73e); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x60e9); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x614a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x61ab); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0c0f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0501); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0304); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0c0f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0503); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0304); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0c0f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0505); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0304); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0c0f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0509); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0304); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x653c); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd73e); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x60e9); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x614a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x61ab); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0c0f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0503); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0304); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0c0f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0502); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0304); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0c0f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0506); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0304); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0c0f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x050a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0304); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd73e); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x60e9); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x614a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x61ab); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0c0f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0505); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0304); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0c0f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0506); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0304); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0c0f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0504); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0304); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0c0f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x050c); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0304); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd73e); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x60e9); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x614a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x61ab); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0c0f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0509); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0304); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0c0f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x050a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0304); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0c0f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x050c); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0304); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0c0f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0508); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0304); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd501); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xce01); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd73e); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x60e9); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x614a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x61ab); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0c0f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0501); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0321); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0c0f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0502); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0321); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0c0f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0504); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0321); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0c0f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0508); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0321); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0346); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd501); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xce01); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8208); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x609d); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa50f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x001a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0c0f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0503); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x001a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x607d); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x00ab); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x00ab); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd501); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xce01); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd700); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x60fd); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa50f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xce00); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd500); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xaa0f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x017b); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0c0f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0503); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xce00); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd500); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0c0f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0a05); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x017b); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd501); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xce01); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd700); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x60fd); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa50f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xce00); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd500); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xaa0f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x01e0); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0c0f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0503); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xce00); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd500); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0c0f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0a05); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x01e0); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd700); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x60fd); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa50f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xce00); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd500); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xaa0f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0231); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0c0f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0503); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xce00); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd500); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0c0f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0a05); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0231); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA08E); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xffff); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA08C); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0221); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA08A); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x01ce); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA088); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0169); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA086); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x00a6); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA084); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x000d); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA082); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0308); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA080); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x029f); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA090); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x007f); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA016); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0020); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA012); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA014); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8010); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8017); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x801b); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8029); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8054); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x805a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8064); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x80a7); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x9430); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x9480); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xb408); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd120); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd057); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x064b); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xcb80); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x9906); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0567); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xcb94); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8190); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x82a0); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x800a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8406); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8010); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa740); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8dff); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x07e4); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa840); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0773); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xcb91); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd700); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x4063); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd139); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xf002); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd140); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd040); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xb404); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0c0f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0d00); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x07dc); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa610); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa110); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa2a0); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa404); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd704); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x4045); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa180); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd704); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x405d); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa720); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0742); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x07ec); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd700); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x5f74); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0742); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd702); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x7fb6); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8190); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x82a0); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8404); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8610); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0c0f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0d01); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x07dc); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x064b); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x07c0); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd700); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x5fa7); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0481); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x94bc); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x870c); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa190); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa00a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa280); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa404); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8220); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x078e); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xcb92); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa840); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd700); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x4063); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd140); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xf002); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd150); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd040); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd703); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x60a0); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x6121); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x61a2); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x6223); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xf02f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0cf0); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0d10); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8010); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa740); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xf00f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0cf0); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0d20); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8010); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa740); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xf00a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0cf0); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0d30); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8010); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa740); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xf005); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0cf0); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0d40); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8010); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa740); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x07e4); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa610); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa008); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd704); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x4046); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa002); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd704); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x405d); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa720); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0742); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x07f7); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd700); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x5f74); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0742); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd702); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x7fb5); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x800a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0cf0); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0d00); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x07e4); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8010); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa740); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd701); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x3ad4); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0537); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8610); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8840); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x064b); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8301); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x800a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8190); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x82a0); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8404); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa70c); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x9402); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x890c); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8840); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x064b); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA10E); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0642); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA10C); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0686); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA10A); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0788); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA108); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x047b); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA106); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x065c); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA104); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0769); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA102); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0565); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA100); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x06f9); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA110); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x00ff); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xb87c); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8530); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xb87e); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xaf85); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x3caf); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8593); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xaf85); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x9caf); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x85a5); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xbf86); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd702); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x5afb); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xe083); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xfb0c); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x020d); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x021b); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x10bf); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x86d7); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x025a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xb7bf); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x86da); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x025a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xfbe0); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x83fc); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0c02); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0d02); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1b10); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xbf86); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xda02); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x5ab7); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xbf86); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xdd02); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x5afb); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xe083); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xfd0c); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x020d); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x021b); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x10bf); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x86dd); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x025a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xb7bf); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x86e0); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x025a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xfbe0); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x83fe); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0c02); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0d02); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1b10); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xbf86); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xe002); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x5ab7); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xaf2f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xbd02); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x2cac); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0286); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x65af); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x212b); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x022c); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x6002); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x86b6); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xaf21); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0cd1); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x03bf); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8710); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x025a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xb7bf); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x870d); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x025a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xb7bf); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8719); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x025a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xb7bf); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8716); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x025a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xb7bf); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x871f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x025a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xb7bf); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x871c); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x025a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xb7bf); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8728); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x025a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xb7bf); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8725); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x025a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xb7bf); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8707); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x025a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xfbad); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x281c); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd100); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xbf87); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0a02); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x5ab7); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xbf87); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1302); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x5ab7); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xbf87); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x2202); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x5ab7); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xbf87); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x2b02); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x5ab7); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xae1a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd101); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xbf87); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0a02); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x5ab7); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xbf87); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1302); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x5ab7); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xbf87); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x2202); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x5ab7); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xbf87); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x2b02); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x5ab7); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd101); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xbf87); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x3402); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x5ab7); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xbf87); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x3102); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x5ab7); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xbf87); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x3d02); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x5ab7); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xbf87); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x3a02); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x5ab7); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xbf87); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x4302); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x5ab7); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xbf87); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x4002); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x5ab7); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xbf87); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x4c02); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x5ab7); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xbf87); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x4902); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x5ab7); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd100); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xbf87); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x2e02); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x5ab7); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xbf87); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x3702); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x5ab7); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xbf87); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x4602); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x5ab7); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xbf87); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x4f02); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x5ab7); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xaf35); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x7ff8); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xfaef); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x69bf); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x86e3); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x025a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xfbbf); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x86fb); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x025a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xb7bf); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x86e6); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x025a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xfbbf); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x86fe); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x025a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xb7bf); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x86e9); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x025a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xfbbf); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8701); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x025a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xb7bf); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x86ec); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x025a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xfbbf); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8704); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x025a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xb7bf); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x86ef); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0262); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x7cbf); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x86f2); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0262); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x7cbf); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x86f5); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0262); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x7cbf); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x86f8); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0262); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x7cef); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x96fe); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xfc04); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xf8fa); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xef69); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xbf86); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xef02); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x6273); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xbf86); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xf202); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x6273); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xbf86); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xf502); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x6273); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xbf86); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xf802); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x6273); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xef96); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xfefc); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0420); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xb540); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x53b5); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x4086); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xb540); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xb9b5); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x40c8); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xb03a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xc8b0); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xbac8); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xb13a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xc8b1); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xba77); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xbd26); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xffbd); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x2677); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xbd28); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xffbd); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x2840); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xbd26); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xc8bd); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x2640); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xbd28); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xc8bd); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x28bb); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa430); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x98b0); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1eba); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xb01e); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xdcb0); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1e98); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xb09e); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xbab0); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x9edc); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xb09e); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x98b1); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1eba); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xb11e); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xdcb1); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1e98); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xb19e); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xbab1); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x9edc); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xb19e); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x11b0); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1e22); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xb01e); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x33b0); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1e11); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xb09e); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x22b0); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x9e33); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xb09e); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x11b1); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1e22); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xb11e); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x33b1); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1e11); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xb19e); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x22b1); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x9e33); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xb19e); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xb85e); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x2f71); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xb860); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x20d9); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xb862); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x2109); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xb864); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x34e7); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xb878); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x000f); ClearEthPhyOcpBit(sc, 0xB820, BIT_7); re_release_phy_mcu_patch_key_lock(sc); } static void re_set_phy_mcu_8125a_1(struct re_softc *sc) { re_set_phy_mcu_patch_request(sc); re_real_set_phy_mcu_8125a_1(sc); re_clear_phy_mcu_patch_request(sc); } static void re_real_set_phy_mcu_8125a_2(struct re_softc *sc) { re_acquire_phy_mcu_patch_key_lock(sc); SetEthPhyOcpBit(sc, 0xB820, BIT_7); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA016); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA012); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA014); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8010); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x808b); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x808f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8093); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8097); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x809d); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x80a1); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x80aa); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd718); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x607b); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x40da); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xf00e); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x42da); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xf01e); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd718); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x615b); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1456); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x14a4); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x14bc); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd718); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x5f2e); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xf01c); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1456); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x14a4); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x14bc); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd718); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x5f2e); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xf024); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1456); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x14a4); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x14bc); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd718); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x5f2e); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xf02c); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1456); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x14a4); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x14bc); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd718); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x5f2e); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xf034); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd719); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x4118); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd504); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xac11); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd501); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xce01); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa410); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xce00); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd500); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x4779); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd504); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xac0f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xae01); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd500); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1444); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xf034); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd719); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x4118); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd504); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xac22); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd501); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xce01); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa420); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xce00); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd500); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x4559); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd504); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xac0f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xae01); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd500); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1444); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xf023); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd719); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x4118); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd504); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xac44); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd501); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xce01); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa440); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xce00); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd500); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x4339); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd504); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xac0f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xae01); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd500); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1444); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xf012); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd719); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x4118); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd504); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xac88); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd501); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xce01); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa480); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xce00); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd500); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x4119); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd504); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xac0f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xae01); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd500); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1444); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xf001); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1456); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd718); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x5fac); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xc48f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x141b); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd504); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8010); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x121a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd0b4); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd1bb); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0898); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd0b4); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd1bb); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0a0e); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd064); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd18a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0b7e); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x401c); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd501); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa804); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8804); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x053b); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd500); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa301); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0648); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xc520); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa201); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd701); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x252d); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1646); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd708); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x4006); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1646); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0308); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA026); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0307); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA024); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1645); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA022); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0647); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA020); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x053a); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA006); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0b7c); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA004); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0a0c); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA002); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0896); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x11a1); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA008); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xff00); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA016); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0010); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA012); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA014); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8010); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8015); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x801a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x801a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x801a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x801a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x801a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x801a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xad02); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x02d7); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x00ed); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0c0f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0509); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xc100); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x008f); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA08E); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xffff); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA08C); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xffff); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA08A); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xffff); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA088); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xffff); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA086); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xffff); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA084); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xffff); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA082); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x008d); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA080); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x00eb); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA090); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0103); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA016); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0020); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA012); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA014); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8010); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8014); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8018); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8024); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8051); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8055); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8072); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x80dc); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xfffd); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xfffd); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8301); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x800a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8190); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x82a0); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8404); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa70c); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x9402); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x890c); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8840); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa380); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x066e); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xcb91); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd700); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x4063); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd139); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xf002); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd140); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd040); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xb404); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0c0f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0d00); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x07e0); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa610); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa110); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa2a0); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa404); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd704); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x4085); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa180); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa404); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8280); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd704); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x405d); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa720); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0743); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x07f0); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd700); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x5f74); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0743); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd702); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x7fb6); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8190); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x82a0); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8404); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8610); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0c0f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0d01); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x07e0); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x066e); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd158); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd04d); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x03d4); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x94bc); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x870c); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8380); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd10d); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd040); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x07c4); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd700); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x5fb4); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa190); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa00a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa280); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa404); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa220); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd130); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd040); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x07c4); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd700); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x5fb4); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xbb80); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd1c4); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd074); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa301); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd704); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x604b); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa90c); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0556); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xcb92); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd700); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x4063); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd116); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xf002); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd119); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd040); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd703); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x60a0); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x6241); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x63e2); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x6583); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xf054); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd701); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x611e); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd701); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x40da); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0cf0); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0d10); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa010); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8740); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xf02f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0cf0); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0d50); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8010); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa740); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xf02a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd701); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x611e); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd701); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x40da); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0cf0); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0d20); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa010); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8740); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xf021); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0cf0); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0d60); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8010); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa740); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xf01c); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd701); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x611e); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd701); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x40da); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0cf0); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0d30); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa010); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8740); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xf013); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0cf0); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0d70); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8010); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa740); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xf00e); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd701); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x611e); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd701); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x40da); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0cf0); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0d40); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa010); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8740); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xf005); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0cf0); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0d80); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8010); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa740); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x07e8); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa610); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd704); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x405d); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa720); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd700); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x5ff4); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa008); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd704); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x4046); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa002); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0743); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x07fb); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd703); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x7f6f); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x7f4e); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x7f2d); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x7f0c); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x800a); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0cf0); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0d00); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x07e8); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8010); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa740); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0743); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd702); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x7fb5); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd701); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x3ad4); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0556); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8610); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x066e); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd1f5); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xd049); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x1800); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x01ec); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA10E); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x01ea); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA10C); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x06a9); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA10A); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x078a); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA108); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x03d2); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA106); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x067f); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA104); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0665); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA102); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA100); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xA110); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x00fc); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xb87c); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8530); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xb87e); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xaf85); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x3caf); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8545); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xaf85); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x45af); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8545); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xee82); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xf900); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0103); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xaf03); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xb7f8); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xe0a6); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x00e1); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa601); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xef01); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x58f0); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa080); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x37a1); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8402); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xae16); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa185); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x02ae); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x11a1); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8702); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xae0c); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xa188); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x02ae); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x07a1); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8902); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xae02); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xae1c); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xe0b4); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x62e1); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xb463); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x6901); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xe4b4); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x62e5); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xb463); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xe0b4); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x62e1); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xb463); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x6901); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xe4b4); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x62e5); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xb463); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xfc04); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xb85e); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x03b3); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xb860); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xffff); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xb862); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xffff); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xb864); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xffff); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0xb878); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0001); ClearEthPhyOcpBit(sc, 0xB820, BIT_7); re_release_phy_mcu_patch_key_lock(sc); } static void re_set_phy_mcu_8125a_2(struct re_softc *sc) { re_set_phy_mcu_patch_request(sc); re_real_set_phy_mcu_8125a_2(sc); re_clear_phy_mcu_patch_request(sc); } static const u_int16_t phy_mcu_ram_code_8125b_1[] = { 0xa436, 0x8024, 0xa438, 0x3700, 0xa436, 0xB82E, 0xa438, 0x0001, 0xb820, 0x0090, 0xa436, 0xA016, 0xa438, 0x0000, 0xa436, 0xA012, 0xa438, 0x0000, 0xa436, 0xA014, 0xa438, 0x1800, 0xa438, 0x8010, 0xa438, 0x1800, 0xa438, 0x8025, 0xa438, 0x1800, 0xa438, 0x803a, 0xa438, 0x1800, 0xa438, 0x8044, 0xa438, 0x1800, 0xa438, 0x8083, 0xa438, 0x1800, 0xa438, 0x808d, 0xa438, 0x1800, 0xa438, 0x808d, 0xa438, 0x1800, 0xa438, 0x808d, 0xa438, 0xd712, 0xa438, 0x4077, 0xa438, 0xd71e, 0xa438, 0x4159, 0xa438, 0xd71e, 0xa438, 0x6099, 0xa438, 0x7f44, 0xa438, 0x1800, 0xa438, 0x1a14, 0xa438, 0x9040, 0xa438, 0x9201, 0xa438, 0x1800, 0xa438, 0x1b1a, 0xa438, 0xd71e, 0xa438, 0x2425, 0xa438, 0x1a14, 0xa438, 0xd71f, 0xa438, 0x3ce5, 0xa438, 0x1afb, 0xa438, 0x1800, 0xa438, 0x1b00, 0xa438, 0xd712, 0xa438, 0x4077, 0xa438, 0xd71e, 0xa438, 0x4159, 0xa438, 0xd71e, 0xa438, 0x60b9, 0xa438, 0x2421, 0xa438, 0x1c17, 0xa438, 0x1800, 0xa438, 0x1a14, 0xa438, 0x9040, 0xa438, 0x1800, 0xa438, 0x1c2c, 0xa438, 0xd71e, 0xa438, 0x2425, 0xa438, 0x1a14, 0xa438, 0xd71f, 0xa438, 0x3ce5, 0xa438, 0x1c0f, 0xa438, 0x1800, 0xa438, 0x1c13, 0xa438, 0xd702, 0xa438, 0xd501, 0xa438, 0x6072, 0xa438, 0x8401, 0xa438, 0xf002, 0xa438, 0xa401, 0xa438, 0x1000, 0xa438, 0x146e, 0xa438, 0x1800, 0xa438, 0x0b77, 0xa438, 0xd703, 0xa438, 0x665d, 0xa438, 0x653e, 0xa438, 0x641f, 0xa438, 0xd700, 0xa438, 0x62c4, 0xa438, 0x6185, 0xa438, 0x6066, 0xa438, 0x1800, 0xa438, 0x165a, 0xa438, 0xc101, 0xa438, 0xcb00, 0xa438, 0x1000, 0xa438, 0x1945, 0xa438, 0xd700, 0xa438, 0x7fa6, 0xa438, 0x1800, 0xa438, 0x807d, 0xa438, 0xc102, 0xa438, 0xcb00, 0xa438, 0x1000, 0xa438, 0x1945, 0xa438, 0xd700, 0xa438, 0x2569, 0xa438, 0x8058, 0xa438, 0x1800, 0xa438, 0x807d, 0xa438, 0xc104, 0xa438, 0xcb00, 0xa438, 0x1000, 0xa438, 0x1945, 0xa438, 0xd700, 0xa438, 0x7fa4, 0xa438, 0x1800, 0xa438, 0x807d, 0xa438, 0xc120, 0xa438, 0xcb00, 0xa438, 0x1000, 0xa438, 0x1945, 0xa438, 0xd703, 0xa438, 0x7fbf, 0xa438, 0x1800, 0xa438, 0x807d, 0xa438, 0xc140, 0xa438, 0xcb00, 0xa438, 0x1000, 0xa438, 0x1945, 0xa438, 0xd703, 0xa438, 0x7fbe, 0xa438, 0x1800, 0xa438, 0x807d, 0xa438, 0xc180, 0xa438, 0xcb00, 0xa438, 0x1000, 0xa438, 0x1945, 0xa438, 0xd703, 0xa438, 0x7fbd, 0xa438, 0xc100, 0xa438, 0xcb00, 0xa438, 0xd708, 0xa438, 0x6018, 0xa438, 0x1800, 0xa438, 0x165a, 0xa438, 0x1000, 0xa438, 0x14f6, 0xa438, 0xd014, 0xa438, 0xd1e3, 0xa438, 0x1000, 0xa438, 0x1356, 0xa438, 0xd705, 0xa438, 0x5fbe, 0xa438, 0x1800, 0xa438, 0x1559, 0xa436, 0xA026, 0xa438, 0xffff, 0xa436, 0xA024, 0xa438, 0xffff, 0xa436, 0xA022, 0xa438, 0xffff, 0xa436, 0xA020, 0xa438, 0x1557, 0xa436, 0xA006, 0xa438, 0x1677, 0xa436, 0xA004, 0xa438, 0x0b75, 0xa436, 0xA002, 0xa438, 0x1c17, 0xa436, 0xA000, 0xa438, 0x1b04, 0xa436, 0xA008, 0xa438, 0x1f00, 0xa436, 0xA016, 0xa438, 0x0020, 0xa436, 0xA012, 0xa438, 0x0000, 0xa436, 0xA014, 0xa438, 0x1800, 0xa438, 0x8010, 0xa438, 0x1800, 0xa438, 0x817f, 0xa438, 0x1800, 0xa438, 0x82ab, 0xa438, 0x1800, 0xa438, 0x83f8, 0xa438, 0x1800, 0xa438, 0x8444, 0xa438, 0x1800, 0xa438, 0x8454, 0xa438, 0x1800, 0xa438, 0x8459, 0xa438, 0x1800, 0xa438, 0x8465, 0xa438, 0xcb11, 0xa438, 0xa50c, 0xa438, 0x8310, 0xa438, 0xd701, 0xa438, 0x4076, 0xa438, 0x0c03, 0xa438, 0x0903, 0xa438, 0xd700, 0xa438, 0x6083, 0xa438, 0x0c1f, 0xa438, 0x0d00, 0xa438, 0xf003, 0xa438, 0x0c1f, 0xa438, 0x0d00, 0xa438, 0x1000, 0xa438, 0x0a7d, 0xa438, 0x1000, 0xa438, 0x0a4d, 0xa438, 0xcb12, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd71f, 0xa438, 0x5f84, 0xa438, 0xd102, 0xa438, 0xd040, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd700, 0xa438, 0x5fb4, 0xa438, 0xd701, 0xa438, 0x60f3, 0xa438, 0xd413, 0xa438, 0x1000, 0xa438, 0x0a37, 0xa438, 0xd410, 0xa438, 0x1000, 0xa438, 0x0a37, 0xa438, 0xcb13, 0xa438, 0xa108, 0xa438, 0x1000, 0xa438, 0x0a42, 0xa438, 0x8108, 0xa438, 0xa00a, 0xa438, 0xa910, 0xa438, 0xa780, 0xa438, 0xd14a, 0xa438, 0xd048, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd701, 0xa438, 0x6255, 0xa438, 0xd700, 0xa438, 0x5f74, 0xa438, 0x6326, 0xa438, 0xd702, 0xa438, 0x5f07, 0xa438, 0x800a, 0xa438, 0xa004, 0xa438, 0x1000, 0xa438, 0x0a42, 0xa438, 0x8004, 0xa438, 0xa001, 0xa438, 0x1000, 0xa438, 0x0a42, 0xa438, 0x8001, 0xa438, 0x0c03, 0xa438, 0x0902, 0xa438, 0xffe2, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd71f, 0xa438, 0x5fab, 0xa438, 0xba08, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd71f, 0xa438, 0x7f8b, 0xa438, 0x9a08, 0xa438, 0x800a, 0xa438, 0xd702, 0xa438, 0x6535, 0xa438, 0xd40d, 0xa438, 0x1000, 0xa438, 0x0a37, 0xa438, 0xcb14, 0xa438, 0xa004, 0xa438, 0x1000, 0xa438, 0x0a42, 0xa438, 0x8004, 0xa438, 0xa001, 0xa438, 0x1000, 0xa438, 0x0a42, 0xa438, 0x8001, 0xa438, 0xa00a, 0xa438, 0xa780, 0xa438, 0xd14a, 0xa438, 0xd048, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd700, 0xa438, 0x5fb4, 0xa438, 0x6206, 0xa438, 0xd702, 0xa438, 0x5f47, 0xa438, 0x800a, 0xa438, 0xa004, 0xa438, 0x1000, 0xa438, 0x0a42, 0xa438, 0x8004, 0xa438, 0xa001, 0xa438, 0x1000, 0xa438, 0x0a42, 0xa438, 0x8001, 0xa438, 0x0c03, 0xa438, 0x0902, 0xa438, 0x1800, 0xa438, 0x8064, 0xa438, 0x800a, 0xa438, 0xd40e, 0xa438, 0x1000, 0xa438, 0x0a37, 0xa438, 0xb920, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd71f, 0xa438, 0x5fac, 0xa438, 0x9920, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd71f, 0xa438, 0x7f8c, 0xa438, 0xd701, 0xa438, 0x6073, 0xa438, 0xd701, 0xa438, 0x4216, 0xa438, 0xa004, 0xa438, 0x1000, 0xa438, 0x0a42, 0xa438, 0x8004, 0xa438, 0xa001, 0xa438, 0x1000, 0xa438, 0x0a42, 0xa438, 0x8001, 0xa438, 0xd120, 0xa438, 0xd040, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd700, 0xa438, 0x5fb4, 0xa438, 0x8504, 0xa438, 0xcb21, 0xa438, 0xa301, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd700, 0xa438, 0x5f9f, 0xa438, 0x8301, 0xa438, 0xd704, 0xa438, 0x40e0, 0xa438, 0xd196, 0xa438, 0xd04d, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd700, 0xa438, 0x5fb4, 0xa438, 0xcb22, 0xa438, 0x1000, 0xa438, 0x0a6d, 0xa438, 0x0c03, 0xa438, 0x1502, 0xa438, 0xa640, 0xa438, 0x9503, 0xa438, 0x8910, 0xa438, 0x8720, 0xa438, 0xd700, 0xa438, 0x6083, 0xa438, 0x0c1f, 0xa438, 0x0d01, 0xa438, 0xf003, 0xa438, 0x0c1f, 0xa438, 0x0d01, 0xa438, 0x1000, 0xa438, 0x0a7d, 0xa438, 0x0c1f, 0xa438, 0x0f14, 0xa438, 0xcb23, 0xa438, 0x8fc0, 0xa438, 0x1000, 0xa438, 0x0a25, 0xa438, 0xaf40, 0xa438, 0x1000, 0xa438, 0x0a25, 0xa438, 0x0cc0, 0xa438, 0x0f80, 0xa438, 0x1000, 0xa438, 0x0a25, 0xa438, 0xafc0, 0xa438, 0x1000, 0xa438, 0x0a25, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd701, 0xa438, 0x5dee, 0xa438, 0xcb24, 0xa438, 0x8f1f, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd701, 0xa438, 0x7f6e, 0xa438, 0xa111, 0xa438, 0xa215, 0xa438, 0xa401, 0xa438, 0x8404, 0xa438, 0xa720, 0xa438, 0xcb25, 0xa438, 0x0c03, 0xa438, 0x1502, 0xa438, 0x8640, 0xa438, 0x9503, 0xa438, 0x1000, 0xa438, 0x0b43, 0xa438, 0x1000, 0xa438, 0x0b86, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xb920, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd71f, 0xa438, 0x5fac, 0xa438, 0x9920, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd71f, 0xa438, 0x7f8c, 0xa438, 0xcb26, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd71f, 0xa438, 0x5f82, 0xa438, 0x8111, 0xa438, 0x8205, 0xa438, 0x8404, 0xa438, 0xcb27, 0xa438, 0xd404, 0xa438, 0x1000, 0xa438, 0x0a37, 0xa438, 0xd700, 0xa438, 0x6083, 0xa438, 0x0c1f, 0xa438, 0x0d02, 0xa438, 0xf003, 0xa438, 0x0c1f, 0xa438, 0x0d02, 0xa438, 0x1000, 0xa438, 0x0a7d, 0xa438, 0xa710, 0xa438, 0xa104, 0xa438, 0x1000, 0xa438, 0x0a42, 0xa438, 0x8104, 0xa438, 0xa001, 0xa438, 0x1000, 0xa438, 0x0a42, 0xa438, 0x8001, 0xa438, 0xa120, 0xa438, 0xaa0f, 0xa438, 0x8110, 0xa438, 0xa284, 0xa438, 0xa404, 0xa438, 0xa00a, 0xa438, 0xd193, 0xa438, 0xd046, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd700, 0xa438, 0x5fb4, 0xa438, 0xcb28, 0xa438, 0xa110, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd700, 0xa438, 0x5fa8, 0xa438, 0x8110, 0xa438, 0x8284, 0xa438, 0xa404, 0xa438, 0x800a, 0xa438, 0x8710, 0xa438, 0xb804, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd71f, 0xa438, 0x7f82, 0xa438, 0x9804, 0xa438, 0xcb29, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd71f, 0xa438, 0x5f85, 0xa438, 0xa710, 0xa438, 0xb820, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd71f, 0xa438, 0x7f65, 0xa438, 0x9820, 0xa438, 0xcb2a, 0xa438, 0xa190, 0xa438, 0xa284, 0xa438, 0xa404, 0xa438, 0xa00a, 0xa438, 0xd13d, 0xa438, 0xd04a, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd700, 0xa438, 0x3444, 0xa438, 0x8149, 0xa438, 0xa220, 0xa438, 0xd1a0, 0xa438, 0xd040, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd700, 0xa438, 0x3444, 0xa438, 0x8151, 0xa438, 0xd702, 0xa438, 0x5f51, 0xa438, 0xcb2f, 0xa438, 0xa302, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd708, 0xa438, 0x5f63, 0xa438, 0xd411, 0xa438, 0x1000, 0xa438, 0x0a37, 0xa438, 0x8302, 0xa438, 0xd409, 0xa438, 0x1000, 0xa438, 0x0a37, 0xa438, 0xb920, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd71f, 0xa438, 0x5fac, 0xa438, 0x9920, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd71f, 0xa438, 0x7f8c, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd71f, 0xa438, 0x5fa3, 0xa438, 0x8190, 0xa438, 0x82a4, 0xa438, 0x8404, 0xa438, 0x800a, 0xa438, 0xb808, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd71f, 0xa438, 0x7fa3, 0xa438, 0x9808, 0xa438, 0x1800, 0xa438, 0x0433, 0xa438, 0xcb15, 0xa438, 0xa508, 0xa438, 0xd700, 0xa438, 0x6083, 0xa438, 0x0c1f, 0xa438, 0x0d01, 0xa438, 0xf003, 0xa438, 0x0c1f, 0xa438, 0x0d01, 0xa438, 0x1000, 0xa438, 0x0a7d, 0xa438, 0x1000, 0xa438, 0x0a4d, 0xa438, 0xa301, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd700, 0xa438, 0x5f9f, 0xa438, 0x8301, 0xa438, 0xd704, 0xa438, 0x40e0, 0xa438, 0xd115, 0xa438, 0xd04f, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd700, 0xa438, 0x5fb4, 0xa438, 0xd413, 0xa438, 0x1000, 0xa438, 0x0a37, 0xa438, 0xcb16, 0xa438, 0x1000, 0xa438, 0x0a6d, 0xa438, 0x0c03, 0xa438, 0x1502, 0xa438, 0xa640, 0xa438, 0x9503, 0xa438, 0x8720, 0xa438, 0xd17a, 0xa438, 0xd04c, 0xa438, 0x0c1f, 0xa438, 0x0f14, 0xa438, 0xcb17, 0xa438, 0x8fc0, 0xa438, 0x1000, 0xa438, 0x0a25, 0xa438, 0xaf40, 0xa438, 0x1000, 0xa438, 0x0a25, 0xa438, 0x0cc0, 0xa438, 0x0f80, 0xa438, 0x1000, 0xa438, 0x0a25, 0xa438, 0xafc0, 0xa438, 0x1000, 0xa438, 0x0a25, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd701, 0xa438, 0x61ce, 0xa438, 0xd700, 0xa438, 0x5db4, 0xa438, 0xcb18, 0xa438, 0x0c03, 0xa438, 0x1502, 0xa438, 0x8640, 0xa438, 0x9503, 0xa438, 0xa720, 0xa438, 0x1000, 0xa438, 0x0b43, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xffd6, 0xa438, 0x8f1f, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd701, 0xa438, 0x7f8e, 0xa438, 0xa131, 0xa438, 0xaa0f, 0xa438, 0xa2d5, 0xa438, 0xa407, 0xa438, 0xa720, 0xa438, 0x8310, 0xa438, 0xa308, 0xa438, 0x8308, 0xa438, 0xcb19, 0xa438, 0x0c03, 0xa438, 0x1502, 0xa438, 0x8640, 0xa438, 0x9503, 0xa438, 0x1000, 0xa438, 0x0b43, 0xa438, 0x1000, 0xa438, 0x0b86, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xb920, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd71f, 0xa438, 0x5fac, 0xa438, 0x9920, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd71f, 0xa438, 0x7f8c, 0xa438, 0xcb1a, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd71f, 0xa438, 0x5f82, 0xa438, 0x8111, 0xa438, 0x82c5, 0xa438, 0xa404, 0xa438, 0x8402, 0xa438, 0xb804, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd71f, 0xa438, 0x7f82, 0xa438, 0x9804, 0xa438, 0xcb1b, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd71f, 0xa438, 0x5f85, 0xa438, 0xa710, 0xa438, 0xb820, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd71f, 0xa438, 0x7f65, 0xa438, 0x9820, 0xa438, 0xcb1c, 0xa438, 0xd700, 0xa438, 0x6083, 0xa438, 0x0c1f, 0xa438, 0x0d02, 0xa438, 0xf003, 0xa438, 0x0c1f, 0xa438, 0x0d02, 0xa438, 0x1000, 0xa438, 0x0a7d, 0xa438, 0xa110, 0xa438, 0xa284, 0xa438, 0xa404, 0xa438, 0x8402, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd700, 0xa438, 0x5fa8, 0xa438, 0xcb1d, 0xa438, 0xa180, 0xa438, 0xa402, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd700, 0xa438, 0x5fa8, 0xa438, 0xa220, 0xa438, 0xd1f5, 0xa438, 0xd049, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd700, 0xa438, 0x3444, 0xa438, 0x8221, 0xa438, 0xd702, 0xa438, 0x5f51, 0xa438, 0xb920, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd71f, 0xa438, 0x5fac, 0xa438, 0x9920, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd71f, 0xa438, 0x7f8c, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd71f, 0xa438, 0x5fa3, 0xa438, 0xa504, 0xa438, 0xd700, 0xa438, 0x6083, 0xa438, 0x0c1f, 0xa438, 0x0d00, 0xa438, 0xf003, 0xa438, 0x0c1f, 0xa438, 0x0d00, 0xa438, 0x1000, 0xa438, 0x0a7d, 0xa438, 0xa00a, 0xa438, 0x8190, 0xa438, 0x82a4, 0xa438, 0x8402, 0xa438, 0xa404, 0xa438, 0xb808, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd71f, 0xa438, 0x7fa3, 0xa438, 0x9808, 0xa438, 0xcb2b, 0xa438, 0xcb2c, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd71f, 0xa438, 0x5f84, 0xa438, 0xd14a, 0xa438, 0xd048, 0xa438, 0xa780, 0xa438, 0xcb2d, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd700, 0xa438, 0x5f94, 0xa438, 0x6208, 0xa438, 0xd702, 0xa438, 0x5f27, 0xa438, 0x800a, 0xa438, 0xa004, 0xa438, 0x1000, 0xa438, 0x0a42, 0xa438, 0x8004, 0xa438, 0xa001, 0xa438, 0x1000, 0xa438, 0x0a42, 0xa438, 0x8001, 0xa438, 0x0c03, 0xa438, 0x0902, 0xa438, 0xa00a, 0xa438, 0xffe9, 0xa438, 0xcb2e, 0xa438, 0xd700, 0xa438, 0x6083, 0xa438, 0x0c1f, 0xa438, 0x0d02, 0xa438, 0xf003, 0xa438, 0x0c1f, 0xa438, 0x0d02, 0xa438, 0x1000, 0xa438, 0x0a7d, 0xa438, 0xa190, 0xa438, 0xa284, 0xa438, 0xa406, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd700, 0xa438, 0x5fa8, 0xa438, 0xa220, 0xa438, 0xd1a0, 0xa438, 0xd040, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd700, 0xa438, 0x3444, 0xa438, 0x827d, 0xa438, 0xd702, 0xa438, 0x5f51, 0xa438, 0xcb2f, 0xa438, 0xa302, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd708, 0xa438, 0x5f63, 0xa438, 0xd411, 0xa438, 0x1000, 0xa438, 0x0a37, 0xa438, 0x8302, 0xa438, 0xd409, 0xa438, 0x1000, 0xa438, 0x0a37, 0xa438, 0xb920, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd71f, 0xa438, 0x5fac, 0xa438, 0x9920, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd71f, 0xa438, 0x7f8c, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd71f, 0xa438, 0x5fa3, 0xa438, 0x8190, 0xa438, 0x82a4, 0xa438, 0x8406, 0xa438, 0x800a, 0xa438, 0xb808, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd71f, 0xa438, 0x7fa3, 0xa438, 0x9808, 0xa438, 0x1800, 0xa438, 0x0433, 0xa438, 0xcb30, 0xa438, 0x8380, 0xa438, 0xcb31, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd71f, 0xa438, 0x5f86, 0xa438, 0x9308, 0xa438, 0xb204, 0xa438, 0xb301, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd701, 0xa438, 0x5fa2, 0xa438, 0xb302, 0xa438, 0x9204, 0xa438, 0xcb32, 0xa438, 0xd408, 0xa438, 0x1000, 0xa438, 0x0a37, 0xa438, 0xd141, 0xa438, 0xd043, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd700, 0xa438, 0x5fb4, 0xa438, 0xd704, 0xa438, 0x4ccc, 0xa438, 0xd700, 0xa438, 0x4c81, 0xa438, 0xd702, 0xa438, 0x609e, 0xa438, 0xd1e5, 0xa438, 0xd04d, 0xa438, 0xf003, 0xa438, 0xd1e5, 0xa438, 0xd04d, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd700, 0xa438, 0x5fb4, 0xa438, 0xd700, 0xa438, 0x6083, 0xa438, 0x0c1f, 0xa438, 0x0d01, 0xa438, 0xf003, 0xa438, 0x0c1f, 0xa438, 0x0d01, 0xa438, 0x1000, 0xa438, 0x0a7d, 0xa438, 0x8710, 0xa438, 0xa108, 0xa438, 0x1000, 0xa438, 0x0a42, 0xa438, 0x8108, 0xa438, 0xa203, 0xa438, 0x8120, 0xa438, 0x8a0f, 0xa438, 0xa111, 0xa438, 0x8204, 0xa438, 0xa140, 0xa438, 0x1000, 0xa438, 0x0a42, 0xa438, 0x8140, 0xa438, 0xd17a, 0xa438, 0xd04b, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd700, 0xa438, 0x5fb4, 0xa438, 0xa204, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd700, 0xa438, 0x5fa7, 0xa438, 0xb920, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd71f, 0xa438, 0x5fac, 0xa438, 0x9920, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd71f, 0xa438, 0x7f8c, 0xa438, 0xd404, 0xa438, 0x1000, 0xa438, 0x0a37, 0xa438, 0xd700, 0xa438, 0x6083, 0xa438, 0x0c1f, 0xa438, 0x0d02, 0xa438, 0xf003, 0xa438, 0x0c1f, 0xa438, 0x0d02, 0xa438, 0x1000, 0xa438, 0x0a7d, 0xa438, 0xa710, 0xa438, 0x8101, 0xa438, 0x8201, 0xa438, 0xa104, 0xa438, 0x1000, 0xa438, 0x0a42, 0xa438, 0x8104, 0xa438, 0xa120, 0xa438, 0xaa0f, 0xa438, 0x8110, 0xa438, 0xa284, 0xa438, 0xa404, 0xa438, 0xa00a, 0xa438, 0xd193, 0xa438, 0xd047, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd700, 0xa438, 0x5fb4, 0xa438, 0xa110, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd700, 0xa438, 0x5fa8, 0xa438, 0xa180, 0xa438, 0xd13d, 0xa438, 0xd04a, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd700, 0xa438, 0x5fb4, 0xa438, 0xf024, 0xa438, 0xa710, 0xa438, 0xa00a, 0xa438, 0x8190, 0xa438, 0x8204, 0xa438, 0xa280, 0xa438, 0xa404, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd700, 0xa438, 0x5fa7, 0xa438, 0x8710, 0xa438, 0xb920, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd71f, 0xa438, 0x5fac, 0xa438, 0x9920, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd71f, 0xa438, 0x7f8c, 0xa438, 0x800a, 0xa438, 0x8190, 0xa438, 0x8284, 0xa438, 0x8406, 0xa438, 0xd700, 0xa438, 0x4121, 0xa438, 0xd701, 0xa438, 0x60f3, 0xa438, 0xd1e5, 0xa438, 0xd04d, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd700, 0xa438, 0x5fb4, 0xa438, 0x8710, 0xa438, 0xa00a, 0xa438, 0x8190, 0xa438, 0x8204, 0xa438, 0xa280, 0xa438, 0xa404, 0xa438, 0xb920, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd71f, 0xa438, 0x5fac, 0xa438, 0x9920, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd71f, 0xa438, 0x7f8c, 0xa438, 0xcb33, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd71f, 0xa438, 0x5f85, 0xa438, 0xa710, 0xa438, 0xb820, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd71f, 0xa438, 0x7f65, 0xa438, 0x9820, 0xa438, 0xcb34, 0xa438, 0xa00a, 0xa438, 0xa190, 0xa438, 0xa284, 0xa438, 0xa404, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd700, 0xa438, 0x5fa9, 0xa438, 0xd701, 0xa438, 0x6853, 0xa438, 0xd700, 0xa438, 0x6083, 0xa438, 0x0c1f, 0xa438, 0x0d00, 0xa438, 0xf003, 0xa438, 0x0c1f, 0xa438, 0x0d00, 0xa438, 0x1000, 0xa438, 0x0a7d, 0xa438, 0x8190, 0xa438, 0x8284, 0xa438, 0xcb35, 0xa438, 0xd407, 0xa438, 0x1000, 0xa438, 0x0a37, 0xa438, 0x8110, 0xa438, 0x8204, 0xa438, 0xa280, 0xa438, 0xa00a, 0xa438, 0xd704, 0xa438, 0x4215, 0xa438, 0xa304, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd700, 0xa438, 0x5fb8, 0xa438, 0xd1c3, 0xa438, 0xd043, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd700, 0xa438, 0x5fb4, 0xa438, 0x8304, 0xa438, 0xd700, 0xa438, 0x4109, 0xa438, 0xf01e, 0xa438, 0xcb36, 0xa438, 0xd412, 0xa438, 0x1000, 0xa438, 0x0a37, 0xa438, 0xd700, 0xa438, 0x6309, 0xa438, 0xd702, 0xa438, 0x42c7, 0xa438, 0x800a, 0xa438, 0x8180, 0xa438, 0x8280, 0xa438, 0x8404, 0xa438, 0xa004, 0xa438, 0x1000, 0xa438, 0x0a42, 0xa438, 0x8004, 0xa438, 0xa001, 0xa438, 0x1000, 0xa438, 0x0a42, 0xa438, 0x8001, 0xa438, 0x0c03, 0xa438, 0x0902, 0xa438, 0xa00a, 0xa438, 0xd14a, 0xa438, 0xd048, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd700, 0xa438, 0x5fb4, 0xa438, 0xd700, 0xa438, 0x6083, 0xa438, 0x0c1f, 0xa438, 0x0d02, 0xa438, 0xf003, 0xa438, 0x0c1f, 0xa438, 0x0d02, 0xa438, 0x1000, 0xa438, 0x0a7d, 0xa438, 0xcc55, 0xa438, 0xcb37, 0xa438, 0xa00a, 0xa438, 0xa190, 0xa438, 0xa2a4, 0xa438, 0xa404, 0xa438, 0xd700, 0xa438, 0x6041, 0xa438, 0xa402, 0xa438, 0xd13d, 0xa438, 0xd04a, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd700, 0xa438, 0x5fb4, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd700, 0xa438, 0x5fa9, 0xa438, 0xd702, 0xa438, 0x5f71, 0xa438, 0xcb38, 0xa438, 0x8224, 0xa438, 0xa288, 0xa438, 0x8180, 0xa438, 0xa110, 0xa438, 0xa404, 0xa438, 0x800a, 0xa438, 0xd700, 0xa438, 0x6041, 0xa438, 0x8402, 0xa438, 0xd415, 0xa438, 0x1000, 0xa438, 0x0a37, 0xa438, 0xd13d, 0xa438, 0xd04a, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd700, 0xa438, 0x5fb4, 0xa438, 0xcb39, 0xa438, 0xa00a, 0xa438, 0xa190, 0xa438, 0xa2a0, 0xa438, 0xa404, 0xa438, 0xd700, 0xa438, 0x6041, 0xa438, 0xa402, 0xa438, 0xd17a, 0xa438, 0xd047, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd700, 0xa438, 0x5fb4, 0xa438, 0x1800, 0xa438, 0x0560, 0xa438, 0xa111, 0xa438, 0x0000, 0xa438, 0x0000, 0xa438, 0x0000, 0xa438, 0x0000, 0xa438, 0xd3f5, 0xa438, 0xd219, 0xa438, 0x1000, 0xa438, 0x0c31, 0xa438, 0xd708, 0xa438, 0x5fa5, 0xa438, 0xa215, 0xa438, 0xd30e, 0xa438, 0xd21a, 0xa438, 0x1000, 0xa438, 0x0c31, 0xa438, 0xd708, 0xa438, 0x63e9, 0xa438, 0xd708, 0xa438, 0x5f65, 0xa438, 0xd708, 0xa438, 0x7f36, 0xa438, 0xa004, 0xa438, 0x1000, 0xa438, 0x0c35, 0xa438, 0x8004, 0xa438, 0xa001, 0xa438, 0x1000, 0xa438, 0x0c35, 0xa438, 0x8001, 0xa438, 0xd708, 0xa438, 0x4098, 0xa438, 0xd102, 0xa438, 0x9401, 0xa438, 0xf003, 0xa438, 0xd103, 0xa438, 0xb401, 0xa438, 0x1000, 0xa438, 0x0c27, 0xa438, 0xa108, 0xa438, 0x1000, 0xa438, 0x0c35, 0xa438, 0x8108, 0xa438, 0x8110, 0xa438, 0x8294, 0xa438, 0xa202, 0xa438, 0x1800, 0xa438, 0x0bdb, 0xa438, 0xd39c, 0xa438, 0xd210, 0xa438, 0x1000, 0xa438, 0x0c31, 0xa438, 0xd708, 0xa438, 0x5fa5, 0xa438, 0xd39c, 0xa438, 0xd210, 0xa438, 0x1000, 0xa438, 0x0c31, 0xa438, 0xd708, 0xa438, 0x5fa5, 0xa438, 0x1000, 0xa438, 0x0c31, 0xa438, 0xd708, 0xa438, 0x29b5, 0xa438, 0x840e, 0xa438, 0xd708, 0xa438, 0x5f4a, 0xa438, 0x0c1f, 0xa438, 0x1014, 0xa438, 0x1000, 0xa438, 0x0c31, 0xa438, 0xd709, 0xa438, 0x7fa4, 0xa438, 0x901f, 0xa438, 0x1800, 0xa438, 0x0c23, 0xa438, 0xcb43, 0xa438, 0xa508, 0xa438, 0xd701, 0xa438, 0x3699, 0xa438, 0x844a, 0xa438, 0xa504, 0xa438, 0xa190, 0xa438, 0xa2a0, 0xa438, 0xa404, 0xa438, 0xa00a, 0xa438, 0xd700, 0xa438, 0x2109, 0xa438, 0x05ea, 0xa438, 0xa402, 0xa438, 0x1800, 0xa438, 0x05ea, 0xa438, 0xcb90, 0xa438, 0x0cf0, 0xa438, 0x0ca0, 0xa438, 0x1800, 0xa438, 0x06db, 0xa438, 0xd1ff, 0xa438, 0xd052, 0xa438, 0xa508, 0xa438, 0x8718, 0xa438, 0xa00a, 0xa438, 0xa190, 0xa438, 0xa2a0, 0xa438, 0xa404, 0xa438, 0x0cf0, 0xa438, 0x0c50, 0xa438, 0x1800, 0xa438, 0x09ef, 0xa438, 0x1000, 0xa438, 0x0a5e, 0xa438, 0xd704, 0xa438, 0x2e70, 0xa438, 0x06da, 0xa438, 0xd700, 0xa438, 0x5f55, 0xa438, 0xa90c, 0xa438, 0x1800, 0xa438, 0x0645, 0xa436, 0xA10E, 0xa438, 0x0644, 0xa436, 0xA10C, 0xa438, 0x09e9, 0xa436, 0xA10A, 0xa438, 0x06da, 0xa436, 0xA108, 0xa438, 0x05e1, 0xa436, 0xA106, 0xa438, 0x0be4, 0xa436, 0xA104, 0xa438, 0x0435, 0xa436, 0xA102, 0xa438, 0x0141, 0xa436, 0xA100, 0xa438, 0x026d, 0xa436, 0xA110, 0xa438, 0x00ff, 0xa436, 0xb87c, 0xa438, 0x85fe, 0xa436, 0xb87e, 0xa438, 0xaf86, 0xa438, 0x16af, 0xa438, 0x8699, 0xa438, 0xaf86, 0xa438, 0xe5af, 0xa438, 0x86f9, 0xa438, 0xaf87, 0xa438, 0x7aaf, 0xa438, 0x883a, 0xa438, 0xaf88, 0xa438, 0x58af, 0xa438, 0x8b6c, 0xa438, 0xd48b, 0xa438, 0x7c02, 0xa438, 0x8644, 0xa438, 0x2c00, 0xa438, 0x503c, 0xa438, 0xffd6, 0xa438, 0xac27, 0xa438, 0x18e1, 0xa438, 0x82fe, 0xa438, 0xad28, 0xa438, 0x0cd4, 0xa438, 0x8b84, 0xa438, 0x0286, 0xa438, 0x442c, 0xa438, 0x003c, 0xa438, 0xac27, 0xa438, 0x06ee, 0xa438, 0x8299, 0xa438, 0x01ae, 0xa438, 0x04ee, 0xa438, 0x8299, 0xa438, 0x00af, 0xa438, 0x23dc, 0xa438, 0xf9fa, 0xa438, 0xcefa, 0xa438, 0xfbef, 0xa438, 0x79fb, 0xa438, 0xc4bf, 0xa438, 0x8b76, 0xa438, 0x026c, 0xa438, 0x6dac, 0xa438, 0x2804, 0xa438, 0xd203, 0xa438, 0xae02, 0xa438, 0xd201, 0xa438, 0xbdd8, 0xa438, 0x19d9, 0xa438, 0xef94, 0xa438, 0x026c, 0xa438, 0x6d78, 0xa438, 0x03ef, 0xa438, 0x648a, 0xa438, 0x0002, 0xa438, 0xbdd8, 0xa438, 0x19d9, 0xa438, 0xef94, 0xa438, 0x026c, 0xa438, 0x6d78, 0xa438, 0x03ef, 0xa438, 0x7402, 0xa438, 0x72cd, 0xa438, 0xac50, 0xa438, 0x02ef, 0xa438, 0x643a, 0xa438, 0x019f, 0xa438, 0xe4ef, 0xa438, 0x4678, 0xa438, 0x03ac, 0xa438, 0x2002, 0xa438, 0xae02, 0xa438, 0xd0ff, 0xa438, 0xffef, 0xa438, 0x97ff, 0xa438, 0xfec6, 0xa438, 0xfefd, 0xa438, 0x041f, 0xa438, 0x771f, 0xa438, 0x221c, 0xa438, 0x450d, 0xa438, 0x481f, 0xa438, 0x00ac, 0xa438, 0x7f04, 0xa438, 0x1a94, 0xa438, 0xae08, 0xa438, 0x1a94, 0xa438, 0xac7f, 0xa438, 0x03d7, 0xa438, 0x0100, 0xa438, 0xef46, 0xa438, 0x0d48, 0xa438, 0x1f00, 0xa438, 0x1c45, 0xa438, 0xef69, 0xa438, 0xef57, 0xa438, 0xef74, 0xa438, 0x0272, 0xa438, 0xe8a7, 0xa438, 0xffff, 0xa438, 0x0d1a, 0xa438, 0x941b, 0xa438, 0x979e, 0xa438, 0x072d, 0xa438, 0x0100, 0xa438, 0x1a64, 0xa438, 0xef76, 0xa438, 0xef97, 0xa438, 0x0d98, 0xa438, 0xd400, 0xa438, 0xff1d, 0xa438, 0x941a, 0xa438, 0x89cf, 0xa438, 0x1a75, 0xa438, 0xaf74, 0xa438, 0xf9bf, 0xa438, 0x8b79, 0xa438, 0x026c, 0xa438, 0x6da1, 0xa438, 0x0005, 0xa438, 0xe180, 0xa438, 0xa0ae, 0xa438, 0x03e1, 0xa438, 0x80a1, 0xa438, 0xaf26, 0xa438, 0x9aac, 0xa438, 0x284d, 0xa438, 0xe08f, 0xa438, 0xffef, 0xa438, 0x10c0, 0xa438, 0xe08f, 0xa438, 0xfe10, 0xa438, 0x1b08, 0xa438, 0xa000, 0xa438, 0x04c8, 0xa438, 0xaf40, 0xa438, 0x67c8, 0xa438, 0xbf8b, 0xa438, 0x8c02, 0xa438, 0x6c4e, 0xa438, 0xc4bf, 0xa438, 0x8b8f, 0xa438, 0x026c, 0xa438, 0x6def, 0xa438, 0x74e0, 0xa438, 0x830c, 0xa438, 0xad20, 0xa438, 0x0302, 0xa438, 0x74ac, 0xa438, 0xccef, 0xa438, 0x971b, 0xa438, 0x76ad, 0xa438, 0x5f02, 0xa438, 0xae13, 0xa438, 0xef69, 0xa438, 0xef30, 0xa438, 0x1b32, 0xa438, 0xc4ef, 0xa438, 0x46e4, 0xa438, 0x8ffb, 0xa438, 0xe58f, 0xa438, 0xfce7, 0xa438, 0x8ffd, 0xa438, 0xcc10, 0xa438, 0x11ae, 0xa438, 0xb8d1, 0xa438, 0x00a1, 0xa438, 0x1f03, 0xa438, 0xaf40, 0xa438, 0x4fbf, 0xa438, 0x8b8c, 0xa438, 0x026c, 0xa438, 0x4ec4, 0xa438, 0xbf8b, 0xa438, 0x8f02, 0xa438, 0x6c6d, 0xa438, 0xef74, 0xa438, 0xe083, 0xa438, 0x0cad, 0xa438, 0x2003, 0xa438, 0x0274, 0xa438, 0xaccc, 0xa438, 0xef97, 0xa438, 0x1b76, 0xa438, 0xad5f, 0xa438, 0x02ae, 0xa438, 0x04ef, 0xa438, 0x69ef, 0xa438, 0x3111, 0xa438, 0xaed1, 0xa438, 0x0287, 0xa438, 0x80af, 0xa438, 0x2293, 0xa438, 0xf8f9, 0xa438, 0xfafb, 0xa438, 0xef59, 0xa438, 0xe080, 0xa438, 0x13ad, 0xa438, 0x252f, 0xa438, 0xbf88, 0xa438, 0x2802, 0xa438, 0x6c6d, 0xa438, 0xef64, 0xa438, 0x1f44, 0xa438, 0xe18f, 0xa438, 0xb91b, 0xa438, 0x64ad, 0xa438, 0x4f1d, 0xa438, 0xd688, 0xa438, 0x2bd7, 0xa438, 0x882e, 0xa438, 0x0274, 0xa438, 0x73ad, 0xa438, 0x5008, 0xa438, 0xbf88, 0xa438, 0x3102, 0xa438, 0x737c, 0xa438, 0xae03, 0xa438, 0x0287, 0xa438, 0xd0bf, 0xa438, 0x882b, 0xa438, 0x0273, 0xa438, 0x73e0, 0xa438, 0x824c, 0xa438, 0xf621, 0xa438, 0xe482, 0xa438, 0x4cbf, 0xa438, 0x8834, 0xa438, 0x0273, 0xa438, 0x7cef, 0xa438, 0x95ff, 0xa438, 0xfefd, 0xa438, 0xfc04, 0xa438, 0xf8f9, 0xa438, 0xfafb, 0xa438, 0xef79, 0xa438, 0xbf88, 0xa438, 0x1f02, 0xa438, 0x737c, 0xa438, 0x1f22, 0xa438, 0xac32, 0xa438, 0x31ef, 0xa438, 0x12bf, 0xa438, 0x8822, 0xa438, 0x026c, 0xa438, 0x4ed6, 0xa438, 0x8fba, 0xa438, 0x1f33, 0xa438, 0xac3c, 0xa438, 0x1eef, 0xa438, 0x13bf, 0xa438, 0x8837, 0xa438, 0x026c, 0xa438, 0x4eef, 0xa438, 0x96d8, 0xa438, 0x19d9, 0xa438, 0xbf88, 0xa438, 0x2502, 0xa438, 0x6c4e, 0xa438, 0xbf88, 0xa438, 0x2502, 0xa438, 0x6c4e, 0xa438, 0x1616, 0xa438, 0x13ae, 0xa438, 0xdf12, 0xa438, 0xaecc, 0xa438, 0xbf88, 0xa438, 0x1f02, 0xa438, 0x7373, 0xa438, 0xef97, 0xa438, 0xfffe, 0xa438, 0xfdfc, 0xa438, 0x0466, 0xa438, 0xac88, 0xa438, 0x54ac, 0xa438, 0x88f0, 0xa438, 0xac8a, 0xa438, 0x92ac, 0xa438, 0xbadd, 0xa438, 0xac6c, 0xa438, 0xeeac, 0xa438, 0x6cff, 0xa438, 0xad02, 0xa438, 0x99ac, 0xa438, 0x0030, 0xa438, 0xac88, 0xa438, 0xd4c3, 0xa438, 0x5000, 0xa438, 0x0000, 0xa438, 0x0000, 0xa438, 0x0000, 0xa438, 0x0000, 0xa438, 0x0000, 0xa438, 0x0000, 0xa438, 0x0000, 0xa438, 0x0000, 0xa438, 0x00b4, 0xa438, 0xecee, 0xa438, 0x8298, 0xa438, 0x00af, 0xa438, 0x1412, 0xa438, 0xf8bf, 0xa438, 0x8b5d, 0xa438, 0x026c, 0xa438, 0x6d58, 0xa438, 0x03e1, 0xa438, 0x8fb8, 0xa438, 0x2901, 0xa438, 0xe58f, 0xa438, 0xb8a0, 0xa438, 0x0049, 0xa438, 0xef47, 0xa438, 0xe483, 0xa438, 0x02e5, 0xa438, 0x8303, 0xa438, 0xbfc2, 0xa438, 0x5f1a, 0xa438, 0x95f7, 0xa438, 0x05ee, 0xa438, 0xffd2, 0xa438, 0x00d8, 0xa438, 0xf605, 0xa438, 0x1f11, 0xa438, 0xef60, 0xa438, 0xbf8b, 0xa438, 0x3002, 0xa438, 0x6c4e, 0xa438, 0xbf8b, 0xa438, 0x3302, 0xa438, 0x6c6d, 0xa438, 0xf728, 0xa438, 0xbf8b, 0xa438, 0x3302, 0xa438, 0x6c4e, 0xa438, 0xf628, 0xa438, 0xbf8b, 0xa438, 0x3302, 0xa438, 0x6c4e, 0xa438, 0x0c64, 0xa438, 0xef46, 0xa438, 0xbf8b, 0xa438, 0x6002, 0xa438, 0x6c4e, 0xa438, 0x0289, 0xa438, 0x9902, 0xa438, 0x3920, 0xa438, 0xaf89, 0xa438, 0x96a0, 0xa438, 0x0149, 0xa438, 0xef47, 0xa438, 0xe483, 0xa438, 0x04e5, 0xa438, 0x8305, 0xa438, 0xbfc2, 0xa438, 0x5f1a, 0xa438, 0x95f7, 0xa438, 0x05ee, 0xa438, 0xffd2, 0xa438, 0x00d8, 0xa438, 0xf605, 0xa438, 0x1f11, 0xa438, 0xef60, 0xa438, 0xbf8b, 0xa438, 0x3002, 0xa438, 0x6c4e, 0xa438, 0xbf8b, 0xa438, 0x3302, 0xa438, 0x6c6d, 0xa438, 0xf729, 0xa438, 0xbf8b, 0xa438, 0x3302, 0xa438, 0x6c4e, 0xa438, 0xf629, 0xa438, 0xbf8b, 0xa438, 0x3302, 0xa438, 0x6c4e, 0xa438, 0x0c64, 0xa438, 0xef46, 0xa438, 0xbf8b, 0xa438, 0x6302, 0xa438, 0x6c4e, 0xa438, 0x0289, 0xa438, 0x9902, 0xa438, 0x3920, 0xa438, 0xaf89, 0xa438, 0x96a0, 0xa438, 0x0249, 0xa438, 0xef47, 0xa438, 0xe483, 0xa438, 0x06e5, 0xa438, 0x8307, 0xa438, 0xbfc2, 0xa438, 0x5f1a, 0xa438, 0x95f7, 0xa438, 0x05ee, 0xa438, 0xffd2, 0xa438, 0x00d8, 0xa438, 0xf605, 0xa438, 0x1f11, 0xa438, 0xef60, 0xa438, 0xbf8b, 0xa438, 0x3002, 0xa438, 0x6c4e, 0xa438, 0xbf8b, 0xa438, 0x3302, 0xa438, 0x6c6d, 0xa438, 0xf72a, 0xa438, 0xbf8b, 0xa438, 0x3302, 0xa438, 0x6c4e, 0xa438, 0xf62a, 0xa438, 0xbf8b, 0xa438, 0x3302, 0xa438, 0x6c4e, 0xa438, 0x0c64, 0xa438, 0xef46, 0xa438, 0xbf8b, 0xa438, 0x6602, 0xa438, 0x6c4e, 0xa438, 0x0289, 0xa438, 0x9902, 0xa438, 0x3920, 0xa438, 0xaf89, 0xa438, 0x96ef, 0xa438, 0x47e4, 0xa438, 0x8308, 0xa438, 0xe583, 0xa438, 0x09bf, 0xa438, 0xc25f, 0xa438, 0x1a95, 0xa438, 0xf705, 0xa438, 0xeeff, 0xa438, 0xd200, 0xa438, 0xd8f6, 0xa438, 0x051f, 0xa438, 0x11ef, 0xa438, 0x60bf, 0xa438, 0x8b30, 0xa438, 0x026c, 0xa438, 0x4ebf, 0xa438, 0x8b33, 0xa438, 0x026c, 0xa438, 0x6df7, 0xa438, 0x2bbf, 0xa438, 0x8b33, 0xa438, 0x026c, 0xa438, 0x4ef6, 0xa438, 0x2bbf, 0xa438, 0x8b33, 0xa438, 0x026c, 0xa438, 0x4e0c, 0xa438, 0x64ef, 0xa438, 0x46bf, 0xa438, 0x8b69, 0xa438, 0x026c, 0xa438, 0x4e02, 0xa438, 0x8999, 0xa438, 0x0239, 0xa438, 0x20af, 0xa438, 0x8996, 0xa438, 0xaf39, 0xa438, 0x1ef8, 0xa438, 0xf9fa, 0xa438, 0xe08f, 0xa438, 0xb838, 0xa438, 0x02ad, 0xa438, 0x2702, 0xa438, 0xae03, 0xa438, 0xaf8b, 0xa438, 0x201f, 0xa438, 0x66ef, 0xa438, 0x65bf, 0xa438, 0xc21f, 0xa438, 0x1a96, 0xa438, 0xf705, 0xa438, 0xeeff, 0xa438, 0xd200, 0xa438, 0xdaf6, 0xa438, 0x05bf, 0xa438, 0xc22f, 0xa438, 0x1a96, 0xa438, 0xf705, 0xa438, 0xeeff, 0xa438, 0xd200, 0xa438, 0xdbf6, 0xa438, 0x05ef, 0xa438, 0x021f, 0xa438, 0x110d, 0xa438, 0x42bf, 0xa438, 0x8b3c, 0xa438, 0x026c, 0xa438, 0x4eef, 0xa438, 0x021b, 0xa438, 0x031f, 0xa438, 0x110d, 0xa438, 0x42bf, 0xa438, 0x8b36, 0xa438, 0x026c, 0xa438, 0x4eef, 0xa438, 0x021a, 0xa438, 0x031f, 0xa438, 0x110d, 0xa438, 0x42bf, 0xa438, 0x8b39, 0xa438, 0x026c, 0xa438, 0x4ebf, 0xa438, 0xc23f, 0xa438, 0x1a96, 0xa438, 0xf705, 0xa438, 0xeeff, 0xa438, 0xd200, 0xa438, 0xdaf6, 0xa438, 0x05bf, 0xa438, 0xc24f, 0xa438, 0x1a96, 0xa438, 0xf705, 0xa438, 0xeeff, 0xa438, 0xd200, 0xa438, 0xdbf6, 0xa438, 0x05ef, 0xa438, 0x021f, 0xa438, 0x110d, 0xa438, 0x42bf, 0xa438, 0x8b45, 0xa438, 0x026c, 0xa438, 0x4eef, 0xa438, 0x021b, 0xa438, 0x031f, 0xa438, 0x110d, 0xa438, 0x42bf, 0xa438, 0x8b3f, 0xa438, 0x026c, 0xa438, 0x4eef, 0xa438, 0x021a, 0xa438, 0x031f, 0xa438, 0x110d, 0xa438, 0x42bf, 0xa438, 0x8b42, 0xa438, 0x026c, 0xa438, 0x4eef, 0xa438, 0x56d0, 0xa438, 0x201f, 0xa438, 0x11bf, 0xa438, 0x8b4e, 0xa438, 0x026c, 0xa438, 0x4ebf, 0xa438, 0x8b48, 0xa438, 0x026c, 0xa438, 0x4ebf, 0xa438, 0x8b4b, 0xa438, 0x026c, 0xa438, 0x4ee1, 0xa438, 0x8578, 0xa438, 0xef03, 0xa438, 0x480a, 0xa438, 0x2805, 0xa438, 0xef20, 0xa438, 0x1b01, 0xa438, 0xad27, 0xa438, 0x3f1f, 0xa438, 0x44e0, 0xa438, 0x8560, 0xa438, 0xe185, 0xa438, 0x61bf, 0xa438, 0x8b51, 0xa438, 0x026c, 0xa438, 0x4ee0, 0xa438, 0x8566, 0xa438, 0xe185, 0xa438, 0x67bf, 0xa438, 0x8b54, 0xa438, 0x026c, 0xa438, 0x4ee0, 0xa438, 0x856c, 0xa438, 0xe185, 0xa438, 0x6dbf, 0xa438, 0x8b57, 0xa438, 0x026c, 0xa438, 0x4ee0, 0xa438, 0x8572, 0xa438, 0xe185, 0xa438, 0x73bf, 0xa438, 0x8b5a, 0xa438, 0x026c, 0xa438, 0x4ee1, 0xa438, 0x8fb8, 0xa438, 0x5900, 0xa438, 0xf728, 0xa438, 0xe58f, 0xa438, 0xb8af, 0xa438, 0x8b2c, 0xa438, 0xe185, 0xa438, 0x791b, 0xa438, 0x21ad, 0xa438, 0x373e, 0xa438, 0x1f44, 0xa438, 0xe085, 0xa438, 0x62e1, 0xa438, 0x8563, 0xa438, 0xbf8b, 0xa438, 0x5102, 0xa438, 0x6c4e, 0xa438, 0xe085, 0xa438, 0x68e1, 0xa438, 0x8569, 0xa438, 0xbf8b, 0xa438, 0x5402, 0xa438, 0x6c4e, 0xa438, 0xe085, 0xa438, 0x6ee1, 0xa438, 0x856f, 0xa438, 0xbf8b, 0xa438, 0x5702, 0xa438, 0x6c4e, 0xa438, 0xe085, 0xa438, 0x74e1, 0xa438, 0x8575, 0xa438, 0xbf8b, 0xa438, 0x5a02, 0xa438, 0x6c4e, 0xa438, 0xe18f, 0xa438, 0xb859, 0xa438, 0x00f7, 0xa438, 0x28e5, 0xa438, 0x8fb8, 0xa438, 0xae4a, 0xa438, 0x1f44, 0xa438, 0xe085, 0xa438, 0x64e1, 0xa438, 0x8565, 0xa438, 0xbf8b, 0xa438, 0x5102, 0xa438, 0x6c4e, 0xa438, 0xe085, 0xa438, 0x6ae1, 0xa438, 0x856b, 0xa438, 0xbf8b, 0xa438, 0x5402, 0xa438, 0x6c4e, 0xa438, 0xe085, 0xa438, 0x70e1, 0xa438, 0x8571, 0xa438, 0xbf8b, 0xa438, 0x5702, 0xa438, 0x6c4e, 0xa438, 0xe085, 0xa438, 0x76e1, 0xa438, 0x8577, 0xa438, 0xbf8b, 0xa438, 0x5a02, 0xa438, 0x6c4e, 0xa438, 0xe18f, 0xa438, 0xb859, 0xa438, 0x00f7, 0xa438, 0x28e5, 0xa438, 0x8fb8, 0xa438, 0xae0c, 0xa438, 0xe18f, 0xa438, 0xb839, 0xa438, 0x04ac, 0xa438, 0x2f04, 0xa438, 0xee8f, 0xa438, 0xb800, 0xa438, 0xfefd, 0xa438, 0xfc04, 0xa438, 0xf0ac, 0xa438, 0x8efc, 0xa438, 0xac8c, 0xa438, 0xf0ac, 0xa438, 0xfaf0, 0xa438, 0xacf8, 0xa438, 0xf0ac, 0xa438, 0xf6f0, 0xa438, 0xad00, 0xa438, 0xf0ac, 0xa438, 0xfef0, 0xa438, 0xacfc, 0xa438, 0xf0ac, 0xa438, 0xf4f0, 0xa438, 0xacf2, 0xa438, 0xf0ac, 0xa438, 0xf0f0, 0xa438, 0xacb0, 0xa438, 0xf0ac, 0xa438, 0xaef0, 0xa438, 0xacac, 0xa438, 0xf0ac, 0xa438, 0xaaf0, 0xa438, 0xacee, 0xa438, 0xf0b0, 0xa438, 0x24f0, 0xa438, 0xb0a4, 0xa438, 0xf0b1, 0xa438, 0x24f0, 0xa438, 0xb1a4, 0xa438, 0xee8f, 0xa438, 0xb800, 0xa438, 0xd400, 0xa438, 0x00af, 0xa438, 0x3976, 0xa438, 0x66ac, 0xa438, 0xeabb, 0xa438, 0xa430, 0xa438, 0x6e50, 0xa438, 0x6e53, 0xa438, 0x6e56, 0xa438, 0x6e59, 0xa438, 0x6e5c, 0xa438, 0x6e5f, 0xa438, 0x6e62, 0xa438, 0x6e65, 0xa438, 0xd9ac, 0xa438, 0x70f0, 0xa438, 0xac6a, 0xa436, 0xb85e, 0xa438, 0x23b7, 0xa436, 0xb860, 0xa438, 0x74db, 0xa436, 0xb862, 0xa438, 0x268c, 0xa436, 0xb864, 0xa438, 0x3FE5, 0xa436, 0xb886, 0xa438, 0x2250, 0xa436, 0xb888, 0xa438, 0x140e, 0xa436, 0xb88a, 0xa438, 0x3696, 0xa436, 0xb88c, 0xa438, 0x3973, 0xa436, 0xb838, 0xa438, 0x00ff, 0xb820, 0x0010, 0xa436, 0x8464, 0xa438, 0xaf84, 0xa438, 0x7caf, 0xa438, 0x8485, 0xa438, 0xaf85, 0xa438, 0x13af, 0xa438, 0x851e, 0xa438, 0xaf85, 0xa438, 0xb9af, 0xa438, 0x8684, 0xa438, 0xaf87, 0xa438, 0x01af, 0xa438, 0x8701, 0xa438, 0xac38, 0xa438, 0x03af, 0xa438, 0x38bb, 0xa438, 0xaf38, 0xa438, 0xc302, 0xa438, 0x4618, 0xa438, 0xbf85, 0xa438, 0x0a02, 0xa438, 0x54b7, 0xa438, 0xbf85, 0xa438, 0x1002, 0xa438, 0x54c0, 0xa438, 0xd400, 0xa438, 0x0fbf, 0xa438, 0x8507, 0xa438, 0x024f, 0xa438, 0x48bf, 0xa438, 0x8504, 0xa438, 0x024f, 0xa438, 0x6759, 0xa438, 0xf0a1, 0xa438, 0x3008, 0xa438, 0xbf85, 0xa438, 0x0d02, 0xa438, 0x54c0, 0xa438, 0xae06, 0xa438, 0xbf85, 0xa438, 0x0d02, 0xa438, 0x54b7, 0xa438, 0xbf85, 0xa438, 0x0402, 0xa438, 0x4f67, 0xa438, 0xa183, 0xa438, 0x02ae, 0xa438, 0x15a1, 0xa438, 0x8502, 0xa438, 0xae10, 0xa438, 0x59f0, 0xa438, 0xa180, 0xa438, 0x16bf, 0xa438, 0x8501, 0xa438, 0x024f, 0xa438, 0x67a1, 0xa438, 0x381b, 0xa438, 0xae0b, 0xa438, 0xe18f, 0xa438, 0xffbf, 0xa438, 0x84fe, 0xa438, 0x024f, 0xa438, 0x48ae, 0xa438, 0x17bf, 0xa438, 0x84fe, 0xa438, 0x0254, 0xa438, 0xb7bf, 0xa438, 0x84fb, 0xa438, 0x0254, 0xa438, 0xb7ae, 0xa438, 0x09a1, 0xa438, 0x5006, 0xa438, 0xbf84, 0xa438, 0xfb02, 0xa438, 0x54c0, 0xa438, 0xaf04, 0xa438, 0x4700, 0xa438, 0xad34, 0xa438, 0xfdad, 0xa438, 0x0670, 0xa438, 0xae14, 0xa438, 0xf0a6, 0xa438, 0x00b8, 0xa438, 0xbd32, 0xa438, 0x30bd, 0xa438, 0x30aa, 0xa438, 0xbd2c, 0xa438, 0xccbd, 0xa438, 0x2ca1, 0xa438, 0x0705, 0xa438, 0xec80, 0xa438, 0xaf40, 0xa438, 0xf7af, 0xa438, 0x40f5, 0xa438, 0xd101, 0xa438, 0xbf85, 0xa438, 0xa402, 0xa438, 0x4f48, 0xa438, 0xbf85, 0xa438, 0xa702, 0xa438, 0x54c0, 0xa438, 0xd10f, 0xa438, 0xbf85, 0xa438, 0xaa02, 0xa438, 0x4f48, 0xa438, 0x024d, 0xa438, 0x6abf, 0xa438, 0x85ad, 0xa438, 0x024f, 0xa438, 0x67bf, 0xa438, 0x8ff7, 0xa438, 0xddbf, 0xa438, 0x85b0, 0xa438, 0x024f, 0xa438, 0x67bf, 0xa438, 0x8ff8, 0xa438, 0xddbf, 0xa438, 0x85b3, 0xa438, 0x024f, 0xa438, 0x67bf, 0xa438, 0x8ff9, 0xa438, 0xddbf, 0xa438, 0x85b6, 0xa438, 0x024f, 0xa438, 0x67bf, 0xa438, 0x8ffa, 0xa438, 0xddd1, 0xa438, 0x00bf, 0xa438, 0x85aa, 0xa438, 0x024f, 0xa438, 0x4802, 0xa438, 0x4d6a, 0xa438, 0xbf85, 0xa438, 0xad02, 0xa438, 0x4f67, 0xa438, 0xbf8f, 0xa438, 0xfbdd, 0xa438, 0xbf85, 0xa438, 0xb002, 0xa438, 0x4f67, 0xa438, 0xbf8f, 0xa438, 0xfcdd, 0xa438, 0xbf85, 0xa438, 0xb302, 0xa438, 0x4f67, 0xa438, 0xbf8f, 0xa438, 0xfddd, 0xa438, 0xbf85, 0xa438, 0xb602, 0xa438, 0x4f67, 0xa438, 0xbf8f, 0xa438, 0xfedd, 0xa438, 0xbf85, 0xa438, 0xa702, 0xa438, 0x54b7, 0xa438, 0xbf85, 0xa438, 0xa102, 0xa438, 0x54b7, 0xa438, 0xaf3c, 0xa438, 0x2066, 0xa438, 0xb800, 0xa438, 0xb8bd, 0xa438, 0x30ee, 0xa438, 0xbd2c, 0xa438, 0xb8bd, 0xa438, 0x7040, 0xa438, 0xbd86, 0xa438, 0xc8bd, 0xa438, 0x8640, 0xa438, 0xbd88, 0xa438, 0xc8bd, 0xa438, 0x8802, 0xa438, 0x1929, 0xa438, 0xa202, 0xa438, 0x02ae, 0xa438, 0x03a2, 0xa438, 0x032e, 0xa438, 0xd10f, 0xa438, 0xbf85, 0xa438, 0xaa02, 0xa438, 0x4f48, 0xa438, 0xe18f, 0xa438, 0xf7bf, 0xa438, 0x85ad, 0xa438, 0x024f, 0xa438, 0x48e1, 0xa438, 0x8ff8, 0xa438, 0xbf85, 0xa438, 0xb002, 0xa438, 0x4f48, 0xa438, 0xe18f, 0xa438, 0xf9bf, 0xa438, 0x85b3, 0xa438, 0x024f, 0xa438, 0x48e1, 0xa438, 0x8ffa, 0xa438, 0xbf85, 0xa438, 0xb602, 0xa438, 0x4f48, 0xa438, 0xae2c, 0xa438, 0xd100, 0xa438, 0xbf85, 0xa438, 0xaa02, 0xa438, 0x4f48, 0xa438, 0xe18f, 0xa438, 0xfbbf, 0xa438, 0x85ad, 0xa438, 0x024f, 0xa438, 0x48e1, 0xa438, 0x8ffc, 0xa438, 0xbf85, 0xa438, 0xb002, 0xa438, 0x4f48, 0xa438, 0xe18f, 0xa438, 0xfdbf, 0xa438, 0x85b3, 0xa438, 0x024f, 0xa438, 0x48e1, 0xa438, 0x8ffe, 0xa438, 0xbf85, 0xa438, 0xb602, 0xa438, 0x4f48, 0xa438, 0xbf86, 0xa438, 0x7e02, 0xa438, 0x4f67, 0xa438, 0xa100, 0xa438, 0x02ae, 0xa438, 0x25a1, 0xa438, 0x041d, 0xa438, 0xe18f, 0xa438, 0xf1bf, 0xa438, 0x8675, 0xa438, 0x024f, 0xa438, 0x48e1, 0xa438, 0x8ff2, 0xa438, 0xbf86, 0xa438, 0x7802, 0xa438, 0x4f48, 0xa438, 0xe18f, 0xa438, 0xf3bf, 0xa438, 0x867b, 0xa438, 0x024f, 0xa438, 0x48ae, 0xa438, 0x29a1, 0xa438, 0x070b, 0xa438, 0xae24, 0xa438, 0xbf86, 0xa438, 0x8102, 0xa438, 0x4f67, 0xa438, 0xad28, 0xa438, 0x1be1, 0xa438, 0x8ff4, 0xa438, 0xbf86, 0xa438, 0x7502, 0xa438, 0x4f48, 0xa438, 0xe18f, 0xa438, 0xf5bf, 0xa438, 0x8678, 0xa438, 0x024f, 0xa438, 0x48e1, 0xa438, 0x8ff6, 0xa438, 0xbf86, 0xa438, 0x7b02, 0xa438, 0x4f48, 0xa438, 0xaf09, 0xa438, 0x8420, 0xa438, 0xbc32, 0xa438, 0x20bc, 0xa438, 0x3e76, 0xa438, 0xbc08, 0xa438, 0xfda6, 0xa438, 0x1a00, 0xa438, 0xb64e, 0xa438, 0xd101, 0xa438, 0xbf85, 0xa438, 0xa402, 0xa438, 0x4f48, 0xa438, 0xbf85, 0xa438, 0xa702, 0xa438, 0x54c0, 0xa438, 0xd10f, 0xa438, 0xbf85, 0xa438, 0xaa02, 0xa438, 0x4f48, 0xa438, 0x024d, 0xa438, 0x6abf, 0xa438, 0x85ad, 0xa438, 0x024f, 0xa438, 0x67bf, 0xa438, 0x8ff7, 0xa438, 0xddbf, 0xa438, 0x85b0, 0xa438, 0x024f, 0xa438, 0x67bf, 0xa438, 0x8ff8, 0xa438, 0xddbf, 0xa438, 0x85b3, 0xa438, 0x024f, 0xa438, 0x67bf, 0xa438, 0x8ff9, 0xa438, 0xddbf, 0xa438, 0x85b6, 0xa438, 0x024f, 0xa438, 0x67bf, 0xa438, 0x8ffa, 0xa438, 0xddd1, 0xa438, 0x00bf, 0xa438, 0x85aa, 0xa438, 0x024f, 0xa438, 0x4802, 0xa438, 0x4d6a, 0xa438, 0xbf85, 0xa438, 0xad02, 0xa438, 0x4f67, 0xa438, 0xbf8f, 0xa438, 0xfbdd, 0xa438, 0xbf85, 0xa438, 0xb002, 0xa438, 0x4f67, 0xa438, 0xbf8f, 0xa438, 0xfcdd, 0xa438, 0xbf85, 0xa438, 0xb302, 0xa438, 0x4f67, 0xa438, 0xbf8f, 0xa438, 0xfddd, 0xa438, 0xbf85, 0xa438, 0xb602, 0xa438, 0x4f67, 0xa438, 0xbf8f, 0xa438, 0xfedd, 0xa438, 0xbf85, 0xa438, 0xa702, 0xa438, 0x54b7, 0xa438, 0xaf00, 0xa438, 0x8800, 0xa436, 0xb818, 0xa438, 0x38b8, 0xa436, 0xb81a, 0xa438, 0x0444, 0xa436, 0xb81c, 0xa438, 0x40ee, 0xa436, 0xb81e, 0xa438, 0x3C1A, 0xa436, 0xb850, 0xa438, 0x0981, 0xa436, 0xb852, 0xa438, 0x0085, 0xa436, 0xb878, 0xa438, 0xffff, 0xa436, 0xb884, 0xa438, 0xffff, 0xa436, 0xb832, 0xa438, 0x003f, 0xa436, 0x0000, 0xa438, 0x0000, 0xa436, 0xB82E, 0xa438, 0x0000, 0xa436, 0x8024, 0xa438, 0x0000, 0xb820, 0x0000, 0xa436, 0x801E, 0xa438, 0x0021, 0xFFFF, 0xFFFF }; static const u_int16_t phy_mcu_ram_code_8125b_2[] = { 0xa436, 0x8024, 0xa438, 0x3701, 0xa436, 0xB82E, 0xa438, 0x0001, 0xb820, 0x0090, 0xa436, 0xA016, 0xa438, 0x0000, 0xa436, 0xA012, 0xa438, 0x0000, 0xa436, 0xA014, 0xa438, 0x1800, 0xa438, 0x8010, 0xa438, 0x1800, 0xa438, 0x801a, 0xa438, 0x1800, 0xa438, 0x8024, 0xa438, 0x1800, 0xa438, 0x802f, 0xa438, 0x1800, 0xa438, 0x8051, 0xa438, 0x1800, 0xa438, 0x8057, 0xa438, 0x1800, 0xa438, 0x8063, 0xa438, 0x1800, 0xa438, 0x8068, 0xa438, 0xd093, 0xa438, 0xd1c4, 0xa438, 0x1000, 0xa438, 0x135c, 0xa438, 0xd704, 0xa438, 0x5fbc, 0xa438, 0xd504, 0xa438, 0xc9f1, 0xa438, 0x1800, 0xa438, 0x0fc9, 0xa438, 0xbb50, 0xa438, 0xd505, 0xa438, 0xa202, 0xa438, 0xd504, 0xa438, 0x8c0f, 0xa438, 0xd500, 0xa438, 0x1000, 0xa438, 0x1519, 0xa438, 0x1800, 0xa438, 0x1548, 0xa438, 0x2f70, 0xa438, 0x802a, 0xa438, 0x2f73, 0xa438, 0x156a, 0xa438, 0x1800, 0xa438, 0x155c, 0xa438, 0xd505, 0xa438, 0xa202, 0xa438, 0xd500, 0xa438, 0x1800, 0xa438, 0x1551, 0xa438, 0xc0c1, 0xa438, 0xc0c0, 0xa438, 0xd05a, 0xa438, 0xd1ba, 0xa438, 0xd701, 0xa438, 0x2529, 0xa438, 0x022a, 0xa438, 0xd0a7, 0xa438, 0xd1b9, 0xa438, 0xa208, 0xa438, 0x1000, 0xa438, 0x080e, 0xa438, 0xd701, 0xa438, 0x408b, 0xa438, 0x1000, 0xa438, 0x0a65, 0xa438, 0xf003, 0xa438, 0x1000, 0xa438, 0x0a6b, 0xa438, 0xd701, 0xa438, 0x1000, 0xa438, 0x0920, 0xa438, 0x1000, 0xa438, 0x0915, 0xa438, 0x1000, 0xa438, 0x0909, 0xa438, 0x228f, 0xa438, 0x8038, 0xa438, 0x9801, 0xa438, 0xd71e, 0xa438, 0x5d61, 0xa438, 0xd701, 0xa438, 0x1800, 0xa438, 0x022a, 0xa438, 0x2005, 0xa438, 0x091a, 0xa438, 0x3bd9, 0xa438, 0x0919, 0xa438, 0x1800, 0xa438, 0x0916, 0xa438, 0x1000, 0xa438, 0x14c5, 0xa438, 0xd703, 0xa438, 0x3181, 0xa438, 0x8061, 0xa438, 0x60ad, 0xa438, 0x1000, 0xa438, 0x135c, 0xa438, 0xd703, 0xa438, 0x5fba, 0xa438, 0x1800, 0xa438, 0x0cc7, 0xa438, 0xd096, 0xa438, 0xd1a9, 0xa438, 0xd503, 0xa438, 0x1800, 0xa438, 0x0c94, 0xa436, 0xA026, 0xa438, 0xffff, 0xa436, 0xA024, 0xa438, 0x0c93, 0xa436, 0xA022, 0xa438, 0x0cc5, 0xa436, 0xA020, 0xa438, 0x0915, 0xa436, 0xA006, 0xa438, 0x020a, 0xa436, 0xA004, 0xa438, 0x155b, 0xa436, 0xA002, 0xa438, 0x1542, 0xa436, 0xA000, 0xa438, 0x0fc7, 0xa436, 0xA008, 0xa438, 0x7f00, 0xa436, 0xA016, 0xa438, 0x0010, 0xa436, 0xA012, 0xa438, 0x0000, 0xa436, 0xA014, 0xa438, 0x1800, 0xa438, 0x8010, 0xa438, 0x1800, 0xa438, 0x801d, 0xa438, 0x1800, 0xa438, 0x802c, 0xa438, 0x1800, 0xa438, 0x802c, 0xa438, 0x1800, 0xa438, 0x802c, 0xa438, 0x1800, 0xa438, 0x802c, 0xa438, 0x1800, 0xa438, 0x802c, 0xa438, 0x1800, 0xa438, 0x802c, 0xa438, 0xd700, 0xa438, 0x6090, 0xa438, 0x60d1, 0xa438, 0xc95c, 0xa438, 0xf007, 0xa438, 0x60b1, 0xa438, 0xc95a, 0xa438, 0xf004, 0xa438, 0xc956, 0xa438, 0xf002, 0xa438, 0xc94e, 0xa438, 0x1800, 0xa438, 0x00cd, 0xa438, 0xd700, 0xa438, 0x6090, 0xa438, 0x60d1, 0xa438, 0xc95c, 0xa438, 0xf007, 0xa438, 0x60b1, 0xa438, 0xc95a, 0xa438, 0xf004, 0xa438, 0xc956, 0xa438, 0xf002, 0xa438, 0xc94e, 0xa438, 0x1000, 0xa438, 0x022a, 0xa438, 0x1800, 0xa438, 0x0132, 0xa436, 0xA08E, 0xa438, 0xffff, 0xa436, 0xA08C, 0xa438, 0xffff, 0xa436, 0xA08A, 0xa438, 0xffff, 0xa436, 0xA088, 0xa438, 0xffff, 0xa436, 0xA086, 0xa438, 0xffff, 0xa436, 0xA084, 0xa438, 0xffff, 0xa436, 0xA082, 0xa438, 0x012f, 0xa436, 0xA080, 0xa438, 0x00cc, 0xa436, 0xA090, 0xa438, 0x0103, 0xa436, 0xA016, 0xa438, 0x0020, 0xa436, 0xA012, 0xa438, 0x0000, 0xa436, 0xA014, 0xa438, 0x1800, 0xa438, 0x8010, 0xa438, 0x1800, 0xa438, 0x8020, 0xa438, 0x1800, 0xa438, 0x802a, 0xa438, 0x1800, 0xa438, 0x8035, 0xa438, 0x1800, 0xa438, 0x803c, 0xa438, 0x1800, 0xa438, 0x803c, 0xa438, 0x1800, 0xa438, 0x803c, 0xa438, 0x1800, 0xa438, 0x803c, 0xa438, 0xd107, 0xa438, 0xd042, 0xa438, 0xa404, 0xa438, 0x1000, 0xa438, 0x09df, 0xa438, 0xd700, 0xa438, 0x5fb4, 0xa438, 0x8280, 0xa438, 0xd700, 0xa438, 0x6065, 0xa438, 0xd125, 0xa438, 0xf002, 0xa438, 0xd12b, 0xa438, 0xd040, 0xa438, 0x1800, 0xa438, 0x077f, 0xa438, 0x0cf0, 0xa438, 0x0c50, 0xa438, 0xd104, 0xa438, 0xd040, 0xa438, 0x1000, 0xa438, 0x0aa8, 0xa438, 0xd700, 0xa438, 0x5fb4, 0xa438, 0x1800, 0xa438, 0x0a2e, 0xa438, 0xcb9b, 0xa438, 0xd110, 0xa438, 0xd040, 0xa438, 0x1000, 0xa438, 0x0b7b, 0xa438, 0x1000, 0xa438, 0x09df, 0xa438, 0xd700, 0xa438, 0x5fb4, 0xa438, 0x1800, 0xa438, 0x081b, 0xa438, 0x1000, 0xa438, 0x09df, 0xa438, 0xd704, 0xa438, 0x7fb8, 0xa438, 0xa718, 0xa438, 0x1800, 0xa438, 0x074e, 0xa436, 0xA10E, 0xa438, 0xffff, 0xa436, 0xA10C, 0xa438, 0xffff, 0xa436, 0xA10A, 0xa438, 0xffff, 0xa436, 0xA108, 0xa438, 0xffff, 0xa436, 0xA106, 0xa438, 0x074d, 0xa436, 0xA104, 0xa438, 0x0818, 0xa436, 0xA102, 0xa438, 0x0a2c, 0xa436, 0xA100, 0xa438, 0x077e, 0xa436, 0xA110, 0xa438, 0x000f, 0xa436, 0xb87c, 0xa438, 0x8625, 0xa436, 0xb87e, 0xa438, 0xaf86, 0xa438, 0x3daf, 0xa438, 0x8689, 0xa438, 0xaf88, 0xa438, 0x69af, 0xa438, 0x8887, 0xa438, 0xaf88, 0xa438, 0x9caf, 0xa438, 0x889c, 0xa438, 0xaf88, 0xa438, 0x9caf, 0xa438, 0x889c, 0xa438, 0xbf86, 0xa438, 0x49d7, 0xa438, 0x0040, 0xa438, 0x0277, 0xa438, 0x7daf, 0xa438, 0x2727, 0xa438, 0x0000, 0xa438, 0x7205, 0xa438, 0x0000, 0xa438, 0x7208, 0xa438, 0x0000, 0xa438, 0x71f3, 0xa438, 0x0000, 0xa438, 0x71f6, 0xa438, 0x0000, 0xa438, 0x7229, 0xa438, 0x0000, 0xa438, 0x722c, 0xa438, 0x0000, 0xa438, 0x7217, 0xa438, 0x0000, 0xa438, 0x721a, 0xa438, 0x0000, 0xa438, 0x721d, 0xa438, 0x0000, 0xa438, 0x7211, 0xa438, 0x0000, 0xa438, 0x7220, 0xa438, 0x0000, 0xa438, 0x7214, 0xa438, 0x0000, 0xa438, 0x722f, 0xa438, 0x0000, 0xa438, 0x7223, 0xa438, 0x0000, 0xa438, 0x7232, 0xa438, 0x0000, 0xa438, 0x7226, 0xa438, 0xf8f9, 0xa438, 0xfae0, 0xa438, 0x85b3, 0xa438, 0x3802, 0xa438, 0xad27, 0xa438, 0x02ae, 0xa438, 0x03af, 0xa438, 0x8830, 0xa438, 0x1f66, 0xa438, 0xef65, 0xa438, 0xbfc2, 0xa438, 0x1f1a, 0xa438, 0x96f7, 0xa438, 0x05ee, 0xa438, 0xffd2, 0xa438, 0x00da, 0xa438, 0xf605, 0xa438, 0xbfc2, 0xa438, 0x2f1a, 0xa438, 0x96f7, 0xa438, 0x05ee, 0xa438, 0xffd2, 0xa438, 0x00db, 0xa438, 0xf605, 0xa438, 0xef02, 0xa438, 0x1f11, 0xa438, 0x0d42, 0xa438, 0xbf88, 0xa438, 0x4202, 0xa438, 0x6e7d, 0xa438, 0xef02, 0xa438, 0x1b03, 0xa438, 0x1f11, 0xa438, 0x0d42, 0xa438, 0xbf88, 0xa438, 0x4502, 0xa438, 0x6e7d, 0xa438, 0xef02, 0xa438, 0x1a03, 0xa438, 0x1f11, 0xa438, 0x0d42, 0xa438, 0xbf88, 0xa438, 0x4802, 0xa438, 0x6e7d, 0xa438, 0xbfc2, 0xa438, 0x3f1a, 0xa438, 0x96f7, 0xa438, 0x05ee, 0xa438, 0xffd2, 0xa438, 0x00da, 0xa438, 0xf605, 0xa438, 0xbfc2, 0xa438, 0x4f1a, 0xa438, 0x96f7, 0xa438, 0x05ee, 0xa438, 0xffd2, 0xa438, 0x00db, 0xa438, 0xf605, 0xa438, 0xef02, 0xa438, 0x1f11, 0xa438, 0x0d42, 0xa438, 0xbf88, 0xa438, 0x4b02, 0xa438, 0x6e7d, 0xa438, 0xef02, 0xa438, 0x1b03, 0xa438, 0x1f11, 0xa438, 0x0d42, 0xa438, 0xbf88, 0xa438, 0x4e02, 0xa438, 0x6e7d, 0xa438, 0xef02, 0xa438, 0x1a03, 0xa438, 0x1f11, 0xa438, 0x0d42, 0xa438, 0xbf88, 0xa438, 0x5102, 0xa438, 0x6e7d, 0xa438, 0xef56, 0xa438, 0xd020, 0xa438, 0x1f11, 0xa438, 0xbf88, 0xa438, 0x5402, 0xa438, 0x6e7d, 0xa438, 0xbf88, 0xa438, 0x5702, 0xa438, 0x6e7d, 0xa438, 0xbf88, 0xa438, 0x5a02, 0xa438, 0x6e7d, 0xa438, 0xe185, 0xa438, 0xa0ef, 0xa438, 0x0348, 0xa438, 0x0a28, 0xa438, 0x05ef, 0xa438, 0x201b, 0xa438, 0x01ad, 0xa438, 0x2735, 0xa438, 0x1f44, 0xa438, 0xe085, 0xa438, 0x88e1, 0xa438, 0x8589, 0xa438, 0xbf88, 0xa438, 0x5d02, 0xa438, 0x6e7d, 0xa438, 0xe085, 0xa438, 0x8ee1, 0xa438, 0x858f, 0xa438, 0xbf88, 0xa438, 0x6002, 0xa438, 0x6e7d, 0xa438, 0xe085, 0xa438, 0x94e1, 0xa438, 0x8595, 0xa438, 0xbf88, 0xa438, 0x6302, 0xa438, 0x6e7d, 0xa438, 0xe085, 0xa438, 0x9ae1, 0xa438, 0x859b, 0xa438, 0xbf88, 0xa438, 0x6602, 0xa438, 0x6e7d, 0xa438, 0xaf88, 0xa438, 0x3cbf, 0xa438, 0x883f, 0xa438, 0x026e, 0xa438, 0x9cad, 0xa438, 0x2835, 0xa438, 0x1f44, 0xa438, 0xe08f, 0xa438, 0xf8e1, 0xa438, 0x8ff9, 0xa438, 0xbf88, 0xa438, 0x5d02, 0xa438, 0x6e7d, 0xa438, 0xe08f, 0xa438, 0xfae1, 0xa438, 0x8ffb, 0xa438, 0xbf88, 0xa438, 0x6002, 0xa438, 0x6e7d, 0xa438, 0xe08f, 0xa438, 0xfce1, 0xa438, 0x8ffd, 0xa438, 0xbf88, 0xa438, 0x6302, 0xa438, 0x6e7d, 0xa438, 0xe08f, 0xa438, 0xfee1, 0xa438, 0x8fff, 0xa438, 0xbf88, 0xa438, 0x6602, 0xa438, 0x6e7d, 0xa438, 0xaf88, 0xa438, 0x3ce1, 0xa438, 0x85a1, 0xa438, 0x1b21, 0xa438, 0xad37, 0xa438, 0x341f, 0xa438, 0x44e0, 0xa438, 0x858a, 0xa438, 0xe185, 0xa438, 0x8bbf, 0xa438, 0x885d, 0xa438, 0x026e, 0xa438, 0x7de0, 0xa438, 0x8590, 0xa438, 0xe185, 0xa438, 0x91bf, 0xa438, 0x8860, 0xa438, 0x026e, 0xa438, 0x7de0, 0xa438, 0x8596, 0xa438, 0xe185, 0xa438, 0x97bf, 0xa438, 0x8863, 0xa438, 0x026e, 0xa438, 0x7de0, 0xa438, 0x859c, 0xa438, 0xe185, 0xa438, 0x9dbf, 0xa438, 0x8866, 0xa438, 0x026e, 0xa438, 0x7dae, 0xa438, 0x401f, 0xa438, 0x44e0, 0xa438, 0x858c, 0xa438, 0xe185, 0xa438, 0x8dbf, 0xa438, 0x885d, 0xa438, 0x026e, 0xa438, 0x7de0, 0xa438, 0x8592, 0xa438, 0xe185, 0xa438, 0x93bf, 0xa438, 0x8860, 0xa438, 0x026e, 0xa438, 0x7de0, 0xa438, 0x8598, 0xa438, 0xe185, 0xa438, 0x99bf, 0xa438, 0x8863, 0xa438, 0x026e, 0xa438, 0x7de0, 0xa438, 0x859e, 0xa438, 0xe185, 0xa438, 0x9fbf, 0xa438, 0x8866, 0xa438, 0x026e, 0xa438, 0x7dae, 0xa438, 0x0ce1, 0xa438, 0x85b3, 0xa438, 0x3904, 0xa438, 0xac2f, 0xa438, 0x04ee, 0xa438, 0x85b3, 0xa438, 0x00af, 0xa438, 0x39d9, 0xa438, 0x22ac, 0xa438, 0xeaf0, 0xa438, 0xacf6, 0xa438, 0xf0ac, 0xa438, 0xfaf0, 0xa438, 0xacf8, 0xa438, 0xf0ac, 0xa438, 0xfcf0, 0xa438, 0xad00, 0xa438, 0xf0ac, 0xa438, 0xfef0, 0xa438, 0xacf0, 0xa438, 0xf0ac, 0xa438, 0xf4f0, 0xa438, 0xacf2, 0xa438, 0xf0ac, 0xa438, 0xb0f0, 0xa438, 0xacae, 0xa438, 0xf0ac, 0xa438, 0xacf0, 0xa438, 0xacaa, 0xa438, 0xa100, 0xa438, 0x0ce1, 0xa438, 0x8ff7, 0xa438, 0xbf88, 0xa438, 0x8402, 0xa438, 0x6e7d, 0xa438, 0xaf26, 0xa438, 0xe9e1, 0xa438, 0x8ff6, 0xa438, 0xbf88, 0xa438, 0x8402, 0xa438, 0x6e7d, 0xa438, 0xaf26, 0xa438, 0xf520, 0xa438, 0xac86, 0xa438, 0xbf88, 0xa438, 0x3f02, 0xa438, 0x6e9c, 0xa438, 0xad28, 0xa438, 0x03af, 0xa438, 0x3324, 0xa438, 0xad38, 0xa438, 0x03af, 0xa438, 0x32e6, 0xa438, 0xaf32, 0xa438, 0xfb00, 0xa436, 0xb87c, 0xa438, 0x8ff6, 0xa436, 0xb87e, 0xa438, 0x0705, 0xa436, 0xb87c, 0xa438, 0x8ff8, 0xa436, 0xb87e, 0xa438, 0x19cc, 0xa436, 0xb87c, 0xa438, 0x8ffa, 0xa436, 0xb87e, 0xa438, 0x28e3, 0xa436, 0xb87c, 0xa438, 0x8ffc, 0xa436, 0xb87e, 0xa438, 0x1047, 0xa436, 0xb87c, 0xa438, 0x8ffe, 0xa436, 0xb87e, 0xa438, 0x0a45, 0xa436, 0xb85e, 0xa438, 0x271E, 0xa436, 0xb860, 0xa438, 0x3846, 0xa436, 0xb862, 0xa438, 0x26E6, 0xa436, 0xb864, 0xa438, 0x32E3, 0xa436, 0xb886, 0xa438, 0xffff, 0xa436, 0xb888, 0xa438, 0xffff, 0xa436, 0xb88a, 0xa438, 0xffff, 0xa436, 0xb88c, 0xa438, 0xffff, 0xa436, 0xb838, 0xa438, 0x000f, 0xb820, 0x0010, 0xa436, 0x0000, 0xa438, 0x0000, 0xa436, 0xB82E, 0xa438, 0x0000, 0xa436, 0x8024, 0xa438, 0x0000, 0xb820, 0x0000, 0xa436, 0x801E, 0xa438, 0x0016, 0xFFFF, 0xFFFF }; static void re_real_set_phy_mcu_8125b_1(struct re_softc *sc) { re_set_phy_mcu_ram_code(sc, phy_mcu_ram_code_8125b_1, ARRAY_SIZE(phy_mcu_ram_code_8125b_1) ); } static void re_set_phy_mcu_8125b_1(struct re_softc *sc) { re_set_phy_mcu_patch_request(sc); re_real_set_phy_mcu_8125b_1(sc); re_clear_phy_mcu_patch_request(sc); } static void re_real_set_phy_mcu_8125b_2(struct re_softc *sc) { re_set_phy_mcu_ram_code(sc, phy_mcu_ram_code_8125b_2, ARRAY_SIZE(phy_mcu_ram_code_8125b_2) ); } static void re_set_phy_mcu_8125b_2(struct re_softc *sc) { re_set_phy_mcu_patch_request(sc); re_real_set_phy_mcu_8125b_2(sc); re_clear_phy_mcu_patch_request(sc); } 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_67: re_set_phy_mcu_8168ep_2(sc); break; case MACFG_68: re_set_phy_mcu_8168h_1(sc); break; case MACFG_69: re_set_phy_mcu_8168h_2(sc); break; case MACFG_80: re_set_phy_mcu_8125a_1(sc); break; case MACFG_81: re_set_phy_mcu_8125a_2(sc); break; case MACFG_82: re_set_phy_mcu_8125b_1(sc); break; case MACFG_83: re_set_phy_mcu_8125b_2(sc); break; } re_write_hw_phy_mcu_code_ver(sc); MP_WritePhyUshort(sc, 0x1F, 0x0000); } static void re_set_hw_phy_before_init_phy_mcu(struct re_softc *sc) { device_t dev = sc->dev; u_int16_t PhyRegValue; switch (sc->re_type) { case MACFG_82: case MACFG_83: MP_RealWritePhyOcpRegWord(sc, 0xBF86, 0x9000); SetEthPhyOcpBit(sc, 0xC402, BIT_10); ClearEthPhyOcpBit(sc, 0xC402, BIT_10); PhyRegValue = MP_RealReadPhyOcpRegWord(sc, 0xBF86); PhyRegValue &= (BIT_1 | BIT_0); if (PhyRegValue != 0) device_printf(dev, "PHY watch dog not clear, value = 0x%x \n", PhyRegValue); MP_RealWritePhyOcpRegWord(sc, 0xBD86, 0x1010); MP_RealWritePhyOcpRegWord(sc, 0xBD88, 0x1010); ClearAndSetEthPhyOcpBit(sc, 0xBD4E, BIT_11 | BIT_10, BIT_11); ClearAndSetEthPhyOcpBit(sc, 0xBF46, BIT_11 | BIT_10 | BIT_9 | BIT_8, BIT_10 | BIT_9 | BIT_8); break; } } 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; struct ifnet *ifp = RE_GET_IFNET(sc); switch (sc->re_type) { case MACFG_59: case MACFG_60: case MACFG_62: case MACFG_67: case MACFG_68: case MACFG_69: case MACFG_70: case MACFG_71: case MACFG_72: case MACFG_80: case MACFG_81: case MACFG_82: case MACFG_83: re_disable_ocp_phy_power_saving(sc); break; } if (HW_DASH_SUPPORT_TYPE_3(sc) && sc->HwPkgDet == 0x06) return; re_set_hw_phy_before_init_phy_mcu(sc); if (FALSE == re_phy_ram_code_check(sc)) { re_set_phy_ram_code_check_fail_flag(sc); return; } re_init_hw_phy_mcu(sc); MP_WritePhyUshort(sc, 0x1F, 0x0000); if (sc->re_type == MACFG_3) { CSR_WRITE_1(sc, 0x82, CSR_READ_1(sc, 0x82)|BIT_0); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x0b, 0x0000); MP_WritePhyUshort(sc, 0x1f, 0x0001); MP_WritePhyUshort(sc, 0x06, 0x006e); MP_WritePhyUshort(sc, 0x08, 0x0708); MP_WritePhyUshort(sc, 0x15, 0x4000); MP_WritePhyUshort(sc, 0x18, 0x65c7); MP_WritePhyUshort(sc, 0x1f, 0x0001); MP_WritePhyUshort(sc, 0x03, 0x00a1); MP_WritePhyUshort(sc, 0x02, 0x0008); MP_WritePhyUshort(sc, 0x01, 0x0120); MP_WritePhyUshort(sc, 0x00, 0x1000); MP_WritePhyUshort(sc, 0x04, 0x0800); MP_WritePhyUshort(sc, 0x04, 0x0000); MP_WritePhyUshort(sc, 0x03, 0xff41); MP_WritePhyUshort(sc, 0x02, 0xdf60); MP_WritePhyUshort(sc, 0x01, 0x0140); MP_WritePhyUshort(sc, 0x00, 0x0077); MP_WritePhyUshort(sc, 0x04, 0x7800); MP_WritePhyUshort(sc, 0x04, 0x7000); MP_WritePhyUshort(sc, 0x03, 0x802f); MP_WritePhyUshort(sc, 0x02, 0x4f02); MP_WritePhyUshort(sc, 0x01, 0x0409); MP_WritePhyUshort(sc, 0x00, 0xf0f9); MP_WritePhyUshort(sc, 0x04, 0x9800); MP_WritePhyUshort(sc, 0x04, 0x9000); MP_WritePhyUshort(sc, 0x03, 0xdf01); MP_WritePhyUshort(sc, 0x02, 0xdf20); MP_WritePhyUshort(sc, 0x01, 0xff95); MP_WritePhyUshort(sc, 0x00, 0xba00); MP_WritePhyUshort(sc, 0x04, 0xa800); MP_WritePhyUshort(sc, 0x04, 0xa000); MP_WritePhyUshort(sc, 0x03, 0xff41); MP_WritePhyUshort(sc, 0x02, 0xdf20); MP_WritePhyUshort(sc, 0x01, 0x0140); MP_WritePhyUshort(sc, 0x00, 0x00bb); MP_WritePhyUshort(sc, 0x04, 0xb800); MP_WritePhyUshort(sc, 0x04, 0xb000); MP_WritePhyUshort(sc, 0x03, 0xdf41); MP_WritePhyUshort(sc, 0x02, 0xdc60); MP_WritePhyUshort(sc, 0x01, 0x6340); MP_WritePhyUshort(sc, 0x00, 0x007d); MP_WritePhyUshort(sc, 0x04, 0xd800); MP_WritePhyUshort(sc, 0x04, 0xd000); MP_WritePhyUshort(sc, 0x03, 0xdf01); MP_WritePhyUshort(sc, 0x02, 0xdf20); MP_WritePhyUshort(sc, 0x01, 0x100a); MP_WritePhyUshort(sc, 0x00, 0xa0ff); MP_WritePhyUshort(sc, 0x04, 0xf800); MP_WritePhyUshort(sc, 0x04, 0xf000); MP_WritePhyUshort(sc, 0x1f, 0x0000); MP_WritePhyUshort(sc, 0x0b, 0x0000); MP_WritePhyUshort(sc, 0x00, 0x9200); CSR_WRITE_1(sc, 0x82, 0x0d); } else if (sc->re_type == MACFG_4) { MP_WritePhyUshort(sc, 0x1f, 0x0002); MP_WritePhyUshort(sc, 0x01, 0x90D0); MP_WritePhyUshort(sc, 0x1f, 0x0000); // MP_WritePhyUshort(sc, 0x1e, 0x8c00); /* PHY link down with some Giga switch */ } else if (sc->re_type == MACFG_5) { MP_WritePhyUshort(sc, 0x1f, 0x0001); MP_WritePhyUshort(sc, 0x04, 0x0000); MP_WritePhyUshort(sc, 0x03, 0x00a1); MP_WritePhyUshort(sc, 0x02, 0x0008); MP_WritePhyUshort(sc, 0x01, 0x0120); MP_WritePhyUshort(sc, 0x00, 0x1000); MP_WritePhyUshort(sc, 0x04, 0x0800); MP_WritePhyUshort(sc, 0x04, 0x9000); MP_WritePhyUshort(sc, 0x03, 0x802f); MP_WritePhyUshort(sc, 0x02, 0x4f02); MP_WritePhyUshort(sc, 0x01, 0x0409); MP_WritePhyUshort(sc, 0x00, 0xf099); MP_WritePhyUshort(sc, 0x04, 0x9800); MP_WritePhyUshort(sc, 0x04, 0xa000); MP_WritePhyUshort(sc, 0x03, 0xdf01); MP_WritePhyUshort(sc, 0x02, 0xdf20); MP_WritePhyUshort(sc, 0x01, 0xff95); MP_WritePhyUshort(sc, 0x00, 0xba00); MP_WritePhyUshort(sc, 0x04, 0xa800); MP_WritePhyUshort(sc, 0x04, 0xf000); MP_WritePhyUshort(sc, 0x03, 0xdf01); MP_WritePhyUshort(sc, 0x02, 0xdf20); MP_WritePhyUshort(sc, 0x01, 0x101a); MP_WritePhyUshort(sc, 0x00, 0xa0ff); MP_WritePhyUshort(sc, 0x04, 0xf800); MP_WritePhyUshort(sc, 0x04, 0x0000); MP_WritePhyUshort(sc, 0x1f, 0x0000); MP_WritePhyUshort(sc, 0x1f, 0x0001); MP_WritePhyUshort(sc, 0x10, 0xf41b); MP_WritePhyUshort(sc, 0x14, 0xfb54); MP_WritePhyUshort(sc, 0x18, 0xf5c7); MP_WritePhyUshort(sc, 0x1f, 0x0000); MP_WritePhyUshort(sc, 0x1f, 0x0001); MP_WritePhyUshort(sc, 0x17, 0x0CC0); MP_WritePhyUshort(sc, 0x1f, 0x0000); MP_WritePhyUshort(sc, 0x1f, 0x0001); MP_WritePhyUshort(sc, 0x10, 0xf01b); } else if (sc->re_type == MACFG_6) { MP_WritePhyUshort(sc, 0x1f, 0x0001); MP_WritePhyUshort(sc, 0x04, 0x0000); MP_WritePhyUshort(sc, 0x03, 0x00a1); MP_WritePhyUshort(sc, 0x02, 0x0008); MP_WritePhyUshort(sc, 0x01, 0x0120); MP_WritePhyUshort(sc, 0x00, 0x1000); MP_WritePhyUshort(sc, 0x04, 0x0800); MP_WritePhyUshort(sc, 0x04, 0x9000); MP_WritePhyUshort(sc, 0x03, 0x802f); MP_WritePhyUshort(sc, 0x02, 0x4f02); MP_WritePhyUshort(sc, 0x01, 0x0409); MP_WritePhyUshort(sc, 0x00, 0xf099); MP_WritePhyUshort(sc, 0x04, 0x9800); MP_WritePhyUshort(sc, 0x04, 0xa000); MP_WritePhyUshort(sc, 0x03, 0xdf01); MP_WritePhyUshort(sc, 0x02, 0xdf20); MP_WritePhyUshort(sc, 0x01, 0xff95); MP_WritePhyUshort(sc, 0x00, 0xba00); MP_WritePhyUshort(sc, 0x04, 0xa800); MP_WritePhyUshort(sc, 0x04, 0xf000); MP_WritePhyUshort(sc, 0x03, 0xdf01); MP_WritePhyUshort(sc, 0x02, 0xdf20); MP_WritePhyUshort(sc, 0x01, 0x101a); MP_WritePhyUshort(sc, 0x00, 0xa0ff); MP_WritePhyUshort(sc, 0x04, 0xf800); MP_WritePhyUshort(sc, 0x04, 0x0000); MP_WritePhyUshort(sc, 0x1f, 0x0000); MP_WritePhyUshort(sc, 0x1f, 0x0001); MP_WritePhyUshort(sc, 0x0b, 0x8480); MP_WritePhyUshort(sc, 0x1f, 0x0000); MP_WritePhyUshort(sc, 0x1f, 0x0001); MP_WritePhyUshort(sc, 0x18, 0x67c7); MP_WritePhyUshort(sc, 0x04, 0x2000); MP_WritePhyUshort(sc, 0x03, 0x002f); MP_WritePhyUshort(sc, 0x02, 0x4360); MP_WritePhyUshort(sc, 0x01, 0x0109); MP_WritePhyUshort(sc, 0x00, 0x3022); MP_WritePhyUshort(sc, 0x04, 0x2800); MP_WritePhyUshort(sc, 0x1f, 0x0000); MP_WritePhyUshort(sc, 0x1f, 0x0001); MP_WritePhyUshort(sc, 0x17, 0x0CC0); } else if (sc->re_type == MACFG_14) { MP_WritePhyUshort(sc, 0x1f, 0x0000); MP_WritePhyUshort(sc, 0x11, MP_ReadPhyUshort(sc, 0x11) | 0x1000); MP_WritePhyUshort(sc, 0x19, MP_ReadPhyUshort(sc, 0x19) | 0x2000); MP_WritePhyUshort(sc, 0x10, MP_ReadPhyUshort(sc, 0x10) | 0x8000); MP_WritePhyUshort(sc, 0x1f, 0x0003); MP_WritePhyUshort(sc, 0x08, 0x441D); MP_WritePhyUshort(sc, 0x01, 0x9100); } else if (sc->re_type == MACFG_15) { MP_WritePhyUshort(sc, 0x1f, 0x0000); MP_WritePhyUshort(sc, 0x11, MP_ReadPhyUshort(sc, 0x11) | 0x1000); MP_WritePhyUshort(sc, 0x19, MP_ReadPhyUshort(sc, 0x19) | 0x2000); MP_WritePhyUshort(sc, 0x10, MP_ReadPhyUshort(sc, 0x10) | 0x8000); MP_WritePhyUshort(sc, 0x1f, 0x0003); MP_WritePhyUshort(sc, 0x08, 0x441D); MP_WritePhyUshort(sc, 0x01, 0x9100); } else if (sc->re_type == MACFG_17) { MP_WritePhyUshort(sc, 0x1f, 0x0000); MP_WritePhyUshort(sc, 0x11, MP_ReadPhyUshort(sc, 0x11) | 0x1000); MP_WritePhyUshort(sc, 0x19, MP_ReadPhyUshort(sc, 0x19) | 0x2000); MP_WritePhyUshort(sc, 0x10, MP_ReadPhyUshort(sc, 0x10) | 0x8000); MP_WritePhyUshort(sc, 0x1f, 0x0003); MP_WritePhyUshort(sc, 0x08, 0x441D); MP_WritePhyUshort(sc, 0x1f, 0x0000); } else if (sc->re_type == MACFG_21) { MP_WritePhyUshort(sc, 0x1F, 0x0001); MP_WritePhyUshort(sc, 0x0B, 0x94B0); MP_WritePhyUshort(sc, 0x1F, 0x0003); MP_WritePhyUshort(sc, 0x12, 0x6096); MP_WritePhyUshort(sc, 0x1F, 0x0000); } else if (sc->re_type == MACFG_22) { MP_WritePhyUshort(sc, 0x1F, 0x0001); MP_WritePhyUshort(sc, 0x0B, 0x94B0); MP_WritePhyUshort(sc, 0x1F, 0x0003); MP_WritePhyUshort(sc, 0x12, 0x6096); } else if (sc->re_type == MACFG_23) { MP_WritePhyUshort(sc, 0x1F, 0x0001); MP_WritePhyUshort(sc, 0x0B, 0x94B0); MP_WritePhyUshort(sc, 0x1F, 0x0003); MP_WritePhyUshort(sc, 0x12, 0x6096); } else if (sc->re_type == MACFG_24) { MP_WritePhyUshort(sc, 0x1F, 0x0001); MP_WritePhyUshort(sc, 0x12, 0x2300); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0003); MP_WritePhyUshort(sc, 0x16, 0x000A); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0003); MP_WritePhyUshort(sc, 0x12, 0xC096); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0002); MP_WritePhyUshort(sc, 0x00, 0x88DE); MP_WritePhyUshort(sc, 0x01, 0x82B1); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0002); MP_WritePhyUshort(sc, 0x08, 0x9E30); MP_WritePhyUshort(sc, 0x09, 0x01F0); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0002); MP_WritePhyUshort(sc, 0x0A, 0x5500); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0002); MP_WritePhyUshort(sc, 0x03, 0x7002); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x14, MP_ReadPhyUshort(sc, 0x14) | BIT_5); MP_WritePhyUshort(sc, 0x0d, MP_ReadPhyUshort(sc, 0x0d) | BIT_5); } else if (sc->re_type == MACFG_25) { MP_WritePhyUshort(sc, 0x1F, 0x0001); MP_WritePhyUshort(sc, 0x12, 0x2300); MP_WritePhyUshort(sc, 0x1F, 0x0003); MP_WritePhyUshort(sc, 0x16, 0x0F0A); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0002); MP_WritePhyUshort(sc, 0x00, 0x88DE); MP_WritePhyUshort(sc, 0x01, 0x82B1); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0002); MP_WritePhyUshort(sc, 0x0C, 0x7EB8); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0002); MP_WritePhyUshort(sc, 0x06, 0x0761); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0001); MP_WritePhyUshort(sc, 0x03, 0x802F); MP_WritePhyUshort(sc, 0x02, 0x4F02); MP_WritePhyUshort(sc, 0x01, 0x0409); MP_WritePhyUshort(sc, 0x00, 0xF099); MP_WritePhyUshort(sc, 0x04, 0x9800); MP_WritePhyUshort(sc, 0x04, 0x9000); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x16, MP_ReadPhyUshort(sc, 0x16) | BIT_0); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x14, MP_ReadPhyUshort(sc, 0x14) | BIT_5); MP_WritePhyUshort(sc, 0x0D, MP_ReadPhyUshort(sc, 0x0D) & ~BIT_5); MP_WritePhyUshort(sc, 0x1F, 0x0001); MP_WritePhyUshort(sc, 0x1D, 0x3D98); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0001); MP_WritePhyUshort(sc, 0x17, 0x0CC0); MP_WritePhyUshort(sc, 0x1F, 0x0000); } else if (sc->re_type == MACFG_26) { MP_WritePhyUshort(sc, 0x1F, 0x0001); MP_WritePhyUshort(sc, 0x12, 0x2300); MP_WritePhyUshort(sc, 0x1F, 0x0003); MP_WritePhyUshort(sc, 0x16, 0x0F0A); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0002); MP_WritePhyUshort(sc, 0x00, 0x88DE); MP_WritePhyUshort(sc, 0x01, 0x82B1); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0002); MP_WritePhyUshort(sc, 0x0C, 0x7EB8); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0002); MP_WritePhyUshort(sc, 0x06, 0x5461); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0002); MP_WritePhyUshort(sc, 0x06, 0x5461); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x16, MP_ReadPhyUshort(sc, 0x16) | BIT_0); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x14, MP_ReadPhyUshort(sc, 0x14) | BIT_5); MP_WritePhyUshort(sc, 0x0D, MP_ReadPhyUshort(sc, 0x0D) & ~BIT_5); MP_WritePhyUshort(sc, 0x1F, 0x0001); MP_WritePhyUshort(sc, 0x1D, 0x3D98); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1f, 0x0001); MP_WritePhyUshort(sc, 0x17, 0x0CC0); MP_WritePhyUshort(sc, 0x1F, 0x0000); } else if (sc->re_type == MACFG_27) { MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x0d, MP_ReadPhyUshort(sc, 0x0d) | BIT_5); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0001); MP_WritePhyUshort(sc, 0x1D, 0x3D98); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0001); MP_WritePhyUshort(sc, 0x14, 0xCAA3); MP_WritePhyUshort(sc, 0x1C, 0x000A); MP_WritePhyUshort(sc, 0x18, 0x65D0); MP_WritePhyUshort(sc, 0x1F, 0x0003); MP_WritePhyUshort(sc, 0x17, 0xB580); MP_WritePhyUshort(sc, 0x18, 0xFF54); MP_WritePhyUshort(sc, 0x19, 0x3954); MP_WritePhyUshort(sc, 0x1F, 0x0002); MP_WritePhyUshort(sc, 0x0D, 0x310C); MP_WritePhyUshort(sc, 0x0E, 0x310C); MP_WritePhyUshort(sc, 0x0F, 0x311C); MP_WritePhyUshort(sc, 0x06, 0x0761); MP_WritePhyUshort(sc, 0x1F, 0x0003); MP_WritePhyUshort(sc, 0x18, 0xFF55); MP_WritePhyUshort(sc, 0x19, 0x3955); MP_WritePhyUshort(sc, 0x18, 0xFF54); MP_WritePhyUshort(sc, 0x19, 0x3954); MP_WritePhyUshort(sc, 0x1f, 0x0001); MP_WritePhyUshort(sc, 0x17, 0x0CC0); } else if (sc->re_type == MACFG_28) { MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x14, MP_ReadPhyUshort(sc, 0x14) | BIT_5); MP_WritePhyUshort(sc, 0x0d, MP_ReadPhyUshort(sc, 0x0d) | BIT_5); MP_WritePhyUshort(sc, 0x1F, 0x0001); MP_WritePhyUshort(sc, 0x14, 0xCAA3); MP_WritePhyUshort(sc, 0x1C, 0x000A); MP_WritePhyUshort(sc, 0x18, 0x65D0); MP_WritePhyUshort(sc, 0x1F, 0x0003); MP_WritePhyUshort(sc, 0x17, 0xB580); MP_WritePhyUshort(sc, 0x18, 0xFF54); MP_WritePhyUshort(sc, 0x19, 0x3954); MP_WritePhyUshort(sc, 0x1F, 0x0002); MP_WritePhyUshort(sc, 0x0D, 0x310C); MP_WritePhyUshort(sc, 0x0E, 0x310C); MP_WritePhyUshort(sc, 0x0F, 0x311C); MP_WritePhyUshort(sc, 0x06, 0x0761); MP_WritePhyUshort(sc, 0x1F, 0x0003); MP_WritePhyUshort(sc, 0x18, 0xFF55); MP_WritePhyUshort(sc, 0x19, 0x3955); MP_WritePhyUshort(sc, 0x18, 0xFF54); MP_WritePhyUshort(sc, 0x19, 0x3954); MP_WritePhyUshort(sc, 0x1f, 0x0001); MP_WritePhyUshort(sc, 0x17, 0x0CC0); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x16, MP_ReadPhyUshort(sc, 0x16) | BIT_0); MP_WritePhyUshort(sc, 0x1F, 0x0000); } else if (sc->re_type == MACFG_31) { MP_WritePhyUshort(sc, 0x1F, 0x0001); MP_WritePhyUshort(sc, 0x06, 0x4064); MP_WritePhyUshort(sc, 0x07, 0x2863); MP_WritePhyUshort(sc, 0x08, 0x059C); MP_WritePhyUshort(sc, 0x09, 0x26B4); MP_WritePhyUshort(sc, 0x0A, 0x6A19); MP_WritePhyUshort(sc, 0x0B, 0xDCC8); MP_WritePhyUshort(sc, 0x10, 0xF06D); MP_WritePhyUshort(sc, 0x14, 0x7F68); MP_WritePhyUshort(sc, 0x18, 0x7FD9); MP_WritePhyUshort(sc, 0x1C, 0xF0FF); MP_WritePhyUshort(sc, 0x1D, 0x3D9C); MP_WritePhyUshort(sc, 0x1F, 0x0003); MP_WritePhyUshort(sc, 0x12, 0xF49F); MP_WritePhyUshort(sc, 0x13, 0x070B); MP_WritePhyUshort(sc, 0x1A, 0x05AD); MP_WritePhyUshort(sc, 0x14, 0x94C0); MP_WritePhyUshort(sc, 0x1F, 0x0002); Data = MP_ReadPhyUshort(sc, 0x0B) & 0xFF00; Data |= 0x10; MP_WritePhyUshort(sc, 0x0B, Data); Data = MP_ReadPhyUshort(sc, 0x0C) & 0x00FF; Data |= 0xA200; MP_WritePhyUshort(sc, 0x0C, Data); MP_WritePhyUshort(sc, 0x1F, 0x0002); MP_WritePhyUshort(sc, 0x06, 0x5561); MP_WritePhyUshort(sc, 0x1F, 0x0005); MP_WritePhyUshort(sc, 0x05, 0x8332); MP_WritePhyUshort(sc, 0x06, 0x5561); if (MP_ReadEfuse(sc, 0x01) == 0xb1) { MP_WritePhyUshort(sc, 0x1F, 0x0002); MP_WritePhyUshort(sc, 0x05, 0x669A); MP_WritePhyUshort(sc, 0x1F, 0x0005); MP_WritePhyUshort(sc, 0x05, 0x8330); MP_WritePhyUshort(sc, 0x06, 0x669A); MP_WritePhyUshort(sc, 0x1F, 0x0002); Data = MP_ReadPhyUshort(sc, 0x0D); if ((Data & 0x00FF) != 0x006C) { Data &= 0xFF00; MP_WritePhyUshort(sc, 0x1F, 0x0002); MP_WritePhyUshort(sc, 0x0D, Data | 0x0065); MP_WritePhyUshort(sc, 0x0D, Data | 0x0066); MP_WritePhyUshort(sc, 0x0D, Data | 0x0067); MP_WritePhyUshort(sc, 0x0D, Data | 0x0068); MP_WritePhyUshort(sc, 0x0D, Data | 0x0069); MP_WritePhyUshort(sc, 0x0D, Data | 0x006A); MP_WritePhyUshort(sc, 0x0D, Data | 0x006B); MP_WritePhyUshort(sc, 0x0D, Data | 0x006C); } } else { MP_WritePhyUshort(sc, 0x1F, 0x0002); MP_WritePhyUshort(sc, 0x05, 0x6662); MP_WritePhyUshort(sc, 0x1F, 0x0005); MP_WritePhyUshort(sc, 0x05, 0x8330); MP_WritePhyUshort(sc, 0x06, 0x6662); } MP_WritePhyUshort(sc, 0x1F, 0x0002); Data = MP_ReadPhyUshort(sc, 0x0D); Data |= 0x300; MP_WritePhyUshort(sc, 0x0D, Data); Data = MP_ReadPhyUshort(sc, 0x0F); Data |= 0x10; MP_WritePhyUshort(sc, 0x0F, Data); MP_WritePhyUshort(sc, 0x1F, 0x0002); Data = MP_ReadPhyUshort(sc, 0x02); Data &= ~0x600; Data |= 0x100; MP_WritePhyUshort(sc, 0x02, Data); Data = MP_ReadPhyUshort(sc, 0x03); Data &= ~0xE000; MP_WritePhyUshort(sc, 0x03, Data); MP_WritePhyUshort(sc, 0x1F, 0x0001); MP_WritePhyUshort(sc, 0x17, 0x0CC0); MP_WritePhyUshort(sc, 0x1F, 0x0005); MP_WritePhyUshort(sc, 0x05, 0x001B); if (MP_ReadPhyUshort(sc, 0x06) == 0xBF00) { MP_WritePhyUshort(sc, 0x1f, 0x0005); MP_WritePhyUshort(sc, 0x05, 0xfff6); MP_WritePhyUshort(sc, 0x06, 0x0080); MP_WritePhyUshort(sc, 0x05, 0x8000); MP_WritePhyUshort(sc, 0x06, 0xf8f9); MP_WritePhyUshort(sc, 0x06, 0xfaef); MP_WritePhyUshort(sc, 0x06, 0x59ee); MP_WritePhyUshort(sc, 0x06, 0xf8ea); MP_WritePhyUshort(sc, 0x06, 0x00ee); MP_WritePhyUshort(sc, 0x06, 0xf8eb); MP_WritePhyUshort(sc, 0x06, 0x00e0); MP_WritePhyUshort(sc, 0x06, 0xf87c); MP_WritePhyUshort(sc, 0x06, 0xe1f8); MP_WritePhyUshort(sc, 0x06, 0x7d59); MP_WritePhyUshort(sc, 0x06, 0x0fef); MP_WritePhyUshort(sc, 0x06, 0x0139); MP_WritePhyUshort(sc, 0x06, 0x029e); MP_WritePhyUshort(sc, 0x06, 0x06ef); MP_WritePhyUshort(sc, 0x06, 0x1039); MP_WritePhyUshort(sc, 0x06, 0x089f); MP_WritePhyUshort(sc, 0x06, 0x2aee); MP_WritePhyUshort(sc, 0x06, 0xf8ea); MP_WritePhyUshort(sc, 0x06, 0x00ee); MP_WritePhyUshort(sc, 0x06, 0xf8eb); MP_WritePhyUshort(sc, 0x06, 0x01e0); MP_WritePhyUshort(sc, 0x06, 0xf87c); MP_WritePhyUshort(sc, 0x06, 0xe1f8); MP_WritePhyUshort(sc, 0x06, 0x7d58); MP_WritePhyUshort(sc, 0x06, 0x409e); MP_WritePhyUshort(sc, 0x06, 0x0f39); MP_WritePhyUshort(sc, 0x06, 0x46aa); MP_WritePhyUshort(sc, 0x06, 0x0bbf); MP_WritePhyUshort(sc, 0x06, 0x8290); MP_WritePhyUshort(sc, 0x06, 0xd682); MP_WritePhyUshort(sc, 0x06, 0x9802); MP_WritePhyUshort(sc, 0x06, 0x014f); MP_WritePhyUshort(sc, 0x06, 0xae09); MP_WritePhyUshort(sc, 0x06, 0xbf82); MP_WritePhyUshort(sc, 0x06, 0x98d6); MP_WritePhyUshort(sc, 0x06, 0x82a0); MP_WritePhyUshort(sc, 0x06, 0x0201); MP_WritePhyUshort(sc, 0x06, 0x4fef); MP_WritePhyUshort(sc, 0x06, 0x95fe); MP_WritePhyUshort(sc, 0x06, 0xfdfc); MP_WritePhyUshort(sc, 0x06, 0x05f8); MP_WritePhyUshort(sc, 0x06, 0xf9fa); MP_WritePhyUshort(sc, 0x06, 0xeef8); MP_WritePhyUshort(sc, 0x06, 0xea00); MP_WritePhyUshort(sc, 0x06, 0xeef8); MP_WritePhyUshort(sc, 0x06, 0xeb00); MP_WritePhyUshort(sc, 0x06, 0xe2f8); MP_WritePhyUshort(sc, 0x06, 0x7ce3); MP_WritePhyUshort(sc, 0x06, 0xf87d); MP_WritePhyUshort(sc, 0x06, 0xa511); MP_WritePhyUshort(sc, 0x06, 0x1112); MP_WritePhyUshort(sc, 0x06, 0xd240); MP_WritePhyUshort(sc, 0x06, 0xd644); MP_WritePhyUshort(sc, 0x06, 0x4402); MP_WritePhyUshort(sc, 0x06, 0x8217); MP_WritePhyUshort(sc, 0x06, 0xd2a0); MP_WritePhyUshort(sc, 0x06, 0xd6aa); MP_WritePhyUshort(sc, 0x06, 0xaa02); MP_WritePhyUshort(sc, 0x06, 0x8217); MP_WritePhyUshort(sc, 0x06, 0xae0f); MP_WritePhyUshort(sc, 0x06, 0xa544); MP_WritePhyUshort(sc, 0x06, 0x4402); MP_WritePhyUshort(sc, 0x06, 0xae4d); MP_WritePhyUshort(sc, 0x06, 0xa5aa); MP_WritePhyUshort(sc, 0x06, 0xaa02); MP_WritePhyUshort(sc, 0x06, 0xae47); MP_WritePhyUshort(sc, 0x06, 0xaf82); MP_WritePhyUshort(sc, 0x06, 0x13ee); MP_WritePhyUshort(sc, 0x06, 0x834e); MP_WritePhyUshort(sc, 0x06, 0x00ee); MP_WritePhyUshort(sc, 0x06, 0x834d); MP_WritePhyUshort(sc, 0x06, 0x0fee); MP_WritePhyUshort(sc, 0x06, 0x834c); MP_WritePhyUshort(sc, 0x06, 0x0fee); MP_WritePhyUshort(sc, 0x06, 0x834f); MP_WritePhyUshort(sc, 0x06, 0x00ee); MP_WritePhyUshort(sc, 0x06, 0x8351); MP_WritePhyUshort(sc, 0x06, 0x00ee); MP_WritePhyUshort(sc, 0x06, 0x834a); MP_WritePhyUshort(sc, 0x06, 0xffee); MP_WritePhyUshort(sc, 0x06, 0x834b); MP_WritePhyUshort(sc, 0x06, 0xffe0); MP_WritePhyUshort(sc, 0x06, 0x8330); MP_WritePhyUshort(sc, 0x06, 0xe183); MP_WritePhyUshort(sc, 0x06, 0x3158); MP_WritePhyUshort(sc, 0x06, 0xfee4); MP_WritePhyUshort(sc, 0x06, 0xf88a); MP_WritePhyUshort(sc, 0x06, 0xe5f8); MP_WritePhyUshort(sc, 0x06, 0x8be0); MP_WritePhyUshort(sc, 0x06, 0x8332); MP_WritePhyUshort(sc, 0x06, 0xe183); MP_WritePhyUshort(sc, 0x06, 0x3359); MP_WritePhyUshort(sc, 0x06, 0x0fe2); MP_WritePhyUshort(sc, 0x06, 0x834d); MP_WritePhyUshort(sc, 0x06, 0x0c24); MP_WritePhyUshort(sc, 0x06, 0x5af0); MP_WritePhyUshort(sc, 0x06, 0x1e12); MP_WritePhyUshort(sc, 0x06, 0xe4f8); MP_WritePhyUshort(sc, 0x06, 0x8ce5); MP_WritePhyUshort(sc, 0x06, 0xf88d); MP_WritePhyUshort(sc, 0x06, 0xaf82); MP_WritePhyUshort(sc, 0x06, 0x13e0); MP_WritePhyUshort(sc, 0x06, 0x834f); MP_WritePhyUshort(sc, 0x06, 0x10e4); MP_WritePhyUshort(sc, 0x06, 0x834f); MP_WritePhyUshort(sc, 0x06, 0xe083); MP_WritePhyUshort(sc, 0x06, 0x4e78); MP_WritePhyUshort(sc, 0x06, 0x009f); MP_WritePhyUshort(sc, 0x06, 0x0ae0); MP_WritePhyUshort(sc, 0x06, 0x834f); MP_WritePhyUshort(sc, 0x06, 0xa010); MP_WritePhyUshort(sc, 0x06, 0xa5ee); MP_WritePhyUshort(sc, 0x06, 0x834e); MP_WritePhyUshort(sc, 0x06, 0x01e0); MP_WritePhyUshort(sc, 0x06, 0x834e); MP_WritePhyUshort(sc, 0x06, 0x7805); MP_WritePhyUshort(sc, 0x06, 0x9e9a); MP_WritePhyUshort(sc, 0x06, 0xe083); MP_WritePhyUshort(sc, 0x06, 0x4e78); MP_WritePhyUshort(sc, 0x06, 0x049e); MP_WritePhyUshort(sc, 0x06, 0x10e0); MP_WritePhyUshort(sc, 0x06, 0x834e); MP_WritePhyUshort(sc, 0x06, 0x7803); MP_WritePhyUshort(sc, 0x06, 0x9e0f); MP_WritePhyUshort(sc, 0x06, 0xe083); MP_WritePhyUshort(sc, 0x06, 0x4e78); MP_WritePhyUshort(sc, 0x06, 0x019e); MP_WritePhyUshort(sc, 0x06, 0x05ae); MP_WritePhyUshort(sc, 0x06, 0x0caf); MP_WritePhyUshort(sc, 0x06, 0x81f8); MP_WritePhyUshort(sc, 0x06, 0xaf81); MP_WritePhyUshort(sc, 0x06, 0xa3af); MP_WritePhyUshort(sc, 0x06, 0x81dc); MP_WritePhyUshort(sc, 0x06, 0xaf82); MP_WritePhyUshort(sc, 0x06, 0x13ee); MP_WritePhyUshort(sc, 0x06, 0x8348); MP_WritePhyUshort(sc, 0x06, 0x00ee); MP_WritePhyUshort(sc, 0x06, 0x8349); MP_WritePhyUshort(sc, 0x06, 0x00e0); MP_WritePhyUshort(sc, 0x06, 0x8351); MP_WritePhyUshort(sc, 0x06, 0x10e4); MP_WritePhyUshort(sc, 0x06, 0x8351); MP_WritePhyUshort(sc, 0x06, 0x5801); MP_WritePhyUshort(sc, 0x06, 0x9fea); MP_WritePhyUshort(sc, 0x06, 0xd000); MP_WritePhyUshort(sc, 0x06, 0xd180); MP_WritePhyUshort(sc, 0x06, 0x1f66); MP_WritePhyUshort(sc, 0x06, 0xe2f8); MP_WritePhyUshort(sc, 0x06, 0xeae3); MP_WritePhyUshort(sc, 0x06, 0xf8eb); MP_WritePhyUshort(sc, 0x06, 0x5af8); MP_WritePhyUshort(sc, 0x06, 0x1e20); MP_WritePhyUshort(sc, 0x06, 0xe6f8); MP_WritePhyUshort(sc, 0x06, 0xeae5); MP_WritePhyUshort(sc, 0x06, 0xf8eb); MP_WritePhyUshort(sc, 0x06, 0xd302); MP_WritePhyUshort(sc, 0x06, 0xb3fe); MP_WritePhyUshort(sc, 0x06, 0xe2f8); MP_WritePhyUshort(sc, 0x06, 0x7cef); MP_WritePhyUshort(sc, 0x06, 0x325b); MP_WritePhyUshort(sc, 0x06, 0x80e3); MP_WritePhyUshort(sc, 0x06, 0xf87d); MP_WritePhyUshort(sc, 0x06, 0x9e03); MP_WritePhyUshort(sc, 0x06, 0x7dff); MP_WritePhyUshort(sc, 0x06, 0xff0d); MP_WritePhyUshort(sc, 0x06, 0x581c); MP_WritePhyUshort(sc, 0x06, 0x551a); MP_WritePhyUshort(sc, 0x06, 0x6511); MP_WritePhyUshort(sc, 0x06, 0xa190); MP_WritePhyUshort(sc, 0x06, 0xd3e2); MP_WritePhyUshort(sc, 0x06, 0x8348); MP_WritePhyUshort(sc, 0x06, 0xe383); MP_WritePhyUshort(sc, 0x06, 0x491b); MP_WritePhyUshort(sc, 0x06, 0x56ab); MP_WritePhyUshort(sc, 0x06, 0x08ef); MP_WritePhyUshort(sc, 0x06, 0x56e6); MP_WritePhyUshort(sc, 0x06, 0x8348); MP_WritePhyUshort(sc, 0x06, 0xe783); MP_WritePhyUshort(sc, 0x06, 0x4910); MP_WritePhyUshort(sc, 0x06, 0xd180); MP_WritePhyUshort(sc, 0x06, 0x1f66); MP_WritePhyUshort(sc, 0x06, 0xa004); MP_WritePhyUshort(sc, 0x06, 0xb9e2); MP_WritePhyUshort(sc, 0x06, 0x8348); MP_WritePhyUshort(sc, 0x06, 0xe383); MP_WritePhyUshort(sc, 0x06, 0x49ef); MP_WritePhyUshort(sc, 0x06, 0x65e2); MP_WritePhyUshort(sc, 0x06, 0x834a); MP_WritePhyUshort(sc, 0x06, 0xe383); MP_WritePhyUshort(sc, 0x06, 0x4b1b); MP_WritePhyUshort(sc, 0x06, 0x56aa); MP_WritePhyUshort(sc, 0x06, 0x0eef); MP_WritePhyUshort(sc, 0x06, 0x56e6); MP_WritePhyUshort(sc, 0x06, 0x834a); MP_WritePhyUshort(sc, 0x06, 0xe783); MP_WritePhyUshort(sc, 0x06, 0x4be2); MP_WritePhyUshort(sc, 0x06, 0x834d); MP_WritePhyUshort(sc, 0x06, 0xe683); MP_WritePhyUshort(sc, 0x06, 0x4ce0); MP_WritePhyUshort(sc, 0x06, 0x834d); MP_WritePhyUshort(sc, 0x06, 0xa000); MP_WritePhyUshort(sc, 0x06, 0x0caf); MP_WritePhyUshort(sc, 0x06, 0x81dc); MP_WritePhyUshort(sc, 0x06, 0xe083); MP_WritePhyUshort(sc, 0x06, 0x4d10); MP_WritePhyUshort(sc, 0x06, 0xe483); MP_WritePhyUshort(sc, 0x06, 0x4dae); MP_WritePhyUshort(sc, 0x06, 0x0480); MP_WritePhyUshort(sc, 0x06, 0xe483); MP_WritePhyUshort(sc, 0x06, 0x4de0); MP_WritePhyUshort(sc, 0x06, 0x834e); MP_WritePhyUshort(sc, 0x06, 0x7803); MP_WritePhyUshort(sc, 0x06, 0x9e0b); MP_WritePhyUshort(sc, 0x06, 0xe083); MP_WritePhyUshort(sc, 0x06, 0x4e78); MP_WritePhyUshort(sc, 0x06, 0x049e); MP_WritePhyUshort(sc, 0x06, 0x04ee); MP_WritePhyUshort(sc, 0x06, 0x834e); MP_WritePhyUshort(sc, 0x06, 0x02e0); MP_WritePhyUshort(sc, 0x06, 0x8332); MP_WritePhyUshort(sc, 0x06, 0xe183); MP_WritePhyUshort(sc, 0x06, 0x3359); MP_WritePhyUshort(sc, 0x06, 0x0fe2); MP_WritePhyUshort(sc, 0x06, 0x834d); MP_WritePhyUshort(sc, 0x06, 0x0c24); MP_WritePhyUshort(sc, 0x06, 0x5af0); MP_WritePhyUshort(sc, 0x06, 0x1e12); MP_WritePhyUshort(sc, 0x06, 0xe4f8); MP_WritePhyUshort(sc, 0x06, 0x8ce5); MP_WritePhyUshort(sc, 0x06, 0xf88d); MP_WritePhyUshort(sc, 0x06, 0xe083); MP_WritePhyUshort(sc, 0x06, 0x30e1); MP_WritePhyUshort(sc, 0x06, 0x8331); MP_WritePhyUshort(sc, 0x06, 0x6801); MP_WritePhyUshort(sc, 0x06, 0xe4f8); MP_WritePhyUshort(sc, 0x06, 0x8ae5); MP_WritePhyUshort(sc, 0x06, 0xf88b); MP_WritePhyUshort(sc, 0x06, 0xae37); MP_WritePhyUshort(sc, 0x06, 0xee83); MP_WritePhyUshort(sc, 0x06, 0x4e03); MP_WritePhyUshort(sc, 0x06, 0xe083); MP_WritePhyUshort(sc, 0x06, 0x4ce1); MP_WritePhyUshort(sc, 0x06, 0x834d); MP_WritePhyUshort(sc, 0x06, 0x1b01); MP_WritePhyUshort(sc, 0x06, 0x9e04); MP_WritePhyUshort(sc, 0x06, 0xaaa1); MP_WritePhyUshort(sc, 0x06, 0xaea8); MP_WritePhyUshort(sc, 0x06, 0xee83); MP_WritePhyUshort(sc, 0x06, 0x4e04); MP_WritePhyUshort(sc, 0x06, 0xee83); MP_WritePhyUshort(sc, 0x06, 0x4f00); MP_WritePhyUshort(sc, 0x06, 0xaeab); MP_WritePhyUshort(sc, 0x06, 0xe083); MP_WritePhyUshort(sc, 0x06, 0x4f78); MP_WritePhyUshort(sc, 0x06, 0x039f); MP_WritePhyUshort(sc, 0x06, 0x14ee); MP_WritePhyUshort(sc, 0x06, 0x834e); MP_WritePhyUshort(sc, 0x06, 0x05d2); MP_WritePhyUshort(sc, 0x06, 0x40d6); MP_WritePhyUshort(sc, 0x06, 0x5554); MP_WritePhyUshort(sc, 0x06, 0x0282); MP_WritePhyUshort(sc, 0x06, 0x17d2); MP_WritePhyUshort(sc, 0x06, 0xa0d6); MP_WritePhyUshort(sc, 0x06, 0xba00); MP_WritePhyUshort(sc, 0x06, 0x0282); MP_WritePhyUshort(sc, 0x06, 0x17fe); MP_WritePhyUshort(sc, 0x06, 0xfdfc); MP_WritePhyUshort(sc, 0x06, 0x05f8); MP_WritePhyUshort(sc, 0x06, 0xe0f8); MP_WritePhyUshort(sc, 0x06, 0x60e1); MP_WritePhyUshort(sc, 0x06, 0xf861); MP_WritePhyUshort(sc, 0x06, 0x6802); MP_WritePhyUshort(sc, 0x06, 0xe4f8); MP_WritePhyUshort(sc, 0x06, 0x60e5); MP_WritePhyUshort(sc, 0x06, 0xf861); MP_WritePhyUshort(sc, 0x06, 0xe0f8); MP_WritePhyUshort(sc, 0x06, 0x48e1); MP_WritePhyUshort(sc, 0x06, 0xf849); MP_WritePhyUshort(sc, 0x06, 0x580f); MP_WritePhyUshort(sc, 0x06, 0x1e02); MP_WritePhyUshort(sc, 0x06, 0xe4f8); MP_WritePhyUshort(sc, 0x06, 0x48e5); MP_WritePhyUshort(sc, 0x06, 0xf849); MP_WritePhyUshort(sc, 0x06, 0xd000); MP_WritePhyUshort(sc, 0x06, 0x0282); MP_WritePhyUshort(sc, 0x06, 0x5bbf); MP_WritePhyUshort(sc, 0x06, 0x8350); MP_WritePhyUshort(sc, 0x06, 0xef46); MP_WritePhyUshort(sc, 0x06, 0xdc19); MP_WritePhyUshort(sc, 0x06, 0xddd0); MP_WritePhyUshort(sc, 0x06, 0x0102); MP_WritePhyUshort(sc, 0x06, 0x825b); MP_WritePhyUshort(sc, 0x06, 0x0282); MP_WritePhyUshort(sc, 0x06, 0x77e0); MP_WritePhyUshort(sc, 0x06, 0xf860); MP_WritePhyUshort(sc, 0x06, 0xe1f8); MP_WritePhyUshort(sc, 0x06, 0x6158); MP_WritePhyUshort(sc, 0x06, 0xfde4); MP_WritePhyUshort(sc, 0x06, 0xf860); MP_WritePhyUshort(sc, 0x06, 0xe5f8); MP_WritePhyUshort(sc, 0x06, 0x61fc); MP_WritePhyUshort(sc, 0x06, 0x04f9); MP_WritePhyUshort(sc, 0x06, 0xfafb); MP_WritePhyUshort(sc, 0x06, 0xc6bf); MP_WritePhyUshort(sc, 0x06, 0xf840); MP_WritePhyUshort(sc, 0x06, 0xbe83); MP_WritePhyUshort(sc, 0x06, 0x50a0); MP_WritePhyUshort(sc, 0x06, 0x0101); MP_WritePhyUshort(sc, 0x06, 0x071b); MP_WritePhyUshort(sc, 0x06, 0x89cf); MP_WritePhyUshort(sc, 0x06, 0xd208); MP_WritePhyUshort(sc, 0x06, 0xebdb); MP_WritePhyUshort(sc, 0x06, 0x19b2); MP_WritePhyUshort(sc, 0x06, 0xfbff); MP_WritePhyUshort(sc, 0x06, 0xfefd); MP_WritePhyUshort(sc, 0x06, 0x04f8); MP_WritePhyUshort(sc, 0x06, 0xe0f8); MP_WritePhyUshort(sc, 0x06, 0x48e1); MP_WritePhyUshort(sc, 0x06, 0xf849); MP_WritePhyUshort(sc, 0x06, 0x6808); MP_WritePhyUshort(sc, 0x06, 0xe4f8); MP_WritePhyUshort(sc, 0x06, 0x48e5); MP_WritePhyUshort(sc, 0x06, 0xf849); MP_WritePhyUshort(sc, 0x06, 0x58f7); MP_WritePhyUshort(sc, 0x06, 0xe4f8); MP_WritePhyUshort(sc, 0x06, 0x48e5); MP_WritePhyUshort(sc, 0x06, 0xf849); MP_WritePhyUshort(sc, 0x06, 0xfc04); MP_WritePhyUshort(sc, 0x06, 0x4d20); MP_WritePhyUshort(sc, 0x06, 0x0002); MP_WritePhyUshort(sc, 0x06, 0x4e22); MP_WritePhyUshort(sc, 0x06, 0x0002); MP_WritePhyUshort(sc, 0x06, 0x4ddf); MP_WritePhyUshort(sc, 0x06, 0xff01); MP_WritePhyUshort(sc, 0x06, 0x4edd); MP_WritePhyUshort(sc, 0x06, 0xff01); MP_WritePhyUshort(sc, 0x06, 0xf8fa); MP_WritePhyUshort(sc, 0x06, 0xfbef); MP_WritePhyUshort(sc, 0x06, 0x79bf); MP_WritePhyUshort(sc, 0x06, 0xf822); MP_WritePhyUshort(sc, 0x06, 0xd819); MP_WritePhyUshort(sc, 0x06, 0xd958); MP_WritePhyUshort(sc, 0x06, 0x849f); MP_WritePhyUshort(sc, 0x06, 0x09bf); MP_WritePhyUshort(sc, 0x06, 0x82be); MP_WritePhyUshort(sc, 0x06, 0xd682); MP_WritePhyUshort(sc, 0x06, 0xc602); MP_WritePhyUshort(sc, 0x06, 0x014f); MP_WritePhyUshort(sc, 0x06, 0xef97); MP_WritePhyUshort(sc, 0x06, 0xfffe); MP_WritePhyUshort(sc, 0x06, 0xfc05); MP_WritePhyUshort(sc, 0x06, 0x17ff); MP_WritePhyUshort(sc, 0x06, 0xfe01); MP_WritePhyUshort(sc, 0x06, 0x1700); MP_WritePhyUshort(sc, 0x06, 0x0102); MP_WritePhyUshort(sc, 0x05, 0x83d8); MP_WritePhyUshort(sc, 0x06, 0x8051); MP_WritePhyUshort(sc, 0x05, 0x83d6); MP_WritePhyUshort(sc, 0x06, 0x82a0); MP_WritePhyUshort(sc, 0x05, 0x83d4); MP_WritePhyUshort(sc, 0x06, 0x8000); MP_WritePhyUshort(sc, 0x02, 0x2010); MP_WritePhyUshort(sc, 0x03, 0xdc00); MP_WritePhyUshort(sc, 0x1f, 0x0000); MP_WritePhyUshort(sc, 0x0b, 0x0600); MP_WritePhyUshort(sc, 0x1f, 0x0005); MP_WritePhyUshort(sc, 0x05, 0xfff6); MP_WritePhyUshort(sc, 0x06, 0x00fc); MP_WritePhyUshort(sc, 0x1f, 0x0000); } MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x0D, 0xF880); MP_WritePhyUshort(sc, 0x1F, 0x0000); } else if (sc->re_type == MACFG_32) { MP_WritePhyUshort(sc, 0x1F, 0x0001); MP_WritePhyUshort(sc, 0x06, 0x4064); MP_WritePhyUshort(sc, 0x07, 0x2863); MP_WritePhyUshort(sc, 0x08, 0x059C); MP_WritePhyUshort(sc, 0x09, 0x26B4); MP_WritePhyUshort(sc, 0x0A, 0x6A19); MP_WritePhyUshort(sc, 0x0B, 0xBCC0); MP_WritePhyUshort(sc, 0x10, 0xF06D); MP_WritePhyUshort(sc, 0x14, 0x7F68); MP_WritePhyUshort(sc, 0x18, 0x7FD9); MP_WritePhyUshort(sc, 0x1C, 0xF0FF); MP_WritePhyUshort(sc, 0x1D, 0x3D9C); MP_WritePhyUshort(sc, 0x1F, 0x0003); MP_WritePhyUshort(sc, 0x12, 0xF49F); MP_WritePhyUshort(sc, 0x13, 0x070B); MP_WritePhyUshort(sc, 0x1A, 0x05AD); MP_WritePhyUshort(sc, 0x14, 0x94C0); MP_WritePhyUshort(sc, 0x1F, 0x0002); MP_WritePhyUshort(sc, 0x06, 0x5571); MP_WritePhyUshort(sc, 0x1F, 0x0002); MP_WritePhyUshort(sc, 0x05, 0x2642); MP_WritePhyUshort(sc, 0x1F, 0x0002); MP_WritePhyUshort(sc, 0x02, 0xC107); MP_WritePhyUshort(sc, 0x03, 0x1002); MP_WritePhyUshort(sc, 0x1F, 0x0001); MP_WritePhyUshort(sc, 0x16, 0x0CC0); MP_WritePhyUshort(sc, 0x1F, 0x0002); MP_WritePhyUshort(sc, 0x0F, 0x0017); MP_WritePhyUshort(sc, 0x1F, 0x0005); MP_WritePhyUshort(sc, 0x05, 0x8200); MP_WritePhyUshort(sc, 0x06, 0xF8F9); MP_WritePhyUshort(sc, 0x06, 0xFAEF); MP_WritePhyUshort(sc, 0x06, 0x59EE); MP_WritePhyUshort(sc, 0x06, 0xF8EA); MP_WritePhyUshort(sc, 0x06, 0x00EE); MP_WritePhyUshort(sc, 0x06, 0xF8EB); MP_WritePhyUshort(sc, 0x06, 0x00E0); MP_WritePhyUshort(sc, 0x06, 0xF87C); MP_WritePhyUshort(sc, 0x06, 0xE1F8); MP_WritePhyUshort(sc, 0x06, 0x7D59); MP_WritePhyUshort(sc, 0x06, 0x0FEF); MP_WritePhyUshort(sc, 0x06, 0x0139); MP_WritePhyUshort(sc, 0x06, 0x029E); MP_WritePhyUshort(sc, 0x06, 0x06EF); MP_WritePhyUshort(sc, 0x06, 0x1039); MP_WritePhyUshort(sc, 0x06, 0x089F); MP_WritePhyUshort(sc, 0x06, 0x2AEE); MP_WritePhyUshort(sc, 0x06, 0xF8EA); MP_WritePhyUshort(sc, 0x06, 0x00EE); MP_WritePhyUshort(sc, 0x06, 0xF8EB); MP_WritePhyUshort(sc, 0x06, 0x01E0); MP_WritePhyUshort(sc, 0x06, 0xF87C); MP_WritePhyUshort(sc, 0x06, 0xE1F8); MP_WritePhyUshort(sc, 0x06, 0x7D58); MP_WritePhyUshort(sc, 0x06, 0x409E); MP_WritePhyUshort(sc, 0x06, 0x0F39); MP_WritePhyUshort(sc, 0x06, 0x46AA); MP_WritePhyUshort(sc, 0x06, 0x0BBF); MP_WritePhyUshort(sc, 0x06, 0x8251); MP_WritePhyUshort(sc, 0x06, 0xD682); MP_WritePhyUshort(sc, 0x06, 0x5902); MP_WritePhyUshort(sc, 0x06, 0x014F); MP_WritePhyUshort(sc, 0x06, 0xAE09); MP_WritePhyUshort(sc, 0x06, 0xBF82); MP_WritePhyUshort(sc, 0x06, 0x59D6); MP_WritePhyUshort(sc, 0x06, 0x8261); MP_WritePhyUshort(sc, 0x06, 0x0201); MP_WritePhyUshort(sc, 0x06, 0x4FEF); MP_WritePhyUshort(sc, 0x06, 0x95FE); MP_WritePhyUshort(sc, 0x06, 0xFDFC); MP_WritePhyUshort(sc, 0x06, 0x054D); MP_WritePhyUshort(sc, 0x06, 0x2000); MP_WritePhyUshort(sc, 0x06, 0x024E); MP_WritePhyUshort(sc, 0x06, 0x2200); MP_WritePhyUshort(sc, 0x06, 0x024D); MP_WritePhyUshort(sc, 0x06, 0xDFFF); MP_WritePhyUshort(sc, 0x06, 0x014E); MP_WritePhyUshort(sc, 0x06, 0xDDFF); MP_WritePhyUshort(sc, 0x06, 0x0100); MP_WritePhyUshort(sc, 0x02, 0x6010); MP_WritePhyUshort(sc, 0x05, 0xFFF6); MP_WritePhyUshort(sc, 0x06, 0x00EC); MP_WritePhyUshort(sc, 0x05, 0x83D4); MP_WritePhyUshort(sc, 0x06, 0x8200); } else if (sc->re_type == MACFG_33) { MP_WritePhyUshort(sc, 0x1F, 0x0001); MP_WritePhyUshort(sc, 0x06, 0x4064); MP_WritePhyUshort(sc, 0x07, 0x2863); MP_WritePhyUshort(sc, 0x08, 0x059C); MP_WritePhyUshort(sc, 0x09, 0x26B4); MP_WritePhyUshort(sc, 0x0A, 0x6A19); MP_WritePhyUshort(sc, 0x0B, 0xDCC8); MP_WritePhyUshort(sc, 0x10, 0xF06D); MP_WritePhyUshort(sc, 0x14, 0x7F68); MP_WritePhyUshort(sc, 0x18, 0x7FD9); MP_WritePhyUshort(sc, 0x1C, 0xF0FF); MP_WritePhyUshort(sc, 0x1D, 0x3D9C); MP_WritePhyUshort(sc, 0x1F, 0x0003); MP_WritePhyUshort(sc, 0x12, 0xF49F); MP_WritePhyUshort(sc, 0x13, 0x070B); MP_WritePhyUshort(sc, 0x1A, 0x05AD); MP_WritePhyUshort(sc, 0x14, 0x94C0); MP_WritePhyUshort(sc, 0x1F, 0x0002); MP_WritePhyUshort(sc, 0x06, 0x5561); MP_WritePhyUshort(sc, 0x1F, 0x0005); MP_WritePhyUshort(sc, 0x05, 0x8332); MP_WritePhyUshort(sc, 0x06, 0x5561); if (MP_ReadEfuse(sc, 0x01) == 0xb1) { MP_WritePhyUshort(sc, 0x1F, 0x0002); MP_WritePhyUshort(sc, 0x05, 0x669A); MP_WritePhyUshort(sc, 0x1F, 0x0005); MP_WritePhyUshort(sc, 0x05, 0x8330); MP_WritePhyUshort(sc, 0x06, 0x669A); MP_WritePhyUshort(sc, 0x1F, 0x0002); Data = MP_ReadPhyUshort(sc, 0x0D); if ((Data & 0x00FF) != 0x006C) { Data &= 0xFF00; MP_WritePhyUshort(sc, 0x1F, 0x0002); MP_WritePhyUshort(sc, 0x0D, Data | 0x0065); MP_WritePhyUshort(sc, 0x0D, Data | 0x0066); MP_WritePhyUshort(sc, 0x0D, Data | 0x0067); MP_WritePhyUshort(sc, 0x0D, Data | 0x0068); MP_WritePhyUshort(sc, 0x0D, Data | 0x0069); MP_WritePhyUshort(sc, 0x0D, Data | 0x006A); MP_WritePhyUshort(sc, 0x0D, Data | 0x006B); MP_WritePhyUshort(sc, 0x0D, Data | 0x006C); } } else { MP_WritePhyUshort(sc, 0x1F, 0x0002); MP_WritePhyUshort(sc, 0x05, 0x2642); MP_WritePhyUshort(sc, 0x1F, 0x0005); MP_WritePhyUshort(sc, 0x05, 0x8330); MP_WritePhyUshort(sc, 0x06, 0x2642); } if (MP_ReadEfuse(sc, 0x30) == 0x98) { MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x11, MP_ReadPhyUshort(sc, 0x11) & ~0x02); MP_WritePhyUshort(sc, 0x1F, 0x0005); MP_WritePhyUshort(sc, 0x01, MP_ReadPhyUshort(sc, 0x01) | 0x200); } else if (MP_ReadEfuse(sc, 0x30) == 0x90) { MP_WritePhyUshort(sc, 0x1F, 0x0005); MP_WritePhyUshort(sc, 0x01, MP_ReadPhyUshort(sc, 0x01) & ~0x200); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x16, 0x5101); } MP_WritePhyUshort(sc, 0x1F, 0x0002); Data = MP_ReadPhyUshort(sc, 0x02); Data &= ~0x600; Data |= 0x100; MP_WritePhyUshort(sc, 0x02, Data); Data = MP_ReadPhyUshort(sc, 0x03); Data &= ~0xE000; MP_WritePhyUshort(sc, 0x03, Data); MP_WritePhyUshort(sc, 0x1F, 0x0001); MP_WritePhyUshort(sc, 0x17, 0x0CC0); MP_WritePhyUshort(sc, 0x1F, 0x0002); Data = MP_ReadPhyUshort(sc, 0x0F); Data |= 0x17; MP_WritePhyUshort(sc, 0x0F, Data); MP_WritePhyUshort(sc, 0x1F, 0x0005); MP_WritePhyUshort(sc, 0x05, 0x001B); if (MP_ReadPhyUshort(sc, 0x06) == 0xB300) { MP_WritePhyUshort(sc, 0x1f, 0x0005); MP_WritePhyUshort(sc, 0x05, 0xfff6); MP_WritePhyUshort(sc, 0x06, 0x0080); MP_WritePhyUshort(sc, 0x05, 0x8000); MP_WritePhyUshort(sc, 0x06, 0xf8f9); MP_WritePhyUshort(sc, 0x06, 0xfaee); MP_WritePhyUshort(sc, 0x06, 0xf8ea); MP_WritePhyUshort(sc, 0x06, 0x00ee); MP_WritePhyUshort(sc, 0x06, 0xf8eb); MP_WritePhyUshort(sc, 0x06, 0x00e2); MP_WritePhyUshort(sc, 0x06, 0xf87c); MP_WritePhyUshort(sc, 0x06, 0xe3f8); MP_WritePhyUshort(sc, 0x06, 0x7da5); MP_WritePhyUshort(sc, 0x06, 0x1111); MP_WritePhyUshort(sc, 0x06, 0x12d2); MP_WritePhyUshort(sc, 0x06, 0x40d6); MP_WritePhyUshort(sc, 0x06, 0x4444); MP_WritePhyUshort(sc, 0x06, 0x0281); MP_WritePhyUshort(sc, 0x06, 0xc6d2); MP_WritePhyUshort(sc, 0x06, 0xa0d6); MP_WritePhyUshort(sc, 0x06, 0xaaaa); MP_WritePhyUshort(sc, 0x06, 0x0281); MP_WritePhyUshort(sc, 0x06, 0xc6ae); MP_WritePhyUshort(sc, 0x06, 0x0fa5); MP_WritePhyUshort(sc, 0x06, 0x4444); MP_WritePhyUshort(sc, 0x06, 0x02ae); MP_WritePhyUshort(sc, 0x06, 0x4da5); MP_WritePhyUshort(sc, 0x06, 0xaaaa); MP_WritePhyUshort(sc, 0x06, 0x02ae); MP_WritePhyUshort(sc, 0x06, 0x47af); MP_WritePhyUshort(sc, 0x06, 0x81c2); MP_WritePhyUshort(sc, 0x06, 0xee83); MP_WritePhyUshort(sc, 0x06, 0x4e00); MP_WritePhyUshort(sc, 0x06, 0xee83); MP_WritePhyUshort(sc, 0x06, 0x4d0f); MP_WritePhyUshort(sc, 0x06, 0xee83); MP_WritePhyUshort(sc, 0x06, 0x4c0f); MP_WritePhyUshort(sc, 0x06, 0xee83); MP_WritePhyUshort(sc, 0x06, 0x4f00); MP_WritePhyUshort(sc, 0x06, 0xee83); MP_WritePhyUshort(sc, 0x06, 0x5100); MP_WritePhyUshort(sc, 0x06, 0xee83); MP_WritePhyUshort(sc, 0x06, 0x4aff); MP_WritePhyUshort(sc, 0x06, 0xee83); MP_WritePhyUshort(sc, 0x06, 0x4bff); MP_WritePhyUshort(sc, 0x06, 0xe083); MP_WritePhyUshort(sc, 0x06, 0x30e1); MP_WritePhyUshort(sc, 0x06, 0x8331); MP_WritePhyUshort(sc, 0x06, 0x58fe); MP_WritePhyUshort(sc, 0x06, 0xe4f8); MP_WritePhyUshort(sc, 0x06, 0x8ae5); MP_WritePhyUshort(sc, 0x06, 0xf88b); MP_WritePhyUshort(sc, 0x06, 0xe083); MP_WritePhyUshort(sc, 0x06, 0x32e1); MP_WritePhyUshort(sc, 0x06, 0x8333); MP_WritePhyUshort(sc, 0x06, 0x590f); MP_WritePhyUshort(sc, 0x06, 0xe283); MP_WritePhyUshort(sc, 0x06, 0x4d0c); MP_WritePhyUshort(sc, 0x06, 0x245a); MP_WritePhyUshort(sc, 0x06, 0xf01e); MP_WritePhyUshort(sc, 0x06, 0x12e4); MP_WritePhyUshort(sc, 0x06, 0xf88c); MP_WritePhyUshort(sc, 0x06, 0xe5f8); MP_WritePhyUshort(sc, 0x06, 0x8daf); MP_WritePhyUshort(sc, 0x06, 0x81c2); MP_WritePhyUshort(sc, 0x06, 0xe083); MP_WritePhyUshort(sc, 0x06, 0x4f10); MP_WritePhyUshort(sc, 0x06, 0xe483); MP_WritePhyUshort(sc, 0x06, 0x4fe0); MP_WritePhyUshort(sc, 0x06, 0x834e); MP_WritePhyUshort(sc, 0x06, 0x7800); MP_WritePhyUshort(sc, 0x06, 0x9f0a); MP_WritePhyUshort(sc, 0x06, 0xe083); MP_WritePhyUshort(sc, 0x06, 0x4fa0); MP_WritePhyUshort(sc, 0x06, 0x10a5); MP_WritePhyUshort(sc, 0x06, 0xee83); MP_WritePhyUshort(sc, 0x06, 0x4e01); MP_WritePhyUshort(sc, 0x06, 0xe083); MP_WritePhyUshort(sc, 0x06, 0x4e78); MP_WritePhyUshort(sc, 0x06, 0x059e); MP_WritePhyUshort(sc, 0x06, 0x9ae0); MP_WritePhyUshort(sc, 0x06, 0x834e); MP_WritePhyUshort(sc, 0x06, 0x7804); MP_WritePhyUshort(sc, 0x06, 0x9e10); MP_WritePhyUshort(sc, 0x06, 0xe083); MP_WritePhyUshort(sc, 0x06, 0x4e78); MP_WritePhyUshort(sc, 0x06, 0x039e); MP_WritePhyUshort(sc, 0x06, 0x0fe0); MP_WritePhyUshort(sc, 0x06, 0x834e); MP_WritePhyUshort(sc, 0x06, 0x7801); MP_WritePhyUshort(sc, 0x06, 0x9e05); MP_WritePhyUshort(sc, 0x06, 0xae0c); MP_WritePhyUshort(sc, 0x06, 0xaf81); MP_WritePhyUshort(sc, 0x06, 0xa7af); MP_WritePhyUshort(sc, 0x06, 0x8152); MP_WritePhyUshort(sc, 0x06, 0xaf81); MP_WritePhyUshort(sc, 0x06, 0x8baf); MP_WritePhyUshort(sc, 0x06, 0x81c2); MP_WritePhyUshort(sc, 0x06, 0xee83); MP_WritePhyUshort(sc, 0x06, 0x4800); MP_WritePhyUshort(sc, 0x06, 0xee83); MP_WritePhyUshort(sc, 0x06, 0x4900); MP_WritePhyUshort(sc, 0x06, 0xe083); MP_WritePhyUshort(sc, 0x06, 0x5110); MP_WritePhyUshort(sc, 0x06, 0xe483); MP_WritePhyUshort(sc, 0x06, 0x5158); MP_WritePhyUshort(sc, 0x06, 0x019f); MP_WritePhyUshort(sc, 0x06, 0xead0); MP_WritePhyUshort(sc, 0x06, 0x00d1); MP_WritePhyUshort(sc, 0x06, 0x801f); MP_WritePhyUshort(sc, 0x06, 0x66e2); MP_WritePhyUshort(sc, 0x06, 0xf8ea); MP_WritePhyUshort(sc, 0x06, 0xe3f8); MP_WritePhyUshort(sc, 0x06, 0xeb5a); MP_WritePhyUshort(sc, 0x06, 0xf81e); MP_WritePhyUshort(sc, 0x06, 0x20e6); MP_WritePhyUshort(sc, 0x06, 0xf8ea); MP_WritePhyUshort(sc, 0x06, 0xe5f8); MP_WritePhyUshort(sc, 0x06, 0xebd3); MP_WritePhyUshort(sc, 0x06, 0x02b3); MP_WritePhyUshort(sc, 0x06, 0xfee2); MP_WritePhyUshort(sc, 0x06, 0xf87c); MP_WritePhyUshort(sc, 0x06, 0xef32); MP_WritePhyUshort(sc, 0x06, 0x5b80); MP_WritePhyUshort(sc, 0x06, 0xe3f8); MP_WritePhyUshort(sc, 0x06, 0x7d9e); MP_WritePhyUshort(sc, 0x06, 0x037d); MP_WritePhyUshort(sc, 0x06, 0xffff); MP_WritePhyUshort(sc, 0x06, 0x0d58); MP_WritePhyUshort(sc, 0x06, 0x1c55); MP_WritePhyUshort(sc, 0x06, 0x1a65); MP_WritePhyUshort(sc, 0x06, 0x11a1); MP_WritePhyUshort(sc, 0x06, 0x90d3); MP_WritePhyUshort(sc, 0x06, 0xe283); MP_WritePhyUshort(sc, 0x06, 0x48e3); MP_WritePhyUshort(sc, 0x06, 0x8349); MP_WritePhyUshort(sc, 0x06, 0x1b56); MP_WritePhyUshort(sc, 0x06, 0xab08); MP_WritePhyUshort(sc, 0x06, 0xef56); MP_WritePhyUshort(sc, 0x06, 0xe683); MP_WritePhyUshort(sc, 0x06, 0x48e7); MP_WritePhyUshort(sc, 0x06, 0x8349); MP_WritePhyUshort(sc, 0x06, 0x10d1); MP_WritePhyUshort(sc, 0x06, 0x801f); MP_WritePhyUshort(sc, 0x06, 0x66a0); MP_WritePhyUshort(sc, 0x06, 0x04b9); MP_WritePhyUshort(sc, 0x06, 0xe283); MP_WritePhyUshort(sc, 0x06, 0x48e3); MP_WritePhyUshort(sc, 0x06, 0x8349); MP_WritePhyUshort(sc, 0x06, 0xef65); MP_WritePhyUshort(sc, 0x06, 0xe283); MP_WritePhyUshort(sc, 0x06, 0x4ae3); MP_WritePhyUshort(sc, 0x06, 0x834b); MP_WritePhyUshort(sc, 0x06, 0x1b56); MP_WritePhyUshort(sc, 0x06, 0xaa0e); MP_WritePhyUshort(sc, 0x06, 0xef56); MP_WritePhyUshort(sc, 0x06, 0xe683); MP_WritePhyUshort(sc, 0x06, 0x4ae7); MP_WritePhyUshort(sc, 0x06, 0x834b); MP_WritePhyUshort(sc, 0x06, 0xe283); MP_WritePhyUshort(sc, 0x06, 0x4de6); MP_WritePhyUshort(sc, 0x06, 0x834c); MP_WritePhyUshort(sc, 0x06, 0xe083); MP_WritePhyUshort(sc, 0x06, 0x4da0); MP_WritePhyUshort(sc, 0x06, 0x000c); MP_WritePhyUshort(sc, 0x06, 0xaf81); MP_WritePhyUshort(sc, 0x06, 0x8be0); MP_WritePhyUshort(sc, 0x06, 0x834d); MP_WritePhyUshort(sc, 0x06, 0x10e4); MP_WritePhyUshort(sc, 0x06, 0x834d); MP_WritePhyUshort(sc, 0x06, 0xae04); MP_WritePhyUshort(sc, 0x06, 0x80e4); MP_WritePhyUshort(sc, 0x06, 0x834d); MP_WritePhyUshort(sc, 0x06, 0xe083); MP_WritePhyUshort(sc, 0x06, 0x4e78); MP_WritePhyUshort(sc, 0x06, 0x039e); MP_WritePhyUshort(sc, 0x06, 0x0be0); MP_WritePhyUshort(sc, 0x06, 0x834e); MP_WritePhyUshort(sc, 0x06, 0x7804); MP_WritePhyUshort(sc, 0x06, 0x9e04); MP_WritePhyUshort(sc, 0x06, 0xee83); MP_WritePhyUshort(sc, 0x06, 0x4e02); MP_WritePhyUshort(sc, 0x06, 0xe083); MP_WritePhyUshort(sc, 0x06, 0x32e1); MP_WritePhyUshort(sc, 0x06, 0x8333); MP_WritePhyUshort(sc, 0x06, 0x590f); MP_WritePhyUshort(sc, 0x06, 0xe283); MP_WritePhyUshort(sc, 0x06, 0x4d0c); MP_WritePhyUshort(sc, 0x06, 0x245a); MP_WritePhyUshort(sc, 0x06, 0xf01e); MP_WritePhyUshort(sc, 0x06, 0x12e4); MP_WritePhyUshort(sc, 0x06, 0xf88c); MP_WritePhyUshort(sc, 0x06, 0xe5f8); MP_WritePhyUshort(sc, 0x06, 0x8de0); MP_WritePhyUshort(sc, 0x06, 0x8330); MP_WritePhyUshort(sc, 0x06, 0xe183); MP_WritePhyUshort(sc, 0x06, 0x3168); MP_WritePhyUshort(sc, 0x06, 0x01e4); MP_WritePhyUshort(sc, 0x06, 0xf88a); MP_WritePhyUshort(sc, 0x06, 0xe5f8); MP_WritePhyUshort(sc, 0x06, 0x8bae); MP_WritePhyUshort(sc, 0x06, 0x37ee); MP_WritePhyUshort(sc, 0x06, 0x834e); MP_WritePhyUshort(sc, 0x06, 0x03e0); MP_WritePhyUshort(sc, 0x06, 0x834c); MP_WritePhyUshort(sc, 0x06, 0xe183); MP_WritePhyUshort(sc, 0x06, 0x4d1b); MP_WritePhyUshort(sc, 0x06, 0x019e); MP_WritePhyUshort(sc, 0x06, 0x04aa); MP_WritePhyUshort(sc, 0x06, 0xa1ae); MP_WritePhyUshort(sc, 0x06, 0xa8ee); MP_WritePhyUshort(sc, 0x06, 0x834e); MP_WritePhyUshort(sc, 0x06, 0x04ee); MP_WritePhyUshort(sc, 0x06, 0x834f); MP_WritePhyUshort(sc, 0x06, 0x00ae); MP_WritePhyUshort(sc, 0x06, 0xabe0); MP_WritePhyUshort(sc, 0x06, 0x834f); MP_WritePhyUshort(sc, 0x06, 0x7803); MP_WritePhyUshort(sc, 0x06, 0x9f14); MP_WritePhyUshort(sc, 0x06, 0xee83); MP_WritePhyUshort(sc, 0x06, 0x4e05); MP_WritePhyUshort(sc, 0x06, 0xd240); MP_WritePhyUshort(sc, 0x06, 0xd655); MP_WritePhyUshort(sc, 0x06, 0x5402); MP_WritePhyUshort(sc, 0x06, 0x81c6); MP_WritePhyUshort(sc, 0x06, 0xd2a0); MP_WritePhyUshort(sc, 0x06, 0xd6ba); MP_WritePhyUshort(sc, 0x06, 0x0002); MP_WritePhyUshort(sc, 0x06, 0x81c6); MP_WritePhyUshort(sc, 0x06, 0xfefd); MP_WritePhyUshort(sc, 0x06, 0xfc05); MP_WritePhyUshort(sc, 0x06, 0xf8e0); MP_WritePhyUshort(sc, 0x06, 0xf860); MP_WritePhyUshort(sc, 0x06, 0xe1f8); MP_WritePhyUshort(sc, 0x06, 0x6168); MP_WritePhyUshort(sc, 0x06, 0x02e4); MP_WritePhyUshort(sc, 0x06, 0xf860); MP_WritePhyUshort(sc, 0x06, 0xe5f8); MP_WritePhyUshort(sc, 0x06, 0x61e0); MP_WritePhyUshort(sc, 0x06, 0xf848); MP_WritePhyUshort(sc, 0x06, 0xe1f8); MP_WritePhyUshort(sc, 0x06, 0x4958); MP_WritePhyUshort(sc, 0x06, 0x0f1e); MP_WritePhyUshort(sc, 0x06, 0x02e4); MP_WritePhyUshort(sc, 0x06, 0xf848); MP_WritePhyUshort(sc, 0x06, 0xe5f8); MP_WritePhyUshort(sc, 0x06, 0x49d0); MP_WritePhyUshort(sc, 0x06, 0x0002); MP_WritePhyUshort(sc, 0x06, 0x820a); MP_WritePhyUshort(sc, 0x06, 0xbf83); MP_WritePhyUshort(sc, 0x06, 0x50ef); MP_WritePhyUshort(sc, 0x06, 0x46dc); MP_WritePhyUshort(sc, 0x06, 0x19dd); MP_WritePhyUshort(sc, 0x06, 0xd001); MP_WritePhyUshort(sc, 0x06, 0x0282); MP_WritePhyUshort(sc, 0x06, 0x0a02); MP_WritePhyUshort(sc, 0x06, 0x8226); MP_WritePhyUshort(sc, 0x06, 0xe0f8); MP_WritePhyUshort(sc, 0x06, 0x60e1); MP_WritePhyUshort(sc, 0x06, 0xf861); MP_WritePhyUshort(sc, 0x06, 0x58fd); MP_WritePhyUshort(sc, 0x06, 0xe4f8); MP_WritePhyUshort(sc, 0x06, 0x60e5); MP_WritePhyUshort(sc, 0x06, 0xf861); MP_WritePhyUshort(sc, 0x06, 0xfc04); MP_WritePhyUshort(sc, 0x06, 0xf9fa); MP_WritePhyUshort(sc, 0x06, 0xfbc6); MP_WritePhyUshort(sc, 0x06, 0xbff8); MP_WritePhyUshort(sc, 0x06, 0x40be); MP_WritePhyUshort(sc, 0x06, 0x8350); MP_WritePhyUshort(sc, 0x06, 0xa001); MP_WritePhyUshort(sc, 0x06, 0x0107); MP_WritePhyUshort(sc, 0x06, 0x1b89); MP_WritePhyUshort(sc, 0x06, 0xcfd2); MP_WritePhyUshort(sc, 0x06, 0x08eb); MP_WritePhyUshort(sc, 0x06, 0xdb19); MP_WritePhyUshort(sc, 0x06, 0xb2fb); MP_WritePhyUshort(sc, 0x06, 0xfffe); MP_WritePhyUshort(sc, 0x06, 0xfd04); MP_WritePhyUshort(sc, 0x06, 0xf8e0); MP_WritePhyUshort(sc, 0x06, 0xf848); MP_WritePhyUshort(sc, 0x06, 0xe1f8); MP_WritePhyUshort(sc, 0x06, 0x4968); MP_WritePhyUshort(sc, 0x06, 0x08e4); MP_WritePhyUshort(sc, 0x06, 0xf848); MP_WritePhyUshort(sc, 0x06, 0xe5f8); MP_WritePhyUshort(sc, 0x06, 0x4958); MP_WritePhyUshort(sc, 0x06, 0xf7e4); MP_WritePhyUshort(sc, 0x06, 0xf848); MP_WritePhyUshort(sc, 0x06, 0xe5f8); MP_WritePhyUshort(sc, 0x06, 0x49fc); MP_WritePhyUshort(sc, 0x06, 0x044d); MP_WritePhyUshort(sc, 0x06, 0x2000); MP_WritePhyUshort(sc, 0x06, 0x024e); MP_WritePhyUshort(sc, 0x06, 0x2200); MP_WritePhyUshort(sc, 0x06, 0x024d); MP_WritePhyUshort(sc, 0x06, 0xdfff); MP_WritePhyUshort(sc, 0x06, 0x014e); MP_WritePhyUshort(sc, 0x06, 0xddff); MP_WritePhyUshort(sc, 0x06, 0x01f8); MP_WritePhyUshort(sc, 0x06, 0xfafb); MP_WritePhyUshort(sc, 0x06, 0xef79); MP_WritePhyUshort(sc, 0x06, 0xbff8); MP_WritePhyUshort(sc, 0x06, 0x22d8); MP_WritePhyUshort(sc, 0x06, 0x19d9); MP_WritePhyUshort(sc, 0x06, 0x5884); MP_WritePhyUshort(sc, 0x06, 0x9f09); MP_WritePhyUshort(sc, 0x06, 0xbf82); MP_WritePhyUshort(sc, 0x06, 0x6dd6); MP_WritePhyUshort(sc, 0x06, 0x8275); MP_WritePhyUshort(sc, 0x06, 0x0201); MP_WritePhyUshort(sc, 0x06, 0x4fef); MP_WritePhyUshort(sc, 0x06, 0x97ff); MP_WritePhyUshort(sc, 0x06, 0xfefc); MP_WritePhyUshort(sc, 0x06, 0x0517); MP_WritePhyUshort(sc, 0x06, 0xfffe); MP_WritePhyUshort(sc, 0x06, 0x0117); MP_WritePhyUshort(sc, 0x06, 0x0001); MP_WritePhyUshort(sc, 0x06, 0x0200); MP_WritePhyUshort(sc, 0x05, 0x83d8); MP_WritePhyUshort(sc, 0x06, 0x8000); MP_WritePhyUshort(sc, 0x05, 0x83d6); MP_WritePhyUshort(sc, 0x06, 0x824f); MP_WritePhyUshort(sc, 0x02, 0x2010); MP_WritePhyUshort(sc, 0x03, 0xdc00); MP_WritePhyUshort(sc, 0x1f, 0x0000); MP_WritePhyUshort(sc, 0x0b, 0x0600); MP_WritePhyUshort(sc, 0x1f, 0x0005); MP_WritePhyUshort(sc, 0x05, 0xfff6); MP_WritePhyUshort(sc, 0x06, 0x00fc); MP_WritePhyUshort(sc, 0x1f, 0x0000); } MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x0D, 0xF880); MP_WritePhyUshort(sc, 0x1F, 0x0000); } else if (sc->re_type == MACFG_36 || sc->re_type == MACFG_37) { MP_WritePhyUshort(sc, 0x1F, 0x0007); MP_WritePhyUshort(sc, 0x1E, 0x0023); Data = MP_ReadPhyUshort(sc, 0x17) | 0x0006; if (sc->RequiredSecLanDonglePatch) Data &= ~(BIT_2); else Data |= (BIT_2); MP_WritePhyUshort(sc, 0x17, Data); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1f, 0x0005); MP_WritePhyUshort(sc, 0x05, 0x8b80); MP_WritePhyUshort(sc, 0x06, 0xc896); MP_WritePhyUshort(sc, 0x1f, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0001); MP_WritePhyUshort(sc, 0x0B, 0x6C20); MP_WritePhyUshort(sc, 0x07, 0x2872); MP_WritePhyUshort(sc, 0x1C, 0xEFFF); MP_WritePhyUshort(sc, 0x1F, 0x0003); MP_WritePhyUshort(sc, 0x14, 0x6420); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0002); Data = MP_ReadPhyUshort(sc, 0x08) & 0x00FF; MP_WritePhyUshort(sc, 0x08, Data | 0x8000); MP_WritePhyUshort(sc, 0x1F, 0x0007); MP_WritePhyUshort(sc, 0x1E, 0x002D); Data = MP_ReadPhyUshort(sc, 0x18); MP_WritePhyUshort(sc, 0x18, Data | 0x0050); MP_WritePhyUshort(sc, 0x1F, 0x0000); Data = MP_ReadPhyUshort(sc, 0x14); MP_WritePhyUshort(sc, 0x14, Data | 0x8000); MP_WritePhyUshort(sc, 0x1F, 0x0002); MP_WritePhyUshort(sc, 0x00, 0x080B); MP_WritePhyUshort(sc, 0x0B, 0x09D7); MP_WritePhyUshort(sc, 0x1f, 0x0000); MP_WritePhyUshort(sc, 0x15, 0x1006); MP_WritePhyUshort(sc, 0x1F, 0x0007); MP_WritePhyUshort(sc, 0x1E, 0x002F); MP_WritePhyUshort(sc, 0x15, 0x1919); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0003); MP_WritePhyUshort(sc, 0x19, 0x7F46); MP_WritePhyUshort(sc, 0x1F, 0x0005); MP_WritePhyUshort(sc, 0x05, 0x8AD2); MP_WritePhyUshort(sc, 0x06, 0x6810); MP_WritePhyUshort(sc, 0x05, 0x8AD4); MP_WritePhyUshort(sc, 0x06, 0x8002); MP_WritePhyUshort(sc, 0x05, 0x8ADE); MP_WritePhyUshort(sc, 0x06, 0x8025); MP_WritePhyUshort(sc, 0x1F, 0x0000); } else if (sc->re_type == MACFG_38) { CSR_WRITE_1(sc, 0x6E, CSR_READ_1(sc, 0x6E)| (1<<6)); Data_u32 = re_eri_read(sc, 0x1D0, 4, ERIAR_ExGMAC); Data_u32 &= ~BIT_1; re_eri_write(sc, 0x1D0, 4, Data_u32, ERIAR_ExGMAC); MP_WritePhyUshort(sc, 0x1F, 0x0005); MP_WritePhyUshort(sc, 0x05, 0x8B80); Data = MP_ReadPhyUshort(sc, 0x06); Data |= BIT_2 | BIT_1; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x1f, 0x0000); MP_WritePhyUshort(sc, 0x1f, 0x0004); MP_WritePhyUshort(sc, 0x1f, 0x0007); MP_WritePhyUshort(sc, 0x1e, 0x002D); Data = MP_ReadPhyUshort(sc, 0x18); Data |= BIT_4; MP_WritePhyUshort(sc, 0x18, Data); MP_WritePhyUshort(sc, 0x1f, 0x0002); MP_WritePhyUshort(sc, 0x1f, 0x0000); Data = MP_ReadPhyUshort(sc, 0x14); Data |= BIT_15; MP_WritePhyUshort(sc, 0x14, Data); MP_WritePhyUshort(sc, 0x1F, 0x0005); MP_WritePhyUshort(sc, 0x05, 0x8B86); Data = MP_ReadPhyUshort(sc, 0x06); Data |= BIT_0; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0001); MP_WritePhyUshort(sc, 0x0B, 0x6C14); MP_WritePhyUshort(sc, 0x14, 0x7F3D); MP_WritePhyUshort(sc, 0x1C, 0xFAFE); MP_WritePhyUshort(sc, 0x08, 0x07C5); MP_WritePhyUshort(sc, 0x10, 0xF090); MP_WritePhyUshort(sc, 0x1F, 0x0003); MP_WritePhyUshort(sc, 0x14, 0x641A); MP_WritePhyUshort(sc, 0x1A, 0x0606); MP_WritePhyUshort(sc, 0x12, 0xF480); MP_WritePhyUshort(sc, 0x13, 0x0747); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0004); MP_WritePhyUshort(sc, 0x1F, 0x0007); MP_WritePhyUshort(sc, 0x1E, 0x0078); MP_WritePhyUshort(sc, 0x15, 0xA408); MP_WritePhyUshort(sc, 0x17, 0x5100); MP_WritePhyUshort(sc, 0x19, 0x0008); MP_WritePhyUshort(sc, 0x1F, 0x0002); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0003); MP_WritePhyUshort(sc, 0x0D, 0x0207); MP_WritePhyUshort(sc, 0x02, 0x5FD0); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0004); MP_WritePhyUshort(sc, 0x1F, 0x0007); MP_WritePhyUshort(sc, 0x1E, 0x00A1); Data = MP_ReadPhyUshort(sc, 0x1A); Data &= ~BIT_2; MP_WritePhyUshort(sc, 0x1A, Data); MP_WritePhyUshort(sc, 0x1F, 0x0002); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0004); MP_WritePhyUshort(sc, 0x1F, 0x0007); MP_WritePhyUshort(sc, 0x1E, 0x002D); Data = MP_ReadPhyUshort(sc, 0x16); Data |= BIT_5; MP_WritePhyUshort(sc, 0x16, Data); MP_WritePhyUshort(sc, 0x1F, 0x0002); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0004); MP_WritePhyUshort(sc, 0x1F, 0x0007); MP_WritePhyUshort(sc, 0x1E, 0x00AC); MP_WritePhyUshort(sc, 0x18, 0x0006); MP_WritePhyUshort(sc, 0x1F, 0x0002); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0003); MP_WritePhyUshort(sc, 0x09, 0xA20F); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0005); MP_WritePhyUshort(sc, 0x05, 0x8B85); Data = MP_ReadPhyUshort(sc, 0x06); Data |= BIT_14; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0005); MP_WritePhyUshort(sc, 0x05, 0x8B54); Data = MP_ReadPhyUshort(sc, 0x06); Data &= ~BIT_11; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x05, 0x8B5D); Data = MP_ReadPhyUshort(sc, 0x06); Data &= ~BIT_11; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x05, 0x8A7C); Data = MP_ReadPhyUshort(sc, 0x06); Data &= ~BIT_8; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x05, 0x8A7F); Data = MP_ReadPhyUshort(sc, 0x06); Data |= BIT_8; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x05, 0x8A82); Data = MP_ReadPhyUshort(sc, 0x06); Data &= ~BIT_8; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x05, 0x8A85); Data = MP_ReadPhyUshort(sc, 0x06); Data &= ~BIT_8; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x05, 0x8A88); Data = MP_ReadPhyUshort(sc, 0x06); Data &= ~BIT_8; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0005); MP_WritePhyUshort(sc, 0x05, 0x8B85); Data = MP_ReadPhyUshort(sc, 0x06); Data |= BIT_15; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x1f, 0x0000); MP_WritePhyUshort(sc, 0x1f, 0x0003); Data = MP_ReadPhyUshort(sc, 0x19); Data &= ~BIT_0; MP_WritePhyUshort(sc, 0x19, Data); Data = MP_ReadPhyUshort(sc, 0x10); Data &= ~BIT_10; MP_WritePhyUshort(sc, 0x10, Data); MP_WritePhyUshort(sc, 0x1f, 0x0000); } else if (sc->re_type == MACFG_39) { Data_u32 = re_eri_read(sc, 0x1D0, 4, ERIAR_ExGMAC); Data_u32 &= ~BIT_1; re_eri_write(sc, 0x1D0, 4, Data_u32, ERIAR_ExGMAC); MP_WritePhyUshort(sc, 0x1F, 0x0005); MP_WritePhyUshort(sc, 0x05, 0x8B80); Data = MP_ReadPhyUshort(sc, 0x06); Data |= BIT_2 | BIT_1; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x1f, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0005); MP_WritePhyUshort(sc, 0x05, 0x8B85); Data = MP_ReadPhyUshort(sc, 0x06); Data |= BIT_15; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x1f, 0x0000); MP_WritePhyUshort(sc, 0x1f, 0x0004); MP_WritePhyUshort(sc, 0x1f, 0x0007); MP_WritePhyUshort(sc, 0x1e, 0x002D); Data = MP_ReadPhyUshort(sc, 0x18); Data |= BIT_4; MP_WritePhyUshort(sc, 0x18, Data); MP_WritePhyUshort(sc, 0x1f, 0x0002); MP_WritePhyUshort(sc, 0x1f, 0x0000); Data = MP_ReadPhyUshort(sc, 0x14); Data |= BIT_15; MP_WritePhyUshort(sc, 0x14, Data); MP_WritePhyUshort(sc, 0x1F, 0x0005); MP_WritePhyUshort(sc, 0x05, 0x8B86); Data = MP_ReadPhyUshort(sc, 0x06); Data |= BIT_0; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x1f, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0004); MP_WritePhyUshort(sc, 0x1F, 0x0007); MP_WritePhyUshort(sc, 0x1E, 0x00AC); MP_WritePhyUshort(sc, 0x18, 0x0006); MP_WritePhyUshort(sc, 0x1F, 0x0002); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0003); MP_WritePhyUshort(sc, 0x09, 0xA20F); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0005); MP_WritePhyUshort(sc, 0x05, 0x8B85); Data = MP_ReadPhyUshort(sc, 0x06); Data |= BIT_14; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x1f, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0005); MP_WritePhyUshort(sc, 0x05, 0x8B54); Data = MP_ReadPhyUshort(sc, 0x06); Data &= ~BIT_11; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x05, 0x8B5D); Data = MP_ReadPhyUshort(sc, 0x06); Data &= ~BIT_11; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x05, 0x8A7C); Data = MP_ReadPhyUshort(sc, 0x06); Data &= ~BIT_8; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x05, 0x8A7F); Data = MP_ReadPhyUshort(sc, 0x06); Data |= BIT_8; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x05, 0x8A82); Data = MP_ReadPhyUshort(sc, 0x06); Data &= ~BIT_8; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x05, 0x8A85); Data = MP_ReadPhyUshort(sc, 0x06); Data &= ~BIT_8; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x05, 0x8A88); Data = MP_ReadPhyUshort(sc, 0x06); Data &= ~BIT_8; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1f, 0x0003); Data = MP_ReadPhyUshort(sc, 0x19); Data &= ~BIT_0; MP_WritePhyUshort(sc, 0x19, Data); Data = MP_ReadPhyUshort(sc, 0x10); Data &= ~BIT_10; MP_WritePhyUshort(sc, 0x10, Data); MP_WritePhyUshort(sc, 0x1f, 0x0000); } else if (sc->re_type == MACFG_41) { MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x11, MP_ReadPhyUshort(sc, 0x11) | 0x1000); MP_WritePhyUshort(sc, 0x1F, 0x0002); MP_WritePhyUshort(sc, 0x0F, MP_ReadPhyUshort(sc, 0x0F) | 0x0003); MP_WritePhyUshort(sc, 0x1F, 0x0000); for (Data_u32=0x800E0068; Data_u32<0x800E006D; Data_u32++) { CSR_WRITE_4(sc, 0xF8, Data_u32); for (i=0; i<10; i++) { DELAY(400); if ((CSR_READ_4(sc, 0xF8)&0x80000000)==0) break; } } } else if (sc->re_type == MACFG_42 || sc->re_type == MACFG_43) { Data_u32 = re_eri_read(sc, 0x1D0, 4, ERIAR_ExGMAC); Data_u32 &= 0xFFFF0000; re_eri_write(sc, 0x1D0, 4, Data_u32, ERIAR_ExGMAC); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x18, 0x0310); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1f, 0x0004); MP_WritePhyUshort(sc, 0x1f, 0x0004); MP_WritePhyUshort(sc, 0x19, 0x7070); MP_WritePhyUshort(sc, 0x1c, 0x0600); MP_WritePhyUshort(sc, 0x1d, 0x9700); MP_WritePhyUshort(sc, 0x1d, 0x7d00); MP_WritePhyUshort(sc, 0x1d, 0x6900); MP_WritePhyUshort(sc, 0x1d, 0x7d00); MP_WritePhyUshort(sc, 0x1d, 0x6800); MP_WritePhyUshort(sc, 0x1d, 0x4899); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c00); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c01); MP_WritePhyUshort(sc, 0x1d, 0x8000); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4c00); MP_WritePhyUshort(sc, 0x1d, 0x4007); MP_WritePhyUshort(sc, 0x1d, 0x4400); MP_WritePhyUshort(sc, 0x1d, 0x4800); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c00); MP_WritePhyUshort(sc, 0x1d, 0x5310); MP_WritePhyUshort(sc, 0x1d, 0x6000); MP_WritePhyUshort(sc, 0x1d, 0x6800); MP_WritePhyUshort(sc, 0x1d, 0x6736); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x571f); MP_WritePhyUshort(sc, 0x1d, 0x5ffb); MP_WritePhyUshort(sc, 0x1d, 0xaa03); MP_WritePhyUshort(sc, 0x1d, 0x5b58); MP_WritePhyUshort(sc, 0x1d, 0x301e); MP_WritePhyUshort(sc, 0x1d, 0x5b64); MP_WritePhyUshort(sc, 0x1d, 0xa6fc); MP_WritePhyUshort(sc, 0x1d, 0xdcdb); MP_WritePhyUshort(sc, 0x1d, 0x0014); MP_WritePhyUshort(sc, 0x1d, 0xd9a9); MP_WritePhyUshort(sc, 0x1d, 0x0013); MP_WritePhyUshort(sc, 0x1d, 0xd16b); MP_WritePhyUshort(sc, 0x1d, 0x0011); MP_WritePhyUshort(sc, 0x1d, 0xb40e); MP_WritePhyUshort(sc, 0x1d, 0xd06b); MP_WritePhyUshort(sc, 0x1d, 0x000c); MP_WritePhyUshort(sc, 0x1d, 0xb206); MP_WritePhyUshort(sc, 0x1d, 0x7c01); MP_WritePhyUshort(sc, 0x1d, 0x5800); MP_WritePhyUshort(sc, 0x1d, 0x7c04); MP_WritePhyUshort(sc, 0x1d, 0x5c00); MP_WritePhyUshort(sc, 0x1d, 0x301a); MP_WritePhyUshort(sc, 0x1d, 0x7c01); MP_WritePhyUshort(sc, 0x1d, 0x5801); MP_WritePhyUshort(sc, 0x1d, 0x7c04); MP_WritePhyUshort(sc, 0x1d, 0x5c04); MP_WritePhyUshort(sc, 0x1d, 0x301e); MP_WritePhyUshort(sc, 0x1d, 0x314d); MP_WritePhyUshort(sc, 0x1d, 0x31f0); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4c20); MP_WritePhyUshort(sc, 0x1d, 0x6004); MP_WritePhyUshort(sc, 0x1d, 0x5310); MP_WritePhyUshort(sc, 0x1d, 0x4833); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c00); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c08); MP_WritePhyUshort(sc, 0x1d, 0x8300); MP_WritePhyUshort(sc, 0x1d, 0x6800); MP_WritePhyUshort(sc, 0x1d, 0x6600); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0xb90c); MP_WritePhyUshort(sc, 0x1d, 0x30d3); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4de0); MP_WritePhyUshort(sc, 0x1d, 0x7c04); MP_WritePhyUshort(sc, 0x1d, 0x6000); MP_WritePhyUshort(sc, 0x1d, 0x6800); MP_WritePhyUshort(sc, 0x1d, 0x6736); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x5310); MP_WritePhyUshort(sc, 0x1d, 0x300b); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4c60); MP_WritePhyUshort(sc, 0x1d, 0x6803); MP_WritePhyUshort(sc, 0x1d, 0x6520); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0xaf03); MP_WritePhyUshort(sc, 0x1d, 0x6015); MP_WritePhyUshort(sc, 0x1d, 0x3059); MP_WritePhyUshort(sc, 0x1d, 0x6017); MP_WritePhyUshort(sc, 0x1d, 0x57e0); MP_WritePhyUshort(sc, 0x1d, 0x580c); MP_WritePhyUshort(sc, 0x1d, 0x588c); MP_WritePhyUshort(sc, 0x1d, 0x7ffc); MP_WritePhyUshort(sc, 0x1d, 0x5fa3); MP_WritePhyUshort(sc, 0x1d, 0x4827); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c00); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c10); MP_WritePhyUshort(sc, 0x1d, 0x8400); MP_WritePhyUshort(sc, 0x1d, 0x7c30); MP_WritePhyUshort(sc, 0x1d, 0x6020); MP_WritePhyUshort(sc, 0x1d, 0x48bf); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c00); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c01); MP_WritePhyUshort(sc, 0x1d, 0xad09); MP_WritePhyUshort(sc, 0x1d, 0x7c03); MP_WritePhyUshort(sc, 0x1d, 0x5c03); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x4400); MP_WritePhyUshort(sc, 0x1d, 0xad2c); MP_WritePhyUshort(sc, 0x1d, 0xd6cf); MP_WritePhyUshort(sc, 0x1d, 0x0002); MP_WritePhyUshort(sc, 0x1d, 0x80f4); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4c80); MP_WritePhyUshort(sc, 0x1d, 0x7c20); MP_WritePhyUshort(sc, 0x1d, 0x5c20); MP_WritePhyUshort(sc, 0x1d, 0x481e); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c00); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c02); MP_WritePhyUshort(sc, 0x1d, 0xad0a); MP_WritePhyUshort(sc, 0x1d, 0x7c03); MP_WritePhyUshort(sc, 0x1d, 0x5c03); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x4400); MP_WritePhyUshort(sc, 0x1d, 0x5310); MP_WritePhyUshort(sc, 0x1d, 0x8d02); MP_WritePhyUshort(sc, 0x1d, 0x4401); MP_WritePhyUshort(sc, 0x1d, 0x81f4); MP_WritePhyUshort(sc, 0x1d, 0x3114); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4d00); MP_WritePhyUshort(sc, 0x1d, 0x4832); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c00); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c10); MP_WritePhyUshort(sc, 0x1d, 0x7c08); MP_WritePhyUshort(sc, 0x1d, 0x6000); MP_WritePhyUshort(sc, 0x1d, 0xa4b7); MP_WritePhyUshort(sc, 0x1d, 0xd9b3); MP_WritePhyUshort(sc, 0x1d, 0xfffe); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4d20); MP_WritePhyUshort(sc, 0x1d, 0x7e00); MP_WritePhyUshort(sc, 0x1d, 0x6200); MP_WritePhyUshort(sc, 0x1d, 0x3045); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4d40); MP_WritePhyUshort(sc, 0x1d, 0x7c40); MP_WritePhyUshort(sc, 0x1d, 0x6000); MP_WritePhyUshort(sc, 0x1d, 0x4401); MP_WritePhyUshort(sc, 0x1d, 0x5210); MP_WritePhyUshort(sc, 0x1d, 0x4833); MP_WritePhyUshort(sc, 0x1d, 0x7c08); MP_WritePhyUshort(sc, 0x1d, 0x4c00); MP_WritePhyUshort(sc, 0x1d, 0x7c08); MP_WritePhyUshort(sc, 0x1d, 0x4c08); MP_WritePhyUshort(sc, 0x1d, 0x8300); MP_WritePhyUshort(sc, 0x1d, 0x5f80); MP_WritePhyUshort(sc, 0x1d, 0x55e0); MP_WritePhyUshort(sc, 0x1d, 0xc06f); MP_WritePhyUshort(sc, 0x1d, 0x0005); MP_WritePhyUshort(sc, 0x1d, 0xd9b3); MP_WritePhyUshort(sc, 0x1d, 0xfffd); MP_WritePhyUshort(sc, 0x1d, 0x7c40); MP_WritePhyUshort(sc, 0x1d, 0x6040); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4d60); MP_WritePhyUshort(sc, 0x1d, 0x57e0); MP_WritePhyUshort(sc, 0x1d, 0x4814); MP_WritePhyUshort(sc, 0x1d, 0x7c04); MP_WritePhyUshort(sc, 0x1d, 0x4c00); MP_WritePhyUshort(sc, 0x1d, 0x7c04); MP_WritePhyUshort(sc, 0x1d, 0x4c04); MP_WritePhyUshort(sc, 0x1d, 0x8200); MP_WritePhyUshort(sc, 0x1d, 0x7c03); MP_WritePhyUshort(sc, 0x1d, 0x5c03); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0xad02); MP_WritePhyUshort(sc, 0x1d, 0x4400); MP_WritePhyUshort(sc, 0x1d, 0xc0e9); MP_WritePhyUshort(sc, 0x1d, 0x0003); MP_WritePhyUshort(sc, 0x1d, 0xadd8); MP_WritePhyUshort(sc, 0x1d, 0x30c6); MP_WritePhyUshort(sc, 0x1d, 0x3078); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4dc0); MP_WritePhyUshort(sc, 0x1d, 0x6730); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0xd09d); MP_WritePhyUshort(sc, 0x1d, 0x0002); MP_WritePhyUshort(sc, 0x1d, 0xb4fe); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4d80); MP_WritePhyUshort(sc, 0x1d, 0x6802); MP_WritePhyUshort(sc, 0x1d, 0x6600); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x7c08); MP_WritePhyUshort(sc, 0x1d, 0x6000); MP_WritePhyUshort(sc, 0x1d, 0x486c); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c00); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c01); MP_WritePhyUshort(sc, 0x1d, 0x9503); MP_WritePhyUshort(sc, 0x1d, 0x7e00); MP_WritePhyUshort(sc, 0x1d, 0x6200); MP_WritePhyUshort(sc, 0x1d, 0x571f); MP_WritePhyUshort(sc, 0x1d, 0x5fbb); MP_WritePhyUshort(sc, 0x1d, 0xaa03); MP_WritePhyUshort(sc, 0x1d, 0x5b58); MP_WritePhyUshort(sc, 0x1d, 0x30e9); MP_WritePhyUshort(sc, 0x1d, 0x5b64); MP_WritePhyUshort(sc, 0x1d, 0xcdab); MP_WritePhyUshort(sc, 0x1d, 0xff5b); MP_WritePhyUshort(sc, 0x1d, 0xcd8d); MP_WritePhyUshort(sc, 0x1d, 0xff59); MP_WritePhyUshort(sc, 0x1d, 0xd96b); MP_WritePhyUshort(sc, 0x1d, 0xff57); MP_WritePhyUshort(sc, 0x1d, 0xd0a0); MP_WritePhyUshort(sc, 0x1d, 0xffdb); MP_WritePhyUshort(sc, 0x1d, 0xcba0); MP_WritePhyUshort(sc, 0x1d, 0x0003); MP_WritePhyUshort(sc, 0x1d, 0x80f0); MP_WritePhyUshort(sc, 0x1d, 0x30f6); MP_WritePhyUshort(sc, 0x1d, 0x3109); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4ce0); MP_WritePhyUshort(sc, 0x1d, 0x7d30); MP_WritePhyUshort(sc, 0x1d, 0x6530); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x7ce0); MP_WritePhyUshort(sc, 0x1d, 0x5400); MP_WritePhyUshort(sc, 0x1d, 0x4832); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c00); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c08); MP_WritePhyUshort(sc, 0x1d, 0x7c08); MP_WritePhyUshort(sc, 0x1d, 0x6008); MP_WritePhyUshort(sc, 0x1d, 0x8300); MP_WritePhyUshort(sc, 0x1d, 0xb902); MP_WritePhyUshort(sc, 0x1d, 0x30d3); MP_WritePhyUshort(sc, 0x1d, 0x308f); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4da0); MP_WritePhyUshort(sc, 0x1d, 0x57a0); MP_WritePhyUshort(sc, 0x1d, 0x590c); MP_WritePhyUshort(sc, 0x1d, 0x5fa2); MP_WritePhyUshort(sc, 0x1d, 0xcba4); MP_WritePhyUshort(sc, 0x1d, 0x0005); MP_WritePhyUshort(sc, 0x1d, 0xcd8d); MP_WritePhyUshort(sc, 0x1d, 0x0003); MP_WritePhyUshort(sc, 0x1d, 0x80fc); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4ca0); MP_WritePhyUshort(sc, 0x1d, 0xb603); MP_WritePhyUshort(sc, 0x1d, 0x7c10); MP_WritePhyUshort(sc, 0x1d, 0x6010); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x541f); MP_WritePhyUshort(sc, 0x1d, 0x7ffc); MP_WritePhyUshort(sc, 0x1d, 0x5fb3); MP_WritePhyUshort(sc, 0x1d, 0x9403); MP_WritePhyUshort(sc, 0x1d, 0x7c03); MP_WritePhyUshort(sc, 0x1d, 0x5c03); MP_WritePhyUshort(sc, 0x1d, 0xaa05); MP_WritePhyUshort(sc, 0x1d, 0x7c80); MP_WritePhyUshort(sc, 0x1d, 0x5800); MP_WritePhyUshort(sc, 0x1d, 0x5b58); MP_WritePhyUshort(sc, 0x1d, 0x3128); MP_WritePhyUshort(sc, 0x1d, 0x7c80); MP_WritePhyUshort(sc, 0x1d, 0x5800); MP_WritePhyUshort(sc, 0x1d, 0x5b64); MP_WritePhyUshort(sc, 0x1d, 0x4827); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c00); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c10); MP_WritePhyUshort(sc, 0x1d, 0x8400); MP_WritePhyUshort(sc, 0x1d, 0x7c10); MP_WritePhyUshort(sc, 0x1d, 0x6000); MP_WritePhyUshort(sc, 0x1d, 0x4824); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c00); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c04); MP_WritePhyUshort(sc, 0x1d, 0x8200); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4cc0); MP_WritePhyUshort(sc, 0x1d, 0x7d00); MP_WritePhyUshort(sc, 0x1d, 0x6400); MP_WritePhyUshort(sc, 0x1d, 0x7ffc); MP_WritePhyUshort(sc, 0x1d, 0x5fbb); MP_WritePhyUshort(sc, 0x1d, 0x4824); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c00); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c04); MP_WritePhyUshort(sc, 0x1d, 0x8200); MP_WritePhyUshort(sc, 0x1d, 0x7e00); MP_WritePhyUshort(sc, 0x1d, 0x6a00); MP_WritePhyUshort(sc, 0x1d, 0x4824); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c00); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c04); MP_WritePhyUshort(sc, 0x1d, 0x8200); MP_WritePhyUshort(sc, 0x1d, 0x7e00); MP_WritePhyUshort(sc, 0x1d, 0x6800); MP_WritePhyUshort(sc, 0x1d, 0x30f6); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4e00); MP_WritePhyUshort(sc, 0x1d, 0x4007); MP_WritePhyUshort(sc, 0x1d, 0x4400); MP_WritePhyUshort(sc, 0x1d, 0x5310); MP_WritePhyUshort(sc, 0x1d, 0x6800); MP_WritePhyUshort(sc, 0x1d, 0x6736); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x570f); MP_WritePhyUshort(sc, 0x1d, 0x5fff); MP_WritePhyUshort(sc, 0x1d, 0xaa03); MP_WritePhyUshort(sc, 0x1d, 0x585b); MP_WritePhyUshort(sc, 0x1d, 0x315c); MP_WritePhyUshort(sc, 0x1d, 0x5867); MP_WritePhyUshort(sc, 0x1d, 0x9402); MP_WritePhyUshort(sc, 0x1d, 0x6200); MP_WritePhyUshort(sc, 0x1d, 0xcda3); MP_WritePhyUshort(sc, 0x1d, 0x009d); MP_WritePhyUshort(sc, 0x1d, 0xcd85); MP_WritePhyUshort(sc, 0x1d, 0x009b); MP_WritePhyUshort(sc, 0x1d, 0xd96b); MP_WritePhyUshort(sc, 0x1d, 0x0099); MP_WritePhyUshort(sc, 0x1d, 0x96e9); MP_WritePhyUshort(sc, 0x1d, 0x6800); MP_WritePhyUshort(sc, 0x1d, 0x6736); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4e20); MP_WritePhyUshort(sc, 0x1d, 0x96e4); MP_WritePhyUshort(sc, 0x1d, 0x8b04); MP_WritePhyUshort(sc, 0x1d, 0x7c08); MP_WritePhyUshort(sc, 0x1d, 0x5008); MP_WritePhyUshort(sc, 0x1d, 0xab03); MP_WritePhyUshort(sc, 0x1d, 0x7c08); MP_WritePhyUshort(sc, 0x1d, 0x5000); MP_WritePhyUshort(sc, 0x1d, 0x6801); MP_WritePhyUshort(sc, 0x1d, 0x6776); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0xdb7c); MP_WritePhyUshort(sc, 0x1d, 0xfff0); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x7fe1); MP_WritePhyUshort(sc, 0x1d, 0x4e40); MP_WritePhyUshort(sc, 0x1d, 0x4837); MP_WritePhyUshort(sc, 0x1d, 0x4418); MP_WritePhyUshort(sc, 0x1d, 0x41c7); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4e40); MP_WritePhyUshort(sc, 0x1d, 0x7c40); MP_WritePhyUshort(sc, 0x1d, 0x5400); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c01); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c01); MP_WritePhyUshort(sc, 0x1d, 0x8fc9); MP_WritePhyUshort(sc, 0x1d, 0xd2a0); MP_WritePhyUshort(sc, 0x1d, 0x004a); MP_WritePhyUshort(sc, 0x1d, 0x9203); MP_WritePhyUshort(sc, 0x1d, 0xa041); MP_WritePhyUshort(sc, 0x1d, 0x3184); MP_WritePhyUshort(sc, 0x1d, 0x7fe1); MP_WritePhyUshort(sc, 0x1d, 0x4e60); MP_WritePhyUshort(sc, 0x1d, 0x489c); MP_WritePhyUshort(sc, 0x1d, 0x4628); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4e60); MP_WritePhyUshort(sc, 0x1d, 0x7e28); MP_WritePhyUshort(sc, 0x1d, 0x4628); MP_WritePhyUshort(sc, 0x1d, 0x7c40); MP_WritePhyUshort(sc, 0x1d, 0x5400); MP_WritePhyUshort(sc, 0x1d, 0x7c01); MP_WritePhyUshort(sc, 0x1d, 0x5800); MP_WritePhyUshort(sc, 0x1d, 0x7c04); MP_WritePhyUshort(sc, 0x1d, 0x5c00); MP_WritePhyUshort(sc, 0x1d, 0x41e8); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c01); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c01); MP_WritePhyUshort(sc, 0x1d, 0x8fb0); MP_WritePhyUshort(sc, 0x1d, 0xb241); MP_WritePhyUshort(sc, 0x1d, 0xa02a); MP_WritePhyUshort(sc, 0x1d, 0x319d); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4ea0); MP_WritePhyUshort(sc, 0x1d, 0x7c02); MP_WritePhyUshort(sc, 0x1d, 0x4402); MP_WritePhyUshort(sc, 0x1d, 0x4448); MP_WritePhyUshort(sc, 0x1d, 0x4894); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c01); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c03); MP_WritePhyUshort(sc, 0x1d, 0x4824); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c07); MP_WritePhyUshort(sc, 0x1d, 0x41ef); MP_WritePhyUshort(sc, 0x1d, 0x41ff); MP_WritePhyUshort(sc, 0x1d, 0x4891); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c07); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c17); MP_WritePhyUshort(sc, 0x1d, 0x8400); MP_WritePhyUshort(sc, 0x1d, 0x8ef8); MP_WritePhyUshort(sc, 0x1d, 0x41c7); MP_WritePhyUshort(sc, 0x1d, 0x8f95); MP_WritePhyUshort(sc, 0x1d, 0x92d5); MP_WritePhyUshort(sc, 0x1d, 0xa10f); MP_WritePhyUshort(sc, 0x1d, 0xd480); MP_WritePhyUshort(sc, 0x1d, 0x0008); MP_WritePhyUshort(sc, 0x1d, 0xd580); MP_WritePhyUshort(sc, 0x1d, 0xffb9); MP_WritePhyUshort(sc, 0x1d, 0xa202); MP_WritePhyUshort(sc, 0x1d, 0x31b8); MP_WritePhyUshort(sc, 0x1d, 0x7c04); MP_WritePhyUshort(sc, 0x1d, 0x4404); MP_WritePhyUshort(sc, 0x1d, 0x31b8); MP_WritePhyUshort(sc, 0x1d, 0xd484); MP_WritePhyUshort(sc, 0x1d, 0xfff3); MP_WritePhyUshort(sc, 0x1d, 0xd484); MP_WritePhyUshort(sc, 0x1d, 0xfff1); MP_WritePhyUshort(sc, 0x1d, 0x314d); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4ee0); MP_WritePhyUshort(sc, 0x1d, 0x7c40); MP_WritePhyUshort(sc, 0x1d, 0x5400); MP_WritePhyUshort(sc, 0x1d, 0x4488); MP_WritePhyUshort(sc, 0x1d, 0x41cf); MP_WritePhyUshort(sc, 0x1d, 0x314d); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4ec0); MP_WritePhyUshort(sc, 0x1d, 0x48f3); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c01); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c09); MP_WritePhyUshort(sc, 0x1d, 0x4508); MP_WritePhyUshort(sc, 0x1d, 0x41c7); MP_WritePhyUshort(sc, 0x1d, 0x8f24); MP_WritePhyUshort(sc, 0x1d, 0xd218); MP_WritePhyUshort(sc, 0x1d, 0x0022); MP_WritePhyUshort(sc, 0x1d, 0xd2a4); MP_WritePhyUshort(sc, 0x1d, 0xff9f); MP_WritePhyUshort(sc, 0x1d, 0x31d9); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4e80); MP_WritePhyUshort(sc, 0x1d, 0x4832); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c01); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c11); MP_WritePhyUshort(sc, 0x1d, 0x4428); MP_WritePhyUshort(sc, 0x1d, 0x7c40); MP_WritePhyUshort(sc, 0x1d, 0x5440); MP_WritePhyUshort(sc, 0x1d, 0x7c01); MP_WritePhyUshort(sc, 0x1d, 0x5801); MP_WritePhyUshort(sc, 0x1d, 0x7c04); MP_WritePhyUshort(sc, 0x1d, 0x5c04); MP_WritePhyUshort(sc, 0x1d, 0x41e8); MP_WritePhyUshort(sc, 0x1d, 0xa4b3); MP_WritePhyUshort(sc, 0x1d, 0x31ee); MP_WritePhyUshort(sc, 0x1d, 0x6800); MP_WritePhyUshort(sc, 0x1d, 0x6736); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x570f); MP_WritePhyUshort(sc, 0x1d, 0x5fff); MP_WritePhyUshort(sc, 0x1d, 0xaa03); MP_WritePhyUshort(sc, 0x1d, 0x585b); MP_WritePhyUshort(sc, 0x1d, 0x31fa); MP_WritePhyUshort(sc, 0x1d, 0x5867); MP_WritePhyUshort(sc, 0x1d, 0xbcf6); MP_WritePhyUshort(sc, 0x1d, 0x300b); MP_WritePhyUshort(sc, 0x1d, 0x300b); MP_WritePhyUshort(sc, 0x1d, 0x314d); MP_WritePhyUshort(sc, 0x1f, 0x0004); MP_WritePhyUshort(sc, 0x1c, 0x0200); MP_WritePhyUshort(sc, 0x19, 0x7030); MP_WritePhyUshort(sc, 0x1f, 0x0000); if (CSR_READ_1(sc, 0xEF)&0x08) { MP_WritePhyUshort(sc, 0x1F, 0x0005); MP_WritePhyUshort(sc, 0x1A, 0x0004); MP_WritePhyUshort(sc, 0x1F, 0x0000); } else { MP_WritePhyUshort(sc, 0x1F, 0x0005); MP_WritePhyUshort(sc, 0x1A, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0000); } if (CSR_READ_1(sc, 0xEF)&0x10) { MP_WritePhyUshort(sc, 0x1F, 0x0004); MP_WritePhyUshort(sc, 0x1C, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0000); } else { MP_WritePhyUshort(sc, 0x1F, 0x0004); MP_WritePhyUshort(sc, 0x1C, 0x0200); MP_WritePhyUshort(sc, 0x1F, 0x0000); } MP_WritePhyUshort(sc, 0x1F, 0x0001); MP_WritePhyUshort(sc, 0x15, 0x7701); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0000); ClearEthPhyBit(sc, 0x1A, BIT_14); if (phy_power_saving == 1) { MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x18, 0x8310); MP_WritePhyUshort(sc, 0x1F, 0x0000); } else { MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x18, 0x0310); MP_WritePhyUshort(sc, 0x1F, 0x0000); DELAY(20000); } MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x0D, 0x0007); MP_WritePhyUshort(sc, 0x0E, 0x003C); MP_WritePhyUshort(sc, 0x0D, 0x4007); MP_WritePhyUshort(sc, 0x0E, 0x0000); MP_WritePhyUshort(sc, 0x0D, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x0D, 0x0003); MP_WritePhyUshort(sc, 0x0E, 0x0015); MP_WritePhyUshort(sc, 0x0D, 0x4003); MP_WritePhyUshort(sc, 0x0E, 0x0000); MP_WritePhyUshort(sc, 0x0D, 0x0000); } else if (sc->re_type == MACFG_50) { MP_WritePhyUshort(sc, 0x1F, 0x0005); MP_WritePhyUshort(sc, 0x05, 0x8B80); Data = MP_ReadPhyUshort(sc, 0x06); Data |= BIT_2 | BIT_1; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x1f, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0007); MP_WritePhyUshort(sc, 0x1E, 0x002D); Data = MP_ReadPhyUshort(sc, 0x18); Data |= BIT_4; MP_WritePhyUshort(sc, 0x18, Data); MP_WritePhyUshort(sc, 0x1f, 0x0000); Data = MP_ReadPhyUshort(sc, 0x14); Data |= BIT_15; MP_WritePhyUshort(sc, 0x14, Data); MP_WritePhyUshort(sc, 0x1F, 0x0005); MP_WritePhyUshort(sc, 0x05, 0x8B86); Data = MP_ReadPhyUshort(sc, 0x06); Data |= BIT_0; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x1f, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0005); MP_WritePhyUshort(sc, 0x05, 0x8B85); Data = MP_ReadPhyUshort(sc, 0x06); Data |= BIT_14; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x1f, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0003); MP_WritePhyUshort(sc, 0x09, 0xA20F); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0005); MP_WritePhyUshort(sc, 0x05, 0x8B55); MP_WritePhyUshort(sc, 0x06, 0x0000); MP_WritePhyUshort(sc, 0x05, 0x8B5E); MP_WritePhyUshort(sc, 0x06, 0x0000); MP_WritePhyUshort(sc, 0x05, 0x8B67); MP_WritePhyUshort(sc, 0x06, 0x0000); MP_WritePhyUshort(sc, 0x05, 0x8B70); MP_WritePhyUshort(sc, 0x06, 0x0000); MP_WritePhyUshort(sc, 0x1f, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0007); MP_WritePhyUshort(sc, 0x1E, 0x0078); MP_WritePhyUshort(sc, 0x17, 0x0000); MP_WritePhyUshort(sc, 0x19, 0x00FB); MP_WritePhyUshort(sc, 0x1f, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0005); MP_WritePhyUshort(sc, 0x05, 0x8B79); MP_WritePhyUshort(sc, 0x06, 0xAA00); MP_WritePhyUshort(sc, 0x1f, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0003); MP_WritePhyUshort(sc, 0x01, 0x328A); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0005); MP_WritePhyUshort(sc, 0x05, 0x8B54); Data = MP_ReadPhyUshort(sc, 0x06); Data &= ~BIT_11; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x05, 0x8B5D); Data = MP_ReadPhyUshort(sc, 0x06); Data &= ~BIT_11; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x05, 0x8A7C); Data = MP_ReadPhyUshort(sc, 0x06); Data &= ~BIT_8; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x05, 0x8A7F); Data = MP_ReadPhyUshort(sc, 0x06); Data |= BIT_8; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x05, 0x8A82); Data = MP_ReadPhyUshort(sc, 0x06); Data &= ~BIT_8; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x05, 0x8A85); Data = MP_ReadPhyUshort(sc, 0x06); Data &= ~BIT_8; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x05, 0x8A88); Data = MP_ReadPhyUshort(sc, 0x06); Data &= ~BIT_8; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0005); MP_WritePhyUshort(sc, 0x05, 0x8B85); Data = MP_ReadPhyUshort(sc, 0x06); Data |= BIT_15; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x1f, 0x0000); MP_WritePhyUshort(sc, 0x1f, 0x0003); Data = MP_ReadPhyUshort(sc, 0x19); Data &= ~BIT_0; MP_WritePhyUshort(sc, 0x19, Data); Data = MP_ReadPhyUshort(sc, 0x10); Data &= ~BIT_10; MP_WritePhyUshort(sc, 0x10, Data); MP_WritePhyUshort(sc, 0x1f, 0x0000); } else if (sc->re_type == MACFG_51) { MP_WritePhyUshort(sc, 0x1F, 0x0005); MP_WritePhyUshort(sc, 0x05, 0x8B80); Data = MP_ReadPhyUshort(sc, 0x06); Data |= BIT_2 | BIT_1; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x1f, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0007); MP_WritePhyUshort(sc, 0x1E, 0x002D); Data = MP_ReadPhyUshort(sc, 0x18); Data |= BIT_4; MP_WritePhyUshort(sc, 0x18, Data); MP_WritePhyUshort(sc, 0x1f, 0x0000); Data = MP_ReadPhyUshort(sc, 0x14); Data |= BIT_15; MP_WritePhyUshort(sc, 0x14, Data); MP_WritePhyUshort(sc, 0x1F, 0x0005); MP_WritePhyUshort(sc, 0x05, 0x8B86); Data = MP_ReadPhyUshort(sc, 0x06); Data |= BIT_0; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x1f, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0005); MP_WritePhyUshort(sc, 0x05, 0x8B54); Data = MP_ReadPhyUshort(sc, 0x06); Data &= ~BIT_11; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x05, 0x8B5D); Data = MP_ReadPhyUshort(sc, 0x06); Data &= ~BIT_11; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x05, 0x8A7C); Data = MP_ReadPhyUshort(sc, 0x06); Data &= ~BIT_8; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x05, 0x8A7F); Data = MP_ReadPhyUshort(sc, 0x06); Data |= BIT_8; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x05, 0x8A82); Data = MP_ReadPhyUshort(sc, 0x06); Data &= ~BIT_8; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x05, 0x8A85); Data = MP_ReadPhyUshort(sc, 0x06); Data &= ~BIT_8; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x05, 0x8A88); Data = MP_ReadPhyUshort(sc, 0x06); Data &= ~BIT_8; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0005); MP_WritePhyUshort(sc, 0x05, 0x8B85); Data = MP_ReadPhyUshort(sc, 0x06); Data |= BIT_15; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x1f, 0x0000); MP_WritePhyUshort(sc, 0x1f, 0x0003); Data = MP_ReadPhyUshort(sc, 0x19); Data &= ~BIT_0; MP_WritePhyUshort(sc, 0x19, Data); Data = MP_ReadPhyUshort(sc, 0x10); Data &= ~BIT_10; MP_WritePhyUshort(sc, 0x10, Data); MP_WritePhyUshort(sc, 0x1f, 0x0000); } else if (sc->re_type == MACFG_52) { Data_u32 = re_eri_read(sc, 0x1D0, 4, ERIAR_ExGMAC); Data_u32 &= ~BIT_1; re_eri_write(sc, 0x1D0, 4, Data_u32, ERIAR_ExGMAC); MP_WritePhyUshort(sc, 0x1F, 0x0005); MP_WritePhyUshort(sc, 0x05, 0x8B80); Data = MP_ReadPhyUshort(sc, 0x06); Data |= BIT_2 | BIT_1; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x1f, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0007); MP_WritePhyUshort(sc, 0x1E, 0x002D); Data = MP_ReadPhyUshort(sc, 0x18); Data |= BIT_4; MP_WritePhyUshort(sc, 0x18, Data); MP_WritePhyUshort(sc, 0x1f, 0x0002); MP_WritePhyUshort(sc, 0x1f, 0x0000); Data = MP_ReadPhyUshort(sc, 0x14); Data |= BIT_15; MP_WritePhyUshort(sc, 0x14, Data); MP_WritePhyUshort(sc, 0x1F, 0x0005); MP_WritePhyUshort(sc, 0x05, 0x8B86); Data = MP_ReadPhyUshort(sc, 0x06); Data |= BIT_0; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x1f, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0005); MP_WritePhyUshort(sc, 0x05, 0x8B85); Data = MP_ReadPhyUshort(sc, 0x06); Data |= BIT_14; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x1f, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0003); MP_WritePhyUshort(sc, 0x09, 0xA20F); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0005); MP_WritePhyUshort(sc, 0x05, 0x8B55); MP_WritePhyUshort(sc, 0x06, 0x0000); MP_WritePhyUshort(sc, 0x05, 0x8B5E); MP_WritePhyUshort(sc, 0x06, 0x0000); MP_WritePhyUshort(sc, 0x05, 0x8B67); MP_WritePhyUshort(sc, 0x06, 0x0000); MP_WritePhyUshort(sc, 0x05, 0x8B70); MP_WritePhyUshort(sc, 0x06, 0x0000); MP_WritePhyUshort(sc, 0x1f, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0007); MP_WritePhyUshort(sc, 0x1E, 0x0078); MP_WritePhyUshort(sc, 0x17, 0x0000); MP_WritePhyUshort(sc, 0x19, 0x00FB); MP_WritePhyUshort(sc, 0x1f, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0005); MP_WritePhyUshort(sc, 0x05, 0x8B79); MP_WritePhyUshort(sc, 0x06, 0xAA00); MP_WritePhyUshort(sc, 0x1f, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0003); MP_WritePhyUshort(sc, 0x01, 0x328A); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0005); MP_WritePhyUshort(sc, 0x05, 0x8B54); Data = MP_ReadPhyUshort(sc, 0x06); Data &= ~BIT_11; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x05, 0x8B5D); Data = MP_ReadPhyUshort(sc, 0x06); Data &= ~BIT_11; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x05, 0x8A7C); Data = MP_ReadPhyUshort(sc, 0x06); Data &= ~BIT_8; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x05, 0x8A7F); Data = MP_ReadPhyUshort(sc, 0x06); Data |= BIT_8; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x05, 0x8A82); Data = MP_ReadPhyUshort(sc, 0x06); Data &= ~BIT_8; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x05, 0x8A85); Data = MP_ReadPhyUshort(sc, 0x06); Data &= ~BIT_8; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x05, 0x8A88); Data = MP_ReadPhyUshort(sc, 0x06); Data &= ~BIT_8; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0005); MP_WritePhyUshort(sc, 0x05, 0x8B85); Data = MP_ReadPhyUshort(sc, 0x06); Data |= BIT_15; MP_WritePhyUshort(sc, 0x06, Data); MP_WritePhyUshort(sc, 0x1f, 0x0000); MP_WritePhyUshort(sc, 0x1f, 0x0003); Data = MP_ReadPhyUshort(sc, 0x19); Data &= ~BIT_0; MP_WritePhyUshort(sc, 0x19, Data); Data = MP_ReadPhyUshort(sc, 0x10); Data &= ~BIT_10; MP_WritePhyUshort(sc, 0x10, Data); MP_WritePhyUshort(sc, 0x1f, 0x0000); } else if (sc->re_type == MACFG_53) { Data_u32 = re_eri_read(sc, 0x1D0, 4, ERIAR_ExGMAC); Data_u32 &= 0xFFFF0000; re_eri_write(sc, 0x1D0, 4, Data_u32, ERIAR_ExGMAC); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x18, 0x0310); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1f, 0x0004); MP_WritePhyUshort(sc, 0x1f, 0x0004); MP_WritePhyUshort(sc, 0x19, 0x7070); MP_WritePhyUshort(sc, 0x1c, 0x0600); MP_WritePhyUshort(sc, 0x1d, 0x9700); MP_WritePhyUshort(sc, 0x1d, 0x7d00); MP_WritePhyUshort(sc, 0x1d, 0x6900); MP_WritePhyUshort(sc, 0x1d, 0x7d00); MP_WritePhyUshort(sc, 0x1d, 0x6800); MP_WritePhyUshort(sc, 0x1d, 0x4899); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c00); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c01); MP_WritePhyUshort(sc, 0x1d, 0x8000); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4c00); MP_WritePhyUshort(sc, 0x1d, 0x4007); MP_WritePhyUshort(sc, 0x1d, 0x4400); MP_WritePhyUshort(sc, 0x1d, 0x4800); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c00); MP_WritePhyUshort(sc, 0x1d, 0x5310); MP_WritePhyUshort(sc, 0x1d, 0x6000); MP_WritePhyUshort(sc, 0x1d, 0x6800); MP_WritePhyUshort(sc, 0x1d, 0x6736); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x571f); MP_WritePhyUshort(sc, 0x1d, 0x5ffb); MP_WritePhyUshort(sc, 0x1d, 0xaa03); MP_WritePhyUshort(sc, 0x1d, 0x5b58); MP_WritePhyUshort(sc, 0x1d, 0x301e); MP_WritePhyUshort(sc, 0x1d, 0x5b64); MP_WritePhyUshort(sc, 0x1d, 0xa6fc); MP_WritePhyUshort(sc, 0x1d, 0xdcdb); MP_WritePhyUshort(sc, 0x1d, 0x0015); MP_WritePhyUshort(sc, 0x1d, 0xb915); MP_WritePhyUshort(sc, 0x1d, 0xb511); MP_WritePhyUshort(sc, 0x1d, 0xd16b); MP_WritePhyUshort(sc, 0x1d, 0x000f); MP_WritePhyUshort(sc, 0x1d, 0xb40f); MP_WritePhyUshort(sc, 0x1d, 0xd06b); MP_WritePhyUshort(sc, 0x1d, 0x000d); MP_WritePhyUshort(sc, 0x1d, 0xb206); MP_WritePhyUshort(sc, 0x1d, 0x7c01); MP_WritePhyUshort(sc, 0x1d, 0x5800); MP_WritePhyUshort(sc, 0x1d, 0x7c04); MP_WritePhyUshort(sc, 0x1d, 0x5c00); MP_WritePhyUshort(sc, 0x1d, 0x301a); MP_WritePhyUshort(sc, 0x1d, 0x7c01); MP_WritePhyUshort(sc, 0x1d, 0x5801); MP_WritePhyUshort(sc, 0x1d, 0x7c04); MP_WritePhyUshort(sc, 0x1d, 0x5c04); MP_WritePhyUshort(sc, 0x1d, 0x301e); MP_WritePhyUshort(sc, 0x1d, 0x3079); MP_WritePhyUshort(sc, 0x1d, 0x30f1); MP_WritePhyUshort(sc, 0x1d, 0x3199); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4c60); MP_WritePhyUshort(sc, 0x1d, 0x6803); MP_WritePhyUshort(sc, 0x1d, 0x6420); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0xaf03); MP_WritePhyUshort(sc, 0x1d, 0x6015); MP_WritePhyUshort(sc, 0x1d, 0x3040); MP_WritePhyUshort(sc, 0x1d, 0x6017); MP_WritePhyUshort(sc, 0x1d, 0x57e0); MP_WritePhyUshort(sc, 0x1d, 0x580c); MP_WritePhyUshort(sc, 0x1d, 0x588c); MP_WritePhyUshort(sc, 0x1d, 0x5fa3); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x4827); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c00); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c10); MP_WritePhyUshort(sc, 0x1d, 0x8400); MP_WritePhyUshort(sc, 0x1d, 0x7c30); MP_WritePhyUshort(sc, 0x1d, 0x6020); MP_WritePhyUshort(sc, 0x1d, 0x48bf); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c00); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c01); MP_WritePhyUshort(sc, 0x1d, 0xd6cf); MP_WritePhyUshort(sc, 0x1d, 0x0002); MP_WritePhyUshort(sc, 0x1d, 0x80fe); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4c80); MP_WritePhyUshort(sc, 0x1d, 0x7c20); MP_WritePhyUshort(sc, 0x1d, 0x5c20); MP_WritePhyUshort(sc, 0x1d, 0x481e); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c00); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c02); MP_WritePhyUshort(sc, 0x1d, 0x5310); MP_WritePhyUshort(sc, 0x1d, 0x81ff); MP_WritePhyUshort(sc, 0x1d, 0x30ba); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4d00); MP_WritePhyUshort(sc, 0x1d, 0x4832); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c00); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c10); MP_WritePhyUshort(sc, 0x1d, 0x7c08); MP_WritePhyUshort(sc, 0x1d, 0x6000); MP_WritePhyUshort(sc, 0x1d, 0xa4cc); MP_WritePhyUshort(sc, 0x1d, 0xd9b3); MP_WritePhyUshort(sc, 0x1d, 0xfffe); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4d20); MP_WritePhyUshort(sc, 0x1d, 0x7e00); MP_WritePhyUshort(sc, 0x1d, 0x6200); MP_WritePhyUshort(sc, 0x1d, 0x300b); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4dc0); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0xd09d); MP_WritePhyUshort(sc, 0x1d, 0x0002); MP_WritePhyUshort(sc, 0x1d, 0xb4fe); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4d80); MP_WritePhyUshort(sc, 0x1d, 0x7c04); MP_WritePhyUshort(sc, 0x1d, 0x6004); MP_WritePhyUshort(sc, 0x1d, 0x5310); MP_WritePhyUshort(sc, 0x1d, 0x6802); MP_WritePhyUshort(sc, 0x1d, 0x6720); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x7c08); MP_WritePhyUshort(sc, 0x1d, 0x6000); MP_WritePhyUshort(sc, 0x1d, 0x486c); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c00); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c01); MP_WritePhyUshort(sc, 0x1d, 0x9503); MP_WritePhyUshort(sc, 0x1d, 0x7e00); MP_WritePhyUshort(sc, 0x1d, 0x6200); MP_WritePhyUshort(sc, 0x1d, 0x571f); MP_WritePhyUshort(sc, 0x1d, 0x5fbb); MP_WritePhyUshort(sc, 0x1d, 0xaa03); MP_WritePhyUshort(sc, 0x1d, 0x5b58); MP_WritePhyUshort(sc, 0x1d, 0x3092); MP_WritePhyUshort(sc, 0x1d, 0x5b64); MP_WritePhyUshort(sc, 0x1d, 0xcdab); MP_WritePhyUshort(sc, 0x1d, 0xff78); MP_WritePhyUshort(sc, 0x1d, 0xcd8d); MP_WritePhyUshort(sc, 0x1d, 0xff76); MP_WritePhyUshort(sc, 0x1d, 0xd96b); MP_WritePhyUshort(sc, 0x1d, 0xff74); MP_WritePhyUshort(sc, 0x1d, 0xd0a0); MP_WritePhyUshort(sc, 0x1d, 0xffd9); MP_WritePhyUshort(sc, 0x1d, 0xcba0); MP_WritePhyUshort(sc, 0x1d, 0x0003); MP_WritePhyUshort(sc, 0x1d, 0x80f0); MP_WritePhyUshort(sc, 0x1d, 0x309f); MP_WritePhyUshort(sc, 0x1d, 0x30ac); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4ce0); MP_WritePhyUshort(sc, 0x1d, 0x4832); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c00); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c08); MP_WritePhyUshort(sc, 0x1d, 0x7c08); MP_WritePhyUshort(sc, 0x1d, 0x6008); MP_WritePhyUshort(sc, 0x1d, 0x8300); MP_WritePhyUshort(sc, 0x1d, 0xb902); MP_WritePhyUshort(sc, 0x1d, 0x3079); MP_WritePhyUshort(sc, 0x1d, 0x3061); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4da0); MP_WritePhyUshort(sc, 0x1d, 0x6400); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x57a0); MP_WritePhyUshort(sc, 0x1d, 0x590c); MP_WritePhyUshort(sc, 0x1d, 0x5fa3); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0xcba4); MP_WritePhyUshort(sc, 0x1d, 0x0004); MP_WritePhyUshort(sc, 0x1d, 0xcd8d); MP_WritePhyUshort(sc, 0x1d, 0x0002); MP_WritePhyUshort(sc, 0x1d, 0x80fc); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4ca0); MP_WritePhyUshort(sc, 0x1d, 0xb603); MP_WritePhyUshort(sc, 0x1d, 0x7c10); MP_WritePhyUshort(sc, 0x1d, 0x6010); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x541f); MP_WritePhyUshort(sc, 0x1d, 0x5fb3); MP_WritePhyUshort(sc, 0x1d, 0xaa05); MP_WritePhyUshort(sc, 0x1d, 0x7c80); MP_WritePhyUshort(sc, 0x1d, 0x5800); MP_WritePhyUshort(sc, 0x1d, 0x5b58); MP_WritePhyUshort(sc, 0x1d, 0x30ca); MP_WritePhyUshort(sc, 0x1d, 0x7c80); MP_WritePhyUshort(sc, 0x1d, 0x5800); MP_WritePhyUshort(sc, 0x1d, 0x5b64); MP_WritePhyUshort(sc, 0x1d, 0x4824); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c00); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c04); MP_WritePhyUshort(sc, 0x1d, 0x8200); MP_WritePhyUshort(sc, 0x1d, 0x4827); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c00); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c10); MP_WritePhyUshort(sc, 0x1d, 0x8400); MP_WritePhyUshort(sc, 0x1d, 0x7c10); MP_WritePhyUshort(sc, 0x1d, 0x6000); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4cc0); MP_WritePhyUshort(sc, 0x1d, 0x5fbb); MP_WritePhyUshort(sc, 0x1d, 0x4824); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c00); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c04); MP_WritePhyUshort(sc, 0x1d, 0x8200); MP_WritePhyUshort(sc, 0x1d, 0x7ce0); MP_WritePhyUshort(sc, 0x1d, 0x5400); MP_WritePhyUshort(sc, 0x1d, 0x6720); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x7e00); MP_WritePhyUshort(sc, 0x1d, 0x6a00); MP_WritePhyUshort(sc, 0x1d, 0x4824); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c00); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c04); MP_WritePhyUshort(sc, 0x1d, 0x8200); MP_WritePhyUshort(sc, 0x1d, 0x7e00); MP_WritePhyUshort(sc, 0x1d, 0x6800); MP_WritePhyUshort(sc, 0x1d, 0x309f); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4e00); MP_WritePhyUshort(sc, 0x1d, 0x4007); MP_WritePhyUshort(sc, 0x1d, 0x4400); MP_WritePhyUshort(sc, 0x1d, 0x5310); MP_WritePhyUshort(sc, 0x1d, 0x6800); MP_WritePhyUshort(sc, 0x1d, 0x6736); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x570f); MP_WritePhyUshort(sc, 0x1d, 0x5fff); MP_WritePhyUshort(sc, 0x1d, 0xaa03); MP_WritePhyUshort(sc, 0x1d, 0x585b); MP_WritePhyUshort(sc, 0x1d, 0x3100); MP_WritePhyUshort(sc, 0x1d, 0x5867); MP_WritePhyUshort(sc, 0x1d, 0x9403); MP_WritePhyUshort(sc, 0x1d, 0x7e00); MP_WritePhyUshort(sc, 0x1d, 0x6200); MP_WritePhyUshort(sc, 0x1d, 0xcda3); MP_WritePhyUshort(sc, 0x1d, 0x002d); MP_WritePhyUshort(sc, 0x1d, 0xcd85); MP_WritePhyUshort(sc, 0x1d, 0x002b); MP_WritePhyUshort(sc, 0x1d, 0xd96b); MP_WritePhyUshort(sc, 0x1d, 0x0029); MP_WritePhyUshort(sc, 0x1d, 0x9629); MP_WritePhyUshort(sc, 0x1d, 0x6800); MP_WritePhyUshort(sc, 0x1d, 0x6736); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x9624); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4e20); MP_WritePhyUshort(sc, 0x1d, 0x8b04); MP_WritePhyUshort(sc, 0x1d, 0x7c08); MP_WritePhyUshort(sc, 0x1d, 0x5008); MP_WritePhyUshort(sc, 0x1d, 0xab03); MP_WritePhyUshort(sc, 0x1d, 0x7c08); MP_WritePhyUshort(sc, 0x1d, 0x5000); MP_WritePhyUshort(sc, 0x1d, 0x6801); MP_WritePhyUshort(sc, 0x1d, 0x6776); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0xdb7c); MP_WritePhyUshort(sc, 0x1d, 0xffee); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x7fe1); MP_WritePhyUshort(sc, 0x1d, 0x4e40); MP_WritePhyUshort(sc, 0x1d, 0x4837); MP_WritePhyUshort(sc, 0x1d, 0x4418); MP_WritePhyUshort(sc, 0x1d, 0x41c7); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4e40); MP_WritePhyUshort(sc, 0x1d, 0x7c40); MP_WritePhyUshort(sc, 0x1d, 0x5400); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c01); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c01); MP_WritePhyUshort(sc, 0x1d, 0x8f07); MP_WritePhyUshort(sc, 0x1d, 0xd2a0); MP_WritePhyUshort(sc, 0x1d, 0x004c); MP_WritePhyUshort(sc, 0x1d, 0x9205); MP_WritePhyUshort(sc, 0x1d, 0xa043); MP_WritePhyUshort(sc, 0x1d, 0x312b); MP_WritePhyUshort(sc, 0x1d, 0x300b); MP_WritePhyUshort(sc, 0x1d, 0x30f1); MP_WritePhyUshort(sc, 0x1d, 0x7fe1); MP_WritePhyUshort(sc, 0x1d, 0x4e60); MP_WritePhyUshort(sc, 0x1d, 0x489c); MP_WritePhyUshort(sc, 0x1d, 0x4628); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4e60); MP_WritePhyUshort(sc, 0x1d, 0x7e28); MP_WritePhyUshort(sc, 0x1d, 0x4628); MP_WritePhyUshort(sc, 0x1d, 0x7c40); MP_WritePhyUshort(sc, 0x1d, 0x5400); MP_WritePhyUshort(sc, 0x1d, 0x7c01); MP_WritePhyUshort(sc, 0x1d, 0x5800); MP_WritePhyUshort(sc, 0x1d, 0x7c04); MP_WritePhyUshort(sc, 0x1d, 0x5c00); MP_WritePhyUshort(sc, 0x1d, 0x41e8); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c01); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c01); MP_WritePhyUshort(sc, 0x1d, 0x8fec); MP_WritePhyUshort(sc, 0x1d, 0xb241); MP_WritePhyUshort(sc, 0x1d, 0xa02a); MP_WritePhyUshort(sc, 0x1d, 0x3146); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4ea0); MP_WritePhyUshort(sc, 0x1d, 0x7c02); MP_WritePhyUshort(sc, 0x1d, 0x4402); MP_WritePhyUshort(sc, 0x1d, 0x4448); MP_WritePhyUshort(sc, 0x1d, 0x4894); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c01); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c03); MP_WritePhyUshort(sc, 0x1d, 0x4824); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c07); MP_WritePhyUshort(sc, 0x1d, 0x41ef); MP_WritePhyUshort(sc, 0x1d, 0x41ff); MP_WritePhyUshort(sc, 0x1d, 0x4891); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c07); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c17); MP_WritePhyUshort(sc, 0x1d, 0x8400); MP_WritePhyUshort(sc, 0x1d, 0x8ef8); MP_WritePhyUshort(sc, 0x1d, 0x41c7); MP_WritePhyUshort(sc, 0x1d, 0x8fd1); MP_WritePhyUshort(sc, 0x1d, 0x92d5); MP_WritePhyUshort(sc, 0x1d, 0xa10f); MP_WritePhyUshort(sc, 0x1d, 0xd480); MP_WritePhyUshort(sc, 0x1d, 0x0008); MP_WritePhyUshort(sc, 0x1d, 0xd580); MP_WritePhyUshort(sc, 0x1d, 0xffb7); MP_WritePhyUshort(sc, 0x1d, 0xa202); MP_WritePhyUshort(sc, 0x1d, 0x3161); MP_WritePhyUshort(sc, 0x1d, 0x7c04); MP_WritePhyUshort(sc, 0x1d, 0x4404); MP_WritePhyUshort(sc, 0x1d, 0x3161); MP_WritePhyUshort(sc, 0x1d, 0xd484); MP_WritePhyUshort(sc, 0x1d, 0xfff3); MP_WritePhyUshort(sc, 0x1d, 0xd484); MP_WritePhyUshort(sc, 0x1d, 0xfff1); MP_WritePhyUshort(sc, 0x1d, 0x30f1); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4ee0); MP_WritePhyUshort(sc, 0x1d, 0x7c40); MP_WritePhyUshort(sc, 0x1d, 0x5400); MP_WritePhyUshort(sc, 0x1d, 0x4488); MP_WritePhyUshort(sc, 0x1d, 0x41cf); MP_WritePhyUshort(sc, 0x1d, 0x30f1); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4ec0); MP_WritePhyUshort(sc, 0x1d, 0x48f3); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c01); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c09); MP_WritePhyUshort(sc, 0x1d, 0x4508); MP_WritePhyUshort(sc, 0x1d, 0x41c7); MP_WritePhyUshort(sc, 0x1d, 0x8fb0); MP_WritePhyUshort(sc, 0x1d, 0xd218); MP_WritePhyUshort(sc, 0x1d, 0xffae); MP_WritePhyUshort(sc, 0x1d, 0xd2a4); MP_WritePhyUshort(sc, 0x1d, 0xff9d); MP_WritePhyUshort(sc, 0x1d, 0x3182); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4e80); MP_WritePhyUshort(sc, 0x1d, 0x4832); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c01); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c11); MP_WritePhyUshort(sc, 0x1d, 0x4428); MP_WritePhyUshort(sc, 0x1d, 0x7c40); MP_WritePhyUshort(sc, 0x1d, 0x5440); MP_WritePhyUshort(sc, 0x1d, 0x7c01); MP_WritePhyUshort(sc, 0x1d, 0x5801); MP_WritePhyUshort(sc, 0x1d, 0x7c04); MP_WritePhyUshort(sc, 0x1d, 0x5c04); MP_WritePhyUshort(sc, 0x1d, 0x41e8); MP_WritePhyUshort(sc, 0x1d, 0xa4b3); MP_WritePhyUshort(sc, 0x1d, 0x3197); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4f20); MP_WritePhyUshort(sc, 0x1d, 0x6800); MP_WritePhyUshort(sc, 0x1d, 0x6736); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x570f); MP_WritePhyUshort(sc, 0x1d, 0x5fff); MP_WritePhyUshort(sc, 0x1d, 0xaa03); MP_WritePhyUshort(sc, 0x1d, 0x585b); MP_WritePhyUshort(sc, 0x1d, 0x31a5); MP_WritePhyUshort(sc, 0x1d, 0x5867); MP_WritePhyUshort(sc, 0x1d, 0xbcf4); MP_WritePhyUshort(sc, 0x1d, 0x300b); MP_WritePhyUshort(sc, 0x1f, 0x0004); MP_WritePhyUshort(sc, 0x1c, 0x0200); MP_WritePhyUshort(sc, 0x19, 0x7030); MP_WritePhyUshort(sc, 0x1f, 0x0000); if (phy_power_saving == 1) { MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x18, 0x8310); MP_WritePhyUshort(sc, 0x1F, 0x0000); } else { MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x18, 0x0310); MP_WritePhyUshort(sc, 0x1F, 0x0000); DELAY(20000); } MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x0D, 0x0007); MP_WritePhyUshort(sc, 0x0E, 0x003C); MP_WritePhyUshort(sc, 0x0D, 0x4007); MP_WritePhyUshort(sc, 0x0E, 0x0000); MP_WritePhyUshort(sc, 0x0D, 0x0000); } else if (sc->re_type == MACFG_54 || sc->re_type == MACFG_55) { Data_u32 = re_eri_read(sc, 0x1D0, 4, ERIAR_ExGMAC); Data_u32 &= 0xFFFF0000; re_eri_write(sc, 0x1D0, 4, Data_u32, ERIAR_ExGMAC); if (sc->re_type == MACFG_55) { MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x18, 0x0310); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1f, 0x0004); MP_WritePhyUshort(sc, 0x1f, 0x0004); MP_WritePhyUshort(sc, 0x19, 0x7070); MP_WritePhyUshort(sc, 0x1c, 0x0600); MP_WritePhyUshort(sc, 0x1d, 0x9700); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4c00); MP_WritePhyUshort(sc, 0x1d, 0x4007); MP_WritePhyUshort(sc, 0x1d, 0x4400); MP_WritePhyUshort(sc, 0x1d, 0x4800); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c00); MP_WritePhyUshort(sc, 0x1d, 0x5310); MP_WritePhyUshort(sc, 0x1d, 0x6000); MP_WritePhyUshort(sc, 0x1d, 0x6800); MP_WritePhyUshort(sc, 0x1d, 0x673e); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x571f); MP_WritePhyUshort(sc, 0x1d, 0x5ffb); MP_WritePhyUshort(sc, 0x1d, 0xaa04); MP_WritePhyUshort(sc, 0x1d, 0x5b58); MP_WritePhyUshort(sc, 0x1d, 0x6100); MP_WritePhyUshort(sc, 0x1d, 0x3016); MP_WritePhyUshort(sc, 0x1d, 0x5b64); MP_WritePhyUshort(sc, 0x1d, 0x6080); MP_WritePhyUshort(sc, 0x1d, 0xa6fa); MP_WritePhyUshort(sc, 0x1d, 0xdcdb); MP_WritePhyUshort(sc, 0x1d, 0x0015); MP_WritePhyUshort(sc, 0x1d, 0xb915); MP_WritePhyUshort(sc, 0x1d, 0xb511); MP_WritePhyUshort(sc, 0x1d, 0xd16b); MP_WritePhyUshort(sc, 0x1d, 0x000f); MP_WritePhyUshort(sc, 0x1d, 0xb40f); MP_WritePhyUshort(sc, 0x1d, 0xd06b); MP_WritePhyUshort(sc, 0x1d, 0x000d); MP_WritePhyUshort(sc, 0x1d, 0xb206); MP_WritePhyUshort(sc, 0x1d, 0x7c01); MP_WritePhyUshort(sc, 0x1d, 0x5800); MP_WritePhyUshort(sc, 0x1d, 0x7c04); MP_WritePhyUshort(sc, 0x1d, 0x5c00); MP_WritePhyUshort(sc, 0x1d, 0x3010); MP_WritePhyUshort(sc, 0x1d, 0x7c01); MP_WritePhyUshort(sc, 0x1d, 0x5801); MP_WritePhyUshort(sc, 0x1d, 0x7c04); MP_WritePhyUshort(sc, 0x1d, 0x5c04); MP_WritePhyUshort(sc, 0x1d, 0x3016); MP_WritePhyUshort(sc, 0x1d, 0x307e); MP_WritePhyUshort(sc, 0x1d, 0x30f4); MP_WritePhyUshort(sc, 0x1d, 0x319f); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4c60); MP_WritePhyUshort(sc, 0x1d, 0x6803); MP_WritePhyUshort(sc, 0x1d, 0x7d00); MP_WritePhyUshort(sc, 0x1d, 0x6900); MP_WritePhyUshort(sc, 0x1d, 0x6520); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0xaf03); MP_WritePhyUshort(sc, 0x1d, 0x6115); MP_WritePhyUshort(sc, 0x1d, 0x303a); MP_WritePhyUshort(sc, 0x1d, 0x6097); MP_WritePhyUshort(sc, 0x1d, 0x57e0); MP_WritePhyUshort(sc, 0x1d, 0x580c); MP_WritePhyUshort(sc, 0x1d, 0x588c); MP_WritePhyUshort(sc, 0x1d, 0x5f80); MP_WritePhyUshort(sc, 0x1d, 0x4827); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c00); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c10); MP_WritePhyUshort(sc, 0x1d, 0x8400); MP_WritePhyUshort(sc, 0x1d, 0x7c30); MP_WritePhyUshort(sc, 0x1d, 0x6020); MP_WritePhyUshort(sc, 0x1d, 0x48bf); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c00); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c01); MP_WritePhyUshort(sc, 0x1d, 0xb802); MP_WritePhyUshort(sc, 0x1d, 0x3053); MP_WritePhyUshort(sc, 0x1d, 0x7c08); MP_WritePhyUshort(sc, 0x1d, 0x6808); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x7c10); MP_WritePhyUshort(sc, 0x1d, 0x6810); MP_WritePhyUshort(sc, 0x1d, 0xd6cf); MP_WritePhyUshort(sc, 0x1d, 0x0002); MP_WritePhyUshort(sc, 0x1d, 0x80fe); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4c80); MP_WritePhyUshort(sc, 0x1d, 0x7c10); MP_WritePhyUshort(sc, 0x1d, 0x6800); MP_WritePhyUshort(sc, 0x1d, 0x7c08); MP_WritePhyUshort(sc, 0x1d, 0x6800); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x7c23); MP_WritePhyUshort(sc, 0x1d, 0x5c23); MP_WritePhyUshort(sc, 0x1d, 0x481e); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c00); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c02); MP_WritePhyUshort(sc, 0x1d, 0x5310); MP_WritePhyUshort(sc, 0x1d, 0x81ff); MP_WritePhyUshort(sc, 0x1d, 0x30c1); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4d00); MP_WritePhyUshort(sc, 0x1d, 0x4832); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c00); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c10); MP_WritePhyUshort(sc, 0x1d, 0x7c08); MP_WritePhyUshort(sc, 0x1d, 0x6000); MP_WritePhyUshort(sc, 0x1d, 0xa4bd); MP_WritePhyUshort(sc, 0x1d, 0xd9b3); MP_WritePhyUshort(sc, 0x1d, 0x00fe); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4d20); MP_WritePhyUshort(sc, 0x1d, 0x7e00); MP_WritePhyUshort(sc, 0x1d, 0x6200); MP_WritePhyUshort(sc, 0x1d, 0x3001); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4dc0); MP_WritePhyUshort(sc, 0x1d, 0xd09d); MP_WritePhyUshort(sc, 0x1d, 0x0002); MP_WritePhyUshort(sc, 0x1d, 0xb4fe); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4d80); MP_WritePhyUshort(sc, 0x1d, 0x7c04); MP_WritePhyUshort(sc, 0x1d, 0x6004); MP_WritePhyUshort(sc, 0x1d, 0x6802); MP_WritePhyUshort(sc, 0x1d, 0x6728); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x7c08); MP_WritePhyUshort(sc, 0x1d, 0x6000); MP_WritePhyUshort(sc, 0x1d, 0x486c); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c00); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c01); MP_WritePhyUshort(sc, 0x1d, 0x9503); MP_WritePhyUshort(sc, 0x1d, 0x7e00); MP_WritePhyUshort(sc, 0x1d, 0x6200); MP_WritePhyUshort(sc, 0x1d, 0x571f); MP_WritePhyUshort(sc, 0x1d, 0x5fbb); MP_WritePhyUshort(sc, 0x1d, 0xaa05); MP_WritePhyUshort(sc, 0x1d, 0x5b58); MP_WritePhyUshort(sc, 0x1d, 0x7d80); MP_WritePhyUshort(sc, 0x1d, 0x6100); MP_WritePhyUshort(sc, 0x1d, 0x309a); MP_WritePhyUshort(sc, 0x1d, 0x5b64); MP_WritePhyUshort(sc, 0x1d, 0x7d80); MP_WritePhyUshort(sc, 0x1d, 0x6080); MP_WritePhyUshort(sc, 0x1d, 0xcdab); MP_WritePhyUshort(sc, 0x1d, 0x0058); MP_WritePhyUshort(sc, 0x1d, 0xcd8d); MP_WritePhyUshort(sc, 0x1d, 0x0056); MP_WritePhyUshort(sc, 0x1d, 0xd96b); MP_WritePhyUshort(sc, 0x1d, 0x0054); MP_WritePhyUshort(sc, 0x1d, 0xd0a0); MP_WritePhyUshort(sc, 0x1d, 0x00d8); MP_WritePhyUshort(sc, 0x1d, 0xcba0); MP_WritePhyUshort(sc, 0x1d, 0x0003); MP_WritePhyUshort(sc, 0x1d, 0x80ec); MP_WritePhyUshort(sc, 0x1d, 0x30a7); MP_WritePhyUshort(sc, 0x1d, 0x30b4); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4ce0); MP_WritePhyUshort(sc, 0x1d, 0x4832); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c00); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c08); MP_WritePhyUshort(sc, 0x1d, 0x7c08); MP_WritePhyUshort(sc, 0x1d, 0x6008); MP_WritePhyUshort(sc, 0x1d, 0x8300); MP_WritePhyUshort(sc, 0x1d, 0xb902); MP_WritePhyUshort(sc, 0x1d, 0x307e); MP_WritePhyUshort(sc, 0x1d, 0x3068); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4da0); MP_WritePhyUshort(sc, 0x1d, 0x6608); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x56a0); MP_WritePhyUshort(sc, 0x1d, 0x590c); MP_WritePhyUshort(sc, 0x1d, 0x5fa0); MP_WritePhyUshort(sc, 0x1d, 0xcba4); MP_WritePhyUshort(sc, 0x1d, 0x0004); MP_WritePhyUshort(sc, 0x1d, 0xcd8d); MP_WritePhyUshort(sc, 0x1d, 0x0002); MP_WritePhyUshort(sc, 0x1d, 0x80fc); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4ca0); MP_WritePhyUshort(sc, 0x1d, 0x7c08); MP_WritePhyUshort(sc, 0x1d, 0x6408); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x7d00); MP_WritePhyUshort(sc, 0x1d, 0x6800); MP_WritePhyUshort(sc, 0x1d, 0xb603); MP_WritePhyUshort(sc, 0x1d, 0x7c10); MP_WritePhyUshort(sc, 0x1d, 0x6010); MP_WritePhyUshort(sc, 0x1d, 0x7d1f); MP_WritePhyUshort(sc, 0x1d, 0x551f); MP_WritePhyUshort(sc, 0x1d, 0x5fb3); MP_WritePhyUshort(sc, 0x1d, 0xaa05); MP_WritePhyUshort(sc, 0x1d, 0x7c80); MP_WritePhyUshort(sc, 0x1d, 0x5800); MP_WritePhyUshort(sc, 0x1d, 0x5b58); MP_WritePhyUshort(sc, 0x1d, 0x30d7); MP_WritePhyUshort(sc, 0x1d, 0x7c80); MP_WritePhyUshort(sc, 0x1d, 0x5800); MP_WritePhyUshort(sc, 0x1d, 0x5b64); MP_WritePhyUshort(sc, 0x1d, 0x4827); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c00); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c10); MP_WritePhyUshort(sc, 0x1d, 0x8400); MP_WritePhyUshort(sc, 0x1d, 0x7c10); MP_WritePhyUshort(sc, 0x1d, 0x6000); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4cc0); MP_WritePhyUshort(sc, 0x1d, 0x7d00); MP_WritePhyUshort(sc, 0x1d, 0x6400); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x5fbb); MP_WritePhyUshort(sc, 0x1d, 0x4824); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c00); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c04); MP_WritePhyUshort(sc, 0x1d, 0x8200); MP_WritePhyUshort(sc, 0x1d, 0x7ce0); MP_WritePhyUshort(sc, 0x1d, 0x5400); MP_WritePhyUshort(sc, 0x1d, 0x7d00); MP_WritePhyUshort(sc, 0x1d, 0x6500); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x30a7); MP_WritePhyUshort(sc, 0x1d, 0x3001); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4e00); MP_WritePhyUshort(sc, 0x1d, 0x4007); MP_WritePhyUshort(sc, 0x1d, 0x4400); MP_WritePhyUshort(sc, 0x1d, 0x5310); MP_WritePhyUshort(sc, 0x1d, 0x6800); MP_WritePhyUshort(sc, 0x1d, 0x673e); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x570f); MP_WritePhyUshort(sc, 0x1d, 0x5fff); MP_WritePhyUshort(sc, 0x1d, 0xaa05); MP_WritePhyUshort(sc, 0x1d, 0x585b); MP_WritePhyUshort(sc, 0x1d, 0x7d80); MP_WritePhyUshort(sc, 0x1d, 0x6100); MP_WritePhyUshort(sc, 0x1d, 0x3107); MP_WritePhyUshort(sc, 0x1d, 0x5867); MP_WritePhyUshort(sc, 0x1d, 0x7d80); MP_WritePhyUshort(sc, 0x1d, 0x6080); MP_WritePhyUshort(sc, 0x1d, 0x9403); MP_WritePhyUshort(sc, 0x1d, 0x7e00); MP_WritePhyUshort(sc, 0x1d, 0x6200); MP_WritePhyUshort(sc, 0x1d, 0xcda3); MP_WritePhyUshort(sc, 0x1d, 0x00e8); MP_WritePhyUshort(sc, 0x1d, 0xcd85); MP_WritePhyUshort(sc, 0x1d, 0x00e6); MP_WritePhyUshort(sc, 0x1d, 0xd96b); MP_WritePhyUshort(sc, 0x1d, 0x00e4); MP_WritePhyUshort(sc, 0x1d, 0x96e4); MP_WritePhyUshort(sc, 0x1d, 0x6800); MP_WritePhyUshort(sc, 0x1d, 0x673e); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4e20); MP_WritePhyUshort(sc, 0x1d, 0x96dd); MP_WritePhyUshort(sc, 0x1d, 0x8b04); MP_WritePhyUshort(sc, 0x1d, 0x7c08); MP_WritePhyUshort(sc, 0x1d, 0x5008); MP_WritePhyUshort(sc, 0x1d, 0xab03); MP_WritePhyUshort(sc, 0x1d, 0x7c08); MP_WritePhyUshort(sc, 0x1d, 0x5000); MP_WritePhyUshort(sc, 0x1d, 0x6801); MP_WritePhyUshort(sc, 0x1d, 0x677e); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0xdb7c); MP_WritePhyUshort(sc, 0x1d, 0x00ee); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x7fe1); MP_WritePhyUshort(sc, 0x1d, 0x4e40); MP_WritePhyUshort(sc, 0x1d, 0x4837); MP_WritePhyUshort(sc, 0x1d, 0x4418); MP_WritePhyUshort(sc, 0x1d, 0x41c7); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4e40); MP_WritePhyUshort(sc, 0x1d, 0x7c40); MP_WritePhyUshort(sc, 0x1d, 0x5400); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c01); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c01); MP_WritePhyUshort(sc, 0x1d, 0x8fc2); MP_WritePhyUshort(sc, 0x1d, 0xd2a0); MP_WritePhyUshort(sc, 0x1d, 0x004b); MP_WritePhyUshort(sc, 0x1d, 0x9204); MP_WritePhyUshort(sc, 0x1d, 0xa042); MP_WritePhyUshort(sc, 0x1d, 0x3132); MP_WritePhyUshort(sc, 0x1d, 0x30f4); MP_WritePhyUshort(sc, 0x1d, 0x7fe1); MP_WritePhyUshort(sc, 0x1d, 0x4e60); MP_WritePhyUshort(sc, 0x1d, 0x489c); MP_WritePhyUshort(sc, 0x1d, 0x4628); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4e60); MP_WritePhyUshort(sc, 0x1d, 0x7e28); MP_WritePhyUshort(sc, 0x1d, 0x4628); MP_WritePhyUshort(sc, 0x1d, 0x7c40); MP_WritePhyUshort(sc, 0x1d, 0x5400); MP_WritePhyUshort(sc, 0x1d, 0x7c01); MP_WritePhyUshort(sc, 0x1d, 0x5800); MP_WritePhyUshort(sc, 0x1d, 0x7c04); MP_WritePhyUshort(sc, 0x1d, 0x5c00); MP_WritePhyUshort(sc, 0x1d, 0x41e8); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c01); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c01); MP_WritePhyUshort(sc, 0x1d, 0x8fa8); MP_WritePhyUshort(sc, 0x1d, 0xb241); MP_WritePhyUshort(sc, 0x1d, 0xa02a); MP_WritePhyUshort(sc, 0x1d, 0x314c); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4ea0); MP_WritePhyUshort(sc, 0x1d, 0x7c02); MP_WritePhyUshort(sc, 0x1d, 0x4402); MP_WritePhyUshort(sc, 0x1d, 0x4448); MP_WritePhyUshort(sc, 0x1d, 0x4894); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c01); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c03); MP_WritePhyUshort(sc, 0x1d, 0x4824); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c07); MP_WritePhyUshort(sc, 0x1d, 0x41ef); MP_WritePhyUshort(sc, 0x1d, 0x41ff); MP_WritePhyUshort(sc, 0x1d, 0x4891); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c07); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c17); MP_WritePhyUshort(sc, 0x1d, 0x8400); MP_WritePhyUshort(sc, 0x1d, 0x8ef8); MP_WritePhyUshort(sc, 0x1d, 0x41c7); MP_WritePhyUshort(sc, 0x1d, 0x8f8d); MP_WritePhyUshort(sc, 0x1d, 0x92d5); MP_WritePhyUshort(sc, 0x1d, 0xa10f); MP_WritePhyUshort(sc, 0x1d, 0xd480); MP_WritePhyUshort(sc, 0x1d, 0x0008); MP_WritePhyUshort(sc, 0x1d, 0xd580); MP_WritePhyUshort(sc, 0x1d, 0x00b8); MP_WritePhyUshort(sc, 0x1d, 0xa202); MP_WritePhyUshort(sc, 0x1d, 0x3167); MP_WritePhyUshort(sc, 0x1d, 0x7c04); MP_WritePhyUshort(sc, 0x1d, 0x4404); MP_WritePhyUshort(sc, 0x1d, 0x3167); MP_WritePhyUshort(sc, 0x1d, 0xd484); MP_WritePhyUshort(sc, 0x1d, 0x00f3); MP_WritePhyUshort(sc, 0x1d, 0xd484); MP_WritePhyUshort(sc, 0x1d, 0x00f1); MP_WritePhyUshort(sc, 0x1d, 0x30f4); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4ee0); MP_WritePhyUshort(sc, 0x1d, 0x7c40); MP_WritePhyUshort(sc, 0x1d, 0x5400); MP_WritePhyUshort(sc, 0x1d, 0x4488); MP_WritePhyUshort(sc, 0x1d, 0x41cf); MP_WritePhyUshort(sc, 0x1d, 0x30f4); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4ec0); MP_WritePhyUshort(sc, 0x1d, 0x48f3); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c01); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c09); MP_WritePhyUshort(sc, 0x1d, 0x4508); MP_WritePhyUshort(sc, 0x1d, 0x41c7); MP_WritePhyUshort(sc, 0x1d, 0x8fb0); MP_WritePhyUshort(sc, 0x1d, 0xd218); MP_WritePhyUshort(sc, 0x1d, 0x00ae); MP_WritePhyUshort(sc, 0x1d, 0xd2a4); MP_WritePhyUshort(sc, 0x1d, 0x009e); MP_WritePhyUshort(sc, 0x1d, 0x3188); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4e80); MP_WritePhyUshort(sc, 0x1d, 0x4832); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c01); MP_WritePhyUshort(sc, 0x1d, 0x7c1f); MP_WritePhyUshort(sc, 0x1d, 0x4c11); MP_WritePhyUshort(sc, 0x1d, 0x4428); MP_WritePhyUshort(sc, 0x1d, 0x7c40); MP_WritePhyUshort(sc, 0x1d, 0x5440); MP_WritePhyUshort(sc, 0x1d, 0x7c01); MP_WritePhyUshort(sc, 0x1d, 0x5801); MP_WritePhyUshort(sc, 0x1d, 0x7c04); MP_WritePhyUshort(sc, 0x1d, 0x5c04); MP_WritePhyUshort(sc, 0x1d, 0x41e8); MP_WritePhyUshort(sc, 0x1d, 0xa4b3); MP_WritePhyUshort(sc, 0x1d, 0x319d); MP_WritePhyUshort(sc, 0x1d, 0x7fe0); MP_WritePhyUshort(sc, 0x1d, 0x4f20); MP_WritePhyUshort(sc, 0x1d, 0x6800); MP_WritePhyUshort(sc, 0x1d, 0x673e); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x0000); MP_WritePhyUshort(sc, 0x1d, 0x570f); MP_WritePhyUshort(sc, 0x1d, 0x5fff); MP_WritePhyUshort(sc, 0x1d, 0xaa04); MP_WritePhyUshort(sc, 0x1d, 0x585b); MP_WritePhyUshort(sc, 0x1d, 0x6100); MP_WritePhyUshort(sc, 0x1d, 0x31ad); MP_WritePhyUshort(sc, 0x1d, 0x5867); MP_WritePhyUshort(sc, 0x1d, 0x6080); MP_WritePhyUshort(sc, 0x1d, 0xbcf2); MP_WritePhyUshort(sc, 0x1d, 0x3001); MP_WritePhyUshort(sc, 0x1f, 0x0004); MP_WritePhyUshort(sc, 0x1c, 0x0200); MP_WritePhyUshort(sc, 0x19, 0x7030); MP_WritePhyUshort(sc, 0x1f, 0x0000); } MP_WritePhyUshort(sc, 0x1F, 0x0001); MP_WritePhyUshort(sc, 0x11, 0x83BA); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0005); ClearEthPhyBit(sc, 0x1A, BIT_2); MP_WritePhyUshort(sc, 0x1F, 0x0000); if (phy_power_saving == 1) { MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x18, 0x8310); MP_WritePhyUshort(sc, 0x1F, 0x0000); } else { MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x18, 0x0310); MP_WritePhyUshort(sc, 0x1F, 0x0000); DELAY(20000); } MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x0D, 0x0007); MP_WritePhyUshort(sc, 0x0E, 0x003C); MP_WritePhyUshort(sc, 0x0D, 0x4007); MP_WritePhyUshort(sc, 0x0E, 0x0000); MP_WritePhyUshort(sc, 0x0D, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x0D, 0x0003); MP_WritePhyUshort(sc, 0x0E, 0x0015); MP_WritePhyUshort(sc, 0x0D, 0x4003); MP_WritePhyUshort(sc, 0x0E, 0x0000); MP_WritePhyUshort(sc, 0x0D, 0x0000); } else if (sc->re_type == MACFG_56) { MP_WritePhyUshort(sc, 0x1F, 0x0A46); PhyRegValue = MP_ReadPhyUshort(sc, 0x10); TmpUshort = (PhyRegValue & BIT_8) ? 0 : BIT_15; MP_WritePhyUshort(sc, 0x1F, 0x0BCC); ClearEthPhyBit(sc, 0x12, BIT_15); SetEthPhyBit(sc, 0x12, TmpUshort); MP_WritePhyUshort(sc, 0x1F, 0x0A46); PhyRegValue = MP_ReadPhyUshort(sc, 0x13); TmpUshort = (PhyRegValue & BIT_8) ? BIT_1 : 0; MP_WritePhyUshort(sc, 0x1F, 0x0C41); ClearEthPhyBit(sc, 0x15, BIT_1); SetEthPhyBit(sc, 0x15, TmpUshort); MP_WritePhyUshort(sc, 0x1F, 0x0A44); SetEthPhyBit(sc, 0x11, (BIT_3 | BIT_2)); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0BCC); ClearEthPhyBit(sc, 0x14, BIT_8); MP_WritePhyUshort(sc, 0x1F, 0x0A44); SetEthPhyBit(sc, 0x11, BIT_7); SetEthPhyBit(sc, 0x11, BIT_6); MP_WritePhyUshort(sc, 0x1F, 0x0A43); MP_WritePhyUshort(sc, 0x13, 0x8084); ClearEthPhyBit(sc, 0x14, (BIT_14 | BIT_13)); SetEthPhyBit(sc, 0x10, BIT_12); SetEthPhyBit(sc, 0x10, BIT_1); SetEthPhyBit(sc, 0x10, BIT_0); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0A4B); SetEthPhyBit(sc, 0x11, BIT_2); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0A43); MP_WritePhyUshort(sc, 0x13, 0x8012); SetEthPhyBit(sc, 0x14, BIT_15); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0C42); ClearAndSetEthPhyBit(sc, 0x11, BIT_13, BIT_14 ); 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, 0x809A); MP_WritePhyUshort(sc, 0x14, 0x8022); MP_WritePhyUshort(sc, 0x13, 0x80A0); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x1000 ); MP_WritePhyUshort(sc, 0x13, 0x8088); MP_WritePhyUshort(sc, 0x14, 0x9222); 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, 0x00, 0x9200); } else if (sc->re_type == MACFG_58) { MP_WritePhyUshort(sc, 0x1F, 0x0BCC); ClearEthPhyBit(sc, 0x14, BIT_8); MP_WritePhyUshort(sc, 0x1F, 0x0A44); SetEthPhyBit(sc, 0x11, BIT_7); SetEthPhyBit(sc, 0x11, BIT_6); MP_WritePhyUshort(sc, 0x1F, 0x0A43); MP_WritePhyUshort(sc, 0x13, 0x8084); ClearEthPhyBit(sc, 0x14, (BIT_14 | BIT_13)); SetEthPhyBit(sc, 0x10, BIT_12); SetEthPhyBit(sc, 0x10, BIT_1); SetEthPhyBit(sc, 0x10, BIT_0); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0A43); MP_WritePhyUshort(sc, 0x13, 0x8012); SetEthPhyBit(sc, 0x14, BIT_15); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0C42); ClearAndSetEthPhyBit(sc, 0x11, BIT_13, BIT_14 ); 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, 0x8011); ClearEthPhyBit(sc, 0x14, BIT_14); MP_WritePhyUshort(sc, 0x1F, 0x0A40); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x00, 0x9200); } else if (sc->re_type == MACFG_59) { MP_WritePhyUshort(sc, 0x1F, 0x0BCC); ClearEthPhyBit(sc, 0x14, BIT_8); MP_WritePhyUshort(sc, 0x1F, 0x0A44); SetEthPhyBit(sc, 0x11, BIT_7); SetEthPhyBit(sc, 0x11, BIT_6); MP_WritePhyUshort(sc, 0x1F, 0x0A43); MP_WritePhyUshort(sc, 0x13, 0x8084); ClearEthPhyBit(sc, 0x14, (BIT_14 | BIT_13)); SetEthPhyBit(sc, 0x10, BIT_12); SetEthPhyBit(sc, 0x10, BIT_1); SetEthPhyBit(sc, 0x10, BIT_0); MP_WritePhyUshort(sc, 0x1F, 0x0A43); MP_WritePhyUshort(sc, 0x13, 0x8012); SetEthPhyBit(sc, 0x14, BIT_15); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0BCE); MP_WritePhyUshort(sc, 0x12, 0x8860); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0A43); MP_WritePhyUshort(sc, 0x13, 0x80F3); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x8B00 ); MP_WritePhyUshort(sc, 0x13, 0x80F0); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x3A00 ); MP_WritePhyUshort(sc, 0x13, 0x80EF); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x0500 ); MP_WritePhyUshort(sc, 0x13, 0x80F6); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x6E00 ); MP_WritePhyUshort(sc, 0x13, 0x80EC); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x6800 ); MP_WritePhyUshort(sc, 0x13, 0x80ED); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x7C00 ); MP_WritePhyUshort(sc, 0x13, 0x80F2); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0xF400 ); MP_WritePhyUshort(sc, 0x13, 0x80F4); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x8500 ); MP_WritePhyUshort(sc, 0x1F, 0x0A43); MP_WritePhyUshort(sc, 0x13, 0x8110); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0xA800 ); MP_WritePhyUshort(sc, 0x13, 0x810F); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x1D00 ); MP_WritePhyUshort(sc, 0x13, 0x8111); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0xF500 ); MP_WritePhyUshort(sc, 0x13, 0x8113); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x6100 ); MP_WritePhyUshort(sc, 0x13, 0x8115); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x9200 ); MP_WritePhyUshort(sc, 0x13, 0x810E); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x0400 ); MP_WritePhyUshort(sc, 0x13, 0x810C); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x7C00 ); MP_WritePhyUshort(sc, 0x13, 0x810B); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x5A00 ); MP_WritePhyUshort(sc, 0x1F, 0x0A43); MP_WritePhyUshort(sc, 0x13, 0x80D1); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0xFF00 ); MP_WritePhyUshort(sc, 0x13, 0x80CD); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x9E00 ); MP_WritePhyUshort(sc, 0x13, 0x80D3); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x0E00 ); MP_WritePhyUshort(sc, 0x13, 0x80D5); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0xCA00 ); MP_WritePhyUshort(sc, 0x13, 0x80D7); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x8400 ); 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, 0x8011); ClearEthPhyBit(sc, 0x14, BIT_14); MP_WritePhyUshort(sc, 0x1F, 0x0A40); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x00, 0x9200); } else if (sc->re_type == MACFG_60) { MP_WritePhyUshort(sc, 0x1F, 0x0A43); MP_WritePhyUshort(sc, 0x13, 0x8012); SetEthPhyBit(sc, 0x14, BIT_15); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0BCE); MP_WritePhyUshort(sc, 0x12, 0x8860); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0A43); MP_WritePhyUshort(sc, 0x13, 0x80F3); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x8B00 ); MP_WritePhyUshort(sc, 0x13, 0x80F0); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x3A00 ); MP_WritePhyUshort(sc, 0x13, 0x80EF); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x0500 ); MP_WritePhyUshort(sc, 0x13, 0x80F6); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x6E00 ); MP_WritePhyUshort(sc, 0x13, 0x80EC); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x6800 ); MP_WritePhyUshort(sc, 0x13, 0x80ED); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x7C00 ); MP_WritePhyUshort(sc, 0x13, 0x80F2); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0xF400 ); MP_WritePhyUshort(sc, 0x13, 0x80F4); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x8500 ); MP_WritePhyUshort(sc, 0x1F, 0x0A43); MP_WritePhyUshort(sc, 0x13, 0x8110); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0xA800 ); MP_WritePhyUshort(sc, 0x13, 0x810F); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x1D00 ); MP_WritePhyUshort(sc, 0x13, 0x8111); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0xF500 ); MP_WritePhyUshort(sc, 0x13, 0x8113); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x6100 ); MP_WritePhyUshort(sc, 0x13, 0x8115); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x9200 ); MP_WritePhyUshort(sc, 0x13, 0x810E); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x0400 ); MP_WritePhyUshort(sc, 0x13, 0x810C); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x7C00 ); MP_WritePhyUshort(sc, 0x13, 0x810B); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x5A00 ); MP_WritePhyUshort(sc, 0x1F, 0x0A43); MP_WritePhyUshort(sc, 0x13, 0x80D1); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0xFF00 ); MP_WritePhyUshort(sc, 0x13, 0x80CD); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x9E00 ); MP_WritePhyUshort(sc, 0x13, 0x80D3); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x0E00 ); MP_WritePhyUshort(sc, 0x13, 0x80D5); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0xCA00 ); MP_WritePhyUshort(sc, 0x13, 0x80D7); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x8400 ); 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, 0x8011); ClearEthPhyBit(sc, 0x14, BIT_14); MP_WritePhyUshort(sc, 0x1F, 0x0A40); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x00, 0x9200); } else if (sc->re_type == MACFG_61) { MP_WritePhyUshort(sc, 0x1F, 0x0A44); SetEthPhyBit(sc, 0x11, (BIT_3 | BIT_2)); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0BCC); ClearEthPhyBit(sc, 0x14, BIT_8); MP_WritePhyUshort(sc, 0x1F, 0x0A44); SetEthPhyBit(sc, 0x11, BIT_7); SetEthPhyBit(sc, 0x11, BIT_6); MP_WritePhyUshort(sc, 0x1F, 0x0A43); MP_WritePhyUshort(sc, 0x13, 0x8084); ClearEthPhyBit(sc, 0x14, (BIT_14 | BIT_13)); SetEthPhyBit(sc, 0x10, BIT_12); SetEthPhyBit(sc, 0x10, BIT_1); SetEthPhyBit(sc, 0x10, BIT_0); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0A4B); SetEthPhyBit(sc, 0x11, BIT_2); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0A43); MP_WritePhyUshort(sc, 0x13, 0x8012); SetEthPhyBit(sc, 0x14, BIT_15); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0C42); ClearAndSetEthPhyBit(sc, 0x11, BIT_13, BIT_14 ); 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, 0x8011); ClearEthPhyBit(sc, 0x14, BIT_14); MP_WritePhyUshort(sc, 0x1F, 0x0A40); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x00, 0x9200); } else if (sc->re_type == MACFG_62 || sc->re_type == MACFG_67) { MP_WritePhyUshort(sc, 0x1F, 0x0BCC); ClearEthPhyBit(sc, 0x14, BIT_8); MP_WritePhyUshort(sc, 0x1F, 0x0A44); SetEthPhyBit(sc, 0x11, BIT_7); SetEthPhyBit(sc, 0x11, BIT_6); MP_WritePhyUshort(sc, 0x1F, 0x0A43); MP_WritePhyUshort(sc, 0x13, 0x8084); ClearEthPhyBit(sc, 0x14, (BIT_14 | BIT_13)); SetEthPhyBit(sc, 0x10, BIT_12); SetEthPhyBit(sc, 0x10, BIT_1); SetEthPhyBit(sc, 0x10, BIT_0); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0A43); MP_WritePhyUshort(sc, 0x13, 0x8012); SetEthPhyBit(sc, 0x14, BIT_15); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0C42); ClearAndSetEthPhyBit(sc, 0x11, BIT_13, BIT_14 ); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0A43); MP_WritePhyUshort(sc, 0x13, 0x80F3); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x8B00 ); MP_WritePhyUshort(sc, 0x13, 0x80F0); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x3A00 ); MP_WritePhyUshort(sc, 0x13, 0x80EF); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x0500 ); MP_WritePhyUshort(sc, 0x13, 0x80F6); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x6E00 ); MP_WritePhyUshort(sc, 0x13, 0x80EC); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x6800 ); MP_WritePhyUshort(sc, 0x13, 0x80ED); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x7C00 ); MP_WritePhyUshort(sc, 0x13, 0x80F2); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0xF400 ); MP_WritePhyUshort(sc, 0x13, 0x80F4); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x8500 ); MP_WritePhyUshort(sc, 0x1F, 0x0A43); MP_WritePhyUshort(sc, 0x13, 0x8110); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0xA800 ); MP_WritePhyUshort(sc, 0x13, 0x810F); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x1D00 ); MP_WritePhyUshort(sc, 0x13, 0x8111); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0xF500 ); MP_WritePhyUshort(sc, 0x13, 0x8113); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x6100 ); MP_WritePhyUshort(sc, 0x13, 0x8115); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x9200 ); MP_WritePhyUshort(sc, 0x13, 0x810E); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x0400 ); MP_WritePhyUshort(sc, 0x13, 0x810C); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x7C00 ); MP_WritePhyUshort(sc, 0x13, 0x810B); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x5A00 ); MP_WritePhyUshort(sc, 0x1F, 0x0A43); MP_WritePhyUshort(sc, 0x13, 0x80D1); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0xFF00 ); MP_WritePhyUshort(sc, 0x13, 0x80CD); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x9E00 ); MP_WritePhyUshort(sc, 0x13, 0x80D3); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x0E00 ); MP_WritePhyUshort(sc, 0x13, 0x80D5); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0xCA00 ); MP_WritePhyUshort(sc, 0x13, 0x80D7); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x8400 ); 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, 0x8011); ClearEthPhyBit(sc, 0x14, BIT_14); MP_WritePhyUshort(sc, 0x1F, 0x0A40); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x00, 0x9200); } else if (sc->re_type == MACFG_63) { MP_WritePhyUshort(sc, 0x1f, 0x0002); MP_WritePhyUshort(sc, 0x10, 0x0008); MP_WritePhyUshort(sc, 0x0d, 0x006c); MP_WritePhyUshort(sc, 0x1f, 0x0000); MP_WritePhyUshort(sc, 0x1f, 0x0001); MP_WritePhyUshort(sc, 0x17, 0x0cc0); MP_WritePhyUshort(sc, 0x1f, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0001); MP_WritePhyUshort(sc, 0x0B, 0xA4D8); MP_WritePhyUshort(sc, 0x09, 0x281C); MP_WritePhyUshort(sc, 0x07, 0x2883); MP_WritePhyUshort(sc, 0x0A, 0x6B35); MP_WritePhyUshort(sc, 0x1D, 0x3DA4); MP_WritePhyUshort(sc, 0x1C, 0xEFFD); MP_WritePhyUshort(sc, 0x14, 0x7F52); MP_WritePhyUshort(sc, 0x18, 0x7FC6); MP_WritePhyUshort(sc, 0x08, 0x0601); MP_WritePhyUshort(sc, 0x06, 0x4063); MP_WritePhyUshort(sc, 0x10, 0xF074); MP_WritePhyUshort(sc, 0x1F, 0x0003); MP_WritePhyUshort(sc, 0x13, 0x0789); MP_WritePhyUshort(sc, 0x12, 0xF4BD); MP_WritePhyUshort(sc, 0x1A, 0x04FD); MP_WritePhyUshort(sc, 0x14, 0x84B0); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0005); MP_WritePhyUshort(sc, 0x01, 0x0340); MP_WritePhyUshort(sc, 0x1F, 0x0001); MP_WritePhyUshort(sc, 0x04, 0x4000); MP_WritePhyUshort(sc, 0x03, 0x1D21); MP_WritePhyUshort(sc, 0x02, 0x0C32); MP_WritePhyUshort(sc, 0x01, 0x0200); MP_WritePhyUshort(sc, 0x00, 0x5554); MP_WritePhyUshort(sc, 0x04, 0x4800); MP_WritePhyUshort(sc, 0x04, 0x4000); MP_WritePhyUshort(sc, 0x04, 0xF000); MP_WritePhyUshort(sc, 0x03, 0xDF01); MP_WritePhyUshort(sc, 0x02, 0xDF20); MP_WritePhyUshort(sc, 0x01, 0x101A); MP_WritePhyUshort(sc, 0x00, 0xA0FF); MP_WritePhyUshort(sc, 0x04, 0xF800); MP_WritePhyUshort(sc, 0x04, 0xF000); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0007); MP_WritePhyUshort(sc, 0x1E, 0x0023); MP_WritePhyUshort(sc, 0x16, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0000); PhyRegValue = MP_ReadPhyUshort(sc, 0x0D); PhyRegValue |= (BIT_5); MP_WritePhyUshort(sc, 0x0D, PhyRegValue); MP_WritePhyUshort(sc, 0x1F, 0x0002); PhyRegValue = MP_ReadPhyUshort(sc, 0x0C); PhyRegValue |= (BIT_10); MP_WritePhyUshort(sc, 0x0C, PhyRegValue); MP_WritePhyUshort(sc, 0x1F, 0x0000); } else if (sc->re_type == MACFG_64) { MP_WritePhyUshort(sc, 0x1f, 0x0001); MP_WritePhyUshort(sc, 0x17, 0x0cc0); MP_WritePhyUshort(sc, 0x1f, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0005); MP_WritePhyUshort(sc, 0x01, 0x0340); MP_WritePhyUshort(sc, 0x1F, 0x0001); MP_WritePhyUshort(sc, 0x04, 0x4000); MP_WritePhyUshort(sc, 0x03, 0x1D21); MP_WritePhyUshort(sc, 0x02, 0x0C32); MP_WritePhyUshort(sc, 0x01, 0x0200); MP_WritePhyUshort(sc, 0x00, 0x5554); MP_WritePhyUshort(sc, 0x04, 0x4800); MP_WritePhyUshort(sc, 0x04, 0x4000); MP_WritePhyUshort(sc, 0x04, 0xF000); MP_WritePhyUshort(sc, 0x03, 0xDF01); MP_WritePhyUshort(sc, 0x02, 0xDF20); MP_WritePhyUshort(sc, 0x01, 0x101A); MP_WritePhyUshort(sc, 0x00, 0xA0FF); MP_WritePhyUshort(sc, 0x04, 0xF800); MP_WritePhyUshort(sc, 0x04, 0xF000); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0007); MP_WritePhyUshort(sc, 0x1E, 0x0023); MP_WritePhyUshort(sc, 0x16, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0000); PhyRegValue = MP_ReadPhyUshort(sc, 0x0D); PhyRegValue |= (BIT_5); MP_WritePhyUshort(sc, 0x0D, PhyRegValue); MP_WritePhyUshort(sc, 0x1F, 0x0002); PhyRegValue = MP_ReadPhyUshort(sc, 0x0C); PhyRegValue |= (BIT_10); MP_WritePhyUshort(sc, 0x0C, PhyRegValue); MP_WritePhyUshort(sc, 0x1F, 0x0000); } else if (sc->re_type == MACFG_65) { MP_WritePhyUshort(sc, 0x1f, 0x0001); MP_WritePhyUshort(sc, 0x17, 0x0cc0); MP_WritePhyUshort(sc, 0x1f, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0000); PhyRegValue = MP_ReadPhyUshort(sc, 0x0D); PhyRegValue |= (BIT_5); MP_WritePhyUshort(sc, 0x0D, PhyRegValue); MP_WritePhyUshort(sc, 0x1F, 0x0002); PhyRegValue = MP_ReadPhyUshort(sc, 0x0C); PhyRegValue |= (BIT_10); MP_WritePhyUshort(sc, 0x0C, PhyRegValue); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0007); MP_WritePhyUshort(sc, 0x1E, 0x002C); MP_WritePhyUshort(sc, 0x15, 0x035D); MP_WritePhyUshort(sc, 0x1F, 0x0005); MP_WritePhyUshort(sc, 0x01, 0x0300); MP_WritePhyUshort(sc, 0x1F, 0x0000); } else if (sc->re_type == MACFG_66) { MP_WritePhyUshort(sc, 0x1F, 0x0000); PhyRegValue = MP_ReadPhyUshort(sc, 0x0D); PhyRegValue |= (BIT_5); MP_WritePhyUshort(sc, 0x0D, PhyRegValue); MP_WritePhyUshort(sc, 0x1F, 0x0002); PhyRegValue = MP_ReadPhyUshort(sc, 0x0C); PhyRegValue |= (BIT_10); MP_WritePhyUshort(sc, 0x0C, PhyRegValue); MP_WritePhyUshort(sc, 0x1F, 0x0000); } else if (sc->re_type == MACFG_68) { MP_WritePhyUshort(sc, 0x1F, 0x0A43); MP_WritePhyUshort(sc, 0x13, 0x809b); ClearAndSetEthPhyBit(sc, 0x14, 0xF800, 0x8000 ); MP_WritePhyUshort(sc, 0x13, 0x80A2); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x8000 ); MP_WritePhyUshort(sc, 0x13, 0x80A4); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x8500 ); MP_WritePhyUshort(sc, 0x13, 0x809C); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0xbd00 ); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0A43); MP_WritePhyUshort(sc, 0x13, 0x80AD); ClearAndSetEthPhyBit(sc, 0x14, 0xF800, 0x7000 ); MP_WritePhyUshort(sc, 0x13, 0x80B4); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x5000 ); MP_WritePhyUshort(sc, 0x13, 0x80AC); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x4000 ); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0A43); MP_WritePhyUshort(sc, 0x13, 0x808E); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x1200 ); MP_WritePhyUshort(sc, 0x13, 0x8090); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0xE500 ); MP_WritePhyUshort(sc, 0x13, 0x8092); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x9F00 ); MP_WritePhyUshort(sc, 0x1F, 0x0000); dout_tapbin = 0x0000; MP_WritePhyUshort(sc, 0x1F, 0x0A46); TmpUshort = MP_ReadPhyUshort(sc, 0x13); TmpUshort &= (BIT_1|BIT_0); TmpUshort <<= 2; dout_tapbin |= TmpUshort; TmpUshort = MP_ReadPhyUshort(sc, 0x12); TmpUshort &= (BIT_15|BIT_14); TmpUshort >>= 14; dout_tapbin |= TmpUshort; dout_tapbin = ~(dout_tapbin^BIT_3); dout_tapbin <<= 12; dout_tapbin &= 0xF000; MP_WritePhyUshort(sc, 0x1F, 0x0A43); MP_WritePhyUshort(sc, 0x13, 0x827A); ClearAndSetEthPhyBit(sc, 0x14, BIT_15|BIT_14|BIT_13|BIT_12, dout_tapbin ); MP_WritePhyUshort(sc, 0x13, 0x827B); ClearAndSetEthPhyBit(sc, 0x14, BIT_15|BIT_14|BIT_13|BIT_12, dout_tapbin ); MP_WritePhyUshort(sc, 0x13, 0x827C); ClearAndSetEthPhyBit(sc, 0x14, BIT_15|BIT_14|BIT_13|BIT_12, dout_tapbin ); MP_WritePhyUshort(sc, 0x13, 0x827D); ClearAndSetEthPhyBit(sc, 0x14, BIT_15|BIT_14|BIT_13|BIT_12, dout_tapbin ); 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); MP_WritePhyUshort(sc, 0x1F, 0x0BCA); ClearAndSetEthPhyBit(sc, 0x17, (BIT_13 | BIT_12), BIT_14 ); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0A43); MP_WritePhyUshort(sc, 0x13, 0x803F); ClearEthPhyBit(sc, 0x14, (BIT_13 | BIT_12)); MP_WritePhyUshort(sc, 0x13, 0x8047); ClearEthPhyBit(sc, 0x14, (BIT_13 | BIT_12)); MP_WritePhyUshort(sc, 0x13, 0x804F); ClearEthPhyBit(sc, 0x14, (BIT_13 | BIT_12)); MP_WritePhyUshort(sc, 0x13, 0x8057); ClearEthPhyBit(sc, 0x14, (BIT_13 | BIT_12)); MP_WritePhyUshort(sc, 0x13, 0x805F); ClearEthPhyBit(sc, 0x14, (BIT_13 | BIT_12)); MP_WritePhyUshort(sc, 0x13, 0x8067); ClearEthPhyBit(sc, 0x14, (BIT_13 | BIT_12)); MP_WritePhyUshort(sc, 0x13, 0x806F); ClearEthPhyBit(sc, 0x14, (BIT_13 | BIT_12)); 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); } else if (sc->re_type == MACFG_69) { MP_WritePhyUshort(sc, 0x1F, 0x0A43); MP_WritePhyUshort(sc, 0x13, 0x808A); ClearAndSetEthPhyBit(sc, 0x14, BIT_5 | BIT_4 | BIT_3 | BIT_2 | BIT_1 | BIT_0, 0x0A); 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 (sc->RequireAdcBiasPatch) { MP_WritePhyUshort(sc, 0x1F, 0x0BCF); MP_WritePhyUshort(sc, 0x16, sc->AdcBiasPatchIoffset); MP_WritePhyUshort(sc, 0x1F, 0x0000); } { u_int16_t rlen; MP_WritePhyUshort(sc, 0x1F, 0x0BCD); PhyRegValue = MP_ReadPhyUshort(sc, 0x16); PhyRegValue &= 0x000F; if (PhyRegValue > 3) { rlen = PhyRegValue - 3; } else { rlen = 0; } PhyRegValue = rlen | (rlen<<4) | (rlen<<8) | (rlen<<12); MP_WritePhyUshort(sc, 0x1F, 0x0BCD); MP_WritePhyUshort(sc, 0x17, PhyRegValue); 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, 0x85FE); ClearAndSetEthPhyBit( sc, 0x14, BIT_15|BIT_14|BIT_13|BIT_12|BIT_11|BIT_10|BIT_8, BIT_9); MP_WritePhyUshort(sc, 0x13, 0x85FF); ClearAndSetEthPhyBit( sc, 0x14, BIT_15|BIT_14|BIT_13|BIT_12, BIT_11|BIT_10|BIT_9|BIT_8); MP_WritePhyUshort(sc, 0x13, 0x814B); ClearAndSetEthPhyBit( sc, 0x14, BIT_15|BIT_14|BIT_13|BIT_11|BIT_10|BIT_9|BIT_8, BIT_12); MP_WritePhyUshort(sc, 0x1F, 0x0A43); MP_WritePhyUshort(sc, 0x13, 0x8045); MP_WritePhyUshort(sc, 0x14, 0x2444); MP_WritePhyUshort(sc, 0x13, 0x804d); MP_WritePhyUshort(sc, 0x14, 0x2444); MP_WritePhyUshort(sc, 0x13, 0x805d); MP_WritePhyUshort(sc, 0x14, 0x2444); MP_WritePhyUshort(sc, 0x13, 0x8011); SetEthPhyBit(sc, 0x14, BIT_15); MP_WritePhyUshort(sc, 0x1F, 0x0A40); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x00, 0x9200); } else if (sc->re_type == MACFG_70 || sc->re_type == MACFG_71 || sc->re_type == MACFG_72) { MP_WritePhyUshort(sc, 0x1F, 0x0A43); MP_WritePhyUshort(sc, 0x13, 0x808E); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x4800); 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, 0x6000); MP_WritePhyUshort(sc, 0x13, 0x808B); ClearAndSetEthPhyBit(sc, 0x14, BIT_13|BIT_12|BIT_11|BIT_10|BIT_9|BIT_8, 0x0B00); MP_WritePhyUshort(sc, 0x13, 0x808D); ClearAndSetEthPhyBit(sc, 0x14, BIT_12|BIT_11|BIT_10|BIT_9|BIT_8, 0x0600); MP_WritePhyUshort(sc, 0x13, 0x808C); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0xB000); MP_WritePhyUshort(sc, 0x13, 0x80A0); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x2800); MP_WritePhyUshort(sc, 0x13, 0x80A2); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x5000); MP_WritePhyUshort(sc, 0x13, 0x809B); ClearAndSetEthPhyBit(sc, 0x14, BIT_15|BIT_14|BIT_13|BIT_12|BIT_11, BIT_15|BIT_13|BIT_12); MP_WritePhyUshort(sc, 0x13, 0x809A); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x4B00); MP_WritePhyUshort(sc, 0x13, 0x809D); ClearAndSetEthPhyBit(sc, 0x14, BIT_13|BIT_12|BIT_11|BIT_10|BIT_9|BIT_8, 0x0800); MP_WritePhyUshort(sc, 0x13, 0x80A1); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x7000); MP_WritePhyUshort(sc, 0x13, 0x809F); ClearAndSetEthPhyBit(sc, 0x14, BIT_12|BIT_11|BIT_10|BIT_9|BIT_8, 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, BIT_15|BIT_14|BIT_13|BIT_12|BIT_11, BIT_15|BIT_12|BIT_11); MP_WritePhyUshort(sc, 0x13, 0x80AF); ClearAndSetEthPhyBit(sc, 0x14, BIT_13|BIT_12|BIT_11|BIT_10|BIT_9|BIT_8, 0x0800); MP_WritePhyUshort(sc, 0x13, 0x80B3); ClearAndSetEthPhyBit(sc, 0x14, 0xFF00, 0x6F00); MP_WritePhyUshort(sc, 0x13, 0x80B1); ClearAndSetEthPhyBit(sc, 0x14, BIT_12|BIT_11|BIT_10|BIT_9|BIT_8, 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, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0A44); SetEthPhyBit( sc, 0x11, BIT_11 ); MP_WritePhyUshort(sc, 0x1F, 0x0000); MP_WritePhyUshort(sc, 0x1F, 0x0A43); MP_WritePhyUshort(sc, 0x13, 0x8016); SetEthPhyBit(sc, 0x14, BIT_10); MP_WritePhyUshort(sc, 0x1F, 0x0000); if (phy_power_saving == 1 && !HW_SUPP_SERDES_PHY(sc)) { 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); } else if (sc->re_type == MACFG_80) { ClearAndSetEthPhyOcpBit(sc, 0xAD40, 0x03FF, 0x84 ); SetEthPhyOcpBit(sc, 0xAD4E, BIT_4); ClearAndSetEthPhyOcpBit(sc, 0xAD16, 0x03FF, 0x0006 ); ClearAndSetEthPhyOcpBit(sc, 0xAD32, 0x003F, 0x0006 ); ClearEthPhyOcpBit(sc, 0xAC08, BIT_12); ClearEthPhyOcpBit(sc, 0xAC08, BIT_8); ClearAndSetEthPhyOcpBit(sc, 0xAC8A, BIT_15|BIT_14|BIT_13|BIT_12, BIT_14|BIT_13|BIT_12 ); SetEthPhyOcpBit(sc, 0xAD18, BIT_10); SetEthPhyOcpBit(sc, 0xAD1A, 0x3FF); SetEthPhyOcpBit(sc, 0xAD1C, 0x3FF); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x80EA); ClearAndSetEthPhyOcpBit(sc, 0xA438, 0xFF00, 0xC400 ); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x80EB); ClearAndSetEthPhyOcpBit(sc, 0xA438, 0x0700, 0x0300 ); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x80F8); ClearAndSetEthPhyOcpBit(sc, 0xA438, 0xFF00, 0x1C00 ); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x80F1); ClearAndSetEthPhyOcpBit(sc, 0xA438, 0xFF00, 0x3000 ); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x80FE); ClearAndSetEthPhyOcpBit(sc, 0xA438, 0xFF00, 0xA500 ); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x8102); ClearAndSetEthPhyOcpBit(sc, 0xA438, 0xFF00, 0x5000 ); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x8105); ClearAndSetEthPhyOcpBit(sc, 0xA438, 0xFF00, 0x3300 ); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x8100); ClearAndSetEthPhyOcpBit(sc, 0xA438, 0xFF00, 0x7000 ); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x8104); ClearAndSetEthPhyOcpBit(sc, 0xA438, 0xFF00, 0xF000 ); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x8106); ClearAndSetEthPhyOcpBit(sc, 0xA438, 0xFF00, 0x6500 ); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x80DC); ClearAndSetEthPhyOcpBit(sc, 0xA438, 0xFF00, 0xED00 ); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x80DF); SetEthPhyOcpBit(sc, 0xA438, BIT_8); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x80E1); ClearEthPhyOcpBit(sc, 0xA438, BIT_8); ClearAndSetEthPhyOcpBit(sc, 0xBF06, 0x003F, 0x38 ); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x819F); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xD0B6); MP_RealWritePhyOcpRegWord(sc, 0xBC34, 0x5555); ClearAndSetEthPhyOcpBit(sc, 0xBF0A, BIT_11|BIT_10|BIT_9, BIT_11|BIT_9 ); ClearEthPhyOcpBit(sc, 0xA5C0, BIT_10); SetEthPhyOcpBit(sc, 0xA442, BIT_11); if (phy_power_saving == 1) { SetEthPhyOcpBit(sc, 0xA430, BIT_2); } else { ClearEthPhyOcpBit(sc, 0xA430, BIT_2); DELAY(20000); } } else if (sc->re_type == MACFG_81) { SetEthPhyOcpBit(sc, 0xAD4E, BIT_4); ClearAndSetEthPhyOcpBit(sc, 0xAD16, 0x03FF, 0x03FF ); ClearAndSetEthPhyOcpBit(sc, 0xAD32, 0x003F, 0x0006 ); ClearEthPhyOcpBit(sc, 0xAC08, BIT_12); ClearEthPhyOcpBit(sc, 0xAC08, BIT_8); ClearAndSetEthPhyOcpBit(sc, 0xACC0, BIT_1|BIT_0, BIT_1 ); ClearAndSetEthPhyOcpBit(sc, 0xAD40, BIT_7|BIT_6|BIT_5, BIT_6 ); ClearAndSetEthPhyOcpBit(sc, 0xAD40, BIT_2|BIT_1|BIT_0, BIT_2 ); ClearEthPhyOcpBit(sc, 0xAC14, BIT_7); ClearEthPhyOcpBit(sc, 0xAC80, BIT_9|BIT_8); ClearAndSetEthPhyOcpBit(sc, 0xAC5E, BIT_2|BIT_1|BIT_0, BIT_1 ); MP_RealWritePhyOcpRegWord(sc, 0xAD4C, 0x00A8); MP_RealWritePhyOcpRegWord(sc, 0xAC5C, 0x01FF); ClearAndSetEthPhyOcpBit(sc, 0xAC8A, BIT_7|BIT_6|BIT_5|BIT_4, BIT_5|BIT_4 ); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x8157); ClearAndSetEthPhyOcpBit(sc, 0xB87E, 0xFF00, 0x0500 ); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x8159); ClearAndSetEthPhyOcpBit(sc, 0xB87E, 0xFF00, 0x0700 ); CSR_WRITE_2(sc, RE_EEE_TXIDLE_TIMER_8125, ifp->if_mtu + ETHER_HDR_LEN + 0x20); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x80A2); MP_RealWritePhyOcpRegWord(sc, 0xB87E, 0x0153); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x809C); MP_RealWritePhyOcpRegWord(sc, 0xB87E, 0x0153); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x81B3); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0043); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x00A7); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x00D6); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x00EC); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x00F6); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x00FB); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x00FD); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x00FF); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x00BB); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0058); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0029); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0013); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0009); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0004); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0002); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x8257); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x020F); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x80EA); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x7843); re_set_phy_mcu_patch_request(sc); ClearEthPhyOcpBit(sc, 0xB896, BIT_0); ClearEthPhyOcpBit(sc, 0xB892, 0xFF00); MP_RealWritePhyOcpRegWord(sc, 0xB88E, 0xC091); MP_RealWritePhyOcpRegWord(sc, 0xB890, 0x6E12); MP_RealWritePhyOcpRegWord(sc, 0xB88E, 0xC092); MP_RealWritePhyOcpRegWord(sc, 0xB890, 0x1214); MP_RealWritePhyOcpRegWord(sc, 0xB88E, 0xC094); MP_RealWritePhyOcpRegWord(sc, 0xB890, 0x1516); MP_RealWritePhyOcpRegWord(sc, 0xB88E, 0xC096); MP_RealWritePhyOcpRegWord(sc, 0xB890, 0x171B); MP_RealWritePhyOcpRegWord(sc, 0xB88E, 0xC098); MP_RealWritePhyOcpRegWord(sc, 0xB890, 0x1B1C); MP_RealWritePhyOcpRegWord(sc, 0xB88E, 0xC09A); MP_RealWritePhyOcpRegWord(sc, 0xB890, 0x1F1F); MP_RealWritePhyOcpRegWord(sc, 0xB88E, 0xC09C); MP_RealWritePhyOcpRegWord(sc, 0xB890, 0x2021); MP_RealWritePhyOcpRegWord(sc, 0xB88E, 0xC09E); MP_RealWritePhyOcpRegWord(sc, 0xB890, 0x2224); MP_RealWritePhyOcpRegWord(sc, 0xB88E, 0xC0A0); MP_RealWritePhyOcpRegWord(sc, 0xB890, 0x2424); MP_RealWritePhyOcpRegWord(sc, 0xB88E, 0xC0A2); MP_RealWritePhyOcpRegWord(sc, 0xB890, 0x2424); MP_RealWritePhyOcpRegWord(sc, 0xB88E, 0xC0A4); MP_RealWritePhyOcpRegWord(sc, 0xB890, 0x2424); MP_RealWritePhyOcpRegWord(sc, 0xB88E, 0xC018); MP_RealWritePhyOcpRegWord(sc, 0xB890, 0x0AF2); MP_RealWritePhyOcpRegWord(sc, 0xB88E, 0xC01A); MP_RealWritePhyOcpRegWord(sc, 0xB890, 0x0D4A); MP_RealWritePhyOcpRegWord(sc, 0xB88E, 0xC01C); MP_RealWritePhyOcpRegWord(sc, 0xB890, 0x0F26); MP_RealWritePhyOcpRegWord(sc, 0xB88E, 0xC01E); MP_RealWritePhyOcpRegWord(sc, 0xB890, 0x118D); MP_RealWritePhyOcpRegWord(sc, 0xB88E, 0xC020); MP_RealWritePhyOcpRegWord(sc, 0xB890, 0x14F3); MP_RealWritePhyOcpRegWord(sc, 0xB88E, 0xC022); MP_RealWritePhyOcpRegWord(sc, 0xB890, 0x175A); MP_RealWritePhyOcpRegWord(sc, 0xB88E, 0xC024); MP_RealWritePhyOcpRegWord(sc, 0xB890, 0x19C0); MP_RealWritePhyOcpRegWord(sc, 0xB88E, 0xC026); MP_RealWritePhyOcpRegWord(sc, 0xB890, 0x1C26); MP_RealWritePhyOcpRegWord(sc, 0xB88E, 0xC089); MP_RealWritePhyOcpRegWord(sc, 0xB890, 0x6050); MP_RealWritePhyOcpRegWord(sc, 0xB88E, 0xC08A); MP_RealWritePhyOcpRegWord(sc, 0xB890, 0x5F6E); MP_RealWritePhyOcpRegWord(sc, 0xB88E, 0xC08C); MP_RealWritePhyOcpRegWord(sc, 0xB890, 0x6E6E); MP_RealWritePhyOcpRegWord(sc, 0xB88E, 0xC08E); MP_RealWritePhyOcpRegWord(sc, 0xB890, 0x6E6E); MP_RealWritePhyOcpRegWord(sc, 0xB88E, 0xC090); MP_RealWritePhyOcpRegWord(sc, 0xB890, 0x6E12); SetEthPhyOcpBit(sc, 0xB896, BIT_0); re_clear_phy_mcu_patch_request(sc); SetEthPhyOcpBit(sc, 0xD068, BIT_13); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x81A2); SetEthPhyOcpBit(sc, 0xA438, BIT_8); ClearAndSetEthPhyOcpBit(sc, 0xB54C, 0xFF00, 0xDB00); ClearEthPhyOcpBit(sc, 0xA454, BIT_0); SetEthPhyOcpBit(sc, 0xA5D4, BIT_5); ClearEthPhyOcpBit(sc, 0xAD4E, BIT_4); ClearEthPhyOcpBit(sc, 0xA86A, BIT_0); SetEthPhyOcpBit(sc, 0xA442, BIT_11); if (sc->RequirePhyMdiSwapPatch) { u_int16_t adccal_offset_p0; u_int16_t adccal_offset_p1; u_int16_t adccal_offset_p2; u_int16_t adccal_offset_p3; u_int16_t rg_lpf_cap_xg_p0; u_int16_t rg_lpf_cap_xg_p1; u_int16_t rg_lpf_cap_xg_p2; u_int16_t rg_lpf_cap_xg_p3; u_int16_t rg_lpf_cap_p0; u_int16_t rg_lpf_cap_p1; u_int16_t rg_lpf_cap_p2; u_int16_t rg_lpf_cap_p3; // GPHY OCP 0xD068 bit[2:0] = 0x1 ([2:1]:subadc,[0]:offset) // GPHY OCP 0xD068 bit[4:3] = 0x0 (p0) // adccal_offset_p0 = GPHY OCP 0xD06A bit[10:0] // GPHY OCP 0xD068 bit[4:3] = 0x1 (p1) // adccal_offset_p1 = GPHY OCP 0xD06A bit[10:0] // GPHY OCP 0xD068 bit[4:3] = 0x2 (p2) // adccal_offset_p2 = GPHY OCP 0xD06A bit[10:0] // GPHY OCP 0xD068 bit[4:3] = 0x3 (p3) // adccal_offset_p3 = GPHY OCP 0xD06A bit[10:0] ClearAndSetEthPhyOcpBit(sc, 0xD068, 0x0007, 0x0001 ); ClearAndSetEthPhyOcpBit(sc, 0xD068, 0x0018, 0x0000 ); adccal_offset_p0 = MP_RealReadPhyOcpRegWord(sc, 0xD06A); adccal_offset_p0 &= 0x07FF; ClearAndSetEthPhyOcpBit(sc, 0xD068, 0x0018, 0x0008 ); adccal_offset_p1 = MP_RealReadPhyOcpRegWord(sc, 0xD06A); adccal_offset_p1 &= 0x07FF; ClearAndSetEthPhyOcpBit(sc, 0xD068, 0x0018, 0x0010 ); adccal_offset_p2 = MP_RealReadPhyOcpRegWord(sc, 0xD06A); adccal_offset_p2 &= 0x07FF; ClearAndSetEthPhyOcpBit(sc, 0xD068, 0x0018, 0x0018 ); adccal_offset_p3 = MP_RealReadPhyOcpRegWord(sc, 0xD06A); adccal_offset_p3 &= 0x07FF; // GPHY OCP 0xD068 bit[4:3] = 0x0 (p0) // GPHY OCP 0xD06A bit[10:0] = adccal_offset_p3 // GPHY OCP 0xD068 bit[4:3] = 0x1 (p1) // GPHY OCP 0xD06A bit[10:0] = adccal_offset_p2 // GPHY OCP 0xD068 bit[4:3] = 0x2 (p2) // GPHY OCP 0xD06A bit[10:0] = adccal_offset_p1 // GPHY OCP 0xD068 bit[4:3] = 0x3 (p3) // GPHY OCP 0xD06A bit[10:0] = adccal_offset_p0 ClearAndSetEthPhyOcpBit(sc, 0xD068, 0x0018, 0x0000 ); ClearAndSetEthPhyOcpBit(sc, 0xD06A, 0x07FF, adccal_offset_p3 ); ClearAndSetEthPhyOcpBit(sc, 0xD068, 0x0018, 0x0008 ); ClearAndSetEthPhyOcpBit(sc, 0xD06A, 0x07FF, adccal_offset_p2 ); ClearAndSetEthPhyOcpBit(sc, 0xD068, 0x0018, 0x0010 ); ClearAndSetEthPhyOcpBit(sc, 0xD06A, 0x07FF, adccal_offset_p1 ); ClearAndSetEthPhyOcpBit(sc, 0xD068, 0x0018, 0x0018 ); ClearAndSetEthPhyOcpBit(sc, 0xD06A, 0x07FF, adccal_offset_p0 ); // rg_lpf_cap_xg_p0 = GPHY OCP 0xBD5A bit[4:0] // rg_lpf_cap_xg_p1 = GPHY OCP 0xBD5A bit[12:8] // rg_lpf_cap_xg_p2 = GPHY OCP 0xBD5C bit[4:0] // rg_lpf_cap_xg_p3 = GPHY OCP 0xBD5C bit[12:8] // rg_lpf_cap_p0 = GPHY OCP 0xBC18 bit[4:0] // rg_lpf_cap_p1 = GPHY OCP 0xBC18 bit[12:8] // rg_lpf_cap_p2 = GPHY OCP 0xBC1A bit[4:0] // rg_lpf_cap_p3 = GPHY OCP 0xBC1A bit[12:8] rg_lpf_cap_xg_p0 = MP_RealReadPhyOcpRegWord(sc, 0xBD5A); rg_lpf_cap_xg_p0 &= 0x001F; rg_lpf_cap_xg_p1 = MP_RealReadPhyOcpRegWord(sc, 0xBD5A); rg_lpf_cap_xg_p1 &= 0x1F00; rg_lpf_cap_xg_p2 = MP_RealReadPhyOcpRegWord(sc, 0xBD5C); rg_lpf_cap_xg_p2 &= 0x001F; rg_lpf_cap_xg_p3 = MP_RealReadPhyOcpRegWord(sc, 0xBD5C); rg_lpf_cap_xg_p3 &= 0x1F00; rg_lpf_cap_p0 = MP_RealReadPhyOcpRegWord(sc, 0xBC18); rg_lpf_cap_p0 &= 0x001F; rg_lpf_cap_p1 = MP_RealReadPhyOcpRegWord(sc, 0xBC18); rg_lpf_cap_p1 &= 0x1F00; rg_lpf_cap_p2 = MP_RealReadPhyOcpRegWord(sc, 0xBC1A); rg_lpf_cap_p2 &= 0x001F; rg_lpf_cap_p3 = MP_RealReadPhyOcpRegWord(sc, 0xBC1A); rg_lpf_cap_p3 &= 0x1F00; // GPHY OCP 0xBD5A bit[4:0] = rg_lpf_cap_xg_p3 // GPHY OCP 0xBD5A bit[12:8] = rg_lpf_cap_xg_p2 // GPHY OCP 0xBD5C bit[4:0] = rg_lpf_cap_xg_p1 // GPHY OCP 0xBD5C bit[12:8] = rg_lpf_cap_xg_p0 // GPHY OCP 0xBC18 bit[4:0] = rg_lpf_cap_p3 // GPHY OCP 0xBC18 bit[12:8] = rg_lpf_cap_p2 // GPHY OCP 0xBC1A bit[4:0] = rg_lpf_cap_p1 // GPHY OCP 0xBC1A bit[12:8] = rg_lpf_cap_p0 ClearAndSetEthPhyOcpBit(sc, 0xBD5A, 0x001F, rg_lpf_cap_xg_p3 >> 8 ); ClearAndSetEthPhyOcpBit(sc, 0xBD5A, 0x1F00, rg_lpf_cap_xg_p2 << 8 ); ClearAndSetEthPhyOcpBit(sc, 0xBD5C, 0x001F, rg_lpf_cap_xg_p1 >> 8 ); ClearAndSetEthPhyOcpBit(sc, 0xBD5C, 0x1F00, rg_lpf_cap_xg_p0 << 8 ); ClearAndSetEthPhyOcpBit(sc, 0xBC18, 0x001F, rg_lpf_cap_p3 >> 8 ); ClearAndSetEthPhyOcpBit(sc, 0xBC18, 0x1F00, rg_lpf_cap_p2 << 8 ); ClearAndSetEthPhyOcpBit(sc, 0xBC1A, 0x001F, rg_lpf_cap_p1 >> 8 ); ClearAndSetEthPhyOcpBit(sc, 0xBC1A, 0x1F00, rg_lpf_cap_p0 << 8 ); } if (phy_power_saving == 1) { SetEthPhyOcpBit(sc, 0xA430, BIT_2); } else { ClearEthPhyOcpBit(sc, 0xA430, BIT_2); DELAY(20000); } } else if (sc->re_type == MACFG_82) { SetEthPhyOcpBit(sc, 0xA442, BIT_11); SetEthPhyOcpBit(sc, 0xBC08, (BIT_3 | BIT_2)); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x8FFF); ClearAndSetEthPhyOcpBit(sc, 0xA438, 0xFF00, 0x0400 ); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x8560); MP_RealWritePhyOcpRegWord(sc, 0xB87E, 0x19CC); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x8562); MP_RealWritePhyOcpRegWord(sc, 0xB87E, 0x19CC); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x8564); MP_RealWritePhyOcpRegWord(sc, 0xB87E, 0x19CC); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x8566); MP_RealWritePhyOcpRegWord(sc, 0xB87E, 0x147D); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x8568); MP_RealWritePhyOcpRegWord(sc, 0xB87E, 0x147D); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x856A); MP_RealWritePhyOcpRegWord(sc, 0xB87E, 0x147D); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x8FFE); MP_RealWritePhyOcpRegWord(sc, 0xB87E, 0x0907); ClearAndSetEthPhyOcpBit(sc, 0xACDA, 0xFF00, 0xFF00 ); ClearAndSetEthPhyOcpBit(sc, 0xACDE, 0xF000, 0xF000 ); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x80D6); MP_RealWritePhyOcpRegWord(sc, 0xB87E, 0x2801); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x80F2); MP_RealWritePhyOcpRegWord(sc, 0xB87E, 0x2801); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x80F4); MP_RealWritePhyOcpRegWord(sc, 0xB87E, 0x6077); MP_RealWritePhyOcpRegWord(sc, 0xB506, 0x01E7); MP_RealWritePhyOcpRegWord(sc, 0xAC8C, 0x0FFC); MP_RealWritePhyOcpRegWord(sc, 0xAC46, 0xB7B4); MP_RealWritePhyOcpRegWord(sc, 0xAC50, 0x0FBC); MP_RealWritePhyOcpRegWord(sc, 0xAC3C, 0x9240); MP_RealWritePhyOcpRegWord(sc, 0xAC4E, 0x0DB4); MP_RealWritePhyOcpRegWord(sc, 0xACC6, 0x0707); MP_RealWritePhyOcpRegWord(sc, 0xACC8, 0xA0D3); MP_RealWritePhyOcpRegWord(sc, 0xAD08, 0x0007); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x8013); MP_RealWritePhyOcpRegWord(sc, 0xB87E, 0x0700); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x8FB9); MP_RealWritePhyOcpRegWord(sc, 0xB87E, 0x2801); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x8FBA); MP_RealWritePhyOcpRegWord(sc, 0xB87E, 0x0100); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x8FBC); MP_RealWritePhyOcpRegWord(sc, 0xB87E, 0x1900); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x8FBE); MP_RealWritePhyOcpRegWord(sc, 0xB87E, 0xE100); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x8FC0); MP_RealWritePhyOcpRegWord(sc, 0xB87E, 0x0800); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x8FC2); MP_RealWritePhyOcpRegWord(sc, 0xB87E, 0xE500); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x8FC4); MP_RealWritePhyOcpRegWord(sc, 0xB87E, 0x0F00); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x8FC6); MP_RealWritePhyOcpRegWord(sc, 0xB87E, 0xF100); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x8FC8); MP_RealWritePhyOcpRegWord(sc, 0xB87E, 0x0400); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x8FCa); MP_RealWritePhyOcpRegWord(sc, 0xB87E, 0xF300); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x8FCc); MP_RealWritePhyOcpRegWord(sc, 0xB87E, 0xFD00); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x8FCe); MP_RealWritePhyOcpRegWord(sc, 0xB87E, 0xFF00); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x8FD0); MP_RealWritePhyOcpRegWord(sc, 0xB87E, 0xFB00); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x8FD2); MP_RealWritePhyOcpRegWord(sc, 0xB87E, 0x0100); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x8FD4); MP_RealWritePhyOcpRegWord(sc, 0xB87E, 0xF400); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x8FD6); MP_RealWritePhyOcpRegWord(sc, 0xB87E, 0xFF00); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x8FD8); MP_RealWritePhyOcpRegWord(sc, 0xB87E, 0xF600); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x813D); MP_RealWritePhyOcpRegWord(sc, 0xB87E, 0x390E); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x814F); MP_RealWritePhyOcpRegWord(sc, 0xB87E, 0x790E); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x80B0); MP_RealWritePhyOcpRegWord(sc, 0xB87E, 0x0F31); SetEthPhyOcpBit(sc, 0xBF4C, BIT_1); SetEthPhyOcpBit(sc, 0xBCCA, (BIT_9 | BIT_8)); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x8141); MP_RealWritePhyOcpRegWord(sc, 0xB87E, 0x320E); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x8153); MP_RealWritePhyOcpRegWord(sc, 0xB87E, 0x720E); ClearEthPhyOcpBit(sc, 0xA432, BIT_6); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x8529); MP_RealWritePhyOcpRegWord(sc, 0xB87E, 0x050E); CSR_WRITE_2(sc, RE_EEE_TXIDLE_TIMER_8125, ifp->if_mtu + ETHER_HDR_LEN + 0x20); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x816C); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xC4A0); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x8170); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xC4A0); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x8174); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x04A0); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x8178); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x04A0); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x817C); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0719); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x8FF4); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0400); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x8FF1); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0404); MP_RealWritePhyOcpRegWord(sc, 0xBF4A, 0x001B); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x8033); MP_RealWritePhyOcpRegWord(sc, 0xB87E, 0x7C13); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x8037); MP_RealWritePhyOcpRegWord(sc, 0xB87E, 0x7C13); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x803B); MP_RealWritePhyOcpRegWord(sc, 0xB87E, 0xFC32); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x803F); MP_RealWritePhyOcpRegWord(sc, 0xB87E, 0x7C13); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x8043); MP_RealWritePhyOcpRegWord(sc, 0xB87E, 0x7C13); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x8047); MP_RealWritePhyOcpRegWord(sc, 0xB87E, 0x7C13); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x8145); MP_RealWritePhyOcpRegWord(sc, 0xB87E, 0x370E); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x8157); MP_RealWritePhyOcpRegWord(sc, 0xB87E, 0x770E); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x8169); MP_RealWritePhyOcpRegWord(sc, 0xB87E, 0x0D0A); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x817B); MP_RealWritePhyOcpRegWord(sc, 0xB87E, 0x1D0A); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x8217); ClearAndSetEthPhyOcpBit(sc, 0xA438, 0xFF00, 0x5000 ); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x821A); ClearAndSetEthPhyOcpBit(sc, 0xA438, 0xFF00, 0x5000 ); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x80DA); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0403); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x80DC); ClearAndSetEthPhyOcpBit(sc, 0xA438, 0xFF00, 0x1000 ); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x80B3); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x0384); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x80B7); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x2007); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x80BA); ClearAndSetEthPhyOcpBit(sc, 0xA438, 0xFF00, 0x6C00 ); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x80B5); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xF009); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x80BD); ClearAndSetEthPhyOcpBit(sc, 0xA438, 0xFF00, 0x9F00 ); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x80C7); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xf083); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x80DD); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x03f0); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x80DF); ClearAndSetEthPhyOcpBit(sc, 0xA438, 0xFF00, 0x1000 ); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x80CB); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x2007); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x80CE); ClearAndSetEthPhyOcpBit(sc, 0xA438, 0xFF00, 0x6C00 ); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x80C9); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x8009); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x80D1); ClearAndSetEthPhyOcpBit(sc, 0xA438, 0xFF00, 0x8000 ); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x80A3); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x200A); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x80A5); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0xF0AD); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x809F); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x6073); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x80A1); MP_RealWritePhyOcpRegWord(sc, 0xA438, 0x000B); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x80A9); ClearAndSetEthPhyOcpBit(sc, 0xA438, 0xFF00, 0xC000 ); re_set_phy_mcu_patch_request(sc); ClearEthPhyOcpBit(sc, 0xB896, BIT_0); ClearEthPhyOcpBit(sc, 0xB892, 0xFF00); MP_RealWritePhyOcpRegWord(sc, 0xB88E, 0xC23E); MP_RealWritePhyOcpRegWord(sc, 0xB890, 0x0000); MP_RealWritePhyOcpRegWord(sc, 0xB88E, 0xC240); MP_RealWritePhyOcpRegWord(sc, 0xB890, 0x0103); MP_RealWritePhyOcpRegWord(sc, 0xB88E, 0xC242); MP_RealWritePhyOcpRegWord(sc, 0xB890, 0x0507); MP_RealWritePhyOcpRegWord(sc, 0xB88E, 0xC244); MP_RealWritePhyOcpRegWord(sc, 0xB890, 0x090B); MP_RealWritePhyOcpRegWord(sc, 0xB88E, 0xC246); MP_RealWritePhyOcpRegWord(sc, 0xB890, 0x0C0E); MP_RealWritePhyOcpRegWord(sc, 0xB88E, 0xC248); MP_RealWritePhyOcpRegWord(sc, 0xB890, 0x1012); MP_RealWritePhyOcpRegWord(sc, 0xB88E, 0xC24A); MP_RealWritePhyOcpRegWord(sc, 0xB890, 0x1416); SetEthPhyOcpBit(sc, 0xB896, BIT_0); re_clear_phy_mcu_patch_request(sc); SetEthPhyOcpBit(sc, 0xA86A, BIT_0); SetEthPhyOcpBit(sc, 0xA6F0, BIT_0); MP_RealWritePhyOcpRegWord(sc, 0xBFA0, 0xD70D); MP_RealWritePhyOcpRegWord(sc, 0xBFA2, 0x4100); MP_RealWritePhyOcpRegWord(sc, 0xBFA4, 0xE868); MP_RealWritePhyOcpRegWord(sc, 0xBFA6, 0xDC59); MP_RealWritePhyOcpRegWord(sc, 0xB54C, 0x3C18); ClearEthPhyOcpBit(sc, 0xBFA4, BIT_5); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x817D); SetEthPhyOcpBit(sc, 0xA438, BIT_12); if (phy_power_saving == 1) { SetEthPhyOcpBit(sc, 0xA430, BIT_2); } else { ClearEthPhyOcpBit(sc, 0xA430, BIT_2); DELAY(20000); } } else if (sc->re_type == MACFG_83) { SetEthPhyOcpBit(sc, 0xA442, BIT_11); ClearAndSetEthPhyOcpBit(sc, 0xAC46, 0x00F0, 0x0090 ); ClearAndSetEthPhyOcpBit(sc, 0xAD30, 0x0003, 0x0001 ); CSR_WRITE_2(sc, RE_EEE_TXIDLE_TIMER_8125, ifp->if_mtu + ETHER_HDR_LEN + 0x20); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x80F5); MP_RealWritePhyOcpRegWord(sc, 0xB87E, 0x760E); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x8107); MP_RealWritePhyOcpRegWord(sc, 0xB87E, 0x360E); MP_RealWritePhyOcpRegWord(sc, 0xB87C, 0x8551); ClearAndSetEthPhyOcpBit(sc, 0xB87E, BIT_15 | BIT_14 | BIT_13 | BIT_12 | BIT_11 | BIT_10 | BIT_9 | BIT_8, BIT_11 ); ClearAndSetEthPhyOcpBit(sc, 0xbf00, 0xE000, 0xA000 ); ClearAndSetEthPhyOcpBit(sc, 0xbf46, 0x0F00, 0x0300 ); MP_RealWritePhyOcpRegWord(sc, 0xa436, 0x8044); MP_RealWritePhyOcpRegWord(sc, 0xa438, 0x2417); MP_RealWritePhyOcpRegWord(sc, 0xa436, 0x804A); MP_RealWritePhyOcpRegWord(sc, 0xa438, 0x2417); MP_RealWritePhyOcpRegWord(sc, 0xa436, 0x8050); MP_RealWritePhyOcpRegWord(sc, 0xa438, 0x2417); MP_RealWritePhyOcpRegWord(sc, 0xa436, 0x8056); MP_RealWritePhyOcpRegWord(sc, 0xa438, 0x2417); MP_RealWritePhyOcpRegWord(sc, 0xa436, 0x805C); MP_RealWritePhyOcpRegWord(sc, 0xa438, 0x2417); MP_RealWritePhyOcpRegWord(sc, 0xa436, 0x8062); MP_RealWritePhyOcpRegWord(sc, 0xa438, 0x2417); MP_RealWritePhyOcpRegWord(sc, 0xa436, 0x8068); MP_RealWritePhyOcpRegWord(sc, 0xa438, 0x2417); MP_RealWritePhyOcpRegWord(sc, 0xa436, 0x806E); MP_RealWritePhyOcpRegWord(sc, 0xa438, 0x2417); MP_RealWritePhyOcpRegWord(sc, 0xa436, 0x8074); MP_RealWritePhyOcpRegWord(sc, 0xa438, 0x2417); MP_RealWritePhyOcpRegWord(sc, 0xa436, 0x807A); MP_RealWritePhyOcpRegWord(sc, 0xa438, 0x2417); ////Nway DACONB //GPHY OCP 0xA4CA bit[6] = 0x1 (rg_dac_lp_burst_off_option) SetEthPhyOcpBit(sc, 0xA4CA, BIT_6); /* MP_RealWritePhyOcpRegWord(sc, 0xBFA0, 0xD70D); MP_RealWritePhyOcpRegWord(sc, 0xBFA2, 0x4100); MP_RealWritePhyOcpRegWord(sc, 0xBFA4, 0xE868); MP_RealWritePhyOcpRegWord(sc, 0xBFA6, 0xDC59); MP_RealWritePhyOcpRegWord(sc, 0xB54C, 0x3C18); ClearEthPhyOcpBit(sc, 0xBFA4, BIT_5); MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x817D); SetEthPhyOcpBit(sc, 0xA438, BIT_12); */ if (phy_power_saving == 1) { SetEthPhyOcpBit(sc, 0xA430, BIT_2); } else { ClearEthPhyOcpBit(sc, 0xA430, BIT_2); DELAY(20000); } } #ifdef ENABLE_FIBER_SUPPORT if (HW_FIBER_MODE_ENABLED(sc)) re_hw_fiber_phy_config(sc); #endif //ENABLE_FIBER_SUPPORT //EthPhyPPSW if (sc->re_type == MACFG_56 || sc->re_type == MACFG_57 || sc->re_type == MACFG_58 || sc->re_type == MACFG_59 || sc->re_type == MACFG_60) { //disable EthPhyPPSW MP_WritePhyUshort(sc, 0x1F, 0x0BCD); MP_WritePhyUshort(sc, 0x14, 0x5065); MP_WritePhyUshort(sc, 0x14, 0xD065); MP_WritePhyUshort(sc, 0x1F, 0x0BC8); MP_WritePhyUshort(sc, 0x12, 0x00ED); MP_WritePhyUshort(sc, 0x1F, 0x0BCD); MP_WritePhyUshort(sc, 0x14, 0x1065); MP_WritePhyUshort(sc, 0x14, 0x9065); MP_WritePhyUshort(sc, 0x14, 0x1065); MP_WritePhyUshort(sc, 0x1F, 0x0000); } else if (sc->re_type == MACFG_68 || sc->re_type == MACFG_69) { //enable EthPhyPPSW MP_WritePhyUshort(sc, 0x1F, 0x0A44); SetEthPhyBit(sc, 0x11, BIT_7); MP_WritePhyUshort(sc, 0x1F, 0x0000); } switch(sc->re_type) { 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: case MACFG_72: case MACFG_80: case MACFG_81: case MACFG_82: case MACFG_83: if (phy_mdix_mode == RE_ETH_PHY_FORCE_MDI) { //Force MDI MP_WritePhyUshort(sc, 0x1F, 0x0A43); SetEthPhyBit(sc, 0x10, BIT_8 | BIT_9); MP_WritePhyUshort(sc, 0x1F, 0x0000); } else if (phy_mdix_mode == RE_ETH_PHY_FORCE_MDIX) { //Force MDIX MP_WritePhyUshort(sc, 0x1F, 0x0A43); ClearEthPhyBit(sc, 0x10, BIT_8); SetEthPhyBit(sc, 0x10, BIT_9); MP_WritePhyUshort(sc, 0x1F, 0x0000); } else { //Auto MDI/MDIX MP_WritePhyUshort(sc, 0x1F, 0x0A43); ClearEthPhyBit(sc, 0x10, BIT_8 | BIT_9); MP_WritePhyUshort(sc, 0x1F, 0x0000); } break; } //legacy force mode(Chap 22) switch(sc->re_type) { case MACFG_80: case MACFG_81: case MACFG_82: case MACFG_83: MP_WritePhyUshort(sc, 0x1F, 0x0A5B); ClearEthPhyBit(sc, 0x12, BIT_15); MP_WritePhyUshort(sc, 0x1F, 0x0000); break; } if (phy_power_saving == 1) { switch (sc->re_type) { case MACFG_59: case MACFG_60: case MACFG_62: case MACFG_67: case MACFG_68: case MACFG_69: case MACFG_70: case MACFG_71: case MACFG_72: re_enable_ocp_phy_power_saving(sc); break; case MACFG_80: case MACFG_81: case MACFG_82: case MACFG_83: //re_enable_ocp_phy_power_saving(sc); break; } } if (eee_enable == 1) re_enable_EEE(sc); else re_disable_EEE(sc); MP_WritePhyUshort(sc, 0x1F, 0x0000); } void MP_WritePhyUshort(struct re_softc *sc,u_int8_t RegAddr,u_int16_t RegData) { u_int32_t TmpUlong=0x80000000; u_int32_t Timeout=0; if (RegAddr == 0x1F) { sc->cur_page = RegData; } if (sc->re_type == MACFG_63) { int i; CSR_WRITE_4(sc, RE_OCPDR, OCPDR_Write | (RegAddr & OCPDR_Reg_Mask) << OCPDR_GPHY_Reg_shift | (RegData & OCPDR_Data_Mask)); CSR_WRITE_4(sc, RE_OCPAR, OCPAR_GPHY_Write); CSR_WRITE_4(sc, RE_EPHY_RXER_NUM, 0); for (i = 0; i < 100; i++) { DELAY(1000); if (!(CSR_READ_4(sc, RE_OCPAR) & OCPAR_Flag)) break; } } else if (sc->re_type == MACFG_56 || sc->re_type == MACFG_57 || 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_70 || sc->re_type == MACFG_71 || sc->re_type == MACFG_72 || sc->re_type == MACFG_80 || sc->re_type == MACFG_81 || sc->re_type == MACFG_82 || sc->re_type == MACFG_83) { if (RegAddr == 0x1F) { return; } 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); TmpUlong |= (((u_int32_t)RegAddr)<<16 | (u_int32_t)RegData); CSR_WRITE_4(sc, RE_PHYAR, TmpUlong); /* Wait for writing to Phy ok */ for (Timeout=0; Timeout<5; Timeout++) { DELAY(1000); if ((CSR_READ_4(sc, RE_PHYAR)&PHYAR_Flag)==0) break; } if (sc->re_type == MACFG_65 || sc->re_type == MACFG_66) CSR_WRITE_4(sc, 0xD0, CSR_READ_4(sc, 0xD0) | 0x00020000); } } u_int16_t MP_ReadPhyUshort(struct re_softc *sc,u_int8_t RegAddr) { u_int16_t RegData; u_int32_t TmpUlong; u_int32_t Timeout=0; if (sc->re_type == MACFG_63) { int i; CSR_WRITE_4(sc, RE_OCPDR, OCPDR_Read | (RegAddr & OCPDR_Reg_Mask) << OCPDR_GPHY_Reg_shift); CSR_WRITE_4(sc, RE_OCPAR, OCPAR_GPHY_Write); CSR_WRITE_4(sc, RE_EPHY_RXER_NUM, 0); for (i = 0; i < 100; i++) { DELAY(1000); if (!(CSR_READ_4(sc, RE_OCPAR) & OCPAR_Flag)) break; } DELAY(1000); CSR_WRITE_4(sc, RE_OCPAR, OCPAR_GPHY_Read); CSR_WRITE_4(sc, RE_EPHY_RXER_NUM, 0); for (i = 0; i < 100; i++) { DELAY(1000); if (CSR_READ_4(sc, RE_OCPAR) & OCPAR_Flag) break; } RegData = CSR_READ_4(sc, RE_OCPDR) & OCPDR_Data_Mask; } else if (sc->re_type == MACFG_56 || sc->re_type == MACFG_57 || 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_70 || sc->re_type == MACFG_71 || sc->re_type == MACFG_72 || sc->re_type == MACFG_80 || sc->re_type == MACFG_81 || sc->re_type == MACFG_82 || sc->re_type == MACFG_83) { 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); TmpUlong = ((u_int32_t)RegAddr << 16); CSR_WRITE_4(sc, RE_PHYAR, TmpUlong); /* Wait for writing to Phy ok */ for (Timeout=0; Timeout<5; Timeout++) { DELAY(1000); TmpUlong = CSR_READ_4(sc, RE_PHYAR); if ((TmpUlong&PHYAR_Flag)!=0) break; } 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); } return RegData; } void MP_WriteEPhyUshort(struct re_softc *sc, u_int8_t RegAddr, u_int16_t RegData) { u_int32_t TmpUlong=0x80000000; u_int32_t Timeout=0; TmpUlong |= (((u_int32_t)RegAddr<<16) | (u_int32_t)RegData); CSR_WRITE_4(sc, RE_EPHYAR, TmpUlong); /* Wait for writing to Phy ok */ for (Timeout=0; Timeout<5; Timeout++) { DELAY(1000); if ((CSR_READ_4(sc, RE_EPHYAR)&PHYAR_Flag)==0) break; } } u_int16_t MP_ReadEPhyUshort(struct re_softc *sc, u_int8_t RegAddr) { u_int16_t RegData; u_int32_t TmpUlong; u_int32_t Timeout=0; TmpUlong = ((u_int32_t)RegAddr << 16); CSR_WRITE_4(sc, RE_EPHYAR, TmpUlong); /* Wait for writing to Phy ok */ for (Timeout=0; Timeout<5; Timeout++) { DELAY(1000); TmpUlong = CSR_READ_4(sc, RE_EPHYAR); if ((TmpUlong&PHYAR_Flag)!=0) break; } RegData = (u_int16_t)(TmpUlong & 0x0000ffff); return RegData; } static u_int8_t re_calc_efuse_dummy_bit(u_int16_t reg) { int s,a,b; u_int8_t dummyBitPos = 0; s=reg% 32; a=s % 16; b=s/16; if (s/16) { dummyBitPos = (u_int8_t)(16-a); } else { dummyBitPos = (u_int8_t)a; } return dummyBitPos; } 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, u_int32_t RegData) { u_int32_t Timeout = 0, WaitCount = 10; u_int32_t TmpUlong = 0x80000000; u_int32_t WriteDone; if (MultiFunSelBit > 7) { return; } TmpUlong |= MultiFunSelBit << 16; CSR_WRITE_4(sc, RE_CSIDR, RegData); TmpUlong |= (u_int32_t) ByteEnAndAddr; CSR_WRITE_4(sc, RE_CSIAR, TmpUlong); do { DELAY(100); WriteDone = CSR_READ_4(sc, RE_CSIAR); Timeout++; } while (((WriteDone & 0x80000000) != 0) && (Timeout < WaitCount)); DELAY(50); } u_int32_t MP_ReadOtherFunPciEConfigSpace( struct re_softc *sc, u_int8_t MultiFunSelBit, u_int16_t ByteEnAndAddr) { u_int32_t Timeout = 0, WaitCount = 10; u_int32_t TmpUlong = 0x00000000; u_int32_t ReadDone; u_int32_t RetVal = 0xffffffff; if (MultiFunSelBit > 7) { return 0xffffffff; } TmpUlong |= MultiFunSelBit << 16; TmpUlong |= (u_int32_t) ByteEnAndAddr; CSR_WRITE_4(sc, RE_CSIAR, TmpUlong); do { DELAY(100); ReadDone = CSR_READ_4(sc, RE_CSIAR); Timeout++; } while (((ReadDone & 0x80000000) == 0)&& (Timeout < WaitCount)); DELAY(50); return RetVal; } void MP_WritePciEConfigSpace( struct re_softc *sc, u_int16_t ByteEnAndAddr, u_int32_t RegData) { u_int8_t MultiFunSelBit; if (sc->re_type == MACFG_52 || sc->re_type == MACFG_53) { MultiFunSelBit = 2; } else if (sc->re_type == MACFG_60) { MultiFunSelBit = 1; } else { MultiFunSelBit = 0; } MP_WriteOtherFunPciEConfigSpace(sc, MultiFunSelBit, ByteEnAndAddr, RegData); } u_int32_t MP_ReadPciEConfigSpace( struct re_softc *sc, u_int16_t ByteEnAndAddr) { u_int8_t MultiFunSelBit; if (sc->re_type == MACFG_52 || sc->re_type == MACFG_53) { MultiFunSelBit = 2; } else if (sc->re_type == MACFG_60) { MultiFunSelBit = 1; } else { MultiFunSelBit = 0; } return MP_ReadOtherFunPciEConfigSpace(sc, MultiFunSelBit, ByteEnAndAddr); } u_int8_t MP_ReadByteFun0PciEConfigSpace( struct re_softc *sc, u_int16_t RegAddr) { u_int8_t RetVal = 0; u_int32_t TmpUlong; u_int16_t RegAlignAddr; u_int8_t ShiftByte; RegAlignAddr = RegAddr & ~(0x3); ShiftByte = RegAddr & (0x3); TmpUlong = MP_ReadOtherFunPciEConfigSpace(sc, 0, RegAlignAddr | 0xF000); TmpUlong >>= (8*ShiftByte); RetVal = (u_int8_t)TmpUlong; return RetVal; } static u_int16_t MappingPhyOcpAddress( struct re_softc *sc, u_int16_t PageNum, u_int8_t RegNum) { u_int16_t OcpPageNum = 0; u_int8_t OcpRegNum = 0; u_int16_t OcpPhyAddress = 0; if (PageNum == 0) { OcpPageNum = 0x0A40 + (RegNum / 8); OcpRegNum = 0x10 + (RegNum % 8); } else { OcpPageNum = PageNum; OcpRegNum = RegNum; } OcpPageNum <<= 4; if (OcpRegNum < 16) { OcpPhyAddress = 0; } else { OcpRegNum -= 16; OcpRegNum <<= 1; OcpPhyAddress = OcpPageNum + OcpRegNum; } return OcpPhyAddress; } u_int16_t MP_RealReadPhyOcpRegWord( struct re_softc *sc, u_int16_t OcpRegAddr) { u_int32_t Timeout = 0, WaitCount = 100; u_int32_t TmpUlong; u_int16_t RetVal = 0xffff; TmpUlong = OcpRegAddr / 2; TmpUlong <<= 16; CSR_WRITE_4(sc, RE_PHYOCPACCESS, TmpUlong); do { DELAY(1); TmpUlong = CSR_READ_4(sc, RE_PHYOCPACCESS); Timeout++; } while ((!(TmpUlong & PHYAR_Flag)) && (Timeout < WaitCount)); RetVal = (u_int16_t)TmpUlong; return RetVal; } u_int16_t MP_ReadPhyOcpRegWord( struct re_softc *sc, u_int16_t PhyPage, u_int8_t PhyRegNum) { u_int16_t OcpRegAddr; u_int16_t RetVal = 0xffff; OcpRegAddr = MappingPhyOcpAddress(sc, PhyPage, PhyRegNum); if (OcpRegAddr % 2) { u_int16_t tmpUshort; tmpUshort = MP_RealReadPhyOcpRegWord(sc, OcpRegAddr); tmpUshort &= 0xFF00; tmpUshort >>= 8; RetVal = tmpUshort; tmpUshort = MP_RealReadPhyOcpRegWord(sc, OcpRegAddr + 1); tmpUshort &= 0x00FF; tmpUshort <<= 8; RetVal |= tmpUshort; } else { RetVal = MP_RealReadPhyOcpRegWord(sc, OcpRegAddr); } return RetVal; } void MP_RealWritePhyOcpRegWord( struct re_softc *sc, u_int16_t OcpRegAddr, u_int16_t RegData) { u_int32_t Timeout = 0, WaitCount = 100; u_int32_t TmpUlong; TmpUlong = OcpRegAddr / 2; TmpUlong <<= 16; TmpUlong += RegData; TmpUlong |= BIT_31; CSR_WRITE_4(sc, RE_PHYOCPACCESS, TmpUlong); do { DELAY(1); TmpUlong = CSR_READ_4(sc, RE_PHYOCPACCESS); Timeout++; } while ((TmpUlong & PHYAR_Flag) && (Timeout < WaitCount)); } void MP_WritePhyOcpRegWord( struct re_softc *sc, u_int16_t PhyPage, u_int8_t PhyRegNum, u_int16_t RegData) { u_int16_t OcpRegAddr; OcpRegAddr = MappingPhyOcpAddress(sc, PhyPage, PhyRegNum); if (OcpRegAddr % 2) { u_int16_t tmpUshort; tmpUshort = MP_RealReadPhyOcpRegWord(sc, OcpRegAddr); tmpUshort &= 0x00FF; tmpUshort |= (RegData << 8); MP_RealWritePhyOcpRegWord(sc, OcpRegAddr, tmpUshort); tmpUshort = MP_RealReadPhyOcpRegWord(sc, OcpRegAddr + 1); tmpUshort &= 0xFF00; tmpUshort |= (RegData >> 8); MP_RealWritePhyOcpRegWord(sc, OcpRegAddr + 1, tmpUshort); } else { MP_RealWritePhyOcpRegWord(sc, OcpRegAddr, RegData); } } void MP_WriteMcuAccessRegWord( struct re_softc *sc, u_int16_t ExtRegAddr, u_int16_t RegData) { u_int32_t TmpUlong; TmpUlong = ExtRegAddr / 2; TmpUlong <<= 16; TmpUlong += RegData; TmpUlong |= BIT_31; CSR_WRITE_4(sc, RE_MCUACCESS, TmpUlong); } u_int16_t MP_ReadMcuAccessRegWord( struct re_softc *sc, u_int16_t ExtRegAddr) { u_int32_t TmpUlong; u_int16_t RetVal = 0xffff; TmpUlong = ExtRegAddr / 2; TmpUlong <<= 16; CSR_WRITE_4(sc, RE_MCUACCESS, TmpUlong); TmpUlong = CSR_READ_4(sc, RE_MCUACCESS); RetVal = (u_int16_t)TmpUlong; return RetVal; } static u_int32_t real_ocp_read(struct re_softc *sc, u_int16_t addr, u_int8_t len) { int i, val_shift, shift = 0; u_int32_t value1 = 0, value2 = 0, mask; if (len > 4 || len <= 0) return -1; while (len > 0) { val_shift = addr % 4; addr = addr & ~0x3; CSR_WRITE_4(sc, RE_OCPAR, (0x0F<<12) | (addr&0xFFF)); for (i = 0; i < 20; i++) { DELAY(100); if (CSR_READ_4(sc, RE_OCPAR) & OCPAR_Flag) break; } if (len == 1) mask = (0xFF << (val_shift * 8)) & 0xFFFFFFFF; else if (len == 2) mask = (0xFFFF << (val_shift * 8)) & 0xFFFFFFFF; else if (len == 3) mask = (0xFFFFFF << (val_shift * 8)) & 0xFFFFFFFF; else mask = (0xFFFFFFFF << (val_shift * 8)) & 0xFFFFFFFF; value1 = CSR_READ_4(sc, RE_OCPDR) & mask; value2 |= (value1 >> val_shift * 8) << shift * 8; if (len <= 4 - val_shift) { len = 0; } else { len -= (4 - val_shift); shift = 4 - val_shift; addr += 4; } } DELAY(20); 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 (HW_DASH_SUPPORT_TYPE_2(sc)) value = re_eri_read(sc, addr, len, ERIAR_OOB); 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; } static int real_ocp_write(struct re_softc *sc, u_int16_t addr, u_int8_t len, u_int32_t value) { int i, val_shift, shift = 0; u_int32_t value1 = 0, mask; if (len > 4 || len <= 0) return -1; while (len > 0) { val_shift = addr % 4; addr = addr & ~0x3; if (len == 1) mask = (0xFF << (val_shift * 8)) & 0xFFFFFFFF; else if (len == 2) mask = (0xFFFF << (val_shift * 8)) & 0xFFFFFFFF; else if (len == 3) mask = (0xFFFFFF << (val_shift * 8)) & 0xFFFFFFFF; else mask = (0xFFFFFFFF << (val_shift * 8)) & 0xFFFFFFFF; value1 = OCP_read(sc, addr, 4) & ~mask; value1 |= ((value << val_shift * 8) >> shift * 8); CSR_WRITE_4(sc, RE_OCPDR, value1); CSR_WRITE_4(sc, RE_OCPAR, OCPAR_Flag | (0x0F<<12) | (addr&0xFFF)); for (i = 0; i < 10; i++) { DELAY(100); /* Check if the RTL8168 has completed ERI write */ if (!(CSR_READ_4(sc, RE_OCPAR) & OCPAR_Flag)) break; } if (len <= 4 - val_shift) { len = 0; } else { len -= (4 - val_shift); shift = 4 - val_shift; addr += 4; } } DELAY(20); 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 (HW_DASH_SUPPORT_TYPE_2(sc)) re_eri_write(sc, addr, len, value, ERIAR_OOB); 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) { u_int8_t reg_16, reg_a0; u_int32_t wait_cnt_0, wait_Cnt_1; u_int16_t ocp_reg_mutex_ib; u_int16_t ocp_reg_mutex_oob; u_int16_t ocp_reg_mutex_prio; switch (sc->re_type) { case MACFG_63: case MACFG_64: case MACFG_65: ocp_reg_mutex_oob = 0x16; ocp_reg_mutex_ib = 0x17; ocp_reg_mutex_prio = 0x9C; break; case MACFG_66: ocp_reg_mutex_oob = 0x06; ocp_reg_mutex_ib = 0x07; ocp_reg_mutex_prio = 0x9C; break; case MACFG_61: case MACFG_62: case MACFG_67: case MACFG_70: case MACFG_71: case MACFG_72: default: ocp_reg_mutex_oob = 0x110; ocp_reg_mutex_ib = 0x114; ocp_reg_mutex_prio = 0x11C; break; } OCP_write(sc, ocp_reg_mutex_ib, 1, BIT_0); reg_16 = OCP_read(sc, ocp_reg_mutex_oob, 1); wait_cnt_0 = 0; while(reg_16) { reg_a0 = OCP_read(sc, ocp_reg_mutex_prio, 1); if (reg_a0) { OCP_write(sc, ocp_reg_mutex_ib, 1, 0x00); reg_a0 = OCP_read(sc, ocp_reg_mutex_prio, 1); wait_Cnt_1 = 0; while(reg_a0) { reg_a0 = OCP_read(sc, ocp_reg_mutex_prio, 1); wait_Cnt_1++; if (wait_Cnt_1 > 2000) break; }; OCP_write(sc, ocp_reg_mutex_ib, 1, BIT_0); } reg_16 = OCP_read(sc, ocp_reg_mutex_oob, 1); wait_cnt_0++; if (wait_cnt_0 > 2000) break; }; } static void OOB_mutex_unlock(struct re_softc *sc) { u_int16_t ocp_reg_mutex_ib; u_int16_t ocp_reg_mutex_oob; u_int16_t ocp_reg_mutex_prio; switch (sc->re_type) { case MACFG_63: case MACFG_64: case MACFG_65: ocp_reg_mutex_oob = 0x16; ocp_reg_mutex_ib = 0x17; ocp_reg_mutex_prio = 0x9C; break; case MACFG_66: ocp_reg_mutex_oob = 0x06; ocp_reg_mutex_ib = 0x07; ocp_reg_mutex_prio = 0x9C; break; case MACFG_61: case MACFG_62: case MACFG_67: case MACFG_70: case MACFG_71: case MACFG_72: default: ocp_reg_mutex_oob = 0x110; ocp_reg_mutex_ib = 0x114; ocp_reg_mutex_prio = 0x11C; break; } OCP_write(sc, ocp_reg_mutex_prio, 1, BIT_0); OCP_write(sc, ocp_reg_mutex_ib, 1, 0x00); } static int re_check_dash(struct re_softc *sc) { 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: case MACFG_72: 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 (OCP_read(sc, reg, 2) & 0x00008000) return 1; else return 0; } break; default: return 0; } } static void OOB_notify(struct re_softc *sc, u_int8_t cmd) { int i; CSR_WRITE_1(sc, RE_ERIDR, cmd); CSR_WRITE_4(sc, RE_ERIAR, 0x800010E8); DELAY(2000); for (i = 0; i < 5; i++) { DELAY(100); if (!(CSR_READ_4(sc, RE_ERIAR) & ERIAR_Flag)) break; } OCP_write(sc, 0x30, 1, 0x01); } void re_driver_start(struct re_softc *sc) { if (HW_DASH_SUPPORT_TYPE_2(sc) || HW_DASH_SUPPORT_TYPE_3(sc)) { u_int32_t tmp_value; if (!sc->re_dash) return; OCP_write(sc, 0x180, 1, OOB_CMD_DRIVER_START); tmp_value = OCP_read(sc, 0x30, 1); tmp_value |= BIT_0; OCP_write(sc, 0x30, 1, tmp_value); } else { int timeout; u_int32_t reg; if (sc->re_type == MACFG_66) { CSR_WRITE_1(sc, RE_TwiCmdReg, CSR_READ_1(sc, RE_TwiCmdReg) | (BIT_7)); } OOB_notify(sc, OOB_CMD_DRIVER_START); if (sc->re_type == MACFG_66) reg = 0xB8; else reg = 0x10; for (timeout = 0; timeout < 10; timeout++) { DELAY(10000); if (OCP_read(sc, reg, 2) & BIT_11) break; } } } void re_driver_stop(struct re_softc *sc) { if (HW_DASH_SUPPORT_TYPE_2(sc) || HW_DASH_SUPPORT_TYPE_3(sc)) { u_int32_t tmp_value; if (!sc->re_dash) return; Dash2DisableTxRx(sc); OCP_write(sc, 0x180, 1, OOB_CMD_DRIVER_STOP); tmp_value = OCP_read(sc, 0x30, 1); tmp_value |= BIT_0; OCP_write(sc, 0x30, 1, tmp_value); } else { int timeout; u_int32_t reg; OOB_notify(sc, OOB_CMD_DRIVER_STOP); if (sc->re_type == MACFG_66) reg = 0xB8; else reg = 0x10; for (timeout = 0; timeout < 10; timeout++) { DELAY(10000); if ((OCP_read(sc, reg, 4) & BIT_11) == 0) break; } if (sc->re_type == MACFG_66) { CSR_WRITE_1(sc, RE_TwiCmdReg, CSR_READ_1(sc, RE_TwiCmdReg) & ~(BIT_7)); } } } /*----------------------------------------------------------------------------*/ /* 8139 (CR9346) 9346 command register bits (offset 0x50, 1 byte)*/ /*----------------------------------------------------------------------------*/ #define CR9346_EEDO 0x01 /* 9346 data out*/ #define CR9346_EEDI 0x02 /* 9346 data in*/ #define CR9346_EESK 0x04 /* 9346 serial clock*/ #define CR9346_EECS 0x08 /* 9346 chip select*/ #define CR9346_EEM0 0x40 /* select 8139 operating mode*/ #define CR9346_EEM1 0x80 /* 00: normal*/ #define CR9346_CFGRW 0xC0 /* Config register write*/ #define CR9346_NORM 0x00 /*----------------------------------------------------------------------------*/ /* EEPROM bit definitions(EEPROM control register bits)*/ /*----------------------------------------------------------------------------*/ #define EN_TRNF 0x10 /* Enable turnoff*/ #define EEDO CR9346_EEDO /* EEPROM data out*/ #define EEDI CR9346_EEDI /* EEPROM data in (set for writing data)*/ #define EECS CR9346_EECS /* EEPROM chip select (1=high, 0=low)*/ #define EESK CR9346_EESK /* EEPROM shift clock (1=high, 0=low)*/ /*----------------------------------------------------------------------------*/ /* EEPROM opcodes*/ /*----------------------------------------------------------------------------*/ #define EEPROM_READ_OPCODE 06 #define EEPROM_WRITE_OPCODE 05 #define EEPROM_ERASE_OPCODE 07 #define EEPROM_EWEN_OPCODE 19 /* Erase/write enable*/ #define EEPROM_EWDS_OPCODE 16 /* Erase/write disable*/ #define CLOCK_RATE 50 /* us*/ #define RaiseClock(_sc,_x) \ (_x) = (_x) | EESK; \ CSR_WRITE_1((_sc), RE_EECMD, (_x)); \ DELAY(CLOCK_RATE); #define LowerClock(_sc,_x) \ (_x) = (_x) & ~EESK; \ CSR_WRITE_1((_sc), RE_EECMD, (_x)); \ DELAY(CLOCK_RATE); /* * Shift out bit(s) to the EEPROM. */ static void re_eeprom_ShiftOutBits(struct re_softc *sc, int data, int count) { u_int16_t x, mask; mask = 0x01 << (count - 1); x = CSR_READ_1(sc, RE_EECMD); x &= ~(EEDO | EEDI); do { x &= ~EEDI; if (data & mask) x |= EEDI; CSR_WRITE_1(sc, RE_EECMD, x); DELAY(CLOCK_RATE); RaiseClock(sc,x); LowerClock(sc,x); mask = mask >> 1; } while (mask); x &= ~EEDI; CSR_WRITE_1(sc, RE_EECMD, x); } /* * Shift in bit(s) from the EEPROM. */ static u_int16_t re_eeprom_ShiftInBits(struct re_softc *sc) { u_int16_t x,d,i; x = CSR_READ_1(sc, RE_EECMD); x &= ~(EEDO | EEDI); d = 0; for (i=0; i<16; i++) { d = d << 1; RaiseClock(sc, x); x = CSR_READ_1(sc, RE_EECMD); x &= ~(EEDI); if (x & EEDO) d |= 1; LowerClock(sc, x); } return d; } /* * Clean up EEprom read/write setting */ static void re_eeprom_EEpromCleanup(struct re_softc *sc) { u_int16_t x; x = CSR_READ_1(sc, RE_EECMD); x &= ~(EECS | EEDI); CSR_WRITE_1(sc, RE_EECMD, x); RaiseClock(sc, x); LowerClock(sc, x); } /* * Read a word of data stored in the EEPROM at address 'addr.' */ static void re_eeprom_getword(struct re_softc *sc, int addr, u_int16_t *dest) { u_int16_t x; /* select EEPROM, reset bits, set EECS*/ x = CSR_READ_1(sc, RE_EECMD); x &= ~(EEDI | EEDO | EESK | CR9346_EEM0); x |= CR9346_EEM1 | EECS; CSR_WRITE_1(sc, RE_EECMD, x); /* write the read opcode and register number in that order*/ /* The opcode is 3bits in length, reg is 6 bits long*/ re_eeprom_ShiftOutBits(sc, EEPROM_READ_OPCODE, 3); if (CSR_READ_4(sc, RE_RXCFG) & RE_RXCFG_RX_9356SEL) re_eeprom_ShiftOutBits(sc, addr,8); /*93c56=8*/ else re_eeprom_ShiftOutBits(sc, addr,6); /*93c46=6*/ /* Now read the data (16 bits) in from the selected EEPROM word*/ *dest=re_eeprom_ShiftInBits(sc); re_eeprom_EEpromCleanup(sc); return; } /* * Read a sequence of words from the EEPROM. */ static void re_read_eeprom(struct re_softc *sc, caddr_t dest, int off, int cnt, int swap) { int i; u_int16_t word = 0, *ptr; for (i = 0; i < cnt; i++) { re_eeprom_getword(sc, off + i, &word); ptr = (u_int16_t *)(dest + (i * 2)); if (swap) *ptr = ntohs(word); else *ptr = word; } return; } #ifdef __DragonFly__ int rtl_check_mac_version(struct re_softc *sc) { return (re_check_mac_version(sc)); } void rtl_init_software_variable(struct re_softc *sc) { re_init_software_variable(sc); } void rtl_exit_oob(struct re_softc *sc) { re_exit_oob(sc); } void rtl_hw_init(struct re_softc *sc) { re_hw_init(sc); } void rtl_reset(struct re_softc *sc) { re_reset(sc); } void rtl_get_hw_mac_address(struct re_softc *sc, u_int8_t *eaddr) { re_get_hw_mac_address(sc, eaddr); } void rtl_phy_power_up(struct re_softc *sc) { re_phy_power_up(sc->dev); } void rtl_hw_phy_config(struct re_softc *sc) { re_hw_phy_config(sc); } void rtl_clrwol(struct re_softc *sc) { re_clrwol(sc); } int rtl_ifmedia_upd(struct ifnet *ifp) { struct re_softc *sc = ifp->if_softc; if (sc->re_device_id == RT_DEVICEID_8125) return (re_ifmedia_upd_8125(ifp)); else return (re_ifmedia_upd(ifp)); } void rtl_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr) { struct re_softc *sc = ifp->if_softc; if (sc->re_device_id == RT_DEVICEID_8125) re_ifmedia_sts_8125(ifp, ifmr); else re_ifmedia_sts(ifp, ifmr); } void rtl_stop(struct re_softc *sc) { sc->phy_reg_anlpar = re_get_phy_lp_ability(sc); re_stop_rtl(sc); } u_int8_t rtl_link_ok(struct re_softc *sc) { return (re_link_ok(sc)); } void rtl_link_on_patch(struct re_softc *sc) { re_link_on_patch(sc); } void rtl_set_eaddr(struct re_softc *sc) { re_init_unlock(sc); } void rtl_hw_start(struct re_softc *sc) { if (sc->re_device_id == RT_DEVICEID_8125) re_hw_start_unlock_8125(sc); else re_hw_start_unlock(sc); } void rtl_set_rx_packet_filter(struct re_softc *sc) { re_set_rx_packet_filter(sc); } void rtl_hw_d3_para(struct re_softc *sc) { re_hw_d3_para(sc); } void rtl_phy_power_down(struct re_softc *sc) { re_phy_power_down(sc->dev); } void rtl_cmac_unmap(struct re_softc *sc) { if (HW_DASH_SUPPORT_TYPE_3(sc) && sc->re_dash && sc->re_mapped_cmac_handle != 0) { bus_space_unmap(sc->re_cmac_tag, sc->re_mapped_cmac_handle, RE_REGS_SIZE); } } #endif /* __DragonFly__ */