diff options
Diffstat (limited to 'freebsd/rtl_bsd_drv_v197.00/if_re.c')
| -rwxr-xr-x | freebsd/rtl_bsd_drv_v197.00/if_re.c | 31155 |
1 files changed, 31155 insertions, 0 deletions
diff --git a/freebsd/rtl_bsd_drv_v197.00/if_re.c b/freebsd/rtl_bsd_drv_v197.00/if_re.c new file mode 100755 index 0000000..9d54e3c --- /dev/null +++ b/freebsd/rtl_bsd_drv_v197.00/if_re.c @@ -0,0 +1,31155 @@ +/* + * Copyright (c) 1997, 1998 + * Bill Paul <wpaul@ctr.columbia.edu>. 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 <wpaul@ctr.columbia.edu> + * Electrical Engineering Department + * Columbia University, New York City + */ + +#include <sys/cdefs.h> + +#ifdef ENABLE_FIBER_SUPPORT +#define FIBER_SUFFIX "-FIBER" +#else +#define FIBER_SUFFIX "" +#endif +#define RE_VERSION "1.97.00" 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 <sys/param.h> +#include <sys/systm.h> +#include <sys/sockio.h> +#include <sys/mbuf.h> +#include <sys/malloc.h> +#include <sys/kernel.h> +#include <sys/socket.h> +#include <sys/taskqueue.h> +#include <sys/random.h> + +#include <net/if.h> +#include <net/if_var.h> +#include <net/if_arp.h> +#include <net/ethernet.h> +#include <net/if_dl.h> +#include <net/if_media.h> + +#include <net/bpf.h> + +#include <vm/vm.h> /* for vtophys */ +#include <vm/pmap.h> /* for vtophys */ +#include <machine/clock.h> /* for DELAY */ + +#include <machine/bus.h> +#include <machine/resource.h> +#include <sys/bus.h> +#include <sys/rman.h> +#include <sys/endian.h> + +#include <dev/mii/mii.h> +#include <dev/re/if_rereg.h> +#ifdef ENABLE_FIBER_SUPPORT +#include <dev/re/if_fiber.h> +#endif //ENABLE_FIBER_SUPPORT + +#if OS_VER < VERSION(5,3) +#include <pci/pcireg.h> +#include <pci/pcivar.h> +#include <machine/bus_pio.h> +#include <machine/bus_memio.h> +#else +#include <dev/pci/pcireg.h> +#include <dev/pci/pcivar.h> +#include <sys/module.h> +#endif + +#if OS_VER > VERSION(5,9) +#include <sys/cdefs.h> +#include <sys/endian.h> +#include <net/if_types.h> +#include <net/if_vlan_var.h> +#endif + +#include <netinet/in.h> +#include <netinet/ip.h> +#include <netinet/ip6.h> + +#include <machine/in_cksum.h> + +#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) + +/* + * 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_8162, + "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 *)); + +static int re_check_dash __P((struct re_softc *)); + +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 *)); +static void re_clrwol __P((struct re_softc *)); +static void re_set_wol_linkspeed __P((struct re_softc *)); + +static void re_start __P((struct ifnet *)); +static int re_encap __P((struct re_softc *, struct mbuf *)); +static int re_8125_pad __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) +static void re_set_multicast_reg __P((struct re_softc *, u_int32_t, u_int32_t)); +static void re_set_rx_packet_filter_in_sleep_state __P((struct re_softc *)); +static void re_set_rx_packet_filter __P((struct re_softc *)); +static void re_setmulti __P((struct re_softc *)); +static int re_ioctl __P((struct ifnet *, u_long, caddr_t)); +static u_int8_t re_link_ok __P((struct re_softc *)); +static void re_link_on_patch __P((struct re_softc *)); +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 + +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)); +static void re_int_task (void *, int); +static void re_int_task_8125 (void *, int); + +static void re_phy_power_up(device_t dev); +static void re_phy_power_down(device_t dev); +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 *); +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 *); +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) + +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); + +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(dev) +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_73: + case MACFG_74: + 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(dev) +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: + case MACFG_73: + case MACFG_74: + 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)); +} + +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); +} + + +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); +} + +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); +} + +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) +{ + u_int16_t regAddr; + + 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_73: + case MACFG_74: + 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); + re_disable_cfg9346_write(sc); + break; + } + + switch(sc->re_type) { + case MACFG_68: + case MACFG_69: + case MACFG_70: + case MACFG_71: + case MACFG_72: + case MACFG_73: + case MACFG_74: + MP_WriteMcuAccessRegWord(sc, 0xFC38, 0x0000); + break; + case MACFG_80: + case MACFG_81: + case MACFG_82: + case MACFG_83: + MP_WriteMcuAccessRegWord(sc, 0xFC48, 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: + case MACFG_73: + case MACFG_74: + 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; + case MACFG_80: + case MACFG_81: + case MACFG_82: + case MACFG_83: + for (regAddr = 0xFC28; regAddr < 0xFC48; regAddr += 2) { + MP_WriteMcuAccessRegWord(sc, regAddr, 0x0000); + } + + DELAY(3000); + + MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x0000); + break; + } +} + +static void +re_switch_mac_mcu_ram_code_page(struct re_softc *sc, u_int16_t page) +{ + u_int16_t tmpUshort; + + page &= (BIT_1 | BIT_0); + tmpUshort = MP_ReadMcuAccessRegWord(sc, 0xE446); + tmpUshort &= ~(BIT_1 | BIT_0); + tmpUshort |= page; + MP_WriteMcuAccessRegWord(sc, 0xE446, tmpUshort); +} + +static void +_re_write_mac_mcu_ram_code(struct re_softc *sc, const u_int16_t *entry, u_int16_t entry_cnt) +{ + u_int16_t i; + + for (i = 0; i < entry_cnt; i++) { + MP_WriteMcuAccessRegWord(sc, 0xF800 + i * 2, entry[i]); + } +} + +static void +_re_write_mac_mcu_ram_code_with_page(struct re_softc *sc, const u_int16_t *entry, u_int16_t entry_cnt, u_int16_t page_size) +{ + u_int16_t i; + u_int16_t offset; + + if (page_size == 0) return; + + for (i = 0; i < entry_cnt; i++) { + offset = i % page_size; + if (offset == 0) { + u_int16_t page = (i / page_size); + re_switch_mac_mcu_ram_code_page(sc, page); + } + MP_WriteMcuAccessRegWord(sc, 0xF800 + offset * 2, entry[i]); + } +} + +static void +re_write_mac_mcu_ram_code(struct re_softc *sc, const u_int16_t *entry, u_int16_t entry_cnt) +{ + if (FALSE == HW_SUPPORT_MAC_MCU(sc)) return; + if (entry == NULL || entry_cnt == 0) return; + + if (sc->MacMcuPageSize > 0) + _re_write_mac_mcu_ram_code_with_page(sc, entry, entry_cnt, sc->MacMcuPageSize); + else + _re_write_mac_mcu_ram_code(sc, entry, entry_cnt); +} + +static void re_set_mac_mcu_8168g_1(struct re_softc *sc) +{ + static const uint16_t mcu_patch_code_8168g_1[] = { + 0xE008, 0xE01B, 0xE022, 0xE094, 0xE097, 0xE09A, 0xE0B3, 0xE0BA, 0x49D2, + 0xF10D, 0x766C, 0x49E2, 0xF00A, 0x1EC0, 0x8EE1, 0xC60A, 0x77C0, 0x4870, + 0x9FC0, 0x1EA0, 0xC707, 0x8EE1, 0x9D6C, 0xC603, 0xBE00, 0xB416, 0x0076, + 0xE86C, 0xC406, 0x7580, 0x4852, 0x8D80, 0xC403, 0xBC00, 0xD3E0, 0x02C8, + 0x8918, 0xE815, 0x1100, 0xF011, 0xE812, 0x4990, 0xF002, 0xE817, 0xE80E, + 0x4992, 0xF002, 0xE80E, 0xE80A, 0x4993, 0xF002, 0xE818, 0xE806, 0x4991, + 0xF002, 0xE838, 0xC25E, 0xBA00, 0xC056, 0x7100, 0xFF80, 0x7100, 0x4892, + 0x4813, 0x8900, 0xE00A, 0x7100, 0x4890, 0x4813, 0x8900, 0xC74B, 0x74F8, + 0x48C2, 0x4841, 0x8CF8, 0xC746, 0x74FC, 0x49C0, 0xF120, 0x49C1, 0xF11E, + 0x74F8, 0x49C0, 0xF01B, 0x49C6, 0xF119, 0x74F8, 0x49C4, 0xF013, 0xC536, + 0x74B0, 0x49C1, 0xF1FD, 0xC537, 0xC434, 0x9CA0, 0xC435, 0x1C13, 0x484F, + 0x9CA2, 0xC52B, 0x74B0, 0x49C1, 0xF1FD, 0x74F8, 0x48C4, 0x8CF8, 0x7100, + 0x4893, 0x8900, 0xFF80, 0xC520, 0x74B0, 0x49C1, 0xF11C, 0xC71E, 0x74FC, + 0x49C1, 0xF118, 0x49C0, 0xF116, 0x74F8, 0x49C0, 0xF013, 0x48C3, 0x8CF8, + 0xC516, 0x74A2, 0x49CE, 0xF1FE, 0xC411, 0x9CA0, 0xC411, 0x1C13, 0x484F, + 0x9CA2, 0x74A2, 0x49CF, 0xF1FE, 0x7100, 0x4891, 0x8900, 0xFF80, 0xE400, + 0xD3E0, 0xE000, 0x0481, 0x0C81, 0xDE20, 0x0000, 0x0992, 0x1B76, 0xC602, + 0xBE00, 0x059C, 0x1B76, 0xC602, 0xBE00, 0x065A, 0xB400, 0x18DE, 0x2008, + 0x4001, 0xF10F, 0x7342, 0x1880, 0x2008, 0x0009, 0x4018, 0xF109, 0x7340, + 0x25BC, 0x130F, 0xF105, 0xC00A, 0x7300, 0x4831, 0x9B00, 0xB000, 0x7340, + 0x8320, 0xC302, 0xBB00, 0x0C12, 0xE860, 0xC406, 0x7580, 0x4851, 0x8D80, + 0xC403, 0xBC00, 0xD3E0, 0x02C8, 0xC406, 0x7580, 0x4850, 0x8D80, 0xC403, + 0xBC00, 0xD3E0, 0x0298 + }; + + MP_WriteMcuAccessRegWord(sc, 0xE43C, 0x0000); + MP_WriteMcuAccessRegWord(sc, 0xE43E, 0x0000); + + MP_WriteMcuAccessRegWord(sc, 0xE434, 0x0004); + MP_WriteMcuAccessRegWord(sc, 0xE43C, 0x0004); + + DisableMcuBPs(sc); + + re_write_mac_mcu_ram_code(sc, mcu_patch_code_8168g_1, ARRAY_SIZE(mcu_patch_code_8168g_1)); + + 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, 0x02C7); + MP_WriteMcuAccessRegWord(sc, 0xFC36, 0x0279); +} + +static void re_set_mac_mcu_8168gu_1(struct re_softc *sc) +{ + static const uint16_t mcu_patch_code_8168gu_1[] = { + 0xE008, 0xE011, 0xE015, 0xE018, 0xE01B, 0xE027, 0xE043, 0xE065, 0x49E2, + 0xF005, 0x49EA, 0xF003, 0xC404, 0xBC00, 0xC403, 0xBC00, 0x0496, 0x051A, + 0x1D01, 0x8DE8, 0xC602, 0xBE00, 0x0206, 0x1B76, 0xC202, 0xBA00, 0x058A, + 0x1B76, 0xC602, 0xBE00, 0x0648, 0x74E6, 0x1B78, 0x46DC, 0x1300, 0xF005, + 0x74F8, 0x48C3, 0x48C4, 0x8CF8, 0x64E7, 0xC302, 0xBB00, 0x068E, 0x74E4, + 0x49C5, 0xF106, 0x49C6, 0xF107, 0x48C8, 0x48C9, 0xE011, 0x48C9, 0x4848, + 0xE00E, 0x4848, 0x49C7, 0xF00A, 0x48C9, 0xC60D, 0x1D1F, 0x8DC2, 0x1D00, + 0x8DC3, 0x1D11, 0x8DC0, 0xE002, 0x4849, 0x94E5, 0xC602, 0xBE00, 0x0238, + 0xE434, 0x49D9, 0xF01B, 0xC31E, 0x7464, 0x49C4, 0xF114, 0xC31B, 0x6460, + 0x14FA, 0xFA02, 0xE00F, 0xC317, 0x7460, 0x49C0, 0xF10B, 0xC311, 0x7462, + 0x48C1, 0x9C62, 0x4841, 0x9C62, 0xC30A, 0x1C04, 0x8C60, 0xE004, 0x1C15, + 0xC305, 0x8C60, 0xC602, 0xBE00, 0x0374, 0xE434, 0xE030, 0xE61C, 0xE906, + 0xC602, 0xBE00, 0x0000 + }; + + DisableMcuBPs(sc); + + re_write_mac_mcu_ram_code(sc, mcu_patch_code_8168gu_1, ARRAY_SIZE(mcu_patch_code_8168gu_1)); + + 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) +{ + static const uint16_t mcu_patch_code_8168gu_2[] = { + 0xE008, 0xE00A, 0xE00D, 0xE02F, 0xE031, 0xE038, 0xE03A, 0xE051, 0xC202, + 0xBA00, 0x0DFC, 0x7444, 0xC502, 0xBD00, 0x0A30, 0x49D9, 0xF019, 0xC520, + 0x64A5, 0x1400, 0xF007, 0x0C01, 0x8CA5, 0x1C15, 0xC515, 0x9CA0, 0xE00F, + 0xC513, 0x74A0, 0x48C8, 0x48CA, 0x9CA0, 0xC510, 0x1B00, 0x9BA0, 0x1B1C, + 0x483F, 0x9BA2, 0x1B04, 0xC506, 0x9BA0, 0xC603, 0xBE00, 0x0298, 0x03DE, + 0xE434, 0xE096, 0xE860, 0xDE20, 0xD3C0, 0xC602, 0xBE00, 0x0A64, 0xC707, + 0x1D00, 0x8DE2, 0x48C1, 0xC502, 0xBD00, 0x00AA, 0xE0C0, 0xC502, 0xBD00, + 0x0132, 0xC50C, 0x74A2, 0x49CE, 0xF1FE, 0x1C00, 0x9EA0, 0x1C1C, 0x484F, + 0x9CA2, 0xC402, 0xBC00, 0x0AFA, 0xDE20, 0xE000, 0xE092, 0xE430, 0xDE20, + 0xE0C0, 0xE860, 0xE84C, 0xB400, 0xB430, 0xE410, 0xC0AE, 0xB407, 0xB406, + 0xB405, 0xB404, 0xB403, 0xB402, 0xB401, 0xC7EE, 0x76F4, 0xC2ED, 0xC3ED, + 0xC1EF, 0xC5F3, 0x74A0, 0x49CD, 0xF001, 0xC5EE, 0x74A0, 0x49C1, 0xF105, + 0xC5E4, 0x74A2, 0x49CE, 0xF00B, 0x7444, 0x484B, 0x9C44, 0x1C10, 0x9C62, + 0x1C11, 0x8C60, 0x1C00, 0x9CF6, 0xE0EC, 0x49E7, 0xF016, 0x1D80, 0x8DF4, + 0x74F8, 0x4843, 0x8CF8, 0x74F8, 0x74F8, 0x7444, 0x48C8, 0x48C9, 0x48CA, + 0x9C44, 0x74F8, 0x4844, 0x8CF8, 0x1E01, 0xE8DB, 0x7420, 0x48C1, 0x9C20, + 0xE0D5, 0x49E6, 0xF02A, 0x1D40, 0x8DF4, 0x74FC, 0x49C0, 0xF124, 0x49C1, + 0xF122, 0x74F8, 0x49C0, 0xF01F, 0xE8D3, 0x48C4, 0x8CF8, 0x1E00, 0xE8C6, + 0xC5B1, 0x74A0, 0x49C3, 0xF016, 0xC5AF, 0x74A4, 0x49C2, 0xF005, 0xC5AA, + 0x74B2, 0x49C9, 0xF10E, 0xC5A6, 0x74A8, 0x4845, 0x4846, 0x4847, 0x4848, + 0x9CA8, 0x74B2, 0x4849, 0x9CB2, 0x74A0, 0x484F, 0x9CA0, 0xE0AA, 0x49E4, + 0xF018, 0x1D10, 0x8DF4, 0x74F8, 0x74F8, 0x74F8, 0x4843, 0x8CF8, 0x74F8, + 0x74F8, 0x74F8, 0x4844, 0x4842, 0x4841, 0x8CF8, 0x1E01, 0xE89A, 0x7420, + 0x4841, 0x9C20, 0x7444, 0x4848, 0x9C44, 0xE091, 0x49E5, 0xF03E, 0x1D20, + 0x8DF4, 0x74F8, 0x48C2, 0x4841, 0x8CF8, 0x1E01, 0x7444, 0x49CA, 0xF103, + 0x49C2, 0xF00C, 0x49C1, 0xF004, 0x6447, 0x2244, 0xE002, 0x1C01, 0x9C62, + 0x1C11, 0x8C60, 0x1C00, 0x9CF6, 0x7444, 0x49C8, 0xF01D, 0x74FC, 0x49C0, + 0xF11A, 0x49C1, 0xF118, 0x74F8, 0x49C0, 0xF015, 0x49C6, 0xF113, 0xE875, + 0x48C4, 0x8CF8, 0x7420, 0x48C1, 0x9C20, 0xC50A, 0x74A2, 0x8CA5, 0x74A0, + 0xC505, 0x9CA2, 0x1C11, 0x9CA0, 0xE00A, 0xE434, 0xD3C0, 0xDC00, 0x7444, + 0x49CA, 0xF004, 0x48CA, 0x9C44, 0xE855, 0xE052, 0x49E8, 0xF024, 0x1D01, + 0x8DF5, 0x7440, 0x49C0, 0xF11E, 0x7444, 0x49C8, 0xF01B, 0x49CA, 0xF119, + 0xC5EC, 0x76A4, 0x49E3, 0xF015, 0x49C0, 0xF103, 0x49C1, 0xF011, 0x4849, + 0x9C44, 0x1C00, 0x9CF6, 0x7444, 0x49C1, 0xF004, 0x6446, 0x1E07, 0xE003, + 0x1C01, 0x1E03, 0x9C62, 0x1C11, 0x8C60, 0xE830, 0xE02D, 0x49E9, 0xF004, + 0x1D02, 0x8DF5, 0xE79C, 0x49E3, 0xF006, 0x1D08, 0x8DF4, 0x74F8, 0x74F8, + 0xE73A, 0x49E1, 0xF007, 0x1D02, 0x8DF4, 0x1E01, 0xE7A7, 0xDE20, 0xE410, + 0x49E0, 0xF017, 0x1D01, 0x8DF4, 0xC5FA, 0x1C00, 0x8CA0, 0x1C1B, 0x9CA2, + 0x74A2, 0x49CF, 0xF0FE, 0xC5F3, 0x74A0, 0x4849, 0x9CA0, 0x74F8, 0x49C0, + 0xF006, 0x48C3, 0x8CF8, 0xE820, 0x74F8, 0x74F8, 0xC432, 0xBC00, 0xC5E4, + 0x74A2, 0x49CE, 0xF1FE, 0x9EA0, 0x1C1C, 0x484F, 0x9CA2, 0xFF80, 0xB404, + 0xB405, 0xC5D9, 0x74A2, 0x49CE, 0xF1FE, 0xC41F, 0x9CA0, 0xC41C, 0x1C13, + 0x484F, 0x9CA2, 0x74A2, 0x49CF, 0xF1FE, 0xB005, 0xB004, 0xFF80, 0xB404, + 0xB405, 0xC5C7, 0x74A2, 0x49CE, 0xF1FE, 0xC40E, 0x9CA0, 0xC40A, 0x1C13, + 0x484F, 0x9CA2, 0x74A2, 0x49CF, 0xF1FE, 0xB005, 0xB004, 0xFF80, 0x0000, + 0x0481, 0x0C81, 0x0AE0 + }; + + DisableMcuBPs(sc); + + re_write_mac_mcu_ram_code(sc, mcu_patch_code_8168gu_2, ARRAY_SIZE(mcu_patch_code_8168gu_2)); + + 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_8168ep_1(struct re_softc *sc) +{ + static const uint16_t mcu_patch_code_8168ep_1[] = { + 0xE008, 0xE0D3, 0xE0D6, 0xE0D9, 0xE0DB, 0xE0DD, 0xE0DF, 0xE0E1, 0xC251, + 0x7340, 0x49B1, 0xF010, 0x1D02, 0x8D40, 0xC202, 0xBA00, 0x2C3A, 0xC0F0, + 0xE8DE, 0x2000, 0x8000, 0xC0B6, 0x268C, 0x752C, 0x49D4, 0xF112, 0xE025, + 0xC2F6, 0x7146, 0xC2F5, 0x7340, 0x49BE, 0xF103, 0xC7F2, 0xE002, 0xC7F1, + 0x304F, 0x6226, 0x49A1, 0xF1F0, 0x7222, 0x49A0, 0xF1ED, 0x2525, 0x1F28, + 0x3097, 0x3091, 0x9A36, 0x752C, 0x21DC, 0x25BC, 0xC6E2, 0x77C0, 0x1304, + 0xF014, 0x1303, 0xF014, 0x1302, 0xF014, 0x1301, 0xF014, 0x49D4, 0xF103, + 0xC3D7, 0xBB00, 0xC618, 0x67C6, 0x752E, 0x22D7, 0x26DD, 0x1505, 0xF013, + 0xC60A, 0xBE00, 0xC309, 0xBB00, 0xC308, 0xBB00, 0xC307, 0xBB00, 0xC306, + 0xBB00, 0x25C8, 0x25A6, 0x25AC, 0x25B2, 0x25B8, 0xCD08, 0x0000, 0xC0BC, + 0xC2FF, 0x7340, 0x49B0, 0xF04E, 0x1F46, 0x308F, 0xC3F7, 0x1C04, 0xE84D, + 0x1401, 0xF147, 0x7226, 0x49A7, 0xF044, 0x7222, 0x2525, 0x1F30, 0x3097, + 0x3091, 0x7340, 0xC4EA, 0x401C, 0xF006, 0xC6E8, 0x75C0, 0x49D7, 0xF105, + 0xE036, 0x1D08, 0x8DC1, 0x0208, 0x6640, 0x2764, 0x1606, 0xF12F, 0x6346, + 0x133B, 0xF12C, 0x9B34, 0x1B18, 0x3093, 0xC32A, 0x1C10, 0xE82A, 0x1401, + 0xF124, 0x1A36, 0x308A, 0x7322, 0x25B5, 0x0B0E, 0x1C00, 0xE82C, 0xC71F, + 0x4027, 0xF11A, 0xE838, 0x1F42, 0x308F, 0x1B08, 0xE824, 0x7236, 0x7746, + 0x1700, 0xF00D, 0xC313, 0x401F, 0xF103, 0x1F00, 0x9F46, 0x7744, 0x449F, + 0x445F, 0xE817, 0xC70A, 0x4027, 0xF105, 0xC302, 0xBB00, 0x2E08, 0x2DC2, + 0xC7FF, 0xBF00, 0xCDB8, 0xFFFF, 0x0C02, 0xA554, 0xA5DC, 0x402F, 0xF105, + 0x1400, 0xF1FA, 0x1C01, 0xE002, 0x1C00, 0xFF80, 0x49B0, 0xF004, 0x0B01, + 0xA1D3, 0xE003, 0x0B02, 0xA5D3, 0x3127, 0x3720, 0x0B02, 0xA5D3, 0x3127, + 0x3720, 0x1300, 0xF1FB, 0xFF80, 0x7322, 0x25B5, 0x1E28, 0x30DE, 0x30D9, + 0x7264, 0x1E11, 0x2368, 0x3116, 0xFF80, 0x1B7E, 0xC602, 0xBE00, 0x06A6, + 0x1B7E, 0xC602, 0xBE00, 0x0764, 0xC602, 0xBE00, 0x0000, 0xC602, 0xBE00, + 0x0000, 0xC602, 0xBE00, 0x0000, 0xC602, 0xBE00, 0x0000, 0xC602, 0xBE00, + 0x0000 + }; + + DisableMcuBPs(sc); + + re_write_mac_mcu_ram_code(sc, mcu_patch_code_8168ep_1, ARRAY_SIZE(mcu_patch_code_8168ep_1)); + + MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000); + + MP_WriteMcuAccessRegWord(sc, 0xFC28, 0x2549); + MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x06A5); + MP_WriteMcuAccessRegWord(sc, 0xFC2C, 0x0763); +} + +static bool re_check_dash_other_fun_present(struct re_softc *sc) +{ + //check if func 2 exist + if (MP_ReadOtherFunPciEConfigSpace(sc, 2, 0xf000) != 0xffffffff) + return true; + + return false; +} + +static void re_set_mac_mcu_8168ep_2(struct re_softc *sc) +{ + static const uint16_t mcu_patch_code_8168ep_2[] = { + 0xE008, 0xE017, 0xE052, 0xE057, 0xE059, 0xE05B, 0xE05D, 0xE05F, 0xC50F, + 0x76A4, 0x49E3, 0xF007, 0x49C0, 0xF103, 0xC607, 0xBE00, 0xC606, 0xBE00, + 0xC602, 0xBE00, 0x0BDA, 0x0BB6, 0x0BBA, 0xDC00, 0xB400, 0xB401, 0xB402, + 0xB403, 0xB404, 0xC02E, 0x7206, 0x49AE, 0xF1FE, 0xC12B, 0x9904, 0xC12A, + 0x9906, 0x7206, 0x49AE, 0xF1FE, 0x7200, 0x49A0, 0xF117, 0xC123, 0xC223, + 0xC323, 0xE808, 0xC322, 0xE806, 0xC321, 0xE804, 0xC320, 0xE802, 0xE00C, + 0x740E, 0x49CE, 0xF1FE, 0x9908, 0x990A, 0x9A0C, 0x9B0E, 0x740E, 0x49CE, + 0xF1FE, 0xFF80, 0xB004, 0xB003, 0xB002, 0xB001, 0xB000, 0xC604, 0xC002, + 0xB800, 0x1FC8, 0xE000, 0xE8E0, 0xF128, 0x0002, 0xFFFF, 0xF000, 0x8001, + 0x8002, 0x8003, 0x8004, 0x48C1, 0x48C2, 0x9C46, 0xC402, 0xBC00, 0x0490, + 0xC602, 0xBE00, 0x0000, 0xC602, 0xBE00, 0x0000, 0xC602, 0xBE00, 0x0000, + 0xC602, 0xBE00, 0x0000, 0xC602, 0xBE00, 0x0000 + }; + + DisableMcuBPs(sc); + + re_write_mac_mcu_ram_code(sc, mcu_patch_code_8168ep_2, ARRAY_SIZE(mcu_patch_code_8168ep_2)); + + MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000); + + MP_WriteMcuAccessRegWord(sc, 0xFC28, 0x0BB3); + if (false == re_check_dash_other_fun_present(sc)) + MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x1FC7); + //MP_WriteMcuAccessRegWord(sc, 0xFC2C, 0x0485); +} + +static void re_set_mac_mcu_8411b_1(struct re_softc *sc) +{ + static const uint16_t mcu_patch_code_8411b_1[] = { + 0xE008, 0xE00A, 0xE00C, 0xE00E, 0xE027, 0xE04F, 0xE05E, 0xE065, 0xC602, + 0xBE00, 0x0000, 0xC502, 0xBD00, 0x074C, 0xC302, 0xBB00, 0x080A, 0x6420, + 0x48C2, 0x8C20, 0xC516, 0x64A4, 0x49C0, 0xF009, 0x74A2, 0x8CA5, 0x74A0, + 0xC50E, 0x9CA2, 0x1C11, 0x9CA0, 0xE006, 0x74F8, 0x48C4, 0x8CF8, 0xC404, + 0xBC00, 0xC403, 0xBC00, 0x0BF2, 0x0C0A, 0xE434, 0xD3C0, 0x49D9, 0xF01F, + 0xC526, 0x64A5, 0x1400, 0xF007, 0x0C01, 0x8CA5, 0x1C15, 0xC51B, 0x9CA0, + 0xE013, 0xC519, 0x74A0, 0x48C4, 0x8CA0, 0xC516, 0x74A4, 0x48C8, 0x48CA, + 0x9CA4, 0xC512, 0x1B00, 0x9BA0, 0x1B1C, 0x483F, 0x9BA2, 0x1B04, 0xC508, + 0x9BA0, 0xC505, 0xBD00, 0xC502, 0xBD00, 0x0300, 0x051E, 0xE434, 0xE018, + 0xE092, 0xDE20, 0xD3C0, 0xC50F, 0x76A4, 0x49E3, 0xF007, 0x49C0, 0xF103, + 0xC607, 0xBE00, 0xC606, 0xBE00, 0xC602, 0xBE00, 0x0C4C, 0x0C28, 0x0C2C, + 0xDC00, 0xC707, 0x1D00, 0x8DE2, 0x48C1, 0xC502, 0xBD00, 0x00AA, 0xE0C0, + 0xC502, 0xBD00, 0x0132 + }; + + DisableMcuBPs(sc); + + re_write_mac_mcu_ram_code(sc, mcu_patch_code_8411b_1, ARRAY_SIZE(mcu_patch_code_8411b_1)); + + 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_8168h_1(struct re_softc *sc) +{ + DisableMcuBPs(sc); +} + +static void re_set_mac_mcu_8168h_2(struct re_softc *sc) +{ + static const uint16_t mcu_patch_code_8168h_1[] = { + 0xE008, 0xE00F, 0xE011, 0xE047, 0xE049, 0xE073, 0xE075, 0xE07A, 0xC707, + 0x1D00, 0x8DE2, 0x48C1, 0xC502, 0xBD00, 0x00E4, 0xE0C0, 0xC502, 0xBD00, + 0x0216, 0xC634, 0x75C0, 0x49D3, 0xF027, 0xC631, 0x75C0, 0x49D3, 0xF123, + 0xC627, 0x75C0, 0xB405, 0xC525, 0x9DC0, 0xC621, 0x75C8, 0x49D5, 0xF00A, + 0x49D6, 0xF008, 0x49D7, 0xF006, 0x49D8, 0xF004, 0x75D2, 0x49D9, 0xF111, + 0xC517, 0x9DC8, 0xC516, 0x9DD2, 0xC618, 0x75C0, 0x49D4, 0xF003, 0x49D0, + 0xF104, 0xC60A, 0xC50E, 0x9DC0, 0xB005, 0xC607, 0x9DC0, 0xB007, 0xC602, + 0xBE00, 0x1A06, 0xB400, 0xE86C, 0xA000, 0x01E1, 0x0200, 0x9200, 0xE84C, + 0xE004, 0xE908, 0xC502, 0xBD00, 0x0B58, 0xB407, 0xB404, 0x2195, 0x25BD, + 0x9BE0, 0x1C1C, 0x484F, 0x9CE2, 0x72E2, 0x49AE, 0xF1FE, 0x0B00, 0xF116, + 0xC71C, 0xC419, 0x9CE0, 0x1C13, 0x484F, 0x9CE2, 0x74E2, 0x49CE, 0xF1FE, + 0xC412, 0x9CE0, 0x1C13, 0x484F, 0x9CE2, 0x74E2, 0x49CE, 0xF1FE, 0xC70C, + 0x74F8, 0x48C3, 0x8CF8, 0xB004, 0xB007, 0xC502, 0xBD00, 0x0F24, 0x0481, + 0x0C81, 0xDE24, 0xE000, 0xC602, 0xBE00, 0x0CA4, 0x48C1, 0x48C2, 0x9C46, + 0xC402, 0xBC00, 0x0578, 0xC602, 0xBE00, 0x0000 + }; + + DisableMcuBPs(sc); + + re_write_mac_mcu_ram_code(sc, mcu_patch_code_8168h_1, ARRAY_SIZE(mcu_patch_code_8168h_1)); + + 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); + //MP_WriteMcuAccessRegWord(sc, 0xFC34, 0x056C); + + 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_8168h_3(struct re_softc *sc) +{ + DisableMcuBPs(sc); +} + +static void re_set_mac_mcu_8168fp_1(struct re_softc *sc) +{ + uint16_t breakPointEnabled = 0; + + DisableMcuBPs(sc); + + if(sc->HwPkgDet == 0x00 || sc->HwPkgDet == 0x0F) { + static const uint16_t mcu_patch_code_8168fp_1_1[] = { + 0xE00A, 0xE0C1, 0xE104, 0xE108, 0xE10D, 0xE112, 0xE11C, 0xE121, 0xE000, + 0xE0C8, 0xB400, 0xC1FE, 0x49E2, 0xF04C, 0x49EA, 0xF04A, 0x74E6, 0xC246, + 0x7542, 0x73EC, 0x1800, 0x49C0, 0xF10D, 0x49C1, 0xF10B, 0x49C2, 0xF109, + 0x49B0, 0xF107, 0x49B1, 0xF105, 0x7220, 0x49A2, 0xF102, 0xE002, 0x4800, + 0x49D0, 0xF10A, 0x49D1, 0xF108, 0x49D2, 0xF106, 0x49D3, 0xF104, 0x49DF, + 0xF102, 0xE00C, 0x4801, 0x72E4, 0x49AD, 0xF108, 0xC225, 0x6741, 0x48F0, + 0x8F41, 0x4870, 0x8F41, 0xC7CF, 0x49B5, 0xF01F, 0x49B2, 0xF00B, 0x4980, + 0xF003, 0x484E, 0x94E7, 0x4981, 0xF004, 0x485E, 0xC212, 0x9543, 0xE071, + 0x49B6, 0xF003, 0x49B3, 0xF10F, 0x4980, 0xF003, 0x484E, 0x94E7, 0x4981, + 0xF004, 0x485E, 0xC204, 0x9543, 0xE005, 0xE000, 0xE0FC, 0xE0FA, 0xE065, + 0x49B7, 0xF007, 0x4980, 0xF005, 0x1A38, 0x46D4, 0x1200, 0xF109, 0x4981, + 0xF055, 0x49C3, 0xF105, 0x1A30, 0x46D5, 0x1200, 0xF04F, 0x7220, 0x49A2, + 0xF130, 0x49C1, 0xF12E, 0x49B0, 0xF12C, 0xC2E6, 0x7240, 0x49A8, 0xF003, + 0x49D0, 0xF126, 0x49A9, 0xF003, 0x49D1, 0xF122, 0x49AA, 0xF003, 0x49D2, + 0xF11E, 0x49AB, 0xF003, 0x49DF, 0xF11A, 0x49AC, 0xF003, 0x49D3, 0xF116, + 0x4980, 0xF003, 0x49C7, 0xF105, 0x4981, 0xF02C, 0x49D7, 0xF02A, 0x49C0, + 0xF00C, 0xC721, 0x62F4, 0x49A0, 0xF008, 0x49A4, 0xF106, 0x4824, 0x8AF4, + 0xC71A, 0x1A40, 0x9AE0, 0x49B6, 0xF017, 0x200E, 0xC7B8, 0x72E0, 0x4710, + 0x92E1, 0xC70E, 0x77E0, 0x49F0, 0xF112, 0xC70B, 0x77E0, 0x27FE, 0x1AFA, + 0x4317, 0xC705, 0x9AE2, 0x1A11, 0x8AE0, 0xE008, 0xE41C, 0xC0AE, 0xD23A, + 0xC7A2, 0x74E6, 0x484F, 0x94E7, 0xC79E, 0x8CE6, 0x8BEC, 0xC29C, 0x8D42, + 0x7220, 0xB000, 0xC502, 0xBD00, 0x0932, 0xB400, 0xC240, 0xC340, 0x7060, + 0x498F, 0xF014, 0x488F, 0x9061, 0x744C, 0x49C3, 0xF004, 0x7562, 0x485E, + 0x9563, 0x7446, 0x49C3, 0xF106, 0x7562, 0x1C30, 0x46E5, 0x1200, 0xF004, + 0x7446, 0x484F, 0x9447, 0xC32A, 0x7466, 0x49C0, 0xF00F, 0x48C0, 0x9C66, + 0x7446, 0x4840, 0x4841, 0x4842, 0x9C46, 0x744C, 0x4840, 0x9C4C, 0x744A, + 0x484A, 0x9C4A, 0xE013, 0x498E, 0xF011, 0x488E, 0x9061, 0x744C, 0x49C3, + 0xF004, 0x7446, 0x484E, 0x9447, 0x7446, 0x1D38, 0x46EC, 0x1500, 0xF004, + 0x7446, 0x484F, 0x9447, 0xB000, 0xC502, 0xBD00, 0x074C, 0xE000, 0xE0FC, + 0xE0C0, 0x4830, 0x4837, 0xC502, 0xBD00, 0x0978, 0x63E2, 0x4830, 0x4837, + 0xC502, 0xBD00, 0x09FE, 0x73E2, 0x4830, 0x8BE2, 0xC302, 0xBB00, 0x0A12, + 0x73E2, 0x48B0, 0x48B3, 0x48B4, 0x48B5, 0x48B6, 0x48B7, 0x8BE2, 0xC302, + 0xBB00, 0x0A5A, 0x73E2, 0x4830, 0x8BE2, 0xC302, 0xBB00, 0x0A6C, 0x73E2, + 0x4830, 0x4837, 0xC502, 0xBD00, 0x0A86 + }; + + re_write_mac_mcu_ram_code(sc, mcu_patch_code_8168fp_1_1, ARRAY_SIZE(mcu_patch_code_8168fp_1_1)); + + 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); + + } else if (sc->HwPkgDet == 0x6) { + static const uint16_t mcu_patch_code_8168fp_1_2[] = { + 0xE008, 0xE00A, 0xE031, 0xE033, 0xE035, 0xE144, 0xE166, 0xE168, 0xC502, + 0xBD00, 0x0000, 0xC725, 0x75E0, 0x48D0, 0x9DE0, 0xC722, 0x75E0, 0x1C78, + 0x416C, 0x1530, 0xF111, 0xC71D, 0x75F6, 0x49D1, 0xF00D, 0x75E0, 0x1C1F, + 0x416C, 0x1502, 0xF108, 0x75FA, 0x49D3, 0xF005, 0x75EC, 0x9DE4, 0x4853, + 0x9DFA, 0xC70B, 0x75E0, 0x4852, 0x4850, 0x9DE0, 0xC602, 0xBE00, 0x04B8, + 0xE420, 0xE000, 0xE0FC, 0xE43C, 0xDC00, 0xEB00, 0xC202, 0xBA00, 0x0000, + 0xC002, 0xB800, 0x0000, 0xB401, 0xB402, 0xB403, 0xB404, 0xB405, 0xB406, + 0xC44D, 0xC54D, 0x1867, 0xE8A2, 0x2318, 0x276E, 0x1601, 0xF106, 0x1A07, + 0xE861, 0xE86B, 0xE873, 0xE037, 0x231E, 0x276E, 0x1602, 0xF10B, 0x1A07, + 0xE858, 0xE862, 0xC247, 0xC344, 0xE8E3, 0xC73B, 0x66E0, 0xE8B5, 0xE029, + 0x231A, 0x276C, 0xC733, 0x9EE0, 0x1866, 0xE885, 0x251C, 0x120F, 0xF011, + 0x1209, 0xF011, 0x2014, 0x240E, 0x1000, 0xF007, 0x120C, 0xF00D, 0x1203, + 0xF00D, 0x1200, 0xF00D, 0x120C, 0xF00D, 0x1203, 0xF00D, 0x1A03, 0xE00C, + 0x1A07, 0xE00A, 0x1A00, 0xE008, 0x1A01, 0xE006, 0x1A02, 0xE004, 0x1A04, + 0xE002, 0x1A05, 0xE829, 0xE833, 0xB006, 0xB005, 0xB004, 0xB003, 0xB002, + 0xB001, 0x60C4, 0xC702, 0xBF00, 0x2786, 0xDD00, 0xD030, 0xE0C4, 0xE0F8, + 0xDC42, 0xD3F0, 0x0000, 0x0004, 0x0007, 0x0014, 0x0090, 0x1000, 0x0F00, + 0x1004, 0x1008, 0x3000, 0x3004, 0x3008, 0x4000, 0x7777, 0x8000, 0x8001, + 0x8008, 0x8003, 0x8004, 0xC000, 0xC004, 0xF004, 0xFFFF, 0xB406, 0xB407, + 0xC6E5, 0x77C0, 0x27F3, 0x23F3, 0x47FA, 0x9FC0, 0xB007, 0xB006, 0xFF80, + 0xB405, 0xB407, 0xC7D8, 0x75E0, 0x48D0, 0x9DE0, 0xB007, 0xB005, 0xFF80, + 0xB401, 0xC0EA, 0xC2DC, 0xC3D8, 0xE865, 0xC0D3, 0xC1E0, 0xC2E3, 0xE861, + 0xE817, 0xC0CD, 0xC2CF, 0xE85D, 0xC0C9, 0xC1D6, 0xC2DB, 0xE859, 0xE80F, + 0xC1C7, 0xC2CE, 0xE855, 0xC0C0, 0xC1D1, 0xC2D3, 0xE851, 0xE807, 0xC0BE, + 0xC2C2, 0xE84D, 0xE803, 0xB001, 0xFF80, 0xB402, 0xC2C6, 0xE859, 0x499F, + 0xF1FE, 0xB002, 0xFF80, 0xB402, 0xB403, 0xB407, 0xE821, 0x8882, 0x1980, + 0x8983, 0xE81D, 0x7180, 0x218B, 0x25BB, 0x1310, 0xF014, 0x1310, 0xFB03, + 0x1F20, 0x38FB, 0x3288, 0x434B, 0x2491, 0x430B, 0x1F0F, 0x38FB, 0x4313, + 0x2121, 0x4353, 0x2521, 0x418A, 0x6282, 0x2527, 0x212F, 0x418A, 0xB007, + 0xB003, 0xB002, 0xFF80, 0x6183, 0x2496, 0x1100, 0xF1FD, 0xFF80, 0x4800, + 0x4801, 0xC213, 0xC313, 0xE815, 0x4860, 0x8EE0, 0xC210, 0xC310, 0xE822, + 0x481E, 0xC20C, 0xC30C, 0xE80C, 0xC206, 0x7358, 0x483A, 0x9B58, 0xFF80, + 0xE8E0, 0xE000, 0x1008, 0x0F00, 0x800C, 0x0F00, 0xB407, 0xB406, 0xB403, + 0xC7F7, 0x98E0, 0x99E2, 0x9AE4, 0x21B2, 0x4831, 0x483F, 0x9BE6, 0x66E7, + 0x49E6, 0xF1FE, 0xB003, 0xB006, 0xB007, 0xFF80, 0xB407, 0xB406, 0xB403, + 0xC7E5, 0x9AE4, 0x21B2, 0x4831, 0x9BE6, 0x66E7, 0x49E6, 0xF1FE, 0x70E0, + 0x71E2, 0xB003, 0xB006, 0xB007, 0xFF80, 0x4882, 0xB406, 0xB405, 0xC71E, + 0x76E0, 0x1D78, 0x4175, 0x1630, 0xF10C, 0xC715, 0x76E0, 0x4861, 0x9EE0, + 0xC713, 0x1EFF, 0x9EE2, 0x75E0, 0x4850, 0x9DE0, 0xE005, 0xC70B, 0x76E0, + 0x4865, 0x9EE0, 0xB005, 0xB006, 0xC708, 0xC102, 0xB900, 0x279E, 0xEB16, + 0xEB00, 0xE43C, 0xDC00, 0xD3EC, 0xC602, 0xBE00, 0x0000, 0xC602, 0xBE00, + 0x0000 + }; + + re_write_mac_mcu_ram_code(sc, mcu_patch_code_8168fp_1_2, ARRAY_SIZE(mcu_patch_code_8168fp_1_2)); + + 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); + } + + if (sc->HwPkgDet == 0x00) + breakPointEnabled = 0x00FC; + else if (sc->HwPkgDet == 0x0F) + breakPointEnabled = 0x00FF; + else if (sc->HwPkgDet == 0x06) + breakPointEnabled = 0x0022; + + MP_WriteMcuAccessRegWord(sc, 0xFC38, breakPointEnabled); +} + +static void re_set_mac_mcu_8168fp_8116as_2(struct re_softc *sc) +{ + static const uint16_t mcu_patch_code_8168fp_2[] = { + 0xE008, 0xE00A, 0xE00F, 0xE014, 0xE016, 0xE018, 0xE01A, 0xE01C, 0xC602, + 0xBE00, 0x2AB2, 0x1BC0, 0x46EB, 0x1BFE, 0xC102, 0xB900, 0x0B1A, 0x1BC0, + 0x46EB, 0x1B7E, 0xC102, 0xB900, 0x0BEA, 0xC602, 0xBE00, 0x0000, 0xC602, + 0xBE00, 0x0000, 0xC602, 0xBE00, 0x0000, 0xC602, 0xBE00, 0x0000, 0xC602, + 0xBE00, 0x0000 + }; + + DisableMcuBPs(sc); + + re_write_mac_mcu_ram_code(sc, mcu_patch_code_8168fp_2, ARRAY_SIZE(mcu_patch_code_8168fp_2)); + + MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000); + + MP_WriteMcuAccessRegWord(sc, 0xFC28, 0x2AAC); + MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x0B14); + MP_WriteMcuAccessRegWord(sc, 0xFC2C, 0x0BE4); + + MP_WriteMcuAccessRegWord(sc, 0xFC38, 0x0007); +} + +static void _re_set_mac_mcu_8168fp_2(struct re_softc *sc) +{ + static const uint16_t mcu_patch_code_8168fp_2[] = { + 0xE008, 0xE00A, 0xE00F, 0xE014, 0xE05F, 0xE064, 0xE066, 0xE068, 0xC602, + 0xBE00, 0x0000, 0x1BC0, 0x46EB, 0x1BFE, 0xC102, 0xB900, 0x0B1A, 0x1BC0, + 0x46EB, 0x1B7E, 0xC102, 0xB900, 0x0BEA, 0xB400, 0xB401, 0xB402, 0xB403, + 0xB404, 0xB405, 0xC03A, 0x7206, 0x49AE, 0xF1FE, 0xC137, 0x9904, 0xC136, + 0x9906, 0x7206, 0x49AE, 0xF1FE, 0x7200, 0x49A0, 0xF10B, 0xC52F, 0xC12E, + 0xC232, 0xC332, 0xE812, 0xC331, 0xE810, 0xC330, 0xE80E, 0xE018, 0xC126, + 0xC229, 0xC525, 0xC328, 0xE808, 0xC523, 0xC326, 0xE805, 0xC521, 0xC324, + 0xE802, 0xE00C, 0x740E, 0x49CE, 0xF1FE, 0x9908, 0x9D0A, 0x9A0C, 0x9B0E, + 0x740E, 0x49CE, 0xF1FE, 0xFF80, 0xB005, 0xB004, 0xB003, 0xB002, 0xB001, + 0xB000, 0xC604, 0xC002, 0xB800, 0x2A5E, 0xE000, 0xE8E0, 0xF128, 0x3DC2, + 0xFFFF, 0x10EC, 0x816A, 0x816D, 0x816C, 0xF000, 0x8002, 0x8004, 0x8007, + 0x48C1, 0x48C2, 0x9C46, 0xC402, 0xBC00, 0x07BC, 0xC602, 0xBE00, 0x0000, + 0xC602, 0xBE00, 0x0000, 0xC602, 0xBE00, 0x0000 + }; + + DisableMcuBPs(sc); + + re_write_mac_mcu_ram_code(sc, mcu_patch_code_8168fp_2, ARRAY_SIZE(mcu_patch_code_8168fp_2)); + + MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000); + + MP_WriteMcuAccessRegWord(sc, 0xFC28, 0x2AAC); + MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x0B14); + MP_WriteMcuAccessRegWord(sc, 0xFC2C, 0x0BE4); + MP_WriteMcuAccessRegWord(sc, 0xFC2E, 0x2A5C); + //MP_WriteMcuAccessRegWord(sc, 0xFC30, 0x07B0); + + if (true == re_check_dash_other_fun_present(sc)) + MP_WriteMcuAccessRegWord(sc, 0xFC38, 0x0006); + else + MP_WriteMcuAccessRegWord(sc, 0xFC38, 0x000E); +} + +static void re_set_mac_mcu_8168fp_2(struct re_softc *sc) +{ + if (sc->hw_hw_supp_serdes_phy_ver == 1) + re_set_mac_mcu_8168fp_8116as_2(sc); + else + _re_set_mac_mcu_8168fp_2(sc); +} + +static void re_set_mac_mcu_8168fp_3(struct re_softc *sc) +{ + static const uint16_t mcu_patch_code_8168fp_3[] = { + 0xE008, 0xE053, 0xE058, 0xE05A, 0xE05C, 0xE05E, 0xE060, 0xE062, 0xB400, + 0xB401, 0xB402, 0xB403, 0xB404, 0xB405, 0xC03A, 0x7206, 0x49AE, 0xF1FE, + 0xC137, 0x9904, 0xC136, 0x9906, 0x7206, 0x49AE, 0xF1FE, 0x7200, 0x49A0, + 0xF10B, 0xC52F, 0xC12E, 0xC232, 0xC332, 0xE812, 0xC331, 0xE810, 0xC330, + 0xE80E, 0xE018, 0xC126, 0xC229, 0xC525, 0xC328, 0xE808, 0xC523, 0xC326, + 0xE805, 0xC521, 0xC324, 0xE802, 0xE00C, 0x740E, 0x49CE, 0xF1FE, 0x9908, + 0x9D0A, 0x9A0C, 0x9B0E, 0x740E, 0x49CE, 0xF1FE, 0xFF80, 0xB005, 0xB004, + 0xB003, 0xB002, 0xB001, 0xB000, 0xC604, 0xC002, 0xB800, 0x2B16, 0xE000, + 0xE8E0, 0xF128, 0x3DC2, 0xFFFF, 0x10EC, 0x816A, 0x816D, 0x816C, 0xF000, + 0x8002, 0x8004, 0x8007, 0x48C1, 0x48C2, 0x9C46, 0xC402, 0xBC00, 0x07BC, + 0xC602, 0xBE00, 0x0000, 0xC602, 0xBE00, 0x0000, 0xC602, 0xBE00, 0x0000, + 0xC602, 0xBE00, 0x0000, 0xC602, 0xBE00, 0x0000, 0xC602, 0xBE00, 0x0000 + }; + + DisableMcuBPs(sc); + + re_write_mac_mcu_ram_code(sc, mcu_patch_code_8168fp_3, ARRAY_SIZE(mcu_patch_code_8168fp_3)); + + MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000); + + MP_WriteMcuAccessRegWord(sc, 0xFC28, 0x2B14); + //MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x07B0); + + if (true == re_check_dash_other_fun_present(sc)) + MP_WriteMcuAccessRegWord(sc, 0xFC38, 0x0000); + else + MP_WriteMcuAccessRegWord(sc, 0xFC38, 0x0001); +} + +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) +{ + static const u_int16_t mcu_patch_code_8125a_2[] = { + 0xE010, 0xE012, 0xE022, 0xE024, 0xE029, 0xE02B, 0xE094, 0xE09D, 0xE09F, + 0xE0AA, 0xE0B5, 0xE0C6, 0xE0CC, 0xE0D1, 0xE0D6, 0xE0D8, 0xC602, 0xBE00, + 0x0000, 0xC60F, 0x73C4, 0x49B3, 0xF106, 0x73C2, 0xC608, 0xB406, 0xC609, + 0xFF80, 0xC605, 0xB406, 0xC605, 0xFF80, 0x0544, 0x0568, 0xE906, 0xCDE8, + 0xC602, 0xBE00, 0x0000, 0x48C1, 0x48C2, 0x9C46, 0xC402, 0xBC00, 0x0A12, + 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, 0x740A, 0x4846, 0x4847, 0x9C0A, + 0xC607, 0x74C0, 0x48C6, 0x9CC0, 0xC602, 0xBE00, 0x13FE, 0xE054, 0x72CA, + 0x4826, 0x4827, 0x9ACA, 0xC607, 0x72C0, 0x48A6, 0x9AC0, 0xC602, 0xBE00, + 0x07DC, 0xE054, 0xC60F, 0x74C4, 0x49CC, 0xF109, 0xC60C, 0x74CA, 0x48C7, + 0x9CCA, 0xC609, 0x74C0, 0x4846, 0x9CC0, 0xC602, 0xBE00, 0x2480, 0xE092, + 0xE0C0, 0xE054, 0x7420, 0x48C0, 0x9C20, 0x7444, 0xC602, 0xBE00, 0x12F8, + 0x1BFF, 0x46EB, 0x1BFF, 0xC102, 0xB900, 0x0D5A, 0x1BFF, 0x46EB, 0x1BFF, + 0xC102, 0xB900, 0x0E2A, 0xC602, 0xBE00, 0x0000, 0xC602, 0xBE00, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6486, + 0x0B15, 0x090E, 0x1139 + }; + + DisableMcuBPs(sc); + + re_write_mac_mcu_ram_code(sc, mcu_patch_code_8125a_2, ARRAY_SIZE(mcu_patch_code_8125a_2)); + + MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000); + + MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x0540); + MP_WriteMcuAccessRegWord(sc, 0xFC2E, 0x0A06); + MP_WriteMcuAccessRegWord(sc, 0xFC30, 0x0EB8); + MP_WriteMcuAccessRegWord(sc, 0xFC32, 0x3A5C); + MP_WriteMcuAccessRegWord(sc, 0xFC34, 0x10A8); + MP_WriteMcuAccessRegWord(sc, 0xFC40, 0x0D54); + MP_WriteMcuAccessRegWord(sc, 0xFC42, 0x0E24); + + MP_WriteMcuAccessRegWord(sc, 0xFC48, 0x307A); +} + +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) +{ + static const u_int16_t mcu_patch_code_8125b_2[] = { + 0xE010, 0xE01B, 0xE026, 0xE037, 0xE03D, 0xE057, 0xE05B, 0xE060, 0xE062, + 0xE064, 0xE066, 0xE068, 0xE06A, 0xE06C, 0xE06E, 0xE070, 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, 0x48C1, 0x48C2, + 0x9C46, 0xC402, 0xBC00, 0x0A52, 0xC602, 0xBE00, 0x0000, 0xC602, 0xBE00, + 0x0000, 0xC602, 0xBE00, 0x0000, 0xC602, 0xBE00, 0x0000, 0xC602, 0xBE00, + 0x0000, 0xC602, 0xBE00, 0x0000, 0xC602, 0xBE00, 0x0000, 0xC602, 0xBE00, + 0x0000, 0xC602, 0xBE00, 0x0000 + }; + + DisableMcuBPs(sc); + + re_write_mac_mcu_ram_code(sc, mcu_patch_code_8125b_2, ARRAY_SIZE(mcu_patch_code_8125b_2)); + + 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, 0xFC34, 0x0A46); + + 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: + re_set_mac_mcu_8168h_1(sc); + break; + case MACFG_69: + re_set_mac_mcu_8168h_2(sc); + break; + case MACFG_70: + re_set_mac_mcu_8168fp_1(sc); + break; + case MACFG_71: + re_set_mac_mcu_8168fp_2(sc); + break; + case MACFG_72: + re_set_mac_mcu_8168fp_3(sc); + break; + case MACFG_73: + re_set_mac_mcu_8168fp_4(sc); + break; + case MACFG_74: + re_set_mac_mcu_8168h_3(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) +{ + arc4rand(dst, 6, 0); + + dst[0] &= 0xfe; + dst[0] |= 0x02; +} + +static void re_disable_now_is_oob(struct re_softc *sc) +{ + if (sc->re_hw_supp_now_is_oob_ver == 1) + 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: + case MACFG_73: + case MACFG_80: + case MACFG_81: + 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: + case MACFG_73: + case MACFG_74: + 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: + 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; + } + break; + 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)); + } + + CSR_WRITE_1(sc, RE_COMMAND, CSR_READ_1(sc, RE_COMMAND) | RE_CMD_STOP_REQ); + + 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; + } + + 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: + case MACFG_73: + case MACFG_74: + 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_73: + case MACFG_74: + 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_73: + case MACFG_74: + 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: + case MACFG_73: + case MACFG_74: + *(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)) { + device_printf(dev,"Invalid ether addr: %6D\n", eaddr, ":"); + random_ether_addr(eaddr); + device_printf(dev,"Random ether addr: %6D\n", eaddr, ":"); + } + + 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; + if ((MP_ReadMcuAccessRegWord(sc, 0xD006) & 0xFF00) == 0x0100) + sc->re_type = MACFG_74; + 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 0x54C00000: + sc->re_type = MACFG_73; + 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, 0x40C00800); + 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, 0x40C00800); + 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_8162: + 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_8162: + 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: + case MACFG_73: + sc->HwSuppDashVer = 3; + break; + case MACFG_80: + case MACFG_81: { + u_int8_t tmpUchar; + tmpUchar = (u_int8_t)MP_ReadMcuAccessRegWord(sc, 0xD006); + if (tmpUchar == 0x02 || tmpUchar == 0x04) + sc->HwSuppDashVer = 2; + } + break; + default: + sc->HwSuppDashVer = 0; + break; + } + + switch(sc->re_type) { + case MACFG_70: + case MACFG_71: + case MACFG_72: + case MACFG_73: + sc->HwPkgDet = MP_ReadMcuAccessRegWord(sc, 0xDC00); + sc->HwPkgDet = (sc->HwPkgDet >> 3) & 0x0F; + break; + } + + switch(sc->re_type) { + case MACFG_71: + case MACFG_72: + case MACFG_73: + 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 */ + sc->re_mapped_cmac_tag = X86_BUS_SPACE_MEM; + if (bus_space_map(sc->re_mapped_cmac_tag, CmacMemPhysAddress, RE_REGS_SIZE, 0, + &cmac_ioaddr)) + sc->re_dash = 0; + else + sc->re_mapped_cmac_handle = cmac_ioaddr; + } + } + } + + switch(sc->re_type) { + case MACFG_61: + case MACFG_62: + case MACFG_67: + sc->re_cmac_handle = sc->re_bhandle; + sc->re_cmac_tag = sc->re_btag; + break; + case MACFG_70: + case MACFG_71: + case MACFG_72: + case MACFG_73: + 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: + case MACFG_73: + case MACFG_74: + 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: + case MACFG_73: { + 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_74: + sc->RequiredSecLanDonglePatch = FALSE; + break; + } + + 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_73: + case MACFG_74: + 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: + case MACFG_54: + case MACFG_55: + sc->re_coalesce_tx_pkt = TRUE; + 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_73: + case MACFG_74: + 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: + case MACFG_73: + sc->re_sw_ram_code_ver = NIC_RAMCODE_VERSION_8168FP; + break; + case MACFG_74: + sc->re_sw_ram_code_ver = NIC_RAMCODE_VERSION_8168H_6838; + 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; + } + + switch (sc->re_type) { + 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: + case MACFG_73: + case MACFG_74: + sc->HwSuppMacMcuVer = 1; + break; + case MACFG_80: + case MACFG_81: + case MACFG_82: + case MACFG_83: + sc->HwSuppMacMcuVer = 2; + break; + } + + switch (sc->re_type) { + case MACFG_80: + case MACFG_81: + case MACFG_82: + case MACFG_83: + sc->MacMcuPageSize = RTL8125_MAC_MCU_PAGE_SIZE; + 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); + } + + sc->link_state = LINK_STATE_UNKNOWN; + +#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 || sc->re_type == MACFG_73 || + sc->re_type == MACFG_74) { + 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 || sc->re_type == MACFG_73 || + sc->re_type == MACFG_74) { + 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_73: + case MACFG_74: + case MACFG_80: + case MACFG_81: + case MACFG_82: + case MACFG_83: + re_disable_ocp_phy_power_saving(sc); + break; + } +} + +/* +* 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_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: + case RT_DEVICEID_8162: + 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: + case RT_DEVICEID_8162: + 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); +} + +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); +} + + +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 + ); +} + +/* + * 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; +} + +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); + + /* Init descriptors. */ + re_var_init(sc); + + 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: + case MACFG_73: + case MACFG_74: + 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 || + sc->re_type == MACFG_74) { + 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); + } + + 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); + + if (sc->re_type == MACFG_68 || sc->re_type == MACFG_69 || + sc->re_type == MACFG_74) { + 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); + } + + 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 || + sc->re_type == MACFG_74) { + MP_WriteMcuAccessRegWord(sc, 0xE054, 0x0000); + + Data32 = re_eri_read(sc, 0x5F0, 4, ERIAR_ExGMAC); + Data32 &= ~(BIT_11 | BIT_10 | BIT_9 | BIT_8 | BIT_3 | BIT_2 | BIT_1 | BIT_0); + re_eri_write(sc, 0x5F0, 4, Data32, ERIAR_ExGMAC); + } else { + re_eri_write(sc, 0x5F0, 2, 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); + + if (sc->re_type == MACFG_74) + SetMcuAccessRegBit(sc, 0xD438, (BIT_1 | BIT_0)); + + 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); + } else if (sc->re_type == MACFG_74) { + ClearMcuAccessRegBit(sc, 0xDE28, (BIT_1 | BIT_0)); + + SetMcuAccessRegBit(sc, 0xDE38, (BIT_2)); + } + + if (sc->re_type == MACFG_60) { + data16 = MP_ReadMcuAccessRegWord(sc, 0xD3C0); + data16 &= 0xF000; + data16 |= 0x0FFF; + 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); + MP_WriteMcuAccessRegWord(sc, 0xE056, data16); + + data16 = MP_ReadMcuAccessRegWord(sc, 0xE052); + data16 &= ~(BIT_15 | BIT_14 | BIT_13 | BIT_3); + data16 |= BIT_15; + 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 |= 0x45F; + 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 || + sc->re_type == MACFG_74) { + 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 (sc->HwPkgDet == 0x0F) + 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 (sc->HwPkgDet == 0x0F) + data16 |= BIT_0; + 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 |= 0x45F; + 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 || + sc->re_type == MACFG_73) + 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 (sc->HwPkgDet == 0x0F) + re_eri_write(sc, 0x5F0, 2, 0x4F00, ERIAR_ExGMAC); + else + re_eri_write(sc, 0x5F0, 2, 0x4000, 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: + case MACFG_73: + case MACFG_74: + 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: + case MACFG_73: + case MACFG_74: + 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); + } + + ifp->if_drv_flags |= IFF_DRV_RUNNING; + ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; + + /* + * Enable interrupts. + */ + CSR_WRITE_2(sc, RE_IMR, RE_INTRS); +} + +static void re_init_unlock(void *xsc) /* Software & Hardware Initialize */ +{ + struct re_softc *sc = xsc; + struct ifnet *ifp; +#if OS_VER < VERSION(6,0) + int i; +#endif + union { + uint32_t align_dummy; + u_char eaddr[ETHER_ADDR_LEN]; + } eaddr; + + ifp = RE_GET_IFNET(sc); + + /* + * Cancel pending I/O and free all RX/TX buffers. + */ + re_stop(sc); + + /* Copy MAC address on stack to align. */ +#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 + + /* Init our MAC address */ + re_rar_set(sc, eaddr.eaddr); + + sc->hw_start_unlock(sc); + + return; +} + +static void re_init(void *xsc) /* Software & Hardware Initialize */ +{ + struct re_softc *sc = xsc; + struct ifnet *ifp; + + 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); +} + +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); + + /* Init descriptors. */ + re_var_init(sc); + + 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, 0x22, 0x0023); + MP_WriteEPhyUshort(sc, 0x02, 0x60C2); + MP_WriteEPhyUshort(sc, 0x29, 0xFF00); + + MP_WriteEPhyUshort(sc, 0x4B, 0xA908); + MP_WriteEPhyUshort(sc, 0x5E, 0x28EB); + MP_WriteEPhyUshort(sc, 0x62, 0x0023); + MP_WriteEPhyUshort(sc, 0x42, 0x60C2); + MP_WriteEPhyUshort(sc, 0x69, 0xFF00); + } + + 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 << 8); + else + data16 |= (3 << 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); + + MP_WriteMcuAccessRegWord(sc, 0xE0C0, 0x4000); + + SetMcuAccessRegBit(sc, 0xE052, (BIT_6 | BIT_5)); + ClearMcuAccessRegBit(sc, 0xE052, BIT_3 | BIT_7); + + data16 = MP_ReadMcuAccessRegWord(sc, 0xC0AC); + data16 |= (BIT_7|BIT_8|BIT_9|BIT_10|BIT_11|BIT_12); + if (macver == 0x60800000) + data16 &= ~(BIT_7); + 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 |= 0x45F; + MP_WriteMcuAccessRegWord(sc, 0xD430, data16); + + //MP_WriteMcuAccessRegWord(sc, 0xE0C0, 0x4F87); + CSR_WRITE_1(sc, 0xD0, CSR_READ_1(sc, 0xD0) | (BIT_6 | BIT_7)); + + 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); + + 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); +} + +/* + * 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; +} + +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_73: + case MACFG_74: + 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 || sc->re_device_id==RT_DEVICEID_8162) { + 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); + } +} + +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); + } +} + +static void +re_clrwol(struct re_softc *sc) +{ + int pmc; + uint16_t pmstat; + uint8_t v; + + RE_LOCK_ASSERT(sc); + + if (pci_find_cap(sc->dev, PCIY_PMG, &pmc) != 0) + return; + + /* 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. + */ +static void re_stop(struct re_softc *sc) /* Stop Driver */ +{ + 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); + + /* + * 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); + } + + switch (sc->re_type) { + case MACFG_74: + SetMcuAccessRegBit(sc, 0xD438, BIT_3); + SetMcuAccessRegBit(sc, 0xDE38, BIT_2); + ClearMcuAccessRegBit(sc, 0xDE28, (BIT_1 | BIT_0)); + SetMcuAccessRegBit(sc, 0xD438, (BIT_1 | BIT_0)); + break; + } + + re_reset(sc); + + /* + * 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; +} + +/* + * 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_device_id == RT_DEVICEID_8125) { + if (re_8125_pad(sc, m_head) != 0) { + IFQ_DRV_PREPEND(&ifp->if_snd, m_head); + ifp->if_drv_flags |= IFF_DRV_OACTIVE; + 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); +} + +#define MIN_IPV4_PATCH_PKT_LEN (121) +#define MIN_IPV6_PATCH_PKT_LEN (147) +static int re_8125_pad(struct re_softc *sc,struct mbuf *m_head) +{ + struct ether_header *eh = mtod(m_head, struct ether_header *); + uint32_t min_pkt_len; + uint16_t ether_type = ntohs(eh->ether_type); + + if ((m_head->m_pkthdr.csum_flags & (CSUM_TCP | CSUM_UDP)) != 0) + goto out; + + min_pkt_len = RE_MIN_FRAMELEN; + if (ether_type == ETHERTYPE_IP) { + struct ip *ip = (struct ip *)mtodo(m_head, ETHER_HDR_LEN); + if (ip->ip_p == IPPROTO_UDP) + min_pkt_len = MIN_IPV4_PATCH_PKT_LEN; + } else if (ether_type == ETHERTYPE_IPV6) { + struct ip6_hdr *ip6 = (struct ip6_hdr *)mtodo(m_head, ETHER_HDR_LEN); + if (ip6->ip6_nxt == IPPROTO_UDP) + min_pkt_len = MIN_IPV6_PATCH_PKT_LEN; + } + + if (m_head->m_pkthdr.len < min_pkt_len) { + static const uint8_t pad[MIN_IPV4_PATCH_PKT_LEN]; + uint16_t pad_len = min_pkt_len - m_head->m_pkthdr.len; + if (!m_append(m_head, pad_len, pad)) + return (1); + + if (ether_type == ETHERTYPE_IP && + m_head->m_pkthdr.csum_flags & CSUM_IP) { + struct ip *ip; + m_head->m_data += ETHER_HDR_LEN; + ip = mtod(m_head, struct ip *); + ip->ip_sum = in_cksum(m_head, ip->ip_hl << 2); + m_head->m_data -= ETHER_HDR_LEN; + m_head->m_pkthdr.csum_flags &= ~CSUM_IP; + } + } + +out: + 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); +} + +static void re_set_multicast_reg(sc, mask0, mask4) +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; +} + +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; +} + +static void re_set_rx_packet_filter(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_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(sc) +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; + } + + /* 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 + { + 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++; + } +#if OS_VER > VERSION(6,0) + IF_ADDR_UNLOCK(ifp); +#endif + + 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; +} + +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); +} + +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_73 || + sc->re_type == MACFG_73 || 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 || sc->re_type == MACFG_73) { + 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); + } + } + + re_init_unlock(sc); +} + +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 + +/* + * 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 || sc->re_type == MACFG_73 || + sc->re_type == MACFG_74) { + //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 || sc->re_type == MACFG_73) + 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: +#if OS_VER < 500000 + case IFM_1000_TX: +#else + case IFM_1000_T: +#endif + 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: + printf("re%d: Unsupported media type\n", sc->re_unit); + return(0); + } + + if (sc->re_device_id==RT_DEVICEID_8162) + ClearEthPhyOcpBit(sc, 0xA5D4, RTK_ADVERTISE_2500FULL); + + 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 || + sc->re_device_id==RT_DEVICEID_8162) { + 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: + case IFM_2500_X: + case IFM_2500_T: + 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: +#if OS_VER < 500000 + case IFM_1000_TX: +#else + case IFM_1000_T: +#endif + 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: + printf("re%d: Unsupported media type\n", sc->re_unit); + return(0); + } + + 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(ifp, ifmr) +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; + } + + RE_UNLOCK(sc); + + return; +} + +static void re_ifmedia_sts_8125(ifp, ifmr) +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) + ifmr->ifm_active |= IFM_2500_T; + } + + 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: + case MACFG_73: + case MACFG_74: + 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: + case MACFG_74: + 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_73: + case MACFG_74: + 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: + case MACFG_73: + OOB_mutex_lock(sc); + if (sc->HwPkgDet == 0x0F) + SetMcuAccessRegBit(sc, 0xE052, BIT_0); + else + ClearMcuAccessRegBit(sc, 0xE052, BIT_0); + OOB_mutex_unlock(sc); + break; + case MACFG_68: + case MACFG_69: + case MACFG_74: + ClearMcuAccessRegBit(sc, 0xE052, BIT_0); + + 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_73: + case MACFG_74: + 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: + case MACFG_73: + case MACFG_74: + 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: + case MACFG_74: + 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_73: + case MACFG_74: + 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: + case MACFG_73: + data = MP_ReadMcuAccessRegWord(sc, 0xE052); + data &= ~(BIT_0); + MP_WriteMcuAccessRegWord(sc, 0xE052, data); + break; + case MACFG_68: + case MACFG_69: + case MACFG_74: + 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_73: + case MACFG_74: + 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: + case MACFG_73: + case MACFG_74: + 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: + case MACFG_73: + case MACFG_74: + 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; + 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: + case MACFG_73: + case MACFG_74: + MP_WritePhyUshort(sc, 0x1f, 0x0B82); + SetEthPhyBit(sc, 0x10, BIT_4); + + MP_WritePhyUshort(sc, 0x1f, 0x0B80); + WaitCount = 0; + do { + PhyRegValue = MP_ReadPhyUshort(sc, 0x10); + 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); + + WaitCount = 0; + do { + PhyRegValue = MP_RealReadPhyOcpRegWord(sc, 0xB800); + DELAY(50); + DELAY(50); + WaitCount++; + } while (!(PhyRegValue & BIT_6) && (WaitCount < 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; + 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: + case MACFG_73: + case MACFG_74: + MP_WritePhyUshort(sc, 0x1f, 0x0B82); + ClearEthPhyBit(sc, 0x10, BIT_4); + + MP_WritePhyUshort(sc, 0x1f, 0x0B80); + WaitCount = 0; + do { + PhyRegValue = MP_ReadPhyUshort(sc, 0x10); + 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); + + WaitCount = 0; + do { + PhyRegValue = MP_RealReadPhyOcpRegWord(sc, 0xB800); + DELAY(50); + DELAY(50); + WaitCount++; + } while ((PhyRegValue & BIT_6) && (WaitCount < 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_8168h_3(struct re_softc *sc) +{ + u_int16_t PhyRegValue; + + re_set_phy_mcu_patch_request(sc); + + MP_WritePhyUshort(sc, 0x1f, 0x0A43); + MP_WritePhyUshort(sc, 0x13, 0x8042); + MP_WritePhyUshort(sc, 0x14, 0x3800); + 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, 0xA016); + MP_WritePhyUshort(sc, 0x14, 0x0000); + MP_WritePhyUshort(sc, 0x13, 0xA012); + MP_WritePhyUshort(sc, 0x14, 0x0000); + MP_WritePhyUshort(sc, 0x13, 0xA014); + MP_WritePhyUshort(sc, 0x14, 0x1800); + MP_WritePhyUshort(sc, 0x14, 0x8002); + MP_WritePhyUshort(sc, 0x14, 0x2b5d); + MP_WritePhyUshort(sc, 0x14, 0x0c68); + MP_WritePhyUshort(sc, 0x14, 0x1800); + MP_WritePhyUshort(sc, 0x14, 0x0b3c); + MP_WritePhyUshort(sc, 0x13, 0xA000); + MP_WritePhyUshort(sc, 0x14, 0x0b3a); + MP_WritePhyUshort(sc, 0x13, 0xA008); + MP_WritePhyUshort(sc, 0x14, 0x0100); + MP_WritePhyUshort(sc, 0x13, 0xB820); + MP_WritePhyUshort(sc, 0x14, 0x0010); + + MP_WritePhyUshort(sc, 0x13, 0x83f3); + MP_WritePhyUshort(sc, 0x14, 0xaf84); + MP_WritePhyUshort(sc, 0x14, 0x0baf); + MP_WritePhyUshort(sc, 0x14, 0x8466); + MP_WritePhyUshort(sc, 0x14, 0xaf84); + MP_WritePhyUshort(sc, 0x14, 0xcdaf); + MP_WritePhyUshort(sc, 0x14, 0x8736); + MP_WritePhyUshort(sc, 0x14, 0xaf87); + MP_WritePhyUshort(sc, 0x14, 0x39af); + MP_WritePhyUshort(sc, 0x14, 0x8739); + MP_WritePhyUshort(sc, 0x14, 0xaf87); + MP_WritePhyUshort(sc, 0x14, 0x39af); + MP_WritePhyUshort(sc, 0x14, 0x8739); + MP_WritePhyUshort(sc, 0x14, 0xef79); + MP_WritePhyUshort(sc, 0x14, 0xfb89); + MP_WritePhyUshort(sc, 0x14, 0xe987); + MP_WritePhyUshort(sc, 0x14, 0xffd7); + MP_WritePhyUshort(sc, 0x14, 0x0017); + MP_WritePhyUshort(sc, 0x14, 0xd400); + MP_WritePhyUshort(sc, 0x14, 0x051c); + MP_WritePhyUshort(sc, 0x14, 0x421a); + MP_WritePhyUshort(sc, 0x14, 0x741b); + MP_WritePhyUshort(sc, 0x14, 0x97e9); + MP_WritePhyUshort(sc, 0x14, 0x87fe); + MP_WritePhyUshort(sc, 0x14, 0xffef); + MP_WritePhyUshort(sc, 0x14, 0x97e0); + MP_WritePhyUshort(sc, 0x14, 0x82aa); + MP_WritePhyUshort(sc, 0x14, 0xa000); + MP_WritePhyUshort(sc, 0x14, 0x08ef); + MP_WritePhyUshort(sc, 0x14, 0x46dc); + MP_WritePhyUshort(sc, 0x14, 0x19dd); + MP_WritePhyUshort(sc, 0x14, 0xaf1a); + MP_WritePhyUshort(sc, 0x14, 0x37a0); + MP_WritePhyUshort(sc, 0x14, 0x012d); + MP_WritePhyUshort(sc, 0x14, 0xe082); + MP_WritePhyUshort(sc, 0x14, 0xa7ac); + MP_WritePhyUshort(sc, 0x14, 0x2013); + MP_WritePhyUshort(sc, 0x14, 0xe087); + MP_WritePhyUshort(sc, 0x14, 0xffe1); + MP_WritePhyUshort(sc, 0x14, 0x87fe); + MP_WritePhyUshort(sc, 0x14, 0xac27); + MP_WritePhyUshort(sc, 0x14, 0x05a1); + MP_WritePhyUshort(sc, 0x14, 0x0807); + MP_WritePhyUshort(sc, 0x14, 0xae0f); + MP_WritePhyUshort(sc, 0x14, 0xa107); + MP_WritePhyUshort(sc, 0x14, 0x02ae); + MP_WritePhyUshort(sc, 0x14, 0x0aef); + MP_WritePhyUshort(sc, 0x14, 0x4619); + MP_WritePhyUshort(sc, 0x14, 0x19dc); + MP_WritePhyUshort(sc, 0x14, 0x19dd); + MP_WritePhyUshort(sc, 0x14, 0xaf1a); + MP_WritePhyUshort(sc, 0x14, 0x37d8); + MP_WritePhyUshort(sc, 0x14, 0x19d9); + MP_WritePhyUshort(sc, 0x14, 0x19dc); + MP_WritePhyUshort(sc, 0x14, 0x19dd); + MP_WritePhyUshort(sc, 0x14, 0xaf1a); + MP_WritePhyUshort(sc, 0x14, 0x3719); + MP_WritePhyUshort(sc, 0x14, 0x19ae); + MP_WritePhyUshort(sc, 0x14, 0xcfbf); + MP_WritePhyUshort(sc, 0x14, 0x8763); + MP_WritePhyUshort(sc, 0x14, 0x0244); + MP_WritePhyUshort(sc, 0x14, 0xdc3c); + MP_WritePhyUshort(sc, 0x14, 0x0005); + MP_WritePhyUshort(sc, 0x14, 0xaaf5); + MP_WritePhyUshort(sc, 0x14, 0x0249); + MP_WritePhyUshort(sc, 0x14, 0xcaef); + MP_WritePhyUshort(sc, 0x14, 0x67d7); + MP_WritePhyUshort(sc, 0x14, 0x0014); + MP_WritePhyUshort(sc, 0x14, 0x0249); + MP_WritePhyUshort(sc, 0x14, 0xe5ad); + MP_WritePhyUshort(sc, 0x14, 0x50f7); + MP_WritePhyUshort(sc, 0x14, 0xd400); + MP_WritePhyUshort(sc, 0x14, 0x01bf); + MP_WritePhyUshort(sc, 0x14, 0x46a7); + MP_WritePhyUshort(sc, 0x14, 0x0244); + MP_WritePhyUshort(sc, 0x14, 0x98bf); + MP_WritePhyUshort(sc, 0x14, 0x465c); + MP_WritePhyUshort(sc, 0x14, 0x024a); + MP_WritePhyUshort(sc, 0x14, 0x5fd4); + MP_WritePhyUshort(sc, 0x14, 0x0003); + MP_WritePhyUshort(sc, 0x14, 0xbf87); + MP_WritePhyUshort(sc, 0x14, 0x7502); + MP_WritePhyUshort(sc, 0x14, 0x4498); + MP_WritePhyUshort(sc, 0x14, 0xbf87); + MP_WritePhyUshort(sc, 0x14, 0x7202); + MP_WritePhyUshort(sc, 0x14, 0x4a5f); + MP_WritePhyUshort(sc, 0x14, 0xbf87); + MP_WritePhyUshort(sc, 0x14, 0x6602); + MP_WritePhyUshort(sc, 0x14, 0x4a5f); + MP_WritePhyUshort(sc, 0x14, 0xbf87); + MP_WritePhyUshort(sc, 0x14, 0x6902); + MP_WritePhyUshort(sc, 0x14, 0x44dc); + MP_WritePhyUshort(sc, 0x14, 0xad28); + MP_WritePhyUshort(sc, 0x14, 0xf7bf); + MP_WritePhyUshort(sc, 0x14, 0x876f); + MP_WritePhyUshort(sc, 0x14, 0x0244); + MP_WritePhyUshort(sc, 0x14, 0xdcad); + MP_WritePhyUshort(sc, 0x14, 0x28f7); + MP_WritePhyUshort(sc, 0x14, 0xbf87); + MP_WritePhyUshort(sc, 0x14, 0x6c02); + MP_WritePhyUshort(sc, 0x14, 0x4a5f); + MP_WritePhyUshort(sc, 0x14, 0xbf87); + MP_WritePhyUshort(sc, 0x14, 0x6c02); + MP_WritePhyUshort(sc, 0x14, 0x4a56); + MP_WritePhyUshort(sc, 0x14, 0xbf46); + MP_WritePhyUshort(sc, 0x14, 0x5c02); + MP_WritePhyUshort(sc, 0x14, 0x4a56); + MP_WritePhyUshort(sc, 0x14, 0xbf45); + MP_WritePhyUshort(sc, 0x14, 0x21af); + MP_WritePhyUshort(sc, 0x14, 0x020e); + MP_WritePhyUshort(sc, 0x14, 0xee82); + MP_WritePhyUshort(sc, 0x14, 0x5000); + MP_WritePhyUshort(sc, 0x14, 0x0284); + MP_WritePhyUshort(sc, 0x14, 0xdd02); + MP_WritePhyUshort(sc, 0x14, 0x8521); + MP_WritePhyUshort(sc, 0x14, 0x0285); + MP_WritePhyUshort(sc, 0x14, 0x36af); + MP_WritePhyUshort(sc, 0x14, 0x03d2); + MP_WritePhyUshort(sc, 0x14, 0xf8f9); + MP_WritePhyUshort(sc, 0x14, 0xfafb); + MP_WritePhyUshort(sc, 0x14, 0xef59); + MP_WritePhyUshort(sc, 0x14, 0xbf45); + MP_WritePhyUshort(sc, 0x14, 0x3002); + MP_WritePhyUshort(sc, 0x14, 0x44dc); + MP_WritePhyUshort(sc, 0x14, 0x3c00); + MP_WritePhyUshort(sc, 0x14, 0x03aa); + MP_WritePhyUshort(sc, 0x14, 0x2cbf); + MP_WritePhyUshort(sc, 0x14, 0x8769); + MP_WritePhyUshort(sc, 0x14, 0x0244); + MP_WritePhyUshort(sc, 0x14, 0xdcad); + MP_WritePhyUshort(sc, 0x14, 0x2823); + MP_WritePhyUshort(sc, 0x14, 0xbf87); + MP_WritePhyUshort(sc, 0x14, 0x6f02); + MP_WritePhyUshort(sc, 0x14, 0x44dc); + MP_WritePhyUshort(sc, 0x14, 0xad28); + MP_WritePhyUshort(sc, 0x14, 0x1a02); + MP_WritePhyUshort(sc, 0x14, 0x49ca); + MP_WritePhyUshort(sc, 0x14, 0xef67); + MP_WritePhyUshort(sc, 0x14, 0xd700); + MP_WritePhyUshort(sc, 0x14, 0x0202); + MP_WritePhyUshort(sc, 0x14, 0x49e5); + MP_WritePhyUshort(sc, 0x14, 0xad50); + MP_WritePhyUshort(sc, 0x14, 0xf7bf); + MP_WritePhyUshort(sc, 0x14, 0x876c); + MP_WritePhyUshort(sc, 0x14, 0x024a); + MP_WritePhyUshort(sc, 0x14, 0x5fbf); + MP_WritePhyUshort(sc, 0x14, 0x876c); + MP_WritePhyUshort(sc, 0x14, 0x024a); + MP_WritePhyUshort(sc, 0x14, 0x56ef); + MP_WritePhyUshort(sc, 0x14, 0x95ff); + MP_WritePhyUshort(sc, 0x14, 0xfefd); + MP_WritePhyUshort(sc, 0x14, 0xfc04); + MP_WritePhyUshort(sc, 0x14, 0xf8fa); + MP_WritePhyUshort(sc, 0x14, 0xef69); + MP_WritePhyUshort(sc, 0x14, 0xe080); + MP_WritePhyUshort(sc, 0x14, 0x15ad); + MP_WritePhyUshort(sc, 0x14, 0x2406); + MP_WritePhyUshort(sc, 0x14, 0xbf87); + MP_WritePhyUshort(sc, 0x14, 0x6002); + MP_WritePhyUshort(sc, 0x14, 0x4a56); + MP_WritePhyUshort(sc, 0x14, 0xef96); + MP_WritePhyUshort(sc, 0x14, 0xfefc); + MP_WritePhyUshort(sc, 0x14, 0x04f8); + MP_WritePhyUshort(sc, 0x14, 0xe087); + MP_WritePhyUshort(sc, 0x14, 0xf9e1); + MP_WritePhyUshort(sc, 0x14, 0x87fa); + MP_WritePhyUshort(sc, 0x14, 0x1b10); + MP_WritePhyUshort(sc, 0x14, 0x9f1e); + MP_WritePhyUshort(sc, 0x14, 0xee87); + MP_WritePhyUshort(sc, 0x14, 0xf900); + MP_WritePhyUshort(sc, 0x14, 0xe080); + MP_WritePhyUshort(sc, 0x14, 0x15ac); + MP_WritePhyUshort(sc, 0x14, 0x2606); + MP_WritePhyUshort(sc, 0x14, 0xee87); + MP_WritePhyUshort(sc, 0x14, 0xf700); + MP_WritePhyUshort(sc, 0x14, 0xae12); + MP_WritePhyUshort(sc, 0x14, 0x0286); + MP_WritePhyUshort(sc, 0x14, 0x9702); + MP_WritePhyUshort(sc, 0x14, 0x8565); + MP_WritePhyUshort(sc, 0x14, 0x0285); + MP_WritePhyUshort(sc, 0x14, 0x9d02); + MP_WritePhyUshort(sc, 0x14, 0x865a); + MP_WritePhyUshort(sc, 0x14, 0xae04); + MP_WritePhyUshort(sc, 0x14, 0x10e4); + MP_WritePhyUshort(sc, 0x14, 0x87f9); + MP_WritePhyUshort(sc, 0x14, 0xfc04); + MP_WritePhyUshort(sc, 0x14, 0xf8f9); + MP_WritePhyUshort(sc, 0x14, 0xfaef); + MP_WritePhyUshort(sc, 0x14, 0x69fa); + MP_WritePhyUshort(sc, 0x14, 0xbf45); + MP_WritePhyUshort(sc, 0x14, 0x3002); + MP_WritePhyUshort(sc, 0x14, 0x44dc); + MP_WritePhyUshort(sc, 0x14, 0xa103); + MP_WritePhyUshort(sc, 0x14, 0x22e0); + MP_WritePhyUshort(sc, 0x14, 0x87eb); + MP_WritePhyUshort(sc, 0x14, 0xe187); + MP_WritePhyUshort(sc, 0x14, 0xecef); + MP_WritePhyUshort(sc, 0x14, 0x64bf); + MP_WritePhyUshort(sc, 0x14, 0x8748); + MP_WritePhyUshort(sc, 0x14, 0x0244); + MP_WritePhyUshort(sc, 0x14, 0xdc1b); + MP_WritePhyUshort(sc, 0x14, 0x46aa); + MP_WritePhyUshort(sc, 0x14, 0x0abf); + MP_WritePhyUshort(sc, 0x14, 0x874b); + MP_WritePhyUshort(sc, 0x14, 0x0244); + MP_WritePhyUshort(sc, 0x14, 0xdc1b); + MP_WritePhyUshort(sc, 0x14, 0x46ab); + MP_WritePhyUshort(sc, 0x14, 0x06bf); + MP_WritePhyUshort(sc, 0x14, 0x8745); + MP_WritePhyUshort(sc, 0x14, 0x024a); + MP_WritePhyUshort(sc, 0x14, 0x5ffe); + MP_WritePhyUshort(sc, 0x14, 0xef96); + MP_WritePhyUshort(sc, 0x14, 0xfefd); + MP_WritePhyUshort(sc, 0x14, 0xfc04); + MP_WritePhyUshort(sc, 0x14, 0xf8f9); + MP_WritePhyUshort(sc, 0x14, 0xef59); + MP_WritePhyUshort(sc, 0x14, 0xf9bf); + MP_WritePhyUshort(sc, 0x14, 0x4530); + MP_WritePhyUshort(sc, 0x14, 0x0244); + MP_WritePhyUshort(sc, 0x14, 0xdca1); + MP_WritePhyUshort(sc, 0x14, 0x0310); + MP_WritePhyUshort(sc, 0x14, 0xe087); + MP_WritePhyUshort(sc, 0x14, 0xf7ac); + MP_WritePhyUshort(sc, 0x14, 0x2605); + MP_WritePhyUshort(sc, 0x14, 0x0285); + MP_WritePhyUshort(sc, 0x14, 0xc9ae); + MP_WritePhyUshort(sc, 0x14, 0x0d02); + MP_WritePhyUshort(sc, 0x14, 0x860d); + MP_WritePhyUshort(sc, 0x14, 0xae08); + MP_WritePhyUshort(sc, 0x14, 0xe287); + MP_WritePhyUshort(sc, 0x14, 0xf7f6); + MP_WritePhyUshort(sc, 0x14, 0x36e6); + MP_WritePhyUshort(sc, 0x14, 0x87f7); + MP_WritePhyUshort(sc, 0x14, 0xfdef); + MP_WritePhyUshort(sc, 0x14, 0x95fd); + MP_WritePhyUshort(sc, 0x14, 0xfc04); + MP_WritePhyUshort(sc, 0x14, 0xf8f9); + MP_WritePhyUshort(sc, 0x14, 0xfafb); + MP_WritePhyUshort(sc, 0x14, 0xef79); + MP_WritePhyUshort(sc, 0x14, 0xfbbf); + MP_WritePhyUshort(sc, 0x14, 0x8748); + MP_WritePhyUshort(sc, 0x14, 0x0244); + MP_WritePhyUshort(sc, 0x14, 0xdcef); + MP_WritePhyUshort(sc, 0x14, 0x64e2); + MP_WritePhyUshort(sc, 0x14, 0x87e9); + MP_WritePhyUshort(sc, 0x14, 0xe387); + MP_WritePhyUshort(sc, 0x14, 0xea1b); + MP_WritePhyUshort(sc, 0x14, 0x659e); + MP_WritePhyUshort(sc, 0x14, 0x10e4); + MP_WritePhyUshort(sc, 0x14, 0x87e9); + MP_WritePhyUshort(sc, 0x14, 0xe587); + MP_WritePhyUshort(sc, 0x14, 0xeae2); + MP_WritePhyUshort(sc, 0x14, 0x87f7); + MP_WritePhyUshort(sc, 0x14, 0xf636); + MP_WritePhyUshort(sc, 0x14, 0xe687); + MP_WritePhyUshort(sc, 0x14, 0xf7ae); + MP_WritePhyUshort(sc, 0x14, 0x13e2); + MP_WritePhyUshort(sc, 0x14, 0x87f7); + MP_WritePhyUshort(sc, 0x14, 0xf736); + MP_WritePhyUshort(sc, 0x14, 0xe687); + MP_WritePhyUshort(sc, 0x14, 0xf702); + MP_WritePhyUshort(sc, 0x14, 0x49ca); + MP_WritePhyUshort(sc, 0x14, 0xef57); + MP_WritePhyUshort(sc, 0x14, 0xe687); + MP_WritePhyUshort(sc, 0x14, 0xe7e7); + MP_WritePhyUshort(sc, 0x14, 0x87e8); + MP_WritePhyUshort(sc, 0x14, 0xffef); + MP_WritePhyUshort(sc, 0x14, 0x97ff); + MP_WritePhyUshort(sc, 0x14, 0xfefd); + MP_WritePhyUshort(sc, 0x14, 0xfc04); + MP_WritePhyUshort(sc, 0x14, 0xf8f9); + MP_WritePhyUshort(sc, 0x14, 0xfafb); + MP_WritePhyUshort(sc, 0x14, 0xef79); + MP_WritePhyUshort(sc, 0x14, 0xfbe2); + MP_WritePhyUshort(sc, 0x14, 0x87e7); + MP_WritePhyUshort(sc, 0x14, 0xe387); + MP_WritePhyUshort(sc, 0x14, 0xe8ef); + MP_WritePhyUshort(sc, 0x14, 0x65e2); + MP_WritePhyUshort(sc, 0x14, 0x87fb); + MP_WritePhyUshort(sc, 0x14, 0xe387); + MP_WritePhyUshort(sc, 0x14, 0xfcef); + MP_WritePhyUshort(sc, 0x14, 0x7502); + MP_WritePhyUshort(sc, 0x14, 0x49e5); + MP_WritePhyUshort(sc, 0x14, 0xac50); + MP_WritePhyUshort(sc, 0x14, 0x1abf); + MP_WritePhyUshort(sc, 0x14, 0x8748); + MP_WritePhyUshort(sc, 0x14, 0x0244); + MP_WritePhyUshort(sc, 0x14, 0xdcef); + MP_WritePhyUshort(sc, 0x14, 0x64e2); + MP_WritePhyUshort(sc, 0x14, 0x87e9); + MP_WritePhyUshort(sc, 0x14, 0xe387); + MP_WritePhyUshort(sc, 0x14, 0xea1b); + MP_WritePhyUshort(sc, 0x14, 0x659e); + MP_WritePhyUshort(sc, 0x14, 0x16e4); + MP_WritePhyUshort(sc, 0x14, 0x87e9); + MP_WritePhyUshort(sc, 0x14, 0xe587); + MP_WritePhyUshort(sc, 0x14, 0xeaae); + MP_WritePhyUshort(sc, 0x14, 0x06bf); + MP_WritePhyUshort(sc, 0x14, 0x8745); + MP_WritePhyUshort(sc, 0x14, 0x024a); + MP_WritePhyUshort(sc, 0x14, 0x5fe2); + MP_WritePhyUshort(sc, 0x14, 0x87f7); + MP_WritePhyUshort(sc, 0x14, 0xf636); + MP_WritePhyUshort(sc, 0x14, 0xe687); + MP_WritePhyUshort(sc, 0x14, 0xf7ff); + MP_WritePhyUshort(sc, 0x14, 0xef97); + MP_WritePhyUshort(sc, 0x14, 0xfffe); + MP_WritePhyUshort(sc, 0x14, 0xfdfc); + MP_WritePhyUshort(sc, 0x14, 0x04f8); + MP_WritePhyUshort(sc, 0x14, 0xf9fa); + MP_WritePhyUshort(sc, 0x14, 0xef69); + MP_WritePhyUshort(sc, 0x14, 0xbf87); + MP_WritePhyUshort(sc, 0x14, 0x3f02); + MP_WritePhyUshort(sc, 0x14, 0x44dc); + MP_WritePhyUshort(sc, 0x14, 0xad28); + MP_WritePhyUshort(sc, 0x14, 0x29bf); + MP_WritePhyUshort(sc, 0x14, 0x873c); + MP_WritePhyUshort(sc, 0x14, 0x0244); + MP_WritePhyUshort(sc, 0x14, 0xdcef); + MP_WritePhyUshort(sc, 0x14, 0x54bf); + MP_WritePhyUshort(sc, 0x14, 0x8739); + MP_WritePhyUshort(sc, 0x14, 0x0244); + MP_WritePhyUshort(sc, 0x14, 0xdcac); + MP_WritePhyUshort(sc, 0x14, 0x290d); + MP_WritePhyUshort(sc, 0x14, 0xac28); + MP_WritePhyUshort(sc, 0x14, 0x05a3); + MP_WritePhyUshort(sc, 0x14, 0x020c); + MP_WritePhyUshort(sc, 0x14, 0xae10); + MP_WritePhyUshort(sc, 0x14, 0xa303); + MP_WritePhyUshort(sc, 0x14, 0x07ae); + MP_WritePhyUshort(sc, 0x14, 0x0ba3); + MP_WritePhyUshort(sc, 0x14, 0x0402); + MP_WritePhyUshort(sc, 0x14, 0xae06); + MP_WritePhyUshort(sc, 0x14, 0xbf87); + MP_WritePhyUshort(sc, 0x14, 0x4502); + MP_WritePhyUshort(sc, 0x14, 0x4a5f); + MP_WritePhyUshort(sc, 0x14, 0xef96); + MP_WritePhyUshort(sc, 0x14, 0xfefd); + MP_WritePhyUshort(sc, 0x14, 0xfc04); + MP_WritePhyUshort(sc, 0x14, 0xf8f9); + MP_WritePhyUshort(sc, 0x14, 0xfafb); + MP_WritePhyUshort(sc, 0x14, 0xef69); + MP_WritePhyUshort(sc, 0x14, 0xfae0); + MP_WritePhyUshort(sc, 0x14, 0x8015); + MP_WritePhyUshort(sc, 0x14, 0xad25); + MP_WritePhyUshort(sc, 0x14, 0x41d2); + MP_WritePhyUshort(sc, 0x14, 0x0002); + MP_WritePhyUshort(sc, 0x14, 0x86ed); + MP_WritePhyUshort(sc, 0x14, 0xe087); + MP_WritePhyUshort(sc, 0x14, 0xebe1); + MP_WritePhyUshort(sc, 0x14, 0x87ec); + MP_WritePhyUshort(sc, 0x14, 0x1b46); + MP_WritePhyUshort(sc, 0x14, 0xab26); + MP_WritePhyUshort(sc, 0x14, 0xd40b); + MP_WritePhyUshort(sc, 0x14, 0xff1b); + MP_WritePhyUshort(sc, 0x14, 0x46aa); + MP_WritePhyUshort(sc, 0x14, 0x1fac); + MP_WritePhyUshort(sc, 0x14, 0x3204); + MP_WritePhyUshort(sc, 0x14, 0xef32); + MP_WritePhyUshort(sc, 0x14, 0xae02); + MP_WritePhyUshort(sc, 0x14, 0xd304); + MP_WritePhyUshort(sc, 0x14, 0x0c31); + MP_WritePhyUshort(sc, 0x14, 0xbf87); + MP_WritePhyUshort(sc, 0x14, 0xeb1a); + MP_WritePhyUshort(sc, 0x14, 0x93d8); + MP_WritePhyUshort(sc, 0x14, 0x19d9); + MP_WritePhyUshort(sc, 0x14, 0x1b46); + MP_WritePhyUshort(sc, 0x14, 0xab0e); + MP_WritePhyUshort(sc, 0x14, 0x19d8); + MP_WritePhyUshort(sc, 0x14, 0x19d9); + MP_WritePhyUshort(sc, 0x14, 0x1b46); + MP_WritePhyUshort(sc, 0x14, 0xaa06); + MP_WritePhyUshort(sc, 0x14, 0x12a2); + MP_WritePhyUshort(sc, 0x14, 0x08c9); + MP_WritePhyUshort(sc, 0x14, 0xae06); + MP_WritePhyUshort(sc, 0x14, 0xbf87); + MP_WritePhyUshort(sc, 0x14, 0x4202); + MP_WritePhyUshort(sc, 0x14, 0x4a5f); + MP_WritePhyUshort(sc, 0x14, 0xfeef); + MP_WritePhyUshort(sc, 0x14, 0x96ff); + MP_WritePhyUshort(sc, 0x14, 0xfefd); + MP_WritePhyUshort(sc, 0x14, 0xfc04); + MP_WritePhyUshort(sc, 0x14, 0xf8fb); + MP_WritePhyUshort(sc, 0x14, 0xef79); + MP_WritePhyUshort(sc, 0x14, 0xa200); + MP_WritePhyUshort(sc, 0x14, 0x05bf); + MP_WritePhyUshort(sc, 0x14, 0x8748); + MP_WritePhyUshort(sc, 0x14, 0xae33); + MP_WritePhyUshort(sc, 0x14, 0xa201); + MP_WritePhyUshort(sc, 0x14, 0x05bf); + MP_WritePhyUshort(sc, 0x14, 0x874b); + MP_WritePhyUshort(sc, 0x14, 0xae2b); + MP_WritePhyUshort(sc, 0x14, 0xa202); + MP_WritePhyUshort(sc, 0x14, 0x05bf); + MP_WritePhyUshort(sc, 0x14, 0x874e); + MP_WritePhyUshort(sc, 0x14, 0xae23); + MP_WritePhyUshort(sc, 0x14, 0xa203); + MP_WritePhyUshort(sc, 0x14, 0x05bf); + MP_WritePhyUshort(sc, 0x14, 0x8751); + MP_WritePhyUshort(sc, 0x14, 0xae1b); + MP_WritePhyUshort(sc, 0x14, 0xa204); + MP_WritePhyUshort(sc, 0x14, 0x05bf); + MP_WritePhyUshort(sc, 0x14, 0x8754); + MP_WritePhyUshort(sc, 0x14, 0xae13); + MP_WritePhyUshort(sc, 0x14, 0xa205); + MP_WritePhyUshort(sc, 0x14, 0x05bf); + MP_WritePhyUshort(sc, 0x14, 0x8757); + MP_WritePhyUshort(sc, 0x14, 0xae0b); + MP_WritePhyUshort(sc, 0x14, 0xa206); + MP_WritePhyUshort(sc, 0x14, 0x05bf); + MP_WritePhyUshort(sc, 0x14, 0x875a); + MP_WritePhyUshort(sc, 0x14, 0xae03); + MP_WritePhyUshort(sc, 0x14, 0xbf87); + MP_WritePhyUshort(sc, 0x14, 0x5d02); + MP_WritePhyUshort(sc, 0x14, 0x44dc); + MP_WritePhyUshort(sc, 0x14, 0xef64); + MP_WritePhyUshort(sc, 0x14, 0xef97); + MP_WritePhyUshort(sc, 0x14, 0xfffc); + MP_WritePhyUshort(sc, 0x14, 0x04af); + MP_WritePhyUshort(sc, 0x14, 0x00ed); + MP_WritePhyUshort(sc, 0x14, 0x54a4); + MP_WritePhyUshort(sc, 0x14, 0x3474); + MP_WritePhyUshort(sc, 0x14, 0xa600); + MP_WritePhyUshort(sc, 0x14, 0x22a4); + MP_WritePhyUshort(sc, 0x14, 0x3411); + MP_WritePhyUshort(sc, 0x14, 0xb842); + MP_WritePhyUshort(sc, 0x14, 0x22b8); + MP_WritePhyUshort(sc, 0x14, 0x42f0); + MP_WritePhyUshort(sc, 0x14, 0xa200); + MP_WritePhyUshort(sc, 0x14, 0xf0a2); + MP_WritePhyUshort(sc, 0x14, 0x02f0); + MP_WritePhyUshort(sc, 0x14, 0xa204); + MP_WritePhyUshort(sc, 0x14, 0xf0a2); + MP_WritePhyUshort(sc, 0x14, 0x06f0); + MP_WritePhyUshort(sc, 0x14, 0xa208); + MP_WritePhyUshort(sc, 0x14, 0xf0a2); + MP_WritePhyUshort(sc, 0x14, 0x0af0); + MP_WritePhyUshort(sc, 0x14, 0xa20c); + MP_WritePhyUshort(sc, 0x14, 0xf0a2); + MP_WritePhyUshort(sc, 0x14, 0x0e55); + MP_WritePhyUshort(sc, 0x14, 0xb820); + MP_WritePhyUshort(sc, 0x14, 0xd9c6); + MP_WritePhyUshort(sc, 0x14, 0x08aa); + MP_WritePhyUshort(sc, 0x14, 0xc430); + MP_WritePhyUshort(sc, 0x14, 0x00c6); + MP_WritePhyUshort(sc, 0x14, 0x1433); + MP_WritePhyUshort(sc, 0x14, 0xc41a); + MP_WritePhyUshort(sc, 0x14, 0x88c4); + MP_WritePhyUshort(sc, 0x14, 0x2e22); + MP_WritePhyUshort(sc, 0x14, 0xc42e); + MP_WritePhyUshort(sc, 0x14, 0x54c4); + MP_WritePhyUshort(sc, 0x14, 0x1a00); + MP_WritePhyUshort(sc, 0x13, 0xb818); + MP_WritePhyUshort(sc, 0x14, 0x1a01); + MP_WritePhyUshort(sc, 0x13, 0xb81a); + MP_WritePhyUshort(sc, 0x14, 0x020b); + MP_WritePhyUshort(sc, 0x13, 0xb81c); + MP_WritePhyUshort(sc, 0x14, 0x03ce); + MP_WritePhyUshort(sc, 0x13, 0xb81e); + MP_WritePhyUshort(sc, 0x14, 0x00e7); + MP_WritePhyUshort(sc, 0x13, 0xb846); + MP_WritePhyUshort(sc, 0x14, 0xffff); + MP_WritePhyUshort(sc, 0x13, 0xb848); + MP_WritePhyUshort(sc, 0x14, 0xffff); + MP_WritePhyUshort(sc, 0x13, 0xb84a); + MP_WritePhyUshort(sc, 0x14, 0xffff); + MP_WritePhyUshort(sc, 0x13, 0xb84c); + MP_WritePhyUshort(sc, 0x14, 0xffff); + MP_WritePhyUshort(sc, 0x13, 0xb832); + MP_WritePhyUshort(sc, 0x14, 0x000f); + + 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, 0x8042); + 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, 0x803f, + 0xa438, 0x1800, 0xa438, 0x8045, 0xa438, 0x1800, 0xa438, 0x8067, + 0xa438, 0x1800, 0xa438, 0x806d, 0xa438, 0x1800, 0xa438, 0x8071, + 0xa438, 0x1800, 0xa438, 0x80b1, 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, 0x1000, 0xa438, 0x135c, 0xa438, 0xd75e, 0xa438, 0x5fae, + 0xa438, 0x9b50, 0xa438, 0x1000, 0xa438, 0x135c, 0xa438, 0xd75e, + 0xa438, 0x7fae, 0xa438, 0x1000, 0xa438, 0x135c, 0xa438, 0xd707, + 0xa438, 0x40a7, 0xa438, 0xd719, 0xa438, 0x4071, 0xa438, 0x1800, + 0xa438, 0x1557, 0xa438, 0xd719, 0xa438, 0x2f70, 0xa438, 0x803b, + 0xa438, 0x2f73, 0xa438, 0x156a, 0xa438, 0x5e70, 0xa438, 0x1800, + 0xa438, 0x155d, 0xa438, 0xd505, 0xa438, 0xa202, 0xa438, 0xd500, + 0xa438, 0xffed, 0xa438, 0xd709, 0xa438, 0x4054, 0xa438, 0xa788, + 0xa438, 0xd70b, 0xa438, 0x1800, 0xa438, 0x172a, 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, 0x804e, 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, 0xd090, + 0xa438, 0xd1c9, 0xa438, 0x1800, 0xa438, 0x1064, 0xa438, 0xd096, + 0xa438, 0xd1a9, 0xa438, 0xd503, 0xa438, 0xa104, 0xa438, 0x0c07, + 0xa438, 0x0902, 0xa438, 0xd500, 0xa438, 0xbc10, 0xa438, 0xd501, + 0xa438, 0xce01, 0xa438, 0xa201, 0xa438, 0x8201, 0xa438, 0xce00, + 0xa438, 0xd500, 0xa438, 0xc484, 0xa438, 0xd503, 0xa438, 0xcc02, + 0xa438, 0xcd0d, 0xa438, 0xaf01, 0xa438, 0xd500, 0xa438, 0xd703, + 0xa438, 0x4371, 0xa438, 0xbd08, 0xa438, 0x1000, 0xa438, 0x135c, + 0xa438, 0xd75e, 0xa438, 0x5fb3, 0xa438, 0xd503, 0xa438, 0xd0f5, + 0xa438, 0xd1c6, 0xa438, 0x0cf0, 0xa438, 0x0e50, 0xa438, 0xd704, + 0xa438, 0x401c, 0xa438, 0xd0f5, 0xa438, 0xd1c6, 0xa438, 0x0cf0, + 0xa438, 0x0ea0, 0xa438, 0x401c, 0xa438, 0xd07b, 0xa438, 0xd1c5, + 0xa438, 0x8ef0, 0xa438, 0x401c, 0xa438, 0x9d08, 0xa438, 0x1000, + 0xa438, 0x135c, 0xa438, 0xd75e, 0xa438, 0x7fb3, 0xa438, 0x1000, + 0xa438, 0x135c, 0xa438, 0xd75e, 0xa438, 0x5fad, 0xa438, 0x1000, + 0xa438, 0x14c5, 0xa438, 0xd703, 0xa438, 0x3181, 0xa438, 0x80af, + 0xa438, 0x60ad, 0xa438, 0x1000, 0xa438, 0x135c, 0xa438, 0xd703, + 0xa438, 0x5fba, 0xa438, 0x1800, 0xa438, 0x0cc7, 0xa438, 0xa802, + 0xa438, 0xa301, 0xa438, 0xa801, 0xa438, 0xc004, 0xa438, 0xd710, + 0xa438, 0x4000, 0xa438, 0x1800, 0xa438, 0x1e79, 0xa436, 0xA026, + 0xa438, 0x1e78, 0xa436, 0xA024, 0xa438, 0x0c93, 0xa436, 0xA022, + 0xa438, 0x1062, 0xa436, 0xA020, 0xa438, 0x0915, 0xa436, 0xA006, + 0xa438, 0x020a, 0xa436, 0xA004, 0xa438, 0x1726, 0xa436, 0xA002, + 0xa438, 0x1542, 0xa436, 0xA000, 0xa438, 0x0fc7, 0xa436, 0xA008, + 0xa438, 0xff00, 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, 0x846e, 0xa438, 0xaf84, 0xa438, 0x86af, + 0xa438, 0x8690, 0xa438, 0xaf86, 0xa438, 0xa4af, 0xa438, 0x86a4, + 0xa438, 0xaf86, 0xa438, 0xa4af, 0xa438, 0x86a4, 0xa438, 0xaf86, + 0xa438, 0xa4af, 0xa438, 0x86a4, 0xa438, 0xee82, 0xa438, 0x5f00, + 0xa438, 0x0284, 0xa438, 0x90af, 0xa438, 0x0441, 0xa438, 0xf8e0, + 0xa438, 0x8ff3, 0xa438, 0xa000, 0xa438, 0x0502, 0xa438, 0x84a4, + 0xa438, 0xae06, 0xa438, 0xa001, 0xa438, 0x0302, 0xa438, 0x84c8, + 0xa438, 0xfc04, 0xa438, 0xf8f9, 0xa438, 0xef59, 0xa438, 0xe080, + 0xa438, 0x15ad, 0xa438, 0x2702, 0xa438, 0xae03, 0xa438, 0xaf84, + 0xa438, 0xc3bf, 0xa438, 0x53ca, 0xa438, 0x0252, 0xa438, 0xc8ad, + 0xa438, 0x2807, 0xa438, 0x0285, 0xa438, 0x2cee, 0xa438, 0x8ff3, + 0xa438, 0x01ef, 0xa438, 0x95fd, 0xa438, 0xfc04, 0xa438, 0xf8f9, + 0xa438, 0xfaef, 0xa438, 0x69bf, 0xa438, 0x53ca, 0xa438, 0x0252, + 0xa438, 0xc8ac, 0xa438, 0x2822, 0xa438, 0xd480, 0xa438, 0x00bf, + 0xa438, 0x8684, 0xa438, 0x0252, 0xa438, 0xa9bf, 0xa438, 0x8687, + 0xa438, 0x0252, 0xa438, 0xa9bf, 0xa438, 0x868a, 0xa438, 0x0252, + 0xa438, 0xa9bf, 0xa438, 0x868d, 0xa438, 0x0252, 0xa438, 0xa9ee, + 0xa438, 0x8ff3, 0xa438, 0x00af, 0xa438, 0x8526, 0xa438, 0xe08f, + 0xa438, 0xf4e1, 0xa438, 0x8ff5, 0xa438, 0xe28f, 0xa438, 0xf6e3, + 0xa438, 0x8ff7, 0xa438, 0x1b45, 0xa438, 0xac27, 0xa438, 0x0eee, + 0xa438, 0x8ff4, 0xa438, 0x00ee, 0xa438, 0x8ff5, 0xa438, 0x0002, + 0xa438, 0x852c, 0xa438, 0xaf85, 0xa438, 0x26e0, 0xa438, 0x8ff4, + 0xa438, 0xe18f, 0xa438, 0xf52c, 0xa438, 0x0001, 0xa438, 0xe48f, + 0xa438, 0xf4e5, 0xa438, 0x8ff5, 0xa438, 0xef96, 0xa438, 0xfefd, + 0xa438, 0xfc04, 0xa438, 0xf8f9, 0xa438, 0xef59, 0xa438, 0xbf53, + 0xa438, 0x2202, 0xa438, 0x52c8, 0xa438, 0xa18b, 0xa438, 0x02ae, + 0xa438, 0x03af, 0xa438, 0x85da, 0xa438, 0xbf57, 0xa438, 0x7202, + 0xa438, 0x52c8, 0xa438, 0xe48f, 0xa438, 0xf8e5, 0xa438, 0x8ff9, + 0xa438, 0xbf57, 0xa438, 0x7502, 0xa438, 0x52c8, 0xa438, 0xe48f, + 0xa438, 0xfae5, 0xa438, 0x8ffb, 0xa438, 0xbf57, 0xa438, 0x7802, + 0xa438, 0x52c8, 0xa438, 0xe48f, 0xa438, 0xfce5, 0xa438, 0x8ffd, + 0xa438, 0xbf57, 0xa438, 0x7b02, 0xa438, 0x52c8, 0xa438, 0xe48f, + 0xa438, 0xfee5, 0xa438, 0x8fff, 0xa438, 0xbf57, 0xa438, 0x6c02, + 0xa438, 0x52c8, 0xa438, 0xa102, 0xa438, 0x13ee, 0xa438, 0x8ffc, + 0xa438, 0x80ee, 0xa438, 0x8ffd, 0xa438, 0x00ee, 0xa438, 0x8ffe, + 0xa438, 0x80ee, 0xa438, 0x8fff, 0xa438, 0x00af, 0xa438, 0x8599, + 0xa438, 0xa101, 0xa438, 0x0cbf, 0xa438, 0x534c, 0xa438, 0x0252, + 0xa438, 0xc8a1, 0xa438, 0x0303, 0xa438, 0xaf85, 0xa438, 0x77bf, + 0xa438, 0x5322, 0xa438, 0x0252, 0xa438, 0xc8a1, 0xa438, 0x8b02, + 0xa438, 0xae03, 0xa438, 0xaf86, 0xa438, 0x64e0, 0xa438, 0x8ff8, + 0xa438, 0xe18f, 0xa438, 0xf9bf, 0xa438, 0x8684, 0xa438, 0x0252, + 0xa438, 0xa9e0, 0xa438, 0x8ffa, 0xa438, 0xe18f, 0xa438, 0xfbbf, + 0xa438, 0x8687, 0xa438, 0x0252, 0xa438, 0xa9e0, 0xa438, 0x8ffc, + 0xa438, 0xe18f, 0xa438, 0xfdbf, 0xa438, 0x868a, 0xa438, 0x0252, + 0xa438, 0xa9e0, 0xa438, 0x8ffe, 0xa438, 0xe18f, 0xa438, 0xffbf, + 0xa438, 0x868d, 0xa438, 0x0252, 0xa438, 0xa9af, 0xa438, 0x867f, + 0xa438, 0xbf53, 0xa438, 0x2202, 0xa438, 0x52c8, 0xa438, 0xa144, + 0xa438, 0x3cbf, 0xa438, 0x547b, 0xa438, 0x0252, 0xa438, 0xc8e4, + 0xa438, 0x8ff8, 0xa438, 0xe58f, 0xa438, 0xf9bf, 0xa438, 0x547e, + 0xa438, 0x0252, 0xa438, 0xc8e4, 0xa438, 0x8ffa, 0xa438, 0xe58f, + 0xa438, 0xfbbf, 0xa438, 0x5481, 0xa438, 0x0252, 0xa438, 0xc8e4, + 0xa438, 0x8ffc, 0xa438, 0xe58f, 0xa438, 0xfdbf, 0xa438, 0x5484, + 0xa438, 0x0252, 0xa438, 0xc8e4, 0xa438, 0x8ffe, 0xa438, 0xe58f, + 0xa438, 0xffbf, 0xa438, 0x5322, 0xa438, 0x0252, 0xa438, 0xc8a1, + 0xa438, 0x4448, 0xa438, 0xaf85, 0xa438, 0xa7bf, 0xa438, 0x5322, + 0xa438, 0x0252, 0xa438, 0xc8a1, 0xa438, 0x313c, 0xa438, 0xbf54, + 0xa438, 0x7b02, 0xa438, 0x52c8, 0xa438, 0xe48f, 0xa438, 0xf8e5, + 0xa438, 0x8ff9, 0xa438, 0xbf54, 0xa438, 0x7e02, 0xa438, 0x52c8, + 0xa438, 0xe48f, 0xa438, 0xfae5, 0xa438, 0x8ffb, 0xa438, 0xbf54, + 0xa438, 0x8102, 0xa438, 0x52c8, 0xa438, 0xe48f, 0xa438, 0xfce5, + 0xa438, 0x8ffd, 0xa438, 0xbf54, 0xa438, 0x8402, 0xa438, 0x52c8, + 0xa438, 0xe48f, 0xa438, 0xfee5, 0xa438, 0x8fff, 0xa438, 0xbf53, + 0xa438, 0x2202, 0xa438, 0x52c8, 0xa438, 0xa131, 0xa438, 0x03af, + 0xa438, 0x85a7, 0xa438, 0xd480, 0xa438, 0x00bf, 0xa438, 0x8684, + 0xa438, 0x0252, 0xa438, 0xa9bf, 0xa438, 0x8687, 0xa438, 0x0252, + 0xa438, 0xa9bf, 0xa438, 0x868a, 0xa438, 0x0252, 0xa438, 0xa9bf, + 0xa438, 0x868d, 0xa438, 0x0252, 0xa438, 0xa9ef, 0xa438, 0x95fd, + 0xa438, 0xfc04, 0xa438, 0xf0d1, 0xa438, 0x2af0, 0xa438, 0xd12c, + 0xa438, 0xf0d1, 0xa438, 0x44f0, 0xa438, 0xd146, 0xa438, 0xbf86, + 0xa438, 0xa102, 0xa438, 0x52c8, 0xa438, 0xbf86, 0xa438, 0xa102, + 0xa438, 0x52c8, 0xa438, 0xd101, 0xa438, 0xaf06, 0xa438, 0xa570, + 0xa438, 0xce42, 0xa436, 0xb818, 0xa438, 0x043d, 0xa436, 0xb81a, + 0xa438, 0x06a3, 0xa436, 0xb81c, 0xa438, 0xffff, 0xa436, 0xb81e, + 0xa438, 0xffff, 0xa436, 0xb850, 0xa438, 0xffff, 0xa436, 0xb852, + 0xa438, 0xffff, 0xa436, 0xb878, 0xa438, 0xffff, 0xa436, 0xb884, + 0xa438, 0xffff, 0xa436, 0xb832, 0xa438, 0x0003, 0xa436, 0x0000, + 0xa438, 0x0000, 0xa436, 0xB82E, 0xa438, 0x0000, 0xa436, 0x8024, + 0xa438, 0x0000, 0xa436, 0x801E, 0xa438, 0x0021, 0xb820, 0x0000, + 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_74: + re_set_phy_mcu_8168h_3(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: + 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_73: + case MACFG_74: + 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 || sc->re_type == MACFG_73) { + 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_74) { + MP_WritePhyUshort(sc, 0x1F, 0x0A44); + SetEthPhyBit(sc, 0x11, BIT_11); + MP_WritePhyUshort(sc, 0x1F, 0x0000); + + if (phy_power_saving == 1) { + MP_WritePhyUshort(sc, 0x1F, 0x0A43); + SetEthPhyBit(sc, 0x10, BIT_2); + MP_WritePhyUshort(sc, 0x1F, 0x0000); + } else { + MP_WritePhyUshort(sc, 0x1F, 0x0A43); + ClearEthPhyBit(sc, 0x10, BIT_2); + MP_WritePhyUshort(sc, 0x1F, 0x0000); + DELAY(20000); + } + + } 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); + + + SetEthPhyOcpBit(sc, 0xA4CA, BIT_6); + + + ClearAndSetEthPhyOcpBit(sc, + 0xBF84, + BIT_15 | BIT_14 | BIT_13, + BIT_15 | BIT_13 + ); + + + MP_RealWritePhyOcpRegWord(sc, 0xA436, 0x8170); + ClearAndSetEthPhyOcpBit(sc, + 0xA438, + BIT_13 | BIT_10 | BIT_9 | BIT_8, + BIT_15 | BIT_14 | BIT_12 | BIT_11 + ); + + /* + 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 || + sc->re_type == MACFG_74) { + //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_73: + case MACFG_74: + 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: + case MACFG_73: + case MACFG_74: + 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_73 || + sc->re_type == MACFG_74 || 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_73 || + sc->re_type == MACFG_74 || 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))<<DummyPos; + if (DummyPos > 0) { + DeCodeDwCmd |= ((DwCmd<<(32-DummyPos))>>(32-DummyPos)); + } + } else { + reg = (u_int16_t)((DwCmd & 0x007F0000) >> 16); + DummyPos = re_calc_efuse_dummy_bit(reg); + Dw17BitData = ((DwCmd & BIT_23) >> 23); + Dw17BitData <<= 16; + Dw17BitData |= (DwCmd & 0x0000FFFF); + DeCodeDwCmd = (Dw17BitData>>(DummyPos+1))<<DummyPos; + if (DummyPos > 0) { + DeCodeDwCmd |= ((Dw17BitData<<(32-DummyPos))>>(32-DummyPos)); + } + } + + return DeCodeDwCmd; +} + +#define EFUSE_WRITE 0x80000000 +#define EFUSE_WRITE_OK 0x00000000 +#define EFUSE_READ 0x00000000 +#define EFUSE_READ_OK 0x80000000 +#define EFUSE_Reg_Mask 0x03FF +#define EFUSE_Reg_Shift 8 +#define EFUSE_Check_Cnt 300 +#define EFUSE_READ_FAIL 0xFF +#define EFUSE_Data_Mask 0x000000FF + +u_int8_t MP_ReadEfuse(struct re_softc *sc, u_int16_t reg) +{ + u_int8_t efuse_data = 0; + u_int32_t temp; + u_int32_t cnt; + + if (sc->re_efuse_ver == EFUSE_NOT_SUPPORT) + return EFUSE_READ_FAIL; + + if (sc->re_efuse_ver == EFUSE_SUPPORT_V1) { + temp = EFUSE_READ | ((reg & EFUSE_Reg_Mask) << EFUSE_Reg_Shift); + CSR_WRITE_4(sc, RE_EFUSEAR, temp); + + cnt = 0; + do { + DELAY(100); + temp = CSR_READ_4(sc, RE_EFUSEAR); + cnt++; + } while (!(temp & EFUSE_READ_OK) && (cnt < EFUSE_Check_Cnt)); + + if (cnt == EFUSE_Check_Cnt) + efuse_data = EFUSE_READ_FAIL; + else + efuse_data = (u_int8_t)(CSR_READ_4(sc, RE_EFUSEAR) & EFUSE_Data_Mask); + } else if (sc->re_efuse_ver == EFUSE_SUPPORT_V2) { + temp = (reg/2) & 0x03ff; + temp <<= 17; + temp |= EFUSE_READ; + CSR_WRITE_4(sc, RE_EFUSEAR, temp); + + cnt = 0; + do { + DELAY(100); + temp = CSR_READ_4(sc, RE_EFUSEAR); + cnt++; + } while (!(temp & EFUSE_READ_OK) && (cnt < EFUSE_Check_Cnt)); + + if (cnt == EFUSE_Check_Cnt) { + efuse_data = EFUSE_READ_FAIL; + } else { + temp = CSR_READ_4(sc, RE_EFUSEAR); + temp = re_decode_efuse_cmd(sc, temp); + + if (reg%2) { + temp >>= 8; + efuse_data = (u_int8_t)temp; + } else { + efuse_data = (u_int8_t)temp; + } + } + } else if (sc->re_efuse_ver == EFUSE_SUPPORT_V3) { + temp = (reg/2) & 0x03ff; + temp <<= 16; + temp |= EFUSE_READ; + CSR_WRITE_4(sc, RE_EFUSEAR, temp); + + cnt = 0; + do { + DELAY(100); + temp = CSR_READ_4(sc, RE_EFUSEAR); + cnt++; + } while (!(temp & EFUSE_READ_OK) && (cnt < EFUSE_Check_Cnt)); + + if (cnt == EFUSE_Check_Cnt) { + efuse_data = EFUSE_READ_FAIL; + } else { + temp = CSR_READ_4(sc, RE_EFUSEAR); + temp = re_decode_efuse_cmd(sc, temp); + + if (reg%2) { + temp >>= 8; + efuse_data = (u_int8_t)temp; + } else { + efuse_data = (u_int8_t)temp; + } + } + } + + DELAY(20); + + return efuse_data; +} + +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: + case MACFG_73: + 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: + case MACFG_73: + 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) +{ + if (HW_DASH_SUPPORT_DASH(sc) == FALSE) + return 0; + + if (HW_DASH_SUPPORT_TYPE_2(sc) || HW_DASH_SUPPORT_TYPE_3(sc)) { + return !!(OCP_read(sc, 0x128, 1) & BIT_0); + } else if (HW_DASH_SUPPORT_TYPE_1(sc)) { + if (sc->re_type == MACFG_66) + return !!(OCP_read(sc, 0xb8, 2) & BIT_15); + else + return !!(OCP_read(sc, 0x10, 2) & BIT_15); + } + + 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(sc, data, count) +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(sc) +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(sc) +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(sc, addr, dest) +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(sc, dest, off, cnt, swap) +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; +} |