sys/dev/netif/re/re.c

   1 /*
   2  * Copyright (c) 1997, 1998
   3  *      Bill Paul <wpaul@ctr.columbia.edu>.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *      This product includes software developed by Bill Paul.
  16  * 4. Neither the name of the author nor the names of any co-contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND
  21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED.  IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD
  24  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  25  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  26  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  27  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  30  * THE POSSIBILITY OF SUCH DAMAGE.
  31  *
  32  * $FreeBSD: src/sys/dev/if_rl.c,v 1.38.2.7 2001/07/19 18:33:07 wpaul Exp $
  33  */
  34
  35 /*
  36  * RealTek 8129/8139 PCI NIC driver
  37  *
  38  * Written by Bill Paul <wpaul@ctr.columbia.edu>
  39  * Electrical Engineering Department
  40  * Columbia University, New York City
  41  */
  42
  43 #ifndef __DragonFly__
  44 #include <sys/cdefs.h>
  45 __FBSDID("$FreeBSD: src/sys/dev/re/if_re.c,v 1.95.00 " __DATE__ " " __TIME__ "  wpaul Exp $");
  46
  47 /*
  48 * This driver also support Realtek 8139C+, 8110S/SB/SC, RTL8111B/C/CP/D and RTL8101E/8102E/8103E.
  49 */
  50
  51 #include <sys/param.h>
  52 #include <sys/systm.h>
  53 #include <sys/sockio.h>
  54 #include <sys/mbuf.h>
  55 #include <sys/malloc.h>
  56 #include <sys/kernel.h>
  57 #include <sys/socket.h>
  58 #include <sys/taskqueue.h>
  59 #include <sys/random.h>
  60
  61 #include <net/if.h>
  62 #include <net/if_var.h>
  63 #include <net/if_arp.h>
  64 #include <net/ethernet.h>
  65 #include <net/if_dl.h>
  66 #include <net/if_media.h>
  67
  68 #include <net/bpf.h>
  69
  70 #include <vm/vm.h>              /* for vtophys */
  71 #include <vm/pmap.h>            /* for vtophys */
  72 #include <machine/clock.h>      /* for DELAY */
  73
  74 #include <machine/bus.h>
  75 #include <machine/resource.h>
  76 #include <sys/bus.h>
  77 #include <sys/rman.h>
  78 #include <sys/endian.h>
  79
  80 #include <dev/mii/mii.h>
  81 #include <dev/re/if_rereg.h>
  82
  83 #if OS_VER < VERSION(5,3)
  84 #include <pci/pcireg.h>
  85 #include <pci/pcivar.h>
  86 #include <machine/bus_pio.h>
  87 #include <machine/bus_memio.h>
  88 #else
  89 #include <dev/pci/pcireg.h>
  90 #include <dev/pci/pcivar.h>
  91 #include <sys/module.h>
  92 #endif
  93
  94 #if OS_VER > VERSION(5,9)
  95 #include <sys/cdefs.h>
  96 #include <sys/endian.h>
  97 #include <net/if_types.h>
  98 #include <net/if_vlan_var.h>
  99 #endif
 100 #else   /* __DragonFly__ */
 101
 102 #include <sys/param.h>
 103 #include <sys/bus.h>
 104 #include <sys/endian.h>
 105 #include <sys/kernel.h>
 106 #include <sys/systm.h>
 107
 108 #include <net/ethernet.h>
 109 #include <net/if.h>
 110 #include <net/if_arp.h>
 111 #include <net/if_dl.h>
 112 #include <net/if_media.h>
 113 #include <net/if_poll.h>
 114 #include <net/vlan/if_vlan_var.h>
 115
 116 #include <bus/pci/pcireg.h>
 117 #include <bus/pci/pcivar.h>
 118
 119 #include <dev/netif/mii_layer/mii.h>
 120 #include <dev/netif/re/if_revar.h>
 121 #include <dev/netif/re/re.h>
 122 #include <dev/netif/re/re_dragonfly.h>
 123
 124 #define RE_LOCK(sc)
 125 #define RE_UNLOCK(sc)
 126 #define RE_LOCK_ASSERT(sc)
 127
 128 #define RE_GET_IFNET(sc)        &(sc)->arpcom.ac_if
 129
 130 #endif  /* !__DragonFly__ */
 131
 132 #define EE_SET(x)                                       \
 133         CSR_WRITE_1(sc, RE_EECMD,                       \
 134                 CSR_READ_1(sc, RE_EECMD) | x)
 135
 136 #define EE_CLR(x)                                       \
 137         CSR_WRITE_1(sc, RE_EECMD,                       \
 138                 CSR_READ_1(sc, RE_EECMD) & ~x)
 139
 140 #ifndef __DragonFly__
 141 /*
 142  * Various supported device vendors/types and their names.
 143  */
 144 static struct re_type re_devs[] = {
 145         {
 146                 RT_VENDORID, RT_DEVICEID_8169,
 147                 "Realtek PCI GBE Family Controller"
 148         },
 149         {
 150                 RT_VENDORID, RT_DEVICEID_8169SC,
 151                 "Realtek PCI GBE Family Controller"
 152         },
 153         {
 154                 RT_VENDORID, RT_DEVICEID_8168,
 155                 "Realtek PCIe GBE Family Controller"
 156         },
 157         {
 158                 RT_VENDORID, RT_DEVICEID_8161,
 159                 "Realtek PCIe GBE Family Controller"
 160         },
 161         {
 162                 RT_VENDORID, RT_DEVICEID_8136,
 163                 "Realtek PCIe FE Family Controller"
 164         },
 165         {
 166                 DLINK_VENDORID, 0x4300,
 167                 "Realtek PCI GBE Family Controller"
 168         },
 169         { 0, 0, NULL }
 170 };
 171
 172 static int      re_probe                        __P((device_t));
 173 static int      re_attach                       __P((device_t));
 174 static int      re_detach                       __P((device_t));
 175 static int      re_suspend                      __P((device_t));
 176 static int      re_resume                       __P((device_t));
 177 static int      re_shutdown                     __P((device_t));
 178
 179 static void MP_WritePhyUshort                   __P((struct re_softc*, u_int8_t, u_int16_t));
 180 static u_int16_t MP_ReadPhyUshort               __P((struct re_softc*, u_int8_t));
 181 static void MP_WriteEPhyUshort                  __P((struct re_softc*, u_int8_t, u_int16_t));
 182 static u_int16_t MP_ReadEPhyUshort              __P((struct re_softc*, u_int8_t));
 183 static u_int8_t MP_ReadEfuse                    __P((struct re_softc*, u_int16_t));
 184 static void MP_WritePhyOcpRegWord       __P((struct re_softc*, u_int16_t, u_int8_t, u_int16_t));
 185 static u_int16_t MP_ReadPhyOcpRegWord   __P((struct re_softc*, u_int16_t, u_int8_t));
 186 static void MP_WriteMcuAccessRegWord    __P((struct re_softc*, u_int16_t, u_int16_t));
 187 static u_int16_t MP_ReadMcuAccessRegWord  __P((struct re_softc*, u_int16_t));
 188 static void MP_WriteOtherFunPciEConfigSpace    __P((struct re_softc *, u_int8_t, u_int16_t, u_int32_t Regata));
 189 static u_int32_t MP_ReadOtherFunPciEConfigSpace   __P((struct re_softc *, u_int8_t, u_int16_t));
 190 static void MP_WritePciEConfigSpace     __P((struct re_softc*, u_int16_t, u_int32_t));
 191 static u_int32_t MP_ReadPciEConfigSpace __P((struct re_softc*, u_int16_t));
 192 #endif  /* !__DragonFly__ */
 193
 194 static int re_check_dash  __P((struct re_softc *));
 195
 196 #ifndef __DragonFly__
 197 static void re_driver_start             __P((struct re_softc*));
 198 static void re_driver_stop              __P((struct re_softc*));
 199
 200 static void re_hw_phy_config            __P((struct re_softc *));
 201 static void re_init                     __P((void *));
 202 static int  re_var_init                 __P((struct re_softc *));
 203 static void re_reset                    __P((struct re_softc *));
 204 static void re_stop                     __P((struct re_softc *));
 205 static void re_setwol                   __P((struct re_softc *));
 206 #endif  /* !__DragonFly__ */
 207 static void re_clrwol                   __P((struct re_softc *));
 208 static void re_set_wol_linkspeed        __P((struct re_softc *));
 209
 210 #ifndef __DragonFly__
 211 static void re_start                            __P((struct ifnet *));
 212 static int re_encap                             __P((struct re_softc *, struct mbuf *));
 213 static void WritePacket                         __P((struct re_softc *, caddr_t, int, int, int, uint32_t, uint32_t));
 214 static int CountFreeTxDescNum                   __P((struct re_descriptor));
 215 static int CountMbufNum                         __P((struct mbuf *));
 216 #ifdef RE_FIXUP_RX
 217 static __inline void re_fixup_rx                __P((struct mbuf *));
 218 #endif
 219 static void re_txeof                            __P((struct re_softc *));
 220
 221 static void re_rxeof                            __P((struct re_softc *));
 222
 223 #if OS_VER < VERSION(7,0)
 224 static void re_intr                             __P((void *));
 225 #else
 226 static int re_intr                              __P((void *));
 227 #endif //OS_VER < VERSION(7,0)
 228 #endif  /* !__DragonFly__ */
 229 static void re_set_multicast_reg        __P((struct re_softc *, u_int32_t, u_int32_t));
 230 #ifndef __DragonFly__
 231 static void re_set_rx_packet_filter_in_sleep_state      __P((struct re_softc *));
 232 #endif
 233 static void re_set_rx_packet_filter     __P((struct re_softc *));
 234 static void re_setmulti                 __P((struct re_softc *));
 235 #ifndef __DragonFly__
 236 static int  re_ioctl                    __P((struct ifnet *, u_long, caddr_t));
 237 #endif
 238 static u_int8_t re_link_ok      __P((struct re_softc *));
 239 static void re_link_on_patch    __P((struct re_softc *));
 240 #ifndef __DragonFly__
 241 static void re_link_down_patch  __P((struct re_softc *));
 242 static void re_init_timer       __P((struct re_softc *));
 243 static void re_stop_timer       __P((struct re_softc *));
 244 static void re_start_timer      __P((struct re_softc *));
 245 static void re_tick                             __P((void *));
 246 #if OS_VER < VERSION(7,0)
 247 static void re_watchdog                         __P((struct ifnet *));
 248 #endif
 249 #endif  /* !__DragonFly__ */
 250
 251 static int  re_ifmedia_upd                      __P((struct ifnet *));
 252 static void re_ifmedia_sts                      __P((struct ifnet *, struct ifmediareq *));
 253
 254 static void re_eeprom_ShiftOutBits              __P((struct re_softc *, int, int));
 255 static u_int16_t re_eeprom_ShiftInBits          __P((struct re_softc *));
 256 static void re_eeprom_EEpromCleanup             __P((struct re_softc *));
 257 static void re_eeprom_getword                   __P((struct re_softc *, int, u_int16_t *));
 258 static void re_read_eeprom                      __P((struct re_softc *, caddr_t, int, int, int));
 259 #ifndef __DragonFly__
 260 static void re_int_task                         (void *, int);
 261 #endif  /* !__DragonFly__ */
 262
 263 static void re_phy_power_up(device_t dev);
 264 static void re_phy_power_down(device_t dev);
 265 #ifndef __DragonFly__
 266 static int re_alloc_buf(struct re_softc *);
 267 static void re_release_buf(struct re_softc *);
 268 static void set_rxbufsize(struct re_softc*);
 269 static void re_release_rx_buf(struct re_softc *);
 270 static void re_release_tx_buf(struct re_softc *);
 271 #endif  /* !__DragonFly__ */
 272 static u_int32_t re_eri_read(struct re_softc *, int, int, int);
 273 static int re_eri_write(struct re_softc *, int, int, u_int32_t, int);
 274 static void OOB_mutex_lock(struct re_softc *);
 275 static void OOB_mutex_unlock(struct re_softc *);
 276
 277 #ifdef __DragonFly__
 278 u_int16_t MP_ReadMcuAccessRegWord(struct re_softc *, u_int16_t);
 279 void MP_WriteMcuAccessRegWord(struct re_softc *, u_int16_t, u_int16_t);
 280
 281 u_int16_t MP_ReadPhyOcpRegWord(struct re_softc *, u_int16_t, u_int8_t);
 282 void MP_WritePhyOcpRegWord(struct re_softc *, u_int16_t, u_int8_t, u_int16_t);
 283
 284 void MP_WritePhyUshort(struct re_softc *, u_int8_t, u_int16_t);
 285 u_int16_t MP_ReadPhyUshort(struct re_softc *, u_int8_t);
 286
 287 u_int32_t MP_ReadPciEConfigSpace(struct re_softc *, u_int16_t);
 288 void MP_WritePciEConfigSpace(struct re_softc *, u_int16_t, u_int32_t);
 289 u_int32_t MP_ReadOtherFunPciEConfigSpace(struct re_softc *, u_int8_t,
 290     u_int16_t);
 291 void MP_WriteOtherFunPciEConfigSpace(struct re_softc *, u_int8_t, u_int16_t,
 292     u_int32_t);
 293
 294 u_int16_t MP_ReadEPhyUshort(struct re_softc *, u_int8_t);
 295 void MP_WriteEPhyUshort(struct re_softc *, u_int8_t, u_int16_t);
 296
 297 u_int8_t MP_ReadEfuse(struct re_softc *, u_int16_t);
 298
 299 void re_driver_start(struct re_softc *);
 300 void re_driver_stop(struct re_softc *);
 301 #endif  /* __DragonFly__ */
 302
 303 /* Tunables. */
 304 static int msi_disable = 1;
 305 TUNABLE_INT("hw.re.msi_disable", &msi_disable);
 306 static int msix_disable = 0;
 307 TUNABLE_INT("hw.re.msix_disable", &msix_disable);
 308 static int prefer_iomap = 0;
 309 TUNABLE_INT("hw.re.prefer_iomap", &prefer_iomap);
 310 static int eee_enable = 0;
 311 TUNABLE_INT("hw.re.eee_enable", &eee_enable);
 312 static int phy_power_saving = 1;
 313 TUNABLE_INT("hw.re.phy_power_saving", &phy_power_saving);
 314 static int phy_mdix_mode = RE_ETH_PHY_AUTO_MDI_MDIX;
 315 TUNABLE_INT("hw.re.phy_mdix_mode", &phy_mdix_mode);
 316
 317 #define RE_CSUM_FEATURES    (CSUM_IP | CSUM_TCP | CSUM_UDP)
 318
 319 #ifndef __DragonFly__
 320 static device_method_t re_methods[] = {
 321         /* Device interface */
 322         DEVMETHOD(device_probe, re_probe),
 323         DEVMETHOD(device_attach, re_attach),
 324         DEVMETHOD(device_detach, re_detach),
 325         DEVMETHOD(device_suspend, re_suspend),
 326         DEVMETHOD(device_resume, re_resume),
 327         DEVMETHOD(device_shutdown, re_shutdown),
 328         { 0, 0 }
 329 };
 330
 331 static driver_t re_driver = {
 332         "re",
 333         re_methods,
 334         sizeof(struct re_softc)
 335 };
 336
 337 static devclass_t re_devclass;
 338
 339 DRIVER_MODULE(if_re, pci, re_driver, re_devclass, NULL, NULL);
 340 #endif  /* !__DragonFly__ */
 341
 342 static int re_is_ups_resume(struct re_softc *sc)
 343 {
 344         return (MP_ReadMcuAccessRegWord(sc, 0xD408) & BIT_0);
 345 }
 346
 347 static void re_clear_ups_resume_bit(struct re_softc *sc)
 348 {
 349         MP_WriteMcuAccessRegWord(sc, 0xD408, MP_ReadMcuAccessRegWord(sc, 0xD408) & ~(BIT_0));
 350 }
 351
 352 static void re_wait_phy_ups_resume(struct re_softc *sc, u_int16_t PhyState)
 353 {
 354         u_int16_t TmpPhyState;
 355         int i=0;
 356
 357         do {
 358                 TmpPhyState = MP_ReadPhyOcpRegWord(sc, 0x0A42, 0x10);
 359                 TmpPhyState &= 0x7;
 360                 DELAY(1000);
 361                 i++;
 362         } while ((i < 100) && (TmpPhyState != 2));
 363 }
 364
 365 static void re_phy_power_up(device_t dev)
 366 {
 367         struct re_softc         *sc;
 368         u_int8_t Data8;
 369
 370         sc = device_get_softc(dev);
 371
 372         if ((sc->re_if_flags & RL_FLAG_PHYWAKE_PM) != 0)
 373                 CSR_WRITE_1(sc, RE_PMCH, CSR_READ_1(sc, RE_PMCH) | (BIT_6|BIT_7));
 374
 375         MP_WritePhyUshort(sc, 0x1F, 0x0000);
 376
 377         switch (sc->re_type) {
 378         case MACFG_4:
 379         case MACFG_5:
 380         case MACFG_6:
 381         case MACFG_21:
 382         case MACFG_22:
 383         case MACFG_23:
 384         case MACFG_24:
 385         case MACFG_25:
 386         case MACFG_26:
 387         case MACFG_27:
 388         case MACFG_28:
 389         case MACFG_31:
 390         case MACFG_32:
 391         case MACFG_33:
 392         case MACFG_63:
 393         case MACFG_64:
 394         case MACFG_65:
 395         case MACFG_66:
 396                 MP_WritePhyUshort(sc, 0x0e, 0x0000);
 397                 break;
 398         case MACFG_56:
 399         case MACFG_57:
 400         case MACFG_58:
 401         case MACFG_61:
 402                 Data8 = re_eri_read(sc, 0x1AB, 1, ERIAR_ExGMAC);
 403                 Data8 |= (BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
 404                 re_eri_write(sc, 0x1AB, 1, Data8, ERIAR_ExGMAC);
 405                 break;
 406         default:
 407                 break;
 408         };
 409
 410
 411         MP_WritePhyUshort(sc, MII_BMCR, BMCR_AUTOEN);
 412
 413         //wait mdc/mdio ready
 414         switch(sc->re_type) {
 415         case MACFG_61:
 416         case MACFG_62:
 417         case MACFG_67:
 418                 DELAY(10000);
 419                 break;
 420         }
 421
 422         //wait ups resume (phy state 3)
 423         switch(sc->re_type) {
 424         case MACFG_68:
 425         case MACFG_69:
 426         case MACFG_70:
 427         case MACFG_71:
 428                 re_wait_phy_ups_resume(sc, 3);
 429                 break;
 430         };
 431 }
 432
 433 static void re_phy_power_down(device_t dev)
 434 {
 435         struct re_softc         *sc;
 436         u_int8_t Data8;
 437
 438         sc = device_get_softc(dev);
 439
 440         if (sc->re_dash) {
 441                 re_set_wol_linkspeed(sc);
 442                 return;
 443         }
 444
 445         MP_WritePhyUshort(sc, 0x1F, 0x0000);
 446
 447         switch (sc->re_type) {
 448         case MACFG_21:
 449         case MACFG_22:
 450         case MACFG_23:
 451         case MACFG_24:
 452         case MACFG_25:
 453         case MACFG_26:
 454         case MACFG_27:
 455         case MACFG_28:
 456         case MACFG_31:
 457         case MACFG_32:
 458         case MACFG_33:
 459         case MACFG_63:
 460         case MACFG_64:
 461         case MACFG_65:
 462         case MACFG_66:
 463                 MP_WritePhyUshort(sc, 0x0e, 0x0200);
 464                 MP_WritePhyUshort(sc, MII_BMCR, (BMCR_AUTOEN|BMCR_PDOWN));
 465                 break;
 466         case MACFG_56:
 467         case MACFG_57:
 468         case MACFG_58:
 469         case MACFG_61:
 470                 Data8 = re_eri_read(sc, 0x1AB, 1, ERIAR_ExGMAC);
 471                 Data8 &= ~(BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
 472                 re_eri_write(sc, 0x1AB, 1, Data8, ERIAR_ExGMAC);
 473
 474                 MP_WritePhyUshort(sc, MII_BMCR, (BMCR_AUTOEN|BMCR_PDOWN));
 475                 break;
 476         default:
 477                 MP_WritePhyUshort(sc, MII_BMCR, (BMCR_AUTOEN|BMCR_PDOWN));
 478                 break;
 479         }
 480
 481         switch (sc->re_type) {
 482         case MACFG_56:
 483         case MACFG_57:
 484                 CSR_WRITE_1(sc, 0xD0, CSR_READ_1(sc, 0xD0) & ~BIT_6);
 485                 break;
 486         }
 487
 488         switch (sc->re_type) {
 489         case MACFG_68:
 490         case MACFG_69:
 491                 CSR_WRITE_1(sc, 0xD0, CSR_READ_1(sc, 0xD0) & ~BIT_6);
 492                 CSR_WRITE_1(sc, 0xF2, CSR_READ_1(sc, 0xF2) & ~BIT_6);
 493                 break;
 494         }
 495
 496         if ((sc->re_if_flags & RL_FLAG_PHYWAKE_PM) != 0)
 497                 CSR_WRITE_1(sc, RE_PMCH, CSR_READ_1(sc, RE_PMCH) & ~(BIT_6|BIT_7));
 498 }
 499
 500 #ifndef __DragonFly__
 501 static void re_tx_dma_map_buf(void *arg, bus_dma_segment_t *segs, int nseg, int error)
 502 {
 503         union TxDesc *txptr = arg;
 504
 505         if (error) {
 506                 txptr->ul[0] &= ~htole32(RL_TDESC_CMD_BUFLEN);
 507                 txptr->so1.TxBuffL = 0;
 508                 txptr->so1.TxBuffH = 0;
 509                 return;
 510         }
 511
 512         txptr->so1.TxBuffL = htole32(RL_ADDR_LO(segs->ds_addr));
 513         txptr->so1.TxBuffH = htole32(RL_ADDR_HI(segs->ds_addr));
 514 }
 515
 516 static void re_rx_dma_map_buf(void *arg, bus_dma_segment_t *segs, int nseg, int error)
 517 {
 518         union RxDesc *rxptr = arg;
 519
 520         if (error) {
 521                 rxptr->ul[0] &= ~htole32(RL_RDESC_CMD_BUFLEN);
 522                 rxptr->so0.RxBuffL = 0;
 523                 rxptr->so0.RxBuffH = 0;
 524                 return;
 525         }
 526
 527         rxptr->so0.RxBuffL = htole32(RL_ADDR_LO(segs->ds_addr));
 528         rxptr->so0.RxBuffH = htole32(RL_ADDR_HI(segs->ds_addr));
 529 }
 530
 531 static void re_dma_map_rxdesc(void *arg, bus_dma_segment_t *segs, int nseg, int error)
 532 {
 533         struct re_softc *sc = arg;
 534
 535
 536         if (error)
 537                 return;
 538
 539         CSR_WRITE_4(sc, 0xe4, RL_ADDR_LO(segs->ds_addr));
 540         CSR_WRITE_4(sc, 0xe8, RL_ADDR_HI(segs->ds_addr));
 541 }
 542
 543 static void re_dma_map_txdesc(void *arg, bus_dma_segment_t *segs, int nseg, int error)
 544 {
 545         struct re_softc *sc = arg;
 546
 547
 548         if (error)
 549                 return;
 550
 551         CSR_WRITE_4(sc, 0x20, RL_ADDR_LO(segs->ds_addr));
 552         CSR_WRITE_4(sc, 0x24, RL_ADDR_HI(segs->ds_addr));
 553 }
 554
 555 /*
 556  * Probe for a RealTek 8129/8139 chip. Check the PCI vendor and device
 557  * IDs against our list and return a device name if we find a match.
 558  */
 559 static int re_probe(dev)        /* Search for Realtek NIC chip */
 560 device_t                dev;
 561 {
 562         struct re_type          *t;
 563         t = re_devs;
 564         while (t->re_name != NULL) {
 565                 if ((pci_get_vendor(dev) == t->re_vid) &&
 566                     (pci_get_device(dev) == t->re_did)) {
 567                         device_set_desc(dev, t->re_name);
 568                         return(0);
 569                 }
 570                 t++;
 571         }
 572
 573         return(ENXIO);
 574 }
 575 #endif  /* !__DragonFly__ */
 576
 577
 578 static u_int32_t re_eri_read_with_oob_base_address(struct re_softc *sc, int addr, int len, int type, const u_int32_t base_address)
 579 {
 580         int i, val_shift, shift = 0;
 581         u_int32_t value1 = 0, value2 = 0, mask;
 582         const u_int32_t transformed_base_address = ((base_address & 0x00FFF000) << 6) | (base_address & 0x000FFF);
 583
 584         if (len > 4 || len <= 0)
 585                 return -1;
 586
 587         while (len > 0) {
 588                 val_shift = addr % ERIAR_Addr_Align;
 589                 addr = addr & ~0x3;
 590
 591                 CSR_WRITE_4(sc,RE_ERIAR,
 592                             ERIAR_Read |
 593                             transformed_base_address |
 594                             type << ERIAR_Type_shift |
 595                             ERIAR_ByteEn << ERIAR_ByteEn_shift |
 596                             addr);
 597
 598                 for (i = 0; i < 10; i++) {
 599                         DELAY(100);
 600
 601                         /* Check if the RTL8168 has completed ERI read */
 602                         if (CSR_READ_4(sc,RE_ERIAR) & ERIAR_Flag)
 603                                 break;
 604                 }
 605
 606                 if (len == 1)           mask = (0xFF << (val_shift * 8)) & 0xFFFFFFFF;
 607                 else if (len == 2)      mask = (0xFFFF << (val_shift * 8)) & 0xFFFFFFFF;
 608                 else if (len == 3)      mask = (0xFFFFFF << (val_shift * 8)) & 0xFFFFFFFF;
 609                 else                    mask = (0xFFFFFFFF << (val_shift * 8)) & 0xFFFFFFFF;
 610
 611                 value1 = CSR_READ_4(sc,RE_ERIDR) & mask;
 612                 value2 |= (value1 >> val_shift * 8) << shift * 8;
 613
 614                 if (len <= 4 - val_shift)
 615                         len = 0;
 616                 else {
 617                         len -= (4 - val_shift);
 618                         shift = 4 - val_shift;
 619                         addr += 4;
 620                 }
 621         }
 622
 623         return value2;
 624 }
 625
 626 static u_int32_t re_eri_read(struct re_softc *sc, int addr, int len, int type)
 627 {
 628         return re_eri_read_with_oob_base_address(sc, addr, len, type, 0);
 629 }
 630
 631 static int re_eri_write_with_oob_base_address(struct re_softc *sc, int addr, int len, u_int32_t value, int type, const u_int32_t base_address)
 632 {
 633
 634         int i, val_shift, shift = 0;
 635         u_int32_t value1 = 0, mask;
 636         const u_int32_t transformed_base_address = ((base_address & 0x00FFF000) << 6) | (base_address & 0x000FFF);
 637
 638         if (len > 4 || len <= 0)
 639                 return -1;
 640
 641         while (len > 0) {
 642                 val_shift = addr % ERIAR_Addr_Align;
 643                 addr = addr & ~0x3;
 644
 645                 if (len == 1)           mask = (0xFF << (val_shift * 8)) & 0xFFFFFFFF;
 646                 else if (len == 2)      mask = (0xFFFF << (val_shift * 8)) & 0xFFFFFFFF;
 647                 else if (len == 3)      mask = (0xFFFFFF << (val_shift * 8)) & 0xFFFFFFFF;
 648                 else                    mask = (0xFFFFFFFF << (val_shift * 8)) & 0xFFFFFFFF;
 649
 650                 value1 = re_eri_read_with_oob_base_address(sc, addr, 4, type, base_address) & ~mask;
 651                 value1 |= ((value << val_shift * 8) >> shift * 8);
 652
 653                 CSR_WRITE_4(sc,RE_ERIDR, value1);
 654                 CSR_WRITE_4(sc,RE_ERIAR,
 655                             ERIAR_Write |
 656                             transformed_base_address |
 657                             type << ERIAR_Type_shift |
 658                             ERIAR_ByteEn << ERIAR_ByteEn_shift |
 659                             addr);
 660
 661                 for (i = 0; i < 10; i++) {
 662                         DELAY(100);
 663
 664                         /* Check if the RTL8168 has completed ERI write */
 665                         if (!(CSR_READ_4(sc,RE_ERIAR) & ERIAR_Flag))
 666                                 break;
 667                 }
 668
 669                 if (len <= 4 - val_shift)
 670                         len = 0;
 671                 else {
 672                         len -= (4 - val_shift);
 673                         shift = 4 - val_shift;
 674                         addr += 4;
 675                 }
 676         }
 677
 678         return 0;
 679 }
 680
 681 static int re_eri_write(struct re_softc *sc, int addr, int len, u_int32_t value, int type)
 682 {
 683         return re_eri_write_with_oob_base_address(sc, addr, len, value, type, 0);
 684 }
 685
 686 static void
 687 ClearAndSetEthPhyBit(
 688         struct re_softc *sc,
 689         u_int8_t   addr,
 690         u_int16_t   clearmask,
 691         u_int16_t   setmask
 692 )
 693 {
 694         u_int16_t PhyRegValue;
 695
 696
 697         PhyRegValue = MP_ReadPhyUshort(sc, addr);
 698         PhyRegValue &= ~clearmask;
 699         PhyRegValue |= setmask;
 700         MP_WritePhyUshort(sc, addr, PhyRegValue);
 701 }
 702
 703 static void
 704 ClearEthPhyBit(
 705         struct re_softc *sc,
 706         u_int8_t   addr,
 707         u_int16_t   mask
 708 )
 709 {
 710         ClearAndSetEthPhyBit(sc,
 711                              addr,
 712                              mask,
 713                              0
 714                             );
 715 }
 716
 717 static void
 718 SetEthPhyBit(
 719         struct re_softc *sc,
 720         u_int8_t   addr,
 721         u_int16_t   mask
 722 )
 723 {
 724         ClearAndSetEthPhyBit(sc,
 725                              addr,
 726                              0,
 727                              mask
 728                             );
 729 }
 730
 731 #ifndef __DragonFly__
 732 static void re_release_rx_buf(struct re_softc *sc)
 733 {
 734         struct ifnet            *ifp;
 735         int i;
 736         ifp = RE_GET_IFNET(sc);
 737
 738         if (sc->re_desc.re_rx_mtag) {
 739                 for (i = 0; i < RE_RX_BUF_NUM; i++) {
 740                         if (sc->re_desc.rx_buf[i]!=NULL) {
 741                                 bus_dmamap_sync(sc->re_desc.re_rx_mtag,
 742                                                 sc->re_desc.re_rx_dmamap[i],
 743                                                 BUS_DMASYNC_POSTREAD);
 744                                 bus_dmamap_unload(sc->re_desc.re_rx_mtag,
 745                                                   sc->re_desc.re_rx_dmamap[i]);
 746                                 bus_dmamap_destroy(sc->re_desc.re_rx_mtag,
 747                                                    sc->re_desc.re_rx_dmamap[i]);
 748                                 m_freem(sc->re_desc.rx_buf[i]);
 749                                 sc->re_desc.rx_buf[i] =NULL;
 750                         }
 751                 }
 752                 bus_dma_tag_destroy(sc->re_desc.re_rx_mtag);
 753                 sc->re_desc.re_rx_mtag =0;
 754         }
 755
 756 }
 757 static void re_release_tx_buf(struct re_softc *sc)
 758 {
 759         struct ifnet            *ifp;
 760         int i;
 761         ifp = RE_GET_IFNET(sc);
 762
 763         if (sc->re_desc.re_tx_mtag) {
 764                 for (i = 0; i < RE_TX_BUF_NUM; i++) {
 765
 766                         bus_dmamap_destroy(sc->re_desc.re_tx_mtag,
 767                                            sc->re_desc.re_tx_dmamap[i]);
 768                         m_freem(sc->re_desc.tx_buf[i]);
 769
 770                 }
 771                 bus_dma_tag_destroy(sc->re_desc.re_tx_mtag);
 772                 sc->re_desc.re_tx_mtag = 0;
 773         }
 774
 775
 776 }
 777 static void re_release_buf(struct re_softc *sc)
 778 {
 779         re_release_rx_buf(sc);
 780         re_release_tx_buf(sc);
 781 }
 782
 783
 784
 785 static int re_alloc_buf(struct re_softc *sc)
 786 {
 787         int error =0;
 788         int i,size;
 789
 790         error = bus_dma_tag_create(sc->re_parent_tag, 1, 0,
 791                                    BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR, NULL,
 792                                    NULL, MCLBYTES* RE_NTXSEGS, RE_NTXSEGS, 4096, 0,
 793                                    NULL, NULL, &sc->re_desc.re_tx_mtag);
 794
 795         if (error) {
 796                 //device_printf(dev,"re_tx_mtag fail\n");
 797                 //goto fail;
 798                 return error;
 799         }
 800
 801         error = bus_dma_tag_create(
 802                         sc->re_parent_tag,
 803                         RE_RX_BUFFER_ALIGN, 0,          /* alignment, boundary */
 804                         BUS_SPACE_MAXADDR,              /* lowaddr */
 805                         BUS_SPACE_MAXADDR,              /* highaddr */
 806                         NULL, NULL,                     /* filter, filterarg */
 807                         sc->re_rx_desc_buf_sz, 1,                       /* maxsize,nsegments */
 808                         sc->re_rx_desc_buf_sz,                  /* maxsegsize */
 809                         0,                              /* flags */
 810                         NULL, NULL,                     /* lockfunc, lockarg */
 811                         &sc->re_desc.re_rx_mtag);
 812         if (error) {
 813                 //device_printf(dev,"re_rx_mtag fail\n");
 814                 //goto fail;
 815                 return error;
 816         }
 817
 818         if (sc->re_rx_mbuf_sz <= MCLBYTES)
 819                 size = MCLBYTES;
 820         else if (sc->re_rx_mbuf_sz <=  MJUMPAGESIZE)
 821                 size = MJUMPAGESIZE;
 822         else
 823                 size =MJUM9BYTES;
 824         for (i = 0; i < RE_RX_BUF_NUM; i++) {
 825                 sc->re_desc.rx_buf[i] = m_getjcl(M_DONTWAIT, MT_DATA, M_PKTHDR, size);
 826                 if (!sc->re_desc.rx_buf[i]) {
 827                         //device_printf(dev, "m_getcl fail!!!\n");
 828                         error = ENXIO;
 829                         //goto fail;
 830                         return error;
 831                 }
 832
 833                 sc->re_desc.rx_buf[i]->m_len = sc->re_desc.rx_buf[i]->m_pkthdr.len = size;
 834 #ifdef RE_FIXUP_RX
 835                 /*
 836                  * This is part of an evil trick to deal with non-x86 platforms.
 837                  * The RealTek chip requires RX buffers to be aligned on 64-bit
 838                  * boundaries, but that will hose non-x86 machines. To get around
 839                  * this, we leave some empty space at the start of each buffer
 840                  * and for non-x86 hosts, we copy the buffer back six bytes
 841                  * to achieve word alignment. This is slightly more efficient
 842                  * than allocating a new buffer, copying the contents, and
 843                  * discarding the old buffer.
 844                  */
 845                 m_adj(sc->re_desc.rx_buf[i], RE_ETHER_ALIGN);
 846 #endif
 847
 848                 error = bus_dmamap_create(sc->re_desc.re_rx_mtag, BUS_DMA_NOWAIT, &sc->re_desc.re_rx_dmamap[i]);
 849                 if (error) {
 850                         //device_printf(dev, "bus_dmamap_create fail!!!\n");
 851                         //goto fail;
 852                         return error;
 853                 }
 854         }
 855
 856         for (i = 0; i < RE_TX_BUF_NUM; i++) {
 857                 error = bus_dmamap_create(sc->re_desc.re_tx_mtag, BUS_DMA_NOWAIT, &sc->re_desc.re_tx_dmamap[i]);
 858                 if (error) {
 859                         //device_printf(dev, "bus_dmamap_create fail!!!\n");
 860                         //goto fail;
 861                         return error;
 862                 }
 863         }
 864
 865         return 0;
 866 }
 867
 868 static void set_rxbufsize(struct re_softc *sc)
 869 {
 870
 871         //printf("set size\n");
 872
 873         struct ifnet            *ifp;
 874         ifp = RE_GET_IFNET(sc);
 875         sc->re_rx_desc_buf_sz = (ifp->if_mtu > ETHERMTU) ? ifp->if_mtu: ETHERMTU;
 876         sc->re_rx_desc_buf_sz += (ETHER_VLAN_ENCAP_LEN + ETHER_HDR_LEN + ETHER_CRC_LEN + 1);
 877         CSR_WRITE_2(sc, RE_RxMaxSize, sc->re_rx_desc_buf_sz);
 878 }
 879 #endif  /* !__DragonFly__ */
 880
 881 static void re_enable_cfg9346_write(struct re_softc *sc)
 882 {
 883         EE_SET(RE_EEMODE_WRITECFG);
 884 }
 885
 886 static void re_disable_cfg9346_write(struct re_softc *sc)
 887 {
 888         EE_CLR(RE_EEMODE_WRITECFG);
 889 }
 890
 891 static void DisableMcuBPs(struct re_softc *sc)
 892 {
 893         switch(sc->re_type) {
 894         case MACFG_68:
 895         case MACFG_69:
 896         case MACFG_70:
 897         case MACFG_71:
 898                 MP_WriteMcuAccessRegWord(sc, 0xFC38, 0x0000);
 899                 break;
 900         }
 901
 902         switch(sc->re_type) {
 903         case MACFG_56:
 904         case MACFG_57:
 905         case MACFG_58:
 906         case MACFG_59:
 907         case MACFG_60:
 908         case MACFG_61:
 909         case MACFG_62:
 910         case MACFG_67:
 911         case MACFG_68:
 912         case MACFG_69:
 913         case MACFG_70:
 914         case MACFG_71:
 915                 re_enable_cfg9346_write(sc);
 916                 CSR_WRITE_1(sc, RE_CFG5, CSR_READ_1(sc, RE_CFG5) & ~BIT_0);
 917                 CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2) & ~BIT_7);
 918                 re_disable_cfg9346_write(sc);
 919
 920                 MP_WriteMcuAccessRegWord(sc, 0xFC28, 0x0000);
 921                 MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x0000);
 922                 MP_WriteMcuAccessRegWord(sc, 0xFC2C, 0x0000);
 923                 MP_WriteMcuAccessRegWord(sc, 0xFC2E, 0x0000);
 924                 MP_WriteMcuAccessRegWord(sc, 0xFC30, 0x0000);
 925                 MP_WriteMcuAccessRegWord(sc, 0xFC32, 0x0000);
 926                 MP_WriteMcuAccessRegWord(sc, 0xFC34, 0x0000);
 927                 MP_WriteMcuAccessRegWord(sc, 0xFC36, 0x0000);
 928
 929                 DELAY(3000);
 930
 931                 MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x0000);
 932                 break;
 933         }
 934 }
 935
 936 static void re_set_mac_mcu_8168g_1(struct re_softc *sc)
 937 {
 938         MP_WriteMcuAccessRegWord(sc, 0xE43C, 0x0000);
 939         MP_WriteMcuAccessRegWord(sc, 0xE43E, 0x0000);
 940
 941         MP_WriteMcuAccessRegWord(sc, 0xE434, 0x0004);
 942         MP_WriteMcuAccessRegWord(sc, 0xE43C, 0x0004);
 943
 944         DisableMcuBPs(sc);
 945
 946         MP_WriteMcuAccessRegWord(sc, 0xF800, 0xE008);
 947         MP_WriteMcuAccessRegWord(sc, 0xF802, 0xE01B);
 948         MP_WriteMcuAccessRegWord(sc, 0xF804, 0xE022);
 949         MP_WriteMcuAccessRegWord(sc, 0xF806, 0xE094);
 950         MP_WriteMcuAccessRegWord(sc, 0xF808, 0xE097);
 951         MP_WriteMcuAccessRegWord(sc, 0xF80A, 0xE09A);
 952         MP_WriteMcuAccessRegWord(sc, 0xF80C, 0xE0B3);
 953         MP_WriteMcuAccessRegWord(sc, 0xF80E, 0xE0BA);
 954         MP_WriteMcuAccessRegWord(sc, 0xF810, 0x49D2);
 955         MP_WriteMcuAccessRegWord(sc, 0xF812, 0xF10D);
 956         MP_WriteMcuAccessRegWord(sc, 0xF814, 0x766C);
 957         MP_WriteMcuAccessRegWord(sc, 0xF816, 0x49E2);
 958         MP_WriteMcuAccessRegWord(sc, 0xF818, 0xF00A);
 959         MP_WriteMcuAccessRegWord(sc, 0xF81A, 0x1EC0);
 960         MP_WriteMcuAccessRegWord(sc, 0xF81C, 0x8EE1);
 961         MP_WriteMcuAccessRegWord(sc, 0xF81E, 0xC60A);
 962         MP_WriteMcuAccessRegWord(sc, 0xF820, 0x77C0);
 963         MP_WriteMcuAccessRegWord(sc, 0xF822, 0x4870);
 964         MP_WriteMcuAccessRegWord(sc, 0xF824, 0x9FC0);
 965         MP_WriteMcuAccessRegWord(sc, 0xF826, 0x1EA0);
 966         MP_WriteMcuAccessRegWord(sc, 0xF828, 0xC707);
 967         MP_WriteMcuAccessRegWord(sc, 0xF82A, 0x8EE1);
 968         MP_WriteMcuAccessRegWord(sc, 0xF82C, 0x9D6C);
 969         MP_WriteMcuAccessRegWord(sc, 0xF82E, 0xC603);
 970         MP_WriteMcuAccessRegWord(sc, 0xF830, 0xBE00);
 971         MP_WriteMcuAccessRegWord(sc, 0xF832, 0xB416);
 972         MP_WriteMcuAccessRegWord(sc, 0xF834, 0x0076);
 973         MP_WriteMcuAccessRegWord(sc, 0xF836, 0xE86C);
 974         MP_WriteMcuAccessRegWord(sc, 0xF838, 0xC406);
 975         MP_WriteMcuAccessRegWord(sc, 0xF83A, 0x7580);
 976         MP_WriteMcuAccessRegWord(sc, 0xF83C, 0x4852);
 977         MP_WriteMcuAccessRegWord(sc, 0xF83E, 0x8D80);
 978         MP_WriteMcuAccessRegWord(sc, 0xF840, 0xC403);
 979         MP_WriteMcuAccessRegWord(sc, 0xF842, 0xBC00);
 980         MP_WriteMcuAccessRegWord(sc, 0xF844, 0xD3E0);
 981         MP_WriteMcuAccessRegWord(sc, 0xF846, 0x02C8);
 982         MP_WriteMcuAccessRegWord(sc, 0xF848, 0x8918);
 983         MP_WriteMcuAccessRegWord(sc, 0xF84A, 0xE815);
 984         MP_WriteMcuAccessRegWord(sc, 0xF84C, 0x1100);
 985         MP_WriteMcuAccessRegWord(sc, 0xF84E, 0xF011);
 986         MP_WriteMcuAccessRegWord(sc, 0xF850, 0xE812);
 987         MP_WriteMcuAccessRegWord(sc, 0xF852, 0x4990);
 988         MP_WriteMcuAccessRegWord(sc, 0xF854, 0xF002);
 989         MP_WriteMcuAccessRegWord(sc, 0xF856, 0xE817);
 990         MP_WriteMcuAccessRegWord(sc, 0xF858, 0xE80E);
 991         MP_WriteMcuAccessRegWord(sc, 0xF85A, 0x4992);
 992         MP_WriteMcuAccessRegWord(sc, 0xF85C, 0xF002);
 993         MP_WriteMcuAccessRegWord(sc, 0xF85E, 0xE80E);
 994         MP_WriteMcuAccessRegWord(sc, 0xF860, 0xE80A);
 995         MP_WriteMcuAccessRegWord(sc, 0xF862, 0x4993);
 996         MP_WriteMcuAccessRegWord(sc, 0xF864, 0xF002);
 997         MP_WriteMcuAccessRegWord(sc, 0xF866, 0xE818);
 998         MP_WriteMcuAccessRegWord(sc, 0xF868, 0xE806);
 999         MP_WriteMcuAccessRegWord(sc, 0xF86A, 0x4991);
1000         MP_WriteMcuAccessRegWord(sc, 0xF86C, 0xF002);
1001         MP_WriteMcuAccessRegWord(sc, 0xF86E, 0xE838);
1002         MP_WriteMcuAccessRegWord(sc, 0xF870, 0xC25E);
1003         MP_WriteMcuAccessRegWord(sc, 0xF872, 0xBA00);
1004         MP_WriteMcuAccessRegWord(sc, 0xF874, 0xC056);
1005         MP_WriteMcuAccessRegWord(sc, 0xF876, 0x7100);
1006         MP_WriteMcuAccessRegWord(sc, 0xF878, 0xFF80);
1007         MP_WriteMcuAccessRegWord(sc, 0xF87A, 0x7100);
1008         MP_WriteMcuAccessRegWord(sc, 0xF87C, 0x4892);
1009         MP_WriteMcuAccessRegWord(sc, 0xF87E, 0x4813);
1010         MP_WriteMcuAccessRegWord(sc, 0xF880, 0x8900);
1011         MP_WriteMcuAccessRegWord(sc, 0xF882, 0xE00A);
1012         MP_WriteMcuAccessRegWord(sc, 0xF884, 0x7100);
1013         MP_WriteMcuAccessRegWord(sc, 0xF886, 0x4890);
1014         MP_WriteMcuAccessRegWord(sc, 0xF888, 0x4813);
1015         MP_WriteMcuAccessRegWord(sc, 0xF88A, 0x8900);
1016         MP_WriteMcuAccessRegWord(sc, 0xF88C, 0xC74B);
1017         MP_WriteMcuAccessRegWord(sc, 0xF88E, 0x74F8);
1018         MP_WriteMcuAccessRegWord(sc, 0xF890, 0x48C2);
1019         MP_WriteMcuAccessRegWord(sc, 0xF892, 0x4841);
1020         MP_WriteMcuAccessRegWord(sc, 0xF894, 0x8CF8);
1021         MP_WriteMcuAccessRegWord(sc, 0xF896, 0xC746);
1022         MP_WriteMcuAccessRegWord(sc, 0xF898, 0x74FC);
1023         MP_WriteMcuAccessRegWord(sc, 0xF89A, 0x49C0);
1024         MP_WriteMcuAccessRegWord(sc, 0xF89C, 0xF120);
1025         MP_WriteMcuAccessRegWord(sc, 0xF89E, 0x49C1);
1026         MP_WriteMcuAccessRegWord(sc, 0xF8A0, 0xF11E);
1027         MP_WriteMcuAccessRegWord(sc, 0xF8A2, 0x74F8);
1028         MP_WriteMcuAccessRegWord(sc, 0xF8A4, 0x49C0);
1029         MP_WriteMcuAccessRegWord(sc, 0xF8A6, 0xF01B);
1030         MP_WriteMcuAccessRegWord(sc, 0xF8A8, 0x49C6);
1031         MP_WriteMcuAccessRegWord(sc, 0xF8AA, 0xF119);
1032         MP_WriteMcuAccessRegWord(sc, 0xF8AC, 0x74F8);
1033         MP_WriteMcuAccessRegWord(sc, 0xF8AE, 0x49C4);
1034         MP_WriteMcuAccessRegWord(sc, 0xF8B0, 0xF013);
1035         MP_WriteMcuAccessRegWord(sc, 0xF8B2, 0xC536);
1036         MP_WriteMcuAccessRegWord(sc, 0xF8B4, 0x74B0);
1037         MP_WriteMcuAccessRegWord(sc, 0xF8B6, 0x49C1);
1038         MP_WriteMcuAccessRegWord(sc, 0xF8B8, 0xF1FD);
1039         MP_WriteMcuAccessRegWord(sc, 0xF8BA, 0xC537);
1040         MP_WriteMcuAccessRegWord(sc, 0xF8BC, 0xC434);
1041         MP_WriteMcuAccessRegWord(sc, 0xF8BE, 0x9CA0);
1042         MP_WriteMcuAccessRegWord(sc, 0xF8C0, 0xC435);
1043         MP_WriteMcuAccessRegWord(sc, 0xF8C2, 0x1C13);
1044         MP_WriteMcuAccessRegWord(sc, 0xF8C4, 0x484F);
1045         MP_WriteMcuAccessRegWord(sc, 0xF8C6, 0x9CA2);
1046         MP_WriteMcuAccessRegWord(sc, 0xF8C8, 0xC52B);
1047         MP_WriteMcuAccessRegWord(sc, 0xF8CA, 0x74B0);
1048         MP_WriteMcuAccessRegWord(sc, 0xF8CC, 0x49C1);
1049         MP_WriteMcuAccessRegWord(sc, 0xF8CE, 0xF1FD);
1050         MP_WriteMcuAccessRegWord(sc, 0xF8D0, 0x74F8);
1051         MP_WriteMcuAccessRegWord(sc, 0xF8D2, 0x48C4);
1052         MP_WriteMcuAccessRegWord(sc, 0xF8D4, 0x8CF8);
1053         MP_WriteMcuAccessRegWord(sc, 0xF8D6, 0x7100);
1054         MP_WriteMcuAccessRegWord(sc, 0xF8D8, 0x4893);
1055         MP_WriteMcuAccessRegWord(sc, 0xF8DA, 0x8900);
1056         MP_WriteMcuAccessRegWord(sc, 0xF8DC, 0xFF80);
1057         MP_WriteMcuAccessRegWord(sc, 0xF8DE, 0xC520);
1058         MP_WriteMcuAccessRegWord(sc, 0xF8E0, 0x74B0);
1059         MP_WriteMcuAccessRegWord(sc, 0xF8E2, 0x49C1);
1060         MP_WriteMcuAccessRegWord(sc, 0xF8E4, 0xF11C);
1061         MP_WriteMcuAccessRegWord(sc, 0xF8E6, 0xC71E);
1062         MP_WriteMcuAccessRegWord(sc, 0xF8E8, 0x74FC);
1063         MP_WriteMcuAccessRegWord(sc, 0xF8EA, 0x49C1);
1064         MP_WriteMcuAccessRegWord(sc, 0xF8EC, 0xF118);
1065         MP_WriteMcuAccessRegWord(sc, 0xF8EE, 0x49C0);
1066         MP_WriteMcuAccessRegWord(sc, 0xF8F0, 0xF116);
1067         MP_WriteMcuAccessRegWord(sc, 0xF8F2, 0x74F8);
1068         MP_WriteMcuAccessRegWord(sc, 0xF8F4, 0x49C0);
1069         MP_WriteMcuAccessRegWord(sc, 0xF8F6, 0xF013);
1070         MP_WriteMcuAccessRegWord(sc, 0xF8F8, 0x48C3);
1071         MP_WriteMcuAccessRegWord(sc, 0xF8FA, 0x8CF8);
1072         MP_WriteMcuAccessRegWord(sc, 0xF8FC, 0xC516);
1073         MP_WriteMcuAccessRegWord(sc, 0xF8FE, 0x74A2);
1074         MP_WriteMcuAccessRegWord(sc, 0xF900, 0x49CE);
1075         MP_WriteMcuAccessRegWord(sc, 0xF902, 0xF1FE);
1076         MP_WriteMcuAccessRegWord(sc, 0xF904, 0xC411);
1077         MP_WriteMcuAccessRegWord(sc, 0xF906, 0x9CA0);
1078         MP_WriteMcuAccessRegWord(sc, 0xF908, 0xC411);
1079         MP_WriteMcuAccessRegWord(sc, 0xF90A, 0x1C13);
1080         MP_WriteMcuAccessRegWord(sc, 0xF90C, 0x484F);
1081         MP_WriteMcuAccessRegWord(sc, 0xF90E, 0x9CA2);
1082         MP_WriteMcuAccessRegWord(sc, 0xF910, 0x74A2);
1083         MP_WriteMcuAccessRegWord(sc, 0xF912, 0x49CF);
1084         MP_WriteMcuAccessRegWord(sc, 0xF914, 0xF1FE);
1085         MP_WriteMcuAccessRegWord(sc, 0xF916, 0x7100);
1086         MP_WriteMcuAccessRegWord(sc, 0xF918, 0x4891);
1087         MP_WriteMcuAccessRegWord(sc, 0xF91A, 0x8900);
1088         MP_WriteMcuAccessRegWord(sc, 0xF91C, 0xFF80);
1089         MP_WriteMcuAccessRegWord(sc, 0xF91E, 0xE400);
1090         MP_WriteMcuAccessRegWord(sc, 0xF920, 0xD3E0);
1091         MP_WriteMcuAccessRegWord(sc, 0xF922, 0xE000);
1092         MP_WriteMcuAccessRegWord(sc, 0xF924, 0x0481);
1093         MP_WriteMcuAccessRegWord(sc, 0xF926, 0x0C81);
1094         MP_WriteMcuAccessRegWord(sc, 0xF928, 0xDE20);
1095         MP_WriteMcuAccessRegWord(sc, 0xF92A, 0x0000);
1096         MP_WriteMcuAccessRegWord(sc, 0xF92C, 0x0992);
1097         MP_WriteMcuAccessRegWord(sc, 0xF92E, 0x1B76);
1098         MP_WriteMcuAccessRegWord(sc, 0xF930, 0xC602);
1099         MP_WriteMcuAccessRegWord(sc, 0xF932, 0xBE00);
1100         MP_WriteMcuAccessRegWord(sc, 0xF934, 0x059C);
1101         MP_WriteMcuAccessRegWord(sc, 0xF936, 0x1B76);
1102         MP_WriteMcuAccessRegWord(sc, 0xF938, 0xC602);
1103         MP_WriteMcuAccessRegWord(sc, 0xF93A, 0xBE00);
1104         MP_WriteMcuAccessRegWord(sc, 0xF93C, 0x065A);
1105         MP_WriteMcuAccessRegWord(sc, 0xF93E, 0xB400);
1106         MP_WriteMcuAccessRegWord(sc, 0xF940, 0x18DE);
1107         MP_WriteMcuAccessRegWord(sc, 0xF942, 0x2008);
1108         MP_WriteMcuAccessRegWord(sc, 0xF944, 0x4001);
1109         MP_WriteMcuAccessRegWord(sc, 0xF946, 0xF10F);
1110         MP_WriteMcuAccessRegWord(sc, 0xF948, 0x7342);
1111         MP_WriteMcuAccessRegWord(sc, 0xF94A, 0x1880);
1112         MP_WriteMcuAccessRegWord(sc, 0xF94C, 0x2008);
1113         MP_WriteMcuAccessRegWord(sc, 0xF94E, 0x0009);
1114         MP_WriteMcuAccessRegWord(sc, 0xF950, 0x4018);
1115         MP_WriteMcuAccessRegWord(sc, 0xF952, 0xF109);
1116         MP_WriteMcuAccessRegWord(sc, 0xF954, 0x7340);
1117         MP_WriteMcuAccessRegWord(sc, 0xF956, 0x25BC);
1118         MP_WriteMcuAccessRegWord(sc, 0xF958, 0x130F);
1119         MP_WriteMcuAccessRegWord(sc, 0xF95A, 0xF105);
1120         MP_WriteMcuAccessRegWord(sc, 0xF95C, 0xC00A);
1121         MP_WriteMcuAccessRegWord(sc, 0xF95E, 0x7300);
1122         MP_WriteMcuAccessRegWord(sc, 0xF960, 0x4831);
1123         MP_WriteMcuAccessRegWord(sc, 0xF962, 0x9B00);
1124         MP_WriteMcuAccessRegWord(sc, 0xF964, 0xB000);
1125         MP_WriteMcuAccessRegWord(sc, 0xF966, 0x7340);
1126         MP_WriteMcuAccessRegWord(sc, 0xF968, 0x8320);
1127         MP_WriteMcuAccessRegWord(sc, 0xF96A, 0xC302);
1128         MP_WriteMcuAccessRegWord(sc, 0xF96C, 0xBB00);
1129         MP_WriteMcuAccessRegWord(sc, 0xF96E, 0x0C12);
1130         MP_WriteMcuAccessRegWord(sc, 0xF970, 0xE860);
1131         MP_WriteMcuAccessRegWord(sc, 0xF972, 0xC406);
1132         MP_WriteMcuAccessRegWord(sc, 0xF974, 0x7580);
1133         MP_WriteMcuAccessRegWord(sc, 0xF976, 0x4851);
1134         MP_WriteMcuAccessRegWord(sc, 0xF978, 0x8D80);
1135         MP_WriteMcuAccessRegWord(sc, 0xF97A, 0xC403);
1136         MP_WriteMcuAccessRegWord(sc, 0xF97C, 0xBC00);
1137         MP_WriteMcuAccessRegWord(sc, 0xF97E, 0xD3E0);
1138         MP_WriteMcuAccessRegWord(sc, 0xF980, 0x02C8);
1139         MP_WriteMcuAccessRegWord(sc, 0xF982, 0xC406);
1140         MP_WriteMcuAccessRegWord(sc, 0xF984, 0x7580);
1141         MP_WriteMcuAccessRegWord(sc, 0xF986, 0x4850);
1142         MP_WriteMcuAccessRegWord(sc, 0xF988, 0x8D80);
1143         MP_WriteMcuAccessRegWord(sc, 0xF98A, 0xC403);
1144         MP_WriteMcuAccessRegWord(sc, 0xF98C, 0xBC00);
1145         MP_WriteMcuAccessRegWord(sc, 0xF98E, 0xD3E0);
1146         MP_WriteMcuAccessRegWord(sc, 0xF990, 0x0298);
1147
1148         MP_WriteMcuAccessRegWord(sc, 0xDE30, 0x0080);
1149
1150         MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000);
1151
1152         MP_WriteMcuAccessRegWord(sc, 0xFC28, 0x0075);
1153         MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x02B1);
1154         MP_WriteMcuAccessRegWord(sc, 0xFC2C, 0x0991);
1155         MP_WriteMcuAccessRegWord(sc, 0xFC2E, 0x059B);
1156         MP_WriteMcuAccessRegWord(sc, 0xFC30, 0x0659);
1157         MP_WriteMcuAccessRegWord(sc, 0xFC32, 0x0000);
1158         MP_WriteMcuAccessRegWord(sc, 0xFC34, 0x02BB);
1159         MP_WriteMcuAccessRegWord(sc, 0xFC36, 0x0279);
1160 }
1161
1162 static void re_set_mac_mcu_8168gu_1(struct re_softc *sc)
1163 {
1164         DisableMcuBPs(sc);
1165
1166         MP_WriteMcuAccessRegWord(sc, 0xF800, 0xE008);
1167         MP_WriteMcuAccessRegWord(sc, 0xF802, 0xE011);
1168         MP_WriteMcuAccessRegWord(sc, 0xF804, 0xE015);
1169         MP_WriteMcuAccessRegWord(sc, 0xF806, 0xE018);
1170         MP_WriteMcuAccessRegWord(sc, 0xF808, 0xE01B);
1171         MP_WriteMcuAccessRegWord(sc, 0xF80A, 0xE027);
1172         MP_WriteMcuAccessRegWord(sc, 0xF80C, 0xE043);
1173         MP_WriteMcuAccessRegWord(sc, 0xF80E, 0xE065);
1174         MP_WriteMcuAccessRegWord(sc, 0xF810, 0x49E2);
1175         MP_WriteMcuAccessRegWord(sc, 0xF812, 0xF005);
1176         MP_WriteMcuAccessRegWord(sc, 0xF814, 0x49EA);
1177         MP_WriteMcuAccessRegWord(sc, 0xF816, 0xF003);
1178         MP_WriteMcuAccessRegWord(sc, 0xF818, 0xC404);
1179         MP_WriteMcuAccessRegWord(sc, 0xF81A, 0xBC00);
1180         MP_WriteMcuAccessRegWord(sc, 0xF81C, 0xC403);
1181         MP_WriteMcuAccessRegWord(sc, 0xF81E, 0xBC00);
1182         MP_WriteMcuAccessRegWord(sc, 0xF820, 0x0496);
1183         MP_WriteMcuAccessRegWord(sc, 0xF822, 0x051A);
1184         MP_WriteMcuAccessRegWord(sc, 0xF824, 0x1D01);
1185         MP_WriteMcuAccessRegWord(sc, 0xF826, 0x8DE8);
1186         MP_WriteMcuAccessRegWord(sc, 0xF828, 0xC602);
1187         MP_WriteMcuAccessRegWord(sc, 0xF82A, 0xBE00);
1188         MP_WriteMcuAccessRegWord(sc, 0xF82C, 0x0206);
1189         MP_WriteMcuAccessRegWord(sc, 0xF82E, 0x1B76);
1190         MP_WriteMcuAccessRegWord(sc, 0xF830, 0xC202);
1191         MP_WriteMcuAccessRegWord(sc, 0xF832, 0xBA00);
1192         MP_WriteMcuAccessRegWord(sc, 0xF834, 0x058A);
1193         MP_WriteMcuAccessRegWord(sc, 0xF836, 0x1B76);
1194         MP_WriteMcuAccessRegWord(sc, 0xF838, 0xC602);
1195         MP_WriteMcuAccessRegWord(sc, 0xF83A, 0xBE00);
1196         MP_WriteMcuAccessRegWord(sc, 0xF83C, 0x0648);
1197         MP_WriteMcuAccessRegWord(sc, 0xF83E, 0x74E6);
1198         MP_WriteMcuAccessRegWord(sc, 0xF840, 0x1B78);
1199         MP_WriteMcuAccessRegWord(sc, 0xF842, 0x46DC);
1200         MP_WriteMcuAccessRegWord(sc, 0xF844, 0x1300);
1201         MP_WriteMcuAccessRegWord(sc, 0xF846, 0xF005);
1202         MP_WriteMcuAccessRegWord(sc, 0xF848, 0x74F8);
1203         MP_WriteMcuAccessRegWord(sc, 0xF84A, 0x48C3);
1204         MP_WriteMcuAccessRegWord(sc, 0xF84C, 0x48C4);
1205         MP_WriteMcuAccessRegWord(sc, 0xF84E, 0x8CF8);
1206         MP_WriteMcuAccessRegWord(sc, 0xF850, 0x64E7);
1207         MP_WriteMcuAccessRegWord(sc, 0xF852, 0xC302);
1208         MP_WriteMcuAccessRegWord(sc, 0xF854, 0xBB00);
1209         MP_WriteMcuAccessRegWord(sc, 0xF856, 0x068E);
1210         MP_WriteMcuAccessRegWord(sc, 0xF858, 0x74E4);
1211         MP_WriteMcuAccessRegWord(sc, 0xF85A, 0x49C5);
1212         MP_WriteMcuAccessRegWord(sc, 0xF85C, 0xF106);
1213         MP_WriteMcuAccessRegWord(sc, 0xF85E, 0x49C6);
1214         MP_WriteMcuAccessRegWord(sc, 0xF860, 0xF107);
1215         MP_WriteMcuAccessRegWord(sc, 0xF862, 0x48C8);
1216         MP_WriteMcuAccessRegWord(sc, 0xF864, 0x48C9);
1217         MP_WriteMcuAccessRegWord(sc, 0xF866, 0xE011);
1218         MP_WriteMcuAccessRegWord(sc, 0xF868, 0x48C9);
1219         MP_WriteMcuAccessRegWord(sc, 0xF86A, 0x4848);
1220         MP_WriteMcuAccessRegWord(sc, 0xF86C, 0xE00E);
1221         MP_WriteMcuAccessRegWord(sc, 0xF86E, 0x4848);
1222         MP_WriteMcuAccessRegWord(sc, 0xF870, 0x49C7);
1223         MP_WriteMcuAccessRegWord(sc, 0xF872, 0xF00A);
1224         MP_WriteMcuAccessRegWord(sc, 0xF874, 0x48C9);
1225         MP_WriteMcuAccessRegWord(sc, 0xF876, 0xC60D);
1226         MP_WriteMcuAccessRegWord(sc, 0xF878, 0x1D1F);
1227         MP_WriteMcuAccessRegWord(sc, 0xF87A, 0x8DC2);
1228         MP_WriteMcuAccessRegWord(sc, 0xF87C, 0x1D00);
1229         MP_WriteMcuAccessRegWord(sc, 0xF87E, 0x8DC3);
1230         MP_WriteMcuAccessRegWord(sc, 0xF880, 0x1D11);
1231         MP_WriteMcuAccessRegWord(sc, 0xF882, 0x8DC0);
1232         MP_WriteMcuAccessRegWord(sc, 0xF884, 0xE002);
1233         MP_WriteMcuAccessRegWord(sc, 0xF886, 0x4849);
1234         MP_WriteMcuAccessRegWord(sc, 0xF888, 0x94E5);
1235         MP_WriteMcuAccessRegWord(sc, 0xF88A, 0xC602);
1236         MP_WriteMcuAccessRegWord(sc, 0xF88C, 0xBE00);
1237         MP_WriteMcuAccessRegWord(sc, 0xF88E, 0x0238);
1238         MP_WriteMcuAccessRegWord(sc, 0xF890, 0xE434);
1239         MP_WriteMcuAccessRegWord(sc, 0xF892, 0x49D9);
1240         MP_WriteMcuAccessRegWord(sc, 0xF894, 0xF01B);
1241         MP_WriteMcuAccessRegWord(sc, 0xF896, 0xC31E);
1242         MP_WriteMcuAccessRegWord(sc, 0xF898, 0x7464);
1243         MP_WriteMcuAccessRegWord(sc, 0xF89A, 0x49C4);
1244         MP_WriteMcuAccessRegWord(sc, 0xF89C, 0xF114);
1245         MP_WriteMcuAccessRegWord(sc, 0xF89E, 0xC31B);
1246         MP_WriteMcuAccessRegWord(sc, 0xF8A0, 0x6460);
1247         MP_WriteMcuAccessRegWord(sc, 0xF8A2, 0x14FA);
1248         MP_WriteMcuAccessRegWord(sc, 0xF8A4, 0xFA02);
1249         MP_WriteMcuAccessRegWord(sc, 0xF8A6, 0xE00F);
1250         MP_WriteMcuAccessRegWord(sc, 0xF8A8, 0xC317);
1251         MP_WriteMcuAccessRegWord(sc, 0xF8AA, 0x7460);
1252         MP_WriteMcuAccessRegWord(sc, 0xF8AC, 0x49C0);
1253         MP_WriteMcuAccessRegWord(sc, 0xF8AE, 0xF10B);
1254         MP_WriteMcuAccessRegWord(sc, 0xF8B0, 0xC311);
1255         MP_WriteMcuAccessRegWord(sc, 0xF8B2, 0x7462);
1256         MP_WriteMcuAccessRegWord(sc, 0xF8B4, 0x48C1);
1257         MP_WriteMcuAccessRegWord(sc, 0xF8B6, 0x9C62);
1258         MP_WriteMcuAccessRegWord(sc, 0xF8B8, 0x4841);
1259         MP_WriteMcuAccessRegWord(sc, 0xF8BA, 0x9C62);
1260         MP_WriteMcuAccessRegWord(sc, 0xF8BC, 0xC30A);
1261         MP_WriteMcuAccessRegWord(sc, 0xF8BE, 0x1C04);
1262         MP_WriteMcuAccessRegWord(sc, 0xF8C0, 0x8C60);
1263         MP_WriteMcuAccessRegWord(sc, 0xF8C2, 0xE004);
1264         MP_WriteMcuAccessRegWord(sc, 0xF8C4, 0x1C15);
1265         MP_WriteMcuAccessRegWord(sc, 0xF8C6, 0xC305);
1266         MP_WriteMcuAccessRegWord(sc, 0xF8C8, 0x8C60);
1267         MP_WriteMcuAccessRegWord(sc, 0xF8CA, 0xC602);
1268         MP_WriteMcuAccessRegWord(sc, 0xF8CC, 0xBE00);
1269         MP_WriteMcuAccessRegWord(sc, 0xF8CE, 0x0374);
1270         MP_WriteMcuAccessRegWord(sc, 0xF8D0, 0xE434);
1271         MP_WriteMcuAccessRegWord(sc, 0xF8D2, 0xE030);
1272         MP_WriteMcuAccessRegWord(sc, 0xF8D4, 0xE61C);
1273         MP_WriteMcuAccessRegWord(sc, 0xF8D6, 0xE906);
1274         MP_WriteMcuAccessRegWord(sc, 0xF8D8, 0xC602);
1275         MP_WriteMcuAccessRegWord(sc, 0xF8DA, 0xBE00);
1276         MP_WriteMcuAccessRegWord(sc, 0xF8DC, 0x0000);
1277
1278         MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000);
1279
1280         MP_WriteMcuAccessRegWord(sc, 0xFC28, 0x0493);
1281         MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x0205);
1282         MP_WriteMcuAccessRegWord(sc, 0xFC2C, 0x0589);
1283         MP_WriteMcuAccessRegWord(sc, 0xFC2E, 0x0647);
1284         MP_WriteMcuAccessRegWord(sc, 0xFC30, 0x0000);
1285         MP_WriteMcuAccessRegWord(sc, 0xFC32, 0x0215);
1286         MP_WriteMcuAccessRegWord(sc, 0xFC34, 0x0285);
1287 }
1288
1289 static void re_set_mac_mcu_8168gu_2(struct re_softc *sc)
1290 {
1291         DisableMcuBPs(sc);
1292
1293         MP_WriteMcuAccessRegWord(sc, 0xF800, 0xE008);
1294         MP_WriteMcuAccessRegWord(sc, 0xF802, 0xE00A);
1295         MP_WriteMcuAccessRegWord(sc, 0xF804, 0xE00D);
1296         MP_WriteMcuAccessRegWord(sc, 0xF806, 0xE02F);
1297         MP_WriteMcuAccessRegWord(sc, 0xF808, 0xE031);
1298         MP_WriteMcuAccessRegWord(sc, 0xF80A, 0xE038);
1299         MP_WriteMcuAccessRegWord(sc, 0xF80C, 0xE03A);
1300         MP_WriteMcuAccessRegWord(sc, 0xF80E, 0xE051);
1301         MP_WriteMcuAccessRegWord(sc, 0xF810, 0xC202);
1302         MP_WriteMcuAccessRegWord(sc, 0xF812, 0xBA00);
1303         MP_WriteMcuAccessRegWord(sc, 0xF814, 0x0DFC);
1304         MP_WriteMcuAccessRegWord(sc, 0xF816, 0x7444);
1305         MP_WriteMcuAccessRegWord(sc, 0xF818, 0xC502);
1306         MP_WriteMcuAccessRegWord(sc, 0xF81A, 0xBD00);
1307         MP_WriteMcuAccessRegWord(sc, 0xF81C, 0x0A30);
1308         MP_WriteMcuAccessRegWord(sc, 0xF81E, 0x49D9);
1309         MP_WriteMcuAccessRegWord(sc, 0xF820, 0xF019);
1310         MP_WriteMcuAccessRegWord(sc, 0xF822, 0xC520);
1311         MP_WriteMcuAccessRegWord(sc, 0xF824, 0x64A5);
1312         MP_WriteMcuAccessRegWord(sc, 0xF826, 0x1400);
1313         MP_WriteMcuAccessRegWord(sc, 0xF828, 0xF007);
1314         MP_WriteMcuAccessRegWord(sc, 0xF82A, 0x0C01);
1315         MP_WriteMcuAccessRegWord(sc, 0xF82C, 0x8CA5);
1316         MP_WriteMcuAccessRegWord(sc, 0xF82E, 0x1C15);
1317         MP_WriteMcuAccessRegWord(sc, 0xF830, 0xC515);
1318         MP_WriteMcuAccessRegWord(sc, 0xF832, 0x9CA0);
1319         MP_WriteMcuAccessRegWord(sc, 0xF834, 0xE00F);
1320         MP_WriteMcuAccessRegWord(sc, 0xF836, 0xC513);
1321         MP_WriteMcuAccessRegWord(sc, 0xF838, 0x74A0);
1322         MP_WriteMcuAccessRegWord(sc, 0xF83A, 0x48C8);
1323         MP_WriteMcuAccessRegWord(sc, 0xF83C, 0x48CA);
1324         MP_WriteMcuAccessRegWord(sc, 0xF83E, 0x9CA0);
1325         MP_WriteMcuAccessRegWord(sc, 0xF840, 0xC510);
1326         MP_WriteMcuAccessRegWord(sc, 0xF842, 0x1B00);
1327         MP_WriteMcuAccessRegWord(sc, 0xF844, 0x9BA0);
1328         MP_WriteMcuAccessRegWord(sc, 0xF846, 0x1B1C);
1329         MP_WriteMcuAccessRegWord(sc, 0xF848, 0x483F);
1330         MP_WriteMcuAccessRegWord(sc, 0xF84A, 0x9BA2);
1331         MP_WriteMcuAccessRegWord(sc, 0xF84C, 0x1B04);
1332         MP_WriteMcuAccessRegWord(sc, 0xF84E, 0xC506);
1333         MP_WriteMcuAccessRegWord(sc, 0xF850, 0x9BA0);
1334         MP_WriteMcuAccessRegWord(sc, 0xF852, 0xC603);
1335         MP_WriteMcuAccessRegWord(sc, 0xF854, 0xBE00);
1336         MP_WriteMcuAccessRegWord(sc, 0xF856, 0x0298);
1337         MP_WriteMcuAccessRegWord(sc, 0xF858, 0x03DE);
1338         MP_WriteMcuAccessRegWord(sc, 0xF85A, 0xE434);
1339         MP_WriteMcuAccessRegWord(sc, 0xF85C, 0xE096);
1340         MP_WriteMcuAccessRegWord(sc, 0xF85E, 0xE860);
1341         MP_WriteMcuAccessRegWord(sc, 0xF860, 0xDE20);
1342         MP_WriteMcuAccessRegWord(sc, 0xF862, 0xD3C0);
1343         MP_WriteMcuAccessRegWord(sc, 0xF864, 0xC602);
1344         MP_WriteMcuAccessRegWord(sc, 0xF866, 0xBE00);
1345         MP_WriteMcuAccessRegWord(sc, 0xF868, 0x0A64);
1346         MP_WriteMcuAccessRegWord(sc, 0xF86A, 0xC707);
1347         MP_WriteMcuAccessRegWord(sc, 0xF86C, 0x1D00);
1348         MP_WriteMcuAccessRegWord(sc, 0xF86E, 0x8DE2);
1349         MP_WriteMcuAccessRegWord(sc, 0xF870, 0x48C1);
1350         MP_WriteMcuAccessRegWord(sc, 0xF872, 0xC502);
1351         MP_WriteMcuAccessRegWord(sc, 0xF874, 0xBD00);
1352         MP_WriteMcuAccessRegWord(sc, 0xF876, 0x00AA);
1353         MP_WriteMcuAccessRegWord(sc, 0xF878, 0xE0C0);
1354         MP_WriteMcuAccessRegWord(sc, 0xF87A, 0xC502);
1355         MP_WriteMcuAccessRegWord(sc, 0xF87C, 0xBD00);
1356         MP_WriteMcuAccessRegWord(sc, 0xF87E, 0x0132);
1357         MP_WriteMcuAccessRegWord(sc, 0xF880, 0xC50C);
1358         MP_WriteMcuAccessRegWord(sc, 0xF882, 0x74A2);
1359         MP_WriteMcuAccessRegWord(sc, 0xF884, 0x49CE);
1360         MP_WriteMcuAccessRegWord(sc, 0xF886, 0xF1FE);
1361         MP_WriteMcuAccessRegWord(sc, 0xF888, 0x1C00);
1362         MP_WriteMcuAccessRegWord(sc, 0xF88A, 0x9EA0);
1363         MP_WriteMcuAccessRegWord(sc, 0xF88C, 0x1C1C);
1364         MP_WriteMcuAccessRegWord(sc, 0xF88E, 0x484F);
1365         MP_WriteMcuAccessRegWord(sc, 0xF890, 0x9CA2);
1366         MP_WriteMcuAccessRegWord(sc, 0xF892, 0xC402);
1367         MP_WriteMcuAccessRegWord(sc, 0xF894, 0xBC00);
1368         MP_WriteMcuAccessRegWord(sc, 0xF896, 0x0AFA);
1369         MP_WriteMcuAccessRegWord(sc, 0xF898, 0xDE20);
1370         MP_WriteMcuAccessRegWord(sc, 0xF89A, 0xE000);
1371         MP_WriteMcuAccessRegWord(sc, 0xF89C, 0xE092);
1372         MP_WriteMcuAccessRegWord(sc, 0xF89E, 0xE430);
1373         MP_WriteMcuAccessRegWord(sc, 0xF8A0, 0xDE20);
1374         MP_WriteMcuAccessRegWord(sc, 0xF8A2, 0xE0C0);
1375         MP_WriteMcuAccessRegWord(sc, 0xF8A4, 0xE860);
1376         MP_WriteMcuAccessRegWord(sc, 0xF8A6, 0xE84C);
1377         MP_WriteMcuAccessRegWord(sc, 0xF8A8, 0xB400);
1378         MP_WriteMcuAccessRegWord(sc, 0xF8AA, 0xB430);
1379         MP_WriteMcuAccessRegWord(sc, 0xF8AC, 0xE410);
1380         MP_WriteMcuAccessRegWord(sc, 0xF8AE, 0xC0AE);
1381         MP_WriteMcuAccessRegWord(sc, 0xF8B0, 0xB407);
1382         MP_WriteMcuAccessRegWord(sc, 0xF8B2, 0xB406);
1383         MP_WriteMcuAccessRegWord(sc, 0xF8B4, 0xB405);
1384         MP_WriteMcuAccessRegWord(sc, 0xF8B6, 0xB404);
1385         MP_WriteMcuAccessRegWord(sc, 0xF8B8, 0xB403);
1386         MP_WriteMcuAccessRegWord(sc, 0xF8BA, 0xB402);
1387         MP_WriteMcuAccessRegWord(sc, 0xF8BC, 0xB401);
1388         MP_WriteMcuAccessRegWord(sc, 0xF8BE, 0xC7EE);
1389         MP_WriteMcuAccessRegWord(sc, 0xF8C0, 0x76F4);
1390         MP_WriteMcuAccessRegWord(sc, 0xF8C2, 0xC2ED);
1391         MP_WriteMcuAccessRegWord(sc, 0xF8C4, 0xC3ED);
1392         MP_WriteMcuAccessRegWord(sc, 0xF8C6, 0xC1EF);
1393         MP_WriteMcuAccessRegWord(sc, 0xF8C8, 0xC5F3);
1394         MP_WriteMcuAccessRegWord(sc, 0xF8CA, 0x74A0);
1395         MP_WriteMcuAccessRegWord(sc, 0xF8CC, 0x49CD);
1396         MP_WriteMcuAccessRegWord(sc, 0xF8CE, 0xF001);
1397         MP_WriteMcuAccessRegWord(sc, 0xF8D0, 0xC5EE);
1398         MP_WriteMcuAccessRegWord(sc, 0xF8D2, 0x74A0);
1399         MP_WriteMcuAccessRegWord(sc, 0xF8D4, 0x49C1);
1400         MP_WriteMcuAccessRegWord(sc, 0xF8D6, 0xF105);
1401         MP_WriteMcuAccessRegWord(sc, 0xF8D8, 0xC5E4);
1402         MP_WriteMcuAccessRegWord(sc, 0xF8DA, 0x74A2);
1403         MP_WriteMcuAccessRegWord(sc, 0xF8DC, 0x49CE);
1404         MP_WriteMcuAccessRegWord(sc, 0xF8DE, 0xF00B);
1405         MP_WriteMcuAccessRegWord(sc, 0xF8E0, 0x7444);
1406         MP_WriteMcuAccessRegWord(sc, 0xF8E2, 0x484B);
1407         MP_WriteMcuAccessRegWord(sc, 0xF8E4, 0x9C44);
1408         MP_WriteMcuAccessRegWord(sc, 0xF8E6, 0x1C10);
1409         MP_WriteMcuAccessRegWord(sc, 0xF8E8, 0x9C62);
1410         MP_WriteMcuAccessRegWord(sc, 0xF8EA, 0x1C11);
1411         MP_WriteMcuAccessRegWord(sc, 0xF8EC, 0x8C60);
1412         MP_WriteMcuAccessRegWord(sc, 0xF8EE, 0x1C00);
1413         MP_WriteMcuAccessRegWord(sc, 0xF8F0, 0x9CF6);
1414         MP_WriteMcuAccessRegWord(sc, 0xF8F2, 0xE0EC);
1415         MP_WriteMcuAccessRegWord(sc, 0xF8F4, 0x49E7);
1416         MP_WriteMcuAccessRegWord(sc, 0xF8F6, 0xF016);
1417         MP_WriteMcuAccessRegWord(sc, 0xF8F8, 0x1D80);
1418         MP_WriteMcuAccessRegWord(sc, 0xF8FA, 0x8DF4);
1419         MP_WriteMcuAccessRegWord(sc, 0xF8FC, 0x74F8);
1420         MP_WriteMcuAccessRegWord(sc, 0xF8FE, 0x4843);
1421         MP_WriteMcuAccessRegWord(sc, 0xF900, 0x8CF8);
1422         MP_WriteMcuAccessRegWord(sc, 0xF902, 0x74F8);
1423         MP_WriteMcuAccessRegWord(sc, 0xF904, 0x74F8);
1424         MP_WriteMcuAccessRegWord(sc, 0xF906, 0x7444);
1425         MP_WriteMcuAccessRegWord(sc, 0xF908, 0x48C8);
1426         MP_WriteMcuAccessRegWord(sc, 0xF90A, 0x48C9);
1427         MP_WriteMcuAccessRegWord(sc, 0xF90C, 0x48CA);
1428         MP_WriteMcuAccessRegWord(sc, 0xF90E, 0x9C44);
1429         MP_WriteMcuAccessRegWord(sc, 0xF910, 0x74F8);
1430         MP_WriteMcuAccessRegWord(sc, 0xF912, 0x4844);
1431         MP_WriteMcuAccessRegWord(sc, 0xF914, 0x8CF8);
1432         MP_WriteMcuAccessRegWord(sc, 0xF916, 0x1E01);
1433         MP_WriteMcuAccessRegWord(sc, 0xF918, 0xE8DB);
1434         MP_WriteMcuAccessRegWord(sc, 0xF91A, 0x7420);
1435         MP_WriteMcuAccessRegWord(sc, 0xF91C, 0x48C1);
1436         MP_WriteMcuAccessRegWord(sc, 0xF91E, 0x9C20);
1437         MP_WriteMcuAccessRegWord(sc, 0xF920, 0xE0D5);
1438         MP_WriteMcuAccessRegWord(sc, 0xF922, 0x49E6);
1439         MP_WriteMcuAccessRegWord(sc, 0xF924, 0xF02A);
1440         MP_WriteMcuAccessRegWord(sc, 0xF926, 0x1D40);
1441         MP_WriteMcuAccessRegWord(sc, 0xF928, 0x8DF4);
1442         MP_WriteMcuAccessRegWord(sc, 0xF92A, 0x74FC);
1443         MP_WriteMcuAccessRegWord(sc, 0xF92C, 0x49C0);
1444         MP_WriteMcuAccessRegWord(sc, 0xF92E, 0xF124);
1445         MP_WriteMcuAccessRegWord(sc, 0xF930, 0x49C1);
1446         MP_WriteMcuAccessRegWord(sc, 0xF932, 0xF122);
1447         MP_WriteMcuAccessRegWord(sc, 0xF934, 0x74F8);
1448         MP_WriteMcuAccessRegWord(sc, 0xF936, 0x49C0);
1449         MP_WriteMcuAccessRegWord(sc, 0xF938, 0xF01F);
1450         MP_WriteMcuAccessRegWord(sc, 0xF93A, 0xE8D3);
1451         MP_WriteMcuAccessRegWord(sc, 0xF93C, 0x48C4);
1452         MP_WriteMcuAccessRegWord(sc, 0xF93E, 0x8CF8);
1453         MP_WriteMcuAccessRegWord(sc, 0xF940, 0x1E00);
1454         MP_WriteMcuAccessRegWord(sc, 0xF942, 0xE8C6);
1455         MP_WriteMcuAccessRegWord(sc, 0xF944, 0xC5B1);
1456         MP_WriteMcuAccessRegWord(sc, 0xF946, 0x74A0);
1457         MP_WriteMcuAccessRegWord(sc, 0xF948, 0x49C3);
1458         MP_WriteMcuAccessRegWord(sc, 0xF94A, 0xF016);
1459         MP_WriteMcuAccessRegWord(sc, 0xF94C, 0xC5AF);
1460         MP_WriteMcuAccessRegWord(sc, 0xF94E, 0x74A4);
1461         MP_WriteMcuAccessRegWord(sc, 0xF950, 0x49C2);
1462         MP_WriteMcuAccessRegWord(sc, 0xF952, 0xF005);
1463         MP_WriteMcuAccessRegWord(sc, 0xF954, 0xC5AA);
1464         MP_WriteMcuAccessRegWord(sc, 0xF956, 0x74B2);
1465         MP_WriteMcuAccessRegWord(sc, 0xF958, 0x49C9);
1466         MP_WriteMcuAccessRegWord(sc, 0xF95A, 0xF10E);
1467         MP_WriteMcuAccessRegWord(sc, 0xF95C, 0xC5A6);
1468         MP_WriteMcuAccessRegWord(sc, 0xF95E, 0x74A8);
1469         MP_WriteMcuAccessRegWord(sc, 0xF960, 0x4845);
1470         MP_WriteMcuAccessRegWord(sc, 0xF962, 0x4846);
1471         MP_WriteMcuAccessRegWord(sc, 0xF964, 0x4847);
1472         MP_WriteMcuAccessRegWord(sc, 0xF966, 0x4848);
1473         MP_WriteMcuAccessRegWord(sc, 0xF968, 0x9CA8);
1474         MP_WriteMcuAccessRegWord(sc, 0xF96A, 0x74B2);
1475         MP_WriteMcuAccessRegWord(sc, 0xF96C, 0x4849);
1476         MP_WriteMcuAccessRegWord(sc, 0xF96E, 0x9CB2);
1477         MP_WriteMcuAccessRegWord(sc, 0xF970, 0x74A0);
1478         MP_WriteMcuAccessRegWord(sc, 0xF972, 0x484F);
1479         MP_WriteMcuAccessRegWord(sc, 0xF974, 0x9CA0);
1480         MP_WriteMcuAccessRegWord(sc, 0xF976, 0xE0AA);
1481         MP_WriteMcuAccessRegWord(sc, 0xF978, 0x49E4);
1482         MP_WriteMcuAccessRegWord(sc, 0xF97A, 0xF018);
1483         MP_WriteMcuAccessRegWord(sc, 0xF97C, 0x1D10);
1484         MP_WriteMcuAccessRegWord(sc, 0xF97E, 0x8DF4);
1485         MP_WriteMcuAccessRegWord(sc, 0xF980, 0x74F8);
1486         MP_WriteMcuAccessRegWord(sc, 0xF982, 0x74F8);
1487         MP_WriteMcuAccessRegWord(sc, 0xF984, 0x74F8);
1488         MP_WriteMcuAccessRegWord(sc, 0xF986, 0x4843);
1489         MP_WriteMcuAccessRegWord(sc, 0xF988, 0x8CF8);
1490         MP_WriteMcuAccessRegWord(sc, 0xF98A, 0x74F8);
1491         MP_WriteMcuAccessRegWord(sc, 0xF98C, 0x74F8);
1492         MP_WriteMcuAccessRegWord(sc, 0xF98E, 0x74F8);
1493         MP_WriteMcuAccessRegWord(sc, 0xF990, 0x4844);
1494         MP_WriteMcuAccessRegWord(sc, 0xF992, 0x4842);
1495         MP_WriteMcuAccessRegWord(sc, 0xF994, 0x4841);
1496         MP_WriteMcuAccessRegWord(sc, 0xF996, 0x8CF8);
1497         MP_WriteMcuAccessRegWord(sc, 0xF998, 0x1E01);
1498         MP_WriteMcuAccessRegWord(sc, 0xF99A, 0xE89A);
1499         MP_WriteMcuAccessRegWord(sc, 0xF99C, 0x7420);
1500         MP_WriteMcuAccessRegWord(sc, 0xF99E, 0x4841);
1501         MP_WriteMcuAccessRegWord(sc, 0xF9A0, 0x9C20);
1502         MP_WriteMcuAccessRegWord(sc, 0xF9A2, 0x7444);
1503         MP_WriteMcuAccessRegWord(sc, 0xF9A4, 0x4848);
1504         MP_WriteMcuAccessRegWord(sc, 0xF9A6, 0x9C44);
1505         MP_WriteMcuAccessRegWord(sc, 0xF9A8, 0xE091);
1506         MP_WriteMcuAccessRegWord(sc, 0xF9AA, 0x49E5);
1507         MP_WriteMcuAccessRegWord(sc, 0xF9AC, 0xF03E);
1508         MP_WriteMcuAccessRegWord(sc, 0xF9AE, 0x1D20);
1509         MP_WriteMcuAccessRegWord(sc, 0xF9B0, 0x8DF4);
1510         MP_WriteMcuAccessRegWord(sc, 0xF9B2, 0x74F8);
1511         MP_WriteMcuAccessRegWord(sc, 0xF9B4, 0x48C2);
1512         MP_WriteMcuAccessRegWord(sc, 0xF9B6, 0x4841);
1513         MP_WriteMcuAccessRegWord(sc, 0xF9B8, 0x8CF8);
1514         MP_WriteMcuAccessRegWord(sc, 0xF9BA, 0x1E01);
1515         MP_WriteMcuAccessRegWord(sc, 0xF9BC, 0x7444);
1516         MP_WriteMcuAccessRegWord(sc, 0xF9BE, 0x49CA);
1517         MP_WriteMcuAccessRegWord(sc, 0xF9C0, 0xF103);
1518         MP_WriteMcuAccessRegWord(sc, 0xF9C2, 0x49C2);
1519         MP_WriteMcuAccessRegWord(sc, 0xF9C4, 0xF00C);
1520         MP_WriteMcuAccessRegWord(sc, 0xF9C6, 0x49C1);
1521         MP_WriteMcuAccessRegWord(sc, 0xF9C8, 0xF004);
1522         MP_WriteMcuAccessRegWord(sc, 0xF9CA, 0x6447);
1523         MP_WriteMcuAccessRegWord(sc, 0xF9CC, 0x2244);
1524         MP_WriteMcuAccessRegWord(sc, 0xF9CE, 0xE002);
1525         MP_WriteMcuAccessRegWord(sc, 0xF9D0, 0x1C01);
1526         MP_WriteMcuAccessRegWord(sc, 0xF9D2, 0x9C62);
1527         MP_WriteMcuAccessRegWord(sc, 0xF9D4, 0x1C11);
1528         MP_WriteMcuAccessRegWord(sc, 0xF9D6, 0x8C60);
1529         MP_WriteMcuAccessRegWord(sc, 0xF9D8, 0x1C00);
1530         MP_WriteMcuAccessRegWord(sc, 0xF9DA, 0x9CF6);
1531         MP_WriteMcuAccessRegWord(sc, 0xF9DC, 0x7444);
1532         MP_WriteMcuAccessRegWord(sc, 0xF9DE, 0x49C8);
1533         MP_WriteMcuAccessRegWord(sc, 0xF9E0, 0xF01D);
1534         MP_WriteMcuAccessRegWord(sc, 0xF9E2, 0x74FC);
1535         MP_WriteMcuAccessRegWord(sc, 0xF9E4, 0x49C0);
1536         MP_WriteMcuAccessRegWord(sc, 0xF9E6, 0xF11A);
1537         MP_WriteMcuAccessRegWord(sc, 0xF9E8, 0x49C1);
1538         MP_WriteMcuAccessRegWord(sc, 0xF9EA, 0xF118);
1539         MP_WriteMcuAccessRegWord(sc, 0xF9EC, 0x74F8);
1540         MP_WriteMcuAccessRegWord(sc, 0xF9EE, 0x49C0);
1541         MP_WriteMcuAccessRegWord(sc, 0xF9F0, 0xF015);
1542         MP_WriteMcuAccessRegWord(sc, 0xF9F2, 0x49C6);
1543         MP_WriteMcuAccessRegWord(sc, 0xF9F4, 0xF113);
1544         MP_WriteMcuAccessRegWord(sc, 0xF9F6, 0xE875);
1545         MP_WriteMcuAccessRegWord(sc, 0xF9F8, 0x48C4);
1546         MP_WriteMcuAccessRegWord(sc, 0xF9FA, 0x8CF8);
1547         MP_WriteMcuAccessRegWord(sc, 0xF9FC, 0x7420);
1548         MP_WriteMcuAccessRegWord(sc, 0xF9FE, 0x48C1);
1549         MP_WriteMcuAccessRegWord(sc, 0xFA00, 0x9C20);
1550         MP_WriteMcuAccessRegWord(sc, 0xFA02, 0xC50A);
1551         MP_WriteMcuAccessRegWord(sc, 0xFA04, 0x74A2);
1552         MP_WriteMcuAccessRegWord(sc, 0xFA06, 0x8CA5);
1553         MP_WriteMcuAccessRegWord(sc, 0xFA08, 0x74A0);
1554         MP_WriteMcuAccessRegWord(sc, 0xFA0A, 0xC505);
1555         MP_WriteMcuAccessRegWord(sc, 0xFA0C, 0x9CA2);
1556         MP_WriteMcuAccessRegWord(sc, 0xFA0E, 0x1C11);
1557         MP_WriteMcuAccessRegWord(sc, 0xFA10, 0x9CA0);
1558         MP_WriteMcuAccessRegWord(sc, 0xFA12, 0xE00A);
1559         MP_WriteMcuAccessRegWord(sc, 0xFA14, 0xE434);
1560         MP_WriteMcuAccessRegWord(sc, 0xFA16, 0xD3C0);
1561         MP_WriteMcuAccessRegWord(sc, 0xFA18, 0xDC00);
1562         MP_WriteMcuAccessRegWord(sc, 0xFA1A, 0x7444);
1563         MP_WriteMcuAccessRegWord(sc, 0xFA1C, 0x49CA);
1564         MP_WriteMcuAccessRegWord(sc, 0xFA1E, 0xF004);
1565         MP_WriteMcuAccessRegWord(sc, 0xFA20, 0x48CA);
1566         MP_WriteMcuAccessRegWord(sc, 0xFA22, 0x9C44);
1567         MP_WriteMcuAccessRegWord(sc, 0xFA24, 0xE855);
1568         MP_WriteMcuAccessRegWord(sc, 0xFA26, 0xE052);
1569         MP_WriteMcuAccessRegWord(sc, 0xFA28, 0x49E8);
1570         MP_WriteMcuAccessRegWord(sc, 0xFA2A, 0xF024);
1571         MP_WriteMcuAccessRegWord(sc, 0xFA2C, 0x1D01);
1572         MP_WriteMcuAccessRegWord(sc, 0xFA2E, 0x8DF5);
1573         MP_WriteMcuAccessRegWord(sc, 0xFA30, 0x7440);
1574         MP_WriteMcuAccessRegWord(sc, 0xFA32, 0x49C0);
1575         MP_WriteMcuAccessRegWord(sc, 0xFA34, 0xF11E);
1576         MP_WriteMcuAccessRegWord(sc, 0xFA36, 0x7444);
1577         MP_WriteMcuAccessRegWord(sc, 0xFA38, 0x49C8);
1578         MP_WriteMcuAccessRegWord(sc, 0xFA3A, 0xF01B);
1579         MP_WriteMcuAccessRegWord(sc, 0xFA3C, 0x49CA);
1580         MP_WriteMcuAccessRegWord(sc, 0xFA3E, 0xF119);
1581         MP_WriteMcuAccessRegWord(sc, 0xFA40, 0xC5EC);
1582         MP_WriteMcuAccessRegWord(sc, 0xFA42, 0x76A4);
1583         MP_WriteMcuAccessRegWord(sc, 0xFA44, 0x49E3);
1584         MP_WriteMcuAccessRegWord(sc, 0xFA46, 0xF015);
1585         MP_WriteMcuAccessRegWord(sc, 0xFA48, 0x49C0);
1586         MP_WriteMcuAccessRegWord(sc, 0xFA4A, 0xF103);
1587         MP_WriteMcuAccessRegWord(sc, 0xFA4C, 0x49C1);
1588         MP_WriteMcuAccessRegWord(sc, 0xFA4E, 0xF011);
1589         MP_WriteMcuAccessRegWord(sc, 0xFA50, 0x4849);
1590         MP_WriteMcuAccessRegWord(sc, 0xFA52, 0x9C44);
1591         MP_WriteMcuAccessRegWord(sc, 0xFA54, 0x1C00);
1592         MP_WriteMcuAccessRegWord(sc, 0xFA56, 0x9CF6);
1593         MP_WriteMcuAccessRegWord(sc, 0xFA58, 0x7444);
1594         MP_WriteMcuAccessRegWord(sc, 0xFA5A, 0x49C1);
1595         MP_WriteMcuAccessRegWord(sc, 0xFA5C, 0xF004);
1596         MP_WriteMcuAccessRegWord(sc, 0xFA5E, 0x6446);
1597         MP_WriteMcuAccessRegWord(sc, 0xFA60, 0x1E07);
1598         MP_WriteMcuAccessRegWord(sc, 0xFA62, 0xE003);
1599         MP_WriteMcuAccessRegWord(sc, 0xFA64, 0x1C01);
1600         MP_WriteMcuAccessRegWord(sc, 0xFA66, 0x1E03);
1601         MP_WriteMcuAccessRegWord(sc, 0xFA68, 0x9C62);
1602         MP_WriteMcuAccessRegWord(sc, 0xFA6A, 0x1C11);
1603         MP_WriteMcuAccessRegWord(sc, 0xFA6C, 0x8C60);
1604         MP_WriteMcuAccessRegWord(sc, 0xFA6E, 0xE830);
1605         MP_WriteMcuAccessRegWord(sc, 0xFA70, 0xE02D);
1606         MP_WriteMcuAccessRegWord(sc, 0xFA72, 0x49E9);
1607         MP_WriteMcuAccessRegWord(sc, 0xFA74, 0xF004);
1608         MP_WriteMcuAccessRegWord(sc, 0xFA76, 0x1D02);
1609         MP_WriteMcuAccessRegWord(sc, 0xFA78, 0x8DF5);
1610         MP_WriteMcuAccessRegWord(sc, 0xFA7A, 0xE79C);
1611         MP_WriteMcuAccessRegWord(sc, 0xFA7C, 0x49E3);
1612         MP_WriteMcuAccessRegWord(sc, 0xFA7E, 0xF006);
1613         MP_WriteMcuAccessRegWord(sc, 0xFA80, 0x1D08);
1614         MP_WriteMcuAccessRegWord(sc, 0xFA82, 0x8DF4);
1615         MP_WriteMcuAccessRegWord(sc, 0xFA84, 0x74F8);
1616         MP_WriteMcuAccessRegWord(sc, 0xFA86, 0x74F8);
1617         MP_WriteMcuAccessRegWord(sc, 0xFA88, 0xE73A);
1618         MP_WriteMcuAccessRegWord(sc, 0xFA8A, 0x49E1);
1619         MP_WriteMcuAccessRegWord(sc, 0xFA8C, 0xF007);
1620         MP_WriteMcuAccessRegWord(sc, 0xFA8E, 0x1D02);
1621         MP_WriteMcuAccessRegWord(sc, 0xFA90, 0x8DF4);
1622         MP_WriteMcuAccessRegWord(sc, 0xFA92, 0x1E01);
1623         MP_WriteMcuAccessRegWord(sc, 0xFA94, 0xE7A7);
1624         MP_WriteMcuAccessRegWord(sc, 0xFA96, 0xDE20);
1625         MP_WriteMcuAccessRegWord(sc, 0xFA98, 0xE410);
1626         MP_WriteMcuAccessRegWord(sc, 0xFA9A, 0x49E0);
1627         MP_WriteMcuAccessRegWord(sc, 0xFA9C, 0xF017);
1628         MP_WriteMcuAccessRegWord(sc, 0xFA9E, 0x1D01);
1629         MP_WriteMcuAccessRegWord(sc, 0xFAA0, 0x8DF4);
1630         MP_WriteMcuAccessRegWord(sc, 0xFAA2, 0xC5FA);
1631         MP_WriteMcuAccessRegWord(sc, 0xFAA4, 0x1C00);
1632         MP_WriteMcuAccessRegWord(sc, 0xFAA6, 0x8CA0);
1633         MP_WriteMcuAccessRegWord(sc, 0xFAA8, 0x1C1B);
1634         MP_WriteMcuAccessRegWord(sc, 0xFAAA, 0x9CA2);
1635         MP_WriteMcuAccessRegWord(sc, 0xFAAC, 0x74A2);
1636         MP_WriteMcuAccessRegWord(sc, 0xFAAE, 0x49CF);
1637         MP_WriteMcuAccessRegWord(sc, 0xFAB0, 0xF0FE);
1638         MP_WriteMcuAccessRegWord(sc, 0xFAB2, 0xC5F3);
1639         MP_WriteMcuAccessRegWord(sc, 0xFAB4, 0x74A0);
1640         MP_WriteMcuAccessRegWord(sc, 0xFAB6, 0x4849);
1641         MP_WriteMcuAccessRegWord(sc, 0xFAB8, 0x9CA0);
1642         MP_WriteMcuAccessRegWord(sc, 0xFABA, 0x74F8);
1643         MP_WriteMcuAccessRegWord(sc, 0xFABC, 0x49C0);
1644         MP_WriteMcuAccessRegWord(sc, 0xFABE, 0xF006);
1645         MP_WriteMcuAccessRegWord(sc, 0xFAC0, 0x48C3);
1646         MP_WriteMcuAccessRegWord(sc, 0xFAC2, 0x8CF8);
1647         MP_WriteMcuAccessRegWord(sc, 0xFAC4, 0xE820);
1648         MP_WriteMcuAccessRegWord(sc, 0xFAC6, 0x74F8);
1649         MP_WriteMcuAccessRegWord(sc, 0xFAC8, 0x74F8);
1650         MP_WriteMcuAccessRegWord(sc, 0xFACA, 0xC432);
1651         MP_WriteMcuAccessRegWord(sc, 0xFACC, 0xBC00);
1652         MP_WriteMcuAccessRegWord(sc, 0xFACE, 0xC5E4);
1653         MP_WriteMcuAccessRegWord(sc, 0xFAD0, 0x74A2);
1654         MP_WriteMcuAccessRegWord(sc, 0xFAD2, 0x49CE);
1655         MP_WriteMcuAccessRegWord(sc, 0xFAD4, 0xF1FE);
1656         MP_WriteMcuAccessRegWord(sc, 0xFAD6, 0x9EA0);
1657         MP_WriteMcuAccessRegWord(sc, 0xFAD8, 0x1C1C);
1658         MP_WriteMcuAccessRegWord(sc, 0xFADA, 0x484F);
1659         MP_WriteMcuAccessRegWord(sc, 0xFADC, 0x9CA2);
1660         MP_WriteMcuAccessRegWord(sc, 0xFADE, 0xFF80);
1661         MP_WriteMcuAccessRegWord(sc, 0xFAE0, 0xB404);
1662         MP_WriteMcuAccessRegWord(sc, 0xFAE2, 0xB405);
1663         MP_WriteMcuAccessRegWord(sc, 0xFAE4, 0xC5D9);
1664         MP_WriteMcuAccessRegWord(sc, 0xFAE6, 0x74A2);
1665         MP_WriteMcuAccessRegWord(sc, 0xFAE8, 0x49CE);
1666         MP_WriteMcuAccessRegWord(sc, 0xFAEA, 0xF1FE);
1667         MP_WriteMcuAccessRegWord(sc, 0xFAEC, 0xC41F);
1668         MP_WriteMcuAccessRegWord(sc, 0xFAEE, 0x9CA0);
1669         MP_WriteMcuAccessRegWord(sc, 0xFAF0, 0xC41C);
1670         MP_WriteMcuAccessRegWord(sc, 0xFAF2, 0x1C13);
1671         MP_WriteMcuAccessRegWord(sc, 0xFAF4, 0x484F);
1672         MP_WriteMcuAccessRegWord(sc, 0xFAF6, 0x9CA2);
1673         MP_WriteMcuAccessRegWord(sc, 0xFAF8, 0x74A2);
1674         MP_WriteMcuAccessRegWord(sc, 0xFAFA, 0x49CF);
1675         MP_WriteMcuAccessRegWord(sc, 0xFAFC, 0xF1FE);
1676         MP_WriteMcuAccessRegWord(sc, 0xFAFE, 0xB005);
1677         MP_WriteMcuAccessRegWord(sc, 0xFB00, 0xB004);
1678         MP_WriteMcuAccessRegWord(sc, 0xFB02, 0xFF80);
1679         MP_WriteMcuAccessRegWord(sc, 0xFB04, 0xB404);
1680         MP_WriteMcuAccessRegWord(sc, 0xFB06, 0xB405);
1681         MP_WriteMcuAccessRegWord(sc, 0xFB08, 0xC5C7);
1682         MP_WriteMcuAccessRegWord(sc, 0xFB0A, 0x74A2);
1683         MP_WriteMcuAccessRegWord(sc, 0xFB0C, 0x49CE);
1684         MP_WriteMcuAccessRegWord(sc, 0xFB0E, 0xF1FE);
1685         MP_WriteMcuAccessRegWord(sc, 0xFB10, 0xC40E);
1686         MP_WriteMcuAccessRegWord(sc, 0xFB12, 0x9CA0);
1687         MP_WriteMcuAccessRegWord(sc, 0xFB14, 0xC40A);
1688         MP_WriteMcuAccessRegWord(sc, 0xFB16, 0x1C13);
1689         MP_WriteMcuAccessRegWord(sc, 0xFB18, 0x484F);
1690         MP_WriteMcuAccessRegWord(sc, 0xFB1A, 0x9CA2);
1691         MP_WriteMcuAccessRegWord(sc, 0xFB1C, 0x74A2);
1692         MP_WriteMcuAccessRegWord(sc, 0xFB1E, 0x49CF);
1693         MP_WriteMcuAccessRegWord(sc, 0xFB20, 0xF1FE);
1694         MP_WriteMcuAccessRegWord(sc, 0xFB22, 0xB005);
1695         MP_WriteMcuAccessRegWord(sc, 0xFB24, 0xB004);
1696         MP_WriteMcuAccessRegWord(sc, 0xFB26, 0xFF80);
1697         MP_WriteMcuAccessRegWord(sc, 0xFB28, 0x0000);
1698         MP_WriteMcuAccessRegWord(sc, 0xFB2A, 0x0481);
1699         MP_WriteMcuAccessRegWord(sc, 0xFB2C, 0x0C81);
1700         MP_WriteMcuAccessRegWord(sc, 0xFB2E, 0x0AE0);
1701
1702         MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000);
1703
1704         MP_WriteMcuAccessRegWord(sc, 0xFC28, 0x0000);
1705         MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x0000);
1706         MP_WriteMcuAccessRegWord(sc, 0xFC2C, 0x0297);
1707         MP_WriteMcuAccessRegWord(sc, 0xFC2E, 0x0000);
1708         MP_WriteMcuAccessRegWord(sc, 0xFC30, 0x00A9);
1709         MP_WriteMcuAccessRegWord(sc, 0xFC32, 0x012D);
1710         MP_WriteMcuAccessRegWord(sc, 0xFC34, 0x0000);
1711         MP_WriteMcuAccessRegWord(sc, 0xFC36, 0x08DF);
1712 }
1713
1714 static void re_set_mac_mcu_8411b_1(struct re_softc *sc)
1715 {
1716         DisableMcuBPs(sc);
1717
1718         MP_WriteMcuAccessRegWord(sc, 0xF800, 0xE008);
1719         MP_WriteMcuAccessRegWord(sc, 0xF802, 0xE00A);
1720         MP_WriteMcuAccessRegWord(sc, 0xF804, 0xE00C);
1721         MP_WriteMcuAccessRegWord(sc, 0xF806, 0xE00E);
1722         MP_WriteMcuAccessRegWord(sc, 0xF808, 0xE027);
1723         MP_WriteMcuAccessRegWord(sc, 0xF80A, 0xE04F);
1724         MP_WriteMcuAccessRegWord(sc, 0xF80C, 0xE05E);
1725         MP_WriteMcuAccessRegWord(sc, 0xF80E, 0xE065);
1726         MP_WriteMcuAccessRegWord(sc, 0xF810, 0xC602);
1727         MP_WriteMcuAccessRegWord(sc, 0xF812, 0xBE00);
1728         MP_WriteMcuAccessRegWord(sc, 0xF814, 0x0000);
1729         MP_WriteMcuAccessRegWord(sc, 0xF816, 0xC502);
1730         MP_WriteMcuAccessRegWord(sc, 0xF818, 0xBD00);
1731         MP_WriteMcuAccessRegWord(sc, 0xF81A, 0x074C);
1732         MP_WriteMcuAccessRegWord(sc, 0xF81C, 0xC302);
1733         MP_WriteMcuAccessRegWord(sc, 0xF81E, 0xBB00);
1734         MP_WriteMcuAccessRegWord(sc, 0xF820, 0x080A);
1735         MP_WriteMcuAccessRegWord(sc, 0xF822, 0x6420);
1736         MP_WriteMcuAccessRegWord(sc, 0xF824, 0x48C2);
1737         MP_WriteMcuAccessRegWord(sc, 0xF826, 0x8C20);
1738         MP_WriteMcuAccessRegWord(sc, 0xF828, 0xC516);
1739         MP_WriteMcuAccessRegWord(sc, 0xF82A, 0x64A4);
1740         MP_WriteMcuAccessRegWord(sc, 0xF82C, 0x49C0);
1741         MP_WriteMcuAccessRegWord(sc, 0xF82E, 0xF009);
1742         MP_WriteMcuAccessRegWord(sc, 0xF830, 0x74A2);
1743         MP_WriteMcuAccessRegWord(sc, 0xF832, 0x8CA5);
1744         MP_WriteMcuAccessRegWord(sc, 0xF834, 0x74A0);
1745         MP_WriteMcuAccessRegWord(sc, 0xF836, 0xC50E);
1746         MP_WriteMcuAccessRegWord(sc, 0xF838, 0x9CA2);
1747         MP_WriteMcuAccessRegWord(sc, 0xF83A, 0x1C11);
1748         MP_WriteMcuAccessRegWord(sc, 0xF83C, 0x9CA0);
1749         MP_WriteMcuAccessRegWord(sc, 0xF83E, 0xE006);
1750         MP_WriteMcuAccessRegWord(sc, 0xF840, 0x74F8);
1751         MP_WriteMcuAccessRegWord(sc, 0xF842, 0x48C4);
1752         MP_WriteMcuAccessRegWord(sc, 0xF844, 0x8CF8);
1753         MP_WriteMcuAccessRegWord(sc, 0xF846, 0xC404);
1754         MP_WriteMcuAccessRegWord(sc, 0xF848, 0xBC00);
1755         MP_WriteMcuAccessRegWord(sc, 0xF84A, 0xC403);
1756         MP_WriteMcuAccessRegWord(sc, 0xF84C, 0xBC00);
1757         MP_WriteMcuAccessRegWord(sc, 0xF84E, 0x0BF2);
1758         MP_WriteMcuAccessRegWord(sc, 0xF850, 0x0C0A);
1759         MP_WriteMcuAccessRegWord(sc, 0xF852, 0xE434);
1760         MP_WriteMcuAccessRegWord(sc, 0xF854, 0xD3C0);
1761         MP_WriteMcuAccessRegWord(sc, 0xF856, 0x49D9);
1762         MP_WriteMcuAccessRegWord(sc, 0xF858, 0xF01F);
1763         MP_WriteMcuAccessRegWord(sc, 0xF85A, 0xC526);
1764         MP_WriteMcuAccessRegWord(sc, 0xF85C, 0x64A5);
1765         MP_WriteMcuAccessRegWord(sc, 0xF85E, 0x1400);
1766         MP_WriteMcuAccessRegWord(sc, 0xF860, 0xF007);
1767         MP_WriteMcuAccessRegWord(sc, 0xF862, 0x0C01);
1768         MP_WriteMcuAccessRegWord(sc, 0xF864, 0x8CA5);
1769         MP_WriteMcuAccessRegWord(sc, 0xF866, 0x1C15);
1770         MP_WriteMcuAccessRegWord(sc, 0xF868, 0xC51B);
1771         MP_WriteMcuAccessRegWord(sc, 0xF86A, 0x9CA0);
1772         MP_WriteMcuAccessRegWord(sc, 0xF86C, 0xE013);
1773         MP_WriteMcuAccessRegWord(sc, 0xF86E, 0xC519);
1774         MP_WriteMcuAccessRegWord(sc, 0xF870, 0x74A0);
1775         MP_WriteMcuAccessRegWord(sc, 0xF872, 0x48C4);
1776         MP_WriteMcuAccessRegWord(sc, 0xF874, 0x8CA0);
1777         MP_WriteMcuAccessRegWord(sc, 0xF876, 0xC516);
1778         MP_WriteMcuAccessRegWord(sc, 0xF878, 0x74A4);
1779         MP_WriteMcuAccessRegWord(sc, 0xF87A, 0x48C8);
1780         MP_WriteMcuAccessRegWord(sc, 0xF87C, 0x48CA);
1781         MP_WriteMcuAccessRegWord(sc, 0xF87E, 0x9CA4);
1782         MP_WriteMcuAccessRegWord(sc, 0xF880, 0xC512);
1783         MP_WriteMcuAccessRegWord(sc, 0xF882, 0x1B00);
1784         MP_WriteMcuAccessRegWord(sc, 0xF884, 0x9BA0);
1785         MP_WriteMcuAccessRegWord(sc, 0xF886, 0x1B1C);
1786         MP_WriteMcuAccessRegWord(sc, 0xF888, 0x483F);
1787         MP_WriteMcuAccessRegWord(sc, 0xF88A, 0x9BA2);
1788         MP_WriteMcuAccessRegWord(sc, 0xF88C, 0x1B04);
1789         MP_WriteMcuAccessRegWord(sc, 0xF88E, 0xC508);
1790         MP_WriteMcuAccessRegWord(sc, 0xF890, 0x9BA0);
1791         MP_WriteMcuAccessRegWord(sc, 0xF892, 0xC505);
1792         MP_WriteMcuAccessRegWord(sc, 0xF894, 0xBD00);
1793         MP_WriteMcuAccessRegWord(sc, 0xF896, 0xC502);
1794         MP_WriteMcuAccessRegWord(sc, 0xF898, 0xBD00);
1795         MP_WriteMcuAccessRegWord(sc, 0xF89A, 0x0300);
1796         MP_WriteMcuAccessRegWord(sc, 0xF89C, 0x051E);
1797         MP_WriteMcuAccessRegWord(sc, 0xF89E, 0xE434);
1798         MP_WriteMcuAccessRegWord(sc, 0xF8A0, 0xE018);
1799         MP_WriteMcuAccessRegWord(sc, 0xF8A2, 0xE092);
1800         MP_WriteMcuAccessRegWord(sc, 0xF8A4, 0xDE20);
1801         MP_WriteMcuAccessRegWord(sc, 0xF8A6, 0xD3C0);
1802         MP_WriteMcuAccessRegWord(sc, 0xF8A8, 0xC50F);
1803         MP_WriteMcuAccessRegWord(sc, 0xF8AA, 0x76A4);
1804         MP_WriteMcuAccessRegWord(sc, 0xF8AC, 0x49E3);
1805         MP_WriteMcuAccessRegWord(sc, 0xF8AE, 0xF007);
1806         MP_WriteMcuAccessRegWord(sc, 0xF8B0, 0x49C0);
1807         MP_WriteMcuAccessRegWord(sc, 0xF8B2, 0xF103);
1808         MP_WriteMcuAccessRegWord(sc, 0xF8B4, 0xC607);
1809         MP_WriteMcuAccessRegWord(sc, 0xF8B6, 0xBE00);
1810         MP_WriteMcuAccessRegWord(sc, 0xF8B8, 0xC606);
1811         MP_WriteMcuAccessRegWord(sc, 0xF8BA, 0xBE00);
1812         MP_WriteMcuAccessRegWord(sc, 0xF8BC, 0xC602);
1813         MP_WriteMcuAccessRegWord(sc, 0xF8BE, 0xBE00);
1814         MP_WriteMcuAccessRegWord(sc, 0xF8C0, 0x0C4C);
1815         MP_WriteMcuAccessRegWord(sc, 0xF8C2, 0x0C28);
1816         MP_WriteMcuAccessRegWord(sc, 0xF8C4, 0x0C2C);
1817         MP_WriteMcuAccessRegWord(sc, 0xF8C6, 0xDC00);
1818         MP_WriteMcuAccessRegWord(sc, 0xF8C8, 0xC707);
1819         MP_WriteMcuAccessRegWord(sc, 0xF8CA, 0x1D00);
1820         MP_WriteMcuAccessRegWord(sc, 0xF8CC, 0x8DE2);
1821         MP_WriteMcuAccessRegWord(sc, 0xF8CE, 0x48C1);
1822         MP_WriteMcuAccessRegWord(sc, 0xF8D0, 0xC502);
1823         MP_WriteMcuAccessRegWord(sc, 0xF8D2, 0xBD00);
1824         MP_WriteMcuAccessRegWord(sc, 0xF8D4, 0x00AA);
1825         MP_WriteMcuAccessRegWord(sc, 0xF8D6, 0xE0C0);
1826         MP_WriteMcuAccessRegWord(sc, 0xF8D8, 0xC502);
1827         MP_WriteMcuAccessRegWord(sc, 0xF8DA, 0xBD00);
1828         MP_WriteMcuAccessRegWord(sc, 0xF8DC, 0x0132);
1829
1830         MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000);
1831
1832         MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x0743);
1833         MP_WriteMcuAccessRegWord(sc, 0xFC2C, 0x0801);
1834         MP_WriteMcuAccessRegWord(sc, 0xFC2E, 0x0BE9);
1835         MP_WriteMcuAccessRegWord(sc, 0xFC30, 0x02FD);
1836         MP_WriteMcuAccessRegWord(sc, 0xFC32, 0x0C25);
1837         MP_WriteMcuAccessRegWord(sc, 0xFC34, 0x00A9);
1838         MP_WriteMcuAccessRegWord(sc, 0xFC36, 0x012D);
1839 }
1840
1841 static void re_set_mac_mcu_8168ep_1(struct re_softc *sc)
1842 {
1843         DisableMcuBPs(sc);
1844
1845         MP_WriteMcuAccessRegWord(sc, 0xF800, 0xE008);
1846         MP_WriteMcuAccessRegWord(sc, 0xF802, 0xE0D3);
1847         MP_WriteMcuAccessRegWord(sc, 0xF804, 0xE0D6);
1848         MP_WriteMcuAccessRegWord(sc, 0xF806, 0xE0D9);
1849         MP_WriteMcuAccessRegWord(sc, 0xF808, 0xE0DB);
1850         MP_WriteMcuAccessRegWord(sc, 0xF80A, 0xE0DD);
1851         MP_WriteMcuAccessRegWord(sc, 0xF80C, 0xE0DF);
1852         MP_WriteMcuAccessRegWord(sc, 0xF80E, 0xE0E1);
1853         MP_WriteMcuAccessRegWord(sc, 0xF810, 0xC251);
1854         MP_WriteMcuAccessRegWord(sc, 0xF812, 0x7340);
1855         MP_WriteMcuAccessRegWord(sc, 0xF814, 0x49B1);
1856         MP_WriteMcuAccessRegWord(sc, 0xF816, 0xF010);
1857         MP_WriteMcuAccessRegWord(sc, 0xF818, 0x1D02);
1858         MP_WriteMcuAccessRegWord(sc, 0xF81A, 0x8D40);
1859         MP_WriteMcuAccessRegWord(sc, 0xF81C, 0xC202);
1860         MP_WriteMcuAccessRegWord(sc, 0xF81E, 0xBA00);
1861         MP_WriteMcuAccessRegWord(sc, 0xF820, 0x2C3A);
1862         MP_WriteMcuAccessRegWord(sc, 0xF822, 0xC0F0);
1863         MP_WriteMcuAccessRegWord(sc, 0xF824, 0xE8DE);
1864         MP_WriteMcuAccessRegWord(sc, 0xF826, 0x2000);
1865         MP_WriteMcuAccessRegWord(sc, 0xF828, 0x8000);
1866         MP_WriteMcuAccessRegWord(sc, 0xF82A, 0xC0B6);
1867         MP_WriteMcuAccessRegWord(sc, 0xF82C, 0x268C);
1868         MP_WriteMcuAccessRegWord(sc, 0xF82E, 0x752C);
1869         MP_WriteMcuAccessRegWord(sc, 0xF830, 0x49D4);
1870         MP_WriteMcuAccessRegWord(sc, 0xF832, 0xF112);
1871         MP_WriteMcuAccessRegWord(sc, 0xF834, 0xE025);
1872         MP_WriteMcuAccessRegWord(sc, 0xF836, 0xC2F6);
1873         MP_WriteMcuAccessRegWord(sc, 0xF838, 0x7146);
1874         MP_WriteMcuAccessRegWord(sc, 0xF83A, 0xC2F5);
1875         MP_WriteMcuAccessRegWord(sc, 0xF83C, 0x7340);
1876         MP_WriteMcuAccessRegWord(sc, 0xF83E, 0x49BE);
1877         MP_WriteMcuAccessRegWord(sc, 0xF840, 0xF103);
1878         MP_WriteMcuAccessRegWord(sc, 0xF842, 0xC7F2);
1879         MP_WriteMcuAccessRegWord(sc, 0xF844, 0xE002);
1880         MP_WriteMcuAccessRegWord(sc, 0xF846, 0xC7F1);
1881         MP_WriteMcuAccessRegWord(sc, 0xF848, 0x304F);
1882         MP_WriteMcuAccessRegWord(sc, 0xF84A, 0x6226);
1883         MP_WriteMcuAccessRegWord(sc, 0xF84C, 0x49A1);
1884         MP_WriteMcuAccessRegWord(sc, 0xF84E, 0xF1F0);
1885         MP_WriteMcuAccessRegWord(sc, 0xF850, 0x7222);
1886         MP_WriteMcuAccessRegWord(sc, 0xF852, 0x49A0);
1887         MP_WriteMcuAccessRegWord(sc, 0xF854, 0xF1ED);
1888         MP_WriteMcuAccessRegWord(sc, 0xF856, 0x2525);
1889         MP_WriteMcuAccessRegWord(sc, 0xF858, 0x1F28);
1890         MP_WriteMcuAccessRegWord(sc, 0xF85A, 0x3097);
1891         MP_WriteMcuAccessRegWord(sc, 0xF85C, 0x3091);
1892         MP_WriteMcuAccessRegWord(sc, 0xF85E, 0x9A36);
1893         MP_WriteMcuAccessRegWord(sc, 0xF860, 0x752C);
1894         MP_WriteMcuAccessRegWord(sc, 0xF862, 0x21DC);
1895         MP_WriteMcuAccessRegWord(sc, 0xF864, 0x25BC);
1896         MP_WriteMcuAccessRegWord(sc, 0xF866, 0xC6E2);
1897         MP_WriteMcuAccessRegWord(sc, 0xF868, 0x77C0);
1898         MP_WriteMcuAccessRegWord(sc, 0xF86A, 0x1304);
1899         MP_WriteMcuAccessRegWord(sc, 0xF86C, 0xF014);
1900         MP_WriteMcuAccessRegWord(sc, 0xF86E, 0x1303);
1901         MP_WriteMcuAccessRegWord(sc, 0xF870, 0xF014);
1902         MP_WriteMcuAccessRegWord(sc, 0xF872, 0x1302);
1903         MP_WriteMcuAccessRegWord(sc, 0xF874, 0xF014);
1904         MP_WriteMcuAccessRegWord(sc, 0xF876, 0x1301);
1905         MP_WriteMcuAccessRegWord(sc, 0xF878, 0xF014);
1906         MP_WriteMcuAccessRegWord(sc, 0xF87A, 0x49D4);
1907         MP_WriteMcuAccessRegWord(sc, 0xF87C, 0xF103);
1908         MP_WriteMcuAccessRegWord(sc, 0xF87E, 0xC3D7);
1909         MP_WriteMcuAccessRegWord(sc, 0xF880, 0xBB00);
1910         MP_WriteMcuAccessRegWord(sc, 0xF882, 0xC618);
1911         MP_WriteMcuAccessRegWord(sc, 0xF884, 0x67C6);
1912         MP_WriteMcuAccessRegWord(sc, 0xF886, 0x752E);
1913         MP_WriteMcuAccessRegWord(sc, 0xF888, 0x22D7);
1914         MP_WriteMcuAccessRegWord(sc, 0xF88A, 0x26DD);
1915         MP_WriteMcuAccessRegWord(sc, 0xF88C, 0x1505);
1916         MP_WriteMcuAccessRegWord(sc, 0xF88E, 0xF013);
1917         MP_WriteMcuAccessRegWord(sc, 0xF890, 0xC60A);
1918         MP_WriteMcuAccessRegWord(sc, 0xF892, 0xBE00);
1919         MP_WriteMcuAccessRegWord(sc, 0xF894, 0xC309);
1920         MP_WriteMcuAccessRegWord(sc, 0xF896, 0xBB00);
1921         MP_WriteMcuAccessRegWord(sc, 0xF898, 0xC308);
1922         MP_WriteMcuAccessRegWord(sc, 0xF89A, 0xBB00);
1923         MP_WriteMcuAccessRegWord(sc, 0xF89C, 0xC307);
1924         MP_WriteMcuAccessRegWord(sc, 0xF89E, 0xBB00);
1925         MP_WriteMcuAccessRegWord(sc, 0xF8A0, 0xC306);
1926         MP_WriteMcuAccessRegWord(sc, 0xF8A2, 0xBB00);
1927         MP_WriteMcuAccessRegWord(sc, 0xF8A4, 0x25C8);
1928         MP_WriteMcuAccessRegWord(sc, 0xF8A6, 0x25A6);
1929         MP_WriteMcuAccessRegWord(sc, 0xF8A8, 0x25AC);
1930         MP_WriteMcuAccessRegWord(sc, 0xF8AA, 0x25B2);
1931         MP_WriteMcuAccessRegWord(sc, 0xF8AC, 0x25B8);
1932         MP_WriteMcuAccessRegWord(sc, 0xF8AE, 0xCD08);
1933         MP_WriteMcuAccessRegWord(sc, 0xF8B0, 0x0000);
1934         MP_WriteMcuAccessRegWord(sc, 0xF8B2, 0xC0BC);
1935         MP_WriteMcuAccessRegWord(sc, 0xF8B4, 0xC2FF);
1936         MP_WriteMcuAccessRegWord(sc, 0xF8B6, 0x7340);
1937         MP_WriteMcuAccessRegWord(sc, 0xF8B8, 0x49B0);
1938         MP_WriteMcuAccessRegWord(sc, 0xF8BA, 0xF04E);
1939         MP_WriteMcuAccessRegWord(sc, 0xF8BC, 0x1F46);
1940         MP_WriteMcuAccessRegWord(sc, 0xF8BE, 0x308F);
1941         MP_WriteMcuAccessRegWord(sc, 0xF8C0, 0xC3F7);
1942         MP_WriteMcuAccessRegWord(sc, 0xF8C2, 0x1C04);
1943         MP_WriteMcuAccessRegWord(sc, 0xF8C4, 0xE84D);
1944         MP_WriteMcuAccessRegWord(sc, 0xF8C6, 0x1401);
1945         MP_WriteMcuAccessRegWord(sc, 0xF8C8, 0xF147);
1946         MP_WriteMcuAccessRegWord(sc, 0xF8CA, 0x7226);
1947         MP_WriteMcuAccessRegWord(sc, 0xF8CC, 0x49A7);
1948         MP_WriteMcuAccessRegWord(sc, 0xF8CE, 0xF044);
1949         MP_WriteMcuAccessRegWord(sc, 0xF8D0, 0x7222);
1950         MP_WriteMcuAccessRegWord(sc, 0xF8D2, 0x2525);
1951         MP_WriteMcuAccessRegWord(sc, 0xF8D4, 0x1F30);
1952         MP_WriteMcuAccessRegWord(sc, 0xF8D6, 0x3097);
1953         MP_WriteMcuAccessRegWord(sc, 0xF8D8, 0x3091);
1954         MP_WriteMcuAccessRegWord(sc, 0xF8DA, 0x7340);
1955         MP_WriteMcuAccessRegWord(sc, 0xF8DC, 0xC4EA);
1956         MP_WriteMcuAccessRegWord(sc, 0xF8DE, 0x401C);
1957         MP_WriteMcuAccessRegWord(sc, 0xF8E0, 0xF006);
1958         MP_WriteMcuAccessRegWord(sc, 0xF8E2, 0xC6E8);
1959         MP_WriteMcuAccessRegWord(sc, 0xF8E4, 0x75C0);
1960         MP_WriteMcuAccessRegWord(sc, 0xF8E6, 0x49D7);
1961         MP_WriteMcuAccessRegWord(sc, 0xF8E8, 0xF105);
1962         MP_WriteMcuAccessRegWord(sc, 0xF8EA, 0xE036);
1963         MP_WriteMcuAccessRegWord(sc, 0xF8EC, 0x1D08);
1964         MP_WriteMcuAccessRegWord(sc, 0xF8EE, 0x8DC1);
1965         MP_WriteMcuAccessRegWord(sc, 0xF8F0, 0x0208);
1966         MP_WriteMcuAccessRegWord(sc, 0xF8F2, 0x6640);
1967         MP_WriteMcuAccessRegWord(sc, 0xF8F4, 0x2764);
1968         MP_WriteMcuAccessRegWord(sc, 0xF8F6, 0x1606);
1969         MP_WriteMcuAccessRegWord(sc, 0xF8F8, 0xF12F);
1970         MP_WriteMcuAccessRegWord(sc, 0xF8FA, 0x6346);
1971         MP_WriteMcuAccessRegWord(sc, 0xF8FC, 0x133B);
1972         MP_WriteMcuAccessRegWord(sc, 0xF8FE, 0xF12C);
1973         MP_WriteMcuAccessRegWord(sc, 0xF900, 0x9B34);
1974         MP_WriteMcuAccessRegWord(sc, 0xF902, 0x1B18);
1975         MP_WriteMcuAccessRegWord(sc, 0xF904, 0x3093);
1976         MP_WriteMcuAccessRegWord(sc, 0xF906, 0xC32A);
1977         MP_WriteMcuAccessRegWord(sc, 0xF908, 0x1C10);
1978         MP_WriteMcuAccessRegWord(sc, 0xF90A, 0xE82A);
1979         MP_WriteMcuAccessRegWord(sc, 0xF90C, 0x1401);
1980         MP_WriteMcuAccessRegWord(sc, 0xF90E, 0xF124);
1981         MP_WriteMcuAccessRegWord(sc, 0xF910, 0x1A36);
1982         MP_WriteMcuAccessRegWord(sc, 0xF912, 0x308A);
1983         MP_WriteMcuAccessRegWord(sc, 0xF914, 0x7322);
1984         MP_WriteMcuAccessRegWord(sc, 0xF916, 0x25B5);
1985         MP_WriteMcuAccessRegWord(sc, 0xF918, 0x0B0E);
1986         MP_WriteMcuAccessRegWord(sc, 0xF91A, 0x1C00);
1987         MP_WriteMcuAccessRegWord(sc, 0xF91C, 0xE82C);
1988         MP_WriteMcuAccessRegWord(sc, 0xF91E, 0xC71F);
1989         MP_WriteMcuAccessRegWord(sc, 0xF920, 0x4027);
1990         MP_WriteMcuAccessRegWord(sc, 0xF922, 0xF11A);
1991         MP_WriteMcuAccessRegWord(sc, 0xF924, 0xE838);
1992         MP_WriteMcuAccessRegWord(sc, 0xF926, 0x1F42);
1993         MP_WriteMcuAccessRegWord(sc, 0xF928, 0x308F);
1994         MP_WriteMcuAccessRegWord(sc, 0xF92A, 0x1B08);
1995         MP_WriteMcuAccessRegWord(sc, 0xF92C, 0xE824);
1996         MP_WriteMcuAccessRegWord(sc, 0xF92E, 0x7236);
1997         MP_WriteMcuAccessRegWord(sc, 0xF930, 0x7746);
1998         MP_WriteMcuAccessRegWord(sc, 0xF932, 0x1700);
1999         MP_WriteMcuAccessRegWord(sc, 0xF934, 0xF00D);
2000         MP_WriteMcuAccessRegWord(sc, 0xF936, 0xC313);
2001         MP_WriteMcuAccessRegWord(sc, 0xF938, 0x401F);
2002         MP_WriteMcuAccessRegWord(sc, 0xF93A, 0xF103);
2003         MP_WriteMcuAccessRegWord(sc, 0xF93C, 0x1F00);
2004         MP_WriteMcuAccessRegWord(sc, 0xF93E, 0x9F46);
2005         MP_WriteMcuAccessRegWord(sc, 0xF940, 0x7744);
2006         MP_WriteMcuAccessRegWord(sc, 0xF942, 0x449F);
2007         MP_WriteMcuAccessRegWord(sc, 0xF944, 0x445F);
2008         MP_WriteMcuAccessRegWord(sc, 0xF946, 0xE817);
2009         MP_WriteMcuAccessRegWord(sc, 0xF948, 0xC70A);
2010         MP_WriteMcuAccessRegWord(sc, 0xF94A, 0x4027);
2011         MP_WriteMcuAccessRegWord(sc, 0xF94C, 0xF105);
2012         MP_WriteMcuAccessRegWord(sc, 0xF94E, 0xC302);
2013         MP_WriteMcuAccessRegWord(sc, 0xF950, 0xBB00);
2014         MP_WriteMcuAccessRegWord(sc, 0xF952, 0x2E08);
2015         MP_WriteMcuAccessRegWord(sc, 0xF954, 0x2DC2);
2016         MP_WriteMcuAccessRegWord(sc, 0xF956, 0xC7FF);
2017         MP_WriteMcuAccessRegWord(sc, 0xF958, 0xBF00);
2018         MP_WriteMcuAccessRegWord(sc, 0xF95A, 0xCDB8);
2019         MP_WriteMcuAccessRegWord(sc, 0xF95C, 0xFFFF);
2020         MP_WriteMcuAccessRegWord(sc, 0xF95E, 0x0C02);
2021         MP_WriteMcuAccessRegWord(sc, 0xF960, 0xA554);
2022         MP_WriteMcuAccessRegWord(sc, 0xF962, 0xA5DC);
2023         MP_WriteMcuAccessRegWord(sc, 0xF964, 0x402F);
2024         MP_WriteMcuAccessRegWord(sc, 0xF966, 0xF105);
2025         MP_WriteMcuAccessRegWord(sc, 0xF968, 0x1400);
2026         MP_WriteMcuAccessRegWord(sc, 0xF96A, 0xF1FA);
2027         MP_WriteMcuAccessRegWord(sc, 0xF96C, 0x1C01);
2028         MP_WriteMcuAccessRegWord(sc, 0xF96E, 0xE002);
2029         MP_WriteMcuAccessRegWord(sc, 0xF970, 0x1C00);
2030         MP_WriteMcuAccessRegWord(sc, 0xF972, 0xFF80);
2031         MP_WriteMcuAccessRegWord(sc, 0xF974, 0x49B0);
2032         MP_WriteMcuAccessRegWord(sc, 0xF976, 0xF004);
2033         MP_WriteMcuAccessRegWord(sc, 0xF978, 0x0B01);
2034         MP_WriteMcuAccessRegWord(sc, 0xF97A, 0xA1D3);
2035         MP_WriteMcuAccessRegWord(sc, 0xF97C, 0xE003);
2036         MP_WriteMcuAccessRegWord(sc, 0xF97E, 0x0B02);
2037         MP_WriteMcuAccessRegWord(sc, 0xF980, 0xA5D3);
2038         MP_WriteMcuAccessRegWord(sc, 0xF982, 0x3127);
2039         MP_WriteMcuAccessRegWord(sc, 0xF984, 0x3720);
2040         MP_WriteMcuAccessRegWord(sc, 0xF986, 0x0B02);
2041         MP_WriteMcuAccessRegWord(sc, 0xF988, 0xA5D3);
2042         MP_WriteMcuAccessRegWord(sc, 0xF98A, 0x3127);
2043         MP_WriteMcuAccessRegWord(sc, 0xF98C, 0x3720);
2044         MP_WriteMcuAccessRegWord(sc, 0xF98E, 0x1300);
2045         MP_WriteMcuAccessRegWord(sc, 0xF990, 0xF1FB);
2046         MP_WriteMcuAccessRegWord(sc, 0xF992, 0xFF80);
2047         MP_WriteMcuAccessRegWord(sc, 0xF994, 0x7322);
2048         MP_WriteMcuAccessRegWord(sc, 0xF996, 0x25B5);
2049         MP_WriteMcuAccessRegWord(sc, 0xF998, 0x1E28);
2050         MP_WriteMcuAccessRegWord(sc, 0xF99A, 0x30DE);
2051         MP_WriteMcuAccessRegWord(sc, 0xF99C, 0x30D9);
2052         MP_WriteMcuAccessRegWord(sc, 0xF99E, 0x7264);
2053         MP_WriteMcuAccessRegWord(sc, 0xF9A0, 0x1E11);
2054         MP_WriteMcuAccessRegWord(sc, 0xF9A2, 0x2368);
2055         MP_WriteMcuAccessRegWord(sc, 0xF9A4, 0x3116);
2056         MP_WriteMcuAccessRegWord(sc, 0xF9A6, 0xFF80);
2057         MP_WriteMcuAccessRegWord(sc, 0xF9A8, 0x1B7E);
2058         MP_WriteMcuAccessRegWord(sc, 0xF9AA, 0xC602);
2059         MP_WriteMcuAccessRegWord(sc, 0xF9AC, 0xBE00);
2060         MP_WriteMcuAccessRegWord(sc, 0xF9AE, 0x06A6);
2061         MP_WriteMcuAccessRegWord(sc, 0xF9B0, 0x1B7E);
2062         MP_WriteMcuAccessRegWord(sc, 0xF9B2, 0xC602);
2063         MP_WriteMcuAccessRegWord(sc, 0xF9B4, 0xBE00);
2064         MP_WriteMcuAccessRegWord(sc, 0xF9B6, 0x0764);
2065         MP_WriteMcuAccessRegWord(sc, 0xF9B8, 0xC602);
2066         MP_WriteMcuAccessRegWord(sc, 0xF9BA, 0xBE00);
2067         MP_WriteMcuAccessRegWord(sc, 0xF9BC, 0x0000);
2068         MP_WriteMcuAccessRegWord(sc, 0xF9BE, 0xC602);
2069         MP_WriteMcuAccessRegWord(sc, 0xF9C0, 0xBE00);
2070         MP_WriteMcuAccessRegWord(sc, 0xF9C2, 0x0000);
2071         MP_WriteMcuAccessRegWord(sc, 0xF9C4, 0xC602);
2072         MP_WriteMcuAccessRegWord(sc, 0xF9C6, 0xBE00);
2073         MP_WriteMcuAccessRegWord(sc, 0xF9C8, 0x0000);
2074         MP_WriteMcuAccessRegWord(sc, 0xF9CA, 0xC602);
2075         MP_WriteMcuAccessRegWord(sc, 0xF9CC, 0xBE00);
2076         MP_WriteMcuAccessRegWord(sc, 0xF9CE, 0x0000);
2077         MP_WriteMcuAccessRegWord(sc, 0xF9D0, 0xC602);
2078         MP_WriteMcuAccessRegWord(sc, 0xF9D2, 0xBE00);
2079         MP_WriteMcuAccessRegWord(sc, 0xF9D4, 0x0000);
2080
2081         MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000);
2082
2083         MP_WriteMcuAccessRegWord(sc, 0xFC28, 0x2549);
2084         MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x06A5);
2085         MP_WriteMcuAccessRegWord(sc, 0xFC2C, 0x0763);
2086 }
2087
2088 static void re_set_mac_mcu_8168ep_2(struct re_softc *sc)
2089 {
2090         DisableMcuBPs(sc);
2091
2092         MP_WriteMcuAccessRegWord(sc, 0xF800, 0xE008);
2093         MP_WriteMcuAccessRegWord(sc, 0xF802, 0xE017);
2094         MP_WriteMcuAccessRegWord(sc, 0xF804, 0xE019);
2095         MP_WriteMcuAccessRegWord(sc, 0xF806, 0xE01B);
2096         MP_WriteMcuAccessRegWord(sc, 0xF808, 0xE01D);
2097         MP_WriteMcuAccessRegWord(sc, 0xF80A, 0xE01F);
2098         MP_WriteMcuAccessRegWord(sc, 0xF80C, 0xE021);
2099         MP_WriteMcuAccessRegWord(sc, 0xF80E, 0xE023);
2100         MP_WriteMcuAccessRegWord(sc, 0xF810, 0xC50F);
2101         MP_WriteMcuAccessRegWord(sc, 0xF812, 0x76A4);
2102         MP_WriteMcuAccessRegWord(sc, 0xF814, 0x49E3);
2103         MP_WriteMcuAccessRegWord(sc, 0xF816, 0xF007);
2104         MP_WriteMcuAccessRegWord(sc, 0xF818, 0x49C0);
2105         MP_WriteMcuAccessRegWord(sc, 0xF81A, 0xF103);
2106         MP_WriteMcuAccessRegWord(sc, 0xF81C, 0xC607);
2107         MP_WriteMcuAccessRegWord(sc, 0xF81E, 0xBE00);
2108         MP_WriteMcuAccessRegWord(sc, 0xF820, 0xC606);
2109         MP_WriteMcuAccessRegWord(sc, 0xF822, 0xBE00);
2110         MP_WriteMcuAccessRegWord(sc, 0xF824, 0xC602);
2111         MP_WriteMcuAccessRegWord(sc, 0xF826, 0xBE00);
2112         MP_WriteMcuAccessRegWord(sc, 0xF828, 0x0BDA);
2113         MP_WriteMcuAccessRegWord(sc, 0xF82A, 0x0BB0);
2114         MP_WriteMcuAccessRegWord(sc, 0xF82C, 0x0BBA);
2115         MP_WriteMcuAccessRegWord(sc, 0xF82E, 0xDC00);
2116         MP_WriteMcuAccessRegWord(sc, 0xF830, 0xC602);
2117         MP_WriteMcuAccessRegWord(sc, 0xF832, 0xBE00);
2118         MP_WriteMcuAccessRegWord(sc, 0xF834, 0x0000);
2119         MP_WriteMcuAccessRegWord(sc, 0xF836, 0xC602);
2120         MP_WriteMcuAccessRegWord(sc, 0xF838, 0xBE00);
2121         MP_WriteMcuAccessRegWord(sc, 0xF83A, 0x0000);
2122         MP_WriteMcuAccessRegWord(sc, 0xF83C, 0xC602);
2123         MP_WriteMcuAccessRegWord(sc, 0xF83E, 0xBE00);
2124         MP_WriteMcuAccessRegWord(sc, 0xF840, 0x0000);
2125         MP_WriteMcuAccessRegWord(sc, 0xF842, 0xC602);
2126         MP_WriteMcuAccessRegWord(sc, 0xF844, 0xBE00);
2127         MP_WriteMcuAccessRegWord(sc, 0xF846, 0x0000);
2128         MP_WriteMcuAccessRegWord(sc, 0xF848, 0xC602);
2129         MP_WriteMcuAccessRegWord(sc, 0xF84A, 0xBE00);
2130         MP_WriteMcuAccessRegWord(sc, 0xF84C, 0x0000);
2131         MP_WriteMcuAccessRegWord(sc, 0xF84E, 0xC602);
2132         MP_WriteMcuAccessRegWord(sc, 0xF850, 0xBE00);
2133         MP_WriteMcuAccessRegWord(sc, 0xF852, 0x0000);
2134         MP_WriteMcuAccessRegWord(sc, 0xF854, 0xC602);
2135         MP_WriteMcuAccessRegWord(sc, 0xF856, 0xBE00);
2136         MP_WriteMcuAccessRegWord(sc, 0xF858, 0x0000);
2137
2138         MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000);
2139
2140         MP_WriteMcuAccessRegWord(sc, 0xFC28, 0x0BB3);
2141 }
2142
2143 static void re_set_mac_mcu_8168h_1(struct re_softc *sc)
2144 {
2145         DisableMcuBPs(sc);
2146
2147         MP_WriteMcuAccessRegWord(sc, 0xF800, 0xE008);
2148         MP_WriteMcuAccessRegWord(sc, 0xF802, 0xE00F);
2149         MP_WriteMcuAccessRegWord(sc, 0xF804, 0xE011);
2150         MP_WriteMcuAccessRegWord(sc, 0xF806, 0xE047);
2151         MP_WriteMcuAccessRegWord(sc, 0xF808, 0xE049);
2152         MP_WriteMcuAccessRegWord(sc, 0xF80A, 0xE073);
2153         MP_WriteMcuAccessRegWord(sc, 0xF80C, 0xE075);
2154         MP_WriteMcuAccessRegWord(sc, 0xF80E, 0xE077);
2155         MP_WriteMcuAccessRegWord(sc, 0xF810, 0xC707);
2156         MP_WriteMcuAccessRegWord(sc, 0xF812, 0x1D00);
2157         MP_WriteMcuAccessRegWord(sc, 0xF814, 0x8DE2);
2158         MP_WriteMcuAccessRegWord(sc, 0xF816, 0x48C1);
2159         MP_WriteMcuAccessRegWord(sc, 0xF818, 0xC502);
2160         MP_WriteMcuAccessRegWord(sc, 0xF81A, 0xBD00);
2161         MP_WriteMcuAccessRegWord(sc, 0xF81C, 0x00E4);
2162         MP_WriteMcuAccessRegWord(sc, 0xF81E, 0xE0C0);
2163         MP_WriteMcuAccessRegWord(sc, 0xF820, 0xC502);
2164         MP_WriteMcuAccessRegWord(sc, 0xF822, 0xBD00);
2165         MP_WriteMcuAccessRegWord(sc, 0xF824, 0x0216);
2166         MP_WriteMcuAccessRegWord(sc, 0xF826, 0xC634);
2167         MP_WriteMcuAccessRegWord(sc, 0xF828, 0x75C0);
2168         MP_WriteMcuAccessRegWord(sc, 0xF82A, 0x49D3);
2169         MP_WriteMcuAccessRegWord(sc, 0xF82C, 0xF027);
2170         MP_WriteMcuAccessRegWord(sc, 0xF82E, 0xC631);
2171         MP_WriteMcuAccessRegWord(sc, 0xF830, 0x75C0);
2172         MP_WriteMcuAccessRegWord(sc, 0xF832, 0x49D3);
2173         MP_WriteMcuAccessRegWord(sc, 0xF834, 0xF123);
2174         MP_WriteMcuAccessRegWord(sc, 0xF836, 0xC627);
2175         MP_WriteMcuAccessRegWord(sc, 0xF838, 0x75C0);
2176         MP_WriteMcuAccessRegWord(sc, 0xF83A, 0xB405);
2177         MP_WriteMcuAccessRegWord(sc, 0xF83C, 0xC525);
2178         MP_WriteMcuAccessRegWord(sc, 0xF83E, 0x9DC0);
2179         MP_WriteMcuAccessRegWord(sc, 0xF840, 0xC621);
2180         MP_WriteMcuAccessRegWord(sc, 0xF842, 0x75C8);
2181         MP_WriteMcuAccessRegWord(sc, 0xF844, 0x49D5);
2182         MP_WriteMcuAccessRegWord(sc, 0xF846, 0xF00A);
2183         MP_WriteMcuAccessRegWord(sc, 0xF848, 0x49D6);
2184         MP_WriteMcuAccessRegWord(sc, 0xF84A, 0xF008);
2185         MP_WriteMcuAccessRegWord(sc, 0xF84C, 0x49D7);
2186         MP_WriteMcuAccessRegWord(sc, 0xF84E, 0xF006);
2187         MP_WriteMcuAccessRegWord(sc, 0xF850, 0x49D8);
2188         MP_WriteMcuAccessRegWord(sc, 0xF852, 0xF004);
2189         MP_WriteMcuAccessRegWord(sc, 0xF854, 0x75D2);
2190         MP_WriteMcuAccessRegWord(sc, 0xF856, 0x49D9);
2191         MP_WriteMcuAccessRegWord(sc, 0xF858, 0xF111);
2192         MP_WriteMcuAccessRegWord(sc, 0xF85A, 0xC517);
2193         MP_WriteMcuAccessRegWord(sc, 0xF85C, 0x9DC8);
2194         MP_WriteMcuAccessRegWord(sc, 0xF85E, 0xC516);
2195         MP_WriteMcuAccessRegWord(sc, 0xF860, 0x9DD2);
2196         MP_WriteMcuAccessRegWord(sc, 0xF862, 0xC618);
2197         MP_WriteMcuAccessRegWord(sc, 0xF864, 0x75C0);
2198         MP_WriteMcuAccessRegWord(sc, 0xF866, 0x49D4);
2199         MP_WriteMcuAccessRegWord(sc, 0xF868, 0xF003);
2200         MP_WriteMcuAccessRegWord(sc, 0xF86A, 0x49D0);
2201         MP_WriteMcuAccessRegWord(sc, 0xF86C, 0xF104);
2202         MP_WriteMcuAccessRegWord(sc, 0xF86E, 0xC60A);
2203         MP_WriteMcuAccessRegWord(sc, 0xF870, 0xC50E);
2204         MP_WriteMcuAccessRegWord(sc, 0xF872, 0x9DC0);
2205         MP_WriteMcuAccessRegWord(sc, 0xF874, 0xB005);
2206         MP_WriteMcuAccessRegWord(sc, 0xF876, 0xC607);
2207         MP_WriteMcuAccessRegWord(sc, 0xF878, 0x9DC0);
2208         MP_WriteMcuAccessRegWord(sc, 0xF87A, 0xB007);
2209         MP_WriteMcuAccessRegWord(sc, 0xF87C, 0xC602);
2210         MP_WriteMcuAccessRegWord(sc, 0xF87E, 0xBE00);
2211         MP_WriteMcuAccessRegWord(sc, 0xF880, 0x1A06);
2212         MP_WriteMcuAccessRegWord(sc, 0xF882, 0xB400);
2213         MP_WriteMcuAccessRegWord(sc, 0xF884, 0xE86C);
2214         MP_WriteMcuAccessRegWord(sc, 0xF886, 0xA000);
2215         MP_WriteMcuAccessRegWord(sc, 0xF888, 0x01E1);
2216         MP_WriteMcuAccessRegWord(sc, 0xF88A, 0x0200);
2217         MP_WriteMcuAccessRegWord(sc, 0xF88C, 0x9200);
2218         MP_WriteMcuAccessRegWord(sc, 0xF88E, 0xE84C);
2219         MP_WriteMcuAccessRegWord(sc, 0xF890, 0xE004);
2220         MP_WriteMcuAccessRegWord(sc, 0xF892, 0xE908);
2221         MP_WriteMcuAccessRegWord(sc, 0xF894, 0xC502);
2222         MP_WriteMcuAccessRegWord(sc, 0xF896, 0xBD00);
2223         MP_WriteMcuAccessRegWord(sc, 0xF898, 0x0B58);
2224         MP_WriteMcuAccessRegWord(sc, 0xF89A, 0xB407);
2225         MP_WriteMcuAccessRegWord(sc, 0xF89C, 0xB404);
2226         MP_WriteMcuAccessRegWord(sc, 0xF89E, 0x2195);
2227         MP_WriteMcuAccessRegWord(sc, 0xF8A0, 0x25BD);
2228         MP_WriteMcuAccessRegWord(sc, 0xF8A2, 0x9BE0);
2229         MP_WriteMcuAccessRegWord(sc, 0xF8A4, 0x1C1C);
2230         MP_WriteMcuAccessRegWord(sc, 0xF8A6, 0x484F);
2231         MP_WriteMcuAccessRegWord(sc, 0xF8A8, 0x9CE2);
2232         MP_WriteMcuAccessRegWord(sc, 0xF8AA, 0x72E2);
2233         MP_WriteMcuAccessRegWord(sc, 0xF8AC, 0x49AE);
2234         MP_WriteMcuAccessRegWord(sc, 0xF8AE, 0xF1FE);
2235         MP_WriteMcuAccessRegWord(sc, 0xF8B0, 0x0B00);
2236         MP_WriteMcuAccessRegWord(sc, 0xF8B2, 0xF116);
2237         MP_WriteMcuAccessRegWord(sc, 0xF8B4, 0xC71C);
2238         MP_WriteMcuAccessRegWord(sc, 0xF8B6, 0xC419);
2239         MP_WriteMcuAccessRegWord(sc, 0xF8B8, 0x9CE0);
2240         MP_WriteMcuAccessRegWord(sc, 0xF8BA, 0x1C13);
2241         MP_WriteMcuAccessRegWord(sc, 0xF8BC, 0x484F);
2242         MP_WriteMcuAccessRegWord(sc, 0xF8BE, 0x9CE2);
2243         MP_WriteMcuAccessRegWord(sc, 0xF8C0, 0x74E2);
2244         MP_WriteMcuAccessRegWord(sc, 0xF8C2, 0x49CE);
2245         MP_WriteMcuAccessRegWord(sc, 0xF8C4, 0xF1FE);
2246         MP_WriteMcuAccessRegWord(sc, 0xF8C6, 0xC412);
2247         MP_WriteMcuAccessRegWord(sc, 0xF8C8, 0x9CE0);
2248         MP_WriteMcuAccessRegWord(sc, 0xF8CA, 0x1C13);
2249         MP_WriteMcuAccessRegWord(sc, 0xF8CC, 0x484F);
2250         MP_WriteMcuAccessRegWord(sc, 0xF8CE, 0x9CE2);
2251         MP_WriteMcuAccessRegWord(sc, 0xF8D0, 0x74E2);
2252         MP_WriteMcuAccessRegWord(sc, 0xF8D2, 0x49CE);
2253         MP_WriteMcuAccessRegWord(sc, 0xF8D4, 0xF1FE);
2254         MP_WriteMcuAccessRegWord(sc, 0xF8D6, 0xC70C);
2255         MP_WriteMcuAccessRegWord(sc, 0xF8D8, 0x74F8);
2256         MP_WriteMcuAccessRegWord(sc, 0xF8DA, 0x48C3);
2257         MP_WriteMcuAccessRegWord(sc, 0xF8DC, 0x8CF8);
2258         MP_WriteMcuAccessRegWord(sc, 0xF8DE, 0xB004);
2259         MP_WriteMcuAccessRegWord(sc, 0xF8E0, 0xB007);
2260         MP_WriteMcuAccessRegWord(sc, 0xF8E2, 0xC502);
2261         MP_WriteMcuAccessRegWord(sc, 0xF8E4, 0xBD00);
2262         MP_WriteMcuAccessRegWord(sc, 0xF8E6, 0x0F24);
2263         MP_WriteMcuAccessRegWord(sc, 0xF8E8, 0x0481);
2264         MP_WriteMcuAccessRegWord(sc, 0xF8EA, 0x0C81);
2265         MP_WriteMcuAccessRegWord(sc, 0xF8EC, 0xDE24);
2266         MP_WriteMcuAccessRegWord(sc, 0xF8EE, 0xE000);
2267         MP_WriteMcuAccessRegWord(sc, 0xF8F0, 0xC602);
2268         MP_WriteMcuAccessRegWord(sc, 0xF8F2, 0xBE00);
2269         MP_WriteMcuAccessRegWord(sc, 0xF8F4, 0x0CA4);
2270         MP_WriteMcuAccessRegWord(sc, 0xF8F6, 0xC502);
2271         MP_WriteMcuAccessRegWord(sc, 0xF8F8, 0xBD00);
2272         MP_WriteMcuAccessRegWord(sc, 0xF8FA, 0x0000);
2273         MP_WriteMcuAccessRegWord(sc, 0xF8FC, 0xC602);
2274         MP_WriteMcuAccessRegWord(sc, 0xF8FE, 0xBE00);
2275         MP_WriteMcuAccessRegWord(sc, 0xF900, 0x0000);
2276
2277         MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000);
2278
2279         MP_WriteMcuAccessRegWord(sc, 0xFC28, 0x00E2);
2280         MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x0210);
2281         MP_WriteMcuAccessRegWord(sc, 0xFC2C, 0x1A04);
2282         MP_WriteMcuAccessRegWord(sc, 0xFC2E, 0x0B26);
2283         MP_WriteMcuAccessRegWord(sc, 0xFC30, 0x0F02);
2284         MP_WriteMcuAccessRegWord(sc, 0xFC32, 0x0CA0);
2285
2286         if (sc->re_device_id == RT_DEVICEID_8136)
2287                 MP_WriteMcuAccessRegWord(sc, 0xFC38, 0x0033);
2288         else
2289                 MP_WriteMcuAccessRegWord(sc, 0xFC38, 0x003F);
2290 }
2291
2292 static void re_set_mac_mcu_8168fp_1(struct re_softc *sc)
2293 {
2294         DisableMcuBPs(sc);
2295
2296         MP_WriteMcuAccessRegWord(sc, 0xF800, 0xE00A);
2297         MP_WriteMcuAccessRegWord(sc, 0xF802, 0xE0C1);
2298         MP_WriteMcuAccessRegWord(sc, 0xF804, 0xE104);
2299         MP_WriteMcuAccessRegWord(sc, 0xF806, 0xE108);
2300         MP_WriteMcuAccessRegWord(sc, 0xF808, 0xE10D);
2301         MP_WriteMcuAccessRegWord(sc, 0xF80A, 0xE112);
2302         MP_WriteMcuAccessRegWord(sc, 0xF80C, 0xE11C);
2303         MP_WriteMcuAccessRegWord(sc, 0xF80E, 0xE121);
2304         MP_WriteMcuAccessRegWord(sc, 0xF810, 0xE000);
2305         MP_WriteMcuAccessRegWord(sc, 0xF812, 0xE0C8);
2306         MP_WriteMcuAccessRegWord(sc, 0xF814, 0xB400);
2307         MP_WriteMcuAccessRegWord(sc, 0xF816, 0xC1FE);
2308         MP_WriteMcuAccessRegWord(sc, 0xF818, 0x49E2);
2309         MP_WriteMcuAccessRegWord(sc, 0xF81A, 0xF04C);
2310         MP_WriteMcuAccessRegWord(sc, 0xF81C, 0x49EA);
2311         MP_WriteMcuAccessRegWord(sc, 0xF81E, 0xF04A);
2312         MP_WriteMcuAccessRegWord(sc, 0xF820, 0x74E6);
2313         MP_WriteMcuAccessRegWord(sc, 0xF822, 0xC246);
2314         MP_WriteMcuAccessRegWord(sc, 0xF824, 0x7542);
2315         MP_WriteMcuAccessRegWord(sc, 0xF826, 0x73EC);
2316         MP_WriteMcuAccessRegWord(sc, 0xF828, 0x1800);
2317         MP_WriteMcuAccessRegWord(sc, 0xF82A, 0x49C0);
2318         MP_WriteMcuAccessRegWord(sc, 0xF82C, 0xF10D);
2319         MP_WriteMcuAccessRegWord(sc, 0xF82E, 0x49C1);
2320         MP_WriteMcuAccessRegWord(sc, 0xF830, 0xF10B);
2321         MP_WriteMcuAccessRegWord(sc, 0xF832, 0x49C2);
2322         MP_WriteMcuAccessRegWord(sc, 0xF834, 0xF109);
2323         MP_WriteMcuAccessRegWord(sc, 0xF836, 0x49B0);
2324         MP_WriteMcuAccessRegWord(sc, 0xF838, 0xF107);
2325         MP_WriteMcuAccessRegWord(sc, 0xF83A, 0x49B1);
2326         MP_WriteMcuAccessRegWord(sc, 0xF83C, 0xF105);
2327         MP_WriteMcuAccessRegWord(sc, 0xF83E, 0x7220);
2328         MP_WriteMcuAccessRegWord(sc, 0xF840, 0x49A2);
2329         MP_WriteMcuAccessRegWord(sc, 0xF842, 0xF102);
2330         MP_WriteMcuAccessRegWord(sc, 0xF844, 0xE002);
2331         MP_WriteMcuAccessRegWord(sc, 0xF846, 0x4800);
2332         MP_WriteMcuAccessRegWord(sc, 0xF848, 0x49D0);
2333         MP_WriteMcuAccessRegWord(sc, 0xF84A, 0xF10A);
2334         MP_WriteMcuAccessRegWord(sc, 0xF84C, 0x49D1);
2335         MP_WriteMcuAccessRegWord(sc, 0xF84E, 0xF108);
2336         MP_WriteMcuAccessRegWord(sc, 0xF850, 0x49D2);
2337         MP_WriteMcuAccessRegWord(sc, 0xF852, 0xF106);
2338         MP_WriteMcuAccessRegWord(sc, 0xF854, 0x49D3);
2339         MP_WriteMcuAccessRegWord(sc, 0xF856, 0xF104);
2340         MP_WriteMcuAccessRegWord(sc, 0xF858, 0x49DF);
2341         MP_WriteMcuAccessRegWord(sc, 0xF85A, 0xF102);
2342         MP_WriteMcuAccessRegWord(sc, 0xF85C, 0xE00C);
2343         MP_WriteMcuAccessRegWord(sc, 0xF85E, 0x4801);
2344         MP_WriteMcuAccessRegWord(sc, 0xF860, 0x72E4);
2345         MP_WriteMcuAccessRegWord(sc, 0xF862, 0x49AD);
2346         MP_WriteMcuAccessRegWord(sc, 0xF864, 0xF108);
2347         MP_WriteMcuAccessRegWord(sc, 0xF866, 0xC225);
2348         MP_WriteMcuAccessRegWord(sc, 0xF868, 0x6741);
2349         MP_WriteMcuAccessRegWord(sc, 0xF86A, 0x48F0);
2350         MP_WriteMcuAccessRegWord(sc, 0xF86C, 0x8F41);
2351         MP_WriteMcuAccessRegWord(sc, 0xF86E, 0x4870);
2352         MP_WriteMcuAccessRegWord(sc, 0xF870, 0x8F41);
2353         MP_WriteMcuAccessRegWord(sc, 0xF872, 0xC7CF);
2354         MP_WriteMcuAccessRegWord(sc, 0xF874, 0x49B5);
2355         MP_WriteMcuAccessRegWord(sc, 0xF876, 0xF01F);
2356         MP_WriteMcuAccessRegWord(sc, 0xF878, 0x49B2);
2357         MP_WriteMcuAccessRegWord(sc, 0xF87A, 0xF00B);
2358         MP_WriteMcuAccessRegWord(sc, 0xF87C, 0x4980);
2359         MP_WriteMcuAccessRegWord(sc, 0xF87E, 0xF003);
2360         MP_WriteMcuAccessRegWord(sc, 0xF880, 0x484E);
2361         MP_WriteMcuAccessRegWord(sc, 0xF882, 0x94E7);
2362         MP_WriteMcuAccessRegWord(sc, 0xF884, 0x4981);
2363         MP_WriteMcuAccessRegWord(sc, 0xF886, 0xF004);
2364         MP_WriteMcuAccessRegWord(sc, 0xF888, 0x485E);
2365         MP_WriteMcuAccessRegWord(sc, 0xF88A, 0xC212);
2366         MP_WriteMcuAccessRegWord(sc, 0xF88C, 0x9543);
2367         MP_WriteMcuAccessRegWord(sc, 0xF88E, 0xE071);
2368         MP_WriteMcuAccessRegWord(sc, 0xF890, 0x49B6);
2369         MP_WriteMcuAccessRegWord(sc, 0xF892, 0xF003);
2370         MP_WriteMcuAccessRegWord(sc, 0xF894, 0x49B3);
2371         MP_WriteMcuAccessRegWord(sc, 0xF896, 0xF10F);
2372         MP_WriteMcuAccessRegWord(sc, 0xF898, 0x4980);
2373         MP_WriteMcuAccessRegWord(sc, 0xF89A, 0xF003);
2374         MP_WriteMcuAccessRegWord(sc, 0xF89C, 0x484E);
2375         MP_WriteMcuAccessRegWord(sc, 0xF89E, 0x94E7);
2376         MP_WriteMcuAccessRegWord(sc, 0xF8A0, 0x4981);
2377         MP_WriteMcuAccessRegWord(sc, 0xF8A2, 0xF004);
2378         MP_WriteMcuAccessRegWord(sc, 0xF8A4, 0x485E);
2379         MP_WriteMcuAccessRegWord(sc, 0xF8A6, 0xC204);
2380         MP_WriteMcuAccessRegWord(sc, 0xF8A8, 0x9543);
2381         MP_WriteMcuAccessRegWord(sc, 0xF8AA, 0xE005);
2382         MP_WriteMcuAccessRegWord(sc, 0xF8AC, 0xE000);
2383         MP_WriteMcuAccessRegWord(sc, 0xF8AE, 0xE0FC);
2384         MP_WriteMcuAccessRegWord(sc, 0xF8B0, 0xE0FA);
2385         MP_WriteMcuAccessRegWord(sc, 0xF8B2, 0xE065);
2386         MP_WriteMcuAccessRegWord(sc, 0xF8B4, 0x49B7);
2387         MP_WriteMcuAccessRegWord(sc, 0xF8B6, 0xF007);
2388         MP_WriteMcuAccessRegWord(sc, 0xF8B8, 0x4980);
2389         MP_WriteMcuAccessRegWord(sc, 0xF8BA, 0xF005);
2390         MP_WriteMcuAccessRegWord(sc, 0xF8BC, 0x1A38);
2391         MP_WriteMcuAccessRegWord(sc, 0xF8BE, 0x46D4);
2392         MP_WriteMcuAccessRegWord(sc, 0xF8C0, 0x1200);
2393         MP_WriteMcuAccessRegWord(sc, 0xF8C2, 0xF109);
2394         MP_WriteMcuAccessRegWord(sc, 0xF8C4, 0x4981);
2395         MP_WriteMcuAccessRegWord(sc, 0xF8C6, 0xF055);
2396         MP_WriteMcuAccessRegWord(sc, 0xF8C8, 0x49C3);
2397         MP_WriteMcuAccessRegWord(sc, 0xF8CA, 0xF105);
2398         MP_WriteMcuAccessRegWord(sc, 0xF8CC, 0x1A30);
2399         MP_WriteMcuAccessRegWord(sc, 0xF8CE, 0x46D5);
2400         MP_WriteMcuAccessRegWord(sc, 0xF8D0, 0x1200);
2401         MP_WriteMcuAccessRegWord(sc, 0xF8D2, 0xF04F);
2402         MP_WriteMcuAccessRegWord(sc, 0xF8D4, 0x7220);
2403         MP_WriteMcuAccessRegWord(sc, 0xF8D6, 0x49A2);
2404         MP_WriteMcuAccessRegWord(sc, 0xF8D8, 0xF130);
2405         MP_WriteMcuAccessRegWord(sc, 0xF8DA, 0x49C1);
2406         MP_WriteMcuAccessRegWord(sc, 0xF8DC, 0xF12E);
2407         MP_WriteMcuAccessRegWord(sc, 0xF8DE, 0x49B0);
2408         MP_WriteMcuAccessRegWord(sc, 0xF8E0, 0xF12C);
2409         MP_WriteMcuAccessRegWord(sc, 0xF8E2, 0xC2E6);
2410         MP_WriteMcuAccessRegWord(sc, 0xF8E4, 0x7240);
2411         MP_WriteMcuAccessRegWord(sc, 0xF8E6, 0x49A8);
2412         MP_WriteMcuAccessRegWord(sc, 0xF8E8, 0xF003);
2413         MP_WriteMcuAccessRegWord(sc, 0xF8EA, 0x49D0);
2414         MP_WriteMcuAccessRegWord(sc, 0xF8EC, 0xF126);
2415         MP_WriteMcuAccessRegWord(sc, 0xF8EE, 0x49A9);
2416         MP_WriteMcuAccessRegWord(sc, 0xF8F0, 0xF003);
2417         MP_WriteMcuAccessRegWord(sc, 0xF8F2, 0x49D1);
2418         MP_WriteMcuAccessRegWord(sc, 0xF8F4, 0xF122);
2419         MP_WriteMcuAccessRegWord(sc, 0xF8F6, 0x49AA);
2420         MP_WriteMcuAccessRegWord(sc, 0xF8F8, 0xF003);
2421         MP_WriteMcuAccessRegWord(sc, 0xF8FA, 0x49D2);
2422         MP_WriteMcuAccessRegWord(sc, 0xF8FC, 0xF11E);
2423         MP_WriteMcuAccessRegWord(sc, 0xF8FE, 0x49AB);
2424         MP_WriteMcuAccessRegWord(sc, 0xF900, 0xF003);
2425         MP_WriteMcuAccessRegWord(sc, 0xF902, 0x49DF);
2426         MP_WriteMcuAccessRegWord(sc, 0xF904, 0xF11A);
2427         MP_WriteMcuAccessRegWord(sc, 0xF906, 0x49AC);
2428         MP_WriteMcuAccessRegWord(sc, 0xF908, 0xF003);
2429         MP_WriteMcuAccessRegWord(sc, 0xF90A, 0x49D3);
2430         MP_WriteMcuAccessRegWord(sc, 0xF90C, 0xF116);
2431         MP_WriteMcuAccessRegWord(sc, 0xF90E, 0x4980);
2432         MP_WriteMcuAccessRegWord(sc, 0xF910, 0xF003);
2433         MP_WriteMcuAccessRegWord(sc, 0xF912, 0x49C7);
2434         MP_WriteMcuAccessRegWord(sc, 0xF914, 0xF105);
2435         MP_WriteMcuAccessRegWord(sc, 0xF916, 0x4981);
2436         MP_WriteMcuAccessRegWord(sc, 0xF918, 0xF02C);
2437         MP_WriteMcuAccessRegWord(sc, 0xF91A, 0x49D7);
2438         MP_WriteMcuAccessRegWord(sc, 0xF91C, 0xF02A);
2439         MP_WriteMcuAccessRegWord(sc, 0xF91E, 0x49C0);
2440         MP_WriteMcuAccessRegWord(sc, 0xF920, 0xF00C);
2441         MP_WriteMcuAccessRegWord(sc, 0xF922, 0xC721);
2442         MP_WriteMcuAccessRegWord(sc, 0xF924, 0x62F4);
2443         MP_WriteMcuAccessRegWord(sc, 0xF926, 0x49A0);
2444         MP_WriteMcuAccessRegWord(sc, 0xF928, 0xF008);
2445         MP_WriteMcuAccessRegWord(sc, 0xF92A, 0x49A4);
2446         MP_WriteMcuAccessRegWord(sc, 0xF92C, 0xF106);
2447         MP_WriteMcuAccessRegWord(sc, 0xF92E, 0x4824);
2448         MP_WriteMcuAccessRegWord(sc, 0xF930, 0x8AF4);
2449         MP_WriteMcuAccessRegWord(sc, 0xF932, 0xC71A);
2450         MP_WriteMcuAccessRegWord(sc, 0xF934, 0x1A40);
2451         MP_WriteMcuAccessRegWord(sc, 0xF936, 0x9AE0);
2452         MP_WriteMcuAccessRegWord(sc, 0xF938, 0x49B6);
2453         MP_WriteMcuAccessRegWord(sc, 0xF93A, 0xF017);
2454         MP_WriteMcuAccessRegWord(sc, 0xF93C, 0x200E);
2455         MP_WriteMcuAccessRegWord(sc, 0xF93E, 0xC7B8);
2456         MP_WriteMcuAccessRegWord(sc, 0xF940, 0x72E0);
2457         MP_WriteMcuAccessRegWord(sc, 0xF942, 0x4710);
2458         MP_WriteMcuAccessRegWord(sc, 0xF944, 0x92E1);
2459         MP_WriteMcuAccessRegWord(sc, 0xF946, 0xC70E);
2460         MP_WriteMcuAccessRegWord(sc, 0xF948, 0x77E0);
2461         MP_WriteMcuAccessRegWord(sc, 0xF94A, 0x49F0);
2462         MP_WriteMcuAccessRegWord(sc, 0xF94C, 0xF112);
2463         MP_WriteMcuAccessRegWord(sc, 0xF94E, 0xC70B);
2464         MP_WriteMcuAccessRegWord(sc, 0xF950, 0x77E0);
2465         MP_WriteMcuAccessRegWord(sc, 0xF952, 0x27FE);
2466         MP_WriteMcuAccessRegWord(sc, 0xF954, 0x1AFA);
2467         MP_WriteMcuAccessRegWord(sc, 0xF956, 0x4317);
2468         MP_WriteMcuAccessRegWord(sc, 0xF958, 0xC705);
2469         MP_WriteMcuAccessRegWord(sc, 0xF95A, 0x9AE2);
2470         MP_WriteMcuAccessRegWord(sc, 0xF95C, 0x1A11);
2471         MP_WriteMcuAccessRegWord(sc, 0xF95E, 0x8AE0);
2472         MP_WriteMcuAccessRegWord(sc, 0xF960, 0xE008);
2473         MP_WriteMcuAccessRegWord(sc, 0xF962, 0xE41C);
2474         MP_WriteMcuAccessRegWord(sc, 0xF964, 0xC0AE);
2475         MP_WriteMcuAccessRegWord(sc, 0xF966, 0xD23A);
2476         MP_WriteMcuAccessRegWord(sc, 0xF968, 0xC7A2);
2477         MP_WriteMcuAccessRegWord(sc, 0xF96A, 0x74E6);
2478         MP_WriteMcuAccessRegWord(sc, 0xF96C, 0x484F);
2479         MP_WriteMcuAccessRegWord(sc, 0xF96E, 0x94E7);
2480         MP_WriteMcuAccessRegWord(sc, 0xF970, 0xC79E);
2481         MP_WriteMcuAccessRegWord(sc, 0xF972, 0x8CE6);
2482         MP_WriteMcuAccessRegWord(sc, 0xF974, 0x8BEC);
2483         MP_WriteMcuAccessRegWord(sc, 0xF976, 0xC29C);
2484         MP_WriteMcuAccessRegWord(sc, 0xF978, 0x8D42);
2485         MP_WriteMcuAccessRegWord(sc, 0xF97A, 0x7220);
2486         MP_WriteMcuAccessRegWord(sc, 0xF97C, 0xB000);
2487         MP_WriteMcuAccessRegWord(sc, 0xF97E, 0xC502);
2488         MP_WriteMcuAccessRegWord(sc, 0xF980, 0xBD00);
2489         MP_WriteMcuAccessRegWord(sc, 0xF982, 0x0932);
2490         MP_WriteMcuAccessRegWord(sc, 0xF984, 0xB400);
2491         MP_WriteMcuAccessRegWord(sc, 0xF986, 0xC240);
2492         MP_WriteMcuAccessRegWord(sc, 0xF988, 0xC340);
2493         MP_WriteMcuAccessRegWord(sc, 0xF98A, 0x7060);
2494         MP_WriteMcuAccessRegWord(sc, 0xF98C, 0x498F);
2495         MP_WriteMcuAccessRegWord(sc, 0xF98E, 0xF014);
2496         MP_WriteMcuAccessRegWord(sc, 0xF990, 0x488F);
2497         MP_WriteMcuAccessRegWord(sc, 0xF992, 0x9061);
2498         MP_WriteMcuAccessRegWord(sc, 0xF994, 0x744C);
2499         MP_WriteMcuAccessRegWord(sc, 0xF996, 0x49C3);
2500         MP_WriteMcuAccessRegWord(sc, 0xF998, 0xF004);
2501         MP_WriteMcuAccessRegWord(sc, 0xF99A, 0x7562);
2502         MP_WriteMcuAccessRegWord(sc, 0xF99C, 0x485E);
2503         MP_WriteMcuAccessRegWord(sc, 0xF99E, 0x9563);
2504         MP_WriteMcuAccessRegWord(sc, 0xF9A0, 0x7446);
2505         MP_WriteMcuAccessRegWord(sc, 0xF9A2, 0x49C3);
2506         MP_WriteMcuAccessRegWord(sc, 0xF9A4, 0xF106);
2507         MP_WriteMcuAccessRegWord(sc, 0xF9A6, 0x7562);
2508         MP_WriteMcuAccessRegWord(sc, 0xF9A8, 0x1C30);
2509         MP_WriteMcuAccessRegWord(sc, 0xF9AA, 0x46E5);
2510         MP_WriteMcuAccessRegWord(sc, 0xF9AC, 0x1200);
2511         MP_WriteMcuAccessRegWord(sc, 0xF9AE, 0xF004);
2512         MP_WriteMcuAccessRegWord(sc, 0xF9B0, 0x7446);
2513         MP_WriteMcuAccessRegWord(sc, 0xF9B2, 0x484F);
2514         MP_WriteMcuAccessRegWord(sc, 0xF9B4, 0x9447);
2515         MP_WriteMcuAccessRegWord(sc, 0xF9B6, 0xC32A);
2516         MP_WriteMcuAccessRegWord(sc, 0xF9B8, 0x7466);
2517         MP_WriteMcuAccessRegWord(sc, 0xF9BA, 0x49C0);
2518         MP_WriteMcuAccessRegWord(sc, 0xF9BC, 0xF00F);
2519         MP_WriteMcuAccessRegWord(sc, 0xF9BE, 0x48C0);
2520         MP_WriteMcuAccessRegWord(sc, 0xF9C0, 0x9C66);
2521         MP_WriteMcuAccessRegWord(sc, 0xF9C2, 0x7446);
2522         MP_WriteMcuAccessRegWord(sc, 0xF9C4, 0x4840);
2523         MP_WriteMcuAccessRegWord(sc, 0xF9C6, 0x4841);
2524         MP_WriteMcuAccessRegWord(sc, 0xF9C8, 0x4842);
2525         MP_WriteMcuAccessRegWord(sc, 0xF9CA, 0x9C46);
2526         MP_WriteMcuAccessRegWord(sc, 0xF9CC, 0x744C);
2527         MP_WriteMcuAccessRegWord(sc, 0xF9CE, 0x4840);
2528         MP_WriteMcuAccessRegWord(sc, 0xF9D0, 0x9C4C);
2529         MP_WriteMcuAccessRegWord(sc, 0xF9D2, 0x744A);
2530         MP_WriteMcuAccessRegWord(sc, 0xF9D4, 0x484A);
2531         MP_WriteMcuAccessRegWord(sc, 0xF9D6, 0x9C4A);
2532         MP_WriteMcuAccessRegWord(sc, 0xF9D8, 0xE013);
2533         MP_WriteMcuAccessRegWord(sc, 0xF9DA, 0x498E);
2534         MP_WriteMcuAccessRegWord(sc, 0xF9DC, 0xF011);
2535         MP_WriteMcuAccessRegWord(sc, 0xF9DE, 0x488E);
2536         MP_WriteMcuAccessRegWord(sc, 0xF9E0, 0x9061);
2537         MP_WriteMcuAccessRegWord(sc, 0xF9E2, 0x744C);
2538         MP_WriteMcuAccessRegWord(sc, 0xF9E4, 0x49C3);
2539         MP_WriteMcuAccessRegWord(sc, 0xF9E6, 0xF004);
2540         MP_WriteMcuAccessRegWord(sc, 0xF9E8, 0x7446);
2541         MP_WriteMcuAccessRegWord(sc, 0xF9EA, 0x484E);
2542         MP_WriteMcuAccessRegWord(sc, 0xF9EC, 0x9447);
2543         MP_WriteMcuAccessRegWord(sc, 0xF9EE, 0x7446);
2544         MP_WriteMcuAccessRegWord(sc, 0xF9F0, 0x1D38);
2545         MP_WriteMcuAccessRegWord(sc, 0xF9F2, 0x46EC);
2546         MP_WriteMcuAccessRegWord(sc, 0xF9F4, 0x1500);
2547         MP_WriteMcuAccessRegWord(sc, 0xF9F6, 0xF004);
2548         MP_WriteMcuAccessRegWord(sc, 0xF9F8, 0x7446);
2549         MP_WriteMcuAccessRegWord(sc, 0xF9FA, 0x484F);
2550         MP_WriteMcuAccessRegWord(sc, 0xF9FC, 0x9447);
2551         MP_WriteMcuAccessRegWord(sc, 0xF9FE, 0xB000);
2552         MP_WriteMcuAccessRegWord(sc, 0xFA00, 0xC502);
2553         MP_WriteMcuAccessRegWord(sc, 0xFA02, 0xBD00);
2554         MP_WriteMcuAccessRegWord(sc, 0xFA04, 0x074C);
2555         MP_WriteMcuAccessRegWord(sc, 0xFA06, 0xE000);
2556         MP_WriteMcuAccessRegWord(sc, 0xFA08, 0xE0FC);
2557         MP_WriteMcuAccessRegWord(sc, 0xFA0A, 0xE0C0);
2558         MP_WriteMcuAccessRegWord(sc, 0xFA0C, 0x4830);
2559         MP_WriteMcuAccessRegWord(sc, 0xFA0E, 0x4837);
2560         MP_WriteMcuAccessRegWord(sc, 0xFA10, 0xC502);
2561         MP_WriteMcuAccessRegWord(sc, 0xFA12, 0xBD00);
2562         MP_WriteMcuAccessRegWord(sc, 0xFA14, 0x0978);
2563         MP_WriteMcuAccessRegWord(sc, 0xFA16, 0x63E2);
2564         MP_WriteMcuAccessRegWord(sc, 0xFA18, 0x4830);
2565         MP_WriteMcuAccessRegWord(sc, 0xFA1A, 0x4837);
2566         MP_WriteMcuAccessRegWord(sc, 0xFA1C, 0xC502);
2567         MP_WriteMcuAccessRegWord(sc, 0xFA1E, 0xBD00);
2568         MP_WriteMcuAccessRegWord(sc, 0xFA20, 0x09FE);
2569         MP_WriteMcuAccessRegWord(sc, 0xFA22, 0x73E2);
2570         MP_WriteMcuAccessRegWord(sc, 0xFA24, 0x4830);
2571         MP_WriteMcuAccessRegWord(sc, 0xFA26, 0x8BE2);
2572         MP_WriteMcuAccessRegWord(sc, 0xFA28, 0xC302);
2573         MP_WriteMcuAccessRegWord(sc, 0xFA2A, 0xBB00);
2574         MP_WriteMcuAccessRegWord(sc, 0xFA2C, 0x0A12);
2575         MP_WriteMcuAccessRegWord(sc, 0xFA2E, 0x73E2);
2576         MP_WriteMcuAccessRegWord(sc, 0xFA30, 0x48B0);
2577         MP_WriteMcuAccessRegWord(sc, 0xFA32, 0x48B3);
2578         MP_WriteMcuAccessRegWord(sc, 0xFA34, 0x48B4);
2579         MP_WriteMcuAccessRegWord(sc, 0xFA36, 0x48B5);
2580         MP_WriteMcuAccessRegWord(sc, 0xFA38, 0x48B6);
2581         MP_WriteMcuAccessRegWord(sc, 0xFA3A, 0x48B7);
2582         MP_WriteMcuAccessRegWord(sc, 0xFA3C, 0x8BE2);
2583         MP_WriteMcuAccessRegWord(sc, 0xFA3E, 0xC302);
2584         MP_WriteMcuAccessRegWord(sc, 0xFA40, 0xBB00);
2585         MP_WriteMcuAccessRegWord(sc, 0xFA42, 0x0A5A);
2586         MP_WriteMcuAccessRegWord(sc, 0xFA44, 0x73E2);
2587         MP_WriteMcuAccessRegWord(sc, 0xFA46, 0x4830);
2588         MP_WriteMcuAccessRegWord(sc, 0xFA48, 0x8BE2);
2589         MP_WriteMcuAccessRegWord(sc, 0xFA4A, 0xC302);
2590         MP_WriteMcuAccessRegWord(sc, 0xFA4C, 0xBB00);
2591         MP_WriteMcuAccessRegWord(sc, 0xFA4E, 0x0A6C);
2592         MP_WriteMcuAccessRegWord(sc, 0xFA50, 0x73E2);
2593         MP_WriteMcuAccessRegWord(sc, 0xFA52, 0x4830);
2594         MP_WriteMcuAccessRegWord(sc, 0xFA54, 0x4837);
2595         MP_WriteMcuAccessRegWord(sc, 0xFA56, 0xC502);
2596         MP_WriteMcuAccessRegWord(sc, 0xFA58, 0xBD00);
2597         MP_WriteMcuAccessRegWord(sc, 0xFA5A, 0x0A86);
2598
2599         MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000);
2600
2601         MP_WriteMcuAccessRegWord(sc, 0xFC28, 0x0890);
2602         MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x0712);
2603         MP_WriteMcuAccessRegWord(sc, 0xFC2C, 0x0974);
2604         MP_WriteMcuAccessRegWord(sc, 0xFC2E, 0x09FC);
2605         MP_WriteMcuAccessRegWord(sc, 0xFC30, 0x0A0E);
2606         MP_WriteMcuAccessRegWord(sc, 0xFC32, 0x0A56);
2607         MP_WriteMcuAccessRegWord(sc, 0xFC34, 0x0A68);
2608         MP_WriteMcuAccessRegWord(sc, 0xFC36, 0x0A84);
2609
2610         if (sc->HwPkgDet == 0x0)
2611                 MP_WriteMcuAccessRegWord(sc, 0xFC38, 0x00FC);
2612         else if(sc->HwPkgDet == 0xF)
2613                 MP_WriteMcuAccessRegWord(sc, 0xFC38, 0x00FF);
2614 }
2615
2616 static void re_set_mac_mcu_8168fp_2(struct re_softc *sc)
2617 {
2618         DisableMcuBPs(sc);
2619
2620         MP_WriteMcuAccessRegWord(sc, 0xF800, 0xE008);
2621         MP_WriteMcuAccessRegWord(sc, 0xF802, 0xE00A);
2622         MP_WriteMcuAccessRegWord(sc, 0xF804, 0xE031);
2623         MP_WriteMcuAccessRegWord(sc, 0xF806, 0xE033);
2624         MP_WriteMcuAccessRegWord(sc, 0xF808, 0xE035);
2625         MP_WriteMcuAccessRegWord(sc, 0xF80A, 0xE144);
2626         MP_WriteMcuAccessRegWord(sc, 0xF80C, 0xE166);
2627         MP_WriteMcuAccessRegWord(sc, 0xF80E, 0xE168);
2628         MP_WriteMcuAccessRegWord(sc, 0xF810, 0xC502);
2629         MP_WriteMcuAccessRegWord(sc, 0xF812, 0xBD00);
2630         MP_WriteMcuAccessRegWord(sc, 0xF814, 0x0000);
2631         MP_WriteMcuAccessRegWord(sc, 0xF816, 0xC725);
2632         MP_WriteMcuAccessRegWord(sc, 0xF818, 0x75E0);
2633         MP_WriteMcuAccessRegWord(sc, 0xF81A, 0x48D0);
2634         MP_WriteMcuAccessRegWord(sc, 0xF81C, 0x9DE0);
2635         MP_WriteMcuAccessRegWord(sc, 0xF81E, 0xC722);
2636         MP_WriteMcuAccessRegWord(sc, 0xF820, 0x75E0);
2637         MP_WriteMcuAccessRegWord(sc, 0xF822, 0x1C78);
2638         MP_WriteMcuAccessRegWord(sc, 0xF824, 0x416C);
2639         MP_WriteMcuAccessRegWord(sc, 0xF826, 0x1530);
2640         MP_WriteMcuAccessRegWord(sc, 0xF828, 0xF111);
2641         MP_WriteMcuAccessRegWord(sc, 0xF82A, 0xC71D);
2642         MP_WriteMcuAccessRegWord(sc, 0xF82C, 0x75F6);
2643         MP_WriteMcuAccessRegWord(sc, 0xF82E, 0x49D1);
2644         MP_WriteMcuAccessRegWord(sc, 0xF830, 0xF00D);
2645         MP_WriteMcuAccessRegWord(sc, 0xF832, 0x75E0);
2646         MP_WriteMcuAccessRegWord(sc, 0xF834, 0x1C1F);
2647         MP_WriteMcuAccessRegWord(sc, 0xF836, 0x416C);
2648         MP_WriteMcuAccessRegWord(sc, 0xF838, 0x1502);
2649         MP_WriteMcuAccessRegWord(sc, 0xF83A, 0xF108);
2650         MP_WriteMcuAccessRegWord(sc, 0xF83C, 0x75FA);
2651         MP_WriteMcuAccessRegWord(sc, 0xF83E, 0x49D3);
2652         MP_WriteMcuAccessRegWord(sc, 0xF840, 0xF005);
2653         MP_WriteMcuAccessRegWord(sc, 0xF842, 0x75EC);
2654         MP_WriteMcuAccessRegWord(sc, 0xF844, 0x9DE4);
2655         MP_WriteMcuAccessRegWord(sc, 0xF846, 0x4853);
2656         MP_WriteMcuAccessRegWord(sc, 0xF848, 0x9DFA);
2657         MP_WriteMcuAccessRegWord(sc, 0xF84A, 0xC70B);
2658         MP_WriteMcuAccessRegWord(sc, 0xF84C, 0x75E0);
2659         MP_WriteMcuAccessRegWord(sc, 0xF84E, 0x4852);
2660         MP_WriteMcuAccessRegWord(sc, 0xF850, 0x4850);
2661         MP_WriteMcuAccessRegWord(sc, 0xF852, 0x9DE0);
2662         MP_WriteMcuAccessRegWord(sc, 0xF854, 0xC602);
2663         MP_WriteMcuAccessRegWord(sc, 0xF856, 0xBE00);
2664         MP_WriteMcuAccessRegWord(sc, 0xF858, 0x04B8);
2665         MP_WriteMcuAccessRegWord(sc, 0xF85A, 0xE420);
2666         MP_WriteMcuAccessRegWord(sc, 0xF85C, 0xE000);
2667         MP_WriteMcuAccessRegWord(sc, 0xF85E, 0xE0FC);
2668         MP_WriteMcuAccessRegWord(sc, 0xF860, 0xE43C);
2669         MP_WriteMcuAccessRegWord(sc, 0xF862, 0xDC00);
2670         MP_WriteMcuAccessRegWord(sc, 0xF864, 0xEB00);
2671         MP_WriteMcuAccessRegWord(sc, 0xF866, 0xC202);
2672         MP_WriteMcuAccessRegWord(sc, 0xF868, 0xBA00);
2673         MP_WriteMcuAccessRegWord(sc, 0xF86A, 0x0000);
2674         MP_WriteMcuAccessRegWord(sc, 0xF86C, 0xC002);
2675         MP_WriteMcuAccessRegWord(sc, 0xF86E, 0xB800);
2676         MP_WriteMcuAccessRegWord(sc, 0xF870, 0x0000);
2677         MP_WriteMcuAccessRegWord(sc, 0xF872, 0xB401);
2678         MP_WriteMcuAccessRegWord(sc, 0xF874, 0xB402);
2679         MP_WriteMcuAccessRegWord(sc, 0xF876, 0xB403);
2680         MP_WriteMcuAccessRegWord(sc, 0xF878, 0xB404);
2681         MP_WriteMcuAccessRegWord(sc, 0xF87A, 0xB405);
2682         MP_WriteMcuAccessRegWord(sc, 0xF87C, 0xB406);
2683         MP_WriteMcuAccessRegWord(sc, 0xF87E, 0xC44D);
2684         MP_WriteMcuAccessRegWord(sc, 0xF880, 0xC54D);
2685         MP_WriteMcuAccessRegWord(sc, 0xF882, 0x1867);
2686         MP_WriteMcuAccessRegWord(sc, 0xF884, 0xE8A2);
2687         MP_WriteMcuAccessRegWord(sc, 0xF886, 0x2318);
2688         MP_WriteMcuAccessRegWord(sc, 0xF888, 0x276E);
2689         MP_WriteMcuAccessRegWord(sc, 0xF88A, 0x1601);
2690         MP_WriteMcuAccessRegWord(sc, 0xF88C, 0xF106);
2691         MP_WriteMcuAccessRegWord(sc, 0xF88E, 0x1A07);
2692         MP_WriteMcuAccessRegWord(sc, 0xF890, 0xE861);
2693         MP_WriteMcuAccessRegWord(sc, 0xF892, 0xE86B);
2694         MP_WriteMcuAccessRegWord(sc, 0xF894, 0xE873);
2695         MP_WriteMcuAccessRegWord(sc, 0xF896, 0xE037);
2696         MP_WriteMcuAccessRegWord(sc, 0xF898, 0x231E);
2697         MP_WriteMcuAccessRegWord(sc, 0xF89A, 0x276E);
2698         MP_WriteMcuAccessRegWord(sc, 0xF89C, 0x1602);
2699         MP_WriteMcuAccessRegWord(sc, 0xF89E, 0xF10B);
2700         MP_WriteMcuAccessRegWord(sc, 0xF8A0, 0x1A07);
2701         MP_WriteMcuAccessRegWord(sc, 0xF8A2, 0xE858);
2702         MP_WriteMcuAccessRegWord(sc, 0xF8A4, 0xE862);
2703         MP_WriteMcuAccessRegWord(sc, 0xF8A6, 0xC247);
2704         MP_WriteMcuAccessRegWord(sc, 0xF8A8, 0xC344);
2705         MP_WriteMcuAccessRegWord(sc, 0xF8AA, 0xE8E3);
2706         MP_WriteMcuAccessRegWord(sc, 0xF8AC, 0xC73B);
2707         MP_WriteMcuAccessRegWord(sc, 0xF8AE, 0x66E0);
2708         MP_WriteMcuAccessRegWord(sc, 0xF8B0, 0xE8B5);
2709         MP_WriteMcuAccessRegWord(sc, 0xF8B2, 0xE029);
2710         MP_WriteMcuAccessRegWord(sc, 0xF8B4, 0x231A);
2711         MP_WriteMcuAccessRegWord(sc, 0xF8B6, 0x276C);
2712         MP_WriteMcuAccessRegWord(sc, 0xF8B8, 0xC733);
2713         MP_WriteMcuAccessRegWord(sc, 0xF8BA, 0x9EE0);
2714         MP_WriteMcuAccessRegWord(sc, 0xF8BC, 0x1866);
2715         MP_WriteMcuAccessRegWord(sc, 0xF8BE, 0xE885);
2716         MP_WriteMcuAccessRegWord(sc, 0xF8C0, 0x251C);
2717         MP_WriteMcuAccessRegWord(sc, 0xF8C2, 0x120F);
2718         MP_WriteMcuAccessRegWord(sc, 0xF8C4, 0xF011);
2719         MP_WriteMcuAccessRegWord(sc, 0xF8C6, 0x1209);
2720         MP_WriteMcuAccessRegWord(sc, 0xF8C8, 0xF011);
2721         MP_WriteMcuAccessRegWord(sc, 0xF8CA, 0x2014);
2722         MP_WriteMcuAccessRegWord(sc, 0xF8CC, 0x240E);
2723         MP_WriteMcuAccessRegWord(sc, 0xF8CE, 0x1000);
2724         MP_WriteMcuAccessRegWord(sc, 0xF8D0, 0xF007);
2725         MP_WriteMcuAccessRegWord(sc, 0xF8D2, 0x120C);
2726         MP_WriteMcuAccessRegWord(sc, 0xF8D4, 0xF00D);
2727         MP_WriteMcuAccessRegWord(sc, 0xF8D6, 0x1203);
2728         MP_WriteMcuAccessRegWord(sc, 0xF8D8, 0xF00D);
2729         MP_WriteMcuAccessRegWord(sc, 0xF8DA, 0x1200);
2730         MP_WriteMcuAccessRegWord(sc, 0xF8DC, 0xF00D);
2731         MP_WriteMcuAccessRegWord(sc, 0xF8DE, 0x120C);
2732         MP_WriteMcuAccessRegWord(sc, 0xF8E0, 0xF00D);
2733         MP_WriteMcuAccessRegWord(sc, 0xF8E2, 0x1203);
2734         MP_WriteMcuAccessRegWord(sc, 0xF8E4, 0xF00D);
2735         MP_WriteMcuAccessRegWord(sc, 0xF8E6, 0x1A03);
2736         MP_WriteMcuAccessRegWord(sc, 0xF8E8, 0xE00C);
2737         MP_WriteMcuAccessRegWord(sc, 0xF8EA, 0x1A07);
2738         MP_WriteMcuAccessRegWord(sc, 0xF8EC, 0xE00A);
2739         MP_WriteMcuAccessRegWord(sc, 0xF8EE, 0x1A00);
2740         MP_WriteMcuAccessRegWord(sc, 0xF8F0, 0xE008);
2741         MP_WriteMcuAccessRegWord(sc, 0xF8F2, 0x1A01);
2742         MP_WriteMcuAccessRegWord(sc, 0xF8F4, 0xE006);
2743         MP_WriteMcuAccessRegWord(sc, 0xF8F6, 0x1A02);
2744         MP_WriteMcuAccessRegWord(sc, 0xF8F8, 0xE004);
2745         MP_WriteMcuAccessRegWord(sc, 0xF8FA, 0x1A04);
2746         MP_WriteMcuAccessRegWord(sc, 0xF8FC, 0xE002);
2747         MP_WriteMcuAccessRegWord(sc, 0xF8FE, 0x1A05);
2748         MP_WriteMcuAccessRegWord(sc, 0xF900, 0xE829);
2749         MP_WriteMcuAccessRegWord(sc, 0xF902, 0xE833);
2750         MP_WriteMcuAccessRegWord(sc, 0xF904, 0xB006);
2751         MP_WriteMcuAccessRegWord(sc, 0xF906, 0xB005);
2752         MP_WriteMcuAccessRegWord(sc, 0xF908, 0xB004);
2753         MP_WriteMcuAccessRegWord(sc, 0xF90A, 0xB003);
2754         MP_WriteMcuAccessRegWord(sc, 0xF90C, 0xB002);
2755         MP_WriteMcuAccessRegWord(sc, 0xF90E, 0xB001);
2756         MP_WriteMcuAccessRegWord(sc, 0xF910, 0x60C4);
2757         MP_WriteMcuAccessRegWord(sc, 0xF912, 0xC702);
2758         MP_WriteMcuAccessRegWord(sc, 0xF914, 0xBF00);
2759         MP_WriteMcuAccessRegWord(sc, 0xF916, 0x2786);
2760         MP_WriteMcuAccessRegWord(sc, 0xF918, 0xDD00);
2761         MP_WriteMcuAccessRegWord(sc, 0xF91A, 0xD030);
2762         MP_WriteMcuAccessRegWord(sc, 0xF91C, 0xE0C4);
2763         MP_WriteMcuAccessRegWord(sc, 0xF91E, 0xE0F8);
2764         MP_WriteMcuAccessRegWord(sc, 0xF920, 0xDC42);
2765         MP_WriteMcuAccessRegWord(sc, 0xF922, 0xD3F0);
2766         MP_WriteMcuAccessRegWord(sc, 0xF924, 0x0000);
2767         MP_WriteMcuAccessRegWord(sc, 0xF926, 0x0004);
2768         MP_WriteMcuAccessRegWord(sc, 0xF928, 0x0007);
2769         MP_WriteMcuAccessRegWord(sc, 0xF92A, 0x0014);
2770         MP_WriteMcuAccessRegWord(sc, 0xF92C, 0x0090);
2771         MP_WriteMcuAccessRegWord(sc, 0xF92E, 0x1000);
2772         MP_WriteMcuAccessRegWord(sc, 0xF930, 0x0F00);
2773         MP_WriteMcuAccessRegWord(sc, 0xF932, 0x1004);
2774         MP_WriteMcuAccessRegWord(sc, 0xF934, 0x1008);
2775         MP_WriteMcuAccessRegWord(sc, 0xF936, 0x3000);
2776         MP_WriteMcuAccessRegWord(sc, 0xF938, 0x3004);
2777         MP_WriteMcuAccessRegWord(sc, 0xF93A, 0x3008);
2778         MP_WriteMcuAccessRegWord(sc, 0xF93C, 0x4000);
2779         MP_WriteMcuAccessRegWord(sc, 0xF93E, 0x7777);
2780         MP_WriteMcuAccessRegWord(sc, 0xF940, 0x8000);
2781         MP_WriteMcuAccessRegWord(sc, 0xF942, 0x8001);
2782         MP_WriteMcuAccessRegWord(sc, 0xF944, 0x8008);
2783         MP_WriteMcuAccessRegWord(sc, 0xF946, 0x8003);
2784         MP_WriteMcuAccessRegWord(sc, 0xF948, 0x8004);
2785         MP_WriteMcuAccessRegWord(sc, 0xF94A, 0xC000);
2786         MP_WriteMcuAccessRegWord(sc, 0xF94C, 0xC004);
2787         MP_WriteMcuAccessRegWord(sc, 0xF94E, 0xF004);
2788         MP_WriteMcuAccessRegWord(sc, 0xF950, 0xFFFF);
2789         MP_WriteMcuAccessRegWord(sc, 0xF952, 0xB406);
2790         MP_WriteMcuAccessRegWord(sc, 0xF954, 0xB407);
2791         MP_WriteMcuAccessRegWord(sc, 0xF956, 0xC6E5);
2792         MP_WriteMcuAccessRegWord(sc, 0xF958, 0x77C0);
2793         MP_WriteMcuAccessRegWord(sc, 0xF95A, 0x27F3);
2794         MP_WriteMcuAccessRegWord(sc, 0xF95C, 0x23F3);
2795         MP_WriteMcuAccessRegWord(sc, 0xF95E, 0x47FA);
2796         MP_WriteMcuAccessRegWord(sc, 0xF960, 0x9FC0);
2797         MP_WriteMcuAccessRegWord(sc, 0xF962, 0xB007);
2798         MP_WriteMcuAccessRegWord(sc, 0xF964, 0xB006);
2799         MP_WriteMcuAccessRegWord(sc, 0xF966, 0xFF80);
2800         MP_WriteMcuAccessRegWord(sc, 0xF968, 0xB405);
2801         MP_WriteMcuAccessRegWord(sc, 0xF96A, 0xB407);
2802         MP_WriteMcuAccessRegWord(sc, 0xF96C, 0xC7D8);
2803         MP_WriteMcuAccessRegWord(sc, 0xF96E, 0x75E0);
2804         MP_WriteMcuAccessRegWord(sc, 0xF970, 0x48D0);
2805         MP_WriteMcuAccessRegWord(sc, 0xF972, 0x9DE0);
2806         MP_WriteMcuAccessRegWord(sc, 0xF974, 0xB007);
2807         MP_WriteMcuAccessRegWord(sc, 0xF976, 0xB005);
2808         MP_WriteMcuAccessRegWord(sc, 0xF978, 0xFF80);
2809         MP_WriteMcuAccessRegWord(sc, 0xF97A, 0xB401);
2810         MP_WriteMcuAccessRegWord(sc, 0xF97C, 0xC0EA);
2811         MP_WriteMcuAccessRegWord(sc, 0xF97E, 0xC2DC);
2812         MP_WriteMcuAccessRegWord(sc, 0xF980, 0xC3D8);
2813         MP_WriteMcuAccessRegWord(sc, 0xF982, 0xE865);
2814         MP_WriteMcuAccessRegWord(sc, 0xF984, 0xC0D3);
2815         MP_WriteMcuAccessRegWord(sc, 0xF986, 0xC1E0);
2816         MP_WriteMcuAccessRegWord(sc, 0xF988, 0xC2E3);
2817         MP_WriteMcuAccessRegWord(sc, 0xF98A, 0xE861);
2818         MP_WriteMcuAccessRegWord(sc, 0xF98C, 0xE817);
2819         MP_WriteMcuAccessRegWord(sc, 0xF98E, 0xC0CD);
2820         MP_WriteMcuAccessRegWord(sc, 0xF990, 0xC2CF);
2821         MP_WriteMcuAccessRegWord(sc, 0xF992, 0xE85D);
2822         MP_WriteMcuAccessRegWord(sc, 0xF994, 0xC0C9);
2823         MP_WriteMcuAccessRegWord(sc, 0xF996, 0xC1D6);
2824         MP_WriteMcuAccessRegWord(sc, 0xF998, 0xC2DB);
2825         MP_WriteMcuAccessRegWord(sc, 0xF99A, 0xE859);
2826         MP_WriteMcuAccessRegWord(sc, 0xF99C, 0xE80F);
2827         MP_WriteMcuAccessRegWord(sc, 0xF99E, 0xC1C7);
2828         MP_WriteMcuAccessRegWord(sc, 0xF9A0, 0xC2CE);
2829         MP_WriteMcuAccessRegWord(sc, 0xF9A2, 0xE855);
2830         MP_WriteMcuAccessRegWord(sc, 0xF9A4, 0xC0C0);
2831         MP_WriteMcuAccessRegWord(sc, 0xF9A6, 0xC1D1);
2832         MP_WriteMcuAccessRegWord(sc, 0xF9A8, 0xC2D3);
2833         MP_WriteMcuAccessRegWord(sc, 0xF9AA, 0xE851);
2834         MP_WriteMcuAccessRegWord(sc, 0xF9AC, 0xE807);
2835         MP_WriteMcuAccessRegWord(sc, 0xF9AE, 0xC0BE);
2836         MP_WriteMcuAccessRegWord(sc, 0xF9B0, 0xC2C2);
2837         MP_WriteMcuAccessRegWord(sc, 0xF9B2, 0xE84D);
2838         MP_WriteMcuAccessRegWord(sc, 0xF9B4, 0xE803);
2839         MP_WriteMcuAccessRegWord(sc, 0xF9B6, 0xB001);
2840         MP_WriteMcuAccessRegWord(sc, 0xF9B8, 0xFF80);
2841         MP_WriteMcuAccessRegWord(sc, 0xF9BA, 0xB402);
2842         MP_WriteMcuAccessRegWord(sc, 0xF9BC, 0xC2C6);
2843         MP_WriteMcuAccessRegWord(sc, 0xF9BE, 0xE859);
2844         MP_WriteMcuAccessRegWord(sc, 0xF9C0, 0x499F);
2845         MP_WriteMcuAccessRegWord(sc, 0xF9C2, 0xF1FE);
2846         MP_WriteMcuAccessRegWord(sc, 0xF9C4, 0xB002);
2847         MP_WriteMcuAccessRegWord(sc, 0xF9C6, 0xFF80);
2848         MP_WriteMcuAccessRegWord(sc, 0xF9C8, 0xB402);
2849         MP_WriteMcuAccessRegWord(sc, 0xF9CA, 0xB403);
2850         MP_WriteMcuAccessRegWord(sc, 0xF9CC, 0xB407);
2851         MP_WriteMcuAccessRegWord(sc, 0xF9CE, 0xE821);
2852         MP_WriteMcuAccessRegWord(sc, 0xF9D0, 0x8882);
2853         MP_WriteMcuAccessRegWord(sc, 0xF9D2, 0x1980);
2854         MP_WriteMcuAccessRegWord(sc, 0xF9D4, 0x8983);
2855         MP_WriteMcuAccessRegWord(sc, 0xF9D6, 0xE81D);
2856         MP_WriteMcuAccessRegWord(sc, 0xF9D8, 0x7180);
2857         MP_WriteMcuAccessRegWord(sc, 0xF9DA, 0x218B);
2858         MP_WriteMcuAccessRegWord(sc, 0xF9DC, 0x25BB);
2859         MP_WriteMcuAccessRegWord(sc, 0xF9DE, 0x1310);
2860         MP_WriteMcuAccessRegWord(sc, 0xF9E0, 0xF014);
2861         MP_WriteMcuAccessRegWord(sc, 0xF9E2, 0x1310);
2862         MP_WriteMcuAccessRegWord(sc, 0xF9E4, 0xFB03);
2863         MP_WriteMcuAccessRegWord(sc, 0xF9E6, 0x1F20);
2864         MP_WriteMcuAccessRegWord(sc, 0xF9E8, 0x38FB);
2865         MP_WriteMcuAccessRegWord(sc, 0xF9EA, 0x3288);
2866         MP_WriteMcuAccessRegWord(sc, 0xF9EC, 0x434B);
2867         MP_WriteMcuAccessRegWord(sc, 0xF9EE, 0x2491);
2868         MP_WriteMcuAccessRegWord(sc, 0xF9F0, 0x430B);
2869         MP_WriteMcuAccessRegWord(sc, 0xF9F2, 0x1F0F);
2870         MP_WriteMcuAccessRegWord(sc, 0xF9F4, 0x38FB);
2871         MP_WriteMcuAccessRegWord(sc, 0xF9F6, 0x4313);
2872         MP_WriteMcuAccessRegWord(sc, 0xF9F8, 0x2121);
2873         MP_WriteMcuAccessRegWord(sc, 0xF9FA, 0x4353);
2874         MP_WriteMcuAccessRegWord(sc, 0xF9FC, 0x2521);
2875         MP_WriteMcuAccessRegWord(sc, 0xF9FE, 0x418A);
2876         MP_WriteMcuAccessRegWord(sc, 0xFA00, 0x6282);
2877         MP_WriteMcuAccessRegWord(sc, 0xFA02, 0x2527);
2878         MP_WriteMcuAccessRegWord(sc, 0xFA04, 0x212F);
2879         MP_WriteMcuAccessRegWord(sc, 0xFA06, 0x418A);
2880         MP_WriteMcuAccessRegWord(sc, 0xFA08, 0xB007);
2881         MP_WriteMcuAccessRegWord(sc, 0xFA0A, 0xB003);
2882         MP_WriteMcuAccessRegWord(sc, 0xFA0C, 0xB002);
2883         MP_WriteMcuAccessRegWord(sc, 0xFA0E, 0xFF80);
2884         MP_WriteMcuAccessRegWord(sc, 0xFA10, 0x6183);
2885         MP_WriteMcuAccessRegWord(sc, 0xFA12, 0x2496);
2886         MP_WriteMcuAccessRegWord(sc, 0xFA14, 0x1100);
2887         MP_WriteMcuAccessRegWord(sc, 0xFA16, 0xF1FD);
2888         MP_WriteMcuAccessRegWord(sc, 0xFA18, 0xFF80);
2889         MP_WriteMcuAccessRegWord(sc, 0xFA1A, 0x4800);
2890         MP_WriteMcuAccessRegWord(sc, 0xFA1C, 0x4801);
2891         MP_WriteMcuAccessRegWord(sc, 0xFA1E, 0xC213);
2892         MP_WriteMcuAccessRegWord(sc, 0xFA20, 0xC313);
2893         MP_WriteMcuAccessRegWord(sc, 0xFA22, 0xE815);
2894         MP_WriteMcuAccessRegWord(sc, 0xFA24, 0x4860);
2895         MP_WriteMcuAccessRegWord(sc, 0xFA26, 0x8EE0);
2896         MP_WriteMcuAccessRegWord(sc, 0xFA28, 0xC210);
2897         MP_WriteMcuAccessRegWord(sc, 0xFA2A, 0xC310);
2898         MP_WriteMcuAccessRegWord(sc, 0xFA2C, 0xE822);
2899         MP_WriteMcuAccessRegWord(sc, 0xFA2E, 0x481E);
2900         MP_WriteMcuAccessRegWord(sc, 0xFA30, 0xC20C);
2901         MP_WriteMcuAccessRegWord(sc, 0xFA32, 0xC30C);
2902         MP_WriteMcuAccessRegWord(sc, 0xFA34, 0xE80C);
2903         MP_WriteMcuAccessRegWord(sc, 0xFA36, 0xC206);
2904         MP_WriteMcuAccessRegWord(sc, 0xFA38, 0x7358);
2905         MP_WriteMcuAccessRegWord(sc, 0xFA3A, 0x483A);
2906         MP_WriteMcuAccessRegWord(sc, 0xFA3C, 0x9B58);
2907         MP_WriteMcuAccessRegWord(sc, 0xFA3E, 0xFF80);
2908         MP_WriteMcuAccessRegWord(sc, 0xFA40, 0xE8E0);
2909         MP_WriteMcuAccessRegWord(sc, 0xFA42, 0xE000);
2910         MP_WriteMcuAccessRegWord(sc, 0xFA44, 0x1008);
2911         MP_WriteMcuAccessRegWord(sc, 0xFA46, 0x0F00);
2912         MP_WriteMcuAccessRegWord(sc, 0xFA48, 0x800C);
2913         MP_WriteMcuAccessRegWord(sc, 0xFA4A, 0x0F00);
2914         MP_WriteMcuAccessRegWord(sc, 0xFA4C, 0xB407);
2915         MP_WriteMcuAccessRegWord(sc, 0xFA4E, 0xB406);
2916         MP_WriteMcuAccessRegWord(sc, 0xFA50, 0xB403);
2917         MP_WriteMcuAccessRegWord(sc, 0xFA52, 0xC7F7);
2918         MP_WriteMcuAccessRegWord(sc, 0xFA54, 0x98E0);
2919         MP_WriteMcuAccessRegWord(sc, 0xFA56, 0x99E2);
2920         MP_WriteMcuAccessRegWord(sc, 0xFA58, 0x9AE4);
2921         MP_WriteMcuAccessRegWord(sc, 0xFA5A, 0x21B2);
2922         MP_WriteMcuAccessRegWord(sc, 0xFA5C, 0x4831);
2923         MP_WriteMcuAccessRegWord(sc, 0xFA5E, 0x483F);
2924         MP_WriteMcuAccessRegWord(sc, 0xFA60, 0x9BE6);
2925         MP_WriteMcuAccessRegWord(sc, 0xFA62, 0x66E7);
2926         MP_WriteMcuAccessRegWord(sc, 0xFA64, 0x49E6);
2927         MP_WriteMcuAccessRegWord(sc, 0xFA66, 0xF1FE);
2928         MP_WriteMcuAccessRegWord(sc, 0xFA68, 0xB003);
2929         MP_WriteMcuAccessRegWord(sc, 0xFA6A, 0xB006);
2930         MP_WriteMcuAccessRegWord(sc, 0xFA6C, 0xB007);
2931         MP_WriteMcuAccessRegWord(sc, 0xFA6E, 0xFF80);
2932         MP_WriteMcuAccessRegWord(sc, 0xFA70, 0xB407);
2933         MP_WriteMcuAccessRegWord(sc, 0xFA72, 0xB406);
2934         MP_WriteMcuAccessRegWord(sc, 0xFA74, 0xB403);
2935         MP_WriteMcuAccessRegWord(sc, 0xFA76, 0xC7E5);
2936         MP_WriteMcuAccessRegWord(sc, 0xFA78, 0x9AE4);
2937         MP_WriteMcuAccessRegWord(sc, 0xFA7A, 0x21B2);
2938         MP_WriteMcuAccessRegWord(sc, 0xFA7C, 0x4831);
2939         MP_WriteMcuAccessRegWord(sc, 0xFA7E, 0x9BE6);
2940         MP_WriteMcuAccessRegWord(sc, 0xFA80, 0x66E7);
2941         MP_WriteMcuAccessRegWord(sc, 0xFA82, 0x49E6);
2942         MP_WriteMcuAccessRegWord(sc, 0xFA84, 0xF1FE);
2943         MP_WriteMcuAccessRegWord(sc, 0xFA86, 0x70E0);
2944         MP_WriteMcuAccessRegWord(sc, 0xFA88, 0x71E2);
2945         MP_WriteMcuAccessRegWord(sc, 0xFA8A, 0xB003);
2946         MP_WriteMcuAccessRegWord(sc, 0xFA8C, 0xB006);
2947         MP_WriteMcuAccessRegWord(sc, 0xFA8E, 0xB007);
2948         MP_WriteMcuAccessRegWord(sc, 0xFA90, 0xFF80);
2949         MP_WriteMcuAccessRegWord(sc, 0xFA92, 0x4882);
2950         MP_WriteMcuAccessRegWord(sc, 0xFA94, 0xB406);
2951         MP_WriteMcuAccessRegWord(sc, 0xFA96, 0xB405);
2952         MP_WriteMcuAccessRegWord(sc, 0xFA98, 0xC71E);
2953         MP_WriteMcuAccessRegWord(sc, 0xFA9A, 0x76E0);
2954         MP_WriteMcuAccessRegWord(sc, 0xFA9C, 0x1D78);
2955         MP_WriteMcuAccessRegWord(sc, 0xFA9E, 0x4175);
2956         MP_WriteMcuAccessRegWord(sc, 0xFAA0, 0x1630);
2957         MP_WriteMcuAccessRegWord(sc, 0xFAA2, 0xF10C);
2958         MP_WriteMcuAccessRegWord(sc, 0xFAA4, 0xC715);
2959         MP_WriteMcuAccessRegWord(sc, 0xFAA6, 0x76E0);
2960         MP_WriteMcuAccessRegWord(sc, 0xFAA8, 0x4861);
2961         MP_WriteMcuAccessRegWord(sc, 0xFAAA, 0x9EE0);
2962         MP_WriteMcuAccessRegWord(sc, 0xFAAC, 0xC713);
2963         MP_WriteMcuAccessRegWord(sc, 0xFAAE, 0x1EFF);
2964         MP_WriteMcuAccessRegWord(sc, 0xFAB0, 0x9EE2);
2965         MP_WriteMcuAccessRegWord(sc, 0xFAB2, 0x75E0);
2966         MP_WriteMcuAccessRegWord(sc, 0xFAB4, 0x4850);
2967         MP_WriteMcuAccessRegWord(sc, 0xFAB6, 0x9DE0);
2968         MP_WriteMcuAccessRegWord(sc, 0xFAB8, 0xE005);
2969         MP_WriteMcuAccessRegWord(sc, 0xFABA, 0xC70B);
2970         MP_WriteMcuAccessRegWord(sc, 0xFABC, 0x76E0);
2971         MP_WriteMcuAccessRegWord(sc, 0xFABE, 0x4865);
2972         MP_WriteMcuAccessRegWord(sc, 0xFAC0, 0x9EE0);
2973         MP_WriteMcuAccessRegWord(sc, 0xFAC2, 0xB005);
2974         MP_WriteMcuAccessRegWord(sc, 0xFAC4, 0xB006);
2975         MP_WriteMcuAccessRegWord(sc, 0xFAC6, 0xC708);
2976         MP_WriteMcuAccessRegWord(sc, 0xFAC8, 0xC102);
2977         MP_WriteMcuAccessRegWord(sc, 0xFACA, 0xB900);
2978         MP_WriteMcuAccessRegWord(sc, 0xFACC, 0x279E);
2979         MP_WriteMcuAccessRegWord(sc, 0xFACE, 0xEB16);
2980         MP_WriteMcuAccessRegWord(sc, 0xFAD0, 0xEB00);
2981         MP_WriteMcuAccessRegWord(sc, 0xFAD2, 0xE43C);
2982         MP_WriteMcuAccessRegWord(sc, 0xFAD4, 0xDC00);
2983         MP_WriteMcuAccessRegWord(sc, 0xFAD6, 0xD3EC);
2984         MP_WriteMcuAccessRegWord(sc, 0xFAD8, 0xC602);
2985         MP_WriteMcuAccessRegWord(sc, 0xFADA, 0xBE00);
2986         MP_WriteMcuAccessRegWord(sc, 0xFADC, 0x0000);
2987         MP_WriteMcuAccessRegWord(sc, 0xFADE, 0xC602);
2988         MP_WriteMcuAccessRegWord(sc, 0xFAE0, 0xBE00);
2989         MP_WriteMcuAccessRegWord(sc, 0xFAE2, 0x0000);
2990
2991         MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000);
2992
2993         MP_WriteMcuAccessRegWord(sc, 0xFC28, 0x0000);
2994         MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x04B4);
2995         MP_WriteMcuAccessRegWord(sc, 0xFC2C, 0x0000);
2996         MP_WriteMcuAccessRegWord(sc, 0xFC2E, 0x0000);
2997         MP_WriteMcuAccessRegWord(sc, 0xFC30, 0x0000);
2998         MP_WriteMcuAccessRegWord(sc, 0xFC32, 0x279C);
2999         MP_WriteMcuAccessRegWord(sc, 0xFC34, 0x0000);
3000         MP_WriteMcuAccessRegWord(sc, 0xFC36, 0x0000);
3001
3002         MP_WriteMcuAccessRegWord(sc, 0xFC38, 0x0022);
3003 }
3004
3005 static void re_hw_mac_mcu_config(struct re_softc *sc)
3006 {
3007         switch(sc->re_type) {
3008         case MACFG_56:
3009                 re_set_mac_mcu_8168g_1(sc);
3010                 break;
3011         case MACFG_58:
3012                 re_set_mac_mcu_8168gu_1(sc);
3013                 break;
3014         case MACFG_59:
3015                 re_set_mac_mcu_8168gu_2(sc);
3016                 break;
3017         case MACFG_60:
3018                 re_set_mac_mcu_8411b_1(sc);
3019                 break;
3020         case MACFG_62:
3021                 re_set_mac_mcu_8168ep_1(sc);
3022                 break;
3023         case MACFG_67:
3024                 re_set_mac_mcu_8168ep_2(sc);
3025                 break;
3026         case MACFG_68:
3027         case MACFG_69:
3028                 re_set_mac_mcu_8168h_1(sc);
3029                 break;
3030         case MACFG_70:
3031                 if (sc->HwPkgDet == 0x00 || sc->HwPkgDet == 0x0F)
3032                         re_set_mac_mcu_8168fp_1(sc);
3033                 else if (sc->HwPkgDet == 0x06)
3034                         re_set_mac_mcu_8168fp_2(sc);
3035                 break;
3036         case MACFG_71:
3037                 DisableMcuBPs(sc);
3038                 break;
3039         }
3040 }
3041
3042 #define ISRIMR_DASH_TYPE2_TX_DISABLE_IDLE BIT_5
3043 static void Dash2DisableTx(struct re_softc *sc)
3044 {
3045         //if (!sc->re_dash) return;
3046
3047         if (HW_DASH_SUPPORT_TYPE_2(sc) || HW_DASH_SUPPORT_TYPE_3(sc)) {
3048                 u_int16_t WaitCnt;
3049                 u_int8_t TmpUchar;
3050
3051                 //Disable oob Tx
3052                 RE_CMAC_WRITE_1(sc, RE_CMAC_IBCR2, RE_CMAC_READ_1(sc, RE_CMAC_IBCR2) & ~(BIT_0));
3053                 WaitCnt = 0;
3054
3055                 //wait oob tx disable
3056                 do {
3057                         TmpUchar = RE_CMAC_READ_1(sc, RE_CMAC_IBISR0);
3058
3059                         if (TmpUchar & ISRIMR_DASH_TYPE2_TX_DISABLE_IDLE) {
3060                                 break;
3061                         }
3062
3063                         DELAY(50);
3064                         WaitCnt++;
3065                 } while(WaitCnt < 2000);
3066
3067                 //Clear ISRIMR_DASH_TYPE2_TX_DISABLE_IDLE
3068                 RE_CMAC_WRITE_1(sc, RE_CMAC_IBISR0, RE_CMAC_READ_1(sc, RE_CMAC_IBISR0) | ISRIMR_DASH_TYPE2_TX_DISABLE_IDLE);
3069         }
3070 }
3071
3072 static void Dash2DisableRx(struct re_softc *sc)
3073 {
3074         //if (!sc->re_dash) return;
3075
3076         if (HW_DASH_SUPPORT_TYPE_2(sc) || HW_DASH_SUPPORT_TYPE_3(sc)) {
3077                 RE_CMAC_WRITE_1(sc, RE_CMAC_IBCR0, RE_CMAC_READ_1(sc, RE_CMAC_IBCR0) & ~(BIT_0));
3078         }
3079 }
3080
3081 static void Dash2DisableTxRx(struct re_softc *sc)
3082 {
3083         if (HW_DASH_SUPPORT_TYPE_2(sc) || HW_DASH_SUPPORT_TYPE_3(sc)) {
3084                 Dash2DisableTx(sc);
3085                 Dash2DisableRx(sc);
3086         }
3087 }
3088
3089 static inline bool
3090 is_zero_ether_addr(const u_int8_t * addr)
3091 {
3092         return ((addr[0] + addr[1] + addr[2] + addr[3] + addr[4] + addr[5]) == 0x00);
3093 }
3094
3095 static inline bool
3096 is_multicast_ether_addr(const u_int8_t * addr)
3097 {
3098         return (0x01 & addr[0]);
3099 }
3100
3101 /*
3102 static inline bool
3103 is_broadcast_ether_addr(const u_int8_t * addr)
3104 {
3105         return ((addr[0] + addr[1] + addr[2] + addr[3] + addr[4] + addr[5]) == (6 * 0xff));
3106 }
3107 */
3108
3109 static inline bool
3110 is_valid_ether_addr(const u_int8_t * addr)
3111 {
3112         return !is_multicast_ether_addr(addr) && !is_zero_ether_addr(addr);
3113 }
3114
3115 static inline void
3116 random_ether_addr(u_int8_t * dst)
3117 {
3118 #ifndef __DragonFly__
3119         if (read_random(dst, 6) == 0)
3120                 arc4rand(dst, 6, 0);
3121 #else
3122         karc4rand(dst, 6);
3123 #endif
3124
3125         dst[0] &= 0xfe;
3126         dst[0] |= 0x02;
3127 }
3128
3129 static void re_disable_now_is_oob(struct re_softc *sc)
3130 {
3131         if (sc->re_hw_supp_now_is_oob_ver == 1)
3132                 CSR_WRITE_1(sc, RE_MCU_CMD, CSR_READ_1(sc, RE_MCU_CMD) & ~RE_NOW_IS_OOB);
3133 }
3134
3135 static void re_exit_oob(struct re_softc *sc)
3136 {
3137         u_int16_t data16;
3138         int i;
3139
3140         re_disable_cfg9346_write(sc);
3141
3142         switch(sc->re_type) {
3143         case MACFG_61:
3144         case MACFG_62:
3145         case MACFG_67:
3146         case MACFG_70:
3147         case MACFG_71:
3148                 Dash2DisableTxRx(sc);
3149                 break;
3150         }
3151
3152         if (sc->re_dash)
3153                 re_driver_start(sc);
3154
3155         switch(sc->re_type) {
3156         case MACFG_56:
3157         case MACFG_57:
3158         case MACFG_58:
3159         case MACFG_59:
3160         case MACFG_60:
3161         case MACFG_61:
3162         case MACFG_62:
3163         case MACFG_67:
3164         case MACFG_68:
3165         case MACFG_69:
3166         case MACFG_70:
3167         case MACFG_71:
3168                 CSR_WRITE_1(sc, 0xF2, CSR_READ_1(sc, 0xF2) | BIT_3);
3169                 DELAY(2000);
3170
3171                 for (i = 0; i < 10; i++) {
3172                         DELAY(100);
3173                         if (CSR_READ_4(sc, RE_TXCFG) & BIT_11)
3174                                 break;
3175                 }
3176
3177                 if (CSR_READ_1(sc, RE_COMMAND) & (RE_CMD_TX_ENB | RE_CMD_RX_ENB)) {
3178                         DELAY(100);
3179                         CSR_WRITE_1(sc, RE_COMMAND, CSR_READ_1(sc, RE_COMMAND) & ~(RE_CMD_TX_ENB | RE_CMD_RX_ENB));
3180                 }
3181
3182                 for (i = 0; i < 10; i++) {
3183                         DELAY(100);
3184                         if ((CSR_READ_1(sc, RE_MCU_CMD) & (RE_TXFIFO_EMPTY | RE_RXFIFO_EMPTY)) == (RE_TXFIFO_EMPTY | RE_RXFIFO_EMPTY))
3185                                 break;
3186
3187                 }
3188                 break;
3189         }
3190
3191         //Disable realwow function
3192         switch (sc->re_type) {
3193         case MACFG_50:
3194         case MACFG_51:
3195                 CSR_WRITE_4(sc, RE_MCUACCESS, 0xE5A90000);
3196                 CSR_WRITE_4(sc, RE_MCUACCESS, 0xF2100010);
3197                 break;
3198         case MACFG_52:
3199                 CSR_WRITE_4(sc, RE_MCUACCESS, 0xE5A90000);
3200                 CSR_WRITE_4(sc, RE_MCUACCESS, 0xE4640000);
3201                 CSR_WRITE_4(sc, RE_MCUACCESS, 0xF2100010);
3202                 break;
3203         case MACFG_56:
3204         case MACFG_57:
3205                 CSR_WRITE_4(sc, RE_MCUACCESS, 0x605E0000);
3206                 CSR_WRITE_4(sc, RE_MCUACCESS, (0xE05E << 16) | (CSR_READ_4(sc, RE_MCUACCESS) & 0xFFFE));
3207                 CSR_WRITE_4(sc, RE_MCUACCESS, 0xE9720000);
3208                 CSR_WRITE_4(sc, RE_MCUACCESS, 0xF2140010);
3209                 break;
3210         case MACFG_60:
3211                 CSR_WRITE_4(sc, RE_MCUACCESS, 0xE05E00FF);
3212                 CSR_WRITE_4(sc, RE_MCUACCESS, 0xE9720000);
3213                 MP_WriteMcuAccessRegWord(sc, 0xE428, 0x0010);
3214                 break;
3215         }
3216
3217         if (sc->re_hw_supp_now_is_oob_ver >0)
3218                 re_disable_now_is_oob(sc);
3219
3220         switch(sc->re_type) {
3221         case MACFG_52:
3222                 for (i = 0; i < 10; i++) {
3223                         DELAY(100);
3224                         if (CSR_READ_2(sc, 0xD2) & BIT_9)
3225                                 break;
3226                 }
3227
3228                 data16 = MP_ReadMcuAccessRegWord(sc, 0xD4DE) | BIT_15;
3229                 MP_WriteMcuAccessRegWord(sc, 0xD4DE, data16);
3230
3231                 for (i = 0; i < 10; i++) {
3232                         DELAY(100);
3233                         if (CSR_READ_2(sc, 0xD2) & BIT_9)
3234                                 break;
3235                 }
3236                 break;
3237         case MACFG_56:
3238         case MACFG_57:
3239         case MACFG_58:
3240         case MACFG_59:
3241         case MACFG_60:
3242         case MACFG_61:
3243         case MACFG_62:
3244         case MACFG_67:
3245         case MACFG_68:
3246         case MACFG_69:
3247         case MACFG_70:
3248         case MACFG_71:
3249                 data16 = MP_ReadMcuAccessRegWord(sc, 0xE8DE) & ~BIT_14;
3250                 MP_WriteMcuAccessRegWord(sc, 0xE8DE, data16);
3251                 for (i = 0; i < 10; i++) {
3252                         DELAY(100);
3253                         if (CSR_READ_2(sc, 0xD2) & BIT_9)
3254                                 break;
3255                 }
3256
3257                 data16 = MP_ReadMcuAccessRegWord(sc, 0xE8DE) | BIT_15;
3258                 MP_WriteMcuAccessRegWord(sc, 0xE8DE, data16);
3259
3260                 for (i = 0; i < 10; i++) {
3261                         DELAY(100);
3262                         if (CSR_READ_2(sc, 0xD2) & BIT_9)
3263                                 break;
3264                 }
3265                 break;
3266         }
3267
3268         //wait ups resume (phy state 2)
3269         switch(sc->re_type) {
3270         case MACFG_68:
3271         case MACFG_69:
3272         case MACFG_70:
3273         case MACFG_71:
3274                 if (re_is_ups_resume(sc)) {
3275                         re_wait_phy_ups_resume(sc, 2);
3276                         re_clear_ups_resume_bit(sc);
3277                 }
3278                 break;
3279         };
3280
3281         /*
3282         * Config MAC MCU
3283         */
3284         re_hw_mac_mcu_config(sc);
3285 }
3286
3287 static void re_hw_init(struct re_softc *sc)
3288 {
3289         /*
3290         * disable EDT.
3291         */
3292         switch(sc->re_type) {
3293         case MACFG_16:
3294         case MACFG_17:
3295         case MACFG_18:
3296         case MACFG_19:
3297         case MACFG_41:
3298                 CSR_WRITE_1(sc, 0xF4, CSR_READ_1(sc, 0xF4) & ~(BIT_0|BIT_1));
3299                 break;
3300         case MACFG_36:
3301         case MACFG_37:
3302         case MACFG_38:
3303         case MACFG_39:
3304         case MACFG_42:
3305         case MACFG_43:
3306         case MACFG_50:
3307         case MACFG_51:
3308         case MACFG_54:
3309         case MACFG_55:
3310                 CSR_WRITE_1(sc, 0xF2, CSR_READ_1(sc, 0xF2) & ~(BIT_0|BIT_1|BIT_2));
3311                 break;
3312         }
3313
3314         switch(sc->re_type) {
3315         case MACFG_5:
3316                 if (CSR_READ_1(sc, RE_CFG2) & 1) {
3317                         CSR_WRITE_4(sc, 0x7C, 0x000FFFFF);
3318                 } else {
3319                         CSR_WRITE_4(sc, 0x7C, 0x000FFF00);
3320                 }
3321                 break;
3322         case MACFG_6:
3323                 if (CSR_READ_1(sc, RE_CFG2) & 1) {
3324                         CSR_WRITE_4(sc, 0x7C, 0x003FFFFF);
3325                 } else {
3326                         CSR_WRITE_4(sc, 0x7C, 0x003FFF00);
3327                 }
3328                 break;
3329         }
3330
3331         switch(sc->re_type) {
3332         case MACFG_33:
3333         case MACFG_36:
3334         case MACFG_37:
3335                 CSR_WRITE_1(sc, 0xF3, CSR_READ_1(sc, 0xF3) | BIT_2);
3336                 break;
3337         }
3338
3339         switch(sc->re_type) {
3340         case MACFG_36:
3341         case MACFG_37:
3342         case MACFG_38:
3343         case MACFG_39:
3344         case MACFG_42:
3345         case MACFG_43:
3346         case MACFG_50:
3347         case MACFG_51:
3348         case MACFG_52:
3349         case MACFG_53:
3350         case MACFG_54:
3351         case MACFG_55:
3352         case MACFG_56:
3353         case MACFG_57:
3354         case MACFG_58:
3355         case MACFG_59:
3356         case MACFG_60:
3357         case MACFG_61:
3358         case MACFG_62:
3359         case MACFG_67:
3360         case MACFG_68:
3361         case MACFG_69:
3362         case MACFG_70:
3363         case MACFG_71:
3364                 re_enable_cfg9346_write(sc);
3365                 CSR_WRITE_1(sc, RE_CFG5, CSR_READ_1(sc, RE_CFG5) & ~BIT_0);
3366                 CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2) & ~BIT_7);
3367                 CSR_WRITE_1(sc, 0xF1, CSR_READ_1(sc, 0xF1) & ~ BIT_7);
3368                 CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2) | BIT_5);
3369                 re_disable_cfg9346_write(sc);
3370                 break;
3371         }
3372
3373         if (sc->re_if_flags & RL_FLAG_PCIE) {
3374                 uint32_t Data32;
3375                 //Set PCIE uncorrectable error status mask pcie 0x108
3376                 Data32 = MP_ReadPciEConfigSpace(sc, 0xF108);
3377                 Data32 |= BIT_20;
3378                 MP_WritePciEConfigSpace(sc, 0xF108, Data32);
3379         }
3380 }
3381
3382 static void re_rar_set(struct re_softc *sc, u_int8_t *eaddr)
3383 {
3384         re_enable_cfg9346_write(sc);
3385
3386         CSR_WRITE_4(sc, RE_IDR0,
3387                     htole32(*(u_int32_t *)(&eaddr[0])));
3388         CSR_WRITE_2(sc, RE_IDR4,
3389                     htole16(*(u_int32_t *)(&eaddr[4])));
3390
3391         switch (sc->re_type) {
3392         case MACFG_36:
3393         case MACFG_37:
3394         case MACFG_42:
3395         case MACFG_43:
3396         case MACFG_54:
3397         case MACFG_55:
3398                 CSR_WRITE_4(sc, RE_SecMAC0,
3399                             htole32(*(u_int32_t *)(&eaddr[0])));
3400                 CSR_WRITE_2(sc, RE_SecMAC4,
3401                             htole16(*(u_int16_t *)(&eaddr[4])));
3402                 break;
3403         }
3404
3405         switch (sc->re_type) {
3406         case MACFG_38:
3407         case MACFG_39:
3408                 re_eri_write(sc, 0xF0, 4, *(u_int16_t *)(&eaddr[0])<<16, ERIAR_ExGMAC);
3409                 re_eri_write(sc, 0xF4, 4, *(u_int32_t *)(&eaddr[2]), ERIAR_ExGMAC);
3410                 break;
3411         }
3412
3413         re_disable_cfg9346_write(sc);
3414 }
3415
3416 static void re_get_hw_mac_address(struct re_softc *sc, u_int8_t *eaddr)
3417 {
3418         device_t dev = sc->dev;
3419         u_int16_t re_eeid = 0;
3420         int i;
3421
3422         for (i = 0; i < ETHER_ADDR_LEN; i++)
3423                 eaddr[i] = CSR_READ_1(sc, RE_IDR0 + i);
3424
3425         switch(sc->re_type) {
3426         case MACFG_50:
3427         case MACFG_51:
3428         case MACFG_52:
3429         case MACFG_53:
3430         case MACFG_56:
3431         case MACFG_57:
3432         case MACFG_58:
3433         case MACFG_59:
3434         case MACFG_60:
3435         case MACFG_61:
3436         case MACFG_62:
3437         case MACFG_67:
3438         case MACFG_68:
3439         case MACFG_69:
3440         case MACFG_70:
3441         case MACFG_71:
3442                 *(u_int32_t *)&eaddr[0] = re_eri_read(sc, 0xE0, 4, ERIAR_ExGMAC);
3443                 *(u_int16_t *)&eaddr[4] = (u_int16_t)re_eri_read(sc, 0xE4, 4, ERIAR_ExGMAC);
3444                 break;
3445         case MACFG_63:
3446         case MACFG_64:
3447         case MACFG_65:
3448         case MACFG_66:
3449                 break;
3450         default:
3451                 re_read_eeprom(sc, (caddr_t)&re_eeid, RE_EE_ID, 1, 0);
3452                 if (re_eeid == 0x8129)
3453                         re_read_eeprom(sc, (caddr_t)&eaddr[0], RE_EE_EADDR, 3, 0);
3454                 break;
3455         }
3456
3457         if (!is_valid_ether_addr(eaddr)) {
3458 #ifndef __DragonFly__
3459                 device_printf(dev,"Invalid ether addr: %6D\n", eaddr, ":");
3460 #else
3461                 device_printf(dev, "Invalid ether addr: "
3462                     "%02x:%02x:%02x:%02x:%02x:%02x\n",
3463                     eaddr[0], eaddr[1], eaddr[2], eaddr[3], eaddr[4], eaddr[5]);
3464 #endif
3465                 random_ether_addr(eaddr);
3466 #ifndef __DragonFly__
3467                 device_printf(dev,"Random ether addr: %6D\n", eaddr, ":");
3468 #else
3469                 device_printf(dev, "Random ether addr: "
3470                     "%02x:%02x:%02x:%02x:%02x:%02x\n",
3471                     eaddr[0], eaddr[1], eaddr[2], eaddr[3], eaddr[4], eaddr[5]);
3472 #endif
3473         }
3474
3475         re_rar_set(sc, eaddr);
3476 }
3477
3478 static int re_check_mac_version(struct re_softc *sc)
3479 {
3480         device_t dev = sc->dev;
3481         int error = 0;
3482
3483         switch(CSR_READ_4(sc, RE_TXCFG) & 0xFCF00000) {
3484         case 0x00800000:
3485         case 0x04000000:
3486                 sc->re_type = MACFG_3;
3487                 sc->max_jumbo_frame_size = Jumbo_Frame_7k;
3488                 CSR_WRITE_4(sc, RE_RXCFG, 0xFF00);
3489                 break;
3490         case 0x10000000:
3491                 sc->re_type = MACFG_4;
3492                 sc->max_jumbo_frame_size = Jumbo_Frame_7k;
3493                 CSR_WRITE_4(sc, RE_RXCFG, 0xFF00);
3494                 break;
3495         case 0x18000000:
3496                 sc->re_type = MACFG_5;
3497                 sc->max_jumbo_frame_size = Jumbo_Frame_7k;
3498                 CSR_WRITE_4(sc, RE_RXCFG, 0xFF00);
3499                 break;
3500         case 0x98000000:
3501                 sc->re_type = MACFG_6;
3502                 sc->max_jumbo_frame_size = Jumbo_Frame_7k;
3503                 CSR_WRITE_4(sc, RE_RXCFG, 0xFF00);
3504                 break;
3505         case 0x34000000:
3506         case 0xB4000000:
3507                 sc->re_type = MACFG_11;
3508                 sc->max_jumbo_frame_size = ETHERMTU;
3509                 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
3510                 break;
3511         case 0x34200000:
3512         case 0xB4200000:
3513                 sc->re_type = MACFG_12;
3514                 sc->max_jumbo_frame_size = ETHERMTU;
3515                 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
3516                 break;
3517         case 0x34300000:
3518         case 0xB4300000:
3519                 sc->re_type = MACFG_13;
3520                 sc->max_jumbo_frame_size = ETHERMTU;
3521                 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
3522                 break;
3523         case 0x34900000:
3524         case 0x24900000:
3525                 sc->re_type = MACFG_14;
3526                 sc->max_jumbo_frame_size = ETHERMTU;
3527                 sc->re_if_flags |= RL_FLAG_DESCV2;
3528                 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
3529                 break;
3530         case 0x34A00000:
3531         case 0x24A00000:
3532                 sc->re_type = MACFG_15;
3533                 sc->max_jumbo_frame_size = ETHERMTU;
3534                 sc->re_if_flags |= RL_FLAG_DESCV2;
3535                 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
3536                 break;
3537         case 0x34B00000:
3538         case 0x24B00000:
3539                 sc->re_type = MACFG_16;
3540                 sc->max_jumbo_frame_size = ETHERMTU;
3541                 sc->re_if_flags |= RL_FLAG_DESCV2;
3542                 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
3543                 break;
3544         case 0x34C00000:
3545         case 0x24C00000:
3546                 sc->re_type = MACFG_17;
3547                 sc->max_jumbo_frame_size = ETHERMTU;
3548                 sc->re_if_flags |= RL_FLAG_DESCV2;
3549                 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
3550                 break;
3551         case 0x34D00000:
3552         case 0x24D00000:
3553                 sc->re_type = MACFG_18;
3554                 sc->max_jumbo_frame_size = ETHERMTU;
3555                 sc->re_if_flags |= RL_FLAG_DESCV2;
3556                 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
3557                 break;
3558         case 0x34E00000:
3559         case 0x24E00000:
3560                 sc->re_type = MACFG_19;
3561                 sc->max_jumbo_frame_size = ETHERMTU;
3562                 sc->re_if_flags |= RL_FLAG_DESCV2;
3563                 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
3564                 break;
3565         case 0x30000000:
3566                 sc->re_type = MACFG_21;
3567                 sc->max_jumbo_frame_size = Jumbo_Frame_4k;
3568                 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
3569                 break;
3570         case 0x38000000:
3571                 sc->re_type = MACFG_22;
3572                 sc->max_jumbo_frame_size = Jumbo_Frame_4k;
3573                 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
3574                 break;
3575         case 0x38500000:
3576         case 0xB8500000:
3577         case 0x38700000:
3578         case 0xB8700000:
3579                 sc->re_type = MACFG_23;
3580                 sc->max_jumbo_frame_size = Jumbo_Frame_4k;
3581                 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
3582                 break;
3583         case 0x3C000000:
3584                 sc->re_type = MACFG_24;
3585                 sc->max_jumbo_frame_size = Jumbo_Frame_6k;
3586                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
3587                 CSR_WRITE_4(sc, RE_RXCFG, 0xC700);
3588                 break;
3589         case 0x3C200000:
3590                 sc->re_type = MACFG_25;
3591                 sc->max_jumbo_frame_size = Jumbo_Frame_6k;
3592                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
3593                 CSR_WRITE_4(sc, RE_RXCFG, 0xC700);
3594                 break;
3595         case 0x3C400000:
3596                 sc->re_type = MACFG_26;
3597                 sc->max_jumbo_frame_size = Jumbo_Frame_6k;
3598                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
3599                 CSR_WRITE_4(sc, RE_RXCFG, 0xC700);
3600                 break;
3601         case 0x3C900000:
3602                 sc->re_type = MACFG_27;
3603                 sc->max_jumbo_frame_size = Jumbo_Frame_6k;
3604                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
3605                 CSR_WRITE_4(sc, RE_RXCFG, 0xC700);
3606                 break;
3607         case 0x3CB00000:
3608                 sc->re_type = MACFG_28;
3609                 sc->max_jumbo_frame_size = Jumbo_Frame_6k;
3610                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
3611                 CSR_WRITE_4(sc, RE_RXCFG, 0xC700);
3612                 break;
3613         case 0x28100000:
3614                 sc->re_type = MACFG_31;
3615                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3616                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
3617                 CSR_WRITE_4(sc, RE_RXCFG, 0x8700);
3618                 break;
3619         case 0x28200000:
3620                 sc->re_type = MACFG_32;
3621                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3622                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
3623                 CSR_WRITE_4(sc, RE_RXCFG, 0x8700);
3624                 break;
3625         case 0x28300000:
3626                 sc->re_type = MACFG_33;
3627                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3628                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
3629                 CSR_WRITE_4(sc, RE_RXCFG, 0x8700);
3630                 break;
3631         case 0x2C100000:
3632                 sc->re_type = MACFG_36;
3633                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3634                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
3635                 CSR_WRITE_4(sc, RE_RXCFG, 0x8700);
3636                 break;
3637         case 0x2C200000:
3638                 sc->re_type = MACFG_37;
3639                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3640                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
3641                 CSR_WRITE_4(sc, RE_RXCFG, 0x8700);
3642                 break;
3643         case 0x2C800000:
3644                 sc->re_type = MACFG_38;
3645                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3646                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
3647                 CSR_WRITE_4(sc, RE_RXCFG, 0xBF00);
3648                 break;
3649         case 0x2C900000:
3650                 sc->re_type = MACFG_39;
3651                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3652                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
3653                 CSR_WRITE_4(sc, RE_RXCFG, 0xBF00);
3654                 break;
3655         case 0x24000000:
3656                 sc->re_type = MACFG_41;
3657                 sc->max_jumbo_frame_size = ETHERMTU;
3658                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
3659                 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
3660                 break;
3661         case 0x40900000:
3662                 sc->re_type = MACFG_42;
3663                 sc->max_jumbo_frame_size = ETHERMTU;
3664                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
3665                 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
3666                 break;
3667         case 0x40A00000:
3668         case 0x40B00000:
3669         case 0x40C00000:
3670                 sc->re_type = MACFG_43;
3671                 sc->max_jumbo_frame_size = ETHERMTU;
3672                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
3673                 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
3674                 break;
3675         case 0x48000000:
3676                 sc->re_type = MACFG_50;
3677                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3678                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
3679                 CSR_WRITE_4(sc, RE_RXCFG, 0xBF00);
3680                 break;
3681         case 0x48100000:
3682                 sc->re_type = MACFG_51;
3683                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3684                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
3685                 CSR_WRITE_4(sc, RE_RXCFG, 0xBF00);
3686                 break;
3687         case 0x48800000:
3688                 sc->re_type = MACFG_52;
3689                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3690                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
3691                 CSR_WRITE_4(sc, RE_RXCFG, 0xBF00);
3692                 break;
3693         case 0x44000000:
3694                 sc->re_type = MACFG_53;
3695                 sc->max_jumbo_frame_size = ETHERMTU;
3696                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
3697                 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
3698                 break;
3699         case 0x44800000:
3700                 sc->re_type = MACFG_54;
3701                 sc->max_jumbo_frame_size = ETHERMTU;
3702                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
3703                 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
3704                 break;
3705         case 0x44900000:
3706                 sc->re_type = MACFG_55;
3707                 sc->max_jumbo_frame_size = ETHERMTU;
3708                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
3709                 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
3710                 break;
3711         case 0x4C000000:
3712                 sc->re_type = MACFG_56;
3713                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3714                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
3715                 CSR_WRITE_4(sc, RE_RXCFG, 0xCF00);
3716                 break;
3717         case 0x4C100000:
3718                 sc->re_type = MACFG_57;
3719                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3720                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
3721                 CSR_WRITE_4(sc, RE_RXCFG, 0xCF00);
3722                 break;
3723         case 0x50800000:
3724                 sc->re_type = MACFG_58;
3725                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3726                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
3727                 CSR_WRITE_4(sc, RE_RXCFG, 0xCF00);
3728                 break;
3729         case 0x50900000:
3730                 sc->re_type = MACFG_59;
3731                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3732                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
3733                 CSR_WRITE_4(sc, RE_RXCFG, 0xCF00);
3734                 break;
3735         case 0x5C800000:
3736                 sc->re_type = MACFG_60;
3737                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3738                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
3739                 CSR_WRITE_4(sc, RE_RXCFG, 0xCF00);
3740                 break;
3741         case 0x50000000:
3742                 sc->re_type = MACFG_61;
3743                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3744                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
3745                 CSR_WRITE_4(sc, RE_RXCFG, 0xCF00);
3746                 break;
3747         case 0x50100000:
3748                 sc->re_type = MACFG_62;
3749                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3750                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
3751                 CSR_WRITE_4(sc, RE_RXCFG, 0xCF00);
3752                 break;
3753         case 0x50200000:
3754                 sc->re_type = MACFG_67;
3755                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3756                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
3757                 CSR_WRITE_4(sc, RE_RXCFG, 0xCF00);
3758                 break;
3759         case 0x28800000:
3760                 sc->re_type = MACFG_63;
3761                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3762                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
3763                 CSR_WRITE_4(sc, RE_RXCFG, 0x8700);
3764                 break;
3765         case 0x28900000:
3766                 sc->re_type = MACFG_64;
3767                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3768                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
3769                 CSR_WRITE_4(sc, RE_RXCFG, 0x8700);
3770                 break;
3771         case 0x28A00000:
3772                 sc->re_type = MACFG_65;
3773                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3774                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
3775                 CSR_WRITE_4(sc, RE_RXCFG, 0x8700);
3776                 break;
3777         case 0x28B00000:
3778                 sc->re_type = MACFG_66;
3779                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3780                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
3781                 CSR_WRITE_4(sc, RE_RXCFG, 0x8700);
3782                 break;
3783         case 0x54000000:
3784                 sc->re_type = MACFG_68;
3785                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3786                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
3787                 CSR_WRITE_4(sc, RE_RXCFG, 0xCF00);
3788                 break;
3789         case 0x54100000:
3790                 sc->re_type = MACFG_69;
3791                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3792                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
3793                 CSR_WRITE_4(sc, RE_RXCFG, 0xCF00);
3794                 break;
3795         case 0x54900000:
3796                 sc->re_type = MACFG_70;
3797                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3798                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
3799                 CSR_WRITE_4(sc, RE_RXCFG, 0xCF00);
3800                 break;
3801         case 0x54A00000:
3802                 sc->re_type = MACFG_71;
3803                 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
3804                 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
3805                 CSR_WRITE_4(sc, RE_RXCFG, 0xCF00);
3806                 break;
3807         default:
3808                 device_printf(dev,"unknown device\n");
3809                 sc->re_type = MACFG_FF;
3810                 error = ENXIO;
3811                 break;
3812         }
3813
3814         switch(sc->re_device_id) {
3815         case RT_DEVICEID_8169:
3816         case RT_DEVICEID_8169SC:
3817         case RT_DEVICEID_8168:
3818         case RT_DEVICEID_8161:
3819                 //do nothing
3820                 break;
3821         default:
3822                 sc->max_jumbo_frame_size = ETHERMTU;
3823                 break;
3824         }
3825
3826         return error;
3827 }
3828
3829 static void re_init_software_variable(struct re_softc *sc)
3830 {
3831         switch(sc->re_device_id) {
3832         case RT_DEVICEID_8168:
3833         case RT_DEVICEID_8161:
3834         case RT_DEVICEID_8136:
3835                 sc->re_if_flags |= RL_FLAG_PCIE;
3836                 break;
3837         }
3838
3839         sc->re_rx_mbuf_sz = sc->max_jumbo_frame_size + ETHER_VLAN_ENCAP_LEN + ETHER_HDR_LEN + ETHER_CRC_LEN + RE_ETHER_ALIGN + 1;
3840
3841         if (sc->re_rx_mbuf_sz > MJUM9BYTES) {
3842                 sc->max_jumbo_frame_size -= (sc->re_rx_mbuf_sz - MJUM9BYTES);
3843                 sc->re_rx_mbuf_sz = MJUM9BYTES;
3844         }
3845
3846         switch(sc->re_type) {
3847         case MACFG_63:
3848         case MACFG_64:
3849         case MACFG_65:
3850         case MACFG_66:
3851                 sc->HwSuppDashVer = 1;
3852                 break;
3853         case MACFG_61:
3854         case MACFG_62:
3855         case MACFG_67:
3856                 sc->HwSuppDashVer = 2;
3857                 break;
3858         case MACFG_70:
3859         case MACFG_71:
3860                 sc->HwSuppDashVer = 3;
3861                 break;
3862         default:
3863                 sc->HwSuppDashVer = 0;
3864                 break;
3865         }
3866
3867         switch(sc->re_type) {
3868         case MACFG_70:
3869         case MACFG_71:
3870                 sc->HwPkgDet = MP_ReadMcuAccessRegWord(sc, 0xDC00);
3871                 sc->HwPkgDet = (sc->HwPkgDet >> 3) & 0x0F;
3872                 //printf("Realtek PCIe GBE Family Controller HwPkgDet = 0x%02X\n",
3873                 //       sc->HwPkgDet);
3874                 break;
3875         }
3876
3877         if (HW_DASH_SUPPORT_TYPE_3(sc) && sc->HwPkgDet == 0x06)
3878                 eee_enable = 0;
3879
3880         if (HW_DASH_SUPPORT_DASH(sc))
3881                 sc->re_dash = re_check_dash(sc);
3882
3883         if (sc->re_dash) {
3884                 if (HW_DASH_SUPPORT_TYPE_3(sc)) {
3885                         u_int64_t CmacMemPhysAddress;
3886                         bus_space_handle_t cmac_ioaddr;
3887
3888                         CmacMemPhysAddress = MP_ReadOtherFunPciEConfigSpace(sc, 0, 0xf018);
3889                         if (!(CmacMemPhysAddress & BIT_0)) {
3890                                 if (CmacMemPhysAddress & BIT_2)
3891                                         CmacMemPhysAddress |=  MP_ReadOtherFunPciEConfigSpace(sc, 0, 0xf01c) << 16;
3892
3893                                 CmacMemPhysAddress &=  0xFFFFFFF0;
3894                                 /* ioremap MMIO region */
3895 #ifndef __DragonFly__
3896                                 sc->re_mapped_cmac_tag = X86_BUS_SPACE_MEM;
3897 #else
3898                                 sc->re_mapped_cmac_tag = X86_64_BUS_SPACE_MEM;
3899 #endif
3900                                 if (bus_space_map(sc->re_mapped_cmac_tag, CmacMemPhysAddress, RE_REGS_SIZE, 0,
3901                                                   &cmac_ioaddr))
3902                                         sc->re_dash = 0;
3903                                 else
3904                                         sc->re_mapped_cmac_handle = cmac_ioaddr;
3905                         }
3906                 }
3907         }
3908
3909         switch(sc->re_type) {
3910         case MACFG_61:
3911         case MACFG_62:
3912         case MACFG_67:
3913                 sc->re_cmac_handle = sc->re_bhandle;
3914                 sc->re_cmac_tag = sc->re_btag;
3915                 break;
3916         case MACFG_70:
3917         case MACFG_71:
3918                 sc->re_cmac_handle = sc->re_mapped_cmac_handle;
3919                 sc->re_cmac_tag = sc->re_mapped_cmac_tag;
3920                 break;
3921         }
3922
3923         switch(sc->re_type) {
3924         case MACFG_14:
3925         case MACFG_15:
3926         case MACFG_16:
3927         case MACFG_17:
3928         case MACFG_18:
3929         case MACFG_19:
3930         case MACFG_31:
3931         case MACFG_32:
3932         case MACFG_33:
3933         case MACFG_41:
3934         case MACFG_63:
3935         case MACFG_64:
3936         case MACFG_65:
3937         case MACFG_66:
3938                 sc->re_efuse_ver = EFUSE_SUPPORT_V1;
3939                 break;
3940         case MACFG_36:
3941         case MACFG_37:
3942         case MACFG_42:
3943         case MACFG_43:
3944         case MACFG_54:
3945         case MACFG_55:
3946                 sc->re_efuse_ver = EFUSE_SUPPORT_V2;
3947                 break;
3948         case MACFG_38:
3949         case MACFG_39:
3950         case MACFG_50:
3951         case MACFG_51:
3952         case MACFG_52:
3953         case MACFG_53:
3954         case MACFG_56:
3955         case MACFG_57:
3956         case MACFG_58:
3957         case MACFG_59:
3958         case MACFG_60:
3959         case MACFG_61:
3960         case MACFG_62:
3961         case MACFG_67:
3962         case MACFG_68:
3963         case MACFG_69:
3964         case MACFG_70:
3965         case MACFG_71:
3966                 sc->re_efuse_ver = EFUSE_SUPPORT_V3;
3967                 break;
3968         default:
3969                 sc->re_efuse_ver = EFUSE_NOT_SUPPORT;
3970                 break;
3971         }
3972
3973         switch(sc->re_type) {
3974         case MACFG_69: {
3975                 u_int16_t ioffset_p3, ioffset_p2, ioffset_p1, ioffset_p0;
3976                 u_int16_t TmpUshort;
3977
3978                 MP_WriteMcuAccessRegWord(sc, 0xDD02, 0x807D);
3979
3980                 TmpUshort = MP_ReadMcuAccessRegWord(sc, 0xDD02);
3981                 ioffset_p3 = ((TmpUshort & BIT_7) >>7);
3982                 ioffset_p3 <<= 3;
3983                 TmpUshort = MP_ReadMcuAccessRegWord(sc, 0xDD00);
3984
3985                 ioffset_p3 |= ((TmpUshort & (BIT_15 | BIT_14 | BIT_13))>>13);
3986
3987                 ioffset_p2 = ((TmpUshort & (BIT_12|BIT_11|BIT_10|BIT_9))>>9);
3988                 ioffset_p1 = ((TmpUshort & (BIT_8|BIT_7|BIT_6|BIT_5))>>5);
3989
3990                 ioffset_p0 = ((TmpUshort & BIT_4) >>4);
3991                 ioffset_p0 <<= 3;
3992                 ioffset_p0 |= (TmpUshort & (BIT_2| BIT_1 | BIT_0));
3993
3994                 if ((ioffset_p3 == 0x0F) && (ioffset_p2 == 0x0F) && (ioffset_p1 == 0x0F) && (ioffset_p0 == 0x0F)) {
3995                         sc->RequireAdcBiasPatch = FALSE;
3996                 } else {
3997                         sc->RequireAdcBiasPatch = TRUE;
3998                         sc->AdcBiasPatchIoffset = (ioffset_p3<<12)|(ioffset_p2<<8)|(ioffset_p1<<4)|(ioffset_p0);
3999                 }
4000         }
4001         break;
4002         }
4003
4004         switch(sc->re_type) {
4005         case MACFG_68:
4006         case MACFG_69:
4007         case MACFG_70:
4008         case MACFG_71: {
4009                 u_int16_t rg_saw_cnt;
4010
4011                 MP_WritePhyUshort(sc, 0x1F, 0x0C42);
4012                 rg_saw_cnt = MP_ReadPhyUshort(sc, 0x13);
4013                 rg_saw_cnt &= ~(BIT_15|BIT_14);
4014                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
4015
4016                 if (rg_saw_cnt > 0) {
4017                         sc->SwrCnt1msIni = 16000000/rg_saw_cnt;
4018                         sc->SwrCnt1msIni &= 0x0FFF;
4019
4020                         sc->RequireAdjustUpsTxLinkPulseTiming = TRUE;
4021                 }
4022         }
4023         break;
4024         }
4025
4026         switch(sc->re_type) {
4027         case MACFG_31:
4028         case MACFG_32:
4029         case MACFG_33:
4030         case MACFG_36:
4031         case MACFG_37:
4032         case MACFG_38:
4033         case MACFG_39:
4034         case MACFG_42:
4035         case MACFG_43:
4036         case MACFG_50:
4037         case MACFG_51:
4038         case MACFG_52:
4039         case MACFG_53:
4040         case MACFG_54:
4041         case MACFG_55:
4042         case MACFG_56:
4043         case MACFG_57:
4044         case MACFG_58:
4045         case MACFG_59:
4046         case MACFG_60:
4047         case MACFG_61:
4048         case MACFG_62:
4049         case MACFG_63:
4050         case MACFG_64:
4051         case MACFG_65:
4052         case MACFG_66:
4053         case MACFG_67:
4054         case MACFG_68:
4055         case MACFG_69:
4056         case MACFG_70:
4057         case MACFG_71:
4058                 sc->re_hw_enable_msi_msix = TRUE;
4059                 break;
4060         }
4061
4062         switch(sc->re_type) {
4063         case MACFG_3:
4064         case MACFG_4:
4065         case MACFG_5:
4066         case MACFG_6:
4067         case MACFG_11:
4068         case MACFG_12:
4069         case MACFG_13:
4070         case MACFG_21:
4071         case MACFG_22:
4072         case MACFG_23:
4073         case MACFG_24:
4074         case MACFG_25:
4075         case MACFG_26:
4076         case MACFG_27:
4077         case MACFG_28:
4078         case MACFG_41:
4079         case MACFG_42:
4080         case MACFG_43:
4081 #ifdef __DragonFly__
4082         case MACFG_50:
4083 #endif
4084         case MACFG_54:
4085         case MACFG_55:
4086                 sc->re_coalesce_tx_pkt = TRUE;
4087 #ifdef __DragonFly__
4088                 if (sc->re_type != MACFG_50)
4089                         sc->re_pad_runt = TRUE;
4090 #endif
4091                 break;
4092         }
4093
4094         switch(sc->re_type) {
4095         case MACFG_36:
4096         case MACFG_37:
4097         case MACFG_38:
4098         case MACFG_39:
4099         case MACFG_42:
4100         case MACFG_43:
4101         case MACFG_50:
4102         case MACFG_51:
4103         case MACFG_52:
4104         case MACFG_53:
4105         case MACFG_54:
4106         case MACFG_55:
4107         case MACFG_56:
4108         case MACFG_57:
4109         case MACFG_58:
4110         case MACFG_59:
4111         case MACFG_60:
4112         case MACFG_61:
4113         case MACFG_62:
4114         case MACFG_67:
4115         case MACFG_68:
4116         case MACFG_69:
4117         case MACFG_70:
4118         case MACFG_71:
4119                 sc->re_hw_supp_now_is_oob_ver = 1;
4120                 break;
4121         }
4122
4123         switch (sc->re_type) {
4124         case MACFG_36:
4125         case MACFG_37:
4126                 sc->re_sw_ram_code_ver = NIC_RAMCODE_VERSION_8168E;
4127                 break;
4128         case MACFG_38:
4129         case MACFG_39:
4130                 sc->re_sw_ram_code_ver = NIC_RAMCODE_VERSION_8168EVL;
4131                 break;
4132         case MACFG_50:
4133         case MACFG_51:
4134                 sc->re_sw_ram_code_ver = NIC_RAMCODE_VERSION_8168F;
4135                 break;
4136         case MACFG_52:
4137                 sc->re_sw_ram_code_ver = NIC_RAMCODE_VERSION_8411;
4138                 break;
4139         case MACFG_56:
4140         case MACFG_57:
4141                 sc->re_sw_ram_code_ver = NIC_RAMCODE_VERSION_8168G;
4142                 break;
4143         case MACFG_58:
4144         case MACFG_59:
4145                 sc->re_sw_ram_code_ver = NIC_RAMCODE_VERSION_8168GU;
4146                 break;
4147         case MACFG_60:
4148                 sc->re_sw_ram_code_ver = NIC_RAMCODE_VERSION_8411B;
4149                 break;
4150         case MACFG_61:
4151         case MACFG_62:
4152         case MACFG_67:
4153                 sc->re_sw_ram_code_ver = NIC_RAMCODE_VERSION_8168EP;
4154                 break;
4155         case MACFG_68:
4156         case MACFG_69:
4157                 sc->re_sw_ram_code_ver = NIC_RAMCODE_VERSION_8168H;
4158                 break;
4159         case MACFG_70:
4160         case MACFG_71:
4161                 sc->re_sw_ram_code_ver = NIC_RAMCODE_VERSION_8168FP;
4162                 break;
4163         }
4164
4165         sc->re_8169_MacVersion=(CSR_READ_4(sc, RE_TXCFG)&0x7c800000)>>25;               /* Get bit 26~30        */
4166         sc->re_8169_MacVersion|=((CSR_READ_4(sc, RE_TXCFG)&0x00800000)!=0 ? 1:0);       /* Get bit 23           */
4167         DBGPRINT1(sc->re_unit,"8169 Mac Version %d",sc->re_8169_MacVersion);
4168
4169         /* Rtl8169s single chip detected */
4170         if (sc->re_type == MACFG_3) {
4171                 RE_LOCK(sc);
4172                 sc->re_8169_PhyVersion=(MP_ReadPhyUshort(sc, 0x03)&0x000f);
4173                 DBGPRINT1(sc->re_unit,"8169 Phy Version %d",sc->re_8169_PhyVersion);
4174                 RE_UNLOCK(sc);
4175         }
4176
4177 #ifndef __DragonFly__
4178         sc->link_state = LINK_STATE_UNKNOWN;
4179 #endif
4180 }
4181
4182 static void re_hw_d3_para(struct re_softc *sc)
4183 {
4184         if (sc->re_type == MACFG_59 || sc->re_type == MACFG_60 ||
4185             sc->re_type == MACFG_62 || sc->re_type == MACFG_67 ||
4186             sc->re_type == MACFG_68 || sc->re_type == MACFG_69 ||
4187             sc->re_type == MACFG_70 || sc->re_type == MACFG_71) {
4188                 MP_WritePhyOcpRegWord(sc, 0x0C41, 0x13, 0x0000);
4189                 MP_WritePhyOcpRegWord(sc, 0x0C41, 0x13, 0x0500);
4190         }
4191 }
4192
4193 #ifndef __DragonFly__
4194 /*
4195 * Attach the interface. Allocate softc structures, do ifmedia
4196 * setup and ethernet/BPF attach.
4197 */
4198 static int re_attach(device_t dev)
4199 {
4200         /*int                   s;*/
4201         u_char                  eaddr[ETHER_ADDR_LEN];
4202         u_int32_t               command;
4203         struct re_softc         *sc;
4204         struct ifnet            *ifp;
4205         int                     unit, error = 0, rid, i;
4206 //      int                     mac_version;
4207 //      int                     mode;
4208 //      u_int8_t                data8;
4209         int     reg;
4210         int             msic=0, msixc=0;
4211
4212         /*s = splimp();*/
4213
4214         sc = device_get_softc(dev);
4215         unit = device_get_unit(dev);
4216         bzero(sc, sizeof(struct re_softc));
4217         RE_LOCK_INIT(sc,device_get_nameunit(dev));
4218         sc->dev = dev;
4219
4220         sc->driver_detach = 0;
4221
4222         sc->re_device_id = pci_get_device(dev);
4223         sc->re_revid = pci_get_revid(dev);
4224         pci_enable_busmaster(dev);
4225
4226         /*
4227          * Map control/status registers.
4228          */
4229         command = pci_read_config(dev, PCIR_COMMAND, 4);
4230         command |= (PCIM_CMD_PORTEN|PCIM_CMD_MEMEN|PCIM_CMD_BUSMASTEREN);
4231         pci_write_config(dev, PCIR_COMMAND, command, 4);
4232         command = pci_read_config(dev, PCIR_COMMAND, 4);
4233
4234         if (prefer_iomap == 0) {
4235                 sc->re_res_id = PCIR_BAR(1);
4236                 sc->re_res_type = SYS_RES_MEMORY;
4237                 /* PCIE NIC use different BARs. */
4238                 if (sc->re_device_id == RT_DEVICEID_8168 || sc->re_device_id == RT_DEVICEID_8161 ||
4239                     sc->re_device_id == RT_DEVICEID_8136)
4240                         sc->re_res_id = PCIR_BAR(2);
4241         } else {
4242                 sc->re_res_id = PCIR_BAR(0);
4243                 sc->re_res_type = SYS_RES_IOPORT;
4244         }
4245         sc->re_res = bus_alloc_resource(dev, sc->re_res_type, &sc->re_res_id,
4246                                         0, ~0, 1, RF_ACTIVE);
4247         if (sc->re_res == NULL && prefer_iomap == 0) {
4248                 sc->re_res_id = PCIR_BAR(0);
4249                 sc->re_res_type = SYS_RES_IOPORT;
4250                 sc->re_res = bus_alloc_resource(dev, sc->re_res_type, &sc->re_res_id,
4251                                                 0, ~0, 1, RF_ACTIVE);
4252         }
4253
4254         if (sc->re_res == NULL) {
4255                 device_printf(dev,"couldn't map ports/memory\n");
4256                 error = ENXIO;
4257                 goto fail;
4258         }
4259
4260         if (sc->re_res_type == SYS_RES_IOPORT)
4261                 device_printf(dev, "Using I/O Ports\n");
4262         else
4263                 device_printf(dev, "Using Memory Mapping!\n");
4264
4265         sc->re_btag = rman_get_bustag(sc->re_res);
4266         sc->re_bhandle = rman_get_bushandle(sc->re_res);
4267
4268         error = re_check_mac_version(sc);
4269
4270         if (error) {
4271                 goto fail;
4272         }
4273
4274         re_init_software_variable(sc);
4275
4276 #if OS_VER >= VERSION(7,0)
4277         msic = pci_msi_count(dev);
4278         msixc = pci_msix_count(dev);
4279         if (pci_find_cap(dev, PCIY_EXPRESS, &reg) == 0) {
4280                 sc->re_if_flags |= RL_FLAG_PCIE;
4281                 sc->re_expcap = reg;
4282         } else {
4283                 sc->re_if_flags &= ~RL_FLAG_PCIE;
4284                 sc->re_expcap = 0;
4285         }
4286
4287         //device_printf(dev, "MSI count : %d\n", msic);
4288         //device_printf(dev, "MSI-X count : %d\n", msixc);
4289         if (sc->re_hw_enable_msi_msix == FALSE) {
4290                 msixc = 0;
4291                 msic = 0;
4292         }
4293         if (msix_disable > 0)
4294                 msixc = 0;
4295         if (msi_disable > 0)
4296                 msic = 0;
4297
4298         /* Prefer MSI-X to MSI. */
4299         if (msixc > 0) {
4300                 rid = PCIR_BAR(4);
4301                 msixc = RL_MSI_MESSAGES;
4302                 sc->re_res_pba = bus_alloc_resource_any(dev, SYS_RES_MEMORY,
4303                                                         &rid, RF_ACTIVE);
4304                 if (sc->re_res_pba == NULL) {
4305                         device_printf(dev,
4306                                       "could not allocate MSI-X PBA resource\n");
4307                 }
4308                 if (sc->re_res_pba != NULL &&
4309                     pci_alloc_msix(dev, &msixc) == 0) {
4310                         if (msixc == RL_MSI_MESSAGES) {
4311                                 device_printf(dev, "Using %d MSI-X message\n",
4312                                               msixc);
4313                                 sc->re_if_flags |= RL_FLAG_MSIX;
4314                         } else
4315                                 pci_release_msi(dev);
4316                 }
4317                 if ((sc->re_if_flags & RL_FLAG_MSIX) == 0) {
4318                         if (sc->re_res_pba != NULL)
4319                                 bus_release_resource(dev, SYS_RES_MEMORY, rid,
4320                                                      sc->re_res_pba);
4321                         sc->re_res_pba = NULL;
4322                         msixc = 0;
4323                 }
4324         }
4325
4326         /* Prefer MSI to INTx. */
4327         if (msixc == 0 && msic > 0) {
4328                 msic = RL_MSI_MESSAGES;
4329                 if (pci_alloc_msi(dev, &msic) == 0) {
4330                         if (msic == RL_MSI_MESSAGES) {
4331                                 device_printf(dev, "Using %d MSI message\n",
4332                                               msic);
4333                                 sc->re_if_flags |= RL_FLAG_MSI;
4334                         } else
4335                                 pci_release_msi(dev);
4336                 }
4337                 if ((sc->re_if_flags & RL_FLAG_MSI) == 0)
4338                         msic = 0;
4339         }
4340 #endif //OS_VER >= VERSION(7,0)
4341
4342         if ((sc->re_if_flags & (RL_FLAG_MSI | RL_FLAG_MSIX)) == 0) {
4343                 rid = 0;
4344                 sc->re_irq = bus_alloc_resource(dev, SYS_RES_IRQ, &rid, 0, ~0, 1,
4345                                                 RF_SHAREABLE | RF_ACTIVE);
4346
4347                 if (sc->re_irq == NULL) {
4348                         device_printf(dev,"couldn't map interrupt\n");
4349                         error = ENXIO;
4350                         goto fail;
4351                 }
4352                 device_printf(dev, "Using line-based interrupt\n");
4353         } else {
4354                 rid = 1;
4355                 sc->re_irq = bus_alloc_resource_any(dev,
4356                                                     SYS_RES_IRQ, &rid, RF_ACTIVE);
4357                 if (sc->re_irq == NULL) {
4358                         device_printf(dev,
4359                                       "couldn't allocate IRQ resources for "
4360                                       "message %d\n", rid);
4361                         error = ENXIO;
4362                         goto fail;
4363                 }
4364         }
4365
4366 #if OS_VER >= VERSION(7,3)
4367         /* Disable ASPM L0S/L1 and Clock Request. */
4368         if (sc->re_expcap != 0) {
4369                 u_int32_t               cap, ctl;
4370                 cap = pci_read_config(dev, sc->re_expcap +
4371                                       RE_PCIER_LINK_CAP, 2);
4372                 if ((cap & RE_PCIEM_LINK_CAP_ASPM) != 0) {
4373                         ctl = pci_read_config(dev, sc->re_expcap +
4374                                               RE_PCIER_LINK_CTL, 2);
4375                         if ((ctl & 0x0103) != 0) {
4376                                 ctl &= ~0x0103;
4377                                 pci_write_config(dev, sc->re_expcap +
4378                                                  RE_PCIER_LINK_CTL, ctl, 2);
4379                                 device_printf(dev, "ASPM disabled\n");
4380                         }
4381                 } else
4382                         device_printf(dev, "no ASPM capability\n");
4383         }
4384 #endif //OS_VER >= VERSION(7,3)
4385
4386         re_init_timer(sc);
4387
4388         RE_LOCK(sc);
4389         re_exit_oob(sc);
4390         re_hw_init(sc);
4391         RE_UNLOCK(sc);
4392
4393         /*
4394          * Reset the adapter. Only take the lock here as it's needed in
4395          * order to call re_reset().
4396          */
4397         RE_LOCK(sc);
4398         re_reset(sc);
4399         RE_UNLOCK(sc);
4400
4401         /* Get station address. */
4402         RE_LOCK(sc);
4403         re_get_hw_mac_address(sc, eaddr);
4404         RE_UNLOCK(sc);
4405
4406         /*
4407          * A RealTek chip was detected. Inform the world.
4408          */
4409         device_printf(dev,"version:1.95.00\n");
4410         device_printf(dev,"Ethernet address: %6D\n", eaddr, ":");
4411         printf("\nThis product is covered by one or more of the following patents: \
4412            \nUS6,570,884, US6,115,776, and US6,327,625.\n");
4413
4414         sc->re_unit = unit;
4415
4416 #if OS_VER < VERSION(6,0)
4417         bcopy(eaddr, (char *)&sc->arpcom.ac_enaddr, ETHER_ADDR_LEN);
4418 #endif
4419
4420         if (sc->re_type == MACFG_3) {   /* Change PCI Latency time*/
4421                 pci_write_config(dev, RE_PCI_LATENCY_TIMER, 0x40, 1);
4422         }
4423
4424         error = bus_dma_tag_create(
4425 #if OS_VER < VERSION(7,0)
4426                         NULL,
4427 #else
4428                         bus_get_dma_tag(dev),           /* parent */
4429 #endif
4430                         1, 0,           /* alignment, boundary */
4431                         BUS_SPACE_MAXADDR,              /* lowaddr */
4432                         BUS_SPACE_MAXADDR,              /* highaddr */
4433                         NULL, NULL,                     /* filter, filterarg */
4434                         BUS_SPACE_MAXSIZE_32BIT,        /* maxsize */
4435                         0,                              /* nsegments */
4436                         BUS_SPACE_MAXSIZE_32BIT,        /* maxsegsize */
4437                         0,                              /* flags */
4438                         NULL, NULL,                     /* lockfunc, lockarg */
4439                         &sc->re_parent_tag);
4440
4441         i = roundup2(sizeof(union RxDesc)*RE_RX_BUF_NUM, RE_DESC_ALIGN);
4442         error = bus_dma_tag_create(
4443                         sc->re_parent_tag,
4444                         RE_DESC_ALIGN, 0,               /* alignment, boundary */
4445                         BUS_SPACE_MAXADDR,              /* lowaddr */
4446                         BUS_SPACE_MAXADDR,              /* highaddr */
4447                         NULL, NULL,                     /* filter, filterarg */
4448                         i,                              /* maxsize */
4449                         1,                              /* nsegments */
4450                         i,                              /* maxsegsize */
4451                         0,                              /* flags */
4452                         NULL, NULL,                     /* lockfunc, lockarg */
4453                         &sc->re_desc.rx_desc_tag);
4454         if (error) {
4455                 device_printf(dev,"bus_dma_tag_create fail\n");
4456                 goto fail;
4457         }
4458
4459         error = bus_dmamem_alloc(sc->re_desc.rx_desc_tag,
4460                                  (void**) &sc->re_desc.rx_desc,
4461                                  BUS_DMA_WAITOK|BUS_DMA_COHERENT|BUS_DMA_ZERO,
4462                                  &sc->re_desc.rx_desc_dmamap);
4463         if (error) {
4464                 device_printf(dev,"bus_dmamem_alloc fail\n");
4465                 goto fail;
4466         }
4467
4468         i = roundup2(sizeof(union TxDesc)*RE_TX_BUF_NUM, RE_DESC_ALIGN);
4469         error = bus_dma_tag_create(
4470                         sc->re_parent_tag,
4471                         RE_DESC_ALIGN, 0,               /* alignment, boundary */
4472                         BUS_SPACE_MAXADDR,              /* lowaddr */
4473                         BUS_SPACE_MAXADDR,              /* highaddr */
4474                         NULL, NULL,                     /* filter, filterarg */
4475                         i,                              /* maxsize */
4476                         1,                              /* nsegments */
4477                         i,                              /* maxsegsize */
4478                         0,                              /* flags */
4479                         NULL, NULL,                     /* lockfunc, lockarg */
4480                         &sc->re_desc.tx_desc_tag);
4481         if (error) {
4482                 device_printf(dev,"bus_dma_tag_create fail\n");
4483                 goto fail;
4484         }
4485
4486         error = bus_dmamem_alloc(sc->re_desc.tx_desc_tag,
4487                                  (void**) &sc->re_desc.tx_desc,
4488                                  BUS_DMA_WAITOK|BUS_DMA_COHERENT|BUS_DMA_ZERO,
4489                                  &sc->re_desc.tx_desc_dmamap);
4490
4491         if (error) {
4492                 device_printf(dev,"bus_dmamem_alloc fail\n");
4493                 goto fail;
4494         }
4495
4496         RE_LOCK(sc);
4497         re_phy_power_up(dev);
4498         re_hw_phy_config(sc);
4499         re_clrwol(sc);
4500         RE_UNLOCK(sc);
4501
4502         sc->re_tx_cstag =1;
4503         sc->re_rx_cstag =1;
4504
4505 #if OS_VER < VERSION(6,0)
4506         ifp = &sc->arpcom.ac_if;
4507 #else
4508         ifp = sc->re_ifp = if_alloc(IFT_ETHER);
4509         if (ifp == NULL) {
4510                 device_printf(dev, "can not if_alloc()\n");
4511                 error = ENOSPC;
4512                 goto fail;
4513         }
4514 #endif
4515         ifp->if_softc = sc;
4516 #if OS_VER < VERSION(5,3)
4517         ifp->if_unit = unit;
4518         ifp->if_name = "re";
4519 #else
4520         if_initname(ifp, device_get_name(dev), device_get_unit(dev));
4521 #endif
4522         ifp->if_mtu = ETHERMTU;
4523         ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
4524         ifp->if_ioctl = re_ioctl;
4525         ifp->if_output = ether_output;
4526         ifp->if_start = re_start;
4527 #if OS_VER < VERSION(7,0)
4528         ifp->if_watchdog = re_watchdog;
4529 #endif
4530         if ((sc->re_type == MACFG_24) || (sc->re_type == MACFG_25) || (sc->re_type == MACFG_26))
4531                 ifp->if_hwassist |= CSUM_TCP | CSUM_UDP;
4532         else
4533                 ifp->if_hwassist |= RE_CSUM_FEATURES;
4534
4535         ifp->if_capabilities = IFCAP_HWCSUM;
4536         ifp->if_capenable = ifp->if_capabilities;
4537         CSR_WRITE_2 (sc, RE_CPlusCmd,CSR_READ_2(sc, RE_CPlusCmd) |RL_RxChkSum);
4538         ifp->if_init = re_init;
4539         /* VLAN capability setup */
4540         ifp->if_capabilities |= IFCAP_VLAN_MTU | IFCAP_VLAN_HWTAGGING;
4541         ifp->if_capenable = ifp->if_capabilities;
4542
4543         /* Enable WOL if PM is supported. */
4544         if (pci_find_cap(sc->dev, PCIY_PMG, &reg) == 0)
4545                 ifp->if_capabilities |= IFCAP_WOL;
4546         ifp->if_capenable = ifp->if_capabilities;
4547         ifp->if_capenable &= ~(IFCAP_WOL_UCAST | IFCAP_WOL_MCAST);
4548
4549         RE_LOCK(sc);
4550         set_rxbufsize(sc);
4551         error =re_alloc_buf(sc);
4552
4553         if (error) {
4554                 RE_UNLOCK(sc);
4555                 goto fail;
4556         }
4557         /* Init descriptors. */
4558         re_var_init(sc);
4559
4560         RE_UNLOCK(sc);
4561
4562         switch(sc->re_device_id) {
4563         case RT_DEVICEID_8169:
4564         case RT_DEVICEID_8169SC:
4565         case RT_DEVICEID_8168:
4566         case RT_DEVICEID_8161:
4567                 ifp->if_baudrate = 1000000000;
4568                 break;
4569
4570         default:
4571                 ifp->if_baudrate = 100000000;
4572                 break;
4573         }
4574         IFQ_SET_MAXLEN(&ifp->if_snd, IFQ_MAXLEN);
4575         ifp->if_snd.ifq_drv_maxlen = IFQ_MAXLEN;
4576         IFQ_SET_READY(&ifp->if_snd);
4577
4578 #if OS_VER>=VERSION(7,0)
4579         TASK_INIT(&sc->re_inttask, 0, re_int_task, sc);
4580 #endif
4581
4582         /*
4583          * Call MI attach routine.
4584          */
4585         /*#if OS_VER < VERSION(5, 1)*/
4586 #if OS_VER < VERSION(4,9)
4587         ether_ifattach(ifp, ETHER_BPF_SUPPORTED);
4588 #else
4589         ether_ifattach(ifp, eaddr);
4590 #endif
4591
4592 #if OS_VER < VERSION(7,0)
4593         error = bus_setup_intr(dev, sc->re_irq, INTR_TYPE_NET,
4594                                re_intr, sc, &sc->re_intrhand);
4595 #else
4596         error = bus_setup_intr(dev, sc->re_irq, INTR_TYPE_NET|INTR_MPSAFE,
4597                                re_intr, NULL, sc, &sc->re_intrhand);
4598 #endif
4599
4600         if (error) {
4601 #if OS_VER < VERSION(4,9)
4602                 ether_ifdetach(ifp, ETHER_BPF_SUPPORTED);
4603 #else
4604                 ether_ifdetach(ifp);
4605 #endif
4606                 device_printf(dev,"couldn't set up irq\n");
4607                 goto fail;
4608         }
4609
4610         /*
4611          * Specify the media types supported by this adapter and register
4612          * callbacks to update media and link information
4613          */
4614         ifmedia_init(&sc->media, IFM_IMASK, re_ifmedia_upd, re_ifmedia_sts);
4615         ifmedia_add(&sc->media, IFM_ETHER | IFM_10_T, 0, NULL);
4616         ifmedia_add(&sc->media, IFM_ETHER | IFM_10_T | IFM_FDX, 0, NULL);
4617         ifmedia_add(&sc->media, IFM_ETHER | IFM_100_TX, 0, NULL);
4618         ifmedia_add(&sc->media, IFM_ETHER | IFM_100_TX | IFM_FDX, 0, NULL);
4619         switch(sc->re_device_id) {
4620         case RT_DEVICEID_8169:
4621         case RT_DEVICEID_8169SC:
4622         case RT_DEVICEID_8168:
4623         case RT_DEVICEID_8161:
4624                 ifmedia_add(&sc->media, IFM_ETHER | IFM_1000_T | IFM_FDX, 0, NULL);
4625                 ifmedia_add(&sc->media, IFM_ETHER | IFM_1000_T, 0, NULL);
4626                 break;
4627
4628         default:
4629                 break;
4630         }
4631         ifmedia_add(&sc->media, IFM_ETHER | IFM_AUTO, 0, NULL);
4632         ifmedia_set(&sc->media, IFM_ETHER | IFM_AUTO);
4633         sc->media.ifm_media = IFM_ETHER | IFM_AUTO;
4634         re_ifmedia_upd(ifp);
4635
4636 fail:
4637         if (error)
4638                 re_detach(dev);
4639
4640         return(error);
4641 }
4642
4643 static int re_detach(device_t dev)
4644 {
4645         struct re_softc         *sc;
4646         struct ifnet            *ifp;
4647         /*int                   s;*/
4648         int                     i;
4649         int                     rid;
4650
4651         /*s = splimp();*/
4652
4653         sc = device_get_softc(dev);
4654
4655         ifp = RE_GET_IFNET(sc);
4656
4657         /* These should only be active if attach succeeded */
4658         if (device_is_attached(dev)) {
4659                 RE_LOCK(sc);
4660                 re_stop(sc);
4661                 RE_UNLOCK(sc);
4662 #if OS_VER>=VERSION(7,0)
4663                 taskqueue_drain(taskqueue_fast, &sc->re_inttask);
4664 #endif
4665 #if OS_VER < VERSION(4,9)
4666                 ether_ifdetach(ifp, ETHER_BPF_SUPPORTED);
4667 #else
4668                 ether_ifdetach(ifp);
4669 #endif
4670         }
4671
4672         bus_generic_detach(dev);
4673
4674         sc->driver_detach = 1;
4675
4676         if (sc->re_intrhand)
4677                 bus_teardown_intr(dev, sc->re_irq, sc->re_intrhand);
4678
4679 #if OS_VER>=VERSION(6,0)
4680         if (ifp)
4681                 if_free(ifp);
4682 #endif
4683
4684         if ((sc->re_if_flags & (RL_FLAG_MSI | RL_FLAG_MSIX)) == 0)
4685                 rid = 0;
4686         else
4687                 rid = 1;
4688         if (sc->re_irq) {
4689                 bus_release_resource(dev, SYS_RES_IRQ, rid, sc->re_irq);
4690                 sc->re_irq = NULL;
4691         }
4692         if ((sc->re_if_flags & (RL_FLAG_MSI | RL_FLAG_MSIX)) != 0)
4693                 pci_release_msi(dev);
4694         if (sc->re_res_pba) {
4695                 rid = PCIR_BAR(4);
4696                 bus_release_resource(dev, SYS_RES_MEMORY, rid, sc->re_res_pba);
4697         }
4698         if (sc->re_res)
4699                 bus_release_resource(dev, sc->re_res_type, sc->re_res_id, sc->re_res);
4700
4701         if (HW_DASH_SUPPORT_TYPE_3(sc) && sc->re_dash)
4702                 bus_space_unmap(sc->re_cmac_tag, sc->re_mapped_cmac_handle, RE_REGS_SIZE);
4703
4704         if (sc->re_desc.re_rx_mtag) {
4705                 for (i = 0; i < RE_RX_BUF_NUM; i++) {
4706                         if (sc->re_desc.rx_buf[i]!=NULL) {
4707                                 bus_dmamap_sync(sc->re_desc.re_rx_mtag,
4708                                                 sc->re_desc.re_rx_dmamap[i],
4709                                                 BUS_DMASYNC_POSTREAD);
4710                                 bus_dmamap_unload(sc->re_desc.re_rx_mtag,
4711                                                   sc->re_desc.re_rx_dmamap[i]);
4712                                 bus_dmamap_destroy(sc->re_desc.re_rx_mtag,
4713                                                    sc->re_desc.re_rx_dmamap[i]);
4714                                 m_freem(sc->re_desc.rx_buf[i]);
4715                                 sc->re_desc.rx_buf[i] =NULL;
4716                         }
4717                 }
4718                 bus_dma_tag_destroy(sc->re_desc.re_rx_mtag);
4719                 sc->re_desc.re_rx_mtag =0;
4720         }
4721
4722         if (sc->re_desc.re_tx_mtag) {
4723                 for (i = 0; i < RE_TX_BUF_NUM; i++) {
4724                         bus_dmamap_destroy(sc->re_desc.re_tx_mtag,
4725                                            sc->re_desc.re_tx_dmamap[i]);
4726                 }
4727                 bus_dma_tag_destroy(sc->re_desc.re_tx_mtag);
4728                 sc->re_desc.re_tx_mtag =0;
4729         }
4730
4731         if (sc->re_desc.rx_desc_tag) {
4732                 bus_dmamap_sync(sc->re_desc.rx_desc_tag,
4733                                 sc->re_desc.rx_desc_dmamap,
4734                                 BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE);
4735                 bus_dmamap_unload(sc->re_desc.rx_desc_tag,
4736                                   sc->re_desc.rx_desc_dmamap);
4737                 bus_dmamem_free(sc->re_desc.rx_desc_tag,
4738                                 sc->re_desc.rx_desc,
4739                                 sc->re_desc.rx_desc_dmamap);
4740                 bus_dma_tag_destroy(sc->re_desc.rx_desc_tag);
4741         }
4742
4743         if (sc->re_desc.tx_desc_tag) {
4744                 bus_dmamap_sync(sc->re_desc.tx_desc_tag,
4745                                 sc->re_desc.tx_desc_dmamap,
4746                                 BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE);
4747                 bus_dmamap_unload(sc->re_desc.tx_desc_tag,
4748                                   sc->re_desc.tx_desc_dmamap);
4749                 bus_dmamem_free(sc->re_desc.tx_desc_tag,
4750                                 sc->re_desc.tx_desc,
4751                                 sc->re_desc.tx_desc_dmamap);
4752                 bus_dma_tag_destroy(sc->re_desc.tx_desc_tag);
4753         }
4754
4755         if (sc->re_parent_tag) {
4756                 bus_dma_tag_destroy(sc->re_parent_tag);
4757         }
4758
4759         /*splx(s);*/
4760         RE_LOCK_DESTROY(sc);
4761
4762         return(0);
4763 }
4764 #endif  /* !__DragonFly__ */
4765
4766 #ifndef __DragonFly__
4767 static void
4768 re_link_state_change(struct ifnet *ifp, int link_state)
4769 {
4770 #if OS_VER>=VERSION(6,0)
4771         if_link_state_change(ifp, link_state);
4772 #else
4773         ifp->if_link_state = link_state
4774 #endif
4775 }
4776
4777 /*
4778   * Device suspend routine.  Stop the interface and save some PCI
4779   * settings in case the BIOS doesn't restore them properly on
4780   * resume.
4781   */
4782 static int
4783 re_suspend(device_t dev)
4784 {
4785         struct re_softc         *sc;
4786         struct ifnet            *ifp;
4787
4788         sc = device_get_softc(dev);
4789         RE_LOCK(sc);
4790         ifp = RE_GET_IFNET(sc);
4791         sc->re_link_chg_det = 0;
4792         re_stop(sc);
4793         re_hw_d3_para(sc);
4794         re_setwol(sc);
4795         sc->suspended = 1;
4796         sc->link_state = LINK_STATE_UNKNOWN;
4797         re_link_state_change(ifp, sc->link_state);
4798         sc->prohibit_access_reg = 1;
4799         RE_UNLOCK(sc);
4800
4801         return (0);
4802 }
4803
4804 /*
4805  * Device resume routine.  Restore some PCI settings in case the BIOS
4806  * doesn't, re-enable busmastering, and restart the interface if
4807  * appropriate.
4808  */
4809 static int
4810 re_resume(device_t dev)
4811 {
4812         struct re_softc         *sc;
4813         struct ifnet            *ifp;
4814
4815         sc = device_get_softc(dev);
4816
4817         RE_LOCK(sc);
4818
4819         ifp = RE_GET_IFNET(sc);
4820
4821         sc->prohibit_access_reg = 0;
4822
4823         re_exit_oob(sc);
4824
4825         re_hw_init(sc);
4826
4827         re_reset(sc);
4828
4829         re_phy_power_up(dev);
4830
4831         re_hw_phy_config(sc);
4832
4833         /*
4834          * Clear WOL matching such that normal Rx filtering
4835          * wouldn't interfere with WOL patterns.
4836          */
4837         re_clrwol(sc);
4838
4839         RE_UNLOCK(sc);
4840
4841         RE_LOCK(sc);
4842         re_ifmedia_upd(ifp);
4843         sc->suspended = 0;
4844         if (ifp->if_flags & IFF_UP) {
4845                 sc->re_link_chg_det = 1;
4846                 re_start_timer(sc);
4847         }
4848         RE_UNLOCK(sc);
4849
4850         return (0);
4851 }
4852 #endif  /* !__DragonFly__ */
4853
4854
4855 static void
4856 ClearAndSetPCIePhyBit(
4857         struct re_softc *sc,
4858         u_int8_t   addr,
4859         u_int16_t   clearmask,
4860         u_int16_t   setmask
4861 )
4862 {
4863         u_int16_t EphyValue;
4864
4865         EphyValue = MP_ReadEPhyUshort(sc, addr);
4866         EphyValue &= ~clearmask;
4867         EphyValue |= setmask;
4868         MP_WriteEPhyUshort(sc, addr, EphyValue);
4869 }
4870
4871 static void
4872 ClearPCIePhyBit(
4873         struct re_softc *sc,
4874         u_int8_t   addr,
4875         u_int16_t   mask
4876 )
4877 {
4878         ClearAndSetPCIePhyBit(sc,
4879                               addr,
4880                               mask,
4881                               0
4882                              );
4883 }
4884
4885 static void
4886 SetPCIePhyBit(
4887         struct re_softc *sc,
4888         u_int8_t   addr,
4889         u_int16_t   mask
4890 )
4891 {
4892         ClearAndSetPCIePhyBit(sc,
4893                               addr,
4894                               0,
4895                               mask
4896                              );
4897 }
4898
4899 #ifndef __DragonFly__
4900 /*
4901  * Stop all chip I/O so that the kernel's probe routines don't
4902  * get confused by errant DMAs when rebooting.
4903  */
4904 static int re_shutdown(dev)     /* The same with re_stop(sc) */
4905 device_t                dev;
4906 {
4907         struct re_softc         *sc;
4908
4909         sc = device_get_softc(dev);
4910
4911         if (sc->re_dash)
4912                 re_driver_stop(sc);
4913
4914         RE_LOCK(sc);
4915         sc->re_link_chg_det = 0;
4916         re_stop(sc);
4917         RE_UNLOCK(sc);
4918
4919         RE_LOCK(sc);
4920         re_hw_d3_para(sc);
4921         re_phy_power_down(dev);
4922         RE_UNLOCK(sc);
4923
4924         return 0;
4925 }
4926 #endif  /* !__DragonFly__ */
4927
4928 static void re_hw_start_unlock(struct re_softc *sc)
4929 {
4930         struct ifnet            *ifp;
4931         u_int32_t               macver;
4932         u_int8_t                data8;
4933         u_int16_t               data16 = 0;
4934         u_int32_t               Data32;
4935
4936         ifp = RE_GET_IFNET(sc);
4937
4938 #ifndef __DragonFly__
4939         /* Init descriptors. */
4940         re_var_init(sc);
4941 #endif
4942
4943         re_enable_cfg9346_write(sc);
4944
4945         switch(sc->re_type) {
4946         case MACFG_36:
4947         case MACFG_37:
4948         case MACFG_38:
4949         case MACFG_39:
4950         case MACFG_42:
4951         case MACFG_43:
4952         case MACFG_50:
4953         case MACFG_51:
4954         case MACFG_52:
4955         case MACFG_53:
4956         case MACFG_54:
4957         case MACFG_55:
4958         case MACFG_56:
4959         case MACFG_57:
4960         case MACFG_58:
4961         case MACFG_59:
4962         case MACFG_60:
4963         case MACFG_61:
4964         case MACFG_62:
4965         case MACFG_67:
4966         case MACFG_68:
4967         case MACFG_69:
4968         case MACFG_70:
4969         case MACFG_71:
4970                 CSR_WRITE_1(sc, RE_CFG5, CSR_READ_1(sc, RE_CFG5) & ~BIT_0);
4971                 CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2) & ~BIT_7);
4972                 CSR_WRITE_1(sc, 0xF1, CSR_READ_1(sc, 0xF1) & ~ BIT_7);
4973                 break;
4974         }
4975
4976         /*disable Link Down Power Saving(non-LDPS)*/
4977         /*CSR_WRITE_1(sc, RE_LDPS, 0x05);*/
4978         /*ldps= CSR_READ_1(sc, RE_LDPS);*/
4979
4980         CSR_WRITE_2(sc, RE_CPCR, 0x2060);
4981
4982         CSR_WRITE_2(sc, RE_IM, 0x5151);
4983
4984         CSR_WRITE_1(sc, RE_MTPS, 0x3f);
4985
4986         if (sc->re_device_id == RT_DEVICEID_8169 || sc->re_device_id == RT_DEVICEID_8169SC) {
4987                 //do nothing
4988         } else {
4989                 /* Set the initial TX configuration.*/
4990                 CSR_WRITE_4(sc, RE_TXCFG, RE_TXCFG_CONFIG);
4991         }
4992
4993         macver = CSR_READ_4(sc, RE_TXCFG) & 0xFC800000;
4994         if (macver == 0x00800000 || macver == 0x04000000 || macver == 0x10000000) {
4995                 CSR_WRITE_2(sc, RE_CPlusCmd, 0x0063| ((sc->re_type == MACFG_3 && sc->re_8169_MacVersion==1) ? 0x4008:0));
4996         } else if (macver == 0x18000000 || macver == 0x98000000) {
4997                 CSR_WRITE_2(sc, RE_CPlusCmd, 0x0068);
4998                 CSR_WRITE_2(sc, 0xe2, 0x0000);
4999         } else if (macver == 0x30000000) {
5000                 CSR_WRITE_2 (sc, RE_CPlusCmd, 0x2060);
5001                 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0);
5002
5003                 if (ifp->if_mtu > ETHERMTU) {
5004                         data8 = pci_read_config(sc->dev, 0x69, 1);
5005                         data8 &= ~0x70;
5006                         data8 |= 0x28;
5007                         pci_write_config(sc->dev, 0x69, data8, 1);
5008                 } else {
5009                         data8 = pci_read_config(sc->dev, 0x69, 1);
5010                         data8 &= ~0x70;
5011                         data8 |= 0x58;
5012                         pci_write_config(sc->dev, 0x69, data8, 1);
5013                 }
5014         } else if (macver == 0x38000000) {
5015                 CSR_WRITE_2 (sc, RE_CPlusCmd, 0x2060);
5016                 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0);
5017
5018                 if (ifp->if_mtu > ETHERMTU) {
5019                         data8 = pci_read_config(sc->dev, 0x69, 1);
5020                         data8 &= ~0x70;
5021                         data8 |= 0x28;
5022                         pci_write_config(sc->dev, 0x69, data8, 1);
5023                         CSR_WRITE_1(sc, RE_CFG4, CSR_READ_1(sc, RE_CFG4) | BIT_0);
5024                 } else {
5025                         data8 = pci_read_config(sc->dev, 0x69, 1);
5026                         data8 &= ~0x70;
5027                         data8 |= 0x58;
5028                         pci_write_config(sc->dev, 0x69, data8, 1);
5029                         CSR_WRITE_1(sc, RE_CFG4, CSR_READ_1(sc, RE_CFG4) & ~ BIT_0);
5030                 }
5031         } else if (macver == 0x34000000 || macver == 0xB4000000) {
5032                 CSR_WRITE_2 (sc, RE_CPlusCmd, 0x2060);
5033         } else if (macver == 0x34800000 || macver == 0x24800000) {
5034                 if (pci_read_config(sc->dev, 0x81, 1) == 1) {
5035                         CSR_WRITE_1(sc, RE_DBG_reg, 0x98);
5036                         CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2) | 0x80);
5037                         CSR_WRITE_1(sc, RE_CFG4, CSR_READ_1(sc, RE_CFG4) | 0x04);
5038                         pci_write_config(sc->dev, 0x81, 1, 1);
5039                 }
5040
5041                 data8 = pci_read_config(sc->dev, 0x79, 1);
5042                 data8 &= ~0x70;
5043                 data8 |= 0x50;
5044                 pci_write_config(sc->dev, 0x79, data8, 1);
5045
5046                 /*set configuration space offset 0x70f to 0x3f*/
5047                 Data32 = MP_ReadPciEConfigSpace(sc, 0x870c);
5048                 Data32 &=0xC0FFFFFF;
5049                 Data32 |= (0x3F << 24);
5050                 MP_WritePciEConfigSpace(sc, 0x870c, Data32);
5051
5052                 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0);
5053
5054                 CSR_WRITE_2 (sc, RE_CPlusCmd, 0x2060);
5055                 if (sc->re_type == MACFG_14) {
5056                         CSR_WRITE_1(sc,RE_CFG1, 0x0f);
5057
5058                         MP_WriteEPhyUshort(sc, 0x03, 0xC2F9);
5059                 } else if (sc->re_type == MACFG_15) {
5060                         CSR_WRITE_1(sc,RE_CFG1, 0x0f);
5061
5062                         MP_WriteEPhyUshort(sc, 0x01, 0x6FE5);
5063                         MP_WriteEPhyUshort(sc, 0x03, 0x07D9);
5064                 } else if (sc->re_type == MACFG_17) {
5065                         MP_WriteEPhyUshort(sc, 0x06, 0xAF35);
5066                 } else if (sc->re_type == MACFG_18) {
5067                         CSR_WRITE_1(sc, 0xF5, CSR_READ_1(sc, 0xF5)|0x04);
5068                         MP_WriteEPhyUshort(sc, 0x19, 0xEC90);
5069                         MP_WriteEPhyUshort(sc, 0x01, 0x6FE5);
5070                         MP_WriteEPhyUshort(sc, 0x03, 0x05D9);
5071                         MP_WriteEPhyUshort(sc, 0x06, 0xAF35);
5072                 } else if (sc->re_type == MACFG_19) {
5073                         if (pci_read_config(sc->dev, 0x80, 1)&3) {
5074                                 MP_WriteEPhyUshort(sc, 0x02, 0x011F);
5075                         }
5076                         CSR_WRITE_1(sc, 0xF4, CSR_READ_1(sc, 0xF4)|0x08);
5077                         CSR_WRITE_1(sc, 0xF5, CSR_READ_1(sc, 0xF5)|0x04);
5078                         MP_WriteEPhyUshort(sc, 0x19, 0xEC90);
5079                         MP_WriteEPhyUshort(sc, 0x01, 0x6FE5);
5080                         MP_WriteEPhyUshort(sc, 0x03, 0x05D9);
5081                         MP_WriteEPhyUshort(sc, 0x06, 0xAF35);
5082                 }
5083         } else if (macver == 0x3C000000) {
5084                 //disable clock request.
5085                 pci_write_config(sc->dev, 0x81, 0, 1);
5086
5087                 /*set configuration space offset 0x70f to 0x27*/
5088                 Data32 = MP_ReadPciEConfigSpace(sc, 0x870c);
5089                 Data32 &=0xC0FFFFFF;
5090                 Data32 |= (0x27 << 24);
5091                 MP_WritePciEConfigSpace(sc, 0x870c, Data32);
5092
5093                 CSR_WRITE_1(sc, RE_CFG1, CSR_READ_1(sc, RE_CFG1)|0x10);
5094                 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0);
5095
5096                 CSR_WRITE_2 (sc, RE_CPlusCmd, 0x2060);
5097                 if (sc->re_type == MACFG_24) {
5098                         /*set mac register offset 0xd1 to 0xf8*/
5099                         CSR_WRITE_1(sc, RE_DBG_reg, 0xF8);
5100
5101                         data16 = MP_ReadEPhyUshort(sc, 0x02) & ~0x1800;
5102                         data16 |= 0x1000;
5103                         MP_WriteEPhyUshort(sc, 0x02, data16);
5104
5105                         data16 = MP_ReadEPhyUshort(sc, 0x03) | 0x0002;
5106                         MP_WriteEPhyUshort(sc, 0x03, data16);
5107
5108                         data16 = MP_ReadEPhyUshort(sc, 0x06) & ~0x0080;
5109                         MP_WriteEPhyUshort(sc, 0x06, data16);
5110
5111                         if (ifp->if_mtu > ETHERMTU) {
5112                                 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) | BIT_2); //Jumbo_en0
5113                                 CSR_WRITE_1(sc, RE_CFG4, CSR_READ_1(sc, RE_CFG4) | (1 << 1)); //Jumbo_en1
5114
5115                                 data8 = pci_read_config(sc->dev, 0x79, 1);
5116                                 data8 &= ~0x70;
5117                                 data8 |= 0x20;
5118                                 pci_write_config(sc->dev, 0x79, data8, 1);
5119                                 ifp->if_capenable &= ~IFCAP_HWCSUM;
5120                                 CSR_WRITE_2 (sc, RE_CPlusCmd,CSR_READ_2(sc, RE_CPlusCmd) & ~RL_RxChkSum);
5121                                 ifp->if_hwassist &= ~RE_CSUM_FEATURES;
5122
5123                         } else {
5124                                 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_2); //Jumbo_en0
5125                                 CSR_WRITE_1(sc, RE_CFG4, CSR_READ_1(sc, RE_CFG4) & ~(1 << 1)); //Jumbo_en1
5126                                 data8 = pci_read_config(sc->dev, 0x79, 1);
5127                                 data8 &= ~0x70;
5128                                 data8 |= 0x50;
5129                                 pci_write_config(sc->dev, 0x79, data8, 1);
5130                                 if (sc->re_tx_cstag) {
5131                                         ifp->if_capenable |= IFCAP_TXCSUM;
5132                                         if ((sc->re_type == MACFG_24) || (sc->re_type == MACFG_25) || (sc->re_type == MACFG_26))
5133                                                 ifp->if_hwassist |= CSUM_TCP | CSUM_UDP;
5134                                         else
5135                                                 ifp->if_hwassist |= RE_CSUM_FEATURES;
5136                                 }
5137                                 if (sc->re_rx_cstag) {
5138                                         ifp->if_capenable |= IFCAP_RXCSUM;
5139                                         CSR_WRITE_2 (sc, RE_CPlusCmd,CSR_READ_2(sc, RE_CPlusCmd) |RL_RxChkSum);
5140                                 }
5141                         }
5142                 } else if (sc->re_type == MACFG_25) {
5143                         data16 = MP_ReadEPhyUshort(sc, 0x01) | 0x0001;
5144                         MP_WriteEPhyUshort(sc, 0x01, data16);
5145
5146                         data16 = MP_ReadEPhyUshort(sc, 0x03) & ~0x0620;
5147                         data16 |= 0x0220;
5148                         MP_WriteEPhyUshort(sc, 0x03, data16);
5149
5150                         if (ifp->if_mtu > ETHERMTU) {
5151                                 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) | BIT_2); //Jumbo_en0
5152                                 CSR_WRITE_1(sc, RE_CFG4, CSR_READ_1(sc, RE_CFG4) | (1<<1)); //Jumbo_en1
5153
5154                                 data8 = pci_read_config(sc->dev, 0x79, 1);
5155                                 data8 &= ~0x70;
5156                                 data8 |= 0x20;
5157                                 pci_write_config(sc->dev, 0x79, data8, 1);
5158                                 ifp->if_capenable &= ~IFCAP_HWCSUM;
5159                                 CSR_WRITE_2 (sc, RE_CPlusCmd,CSR_READ_2(sc, RE_CPlusCmd) & ~RL_RxChkSum);
5160                                 ifp->if_hwassist &= ~RE_CSUM_FEATURES;
5161
5162                         } else {
5163                                 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_2); //Jumbo_en0
5164                                 CSR_WRITE_1(sc, RE_CFG4, CSR_READ_1(sc, RE_CFG4) & ~(1<<1)); //Jumbo_en1
5165                                 data8 = pci_read_config(sc->dev, 0x79, 1);
5166                                 data8 &= ~0x70;
5167                                 data8 |= 0x50;
5168                                 pci_write_config(sc->dev, 0x79, data8, 1);
5169                                 if (sc->re_tx_cstag) {
5170                                         ifp->if_capenable |= IFCAP_TXCSUM;
5171                                         if ((sc->re_type == MACFG_24) || (sc->re_type == MACFG_25) || (sc->re_type == MACFG_26))
5172                                                 ifp->if_hwassist |= CSUM_TCP | CSUM_UDP;
5173                                         else
5174                                                 ifp->if_hwassist |= RE_CSUM_FEATURES;
5175                                 }
5176                                 if (sc->re_rx_cstag) {
5177                                         ifp->if_capenable |= IFCAP_RXCSUM;
5178                                         CSR_WRITE_2 (sc, RE_CPlusCmd,CSR_READ_2(sc, RE_CPlusCmd) |RL_RxChkSum);
5179                                 }
5180
5181
5182                         }
5183                 } else if (sc->re_type == MACFG_26) {
5184                         if (ifp->if_mtu > ETHERMTU) {
5185                                 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) | BIT_2); //Jumbo_en0
5186                                 CSR_WRITE_1(sc, RE_CFG4, CSR_READ_1(sc, RE_CFG4) | (1<<1)); //Jumbo_en1
5187
5188                                 data8 = pci_read_config(sc->dev, 0x79, 1);
5189                                 data8 &= ~0x70;
5190                                 data8 |= 0x20;
5191                                 pci_write_config(sc->dev, 0x79, data8, 1);
5192                                 ifp->if_capenable &= ~IFCAP_HWCSUM;
5193                                 CSR_WRITE_2 (sc, RE_CPlusCmd,CSR_READ_2(sc, RE_CPlusCmd) & ~RL_RxChkSum);
5194                                 ifp->if_hwassist &= ~RE_CSUM_FEATURES;
5195                         } else {
5196                                 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_2); //Jumbo_en0
5197                                 CSR_WRITE_1(sc, RE_CFG4, CSR_READ_1(sc, RE_CFG4) & ~(1<<1)); //Jumbo_en1
5198                                 data8 = pci_read_config(sc->dev, 0x79, 1);
5199                                 data8 &= ~0x70;
5200                                 data8 |= 0x50;
5201                                 pci_write_config(sc->dev, 0x79, data8, 1);
5202                                 if (sc->re_tx_cstag) {
5203                                         ifp->if_capenable |= IFCAP_TXCSUM;
5204                                         if ((sc->re_type == MACFG_24) || (sc->re_type == MACFG_25) || (sc->re_type == MACFG_26))
5205                                                 ifp->if_hwassist |= CSUM_TCP | CSUM_UDP;
5206                                         else
5207                                                 ifp->if_hwassist |= RE_CSUM_FEATURES;
5208                                 }
5209                                 if (sc->re_rx_cstag) {
5210                                         ifp->if_capenable |= IFCAP_RXCSUM;
5211                                         CSR_WRITE_2 (sc, RE_CPlusCmd,CSR_READ_2(sc, RE_CPlusCmd) |RL_RxChkSum);
5212                                 }
5213                         }
5214                 }
5215         } else if (macver == 0x3C800000) {
5216                 //disable clock request.
5217                 pci_write_config(sc->dev, 0x81, 0x00, 1);
5218
5219                 /*set configuration space offset 0x70f to 0x27*/
5220                 Data32 = MP_ReadPciEConfigSpace(sc, 0x870c);
5221                 Data32 &=0xC0FFFFFF;
5222                 Data32 |= (0x27 << 24);
5223                 MP_WritePciEConfigSpace(sc, 0x870c, Data32);
5224
5225                 re_eri_write(sc, 0x1EC, 1, 0x07, ERIAR_ASF);
5226
5227                 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0);
5228                 CSR_WRITE_2 (sc, RE_CPlusCmd, 0x2060);
5229                 if (sc->re_type == MACFG_28)
5230                         CSR_WRITE_1(sc, 0xD1, 0x20);
5231
5232                 if (ifp->if_mtu > ETHERMTU) {
5233                         CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) | BIT_2); //Jumbo_en0
5234                         CSR_WRITE_1(sc, RE_CFG4, CSR_READ_1(sc, RE_CFG4) | (1<<1)); //Jumbo_en1
5235
5236                         data8 = pci_read_config(sc->dev, 0x79, 1);
5237                         data8 &= ~0x70;
5238                         data8 |= 0x20;
5239                         pci_write_config(sc->dev, 0x79, data8, 1);
5240                         ifp->if_capenable &= ~IFCAP_HWCSUM;
5241                         CSR_WRITE_2 (sc, RE_CPlusCmd,CSR_READ_2(sc, RE_CPlusCmd) & ~RL_RxChkSum);
5242                         ifp->if_hwassist &= ~RE_CSUM_FEATURES;
5243                 } else {
5244                         CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_2); //Jumbo_en0
5245                         CSR_WRITE_1(sc, RE_CFG4, CSR_READ_1(sc, RE_CFG4) & ~(1<<1)); //Jumbo_en1
5246                         data8 = pci_read_config(sc->dev, 0x79, 1);
5247                         data8 &= ~0x70;
5248                         data8 |= 0x50;
5249                         pci_write_config(sc->dev, 0x79, data8, 1);
5250                         if (sc->re_tx_cstag) {
5251                                 ifp->if_capenable |= IFCAP_TXCSUM;
5252                                 ifp->if_hwassist |= RE_CSUM_FEATURES;
5253                         }
5254                         if (sc->re_rx_cstag) {
5255                                 ifp->if_capenable |= IFCAP_RXCSUM;
5256                                 CSR_WRITE_2 (sc, RE_CPlusCmd,CSR_READ_2(sc, RE_CPlusCmd) |RL_RxChkSum);
5257                         }
5258                 }
5259         } else if (macver == 0x28000000) {
5260                 //disable clock request.
5261                 pci_write_config(sc->dev, 0x81, 0x00, 1);
5262
5263                 /*set configuration space offset 0x70f to 0x13*/
5264                 Data32 = MP_ReadPciEConfigSpace(sc, 0x870c);
5265                 Data32 &=0xC0FFFFFF;
5266                 Data32 |= (0x27 << 24);
5267                 MP_WritePciEConfigSpace(sc, 0x870c, Data32);
5268
5269                 CSR_WRITE_1(sc, RE_TDFNR, 0x8);
5270
5271                 CSR_WRITE_1(sc, 0xD1, CSR_READ_1(sc, 0xD1) | 0x02);
5272
5273                 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0);
5274                 CSR_WRITE_1(sc, RE_DBG_reg, CSR_READ_1(sc, RE_DBG_reg)|0x82);
5275
5276                 CSR_WRITE_2 (sc, RE_CPlusCmd, 0x2060);
5277
5278                 if (ifp->if_mtu > ETHERMTU) {
5279                         CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) | BIT_2); //Jumbo_en0
5280                         CSR_WRITE_1(sc, RE_CFG4, CSR_READ_1(sc, RE_CFG4) | (1<<1)); //Jumbo_en1
5281
5282                         data8 = pci_read_config(sc->dev, 0x79, 1);
5283                         data8 &= ~0x70;
5284                         data8 |= 0x20;
5285                         pci_write_config(sc->dev, 0x79, data8, 1);
5286                         ifp->if_capenable &= ~IFCAP_HWCSUM;
5287                         CSR_WRITE_2 (sc, RE_CPlusCmd,CSR_READ_2(sc, RE_CPlusCmd) & ~RL_RxChkSum);
5288                         ifp->if_hwassist &= ~RE_CSUM_FEATURES;
5289
5290                 } else {
5291                         CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_2); //Jumbo_en0
5292                         CSR_WRITE_1(sc, RE_CFG4, CSR_READ_1(sc, RE_CFG4) & ~(1<<1)); //Jumbo_en1
5293                         data8 = pci_read_config(sc->dev, 0x79, 1);
5294                         data8 &= ~0x70;
5295                         data8 |= 0x50;
5296                         pci_write_config(sc->dev, 0x79, data8, 1);
5297                         if (sc->re_tx_cstag) {
5298                                 ifp->if_capenable |= IFCAP_TXCSUM;
5299                                 ifp->if_hwassist |= RE_CSUM_FEATURES;
5300                         }
5301                         if (sc->re_rx_cstag) {
5302                                 ifp->if_capenable |= IFCAP_RXCSUM;
5303                                 CSR_WRITE_2 (sc, RE_CPlusCmd,CSR_READ_2(sc, RE_CPlusCmd) |RL_RxChkSum);
5304                         }
5305                 }
5306
5307                 if (sc->re_type == MACFG_31) {
5308                         CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~(1<<4));
5309
5310                         MP_WriteEPhyUshort(sc, 0x01, 0x7C7F);
5311                         MP_WriteEPhyUshort(sc, 0x02, 0x011F);
5312                         MP_WriteEPhyUshort(sc, 0x06, 0xB271);
5313                         MP_WriteEPhyUshort(sc, 0x07, 0xCE00);
5314                 } else if (sc->re_type == MACFG_32) {
5315                         MP_WriteEPhyUshort(sc, 0x01, 0x7C7D);
5316                         MP_WriteEPhyUshort(sc, 0x02, 0x091F);
5317                         MP_WriteEPhyUshort(sc, 0x03, 0xC5BA);
5318                         MP_WriteEPhyUshort(sc, 0x06, 0xB279);
5319                         MP_WriteEPhyUshort(sc, 0x07, 0xAF00);
5320                         MP_WriteEPhyUshort(sc, 0x1E, 0xB8EB);
5321                 } else if (sc->re_type == MACFG_33) {
5322                         CSR_WRITE_1(sc, RE_CFG1, CSR_READ_1(sc, RE_CFG1)|0x10);
5323
5324                         MP_WriteEPhyUshort(sc, 0x01, 0x6C7F);
5325                         MP_WriteEPhyUshort(sc, 0x02, 0x011F);
5326                         ClearAndSetPCIePhyBit(sc,
5327                                               0x03,
5328                                               0xFFF0,
5329                                               0x01B0
5330                                              );
5331                         MP_WriteEPhyUshort(sc, 0x1A, 0x0546);
5332                         MP_WriteEPhyUshort(sc, 0x1C, 0x80C4);
5333                         MP_WriteEPhyUshort(sc, 0x1D, 0x78E5);
5334                         MP_WriteEPhyUshort(sc, 0x0A, 0x8100);
5335                 }
5336         } else if (macver == 0x28800000) {
5337                 /* disable clock request. */
5338                 pci_write_config(sc->dev, 0x81, 0x00, 1);
5339
5340                 /*set configuration space offset 0x70f to 0x17*/
5341                 Data32 = MP_ReadPciEConfigSpace(sc, 0x870c);
5342                 Data32 &=0xC0FFFFFF;
5343                 Data32 |= (0x27 << 24);
5344                 MP_WritePciEConfigSpace(sc, 0x870c, Data32);
5345
5346                 CSR_WRITE_1(sc, RE_TDFNR, 0x8);
5347                 if (sc->re_dash &&
5348                     (sc->re_type == MACFG_63 || sc->re_type == MACFG_64))
5349                         CSR_WRITE_1(sc, RE_TDFNR, 0x1);
5350
5351                 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0);
5352                 CSR_WRITE_1(sc, RE_DBG_reg, CSR_READ_1(sc, RE_DBG_reg)|0x82);
5353
5354                 CSR_WRITE_2 (sc, RE_CPlusCmd, 0x2060);
5355
5356                 if (ifp->if_mtu > ETHERMTU) {
5357                         CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) | BIT_2); //Jumbo_en0
5358                         CSR_WRITE_1(sc, RE_CFG4, CSR_READ_1(sc, RE_CFG4) | (1<<1)); //Jumbo_en1
5359
5360                         data8 = pci_read_config(sc->dev, 0x79, 1);
5361                         data8 &= ~0x70;
5362                         data8 |= 0x20;
5363                         pci_write_config(sc->dev, 0x79, data8, 1);
5364                         ifp->if_capenable &= ~IFCAP_HWCSUM;
5365                         CSR_WRITE_2 (sc, RE_CPlusCmd,CSR_READ_2(sc, RE_CPlusCmd) & ~RL_RxChkSum);
5366                         ifp->if_hwassist &= ~RE_CSUM_FEATURES;
5367
5368                 } else {
5369                         CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_2); //Jumbo_en0
5370                         CSR_WRITE_1(sc, RE_CFG4, CSR_READ_1(sc, RE_CFG4) & ~(1<<1)); //Jumbo_en1
5371                         data8 = pci_read_config(sc->dev, 0x79, 1);
5372                         data8 &= ~0x70;
5373                         data8 |= 0x50;
5374                         pci_write_config(sc->dev, 0x79, data8, 1);
5375                         if (sc->re_tx_cstag) {
5376                                 ifp->if_capenable |= IFCAP_TXCSUM;
5377                                 ifp->if_hwassist |= RE_CSUM_FEATURES;
5378                         }
5379                         if (sc->re_rx_cstag) {
5380                                 ifp->if_capenable |= IFCAP_RXCSUM;
5381                                 CSR_WRITE_2 (sc, RE_CPlusCmd,CSR_READ_2(sc, RE_CPlusCmd) |RL_RxChkSum);
5382                         }
5383                 }
5384
5385                 if (sc->re_type == MACFG_65 || sc->re_type == MACFG_66) {
5386                         SetPCIePhyBit(sc, 0x0B, (BIT_3 | BIT_6));
5387
5388                         ClearAndSetPCIePhyBit(sc,
5389                                               0x19,
5390                                               BIT_5,
5391                                               (BIT_4 | BIT_6)
5392                                              );
5393
5394                         ClearAndSetPCIePhyBit(sc,
5395                                               0x0C,
5396                                               BIT_8,
5397                                               BIT_5
5398                                              );
5399
5400                         ClearPCIePhyBit(sc, 0x10, (BIT_2));
5401                 }
5402         } else if (macver == 0x2C000000) {
5403                 /* disable clock request. */
5404                 pci_write_config(sc->dev, 0x81, 0x00, 1);
5405
5406                 /*set configuration space offset 0x70f to 0x20*/
5407                 Data32 = MP_ReadPciEConfigSpace(sc, 0x870c);
5408                 Data32 &=0xC0FFFFFF;
5409                 Data32 |= (0x27 << 24);
5410                 MP_WritePciEConfigSpace(sc, 0x870c, Data32);
5411
5412                 CSR_WRITE_1(sc, 0xF3, CSR_READ_1(sc, 0xF3)|0x20);
5413                 CSR_WRITE_1(sc, 0xF3, CSR_READ_1(sc, 0xF3)& ~0x20);
5414
5415                 CSR_WRITE_1(sc, 0xD0, CSR_READ_1(sc, 0xD0)|0xC0);
5416                 CSR_WRITE_1(sc, 0xF1, CSR_READ_1(sc, 0xF1)|0x73);
5417                 CSR_WRITE_1(sc, RE_CFG5, (CSR_READ_1(sc, RE_CFG5)& ~0x08));
5418                 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0);
5419
5420                 CSR_WRITE_1(sc, RE_TDFNR, 0x8);
5421
5422                 if (sc->re_type == MACFG_36 || sc->re_type == MACFG_37) {
5423                         /* set EPHY registers */
5424                         data16 = MP_ReadEPhyUshort(sc, 0x00) & ~0x0200;
5425                         data16 |= 0x0100;
5426                         MP_WriteEPhyUshort(sc, 0x00, data16);
5427
5428                         data16 = MP_ReadEPhyUshort(sc, 0x00);
5429                         data16 |= 0x0004;
5430                         MP_WriteEPhyUshort(sc, 0x00, data16);
5431
5432                         data16 = MP_ReadEPhyUshort(sc, 0x06) & ~0x0002;
5433                         data16 |= 0x0001;
5434                         MP_WriteEPhyUshort(sc, 0x06, data16);
5435
5436                         data16 = MP_ReadEPhyUshort(sc, 0x06);
5437                         data16 |= 0x0030;
5438                         MP_WriteEPhyUshort(sc, 0x06, data16);
5439
5440                         data16 = MP_ReadEPhyUshort(sc, 0x07);
5441                         data16 |= 0x2000;
5442                         MP_WriteEPhyUshort(sc, 0x07, data16);
5443
5444                         data16 = MP_ReadEPhyUshort(sc, 0x00);
5445                         data16 |= 0x0020;
5446                         MP_WriteEPhyUshort(sc, 0x00, data16);
5447
5448                         data16 = MP_ReadEPhyUshort(sc, 0x03) & ~0x5800;
5449                         data16 |= 0x2000;
5450                         MP_WriteEPhyUshort(sc, 0x03, data16);
5451
5452                         data16 = MP_ReadEPhyUshort(sc, 0x03);
5453                         data16 |= 0x0001;
5454                         MP_WriteEPhyUshort(sc, 0x03, data16);
5455
5456                         data16 = MP_ReadEPhyUshort(sc, 0x01) & ~0x0800;
5457                         data16 |= 0x1000;
5458                         MP_WriteEPhyUshort(sc, 0x01, data16);
5459
5460                         data16 = MP_ReadEPhyUshort(sc, 0x07);
5461                         data16 |= 0x4000;
5462                         MP_WriteEPhyUshort(sc, 0x07, data16);
5463
5464                         data16 = MP_ReadEPhyUshort(sc, 0x1E);
5465                         data16 |= 0x2000;
5466                         MP_WriteEPhyUshort(sc, 0x1E, data16);
5467
5468                         MP_WriteEPhyUshort(sc, 0x19, 0xFE6C);
5469
5470                         data16 = MP_ReadEPhyUshort(sc, 0x0A);
5471                         data16 |= 0x0040;
5472                         MP_WriteEPhyUshort(sc, 0x0A, data16);
5473
5474                         if (ifp->if_mtu > ETHERMTU) {
5475                                 CSR_WRITE_1 (sc, RE_MTPS, 0x24);
5476                                 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) | BIT_2);
5477                                 CSR_WRITE_1(sc, RE_CFG4, CSR_READ_1(sc, RE_CFG4) |0x01);
5478                                 data8 = pci_read_config(sc->dev, 0x79, 1);
5479                                 data8 &= ~0x70;
5480                                 data8 |= 0x20;
5481                                 pci_write_config(sc->dev, 0x79, data8, 1);
5482                                 ifp->if_capenable &= ~IFCAP_HWCSUM;
5483                                 CSR_WRITE_2 (sc, RE_CPlusCmd,CSR_READ_2(sc, RE_CPlusCmd) & ~RL_RxChkSum);
5484                                 ifp->if_hwassist &= ~RE_CSUM_FEATURES;
5485                         } else {
5486                                 CSR_WRITE_1 (sc, RE_MTPS, 0x0c);
5487                                 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_2);
5488                                 CSR_WRITE_1(sc, RE_CFG4, CSR_READ_1(sc, RE_CFG4) & ~0x01);
5489                                 data8 = pci_read_config(sc->dev, 0x79, 1);
5490                                 data8 &= ~0x70;
5491                                 data8 |= 0x50;
5492                                 pci_write_config(sc->dev, 0x79, data8, 1);
5493
5494                                 if (sc->re_tx_cstag) {
5495                                         ifp->if_capenable |= IFCAP_TXCSUM;
5496                                         ifp->if_hwassist |= RE_CSUM_FEATURES;
5497                                 }
5498                                 if (sc->re_rx_cstag) {
5499                                         ifp->if_capenable |= IFCAP_RXCSUM;
5500                                         CSR_WRITE_2 (sc, RE_CPlusCmd,CSR_READ_2(sc, RE_CPlusCmd) |RL_RxChkSum);
5501                                 }
5502                         }
5503                 }
5504         } else if (macver == 0x2C800000) {
5505                 /* disable clock request. */
5506                 pci_write_config(sc->dev, 0x81, 0x00, 1);
5507
5508                 /*set configuration space offset 0x70f to 0x27*/
5509                 Data32 = MP_ReadPciEConfigSpace(sc, 0x870c);
5510                 Data32 &=0xC0FFFFFF;
5511                 Data32 |= (0x27 << 24);
5512                 MP_WritePciEConfigSpace(sc, 0x870c, Data32);
5513
5514                 data8 = pci_read_config(sc->dev, 0x79, 1);
5515                 data8 &= ~0x70;
5516                 data8 |= 0x50;
5517                 pci_write_config(sc->dev, 0x79, data8, 1);
5518
5519                 CSR_WRITE_1(sc, RE_TDFNR, 0x8);
5520
5521                 re_eri_write(sc, 0xC0, 2, 0x0000, ERIAR_ExGMAC);
5522                 re_eri_write(sc, 0xB8, 4, 0x00000000, ERIAR_ExGMAC);
5523                 re_eri_write(sc, 0xC8, 4, 0x00100002, ERIAR_ExGMAC);
5524                 re_eri_write(sc, 0xE8, 4, 0x00100006, ERIAR_ExGMAC);
5525                 Data32 = re_eri_read(sc, 0xdc, 4, ERIAR_ExGMAC);
5526                 Data32 &= ~BIT_0;
5527                 re_eri_write(sc, 0xdc, 1, Data32, ERIAR_ExGMAC);
5528                 Data32 |= BIT_0;
5529                 re_eri_write(sc, 0xdc, 1, Data32, ERIAR_ExGMAC);
5530
5531                 Data32 = re_eri_read(sc, 0xD4, 4, ERIAR_ExGMAC);
5532                 Data32 |= (BIT_8 | BIT_9 | BIT_10 | BIT_11 | BIT_12);
5533                 re_eri_write(sc, 0xD4, 4, Data32, ERIAR_ExGMAC);
5534                 if (sc ->re_type == MACFG_39) {
5535                         Data32 = re_eri_read(sc, 0x1B0, 4, ERIAR_ExGMAC);
5536                         Data32 |= BIT_4;
5537                         re_eri_write(sc, 0x1B0, 4, Data32, ERIAR_ExGMAC);
5538                         re_eri_write(sc, 0xCC, 4, 0x00000050, ERIAR_ExGMAC);
5539                         re_eri_write(sc, 0xD0, 4, 0x07ff0060, ERIAR_ExGMAC);
5540                 }
5541
5542                 CSR_WRITE_4(sc, RE_TXCFG, CSR_READ_4(sc, RE_TXCFG) |BIT_7);
5543                 CSR_WRITE_1(sc, 0xD3, CSR_READ_1(sc, 0xD3) & ~BIT_7);
5544                 CSR_WRITE_1(sc, 0x1B, CSR_READ_1(sc, 0x1B) & ~0x07);
5545
5546                 CSR_WRITE_2 (sc, RE_CPlusCmd, 0x2060);
5547
5548                 if (sc ->re_type == MACFG_38) {
5549                         CSR_WRITE_4(sc, 0xB0, 0xEE480010);
5550                         CSR_WRITE_1(sc, 0x1A, CSR_READ_1(sc, 0x1A) & ~(BIT_2 |BIT_3));
5551                         re_eri_write(sc, 0x1DC, 1, 0x64, ERIAR_ExGMAC);
5552
5553                         MP_WriteEPhyUshort(sc, 0x06, 0xF020);
5554                         MP_WriteEPhyUshort(sc, 0x07, 0x01FF);
5555                         MP_WriteEPhyUshort(sc, 0x00, 0x5027);
5556                         MP_WriteEPhyUshort(sc, 0x01, 0x0003);
5557                         MP_WriteEPhyUshort(sc, 0x02, 0x2D16);
5558                         MP_WriteEPhyUshort(sc, 0x03, 0x6D49);
5559                         MP_WriteEPhyUshort(sc, 0x08, 0x0006);
5560                         MP_WriteEPhyUshort(sc, 0x0A, 0x00C8);
5561                 }
5562
5563                 data16 = MP_ReadEPhyUshort(sc, 0x09);
5564                 data16 |= BIT_7;
5565                 MP_WriteEPhyUshort(sc, 0x09, data16);
5566
5567                 data16 = MP_ReadEPhyUshort(sc, 0x19);
5568                 data16 |= (BIT_2 | BIT_5 | BIT_9);
5569                 MP_WriteEPhyUshort(sc, 0x19, data16);
5570
5571                 SetPCIePhyBit(sc, 0x00, BIT_3);
5572                 ClearAndSetPCIePhyBit(sc,
5573                                       0x0C,
5574                                       (BIT_13|BIT_12|BIT_11|BIT_10|BIT_8|BIT_7|BIT_6|BIT_5|BIT_4),
5575                                       BIT_9
5576                                      );
5577
5578                 CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2) | BIT_5);
5579                 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0);
5580
5581                 CSR_WRITE_1(sc, 0xD0, CSR_READ_1(sc, 0xD0) | BIT_6);
5582                 CSR_WRITE_1(sc, 0xF2, CSR_READ_1(sc, 0xF2) | BIT_6);
5583
5584                 CSR_WRITE_1 (sc, RE_MTPS, 0x27);
5585                 ifp->if_capenable &= ~IFCAP_HWCSUM;
5586                 ifp->if_hwassist &= ~RE_CSUM_FEATURES;
5587         } else if (macver == 0x24000000) {
5588                 if (pci_read_config(sc->dev, 0x81, 1)==1) {
5589                         CSR_WRITE_1(sc, RE_DBG_reg, 0x98);
5590                         CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2) | 0x80);
5591                         CSR_WRITE_1(sc, RE_CFG4, CSR_READ_1(sc, RE_CFG4) | 0x04);
5592                         pci_write_config(sc->dev, 0x81, 1, 1);
5593                 }
5594                 data8 = pci_read_config(sc->dev, 0x79, 1);
5595                 data8 &= ~0x70;
5596                 data8 |= 0x50;
5597                 pci_write_config(sc->dev, 0x79, data8, 1);
5598
5599                 /*set configuration space offset 0x70f to 0x3F*/
5600                 Data32 = MP_ReadPciEConfigSpace(sc, 0x870c);
5601                 Data32 &=0xC0FFFFFF;
5602                 Data32 |= (0x3F << 24);
5603                 MP_WritePciEConfigSpace(sc, 0x870c, Data32);
5604
5605                 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0);
5606
5607                 CSR_WRITE_2 (sc, RE_CPlusCmd, 0x2060);
5608
5609                 MP_WriteEPhyUshort(sc, 0x06, 0xAF25);
5610                 MP_WriteEPhyUshort(sc, 0x07, 0x8E68);
5611         } else if (macver == 0x40800000) {
5612                 CSR_WRITE_1(sc, 0xF2, CSR_READ_1(sc, 0xF2) | 0x80);
5613                 CSR_WRITE_1(sc, 0xF1, CSR_READ_1(sc, 0xF1) | 0x28);
5614                 CSR_WRITE_1(sc, 0xD3, CSR_READ_1(sc, 0xD3) | 0x0C);
5615                 CSR_WRITE_1(sc, 0xD3, CSR_READ_1(sc, 0xD3) & ~BIT_7);
5616                 CSR_WRITE_1(sc, 0xD0, CSR_READ_1(sc, 0xD0) | 0x40);
5617                 CSR_WRITE_2(sc, 0xE0, CSR_READ_2(sc, 0xE0) & ~0xDF9C);
5618                 CSR_WRITE_1(sc, 0xD1, CSR_READ_1(sc, 0xD1) | 0x02);
5619
5620                 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0);
5621
5622                 if (sc->re_type == MACFG_42) {
5623                         /* set EPHY registers */
5624                         SetPCIePhyBit(sc, 0x07, BIT_14);
5625                         SetPCIePhyBit(sc, 0x19, BIT_9);
5626                         SetPCIePhyBit(sc, 0x19, BIT_5);
5627                         SetPCIePhyBit(sc, 0x1E, BIT_13);
5628                         SetPCIePhyBit(sc, 0x03, BIT_0);
5629                         SetPCIePhyBit(sc, 0x19, BIT_8);
5630                         SetPCIePhyBit(sc, 0x19, BIT_2);
5631                         SetPCIePhyBit(sc, 0x0A, BIT_5);
5632                         SetPCIePhyBit(sc, 0x05, BIT_13);
5633                 }
5634                 if (sc->re_type == MACFG_43) {
5635                         SetPCIePhyBit(sc, 0x07, BIT_14);
5636                         SetPCIePhyBit(sc, 0x19, BIT_9);
5637                         SetPCIePhyBit(sc, 0x19, BIT_5);
5638                         SetPCIePhyBit(sc, 0x1E, BIT_13);
5639                         SetPCIePhyBit(sc, 0x03, BIT_0);
5640                         SetPCIePhyBit(sc, 0x19, BIT_8);
5641                         SetPCIePhyBit(sc, 0x19, BIT_2);
5642                         SetPCIePhyBit(sc, 0x0A, BIT_5);
5643                         SetPCIePhyBit(sc, 0x1E, BIT_15);
5644                         SetPCIePhyBit(sc, 0x05, BIT_13);
5645                 }
5646         } else if (macver == 0x44000000) {
5647
5648                 CSR_WRITE_2(sc, 0xE0, CSR_READ_2(sc, 0xE0) & ~0xDF9C);
5649
5650                 re_eri_write(sc, 0xC8, 4, 0x00000002, ERIAR_ExGMAC);
5651                 re_eri_write(sc, 0xE8, 4, 0x00000006, ERIAR_ExGMAC);
5652
5653                 Data32 = re_eri_read(sc, 0xD4, 4, ERIAR_ExGMAC);
5654                 Data32 |= BIT_11 | BIT_10;
5655                 re_eri_write(sc, 0xD4, 4, Data32, ERIAR_ExGMAC);
5656
5657                 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0);
5658
5659                 /* set EPHY registers */
5660                 MP_WriteEPhyUshort(sc, 0x19, 0xFF64);
5661
5662                 CSR_WRITE_1 (sc, RE_MTPS, 0x27);
5663         } else if (macver == 0x48000000) {
5664                 /*set configuration space offset 0x70f to 0x27*/
5665                 Data32 = MP_ReadPciEConfigSpace(sc, 0x870c);
5666                 Data32 &=0xC0FFFFFF;
5667                 Data32 |= (0x27 << 24);
5668                 MP_WritePciEConfigSpace(sc, 0x870c, Data32);
5669
5670                 data8 = pci_read_config(sc->dev, 0x79, 1);
5671                 data8 &= ~0x70;
5672                 data8 |= 0x50;
5673                 pci_write_config(sc->dev, 0x79, data8, 1);
5674
5675                 CSR_WRITE_1(sc, RE_TDFNR, 0x8);
5676
5677                 Data32 = re_eri_read(sc, 0xD4, 4, ERIAR_ExGMAC);
5678                 Data32 |= (BIT_8 | BIT_9 | BIT_10 | BIT_11 | BIT_12);
5679                 re_eri_write(sc, 0xD4, 4, Data32, ERIAR_ExGMAC);
5680                 re_eri_write(sc, 0xC0, 2, 0x0000, ERIAR_ExGMAC);
5681                 re_eri_write(sc, 0xB8, 4, 0x00000000, ERIAR_ExGMAC);
5682                 re_eri_write(sc, 0xC8, 4, 0x00100002, ERIAR_ExGMAC);
5683                 re_eri_write(sc, 0xE8, 4, 0x00100006, ERIAR_ExGMAC);
5684                 Data32 = re_eri_read(sc, 0xdc, 4, ERIAR_ExGMAC);
5685                 Data32 &= ~BIT_0;
5686                 re_eri_write(sc, 0xdc, 1, Data32, ERIAR_ExGMAC);
5687                 Data32 |= BIT_0;
5688                 re_eri_write(sc, 0xdc, 1, Data32, ERIAR_ExGMAC);
5689                 Data32 = re_eri_read(sc, 0x1B0, 4, ERIAR_ExGMAC);
5690                 Data32 |= BIT_4;
5691                 re_eri_write(sc, 0x1B0, 4, Data32, ERIAR_ExGMAC);
5692                 re_eri_write(sc, 0xCC, 4, 0x00000050, ERIAR_ExGMAC);
5693                 re_eri_write(sc, 0xD0, 4, 0x00000060, ERIAR_ExGMAC);
5694                 Data32 = re_eri_read(sc, 0x1D0, 4, ERIAR_ExGMAC);
5695                 Data32 |= BIT_4;
5696                 re_eri_write(sc, 0x1D0, 4, Data32, ERIAR_ExGMAC);
5697
5698                 CSR_WRITE_4(sc, RE_TXCFG, CSR_READ_4(sc, RE_TXCFG) | BIT_7);
5699                 CSR_WRITE_1(sc, 0xD3, CSR_READ_1(sc, 0xD3) & ~BIT_7);
5700                 CSR_WRITE_1(sc, 0x1B, CSR_READ_1(sc, 0x1B) & ~0x07);
5701
5702                 CSR_WRITE_2 (sc, RE_CPlusCmd, 0x2060);
5703
5704                 if (sc->re_type == MACFG_50) {
5705                         data16 = MP_ReadEPhyUshort(sc, 0x06);
5706                         data16 &= ~(BIT_7 | BIT_6);
5707                         data16 |= BIT_5;
5708                         MP_WriteEPhyUshort(sc, 0x06, data16);
5709
5710                         data16 = MP_ReadEPhyUshort(sc, 0x08);
5711                         data16 &= ~BIT_0;
5712                         data16 |= BIT_1;
5713                         MP_WriteEPhyUshort(sc, 0x08, data16);
5714                 }
5715
5716                 data16 = MP_ReadEPhyUshort(sc, 0x09);
5717                 data16 |= BIT_7;
5718                 MP_WriteEPhyUshort(sc, 0x09, data16);
5719
5720                 data16 = MP_ReadEPhyUshort(sc, 0x19);
5721                 data16 |= (BIT_2 | BIT_5 | BIT_9);
5722                 MP_WriteEPhyUshort(sc, 0x19, data16);
5723
5724                 SetPCIePhyBit(sc, 0x00, BIT_3);
5725                 ClearAndSetPCIePhyBit(sc,
5726                                       0x0C,
5727                                       (BIT_13|BIT_12|BIT_11|BIT_10|BIT_8|BIT_7|BIT_6|BIT_5|BIT_4),
5728                                       BIT_9
5729                                      );
5730
5731                 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0);
5732
5733                 CSR_WRITE_1(sc, 0xD0, CSR_READ_1(sc, 0xD0) | BIT_6);
5734                 CSR_WRITE_1(sc, 0xF2, CSR_READ_1(sc, 0xF2) | BIT_6);
5735
5736                 CSR_WRITE_1 (sc, RE_MTPS, 0x27);
5737
5738                 if (ifp->if_mtu > ETHERMTU) {
5739                         ifp->if_capenable &= ~IFCAP_HWCSUM;
5740                         ifp->if_hwassist &= ~RE_CSUM_FEATURES;
5741                 } else {
5742                         if (sc->re_tx_cstag) {
5743                                 ifp->if_capenable |= IFCAP_TXCSUM;
5744                                 ifp->if_hwassist |= RE_CSUM_FEATURES;
5745                         }
5746                         if (sc->re_rx_cstag) {
5747                                 ifp->if_capenable |= IFCAP_RXCSUM;
5748                         }
5749                 }
5750         } else if (macver == 0x48800000) {
5751                 /*set configuration space offset 0x70f to 0x27*/
5752                 Data32 = MP_ReadPciEConfigSpace(sc, 0x870c);
5753                 Data32 &=0xC0FFFFFF;
5754                 Data32 |= (0x27 << 24);
5755                 MP_WritePciEConfigSpace(sc, 0x870c, Data32);
5756
5757                 data8 = pci_read_config(sc->dev, 0x79, 1);
5758                 data8 &= ~0x70;
5759                 data8 |= 0x50;
5760                 pci_write_config(sc->dev, 0x79, data8, 1);
5761
5762                 CSR_WRITE_1(sc, RE_TDFNR, 0x8);
5763
5764                 Data32 = re_eri_read(sc, 0xD4, 4, ERIAR_ExGMAC);
5765                 Data32 |= BIT_11 | BIT_10;
5766                 re_eri_write(sc, 0xD4, 4, Data32, ERIAR_ExGMAC);
5767                 re_eri_write(sc, 0xC0, 2, 0x0000, ERIAR_ExGMAC);
5768                 re_eri_write(sc, 0xB8, 4, 0x00000000, ERIAR_ExGMAC);
5769                 re_eri_write(sc, 0xC8, 4, 0x00100002, ERIAR_ExGMAC);
5770                 re_eri_write(sc, 0xE8, 4, 0x00100006, ERIAR_ExGMAC);
5771                 Data32 = re_eri_read(sc, 0xdc, 4, ERIAR_ExGMAC);
5772                 Data32 &= ~BIT_0;
5773                 re_eri_write(sc, 0xdc, 1, Data32, ERIAR_ExGMAC);
5774                 Data32 |= BIT_0;
5775                 re_eri_write(sc, 0xdc, 1, Data32, ERIAR_ExGMAC);
5776                 Data32 = re_eri_read(sc, 0x1B0, 4, ERIAR_ExGMAC);
5777                 Data32 |= BIT_4;
5778                 re_eri_write(sc, 0x1B0, 4, Data32, ERIAR_ExGMAC);
5779                 re_eri_write(sc, 0xCC, 4, 0x00000050, ERIAR_ExGMAC);
5780                 re_eri_write(sc, 0xD0, 4, 0x00000060, ERIAR_ExGMAC);
5781                 Data32 = re_eri_read(sc, 0x1D0, 4, ERIAR_ExGMAC);
5782                 Data32 |= BIT_4;
5783                 re_eri_write(sc, 0x1D0, 4, Data32, ERIAR_ExGMAC);
5784
5785                 CSR_WRITE_4(sc, RE_TXCFG, CSR_READ_4(sc, RE_TXCFG) | BIT_7);
5786                 CSR_WRITE_1(sc, 0xD3, CSR_READ_1(sc, 0xD3) & ~BIT_7);
5787 //              CSR_WRITE_1(sc, 0x1B, CSR_READ_1(sc, 0x1B) & ~0x07);
5788
5789                 CSR_WRITE_2 (sc, RE_CPlusCmd, 0x2060);
5790
5791                 data16 = MP_ReadEPhyUshort(sc, 0x06);
5792                 data16 &= ~(BIT_7 | BIT_6);
5793                 data16 |= BIT_5;
5794                 MP_WriteEPhyUshort(sc, 0x06, data16);
5795
5796                 MP_WriteEPhyUshort(sc, 0x0f, 0x5200);
5797
5798                 data16 = MP_ReadEPhyUshort(sc, 0x1e);
5799                 data16 |= BIT_14;
5800                 MP_WriteEPhyUshort(sc, 0x1e, data16);
5801
5802                 data16 = MP_ReadEPhyUshort(sc, 0x19);
5803                 data16 |= (BIT_2 | BIT_5 | BIT_9);
5804                 MP_WriteEPhyUshort(sc, 0x19, data16);
5805
5806                 SetPCIePhyBit(sc, 0x00, BIT_3);
5807                 ClearAndSetPCIePhyBit(sc,
5808                                       0x0C,
5809                                       (BIT_13|BIT_12|BIT_11|BIT_10|BIT_8|BIT_7|BIT_6|BIT_5|BIT_4),
5810                                       BIT_9
5811                                      );
5812
5813                 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0);
5814
5815                 CSR_WRITE_1(sc, 0xD0, CSR_READ_1(sc, 0xD0) | BIT_6);
5816                 CSR_WRITE_1(sc, 0xF2, CSR_READ_1(sc, 0xF2) | BIT_6);
5817
5818                 CSR_WRITE_1 (sc, RE_MTPS, 0x27);
5819
5820                 if (ifp->if_mtu > ETHERMTU) {
5821                         ifp->if_capenable &= ~IFCAP_HWCSUM;
5822                         ifp->if_hwassist &= ~RE_CSUM_FEATURES;
5823                 } else {
5824                         if (sc->re_tx_cstag) {
5825                                 ifp->if_capenable |= IFCAP_TXCSUM;
5826                                 ifp->if_hwassist |= RE_CSUM_FEATURES;
5827                         }
5828                         if (sc->re_rx_cstag) {
5829                                 ifp->if_capenable |= IFCAP_RXCSUM;
5830                         }
5831                 }
5832         } else if (macver == 0x44800000) {
5833                 CSR_WRITE_1(sc, 0xF2, CSR_READ_1(sc, 0xF2) | 0x80);
5834                 CSR_WRITE_1(sc, 0xF1, CSR_READ_1(sc, 0xF1) | 0x28);
5835                 CSR_WRITE_1(sc, 0xD3, CSR_READ_1(sc, 0xD3) | 0x0C);
5836                 CSR_WRITE_1(sc, 0xD3, CSR_READ_1(sc, 0xD3) & ~BIT_7);
5837                 CSR_WRITE_1(sc, 0xD0, CSR_READ_1(sc, 0xD0) | 0x40);
5838                 CSR_WRITE_2(sc, 0xE0, CSR_READ_2(sc, 0xE0) & ~0xDF9C);
5839
5840                 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0);
5841         } else if (macver == 0x4C000000 || macver == 0x50800000 ||
5842                    macver == 0x5C800000 || macver == 0x54000000) {
5843                 CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2) | BIT_5);
5844
5845                 if (sc->re_type == MACFG_59) {
5846                         MP_WriteMcuAccessRegWord(sc, 0xD3C0, 0x0B00);
5847                         MP_WriteMcuAccessRegWord(sc, 0xD3C2, 0x0000);
5848                 }
5849
5850                 if (sc->re_type == MACFG_68 || sc->re_type == MACFG_69) {
5851                         MP_WriteMcuAccessRegWord(sc, 0xD400, MP_ReadMcuAccessRegWord(sc, 0xD400) & ~(BIT_0));
5852
5853                         data16 = MP_ReadMcuAccessRegWord(sc, 0xE63E);
5854                         data16 &= ~(BIT_3 | BIT_2 | BIT_1);
5855                         MP_WriteMcuAccessRegWord(sc, 0xE63E, data16);
5856                         data16 |= (BIT_0);
5857                         MP_WriteMcuAccessRegWord(sc, 0xE63E, data16);
5858                         data16 &= ~(BIT_0);
5859                         MP_WriteMcuAccessRegWord(sc, 0xE63E, data16);
5860                         MP_WriteMcuAccessRegWord(sc, 0xC094, 0x0);
5861                         MP_WriteMcuAccessRegWord(sc, 0xC09E, 0x0);
5862
5863                         MP_WriteMcuAccessRegWord(sc, 0xE098, 0x0AA2);
5864                 }
5865
5866                 /*set configuration space offset 0x70f to 0x17*/
5867                 Data32 = MP_ReadPciEConfigSpace(sc, 0x870c);
5868                 Data32 &=0xC0FFFFFF;
5869                 Data32 |= (0x27 << 24);
5870                 MP_WritePciEConfigSpace(sc, 0x870c, Data32);
5871
5872                 data8 = pci_read_config(sc->dev, 0x79, 1);
5873                 data8 &= ~0x70;
5874                 data8 |= 0x50;
5875                 pci_write_config(sc->dev, 0x79, data8, 1);
5876
5877                 CSR_WRITE_1(sc, RE_TDFNR, 0x4);
5878
5879                 if (sc->re_type == MACFG_56 || sc->re_type == MACFG_57) {
5880                         Data32 = MP_ReadPciEConfigSpace(sc, 0x2710);
5881                         Data32 &=0xFFFF0FFF;
5882                         Data32 |= (0x04 << 12);
5883                         MP_WritePciEConfigSpace(sc, 0x2710, Data32);
5884                 }
5885
5886                 if (sc->re_type == MACFG_68 || sc->re_type == MACFG_69) {
5887                         Data32 = re_eri_read(sc, 0xD4, 4, ERIAR_ExGMAC);
5888                         Data32 |= (BIT_8 | BIT_9 | BIT_10 | BIT_11 | BIT_12);
5889                         re_eri_write(sc, 0xD4, 4, Data32, ERIAR_ExGMAC);
5890
5891                         Data32 = re_eri_read(sc, 0xDC, 4, ERIAR_ExGMAC);
5892                         Data32 |= (BIT_2| BIT_3 | BIT_4);
5893                         re_eri_write(sc, 0xDC, 4, Data32, ERIAR_ExGMAC);
5894                 } else {
5895                         Data32 = re_eri_read(sc, 0xD4, 4, ERIAR_ExGMAC);
5896                         Data32 |= (BIT_7 | BIT_8 | BIT_9 | BIT_10 | BIT_11 | BIT_12);
5897                         re_eri_write(sc, 0xD4, 4, Data32, ERIAR_ExGMAC);
5898                 }
5899
5900                 re_eri_write(sc, 0xC8, 4, 0x00080002, ERIAR_ExGMAC);
5901                 re_eri_write(sc, 0xCC, 1, 0x38, ERIAR_ExGMAC);
5902                 re_eri_write(sc, 0xD0, 1, 0x48, ERIAR_ExGMAC);
5903                 re_eri_write(sc, 0xE8, 4, 0x00100006, ERIAR_ExGMAC);
5904
5905                 if (sc->re_type == MACFG_68 || sc->re_type == MACFG_69)
5906                         MP_WriteMcuAccessRegWord(sc, 0xE054, 0xFC01);
5907
5908                 re_eri_write(sc, 0x5F0, 4, 0x4F87, ERIAR_ExGMAC);
5909
5910                 Data32 = re_eri_read(sc, 0xdc, 4, ERIAR_ExGMAC);
5911                 Data32 &= ~BIT_0;
5912                 re_eri_write(sc, 0xdc, 1, Data32, ERIAR_ExGMAC);
5913                 Data32 |= BIT_0;
5914                 re_eri_write(sc, 0xdc, 1, Data32, ERIAR_ExGMAC);
5915
5916                 Data32 = re_eri_read(sc, 0x2FC, 4, ERIAR_ExGMAC);
5917                 Data32 &= ~(BIT_0 | BIT_1 | BIT_2);
5918                 Data32 |= (BIT_0);
5919                 re_eri_write(sc, 0x2FC, 4, Data32, ERIAR_ExGMAC);
5920
5921                 Data32 = re_eri_read(sc, 0x1B0, 4, ERIAR_ExGMAC);
5922                 Data32 &= ~BIT_12;
5923                 re_eri_write(sc, 0x1B0, 4, Data32, ERIAR_ExGMAC);
5924
5925                 CSR_WRITE_4(sc, RE_TXCFG, CSR_READ_4(sc, RE_TXCFG) | BIT_7);
5926                 CSR_WRITE_1(sc, 0xD3, CSR_READ_1(sc, 0xD3) & ~BIT_7);
5927                 CSR_WRITE_1(sc, 0x1B, CSR_READ_1(sc, 0x1B) & ~0x07);
5928
5929                 CSR_WRITE_2 (sc, RE_CPlusCmd, 0x2060);
5930
5931                 if (sc->re_type == MACFG_56 || sc->re_type == MACFG_57) {
5932                         ClearPCIePhyBit(sc, 0x00, BIT_3);
5933                         ClearAndSetPCIePhyBit(sc,
5934                                               0x0C,
5935                                               (BIT_13|BIT_12|BIT_10|BIT_9|BIT_8|BIT_7|BIT_6|BIT_4),
5936                                               (BIT_11|BIT_5)
5937                                              );
5938                         SetPCIePhyBit(sc, 0x1E, BIT_0);
5939                         ClearPCIePhyBit(sc, 0x19, BIT_15);
5940                 }  else if (sc->re_type == MACFG_58) {
5941                         SetPCIePhyBit(sc, 0x00, (BIT_3));
5942                         ClearAndSetPCIePhyBit(sc,
5943                                               0x0C,
5944                                               (BIT_13 | BIT_12 | BIT_11 | BIT_10 | BIT_8 | BIT_7 | BIT_6 | BIT_5 | BIT_4),
5945                                               BIT_9
5946                                              );
5947                 }  else if (sc->re_type == MACFG_59) {
5948                         ClearPCIePhyBit(sc, 0x00, BIT_3);
5949                         ClearAndSetPCIePhyBit(sc,
5950                                               0x0C,
5951                                               (BIT_13 | BIT_12 | BIT_10 | BIT_9 | BIT_8 | BIT_7 | BIT_6 | BIT_4),
5952                                               (BIT_5 | BIT_11)
5953                                              );
5954
5955                         SetPCIePhyBit(sc, 0x1E, BIT_0);
5956                         ClearPCIePhyBit(sc, 0x19, BIT_15);
5957                         MP_WriteEPhyUshort(sc, 0x19, 0x7C00);
5958                         MP_WriteEPhyUshort(sc, 0x1E, 0x20EB);
5959                         MP_WriteEPhyUshort(sc, 0x0D, 0x1666);
5960                         MP_WriteEPhyUshort(sc, 0x00, 0x10A3);
5961
5962                         MP_WriteEPhyUshort(sc, 0x06, 0xF050);
5963
5964                         SetPCIePhyBit(sc, 0x04, BIT_4);
5965                         ClearPCIePhyBit(sc, 0x1D, BIT_14);
5966                 } else if (sc->re_type == MACFG_60) {
5967                         ClearPCIePhyBit(sc, 0x00, BIT_3);
5968                         ClearAndSetPCIePhyBit(sc,
5969                                               0x0C,
5970                                               (BIT_13 | BIT_12 | BIT_10 | BIT_9 | BIT_8 | BIT_7 | BIT_6 | BIT_4),
5971                                               (BIT_5 | BIT_11)
5972                                              );
5973                         SetPCIePhyBit(sc, 0x1E, BIT_0);
5974                         ClearPCIePhyBit(sc, 0x19, BIT_15);
5975
5976                         ClearPCIePhyBit(sc, 0x19, (BIT_5 | BIT_0));
5977
5978                         SetPCIePhyBit(sc, 0x1E, BIT_13);
5979                         ClearPCIePhyBit(sc, 0x0D, BIT_8);
5980                         SetPCIePhyBit(sc, 0x0D, BIT_9);
5981                         SetPCIePhyBit(sc, 0x00, BIT_7);
5982
5983                         SetPCIePhyBit(sc, 0x06, BIT_4);
5984
5985                         SetPCIePhyBit(sc, 0x04, BIT_4);
5986                         SetPCIePhyBit(sc, 0x1D, BIT_14);
5987                 } else if (sc->re_type == MACFG_68 || sc->re_type == MACFG_69) {
5988                         ClearPCIePhyBit(sc, 0x1E, BIT_11);
5989
5990                         SetPCIePhyBit(sc, 0x1E, BIT_0);
5991                         SetPCIePhyBit(sc, 0x1D, BIT_11);
5992
5993                         MP_WriteEPhyUshort(sc, 0x05, 0x2089);
5994                         MP_WriteEPhyUshort(sc, 0x06, 0x5881);
5995
5996                         MP_WriteEPhyUshort(sc, 0x04, 0x854A);
5997                         MP_WriteEPhyUshort(sc, 0x01, 0x068B);
5998                 }
5999
6000                 if (sc->re_type == MACFG_60) {
6001                         data16 = MP_ReadMcuAccessRegWord(sc, 0xD3C0);
6002                         data16 &= 0xF000;
6003                         data16 |= 0x3A9;
6004                         MP_WriteMcuAccessRegWord(sc, 0xD3C0, data16);
6005
6006                         data16 = MP_ReadMcuAccessRegWord(sc, 0xD3C2);
6007                         data16 &= 0xFF00;
6008                         MP_WriteMcuAccessRegWord(sc, 0xD3C2, data16);
6009
6010                         data16 = MP_ReadMcuAccessRegWord(sc, 0xD3C4);
6011                         data16 |= (BIT_0);
6012                         MP_WriteMcuAccessRegWord(sc, 0xD3C4, data16);
6013                 } else if (sc->re_type == MACFG_68 || sc->re_type == MACFG_69) {
6014                         if (sc->RequireAdjustUpsTxLinkPulseTiming) {
6015                                 data16 = MP_ReadMcuAccessRegWord(sc, 0xD412);
6016                                 data16 &= ~(0x0FFF);
6017                                 data16 |= sc->SwrCnt1msIni;
6018                                 MP_WriteMcuAccessRegWord(sc, 0xD412, data16);
6019                         }
6020
6021                         data16 = MP_ReadMcuAccessRegWord(sc, 0xE056);
6022                         data16 &= ~(BIT_7 | BIT_6 | BIT_5 | BIT_4);
6023                         data16 |= (BIT_6 | BIT_5 | BIT_4);
6024                         MP_WriteMcuAccessRegWord(sc, 0xE056, data16);
6025
6026                         data16 = MP_ReadMcuAccessRegWord(sc, 0xE052);
6027                         data16 &= ~(BIT_14 | BIT_13);
6028                         data16 |= BIT_15;
6029                         data16 |= BIT_3;
6030                         MP_WriteMcuAccessRegWord(sc, 0xE052, data16);
6031
6032                         data16 = MP_ReadMcuAccessRegWord(sc, 0xD420);
6033                         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);
6034                         data16 |= 0x47F;
6035                         MP_WriteMcuAccessRegWord(sc, 0xD420, data16);
6036
6037                         data16 = MP_ReadMcuAccessRegWord(sc, 0xE0D6);
6038                         data16 &= ~(BIT_8 | BIT_7 | BIT_6 | BIT_5 | BIT_4 | BIT_3 | BIT_2 | BIT_1 | BIT_0);
6039                         data16 |= 0x17F;
6040                         MP_WriteMcuAccessRegWord(sc, 0xE0D6, data16);
6041                 }
6042
6043                 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0);
6044
6045                 CSR_WRITE_1(sc, 0xD0, CSR_READ_1(sc, 0xD0) | BIT_6);
6046                 CSR_WRITE_1(sc, 0xF2, CSR_READ_1(sc, 0xF2) | BIT_6);
6047
6048                 CSR_WRITE_1(sc, 0xF2, CSR_READ_1(sc, 0xF2) & ~BIT_3);
6049
6050                 CSR_WRITE_1 (sc, RE_MTPS, 0x27);
6051
6052                 if (sc->re_type == MACFG_56 || sc->re_type == MACFG_57 ||
6053                     sc->re_type == MACFG_58 || sc->re_type == MACFG_59) {
6054                         MP_WriteMcuAccessRegWord(sc, 0xC140, 0xFFFF);
6055                 } else if (sc->re_type == MACFG_68 || sc->re_type == MACFG_69) {
6056                         MP_WriteMcuAccessRegWord(sc, 0xC140, 0xFFFF);
6057                         MP_WriteMcuAccessRegWord(sc, 0xC142, 0xFFFF);
6058                 }
6059
6060                 if (ifp->if_mtu > ETHERMTU) {
6061                         ifp->if_capenable &= ~IFCAP_HWCSUM;
6062                         ifp->if_hwassist &= ~RE_CSUM_FEATURES;
6063                 } else {
6064                         if (sc->re_tx_cstag) {
6065                                 ifp->if_capenable |= IFCAP_TXCSUM;
6066                                 ifp->if_hwassist |= RE_CSUM_FEATURES;
6067                         }
6068                         if (sc->re_rx_cstag) {
6069                                 ifp->if_capenable |= IFCAP_RXCSUM;
6070                         }
6071                 }
6072         } else if (macver == 0x50000000) {
6073                 /*set configuration space offset 0x70f to 0x17*/
6074                 Data32 = MP_ReadPciEConfigSpace(sc, 0x870c);
6075                 Data32 &=0xC0FFFFFF;
6076                 Data32 |= (0x27 << 24);
6077                 MP_WritePciEConfigSpace(sc, 0x870c, Data32);
6078
6079                 data8 = pci_read_config(sc->dev, 0x79, 1);
6080                 data8 &= ~0x70;
6081                 data8 |= 0x50;
6082                 pci_write_config(sc->dev, 0x79, data8, 1);
6083
6084                 Data32 = re_eri_read(sc, 0xD4, 4, ERIAR_ExGMAC);
6085                 Data32 |= BIT_7 | BIT_8 | BIT_9 | BIT_10 | BIT_11 | BIT_12;
6086                 re_eri_write(sc, 0xD4, 4, Data32, ERIAR_ExGMAC);
6087
6088                 re_eri_write(sc, 0xC8, 4, 0x00080002, ERIAR_ExGMAC);
6089                 re_eri_write(sc, 0xCC, 1, 0x2F, ERIAR_ExGMAC);
6090                 re_eri_write(sc, 0xD0, 1, 0x5F, ERIAR_ExGMAC);
6091                 re_eri_write(sc, 0xE8, 4, 0x00100006, ERIAR_ExGMAC);
6092
6093                 if (sc->re_type == MACFG_62 || sc->re_type == MACFG_67) {
6094                         OOB_mutex_lock(sc);
6095                         re_eri_write(sc, 0x5F0, 4, 0x4F87, ERIAR_ExGMAC);
6096                         OOB_mutex_unlock(sc);
6097                 }
6098
6099                 Data32 = re_eri_read(sc, 0xdc, 4, ERIAR_ExGMAC);
6100                 Data32 &= ~BIT_0;
6101                 re_eri_write(sc, 0xdc, 1, Data32, ERIAR_ExGMAC);
6102                 Data32 |= BIT_0;
6103                 re_eri_write(sc, 0xdc, 1, Data32, ERIAR_ExGMAC);
6104
6105                 Data32 = re_eri_read(sc, 0x2FC, 4, ERIAR_ExGMAC);
6106                 Data32 &= ~(BIT_0 | BIT_1 | BIT_2);
6107                 Data32 |= (BIT_0);
6108                 re_eri_write(sc, 0x2FC, 4, Data32, ERIAR_ExGMAC);
6109
6110                 Data32 = re_eri_read(sc, 0x1B0, 4, ERIAR_ExGMAC);
6111                 Data32 &= ~BIT_12;
6112                 re_eri_write(sc, 0x1B0, 4, Data32, ERIAR_ExGMAC);
6113
6114                 CSR_WRITE_4(sc, RE_TXCFG, CSR_READ_4(sc, RE_TXCFG) | BIT_7);
6115                 CSR_WRITE_1(sc, 0xD3, CSR_READ_1(sc, 0xD3) & ~BIT_7);
6116                 CSR_WRITE_1(sc, 0x1B, CSR_READ_1(sc, 0x1B) & ~0x07);
6117
6118                 CSR_WRITE_2 (sc, RE_CPlusCmd, 0x2060);
6119
6120                 if (sc->re_type == MACFG_61) {
6121                         MP_WriteEPhyUshort(sc, 0x00, 0x10AB);
6122                         MP_WriteEPhyUshort(sc, 0x06, 0xF030);
6123                         MP_WriteEPhyUshort(sc, 0x08, 0x2006);
6124                         MP_WriteEPhyUshort(sc, 0x0D, 0x1666);
6125                         ClearPCIePhyBit(sc, 0x0C, (BIT_13 | BIT_12 | BIT_11 | BIT_10 | BIT_9 | BIT_8 | BIT_7 | BIT_6 | BIT_5 | BIT_4));
6126                 }  else if (sc->re_type == MACFG_62) {
6127                         MP_WriteEPhyUshort(sc, 0x00, 0x10A3);
6128                         MP_WriteEPhyUshort(sc, 0x19, 0xFC00);
6129                         MP_WriteEPhyUshort(sc, 0x1E, 0x20EA);
6130                 } else if (sc->re_type == MACFG_67) {
6131                         SetPCIePhyBit(sc, 0x00, BIT_7);
6132                         ClearAndSetPCIePhyBit(sc,
6133                                               0x0D,
6134                                               BIT_8,
6135                                               BIT_9
6136                                              );
6137                         ClearPCIePhyBit(sc, 0x19, (BIT_15 | BIT_5 | BIT_0));
6138                         SetPCIePhyBit(sc, 0x1E, BIT_13);
6139                 }
6140
6141                 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0);
6142
6143                 CSR_WRITE_1(sc, 0xD0, CSR_READ_1(sc, 0xD0) | BIT_6);
6144                 CSR_WRITE_1(sc, 0xF2, CSR_READ_1(sc, 0xF2) | BIT_6);
6145
6146                 CSR_WRITE_1(sc, 0xF2, CSR_READ_1(sc, 0xF2) & ~BIT_3);
6147
6148                 CSR_WRITE_1 (sc, RE_MTPS, 0x27);
6149
6150                 if (sc->re_type == MACFG_67) {
6151                         data16 = MP_ReadMcuAccessRegWord(sc, 0xD3E2);
6152                         data16 &= 0xF000;
6153                         data16 |= 0x3A9;
6154                         MP_WriteMcuAccessRegWord(sc, 0xD3E2, data16);
6155
6156                         data16 = MP_ReadMcuAccessRegWord(sc, 0xD3E4);
6157                         data16 &= 0xFF00;
6158                         MP_WriteMcuAccessRegWord(sc, 0xD3E4, data16);
6159
6160                         data16 = MP_ReadMcuAccessRegWord(sc, 0xE860);
6161                         data16 |= BIT_7;
6162                         MP_WriteMcuAccessRegWord(sc, 0xE860, data16);
6163                 }
6164
6165                 MP_WriteMcuAccessRegWord(sc, 0xC140, 0xFFFF);
6166                 MP_WriteMcuAccessRegWord(sc, 0xC142, 0xFFFF);
6167
6168                 if (ifp->if_mtu > ETHERMTU) {
6169                         ifp->if_capenable &= ~IFCAP_HWCSUM;
6170                         ifp->if_hwassist &= ~RE_CSUM_FEATURES;
6171                 } else {
6172                         if (sc->re_tx_cstag) {
6173                                 ifp->if_capenable |= IFCAP_TXCSUM;
6174                                 ifp->if_hwassist |= RE_CSUM_FEATURES;
6175                         }
6176                         if (sc->re_rx_cstag) {
6177                                 ifp->if_capenable |= IFCAP_RXCSUM;
6178                         }
6179                 }
6180         } else if (macver == 0x54800000) {
6181                 MP_WriteMcuAccessRegWord(sc, 0xD400, MP_ReadMcuAccessRegWord(sc, 0xD400) & ~(BIT_0));
6182
6183                 if (sc->RequireAdjustUpsTxLinkPulseTiming) {
6184                         data16 = MP_ReadMcuAccessRegWord(sc, 0xD412);
6185                         data16 &= ~(0x0FFF);
6186                         data16 |= sc->SwrCnt1msIni;
6187                         MP_WriteMcuAccessRegWord(sc, 0xD412, data16);
6188                 }
6189
6190                 data16 = MP_ReadMcuAccessRegWord(sc, 0xE056);
6191                 data16 &= ~(BIT_7 | BIT_6 | BIT_5 | BIT_4);
6192                 data16 |= (BIT_6 | BIT_5 | BIT_4);
6193                 MP_WriteMcuAccessRegWord(sc, 0xE056, data16);
6194
6195                 OOB_mutex_lock(sc);
6196                 data16 = MP_ReadMcuAccessRegWord(sc, 0xE052);
6197                 if (sc->re_type == MACFG_71)
6198                         data16 |= BIT_3;
6199                 else
6200                         data16 &= ~BIT_3;
6201                 MP_WriteMcuAccessRegWord(sc, 0xE052, data16);
6202                 OOB_mutex_unlock(sc);
6203
6204                 data16 = MP_ReadMcuAccessRegWord(sc, 0xD420);
6205                 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);
6206                 data16 |= 0x47F;
6207                 MP_WriteMcuAccessRegWord(sc, 0xD420, data16);
6208
6209                 CSR_WRITE_1(sc, RE_TDFNR, 0x4);
6210
6211                 data16 = MP_ReadMcuAccessRegWord(sc, 0xE63E);
6212                 data16 &= ~(BIT_3 | BIT_2 | BIT_1);
6213                 MP_WriteMcuAccessRegWord(sc, 0xE63E, data16);
6214                 data16 |= (BIT_0);
6215                 MP_WriteMcuAccessRegWord(sc, 0xE63E, data16);
6216                 data16 &= ~(BIT_0);
6217                 MP_WriteMcuAccessRegWord(sc, 0xE63E, data16);
6218                 MP_WriteMcuAccessRegWord(sc, 0xC094, 0x0);
6219                 MP_WriteMcuAccessRegWord(sc, 0xC09E, 0x0);
6220
6221                 /*set configuration space offset 0x70f to 0x27*/
6222                 Data32 = MP_ReadPciEConfigSpace(sc, 0x870c);
6223                 Data32 &=0xC0FFFFFF;
6224                 Data32 |= (0x27 << 24);
6225                 MP_WritePciEConfigSpace(sc, 0x870c, Data32);
6226
6227                 data8 = pci_read_config(sc->dev, 0x79, 1);
6228                 data8 &= ~0x70;
6229                 data8 |= 0x50;
6230                 pci_write_config(sc->dev, 0x79, data8, 1);
6231
6232                 Data32 = re_eri_read(sc, 0xD4, 4, ERIAR_ExGMAC);
6233                 Data32 |= BIT_7 | BIT_8 | BIT_9 | BIT_10 | BIT_11 | BIT_12;
6234                 if (sc->re_type == MACFG_71) Data32 |= BIT_4;
6235                 re_eri_write(sc, 0xD4, 4, Data32, ERIAR_ExGMAC);
6236
6237                 re_eri_write(sc, 0xC8, 4, 0x00080002, ERIAR_ExGMAC);
6238                 re_eri_write(sc, 0xCC, 1, 0x2F, ERIAR_ExGMAC);
6239                 re_eri_write(sc, 0xD0, 1, 0x5F, ERIAR_ExGMAC);
6240                 re_eri_write(sc, 0xE8, 4, 0x00100006, ERIAR_ExGMAC);
6241
6242                 MP_WriteMcuAccessRegWord(sc, 0xE054, 0xFC01);
6243
6244                 OOB_mutex_lock(sc);
6245                 Data32 = re_eri_read(sc, 0x5F0, 4, ERIAR_ExGMAC);
6246                 Data32 |= (BIT_8 | BIT_9 | BIT_10 | BIT_11);
6247                 re_eri_write(sc, 0x5F0, 4, Data32, ERIAR_ExGMAC);
6248                 OOB_mutex_unlock(sc);
6249
6250                 Data32 = re_eri_read(sc, 0xdc, 4, ERIAR_ExGMAC);
6251                 Data32 &= ~BIT_0;
6252                 re_eri_write(sc, 0xdc, 1, Data32, ERIAR_ExGMAC);
6253                 Data32 |= BIT_0;
6254                 re_eri_write(sc, 0xdc, 1, Data32, ERIAR_ExGMAC);
6255
6256                 Data32 = re_eri_read(sc, 0x2FC, 4, ERIAR_ExGMAC);
6257                 Data32 &= ~(BIT_0 | BIT_1 | BIT_2);
6258                 Data32 |= (BIT_0);
6259                 re_eri_write(sc, 0x2FC, 4, Data32, ERIAR_ExGMAC);
6260
6261                 Data32 = re_eri_read(sc, 0x1B0, 4, ERIAR_ExGMAC);
6262                 Data32 &= ~BIT_12;
6263                 re_eri_write(sc, 0x1B0, 4, Data32, ERIAR_ExGMAC);
6264
6265                 Data32 = re_eri_read(sc, 0x1D0, 1, ERIAR_ExGMAC);
6266                 Data32 &= ~BIT_1;
6267                 re_eri_write(sc, 0x1D0, 1, Data32, ERIAR_ExGMAC);
6268
6269                 re_eri_write(sc, 0xC0, 2, 0x0000, ERIAR_ExGMAC);
6270                 re_eri_write(sc, 0xB8, 4, 0x00000000, ERIAR_ExGMAC);
6271
6272                 CSR_WRITE_4(sc, RE_TXCFG, CSR_READ_4(sc, RE_TXCFG) | BIT_7);
6273                 CSR_WRITE_1(sc, 0xD3, CSR_READ_1(sc, 0xD3) & ~BIT_7);
6274                 CSR_WRITE_1(sc, 0x1B, CSR_READ_1(sc, 0x1B) & ~0x07);
6275
6276                 CSR_WRITE_2 (sc, RE_CPlusCmd, 0x2060);
6277
6278                 ClearAndSetPCIePhyBit(sc,
6279                                       0x19,
6280                                       BIT_6,
6281                                       (BIT_12| BIT_8)
6282                                      );
6283                 ClearAndSetPCIePhyBit(sc,
6284                                       0x59,
6285                                       BIT_6,
6286                                       (BIT_12| BIT_8)
6287                                      );
6288
6289                 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0);
6290
6291                 CSR_WRITE_1(sc, 0xD0, CSR_READ_1(sc, 0xD0) | BIT_6);
6292                 CSR_WRITE_1(sc, 0xF2, CSR_READ_1(sc, 0xF2) | BIT_6);
6293
6294                 CSR_WRITE_1(sc, 0xD0, CSR_READ_1(sc, 0xD0) | BIT_7);
6295
6296                 CSR_WRITE_1(sc, 0xF2, CSR_READ_1(sc, 0xF2) & ~BIT_3);
6297
6298                 if (ifp->if_mtu > ETHERMTU)
6299                         CSR_WRITE_1 (sc, RE_MTPS, 0x27);
6300
6301                 data16 = MP_ReadMcuAccessRegWord(sc, 0xD3E2);
6302                 data16 &= 0xF000;
6303                 data16 |= 0x3A9;
6304                 MP_WriteMcuAccessRegWord(sc, 0xD3E2, data16);
6305
6306                 data16 = MP_ReadMcuAccessRegWord(sc, 0xD3E4);
6307                 data16 &= 0xFF00;
6308                 MP_WriteMcuAccessRegWord(sc, 0xD3E4, data16);
6309
6310                 data16 = MP_ReadMcuAccessRegWord(sc, 0xE860);
6311                 data16 |= BIT_7;
6312                 MP_WriteMcuAccessRegWord(sc, 0xE860, data16);
6313
6314                 MP_WriteMcuAccessRegWord(sc, 0xC140, 0xFFFF);
6315                 MP_WriteMcuAccessRegWord(sc, 0xC142, 0xFFFF);
6316
6317                 if (ifp->if_mtu > ETHERMTU) {
6318                         ifp->if_capenable &= ~IFCAP_HWCSUM;
6319                         ifp->if_hwassist &= ~RE_CSUM_FEATURES;
6320                 } else {
6321                         if (sc->re_tx_cstag) {
6322                                 ifp->if_capenable |= IFCAP_TXCSUM;
6323                                 ifp->if_hwassist |= RE_CSUM_FEATURES;
6324                         }
6325                         if (sc->re_rx_cstag) {
6326                                 ifp->if_capenable |= IFCAP_RXCSUM;
6327                         }
6328                 }
6329         }
6330
6331         //clear io_rdy_l23
6332         switch (sc->re_type) {
6333         case MACFG_42:
6334         case MACFG_43:
6335         case MACFG_52:
6336         case MACFG_53:
6337         case MACFG_54:
6338         case MACFG_55:
6339         case MACFG_56:
6340         case MACFG_57:
6341         case MACFG_58:
6342         case MACFG_59:
6343         case MACFG_60:
6344         case MACFG_61:
6345         case MACFG_62:
6346         case MACFG_67:
6347         case MACFG_68:
6348         case MACFG_69:
6349         case MACFG_70:
6350         case MACFG_71:
6351                 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_1);
6352                 break;
6353         }
6354
6355         switch(sc->re_type) {
6356         case MACFG_36:
6357         case MACFG_37:
6358         case MACFG_38:
6359         case MACFG_39:
6360         case MACFG_42:
6361         case MACFG_43:
6362         case MACFG_50:
6363         case MACFG_51:
6364         case MACFG_52:
6365         case MACFG_53:
6366         case MACFG_54:
6367         case MACFG_55:
6368         case MACFG_56:
6369         case MACFG_57:
6370         case MACFG_58:
6371         case MACFG_59:
6372         case MACFG_60:
6373         case MACFG_61:
6374         case MACFG_62:
6375         case MACFG_67:
6376         case MACFG_68:
6377         case MACFG_69:
6378         case MACFG_70:
6379         case MACFG_71:
6380                 CSR_WRITE_1(sc, RE_CFG5, CSR_READ_1(sc, RE_CFG5) | BIT_0);
6381                 CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2) | BIT_7);
6382                 CSR_WRITE_1(sc, 0xF1, CSR_READ_1(sc, 0xF1) | BIT_7);
6383                 break;
6384         }
6385
6386         //clear wol
6387         re_clrwol(sc);
6388
6389         data16 = CSR_READ_2(sc, RE_CPlusCmd);
6390         if ((ifp->if_capenable & IFCAP_VLAN_HWTAGGING) != 0)
6391                 data16 |= RL_CPLUSCMD_VLANSTRIP;
6392         else
6393                 data16 &= ~RL_CPLUSCMD_VLANSTRIP;
6394
6395         if ((ifp->if_capenable & IFCAP_RXCSUM) != 0)
6396                 data16 |= RL_RxChkSum;
6397         else
6398                 data16 &= ~RL_RxChkSum;
6399         CSR_WRITE_2 (sc, RE_CPlusCmd, data16);
6400
6401         re_disable_cfg9346_write(sc);
6402         //CSR_WRITE_1(sc, 0xec, 0x3f);
6403
6404         if (sc->re_device_id == RT_DEVICEID_8169 || sc->re_device_id == RT_DEVICEID_8169SC) {
6405                 /* Enable transmit and receive.*/
6406                 CSR_WRITE_1(sc, RE_COMMAND, RE_CMD_TX_ENB | RE_CMD_RX_ENB);
6407
6408                 /* Set the initial TX configuration.*/
6409                 CSR_WRITE_4(sc, RE_TXCFG, RE_TXCFG_CONFIG);
6410
6411                 /* Set the initial RX configuration.*/
6412                 /*
6413                  * Program the multicast filter, if necessary.
6414                  */
6415                 re_set_rx_packet_filter(sc);
6416         } else {
6417                 /* Set the initial RX configuration.*/
6418                 /*
6419                  * Program the multicast filter, if necessary.
6420                  */
6421                 re_set_rx_packet_filter(sc);
6422
6423                 /* Enable transmit and receive.*/
6424                 CSR_WRITE_1(sc, RE_COMMAND, RE_CMD_TX_ENB | RE_CMD_RX_ENB);
6425         }
6426
6427 #ifndef __DragonFly__
6428         ifp->if_drv_flags |= IFF_DRV_RUNNING;
6429         ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
6430
6431         /*
6432         * Enable interrupts.
6433         */
6434         CSR_WRITE_2(sc, RE_IMR, RE_INTRS);
6435 #endif
6436 }
6437
6438 static void re_init_unlock(void *xsc)   /* Software & Hardware Initialize */
6439 {
6440         struct re_softc         *sc = xsc;
6441         struct ifnet            *ifp;
6442 #ifndef __DragonFly__
6443 #if OS_VER < VERSION(6,0)
6444         int                     i;
6445 #endif
6446 #endif  /* !__DragonFly__ */
6447         union {
6448                 uint32_t align_dummy;
6449                 u_char eaddr[ETHER_ADDR_LEN];
6450         } eaddr;
6451
6452         ifp = RE_GET_IFNET(sc);
6453
6454 #ifndef __DragonFly__
6455         /*
6456          * Cancel pending I/O and free all RX/TX buffers.
6457          */
6458         re_stop(sc);
6459 #endif  /* !__DragonFly__ */
6460
6461         /* Copy MAC address on stack to align. */
6462 #ifndef __DragonFly__
6463 #if OS_VER < VERSION(6,0)
6464         bcopy((char *)&sc->arpcom.ac_enaddr, eaddr.eaddr, ETHER_ADDR_LEN);
6465 #elif OS_VER < VERSION(7,0)
6466         bcopy(IFP2ENADDR(ifp), eaddr.eaddr, ETHER_ADDR_LEN);
6467 #else
6468         bcopy(IF_LLADDR(ifp), eaddr.eaddr, ETHER_ADDR_LEN);
6469 #endif
6470 #else   /* __DragonFly__ */
6471         bcopy(IF_LLADDR(ifp), eaddr.eaddr, ETHER_ADDR_LEN);
6472 #endif  /* !__DragonFly__ */
6473
6474         /* Init our MAC address */
6475         re_rar_set(sc, eaddr.eaddr);
6476
6477 #ifndef __DragonFly__
6478         re_hw_start_unlock(sc);
6479 #endif
6480
6481         return;
6482 }
6483
6484 #ifndef __DragonFly__
6485 static void re_init(void *xsc)          /* Software & Hardware Initialize */
6486 {
6487         struct re_softc         *sc = xsc;
6488         struct ifnet            *ifp;
6489
6490         RE_LOCK(sc);
6491         ifp = RE_GET_IFNET(sc);
6492
6493         if (re_link_ok(sc)) {
6494                 sc->link_state = LINK_STATE_UP;
6495                 re_link_state_change(ifp, sc->link_state);
6496                 re_link_on_patch(sc);
6497         }
6498
6499         sc->re_link_chg_det = 1;
6500         re_start_timer(sc);
6501
6502         RE_UNLOCK(sc);
6503 }
6504
6505 /*
6506  * Initialize the transmit descriptors.
6507  */
6508 static int re_var_init(struct re_softc *sc)
6509 {
6510         int                     i;
6511         union RxDesc *rxptr;
6512         union TxDesc *txptr;
6513
6514         sc->re_desc.rx_cur_index = 0;
6515         sc->re_desc.rx_last_index = 0;
6516         rxptr = sc->re_desc.rx_desc;
6517         for (i = 0; i < RE_RX_BUF_NUM; i++) {
6518                 memset(&rxptr[i], 0, sizeof(union RxDesc));
6519
6520                 /* Init the RX buffer pointer register. */
6521                 bus_dmamap_load(sc->re_desc.re_rx_mtag,
6522                                 sc->re_desc.re_rx_dmamap[i],
6523                                 sc->re_desc.rx_buf[i]->m_data, sc->re_rx_desc_buf_sz,
6524                                 re_rx_dma_map_buf,
6525                                 &rxptr[i],
6526                                 0);
6527                 bus_dmamap_sync(sc->re_desc.re_rx_mtag,
6528                                 sc->re_desc.re_rx_dmamap[i],
6529                                 BUS_DMASYNC_PREREAD);
6530
6531                 rxptr[i].ul[0] = htole32(sc->re_rx_desc_buf_sz);
6532                 if (i == (RE_RX_BUF_NUM - 1))
6533                         rxptr[i].ul[0] |= htole32(RL_RDESC_CMD_EOR);
6534                 rxptr[i].ul[0] |= htole32(RL_RDESC_CMD_OWN);
6535         }
6536
6537         bus_dmamap_load(sc->re_desc.rx_desc_tag,
6538                         sc->re_desc.rx_desc_dmamap,
6539                         sc->re_desc.rx_desc,
6540                         sizeof(union RxDesc)*RE_RX_BUF_NUM,
6541                         re_dma_map_rxdesc,
6542                         sc,
6543                         0);
6544         bus_dmamap_sync(sc->re_desc.rx_desc_tag,
6545                         sc->re_desc.rx_desc_dmamap,
6546                         BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
6547
6548         sc->re_desc.tx_cur_index = 0;
6549         sc->re_desc.tx_last_index = 0;
6550         txptr = sc->re_desc.tx_desc;
6551         for (i = 0; i < RE_TX_BUF_NUM; i++) {
6552                 memset(&txptr[i], 0, sizeof(union TxDesc));
6553                 if (i == (RE_TX_BUF_NUM - 1))
6554                         txptr[i].ul[0] = htole32(RL_TDESC_CMD_EOR);
6555         }
6556
6557         bus_dmamap_load(sc->re_desc.tx_desc_tag,
6558                         sc->re_desc.tx_desc_dmamap,
6559                         sc->re_desc.tx_desc,
6560                         sizeof(union RxDesc) * RE_TX_BUF_NUM,
6561                         re_dma_map_txdesc,
6562                         sc,
6563                         0);
6564         bus_dmamap_sync(sc->re_desc.tx_desc_tag,
6565                         sc->re_desc.tx_desc_dmamap,
6566                         BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
6567
6568         return 0;
6569 }
6570 #endif  /* !__DragonFly__ */
6571
6572 static void re_reset(struct re_softc *sc)
6573 {
6574         register int            i;
6575
6576         CSR_WRITE_4(sc, RE_RXCFG, CSR_READ_4(sc, RE_RXCFG)& ~0x3F);
6577
6578         switch (sc->re_type) {
6579         case MACFG_3:
6580         case MACFG_4:
6581         case MACFG_5:
6582         case MACFG_6:
6583                 DELAY(10000);
6584                 break;
6585         case MACFG_11:
6586         case MACFG_12:
6587         case MACFG_13:
6588         case MACFG_14:
6589         case MACFG_15:
6590         case MACFG_16:
6591         case MACFG_17:
6592         case MACFG_18:
6593         case MACFG_19:
6594         case MACFG_21:
6595         case MACFG_22:
6596         case MACFG_23:
6597         case MACFG_24:
6598         case MACFG_25:
6599         case MACFG_26:
6600         case MACFG_27:
6601         case MACFG_28:
6602         case MACFG_31:
6603         case MACFG_32:
6604         case MACFG_33:
6605         case MACFG_36:
6606         case MACFG_37:
6607         case MACFG_41:
6608         case MACFG_42:
6609         case MACFG_43:
6610         case MACFG_54:
6611         case MACFG_55:
6612         case MACFG_63:
6613         case MACFG_64:
6614         case MACFG_65:
6615         case MACFG_66:
6616                 CSR_WRITE_1(sc, RE_COMMAND, 0x8C);
6617                 break;
6618         case MACFG_38:
6619         case MACFG_39:
6620         case MACFG_50:
6621         case MACFG_51:
6622         case MACFG_52:
6623         case MACFG_53:
6624                 CSR_WRITE_1(sc, RE_COMMAND, 0x8C);
6625                 while (!(CSR_READ_4(sc,RE_TXCFG) & BIT_11)) DELAY(100);
6626                 break;
6627         case MACFG_56:
6628         case MACFG_57:
6629         case MACFG_58:
6630         case MACFG_59:
6631         case MACFG_60:
6632         case MACFG_61:
6633         case MACFG_62:
6634         case MACFG_67:
6635         case MACFG_68:
6636         case MACFG_69:
6637         case MACFG_70:
6638         case MACFG_71:
6639                 DELAY(2000);
6640                 break;
6641         default:
6642                 DELAY(10000);
6643                 break;
6644         }
6645         DELAY(200);
6646         CSR_WRITE_1(sc, RE_COMMAND, RE_CMD_RESET);
6647
6648         for (i = 0; i < RE_TIMEOUT; i++) {
6649                 DELAY(10);
6650                 if (!(CSR_READ_1(sc, RE_COMMAND) & RE_CMD_RESET))
6651                         break;
6652         }
6653
6654         if (i == RE_TIMEOUT)
6655                 device_printf(sc->dev,"reset never completed!\n");
6656
6657         return;
6658 }
6659
6660 static u_int8_t re_link_ok(struct re_softc *sc)
6661 {
6662         u_int8_t        retval;
6663
6664         retval = (CSR_READ_1(sc, RE_PHY_STATUS) & RL_PHY_STATUS_LINK_STS) ? 1 : 0;
6665
6666         return retval;
6667 }
6668
6669 static void
6670 re_set_wol_linkspeed(struct re_softc *sc)
6671 {
6672         u_int8_t wol_link_speed;
6673         u_int16_t anar;
6674
6675         MP_WritePhyUshort(sc, 0x1F, 0x0000);
6676
6677         wol_link_speed = RE_WOL_LINK_SPEED_100M_FIRST;
6678         if (!sc->re_dash) {
6679                 if (re_link_ok(sc)) {
6680                         u_int16_t anlpar;
6681
6682                         anlpar = MP_ReadPhyUshort(sc,MII_ANLPAR);
6683                         if ((anlpar & ANLPAR_10_FD) || (anlpar & ANLPAR_10)) {
6684                                 wol_link_speed = RE_WOL_LINK_SPEED_10M_FIRST;
6685                         } else {
6686                                 wol_link_speed = RE_WOL_LINK_SPEED_100M_FIRST;
6687                         }
6688                 }
6689         }
6690
6691         anar = MP_ReadPhyUshort(sc,MII_ANAR);
6692
6693         if (wol_link_speed == RE_WOL_LINK_SPEED_10M_FIRST)
6694                 anar &= ~(ANAR_TX_FD | ANAR_TX);
6695
6696         if (sc->re_device_id==RT_DEVICEID_8169 || sc->re_device_id==RT_DEVICEID_8169SC ||
6697             sc->re_device_id==RT_DEVICEID_8168 || sc->re_device_id==RT_DEVICEID_8161) {
6698                 u_int16_t gbcr;
6699
6700                 gbcr = MP_ReadPhyUshort(sc,MII_100T2CR);
6701                 gbcr &= ~(GTCR_ADV_1000TFDX|GTCR_ADV_1000THDX);
6702                 MP_WritePhyUshort(sc, MII_100T2CR, gbcr);
6703                 MP_WritePhyUshort(sc, MII_ANAR, anar);
6704                 MP_WritePhyUshort(sc, MII_BMCR, BMCR_RESET | BMCR_AUTOEN | BMCR_STARTNEG);
6705         } else if (sc->re_type == MACFG_36) {
6706                 MP_WritePhyUshort(sc, MII_ANAR, anar);
6707                 MP_WritePhyUshort(sc, MII_BMCR, BMCR_RESET | BMCR_AUTOEN | BMCR_STARTNEG);
6708         } else {
6709                 MP_WritePhyUshort(sc, MII_ANAR, anar);
6710                 MP_WritePhyUshort(sc, MII_BMCR, BMCR_AUTOEN | BMCR_STARTNEG);
6711         }
6712 }
6713
6714 #ifndef __DragonFly__
6715 static void
6716 re_setwol(struct re_softc *sc)
6717 {
6718         struct ifnet            *ifp;
6719         int                     pmc;
6720         uint16_t                pmstat;
6721         uint8_t                 v;
6722
6723         RE_LOCK_ASSERT(sc);
6724
6725         ifp = RE_GET_IFNET(sc);
6726
6727         if ((ifp->if_capenable & IFCAP_WOL) == 0) {
6728                 re_phy_power_down(sc->dev);
6729                 return;
6730         }
6731
6732         if (pci_find_cap(sc->dev, PCIY_PMG, &pmc) != 0)
6733                 return;
6734
6735         /* Enable config register write. */
6736         re_enable_cfg9346_write(sc);
6737
6738         /* Enable PME. */
6739         if (sc->re_device_id==RT_DEVICEID_8169 || sc->re_device_id==RT_DEVICEID_8169SC) {
6740                 v = CSR_READ_1(sc, RE_CFG1);
6741                 v &= ~RE_CFG1_PME;
6742                 if ((ifp->if_capenable & IFCAP_WOL) != 0)
6743                         v |= RE_CFG1_PME;
6744                 CSR_WRITE_1(sc, RE_CFG1, v);
6745         }
6746
6747         if (sc->re_if_flags & RL_FLAG_MAGIC_PACKET_V2) {
6748                 uint32_t                Data32;
6749
6750                 Data32 = re_eri_read(sc, 0xDC, 4, ERIAR_ExGMAC);
6751                 Data32 &= ~(BIT_16);
6752                 if ((ifp->if_capenable & IFCAP_WOL_MAGIC) != 0)
6753                         Data32 |= BIT_16;
6754                 re_eri_write(sc, 0xDC, 4, Data32, ERIAR_ExGMAC);
6755         } else {
6756                 v = CSR_READ_1(sc, RE_CFG3);
6757                 v &= ~(RL_CFG3_WOL_MAGIC);
6758                 if ((ifp->if_capenable & IFCAP_WOL_MAGIC) != 0)
6759                         v |= RL_CFG3_WOL_MAGIC;
6760                 CSR_WRITE_1(sc, RE_CFG3, v);
6761         }
6762
6763         v = CSR_READ_1(sc, RE_CFG5);
6764         v &= ~(RL_CFG5_WOL_BCAST | RL_CFG5_WOL_MCAST | RL_CFG5_WOL_UCAST |
6765                RL_CFG5_WOL_LANWAKE);
6766
6767         if ((ifp->if_capenable & IFCAP_WOL_UCAST) != 0)
6768                 v |= RL_CFG5_WOL_UCAST;
6769         if ((ifp->if_capenable & IFCAP_WOL_MCAST) != 0)
6770                 v |= RL_CFG5_WOL_MCAST | RL_CFG5_WOL_BCAST;
6771         if ((ifp->if_capenable & IFCAP_WOL) != 0)
6772                 v |= RL_CFG5_WOL_LANWAKE;
6773         CSR_WRITE_1(sc, RE_CFG5, v);
6774
6775         /* Config register write done. */
6776         re_disable_cfg9346_write(sc);
6777
6778         /*
6779          * It seems that hardware resets its link speed to 100Mbps in
6780          * power down mode so switching to 100Mbps in driver is not
6781          * needed.
6782          */
6783
6784         /* Request PME if WOL is requested. */
6785         pmstat = pci_read_config(sc->dev, pmc + PCIR_POWER_STATUS, 2);
6786         pmstat &= ~(PCIM_PSTAT_PMEENABLE);
6787         if ((ifp->if_capenable & IFCAP_WOL) != 0)
6788                 pmstat |= PCIM_PSTAT_PMEENABLE;
6789         pci_write_config(sc->dev, pmc + PCIR_POWER_STATUS, pmstat, 2);
6790
6791         /* Put controller into sleep mode. */
6792         if ((ifp->if_capenable & IFCAP_WOL) != 0) {
6793                 re_set_rx_packet_filter_in_sleep_state(sc);
6794                 re_set_wol_linkspeed(sc);
6795                 if (sc->re_type == MACFG_21 || sc->re_type == MACFG_22)
6796                         CSR_WRITE_1(sc, RE_COMMAND, RE_CMD_RX_ENB);
6797         }
6798 }
6799 #endif  /* !__DragonFly__ */
6800
6801 static void
6802 re_clrwol(struct re_softc *sc)
6803 {
6804         int                     pmc;
6805         uint16_t                pmstat;
6806         uint8_t                 v;
6807
6808         RE_LOCK_ASSERT(sc);
6809
6810 #ifndef __DragonFly__
6811         if (pci_find_cap(sc->dev, PCIY_PMG, &pmc) != 0)
6812                 return;
6813 #else
6814         if (pci_find_extcap(sc->dev, PCIY_PMG, &pmc) != 0)
6815                 return;
6816 #endif
6817
6818         /* Disable PME and clear PME status. */
6819         pmstat = pci_read_config(sc->dev, pmc + PCIR_POWER_STATUS, 2);
6820         pmstat &= ~PCIM_PSTAT_PMEENABLE;
6821         pci_write_config(sc->dev, pmc + PCIR_POWER_STATUS, pmstat, 2);
6822
6823         /* Enable config register write. */
6824         re_enable_cfg9346_write(sc);
6825
6826         if (sc->re_device_id==RT_DEVICEID_8169 || sc->re_device_id==RT_DEVICEID_8169SC) {
6827                 v = CSR_READ_1(sc, RE_CFG1);
6828                 v &= ~RE_CFG1_PME;
6829                 CSR_WRITE_1(sc, RE_CFG1, v);
6830         }
6831
6832         v = CSR_READ_1(sc, RE_CFG3);
6833         v &= ~(RL_CFG3_WOL_LINK);
6834         CSR_WRITE_1(sc, RE_CFG3, v);
6835
6836         if (sc->re_if_flags & RL_FLAG_MAGIC_PACKET_V2) {
6837                 uint32_t                Data32;
6838
6839                 Data32 = re_eri_read(sc, 0xDC, 4, ERIAR_ExGMAC);
6840                 Data32 &= ~(BIT_16);
6841                 re_eri_write(sc, 0xDC, 4, Data32, ERIAR_ExGMAC);
6842         } else {
6843                 v = CSR_READ_1(sc, RE_CFG3);
6844                 v &= ~(RL_CFG3_WOL_MAGIC);
6845                 CSR_WRITE_1(sc, RE_CFG3, v);
6846         }
6847
6848         v = CSR_READ_1(sc, RE_CFG5);
6849         v &= ~(RL_CFG5_WOL_BCAST | RL_CFG5_WOL_MCAST | RL_CFG5_WOL_UCAST);
6850         v &= ~RL_CFG5_WOL_LANWAKE;
6851         CSR_WRITE_1(sc, RE_CFG5, v);
6852
6853         /* Config register write done. */
6854         re_disable_cfg9346_write(sc);
6855 }
6856
6857 /*
6858  * Stop the adapter and free any mbufs allocated to the
6859  * RX and TX lists.
6860  */
6861 #ifndef __DragonFly__
6862 static void re_stop(struct re_softc *sc)        /* Stop Driver */
6863 #else   /* __DragonFly__ */
6864 static void
6865 re_stop_rtl(struct re_softc *sc)
6866 #endif  /* !__DragonFly__ */
6867 {
6868 #ifndef __DragonFly__
6869         struct ifnet            *ifp;
6870
6871         /*      RE_LOCK_ASSERT(sc);*/
6872
6873         ifp = RE_GET_IFNET(sc);
6874 #if OS_VER < VERSION(9,0)
6875         ifp->if_timer = 0;
6876 #endif
6877
6878         re_stop_timer(sc);
6879 #endif  /* !__DragonFly__ */
6880
6881         /*
6882          * Disable accepting frames to put RX MAC into idle state.
6883          * Otherwise it's possible to get frames while stop command
6884          * execution is in progress and controller can DMA the frame
6885          * to already freed RX buffer during that period.
6886          */
6887         CSR_WRITE_4(sc, RE_RXCFG, CSR_READ_4(sc, RE_RXCFG) &
6888                     ~(RE_RXCFG_RX_ALLPHYS | RE_RXCFG_RX_INDIV | RE_RXCFG_RX_MULTI |
6889                       RE_RXCFG_RX_BROAD | RE_RXCFG_RX_RUNT | RE_RXCFG_RX_ERRPKT));
6890
6891         CSR_WRITE_2(sc, RE_IMR, 0x0000);
6892         CSR_WRITE_2(sc, RE_ISR, 0xffff);
6893         if (sc->re_type == MACFG_50 || sc->re_type == MACFG_51 || sc->re_type == MACFG_52) {
6894                 re_eri_write(sc, 0x1bc, 4, 0x0000001f, ERIAR_ExGMAC);
6895                 re_eri_write(sc, 0x1dc, 4, 0x0000002d, ERIAR_ExGMAC);
6896         } else if (sc->re_type == MACFG_38) {
6897                 re_eri_write(sc, 0x1bc, 4, 0x0000001f, ERIAR_ExGMAC);
6898                 re_eri_write(sc, 0x1dc, 4, 0x0000003f, ERIAR_ExGMAC);
6899         }
6900         re_reset(sc);
6901
6902 #ifndef __DragonFly__
6903         /*
6904          * Free the TX list buffers.
6905          */
6906         while (sc->re_desc.tx_last_index!=sc->re_desc.tx_cur_index) {
6907                 if (sc->re_desc.re_tx_mtag) {
6908                         bus_dmamap_sync(sc->re_desc.re_tx_mtag,
6909                                         sc->re_desc.re_tx_dmamap[sc->re_desc.tx_last_index],
6910                                         BUS_DMASYNC_POSTWRITE);
6911                         bus_dmamap_unload(sc->re_desc.re_tx_mtag,
6912                                           sc->re_desc.re_tx_dmamap[sc->re_desc.tx_last_index]);
6913                 }
6914
6915                 if (sc->re_desc.tx_buf[sc->re_desc.tx_last_index]!=NULL) {
6916                         m_freem(sc->re_desc.tx_buf[sc->re_desc.tx_last_index]);
6917                         sc->re_desc.tx_buf[sc->re_desc.tx_last_index] = NULL;
6918                 }
6919                 sc->re_desc.tx_last_index = (sc->re_desc.tx_last_index+1)%RE_TX_BUF_NUM;
6920         }
6921
6922         ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
6923
6924         return;
6925 #endif  /* !__DragonFly__ */
6926 }
6927
6928 #ifndef __DragonFly__
6929 /*
6930  * Main transmit routine.
6931  */
6932 static void re_start(struct ifnet *ifp)         /* Transmit Packet*/
6933 {
6934         struct re_softc         *sc;
6935         struct mbuf             *m_head = NULL;
6936
6937         sc = ifp->if_softc;     /* Paste to ifp in function re_attach(dev) */
6938
6939         RE_LOCK(sc);
6940
6941         /*      RE_LOCK_ASSERT(sc);*/
6942
6943         if ((sc->driver_detach == 1) || (sc->rx_fifo_overflow != 0)) {
6944                 RE_UNLOCK(sc);
6945                 return;
6946         }
6947
6948         while (1) {
6949                 int fs = 1, ls = 0, TxLen = 0, PktLen;
6950                 struct mbuf *ptr;
6951                 uint32_t  opts1 =0;
6952                 uint32_t  opts2 =0;
6953                 IFQ_DRV_DEQUEUE(&ifp->if_snd, m_head);  /* Remove(get) data from system transmit queue */
6954                 if (m_head == NULL) {
6955                         break;
6956                 }
6957
6958                 if (sc->re_coalesce_tx_pkt) {
6959                         if (re_encap(sc, m_head)) {
6960                                 IFQ_DRV_PREPEND(&ifp->if_snd, m_head);
6961                                 ifp->if_drv_flags |= IFF_DRV_OACTIVE;
6962                                 break;
6963                         }
6964
6965                         m_head = sc->re_desc.tx_buf[sc->re_desc.tx_cur_index];
6966                 }
6967
6968                 if (CountMbufNum(m_head) > CountFreeTxDescNum(sc->re_desc)) {   /* No enough descriptor */
6969                         IFQ_DRV_PREPEND(&ifp->if_snd, m_head);
6970                         ifp->if_drv_flags |= IFF_DRV_OACTIVE;
6971                         break;
6972                 }
6973
6974                 if (ifp->if_bpf) {              /* If there's a BPF listener, bounce a copy of this frame to him. */
6975                         //printf("If there's a BPF listener, bounce a copy of this frame to him. \n");
6976
6977                         /*#if OS_VER < VERSION(5, 1)*/
6978 #if OS_VER < VERSION(4,9)
6979                         bpf_mtap(ifp, m_head);
6980 #else
6981                         bpf_mtap(ifp->if_bpf, m_head);
6982 #endif
6983                 }
6984
6985                 //hw checksum
6986                 if (ifp->if_capenable & IFCAP_TXCSUM) {
6987                         if ((m_head->m_pkthdr.csum_flags & RE_CSUM_FEATURES) !=0)       {
6988                                 if (!(sc->re_if_flags & RL_FLAG_DESCV2)) {
6989                                         opts1 |= RL_IPV4CS1;
6990                                         if ((m_head->m_pkthdr.csum_flags & CSUM_TCP)!=0)
6991                                                 opts1 |=RL_TCPCS1;
6992                                         if ((m_head->m_pkthdr.csum_flags & CSUM_UDP)!=0)
6993                                                 opts1 |=RL_UDPCS1;
6994                                 } else {
6995                                         opts2 |=  RL_IPV4CS;
6996                                         if ((m_head->m_pkthdr.csum_flags & CSUM_TCP)!=0)
6997                                                 opts2 |= RL_TCPCS;
6998                                         else if ((m_head->m_pkthdr.csum_flags & CSUM_UDP)!=0)
6999                                                 opts2 |= RL_UDPCS;
7000                                 }
7001                         }
7002                 }
7003
7004                 //vlan
7005                 if (m_head->m_flags & M_VLANTAG)
7006                         opts2 |= bswap16(m_head->m_pkthdr.ether_vtag) | RL_TDESC_VLANCTL_TAG;
7007                 ptr = m_head;
7008                 PktLen = ptr->m_pkthdr.len;
7009 #ifdef _DEBUG_
7010                 printf("PktLen=%d",PktLen);
7011 #endif
7012                 while (ptr!=NULL) {
7013                         if (ptr->m_len >0) {
7014 #ifdef _DEBUG_
7015                                 printf(", len=%d T=%d F=%d",ptr->m_len,ptr->m_type,ptr->m_flags);
7016 #endif
7017                                 TxLen += ptr->m_len;
7018                                 if (TxLen >= PktLen) {
7019                                         ls=1;
7020                                         sc->re_desc.tx_buf[sc->re_desc.tx_cur_index] = m_head;
7021                                 } else
7022                                         sc->re_desc.tx_buf[sc->re_desc.tx_cur_index] = NULL;
7023
7024                                 //vlan
7025                                 WritePacket(sc,ptr->m_data,ptr->m_len,fs,ls,opts2,opts1);
7026
7027                                 fs=0;
7028                         }
7029                         ptr = ptr->m_next;
7030                 }
7031 #ifdef _DEBUG_
7032                 printf("\n");
7033 #endif
7034         }
7035 #if OS_VER < VERSION(9,0)
7036         ifp->if_timer = 5;
7037 #endif
7038
7039         RE_UNLOCK(sc);
7040
7041         return;
7042 }
7043
7044 /*
7045  * Encapsulate an mbuf chain in a descriptor by coupling the mbuf data
7046  * pointers to the fragment pointers.
7047  */
7048 static int re_encap(struct re_softc *sc,struct mbuf *m_head)
7049 {
7050         struct mbuf             *m_new = NULL;
7051
7052         m_new = m_defrag(m_head, M_DONTWAIT);
7053
7054         if (m_new == NULL) {
7055                 printf("re%d: no memory for tx list", sc->re_unit);
7056                 return (1);
7057         }
7058         m_head = m_new;
7059
7060         /* Pad frames to at least 60 bytes. */
7061         if (m_head->m_pkthdr.len < RE_MIN_FRAMELEN) {   /* Case length < 60 bytes */
7062                 /*
7063                  * Make security concious people happy: zero out the
7064                  * bytes in the pad area, since we don't know what
7065                  * this mbuf cluster buffer's previous user might
7066                  * have left in it.
7067                  */
7068                 bzero(mtod(m_head, char *) + m_head->m_pkthdr.len,
7069                       RE_MIN_FRAMELEN - m_head->m_pkthdr.len);
7070                 m_head->m_pkthdr.len = RE_MIN_FRAMELEN;
7071                 m_head->m_len = m_head->m_pkthdr.len;
7072         }
7073
7074         sc->re_desc.tx_buf[sc->re_desc.tx_cur_index] = m_head;
7075
7076         return(0);
7077 }
7078
7079 static void WritePacket(struct re_softc *sc, caddr_t addr, int len,int fs_flag,int ls_flag, uint32_t opts2,uint32_t opts1)
7080 {
7081         union TxDesc *txptr;
7082
7083         txptr=&(sc->re_desc.tx_desc[sc->re_desc.tx_cur_index]);
7084
7085         txptr->ul[0] &= htole32(0x40000000);
7086         txptr->ul[0] |= htole32(opts1);
7087         txptr->ul[1] = htole32(opts2);
7088
7089         if (fs_flag)
7090                 txptr->ul[0] |= htole32(RL_TDESC_CMD_SOF);
7091         if (ls_flag)
7092                 txptr->ul[0] |= htole32(RL_TDESC_CMD_EOF);
7093         txptr->ul[0] |= htole32(len);
7094         bus_dmamap_load(sc->re_desc.re_tx_mtag,
7095                         sc->re_desc.re_tx_dmamap[sc->re_desc.tx_cur_index],
7096                         addr,
7097                         len,
7098                         re_tx_dma_map_buf, txptr,
7099                         0);
7100         bus_dmamap_sync(sc->re_desc.re_tx_mtag,
7101                         sc->re_desc.re_tx_dmamap[sc->re_desc.tx_cur_index],
7102                         BUS_DMASYNC_PREWRITE);
7103         txptr->ul[0] |= htole32(RL_TDESC_CMD_OWN);
7104
7105         bus_dmamap_sync(sc->re_desc.tx_desc_tag,
7106                         sc->re_desc.tx_desc_dmamap,
7107                         BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
7108
7109         if (ls_flag) {
7110                 CSR_WRITE_1(sc, RE_TPPOLL, RE_NPQ);
7111                 CSR_WRITE_1(sc, RE_TPPOLL, RE_NPQ);
7112         }
7113
7114         sc->re_desc.tx_cur_index = (sc->re_desc.tx_cur_index+1)%RE_TX_BUF_NUM;
7115 }
7116
7117 static int CountFreeTxDescNum(struct re_descriptor desc)
7118 {
7119         int ret=desc.tx_last_index-desc.tx_cur_index;
7120         if (ret<=0)
7121                 ret+=RE_TX_BUF_NUM;
7122         ret--;
7123         return ret;
7124 }
7125
7126 static int CountMbufNum(struct mbuf *m_head)
7127 {
7128         int ret=0;
7129         struct mbuf *ptr = m_head;
7130
7131         while (ptr!=NULL) {
7132                 if (ptr->m_len >0)
7133                         ret++;
7134                 ptr=ptr->m_next;
7135         }
7136
7137         return ret;
7138 }
7139
7140 #ifdef RE_FIXUP_RX
7141 static __inline void re_fixup_rx(struct mbuf *m)
7142 {
7143         int                     i;
7144         uint16_t                *src, *dst;
7145
7146         src = mtod(m, uint16_t *);
7147         dst = src - (RE_ETHER_ALIGN - ETHER_ALIGN) / sizeof *src;
7148
7149         for (i = 0; i < (m->m_len / sizeof(uint16_t) + 1); i++)
7150                 *dst++ = *src++;
7151
7152         m->m_data -= RE_ETHER_ALIGN - ETHER_ALIGN;
7153 }
7154 #endif
7155
7156 /*
7157  * A frame was downloaded to the chip. It's safe for us to clean up
7158  * the list buffers.
7159  */
7160 static void re_txeof(struct re_softc *sc)       /* Transmit OK/ERR handler */
7161 {
7162         union TxDesc *txptr;
7163         struct ifnet            *ifp;
7164         u_int32_t           txstat;
7165
7166         /*      printf("X");*/
7167
7168         ifp = RE_GET_IFNET(sc);
7169
7170 #if OS_VER < VERSION(9,0)
7171         /* Clear the timeout timer. */
7172         ifp->if_timer = 0;
7173 #endif
7174
7175         bus_dmamap_sync(sc->re_desc.tx_desc_tag,
7176                         sc->re_desc.tx_desc_dmamap,
7177                         BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE);
7178
7179         while (sc->re_desc.tx_last_index!=sc->re_desc.tx_cur_index) {
7180                 txptr=&(sc->re_desc.tx_desc[sc->re_desc.tx_last_index]);
7181                 txstat = le32toh(txptr->ul[0]);
7182                 if (txstat & RL_TDESC_STAT_OWN)
7183                         break;
7184 #ifdef _DEBUG_
7185                 printf("**** Tx OK  ****\n");
7186 #endif
7187                 bus_dmamap_sync(sc->re_desc.re_tx_mtag,
7188                                 sc->re_desc.re_tx_dmamap[sc->re_desc.tx_last_index],
7189                                 BUS_DMASYNC_POSTWRITE);
7190                 bus_dmamap_unload(sc->re_desc.re_tx_mtag,
7191                                   sc->re_desc.re_tx_dmamap[sc->re_desc.tx_last_index]);
7192
7193                 if (sc->re_desc.tx_buf[sc->re_desc.tx_last_index]!=NULL) {
7194                         m_freem(sc->re_desc.tx_buf[sc->re_desc.tx_last_index]); /* Free Current MBuf in a Mbuf list*/
7195                         sc->re_desc.tx_buf[sc->re_desc.tx_last_index] = NULL;
7196                 }
7197
7198                 sc->re_desc.tx_last_index = (sc->re_desc.tx_last_index+1)%RE_TX_BUF_NUM;
7199 #if OS_VER < VERSION(11,0)
7200                 if (txstat & (RL_TDESC_STAT_EXCESSCOL|
7201                               RL_TDESC_STAT_COLCNT))
7202                         ifp->if_collisions++;
7203                 if (txstat & RL_TDESC_STAT_TXERRSUM)
7204                         ifp->if_oerrors++;
7205                 else
7206                         ifp->if_opackets++;
7207 #else
7208                 if (txstat & (RL_TDESC_STAT_EXCESSCOL|
7209                               RL_TDESC_STAT_COLCNT))
7210                         if_inc_counter(ifp, IFCOUNTER_COLLISIONS, 1);
7211                 if (txstat & RL_TDESC_STAT_TXERRSUM)
7212                         if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
7213                 else
7214                         if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1);
7215 #endif
7216                 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
7217         }
7218
7219         return;
7220 }
7221
7222 /*
7223  * A frame has been uploaded: pass the resulting mbuf chain up to
7224  * the higher level protocols.
7225  *
7226  * You know there's something wrong with a PCI bus-master chip design
7227  * when you have to use m_devget().
7228  *
7229  * The receive operation is badly documented in the datasheet, so I'll
7230  * attempt to document it here. The driver provides a buffer area and
7231  * places its base address in the RX buffer start address register.
7232  * The chip then begins copying frames into the RX buffer. Each frame
7233  * is preceeded by a 32-bit RX status word which specifies the length
7234  * of the frame and certain other status bits. Each frame (starting with
7235  * the status word) is also 32-bit aligned. The frame length is in the
7236  * first 16 bits of the status word; the lower 15 bits correspond with
7237  * the 'rx status register' mentioned in the datasheet.
7238  *
7239  * Note: to make the Alpha happy, the frame payload needs to be aligned
7240  * on a 32-bit boundary. To achieve this, we cheat a bit by copying from
7241  * the ring buffer starting at an address two bytes before the actual
7242  * data location. We can then shave off the first two bytes using m_adj().
7243  * The reason we do this is because m_devget() doesn't let us specify an
7244  * offset into the mbuf storage space, so we have to artificially create
7245  * one. The ring is allocated in such a way that there are a few unused
7246  * bytes of space preceecing it so that it will be safe for us to do the
7247  * 2-byte backstep even if reading from the ring at offset 0.
7248  */
7249 static void re_rxeof(sc)        /* Receive Data OK/ERR handler */
7250 struct re_softc         *sc;
7251 {
7252         struct ether_header     *eh;
7253         struct mbuf             *m;
7254         struct ifnet            *ifp;
7255         union RxDesc *rxptr;
7256         int bError;
7257         struct mbuf *buf;
7258         int size;
7259         int maxpkt = RE_RX_BUF_NUM;
7260
7261         u_int32_t opts2,opts1;
7262
7263         /*              RE_LOCK_ASSERT(sc);*/
7264
7265         ifp = RE_GET_IFNET(sc);
7266
7267         bus_dmamap_sync(sc->re_desc.rx_desc_tag,
7268                         sc->re_desc.rx_desc_dmamap,
7269                         BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE);
7270
7271         rxptr=&(sc->re_desc.rx_desc[sc->re_desc.rx_cur_index]);
7272         while ((rxptr->ul[0]&htole32(RL_RDESC_STAT_OWN))==0) {  /* Receive OK */
7273                 bError = 0;
7274
7275                 opts1 = le32toh(rxptr->ul[0]);
7276
7277                 /* Check if this packet is received correctly*/
7278                 if (opts1&0x200000) {   /*Check RES bit*/
7279                         bError=1;
7280 #if OS_VER < VERSION(11,0)
7281                         ifp->if_ierrors++;
7282 #else
7283                         if_inc_counter(ifp, IFCOUNTER_IERRORS, 1);
7284 #endif
7285                         goto update_desc;
7286                 }
7287                 opts2 = le32toh(rxptr->ul[1]);
7288
7289                 //buf = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR); /* Alloc a new mbuf */
7290
7291                 if (sc->re_rx_mbuf_sz <= MCLBYTES)
7292                         size = MCLBYTES;
7293                 else if (sc->re_rx_mbuf_sz <= MJUMPAGESIZE)
7294                         size = MJUMPAGESIZE;
7295                 else
7296                         size = MJUM9BYTES;
7297
7298                 buf = m_getjcl(M_DONTWAIT, MT_DATA, M_PKTHDR, size);
7299                 if (buf==NULL) {
7300                         bError=1;
7301 #if OS_VER < VERSION(11,0)
7302                         ifp->if_iqdrops++;
7303 #else
7304                         if_inc_counter(ifp, IFCOUNTER_IQDROPS, 1);
7305 #endif
7306                         goto update_desc;
7307                 }
7308
7309                 buf->m_len = buf->m_pkthdr.len = size;
7310 #ifdef RE_FIXUP_RX
7311                 /*
7312                  * This is part of an evil trick to deal with non-x86 platforms.
7313                  * The RealTek chip requires RX buffers to be aligned on 64-bit
7314                  * boundaries, but that will hose non-x86 machines. To get around
7315                  * this, we leave some empty space at the start of each buffer
7316                  * and for non-x86 hosts, we copy the buffer back six bytes
7317                  * to achieve word alignment. This is slightly more efficient
7318                  * than allocating a new buffer, copying the contents, and
7319                  * discarding the old buffer.
7320                  */
7321                 m_adj(buf, RE_ETHER_ALIGN);
7322 #endif
7323
7324                 bus_dmamap_sync(sc->re_desc.re_rx_mtag,
7325                                 sc->re_desc.re_rx_dmamap[sc->re_desc.rx_cur_index],
7326                                 BUS_DMASYNC_POSTREAD);
7327                 bus_dmamap_unload(sc->re_desc.re_rx_mtag,
7328                                   sc->re_desc.re_rx_dmamap[sc->re_desc.rx_cur_index]);
7329
7330                 m = sc->re_desc.rx_buf[sc->re_desc.rx_cur_index];
7331                 sc->re_desc.rx_buf[sc->re_desc.rx_cur_index] = buf;
7332                 m->m_pkthdr.len = m->m_len = (opts1&RL_RDESC_STAT_GFRAGLEN)-ETHER_CRC_LEN;
7333                 m->m_pkthdr.rcvif = ifp;
7334
7335 #ifdef RE_FIXUP_RX
7336                 re_fixup_rx(m);
7337 #endif
7338
7339                 //vlan
7340                 if (opts2 & RL_RDESC_VLANCTL_TAG) {
7341                         m->m_pkthdr.ether_vtag =
7342                                 bswap16((opts2 & RL_RDESC_VLANCTL_DATA));
7343                         m->m_flags |= M_VLANTAG;
7344                 }
7345                 if (ifp->if_capenable & IFCAP_RXCSUM) {
7346                         if (!(sc->re_if_flags & RL_FLAG_DESCV2)) {
7347                                 if (opts1 & RL_ProtoIP)
7348                                         m->m_pkthdr.csum_flags |=  CSUM_IP_CHECKED;
7349                                 if (!(opts1 & RL_IPF))
7350                                         m->m_pkthdr.csum_flags |= CSUM_IP_VALID;
7351                                 if ((((opts1 & RL_ProtoIP)==(1<<17)) && !(opts1 & RL_TCPF))   || (((opts1 & RL_ProtoIP)==(1<<18)) && !(opts1 & RL_UDPF))) {
7352                                         m->m_pkthdr.csum_flags |= CSUM_DATA_VALID|CSUM_PSEUDO_HDR;
7353                                         m->m_pkthdr.csum_data = 0xffff;
7354                                 }
7355                         } else {
7356                                 if ((opts1 & RL_ProtoIP) && (opts2 & RL_V4F))
7357                                         m->m_pkthdr.csum_flags |=  CSUM_IP_CHECKED;
7358                                 if (!(opts1 & RL_IPF) && (opts2 & RL_V4F))
7359                                         m->m_pkthdr.csum_flags |= CSUM_IP_VALID;
7360                                 if (((opts1 & RL_TCPT) && !(opts2 & RL_TCPF)) || ((opts1 & RL_UDPT) && !(opts2 & RL_UDPF))) {
7361                                         m->m_pkthdr.csum_flags |= CSUM_DATA_VALID|CSUM_PSEUDO_HDR;
7362                                         m->m_pkthdr.csum_data = 0xffff;
7363                                 }
7364                         }
7365                 }
7366
7367                 eh = mtod(m, struct ether_header *);
7368 #if OS_VER < VERSION(11,0)
7369                 ifp->if_ipackets++;
7370 #else
7371                 if_inc_counter(ifp, IFCOUNTER_IPACKETS, 1);
7372 #endif
7373 #ifdef _DEBUG_
7374                 printf("Rcv Packet, Len=%d \n", m->m_len);
7375 #endif
7376
7377                 RE_UNLOCK(sc);
7378
7379                 /*#if OS_VER < VERSION(5, 1)*/
7380 #if OS_VER < VERSION(4,9)
7381                 /* Remove header from mbuf and pass it on. */
7382                 m_adj(m, sizeof(struct ether_header));
7383                 ether_input(ifp, eh, m);
7384 #else
7385                 (*ifp->if_input)(ifp, m);
7386 #endif
7387                 RE_LOCK(sc);
7388
7389 update_desc:
7390                 rxptr->ul[0]&=htole32(0x40000000);      /* keep EOR bit */
7391                 rxptr->ul[1]=0;
7392
7393                 rxptr->ul[0] |= htole32(sc->re_rx_desc_buf_sz);
7394                 if (!bError) {
7395                         bus_dmamap_load(sc->re_desc.re_rx_mtag,
7396                                         sc->re_desc.re_rx_dmamap[sc->re_desc.rx_cur_index],
7397                                         sc->re_desc.rx_buf[sc->re_desc.rx_cur_index]->m_data,
7398                                         sc->re_rx_desc_buf_sz,
7399                                         re_rx_dma_map_buf, rxptr,
7400                                         0);
7401                         bus_dmamap_sync(sc->re_desc.re_rx_mtag,
7402                                         sc->re_desc.re_rx_dmamap[sc->re_desc.rx_cur_index],
7403                                         BUS_DMASYNC_PREREAD);
7404                 }
7405                 rxptr->ul[0] |= htole32(RL_RDESC_CMD_OWN);
7406                 sc->re_desc.rx_cur_index = (sc->re_desc.rx_cur_index+1)%RE_RX_BUF_NUM;
7407                 rxptr=&sc->re_desc.rx_desc[sc->re_desc.rx_cur_index];
7408
7409                 maxpkt--;
7410                 if (maxpkt==0)
7411                         break;
7412         }
7413
7414         bus_dmamap_sync(sc->re_desc.rx_desc_tag,
7415                         sc->re_desc.rx_desc_dmamap,
7416                         BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
7417
7418         return;
7419 }
7420
7421 #if OS_VER < VERSION(7,0)
7422 static void re_intr(void *arg)          /* Interrupt Handler */
7423 #else
7424 static int re_intr(void *arg)   /* Interrupt Handler */
7425 #endif //OS_VER < VERSION(7,0)
7426 {
7427         struct re_softc         *sc;
7428
7429         sc = arg;
7430
7431         if ((sc->re_if_flags & (RL_FLAG_MSI | RL_FLAG_MSIX)) == 0) {
7432                 if ((CSR_READ_2(sc, RE_ISR) & RE_INTRS) == 0) {
7433 #if OS_VER < VERSION(7,0)
7434                         return;
7435 #else
7436                         return (FILTER_STRAY);
7437 #endif
7438                 }
7439         }
7440
7441         /* Disable interrupts. */
7442         CSR_WRITE_2(sc, RE_IMR, 0x0000);
7443
7444 #if OS_VER < VERSION(7,0)
7445         re_int_task(arg, 0);
7446 #else //OS_VER < VERSION(7,0)
7447 #if OS_VER < VERSION(11,0)
7448         taskqueue_enqueue_fast(taskqueue_fast, &sc->re_inttask);
7449 #else ////OS_VER < VERSION(11,0)
7450         taskqueue_enqueue(taskqueue_fast, &sc->re_inttask);
7451 #endif //OS_VER < VERSION(11,0)
7452         return (FILTER_HANDLED);
7453 #endif //OS_VER < VERSION(7,0)
7454 }
7455
7456 static void re_int_task(void *arg, int npending)
7457 {
7458         struct re_softc         *sc;
7459         struct ifnet            *ifp;
7460         u_int16_t               status;
7461
7462         sc = arg;
7463
7464         RE_LOCK(sc);
7465
7466         ifp = RE_GET_IFNET(sc);
7467
7468         status = CSR_READ_2(sc, RE_ISR);
7469
7470         if (status) {
7471                 CSR_WRITE_2(sc, RE_ISR, status & 0xffbf);
7472         }
7473
7474         if (sc->suspended ||
7475             (ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) {
7476                 RE_UNLOCK(sc);
7477                 return;
7478         }
7479
7480         re_rxeof(sc);
7481
7482         if (sc->re_type == MACFG_21) {
7483                 if (status & RE_ISR_FIFO_OFLOW) {
7484                         sc->rx_fifo_overflow = 1;
7485                         CSR_WRITE_2(sc, 0x00e2, 0x0000);
7486                         CSR_WRITE_4(sc, 0x0048, 0x4000);
7487                         CSR_WRITE_4(sc, 0x0058, 0x4000);
7488                 } else {
7489                         sc->rx_fifo_overflow = 0;
7490                         CSR_WRITE_4(sc,RE_CPCR, 0x51512082);
7491                 }
7492
7493                 if (status & RE_ISR_PCS_TIMEOUT) {
7494                         if ((status & RE_ISR_FIFO_OFLOW) &&
7495                             (!(status & (RE_ISR_RX_OK | RE_ISR_TX_OK | RE_ISR_RX_OVERRUN)))) {
7496                                 re_reset(sc);
7497                                 re_init(sc);
7498                                 sc->rx_fifo_overflow = 0;
7499                                 CSR_WRITE_2(sc, RE_ISR, RE_ISR_FIFO_OFLOW);
7500                         }
7501                 }
7502         }
7503
7504         re_txeof(sc);
7505
7506         if (status & RE_ISR_SYSTEM_ERR) {
7507                 re_reset(sc);
7508                 re_init(sc);
7509         }
7510
7511         switch(sc->re_type) {
7512         case MACFG_21:
7513         case MACFG_22:
7514         case MACFG_23:
7515         case MACFG_24:
7516                 CSR_WRITE_1(sc, RE_TPPOLL, RE_NPQ);
7517                 break;
7518
7519         default:
7520                 break;
7521         }
7522
7523         RE_UNLOCK(sc);
7524
7525         if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd))
7526                 re_start(ifp);
7527
7528 #if OS_VER>=VERSION(7,0)
7529         if (CSR_READ_2(sc, RE_ISR) & RE_INTRS) {
7530 #if OS_VER < VERSION(11,0)
7531                 taskqueue_enqueue_fast(taskqueue_fast, &sc->re_inttask);
7532 #else ////OS_VER < VERSION(11,0)
7533                 taskqueue_enqueue(taskqueue_fast, &sc->re_inttask);
7534 #endif //OS_VER < VERSION(11,0)
7535                 return;
7536         }
7537 #endif //OS_VER>=VERSION(7,0)
7538
7539         /* Re-enable interrupts. */
7540         CSR_WRITE_2(sc, RE_IMR, RE_INTRS);
7541 }
7542 #endif  /* !__DragonFly__ */
7543
7544 static void re_set_multicast_reg(struct re_softc *sc, u_int32_t mask0, u_int32_t mask4)
7545 {
7546         u_int8_t  enable_cfg_reg_write = 0;
7547
7548         if (sc->re_type == MACFG_5 || sc->re_type == MACFG_6)
7549                 enable_cfg_reg_write = 1;
7550
7551         if (enable_cfg_reg_write)
7552                 re_enable_cfg9346_write(sc);
7553         CSR_WRITE_4(sc, RE_MAR0, mask0);
7554         CSR_WRITE_4(sc, RE_MAR4, mask4);
7555         if (enable_cfg_reg_write)
7556                 re_disable_cfg9346_write(sc);
7557
7558         return;
7559 }
7560
7561 #ifndef __DragonFly__
7562 static void re_set_rx_packet_filter_in_sleep_state(struct re_softc *sc)
7563 {
7564         struct ifnet            *ifp;
7565         u_int32_t               rxfilt;
7566
7567         ifp = RE_GET_IFNET(sc);
7568
7569         rxfilt = CSR_READ_4(sc, RE_RXCFG);
7570
7571         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);
7572         rxfilt |= (RE_RXCFG_RX_INDIV | RE_RXCFG_RX_MULTI | RE_RXCFG_RX_BROAD);
7573
7574         CSR_WRITE_4(sc, RE_RXCFG, rxfilt);
7575
7576         re_set_multicast_reg(sc, 0xFFFFFFFF, 0xFFFFFFFF);
7577
7578         return;
7579 }
7580 #endif  /* !__DragonFly__ */
7581
7582 static void re_set_rx_packet_filter(struct re_softc *sc)
7583 {
7584         struct ifnet            *ifp;
7585         u_int32_t               rxfilt;
7586
7587         ifp = RE_GET_IFNET(sc);
7588
7589         rxfilt = CSR_READ_4(sc, RE_RXCFG);
7590
7591         rxfilt |= RE_RXCFG_RX_INDIV;
7592
7593         if (ifp->if_flags & (IFF_MULTICAST | IFF_ALLMULTI | IFF_PROMISC)) {
7594                 rxfilt |= (RE_RXCFG_RX_ALLPHYS | RE_RXCFG_RX_MULTI);
7595         } else {
7596                 rxfilt &= ~(RE_RXCFG_RX_MULTI);
7597         }
7598
7599         if (ifp->if_flags & IFF_PROMISC) {
7600                 rxfilt |= (RE_RXCFG_RX_ALLPHYS | RE_RXCFG_RX_RUNT | RE_RXCFG_RX_ERRPKT);
7601         } else {
7602                 rxfilt &= ~(RE_RXCFG_RX_ALLPHYS | RE_RXCFG_RX_RUNT | RE_RXCFG_RX_ERRPKT);
7603         }
7604
7605         if (ifp->if_flags & (IFF_BROADCAST | IFF_PROMISC)) {
7606                 rxfilt |= RE_RXCFG_RX_BROAD;
7607         } else {
7608                 rxfilt &= ~RE_RXCFG_RX_BROAD;
7609         }
7610
7611         CSR_WRITE_4(sc, RE_RXCFG, rxfilt);
7612
7613         re_setmulti(sc);
7614
7615         return;
7616 }
7617
7618 /*
7619  * Program the 64-bit multicast hash filter.
7620  */
7621 static void re_setmulti(struct re_softc *sc)
7622 {
7623         struct ifnet            *ifp;
7624         int                     h = 0;
7625         u_int32_t               hashes[2] = { 0, 0 };
7626         struct ifmultiaddr      *ifma;
7627         u_int32_t               rxfilt;
7628         int                     mcnt = 0;
7629
7630         ifp = RE_GET_IFNET(sc);
7631
7632         rxfilt = CSR_READ_4(sc, RE_RXCFG);
7633
7634         if (ifp->if_flags & IFF_ALLMULTI || ifp->if_flags & IFF_PROMISC) {
7635                 rxfilt |= RE_RXCFG_RX_MULTI;
7636                 CSR_WRITE_4(sc, RE_RXCFG, rxfilt);
7637                 re_set_multicast_reg(sc, 0xFFFFFFFF, 0xFFFFFFFF);
7638
7639                 return;
7640         }
7641
7642 #ifndef __DragonFly__
7643         /* now program new ones */
7644 #if OS_VER > VERSION(6,0)
7645         IF_ADDR_LOCK(ifp);
7646 #endif
7647 #if OS_VER < VERSION(4,9)
7648         for (ifma = ifp->if_multiaddrs.lh_first; ifma != NULL;
7649              ifma = ifma->ifma_link.le_next)
7650 #else
7651         TAILQ_FOREACH(ifma,&ifp->if_multiaddrs,ifma_link)
7652 #endif
7653 #else   /* __DragonFly__ */
7654         TAILQ_FOREACH(ifma,&ifp->if_multiaddrs,ifma_link)
7655 #endif  /* !__DragonFly__ */
7656         {
7657                 if (ifma->ifma_addr->sa_family != AF_LINK)
7658                         continue;
7659                 h = ether_crc32_be(LLADDR((struct sockaddr_dl *)
7660                                           ifma->ifma_addr), ETHER_ADDR_LEN) >> 26;
7661                 if (h < 32)
7662                         hashes[0] |= (1 << h);
7663                 else
7664                         hashes[1] |= (1 << (h - 32));
7665                 mcnt++;
7666         }
7667 #ifndef __DragonFly__
7668 #if OS_VER > VERSION(6,0)
7669         IF_ADDR_UNLOCK(ifp);
7670 #endif
7671 #endif  /* !__DragonFly__ */
7672
7673         if (mcnt) {
7674                 if ((sc->re_if_flags & RL_FLAG_PCIE) != 0) {
7675                         h = bswap32(hashes[0]);
7676                         hashes[0] = bswap32(hashes[1]);
7677                         hashes[1] = h;
7678                 }
7679                 rxfilt |= RE_RXCFG_RX_MULTI;
7680         } else
7681                 rxfilt &= ~RE_RXCFG_RX_MULTI;
7682
7683         CSR_WRITE_4(sc, RE_RXCFG, rxfilt);
7684         re_set_multicast_reg(sc, hashes[0], hashes[1]);
7685
7686         return;
7687 }
7688
7689 #ifndef __DragonFly__
7690 static int re_ioctl(ifp, command, data)
7691 struct ifnet            *ifp;
7692 u_long                  command;
7693 caddr_t                 data;
7694 {
7695         struct re_softc         *sc = ifp->if_softc;
7696         struct ifreq            *ifr = (struct ifreq *) data;
7697         /*int                   s;*/
7698         int                     error = 0;
7699         int mask, reinit;
7700         /*s = splimp();*/
7701
7702         switch(command) {
7703         case SIOCSIFADDR:
7704         case SIOCGIFADDR:
7705                 error = ether_ioctl(ifp, command, data);
7706
7707                 break;
7708         case SIOCSIFMTU:
7709
7710                 //printf("before mtu =%d\n",(int)ifp->if_mtu);
7711                 if (ifr->ifr_mtu > sc->max_jumbo_frame_size)
7712                         error = EINVAL;
7713                 else {
7714                         ifp->if_mtu = ifr->ifr_mtu;
7715
7716                         //if running
7717                         if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
7718                                 //printf("set mtu when running\n");
7719
7720                                 RE_LOCK(sc);
7721                                 re_stop(sc);
7722
7723                                 re_release_buf(sc);
7724                                 set_rxbufsize(sc);
7725                                 error =re_alloc_buf(sc);
7726
7727                                 if (error == 0) {
7728                                         re_init(sc);
7729                                 }
7730                                 RE_UNLOCK(sc);
7731
7732                         } else {
7733                                 //if not running
7734                                 RE_LOCK(sc);
7735                                 re_release_buf(sc);
7736                                 set_rxbufsize(sc);
7737                                 error =re_alloc_buf(sc);
7738                                 if (error == 0) {
7739                                         /* Init descriptors. */
7740                                         re_var_init(sc);
7741                                 }
7742                                 RE_UNLOCK(sc);
7743                         }
7744
7745                 }
7746                 //      printf("after mtu =%d\n",(int)ifp->if_mtu);
7747                 break;
7748         case SIOCSIFFLAGS:
7749                 RE_LOCK(sc);
7750                 if (ifp->if_flags & IFF_UP) {
7751                         re_init(sc);
7752                 } else if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
7753                         re_stop(sc);
7754                 }
7755                 error = 0;
7756                 RE_UNLOCK(sc);
7757                 break;
7758         case SIOCADDMULTI:
7759         case SIOCDELMULTI:
7760                 RE_LOCK(sc);
7761                 re_set_rx_packet_filter(sc);
7762                 RE_UNLOCK(sc);
7763                 error = 0;
7764                 break;
7765         case SIOCGIFMEDIA:
7766         case SIOCSIFMEDIA:
7767                 error = ifmedia_ioctl(ifp, ifr, &sc->media, command);
7768                 break;
7769         case SIOCSIFCAP:
7770
7771
7772                 mask = ifr->ifr_reqcap ^ ifp->if_capenable;
7773                 reinit = 0;
7774
7775                 if ((mask & IFCAP_TXCSUM) != 0 && (ifp->if_capabilities & IFCAP_TXCSUM) != 0) {
7776                         ifp->if_capenable ^= IFCAP_TXCSUM;
7777                         if ((ifp->if_capenable & IFCAP_TXCSUM) != 0)  {
7778                                 if ((sc->re_type == MACFG_24) || (sc->re_type == MACFG_24) || (sc->re_type == MACFG_26))
7779                                         ifp->if_hwassist |= CSUM_TCP | CSUM_UDP;
7780                                 else
7781                                         ifp->if_hwassist |= RE_CSUM_FEATURES;
7782                         } else
7783                                 ifp->if_hwassist &= ~RE_CSUM_FEATURES;
7784                         reinit = 1;
7785                 }
7786
7787                 if ((mask & IFCAP_RXCSUM) != 0 &&
7788                     (ifp->if_capabilities & IFCAP_RXCSUM) != 0) {
7789                         ifp->if_capenable ^= IFCAP_RXCSUM;
7790                         reinit = 1;
7791                 }
7792
7793                 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))) {
7794                         if (ifp->if_capenable & IFCAP_TXCSUM)
7795                                 sc->re_tx_cstag = 1;
7796                         else
7797                                 sc->re_tx_cstag = 0;
7798
7799                         if (ifp->if_capenable & IFCAP_RXCSUM)
7800                                 sc->re_rx_cstag = 1;
7801                         else
7802                                 sc->re_rx_cstag = 0;
7803                 }
7804                 if ((mask & IFCAP_VLAN_HWTAGGING) != 0 &&
7805                     (ifp->if_capabilities & IFCAP_VLAN_HWTAGGING) != 0) {
7806                         ifp->if_capenable ^= IFCAP_VLAN_HWTAGGING;
7807                         /* TSO over VLAN requires VLAN hardware tagging. */
7808                         //if ((ifp->if_capenable & IFCAP_VLAN_HWTAGGING) == 0)
7809                         //      ifp->if_capenable &= ~IFCAP_VLAN_HWTSO;
7810                         reinit = 1;
7811                 }
7812
7813                 if ((mask & IFCAP_WOL) != 0 &&
7814                     (ifp->if_capabilities & IFCAP_WOL) != 0) {
7815                         if ((mask & IFCAP_WOL_UCAST) != 0)
7816                                 ifp->if_capenable ^= IFCAP_WOL_UCAST;
7817                         if ((mask & IFCAP_WOL_MCAST) != 0)
7818                                 ifp->if_capenable ^= IFCAP_WOL_MCAST;
7819                         if ((mask & IFCAP_WOL_MAGIC) != 0)
7820                                 ifp->if_capenable ^= IFCAP_WOL_MAGIC;
7821                 }
7822                 if (reinit && ifp->if_drv_flags & IFF_DRV_RUNNING) {
7823                         ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
7824                         re_init(sc);
7825                 }
7826                 VLAN_CAPABILITIES(ifp);
7827                 break;
7828         default:
7829                 error = EINVAL;
7830                 break;
7831         }
7832
7833         /*(void)splx(s);*/
7834
7835         return(error);
7836 }
7837 #endif  /* !__DragonFly__ */
7838
7839 static void re_link_on_patch(struct re_softc *sc)
7840 {
7841         struct ifnet            *ifp;
7842
7843         ifp = RE_GET_IFNET(sc);
7844
7845         if (sc->re_type == MACFG_50 || sc->re_type == MACFG_51 || sc->re_type == MACFG_52) {
7846                 if (CSR_READ_1(sc, RE_PHY_STATUS) & RL_PHY_STATUS_1000MF) {
7847                         re_eri_write(sc, 0x1bc, 4, 0x00000011, ERIAR_ExGMAC);
7848                         re_eri_write(sc, 0x1dc, 4, 0x0000001f, ERIAR_ExGMAC);
7849                 } else if (CSR_READ_1(sc, RE_PHY_STATUS) & RL_PHY_STATUS_100M) {
7850                         re_eri_write(sc, 0x1bc, 4, 0x0000001f, ERIAR_ExGMAC);
7851                         re_eri_write(sc, 0x1dc, 4, 0x0000001f, ERIAR_ExGMAC);
7852                 } else {
7853                         re_eri_write(sc, 0x1bc, 4, 0x0000001f, ERIAR_ExGMAC);
7854                         re_eri_write(sc, 0x1dc, 4, 0x0000002d, ERIAR_ExGMAC);
7855                 }
7856         } else if ((sc->re_type == MACFG_38 || sc->re_type == MACFG_39) && (ifp->if_flags & IFF_UP)) {
7857                 if (sc->re_type == MACFG_38 && (CSR_READ_1(sc, RE_PHY_STATUS) & RL_PHY_STATUS_10M)) {
7858                         CSR_WRITE_4(sc, RE_RXCFG, CSR_READ_4(sc, RE_RXCFG) | RE_RXCFG_RX_ALLPHYS);
7859                 } else if (sc->re_type == MACFG_39) {
7860                         if (CSR_READ_1(sc, RE_PHY_STATUS) & RL_PHY_STATUS_1000MF) {
7861                                 re_eri_write(sc, 0x1bc, 4, 0x00000011, ERIAR_ExGMAC);
7862                                 re_eri_write(sc, 0x1dc, 4, 0x00000005, ERIAR_ExGMAC);
7863                         } else if (CSR_READ_1(sc, RE_PHY_STATUS) & RL_PHY_STATUS_100M) {
7864                                 re_eri_write(sc, 0x1bc, 4, 0x0000001f, ERIAR_ExGMAC);
7865                                 re_eri_write(sc, 0x1dc, 4, 0x00000005, ERIAR_ExGMAC);
7866                         } else {
7867                                 re_eri_write(sc, 0x1bc, 4, 0x0000001f, ERIAR_ExGMAC);
7868                                 re_eri_write(sc, 0x1dc, 4, 0x0000003f, ERIAR_ExGMAC);
7869                         }
7870                 }
7871         } else if ((sc->re_type == MACFG_36 || sc->re_type == MACFG_37) && eee_enable ==1) {
7872                 /*Full -Duplex  mode*/
7873                 if (CSR_READ_1(sc, RE_PHY_STATUS) & RL_PHY_STATUS_FULL_DUP) {
7874                         MP_WritePhyUshort(sc, 0x1F, 0x0006);
7875                         MP_WritePhyUshort(sc, 0x00, 0x5a30);
7876                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
7877                         if (CSR_READ_1(sc, RE_PHY_STATUS) & (RL_PHY_STATUS_10M | RL_PHY_STATUS_100M))
7878                                 CSR_WRITE_4(sc, RE_TXCFG, (CSR_READ_4(sc, RE_TXCFG) & ~BIT_19) | BIT_25);
7879
7880                 } else {
7881                         MP_WritePhyUshort(sc, 0x1F, 0x0006);
7882                         MP_WritePhyUshort(sc, 0x00, 0x5a00);
7883                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
7884                         if (CSR_READ_1(sc, RE_PHY_STATUS) & (RL_PHY_STATUS_10M | RL_PHY_STATUS_100M))
7885                                 CSR_WRITE_4(sc, RE_TXCFG, (CSR_READ_4(sc, RE_TXCFG) & ~BIT_19) | RE_TXCFG_IFG);
7886                 }
7887         } else if ((sc->re_type == MACFG_56 || sc->re_type == MACFG_57 ||
7888                     sc->re_type == MACFG_58 || sc->re_type == MACFG_59 ||
7889                     sc->re_type == MACFG_60 || sc->re_type == MACFG_61 ||
7890                     sc->re_type == MACFG_62 || sc->re_type == MACFG_67 ||
7891                     sc->re_type == MACFG_68 || sc->re_type == MACFG_69 ||
7892                     sc->re_type == MACFG_70 || sc->re_type == MACFG_71) &&
7893                    (ifp->if_flags & IFF_UP)) {
7894                 if (CSR_READ_1(sc, RE_PHY_STATUS) & RL_PHY_STATUS_FULL_DUP)
7895                         CSR_WRITE_4(sc, RE_TXCFG, (CSR_READ_4(sc, RE_TXCFG) | (BIT_24 | BIT_25)) & ~BIT_19);
7896                 else
7897                         CSR_WRITE_4(sc, RE_TXCFG, (CSR_READ_4(sc, RE_TXCFG) | BIT_25) & ~(BIT_19 | BIT_24));
7898         }
7899
7900         if (sc->re_type == MACFG_56 || sc->re_type == MACFG_57 ||
7901             sc->re_type == MACFG_61 || sc->re_type == MACFG_62) {
7902                 /*half mode*/
7903                 if (!(CSR_READ_1(sc, RE_PHY_STATUS) & RL_PHY_STATUS_FULL_DUP)) {
7904                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
7905                         MP_WritePhyUshort(sc, MII_ANAR, MP_ReadPhyUshort(sc, MII_ANAR)&~(ANAR_PAUSE_SYM |ANAR_PAUSE_ASYM));
7906                 }
7907         }
7908
7909         if ((sc->re_type == MACFG_70 || sc->re_type == MACFG_71) &&
7910             (CSR_READ_1(sc, RE_PHY_STATUS) & RL_PHY_STATUS_10M)) {
7911                 uint32_t Data32;
7912
7913                 Data32 = re_eri_read(sc, 0x1D0, 1, ERIAR_ExGMAC);
7914                 Data32 |= BIT_1;
7915                 re_eri_write(sc, 0x1D0, 1, Data32, ERIAR_ExGMAC);
7916         }
7917
7918 #ifndef __DragonFly__
7919         re_init_unlock(sc);
7920 #endif
7921 }
7922
7923 #ifndef __DragonFly__
7924 static void re_link_down_patch(struct re_softc *sc)
7925 {
7926         struct ifnet            *ifp;
7927
7928         ifp = RE_GET_IFNET(sc);
7929
7930         re_txeof(sc);
7931         re_rxeof(sc);
7932         re_stop(sc);
7933
7934         re_ifmedia_upd(ifp);
7935 }
7936
7937 /*
7938  * Check Link Status.
7939  */
7940 static void re_check_link_status(struct re_softc *sc)
7941 {
7942         u_int8_t        link_state;
7943         struct ifnet            *ifp;
7944
7945         ifp = RE_GET_IFNET(sc);
7946
7947         if (re_link_ok(sc)) {
7948                 link_state = LINK_STATE_UP;
7949         } else {
7950                 link_state = LINK_STATE_DOWN;
7951         }
7952
7953         if (link_state != sc->link_state) {
7954                 sc->link_state = link_state;
7955                 if (link_state == LINK_STATE_UP) {
7956                         re_link_on_patch(sc);
7957                         re_link_state_change(ifp, LINK_STATE_UP);
7958                 } else {
7959                         re_link_state_change(ifp, LINK_STATE_DOWN);
7960                         re_link_down_patch(sc);
7961                 }
7962         }
7963 }
7964
7965 static void re_init_timer(struct re_softc *sc)
7966 {
7967 #ifdef RE_USE_NEW_CALLOUT_FUN
7968         callout_init(&sc->re_stat_ch, CALLOUT_MPSAFE);
7969 #else
7970         callout_handle_init(&sc->re_stat_ch);
7971 #endif
7972 }
7973
7974 static void re_stop_timer(struct re_softc *sc)
7975 {
7976 #ifdef RE_USE_NEW_CALLOUT_FUN
7977         callout_stop(&sc->re_stat_ch);
7978 #else
7979         untimeout(re_tick, sc, sc->re_stat_ch);
7980 #endif
7981 }
7982
7983 static void re_start_timer(struct re_softc *sc)
7984 {
7985 #ifdef RE_USE_NEW_CALLOUT_FUN
7986         callout_reset(&sc->re_stat_ch, hz, re_tick, sc);
7987 #else
7988         re_stop_timer(sc);
7989         sc->re_stat_ch = timeout(re_tick, sc, hz);
7990 #endif
7991 }
7992
7993 static void re_tick(xsc)
7994 void                    *xsc;
7995 {
7996         /*called per second*/
7997         struct re_softc         *sc;
7998         int                     s;
7999
8000         s = splimp();
8001
8002         sc = xsc;
8003         /*mii = device_get_softc(sc->re_miibus);
8004
8005         mii_tick(mii);*/
8006
8007         splx(s);
8008
8009         RE_LOCK(sc);
8010
8011         if (sc->re_link_chg_det == 1) {
8012                 re_check_link_status(sc);
8013                 re_start_timer(sc);
8014         }
8015
8016         RE_UNLOCK(sc);
8017
8018         return;
8019 }
8020
8021 #if OS_VER < VERSION(7,0)
8022 static void re_watchdog(ifp)
8023 struct ifnet            *ifp;
8024 {
8025         struct re_softc         *sc;
8026
8027         sc = ifp->if_softc;
8028
8029         printf("re%d: watchdog timeout\n", sc->re_unit);
8030 #if OS_VER < VERSION(11,0)
8031         ifp->if_oerrors++;
8032 #else
8033         if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
8034 #endif
8035
8036         re_txeof(sc);
8037         re_rxeof(sc);
8038         re_init(sc);
8039
8040         return;
8041 }
8042 #endif
8043 #endif  /* !__DragonFly__ */
8044
8045 /*
8046  * Set media options.
8047  */
8048 static int re_ifmedia_upd(struct ifnet *ifp)
8049 {
8050         struct re_softc *sc = ifp->if_softc;
8051         struct ifmedia  *ifm = &sc->media;
8052         int anar;
8053         int gbcr;
8054
8055         if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER)
8056                 return(EINVAL);
8057
8058         if (sc->re_type == MACFG_68 || sc->re_type == MACFG_69 ||
8059             sc->re_type == MACFG_70 || sc->re_type == MACFG_71) {
8060                 //Disable Giga Lite
8061                 MP_WritePhyUshort(sc, 0x1F, 0x0A42);
8062                 ClearEthPhyBit(sc, 0x14, BIT_9);
8063                 if (sc->re_type == MACFG_70 || sc->re_type == MACFG_71)
8064                         ClearEthPhyBit(sc, 0x14, BIT_7);
8065                 MP_WritePhyUshort(sc, 0x1F, 0x0A40);
8066                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8067         }
8068
8069
8070         switch (IFM_SUBTYPE(ifm->ifm_media)) {
8071         case IFM_AUTO:
8072                 anar = ANAR_TX_FD |
8073                        ANAR_TX |
8074                        ANAR_10_FD |
8075                        ANAR_10;
8076                 gbcr = GTCR_ADV_1000TFDX |
8077                        GTCR_ADV_1000THDX;
8078                 break;
8079         case IFM_1000_SX:
8080 #ifndef __DragonFly__
8081 #if OS_VER < 500000
8082         case IFM_1000_TX:
8083 #else
8084         case IFM_1000_T:
8085 #endif
8086 #else   /* __DragonFly__ */
8087         case IFM_1000_T:
8088 #endif  /* !__DragonFly__ */
8089                 anar = ANAR_TX_FD |
8090                        ANAR_TX |
8091                        ANAR_10_FD |
8092                        ANAR_10;
8093                 gbcr = GTCR_ADV_1000TFDX |
8094                        GTCR_ADV_1000THDX;
8095                 break;
8096         case IFM_100_TX:
8097                 gbcr = MP_ReadPhyUshort(sc, MII_100T2CR) &
8098                        ~(GTCR_ADV_1000TFDX | GTCR_ADV_1000THDX);
8099                 if ((ifm->ifm_media & IFM_GMASK) == IFM_FDX) {
8100                         anar = ANAR_TX_FD |
8101                                ANAR_TX |
8102                                ANAR_10_FD |
8103                                ANAR_10;
8104                 } else {
8105                         anar = ANAR_TX |
8106                                ANAR_10_FD |
8107                                ANAR_10;
8108                 }
8109                 break;
8110         case IFM_10_T:
8111                 gbcr = MP_ReadPhyUshort(sc, MII_100T2CR) &
8112                        ~(GTCR_ADV_1000TFDX | GTCR_ADV_1000THDX);
8113                 if ((ifm->ifm_media & IFM_GMASK) == IFM_FDX) {
8114                         anar = ANAR_10_FD |
8115                                ANAR_10;
8116                 } else {
8117                         anar = ANAR_10;
8118                 }
8119
8120                 if (sc->re_type == MACFG_13) {
8121                         MP_WritePhyUshort(sc, MII_BMCR, 0x8000);
8122                 }
8123
8124                 break;
8125         default:
8126 #ifndef __DragonFly__
8127                 printf("re%d: Unsupported media type\n", sc->re_unit);
8128                 return(0);
8129 #else
8130                 if_printf(ifp, "Unsupported media type\n");
8131                 return (EOPNOTSUPP);
8132 #endif
8133         }
8134
8135         MP_WritePhyUshort(sc, 0x1F, 0x0000);
8136         if (sc->re_device_id==RT_DEVICEID_8169 || sc->re_device_id==RT_DEVICEID_8169SC ||
8137             sc->re_device_id==RT_DEVICEID_8168 || sc->re_device_id==RT_DEVICEID_8161) {
8138                 MP_WritePhyUshort(sc, MII_ANAR, anar | 0x0800 | ANAR_FC);
8139                 MP_WritePhyUshort(sc, MII_100T2CR, gbcr);
8140                 MP_WritePhyUshort(sc, MII_BMCR, BMCR_RESET | BMCR_AUTOEN | BMCR_STARTNEG);
8141         } else if (sc->re_type == MACFG_36) {
8142                 MP_WritePhyUshort(sc, MII_ANAR, anar | 0x0800 | ANAR_FC);
8143                 MP_WritePhyUshort(sc, MII_BMCR, BMCR_RESET | BMCR_AUTOEN | BMCR_STARTNEG);
8144         } else {
8145                 MP_WritePhyUshort(sc, MII_ANAR, anar | 1);
8146                 MP_WritePhyUshort(sc, MII_BMCR, BMCR_AUTOEN | BMCR_STARTNEG);
8147         }
8148
8149         return(0);
8150 }
8151
8152 /*
8153  * Report current media status.
8154  */
8155 static void re_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr)
8156 {
8157         struct re_softc         *sc;
8158
8159         sc = ifp->if_softc;
8160
8161         RE_LOCK(sc);
8162
8163         ifmr->ifm_status = IFM_AVALID;
8164         ifmr->ifm_active = IFM_ETHER;
8165
8166         if (re_link_ok(sc)) {
8167                 unsigned char msr;
8168
8169                 ifmr->ifm_status |= IFM_ACTIVE;
8170
8171                 msr = CSR_READ_1(sc, RE_PHY_STATUS);
8172                 if (msr & RL_PHY_STATUS_FULL_DUP)
8173                         ifmr->ifm_active |= IFM_FDX;
8174                 else
8175                         ifmr->ifm_active |= IFM_HDX;
8176
8177                 if (msr & RL_PHY_STATUS_10M)
8178                         ifmr->ifm_active |= IFM_10_T;
8179                 else if (msr & RL_PHY_STATUS_100M)
8180                         ifmr->ifm_active |= IFM_100_TX;
8181                 else if (msr & RL_PHY_STATUS_1000MF)
8182                         ifmr->ifm_active |= IFM_1000_T;
8183 #ifdef __DragonFly__
8184         } else {
8185                 if (IFM_SUBTYPE(sc->media.ifm_media) == IFM_AUTO)
8186                         ifmr->ifm_active |= IFM_NONE;
8187                 else
8188                         ifmr->ifm_active |= sc->media.ifm_media;
8189 #endif
8190         }
8191
8192         RE_UNLOCK(sc);
8193
8194         return;
8195 }
8196
8197 static int re_enable_EEE(struct re_softc *sc)
8198 {
8199         int ret;
8200         u_int16_t data;
8201         u_int16_t PhyRegValue;
8202         u_int32_t WaitCnt;
8203
8204         ret = 0;
8205         switch (sc->re_type) {
8206         case MACFG_42:
8207         case MACFG_43:
8208                 re_eri_write(sc, 0x1B0, 2, 0xED03, ERIAR_ExGMAC);
8209                 MP_WritePhyUshort(sc, 0x1F, 0x0004);
8210                 if (CSR_READ_1(sc, 0xEF) & 0x02) {
8211                         MP_WritePhyUshort(sc, 0x10, 0x731F);
8212                         MP_WritePhyUshort(sc, 0x19, 0x7630);
8213                 } else {
8214                         MP_WritePhyUshort(sc, 0x10, 0x711F);
8215                         MP_WritePhyUshort(sc, 0x19, 0x7030);
8216                 }
8217                 MP_WritePhyUshort(sc, 0x1A, 0x1506);
8218                 MP_WritePhyUshort(sc, 0x1B, 0x0551);
8219                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8220                 MP_WritePhyUshort(sc, 0x0D, 0x0007);
8221                 MP_WritePhyUshort(sc, 0x0E, 0x003C);
8222                 MP_WritePhyUshort(sc, 0x0D, 0x4007);
8223                 MP_WritePhyUshort(sc, 0x0E, 0x0002);
8224                 MP_WritePhyUshort(sc, 0x0D, 0x0000);
8225
8226                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8227                 MP_WritePhyUshort(sc, 0x0D, 0x0003);
8228                 MP_WritePhyUshort(sc, 0x0E, 0x0015);
8229                 MP_WritePhyUshort(sc, 0x0D, 0x4003);
8230                 MP_WritePhyUshort(sc, 0x0E, 0x0002);
8231                 MP_WritePhyUshort(sc, 0x0D, 0x0000);
8232
8233                 MP_WritePhyUshort(sc, MII_BMCR, BMCR_AUTOEN | BMCR_STARTNEG);
8234                 break;
8235
8236         case MACFG_53:
8237         case MACFG_54:
8238         case MACFG_55:
8239                 re_eri_write(sc, 0x1B0, 2, 0xED03, ERIAR_ExGMAC);
8240                 MP_WritePhyUshort(sc, 0x1F, 0x0004);
8241                 MP_WritePhyUshort(sc, 0x10, 0x731F);
8242                 MP_WritePhyUshort(sc, 0x19, 0x7630);
8243                 MP_WritePhyUshort(sc, 0x1A, 0x1506);
8244                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8245                 MP_WritePhyUshort(sc, 0x0D, 0x0007);
8246                 MP_WritePhyUshort(sc, 0x0E, 0x003C);
8247                 MP_WritePhyUshort(sc, 0x0D, 0x4007);
8248                 MP_WritePhyUshort(sc, 0x0E, 0x0002);
8249                 MP_WritePhyUshort(sc, 0x0D, 0x0000);
8250
8251                 MP_WritePhyUshort(sc, MII_BMCR, BMCR_AUTOEN | BMCR_STARTNEG);
8252                 break;
8253
8254         case MACFG_36:
8255         case MACFG_37:
8256                 MP_WritePhyUshort(sc, 0x1F, 0x0007);
8257                 MP_WritePhyUshort(sc, 0x1E, 0x0020);
8258                 data = MP_ReadPhyUshort(sc, 0x15) | 0x0100;
8259                 MP_WritePhyUshort(sc, 0x15, data);
8260                 MP_WritePhyUshort(sc, 0x1F, 0x0006);
8261                 MP_WritePhyUshort(sc, 0x00, 0x5A30);
8262                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8263                 MP_WritePhyUshort(sc, 0x0D, 0x0007);
8264                 MP_WritePhyUshort(sc, 0x0E, 0x003C);
8265                 MP_WritePhyUshort(sc, 0x0D, 0x4007);
8266                 MP_WritePhyUshort(sc, 0x0E, 0x0006);
8267                 MP_WritePhyUshort(sc, 0x0D, 0x0000);
8268                 if ((CSR_READ_1(sc, RE_CFG4)&RL_CFG4_CUSTOMIZED_LED) && (CSR_READ_1(sc, RE_MACDBG) & BIT_7)) {
8269                         MP_WritePhyUshort(sc, 0x1F, 0x0005);
8270                         MP_WritePhyUshort(sc, 0x05, 0x8AC8);
8271                         MP_WritePhyUshort(sc, 0x06, CSR_READ_1(sc, RE_CUSTOM_LED));
8272                         MP_WritePhyUshort(sc, 0x05, 0x8B82);
8273                         data = MP_ReadPhyUshort(sc, 0x06) | 0x0010;
8274                         MP_WritePhyUshort(sc, 0x05, 0x8B82);
8275                         MP_WritePhyUshort(sc, 0x06, data);
8276                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
8277                 }
8278                 break;
8279
8280         case MACFG_50:
8281         case MACFG_51:
8282         case MACFG_52:
8283                 data = re_eri_read(sc, 0x1B0, 4, ERIAR_ExGMAC) | 0x0003;
8284                 re_eri_write(sc, 0x1B0, 4, data, ERIAR_ExGMAC);
8285                 MP_WritePhyUshort(sc, 0x1F, 0x0007);
8286                 MP_WritePhyUshort(sc, 0x1E, 0x0020);
8287                 data = MP_ReadPhyUshort(sc, 0x15)|0x0100;
8288                 MP_WritePhyUshort(sc, 0x15, data);
8289                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
8290                 MP_WritePhyUshort(sc, 0x05, 0x8B85);
8291                 data = MP_ReadPhyUshort(sc, 0x06)|0x2000;
8292                 MP_WritePhyUshort(sc, 0x06, data);
8293                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8294                 MP_WritePhyUshort(sc, 0x0D, 0x0007);
8295                 MP_WritePhyUshort(sc, 0x0E, 0x003C);
8296                 MP_WritePhyUshort(sc, 0x0D, 0x4007);
8297                 MP_WritePhyUshort(sc, 0x0E, 0x0006);
8298                 MP_WritePhyUshort(sc, 0x1D, 0x0000);
8299                 break;
8300
8301         case MACFG_38:
8302         case MACFG_39:
8303                 data = re_eri_read(sc, 0x1B0, 4, ERIAR_ExGMAC);
8304                 data |= BIT_1 | BIT_0;
8305                 re_eri_write(sc, 0x1B0, 4, data, ERIAR_ExGMAC);
8306                 MP_WritePhyUshort(sc, 0x1F, 0x0004);
8307                 MP_WritePhyUshort(sc, 0x1F, 0x0007);
8308                 MP_WritePhyUshort(sc, 0x1e, 0x0020);
8309                 data = MP_ReadPhyUshort(sc, 0x15);
8310                 data |= BIT_8;
8311                 MP_WritePhyUshort(sc, 0x15, data);
8312                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
8313                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
8314                 MP_WritePhyUshort(sc, 0x05, 0x8B85);
8315                 data = MP_ReadPhyUshort(sc, 0x06);
8316                 data |= BIT_13;
8317                 MP_WritePhyUshort(sc, 0x06, data);
8318                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8319                 MP_WritePhyUshort(sc, 0x0D, 0x0007);
8320                 MP_WritePhyUshort(sc, 0x0E, 0x003C);
8321                 MP_WritePhyUshort(sc, 0x0D, 0x4007);
8322                 MP_WritePhyUshort(sc, 0x0E, 0x0006);
8323                 MP_WritePhyUshort(sc, 0x0D, 0x0000);
8324                 break;
8325
8326         case MACFG_56:
8327         case MACFG_57:
8328         case MACFG_58:
8329         case MACFG_59:
8330         case MACFG_60:
8331         case MACFG_61:
8332         case MACFG_62:
8333         case MACFG_67:
8334         case MACFG_68:
8335         case MACFG_69:
8336         case MACFG_70:
8337         case MACFG_71:
8338                 data = re_eri_read(sc, 0x1B0, 4, ERIAR_ExGMAC);
8339                 data |= BIT_1 | BIT_0;
8340                 re_eri_write(sc, 0x1B0, 4, data, ERIAR_ExGMAC);
8341                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
8342                 data = MP_ReadPhyUshort(sc, 0x11);
8343                 MP_WritePhyUshort(sc, 0x11, data | BIT_4);
8344                 MP_WritePhyUshort(sc, 0x1F, 0x0A5D);
8345                 MP_WritePhyUshort(sc, 0x10, 0x0006);
8346                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8347                 break;
8348
8349         default:
8350                 ret = -EOPNOTSUPP;
8351                 break;
8352         }
8353
8354         switch (sc->re_type) {
8355         case MACFG_68:
8356         case MACFG_69:
8357                 MP_WritePhyUshort(sc, 0x1F, 0x0A4A);
8358                 SetEthPhyBit(sc, 0x11, BIT_9);
8359                 MP_WritePhyUshort(sc, 0x1F, 0x0A42);
8360                 SetEthPhyBit(sc, 0x14, BIT_7);
8361                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8362                 break;
8363         }
8364
8365         /*Advanced EEE*/
8366         switch (sc->re_type) {
8367         case MACFG_58:
8368         case MACFG_59:
8369         case MACFG_60:
8370         case MACFG_68:
8371         case MACFG_69:
8372                 MP_WritePhyUshort(sc, 0x1F, 0x0B82);
8373                 SetEthPhyBit(sc, 0x10, BIT_4);
8374                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8375
8376                 MP_WritePhyUshort(sc, 0x1F, 0x0B80);
8377                 WaitCnt = 0;
8378                 do {
8379                         PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
8380                         PhyRegValue &= 0x0040;
8381                         DELAY(50);
8382                         DELAY(50);
8383                         WaitCnt++;
8384                 } while(PhyRegValue != 0x0040 && WaitCnt <1000);
8385
8386                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8387                 break;
8388         }
8389
8390         switch (sc->re_type) {
8391         case MACFG_59:
8392                 re_eri_write(sc, 0x1EA, 1, 0xFA, ERIAR_ExGMAC);
8393
8394                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
8395                 data = MP_ReadPhyUshort(sc, 0x10);
8396                 if (data & BIT_10) {
8397                         MP_WritePhyUshort(sc, 0x1F, 0x0A42);
8398                         data = MP_ReadPhyUshort(sc, 0x16);
8399                         data &= ~(BIT_1);
8400                         MP_WritePhyUshort(sc, 0x16, data);
8401                 } else {
8402                         MP_WritePhyUshort(sc, 0x1F, 0x0A42);
8403                         data = MP_ReadPhyUshort(sc, 0x16);
8404                         data |= BIT_1;
8405                         MP_WritePhyUshort(sc, 0x16, data);
8406                 }
8407                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8408                 break;
8409         case MACFG_60:
8410                 data = MP_ReadMcuAccessRegWord(sc, 0xE052);
8411                 data |= BIT_0;
8412                 MP_WriteMcuAccessRegWord(sc, 0xE052, data);
8413                 data = MP_ReadMcuAccessRegWord(sc, 0xE056);
8414                 data &= 0xFF0F;
8415                 data |= (BIT_4 | BIT_5 | BIT_6);
8416                 MP_WriteMcuAccessRegWord(sc, 0xE056, data);
8417
8418                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
8419                 data = MP_ReadPhyUshort(sc, 0x10);
8420                 if (data & BIT_10) {
8421                         MP_WritePhyUshort(sc, 0x1F, 0x0A42);
8422                         data = MP_ReadPhyUshort(sc, 0x16);
8423                         data &= ~(BIT_1);
8424                         MP_WritePhyUshort(sc, 0x16, data);
8425                 } else {
8426                         MP_WritePhyUshort(sc, 0x1F, 0x0A42);
8427                         data = MP_ReadPhyUshort(sc, 0x16);
8428                         data |= BIT_1;
8429                         MP_WritePhyUshort(sc, 0x16, data);
8430                 }
8431                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8432                 break;
8433         case MACFG_61:
8434         case MACFG_62:
8435         case MACFG_67:
8436                 OOB_mutex_lock(sc);
8437                 data = MP_ReadMcuAccessRegWord(sc, 0xE052);
8438                 data &= ~BIT_0;
8439                 MP_WriteMcuAccessRegWord(sc, 0xE052, data);
8440                 OOB_mutex_unlock(sc);
8441                 data = MP_ReadMcuAccessRegWord(sc, 0xE056);
8442                 data &= 0xFF0F;
8443                 data |= (BIT_4 | BIT_5 | BIT_6);
8444                 MP_WriteMcuAccessRegWord(sc, 0xE056, data);
8445                 break;
8446         case MACFG_70:
8447         case MACFG_71:
8448                 OOB_mutex_lock(sc);
8449                 data = MP_ReadMcuAccessRegWord(sc, 0xE052);
8450                 data &= ~BIT_0;
8451                 MP_WriteMcuAccessRegWord(sc, 0xE052, data);
8452                 OOB_mutex_unlock(sc);
8453                 data = MP_ReadMcuAccessRegWord(sc, 0xE056);
8454                 data &= 0xFF0F;
8455                 data |= (BIT_4 | BIT_5 | BIT_6);
8456                 MP_WriteMcuAccessRegWord(sc, 0xE056, data);
8457                 MP_WriteMcuAccessRegWord(sc, 0xEA80, 0x0003);
8458                 break;
8459         case MACFG_68:
8460         case MACFG_69:
8461                 data = MP_ReadMcuAccessRegWord(sc, 0xE052);
8462                 data |= BIT_0;
8463                 MP_WriteMcuAccessRegWord(sc, 0xE052, data);
8464
8465                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
8466                 data = MP_ReadPhyUshort(sc, 0x10) | BIT_15;
8467                 MP_WritePhyUshort(sc, 0x10, data);
8468
8469                 MP_WritePhyUshort(sc, 0x1F, 0x0A44);
8470                 data = MP_ReadPhyUshort(sc, 0x11) | BIT_13 | BIT_14;
8471                 data &= ~(BIT_12);
8472                 MP_WritePhyUshort(sc, 0x11, data);
8473                 break;
8474         }
8475
8476         switch (sc->re_type) {
8477         case MACFG_58:
8478         case MACFG_59:
8479         case MACFG_60:
8480         case MACFG_68:
8481         case MACFG_69:
8482                 MP_WritePhyUshort(sc, 0x1F, 0x0B82);
8483                 ClearEthPhyBit(sc, 0x10, BIT_4);
8484                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8485                 break;
8486         }
8487
8488         return ret;
8489 }
8490
8491 static int re_disable_EEE(struct re_softc *sc)
8492 {
8493         int ret;
8494         u_int16_t data;
8495         u_int16_t PhyRegValue;
8496         u_int32_t WaitCnt;
8497
8498         ret = 0;
8499         switch (sc->re_type) {
8500         case MACFG_42:
8501         case MACFG_43:
8502                 re_eri_write(sc, 0x1B0, 2, 0, ERIAR_ExGMAC);
8503                 MP_WritePhyUshort(sc, 0x1F, 0x0004);
8504                 MP_WritePhyUshort(sc, 0x10, 0x401F);
8505                 MP_WritePhyUshort(sc, 0x19, 0x7030);
8506
8507                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8508                 MP_WritePhyUshort(sc, 0x0D, 0x0007);
8509                 MP_WritePhyUshort(sc, 0x0E, 0x003C);
8510                 MP_WritePhyUshort(sc, 0x0D, 0x4007);
8511                 MP_WritePhyUshort(sc, 0x0E, 0x0000);
8512                 MP_WritePhyUshort(sc, 0x0D, 0x0000);
8513
8514                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8515                 MP_WritePhyUshort(sc, 0x0D, 0x0003);
8516                 MP_WritePhyUshort(sc, 0x0E, 0x0015);
8517                 MP_WritePhyUshort(sc, 0x0D, 0x4003);
8518                 MP_WritePhyUshort(sc, 0x0E, 0x0000);
8519                 MP_WritePhyUshort(sc, 0x0D, 0x0000);
8520
8521                 MP_WritePhyUshort(sc, MII_BMCR, BMCR_AUTOEN | BMCR_STARTNEG);
8522                 break;
8523
8524         case MACFG_53:
8525                 re_eri_write(sc, 0x1B0, 2, 0, ERIAR_ExGMAC);
8526                 MP_WritePhyUshort(sc, 0x1F, 0x0004);
8527                 MP_WritePhyUshort(sc, 0x10, 0x401F);
8528                 MP_WritePhyUshort(sc, 0x19, 0x7030);
8529
8530                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8531                 MP_WritePhyUshort(sc, 0x0D, 0x0007);
8532                 MP_WritePhyUshort(sc, 0x0E, 0x003C);
8533                 MP_WritePhyUshort(sc, 0x0D, 0x4007);
8534                 MP_WritePhyUshort(sc, 0x0E, 0x0000);
8535                 MP_WritePhyUshort(sc, 0x0D, 0x0000);
8536
8537                 MP_WritePhyUshort(sc, MII_BMCR, BMCR_AUTOEN | BMCR_STARTNEG);
8538                 break;
8539
8540         case MACFG_54:
8541         case MACFG_55:
8542                 re_eri_write(sc, 0x1B0, 2, 0, ERIAR_ExGMAC);
8543                 MP_WritePhyUshort(sc, 0x1F, 0x0004);
8544                 MP_WritePhyUshort(sc, 0x10, 0xC07F);
8545                 MP_WritePhyUshort(sc, 0x19, 0x7030);
8546                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8547
8548                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8549                 MP_WritePhyUshort(sc, 0x0D, 0x0007);
8550                 MP_WritePhyUshort(sc, 0x0E, 0x003C);
8551                 MP_WritePhyUshort(sc, 0x0D, 0x4007);
8552                 MP_WritePhyUshort(sc, 0x0E, 0x0000);
8553                 MP_WritePhyUshort(sc, 0x0D, 0x0000);
8554
8555                 MP_WritePhyUshort(sc, MII_BMCR, BMCR_AUTOEN | BMCR_STARTNEG);
8556                 break;
8557
8558         case MACFG_36:
8559         case MACFG_37:
8560                 MP_WritePhyUshort(sc, 0x1F, 0x0007);
8561                 MP_WritePhyUshort(sc, 0x1E, 0x0020);
8562                 data = MP_ReadPhyUshort(sc, 0x15) & ~0x0100;
8563                 MP_WritePhyUshort(sc, 0x15, data);
8564                 MP_WritePhyUshort(sc, 0x1F, 0x0006);
8565                 MP_WritePhyUshort(sc, 0x00, 0x5A00);
8566                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8567                 MP_WritePhyUshort(sc, 0x0D, 0x0007);
8568                 MP_WritePhyUshort(sc, 0x0E, 0x003C);
8569                 MP_WritePhyUshort(sc, 0x0D, 0x4007);
8570                 MP_WritePhyUshort(sc, 0x0E, 0x0000);
8571                 MP_WritePhyUshort(sc, 0x0D, 0x0000);
8572                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8573                 if (CSR_READ_1(sc, RE_CFG4) & RL_CFG4_CUSTOMIZED_LED) {
8574                         MP_WritePhyUshort(sc, 0x1F, 0x0005);
8575                         MP_WritePhyUshort(sc, 0x05, 0x8B82);
8576                         data = MP_ReadPhyUshort(sc, 0x06) & ~0x0010;
8577                         MP_WritePhyUshort(sc, 0x05, 0x8B82);
8578                         MP_WritePhyUshort(sc, 0x06, data);
8579                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
8580                 }
8581                 break;
8582
8583         case MACFG_50:
8584         case MACFG_51:
8585         case MACFG_52:
8586                 data = re_eri_read(sc, 0x1B0, 4, ERIAR_ExGMAC)& ~0x0003;
8587                 re_eri_write(sc, 0x1B0, 4, data, ERIAR_ExGMAC);
8588                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
8589                 MP_WritePhyUshort(sc, 0x05, 0x8B85);
8590                 data = MP_ReadPhyUshort(sc, 0x06) & ~0x2000;
8591                 MP_WritePhyUshort(sc, 0x06, data);
8592                 MP_WritePhyUshort(sc, 0x1F, 0x0007);
8593                 MP_WritePhyUshort(sc, 0x1E, 0x0020);
8594                 data = MP_ReadPhyUshort(sc, 0x15) & ~0x0100;
8595                 MP_WritePhyUshort(sc, 0x15, data);
8596                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8597                 MP_WritePhyUshort(sc, 0x0D, 0x0007);
8598                 MP_WritePhyUshort(sc, 0x0E, 0x003C);
8599                 MP_WritePhyUshort(sc, 0x0D, 0x4007);
8600                 MP_WritePhyUshort(sc, 0x0E, 0x0000);
8601                 MP_WritePhyUshort(sc, 0x0D, 0x0000);
8602                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8603                 break;
8604
8605         case MACFG_38:
8606         case MACFG_39:
8607                 data = re_eri_read(sc, 0x1B0, 4, ERIAR_ExGMAC);
8608                 data &= ~(BIT_1 | BIT_0);
8609                 re_eri_write(sc, 0x1B0, 4, data, ERIAR_ExGMAC);
8610                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
8611                 MP_WritePhyUshort(sc, 0x05, 0x8B85);
8612                 data = MP_ReadPhyUshort(sc, 0x06);
8613                 data &= ~BIT_13;
8614                 MP_WritePhyUshort(sc, 0x06, data);
8615                 MP_WritePhyUshort(sc, 0x1F, 0x0004);
8616                 MP_WritePhyUshort(sc, 0x1F, 0x0007);
8617                 MP_WritePhyUshort(sc, 0x1e, 0x0020);
8618                 data = MP_ReadPhyUshort(sc, 0x15);
8619                 data &= ~BIT_8;
8620                 MP_WritePhyUshort(sc, 0x15, data);
8621                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
8622                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8623                 MP_WritePhyUshort(sc, 0x0D, 0x0007);
8624                 MP_WritePhyUshort(sc, 0x0E, 0x003C);
8625                 MP_WritePhyUshort(sc, 0x0D, 0x4007);
8626                 MP_WritePhyUshort(sc, 0x0E, 0x0000);
8627                 MP_WritePhyUshort(sc, 0x0D, 0x0000);
8628                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8629                 break;
8630
8631         case MACFG_56:
8632         case MACFG_57:
8633         case MACFG_58:
8634         case MACFG_59:
8635         case MACFG_60:
8636         case MACFG_61:
8637         case MACFG_62:
8638         case MACFG_67:
8639         case MACFG_68:
8640         case MACFG_69:
8641         case MACFG_70:
8642         case MACFG_71:
8643                 data = re_eri_read(sc, 0x1B0, 4, ERIAR_ExGMAC);
8644                 data &= ~(BIT_1 | BIT_0);
8645                 re_eri_write(sc, 0x1B0, 4, data, ERIAR_ExGMAC);
8646                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
8647                 data = MP_ReadPhyUshort(sc, 0x11);
8648                 MP_WritePhyUshort(sc, 0x11, data & ~BIT_4);
8649                 MP_WritePhyUshort(sc, 0x1F, 0x0A5D);
8650                 MP_WritePhyUshort(sc, 0x10, 0x0000);
8651                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8652                 break;
8653
8654         default:
8655                 ret = -EOPNOTSUPP;
8656                 break;
8657         }
8658
8659         switch (sc->re_type) {
8660         case MACFG_68:
8661         case MACFG_69:
8662                 MP_WritePhyUshort(sc, 0x1F, 0x0A42);
8663                 ClearEthPhyBit(sc, 0x14, BIT_7);
8664                 MP_WritePhyUshort(sc, 0x1F, 0x0A4A);
8665                 ClearEthPhyBit(sc, 0x11, BIT_9);
8666                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8667                 break;
8668         }
8669
8670         /*Advanced EEE*/
8671         switch (sc->re_type) {
8672         case MACFG_58:
8673         case MACFG_59:
8674         case MACFG_60:
8675         case MACFG_68:
8676         case MACFG_69:
8677                 MP_WritePhyUshort(sc, 0x1F, 0x0B82);
8678                 SetEthPhyBit(sc, 0x10, BIT_4);
8679                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8680
8681                 MP_WritePhyUshort(sc, 0x1F, 0x0B80);
8682                 WaitCnt = 0;
8683                 do {
8684                         PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
8685                         PhyRegValue &= 0x0040;
8686                         DELAY(50);
8687                         DELAY(50);
8688                         WaitCnt++;
8689                 } while(PhyRegValue != 0x0040 && WaitCnt <1000);
8690
8691                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8692                 break;
8693         }
8694
8695         switch (sc->re_type) {
8696         case MACFG_59:
8697                 re_eri_write(sc, 0x1EA, 1, 0x00, ERIAR_ExGMAC);
8698
8699                 MP_WritePhyUshort(sc, 0x1F, 0x0A42);
8700                 data = MP_ReadPhyUshort(sc, 0x16);
8701                 data &= ~(BIT_1);
8702                 MP_WritePhyUshort(sc, 0x16, data);
8703                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8704                 break;
8705         case MACFG_60:
8706                 data = MP_ReadMcuAccessRegWord(sc, 0xE052);
8707                 data &= ~(BIT_0);
8708                 MP_WriteMcuAccessRegWord(sc, 0xE052, data);
8709
8710                 MP_WritePhyUshort(sc, 0x1F, 0x0A42);
8711                 data = MP_ReadPhyUshort(sc, 0x16);
8712                 data &= ~(BIT_1);
8713                 MP_WritePhyUshort(sc, 0x16, data);
8714                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8715                 break;
8716         case MACFG_61:
8717         case MACFG_62:
8718         case MACFG_67:
8719         case MACFG_70:
8720         case MACFG_71:
8721                 data = MP_ReadMcuAccessRegWord(sc, 0xE052);
8722                 data &= ~(BIT_0);
8723                 MP_WriteMcuAccessRegWord(sc, 0xE052, data);
8724                 break;
8725         case MACFG_68:
8726         case MACFG_69:
8727                 data = MP_ReadMcuAccessRegWord(sc, 0xE052);
8728                 data &= ~(BIT_0);
8729                 MP_WriteMcuAccessRegWord(sc, 0xE052, data);
8730
8731                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
8732                 data = MP_ReadPhyUshort(sc, 0x10) & ~(BIT_15);
8733                 MP_WritePhyUshort(sc, 0x10, data);
8734
8735                 MP_WritePhyUshort(sc, 0x1F, 0x0A44);
8736                 data = MP_ReadPhyUshort(sc, 0x11) & ~(BIT_12 | BIT_13 | BIT_14);
8737                 MP_WritePhyUshort(sc, 0x11, data);
8738                 break;
8739         }
8740
8741         switch (sc->re_type) {
8742         case MACFG_58:
8743         case MACFG_59:
8744         case MACFG_60:
8745         case MACFG_68:
8746         case MACFG_69:
8747                 MP_WritePhyUshort(sc, 0x1F, 0x0B82);
8748                 ClearEthPhyBit(sc, 0x10, BIT_4);
8749                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8750                 break;
8751         }
8752
8753         return ret;
8754 }
8755
8756 static int re_phy_ram_code_check(struct re_softc *sc)
8757 {
8758         u_int16_t PhyRegValue;
8759         u_int32_t WaitCnt;
8760         int retval = TRUE;
8761
8762         switch(sc->re_type) {
8763         case MACFG_56:
8764                 MP_WritePhyUshort(sc, 0x1f, 0x0A40);
8765                 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
8766                 PhyRegValue &= ~(BIT_11);
8767                 MP_WritePhyUshort(sc, 0x10, PhyRegValue);
8768
8769
8770                 MP_WritePhyUshort(sc, 0x1f, 0x0A00);
8771                 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
8772                 PhyRegValue &= ~(BIT_12 | BIT_13 | BIT_14 | BIT_15);
8773                 MP_WritePhyUshort(sc, 0x10, PhyRegValue);
8774
8775                 MP_WritePhyUshort(sc, 0x1f, 0x0A43);
8776                 MP_WritePhyUshort(sc, 0x13, 0x8010);
8777                 PhyRegValue = MP_ReadPhyUshort(sc, 0x14);
8778                 PhyRegValue &= ~(BIT_11);
8779                 MP_WritePhyUshort(sc, 0x14, PhyRegValue);
8780
8781                 MP_WritePhyUshort(sc, 0x1f, 0x0B82);
8782                 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
8783                 PhyRegValue |= BIT_4;
8784                 MP_WritePhyUshort(sc, 0x10, PhyRegValue);
8785
8786                 MP_WritePhyUshort(sc, 0x1f, 0x0B80);
8787                 WaitCnt = 0;
8788                 do {
8789                         PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
8790                         PhyRegValue &= 0x0040;
8791                         DELAY(50);
8792                         DELAY(50);
8793                         WaitCnt++;
8794                 } while(PhyRegValue != 0x0040 && WaitCnt <1000);
8795
8796                 if (WaitCnt == 1000) {
8797                         retval = FALSE;
8798                 }
8799
8800                 MP_WritePhyUshort(sc, 0x1f, 0x0A40);
8801                 MP_WritePhyUshort(sc, 0x10, 0x0140);
8802
8803                 MP_WritePhyUshort(sc, 0x1f, 0x0A4A);
8804                 PhyRegValue = MP_ReadPhyUshort(sc, 0x13);
8805                 PhyRegValue &= ~(BIT_6);
8806                 PhyRegValue |= (BIT_7);
8807                 MP_WritePhyUshort(sc, 0x13, PhyRegValue);
8808
8809                 MP_WritePhyUshort(sc, 0x1f, 0x0A44);
8810                 PhyRegValue = MP_ReadPhyUshort(sc, 0x14);
8811                 PhyRegValue |= (BIT_2);
8812                 MP_WritePhyUshort(sc, 0x14, PhyRegValue);
8813
8814                 MP_WritePhyUshort(sc, 0x1f, 0x0A50);
8815                 PhyRegValue = MP_ReadPhyUshort(sc, 0x11);
8816                 PhyRegValue |= (BIT_11|BIT_12);
8817                 MP_WritePhyUshort(sc, 0x11, PhyRegValue);
8818
8819                 MP_WritePhyUshort(sc, 0x1f, 0x0B82);
8820                 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
8821                 PhyRegValue &= ~(BIT_4);
8822                 MP_WritePhyUshort(sc, 0x10, PhyRegValue);
8823
8824                 MP_WritePhyUshort(sc, 0x1f, 0x0A22);
8825                 WaitCnt = 0;
8826                 do {
8827                         PhyRegValue = MP_ReadPhyUshort(sc, 0x12);
8828                         PhyRegValue &= 0x0010;
8829                         DELAY(50);
8830                         DELAY(50);
8831                         WaitCnt++;
8832                 } while(PhyRegValue != 0x0010 && WaitCnt <1000);
8833
8834                 if (WaitCnt == 1000) {
8835                         retval = FALSE;
8836                 }
8837
8838                 MP_WritePhyUshort(sc, 0x1f, 0x0A40);
8839                 MP_WritePhyUshort(sc, 0x10, 0x1040);
8840
8841                 MP_WritePhyUshort(sc, 0x1f, 0x0A4A);
8842                 PhyRegValue = MP_ReadPhyUshort(sc, 0x13);
8843                 PhyRegValue &= ~(BIT_6|BIT_7);
8844                 MP_WritePhyUshort(sc, 0x13, PhyRegValue);
8845
8846                 MP_WritePhyUshort(sc, 0x1f, 0x0A44);
8847                 PhyRegValue = MP_ReadPhyUshort(sc, 0x14);
8848                 PhyRegValue &= ~(BIT_2);
8849                 MP_WritePhyUshort(sc, 0x14, PhyRegValue);
8850
8851                 MP_WritePhyUshort(sc, 0x1f, 0x0A50);
8852                 PhyRegValue = MP_ReadPhyUshort(sc, 0x11);
8853                 PhyRegValue &= ~(BIT_11|BIT_12);
8854                 MP_WritePhyUshort(sc, 0x11, PhyRegValue);
8855
8856                 MP_WritePhyUshort(sc, 0x1f, 0x0A43);
8857                 MP_WritePhyUshort(sc, 0x13, 0x8010);
8858                 PhyRegValue = MP_ReadPhyUshort(sc, 0x14);
8859                 PhyRegValue |= (BIT_11);
8860                 MP_WritePhyUshort(sc, 0x14, PhyRegValue);
8861
8862                 MP_WritePhyUshort(sc, 0x1f, 0x0B82);
8863                 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
8864                 PhyRegValue |= BIT_4;
8865                 MP_WritePhyUshort(sc, 0x10, PhyRegValue);
8866
8867                 MP_WritePhyUshort(sc, 0x1f, 0x0B80);
8868                 WaitCnt = 0;
8869                 do {
8870                         PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
8871                         PhyRegValue &= 0x0040;
8872                         DELAY(50);
8873                         DELAY(50);
8874                         WaitCnt++;
8875                 } while(PhyRegValue != 0x0040 && WaitCnt <1000);
8876
8877                 if (WaitCnt == 1000) {
8878                         retval = FALSE;
8879                 }
8880
8881                 MP_WritePhyUshort(sc, 0x1f, 0x0A20);
8882                 PhyRegValue = MP_ReadPhyUshort(sc, 0x13);
8883                 if (PhyRegValue & BIT_11) {
8884                         if (PhyRegValue & BIT_10) {
8885                                 retval = FALSE;
8886                         }
8887                 }
8888
8889                 MP_WritePhyUshort(sc, 0x1f, 0x0B82);
8890                 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
8891                 PhyRegValue &= ~(BIT_4);
8892                 MP_WritePhyUshort(sc, 0x10, PhyRegValue);
8893
8894                 //delay 2ms
8895                 DELAY(2000);
8896                 break;
8897         default:
8898                 break;
8899         }
8900
8901         MP_WritePhyUshort(sc, 0x1F, 0x0000);
8902
8903         return retval;
8904 }
8905
8906 static void re_set_phy_ram_code_check_fail_flag(struct re_softc *sc)
8907 {
8908         u_int16_t TmpUshort;
8909
8910         switch(sc->re_type) {
8911         case MACFG_56:
8912                 TmpUshort = MP_ReadMcuAccessRegWord(sc, 0xD3C0);
8913                 TmpUshort |= BIT_0;
8914                 MP_WriteMcuAccessRegWord(sc, 0xD3C0, TmpUshort);
8915                 break;
8916         }
8917 }
8918
8919 static int re_hw_phy_mcu_code_ver_matched(struct re_softc *sc)
8920 {
8921         int ram_code_ver_match = 0;
8922
8923         switch (sc->re_type) {
8924         case MACFG_36:
8925         case MACFG_37:
8926                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
8927                 MP_WritePhyUshort(sc, 0x05, 0x8B60);
8928                 sc->re_hw_ram_code_ver = MP_ReadPhyUshort(sc, 0x06);
8929                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8930                 break;
8931         case MACFG_38:
8932         case MACFG_39:
8933         case MACFG_50:
8934         case MACFG_51:
8935         case MACFG_52:
8936                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
8937                 MP_WritePhyUshort(sc, 0x05, 0x8B30);
8938                 sc->re_hw_ram_code_ver = MP_ReadPhyUshort(sc, 0x06);
8939                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8940                 break;
8941         case MACFG_56:
8942         case MACFG_57:
8943         case MACFG_58:
8944         case MACFG_59:
8945         case MACFG_60:
8946         case MACFG_61:
8947         case MACFG_62:
8948         case MACFG_67:
8949         case MACFG_68:
8950         case MACFG_69:
8951         case MACFG_70:
8952         case MACFG_71:
8953                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
8954                 MP_WritePhyUshort(sc, 0x13, 0x801E);
8955                 sc->re_hw_ram_code_ver = MP_ReadPhyUshort(sc, 0x14);
8956                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8957                 break;
8958         default:
8959                 sc->re_hw_ram_code_ver = ~0;
8960                 break;
8961         }
8962
8963         if (sc->re_hw_ram_code_ver == sc->re_sw_ram_code_ver)
8964                 ram_code_ver_match = 1;
8965
8966         return ram_code_ver_match;
8967 }
8968
8969 static void re_write_hw_phy_mcu_code_ver(struct re_softc *sc)
8970 {
8971         switch (sc->re_type) {
8972         case MACFG_36:
8973         case MACFG_37:
8974                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
8975                 MP_WritePhyUshort(sc, 0x05, 0x8B60);
8976                 MP_WritePhyUshort(sc, 0x06, sc->re_sw_ram_code_ver);
8977                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8978                 sc->re_hw_ram_code_ver = sc->re_sw_ram_code_ver;
8979                 break;
8980         case MACFG_38:
8981         case MACFG_39:
8982         case MACFG_50:
8983         case MACFG_51:
8984         case MACFG_52:
8985                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
8986                 MP_WritePhyUshort(sc, 0x05, 0x8B30);
8987                 MP_WritePhyUshort(sc, 0x06, sc->re_sw_ram_code_ver);
8988                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8989                 sc->re_hw_ram_code_ver = sc->re_sw_ram_code_ver;
8990                 break;
8991         case MACFG_56:
8992         case MACFG_57:
8993         case MACFG_58:
8994         case MACFG_59:
8995         case MACFG_60:
8996         case MACFG_61:
8997         case MACFG_62:
8998         case MACFG_67:
8999         case MACFG_68:
9000         case MACFG_69:
9001         case MACFG_70:
9002         case MACFG_71:
9003                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
9004                 MP_WritePhyUshort(sc, 0x13, 0x801E);
9005                 MP_WritePhyUshort(sc, 0x14, sc->re_sw_ram_code_ver);
9006                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
9007                 sc->re_hw_ram_code_ver = sc->re_sw_ram_code_ver;
9008                 break;
9009         }
9010 }
9011
9012 static void re_set_phy_mcu_8168e_1(struct re_softc *sc)
9013 {
9014         u_int16_t PhyRegValue;
9015         int i;
9016
9017         MP_WritePhyUshort(sc, 0x1f, 0x0000);
9018         MP_WritePhyUshort(sc, 0x00, 0x1800);
9019         MP_WritePhyUshort(sc, 0x1f, 0x0007);
9020         MP_WritePhyUshort(sc, 0x1e, 0x0023);
9021         MP_WritePhyUshort(sc, 0x17, 0x0117);
9022         MP_WritePhyUshort(sc, 0x1f, 0x0007);
9023         MP_WritePhyUshort(sc, 0x1E, 0x002C);
9024         MP_WritePhyUshort(sc, 0x1B, 0x5000);
9025         MP_WritePhyUshort(sc, 0x1f, 0x0000);
9026         MP_WritePhyUshort(sc, 0x16, 0x4104);
9027         for (i=0; i<200; i++) {
9028                 DELAY(100);
9029                 PhyRegValue = MP_ReadPhyUshort(sc, 0x1E);
9030                 PhyRegValue &= 0x03FF;
9031                 if (PhyRegValue== 0x000C)
9032                         break;
9033         }
9034         MP_WritePhyUshort(sc, 0x1f, 0x0005);
9035         for (i=0; i<200; i++) {
9036                 DELAY(100);
9037                 PhyRegValue = MP_ReadPhyUshort(sc, 0x07);
9038                 if ((PhyRegValue&0x0020)==0)
9039                         break;
9040         }
9041         PhyRegValue = MP_ReadPhyUshort(sc, 0x07);
9042         if (PhyRegValue & 0x0020) {
9043                 MP_WritePhyUshort(sc, 0x1f, 0x0007);
9044                 MP_WritePhyUshort(sc, 0x1e, 0x00a1);
9045                 MP_WritePhyUshort(sc, 0x17, 0x1000);
9046                 MP_WritePhyUshort(sc, 0x17, 0x0000);
9047                 MP_WritePhyUshort(sc, 0x17, 0x2000);
9048                 MP_WritePhyUshort(sc, 0x1e, 0x002f);
9049                 MP_WritePhyUshort(sc, 0x18, 0x9bfb);
9050                 MP_WritePhyUshort(sc, 0x1f, 0x0005);
9051                 MP_WritePhyUshort(sc, 0x07, 0x0000);
9052                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
9053         }
9054
9055         MP_WritePhyUshort(sc, 0x1f, 0x0005);
9056         MP_WritePhyUshort(sc, 0x05, 0xfff6);
9057         MP_WritePhyUshort(sc, 0x06, 0x0080);
9058         PhyRegValue = MP_ReadPhyUshort(sc, 0x00);
9059         PhyRegValue &= ~(BIT_7);
9060         MP_WritePhyUshort(sc, 0x00, PhyRegValue);
9061         MP_WritePhyUshort(sc, 0x1f, 0x0002);
9062         PhyRegValue = MP_ReadPhyUshort(sc, 0x08);
9063         PhyRegValue &= ~(BIT_7);
9064         MP_WritePhyUshort(sc, 0x08, PhyRegValue);
9065         MP_WritePhyUshort(sc, 0x1f, 0x0000);
9066         MP_WritePhyUshort(sc, 0x1f, 0x0007);
9067         MP_WritePhyUshort(sc, 0x1e, 0x0023);
9068         MP_WritePhyUshort(sc, 0x16, 0x0306);
9069         MP_WritePhyUshort(sc, 0x16, 0x0307);
9070         MP_WritePhyUshort(sc, 0x15, 0x000e);
9071         MP_WritePhyUshort(sc, 0x19, 0x000a);
9072         MP_WritePhyUshort(sc, 0x15, 0x0010);
9073         MP_WritePhyUshort(sc, 0x19, 0x0008);
9074         MP_WritePhyUshort(sc, 0x15, 0x0018);
9075         MP_WritePhyUshort(sc, 0x19, 0x4801);
9076         MP_WritePhyUshort(sc, 0x15, 0x0019);
9077         MP_WritePhyUshort(sc, 0x19, 0x6801);
9078         MP_WritePhyUshort(sc, 0x15, 0x001a);
9079         MP_WritePhyUshort(sc, 0x19, 0x66a1);
9080         MP_WritePhyUshort(sc, 0x15, 0x001f);
9081         MP_WritePhyUshort(sc, 0x19, 0x0000);
9082         MP_WritePhyUshort(sc, 0x15, 0x0020);
9083         MP_WritePhyUshort(sc, 0x19, 0x0000);
9084         MP_WritePhyUshort(sc, 0x15, 0x0021);
9085         MP_WritePhyUshort(sc, 0x19, 0x0000);
9086         MP_WritePhyUshort(sc, 0x15, 0x0022);
9087         MP_WritePhyUshort(sc, 0x19, 0x0000);
9088         MP_WritePhyUshort(sc, 0x15, 0x0023);
9089         MP_WritePhyUshort(sc, 0x19, 0x0000);
9090         MP_WritePhyUshort(sc, 0x15, 0x0024);
9091         MP_WritePhyUshort(sc, 0x19, 0x0000);
9092         MP_WritePhyUshort(sc, 0x15, 0x0025);
9093         MP_WritePhyUshort(sc, 0x19, 0x64a1);
9094         MP_WritePhyUshort(sc, 0x15, 0x0026);
9095         MP_WritePhyUshort(sc, 0x19, 0x40ea);
9096         MP_WritePhyUshort(sc, 0x15, 0x0027);
9097         MP_WritePhyUshort(sc, 0x19, 0x4503);
9098         MP_WritePhyUshort(sc, 0x15, 0x0028);
9099         MP_WritePhyUshort(sc, 0x19, 0x9f00);
9100         MP_WritePhyUshort(sc, 0x15, 0x0029);
9101         MP_WritePhyUshort(sc, 0x19, 0xa631);
9102         MP_WritePhyUshort(sc, 0x15, 0x002a);
9103         MP_WritePhyUshort(sc, 0x19, 0x9717);
9104         MP_WritePhyUshort(sc, 0x15, 0x002b);
9105         MP_WritePhyUshort(sc, 0x19, 0x302c);
9106         MP_WritePhyUshort(sc, 0x15, 0x002c);
9107         MP_WritePhyUshort(sc, 0x19, 0x4802);
9108         MP_WritePhyUshort(sc, 0x15, 0x002d);
9109         MP_WritePhyUshort(sc, 0x19, 0x58da);
9110         MP_WritePhyUshort(sc, 0x15, 0x002e);
9111         MP_WritePhyUshort(sc, 0x19, 0x400d);
9112         MP_WritePhyUshort(sc, 0x15, 0x002f);
9113         MP_WritePhyUshort(sc, 0x19, 0x4488);
9114         MP_WritePhyUshort(sc, 0x15, 0x0030);
9115         MP_WritePhyUshort(sc, 0x19, 0x9e00);
9116         MP_WritePhyUshort(sc, 0x15, 0x0031);
9117         MP_WritePhyUshort(sc, 0x19, 0x63c8);
9118         MP_WritePhyUshort(sc, 0x15, 0x0032);
9119         MP_WritePhyUshort(sc, 0x19, 0x6481);
9120         MP_WritePhyUshort(sc, 0x15, 0x0033);
9121         MP_WritePhyUshort(sc, 0x19, 0x0000);
9122         MP_WritePhyUshort(sc, 0x15, 0x0034);
9123         MP_WritePhyUshort(sc, 0x19, 0x0000);
9124         MP_WritePhyUshort(sc, 0x15, 0x0035);
9125         MP_WritePhyUshort(sc, 0x19, 0x0000);
9126         MP_WritePhyUshort(sc, 0x15, 0x0036);
9127         MP_WritePhyUshort(sc, 0x19, 0x0000);
9128         MP_WritePhyUshort(sc, 0x15, 0x0037);
9129         MP_WritePhyUshort(sc, 0x19, 0x0000);
9130         MP_WritePhyUshort(sc, 0x15, 0x0038);
9131         MP_WritePhyUshort(sc, 0x19, 0x0000);
9132         MP_WritePhyUshort(sc, 0x15, 0x0039);
9133         MP_WritePhyUshort(sc, 0x19, 0x0000);
9134         MP_WritePhyUshort(sc, 0x15, 0x003a);
9135         MP_WritePhyUshort(sc, 0x19, 0x0000);
9136         MP_WritePhyUshort(sc, 0x15, 0x003b);
9137         MP_WritePhyUshort(sc, 0x19, 0x63e8);
9138         MP_WritePhyUshort(sc, 0x15, 0x003c);
9139         MP_WritePhyUshort(sc, 0x19, 0x7d00);
9140         MP_WritePhyUshort(sc, 0x15, 0x003d);
9141         MP_WritePhyUshort(sc, 0x19, 0x59d4);
9142         MP_WritePhyUshort(sc, 0x15, 0x003e);
9143         MP_WritePhyUshort(sc, 0x19, 0x63f8);
9144         MP_WritePhyUshort(sc, 0x15, 0x0040);
9145         MP_WritePhyUshort(sc, 0x19, 0x64a1);
9146         MP_WritePhyUshort(sc, 0x15, 0x0041);
9147         MP_WritePhyUshort(sc, 0x19, 0x30de);
9148         MP_WritePhyUshort(sc, 0x15, 0x0044);
9149         MP_WritePhyUshort(sc, 0x19, 0x480f);
9150         MP_WritePhyUshort(sc, 0x15, 0x0045);
9151         MP_WritePhyUshort(sc, 0x19, 0x6800);
9152         MP_WritePhyUshort(sc, 0x15, 0x0046);
9153         MP_WritePhyUshort(sc, 0x19, 0x6680);
9154         MP_WritePhyUshort(sc, 0x15, 0x0047);
9155         MP_WritePhyUshort(sc, 0x19, 0x7c10);
9156         MP_WritePhyUshort(sc, 0x15, 0x0048);
9157         MP_WritePhyUshort(sc, 0x19, 0x63c8);
9158         MP_WritePhyUshort(sc, 0x15, 0x0049);
9159         MP_WritePhyUshort(sc, 0x19, 0x0000);
9160         MP_WritePhyUshort(sc, 0x15, 0x004a);
9161         MP_WritePhyUshort(sc, 0x19, 0x0000);
9162         MP_WritePhyUshort(sc, 0x15, 0x004b);
9163         MP_WritePhyUshort(sc, 0x19, 0x0000);
9164         MP_WritePhyUshort(sc, 0x15, 0x004c);
9165         MP_WritePhyUshort(sc, 0x19, 0x0000);
9166         MP_WritePhyUshort(sc, 0x15, 0x004d);
9167         MP_WritePhyUshort(sc, 0x19, 0x0000);
9168         MP_WritePhyUshort(sc, 0x15, 0x004e);
9169         MP_WritePhyUshort(sc, 0x19, 0x0000);
9170         MP_WritePhyUshort(sc, 0x15, 0x004f);
9171         MP_WritePhyUshort(sc, 0x19, 0x40ea);
9172         MP_WritePhyUshort(sc, 0x15, 0x0050);
9173         MP_WritePhyUshort(sc, 0x19, 0x4503);
9174         MP_WritePhyUshort(sc, 0x15, 0x0051);
9175         MP_WritePhyUshort(sc, 0x19, 0x58ca);
9176         MP_WritePhyUshort(sc, 0x15, 0x0052);
9177         MP_WritePhyUshort(sc, 0x19, 0x63c8);
9178         MP_WritePhyUshort(sc, 0x15, 0x0053);
9179         MP_WritePhyUshort(sc, 0x19, 0x63d8);
9180         MP_WritePhyUshort(sc, 0x15, 0x0054);
9181         MP_WritePhyUshort(sc, 0x19, 0x66a0);
9182         MP_WritePhyUshort(sc, 0x15, 0x0055);
9183         MP_WritePhyUshort(sc, 0x19, 0x9f00);
9184         MP_WritePhyUshort(sc, 0x15, 0x0056);
9185         MP_WritePhyUshort(sc, 0x19, 0x3000);
9186         MP_WritePhyUshort(sc, 0x15, 0x006E);
9187         MP_WritePhyUshort(sc, 0x19, 0x9afa);
9188         MP_WritePhyUshort(sc, 0x15, 0x00a1);
9189         MP_WritePhyUshort(sc, 0x19, 0x3044);
9190         MP_WritePhyUshort(sc, 0x15, 0x00ab);
9191         MP_WritePhyUshort(sc, 0x19, 0x5820);
9192         MP_WritePhyUshort(sc, 0x15, 0x00ac);
9193         MP_WritePhyUshort(sc, 0x19, 0x5e04);
9194         MP_WritePhyUshort(sc, 0x15, 0x00ad);
9195         MP_WritePhyUshort(sc, 0x19, 0xb60c);
9196         MP_WritePhyUshort(sc, 0x15, 0x00af);
9197         MP_WritePhyUshort(sc, 0x19, 0x000a);
9198         MP_WritePhyUshort(sc, 0x15, 0x00b2);
9199         MP_WritePhyUshort(sc, 0x19, 0x30b9);
9200         MP_WritePhyUshort(sc, 0x15, 0x00b9);
9201         MP_WritePhyUshort(sc, 0x19, 0x4408);
9202         MP_WritePhyUshort(sc, 0x15, 0x00ba);
9203         MP_WritePhyUshort(sc, 0x19, 0x480b);
9204         MP_WritePhyUshort(sc, 0x15, 0x00bb);
9205         MP_WritePhyUshort(sc, 0x19, 0x5e00);
9206         MP_WritePhyUshort(sc, 0x15, 0x00bc);
9207         MP_WritePhyUshort(sc, 0x19, 0x405f);
9208         MP_WritePhyUshort(sc, 0x15, 0x00bd);
9209         MP_WritePhyUshort(sc, 0x19, 0x4448);
9210         MP_WritePhyUshort(sc, 0x15, 0x00be);
9211         MP_WritePhyUshort(sc, 0x19, 0x4020);
9212         MP_WritePhyUshort(sc, 0x15, 0x00bf);
9213         MP_WritePhyUshort(sc, 0x19, 0x4468);
9214         MP_WritePhyUshort(sc, 0x15, 0x00c0);
9215         MP_WritePhyUshort(sc, 0x19, 0x9c02);
9216         MP_WritePhyUshort(sc, 0x15, 0x00c1);
9217         MP_WritePhyUshort(sc, 0x19, 0x58a0);
9218         MP_WritePhyUshort(sc, 0x15, 0x00c2);
9219         MP_WritePhyUshort(sc, 0x19, 0xb605);
9220         MP_WritePhyUshort(sc, 0x15, 0x00c3);
9221         MP_WritePhyUshort(sc, 0x19, 0xc0d3);
9222         MP_WritePhyUshort(sc, 0x15, 0x00c4);
9223         MP_WritePhyUshort(sc, 0x19, 0x00e6);
9224         MP_WritePhyUshort(sc, 0x15, 0x00c5);
9225         MP_WritePhyUshort(sc, 0x19, 0xdaec);
9226         MP_WritePhyUshort(sc, 0x15, 0x00c6);
9227         MP_WritePhyUshort(sc, 0x19, 0x00fa);
9228         MP_WritePhyUshort(sc, 0x15, 0x00c7);
9229         MP_WritePhyUshort(sc, 0x19, 0x9df9);
9230         MP_WritePhyUshort(sc, 0x15, 0x00c8);
9231         MP_WritePhyUshort(sc, 0x19, 0x307a);
9232         MP_WritePhyUshort(sc, 0x15, 0x0112);
9233         MP_WritePhyUshort(sc, 0x19, 0x6421);
9234         MP_WritePhyUshort(sc, 0x15, 0x0113);
9235         MP_WritePhyUshort(sc, 0x19, 0x7c08);
9236         MP_WritePhyUshort(sc, 0x15, 0x0114);
9237         MP_WritePhyUshort(sc, 0x19, 0x63f0);
9238         MP_WritePhyUshort(sc, 0x15, 0x0115);
9239         MP_WritePhyUshort(sc, 0x19, 0x4003);
9240         MP_WritePhyUshort(sc, 0x15, 0x0116);
9241         MP_WritePhyUshort(sc, 0x19, 0x4418);
9242         MP_WritePhyUshort(sc, 0x15, 0x0117);
9243         MP_WritePhyUshort(sc, 0x19, 0x9b00);
9244         MP_WritePhyUshort(sc, 0x15, 0x0118);
9245         MP_WritePhyUshort(sc, 0x19, 0x6461);
9246         MP_WritePhyUshort(sc, 0x15, 0x0119);
9247         MP_WritePhyUshort(sc, 0x19, 0x64e1);
9248         MP_WritePhyUshort(sc, 0x15, 0x011a);
9249         MP_WritePhyUshort(sc, 0x19, 0x0000);
9250         MP_WritePhyUshort(sc, 0x15, 0x0150);
9251         MP_WritePhyUshort(sc, 0x19, 0x7c80);
9252         MP_WritePhyUshort(sc, 0x15, 0x0151);
9253         MP_WritePhyUshort(sc, 0x19, 0x6461);
9254         MP_WritePhyUshort(sc, 0x15, 0x0152);
9255         MP_WritePhyUshort(sc, 0x19, 0x4003);
9256         MP_WritePhyUshort(sc, 0x15, 0x0153);
9257         MP_WritePhyUshort(sc, 0x19, 0x4540);
9258         MP_WritePhyUshort(sc, 0x15, 0x0154);
9259         MP_WritePhyUshort(sc, 0x19, 0x9f00);
9260         MP_WritePhyUshort(sc, 0x15, 0x0155);
9261         MP_WritePhyUshort(sc, 0x19, 0x9d00);
9262         MP_WritePhyUshort(sc, 0x15, 0x0156);
9263         MP_WritePhyUshort(sc, 0x19, 0x7c40);
9264         MP_WritePhyUshort(sc, 0x15, 0x0157);
9265         MP_WritePhyUshort(sc, 0x19, 0x6421);
9266         MP_WritePhyUshort(sc, 0x15, 0x0158);
9267         MP_WritePhyUshort(sc, 0x19, 0x7c80);
9268         MP_WritePhyUshort(sc, 0x15, 0x0159);
9269         MP_WritePhyUshort(sc, 0x19, 0x64a1);
9270         MP_WritePhyUshort(sc, 0x15, 0x015a);
9271         MP_WritePhyUshort(sc, 0x19, 0x30fe);
9272         MP_WritePhyUshort(sc, 0x15, 0x021e);
9273         MP_WritePhyUshort(sc, 0x19, 0x5410);
9274         MP_WritePhyUshort(sc, 0x15, 0x0225);
9275         MP_WritePhyUshort(sc, 0x19, 0x5400);
9276         MP_WritePhyUshort(sc, 0x15, 0x023D);
9277         MP_WritePhyUshort(sc, 0x19, 0x4050);
9278         MP_WritePhyUshort(sc, 0x15, 0x0295);
9279         MP_WritePhyUshort(sc, 0x19, 0x6c08);
9280         MP_WritePhyUshort(sc, 0x15, 0x02bd);
9281         MP_WritePhyUshort(sc, 0x19, 0xa523);
9282         MP_WritePhyUshort(sc, 0x15, 0x02be);
9283         MP_WritePhyUshort(sc, 0x19, 0x32ca);
9284         MP_WritePhyUshort(sc, 0x15, 0x02ca);
9285         MP_WritePhyUshort(sc, 0x19, 0x48b3);
9286         MP_WritePhyUshort(sc, 0x15, 0x02cb);
9287         MP_WritePhyUshort(sc, 0x19, 0x4020);
9288         MP_WritePhyUshort(sc, 0x15, 0x02cc);
9289         MP_WritePhyUshort(sc, 0x19, 0x4823);
9290         MP_WritePhyUshort(sc, 0x15, 0x02cd);
9291         MP_WritePhyUshort(sc, 0x19, 0x4510);
9292         MP_WritePhyUshort(sc, 0x15, 0x02ce);
9293         MP_WritePhyUshort(sc, 0x19, 0xb63a);
9294         MP_WritePhyUshort(sc, 0x15, 0x02cf);
9295         MP_WritePhyUshort(sc, 0x19, 0x7dc8);
9296         MP_WritePhyUshort(sc, 0x15, 0x02d6);
9297         MP_WritePhyUshort(sc, 0x19, 0x9bf8);
9298         MP_WritePhyUshort(sc, 0x15, 0x02d8);
9299         MP_WritePhyUshort(sc, 0x19, 0x85f6);
9300         MP_WritePhyUshort(sc, 0x15, 0x02d9);
9301         MP_WritePhyUshort(sc, 0x19, 0x32e0);
9302         MP_WritePhyUshort(sc, 0x15, 0x02e0);
9303         MP_WritePhyUshort(sc, 0x19, 0x4834);
9304         MP_WritePhyUshort(sc, 0x15, 0x02e1);
9305         MP_WritePhyUshort(sc, 0x19, 0x6c08);
9306         MP_WritePhyUshort(sc, 0x15, 0x02e2);
9307         MP_WritePhyUshort(sc, 0x19, 0x4020);
9308         MP_WritePhyUshort(sc, 0x15, 0x02e3);
9309         MP_WritePhyUshort(sc, 0x19, 0x4824);
9310         MP_WritePhyUshort(sc, 0x15, 0x02e4);
9311         MP_WritePhyUshort(sc, 0x19, 0x4520);
9312         MP_WritePhyUshort(sc, 0x15, 0x02e5);
9313         MP_WritePhyUshort(sc, 0x19, 0x4008);
9314         MP_WritePhyUshort(sc, 0x15, 0x02e6);
9315         MP_WritePhyUshort(sc, 0x19, 0x4560);
9316         MP_WritePhyUshort(sc, 0x15, 0x02e7);
9317         MP_WritePhyUshort(sc, 0x19, 0x9d04);
9318         MP_WritePhyUshort(sc, 0x15, 0x02e8);
9319         MP_WritePhyUshort(sc, 0x19, 0x48c4);
9320         MP_WritePhyUshort(sc, 0x15, 0x02e9);
9321         MP_WritePhyUshort(sc, 0x19, 0x0000);
9322         MP_WritePhyUshort(sc, 0x15, 0x02ea);
9323         MP_WritePhyUshort(sc, 0x19, 0x4844);
9324         MP_WritePhyUshort(sc, 0x15, 0x02eb);
9325         MP_WritePhyUshort(sc, 0x19, 0x7dc8);
9326         MP_WritePhyUshort(sc, 0x15, 0x02f0);
9327         MP_WritePhyUshort(sc, 0x19, 0x9cf7);
9328         MP_WritePhyUshort(sc, 0x15, 0x02f1);
9329         MP_WritePhyUshort(sc, 0x19, 0xdf94);
9330         MP_WritePhyUshort(sc, 0x15, 0x02f2);
9331         MP_WritePhyUshort(sc, 0x19, 0x0002);
9332         MP_WritePhyUshort(sc, 0x15, 0x02f3);
9333         MP_WritePhyUshort(sc, 0x19, 0x6810);
9334         MP_WritePhyUshort(sc, 0x15, 0x02f4);
9335         MP_WritePhyUshort(sc, 0x19, 0xb614);
9336         MP_WritePhyUshort(sc, 0x15, 0x02f5);
9337         MP_WritePhyUshort(sc, 0x19, 0xc42b);
9338         MP_WritePhyUshort(sc, 0x15, 0x02f6);
9339         MP_WritePhyUshort(sc, 0x19, 0x00d4);
9340         MP_WritePhyUshort(sc, 0x15, 0x02f7);
9341         MP_WritePhyUshort(sc, 0x19, 0xc455);
9342         MP_WritePhyUshort(sc, 0x15, 0x02f8);
9343         MP_WritePhyUshort(sc, 0x19, 0x0093);
9344         MP_WritePhyUshort(sc, 0x15, 0x02f9);
9345         MP_WritePhyUshort(sc, 0x19, 0x92ee);
9346         MP_WritePhyUshort(sc, 0x15, 0x02fa);
9347         MP_WritePhyUshort(sc, 0x19, 0xefed);
9348         MP_WritePhyUshort(sc, 0x15, 0x02fb);
9349         MP_WritePhyUshort(sc, 0x19, 0x3312);
9350         MP_WritePhyUshort(sc, 0x15, 0x0312);
9351         MP_WritePhyUshort(sc, 0x19, 0x49b5);
9352         MP_WritePhyUshort(sc, 0x15, 0x0313);
9353         MP_WritePhyUshort(sc, 0x19, 0x7d00);
9354         MP_WritePhyUshort(sc, 0x15, 0x0314);
9355         MP_WritePhyUshort(sc, 0x19, 0x4d00);
9356         MP_WritePhyUshort(sc, 0x15, 0x0315);
9357         MP_WritePhyUshort(sc, 0x19, 0x6810);
9358         MP_WritePhyUshort(sc, 0x15, 0x031e);
9359         MP_WritePhyUshort(sc, 0x19, 0x404f);
9360         MP_WritePhyUshort(sc, 0x15, 0x031f);
9361         MP_WritePhyUshort(sc, 0x19, 0x44c8);
9362         MP_WritePhyUshort(sc, 0x15, 0x0320);
9363         MP_WritePhyUshort(sc, 0x19, 0xd64f);
9364         MP_WritePhyUshort(sc, 0x15, 0x0321);
9365         MP_WritePhyUshort(sc, 0x19, 0x00e7);
9366         MP_WritePhyUshort(sc, 0x15, 0x0322);
9367         MP_WritePhyUshort(sc, 0x19, 0x7c08);
9368         MP_WritePhyUshort(sc, 0x15, 0x0323);
9369         MP_WritePhyUshort(sc, 0x19, 0x8203);
9370         MP_WritePhyUshort(sc, 0x15, 0x0324);
9371         MP_WritePhyUshort(sc, 0x19, 0x4d48);
9372         MP_WritePhyUshort(sc, 0x15, 0x0325);
9373         MP_WritePhyUshort(sc, 0x19, 0x3327);
9374         MP_WritePhyUshort(sc, 0x15, 0x0326);
9375         MP_WritePhyUshort(sc, 0x19, 0x4d40);
9376         MP_WritePhyUshort(sc, 0x15, 0x0327);
9377         MP_WritePhyUshort(sc, 0x19, 0xc8d7);
9378         MP_WritePhyUshort(sc, 0x15, 0x0328);
9379         MP_WritePhyUshort(sc, 0x19, 0x0003);
9380         MP_WritePhyUshort(sc, 0x15, 0x0329);
9381         MP_WritePhyUshort(sc, 0x19, 0x7c20);
9382         MP_WritePhyUshort(sc, 0x15, 0x032a);
9383         MP_WritePhyUshort(sc, 0x19, 0x4c20);
9384         MP_WritePhyUshort(sc, 0x15, 0x032b);
9385         MP_WritePhyUshort(sc, 0x19, 0xc8ed);
9386         MP_WritePhyUshort(sc, 0x15, 0x032c);
9387         MP_WritePhyUshort(sc, 0x19, 0x00f4);
9388         MP_WritePhyUshort(sc, 0x15, 0x032d);
9389         MP_WritePhyUshort(sc, 0x19, 0x82b3);
9390         MP_WritePhyUshort(sc, 0x15, 0x032e);
9391         MP_WritePhyUshort(sc, 0x19, 0xd11d);
9392         MP_WritePhyUshort(sc, 0x15, 0x032f);
9393         MP_WritePhyUshort(sc, 0x19, 0x00b1);
9394         MP_WritePhyUshort(sc, 0x15, 0x0330);
9395         MP_WritePhyUshort(sc, 0x19, 0xde18);
9396         MP_WritePhyUshort(sc, 0x15, 0x0331);
9397         MP_WritePhyUshort(sc, 0x19, 0x0008);
9398         MP_WritePhyUshort(sc, 0x15, 0x0332);
9399         MP_WritePhyUshort(sc, 0x19, 0x91ee);
9400         MP_WritePhyUshort(sc, 0x15, 0x0333);
9401         MP_WritePhyUshort(sc, 0x19, 0x3339);
9402         MP_WritePhyUshort(sc, 0x15, 0x033a);
9403         MP_WritePhyUshort(sc, 0x19, 0x4064);
9404         MP_WritePhyUshort(sc, 0x15, 0x0340);
9405         MP_WritePhyUshort(sc, 0x19, 0x9e06);
9406         MP_WritePhyUshort(sc, 0x15, 0x0341);
9407         MP_WritePhyUshort(sc, 0x19, 0x7c08);
9408         MP_WritePhyUshort(sc, 0x15, 0x0342);
9409         MP_WritePhyUshort(sc, 0x19, 0x8203);
9410         MP_WritePhyUshort(sc, 0x15, 0x0343);
9411         MP_WritePhyUshort(sc, 0x19, 0x4d48);
9412         MP_WritePhyUshort(sc, 0x15, 0x0344);
9413         MP_WritePhyUshort(sc, 0x19, 0x3346);
9414         MP_WritePhyUshort(sc, 0x15, 0x0345);
9415         MP_WritePhyUshort(sc, 0x19, 0x4d40);
9416         MP_WritePhyUshort(sc, 0x15, 0x0346);
9417         MP_WritePhyUshort(sc, 0x19, 0xd11d);
9418         MP_WritePhyUshort(sc, 0x15, 0x0347);
9419         MP_WritePhyUshort(sc, 0x19, 0x0099);
9420         MP_WritePhyUshort(sc, 0x15, 0x0348);
9421         MP_WritePhyUshort(sc, 0x19, 0xbb17);
9422         MP_WritePhyUshort(sc, 0x15, 0x0349);
9423         MP_WritePhyUshort(sc, 0x19, 0x8102);
9424         MP_WritePhyUshort(sc, 0x15, 0x034a);
9425         MP_WritePhyUshort(sc, 0x19, 0x334d);
9426         MP_WritePhyUshort(sc, 0x15, 0x034b);
9427         MP_WritePhyUshort(sc, 0x19, 0xa22c);
9428         MP_WritePhyUshort(sc, 0x15, 0x034c);
9429         MP_WritePhyUshort(sc, 0x19, 0x3397);
9430         MP_WritePhyUshort(sc, 0x15, 0x034d);
9431         MP_WritePhyUshort(sc, 0x19, 0x91f2);
9432         MP_WritePhyUshort(sc, 0x15, 0x034e);
9433         MP_WritePhyUshort(sc, 0x19, 0xc218);
9434         MP_WritePhyUshort(sc, 0x15, 0x034f);
9435         MP_WritePhyUshort(sc, 0x19, 0x00f0);
9436         MP_WritePhyUshort(sc, 0x15, 0x0350);
9437         MP_WritePhyUshort(sc, 0x19, 0x3397);
9438         MP_WritePhyUshort(sc, 0x15, 0x0351);
9439         MP_WritePhyUshort(sc, 0x19, 0x0000);
9440         MP_WritePhyUshort(sc, 0x15, 0x0364);
9441         MP_WritePhyUshort(sc, 0x19, 0xbc05);
9442         MP_WritePhyUshort(sc, 0x15, 0x0367);
9443         MP_WritePhyUshort(sc, 0x19, 0xa1fc);
9444         MP_WritePhyUshort(sc, 0x15, 0x0368);
9445         MP_WritePhyUshort(sc, 0x19, 0x3377);
9446         MP_WritePhyUshort(sc, 0x15, 0x0369);
9447         MP_WritePhyUshort(sc, 0x19, 0x328b);
9448         MP_WritePhyUshort(sc, 0x15, 0x036a);
9449         MP_WritePhyUshort(sc, 0x19, 0x0000);
9450         MP_WritePhyUshort(sc, 0x15, 0x0377);
9451         MP_WritePhyUshort(sc, 0x19, 0x4b97);
9452         MP_WritePhyUshort(sc, 0x15, 0x0378);
9453         MP_WritePhyUshort(sc, 0x19, 0x6818);
9454         MP_WritePhyUshort(sc, 0x15, 0x0379);
9455         MP_WritePhyUshort(sc, 0x19, 0x4b07);
9456         MP_WritePhyUshort(sc, 0x15, 0x037a);
9457         MP_WritePhyUshort(sc, 0x19, 0x40ac);
9458         MP_WritePhyUshort(sc, 0x15, 0x037b);
9459         MP_WritePhyUshort(sc, 0x19, 0x4445);
9460         MP_WritePhyUshort(sc, 0x15, 0x037c);
9461         MP_WritePhyUshort(sc, 0x19, 0x404e);
9462         MP_WritePhyUshort(sc, 0x15, 0x037d);
9463         MP_WritePhyUshort(sc, 0x19, 0x4461);
9464         MP_WritePhyUshort(sc, 0x15, 0x037e);
9465         MP_WritePhyUshort(sc, 0x19, 0x9c09);
9466         MP_WritePhyUshort(sc, 0x15, 0x037f);
9467         MP_WritePhyUshort(sc, 0x19, 0x63da);
9468         MP_WritePhyUshort(sc, 0x15, 0x0380);
9469         MP_WritePhyUshort(sc, 0x19, 0x5440);
9470         MP_WritePhyUshort(sc, 0x15, 0x0381);
9471         MP_WritePhyUshort(sc, 0x19, 0x4b98);
9472         MP_WritePhyUshort(sc, 0x15, 0x0382);
9473         MP_WritePhyUshort(sc, 0x19, 0x7c60);
9474         MP_WritePhyUshort(sc, 0x15, 0x0383);
9475         MP_WritePhyUshort(sc, 0x19, 0x4c00);
9476         MP_WritePhyUshort(sc, 0x15, 0x0384);
9477         MP_WritePhyUshort(sc, 0x19, 0x4b08);
9478         MP_WritePhyUshort(sc, 0x15, 0x0385);
9479         MP_WritePhyUshort(sc, 0x19, 0x63d8);
9480         MP_WritePhyUshort(sc, 0x15, 0x0386);
9481         MP_WritePhyUshort(sc, 0x19, 0x338d);
9482         MP_WritePhyUshort(sc, 0x15, 0x0387);
9483         MP_WritePhyUshort(sc, 0x19, 0xd64f);
9484         MP_WritePhyUshort(sc, 0x15, 0x0388);
9485         MP_WritePhyUshort(sc, 0x19, 0x0080);
9486         MP_WritePhyUshort(sc, 0x15, 0x0389);
9487         MP_WritePhyUshort(sc, 0x19, 0x820c);
9488         MP_WritePhyUshort(sc, 0x15, 0x038a);
9489         MP_WritePhyUshort(sc, 0x19, 0xa10b);
9490         MP_WritePhyUshort(sc, 0x15, 0x038b);
9491         MP_WritePhyUshort(sc, 0x19, 0x9df3);
9492         MP_WritePhyUshort(sc, 0x15, 0x038c);
9493         MP_WritePhyUshort(sc, 0x19, 0x3395);
9494         MP_WritePhyUshort(sc, 0x15, 0x038d);
9495         MP_WritePhyUshort(sc, 0x19, 0xd64f);
9496         MP_WritePhyUshort(sc, 0x15, 0x038e);
9497         MP_WritePhyUshort(sc, 0x19, 0x00f9);
9498         MP_WritePhyUshort(sc, 0x15, 0x038f);
9499         MP_WritePhyUshort(sc, 0x19, 0xc017);
9500         MP_WritePhyUshort(sc, 0x15, 0x0390);
9501         MP_WritePhyUshort(sc, 0x19, 0x0005);
9502         MP_WritePhyUshort(sc, 0x15, 0x0391);
9503         MP_WritePhyUshort(sc, 0x19, 0x6c0b);
9504         MP_WritePhyUshort(sc, 0x15, 0x0392);
9505         MP_WritePhyUshort(sc, 0x19, 0xa103);
9506         MP_WritePhyUshort(sc, 0x15, 0x0393);
9507         MP_WritePhyUshort(sc, 0x19, 0x6c08);
9508         MP_WritePhyUshort(sc, 0x15, 0x0394);
9509         MP_WritePhyUshort(sc, 0x19, 0x9df9);
9510         MP_WritePhyUshort(sc, 0x15, 0x0395);
9511         MP_WritePhyUshort(sc, 0x19, 0x6c08);
9512         MP_WritePhyUshort(sc, 0x15, 0x0396);
9513         MP_WritePhyUshort(sc, 0x19, 0x3397);
9514         MP_WritePhyUshort(sc, 0x15, 0x0399);
9515         MP_WritePhyUshort(sc, 0x19, 0x6810);
9516         MP_WritePhyUshort(sc, 0x15, 0x03a4);
9517         MP_WritePhyUshort(sc, 0x19, 0x7c08);
9518         MP_WritePhyUshort(sc, 0x15, 0x03a5);
9519         MP_WritePhyUshort(sc, 0x19, 0x8203);
9520         MP_WritePhyUshort(sc, 0x15, 0x03a6);
9521         MP_WritePhyUshort(sc, 0x19, 0x4d08);
9522         MP_WritePhyUshort(sc, 0x15, 0x03a7);
9523         MP_WritePhyUshort(sc, 0x19, 0x33a9);
9524         MP_WritePhyUshort(sc, 0x15, 0x03a8);
9525         MP_WritePhyUshort(sc, 0x19, 0x4d00);
9526         MP_WritePhyUshort(sc, 0x15, 0x03a9);
9527         MP_WritePhyUshort(sc, 0x19, 0x9bfa);
9528         MP_WritePhyUshort(sc, 0x15, 0x03aa);
9529         MP_WritePhyUshort(sc, 0x19, 0x33b6);
9530         MP_WritePhyUshort(sc, 0x15, 0x03bb);
9531         MP_WritePhyUshort(sc, 0x19, 0x4056);
9532         MP_WritePhyUshort(sc, 0x15, 0x03bc);
9533         MP_WritePhyUshort(sc, 0x19, 0x44e9);
9534         MP_WritePhyUshort(sc, 0x15, 0x03bd);
9535         MP_WritePhyUshort(sc, 0x19, 0x405e);
9536         MP_WritePhyUshort(sc, 0x15, 0x03be);
9537         MP_WritePhyUshort(sc, 0x19, 0x44f8);
9538         MP_WritePhyUshort(sc, 0x15, 0x03bf);
9539         MP_WritePhyUshort(sc, 0x19, 0xd64f);
9540         MP_WritePhyUshort(sc, 0x15, 0x03c0);
9541         MP_WritePhyUshort(sc, 0x19, 0x0037);
9542         MP_WritePhyUshort(sc, 0x15, 0x03c1);
9543         MP_WritePhyUshort(sc, 0x19, 0xbd37);
9544         MP_WritePhyUshort(sc, 0x15, 0x03c2);
9545         MP_WritePhyUshort(sc, 0x19, 0x9cfd);
9546         MP_WritePhyUshort(sc, 0x15, 0x03c3);
9547         MP_WritePhyUshort(sc, 0x19, 0xc639);
9548         MP_WritePhyUshort(sc, 0x15, 0x03c4);
9549         MP_WritePhyUshort(sc, 0x19, 0x0011);
9550         MP_WritePhyUshort(sc, 0x15, 0x03c5);
9551         MP_WritePhyUshort(sc, 0x19, 0x9b03);
9552         MP_WritePhyUshort(sc, 0x15, 0x03c6);
9553         MP_WritePhyUshort(sc, 0x19, 0x7c01);
9554         MP_WritePhyUshort(sc, 0x15, 0x03c7);
9555         MP_WritePhyUshort(sc, 0x19, 0x4c01);
9556         MP_WritePhyUshort(sc, 0x15, 0x03c8);
9557         MP_WritePhyUshort(sc, 0x19, 0x9e03);
9558         MP_WritePhyUshort(sc, 0x15, 0x03c9);
9559         MP_WritePhyUshort(sc, 0x19, 0x7c20);
9560         MP_WritePhyUshort(sc, 0x15, 0x03ca);
9561         MP_WritePhyUshort(sc, 0x19, 0x4c20);
9562         MP_WritePhyUshort(sc, 0x15, 0x03cb);
9563         MP_WritePhyUshort(sc, 0x19, 0x9af4);
9564         MP_WritePhyUshort(sc, 0x15, 0x03cc);
9565         MP_WritePhyUshort(sc, 0x19, 0x7c12);
9566         MP_WritePhyUshort(sc, 0x15, 0x03cd);
9567         MP_WritePhyUshort(sc, 0x19, 0x4c52);
9568         MP_WritePhyUshort(sc, 0x15, 0x03ce);
9569         MP_WritePhyUshort(sc, 0x19, 0x4470);
9570         MP_WritePhyUshort(sc, 0x15, 0x03cf);
9571         MP_WritePhyUshort(sc, 0x19, 0x7c12);
9572         MP_WritePhyUshort(sc, 0x15, 0x03d0);
9573         MP_WritePhyUshort(sc, 0x19, 0x4c40);
9574         MP_WritePhyUshort(sc, 0x15, 0x03d1);
9575         MP_WritePhyUshort(sc, 0x19, 0x33bf);
9576         MP_WritePhyUshort(sc, 0x15, 0x03d6);
9577         MP_WritePhyUshort(sc, 0x19, 0x4047);
9578         MP_WritePhyUshort(sc, 0x15, 0x03d7);
9579         MP_WritePhyUshort(sc, 0x19, 0x4469);
9580         MP_WritePhyUshort(sc, 0x15, 0x03d8);
9581         MP_WritePhyUshort(sc, 0x19, 0x492b);
9582         MP_WritePhyUshort(sc, 0x15, 0x03d9);
9583         MP_WritePhyUshort(sc, 0x19, 0x4479);
9584         MP_WritePhyUshort(sc, 0x15, 0x03da);
9585         MP_WritePhyUshort(sc, 0x19, 0x7c09);
9586         MP_WritePhyUshort(sc, 0x15, 0x03db);
9587         MP_WritePhyUshort(sc, 0x19, 0x8203);
9588         MP_WritePhyUshort(sc, 0x15, 0x03dc);
9589         MP_WritePhyUshort(sc, 0x19, 0x4d48);
9590         MP_WritePhyUshort(sc, 0x15, 0x03dd);
9591         MP_WritePhyUshort(sc, 0x19, 0x33df);
9592         MP_WritePhyUshort(sc, 0x15, 0x03de);
9593         MP_WritePhyUshort(sc, 0x19, 0x4d40);
9594         MP_WritePhyUshort(sc, 0x15, 0x03df);
9595         MP_WritePhyUshort(sc, 0x19, 0xd64f);
9596         MP_WritePhyUshort(sc, 0x15, 0x03e0);
9597         MP_WritePhyUshort(sc, 0x19, 0x0017);
9598         MP_WritePhyUshort(sc, 0x15, 0x03e1);
9599         MP_WritePhyUshort(sc, 0x19, 0xbd17);
9600         MP_WritePhyUshort(sc, 0x15, 0x03e2);
9601         MP_WritePhyUshort(sc, 0x19, 0x9b03);
9602         MP_WritePhyUshort(sc, 0x15, 0x03e3);
9603         MP_WritePhyUshort(sc, 0x19, 0x7c20);
9604         MP_WritePhyUshort(sc, 0x15, 0x03e4);
9605         MP_WritePhyUshort(sc, 0x19, 0x4c20);
9606         MP_WritePhyUshort(sc, 0x15, 0x03e5);
9607         MP_WritePhyUshort(sc, 0x19, 0x88f5);
9608         MP_WritePhyUshort(sc, 0x15, 0x03e6);
9609         MP_WritePhyUshort(sc, 0x19, 0xc428);
9610         MP_WritePhyUshort(sc, 0x15, 0x03e7);
9611         MP_WritePhyUshort(sc, 0x19, 0x0008);
9612         MP_WritePhyUshort(sc, 0x15, 0x03e8);
9613         MP_WritePhyUshort(sc, 0x19, 0x9af2);
9614         MP_WritePhyUshort(sc, 0x15, 0x03e9);
9615         MP_WritePhyUshort(sc, 0x19, 0x7c12);
9616         MP_WritePhyUshort(sc, 0x15, 0x03ea);
9617         MP_WritePhyUshort(sc, 0x19, 0x4c52);
9618         MP_WritePhyUshort(sc, 0x15, 0x03eb);
9619         MP_WritePhyUshort(sc, 0x19, 0x4470);
9620         MP_WritePhyUshort(sc, 0x15, 0x03ec);
9621         MP_WritePhyUshort(sc, 0x19, 0x7c12);
9622         MP_WritePhyUshort(sc, 0x15, 0x03ed);
9623         MP_WritePhyUshort(sc, 0x19, 0x4c40);
9624         MP_WritePhyUshort(sc, 0x15, 0x03ee);
9625         MP_WritePhyUshort(sc, 0x19, 0x33da);
9626         MP_WritePhyUshort(sc, 0x15, 0x03ef);
9627         MP_WritePhyUshort(sc, 0x19, 0x3312);
9628         MP_WritePhyUshort(sc, 0x16, 0x0306);
9629         MP_WritePhyUshort(sc, 0x16, 0x0300);
9630         MP_WritePhyUshort(sc, 0x1f, 0x0000);
9631         MP_WritePhyUshort(sc, 0x17, 0x2179);
9632         MP_WritePhyUshort(sc, 0x1f, 0x0007);
9633         MP_WritePhyUshort(sc, 0x1e, 0x0040);
9634         MP_WritePhyUshort(sc, 0x18, 0x0645);
9635         MP_WritePhyUshort(sc, 0x19, 0xe200);
9636         MP_WritePhyUshort(sc, 0x18, 0x0655);
9637         MP_WritePhyUshort(sc, 0x19, 0x9000);
9638         MP_WritePhyUshort(sc, 0x18, 0x0d05);
9639         MP_WritePhyUshort(sc, 0x19, 0xbe00);
9640         MP_WritePhyUshort(sc, 0x18, 0x0d15);
9641         MP_WritePhyUshort(sc, 0x19, 0xd300);
9642         MP_WritePhyUshort(sc, 0x18, 0x0d25);
9643         MP_WritePhyUshort(sc, 0x19, 0xfe00);
9644         MP_WritePhyUshort(sc, 0x18, 0x0d35);
9645         MP_WritePhyUshort(sc, 0x19, 0x4000);
9646         MP_WritePhyUshort(sc, 0x18, 0x0d45);
9647         MP_WritePhyUshort(sc, 0x19, 0x7f00);
9648         MP_WritePhyUshort(sc, 0x18, 0x0d55);
9649         MP_WritePhyUshort(sc, 0x19, 0x1000);
9650         MP_WritePhyUshort(sc, 0x18, 0x0d65);
9651         MP_WritePhyUshort(sc, 0x19, 0x0000);
9652         MP_WritePhyUshort(sc, 0x18, 0x0d75);
9653         MP_WritePhyUshort(sc, 0x19, 0x8200);
9654         MP_WritePhyUshort(sc, 0x18, 0x0d85);
9655         MP_WritePhyUshort(sc, 0x19, 0x0000);
9656         MP_WritePhyUshort(sc, 0x18, 0x0d95);
9657         MP_WritePhyUshort(sc, 0x19, 0x7000);
9658         MP_WritePhyUshort(sc, 0x18, 0x0da5);
9659         MP_WritePhyUshort(sc, 0x19, 0x0f00);
9660         MP_WritePhyUshort(sc, 0x18, 0x0db5);
9661         MP_WritePhyUshort(sc, 0x19, 0x0100);
9662         MP_WritePhyUshort(sc, 0x18, 0x0dc5);
9663         MP_WritePhyUshort(sc, 0x19, 0x9b00);
9664         MP_WritePhyUshort(sc, 0x18, 0x0dd5);
9665         MP_WritePhyUshort(sc, 0x19, 0x7f00);
9666         MP_WritePhyUshort(sc, 0x18, 0x0de5);
9667         MP_WritePhyUshort(sc, 0x19, 0xe000);
9668         MP_WritePhyUshort(sc, 0x18, 0x0df5);
9669         MP_WritePhyUshort(sc, 0x19, 0xef00);
9670         MP_WritePhyUshort(sc, 0x18, 0x16d5);
9671         MP_WritePhyUshort(sc, 0x19, 0xe200);
9672         MP_WritePhyUshort(sc, 0x18, 0x16e5);
9673         MP_WritePhyUshort(sc, 0x19, 0xab00);
9674         MP_WritePhyUshort(sc, 0x18, 0x2904);
9675         MP_WritePhyUshort(sc, 0x19, 0x4000);
9676         MP_WritePhyUshort(sc, 0x18, 0x2914);
9677         MP_WritePhyUshort(sc, 0x19, 0x7f00);
9678         MP_WritePhyUshort(sc, 0x18, 0x2924);
9679         MP_WritePhyUshort(sc, 0x19, 0x0100);
9680         MP_WritePhyUshort(sc, 0x18, 0x2934);
9681         MP_WritePhyUshort(sc, 0x19, 0x2000);
9682         MP_WritePhyUshort(sc, 0x18, 0x2944);
9683         MP_WritePhyUshort(sc, 0x19, 0x0000);
9684         MP_WritePhyUshort(sc, 0x18, 0x2954);
9685         MP_WritePhyUshort(sc, 0x19, 0x4600);
9686         MP_WritePhyUshort(sc, 0x18, 0x2964);
9687         MP_WritePhyUshort(sc, 0x19, 0xfc00);
9688         MP_WritePhyUshort(sc, 0x18, 0x2974);
9689         MP_WritePhyUshort(sc, 0x19, 0x0000);
9690         MP_WritePhyUshort(sc, 0x18, 0x2984);
9691         MP_WritePhyUshort(sc, 0x19, 0x5000);
9692         MP_WritePhyUshort(sc, 0x18, 0x2994);
9693         MP_WritePhyUshort(sc, 0x19, 0x9d00);
9694         MP_WritePhyUshort(sc, 0x18, 0x29a4);
9695         MP_WritePhyUshort(sc, 0x19, 0xff00);
9696         MP_WritePhyUshort(sc, 0x18, 0x29b4);
9697         MP_WritePhyUshort(sc, 0x19, 0x4000);
9698         MP_WritePhyUshort(sc, 0x18, 0x29c4);
9699         MP_WritePhyUshort(sc, 0x19, 0x7f00);
9700         MP_WritePhyUshort(sc, 0x18, 0x29d4);
9701         MP_WritePhyUshort(sc, 0x19, 0x0000);
9702         MP_WritePhyUshort(sc, 0x18, 0x29e4);
9703         MP_WritePhyUshort(sc, 0x19, 0x2000);
9704         MP_WritePhyUshort(sc, 0x18, 0x29f4);
9705         MP_WritePhyUshort(sc, 0x19, 0x0000);
9706         MP_WritePhyUshort(sc, 0x18, 0x2a04);
9707         MP_WritePhyUshort(sc, 0x19, 0xe600);
9708         MP_WritePhyUshort(sc, 0x18, 0x2a14);
9709         MP_WritePhyUshort(sc, 0x19, 0xff00);
9710         MP_WritePhyUshort(sc, 0x18, 0x2a24);
9711         MP_WritePhyUshort(sc, 0x19, 0x0000);
9712         MP_WritePhyUshort(sc, 0x18, 0x2a34);
9713         MP_WritePhyUshort(sc, 0x19, 0x5000);
9714         MP_WritePhyUshort(sc, 0x18, 0x2a44);
9715         MP_WritePhyUshort(sc, 0x19, 0x8500);
9716         MP_WritePhyUshort(sc, 0x18, 0x2a54);
9717         MP_WritePhyUshort(sc, 0x19, 0x7f00);
9718         MP_WritePhyUshort(sc, 0x18, 0x2a64);
9719         MP_WritePhyUshort(sc, 0x19, 0xac00);
9720         MP_WritePhyUshort(sc, 0x18, 0x2a74);
9721         MP_WritePhyUshort(sc, 0x19, 0x0800);
9722         MP_WritePhyUshort(sc, 0x18, 0x2a84);
9723         MP_WritePhyUshort(sc, 0x19, 0xfc00);
9724         MP_WritePhyUshort(sc, 0x18, 0x2a94);
9725         MP_WritePhyUshort(sc, 0x19, 0xe000);
9726         MP_WritePhyUshort(sc, 0x18, 0x2aa4);
9727         MP_WritePhyUshort(sc, 0x19, 0x7400);
9728         MP_WritePhyUshort(sc, 0x18, 0x2ab4);
9729         MP_WritePhyUshort(sc, 0x19, 0x4000);
9730         MP_WritePhyUshort(sc, 0x18, 0x2ac4);
9731         MP_WritePhyUshort(sc, 0x19, 0x7f00);
9732         MP_WritePhyUshort(sc, 0x18, 0x2ad4);
9733         MP_WritePhyUshort(sc, 0x19, 0x0100);
9734         MP_WritePhyUshort(sc, 0x18, 0x2ae4);
9735         MP_WritePhyUshort(sc, 0x19, 0xff00);
9736         MP_WritePhyUshort(sc, 0x18, 0x2af4);
9737         MP_WritePhyUshort(sc, 0x19, 0x0000);
9738         MP_WritePhyUshort(sc, 0x18, 0x2b04);
9739         MP_WritePhyUshort(sc, 0x19, 0x4400);
9740         MP_WritePhyUshort(sc, 0x18, 0x2b14);
9741         MP_WritePhyUshort(sc, 0x19, 0xfc00);
9742         MP_WritePhyUshort(sc, 0x18, 0x2b24);
9743         MP_WritePhyUshort(sc, 0x19, 0x0000);
9744         MP_WritePhyUshort(sc, 0x18, 0x2b34);
9745         MP_WritePhyUshort(sc, 0x19, 0x4000);
9746         MP_WritePhyUshort(sc, 0x18, 0x2b44);
9747         MP_WritePhyUshort(sc, 0x19, 0x9d00);
9748         MP_WritePhyUshort(sc, 0x18, 0x2b54);
9749         MP_WritePhyUshort(sc, 0x19, 0xff00);
9750         MP_WritePhyUshort(sc, 0x18, 0x2b64);
9751         MP_WritePhyUshort(sc, 0x19, 0x4000);
9752         MP_WritePhyUshort(sc, 0x18, 0x2b74);
9753         MP_WritePhyUshort(sc, 0x19, 0x7f00);
9754         MP_WritePhyUshort(sc, 0x18, 0x2b84);
9755         MP_WritePhyUshort(sc, 0x19, 0x0000);
9756         MP_WritePhyUshort(sc, 0x18, 0x2b94);
9757         MP_WritePhyUshort(sc, 0x19, 0xff00);
9758         MP_WritePhyUshort(sc, 0x18, 0x2ba4);
9759         MP_WritePhyUshort(sc, 0x19, 0x0000);
9760         MP_WritePhyUshort(sc, 0x18, 0x2bb4);
9761         MP_WritePhyUshort(sc, 0x19, 0xfc00);
9762         MP_WritePhyUshort(sc, 0x18, 0x2bc4);
9763         MP_WritePhyUshort(sc, 0x19, 0xff00);
9764         MP_WritePhyUshort(sc, 0x18, 0x2bd4);
9765         MP_WritePhyUshort(sc, 0x19, 0x0000);
9766         MP_WritePhyUshort(sc, 0x18, 0x2be4);
9767         MP_WritePhyUshort(sc, 0x19, 0x4000);
9768         MP_WritePhyUshort(sc, 0x18, 0x2bf4);
9769         MP_WritePhyUshort(sc, 0x19, 0x8900);
9770         MP_WritePhyUshort(sc, 0x18, 0x2c04);
9771         MP_WritePhyUshort(sc, 0x19, 0x8300);
9772         MP_WritePhyUshort(sc, 0x18, 0x2c14);
9773         MP_WritePhyUshort(sc, 0x19, 0xe000);
9774         MP_WritePhyUshort(sc, 0x18, 0x2c24);
9775         MP_WritePhyUshort(sc, 0x19, 0x0000);
9776         MP_WritePhyUshort(sc, 0x18, 0x2c34);
9777         MP_WritePhyUshort(sc, 0x19, 0xac00);
9778         MP_WritePhyUshort(sc, 0x18, 0x2c44);
9779         MP_WritePhyUshort(sc, 0x19, 0x0800);
9780         MP_WritePhyUshort(sc, 0x18, 0x2c54);
9781         MP_WritePhyUshort(sc, 0x19, 0xfa00);
9782         MP_WritePhyUshort(sc, 0x18, 0x2c64);
9783         MP_WritePhyUshort(sc, 0x19, 0xe100);
9784         MP_WritePhyUshort(sc, 0x18, 0x2c74);
9785         MP_WritePhyUshort(sc, 0x19, 0x7f00);
9786         MP_WritePhyUshort(sc, 0x18, 0x0001);
9787         MP_WritePhyUshort(sc, 0x1f, 0x0000);
9788         MP_WritePhyUshort(sc, 0x17, 0x2100);
9789         MP_WritePhyUshort(sc, 0x1f, 0x0005);
9790         MP_WritePhyUshort(sc, 0x05, 0xfff6);
9791         MP_WritePhyUshort(sc, 0x06, 0x0080);
9792         MP_WritePhyUshort(sc, 0x05, 0x8b88);
9793         MP_WritePhyUshort(sc, 0x06, 0x0000);
9794         MP_WritePhyUshort(sc, 0x06, 0x0000);
9795         MP_WritePhyUshort(sc, 0x06, 0x0000);
9796         MP_WritePhyUshort(sc, 0x06, 0x0000);
9797         MP_WritePhyUshort(sc, 0x05, 0x8000);
9798         MP_WritePhyUshort(sc, 0x06, 0xd480);
9799         MP_WritePhyUshort(sc, 0x06, 0xc1e4);
9800         MP_WritePhyUshort(sc, 0x06, 0x8b9a);
9801         MP_WritePhyUshort(sc, 0x06, 0xe58b);
9802         MP_WritePhyUshort(sc, 0x06, 0x9bee);
9803         MP_WritePhyUshort(sc, 0x06, 0x8b83);
9804         MP_WritePhyUshort(sc, 0x06, 0x41bf);
9805         MP_WritePhyUshort(sc, 0x06, 0x8b88);
9806         MP_WritePhyUshort(sc, 0x06, 0xec00);
9807         MP_WritePhyUshort(sc, 0x06, 0x19a9);
9808         MP_WritePhyUshort(sc, 0x06, 0x8b90);
9809         MP_WritePhyUshort(sc, 0x06, 0xf9ee);
9810         MP_WritePhyUshort(sc, 0x06, 0xfff6);
9811         MP_WritePhyUshort(sc, 0x06, 0x00ee);
9812         MP_WritePhyUshort(sc, 0x06, 0xfff7);
9813         MP_WritePhyUshort(sc, 0x06, 0xffe0);
9814         MP_WritePhyUshort(sc, 0x06, 0xe140);
9815         MP_WritePhyUshort(sc, 0x06, 0xe1e1);
9816         MP_WritePhyUshort(sc, 0x06, 0x41f7);
9817         MP_WritePhyUshort(sc, 0x06, 0x2ff6);
9818         MP_WritePhyUshort(sc, 0x06, 0x28e4);
9819         MP_WritePhyUshort(sc, 0x06, 0xe140);
9820         MP_WritePhyUshort(sc, 0x06, 0xe5e1);
9821         MP_WritePhyUshort(sc, 0x06, 0x41f7);
9822         MP_WritePhyUshort(sc, 0x06, 0x0002);
9823         MP_WritePhyUshort(sc, 0x06, 0x020c);
9824         MP_WritePhyUshort(sc, 0x06, 0x0202);
9825         MP_WritePhyUshort(sc, 0x06, 0x1d02);
9826         MP_WritePhyUshort(sc, 0x06, 0x0230);
9827         MP_WritePhyUshort(sc, 0x06, 0x0202);
9828         MP_WritePhyUshort(sc, 0x06, 0x4002);
9829         MP_WritePhyUshort(sc, 0x06, 0x028b);
9830         MP_WritePhyUshort(sc, 0x06, 0x0280);
9831         MP_WritePhyUshort(sc, 0x06, 0x6c02);
9832         MP_WritePhyUshort(sc, 0x06, 0x8085);
9833         MP_WritePhyUshort(sc, 0x06, 0xe08b);
9834         MP_WritePhyUshort(sc, 0x06, 0x88e1);
9835         MP_WritePhyUshort(sc, 0x06, 0x8b89);
9836         MP_WritePhyUshort(sc, 0x06, 0x1e01);
9837         MP_WritePhyUshort(sc, 0x06, 0xe18b);
9838         MP_WritePhyUshort(sc, 0x06, 0x8a1e);
9839         MP_WritePhyUshort(sc, 0x06, 0x01e1);
9840         MP_WritePhyUshort(sc, 0x06, 0x8b8b);
9841         MP_WritePhyUshort(sc, 0x06, 0x1e01);
9842         MP_WritePhyUshort(sc, 0x06, 0xe18b);
9843         MP_WritePhyUshort(sc, 0x06, 0x8c1e);
9844         MP_WritePhyUshort(sc, 0x06, 0x01e1);
9845         MP_WritePhyUshort(sc, 0x06, 0x8b8d);
9846         MP_WritePhyUshort(sc, 0x06, 0x1e01);
9847         MP_WritePhyUshort(sc, 0x06, 0xe18b);
9848         MP_WritePhyUshort(sc, 0x06, 0x8e1e);
9849         MP_WritePhyUshort(sc, 0x06, 0x01a0);
9850         MP_WritePhyUshort(sc, 0x06, 0x00c7);
9851         MP_WritePhyUshort(sc, 0x06, 0xaec3);
9852         MP_WritePhyUshort(sc, 0x06, 0xf8e0);
9853         MP_WritePhyUshort(sc, 0x06, 0x8b8d);
9854         MP_WritePhyUshort(sc, 0x06, 0xad20);
9855         MP_WritePhyUshort(sc, 0x06, 0x10ee);
9856         MP_WritePhyUshort(sc, 0x06, 0x8b8d);
9857         MP_WritePhyUshort(sc, 0x06, 0x0002);
9858         MP_WritePhyUshort(sc, 0x06, 0x1310);
9859         MP_WritePhyUshort(sc, 0x06, 0x021f);
9860         MP_WritePhyUshort(sc, 0x06, 0x9d02);
9861         MP_WritePhyUshort(sc, 0x06, 0x1f0c);
9862         MP_WritePhyUshort(sc, 0x06, 0x0227);
9863         MP_WritePhyUshort(sc, 0x06, 0x49fc);
9864         MP_WritePhyUshort(sc, 0x06, 0x04f8);
9865         MP_WritePhyUshort(sc, 0x06, 0xe08b);
9866         MP_WritePhyUshort(sc, 0x06, 0x8ead);
9867         MP_WritePhyUshort(sc, 0x06, 0x200b);
9868         MP_WritePhyUshort(sc, 0x06, 0xf620);
9869         MP_WritePhyUshort(sc, 0x06, 0xe48b);
9870         MP_WritePhyUshort(sc, 0x06, 0x8e02);
9871         MP_WritePhyUshort(sc, 0x06, 0x830e);
9872         MP_WritePhyUshort(sc, 0x06, 0x021b);
9873         MP_WritePhyUshort(sc, 0x06, 0x67ad);
9874         MP_WritePhyUshort(sc, 0x06, 0x2211);
9875         MP_WritePhyUshort(sc, 0x06, 0xf622);
9876         MP_WritePhyUshort(sc, 0x06, 0xe48b);
9877         MP_WritePhyUshort(sc, 0x06, 0x8e02);
9878         MP_WritePhyUshort(sc, 0x06, 0x2ba5);
9879         MP_WritePhyUshort(sc, 0x06, 0x022a);
9880         MP_WritePhyUshort(sc, 0x06, 0x2402);
9881         MP_WritePhyUshort(sc, 0x06, 0x80c6);
9882         MP_WritePhyUshort(sc, 0x06, 0x022a);
9883         MP_WritePhyUshort(sc, 0x06, 0xf0ad);
9884         MP_WritePhyUshort(sc, 0x06, 0x2511);
9885         MP_WritePhyUshort(sc, 0x06, 0xf625);
9886         MP_WritePhyUshort(sc, 0x06, 0xe48b);
9887         MP_WritePhyUshort(sc, 0x06, 0x8e02);
9888         MP_WritePhyUshort(sc, 0x06, 0x8226);
9889         MP_WritePhyUshort(sc, 0x06, 0x0204);
9890         MP_WritePhyUshort(sc, 0x06, 0x0302);
9891         MP_WritePhyUshort(sc, 0x06, 0x19cc);
9892         MP_WritePhyUshort(sc, 0x06, 0x022b);
9893         MP_WritePhyUshort(sc, 0x06, 0x5bfc);
9894         MP_WritePhyUshort(sc, 0x06, 0x04ee);
9895         MP_WritePhyUshort(sc, 0x06, 0x8b8d);
9896         MP_WritePhyUshort(sc, 0x06, 0x0105);
9897         MP_WritePhyUshort(sc, 0x06, 0xf8e0);
9898         MP_WritePhyUshort(sc, 0x06, 0x8b83);
9899         MP_WritePhyUshort(sc, 0x06, 0xad24);
9900         MP_WritePhyUshort(sc, 0x06, 0x44e0);
9901         MP_WritePhyUshort(sc, 0x06, 0xe022);
9902         MP_WritePhyUshort(sc, 0x06, 0xe1e0);
9903         MP_WritePhyUshort(sc, 0x06, 0x23ad);
9904         MP_WritePhyUshort(sc, 0x06, 0x223b);
9905         MP_WritePhyUshort(sc, 0x06, 0xe08a);
9906         MP_WritePhyUshort(sc, 0x06, 0xbea0);
9907         MP_WritePhyUshort(sc, 0x06, 0x0005);
9908         MP_WritePhyUshort(sc, 0x06, 0x0228);
9909         MP_WritePhyUshort(sc, 0x06, 0xdeae);
9910         MP_WritePhyUshort(sc, 0x06, 0x42a0);
9911         MP_WritePhyUshort(sc, 0x06, 0x0105);
9912         MP_WritePhyUshort(sc, 0x06, 0x0228);
9913         MP_WritePhyUshort(sc, 0x06, 0xf1ae);
9914         MP_WritePhyUshort(sc, 0x06, 0x3aa0);
9915         MP_WritePhyUshort(sc, 0x06, 0x0205);
9916         MP_WritePhyUshort(sc, 0x06, 0x0281);
9917         MP_WritePhyUshort(sc, 0x06, 0x25ae);
9918         MP_WritePhyUshort(sc, 0x06, 0x32a0);
9919         MP_WritePhyUshort(sc, 0x06, 0x0305);
9920         MP_WritePhyUshort(sc, 0x06, 0x0229);
9921         MP_WritePhyUshort(sc, 0x06, 0x9aae);
9922         MP_WritePhyUshort(sc, 0x06, 0x2aa0);
9923         MP_WritePhyUshort(sc, 0x06, 0x0405);
9924         MP_WritePhyUshort(sc, 0x06, 0x0229);
9925         MP_WritePhyUshort(sc, 0x06, 0xaeae);
9926         MP_WritePhyUshort(sc, 0x06, 0x22a0);
9927         MP_WritePhyUshort(sc, 0x06, 0x0505);
9928         MP_WritePhyUshort(sc, 0x06, 0x0229);
9929         MP_WritePhyUshort(sc, 0x06, 0xd7ae);
9930         MP_WritePhyUshort(sc, 0x06, 0x1aa0);
9931         MP_WritePhyUshort(sc, 0x06, 0x0605);
9932         MP_WritePhyUshort(sc, 0x06, 0x0229);
9933         MP_WritePhyUshort(sc, 0x06, 0xfeae);
9934         MP_WritePhyUshort(sc, 0x06, 0x12ee);
9935         MP_WritePhyUshort(sc, 0x06, 0x8ac0);
9936         MP_WritePhyUshort(sc, 0x06, 0x00ee);
9937         MP_WritePhyUshort(sc, 0x06, 0x8ac1);
9938         MP_WritePhyUshort(sc, 0x06, 0x00ee);
9939         MP_WritePhyUshort(sc, 0x06, 0x8ac6);
9940         MP_WritePhyUshort(sc, 0x06, 0x00ee);
9941         MP_WritePhyUshort(sc, 0x06, 0x8abe);
9942         MP_WritePhyUshort(sc, 0x06, 0x00ae);
9943         MP_WritePhyUshort(sc, 0x06, 0x00fc);
9944         MP_WritePhyUshort(sc, 0x06, 0x04f8);
9945         MP_WritePhyUshort(sc, 0x06, 0x022a);
9946         MP_WritePhyUshort(sc, 0x06, 0x67e0);
9947         MP_WritePhyUshort(sc, 0x06, 0xe022);
9948         MP_WritePhyUshort(sc, 0x06, 0xe1e0);
9949         MP_WritePhyUshort(sc, 0x06, 0x230d);
9950         MP_WritePhyUshort(sc, 0x06, 0x0658);
9951         MP_WritePhyUshort(sc, 0x06, 0x03a0);
9952         MP_WritePhyUshort(sc, 0x06, 0x0202);
9953         MP_WritePhyUshort(sc, 0x06, 0xae2d);
9954         MP_WritePhyUshort(sc, 0x06, 0xa001);
9955         MP_WritePhyUshort(sc, 0x06, 0x02ae);
9956         MP_WritePhyUshort(sc, 0x06, 0x2da0);
9957         MP_WritePhyUshort(sc, 0x06, 0x004d);
9958         MP_WritePhyUshort(sc, 0x06, 0xe0e2);
9959         MP_WritePhyUshort(sc, 0x06, 0x00e1);
9960         MP_WritePhyUshort(sc, 0x06, 0xe201);
9961         MP_WritePhyUshort(sc, 0x06, 0xad24);
9962         MP_WritePhyUshort(sc, 0x06, 0x44e0);
9963         MP_WritePhyUshort(sc, 0x06, 0x8ac2);
9964         MP_WritePhyUshort(sc, 0x06, 0xe48a);
9965         MP_WritePhyUshort(sc, 0x06, 0xc4e0);
9966         MP_WritePhyUshort(sc, 0x06, 0x8ac3);
9967         MP_WritePhyUshort(sc, 0x06, 0xe48a);
9968         MP_WritePhyUshort(sc, 0x06, 0xc5ee);
9969         MP_WritePhyUshort(sc, 0x06, 0x8abe);
9970         MP_WritePhyUshort(sc, 0x06, 0x03e0);
9971         MP_WritePhyUshort(sc, 0x06, 0x8b83);
9972         MP_WritePhyUshort(sc, 0x06, 0xad25);
9973         MP_WritePhyUshort(sc, 0x06, 0x3aee);
9974         MP_WritePhyUshort(sc, 0x06, 0x8abe);
9975         MP_WritePhyUshort(sc, 0x06, 0x05ae);
9976         MP_WritePhyUshort(sc, 0x06, 0x34e0);
9977         MP_WritePhyUshort(sc, 0x06, 0x8ace);
9978         MP_WritePhyUshort(sc, 0x06, 0xae03);
9979         MP_WritePhyUshort(sc, 0x06, 0xe08a);
9980         MP_WritePhyUshort(sc, 0x06, 0xcfe1);
9981         MP_WritePhyUshort(sc, 0x06, 0x8ac2);
9982         MP_WritePhyUshort(sc, 0x06, 0x4905);
9983         MP_WritePhyUshort(sc, 0x06, 0xe58a);
9984         MP_WritePhyUshort(sc, 0x06, 0xc4e1);
9985         MP_WritePhyUshort(sc, 0x06, 0x8ac3);
9986         MP_WritePhyUshort(sc, 0x06, 0x4905);
9987         MP_WritePhyUshort(sc, 0x06, 0xe58a);
9988         MP_WritePhyUshort(sc, 0x06, 0xc5ee);
9989         MP_WritePhyUshort(sc, 0x06, 0x8abe);
9990         MP_WritePhyUshort(sc, 0x06, 0x0502);
9991         MP_WritePhyUshort(sc, 0x06, 0x2ab6);
9992         MP_WritePhyUshort(sc, 0x06, 0xac20);
9993         MP_WritePhyUshort(sc, 0x06, 0x1202);
9994         MP_WritePhyUshort(sc, 0x06, 0x819b);
9995         MP_WritePhyUshort(sc, 0x06, 0xac20);
9996         MP_WritePhyUshort(sc, 0x06, 0x0cee);
9997         MP_WritePhyUshort(sc, 0x06, 0x8ac1);
9998         MP_WritePhyUshort(sc, 0x06, 0x00ee);
9999         MP_WritePhyUshort(sc, 0x06, 0x8ac6);
10000         MP_WritePhyUshort(sc, 0x06, 0x00ee);
10001         MP_WritePhyUshort(sc, 0x06, 0x8abe);
10002         MP_WritePhyUshort(sc, 0x06, 0x02fc);
10003         MP_WritePhyUshort(sc, 0x06, 0x04d0);
10004         MP_WritePhyUshort(sc, 0x06, 0x0002);
10005         MP_WritePhyUshort(sc, 0x06, 0x81ad);
10006         MP_WritePhyUshort(sc, 0x06, 0x590f);
10007         MP_WritePhyUshort(sc, 0x06, 0x3902);
10008         MP_WritePhyUshort(sc, 0x06, 0xaa04);
10009         MP_WritePhyUshort(sc, 0x06, 0xd001);
10010         MP_WritePhyUshort(sc, 0x06, 0xae02);
10011         MP_WritePhyUshort(sc, 0x06, 0xd000);
10012         MP_WritePhyUshort(sc, 0x06, 0x04f9);
10013         MP_WritePhyUshort(sc, 0x06, 0xfae2);
10014         MP_WritePhyUshort(sc, 0x06, 0xe2d2);
10015         MP_WritePhyUshort(sc, 0x06, 0xe3e2);
10016         MP_WritePhyUshort(sc, 0x06, 0xd3f9);
10017         MP_WritePhyUshort(sc, 0x06, 0x5af7);
10018         MP_WritePhyUshort(sc, 0x06, 0xe6e2);
10019         MP_WritePhyUshort(sc, 0x06, 0xd2e7);
10020         MP_WritePhyUshort(sc, 0x06, 0xe2d3);
10021         MP_WritePhyUshort(sc, 0x06, 0xe2e0);
10022         MP_WritePhyUshort(sc, 0x06, 0x2ce3);
10023         MP_WritePhyUshort(sc, 0x06, 0xe02d);
10024         MP_WritePhyUshort(sc, 0x06, 0xf95b);
10025         MP_WritePhyUshort(sc, 0x06, 0xe01e);
10026         MP_WritePhyUshort(sc, 0x06, 0x30e6);
10027         MP_WritePhyUshort(sc, 0x06, 0xe02c);
10028         MP_WritePhyUshort(sc, 0x06, 0xe7e0);
10029         MP_WritePhyUshort(sc, 0x06, 0x2de2);
10030         MP_WritePhyUshort(sc, 0x06, 0xe2cc);
10031         MP_WritePhyUshort(sc, 0x06, 0xe3e2);
10032         MP_WritePhyUshort(sc, 0x06, 0xcdf9);
10033         MP_WritePhyUshort(sc, 0x06, 0x5a0f);
10034         MP_WritePhyUshort(sc, 0x06, 0x6a50);
10035         MP_WritePhyUshort(sc, 0x06, 0xe6e2);
10036         MP_WritePhyUshort(sc, 0x06, 0xcce7);
10037         MP_WritePhyUshort(sc, 0x06, 0xe2cd);
10038         MP_WritePhyUshort(sc, 0x06, 0xe0e0);
10039         MP_WritePhyUshort(sc, 0x06, 0x3ce1);
10040         MP_WritePhyUshort(sc, 0x06, 0xe03d);
10041         MP_WritePhyUshort(sc, 0x06, 0xef64);
10042         MP_WritePhyUshort(sc, 0x06, 0xfde0);
10043         MP_WritePhyUshort(sc, 0x06, 0xe2cc);
10044         MP_WritePhyUshort(sc, 0x06, 0xe1e2);
10045         MP_WritePhyUshort(sc, 0x06, 0xcd58);
10046         MP_WritePhyUshort(sc, 0x06, 0x0f5a);
10047         MP_WritePhyUshort(sc, 0x06, 0xf01e);
10048         MP_WritePhyUshort(sc, 0x06, 0x02e4);
10049         MP_WritePhyUshort(sc, 0x06, 0xe2cc);
10050         MP_WritePhyUshort(sc, 0x06, 0xe5e2);
10051         MP_WritePhyUshort(sc, 0x06, 0xcdfd);
10052         MP_WritePhyUshort(sc, 0x06, 0xe0e0);
10053         MP_WritePhyUshort(sc, 0x06, 0x2ce1);
10054         MP_WritePhyUshort(sc, 0x06, 0xe02d);
10055         MP_WritePhyUshort(sc, 0x06, 0x59e0);
10056         MP_WritePhyUshort(sc, 0x06, 0x5b1f);
10057         MP_WritePhyUshort(sc, 0x06, 0x1e13);
10058         MP_WritePhyUshort(sc, 0x06, 0xe4e0);
10059         MP_WritePhyUshort(sc, 0x06, 0x2ce5);
10060         MP_WritePhyUshort(sc, 0x06, 0xe02d);
10061         MP_WritePhyUshort(sc, 0x06, 0xfde0);
10062         MP_WritePhyUshort(sc, 0x06, 0xe2d2);
10063         MP_WritePhyUshort(sc, 0x06, 0xe1e2);
10064         MP_WritePhyUshort(sc, 0x06, 0xd358);
10065         MP_WritePhyUshort(sc, 0x06, 0xf75a);
10066         MP_WritePhyUshort(sc, 0x06, 0x081e);
10067         MP_WritePhyUshort(sc, 0x06, 0x02e4);
10068         MP_WritePhyUshort(sc, 0x06, 0xe2d2);
10069         MP_WritePhyUshort(sc, 0x06, 0xe5e2);
10070         MP_WritePhyUshort(sc, 0x06, 0xd3ef);
10071         MP_WritePhyUshort(sc, 0x06, 0x46fe);
10072         MP_WritePhyUshort(sc, 0x06, 0xfd04);
10073         MP_WritePhyUshort(sc, 0x06, 0xf8f9);
10074         MP_WritePhyUshort(sc, 0x06, 0xfaef);
10075         MP_WritePhyUshort(sc, 0x06, 0x69e0);
10076         MP_WritePhyUshort(sc, 0x06, 0xe022);
10077         MP_WritePhyUshort(sc, 0x06, 0xe1e0);
10078         MP_WritePhyUshort(sc, 0x06, 0x2358);
10079         MP_WritePhyUshort(sc, 0x06, 0xc4e1);
10080         MP_WritePhyUshort(sc, 0x06, 0x8b6e);
10081         MP_WritePhyUshort(sc, 0x06, 0x1f10);
10082         MP_WritePhyUshort(sc, 0x06, 0x9e58);
10083         MP_WritePhyUshort(sc, 0x06, 0xe48b);
10084         MP_WritePhyUshort(sc, 0x06, 0x6ead);
10085         MP_WritePhyUshort(sc, 0x06, 0x2222);
10086         MP_WritePhyUshort(sc, 0x06, 0xac27);
10087         MP_WritePhyUshort(sc, 0x06, 0x55ac);
10088         MP_WritePhyUshort(sc, 0x06, 0x2602);
10089         MP_WritePhyUshort(sc, 0x06, 0xae1a);
10090         MP_WritePhyUshort(sc, 0x06, 0xd106);
10091         MP_WritePhyUshort(sc, 0x06, 0xbf3b);
10092         MP_WritePhyUshort(sc, 0x06, 0xba02);
10093         MP_WritePhyUshort(sc, 0x06, 0x2dc1);
10094         MP_WritePhyUshort(sc, 0x06, 0xd107);
10095         MP_WritePhyUshort(sc, 0x06, 0xbf3b);
10096         MP_WritePhyUshort(sc, 0x06, 0xbd02);
10097         MP_WritePhyUshort(sc, 0x06, 0x2dc1);
10098         MP_WritePhyUshort(sc, 0x06, 0xd107);
10099         MP_WritePhyUshort(sc, 0x06, 0xbf3b);
10100         MP_WritePhyUshort(sc, 0x06, 0xc002);
10101         MP_WritePhyUshort(sc, 0x06, 0x2dc1);
10102         MP_WritePhyUshort(sc, 0x06, 0xae30);
10103         MP_WritePhyUshort(sc, 0x06, 0xd103);
10104         MP_WritePhyUshort(sc, 0x06, 0xbf3b);
10105         MP_WritePhyUshort(sc, 0x06, 0xc302);
10106         MP_WritePhyUshort(sc, 0x06, 0x2dc1);
10107         MP_WritePhyUshort(sc, 0x06, 0xd100);
10108         MP_WritePhyUshort(sc, 0x06, 0xbf3b);
10109         MP_WritePhyUshort(sc, 0x06, 0xc602);
10110         MP_WritePhyUshort(sc, 0x06, 0x2dc1);
10111         MP_WritePhyUshort(sc, 0x06, 0xd100);
10112         MP_WritePhyUshort(sc, 0x06, 0xbf82);
10113         MP_WritePhyUshort(sc, 0x06, 0xca02);
10114         MP_WritePhyUshort(sc, 0x06, 0x2dc1);
10115         MP_WritePhyUshort(sc, 0x06, 0xd10f);
10116         MP_WritePhyUshort(sc, 0x06, 0xbf3b);
10117         MP_WritePhyUshort(sc, 0x06, 0xba02);
10118         MP_WritePhyUshort(sc, 0x06, 0x2dc1);
10119         MP_WritePhyUshort(sc, 0x06, 0xd101);
10120         MP_WritePhyUshort(sc, 0x06, 0xbf3b);
10121         MP_WritePhyUshort(sc, 0x06, 0xbd02);
10122         MP_WritePhyUshort(sc, 0x06, 0x2dc1);
10123         MP_WritePhyUshort(sc, 0x06, 0xd101);
10124         MP_WritePhyUshort(sc, 0x06, 0xbf3b);
10125         MP_WritePhyUshort(sc, 0x06, 0xc002);
10126         MP_WritePhyUshort(sc, 0x06, 0x2dc1);
10127         MP_WritePhyUshort(sc, 0x06, 0xef96);
10128         MP_WritePhyUshort(sc, 0x06, 0xfefd);
10129         MP_WritePhyUshort(sc, 0x06, 0xfc04);
10130         MP_WritePhyUshort(sc, 0x06, 0xd100);
10131         MP_WritePhyUshort(sc, 0x06, 0xbf3b);
10132         MP_WritePhyUshort(sc, 0x06, 0xc302);
10133         MP_WritePhyUshort(sc, 0x06, 0x2dc1);
10134         MP_WritePhyUshort(sc, 0x06, 0xd011);
10135         MP_WritePhyUshort(sc, 0x06, 0x022b);
10136         MP_WritePhyUshort(sc, 0x06, 0xfb59);
10137         MP_WritePhyUshort(sc, 0x06, 0x03ef);
10138         MP_WritePhyUshort(sc, 0x06, 0x01d1);
10139         MP_WritePhyUshort(sc, 0x06, 0x00a0);
10140         MP_WritePhyUshort(sc, 0x06, 0x0002);
10141         MP_WritePhyUshort(sc, 0x06, 0xd101);
10142         MP_WritePhyUshort(sc, 0x06, 0xbf3b);
10143         MP_WritePhyUshort(sc, 0x06, 0xc602);
10144         MP_WritePhyUshort(sc, 0x06, 0x2dc1);
10145         MP_WritePhyUshort(sc, 0x06, 0xd111);
10146         MP_WritePhyUshort(sc, 0x06, 0xad20);
10147         MP_WritePhyUshort(sc, 0x06, 0x020c);
10148         MP_WritePhyUshort(sc, 0x06, 0x11ad);
10149         MP_WritePhyUshort(sc, 0x06, 0x2102);
10150         MP_WritePhyUshort(sc, 0x06, 0x0c12);
10151         MP_WritePhyUshort(sc, 0x06, 0xbf82);
10152         MP_WritePhyUshort(sc, 0x06, 0xca02);
10153         MP_WritePhyUshort(sc, 0x06, 0x2dc1);
10154         MP_WritePhyUshort(sc, 0x06, 0xaec8);
10155         MP_WritePhyUshort(sc, 0x06, 0x70e4);
10156         MP_WritePhyUshort(sc, 0x06, 0x2602);
10157         MP_WritePhyUshort(sc, 0x06, 0x82d1);
10158         MP_WritePhyUshort(sc, 0x06, 0x05f8);
10159         MP_WritePhyUshort(sc, 0x06, 0xfaef);
10160         MP_WritePhyUshort(sc, 0x06, 0x69e0);
10161         MP_WritePhyUshort(sc, 0x06, 0xe2fe);
10162         MP_WritePhyUshort(sc, 0x06, 0xe1e2);
10163         MP_WritePhyUshort(sc, 0x06, 0xffad);
10164         MP_WritePhyUshort(sc, 0x06, 0x2d1a);
10165         MP_WritePhyUshort(sc, 0x06, 0xe0e1);
10166         MP_WritePhyUshort(sc, 0x06, 0x4ee1);
10167         MP_WritePhyUshort(sc, 0x06, 0xe14f);
10168         MP_WritePhyUshort(sc, 0x06, 0xac2d);
10169         MP_WritePhyUshort(sc, 0x06, 0x22f6);
10170         MP_WritePhyUshort(sc, 0x06, 0x0302);
10171         MP_WritePhyUshort(sc, 0x06, 0x033b);
10172         MP_WritePhyUshort(sc, 0x06, 0xf703);
10173         MP_WritePhyUshort(sc, 0x06, 0xf706);
10174         MP_WritePhyUshort(sc, 0x06, 0xbf84);
10175         MP_WritePhyUshort(sc, 0x06, 0x4402);
10176         MP_WritePhyUshort(sc, 0x06, 0x2d21);
10177         MP_WritePhyUshort(sc, 0x06, 0xae11);
10178         MP_WritePhyUshort(sc, 0x06, 0xe0e1);
10179         MP_WritePhyUshort(sc, 0x06, 0x4ee1);
10180         MP_WritePhyUshort(sc, 0x06, 0xe14f);
10181         MP_WritePhyUshort(sc, 0x06, 0xad2d);
10182         MP_WritePhyUshort(sc, 0x06, 0x08bf);
10183         MP_WritePhyUshort(sc, 0x06, 0x844f);
10184         MP_WritePhyUshort(sc, 0x06, 0x022d);
10185         MP_WritePhyUshort(sc, 0x06, 0x21f6);
10186         MP_WritePhyUshort(sc, 0x06, 0x06ef);
10187         MP_WritePhyUshort(sc, 0x06, 0x96fe);
10188         MP_WritePhyUshort(sc, 0x06, 0xfc04);
10189         MP_WritePhyUshort(sc, 0x06, 0xf8fa);
10190         MP_WritePhyUshort(sc, 0x06, 0xef69);
10191         MP_WritePhyUshort(sc, 0x06, 0x0283);
10192         MP_WritePhyUshort(sc, 0x06, 0x4502);
10193         MP_WritePhyUshort(sc, 0x06, 0x83a2);
10194         MP_WritePhyUshort(sc, 0x06, 0xe0e0);
10195         MP_WritePhyUshort(sc, 0x06, 0x00e1);
10196         MP_WritePhyUshort(sc, 0x06, 0xe001);
10197         MP_WritePhyUshort(sc, 0x06, 0xad27);
10198         MP_WritePhyUshort(sc, 0x06, 0x1fd1);
10199         MP_WritePhyUshort(sc, 0x06, 0x01bf);
10200         MP_WritePhyUshort(sc, 0x06, 0x843b);
10201         MP_WritePhyUshort(sc, 0x06, 0x022d);
10202         MP_WritePhyUshort(sc, 0x06, 0xc1e0);
10203         MP_WritePhyUshort(sc, 0x06, 0xe020);
10204         MP_WritePhyUshort(sc, 0x06, 0xe1e0);
10205         MP_WritePhyUshort(sc, 0x06, 0x21ad);
10206         MP_WritePhyUshort(sc, 0x06, 0x200e);
10207         MP_WritePhyUshort(sc, 0x06, 0xd100);
10208         MP_WritePhyUshort(sc, 0x06, 0xbf84);
10209         MP_WritePhyUshort(sc, 0x06, 0x3b02);
10210         MP_WritePhyUshort(sc, 0x06, 0x2dc1);
10211         MP_WritePhyUshort(sc, 0x06, 0xbf3b);
10212         MP_WritePhyUshort(sc, 0x06, 0x9602);
10213         MP_WritePhyUshort(sc, 0x06, 0x2d21);
10214         MP_WritePhyUshort(sc, 0x06, 0xef96);
10215         MP_WritePhyUshort(sc, 0x06, 0xfefc);
10216         MP_WritePhyUshort(sc, 0x06, 0x04f8);
10217         MP_WritePhyUshort(sc, 0x06, 0xf9fa);
10218         MP_WritePhyUshort(sc, 0x06, 0xef69);
10219         MP_WritePhyUshort(sc, 0x06, 0xe08b);
10220         MP_WritePhyUshort(sc, 0x06, 0x87ad);
10221         MP_WritePhyUshort(sc, 0x06, 0x204c);
10222         MP_WritePhyUshort(sc, 0x06, 0xd200);
10223         MP_WritePhyUshort(sc, 0x06, 0xe0e2);
10224         MP_WritePhyUshort(sc, 0x06, 0x0058);
10225         MP_WritePhyUshort(sc, 0x06, 0x010c);
10226         MP_WritePhyUshort(sc, 0x06, 0x021e);
10227         MP_WritePhyUshort(sc, 0x06, 0x20e0);
10228         MP_WritePhyUshort(sc, 0x06, 0xe000);
10229         MP_WritePhyUshort(sc, 0x06, 0x5810);
10230         MP_WritePhyUshort(sc, 0x06, 0x1e20);
10231         MP_WritePhyUshort(sc, 0x06, 0xe0e0);
10232         MP_WritePhyUshort(sc, 0x06, 0x3658);
10233         MP_WritePhyUshort(sc, 0x06, 0x031e);
10234         MP_WritePhyUshort(sc, 0x06, 0x20e0);
10235         MP_WritePhyUshort(sc, 0x06, 0xe022);
10236         MP_WritePhyUshort(sc, 0x06, 0xe1e0);
10237         MP_WritePhyUshort(sc, 0x06, 0x2358);
10238         MP_WritePhyUshort(sc, 0x06, 0xe01e);
10239         MP_WritePhyUshort(sc, 0x06, 0x20e0);
10240         MP_WritePhyUshort(sc, 0x06, 0x8b64);
10241         MP_WritePhyUshort(sc, 0x06, 0x1f02);
10242         MP_WritePhyUshort(sc, 0x06, 0x9e22);
10243         MP_WritePhyUshort(sc, 0x06, 0xe68b);
10244         MP_WritePhyUshort(sc, 0x06, 0x64ad);
10245         MP_WritePhyUshort(sc, 0x06, 0x3214);
10246         MP_WritePhyUshort(sc, 0x06, 0xad34);
10247         MP_WritePhyUshort(sc, 0x06, 0x11ef);
10248         MP_WritePhyUshort(sc, 0x06, 0x0258);
10249         MP_WritePhyUshort(sc, 0x06, 0x039e);
10250         MP_WritePhyUshort(sc, 0x06, 0x07ad);
10251         MP_WritePhyUshort(sc, 0x06, 0x3508);
10252         MP_WritePhyUshort(sc, 0x06, 0x5ac0);
10253         MP_WritePhyUshort(sc, 0x06, 0x9f04);
10254         MP_WritePhyUshort(sc, 0x06, 0xd101);
10255         MP_WritePhyUshort(sc, 0x06, 0xae02);
10256         MP_WritePhyUshort(sc, 0x06, 0xd100);
10257         MP_WritePhyUshort(sc, 0x06, 0xbf84);
10258         MP_WritePhyUshort(sc, 0x06, 0x3e02);
10259         MP_WritePhyUshort(sc, 0x06, 0x2dc1);
10260         MP_WritePhyUshort(sc, 0x06, 0xef96);
10261         MP_WritePhyUshort(sc, 0x06, 0xfefd);
10262         MP_WritePhyUshort(sc, 0x06, 0xfc04);
10263         MP_WritePhyUshort(sc, 0x06, 0xf8f9);
10264         MP_WritePhyUshort(sc, 0x06, 0xfbe0);
10265         MP_WritePhyUshort(sc, 0x06, 0x8b85);
10266         MP_WritePhyUshort(sc, 0x06, 0xad25);
10267         MP_WritePhyUshort(sc, 0x06, 0x22e0);
10268         MP_WritePhyUshort(sc, 0x06, 0xe022);
10269         MP_WritePhyUshort(sc, 0x06, 0xe1e0);
10270         MP_WritePhyUshort(sc, 0x06, 0x23e2);
10271         MP_WritePhyUshort(sc, 0x06, 0xe036);
10272         MP_WritePhyUshort(sc, 0x06, 0xe3e0);
10273         MP_WritePhyUshort(sc, 0x06, 0x375a);
10274         MP_WritePhyUshort(sc, 0x06, 0xc40d);
10275         MP_WritePhyUshort(sc, 0x06, 0x0158);
10276         MP_WritePhyUshort(sc, 0x06, 0x021e);
10277         MP_WritePhyUshort(sc, 0x06, 0x20e3);
10278         MP_WritePhyUshort(sc, 0x06, 0x8ae7);
10279         MP_WritePhyUshort(sc, 0x06, 0xac31);
10280         MP_WritePhyUshort(sc, 0x06, 0x60ac);
10281         MP_WritePhyUshort(sc, 0x06, 0x3a08);
10282         MP_WritePhyUshort(sc, 0x06, 0xac3e);
10283         MP_WritePhyUshort(sc, 0x06, 0x26ae);
10284         MP_WritePhyUshort(sc, 0x06, 0x67af);
10285         MP_WritePhyUshort(sc, 0x06, 0x8437);
10286         MP_WritePhyUshort(sc, 0x06, 0xad37);
10287         MP_WritePhyUshort(sc, 0x06, 0x61e0);
10288         MP_WritePhyUshort(sc, 0x06, 0x8ae8);
10289         MP_WritePhyUshort(sc, 0x06, 0x10e4);
10290         MP_WritePhyUshort(sc, 0x06, 0x8ae8);
10291         MP_WritePhyUshort(sc, 0x06, 0xe18a);
10292         MP_WritePhyUshort(sc, 0x06, 0xe91b);
10293         MP_WritePhyUshort(sc, 0x06, 0x109e);
10294         MP_WritePhyUshort(sc, 0x06, 0x02ae);
10295         MP_WritePhyUshort(sc, 0x06, 0x51d1);
10296         MP_WritePhyUshort(sc, 0x06, 0x00bf);
10297         MP_WritePhyUshort(sc, 0x06, 0x8441);
10298         MP_WritePhyUshort(sc, 0x06, 0x022d);
10299         MP_WritePhyUshort(sc, 0x06, 0xc1ee);
10300         MP_WritePhyUshort(sc, 0x06, 0x8ae8);
10301         MP_WritePhyUshort(sc, 0x06, 0x00ae);
10302         MP_WritePhyUshort(sc, 0x06, 0x43ad);
10303         MP_WritePhyUshort(sc, 0x06, 0x3627);
10304         MP_WritePhyUshort(sc, 0x06, 0xe08a);
10305         MP_WritePhyUshort(sc, 0x06, 0xeee1);
10306         MP_WritePhyUshort(sc, 0x06, 0x8aef);
10307         MP_WritePhyUshort(sc, 0x06, 0xef74);
10308         MP_WritePhyUshort(sc, 0x06, 0xe08a);
10309         MP_WritePhyUshort(sc, 0x06, 0xeae1);
10310         MP_WritePhyUshort(sc, 0x06, 0x8aeb);
10311         MP_WritePhyUshort(sc, 0x06, 0x1b74);
10312         MP_WritePhyUshort(sc, 0x06, 0x9e2e);
10313         MP_WritePhyUshort(sc, 0x06, 0x14e4);
10314         MP_WritePhyUshort(sc, 0x06, 0x8aea);
10315         MP_WritePhyUshort(sc, 0x06, 0xe58a);
10316         MP_WritePhyUshort(sc, 0x06, 0xebef);
10317         MP_WritePhyUshort(sc, 0x06, 0x74e0);
10318         MP_WritePhyUshort(sc, 0x06, 0x8aee);
10319         MP_WritePhyUshort(sc, 0x06, 0xe18a);
10320         MP_WritePhyUshort(sc, 0x06, 0xef1b);
10321         MP_WritePhyUshort(sc, 0x06, 0x479e);
10322         MP_WritePhyUshort(sc, 0x06, 0x0fae);
10323         MP_WritePhyUshort(sc, 0x06, 0x19ee);
10324         MP_WritePhyUshort(sc, 0x06, 0x8aea);
10325         MP_WritePhyUshort(sc, 0x06, 0x00ee);
10326         MP_WritePhyUshort(sc, 0x06, 0x8aeb);
10327         MP_WritePhyUshort(sc, 0x06, 0x00ae);
10328         MP_WritePhyUshort(sc, 0x06, 0x0fac);
10329         MP_WritePhyUshort(sc, 0x06, 0x390c);
10330         MP_WritePhyUshort(sc, 0x06, 0xd101);
10331         MP_WritePhyUshort(sc, 0x06, 0xbf84);
10332         MP_WritePhyUshort(sc, 0x06, 0x4102);
10333         MP_WritePhyUshort(sc, 0x06, 0x2dc1);
10334         MP_WritePhyUshort(sc, 0x06, 0xee8a);
10335         MP_WritePhyUshort(sc, 0x06, 0xe800);
10336         MP_WritePhyUshort(sc, 0x06, 0xe68a);
10337         MP_WritePhyUshort(sc, 0x06, 0xe7ff);
10338         MP_WritePhyUshort(sc, 0x06, 0xfdfc);
10339         MP_WritePhyUshort(sc, 0x06, 0x0400);
10340         MP_WritePhyUshort(sc, 0x06, 0xe234);
10341         MP_WritePhyUshort(sc, 0x06, 0xcce2);
10342         MP_WritePhyUshort(sc, 0x06, 0x0088);
10343         MP_WritePhyUshort(sc, 0x06, 0xe200);
10344         MP_WritePhyUshort(sc, 0x06, 0xa725);
10345         MP_WritePhyUshort(sc, 0x06, 0xe50a);
10346         MP_WritePhyUshort(sc, 0x06, 0x1de5);
10347         MP_WritePhyUshort(sc, 0x06, 0x0a2c);
10348         MP_WritePhyUshort(sc, 0x06, 0xe50a);
10349         MP_WritePhyUshort(sc, 0x06, 0x6de5);
10350         MP_WritePhyUshort(sc, 0x06, 0x0a1d);
10351         MP_WritePhyUshort(sc, 0x06, 0xe50a);
10352         MP_WritePhyUshort(sc, 0x06, 0x1ce5);
10353         MP_WritePhyUshort(sc, 0x06, 0x0a2d);
10354         MP_WritePhyUshort(sc, 0x06, 0xa755);
10355         MP_WritePhyUshort(sc, 0x05, 0x8b64);
10356         MP_WritePhyUshort(sc, 0x06, 0x0000);
10357         MP_WritePhyUshort(sc, 0x05, 0x8b94);
10358         MP_WritePhyUshort(sc, 0x06, 0x82cd);
10359         MP_WritePhyUshort(sc, 0x05, 0x8b85);
10360         MP_WritePhyUshort(sc, 0x06, 0x2000);
10361         MP_WritePhyUshort(sc, 0x05, 0x8aee);
10362         MP_WritePhyUshort(sc, 0x06, 0x03b8);
10363         MP_WritePhyUshort(sc, 0x05, 0x8ae8);
10364         MP_WritePhyUshort(sc, 0x06, 0x0002);
10365         PhyRegValue = MP_ReadPhyUshort(sc, 0x01);
10366         PhyRegValue |= BIT_0;
10367         MP_WritePhyUshort(sc, 0x01, PhyRegValue);
10368         PhyRegValue = MP_ReadPhyUshort(sc, 0x00);
10369         PhyRegValue |= BIT_0;
10370         MP_WritePhyUshort(sc, 0x00, PhyRegValue);
10371         MP_WritePhyUshort(sc, 0x1f, 0x0);
10372         MP_WritePhyUshort(sc, 0x1f, 0x0005);
10373         for (i=0; i<200; i++) {
10374                 DELAY(100);
10375                 PhyRegValue = MP_ReadPhyUshort(sc, 0x00);
10376                 if (PhyRegValue&0x0080)
10377                         break;
10378         }
10379         MP_WritePhyUshort(sc, 0x1f, 0x0007);
10380         MP_WritePhyUshort(sc, 0x1e, 0x0023);
10381         PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
10382         PhyRegValue &= ~(BIT_0);
10383         if (sc->RequiredSecLanDonglePatch)
10384                 PhyRegValue &= ~(BIT_2);
10385         MP_WritePhyUshort(sc, 0x17, PhyRegValue);
10386         MP_WritePhyUshort(sc, 0x1f, 0x0007);
10387         MP_WritePhyUshort(sc, 0x1e, 0x0028);
10388         MP_WritePhyUshort(sc, 0x15, 0x0010);
10389         MP_WritePhyUshort(sc, 0x1f, 0x0007);
10390         MP_WritePhyUshort(sc, 0x1e, 0x0041);
10391         MP_WritePhyUshort(sc, 0x15, 0x0802);
10392         MP_WritePhyUshort(sc, 0x16, 0x2185);
10393         MP_WritePhyUshort(sc, 0x1f, 0x0000);
10394 }
10395
10396 static void re_set_phy_mcu_8168e_2(struct re_softc *sc)
10397 {
10398         u_int16_t PhyRegValue;
10399         int     i;
10400
10401         if (MP_ReadEfuse(sc, 0x22) == 0x0c) {
10402                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
10403                 MP_WritePhyUshort(sc, 0x00, 0x1800);
10404                 MP_WritePhyUshort(sc, 0x1f, 0x0007);
10405                 MP_WritePhyUshort(sc, 0x1e, 0x0023);
10406                 MP_WritePhyUshort(sc, 0x17, 0x0117);
10407                 MP_WritePhyUshort(sc, 0x1f, 0x0007);
10408                 MP_WritePhyUshort(sc, 0x1E, 0x002C);
10409                 MP_WritePhyUshort(sc, 0x1B, 0x5000);
10410                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
10411                 MP_WritePhyUshort(sc, 0x16, 0x4104);
10412                 for (i=0; i<200; i++) {
10413                         DELAY(100);
10414                         PhyRegValue = MP_ReadPhyUshort(sc, 0x1E);
10415                         PhyRegValue &= 0x03FF;
10416                         if (PhyRegValue== 0x000C)
10417                                 break;
10418                 }
10419                 MP_WritePhyUshort(sc, 0x1f, 0x0005);
10420                 for (i=0; i<200; i++) {
10421                         DELAY(100);
10422                         PhyRegValue = MP_ReadPhyUshort(sc, 0x07);
10423                         if ((PhyRegValue&0x0020)==0)
10424                                 break;
10425                 }
10426                 PhyRegValue = MP_ReadPhyUshort(sc, 0x07);
10427                 if (PhyRegValue & 0x0020) {
10428                         MP_WritePhyUshort(sc, 0x1f, 0x0007);
10429                         MP_WritePhyUshort(sc, 0x1e, 0x00a1);
10430                         MP_WritePhyUshort(sc, 0x17, 0x1000);
10431                         MP_WritePhyUshort(sc, 0x17, 0x0000);
10432                         MP_WritePhyUshort(sc, 0x17, 0x2000);
10433                         MP_WritePhyUshort(sc, 0x1e, 0x002f);
10434                         MP_WritePhyUshort(sc, 0x18, 0x9bfb);
10435                         MP_WritePhyUshort(sc, 0x1f, 0x0005);
10436                         MP_WritePhyUshort(sc, 0x07, 0x0000);
10437                         MP_WritePhyUshort(sc, 0x1f, 0x0000);
10438                 }
10439                 MP_WritePhyUshort(sc, 0x1f, 0x0005);
10440                 MP_WritePhyUshort(sc, 0x05, 0xfff6);
10441                 MP_WritePhyUshort(sc, 0x06, 0x0080);
10442                 PhyRegValue = MP_ReadPhyUshort(sc, 0x00);
10443                 PhyRegValue &= ~(BIT_7);
10444                 MP_WritePhyUshort(sc, 0x00, PhyRegValue);
10445                 MP_WritePhyUshort(sc, 0x1f, 0x0002);
10446                 PhyRegValue = MP_ReadPhyUshort(sc, 0x08);
10447                 PhyRegValue &= ~(BIT_7);
10448                 MP_WritePhyUshort(sc, 0x08, PhyRegValue);
10449                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
10450                 MP_WritePhyUshort(sc, 0x1f, 0x0007);
10451                 MP_WritePhyUshort(sc, 0x1e, 0x0023);
10452                 MP_WritePhyUshort(sc, 0x16, 0x0306);
10453                 MP_WritePhyUshort(sc, 0x16, 0x0307);
10454                 MP_WritePhyUshort(sc, 0x15, 0x000e);
10455                 MP_WritePhyUshort(sc, 0x19, 0x000a);
10456                 MP_WritePhyUshort(sc, 0x15, 0x0010);
10457                 MP_WritePhyUshort(sc, 0x19, 0x0008);
10458                 MP_WritePhyUshort(sc, 0x15, 0x0018);
10459                 MP_WritePhyUshort(sc, 0x19, 0x4801);
10460                 MP_WritePhyUshort(sc, 0x15, 0x0019);
10461                 MP_WritePhyUshort(sc, 0x19, 0x6801);
10462                 MP_WritePhyUshort(sc, 0x15, 0x001a);
10463                 MP_WritePhyUshort(sc, 0x19, 0x66a1);
10464                 MP_WritePhyUshort(sc, 0x15, 0x001f);
10465                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10466                 MP_WritePhyUshort(sc, 0x15, 0x0020);
10467                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10468                 MP_WritePhyUshort(sc, 0x15, 0x0021);
10469                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10470                 MP_WritePhyUshort(sc, 0x15, 0x0022);
10471                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10472                 MP_WritePhyUshort(sc, 0x15, 0x0023);
10473                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10474                 MP_WritePhyUshort(sc, 0x15, 0x0024);
10475                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10476                 MP_WritePhyUshort(sc, 0x15, 0x0025);
10477                 MP_WritePhyUshort(sc, 0x19, 0x64a1);
10478                 MP_WritePhyUshort(sc, 0x15, 0x0026);
10479                 MP_WritePhyUshort(sc, 0x19, 0x40ea);
10480                 MP_WritePhyUshort(sc, 0x15, 0x0027);
10481                 MP_WritePhyUshort(sc, 0x19, 0x4503);
10482                 MP_WritePhyUshort(sc, 0x15, 0x0028);
10483                 MP_WritePhyUshort(sc, 0x19, 0x9f00);
10484                 MP_WritePhyUshort(sc, 0x15, 0x0029);
10485                 MP_WritePhyUshort(sc, 0x19, 0xa631);
10486                 MP_WritePhyUshort(sc, 0x15, 0x002a);
10487                 MP_WritePhyUshort(sc, 0x19, 0x9717);
10488                 MP_WritePhyUshort(sc, 0x15, 0x002b);
10489                 MP_WritePhyUshort(sc, 0x19, 0x302c);
10490                 MP_WritePhyUshort(sc, 0x15, 0x002c);
10491                 MP_WritePhyUshort(sc, 0x19, 0x4802);
10492                 MP_WritePhyUshort(sc, 0x15, 0x002d);
10493                 MP_WritePhyUshort(sc, 0x19, 0x58da);
10494                 MP_WritePhyUshort(sc, 0x15, 0x002e);
10495                 MP_WritePhyUshort(sc, 0x19, 0x400d);
10496                 MP_WritePhyUshort(sc, 0x15, 0x002f);
10497                 MP_WritePhyUshort(sc, 0x19, 0x4488);
10498                 MP_WritePhyUshort(sc, 0x15, 0x0030);
10499                 MP_WritePhyUshort(sc, 0x19, 0x9e00);
10500                 MP_WritePhyUshort(sc, 0x15, 0x0031);
10501                 MP_WritePhyUshort(sc, 0x19, 0x63c8);
10502                 MP_WritePhyUshort(sc, 0x15, 0x0032);
10503                 MP_WritePhyUshort(sc, 0x19, 0x6481);
10504                 MP_WritePhyUshort(sc, 0x15, 0x0033);
10505                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10506                 MP_WritePhyUshort(sc, 0x15, 0x0034);
10507                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10508                 MP_WritePhyUshort(sc, 0x15, 0x0035);
10509                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10510                 MP_WritePhyUshort(sc, 0x15, 0x0036);
10511                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10512                 MP_WritePhyUshort(sc, 0x15, 0x0037);
10513                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10514                 MP_WritePhyUshort(sc, 0x15, 0x0038);
10515                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10516                 MP_WritePhyUshort(sc, 0x15, 0x0039);
10517                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10518                 MP_WritePhyUshort(sc, 0x15, 0x003a);
10519                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10520                 MP_WritePhyUshort(sc, 0x15, 0x003b);
10521                 MP_WritePhyUshort(sc, 0x19, 0x63e8);
10522                 MP_WritePhyUshort(sc, 0x15, 0x003c);
10523                 MP_WritePhyUshort(sc, 0x19, 0x7d00);
10524                 MP_WritePhyUshort(sc, 0x15, 0x003d);
10525                 MP_WritePhyUshort(sc, 0x19, 0x59d4);
10526                 MP_WritePhyUshort(sc, 0x15, 0x003e);
10527                 MP_WritePhyUshort(sc, 0x19, 0x63f8);
10528                 MP_WritePhyUshort(sc, 0x15, 0x0040);
10529                 MP_WritePhyUshort(sc, 0x19, 0x64a1);
10530                 MP_WritePhyUshort(sc, 0x15, 0x0041);
10531                 MP_WritePhyUshort(sc, 0x19, 0x30de);
10532                 MP_WritePhyUshort(sc, 0x15, 0x0044);
10533                 MP_WritePhyUshort(sc, 0x19, 0x480f);
10534                 MP_WritePhyUshort(sc, 0x15, 0x0045);
10535                 MP_WritePhyUshort(sc, 0x19, 0x6800);
10536                 MP_WritePhyUshort(sc, 0x15, 0x0046);
10537                 MP_WritePhyUshort(sc, 0x19, 0x6680);
10538                 MP_WritePhyUshort(sc, 0x15, 0x0047);
10539                 MP_WritePhyUshort(sc, 0x19, 0x7c10);
10540                 MP_WritePhyUshort(sc, 0x15, 0x0048);
10541                 MP_WritePhyUshort(sc, 0x19, 0x63c8);
10542                 MP_WritePhyUshort(sc, 0x15, 0x0049);
10543                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10544                 MP_WritePhyUshort(sc, 0x15, 0x004a);
10545                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10546                 MP_WritePhyUshort(sc, 0x15, 0x004b);
10547                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10548                 MP_WritePhyUshort(sc, 0x15, 0x004c);
10549                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10550                 MP_WritePhyUshort(sc, 0x15, 0x004d);
10551                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10552                 MP_WritePhyUshort(sc, 0x15, 0x004e);
10553                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10554                 MP_WritePhyUshort(sc, 0x15, 0x004f);
10555                 MP_WritePhyUshort(sc, 0x19, 0x40ea);
10556                 MP_WritePhyUshort(sc, 0x15, 0x0050);
10557                 MP_WritePhyUshort(sc, 0x19, 0x4503);
10558                 MP_WritePhyUshort(sc, 0x15, 0x0051);
10559                 MP_WritePhyUshort(sc, 0x19, 0x58ca);
10560                 MP_WritePhyUshort(sc, 0x15, 0x0052);
10561                 MP_WritePhyUshort(sc, 0x19, 0x63c8);
10562                 MP_WritePhyUshort(sc, 0x15, 0x0053);
10563                 MP_WritePhyUshort(sc, 0x19, 0x63d8);
10564                 MP_WritePhyUshort(sc, 0x15, 0x0054);
10565                 MP_WritePhyUshort(sc, 0x19, 0x66a0);
10566                 MP_WritePhyUshort(sc, 0x15, 0x0055);
10567                 MP_WritePhyUshort(sc, 0x19, 0x9f00);
10568                 MP_WritePhyUshort(sc, 0x15, 0x0056);
10569                 MP_WritePhyUshort(sc, 0x19, 0x3000);
10570                 MP_WritePhyUshort(sc, 0x15, 0x00a1);
10571                 MP_WritePhyUshort(sc, 0x19, 0x3044);
10572                 MP_WritePhyUshort(sc, 0x15, 0x00ab);
10573                 MP_WritePhyUshort(sc, 0x19, 0x5820);
10574                 MP_WritePhyUshort(sc, 0x15, 0x00ac);
10575                 MP_WritePhyUshort(sc, 0x19, 0x5e04);
10576                 MP_WritePhyUshort(sc, 0x15, 0x00ad);
10577                 MP_WritePhyUshort(sc, 0x19, 0xb60c);
10578                 MP_WritePhyUshort(sc, 0x15, 0x00af);
10579                 MP_WritePhyUshort(sc, 0x19, 0x000a);
10580                 MP_WritePhyUshort(sc, 0x15, 0x00b2);
10581                 MP_WritePhyUshort(sc, 0x19, 0x30b9);
10582                 MP_WritePhyUshort(sc, 0x15, 0x00b9);
10583                 MP_WritePhyUshort(sc, 0x19, 0x4408);
10584                 MP_WritePhyUshort(sc, 0x15, 0x00ba);
10585                 MP_WritePhyUshort(sc, 0x19, 0x480b);
10586                 MP_WritePhyUshort(sc, 0x15, 0x00bb);
10587                 MP_WritePhyUshort(sc, 0x19, 0x5e00);
10588                 MP_WritePhyUshort(sc, 0x15, 0x00bc);
10589                 MP_WritePhyUshort(sc, 0x19, 0x405f);
10590                 MP_WritePhyUshort(sc, 0x15, 0x00bd);
10591                 MP_WritePhyUshort(sc, 0x19, 0x4448);
10592                 MP_WritePhyUshort(sc, 0x15, 0x00be);
10593                 MP_WritePhyUshort(sc, 0x19, 0x4020);
10594                 MP_WritePhyUshort(sc, 0x15, 0x00bf);
10595                 MP_WritePhyUshort(sc, 0x19, 0x4468);
10596                 MP_WritePhyUshort(sc, 0x15, 0x00c0);
10597                 MP_WritePhyUshort(sc, 0x19, 0x9c02);
10598                 MP_WritePhyUshort(sc, 0x15, 0x00c1);
10599                 MP_WritePhyUshort(sc, 0x19, 0x58a0);
10600                 MP_WritePhyUshort(sc, 0x15, 0x00c2);
10601                 MP_WritePhyUshort(sc, 0x19, 0xb605);
10602                 MP_WritePhyUshort(sc, 0x15, 0x00c3);
10603                 MP_WritePhyUshort(sc, 0x19, 0xc0d3);
10604                 MP_WritePhyUshort(sc, 0x15, 0x00c4);
10605                 MP_WritePhyUshort(sc, 0x19, 0x00e6);
10606                 MP_WritePhyUshort(sc, 0x15, 0x00c5);
10607                 MP_WritePhyUshort(sc, 0x19, 0xdaec);
10608                 MP_WritePhyUshort(sc, 0x15, 0x00c6);
10609                 MP_WritePhyUshort(sc, 0x19, 0x00fa);
10610                 MP_WritePhyUshort(sc, 0x15, 0x00c7);
10611                 MP_WritePhyUshort(sc, 0x19, 0x9df9);
10612                 MP_WritePhyUshort(sc, 0x15, 0x0112);
10613                 MP_WritePhyUshort(sc, 0x19, 0x6421);
10614                 MP_WritePhyUshort(sc, 0x15, 0x0113);
10615                 MP_WritePhyUshort(sc, 0x19, 0x7c08);
10616                 MP_WritePhyUshort(sc, 0x15, 0x0114);
10617                 MP_WritePhyUshort(sc, 0x19, 0x63f0);
10618                 MP_WritePhyUshort(sc, 0x15, 0x0115);
10619                 MP_WritePhyUshort(sc, 0x19, 0x4003);
10620                 MP_WritePhyUshort(sc, 0x15, 0x0116);
10621                 MP_WritePhyUshort(sc, 0x19, 0x4418);
10622                 MP_WritePhyUshort(sc, 0x15, 0x0117);
10623                 MP_WritePhyUshort(sc, 0x19, 0x9b00);
10624                 MP_WritePhyUshort(sc, 0x15, 0x0118);
10625                 MP_WritePhyUshort(sc, 0x19, 0x6461);
10626                 MP_WritePhyUshort(sc, 0x15, 0x0119);
10627                 MP_WritePhyUshort(sc, 0x19, 0x64e1);
10628                 MP_WritePhyUshort(sc, 0x15, 0x011a);
10629                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10630                 MP_WritePhyUshort(sc, 0x15, 0x0150);
10631                 MP_WritePhyUshort(sc, 0x19, 0x7c80);
10632                 MP_WritePhyUshort(sc, 0x15, 0x0151);
10633                 MP_WritePhyUshort(sc, 0x19, 0x6461);
10634                 MP_WritePhyUshort(sc, 0x15, 0x0152);
10635                 MP_WritePhyUshort(sc, 0x19, 0x4003);
10636                 MP_WritePhyUshort(sc, 0x15, 0x0153);
10637                 MP_WritePhyUshort(sc, 0x19, 0x4540);
10638                 MP_WritePhyUshort(sc, 0x15, 0x0154);
10639                 MP_WritePhyUshort(sc, 0x19, 0x9f00);
10640                 MP_WritePhyUshort(sc, 0x15, 0x0155);
10641                 MP_WritePhyUshort(sc, 0x19, 0x9d00);
10642                 MP_WritePhyUshort(sc, 0x15, 0x0156);
10643                 MP_WritePhyUshort(sc, 0x19, 0x7c40);
10644                 MP_WritePhyUshort(sc, 0x15, 0x0157);
10645                 MP_WritePhyUshort(sc, 0x19, 0x6421);
10646                 MP_WritePhyUshort(sc, 0x15, 0x0158);
10647                 MP_WritePhyUshort(sc, 0x19, 0x7c80);
10648                 MP_WritePhyUshort(sc, 0x15, 0x0159);
10649                 MP_WritePhyUshort(sc, 0x19, 0x64a1);
10650                 MP_WritePhyUshort(sc, 0x15, 0x015a);
10651                 MP_WritePhyUshort(sc, 0x19, 0x30fe);
10652                 MP_WritePhyUshort(sc, 0x15, 0x029c);
10653                 MP_WritePhyUshort(sc, 0x19, 0x0070);
10654                 MP_WritePhyUshort(sc, 0x15, 0x02b2);
10655                 MP_WritePhyUshort(sc, 0x19, 0x005a);
10656                 MP_WritePhyUshort(sc, 0x15, 0x02bd);
10657                 MP_WritePhyUshort(sc, 0x19, 0xa522);
10658                 MP_WritePhyUshort(sc, 0x15, 0x02ce);
10659                 MP_WritePhyUshort(sc, 0x19, 0xb63e);
10660                 MP_WritePhyUshort(sc, 0x15, 0x02d9);
10661                 MP_WritePhyUshort(sc, 0x19, 0x32df);
10662                 MP_WritePhyUshort(sc, 0x15, 0x02df);
10663                 MP_WritePhyUshort(sc, 0x19, 0x4500);
10664                 MP_WritePhyUshort(sc, 0x15, 0x02e7);
10665                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10666                 MP_WritePhyUshort(sc, 0x15, 0x02f4);
10667                 MP_WritePhyUshort(sc, 0x19, 0xb618);
10668                 MP_WritePhyUshort(sc, 0x15, 0x02fb);
10669                 MP_WritePhyUshort(sc, 0x19, 0xb900);
10670                 MP_WritePhyUshort(sc, 0x15, 0x02fc);
10671                 MP_WritePhyUshort(sc, 0x19, 0x49b5);
10672                 MP_WritePhyUshort(sc, 0x15, 0x02fd);
10673                 MP_WritePhyUshort(sc, 0x19, 0x6812);
10674                 MP_WritePhyUshort(sc, 0x15, 0x02fe);
10675                 MP_WritePhyUshort(sc, 0x19, 0x66a0);
10676                 MP_WritePhyUshort(sc, 0x15, 0x02ff);
10677                 MP_WritePhyUshort(sc, 0x19, 0x9900);
10678                 MP_WritePhyUshort(sc, 0x15, 0x0300);
10679                 MP_WritePhyUshort(sc, 0x19, 0x64a0);
10680                 MP_WritePhyUshort(sc, 0x15, 0x0301);
10681                 MP_WritePhyUshort(sc, 0x19, 0x3316);
10682                 MP_WritePhyUshort(sc, 0x15, 0x0308);
10683                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10684                 MP_WritePhyUshort(sc, 0x15, 0x030c);
10685                 MP_WritePhyUshort(sc, 0x19, 0x3000);
10686                 MP_WritePhyUshort(sc, 0x15, 0x0312);
10687                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10688                 MP_WritePhyUshort(sc, 0x15, 0x0313);
10689                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10690                 MP_WritePhyUshort(sc, 0x15, 0x0314);
10691                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10692                 MP_WritePhyUshort(sc, 0x15, 0x0315);
10693                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10694                 MP_WritePhyUshort(sc, 0x15, 0x0316);
10695                 MP_WritePhyUshort(sc, 0x19, 0x49b5);
10696                 MP_WritePhyUshort(sc, 0x15, 0x0317);
10697                 MP_WritePhyUshort(sc, 0x19, 0x7d00);
10698                 MP_WritePhyUshort(sc, 0x15, 0x0318);
10699                 MP_WritePhyUshort(sc, 0x19, 0x4d00);
10700                 MP_WritePhyUshort(sc, 0x15, 0x0319);
10701                 MP_WritePhyUshort(sc, 0x19, 0x6810);
10702                 MP_WritePhyUshort(sc, 0x15, 0x031a);
10703                 MP_WritePhyUshort(sc, 0x19, 0x6c08);
10704                 MP_WritePhyUshort(sc, 0x15, 0x031b);
10705                 MP_WritePhyUshort(sc, 0x19, 0x4925);
10706                 MP_WritePhyUshort(sc, 0x15, 0x031c);
10707                 MP_WritePhyUshort(sc, 0x19, 0x403b);
10708                 MP_WritePhyUshort(sc, 0x15, 0x031d);
10709                 MP_WritePhyUshort(sc, 0x19, 0xa602);
10710                 MP_WritePhyUshort(sc, 0x15, 0x031e);
10711                 MP_WritePhyUshort(sc, 0x19, 0x402f);
10712                 MP_WritePhyUshort(sc, 0x15, 0x031f);
10713                 MP_WritePhyUshort(sc, 0x19, 0x4484);
10714                 MP_WritePhyUshort(sc, 0x15, 0x0320);
10715                 MP_WritePhyUshort(sc, 0x19, 0x40c8);
10716                 MP_WritePhyUshort(sc, 0x15, 0x0321);
10717                 MP_WritePhyUshort(sc, 0x19, 0x44c4);
10718                 MP_WritePhyUshort(sc, 0x15, 0x0322);
10719                 MP_WritePhyUshort(sc, 0x19, 0x404f);
10720                 MP_WritePhyUshort(sc, 0x15, 0x0323);
10721                 MP_WritePhyUshort(sc, 0x19, 0x44c8);
10722                 MP_WritePhyUshort(sc, 0x15, 0x0324);
10723                 MP_WritePhyUshort(sc, 0x19, 0xd64f);
10724                 MP_WritePhyUshort(sc, 0x15, 0x0325);
10725                 MP_WritePhyUshort(sc, 0x19, 0x00e7);
10726                 MP_WritePhyUshort(sc, 0x15, 0x0326);
10727                 MP_WritePhyUshort(sc, 0x19, 0x7c08);
10728                 MP_WritePhyUshort(sc, 0x15, 0x0327);
10729                 MP_WritePhyUshort(sc, 0x19, 0x8203);
10730                 MP_WritePhyUshort(sc, 0x15, 0x0328);
10731                 MP_WritePhyUshort(sc, 0x19, 0x4d48);
10732                 MP_WritePhyUshort(sc, 0x15, 0x0329);
10733                 MP_WritePhyUshort(sc, 0x19, 0x332b);
10734                 MP_WritePhyUshort(sc, 0x15, 0x032a);
10735                 MP_WritePhyUshort(sc, 0x19, 0x4d40);
10736                 MP_WritePhyUshort(sc, 0x15, 0x032c);
10737                 MP_WritePhyUshort(sc, 0x19, 0x00f8);
10738                 MP_WritePhyUshort(sc, 0x15, 0x032d);
10739                 MP_WritePhyUshort(sc, 0x19, 0x82b2);
10740                 MP_WritePhyUshort(sc, 0x15, 0x032f);
10741                 MP_WritePhyUshort(sc, 0x19, 0x00b0);
10742                 MP_WritePhyUshort(sc, 0x15, 0x0332);
10743                 MP_WritePhyUshort(sc, 0x19, 0x91f2);
10744                 MP_WritePhyUshort(sc, 0x15, 0x033f);
10745                 MP_WritePhyUshort(sc, 0x19, 0xb6cd);
10746                 MP_WritePhyUshort(sc, 0x15, 0x0340);
10747                 MP_WritePhyUshort(sc, 0x19, 0x9e01);
10748                 MP_WritePhyUshort(sc, 0x15, 0x0341);
10749                 MP_WritePhyUshort(sc, 0x19, 0xd11d);
10750                 MP_WritePhyUshort(sc, 0x15, 0x0342);
10751                 MP_WritePhyUshort(sc, 0x19, 0x009d);
10752                 MP_WritePhyUshort(sc, 0x15, 0x0343);
10753                 MP_WritePhyUshort(sc, 0x19, 0xbb1c);
10754                 MP_WritePhyUshort(sc, 0x15, 0x0344);
10755                 MP_WritePhyUshort(sc, 0x19, 0x8102);
10756                 MP_WritePhyUshort(sc, 0x15, 0x0345);
10757                 MP_WritePhyUshort(sc, 0x19, 0x3348);
10758                 MP_WritePhyUshort(sc, 0x15, 0x0346);
10759                 MP_WritePhyUshort(sc, 0x19, 0xa231);
10760                 MP_WritePhyUshort(sc, 0x15, 0x0347);
10761                 MP_WritePhyUshort(sc, 0x19, 0x335b);
10762                 MP_WritePhyUshort(sc, 0x15, 0x0348);
10763                 MP_WritePhyUshort(sc, 0x19, 0x91f7);
10764                 MP_WritePhyUshort(sc, 0x15, 0x0349);
10765                 MP_WritePhyUshort(sc, 0x19, 0xc218);
10766                 MP_WritePhyUshort(sc, 0x15, 0x034a);
10767                 MP_WritePhyUshort(sc, 0x19, 0x00f5);
10768                 MP_WritePhyUshort(sc, 0x15, 0x034b);
10769                 MP_WritePhyUshort(sc, 0x19, 0x335b);
10770                 MP_WritePhyUshort(sc, 0x15, 0x034c);
10771                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10772                 MP_WritePhyUshort(sc, 0x15, 0x034d);
10773                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10774                 MP_WritePhyUshort(sc, 0x15, 0x034e);
10775                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10776                 MP_WritePhyUshort(sc, 0x15, 0x034f);
10777                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10778                 MP_WritePhyUshort(sc, 0x15, 0x0350);
10779                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10780                 MP_WritePhyUshort(sc, 0x15, 0x035b);
10781                 MP_WritePhyUshort(sc, 0x19, 0xa23c);
10782                 MP_WritePhyUshort(sc, 0x15, 0x035c);
10783                 MP_WritePhyUshort(sc, 0x19, 0x7c08);
10784                 MP_WritePhyUshort(sc, 0x15, 0x035d);
10785                 MP_WritePhyUshort(sc, 0x19, 0x4c00);
10786                 MP_WritePhyUshort(sc, 0x15, 0x035e);
10787                 MP_WritePhyUshort(sc, 0x19, 0x3397);
10788                 MP_WritePhyUshort(sc, 0x15, 0x0363);
10789                 MP_WritePhyUshort(sc, 0x19, 0xb6a9);
10790                 MP_WritePhyUshort(sc, 0x15, 0x0366);
10791                 MP_WritePhyUshort(sc, 0x19, 0x00f5);
10792                 MP_WritePhyUshort(sc, 0x15, 0x0382);
10793                 MP_WritePhyUshort(sc, 0x19, 0x7c40);
10794                 MP_WritePhyUshort(sc, 0x15, 0x0388);
10795                 MP_WritePhyUshort(sc, 0x19, 0x0084);
10796                 MP_WritePhyUshort(sc, 0x15, 0x0389);
10797                 MP_WritePhyUshort(sc, 0x19, 0xdd17);
10798                 MP_WritePhyUshort(sc, 0x15, 0x038a);
10799                 MP_WritePhyUshort(sc, 0x19, 0x000b);
10800                 MP_WritePhyUshort(sc, 0x15, 0x038b);
10801                 MP_WritePhyUshort(sc, 0x19, 0xa10a);
10802                 MP_WritePhyUshort(sc, 0x15, 0x038c);
10803                 MP_WritePhyUshort(sc, 0x19, 0x337e);
10804                 MP_WritePhyUshort(sc, 0x15, 0x038d);
10805                 MP_WritePhyUshort(sc, 0x19, 0x6c0b);
10806                 MP_WritePhyUshort(sc, 0x15, 0x038e);
10807                 MP_WritePhyUshort(sc, 0x19, 0xa107);
10808                 MP_WritePhyUshort(sc, 0x15, 0x038f);
10809                 MP_WritePhyUshort(sc, 0x19, 0x6c08);
10810                 MP_WritePhyUshort(sc, 0x15, 0x0390);
10811                 MP_WritePhyUshort(sc, 0x19, 0xc017);
10812                 MP_WritePhyUshort(sc, 0x15, 0x0391);
10813                 MP_WritePhyUshort(sc, 0x19, 0x0004);
10814                 MP_WritePhyUshort(sc, 0x15, 0x0392);
10815                 MP_WritePhyUshort(sc, 0x19, 0xd64f);
10816                 MP_WritePhyUshort(sc, 0x15, 0x0393);
10817                 MP_WritePhyUshort(sc, 0x19, 0x00f4);
10818                 MP_WritePhyUshort(sc, 0x15, 0x0397);
10819                 MP_WritePhyUshort(sc, 0x19, 0x4098);
10820                 MP_WritePhyUshort(sc, 0x15, 0x0398);
10821                 MP_WritePhyUshort(sc, 0x19, 0x4408);
10822                 MP_WritePhyUshort(sc, 0x15, 0x0399);
10823                 MP_WritePhyUshort(sc, 0x19, 0x55bf);
10824                 MP_WritePhyUshort(sc, 0x15, 0x039a);
10825                 MP_WritePhyUshort(sc, 0x19, 0x4bb9);
10826                 MP_WritePhyUshort(sc, 0x15, 0x039b);
10827                 MP_WritePhyUshort(sc, 0x19, 0x6810);
10828                 MP_WritePhyUshort(sc, 0x15, 0x039c);
10829                 MP_WritePhyUshort(sc, 0x19, 0x4b29);
10830                 MP_WritePhyUshort(sc, 0x15, 0x039d);
10831                 MP_WritePhyUshort(sc, 0x19, 0x4041);
10832                 MP_WritePhyUshort(sc, 0x15, 0x039e);
10833                 MP_WritePhyUshort(sc, 0x19, 0x442a);
10834                 MP_WritePhyUshort(sc, 0x15, 0x039f);
10835                 MP_WritePhyUshort(sc, 0x19, 0x4029);
10836                 MP_WritePhyUshort(sc, 0x15, 0x03aa);
10837                 MP_WritePhyUshort(sc, 0x19, 0x33b8);
10838                 MP_WritePhyUshort(sc, 0x15, 0x03b6);
10839                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10840                 MP_WritePhyUshort(sc, 0x15, 0x03b7);
10841                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10842                 MP_WritePhyUshort(sc, 0x15, 0x03b8);
10843                 MP_WritePhyUshort(sc, 0x19, 0x543f);
10844                 MP_WritePhyUshort(sc, 0x15, 0x03b9);
10845                 MP_WritePhyUshort(sc, 0x19, 0x499a);
10846                 MP_WritePhyUshort(sc, 0x15, 0x03ba);
10847                 MP_WritePhyUshort(sc, 0x19, 0x7c40);
10848                 MP_WritePhyUshort(sc, 0x15, 0x03bb);
10849                 MP_WritePhyUshort(sc, 0x19, 0x4c40);
10850                 MP_WritePhyUshort(sc, 0x15, 0x03bc);
10851                 MP_WritePhyUshort(sc, 0x19, 0x490a);
10852                 MP_WritePhyUshort(sc, 0x15, 0x03bd);
10853                 MP_WritePhyUshort(sc, 0x19, 0x405e);
10854                 MP_WritePhyUshort(sc, 0x15, 0x03c2);
10855                 MP_WritePhyUshort(sc, 0x19, 0x9a03);
10856                 MP_WritePhyUshort(sc, 0x15, 0x03c4);
10857                 MP_WritePhyUshort(sc, 0x19, 0x0015);
10858                 MP_WritePhyUshort(sc, 0x15, 0x03c5);
10859                 MP_WritePhyUshort(sc, 0x19, 0x9e03);
10860                 MP_WritePhyUshort(sc, 0x15, 0x03c8);
10861                 MP_WritePhyUshort(sc, 0x19, 0x9cf7);
10862                 MP_WritePhyUshort(sc, 0x15, 0x03c9);
10863                 MP_WritePhyUshort(sc, 0x19, 0x7c12);
10864                 MP_WritePhyUshort(sc, 0x15, 0x03ca);
10865                 MP_WritePhyUshort(sc, 0x19, 0x4c52);
10866                 MP_WritePhyUshort(sc, 0x15, 0x03cb);
10867                 MP_WritePhyUshort(sc, 0x19, 0x4458);
10868                 MP_WritePhyUshort(sc, 0x15, 0x03cd);
10869                 MP_WritePhyUshort(sc, 0x19, 0x4c40);
10870                 MP_WritePhyUshort(sc, 0x15, 0x03ce);
10871                 MP_WritePhyUshort(sc, 0x19, 0x33bf);
10872                 MP_WritePhyUshort(sc, 0x15, 0x03cf);
10873                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10874                 MP_WritePhyUshort(sc, 0x15, 0x03d0);
10875                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10876                 MP_WritePhyUshort(sc, 0x15, 0x03d1);
10877                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10878                 MP_WritePhyUshort(sc, 0x15, 0x03d5);
10879                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10880                 MP_WritePhyUshort(sc, 0x15, 0x03d6);
10881                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10882                 MP_WritePhyUshort(sc, 0x15, 0x03d7);
10883                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10884                 MP_WritePhyUshort(sc, 0x15, 0x03d8);
10885                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10886                 MP_WritePhyUshort(sc, 0x15, 0x03d9);
10887                 MP_WritePhyUshort(sc, 0x19, 0x49bb);
10888                 MP_WritePhyUshort(sc, 0x15, 0x03da);
10889                 MP_WritePhyUshort(sc, 0x19, 0x4478);
10890                 MP_WritePhyUshort(sc, 0x15, 0x03db);
10891                 MP_WritePhyUshort(sc, 0x19, 0x492b);
10892                 MP_WritePhyUshort(sc, 0x15, 0x03dc);
10893                 MP_WritePhyUshort(sc, 0x19, 0x7c01);
10894                 MP_WritePhyUshort(sc, 0x15, 0x03dd);
10895                 MP_WritePhyUshort(sc, 0x19, 0x4c00);
10896                 MP_WritePhyUshort(sc, 0x15, 0x03de);
10897                 MP_WritePhyUshort(sc, 0x19, 0xbd1a);
10898                 MP_WritePhyUshort(sc, 0x15, 0x03df);
10899                 MP_WritePhyUshort(sc, 0x19, 0xc428);
10900                 MP_WritePhyUshort(sc, 0x15, 0x03e0);
10901                 MP_WritePhyUshort(sc, 0x19, 0x0008);
10902                 MP_WritePhyUshort(sc, 0x15, 0x03e1);
10903                 MP_WritePhyUshort(sc, 0x19, 0x9cfd);
10904                 MP_WritePhyUshort(sc, 0x15, 0x03e2);
10905                 MP_WritePhyUshort(sc, 0x19, 0x7c12);
10906                 MP_WritePhyUshort(sc, 0x15, 0x03e3);
10907                 MP_WritePhyUshort(sc, 0x19, 0x4c52);
10908                 MP_WritePhyUshort(sc, 0x15, 0x03e4);
10909                 MP_WritePhyUshort(sc, 0x19, 0x4458);
10910                 MP_WritePhyUshort(sc, 0x15, 0x03e5);
10911                 MP_WritePhyUshort(sc, 0x19, 0x7c12);
10912                 MP_WritePhyUshort(sc, 0x15, 0x03e6);
10913                 MP_WritePhyUshort(sc, 0x19, 0x4c40);
10914                 MP_WritePhyUshort(sc, 0x15, 0x03e7);
10915                 MP_WritePhyUshort(sc, 0x19, 0x33de);
10916                 MP_WritePhyUshort(sc, 0x15, 0x03e8);
10917                 MP_WritePhyUshort(sc, 0x19, 0xc218);
10918                 MP_WritePhyUshort(sc, 0x15, 0x03e9);
10919                 MP_WritePhyUshort(sc, 0x19, 0x0002);
10920                 MP_WritePhyUshort(sc, 0x15, 0x03ea);
10921                 MP_WritePhyUshort(sc, 0x19, 0x32df);
10922                 MP_WritePhyUshort(sc, 0x15, 0x03eb);
10923                 MP_WritePhyUshort(sc, 0x19, 0x3316);
10924                 MP_WritePhyUshort(sc, 0x15, 0x03ec);
10925                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10926                 MP_WritePhyUshort(sc, 0x15, 0x03ed);
10927                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10928                 MP_WritePhyUshort(sc, 0x15, 0x03ee);
10929                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10930                 MP_WritePhyUshort(sc, 0x15, 0x03ef);
10931                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10932                 MP_WritePhyUshort(sc, 0x15, 0x03f7);
10933                 MP_WritePhyUshort(sc, 0x19, 0x330c);
10934                 MP_WritePhyUshort(sc, 0x16, 0x0306);
10935                 MP_WritePhyUshort(sc, 0x16, 0x0300);
10936                 MP_WritePhyUshort(sc, 0x1f, 0x0005);
10937                 MP_WritePhyUshort(sc, 0x05, 0xfff6);
10938                 MP_WritePhyUshort(sc, 0x06, 0x0080);
10939                 MP_WritePhyUshort(sc, 0x05, 0x8000);
10940                 MP_WritePhyUshort(sc, 0x06, 0x0280);
10941                 MP_WritePhyUshort(sc, 0x06, 0x48f7);
10942                 MP_WritePhyUshort(sc, 0x06, 0x00e0);
10943                 MP_WritePhyUshort(sc, 0x06, 0xfff7);
10944                 MP_WritePhyUshort(sc, 0x06, 0xa080);
10945                 MP_WritePhyUshort(sc, 0x06, 0x02ae);
10946                 MP_WritePhyUshort(sc, 0x06, 0xf602);
10947                 MP_WritePhyUshort(sc, 0x06, 0x0200);
10948                 MP_WritePhyUshort(sc, 0x06, 0x0280);
10949                 MP_WritePhyUshort(sc, 0x06, 0x9002);
10950                 MP_WritePhyUshort(sc, 0x06, 0x0224);
10951                 MP_WritePhyUshort(sc, 0x06, 0x0202);
10952                 MP_WritePhyUshort(sc, 0x06, 0x3402);
10953                 MP_WritePhyUshort(sc, 0x06, 0x027f);
10954                 MP_WritePhyUshort(sc, 0x06, 0x0280);
10955                 MP_WritePhyUshort(sc, 0x06, 0xa602);
10956                 MP_WritePhyUshort(sc, 0x06, 0x80bf);
10957                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
10958                 MP_WritePhyUshort(sc, 0x06, 0x88e1);
10959                 MP_WritePhyUshort(sc, 0x06, 0x8b89);
10960                 MP_WritePhyUshort(sc, 0x06, 0x1e01);
10961                 MP_WritePhyUshort(sc, 0x06, 0xe18b);
10962                 MP_WritePhyUshort(sc, 0x06, 0x8a1e);
10963                 MP_WritePhyUshort(sc, 0x06, 0x01e1);
10964                 MP_WritePhyUshort(sc, 0x06, 0x8b8b);
10965                 MP_WritePhyUshort(sc, 0x06, 0x1e01);
10966                 MP_WritePhyUshort(sc, 0x06, 0xe18b);
10967                 MP_WritePhyUshort(sc, 0x06, 0x8c1e);
10968                 MP_WritePhyUshort(sc, 0x06, 0x01e1);
10969                 MP_WritePhyUshort(sc, 0x06, 0x8b8d);
10970                 MP_WritePhyUshort(sc, 0x06, 0x1e01);
10971                 MP_WritePhyUshort(sc, 0x06, 0xe18b);
10972                 MP_WritePhyUshort(sc, 0x06, 0x8e1e);
10973                 MP_WritePhyUshort(sc, 0x06, 0x01a0);
10974                 MP_WritePhyUshort(sc, 0x06, 0x00c7);
10975                 MP_WritePhyUshort(sc, 0x06, 0xaebb);
10976                 MP_WritePhyUshort(sc, 0x06, 0xee8a);
10977                 MP_WritePhyUshort(sc, 0x06, 0xe600);
10978                 MP_WritePhyUshort(sc, 0x06, 0xee8a);
10979                 MP_WritePhyUshort(sc, 0x06, 0xee03);
10980                 MP_WritePhyUshort(sc, 0x06, 0xee8a);
10981                 MP_WritePhyUshort(sc, 0x06, 0xefb8);
10982                 MP_WritePhyUshort(sc, 0x06, 0xee8a);
10983                 MP_WritePhyUshort(sc, 0x06, 0xe902);
10984                 MP_WritePhyUshort(sc, 0x06, 0xee8b);
10985                 MP_WritePhyUshort(sc, 0x06, 0x8285);
10986                 MP_WritePhyUshort(sc, 0x06, 0xee8b);
10987                 MP_WritePhyUshort(sc, 0x06, 0x8520);
10988                 MP_WritePhyUshort(sc, 0x06, 0xee8b);
10989                 MP_WritePhyUshort(sc, 0x06, 0x8701);
10990                 MP_WritePhyUshort(sc, 0x06, 0xd481);
10991                 MP_WritePhyUshort(sc, 0x06, 0x35e4);
10992                 MP_WritePhyUshort(sc, 0x06, 0x8b94);
10993                 MP_WritePhyUshort(sc, 0x06, 0xe58b);
10994                 MP_WritePhyUshort(sc, 0x06, 0x95bf);
10995                 MP_WritePhyUshort(sc, 0x06, 0x8b88);
10996                 MP_WritePhyUshort(sc, 0x06, 0xec00);
10997                 MP_WritePhyUshort(sc, 0x06, 0x19a9);
10998                 MP_WritePhyUshort(sc, 0x06, 0x8b90);
10999                 MP_WritePhyUshort(sc, 0x06, 0xf9ee);
11000                 MP_WritePhyUshort(sc, 0x06, 0xfff6);
11001                 MP_WritePhyUshort(sc, 0x06, 0x00ee);
11002                 MP_WritePhyUshort(sc, 0x06, 0xfff7);
11003                 MP_WritePhyUshort(sc, 0x06, 0xffe0);
11004                 MP_WritePhyUshort(sc, 0x06, 0xe140);
11005                 MP_WritePhyUshort(sc, 0x06, 0xe1e1);
11006                 MP_WritePhyUshort(sc, 0x06, 0x41f7);
11007                 MP_WritePhyUshort(sc, 0x06, 0x2ff6);
11008                 MP_WritePhyUshort(sc, 0x06, 0x28e4);
11009                 MP_WritePhyUshort(sc, 0x06, 0xe140);
11010                 MP_WritePhyUshort(sc, 0x06, 0xe5e1);
11011                 MP_WritePhyUshort(sc, 0x06, 0x4104);
11012                 MP_WritePhyUshort(sc, 0x06, 0xf8e0);
11013                 MP_WritePhyUshort(sc, 0x06, 0x8b89);
11014                 MP_WritePhyUshort(sc, 0x06, 0xad20);
11015                 MP_WritePhyUshort(sc, 0x06, 0x0dee);
11016                 MP_WritePhyUshort(sc, 0x06, 0x8b89);
11017                 MP_WritePhyUshort(sc, 0x06, 0x0002);
11018                 MP_WritePhyUshort(sc, 0x06, 0x82f4);
11019                 MP_WritePhyUshort(sc, 0x06, 0x021f);
11020                 MP_WritePhyUshort(sc, 0x06, 0x4102);
11021                 MP_WritePhyUshort(sc, 0x06, 0x2812);
11022                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
11023                 MP_WritePhyUshort(sc, 0x06, 0xf8e0);
11024                 MP_WritePhyUshort(sc, 0x06, 0x8b8d);
11025                 MP_WritePhyUshort(sc, 0x06, 0xad20);
11026                 MP_WritePhyUshort(sc, 0x06, 0x10ee);
11027                 MP_WritePhyUshort(sc, 0x06, 0x8b8d);
11028                 MP_WritePhyUshort(sc, 0x06, 0x0002);
11029                 MP_WritePhyUshort(sc, 0x06, 0x139d);
11030                 MP_WritePhyUshort(sc, 0x06, 0x0281);
11031                 MP_WritePhyUshort(sc, 0x06, 0xd602);
11032                 MP_WritePhyUshort(sc, 0x06, 0x1f99);
11033                 MP_WritePhyUshort(sc, 0x06, 0x0227);
11034                 MP_WritePhyUshort(sc, 0x06, 0xeafc);
11035                 MP_WritePhyUshort(sc, 0x06, 0x04f8);
11036                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
11037                 MP_WritePhyUshort(sc, 0x06, 0x8ead);
11038                 MP_WritePhyUshort(sc, 0x06, 0x2014);
11039                 MP_WritePhyUshort(sc, 0x06, 0xf620);
11040                 MP_WritePhyUshort(sc, 0x06, 0xe48b);
11041                 MP_WritePhyUshort(sc, 0x06, 0x8e02);
11042                 MP_WritePhyUshort(sc, 0x06, 0x8104);
11043                 MP_WritePhyUshort(sc, 0x06, 0x021b);
11044                 MP_WritePhyUshort(sc, 0x06, 0xf402);
11045                 MP_WritePhyUshort(sc, 0x06, 0x2c9c);
11046                 MP_WritePhyUshort(sc, 0x06, 0x0281);
11047                 MP_WritePhyUshort(sc, 0x06, 0x7902);
11048                 MP_WritePhyUshort(sc, 0x06, 0x8443);
11049                 MP_WritePhyUshort(sc, 0x06, 0xad22);
11050                 MP_WritePhyUshort(sc, 0x06, 0x11f6);
11051                 MP_WritePhyUshort(sc, 0x06, 0x22e4);
11052                 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
11053                 MP_WritePhyUshort(sc, 0x06, 0x022c);
11054                 MP_WritePhyUshort(sc, 0x06, 0x4602);
11055                 MP_WritePhyUshort(sc, 0x06, 0x2ac5);
11056                 MP_WritePhyUshort(sc, 0x06, 0x0229);
11057                 MP_WritePhyUshort(sc, 0x06, 0x2002);
11058                 MP_WritePhyUshort(sc, 0x06, 0x2b91);
11059                 MP_WritePhyUshort(sc, 0x06, 0xad25);
11060                 MP_WritePhyUshort(sc, 0x06, 0x11f6);
11061                 MP_WritePhyUshort(sc, 0x06, 0x25e4);
11062                 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
11063                 MP_WritePhyUshort(sc, 0x06, 0x0284);
11064                 MP_WritePhyUshort(sc, 0x06, 0xe202);
11065                 MP_WritePhyUshort(sc, 0x06, 0x043a);
11066                 MP_WritePhyUshort(sc, 0x06, 0x021a);
11067                 MP_WritePhyUshort(sc, 0x06, 0x5902);
11068                 MP_WritePhyUshort(sc, 0x06, 0x2bfc);
11069                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
11070                 MP_WritePhyUshort(sc, 0x06, 0xf8fa);
11071                 MP_WritePhyUshort(sc, 0x06, 0xef69);
11072                 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
11073                 MP_WritePhyUshort(sc, 0x06, 0x00e1);
11074                 MP_WritePhyUshort(sc, 0x06, 0xe001);
11075                 MP_WritePhyUshort(sc, 0x06, 0xad27);
11076                 MP_WritePhyUshort(sc, 0x06, 0x1fd1);
11077                 MP_WritePhyUshort(sc, 0x06, 0x01bf);
11078                 MP_WritePhyUshort(sc, 0x06, 0x8638);
11079                 MP_WritePhyUshort(sc, 0x06, 0x022f);
11080                 MP_WritePhyUshort(sc, 0x06, 0x50e0);
11081                 MP_WritePhyUshort(sc, 0x06, 0xe020);
11082                 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
11083                 MP_WritePhyUshort(sc, 0x06, 0x21ad);
11084                 MP_WritePhyUshort(sc, 0x06, 0x200e);
11085                 MP_WritePhyUshort(sc, 0x06, 0xd100);
11086                 MP_WritePhyUshort(sc, 0x06, 0xbf86);
11087                 MP_WritePhyUshort(sc, 0x06, 0x3802);
11088                 MP_WritePhyUshort(sc, 0x06, 0x2f50);
11089                 MP_WritePhyUshort(sc, 0x06, 0xbf3d);
11090                 MP_WritePhyUshort(sc, 0x06, 0x3902);
11091                 MP_WritePhyUshort(sc, 0x06, 0x2eb0);
11092                 MP_WritePhyUshort(sc, 0x06, 0xef96);
11093                 MP_WritePhyUshort(sc, 0x06, 0xfefc);
11094                 MP_WritePhyUshort(sc, 0x06, 0x0402);
11095                 MP_WritePhyUshort(sc, 0x06, 0x8591);
11096                 MP_WritePhyUshort(sc, 0x06, 0x0281);
11097                 MP_WritePhyUshort(sc, 0x06, 0x3c05);
11098                 MP_WritePhyUshort(sc, 0x06, 0xf8fa);
11099                 MP_WritePhyUshort(sc, 0x06, 0xef69);
11100                 MP_WritePhyUshort(sc, 0x06, 0xe0e2);
11101                 MP_WritePhyUshort(sc, 0x06, 0xfee1);
11102                 MP_WritePhyUshort(sc, 0x06, 0xe2ff);
11103                 MP_WritePhyUshort(sc, 0x06, 0xad2d);
11104                 MP_WritePhyUshort(sc, 0x06, 0x1ae0);
11105                 MP_WritePhyUshort(sc, 0x06, 0xe14e);
11106                 MP_WritePhyUshort(sc, 0x06, 0xe1e1);
11107                 MP_WritePhyUshort(sc, 0x06, 0x4fac);
11108                 MP_WritePhyUshort(sc, 0x06, 0x2d22);
11109                 MP_WritePhyUshort(sc, 0x06, 0xf603);
11110                 MP_WritePhyUshort(sc, 0x06, 0x0203);
11111                 MP_WritePhyUshort(sc, 0x06, 0x36f7);
11112                 MP_WritePhyUshort(sc, 0x06, 0x03f7);
11113                 MP_WritePhyUshort(sc, 0x06, 0x06bf);
11114                 MP_WritePhyUshort(sc, 0x06, 0x8622);
11115                 MP_WritePhyUshort(sc, 0x06, 0x022e);
11116                 MP_WritePhyUshort(sc, 0x06, 0xb0ae);
11117                 MP_WritePhyUshort(sc, 0x06, 0x11e0);
11118                 MP_WritePhyUshort(sc, 0x06, 0xe14e);
11119                 MP_WritePhyUshort(sc, 0x06, 0xe1e1);
11120                 MP_WritePhyUshort(sc, 0x06, 0x4fad);
11121                 MP_WritePhyUshort(sc, 0x06, 0x2d08);
11122                 MP_WritePhyUshort(sc, 0x06, 0xbf86);
11123                 MP_WritePhyUshort(sc, 0x06, 0x2d02);
11124                 MP_WritePhyUshort(sc, 0x06, 0x2eb0);
11125                 MP_WritePhyUshort(sc, 0x06, 0xf606);
11126                 MP_WritePhyUshort(sc, 0x06, 0xef96);
11127                 MP_WritePhyUshort(sc, 0x06, 0xfefc);
11128                 MP_WritePhyUshort(sc, 0x06, 0x04f8);
11129                 MP_WritePhyUshort(sc, 0x06, 0xf9fa);
11130                 MP_WritePhyUshort(sc, 0x06, 0xef69);
11131                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
11132                 MP_WritePhyUshort(sc, 0x06, 0x87ad);
11133                 MP_WritePhyUshort(sc, 0x06, 0x204c);
11134                 MP_WritePhyUshort(sc, 0x06, 0xd200);
11135                 MP_WritePhyUshort(sc, 0x06, 0xe0e2);
11136                 MP_WritePhyUshort(sc, 0x06, 0x0058);
11137                 MP_WritePhyUshort(sc, 0x06, 0x010c);
11138                 MP_WritePhyUshort(sc, 0x06, 0x021e);
11139                 MP_WritePhyUshort(sc, 0x06, 0x20e0);
11140                 MP_WritePhyUshort(sc, 0x06, 0xe000);
11141                 MP_WritePhyUshort(sc, 0x06, 0x5810);
11142                 MP_WritePhyUshort(sc, 0x06, 0x1e20);
11143                 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
11144                 MP_WritePhyUshort(sc, 0x06, 0x3658);
11145                 MP_WritePhyUshort(sc, 0x06, 0x031e);
11146                 MP_WritePhyUshort(sc, 0x06, 0x20e0);
11147                 MP_WritePhyUshort(sc, 0x06, 0xe022);
11148                 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
11149                 MP_WritePhyUshort(sc, 0x06, 0x2358);
11150                 MP_WritePhyUshort(sc, 0x06, 0xe01e);
11151                 MP_WritePhyUshort(sc, 0x06, 0x20e0);
11152                 MP_WritePhyUshort(sc, 0x06, 0x8ae6);
11153                 MP_WritePhyUshort(sc, 0x06, 0x1f02);
11154                 MP_WritePhyUshort(sc, 0x06, 0x9e22);
11155                 MP_WritePhyUshort(sc, 0x06, 0xe68a);
11156                 MP_WritePhyUshort(sc, 0x06, 0xe6ad);
11157                 MP_WritePhyUshort(sc, 0x06, 0x3214);
11158                 MP_WritePhyUshort(sc, 0x06, 0xad34);
11159                 MP_WritePhyUshort(sc, 0x06, 0x11ef);
11160                 MP_WritePhyUshort(sc, 0x06, 0x0258);
11161                 MP_WritePhyUshort(sc, 0x06, 0x039e);
11162                 MP_WritePhyUshort(sc, 0x06, 0x07ad);
11163                 MP_WritePhyUshort(sc, 0x06, 0x3508);
11164                 MP_WritePhyUshort(sc, 0x06, 0x5ac0);
11165                 MP_WritePhyUshort(sc, 0x06, 0x9f04);
11166                 MP_WritePhyUshort(sc, 0x06, 0xd101);
11167                 MP_WritePhyUshort(sc, 0x06, 0xae02);
11168                 MP_WritePhyUshort(sc, 0x06, 0xd100);
11169                 MP_WritePhyUshort(sc, 0x06, 0xbf86);
11170                 MP_WritePhyUshort(sc, 0x06, 0x3e02);
11171                 MP_WritePhyUshort(sc, 0x06, 0x2f50);
11172                 MP_WritePhyUshort(sc, 0x06, 0xef96);
11173                 MP_WritePhyUshort(sc, 0x06, 0xfefd);
11174                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
11175                 MP_WritePhyUshort(sc, 0x06, 0xf8f9);
11176                 MP_WritePhyUshort(sc, 0x06, 0xfae0);
11177                 MP_WritePhyUshort(sc, 0x06, 0x8b81);
11178                 MP_WritePhyUshort(sc, 0x06, 0xac26);
11179                 MP_WritePhyUshort(sc, 0x06, 0x0ee0);
11180                 MP_WritePhyUshort(sc, 0x06, 0x8b81);
11181                 MP_WritePhyUshort(sc, 0x06, 0xac21);
11182                 MP_WritePhyUshort(sc, 0x06, 0x08e0);
11183                 MP_WritePhyUshort(sc, 0x06, 0x8b87);
11184                 MP_WritePhyUshort(sc, 0x06, 0xac24);
11185                 MP_WritePhyUshort(sc, 0x06, 0x02ae);
11186                 MP_WritePhyUshort(sc, 0x06, 0x6bee);
11187                 MP_WritePhyUshort(sc, 0x06, 0xe0ea);
11188                 MP_WritePhyUshort(sc, 0x06, 0x00ee);
11189                 MP_WritePhyUshort(sc, 0x06, 0xe0eb);
11190                 MP_WritePhyUshort(sc, 0x06, 0x00e2);
11191                 MP_WritePhyUshort(sc, 0x06, 0xe07c);
11192                 MP_WritePhyUshort(sc, 0x06, 0xe3e0);
11193                 MP_WritePhyUshort(sc, 0x06, 0x7da5);
11194                 MP_WritePhyUshort(sc, 0x06, 0x1111);
11195                 MP_WritePhyUshort(sc, 0x06, 0x15d2);
11196                 MP_WritePhyUshort(sc, 0x06, 0x60d6);
11197                 MP_WritePhyUshort(sc, 0x06, 0x6666);
11198                 MP_WritePhyUshort(sc, 0x06, 0x0207);
11199                 MP_WritePhyUshort(sc, 0x06, 0xf9d2);
11200                 MP_WritePhyUshort(sc, 0x06, 0xa0d6);
11201                 MP_WritePhyUshort(sc, 0x06, 0xaaaa);
11202                 MP_WritePhyUshort(sc, 0x06, 0x0207);
11203                 MP_WritePhyUshort(sc, 0x06, 0xf902);
11204                 MP_WritePhyUshort(sc, 0x06, 0x825c);
11205                 MP_WritePhyUshort(sc, 0x06, 0xae44);
11206                 MP_WritePhyUshort(sc, 0x06, 0xa566);
11207                 MP_WritePhyUshort(sc, 0x06, 0x6602);
11208                 MP_WritePhyUshort(sc, 0x06, 0xae38);
11209                 MP_WritePhyUshort(sc, 0x06, 0xa5aa);
11210                 MP_WritePhyUshort(sc, 0x06, 0xaa02);
11211                 MP_WritePhyUshort(sc, 0x06, 0xae32);
11212                 MP_WritePhyUshort(sc, 0x06, 0xeee0);
11213                 MP_WritePhyUshort(sc, 0x06, 0xea04);
11214                 MP_WritePhyUshort(sc, 0x06, 0xeee0);
11215                 MP_WritePhyUshort(sc, 0x06, 0xeb06);
11216                 MP_WritePhyUshort(sc, 0x06, 0xe2e0);
11217                 MP_WritePhyUshort(sc, 0x06, 0x7ce3);
11218                 MP_WritePhyUshort(sc, 0x06, 0xe07d);
11219                 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
11220                 MP_WritePhyUshort(sc, 0x06, 0x38e1);
11221                 MP_WritePhyUshort(sc, 0x06, 0xe039);
11222                 MP_WritePhyUshort(sc, 0x06, 0xad2e);
11223                 MP_WritePhyUshort(sc, 0x06, 0x21ad);
11224                 MP_WritePhyUshort(sc, 0x06, 0x3f13);
11225                 MP_WritePhyUshort(sc, 0x06, 0xe0e4);
11226                 MP_WritePhyUshort(sc, 0x06, 0x14e1);
11227                 MP_WritePhyUshort(sc, 0x06, 0xe415);
11228                 MP_WritePhyUshort(sc, 0x06, 0x6880);
11229                 MP_WritePhyUshort(sc, 0x06, 0xe4e4);
11230                 MP_WritePhyUshort(sc, 0x06, 0x14e5);
11231                 MP_WritePhyUshort(sc, 0x06, 0xe415);
11232                 MP_WritePhyUshort(sc, 0x06, 0x0282);
11233                 MP_WritePhyUshort(sc, 0x06, 0x5cae);
11234                 MP_WritePhyUshort(sc, 0x06, 0x0bac);
11235                 MP_WritePhyUshort(sc, 0x06, 0x3e02);
11236                 MP_WritePhyUshort(sc, 0x06, 0xae06);
11237                 MP_WritePhyUshort(sc, 0x06, 0x0282);
11238                 MP_WritePhyUshort(sc, 0x06, 0x8602);
11239                 MP_WritePhyUshort(sc, 0x06, 0x82b0);
11240                 MP_WritePhyUshort(sc, 0x06, 0xfefd);
11241                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
11242                 MP_WritePhyUshort(sc, 0x06, 0xf8e1);
11243                 MP_WritePhyUshort(sc, 0x06, 0x8b2e);
11244                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
11245                 MP_WritePhyUshort(sc, 0x06, 0x81ad);
11246                 MP_WritePhyUshort(sc, 0x06, 0x2605);
11247                 MP_WritePhyUshort(sc, 0x06, 0x0221);
11248                 MP_WritePhyUshort(sc, 0x06, 0xf3f7);
11249                 MP_WritePhyUshort(sc, 0x06, 0x28e0);
11250                 MP_WritePhyUshort(sc, 0x06, 0x8b81);
11251                 MP_WritePhyUshort(sc, 0x06, 0xad21);
11252                 MP_WritePhyUshort(sc, 0x06, 0x0502);
11253                 MP_WritePhyUshort(sc, 0x06, 0x22f8);
11254                 MP_WritePhyUshort(sc, 0x06, 0xf729);
11255                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
11256                 MP_WritePhyUshort(sc, 0x06, 0x87ad);
11257                 MP_WritePhyUshort(sc, 0x06, 0x2405);
11258                 MP_WritePhyUshort(sc, 0x06, 0x0282);
11259                 MP_WritePhyUshort(sc, 0x06, 0xebf7);
11260                 MP_WritePhyUshort(sc, 0x06, 0x2ae5);
11261                 MP_WritePhyUshort(sc, 0x06, 0x8b2e);
11262                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
11263                 MP_WritePhyUshort(sc, 0x06, 0xf8e0);
11264                 MP_WritePhyUshort(sc, 0x06, 0x8b81);
11265                 MP_WritePhyUshort(sc, 0x06, 0xad26);
11266                 MP_WritePhyUshort(sc, 0x06, 0x0302);
11267                 MP_WritePhyUshort(sc, 0x06, 0x2134);
11268                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
11269                 MP_WritePhyUshort(sc, 0x06, 0x81ad);
11270                 MP_WritePhyUshort(sc, 0x06, 0x2109);
11271                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
11272                 MP_WritePhyUshort(sc, 0x06, 0x2eac);
11273                 MP_WritePhyUshort(sc, 0x06, 0x2003);
11274                 MP_WritePhyUshort(sc, 0x06, 0x0283);
11275                 MP_WritePhyUshort(sc, 0x06, 0x52e0);
11276                 MP_WritePhyUshort(sc, 0x06, 0x8b87);
11277                 MP_WritePhyUshort(sc, 0x06, 0xad24);
11278                 MP_WritePhyUshort(sc, 0x06, 0x09e0);
11279                 MP_WritePhyUshort(sc, 0x06, 0x8b2e);
11280                 MP_WritePhyUshort(sc, 0x06, 0xac21);
11281                 MP_WritePhyUshort(sc, 0x06, 0x0302);
11282                 MP_WritePhyUshort(sc, 0x06, 0x8337);
11283                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
11284                 MP_WritePhyUshort(sc, 0x06, 0xf8e1);
11285                 MP_WritePhyUshort(sc, 0x06, 0x8b2e);
11286                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
11287                 MP_WritePhyUshort(sc, 0x06, 0x81ad);
11288                 MP_WritePhyUshort(sc, 0x06, 0x2608);
11289                 MP_WritePhyUshort(sc, 0x06, 0xe085);
11290                 MP_WritePhyUshort(sc, 0x06, 0xd2ad);
11291                 MP_WritePhyUshort(sc, 0x06, 0x2502);
11292                 MP_WritePhyUshort(sc, 0x06, 0xf628);
11293                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
11294                 MP_WritePhyUshort(sc, 0x06, 0x81ad);
11295                 MP_WritePhyUshort(sc, 0x06, 0x210a);
11296                 MP_WritePhyUshort(sc, 0x06, 0xe086);
11297                 MP_WritePhyUshort(sc, 0x06, 0x0af6);
11298                 MP_WritePhyUshort(sc, 0x06, 0x27a0);
11299                 MP_WritePhyUshort(sc, 0x06, 0x0502);
11300                 MP_WritePhyUshort(sc, 0x06, 0xf629);
11301                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
11302                 MP_WritePhyUshort(sc, 0x06, 0x87ad);
11303                 MP_WritePhyUshort(sc, 0x06, 0x2408);
11304                 MP_WritePhyUshort(sc, 0x06, 0xe08a);
11305                 MP_WritePhyUshort(sc, 0x06, 0xedad);
11306                 MP_WritePhyUshort(sc, 0x06, 0x2002);
11307                 MP_WritePhyUshort(sc, 0x06, 0xf62a);
11308                 MP_WritePhyUshort(sc, 0x06, 0xe58b);
11309                 MP_WritePhyUshort(sc, 0x06, 0x2ea1);
11310                 MP_WritePhyUshort(sc, 0x06, 0x0003);
11311                 MP_WritePhyUshort(sc, 0x06, 0x0221);
11312                 MP_WritePhyUshort(sc, 0x06, 0x11fc);
11313                 MP_WritePhyUshort(sc, 0x06, 0x04ee);
11314                 MP_WritePhyUshort(sc, 0x06, 0x8aed);
11315                 MP_WritePhyUshort(sc, 0x06, 0x00ee);
11316                 MP_WritePhyUshort(sc, 0x06, 0x8aec);
11317                 MP_WritePhyUshort(sc, 0x06, 0x0004);
11318                 MP_WritePhyUshort(sc, 0x06, 0xf8e0);
11319                 MP_WritePhyUshort(sc, 0x06, 0x8b87);
11320                 MP_WritePhyUshort(sc, 0x06, 0xad24);
11321                 MP_WritePhyUshort(sc, 0x06, 0x3ae0);
11322                 MP_WritePhyUshort(sc, 0x06, 0xe0ea);
11323                 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
11324                 MP_WritePhyUshort(sc, 0x06, 0xeb58);
11325                 MP_WritePhyUshort(sc, 0x06, 0xf8d1);
11326                 MP_WritePhyUshort(sc, 0x06, 0x01e4);
11327                 MP_WritePhyUshort(sc, 0x06, 0xe0ea);
11328                 MP_WritePhyUshort(sc, 0x06, 0xe5e0);
11329                 MP_WritePhyUshort(sc, 0x06, 0xebe0);
11330                 MP_WritePhyUshort(sc, 0x06, 0xe07c);
11331                 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
11332                 MP_WritePhyUshort(sc, 0x06, 0x7d5c);
11333                 MP_WritePhyUshort(sc, 0x06, 0x00ff);
11334                 MP_WritePhyUshort(sc, 0x06, 0x3c00);
11335                 MP_WritePhyUshort(sc, 0x06, 0x1eab);
11336                 MP_WritePhyUshort(sc, 0x06, 0x1ce0);
11337                 MP_WritePhyUshort(sc, 0x06, 0xe04c);
11338                 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
11339                 MP_WritePhyUshort(sc, 0x06, 0x4d58);
11340                 MP_WritePhyUshort(sc, 0x06, 0xc1e4);
11341                 MP_WritePhyUshort(sc, 0x06, 0xe04c);
11342                 MP_WritePhyUshort(sc, 0x06, 0xe5e0);
11343                 MP_WritePhyUshort(sc, 0x06, 0x4de0);
11344                 MP_WritePhyUshort(sc, 0x06, 0xe0ee);
11345                 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
11346                 MP_WritePhyUshort(sc, 0x06, 0xef69);
11347                 MP_WritePhyUshort(sc, 0x06, 0x3ce4);
11348                 MP_WritePhyUshort(sc, 0x06, 0xe0ee);
11349                 MP_WritePhyUshort(sc, 0x06, 0xe5e0);
11350                 MP_WritePhyUshort(sc, 0x06, 0xeffc);
11351                 MP_WritePhyUshort(sc, 0x06, 0x04f8);
11352                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
11353                 MP_WritePhyUshort(sc, 0x06, 0x87ad);
11354                 MP_WritePhyUshort(sc, 0x06, 0x2412);
11355                 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
11356                 MP_WritePhyUshort(sc, 0x06, 0xeee1);
11357                 MP_WritePhyUshort(sc, 0x06, 0xe0ef);
11358                 MP_WritePhyUshort(sc, 0x06, 0x59c3);
11359                 MP_WritePhyUshort(sc, 0x06, 0xe4e0);
11360                 MP_WritePhyUshort(sc, 0x06, 0xeee5);
11361                 MP_WritePhyUshort(sc, 0x06, 0xe0ef);
11362                 MP_WritePhyUshort(sc, 0x06, 0xee8a);
11363                 MP_WritePhyUshort(sc, 0x06, 0xed01);
11364                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
11365                 MP_WritePhyUshort(sc, 0x06, 0xf8e0);
11366                 MP_WritePhyUshort(sc, 0x06, 0x8b81);
11367                 MP_WritePhyUshort(sc, 0x06, 0xac25);
11368                 MP_WritePhyUshort(sc, 0x06, 0x0502);
11369                 MP_WritePhyUshort(sc, 0x06, 0x8363);
11370                 MP_WritePhyUshort(sc, 0x06, 0xae03);
11371                 MP_WritePhyUshort(sc, 0x06, 0x0225);
11372                 MP_WritePhyUshort(sc, 0x06, 0x16fc);
11373                 MP_WritePhyUshort(sc, 0x06, 0x04f8);
11374                 MP_WritePhyUshort(sc, 0x06, 0xf9fa);
11375                 MP_WritePhyUshort(sc, 0x06, 0xef69);
11376                 MP_WritePhyUshort(sc, 0x06, 0xfae0);
11377                 MP_WritePhyUshort(sc, 0x06, 0x860a);
11378                 MP_WritePhyUshort(sc, 0x06, 0xa000);
11379                 MP_WritePhyUshort(sc, 0x06, 0x19e0);
11380                 MP_WritePhyUshort(sc, 0x06, 0x860b);
11381                 MP_WritePhyUshort(sc, 0x06, 0xe18b);
11382                 MP_WritePhyUshort(sc, 0x06, 0x331b);
11383                 MP_WritePhyUshort(sc, 0x06, 0x109e);
11384                 MP_WritePhyUshort(sc, 0x06, 0x04aa);
11385                 MP_WritePhyUshort(sc, 0x06, 0x02ae);
11386                 MP_WritePhyUshort(sc, 0x06, 0x06ee);
11387                 MP_WritePhyUshort(sc, 0x06, 0x860a);
11388                 MP_WritePhyUshort(sc, 0x06, 0x01ae);
11389                 MP_WritePhyUshort(sc, 0x06, 0xe602);
11390                 MP_WritePhyUshort(sc, 0x06, 0x241e);
11391                 MP_WritePhyUshort(sc, 0x06, 0xae14);
11392                 MP_WritePhyUshort(sc, 0x06, 0xa001);
11393                 MP_WritePhyUshort(sc, 0x06, 0x1402);
11394                 MP_WritePhyUshort(sc, 0x06, 0x2426);
11395                 MP_WritePhyUshort(sc, 0x06, 0xbf26);
11396                 MP_WritePhyUshort(sc, 0x06, 0x6d02);
11397                 MP_WritePhyUshort(sc, 0x06, 0x2eb0);
11398                 MP_WritePhyUshort(sc, 0x06, 0xee86);
11399                 MP_WritePhyUshort(sc, 0x06, 0x0b00);
11400                 MP_WritePhyUshort(sc, 0x06, 0xee86);
11401                 MP_WritePhyUshort(sc, 0x06, 0x0a02);
11402                 MP_WritePhyUshort(sc, 0x06, 0xaf84);
11403                 MP_WritePhyUshort(sc, 0x06, 0x3ca0);
11404                 MP_WritePhyUshort(sc, 0x06, 0x0252);
11405                 MP_WritePhyUshort(sc, 0x06, 0xee86);
11406                 MP_WritePhyUshort(sc, 0x06, 0x0400);
11407                 MP_WritePhyUshort(sc, 0x06, 0xee86);
11408                 MP_WritePhyUshort(sc, 0x06, 0x0500);
11409                 MP_WritePhyUshort(sc, 0x06, 0xe086);
11410                 MP_WritePhyUshort(sc, 0x06, 0x0be1);
11411                 MP_WritePhyUshort(sc, 0x06, 0x8b32);
11412                 MP_WritePhyUshort(sc, 0x06, 0x1b10);
11413                 MP_WritePhyUshort(sc, 0x06, 0x9e04);
11414                 MP_WritePhyUshort(sc, 0x06, 0xaa02);
11415                 MP_WritePhyUshort(sc, 0x06, 0xaecb);
11416                 MP_WritePhyUshort(sc, 0x06, 0xee86);
11417                 MP_WritePhyUshort(sc, 0x06, 0x0b00);
11418                 MP_WritePhyUshort(sc, 0x06, 0x0224);
11419                 MP_WritePhyUshort(sc, 0x06, 0x3ae2);
11420                 MP_WritePhyUshort(sc, 0x06, 0x8604);
11421                 MP_WritePhyUshort(sc, 0x06, 0xe386);
11422                 MP_WritePhyUshort(sc, 0x06, 0x05ef);
11423                 MP_WritePhyUshort(sc, 0x06, 0x65e2);
11424                 MP_WritePhyUshort(sc, 0x06, 0x8606);
11425                 MP_WritePhyUshort(sc, 0x06, 0xe386);
11426                 MP_WritePhyUshort(sc, 0x06, 0x071b);
11427                 MP_WritePhyUshort(sc, 0x06, 0x56aa);
11428                 MP_WritePhyUshort(sc, 0x06, 0x0eef);
11429                 MP_WritePhyUshort(sc, 0x06, 0x56e6);
11430                 MP_WritePhyUshort(sc, 0x06, 0x8606);
11431                 MP_WritePhyUshort(sc, 0x06, 0xe786);
11432                 MP_WritePhyUshort(sc, 0x06, 0x07e2);
11433                 MP_WritePhyUshort(sc, 0x06, 0x8609);
11434                 MP_WritePhyUshort(sc, 0x06, 0xe686);
11435                 MP_WritePhyUshort(sc, 0x06, 0x08e0);
11436                 MP_WritePhyUshort(sc, 0x06, 0x8609);
11437                 MP_WritePhyUshort(sc, 0x06, 0xa000);
11438                 MP_WritePhyUshort(sc, 0x06, 0x07ee);
11439                 MP_WritePhyUshort(sc, 0x06, 0x860a);
11440                 MP_WritePhyUshort(sc, 0x06, 0x03af);
11441                 MP_WritePhyUshort(sc, 0x06, 0x8369);
11442                 MP_WritePhyUshort(sc, 0x06, 0x0224);
11443                 MP_WritePhyUshort(sc, 0x06, 0x8e02);
11444                 MP_WritePhyUshort(sc, 0x06, 0x2426);
11445                 MP_WritePhyUshort(sc, 0x06, 0xae48);
11446                 MP_WritePhyUshort(sc, 0x06, 0xa003);
11447                 MP_WritePhyUshort(sc, 0x06, 0x21e0);
11448                 MP_WritePhyUshort(sc, 0x06, 0x8608);
11449                 MP_WritePhyUshort(sc, 0x06, 0xe186);
11450                 MP_WritePhyUshort(sc, 0x06, 0x091b);
11451                 MP_WritePhyUshort(sc, 0x06, 0x019e);
11452                 MP_WritePhyUshort(sc, 0x06, 0x0caa);
11453                 MP_WritePhyUshort(sc, 0x06, 0x0502);
11454                 MP_WritePhyUshort(sc, 0x06, 0x249d);
11455                 MP_WritePhyUshort(sc, 0x06, 0xaee7);
11456                 MP_WritePhyUshort(sc, 0x06, 0x0224);
11457                 MP_WritePhyUshort(sc, 0x06, 0x8eae);
11458                 MP_WritePhyUshort(sc, 0x06, 0xe2ee);
11459                 MP_WritePhyUshort(sc, 0x06, 0x860a);
11460                 MP_WritePhyUshort(sc, 0x06, 0x04ee);
11461                 MP_WritePhyUshort(sc, 0x06, 0x860b);
11462                 MP_WritePhyUshort(sc, 0x06, 0x00af);
11463                 MP_WritePhyUshort(sc, 0x06, 0x8369);
11464                 MP_WritePhyUshort(sc, 0x06, 0xa004);
11465                 MP_WritePhyUshort(sc, 0x06, 0x15e0);
11466                 MP_WritePhyUshort(sc, 0x06, 0x860b);
11467                 MP_WritePhyUshort(sc, 0x06, 0xe18b);
11468                 MP_WritePhyUshort(sc, 0x06, 0x341b);
11469                 MP_WritePhyUshort(sc, 0x06, 0x109e);
11470                 MP_WritePhyUshort(sc, 0x06, 0x05aa);
11471                 MP_WritePhyUshort(sc, 0x06, 0x03af);
11472                 MP_WritePhyUshort(sc, 0x06, 0x8383);
11473                 MP_WritePhyUshort(sc, 0x06, 0xee86);
11474                 MP_WritePhyUshort(sc, 0x06, 0x0a05);
11475                 MP_WritePhyUshort(sc, 0x06, 0xae0c);
11476                 MP_WritePhyUshort(sc, 0x06, 0xa005);
11477                 MP_WritePhyUshort(sc, 0x06, 0x02ae);
11478                 MP_WritePhyUshort(sc, 0x06, 0x0702);
11479                 MP_WritePhyUshort(sc, 0x06, 0x2309);
11480                 MP_WritePhyUshort(sc, 0x06, 0xee86);
11481                 MP_WritePhyUshort(sc, 0x06, 0x0a00);
11482                 MP_WritePhyUshort(sc, 0x06, 0xfeef);
11483                 MP_WritePhyUshort(sc, 0x06, 0x96fe);
11484                 MP_WritePhyUshort(sc, 0x06, 0xfdfc);
11485                 MP_WritePhyUshort(sc, 0x06, 0x04f8);
11486                 MP_WritePhyUshort(sc, 0x06, 0xf9fa);
11487                 MP_WritePhyUshort(sc, 0x06, 0xef69);
11488                 MP_WritePhyUshort(sc, 0x06, 0xfbe0);
11489                 MP_WritePhyUshort(sc, 0x06, 0x8b85);
11490                 MP_WritePhyUshort(sc, 0x06, 0xad25);
11491                 MP_WritePhyUshort(sc, 0x06, 0x22e0);
11492                 MP_WritePhyUshort(sc, 0x06, 0xe022);
11493                 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
11494                 MP_WritePhyUshort(sc, 0x06, 0x23e2);
11495                 MP_WritePhyUshort(sc, 0x06, 0xe036);
11496                 MP_WritePhyUshort(sc, 0x06, 0xe3e0);
11497                 MP_WritePhyUshort(sc, 0x06, 0x375a);
11498                 MP_WritePhyUshort(sc, 0x06, 0xc40d);
11499                 MP_WritePhyUshort(sc, 0x06, 0x0158);
11500                 MP_WritePhyUshort(sc, 0x06, 0x021e);
11501                 MP_WritePhyUshort(sc, 0x06, 0x20e3);
11502                 MP_WritePhyUshort(sc, 0x06, 0x8ae7);
11503                 MP_WritePhyUshort(sc, 0x06, 0xac31);
11504                 MP_WritePhyUshort(sc, 0x06, 0x60ac);
11505                 MP_WritePhyUshort(sc, 0x06, 0x3a08);
11506                 MP_WritePhyUshort(sc, 0x06, 0xac3e);
11507                 MP_WritePhyUshort(sc, 0x06, 0x26ae);
11508                 MP_WritePhyUshort(sc, 0x06, 0x67af);
11509                 MP_WritePhyUshort(sc, 0x06, 0x84db);
11510                 MP_WritePhyUshort(sc, 0x06, 0xad37);
11511                 MP_WritePhyUshort(sc, 0x06, 0x61e0);
11512                 MP_WritePhyUshort(sc, 0x06, 0x8ae8);
11513                 MP_WritePhyUshort(sc, 0x06, 0x10e4);
11514                 MP_WritePhyUshort(sc, 0x06, 0x8ae8);
11515                 MP_WritePhyUshort(sc, 0x06, 0xe18a);
11516                 MP_WritePhyUshort(sc, 0x06, 0xe91b);
11517                 MP_WritePhyUshort(sc, 0x06, 0x109e);
11518                 MP_WritePhyUshort(sc, 0x06, 0x02ae);
11519                 MP_WritePhyUshort(sc, 0x06, 0x51d1);
11520                 MP_WritePhyUshort(sc, 0x06, 0x00bf);
11521                 MP_WritePhyUshort(sc, 0x06, 0x863b);
11522                 MP_WritePhyUshort(sc, 0x06, 0x022f);
11523                 MP_WritePhyUshort(sc, 0x06, 0x50ee);
11524                 MP_WritePhyUshort(sc, 0x06, 0x8ae8);
11525                 MP_WritePhyUshort(sc, 0x06, 0x00ae);
11526                 MP_WritePhyUshort(sc, 0x06, 0x43ad);
11527                 MP_WritePhyUshort(sc, 0x06, 0x3627);
11528                 MP_WritePhyUshort(sc, 0x06, 0xe08a);
11529                 MP_WritePhyUshort(sc, 0x06, 0xeee1);
11530                 MP_WritePhyUshort(sc, 0x06, 0x8aef);
11531                 MP_WritePhyUshort(sc, 0x06, 0xef74);
11532                 MP_WritePhyUshort(sc, 0x06, 0xe08a);
11533                 MP_WritePhyUshort(sc, 0x06, 0xeae1);
11534                 MP_WritePhyUshort(sc, 0x06, 0x8aeb);
11535                 MP_WritePhyUshort(sc, 0x06, 0x1b74);
11536                 MP_WritePhyUshort(sc, 0x06, 0x9e2e);
11537                 MP_WritePhyUshort(sc, 0x06, 0x14e4);
11538                 MP_WritePhyUshort(sc, 0x06, 0x8aea);
11539                 MP_WritePhyUshort(sc, 0x06, 0xe58a);
11540                 MP_WritePhyUshort(sc, 0x06, 0xebef);
11541                 MP_WritePhyUshort(sc, 0x06, 0x74e0);
11542                 MP_WritePhyUshort(sc, 0x06, 0x8aee);
11543                 MP_WritePhyUshort(sc, 0x06, 0xe18a);
11544                 MP_WritePhyUshort(sc, 0x06, 0xef1b);
11545                 MP_WritePhyUshort(sc, 0x06, 0x479e);
11546                 MP_WritePhyUshort(sc, 0x06, 0x0fae);
11547                 MP_WritePhyUshort(sc, 0x06, 0x19ee);
11548                 MP_WritePhyUshort(sc, 0x06, 0x8aea);
11549                 MP_WritePhyUshort(sc, 0x06, 0x00ee);
11550                 MP_WritePhyUshort(sc, 0x06, 0x8aeb);
11551                 MP_WritePhyUshort(sc, 0x06, 0x00ae);
11552                 MP_WritePhyUshort(sc, 0x06, 0x0fac);
11553                 MP_WritePhyUshort(sc, 0x06, 0x390c);
11554                 MP_WritePhyUshort(sc, 0x06, 0xd101);
11555                 MP_WritePhyUshort(sc, 0x06, 0xbf86);
11556                 MP_WritePhyUshort(sc, 0x06, 0x3b02);
11557                 MP_WritePhyUshort(sc, 0x06, 0x2f50);
11558                 MP_WritePhyUshort(sc, 0x06, 0xee8a);
11559                 MP_WritePhyUshort(sc, 0x06, 0xe800);
11560                 MP_WritePhyUshort(sc, 0x06, 0xe68a);
11561                 MP_WritePhyUshort(sc, 0x06, 0xe7ff);
11562                 MP_WritePhyUshort(sc, 0x06, 0xef96);
11563                 MP_WritePhyUshort(sc, 0x06, 0xfefd);
11564                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
11565                 MP_WritePhyUshort(sc, 0x06, 0xf8f9);
11566                 MP_WritePhyUshort(sc, 0x06, 0xfaef);
11567                 MP_WritePhyUshort(sc, 0x06, 0x69e0);
11568                 MP_WritePhyUshort(sc, 0x06, 0xe022);
11569                 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
11570                 MP_WritePhyUshort(sc, 0x06, 0x2358);
11571                 MP_WritePhyUshort(sc, 0x06, 0xc4e1);
11572                 MP_WritePhyUshort(sc, 0x06, 0x8b6e);
11573                 MP_WritePhyUshort(sc, 0x06, 0x1f10);
11574                 MP_WritePhyUshort(sc, 0x06, 0x9e24);
11575                 MP_WritePhyUshort(sc, 0x06, 0xe48b);
11576                 MP_WritePhyUshort(sc, 0x06, 0x6ead);
11577                 MP_WritePhyUshort(sc, 0x06, 0x2218);
11578                 MP_WritePhyUshort(sc, 0x06, 0xac27);
11579                 MP_WritePhyUshort(sc, 0x06, 0x0dac);
11580                 MP_WritePhyUshort(sc, 0x06, 0x2605);
11581                 MP_WritePhyUshort(sc, 0x06, 0x0203);
11582                 MP_WritePhyUshort(sc, 0x06, 0x8fae);
11583                 MP_WritePhyUshort(sc, 0x06, 0x1302);
11584                 MP_WritePhyUshort(sc, 0x06, 0x03c8);
11585                 MP_WritePhyUshort(sc, 0x06, 0xae0e);
11586                 MP_WritePhyUshort(sc, 0x06, 0x0203);
11587                 MP_WritePhyUshort(sc, 0x06, 0xe102);
11588                 MP_WritePhyUshort(sc, 0x06, 0x8520);
11589                 MP_WritePhyUshort(sc, 0x06, 0xae06);
11590                 MP_WritePhyUshort(sc, 0x06, 0x0203);
11591                 MP_WritePhyUshort(sc, 0x06, 0x8f02);
11592                 MP_WritePhyUshort(sc, 0x06, 0x8566);
11593                 MP_WritePhyUshort(sc, 0x06, 0xef96);
11594                 MP_WritePhyUshort(sc, 0x06, 0xfefd);
11595                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
11596                 MP_WritePhyUshort(sc, 0x06, 0xf8fa);
11597                 MP_WritePhyUshort(sc, 0x06, 0xef69);
11598                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
11599                 MP_WritePhyUshort(sc, 0x06, 0x82ad);
11600                 MP_WritePhyUshort(sc, 0x06, 0x2737);
11601                 MP_WritePhyUshort(sc, 0x06, 0xbf86);
11602                 MP_WritePhyUshort(sc, 0x06, 0x4402);
11603                 MP_WritePhyUshort(sc, 0x06, 0x2f23);
11604                 MP_WritePhyUshort(sc, 0x06, 0xac28);
11605                 MP_WritePhyUshort(sc, 0x06, 0x2ed1);
11606                 MP_WritePhyUshort(sc, 0x06, 0x01bf);
11607                 MP_WritePhyUshort(sc, 0x06, 0x8647);
11608                 MP_WritePhyUshort(sc, 0x06, 0x022f);
11609                 MP_WritePhyUshort(sc, 0x06, 0x50bf);
11610                 MP_WritePhyUshort(sc, 0x06, 0x8641);
11611                 MP_WritePhyUshort(sc, 0x06, 0x022f);
11612                 MP_WritePhyUshort(sc, 0x06, 0x23e5);
11613                 MP_WritePhyUshort(sc, 0x06, 0x8af0);
11614                 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
11615                 MP_WritePhyUshort(sc, 0x06, 0x22e1);
11616                 MP_WritePhyUshort(sc, 0x06, 0xe023);
11617                 MP_WritePhyUshort(sc, 0x06, 0xac2e);
11618                 MP_WritePhyUshort(sc, 0x06, 0x04d1);
11619                 MP_WritePhyUshort(sc, 0x06, 0x01ae);
11620                 MP_WritePhyUshort(sc, 0x06, 0x02d1);
11621                 MP_WritePhyUshort(sc, 0x06, 0x00bf);
11622                 MP_WritePhyUshort(sc, 0x06, 0x8641);
11623                 MP_WritePhyUshort(sc, 0x06, 0x022f);
11624                 MP_WritePhyUshort(sc, 0x06, 0x50d1);
11625                 MP_WritePhyUshort(sc, 0x06, 0x01bf);
11626                 MP_WritePhyUshort(sc, 0x06, 0x8644);
11627                 MP_WritePhyUshort(sc, 0x06, 0x022f);
11628                 MP_WritePhyUshort(sc, 0x06, 0x50ef);
11629                 MP_WritePhyUshort(sc, 0x06, 0x96fe);
11630                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
11631                 MP_WritePhyUshort(sc, 0x06, 0xf8fa);
11632                 MP_WritePhyUshort(sc, 0x06, 0xef69);
11633                 MP_WritePhyUshort(sc, 0x06, 0xbf86);
11634                 MP_WritePhyUshort(sc, 0x06, 0x4702);
11635                 MP_WritePhyUshort(sc, 0x06, 0x2f23);
11636                 MP_WritePhyUshort(sc, 0x06, 0xad28);
11637                 MP_WritePhyUshort(sc, 0x06, 0x19d1);
11638                 MP_WritePhyUshort(sc, 0x06, 0x00bf);
11639                 MP_WritePhyUshort(sc, 0x06, 0x8644);
11640                 MP_WritePhyUshort(sc, 0x06, 0x022f);
11641                 MP_WritePhyUshort(sc, 0x06, 0x50e1);
11642                 MP_WritePhyUshort(sc, 0x06, 0x8af0);
11643                 MP_WritePhyUshort(sc, 0x06, 0xbf86);
11644                 MP_WritePhyUshort(sc, 0x06, 0x4102);
11645                 MP_WritePhyUshort(sc, 0x06, 0x2f50);
11646                 MP_WritePhyUshort(sc, 0x06, 0xd100);
11647                 MP_WritePhyUshort(sc, 0x06, 0xbf86);
11648                 MP_WritePhyUshort(sc, 0x06, 0x4702);
11649                 MP_WritePhyUshort(sc, 0x06, 0x2f50);
11650                 MP_WritePhyUshort(sc, 0x06, 0xef96);
11651                 MP_WritePhyUshort(sc, 0x06, 0xfefc);
11652                 MP_WritePhyUshort(sc, 0x06, 0x04f8);
11653                 MP_WritePhyUshort(sc, 0x06, 0xe0e2);
11654                 MP_WritePhyUshort(sc, 0x06, 0xfee1);
11655                 MP_WritePhyUshort(sc, 0x06, 0xe2ff);
11656                 MP_WritePhyUshort(sc, 0x06, 0xad2e);
11657                 MP_WritePhyUshort(sc, 0x06, 0x63e0);
11658                 MP_WritePhyUshort(sc, 0x06, 0xe038);
11659                 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
11660                 MP_WritePhyUshort(sc, 0x06, 0x39ad);
11661                 MP_WritePhyUshort(sc, 0x06, 0x2f10);
11662                 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
11663                 MP_WritePhyUshort(sc, 0x06, 0x34e1);
11664                 MP_WritePhyUshort(sc, 0x06, 0xe035);
11665                 MP_WritePhyUshort(sc, 0x06, 0xf726);
11666                 MP_WritePhyUshort(sc, 0x06, 0xe4e0);
11667                 MP_WritePhyUshort(sc, 0x06, 0x34e5);
11668                 MP_WritePhyUshort(sc, 0x06, 0xe035);
11669                 MP_WritePhyUshort(sc, 0x06, 0xae0e);
11670                 MP_WritePhyUshort(sc, 0x06, 0xe0e2);
11671                 MP_WritePhyUshort(sc, 0x06, 0xd6e1);
11672                 MP_WritePhyUshort(sc, 0x06, 0xe2d7);
11673                 MP_WritePhyUshort(sc, 0x06, 0xf728);
11674                 MP_WritePhyUshort(sc, 0x06, 0xe4e2);
11675                 MP_WritePhyUshort(sc, 0x06, 0xd6e5);
11676                 MP_WritePhyUshort(sc, 0x06, 0xe2d7);
11677                 MP_WritePhyUshort(sc, 0x06, 0xe0e2);
11678                 MP_WritePhyUshort(sc, 0x06, 0x34e1);
11679                 MP_WritePhyUshort(sc, 0x06, 0xe235);
11680                 MP_WritePhyUshort(sc, 0x06, 0xf72b);
11681                 MP_WritePhyUshort(sc, 0x06, 0xe4e2);
11682                 MP_WritePhyUshort(sc, 0x06, 0x34e5);
11683                 MP_WritePhyUshort(sc, 0x06, 0xe235);
11684                 MP_WritePhyUshort(sc, 0x06, 0xd07d);
11685                 MP_WritePhyUshort(sc, 0x06, 0xb0fe);
11686                 MP_WritePhyUshort(sc, 0x06, 0xe0e2);
11687                 MP_WritePhyUshort(sc, 0x06, 0x34e1);
11688                 MP_WritePhyUshort(sc, 0x06, 0xe235);
11689                 MP_WritePhyUshort(sc, 0x06, 0xf62b);
11690                 MP_WritePhyUshort(sc, 0x06, 0xe4e2);
11691                 MP_WritePhyUshort(sc, 0x06, 0x34e5);
11692                 MP_WritePhyUshort(sc, 0x06, 0xe235);
11693                 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
11694                 MP_WritePhyUshort(sc, 0x06, 0x34e1);
11695                 MP_WritePhyUshort(sc, 0x06, 0xe035);
11696                 MP_WritePhyUshort(sc, 0x06, 0xf626);
11697                 MP_WritePhyUshort(sc, 0x06, 0xe4e0);
11698                 MP_WritePhyUshort(sc, 0x06, 0x34e5);
11699                 MP_WritePhyUshort(sc, 0x06, 0xe035);
11700                 MP_WritePhyUshort(sc, 0x06, 0xe0e2);
11701                 MP_WritePhyUshort(sc, 0x06, 0xd6e1);
11702                 MP_WritePhyUshort(sc, 0x06, 0xe2d7);
11703                 MP_WritePhyUshort(sc, 0x06, 0xf628);
11704                 MP_WritePhyUshort(sc, 0x06, 0xe4e2);
11705                 MP_WritePhyUshort(sc, 0x06, 0xd6e5);
11706                 MP_WritePhyUshort(sc, 0x06, 0xe2d7);
11707                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
11708                 MP_WritePhyUshort(sc, 0x06, 0xae20);
11709                 MP_WritePhyUshort(sc, 0x06, 0x0000);
11710                 MP_WritePhyUshort(sc, 0x06, 0x0000);
11711                 MP_WritePhyUshort(sc, 0x06, 0x0000);
11712                 MP_WritePhyUshort(sc, 0x06, 0x0000);
11713                 MP_WritePhyUshort(sc, 0x06, 0x0000);
11714                 MP_WritePhyUshort(sc, 0x06, 0x0000);
11715                 MP_WritePhyUshort(sc, 0x06, 0x0000);
11716                 MP_WritePhyUshort(sc, 0x06, 0x0000);
11717                 MP_WritePhyUshort(sc, 0x06, 0x0000);
11718                 MP_WritePhyUshort(sc, 0x06, 0x0000);
11719                 MP_WritePhyUshort(sc, 0x06, 0x0000);
11720                 MP_WritePhyUshort(sc, 0x06, 0x0000);
11721                 MP_WritePhyUshort(sc, 0x06, 0x0000);
11722                 MP_WritePhyUshort(sc, 0x06, 0x0000);
11723                 MP_WritePhyUshort(sc, 0x06, 0x0000);
11724                 MP_WritePhyUshort(sc, 0x06, 0x0000);
11725                 MP_WritePhyUshort(sc, 0x06, 0xa725);
11726                 MP_WritePhyUshort(sc, 0x06, 0xe50a);
11727                 MP_WritePhyUshort(sc, 0x06, 0x1de5);
11728                 MP_WritePhyUshort(sc, 0x06, 0x0a2c);
11729                 MP_WritePhyUshort(sc, 0x06, 0xe50a);
11730                 MP_WritePhyUshort(sc, 0x06, 0x6de5);
11731                 MP_WritePhyUshort(sc, 0x06, 0x0a1d);
11732                 MP_WritePhyUshort(sc, 0x06, 0xe50a);
11733                 MP_WritePhyUshort(sc, 0x06, 0x1ce5);
11734                 MP_WritePhyUshort(sc, 0x06, 0x0a2d);
11735                 MP_WritePhyUshort(sc, 0x06, 0xa755);
11736                 MP_WritePhyUshort(sc, 0x06, 0x00e2);
11737                 MP_WritePhyUshort(sc, 0x06, 0x3488);
11738                 MP_WritePhyUshort(sc, 0x06, 0xe200);
11739                 MP_WritePhyUshort(sc, 0x06, 0xcce2);
11740                 MP_WritePhyUshort(sc, 0x06, 0x0055);
11741                 MP_WritePhyUshort(sc, 0x06, 0xe020);
11742                 MP_WritePhyUshort(sc, 0x06, 0x55e2);
11743                 MP_WritePhyUshort(sc, 0x06, 0xd600);
11744                 MP_WritePhyUshort(sc, 0x06, 0xe24a);
11745                 PhyRegValue = MP_ReadPhyUshort(sc, 0x01);
11746                 PhyRegValue |= BIT_0;
11747                 MP_WritePhyUshort(sc, 0x01, PhyRegValue);
11748                 PhyRegValue = MP_ReadPhyUshort(sc, 0x00);
11749                 PhyRegValue |= BIT_0;
11750                 MP_WritePhyUshort(sc, 0x00, PhyRegValue);
11751                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
11752                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
11753                 MP_WritePhyUshort(sc, 0x17, 0x2179);
11754                 MP_WritePhyUshort(sc, 0x1f, 0x0001);
11755                 MP_WritePhyUshort(sc, 0x10, 0xf274);
11756                 MP_WritePhyUshort(sc, 0x1f, 0x0007);
11757                 MP_WritePhyUshort(sc, 0x1e, 0x0042);
11758                 MP_WritePhyUshort(sc, 0x15, 0x0f00);
11759                 MP_WritePhyUshort(sc, 0x15, 0x0f00);
11760                 MP_WritePhyUshort(sc, 0x16, 0x7408);
11761                 MP_WritePhyUshort(sc, 0x15, 0x0e00);
11762                 MP_WritePhyUshort(sc, 0x15, 0x0f00);
11763                 MP_WritePhyUshort(sc, 0x15, 0x0f01);
11764                 MP_WritePhyUshort(sc, 0x16, 0x4000);
11765                 MP_WritePhyUshort(sc, 0x15, 0x0e01);
11766                 MP_WritePhyUshort(sc, 0x15, 0x0f01);
11767                 MP_WritePhyUshort(sc, 0x15, 0x0f02);
11768                 MP_WritePhyUshort(sc, 0x16, 0x9400);
11769                 MP_WritePhyUshort(sc, 0x15, 0x0e02);
11770                 MP_WritePhyUshort(sc, 0x15, 0x0f02);
11771                 MP_WritePhyUshort(sc, 0x15, 0x0f03);
11772                 MP_WritePhyUshort(sc, 0x16, 0x7408);
11773                 MP_WritePhyUshort(sc, 0x15, 0x0e03);
11774                 MP_WritePhyUshort(sc, 0x15, 0x0f03);
11775                 MP_WritePhyUshort(sc, 0x15, 0x0f04);
11776                 MP_WritePhyUshort(sc, 0x16, 0x4008);
11777                 MP_WritePhyUshort(sc, 0x15, 0x0e04);
11778                 MP_WritePhyUshort(sc, 0x15, 0x0f04);
11779                 MP_WritePhyUshort(sc, 0x15, 0x0f05);
11780                 MP_WritePhyUshort(sc, 0x16, 0x9400);
11781                 MP_WritePhyUshort(sc, 0x15, 0x0e05);
11782                 MP_WritePhyUshort(sc, 0x15, 0x0f05);
11783                 MP_WritePhyUshort(sc, 0x15, 0x0f06);
11784                 MP_WritePhyUshort(sc, 0x16, 0x0803);
11785                 MP_WritePhyUshort(sc, 0x15, 0x0e06);
11786                 MP_WritePhyUshort(sc, 0x15, 0x0f06);
11787                 MP_WritePhyUshort(sc, 0x15, 0x0d00);
11788                 MP_WritePhyUshort(sc, 0x15, 0x0100);
11789                 MP_WritePhyUshort(sc, 0x1f, 0x0001);
11790                 MP_WritePhyUshort(sc, 0x10, 0xf074);
11791                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
11792                 MP_WritePhyUshort(sc, 0x17, 0x2149);
11793                 MP_WritePhyUshort(sc, 0x1f, 0x0005);
11794                 for (i=0; i<200; i++) {
11795                         DELAY(100);
11796                         PhyRegValue = MP_ReadPhyUshort(sc, 0x00);
11797                         if (PhyRegValue&0x0080)
11798                                 break;
11799                 }
11800                 MP_WritePhyUshort(sc, 0x1f, 0x0007);
11801                 MP_WritePhyUshort(sc, 0x1e, 0x0023);
11802                 PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
11803                 PhyRegValue &= ~(BIT_0);
11804                 if (sc->RequiredSecLanDonglePatch)
11805                         PhyRegValue &= ~(BIT_2);
11806                 MP_WritePhyUshort(sc, 0x17, PhyRegValue);
11807                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
11808                 MP_WritePhyUshort(sc, 0x1f, 0x0007);
11809                 MP_WritePhyUshort(sc, 0x1e, 0x0023);
11810                 PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
11811                 PhyRegValue |= BIT_14;
11812                 MP_WritePhyUshort(sc, 0x17, PhyRegValue);
11813                 MP_WritePhyUshort(sc, 0x1e, 0x0020);
11814                 PhyRegValue = MP_ReadPhyUshort(sc, 0x1b);
11815                 PhyRegValue |= BIT_7;
11816                 MP_WritePhyUshort(sc, 0x1b, PhyRegValue);
11817                 MP_WritePhyUshort(sc, 0x1e, 0x0041);
11818                 MP_WritePhyUshort(sc, 0x15, 0x0e02);
11819                 MP_WritePhyUshort(sc, 0x1e, 0x0028);
11820                 PhyRegValue = MP_ReadPhyUshort(sc, 0x19);
11821                 PhyRegValue |= BIT_15;
11822                 MP_WritePhyUshort(sc, 0x19, PhyRegValue);
11823                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
11824         } else {
11825                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
11826                 MP_WritePhyUshort(sc, 0x00, 0x1800);
11827                 MP_WritePhyUshort(sc, 0x1f, 0x0007);
11828                 MP_WritePhyUshort(sc, 0x1e, 0x0023);
11829                 MP_WritePhyUshort(sc, 0x17, 0x0117);
11830                 MP_WritePhyUshort(sc, 0x1f, 0x0007);
11831                 MP_WritePhyUshort(sc, 0x1E, 0x002C);
11832                 MP_WritePhyUshort(sc, 0x1B, 0x5000);
11833                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
11834                 MP_WritePhyUshort(sc, 0x16, 0x4104);
11835                 for (i = 0; i < 200; i++) {
11836                         DELAY(100);
11837                         PhyRegValue = MP_ReadPhyUshort(sc, 0x1E);
11838                         PhyRegValue &= 0x03FF;
11839                         if (PhyRegValue==0x000C)
11840                                 break;
11841                 }
11842                 MP_WritePhyUshort(sc, 0x1f, 0x0005);
11843                 for (i = 0; i < 200; i++) {
11844                         DELAY(100);
11845                         PhyRegValue = MP_ReadPhyUshort(sc, 0x07);
11846                         if ((PhyRegValue & BIT_5) == 0)
11847                                 break;
11848                 }
11849                 PhyRegValue = MP_ReadPhyUshort(sc, 0x07);
11850                 if (PhyRegValue & BIT_5) {
11851                         MP_WritePhyUshort(sc, 0x1f, 0x0007);
11852                         MP_WritePhyUshort(sc, 0x1e, 0x00a1);
11853                         MP_WritePhyUshort(sc, 0x17, 0x1000);
11854                         MP_WritePhyUshort(sc, 0x17, 0x0000);
11855                         MP_WritePhyUshort(sc, 0x17, 0x2000);
11856                         MP_WritePhyUshort(sc, 0x1e, 0x002f);
11857                         MP_WritePhyUshort(sc, 0x18, 0x9bfb);
11858                         MP_WritePhyUshort(sc, 0x1f, 0x0005);
11859                         MP_WritePhyUshort(sc, 0x07, 0x0000);
11860                         MP_WritePhyUshort(sc, 0x1f, 0x0000);
11861                 }
11862                 MP_WritePhyUshort(sc, 0x1f, 0x0005);
11863                 MP_WritePhyUshort(sc, 0x05, 0xfff6);
11864                 MP_WritePhyUshort(sc, 0x06, 0x0080);
11865                 PhyRegValue = MP_ReadPhyUshort(sc, 0x00);
11866                 PhyRegValue &= ~(BIT_7);
11867                 MP_WritePhyUshort(sc, 0x00, PhyRegValue);
11868                 MP_WritePhyUshort(sc, 0x1f, 0x0002);
11869                 PhyRegValue = MP_ReadPhyUshort(sc, 0x08);
11870                 PhyRegValue &= ~(BIT_7);
11871                 MP_WritePhyUshort(sc, 0x08, PhyRegValue);
11872                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
11873
11874                 MP_WritePhyUshort(sc, 0x1f, 0x0007);
11875                 MP_WritePhyUshort(sc, 0x1e, 0x0023);
11876                 MP_WritePhyUshort(sc, 0x16, 0x0306);
11877                 MP_WritePhyUshort(sc, 0x16, 0x0307);
11878                 MP_WritePhyUshort(sc, 0x15, 0x000e);
11879                 MP_WritePhyUshort(sc, 0x19, 0x000a);
11880                 MP_WritePhyUshort(sc, 0x15, 0x0010);
11881                 MP_WritePhyUshort(sc, 0x19, 0x0008);
11882                 MP_WritePhyUshort(sc, 0x15, 0x0018);
11883                 MP_WritePhyUshort(sc, 0x19, 0x4801);
11884                 MP_WritePhyUshort(sc, 0x15, 0x0019);
11885                 MP_WritePhyUshort(sc, 0x19, 0x6801);
11886                 MP_WritePhyUshort(sc, 0x15, 0x001a);
11887                 MP_WritePhyUshort(sc, 0x19, 0x66a1);
11888                 MP_WritePhyUshort(sc, 0x15, 0x001f);
11889                 MP_WritePhyUshort(sc, 0x19, 0x0000);
11890                 MP_WritePhyUshort(sc, 0x15, 0x0020);
11891                 MP_WritePhyUshort(sc, 0x19, 0x0000);
11892                 MP_WritePhyUshort(sc, 0x15, 0x0021);
11893                 MP_WritePhyUshort(sc, 0x19, 0x0000);
11894                 MP_WritePhyUshort(sc, 0x15, 0x0022);
11895                 MP_WritePhyUshort(sc, 0x19, 0x0000);
11896                 MP_WritePhyUshort(sc, 0x15, 0x0023);
11897                 MP_WritePhyUshort(sc, 0x19, 0x0000);
11898                 MP_WritePhyUshort(sc, 0x15, 0x0024);
11899                 MP_WritePhyUshort(sc, 0x19, 0x0000);
11900                 MP_WritePhyUshort(sc, 0x15, 0x0025);
11901                 MP_WritePhyUshort(sc, 0x19, 0x64a1);
11902                 MP_WritePhyUshort(sc, 0x15, 0x0026);
11903                 MP_WritePhyUshort(sc, 0x19, 0x40ea);
11904                 MP_WritePhyUshort(sc, 0x15, 0x0027);
11905                 MP_WritePhyUshort(sc, 0x19, 0x4503);
11906                 MP_WritePhyUshort(sc, 0x15, 0x0028);
11907                 MP_WritePhyUshort(sc, 0x19, 0x9f00);
11908                 MP_WritePhyUshort(sc, 0x15, 0x0029);
11909                 MP_WritePhyUshort(sc, 0x19, 0xa631);
11910                 MP_WritePhyUshort(sc, 0x15, 0x002a);
11911                 MP_WritePhyUshort(sc, 0x19, 0x9717);
11912                 MP_WritePhyUshort(sc, 0x15, 0x002b);
11913                 MP_WritePhyUshort(sc, 0x19, 0x302c);
11914                 MP_WritePhyUshort(sc, 0x15, 0x002c);
11915                 MP_WritePhyUshort(sc, 0x19, 0x4802);
11916                 MP_WritePhyUshort(sc, 0x15, 0x002d);
11917                 MP_WritePhyUshort(sc, 0x19, 0x58da);
11918                 MP_WritePhyUshort(sc, 0x15, 0x002e);
11919                 MP_WritePhyUshort(sc, 0x19, 0x400d);
11920                 MP_WritePhyUshort(sc, 0x15, 0x002f);
11921                 MP_WritePhyUshort(sc, 0x19, 0x4488);
11922                 MP_WritePhyUshort(sc, 0x15, 0x0030);
11923                 MP_WritePhyUshort(sc, 0x19, 0x9e00);
11924                 MP_WritePhyUshort(sc, 0x15, 0x0031);
11925                 MP_WritePhyUshort(sc, 0x19, 0x63c8);
11926                 MP_WritePhyUshort(sc, 0x15, 0x0032);
11927                 MP_WritePhyUshort(sc, 0x19, 0x6481);
11928                 MP_WritePhyUshort(sc, 0x15, 0x0033);
11929                 MP_WritePhyUshort(sc, 0x19, 0x0000);
11930                 MP_WritePhyUshort(sc, 0x15, 0x0034);
11931                 MP_WritePhyUshort(sc, 0x19, 0x0000);
11932                 MP_WritePhyUshort(sc, 0x15, 0x0035);
11933                 MP_WritePhyUshort(sc, 0x19, 0x0000);
11934                 MP_WritePhyUshort(sc, 0x15, 0x0036);
11935                 MP_WritePhyUshort(sc, 0x19, 0x0000);
11936                 MP_WritePhyUshort(sc, 0x15, 0x0037);
11937                 MP_WritePhyUshort(sc, 0x19, 0x0000);
11938                 MP_WritePhyUshort(sc, 0x15, 0x0038);
11939                 MP_WritePhyUshort(sc, 0x19, 0x0000);
11940                 MP_WritePhyUshort(sc, 0x15, 0x0039);
11941                 MP_WritePhyUshort(sc, 0x19, 0x0000);
11942                 MP_WritePhyUshort(sc, 0x15, 0x003a);
11943                 MP_WritePhyUshort(sc, 0x19, 0x0000);
11944                 MP_WritePhyUshort(sc, 0x15, 0x003b);
11945                 MP_WritePhyUshort(sc, 0x19, 0x63e8);
11946                 MP_WritePhyUshort(sc, 0x15, 0x003c);
11947                 MP_WritePhyUshort(sc, 0x19, 0x7d00);
11948                 MP_WritePhyUshort(sc, 0x15, 0x003d);
11949                 MP_WritePhyUshort(sc, 0x19, 0x59d4);
11950                 MP_WritePhyUshort(sc, 0x15, 0x003e);
11951                 MP_WritePhyUshort(sc, 0x19, 0x63f8);
11952                 MP_WritePhyUshort(sc, 0x15, 0x0040);
11953                 MP_WritePhyUshort(sc, 0x19, 0x64a1);
11954                 MP_WritePhyUshort(sc, 0x15, 0x0041);
11955                 MP_WritePhyUshort(sc, 0x19, 0x30de);
11956                 MP_WritePhyUshort(sc, 0x15, 0x0044);
11957                 MP_WritePhyUshort(sc, 0x19, 0x480f);
11958                 MP_WritePhyUshort(sc, 0x15, 0x0045);
11959                 MP_WritePhyUshort(sc, 0x19, 0x6800);
11960                 MP_WritePhyUshort(sc, 0x15, 0x0046);
11961                 MP_WritePhyUshort(sc, 0x19, 0x6680);
11962                 MP_WritePhyUshort(sc, 0x15, 0x0047);
11963                 MP_WritePhyUshort(sc, 0x19, 0x7c10);
11964                 MP_WritePhyUshort(sc, 0x15, 0x0048);
11965                 MP_WritePhyUshort(sc, 0x19, 0x63c8);
11966                 MP_WritePhyUshort(sc, 0x15, 0x0049);
11967                 MP_WritePhyUshort(sc, 0x19, 0x0000);
11968                 MP_WritePhyUshort(sc, 0x15, 0x004a);
11969                 MP_WritePhyUshort(sc, 0x19, 0x0000);
11970                 MP_WritePhyUshort(sc, 0x15, 0x004b);
11971                 MP_WritePhyUshort(sc, 0x19, 0x0000);
11972                 MP_WritePhyUshort(sc, 0x15, 0x004c);
11973                 MP_WritePhyUshort(sc, 0x19, 0x0000);
11974                 MP_WritePhyUshort(sc, 0x15, 0x004d);
11975                 MP_WritePhyUshort(sc, 0x19, 0x0000);
11976                 MP_WritePhyUshort(sc, 0x15, 0x004e);
11977                 MP_WritePhyUshort(sc, 0x19, 0x0000);
11978                 MP_WritePhyUshort(sc, 0x15, 0x004f);
11979                 MP_WritePhyUshort(sc, 0x19, 0x40ea);
11980                 MP_WritePhyUshort(sc, 0x15, 0x0050);
11981                 MP_WritePhyUshort(sc, 0x19, 0x4503);
11982                 MP_WritePhyUshort(sc, 0x15, 0x0051);
11983                 MP_WritePhyUshort(sc, 0x19, 0x58ca);
11984                 MP_WritePhyUshort(sc, 0x15, 0x0052);
11985                 MP_WritePhyUshort(sc, 0x19, 0x63c8);
11986                 MP_WritePhyUshort(sc, 0x15, 0x0053);
11987                 MP_WritePhyUshort(sc, 0x19, 0x63d8);
11988                 MP_WritePhyUshort(sc, 0x15, 0x0054);
11989                 MP_WritePhyUshort(sc, 0x19, 0x66a0);
11990                 MP_WritePhyUshort(sc, 0x15, 0x0055);
11991                 MP_WritePhyUshort(sc, 0x19, 0x9f00);
11992                 MP_WritePhyUshort(sc, 0x15, 0x0056);
11993                 MP_WritePhyUshort(sc, 0x19, 0x3000);
11994                 MP_WritePhyUshort(sc, 0x15, 0x00a1);
11995                 MP_WritePhyUshort(sc, 0x19, 0x3044);
11996                 MP_WritePhyUshort(sc, 0x15, 0x00ab);
11997                 MP_WritePhyUshort(sc, 0x19, 0x5820);
11998                 MP_WritePhyUshort(sc, 0x15, 0x00ac);
11999                 MP_WritePhyUshort(sc, 0x19, 0x5e04);
12000                 MP_WritePhyUshort(sc, 0x15, 0x00ad);
12001                 MP_WritePhyUshort(sc, 0x19, 0xb60c);
12002                 MP_WritePhyUshort(sc, 0x15, 0x00af);
12003                 MP_WritePhyUshort(sc, 0x19, 0x000a);
12004                 MP_WritePhyUshort(sc, 0x15, 0x00b2);
12005                 MP_WritePhyUshort(sc, 0x19, 0x30b9);
12006                 MP_WritePhyUshort(sc, 0x15, 0x00b9);
12007                 MP_WritePhyUshort(sc, 0x19, 0x4408);
12008                 MP_WritePhyUshort(sc, 0x15, 0x00ba);
12009                 MP_WritePhyUshort(sc, 0x19, 0x480b);
12010                 MP_WritePhyUshort(sc, 0x15, 0x00bb);
12011                 MP_WritePhyUshort(sc, 0x19, 0x5e00);
12012                 MP_WritePhyUshort(sc, 0x15, 0x00bc);
12013                 MP_WritePhyUshort(sc, 0x19, 0x405f);
12014                 MP_WritePhyUshort(sc, 0x15, 0x00bd);
12015                 MP_WritePhyUshort(sc, 0x19, 0x4448);
12016                 MP_WritePhyUshort(sc, 0x15, 0x00be);
12017                 MP_WritePhyUshort(sc, 0x19, 0x4020);
12018                 MP_WritePhyUshort(sc, 0x15, 0x00bf);
12019                 MP_WritePhyUshort(sc, 0x19, 0x4468);
12020                 MP_WritePhyUshort(sc, 0x15, 0x00c0);
12021                 MP_WritePhyUshort(sc, 0x19, 0x9c02);
12022                 MP_WritePhyUshort(sc, 0x15, 0x00c1);
12023                 MP_WritePhyUshort(sc, 0x19, 0x58a0);
12024                 MP_WritePhyUshort(sc, 0x15, 0x00c2);
12025                 MP_WritePhyUshort(sc, 0x19, 0xb605);
12026                 MP_WritePhyUshort(sc, 0x15, 0x00c3);
12027                 MP_WritePhyUshort(sc, 0x19, 0xc0d3);
12028                 MP_WritePhyUshort(sc, 0x15, 0x00c4);
12029                 MP_WritePhyUshort(sc, 0x19, 0x00e6);
12030                 MP_WritePhyUshort(sc, 0x15, 0x00c5);
12031                 MP_WritePhyUshort(sc, 0x19, 0xdaec);
12032                 MP_WritePhyUshort(sc, 0x15, 0x00c6);
12033                 MP_WritePhyUshort(sc, 0x19, 0x00fa);
12034                 MP_WritePhyUshort(sc, 0x15, 0x00c7);
12035                 MP_WritePhyUshort(sc, 0x19, 0x9df9);
12036                 MP_WritePhyUshort(sc, 0x15, 0x0112);
12037                 MP_WritePhyUshort(sc, 0x19, 0x6421);
12038                 MP_WritePhyUshort(sc, 0x15, 0x0113);
12039                 MP_WritePhyUshort(sc, 0x19, 0x7c08);
12040                 MP_WritePhyUshort(sc, 0x15, 0x0114);
12041                 MP_WritePhyUshort(sc, 0x19, 0x63f0);
12042                 MP_WritePhyUshort(sc, 0x15, 0x0115);
12043                 MP_WritePhyUshort(sc, 0x19, 0x4003);
12044                 MP_WritePhyUshort(sc, 0x15, 0x0116);
12045                 MP_WritePhyUshort(sc, 0x19, 0x4418);
12046                 MP_WritePhyUshort(sc, 0x15, 0x0117);
12047                 MP_WritePhyUshort(sc, 0x19, 0x9b00);
12048                 MP_WritePhyUshort(sc, 0x15, 0x0118);
12049                 MP_WritePhyUshort(sc, 0x19, 0x6461);
12050                 MP_WritePhyUshort(sc, 0x15, 0x0119);
12051                 MP_WritePhyUshort(sc, 0x19, 0x64e1);
12052                 MP_WritePhyUshort(sc, 0x15, 0x011a);
12053                 MP_WritePhyUshort(sc, 0x19, 0x0000);
12054                 MP_WritePhyUshort(sc, 0x15, 0x0150);
12055                 MP_WritePhyUshort(sc, 0x19, 0x7c80);
12056                 MP_WritePhyUshort(sc, 0x15, 0x0151);
12057                 MP_WritePhyUshort(sc, 0x19, 0x6461);
12058                 MP_WritePhyUshort(sc, 0x15, 0x0152);
12059                 MP_WritePhyUshort(sc, 0x19, 0x4003);
12060                 MP_WritePhyUshort(sc, 0x15, 0x0153);
12061                 MP_WritePhyUshort(sc, 0x19, 0x4540);
12062                 MP_WritePhyUshort(sc, 0x15, 0x0154);
12063                 MP_WritePhyUshort(sc, 0x19, 0x9f00);
12064                 MP_WritePhyUshort(sc, 0x15, 0x0155);
12065                 MP_WritePhyUshort(sc, 0x19, 0x9d00);
12066                 MP_WritePhyUshort(sc, 0x15, 0x0156);
12067                 MP_WritePhyUshort(sc, 0x19, 0x7c40);
12068                 MP_WritePhyUshort(sc, 0x15, 0x0157);
12069                 MP_WritePhyUshort(sc, 0x19, 0x6421);
12070                 MP_WritePhyUshort(sc, 0x15, 0x0158);
12071                 MP_WritePhyUshort(sc, 0x19, 0x7c80);
12072                 MP_WritePhyUshort(sc, 0x15, 0x0159);
12073                 MP_WritePhyUshort(sc, 0x19, 0x64a1);
12074                 MP_WritePhyUshort(sc, 0x15, 0x015a);
12075                 MP_WritePhyUshort(sc, 0x19, 0x30fe);
12076                 MP_WritePhyUshort(sc, 0x15, 0x029c);
12077                 MP_WritePhyUshort(sc, 0x19, 0x0070);
12078                 MP_WritePhyUshort(sc, 0x15, 0x02b2);
12079                 MP_WritePhyUshort(sc, 0x19, 0x005a);
12080                 MP_WritePhyUshort(sc, 0x15, 0x02bd);
12081                 MP_WritePhyUshort(sc, 0x19, 0xa522);
12082                 MP_WritePhyUshort(sc, 0x15, 0x02ce);
12083                 MP_WritePhyUshort(sc, 0x19, 0xb63e);
12084                 MP_WritePhyUshort(sc, 0x15, 0x02d9);
12085                 MP_WritePhyUshort(sc, 0x19, 0x32df);
12086                 MP_WritePhyUshort(sc, 0x15, 0x02df);
12087                 MP_WritePhyUshort(sc, 0x19, 0x4500);
12088                 MP_WritePhyUshort(sc, 0x15, 0x02f4);
12089                 MP_WritePhyUshort(sc, 0x19, 0xb618);
12090                 MP_WritePhyUshort(sc, 0x15, 0x02fb);
12091                 MP_WritePhyUshort(sc, 0x19, 0xb900);
12092                 MP_WritePhyUshort(sc, 0x15, 0x02fc);
12093                 MP_WritePhyUshort(sc, 0x19, 0x49b5);
12094                 MP_WritePhyUshort(sc, 0x15, 0x02fd);
12095                 MP_WritePhyUshort(sc, 0x19, 0x6812);
12096                 MP_WritePhyUshort(sc, 0x15, 0x02fe);
12097                 MP_WritePhyUshort(sc, 0x19, 0x66a0);
12098                 MP_WritePhyUshort(sc, 0x15, 0x02ff);
12099                 MP_WritePhyUshort(sc, 0x19, 0x9900);
12100                 MP_WritePhyUshort(sc, 0x15, 0x0300);
12101                 MP_WritePhyUshort(sc, 0x19, 0x64a0);
12102                 MP_WritePhyUshort(sc, 0x15, 0x0301);
12103                 MP_WritePhyUshort(sc, 0x19, 0x3316);
12104                 MP_WritePhyUshort(sc, 0x15, 0x0308);
12105                 MP_WritePhyUshort(sc, 0x19, 0x0000);
12106                 MP_WritePhyUshort(sc, 0x15, 0x030c);
12107                 MP_WritePhyUshort(sc, 0x19, 0x3000);
12108                 MP_WritePhyUshort(sc, 0x15, 0x0312);
12109                 MP_WritePhyUshort(sc, 0x19, 0x0000);
12110                 MP_WritePhyUshort(sc, 0x15, 0x0313);
12111                 MP_WritePhyUshort(sc, 0x19, 0x0000);
12112                 MP_WritePhyUshort(sc, 0x15, 0x0314);
12113                 MP_WritePhyUshort(sc, 0x19, 0x0000);
12114                 MP_WritePhyUshort(sc, 0x15, 0x0315);
12115                 MP_WritePhyUshort(sc, 0x19, 0x0000);
12116                 MP_WritePhyUshort(sc, 0x15, 0x0316);
12117                 MP_WritePhyUshort(sc, 0x19, 0x49b5);
12118                 MP_WritePhyUshort(sc, 0x15, 0x0317);
12119                 MP_WritePhyUshort(sc, 0x19, 0x7d00);
12120                 MP_WritePhyUshort(sc, 0x15, 0x0318);
12121                 MP_WritePhyUshort(sc, 0x19, 0x4d00);
12122                 MP_WritePhyUshort(sc, 0x15, 0x0319);
12123                 MP_WritePhyUshort(sc, 0x19, 0x6810);
12124                 MP_WritePhyUshort(sc, 0x15, 0x031a);
12125                 MP_WritePhyUshort(sc, 0x19, 0x6c08);
12126                 MP_WritePhyUshort(sc, 0x15, 0x031b);
12127                 MP_WritePhyUshort(sc, 0x19, 0x4925);
12128                 MP_WritePhyUshort(sc, 0x15, 0x031c);
12129                 MP_WritePhyUshort(sc, 0x19, 0x403b);
12130                 MP_WritePhyUshort(sc, 0x15, 0x031d);
12131                 MP_WritePhyUshort(sc, 0x19, 0xa602);
12132                 MP_WritePhyUshort(sc, 0x15, 0x031e);
12133                 MP_WritePhyUshort(sc, 0x19, 0x402f);
12134                 MP_WritePhyUshort(sc, 0x15, 0x031f);
12135                 MP_WritePhyUshort(sc, 0x19, 0x4484);
12136                 MP_WritePhyUshort(sc, 0x15, 0x0320);
12137                 MP_WritePhyUshort(sc, 0x19, 0x40c8);
12138                 MP_WritePhyUshort(sc, 0x15, 0x0321);
12139                 MP_WritePhyUshort(sc, 0x19, 0x44c4);
12140                 MP_WritePhyUshort(sc, 0x15, 0x0322);
12141                 MP_WritePhyUshort(sc, 0x19, 0x404f);
12142                 MP_WritePhyUshort(sc, 0x15, 0x0323);
12143                 MP_WritePhyUshort(sc, 0x19, 0x44c8);
12144                 MP_WritePhyUshort(sc, 0x15, 0x0324);
12145                 MP_WritePhyUshort(sc, 0x19, 0xd64f);
12146                 MP_WritePhyUshort(sc, 0x15, 0x0325);
12147                 MP_WritePhyUshort(sc, 0x19, 0x00e7);
12148                 MP_WritePhyUshort(sc, 0x15, 0x0326);
12149                 MP_WritePhyUshort(sc, 0x19, 0x7c08);
12150                 MP_WritePhyUshort(sc, 0x15, 0x0327);
12151                 MP_WritePhyUshort(sc, 0x19, 0x8203);
12152                 MP_WritePhyUshort(sc, 0x15, 0x0328);
12153                 MP_WritePhyUshort(sc, 0x19, 0x4d48);
12154                 MP_WritePhyUshort(sc, 0x15, 0x0329);
12155                 MP_WritePhyUshort(sc, 0x19, 0x332b);
12156                 MP_WritePhyUshort(sc, 0x15, 0x032a);
12157                 MP_WritePhyUshort(sc, 0x19, 0x4d40);
12158                 MP_WritePhyUshort(sc, 0x15, 0x032c);
12159                 MP_WritePhyUshort(sc, 0x19, 0x00f8);
12160                 MP_WritePhyUshort(sc, 0x15, 0x032d);
12161                 MP_WritePhyUshort(sc, 0x19, 0x82b2);
12162                 MP_WritePhyUshort(sc, 0x15, 0x032f);
12163                 MP_WritePhyUshort(sc, 0x19, 0x00b0);
12164                 MP_WritePhyUshort(sc, 0x15, 0x0332);
12165                 MP_WritePhyUshort(sc, 0x19, 0x91f2);
12166                 MP_WritePhyUshort(sc, 0x15, 0x033f);
12167                 MP_WritePhyUshort(sc, 0x19, 0xb6cd);
12168                 MP_WritePhyUshort(sc, 0x15, 0x0340);
12169                 MP_WritePhyUshort(sc, 0x19, 0x9e01);
12170                 MP_WritePhyUshort(sc, 0x15, 0x0341);
12171                 MP_WritePhyUshort(sc, 0x19, 0xd11d);
12172                 MP_WritePhyUshort(sc, 0x15, 0x0342);
12173                 MP_WritePhyUshort(sc, 0x19, 0x009d);
12174                 MP_WritePhyUshort(sc, 0x15, 0x0343);
12175                 MP_WritePhyUshort(sc, 0x19, 0xbb1c);
12176                 MP_WritePhyUshort(sc, 0x15, 0x0344);
12177                 MP_WritePhyUshort(sc, 0x19, 0x8102);
12178                 MP_WritePhyUshort(sc, 0x15, 0x0345);
12179                 MP_WritePhyUshort(sc, 0x19, 0x3348);
12180                 MP_WritePhyUshort(sc, 0x15, 0x0346);
12181                 MP_WritePhyUshort(sc, 0x19, 0xa231);
12182                 MP_WritePhyUshort(sc, 0x15, 0x0347);
12183                 MP_WritePhyUshort(sc, 0x19, 0x335b);
12184                 MP_WritePhyUshort(sc, 0x15, 0x0348);
12185                 MP_WritePhyUshort(sc, 0x19, 0x91f7);
12186                 MP_WritePhyUshort(sc, 0x15, 0x0349);
12187                 MP_WritePhyUshort(sc, 0x19, 0xc218);
12188                 MP_WritePhyUshort(sc, 0x15, 0x034a);
12189                 MP_WritePhyUshort(sc, 0x19, 0x00f5);
12190                 MP_WritePhyUshort(sc, 0x15, 0x034b);
12191                 MP_WritePhyUshort(sc, 0x19, 0x335b);
12192                 MP_WritePhyUshort(sc, 0x15, 0x034c);
12193                 MP_WritePhyUshort(sc, 0x19, 0x0000);
12194                 MP_WritePhyUshort(sc, 0x15, 0x034d);
12195                 MP_WritePhyUshort(sc, 0x19, 0x0000);
12196                 MP_WritePhyUshort(sc, 0x15, 0x034e);
12197                 MP_WritePhyUshort(sc, 0x19, 0x0000);
12198                 MP_WritePhyUshort(sc, 0x15, 0x034f);
12199                 MP_WritePhyUshort(sc, 0x19, 0x0000);
12200                 MP_WritePhyUshort(sc, 0x15, 0x0350);
12201                 MP_WritePhyUshort(sc, 0x19, 0x0000);
12202                 MP_WritePhyUshort(sc, 0x15, 0x035b);
12203                 MP_WritePhyUshort(sc, 0x19, 0xa23c);
12204                 MP_WritePhyUshort(sc, 0x15, 0x035c);
12205                 MP_WritePhyUshort(sc, 0x19, 0x7c08);
12206                 MP_WritePhyUshort(sc, 0x15, 0x035d);
12207                 MP_WritePhyUshort(sc, 0x19, 0x4c00);
12208                 MP_WritePhyUshort(sc, 0x15, 0x035e);
12209                 MP_WritePhyUshort(sc, 0x19, 0x3397);
12210                 MP_WritePhyUshort(sc, 0x15, 0x0363);
12211                 MP_WritePhyUshort(sc, 0x19, 0xb6a9);
12212                 MP_WritePhyUshort(sc, 0x15, 0x0366);
12213                 MP_WritePhyUshort(sc, 0x19, 0x00f5);
12214                 MP_WritePhyUshort(sc, 0x15, 0x0382);
12215                 MP_WritePhyUshort(sc, 0x19, 0x7c40);
12216                 MP_WritePhyUshort(sc, 0x15, 0x0388);
12217                 MP_WritePhyUshort(sc, 0x19, 0x0084);
12218                 MP_WritePhyUshort(sc, 0x15, 0x0389);
12219                 MP_WritePhyUshort(sc, 0x19, 0xdd17);
12220                 MP_WritePhyUshort(sc, 0x15, 0x038a);
12221                 MP_WritePhyUshort(sc, 0x19, 0x000b);
12222                 MP_WritePhyUshort(sc, 0x15, 0x038b);
12223                 MP_WritePhyUshort(sc, 0x19, 0xa10a);
12224                 MP_WritePhyUshort(sc, 0x15, 0x038c);
12225                 MP_WritePhyUshort(sc, 0x19, 0x337e);
12226                 MP_WritePhyUshort(sc, 0x15, 0x038d);
12227                 MP_WritePhyUshort(sc, 0x19, 0x6c0b);
12228                 MP_WritePhyUshort(sc, 0x15, 0x038e);
12229                 MP_WritePhyUshort(sc, 0x19, 0xa107);
12230                 MP_WritePhyUshort(sc, 0x15, 0x038f);
12231                 MP_WritePhyUshort(sc, 0x19, 0x6c08);
12232                 MP_WritePhyUshort(sc, 0x15, 0x0390);
12233                 MP_WritePhyUshort(sc, 0x19, 0xc017);
12234                 MP_WritePhyUshort(sc, 0x15, 0x0391);
12235                 MP_WritePhyUshort(sc, 0x19, 0x0004);
12236                 MP_WritePhyUshort(sc, 0x15, 0x0392);
12237                 MP_WritePhyUshort(sc, 0x19, 0xd64f);
12238                 MP_WritePhyUshort(sc, 0x15, 0x0393);
12239                 MP_WritePhyUshort(sc, 0x19, 0x00f4);
12240                 MP_WritePhyUshort(sc, 0x15, 0x0397);
12241                 MP_WritePhyUshort(sc, 0x19, 0x4098);
12242                 MP_WritePhyUshort(sc, 0x15, 0x0398);
12243                 MP_WritePhyUshort(sc, 0x19, 0x4408);
12244                 MP_WritePhyUshort(sc, 0x15, 0x0399);
12245                 MP_WritePhyUshort(sc, 0x19, 0x55bf);
12246                 MP_WritePhyUshort(sc, 0x15, 0x039a);
12247                 MP_WritePhyUshort(sc, 0x19, 0x4bb9);
12248                 MP_WritePhyUshort(sc, 0x15, 0x039b);
12249                 MP_WritePhyUshort(sc, 0x19, 0x6810);
12250                 MP_WritePhyUshort(sc, 0x15, 0x039c);
12251                 MP_WritePhyUshort(sc, 0x19, 0x4b29);
12252                 MP_WritePhyUshort(sc, 0x15, 0x039d);
12253                 MP_WritePhyUshort(sc, 0x19, 0x4041);
12254                 MP_WritePhyUshort(sc, 0x15, 0x039e);
12255                 MP_WritePhyUshort(sc, 0x19, 0x442a);
12256                 MP_WritePhyUshort(sc, 0x15, 0x039f);
12257                 MP_WritePhyUshort(sc, 0x19, 0x4029);
12258                 MP_WritePhyUshort(sc, 0x15, 0x03aa);
12259                 MP_WritePhyUshort(sc, 0x19, 0x33b8);
12260                 MP_WritePhyUshort(sc, 0x15, 0x03b6);
12261                 MP_WritePhyUshort(sc, 0x19, 0x0000);
12262                 MP_WritePhyUshort(sc, 0x15, 0x03b7);
12263                 MP_WritePhyUshort(sc, 0x19, 0x0000);
12264                 MP_WritePhyUshort(sc, 0x15, 0x03b8);
12265                 MP_WritePhyUshort(sc, 0x19, 0x543f);
12266                 MP_WritePhyUshort(sc, 0x15, 0x03b9);
12267                 MP_WritePhyUshort(sc, 0x19, 0x499a);
12268                 MP_WritePhyUshort(sc, 0x15, 0x03ba);
12269                 MP_WritePhyUshort(sc, 0x19, 0x7c40);
12270                 MP_WritePhyUshort(sc, 0x15, 0x03bb);
12271                 MP_WritePhyUshort(sc, 0x19, 0x4c40);
12272                 MP_WritePhyUshort(sc, 0x15, 0x03bc);
12273                 MP_WritePhyUshort(sc, 0x19, 0x490a);
12274                 MP_WritePhyUshort(sc, 0x15, 0x03bd);
12275                 MP_WritePhyUshort(sc, 0x19, 0x405e);
12276                 MP_WritePhyUshort(sc, 0x15, 0x03c2);
12277                 MP_WritePhyUshort(sc, 0x19, 0x9a03);
12278                 MP_WritePhyUshort(sc, 0x15, 0x03c4);
12279                 MP_WritePhyUshort(sc, 0x19, 0x0015);
12280                 MP_WritePhyUshort(sc, 0x15, 0x03c5);
12281                 MP_WritePhyUshort(sc, 0x19, 0x9e03);
12282                 MP_WritePhyUshort(sc, 0x15, 0x03c8);
12283                 MP_WritePhyUshort(sc, 0x19, 0x9cf7);
12284                 MP_WritePhyUshort(sc, 0x15, 0x03c9);
12285                 MP_WritePhyUshort(sc, 0x19, 0x7c12);
12286                 MP_WritePhyUshort(sc, 0x15, 0x03ca);
12287                 MP_WritePhyUshort(sc, 0x19, 0x4c52);
12288                 MP_WritePhyUshort(sc, 0x15, 0x03cb);
12289                 MP_WritePhyUshort(sc, 0x19, 0x4458);
12290                 MP_WritePhyUshort(sc, 0x15, 0x03cd);
12291                 MP_WritePhyUshort(sc, 0x19, 0x4c40);
12292                 MP_WritePhyUshort(sc, 0x15, 0x03ce);
12293                 MP_WritePhyUshort(sc, 0x19, 0x33bf);
12294                 MP_WritePhyUshort(sc, 0x15, 0x03cf);
12295                 MP_WritePhyUshort(sc, 0x19, 0x0000);
12296                 MP_WritePhyUshort(sc, 0x15, 0x03d0);
12297                 MP_WritePhyUshort(sc, 0x19, 0x0000);
12298                 MP_WritePhyUshort(sc, 0x15, 0x03d1);
12299                 MP_WritePhyUshort(sc, 0x19, 0x0000);
12300                 MP_WritePhyUshort(sc, 0x15, 0x03d5);
12301                 MP_WritePhyUshort(sc, 0x19, 0x0000);
12302                 MP_WritePhyUshort(sc, 0x15, 0x03d6);
12303                 MP_WritePhyUshort(sc, 0x19, 0x0000);
12304                 MP_WritePhyUshort(sc, 0x15, 0x03d7);
12305                 MP_WritePhyUshort(sc, 0x19, 0x0000);
12306                 MP_WritePhyUshort(sc, 0x15, 0x03d8);
12307                 MP_WritePhyUshort(sc, 0x19, 0x0000);
12308                 MP_WritePhyUshort(sc, 0x15, 0x03d9);
12309                 MP_WritePhyUshort(sc, 0x19, 0x49bb);
12310                 MP_WritePhyUshort(sc, 0x15, 0x03da);
12311                 MP_WritePhyUshort(sc, 0x19, 0x4478);
12312                 MP_WritePhyUshort(sc, 0x15, 0x03db);
12313                 MP_WritePhyUshort(sc, 0x19, 0x492b);
12314                 MP_WritePhyUshort(sc, 0x15, 0x03dc);
12315                 MP_WritePhyUshort(sc, 0x19, 0x7c01);
12316                 MP_WritePhyUshort(sc, 0x15, 0x03dd);
12317                 MP_WritePhyUshort(sc, 0x19, 0x4c00);
12318                 MP_WritePhyUshort(sc, 0x15, 0x03de);
12319                 MP_WritePhyUshort(sc, 0x19, 0xbd1a);
12320                 MP_WritePhyUshort(sc, 0x15, 0x03df);
12321                 MP_WritePhyUshort(sc, 0x19, 0xc428);
12322                 MP_WritePhyUshort(sc, 0x15, 0x03e0);
12323                 MP_WritePhyUshort(sc, 0x19, 0x0008);
12324                 MP_WritePhyUshort(sc, 0x15, 0x03e1);
12325                 MP_WritePhyUshort(sc, 0x19, 0x9cfd);
12326                 MP_WritePhyUshort(sc, 0x15, 0x03e2);
12327                 MP_WritePhyUshort(sc, 0x19, 0x7c12);
12328                 MP_WritePhyUshort(sc, 0x15, 0x03e3);
12329                 MP_WritePhyUshort(sc, 0x19, 0x4c52);
12330                 MP_WritePhyUshort(sc, 0x15, 0x03e4);
12331                 MP_WritePhyUshort(sc, 0x19, 0x4458);
12332                 MP_WritePhyUshort(sc, 0x15, 0x03e5);
12333                 MP_WritePhyUshort(sc, 0x19, 0x7c12);
12334                 MP_WritePhyUshort(sc, 0x15, 0x03e6);
12335                 MP_WritePhyUshort(sc, 0x19, 0x4c40);
12336                 MP_WritePhyUshort(sc, 0x15, 0x03e7);
12337                 MP_WritePhyUshort(sc, 0x19, 0x33de);
12338                 MP_WritePhyUshort(sc, 0x15, 0x03e8);
12339                 MP_WritePhyUshort(sc, 0x19, 0xc218);
12340                 MP_WritePhyUshort(sc, 0x15, 0x03e9);
12341                 MP_WritePhyUshort(sc, 0x19, 0x0002);
12342                 MP_WritePhyUshort(sc, 0x15, 0x03ea);
12343                 MP_WritePhyUshort(sc, 0x19, 0x32df);
12344                 MP_WritePhyUshort(sc, 0x15, 0x03eb);
12345                 MP_WritePhyUshort(sc, 0x19, 0x3316);
12346                 MP_WritePhyUshort(sc, 0x15, 0x03ec);
12347                 MP_WritePhyUshort(sc, 0x19, 0x0000);
12348                 MP_WritePhyUshort(sc, 0x15, 0x03ed);
12349                 MP_WritePhyUshort(sc, 0x19, 0x0000);
12350                 MP_WritePhyUshort(sc, 0x15, 0x03ee);
12351                 MP_WritePhyUshort(sc, 0x19, 0x0000);
12352                 MP_WritePhyUshort(sc, 0x15, 0x03ef);
12353                 MP_WritePhyUshort(sc, 0x19, 0x0000);
12354                 MP_WritePhyUshort(sc, 0x15, 0x03f7);
12355                 MP_WritePhyUshort(sc, 0x19, 0x330c);
12356                 MP_WritePhyUshort(sc, 0x16, 0x0306);
12357                 MP_WritePhyUshort(sc, 0x16, 0x0300);
12358
12359                 MP_WritePhyUshort(sc, 0x1f, 0x0005);
12360                 MP_WritePhyUshort(sc, 0x05, 0xfff6);
12361                 MP_WritePhyUshort(sc, 0x06, 0x0080);
12362                 MP_WritePhyUshort(sc, 0x05, 0x8000);
12363                 MP_WritePhyUshort(sc, 0x06, 0x0280);
12364                 MP_WritePhyUshort(sc, 0x06, 0x48f7);
12365                 MP_WritePhyUshort(sc, 0x06, 0x00e0);
12366                 MP_WritePhyUshort(sc, 0x06, 0xfff7);
12367                 MP_WritePhyUshort(sc, 0x06, 0xa080);
12368                 MP_WritePhyUshort(sc, 0x06, 0x02ae);
12369                 MP_WritePhyUshort(sc, 0x06, 0xf602);
12370                 MP_WritePhyUshort(sc, 0x06, 0x0200);
12371                 MP_WritePhyUshort(sc, 0x06, 0x0280);
12372                 MP_WritePhyUshort(sc, 0x06, 0x9002);
12373                 MP_WritePhyUshort(sc, 0x06, 0x0224);
12374                 MP_WritePhyUshort(sc, 0x06, 0x0202);
12375                 MP_WritePhyUshort(sc, 0x06, 0x3402);
12376                 MP_WritePhyUshort(sc, 0x06, 0x027f);
12377                 MP_WritePhyUshort(sc, 0x06, 0x0280);
12378                 MP_WritePhyUshort(sc, 0x06, 0xa602);
12379                 MP_WritePhyUshort(sc, 0x06, 0x80bf);
12380                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
12381                 MP_WritePhyUshort(sc, 0x06, 0x88e1);
12382                 MP_WritePhyUshort(sc, 0x06, 0x8b89);
12383                 MP_WritePhyUshort(sc, 0x06, 0x1e01);
12384                 MP_WritePhyUshort(sc, 0x06, 0xe18b);
12385                 MP_WritePhyUshort(sc, 0x06, 0x8a1e);
12386                 MP_WritePhyUshort(sc, 0x06, 0x01e1);
12387                 MP_WritePhyUshort(sc, 0x06, 0x8b8b);
12388                 MP_WritePhyUshort(sc, 0x06, 0x1e01);
12389                 MP_WritePhyUshort(sc, 0x06, 0xe18b);
12390                 MP_WritePhyUshort(sc, 0x06, 0x8c1e);
12391                 MP_WritePhyUshort(sc, 0x06, 0x01e1);
12392                 MP_WritePhyUshort(sc, 0x06, 0x8b8d);
12393                 MP_WritePhyUshort(sc, 0x06, 0x1e01);
12394                 MP_WritePhyUshort(sc, 0x06, 0xe18b);
12395                 MP_WritePhyUshort(sc, 0x06, 0x8e1e);
12396                 MP_WritePhyUshort(sc, 0x06, 0x01a0);
12397                 MP_WritePhyUshort(sc, 0x06, 0x00c7);
12398                 MP_WritePhyUshort(sc, 0x06, 0xaebb);
12399                 MP_WritePhyUshort(sc, 0x06, 0xee8a);
12400                 MP_WritePhyUshort(sc, 0x06, 0xe600);
12401                 MP_WritePhyUshort(sc, 0x06, 0xee8a);
12402                 MP_WritePhyUshort(sc, 0x06, 0xee03);
12403                 MP_WritePhyUshort(sc, 0x06, 0xee8a);
12404                 MP_WritePhyUshort(sc, 0x06, 0xefb8);
12405                 MP_WritePhyUshort(sc, 0x06, 0xee8a);
12406                 MP_WritePhyUshort(sc, 0x06, 0xe902);
12407                 MP_WritePhyUshort(sc, 0x06, 0xee8b);
12408                 MP_WritePhyUshort(sc, 0x06, 0x8285);
12409                 MP_WritePhyUshort(sc, 0x06, 0xee8b);
12410                 MP_WritePhyUshort(sc, 0x06, 0x8520);
12411                 MP_WritePhyUshort(sc, 0x06, 0xee8b);
12412                 MP_WritePhyUshort(sc, 0x06, 0x8701);
12413                 MP_WritePhyUshort(sc, 0x06, 0xd481);
12414                 MP_WritePhyUshort(sc, 0x06, 0x35e4);
12415                 MP_WritePhyUshort(sc, 0x06, 0x8b94);
12416                 MP_WritePhyUshort(sc, 0x06, 0xe58b);
12417                 MP_WritePhyUshort(sc, 0x06, 0x95bf);
12418                 MP_WritePhyUshort(sc, 0x06, 0x8b88);
12419                 MP_WritePhyUshort(sc, 0x06, 0xec00);
12420                 MP_WritePhyUshort(sc, 0x06, 0x19a9);
12421                 MP_WritePhyUshort(sc, 0x06, 0x8b90);
12422                 MP_WritePhyUshort(sc, 0x06, 0xf9ee);
12423                 MP_WritePhyUshort(sc, 0x06, 0xfff6);
12424                 MP_WritePhyUshort(sc, 0x06, 0x00ee);
12425                 MP_WritePhyUshort(sc, 0x06, 0xfff7);
12426                 MP_WritePhyUshort(sc, 0x06, 0xffe0);
12427                 MP_WritePhyUshort(sc, 0x06, 0xe140);
12428                 MP_WritePhyUshort(sc, 0x06, 0xe1e1);
12429                 MP_WritePhyUshort(sc, 0x06, 0x41f7);
12430                 MP_WritePhyUshort(sc, 0x06, 0x2ff6);
12431                 MP_WritePhyUshort(sc, 0x06, 0x28e4);
12432                 MP_WritePhyUshort(sc, 0x06, 0xe140);
12433                 MP_WritePhyUshort(sc, 0x06, 0xe5e1);
12434                 MP_WritePhyUshort(sc, 0x06, 0x4104);
12435                 MP_WritePhyUshort(sc, 0x06, 0xf8e0);
12436                 MP_WritePhyUshort(sc, 0x06, 0x8b89);
12437                 MP_WritePhyUshort(sc, 0x06, 0xad20);
12438                 MP_WritePhyUshort(sc, 0x06, 0x0dee);
12439                 MP_WritePhyUshort(sc, 0x06, 0x8b89);
12440                 MP_WritePhyUshort(sc, 0x06, 0x0002);
12441                 MP_WritePhyUshort(sc, 0x06, 0x82f4);
12442                 MP_WritePhyUshort(sc, 0x06, 0x021f);
12443                 MP_WritePhyUshort(sc, 0x06, 0x4102);
12444                 MP_WritePhyUshort(sc, 0x06, 0x2812);
12445                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
12446                 MP_WritePhyUshort(sc, 0x06, 0xf8e0);
12447                 MP_WritePhyUshort(sc, 0x06, 0x8b8d);
12448                 MP_WritePhyUshort(sc, 0x06, 0xad20);
12449                 MP_WritePhyUshort(sc, 0x06, 0x10ee);
12450                 MP_WritePhyUshort(sc, 0x06, 0x8b8d);
12451                 MP_WritePhyUshort(sc, 0x06, 0x0002);
12452                 MP_WritePhyUshort(sc, 0x06, 0x139d);
12453                 MP_WritePhyUshort(sc, 0x06, 0x0281);
12454                 MP_WritePhyUshort(sc, 0x06, 0xd602);
12455                 MP_WritePhyUshort(sc, 0x06, 0x1f99);
12456                 MP_WritePhyUshort(sc, 0x06, 0x0227);
12457                 MP_WritePhyUshort(sc, 0x06, 0xeafc);
12458                 MP_WritePhyUshort(sc, 0x06, 0x04f8);
12459                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
12460                 MP_WritePhyUshort(sc, 0x06, 0x8ead);
12461                 MP_WritePhyUshort(sc, 0x06, 0x2014);
12462                 MP_WritePhyUshort(sc, 0x06, 0xf620);
12463                 MP_WritePhyUshort(sc, 0x06, 0xe48b);
12464                 MP_WritePhyUshort(sc, 0x06, 0x8e02);
12465                 MP_WritePhyUshort(sc, 0x06, 0x8104);
12466                 MP_WritePhyUshort(sc, 0x06, 0x021b);
12467                 MP_WritePhyUshort(sc, 0x06, 0xf402);
12468                 MP_WritePhyUshort(sc, 0x06, 0x2c9c);
12469                 MP_WritePhyUshort(sc, 0x06, 0x0281);
12470                 MP_WritePhyUshort(sc, 0x06, 0x7902);
12471                 MP_WritePhyUshort(sc, 0x06, 0x8443);
12472                 MP_WritePhyUshort(sc, 0x06, 0xad22);
12473                 MP_WritePhyUshort(sc, 0x06, 0x11f6);
12474                 MP_WritePhyUshort(sc, 0x06, 0x22e4);
12475                 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
12476                 MP_WritePhyUshort(sc, 0x06, 0x022c);
12477                 MP_WritePhyUshort(sc, 0x06, 0x4602);
12478                 MP_WritePhyUshort(sc, 0x06, 0x2ac5);
12479                 MP_WritePhyUshort(sc, 0x06, 0x0229);
12480                 MP_WritePhyUshort(sc, 0x06, 0x2002);
12481                 MP_WritePhyUshort(sc, 0x06, 0x2b91);
12482                 MP_WritePhyUshort(sc, 0x06, 0xad25);
12483                 MP_WritePhyUshort(sc, 0x06, 0x11f6);
12484                 MP_WritePhyUshort(sc, 0x06, 0x25e4);
12485                 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
12486                 MP_WritePhyUshort(sc, 0x06, 0x0284);
12487                 MP_WritePhyUshort(sc, 0x06, 0xe202);
12488                 MP_WritePhyUshort(sc, 0x06, 0x043a);
12489                 MP_WritePhyUshort(sc, 0x06, 0x021a);
12490                 MP_WritePhyUshort(sc, 0x06, 0x5902);
12491                 MP_WritePhyUshort(sc, 0x06, 0x2bfc);
12492                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
12493                 MP_WritePhyUshort(sc, 0x06, 0xf8fa);
12494                 MP_WritePhyUshort(sc, 0x06, 0xef69);
12495                 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
12496                 MP_WritePhyUshort(sc, 0x06, 0x00e1);
12497                 MP_WritePhyUshort(sc, 0x06, 0xe001);
12498                 MP_WritePhyUshort(sc, 0x06, 0xad27);
12499                 MP_WritePhyUshort(sc, 0x06, 0x1fd1);
12500                 MP_WritePhyUshort(sc, 0x06, 0x01bf);
12501                 MP_WritePhyUshort(sc, 0x06, 0x8638);
12502                 MP_WritePhyUshort(sc, 0x06, 0x022f);
12503                 MP_WritePhyUshort(sc, 0x06, 0x50e0);
12504                 MP_WritePhyUshort(sc, 0x06, 0xe020);
12505                 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
12506                 MP_WritePhyUshort(sc, 0x06, 0x21ad);
12507                 MP_WritePhyUshort(sc, 0x06, 0x200e);
12508                 MP_WritePhyUshort(sc, 0x06, 0xd100);
12509                 MP_WritePhyUshort(sc, 0x06, 0xbf86);
12510                 MP_WritePhyUshort(sc, 0x06, 0x3802);
12511                 MP_WritePhyUshort(sc, 0x06, 0x2f50);
12512                 MP_WritePhyUshort(sc, 0x06, 0xbf3d);
12513                 MP_WritePhyUshort(sc, 0x06, 0x3902);
12514                 MP_WritePhyUshort(sc, 0x06, 0x2eb0);
12515                 MP_WritePhyUshort(sc, 0x06, 0xef96);
12516                 MP_WritePhyUshort(sc, 0x06, 0xfefc);
12517                 MP_WritePhyUshort(sc, 0x06, 0x0402);
12518                 MP_WritePhyUshort(sc, 0x06, 0x8591);
12519                 MP_WritePhyUshort(sc, 0x06, 0x0281);
12520                 MP_WritePhyUshort(sc, 0x06, 0x3c05);
12521                 MP_WritePhyUshort(sc, 0x06, 0xf8fa);
12522                 MP_WritePhyUshort(sc, 0x06, 0xef69);
12523                 MP_WritePhyUshort(sc, 0x06, 0xe0e2);
12524                 MP_WritePhyUshort(sc, 0x06, 0xfee1);
12525                 MP_WritePhyUshort(sc, 0x06, 0xe2ff);
12526                 MP_WritePhyUshort(sc, 0x06, 0xad2d);
12527                 MP_WritePhyUshort(sc, 0x06, 0x1ae0);
12528                 MP_WritePhyUshort(sc, 0x06, 0xe14e);
12529                 MP_WritePhyUshort(sc, 0x06, 0xe1e1);
12530                 MP_WritePhyUshort(sc, 0x06, 0x4fac);
12531                 MP_WritePhyUshort(sc, 0x06, 0x2d22);
12532                 MP_WritePhyUshort(sc, 0x06, 0xf603);
12533                 MP_WritePhyUshort(sc, 0x06, 0x0203);
12534                 MP_WritePhyUshort(sc, 0x06, 0x36f7);
12535                 MP_WritePhyUshort(sc, 0x06, 0x03f7);
12536                 MP_WritePhyUshort(sc, 0x06, 0x06bf);
12537                 MP_WritePhyUshort(sc, 0x06, 0x8622);
12538                 MP_WritePhyUshort(sc, 0x06, 0x022e);
12539                 MP_WritePhyUshort(sc, 0x06, 0xb0ae);
12540                 MP_WritePhyUshort(sc, 0x06, 0x11e0);
12541                 MP_WritePhyUshort(sc, 0x06, 0xe14e);
12542                 MP_WritePhyUshort(sc, 0x06, 0xe1e1);
12543                 MP_WritePhyUshort(sc, 0x06, 0x4fad);
12544                 MP_WritePhyUshort(sc, 0x06, 0x2d08);
12545                 MP_WritePhyUshort(sc, 0x06, 0xbf86);
12546                 MP_WritePhyUshort(sc, 0x06, 0x2d02);
12547                 MP_WritePhyUshort(sc, 0x06, 0x2eb0);
12548                 MP_WritePhyUshort(sc, 0x06, 0xf606);
12549                 MP_WritePhyUshort(sc, 0x06, 0xef96);
12550                 MP_WritePhyUshort(sc, 0x06, 0xfefc);
12551                 MP_WritePhyUshort(sc, 0x06, 0x04f8);
12552                 MP_WritePhyUshort(sc, 0x06, 0xf9fa);
12553                 MP_WritePhyUshort(sc, 0x06, 0xef69);
12554                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
12555                 MP_WritePhyUshort(sc, 0x06, 0x87ad);
12556                 MP_WritePhyUshort(sc, 0x06, 0x204c);
12557                 MP_WritePhyUshort(sc, 0x06, 0xd200);
12558                 MP_WritePhyUshort(sc, 0x06, 0xe0e2);
12559                 MP_WritePhyUshort(sc, 0x06, 0x0058);
12560                 MP_WritePhyUshort(sc, 0x06, 0x010c);
12561                 MP_WritePhyUshort(sc, 0x06, 0x021e);
12562                 MP_WritePhyUshort(sc, 0x06, 0x20e0);
12563                 MP_WritePhyUshort(sc, 0x06, 0xe000);
12564                 MP_WritePhyUshort(sc, 0x06, 0x5810);
12565                 MP_WritePhyUshort(sc, 0x06, 0x1e20);
12566                 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
12567                 MP_WritePhyUshort(sc, 0x06, 0x3658);
12568                 MP_WritePhyUshort(sc, 0x06, 0x031e);
12569                 MP_WritePhyUshort(sc, 0x06, 0x20e0);
12570                 MP_WritePhyUshort(sc, 0x06, 0xe022);
12571                 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
12572                 MP_WritePhyUshort(sc, 0x06, 0x2358);
12573                 MP_WritePhyUshort(sc, 0x06, 0xe01e);
12574                 MP_WritePhyUshort(sc, 0x06, 0x20e0);
12575                 MP_WritePhyUshort(sc, 0x06, 0x8ae6);
12576                 MP_WritePhyUshort(sc, 0x06, 0x1f02);
12577                 MP_WritePhyUshort(sc, 0x06, 0x9e22);
12578                 MP_WritePhyUshort(sc, 0x06, 0xe68a);
12579                 MP_WritePhyUshort(sc, 0x06, 0xe6ad);
12580                 MP_WritePhyUshort(sc, 0x06, 0x3214);
12581                 MP_WritePhyUshort(sc, 0x06, 0xad34);
12582                 MP_WritePhyUshort(sc, 0x06, 0x11ef);
12583                 MP_WritePhyUshort(sc, 0x06, 0x0258);
12584                 MP_WritePhyUshort(sc, 0x06, 0x039e);
12585                 MP_WritePhyUshort(sc, 0x06, 0x07ad);
12586                 MP_WritePhyUshort(sc, 0x06, 0x3508);
12587                 MP_WritePhyUshort(sc, 0x06, 0x5ac0);
12588                 MP_WritePhyUshort(sc, 0x06, 0x9f04);
12589                 MP_WritePhyUshort(sc, 0x06, 0xd101);
12590                 MP_WritePhyUshort(sc, 0x06, 0xae02);
12591                 MP_WritePhyUshort(sc, 0x06, 0xd100);
12592                 MP_WritePhyUshort(sc, 0x06, 0xbf86);
12593                 MP_WritePhyUshort(sc, 0x06, 0x3e02);
12594                 MP_WritePhyUshort(sc, 0x06, 0x2f50);
12595                 MP_WritePhyUshort(sc, 0x06, 0xef96);
12596                 MP_WritePhyUshort(sc, 0x06, 0xfefd);
12597                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
12598                 MP_WritePhyUshort(sc, 0x06, 0xf8f9);
12599                 MP_WritePhyUshort(sc, 0x06, 0xfae0);
12600                 MP_WritePhyUshort(sc, 0x06, 0x8b81);
12601                 MP_WritePhyUshort(sc, 0x06, 0xac26);
12602                 MP_WritePhyUshort(sc, 0x06, 0x0ee0);
12603                 MP_WritePhyUshort(sc, 0x06, 0x8b81);
12604                 MP_WritePhyUshort(sc, 0x06, 0xac21);
12605                 MP_WritePhyUshort(sc, 0x06, 0x08e0);
12606                 MP_WritePhyUshort(sc, 0x06, 0x8b87);
12607                 MP_WritePhyUshort(sc, 0x06, 0xac24);
12608                 MP_WritePhyUshort(sc, 0x06, 0x02ae);
12609                 MP_WritePhyUshort(sc, 0x06, 0x6bee);
12610                 MP_WritePhyUshort(sc, 0x06, 0xe0ea);
12611                 MP_WritePhyUshort(sc, 0x06, 0x00ee);
12612                 MP_WritePhyUshort(sc, 0x06, 0xe0eb);
12613                 MP_WritePhyUshort(sc, 0x06, 0x00e2);
12614                 MP_WritePhyUshort(sc, 0x06, 0xe07c);
12615                 MP_WritePhyUshort(sc, 0x06, 0xe3e0);
12616                 MP_WritePhyUshort(sc, 0x06, 0x7da5);
12617                 MP_WritePhyUshort(sc, 0x06, 0x1111);
12618                 MP_WritePhyUshort(sc, 0x06, 0x15d2);
12619                 MP_WritePhyUshort(sc, 0x06, 0x60d6);
12620                 MP_WritePhyUshort(sc, 0x06, 0x6666);
12621                 MP_WritePhyUshort(sc, 0x06, 0x0207);
12622                 MP_WritePhyUshort(sc, 0x06, 0xf9d2);
12623                 MP_WritePhyUshort(sc, 0x06, 0xa0d6);
12624                 MP_WritePhyUshort(sc, 0x06, 0xaaaa);
12625                 MP_WritePhyUshort(sc, 0x06, 0x0207);
12626                 MP_WritePhyUshort(sc, 0x06, 0xf902);
12627                 MP_WritePhyUshort(sc, 0x06, 0x825c);
12628                 MP_WritePhyUshort(sc, 0x06, 0xae44);
12629                 MP_WritePhyUshort(sc, 0x06, 0xa566);
12630                 MP_WritePhyUshort(sc, 0x06, 0x6602);
12631                 MP_WritePhyUshort(sc, 0x06, 0xae38);
12632                 MP_WritePhyUshort(sc, 0x06, 0xa5aa);
12633                 MP_WritePhyUshort(sc, 0x06, 0xaa02);
12634                 MP_WritePhyUshort(sc, 0x06, 0xae32);
12635                 MP_WritePhyUshort(sc, 0x06, 0xeee0);
12636                 MP_WritePhyUshort(sc, 0x06, 0xea04);
12637                 MP_WritePhyUshort(sc, 0x06, 0xeee0);
12638                 MP_WritePhyUshort(sc, 0x06, 0xeb06);
12639                 MP_WritePhyUshort(sc, 0x06, 0xe2e0);
12640                 MP_WritePhyUshort(sc, 0x06, 0x7ce3);
12641                 MP_WritePhyUshort(sc, 0x06, 0xe07d);
12642                 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
12643                 MP_WritePhyUshort(sc, 0x06, 0x38e1);
12644                 MP_WritePhyUshort(sc, 0x06, 0xe039);
12645                 MP_WritePhyUshort(sc, 0x06, 0xad2e);
12646                 MP_WritePhyUshort(sc, 0x06, 0x21ad);
12647                 MP_WritePhyUshort(sc, 0x06, 0x3f13);
12648                 MP_WritePhyUshort(sc, 0x06, 0xe0e4);
12649                 MP_WritePhyUshort(sc, 0x06, 0x14e1);
12650                 MP_WritePhyUshort(sc, 0x06, 0xe415);
12651                 MP_WritePhyUshort(sc, 0x06, 0x6880);
12652                 MP_WritePhyUshort(sc, 0x06, 0xe4e4);
12653                 MP_WritePhyUshort(sc, 0x06, 0x14e5);
12654                 MP_WritePhyUshort(sc, 0x06, 0xe415);
12655                 MP_WritePhyUshort(sc, 0x06, 0x0282);
12656                 MP_WritePhyUshort(sc, 0x06, 0x5cae);
12657                 MP_WritePhyUshort(sc, 0x06, 0x0bac);
12658                 MP_WritePhyUshort(sc, 0x06, 0x3e02);
12659                 MP_WritePhyUshort(sc, 0x06, 0xae06);
12660                 MP_WritePhyUshort(sc, 0x06, 0x0282);
12661                 MP_WritePhyUshort(sc, 0x06, 0x8602);
12662                 MP_WritePhyUshort(sc, 0x06, 0x82b0);
12663                 MP_WritePhyUshort(sc, 0x06, 0xfefd);
12664                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
12665                 MP_WritePhyUshort(sc, 0x06, 0xf8e1);
12666                 MP_WritePhyUshort(sc, 0x06, 0x8b2e);
12667                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
12668                 MP_WritePhyUshort(sc, 0x06, 0x81ad);
12669                 MP_WritePhyUshort(sc, 0x06, 0x2605);
12670                 MP_WritePhyUshort(sc, 0x06, 0x0221);
12671                 MP_WritePhyUshort(sc, 0x06, 0xf3f7);
12672                 MP_WritePhyUshort(sc, 0x06, 0x28e0);
12673                 MP_WritePhyUshort(sc, 0x06, 0x8b81);
12674                 MP_WritePhyUshort(sc, 0x06, 0xad21);
12675                 MP_WritePhyUshort(sc, 0x06, 0x0502);
12676                 MP_WritePhyUshort(sc, 0x06, 0x22f8);
12677                 MP_WritePhyUshort(sc, 0x06, 0xf729);
12678                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
12679                 MP_WritePhyUshort(sc, 0x06, 0x87ad);
12680                 MP_WritePhyUshort(sc, 0x06, 0x2405);
12681                 MP_WritePhyUshort(sc, 0x06, 0x0282);
12682                 MP_WritePhyUshort(sc, 0x06, 0xebf7);
12683                 MP_WritePhyUshort(sc, 0x06, 0x2ae5);
12684                 MP_WritePhyUshort(sc, 0x06, 0x8b2e);
12685                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
12686                 MP_WritePhyUshort(sc, 0x06, 0xf8e0);
12687                 MP_WritePhyUshort(sc, 0x06, 0x8b81);
12688                 MP_WritePhyUshort(sc, 0x06, 0xad26);
12689                 MP_WritePhyUshort(sc, 0x06, 0x0302);
12690                 MP_WritePhyUshort(sc, 0x06, 0x2134);
12691                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
12692                 MP_WritePhyUshort(sc, 0x06, 0x81ad);
12693                 MP_WritePhyUshort(sc, 0x06, 0x2109);
12694                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
12695                 MP_WritePhyUshort(sc, 0x06, 0x2eac);
12696                 MP_WritePhyUshort(sc, 0x06, 0x2003);
12697                 MP_WritePhyUshort(sc, 0x06, 0x0283);
12698                 MP_WritePhyUshort(sc, 0x06, 0x52e0);
12699                 MP_WritePhyUshort(sc, 0x06, 0x8b87);
12700                 MP_WritePhyUshort(sc, 0x06, 0xad24);
12701                 MP_WritePhyUshort(sc, 0x06, 0x09e0);
12702                 MP_WritePhyUshort(sc, 0x06, 0x8b2e);
12703                 MP_WritePhyUshort(sc, 0x06, 0xac21);
12704                 MP_WritePhyUshort(sc, 0x06, 0x0302);
12705                 MP_WritePhyUshort(sc, 0x06, 0x8337);
12706                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
12707                 MP_WritePhyUshort(sc, 0x06, 0xf8e1);
12708                 MP_WritePhyUshort(sc, 0x06, 0x8b2e);
12709                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
12710                 MP_WritePhyUshort(sc, 0x06, 0x81ad);
12711                 MP_WritePhyUshort(sc, 0x06, 0x2608);
12712                 MP_WritePhyUshort(sc, 0x06, 0xe085);
12713                 MP_WritePhyUshort(sc, 0x06, 0xd2ad);
12714                 MP_WritePhyUshort(sc, 0x06, 0x2502);
12715                 MP_WritePhyUshort(sc, 0x06, 0xf628);
12716                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
12717                 MP_WritePhyUshort(sc, 0x06, 0x81ad);
12718                 MP_WritePhyUshort(sc, 0x06, 0x210a);
12719                 MP_WritePhyUshort(sc, 0x06, 0xe086);
12720                 MP_WritePhyUshort(sc, 0x06, 0x0af6);
12721                 MP_WritePhyUshort(sc, 0x06, 0x27a0);
12722                 MP_WritePhyUshort(sc, 0x06, 0x0502);
12723                 MP_WritePhyUshort(sc, 0x06, 0xf629);
12724                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
12725                 MP_WritePhyUshort(sc, 0x06, 0x87ad);
12726                 MP_WritePhyUshort(sc, 0x06, 0x2408);
12727                 MP_WritePhyUshort(sc, 0x06, 0xe08a);
12728                 MP_WritePhyUshort(sc, 0x06, 0xedad);
12729                 MP_WritePhyUshort(sc, 0x06, 0x2002);
12730                 MP_WritePhyUshort(sc, 0x06, 0xf62a);
12731                 MP_WritePhyUshort(sc, 0x06, 0xe58b);
12732                 MP_WritePhyUshort(sc, 0x06, 0x2ea1);
12733                 MP_WritePhyUshort(sc, 0x06, 0x0003);
12734                 MP_WritePhyUshort(sc, 0x06, 0x0221);
12735                 MP_WritePhyUshort(sc, 0x06, 0x11fc);
12736                 MP_WritePhyUshort(sc, 0x06, 0x04ee);
12737                 MP_WritePhyUshort(sc, 0x06, 0x8aed);
12738                 MP_WritePhyUshort(sc, 0x06, 0x00ee);
12739                 MP_WritePhyUshort(sc, 0x06, 0x8aec);
12740                 MP_WritePhyUshort(sc, 0x06, 0x0004);
12741                 MP_WritePhyUshort(sc, 0x06, 0xf8e0);
12742                 MP_WritePhyUshort(sc, 0x06, 0x8b87);
12743                 MP_WritePhyUshort(sc, 0x06, 0xad24);
12744                 MP_WritePhyUshort(sc, 0x06, 0x3ae0);
12745                 MP_WritePhyUshort(sc, 0x06, 0xe0ea);
12746                 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
12747                 MP_WritePhyUshort(sc, 0x06, 0xeb58);
12748                 MP_WritePhyUshort(sc, 0x06, 0xf8d1);
12749                 MP_WritePhyUshort(sc, 0x06, 0x01e4);
12750                 MP_WritePhyUshort(sc, 0x06, 0xe0ea);
12751                 MP_WritePhyUshort(sc, 0x06, 0xe5e0);
12752                 MP_WritePhyUshort(sc, 0x06, 0xebe0);
12753                 MP_WritePhyUshort(sc, 0x06, 0xe07c);
12754                 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
12755                 MP_WritePhyUshort(sc, 0x06, 0x7d5c);
12756                 MP_WritePhyUshort(sc, 0x06, 0x00ff);
12757                 MP_WritePhyUshort(sc, 0x06, 0x3c00);
12758                 MP_WritePhyUshort(sc, 0x06, 0x1eab);
12759                 MP_WritePhyUshort(sc, 0x06, 0x1ce0);
12760                 MP_WritePhyUshort(sc, 0x06, 0xe04c);
12761                 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
12762                 MP_WritePhyUshort(sc, 0x06, 0x4d58);
12763                 MP_WritePhyUshort(sc, 0x06, 0xc1e4);
12764                 MP_WritePhyUshort(sc, 0x06, 0xe04c);
12765                 MP_WritePhyUshort(sc, 0x06, 0xe5e0);
12766                 MP_WritePhyUshort(sc, 0x06, 0x4de0);
12767                 MP_WritePhyUshort(sc, 0x06, 0xe0ee);
12768                 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
12769                 MP_WritePhyUshort(sc, 0x06, 0xef69);
12770                 MP_WritePhyUshort(sc, 0x06, 0x3ce4);
12771                 MP_WritePhyUshort(sc, 0x06, 0xe0ee);
12772                 MP_WritePhyUshort(sc, 0x06, 0xe5e0);
12773                 MP_WritePhyUshort(sc, 0x06, 0xeffc);
12774                 MP_WritePhyUshort(sc, 0x06, 0x04f8);
12775                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
12776                 MP_WritePhyUshort(sc, 0x06, 0x87ad);
12777                 MP_WritePhyUshort(sc, 0x06, 0x2412);
12778                 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
12779                 MP_WritePhyUshort(sc, 0x06, 0xeee1);
12780                 MP_WritePhyUshort(sc, 0x06, 0xe0ef);
12781                 MP_WritePhyUshort(sc, 0x06, 0x59c3);
12782                 MP_WritePhyUshort(sc, 0x06, 0xe4e0);
12783                 MP_WritePhyUshort(sc, 0x06, 0xeee5);
12784                 MP_WritePhyUshort(sc, 0x06, 0xe0ef);
12785                 MP_WritePhyUshort(sc, 0x06, 0xee8a);
12786                 MP_WritePhyUshort(sc, 0x06, 0xed01);
12787                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
12788                 MP_WritePhyUshort(sc, 0x06, 0xf8e0);
12789                 MP_WritePhyUshort(sc, 0x06, 0x8b81);
12790                 MP_WritePhyUshort(sc, 0x06, 0xac25);
12791                 MP_WritePhyUshort(sc, 0x06, 0x0502);
12792                 MP_WritePhyUshort(sc, 0x06, 0x8363);
12793                 MP_WritePhyUshort(sc, 0x06, 0xae03);
12794                 MP_WritePhyUshort(sc, 0x06, 0x0225);
12795                 MP_WritePhyUshort(sc, 0x06, 0x16fc);
12796                 MP_WritePhyUshort(sc, 0x06, 0x04f8);
12797                 MP_WritePhyUshort(sc, 0x06, 0xf9fa);
12798                 MP_WritePhyUshort(sc, 0x06, 0xef69);
12799                 MP_WritePhyUshort(sc, 0x06, 0xfae0);
12800                 MP_WritePhyUshort(sc, 0x06, 0x860a);
12801                 MP_WritePhyUshort(sc, 0x06, 0xa000);
12802                 MP_WritePhyUshort(sc, 0x06, 0x19e0);
12803                 MP_WritePhyUshort(sc, 0x06, 0x860b);
12804                 MP_WritePhyUshort(sc, 0x06, 0xe18b);
12805                 MP_WritePhyUshort(sc, 0x06, 0x331b);
12806                 MP_WritePhyUshort(sc, 0x06, 0x109e);
12807                 MP_WritePhyUshort(sc, 0x06, 0x04aa);
12808                 MP_WritePhyUshort(sc, 0x06, 0x02ae);
12809                 MP_WritePhyUshort(sc, 0x06, 0x06ee);
12810                 MP_WritePhyUshort(sc, 0x06, 0x860a);
12811                 MP_WritePhyUshort(sc, 0x06, 0x01ae);
12812                 MP_WritePhyUshort(sc, 0x06, 0xe602);
12813                 MP_WritePhyUshort(sc, 0x06, 0x241e);
12814                 MP_WritePhyUshort(sc, 0x06, 0xae14);
12815                 MP_WritePhyUshort(sc, 0x06, 0xa001);
12816                 MP_WritePhyUshort(sc, 0x06, 0x1402);
12817                 MP_WritePhyUshort(sc, 0x06, 0x2426);
12818                 MP_WritePhyUshort(sc, 0x06, 0xbf26);
12819                 MP_WritePhyUshort(sc, 0x06, 0x6d02);
12820                 MP_WritePhyUshort(sc, 0x06, 0x2eb0);
12821                 MP_WritePhyUshort(sc, 0x06, 0xee86);
12822                 MP_WritePhyUshort(sc, 0x06, 0x0b00);
12823                 MP_WritePhyUshort(sc, 0x06, 0xee86);
12824                 MP_WritePhyUshort(sc, 0x06, 0x0a02);
12825                 MP_WritePhyUshort(sc, 0x06, 0xaf84);
12826                 MP_WritePhyUshort(sc, 0x06, 0x3ca0);
12827                 MP_WritePhyUshort(sc, 0x06, 0x0252);
12828                 MP_WritePhyUshort(sc, 0x06, 0xee86);
12829                 MP_WritePhyUshort(sc, 0x06, 0x0400);
12830                 MP_WritePhyUshort(sc, 0x06, 0xee86);
12831                 MP_WritePhyUshort(sc, 0x06, 0x0500);
12832                 MP_WritePhyUshort(sc, 0x06, 0xe086);
12833                 MP_WritePhyUshort(sc, 0x06, 0x0be1);
12834                 MP_WritePhyUshort(sc, 0x06, 0x8b32);
12835                 MP_WritePhyUshort(sc, 0x06, 0x1b10);
12836                 MP_WritePhyUshort(sc, 0x06, 0x9e04);
12837                 MP_WritePhyUshort(sc, 0x06, 0xaa02);
12838                 MP_WritePhyUshort(sc, 0x06, 0xaecb);
12839                 MP_WritePhyUshort(sc, 0x06, 0xee86);
12840                 MP_WritePhyUshort(sc, 0x06, 0x0b00);
12841                 MP_WritePhyUshort(sc, 0x06, 0x0224);
12842                 MP_WritePhyUshort(sc, 0x06, 0x3ae2);
12843                 MP_WritePhyUshort(sc, 0x06, 0x8604);
12844                 MP_WritePhyUshort(sc, 0x06, 0xe386);
12845                 MP_WritePhyUshort(sc, 0x06, 0x05ef);
12846                 MP_WritePhyUshort(sc, 0x06, 0x65e2);
12847                 MP_WritePhyUshort(sc, 0x06, 0x8606);
12848                 MP_WritePhyUshort(sc, 0x06, 0xe386);
12849                 MP_WritePhyUshort(sc, 0x06, 0x071b);
12850                 MP_WritePhyUshort(sc, 0x06, 0x56aa);
12851                 MP_WritePhyUshort(sc, 0x06, 0x0eef);
12852                 MP_WritePhyUshort(sc, 0x06, 0x56e6);
12853                 MP_WritePhyUshort(sc, 0x06, 0x8606);
12854                 MP_WritePhyUshort(sc, 0x06, 0xe786);
12855                 MP_WritePhyUshort(sc, 0x06, 0x07e2);
12856                 MP_WritePhyUshort(sc, 0x06, 0x8609);
12857                 MP_WritePhyUshort(sc, 0x06, 0xe686);
12858                 MP_WritePhyUshort(sc, 0x06, 0x08e0);
12859                 MP_WritePhyUshort(sc, 0x06, 0x8609);
12860                 MP_WritePhyUshort(sc, 0x06, 0xa000);
12861                 MP_WritePhyUshort(sc, 0x06, 0x07ee);
12862                 MP_WritePhyUshort(sc, 0x06, 0x860a);
12863                 MP_WritePhyUshort(sc, 0x06, 0x03af);
12864                 MP_WritePhyUshort(sc, 0x06, 0x8369);
12865                 MP_WritePhyUshort(sc, 0x06, 0x0224);
12866                 MP_WritePhyUshort(sc, 0x06, 0x8e02);
12867                 MP_WritePhyUshort(sc, 0x06, 0x2426);
12868                 MP_WritePhyUshort(sc, 0x06, 0xae48);
12869                 MP_WritePhyUshort(sc, 0x06, 0xa003);
12870                 MP_WritePhyUshort(sc, 0x06, 0x21e0);
12871                 MP_WritePhyUshort(sc, 0x06, 0x8608);
12872                 MP_WritePhyUshort(sc, 0x06, 0xe186);
12873                 MP_WritePhyUshort(sc, 0x06, 0x091b);
12874                 MP_WritePhyUshort(sc, 0x06, 0x019e);
12875                 MP_WritePhyUshort(sc, 0x06, 0x0caa);
12876                 MP_WritePhyUshort(sc, 0x06, 0x0502);
12877                 MP_WritePhyUshort(sc, 0x06, 0x249d);
12878                 MP_WritePhyUshort(sc, 0x06, 0xaee7);
12879                 MP_WritePhyUshort(sc, 0x06, 0x0224);
12880                 MP_WritePhyUshort(sc, 0x06, 0x8eae);
12881                 MP_WritePhyUshort(sc, 0x06, 0xe2ee);
12882                 MP_WritePhyUshort(sc, 0x06, 0x860a);
12883                 MP_WritePhyUshort(sc, 0x06, 0x04ee);
12884                 MP_WritePhyUshort(sc, 0x06, 0x860b);
12885                 MP_WritePhyUshort(sc, 0x06, 0x00af);
12886                 MP_WritePhyUshort(sc, 0x06, 0x8369);
12887                 MP_WritePhyUshort(sc, 0x06, 0xa004);
12888                 MP_WritePhyUshort(sc, 0x06, 0x15e0);
12889                 MP_WritePhyUshort(sc, 0x06, 0x860b);
12890                 MP_WritePhyUshort(sc, 0x06, 0xe18b);
12891                 MP_WritePhyUshort(sc, 0x06, 0x341b);
12892                 MP_WritePhyUshort(sc, 0x06, 0x109e);
12893                 MP_WritePhyUshort(sc, 0x06, 0x05aa);
12894                 MP_WritePhyUshort(sc, 0x06, 0x03af);
12895                 MP_WritePhyUshort(sc, 0x06, 0x8383);
12896                 MP_WritePhyUshort(sc, 0x06, 0xee86);
12897                 MP_WritePhyUshort(sc, 0x06, 0x0a05);
12898                 MP_WritePhyUshort(sc, 0x06, 0xae0c);
12899                 MP_WritePhyUshort(sc, 0x06, 0xa005);
12900                 MP_WritePhyUshort(sc, 0x06, 0x02ae);
12901                 MP_WritePhyUshort(sc, 0x06, 0x0702);
12902                 MP_WritePhyUshort(sc, 0x06, 0x2309);
12903                 MP_WritePhyUshort(sc, 0x06, 0xee86);
12904                 MP_WritePhyUshort(sc, 0x06, 0x0a00);
12905                 MP_WritePhyUshort(sc, 0x06, 0xfeef);
12906                 MP_WritePhyUshort(sc, 0x06, 0x96fe);
12907                 MP_WritePhyUshort(sc, 0x06, 0xfdfc);
12908                 MP_WritePhyUshort(sc, 0x06, 0x04f8);
12909                 MP_WritePhyUshort(sc, 0x06, 0xf9fa);
12910                 MP_WritePhyUshort(sc, 0x06, 0xef69);
12911                 MP_WritePhyUshort(sc, 0x06, 0xfbe0);
12912                 MP_WritePhyUshort(sc, 0x06, 0x8b85);
12913                 MP_WritePhyUshort(sc, 0x06, 0xad25);
12914                 MP_WritePhyUshort(sc, 0x06, 0x22e0);
12915                 MP_WritePhyUshort(sc, 0x06, 0xe022);
12916                 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
12917                 MP_WritePhyUshort(sc, 0x06, 0x23e2);
12918                 MP_WritePhyUshort(sc, 0x06, 0xe036);
12919                 MP_WritePhyUshort(sc, 0x06, 0xe3e0);
12920                 MP_WritePhyUshort(sc, 0x06, 0x375a);
12921                 MP_WritePhyUshort(sc, 0x06, 0xc40d);
12922                 MP_WritePhyUshort(sc, 0x06, 0x0158);
12923                 MP_WritePhyUshort(sc, 0x06, 0x021e);
12924                 MP_WritePhyUshort(sc, 0x06, 0x20e3);
12925                 MP_WritePhyUshort(sc, 0x06, 0x8ae7);
12926                 MP_WritePhyUshort(sc, 0x06, 0xac31);
12927                 MP_WritePhyUshort(sc, 0x06, 0x60ac);
12928                 MP_WritePhyUshort(sc, 0x06, 0x3a08);
12929                 MP_WritePhyUshort(sc, 0x06, 0xac3e);
12930                 MP_WritePhyUshort(sc, 0x06, 0x26ae);
12931                 MP_WritePhyUshort(sc, 0x06, 0x67af);
12932                 MP_WritePhyUshort(sc, 0x06, 0x84db);
12933                 MP_WritePhyUshort(sc, 0x06, 0xad37);
12934                 MP_WritePhyUshort(sc, 0x06, 0x61e0);
12935                 MP_WritePhyUshort(sc, 0x06, 0x8ae8);
12936                 MP_WritePhyUshort(sc, 0x06, 0x10e4);
12937                 MP_WritePhyUshort(sc, 0x06, 0x8ae8);
12938                 MP_WritePhyUshort(sc, 0x06, 0xe18a);
12939                 MP_WritePhyUshort(sc, 0x06, 0xe91b);
12940                 MP_WritePhyUshort(sc, 0x06, 0x109e);
12941                 MP_WritePhyUshort(sc, 0x06, 0x02ae);
12942                 MP_WritePhyUshort(sc, 0x06, 0x51d1);
12943                 MP_WritePhyUshort(sc, 0x06, 0x00bf);
12944                 MP_WritePhyUshort(sc, 0x06, 0x863b);
12945                 MP_WritePhyUshort(sc, 0x06, 0x022f);
12946                 MP_WritePhyUshort(sc, 0x06, 0x50ee);
12947                 MP_WritePhyUshort(sc, 0x06, 0x8ae8);
12948                 MP_WritePhyUshort(sc, 0x06, 0x00ae);
12949                 MP_WritePhyUshort(sc, 0x06, 0x43ad);
12950                 MP_WritePhyUshort(sc, 0x06, 0x3627);
12951                 MP_WritePhyUshort(sc, 0x06, 0xe08a);
12952                 MP_WritePhyUshort(sc, 0x06, 0xeee1);
12953                 MP_WritePhyUshort(sc, 0x06, 0x8aef);
12954                 MP_WritePhyUshort(sc, 0x06, 0xef74);
12955                 MP_WritePhyUshort(sc, 0x06, 0xe08a);
12956                 MP_WritePhyUshort(sc, 0x06, 0xeae1);
12957                 MP_WritePhyUshort(sc, 0x06, 0x8aeb);
12958                 MP_WritePhyUshort(sc, 0x06, 0x1b74);
12959                 MP_WritePhyUshort(sc, 0x06, 0x9e2e);
12960                 MP_WritePhyUshort(sc, 0x06, 0x14e4);
12961                 MP_WritePhyUshort(sc, 0x06, 0x8aea);
12962                 MP_WritePhyUshort(sc, 0x06, 0xe58a);
12963                 MP_WritePhyUshort(sc, 0x06, 0xebef);
12964                 MP_WritePhyUshort(sc, 0x06, 0x74e0);
12965                 MP_WritePhyUshort(sc, 0x06, 0x8aee);
12966                 MP_WritePhyUshort(sc, 0x06, 0xe18a);
12967                 MP_WritePhyUshort(sc, 0x06, 0xef1b);
12968                 MP_WritePhyUshort(sc, 0x06, 0x479e);
12969                 MP_WritePhyUshort(sc, 0x06, 0x0fae);
12970                 MP_WritePhyUshort(sc, 0x06, 0x19ee);
12971                 MP_WritePhyUshort(sc, 0x06, 0x8aea);
12972                 MP_WritePhyUshort(sc, 0x06, 0x00ee);
12973                 MP_WritePhyUshort(sc, 0x06, 0x8aeb);
12974                 MP_WritePhyUshort(sc, 0x06, 0x00ae);
12975                 MP_WritePhyUshort(sc, 0x06, 0x0fac);
12976                 MP_WritePhyUshort(sc, 0x06, 0x390c);
12977                 MP_WritePhyUshort(sc, 0x06, 0xd101);
12978                 MP_WritePhyUshort(sc, 0x06, 0xbf86);
12979                 MP_WritePhyUshort(sc, 0x06, 0x3b02);
12980                 MP_WritePhyUshort(sc, 0x06, 0x2f50);
12981                 MP_WritePhyUshort(sc, 0x06, 0xee8a);
12982                 MP_WritePhyUshort(sc, 0x06, 0xe800);
12983                 MP_WritePhyUshort(sc, 0x06, 0xe68a);
12984                 MP_WritePhyUshort(sc, 0x06, 0xe7ff);
12985                 MP_WritePhyUshort(sc, 0x06, 0xef96);
12986                 MP_WritePhyUshort(sc, 0x06, 0xfefd);
12987                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
12988                 MP_WritePhyUshort(sc, 0x06, 0xf8f9);
12989                 MP_WritePhyUshort(sc, 0x06, 0xfaef);
12990                 MP_WritePhyUshort(sc, 0x06, 0x69e0);
12991                 MP_WritePhyUshort(sc, 0x06, 0xe022);
12992                 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
12993                 MP_WritePhyUshort(sc, 0x06, 0x2358);
12994                 MP_WritePhyUshort(sc, 0x06, 0xc4e1);
12995                 MP_WritePhyUshort(sc, 0x06, 0x8b6e);
12996                 MP_WritePhyUshort(sc, 0x06, 0x1f10);
12997                 MP_WritePhyUshort(sc, 0x06, 0x9e24);
12998                 MP_WritePhyUshort(sc, 0x06, 0xe48b);
12999                 MP_WritePhyUshort(sc, 0x06, 0x6ead);
13000                 MP_WritePhyUshort(sc, 0x06, 0x2218);
13001                 MP_WritePhyUshort(sc, 0x06, 0xac27);
13002                 MP_WritePhyUshort(sc, 0x06, 0x0dac);
13003                 MP_WritePhyUshort(sc, 0x06, 0x2605);
13004                 MP_WritePhyUshort(sc, 0x06, 0x0203);
13005                 MP_WritePhyUshort(sc, 0x06, 0x8fae);
13006                 MP_WritePhyUshort(sc, 0x06, 0x1302);
13007                 MP_WritePhyUshort(sc, 0x06, 0x03c8);
13008                 MP_WritePhyUshort(sc, 0x06, 0xae0e);
13009                 MP_WritePhyUshort(sc, 0x06, 0x0203);
13010                 MP_WritePhyUshort(sc, 0x06, 0xe102);
13011                 MP_WritePhyUshort(sc, 0x06, 0x8520);
13012                 MP_WritePhyUshort(sc, 0x06, 0xae06);
13013                 MP_WritePhyUshort(sc, 0x06, 0x0203);
13014                 MP_WritePhyUshort(sc, 0x06, 0x8f02);
13015                 MP_WritePhyUshort(sc, 0x06, 0x8566);
13016                 MP_WritePhyUshort(sc, 0x06, 0xef96);
13017                 MP_WritePhyUshort(sc, 0x06, 0xfefd);
13018                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
13019                 MP_WritePhyUshort(sc, 0x06, 0xf8fa);
13020                 MP_WritePhyUshort(sc, 0x06, 0xef69);
13021                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
13022                 MP_WritePhyUshort(sc, 0x06, 0x82ad);
13023                 MP_WritePhyUshort(sc, 0x06, 0x2737);
13024                 MP_WritePhyUshort(sc, 0x06, 0xbf86);
13025                 MP_WritePhyUshort(sc, 0x06, 0x4402);
13026                 MP_WritePhyUshort(sc, 0x06, 0x2f23);
13027                 MP_WritePhyUshort(sc, 0x06, 0xac28);
13028                 MP_WritePhyUshort(sc, 0x06, 0x2ed1);
13029                 MP_WritePhyUshort(sc, 0x06, 0x01bf);
13030                 MP_WritePhyUshort(sc, 0x06, 0x8647);
13031                 MP_WritePhyUshort(sc, 0x06, 0x022f);
13032                 MP_WritePhyUshort(sc, 0x06, 0x50bf);
13033                 MP_WritePhyUshort(sc, 0x06, 0x8641);
13034                 MP_WritePhyUshort(sc, 0x06, 0x022f);
13035                 MP_WritePhyUshort(sc, 0x06, 0x23e5);
13036                 MP_WritePhyUshort(sc, 0x06, 0x8af0);
13037                 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
13038                 MP_WritePhyUshort(sc, 0x06, 0x22e1);
13039                 MP_WritePhyUshort(sc, 0x06, 0xe023);
13040                 MP_WritePhyUshort(sc, 0x06, 0xac2e);
13041                 MP_WritePhyUshort(sc, 0x06, 0x04d1);
13042                 MP_WritePhyUshort(sc, 0x06, 0x01ae);
13043                 MP_WritePhyUshort(sc, 0x06, 0x02d1);
13044                 MP_WritePhyUshort(sc, 0x06, 0x00bf);
13045                 MP_WritePhyUshort(sc, 0x06, 0x8641);
13046                 MP_WritePhyUshort(sc, 0x06, 0x022f);
13047                 MP_WritePhyUshort(sc, 0x06, 0x50d1);
13048                 MP_WritePhyUshort(sc, 0x06, 0x01bf);
13049                 MP_WritePhyUshort(sc, 0x06, 0x8644);
13050                 MP_WritePhyUshort(sc, 0x06, 0x022f);
13051                 MP_WritePhyUshort(sc, 0x06, 0x50ef);
13052                 MP_WritePhyUshort(sc, 0x06, 0x96fe);
13053                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
13054                 MP_WritePhyUshort(sc, 0x06, 0xf8fa);
13055                 MP_WritePhyUshort(sc, 0x06, 0xef69);
13056                 MP_WritePhyUshort(sc, 0x06, 0xbf86);
13057                 MP_WritePhyUshort(sc, 0x06, 0x4702);
13058                 MP_WritePhyUshort(sc, 0x06, 0x2f23);
13059                 MP_WritePhyUshort(sc, 0x06, 0xad28);
13060                 MP_WritePhyUshort(sc, 0x06, 0x19d1);
13061                 MP_WritePhyUshort(sc, 0x06, 0x00bf);
13062                 MP_WritePhyUshort(sc, 0x06, 0x8644);
13063                 MP_WritePhyUshort(sc, 0x06, 0x022f);
13064                 MP_WritePhyUshort(sc, 0x06, 0x50e1);
13065                 MP_WritePhyUshort(sc, 0x06, 0x8af0);
13066                 MP_WritePhyUshort(sc, 0x06, 0xbf86);
13067                 MP_WritePhyUshort(sc, 0x06, 0x4102);
13068                 MP_WritePhyUshort(sc, 0x06, 0x2f50);
13069                 MP_WritePhyUshort(sc, 0x06, 0xd100);
13070                 MP_WritePhyUshort(sc, 0x06, 0xbf86);
13071                 MP_WritePhyUshort(sc, 0x06, 0x4702);
13072                 MP_WritePhyUshort(sc, 0x06, 0x2f50);
13073                 MP_WritePhyUshort(sc, 0x06, 0xef96);
13074                 MP_WritePhyUshort(sc, 0x06, 0xfefc);
13075                 MP_WritePhyUshort(sc, 0x06, 0x04f8);
13076                 MP_WritePhyUshort(sc, 0x06, 0xe0e2);
13077                 MP_WritePhyUshort(sc, 0x06, 0xfee1);
13078                 MP_WritePhyUshort(sc, 0x06, 0xe2ff);
13079                 MP_WritePhyUshort(sc, 0x06, 0xad2e);
13080                 MP_WritePhyUshort(sc, 0x06, 0x63e0);
13081                 MP_WritePhyUshort(sc, 0x06, 0xe038);
13082                 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
13083                 MP_WritePhyUshort(sc, 0x06, 0x39ad);
13084                 MP_WritePhyUshort(sc, 0x06, 0x2f10);
13085                 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
13086                 MP_WritePhyUshort(sc, 0x06, 0x34e1);
13087                 MP_WritePhyUshort(sc, 0x06, 0xe035);
13088                 MP_WritePhyUshort(sc, 0x06, 0xf726);
13089                 MP_WritePhyUshort(sc, 0x06, 0xe4e0);
13090                 MP_WritePhyUshort(sc, 0x06, 0x34e5);
13091                 MP_WritePhyUshort(sc, 0x06, 0xe035);
13092                 MP_WritePhyUshort(sc, 0x06, 0xae0e);
13093                 MP_WritePhyUshort(sc, 0x06, 0xe0e2);
13094                 MP_WritePhyUshort(sc, 0x06, 0xd6e1);
13095                 MP_WritePhyUshort(sc, 0x06, 0xe2d7);
13096                 MP_WritePhyUshort(sc, 0x06, 0xf728);
13097                 MP_WritePhyUshort(sc, 0x06, 0xe4e2);
13098                 MP_WritePhyUshort(sc, 0x06, 0xd6e5);
13099                 MP_WritePhyUshort(sc, 0x06, 0xe2d7);
13100                 MP_WritePhyUshort(sc, 0x06, 0xe0e2);
13101                 MP_WritePhyUshort(sc, 0x06, 0x34e1);
13102                 MP_WritePhyUshort(sc, 0x06, 0xe235);
13103                 MP_WritePhyUshort(sc, 0x06, 0xf72b);
13104                 MP_WritePhyUshort(sc, 0x06, 0xe4e2);
13105                 MP_WritePhyUshort(sc, 0x06, 0x34e5);
13106                 MP_WritePhyUshort(sc, 0x06, 0xe235);
13107                 MP_WritePhyUshort(sc, 0x06, 0xd07d);
13108                 MP_WritePhyUshort(sc, 0x06, 0xb0fe);
13109                 MP_WritePhyUshort(sc, 0x06, 0xe0e2);
13110                 MP_WritePhyUshort(sc, 0x06, 0x34e1);
13111                 MP_WritePhyUshort(sc, 0x06, 0xe235);
13112                 MP_WritePhyUshort(sc, 0x06, 0xf62b);
13113                 MP_WritePhyUshort(sc, 0x06, 0xe4e2);
13114                 MP_WritePhyUshort(sc, 0x06, 0x34e5);
13115                 MP_WritePhyUshort(sc, 0x06, 0xe235);
13116                 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
13117                 MP_WritePhyUshort(sc, 0x06, 0x34e1);
13118                 MP_WritePhyUshort(sc, 0x06, 0xe035);
13119                 MP_WritePhyUshort(sc, 0x06, 0xf626);
13120                 MP_WritePhyUshort(sc, 0x06, 0xe4e0);
13121                 MP_WritePhyUshort(sc, 0x06, 0x34e5);
13122                 MP_WritePhyUshort(sc, 0x06, 0xe035);
13123                 MP_WritePhyUshort(sc, 0x06, 0xe0e2);
13124                 MP_WritePhyUshort(sc, 0x06, 0xd6e1);
13125                 MP_WritePhyUshort(sc, 0x06, 0xe2d7);
13126                 MP_WritePhyUshort(sc, 0x06, 0xf628);
13127                 MP_WritePhyUshort(sc, 0x06, 0xe4e2);
13128                 MP_WritePhyUshort(sc, 0x06, 0xd6e5);
13129                 MP_WritePhyUshort(sc, 0x06, 0xe2d7);
13130                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
13131                 MP_WritePhyUshort(sc, 0x06, 0xae20);
13132                 MP_WritePhyUshort(sc, 0x06, 0x0000);
13133                 MP_WritePhyUshort(sc, 0x06, 0x0000);
13134                 MP_WritePhyUshort(sc, 0x06, 0x0000);
13135                 MP_WritePhyUshort(sc, 0x06, 0x0000);
13136                 MP_WritePhyUshort(sc, 0x06, 0x0000);
13137                 MP_WritePhyUshort(sc, 0x06, 0x0000);
13138                 MP_WritePhyUshort(sc, 0x06, 0x0000);
13139                 MP_WritePhyUshort(sc, 0x06, 0x0000);
13140                 MP_WritePhyUshort(sc, 0x06, 0x0000);
13141                 MP_WritePhyUshort(sc, 0x06, 0x0000);
13142                 MP_WritePhyUshort(sc, 0x06, 0x0000);
13143                 MP_WritePhyUshort(sc, 0x06, 0x0000);
13144                 MP_WritePhyUshort(sc, 0x06, 0x0000);
13145                 MP_WritePhyUshort(sc, 0x06, 0x0000);
13146                 MP_WritePhyUshort(sc, 0x06, 0x0000);
13147                 MP_WritePhyUshort(sc, 0x06, 0x0000);
13148                 MP_WritePhyUshort(sc, 0x06, 0xa725);
13149                 MP_WritePhyUshort(sc, 0x06, 0xe50a);
13150                 MP_WritePhyUshort(sc, 0x06, 0x1de5);
13151                 MP_WritePhyUshort(sc, 0x06, 0x0a2c);
13152                 MP_WritePhyUshort(sc, 0x06, 0xe50a);
13153                 MP_WritePhyUshort(sc, 0x06, 0x6de5);
13154                 MP_WritePhyUshort(sc, 0x06, 0x0a1d);
13155                 MP_WritePhyUshort(sc, 0x06, 0xe50a);
13156                 MP_WritePhyUshort(sc, 0x06, 0x1ce5);
13157                 MP_WritePhyUshort(sc, 0x06, 0x0a2d);
13158                 MP_WritePhyUshort(sc, 0x06, 0xa755);
13159                 MP_WritePhyUshort(sc, 0x06, 0x00e2);
13160                 MP_WritePhyUshort(sc, 0x06, 0x3488);
13161                 MP_WritePhyUshort(sc, 0x06, 0xe200);
13162                 MP_WritePhyUshort(sc, 0x06, 0xcce2);
13163                 MP_WritePhyUshort(sc, 0x06, 0x0055);
13164                 MP_WritePhyUshort(sc, 0x06, 0xe020);
13165                 MP_WritePhyUshort(sc, 0x06, 0x55e2);
13166                 MP_WritePhyUshort(sc, 0x06, 0xd600);
13167                 MP_WritePhyUshort(sc, 0x06, 0xe24a);
13168                 PhyRegValue = MP_ReadPhyUshort(sc, 0x01);
13169                 PhyRegValue |= BIT_0;
13170                 MP_WritePhyUshort(sc, 0x01, PhyRegValue);
13171                 PhyRegValue = MP_ReadPhyUshort(sc, 0x00);
13172                 PhyRegValue |= BIT_0;
13173                 MP_WritePhyUshort(sc, 0x00, PhyRegValue);
13174                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
13175
13176                 MP_WritePhyUshort(sc, 0x1f, 0x0005);
13177                 for (i = 0; i < 200; i++) {
13178                         DELAY(100);
13179                         PhyRegValue = MP_ReadPhyUshort(sc, 0x00);
13180                         if (PhyRegValue & BIT_7)
13181                                 break;
13182                 }
13183                 MP_WritePhyUshort(sc, 0x1f, 0x0007);
13184                 MP_WritePhyUshort(sc, 0x1e, 0x0023);
13185                 PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
13186                 PhyRegValue &= ~(BIT_0);
13187                 if (sc->RequiredSecLanDonglePatch)
13188                         PhyRegValue &= ~(BIT_2);
13189                 MP_WritePhyUshort(sc, 0x17, PhyRegValue);
13190                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
13191         }
13192 }
13193
13194 static void re_set_phy_mcu_8168evl_1(struct re_softc *sc)
13195 {
13196         u_int16_t PhyRegValue;
13197         int i;
13198
13199         MP_WritePhyUshort(sc, 0x1f, 0x0000);
13200         MP_WritePhyUshort(sc, 0x00, 0x1800);
13201         PhyRegValue= MP_ReadPhyUshort(sc, 0x15);
13202         PhyRegValue &= ~BIT_12;
13203         MP_WritePhyUshort(sc, 0x15, PhyRegValue);
13204         DELAY(200);
13205         DELAY(200);
13206         MP_WritePhyUshort(sc, 0x1f, 0x0004);
13207         MP_WritePhyUshort(sc, 0x1f, 0x0007);
13208         MP_WritePhyUshort(sc, 0x1e, 0x0023);
13209         PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
13210         if ((PhyRegValue & BIT_11) == 0x0000) {
13211                 PhyRegValue |= BIT_0;
13212                 MP_WritePhyUshort(sc, 0x17, PhyRegValue);
13213                 for (i = 0; i < 200; i++) {
13214                         DELAY(100);
13215                         PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
13216                         if (PhyRegValue & BIT_11)
13217                                 break;
13218                 }
13219         }
13220         PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
13221         PhyRegValue |= BIT_11;
13222         MP_WritePhyUshort(sc, 0x17,PhyRegValue);
13223         MP_WritePhyUshort(sc, 0x1f, 0x0004);
13224         MP_WritePhyUshort(sc, 0x1f, 0x0007);
13225         MP_WritePhyUshort(sc, 0x1E, 0x002C);
13226         MP_WritePhyUshort(sc, 0x1B, 0x5000);
13227         MP_WritePhyUshort(sc, 0x1E, 0x002d);
13228         MP_WritePhyUshort(sc, 0x19, 0x0004);
13229         MP_WritePhyUshort(sc, 0x1f, 0x0002);
13230         MP_WritePhyUshort(sc, 0x1f, 0x0000);
13231         for (i = 0; i < 200; i++) {
13232                 DELAY(100);
13233                 PhyRegValue= MP_ReadPhyUshort(sc, 0x1E);
13234                 if ((PhyRegValue& 0x03FF) == 0x0014)
13235                         break;
13236         }
13237         MP_WritePhyUshort(sc, 0x1f, 0x0005);
13238         for (i = 0; i < 200; i++) {
13239                 DELAY(100);
13240                 PhyRegValue= MP_ReadPhyUshort(sc, 0x07);
13241                 if ((PhyRegValue& BIT_5) == 0)
13242                         break;
13243         }
13244         PhyRegValue = MP_ReadPhyUshort(sc, 0x07);
13245         if (PhyRegValue & BIT_5) {
13246                 MP_WritePhyUshort(sc, 0x1f, 0x0004);
13247                 MP_WritePhyUshort(sc, 0x1f, 0x0007);
13248                 MP_WritePhyUshort(sc, 0x1e, 0x00a1);
13249                 MP_WritePhyUshort(sc, 0x17, 0x1000);
13250                 MP_WritePhyUshort(sc, 0x17, 0x0000);
13251                 MP_WritePhyUshort(sc, 0x17, 0x2000);
13252                 MP_WritePhyUshort(sc, 0x1e, 0x002f);
13253                 MP_WritePhyUshort(sc, 0x18, 0x9bfb);
13254                 MP_WritePhyUshort(sc, 0x1f, 0x0005);
13255                 MP_WritePhyUshort(sc, 0x07, 0x0000);
13256                 MP_WritePhyUshort(sc, 0x1f, 0x0002);
13257                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
13258         }
13259         MP_WritePhyUshort(sc, 0x1f, 0x0005);
13260         MP_WritePhyUshort(sc, 0x05, 0xfff6);
13261         MP_WritePhyUshort(sc, 0x06, 0x0080);
13262         PhyRegValue = MP_ReadPhyUshort(sc, 0x00);
13263         PhyRegValue &= ~BIT_7;
13264         MP_WritePhyUshort(sc, 0x00, PhyRegValue);
13265         MP_WritePhyUshort(sc, 0x1f, 0x0004);
13266         MP_WritePhyUshort(sc, 0x1f, 0x0007);
13267         MP_WritePhyUshort(sc, 0x1e, 0x0023);
13268         MP_WritePhyUshort(sc, 0x16, 0x0306);
13269         MP_WritePhyUshort(sc, 0x16, 0x0307);
13270         MP_WritePhyUshort(sc, 0x15, 0x0000);
13271         MP_WritePhyUshort(sc, 0x19, 0x407d);
13272         MP_WritePhyUshort(sc, 0x15, 0x0001);
13273         MP_WritePhyUshort(sc, 0x19, 0x440f);
13274         MP_WritePhyUshort(sc, 0x15, 0x0002);
13275         MP_WritePhyUshort(sc, 0x19, 0x7c03);
13276         MP_WritePhyUshort(sc, 0x15, 0x0003);
13277         MP_WritePhyUshort(sc, 0x19, 0x6c03);
13278         MP_WritePhyUshort(sc, 0x15, 0x0004);
13279         MP_WritePhyUshort(sc, 0x19, 0xc4d5);
13280         MP_WritePhyUshort(sc, 0x15, 0x0005);
13281         MP_WritePhyUshort(sc, 0x19, 0x00ff);
13282         MP_WritePhyUshort(sc, 0x15, 0x0006);
13283         MP_WritePhyUshort(sc, 0x19, 0x74f0);
13284         MP_WritePhyUshort(sc, 0x15, 0x0007);
13285         MP_WritePhyUshort(sc, 0x19, 0x4880);
13286         MP_WritePhyUshort(sc, 0x15, 0x0008);
13287         MP_WritePhyUshort(sc, 0x19, 0x4c00);
13288         MP_WritePhyUshort(sc, 0x15, 0x0009);
13289         MP_WritePhyUshort(sc, 0x19, 0x4800);
13290         MP_WritePhyUshort(sc, 0x15, 0x000a);
13291         MP_WritePhyUshort(sc, 0x19, 0x5000);
13292         MP_WritePhyUshort(sc, 0x15, 0x000b);
13293         MP_WritePhyUshort(sc, 0x19, 0x4400);
13294         MP_WritePhyUshort(sc, 0x15, 0x000c);
13295         MP_WritePhyUshort(sc, 0x19, 0x7801);
13296         MP_WritePhyUshort(sc, 0x15, 0x000d);
13297         MP_WritePhyUshort(sc, 0x19, 0x4000);
13298         MP_WritePhyUshort(sc, 0x15, 0x000e);
13299         MP_WritePhyUshort(sc, 0x19, 0x7800);
13300         MP_WritePhyUshort(sc, 0x15, 0x000f);
13301         MP_WritePhyUshort(sc, 0x19, 0x7010);
13302         MP_WritePhyUshort(sc, 0x15, 0x0010);
13303         MP_WritePhyUshort(sc, 0x19, 0x6804);
13304         MP_WritePhyUshort(sc, 0x15, 0x0011);
13305         MP_WritePhyUshort(sc, 0x19, 0x64a0);
13306         MP_WritePhyUshort(sc, 0x15, 0x0012);
13307         MP_WritePhyUshort(sc, 0x19, 0x63da);
13308         MP_WritePhyUshort(sc, 0x15, 0x0013);
13309         MP_WritePhyUshort(sc, 0x19, 0x63d8);
13310         MP_WritePhyUshort(sc, 0x15, 0x0014);
13311         MP_WritePhyUshort(sc, 0x19, 0x6f05);
13312         MP_WritePhyUshort(sc, 0x15, 0x0015);
13313         MP_WritePhyUshort(sc, 0x19, 0x5420);
13314         MP_WritePhyUshort(sc, 0x15, 0x0016);
13315         MP_WritePhyUshort(sc, 0x19, 0x58ce);
13316         MP_WritePhyUshort(sc, 0x15, 0x0017);
13317         MP_WritePhyUshort(sc, 0x19, 0x5cf3);
13318         MP_WritePhyUshort(sc, 0x15, 0x0018);
13319         MP_WritePhyUshort(sc, 0x19, 0xb600);
13320         MP_WritePhyUshort(sc, 0x15, 0x0019);
13321         MP_WritePhyUshort(sc, 0x19, 0xc659);
13322         MP_WritePhyUshort(sc, 0x15, 0x001a);
13323         MP_WritePhyUshort(sc, 0x19, 0x0018);
13324         MP_WritePhyUshort(sc, 0x15, 0x001b);
13325         MP_WritePhyUshort(sc, 0x19, 0xc403);
13326         MP_WritePhyUshort(sc, 0x15, 0x001c);
13327         MP_WritePhyUshort(sc, 0x19, 0x0016);
13328         MP_WritePhyUshort(sc, 0x15, 0x001d);
13329         MP_WritePhyUshort(sc, 0x19, 0xaa05);
13330         MP_WritePhyUshort(sc, 0x15, 0x001e);
13331         MP_WritePhyUshort(sc, 0x19, 0xc503);
13332         MP_WritePhyUshort(sc, 0x15, 0x001f);
13333         MP_WritePhyUshort(sc, 0x19, 0x0003);
13334         MP_WritePhyUshort(sc, 0x15, 0x0020);
13335         MP_WritePhyUshort(sc, 0x19, 0x89f8);
13336         MP_WritePhyUshort(sc, 0x15, 0x0021);
13337         MP_WritePhyUshort(sc, 0x19, 0x32ae);
13338         MP_WritePhyUshort(sc, 0x15, 0x0022);
13339         MP_WritePhyUshort(sc, 0x19, 0x7c03);
13340         MP_WritePhyUshort(sc, 0x15, 0x0023);
13341         MP_WritePhyUshort(sc, 0x19, 0x6c03);
13342         MP_WritePhyUshort(sc, 0x15, 0x0024);
13343         MP_WritePhyUshort(sc, 0x19, 0x7c03);
13344         MP_WritePhyUshort(sc, 0x15, 0x0025);
13345         MP_WritePhyUshort(sc, 0x19, 0x6801);
13346         MP_WritePhyUshort(sc, 0x15, 0x0026);
13347         MP_WritePhyUshort(sc, 0x19, 0x66a0);
13348         MP_WritePhyUshort(sc, 0x15, 0x0027);
13349         MP_WritePhyUshort(sc, 0x19, 0xa300);
13350         MP_WritePhyUshort(sc, 0x15, 0x0028);
13351         MP_WritePhyUshort(sc, 0x19, 0x64a0);
13352         MP_WritePhyUshort(sc, 0x15, 0x0029);
13353         MP_WritePhyUshort(sc, 0x19, 0x76f0);
13354         MP_WritePhyUshort(sc, 0x15, 0x002a);
13355         MP_WritePhyUshort(sc, 0x19, 0x7670);
13356         MP_WritePhyUshort(sc, 0x15, 0x002b);
13357         MP_WritePhyUshort(sc, 0x19, 0x7630);
13358         MP_WritePhyUshort(sc, 0x15, 0x002c);
13359         MP_WritePhyUshort(sc, 0x19, 0x31a6);
13360         MP_WritePhyUshort(sc, 0x15, 0x002d);
13361         MP_WritePhyUshort(sc, 0x19, 0x0000);
13362         MP_WritePhyUshort(sc, 0x15, 0x002e);
13363         MP_WritePhyUshort(sc, 0x19, 0x0000);
13364         MP_WritePhyUshort(sc, 0x15, 0x002f);
13365         MP_WritePhyUshort(sc, 0x19, 0x0000);
13366         MP_WritePhyUshort(sc, 0x15, 0x0030);
13367         MP_WritePhyUshort(sc, 0x19, 0x0000);
13368         MP_WritePhyUshort(sc, 0x15, 0x0031);
13369         MP_WritePhyUshort(sc, 0x19, 0x0000);
13370         MP_WritePhyUshort(sc, 0x15, 0x0032);
13371         MP_WritePhyUshort(sc, 0x19, 0x4801);
13372         MP_WritePhyUshort(sc, 0x15, 0x0033);
13373         MP_WritePhyUshort(sc, 0x19, 0x6803);
13374         MP_WritePhyUshort(sc, 0x15, 0x0034);
13375         MP_WritePhyUshort(sc, 0x19, 0x66a1);
13376         MP_WritePhyUshort(sc, 0x15, 0x0035);
13377         MP_WritePhyUshort(sc, 0x19, 0x7c03);
13378         MP_WritePhyUshort(sc, 0x15, 0x0036);
13379         MP_WritePhyUshort(sc, 0x19, 0x6c03);
13380         MP_WritePhyUshort(sc, 0x15, 0x0037);
13381         MP_WritePhyUshort(sc, 0x19, 0xa300);
13382         MP_WritePhyUshort(sc, 0x15, 0x0038);
13383         MP_WritePhyUshort(sc, 0x19, 0x64a1);
13384         MP_WritePhyUshort(sc, 0x15, 0x0039);
13385         MP_WritePhyUshort(sc, 0x19, 0x7c08);
13386         MP_WritePhyUshort(sc, 0x15, 0x003a);
13387         MP_WritePhyUshort(sc, 0x19, 0x74f8);
13388         MP_WritePhyUshort(sc, 0x15, 0x003b);
13389         MP_WritePhyUshort(sc, 0x19, 0x63d0);
13390         MP_WritePhyUshort(sc, 0x15, 0x003c);
13391         MP_WritePhyUshort(sc, 0x19, 0x7ff0);
13392         MP_WritePhyUshort(sc, 0x15, 0x003d);
13393         MP_WritePhyUshort(sc, 0x19, 0x77f0);
13394         MP_WritePhyUshort(sc, 0x15, 0x003e);
13395         MP_WritePhyUshort(sc, 0x19, 0x7ff0);
13396         MP_WritePhyUshort(sc, 0x15, 0x003f);
13397         MP_WritePhyUshort(sc, 0x19, 0x7750);
13398         MP_WritePhyUshort(sc, 0x15, 0x0040);
13399         MP_WritePhyUshort(sc, 0x19, 0x63d8);
13400         MP_WritePhyUshort(sc, 0x15, 0x0041);
13401         MP_WritePhyUshort(sc, 0x19, 0x7cf0);
13402         MP_WritePhyUshort(sc, 0x15, 0x0042);
13403         MP_WritePhyUshort(sc, 0x19, 0x7708);
13404         MP_WritePhyUshort(sc, 0x15, 0x0043);
13405         MP_WritePhyUshort(sc, 0x19, 0xa654);
13406         MP_WritePhyUshort(sc, 0x15, 0x0044);
13407         MP_WritePhyUshort(sc, 0x19, 0x304a);
13408         MP_WritePhyUshort(sc, 0x15, 0x0045);
13409         MP_WritePhyUshort(sc, 0x19, 0x0000);
13410         MP_WritePhyUshort(sc, 0x15, 0x0046);
13411         MP_WritePhyUshort(sc, 0x19, 0x0000);
13412         MP_WritePhyUshort(sc, 0x15, 0x0047);
13413         MP_WritePhyUshort(sc, 0x19, 0x0000);
13414         MP_WritePhyUshort(sc, 0x15, 0x0048);
13415         MP_WritePhyUshort(sc, 0x19, 0x0000);
13416         MP_WritePhyUshort(sc, 0x15, 0x0049);
13417         MP_WritePhyUshort(sc, 0x19, 0x0000);
13418         MP_WritePhyUshort(sc, 0x15, 0x004a);
13419         MP_WritePhyUshort(sc, 0x19, 0x4802);
13420         MP_WritePhyUshort(sc, 0x15, 0x004b);
13421         MP_WritePhyUshort(sc, 0x19, 0x4003);
13422         MP_WritePhyUshort(sc, 0x15, 0x004c);
13423         MP_WritePhyUshort(sc, 0x19, 0x4440);
13424         MP_WritePhyUshort(sc, 0x15, 0x004d);
13425         MP_WritePhyUshort(sc, 0x19, 0x63c8);
13426         MP_WritePhyUshort(sc, 0x15, 0x004e);
13427         MP_WritePhyUshort(sc, 0x19, 0x6481);
13428         MP_WritePhyUshort(sc, 0x15, 0x004f);
13429         MP_WritePhyUshort(sc, 0x19, 0x9d00);
13430         MP_WritePhyUshort(sc, 0x15, 0x0050);
13431         MP_WritePhyUshort(sc, 0x19, 0x63e8);
13432         MP_WritePhyUshort(sc, 0x15, 0x0051);
13433         MP_WritePhyUshort(sc, 0x19, 0x7d00);
13434         MP_WritePhyUshort(sc, 0x15, 0x0052);
13435         MP_WritePhyUshort(sc, 0x19, 0x5900);
13436         MP_WritePhyUshort(sc, 0x15, 0x0053);
13437         MP_WritePhyUshort(sc, 0x19, 0x63f8);
13438         MP_WritePhyUshort(sc, 0x15, 0x0054);
13439         MP_WritePhyUshort(sc, 0x19, 0x64a1);
13440         MP_WritePhyUshort(sc, 0x15, 0x0055);
13441         MP_WritePhyUshort(sc, 0x19, 0x3116);
13442         MP_WritePhyUshort(sc, 0x15, 0x0056);
13443         MP_WritePhyUshort(sc, 0x19, 0x0000);
13444         MP_WritePhyUshort(sc, 0x15, 0x0057);
13445         MP_WritePhyUshort(sc, 0x19, 0x0000);
13446         MP_WritePhyUshort(sc, 0x15, 0x0058);
13447         MP_WritePhyUshort(sc, 0x19, 0x0000);
13448         MP_WritePhyUshort(sc, 0x15, 0x0059);
13449         MP_WritePhyUshort(sc, 0x19, 0x0000);
13450         MP_WritePhyUshort(sc, 0x15, 0x005a);
13451         MP_WritePhyUshort(sc, 0x19, 0x7c03);
13452         MP_WritePhyUshort(sc, 0x15, 0x005b);
13453         MP_WritePhyUshort(sc, 0x19, 0x6c03);
13454         MP_WritePhyUshort(sc, 0x15, 0x005c);
13455         MP_WritePhyUshort(sc, 0x19, 0x7c08);
13456         MP_WritePhyUshort(sc, 0x15, 0x005d);
13457         MP_WritePhyUshort(sc, 0x19, 0x6000);
13458         MP_WritePhyUshort(sc, 0x15, 0x005e);
13459         MP_WritePhyUshort(sc, 0x19, 0x59ce);
13460         MP_WritePhyUshort(sc, 0x15, 0x005f);
13461         MP_WritePhyUshort(sc, 0x19, 0x4400);
13462         MP_WritePhyUshort(sc, 0x15, 0x0060);
13463         MP_WritePhyUshort(sc, 0x19, 0x7d00);
13464         MP_WritePhyUshort(sc, 0x15, 0x0061);
13465         MP_WritePhyUshort(sc, 0x19, 0x72b0);
13466         MP_WritePhyUshort(sc, 0x15, 0x0062);
13467         MP_WritePhyUshort(sc, 0x19, 0x400e);
13468         MP_WritePhyUshort(sc, 0x15, 0x0063);
13469         MP_WritePhyUshort(sc, 0x19, 0x4440);
13470         MP_WritePhyUshort(sc, 0x15, 0x0064);
13471         MP_WritePhyUshort(sc, 0x19, 0x9d00);
13472         MP_WritePhyUshort(sc, 0x15, 0x0065);
13473         MP_WritePhyUshort(sc, 0x19, 0x7f00);
13474         MP_WritePhyUshort(sc, 0x15, 0x0066);
13475         MP_WritePhyUshort(sc, 0x19, 0x70b0);
13476         MP_WritePhyUshort(sc, 0x15, 0x0067);
13477         MP_WritePhyUshort(sc, 0x19, 0x7c08);
13478         MP_WritePhyUshort(sc, 0x15, 0x0068);
13479         MP_WritePhyUshort(sc, 0x19, 0x6008);
13480         MP_WritePhyUshort(sc, 0x15, 0x0069);
13481         MP_WritePhyUshort(sc, 0x19, 0x7cf0);
13482         MP_WritePhyUshort(sc, 0x15, 0x006a);
13483         MP_WritePhyUshort(sc, 0x19, 0x7750);
13484         MP_WritePhyUshort(sc, 0x15, 0x006b);
13485         MP_WritePhyUshort(sc, 0x19, 0x4007);
13486         MP_WritePhyUshort(sc, 0x15, 0x006c);
13487         MP_WritePhyUshort(sc, 0x19, 0x4500);
13488         MP_WritePhyUshort(sc, 0x15, 0x006d);
13489         MP_WritePhyUshort(sc, 0x19, 0x4023);
13490         MP_WritePhyUshort(sc, 0x15, 0x006e);
13491         MP_WritePhyUshort(sc, 0x19, 0x4580);
13492         MP_WritePhyUshort(sc, 0x15, 0x006f);
13493         MP_WritePhyUshort(sc, 0x19, 0x9f00);
13494         MP_WritePhyUshort(sc, 0x15, 0x0070);
13495         MP_WritePhyUshort(sc, 0x19, 0xcd78);
13496         MP_WritePhyUshort(sc, 0x15, 0x0071);
13497         MP_WritePhyUshort(sc, 0x19, 0x0003);
13498         MP_WritePhyUshort(sc, 0x15, 0x0072);
13499         MP_WritePhyUshort(sc, 0x19, 0xbe02);
13500         MP_WritePhyUshort(sc, 0x15, 0x0073);
13501         MP_WritePhyUshort(sc, 0x19, 0x3070);
13502         MP_WritePhyUshort(sc, 0x15, 0x0074);
13503         MP_WritePhyUshort(sc, 0x19, 0x7cf0);
13504         MP_WritePhyUshort(sc, 0x15, 0x0075);
13505         MP_WritePhyUshort(sc, 0x19, 0x77f0);
13506         MP_WritePhyUshort(sc, 0x15, 0x0076);
13507         MP_WritePhyUshort(sc, 0x19, 0x4400);
13508         MP_WritePhyUshort(sc, 0x15, 0x0077);
13509         MP_WritePhyUshort(sc, 0x19, 0x4007);
13510         MP_WritePhyUshort(sc, 0x15, 0x0078);
13511         MP_WritePhyUshort(sc, 0x19, 0x4500);
13512         MP_WritePhyUshort(sc, 0x15, 0x0079);
13513         MP_WritePhyUshort(sc, 0x19, 0x4023);
13514         MP_WritePhyUshort(sc, 0x15, 0x007a);
13515         MP_WritePhyUshort(sc, 0x19, 0x4580);
13516         MP_WritePhyUshort(sc, 0x15, 0x007b);
13517         MP_WritePhyUshort(sc, 0x19, 0x9f00);
13518         MP_WritePhyUshort(sc, 0x15, 0x007c);
13519         MP_WritePhyUshort(sc, 0x19, 0xce80);
13520         MP_WritePhyUshort(sc, 0x15, 0x007d);
13521         MP_WritePhyUshort(sc, 0x19, 0x0004);
13522         MP_WritePhyUshort(sc, 0x15, 0x007e);
13523         MP_WritePhyUshort(sc, 0x19, 0xce80);
13524         MP_WritePhyUshort(sc, 0x15, 0x007f);
13525         MP_WritePhyUshort(sc, 0x19, 0x0002);
13526         MP_WritePhyUshort(sc, 0x15, 0x0080);
13527         MP_WritePhyUshort(sc, 0x19, 0x307c);
13528         MP_WritePhyUshort(sc, 0x15, 0x0081);
13529         MP_WritePhyUshort(sc, 0x19, 0x4400);
13530         MP_WritePhyUshort(sc, 0x15, 0x0082);
13531         MP_WritePhyUshort(sc, 0x19, 0x480f);
13532         MP_WritePhyUshort(sc, 0x15, 0x0083);
13533         MP_WritePhyUshort(sc, 0x19, 0x6802);
13534         MP_WritePhyUshort(sc, 0x15, 0x0084);
13535         MP_WritePhyUshort(sc, 0x19, 0x6680);
13536         MP_WritePhyUshort(sc, 0x15, 0x0085);
13537         MP_WritePhyUshort(sc, 0x19, 0x7c10);
13538         MP_WritePhyUshort(sc, 0x15, 0x0086);
13539         MP_WritePhyUshort(sc, 0x19, 0x6010);
13540         MP_WritePhyUshort(sc, 0x15, 0x0087);
13541         MP_WritePhyUshort(sc, 0x19, 0x400a);
13542         MP_WritePhyUshort(sc, 0x15, 0x0088);
13543         MP_WritePhyUshort(sc, 0x19, 0x4580);
13544         MP_WritePhyUshort(sc, 0x15, 0x0089);
13545         MP_WritePhyUshort(sc, 0x19, 0x9e00);
13546         MP_WritePhyUshort(sc, 0x15, 0x008a);
13547         MP_WritePhyUshort(sc, 0x19, 0x7d00);
13548         MP_WritePhyUshort(sc, 0x15, 0x008b);
13549         MP_WritePhyUshort(sc, 0x19, 0x5800);
13550         MP_WritePhyUshort(sc, 0x15, 0x008c);
13551         MP_WritePhyUshort(sc, 0x19, 0x63c8);
13552         MP_WritePhyUshort(sc, 0x15, 0x008d);
13553         MP_WritePhyUshort(sc, 0x19, 0x63d8);
13554         MP_WritePhyUshort(sc, 0x15, 0x008e);
13555         MP_WritePhyUshort(sc, 0x19, 0x66a0);
13556         MP_WritePhyUshort(sc, 0x15, 0x008f);
13557         MP_WritePhyUshort(sc, 0x19, 0x8300);
13558         MP_WritePhyUshort(sc, 0x15, 0x0090);
13559         MP_WritePhyUshort(sc, 0x19, 0x7ff0);
13560         MP_WritePhyUshort(sc, 0x15, 0x0091);
13561         MP_WritePhyUshort(sc, 0x19, 0x74f0);
13562         MP_WritePhyUshort(sc, 0x15, 0x0092);
13563         MP_WritePhyUshort(sc, 0x19, 0x3006);
13564         MP_WritePhyUshort(sc, 0x15, 0x0093);
13565         MP_WritePhyUshort(sc, 0x19, 0x0000);
13566         MP_WritePhyUshort(sc, 0x15, 0x0094);
13567         MP_WritePhyUshort(sc, 0x19, 0x0000);
13568         MP_WritePhyUshort(sc, 0x15, 0x0095);
13569         MP_WritePhyUshort(sc, 0x19, 0x0000);
13570         MP_WritePhyUshort(sc, 0x15, 0x0096);
13571         MP_WritePhyUshort(sc, 0x19, 0x0000);
13572         MP_WritePhyUshort(sc, 0x15, 0x0097);
13573         MP_WritePhyUshort(sc, 0x19, 0x4803);
13574         MP_WritePhyUshort(sc, 0x15, 0x0098);
13575         MP_WritePhyUshort(sc, 0x19, 0x7c03);
13576         MP_WritePhyUshort(sc, 0x15, 0x0099);
13577         MP_WritePhyUshort(sc, 0x19, 0x6c03);
13578         MP_WritePhyUshort(sc, 0x15, 0x009a);
13579         MP_WritePhyUshort(sc, 0x19, 0xa203);
13580         MP_WritePhyUshort(sc, 0x15, 0x009b);
13581         MP_WritePhyUshort(sc, 0x19, 0x64b1);
13582         MP_WritePhyUshort(sc, 0x15, 0x009c);
13583         MP_WritePhyUshort(sc, 0x19, 0x309e);
13584         MP_WritePhyUshort(sc, 0x15, 0x009d);
13585         MP_WritePhyUshort(sc, 0x19, 0x64b3);
13586         MP_WritePhyUshort(sc, 0x15, 0x009e);
13587         MP_WritePhyUshort(sc, 0x19, 0x4030);
13588         MP_WritePhyUshort(sc, 0x15, 0x009f);
13589         MP_WritePhyUshort(sc, 0x19, 0x440e);
13590         MP_WritePhyUshort(sc, 0x15, 0x00a0);
13591         MP_WritePhyUshort(sc, 0x19, 0x4020);
13592         MP_WritePhyUshort(sc, 0x15, 0x00a1);
13593         MP_WritePhyUshort(sc, 0x19, 0x4419);
13594         MP_WritePhyUshort(sc, 0x15, 0x00a2);
13595         MP_WritePhyUshort(sc, 0x19, 0x7801);
13596         MP_WritePhyUshort(sc, 0x15, 0x00a3);
13597         MP_WritePhyUshort(sc, 0x19, 0xc520);
13598         MP_WritePhyUshort(sc, 0x15, 0x00a4);
13599         MP_WritePhyUshort(sc, 0x19, 0x000b);
13600         MP_WritePhyUshort(sc, 0x15, 0x00a5);
13601         MP_WritePhyUshort(sc, 0x19, 0x4020);
13602         MP_WritePhyUshort(sc, 0x15, 0x00a6);
13603         MP_WritePhyUshort(sc, 0x19, 0x7800);
13604         MP_WritePhyUshort(sc, 0x15, 0x00a7);
13605         MP_WritePhyUshort(sc, 0x19, 0x58a4);
13606         MP_WritePhyUshort(sc, 0x15, 0x00a8);
13607         MP_WritePhyUshort(sc, 0x19, 0x63da);
13608         MP_WritePhyUshort(sc, 0x15, 0x00a9);
13609         MP_WritePhyUshort(sc, 0x19, 0x5cb0);
13610         MP_WritePhyUshort(sc, 0x15, 0x00aa);
13611         MP_WritePhyUshort(sc, 0x19, 0x7d00);
13612         MP_WritePhyUshort(sc, 0x15, 0x00ab);
13613         MP_WritePhyUshort(sc, 0x19, 0x72b0);
13614         MP_WritePhyUshort(sc, 0x15, 0x00ac);
13615         MP_WritePhyUshort(sc, 0x19, 0x7f00);
13616         MP_WritePhyUshort(sc, 0x15, 0x00ad);
13617         MP_WritePhyUshort(sc, 0x19, 0x70b0);
13618         MP_WritePhyUshort(sc, 0x15, 0x00ae);
13619         MP_WritePhyUshort(sc, 0x19, 0x30b8);
13620         MP_WritePhyUshort(sc, 0x15, 0x00AF);
13621         MP_WritePhyUshort(sc, 0x19, 0x4060);
13622         MP_WritePhyUshort(sc, 0x15, 0x00B0);
13623         MP_WritePhyUshort(sc, 0x19, 0x7800);
13624         MP_WritePhyUshort(sc, 0x15, 0x00B1);
13625         MP_WritePhyUshort(sc, 0x19, 0x7e00);
13626         MP_WritePhyUshort(sc, 0x15, 0x00B2);
13627         MP_WritePhyUshort(sc, 0x19, 0x72B0);
13628         MP_WritePhyUshort(sc, 0x15, 0x00B3);
13629         MP_WritePhyUshort(sc, 0x19, 0x7F00);
13630         MP_WritePhyUshort(sc, 0x15, 0x00B4);
13631         MP_WritePhyUshort(sc, 0x19, 0x73B0);
13632         MP_WritePhyUshort(sc, 0x15, 0x00b5);
13633         MP_WritePhyUshort(sc, 0x19, 0x58a0);
13634         MP_WritePhyUshort(sc, 0x15, 0x00b6);
13635         MP_WritePhyUshort(sc, 0x19, 0x63d2);
13636         MP_WritePhyUshort(sc, 0x15, 0x00b7);
13637         MP_WritePhyUshort(sc, 0x19, 0x5c00);
13638         MP_WritePhyUshort(sc, 0x15, 0x00b8);
13639         MP_WritePhyUshort(sc, 0x19, 0x5780);
13640         MP_WritePhyUshort(sc, 0x15, 0x00b9);
13641         MP_WritePhyUshort(sc, 0x19, 0xb60d);
13642         MP_WritePhyUshort(sc, 0x15, 0x00ba);
13643         MP_WritePhyUshort(sc, 0x19, 0x9bff);
13644         MP_WritePhyUshort(sc, 0x15, 0x00bb);
13645         MP_WritePhyUshort(sc, 0x19, 0x7c03);
13646         MP_WritePhyUshort(sc, 0x15, 0x00bc);
13647         MP_WritePhyUshort(sc, 0x19, 0x6001);
13648         MP_WritePhyUshort(sc, 0x15, 0x00bd);
13649         MP_WritePhyUshort(sc, 0x19, 0xc020);
13650         MP_WritePhyUshort(sc, 0x15, 0x00be);
13651         MP_WritePhyUshort(sc, 0x19, 0x002b);
13652         MP_WritePhyUshort(sc, 0x15, 0x00bf);
13653         MP_WritePhyUshort(sc, 0x19, 0xc137);
13654         MP_WritePhyUshort(sc, 0x15, 0x00c0);
13655         MP_WritePhyUshort(sc, 0x19, 0x0006);
13656         MP_WritePhyUshort(sc, 0x15, 0x00c1);
13657         MP_WritePhyUshort(sc, 0x19, 0x9af8);
13658         MP_WritePhyUshort(sc, 0x15, 0x00c2);
13659         MP_WritePhyUshort(sc, 0x19, 0x30c6);
13660         MP_WritePhyUshort(sc, 0x15, 0x00c3);
13661         MP_WritePhyUshort(sc, 0x19, 0x0000);
13662         MP_WritePhyUshort(sc, 0x15, 0x00c4);
13663         MP_WritePhyUshort(sc, 0x19, 0x0000);
13664         MP_WritePhyUshort(sc, 0x15, 0x00c5);
13665         MP_WritePhyUshort(sc, 0x19, 0x0000);
13666         MP_WritePhyUshort(sc, 0x15, 0x00c6);
13667         MP_WritePhyUshort(sc, 0x19, 0x7d00);
13668         MP_WritePhyUshort(sc, 0x15, 0x00c7);
13669         MP_WritePhyUshort(sc, 0x19, 0x70b0);
13670         MP_WritePhyUshort(sc, 0x15, 0x00c8);
13671         MP_WritePhyUshort(sc, 0x19, 0x4400);
13672         MP_WritePhyUshort(sc, 0x15, 0x00c9);
13673         MP_WritePhyUshort(sc, 0x19, 0x4804);
13674         MP_WritePhyUshort(sc, 0x15, 0x00ca);
13675         MP_WritePhyUshort(sc, 0x19, 0x7c80);
13676         MP_WritePhyUshort(sc, 0x15, 0x00cb);
13677         MP_WritePhyUshort(sc, 0x19, 0x5c80);
13678         MP_WritePhyUshort(sc, 0x15, 0x00cc);
13679         MP_WritePhyUshort(sc, 0x19, 0x4010);
13680         MP_WritePhyUshort(sc, 0x15, 0x00cd);
13681         MP_WritePhyUshort(sc, 0x19, 0x4415);
13682         MP_WritePhyUshort(sc, 0x15, 0x00ce);
13683         MP_WritePhyUshort(sc, 0x19, 0x9b00);
13684         MP_WritePhyUshort(sc, 0x15, 0x00cf);
13685         MP_WritePhyUshort(sc, 0x19, 0x7f00);
13686         MP_WritePhyUshort(sc, 0x15, 0x00d0);
13687         MP_WritePhyUshort(sc, 0x19, 0x70b0);
13688         MP_WritePhyUshort(sc, 0x15, 0x00d1);
13689         MP_WritePhyUshort(sc, 0x19, 0x3177);
13690         MP_WritePhyUshort(sc, 0x15, 0x00d2);
13691         MP_WritePhyUshort(sc, 0x19, 0x0000);
13692         MP_WritePhyUshort(sc, 0x15, 0x00d3);
13693         MP_WritePhyUshort(sc, 0x19, 0x0000);
13694         MP_WritePhyUshort(sc, 0x15, 0x00d4);
13695         MP_WritePhyUshort(sc, 0x19, 0x0000);
13696         MP_WritePhyUshort(sc, 0x15, 0x00d5);
13697         MP_WritePhyUshort(sc, 0x19, 0x4808);
13698         MP_WritePhyUshort(sc, 0x15, 0x00d6);
13699         MP_WritePhyUshort(sc, 0x19, 0x4007);
13700         MP_WritePhyUshort(sc, 0x15, 0x00d7);
13701         MP_WritePhyUshort(sc, 0x19, 0x4420);
13702         MP_WritePhyUshort(sc, 0x15, 0x00d8);
13703         MP_WritePhyUshort(sc, 0x19, 0x63d8);
13704         MP_WritePhyUshort(sc, 0x15, 0x00d9);
13705         MP_WritePhyUshort(sc, 0x19, 0xb608);
13706         MP_WritePhyUshort(sc, 0x15, 0x00da);
13707         MP_WritePhyUshort(sc, 0x19, 0xbcbd);
13708         MP_WritePhyUshort(sc, 0x15, 0x00db);
13709         MP_WritePhyUshort(sc, 0x19, 0xc60b);
13710         MP_WritePhyUshort(sc, 0x15, 0x00dc);
13711         MP_WritePhyUshort(sc, 0x19, 0x00fd);
13712         MP_WritePhyUshort(sc, 0x15, 0x00dd);
13713         MP_WritePhyUshort(sc, 0x19, 0x30e1);
13714         MP_WritePhyUshort(sc, 0x15, 0x00de);
13715         MP_WritePhyUshort(sc, 0x19, 0x0000);
13716         MP_WritePhyUshort(sc, 0x15, 0x00df);
13717         MP_WritePhyUshort(sc, 0x19, 0x0000);
13718         MP_WritePhyUshort(sc, 0x15, 0x00e0);
13719         MP_WritePhyUshort(sc, 0x19, 0x0000);
13720         MP_WritePhyUshort(sc, 0x15, 0x00e1);
13721         MP_WritePhyUshort(sc, 0x19, 0x4809);
13722         MP_WritePhyUshort(sc, 0x15, 0x00e2);
13723         MP_WritePhyUshort(sc, 0x19, 0x7e40);
13724         MP_WritePhyUshort(sc, 0x15, 0x00e3);
13725         MP_WritePhyUshort(sc, 0x19, 0x5a40);
13726         MP_WritePhyUshort(sc, 0x15, 0x00e4);
13727         MP_WritePhyUshort(sc, 0x19, 0x305a);
13728         MP_WritePhyUshort(sc, 0x15, 0x00e5);
13729         MP_WritePhyUshort(sc, 0x19, 0x0000);
13730         MP_WritePhyUshort(sc, 0x15, 0x00e6);
13731         MP_WritePhyUshort(sc, 0x19, 0x0000);
13732         MP_WritePhyUshort(sc, 0x15, 0x00e7);
13733         MP_WritePhyUshort(sc, 0x19, 0x0000);
13734         MP_WritePhyUshort(sc, 0x15, 0x00e8);
13735         MP_WritePhyUshort(sc, 0x19, 0x0000);
13736         MP_WritePhyUshort(sc, 0x15, 0x00e9);
13737         MP_WritePhyUshort(sc, 0x19, 0x480a);
13738         MP_WritePhyUshort(sc, 0x15, 0x00ea);
13739         MP_WritePhyUshort(sc, 0x19, 0x5820);
13740         MP_WritePhyUshort(sc, 0x15, 0x00eb);
13741         MP_WritePhyUshort(sc, 0x19, 0x6c03);
13742         MP_WritePhyUshort(sc, 0x15, 0x00ec);
13743         MP_WritePhyUshort(sc, 0x19, 0xb60a);
13744         MP_WritePhyUshort(sc, 0x15, 0x00ed);
13745         MP_WritePhyUshort(sc, 0x19, 0xda07);
13746         MP_WritePhyUshort(sc, 0x15, 0x00ee);
13747         MP_WritePhyUshort(sc, 0x19, 0x0008);
13748         MP_WritePhyUshort(sc, 0x15, 0x00ef);
13749         MP_WritePhyUshort(sc, 0x19, 0xc60b);
13750         MP_WritePhyUshort(sc, 0x15, 0x00f0);
13751         MP_WritePhyUshort(sc, 0x19, 0x00fc);
13752         MP_WritePhyUshort(sc, 0x15, 0x00f1);
13753         MP_WritePhyUshort(sc, 0x19, 0x30f6);
13754         MP_WritePhyUshort(sc, 0x15, 0x00f2);
13755         MP_WritePhyUshort(sc, 0x19, 0x0000);
13756         MP_WritePhyUshort(sc, 0x15, 0x00f3);
13757         MP_WritePhyUshort(sc, 0x19, 0x0000);
13758         MP_WritePhyUshort(sc, 0x15, 0x00f4);
13759         MP_WritePhyUshort(sc, 0x19, 0x0000);
13760         MP_WritePhyUshort(sc, 0x15, 0x00f5);
13761         MP_WritePhyUshort(sc, 0x19, 0x0000);
13762         MP_WritePhyUshort(sc, 0x15, 0x00f6);
13763         MP_WritePhyUshort(sc, 0x19, 0x4408);
13764         MP_WritePhyUshort(sc, 0x15, 0x00f7);
13765         MP_WritePhyUshort(sc, 0x19, 0x480b);
13766         MP_WritePhyUshort(sc, 0x15, 0x00f8);
13767         MP_WritePhyUshort(sc, 0x19, 0x6f03);
13768         MP_WritePhyUshort(sc, 0x15, 0x00f9);
13769         MP_WritePhyUshort(sc, 0x19, 0x405f);
13770         MP_WritePhyUshort(sc, 0x15, 0x00fa);
13771         MP_WritePhyUshort(sc, 0x19, 0x4448);
13772         MP_WritePhyUshort(sc, 0x15, 0x00fb);
13773         MP_WritePhyUshort(sc, 0x19, 0x4020);
13774         MP_WritePhyUshort(sc, 0x15, 0x00fc);
13775         MP_WritePhyUshort(sc, 0x19, 0x4468);
13776         MP_WritePhyUshort(sc, 0x15, 0x00fd);
13777         MP_WritePhyUshort(sc, 0x19, 0x9c03);
13778         MP_WritePhyUshort(sc, 0x15, 0x00fe);
13779         MP_WritePhyUshort(sc, 0x19, 0x6f07);
13780         MP_WritePhyUshort(sc, 0x15, 0x00ff);
13781         MP_WritePhyUshort(sc, 0x19, 0x58a0);
13782         MP_WritePhyUshort(sc, 0x15, 0x0100);
13783         MP_WritePhyUshort(sc, 0x19, 0xd6d1);
13784         MP_WritePhyUshort(sc, 0x15, 0x0101);
13785         MP_WritePhyUshort(sc, 0x19, 0x0004);
13786         MP_WritePhyUshort(sc, 0x15, 0x0102);
13787         MP_WritePhyUshort(sc, 0x19, 0xc137);
13788         MP_WritePhyUshort(sc, 0x15, 0x0103);
13789         MP_WritePhyUshort(sc, 0x19, 0x0002);
13790         MP_WritePhyUshort(sc, 0x15, 0x0104);
13791         MP_WritePhyUshort(sc, 0x19, 0xa0e5);
13792         MP_WritePhyUshort(sc, 0x15, 0x0105);
13793         MP_WritePhyUshort(sc, 0x19, 0x9df8);
13794         MP_WritePhyUshort(sc, 0x15, 0x0106);
13795         MP_WritePhyUshort(sc, 0x19, 0x30c6);
13796         MP_WritePhyUshort(sc, 0x15, 0x0107);
13797         MP_WritePhyUshort(sc, 0x19, 0x0000);
13798         MP_WritePhyUshort(sc, 0x15, 0x0108);
13799         MP_WritePhyUshort(sc, 0x19, 0x0000);
13800         MP_WritePhyUshort(sc, 0x15, 0x0109);
13801         MP_WritePhyUshort(sc, 0x19, 0x0000);
13802         MP_WritePhyUshort(sc, 0x15, 0x010a);
13803         MP_WritePhyUshort(sc, 0x19, 0x0000);
13804         MP_WritePhyUshort(sc, 0x15, 0x010b);
13805         MP_WritePhyUshort(sc, 0x19, 0x4808);
13806         MP_WritePhyUshort(sc, 0x15, 0x010c);
13807         MP_WritePhyUshort(sc, 0x19, 0xc32d);
13808         MP_WritePhyUshort(sc, 0x15, 0x010d);
13809         MP_WritePhyUshort(sc, 0x19, 0x0003);
13810         MP_WritePhyUshort(sc, 0x15, 0x010e);
13811         MP_WritePhyUshort(sc, 0x19, 0xc8b3);
13812         MP_WritePhyUshort(sc, 0x15, 0x010f);
13813         MP_WritePhyUshort(sc, 0x19, 0x00fc);
13814         MP_WritePhyUshort(sc, 0x15, 0x0110);
13815         MP_WritePhyUshort(sc, 0x19, 0x4400);
13816         MP_WritePhyUshort(sc, 0x15, 0x0111);
13817         MP_WritePhyUshort(sc, 0x19, 0x3116);
13818         MP_WritePhyUshort(sc, 0x15, 0x0112);
13819         MP_WritePhyUshort(sc, 0x19, 0x0000);
13820         MP_WritePhyUshort(sc, 0x15, 0x0113);
13821         MP_WritePhyUshort(sc, 0x19, 0x0000);
13822         MP_WritePhyUshort(sc, 0x15, 0x0114);
13823         MP_WritePhyUshort(sc, 0x19, 0x0000);
13824         MP_WritePhyUshort(sc, 0x15, 0x0115);
13825         MP_WritePhyUshort(sc, 0x19, 0x0000);
13826         MP_WritePhyUshort(sc, 0x15, 0x0116);
13827         MP_WritePhyUshort(sc, 0x19, 0x4803);
13828         MP_WritePhyUshort(sc, 0x15, 0x0117);
13829         MP_WritePhyUshort(sc, 0x19, 0x7c03);
13830         MP_WritePhyUshort(sc, 0x15, 0x0118);
13831         MP_WritePhyUshort(sc, 0x19, 0x6c02);
13832         MP_WritePhyUshort(sc, 0x15, 0x0119);
13833         MP_WritePhyUshort(sc, 0x19, 0x7c04);
13834         MP_WritePhyUshort(sc, 0x15, 0x011a);
13835         MP_WritePhyUshort(sc, 0x19, 0x6000);
13836         MP_WritePhyUshort(sc, 0x15, 0x011b);
13837         MP_WritePhyUshort(sc, 0x19, 0x5cf7);
13838         MP_WritePhyUshort(sc, 0x15, 0x011c);
13839         MP_WritePhyUshort(sc, 0x19, 0x7c2a);
13840         MP_WritePhyUshort(sc, 0x15, 0x011d);
13841         MP_WritePhyUshort(sc, 0x19, 0x5800);
13842         MP_WritePhyUshort(sc, 0x15, 0x011e);
13843         MP_WritePhyUshort(sc, 0x19, 0x5400);
13844         MP_WritePhyUshort(sc, 0x15, 0x011f);
13845         MP_WritePhyUshort(sc, 0x19, 0x7c08);
13846         MP_WritePhyUshort(sc, 0x15, 0x0120);
13847         MP_WritePhyUshort(sc, 0x19, 0x74f0);
13848         MP_WritePhyUshort(sc, 0x15, 0x0121);
13849         MP_WritePhyUshort(sc, 0x19, 0x4019);
13850         MP_WritePhyUshort(sc, 0x15, 0x0122);
13851         MP_WritePhyUshort(sc, 0x19, 0x440d);
13852         MP_WritePhyUshort(sc, 0x15, 0x0123);
13853         MP_WritePhyUshort(sc, 0x19, 0xb6c1);
13854         MP_WritePhyUshort(sc, 0x15, 0x0124);
13855         MP_WritePhyUshort(sc, 0x19, 0xc05b);
13856         MP_WritePhyUshort(sc, 0x15, 0x0125);
13857         MP_WritePhyUshort(sc, 0x19, 0x00bf);
13858         MP_WritePhyUshort(sc, 0x15, 0x0126);
13859         MP_WritePhyUshort(sc, 0x19, 0xc025);
13860         MP_WritePhyUshort(sc, 0x15, 0x0127);
13861         MP_WritePhyUshort(sc, 0x19, 0x00bd);
13862         MP_WritePhyUshort(sc, 0x15, 0x0128);
13863         MP_WritePhyUshort(sc, 0x19, 0xc603);
13864         MP_WritePhyUshort(sc, 0x15, 0x0129);
13865         MP_WritePhyUshort(sc, 0x19, 0x00bb);
13866         MP_WritePhyUshort(sc, 0x15, 0x012a);
13867         MP_WritePhyUshort(sc, 0x19, 0x8805);
13868         MP_WritePhyUshort(sc, 0x15, 0x012b);
13869         MP_WritePhyUshort(sc, 0x19, 0x7801);
13870         MP_WritePhyUshort(sc, 0x15, 0x012c);
13871         MP_WritePhyUshort(sc, 0x19, 0x4001);
13872         MP_WritePhyUshort(sc, 0x15, 0x012d);
13873         MP_WritePhyUshort(sc, 0x19, 0x7800);
13874         MP_WritePhyUshort(sc, 0x15, 0x012e);
13875         MP_WritePhyUshort(sc, 0x19, 0xa3dd);
13876         MP_WritePhyUshort(sc, 0x15, 0x012f);
13877         MP_WritePhyUshort(sc, 0x19, 0x7c03);
13878         MP_WritePhyUshort(sc, 0x15, 0x0130);
13879         MP_WritePhyUshort(sc, 0x19, 0x6c03);
13880         MP_WritePhyUshort(sc, 0x15, 0x0131);
13881         MP_WritePhyUshort(sc, 0x19, 0x8407);
13882         MP_WritePhyUshort(sc, 0x15, 0x0132);
13883         MP_WritePhyUshort(sc, 0x19, 0x7c03);
13884         MP_WritePhyUshort(sc, 0x15, 0x0133);
13885         MP_WritePhyUshort(sc, 0x19, 0x6c02);
13886         MP_WritePhyUshort(sc, 0x15, 0x0134);
13887         MP_WritePhyUshort(sc, 0x19, 0xd9b8);
13888         MP_WritePhyUshort(sc, 0x15, 0x0135);
13889         MP_WritePhyUshort(sc, 0x19, 0x0003);
13890         MP_WritePhyUshort(sc, 0x15, 0x0136);
13891         MP_WritePhyUshort(sc, 0x19, 0xc240);
13892         MP_WritePhyUshort(sc, 0x15, 0x0137);
13893         MP_WritePhyUshort(sc, 0x19, 0x0015);
13894         MP_WritePhyUshort(sc, 0x15, 0x0138);
13895         MP_WritePhyUshort(sc, 0x19, 0x7c03);
13896         MP_WritePhyUshort(sc, 0x15, 0x0139);
13897         MP_WritePhyUshort(sc, 0x19, 0x6c02);
13898         MP_WritePhyUshort(sc, 0x15, 0x013a);
13899         MP_WritePhyUshort(sc, 0x19, 0x9ae9);
13900         MP_WritePhyUshort(sc, 0x15, 0x013b);
13901         MP_WritePhyUshort(sc, 0x19, 0x3140);
13902         MP_WritePhyUshort(sc, 0x15, 0x013c);
13903         MP_WritePhyUshort(sc, 0x19, 0x0000);
13904         MP_WritePhyUshort(sc, 0x15, 0x013d);
13905         MP_WritePhyUshort(sc, 0x19, 0x0000);
13906         MP_WritePhyUshort(sc, 0x15, 0x013e);
13907         MP_WritePhyUshort(sc, 0x19, 0x0000);
13908         MP_WritePhyUshort(sc, 0x15, 0x013f);
13909         MP_WritePhyUshort(sc, 0x19, 0x0000);
13910         MP_WritePhyUshort(sc, 0x15, 0x0140);
13911         MP_WritePhyUshort(sc, 0x19, 0x4807);
13912         MP_WritePhyUshort(sc, 0x15, 0x0141);
13913         MP_WritePhyUshort(sc, 0x19, 0x4004);
13914         MP_WritePhyUshort(sc, 0x15, 0x0142);
13915         MP_WritePhyUshort(sc, 0x19, 0x4410);
13916         MP_WritePhyUshort(sc, 0x15, 0x0143);
13917         MP_WritePhyUshort(sc, 0x19, 0x7c0c);
13918         MP_WritePhyUshort(sc, 0x15, 0x0144);
13919         MP_WritePhyUshort(sc, 0x19, 0x600c);
13920         MP_WritePhyUshort(sc, 0x15, 0x0145);
13921         MP_WritePhyUshort(sc, 0x19, 0x9b00);
13922         MP_WritePhyUshort(sc, 0x15, 0x0146);
13923         MP_WritePhyUshort(sc, 0x19, 0xa68f);
13924         MP_WritePhyUshort(sc, 0x15, 0x0147);
13925         MP_WritePhyUshort(sc, 0x19, 0x3116);
13926         MP_WritePhyUshort(sc, 0x15, 0x0148);
13927         MP_WritePhyUshort(sc, 0x19, 0x0000);
13928         MP_WritePhyUshort(sc, 0x15, 0x0149);
13929         MP_WritePhyUshort(sc, 0x19, 0x0000);
13930         MP_WritePhyUshort(sc, 0x15, 0x014a);
13931         MP_WritePhyUshort(sc, 0x19, 0x0000);
13932         MP_WritePhyUshort(sc, 0x15, 0x014b);
13933         MP_WritePhyUshort(sc, 0x19, 0x0000);
13934         MP_WritePhyUshort(sc, 0x15, 0x014c);
13935         MP_WritePhyUshort(sc, 0x19, 0x4804);
13936         MP_WritePhyUshort(sc, 0x15, 0x014d);
13937         MP_WritePhyUshort(sc, 0x19, 0x54c0);
13938         MP_WritePhyUshort(sc, 0x15, 0x014e);
13939         MP_WritePhyUshort(sc, 0x19, 0xb703);
13940         MP_WritePhyUshort(sc, 0x15, 0x014f);
13941         MP_WritePhyUshort(sc, 0x19, 0x5cff);
13942         MP_WritePhyUshort(sc, 0x15, 0x0150);
13943         MP_WritePhyUshort(sc, 0x19, 0x315f);
13944         MP_WritePhyUshort(sc, 0x15, 0x0151);
13945         MP_WritePhyUshort(sc, 0x19, 0x7c08);
13946         MP_WritePhyUshort(sc, 0x15, 0x0152);
13947         MP_WritePhyUshort(sc, 0x19, 0x74f8);
13948         MP_WritePhyUshort(sc, 0x15, 0x0153);
13949         MP_WritePhyUshort(sc, 0x19, 0x6421);
13950         MP_WritePhyUshort(sc, 0x15, 0x0154);
13951         MP_WritePhyUshort(sc, 0x19, 0x7c08);
13952         MP_WritePhyUshort(sc, 0x15, 0x0155);
13953         MP_WritePhyUshort(sc, 0x19, 0x6000);
13954         MP_WritePhyUshort(sc, 0x15, 0x0156);
13955         MP_WritePhyUshort(sc, 0x19, 0x4003);
13956         MP_WritePhyUshort(sc, 0x15, 0x0157);
13957         MP_WritePhyUshort(sc, 0x19, 0x4418);
13958         MP_WritePhyUshort(sc, 0x15, 0x0158);
13959         MP_WritePhyUshort(sc, 0x19, 0x9b00);
13960         MP_WritePhyUshort(sc, 0x15, 0x0159);
13961         MP_WritePhyUshort(sc, 0x19, 0x6461);
13962         MP_WritePhyUshort(sc, 0x15, 0x015a);
13963         MP_WritePhyUshort(sc, 0x19, 0x64e1);
13964         MP_WritePhyUshort(sc, 0x15, 0x015b);
13965         MP_WritePhyUshort(sc, 0x19, 0x7c20);
13966         MP_WritePhyUshort(sc, 0x15, 0x015c);
13967         MP_WritePhyUshort(sc, 0x19, 0x5820);
13968         MP_WritePhyUshort(sc, 0x15, 0x015d);
13969         MP_WritePhyUshort(sc, 0x19, 0x5ccf);
13970         MP_WritePhyUshort(sc, 0x15, 0x015e);
13971         MP_WritePhyUshort(sc, 0x19, 0x7050);
13972         MP_WritePhyUshort(sc, 0x15, 0x015f);
13973         MP_WritePhyUshort(sc, 0x19, 0xd9b8);
13974         MP_WritePhyUshort(sc, 0x15, 0x0160);
13975         MP_WritePhyUshort(sc, 0x19, 0x0008);
13976         MP_WritePhyUshort(sc, 0x15, 0x0161);
13977         MP_WritePhyUshort(sc, 0x19, 0xdab1);
13978         MP_WritePhyUshort(sc, 0x15, 0x0162);
13979         MP_WritePhyUshort(sc, 0x19, 0x0015);
13980         MP_WritePhyUshort(sc, 0x15, 0x0163);
13981         MP_WritePhyUshort(sc, 0x19, 0xc244);
13982         MP_WritePhyUshort(sc, 0x15, 0x0164);
13983         MP_WritePhyUshort(sc, 0x19, 0x0013);
13984         MP_WritePhyUshort(sc, 0x15, 0x0165);
13985         MP_WritePhyUshort(sc, 0x19, 0xc021);
13986         MP_WritePhyUshort(sc, 0x15, 0x0166);
13987         MP_WritePhyUshort(sc, 0x19, 0x00f9);
13988         MP_WritePhyUshort(sc, 0x15, 0x0167);
13989         MP_WritePhyUshort(sc, 0x19, 0x3177);
13990         MP_WritePhyUshort(sc, 0x15, 0x0168);
13991         MP_WritePhyUshort(sc, 0x19, 0x5cf7);
13992         MP_WritePhyUshort(sc, 0x15, 0x0169);
13993         MP_WritePhyUshort(sc, 0x19, 0x4010);
13994         MP_WritePhyUshort(sc, 0x15, 0x016a);
13995         MP_WritePhyUshort(sc, 0x19, 0x4428);
13996         MP_WritePhyUshort(sc, 0x15, 0x016b);
13997         MP_WritePhyUshort(sc, 0x19, 0x9c00);
13998         MP_WritePhyUshort(sc, 0x15, 0x016c);
13999         MP_WritePhyUshort(sc, 0x19, 0x7c08);
14000         MP_WritePhyUshort(sc, 0x15, 0x016d);
14001         MP_WritePhyUshort(sc, 0x19, 0x6008);
14002         MP_WritePhyUshort(sc, 0x15, 0x016e);
14003         MP_WritePhyUshort(sc, 0x19, 0x7c08);
14004         MP_WritePhyUshort(sc, 0x15, 0x016f);
14005         MP_WritePhyUshort(sc, 0x19, 0x74f0);
14006         MP_WritePhyUshort(sc, 0x15, 0x0170);
14007         MP_WritePhyUshort(sc, 0x19, 0x6461);
14008         MP_WritePhyUshort(sc, 0x15, 0x0171);
14009         MP_WritePhyUshort(sc, 0x19, 0x6421);
14010         MP_WritePhyUshort(sc, 0x15, 0x0172);
14011         MP_WritePhyUshort(sc, 0x19, 0x64a1);
14012         MP_WritePhyUshort(sc, 0x15, 0x0173);
14013         MP_WritePhyUshort(sc, 0x19, 0x3116);
14014         MP_WritePhyUshort(sc, 0x15, 0x0174);
14015         MP_WritePhyUshort(sc, 0x19, 0x0000);
14016         MP_WritePhyUshort(sc, 0x15, 0x0175);
14017         MP_WritePhyUshort(sc, 0x19, 0x0000);
14018         MP_WritePhyUshort(sc, 0x15, 0x0176);
14019         MP_WritePhyUshort(sc, 0x19, 0x0000);
14020         MP_WritePhyUshort(sc, 0x15, 0x0177);
14021         MP_WritePhyUshort(sc, 0x19, 0x4805);
14022         MP_WritePhyUshort(sc, 0x15, 0x0178);
14023         MP_WritePhyUshort(sc, 0x19, 0xa103);
14024         MP_WritePhyUshort(sc, 0x15, 0x0179);
14025         MP_WritePhyUshort(sc, 0x19, 0x7c02);
14026         MP_WritePhyUshort(sc, 0x15, 0x017a);
14027         MP_WritePhyUshort(sc, 0x19, 0x6002);
14028         MP_WritePhyUshort(sc, 0x15, 0x017b);
14029         MP_WritePhyUshort(sc, 0x19, 0x7e00);
14030         MP_WritePhyUshort(sc, 0x15, 0x017c);
14031         MP_WritePhyUshort(sc, 0x19, 0x5400);
14032         MP_WritePhyUshort(sc, 0x15, 0x017d);
14033         MP_WritePhyUshort(sc, 0x19, 0x7c6b);
14034         MP_WritePhyUshort(sc, 0x15, 0x017e);
14035         MP_WritePhyUshort(sc, 0x19, 0x5c63);
14036         MP_WritePhyUshort(sc, 0x15, 0x017f);
14037         MP_WritePhyUshort(sc, 0x19, 0x407d);
14038         MP_WritePhyUshort(sc, 0x15, 0x0180);
14039         MP_WritePhyUshort(sc, 0x19, 0xa602);
14040         MP_WritePhyUshort(sc, 0x15, 0x0181);
14041         MP_WritePhyUshort(sc, 0x19, 0x4001);
14042         MP_WritePhyUshort(sc, 0x15, 0x0182);
14043         MP_WritePhyUshort(sc, 0x19, 0x4420);
14044         MP_WritePhyUshort(sc, 0x15, 0x0183);
14045         MP_WritePhyUshort(sc, 0x19, 0x4020);
14046         MP_WritePhyUshort(sc, 0x15, 0x0184);
14047         MP_WritePhyUshort(sc, 0x19, 0x44a1);
14048         MP_WritePhyUshort(sc, 0x15, 0x0185);
14049         MP_WritePhyUshort(sc, 0x19, 0xd6e0);
14050         MP_WritePhyUshort(sc, 0x15, 0x0186);
14051         MP_WritePhyUshort(sc, 0x19, 0x0009);
14052         MP_WritePhyUshort(sc, 0x15, 0x0187);
14053         MP_WritePhyUshort(sc, 0x19, 0x9efe);
14054         MP_WritePhyUshort(sc, 0x15, 0x0188);
14055         MP_WritePhyUshort(sc, 0x19, 0x7c02);
14056         MP_WritePhyUshort(sc, 0x15, 0x0189);
14057         MP_WritePhyUshort(sc, 0x19, 0x6000);
14058         MP_WritePhyUshort(sc, 0x15, 0x018a);
14059         MP_WritePhyUshort(sc, 0x19, 0x9c00);
14060         MP_WritePhyUshort(sc, 0x15, 0x018b);
14061         MP_WritePhyUshort(sc, 0x19, 0x318f);
14062         MP_WritePhyUshort(sc, 0x15, 0x018c);
14063         MP_WritePhyUshort(sc, 0x19, 0x0000);
14064         MP_WritePhyUshort(sc, 0x15, 0x018d);
14065         MP_WritePhyUshort(sc, 0x19, 0x0000);
14066         MP_WritePhyUshort(sc, 0x15, 0x018e);
14067         MP_WritePhyUshort(sc, 0x19, 0x0000);
14068         MP_WritePhyUshort(sc, 0x15, 0x018f);
14069         MP_WritePhyUshort(sc, 0x19, 0x4806);
14070         MP_WritePhyUshort(sc, 0x15, 0x0190);
14071         MP_WritePhyUshort(sc, 0x19, 0x7c10);
14072         MP_WritePhyUshort(sc, 0x15, 0x0191);
14073         MP_WritePhyUshort(sc, 0x19, 0x5c10);
14074         MP_WritePhyUshort(sc, 0x15, 0x0192);
14075         MP_WritePhyUshort(sc, 0x19, 0x40fa);
14076         MP_WritePhyUshort(sc, 0x15, 0x0193);
14077         MP_WritePhyUshort(sc, 0x19, 0xa602);
14078         MP_WritePhyUshort(sc, 0x15, 0x0194);
14079         MP_WritePhyUshort(sc, 0x19, 0x4010);
14080         MP_WritePhyUshort(sc, 0x15, 0x0195);
14081         MP_WritePhyUshort(sc, 0x19, 0x4440);
14082         MP_WritePhyUshort(sc, 0x15, 0x0196);
14083         MP_WritePhyUshort(sc, 0x19, 0x9d00);
14084         MP_WritePhyUshort(sc, 0x15, 0x0197);
14085         MP_WritePhyUshort(sc, 0x19, 0x7c80);
14086         MP_WritePhyUshort(sc, 0x15, 0x0198);
14087         MP_WritePhyUshort(sc, 0x19, 0x6400);
14088         MP_WritePhyUshort(sc, 0x15, 0x0199);
14089         MP_WritePhyUshort(sc, 0x19, 0x4003);
14090         MP_WritePhyUshort(sc, 0x15, 0x019a);
14091         MP_WritePhyUshort(sc, 0x19, 0x4540);
14092         MP_WritePhyUshort(sc, 0x15, 0x019b);
14093         MP_WritePhyUshort(sc, 0x19, 0x7c08);
14094         MP_WritePhyUshort(sc, 0x15, 0x019c);
14095         MP_WritePhyUshort(sc, 0x19, 0x6008);
14096         MP_WritePhyUshort(sc, 0x15, 0x019d);
14097         MP_WritePhyUshort(sc, 0x19, 0x9f00);
14098         MP_WritePhyUshort(sc, 0x15, 0x019e);
14099         MP_WritePhyUshort(sc, 0x19, 0x7c40);
14100         MP_WritePhyUshort(sc, 0x15, 0x019f);
14101         MP_WritePhyUshort(sc, 0x19, 0x6400);
14102         MP_WritePhyUshort(sc, 0x15, 0x01a0);
14103         MP_WritePhyUshort(sc, 0x19, 0x7c80);
14104         MP_WritePhyUshort(sc, 0x15, 0x01a1);
14105         MP_WritePhyUshort(sc, 0x19, 0x6480);
14106         MP_WritePhyUshort(sc, 0x15, 0x01a2);
14107         MP_WritePhyUshort(sc, 0x19, 0x3140);
14108         MP_WritePhyUshort(sc, 0x15, 0x01a3);
14109         MP_WritePhyUshort(sc, 0x19, 0x0000);
14110         MP_WritePhyUshort(sc, 0x15, 0x01a4);
14111         MP_WritePhyUshort(sc, 0x19, 0x0000);
14112         MP_WritePhyUshort(sc, 0x15, 0x01a5);
14113         MP_WritePhyUshort(sc, 0x19, 0x0000);
14114         MP_WritePhyUshort(sc, 0x15, 0x01a6);
14115         MP_WritePhyUshort(sc, 0x19, 0x4400);
14116         MP_WritePhyUshort(sc, 0x15, 0x01a7);
14117         MP_WritePhyUshort(sc, 0x19, 0x7c0b);
14118         MP_WritePhyUshort(sc, 0x15, 0x01a8);
14119         MP_WritePhyUshort(sc, 0x19, 0x6c01);
14120         MP_WritePhyUshort(sc, 0x15, 0x01a9);
14121         MP_WritePhyUshort(sc, 0x19, 0x64a8);
14122         MP_WritePhyUshort(sc, 0x15, 0x01aa);
14123         MP_WritePhyUshort(sc, 0x19, 0x6800);
14124         MP_WritePhyUshort(sc, 0x15, 0x01ab);
14125         MP_WritePhyUshort(sc, 0x19, 0x5cf0);
14126         MP_WritePhyUshort(sc, 0x15, 0x01ac);
14127         MP_WritePhyUshort(sc, 0x19, 0x588f);
14128         MP_WritePhyUshort(sc, 0x15, 0x01ad);
14129         MP_WritePhyUshort(sc, 0x19, 0xb628);
14130         MP_WritePhyUshort(sc, 0x15, 0x01ae);
14131         MP_WritePhyUshort(sc, 0x19, 0xc053);
14132         MP_WritePhyUshort(sc, 0x15, 0x01af);
14133         MP_WritePhyUshort(sc, 0x19, 0x0026);
14134         MP_WritePhyUshort(sc, 0x15, 0x01b0);
14135         MP_WritePhyUshort(sc, 0x19, 0xc02d);
14136         MP_WritePhyUshort(sc, 0x15, 0x01b1);
14137         MP_WritePhyUshort(sc, 0x19, 0x0024);
14138         MP_WritePhyUshort(sc, 0x15, 0x01b2);
14139         MP_WritePhyUshort(sc, 0x19, 0xc603);
14140         MP_WritePhyUshort(sc, 0x15, 0x01b3);
14141         MP_WritePhyUshort(sc, 0x19, 0x0022);
14142         MP_WritePhyUshort(sc, 0x15, 0x01b4);
14143         MP_WritePhyUshort(sc, 0x19, 0x8cf9);
14144         MP_WritePhyUshort(sc, 0x15, 0x01b5);
14145         MP_WritePhyUshort(sc, 0x19, 0x31ba);
14146         MP_WritePhyUshort(sc, 0x15, 0x01b6);
14147         MP_WritePhyUshort(sc, 0x19, 0x0000);
14148         MP_WritePhyUshort(sc, 0x15, 0x01b7);
14149         MP_WritePhyUshort(sc, 0x19, 0x0000);
14150         MP_WritePhyUshort(sc, 0x15, 0x01b8);
14151         MP_WritePhyUshort(sc, 0x19, 0x0000);
14152         MP_WritePhyUshort(sc, 0x15, 0x01b9);
14153         MP_WritePhyUshort(sc, 0x19, 0x0000);
14154         MP_WritePhyUshort(sc, 0x15, 0x01ba);
14155         MP_WritePhyUshort(sc, 0x19, 0x4400);
14156         MP_WritePhyUshort(sc, 0x15, 0x01bb);
14157         MP_WritePhyUshort(sc, 0x19, 0x5420);
14158         MP_WritePhyUshort(sc, 0x15, 0x01bc);
14159         MP_WritePhyUshort(sc, 0x19, 0x4811);
14160         MP_WritePhyUshort(sc, 0x15, 0x01bd);
14161         MP_WritePhyUshort(sc, 0x19, 0x5000);
14162         MP_WritePhyUshort(sc, 0x15, 0x01be);
14163         MP_WritePhyUshort(sc, 0x19, 0x4801);
14164         MP_WritePhyUshort(sc, 0x15, 0x01bf);
14165         MP_WritePhyUshort(sc, 0x19, 0x6800);
14166         MP_WritePhyUshort(sc, 0x15, 0x01c0);
14167         MP_WritePhyUshort(sc, 0x19, 0x31f5);
14168         MP_WritePhyUshort(sc, 0x15, 0x01c1);
14169         MP_WritePhyUshort(sc, 0x19, 0xb614);
14170         MP_WritePhyUshort(sc, 0x15, 0x01c2);
14171         MP_WritePhyUshort(sc, 0x19, 0x8ce4);
14172         MP_WritePhyUshort(sc, 0x15, 0x01c3);
14173         MP_WritePhyUshort(sc, 0x19, 0xb30c);
14174         MP_WritePhyUshort(sc, 0x15, 0x01c4);
14175         MP_WritePhyUshort(sc, 0x19, 0x7c03);
14176         MP_WritePhyUshort(sc, 0x15, 0x01c5);
14177         MP_WritePhyUshort(sc, 0x19, 0x6c02);
14178         MP_WritePhyUshort(sc, 0x15, 0x01c6);
14179         MP_WritePhyUshort(sc, 0x19, 0x8206);
14180         MP_WritePhyUshort(sc, 0x15, 0x01c7);
14181         MP_WritePhyUshort(sc, 0x19, 0x7c03);
14182         MP_WritePhyUshort(sc, 0x15, 0x01c8);
14183         MP_WritePhyUshort(sc, 0x19, 0x6c00);
14184         MP_WritePhyUshort(sc, 0x15, 0x01c9);
14185         MP_WritePhyUshort(sc, 0x19, 0x7c04);
14186         MP_WritePhyUshort(sc, 0x15, 0x01ca);
14187         MP_WritePhyUshort(sc, 0x19, 0x7404);
14188         MP_WritePhyUshort(sc, 0x15, 0x01cb);
14189         MP_WritePhyUshort(sc, 0x19, 0x31c0);
14190         MP_WritePhyUshort(sc, 0x15, 0x01cc);
14191         MP_WritePhyUshort(sc, 0x19, 0x7c04);
14192         MP_WritePhyUshort(sc, 0x15, 0x01cd);
14193         MP_WritePhyUshort(sc, 0x19, 0x7400);
14194         MP_WritePhyUshort(sc, 0x15, 0x01ce);
14195         MP_WritePhyUshort(sc, 0x19, 0x31c0);
14196         MP_WritePhyUshort(sc, 0x15, 0x01cf);
14197         MP_WritePhyUshort(sc, 0x19, 0x8df1);
14198         MP_WritePhyUshort(sc, 0x15, 0x01d0);
14199         MP_WritePhyUshort(sc, 0x19, 0x3248);
14200         MP_WritePhyUshort(sc, 0x15, 0x01d1);
14201         MP_WritePhyUshort(sc, 0x19, 0x0000);
14202         MP_WritePhyUshort(sc, 0x15, 0x01d2);
14203         MP_WritePhyUshort(sc, 0x19, 0x0000);
14204         MP_WritePhyUshort(sc, 0x15, 0x01d3);
14205         MP_WritePhyUshort(sc, 0x19, 0x0000);
14206         MP_WritePhyUshort(sc, 0x15, 0x01d4);
14207         MP_WritePhyUshort(sc, 0x19, 0x0000);
14208         MP_WritePhyUshort(sc, 0x15, 0x01d5);
14209         MP_WritePhyUshort(sc, 0x19, 0x4400);
14210         MP_WritePhyUshort(sc, 0x15, 0x01d6);
14211         MP_WritePhyUshort(sc, 0x19, 0x7c03);
14212         MP_WritePhyUshort(sc, 0x15, 0x01d7);
14213         MP_WritePhyUshort(sc, 0x19, 0x6c03);
14214         MP_WritePhyUshort(sc, 0x15, 0x01d8);
14215         MP_WritePhyUshort(sc, 0x19, 0x7670);
14216         MP_WritePhyUshort(sc, 0x15, 0x01d9);
14217         MP_WritePhyUshort(sc, 0x19, 0x4023);
14218         MP_WritePhyUshort(sc, 0x15, 0x01da);
14219         MP_WritePhyUshort(sc, 0x19, 0x4500);
14220         MP_WritePhyUshort(sc, 0x15, 0x01db);
14221         MP_WritePhyUshort(sc, 0x19, 0x4069);
14222         MP_WritePhyUshort(sc, 0x15, 0x01dc);
14223         MP_WritePhyUshort(sc, 0x19, 0x4580);
14224         MP_WritePhyUshort(sc, 0x15, 0x01dd);
14225         MP_WritePhyUshort(sc, 0x19, 0x9f00);
14226         MP_WritePhyUshort(sc, 0x15, 0x01de);
14227         MP_WritePhyUshort(sc, 0x19, 0xcff5);
14228         MP_WritePhyUshort(sc, 0x15, 0x01df);
14229         MP_WritePhyUshort(sc, 0x19, 0x00ff);
14230         MP_WritePhyUshort(sc, 0x15, 0x01e0);
14231         MP_WritePhyUshort(sc, 0x19, 0x76f0);
14232         MP_WritePhyUshort(sc, 0x15, 0x01e1);
14233         MP_WritePhyUshort(sc, 0x19, 0x4400);
14234         MP_WritePhyUshort(sc, 0x15, 0x01e2);
14235         MP_WritePhyUshort(sc, 0x19, 0x4023);
14236         MP_WritePhyUshort(sc, 0x15, 0x01e3);
14237         MP_WritePhyUshort(sc, 0x19, 0x4500);
14238         MP_WritePhyUshort(sc, 0x15, 0x01e4);
14239         MP_WritePhyUshort(sc, 0x19, 0x4069);
14240         MP_WritePhyUshort(sc, 0x15, 0x01e5);
14241         MP_WritePhyUshort(sc, 0x19, 0x4580);
14242         MP_WritePhyUshort(sc, 0x15, 0x01e6);
14243         MP_WritePhyUshort(sc, 0x19, 0x9f00);
14244         MP_WritePhyUshort(sc, 0x15, 0x01e7);
14245         MP_WritePhyUshort(sc, 0x19, 0xd0f5);
14246         MP_WritePhyUshort(sc, 0x15, 0x01e8);
14247         MP_WritePhyUshort(sc, 0x19, 0x00ff);
14248         MP_WritePhyUshort(sc, 0x15, 0x01e9);
14249         MP_WritePhyUshort(sc, 0x19, 0x4400);
14250         MP_WritePhyUshort(sc, 0x15, 0x01ea);
14251         MP_WritePhyUshort(sc, 0x19, 0x7c03);
14252         MP_WritePhyUshort(sc, 0x15, 0x01eb);
14253         MP_WritePhyUshort(sc, 0x19, 0x6800);
14254         MP_WritePhyUshort(sc, 0x15, 0x01ec);
14255         MP_WritePhyUshort(sc, 0x19, 0x66a0);
14256         MP_WritePhyUshort(sc, 0x15, 0x01ed);
14257         MP_WritePhyUshort(sc, 0x19, 0x8300);
14258         MP_WritePhyUshort(sc, 0x15, 0x01ee);
14259         MP_WritePhyUshort(sc, 0x19, 0x74f0);
14260         MP_WritePhyUshort(sc, 0x15, 0x01ef);
14261         MP_WritePhyUshort(sc, 0x19, 0x3006);
14262         MP_WritePhyUshort(sc, 0x15, 0x01f0);
14263         MP_WritePhyUshort(sc, 0x19, 0x0000);
14264         MP_WritePhyUshort(sc, 0x15, 0x01f1);
14265         MP_WritePhyUshort(sc, 0x19, 0x0000);
14266         MP_WritePhyUshort(sc, 0x15, 0x01f2);
14267         MP_WritePhyUshort(sc, 0x19, 0x0000);
14268         MP_WritePhyUshort(sc, 0x15, 0x01f3);
14269         MP_WritePhyUshort(sc, 0x19, 0x0000);
14270         MP_WritePhyUshort(sc, 0x15, 0x01f4);
14271         MP_WritePhyUshort(sc, 0x19, 0x0000);
14272         MP_WritePhyUshort(sc, 0x15, 0x01f5);
14273         MP_WritePhyUshort(sc, 0x19, 0x7c03);
14274         MP_WritePhyUshort(sc, 0x15, 0x01f6);
14275         MP_WritePhyUshort(sc, 0x19, 0x6c02);
14276         MP_WritePhyUshort(sc, 0x15, 0x01f7);
14277         MP_WritePhyUshort(sc, 0x19, 0x409d);
14278         MP_WritePhyUshort(sc, 0x15, 0x01f8);
14279         MP_WritePhyUshort(sc, 0x19, 0x7c87);
14280         MP_WritePhyUshort(sc, 0x15, 0x01f9);
14281         MP_WritePhyUshort(sc, 0x19, 0xae14);
14282         MP_WritePhyUshort(sc, 0x15, 0x01fa);
14283         MP_WritePhyUshort(sc, 0x19, 0x4400);
14284         MP_WritePhyUshort(sc, 0x15, 0x01fb);
14285         MP_WritePhyUshort(sc, 0x19, 0x7c40);
14286         MP_WritePhyUshort(sc, 0x15, 0x01fc);
14287         MP_WritePhyUshort(sc, 0x19, 0x6800);
14288         MP_WritePhyUshort(sc, 0x15, 0x01fd);
14289         MP_WritePhyUshort(sc, 0x19, 0x7801);
14290         MP_WritePhyUshort(sc, 0x15, 0x01fe);
14291         MP_WritePhyUshort(sc, 0x19, 0x980e);
14292         MP_WritePhyUshort(sc, 0x15, 0x01ff);
14293         MP_WritePhyUshort(sc, 0x19, 0x930c);
14294         MP_WritePhyUshort(sc, 0x15, 0x0200);
14295         MP_WritePhyUshort(sc, 0x19, 0x9206);
14296         MP_WritePhyUshort(sc, 0x15, 0x0201);
14297         MP_WritePhyUshort(sc, 0x19, 0x4002);
14298         MP_WritePhyUshort(sc, 0x15, 0x0202);
14299         MP_WritePhyUshort(sc, 0x19, 0x7800);
14300         MP_WritePhyUshort(sc, 0x15, 0x0203);
14301         MP_WritePhyUshort(sc, 0x19, 0x588f);
14302         MP_WritePhyUshort(sc, 0x15, 0x0204);
14303         MP_WritePhyUshort(sc, 0x19, 0x5520);
14304         MP_WritePhyUshort(sc, 0x15, 0x0205);
14305         MP_WritePhyUshort(sc, 0x19, 0x320c);
14306         MP_WritePhyUshort(sc, 0x15, 0x0206);
14307         MP_WritePhyUshort(sc, 0x19, 0x4000);
14308         MP_WritePhyUshort(sc, 0x15, 0x0207);
14309         MP_WritePhyUshort(sc, 0x19, 0x7800);
14310         MP_WritePhyUshort(sc, 0x15, 0x0208);
14311         MP_WritePhyUshort(sc, 0x19, 0x588d);
14312         MP_WritePhyUshort(sc, 0x15, 0x0209);
14313         MP_WritePhyUshort(sc, 0x19, 0x5500);
14314         MP_WritePhyUshort(sc, 0x15, 0x020a);
14315         MP_WritePhyUshort(sc, 0x19, 0x320c);
14316         MP_WritePhyUshort(sc, 0x15, 0x020b);
14317         MP_WritePhyUshort(sc, 0x19, 0x4002);
14318         MP_WritePhyUshort(sc, 0x15, 0x020c);
14319         MP_WritePhyUshort(sc, 0x19, 0x3220);
14320         MP_WritePhyUshort(sc, 0x15, 0x020d);
14321         MP_WritePhyUshort(sc, 0x19, 0x4480);
14322         MP_WritePhyUshort(sc, 0x15, 0x020e);
14323         MP_WritePhyUshort(sc, 0x19, 0x9e03);
14324         MP_WritePhyUshort(sc, 0x15, 0x020f);
14325         MP_WritePhyUshort(sc, 0x19, 0x7c40);
14326         MP_WritePhyUshort(sc, 0x15, 0x0210);
14327         MP_WritePhyUshort(sc, 0x19, 0x6840);
14328         MP_WritePhyUshort(sc, 0x15, 0x0211);
14329         MP_WritePhyUshort(sc, 0x19, 0x7801);
14330         MP_WritePhyUshort(sc, 0x15, 0x0212);
14331         MP_WritePhyUshort(sc, 0x19, 0x980e);
14332         MP_WritePhyUshort(sc, 0x15, 0x0213);
14333         MP_WritePhyUshort(sc, 0x19, 0x930c);
14334         MP_WritePhyUshort(sc, 0x15, 0x0214);
14335         MP_WritePhyUshort(sc, 0x19, 0x9206);
14336         MP_WritePhyUshort(sc, 0x15, 0x0215);
14337         MP_WritePhyUshort(sc, 0x19, 0x4000);
14338         MP_WritePhyUshort(sc, 0x15, 0x0216);
14339         MP_WritePhyUshort(sc, 0x19, 0x7800);
14340         MP_WritePhyUshort(sc, 0x15, 0x0217);
14341         MP_WritePhyUshort(sc, 0x19, 0x588f);
14342         MP_WritePhyUshort(sc, 0x15, 0x0218);
14343         MP_WritePhyUshort(sc, 0x19, 0x5520);
14344         MP_WritePhyUshort(sc, 0x15, 0x0219);
14345         MP_WritePhyUshort(sc, 0x19, 0x3220);
14346         MP_WritePhyUshort(sc, 0x15, 0x021a);
14347         MP_WritePhyUshort(sc, 0x19, 0x4002);
14348         MP_WritePhyUshort(sc, 0x15, 0x021b);
14349         MP_WritePhyUshort(sc, 0x19, 0x7800);
14350         MP_WritePhyUshort(sc, 0x15, 0x021c);
14351         MP_WritePhyUshort(sc, 0x19, 0x588d);
14352         MP_WritePhyUshort(sc, 0x15, 0x021d);
14353         MP_WritePhyUshort(sc, 0x19, 0x5540);
14354         MP_WritePhyUshort(sc, 0x15, 0x021e);
14355         MP_WritePhyUshort(sc, 0x19, 0x3220);
14356         MP_WritePhyUshort(sc, 0x15, 0x021f);
14357         MP_WritePhyUshort(sc, 0x19, 0x4000);
14358         MP_WritePhyUshort(sc, 0x15, 0x0220);
14359         MP_WritePhyUshort(sc, 0x19, 0x7800);
14360         MP_WritePhyUshort(sc, 0x15, 0x0221);
14361         MP_WritePhyUshort(sc, 0x19, 0x7c03);
14362         MP_WritePhyUshort(sc, 0x15, 0x0222);
14363         MP_WritePhyUshort(sc, 0x19, 0x6c00);
14364         MP_WritePhyUshort(sc, 0x15, 0x0223);
14365         MP_WritePhyUshort(sc, 0x19, 0x3231);
14366         MP_WritePhyUshort(sc, 0x15, 0x0224);
14367         MP_WritePhyUshort(sc, 0x19, 0xab06);
14368         MP_WritePhyUshort(sc, 0x15, 0x0225);
14369         MP_WritePhyUshort(sc, 0x19, 0xbf08);
14370         MP_WritePhyUshort(sc, 0x15, 0x0226);
14371         MP_WritePhyUshort(sc, 0x19, 0x4076);
14372         MP_WritePhyUshort(sc, 0x15, 0x0227);
14373         MP_WritePhyUshort(sc, 0x19, 0x7d07);
14374         MP_WritePhyUshort(sc, 0x15, 0x0228);
14375         MP_WritePhyUshort(sc, 0x19, 0x4502);
14376         MP_WritePhyUshort(sc, 0x15, 0x0229);
14377         MP_WritePhyUshort(sc, 0x19, 0x3231);
14378         MP_WritePhyUshort(sc, 0x15, 0x022a);
14379         MP_WritePhyUshort(sc, 0x19, 0x7d80);
14380         MP_WritePhyUshort(sc, 0x15, 0x022b);
14381         MP_WritePhyUshort(sc, 0x19, 0x5180);
14382         MP_WritePhyUshort(sc, 0x15, 0x022c);
14383         MP_WritePhyUshort(sc, 0x19, 0x322f);
14384         MP_WritePhyUshort(sc, 0x15, 0x022d);
14385         MP_WritePhyUshort(sc, 0x19, 0x7d80);
14386         MP_WritePhyUshort(sc, 0x15, 0x022e);
14387         MP_WritePhyUshort(sc, 0x19, 0x5000);
14388         MP_WritePhyUshort(sc, 0x15, 0x022f);
14389         MP_WritePhyUshort(sc, 0x19, 0x7d07);
14390         MP_WritePhyUshort(sc, 0x15, 0x0230);
14391         MP_WritePhyUshort(sc, 0x19, 0x4402);
14392         MP_WritePhyUshort(sc, 0x15, 0x0231);
14393         MP_WritePhyUshort(sc, 0x19, 0x7c03);
14394         MP_WritePhyUshort(sc, 0x15, 0x0232);
14395         MP_WritePhyUshort(sc, 0x19, 0x6c02);
14396         MP_WritePhyUshort(sc, 0x15, 0x0233);
14397         MP_WritePhyUshort(sc, 0x19, 0x7c03);
14398         MP_WritePhyUshort(sc, 0x15, 0x0234);
14399         MP_WritePhyUshort(sc, 0x19, 0xb309);
14400         MP_WritePhyUshort(sc, 0x15, 0x0235);
14401         MP_WritePhyUshort(sc, 0x19, 0xb204);
14402         MP_WritePhyUshort(sc, 0x15, 0x0236);
14403         MP_WritePhyUshort(sc, 0x19, 0xb105);
14404         MP_WritePhyUshort(sc, 0x15, 0x0237);
14405         MP_WritePhyUshort(sc, 0x19, 0x6c00);
14406         MP_WritePhyUshort(sc, 0x15, 0x0238);
14407         MP_WritePhyUshort(sc, 0x19, 0x31c1);
14408         MP_WritePhyUshort(sc, 0x15, 0x0239);
14409         MP_WritePhyUshort(sc, 0x19, 0x6c00);
14410         MP_WritePhyUshort(sc, 0x15, 0x023a);
14411         MP_WritePhyUshort(sc, 0x19, 0x3261);
14412         MP_WritePhyUshort(sc, 0x15, 0x023b);
14413         MP_WritePhyUshort(sc, 0x19, 0x6c00);
14414         MP_WritePhyUshort(sc, 0x15, 0x023c);
14415         MP_WritePhyUshort(sc, 0x19, 0x3250);
14416         MP_WritePhyUshort(sc, 0x15, 0x023d);
14417         MP_WritePhyUshort(sc, 0x19, 0xb203);
14418         MP_WritePhyUshort(sc, 0x15, 0x023e);
14419         MP_WritePhyUshort(sc, 0x19, 0x6c00);
14420         MP_WritePhyUshort(sc, 0x15, 0x023f);
14421         MP_WritePhyUshort(sc, 0x19, 0x327a);
14422         MP_WritePhyUshort(sc, 0x15, 0x0240);
14423         MP_WritePhyUshort(sc, 0x19, 0x6c00);
14424         MP_WritePhyUshort(sc, 0x15, 0x0241);
14425         MP_WritePhyUshort(sc, 0x19, 0x3293);
14426         MP_WritePhyUshort(sc, 0x15, 0x0242);
14427         MP_WritePhyUshort(sc, 0x19, 0x0000);
14428         MP_WritePhyUshort(sc, 0x15, 0x0243);
14429         MP_WritePhyUshort(sc, 0x19, 0x0000);
14430         MP_WritePhyUshort(sc, 0x15, 0x0244);
14431         MP_WritePhyUshort(sc, 0x19, 0x0000);
14432         MP_WritePhyUshort(sc, 0x15, 0x0245);
14433         MP_WritePhyUshort(sc, 0x19, 0x0000);
14434         MP_WritePhyUshort(sc, 0x15, 0x0246);
14435         MP_WritePhyUshort(sc, 0x19, 0x0000);
14436         MP_WritePhyUshort(sc, 0x15, 0x0247);
14437         MP_WritePhyUshort(sc, 0x19, 0x32a3);
14438         MP_WritePhyUshort(sc, 0x15, 0x0248);
14439         MP_WritePhyUshort(sc, 0x19, 0x5520);
14440         MP_WritePhyUshort(sc, 0x15, 0x0249);
14441         MP_WritePhyUshort(sc, 0x19, 0x403d);
14442         MP_WritePhyUshort(sc, 0x15, 0x024a);
14443         MP_WritePhyUshort(sc, 0x19, 0x440c);
14444         MP_WritePhyUshort(sc, 0x15, 0x024b);
14445         MP_WritePhyUshort(sc, 0x19, 0x4812);
14446         MP_WritePhyUshort(sc, 0x15, 0x024c);
14447         MP_WritePhyUshort(sc, 0x19, 0x5001);
14448         MP_WritePhyUshort(sc, 0x15, 0x024d);
14449         MP_WritePhyUshort(sc, 0x19, 0x4802);
14450         MP_WritePhyUshort(sc, 0x15, 0x024e);
14451         MP_WritePhyUshort(sc, 0x19, 0x6880);
14452         MP_WritePhyUshort(sc, 0x15, 0x024f);
14453         MP_WritePhyUshort(sc, 0x19, 0x31f5);
14454         MP_WritePhyUshort(sc, 0x15, 0x0250);
14455         MP_WritePhyUshort(sc, 0x19, 0xb685);
14456         MP_WritePhyUshort(sc, 0x15, 0x0251);
14457         MP_WritePhyUshort(sc, 0x19, 0x801c);
14458         MP_WritePhyUshort(sc, 0x15, 0x0252);
14459         MP_WritePhyUshort(sc, 0x19, 0xbaf5);
14460         MP_WritePhyUshort(sc, 0x15, 0x0253);
14461         MP_WritePhyUshort(sc, 0x19, 0xc07c);
14462         MP_WritePhyUshort(sc, 0x15, 0x0254);
14463         MP_WritePhyUshort(sc, 0x19, 0x00fb);
14464         MP_WritePhyUshort(sc, 0x15, 0x0255);
14465         MP_WritePhyUshort(sc, 0x19, 0x325a);
14466         MP_WritePhyUshort(sc, 0x15, 0x0256);
14467         MP_WritePhyUshort(sc, 0x19, 0x0000);
14468         MP_WritePhyUshort(sc, 0x15, 0x0257);
14469         MP_WritePhyUshort(sc, 0x19, 0x0000);
14470         MP_WritePhyUshort(sc, 0x15, 0x0258);
14471         MP_WritePhyUshort(sc, 0x19, 0x0000);
14472         MP_WritePhyUshort(sc, 0x15, 0x0259);
14473         MP_WritePhyUshort(sc, 0x19, 0x0000);
14474         MP_WritePhyUshort(sc, 0x15, 0x025a);
14475         MP_WritePhyUshort(sc, 0x19, 0x481a);
14476         MP_WritePhyUshort(sc, 0x15, 0x025b);
14477         MP_WritePhyUshort(sc, 0x19, 0x5001);
14478         MP_WritePhyUshort(sc, 0x15, 0x025c);
14479         MP_WritePhyUshort(sc, 0x19, 0x401b);
14480         MP_WritePhyUshort(sc, 0x15, 0x025d);
14481         MP_WritePhyUshort(sc, 0x19, 0x480a);
14482         MP_WritePhyUshort(sc, 0x15, 0x025e);
14483         MP_WritePhyUshort(sc, 0x19, 0x4418);
14484         MP_WritePhyUshort(sc, 0x15, 0x025f);
14485         MP_WritePhyUshort(sc, 0x19, 0x6900);
14486         MP_WritePhyUshort(sc, 0x15, 0x0260);
14487         MP_WritePhyUshort(sc, 0x19, 0x31f5);
14488         MP_WritePhyUshort(sc, 0x15, 0x0261);
14489         MP_WritePhyUshort(sc, 0x19, 0xb64b);
14490         MP_WritePhyUshort(sc, 0x15, 0x0262);
14491         MP_WritePhyUshort(sc, 0x19, 0xdb00);
14492         MP_WritePhyUshort(sc, 0x15, 0x0263);
14493         MP_WritePhyUshort(sc, 0x19, 0x0048);
14494         MP_WritePhyUshort(sc, 0x15, 0x0264);
14495         MP_WritePhyUshort(sc, 0x19, 0xdb7d);
14496         MP_WritePhyUshort(sc, 0x15, 0x0265);
14497         MP_WritePhyUshort(sc, 0x19, 0x0002);
14498         MP_WritePhyUshort(sc, 0x15, 0x0266);
14499         MP_WritePhyUshort(sc, 0x19, 0xa0fa);
14500         MP_WritePhyUshort(sc, 0x15, 0x0267);
14501         MP_WritePhyUshort(sc, 0x19, 0x4408);
14502         MP_WritePhyUshort(sc, 0x15, 0x0268);
14503         MP_WritePhyUshort(sc, 0x19, 0x3248);
14504         MP_WritePhyUshort(sc, 0x15, 0x0269);
14505         MP_WritePhyUshort(sc, 0x19, 0x0000);
14506         MP_WritePhyUshort(sc, 0x15, 0x026a);
14507         MP_WritePhyUshort(sc, 0x19, 0x0000);
14508         MP_WritePhyUshort(sc, 0x15, 0x026b);
14509         MP_WritePhyUshort(sc, 0x19, 0x0000);
14510         MP_WritePhyUshort(sc, 0x15, 0x026c);
14511         MP_WritePhyUshort(sc, 0x19, 0x0000);
14512         MP_WritePhyUshort(sc, 0x15, 0x026d);
14513         MP_WritePhyUshort(sc, 0x19, 0xb806);
14514         MP_WritePhyUshort(sc, 0x15, 0x026e);
14515         MP_WritePhyUshort(sc, 0x19, 0x588d);
14516         MP_WritePhyUshort(sc, 0x15, 0x026f);
14517         MP_WritePhyUshort(sc, 0x19, 0x5500);
14518         MP_WritePhyUshort(sc, 0x15, 0x0270);
14519         MP_WritePhyUshort(sc, 0x19, 0x7801);
14520         MP_WritePhyUshort(sc, 0x15, 0x0271);
14521         MP_WritePhyUshort(sc, 0x19, 0x4002);
14522         MP_WritePhyUshort(sc, 0x15, 0x0272);
14523         MP_WritePhyUshort(sc, 0x19, 0x7800);
14524         MP_WritePhyUshort(sc, 0x15, 0x0273);
14525         MP_WritePhyUshort(sc, 0x19, 0x4814);
14526         MP_WritePhyUshort(sc, 0x15, 0x0274);
14527         MP_WritePhyUshort(sc, 0x19, 0x500b);
14528         MP_WritePhyUshort(sc, 0x15, 0x0275);
14529         MP_WritePhyUshort(sc, 0x19, 0x4804);
14530         MP_WritePhyUshort(sc, 0x15, 0x0276);
14531         MP_WritePhyUshort(sc, 0x19, 0x40c4);
14532         MP_WritePhyUshort(sc, 0x15, 0x0277);
14533         MP_WritePhyUshort(sc, 0x19, 0x4425);
14534         MP_WritePhyUshort(sc, 0x15, 0x0278);
14535         MP_WritePhyUshort(sc, 0x19, 0x6a00);
14536         MP_WritePhyUshort(sc, 0x15, 0x0279);
14537         MP_WritePhyUshort(sc, 0x19, 0x31f5);
14538         MP_WritePhyUshort(sc, 0x15, 0x027a);
14539         MP_WritePhyUshort(sc, 0x19, 0xb632);
14540         MP_WritePhyUshort(sc, 0x15, 0x027b);
14541         MP_WritePhyUshort(sc, 0x19, 0xdc03);
14542         MP_WritePhyUshort(sc, 0x15, 0x027c);
14543         MP_WritePhyUshort(sc, 0x19, 0x0027);
14544         MP_WritePhyUshort(sc, 0x15, 0x027d);
14545         MP_WritePhyUshort(sc, 0x19, 0x80fc);
14546         MP_WritePhyUshort(sc, 0x15, 0x027e);
14547         MP_WritePhyUshort(sc, 0x19, 0x3283);
14548         MP_WritePhyUshort(sc, 0x15, 0x027f);
14549         MP_WritePhyUshort(sc, 0x19, 0x0000);
14550         MP_WritePhyUshort(sc, 0x15, 0x0280);
14551         MP_WritePhyUshort(sc, 0x19, 0x0000);
14552         MP_WritePhyUshort(sc, 0x15, 0x0281);
14553         MP_WritePhyUshort(sc, 0x19, 0x0000);
14554         MP_WritePhyUshort(sc, 0x15, 0x0282);
14555         MP_WritePhyUshort(sc, 0x19, 0x0000);
14556         MP_WritePhyUshort(sc, 0x15, 0x0283);
14557         MP_WritePhyUshort(sc, 0x19, 0xb806);
14558         MP_WritePhyUshort(sc, 0x15, 0x0284);
14559         MP_WritePhyUshort(sc, 0x19, 0x588f);
14560         MP_WritePhyUshort(sc, 0x15, 0x0285);
14561         MP_WritePhyUshort(sc, 0x19, 0x5520);
14562         MP_WritePhyUshort(sc, 0x15, 0x0286);
14563         MP_WritePhyUshort(sc, 0x19, 0x7801);
14564         MP_WritePhyUshort(sc, 0x15, 0x0287);
14565         MP_WritePhyUshort(sc, 0x19, 0x4000);
14566         MP_WritePhyUshort(sc, 0x15, 0x0288);
14567         MP_WritePhyUshort(sc, 0x19, 0x7800);
14568         MP_WritePhyUshort(sc, 0x15, 0x0289);
14569         MP_WritePhyUshort(sc, 0x19, 0x4818);
14570         MP_WritePhyUshort(sc, 0x15, 0x028a);
14571         MP_WritePhyUshort(sc, 0x19, 0x5051);
14572         MP_WritePhyUshort(sc, 0x15, 0x028b);
14573         MP_WritePhyUshort(sc, 0x19, 0x4808);
14574         MP_WritePhyUshort(sc, 0x15, 0x028c);
14575         MP_WritePhyUshort(sc, 0x19, 0x4050);
14576         MP_WritePhyUshort(sc, 0x15, 0x028d);
14577         MP_WritePhyUshort(sc, 0x19, 0x4462);
14578         MP_WritePhyUshort(sc, 0x15, 0x028e);
14579         MP_WritePhyUshort(sc, 0x19, 0x40c4);
14580         MP_WritePhyUshort(sc, 0x15, 0x028f);
14581         MP_WritePhyUshort(sc, 0x19, 0x4473);
14582         MP_WritePhyUshort(sc, 0x15, 0x0290);
14583         MP_WritePhyUshort(sc, 0x19, 0x5041);
14584         MP_WritePhyUshort(sc, 0x15, 0x0291);
14585         MP_WritePhyUshort(sc, 0x19, 0x6b00);
14586         MP_WritePhyUshort(sc, 0x15, 0x0292);
14587         MP_WritePhyUshort(sc, 0x19, 0x31f5);
14588         MP_WritePhyUshort(sc, 0x15, 0x0293);
14589         MP_WritePhyUshort(sc, 0x19, 0xb619);
14590         MP_WritePhyUshort(sc, 0x15, 0x0294);
14591         MP_WritePhyUshort(sc, 0x19, 0x80d9);
14592         MP_WritePhyUshort(sc, 0x15, 0x0295);
14593         MP_WritePhyUshort(sc, 0x19, 0xbd06);
14594         MP_WritePhyUshort(sc, 0x15, 0x0296);
14595         MP_WritePhyUshort(sc, 0x19, 0xbb0d);
14596         MP_WritePhyUshort(sc, 0x15, 0x0297);
14597         MP_WritePhyUshort(sc, 0x19, 0xaf14);
14598         MP_WritePhyUshort(sc, 0x15, 0x0298);
14599         MP_WritePhyUshort(sc, 0x19, 0x8efa);
14600         MP_WritePhyUshort(sc, 0x15, 0x0299);
14601         MP_WritePhyUshort(sc, 0x19, 0x5049);
14602         MP_WritePhyUshort(sc, 0x15, 0x029a);
14603         MP_WritePhyUshort(sc, 0x19, 0x3248);
14604         MP_WritePhyUshort(sc, 0x15, 0x029b);
14605         MP_WritePhyUshort(sc, 0x19, 0x4c10);
14606         MP_WritePhyUshort(sc, 0x15, 0x029c);
14607         MP_WritePhyUshort(sc, 0x19, 0x44b0);
14608         MP_WritePhyUshort(sc, 0x15, 0x029d);
14609         MP_WritePhyUshort(sc, 0x19, 0x4c00);
14610         MP_WritePhyUshort(sc, 0x15, 0x029e);
14611         MP_WritePhyUshort(sc, 0x19, 0x3292);
14612         MP_WritePhyUshort(sc, 0x15, 0x029f);
14613         MP_WritePhyUshort(sc, 0x19, 0x0000);
14614         MP_WritePhyUshort(sc, 0x15, 0x02a0);
14615         MP_WritePhyUshort(sc, 0x19, 0x0000);
14616         MP_WritePhyUshort(sc, 0x15, 0x02a1);
14617         MP_WritePhyUshort(sc, 0x19, 0x0000);
14618         MP_WritePhyUshort(sc, 0x15, 0x02a2);
14619         MP_WritePhyUshort(sc, 0x19, 0x0000);
14620         MP_WritePhyUshort(sc, 0x15, 0x02a3);
14621         MP_WritePhyUshort(sc, 0x19, 0x481f);
14622         MP_WritePhyUshort(sc, 0x15, 0x02a4);
14623         MP_WritePhyUshort(sc, 0x19, 0x5005);
14624         MP_WritePhyUshort(sc, 0x15, 0x02a5);
14625         MP_WritePhyUshort(sc, 0x19, 0x480f);
14626         MP_WritePhyUshort(sc, 0x15, 0x02a6);
14627         MP_WritePhyUshort(sc, 0x19, 0xac00);
14628         MP_WritePhyUshort(sc, 0x15, 0x02a7);
14629         MP_WritePhyUshort(sc, 0x19, 0x31a6);
14630         MP_WritePhyUshort(sc, 0x15, 0x02a8);
14631         MP_WritePhyUshort(sc, 0x19, 0x0000);
14632         MP_WritePhyUshort(sc, 0x15, 0x02a9);
14633         MP_WritePhyUshort(sc, 0x19, 0x0000);
14634         MP_WritePhyUshort(sc, 0x15, 0x02aa);
14635         MP_WritePhyUshort(sc, 0x19, 0x0000);
14636         MP_WritePhyUshort(sc, 0x15, 0x02ab);
14637         MP_WritePhyUshort(sc, 0x19, 0x31ba);
14638         MP_WritePhyUshort(sc, 0x15, 0x02ac);
14639         MP_WritePhyUshort(sc, 0x19, 0x31d5);
14640         MP_WritePhyUshort(sc, 0x15, 0x02ad);
14641         MP_WritePhyUshort(sc, 0x19, 0x0000);
14642         MP_WritePhyUshort(sc, 0x15, 0x02ae);
14643         MP_WritePhyUshort(sc, 0x19, 0x5cf0);
14644         MP_WritePhyUshort(sc, 0x15, 0x02af);
14645         MP_WritePhyUshort(sc, 0x19, 0x588c);
14646         MP_WritePhyUshort(sc, 0x15, 0x02b0);
14647         MP_WritePhyUshort(sc, 0x19, 0x542f);
14648         MP_WritePhyUshort(sc, 0x15, 0x02b1);
14649         MP_WritePhyUshort(sc, 0x19, 0x7ffb);
14650         MP_WritePhyUshort(sc, 0x15, 0x02b2);
14651         MP_WritePhyUshort(sc, 0x19, 0x6ff8);
14652         MP_WritePhyUshort(sc, 0x15, 0x02b3);
14653         MP_WritePhyUshort(sc, 0x19, 0x64a4);
14654         MP_WritePhyUshort(sc, 0x15, 0x02b4);
14655         MP_WritePhyUshort(sc, 0x19, 0x64a0);
14656         MP_WritePhyUshort(sc, 0x15, 0x02b5);
14657         MP_WritePhyUshort(sc, 0x19, 0x6800);
14658         MP_WritePhyUshort(sc, 0x15, 0x02b6);
14659         MP_WritePhyUshort(sc, 0x19, 0x4400);
14660         MP_WritePhyUshort(sc, 0x15, 0x02b7);
14661         MP_WritePhyUshort(sc, 0x19, 0x4020);
14662         MP_WritePhyUshort(sc, 0x15, 0x02b8);
14663         MP_WritePhyUshort(sc, 0x19, 0x4480);
14664         MP_WritePhyUshort(sc, 0x15, 0x02b9);
14665         MP_WritePhyUshort(sc, 0x19, 0x9e00);
14666         MP_WritePhyUshort(sc, 0x15, 0x02ba);
14667         MP_WritePhyUshort(sc, 0x19, 0x4891);
14668         MP_WritePhyUshort(sc, 0x15, 0x02bb);
14669         MP_WritePhyUshort(sc, 0x19, 0x4cc0);
14670         MP_WritePhyUshort(sc, 0x15, 0x02bc);
14671         MP_WritePhyUshort(sc, 0x19, 0x4801);
14672         MP_WritePhyUshort(sc, 0x15, 0x02bd);
14673         MP_WritePhyUshort(sc, 0x19, 0xa609);
14674         MP_WritePhyUshort(sc, 0x15, 0x02be);
14675         MP_WritePhyUshort(sc, 0x19, 0xd64f);
14676         MP_WritePhyUshort(sc, 0x15, 0x02bf);
14677         MP_WritePhyUshort(sc, 0x19, 0x004e);
14678         MP_WritePhyUshort(sc, 0x15, 0x02c0);
14679         MP_WritePhyUshort(sc, 0x19, 0x87fe);
14680         MP_WritePhyUshort(sc, 0x15, 0x02c1);
14681         MP_WritePhyUshort(sc, 0x19, 0x32c6);
14682         MP_WritePhyUshort(sc, 0x15, 0x02c2);
14683         MP_WritePhyUshort(sc, 0x19, 0x0000);
14684         MP_WritePhyUshort(sc, 0x15, 0x02c3);
14685         MP_WritePhyUshort(sc, 0x19, 0x0000);
14686         MP_WritePhyUshort(sc, 0x15, 0x02c4);
14687         MP_WritePhyUshort(sc, 0x19, 0x0000);
14688         MP_WritePhyUshort(sc, 0x15, 0x02c5);
14689         MP_WritePhyUshort(sc, 0x19, 0x0000);
14690         MP_WritePhyUshort(sc, 0x15, 0x02c6);
14691         MP_WritePhyUshort(sc, 0x19, 0x48b2);
14692         MP_WritePhyUshort(sc, 0x15, 0x02c7);
14693         MP_WritePhyUshort(sc, 0x19, 0x4020);
14694         MP_WritePhyUshort(sc, 0x15, 0x02c8);
14695         MP_WritePhyUshort(sc, 0x19, 0x4822);
14696         MP_WritePhyUshort(sc, 0x15, 0x02c9);
14697         MP_WritePhyUshort(sc, 0x19, 0x4488);
14698         MP_WritePhyUshort(sc, 0x15, 0x02ca);
14699         MP_WritePhyUshort(sc, 0x19, 0xd64f);
14700         MP_WritePhyUshort(sc, 0x15, 0x02cb);
14701         MP_WritePhyUshort(sc, 0x19, 0x0042);
14702         MP_WritePhyUshort(sc, 0x15, 0x02cc);
14703         MP_WritePhyUshort(sc, 0x19, 0x8203);
14704         MP_WritePhyUshort(sc, 0x15, 0x02cd);
14705         MP_WritePhyUshort(sc, 0x19, 0x4cc8);
14706         MP_WritePhyUshort(sc, 0x15, 0x02ce);
14707         MP_WritePhyUshort(sc, 0x19, 0x32d0);
14708         MP_WritePhyUshort(sc, 0x15, 0x02cf);
14709         MP_WritePhyUshort(sc, 0x19, 0x4cc0);
14710         MP_WritePhyUshort(sc, 0x15, 0x02d0);
14711         MP_WritePhyUshort(sc, 0x19, 0xc4d4);
14712         MP_WritePhyUshort(sc, 0x15, 0x02d1);
14713         MP_WritePhyUshort(sc, 0x19, 0x00f9);
14714         MP_WritePhyUshort(sc, 0x15, 0x02d2);
14715         MP_WritePhyUshort(sc, 0x19, 0xa51a);
14716         MP_WritePhyUshort(sc, 0x15, 0x02d3);
14717         MP_WritePhyUshort(sc, 0x19, 0x32d9);
14718         MP_WritePhyUshort(sc, 0x15, 0x02d4);
14719         MP_WritePhyUshort(sc, 0x19, 0x0000);
14720         MP_WritePhyUshort(sc, 0x15, 0x02d5);
14721         MP_WritePhyUshort(sc, 0x19, 0x0000);
14722         MP_WritePhyUshort(sc, 0x15, 0x02d6);
14723         MP_WritePhyUshort(sc, 0x19, 0x0000);
14724         MP_WritePhyUshort(sc, 0x15, 0x02d7);
14725         MP_WritePhyUshort(sc, 0x19, 0x0000);
14726         MP_WritePhyUshort(sc, 0x15, 0x02d8);
14727         MP_WritePhyUshort(sc, 0x19, 0x0000);
14728         MP_WritePhyUshort(sc, 0x15, 0x02d9);
14729         MP_WritePhyUshort(sc, 0x19, 0x48b3);
14730         MP_WritePhyUshort(sc, 0x15, 0x02da);
14731         MP_WritePhyUshort(sc, 0x19, 0x4020);
14732         MP_WritePhyUshort(sc, 0x15, 0x02db);
14733         MP_WritePhyUshort(sc, 0x19, 0x4823);
14734         MP_WritePhyUshort(sc, 0x15, 0x02dc);
14735         MP_WritePhyUshort(sc, 0x19, 0x4410);
14736         MP_WritePhyUshort(sc, 0x15, 0x02dd);
14737         MP_WritePhyUshort(sc, 0x19, 0xb630);
14738         MP_WritePhyUshort(sc, 0x15, 0x02de);
14739         MP_WritePhyUshort(sc, 0x19, 0x7dc8);
14740         MP_WritePhyUshort(sc, 0x15, 0x02df);
14741         MP_WritePhyUshort(sc, 0x19, 0x8203);
14742         MP_WritePhyUshort(sc, 0x15, 0x02e0);
14743         MP_WritePhyUshort(sc, 0x19, 0x4c48);
14744         MP_WritePhyUshort(sc, 0x15, 0x02e1);
14745         MP_WritePhyUshort(sc, 0x19, 0x32e3);
14746         MP_WritePhyUshort(sc, 0x15, 0x02e2);
14747         MP_WritePhyUshort(sc, 0x19, 0x4c40);
14748         MP_WritePhyUshort(sc, 0x15, 0x02e3);
14749         MP_WritePhyUshort(sc, 0x19, 0x9bfa);
14750         MP_WritePhyUshort(sc, 0x15, 0x02e4);
14751         MP_WritePhyUshort(sc, 0x19, 0x84ca);
14752         MP_WritePhyUshort(sc, 0x15, 0x02e5);
14753         MP_WritePhyUshort(sc, 0x19, 0x85f8);
14754         MP_WritePhyUshort(sc, 0x15, 0x02e6);
14755         MP_WritePhyUshort(sc, 0x19, 0x32ec);
14756         MP_WritePhyUshort(sc, 0x15, 0x02e7);
14757         MP_WritePhyUshort(sc, 0x19, 0x0000);
14758         MP_WritePhyUshort(sc, 0x15, 0x02e8);
14759         MP_WritePhyUshort(sc, 0x19, 0x0000);
14760         MP_WritePhyUshort(sc, 0x15, 0x02e9);
14761         MP_WritePhyUshort(sc, 0x19, 0x0000);
14762         MP_WritePhyUshort(sc, 0x15, 0x02ea);
14763         MP_WritePhyUshort(sc, 0x19, 0x0000);
14764         MP_WritePhyUshort(sc, 0x15, 0x02eb);
14765         MP_WritePhyUshort(sc, 0x19, 0x0000);
14766         MP_WritePhyUshort(sc, 0x15, 0x02ec);
14767         MP_WritePhyUshort(sc, 0x19, 0x48d4);
14768         MP_WritePhyUshort(sc, 0x15, 0x02ed);
14769         MP_WritePhyUshort(sc, 0x19, 0x4020);
14770         MP_WritePhyUshort(sc, 0x15, 0x02ee);
14771         MP_WritePhyUshort(sc, 0x19, 0x4844);
14772         MP_WritePhyUshort(sc, 0x15, 0x02ef);
14773         MP_WritePhyUshort(sc, 0x19, 0x4420);
14774         MP_WritePhyUshort(sc, 0x15, 0x02f0);
14775         MP_WritePhyUshort(sc, 0x19, 0x6800);
14776         MP_WritePhyUshort(sc, 0x15, 0x02f1);
14777         MP_WritePhyUshort(sc, 0x19, 0x7dc0);
14778         MP_WritePhyUshort(sc, 0x15, 0x02f2);
14779         MP_WritePhyUshort(sc, 0x19, 0x4c40);
14780         MP_WritePhyUshort(sc, 0x15, 0x02f3);
14781         MP_WritePhyUshort(sc, 0x19, 0x7c0b);
14782         MP_WritePhyUshort(sc, 0x15, 0x02f4);
14783         MP_WritePhyUshort(sc, 0x19, 0x6c08);
14784         MP_WritePhyUshort(sc, 0x15, 0x02f5);
14785         MP_WritePhyUshort(sc, 0x19, 0x3311);
14786         MP_WritePhyUshort(sc, 0x15, 0x02f6);
14787         MP_WritePhyUshort(sc, 0x19, 0x9cfd);
14788         MP_WritePhyUshort(sc, 0x15, 0x02f7);
14789         MP_WritePhyUshort(sc, 0x19, 0xb616);
14790         MP_WritePhyUshort(sc, 0x15, 0x02f8);
14791         MP_WritePhyUshort(sc, 0x19, 0xc42b);
14792         MP_WritePhyUshort(sc, 0x15, 0x02f9);
14793         MP_WritePhyUshort(sc, 0x19, 0x00e0);
14794         MP_WritePhyUshort(sc, 0x15, 0x02fa);
14795         MP_WritePhyUshort(sc, 0x19, 0xc455);
14796         MP_WritePhyUshort(sc, 0x15, 0x02fb);
14797         MP_WritePhyUshort(sc, 0x19, 0x00b3);
14798         MP_WritePhyUshort(sc, 0x15, 0x02fc);
14799         MP_WritePhyUshort(sc, 0x19, 0xb20a);
14800         MP_WritePhyUshort(sc, 0x15, 0x02fd);
14801         MP_WritePhyUshort(sc, 0x19, 0x7c03);
14802         MP_WritePhyUshort(sc, 0x15, 0x02fe);
14803         MP_WritePhyUshort(sc, 0x19, 0x6c02);
14804         MP_WritePhyUshort(sc, 0x15, 0x02ff);
14805         MP_WritePhyUshort(sc, 0x19, 0x8204);
14806         MP_WritePhyUshort(sc, 0x15, 0x0300);
14807         MP_WritePhyUshort(sc, 0x19, 0x7c04);
14808         MP_WritePhyUshort(sc, 0x15, 0x0301);
14809         MP_WritePhyUshort(sc, 0x19, 0x7404);
14810         MP_WritePhyUshort(sc, 0x15, 0x0302);
14811         MP_WritePhyUshort(sc, 0x19, 0x32f3);
14812         MP_WritePhyUshort(sc, 0x15, 0x0303);
14813         MP_WritePhyUshort(sc, 0x19, 0x7c04);
14814         MP_WritePhyUshort(sc, 0x15, 0x0304);
14815         MP_WritePhyUshort(sc, 0x19, 0x7400);
14816         MP_WritePhyUshort(sc, 0x15, 0x0305);
14817         MP_WritePhyUshort(sc, 0x19, 0x32f3);
14818         MP_WritePhyUshort(sc, 0x15, 0x0306);
14819         MP_WritePhyUshort(sc, 0x19, 0xefed);
14820         MP_WritePhyUshort(sc, 0x15, 0x0307);
14821         MP_WritePhyUshort(sc, 0x19, 0x3342);
14822         MP_WritePhyUshort(sc, 0x15, 0x0308);
14823         MP_WritePhyUshort(sc, 0x19, 0x0000);
14824         MP_WritePhyUshort(sc, 0x15, 0x0309);
14825         MP_WritePhyUshort(sc, 0x19, 0x0000);
14826         MP_WritePhyUshort(sc, 0x15, 0x030a);
14827         MP_WritePhyUshort(sc, 0x19, 0x0000);
14828         MP_WritePhyUshort(sc, 0x15, 0x030b);
14829         MP_WritePhyUshort(sc, 0x19, 0x0000);
14830         MP_WritePhyUshort(sc, 0x15, 0x030c);
14831         MP_WritePhyUshort(sc, 0x19, 0x0000);
14832         MP_WritePhyUshort(sc, 0x15, 0x030d);
14833         MP_WritePhyUshort(sc, 0x19, 0x3006);
14834         MP_WritePhyUshort(sc, 0x15, 0x030e);
14835         MP_WritePhyUshort(sc, 0x19, 0x0000);
14836         MP_WritePhyUshort(sc, 0x15, 0x030f);
14837         MP_WritePhyUshort(sc, 0x19, 0x0000);
14838         MP_WritePhyUshort(sc, 0x15, 0x0310);
14839         MP_WritePhyUshort(sc, 0x19, 0x0000);
14840         MP_WritePhyUshort(sc, 0x15, 0x0311);
14841         MP_WritePhyUshort(sc, 0x19, 0x7c08);
14842         MP_WritePhyUshort(sc, 0x15, 0x0312);
14843         MP_WritePhyUshort(sc, 0x19, 0xa207);
14844         MP_WritePhyUshort(sc, 0x15, 0x0313);
14845         MP_WritePhyUshort(sc, 0x19, 0x4c00);
14846         MP_WritePhyUshort(sc, 0x15, 0x0314);
14847         MP_WritePhyUshort(sc, 0x19, 0x3322);
14848         MP_WritePhyUshort(sc, 0x15, 0x0315);
14849         MP_WritePhyUshort(sc, 0x19, 0x4041);
14850         MP_WritePhyUshort(sc, 0x15, 0x0316);
14851         MP_WritePhyUshort(sc, 0x19, 0x7d07);
14852         MP_WritePhyUshort(sc, 0x15, 0x0317);
14853         MP_WritePhyUshort(sc, 0x19, 0x4502);
14854         MP_WritePhyUshort(sc, 0x15, 0x0318);
14855         MP_WritePhyUshort(sc, 0x19, 0x3322);
14856         MP_WritePhyUshort(sc, 0x15, 0x0319);
14857         MP_WritePhyUshort(sc, 0x19, 0x4c08);
14858         MP_WritePhyUshort(sc, 0x15, 0x031a);
14859         MP_WritePhyUshort(sc, 0x19, 0x3322);
14860         MP_WritePhyUshort(sc, 0x15, 0x031b);
14861         MP_WritePhyUshort(sc, 0x19, 0x7d80);
14862         MP_WritePhyUshort(sc, 0x15, 0x031c);
14863         MP_WritePhyUshort(sc, 0x19, 0x5180);
14864         MP_WritePhyUshort(sc, 0x15, 0x031d);
14865         MP_WritePhyUshort(sc, 0x19, 0x3320);
14866         MP_WritePhyUshort(sc, 0x15, 0x031e);
14867         MP_WritePhyUshort(sc, 0x19, 0x7d80);
14868         MP_WritePhyUshort(sc, 0x15, 0x031f);
14869         MP_WritePhyUshort(sc, 0x19, 0x5000);
14870         MP_WritePhyUshort(sc, 0x15, 0x0320);
14871         MP_WritePhyUshort(sc, 0x19, 0x7d07);
14872         MP_WritePhyUshort(sc, 0x15, 0x0321);
14873         MP_WritePhyUshort(sc, 0x19, 0x4402);
14874         MP_WritePhyUshort(sc, 0x15, 0x0322);
14875         MP_WritePhyUshort(sc, 0x19, 0x7c03);
14876         MP_WritePhyUshort(sc, 0x15, 0x0323);
14877         MP_WritePhyUshort(sc, 0x19, 0x6c02);
14878         MP_WritePhyUshort(sc, 0x15, 0x0324);
14879         MP_WritePhyUshort(sc, 0x19, 0x7c03);
14880         MP_WritePhyUshort(sc, 0x15, 0x0325);
14881         MP_WritePhyUshort(sc, 0x19, 0xb30c);
14882         MP_WritePhyUshort(sc, 0x15, 0x0326);
14883         MP_WritePhyUshort(sc, 0x19, 0xb206);
14884         MP_WritePhyUshort(sc, 0x15, 0x0327);
14885         MP_WritePhyUshort(sc, 0x19, 0xb103);
14886         MP_WritePhyUshort(sc, 0x15, 0x0328);
14887         MP_WritePhyUshort(sc, 0x19, 0x6c00);
14888         MP_WritePhyUshort(sc, 0x15, 0x0329);
14889         MP_WritePhyUshort(sc, 0x19, 0x32f6);
14890         MP_WritePhyUshort(sc, 0x15, 0x032a);
14891         MP_WritePhyUshort(sc, 0x19, 0x6c00);
14892         MP_WritePhyUshort(sc, 0x15, 0x032b);
14893         MP_WritePhyUshort(sc, 0x19, 0x3352);
14894         MP_WritePhyUshort(sc, 0x15, 0x032c);
14895         MP_WritePhyUshort(sc, 0x19, 0xb103);
14896         MP_WritePhyUshort(sc, 0x15, 0x032d);
14897         MP_WritePhyUshort(sc, 0x19, 0x6c00);
14898         MP_WritePhyUshort(sc, 0x15, 0x032e);
14899         MP_WritePhyUshort(sc, 0x19, 0x336a);
14900         MP_WritePhyUshort(sc, 0x15, 0x032f);
14901         MP_WritePhyUshort(sc, 0x19, 0x6c00);
14902         MP_WritePhyUshort(sc, 0x15, 0x0330);
14903         MP_WritePhyUshort(sc, 0x19, 0x3382);
14904         MP_WritePhyUshort(sc, 0x15, 0x0331);
14905         MP_WritePhyUshort(sc, 0x19, 0xb206);
14906         MP_WritePhyUshort(sc, 0x15, 0x0332);
14907         MP_WritePhyUshort(sc, 0x19, 0xb103);
14908         MP_WritePhyUshort(sc, 0x15, 0x0333);
14909         MP_WritePhyUshort(sc, 0x19, 0x6c00);
14910         MP_WritePhyUshort(sc, 0x15, 0x0334);
14911         MP_WritePhyUshort(sc, 0x19, 0x3395);
14912         MP_WritePhyUshort(sc, 0x15, 0x0335);
14913         MP_WritePhyUshort(sc, 0x19, 0x6c00);
14914         MP_WritePhyUshort(sc, 0x15, 0x0336);
14915         MP_WritePhyUshort(sc, 0x19, 0x33c6);
14916         MP_WritePhyUshort(sc, 0x15, 0x0337);
14917         MP_WritePhyUshort(sc, 0x19, 0xb103);
14918         MP_WritePhyUshort(sc, 0x15, 0x0338);
14919         MP_WritePhyUshort(sc, 0x19, 0x6c00);
14920         MP_WritePhyUshort(sc, 0x15, 0x0339);
14921         MP_WritePhyUshort(sc, 0x19, 0x33d7);
14922         MP_WritePhyUshort(sc, 0x15, 0x033a);
14923         MP_WritePhyUshort(sc, 0x19, 0x6c00);
14924         MP_WritePhyUshort(sc, 0x15, 0x033b);
14925         MP_WritePhyUshort(sc, 0x19, 0x33f2);
14926         MP_WritePhyUshort(sc, 0x15, 0x033c);
14927         MP_WritePhyUshort(sc, 0x19, 0x0000);
14928         MP_WritePhyUshort(sc, 0x15, 0x033d);
14929         MP_WritePhyUshort(sc, 0x19, 0x0000);
14930         MP_WritePhyUshort(sc, 0x15, 0x033e);
14931         MP_WritePhyUshort(sc, 0x19, 0x0000);
14932         MP_WritePhyUshort(sc, 0x15, 0x033f);
14933         MP_WritePhyUshort(sc, 0x19, 0x0000);
14934         MP_WritePhyUshort(sc, 0x15, 0x0340);
14935         MP_WritePhyUshort(sc, 0x19, 0x0000);
14936         MP_WritePhyUshort(sc, 0x15, 0x0341);
14937         MP_WritePhyUshort(sc, 0x19, 0x0000);
14938         MP_WritePhyUshort(sc, 0x15, 0x0342);
14939         MP_WritePhyUshort(sc, 0x19, 0x49b5);
14940         MP_WritePhyUshort(sc, 0x15, 0x0343);
14941         MP_WritePhyUshort(sc, 0x19, 0x7d00);
14942         MP_WritePhyUshort(sc, 0x15, 0x0344);
14943         MP_WritePhyUshort(sc, 0x19, 0x4d00);
14944         MP_WritePhyUshort(sc, 0x15, 0x0345);
14945         MP_WritePhyUshort(sc, 0x19, 0x6880);
14946         MP_WritePhyUshort(sc, 0x15, 0x0346);
14947         MP_WritePhyUshort(sc, 0x19, 0x7c08);
14948         MP_WritePhyUshort(sc, 0x15, 0x0347);
14949         MP_WritePhyUshort(sc, 0x19, 0x6c08);
14950         MP_WritePhyUshort(sc, 0x15, 0x0348);
14951         MP_WritePhyUshort(sc, 0x19, 0x4925);
14952         MP_WritePhyUshort(sc, 0x15, 0x0349);
14953         MP_WritePhyUshort(sc, 0x19, 0x403b);
14954         MP_WritePhyUshort(sc, 0x15, 0x034a);
14955         MP_WritePhyUshort(sc, 0x19, 0xa602);
14956         MP_WritePhyUshort(sc, 0x15, 0x034b);
14957         MP_WritePhyUshort(sc, 0x19, 0x402f);
14958         MP_WritePhyUshort(sc, 0x15, 0x034c);
14959         MP_WritePhyUshort(sc, 0x19, 0x4484);
14960         MP_WritePhyUshort(sc, 0x15, 0x034d);
14961         MP_WritePhyUshort(sc, 0x19, 0x40c8);
14962         MP_WritePhyUshort(sc, 0x15, 0x034e);
14963         MP_WritePhyUshort(sc, 0x19, 0x44c4);
14964         MP_WritePhyUshort(sc, 0x15, 0x034f);
14965         MP_WritePhyUshort(sc, 0x19, 0xd64f);
14966         MP_WritePhyUshort(sc, 0x15, 0x0350);
14967         MP_WritePhyUshort(sc, 0x19, 0x00bd);
14968         MP_WritePhyUshort(sc, 0x15, 0x0351);
14969         MP_WritePhyUshort(sc, 0x19, 0x3311);
14970         MP_WritePhyUshort(sc, 0x15, 0x0352);
14971         MP_WritePhyUshort(sc, 0x19, 0xc8ed);
14972         MP_WritePhyUshort(sc, 0x15, 0x0353);
14973         MP_WritePhyUshort(sc, 0x19, 0x00fc);
14974         MP_WritePhyUshort(sc, 0x15, 0x0354);
14975         MP_WritePhyUshort(sc, 0x19, 0x8221);
14976         MP_WritePhyUshort(sc, 0x15, 0x0355);
14977         MP_WritePhyUshort(sc, 0x19, 0xd11d);
14978         MP_WritePhyUshort(sc, 0x15, 0x0356);
14979         MP_WritePhyUshort(sc, 0x19, 0x001f);
14980         MP_WritePhyUshort(sc, 0x15, 0x0357);
14981         MP_WritePhyUshort(sc, 0x19, 0xde18);
14982         MP_WritePhyUshort(sc, 0x15, 0x0358);
14983         MP_WritePhyUshort(sc, 0x19, 0x0008);
14984         MP_WritePhyUshort(sc, 0x15, 0x0359);
14985         MP_WritePhyUshort(sc, 0x19, 0x91f6);
14986         MP_WritePhyUshort(sc, 0x15, 0x035a);
14987         MP_WritePhyUshort(sc, 0x19, 0x3360);
14988         MP_WritePhyUshort(sc, 0x15, 0x035b);
14989         MP_WritePhyUshort(sc, 0x19, 0x0000);
14990         MP_WritePhyUshort(sc, 0x15, 0x035c);
14991         MP_WritePhyUshort(sc, 0x19, 0x0000);
14992         MP_WritePhyUshort(sc, 0x15, 0x035d);
14993         MP_WritePhyUshort(sc, 0x19, 0x0000);
14994         MP_WritePhyUshort(sc, 0x15, 0x035e);
14995         MP_WritePhyUshort(sc, 0x19, 0x0000);
14996         MP_WritePhyUshort(sc, 0x15, 0x035f);
14997         MP_WritePhyUshort(sc, 0x19, 0x0000);
14998         MP_WritePhyUshort(sc, 0x15, 0x0360);
14999         MP_WritePhyUshort(sc, 0x19, 0x4bb6);
15000         MP_WritePhyUshort(sc, 0x15, 0x0361);
15001         MP_WritePhyUshort(sc, 0x19, 0x4064);
15002         MP_WritePhyUshort(sc, 0x15, 0x0362);
15003         MP_WritePhyUshort(sc, 0x19, 0x4b26);
15004         MP_WritePhyUshort(sc, 0x15, 0x0363);
15005         MP_WritePhyUshort(sc, 0x19, 0x4410);
15006         MP_WritePhyUshort(sc, 0x15, 0x0364);
15007         MP_WritePhyUshort(sc, 0x19, 0x4006);
15008         MP_WritePhyUshort(sc, 0x15, 0x0365);
15009         MP_WritePhyUshort(sc, 0x19, 0x4490);
15010         MP_WritePhyUshort(sc, 0x15, 0x0366);
15011         MP_WritePhyUshort(sc, 0x19, 0x6900);
15012         MP_WritePhyUshort(sc, 0x15, 0x0367);
15013         MP_WritePhyUshort(sc, 0x19, 0xb6a6);
15014         MP_WritePhyUshort(sc, 0x15, 0x0368);
15015         MP_WritePhyUshort(sc, 0x19, 0x9e02);
15016         MP_WritePhyUshort(sc, 0x15, 0x0369);
15017         MP_WritePhyUshort(sc, 0x19, 0x3311);
15018         MP_WritePhyUshort(sc, 0x15, 0x036a);
15019         MP_WritePhyUshort(sc, 0x19, 0xd11d);
15020         MP_WritePhyUshort(sc, 0x15, 0x036b);
15021         MP_WritePhyUshort(sc, 0x19, 0x000a);
15022         MP_WritePhyUshort(sc, 0x15, 0x036c);
15023         MP_WritePhyUshort(sc, 0x19, 0xbb0f);
15024         MP_WritePhyUshort(sc, 0x15, 0x036d);
15025         MP_WritePhyUshort(sc, 0x19, 0x8102);
15026         MP_WritePhyUshort(sc, 0x15, 0x036e);
15027         MP_WritePhyUshort(sc, 0x19, 0x3371);
15028         MP_WritePhyUshort(sc, 0x15, 0x036f);
15029         MP_WritePhyUshort(sc, 0x19, 0xa21e);
15030         MP_WritePhyUshort(sc, 0x15, 0x0370);
15031         MP_WritePhyUshort(sc, 0x19, 0x33b6);
15032         MP_WritePhyUshort(sc, 0x15, 0x0371);
15033         MP_WritePhyUshort(sc, 0x19, 0x91f6);
15034         MP_WritePhyUshort(sc, 0x15, 0x0372);
15035         MP_WritePhyUshort(sc, 0x19, 0xc218);
15036         MP_WritePhyUshort(sc, 0x15, 0x0373);
15037         MP_WritePhyUshort(sc, 0x19, 0x00f4);
15038         MP_WritePhyUshort(sc, 0x15, 0x0374);
15039         MP_WritePhyUshort(sc, 0x19, 0x33b6);
15040         MP_WritePhyUshort(sc, 0x15, 0x0375);
15041         MP_WritePhyUshort(sc, 0x19, 0x32ec);
15042         MP_WritePhyUshort(sc, 0x15, 0x0376);
15043         MP_WritePhyUshort(sc, 0x19, 0x0000);
15044         MP_WritePhyUshort(sc, 0x15, 0x0377);
15045         MP_WritePhyUshort(sc, 0x19, 0x0000);
15046         MP_WritePhyUshort(sc, 0x15, 0x0378);
15047         MP_WritePhyUshort(sc, 0x19, 0x0000);
15048         MP_WritePhyUshort(sc, 0x15, 0x0379);
15049         MP_WritePhyUshort(sc, 0x19, 0x0000);
15050         MP_WritePhyUshort(sc, 0x15, 0x037a);
15051         MP_WritePhyUshort(sc, 0x19, 0x0000);
15052         MP_WritePhyUshort(sc, 0x15, 0x037b);
15053         MP_WritePhyUshort(sc, 0x19, 0x4b97);
15054         MP_WritePhyUshort(sc, 0x15, 0x037c);
15055         MP_WritePhyUshort(sc, 0x19, 0x402b);
15056         MP_WritePhyUshort(sc, 0x15, 0x037d);
15057         MP_WritePhyUshort(sc, 0x19, 0x4b07);
15058         MP_WritePhyUshort(sc, 0x15, 0x037e);
15059         MP_WritePhyUshort(sc, 0x19, 0x4422);
15060         MP_WritePhyUshort(sc, 0x15, 0x037f);
15061         MP_WritePhyUshort(sc, 0x19, 0x6980);
15062         MP_WritePhyUshort(sc, 0x15, 0x0380);
15063         MP_WritePhyUshort(sc, 0x19, 0xb608);
15064         MP_WritePhyUshort(sc, 0x15, 0x0381);
15065         MP_WritePhyUshort(sc, 0x19, 0x3311);
15066         MP_WritePhyUshort(sc, 0x15, 0x0382);
15067         MP_WritePhyUshort(sc, 0x19, 0xbc05);
15068         MP_WritePhyUshort(sc, 0x15, 0x0383);
15069         MP_WritePhyUshort(sc, 0x19, 0xc21c);
15070         MP_WritePhyUshort(sc, 0x15, 0x0384);
15071         MP_WritePhyUshort(sc, 0x19, 0x0032);
15072         MP_WritePhyUshort(sc, 0x15, 0x0385);
15073         MP_WritePhyUshort(sc, 0x19, 0xa1fb);
15074         MP_WritePhyUshort(sc, 0x15, 0x0386);
15075         MP_WritePhyUshort(sc, 0x19, 0x338d);
15076         MP_WritePhyUshort(sc, 0x15, 0x0387);
15077         MP_WritePhyUshort(sc, 0x19, 0x32ae);
15078         MP_WritePhyUshort(sc, 0x15, 0x0388);
15079         MP_WritePhyUshort(sc, 0x19, 0x330d);
15080         MP_WritePhyUshort(sc, 0x15, 0x0389);
15081         MP_WritePhyUshort(sc, 0x19, 0x0000);
15082         MP_WritePhyUshort(sc, 0x15, 0x038a);
15083         MP_WritePhyUshort(sc, 0x19, 0x0000);
15084         MP_WritePhyUshort(sc, 0x15, 0x038b);
15085         MP_WritePhyUshort(sc, 0x19, 0x0000);
15086         MP_WritePhyUshort(sc, 0x15, 0x038c);
15087         MP_WritePhyUshort(sc, 0x19, 0x0000);
15088         MP_WritePhyUshort(sc, 0x15, 0x038d);
15089         MP_WritePhyUshort(sc, 0x19, 0x4b97);
15090         MP_WritePhyUshort(sc, 0x15, 0x038e);
15091         MP_WritePhyUshort(sc, 0x19, 0x6a08);
15092         MP_WritePhyUshort(sc, 0x15, 0x038f);
15093         MP_WritePhyUshort(sc, 0x19, 0x4b07);
15094         MP_WritePhyUshort(sc, 0x15, 0x0390);
15095         MP_WritePhyUshort(sc, 0x19, 0x40ac);
15096         MP_WritePhyUshort(sc, 0x15, 0x0391);
15097         MP_WritePhyUshort(sc, 0x19, 0x4445);
15098         MP_WritePhyUshort(sc, 0x15, 0x0392);
15099         MP_WritePhyUshort(sc, 0x19, 0x404e);
15100         MP_WritePhyUshort(sc, 0x15, 0x0393);
15101         MP_WritePhyUshort(sc, 0x19, 0x4461);
15102         MP_WritePhyUshort(sc, 0x15, 0x0394);
15103         MP_WritePhyUshort(sc, 0x19, 0x3311);
15104         MP_WritePhyUshort(sc, 0x15, 0x0395);
15105         MP_WritePhyUshort(sc, 0x19, 0x9c0a);
15106         MP_WritePhyUshort(sc, 0x15, 0x0396);
15107         MP_WritePhyUshort(sc, 0x19, 0x63da);
15108         MP_WritePhyUshort(sc, 0x15, 0x0397);
15109         MP_WritePhyUshort(sc, 0x19, 0x6f0c);
15110         MP_WritePhyUshort(sc, 0x15, 0x0398);
15111         MP_WritePhyUshort(sc, 0x19, 0x5440);
15112         MP_WritePhyUshort(sc, 0x15, 0x0399);
15113         MP_WritePhyUshort(sc, 0x19, 0x4b98);
15114         MP_WritePhyUshort(sc, 0x15, 0x039a);
15115         MP_WritePhyUshort(sc, 0x19, 0x7c40);
15116         MP_WritePhyUshort(sc, 0x15, 0x039b);
15117         MP_WritePhyUshort(sc, 0x19, 0x4c00);
15118         MP_WritePhyUshort(sc, 0x15, 0x039c);
15119         MP_WritePhyUshort(sc, 0x19, 0x4b08);
15120         MP_WritePhyUshort(sc, 0x15, 0x039d);
15121         MP_WritePhyUshort(sc, 0x19, 0x63d8);
15122         MP_WritePhyUshort(sc, 0x15, 0x039e);
15123         MP_WritePhyUshort(sc, 0x19, 0x33a5);
15124         MP_WritePhyUshort(sc, 0x15, 0x039f);
15125         MP_WritePhyUshort(sc, 0x19, 0xd64f);
15126         MP_WritePhyUshort(sc, 0x15, 0x03a0);
15127         MP_WritePhyUshort(sc, 0x19, 0x00e8);
15128         MP_WritePhyUshort(sc, 0x15, 0x03a1);
15129         MP_WritePhyUshort(sc, 0x19, 0x820e);
15130         MP_WritePhyUshort(sc, 0x15, 0x03a2);
15131         MP_WritePhyUshort(sc, 0x19, 0xa10d);
15132         MP_WritePhyUshort(sc, 0x15, 0x03a3);
15133         MP_WritePhyUshort(sc, 0x19, 0x9df1);
15134         MP_WritePhyUshort(sc, 0x15, 0x03a4);
15135         MP_WritePhyUshort(sc, 0x19, 0x33af);
15136         MP_WritePhyUshort(sc, 0x15, 0x03a5);
15137         MP_WritePhyUshort(sc, 0x19, 0xd64f);
15138         MP_WritePhyUshort(sc, 0x15, 0x03a6);
15139         MP_WritePhyUshort(sc, 0x19, 0x00f9);
15140         MP_WritePhyUshort(sc, 0x15, 0x03a7);
15141         MP_WritePhyUshort(sc, 0x19, 0xc017);
15142         MP_WritePhyUshort(sc, 0x15, 0x03a8);
15143         MP_WritePhyUshort(sc, 0x19, 0x0007);
15144         MP_WritePhyUshort(sc, 0x15, 0x03a9);
15145         MP_WritePhyUshort(sc, 0x19, 0x7c03);
15146         MP_WritePhyUshort(sc, 0x15, 0x03aa);
15147         MP_WritePhyUshort(sc, 0x19, 0x6c03);
15148         MP_WritePhyUshort(sc, 0x15, 0x03ab);
15149         MP_WritePhyUshort(sc, 0x19, 0xa104);
15150         MP_WritePhyUshort(sc, 0x15, 0x03ac);
15151         MP_WritePhyUshort(sc, 0x19, 0x7c03);
15152         MP_WritePhyUshort(sc, 0x15, 0x03ad);
15153         MP_WritePhyUshort(sc, 0x19, 0x6c00);
15154         MP_WritePhyUshort(sc, 0x15, 0x03ae);
15155         MP_WritePhyUshort(sc, 0x19, 0x9df7);
15156         MP_WritePhyUshort(sc, 0x15, 0x03af);
15157         MP_WritePhyUshort(sc, 0x19, 0x7c03);
15158         MP_WritePhyUshort(sc, 0x15, 0x03b0);
15159         MP_WritePhyUshort(sc, 0x19, 0x6c08);
15160         MP_WritePhyUshort(sc, 0x15, 0x03b1);
15161         MP_WritePhyUshort(sc, 0x19, 0x33b6);
15162         MP_WritePhyUshort(sc, 0x15, 0x03b2);
15163         MP_WritePhyUshort(sc, 0x19, 0x0000);
15164         MP_WritePhyUshort(sc, 0x15, 0x03b3);
15165         MP_WritePhyUshort(sc, 0x19, 0x0000);
15166         MP_WritePhyUshort(sc, 0x15, 0x03b4);
15167         MP_WritePhyUshort(sc, 0x19, 0x0000);
15168         MP_WritePhyUshort(sc, 0x15, 0x03b5);
15169         MP_WritePhyUshort(sc, 0x19, 0x0000);
15170         MP_WritePhyUshort(sc, 0x15, 0x03b6);
15171         MP_WritePhyUshort(sc, 0x19, 0x55af);
15172         MP_WritePhyUshort(sc, 0x15, 0x03b7);
15173         MP_WritePhyUshort(sc, 0x19, 0x7ff0);
15174         MP_WritePhyUshort(sc, 0x15, 0x03b8);
15175         MP_WritePhyUshort(sc, 0x19, 0x6ff0);
15176         MP_WritePhyUshort(sc, 0x15, 0x03b9);
15177         MP_WritePhyUshort(sc, 0x19, 0x4bb9);
15178         MP_WritePhyUshort(sc, 0x15, 0x03ba);
15179         MP_WritePhyUshort(sc, 0x19, 0x6a80);
15180         MP_WritePhyUshort(sc, 0x15, 0x03bb);
15181         MP_WritePhyUshort(sc, 0x19, 0x4b29);
15182         MP_WritePhyUshort(sc, 0x15, 0x03bc);
15183         MP_WritePhyUshort(sc, 0x19, 0x4041);
15184         MP_WritePhyUshort(sc, 0x15, 0x03bd);
15185         MP_WritePhyUshort(sc, 0x19, 0x440a);
15186         MP_WritePhyUshort(sc, 0x15, 0x03be);
15187         MP_WritePhyUshort(sc, 0x19, 0x4029);
15188         MP_WritePhyUshort(sc, 0x15, 0x03bf);
15189         MP_WritePhyUshort(sc, 0x19, 0x4418);
15190         MP_WritePhyUshort(sc, 0x15, 0x03c0);
15191         MP_WritePhyUshort(sc, 0x19, 0x4090);
15192         MP_WritePhyUshort(sc, 0x15, 0x03c1);
15193         MP_WritePhyUshort(sc, 0x19, 0x4438);
15194         MP_WritePhyUshort(sc, 0x15, 0x03c2);
15195         MP_WritePhyUshort(sc, 0x19, 0x40c4);
15196         MP_WritePhyUshort(sc, 0x15, 0x03c3);
15197         MP_WritePhyUshort(sc, 0x19, 0x447b);
15198         MP_WritePhyUshort(sc, 0x15, 0x03c4);
15199         MP_WritePhyUshort(sc, 0x19, 0xb6c4);
15200         MP_WritePhyUshort(sc, 0x15, 0x03c5);
15201         MP_WritePhyUshort(sc, 0x19, 0x3311);
15202         MP_WritePhyUshort(sc, 0x15, 0x03c6);
15203         MP_WritePhyUshort(sc, 0x19, 0x9bfe);
15204         MP_WritePhyUshort(sc, 0x15, 0x03c7);
15205         MP_WritePhyUshort(sc, 0x19, 0x33cc);
15206         MP_WritePhyUshort(sc, 0x15, 0x03c8);
15207         MP_WritePhyUshort(sc, 0x19, 0x0000);
15208         MP_WritePhyUshort(sc, 0x15, 0x03c9);
15209         MP_WritePhyUshort(sc, 0x19, 0x0000);
15210         MP_WritePhyUshort(sc, 0x15, 0x03ca);
15211         MP_WritePhyUshort(sc, 0x19, 0x0000);
15212         MP_WritePhyUshort(sc, 0x15, 0x03cb);
15213         MP_WritePhyUshort(sc, 0x19, 0x0000);
15214         MP_WritePhyUshort(sc, 0x15, 0x03cc);
15215         MP_WritePhyUshort(sc, 0x19, 0x542f);
15216         MP_WritePhyUshort(sc, 0x15, 0x03cd);
15217         MP_WritePhyUshort(sc, 0x19, 0x499a);
15218         MP_WritePhyUshort(sc, 0x15, 0x03ce);
15219         MP_WritePhyUshort(sc, 0x19, 0x7c40);
15220         MP_WritePhyUshort(sc, 0x15, 0x03cf);
15221         MP_WritePhyUshort(sc, 0x19, 0x4c40);
15222         MP_WritePhyUshort(sc, 0x15, 0x03d0);
15223         MP_WritePhyUshort(sc, 0x19, 0x490a);
15224         MP_WritePhyUshort(sc, 0x15, 0x03d1);
15225         MP_WritePhyUshort(sc, 0x19, 0x405e);
15226         MP_WritePhyUshort(sc, 0x15, 0x03d2);
15227         MP_WritePhyUshort(sc, 0x19, 0x44f8);
15228         MP_WritePhyUshort(sc, 0x15, 0x03d3);
15229         MP_WritePhyUshort(sc, 0x19, 0x6b00);
15230         MP_WritePhyUshort(sc, 0x15, 0x03d4);
15231         MP_WritePhyUshort(sc, 0x19, 0xd64f);
15232         MP_WritePhyUshort(sc, 0x15, 0x03d5);
15233         MP_WritePhyUshort(sc, 0x19, 0x0028);
15234         MP_WritePhyUshort(sc, 0x15, 0x03d6);
15235         MP_WritePhyUshort(sc, 0x19, 0x3311);
15236         MP_WritePhyUshort(sc, 0x15, 0x03d7);
15237         MP_WritePhyUshort(sc, 0x19, 0xbd27);
15238         MP_WritePhyUshort(sc, 0x15, 0x03d8);
15239         MP_WritePhyUshort(sc, 0x19, 0x9cfc);
15240         MP_WritePhyUshort(sc, 0x15, 0x03d9);
15241         MP_WritePhyUshort(sc, 0x19, 0xc639);
15242         MP_WritePhyUshort(sc, 0x15, 0x03da);
15243         MP_WritePhyUshort(sc, 0x19, 0x000f);
15244         MP_WritePhyUshort(sc, 0x15, 0x03db);
15245         MP_WritePhyUshort(sc, 0x19, 0x9e03);
15246         MP_WritePhyUshort(sc, 0x15, 0x03dc);
15247         MP_WritePhyUshort(sc, 0x19, 0x7c01);
15248         MP_WritePhyUshort(sc, 0x15, 0x03dd);
15249         MP_WritePhyUshort(sc, 0x19, 0x4c01);
15250         MP_WritePhyUshort(sc, 0x15, 0x03de);
15251         MP_WritePhyUshort(sc, 0x19, 0x9af6);
15252         MP_WritePhyUshort(sc, 0x15, 0x03df);
15253         MP_WritePhyUshort(sc, 0x19, 0x7c12);
15254         MP_WritePhyUshort(sc, 0x15, 0x03e0);
15255         MP_WritePhyUshort(sc, 0x19, 0x4c52);
15256         MP_WritePhyUshort(sc, 0x15, 0x03e1);
15257         MP_WritePhyUshort(sc, 0x19, 0x4470);
15258         MP_WritePhyUshort(sc, 0x15, 0x03e2);
15259         MP_WritePhyUshort(sc, 0x19, 0x7c12);
15260         MP_WritePhyUshort(sc, 0x15, 0x03e3);
15261         MP_WritePhyUshort(sc, 0x19, 0x4c40);
15262         MP_WritePhyUshort(sc, 0x15, 0x03e4);
15263         MP_WritePhyUshort(sc, 0x19, 0x33d4);
15264         MP_WritePhyUshort(sc, 0x15, 0x03e5);
15265         MP_WritePhyUshort(sc, 0x19, 0x0000);
15266         MP_WritePhyUshort(sc, 0x15, 0x03e6);
15267         MP_WritePhyUshort(sc, 0x19, 0x0000);
15268         MP_WritePhyUshort(sc, 0x15, 0x03e7);
15269         MP_WritePhyUshort(sc, 0x19, 0x0000);
15270         MP_WritePhyUshort(sc, 0x15, 0x03e8);
15271         MP_WritePhyUshort(sc, 0x19, 0x0000);
15272         MP_WritePhyUshort(sc, 0x15, 0x03e9);
15273         MP_WritePhyUshort(sc, 0x19, 0x49bb);
15274         MP_WritePhyUshort(sc, 0x15, 0x03ea);
15275         MP_WritePhyUshort(sc, 0x19, 0x4478);
15276         MP_WritePhyUshort(sc, 0x15, 0x03eb);
15277         MP_WritePhyUshort(sc, 0x19, 0x492b);
15278         MP_WritePhyUshort(sc, 0x15, 0x03ec);
15279         MP_WritePhyUshort(sc, 0x19, 0x6b80);
15280         MP_WritePhyUshort(sc, 0x15, 0x03ed);
15281         MP_WritePhyUshort(sc, 0x19, 0x7c01);
15282         MP_WritePhyUshort(sc, 0x15, 0x03ee);
15283         MP_WritePhyUshort(sc, 0x19, 0x4c00);
15284         MP_WritePhyUshort(sc, 0x15, 0x03ef);
15285         MP_WritePhyUshort(sc, 0x19, 0xd64f);
15286         MP_WritePhyUshort(sc, 0x15, 0x03f0);
15287         MP_WritePhyUshort(sc, 0x19, 0x000d);
15288         MP_WritePhyUshort(sc, 0x15, 0x03f1);
15289         MP_WritePhyUshort(sc, 0x19, 0x3311);
15290         MP_WritePhyUshort(sc, 0x15, 0x03f2);
15291         MP_WritePhyUshort(sc, 0x19, 0xbd0c);
15292         MP_WritePhyUshort(sc, 0x15, 0x03f3);
15293         MP_WritePhyUshort(sc, 0x19, 0xc428);
15294         MP_WritePhyUshort(sc, 0x15, 0x03f4);
15295         MP_WritePhyUshort(sc, 0x19, 0x0008);
15296         MP_WritePhyUshort(sc, 0x15, 0x03f5);
15297         MP_WritePhyUshort(sc, 0x19, 0x9afa);
15298         MP_WritePhyUshort(sc, 0x15, 0x03f6);
15299         MP_WritePhyUshort(sc, 0x19, 0x7c12);
15300         MP_WritePhyUshort(sc, 0x15, 0x03f7);
15301         MP_WritePhyUshort(sc, 0x19, 0x4c52);
15302         MP_WritePhyUshort(sc, 0x15, 0x03f8);
15303         MP_WritePhyUshort(sc, 0x19, 0x4470);
15304         MP_WritePhyUshort(sc, 0x15, 0x03f9);
15305         MP_WritePhyUshort(sc, 0x19, 0x7c12);
15306         MP_WritePhyUshort(sc, 0x15, 0x03fa);
15307         MP_WritePhyUshort(sc, 0x19, 0x4c40);
15308         MP_WritePhyUshort(sc, 0x15, 0x03fb);
15309         MP_WritePhyUshort(sc, 0x19, 0x33ef);
15310         MP_WritePhyUshort(sc, 0x15, 0x03fc);
15311         MP_WritePhyUshort(sc, 0x19, 0x3342);
15312         MP_WritePhyUshort(sc, 0x15, 0x03fd);
15313         MP_WritePhyUshort(sc, 0x19, 0x330d);
15314         MP_WritePhyUshort(sc, 0x15, 0x03fe);
15315         MP_WritePhyUshort(sc, 0x19, 0x32ae);
15316         MP_WritePhyUshort(sc, 0x15, 0x0000);
15317         MP_WritePhyUshort(sc, 0x16, 0x0306);
15318         MP_WritePhyUshort(sc, 0x16, 0x0300);
15319         MP_WritePhyUshort(sc, 0x1f, 0x0002);
15320         MP_WritePhyUshort(sc, 0x1f, 0x0000);
15321         MP_WritePhyUshort(sc, 0x1f, 0x0005);
15322         MP_WritePhyUshort(sc, 0x05, 0xfff6);
15323         MP_WritePhyUshort(sc, 0x06, 0x0080);
15324         MP_WritePhyUshort(sc, 0x05, 0x8000);
15325         MP_WritePhyUshort(sc, 0x06, 0x0280);
15326         MP_WritePhyUshort(sc, 0x06, 0x48f7);
15327         MP_WritePhyUshort(sc, 0x06, 0x00e0);
15328         MP_WritePhyUshort(sc, 0x06, 0xfff7);
15329         MP_WritePhyUshort(sc, 0x06, 0xa080);
15330         MP_WritePhyUshort(sc, 0x06, 0x02ae);
15331         MP_WritePhyUshort(sc, 0x06, 0xf602);
15332         MP_WritePhyUshort(sc, 0x06, 0x0112);
15333         MP_WritePhyUshort(sc, 0x06, 0x0201);
15334         MP_WritePhyUshort(sc, 0x06, 0x1f02);
15335         MP_WritePhyUshort(sc, 0x06, 0x012c);
15336         MP_WritePhyUshort(sc, 0x06, 0x0201);
15337         MP_WritePhyUshort(sc, 0x06, 0x3c02);
15338         MP_WritePhyUshort(sc, 0x06, 0x0156);
15339         MP_WritePhyUshort(sc, 0x06, 0x0201);
15340         MP_WritePhyUshort(sc, 0x06, 0x6d02);
15341         MP_WritePhyUshort(sc, 0x06, 0x809d);
15342         MP_WritePhyUshort(sc, 0x06, 0xe08b);
15343         MP_WritePhyUshort(sc, 0x06, 0x88e1);
15344         MP_WritePhyUshort(sc, 0x06, 0x8b89);
15345         MP_WritePhyUshort(sc, 0x06, 0x1e01);
15346         MP_WritePhyUshort(sc, 0x06, 0xe18b);
15347         MP_WritePhyUshort(sc, 0x06, 0x8a1e);
15348         MP_WritePhyUshort(sc, 0x06, 0x01e1);
15349         MP_WritePhyUshort(sc, 0x06, 0x8b8b);
15350         MP_WritePhyUshort(sc, 0x06, 0x1e01);
15351         MP_WritePhyUshort(sc, 0x06, 0xe18b);
15352         MP_WritePhyUshort(sc, 0x06, 0x8c1e);
15353         MP_WritePhyUshort(sc, 0x06, 0x01e1);
15354         MP_WritePhyUshort(sc, 0x06, 0x8b8d);
15355         MP_WritePhyUshort(sc, 0x06, 0x1e01);
15356         MP_WritePhyUshort(sc, 0x06, 0xe18b);
15357         MP_WritePhyUshort(sc, 0x06, 0x8e1e);
15358         MP_WritePhyUshort(sc, 0x06, 0x01a0);
15359         MP_WritePhyUshort(sc, 0x06, 0x00c7);
15360         MP_WritePhyUshort(sc, 0x06, 0xaebb);
15361         MP_WritePhyUshort(sc, 0x06, 0xd100);
15362         MP_WritePhyUshort(sc, 0x06, 0xbf82);
15363         MP_WritePhyUshort(sc, 0x06, 0xc702);
15364         MP_WritePhyUshort(sc, 0x06, 0x320a);
15365         MP_WritePhyUshort(sc, 0x06, 0xd105);
15366         MP_WritePhyUshort(sc, 0x06, 0xbf82);
15367         MP_WritePhyUshort(sc, 0x06, 0xcd02);
15368         MP_WritePhyUshort(sc, 0x06, 0x320a);
15369         MP_WritePhyUshort(sc, 0x06, 0xd100);
15370         MP_WritePhyUshort(sc, 0x06, 0xbf82);
15371         MP_WritePhyUshort(sc, 0x06, 0xca02);
15372         MP_WritePhyUshort(sc, 0x06, 0x320a);
15373         MP_WritePhyUshort(sc, 0x06, 0xd105);
15374         MP_WritePhyUshort(sc, 0x06, 0xbf82);
15375         MP_WritePhyUshort(sc, 0x06, 0xd002);
15376         MP_WritePhyUshort(sc, 0x06, 0x320a);
15377         MP_WritePhyUshort(sc, 0x06, 0xd481);
15378         MP_WritePhyUshort(sc, 0x06, 0xc9e4);
15379         MP_WritePhyUshort(sc, 0x06, 0x8b90);
15380         MP_WritePhyUshort(sc, 0x06, 0xe58b);
15381         MP_WritePhyUshort(sc, 0x06, 0x91d4);
15382         MP_WritePhyUshort(sc, 0x06, 0x81b8);
15383         MP_WritePhyUshort(sc, 0x06, 0xe48b);
15384         MP_WritePhyUshort(sc, 0x06, 0x92e5);
15385         MP_WritePhyUshort(sc, 0x06, 0x8b93);
15386         MP_WritePhyUshort(sc, 0x06, 0xbf8b);
15387         MP_WritePhyUshort(sc, 0x06, 0x88ec);
15388         MP_WritePhyUshort(sc, 0x06, 0x0019);
15389         MP_WritePhyUshort(sc, 0x06, 0xa98b);
15390         MP_WritePhyUshort(sc, 0x06, 0x90f9);
15391         MP_WritePhyUshort(sc, 0x06, 0xeeff);
15392         MP_WritePhyUshort(sc, 0x06, 0xf600);
15393         MP_WritePhyUshort(sc, 0x06, 0xeeff);
15394         MP_WritePhyUshort(sc, 0x06, 0xf7fc);
15395         MP_WritePhyUshort(sc, 0x06, 0xd100);
15396         MP_WritePhyUshort(sc, 0x06, 0xbf82);
15397         MP_WritePhyUshort(sc, 0x06, 0xc102);
15398         MP_WritePhyUshort(sc, 0x06, 0x320a);
15399         MP_WritePhyUshort(sc, 0x06, 0xd101);
15400         MP_WritePhyUshort(sc, 0x06, 0xbf82);
15401         MP_WritePhyUshort(sc, 0x06, 0xc402);
15402         MP_WritePhyUshort(sc, 0x06, 0x320a);
15403         MP_WritePhyUshort(sc, 0x06, 0x04f8);
15404         MP_WritePhyUshort(sc, 0x06, 0xe08b);
15405         MP_WritePhyUshort(sc, 0x06, 0x8ead);
15406         MP_WritePhyUshort(sc, 0x06, 0x201a);
15407         MP_WritePhyUshort(sc, 0x06, 0xf620);
15408         MP_WritePhyUshort(sc, 0x06, 0xe48b);
15409         MP_WritePhyUshort(sc, 0x06, 0x8e02);
15410         MP_WritePhyUshort(sc, 0x06, 0x824b);
15411         MP_WritePhyUshort(sc, 0x06, 0x0281);
15412         MP_WritePhyUshort(sc, 0x06, 0x1902);
15413         MP_WritePhyUshort(sc, 0x06, 0x2c9d);
15414         MP_WritePhyUshort(sc, 0x06, 0x0203);
15415         MP_WritePhyUshort(sc, 0x06, 0x9602);
15416         MP_WritePhyUshort(sc, 0x06, 0x0473);
15417         MP_WritePhyUshort(sc, 0x06, 0x022e);
15418         MP_WritePhyUshort(sc, 0x06, 0x3902);
15419         MP_WritePhyUshort(sc, 0x06, 0x044d);
15420         MP_WritePhyUshort(sc, 0x06, 0xe08b);
15421         MP_WritePhyUshort(sc, 0x06, 0x8ead);
15422         MP_WritePhyUshort(sc, 0x06, 0x210b);
15423         MP_WritePhyUshort(sc, 0x06, 0xf621);
15424         MP_WritePhyUshort(sc, 0x06, 0xe48b);
15425         MP_WritePhyUshort(sc, 0x06, 0x8e02);
15426         MP_WritePhyUshort(sc, 0x06, 0x0416);
15427         MP_WritePhyUshort(sc, 0x06, 0x021b);
15428         MP_WritePhyUshort(sc, 0x06, 0xa4e0);
15429         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
15430         MP_WritePhyUshort(sc, 0x06, 0xad22);
15431         MP_WritePhyUshort(sc, 0x06, 0x05f6);
15432         MP_WritePhyUshort(sc, 0x06, 0x22e4);
15433         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
15434         MP_WritePhyUshort(sc, 0x06, 0xe08b);
15435         MP_WritePhyUshort(sc, 0x06, 0x8ead);
15436         MP_WritePhyUshort(sc, 0x06, 0x2305);
15437         MP_WritePhyUshort(sc, 0x06, 0xf623);
15438         MP_WritePhyUshort(sc, 0x06, 0xe48b);
15439         MP_WritePhyUshort(sc, 0x06, 0x8ee0);
15440         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
15441         MP_WritePhyUshort(sc, 0x06, 0xad24);
15442         MP_WritePhyUshort(sc, 0x06, 0x05f6);
15443         MP_WritePhyUshort(sc, 0x06, 0x24e4);
15444         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
15445         MP_WritePhyUshort(sc, 0x06, 0xe08b);
15446         MP_WritePhyUshort(sc, 0x06, 0x8ead);
15447         MP_WritePhyUshort(sc, 0x06, 0x2505);
15448         MP_WritePhyUshort(sc, 0x06, 0xf625);
15449         MP_WritePhyUshort(sc, 0x06, 0xe48b);
15450         MP_WritePhyUshort(sc, 0x06, 0x8ee0);
15451         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
15452         MP_WritePhyUshort(sc, 0x06, 0xad26);
15453         MP_WritePhyUshort(sc, 0x06, 0x08f6);
15454         MP_WritePhyUshort(sc, 0x06, 0x26e4);
15455         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
15456         MP_WritePhyUshort(sc, 0x06, 0x0281);
15457         MP_WritePhyUshort(sc, 0x06, 0xdae0);
15458         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
15459         MP_WritePhyUshort(sc, 0x06, 0xad27);
15460         MP_WritePhyUshort(sc, 0x06, 0x05f6);
15461         MP_WritePhyUshort(sc, 0x06, 0x27e4);
15462         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
15463         MP_WritePhyUshort(sc, 0x06, 0x0203);
15464         MP_WritePhyUshort(sc, 0x06, 0x5cfc);
15465         MP_WritePhyUshort(sc, 0x06, 0x04f8);
15466         MP_WritePhyUshort(sc, 0x06, 0xfaef);
15467         MP_WritePhyUshort(sc, 0x06, 0x69e0);
15468         MP_WritePhyUshort(sc, 0x06, 0x8b85);
15469         MP_WritePhyUshort(sc, 0x06, 0xad21);
15470         MP_WritePhyUshort(sc, 0x06, 0x57e0);
15471         MP_WritePhyUshort(sc, 0x06, 0xe022);
15472         MP_WritePhyUshort(sc, 0x06, 0xe1e0);
15473         MP_WritePhyUshort(sc, 0x06, 0x2358);
15474         MP_WritePhyUshort(sc, 0x06, 0xc059);
15475         MP_WritePhyUshort(sc, 0x06, 0x021e);
15476         MP_WritePhyUshort(sc, 0x06, 0x01e1);
15477         MP_WritePhyUshort(sc, 0x06, 0x8b3c);
15478         MP_WritePhyUshort(sc, 0x06, 0x1f10);
15479         MP_WritePhyUshort(sc, 0x06, 0x9e44);
15480         MP_WritePhyUshort(sc, 0x06, 0xe48b);
15481         MP_WritePhyUshort(sc, 0x06, 0x3cad);
15482         MP_WritePhyUshort(sc, 0x06, 0x211d);
15483         MP_WritePhyUshort(sc, 0x06, 0xe18b);
15484         MP_WritePhyUshort(sc, 0x06, 0x84f7);
15485         MP_WritePhyUshort(sc, 0x06, 0x29e5);
15486         MP_WritePhyUshort(sc, 0x06, 0x8b84);
15487         MP_WritePhyUshort(sc, 0x06, 0xac27);
15488         MP_WritePhyUshort(sc, 0x06, 0x0dac);
15489         MP_WritePhyUshort(sc, 0x06, 0x2605);
15490         MP_WritePhyUshort(sc, 0x06, 0x0281);
15491         MP_WritePhyUshort(sc, 0x06, 0x7fae);
15492         MP_WritePhyUshort(sc, 0x06, 0x2b02);
15493         MP_WritePhyUshort(sc, 0x06, 0x2c23);
15494         MP_WritePhyUshort(sc, 0x06, 0xae26);
15495         MP_WritePhyUshort(sc, 0x06, 0x022c);
15496         MP_WritePhyUshort(sc, 0x06, 0x41ae);
15497         MP_WritePhyUshort(sc, 0x06, 0x21e0);
15498         MP_WritePhyUshort(sc, 0x06, 0x8b87);
15499         MP_WritePhyUshort(sc, 0x06, 0xad22);
15500         MP_WritePhyUshort(sc, 0x06, 0x18e0);
15501         MP_WritePhyUshort(sc, 0x06, 0xfff7);
15502         MP_WritePhyUshort(sc, 0x06, 0x58fc);
15503         MP_WritePhyUshort(sc, 0x06, 0xe4ff);
15504         MP_WritePhyUshort(sc, 0x06, 0xf7d1);
15505         MP_WritePhyUshort(sc, 0x06, 0x00bf);
15506         MP_WritePhyUshort(sc, 0x06, 0x2eee);
15507         MP_WritePhyUshort(sc, 0x06, 0x0232);
15508         MP_WritePhyUshort(sc, 0x06, 0x0ad1);
15509         MP_WritePhyUshort(sc, 0x06, 0x00bf);
15510         MP_WritePhyUshort(sc, 0x06, 0x82e8);
15511         MP_WritePhyUshort(sc, 0x06, 0x0232);
15512         MP_WritePhyUshort(sc, 0x06, 0x0a02);
15513         MP_WritePhyUshort(sc, 0x06, 0x2bdf);
15514         MP_WritePhyUshort(sc, 0x06, 0xef96);
15515         MP_WritePhyUshort(sc, 0x06, 0xfefc);
15516         MP_WritePhyUshort(sc, 0x06, 0x04d0);
15517         MP_WritePhyUshort(sc, 0x06, 0x0202);
15518         MP_WritePhyUshort(sc, 0x06, 0x1e97);
15519         MP_WritePhyUshort(sc, 0x06, 0xe08b);
15520         MP_WritePhyUshort(sc, 0x06, 0x87ad);
15521         MP_WritePhyUshort(sc, 0x06, 0x2228);
15522         MP_WritePhyUshort(sc, 0x06, 0xd100);
15523         MP_WritePhyUshort(sc, 0x06, 0xbf82);
15524         MP_WritePhyUshort(sc, 0x06, 0xd302);
15525         MP_WritePhyUshort(sc, 0x06, 0x320a);
15526         MP_WritePhyUshort(sc, 0x06, 0xd10c);
15527         MP_WritePhyUshort(sc, 0x06, 0xbf82);
15528         MP_WritePhyUshort(sc, 0x06, 0xd602);
15529         MP_WritePhyUshort(sc, 0x06, 0x320a);
15530         MP_WritePhyUshort(sc, 0x06, 0xd104);
15531         MP_WritePhyUshort(sc, 0x06, 0xbf82);
15532         MP_WritePhyUshort(sc, 0x06, 0xd902);
15533         MP_WritePhyUshort(sc, 0x06, 0x320a);
15534         MP_WritePhyUshort(sc, 0x06, 0xd101);
15535         MP_WritePhyUshort(sc, 0x06, 0xbf82);
15536         MP_WritePhyUshort(sc, 0x06, 0xe802);
15537         MP_WritePhyUshort(sc, 0x06, 0x320a);
15538         MP_WritePhyUshort(sc, 0x06, 0xe0ff);
15539         MP_WritePhyUshort(sc, 0x06, 0xf768);
15540         MP_WritePhyUshort(sc, 0x06, 0x03e4);
15541         MP_WritePhyUshort(sc, 0x06, 0xfff7);
15542         MP_WritePhyUshort(sc, 0x06, 0xd004);
15543         MP_WritePhyUshort(sc, 0x06, 0x0228);
15544         MP_WritePhyUshort(sc, 0x06, 0x7a04);
15545         MP_WritePhyUshort(sc, 0x06, 0xf8e0);
15546         MP_WritePhyUshort(sc, 0x06, 0xe234);
15547         MP_WritePhyUshort(sc, 0x06, 0xe1e2);
15548         MP_WritePhyUshort(sc, 0x06, 0x35f6);
15549         MP_WritePhyUshort(sc, 0x06, 0x2be4);
15550         MP_WritePhyUshort(sc, 0x06, 0xe234);
15551         MP_WritePhyUshort(sc, 0x06, 0xe5e2);
15552         MP_WritePhyUshort(sc, 0x06, 0x35fc);
15553         MP_WritePhyUshort(sc, 0x06, 0x05f8);
15554         MP_WritePhyUshort(sc, 0x06, 0xe0e2);
15555         MP_WritePhyUshort(sc, 0x06, 0x34e1);
15556         MP_WritePhyUshort(sc, 0x06, 0xe235);
15557         MP_WritePhyUshort(sc, 0x06, 0xf72b);
15558         MP_WritePhyUshort(sc, 0x06, 0xe4e2);
15559         MP_WritePhyUshort(sc, 0x06, 0x34e5);
15560         MP_WritePhyUshort(sc, 0x06, 0xe235);
15561         MP_WritePhyUshort(sc, 0x06, 0xfc05);
15562         MP_WritePhyUshort(sc, 0x06, 0xf8f9);
15563         MP_WritePhyUshort(sc, 0x06, 0xfaef);
15564         MP_WritePhyUshort(sc, 0x06, 0x69ac);
15565         MP_WritePhyUshort(sc, 0x06, 0x1b4c);
15566         MP_WritePhyUshort(sc, 0x06, 0xbf2e);
15567         MP_WritePhyUshort(sc, 0x06, 0x3002);
15568         MP_WritePhyUshort(sc, 0x06, 0x31dd);
15569         MP_WritePhyUshort(sc, 0x06, 0xef01);
15570         MP_WritePhyUshort(sc, 0x06, 0xe28a);
15571         MP_WritePhyUshort(sc, 0x06, 0x76e4);
15572         MP_WritePhyUshort(sc, 0x06, 0x8a76);
15573         MP_WritePhyUshort(sc, 0x06, 0x1f12);
15574         MP_WritePhyUshort(sc, 0x06, 0x9e3a);
15575         MP_WritePhyUshort(sc, 0x06, 0xef12);
15576         MP_WritePhyUshort(sc, 0x06, 0x5907);
15577         MP_WritePhyUshort(sc, 0x06, 0x9f12);
15578         MP_WritePhyUshort(sc, 0x06, 0xf8e0);
15579         MP_WritePhyUshort(sc, 0x06, 0x8b40);
15580         MP_WritePhyUshort(sc, 0x06, 0xf721);
15581         MP_WritePhyUshort(sc, 0x06, 0xe48b);
15582         MP_WritePhyUshort(sc, 0x06, 0x40d0);
15583         MP_WritePhyUshort(sc, 0x06, 0x0302);
15584         MP_WritePhyUshort(sc, 0x06, 0x287a);
15585         MP_WritePhyUshort(sc, 0x06, 0x0282);
15586         MP_WritePhyUshort(sc, 0x06, 0x34fc);
15587         MP_WritePhyUshort(sc, 0x06, 0xa000);
15588         MP_WritePhyUshort(sc, 0x06, 0x1002);
15589         MP_WritePhyUshort(sc, 0x06, 0x2dc3);
15590         MP_WritePhyUshort(sc, 0x06, 0x022e);
15591         MP_WritePhyUshort(sc, 0x06, 0x21e0);
15592         MP_WritePhyUshort(sc, 0x06, 0x8b40);
15593         MP_WritePhyUshort(sc, 0x06, 0xf621);
15594         MP_WritePhyUshort(sc, 0x06, 0xe48b);
15595         MP_WritePhyUshort(sc, 0x06, 0x40ae);
15596         MP_WritePhyUshort(sc, 0x06, 0x0fbf);
15597         MP_WritePhyUshort(sc, 0x06, 0x3fa5);
15598         MP_WritePhyUshort(sc, 0x06, 0x0231);
15599         MP_WritePhyUshort(sc, 0x06, 0x6cbf);
15600         MP_WritePhyUshort(sc, 0x06, 0x3fa2);
15601         MP_WritePhyUshort(sc, 0x06, 0x0231);
15602         MP_WritePhyUshort(sc, 0x06, 0x6c02);
15603         MP_WritePhyUshort(sc, 0x06, 0x2dc3);
15604         MP_WritePhyUshort(sc, 0x06, 0xef96);
15605         MP_WritePhyUshort(sc, 0x06, 0xfefd);
15606         MP_WritePhyUshort(sc, 0x06, 0xfc04);
15607         MP_WritePhyUshort(sc, 0x06, 0xf8e0);
15608         MP_WritePhyUshort(sc, 0x06, 0xe2f4);
15609         MP_WritePhyUshort(sc, 0x06, 0xe1e2);
15610         MP_WritePhyUshort(sc, 0x06, 0xf5e4);
15611         MP_WritePhyUshort(sc, 0x06, 0x8a78);
15612         MP_WritePhyUshort(sc, 0x06, 0xe58a);
15613         MP_WritePhyUshort(sc, 0x06, 0x79ee);
15614         MP_WritePhyUshort(sc, 0x06, 0xe2f4);
15615         MP_WritePhyUshort(sc, 0x06, 0xd8ee);
15616         MP_WritePhyUshort(sc, 0x06, 0xe2f5);
15617         MP_WritePhyUshort(sc, 0x06, 0x20fc);
15618         MP_WritePhyUshort(sc, 0x06, 0x04f8);
15619         MP_WritePhyUshort(sc, 0x06, 0xf9fa);
15620         MP_WritePhyUshort(sc, 0x06, 0xef69);
15621         MP_WritePhyUshort(sc, 0x06, 0xe08b);
15622         MP_WritePhyUshort(sc, 0x06, 0x87ad);
15623         MP_WritePhyUshort(sc, 0x06, 0x2065);
15624         MP_WritePhyUshort(sc, 0x06, 0xd200);
15625         MP_WritePhyUshort(sc, 0x06, 0xbf2e);
15626         MP_WritePhyUshort(sc, 0x06, 0xe802);
15627         MP_WritePhyUshort(sc, 0x06, 0x31dd);
15628         MP_WritePhyUshort(sc, 0x06, 0x1e21);
15629         MP_WritePhyUshort(sc, 0x06, 0xbf82);
15630         MP_WritePhyUshort(sc, 0x06, 0xdf02);
15631         MP_WritePhyUshort(sc, 0x06, 0x31dd);
15632         MP_WritePhyUshort(sc, 0x06, 0x0c11);
15633         MP_WritePhyUshort(sc, 0x06, 0x1e21);
15634         MP_WritePhyUshort(sc, 0x06, 0xbf82);
15635         MP_WritePhyUshort(sc, 0x06, 0xe202);
15636         MP_WritePhyUshort(sc, 0x06, 0x31dd);
15637         MP_WritePhyUshort(sc, 0x06, 0x0c12);
15638         MP_WritePhyUshort(sc, 0x06, 0x1e21);
15639         MP_WritePhyUshort(sc, 0x06, 0xbf82);
15640         MP_WritePhyUshort(sc, 0x06, 0xe502);
15641         MP_WritePhyUshort(sc, 0x06, 0x31dd);
15642         MP_WritePhyUshort(sc, 0x06, 0x0c13);
15643         MP_WritePhyUshort(sc, 0x06, 0x1e21);
15644         MP_WritePhyUshort(sc, 0x06, 0xbf1f);
15645         MP_WritePhyUshort(sc, 0x06, 0x5302);
15646         MP_WritePhyUshort(sc, 0x06, 0x31dd);
15647         MP_WritePhyUshort(sc, 0x06, 0x0c14);
15648         MP_WritePhyUshort(sc, 0x06, 0x1e21);
15649         MP_WritePhyUshort(sc, 0x06, 0xbf82);
15650         MP_WritePhyUshort(sc, 0x06, 0xeb02);
15651         MP_WritePhyUshort(sc, 0x06, 0x31dd);
15652         MP_WritePhyUshort(sc, 0x06, 0x0c16);
15653         MP_WritePhyUshort(sc, 0x06, 0x1e21);
15654         MP_WritePhyUshort(sc, 0x06, 0xe083);
15655         MP_WritePhyUshort(sc, 0x06, 0xe01f);
15656         MP_WritePhyUshort(sc, 0x06, 0x029e);
15657         MP_WritePhyUshort(sc, 0x06, 0x22e6);
15658         MP_WritePhyUshort(sc, 0x06, 0x83e0);
15659         MP_WritePhyUshort(sc, 0x06, 0xad31);
15660         MP_WritePhyUshort(sc, 0x06, 0x14ad);
15661         MP_WritePhyUshort(sc, 0x06, 0x3011);
15662         MP_WritePhyUshort(sc, 0x06, 0xef02);
15663         MP_WritePhyUshort(sc, 0x06, 0x580c);
15664         MP_WritePhyUshort(sc, 0x06, 0x9e07);
15665         MP_WritePhyUshort(sc, 0x06, 0xad36);
15666         MP_WritePhyUshort(sc, 0x06, 0x085a);
15667         MP_WritePhyUshort(sc, 0x06, 0x309f);
15668         MP_WritePhyUshort(sc, 0x06, 0x04d1);
15669         MP_WritePhyUshort(sc, 0x06, 0x01ae);
15670         MP_WritePhyUshort(sc, 0x06, 0x02d1);
15671         MP_WritePhyUshort(sc, 0x06, 0x00bf);
15672         MP_WritePhyUshort(sc, 0x06, 0x82dc);
15673         MP_WritePhyUshort(sc, 0x06, 0x0232);
15674         MP_WritePhyUshort(sc, 0x06, 0x0aef);
15675         MP_WritePhyUshort(sc, 0x06, 0x96fe);
15676         MP_WritePhyUshort(sc, 0x06, 0xfdfc);
15677         MP_WritePhyUshort(sc, 0x06, 0x0400);
15678         MP_WritePhyUshort(sc, 0x06, 0xe140);
15679         MP_WritePhyUshort(sc, 0x06, 0x77e1);
15680         MP_WritePhyUshort(sc, 0x06, 0x4010);
15681         MP_WritePhyUshort(sc, 0x06, 0xe150);
15682         MP_WritePhyUshort(sc, 0x06, 0x32e1);
15683         MP_WritePhyUshort(sc, 0x06, 0x5030);
15684         MP_WritePhyUshort(sc, 0x06, 0xe144);
15685         MP_WritePhyUshort(sc, 0x06, 0x74e1);
15686         MP_WritePhyUshort(sc, 0x06, 0x44bb);
15687         MP_WritePhyUshort(sc, 0x06, 0xe2d2);
15688         MP_WritePhyUshort(sc, 0x06, 0x40e0);
15689         MP_WritePhyUshort(sc, 0x06, 0x2cfc);
15690         MP_WritePhyUshort(sc, 0x06, 0xe2cc);
15691         MP_WritePhyUshort(sc, 0x06, 0xcce2);
15692         MP_WritePhyUshort(sc, 0x06, 0x00cc);
15693         MP_WritePhyUshort(sc, 0x06, 0xe000);
15694         MP_WritePhyUshort(sc, 0x06, 0x99e0);
15695         MP_WritePhyUshort(sc, 0x06, 0x3688);
15696         MP_WritePhyUshort(sc, 0x06, 0xe036);
15697         MP_WritePhyUshort(sc, 0x06, 0x99e1);
15698         MP_WritePhyUshort(sc, 0x06, 0x40dd);
15699         MP_WritePhyUshort(sc, 0x06, 0xe022);
15700         MP_WritePhyUshort(sc, 0x05, 0xe142);
15701         PhyRegValue = MP_ReadPhyUshort(sc, 0x06);
15702         PhyRegValue |= BIT_0;
15703         MP_WritePhyUshort(sc, 0x06, PhyRegValue);
15704         MP_WritePhyUshort(sc, 0x05, 0xe140);
15705         PhyRegValue = MP_ReadPhyUshort(sc, 0x06);
15706         PhyRegValue |= BIT_0;
15707         MP_WritePhyUshort(sc, 0x06, PhyRegValue);
15708         MP_WritePhyUshort(sc, 0x1f, 0x0000);
15709         MP_WritePhyUshort(sc, 0x1f, 0x0005);
15710         for (i = 0; i < 200; i++) {
15711                 DELAY(100);
15712                 PhyRegValue = MP_ReadPhyUshort(sc, 0x00);
15713                 if (PhyRegValue & BIT_7)
15714                         break;
15715         }
15716
15717         MP_WritePhyUshort(sc, 0x1F, 0x0001);
15718         MP_WritePhyUshort(sc, 0x0B, 0x6C14);
15719         MP_WritePhyUshort(sc, 0x14, 0x7F3D);
15720         MP_WritePhyUshort(sc, 0x1C, 0xFAFE);
15721         MP_WritePhyUshort(sc, 0x08, 0x07C5);
15722         MP_WritePhyUshort(sc, 0x10, 0xF090);
15723         MP_WritePhyUshort(sc, 0x1F, 0x0003);
15724         MP_WritePhyUshort(sc, 0x14, 0x641A);
15725         MP_WritePhyUshort(sc, 0x1A, 0x0606);
15726         MP_WritePhyUshort(sc, 0x12, 0xF480);
15727         MP_WritePhyUshort(sc, 0x13, 0x0747);
15728         MP_WritePhyUshort(sc, 0x1F, 0x0000);
15729
15730         MP_WritePhyUshort(sc, 0x1F, 0x0003);
15731         MP_WritePhyUshort(sc, 0x0D, 0x0207);
15732         MP_WritePhyUshort(sc, 0x02, 0x5FD0);
15733         MP_WritePhyUshort(sc, 0x1F, 0x0000);
15734
15735         MP_WritePhyUshort(sc, 0x1F, 0x0003);
15736         MP_WritePhyUshort(sc, 0x09, 0xA20F);
15737         MP_WritePhyUshort(sc, 0x1F, 0x0000);
15738
15739         MP_WritePhyUshort(sc, 0x1f, 0x0003);
15740         PhyRegValue = MP_ReadPhyUshort(sc, 0x19);
15741         PhyRegValue &= ~BIT_0;
15742         MP_WritePhyUshort(sc, 0x19, PhyRegValue);
15743         PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
15744         PhyRegValue &= ~BIT_10;
15745         MP_WritePhyUshort(sc, 0x10, PhyRegValue);
15746         MP_WritePhyUshort(sc, 0x1f, 0x0000);
15747
15748         MP_WritePhyUshort(sc, 0x1f, 0x0004);
15749         MP_WritePhyUshort(sc, 0x1f, 0x0007);
15750         MP_WritePhyUshort(sc, 0x1e, 0x0023);
15751         PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
15752         PhyRegValue &= ~BIT_0;
15753         PhyRegValue |= BIT_2;
15754         MP_WritePhyUshort(sc, 0x17, PhyRegValue);
15755         MP_WritePhyUshort(sc, 0x1f, 0x0002);
15756         MP_WritePhyUshort(sc, 0x1f, 0x0000);
15757 }
15758
15759 static void re_set_phy_mcu_8168evl_2(struct re_softc *sc)
15760 {
15761         u_int16_t PhyRegValue;
15762         int i;
15763
15764         MP_WritePhyUshort(sc, 0x1f, 0x0000);
15765         MP_WritePhyUshort(sc, 0x00, 0x1800);
15766         PhyRegValue = MP_ReadPhyUshort(sc, 0x15);
15767         PhyRegValue &= ~(BIT_12);
15768         MP_WritePhyUshort(sc, 0x15, PhyRegValue);
15769         MP_WritePhyUshort(sc, 0x00, 0x4800);
15770         MP_WritePhyUshort(sc, 0x1f, 0x0007);
15771         MP_WritePhyUshort(sc, 0x1e, 0x002f);
15772         for (i = 0; i < 1000; i++) {
15773                 if (MP_ReadPhyUshort(sc, 0x1c) & BIT_7)
15774                         break;
15775                 DELAY(100);
15776         }
15777         MP_WritePhyUshort(sc, 0x1f, 0x0000);
15778         MP_WritePhyUshort(sc, 0x00, 0x1800);
15779         MP_WritePhyUshort(sc, 0x1f, 0x0007);
15780         MP_WritePhyUshort(sc, 0x1e, 0x0023);
15781         for (i = 0; i < 200; i++) {
15782                 if ((MP_ReadPhyUshort(sc, 0x17) & BIT_0) == 0)
15783                         break;
15784                 DELAY(100);
15785         }
15786         MP_WritePhyUshort(sc, 0x1f, 0x0005);
15787         MP_WritePhyUshort(sc, 0x05, 0xfff6);
15788         MP_WritePhyUshort(sc, 0x06, 0x0080);
15789         MP_WritePhyUshort(sc, 0x1f, 0x0007);
15790         MP_WritePhyUshort(sc, 0x1e, 0x0023);
15791         MP_WritePhyUshort(sc, 0x16, 0x0306);
15792         MP_WritePhyUshort(sc, 0x16, 0x0307);
15793         MP_WritePhyUshort(sc, 0x15, 0x00AF);
15794         MP_WritePhyUshort(sc, 0x19, 0x4060);
15795         MP_WritePhyUshort(sc, 0x15, 0x00B0);
15796         MP_WritePhyUshort(sc, 0x19, 0x7800);
15797         MP_WritePhyUshort(sc, 0x15, 0x00B1);
15798         MP_WritePhyUshort(sc, 0x19, 0x7e00);
15799         MP_WritePhyUshort(sc, 0x15, 0x00B2);
15800         MP_WritePhyUshort(sc, 0x19, 0x72B0);
15801         MP_WritePhyUshort(sc, 0x15, 0x00B3);
15802         MP_WritePhyUshort(sc, 0x19, 0x7F00);
15803         MP_WritePhyUshort(sc, 0x15, 0x00B4);
15804         MP_WritePhyUshort(sc, 0x19, 0x73B0);
15805         MP_WritePhyUshort(sc, 0x15, 0x0101);
15806         MP_WritePhyUshort(sc, 0x19, 0x0005);
15807         MP_WritePhyUshort(sc, 0x15, 0x0103);
15808         MP_WritePhyUshort(sc, 0x19, 0x0003);
15809         MP_WritePhyUshort(sc, 0x15, 0x0105);
15810         MP_WritePhyUshort(sc, 0x19, 0x30FD);
15811         MP_WritePhyUshort(sc, 0x15, 0x0106);
15812         MP_WritePhyUshort(sc, 0x19, 0x9DF7);
15813         MP_WritePhyUshort(sc, 0x15, 0x0107);
15814         MP_WritePhyUshort(sc, 0x19, 0x30C6);
15815         MP_WritePhyUshort(sc, 0x15, 0x0098);
15816         MP_WritePhyUshort(sc, 0x19, 0x7c0b);
15817         MP_WritePhyUshort(sc, 0x15, 0x0099);
15818         MP_WritePhyUshort(sc, 0x19, 0x6c0b);
15819         MP_WritePhyUshort(sc, 0x15, 0x00eb);
15820         MP_WritePhyUshort(sc, 0x19, 0x6c0b);
15821         MP_WritePhyUshort(sc, 0x15, 0x00f8);
15822         MP_WritePhyUshort(sc, 0x19, 0x6f0b);
15823         MP_WritePhyUshort(sc, 0x15, 0x00fe);
15824         MP_WritePhyUshort(sc, 0x19, 0x6f0f);
15825         MP_WritePhyUshort(sc, 0x15, 0x00db);
15826         MP_WritePhyUshort(sc, 0x19, 0x6f09);
15827         MP_WritePhyUshort(sc, 0x15, 0x00dc);
15828         MP_WritePhyUshort(sc, 0x19, 0xaefd);
15829         MP_WritePhyUshort(sc, 0x15, 0x00dd);
15830         MP_WritePhyUshort(sc, 0x19, 0x6f0b);
15831         MP_WritePhyUshort(sc, 0x15, 0x00de);
15832         MP_WritePhyUshort(sc, 0x19, 0xc60b);
15833         MP_WritePhyUshort(sc, 0x15, 0x00df);
15834         MP_WritePhyUshort(sc, 0x19, 0x00fa);
15835         MP_WritePhyUshort(sc, 0x15, 0x00e0);
15836         MP_WritePhyUshort(sc, 0x19, 0x30e1);
15837         MP_WritePhyUshort(sc, 0x15, 0x020c);
15838         MP_WritePhyUshort(sc, 0x19, 0x3224);
15839         MP_WritePhyUshort(sc, 0x15, 0x020e);
15840         MP_WritePhyUshort(sc, 0x19, 0x9813);
15841         MP_WritePhyUshort(sc, 0x15, 0x020f);
15842         MP_WritePhyUshort(sc, 0x19, 0x7801);
15843         MP_WritePhyUshort(sc, 0x15, 0x0210);
15844         MP_WritePhyUshort(sc, 0x19, 0x930f);
15845         MP_WritePhyUshort(sc, 0x15, 0x0211);
15846         MP_WritePhyUshort(sc, 0x19, 0x9206);
15847         MP_WritePhyUshort(sc, 0x15, 0x0212);
15848         MP_WritePhyUshort(sc, 0x19, 0x4002);
15849         MP_WritePhyUshort(sc, 0x15, 0x0213);
15850         MP_WritePhyUshort(sc, 0x19, 0x7800);
15851         MP_WritePhyUshort(sc, 0x15, 0x0214);
15852         MP_WritePhyUshort(sc, 0x19, 0x588f);
15853         MP_WritePhyUshort(sc, 0x15, 0x0215);
15854         MP_WritePhyUshort(sc, 0x19, 0x5520);
15855         MP_WritePhyUshort(sc, 0x15, 0x0216);
15856         MP_WritePhyUshort(sc, 0x19, 0x3224);
15857         MP_WritePhyUshort(sc, 0x15, 0x0217);
15858         MP_WritePhyUshort(sc, 0x19, 0x4002);
15859         MP_WritePhyUshort(sc, 0x15, 0x0218);
15860         MP_WritePhyUshort(sc, 0x19, 0x7800);
15861         MP_WritePhyUshort(sc, 0x15, 0x0219);
15862         MP_WritePhyUshort(sc, 0x19, 0x588d);
15863         MP_WritePhyUshort(sc, 0x15, 0x021a);
15864         MP_WritePhyUshort(sc, 0x19, 0x5540);
15865         MP_WritePhyUshort(sc, 0x15, 0x021b);
15866         MP_WritePhyUshort(sc, 0x19, 0x9e03);
15867         MP_WritePhyUshort(sc, 0x15, 0x021c);
15868         MP_WritePhyUshort(sc, 0x19, 0x7c40);
15869         MP_WritePhyUshort(sc, 0x15, 0x021d);
15870         MP_WritePhyUshort(sc, 0x19, 0x6840);
15871         MP_WritePhyUshort(sc, 0x15, 0x021e);
15872         MP_WritePhyUshort(sc, 0x19, 0x3224);
15873         MP_WritePhyUshort(sc, 0x15, 0x021f);
15874         MP_WritePhyUshort(sc, 0x19, 0x4002);
15875         MP_WritePhyUshort(sc, 0x15, 0x0220);
15876         MP_WritePhyUshort(sc, 0x19, 0x3224);
15877         MP_WritePhyUshort(sc, 0x15, 0x0221);
15878         MP_WritePhyUshort(sc, 0x19, 0x9e03);
15879         MP_WritePhyUshort(sc, 0x15, 0x0222);
15880         MP_WritePhyUshort(sc, 0x19, 0x7c40);
15881         MP_WritePhyUshort(sc, 0x15, 0x0223);
15882         MP_WritePhyUshort(sc, 0x19, 0x6840);
15883         MP_WritePhyUshort(sc, 0x15, 0x0224);
15884         MP_WritePhyUshort(sc, 0x19, 0x7800);
15885         MP_WritePhyUshort(sc, 0x15, 0x0225);
15886         MP_WritePhyUshort(sc, 0x19, 0x3231);
15887         MP_WritePhyUshort(sc, 0x15, 0x0000);
15888         MP_WritePhyUshort(sc, 0x16, 0x0306);
15889         MP_WritePhyUshort(sc, 0x16, 0x0300);
15890         MP_WritePhyUshort(sc, 0x1f, 0x0002);
15891         MP_WritePhyUshort(sc, 0x1f, 0x0000);
15892         MP_WritePhyUshort(sc, 0x1f, 0x0000);
15893         MP_WritePhyUshort(sc, 0x17, 0x2160);
15894         MP_WritePhyUshort(sc, 0x1f, 0x0007);
15895         MP_WritePhyUshort(sc, 0x1e, 0x0040);
15896         MP_WritePhyUshort(sc, 0x18, 0x0004);
15897         MP_WritePhyUshort(sc, 0x18, 0x09d4);
15898         MP_WritePhyUshort(sc, 0x19, 0x4000);
15899         MP_WritePhyUshort(sc, 0x18, 0x09e4);
15900         MP_WritePhyUshort(sc, 0x19, 0x0800);
15901         MP_WritePhyUshort(sc, 0x18, 0x09f4);
15902         MP_WritePhyUshort(sc, 0x19, 0xff00);
15903         MP_WritePhyUshort(sc, 0x18, 0x0a04);
15904         MP_WritePhyUshort(sc, 0x19, 0x4000);
15905         MP_WritePhyUshort(sc, 0x18, 0x0a14);
15906         MP_WritePhyUshort(sc, 0x19, 0x0c00);
15907         MP_WritePhyUshort(sc, 0x18, 0x0a24);
15908         MP_WritePhyUshort(sc, 0x19, 0xff00);
15909         MP_WritePhyUshort(sc, 0x18, 0x0a74);
15910         MP_WritePhyUshort(sc, 0x19, 0xf600);
15911         MP_WritePhyUshort(sc, 0x18, 0x1a24);
15912         MP_WritePhyUshort(sc, 0x19, 0x7d00);
15913         MP_WritePhyUshort(sc, 0x18, 0x1a64);
15914         MP_WritePhyUshort(sc, 0x19, 0x0500);
15915         MP_WritePhyUshort(sc, 0x18, 0x1a74);
15916         MP_WritePhyUshort(sc, 0x19, 0x9500);
15917         MP_WritePhyUshort(sc, 0x18, 0x1a84);
15918         MP_WritePhyUshort(sc, 0x19, 0x8000);
15919         MP_WritePhyUshort(sc, 0x18, 0x1a94);
15920         MP_WritePhyUshort(sc, 0x19, 0x7d00);
15921         MP_WritePhyUshort(sc, 0x18, 0x1aa4);
15922         MP_WritePhyUshort(sc, 0x19, 0x9600);
15923         MP_WritePhyUshort(sc, 0x18, 0x1ac4);
15924         MP_WritePhyUshort(sc, 0x19, 0x4000);
15925         MP_WritePhyUshort(sc, 0x18, 0x1ad4);
15926         MP_WritePhyUshort(sc, 0x19, 0x0800);
15927         MP_WritePhyUshort(sc, 0x18, 0x1af4);
15928         MP_WritePhyUshort(sc, 0x19, 0xc400);
15929         MP_WritePhyUshort(sc, 0x18, 0x1b04);
15930         MP_WritePhyUshort(sc, 0x19, 0x4000);
15931         MP_WritePhyUshort(sc, 0x18, 0x1b14);
15932         MP_WritePhyUshort(sc, 0x19, 0x0800);
15933         MP_WritePhyUshort(sc, 0x18, 0x1b24);
15934         MP_WritePhyUshort(sc, 0x19, 0xfd00);
15935         MP_WritePhyUshort(sc, 0x18, 0x1b34);
15936         MP_WritePhyUshort(sc, 0x19, 0x4000);
15937         MP_WritePhyUshort(sc, 0x18, 0x1b44);
15938         MP_WritePhyUshort(sc, 0x19, 0x0400);
15939         MP_WritePhyUshort(sc, 0x18, 0x1b94);
15940         MP_WritePhyUshort(sc, 0x19, 0xf100);
15941         MP_WritePhyUshort(sc, 0x1f, 0x0000);
15942         MP_WritePhyUshort(sc, 0x17, 0x2100);
15943         MP_WritePhyUshort(sc, 0x1f, 0x0007);
15944         MP_WritePhyUshort(sc, 0x1e, 0x0040);
15945         MP_WritePhyUshort(sc, 0x18, 0x0000);
15946         MP_WritePhyUshort(sc, 0x1f, 0x0000);
15947         MP_WritePhyUshort(sc, 0x1f, 0x0005);
15948         MP_WritePhyUshort(sc, 0x05, 0xfff6);
15949         MP_WritePhyUshort(sc, 0x06, 0x0080);
15950         MP_WritePhyUshort(sc, 0x05, 0x8000);
15951         MP_WritePhyUshort(sc, 0x06, 0x0280);
15952         MP_WritePhyUshort(sc, 0x06, 0x48f7);
15953         MP_WritePhyUshort(sc, 0x06, 0x00e0);
15954         MP_WritePhyUshort(sc, 0x06, 0xfff7);
15955         MP_WritePhyUshort(sc, 0x06, 0xa080);
15956         MP_WritePhyUshort(sc, 0x06, 0x02ae);
15957         MP_WritePhyUshort(sc, 0x06, 0xf602);
15958         MP_WritePhyUshort(sc, 0x06, 0x0115);
15959         MP_WritePhyUshort(sc, 0x06, 0x0201);
15960         MP_WritePhyUshort(sc, 0x06, 0x2202);
15961         MP_WritePhyUshort(sc, 0x06, 0x80a0);
15962         MP_WritePhyUshort(sc, 0x06, 0x0201);
15963         MP_WritePhyUshort(sc, 0x06, 0x3f02);
15964         MP_WritePhyUshort(sc, 0x06, 0x0159);
15965         MP_WritePhyUshort(sc, 0x06, 0x0280);
15966         MP_WritePhyUshort(sc, 0x06, 0xbd02);
15967         MP_WritePhyUshort(sc, 0x06, 0x80da);
15968         MP_WritePhyUshort(sc, 0x06, 0xe08b);
15969         MP_WritePhyUshort(sc, 0x06, 0x88e1);
15970         MP_WritePhyUshort(sc, 0x06, 0x8b89);
15971         MP_WritePhyUshort(sc, 0x06, 0x1e01);
15972         MP_WritePhyUshort(sc, 0x06, 0xe18b);
15973         MP_WritePhyUshort(sc, 0x06, 0x8a1e);
15974         MP_WritePhyUshort(sc, 0x06, 0x01e1);
15975         MP_WritePhyUshort(sc, 0x06, 0x8b8b);
15976         MP_WritePhyUshort(sc, 0x06, 0x1e01);
15977         MP_WritePhyUshort(sc, 0x06, 0xe18b);
15978         MP_WritePhyUshort(sc, 0x06, 0x8c1e);
15979         MP_WritePhyUshort(sc, 0x06, 0x01e1);
15980         MP_WritePhyUshort(sc, 0x06, 0x8b8d);
15981         MP_WritePhyUshort(sc, 0x06, 0x1e01);
15982         MP_WritePhyUshort(sc, 0x06, 0xe18b);
15983         MP_WritePhyUshort(sc, 0x06, 0x8e1e);
15984         MP_WritePhyUshort(sc, 0x06, 0x01a0);
15985         MP_WritePhyUshort(sc, 0x06, 0x00c7);
15986         MP_WritePhyUshort(sc, 0x06, 0xaebb);
15987         MP_WritePhyUshort(sc, 0x06, 0xd481);
15988         MP_WritePhyUshort(sc, 0x06, 0xd2e4);
15989         MP_WritePhyUshort(sc, 0x06, 0x8b92);
15990         MP_WritePhyUshort(sc, 0x06, 0xe58b);
15991         MP_WritePhyUshort(sc, 0x06, 0x93d1);
15992         MP_WritePhyUshort(sc, 0x06, 0x03bf);
15993         MP_WritePhyUshort(sc, 0x06, 0x859e);
15994         MP_WritePhyUshort(sc, 0x06, 0x0237);
15995         MP_WritePhyUshort(sc, 0x06, 0x23d1);
15996         MP_WritePhyUshort(sc, 0x06, 0x02bf);
15997         MP_WritePhyUshort(sc, 0x06, 0x85a1);
15998         MP_WritePhyUshort(sc, 0x06, 0x0237);
15999         MP_WritePhyUshort(sc, 0x06, 0x23ee);
16000         MP_WritePhyUshort(sc, 0x06, 0x8608);
16001         MP_WritePhyUshort(sc, 0x06, 0x03ee);
16002         MP_WritePhyUshort(sc, 0x06, 0x860a);
16003         MP_WritePhyUshort(sc, 0x06, 0x60ee);
16004         MP_WritePhyUshort(sc, 0x06, 0x8610);
16005         MP_WritePhyUshort(sc, 0x06, 0x00ee);
16006         MP_WritePhyUshort(sc, 0x06, 0x8611);
16007         MP_WritePhyUshort(sc, 0x06, 0x00ee);
16008         MP_WritePhyUshort(sc, 0x06, 0x8abe);
16009         MP_WritePhyUshort(sc, 0x06, 0x07ee);
16010         MP_WritePhyUshort(sc, 0x06, 0x8abf);
16011         MP_WritePhyUshort(sc, 0x06, 0x73ee);
16012         MP_WritePhyUshort(sc, 0x06, 0x8a95);
16013         MP_WritePhyUshort(sc, 0x06, 0x02bf);
16014         MP_WritePhyUshort(sc, 0x06, 0x8b88);
16015         MP_WritePhyUshort(sc, 0x06, 0xec00);
16016         MP_WritePhyUshort(sc, 0x06, 0x19a9);
16017         MP_WritePhyUshort(sc, 0x06, 0x8b90);
16018         MP_WritePhyUshort(sc, 0x06, 0xf9ee);
16019         MP_WritePhyUshort(sc, 0x06, 0xfff6);
16020         MP_WritePhyUshort(sc, 0x06, 0x00ee);
16021         MP_WritePhyUshort(sc, 0x06, 0xfff7);
16022         MP_WritePhyUshort(sc, 0x06, 0xfed1);
16023         MP_WritePhyUshort(sc, 0x06, 0x00bf);
16024         MP_WritePhyUshort(sc, 0x06, 0x8595);
16025         MP_WritePhyUshort(sc, 0x06, 0x0237);
16026         MP_WritePhyUshort(sc, 0x06, 0x23d1);
16027         MP_WritePhyUshort(sc, 0x06, 0x01bf);
16028         MP_WritePhyUshort(sc, 0x06, 0x8598);
16029         MP_WritePhyUshort(sc, 0x06, 0x0237);
16030         MP_WritePhyUshort(sc, 0x06, 0x2304);
16031         MP_WritePhyUshort(sc, 0x06, 0xf8e0);
16032         MP_WritePhyUshort(sc, 0x06, 0x8b8a);
16033         MP_WritePhyUshort(sc, 0x06, 0xad20);
16034         MP_WritePhyUshort(sc, 0x06, 0x14ee);
16035         MP_WritePhyUshort(sc, 0x06, 0x8b8a);
16036         MP_WritePhyUshort(sc, 0x06, 0x0002);
16037         MP_WritePhyUshort(sc, 0x06, 0x1f9a);
16038         MP_WritePhyUshort(sc, 0x06, 0xe0e4);
16039         MP_WritePhyUshort(sc, 0x06, 0x26e1);
16040         MP_WritePhyUshort(sc, 0x06, 0xe427);
16041         MP_WritePhyUshort(sc, 0x06, 0xeee4);
16042         MP_WritePhyUshort(sc, 0x06, 0x2623);
16043         MP_WritePhyUshort(sc, 0x06, 0xe5e4);
16044         MP_WritePhyUshort(sc, 0x06, 0x27fc);
16045         MP_WritePhyUshort(sc, 0x06, 0x04f8);
16046         MP_WritePhyUshort(sc, 0x06, 0xe08b);
16047         MP_WritePhyUshort(sc, 0x06, 0x8dad);
16048         MP_WritePhyUshort(sc, 0x06, 0x2014);
16049         MP_WritePhyUshort(sc, 0x06, 0xee8b);
16050         MP_WritePhyUshort(sc, 0x06, 0x8d00);
16051         MP_WritePhyUshort(sc, 0x06, 0xe08a);
16052         MP_WritePhyUshort(sc, 0x06, 0x5a78);
16053         MP_WritePhyUshort(sc, 0x06, 0x039e);
16054         MP_WritePhyUshort(sc, 0x06, 0x0902);
16055         MP_WritePhyUshort(sc, 0x06, 0x05db);
16056         MP_WritePhyUshort(sc, 0x06, 0x0282);
16057         MP_WritePhyUshort(sc, 0x06, 0x7b02);
16058         MP_WritePhyUshort(sc, 0x06, 0x3231);
16059         MP_WritePhyUshort(sc, 0x06, 0xfc04);
16060         MP_WritePhyUshort(sc, 0x06, 0xf8e0);
16061         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16062         MP_WritePhyUshort(sc, 0x06, 0xad20);
16063         MP_WritePhyUshort(sc, 0x06, 0x1df6);
16064         MP_WritePhyUshort(sc, 0x06, 0x20e4);
16065         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16066         MP_WritePhyUshort(sc, 0x06, 0x0281);
16067         MP_WritePhyUshort(sc, 0x06, 0x5c02);
16068         MP_WritePhyUshort(sc, 0x06, 0x2bcb);
16069         MP_WritePhyUshort(sc, 0x06, 0x022d);
16070         MP_WritePhyUshort(sc, 0x06, 0x2902);
16071         MP_WritePhyUshort(sc, 0x06, 0x03b4);
16072         MP_WritePhyUshort(sc, 0x06, 0x0285);
16073         MP_WritePhyUshort(sc, 0x06, 0x6402);
16074         MP_WritePhyUshort(sc, 0x06, 0x2eca);
16075         MP_WritePhyUshort(sc, 0x06, 0x0284);
16076         MP_WritePhyUshort(sc, 0x06, 0xcd02);
16077         MP_WritePhyUshort(sc, 0x06, 0x046f);
16078         MP_WritePhyUshort(sc, 0x06, 0xe08b);
16079         MP_WritePhyUshort(sc, 0x06, 0x8ead);
16080         MP_WritePhyUshort(sc, 0x06, 0x210b);
16081         MP_WritePhyUshort(sc, 0x06, 0xf621);
16082         MP_WritePhyUshort(sc, 0x06, 0xe48b);
16083         MP_WritePhyUshort(sc, 0x06, 0x8e02);
16084         MP_WritePhyUshort(sc, 0x06, 0x8520);
16085         MP_WritePhyUshort(sc, 0x06, 0x021b);
16086         MP_WritePhyUshort(sc, 0x06, 0xe8e0);
16087         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16088         MP_WritePhyUshort(sc, 0x06, 0xad22);
16089         MP_WritePhyUshort(sc, 0x06, 0x05f6);
16090         MP_WritePhyUshort(sc, 0x06, 0x22e4);
16091         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16092         MP_WritePhyUshort(sc, 0x06, 0xe08b);
16093         MP_WritePhyUshort(sc, 0x06, 0x8ead);
16094         MP_WritePhyUshort(sc, 0x06, 0x2308);
16095         MP_WritePhyUshort(sc, 0x06, 0xf623);
16096         MP_WritePhyUshort(sc, 0x06, 0xe48b);
16097         MP_WritePhyUshort(sc, 0x06, 0x8e02);
16098         MP_WritePhyUshort(sc, 0x06, 0x311c);
16099         MP_WritePhyUshort(sc, 0x06, 0xe08b);
16100         MP_WritePhyUshort(sc, 0x06, 0x8ead);
16101         MP_WritePhyUshort(sc, 0x06, 0x2405);
16102         MP_WritePhyUshort(sc, 0x06, 0xf624);
16103         MP_WritePhyUshort(sc, 0x06, 0xe48b);
16104         MP_WritePhyUshort(sc, 0x06, 0x8ee0);
16105         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16106         MP_WritePhyUshort(sc, 0x06, 0xad25);
16107         MP_WritePhyUshort(sc, 0x06, 0x05f6);
16108         MP_WritePhyUshort(sc, 0x06, 0x25e4);
16109         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16110         MP_WritePhyUshort(sc, 0x06, 0xe08b);
16111         MP_WritePhyUshort(sc, 0x06, 0x8ead);
16112         MP_WritePhyUshort(sc, 0x06, 0x2608);
16113         MP_WritePhyUshort(sc, 0x06, 0xf626);
16114         MP_WritePhyUshort(sc, 0x06, 0xe48b);
16115         MP_WritePhyUshort(sc, 0x06, 0x8e02);
16116         MP_WritePhyUshort(sc, 0x06, 0x2df5);
16117         MP_WritePhyUshort(sc, 0x06, 0xe08b);
16118         MP_WritePhyUshort(sc, 0x06, 0x8ead);
16119         MP_WritePhyUshort(sc, 0x06, 0x2705);
16120         MP_WritePhyUshort(sc, 0x06, 0xf627);
16121         MP_WritePhyUshort(sc, 0x06, 0xe48b);
16122         MP_WritePhyUshort(sc, 0x06, 0x8e02);
16123         MP_WritePhyUshort(sc, 0x06, 0x037a);
16124         MP_WritePhyUshort(sc, 0x06, 0xfc04);
16125         MP_WritePhyUshort(sc, 0x06, 0xf8f9);
16126         MP_WritePhyUshort(sc, 0x06, 0xfaef);
16127         MP_WritePhyUshort(sc, 0x06, 0x69e0);
16128         MP_WritePhyUshort(sc, 0x06, 0x8b87);
16129         MP_WritePhyUshort(sc, 0x06, 0xad20);
16130         MP_WritePhyUshort(sc, 0x06, 0x65d2);
16131         MP_WritePhyUshort(sc, 0x06, 0x00bf);
16132         MP_WritePhyUshort(sc, 0x06, 0x2fe9);
16133         MP_WritePhyUshort(sc, 0x06, 0x0236);
16134         MP_WritePhyUshort(sc, 0x06, 0xf61e);
16135         MP_WritePhyUshort(sc, 0x06, 0x21bf);
16136         MP_WritePhyUshort(sc, 0x06, 0x2ff5);
16137         MP_WritePhyUshort(sc, 0x06, 0x0236);
16138         MP_WritePhyUshort(sc, 0x06, 0xf60c);
16139         MP_WritePhyUshort(sc, 0x06, 0x111e);
16140         MP_WritePhyUshort(sc, 0x06, 0x21bf);
16141         MP_WritePhyUshort(sc, 0x06, 0x2ff8);
16142         MP_WritePhyUshort(sc, 0x06, 0x0236);
16143         MP_WritePhyUshort(sc, 0x06, 0xf60c);
16144         MP_WritePhyUshort(sc, 0x06, 0x121e);
16145         MP_WritePhyUshort(sc, 0x06, 0x21bf);
16146         MP_WritePhyUshort(sc, 0x06, 0x2ffb);
16147         MP_WritePhyUshort(sc, 0x06, 0x0236);
16148         MP_WritePhyUshort(sc, 0x06, 0xf60c);
16149         MP_WritePhyUshort(sc, 0x06, 0x131e);
16150         MP_WritePhyUshort(sc, 0x06, 0x21bf);
16151         MP_WritePhyUshort(sc, 0x06, 0x1f97);
16152         MP_WritePhyUshort(sc, 0x06, 0x0236);
16153         MP_WritePhyUshort(sc, 0x06, 0xf60c);
16154         MP_WritePhyUshort(sc, 0x06, 0x141e);
16155         MP_WritePhyUshort(sc, 0x06, 0x21bf);
16156         MP_WritePhyUshort(sc, 0x06, 0x859b);
16157         MP_WritePhyUshort(sc, 0x06, 0x0236);
16158         MP_WritePhyUshort(sc, 0x06, 0xf60c);
16159         MP_WritePhyUshort(sc, 0x06, 0x161e);
16160         MP_WritePhyUshort(sc, 0x06, 0x21e0);
16161         MP_WritePhyUshort(sc, 0x06, 0x8a8c);
16162         MP_WritePhyUshort(sc, 0x06, 0x1f02);
16163         MP_WritePhyUshort(sc, 0x06, 0x9e22);
16164         MP_WritePhyUshort(sc, 0x06, 0xe68a);
16165         MP_WritePhyUshort(sc, 0x06, 0x8cad);
16166         MP_WritePhyUshort(sc, 0x06, 0x3114);
16167         MP_WritePhyUshort(sc, 0x06, 0xad30);
16168         MP_WritePhyUshort(sc, 0x06, 0x11ef);
16169         MP_WritePhyUshort(sc, 0x06, 0x0258);
16170         MP_WritePhyUshort(sc, 0x06, 0x0c9e);
16171         MP_WritePhyUshort(sc, 0x06, 0x07ad);
16172         MP_WritePhyUshort(sc, 0x06, 0x3608);
16173         MP_WritePhyUshort(sc, 0x06, 0x5a30);
16174         MP_WritePhyUshort(sc, 0x06, 0x9f04);
16175         MP_WritePhyUshort(sc, 0x06, 0xd101);
16176         MP_WritePhyUshort(sc, 0x06, 0xae02);
16177         MP_WritePhyUshort(sc, 0x06, 0xd100);
16178         MP_WritePhyUshort(sc, 0x06, 0xbf2f);
16179         MP_WritePhyUshort(sc, 0x06, 0xf202);
16180         MP_WritePhyUshort(sc, 0x06, 0x3723);
16181         MP_WritePhyUshort(sc, 0x06, 0xef96);
16182         MP_WritePhyUshort(sc, 0x06, 0xfefd);
16183         MP_WritePhyUshort(sc, 0x06, 0xfc04);
16184         MP_WritePhyUshort(sc, 0x06, 0xf8f9);
16185         MP_WritePhyUshort(sc, 0x06, 0xface);
16186         MP_WritePhyUshort(sc, 0x06, 0xfaef);
16187         MP_WritePhyUshort(sc, 0x06, 0x69fa);
16188         MP_WritePhyUshort(sc, 0x06, 0xd401);
16189         MP_WritePhyUshort(sc, 0x06, 0x55b4);
16190         MP_WritePhyUshort(sc, 0x06, 0xfebf);
16191         MP_WritePhyUshort(sc, 0x06, 0x85a7);
16192         MP_WritePhyUshort(sc, 0x06, 0x0236);
16193         MP_WritePhyUshort(sc, 0x06, 0xf6ac);
16194         MP_WritePhyUshort(sc, 0x06, 0x280b);
16195         MP_WritePhyUshort(sc, 0x06, 0xbf85);
16196         MP_WritePhyUshort(sc, 0x06, 0xa402);
16197         MP_WritePhyUshort(sc, 0x06, 0x36f6);
16198         MP_WritePhyUshort(sc, 0x06, 0xac28);
16199         MP_WritePhyUshort(sc, 0x06, 0x49ae);
16200         MP_WritePhyUshort(sc, 0x06, 0x64bf);
16201         MP_WritePhyUshort(sc, 0x06, 0x85a4);
16202         MP_WritePhyUshort(sc, 0x06, 0x0236);
16203         MP_WritePhyUshort(sc, 0x06, 0xf6ac);
16204         MP_WritePhyUshort(sc, 0x06, 0x285b);
16205         MP_WritePhyUshort(sc, 0x06, 0xd000);
16206         MP_WritePhyUshort(sc, 0x06, 0x0282);
16207         MP_WritePhyUshort(sc, 0x06, 0x60ac);
16208         MP_WritePhyUshort(sc, 0x06, 0x2105);
16209         MP_WritePhyUshort(sc, 0x06, 0xac22);
16210         MP_WritePhyUshort(sc, 0x06, 0x02ae);
16211         MP_WritePhyUshort(sc, 0x06, 0x4ebf);
16212         MP_WritePhyUshort(sc, 0x06, 0xe0c4);
16213         MP_WritePhyUshort(sc, 0x06, 0xbe86);
16214         MP_WritePhyUshort(sc, 0x06, 0x14d2);
16215         MP_WritePhyUshort(sc, 0x06, 0x04d8);
16216         MP_WritePhyUshort(sc, 0x06, 0x19d9);
16217         MP_WritePhyUshort(sc, 0x06, 0x1907);
16218         MP_WritePhyUshort(sc, 0x06, 0xdc19);
16219         MP_WritePhyUshort(sc, 0x06, 0xdd19);
16220         MP_WritePhyUshort(sc, 0x06, 0x0789);
16221         MP_WritePhyUshort(sc, 0x06, 0x89ef);
16222         MP_WritePhyUshort(sc, 0x06, 0x645e);
16223         MP_WritePhyUshort(sc, 0x06, 0x07ff);
16224         MP_WritePhyUshort(sc, 0x06, 0x0d65);
16225         MP_WritePhyUshort(sc, 0x06, 0x5cf8);
16226         MP_WritePhyUshort(sc, 0x06, 0x001e);
16227         MP_WritePhyUshort(sc, 0x06, 0x46dc);
16228         MP_WritePhyUshort(sc, 0x06, 0x19dd);
16229         MP_WritePhyUshort(sc, 0x06, 0x19b2);
16230         MP_WritePhyUshort(sc, 0x06, 0xe2d4);
16231         MP_WritePhyUshort(sc, 0x06, 0x0001);
16232         MP_WritePhyUshort(sc, 0x06, 0xbf85);
16233         MP_WritePhyUshort(sc, 0x06, 0xa402);
16234         MP_WritePhyUshort(sc, 0x06, 0x3723);
16235         MP_WritePhyUshort(sc, 0x06, 0xae1d);
16236         MP_WritePhyUshort(sc, 0x06, 0xbee0);
16237         MP_WritePhyUshort(sc, 0x06, 0xc4bf);
16238         MP_WritePhyUshort(sc, 0x06, 0x8614);
16239         MP_WritePhyUshort(sc, 0x06, 0xd204);
16240         MP_WritePhyUshort(sc, 0x06, 0xd819);
16241         MP_WritePhyUshort(sc, 0x06, 0xd919);
16242         MP_WritePhyUshort(sc, 0x06, 0x07dc);
16243         MP_WritePhyUshort(sc, 0x06, 0x19dd);
16244         MP_WritePhyUshort(sc, 0x06, 0x1907);
16245         MP_WritePhyUshort(sc, 0x06, 0xb2f4);
16246         MP_WritePhyUshort(sc, 0x06, 0xd400);
16247         MP_WritePhyUshort(sc, 0x06, 0x00bf);
16248         MP_WritePhyUshort(sc, 0x06, 0x85a4);
16249         MP_WritePhyUshort(sc, 0x06, 0x0237);
16250         MP_WritePhyUshort(sc, 0x06, 0x23fe);
16251         MP_WritePhyUshort(sc, 0x06, 0xef96);
16252         MP_WritePhyUshort(sc, 0x06, 0xfec6);
16253         MP_WritePhyUshort(sc, 0x06, 0xfefd);
16254         MP_WritePhyUshort(sc, 0x06, 0xfc05);
16255         MP_WritePhyUshort(sc, 0x06, 0xf9e2);
16256         MP_WritePhyUshort(sc, 0x06, 0xe0ea);
16257         MP_WritePhyUshort(sc, 0x06, 0xe3e0);
16258         MP_WritePhyUshort(sc, 0x06, 0xeb5a);
16259         MP_WritePhyUshort(sc, 0x06, 0x070c);
16260         MP_WritePhyUshort(sc, 0x06, 0x031e);
16261         MP_WritePhyUshort(sc, 0x06, 0x20e6);
16262         MP_WritePhyUshort(sc, 0x06, 0xe0ea);
16263         MP_WritePhyUshort(sc, 0x06, 0xe7e0);
16264         MP_WritePhyUshort(sc, 0x06, 0xebe0);
16265         MP_WritePhyUshort(sc, 0x06, 0xe0fc);
16266         MP_WritePhyUshort(sc, 0x06, 0xe1e0);
16267         MP_WritePhyUshort(sc, 0x06, 0xfdfd);
16268         MP_WritePhyUshort(sc, 0x06, 0x04f8);
16269         MP_WritePhyUshort(sc, 0x06, 0xf9e0);
16270         MP_WritePhyUshort(sc, 0x06, 0x8b81);
16271         MP_WritePhyUshort(sc, 0x06, 0xac26);
16272         MP_WritePhyUshort(sc, 0x06, 0x1ae0);
16273         MP_WritePhyUshort(sc, 0x06, 0x8b81);
16274         MP_WritePhyUshort(sc, 0x06, 0xac21);
16275         MP_WritePhyUshort(sc, 0x06, 0x14e0);
16276         MP_WritePhyUshort(sc, 0x06, 0x8b85);
16277         MP_WritePhyUshort(sc, 0x06, 0xac20);
16278         MP_WritePhyUshort(sc, 0x06, 0x0ee0);
16279         MP_WritePhyUshort(sc, 0x06, 0x8b85);
16280         MP_WritePhyUshort(sc, 0x06, 0xac23);
16281         MP_WritePhyUshort(sc, 0x06, 0x08e0);
16282         MP_WritePhyUshort(sc, 0x06, 0x8b87);
16283         MP_WritePhyUshort(sc, 0x06, 0xac24);
16284         MP_WritePhyUshort(sc, 0x06, 0x02ae);
16285         MP_WritePhyUshort(sc, 0x06, 0x3802);
16286         MP_WritePhyUshort(sc, 0x06, 0x1ab5);
16287         MP_WritePhyUshort(sc, 0x06, 0xeee4);
16288         MP_WritePhyUshort(sc, 0x06, 0x1c04);
16289         MP_WritePhyUshort(sc, 0x06, 0xeee4);
16290         MP_WritePhyUshort(sc, 0x06, 0x1d04);
16291         MP_WritePhyUshort(sc, 0x06, 0xe2e0);
16292         MP_WritePhyUshort(sc, 0x06, 0x7ce3);
16293         MP_WritePhyUshort(sc, 0x06, 0xe07d);
16294         MP_WritePhyUshort(sc, 0x06, 0xe0e0);
16295         MP_WritePhyUshort(sc, 0x06, 0x38e1);
16296         MP_WritePhyUshort(sc, 0x06, 0xe039);
16297         MP_WritePhyUshort(sc, 0x06, 0xad2e);
16298         MP_WritePhyUshort(sc, 0x06, 0x1bad);
16299         MP_WritePhyUshort(sc, 0x06, 0x390d);
16300         MP_WritePhyUshort(sc, 0x06, 0xd101);
16301         MP_WritePhyUshort(sc, 0x06, 0xbf21);
16302         MP_WritePhyUshort(sc, 0x06, 0xd502);
16303         MP_WritePhyUshort(sc, 0x06, 0x3723);
16304         MP_WritePhyUshort(sc, 0x06, 0x0282);
16305         MP_WritePhyUshort(sc, 0x06, 0xd8ae);
16306         MP_WritePhyUshort(sc, 0x06, 0x0bac);
16307         MP_WritePhyUshort(sc, 0x06, 0x3802);
16308         MP_WritePhyUshort(sc, 0x06, 0xae06);
16309         MP_WritePhyUshort(sc, 0x06, 0x0283);
16310         MP_WritePhyUshort(sc, 0x06, 0x1802);
16311         MP_WritePhyUshort(sc, 0x06, 0x8360);
16312         MP_WritePhyUshort(sc, 0x06, 0x021a);
16313         MP_WritePhyUshort(sc, 0x06, 0xc6fd);
16314         MP_WritePhyUshort(sc, 0x06, 0xfc04);
16315         MP_WritePhyUshort(sc, 0x06, 0xf8e1);
16316         MP_WritePhyUshort(sc, 0x06, 0x8af4);
16317         MP_WritePhyUshort(sc, 0x06, 0xe08b);
16318         MP_WritePhyUshort(sc, 0x06, 0x81ad);
16319         MP_WritePhyUshort(sc, 0x06, 0x2605);
16320         MP_WritePhyUshort(sc, 0x06, 0x0222);
16321         MP_WritePhyUshort(sc, 0x06, 0xa4f7);
16322         MP_WritePhyUshort(sc, 0x06, 0x28e0);
16323         MP_WritePhyUshort(sc, 0x06, 0x8b81);
16324         MP_WritePhyUshort(sc, 0x06, 0xad21);
16325         MP_WritePhyUshort(sc, 0x06, 0x0502);
16326         MP_WritePhyUshort(sc, 0x06, 0x23a9);
16327         MP_WritePhyUshort(sc, 0x06, 0xf729);
16328         MP_WritePhyUshort(sc, 0x06, 0xe08b);
16329         MP_WritePhyUshort(sc, 0x06, 0x85ad);
16330         MP_WritePhyUshort(sc, 0x06, 0x2005);
16331         MP_WritePhyUshort(sc, 0x06, 0x0214);
16332         MP_WritePhyUshort(sc, 0x06, 0xabf7);
16333         MP_WritePhyUshort(sc, 0x06, 0x2ae0);
16334         MP_WritePhyUshort(sc, 0x06, 0x8b85);
16335         MP_WritePhyUshort(sc, 0x06, 0xad23);
16336         MP_WritePhyUshort(sc, 0x06, 0x0502);
16337         MP_WritePhyUshort(sc, 0x06, 0x12e7);
16338         MP_WritePhyUshort(sc, 0x06, 0xf72b);
16339         MP_WritePhyUshort(sc, 0x06, 0xe08b);
16340         MP_WritePhyUshort(sc, 0x06, 0x87ad);
16341         MP_WritePhyUshort(sc, 0x06, 0x2405);
16342         MP_WritePhyUshort(sc, 0x06, 0x0283);
16343         MP_WritePhyUshort(sc, 0x06, 0xbcf7);
16344         MP_WritePhyUshort(sc, 0x06, 0x2ce5);
16345         MP_WritePhyUshort(sc, 0x06, 0x8af4);
16346         MP_WritePhyUshort(sc, 0x06, 0xfc04);
16347         MP_WritePhyUshort(sc, 0x06, 0xf8e0);
16348         MP_WritePhyUshort(sc, 0x06, 0x8b81);
16349         MP_WritePhyUshort(sc, 0x06, 0xad26);
16350         MP_WritePhyUshort(sc, 0x06, 0x0302);
16351         MP_WritePhyUshort(sc, 0x06, 0x21e5);
16352         MP_WritePhyUshort(sc, 0x06, 0xe08b);
16353         MP_WritePhyUshort(sc, 0x06, 0x81ad);
16354         MP_WritePhyUshort(sc, 0x06, 0x2109);
16355         MP_WritePhyUshort(sc, 0x06, 0xe08a);
16356         MP_WritePhyUshort(sc, 0x06, 0xf4ac);
16357         MP_WritePhyUshort(sc, 0x06, 0x2003);
16358         MP_WritePhyUshort(sc, 0x06, 0x0223);
16359         MP_WritePhyUshort(sc, 0x06, 0x98e0);
16360         MP_WritePhyUshort(sc, 0x06, 0x8b85);
16361         MP_WritePhyUshort(sc, 0x06, 0xad20);
16362         MP_WritePhyUshort(sc, 0x06, 0x09e0);
16363         MP_WritePhyUshort(sc, 0x06, 0x8af4);
16364         MP_WritePhyUshort(sc, 0x06, 0xac21);
16365         MP_WritePhyUshort(sc, 0x06, 0x0302);
16366         MP_WritePhyUshort(sc, 0x06, 0x13fb);
16367         MP_WritePhyUshort(sc, 0x06, 0xe08b);
16368         MP_WritePhyUshort(sc, 0x06, 0x85ad);
16369         MP_WritePhyUshort(sc, 0x06, 0x2309);
16370         MP_WritePhyUshort(sc, 0x06, 0xe08a);
16371         MP_WritePhyUshort(sc, 0x06, 0xf4ac);
16372         MP_WritePhyUshort(sc, 0x06, 0x2203);
16373         MP_WritePhyUshort(sc, 0x06, 0x0212);
16374         MP_WritePhyUshort(sc, 0x06, 0xfae0);
16375         MP_WritePhyUshort(sc, 0x06, 0x8b87);
16376         MP_WritePhyUshort(sc, 0x06, 0xad24);
16377         MP_WritePhyUshort(sc, 0x06, 0x09e0);
16378         MP_WritePhyUshort(sc, 0x06, 0x8af4);
16379         MP_WritePhyUshort(sc, 0x06, 0xac23);
16380         MP_WritePhyUshort(sc, 0x06, 0x0302);
16381         MP_WritePhyUshort(sc, 0x06, 0x83c1);
16382         MP_WritePhyUshort(sc, 0x06, 0xfc04);
16383         MP_WritePhyUshort(sc, 0x06, 0xf8e1);
16384         MP_WritePhyUshort(sc, 0x06, 0x8af4);
16385         MP_WritePhyUshort(sc, 0x06, 0xe08b);
16386         MP_WritePhyUshort(sc, 0x06, 0x81ad);
16387         MP_WritePhyUshort(sc, 0x06, 0x2608);
16388         MP_WritePhyUshort(sc, 0x06, 0xe083);
16389         MP_WritePhyUshort(sc, 0x06, 0xd2ad);
16390         MP_WritePhyUshort(sc, 0x06, 0x2502);
16391         MP_WritePhyUshort(sc, 0x06, 0xf628);
16392         MP_WritePhyUshort(sc, 0x06, 0xe08b);
16393         MP_WritePhyUshort(sc, 0x06, 0x81ad);
16394         MP_WritePhyUshort(sc, 0x06, 0x210a);
16395         MP_WritePhyUshort(sc, 0x06, 0xe084);
16396         MP_WritePhyUshort(sc, 0x06, 0x0af6);
16397         MP_WritePhyUshort(sc, 0x06, 0x27a0);
16398         MP_WritePhyUshort(sc, 0x06, 0x0502);
16399         MP_WritePhyUshort(sc, 0x06, 0xf629);
16400         MP_WritePhyUshort(sc, 0x06, 0xe08b);
16401         MP_WritePhyUshort(sc, 0x06, 0x85ad);
16402         MP_WritePhyUshort(sc, 0x06, 0x2008);
16403         MP_WritePhyUshort(sc, 0x06, 0xe08a);
16404         MP_WritePhyUshort(sc, 0x06, 0xe8ad);
16405         MP_WritePhyUshort(sc, 0x06, 0x2102);
16406         MP_WritePhyUshort(sc, 0x06, 0xf62a);
16407         MP_WritePhyUshort(sc, 0x06, 0xe08b);
16408         MP_WritePhyUshort(sc, 0x06, 0x85ad);
16409         MP_WritePhyUshort(sc, 0x06, 0x2308);
16410         MP_WritePhyUshort(sc, 0x06, 0xe08b);
16411         MP_WritePhyUshort(sc, 0x06, 0x20a0);
16412         MP_WritePhyUshort(sc, 0x06, 0x0302);
16413         MP_WritePhyUshort(sc, 0x06, 0xf62b);
16414         MP_WritePhyUshort(sc, 0x06, 0xe08b);
16415         MP_WritePhyUshort(sc, 0x06, 0x87ad);
16416         MP_WritePhyUshort(sc, 0x06, 0x2408);
16417         MP_WritePhyUshort(sc, 0x06, 0xe086);
16418         MP_WritePhyUshort(sc, 0x06, 0x02a0);
16419         MP_WritePhyUshort(sc, 0x06, 0x0302);
16420         MP_WritePhyUshort(sc, 0x06, 0xf62c);
16421         MP_WritePhyUshort(sc, 0x06, 0xe58a);
16422         MP_WritePhyUshort(sc, 0x06, 0xf4a1);
16423         MP_WritePhyUshort(sc, 0x06, 0x0008);
16424         MP_WritePhyUshort(sc, 0x06, 0xd100);
16425         MP_WritePhyUshort(sc, 0x06, 0xbf21);
16426         MP_WritePhyUshort(sc, 0x06, 0xd502);
16427         MP_WritePhyUshort(sc, 0x06, 0x3723);
16428         MP_WritePhyUshort(sc, 0x06, 0xfc04);
16429         MP_WritePhyUshort(sc, 0x06, 0xee86);
16430         MP_WritePhyUshort(sc, 0x06, 0x0200);
16431         MP_WritePhyUshort(sc, 0x06, 0x04f8);
16432         MP_WritePhyUshort(sc, 0x06, 0xe08b);
16433         MP_WritePhyUshort(sc, 0x06, 0x87ad);
16434         MP_WritePhyUshort(sc, 0x06, 0x241e);
16435         MP_WritePhyUshort(sc, 0x06, 0xe086);
16436         MP_WritePhyUshort(sc, 0x06, 0x02a0);
16437         MP_WritePhyUshort(sc, 0x06, 0x0005);
16438         MP_WritePhyUshort(sc, 0x06, 0x0283);
16439         MP_WritePhyUshort(sc, 0x06, 0xe8ae);
16440         MP_WritePhyUshort(sc, 0x06, 0xf5a0);
16441         MP_WritePhyUshort(sc, 0x06, 0x0105);
16442         MP_WritePhyUshort(sc, 0x06, 0x0283);
16443         MP_WritePhyUshort(sc, 0x06, 0xf8ae);
16444         MP_WritePhyUshort(sc, 0x06, 0x0ba0);
16445         MP_WritePhyUshort(sc, 0x06, 0x0205);
16446         MP_WritePhyUshort(sc, 0x06, 0x0284);
16447         MP_WritePhyUshort(sc, 0x06, 0x14ae);
16448         MP_WritePhyUshort(sc, 0x06, 0x03a0);
16449         MP_WritePhyUshort(sc, 0x06, 0x0300);
16450         MP_WritePhyUshort(sc, 0x06, 0xfc04);
16451         MP_WritePhyUshort(sc, 0x06, 0xf8fa);
16452         MP_WritePhyUshort(sc, 0x06, 0xef69);
16453         MP_WritePhyUshort(sc, 0x06, 0x0284);
16454         MP_WritePhyUshort(sc, 0x06, 0x2bee);
16455         MP_WritePhyUshort(sc, 0x06, 0x8602);
16456         MP_WritePhyUshort(sc, 0x06, 0x01ef);
16457         MP_WritePhyUshort(sc, 0x06, 0x96fe);
16458         MP_WritePhyUshort(sc, 0x06, 0xfc04);
16459         MP_WritePhyUshort(sc, 0x06, 0xf8ee);
16460         MP_WritePhyUshort(sc, 0x06, 0x8609);
16461         MP_WritePhyUshort(sc, 0x06, 0x0002);
16462         MP_WritePhyUshort(sc, 0x06, 0x8461);
16463         MP_WritePhyUshort(sc, 0x06, 0xfc04);
16464         MP_WritePhyUshort(sc, 0x06, 0xae10);
16465         MP_WritePhyUshort(sc, 0x06, 0x0000);
16466         MP_WritePhyUshort(sc, 0x06, 0x0000);
16467         MP_WritePhyUshort(sc, 0x06, 0x0000);
16468         MP_WritePhyUshort(sc, 0x06, 0x0000);
16469         MP_WritePhyUshort(sc, 0x06, 0x0000);
16470         MP_WritePhyUshort(sc, 0x06, 0x0000);
16471         MP_WritePhyUshort(sc, 0x06, 0x0000);
16472         MP_WritePhyUshort(sc, 0x06, 0x0000);
16473         MP_WritePhyUshort(sc, 0x06, 0xf8e0);
16474         MP_WritePhyUshort(sc, 0x06, 0x8608);
16475         MP_WritePhyUshort(sc, 0x06, 0xe186);
16476         MP_WritePhyUshort(sc, 0x06, 0x091f);
16477         MP_WritePhyUshort(sc, 0x06, 0x019e);
16478         MP_WritePhyUshort(sc, 0x06, 0x0611);
16479         MP_WritePhyUshort(sc, 0x06, 0xe586);
16480         MP_WritePhyUshort(sc, 0x06, 0x09ae);
16481         MP_WritePhyUshort(sc, 0x06, 0x04ee);
16482         MP_WritePhyUshort(sc, 0x06, 0x8602);
16483         MP_WritePhyUshort(sc, 0x06, 0x01fc);
16484         MP_WritePhyUshort(sc, 0x06, 0x04f8);
16485         MP_WritePhyUshort(sc, 0x06, 0xf9fa);
16486         MP_WritePhyUshort(sc, 0x06, 0xef69);
16487         MP_WritePhyUshort(sc, 0x06, 0xfbbf);
16488         MP_WritePhyUshort(sc, 0x06, 0x8604);
16489         MP_WritePhyUshort(sc, 0x06, 0xef79);
16490         MP_WritePhyUshort(sc, 0x06, 0xd200);
16491         MP_WritePhyUshort(sc, 0x06, 0xd400);
16492         MP_WritePhyUshort(sc, 0x06, 0x221e);
16493         MP_WritePhyUshort(sc, 0x06, 0x02bf);
16494         MP_WritePhyUshort(sc, 0x06, 0x2fec);
16495         MP_WritePhyUshort(sc, 0x06, 0x0237);
16496         MP_WritePhyUshort(sc, 0x06, 0x23bf);
16497         MP_WritePhyUshort(sc, 0x06, 0x13f2);
16498         MP_WritePhyUshort(sc, 0x06, 0x0236);
16499         MP_WritePhyUshort(sc, 0x06, 0xf60d);
16500         MP_WritePhyUshort(sc, 0x06, 0x4559);
16501         MP_WritePhyUshort(sc, 0x06, 0x1fef);
16502         MP_WritePhyUshort(sc, 0x06, 0x97dd);
16503         MP_WritePhyUshort(sc, 0x06, 0xd308);
16504         MP_WritePhyUshort(sc, 0x06, 0x1a93);
16505         MP_WritePhyUshort(sc, 0x06, 0xdd12);
16506         MP_WritePhyUshort(sc, 0x06, 0x17a2);
16507         MP_WritePhyUshort(sc, 0x06, 0x04de);
16508         MP_WritePhyUshort(sc, 0x06, 0xffef);
16509         MP_WritePhyUshort(sc, 0x06, 0x96fe);
16510         MP_WritePhyUshort(sc, 0x06, 0xfdfc);
16511         MP_WritePhyUshort(sc, 0x06, 0x04f8);
16512         MP_WritePhyUshort(sc, 0x06, 0xf9fa);
16513         MP_WritePhyUshort(sc, 0x06, 0xef69);
16514         MP_WritePhyUshort(sc, 0x06, 0xfbee);
16515         MP_WritePhyUshort(sc, 0x06, 0x8602);
16516         MP_WritePhyUshort(sc, 0x06, 0x03d5);
16517         MP_WritePhyUshort(sc, 0x06, 0x0080);
16518         MP_WritePhyUshort(sc, 0x06, 0xbf86);
16519         MP_WritePhyUshort(sc, 0x06, 0x04ef);
16520         MP_WritePhyUshort(sc, 0x06, 0x79ef);
16521         MP_WritePhyUshort(sc, 0x06, 0x45bf);
16522         MP_WritePhyUshort(sc, 0x06, 0x2fec);
16523         MP_WritePhyUshort(sc, 0x06, 0x0237);
16524         MP_WritePhyUshort(sc, 0x06, 0x23bf);
16525         MP_WritePhyUshort(sc, 0x06, 0x13f2);
16526         MP_WritePhyUshort(sc, 0x06, 0x0236);
16527         MP_WritePhyUshort(sc, 0x06, 0xf6ad);
16528         MP_WritePhyUshort(sc, 0x06, 0x2702);
16529         MP_WritePhyUshort(sc, 0x06, 0x78ff);
16530         MP_WritePhyUshort(sc, 0x06, 0xe186);
16531         MP_WritePhyUshort(sc, 0x06, 0x0a1b);
16532         MP_WritePhyUshort(sc, 0x06, 0x01aa);
16533         MP_WritePhyUshort(sc, 0x06, 0x2eef);
16534         MP_WritePhyUshort(sc, 0x06, 0x97d9);
16535         MP_WritePhyUshort(sc, 0x06, 0x7900);
16536         MP_WritePhyUshort(sc, 0x06, 0x9e2b);
16537         MP_WritePhyUshort(sc, 0x06, 0x81dd);
16538         MP_WritePhyUshort(sc, 0x06, 0xbf85);
16539         MP_WritePhyUshort(sc, 0x06, 0xad02);
16540         MP_WritePhyUshort(sc, 0x06, 0x3723);
16541         MP_WritePhyUshort(sc, 0x06, 0xd101);
16542         MP_WritePhyUshort(sc, 0x06, 0xef02);
16543         MP_WritePhyUshort(sc, 0x06, 0x100c);
16544         MP_WritePhyUshort(sc, 0x06, 0x11b0);
16545         MP_WritePhyUshort(sc, 0x06, 0xfc0d);
16546         MP_WritePhyUshort(sc, 0x06, 0x11bf);
16547         MP_WritePhyUshort(sc, 0x06, 0x85aa);
16548         MP_WritePhyUshort(sc, 0x06, 0x0237);
16549         MP_WritePhyUshort(sc, 0x06, 0x23d1);
16550         MP_WritePhyUshort(sc, 0x06, 0x00bf);
16551         MP_WritePhyUshort(sc, 0x06, 0x85aa);
16552         MP_WritePhyUshort(sc, 0x06, 0x0237);
16553         MP_WritePhyUshort(sc, 0x06, 0x23ee);
16554         MP_WritePhyUshort(sc, 0x06, 0x8602);
16555         MP_WritePhyUshort(sc, 0x06, 0x02ae);
16556         MP_WritePhyUshort(sc, 0x06, 0x0413);
16557         MP_WritePhyUshort(sc, 0x06, 0xa38b);
16558         MP_WritePhyUshort(sc, 0x06, 0xb4d3);
16559         MP_WritePhyUshort(sc, 0x06, 0x8012);
16560         MP_WritePhyUshort(sc, 0x06, 0x17a2);
16561         MP_WritePhyUshort(sc, 0x06, 0x04ad);
16562         MP_WritePhyUshort(sc, 0x06, 0xffef);
16563         MP_WritePhyUshort(sc, 0x06, 0x96fe);
16564         MP_WritePhyUshort(sc, 0x06, 0xfdfc);
16565         MP_WritePhyUshort(sc, 0x06, 0x04f8);
16566         MP_WritePhyUshort(sc, 0x06, 0xf9e0);
16567         MP_WritePhyUshort(sc, 0x06, 0x8b85);
16568         MP_WritePhyUshort(sc, 0x06, 0xad25);
16569         MP_WritePhyUshort(sc, 0x06, 0x48e0);
16570         MP_WritePhyUshort(sc, 0x06, 0x8a96);
16571         MP_WritePhyUshort(sc, 0x06, 0xe18a);
16572         MP_WritePhyUshort(sc, 0x06, 0x977c);
16573         MP_WritePhyUshort(sc, 0x06, 0x0000);
16574         MP_WritePhyUshort(sc, 0x06, 0x9e35);
16575         MP_WritePhyUshort(sc, 0x06, 0xee8a);
16576         MP_WritePhyUshort(sc, 0x06, 0x9600);
16577         MP_WritePhyUshort(sc, 0x06, 0xee8a);
16578         MP_WritePhyUshort(sc, 0x06, 0x9700);
16579         MP_WritePhyUshort(sc, 0x06, 0xe08a);
16580         MP_WritePhyUshort(sc, 0x06, 0xbee1);
16581         MP_WritePhyUshort(sc, 0x06, 0x8abf);
16582         MP_WritePhyUshort(sc, 0x06, 0xe286);
16583         MP_WritePhyUshort(sc, 0x06, 0x10e3);
16584         MP_WritePhyUshort(sc, 0x06, 0x8611);
16585         MP_WritePhyUshort(sc, 0x06, 0x0236);
16586         MP_WritePhyUshort(sc, 0x06, 0x1aad);
16587         MP_WritePhyUshort(sc, 0x06, 0x2012);
16588         MP_WritePhyUshort(sc, 0x06, 0xee8a);
16589         MP_WritePhyUshort(sc, 0x06, 0x9603);
16590         MP_WritePhyUshort(sc, 0x06, 0xee8a);
16591         MP_WritePhyUshort(sc, 0x06, 0x97b7);
16592         MP_WritePhyUshort(sc, 0x06, 0xee86);
16593         MP_WritePhyUshort(sc, 0x06, 0x1000);
16594         MP_WritePhyUshort(sc, 0x06, 0xee86);
16595         MP_WritePhyUshort(sc, 0x06, 0x1100);
16596         MP_WritePhyUshort(sc, 0x06, 0xae11);
16597         MP_WritePhyUshort(sc, 0x06, 0x15e6);
16598         MP_WritePhyUshort(sc, 0x06, 0x8610);
16599         MP_WritePhyUshort(sc, 0x06, 0xe786);
16600         MP_WritePhyUshort(sc, 0x06, 0x11ae);
16601         MP_WritePhyUshort(sc, 0x06, 0x08ee);
16602         MP_WritePhyUshort(sc, 0x06, 0x8610);
16603         MP_WritePhyUshort(sc, 0x06, 0x00ee);
16604         MP_WritePhyUshort(sc, 0x06, 0x8611);
16605         MP_WritePhyUshort(sc, 0x06, 0x00fd);
16606         MP_WritePhyUshort(sc, 0x06, 0xfc04);
16607         MP_WritePhyUshort(sc, 0x06, 0xf8fa);
16608         MP_WritePhyUshort(sc, 0x06, 0xef69);
16609         MP_WritePhyUshort(sc, 0x06, 0xe0e0);
16610         MP_WritePhyUshort(sc, 0x06, 0x00e1);
16611         MP_WritePhyUshort(sc, 0x06, 0xe001);
16612         MP_WritePhyUshort(sc, 0x06, 0xad27);
16613         MP_WritePhyUshort(sc, 0x06, 0x32e0);
16614         MP_WritePhyUshort(sc, 0x06, 0x8b40);
16615         MP_WritePhyUshort(sc, 0x06, 0xf720);
16616         MP_WritePhyUshort(sc, 0x06, 0xe48b);
16617         MP_WritePhyUshort(sc, 0x06, 0x40bf);
16618         MP_WritePhyUshort(sc, 0x06, 0x31f5);
16619         MP_WritePhyUshort(sc, 0x06, 0x0236);
16620         MP_WritePhyUshort(sc, 0x06, 0xf6ad);
16621         MP_WritePhyUshort(sc, 0x06, 0x2821);
16622         MP_WritePhyUshort(sc, 0x06, 0xe0e0);
16623         MP_WritePhyUshort(sc, 0x06, 0x20e1);
16624         MP_WritePhyUshort(sc, 0x06, 0xe021);
16625         MP_WritePhyUshort(sc, 0x06, 0xad20);
16626         MP_WritePhyUshort(sc, 0x06, 0x18e0);
16627         MP_WritePhyUshort(sc, 0x06, 0x8b40);
16628         MP_WritePhyUshort(sc, 0x06, 0xf620);
16629         MP_WritePhyUshort(sc, 0x06, 0xe48b);
16630         MP_WritePhyUshort(sc, 0x06, 0x40ee);
16631         MP_WritePhyUshort(sc, 0x06, 0x8b3b);
16632         MP_WritePhyUshort(sc, 0x06, 0xffe0);
16633         MP_WritePhyUshort(sc, 0x06, 0x8a8a);
16634         MP_WritePhyUshort(sc, 0x06, 0xe18a);
16635         MP_WritePhyUshort(sc, 0x06, 0x8be4);
16636         MP_WritePhyUshort(sc, 0x06, 0xe000);
16637         MP_WritePhyUshort(sc, 0x06, 0xe5e0);
16638         MP_WritePhyUshort(sc, 0x06, 0x01ef);
16639         MP_WritePhyUshort(sc, 0x06, 0x96fe);
16640         MP_WritePhyUshort(sc, 0x06, 0xfc04);
16641         MP_WritePhyUshort(sc, 0x06, 0xf8fa);
16642         MP_WritePhyUshort(sc, 0x06, 0xef69);
16643         MP_WritePhyUshort(sc, 0x06, 0xe08b);
16644         MP_WritePhyUshort(sc, 0x06, 0x80ad);
16645         MP_WritePhyUshort(sc, 0x06, 0x2722);
16646         MP_WritePhyUshort(sc, 0x06, 0xbf44);
16647         MP_WritePhyUshort(sc, 0x06, 0xfc02);
16648         MP_WritePhyUshort(sc, 0x06, 0x36f6);
16649         MP_WritePhyUshort(sc, 0x06, 0xe08b);
16650         MP_WritePhyUshort(sc, 0x06, 0x441f);
16651         MP_WritePhyUshort(sc, 0x06, 0x019e);
16652         MP_WritePhyUshort(sc, 0x06, 0x15e5);
16653         MP_WritePhyUshort(sc, 0x06, 0x8b44);
16654         MP_WritePhyUshort(sc, 0x06, 0xad29);
16655         MP_WritePhyUshort(sc, 0x06, 0x07ac);
16656         MP_WritePhyUshort(sc, 0x06, 0x2804);
16657         MP_WritePhyUshort(sc, 0x06, 0xd101);
16658         MP_WritePhyUshort(sc, 0x06, 0xae02);
16659         MP_WritePhyUshort(sc, 0x06, 0xd100);
16660         MP_WritePhyUshort(sc, 0x06, 0xbf85);
16661         MP_WritePhyUshort(sc, 0x06, 0xb002);
16662         MP_WritePhyUshort(sc, 0x06, 0x3723);
16663         MP_WritePhyUshort(sc, 0x06, 0xef96);
16664         MP_WritePhyUshort(sc, 0x06, 0xfefc);
16665         MP_WritePhyUshort(sc, 0x06, 0x0400);
16666         MP_WritePhyUshort(sc, 0x06, 0xe140);
16667         MP_WritePhyUshort(sc, 0x06, 0x77e1);
16668         MP_WritePhyUshort(sc, 0x06, 0x40dd);
16669         MP_WritePhyUshort(sc, 0x06, 0xe022);
16670         MP_WritePhyUshort(sc, 0x06, 0x32e1);
16671         MP_WritePhyUshort(sc, 0x06, 0x5074);
16672         MP_WritePhyUshort(sc, 0x06, 0xe144);
16673         MP_WritePhyUshort(sc, 0x06, 0xffe0);
16674         MP_WritePhyUshort(sc, 0x06, 0xdaff);
16675         MP_WritePhyUshort(sc, 0x06, 0xe0c0);
16676         MP_WritePhyUshort(sc, 0x06, 0x52e0);
16677         MP_WritePhyUshort(sc, 0x06, 0xeed9);
16678         MP_WritePhyUshort(sc, 0x06, 0xe04c);
16679         MP_WritePhyUshort(sc, 0x06, 0xbbe0);
16680         MP_WritePhyUshort(sc, 0x06, 0x2a00);
16681         MP_WritePhyUshort(sc, 0x05, 0xe142);
16682         PhyRegValue = MP_ReadPhyUshort(sc, 0x06);
16683         PhyRegValue |= BIT_0;
16684         MP_WritePhyUshort(sc, 0x06, PhyRegValue);
16685         MP_WritePhyUshort(sc, 0x05, 0xe140);
16686         PhyRegValue = MP_ReadPhyUshort(sc, 0x06);
16687         PhyRegValue |= BIT_0;
16688         MP_WritePhyUshort(sc, 0x06, PhyRegValue);
16689         MP_WritePhyUshort(sc, 0x1f, 0x0000);
16690         MP_WritePhyUshort(sc, 0x1f, 0x0005);
16691         for (i = 0; i < 200; i++) {
16692                 DELAY(100);
16693                 PhyRegValue = MP_ReadPhyUshort(sc, 0x00);
16694                 if (PhyRegValue & BIT_7)
16695                         break;
16696         }
16697
16698         MP_WritePhyUshort(sc, 0x1F, 0x0003);
16699         MP_WritePhyUshort(sc, 0x09, 0xA20F);
16700         MP_WritePhyUshort(sc, 0x1F, 0x0000);
16701
16702         MP_WritePhyUshort(sc, 0x1f, 0x0003);
16703         PhyRegValue = MP_ReadPhyUshort(sc, 0x19);
16704         PhyRegValue &= ~BIT_0;
16705         MP_WritePhyUshort(sc, 0x19, PhyRegValue);
16706         PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
16707         PhyRegValue &= ~BIT_10;
16708         MP_WritePhyUshort(sc, 0x10, PhyRegValue);
16709         MP_WritePhyUshort(sc, 0x1f, 0x0000);
16710
16711         MP_WritePhyUshort(sc, 0x1f, 0x0007);
16712         MP_WritePhyUshort(sc, 0x1e, 0x0042);
16713         MP_WritePhyUshort(sc, 0x18, 0x2300);
16714         MP_WritePhyUshort(sc, 0x1f, 0x0000);
16715         MP_WritePhyUshort(sc, 0x1f, 0x0007);
16716         MP_WritePhyUshort(sc, 0x1e, 0x0023);
16717         PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
16718         if (sc->RequiredSecLanDonglePatch)
16719                 PhyRegValue &= ~(BIT_2);
16720         MP_WritePhyUshort(sc, 0x17, PhyRegValue);
16721         MP_WritePhyUshort(sc, 0x1f, 0x0000);
16722         MP_WritePhyUshort(sc, 0x00, 0x9200);
16723 }
16724
16725 static void re_set_phy_mcu_8168f_1(struct re_softc *sc)
16726 {
16727         u_int16_t PhyRegValue;
16728         int i;
16729
16730         MP_WritePhyUshort(sc, 0x1f, 0x0000);
16731         MP_WritePhyUshort(sc, 0x00, 0x1800);
16732         PhyRegValue = MP_ReadPhyUshort(sc, 0x15);
16733         PhyRegValue &= ~(BIT_12);
16734         MP_WritePhyUshort(sc, 0x15, PhyRegValue);
16735         MP_WritePhyUshort(sc, 0x00, 0x4800);
16736         MP_WritePhyUshort(sc, 0x1f, 0x0007);
16737         MP_WritePhyUshort(sc, 0x1e, 0x002f);
16738         for (i = 0; i < 1000; i++) {
16739                 DELAY(100);
16740                 PhyRegValue = MP_ReadPhyUshort(sc, 0x1c);
16741                 if (PhyRegValue & BIT_7)
16742                         break;
16743         }
16744         MP_WritePhyUshort(sc, 0x1f, 0x0000);
16745         MP_WritePhyUshort(sc, 0x00, 0x1800);
16746         MP_WritePhyUshort(sc, 0x1f, 0x0007);
16747         MP_WritePhyUshort(sc, 0x1e, 0x0023);
16748         for (i = 0; i < 200; i++) {
16749                 DELAY(100);
16750                 PhyRegValue = MP_ReadPhyUshort(sc, 0x18);
16751                 if (!(PhyRegValue & BIT_0))
16752                         break;
16753         }
16754         MP_WritePhyUshort(sc, 0x1f, 0x0005);
16755         MP_WritePhyUshort(sc, 0x05, 0xfff6);
16756         MP_WritePhyUshort(sc, 0x06, 0x0080);
16757         MP_WritePhyUshort(sc, 0x1f, 0x0007);
16758         MP_WritePhyUshort(sc, 0x1e, 0x0023);
16759         MP_WritePhyUshort(sc, 0x16, 0x0306);
16760         MP_WritePhyUshort(sc, 0x16, 0x0307);
16761         MP_WritePhyUshort(sc, 0x15, 0x0194);
16762         MP_WritePhyUshort(sc, 0x19, 0x407D);
16763         MP_WritePhyUshort(sc, 0x15, 0x0098);
16764         MP_WritePhyUshort(sc, 0x19, 0x7c0b);
16765         MP_WritePhyUshort(sc, 0x15, 0x0099);
16766         MP_WritePhyUshort(sc, 0x19, 0x6c0b);
16767         MP_WritePhyUshort(sc, 0x15, 0x00eb);
16768         MP_WritePhyUshort(sc, 0x19, 0x6c0b);
16769         MP_WritePhyUshort(sc, 0x15, 0x00f8);
16770         MP_WritePhyUshort(sc, 0x19, 0x6f0b);
16771         MP_WritePhyUshort(sc, 0x15, 0x00fe);
16772         MP_WritePhyUshort(sc, 0x19, 0x6f0f);
16773         MP_WritePhyUshort(sc, 0x15, 0x00db);
16774         MP_WritePhyUshort(sc, 0x19, 0x6f09);
16775         MP_WritePhyUshort(sc, 0x15, 0x00dc);
16776         MP_WritePhyUshort(sc, 0x19, 0xaefd);
16777         MP_WritePhyUshort(sc, 0x15, 0x00dd);
16778         MP_WritePhyUshort(sc, 0x19, 0x6f0b);
16779         MP_WritePhyUshort(sc, 0x15, 0x00de);
16780         MP_WritePhyUshort(sc, 0x19, 0xc60b);
16781         MP_WritePhyUshort(sc, 0x15, 0x00df);
16782         MP_WritePhyUshort(sc, 0x19, 0x00fa);
16783         MP_WritePhyUshort(sc, 0x15, 0x00e0);
16784         MP_WritePhyUshort(sc, 0x19, 0x30e1);
16785         MP_WritePhyUshort(sc, 0x15, 0x020c);
16786         MP_WritePhyUshort(sc, 0x19, 0x3224);
16787         MP_WritePhyUshort(sc, 0x15, 0x020e);
16788         MP_WritePhyUshort(sc, 0x19, 0x9813);
16789         MP_WritePhyUshort(sc, 0x15, 0x020f);
16790         MP_WritePhyUshort(sc, 0x19, 0x7801);
16791         MP_WritePhyUshort(sc, 0x15, 0x0210);
16792         MP_WritePhyUshort(sc, 0x19, 0x930f);
16793         MP_WritePhyUshort(sc, 0x15, 0x0211);
16794         MP_WritePhyUshort(sc, 0x19, 0x9206);
16795         MP_WritePhyUshort(sc, 0x15, 0x0212);
16796         MP_WritePhyUshort(sc, 0x19, 0x4002);
16797         MP_WritePhyUshort(sc, 0x15, 0x0213);
16798         MP_WritePhyUshort(sc, 0x19, 0x7800);
16799         MP_WritePhyUshort(sc, 0x15, 0x0214);
16800         MP_WritePhyUshort(sc, 0x19, 0x588f);
16801         MP_WritePhyUshort(sc, 0x15, 0x0215);
16802         MP_WritePhyUshort(sc, 0x19, 0x5520);
16803         MP_WritePhyUshort(sc, 0x15, 0x0216);
16804         MP_WritePhyUshort(sc, 0x19, 0x3224);
16805         MP_WritePhyUshort(sc, 0x15, 0x0217);
16806         MP_WritePhyUshort(sc, 0x19, 0x4002);
16807         MP_WritePhyUshort(sc, 0x15, 0x0218);
16808         MP_WritePhyUshort(sc, 0x19, 0x7800);
16809         MP_WritePhyUshort(sc, 0x15, 0x0219);
16810         MP_WritePhyUshort(sc, 0x19, 0x588d);
16811         MP_WritePhyUshort(sc, 0x15, 0x021a);
16812         MP_WritePhyUshort(sc, 0x19, 0x5540);
16813         MP_WritePhyUshort(sc, 0x15, 0x021b);
16814         MP_WritePhyUshort(sc, 0x19, 0x9e03);
16815         MP_WritePhyUshort(sc, 0x15, 0x021c);
16816         MP_WritePhyUshort(sc, 0x19, 0x7c40);
16817         MP_WritePhyUshort(sc, 0x15, 0x021d);
16818         MP_WritePhyUshort(sc, 0x19, 0x6840);
16819         MP_WritePhyUshort(sc, 0x15, 0x021e);
16820         MP_WritePhyUshort(sc, 0x19, 0x3224);
16821         MP_WritePhyUshort(sc, 0x15, 0x021f);
16822         MP_WritePhyUshort(sc, 0x19, 0x4002);
16823         MP_WritePhyUshort(sc, 0x15, 0x0220);
16824         MP_WritePhyUshort(sc, 0x19, 0x3224);
16825         MP_WritePhyUshort(sc, 0x15, 0x0221);
16826         MP_WritePhyUshort(sc, 0x19, 0x9e03);
16827         MP_WritePhyUshort(sc, 0x15, 0x0222);
16828         MP_WritePhyUshort(sc, 0x19, 0x7c40);
16829         MP_WritePhyUshort(sc, 0x15, 0x0223);
16830         MP_WritePhyUshort(sc, 0x19, 0x6840);
16831         MP_WritePhyUshort(sc, 0x15, 0x0224);
16832         MP_WritePhyUshort(sc, 0x19, 0x7800);
16833         MP_WritePhyUshort(sc, 0x15, 0x0225);
16834         MP_WritePhyUshort(sc, 0x19, 0x3231);
16835         MP_WritePhyUshort(sc, 0x15, 0x0000);
16836         MP_WritePhyUshort(sc, 0x16, 0x0306);
16837         MP_WritePhyUshort(sc, 0x16, 0x0300);
16838         MP_WritePhyUshort(sc, 0x1f, 0x0000);
16839         MP_WritePhyUshort(sc, 0x1f, 0x0005);
16840         MP_WritePhyUshort(sc, 0x05, 0xfff6);
16841         MP_WritePhyUshort(sc, 0x06, 0x0080);
16842         MP_WritePhyUshort(sc, 0x05, 0x8000);
16843         MP_WritePhyUshort(sc, 0x06, 0x0280);
16844         MP_WritePhyUshort(sc, 0x06, 0x48f7);
16845         MP_WritePhyUshort(sc, 0x06, 0x00e0);
16846         MP_WritePhyUshort(sc, 0x06, 0xfff7);
16847         MP_WritePhyUshort(sc, 0x06, 0xa080);
16848         MP_WritePhyUshort(sc, 0x06, 0x02ae);
16849         MP_WritePhyUshort(sc, 0x06, 0xf602);
16850         MP_WritePhyUshort(sc, 0x06, 0x0118);
16851         MP_WritePhyUshort(sc, 0x06, 0x0201);
16852         MP_WritePhyUshort(sc, 0x06, 0x2502);
16853         MP_WritePhyUshort(sc, 0x06, 0x8090);
16854         MP_WritePhyUshort(sc, 0x06, 0x0201);
16855         MP_WritePhyUshort(sc, 0x06, 0x4202);
16856         MP_WritePhyUshort(sc, 0x06, 0x015c);
16857         MP_WritePhyUshort(sc, 0x06, 0x0280);
16858         MP_WritePhyUshort(sc, 0x06, 0xad02);
16859         MP_WritePhyUshort(sc, 0x06, 0x80ca);
16860         MP_WritePhyUshort(sc, 0x06, 0xe08b);
16861         MP_WritePhyUshort(sc, 0x06, 0x88e1);
16862         MP_WritePhyUshort(sc, 0x06, 0x8b89);
16863         MP_WritePhyUshort(sc, 0x06, 0x1e01);
16864         MP_WritePhyUshort(sc, 0x06, 0xe18b);
16865         MP_WritePhyUshort(sc, 0x06, 0x8a1e);
16866         MP_WritePhyUshort(sc, 0x06, 0x01e1);
16867         MP_WritePhyUshort(sc, 0x06, 0x8b8b);
16868         MP_WritePhyUshort(sc, 0x06, 0x1e01);
16869         MP_WritePhyUshort(sc, 0x06, 0xe18b);
16870         MP_WritePhyUshort(sc, 0x06, 0x8c1e);
16871         MP_WritePhyUshort(sc, 0x06, 0x01e1);
16872         MP_WritePhyUshort(sc, 0x06, 0x8b8d);
16873         MP_WritePhyUshort(sc, 0x06, 0x1e01);
16874         MP_WritePhyUshort(sc, 0x06, 0xe18b);
16875         MP_WritePhyUshort(sc, 0x06, 0x8e1e);
16876         MP_WritePhyUshort(sc, 0x06, 0x01a0);
16877         MP_WritePhyUshort(sc, 0x06, 0x00c7);
16878         MP_WritePhyUshort(sc, 0x06, 0xaebb);
16879         MP_WritePhyUshort(sc, 0x06, 0xd484);
16880         MP_WritePhyUshort(sc, 0x06, 0x3ce4);
16881         MP_WritePhyUshort(sc, 0x06, 0x8b92);
16882         MP_WritePhyUshort(sc, 0x06, 0xe58b);
16883         MP_WritePhyUshort(sc, 0x06, 0x93ee);
16884         MP_WritePhyUshort(sc, 0x06, 0x8ac8);
16885         MP_WritePhyUshort(sc, 0x06, 0x03ee);
16886         MP_WritePhyUshort(sc, 0x06, 0x8aca);
16887         MP_WritePhyUshort(sc, 0x06, 0x60ee);
16888         MP_WritePhyUshort(sc, 0x06, 0x8ac0);
16889         MP_WritePhyUshort(sc, 0x06, 0x00ee);
16890         MP_WritePhyUshort(sc, 0x06, 0x8ac1);
16891         MP_WritePhyUshort(sc, 0x06, 0x00ee);
16892         MP_WritePhyUshort(sc, 0x06, 0x8abe);
16893         MP_WritePhyUshort(sc, 0x06, 0x07ee);
16894         MP_WritePhyUshort(sc, 0x06, 0x8abf);
16895         MP_WritePhyUshort(sc, 0x06, 0x73ee);
16896         MP_WritePhyUshort(sc, 0x06, 0x8a95);
16897         MP_WritePhyUshort(sc, 0x06, 0x02bf);
16898         MP_WritePhyUshort(sc, 0x06, 0x8b88);
16899         MP_WritePhyUshort(sc, 0x06, 0xec00);
16900         MP_WritePhyUshort(sc, 0x06, 0x19a9);
16901         MP_WritePhyUshort(sc, 0x06, 0x8b90);
16902         MP_WritePhyUshort(sc, 0x06, 0xf9ee);
16903         MP_WritePhyUshort(sc, 0x06, 0xfff6);
16904         MP_WritePhyUshort(sc, 0x06, 0x00ee);
16905         MP_WritePhyUshort(sc, 0x06, 0xfff7);
16906         MP_WritePhyUshort(sc, 0x06, 0xfed1);
16907         MP_WritePhyUshort(sc, 0x06, 0x00bf);
16908         MP_WritePhyUshort(sc, 0x06, 0x85a4);
16909         MP_WritePhyUshort(sc, 0x06, 0x0238);
16910         MP_WritePhyUshort(sc, 0x06, 0x7dd1);
16911         MP_WritePhyUshort(sc, 0x06, 0x01bf);
16912         MP_WritePhyUshort(sc, 0x06, 0x85a7);
16913         MP_WritePhyUshort(sc, 0x06, 0x0238);
16914         MP_WritePhyUshort(sc, 0x06, 0x7d04);
16915         MP_WritePhyUshort(sc, 0x06, 0xf8e0);
16916         MP_WritePhyUshort(sc, 0x06, 0x8b8a);
16917         MP_WritePhyUshort(sc, 0x06, 0xad20);
16918         MP_WritePhyUshort(sc, 0x06, 0x14ee);
16919         MP_WritePhyUshort(sc, 0x06, 0x8b8a);
16920         MP_WritePhyUshort(sc, 0x06, 0x0002);
16921         MP_WritePhyUshort(sc, 0x06, 0x204b);
16922         MP_WritePhyUshort(sc, 0x06, 0xe0e4);
16923         MP_WritePhyUshort(sc, 0x06, 0x26e1);
16924         MP_WritePhyUshort(sc, 0x06, 0xe427);
16925         MP_WritePhyUshort(sc, 0x06, 0xeee4);
16926         MP_WritePhyUshort(sc, 0x06, 0x2623);
16927         MP_WritePhyUshort(sc, 0x06, 0xe5e4);
16928         MP_WritePhyUshort(sc, 0x06, 0x27fc);
16929         MP_WritePhyUshort(sc, 0x06, 0x04f8);
16930         MP_WritePhyUshort(sc, 0x06, 0xe08b);
16931         MP_WritePhyUshort(sc, 0x06, 0x8dad);
16932         MP_WritePhyUshort(sc, 0x06, 0x2014);
16933         MP_WritePhyUshort(sc, 0x06, 0xee8b);
16934         MP_WritePhyUshort(sc, 0x06, 0x8d00);
16935         MP_WritePhyUshort(sc, 0x06, 0xe08a);
16936         MP_WritePhyUshort(sc, 0x06, 0x5a78);
16937         MP_WritePhyUshort(sc, 0x06, 0x039e);
16938         MP_WritePhyUshort(sc, 0x06, 0x0902);
16939         MP_WritePhyUshort(sc, 0x06, 0x05e8);
16940         MP_WritePhyUshort(sc, 0x06, 0x0281);
16941         MP_WritePhyUshort(sc, 0x06, 0x4f02);
16942         MP_WritePhyUshort(sc, 0x06, 0x326c);
16943         MP_WritePhyUshort(sc, 0x06, 0xfc04);
16944         MP_WritePhyUshort(sc, 0x06, 0xf8e0);
16945         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16946         MP_WritePhyUshort(sc, 0x06, 0xad20);
16947         MP_WritePhyUshort(sc, 0x06, 0x1df6);
16948         MP_WritePhyUshort(sc, 0x06, 0x20e4);
16949         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16950         MP_WritePhyUshort(sc, 0x06, 0x022f);
16951         MP_WritePhyUshort(sc, 0x06, 0x0902);
16952         MP_WritePhyUshort(sc, 0x06, 0x2ab0);
16953         MP_WritePhyUshort(sc, 0x06, 0x0285);
16954         MP_WritePhyUshort(sc, 0x06, 0x1602);
16955         MP_WritePhyUshort(sc, 0x06, 0x03ba);
16956         MP_WritePhyUshort(sc, 0x06, 0x0284);
16957         MP_WritePhyUshort(sc, 0x06, 0xe502);
16958         MP_WritePhyUshort(sc, 0x06, 0x2df1);
16959         MP_WritePhyUshort(sc, 0x06, 0x0283);
16960         MP_WritePhyUshort(sc, 0x06, 0x8302);
16961         MP_WritePhyUshort(sc, 0x06, 0x0475);
16962         MP_WritePhyUshort(sc, 0x06, 0xe08b);
16963         MP_WritePhyUshort(sc, 0x06, 0x8ead);
16964         MP_WritePhyUshort(sc, 0x06, 0x210b);
16965         MP_WritePhyUshort(sc, 0x06, 0xf621);
16966         MP_WritePhyUshort(sc, 0x06, 0xe48b);
16967         MP_WritePhyUshort(sc, 0x06, 0x8e02);
16968         MP_WritePhyUshort(sc, 0x06, 0x83f8);
16969         MP_WritePhyUshort(sc, 0x06, 0x021c);
16970         MP_WritePhyUshort(sc, 0x06, 0x99e0);
16971         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16972         MP_WritePhyUshort(sc, 0x06, 0xad22);
16973         MP_WritePhyUshort(sc, 0x06, 0x08f6);
16974         MP_WritePhyUshort(sc, 0x06, 0x22e4);
16975         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16976         MP_WritePhyUshort(sc, 0x06, 0x0235);
16977         MP_WritePhyUshort(sc, 0x06, 0x63e0);
16978         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16979         MP_WritePhyUshort(sc, 0x06, 0xad23);
16980         MP_WritePhyUshort(sc, 0x06, 0x08f6);
16981         MP_WritePhyUshort(sc, 0x06, 0x23e4);
16982         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16983         MP_WritePhyUshort(sc, 0x06, 0x0231);
16984         MP_WritePhyUshort(sc, 0x06, 0x57e0);
16985         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16986         MP_WritePhyUshort(sc, 0x06, 0xad24);
16987         MP_WritePhyUshort(sc, 0x06, 0x05f6);
16988         MP_WritePhyUshort(sc, 0x06, 0x24e4);
16989         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16990         MP_WritePhyUshort(sc, 0x06, 0xe08b);
16991         MP_WritePhyUshort(sc, 0x06, 0x8ead);
16992         MP_WritePhyUshort(sc, 0x06, 0x2505);
16993         MP_WritePhyUshort(sc, 0x06, 0xf625);
16994         MP_WritePhyUshort(sc, 0x06, 0xe48b);
16995         MP_WritePhyUshort(sc, 0x06, 0x8ee0);
16996         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16997         MP_WritePhyUshort(sc, 0x06, 0xad26);
16998         MP_WritePhyUshort(sc, 0x06, 0x08f6);
16999         MP_WritePhyUshort(sc, 0x06, 0x26e4);
17000         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
17001         MP_WritePhyUshort(sc, 0x06, 0x022d);
17002         MP_WritePhyUshort(sc, 0x06, 0x1ce0);
17003         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
17004         MP_WritePhyUshort(sc, 0x06, 0xad27);
17005         MP_WritePhyUshort(sc, 0x06, 0x05f6);
17006         MP_WritePhyUshort(sc, 0x06, 0x27e4);
17007         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
17008         MP_WritePhyUshort(sc, 0x06, 0x0203);
17009         MP_WritePhyUshort(sc, 0x06, 0x80fc);
17010         MP_WritePhyUshort(sc, 0x06, 0x04f8);
17011         MP_WritePhyUshort(sc, 0x06, 0xf9e0);
17012         MP_WritePhyUshort(sc, 0x06, 0x8b81);
17013         MP_WritePhyUshort(sc, 0x06, 0xac26);
17014         MP_WritePhyUshort(sc, 0x06, 0x1ae0);
17015         MP_WritePhyUshort(sc, 0x06, 0x8b81);
17016         MP_WritePhyUshort(sc, 0x06, 0xac21);
17017         MP_WritePhyUshort(sc, 0x06, 0x14e0);
17018         MP_WritePhyUshort(sc, 0x06, 0x8b85);
17019         MP_WritePhyUshort(sc, 0x06, 0xac20);
17020         MP_WritePhyUshort(sc, 0x06, 0x0ee0);
17021         MP_WritePhyUshort(sc, 0x06, 0x8b85);
17022         MP_WritePhyUshort(sc, 0x06, 0xac23);
17023         MP_WritePhyUshort(sc, 0x06, 0x08e0);
17024         MP_WritePhyUshort(sc, 0x06, 0x8b87);
17025         MP_WritePhyUshort(sc, 0x06, 0xac24);
17026         MP_WritePhyUshort(sc, 0x06, 0x02ae);
17027         MP_WritePhyUshort(sc, 0x06, 0x3802);
17028         MP_WritePhyUshort(sc, 0x06, 0x1ac2);
17029         MP_WritePhyUshort(sc, 0x06, 0xeee4);
17030         MP_WritePhyUshort(sc, 0x06, 0x1c04);
17031         MP_WritePhyUshort(sc, 0x06, 0xeee4);
17032         MP_WritePhyUshort(sc, 0x06, 0x1d04);
17033         MP_WritePhyUshort(sc, 0x06, 0xe2e0);
17034         MP_WritePhyUshort(sc, 0x06, 0x7ce3);
17035         MP_WritePhyUshort(sc, 0x06, 0xe07d);
17036         MP_WritePhyUshort(sc, 0x06, 0xe0e0);
17037         MP_WritePhyUshort(sc, 0x06, 0x38e1);
17038         MP_WritePhyUshort(sc, 0x06, 0xe039);
17039         MP_WritePhyUshort(sc, 0x06, 0xad2e);
17040         MP_WritePhyUshort(sc, 0x06, 0x1bad);
17041         MP_WritePhyUshort(sc, 0x06, 0x390d);
17042         MP_WritePhyUshort(sc, 0x06, 0xd101);
17043         MP_WritePhyUshort(sc, 0x06, 0xbf22);
17044         MP_WritePhyUshort(sc, 0x06, 0x7a02);
17045         MP_WritePhyUshort(sc, 0x06, 0x387d);
17046         MP_WritePhyUshort(sc, 0x06, 0x0281);
17047         MP_WritePhyUshort(sc, 0x06, 0xacae);
17048         MP_WritePhyUshort(sc, 0x06, 0x0bac);
17049         MP_WritePhyUshort(sc, 0x06, 0x3802);
17050         MP_WritePhyUshort(sc, 0x06, 0xae06);
17051         MP_WritePhyUshort(sc, 0x06, 0x0281);
17052         MP_WritePhyUshort(sc, 0x06, 0xe902);
17053         MP_WritePhyUshort(sc, 0x06, 0x822e);
17054         MP_WritePhyUshort(sc, 0x06, 0x021a);
17055         MP_WritePhyUshort(sc, 0x06, 0xd3fd);
17056         MP_WritePhyUshort(sc, 0x06, 0xfc04);
17057         MP_WritePhyUshort(sc, 0x06, 0xf8e1);
17058         MP_WritePhyUshort(sc, 0x06, 0x8af4);
17059         MP_WritePhyUshort(sc, 0x06, 0xe08b);
17060         MP_WritePhyUshort(sc, 0x06, 0x81ad);
17061         MP_WritePhyUshort(sc, 0x06, 0x2602);
17062         MP_WritePhyUshort(sc, 0x06, 0xf728);
17063         MP_WritePhyUshort(sc, 0x06, 0xe08b);
17064         MP_WritePhyUshort(sc, 0x06, 0x81ad);
17065         MP_WritePhyUshort(sc, 0x06, 0x2105);
17066         MP_WritePhyUshort(sc, 0x06, 0x0222);
17067         MP_WritePhyUshort(sc, 0x06, 0x8ef7);
17068         MP_WritePhyUshort(sc, 0x06, 0x29e0);
17069         MP_WritePhyUshort(sc, 0x06, 0x8b85);
17070         MP_WritePhyUshort(sc, 0x06, 0xad20);
17071         MP_WritePhyUshort(sc, 0x06, 0x0502);
17072         MP_WritePhyUshort(sc, 0x06, 0x14b8);
17073         MP_WritePhyUshort(sc, 0x06, 0xf72a);
17074         MP_WritePhyUshort(sc, 0x06, 0xe08b);
17075         MP_WritePhyUshort(sc, 0x06, 0x85ad);
17076         MP_WritePhyUshort(sc, 0x06, 0x2305);
17077         MP_WritePhyUshort(sc, 0x06, 0x0212);
17078         MP_WritePhyUshort(sc, 0x06, 0xf4f7);
17079         MP_WritePhyUshort(sc, 0x06, 0x2be0);
17080         MP_WritePhyUshort(sc, 0x06, 0x8b87);
17081         MP_WritePhyUshort(sc, 0x06, 0xad24);
17082         MP_WritePhyUshort(sc, 0x06, 0x0502);
17083         MP_WritePhyUshort(sc, 0x06, 0x8284);
17084         MP_WritePhyUshort(sc, 0x06, 0xf72c);
17085         MP_WritePhyUshort(sc, 0x06, 0xe58a);
17086         MP_WritePhyUshort(sc, 0x06, 0xf4fc);
17087         MP_WritePhyUshort(sc, 0x06, 0x04f8);
17088         MP_WritePhyUshort(sc, 0x06, 0xe08b);
17089         MP_WritePhyUshort(sc, 0x06, 0x81ad);
17090         MP_WritePhyUshort(sc, 0x06, 0x2600);
17091         MP_WritePhyUshort(sc, 0x06, 0xe08b);
17092         MP_WritePhyUshort(sc, 0x06, 0x81ad);
17093         MP_WritePhyUshort(sc, 0x06, 0x2109);
17094         MP_WritePhyUshort(sc, 0x06, 0xe08a);
17095         MP_WritePhyUshort(sc, 0x06, 0xf4ac);
17096         MP_WritePhyUshort(sc, 0x06, 0x2003);
17097         MP_WritePhyUshort(sc, 0x06, 0x0222);
17098         MP_WritePhyUshort(sc, 0x06, 0x7de0);
17099         MP_WritePhyUshort(sc, 0x06, 0x8b85);
17100         MP_WritePhyUshort(sc, 0x06, 0xad20);
17101         MP_WritePhyUshort(sc, 0x06, 0x09e0);
17102         MP_WritePhyUshort(sc, 0x06, 0x8af4);
17103         MP_WritePhyUshort(sc, 0x06, 0xac21);
17104         MP_WritePhyUshort(sc, 0x06, 0x0302);
17105         MP_WritePhyUshort(sc, 0x06, 0x1408);
17106         MP_WritePhyUshort(sc, 0x06, 0xe08b);
17107         MP_WritePhyUshort(sc, 0x06, 0x85ad);
17108         MP_WritePhyUshort(sc, 0x06, 0x2309);
17109         MP_WritePhyUshort(sc, 0x06, 0xe08a);
17110         MP_WritePhyUshort(sc, 0x06, 0xf4ac);
17111         MP_WritePhyUshort(sc, 0x06, 0x2203);
17112         MP_WritePhyUshort(sc, 0x06, 0x0213);
17113         MP_WritePhyUshort(sc, 0x06, 0x07e0);
17114         MP_WritePhyUshort(sc, 0x06, 0x8b87);
17115         MP_WritePhyUshort(sc, 0x06, 0xad24);
17116         MP_WritePhyUshort(sc, 0x06, 0x09e0);
17117         MP_WritePhyUshort(sc, 0x06, 0x8af4);
17118         MP_WritePhyUshort(sc, 0x06, 0xac23);
17119         MP_WritePhyUshort(sc, 0x06, 0x0302);
17120         MP_WritePhyUshort(sc, 0x06, 0x8289);
17121         MP_WritePhyUshort(sc, 0x06, 0xfc04);
17122         MP_WritePhyUshort(sc, 0x06, 0xf8e1);
17123         MP_WritePhyUshort(sc, 0x06, 0x8af4);
17124         MP_WritePhyUshort(sc, 0x06, 0xe08b);
17125         MP_WritePhyUshort(sc, 0x06, 0x81ad);
17126         MP_WritePhyUshort(sc, 0x06, 0x2602);
17127         MP_WritePhyUshort(sc, 0x06, 0xf628);
17128         MP_WritePhyUshort(sc, 0x06, 0xe08b);
17129         MP_WritePhyUshort(sc, 0x06, 0x81ad);
17130         MP_WritePhyUshort(sc, 0x06, 0x210a);
17131         MP_WritePhyUshort(sc, 0x06, 0xe083);
17132         MP_WritePhyUshort(sc, 0x06, 0xecf6);
17133         MP_WritePhyUshort(sc, 0x06, 0x27a0);
17134         MP_WritePhyUshort(sc, 0x06, 0x0502);
17135         MP_WritePhyUshort(sc, 0x06, 0xf629);
17136         MP_WritePhyUshort(sc, 0x06, 0xe08b);
17137         MP_WritePhyUshort(sc, 0x06, 0x85ad);
17138         MP_WritePhyUshort(sc, 0x06, 0x2008);
17139         MP_WritePhyUshort(sc, 0x06, 0xe08a);
17140         MP_WritePhyUshort(sc, 0x06, 0xe8ad);
17141         MP_WritePhyUshort(sc, 0x06, 0x2102);
17142         MP_WritePhyUshort(sc, 0x06, 0xf62a);
17143         MP_WritePhyUshort(sc, 0x06, 0xe08b);
17144         MP_WritePhyUshort(sc, 0x06, 0x85ad);
17145         MP_WritePhyUshort(sc, 0x06, 0x2308);
17146         MP_WritePhyUshort(sc, 0x06, 0xe08b);
17147         MP_WritePhyUshort(sc, 0x06, 0x20a0);
17148         MP_WritePhyUshort(sc, 0x06, 0x0302);
17149         MP_WritePhyUshort(sc, 0x06, 0xf62b);
17150         MP_WritePhyUshort(sc, 0x06, 0xe08b);
17151         MP_WritePhyUshort(sc, 0x06, 0x87ad);
17152         MP_WritePhyUshort(sc, 0x06, 0x2408);
17153         MP_WritePhyUshort(sc, 0x06, 0xe08a);
17154         MP_WritePhyUshort(sc, 0x06, 0xc2a0);
17155         MP_WritePhyUshort(sc, 0x06, 0x0302);
17156         MP_WritePhyUshort(sc, 0x06, 0xf62c);
17157         MP_WritePhyUshort(sc, 0x06, 0xe58a);
17158         MP_WritePhyUshort(sc, 0x06, 0xf4a1);
17159         MP_WritePhyUshort(sc, 0x06, 0x0008);
17160         MP_WritePhyUshort(sc, 0x06, 0xd100);
17161         MP_WritePhyUshort(sc, 0x06, 0xbf22);
17162         MP_WritePhyUshort(sc, 0x06, 0x7a02);
17163         MP_WritePhyUshort(sc, 0x06, 0x387d);
17164         MP_WritePhyUshort(sc, 0x06, 0xfc04);
17165         MP_WritePhyUshort(sc, 0x06, 0xee8a);
17166         MP_WritePhyUshort(sc, 0x06, 0xc200);
17167         MP_WritePhyUshort(sc, 0x06, 0x04f8);
17168         MP_WritePhyUshort(sc, 0x06, 0xe08b);
17169         MP_WritePhyUshort(sc, 0x06, 0x87ad);
17170         MP_WritePhyUshort(sc, 0x06, 0x241e);
17171         MP_WritePhyUshort(sc, 0x06, 0xe08a);
17172         MP_WritePhyUshort(sc, 0x06, 0xc2a0);
17173         MP_WritePhyUshort(sc, 0x06, 0x0005);
17174         MP_WritePhyUshort(sc, 0x06, 0x0282);
17175         MP_WritePhyUshort(sc, 0x06, 0xb0ae);
17176         MP_WritePhyUshort(sc, 0x06, 0xf5a0);
17177         MP_WritePhyUshort(sc, 0x06, 0x0105);
17178         MP_WritePhyUshort(sc, 0x06, 0x0282);
17179         MP_WritePhyUshort(sc, 0x06, 0xc0ae);
17180         MP_WritePhyUshort(sc, 0x06, 0x0ba0);
17181         MP_WritePhyUshort(sc, 0x06, 0x0205);
17182         MP_WritePhyUshort(sc, 0x06, 0x0282);
17183         MP_WritePhyUshort(sc, 0x06, 0xcaae);
17184         MP_WritePhyUshort(sc, 0x06, 0x03a0);
17185         MP_WritePhyUshort(sc, 0x06, 0x0300);
17186         MP_WritePhyUshort(sc, 0x06, 0xfc04);
17187         MP_WritePhyUshort(sc, 0x06, 0xf8fa);
17188         MP_WritePhyUshort(sc, 0x06, 0xef69);
17189         MP_WritePhyUshort(sc, 0x06, 0x0282);
17190         MP_WritePhyUshort(sc, 0x06, 0xe1ee);
17191         MP_WritePhyUshort(sc, 0x06, 0x8ac2);
17192         MP_WritePhyUshort(sc, 0x06, 0x01ef);
17193         MP_WritePhyUshort(sc, 0x06, 0x96fe);
17194         MP_WritePhyUshort(sc, 0x06, 0xfc04);
17195         MP_WritePhyUshort(sc, 0x06, 0xf8ee);
17196         MP_WritePhyUshort(sc, 0x06, 0x8ac9);
17197         MP_WritePhyUshort(sc, 0x06, 0x0002);
17198         MP_WritePhyUshort(sc, 0x06, 0x8317);
17199         MP_WritePhyUshort(sc, 0x06, 0xfc04);
17200         MP_WritePhyUshort(sc, 0x06, 0xf8e0);
17201         MP_WritePhyUshort(sc, 0x06, 0x8ac8);
17202         MP_WritePhyUshort(sc, 0x06, 0xe18a);
17203         MP_WritePhyUshort(sc, 0x06, 0xc91f);
17204         MP_WritePhyUshort(sc, 0x06, 0x019e);
17205         MP_WritePhyUshort(sc, 0x06, 0x0611);
17206         MP_WritePhyUshort(sc, 0x06, 0xe58a);
17207         MP_WritePhyUshort(sc, 0x06, 0xc9ae);
17208         MP_WritePhyUshort(sc, 0x06, 0x04ee);
17209         MP_WritePhyUshort(sc, 0x06, 0x8ac2);
17210         MP_WritePhyUshort(sc, 0x06, 0x01fc);
17211         MP_WritePhyUshort(sc, 0x06, 0x04f8);
17212         MP_WritePhyUshort(sc, 0x06, 0xf9fa);
17213         MP_WritePhyUshort(sc, 0x06, 0xef69);
17214         MP_WritePhyUshort(sc, 0x06, 0xfbbf);
17215         MP_WritePhyUshort(sc, 0x06, 0x8ac4);
17216         MP_WritePhyUshort(sc, 0x06, 0xef79);
17217         MP_WritePhyUshort(sc, 0x06, 0xd200);
17218         MP_WritePhyUshort(sc, 0x06, 0xd400);
17219         MP_WritePhyUshort(sc, 0x06, 0x221e);
17220         MP_WritePhyUshort(sc, 0x06, 0x02bf);
17221         MP_WritePhyUshort(sc, 0x06, 0x3024);
17222         MP_WritePhyUshort(sc, 0x06, 0x0238);
17223         MP_WritePhyUshort(sc, 0x06, 0x7dbf);
17224         MP_WritePhyUshort(sc, 0x06, 0x13ff);
17225         MP_WritePhyUshort(sc, 0x06, 0x0238);
17226         MP_WritePhyUshort(sc, 0x06, 0x500d);
17227         MP_WritePhyUshort(sc, 0x06, 0x4559);
17228         MP_WritePhyUshort(sc, 0x06, 0x1fef);
17229         MP_WritePhyUshort(sc, 0x06, 0x97dd);
17230         MP_WritePhyUshort(sc, 0x06, 0xd308);
17231         MP_WritePhyUshort(sc, 0x06, 0x1a93);
17232         MP_WritePhyUshort(sc, 0x06, 0xdd12);
17233         MP_WritePhyUshort(sc, 0x06, 0x17a2);
17234         MP_WritePhyUshort(sc, 0x06, 0x04de);
17235         MP_WritePhyUshort(sc, 0x06, 0xffef);
17236         MP_WritePhyUshort(sc, 0x06, 0x96fe);
17237         MP_WritePhyUshort(sc, 0x06, 0xfdfc);
17238         MP_WritePhyUshort(sc, 0x06, 0x04f8);
17239         MP_WritePhyUshort(sc, 0x06, 0xf9fa);
17240         MP_WritePhyUshort(sc, 0x06, 0xef69);
17241         MP_WritePhyUshort(sc, 0x06, 0xfbee);
17242         MP_WritePhyUshort(sc, 0x06, 0x8ac2);
17243         MP_WritePhyUshort(sc, 0x06, 0x03d5);
17244         MP_WritePhyUshort(sc, 0x06, 0x0080);
17245         MP_WritePhyUshort(sc, 0x06, 0xbf8a);
17246         MP_WritePhyUshort(sc, 0x06, 0xc4ef);
17247         MP_WritePhyUshort(sc, 0x06, 0x79ef);
17248         MP_WritePhyUshort(sc, 0x06, 0x45bf);
17249         MP_WritePhyUshort(sc, 0x06, 0x3024);
17250         MP_WritePhyUshort(sc, 0x06, 0x0238);
17251         MP_WritePhyUshort(sc, 0x06, 0x7dbf);
17252         MP_WritePhyUshort(sc, 0x06, 0x13ff);
17253         MP_WritePhyUshort(sc, 0x06, 0x0238);
17254         MP_WritePhyUshort(sc, 0x06, 0x50ad);
17255         MP_WritePhyUshort(sc, 0x06, 0x2702);
17256         MP_WritePhyUshort(sc, 0x06, 0x78ff);
17257         MP_WritePhyUshort(sc, 0x06, 0xe18a);
17258         MP_WritePhyUshort(sc, 0x06, 0xca1b);
17259         MP_WritePhyUshort(sc, 0x06, 0x01aa);
17260         MP_WritePhyUshort(sc, 0x06, 0x2eef);
17261         MP_WritePhyUshort(sc, 0x06, 0x97d9);
17262         MP_WritePhyUshort(sc, 0x06, 0x7900);
17263         MP_WritePhyUshort(sc, 0x06, 0x9e2b);
17264         MP_WritePhyUshort(sc, 0x06, 0x81dd);
17265         MP_WritePhyUshort(sc, 0x06, 0xbf85);
17266         MP_WritePhyUshort(sc, 0x06, 0xad02);
17267         MP_WritePhyUshort(sc, 0x06, 0x387d);
17268         MP_WritePhyUshort(sc, 0x06, 0xd101);
17269         MP_WritePhyUshort(sc, 0x06, 0xef02);
17270         MP_WritePhyUshort(sc, 0x06, 0x100c);
17271         MP_WritePhyUshort(sc, 0x06, 0x11b0);
17272         MP_WritePhyUshort(sc, 0x06, 0xfc0d);
17273         MP_WritePhyUshort(sc, 0x06, 0x11bf);
17274         MP_WritePhyUshort(sc, 0x06, 0x85aa);
17275         MP_WritePhyUshort(sc, 0x06, 0x0238);
17276         MP_WritePhyUshort(sc, 0x06, 0x7dd1);
17277         MP_WritePhyUshort(sc, 0x06, 0x00bf);
17278         MP_WritePhyUshort(sc, 0x06, 0x85aa);
17279         MP_WritePhyUshort(sc, 0x06, 0x0238);
17280         MP_WritePhyUshort(sc, 0x06, 0x7dee);
17281         MP_WritePhyUshort(sc, 0x06, 0x8ac2);
17282         MP_WritePhyUshort(sc, 0x06, 0x02ae);
17283         MP_WritePhyUshort(sc, 0x06, 0x0413);
17284         MP_WritePhyUshort(sc, 0x06, 0xa38b);
17285         MP_WritePhyUshort(sc, 0x06, 0xb4d3);
17286         MP_WritePhyUshort(sc, 0x06, 0x8012);
17287         MP_WritePhyUshort(sc, 0x06, 0x17a2);
17288         MP_WritePhyUshort(sc, 0x06, 0x04ad);
17289         MP_WritePhyUshort(sc, 0x06, 0xffef);
17290         MP_WritePhyUshort(sc, 0x06, 0x96fe);
17291         MP_WritePhyUshort(sc, 0x06, 0xfdfc);
17292         MP_WritePhyUshort(sc, 0x06, 0x04f8);
17293         MP_WritePhyUshort(sc, 0x06, 0xf9e0);
17294         MP_WritePhyUshort(sc, 0x06, 0x8b85);
17295         MP_WritePhyUshort(sc, 0x06, 0xad25);
17296         MP_WritePhyUshort(sc, 0x06, 0x48e0);
17297         MP_WritePhyUshort(sc, 0x06, 0x8a96);
17298         MP_WritePhyUshort(sc, 0x06, 0xe18a);
17299         MP_WritePhyUshort(sc, 0x06, 0x977c);
17300         MP_WritePhyUshort(sc, 0x06, 0x0000);
17301         MP_WritePhyUshort(sc, 0x06, 0x9e35);
17302         MP_WritePhyUshort(sc, 0x06, 0xee8a);
17303         MP_WritePhyUshort(sc, 0x06, 0x9600);
17304         MP_WritePhyUshort(sc, 0x06, 0xee8a);
17305         MP_WritePhyUshort(sc, 0x06, 0x9700);
17306         MP_WritePhyUshort(sc, 0x06, 0xe08a);
17307         MP_WritePhyUshort(sc, 0x06, 0xbee1);
17308         MP_WritePhyUshort(sc, 0x06, 0x8abf);
17309         MP_WritePhyUshort(sc, 0x06, 0xe28a);
17310         MP_WritePhyUshort(sc, 0x06, 0xc0e3);
17311         MP_WritePhyUshort(sc, 0x06, 0x8ac1);
17312         MP_WritePhyUshort(sc, 0x06, 0x0237);
17313         MP_WritePhyUshort(sc, 0x06, 0x74ad);
17314         MP_WritePhyUshort(sc, 0x06, 0x2012);
17315         MP_WritePhyUshort(sc, 0x06, 0xee8a);
17316         MP_WritePhyUshort(sc, 0x06, 0x9603);
17317         MP_WritePhyUshort(sc, 0x06, 0xee8a);
17318         MP_WritePhyUshort(sc, 0x06, 0x97b7);
17319         MP_WritePhyUshort(sc, 0x06, 0xee8a);
17320         MP_WritePhyUshort(sc, 0x06, 0xc000);
17321         MP_WritePhyUshort(sc, 0x06, 0xee8a);
17322         MP_WritePhyUshort(sc, 0x06, 0xc100);
17323         MP_WritePhyUshort(sc, 0x06, 0xae11);
17324         MP_WritePhyUshort(sc, 0x06, 0x15e6);
17325         MP_WritePhyUshort(sc, 0x06, 0x8ac0);
17326         MP_WritePhyUshort(sc, 0x06, 0xe78a);
17327         MP_WritePhyUshort(sc, 0x06, 0xc1ae);
17328         MP_WritePhyUshort(sc, 0x06, 0x08ee);
17329         MP_WritePhyUshort(sc, 0x06, 0x8ac0);
17330         MP_WritePhyUshort(sc, 0x06, 0x00ee);
17331         MP_WritePhyUshort(sc, 0x06, 0x8ac1);
17332         MP_WritePhyUshort(sc, 0x06, 0x00fd);
17333         MP_WritePhyUshort(sc, 0x06, 0xfc04);
17334         MP_WritePhyUshort(sc, 0x06, 0xae20);
17335         MP_WritePhyUshort(sc, 0x06, 0x0000);
17336         MP_WritePhyUshort(sc, 0x06, 0x0000);
17337         MP_WritePhyUshort(sc, 0x06, 0x0000);
17338         MP_WritePhyUshort(sc, 0x06, 0x0000);
17339         MP_WritePhyUshort(sc, 0x06, 0x0000);
17340         MP_WritePhyUshort(sc, 0x06, 0x0000);
17341         MP_WritePhyUshort(sc, 0x06, 0x0000);
17342         MP_WritePhyUshort(sc, 0x06, 0x0000);
17343         MP_WritePhyUshort(sc, 0x06, 0x0000);
17344         MP_WritePhyUshort(sc, 0x06, 0x0000);
17345         MP_WritePhyUshort(sc, 0x06, 0x0000);
17346         MP_WritePhyUshort(sc, 0x06, 0x0000);
17347         MP_WritePhyUshort(sc, 0x06, 0x0000);
17348         MP_WritePhyUshort(sc, 0x06, 0x0000);
17349         MP_WritePhyUshort(sc, 0x06, 0x0000);
17350         MP_WritePhyUshort(sc, 0x06, 0x0000);
17351         MP_WritePhyUshort(sc, 0x06, 0xf8fa);
17352         MP_WritePhyUshort(sc, 0x06, 0xef69);
17353         MP_WritePhyUshort(sc, 0x06, 0xe0e0);
17354         MP_WritePhyUshort(sc, 0x06, 0x00e1);
17355         MP_WritePhyUshort(sc, 0x06, 0xe001);
17356         MP_WritePhyUshort(sc, 0x06, 0xad27);
17357         MP_WritePhyUshort(sc, 0x06, 0x32e0);
17358         MP_WritePhyUshort(sc, 0x06, 0x8b40);
17359         MP_WritePhyUshort(sc, 0x06, 0xf720);
17360         MP_WritePhyUshort(sc, 0x06, 0xe48b);
17361         MP_WritePhyUshort(sc, 0x06, 0x40bf);
17362         MP_WritePhyUshort(sc, 0x06, 0x3230);
17363         MP_WritePhyUshort(sc, 0x06, 0x0238);
17364         MP_WritePhyUshort(sc, 0x06, 0x50ad);
17365         MP_WritePhyUshort(sc, 0x06, 0x2821);
17366         MP_WritePhyUshort(sc, 0x06, 0xe0e0);
17367         MP_WritePhyUshort(sc, 0x06, 0x20e1);
17368         MP_WritePhyUshort(sc, 0x06, 0xe021);
17369         MP_WritePhyUshort(sc, 0x06, 0xad20);
17370         MP_WritePhyUshort(sc, 0x06, 0x18e0);
17371         MP_WritePhyUshort(sc, 0x06, 0x8b40);
17372         MP_WritePhyUshort(sc, 0x06, 0xf620);
17373         MP_WritePhyUshort(sc, 0x06, 0xe48b);
17374         MP_WritePhyUshort(sc, 0x06, 0x40ee);
17375         MP_WritePhyUshort(sc, 0x06, 0x8b3b);
17376         MP_WritePhyUshort(sc, 0x06, 0xffe0);
17377         MP_WritePhyUshort(sc, 0x06, 0x8a8a);
17378         MP_WritePhyUshort(sc, 0x06, 0xe18a);
17379         MP_WritePhyUshort(sc, 0x06, 0x8be4);
17380         MP_WritePhyUshort(sc, 0x06, 0xe000);
17381         MP_WritePhyUshort(sc, 0x06, 0xe5e0);
17382         MP_WritePhyUshort(sc, 0x06, 0x01ef);
17383         MP_WritePhyUshort(sc, 0x06, 0x96fe);
17384         MP_WritePhyUshort(sc, 0x06, 0xfc04);
17385         MP_WritePhyUshort(sc, 0x06, 0xf8f9);
17386         MP_WritePhyUshort(sc, 0x06, 0xface);
17387         MP_WritePhyUshort(sc, 0x06, 0xfaef);
17388         MP_WritePhyUshort(sc, 0x06, 0x69fa);
17389         MP_WritePhyUshort(sc, 0x06, 0xd401);
17390         MP_WritePhyUshort(sc, 0x06, 0x55b4);
17391         MP_WritePhyUshort(sc, 0x06, 0xfebf);
17392         MP_WritePhyUshort(sc, 0x06, 0x1c1e);
17393         MP_WritePhyUshort(sc, 0x06, 0x0238);
17394         MP_WritePhyUshort(sc, 0x06, 0x50ac);
17395         MP_WritePhyUshort(sc, 0x06, 0x280b);
17396         MP_WritePhyUshort(sc, 0x06, 0xbf1c);
17397         MP_WritePhyUshort(sc, 0x06, 0x1b02);
17398         MP_WritePhyUshort(sc, 0x06, 0x3850);
17399         MP_WritePhyUshort(sc, 0x06, 0xac28);
17400         MP_WritePhyUshort(sc, 0x06, 0x49ae);
17401         MP_WritePhyUshort(sc, 0x06, 0x64bf);
17402         MP_WritePhyUshort(sc, 0x06, 0x1c1b);
17403         MP_WritePhyUshort(sc, 0x06, 0x0238);
17404         MP_WritePhyUshort(sc, 0x06, 0x50ac);
17405         MP_WritePhyUshort(sc, 0x06, 0x285b);
17406         MP_WritePhyUshort(sc, 0x06, 0xd000);
17407         MP_WritePhyUshort(sc, 0x06, 0x0284);
17408         MP_WritePhyUshort(sc, 0x06, 0xcaac);
17409         MP_WritePhyUshort(sc, 0x06, 0x2105);
17410         MP_WritePhyUshort(sc, 0x06, 0xac22);
17411         MP_WritePhyUshort(sc, 0x06, 0x02ae);
17412         MP_WritePhyUshort(sc, 0x06, 0x4ebf);
17413         MP_WritePhyUshort(sc, 0x06, 0xe0c4);
17414         MP_WritePhyUshort(sc, 0x06, 0xbe85);
17415         MP_WritePhyUshort(sc, 0x06, 0xf6d2);
17416         MP_WritePhyUshort(sc, 0x06, 0x04d8);
17417         MP_WritePhyUshort(sc, 0x06, 0x19d9);
17418         MP_WritePhyUshort(sc, 0x06, 0x1907);
17419         MP_WritePhyUshort(sc, 0x06, 0xdc19);
17420         MP_WritePhyUshort(sc, 0x06, 0xdd19);
17421         MP_WritePhyUshort(sc, 0x06, 0x0789);
17422         MP_WritePhyUshort(sc, 0x06, 0x89ef);
17423         MP_WritePhyUshort(sc, 0x06, 0x645e);
17424         MP_WritePhyUshort(sc, 0x06, 0x07ff);
17425         MP_WritePhyUshort(sc, 0x06, 0x0d65);
17426         MP_WritePhyUshort(sc, 0x06, 0x5cf8);
17427         MP_WritePhyUshort(sc, 0x06, 0x001e);
17428         MP_WritePhyUshort(sc, 0x06, 0x46dc);
17429         MP_WritePhyUshort(sc, 0x06, 0x19dd);
17430         MP_WritePhyUshort(sc, 0x06, 0x19b2);
17431         MP_WritePhyUshort(sc, 0x06, 0xe2d4);
17432         MP_WritePhyUshort(sc, 0x06, 0x0001);
17433         MP_WritePhyUshort(sc, 0x06, 0xbf1c);
17434         MP_WritePhyUshort(sc, 0x06, 0x1b02);
17435         MP_WritePhyUshort(sc, 0x06, 0x387d);
17436         MP_WritePhyUshort(sc, 0x06, 0xae1d);
17437         MP_WritePhyUshort(sc, 0x06, 0xbee0);
17438         MP_WritePhyUshort(sc, 0x06, 0xc4bf);
17439         MP_WritePhyUshort(sc, 0x06, 0x85f6);
17440         MP_WritePhyUshort(sc, 0x06, 0xd204);
17441         MP_WritePhyUshort(sc, 0x06, 0xd819);
17442         MP_WritePhyUshort(sc, 0x06, 0xd919);
17443         MP_WritePhyUshort(sc, 0x06, 0x07dc);
17444         MP_WritePhyUshort(sc, 0x06, 0x19dd);
17445         MP_WritePhyUshort(sc, 0x06, 0x1907);
17446         MP_WritePhyUshort(sc, 0x06, 0xb2f4);
17447         MP_WritePhyUshort(sc, 0x06, 0xd400);
17448         MP_WritePhyUshort(sc, 0x06, 0x00bf);
17449         MP_WritePhyUshort(sc, 0x06, 0x1c1b);
17450         MP_WritePhyUshort(sc, 0x06, 0x0238);
17451         MP_WritePhyUshort(sc, 0x06, 0x7dfe);
17452         MP_WritePhyUshort(sc, 0x06, 0xef96);
17453         MP_WritePhyUshort(sc, 0x06, 0xfec6);
17454         MP_WritePhyUshort(sc, 0x06, 0xfefd);
17455         MP_WritePhyUshort(sc, 0x06, 0xfc05);
17456         MP_WritePhyUshort(sc, 0x06, 0xf9e2);
17457         MP_WritePhyUshort(sc, 0x06, 0xe0ea);
17458         MP_WritePhyUshort(sc, 0x06, 0xe3e0);
17459         MP_WritePhyUshort(sc, 0x06, 0xeb5a);
17460         MP_WritePhyUshort(sc, 0x06, 0x070c);
17461         MP_WritePhyUshort(sc, 0x06, 0x031e);
17462         MP_WritePhyUshort(sc, 0x06, 0x20e6);
17463         MP_WritePhyUshort(sc, 0x06, 0xe0ea);
17464         MP_WritePhyUshort(sc, 0x06, 0xe7e0);
17465         MP_WritePhyUshort(sc, 0x06, 0xebe0);
17466         MP_WritePhyUshort(sc, 0x06, 0xe0fc);
17467         MP_WritePhyUshort(sc, 0x06, 0xe1e0);
17468         MP_WritePhyUshort(sc, 0x06, 0xfdfd);
17469         MP_WritePhyUshort(sc, 0x06, 0x04f8);
17470         MP_WritePhyUshort(sc, 0x06, 0xfaef);
17471         MP_WritePhyUshort(sc, 0x06, 0x69e0);
17472         MP_WritePhyUshort(sc, 0x06, 0x8b80);
17473         MP_WritePhyUshort(sc, 0x06, 0xad27);
17474         MP_WritePhyUshort(sc, 0x06, 0x22bf);
17475         MP_WritePhyUshort(sc, 0x06, 0x4616);
17476         MP_WritePhyUshort(sc, 0x06, 0x0238);
17477         MP_WritePhyUshort(sc, 0x06, 0x50e0);
17478         MP_WritePhyUshort(sc, 0x06, 0x8b44);
17479         MP_WritePhyUshort(sc, 0x06, 0x1f01);
17480         MP_WritePhyUshort(sc, 0x06, 0x9e15);
17481         MP_WritePhyUshort(sc, 0x06, 0xe58b);
17482         MP_WritePhyUshort(sc, 0x06, 0x44ad);
17483         MP_WritePhyUshort(sc, 0x06, 0x2907);
17484         MP_WritePhyUshort(sc, 0x06, 0xac28);
17485         MP_WritePhyUshort(sc, 0x06, 0x04d1);
17486         MP_WritePhyUshort(sc, 0x06, 0x01ae);
17487         MP_WritePhyUshort(sc, 0x06, 0x02d1);
17488         MP_WritePhyUshort(sc, 0x06, 0x00bf);
17489         MP_WritePhyUshort(sc, 0x06, 0x85b0);
17490         MP_WritePhyUshort(sc, 0x06, 0x0238);
17491         MP_WritePhyUshort(sc, 0x06, 0x7def);
17492         MP_WritePhyUshort(sc, 0x06, 0x96fe);
17493         MP_WritePhyUshort(sc, 0x06, 0xfc04);
17494         MP_WritePhyUshort(sc, 0x06, 0xf8e0);
17495         MP_WritePhyUshort(sc, 0x06, 0x8b85);
17496         MP_WritePhyUshort(sc, 0x06, 0xad26);
17497         MP_WritePhyUshort(sc, 0x06, 0x30e0);
17498         MP_WritePhyUshort(sc, 0x06, 0xe036);
17499         MP_WritePhyUshort(sc, 0x06, 0xe1e0);
17500         MP_WritePhyUshort(sc, 0x06, 0x37e1);
17501         MP_WritePhyUshort(sc, 0x06, 0x8b3f);
17502         MP_WritePhyUshort(sc, 0x06, 0x1f10);
17503         MP_WritePhyUshort(sc, 0x06, 0x9e23);
17504         MP_WritePhyUshort(sc, 0x06, 0xe48b);
17505         MP_WritePhyUshort(sc, 0x06, 0x3fac);
17506         MP_WritePhyUshort(sc, 0x06, 0x200b);
17507         MP_WritePhyUshort(sc, 0x06, 0xac21);
17508         MP_WritePhyUshort(sc, 0x06, 0x0dac);
17509         MP_WritePhyUshort(sc, 0x06, 0x250f);
17510         MP_WritePhyUshort(sc, 0x06, 0xac27);
17511         MP_WritePhyUshort(sc, 0x06, 0x11ae);
17512         MP_WritePhyUshort(sc, 0x06, 0x1202);
17513         MP_WritePhyUshort(sc, 0x06, 0x2c47);
17514         MP_WritePhyUshort(sc, 0x06, 0xae0d);
17515         MP_WritePhyUshort(sc, 0x06, 0x0285);
17516         MP_WritePhyUshort(sc, 0x06, 0x4fae);
17517         MP_WritePhyUshort(sc, 0x06, 0x0802);
17518         MP_WritePhyUshort(sc, 0x06, 0x2c69);
17519         MP_WritePhyUshort(sc, 0x06, 0xae03);
17520         MP_WritePhyUshort(sc, 0x06, 0x022c);
17521         MP_WritePhyUshort(sc, 0x06, 0x7cfc);
17522         MP_WritePhyUshort(sc, 0x06, 0x04f8);
17523         MP_WritePhyUshort(sc, 0x06, 0xfaef);
17524         MP_WritePhyUshort(sc, 0x06, 0x6902);
17525         MP_WritePhyUshort(sc, 0x06, 0x856c);
17526         MP_WritePhyUshort(sc, 0x06, 0xe0e0);
17527         MP_WritePhyUshort(sc, 0x06, 0x14e1);
17528         MP_WritePhyUshort(sc, 0x06, 0xe015);
17529         MP_WritePhyUshort(sc, 0x06, 0xad26);
17530         MP_WritePhyUshort(sc, 0x06, 0x08d1);
17531         MP_WritePhyUshort(sc, 0x06, 0x1ebf);
17532         MP_WritePhyUshort(sc, 0x06, 0x2cd9);
17533         MP_WritePhyUshort(sc, 0x06, 0x0238);
17534         MP_WritePhyUshort(sc, 0x06, 0x7def);
17535         MP_WritePhyUshort(sc, 0x06, 0x96fe);
17536         MP_WritePhyUshort(sc, 0x06, 0xfc04);
17537         MP_WritePhyUshort(sc, 0x06, 0xf8e0);
17538         MP_WritePhyUshort(sc, 0x06, 0x8b85);
17539         MP_WritePhyUshort(sc, 0x06, 0xad27);
17540         MP_WritePhyUshort(sc, 0x06, 0x2fd0);
17541         MP_WritePhyUshort(sc, 0x06, 0x0b02);
17542         MP_WritePhyUshort(sc, 0x06, 0x3682);
17543         MP_WritePhyUshort(sc, 0x06, 0x5882);
17544         MP_WritePhyUshort(sc, 0x06, 0x7882);
17545         MP_WritePhyUshort(sc, 0x06, 0x9f24);
17546         MP_WritePhyUshort(sc, 0x06, 0xe08b);
17547         MP_WritePhyUshort(sc, 0x06, 0x32e1);
17548         MP_WritePhyUshort(sc, 0x06, 0x8b33);
17549         MP_WritePhyUshort(sc, 0x06, 0x1f10);
17550         MP_WritePhyUshort(sc, 0x06, 0x9e1a);
17551         MP_WritePhyUshort(sc, 0x06, 0x10e4);
17552         MP_WritePhyUshort(sc, 0x06, 0x8b32);
17553         MP_WritePhyUshort(sc, 0x06, 0xe0e0);
17554         MP_WritePhyUshort(sc, 0x06, 0x28e1);
17555         MP_WritePhyUshort(sc, 0x06, 0xe029);
17556         MP_WritePhyUshort(sc, 0x06, 0xf72c);
17557         MP_WritePhyUshort(sc, 0x06, 0xe4e0);
17558         MP_WritePhyUshort(sc, 0x06, 0x28e5);
17559         MP_WritePhyUshort(sc, 0x06, 0xe029);
17560         MP_WritePhyUshort(sc, 0x06, 0xf62c);
17561         MP_WritePhyUshort(sc, 0x06, 0xe4e0);
17562         MP_WritePhyUshort(sc, 0x06, 0x28e5);
17563         MP_WritePhyUshort(sc, 0x06, 0xe029);
17564         MP_WritePhyUshort(sc, 0x06, 0xfc04);
17565         MP_WritePhyUshort(sc, 0x06, 0x00e1);
17566         MP_WritePhyUshort(sc, 0x06, 0x4077);
17567         MP_WritePhyUshort(sc, 0x06, 0xe140);
17568         MP_WritePhyUshort(sc, 0x06, 0x52e0);
17569         MP_WritePhyUshort(sc, 0x06, 0xeed9);
17570         MP_WritePhyUshort(sc, 0x06, 0xe04c);
17571         MP_WritePhyUshort(sc, 0x06, 0xbbe0);
17572         MP_WritePhyUshort(sc, 0x06, 0x2a00);
17573         MP_WritePhyUshort(sc, 0x05, 0xe142);
17574         PhyRegValue = MP_ReadPhyUshort(sc, 0x06);
17575         PhyRegValue |= BIT_0;
17576         MP_WritePhyUshort(sc, 0x06, PhyRegValue);
17577         MP_WritePhyUshort(sc, 0x05, 0xe140);
17578         PhyRegValue = MP_ReadPhyUshort(sc, 0x06);
17579         PhyRegValue |= BIT_0;
17580         MP_WritePhyUshort(sc, 0x06, PhyRegValue);
17581         MP_WritePhyUshort(sc, 0x1f, 0x0000);
17582         MP_WritePhyUshort(sc, 0x1f, 0x0005);
17583         for (i = 0; i < 200; i++) {
17584                 DELAY(100);
17585                 PhyRegValue = MP_ReadPhyUshort(sc, 0x00);
17586                 if (PhyRegValue & BIT_7)
17587                         break;
17588         }
17589
17590         MP_WritePhyUshort(sc, 0x1f, 0x0007);
17591         MP_WritePhyUshort(sc, 0x1e, 0x0023);
17592         PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
17593         PhyRegValue |= BIT_1;
17594         if (sc->RequiredSecLanDonglePatch)
17595                 PhyRegValue &= ~(BIT_2);
17596         MP_WritePhyUshort(sc, 0x17, PhyRegValue);
17597         MP_WritePhyUshort(sc, 0x1f, 0x0000);
17598
17599         MP_WritePhyUshort(sc, 0x1f, 0x0003);
17600         MP_WritePhyUshort(sc, 0x09, 0xA20F);
17601         MP_WritePhyUshort(sc, 0x1f, 0x0000);
17602
17603         MP_WritePhyUshort(sc, 0x1f, 0x0003);
17604         MP_WritePhyUshort(sc, 0x01, 0x328A);
17605         MP_WritePhyUshort(sc, 0x1f, 0x0000);
17606
17607         MP_WritePhyUshort(sc, 0x1f, 0x0003);
17608         PhyRegValue = MP_ReadPhyUshort(sc, 0x19);
17609         PhyRegValue &= ~BIT_0;
17610         MP_WritePhyUshort(sc, 0x19, PhyRegValue);
17611         PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
17612         PhyRegValue &= ~BIT_10;
17613         MP_WritePhyUshort(sc, 0x10, PhyRegValue);
17614         MP_WritePhyUshort(sc, 0x1f, 0x0000);
17615
17616
17617         MP_WritePhyUshort(sc, 0x1f, 0x0000);
17618         MP_WritePhyUshort(sc, 0x00, 0x9200);
17619 }
17620
17621 static void re_set_phy_mcu_8168f_2(struct re_softc *sc)
17622 {
17623         u_int16_t PhyRegValue;
17624         int i;
17625
17626         MP_WritePhyUshort(sc, 0x1f, 0x0000);
17627         MP_WritePhyUshort(sc, 0x00, 0x1800);
17628         PhyRegValue = MP_ReadPhyUshort(sc, 0x15);
17629         PhyRegValue &= ~(BIT_12);
17630         MP_WritePhyUshort(sc, 0x15, PhyRegValue);
17631         MP_WritePhyUshort(sc, 0x00, 0x4800);
17632         MP_WritePhyUshort(sc, 0x1f, 0x0007);
17633         MP_WritePhyUshort(sc, 0x1e, 0x002f);
17634         for (i = 0; i < 1000; i++) {
17635                 DELAY(100);
17636                 PhyRegValue = MP_ReadPhyUshort(sc, 0x1c);
17637                 if (PhyRegValue & BIT_7)
17638                         break;
17639         }
17640         MP_WritePhyUshort(sc, 0x1f, 0x0000);
17641         MP_WritePhyUshort(sc, 0x00, 0x1800);
17642         MP_WritePhyUshort(sc, 0x1f, 0x0007);
17643         MP_WritePhyUshort(sc, 0x1e, 0x0023);
17644         for (i = 0; i < 200; i++) {
17645                 DELAY(100);
17646                 PhyRegValue = MP_ReadPhyUshort(sc, 0x18);
17647                 if (!(PhyRegValue & BIT_0))
17648                         break;
17649         }
17650         MP_WritePhyUshort(sc, 0x1f, 0x0005);
17651         MP_WritePhyUshort(sc, 0x05, 0xfff6);
17652         MP_WritePhyUshort(sc, 0x06, 0x0080);
17653         MP_WritePhyUshort(sc, 0x1f, 0x0007);
17654         MP_WritePhyUshort(sc, 0x1e, 0x0023);
17655         MP_WritePhyUshort(sc, 0x16, 0x0306);
17656         MP_WritePhyUshort(sc, 0x16, 0x0307);
17657         MP_WritePhyUshort(sc, 0x15, 0x0098);
17658         MP_WritePhyUshort(sc, 0x19, 0x7c0b);
17659         MP_WritePhyUshort(sc, 0x15, 0x0099);
17660         MP_WritePhyUshort(sc, 0x19, 0x6c0b);
17661         MP_WritePhyUshort(sc, 0x15, 0x00eb);
17662         MP_WritePhyUshort(sc, 0x19, 0x6c0b);
17663         MP_WritePhyUshort(sc, 0x15, 0x00f8);
17664         MP_WritePhyUshort(sc, 0x19, 0x6f0b);
17665         MP_WritePhyUshort(sc, 0x15, 0x00fe);
17666         MP_WritePhyUshort(sc, 0x19, 0x6f0f);
17667         MP_WritePhyUshort(sc, 0x15, 0x00db);
17668         MP_WritePhyUshort(sc, 0x19, 0x6f09);
17669         MP_WritePhyUshort(sc, 0x15, 0x00dc);
17670         MP_WritePhyUshort(sc, 0x19, 0xaefd);
17671         MP_WritePhyUshort(sc, 0x15, 0x00dd);
17672         MP_WritePhyUshort(sc, 0x19, 0x6f0b);
17673         MP_WritePhyUshort(sc, 0x15, 0x00de);
17674         MP_WritePhyUshort(sc, 0x19, 0xc60b);
17675         MP_WritePhyUshort(sc, 0x15, 0x00df);
17676         MP_WritePhyUshort(sc, 0x19, 0x00fa);
17677         MP_WritePhyUshort(sc, 0x15, 0x00e0);
17678         MP_WritePhyUshort(sc, 0x19, 0x30e1);
17679         MP_WritePhyUshort(sc, 0x15, 0x020c);
17680         MP_WritePhyUshort(sc, 0x19, 0x3224);
17681         MP_WritePhyUshort(sc, 0x15, 0x020e);
17682         MP_WritePhyUshort(sc, 0x19, 0x9813);
17683         MP_WritePhyUshort(sc, 0x15, 0x020f);
17684         MP_WritePhyUshort(sc, 0x19, 0x7801);
17685         MP_WritePhyUshort(sc, 0x15, 0x0210);
17686         MP_WritePhyUshort(sc, 0x19, 0x930f);
17687         MP_WritePhyUshort(sc, 0x15, 0x0211);
17688         MP_WritePhyUshort(sc, 0x19, 0x9206);
17689         MP_WritePhyUshort(sc, 0x15, 0x0212);
17690         MP_WritePhyUshort(sc, 0x19, 0x4002);
17691         MP_WritePhyUshort(sc, 0x15, 0x0213);
17692         MP_WritePhyUshort(sc, 0x19, 0x7800);
17693         MP_WritePhyUshort(sc, 0x15, 0x0214);
17694         MP_WritePhyUshort(sc, 0x19, 0x588f);
17695         MP_WritePhyUshort(sc, 0x15, 0x0215);
17696         MP_WritePhyUshort(sc, 0x19, 0x5520);
17697         MP_WritePhyUshort(sc, 0x15, 0x0216);
17698         MP_WritePhyUshort(sc, 0x19, 0x3224);
17699         MP_WritePhyUshort(sc, 0x15, 0x0217);
17700         MP_WritePhyUshort(sc, 0x19, 0x4002);
17701         MP_WritePhyUshort(sc, 0x15, 0x0218);
17702         MP_WritePhyUshort(sc, 0x19, 0x7800);
17703         MP_WritePhyUshort(sc, 0x15, 0x0219);
17704         MP_WritePhyUshort(sc, 0x19, 0x588d);
17705         MP_WritePhyUshort(sc, 0x15, 0x021a);
17706         MP_WritePhyUshort(sc, 0x19, 0x5540);
17707         MP_WritePhyUshort(sc, 0x15, 0x021b);
17708         MP_WritePhyUshort(sc, 0x19, 0x9e03);
17709         MP_WritePhyUshort(sc, 0x15, 0x021c);
17710         MP_WritePhyUshort(sc, 0x19, 0x7c40);
17711         MP_WritePhyUshort(sc, 0x15, 0x021d);
17712         MP_WritePhyUshort(sc, 0x19, 0x6840);
17713         MP_WritePhyUshort(sc, 0x15, 0x021e);
17714         MP_WritePhyUshort(sc, 0x19, 0x3224);
17715         MP_WritePhyUshort(sc, 0x15, 0x021f);
17716         MP_WritePhyUshort(sc, 0x19, 0x4002);
17717         MP_WritePhyUshort(sc, 0x15, 0x0220);
17718         MP_WritePhyUshort(sc, 0x19, 0x3224);
17719         MP_WritePhyUshort(sc, 0x15, 0x0221);
17720         MP_WritePhyUshort(sc, 0x19, 0x9e03);
17721         MP_WritePhyUshort(sc, 0x15, 0x0222);
17722         MP_WritePhyUshort(sc, 0x19, 0x7c40);
17723         MP_WritePhyUshort(sc, 0x15, 0x0223);
17724         MP_WritePhyUshort(sc, 0x19, 0x6840);
17725         MP_WritePhyUshort(sc, 0x15, 0x0224);
17726         MP_WritePhyUshort(sc, 0x19, 0x7800);
17727         MP_WritePhyUshort(sc, 0x15, 0x0225);
17728         MP_WritePhyUshort(sc, 0x19, 0x3231);
17729         MP_WritePhyUshort(sc, 0x15, 0x0000);
17730         MP_WritePhyUshort(sc, 0x16, 0x0306);
17731         MP_WritePhyUshort(sc, 0x16, 0x0300);
17732         MP_WritePhyUshort(sc, 0x1f, 0x0000);
17733         MP_WritePhyUshort(sc, 0x1f, 0x0005);
17734         MP_WritePhyUshort(sc, 0x05, 0xfff6);
17735         MP_WritePhyUshort(sc, 0x06, 0x0080);
17736         MP_WritePhyUshort(sc, 0x05, 0x8000);
17737         MP_WritePhyUshort(sc, 0x06, 0x0280);
17738         MP_WritePhyUshort(sc, 0x06, 0x48f7);
17739         MP_WritePhyUshort(sc, 0x06, 0x00e0);
17740         MP_WritePhyUshort(sc, 0x06, 0xfff7);
17741         MP_WritePhyUshort(sc, 0x06, 0xa080);
17742         MP_WritePhyUshort(sc, 0x06, 0x02ae);
17743         MP_WritePhyUshort(sc, 0x06, 0xf602);
17744         MP_WritePhyUshort(sc, 0x06, 0x011b);
17745         MP_WritePhyUshort(sc, 0x06, 0x0201);
17746         MP_WritePhyUshort(sc, 0x06, 0x2802);
17747         MP_WritePhyUshort(sc, 0x06, 0x0135);
17748         MP_WritePhyUshort(sc, 0x06, 0x0201);
17749         MP_WritePhyUshort(sc, 0x06, 0x4502);
17750         MP_WritePhyUshort(sc, 0x06, 0x015f);
17751         MP_WritePhyUshort(sc, 0x06, 0x0280);
17752         MP_WritePhyUshort(sc, 0x06, 0x6b02);
17753         MP_WritePhyUshort(sc, 0x06, 0x80e5);
17754         MP_WritePhyUshort(sc, 0x06, 0xe08b);
17755         MP_WritePhyUshort(sc, 0x06, 0x88e1);
17756         MP_WritePhyUshort(sc, 0x06, 0x8b89);
17757         MP_WritePhyUshort(sc, 0x06, 0x1e01);
17758         MP_WritePhyUshort(sc, 0x06, 0xe18b);
17759         MP_WritePhyUshort(sc, 0x06, 0x8a1e);
17760         MP_WritePhyUshort(sc, 0x06, 0x01e1);
17761         MP_WritePhyUshort(sc, 0x06, 0x8b8b);
17762         MP_WritePhyUshort(sc, 0x06, 0x1e01);
17763         MP_WritePhyUshort(sc, 0x06, 0xe18b);
17764         MP_WritePhyUshort(sc, 0x06, 0x8c1e);
17765         MP_WritePhyUshort(sc, 0x06, 0x01e1);
17766         MP_WritePhyUshort(sc, 0x06, 0x8b8d);
17767         MP_WritePhyUshort(sc, 0x06, 0x1e01);
17768         MP_WritePhyUshort(sc, 0x06, 0xe18b);
17769         MP_WritePhyUshort(sc, 0x06, 0x8e1e);
17770         MP_WritePhyUshort(sc, 0x06, 0x01a0);
17771         MP_WritePhyUshort(sc, 0x06, 0x00c7);
17772         MP_WritePhyUshort(sc, 0x06, 0xaebb);
17773         MP_WritePhyUshort(sc, 0x06, 0xbf8b);
17774         MP_WritePhyUshort(sc, 0x06, 0x88ec);
17775         MP_WritePhyUshort(sc, 0x06, 0x0019);
17776         MP_WritePhyUshort(sc, 0x06, 0xa98b);
17777         MP_WritePhyUshort(sc, 0x06, 0x90f9);
17778         MP_WritePhyUshort(sc, 0x06, 0xeeff);
17779         MP_WritePhyUshort(sc, 0x06, 0xf600);
17780         MP_WritePhyUshort(sc, 0x06, 0xeeff);
17781         MP_WritePhyUshort(sc, 0x06, 0xf7fe);
17782         MP_WritePhyUshort(sc, 0x06, 0xd100);
17783         MP_WritePhyUshort(sc, 0x06, 0xbf81);
17784         MP_WritePhyUshort(sc, 0x06, 0x9802);
17785         MP_WritePhyUshort(sc, 0x06, 0x39f3);
17786         MP_WritePhyUshort(sc, 0x06, 0xd101);
17787         MP_WritePhyUshort(sc, 0x06, 0xbf81);
17788         MP_WritePhyUshort(sc, 0x06, 0x9b02);
17789         MP_WritePhyUshort(sc, 0x06, 0x39f3);
17790         MP_WritePhyUshort(sc, 0x06, 0x04f8);
17791         MP_WritePhyUshort(sc, 0x06, 0xe08b);
17792         MP_WritePhyUshort(sc, 0x06, 0x8dad);
17793         MP_WritePhyUshort(sc, 0x06, 0x2014);
17794         MP_WritePhyUshort(sc, 0x06, 0xee8b);
17795         MP_WritePhyUshort(sc, 0x06, 0x8d00);
17796         MP_WritePhyUshort(sc, 0x06, 0xe08a);
17797         MP_WritePhyUshort(sc, 0x06, 0x5a78);
17798         MP_WritePhyUshort(sc, 0x06, 0x039e);
17799         MP_WritePhyUshort(sc, 0x06, 0x0902);
17800         MP_WritePhyUshort(sc, 0x06, 0x05fc);
17801         MP_WritePhyUshort(sc, 0x06, 0x0280);
17802         MP_WritePhyUshort(sc, 0x06, 0x8802);
17803         MP_WritePhyUshort(sc, 0x06, 0x32dd);
17804         MP_WritePhyUshort(sc, 0x06, 0xfc04);
17805         MP_WritePhyUshort(sc, 0x06, 0xf8f9);
17806         MP_WritePhyUshort(sc, 0x06, 0xe08b);
17807         MP_WritePhyUshort(sc, 0x06, 0x81ac);
17808         MP_WritePhyUshort(sc, 0x06, 0x261a);
17809         MP_WritePhyUshort(sc, 0x06, 0xe08b);
17810         MP_WritePhyUshort(sc, 0x06, 0x81ac);
17811         MP_WritePhyUshort(sc, 0x06, 0x2114);
17812         MP_WritePhyUshort(sc, 0x06, 0xe08b);
17813         MP_WritePhyUshort(sc, 0x06, 0x85ac);
17814         MP_WritePhyUshort(sc, 0x06, 0x200e);
17815         MP_WritePhyUshort(sc, 0x06, 0xe08b);
17816         MP_WritePhyUshort(sc, 0x06, 0x85ac);
17817         MP_WritePhyUshort(sc, 0x06, 0x2308);
17818         MP_WritePhyUshort(sc, 0x06, 0xe08b);
17819         MP_WritePhyUshort(sc, 0x06, 0x87ac);
17820         MP_WritePhyUshort(sc, 0x06, 0x2402);
17821         MP_WritePhyUshort(sc, 0x06, 0xae38);
17822         MP_WritePhyUshort(sc, 0x06, 0x021a);
17823         MP_WritePhyUshort(sc, 0x06, 0xd6ee);
17824         MP_WritePhyUshort(sc, 0x06, 0xe41c);
17825         MP_WritePhyUshort(sc, 0x06, 0x04ee);
17826         MP_WritePhyUshort(sc, 0x06, 0xe41d);
17827         MP_WritePhyUshort(sc, 0x06, 0x04e2);
17828         MP_WritePhyUshort(sc, 0x06, 0xe07c);
17829         MP_WritePhyUshort(sc, 0x06, 0xe3e0);
17830         MP_WritePhyUshort(sc, 0x06, 0x7de0);
17831         MP_WritePhyUshort(sc, 0x06, 0xe038);
17832         MP_WritePhyUshort(sc, 0x06, 0xe1e0);
17833         MP_WritePhyUshort(sc, 0x06, 0x39ad);
17834         MP_WritePhyUshort(sc, 0x06, 0x2e1b);
17835         MP_WritePhyUshort(sc, 0x06, 0xad39);
17836         MP_WritePhyUshort(sc, 0x06, 0x0dd1);
17837         MP_WritePhyUshort(sc, 0x06, 0x01bf);
17838         MP_WritePhyUshort(sc, 0x06, 0x22c8);
17839         MP_WritePhyUshort(sc, 0x06, 0x0239);
17840         MP_WritePhyUshort(sc, 0x06, 0xf302);
17841         MP_WritePhyUshort(sc, 0x06, 0x21f0);
17842         MP_WritePhyUshort(sc, 0x06, 0xae0b);
17843         MP_WritePhyUshort(sc, 0x06, 0xac38);
17844         MP_WritePhyUshort(sc, 0x06, 0x02ae);
17845         MP_WritePhyUshort(sc, 0x06, 0x0602);
17846         MP_WritePhyUshort(sc, 0x06, 0x222d);
17847         MP_WritePhyUshort(sc, 0x06, 0x0222);
17848         MP_WritePhyUshort(sc, 0x06, 0x7202);
17849         MP_WritePhyUshort(sc, 0x06, 0x1ae7);
17850         MP_WritePhyUshort(sc, 0x06, 0xfdfc);
17851         MP_WritePhyUshort(sc, 0x06, 0x04f8);
17852         MP_WritePhyUshort(sc, 0x06, 0xe08b);
17853         MP_WritePhyUshort(sc, 0x06, 0x8ead);
17854         MP_WritePhyUshort(sc, 0x06, 0x201a);
17855         MP_WritePhyUshort(sc, 0x06, 0xf620);
17856         MP_WritePhyUshort(sc, 0x06, 0xe48b);
17857         MP_WritePhyUshort(sc, 0x06, 0x8e02);
17858         MP_WritePhyUshort(sc, 0x06, 0x2afe);
17859         MP_WritePhyUshort(sc, 0x06, 0x022c);
17860         MP_WritePhyUshort(sc, 0x06, 0x5c02);
17861         MP_WritePhyUshort(sc, 0x06, 0x03c5);
17862         MP_WritePhyUshort(sc, 0x06, 0x0281);
17863         MP_WritePhyUshort(sc, 0x06, 0x6702);
17864         MP_WritePhyUshort(sc, 0x06, 0x2e4f);
17865         MP_WritePhyUshort(sc, 0x06, 0x0204);
17866         MP_WritePhyUshort(sc, 0x06, 0x8902);
17867         MP_WritePhyUshort(sc, 0x06, 0x2f7a);
17868         MP_WritePhyUshort(sc, 0x06, 0xe08b);
17869         MP_WritePhyUshort(sc, 0x06, 0x8ead);
17870         MP_WritePhyUshort(sc, 0x06, 0x210b);
17871         MP_WritePhyUshort(sc, 0x06, 0xf621);
17872         MP_WritePhyUshort(sc, 0x06, 0xe48b);
17873         MP_WritePhyUshort(sc, 0x06, 0x8e02);
17874         MP_WritePhyUshort(sc, 0x06, 0x0445);
17875         MP_WritePhyUshort(sc, 0x06, 0x021c);
17876         MP_WritePhyUshort(sc, 0x06, 0xb8e0);
17877         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
17878         MP_WritePhyUshort(sc, 0x06, 0xad22);
17879         MP_WritePhyUshort(sc, 0x06, 0x08f6);
17880         MP_WritePhyUshort(sc, 0x06, 0x22e4);
17881         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
17882         MP_WritePhyUshort(sc, 0x06, 0x0235);
17883         MP_WritePhyUshort(sc, 0x06, 0xd4e0);
17884         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
17885         MP_WritePhyUshort(sc, 0x06, 0xad23);
17886         MP_WritePhyUshort(sc, 0x06, 0x08f6);
17887         MP_WritePhyUshort(sc, 0x06, 0x23e4);
17888         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
17889         MP_WritePhyUshort(sc, 0x06, 0x0231);
17890         MP_WritePhyUshort(sc, 0x06, 0xc8e0);
17891         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
17892         MP_WritePhyUshort(sc, 0x06, 0xad24);
17893         MP_WritePhyUshort(sc, 0x06, 0x05f6);
17894         MP_WritePhyUshort(sc, 0x06, 0x24e4);
17895         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
17896         MP_WritePhyUshort(sc, 0x06, 0xe08b);
17897         MP_WritePhyUshort(sc, 0x06, 0x8ead);
17898         MP_WritePhyUshort(sc, 0x06, 0x2505);
17899         MP_WritePhyUshort(sc, 0x06, 0xf625);
17900         MP_WritePhyUshort(sc, 0x06, 0xe48b);
17901         MP_WritePhyUshort(sc, 0x06, 0x8ee0);
17902         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
17903         MP_WritePhyUshort(sc, 0x06, 0xad26);
17904         MP_WritePhyUshort(sc, 0x06, 0x08f6);
17905         MP_WritePhyUshort(sc, 0x06, 0x26e4);
17906         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
17907         MP_WritePhyUshort(sc, 0x06, 0x022d);
17908         MP_WritePhyUshort(sc, 0x06, 0x6ae0);
17909         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
17910         MP_WritePhyUshort(sc, 0x06, 0xad27);
17911         MP_WritePhyUshort(sc, 0x06, 0x05f6);
17912         MP_WritePhyUshort(sc, 0x06, 0x27e4);
17913         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
17914         MP_WritePhyUshort(sc, 0x06, 0x0203);
17915         MP_WritePhyUshort(sc, 0x06, 0x8bfc);
17916         MP_WritePhyUshort(sc, 0x06, 0x04f8);
17917         MP_WritePhyUshort(sc, 0x06, 0xfaef);
17918         MP_WritePhyUshort(sc, 0x06, 0x69e0);
17919         MP_WritePhyUshort(sc, 0x06, 0x8b80);
17920         MP_WritePhyUshort(sc, 0x06, 0xad27);
17921         MP_WritePhyUshort(sc, 0x06, 0x22bf);
17922         MP_WritePhyUshort(sc, 0x06, 0x479a);
17923         MP_WritePhyUshort(sc, 0x06, 0x0239);
17924         MP_WritePhyUshort(sc, 0x06, 0xc6e0);
17925         MP_WritePhyUshort(sc, 0x06, 0x8b44);
17926         MP_WritePhyUshort(sc, 0x06, 0x1f01);
17927         MP_WritePhyUshort(sc, 0x06, 0x9e15);
17928         MP_WritePhyUshort(sc, 0x06, 0xe58b);
17929         MP_WritePhyUshort(sc, 0x06, 0x44ad);
17930         MP_WritePhyUshort(sc, 0x06, 0x2907);
17931         MP_WritePhyUshort(sc, 0x06, 0xac28);
17932         MP_WritePhyUshort(sc, 0x06, 0x04d1);
17933         MP_WritePhyUshort(sc, 0x06, 0x01ae);
17934         MP_WritePhyUshort(sc, 0x06, 0x02d1);
17935         MP_WritePhyUshort(sc, 0x06, 0x00bf);
17936         MP_WritePhyUshort(sc, 0x06, 0x819e);
17937         MP_WritePhyUshort(sc, 0x06, 0x0239);
17938         MP_WritePhyUshort(sc, 0x06, 0xf3ef);
17939         MP_WritePhyUshort(sc, 0x06, 0x96fe);
17940         MP_WritePhyUshort(sc, 0x06, 0xfc04);
17941         MP_WritePhyUshort(sc, 0x06, 0x00e1);
17942         MP_WritePhyUshort(sc, 0x06, 0x4077);
17943         MP_WritePhyUshort(sc, 0x06, 0xe140);
17944         MP_WritePhyUshort(sc, 0x06, 0xbbe0);
17945         MP_WritePhyUshort(sc, 0x06, 0x2a00);
17946         MP_WritePhyUshort(sc, 0x05, 0xe142);
17947         PhyRegValue = MP_ReadPhyUshort(sc, 0x06);
17948         PhyRegValue |= BIT_0;
17949         MP_WritePhyUshort(sc, 0x06, PhyRegValue);
17950         MP_WritePhyUshort(sc, 0x05, 0xe140);
17951         PhyRegValue = MP_ReadPhyUshort(sc, 0x06);
17952         PhyRegValue |= BIT_0;
17953         MP_WritePhyUshort(sc, 0x06, PhyRegValue);
17954         MP_WritePhyUshort(sc, 0x1f, 0x0000);
17955         MP_WritePhyUshort(sc, 0x1f, 0x0005);
17956         for (i = 0; i < 200; i++) {
17957                 DELAY(100);
17958                 PhyRegValue = MP_ReadPhyUshort(sc, 0x00);
17959                 if (PhyRegValue & BIT_7)
17960                         break;
17961         }
17962
17963         MP_WritePhyUshort(sc, 0x1f, 0x0007);
17964         MP_WritePhyUshort(sc, 0x1e, 0x0023);
17965         PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
17966         PhyRegValue |= BIT_1;
17967         if (sc->RequiredSecLanDonglePatch)
17968                 PhyRegValue &= ~(BIT_2);
17969         MP_WritePhyUshort(sc, 0x17, PhyRegValue);
17970         MP_WritePhyUshort(sc, 0x1f, 0x0000);
17971
17972         MP_WritePhyUshort(sc, 0x1f, 0x0003);
17973         PhyRegValue = MP_ReadPhyUshort(sc, 0x19);
17974         PhyRegValue &= ~BIT_0;
17975         MP_WritePhyUshort(sc, 0x19, PhyRegValue);
17976         PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
17977         PhyRegValue &= ~BIT_10;
17978         MP_WritePhyUshort(sc, 0x10, PhyRegValue);
17979
17980         MP_WritePhyUshort(sc, 0x1f, 0x0000);
17981         MP_WritePhyUshort(sc, 0x00, 0x9200);
17982 }
17983
17984 static void re_set_phy_mcu_8411_1(struct re_softc *sc)
17985 {
17986         u_int16_t PhyRegValue;
17987         int i;
17988
17989         MP_WritePhyUshort(sc, 0x1f, 0x0000);
17990         MP_WritePhyUshort(sc, 0x00, 0x1800);
17991         PhyRegValue = MP_ReadPhyUshort(sc, 0x15);
17992         PhyRegValue &= ~(BIT_12);
17993         MP_WritePhyUshort(sc, 0x15, PhyRegValue);
17994         MP_WritePhyUshort(sc, 0x00, 0x4800);
17995         MP_WritePhyUshort(sc, 0x1f, 0x0007);
17996         MP_WritePhyUshort(sc, 0x1e, 0x002f);
17997         for (i = 0; i < 1000; i++) {
17998                 DELAY(100);
17999                 PhyRegValue = MP_ReadPhyUshort(sc, 0x1c);
18000                 if (PhyRegValue & BIT_7)
18001                         break;
18002         }
18003         MP_WritePhyUshort(sc, 0x1f, 0x0000);
18004         MP_WritePhyUshort(sc, 0x00, 0x1800);
18005         MP_WritePhyUshort(sc, 0x1f, 0x0007);
18006         MP_WritePhyUshort(sc, 0x1e, 0x0023);
18007         for (i = 0; i < 200; i++) {
18008                 DELAY(100);
18009                 PhyRegValue = MP_ReadPhyUshort(sc, 0x18);
18010                 if (!(PhyRegValue & BIT_0))
18011                         break;
18012         }
18013         MP_WritePhyUshort(sc, 0x1f, 0x0005);
18014         MP_WritePhyUshort(sc, 0x05, 0xfff6);
18015         MP_WritePhyUshort(sc, 0x06, 0x0080);
18016         MP_WritePhyUshort(sc, 0x1f, 0x0007);
18017         MP_WritePhyUshort(sc, 0x1e, 0x0023);
18018         MP_WritePhyUshort(sc, 0x16, 0x0306);
18019         MP_WritePhyUshort(sc, 0x16, 0x0307);
18020         MP_WritePhyUshort(sc, 0x15, 0x0098);
18021         MP_WritePhyUshort(sc, 0x19, 0x7c0b);
18022         MP_WritePhyUshort(sc, 0x15, 0x0099);
18023         MP_WritePhyUshort(sc, 0x19, 0x6c0b);
18024         MP_WritePhyUshort(sc, 0x15, 0x00eb);
18025         MP_WritePhyUshort(sc, 0x19, 0x6c0b);
18026         MP_WritePhyUshort(sc, 0x15, 0x00f8);
18027         MP_WritePhyUshort(sc, 0x19, 0x6f0b);
18028         MP_WritePhyUshort(sc, 0x15, 0x00fe);
18029         MP_WritePhyUshort(sc, 0x19, 0x6f0f);
18030         MP_WritePhyUshort(sc, 0x15, 0x00db);
18031         MP_WritePhyUshort(sc, 0x19, 0x6f09);
18032         MP_WritePhyUshort(sc, 0x15, 0x00dc);
18033         MP_WritePhyUshort(sc, 0x19, 0xaefd);
18034         MP_WritePhyUshort(sc, 0x15, 0x00dd);
18035         MP_WritePhyUshort(sc, 0x19, 0x6f0b);
18036         MP_WritePhyUshort(sc, 0x15, 0x00de);
18037         MP_WritePhyUshort(sc, 0x19, 0xc60b);
18038         MP_WritePhyUshort(sc, 0x15, 0x00df);
18039         MP_WritePhyUshort(sc, 0x19, 0x00fa);
18040         MP_WritePhyUshort(sc, 0x15, 0x00e0);
18041         MP_WritePhyUshort(sc, 0x19, 0x30e1);
18042         MP_WritePhyUshort(sc, 0x15, 0x020c);
18043         MP_WritePhyUshort(sc, 0x19, 0x3224);
18044         MP_WritePhyUshort(sc, 0x15, 0x020e);
18045         MP_WritePhyUshort(sc, 0x19, 0x9813);
18046         MP_WritePhyUshort(sc, 0x15, 0x020f);
18047         MP_WritePhyUshort(sc, 0x19, 0x7801);
18048         MP_WritePhyUshort(sc, 0x15, 0x0210);
18049         MP_WritePhyUshort(sc, 0x19, 0x930f);
18050         MP_WritePhyUshort(sc, 0x15, 0x0211);
18051         MP_WritePhyUshort(sc, 0x19, 0x9206);
18052         MP_WritePhyUshort(sc, 0x15, 0x0212);
18053         MP_WritePhyUshort(sc, 0x19, 0x4002);
18054         MP_WritePhyUshort(sc, 0x15, 0x0213);
18055         MP_WritePhyUshort(sc, 0x19, 0x7800);
18056         MP_WritePhyUshort(sc, 0x15, 0x0214);
18057         MP_WritePhyUshort(sc, 0x19, 0x588f);
18058         MP_WritePhyUshort(sc, 0x15, 0x0215);
18059         MP_WritePhyUshort(sc, 0x19, 0x5520);
18060         MP_WritePhyUshort(sc, 0x15, 0x0216);
18061         MP_WritePhyUshort(sc, 0x19, 0x3224);
18062         MP_WritePhyUshort(sc, 0x15, 0x0217);
18063         MP_WritePhyUshort(sc, 0x19, 0x4002);
18064         MP_WritePhyUshort(sc, 0x15, 0x0218);
18065         MP_WritePhyUshort(sc, 0x19, 0x7800);
18066         MP_WritePhyUshort(sc, 0x15, 0x0219);
18067         MP_WritePhyUshort(sc, 0x19, 0x588d);
18068         MP_WritePhyUshort(sc, 0x15, 0x021a);
18069         MP_WritePhyUshort(sc, 0x19, 0x5540);
18070         MP_WritePhyUshort(sc, 0x15, 0x021b);
18071         MP_WritePhyUshort(sc, 0x19, 0x9e03);
18072         MP_WritePhyUshort(sc, 0x15, 0x021c);
18073         MP_WritePhyUshort(sc, 0x19, 0x7c40);
18074         MP_WritePhyUshort(sc, 0x15, 0x021d);
18075         MP_WritePhyUshort(sc, 0x19, 0x6840);
18076         MP_WritePhyUshort(sc, 0x15, 0x021e);
18077         MP_WritePhyUshort(sc, 0x19, 0x3224);
18078         MP_WritePhyUshort(sc, 0x15, 0x021f);
18079         MP_WritePhyUshort(sc, 0x19, 0x4002);
18080         MP_WritePhyUshort(sc, 0x15, 0x0220);
18081         MP_WritePhyUshort(sc, 0x19, 0x3224);
18082         MP_WritePhyUshort(sc, 0x15, 0x0221);
18083         MP_WritePhyUshort(sc, 0x19, 0x9e03);
18084         MP_WritePhyUshort(sc, 0x15, 0x0222);
18085         MP_WritePhyUshort(sc, 0x19, 0x7c40);
18086         MP_WritePhyUshort(sc, 0x15, 0x0223);
18087         MP_WritePhyUshort(sc, 0x19, 0x6840);
18088         MP_WritePhyUshort(sc, 0x15, 0x0224);
18089         MP_WritePhyUshort(sc, 0x19, 0x7800);
18090         MP_WritePhyUshort(sc, 0x15, 0x0225);
18091         MP_WritePhyUshort(sc, 0x19, 0x3231);
18092         MP_WritePhyUshort(sc, 0x15, 0x0000);
18093         MP_WritePhyUshort(sc, 0x16, 0x0306);
18094         MP_WritePhyUshort(sc, 0x16, 0x0300);
18095         MP_WritePhyUshort(sc, 0x1f, 0x0000);
18096         MP_WritePhyUshort(sc, 0x1f, 0x0005);
18097         MP_WritePhyUshort(sc, 0x05, 0xfff6);
18098         MP_WritePhyUshort(sc, 0x06, 0x0080);
18099         MP_WritePhyUshort(sc, 0x05, 0x8000);
18100         MP_WritePhyUshort(sc, 0x06, 0x0280);
18101         MP_WritePhyUshort(sc, 0x06, 0x48f7);
18102         MP_WritePhyUshort(sc, 0x06, 0x00e0);
18103         MP_WritePhyUshort(sc, 0x06, 0xfff7);
18104         MP_WritePhyUshort(sc, 0x06, 0xa080);
18105         MP_WritePhyUshort(sc, 0x06, 0x02ae);
18106         MP_WritePhyUshort(sc, 0x06, 0xf602);
18107         MP_WritePhyUshort(sc, 0x06, 0x011e);
18108         MP_WritePhyUshort(sc, 0x06, 0x0201);
18109         MP_WritePhyUshort(sc, 0x06, 0x2b02);
18110         MP_WritePhyUshort(sc, 0x06, 0x8077);
18111         MP_WritePhyUshort(sc, 0x06, 0x0201);
18112         MP_WritePhyUshort(sc, 0x06, 0x4802);
18113         MP_WritePhyUshort(sc, 0x06, 0x0162);
18114         MP_WritePhyUshort(sc, 0x06, 0x0280);
18115         MP_WritePhyUshort(sc, 0x06, 0x9402);
18116         MP_WritePhyUshort(sc, 0x06, 0x810e);
18117         MP_WritePhyUshort(sc, 0x06, 0xe08b);
18118         MP_WritePhyUshort(sc, 0x06, 0x88e1);
18119         MP_WritePhyUshort(sc, 0x06, 0x8b89);
18120         MP_WritePhyUshort(sc, 0x06, 0x1e01);
18121         MP_WritePhyUshort(sc, 0x06, 0xe18b);
18122         MP_WritePhyUshort(sc, 0x06, 0x8a1e);
18123         MP_WritePhyUshort(sc, 0x06, 0x01e1);
18124         MP_WritePhyUshort(sc, 0x06, 0x8b8b);
18125         MP_WritePhyUshort(sc, 0x06, 0x1e01);
18126         MP_WritePhyUshort(sc, 0x06, 0xe18b);
18127         MP_WritePhyUshort(sc, 0x06, 0x8c1e);
18128         MP_WritePhyUshort(sc, 0x06, 0x01e1);
18129         MP_WritePhyUshort(sc, 0x06, 0x8b8d);
18130         MP_WritePhyUshort(sc, 0x06, 0x1e01);
18131         MP_WritePhyUshort(sc, 0x06, 0xe18b);
18132         MP_WritePhyUshort(sc, 0x06, 0x8e1e);
18133         MP_WritePhyUshort(sc, 0x06, 0x01a0);
18134         MP_WritePhyUshort(sc, 0x06, 0x00c7);
18135         MP_WritePhyUshort(sc, 0x06, 0xaebb);
18136         MP_WritePhyUshort(sc, 0x06, 0xd481);
18137         MP_WritePhyUshort(sc, 0x06, 0xd4e4);
18138         MP_WritePhyUshort(sc, 0x06, 0x8b92);
18139         MP_WritePhyUshort(sc, 0x06, 0xe58b);
18140         MP_WritePhyUshort(sc, 0x06, 0x9302);
18141         MP_WritePhyUshort(sc, 0x06, 0x2e5a);
18142         MP_WritePhyUshort(sc, 0x06, 0xbf8b);
18143         MP_WritePhyUshort(sc, 0x06, 0x88ec);
18144         MP_WritePhyUshort(sc, 0x06, 0x0019);
18145         MP_WritePhyUshort(sc, 0x06, 0xa98b);
18146         MP_WritePhyUshort(sc, 0x06, 0x90f9);
18147         MP_WritePhyUshort(sc, 0x06, 0xeeff);
18148         MP_WritePhyUshort(sc, 0x06, 0xf600);
18149         MP_WritePhyUshort(sc, 0x06, 0xeeff);
18150         MP_WritePhyUshort(sc, 0x06, 0xf7fc);
18151         MP_WritePhyUshort(sc, 0x06, 0xd100);
18152         MP_WritePhyUshort(sc, 0x06, 0xbf83);
18153         MP_WritePhyUshort(sc, 0x06, 0x3c02);
18154         MP_WritePhyUshort(sc, 0x06, 0x3a21);
18155         MP_WritePhyUshort(sc, 0x06, 0xd101);
18156         MP_WritePhyUshort(sc, 0x06, 0xbf83);
18157         MP_WritePhyUshort(sc, 0x06, 0x3f02);
18158         MP_WritePhyUshort(sc, 0x06, 0x3a21);
18159         MP_WritePhyUshort(sc, 0x06, 0x04f8);
18160         MP_WritePhyUshort(sc, 0x06, 0xe08b);
18161         MP_WritePhyUshort(sc, 0x06, 0x8aad);
18162         MP_WritePhyUshort(sc, 0x06, 0x2014);
18163         MP_WritePhyUshort(sc, 0x06, 0xee8b);
18164         MP_WritePhyUshort(sc, 0x06, 0x8a00);
18165         MP_WritePhyUshort(sc, 0x06, 0x0220);
18166         MP_WritePhyUshort(sc, 0x06, 0x8be0);
18167         MP_WritePhyUshort(sc, 0x06, 0xe426);
18168         MP_WritePhyUshort(sc, 0x06, 0xe1e4);
18169         MP_WritePhyUshort(sc, 0x06, 0x27ee);
18170         MP_WritePhyUshort(sc, 0x06, 0xe426);
18171         MP_WritePhyUshort(sc, 0x06, 0x23e5);
18172         MP_WritePhyUshort(sc, 0x06, 0xe427);
18173         MP_WritePhyUshort(sc, 0x06, 0xfc04);
18174         MP_WritePhyUshort(sc, 0x06, 0xf8e0);
18175         MP_WritePhyUshort(sc, 0x06, 0x8b8d);
18176         MP_WritePhyUshort(sc, 0x06, 0xad20);
18177         MP_WritePhyUshort(sc, 0x06, 0x14ee);
18178         MP_WritePhyUshort(sc, 0x06, 0x8b8d);
18179         MP_WritePhyUshort(sc, 0x06, 0x00e0);
18180         MP_WritePhyUshort(sc, 0x06, 0x8a5a);
18181         MP_WritePhyUshort(sc, 0x06, 0x7803);
18182         MP_WritePhyUshort(sc, 0x06, 0x9e09);
18183         MP_WritePhyUshort(sc, 0x06, 0x0206);
18184         MP_WritePhyUshort(sc, 0x06, 0x2802);
18185         MP_WritePhyUshort(sc, 0x06, 0x80b1);
18186         MP_WritePhyUshort(sc, 0x06, 0x0232);
18187         MP_WritePhyUshort(sc, 0x06, 0xfdfc);
18188         MP_WritePhyUshort(sc, 0x06, 0x04f8);
18189         MP_WritePhyUshort(sc, 0x06, 0xf9e0);
18190         MP_WritePhyUshort(sc, 0x06, 0x8b81);
18191         MP_WritePhyUshort(sc, 0x06, 0xac26);
18192         MP_WritePhyUshort(sc, 0x06, 0x1ae0);
18193         MP_WritePhyUshort(sc, 0x06, 0x8b81);
18194         MP_WritePhyUshort(sc, 0x06, 0xac21);
18195         MP_WritePhyUshort(sc, 0x06, 0x14e0);
18196         MP_WritePhyUshort(sc, 0x06, 0x8b85);
18197         MP_WritePhyUshort(sc, 0x06, 0xac20);
18198         MP_WritePhyUshort(sc, 0x06, 0x0ee0);
18199         MP_WritePhyUshort(sc, 0x06, 0x8b85);
18200         MP_WritePhyUshort(sc, 0x06, 0xac23);
18201         MP_WritePhyUshort(sc, 0x06, 0x08e0);
18202         MP_WritePhyUshort(sc, 0x06, 0x8b87);
18203         MP_WritePhyUshort(sc, 0x06, 0xac24);
18204         MP_WritePhyUshort(sc, 0x06, 0x02ae);
18205         MP_WritePhyUshort(sc, 0x06, 0x3802);
18206         MP_WritePhyUshort(sc, 0x06, 0x1b02);
18207         MP_WritePhyUshort(sc, 0x06, 0xeee4);
18208         MP_WritePhyUshort(sc, 0x06, 0x1c04);
18209         MP_WritePhyUshort(sc, 0x06, 0xeee4);
18210         MP_WritePhyUshort(sc, 0x06, 0x1d04);
18211         MP_WritePhyUshort(sc, 0x06, 0xe2e0);
18212         MP_WritePhyUshort(sc, 0x06, 0x7ce3);
18213         MP_WritePhyUshort(sc, 0x06, 0xe07d);
18214         MP_WritePhyUshort(sc, 0x06, 0xe0e0);
18215         MP_WritePhyUshort(sc, 0x06, 0x38e1);
18216         MP_WritePhyUshort(sc, 0x06, 0xe039);
18217         MP_WritePhyUshort(sc, 0x06, 0xad2e);
18218         MP_WritePhyUshort(sc, 0x06, 0x1bad);
18219         MP_WritePhyUshort(sc, 0x06, 0x390d);
18220         MP_WritePhyUshort(sc, 0x06, 0xd101);
18221         MP_WritePhyUshort(sc, 0x06, 0xbf22);
18222         MP_WritePhyUshort(sc, 0x06, 0xe802);
18223         MP_WritePhyUshort(sc, 0x06, 0x3a21);
18224         MP_WritePhyUshort(sc, 0x06, 0x0222);
18225         MP_WritePhyUshort(sc, 0x06, 0x10ae);
18226         MP_WritePhyUshort(sc, 0x06, 0x0bac);
18227         MP_WritePhyUshort(sc, 0x06, 0x3802);
18228         MP_WritePhyUshort(sc, 0x06, 0xae06);
18229         MP_WritePhyUshort(sc, 0x06, 0x0222);
18230         MP_WritePhyUshort(sc, 0x06, 0x4d02);
18231         MP_WritePhyUshort(sc, 0x06, 0x2292);
18232         MP_WritePhyUshort(sc, 0x06, 0x021b);
18233         MP_WritePhyUshort(sc, 0x06, 0x13fd);
18234         MP_WritePhyUshort(sc, 0x06, 0xfc04);
18235         MP_WritePhyUshort(sc, 0x06, 0xf8e0);
18236         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
18237         MP_WritePhyUshort(sc, 0x06, 0xad20);
18238         MP_WritePhyUshort(sc, 0x06, 0x1af6);
18239         MP_WritePhyUshort(sc, 0x06, 0x20e4);
18240         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
18241         MP_WritePhyUshort(sc, 0x06, 0x022b);
18242         MP_WritePhyUshort(sc, 0x06, 0x1e02);
18243         MP_WritePhyUshort(sc, 0x06, 0x82ae);
18244         MP_WritePhyUshort(sc, 0x06, 0x0203);
18245         MP_WritePhyUshort(sc, 0x06, 0xc002);
18246         MP_WritePhyUshort(sc, 0x06, 0x827d);
18247         MP_WritePhyUshort(sc, 0x06, 0x022e);
18248         MP_WritePhyUshort(sc, 0x06, 0x6f02);
18249         MP_WritePhyUshort(sc, 0x06, 0x047b);
18250         MP_WritePhyUshort(sc, 0x06, 0x022f);
18251         MP_WritePhyUshort(sc, 0x06, 0x9ae0);
18252         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
18253         MP_WritePhyUshort(sc, 0x06, 0xad21);
18254         MP_WritePhyUshort(sc, 0x06, 0x0bf6);
18255         MP_WritePhyUshort(sc, 0x06, 0x21e4);
18256         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
18257         MP_WritePhyUshort(sc, 0x06, 0x0281);
18258         MP_WritePhyUshort(sc, 0x06, 0x9002);
18259         MP_WritePhyUshort(sc, 0x06, 0x1cd9);
18260         MP_WritePhyUshort(sc, 0x06, 0xe08b);
18261         MP_WritePhyUshort(sc, 0x06, 0x8ead);
18262         MP_WritePhyUshort(sc, 0x06, 0x2208);
18263         MP_WritePhyUshort(sc, 0x06, 0xf622);
18264         MP_WritePhyUshort(sc, 0x06, 0xe48b);
18265         MP_WritePhyUshort(sc, 0x06, 0x8e02);
18266         MP_WritePhyUshort(sc, 0x06, 0x35f4);
18267         MP_WritePhyUshort(sc, 0x06, 0xe08b);
18268         MP_WritePhyUshort(sc, 0x06, 0x8ead);
18269         MP_WritePhyUshort(sc, 0x06, 0x2308);
18270         MP_WritePhyUshort(sc, 0x06, 0xf623);
18271         MP_WritePhyUshort(sc, 0x06, 0xe48b);
18272         MP_WritePhyUshort(sc, 0x06, 0x8e02);
18273         MP_WritePhyUshort(sc, 0x06, 0x31e8);
18274         MP_WritePhyUshort(sc, 0x06, 0xe08b);
18275         MP_WritePhyUshort(sc, 0x06, 0x8ead);
18276         MP_WritePhyUshort(sc, 0x06, 0x2405);
18277         MP_WritePhyUshort(sc, 0x06, 0xf624);
18278         MP_WritePhyUshort(sc, 0x06, 0xe48b);
18279         MP_WritePhyUshort(sc, 0x06, 0x8ee0);
18280         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
18281         MP_WritePhyUshort(sc, 0x06, 0xad25);
18282         MP_WritePhyUshort(sc, 0x06, 0x05f6);
18283         MP_WritePhyUshort(sc, 0x06, 0x25e4);
18284         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
18285         MP_WritePhyUshort(sc, 0x06, 0xe08b);
18286         MP_WritePhyUshort(sc, 0x06, 0x8ead);
18287         MP_WritePhyUshort(sc, 0x06, 0x2608);
18288         MP_WritePhyUshort(sc, 0x06, 0xf626);
18289         MP_WritePhyUshort(sc, 0x06, 0xe48b);
18290         MP_WritePhyUshort(sc, 0x06, 0x8e02);
18291         MP_WritePhyUshort(sc, 0x06, 0x2d8a);
18292         MP_WritePhyUshort(sc, 0x06, 0xe08b);
18293         MP_WritePhyUshort(sc, 0x06, 0x8ead);
18294         MP_WritePhyUshort(sc, 0x06, 0x2705);
18295         MP_WritePhyUshort(sc, 0x06, 0xf627);
18296         MP_WritePhyUshort(sc, 0x06, 0xe48b);
18297         MP_WritePhyUshort(sc, 0x06, 0x8e02);
18298         MP_WritePhyUshort(sc, 0x06, 0x0386);
18299         MP_WritePhyUshort(sc, 0x06, 0xfc04);
18300         MP_WritePhyUshort(sc, 0x06, 0xf8fa);
18301         MP_WritePhyUshort(sc, 0x06, 0xef69);
18302         MP_WritePhyUshort(sc, 0x06, 0xe0e0);
18303         MP_WritePhyUshort(sc, 0x06, 0x00e1);
18304         MP_WritePhyUshort(sc, 0x06, 0xe001);
18305         MP_WritePhyUshort(sc, 0x06, 0xad27);
18306         MP_WritePhyUshort(sc, 0x06, 0x32e0);
18307         MP_WritePhyUshort(sc, 0x06, 0x8b40);
18308         MP_WritePhyUshort(sc, 0x06, 0xf720);
18309         MP_WritePhyUshort(sc, 0x06, 0xe48b);
18310         MP_WritePhyUshort(sc, 0x06, 0x40bf);
18311         MP_WritePhyUshort(sc, 0x06, 0x32c1);
18312         MP_WritePhyUshort(sc, 0x06, 0x0239);
18313         MP_WritePhyUshort(sc, 0x06, 0xf4ad);
18314         MP_WritePhyUshort(sc, 0x06, 0x2821);
18315         MP_WritePhyUshort(sc, 0x06, 0xe0e0);
18316         MP_WritePhyUshort(sc, 0x06, 0x20e1);
18317         MP_WritePhyUshort(sc, 0x06, 0xe021);
18318         MP_WritePhyUshort(sc, 0x06, 0xad20);
18319         MP_WritePhyUshort(sc, 0x06, 0x18e0);
18320         MP_WritePhyUshort(sc, 0x06, 0x8b40);
18321         MP_WritePhyUshort(sc, 0x06, 0xf620);
18322         MP_WritePhyUshort(sc, 0x06, 0xe48b);
18323         MP_WritePhyUshort(sc, 0x06, 0x40ee);
18324         MP_WritePhyUshort(sc, 0x06, 0x8b3b);
18325         MP_WritePhyUshort(sc, 0x06, 0xffe0);
18326         MP_WritePhyUshort(sc, 0x06, 0x8a8a);
18327         MP_WritePhyUshort(sc, 0x06, 0xe18a);
18328         MP_WritePhyUshort(sc, 0x06, 0x8be4);
18329         MP_WritePhyUshort(sc, 0x06, 0xe000);
18330         MP_WritePhyUshort(sc, 0x06, 0xe5e0);
18331         MP_WritePhyUshort(sc, 0x06, 0x01ef);
18332         MP_WritePhyUshort(sc, 0x06, 0x96fe);
18333         MP_WritePhyUshort(sc, 0x06, 0xfc04);
18334         MP_WritePhyUshort(sc, 0x06, 0xf8f9);
18335         MP_WritePhyUshort(sc, 0x06, 0xface);
18336         MP_WritePhyUshort(sc, 0x06, 0xfaef);
18337         MP_WritePhyUshort(sc, 0x06, 0x69fa);
18338         MP_WritePhyUshort(sc, 0x06, 0xd401);
18339         MP_WritePhyUshort(sc, 0x06, 0x55b4);
18340         MP_WritePhyUshort(sc, 0x06, 0xfebf);
18341         MP_WritePhyUshort(sc, 0x06, 0x1c5e);
18342         MP_WritePhyUshort(sc, 0x06, 0x0239);
18343         MP_WritePhyUshort(sc, 0x06, 0xf4ac);
18344         MP_WritePhyUshort(sc, 0x06, 0x280b);
18345         MP_WritePhyUshort(sc, 0x06, 0xbf1c);
18346         MP_WritePhyUshort(sc, 0x06, 0x5b02);
18347         MP_WritePhyUshort(sc, 0x06, 0x39f4);
18348         MP_WritePhyUshort(sc, 0x06, 0xac28);
18349         MP_WritePhyUshort(sc, 0x06, 0x49ae);
18350         MP_WritePhyUshort(sc, 0x06, 0x64bf);
18351         MP_WritePhyUshort(sc, 0x06, 0x1c5b);
18352         MP_WritePhyUshort(sc, 0x06, 0x0239);
18353         MP_WritePhyUshort(sc, 0x06, 0xf4ac);
18354         MP_WritePhyUshort(sc, 0x06, 0x285b);
18355         MP_WritePhyUshort(sc, 0x06, 0xd000);
18356         MP_WritePhyUshort(sc, 0x06, 0x0282);
18357         MP_WritePhyUshort(sc, 0x06, 0x62ac);
18358         MP_WritePhyUshort(sc, 0x06, 0x2105);
18359         MP_WritePhyUshort(sc, 0x06, 0xac22);
18360         MP_WritePhyUshort(sc, 0x06, 0x02ae);
18361         MP_WritePhyUshort(sc, 0x06, 0x4ebf);
18362         MP_WritePhyUshort(sc, 0x06, 0xe0c4);
18363         MP_WritePhyUshort(sc, 0x06, 0xbe85);
18364         MP_WritePhyUshort(sc, 0x06, 0xecd2);
18365         MP_WritePhyUshort(sc, 0x06, 0x04d8);
18366         MP_WritePhyUshort(sc, 0x06, 0x19d9);
18367         MP_WritePhyUshort(sc, 0x06, 0x1907);
18368         MP_WritePhyUshort(sc, 0x06, 0xdc19);
18369         MP_WritePhyUshort(sc, 0x06, 0xdd19);
18370         MP_WritePhyUshort(sc, 0x06, 0x0789);
18371         MP_WritePhyUshort(sc, 0x06, 0x89ef);
18372         MP_WritePhyUshort(sc, 0x06, 0x645e);
18373         MP_WritePhyUshort(sc, 0x06, 0x07ff);
18374         MP_WritePhyUshort(sc, 0x06, 0x0d65);
18375         MP_WritePhyUshort(sc, 0x06, 0x5cf8);
18376         MP_WritePhyUshort(sc, 0x06, 0x001e);
18377         MP_WritePhyUshort(sc, 0x06, 0x46dc);
18378         MP_WritePhyUshort(sc, 0x06, 0x19dd);
18379         MP_WritePhyUshort(sc, 0x06, 0x19b2);
18380         MP_WritePhyUshort(sc, 0x06, 0xe2d4);
18381         MP_WritePhyUshort(sc, 0x06, 0x0001);
18382         MP_WritePhyUshort(sc, 0x06, 0xbf1c);
18383         MP_WritePhyUshort(sc, 0x06, 0x5b02);
18384         MP_WritePhyUshort(sc, 0x06, 0x3a21);
18385         MP_WritePhyUshort(sc, 0x06, 0xae1d);
18386         MP_WritePhyUshort(sc, 0x06, 0xbee0);
18387         MP_WritePhyUshort(sc, 0x06, 0xc4bf);
18388         MP_WritePhyUshort(sc, 0x06, 0x85ec);
18389         MP_WritePhyUshort(sc, 0x06, 0xd204);
18390         MP_WritePhyUshort(sc, 0x06, 0xd819);
18391         MP_WritePhyUshort(sc, 0x06, 0xd919);
18392         MP_WritePhyUshort(sc, 0x06, 0x07dc);
18393         MP_WritePhyUshort(sc, 0x06, 0x19dd);
18394         MP_WritePhyUshort(sc, 0x06, 0x1907);
18395         MP_WritePhyUshort(sc, 0x06, 0xb2f4);
18396         MP_WritePhyUshort(sc, 0x06, 0xd400);
18397         MP_WritePhyUshort(sc, 0x06, 0x00bf);
18398         MP_WritePhyUshort(sc, 0x06, 0x1c5b);
18399         MP_WritePhyUshort(sc, 0x06, 0x023a);
18400         MP_WritePhyUshort(sc, 0x06, 0x21fe);
18401         MP_WritePhyUshort(sc, 0x06, 0xef96);
18402         MP_WritePhyUshort(sc, 0x06, 0xfec6);
18403         MP_WritePhyUshort(sc, 0x06, 0xfefd);
18404         MP_WritePhyUshort(sc, 0x06, 0xfc05);
18405         MP_WritePhyUshort(sc, 0x06, 0xf9e2);
18406         MP_WritePhyUshort(sc, 0x06, 0xe0ea);
18407         MP_WritePhyUshort(sc, 0x06, 0xe3e0);
18408         MP_WritePhyUshort(sc, 0x06, 0xeb5a);
18409         MP_WritePhyUshort(sc, 0x06, 0x070c);
18410         MP_WritePhyUshort(sc, 0x06, 0x031e);
18411         MP_WritePhyUshort(sc, 0x06, 0x20e6);
18412         MP_WritePhyUshort(sc, 0x06, 0xe0ea);
18413         MP_WritePhyUshort(sc, 0x06, 0xe7e0);
18414         MP_WritePhyUshort(sc, 0x06, 0xebe0);
18415         MP_WritePhyUshort(sc, 0x06, 0xe0fc);
18416         MP_WritePhyUshort(sc, 0x06, 0xe1e0);
18417         MP_WritePhyUshort(sc, 0x06, 0xfdfd);
18418         MP_WritePhyUshort(sc, 0x06, 0x04f8);
18419         MP_WritePhyUshort(sc, 0x06, 0xfaef);
18420         MP_WritePhyUshort(sc, 0x06, 0x69e0);
18421         MP_WritePhyUshort(sc, 0x06, 0x8b80);
18422         MP_WritePhyUshort(sc, 0x06, 0xad27);
18423         MP_WritePhyUshort(sc, 0x06, 0x22bf);
18424         MP_WritePhyUshort(sc, 0x06, 0x47ba);
18425         MP_WritePhyUshort(sc, 0x06, 0x0239);
18426         MP_WritePhyUshort(sc, 0x06, 0xf4e0);
18427         MP_WritePhyUshort(sc, 0x06, 0x8b44);
18428         MP_WritePhyUshort(sc, 0x06, 0x1f01);
18429         MP_WritePhyUshort(sc, 0x06, 0x9e15);
18430         MP_WritePhyUshort(sc, 0x06, 0xe58b);
18431         MP_WritePhyUshort(sc, 0x06, 0x44ad);
18432         MP_WritePhyUshort(sc, 0x06, 0x2907);
18433         MP_WritePhyUshort(sc, 0x06, 0xac28);
18434         MP_WritePhyUshort(sc, 0x06, 0x04d1);
18435         MP_WritePhyUshort(sc, 0x06, 0x01ae);
18436         MP_WritePhyUshort(sc, 0x06, 0x02d1);
18437         MP_WritePhyUshort(sc, 0x06, 0x00bf);
18438         MP_WritePhyUshort(sc, 0x06, 0x8342);
18439         MP_WritePhyUshort(sc, 0x06, 0x023a);
18440         MP_WritePhyUshort(sc, 0x06, 0x21ef);
18441         MP_WritePhyUshort(sc, 0x06, 0x96fe);
18442         MP_WritePhyUshort(sc, 0x06, 0xfc04);
18443         MP_WritePhyUshort(sc, 0x06, 0xf8e0);
18444         MP_WritePhyUshort(sc, 0x06, 0x8b85);
18445         MP_WritePhyUshort(sc, 0x06, 0xad26);
18446         MP_WritePhyUshort(sc, 0x06, 0x30e0);
18447         MP_WritePhyUshort(sc, 0x06, 0xe036);
18448         MP_WritePhyUshort(sc, 0x06, 0xe1e0);
18449         MP_WritePhyUshort(sc, 0x06, 0x37e1);
18450         MP_WritePhyUshort(sc, 0x06, 0x8b3f);
18451         MP_WritePhyUshort(sc, 0x06, 0x1f10);
18452         MP_WritePhyUshort(sc, 0x06, 0x9e23);
18453         MP_WritePhyUshort(sc, 0x06, 0xe48b);
18454         MP_WritePhyUshort(sc, 0x06, 0x3fac);
18455         MP_WritePhyUshort(sc, 0x06, 0x200b);
18456         MP_WritePhyUshort(sc, 0x06, 0xac21);
18457         MP_WritePhyUshort(sc, 0x06, 0x0dac);
18458         MP_WritePhyUshort(sc, 0x06, 0x250f);
18459         MP_WritePhyUshort(sc, 0x06, 0xac27);
18460         MP_WritePhyUshort(sc, 0x06, 0x11ae);
18461         MP_WritePhyUshort(sc, 0x06, 0x1202);
18462         MP_WritePhyUshort(sc, 0x06, 0x2cb5);
18463         MP_WritePhyUshort(sc, 0x06, 0xae0d);
18464         MP_WritePhyUshort(sc, 0x06, 0x0282);
18465         MP_WritePhyUshort(sc, 0x06, 0xe7ae);
18466         MP_WritePhyUshort(sc, 0x06, 0x0802);
18467         MP_WritePhyUshort(sc, 0x06, 0x2cd7);
18468         MP_WritePhyUshort(sc, 0x06, 0xae03);
18469         MP_WritePhyUshort(sc, 0x06, 0x022c);
18470         MP_WritePhyUshort(sc, 0x06, 0xeafc);
18471         MP_WritePhyUshort(sc, 0x06, 0x04f8);
18472         MP_WritePhyUshort(sc, 0x06, 0xfaef);
18473         MP_WritePhyUshort(sc, 0x06, 0x6902);
18474         MP_WritePhyUshort(sc, 0x06, 0x8304);
18475         MP_WritePhyUshort(sc, 0x06, 0xe0e0);
18476         MP_WritePhyUshort(sc, 0x06, 0x14e1);
18477         MP_WritePhyUshort(sc, 0x06, 0xe015);
18478         MP_WritePhyUshort(sc, 0x06, 0xad26);
18479         MP_WritePhyUshort(sc, 0x06, 0x08d1);
18480         MP_WritePhyUshort(sc, 0x06, 0x1ebf);
18481         MP_WritePhyUshort(sc, 0x06, 0x2d47);
18482         MP_WritePhyUshort(sc, 0x06, 0x023a);
18483         MP_WritePhyUshort(sc, 0x06, 0x21ef);
18484         MP_WritePhyUshort(sc, 0x06, 0x96fe);
18485         MP_WritePhyUshort(sc, 0x06, 0xfc04);
18486         MP_WritePhyUshort(sc, 0x06, 0xf8e0);
18487         MP_WritePhyUshort(sc, 0x06, 0x8b85);
18488         MP_WritePhyUshort(sc, 0x06, 0xad27);
18489         MP_WritePhyUshort(sc, 0x06, 0x2fd0);
18490         MP_WritePhyUshort(sc, 0x06, 0x0b02);
18491         MP_WritePhyUshort(sc, 0x06, 0x3826);
18492         MP_WritePhyUshort(sc, 0x06, 0x5882);
18493         MP_WritePhyUshort(sc, 0x06, 0x7882);
18494         MP_WritePhyUshort(sc, 0x06, 0x9f24);
18495         MP_WritePhyUshort(sc, 0x06, 0xe08b);
18496         MP_WritePhyUshort(sc, 0x06, 0x32e1);
18497         MP_WritePhyUshort(sc, 0x06, 0x8b33);
18498         MP_WritePhyUshort(sc, 0x06, 0x1f10);
18499         MP_WritePhyUshort(sc, 0x06, 0x9e1a);
18500         MP_WritePhyUshort(sc, 0x06, 0x10e4);
18501         MP_WritePhyUshort(sc, 0x06, 0x8b32);
18502         MP_WritePhyUshort(sc, 0x06, 0xe0e0);
18503         MP_WritePhyUshort(sc, 0x06, 0x28e1);
18504         MP_WritePhyUshort(sc, 0x06, 0xe029);
18505         MP_WritePhyUshort(sc, 0x06, 0xf72c);
18506         MP_WritePhyUshort(sc, 0x06, 0xe4e0);
18507         MP_WritePhyUshort(sc, 0x06, 0x28e5);
18508         MP_WritePhyUshort(sc, 0x06, 0xe029);
18509         MP_WritePhyUshort(sc, 0x06, 0xf62c);
18510         MP_WritePhyUshort(sc, 0x06, 0xe4e0);
18511         MP_WritePhyUshort(sc, 0x06, 0x28e5);
18512         MP_WritePhyUshort(sc, 0x06, 0xe029);
18513         MP_WritePhyUshort(sc, 0x06, 0xfc04);
18514         MP_WritePhyUshort(sc, 0x06, 0x00e1);
18515         MP_WritePhyUshort(sc, 0x06, 0x4077);
18516         MP_WritePhyUshort(sc, 0x06, 0xe140);
18517         MP_WritePhyUshort(sc, 0x06, 0xbbe0);
18518         MP_WritePhyUshort(sc, 0x06, 0x2a00);
18519         MP_WritePhyUshort(sc, 0x05, 0xe142);
18520         PhyRegValue = MP_ReadPhyUshort(sc, 0x06);
18521         PhyRegValue |= BIT_0;
18522         MP_WritePhyUshort(sc, 0x06,PhyRegValue);
18523         MP_WritePhyUshort(sc, 0x05, 0xe140);
18524         PhyRegValue = MP_ReadPhyUshort(sc, 0x06);
18525         PhyRegValue |= BIT_0;
18526         MP_WritePhyUshort(sc, 0x06, PhyRegValue);
18527         MP_WritePhyUshort(sc, 0x1f, 0x0000);
18528         MP_WritePhyUshort(sc, 0x1f, 0x0005);
18529         for (i = 0; i < 200; i++) {
18530                 DELAY(100);
18531                 PhyRegValue = MP_ReadPhyUshort(sc, 0x00);
18532                 if (PhyRegValue & BIT_7)
18533                         break;
18534         }
18535         MP_WritePhyUshort(sc, 0x1f, 0x0007);
18536         MP_WritePhyUshort(sc, 0x1e, 0x0023);
18537         PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
18538         PhyRegValue |= BIT_1;
18539         if (sc->RequiredSecLanDonglePatch)
18540                 PhyRegValue &= ~(BIT_2);
18541         MP_WritePhyUshort(sc, 0x17, PhyRegValue);
18542         MP_WritePhyUshort(sc, 0x1f, 0x0000);
18543         MP_WritePhyUshort(sc, 0x1f, 0x0003);
18544         MP_WritePhyUshort(sc, 0x09, 0xA20F);
18545         MP_WritePhyUshort(sc, 0x1f, 0x0000);
18546         MP_WritePhyUshort(sc, 0x1f, 0x0003);
18547         MP_WritePhyUshort(sc, 0x01, 0x328A);
18548         MP_WritePhyUshort(sc, 0x1f, 0x0000);
18549         MP_WritePhyUshort(sc, 0x1f, 0x0003);
18550         PhyRegValue = MP_ReadPhyUshort(sc, 0x19);
18551         PhyRegValue &= ~BIT_0;
18552         MP_WritePhyUshort(sc, 0x19, PhyRegValue);
18553         PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
18554         PhyRegValue &= ~BIT_10;
18555         MP_WritePhyUshort(sc, 0x10, PhyRegValue);
18556         MP_WritePhyUshort(sc, 0x1f, 0x0000);
18557         MP_WritePhyUshort(sc, 0x00, 0x9200);
18558 }
18559
18560 static void re_set_phy_mcu_8168g_1(struct re_softc *sc)
18561 {
18562         u_int16_t PhyRegValue;
18563         u_int32_t WaitCnt;
18564
18565         MP_WritePhyUshort(sc, 0x1f, 0x0B82);
18566         PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
18567         PhyRegValue |= BIT_4;
18568         MP_WritePhyUshort(sc, 0x10, PhyRegValue);
18569
18570         MP_WritePhyUshort(sc, 0x1f, 0x0B80);
18571         WaitCnt = 0;
18572         do {
18573                 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
18574                 PhyRegValue &= 0x0040;
18575                 DELAY(50);
18576                 DELAY(50);
18577                 WaitCnt++;
18578         } while(PhyRegValue != 0x0040 && WaitCnt <1000);
18579
18580         MP_WritePhyUshort(sc, 0x1f, 0x0A43);
18581         MP_WritePhyUshort(sc, 0x13, 0x8146);
18582         MP_WritePhyUshort(sc, 0x14, 0x2300);
18583         MP_WritePhyUshort(sc, 0x13, 0xB820);
18584         MP_WritePhyUshort(sc, 0x14, 0x0210);
18585
18586         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
18587         MP_WritePhyUshort(sc, 0x13, 0xB820);
18588         MP_WritePhyUshort(sc, 0x14, 0x0290);
18589         MP_WritePhyUshort(sc, 0x13, 0xA012);
18590         MP_WritePhyUshort(sc, 0x14, 0x0000);
18591         MP_WritePhyUshort(sc, 0x13, 0xA014);
18592         MP_WritePhyUshort(sc, 0x14, 0x2c04);
18593         MP_WritePhyUshort(sc, 0x14, 0x2c0c);
18594         MP_WritePhyUshort(sc, 0x14, 0x2c6c);
18595         MP_WritePhyUshort(sc, 0x14, 0x2d0d);
18596         MP_WritePhyUshort(sc, 0x14, 0x31ce);
18597         MP_WritePhyUshort(sc, 0x14, 0x506d);
18598         MP_WritePhyUshort(sc, 0x14, 0xd708);
18599         MP_WritePhyUshort(sc, 0x14, 0x3108);
18600         MP_WritePhyUshort(sc, 0x14, 0x106d);
18601         MP_WritePhyUshort(sc, 0x14, 0x1560);
18602         MP_WritePhyUshort(sc, 0x14, 0x15a9);
18603         MP_WritePhyUshort(sc, 0x14, 0x206e);
18604         MP_WritePhyUshort(sc, 0x14, 0x175b);
18605         MP_WritePhyUshort(sc, 0x14, 0x6062);
18606         MP_WritePhyUshort(sc, 0x14, 0xd700);
18607         MP_WritePhyUshort(sc, 0x14, 0x5fae);
18608         MP_WritePhyUshort(sc, 0x14, 0xd708);
18609         MP_WritePhyUshort(sc, 0x14, 0x3107);
18610         MP_WritePhyUshort(sc, 0x14, 0x4c1e);
18611         MP_WritePhyUshort(sc, 0x14, 0x4169);
18612         MP_WritePhyUshort(sc, 0x14, 0x316a);
18613         MP_WritePhyUshort(sc, 0x14, 0x0c19);
18614         MP_WritePhyUshort(sc, 0x14, 0x31aa);
18615         MP_WritePhyUshort(sc, 0x14, 0x0c19);
18616         MP_WritePhyUshort(sc, 0x14, 0x2c1b);
18617         MP_WritePhyUshort(sc, 0x14, 0x5e62);
18618         MP_WritePhyUshort(sc, 0x14, 0x26b5);
18619         MP_WritePhyUshort(sc, 0x14, 0x31ab);
18620         MP_WritePhyUshort(sc, 0x14, 0x5c1e);
18621         MP_WritePhyUshort(sc, 0x14, 0x2c0c);
18622         MP_WritePhyUshort(sc, 0x14, 0xc040);
18623         MP_WritePhyUshort(sc, 0x14, 0x8808);
18624         MP_WritePhyUshort(sc, 0x14, 0xc520);
18625         MP_WritePhyUshort(sc, 0x14, 0xc421);
18626         MP_WritePhyUshort(sc, 0x14, 0xd05a);
18627         MP_WritePhyUshort(sc, 0x14, 0xd19a);
18628         MP_WritePhyUshort(sc, 0x14, 0xd709);
18629         MP_WritePhyUshort(sc, 0x14, 0x608f);
18630         MP_WritePhyUshort(sc, 0x14, 0xd06b);
18631         MP_WritePhyUshort(sc, 0x14, 0xd18a);
18632         MP_WritePhyUshort(sc, 0x14, 0x2c2c);
18633         MP_WritePhyUshort(sc, 0x14, 0xd0be);
18634         MP_WritePhyUshort(sc, 0x14, 0xd188);
18635         MP_WritePhyUshort(sc, 0x14, 0x2c2c);
18636         MP_WritePhyUshort(sc, 0x14, 0xd708);
18637         MP_WritePhyUshort(sc, 0x14, 0x4072);
18638         MP_WritePhyUshort(sc, 0x14, 0xc104);
18639         MP_WritePhyUshort(sc, 0x14, 0x2c3e);
18640         MP_WritePhyUshort(sc, 0x14, 0x4076);
18641         MP_WritePhyUshort(sc, 0x14, 0xc110);
18642         MP_WritePhyUshort(sc, 0x14, 0x2c3e);
18643         MP_WritePhyUshort(sc, 0x14, 0x4071);
18644         MP_WritePhyUshort(sc, 0x14, 0xc102);
18645         MP_WritePhyUshort(sc, 0x14, 0x2c3e);
18646         MP_WritePhyUshort(sc, 0x14, 0x4070);
18647         MP_WritePhyUshort(sc, 0x14, 0xc101);
18648         MP_WritePhyUshort(sc, 0x14, 0x2c3e);
18649         MP_WritePhyUshort(sc, 0x14, 0x175b);
18650         MP_WritePhyUshort(sc, 0x14, 0xd709);
18651         MP_WritePhyUshort(sc, 0x14, 0x3390);
18652         MP_WritePhyUshort(sc, 0x14, 0x5c39);
18653         MP_WritePhyUshort(sc, 0x14, 0x2c4e);
18654         MP_WritePhyUshort(sc, 0x14, 0x175b);
18655         MP_WritePhyUshort(sc, 0x14, 0xd708);
18656         MP_WritePhyUshort(sc, 0x14, 0x6193);
18657         MP_WritePhyUshort(sc, 0x14, 0xd709);
18658         MP_WritePhyUshort(sc, 0x14, 0x5f9d);
18659         MP_WritePhyUshort(sc, 0x14, 0x408b);
18660         MP_WritePhyUshort(sc, 0x14, 0xd71e);
18661         MP_WritePhyUshort(sc, 0x14, 0x6042);
18662         MP_WritePhyUshort(sc, 0x14, 0xb401);
18663         MP_WritePhyUshort(sc, 0x14, 0x175b);
18664         MP_WritePhyUshort(sc, 0x14, 0xd708);
18665         MP_WritePhyUshort(sc, 0x14, 0x6073);
18666         MP_WritePhyUshort(sc, 0x14, 0x5fbc);
18667         MP_WritePhyUshort(sc, 0x14, 0x2c4d);
18668         MP_WritePhyUshort(sc, 0x14, 0x26ed);
18669         MP_WritePhyUshort(sc, 0x14, 0xb280);
18670         MP_WritePhyUshort(sc, 0x14, 0xa841);
18671         MP_WritePhyUshort(sc, 0x14, 0x9420);
18672         MP_WritePhyUshort(sc, 0x14, 0x8710);
18673         MP_WritePhyUshort(sc, 0x14, 0xd709);
18674         MP_WritePhyUshort(sc, 0x14, 0x42ec);
18675         MP_WritePhyUshort(sc, 0x14, 0x606d);
18676         MP_WritePhyUshort(sc, 0x14, 0xd207);
18677         MP_WritePhyUshort(sc, 0x14, 0x2c57);
18678         MP_WritePhyUshort(sc, 0x14, 0xd203);
18679         MP_WritePhyUshort(sc, 0x14, 0x33ff);
18680         MP_WritePhyUshort(sc, 0x14, 0x563b);
18681         MP_WritePhyUshort(sc, 0x14, 0x3275);
18682         MP_WritePhyUshort(sc, 0x14, 0x7c5e);
18683         MP_WritePhyUshort(sc, 0x14, 0xb240);
18684         MP_WritePhyUshort(sc, 0x14, 0xb402);
18685         MP_WritePhyUshort(sc, 0x14, 0x263b);
18686         MP_WritePhyUshort(sc, 0x14, 0x6096);
18687         MP_WritePhyUshort(sc, 0x14, 0xb240);
18688         MP_WritePhyUshort(sc, 0x14, 0xb406);
18689         MP_WritePhyUshort(sc, 0x14, 0x263b);
18690         MP_WritePhyUshort(sc, 0x14, 0x31d7);
18691         MP_WritePhyUshort(sc, 0x14, 0x7c67);
18692         MP_WritePhyUshort(sc, 0x14, 0xb240);
18693         MP_WritePhyUshort(sc, 0x14, 0xb40e);
18694         MP_WritePhyUshort(sc, 0x14, 0x263b);
18695         MP_WritePhyUshort(sc, 0x14, 0xb410);
18696         MP_WritePhyUshort(sc, 0x14, 0x8802);
18697         MP_WritePhyUshort(sc, 0x14, 0xb240);
18698         MP_WritePhyUshort(sc, 0x14, 0x940e);
18699         MP_WritePhyUshort(sc, 0x14, 0x263b);
18700         MP_WritePhyUshort(sc, 0x14, 0xba04);
18701         MP_WritePhyUshort(sc, 0x14, 0x1cd6);
18702         MP_WritePhyUshort(sc, 0x14, 0xa902);
18703         MP_WritePhyUshort(sc, 0x14, 0xd711);
18704         MP_WritePhyUshort(sc, 0x14, 0x4045);
18705         MP_WritePhyUshort(sc, 0x14, 0xa980);
18706         MP_WritePhyUshort(sc, 0x14, 0x3003);
18707         MP_WritePhyUshort(sc, 0x14, 0x59b1);
18708         MP_WritePhyUshort(sc, 0x14, 0xa540);
18709         MP_WritePhyUshort(sc, 0x14, 0xa601);
18710         MP_WritePhyUshort(sc, 0x14, 0xd710);
18711         MP_WritePhyUshort(sc, 0x14, 0x4043);
18712         MP_WritePhyUshort(sc, 0x14, 0xa910);
18713         MP_WritePhyUshort(sc, 0x14, 0xd711);
18714         MP_WritePhyUshort(sc, 0x14, 0x60a0);
18715         MP_WritePhyUshort(sc, 0x14, 0xca33);
18716         MP_WritePhyUshort(sc, 0x14, 0xcb33);
18717         MP_WritePhyUshort(sc, 0x14, 0xa941);
18718         MP_WritePhyUshort(sc, 0x14, 0x2c82);
18719         MP_WritePhyUshort(sc, 0x14, 0xcaff);
18720         MP_WritePhyUshort(sc, 0x14, 0xcbff);
18721         MP_WritePhyUshort(sc, 0x14, 0xa921);
18722         MP_WritePhyUshort(sc, 0x14, 0xce02);
18723         MP_WritePhyUshort(sc, 0x14, 0xe070);
18724         MP_WritePhyUshort(sc, 0x14, 0x0f10);
18725         MP_WritePhyUshort(sc, 0x14, 0xaf01);
18726         MP_WritePhyUshort(sc, 0x14, 0x8f01);
18727         MP_WritePhyUshort(sc, 0x14, 0x1766);
18728         MP_WritePhyUshort(sc, 0x14, 0x8e02);
18729         MP_WritePhyUshort(sc, 0x14, 0x1787);
18730         MP_WritePhyUshort(sc, 0x14, 0xd710);
18731         MP_WritePhyUshort(sc, 0x14, 0x609c);
18732         MP_WritePhyUshort(sc, 0x14, 0xd71e);
18733         MP_WritePhyUshort(sc, 0x14, 0x7fa4);
18734         MP_WritePhyUshort(sc, 0x14, 0x2cd4);
18735         MP_WritePhyUshort(sc, 0x14, 0x1ce9);
18736         MP_WritePhyUshort(sc, 0x14, 0xce04);
18737         MP_WritePhyUshort(sc, 0x14, 0xe070);
18738         MP_WritePhyUshort(sc, 0x14, 0x0f20);
18739         MP_WritePhyUshort(sc, 0x14, 0xaf01);
18740         MP_WritePhyUshort(sc, 0x14, 0x8f01);
18741         MP_WritePhyUshort(sc, 0x14, 0x1766);
18742         MP_WritePhyUshort(sc, 0x14, 0x8e04);
18743         MP_WritePhyUshort(sc, 0x14, 0x6044);
18744         MP_WritePhyUshort(sc, 0x14, 0x2cd4);
18745         MP_WritePhyUshort(sc, 0x14, 0xa520);
18746         MP_WritePhyUshort(sc, 0x14, 0xd710);
18747         MP_WritePhyUshort(sc, 0x14, 0x4043);
18748         MP_WritePhyUshort(sc, 0x14, 0x2cc1);
18749         MP_WritePhyUshort(sc, 0x14, 0xe00f);
18750         MP_WritePhyUshort(sc, 0x14, 0x0501);
18751         MP_WritePhyUshort(sc, 0x14, 0x1cef);
18752         MP_WritePhyUshort(sc, 0x14, 0xb801);
18753         MP_WritePhyUshort(sc, 0x14, 0xd71e);
18754         MP_WritePhyUshort(sc, 0x14, 0x4060);
18755         MP_WritePhyUshort(sc, 0x14, 0x7fc4);
18756         MP_WritePhyUshort(sc, 0x14, 0x2cd4);
18757         MP_WritePhyUshort(sc, 0x14, 0x1cf5);
18758         MP_WritePhyUshort(sc, 0x14, 0xe00f);
18759         MP_WritePhyUshort(sc, 0x14, 0x0502);
18760         MP_WritePhyUshort(sc, 0x14, 0x1cef);
18761         MP_WritePhyUshort(sc, 0x14, 0xb802);
18762         MP_WritePhyUshort(sc, 0x14, 0xd71e);
18763         MP_WritePhyUshort(sc, 0x14, 0x4061);
18764         MP_WritePhyUshort(sc, 0x14, 0x7fc4);
18765         MP_WritePhyUshort(sc, 0x14, 0x2cd4);
18766         MP_WritePhyUshort(sc, 0x14, 0x1cf5);
18767         MP_WritePhyUshort(sc, 0x14, 0xe00f);
18768         MP_WritePhyUshort(sc, 0x14, 0x0504);
18769         MP_WritePhyUshort(sc, 0x14, 0xd710);
18770         MP_WritePhyUshort(sc, 0x14, 0x6099);
18771         MP_WritePhyUshort(sc, 0x14, 0xd71e);
18772         MP_WritePhyUshort(sc, 0x14, 0x7fa4);
18773         MP_WritePhyUshort(sc, 0x14, 0x2cd4);
18774         MP_WritePhyUshort(sc, 0x14, 0xc17f);
18775         MP_WritePhyUshort(sc, 0x14, 0xc200);
18776         MP_WritePhyUshort(sc, 0x14, 0xc43f);
18777         MP_WritePhyUshort(sc, 0x14, 0xcc03);
18778         MP_WritePhyUshort(sc, 0x14, 0xa701);
18779         MP_WritePhyUshort(sc, 0x14, 0xa510);
18780         MP_WritePhyUshort(sc, 0x14, 0xd710);
18781         MP_WritePhyUshort(sc, 0x14, 0x4018);
18782         MP_WritePhyUshort(sc, 0x14, 0x9910);
18783         MP_WritePhyUshort(sc, 0x14, 0x8510);
18784         MP_WritePhyUshort(sc, 0x14, 0x2860);
18785         MP_WritePhyUshort(sc, 0x14, 0xe00f);
18786         MP_WritePhyUshort(sc, 0x14, 0x0504);
18787         MP_WritePhyUshort(sc, 0x14, 0xd710);
18788         MP_WritePhyUshort(sc, 0x14, 0x6099);
18789         MP_WritePhyUshort(sc, 0x14, 0xd71e);
18790         MP_WritePhyUshort(sc, 0x14, 0x7fa4);
18791         MP_WritePhyUshort(sc, 0x14, 0x2cd4);
18792         MP_WritePhyUshort(sc, 0x14, 0xa608);
18793         MP_WritePhyUshort(sc, 0x14, 0xc17d);
18794         MP_WritePhyUshort(sc, 0x14, 0xc200);
18795         MP_WritePhyUshort(sc, 0x14, 0xc43f);
18796         MP_WritePhyUshort(sc, 0x14, 0xcc03);
18797         MP_WritePhyUshort(sc, 0x14, 0xa701);
18798         MP_WritePhyUshort(sc, 0x14, 0xa510);
18799         MP_WritePhyUshort(sc, 0x14, 0xd710);
18800         MP_WritePhyUshort(sc, 0x14, 0x4018);
18801         MP_WritePhyUshort(sc, 0x14, 0x9910);
18802         MP_WritePhyUshort(sc, 0x14, 0x8510);
18803         MP_WritePhyUshort(sc, 0x14, 0x2926);
18804         MP_WritePhyUshort(sc, 0x14, 0x1792);
18805         MP_WritePhyUshort(sc, 0x14, 0x27db);
18806         MP_WritePhyUshort(sc, 0x14, 0xc000);
18807         MP_WritePhyUshort(sc, 0x14, 0xc100);
18808         MP_WritePhyUshort(sc, 0x14, 0xc200);
18809         MP_WritePhyUshort(sc, 0x14, 0xc300);
18810         MP_WritePhyUshort(sc, 0x14, 0xc400);
18811         MP_WritePhyUshort(sc, 0x14, 0xc500);
18812         MP_WritePhyUshort(sc, 0x14, 0xc600);
18813         MP_WritePhyUshort(sc, 0x14, 0xc7c1);
18814         MP_WritePhyUshort(sc, 0x14, 0xc800);
18815         MP_WritePhyUshort(sc, 0x14, 0xcc00);
18816         MP_WritePhyUshort(sc, 0x14, 0x0800);
18817         MP_WritePhyUshort(sc, 0x14, 0xca0f);
18818         MP_WritePhyUshort(sc, 0x14, 0xcbff);
18819         MP_WritePhyUshort(sc, 0x14, 0xa901);
18820         MP_WritePhyUshort(sc, 0x14, 0x8902);
18821         MP_WritePhyUshort(sc, 0x14, 0xc900);
18822         MP_WritePhyUshort(sc, 0x14, 0xca00);
18823         MP_WritePhyUshort(sc, 0x14, 0xcb00);
18824         MP_WritePhyUshort(sc, 0x14, 0x0800);
18825         MP_WritePhyUshort(sc, 0x14, 0xb804);
18826         MP_WritePhyUshort(sc, 0x14, 0x0800);
18827         MP_WritePhyUshort(sc, 0x14, 0xd71e);
18828         MP_WritePhyUshort(sc, 0x14, 0x6044);
18829         MP_WritePhyUshort(sc, 0x14, 0x9804);
18830         MP_WritePhyUshort(sc, 0x14, 0x0800);
18831         MP_WritePhyUshort(sc, 0x14, 0xd710);
18832         MP_WritePhyUshort(sc, 0x14, 0x6099);
18833         MP_WritePhyUshort(sc, 0x14, 0xd71e);
18834         MP_WritePhyUshort(sc, 0x14, 0x7fa4);
18835         MP_WritePhyUshort(sc, 0x14, 0x2cd4);
18836         MP_WritePhyUshort(sc, 0x14, 0x0800);
18837         MP_WritePhyUshort(sc, 0x14, 0xa510);
18838         MP_WritePhyUshort(sc, 0x14, 0xd710);
18839         MP_WritePhyUshort(sc, 0x14, 0x6098);
18840         MP_WritePhyUshort(sc, 0x14, 0xd71e);
18841         MP_WritePhyUshort(sc, 0x14, 0x7fa4);
18842         MP_WritePhyUshort(sc, 0x14, 0x2cd4);
18843         MP_WritePhyUshort(sc, 0x14, 0x8510);
18844         MP_WritePhyUshort(sc, 0x14, 0x0800);
18845         MP_WritePhyUshort(sc, 0x14, 0xd711);
18846         MP_WritePhyUshort(sc, 0x14, 0x3003);
18847         MP_WritePhyUshort(sc, 0x14, 0x1d01);
18848         MP_WritePhyUshort(sc, 0x14, 0x2d0b);
18849         MP_WritePhyUshort(sc, 0x14, 0xd710);
18850         MP_WritePhyUshort(sc, 0x14, 0x60be);
18851         MP_WritePhyUshort(sc, 0x14, 0xe060);
18852         MP_WritePhyUshort(sc, 0x14, 0x0920);
18853         MP_WritePhyUshort(sc, 0x14, 0x1cd6);
18854         MP_WritePhyUshort(sc, 0x14, 0x2c89);
18855         MP_WritePhyUshort(sc, 0x14, 0xd71e);
18856         MP_WritePhyUshort(sc, 0x14, 0x3063);
18857         MP_WritePhyUshort(sc, 0x14, 0x1948);
18858         MP_WritePhyUshort(sc, 0x14, 0x288a);
18859         MP_WritePhyUshort(sc, 0x14, 0x1cd6);
18860         MP_WritePhyUshort(sc, 0x14, 0x29bd);
18861         MP_WritePhyUshort(sc, 0x14, 0xa802);
18862         MP_WritePhyUshort(sc, 0x14, 0xa303);
18863         MP_WritePhyUshort(sc, 0x14, 0x843f);
18864         MP_WritePhyUshort(sc, 0x14, 0x81ff);
18865         MP_WritePhyUshort(sc, 0x14, 0x8208);
18866         MP_WritePhyUshort(sc, 0x14, 0xa201);
18867         MP_WritePhyUshort(sc, 0x14, 0xc001);
18868         MP_WritePhyUshort(sc, 0x14, 0xd710);
18869         MP_WritePhyUshort(sc, 0x14, 0x30a0);
18870         MP_WritePhyUshort(sc, 0x14, 0x0d1c);
18871         MP_WritePhyUshort(sc, 0x14, 0x30a0);
18872         MP_WritePhyUshort(sc, 0x14, 0x3d13);
18873         MP_WritePhyUshort(sc, 0x14, 0xd71e);
18874         MP_WritePhyUshort(sc, 0x14, 0x7f4c);
18875         MP_WritePhyUshort(sc, 0x14, 0x2ab6);
18876         MP_WritePhyUshort(sc, 0x14, 0xe003);
18877         MP_WritePhyUshort(sc, 0x14, 0x0202);
18878         MP_WritePhyUshort(sc, 0x14, 0xd710);
18879         MP_WritePhyUshort(sc, 0x14, 0x6090);
18880         MP_WritePhyUshort(sc, 0x14, 0xd71e);
18881         MP_WritePhyUshort(sc, 0x14, 0x7fac);
18882         MP_WritePhyUshort(sc, 0x14, 0x2ab6);
18883         MP_WritePhyUshort(sc, 0x14, 0xa20c);
18884         MP_WritePhyUshort(sc, 0x14, 0xd710);
18885         MP_WritePhyUshort(sc, 0x14, 0x6091);
18886         MP_WritePhyUshort(sc, 0x14, 0xd71e);
18887         MP_WritePhyUshort(sc, 0x14, 0x7fac);
18888         MP_WritePhyUshort(sc, 0x14, 0x2ab6);
18889         MP_WritePhyUshort(sc, 0x14, 0x820e);
18890         MP_WritePhyUshort(sc, 0x14, 0xa3e0);
18891         MP_WritePhyUshort(sc, 0x14, 0xa520);
18892         MP_WritePhyUshort(sc, 0x14, 0xd710);
18893         MP_WritePhyUshort(sc, 0x14, 0x609d);
18894         MP_WritePhyUshort(sc, 0x14, 0xd71e);
18895         MP_WritePhyUshort(sc, 0x14, 0x7fac);
18896         MP_WritePhyUshort(sc, 0x14, 0x2ab6);
18897         MP_WritePhyUshort(sc, 0x14, 0x8520);
18898         MP_WritePhyUshort(sc, 0x14, 0x6703);
18899         MP_WritePhyUshort(sc, 0x14, 0x2d34);
18900         MP_WritePhyUshort(sc, 0x14, 0xa13e);
18901         MP_WritePhyUshort(sc, 0x14, 0xc001);
18902         MP_WritePhyUshort(sc, 0x14, 0xd710);
18903         MP_WritePhyUshort(sc, 0x14, 0x4000);
18904         MP_WritePhyUshort(sc, 0x14, 0x6046);
18905         MP_WritePhyUshort(sc, 0x14, 0x2d0d);
18906         MP_WritePhyUshort(sc, 0x14, 0xa43f);
18907         MP_WritePhyUshort(sc, 0x14, 0xa101);
18908         MP_WritePhyUshort(sc, 0x14, 0xc020);
18909         MP_WritePhyUshort(sc, 0x14, 0xd710);
18910         MP_WritePhyUshort(sc, 0x14, 0x3121);
18911         MP_WritePhyUshort(sc, 0x14, 0x0d45);
18912         MP_WritePhyUshort(sc, 0x14, 0x30c0);
18913         MP_WritePhyUshort(sc, 0x14, 0x3d0d);
18914         MP_WritePhyUshort(sc, 0x14, 0xd71e);
18915         MP_WritePhyUshort(sc, 0x14, 0x7f4c);
18916         MP_WritePhyUshort(sc, 0x14, 0x2ab6);
18917         MP_WritePhyUshort(sc, 0x14, 0xa540);
18918         MP_WritePhyUshort(sc, 0x14, 0xc001);
18919         MP_WritePhyUshort(sc, 0x14, 0xd710);
18920         MP_WritePhyUshort(sc, 0x14, 0x4001);
18921         MP_WritePhyUshort(sc, 0x14, 0xe00f);
18922         MP_WritePhyUshort(sc, 0x14, 0x0501);
18923         MP_WritePhyUshort(sc, 0x14, 0x1dac);
18924         MP_WritePhyUshort(sc, 0x14, 0xc1c4);
18925         MP_WritePhyUshort(sc, 0x14, 0xa268);
18926         MP_WritePhyUshort(sc, 0x14, 0xa303);
18927         MP_WritePhyUshort(sc, 0x14, 0x8420);
18928         MP_WritePhyUshort(sc, 0x14, 0xe00f);
18929         MP_WritePhyUshort(sc, 0x14, 0x0502);
18930         MP_WritePhyUshort(sc, 0x14, 0x1dac);
18931         MP_WritePhyUshort(sc, 0x14, 0xc002);
18932         MP_WritePhyUshort(sc, 0x14, 0xd710);
18933         MP_WritePhyUshort(sc, 0x14, 0x4000);
18934         MP_WritePhyUshort(sc, 0x14, 0x8208);
18935         MP_WritePhyUshort(sc, 0x14, 0x8410);
18936         MP_WritePhyUshort(sc, 0x14, 0xa121);
18937         MP_WritePhyUshort(sc, 0x14, 0xc002);
18938         MP_WritePhyUshort(sc, 0x14, 0xd710);
18939         MP_WritePhyUshort(sc, 0x14, 0x4000);
18940         MP_WritePhyUshort(sc, 0x14, 0x8120);
18941         MP_WritePhyUshort(sc, 0x14, 0x8180);
18942         MP_WritePhyUshort(sc, 0x14, 0x1d97);
18943         MP_WritePhyUshort(sc, 0x14, 0xa180);
18944         MP_WritePhyUshort(sc, 0x14, 0xa13a);
18945         MP_WritePhyUshort(sc, 0x14, 0x8240);
18946         MP_WritePhyUshort(sc, 0x14, 0xa430);
18947         MP_WritePhyUshort(sc, 0x14, 0xc010);
18948         MP_WritePhyUshort(sc, 0x14, 0xd710);
18949         MP_WritePhyUshort(sc, 0x14, 0x30e1);
18950         MP_WritePhyUshort(sc, 0x14, 0x0abc);
18951         MP_WritePhyUshort(sc, 0x14, 0xd71e);
18952         MP_WritePhyUshort(sc, 0x14, 0x7f8c);
18953         MP_WritePhyUshort(sc, 0x14, 0x2ab6);
18954         MP_WritePhyUshort(sc, 0x14, 0xa480);
18955         MP_WritePhyUshort(sc, 0x14, 0xa230);
18956         MP_WritePhyUshort(sc, 0x14, 0xa303);
18957         MP_WritePhyUshort(sc, 0x14, 0xc001);
18958         MP_WritePhyUshort(sc, 0x14, 0xd70c);
18959         MP_WritePhyUshort(sc, 0x14, 0x4124);
18960         MP_WritePhyUshort(sc, 0x14, 0xd710);
18961         MP_WritePhyUshort(sc, 0x14, 0x6120);
18962         MP_WritePhyUshort(sc, 0x14, 0xd711);
18963         MP_WritePhyUshort(sc, 0x14, 0x3128);
18964         MP_WritePhyUshort(sc, 0x14, 0x3d76);
18965         MP_WritePhyUshort(sc, 0x14, 0x2d70);
18966         MP_WritePhyUshort(sc, 0x14, 0xa801);
18967         MP_WritePhyUshort(sc, 0x14, 0x2d6c);
18968         MP_WritePhyUshort(sc, 0x14, 0xd710);
18969         MP_WritePhyUshort(sc, 0x14, 0x4000);
18970         MP_WritePhyUshort(sc, 0x14, 0xe018);
18971         MP_WritePhyUshort(sc, 0x14, 0x0208);
18972         MP_WritePhyUshort(sc, 0x14, 0xa1f8);
18973         MP_WritePhyUshort(sc, 0x14, 0x8480);
18974         MP_WritePhyUshort(sc, 0x14, 0xc004);
18975         MP_WritePhyUshort(sc, 0x14, 0xd710);
18976         MP_WritePhyUshort(sc, 0x14, 0x4000);
18977         MP_WritePhyUshort(sc, 0x14, 0x6046);
18978         MP_WritePhyUshort(sc, 0x14, 0x2d0d);
18979         MP_WritePhyUshort(sc, 0x14, 0xa43f);
18980         MP_WritePhyUshort(sc, 0x14, 0xa105);
18981         MP_WritePhyUshort(sc, 0x14, 0x8228);
18982         MP_WritePhyUshort(sc, 0x14, 0xc004);
18983         MP_WritePhyUshort(sc, 0x14, 0xd710);
18984         MP_WritePhyUshort(sc, 0x14, 0x4000);
18985         MP_WritePhyUshort(sc, 0x14, 0x81bc);
18986         MP_WritePhyUshort(sc, 0x14, 0xa220);
18987         MP_WritePhyUshort(sc, 0x14, 0x1d97);
18988         MP_WritePhyUshort(sc, 0x14, 0x8220);
18989         MP_WritePhyUshort(sc, 0x14, 0xa1bc);
18990         MP_WritePhyUshort(sc, 0x14, 0xc040);
18991         MP_WritePhyUshort(sc, 0x14, 0xd710);
18992         MP_WritePhyUshort(sc, 0x14, 0x30e1);
18993         MP_WritePhyUshort(sc, 0x14, 0x0abc);
18994         MP_WritePhyUshort(sc, 0x14, 0x30e1);
18995         MP_WritePhyUshort(sc, 0x14, 0x3d0d);
18996         MP_WritePhyUshort(sc, 0x14, 0xd71e);
18997         MP_WritePhyUshort(sc, 0x14, 0x7f4c);
18998         MP_WritePhyUshort(sc, 0x14, 0x2ab6);
18999         MP_WritePhyUshort(sc, 0x14, 0xa802);
19000         MP_WritePhyUshort(sc, 0x14, 0xd70c);
19001         MP_WritePhyUshort(sc, 0x14, 0x4244);
19002         MP_WritePhyUshort(sc, 0x14, 0xa301);
19003         MP_WritePhyUshort(sc, 0x14, 0xc004);
19004         MP_WritePhyUshort(sc, 0x14, 0xd711);
19005         MP_WritePhyUshort(sc, 0x14, 0x3128);
19006         MP_WritePhyUshort(sc, 0x14, 0x3da5);
19007         MP_WritePhyUshort(sc, 0x14, 0xd710);
19008         MP_WritePhyUshort(sc, 0x14, 0x5f80);
19009         MP_WritePhyUshort(sc, 0x14, 0xd711);
19010         MP_WritePhyUshort(sc, 0x14, 0x3109);
19011         MP_WritePhyUshort(sc, 0x14, 0x3da7);
19012         MP_WritePhyUshort(sc, 0x14, 0x2dab);
19013         MP_WritePhyUshort(sc, 0x14, 0xa801);
19014         MP_WritePhyUshort(sc, 0x14, 0x2d9a);
19015         MP_WritePhyUshort(sc, 0x14, 0xa802);
19016         MP_WritePhyUshort(sc, 0x14, 0xc004);
19017         MP_WritePhyUshort(sc, 0x14, 0xd710);
19018         MP_WritePhyUshort(sc, 0x14, 0x4000);
19019         MP_WritePhyUshort(sc, 0x14, 0x0800);
19020         MP_WritePhyUshort(sc, 0x14, 0xa510);
19021         MP_WritePhyUshort(sc, 0x14, 0xd710);
19022         MP_WritePhyUshort(sc, 0x14, 0x609a);
19023         MP_WritePhyUshort(sc, 0x14, 0xd71e);
19024         MP_WritePhyUshort(sc, 0x14, 0x7fac);
19025         MP_WritePhyUshort(sc, 0x14, 0x2ab6);
19026         MP_WritePhyUshort(sc, 0x14, 0x8510);
19027         MP_WritePhyUshort(sc, 0x14, 0x0800);
19028         MP_WritePhyUshort(sc, 0x13, 0xA01A);
19029         MP_WritePhyUshort(sc, 0x14, 0x0000);
19030         MP_WritePhyUshort(sc, 0x13, 0xA006);
19031         MP_WritePhyUshort(sc, 0x14, 0x0ad6);
19032         MP_WritePhyUshort(sc, 0x13, 0xA004);
19033         MP_WritePhyUshort(sc, 0x14, 0x07f5);
19034         MP_WritePhyUshort(sc, 0x13, 0xA002);
19035         MP_WritePhyUshort(sc, 0x14, 0x06a9);
19036         MP_WritePhyUshort(sc, 0x13, 0xA000);
19037         MP_WritePhyUshort(sc, 0x14, 0xf069);
19038         MP_WritePhyUshort(sc, 0x13, 0xB820);
19039         MP_WritePhyUshort(sc, 0x14, 0x0210);
19040
19041         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19042         MP_WritePhyUshort(sc, 0x13, 0x83a0);
19043         MP_WritePhyUshort(sc, 0x14, 0xaf83);
19044         MP_WritePhyUshort(sc, 0x14, 0xacaf);
19045         MP_WritePhyUshort(sc, 0x14, 0x83b8);
19046         MP_WritePhyUshort(sc, 0x14, 0xaf83);
19047         MP_WritePhyUshort(sc, 0x14, 0xcdaf);
19048         MP_WritePhyUshort(sc, 0x14, 0x83d3);
19049         MP_WritePhyUshort(sc, 0x14, 0x0204);
19050         MP_WritePhyUshort(sc, 0x14, 0x9a02);
19051         MP_WritePhyUshort(sc, 0x14, 0x09a9);
19052         MP_WritePhyUshort(sc, 0x14, 0x0284);
19053         MP_WritePhyUshort(sc, 0x14, 0x61af);
19054         MP_WritePhyUshort(sc, 0x14, 0x02fc);
19055         MP_WritePhyUshort(sc, 0x14, 0xad20);
19056         MP_WritePhyUshort(sc, 0x14, 0x0302);
19057         MP_WritePhyUshort(sc, 0x14, 0x867c);
19058         MP_WritePhyUshort(sc, 0x14, 0xad21);
19059         MP_WritePhyUshort(sc, 0x14, 0x0302);
19060         MP_WritePhyUshort(sc, 0x14, 0x85c9);
19061         MP_WritePhyUshort(sc, 0x14, 0xad22);
19062         MP_WritePhyUshort(sc, 0x14, 0x0302);
19063         MP_WritePhyUshort(sc, 0x14, 0x1bc0);
19064         MP_WritePhyUshort(sc, 0x14, 0xaf17);
19065         MP_WritePhyUshort(sc, 0x14, 0xe302);
19066         MP_WritePhyUshort(sc, 0x14, 0x8703);
19067         MP_WritePhyUshort(sc, 0x14, 0xaf18);
19068         MP_WritePhyUshort(sc, 0x14, 0x6201);
19069         MP_WritePhyUshort(sc, 0x14, 0x06e0);
19070         MP_WritePhyUshort(sc, 0x14, 0x8148);
19071         MP_WritePhyUshort(sc, 0x14, 0xaf3c);
19072         MP_WritePhyUshort(sc, 0x14, 0x69f8);
19073         MP_WritePhyUshort(sc, 0x14, 0xf9fa);
19074         MP_WritePhyUshort(sc, 0x14, 0xef69);
19075         MP_WritePhyUshort(sc, 0x14, 0xee80);
19076         MP_WritePhyUshort(sc, 0x14, 0x10f7);
19077         MP_WritePhyUshort(sc, 0x14, 0xee80);
19078         MP_WritePhyUshort(sc, 0x14, 0x131f);
19079         MP_WritePhyUshort(sc, 0x14, 0xd104);
19080         MP_WritePhyUshort(sc, 0x14, 0xbf87);
19081         MP_WritePhyUshort(sc, 0x14, 0xf302);
19082         MP_WritePhyUshort(sc, 0x14, 0x4259);
19083         MP_WritePhyUshort(sc, 0x14, 0x0287);
19084         MP_WritePhyUshort(sc, 0x14, 0x88bf);
19085         MP_WritePhyUshort(sc, 0x14, 0x87cf);
19086         MP_WritePhyUshort(sc, 0x14, 0xd7b8);
19087         MP_WritePhyUshort(sc, 0x14, 0x22d0);
19088         MP_WritePhyUshort(sc, 0x14, 0x0c02);
19089         MP_WritePhyUshort(sc, 0x14, 0x4252);
19090         MP_WritePhyUshort(sc, 0x14, 0xee80);
19091         MP_WritePhyUshort(sc, 0x14, 0xcda0);
19092         MP_WritePhyUshort(sc, 0x14, 0xee80);
19093         MP_WritePhyUshort(sc, 0x14, 0xce8b);
19094         MP_WritePhyUshort(sc, 0x14, 0xee80);
19095         MP_WritePhyUshort(sc, 0x14, 0xd1f5);
19096         MP_WritePhyUshort(sc, 0x14, 0xee80);
19097         MP_WritePhyUshort(sc, 0x14, 0xd2a9);
19098         MP_WritePhyUshort(sc, 0x14, 0xee80);
19099         MP_WritePhyUshort(sc, 0x14, 0xd30a);
19100         MP_WritePhyUshort(sc, 0x14, 0xee80);
19101         MP_WritePhyUshort(sc, 0x14, 0xf010);
19102         MP_WritePhyUshort(sc, 0x14, 0xee80);
19103         MP_WritePhyUshort(sc, 0x14, 0xf38f);
19104         MP_WritePhyUshort(sc, 0x14, 0xee81);
19105         MP_WritePhyUshort(sc, 0x14, 0x011e);
19106         MP_WritePhyUshort(sc, 0x14, 0xee81);
19107         MP_WritePhyUshort(sc, 0x14, 0x0b4a);
19108         MP_WritePhyUshort(sc, 0x14, 0xee81);
19109         MP_WritePhyUshort(sc, 0x14, 0x0c7c);
19110         MP_WritePhyUshort(sc, 0x14, 0xee81);
19111         MP_WritePhyUshort(sc, 0x14, 0x127f);
19112         MP_WritePhyUshort(sc, 0x14, 0xd100);
19113         MP_WritePhyUshort(sc, 0x14, 0x0210);
19114         MP_WritePhyUshort(sc, 0x14, 0xb5ee);
19115         MP_WritePhyUshort(sc, 0x14, 0x8088);
19116         MP_WritePhyUshort(sc, 0x14, 0xa4ee);
19117         MP_WritePhyUshort(sc, 0x14, 0x8089);
19118         MP_WritePhyUshort(sc, 0x14, 0x44ee);
19119         MP_WritePhyUshort(sc, 0x14, 0x809a);
19120         MP_WritePhyUshort(sc, 0x14, 0xa4ee);
19121         MP_WritePhyUshort(sc, 0x14, 0x809b);
19122         MP_WritePhyUshort(sc, 0x14, 0x44ee);
19123         MP_WritePhyUshort(sc, 0x14, 0x809c);
19124         MP_WritePhyUshort(sc, 0x14, 0xa7ee);
19125         MP_WritePhyUshort(sc, 0x14, 0x80a5);
19126         MP_WritePhyUshort(sc, 0x14, 0xa7d2);
19127         MP_WritePhyUshort(sc, 0x14, 0x0002);
19128         MP_WritePhyUshort(sc, 0x14, 0x0e66);
19129         MP_WritePhyUshort(sc, 0x14, 0x0285);
19130         MP_WritePhyUshort(sc, 0x14, 0xc0ee);
19131         MP_WritePhyUshort(sc, 0x14, 0x87fc);
19132         MP_WritePhyUshort(sc, 0x14, 0x00e0);
19133         MP_WritePhyUshort(sc, 0x14, 0x8245);
19134         MP_WritePhyUshort(sc, 0x14, 0xf622);
19135         MP_WritePhyUshort(sc, 0x14, 0xe482);
19136         MP_WritePhyUshort(sc, 0x14, 0x45ef);
19137         MP_WritePhyUshort(sc, 0x14, 0x96fe);
19138         MP_WritePhyUshort(sc, 0x14, 0xfdfc);
19139         MP_WritePhyUshort(sc, 0x14, 0x0402);
19140         MP_WritePhyUshort(sc, 0x14, 0x847a);
19141         MP_WritePhyUshort(sc, 0x14, 0x0284);
19142         MP_WritePhyUshort(sc, 0x14, 0xb302);
19143         MP_WritePhyUshort(sc, 0x14, 0x0cab);
19144         MP_WritePhyUshort(sc, 0x14, 0x020c);
19145         MP_WritePhyUshort(sc, 0x14, 0xc402);
19146         MP_WritePhyUshort(sc, 0x14, 0x0cef);
19147         MP_WritePhyUshort(sc, 0x14, 0x020d);
19148         MP_WritePhyUshort(sc, 0x14, 0x0802);
19149         MP_WritePhyUshort(sc, 0x14, 0x0d33);
19150         MP_WritePhyUshort(sc, 0x14, 0x020c);
19151         MP_WritePhyUshort(sc, 0x14, 0x3d04);
19152         MP_WritePhyUshort(sc, 0x14, 0xf8fa);
19153         MP_WritePhyUshort(sc, 0x14, 0xef69);
19154         MP_WritePhyUshort(sc, 0x14, 0xe182);
19155         MP_WritePhyUshort(sc, 0x14, 0x2fac);
19156         MP_WritePhyUshort(sc, 0x14, 0x291a);
19157         MP_WritePhyUshort(sc, 0x14, 0xe082);
19158         MP_WritePhyUshort(sc, 0x14, 0x24ac);
19159         MP_WritePhyUshort(sc, 0x14, 0x2102);
19160         MP_WritePhyUshort(sc, 0x14, 0xae22);
19161         MP_WritePhyUshort(sc, 0x14, 0x0210);
19162         MP_WritePhyUshort(sc, 0x14, 0x57f6);
19163         MP_WritePhyUshort(sc, 0x14, 0x21e4);
19164         MP_WritePhyUshort(sc, 0x14, 0x8224);
19165         MP_WritePhyUshort(sc, 0x14, 0xd101);
19166         MP_WritePhyUshort(sc, 0x14, 0xbf44);
19167         MP_WritePhyUshort(sc, 0x14, 0xd202);
19168         MP_WritePhyUshort(sc, 0x14, 0x4259);
19169         MP_WritePhyUshort(sc, 0x14, 0xae10);
19170         MP_WritePhyUshort(sc, 0x14, 0x0212);
19171         MP_WritePhyUshort(sc, 0x14, 0x4cf6);
19172         MP_WritePhyUshort(sc, 0x14, 0x29e5);
19173         MP_WritePhyUshort(sc, 0x14, 0x822f);
19174         MP_WritePhyUshort(sc, 0x14, 0xe082);
19175         MP_WritePhyUshort(sc, 0x14, 0x24f6);
19176         MP_WritePhyUshort(sc, 0x14, 0x21e4);
19177         MP_WritePhyUshort(sc, 0x14, 0x8224);
19178         MP_WritePhyUshort(sc, 0x14, 0xef96);
19179         MP_WritePhyUshort(sc, 0x14, 0xfefc);
19180         MP_WritePhyUshort(sc, 0x14, 0x04f8);
19181         MP_WritePhyUshort(sc, 0x14, 0xe182);
19182         MP_WritePhyUshort(sc, 0x14, 0x2fac);
19183         MP_WritePhyUshort(sc, 0x14, 0x2a18);
19184         MP_WritePhyUshort(sc, 0x14, 0xe082);
19185         MP_WritePhyUshort(sc, 0x14, 0x24ac);
19186         MP_WritePhyUshort(sc, 0x14, 0x2202);
19187         MP_WritePhyUshort(sc, 0x14, 0xae26);
19188         MP_WritePhyUshort(sc, 0x14, 0x0284);
19189         MP_WritePhyUshort(sc, 0x14, 0xf802);
19190         MP_WritePhyUshort(sc, 0x14, 0x8565);
19191         MP_WritePhyUshort(sc, 0x14, 0xd101);
19192         MP_WritePhyUshort(sc, 0x14, 0xbf44);
19193         MP_WritePhyUshort(sc, 0x14, 0xd502);
19194         MP_WritePhyUshort(sc, 0x14, 0x4259);
19195         MP_WritePhyUshort(sc, 0x14, 0xae0e);
19196         MP_WritePhyUshort(sc, 0x14, 0x0284);
19197         MP_WritePhyUshort(sc, 0x14, 0xea02);
19198         MP_WritePhyUshort(sc, 0x14, 0x85a9);
19199         MP_WritePhyUshort(sc, 0x14, 0xe182);
19200         MP_WritePhyUshort(sc, 0x14, 0x2ff6);
19201         MP_WritePhyUshort(sc, 0x14, 0x2ae5);
19202         MP_WritePhyUshort(sc, 0x14, 0x822f);
19203         MP_WritePhyUshort(sc, 0x14, 0xe082);
19204         MP_WritePhyUshort(sc, 0x14, 0x24f6);
19205         MP_WritePhyUshort(sc, 0x14, 0x22e4);
19206         MP_WritePhyUshort(sc, 0x14, 0x8224);
19207         MP_WritePhyUshort(sc, 0x14, 0xfc04);
19208         MP_WritePhyUshort(sc, 0x14, 0xf9e2);
19209         MP_WritePhyUshort(sc, 0x14, 0x8011);
19210         MP_WritePhyUshort(sc, 0x14, 0xad31);
19211         MP_WritePhyUshort(sc, 0x14, 0x05d2);
19212         MP_WritePhyUshort(sc, 0x14, 0x0002);
19213         MP_WritePhyUshort(sc, 0x14, 0x0e66);
19214         MP_WritePhyUshort(sc, 0x14, 0xfd04);
19215         MP_WritePhyUshort(sc, 0x14, 0xf8f9);
19216         MP_WritePhyUshort(sc, 0x14, 0xfaef);
19217         MP_WritePhyUshort(sc, 0x14, 0x69e0);
19218         MP_WritePhyUshort(sc, 0x14, 0x8011);
19219         MP_WritePhyUshort(sc, 0x14, 0xad21);
19220         MP_WritePhyUshort(sc, 0x14, 0x5cbf);
19221         MP_WritePhyUshort(sc, 0x14, 0x43be);
19222         MP_WritePhyUshort(sc, 0x14, 0x0242);
19223         MP_WritePhyUshort(sc, 0x14, 0x97ac);
19224         MP_WritePhyUshort(sc, 0x14, 0x281b);
19225         MP_WritePhyUshort(sc, 0x14, 0xbf43);
19226         MP_WritePhyUshort(sc, 0x14, 0xc102);
19227         MP_WritePhyUshort(sc, 0x14, 0x4297);
19228         MP_WritePhyUshort(sc, 0x14, 0xac28);
19229         MP_WritePhyUshort(sc, 0x14, 0x12bf);
19230         MP_WritePhyUshort(sc, 0x14, 0x43c7);
19231         MP_WritePhyUshort(sc, 0x14, 0x0242);
19232         MP_WritePhyUshort(sc, 0x14, 0x97ac);
19233         MP_WritePhyUshort(sc, 0x14, 0x2804);
19234         MP_WritePhyUshort(sc, 0x14, 0xd300);
19235         MP_WritePhyUshort(sc, 0x14, 0xae07);
19236         MP_WritePhyUshort(sc, 0x14, 0xd306);
19237         MP_WritePhyUshort(sc, 0x14, 0xaf85);
19238         MP_WritePhyUshort(sc, 0x14, 0x56d3);
19239         MP_WritePhyUshort(sc, 0x14, 0x03e0);
19240         MP_WritePhyUshort(sc, 0x14, 0x8011);
19241         MP_WritePhyUshort(sc, 0x14, 0xad26);
19242         MP_WritePhyUshort(sc, 0x14, 0x25bf);
19243         MP_WritePhyUshort(sc, 0x14, 0x4559);
19244         MP_WritePhyUshort(sc, 0x14, 0x0242);
19245         MP_WritePhyUshort(sc, 0x14, 0x97e2);
19246         MP_WritePhyUshort(sc, 0x14, 0x8073);
19247         MP_WritePhyUshort(sc, 0x14, 0x0d21);
19248         MP_WritePhyUshort(sc, 0x14, 0xf637);
19249         MP_WritePhyUshort(sc, 0x14, 0x0d11);
19250         MP_WritePhyUshort(sc, 0x14, 0xf62f);
19251         MP_WritePhyUshort(sc, 0x14, 0x1b21);
19252         MP_WritePhyUshort(sc, 0x14, 0xaa02);
19253         MP_WritePhyUshort(sc, 0x14, 0xae10);
19254         MP_WritePhyUshort(sc, 0x14, 0xe280);
19255         MP_WritePhyUshort(sc, 0x14, 0x740d);
19256         MP_WritePhyUshort(sc, 0x14, 0x21f6);
19257         MP_WritePhyUshort(sc, 0x14, 0x371b);
19258         MP_WritePhyUshort(sc, 0x14, 0x21aa);
19259         MP_WritePhyUshort(sc, 0x14, 0x0313);
19260         MP_WritePhyUshort(sc, 0x14, 0xae02);
19261         MP_WritePhyUshort(sc, 0x14, 0x2b02);
19262         MP_WritePhyUshort(sc, 0x14, 0x020e);
19263         MP_WritePhyUshort(sc, 0x14, 0x5102);
19264         MP_WritePhyUshort(sc, 0x14, 0x0e66);
19265         MP_WritePhyUshort(sc, 0x14, 0x020f);
19266         MP_WritePhyUshort(sc, 0x14, 0xa3ef);
19267         MP_WritePhyUshort(sc, 0x14, 0x96fe);
19268         MP_WritePhyUshort(sc, 0x14, 0xfdfc);
19269         MP_WritePhyUshort(sc, 0x14, 0x04f8);
19270         MP_WritePhyUshort(sc, 0x14, 0xf9fa);
19271         MP_WritePhyUshort(sc, 0x14, 0xef69);
19272         MP_WritePhyUshort(sc, 0x14, 0xe080);
19273         MP_WritePhyUshort(sc, 0x14, 0x12ad);
19274         MP_WritePhyUshort(sc, 0x14, 0x2733);
19275         MP_WritePhyUshort(sc, 0x14, 0xbf43);
19276         MP_WritePhyUshort(sc, 0x14, 0xbe02);
19277         MP_WritePhyUshort(sc, 0x14, 0x4297);
19278         MP_WritePhyUshort(sc, 0x14, 0xac28);
19279         MP_WritePhyUshort(sc, 0x14, 0x09bf);
19280         MP_WritePhyUshort(sc, 0x14, 0x43c1);
19281         MP_WritePhyUshort(sc, 0x14, 0x0242);
19282         MP_WritePhyUshort(sc, 0x14, 0x97ad);
19283         MP_WritePhyUshort(sc, 0x14, 0x2821);
19284         MP_WritePhyUshort(sc, 0x14, 0xbf45);
19285         MP_WritePhyUshort(sc, 0x14, 0x5902);
19286         MP_WritePhyUshort(sc, 0x14, 0x4297);
19287         MP_WritePhyUshort(sc, 0x14, 0xe387);
19288         MP_WritePhyUshort(sc, 0x14, 0xffd2);
19289         MP_WritePhyUshort(sc, 0x14, 0x001b);
19290         MP_WritePhyUshort(sc, 0x14, 0x45ac);
19291         MP_WritePhyUshort(sc, 0x14, 0x2711);
19292         MP_WritePhyUshort(sc, 0x14, 0xe187);
19293         MP_WritePhyUshort(sc, 0x14, 0xfebf);
19294         MP_WritePhyUshort(sc, 0x14, 0x87e4);
19295         MP_WritePhyUshort(sc, 0x14, 0x0242);
19296         MP_WritePhyUshort(sc, 0x14, 0x590d);
19297         MP_WritePhyUshort(sc, 0x14, 0x11bf);
19298         MP_WritePhyUshort(sc, 0x14, 0x87e7);
19299         MP_WritePhyUshort(sc, 0x14, 0x0242);
19300         MP_WritePhyUshort(sc, 0x14, 0x59ef);
19301         MP_WritePhyUshort(sc, 0x14, 0x96fe);
19302         MP_WritePhyUshort(sc, 0x14, 0xfdfc);
19303         MP_WritePhyUshort(sc, 0x14, 0x04f8);
19304         MP_WritePhyUshort(sc, 0x14, 0xfaef);
19305         MP_WritePhyUshort(sc, 0x14, 0x69d1);
19306         MP_WritePhyUshort(sc, 0x14, 0x00bf);
19307         MP_WritePhyUshort(sc, 0x14, 0x87e4);
19308         MP_WritePhyUshort(sc, 0x14, 0x0242);
19309         MP_WritePhyUshort(sc, 0x14, 0x59bf);
19310         MP_WritePhyUshort(sc, 0x14, 0x87e7);
19311         MP_WritePhyUshort(sc, 0x14, 0x0242);
19312         MP_WritePhyUshort(sc, 0x14, 0x59ef);
19313         MP_WritePhyUshort(sc, 0x14, 0x96fe);
19314         MP_WritePhyUshort(sc, 0x14, 0xfc04);
19315         MP_WritePhyUshort(sc, 0x14, 0xee87);
19316         MP_WritePhyUshort(sc, 0x14, 0xff46);
19317         MP_WritePhyUshort(sc, 0x14, 0xee87);
19318         MP_WritePhyUshort(sc, 0x14, 0xfe01);
19319         MP_WritePhyUshort(sc, 0x14, 0x04f8);
19320         MP_WritePhyUshort(sc, 0x14, 0xfaef);
19321         MP_WritePhyUshort(sc, 0x14, 0x69e0);
19322         MP_WritePhyUshort(sc, 0x14, 0x8241);
19323         MP_WritePhyUshort(sc, 0x14, 0xa000);
19324         MP_WritePhyUshort(sc, 0x14, 0x0502);
19325         MP_WritePhyUshort(sc, 0x14, 0x85eb);
19326         MP_WritePhyUshort(sc, 0x14, 0xae0e);
19327         MP_WritePhyUshort(sc, 0x14, 0xa001);
19328         MP_WritePhyUshort(sc, 0x14, 0x0502);
19329         MP_WritePhyUshort(sc, 0x14, 0x1a5a);
19330         MP_WritePhyUshort(sc, 0x14, 0xae06);
19331         MP_WritePhyUshort(sc, 0x14, 0xa002);
19332         MP_WritePhyUshort(sc, 0x14, 0x0302);
19333         MP_WritePhyUshort(sc, 0x14, 0x1ae6);
19334         MP_WritePhyUshort(sc, 0x14, 0xef96);
19335         MP_WritePhyUshort(sc, 0x14, 0xfefc);
19336         MP_WritePhyUshort(sc, 0x14, 0x04f8);
19337         MP_WritePhyUshort(sc, 0x14, 0xf9fa);
19338         MP_WritePhyUshort(sc, 0x14, 0xef69);
19339         MP_WritePhyUshort(sc, 0x14, 0xe082);
19340         MP_WritePhyUshort(sc, 0x14, 0x29f6);
19341         MP_WritePhyUshort(sc, 0x14, 0x21e4);
19342         MP_WritePhyUshort(sc, 0x14, 0x8229);
19343         MP_WritePhyUshort(sc, 0x14, 0xe080);
19344         MP_WritePhyUshort(sc, 0x14, 0x10ac);
19345         MP_WritePhyUshort(sc, 0x14, 0x2202);
19346         MP_WritePhyUshort(sc, 0x14, 0xae76);
19347         MP_WritePhyUshort(sc, 0x14, 0xe082);
19348         MP_WritePhyUshort(sc, 0x14, 0x27f7);
19349         MP_WritePhyUshort(sc, 0x14, 0x21e4);
19350         MP_WritePhyUshort(sc, 0x14, 0x8227);
19351         MP_WritePhyUshort(sc, 0x14, 0xbf43);
19352         MP_WritePhyUshort(sc, 0x14, 0x1302);
19353         MP_WritePhyUshort(sc, 0x14, 0x4297);
19354         MP_WritePhyUshort(sc, 0x14, 0xef21);
19355         MP_WritePhyUshort(sc, 0x14, 0xbf43);
19356         MP_WritePhyUshort(sc, 0x14, 0x1602);
19357         MP_WritePhyUshort(sc, 0x14, 0x4297);
19358         MP_WritePhyUshort(sc, 0x14, 0x0c11);
19359         MP_WritePhyUshort(sc, 0x14, 0x1e21);
19360         MP_WritePhyUshort(sc, 0x14, 0xbf43);
19361         MP_WritePhyUshort(sc, 0x14, 0x1902);
19362         MP_WritePhyUshort(sc, 0x14, 0x4297);
19363         MP_WritePhyUshort(sc, 0x14, 0x0c12);
19364         MP_WritePhyUshort(sc, 0x14, 0x1e21);
19365         MP_WritePhyUshort(sc, 0x14, 0xe682);
19366         MP_WritePhyUshort(sc, 0x14, 0x43a2);
19367         MP_WritePhyUshort(sc, 0x14, 0x000a);
19368         MP_WritePhyUshort(sc, 0x14, 0xe182);
19369         MP_WritePhyUshort(sc, 0x14, 0x27f6);
19370         MP_WritePhyUshort(sc, 0x14, 0x29e5);
19371         MP_WritePhyUshort(sc, 0x14, 0x8227);
19372         MP_WritePhyUshort(sc, 0x14, 0xae42);
19373         MP_WritePhyUshort(sc, 0x14, 0xe082);
19374         MP_WritePhyUshort(sc, 0x14, 0x44f7);
19375         MP_WritePhyUshort(sc, 0x14, 0x21e4);
19376         MP_WritePhyUshort(sc, 0x14, 0x8244);
19377         MP_WritePhyUshort(sc, 0x14, 0x0246);
19378         MP_WritePhyUshort(sc, 0x14, 0xaebf);
19379         MP_WritePhyUshort(sc, 0x14, 0x4325);
19380         MP_WritePhyUshort(sc, 0x14, 0x0242);
19381         MP_WritePhyUshort(sc, 0x14, 0x97ef);
19382         MP_WritePhyUshort(sc, 0x14, 0x21bf);
19383         MP_WritePhyUshort(sc, 0x14, 0x431c);
19384         MP_WritePhyUshort(sc, 0x14, 0x0242);
19385         MP_WritePhyUshort(sc, 0x14, 0x970c);
19386         MP_WritePhyUshort(sc, 0x14, 0x121e);
19387         MP_WritePhyUshort(sc, 0x14, 0x21bf);
19388         MP_WritePhyUshort(sc, 0x14, 0x431f);
19389         MP_WritePhyUshort(sc, 0x14, 0x0242);
19390         MP_WritePhyUshort(sc, 0x14, 0x970c);
19391         MP_WritePhyUshort(sc, 0x14, 0x131e);
19392         MP_WritePhyUshort(sc, 0x14, 0x21bf);
19393         MP_WritePhyUshort(sc, 0x14, 0x4328);
19394         MP_WritePhyUshort(sc, 0x14, 0x0242);
19395         MP_WritePhyUshort(sc, 0x14, 0x970c);
19396         MP_WritePhyUshort(sc, 0x14, 0x141e);
19397         MP_WritePhyUshort(sc, 0x14, 0x21bf);
19398         MP_WritePhyUshort(sc, 0x14, 0x44b1);
19399         MP_WritePhyUshort(sc, 0x14, 0x0242);
19400         MP_WritePhyUshort(sc, 0x14, 0x970c);
19401         MP_WritePhyUshort(sc, 0x14, 0x161e);
19402         MP_WritePhyUshort(sc, 0x14, 0x21e6);
19403         MP_WritePhyUshort(sc, 0x14, 0x8242);
19404         MP_WritePhyUshort(sc, 0x14, 0xee82);
19405         MP_WritePhyUshort(sc, 0x14, 0x4101);
19406         MP_WritePhyUshort(sc, 0x14, 0xef96);
19407         MP_WritePhyUshort(sc, 0x14, 0xfefd);
19408         MP_WritePhyUshort(sc, 0x14, 0xfc04);
19409         MP_WritePhyUshort(sc, 0x14, 0xf8fa);
19410         MP_WritePhyUshort(sc, 0x14, 0xef69);
19411         MP_WritePhyUshort(sc, 0x14, 0xe082);
19412         MP_WritePhyUshort(sc, 0x14, 0x46a0);
19413         MP_WritePhyUshort(sc, 0x14, 0x0005);
19414         MP_WritePhyUshort(sc, 0x14, 0x0286);
19415         MP_WritePhyUshort(sc, 0x14, 0x96ae);
19416         MP_WritePhyUshort(sc, 0x14, 0x06a0);
19417         MP_WritePhyUshort(sc, 0x14, 0x0103);
19418         MP_WritePhyUshort(sc, 0x14, 0x0219);
19419         MP_WritePhyUshort(sc, 0x14, 0x19ef);
19420         MP_WritePhyUshort(sc, 0x14, 0x96fe);
19421         MP_WritePhyUshort(sc, 0x14, 0xfc04);
19422         MP_WritePhyUshort(sc, 0x14, 0xf8fa);
19423         MP_WritePhyUshort(sc, 0x14, 0xef69);
19424         MP_WritePhyUshort(sc, 0x14, 0xe082);
19425         MP_WritePhyUshort(sc, 0x14, 0x29f6);
19426         MP_WritePhyUshort(sc, 0x14, 0x20e4);
19427         MP_WritePhyUshort(sc, 0x14, 0x8229);
19428         MP_WritePhyUshort(sc, 0x14, 0xe080);
19429         MP_WritePhyUshort(sc, 0x14, 0x10ac);
19430         MP_WritePhyUshort(sc, 0x14, 0x2102);
19431         MP_WritePhyUshort(sc, 0x14, 0xae54);
19432         MP_WritePhyUshort(sc, 0x14, 0xe082);
19433         MP_WritePhyUshort(sc, 0x14, 0x27f7);
19434         MP_WritePhyUshort(sc, 0x14, 0x20e4);
19435         MP_WritePhyUshort(sc, 0x14, 0x8227);
19436         MP_WritePhyUshort(sc, 0x14, 0xbf42);
19437         MP_WritePhyUshort(sc, 0x14, 0xe602);
19438         MP_WritePhyUshort(sc, 0x14, 0x4297);
19439         MP_WritePhyUshort(sc, 0x14, 0xac28);
19440         MP_WritePhyUshort(sc, 0x14, 0x22bf);
19441         MP_WritePhyUshort(sc, 0x14, 0x430d);
19442         MP_WritePhyUshort(sc, 0x14, 0x0242);
19443         MP_WritePhyUshort(sc, 0x14, 0x97e5);
19444         MP_WritePhyUshort(sc, 0x14, 0x8247);
19445         MP_WritePhyUshort(sc, 0x14, 0xac28);
19446         MP_WritePhyUshort(sc, 0x14, 0x20d1);
19447         MP_WritePhyUshort(sc, 0x14, 0x03bf);
19448         MP_WritePhyUshort(sc, 0x14, 0x4307);
19449         MP_WritePhyUshort(sc, 0x14, 0x0242);
19450         MP_WritePhyUshort(sc, 0x14, 0x59ee);
19451         MP_WritePhyUshort(sc, 0x14, 0x8246);
19452         MP_WritePhyUshort(sc, 0x14, 0x00e1);
19453         MP_WritePhyUshort(sc, 0x14, 0x8227);
19454         MP_WritePhyUshort(sc, 0x14, 0xf628);
19455         MP_WritePhyUshort(sc, 0x14, 0xe582);
19456         MP_WritePhyUshort(sc, 0x14, 0x27ae);
19457         MP_WritePhyUshort(sc, 0x14, 0x21d1);
19458         MP_WritePhyUshort(sc, 0x14, 0x04bf);
19459         MP_WritePhyUshort(sc, 0x14, 0x4307);
19460         MP_WritePhyUshort(sc, 0x14, 0x0242);
19461         MP_WritePhyUshort(sc, 0x14, 0x59ae);
19462         MP_WritePhyUshort(sc, 0x14, 0x08d1);
19463         MP_WritePhyUshort(sc, 0x14, 0x05bf);
19464         MP_WritePhyUshort(sc, 0x14, 0x4307);
19465         MP_WritePhyUshort(sc, 0x14, 0x0242);
19466         MP_WritePhyUshort(sc, 0x14, 0x59e0);
19467         MP_WritePhyUshort(sc, 0x14, 0x8244);
19468         MP_WritePhyUshort(sc, 0x14, 0xf720);
19469         MP_WritePhyUshort(sc, 0x14, 0xe482);
19470         MP_WritePhyUshort(sc, 0x14, 0x4402);
19471         MP_WritePhyUshort(sc, 0x14, 0x46ae);
19472         MP_WritePhyUshort(sc, 0x14, 0xee82);
19473         MP_WritePhyUshort(sc, 0x14, 0x4601);
19474         MP_WritePhyUshort(sc, 0x14, 0xef96);
19475         MP_WritePhyUshort(sc, 0x14, 0xfefc);
19476         MP_WritePhyUshort(sc, 0x14, 0x04f8);
19477         MP_WritePhyUshort(sc, 0x14, 0xfaef);
19478         MP_WritePhyUshort(sc, 0x14, 0x69e0);
19479         MP_WritePhyUshort(sc, 0x14, 0x8013);
19480         MP_WritePhyUshort(sc, 0x14, 0xad24);
19481         MP_WritePhyUshort(sc, 0x14, 0x1cbf);
19482         MP_WritePhyUshort(sc, 0x14, 0x87f0);
19483         MP_WritePhyUshort(sc, 0x14, 0x0242);
19484         MP_WritePhyUshort(sc, 0x14, 0x97ad);
19485         MP_WritePhyUshort(sc, 0x14, 0x2813);
19486         MP_WritePhyUshort(sc, 0x14, 0xe087);
19487         MP_WritePhyUshort(sc, 0x14, 0xfca0);
19488         MP_WritePhyUshort(sc, 0x14, 0x0005);
19489         MP_WritePhyUshort(sc, 0x14, 0x0287);
19490         MP_WritePhyUshort(sc, 0x14, 0x36ae);
19491         MP_WritePhyUshort(sc, 0x14, 0x10a0);
19492         MP_WritePhyUshort(sc, 0x14, 0x0105);
19493         MP_WritePhyUshort(sc, 0x14, 0x0287);
19494         MP_WritePhyUshort(sc, 0x14, 0x48ae);
19495         MP_WritePhyUshort(sc, 0x14, 0x08e0);
19496         MP_WritePhyUshort(sc, 0x14, 0x8230);
19497         MP_WritePhyUshort(sc, 0x14, 0xf626);
19498         MP_WritePhyUshort(sc, 0x14, 0xe482);
19499         MP_WritePhyUshort(sc, 0x14, 0x30ef);
19500         MP_WritePhyUshort(sc, 0x14, 0x96fe);
19501         MP_WritePhyUshort(sc, 0x14, 0xfc04);
19502         MP_WritePhyUshort(sc, 0x14, 0xf8e0);
19503         MP_WritePhyUshort(sc, 0x14, 0x8245);
19504         MP_WritePhyUshort(sc, 0x14, 0xf722);
19505         MP_WritePhyUshort(sc, 0x14, 0xe482);
19506         MP_WritePhyUshort(sc, 0x14, 0x4502);
19507         MP_WritePhyUshort(sc, 0x14, 0x46ae);
19508         MP_WritePhyUshort(sc, 0x14, 0xee87);
19509         MP_WritePhyUshort(sc, 0x14, 0xfc01);
19510         MP_WritePhyUshort(sc, 0x14, 0xfc04);
19511         MP_WritePhyUshort(sc, 0x14, 0xf8fa);
19512         MP_WritePhyUshort(sc, 0x14, 0xef69);
19513         MP_WritePhyUshort(sc, 0x14, 0xfb02);
19514         MP_WritePhyUshort(sc, 0x14, 0x46d3);
19515         MP_WritePhyUshort(sc, 0x14, 0xad50);
19516         MP_WritePhyUshort(sc, 0x14, 0x2fbf);
19517         MP_WritePhyUshort(sc, 0x14, 0x87ed);
19518         MP_WritePhyUshort(sc, 0x14, 0xd101);
19519         MP_WritePhyUshort(sc, 0x14, 0x0242);
19520         MP_WritePhyUshort(sc, 0x14, 0x59bf);
19521         MP_WritePhyUshort(sc, 0x14, 0x87ed);
19522         MP_WritePhyUshort(sc, 0x14, 0xd100);
19523         MP_WritePhyUshort(sc, 0x14, 0x0242);
19524         MP_WritePhyUshort(sc, 0x14, 0x59e0);
19525         MP_WritePhyUshort(sc, 0x14, 0x8245);
19526         MP_WritePhyUshort(sc, 0x14, 0xf622);
19527         MP_WritePhyUshort(sc, 0x14, 0xe482);
19528         MP_WritePhyUshort(sc, 0x14, 0x4502);
19529         MP_WritePhyUshort(sc, 0x14, 0x46ae);
19530         MP_WritePhyUshort(sc, 0x14, 0xd100);
19531         MP_WritePhyUshort(sc, 0x14, 0xbf87);
19532         MP_WritePhyUshort(sc, 0x14, 0xf002);
19533         MP_WritePhyUshort(sc, 0x14, 0x4259);
19534         MP_WritePhyUshort(sc, 0x14, 0xee87);
19535         MP_WritePhyUshort(sc, 0x14, 0xfc00);
19536         MP_WritePhyUshort(sc, 0x14, 0xe082);
19537         MP_WritePhyUshort(sc, 0x14, 0x30f6);
19538         MP_WritePhyUshort(sc, 0x14, 0x26e4);
19539         MP_WritePhyUshort(sc, 0x14, 0x8230);
19540         MP_WritePhyUshort(sc, 0x14, 0xffef);
19541         MP_WritePhyUshort(sc, 0x14, 0x96fe);
19542         MP_WritePhyUshort(sc, 0x14, 0xfc04);
19543         MP_WritePhyUshort(sc, 0x14, 0xf8f9);
19544         MP_WritePhyUshort(sc, 0x14, 0xface);
19545         MP_WritePhyUshort(sc, 0x14, 0xfaef);
19546         MP_WritePhyUshort(sc, 0x14, 0x69fb);
19547         MP_WritePhyUshort(sc, 0x14, 0xbf87);
19548         MP_WritePhyUshort(sc, 0x14, 0xb3d7);
19549         MP_WritePhyUshort(sc, 0x14, 0x001c);
19550         MP_WritePhyUshort(sc, 0x14, 0xd819);
19551         MP_WritePhyUshort(sc, 0x14, 0xd919);
19552         MP_WritePhyUshort(sc, 0x14, 0xda19);
19553         MP_WritePhyUshort(sc, 0x14, 0xdb19);
19554         MP_WritePhyUshort(sc, 0x14, 0x07ef);
19555         MP_WritePhyUshort(sc, 0x14, 0x9502);
19556         MP_WritePhyUshort(sc, 0x14, 0x4259);
19557         MP_WritePhyUshort(sc, 0x14, 0x073f);
19558         MP_WritePhyUshort(sc, 0x14, 0x0004);
19559         MP_WritePhyUshort(sc, 0x14, 0x9fec);
19560         MP_WritePhyUshort(sc, 0x14, 0xffef);
19561         MP_WritePhyUshort(sc, 0x14, 0x96fe);
19562         MP_WritePhyUshort(sc, 0x14, 0xc6fe);
19563         MP_WritePhyUshort(sc, 0x14, 0xfdfc);
19564         MP_WritePhyUshort(sc, 0x14, 0x0400);
19565         MP_WritePhyUshort(sc, 0x14, 0x0145);
19566         MP_WritePhyUshort(sc, 0x14, 0x7d00);
19567         MP_WritePhyUshort(sc, 0x14, 0x0345);
19568         MP_WritePhyUshort(sc, 0x14, 0x5c00);
19569         MP_WritePhyUshort(sc, 0x14, 0x0143);
19570         MP_WritePhyUshort(sc, 0x14, 0x4f00);
19571         MP_WritePhyUshort(sc, 0x14, 0x0387);
19572         MP_WritePhyUshort(sc, 0x14, 0xdb00);
19573         MP_WritePhyUshort(sc, 0x14, 0x0987);
19574         MP_WritePhyUshort(sc, 0x14, 0xde00);
19575         MP_WritePhyUshort(sc, 0x14, 0x0987);
19576         MP_WritePhyUshort(sc, 0x14, 0xe100);
19577         MP_WritePhyUshort(sc, 0x14, 0x0087);
19578         MP_WritePhyUshort(sc, 0x14, 0xeaa4);
19579         MP_WritePhyUshort(sc, 0x14, 0x00b8);
19580         MP_WritePhyUshort(sc, 0x14, 0x20c4);
19581         MP_WritePhyUshort(sc, 0x14, 0x1600);
19582         MP_WritePhyUshort(sc, 0x14, 0x000f);
19583         MP_WritePhyUshort(sc, 0x14, 0xf800);
19584         MP_WritePhyUshort(sc, 0x14, 0x7098);
19585         MP_WritePhyUshort(sc, 0x14, 0xa58a);
19586         MP_WritePhyUshort(sc, 0x14, 0xb6a8);
19587         MP_WritePhyUshort(sc, 0x14, 0x3e50);
19588         MP_WritePhyUshort(sc, 0x14, 0xa83e);
19589         MP_WritePhyUshort(sc, 0x14, 0x33bc);
19590         MP_WritePhyUshort(sc, 0x14, 0xc622);
19591         MP_WritePhyUshort(sc, 0x14, 0xbcc6);
19592         MP_WritePhyUshort(sc, 0x14, 0xaaa4);
19593         MP_WritePhyUshort(sc, 0x14, 0x42ff);
19594         MP_WritePhyUshort(sc, 0x14, 0xc408);
19595         MP_WritePhyUshort(sc, 0x14, 0x00c4);
19596         MP_WritePhyUshort(sc, 0x14, 0x16a8);
19597         MP_WritePhyUshort(sc, 0x14, 0xbcc0);
19598         MP_WritePhyUshort(sc, 0x13, 0xb818);
19599         MP_WritePhyUshort(sc, 0x14, 0x02f3);
19600         MP_WritePhyUshort(sc, 0x13, 0xb81a);
19601         MP_WritePhyUshort(sc, 0x14, 0x17d1);
19602         MP_WritePhyUshort(sc, 0x13, 0xb81c);
19603         MP_WritePhyUshort(sc, 0x14, 0x185a);
19604         MP_WritePhyUshort(sc, 0x13, 0xb81e);
19605         MP_WritePhyUshort(sc, 0x14, 0x3c66);
19606         MP_WritePhyUshort(sc, 0x13, 0xb820);
19607         MP_WritePhyUshort(sc, 0x14, 0x021f);
19608         MP_WritePhyUshort(sc, 0x13, 0xc416);
19609         MP_WritePhyUshort(sc, 0x14, 0x0500);
19610         MP_WritePhyUshort(sc, 0x13, 0xb82e);
19611         MP_WritePhyUshort(sc, 0x14, 0xfffc);
19612
19613         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19614         MP_WritePhyUshort(sc, 0x13, 0x0000);
19615         MP_WritePhyUshort(sc, 0x14, 0x0000);
19616         MP_WritePhyUshort(sc, 0x1f, 0x0B82);
19617         PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
19618         PhyRegValue &= ~(BIT_9);
19619         MP_WritePhyUshort(sc, 0x10, PhyRegValue);
19620         MP_WritePhyUshort(sc, 0x1f, 0x0A43);
19621         MP_WritePhyUshort(sc, 0x13, 0x8146);
19622         MP_WritePhyUshort(sc, 0x14, 0x0000);
19623
19624         MP_WritePhyUshort(sc, 0x1f, 0x0B82);
19625         PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
19626         PhyRegValue &= ~(BIT_4);
19627         MP_WritePhyUshort(sc, 0x10, PhyRegValue);
19628         if (sc->RequiredSecLanDonglePatch) {
19629                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19630                 PhyRegValue = MP_ReadPhyUshort(sc, 0x11);
19631                 PhyRegValue &= ~(BIT_6);
19632                 MP_WritePhyUshort(sc, 0x11, PhyRegValue);
19633         }
19634 }
19635
19636 static void re_set_phy_mcu_8168gu_2(struct re_softc *sc)
19637 {
19638         u_int16_t PhyRegValue;
19639         u_int32_t WaitCnt;
19640
19641         MP_WritePhyUshort(sc, 0x1f, 0x0B82);
19642         PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
19643         PhyRegValue |= BIT_4;
19644         MP_WritePhyUshort(sc, 0x10, PhyRegValue);
19645
19646         MP_WritePhyUshort(sc, 0x1f, 0x0B80);
19647         WaitCnt = 0;
19648         do {
19649                 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
19650                 PhyRegValue &= 0x0040;
19651                 DELAY(50);
19652                 DELAY(50);
19653                 WaitCnt++;
19654         } while(PhyRegValue != 0x0040 && WaitCnt <1000);
19655
19656         MP_WritePhyUshort(sc, 0x1f, 0x0A43);
19657         MP_WritePhyUshort(sc, 0x13, 0x8146);
19658         MP_WritePhyUshort(sc, 0x14, 0x0300);
19659         MP_WritePhyUshort(sc, 0x13, 0xB82E);
19660         MP_WritePhyUshort(sc, 0x14, 0x0001);
19661
19662         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19663         MP_WritePhyUshort(sc, 0x13, 0xb820);
19664         MP_WritePhyUshort(sc, 0x14, 0x0290);
19665         MP_WritePhyUshort(sc, 0x13, 0xa012);
19666         MP_WritePhyUshort(sc, 0x14, 0x0000);
19667         MP_WritePhyUshort(sc, 0x13, 0xa014);
19668         MP_WritePhyUshort(sc, 0x14, 0x2c04);
19669         MP_WritePhyUshort(sc, 0x14, 0x2c07);
19670         MP_WritePhyUshort(sc, 0x14, 0x2c07);
19671         MP_WritePhyUshort(sc, 0x14, 0x2c07);
19672         MP_WritePhyUshort(sc, 0x14, 0xa304);
19673         MP_WritePhyUshort(sc, 0x14, 0xa301);
19674         MP_WritePhyUshort(sc, 0x14, 0x207e);
19675         MP_WritePhyUshort(sc, 0x13, 0xa01a);
19676         MP_WritePhyUshort(sc, 0x14, 0x0000);
19677         MP_WritePhyUshort(sc, 0x13, 0xa006);
19678         MP_WritePhyUshort(sc, 0x14, 0x0fff);
19679         MP_WritePhyUshort(sc, 0x13, 0xa004);
19680         MP_WritePhyUshort(sc, 0x14, 0x0fff);
19681         MP_WritePhyUshort(sc, 0x13, 0xa002);
19682         MP_WritePhyUshort(sc, 0x14, 0x0fff);
19683         MP_WritePhyUshort(sc, 0x13, 0xa000);
19684         MP_WritePhyUshort(sc, 0x14, 0x107c);
19685         MP_WritePhyUshort(sc, 0x13, 0xb820);
19686         MP_WritePhyUshort(sc, 0x14, 0x0210);
19687
19688         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19689         MP_WritePhyUshort(sc, 0x13, 0x0000);
19690         MP_WritePhyUshort(sc, 0x14, 0x0000);
19691         MP_WritePhyUshort(sc, 0x1f, 0x0B82);
19692         PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
19693         PhyRegValue &= ~(BIT_0);
19694         MP_WritePhyUshort(sc, 0x17, PhyRegValue);
19695         MP_WritePhyUshort(sc, 0x1f, 0x0A43);
19696         MP_WritePhyUshort(sc, 0x13, 0x8146);
19697         MP_WritePhyUshort(sc, 0x14, 0x0000);
19698
19699         MP_WritePhyUshort(sc, 0x1f, 0x0B82);
19700         PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
19701         PhyRegValue &= ~(BIT_4);
19702         MP_WritePhyUshort(sc, 0x10, PhyRegValue);
19703         if (sc->RequiredSecLanDonglePatch) {
19704                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19705                 PhyRegValue = MP_ReadPhyUshort(sc, 0x11);
19706                 PhyRegValue &= ~(BIT_6);
19707                 MP_WritePhyUshort(sc, 0x11, PhyRegValue);
19708         }
19709 }
19710
19711 static void re_set_phy_mcu_8411b_1(struct re_softc *sc)
19712 {
19713         u_int16_t PhyRegValue;
19714         u_int32_t WaitCnt;
19715
19716         MP_WritePhyUshort(sc, 0x1f, 0x0B82);
19717         PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
19718         PhyRegValue |= BIT_4;
19719         MP_WritePhyUshort(sc, 0x10, PhyRegValue);
19720
19721         MP_WritePhyUshort(sc, 0x1f, 0x0B80);
19722         WaitCnt = 0;
19723         do {
19724                 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
19725                 PhyRegValue &= 0x0040;
19726                 DELAY(50);
19727                 DELAY(50);
19728                 WaitCnt++;
19729         } while(PhyRegValue != 0x0040 && WaitCnt <1000);
19730
19731         MP_WritePhyUshort(sc, 0x1f, 0x0A43);
19732         MP_WritePhyUshort(sc, 0x13, 0x8146);
19733         MP_WritePhyUshort(sc, 0x14, 0x0100);
19734         MP_WritePhyUshort(sc, 0x13, 0xB82E);
19735         MP_WritePhyUshort(sc, 0x14, 0x0001);
19736
19737         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19738         MP_WritePhyUshort(sc, 0x13, 0xb820);
19739         MP_WritePhyUshort(sc, 0x14, 0x0290);
19740         MP_WritePhyUshort(sc, 0x13, 0xa012);
19741         MP_WritePhyUshort(sc, 0x14, 0x0000);
19742         MP_WritePhyUshort(sc, 0x13, 0xa014);
19743         MP_WritePhyUshort(sc, 0x14, 0x2c04);
19744         MP_WritePhyUshort(sc, 0x14, 0x2c07);
19745         MP_WritePhyUshort(sc, 0x14, 0x2c07);
19746         MP_WritePhyUshort(sc, 0x14, 0x2c07);
19747         MP_WritePhyUshort(sc, 0x14, 0xa304);
19748         MP_WritePhyUshort(sc, 0x14, 0xa301);
19749         MP_WritePhyUshort(sc, 0x14, 0x207e);
19750         MP_WritePhyUshort(sc, 0x13, 0xa01a);
19751         MP_WritePhyUshort(sc, 0x14, 0x0000);
19752         MP_WritePhyUshort(sc, 0x13, 0xa006);
19753         MP_WritePhyUshort(sc, 0x14, 0x0fff);
19754         MP_WritePhyUshort(sc, 0x13, 0xa004);
19755         MP_WritePhyUshort(sc, 0x14, 0x0fff);
19756         MP_WritePhyUshort(sc, 0x13, 0xa002);
19757         MP_WritePhyUshort(sc, 0x14, 0x0fff);
19758         MP_WritePhyUshort(sc, 0x13, 0xa000);
19759         MP_WritePhyUshort(sc, 0x14, 0x107c);
19760         MP_WritePhyUshort(sc, 0x13, 0xb820);
19761         MP_WritePhyUshort(sc, 0x14, 0x0210);
19762
19763         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19764         MP_WritePhyUshort(sc, 0x13, 0x0000);
19765         MP_WritePhyUshort(sc, 0x14, 0x0000);
19766         MP_WritePhyUshort(sc, 0x1f, 0x0B82);
19767         PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
19768         PhyRegValue &= ~(BIT_0);
19769         MP_WritePhyUshort(sc, 0x17, PhyRegValue);
19770         MP_WritePhyUshort(sc, 0x1f, 0x0A43);
19771         MP_WritePhyUshort(sc, 0x13, 0x8146);
19772         MP_WritePhyUshort(sc, 0x14, 0x0000);
19773
19774         MP_WritePhyUshort(sc, 0x1f, 0x0B82);
19775         PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
19776         PhyRegValue &= ~(BIT_4);
19777         MP_WritePhyUshort(sc, 0x10, PhyRegValue);
19778         if (sc->RequiredSecLanDonglePatch) {
19779                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19780                 PhyRegValue = MP_ReadPhyUshort(sc, 0x11);
19781                 PhyRegValue &= ~(BIT_6);
19782                 MP_WritePhyUshort(sc, 0x11, PhyRegValue);
19783         }
19784 }
19785
19786 static void re_set_phy_mcu_8168h_1(struct re_softc *sc)
19787 {
19788         u_int16_t PhyRegValue;
19789         u_int32_t WaitCnt;
19790
19791         MP_WritePhyUshort(sc, 0x1f, 0x0B82);
19792         PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
19793         PhyRegValue |= BIT_4;
19794         MP_WritePhyUshort(sc, 0x10, PhyRegValue);
19795
19796         MP_WritePhyUshort(sc, 0x1f, 0x0B80);
19797         WaitCnt = 0;
19798         do {
19799                 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
19800                 PhyRegValue &= 0x0040;
19801                 DELAY(50);
19802                 DELAY(50);
19803                 WaitCnt++;
19804         } while(PhyRegValue != 0x0040 && WaitCnt <1000);
19805
19806         MP_WritePhyUshort(sc, 0x1f, 0x0A43);
19807         MP_WritePhyUshort(sc, 0x13, 0x8028);
19808         MP_WritePhyUshort(sc, 0x14, 0x6200);
19809         MP_WritePhyUshort(sc, 0x13, 0xB82E);
19810         MP_WritePhyUshort(sc, 0x14, 0x0001);
19811
19812         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19813         MP_WritePhyUshort(sc, 0x13, 0xB820);
19814         MP_WritePhyUshort(sc, 0x14, 0x0290);
19815         MP_WritePhyUshort(sc, 0x13, 0xA012);
19816         MP_WritePhyUshort(sc, 0x14, 0x0000);
19817         MP_WritePhyUshort(sc, 0x13, 0xA014);
19818         MP_WritePhyUshort(sc, 0x14, 0x2c04);
19819         MP_WritePhyUshort(sc, 0x14, 0x2c10);
19820         MP_WritePhyUshort(sc, 0x14, 0x2c10);
19821         MP_WritePhyUshort(sc, 0x14, 0x2c10);
19822         MP_WritePhyUshort(sc, 0x14, 0xa210);
19823         MP_WritePhyUshort(sc, 0x14, 0xa101);
19824         MP_WritePhyUshort(sc, 0x14, 0xce10);
19825         MP_WritePhyUshort(sc, 0x14, 0xe070);
19826         MP_WritePhyUshort(sc, 0x14, 0x0f40);
19827         MP_WritePhyUshort(sc, 0x14, 0xaf01);
19828         MP_WritePhyUshort(sc, 0x14, 0x8f01);
19829         MP_WritePhyUshort(sc, 0x14, 0x183e);
19830         MP_WritePhyUshort(sc, 0x14, 0x8e10);
19831         MP_WritePhyUshort(sc, 0x14, 0x8101);
19832         MP_WritePhyUshort(sc, 0x14, 0x8210);
19833         MP_WritePhyUshort(sc, 0x14, 0x28da);
19834         MP_WritePhyUshort(sc, 0x13, 0xA01A);
19835         MP_WritePhyUshort(sc, 0x14, 0x0000);
19836         MP_WritePhyUshort(sc, 0x13, 0xA006);
19837         MP_WritePhyUshort(sc, 0x14, 0x0017);
19838         MP_WritePhyUshort(sc, 0x13, 0xA004);
19839         MP_WritePhyUshort(sc, 0x14, 0x0015);
19840         MP_WritePhyUshort(sc, 0x13, 0xA002);
19841         MP_WritePhyUshort(sc, 0x14, 0x0013);
19842         MP_WritePhyUshort(sc, 0x13, 0xA000);
19843         MP_WritePhyUshort(sc, 0x14, 0x18d1);
19844         MP_WritePhyUshort(sc, 0x13, 0xB820);
19845         MP_WritePhyUshort(sc, 0x14, 0x0210);
19846
19847         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19848         MP_WritePhyUshort(sc, 0x13, 0x0000);
19849         MP_WritePhyUshort(sc, 0x14, 0x0000);
19850         MP_WritePhyUshort(sc, 0x1f, 0x0B82);
19851         PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
19852         PhyRegValue &= ~(BIT_0);
19853         MP_WritePhyUshort(sc, 0x17, PhyRegValue);
19854         MP_WritePhyUshort(sc, 0x1f, 0x0A43);
19855         MP_WritePhyUshort(sc, 0x13, 0x8028);
19856         MP_WritePhyUshort(sc, 0x14, 0x0000);
19857
19858         MP_WritePhyUshort(sc, 0x1f, 0x0B82);
19859         PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
19860         PhyRegValue &= ~(BIT_4);
19861         MP_WritePhyUshort(sc, 0x10, PhyRegValue);
19862         if (sc->RequiredSecLanDonglePatch) {
19863                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19864                 PhyRegValue = MP_ReadPhyUshort(sc, 0x11);
19865                 PhyRegValue &= ~(BIT_6);
19866                 MP_WritePhyUshort(sc, 0x11, PhyRegValue);
19867         }
19868 }
19869
19870 static void re_set_phy_mcu_8168h_2(struct re_softc *sc)
19871 {
19872         u_int16_t PhyRegValue;
19873         u_int32_t WaitCnt;
19874
19875         MP_WritePhyUshort(sc, 0x1f, 0x0B82);
19876         PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
19877         PhyRegValue |= BIT_4;
19878         MP_WritePhyUshort(sc, 0x10, PhyRegValue);
19879
19880         MP_WritePhyUshort(sc, 0x1f, 0x0B80);
19881         WaitCnt = 0;
19882         do {
19883                 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
19884                 PhyRegValue &= 0x0040;
19885                 DELAY(50);
19886                 DELAY(50);
19887                 WaitCnt++;
19888         } while(PhyRegValue != 0x0040 && WaitCnt <1000);
19889
19890         MP_WritePhyUshort(sc, 0x1f, 0x0A43);
19891         MP_WritePhyUshort(sc, 0x13, 0x8028);
19892         MP_WritePhyUshort(sc, 0x14, 0x6201);
19893         MP_WritePhyUshort(sc, 0x13, 0xB82E);
19894         MP_WritePhyUshort(sc, 0x14, 0x0001);
19895
19896         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19897         MP_WritePhyUshort(sc, 0x13, 0xB820);
19898         MP_WritePhyUshort(sc, 0x14, 0x0290);
19899         MP_WritePhyUshort(sc, 0x13, 0xA012);
19900         MP_WritePhyUshort(sc, 0x14, 0x0000);
19901         MP_WritePhyUshort(sc, 0x13, 0xA014);
19902         MP_WritePhyUshort(sc, 0x14, 0x2c04);
19903         MP_WritePhyUshort(sc, 0x14, 0x2c09);
19904         MP_WritePhyUshort(sc, 0x14, 0x2c09);
19905         MP_WritePhyUshort(sc, 0x14, 0x2c09);
19906         MP_WritePhyUshort(sc, 0x14, 0xad01);
19907         MP_WritePhyUshort(sc, 0x14, 0xad01);
19908         MP_WritePhyUshort(sc, 0x14, 0xad01);
19909         MP_WritePhyUshort(sc, 0x14, 0xad01);
19910         MP_WritePhyUshort(sc, 0x14, 0x236c);
19911         MP_WritePhyUshort(sc, 0x13, 0xA01A);
19912         MP_WritePhyUshort(sc, 0x14, 0x0000);
19913         MP_WritePhyUshort(sc, 0x13, 0xA006);
19914         MP_WritePhyUshort(sc, 0x14, 0x0fff);
19915         MP_WritePhyUshort(sc, 0x13, 0xA004);
19916         MP_WritePhyUshort(sc, 0x14, 0x0fff);
19917         MP_WritePhyUshort(sc, 0x13, 0xA002);
19918         MP_WritePhyUshort(sc, 0x14, 0x0fff);
19919         MP_WritePhyUshort(sc, 0x13, 0xA000);
19920         MP_WritePhyUshort(sc, 0x14, 0x136b);
19921         MP_WritePhyUshort(sc, 0x13, 0xB820);
19922         MP_WritePhyUshort(sc, 0x14, 0x0210);
19923
19924         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19925         MP_WritePhyUshort(sc, 0x13, 0x0000);
19926         MP_WritePhyUshort(sc, 0x14, 0x0000);
19927         MP_WritePhyUshort(sc, 0x1f, 0x0B82);
19928         PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
19929         PhyRegValue &= ~(BIT_0);
19930         MP_WritePhyUshort(sc, 0x17, PhyRegValue);
19931         MP_WritePhyUshort(sc, 0x1f, 0x0A43);
19932         MP_WritePhyUshort(sc, 0x13, 0x8028);
19933         MP_WritePhyUshort(sc, 0x14, 0x0000);
19934
19935         MP_WritePhyUshort(sc, 0x1f, 0x0B82);
19936         PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
19937         PhyRegValue &= ~(BIT_4);
19938         MP_WritePhyUshort(sc, 0x10, PhyRegValue);
19939         if (sc->RequiredSecLanDonglePatch) {
19940                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19941                 PhyRegValue = MP_ReadPhyUshort(sc, 0x11);
19942                 PhyRegValue &= ~(BIT_6);
19943                 MP_WritePhyUshort(sc, 0x11, PhyRegValue);
19944         }
19945 }
19946
19947 static void re_set_phy_mcu_8168ep_1(struct re_softc *sc)
19948 {
19949         u_int16_t PhyRegValue;
19950         u_int32_t WaitCnt;
19951
19952         MP_WritePhyUshort(sc, 0x1f, 0x0B82);
19953         PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
19954         PhyRegValue |= BIT_4;
19955         MP_WritePhyUshort(sc, 0x10, PhyRegValue);
19956
19957         MP_WritePhyUshort(sc, 0x1f, 0x0B80);
19958         WaitCnt = 0;
19959         do {
19960                 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
19961                 PhyRegValue &= 0x0040;
19962                 DELAY(50);
19963                 DELAY(50);
19964                 WaitCnt++;
19965         } while(PhyRegValue != 0x0040 && WaitCnt <1000);
19966
19967         MP_WritePhyUshort(sc, 0x1f, 0x0A43);
19968         MP_WritePhyUshort(sc, 0x13, 0x8146);
19969         MP_WritePhyUshort(sc, 0x14, 0x2700);
19970         MP_WritePhyUshort(sc, 0x13, 0xB82E);
19971         MP_WritePhyUshort(sc, 0x14, 0x0001);
19972
19973         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19974         MP_WritePhyUshort(sc, 0x13, 0xb820);
19975         MP_WritePhyUshort(sc, 0x14, 0x0090);
19976         MP_WritePhyUshort(sc, 0x13, 0xa012);
19977         MP_WritePhyUshort(sc, 0x14, 0x0000);
19978         MP_WritePhyUshort(sc, 0x13, 0xa014);
19979         MP_WritePhyUshort(sc, 0x14, 0x2c04);
19980         MP_WritePhyUshort(sc, 0x14, 0x2c1b);
19981         MP_WritePhyUshort(sc, 0x14, 0x2c65);
19982         MP_WritePhyUshort(sc, 0x14, 0x2d14);
19983         MP_WritePhyUshort(sc, 0x14, 0xd71e);
19984         MP_WritePhyUshort(sc, 0x14, 0x4092);
19985         MP_WritePhyUshort(sc, 0x14, 0xba04);
19986         MP_WritePhyUshort(sc, 0x14, 0x3084);
19987         MP_WritePhyUshort(sc, 0x14, 0x1d04);
19988         MP_WritePhyUshort(sc, 0x14, 0x1cdd);
19989         MP_WritePhyUshort(sc, 0x14, 0x1ce8);
19990         MP_WritePhyUshort(sc, 0x14, 0xaeff);
19991         MP_WritePhyUshort(sc, 0x14, 0xaf02);
19992         MP_WritePhyUshort(sc, 0x14, 0x8f02);
19993         MP_WritePhyUshort(sc, 0x14, 0x8eff);
19994         MP_WritePhyUshort(sc, 0x14, 0xce01);
19995         MP_WritePhyUshort(sc, 0x14, 0xe070);
19996         MP_WritePhyUshort(sc, 0x14, 0x0f00);
19997         MP_WritePhyUshort(sc, 0x14, 0xaf01);
19998         MP_WritePhyUshort(sc, 0x14, 0x8f01);
19999         MP_WritePhyUshort(sc, 0x14, 0xd712);
20000         MP_WritePhyUshort(sc, 0x14, 0x5fe8);
20001         MP_WritePhyUshort(sc, 0x14, 0xaf02);
20002         MP_WritePhyUshort(sc, 0x14, 0x8f02);
20003         MP_WritePhyUshort(sc, 0x14, 0x8e01);
20004         MP_WritePhyUshort(sc, 0x14, 0x1cf2);
20005         MP_WritePhyUshort(sc, 0x14, 0x2825);
20006         MP_WritePhyUshort(sc, 0x14, 0xd05a);
20007         MP_WritePhyUshort(sc, 0x14, 0xd19a);
20008         MP_WritePhyUshort(sc, 0x14, 0xd709);
20009         MP_WritePhyUshort(sc, 0x14, 0x608f);
20010         MP_WritePhyUshort(sc, 0x14, 0xd06b);
20011         MP_WritePhyUshort(sc, 0x14, 0xd18a);
20012         MP_WritePhyUshort(sc, 0x14, 0x2c25);
20013         MP_WritePhyUshort(sc, 0x14, 0xd0be);
20014         MP_WritePhyUshort(sc, 0x14, 0xd188);
20015         MP_WritePhyUshort(sc, 0x14, 0x2c25);
20016         MP_WritePhyUshort(sc, 0x14, 0xd708);
20017         MP_WritePhyUshort(sc, 0x14, 0x4072);
20018         MP_WritePhyUshort(sc, 0x14, 0xc104);
20019         MP_WritePhyUshort(sc, 0x14, 0x2c37);
20020         MP_WritePhyUshort(sc, 0x14, 0x4076);
20021         MP_WritePhyUshort(sc, 0x14, 0xc110);
20022         MP_WritePhyUshort(sc, 0x14, 0x2c37);
20023         MP_WritePhyUshort(sc, 0x14, 0x4071);
20024         MP_WritePhyUshort(sc, 0x14, 0xc102);
20025         MP_WritePhyUshort(sc, 0x14, 0x2c37);
20026         MP_WritePhyUshort(sc, 0x14, 0x4070);
20027         MP_WritePhyUshort(sc, 0x14, 0xc101);
20028         MP_WritePhyUshort(sc, 0x14, 0x2c37);
20029         MP_WritePhyUshort(sc, 0x14, 0x1786);
20030         MP_WritePhyUshort(sc, 0x14, 0xd709);
20031         MP_WritePhyUshort(sc, 0x14, 0x3390);
20032         MP_WritePhyUshort(sc, 0x14, 0x5c32);
20033         MP_WritePhyUshort(sc, 0x14, 0x2c47);
20034         MP_WritePhyUshort(sc, 0x14, 0x1786);
20035         MP_WritePhyUshort(sc, 0x14, 0xd708);
20036         MP_WritePhyUshort(sc, 0x14, 0x6193);
20037         MP_WritePhyUshort(sc, 0x14, 0xd709);
20038         MP_WritePhyUshort(sc, 0x14, 0x5f9d);
20039         MP_WritePhyUshort(sc, 0x14, 0x408b);
20040         MP_WritePhyUshort(sc, 0x14, 0xd71e);
20041         MP_WritePhyUshort(sc, 0x14, 0x6042);
20042         MP_WritePhyUshort(sc, 0x14, 0xb401);
20043         MP_WritePhyUshort(sc, 0x14, 0x1786);
20044         MP_WritePhyUshort(sc, 0x14, 0xd708);
20045         MP_WritePhyUshort(sc, 0x14, 0x6073);
20046         MP_WritePhyUshort(sc, 0x14, 0x5fbc);
20047         MP_WritePhyUshort(sc, 0x14, 0x2c46);
20048         MP_WritePhyUshort(sc, 0x14, 0x26fe);
20049         MP_WritePhyUshort(sc, 0x14, 0xb280);
20050         MP_WritePhyUshort(sc, 0x14, 0xa841);
20051         MP_WritePhyUshort(sc, 0x14, 0x94e0);
20052         MP_WritePhyUshort(sc, 0x14, 0x8710);
20053         MP_WritePhyUshort(sc, 0x14, 0xd709);
20054         MP_WritePhyUshort(sc, 0x14, 0x42ec);
20055         MP_WritePhyUshort(sc, 0x14, 0x606d);
20056         MP_WritePhyUshort(sc, 0x14, 0xd207);
20057         MP_WritePhyUshort(sc, 0x14, 0x2c50);
20058         MP_WritePhyUshort(sc, 0x14, 0xd203);
20059         MP_WritePhyUshort(sc, 0x14, 0x33ff);
20060         MP_WritePhyUshort(sc, 0x14, 0x5647);
20061         MP_WritePhyUshort(sc, 0x14, 0x3275);
20062         MP_WritePhyUshort(sc, 0x14, 0x7c57);
20063         MP_WritePhyUshort(sc, 0x14, 0xb240);
20064         MP_WritePhyUshort(sc, 0x14, 0xb402);
20065         MP_WritePhyUshort(sc, 0x14, 0x2647);
20066         MP_WritePhyUshort(sc, 0x14, 0x6096);
20067         MP_WritePhyUshort(sc, 0x14, 0xb240);
20068         MP_WritePhyUshort(sc, 0x14, 0xb406);
20069         MP_WritePhyUshort(sc, 0x14, 0x2647);
20070         MP_WritePhyUshort(sc, 0x14, 0x31d7);
20071         MP_WritePhyUshort(sc, 0x14, 0x7c60);
20072         MP_WritePhyUshort(sc, 0x14, 0xb240);
20073         MP_WritePhyUshort(sc, 0x14, 0xb40e);
20074         MP_WritePhyUshort(sc, 0x14, 0x2647);
20075         MP_WritePhyUshort(sc, 0x14, 0xb410);
20076         MP_WritePhyUshort(sc, 0x14, 0x8802);
20077         MP_WritePhyUshort(sc, 0x14, 0xb240);
20078         MP_WritePhyUshort(sc, 0x14, 0x940e);
20079         MP_WritePhyUshort(sc, 0x14, 0x2647);
20080         MP_WritePhyUshort(sc, 0x14, 0xba04);
20081         MP_WritePhyUshort(sc, 0x14, 0x1cdd);
20082         MP_WritePhyUshort(sc, 0x14, 0xa902);
20083         MP_WritePhyUshort(sc, 0x14, 0xd711);
20084         MP_WritePhyUshort(sc, 0x14, 0x4045);
20085         MP_WritePhyUshort(sc, 0x14, 0xa980);
20086         MP_WritePhyUshort(sc, 0x14, 0x3003);
20087         MP_WritePhyUshort(sc, 0x14, 0x5a19);
20088         MP_WritePhyUshort(sc, 0x14, 0xa540);
20089         MP_WritePhyUshort(sc, 0x14, 0xa601);
20090         MP_WritePhyUshort(sc, 0x14, 0xd710);
20091         MP_WritePhyUshort(sc, 0x14, 0x4043);
20092         MP_WritePhyUshort(sc, 0x14, 0xa910);
20093         MP_WritePhyUshort(sc, 0x14, 0xd711);
20094         MP_WritePhyUshort(sc, 0x14, 0x60a0);
20095         MP_WritePhyUshort(sc, 0x14, 0xca33);
20096         MP_WritePhyUshort(sc, 0x14, 0xcb33);
20097         MP_WritePhyUshort(sc, 0x14, 0xa941);
20098         MP_WritePhyUshort(sc, 0x14, 0x2c7b);
20099         MP_WritePhyUshort(sc, 0x14, 0xcaff);
20100         MP_WritePhyUshort(sc, 0x14, 0xcbff);
20101         MP_WritePhyUshort(sc, 0x14, 0xa921);
20102         MP_WritePhyUshort(sc, 0x14, 0xce02);
20103         MP_WritePhyUshort(sc, 0x14, 0xe070);
20104         MP_WritePhyUshort(sc, 0x14, 0x0f10);
20105         MP_WritePhyUshort(sc, 0x14, 0xaf01);
20106         MP_WritePhyUshort(sc, 0x14, 0x8f01);
20107         MP_WritePhyUshort(sc, 0x14, 0x1791);
20108         MP_WritePhyUshort(sc, 0x14, 0x8e02);
20109         MP_WritePhyUshort(sc, 0x14, 0xd710);
20110         MP_WritePhyUshort(sc, 0x14, 0x41a3);
20111         MP_WritePhyUshort(sc, 0x14, 0xa140);
20112         MP_WritePhyUshort(sc, 0x14, 0xa220);
20113         MP_WritePhyUshort(sc, 0x14, 0xce10);
20114         MP_WritePhyUshort(sc, 0x14, 0xe070);
20115         MP_WritePhyUshort(sc, 0x14, 0x0f40);
20116         MP_WritePhyUshort(sc, 0x14, 0xaf01);
20117         MP_WritePhyUshort(sc, 0x14, 0x8f01);
20118         MP_WritePhyUshort(sc, 0x14, 0x1791);
20119         MP_WritePhyUshort(sc, 0x14, 0x8e10);
20120         MP_WritePhyUshort(sc, 0x14, 0x8140);
20121         MP_WritePhyUshort(sc, 0x14, 0x8220);
20122         MP_WritePhyUshort(sc, 0x14, 0xa301);
20123         MP_WritePhyUshort(sc, 0x14, 0x17b2);
20124         MP_WritePhyUshort(sc, 0x14, 0xd710);
20125         MP_WritePhyUshort(sc, 0x14, 0x609c);
20126         MP_WritePhyUshort(sc, 0x14, 0xd71e);
20127         MP_WritePhyUshort(sc, 0x14, 0x7fa4);
20128         MP_WritePhyUshort(sc, 0x14, 0x2cdb);
20129         MP_WritePhyUshort(sc, 0x14, 0x1cf0);
20130         MP_WritePhyUshort(sc, 0x14, 0xce04);
20131         MP_WritePhyUshort(sc, 0x14, 0xe070);
20132         MP_WritePhyUshort(sc, 0x14, 0x0f20);
20133         MP_WritePhyUshort(sc, 0x14, 0xaf01);
20134         MP_WritePhyUshort(sc, 0x14, 0x8f01);
20135         MP_WritePhyUshort(sc, 0x14, 0x1791);
20136         MP_WritePhyUshort(sc, 0x14, 0x8e04);
20137         MP_WritePhyUshort(sc, 0x14, 0x6044);
20138         MP_WritePhyUshort(sc, 0x14, 0x2cdb);
20139         MP_WritePhyUshort(sc, 0x14, 0xa520);
20140         MP_WritePhyUshort(sc, 0x14, 0xd710);
20141         MP_WritePhyUshort(sc, 0x14, 0x4043);
20142         MP_WritePhyUshort(sc, 0x14, 0x2cc8);
20143         MP_WritePhyUshort(sc, 0x14, 0xe00f);
20144         MP_WritePhyUshort(sc, 0x14, 0x0501);
20145         MP_WritePhyUshort(sc, 0x14, 0x1cf6);
20146         MP_WritePhyUshort(sc, 0x14, 0xb801);
20147         MP_WritePhyUshort(sc, 0x14, 0xd71e);
20148         MP_WritePhyUshort(sc, 0x14, 0x4060);
20149         MP_WritePhyUshort(sc, 0x14, 0x7fc4);
20150         MP_WritePhyUshort(sc, 0x14, 0x2cdb);
20151         MP_WritePhyUshort(sc, 0x14, 0x1cfc);
20152         MP_WritePhyUshort(sc, 0x14, 0xe00f);
20153         MP_WritePhyUshort(sc, 0x14, 0x0502);
20154         MP_WritePhyUshort(sc, 0x14, 0x1cf6);
20155         MP_WritePhyUshort(sc, 0x14, 0xb802);
20156         MP_WritePhyUshort(sc, 0x14, 0xd71e);
20157         MP_WritePhyUshort(sc, 0x14, 0x4061);
20158         MP_WritePhyUshort(sc, 0x14, 0x7fc4);
20159         MP_WritePhyUshort(sc, 0x14, 0x2cdb);
20160         MP_WritePhyUshort(sc, 0x14, 0x1cfc);
20161         MP_WritePhyUshort(sc, 0x14, 0xe00f);
20162         MP_WritePhyUshort(sc, 0x14, 0x0504);
20163         MP_WritePhyUshort(sc, 0x14, 0xd710);
20164         MP_WritePhyUshort(sc, 0x14, 0x6099);
20165         MP_WritePhyUshort(sc, 0x14, 0xd71e);
20166         MP_WritePhyUshort(sc, 0x14, 0x7fa4);
20167         MP_WritePhyUshort(sc, 0x14, 0x2cdb);
20168         MP_WritePhyUshort(sc, 0x14, 0xc17f);
20169         MP_WritePhyUshort(sc, 0x14, 0xc200);
20170         MP_WritePhyUshort(sc, 0x14, 0xc43f);
20171         MP_WritePhyUshort(sc, 0x14, 0xcc03);
20172         MP_WritePhyUshort(sc, 0x14, 0xa701);
20173         MP_WritePhyUshort(sc, 0x14, 0xa510);
20174         MP_WritePhyUshort(sc, 0x14, 0xd710);
20175         MP_WritePhyUshort(sc, 0x14, 0x4018);
20176         MP_WritePhyUshort(sc, 0x14, 0x9910);
20177         MP_WritePhyUshort(sc, 0x14, 0x8510);
20178         MP_WritePhyUshort(sc, 0x14, 0x28a1);
20179         MP_WritePhyUshort(sc, 0x14, 0xe00f);
20180         MP_WritePhyUshort(sc, 0x14, 0x0504);
20181         MP_WritePhyUshort(sc, 0x14, 0xd710);
20182         MP_WritePhyUshort(sc, 0x14, 0x6099);
20183         MP_WritePhyUshort(sc, 0x14, 0xd71e);
20184         MP_WritePhyUshort(sc, 0x14, 0x7fa4);
20185         MP_WritePhyUshort(sc, 0x14, 0x2cdb);
20186         MP_WritePhyUshort(sc, 0x14, 0xa608);
20187         MP_WritePhyUshort(sc, 0x14, 0xc17d);
20188         MP_WritePhyUshort(sc, 0x14, 0xc200);
20189         MP_WritePhyUshort(sc, 0x14, 0xc43f);
20190         MP_WritePhyUshort(sc, 0x14, 0xcc03);
20191         MP_WritePhyUshort(sc, 0x14, 0xa701);
20192         MP_WritePhyUshort(sc, 0x14, 0xa510);
20193         MP_WritePhyUshort(sc, 0x14, 0xd710);
20194         MP_WritePhyUshort(sc, 0x14, 0x4018);
20195         MP_WritePhyUshort(sc, 0x14, 0x9910);
20196         MP_WritePhyUshort(sc, 0x14, 0x8510);
20197         MP_WritePhyUshort(sc, 0x14, 0x298e);
20198         MP_WritePhyUshort(sc, 0x14, 0x17bd);
20199         MP_WritePhyUshort(sc, 0x14, 0x2815);
20200         MP_WritePhyUshort(sc, 0x14, 0xc000);
20201         MP_WritePhyUshort(sc, 0x14, 0xc100);
20202         MP_WritePhyUshort(sc, 0x14, 0xc200);
20203         MP_WritePhyUshort(sc, 0x14, 0xc300);
20204         MP_WritePhyUshort(sc, 0x14, 0xc400);
20205         MP_WritePhyUshort(sc, 0x14, 0xc500);
20206         MP_WritePhyUshort(sc, 0x14, 0xc600);
20207         MP_WritePhyUshort(sc, 0x14, 0xc7c1);
20208         MP_WritePhyUshort(sc, 0x14, 0xc800);
20209         MP_WritePhyUshort(sc, 0x14, 0xcc00);
20210         MP_WritePhyUshort(sc, 0x14, 0x0800);
20211         MP_WritePhyUshort(sc, 0x14, 0xca0f);
20212         MP_WritePhyUshort(sc, 0x14, 0xcbff);
20213         MP_WritePhyUshort(sc, 0x14, 0xa901);
20214         MP_WritePhyUshort(sc, 0x14, 0x8902);
20215         MP_WritePhyUshort(sc, 0x14, 0xc900);
20216         MP_WritePhyUshort(sc, 0x14, 0xca00);
20217         MP_WritePhyUshort(sc, 0x14, 0xcb00);
20218         MP_WritePhyUshort(sc, 0x14, 0x0800);
20219         MP_WritePhyUshort(sc, 0x14, 0xb804);
20220         MP_WritePhyUshort(sc, 0x14, 0x0800);
20221         MP_WritePhyUshort(sc, 0x14, 0xd71e);
20222         MP_WritePhyUshort(sc, 0x14, 0x6044);
20223         MP_WritePhyUshort(sc, 0x14, 0x9804);
20224         MP_WritePhyUshort(sc, 0x14, 0x0800);
20225         MP_WritePhyUshort(sc, 0x14, 0xd710);
20226         MP_WritePhyUshort(sc, 0x14, 0x6099);
20227         MP_WritePhyUshort(sc, 0x14, 0xd71e);
20228         MP_WritePhyUshort(sc, 0x14, 0x7fa4);
20229         MP_WritePhyUshort(sc, 0x14, 0x2cdb);
20230         MP_WritePhyUshort(sc, 0x14, 0x0800);
20231         MP_WritePhyUshort(sc, 0x14, 0xa510);
20232         MP_WritePhyUshort(sc, 0x14, 0xd710);
20233         MP_WritePhyUshort(sc, 0x14, 0x6098);
20234         MP_WritePhyUshort(sc, 0x14, 0xd71e);
20235         MP_WritePhyUshort(sc, 0x14, 0x7fa4);
20236         MP_WritePhyUshort(sc, 0x14, 0x2cdb);
20237         MP_WritePhyUshort(sc, 0x14, 0x8510);
20238         MP_WritePhyUshort(sc, 0x14, 0x0800);
20239         MP_WritePhyUshort(sc, 0x14, 0xd711);
20240         MP_WritePhyUshort(sc, 0x14, 0x3003);
20241         MP_WritePhyUshort(sc, 0x14, 0x1d08);
20242         MP_WritePhyUshort(sc, 0x14, 0x2d12);
20243         MP_WritePhyUshort(sc, 0x14, 0xd710);
20244         MP_WritePhyUshort(sc, 0x14, 0x60be);
20245         MP_WritePhyUshort(sc, 0x14, 0xe060);
20246         MP_WritePhyUshort(sc, 0x14, 0x0920);
20247         MP_WritePhyUshort(sc, 0x14, 0x1cdd);
20248         MP_WritePhyUshort(sc, 0x14, 0x2c90);
20249         MP_WritePhyUshort(sc, 0x14, 0xd71e);
20250         MP_WritePhyUshort(sc, 0x14, 0x3063);
20251         MP_WritePhyUshort(sc, 0x14, 0x19b0);
20252         MP_WritePhyUshort(sc, 0x14, 0x28d5);
20253         MP_WritePhyUshort(sc, 0x14, 0x1cdd);
20254         MP_WritePhyUshort(sc, 0x14, 0x2a25);
20255         MP_WritePhyUshort(sc, 0x14, 0xa802);
20256         MP_WritePhyUshort(sc, 0x14, 0xa303);
20257         MP_WritePhyUshort(sc, 0x14, 0x843f);
20258         MP_WritePhyUshort(sc, 0x14, 0x81ff);
20259         MP_WritePhyUshort(sc, 0x14, 0x8208);
20260         MP_WritePhyUshort(sc, 0x14, 0xa201);
20261         MP_WritePhyUshort(sc, 0x14, 0xc001);
20262         MP_WritePhyUshort(sc, 0x14, 0xd710);
20263         MP_WritePhyUshort(sc, 0x14, 0x30a0);
20264         MP_WritePhyUshort(sc, 0x14, 0x0d23);
20265         MP_WritePhyUshort(sc, 0x14, 0x30a0);
20266         MP_WritePhyUshort(sc, 0x14, 0x3d1a);
20267         MP_WritePhyUshort(sc, 0x14, 0xd71e);
20268         MP_WritePhyUshort(sc, 0x14, 0x7f4c);
20269         MP_WritePhyUshort(sc, 0x14, 0x2b1e);
20270         MP_WritePhyUshort(sc, 0x14, 0xe003);
20271         MP_WritePhyUshort(sc, 0x14, 0x0202);
20272         MP_WritePhyUshort(sc, 0x14, 0xd710);
20273         MP_WritePhyUshort(sc, 0x14, 0x6090);
20274         MP_WritePhyUshort(sc, 0x14, 0xd71e);
20275         MP_WritePhyUshort(sc, 0x14, 0x7fac);
20276         MP_WritePhyUshort(sc, 0x14, 0x2b1e);
20277         MP_WritePhyUshort(sc, 0x14, 0xa20c);
20278         MP_WritePhyUshort(sc, 0x14, 0xd710);
20279         MP_WritePhyUshort(sc, 0x14, 0x6091);
20280         MP_WritePhyUshort(sc, 0x14, 0xd71e);
20281         MP_WritePhyUshort(sc, 0x14, 0x7fac);
20282         MP_WritePhyUshort(sc, 0x14, 0x2b1e);
20283         MP_WritePhyUshort(sc, 0x14, 0x820e);
20284         MP_WritePhyUshort(sc, 0x14, 0xa3e0);
20285         MP_WritePhyUshort(sc, 0x14, 0xa520);
20286         MP_WritePhyUshort(sc, 0x14, 0xd710);
20287         MP_WritePhyUshort(sc, 0x14, 0x609d);
20288         MP_WritePhyUshort(sc, 0x14, 0xd71e);
20289         MP_WritePhyUshort(sc, 0x14, 0x7fac);
20290         MP_WritePhyUshort(sc, 0x14, 0x2b1e);
20291         MP_WritePhyUshort(sc, 0x14, 0x8520);
20292         MP_WritePhyUshort(sc, 0x14, 0x6703);
20293         MP_WritePhyUshort(sc, 0x14, 0x2d3b);
20294         MP_WritePhyUshort(sc, 0x14, 0xa13e);
20295         MP_WritePhyUshort(sc, 0x14, 0xc001);
20296         MP_WritePhyUshort(sc, 0x14, 0xd710);
20297         MP_WritePhyUshort(sc, 0x14, 0x4000);
20298         MP_WritePhyUshort(sc, 0x14, 0x6046);
20299         MP_WritePhyUshort(sc, 0x14, 0x2d14);
20300         MP_WritePhyUshort(sc, 0x14, 0xa43f);
20301         MP_WritePhyUshort(sc, 0x14, 0xa101);
20302         MP_WritePhyUshort(sc, 0x14, 0xc020);
20303         MP_WritePhyUshort(sc, 0x14, 0xd710);
20304         MP_WritePhyUshort(sc, 0x14, 0x3121);
20305         MP_WritePhyUshort(sc, 0x14, 0x0d4c);
20306         MP_WritePhyUshort(sc, 0x14, 0x30c0);
20307         MP_WritePhyUshort(sc, 0x14, 0x3d14);
20308         MP_WritePhyUshort(sc, 0x14, 0xd71e);
20309         MP_WritePhyUshort(sc, 0x14, 0x7f4c);
20310         MP_WritePhyUshort(sc, 0x14, 0x2b1e);
20311         MP_WritePhyUshort(sc, 0x14, 0xa540);
20312         MP_WritePhyUshort(sc, 0x14, 0xc001);
20313         MP_WritePhyUshort(sc, 0x14, 0xd710);
20314         MP_WritePhyUshort(sc, 0x14, 0x4001);
20315         MP_WritePhyUshort(sc, 0x14, 0xe00f);
20316         MP_WritePhyUshort(sc, 0x14, 0x0501);
20317         MP_WritePhyUshort(sc, 0x14, 0x1db3);
20318         MP_WritePhyUshort(sc, 0x14, 0xc1c4);
20319         MP_WritePhyUshort(sc, 0x14, 0xa268);
20320         MP_WritePhyUshort(sc, 0x14, 0xa303);
20321         MP_WritePhyUshort(sc, 0x14, 0x8420);
20322         MP_WritePhyUshort(sc, 0x14, 0xe00f);
20323         MP_WritePhyUshort(sc, 0x14, 0x0502);
20324         MP_WritePhyUshort(sc, 0x14, 0x1db3);
20325         MP_WritePhyUshort(sc, 0x14, 0xc002);
20326         MP_WritePhyUshort(sc, 0x14, 0xd710);
20327         MP_WritePhyUshort(sc, 0x14, 0x4000);
20328         MP_WritePhyUshort(sc, 0x14, 0x8208);
20329         MP_WritePhyUshort(sc, 0x14, 0x8410);
20330         MP_WritePhyUshort(sc, 0x14, 0xa121);
20331         MP_WritePhyUshort(sc, 0x14, 0xc002);
20332         MP_WritePhyUshort(sc, 0x14, 0xd710);
20333         MP_WritePhyUshort(sc, 0x14, 0x4000);
20334         MP_WritePhyUshort(sc, 0x14, 0x8120);
20335         MP_WritePhyUshort(sc, 0x14, 0x8180);
20336         MP_WritePhyUshort(sc, 0x14, 0x1d9e);
20337         MP_WritePhyUshort(sc, 0x14, 0xa180);
20338         MP_WritePhyUshort(sc, 0x14, 0xa13a);
20339         MP_WritePhyUshort(sc, 0x14, 0x8240);
20340         MP_WritePhyUshort(sc, 0x14, 0xa430);
20341         MP_WritePhyUshort(sc, 0x14, 0xc010);
20342         MP_WritePhyUshort(sc, 0x14, 0xd710);
20343         MP_WritePhyUshort(sc, 0x14, 0x30e1);
20344         MP_WritePhyUshort(sc, 0x14, 0x0b24);
20345         MP_WritePhyUshort(sc, 0x14, 0xd71e);
20346         MP_WritePhyUshort(sc, 0x14, 0x7f8c);
20347         MP_WritePhyUshort(sc, 0x14, 0x2b1e);
20348         MP_WritePhyUshort(sc, 0x14, 0xa480);
20349         MP_WritePhyUshort(sc, 0x14, 0xa230);
20350         MP_WritePhyUshort(sc, 0x14, 0xa303);
20351         MP_WritePhyUshort(sc, 0x14, 0xc001);
20352         MP_WritePhyUshort(sc, 0x14, 0xd70c);
20353         MP_WritePhyUshort(sc, 0x14, 0x4124);
20354         MP_WritePhyUshort(sc, 0x14, 0xd710);
20355         MP_WritePhyUshort(sc, 0x14, 0x6120);
20356         MP_WritePhyUshort(sc, 0x14, 0xd711);
20357         MP_WritePhyUshort(sc, 0x14, 0x3128);
20358         MP_WritePhyUshort(sc, 0x14, 0x3d7d);
20359         MP_WritePhyUshort(sc, 0x14, 0x2d77);
20360         MP_WritePhyUshort(sc, 0x14, 0xa801);
20361         MP_WritePhyUshort(sc, 0x14, 0x2d73);
20362         MP_WritePhyUshort(sc, 0x14, 0xd710);
20363         MP_WritePhyUshort(sc, 0x14, 0x4000);
20364         MP_WritePhyUshort(sc, 0x14, 0xe018);
20365         MP_WritePhyUshort(sc, 0x14, 0x0208);
20366         MP_WritePhyUshort(sc, 0x14, 0xa1f8);
20367         MP_WritePhyUshort(sc, 0x14, 0x8480);
20368         MP_WritePhyUshort(sc, 0x14, 0xc004);
20369         MP_WritePhyUshort(sc, 0x14, 0xd710);
20370         MP_WritePhyUshort(sc, 0x14, 0x4000);
20371         MP_WritePhyUshort(sc, 0x14, 0x6046);
20372         MP_WritePhyUshort(sc, 0x14, 0x2d14);
20373         MP_WritePhyUshort(sc, 0x14, 0xa43f);
20374         MP_WritePhyUshort(sc, 0x14, 0xa105);
20375         MP_WritePhyUshort(sc, 0x14, 0x8228);
20376         MP_WritePhyUshort(sc, 0x14, 0xc004);
20377         MP_WritePhyUshort(sc, 0x14, 0xd710);
20378         MP_WritePhyUshort(sc, 0x14, 0x4000);
20379         MP_WritePhyUshort(sc, 0x14, 0x81bc);
20380         MP_WritePhyUshort(sc, 0x14, 0xa220);
20381         MP_WritePhyUshort(sc, 0x14, 0x1d9e);
20382         MP_WritePhyUshort(sc, 0x14, 0x8220);
20383         MP_WritePhyUshort(sc, 0x14, 0xa1bc);
20384         MP_WritePhyUshort(sc, 0x14, 0xc040);
20385         MP_WritePhyUshort(sc, 0x14, 0xd710);
20386         MP_WritePhyUshort(sc, 0x14, 0x30e1);
20387         MP_WritePhyUshort(sc, 0x14, 0x0b24);
20388         MP_WritePhyUshort(sc, 0x14, 0x30e1);
20389         MP_WritePhyUshort(sc, 0x14, 0x3d14);
20390         MP_WritePhyUshort(sc, 0x14, 0xd71e);
20391         MP_WritePhyUshort(sc, 0x14, 0x7f4c);
20392         MP_WritePhyUshort(sc, 0x14, 0x2b1e);
20393         MP_WritePhyUshort(sc, 0x14, 0xa802);
20394         MP_WritePhyUshort(sc, 0x14, 0xd70c);
20395         MP_WritePhyUshort(sc, 0x14, 0x4244);
20396         MP_WritePhyUshort(sc, 0x14, 0xa301);
20397         MP_WritePhyUshort(sc, 0x14, 0xc004);
20398         MP_WritePhyUshort(sc, 0x14, 0xd711);
20399         MP_WritePhyUshort(sc, 0x14, 0x3128);
20400         MP_WritePhyUshort(sc, 0x14, 0x3dac);
20401         MP_WritePhyUshort(sc, 0x14, 0xd710);
20402         MP_WritePhyUshort(sc, 0x14, 0x5f80);
20403         MP_WritePhyUshort(sc, 0x14, 0xd711);
20404         MP_WritePhyUshort(sc, 0x14, 0x3109);
20405         MP_WritePhyUshort(sc, 0x14, 0x3dae);
20406         MP_WritePhyUshort(sc, 0x14, 0x2db2);
20407         MP_WritePhyUshort(sc, 0x14, 0xa801);
20408         MP_WritePhyUshort(sc, 0x14, 0x2da1);
20409         MP_WritePhyUshort(sc, 0x14, 0xa802);
20410         MP_WritePhyUshort(sc, 0x14, 0xc004);
20411         MP_WritePhyUshort(sc, 0x14, 0xd710);
20412         MP_WritePhyUshort(sc, 0x14, 0x4000);
20413         MP_WritePhyUshort(sc, 0x14, 0x0800);
20414         MP_WritePhyUshort(sc, 0x14, 0xa510);
20415         MP_WritePhyUshort(sc, 0x14, 0xd710);
20416         MP_WritePhyUshort(sc, 0x14, 0x609a);
20417         MP_WritePhyUshort(sc, 0x14, 0xd71e);
20418         MP_WritePhyUshort(sc, 0x14, 0x7fac);
20419         MP_WritePhyUshort(sc, 0x14, 0x2b1e);
20420         MP_WritePhyUshort(sc, 0x14, 0x8510);
20421         MP_WritePhyUshort(sc, 0x14, 0x0800);
20422         MP_WritePhyUshort(sc, 0x13, 0xa01a);
20423         MP_WritePhyUshort(sc, 0x14, 0x0000);
20424         MP_WritePhyUshort(sc, 0x13, 0xa006);
20425         MP_WritePhyUshort(sc, 0x14, 0x0b3e);
20426         MP_WritePhyUshort(sc, 0x13, 0xa004);
20427         MP_WritePhyUshort(sc, 0x14, 0x0828);
20428         MP_WritePhyUshort(sc, 0x13, 0xa002);
20429         MP_WritePhyUshort(sc, 0x14, 0x06dd);
20430         MP_WritePhyUshort(sc, 0x13, 0xa000);
20431         MP_WritePhyUshort(sc, 0x14, 0xf815);
20432         MP_WritePhyUshort(sc, 0x13, 0xb820);
20433         MP_WritePhyUshort(sc, 0x14, 0x0010);
20434
20435         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
20436         MP_WritePhyUshort(sc, 0x13, 0x83b0);
20437         MP_WritePhyUshort(sc, 0x14, 0xaf83);
20438         MP_WritePhyUshort(sc, 0x14, 0xbcaf);
20439         MP_WritePhyUshort(sc, 0x14, 0x83c8);
20440         MP_WritePhyUshort(sc, 0x14, 0xaf83);
20441         MP_WritePhyUshort(sc, 0x14, 0xddaf);
20442         MP_WritePhyUshort(sc, 0x14, 0x83e0);
20443         MP_WritePhyUshort(sc, 0x14, 0x0204);
20444         MP_WritePhyUshort(sc, 0x14, 0xa102);
20445         MP_WritePhyUshort(sc, 0x14, 0x09b4);
20446         MP_WritePhyUshort(sc, 0x14, 0x0284);
20447         MP_WritePhyUshort(sc, 0x14, 0x62af);
20448         MP_WritePhyUshort(sc, 0x14, 0x02ec);
20449         MP_WritePhyUshort(sc, 0x14, 0xad20);
20450         MP_WritePhyUshort(sc, 0x14, 0x0302);
20451         MP_WritePhyUshort(sc, 0x14, 0x867d);
20452         MP_WritePhyUshort(sc, 0x14, 0xad21);
20453         MP_WritePhyUshort(sc, 0x14, 0x0302);
20454         MP_WritePhyUshort(sc, 0x14, 0x85ca);
20455         MP_WritePhyUshort(sc, 0x14, 0xad22);
20456         MP_WritePhyUshort(sc, 0x14, 0x0302);
20457         MP_WritePhyUshort(sc, 0x14, 0x1bce);
20458         MP_WritePhyUshort(sc, 0x14, 0xaf18);
20459         MP_WritePhyUshort(sc, 0x14, 0x11af);
20460         MP_WritePhyUshort(sc, 0x14, 0x1811);
20461         MP_WritePhyUshort(sc, 0x14, 0x0106);
20462         MP_WritePhyUshort(sc, 0x14, 0xe081);
20463         MP_WritePhyUshort(sc, 0x14, 0x48af);
20464         MP_WritePhyUshort(sc, 0x14, 0x3b1f);
20465         MP_WritePhyUshort(sc, 0x14, 0xf8f9);
20466         MP_WritePhyUshort(sc, 0x14, 0xfaef);
20467         MP_WritePhyUshort(sc, 0x14, 0x69ee);
20468         MP_WritePhyUshort(sc, 0x14, 0x8010);
20469         MP_WritePhyUshort(sc, 0x14, 0xf7d1);
20470         MP_WritePhyUshort(sc, 0x14, 0x04bf);
20471         MP_WritePhyUshort(sc, 0x14, 0x8776);
20472         MP_WritePhyUshort(sc, 0x14, 0x0241);
20473         MP_WritePhyUshort(sc, 0x14, 0x0a02);
20474         MP_WritePhyUshort(sc, 0x14, 0x8704);
20475         MP_WritePhyUshort(sc, 0x14, 0xbf87);
20476         MP_WritePhyUshort(sc, 0x14, 0x4fd7);
20477         MP_WritePhyUshort(sc, 0x14, 0xb822);
20478         MP_WritePhyUshort(sc, 0x14, 0xd00c);
20479         MP_WritePhyUshort(sc, 0x14, 0x0241);
20480         MP_WritePhyUshort(sc, 0x14, 0x03ee);
20481         MP_WritePhyUshort(sc, 0x14, 0x80cd);
20482         MP_WritePhyUshort(sc, 0x14, 0xa0ee);
20483         MP_WritePhyUshort(sc, 0x14, 0x80ce);
20484         MP_WritePhyUshort(sc, 0x14, 0x8bee);
20485         MP_WritePhyUshort(sc, 0x14, 0x80d1);
20486         MP_WritePhyUshort(sc, 0x14, 0xf5ee);
20487         MP_WritePhyUshort(sc, 0x14, 0x80d2);
20488         MP_WritePhyUshort(sc, 0x14, 0xa9ee);
20489         MP_WritePhyUshort(sc, 0x14, 0x80d3);
20490         MP_WritePhyUshort(sc, 0x14, 0x0aee);
20491         MP_WritePhyUshort(sc, 0x14, 0x80f0);
20492         MP_WritePhyUshort(sc, 0x14, 0x10ee);
20493         MP_WritePhyUshort(sc, 0x14, 0x80f3);
20494         MP_WritePhyUshort(sc, 0x14, 0x8fee);
20495         MP_WritePhyUshort(sc, 0x14, 0x8101);
20496         MP_WritePhyUshort(sc, 0x14, 0x1eee);
20497         MP_WritePhyUshort(sc, 0x14, 0x810b);
20498         MP_WritePhyUshort(sc, 0x14, 0x4aee);
20499         MP_WritePhyUshort(sc, 0x14, 0x810c);
20500         MP_WritePhyUshort(sc, 0x14, 0x7cee);
20501         MP_WritePhyUshort(sc, 0x14, 0x8112);
20502         MP_WritePhyUshort(sc, 0x14, 0x7fd1);
20503         MP_WritePhyUshort(sc, 0x14, 0x0002);
20504         MP_WritePhyUshort(sc, 0x14, 0x10e3);
20505         MP_WritePhyUshort(sc, 0x14, 0xee80);
20506         MP_WritePhyUshort(sc, 0x14, 0x8892);
20507         MP_WritePhyUshort(sc, 0x14, 0xee80);
20508         MP_WritePhyUshort(sc, 0x14, 0x8922);
20509         MP_WritePhyUshort(sc, 0x14, 0xee80);
20510         MP_WritePhyUshort(sc, 0x14, 0x9a80);
20511         MP_WritePhyUshort(sc, 0x14, 0xee80);
20512         MP_WritePhyUshort(sc, 0x14, 0x9b22);
20513         MP_WritePhyUshort(sc, 0x14, 0xee80);
20514         MP_WritePhyUshort(sc, 0x14, 0x9ca7);
20515         MP_WritePhyUshort(sc, 0x14, 0xee80);
20516         MP_WritePhyUshort(sc, 0x14, 0xa010);
20517         MP_WritePhyUshort(sc, 0x14, 0xee80);
20518         MP_WritePhyUshort(sc, 0x14, 0xa5a7);
20519         MP_WritePhyUshort(sc, 0x14, 0xd200);
20520         MP_WritePhyUshort(sc, 0x14, 0x020e);
20521         MP_WritePhyUshort(sc, 0x14, 0x4b02);
20522         MP_WritePhyUshort(sc, 0x14, 0x85c1);
20523         MP_WritePhyUshort(sc, 0x14, 0xef96);
20524         MP_WritePhyUshort(sc, 0x14, 0xfefd);
20525         MP_WritePhyUshort(sc, 0x14, 0xfc04);
20526         MP_WritePhyUshort(sc, 0x14, 0x0284);
20527         MP_WritePhyUshort(sc, 0x14, 0x7b02);
20528         MP_WritePhyUshort(sc, 0x14, 0x84b4);
20529         MP_WritePhyUshort(sc, 0x14, 0x020c);
20530         MP_WritePhyUshort(sc, 0x14, 0x9202);
20531         MP_WritePhyUshort(sc, 0x14, 0x0cab);
20532         MP_WritePhyUshort(sc, 0x14, 0x020c);
20533         MP_WritePhyUshort(sc, 0x14, 0xd602);
20534         MP_WritePhyUshort(sc, 0x14, 0x0cef);
20535         MP_WritePhyUshort(sc, 0x14, 0x020d);
20536         MP_WritePhyUshort(sc, 0x14, 0x1a02);
20537         MP_WritePhyUshort(sc, 0x14, 0x0c24);
20538         MP_WritePhyUshort(sc, 0x14, 0x04f8);
20539         MP_WritePhyUshort(sc, 0x14, 0xfaef);
20540         MP_WritePhyUshort(sc, 0x14, 0x69e1);
20541         MP_WritePhyUshort(sc, 0x14, 0x8234);
20542         MP_WritePhyUshort(sc, 0x14, 0xac29);
20543         MP_WritePhyUshort(sc, 0x14, 0x1ae0);
20544         MP_WritePhyUshort(sc, 0x14, 0x8229);
20545         MP_WritePhyUshort(sc, 0x14, 0xac21);
20546         MP_WritePhyUshort(sc, 0x14, 0x02ae);
20547         MP_WritePhyUshort(sc, 0x14, 0x2202);
20548         MP_WritePhyUshort(sc, 0x14, 0x1085);
20549         MP_WritePhyUshort(sc, 0x14, 0xf621);
20550         MP_WritePhyUshort(sc, 0x14, 0xe482);
20551         MP_WritePhyUshort(sc, 0x14, 0x29d1);
20552         MP_WritePhyUshort(sc, 0x14, 0x01bf);
20553         MP_WritePhyUshort(sc, 0x14, 0x4364);
20554         MP_WritePhyUshort(sc, 0x14, 0x0241);
20555         MP_WritePhyUshort(sc, 0x14, 0x0aae);
20556         MP_WritePhyUshort(sc, 0x14, 0x1002);
20557         MP_WritePhyUshort(sc, 0x14, 0x127a);
20558         MP_WritePhyUshort(sc, 0x14, 0xf629);
20559         MP_WritePhyUshort(sc, 0x14, 0xe582);
20560         MP_WritePhyUshort(sc, 0x14, 0x34e0);
20561         MP_WritePhyUshort(sc, 0x14, 0x8229);
20562         MP_WritePhyUshort(sc, 0x14, 0xf621);
20563         MP_WritePhyUshort(sc, 0x14, 0xe482);
20564         MP_WritePhyUshort(sc, 0x14, 0x29ef);
20565         MP_WritePhyUshort(sc, 0x14, 0x96fe);
20566         MP_WritePhyUshort(sc, 0x14, 0xfc04);
20567         MP_WritePhyUshort(sc, 0x14, 0xf8e1);
20568         MP_WritePhyUshort(sc, 0x14, 0x8234);
20569         MP_WritePhyUshort(sc, 0x14, 0xac2a);
20570         MP_WritePhyUshort(sc, 0x14, 0x18e0);
20571         MP_WritePhyUshort(sc, 0x14, 0x8229);
20572         MP_WritePhyUshort(sc, 0x14, 0xac22);
20573         MP_WritePhyUshort(sc, 0x14, 0x02ae);
20574         MP_WritePhyUshort(sc, 0x14, 0x2602);
20575         MP_WritePhyUshort(sc, 0x14, 0x84f9);
20576         MP_WritePhyUshort(sc, 0x14, 0x0285);
20577         MP_WritePhyUshort(sc, 0x14, 0x66d1);
20578         MP_WritePhyUshort(sc, 0x14, 0x01bf);
20579         MP_WritePhyUshort(sc, 0x14, 0x4367);
20580         MP_WritePhyUshort(sc, 0x14, 0x0241);
20581         MP_WritePhyUshort(sc, 0x14, 0x0aae);
20582         MP_WritePhyUshort(sc, 0x14, 0x0e02);
20583         MP_WritePhyUshort(sc, 0x14, 0x84eb);
20584         MP_WritePhyUshort(sc, 0x14, 0x0285);
20585         MP_WritePhyUshort(sc, 0x14, 0xaae1);
20586         MP_WritePhyUshort(sc, 0x14, 0x8234);
20587         MP_WritePhyUshort(sc, 0x14, 0xf62a);
20588         MP_WritePhyUshort(sc, 0x14, 0xe582);
20589         MP_WritePhyUshort(sc, 0x14, 0x34e0);
20590         MP_WritePhyUshort(sc, 0x14, 0x8229);
20591         MP_WritePhyUshort(sc, 0x14, 0xf622);
20592         MP_WritePhyUshort(sc, 0x14, 0xe482);
20593         MP_WritePhyUshort(sc, 0x14, 0x29fc);
20594         MP_WritePhyUshort(sc, 0x14, 0x04f9);
20595         MP_WritePhyUshort(sc, 0x14, 0xe280);
20596         MP_WritePhyUshort(sc, 0x14, 0x11ad);
20597         MP_WritePhyUshort(sc, 0x14, 0x3105);
20598         MP_WritePhyUshort(sc, 0x14, 0xd200);
20599         MP_WritePhyUshort(sc, 0x14, 0x020e);
20600         MP_WritePhyUshort(sc, 0x14, 0x4bfd);
20601         MP_WritePhyUshort(sc, 0x14, 0x04f8);
20602         MP_WritePhyUshort(sc, 0x14, 0xf9fa);
20603         MP_WritePhyUshort(sc, 0x14, 0xef69);
20604         MP_WritePhyUshort(sc, 0x14, 0xe080);
20605         MP_WritePhyUshort(sc, 0x14, 0x11ad);
20606         MP_WritePhyUshort(sc, 0x14, 0x215c);
20607         MP_WritePhyUshort(sc, 0x14, 0xbf42);
20608         MP_WritePhyUshort(sc, 0x14, 0x5002);
20609         MP_WritePhyUshort(sc, 0x14, 0x4148);
20610         MP_WritePhyUshort(sc, 0x14, 0xac28);
20611         MP_WritePhyUshort(sc, 0x14, 0x1bbf);
20612         MP_WritePhyUshort(sc, 0x14, 0x4253);
20613         MP_WritePhyUshort(sc, 0x14, 0x0241);
20614         MP_WritePhyUshort(sc, 0x14, 0x48ac);
20615         MP_WritePhyUshort(sc, 0x14, 0x2812);
20616         MP_WritePhyUshort(sc, 0x14, 0xbf42);
20617         MP_WritePhyUshort(sc, 0x14, 0x5902);
20618         MP_WritePhyUshort(sc, 0x14, 0x4148);
20619         MP_WritePhyUshort(sc, 0x14, 0xac28);
20620         MP_WritePhyUshort(sc, 0x14, 0x04d3);
20621         MP_WritePhyUshort(sc, 0x14, 0x00ae);
20622         MP_WritePhyUshort(sc, 0x14, 0x07d3);
20623         MP_WritePhyUshort(sc, 0x14, 0x06af);
20624         MP_WritePhyUshort(sc, 0x14, 0x8557);
20625         MP_WritePhyUshort(sc, 0x14, 0xd303);
20626         MP_WritePhyUshort(sc, 0x14, 0xe080);
20627         MP_WritePhyUshort(sc, 0x14, 0x11ad);
20628         MP_WritePhyUshort(sc, 0x14, 0x2625);
20629         MP_WritePhyUshort(sc, 0x14, 0xbf43);
20630         MP_WritePhyUshort(sc, 0x14, 0xeb02);
20631         MP_WritePhyUshort(sc, 0x14, 0x4148);
20632         MP_WritePhyUshort(sc, 0x14, 0xe280);
20633         MP_WritePhyUshort(sc, 0x14, 0x730d);
20634         MP_WritePhyUshort(sc, 0x14, 0x21f6);
20635         MP_WritePhyUshort(sc, 0x14, 0x370d);
20636         MP_WritePhyUshort(sc, 0x14, 0x11f6);
20637         MP_WritePhyUshort(sc, 0x14, 0x2f1b);
20638         MP_WritePhyUshort(sc, 0x14, 0x21aa);
20639         MP_WritePhyUshort(sc, 0x14, 0x02ae);
20640         MP_WritePhyUshort(sc, 0x14, 0x10e2);
20641         MP_WritePhyUshort(sc, 0x14, 0x8074);
20642         MP_WritePhyUshort(sc, 0x14, 0x0d21);
20643         MP_WritePhyUshort(sc, 0x14, 0xf637);
20644         MP_WritePhyUshort(sc, 0x14, 0x1b21);
20645         MP_WritePhyUshort(sc, 0x14, 0xaa03);
20646         MP_WritePhyUshort(sc, 0x14, 0x13ae);
20647         MP_WritePhyUshort(sc, 0x14, 0x022b);
20648         MP_WritePhyUshort(sc, 0x14, 0x0202);
20649         MP_WritePhyUshort(sc, 0x14, 0x0e36);
20650         MP_WritePhyUshort(sc, 0x14, 0x020e);
20651         MP_WritePhyUshort(sc, 0x14, 0x4b02);
20652         MP_WritePhyUshort(sc, 0x14, 0x0f91);
20653         MP_WritePhyUshort(sc, 0x14, 0xef96);
20654         MP_WritePhyUshort(sc, 0x14, 0xfefd);
20655         MP_WritePhyUshort(sc, 0x14, 0xfc04);
20656         MP_WritePhyUshort(sc, 0x14, 0xf8f9);
20657         MP_WritePhyUshort(sc, 0x14, 0xfaef);
20658         MP_WritePhyUshort(sc, 0x14, 0x69e0);
20659         MP_WritePhyUshort(sc, 0x14, 0x8012);
20660         MP_WritePhyUshort(sc, 0x14, 0xad27);
20661         MP_WritePhyUshort(sc, 0x14, 0x33bf);
20662         MP_WritePhyUshort(sc, 0x14, 0x4250);
20663         MP_WritePhyUshort(sc, 0x14, 0x0241);
20664         MP_WritePhyUshort(sc, 0x14, 0x48ac);
20665         MP_WritePhyUshort(sc, 0x14, 0x2809);
20666         MP_WritePhyUshort(sc, 0x14, 0xbf42);
20667         MP_WritePhyUshort(sc, 0x14, 0x5302);
20668         MP_WritePhyUshort(sc, 0x14, 0x4148);
20669         MP_WritePhyUshort(sc, 0x14, 0xad28);
20670         MP_WritePhyUshort(sc, 0x14, 0x21bf);
20671         MP_WritePhyUshort(sc, 0x14, 0x43eb);
20672         MP_WritePhyUshort(sc, 0x14, 0x0241);
20673         MP_WritePhyUshort(sc, 0x14, 0x48e3);
20674         MP_WritePhyUshort(sc, 0x14, 0x87ff);
20675         MP_WritePhyUshort(sc, 0x14, 0xd200);
20676         MP_WritePhyUshort(sc, 0x14, 0x1b45);
20677         MP_WritePhyUshort(sc, 0x14, 0xac27);
20678         MP_WritePhyUshort(sc, 0x14, 0x11e1);
20679         MP_WritePhyUshort(sc, 0x14, 0x87fe);
20680         MP_WritePhyUshort(sc, 0x14, 0xbf87);
20681         MP_WritePhyUshort(sc, 0x14, 0x6702);
20682         MP_WritePhyUshort(sc, 0x14, 0x410a);
20683         MP_WritePhyUshort(sc, 0x14, 0x0d11);
20684         MP_WritePhyUshort(sc, 0x14, 0xbf87);
20685         MP_WritePhyUshort(sc, 0x14, 0x6a02);
20686         MP_WritePhyUshort(sc, 0x14, 0x410a);
20687         MP_WritePhyUshort(sc, 0x14, 0xef96);
20688         MP_WritePhyUshort(sc, 0x14, 0xfefd);
20689         MP_WritePhyUshort(sc, 0x14, 0xfc04);
20690         MP_WritePhyUshort(sc, 0x14, 0xf8fa);
20691         MP_WritePhyUshort(sc, 0x14, 0xef69);
20692         MP_WritePhyUshort(sc, 0x14, 0xd100);
20693         MP_WritePhyUshort(sc, 0x14, 0xbf87);
20694         MP_WritePhyUshort(sc, 0x14, 0x6702);
20695         MP_WritePhyUshort(sc, 0x14, 0x410a);
20696         MP_WritePhyUshort(sc, 0x14, 0xbf87);
20697         MP_WritePhyUshort(sc, 0x14, 0x6a02);
20698         MP_WritePhyUshort(sc, 0x14, 0x410a);
20699         MP_WritePhyUshort(sc, 0x14, 0xef96);
20700         MP_WritePhyUshort(sc, 0x14, 0xfefc);
20701         MP_WritePhyUshort(sc, 0x14, 0x04ee);
20702         MP_WritePhyUshort(sc, 0x14, 0x87ff);
20703         MP_WritePhyUshort(sc, 0x14, 0x46ee);
20704         MP_WritePhyUshort(sc, 0x14, 0x87fe);
20705         MP_WritePhyUshort(sc, 0x14, 0x0104);
20706         MP_WritePhyUshort(sc, 0x14, 0xf8fa);
20707         MP_WritePhyUshort(sc, 0x14, 0xef69);
20708         MP_WritePhyUshort(sc, 0x14, 0xe082);
20709         MP_WritePhyUshort(sc, 0x14, 0x46a0);
20710         MP_WritePhyUshort(sc, 0x14, 0x0005);
20711         MP_WritePhyUshort(sc, 0x14, 0x0285);
20712         MP_WritePhyUshort(sc, 0x14, 0xecae);
20713         MP_WritePhyUshort(sc, 0x14, 0x0ea0);
20714         MP_WritePhyUshort(sc, 0x14, 0x0105);
20715         MP_WritePhyUshort(sc, 0x14, 0x021a);
20716         MP_WritePhyUshort(sc, 0x14, 0x68ae);
20717         MP_WritePhyUshort(sc, 0x14, 0x06a0);
20718         MP_WritePhyUshort(sc, 0x14, 0x0203);
20719         MP_WritePhyUshort(sc, 0x14, 0x021a);
20720         MP_WritePhyUshort(sc, 0x14, 0xf4ef);
20721         MP_WritePhyUshort(sc, 0x14, 0x96fe);
20722         MP_WritePhyUshort(sc, 0x14, 0xfc04);
20723         MP_WritePhyUshort(sc, 0x14, 0xf8f9);
20724         MP_WritePhyUshort(sc, 0x14, 0xfaef);
20725         MP_WritePhyUshort(sc, 0x14, 0x69e0);
20726         MP_WritePhyUshort(sc, 0x14, 0x822e);
20727         MP_WritePhyUshort(sc, 0x14, 0xf621);
20728         MP_WritePhyUshort(sc, 0x14, 0xe482);
20729         MP_WritePhyUshort(sc, 0x14, 0x2ee0);
20730         MP_WritePhyUshort(sc, 0x14, 0x8010);
20731         MP_WritePhyUshort(sc, 0x14, 0xac22);
20732         MP_WritePhyUshort(sc, 0x14, 0x02ae);
20733         MP_WritePhyUshort(sc, 0x14, 0x76e0);
20734         MP_WritePhyUshort(sc, 0x14, 0x822c);
20735         MP_WritePhyUshort(sc, 0x14, 0xf721);
20736         MP_WritePhyUshort(sc, 0x14, 0xe482);
20737         MP_WritePhyUshort(sc, 0x14, 0x2cbf);
20738         MP_WritePhyUshort(sc, 0x14, 0x41a5);
20739         MP_WritePhyUshort(sc, 0x14, 0x0241);
20740         MP_WritePhyUshort(sc, 0x14, 0x48ef);
20741         MP_WritePhyUshort(sc, 0x14, 0x21bf);
20742         MP_WritePhyUshort(sc, 0x14, 0x41a8);
20743         MP_WritePhyUshort(sc, 0x14, 0x0241);
20744         MP_WritePhyUshort(sc, 0x14, 0x480c);
20745         MP_WritePhyUshort(sc, 0x14, 0x111e);
20746         MP_WritePhyUshort(sc, 0x14, 0x21bf);
20747         MP_WritePhyUshort(sc, 0x14, 0x41ab);
20748         MP_WritePhyUshort(sc, 0x14, 0x0241);
20749         MP_WritePhyUshort(sc, 0x14, 0x480c);
20750         MP_WritePhyUshort(sc, 0x14, 0x121e);
20751         MP_WritePhyUshort(sc, 0x14, 0x21e6);
20752         MP_WritePhyUshort(sc, 0x14, 0x8248);
20753         MP_WritePhyUshort(sc, 0x14, 0xa200);
20754         MP_WritePhyUshort(sc, 0x14, 0x0ae1);
20755         MP_WritePhyUshort(sc, 0x14, 0x822c);
20756         MP_WritePhyUshort(sc, 0x14, 0xf629);
20757         MP_WritePhyUshort(sc, 0x14, 0xe582);
20758         MP_WritePhyUshort(sc, 0x14, 0x2cae);
20759         MP_WritePhyUshort(sc, 0x14, 0x42e0);
20760         MP_WritePhyUshort(sc, 0x14, 0x8249);
20761         MP_WritePhyUshort(sc, 0x14, 0xf721);
20762         MP_WritePhyUshort(sc, 0x14, 0xe482);
20763         MP_WritePhyUshort(sc, 0x14, 0x4902);
20764         MP_WritePhyUshort(sc, 0x14, 0x4520);
20765         MP_WritePhyUshort(sc, 0x14, 0xbf41);
20766         MP_WritePhyUshort(sc, 0x14, 0xb702);
20767         MP_WritePhyUshort(sc, 0x14, 0x4148);
20768         MP_WritePhyUshort(sc, 0x14, 0xef21);
20769         MP_WritePhyUshort(sc, 0x14, 0xbf41);
20770         MP_WritePhyUshort(sc, 0x14, 0xae02);
20771         MP_WritePhyUshort(sc, 0x14, 0x4148);
20772         MP_WritePhyUshort(sc, 0x14, 0x0c12);
20773         MP_WritePhyUshort(sc, 0x14, 0x1e21);
20774         MP_WritePhyUshort(sc, 0x14, 0xbf41);
20775         MP_WritePhyUshort(sc, 0x14, 0xb102);
20776         MP_WritePhyUshort(sc, 0x14, 0x4148);
20777         MP_WritePhyUshort(sc, 0x14, 0x0c13);
20778         MP_WritePhyUshort(sc, 0x14, 0x1e21);
20779         MP_WritePhyUshort(sc, 0x14, 0xbf41);
20780         MP_WritePhyUshort(sc, 0x14, 0xba02);
20781         MP_WritePhyUshort(sc, 0x14, 0x4148);
20782         MP_WritePhyUshort(sc, 0x14, 0x0c14);
20783         MP_WritePhyUshort(sc, 0x14, 0x1e21);
20784         MP_WritePhyUshort(sc, 0x14, 0xbf43);
20785         MP_WritePhyUshort(sc, 0x14, 0x4602);
20786         MP_WritePhyUshort(sc, 0x14, 0x4148);
20787         MP_WritePhyUshort(sc, 0x14, 0x0c16);
20788         MP_WritePhyUshort(sc, 0x14, 0x1e21);
20789         MP_WritePhyUshort(sc, 0x14, 0xe682);
20790         MP_WritePhyUshort(sc, 0x14, 0x47ee);
20791         MP_WritePhyUshort(sc, 0x14, 0x8246);
20792         MP_WritePhyUshort(sc, 0x14, 0x01ef);
20793         MP_WritePhyUshort(sc, 0x14, 0x96fe);
20794         MP_WritePhyUshort(sc, 0x14, 0xfdfc);
20795         MP_WritePhyUshort(sc, 0x14, 0x04f8);
20796         MP_WritePhyUshort(sc, 0x14, 0xfaef);
20797         MP_WritePhyUshort(sc, 0x14, 0x69e0);
20798         MP_WritePhyUshort(sc, 0x14, 0x824b);
20799         MP_WritePhyUshort(sc, 0x14, 0xa000);
20800         MP_WritePhyUshort(sc, 0x14, 0x0502);
20801         MP_WritePhyUshort(sc, 0x14, 0x8697);
20802         MP_WritePhyUshort(sc, 0x14, 0xae06);
20803         MP_WritePhyUshort(sc, 0x14, 0xa001);
20804         MP_WritePhyUshort(sc, 0x14, 0x0302);
20805         MP_WritePhyUshort(sc, 0x14, 0x1937);
20806         MP_WritePhyUshort(sc, 0x14, 0xef96);
20807         MP_WritePhyUshort(sc, 0x14, 0xfefc);
20808         MP_WritePhyUshort(sc, 0x14, 0x04f8);
20809         MP_WritePhyUshort(sc, 0x14, 0xfaef);
20810         MP_WritePhyUshort(sc, 0x14, 0x69e0);
20811         MP_WritePhyUshort(sc, 0x14, 0x822e);
20812         MP_WritePhyUshort(sc, 0x14, 0xf620);
20813         MP_WritePhyUshort(sc, 0x14, 0xe482);
20814         MP_WritePhyUshort(sc, 0x14, 0x2ee0);
20815         MP_WritePhyUshort(sc, 0x14, 0x8010);
20816         MP_WritePhyUshort(sc, 0x14, 0xac21);
20817         MP_WritePhyUshort(sc, 0x14, 0x02ae);
20818         MP_WritePhyUshort(sc, 0x14, 0x54e0);
20819         MP_WritePhyUshort(sc, 0x14, 0x822c);
20820         MP_WritePhyUshort(sc, 0x14, 0xf720);
20821         MP_WritePhyUshort(sc, 0x14, 0xe482);
20822         MP_WritePhyUshort(sc, 0x14, 0x2cbf);
20823         MP_WritePhyUshort(sc, 0x14, 0x4175);
20824         MP_WritePhyUshort(sc, 0x14, 0x0241);
20825         MP_WritePhyUshort(sc, 0x14, 0x48ac);
20826         MP_WritePhyUshort(sc, 0x14, 0x2822);
20827         MP_WritePhyUshort(sc, 0x14, 0xbf41);
20828         MP_WritePhyUshort(sc, 0x14, 0x9f02);
20829         MP_WritePhyUshort(sc, 0x14, 0x4148);
20830         MP_WritePhyUshort(sc, 0x14, 0xe582);
20831         MP_WritePhyUshort(sc, 0x14, 0x4cac);
20832         MP_WritePhyUshort(sc, 0x14, 0x2820);
20833         MP_WritePhyUshort(sc, 0x14, 0xd103);
20834         MP_WritePhyUshort(sc, 0x14, 0xbf41);
20835         MP_WritePhyUshort(sc, 0x14, 0x9902);
20836         MP_WritePhyUshort(sc, 0x14, 0x410a);
20837         MP_WritePhyUshort(sc, 0x14, 0xee82);
20838         MP_WritePhyUshort(sc, 0x14, 0x4b00);
20839         MP_WritePhyUshort(sc, 0x14, 0xe182);
20840         MP_WritePhyUshort(sc, 0x14, 0x2cf6);
20841         MP_WritePhyUshort(sc, 0x14, 0x28e5);
20842         MP_WritePhyUshort(sc, 0x14, 0x822c);
20843         MP_WritePhyUshort(sc, 0x14, 0xae21);
20844         MP_WritePhyUshort(sc, 0x14, 0xd104);
20845         MP_WritePhyUshort(sc, 0x14, 0xbf41);
20846         MP_WritePhyUshort(sc, 0x14, 0x9902);
20847         MP_WritePhyUshort(sc, 0x14, 0x410a);
20848         MP_WritePhyUshort(sc, 0x14, 0xae08);
20849         MP_WritePhyUshort(sc, 0x14, 0xd105);
20850         MP_WritePhyUshort(sc, 0x14, 0xbf41);
20851         MP_WritePhyUshort(sc, 0x14, 0x9902);
20852         MP_WritePhyUshort(sc, 0x14, 0x410a);
20853         MP_WritePhyUshort(sc, 0x14, 0xe082);
20854         MP_WritePhyUshort(sc, 0x14, 0x49f7);
20855         MP_WritePhyUshort(sc, 0x14, 0x20e4);
20856         MP_WritePhyUshort(sc, 0x14, 0x8249);
20857         MP_WritePhyUshort(sc, 0x14, 0x0245);
20858         MP_WritePhyUshort(sc, 0x14, 0x20ee);
20859         MP_WritePhyUshort(sc, 0x14, 0x824b);
20860         MP_WritePhyUshort(sc, 0x14, 0x01ef);
20861         MP_WritePhyUshort(sc, 0x14, 0x96fe);
20862         MP_WritePhyUshort(sc, 0x14, 0xfc04);
20863         MP_WritePhyUshort(sc, 0x14, 0xf8f9);
20864         MP_WritePhyUshort(sc, 0x14, 0xface);
20865         MP_WritePhyUshort(sc, 0x14, 0xfaef);
20866         MP_WritePhyUshort(sc, 0x14, 0x69fb);
20867         MP_WritePhyUshort(sc, 0x14, 0xbf87);
20868         MP_WritePhyUshort(sc, 0x14, 0x2fd7);
20869         MP_WritePhyUshort(sc, 0x14, 0x0020);
20870         MP_WritePhyUshort(sc, 0x14, 0xd819);
20871         MP_WritePhyUshort(sc, 0x14, 0xd919);
20872         MP_WritePhyUshort(sc, 0x14, 0xda19);
20873         MP_WritePhyUshort(sc, 0x14, 0xdb19);
20874         MP_WritePhyUshort(sc, 0x14, 0x07ef);
20875         MP_WritePhyUshort(sc, 0x14, 0x9502);
20876         MP_WritePhyUshort(sc, 0x14, 0x410a);
20877         MP_WritePhyUshort(sc, 0x14, 0x073f);
20878         MP_WritePhyUshort(sc, 0x14, 0x0004);
20879         MP_WritePhyUshort(sc, 0x14, 0x9fec);
20880         MP_WritePhyUshort(sc, 0x14, 0xffef);
20881         MP_WritePhyUshort(sc, 0x14, 0x96fe);
20882         MP_WritePhyUshort(sc, 0x14, 0xc6fe);
20883         MP_WritePhyUshort(sc, 0x14, 0xfdfc);
20884         MP_WritePhyUshort(sc, 0x14, 0x0400);
20885         MP_WritePhyUshort(sc, 0x14, 0x0144);
20886         MP_WritePhyUshort(sc, 0x14, 0x0000);
20887         MP_WritePhyUshort(sc, 0x14, 0x0343);
20888         MP_WritePhyUshort(sc, 0x14, 0xee00);
20889         MP_WritePhyUshort(sc, 0x14, 0x0087);
20890         MP_WritePhyUshort(sc, 0x14, 0x5b00);
20891         MP_WritePhyUshort(sc, 0x14, 0x0141);
20892         MP_WritePhyUshort(sc, 0x14, 0xe100);
20893         MP_WritePhyUshort(sc, 0x14, 0x0387);
20894         MP_WritePhyUshort(sc, 0x14, 0x5e00);
20895         MP_WritePhyUshort(sc, 0x14, 0x0987);
20896         MP_WritePhyUshort(sc, 0x14, 0x6100);
20897         MP_WritePhyUshort(sc, 0x14, 0x0987);
20898         MP_WritePhyUshort(sc, 0x14, 0x6400);
20899         MP_WritePhyUshort(sc, 0x14, 0x0087);
20900         MP_WritePhyUshort(sc, 0x14, 0x6da4);
20901         MP_WritePhyUshort(sc, 0x14, 0x00b8);
20902         MP_WritePhyUshort(sc, 0x14, 0x20c4);
20903         MP_WritePhyUshort(sc, 0x14, 0x1600);
20904         MP_WritePhyUshort(sc, 0x14, 0x000f);
20905         MP_WritePhyUshort(sc, 0x14, 0xf800);
20906         MP_WritePhyUshort(sc, 0x14, 0x7000);
20907         MP_WritePhyUshort(sc, 0x14, 0xb82e);
20908         MP_WritePhyUshort(sc, 0x14, 0x98a5);
20909         MP_WritePhyUshort(sc, 0x14, 0x8ab6);
20910         MP_WritePhyUshort(sc, 0x14, 0xa83e);
20911         MP_WritePhyUshort(sc, 0x14, 0x50a8);
20912         MP_WritePhyUshort(sc, 0x14, 0x3e33);
20913         MP_WritePhyUshort(sc, 0x14, 0xbcc6);
20914         MP_WritePhyUshort(sc, 0x14, 0x22bc);
20915         MP_WritePhyUshort(sc, 0x14, 0xc6aa);
20916         MP_WritePhyUshort(sc, 0x14, 0xa442);
20917         MP_WritePhyUshort(sc, 0x14, 0xffc4);
20918         MP_WritePhyUshort(sc, 0x14, 0x0800);
20919         MP_WritePhyUshort(sc, 0x14, 0xc416);
20920         MP_WritePhyUshort(sc, 0x14, 0xa8bc);
20921         MP_WritePhyUshort(sc, 0x14, 0xc000);
20922         MP_WritePhyUshort(sc, 0x13, 0xb818);
20923         MP_WritePhyUshort(sc, 0x14, 0x02e3);
20924         MP_WritePhyUshort(sc, 0x13, 0xb81a);
20925         MP_WritePhyUshort(sc, 0x14, 0x17ff);
20926         MP_WritePhyUshort(sc, 0x13, 0xb81e);
20927         MP_WritePhyUshort(sc, 0x14, 0x3b1c);
20928         MP_WritePhyUshort(sc, 0x13, 0xb820);
20929         MP_WritePhyUshort(sc, 0x14, 0x021b);
20930         MP_WritePhyUshort(sc, 0x1f, 0x0000);
20931
20932         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
20933         MP_WritePhyUshort(sc, 0x13, 0x0000);
20934         MP_WritePhyUshort(sc, 0x14, 0x0000);
20935         MP_WritePhyUshort(sc, 0x1f, 0x0B82);
20936         PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
20937         PhyRegValue &= ~(BIT_0);
20938         MP_WritePhyUshort(sc, 0x17, PhyRegValue);
20939         if (sc->RequiredSecLanDonglePatch)
20940                 PhyRegValue &= ~(BIT_2);
20941         MP_WritePhyUshort(sc,0x1f, 0x0000);
20942
20943         MP_WritePhyUshort(sc, 0x1F, 0x0003);
20944         MP_WritePhyUshort(sc, 0x09, 0xA20F);
20945         MP_WritePhyUshort(sc, 0x1F, 0x0000);
20946         MP_WritePhyUshort(sc, 0x1F, 0x0003);
20947         MP_WritePhyUshort(sc, 0x01, 0x328A);
20948         MP_WritePhyUshort(sc, 0x1F, 0x0000);
20949         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
20950         MP_WritePhyUshort(sc, 0x13, 0x8011);
20951         ClearEthPhyBit(sc, 0x14, BIT_14);
20952         MP_WritePhyUshort(sc, 0x1F, 0x0A40);
20953         MP_WritePhyUshort(sc, 0x1F, 0x0000);
20954         MP_WritePhyUshort(sc,0x1f, 0x0000);
20955         MP_WritePhyUshort(sc,0x00, 0x9200);
20956 }
20957
20958 static void re_set_phy_mcu_8168ep_2(struct re_softc *sc)
20959 {
20960         u_int16_t PhyRegValue;
20961         u_int32_t WaitCnt;
20962
20963         MP_WritePhyUshort(sc,0x1f, 0x0B82);
20964         PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
20965         PhyRegValue |= BIT_4;
20966         MP_WritePhyUshort(sc,0x10, PhyRegValue);
20967
20968         MP_WritePhyUshort(sc,0x1f, 0x0B80);
20969         WaitCnt = 0;
20970         do {
20971                 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
20972                 PhyRegValue &= 0x0040;
20973                 DELAY(50);
20974                 DELAY(50);
20975                 WaitCnt++;
20976         } while(PhyRegValue != 0x0040 && WaitCnt <1000);
20977
20978         MP_WritePhyUshort(sc,0x1f, 0x0A43);
20979         MP_WritePhyUshort(sc,0x13, 0x8146);
20980         MP_WritePhyUshort(sc,0x14, 0x8700);
20981         MP_WritePhyUshort(sc,0x13, 0xB82E);
20982         MP_WritePhyUshort(sc,0x14, 0x0001);
20983
20984         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
20985
20986         MP_WritePhyUshort(sc, 0x13, 0x83DD);
20987         MP_WritePhyUshort(sc, 0x14, 0xAF83);
20988         MP_WritePhyUshort(sc, 0x14, 0xE9AF);
20989         MP_WritePhyUshort(sc, 0x14, 0x83EE);
20990         MP_WritePhyUshort(sc, 0x14, 0xAF83);
20991         MP_WritePhyUshort(sc, 0x14, 0xF1A1);
20992         MP_WritePhyUshort(sc, 0x14, 0x83F4);
20993         MP_WritePhyUshort(sc, 0x14, 0xD149);
20994         MP_WritePhyUshort(sc, 0x14, 0xAF06);
20995         MP_WritePhyUshort(sc, 0x14, 0x47AF);
20996         MP_WritePhyUshort(sc, 0x14, 0x0000);
20997         MP_WritePhyUshort(sc, 0x14, 0xAF00);
20998         MP_WritePhyUshort(sc, 0x14, 0x00AF);
20999         MP_WritePhyUshort(sc, 0x14, 0x0000);
21000
21001         MP_WritePhyUshort(sc, 0x13, 0xB818);
21002         MP_WritePhyUshort(sc, 0x14, 0x0645);
21003
21004         MP_WritePhyUshort(sc, 0x13, 0xB81A);
21005         MP_WritePhyUshort(sc, 0x14, 0x0000);
21006
21007         MP_WritePhyUshort(sc, 0x13, 0xB81C);
21008         MP_WritePhyUshort(sc, 0x14, 0x0000);
21009
21010         MP_WritePhyUshort(sc, 0x13, 0xB81E);
21011         MP_WritePhyUshort(sc, 0x14, 0x0000);
21012
21013         MP_WritePhyUshort(sc, 0x13, 0xB832);
21014         MP_WritePhyUshort(sc, 0x14, 0x0001);
21015
21016         MP_WritePhyUshort(sc,0x1F, 0x0A43);
21017         MP_WritePhyUshort(sc,0x13, 0x0000);
21018         MP_WritePhyUshort(sc,0x14, 0x0000);
21019         MP_WritePhyUshort(sc,0x1f, 0x0B82);
21020         PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
21021         PhyRegValue &= ~(BIT_0);
21022         MP_WritePhyUshort(sc,0x17, PhyRegValue);
21023         MP_WritePhyUshort(sc,0x1f, 0x0A43);
21024         MP_WritePhyUshort(sc,0x13, 0x8146);
21025         MP_WritePhyUshort(sc,0x14, 0x0000);
21026
21027         MP_WritePhyUshort(sc,0x1f, 0x0B82);
21028         PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
21029         PhyRegValue &= ~(BIT_4);
21030         MP_WritePhyUshort(sc,0x10, PhyRegValue);
21031 }
21032
21033 static void re_init_hw_phy_mcu(struct re_softc *sc)
21034 {
21035         if (re_hw_phy_mcu_code_ver_matched(sc)) return;
21036
21037         switch (sc->re_type) {
21038         case MACFG_36:
21039                 re_set_phy_mcu_8168e_1(sc);
21040                 break;
21041         case MACFG_37:
21042                 re_set_phy_mcu_8168e_2(sc);
21043                 break;
21044         case MACFG_38:
21045                 re_set_phy_mcu_8168evl_1(sc);
21046                 break;
21047         case MACFG_39:
21048                 re_set_phy_mcu_8168evl_2(sc);
21049                 break;
21050         case MACFG_50:
21051                 re_set_phy_mcu_8168f_1(sc);
21052                 break;
21053         case MACFG_51:
21054                 re_set_phy_mcu_8168f_2(sc);
21055                 break;
21056         case MACFG_52:
21057                 re_set_phy_mcu_8411_1(sc);
21058                 break;
21059         case MACFG_56:
21060                 re_set_phy_mcu_8168g_1(sc);
21061                 break;
21062         case MACFG_59:
21063                 re_set_phy_mcu_8168gu_2(sc);
21064                 break;
21065         case MACFG_60:
21066                 re_set_phy_mcu_8411b_1(sc);
21067                 break;
21068         case MACFG_61:
21069                 re_set_phy_mcu_8168ep_1(sc);
21070                 break;
21071         case MACFG_67:
21072                 re_set_phy_mcu_8168ep_2(sc);
21073                 break;
21074         case MACFG_68:
21075                 re_set_phy_mcu_8168h_1(sc);
21076                 break;
21077         case MACFG_69:
21078                 re_set_phy_mcu_8168h_2(sc);
21079                 break;
21080         }
21081
21082         re_write_hw_phy_mcu_code_ver(sc);
21083
21084         MP_WritePhyUshort(sc, 0x1F, 0x0000);
21085 }
21086
21087 static void re_hw_phy_config(struct re_softc *sc)
21088 {
21089         u_int16_t Data, PhyRegValue, TmpUshort;
21090         u_int32_t Data_u32;
21091         u_int16_t dout_tapbin;
21092         int     i;
21093
21094         if (sc->re_type == MACFG_59 || sc->re_type == MACFG_60 ||
21095             sc->re_type == MACFG_62 || sc->re_type == MACFG_67 ||
21096             sc->re_type == MACFG_68 || sc->re_type == MACFG_69 ||
21097             sc->re_type == MACFG_70 || sc->re_type == MACFG_71) {
21098                 MP_WritePhyOcpRegWord(sc, 0x0C41, 0x13, 0x0000);
21099                 MP_WritePhyOcpRegWord(sc, 0x0C41, 0x13, 0x0500);
21100         }
21101
21102         if (HW_DASH_SUPPORT_TYPE_3(sc) && sc->HwPkgDet == 0x06) return;
21103
21104         if (FALSE == re_phy_ram_code_check(sc)) {
21105                 re_set_phy_ram_code_check_fail_flag(sc);
21106                 return;
21107         }
21108
21109         re_init_hw_phy_mcu(sc);
21110
21111         MP_WritePhyUshort(sc, 0x1F, 0x0000);
21112
21113         if (sc->re_type == MACFG_3) {
21114                 CSR_WRITE_1(sc, 0x82, CSR_READ_1(sc, 0x82)|BIT_0);
21115                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21116                 MP_WritePhyUshort(sc, 0x0b, 0x0000);
21117
21118                 MP_WritePhyUshort(sc, 0x1f, 0x0001);
21119                 MP_WritePhyUshort(sc, 0x06, 0x006e);
21120                 MP_WritePhyUshort(sc, 0x08, 0x0708);
21121                 MP_WritePhyUshort(sc, 0x15, 0x4000);
21122                 MP_WritePhyUshort(sc, 0x18, 0x65c7);
21123
21124                 MP_WritePhyUshort(sc, 0x1f, 0x0001);
21125                 MP_WritePhyUshort(sc, 0x03, 0x00a1);
21126                 MP_WritePhyUshort(sc, 0x02, 0x0008);
21127                 MP_WritePhyUshort(sc, 0x01, 0x0120);
21128                 MP_WritePhyUshort(sc, 0x00, 0x1000);
21129                 MP_WritePhyUshort(sc, 0x04, 0x0800);
21130                 MP_WritePhyUshort(sc, 0x04, 0x0000);
21131
21132                 MP_WritePhyUshort(sc, 0x03, 0xff41);
21133                 MP_WritePhyUshort(sc, 0x02, 0xdf60);
21134                 MP_WritePhyUshort(sc, 0x01, 0x0140);
21135                 MP_WritePhyUshort(sc, 0x00, 0x0077);
21136                 MP_WritePhyUshort(sc, 0x04, 0x7800);
21137                 MP_WritePhyUshort(sc, 0x04, 0x7000);
21138
21139                 MP_WritePhyUshort(sc, 0x03, 0x802f);
21140                 MP_WritePhyUshort(sc, 0x02, 0x4f02);
21141                 MP_WritePhyUshort(sc, 0x01, 0x0409);
21142                 MP_WritePhyUshort(sc, 0x00, 0xf0f9);
21143                 MP_WritePhyUshort(sc, 0x04, 0x9800);
21144                 MP_WritePhyUshort(sc, 0x04, 0x9000);
21145
21146                 MP_WritePhyUshort(sc, 0x03, 0xdf01);
21147                 MP_WritePhyUshort(sc, 0x02, 0xdf20);
21148                 MP_WritePhyUshort(sc, 0x01, 0xff95);
21149                 MP_WritePhyUshort(sc, 0x00, 0xba00);
21150                 MP_WritePhyUshort(sc, 0x04, 0xa800);
21151                 MP_WritePhyUshort(sc, 0x04, 0xa000);
21152
21153                 MP_WritePhyUshort(sc, 0x03, 0xff41);
21154                 MP_WritePhyUshort(sc, 0x02, 0xdf20);
21155                 MP_WritePhyUshort(sc, 0x01, 0x0140);
21156                 MP_WritePhyUshort(sc, 0x00, 0x00bb);
21157                 MP_WritePhyUshort(sc, 0x04, 0xb800);
21158                 MP_WritePhyUshort(sc, 0x04, 0xb000);
21159
21160                 MP_WritePhyUshort(sc, 0x03, 0xdf41);
21161                 MP_WritePhyUshort(sc, 0x02, 0xdc60);
21162                 MP_WritePhyUshort(sc, 0x01, 0x6340);
21163                 MP_WritePhyUshort(sc, 0x00, 0x007d);
21164                 MP_WritePhyUshort(sc, 0x04, 0xd800);
21165                 MP_WritePhyUshort(sc, 0x04, 0xd000);
21166
21167                 MP_WritePhyUshort(sc, 0x03, 0xdf01);
21168                 MP_WritePhyUshort(sc, 0x02, 0xdf20);
21169                 MP_WritePhyUshort(sc, 0x01, 0x100a);
21170                 MP_WritePhyUshort(sc, 0x00, 0xa0ff);
21171                 MP_WritePhyUshort(sc, 0x04, 0xf800);
21172                 MP_WritePhyUshort(sc, 0x04, 0xf000);
21173
21174                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
21175                 MP_WritePhyUshort(sc, 0x0b, 0x0000);
21176                 MP_WritePhyUshort(sc, 0x00, 0x9200);
21177
21178                 CSR_WRITE_1(sc, 0x82, 0x0d);
21179         } else if (sc->re_type == MACFG_4) {
21180                 MP_WritePhyUshort(sc, 0x1f, 0x0002);
21181                 MP_WritePhyUshort(sc, 0x01, 0x90D0);
21182                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
21183                 // MP_WritePhyUshort(sc, 0x1e, 0x8c00); /* PHY link down with some Giga switch */
21184         } else if (sc->re_type == MACFG_5) {
21185                 MP_WritePhyUshort(sc, 0x1f, 0x0001);
21186                 MP_WritePhyUshort(sc, 0x04, 0x0000);
21187                 MP_WritePhyUshort(sc, 0x03, 0x00a1);
21188                 MP_WritePhyUshort(sc, 0x02, 0x0008);
21189                 MP_WritePhyUshort(sc, 0x01, 0x0120);
21190                 MP_WritePhyUshort(sc, 0x00, 0x1000);
21191                 MP_WritePhyUshort(sc, 0x04, 0x0800);
21192
21193                 MP_WritePhyUshort(sc, 0x04, 0x9000);
21194                 MP_WritePhyUshort(sc, 0x03, 0x802f);
21195                 MP_WritePhyUshort(sc, 0x02, 0x4f02);
21196                 MP_WritePhyUshort(sc, 0x01, 0x0409);
21197                 MP_WritePhyUshort(sc, 0x00, 0xf099);
21198                 MP_WritePhyUshort(sc, 0x04, 0x9800);
21199
21200                 MP_WritePhyUshort(sc, 0x04, 0xa000);
21201                 MP_WritePhyUshort(sc, 0x03, 0xdf01);
21202                 MP_WritePhyUshort(sc, 0x02, 0xdf20);
21203                 MP_WritePhyUshort(sc, 0x01, 0xff95);
21204                 MP_WritePhyUshort(sc, 0x00, 0xba00);
21205                 MP_WritePhyUshort(sc, 0x04, 0xa800);
21206
21207                 MP_WritePhyUshort(sc, 0x04, 0xf000);
21208                 MP_WritePhyUshort(sc, 0x03, 0xdf01);
21209                 MP_WritePhyUshort(sc, 0x02, 0xdf20);
21210                 MP_WritePhyUshort(sc, 0x01, 0x101a);
21211                 MP_WritePhyUshort(sc, 0x00, 0xa0ff);
21212                 MP_WritePhyUshort(sc, 0x04, 0xf800);
21213                 MP_WritePhyUshort(sc, 0x04, 0x0000);
21214                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
21215
21216                 MP_WritePhyUshort(sc, 0x1f, 0x0001);
21217                 MP_WritePhyUshort(sc, 0x10, 0xf41b);
21218                 MP_WritePhyUshort(sc, 0x14, 0xfb54);
21219                 MP_WritePhyUshort(sc, 0x18, 0xf5c7);
21220                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
21221
21222                 MP_WritePhyUshort(sc, 0x1f, 0x0001);
21223                 MP_WritePhyUshort(sc, 0x17, 0x0CC0);
21224                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
21225
21226                 MP_WritePhyUshort(sc, 0x1f, 0x0001);
21227                 MP_WritePhyUshort(sc, 0x10, 0xf01b);
21228
21229         } else if (sc->re_type == MACFG_6) {
21230                 MP_WritePhyUshort(sc, 0x1f, 0x0001);
21231                 MP_WritePhyUshort(sc, 0x04, 0x0000);
21232                 MP_WritePhyUshort(sc, 0x03, 0x00a1);
21233                 MP_WritePhyUshort(sc, 0x02, 0x0008);
21234                 MP_WritePhyUshort(sc, 0x01, 0x0120);
21235                 MP_WritePhyUshort(sc, 0x00, 0x1000);
21236                 MP_WritePhyUshort(sc, 0x04, 0x0800);
21237
21238                 MP_WritePhyUshort(sc, 0x04, 0x9000);
21239                 MP_WritePhyUshort(sc, 0x03, 0x802f);
21240                 MP_WritePhyUshort(sc, 0x02, 0x4f02);
21241                 MP_WritePhyUshort(sc, 0x01, 0x0409);
21242                 MP_WritePhyUshort(sc, 0x00, 0xf099);
21243                 MP_WritePhyUshort(sc, 0x04, 0x9800);
21244
21245                 MP_WritePhyUshort(sc, 0x04, 0xa000);
21246                 MP_WritePhyUshort(sc, 0x03, 0xdf01);
21247                 MP_WritePhyUshort(sc, 0x02, 0xdf20);
21248                 MP_WritePhyUshort(sc, 0x01, 0xff95);
21249                 MP_WritePhyUshort(sc, 0x00, 0xba00);
21250                 MP_WritePhyUshort(sc, 0x04, 0xa800);
21251
21252                 MP_WritePhyUshort(sc, 0x04, 0xf000);
21253                 MP_WritePhyUshort(sc, 0x03, 0xdf01);
21254                 MP_WritePhyUshort(sc, 0x02, 0xdf20);
21255                 MP_WritePhyUshort(sc, 0x01, 0x101a);
21256                 MP_WritePhyUshort(sc, 0x00, 0xa0ff);
21257                 MP_WritePhyUshort(sc, 0x04, 0xf800);
21258                 MP_WritePhyUshort(sc, 0x04, 0x0000);
21259                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
21260
21261                 MP_WritePhyUshort(sc, 0x1f, 0x0001);
21262                 MP_WritePhyUshort(sc, 0x0b, 0x8480);
21263                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
21264
21265                 MP_WritePhyUshort(sc, 0x1f, 0x0001);
21266                 MP_WritePhyUshort(sc, 0x18, 0x67c7);
21267                 MP_WritePhyUshort(sc, 0x04, 0x2000);
21268                 MP_WritePhyUshort(sc, 0x03, 0x002f);
21269                 MP_WritePhyUshort(sc, 0x02, 0x4360);
21270                 MP_WritePhyUshort(sc, 0x01, 0x0109);
21271                 MP_WritePhyUshort(sc, 0x00, 0x3022);
21272                 MP_WritePhyUshort(sc, 0x04, 0x2800);
21273                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
21274
21275                 MP_WritePhyUshort(sc, 0x1f, 0x0001);
21276                 MP_WritePhyUshort(sc, 0x17, 0x0CC0);
21277         } else if (sc->re_type == MACFG_14) {
21278                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
21279                 MP_WritePhyUshort(sc, 0x11, MP_ReadPhyUshort(sc, 0x11) | 0x1000);
21280                 MP_WritePhyUshort(sc, 0x19, MP_ReadPhyUshort(sc, 0x19) | 0x2000);
21281                 MP_WritePhyUshort(sc, 0x10, MP_ReadPhyUshort(sc, 0x10) | 0x8000);
21282
21283                 MP_WritePhyUshort(sc, 0x1f, 0x0003);
21284                 MP_WritePhyUshort(sc, 0x08, 0x441D);
21285                 MP_WritePhyUshort(sc, 0x01, 0x9100);
21286         } else if (sc->re_type == MACFG_15) {
21287                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
21288                 MP_WritePhyUshort(sc, 0x11, MP_ReadPhyUshort(sc, 0x11) | 0x1000);
21289                 MP_WritePhyUshort(sc, 0x19, MP_ReadPhyUshort(sc, 0x19) | 0x2000);
21290                 MP_WritePhyUshort(sc, 0x10, MP_ReadPhyUshort(sc, 0x10) | 0x8000);
21291
21292                 MP_WritePhyUshort(sc, 0x1f, 0x0003);
21293                 MP_WritePhyUshort(sc, 0x08, 0x441D);
21294                 MP_WritePhyUshort(sc, 0x01, 0x9100);
21295         } else if (sc->re_type == MACFG_17) {
21296                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
21297                 MP_WritePhyUshort(sc, 0x11, MP_ReadPhyUshort(sc, 0x11) | 0x1000);
21298                 MP_WritePhyUshort(sc, 0x19, MP_ReadPhyUshort(sc, 0x19) | 0x2000);
21299                 MP_WritePhyUshort(sc, 0x10, MP_ReadPhyUshort(sc, 0x10) | 0x8000);
21300
21301                 MP_WritePhyUshort(sc, 0x1f, 0x0003);
21302                 MP_WritePhyUshort(sc, 0x08, 0x441D);
21303
21304                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
21305         } else if (sc->re_type == MACFG_21) {
21306                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
21307                 MP_WritePhyUshort(sc, 0x0B, 0x94B0);
21308
21309                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
21310                 MP_WritePhyUshort(sc, 0x12, 0x6096);
21311                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21312         } else if (sc->re_type == MACFG_22) {
21313                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
21314                 MP_WritePhyUshort(sc, 0x0B, 0x94B0);
21315
21316                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
21317                 MP_WritePhyUshort(sc, 0x12, 0x6096);
21318         } else if (sc->re_type == MACFG_23) {
21319                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
21320                 MP_WritePhyUshort(sc, 0x0B, 0x94B0);
21321
21322                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
21323                 MP_WritePhyUshort(sc, 0x12, 0x6096);
21324         } else if (sc->re_type == MACFG_24) {
21325                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
21326                 MP_WritePhyUshort(sc, 0x12, 0x2300);
21327                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21328                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
21329                 MP_WritePhyUshort(sc, 0x16, 0x000A);
21330                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21331
21332                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
21333                 MP_WritePhyUshort(sc, 0x12, 0xC096);
21334                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21335
21336                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21337                 MP_WritePhyUshort(sc, 0x00, 0x88DE);
21338                 MP_WritePhyUshort(sc, 0x01, 0x82B1);
21339                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21340
21341                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21342                 MP_WritePhyUshort(sc, 0x08, 0x9E30);
21343                 MP_WritePhyUshort(sc, 0x09, 0x01F0);
21344                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21345
21346                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21347                 MP_WritePhyUshort(sc, 0x0A, 0x5500);
21348                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21349
21350                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21351                 MP_WritePhyUshort(sc, 0x03, 0x7002);
21352                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21353
21354                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21355                 MP_WritePhyUshort(sc, 0x14, MP_ReadPhyUshort(sc, 0x14) | BIT_5);
21356                 MP_WritePhyUshort(sc, 0x0d, MP_ReadPhyUshort(sc, 0x0d) | BIT_5);
21357         } else if (sc->re_type == MACFG_25) {
21358                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
21359                 MP_WritePhyUshort(sc, 0x12, 0x2300);
21360                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
21361                 MP_WritePhyUshort(sc, 0x16, 0x0F0A);
21362                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21363
21364                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21365                 MP_WritePhyUshort(sc, 0x00, 0x88DE);
21366                 MP_WritePhyUshort(sc, 0x01, 0x82B1);
21367                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21368
21369                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21370                 MP_WritePhyUshort(sc, 0x0C, 0x7EB8);
21371                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21372
21373                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21374                 MP_WritePhyUshort(sc, 0x06, 0x0761);
21375                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21376
21377                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
21378                 MP_WritePhyUshort(sc, 0x03, 0x802F);
21379                 MP_WritePhyUshort(sc, 0x02, 0x4F02);
21380                 MP_WritePhyUshort(sc, 0x01, 0x0409);
21381                 MP_WritePhyUshort(sc, 0x00, 0xF099);
21382                 MP_WritePhyUshort(sc, 0x04, 0x9800);
21383                 MP_WritePhyUshort(sc, 0x04, 0x9000);
21384                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21385
21386                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21387                 MP_WritePhyUshort(sc, 0x16, MP_ReadPhyUshort(sc, 0x16) | BIT_0);
21388
21389                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21390                 MP_WritePhyUshort(sc, 0x14, MP_ReadPhyUshort(sc, 0x14) | BIT_5);
21391                 MP_WritePhyUshort(sc, 0x0D, MP_ReadPhyUshort(sc, 0x0D) & ~BIT_5);
21392
21393                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
21394                 MP_WritePhyUshort(sc, 0x1D, 0x3D98);
21395                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21396
21397                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
21398                 MP_WritePhyUshort(sc, 0x17, 0x0CC0);
21399                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21400         } else if (sc->re_type == MACFG_26) {
21401                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
21402                 MP_WritePhyUshort(sc, 0x12, 0x2300);
21403                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
21404                 MP_WritePhyUshort(sc, 0x16, 0x0F0A);
21405                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21406
21407                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21408                 MP_WritePhyUshort(sc, 0x00, 0x88DE);
21409                 MP_WritePhyUshort(sc, 0x01, 0x82B1);
21410                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21411
21412                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21413                 MP_WritePhyUshort(sc, 0x0C, 0x7EB8);
21414                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21415
21416                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21417                 MP_WritePhyUshort(sc, 0x06, 0x5461);
21418                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21419
21420                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21421                 MP_WritePhyUshort(sc, 0x06, 0x5461);
21422                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21423
21424                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21425                 MP_WritePhyUshort(sc, 0x16, MP_ReadPhyUshort(sc, 0x16) | BIT_0);
21426
21427                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21428                 MP_WritePhyUshort(sc, 0x14, MP_ReadPhyUshort(sc, 0x14) | BIT_5);
21429                 MP_WritePhyUshort(sc, 0x0D, MP_ReadPhyUshort(sc, 0x0D) & ~BIT_5);
21430
21431                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
21432                 MP_WritePhyUshort(sc, 0x1D, 0x3D98);
21433                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21434
21435                 MP_WritePhyUshort(sc, 0x1f, 0x0001);
21436                 MP_WritePhyUshort(sc, 0x17, 0x0CC0);
21437                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21438         } else if (sc->re_type == MACFG_27) {
21439                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21440                 MP_WritePhyUshort(sc, 0x0d, MP_ReadPhyUshort(sc, 0x0d) | BIT_5);
21441                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21442
21443                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
21444                 MP_WritePhyUshort(sc, 0x1D, 0x3D98);
21445                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21446
21447                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
21448                 MP_WritePhyUshort(sc, 0x14, 0xCAA3);
21449                 MP_WritePhyUshort(sc, 0x1C, 0x000A);
21450                 MP_WritePhyUshort(sc, 0x18, 0x65D0);
21451
21452                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
21453                 MP_WritePhyUshort(sc, 0x17, 0xB580);
21454                 MP_WritePhyUshort(sc, 0x18, 0xFF54);
21455                 MP_WritePhyUshort(sc, 0x19, 0x3954);
21456
21457                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21458                 MP_WritePhyUshort(sc, 0x0D, 0x310C);
21459                 MP_WritePhyUshort(sc, 0x0E, 0x310C);
21460                 MP_WritePhyUshort(sc, 0x0F, 0x311C);
21461                 MP_WritePhyUshort(sc, 0x06, 0x0761);
21462
21463                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
21464                 MP_WritePhyUshort(sc, 0x18, 0xFF55);
21465                 MP_WritePhyUshort(sc, 0x19, 0x3955);
21466                 MP_WritePhyUshort(sc, 0x18, 0xFF54);
21467                 MP_WritePhyUshort(sc, 0x19, 0x3954);
21468
21469                 MP_WritePhyUshort(sc, 0x1f, 0x0001);
21470                 MP_WritePhyUshort(sc, 0x17, 0x0CC0);
21471         } else if (sc->re_type == MACFG_28) {
21472                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21473                 MP_WritePhyUshort(sc, 0x14, MP_ReadPhyUshort(sc, 0x14) | BIT_5);
21474                 MP_WritePhyUshort(sc, 0x0d, MP_ReadPhyUshort(sc, 0x0d) | BIT_5);
21475
21476                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
21477                 MP_WritePhyUshort(sc, 0x14, 0xCAA3);
21478                 MP_WritePhyUshort(sc, 0x1C, 0x000A);
21479                 MP_WritePhyUshort(sc, 0x18, 0x65D0);
21480
21481                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
21482                 MP_WritePhyUshort(sc, 0x17, 0xB580);
21483                 MP_WritePhyUshort(sc, 0x18, 0xFF54);
21484                 MP_WritePhyUshort(sc, 0x19, 0x3954);
21485
21486                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21487                 MP_WritePhyUshort(sc, 0x0D, 0x310C);
21488                 MP_WritePhyUshort(sc, 0x0E, 0x310C);
21489                 MP_WritePhyUshort(sc, 0x0F, 0x311C);
21490                 MP_WritePhyUshort(sc, 0x06, 0x0761);
21491
21492                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
21493                 MP_WritePhyUshort(sc, 0x18, 0xFF55);
21494                 MP_WritePhyUshort(sc, 0x19, 0x3955);
21495                 MP_WritePhyUshort(sc, 0x18, 0xFF54);
21496                 MP_WritePhyUshort(sc, 0x19, 0x3954);
21497
21498                 MP_WritePhyUshort(sc, 0x1f, 0x0001);
21499                 MP_WritePhyUshort(sc, 0x17, 0x0CC0);
21500
21501                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21502                 MP_WritePhyUshort(sc, 0x16, MP_ReadPhyUshort(sc, 0x16) | BIT_0);
21503                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21504         } else if (sc->re_type == MACFG_31) {
21505                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
21506                 MP_WritePhyUshort(sc, 0x06, 0x4064);
21507                 MP_WritePhyUshort(sc, 0x07, 0x2863);
21508                 MP_WritePhyUshort(sc, 0x08, 0x059C);
21509                 MP_WritePhyUshort(sc, 0x09, 0x26B4);
21510                 MP_WritePhyUshort(sc, 0x0A, 0x6A19);
21511                 MP_WritePhyUshort(sc, 0x0B, 0xDCC8);
21512                 MP_WritePhyUshort(sc, 0x10, 0xF06D);
21513                 MP_WritePhyUshort(sc, 0x14, 0x7F68);
21514                 MP_WritePhyUshort(sc, 0x18, 0x7FD9);
21515                 MP_WritePhyUshort(sc, 0x1C, 0xF0FF);
21516                 MP_WritePhyUshort(sc, 0x1D, 0x3D9C);
21517                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
21518                 MP_WritePhyUshort(sc, 0x12, 0xF49F);
21519                 MP_WritePhyUshort(sc, 0x13, 0x070B);
21520                 MP_WritePhyUshort(sc, 0x1A, 0x05AD);
21521                 MP_WritePhyUshort(sc, 0x14, 0x94C0);
21522
21523                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21524                 Data = MP_ReadPhyUshort(sc, 0x0B) & 0xFF00;
21525                 Data |= 0x10;
21526                 MP_WritePhyUshort(sc, 0x0B, Data);
21527                 Data = MP_ReadPhyUshort(sc, 0x0C) & 0x00FF;
21528                 Data |= 0xA200;
21529                 MP_WritePhyUshort(sc, 0x0C, Data);
21530
21531                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21532                 MP_WritePhyUshort(sc, 0x06, 0x5561);
21533                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
21534                 MP_WritePhyUshort(sc, 0x05, 0x8332);
21535                 MP_WritePhyUshort(sc, 0x06, 0x5561);
21536
21537                 if (MP_ReadEfuse(sc, 0x01) == 0xb1) {
21538                         MP_WritePhyUshort(sc, 0x1F, 0x0002);
21539                         MP_WritePhyUshort(sc, 0x05, 0x669A);
21540                         MP_WritePhyUshort(sc, 0x1F, 0x0005);
21541                         MP_WritePhyUshort(sc, 0x05, 0x8330);
21542                         MP_WritePhyUshort(sc, 0x06, 0x669A);
21543
21544                         MP_WritePhyUshort(sc, 0x1F, 0x0002);
21545                         Data = MP_ReadPhyUshort(sc, 0x0D);
21546                         if ((Data & 0x00FF) != 0x006C) {
21547                                 Data &= 0xFF00;
21548                                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21549                                 MP_WritePhyUshort(sc, 0x0D, Data | 0x0065);
21550                                 MP_WritePhyUshort(sc, 0x0D, Data | 0x0066);
21551                                 MP_WritePhyUshort(sc, 0x0D, Data | 0x0067);
21552                                 MP_WritePhyUshort(sc, 0x0D, Data | 0x0068);
21553                                 MP_WritePhyUshort(sc, 0x0D, Data | 0x0069);
21554                                 MP_WritePhyUshort(sc, 0x0D, Data | 0x006A);
21555                                 MP_WritePhyUshort(sc, 0x0D, Data | 0x006B);
21556                                 MP_WritePhyUshort(sc, 0x0D, Data | 0x006C);
21557                         }
21558                 } else {
21559                         MP_WritePhyUshort(sc, 0x1F, 0x0002);
21560                         MP_WritePhyUshort(sc, 0x05, 0x6662);
21561                         MP_WritePhyUshort(sc, 0x1F, 0x0005);
21562                         MP_WritePhyUshort(sc, 0x05, 0x8330);
21563                         MP_WritePhyUshort(sc, 0x06, 0x6662);
21564                 }
21565
21566                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21567                 Data = MP_ReadPhyUshort(sc, 0x0D);
21568                 Data |= 0x300;
21569                 MP_WritePhyUshort(sc, 0x0D, Data);
21570                 Data = MP_ReadPhyUshort(sc, 0x0F);
21571                 Data |= 0x10;
21572                 MP_WritePhyUshort(sc, 0x0F, Data);
21573
21574                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21575                 Data = MP_ReadPhyUshort(sc, 0x02);
21576                 Data &= ~0x600;
21577                 Data |= 0x100;
21578                 MP_WritePhyUshort(sc, 0x02, Data);
21579                 Data = MP_ReadPhyUshort(sc, 0x03);
21580                 Data &= ~0xE000;
21581                 MP_WritePhyUshort(sc, 0x03, Data);
21582
21583                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
21584                 MP_WritePhyUshort(sc, 0x17, 0x0CC0);
21585
21586                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
21587                 MP_WritePhyUshort(sc, 0x05, 0x001B);
21588                 if (MP_ReadPhyUshort(sc, 0x06) == 0xBF00) {
21589                         MP_WritePhyUshort(sc, 0x1f, 0x0005);
21590                         MP_WritePhyUshort(sc, 0x05, 0xfff6);
21591                         MP_WritePhyUshort(sc, 0x06, 0x0080);
21592                         MP_WritePhyUshort(sc, 0x05, 0x8000);
21593                         MP_WritePhyUshort(sc, 0x06, 0xf8f9);
21594                         MP_WritePhyUshort(sc, 0x06, 0xfaef);
21595                         MP_WritePhyUshort(sc, 0x06, 0x59ee);
21596                         MP_WritePhyUshort(sc, 0x06, 0xf8ea);
21597                         MP_WritePhyUshort(sc, 0x06, 0x00ee);
21598                         MP_WritePhyUshort(sc, 0x06, 0xf8eb);
21599                         MP_WritePhyUshort(sc, 0x06, 0x00e0);
21600                         MP_WritePhyUshort(sc, 0x06, 0xf87c);
21601                         MP_WritePhyUshort(sc, 0x06, 0xe1f8);
21602                         MP_WritePhyUshort(sc, 0x06, 0x7d59);
21603                         MP_WritePhyUshort(sc, 0x06, 0x0fef);
21604                         MP_WritePhyUshort(sc, 0x06, 0x0139);
21605                         MP_WritePhyUshort(sc, 0x06, 0x029e);
21606                         MP_WritePhyUshort(sc, 0x06, 0x06ef);
21607                         MP_WritePhyUshort(sc, 0x06, 0x1039);
21608                         MP_WritePhyUshort(sc, 0x06, 0x089f);
21609                         MP_WritePhyUshort(sc, 0x06, 0x2aee);
21610                         MP_WritePhyUshort(sc, 0x06, 0xf8ea);
21611                         MP_WritePhyUshort(sc, 0x06, 0x00ee);
21612                         MP_WritePhyUshort(sc, 0x06, 0xf8eb);
21613                         MP_WritePhyUshort(sc, 0x06, 0x01e0);
21614                         MP_WritePhyUshort(sc, 0x06, 0xf87c);
21615                         MP_WritePhyUshort(sc, 0x06, 0xe1f8);
21616                         MP_WritePhyUshort(sc, 0x06, 0x7d58);
21617                         MP_WritePhyUshort(sc, 0x06, 0x409e);
21618                         MP_WritePhyUshort(sc, 0x06, 0x0f39);
21619                         MP_WritePhyUshort(sc, 0x06, 0x46aa);
21620                         MP_WritePhyUshort(sc, 0x06, 0x0bbf);
21621                         MP_WritePhyUshort(sc, 0x06, 0x8290);
21622                         MP_WritePhyUshort(sc, 0x06, 0xd682);
21623                         MP_WritePhyUshort(sc, 0x06, 0x9802);
21624                         MP_WritePhyUshort(sc, 0x06, 0x014f);
21625                         MP_WritePhyUshort(sc, 0x06, 0xae09);
21626                         MP_WritePhyUshort(sc, 0x06, 0xbf82);
21627                         MP_WritePhyUshort(sc, 0x06, 0x98d6);
21628                         MP_WritePhyUshort(sc, 0x06, 0x82a0);
21629                         MP_WritePhyUshort(sc, 0x06, 0x0201);
21630                         MP_WritePhyUshort(sc, 0x06, 0x4fef);
21631                         MP_WritePhyUshort(sc, 0x06, 0x95fe);
21632                         MP_WritePhyUshort(sc, 0x06, 0xfdfc);
21633                         MP_WritePhyUshort(sc, 0x06, 0x05f8);
21634                         MP_WritePhyUshort(sc, 0x06, 0xf9fa);
21635                         MP_WritePhyUshort(sc, 0x06, 0xeef8);
21636                         MP_WritePhyUshort(sc, 0x06, 0xea00);
21637                         MP_WritePhyUshort(sc, 0x06, 0xeef8);
21638                         MP_WritePhyUshort(sc, 0x06, 0xeb00);
21639                         MP_WritePhyUshort(sc, 0x06, 0xe2f8);
21640                         MP_WritePhyUshort(sc, 0x06, 0x7ce3);
21641                         MP_WritePhyUshort(sc, 0x06, 0xf87d);
21642                         MP_WritePhyUshort(sc, 0x06, 0xa511);
21643                         MP_WritePhyUshort(sc, 0x06, 0x1112);
21644                         MP_WritePhyUshort(sc, 0x06, 0xd240);
21645                         MP_WritePhyUshort(sc, 0x06, 0xd644);
21646                         MP_WritePhyUshort(sc, 0x06, 0x4402);
21647                         MP_WritePhyUshort(sc, 0x06, 0x8217);
21648                         MP_WritePhyUshort(sc, 0x06, 0xd2a0);
21649                         MP_WritePhyUshort(sc, 0x06, 0xd6aa);
21650                         MP_WritePhyUshort(sc, 0x06, 0xaa02);
21651                         MP_WritePhyUshort(sc, 0x06, 0x8217);
21652                         MP_WritePhyUshort(sc, 0x06, 0xae0f);
21653                         MP_WritePhyUshort(sc, 0x06, 0xa544);
21654                         MP_WritePhyUshort(sc, 0x06, 0x4402);
21655                         MP_WritePhyUshort(sc, 0x06, 0xae4d);
21656                         MP_WritePhyUshort(sc, 0x06, 0xa5aa);
21657                         MP_WritePhyUshort(sc, 0x06, 0xaa02);
21658                         MP_WritePhyUshort(sc, 0x06, 0xae47);
21659                         MP_WritePhyUshort(sc, 0x06, 0xaf82);
21660                         MP_WritePhyUshort(sc, 0x06, 0x13ee);
21661                         MP_WritePhyUshort(sc, 0x06, 0x834e);
21662                         MP_WritePhyUshort(sc, 0x06, 0x00ee);
21663                         MP_WritePhyUshort(sc, 0x06, 0x834d);
21664                         MP_WritePhyUshort(sc, 0x06, 0x0fee);
21665                         MP_WritePhyUshort(sc, 0x06, 0x834c);
21666                         MP_WritePhyUshort(sc, 0x06, 0x0fee);
21667                         MP_WritePhyUshort(sc, 0x06, 0x834f);
21668                         MP_WritePhyUshort(sc, 0x06, 0x00ee);
21669                         MP_WritePhyUshort(sc, 0x06, 0x8351);
21670                         MP_WritePhyUshort(sc, 0x06, 0x00ee);
21671                         MP_WritePhyUshort(sc, 0x06, 0x834a);
21672                         MP_WritePhyUshort(sc, 0x06, 0xffee);
21673                         MP_WritePhyUshort(sc, 0x06, 0x834b);
21674                         MP_WritePhyUshort(sc, 0x06, 0xffe0);
21675                         MP_WritePhyUshort(sc, 0x06, 0x8330);
21676                         MP_WritePhyUshort(sc, 0x06, 0xe183);
21677                         MP_WritePhyUshort(sc, 0x06, 0x3158);
21678                         MP_WritePhyUshort(sc, 0x06, 0xfee4);
21679                         MP_WritePhyUshort(sc, 0x06, 0xf88a);
21680                         MP_WritePhyUshort(sc, 0x06, 0xe5f8);
21681                         MP_WritePhyUshort(sc, 0x06, 0x8be0);
21682                         MP_WritePhyUshort(sc, 0x06, 0x8332);
21683                         MP_WritePhyUshort(sc, 0x06, 0xe183);
21684                         MP_WritePhyUshort(sc, 0x06, 0x3359);
21685                         MP_WritePhyUshort(sc, 0x06, 0x0fe2);
21686                         MP_WritePhyUshort(sc, 0x06, 0x834d);
21687                         MP_WritePhyUshort(sc, 0x06, 0x0c24);
21688                         MP_WritePhyUshort(sc, 0x06, 0x5af0);
21689                         MP_WritePhyUshort(sc, 0x06, 0x1e12);
21690                         MP_WritePhyUshort(sc, 0x06, 0xe4f8);
21691                         MP_WritePhyUshort(sc, 0x06, 0x8ce5);
21692                         MP_WritePhyUshort(sc, 0x06, 0xf88d);
21693                         MP_WritePhyUshort(sc, 0x06, 0xaf82);
21694                         MP_WritePhyUshort(sc, 0x06, 0x13e0);
21695                         MP_WritePhyUshort(sc, 0x06, 0x834f);
21696                         MP_WritePhyUshort(sc, 0x06, 0x10e4);
21697                         MP_WritePhyUshort(sc, 0x06, 0x834f);
21698                         MP_WritePhyUshort(sc, 0x06, 0xe083);
21699                         MP_WritePhyUshort(sc, 0x06, 0x4e78);
21700                         MP_WritePhyUshort(sc, 0x06, 0x009f);
21701                         MP_WritePhyUshort(sc, 0x06, 0x0ae0);
21702                         MP_WritePhyUshort(sc, 0x06, 0x834f);
21703                         MP_WritePhyUshort(sc, 0x06, 0xa010);
21704                         MP_WritePhyUshort(sc, 0x06, 0xa5ee);
21705                         MP_WritePhyUshort(sc, 0x06, 0x834e);
21706                         MP_WritePhyUshort(sc, 0x06, 0x01e0);
21707                         MP_WritePhyUshort(sc, 0x06, 0x834e);
21708                         MP_WritePhyUshort(sc, 0x06, 0x7805);
21709                         MP_WritePhyUshort(sc, 0x06, 0x9e9a);
21710                         MP_WritePhyUshort(sc, 0x06, 0xe083);
21711                         MP_WritePhyUshort(sc, 0x06, 0x4e78);
21712                         MP_WritePhyUshort(sc, 0x06, 0x049e);
21713                         MP_WritePhyUshort(sc, 0x06, 0x10e0);
21714                         MP_WritePhyUshort(sc, 0x06, 0x834e);
21715                         MP_WritePhyUshort(sc, 0x06, 0x7803);
21716                         MP_WritePhyUshort(sc, 0x06, 0x9e0f);
21717                         MP_WritePhyUshort(sc, 0x06, 0xe083);
21718                         MP_WritePhyUshort(sc, 0x06, 0x4e78);
21719                         MP_WritePhyUshort(sc, 0x06, 0x019e);
21720                         MP_WritePhyUshort(sc, 0x06, 0x05ae);
21721                         MP_WritePhyUshort(sc, 0x06, 0x0caf);
21722                         MP_WritePhyUshort(sc, 0x06, 0x81f8);
21723                         MP_WritePhyUshort(sc, 0x06, 0xaf81);
21724                         MP_WritePhyUshort(sc, 0x06, 0xa3af);
21725                         MP_WritePhyUshort(sc, 0x06, 0x81dc);
21726                         MP_WritePhyUshort(sc, 0x06, 0xaf82);
21727                         MP_WritePhyUshort(sc, 0x06, 0x13ee);
21728                         MP_WritePhyUshort(sc, 0x06, 0x8348);
21729                         MP_WritePhyUshort(sc, 0x06, 0x00ee);
21730                         MP_WritePhyUshort(sc, 0x06, 0x8349);
21731                         MP_WritePhyUshort(sc, 0x06, 0x00e0);
21732                         MP_WritePhyUshort(sc, 0x06, 0x8351);
21733                         MP_WritePhyUshort(sc, 0x06, 0x10e4);
21734                         MP_WritePhyUshort(sc, 0x06, 0x8351);
21735                         MP_WritePhyUshort(sc, 0x06, 0x5801);
21736                         MP_WritePhyUshort(sc, 0x06, 0x9fea);
21737                         MP_WritePhyUshort(sc, 0x06, 0xd000);
21738                         MP_WritePhyUshort(sc, 0x06, 0xd180);
21739                         MP_WritePhyUshort(sc, 0x06, 0x1f66);
21740                         MP_WritePhyUshort(sc, 0x06, 0xe2f8);
21741                         MP_WritePhyUshort(sc, 0x06, 0xeae3);
21742                         MP_WritePhyUshort(sc, 0x06, 0xf8eb);
21743                         MP_WritePhyUshort(sc, 0x06, 0x5af8);
21744                         MP_WritePhyUshort(sc, 0x06, 0x1e20);
21745                         MP_WritePhyUshort(sc, 0x06, 0xe6f8);
21746                         MP_WritePhyUshort(sc, 0x06, 0xeae5);
21747                         MP_WritePhyUshort(sc, 0x06, 0xf8eb);
21748                         MP_WritePhyUshort(sc, 0x06, 0xd302);
21749                         MP_WritePhyUshort(sc, 0x06, 0xb3fe);
21750                         MP_WritePhyUshort(sc, 0x06, 0xe2f8);
21751                         MP_WritePhyUshort(sc, 0x06, 0x7cef);
21752                         MP_WritePhyUshort(sc, 0x06, 0x325b);
21753                         MP_WritePhyUshort(sc, 0x06, 0x80e3);
21754                         MP_WritePhyUshort(sc, 0x06, 0xf87d);
21755                         MP_WritePhyUshort(sc, 0x06, 0x9e03);
21756                         MP_WritePhyUshort(sc, 0x06, 0x7dff);
21757                         MP_WritePhyUshort(sc, 0x06, 0xff0d);
21758                         MP_WritePhyUshort(sc, 0x06, 0x581c);
21759                         MP_WritePhyUshort(sc, 0x06, 0x551a);
21760                         MP_WritePhyUshort(sc, 0x06, 0x6511);
21761                         MP_WritePhyUshort(sc, 0x06, 0xa190);
21762                         MP_WritePhyUshort(sc, 0x06, 0xd3e2);
21763                         MP_WritePhyUshort(sc, 0x06, 0x8348);
21764                         MP_WritePhyUshort(sc, 0x06, 0xe383);
21765                         MP_WritePhyUshort(sc, 0x06, 0x491b);
21766                         MP_WritePhyUshort(sc, 0x06, 0x56ab);
21767                         MP_WritePhyUshort(sc, 0x06, 0x08ef);
21768                         MP_WritePhyUshort(sc, 0x06, 0x56e6);
21769                         MP_WritePhyUshort(sc, 0x06, 0x8348);
21770                         MP_WritePhyUshort(sc, 0x06, 0xe783);
21771                         MP_WritePhyUshort(sc, 0x06, 0x4910);
21772                         MP_WritePhyUshort(sc, 0x06, 0xd180);
21773                         MP_WritePhyUshort(sc, 0x06, 0x1f66);
21774                         MP_WritePhyUshort(sc, 0x06, 0xa004);
21775                         MP_WritePhyUshort(sc, 0x06, 0xb9e2);
21776                         MP_WritePhyUshort(sc, 0x06, 0x8348);
21777                         MP_WritePhyUshort(sc, 0x06, 0xe383);
21778                         MP_WritePhyUshort(sc, 0x06, 0x49ef);
21779                         MP_WritePhyUshort(sc, 0x06, 0x65e2);
21780                         MP_WritePhyUshort(sc, 0x06, 0x834a);
21781                         MP_WritePhyUshort(sc, 0x06, 0xe383);
21782                         MP_WritePhyUshort(sc, 0x06, 0x4b1b);
21783                         MP_WritePhyUshort(sc, 0x06, 0x56aa);
21784                         MP_WritePhyUshort(sc, 0x06, 0x0eef);
21785                         MP_WritePhyUshort(sc, 0x06, 0x56e6);
21786                         MP_WritePhyUshort(sc, 0x06, 0x834a);
21787                         MP_WritePhyUshort(sc, 0x06, 0xe783);
21788                         MP_WritePhyUshort(sc, 0x06, 0x4be2);
21789                         MP_WritePhyUshort(sc, 0x06, 0x834d);
21790                         MP_WritePhyUshort(sc, 0x06, 0xe683);
21791                         MP_WritePhyUshort(sc, 0x06, 0x4ce0);
21792                         MP_WritePhyUshort(sc, 0x06, 0x834d);
21793                         MP_WritePhyUshort(sc, 0x06, 0xa000);
21794                         MP_WritePhyUshort(sc, 0x06, 0x0caf);
21795                         MP_WritePhyUshort(sc, 0x06, 0x81dc);
21796                         MP_WritePhyUshort(sc, 0x06, 0xe083);
21797                         MP_WritePhyUshort(sc, 0x06, 0x4d10);
21798                         MP_WritePhyUshort(sc, 0x06, 0xe483);
21799                         MP_WritePhyUshort(sc, 0x06, 0x4dae);
21800                         MP_WritePhyUshort(sc, 0x06, 0x0480);
21801                         MP_WritePhyUshort(sc, 0x06, 0xe483);
21802                         MP_WritePhyUshort(sc, 0x06, 0x4de0);
21803                         MP_WritePhyUshort(sc, 0x06, 0x834e);
21804                         MP_WritePhyUshort(sc, 0x06, 0x7803);
21805                         MP_WritePhyUshort(sc, 0x06, 0x9e0b);
21806                         MP_WritePhyUshort(sc, 0x06, 0xe083);
21807                         MP_WritePhyUshort(sc, 0x06, 0x4e78);
21808                         MP_WritePhyUshort(sc, 0x06, 0x049e);
21809                         MP_WritePhyUshort(sc, 0x06, 0x04ee);
21810                         MP_WritePhyUshort(sc, 0x06, 0x834e);
21811                         MP_WritePhyUshort(sc, 0x06, 0x02e0);
21812                         MP_WritePhyUshort(sc, 0x06, 0x8332);
21813                         MP_WritePhyUshort(sc, 0x06, 0xe183);
21814                         MP_WritePhyUshort(sc, 0x06, 0x3359);
21815                         MP_WritePhyUshort(sc, 0x06, 0x0fe2);
21816                         MP_WritePhyUshort(sc, 0x06, 0x834d);
21817                         MP_WritePhyUshort(sc, 0x06, 0x0c24);
21818                         MP_WritePhyUshort(sc, 0x06, 0x5af0);
21819                         MP_WritePhyUshort(sc, 0x06, 0x1e12);
21820                         MP_WritePhyUshort(sc, 0x06, 0xe4f8);
21821                         MP_WritePhyUshort(sc, 0x06, 0x8ce5);
21822                         MP_WritePhyUshort(sc, 0x06, 0xf88d);
21823                         MP_WritePhyUshort(sc, 0x06, 0xe083);
21824                         MP_WritePhyUshort(sc, 0x06, 0x30e1);
21825                         MP_WritePhyUshort(sc, 0x06, 0x8331);
21826                         MP_WritePhyUshort(sc, 0x06, 0x6801);
21827                         MP_WritePhyUshort(sc, 0x06, 0xe4f8);
21828                         MP_WritePhyUshort(sc, 0x06, 0x8ae5);
21829                         MP_WritePhyUshort(sc, 0x06, 0xf88b);
21830                         MP_WritePhyUshort(sc, 0x06, 0xae37);
21831                         MP_WritePhyUshort(sc, 0x06, 0xee83);
21832                         MP_WritePhyUshort(sc, 0x06, 0x4e03);
21833                         MP_WritePhyUshort(sc, 0x06, 0xe083);
21834                         MP_WritePhyUshort(sc, 0x06, 0x4ce1);
21835                         MP_WritePhyUshort(sc, 0x06, 0x834d);
21836                         MP_WritePhyUshort(sc, 0x06, 0x1b01);
21837                         MP_WritePhyUshort(sc, 0x06, 0x9e04);
21838                         MP_WritePhyUshort(sc, 0x06, 0xaaa1);
21839                         MP_WritePhyUshort(sc, 0x06, 0xaea8);
21840                         MP_WritePhyUshort(sc, 0x06, 0xee83);
21841                         MP_WritePhyUshort(sc, 0x06, 0x4e04);
21842                         MP_WritePhyUshort(sc, 0x06, 0xee83);
21843                         MP_WritePhyUshort(sc, 0x06, 0x4f00);
21844                         MP_WritePhyUshort(sc, 0x06, 0xaeab);
21845                         MP_WritePhyUshort(sc, 0x06, 0xe083);
21846                         MP_WritePhyUshort(sc, 0x06, 0x4f78);
21847                         MP_WritePhyUshort(sc, 0x06, 0x039f);
21848                         MP_WritePhyUshort(sc, 0x06, 0x14ee);
21849                         MP_WritePhyUshort(sc, 0x06, 0x834e);
21850                         MP_WritePhyUshort(sc, 0x06, 0x05d2);
21851                         MP_WritePhyUshort(sc, 0x06, 0x40d6);
21852                         MP_WritePhyUshort(sc, 0x06, 0x5554);
21853                         MP_WritePhyUshort(sc, 0x06, 0x0282);
21854                         MP_WritePhyUshort(sc, 0x06, 0x17d2);
21855                         MP_WritePhyUshort(sc, 0x06, 0xa0d6);
21856                         MP_WritePhyUshort(sc, 0x06, 0xba00);
21857                         MP_WritePhyUshort(sc, 0x06, 0x0282);
21858                         MP_WritePhyUshort(sc, 0x06, 0x17fe);
21859                         MP_WritePhyUshort(sc, 0x06, 0xfdfc);
21860                         MP_WritePhyUshort(sc, 0x06, 0x05f8);
21861                         MP_WritePhyUshort(sc, 0x06, 0xe0f8);
21862                         MP_WritePhyUshort(sc, 0x06, 0x60e1);
21863                         MP_WritePhyUshort(sc, 0x06, 0xf861);
21864                         MP_WritePhyUshort(sc, 0x06, 0x6802);
21865                         MP_WritePhyUshort(sc, 0x06, 0xe4f8);
21866                         MP_WritePhyUshort(sc, 0x06, 0x60e5);
21867                         MP_WritePhyUshort(sc, 0x06, 0xf861);
21868                         MP_WritePhyUshort(sc, 0x06, 0xe0f8);
21869                         MP_WritePhyUshort(sc, 0x06, 0x48e1);
21870                         MP_WritePhyUshort(sc, 0x06, 0xf849);
21871                         MP_WritePhyUshort(sc, 0x06, 0x580f);
21872                         MP_WritePhyUshort(sc, 0x06, 0x1e02);
21873                         MP_WritePhyUshort(sc, 0x06, 0xe4f8);
21874                         MP_WritePhyUshort(sc, 0x06, 0x48e5);
21875                         MP_WritePhyUshort(sc, 0x06, 0xf849);
21876                         MP_WritePhyUshort(sc, 0x06, 0xd000);
21877                         MP_WritePhyUshort(sc, 0x06, 0x0282);
21878                         MP_WritePhyUshort(sc, 0x06, 0x5bbf);
21879                         MP_WritePhyUshort(sc, 0x06, 0x8350);
21880                         MP_WritePhyUshort(sc, 0x06, 0xef46);
21881                         MP_WritePhyUshort(sc, 0x06, 0xdc19);
21882                         MP_WritePhyUshort(sc, 0x06, 0xddd0);
21883                         MP_WritePhyUshort(sc, 0x06, 0x0102);
21884                         MP_WritePhyUshort(sc, 0x06, 0x825b);
21885                         MP_WritePhyUshort(sc, 0x06, 0x0282);
21886                         MP_WritePhyUshort(sc, 0x06, 0x77e0);
21887                         MP_WritePhyUshort(sc, 0x06, 0xf860);
21888                         MP_WritePhyUshort(sc, 0x06, 0xe1f8);
21889                         MP_WritePhyUshort(sc, 0x06, 0x6158);
21890                         MP_WritePhyUshort(sc, 0x06, 0xfde4);
21891                         MP_WritePhyUshort(sc, 0x06, 0xf860);
21892                         MP_WritePhyUshort(sc, 0x06, 0xe5f8);
21893                         MP_WritePhyUshort(sc, 0x06, 0x61fc);
21894                         MP_WritePhyUshort(sc, 0x06, 0x04f9);
21895                         MP_WritePhyUshort(sc, 0x06, 0xfafb);
21896                         MP_WritePhyUshort(sc, 0x06, 0xc6bf);
21897                         MP_WritePhyUshort(sc, 0x06, 0xf840);
21898                         MP_WritePhyUshort(sc, 0x06, 0xbe83);
21899                         MP_WritePhyUshort(sc, 0x06, 0x50a0);
21900                         MP_WritePhyUshort(sc, 0x06, 0x0101);
21901                         MP_WritePhyUshort(sc, 0x06, 0x071b);
21902                         MP_WritePhyUshort(sc, 0x06, 0x89cf);
21903                         MP_WritePhyUshort(sc, 0x06, 0xd208);
21904                         MP_WritePhyUshort(sc, 0x06, 0xebdb);
21905                         MP_WritePhyUshort(sc, 0x06, 0x19b2);
21906                         MP_WritePhyUshort(sc, 0x06, 0xfbff);
21907                         MP_WritePhyUshort(sc, 0x06, 0xfefd);
21908                         MP_WritePhyUshort(sc, 0x06, 0x04f8);
21909                         MP_WritePhyUshort(sc, 0x06, 0xe0f8);
21910                         MP_WritePhyUshort(sc, 0x06, 0x48e1);
21911                         MP_WritePhyUshort(sc, 0x06, 0xf849);
21912                         MP_WritePhyUshort(sc, 0x06, 0x6808);
21913                         MP_WritePhyUshort(sc, 0x06, 0xe4f8);
21914                         MP_WritePhyUshort(sc, 0x06, 0x48e5);
21915                         MP_WritePhyUshort(sc, 0x06, 0xf849);
21916                         MP_WritePhyUshort(sc, 0x06, 0x58f7);
21917                         MP_WritePhyUshort(sc, 0x06, 0xe4f8);
21918                         MP_WritePhyUshort(sc, 0x06, 0x48e5);
21919                         MP_WritePhyUshort(sc, 0x06, 0xf849);
21920                         MP_WritePhyUshort(sc, 0x06, 0xfc04);
21921                         MP_WritePhyUshort(sc, 0x06, 0x4d20);
21922                         MP_WritePhyUshort(sc, 0x06, 0x0002);
21923                         MP_WritePhyUshort(sc, 0x06, 0x4e22);
21924                         MP_WritePhyUshort(sc, 0x06, 0x0002);
21925                         MP_WritePhyUshort(sc, 0x06, 0x4ddf);
21926                         MP_WritePhyUshort(sc, 0x06, 0xff01);
21927                         MP_WritePhyUshort(sc, 0x06, 0x4edd);
21928                         MP_WritePhyUshort(sc, 0x06, 0xff01);
21929                         MP_WritePhyUshort(sc, 0x06, 0xf8fa);
21930                         MP_WritePhyUshort(sc, 0x06, 0xfbef);
21931                         MP_WritePhyUshort(sc, 0x06, 0x79bf);
21932                         MP_WritePhyUshort(sc, 0x06, 0xf822);
21933                         MP_WritePhyUshort(sc, 0x06, 0xd819);
21934                         MP_WritePhyUshort(sc, 0x06, 0xd958);
21935                         MP_WritePhyUshort(sc, 0x06, 0x849f);
21936                         MP_WritePhyUshort(sc, 0x06, 0x09bf);
21937                         MP_WritePhyUshort(sc, 0x06, 0x82be);
21938                         MP_WritePhyUshort(sc, 0x06, 0xd682);
21939                         MP_WritePhyUshort(sc, 0x06, 0xc602);
21940                         MP_WritePhyUshort(sc, 0x06, 0x014f);
21941                         MP_WritePhyUshort(sc, 0x06, 0xef97);
21942                         MP_WritePhyUshort(sc, 0x06, 0xfffe);
21943                         MP_WritePhyUshort(sc, 0x06, 0xfc05);
21944                         MP_WritePhyUshort(sc, 0x06, 0x17ff);
21945                         MP_WritePhyUshort(sc, 0x06, 0xfe01);
21946                         MP_WritePhyUshort(sc, 0x06, 0x1700);
21947                         MP_WritePhyUshort(sc, 0x06, 0x0102);
21948                         MP_WritePhyUshort(sc, 0x05, 0x83d8);
21949                         MP_WritePhyUshort(sc, 0x06, 0x8051);
21950                         MP_WritePhyUshort(sc, 0x05, 0x83d6);
21951                         MP_WritePhyUshort(sc, 0x06, 0x82a0);
21952                         MP_WritePhyUshort(sc, 0x05, 0x83d4);
21953                         MP_WritePhyUshort(sc, 0x06, 0x8000);
21954                         MP_WritePhyUshort(sc, 0x02, 0x2010);
21955                         MP_WritePhyUshort(sc, 0x03, 0xdc00);
21956                         MP_WritePhyUshort(sc, 0x1f, 0x0000);
21957                         MP_WritePhyUshort(sc, 0x0b, 0x0600);
21958                         MP_WritePhyUshort(sc, 0x1f, 0x0005);
21959                         MP_WritePhyUshort(sc, 0x05, 0xfff6);
21960                         MP_WritePhyUshort(sc, 0x06, 0x00fc);
21961                         MP_WritePhyUshort(sc, 0x1f, 0x0000);
21962                 }
21963
21964                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21965                 MP_WritePhyUshort(sc, 0x0D, 0xF880);
21966                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21967         } else if (sc->re_type == MACFG_32) {
21968                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
21969                 MP_WritePhyUshort(sc, 0x06, 0x4064);
21970                 MP_WritePhyUshort(sc, 0x07, 0x2863);
21971                 MP_WritePhyUshort(sc, 0x08, 0x059C);
21972                 MP_WritePhyUshort(sc, 0x09, 0x26B4);
21973                 MP_WritePhyUshort(sc, 0x0A, 0x6A19);
21974                 MP_WritePhyUshort(sc, 0x0B, 0xBCC0);
21975                 MP_WritePhyUshort(sc, 0x10, 0xF06D);
21976                 MP_WritePhyUshort(sc, 0x14, 0x7F68);
21977                 MP_WritePhyUshort(sc, 0x18, 0x7FD9);
21978                 MP_WritePhyUshort(sc, 0x1C, 0xF0FF);
21979                 MP_WritePhyUshort(sc, 0x1D, 0x3D9C);
21980                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
21981                 MP_WritePhyUshort(sc, 0x12, 0xF49F);
21982                 MP_WritePhyUshort(sc, 0x13, 0x070B);
21983                 MP_WritePhyUshort(sc, 0x1A, 0x05AD);
21984                 MP_WritePhyUshort(sc, 0x14, 0x94C0);
21985
21986                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21987                 MP_WritePhyUshort(sc, 0x06, 0x5571);
21988
21989                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21990                 MP_WritePhyUshort(sc, 0x05, 0x2642);
21991
21992                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21993                 MP_WritePhyUshort(sc, 0x02, 0xC107);
21994                 MP_WritePhyUshort(sc, 0x03, 0x1002);
21995
21996                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
21997                 MP_WritePhyUshort(sc, 0x16, 0x0CC0);
21998
21999                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
22000                 MP_WritePhyUshort(sc, 0x0F, 0x0017);
22001
22002                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
22003                 MP_WritePhyUshort(sc, 0x05, 0x8200);
22004                 MP_WritePhyUshort(sc, 0x06, 0xF8F9);
22005                 MP_WritePhyUshort(sc, 0x06, 0xFAEF);
22006                 MP_WritePhyUshort(sc, 0x06, 0x59EE);
22007                 MP_WritePhyUshort(sc, 0x06, 0xF8EA);
22008                 MP_WritePhyUshort(sc, 0x06, 0x00EE);
22009                 MP_WritePhyUshort(sc, 0x06, 0xF8EB);
22010                 MP_WritePhyUshort(sc, 0x06, 0x00E0);
22011                 MP_WritePhyUshort(sc, 0x06, 0xF87C);
22012                 MP_WritePhyUshort(sc, 0x06, 0xE1F8);
22013                 MP_WritePhyUshort(sc, 0x06, 0x7D59);
22014                 MP_WritePhyUshort(sc, 0x06, 0x0FEF);
22015                 MP_WritePhyUshort(sc, 0x06, 0x0139);
22016                 MP_WritePhyUshort(sc, 0x06, 0x029E);
22017                 MP_WritePhyUshort(sc, 0x06, 0x06EF);
22018                 MP_WritePhyUshort(sc, 0x06, 0x1039);
22019                 MP_WritePhyUshort(sc, 0x06, 0x089F);
22020                 MP_WritePhyUshort(sc, 0x06, 0x2AEE);
22021                 MP_WritePhyUshort(sc, 0x06, 0xF8EA);
22022                 MP_WritePhyUshort(sc, 0x06, 0x00EE);
22023                 MP_WritePhyUshort(sc, 0x06, 0xF8EB);
22024                 MP_WritePhyUshort(sc, 0x06, 0x01E0);
22025                 MP_WritePhyUshort(sc, 0x06, 0xF87C);
22026                 MP_WritePhyUshort(sc, 0x06, 0xE1F8);
22027                 MP_WritePhyUshort(sc, 0x06, 0x7D58);
22028                 MP_WritePhyUshort(sc, 0x06, 0x409E);
22029                 MP_WritePhyUshort(sc, 0x06, 0x0F39);
22030                 MP_WritePhyUshort(sc, 0x06, 0x46AA);
22031                 MP_WritePhyUshort(sc, 0x06, 0x0BBF);
22032                 MP_WritePhyUshort(sc, 0x06, 0x8251);
22033                 MP_WritePhyUshort(sc, 0x06, 0xD682);
22034                 MP_WritePhyUshort(sc, 0x06, 0x5902);
22035                 MP_WritePhyUshort(sc, 0x06, 0x014F);
22036                 MP_WritePhyUshort(sc, 0x06, 0xAE09);
22037                 MP_WritePhyUshort(sc, 0x06, 0xBF82);
22038                 MP_WritePhyUshort(sc, 0x06, 0x59D6);
22039                 MP_WritePhyUshort(sc, 0x06, 0x8261);
22040                 MP_WritePhyUshort(sc, 0x06, 0x0201);
22041                 MP_WritePhyUshort(sc, 0x06, 0x4FEF);
22042                 MP_WritePhyUshort(sc, 0x06, 0x95FE);
22043                 MP_WritePhyUshort(sc, 0x06, 0xFDFC);
22044                 MP_WritePhyUshort(sc, 0x06, 0x054D);
22045                 MP_WritePhyUshort(sc, 0x06, 0x2000);
22046                 MP_WritePhyUshort(sc, 0x06, 0x024E);
22047                 MP_WritePhyUshort(sc, 0x06, 0x2200);
22048                 MP_WritePhyUshort(sc, 0x06, 0x024D);
22049                 MP_WritePhyUshort(sc, 0x06, 0xDFFF);
22050                 MP_WritePhyUshort(sc, 0x06, 0x014E);
22051                 MP_WritePhyUshort(sc, 0x06, 0xDDFF);
22052                 MP_WritePhyUshort(sc, 0x06, 0x0100);
22053                 MP_WritePhyUshort(sc, 0x02, 0x6010);
22054                 MP_WritePhyUshort(sc, 0x05, 0xFFF6);
22055                 MP_WritePhyUshort(sc, 0x06, 0x00EC);
22056                 MP_WritePhyUshort(sc, 0x05, 0x83D4);
22057                 MP_WritePhyUshort(sc, 0x06, 0x8200);
22058
22059         } else if (sc->re_type == MACFG_33) {
22060                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
22061                 MP_WritePhyUshort(sc, 0x06, 0x4064);
22062                 MP_WritePhyUshort(sc, 0x07, 0x2863);
22063                 MP_WritePhyUshort(sc, 0x08, 0x059C);
22064                 MP_WritePhyUshort(sc, 0x09, 0x26B4);
22065                 MP_WritePhyUshort(sc, 0x0A, 0x6A19);
22066                 MP_WritePhyUshort(sc, 0x0B, 0xDCC8);
22067                 MP_WritePhyUshort(sc, 0x10, 0xF06D);
22068                 MP_WritePhyUshort(sc, 0x14, 0x7F68);
22069                 MP_WritePhyUshort(sc, 0x18, 0x7FD9);
22070                 MP_WritePhyUshort(sc, 0x1C, 0xF0FF);
22071                 MP_WritePhyUshort(sc, 0x1D, 0x3D9C);
22072                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
22073                 MP_WritePhyUshort(sc, 0x12, 0xF49F);
22074                 MP_WritePhyUshort(sc, 0x13, 0x070B);
22075                 MP_WritePhyUshort(sc, 0x1A, 0x05AD);
22076                 MP_WritePhyUshort(sc, 0x14, 0x94C0);
22077
22078                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
22079                 MP_WritePhyUshort(sc, 0x06, 0x5561);
22080                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
22081                 MP_WritePhyUshort(sc, 0x05, 0x8332);
22082                 MP_WritePhyUshort(sc, 0x06, 0x5561);
22083
22084                 if (MP_ReadEfuse(sc, 0x01) == 0xb1) {
22085                         MP_WritePhyUshort(sc, 0x1F, 0x0002);
22086                         MP_WritePhyUshort(sc, 0x05, 0x669A);
22087                         MP_WritePhyUshort(sc, 0x1F, 0x0005);
22088                         MP_WritePhyUshort(sc, 0x05, 0x8330);
22089                         MP_WritePhyUshort(sc, 0x06, 0x669A);
22090
22091                         MP_WritePhyUshort(sc, 0x1F, 0x0002);
22092                         Data = MP_ReadPhyUshort(sc, 0x0D);
22093                         if ((Data & 0x00FF) != 0x006C) {
22094                                 Data &= 0xFF00;
22095                                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
22096                                 MP_WritePhyUshort(sc, 0x0D, Data | 0x0065);
22097                                 MP_WritePhyUshort(sc, 0x0D, Data | 0x0066);
22098                                 MP_WritePhyUshort(sc, 0x0D, Data | 0x0067);
22099                                 MP_WritePhyUshort(sc, 0x0D, Data | 0x0068);
22100                                 MP_WritePhyUshort(sc, 0x0D, Data | 0x0069);
22101                                 MP_WritePhyUshort(sc, 0x0D, Data | 0x006A);
22102                                 MP_WritePhyUshort(sc, 0x0D, Data | 0x006B);
22103                                 MP_WritePhyUshort(sc, 0x0D, Data | 0x006C);
22104                         }
22105                 } else {
22106                         MP_WritePhyUshort(sc, 0x1F, 0x0002);
22107                         MP_WritePhyUshort(sc, 0x05, 0x2642);
22108                         MP_WritePhyUshort(sc, 0x1F, 0x0005);
22109                         MP_WritePhyUshort(sc, 0x05, 0x8330);
22110                         MP_WritePhyUshort(sc, 0x06, 0x2642);
22111                 }
22112
22113                 if (MP_ReadEfuse(sc, 0x30) == 0x98) {
22114                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
22115                         MP_WritePhyUshort(sc, 0x11, MP_ReadPhyUshort(sc, 0x11) & ~0x02);
22116                         MP_WritePhyUshort(sc, 0x1F, 0x0005);
22117                         MP_WritePhyUshort(sc, 0x01, MP_ReadPhyUshort(sc, 0x01) | 0x200);
22118                 } else if (MP_ReadEfuse(sc, 0x30) == 0x90) {
22119                         MP_WritePhyUshort(sc, 0x1F, 0x0005);
22120                         MP_WritePhyUshort(sc, 0x01, MP_ReadPhyUshort(sc, 0x01) & ~0x200);
22121                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
22122                         MP_WritePhyUshort(sc, 0x16, 0x5101);
22123                 }
22124
22125                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
22126                 Data = MP_ReadPhyUshort(sc, 0x02);
22127                 Data &= ~0x600;
22128                 Data |= 0x100;
22129                 MP_WritePhyUshort(sc, 0x02, Data);
22130                 Data = MP_ReadPhyUshort(sc, 0x03);
22131                 Data &= ~0xE000;
22132                 MP_WritePhyUshort(sc, 0x03, Data);
22133
22134                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
22135                 MP_WritePhyUshort(sc, 0x17, 0x0CC0);
22136
22137                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
22138                 Data = MP_ReadPhyUshort(sc, 0x0F);
22139                 Data |= 0x17;
22140                 MP_WritePhyUshort(sc, 0x0F, Data);
22141
22142                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
22143                 MP_WritePhyUshort(sc, 0x05, 0x001B);
22144                 if (MP_ReadPhyUshort(sc, 0x06) == 0xB300) {
22145                         MP_WritePhyUshort(sc, 0x1f, 0x0005);
22146                         MP_WritePhyUshort(sc, 0x05, 0xfff6);
22147                         MP_WritePhyUshort(sc, 0x06, 0x0080);
22148                         MP_WritePhyUshort(sc, 0x05, 0x8000);
22149                         MP_WritePhyUshort(sc, 0x06, 0xf8f9);
22150                         MP_WritePhyUshort(sc, 0x06, 0xfaee);
22151                         MP_WritePhyUshort(sc, 0x06, 0xf8ea);
22152                         MP_WritePhyUshort(sc, 0x06, 0x00ee);
22153                         MP_WritePhyUshort(sc, 0x06, 0xf8eb);
22154                         MP_WritePhyUshort(sc, 0x06, 0x00e2);
22155                         MP_WritePhyUshort(sc, 0x06, 0xf87c);
22156                         MP_WritePhyUshort(sc, 0x06, 0xe3f8);
22157                         MP_WritePhyUshort(sc, 0x06, 0x7da5);
22158                         MP_WritePhyUshort(sc, 0x06, 0x1111);
22159                         MP_WritePhyUshort(sc, 0x06, 0x12d2);
22160                         MP_WritePhyUshort(sc, 0x06, 0x40d6);
22161                         MP_WritePhyUshort(sc, 0x06, 0x4444);
22162                         MP_WritePhyUshort(sc, 0x06, 0x0281);
22163                         MP_WritePhyUshort(sc, 0x06, 0xc6d2);
22164                         MP_WritePhyUshort(sc, 0x06, 0xa0d6);
22165                         MP_WritePhyUshort(sc, 0x06, 0xaaaa);
22166                         MP_WritePhyUshort(sc, 0x06, 0x0281);
22167                         MP_WritePhyUshort(sc, 0x06, 0xc6ae);
22168                         MP_WritePhyUshort(sc, 0x06, 0x0fa5);
22169                         MP_WritePhyUshort(sc, 0x06, 0x4444);
22170                         MP_WritePhyUshort(sc, 0x06, 0x02ae);
22171                         MP_WritePhyUshort(sc, 0x06, 0x4da5);
22172                         MP_WritePhyUshort(sc, 0x06, 0xaaaa);
22173                         MP_WritePhyUshort(sc, 0x06, 0x02ae);
22174                         MP_WritePhyUshort(sc, 0x06, 0x47af);
22175                         MP_WritePhyUshort(sc, 0x06, 0x81c2);
22176                         MP_WritePhyUshort(sc, 0x06, 0xee83);
22177                         MP_WritePhyUshort(sc, 0x06, 0x4e00);
22178                         MP_WritePhyUshort(sc, 0x06, 0xee83);
22179                         MP_WritePhyUshort(sc, 0x06, 0x4d0f);
22180                         MP_WritePhyUshort(sc, 0x06, 0xee83);
22181                         MP_WritePhyUshort(sc, 0x06, 0x4c0f);
22182                         MP_WritePhyUshort(sc, 0x06, 0xee83);
22183                         MP_WritePhyUshort(sc, 0x06, 0x4f00);
22184                         MP_WritePhyUshort(sc, 0x06, 0xee83);
22185                         MP_WritePhyUshort(sc, 0x06, 0x5100);
22186                         MP_WritePhyUshort(sc, 0x06, 0xee83);
22187                         MP_WritePhyUshort(sc, 0x06, 0x4aff);
22188                         MP_WritePhyUshort(sc, 0x06, 0xee83);
22189                         MP_WritePhyUshort(sc, 0x06, 0x4bff);
22190                         MP_WritePhyUshort(sc, 0x06, 0xe083);
22191                         MP_WritePhyUshort(sc, 0x06, 0x30e1);
22192                         MP_WritePhyUshort(sc, 0x06, 0x8331);
22193                         MP_WritePhyUshort(sc, 0x06, 0x58fe);
22194                         MP_WritePhyUshort(sc, 0x06, 0xe4f8);
22195                         MP_WritePhyUshort(sc, 0x06, 0x8ae5);
22196                         MP_WritePhyUshort(sc, 0x06, 0xf88b);
22197                         MP_WritePhyUshort(sc, 0x06, 0xe083);
22198                         MP_WritePhyUshort(sc, 0x06, 0x32e1);
22199                         MP_WritePhyUshort(sc, 0x06, 0x8333);
22200                         MP_WritePhyUshort(sc, 0x06, 0x590f);
22201                         MP_WritePhyUshort(sc, 0x06, 0xe283);
22202                         MP_WritePhyUshort(sc, 0x06, 0x4d0c);
22203                         MP_WritePhyUshort(sc, 0x06, 0x245a);
22204                         MP_WritePhyUshort(sc, 0x06, 0xf01e);
22205                         MP_WritePhyUshort(sc, 0x06, 0x12e4);
22206                         MP_WritePhyUshort(sc, 0x06, 0xf88c);
22207                         MP_WritePhyUshort(sc, 0x06, 0xe5f8);
22208                         MP_WritePhyUshort(sc, 0x06, 0x8daf);
22209                         MP_WritePhyUshort(sc, 0x06, 0x81c2);
22210                         MP_WritePhyUshort(sc, 0x06, 0xe083);
22211                         MP_WritePhyUshort(sc, 0x06, 0x4f10);
22212                         MP_WritePhyUshort(sc, 0x06, 0xe483);
22213                         MP_WritePhyUshort(sc, 0x06, 0x4fe0);
22214                         MP_WritePhyUshort(sc, 0x06, 0x834e);
22215                         MP_WritePhyUshort(sc, 0x06, 0x7800);
22216                         MP_WritePhyUshort(sc, 0x06, 0x9f0a);
22217                         MP_WritePhyUshort(sc, 0x06, 0xe083);
22218                         MP_WritePhyUshort(sc, 0x06, 0x4fa0);
22219                         MP_WritePhyUshort(sc, 0x06, 0x10a5);
22220                         MP_WritePhyUshort(sc, 0x06, 0xee83);
22221                         MP_WritePhyUshort(sc, 0x06, 0x4e01);
22222                         MP_WritePhyUshort(sc, 0x06, 0xe083);
22223                         MP_WritePhyUshort(sc, 0x06, 0x4e78);
22224                         MP_WritePhyUshort(sc, 0x06, 0x059e);
22225                         MP_WritePhyUshort(sc, 0x06, 0x9ae0);
22226                         MP_WritePhyUshort(sc, 0x06, 0x834e);
22227                         MP_WritePhyUshort(sc, 0x06, 0x7804);
22228                         MP_WritePhyUshort(sc, 0x06, 0x9e10);
22229                         MP_WritePhyUshort(sc, 0x06, 0xe083);
22230                         MP_WritePhyUshort(sc, 0x06, 0x4e78);
22231                         MP_WritePhyUshort(sc, 0x06, 0x039e);
22232                         MP_WritePhyUshort(sc, 0x06, 0x0fe0);
22233                         MP_WritePhyUshort(sc, 0x06, 0x834e);
22234                         MP_WritePhyUshort(sc, 0x06, 0x7801);
22235                         MP_WritePhyUshort(sc, 0x06, 0x9e05);
22236                         MP_WritePhyUshort(sc, 0x06, 0xae0c);
22237                         MP_WritePhyUshort(sc, 0x06, 0xaf81);
22238                         MP_WritePhyUshort(sc, 0x06, 0xa7af);
22239                         MP_WritePhyUshort(sc, 0x06, 0x8152);
22240                         MP_WritePhyUshort(sc, 0x06, 0xaf81);
22241                         MP_WritePhyUshort(sc, 0x06, 0x8baf);
22242                         MP_WritePhyUshort(sc, 0x06, 0x81c2);
22243                         MP_WritePhyUshort(sc, 0x06, 0xee83);
22244                         MP_WritePhyUshort(sc, 0x06, 0x4800);
22245                         MP_WritePhyUshort(sc, 0x06, 0xee83);
22246                         MP_WritePhyUshort(sc, 0x06, 0x4900);
22247                         MP_WritePhyUshort(sc, 0x06, 0xe083);
22248                         MP_WritePhyUshort(sc, 0x06, 0x5110);
22249                         MP_WritePhyUshort(sc, 0x06, 0xe483);
22250                         MP_WritePhyUshort(sc, 0x06, 0x5158);
22251                         MP_WritePhyUshort(sc, 0x06, 0x019f);
22252                         MP_WritePhyUshort(sc, 0x06, 0xead0);
22253                         MP_WritePhyUshort(sc, 0x06, 0x00d1);
22254                         MP_WritePhyUshort(sc, 0x06, 0x801f);
22255                         MP_WritePhyUshort(sc, 0x06, 0x66e2);
22256                         MP_WritePhyUshort(sc, 0x06, 0xf8ea);
22257                         MP_WritePhyUshort(sc, 0x06, 0xe3f8);
22258                         MP_WritePhyUshort(sc, 0x06, 0xeb5a);
22259                         MP_WritePhyUshort(sc, 0x06, 0xf81e);
22260                         MP_WritePhyUshort(sc, 0x06, 0x20e6);
22261                         MP_WritePhyUshort(sc, 0x06, 0xf8ea);
22262                         MP_WritePhyUshort(sc, 0x06, 0xe5f8);
22263                         MP_WritePhyUshort(sc, 0x06, 0xebd3);
22264                         MP_WritePhyUshort(sc, 0x06, 0x02b3);
22265                         MP_WritePhyUshort(sc, 0x06, 0xfee2);
22266                         MP_WritePhyUshort(sc, 0x06, 0xf87c);
22267                         MP_WritePhyUshort(sc, 0x06, 0xef32);
22268                         MP_WritePhyUshort(sc, 0x06, 0x5b80);
22269                         MP_WritePhyUshort(sc, 0x06, 0xe3f8);
22270                         MP_WritePhyUshort(sc, 0x06, 0x7d9e);
22271                         MP_WritePhyUshort(sc, 0x06, 0x037d);
22272                         MP_WritePhyUshort(sc, 0x06, 0xffff);
22273                         MP_WritePhyUshort(sc, 0x06, 0x0d58);
22274                         MP_WritePhyUshort(sc, 0x06, 0x1c55);
22275                         MP_WritePhyUshort(sc, 0x06, 0x1a65);
22276                         MP_WritePhyUshort(sc, 0x06, 0x11a1);
22277                         MP_WritePhyUshort(sc, 0x06, 0x90d3);
22278                         MP_WritePhyUshort(sc, 0x06, 0xe283);
22279                         MP_WritePhyUshort(sc, 0x06, 0x48e3);
22280                         MP_WritePhyUshort(sc, 0x06, 0x8349);
22281                         MP_WritePhyUshort(sc, 0x06, 0x1b56);
22282                         MP_WritePhyUshort(sc, 0x06, 0xab08);
22283                         MP_WritePhyUshort(sc, 0x06, 0xef56);
22284                         MP_WritePhyUshort(sc, 0x06, 0xe683);
22285                         MP_WritePhyUshort(sc, 0x06, 0x48e7);
22286                         MP_WritePhyUshort(sc, 0x06, 0x8349);
22287                         MP_WritePhyUshort(sc, 0x06, 0x10d1);
22288                         MP_WritePhyUshort(sc, 0x06, 0x801f);
22289                         MP_WritePhyUshort(sc, 0x06, 0x66a0);
22290                         MP_WritePhyUshort(sc, 0x06, 0x04b9);
22291                         MP_WritePhyUshort(sc, 0x06, 0xe283);
22292                         MP_WritePhyUshort(sc, 0x06, 0x48e3);
22293                         MP_WritePhyUshort(sc, 0x06, 0x8349);
22294                         MP_WritePhyUshort(sc, 0x06, 0xef65);
22295                         MP_WritePhyUshort(sc, 0x06, 0xe283);
22296                         MP_WritePhyUshort(sc, 0x06, 0x4ae3);
22297                         MP_WritePhyUshort(sc, 0x06, 0x834b);
22298                         MP_WritePhyUshort(sc, 0x06, 0x1b56);
22299                         MP_WritePhyUshort(sc, 0x06, 0xaa0e);
22300                         MP_WritePhyUshort(sc, 0x06, 0xef56);
22301                         MP_WritePhyUshort(sc, 0x06, 0xe683);
22302                         MP_WritePhyUshort(sc, 0x06, 0x4ae7);
22303                         MP_WritePhyUshort(sc, 0x06, 0x834b);
22304                         MP_WritePhyUshort(sc, 0x06, 0xe283);
22305                         MP_WritePhyUshort(sc, 0x06, 0x4de6);
22306                         MP_WritePhyUshort(sc, 0x06, 0x834c);
22307                         MP_WritePhyUshort(sc, 0x06, 0xe083);
22308                         MP_WritePhyUshort(sc, 0x06, 0x4da0);
22309                         MP_WritePhyUshort(sc, 0x06, 0x000c);
22310                         MP_WritePhyUshort(sc, 0x06, 0xaf81);
22311                         MP_WritePhyUshort(sc, 0x06, 0x8be0);
22312                         MP_WritePhyUshort(sc, 0x06, 0x834d);
22313                         MP_WritePhyUshort(sc, 0x06, 0x10e4);
22314                         MP_WritePhyUshort(sc, 0x06, 0x834d);
22315                         MP_WritePhyUshort(sc, 0x06, 0xae04);
22316                         MP_WritePhyUshort(sc, 0x06, 0x80e4);
22317                         MP_WritePhyUshort(sc, 0x06, 0x834d);
22318                         MP_WritePhyUshort(sc, 0x06, 0xe083);
22319                         MP_WritePhyUshort(sc, 0x06, 0x4e78);
22320                         MP_WritePhyUshort(sc, 0x06, 0x039e);
22321                         MP_WritePhyUshort(sc, 0x06, 0x0be0);
22322                         MP_WritePhyUshort(sc, 0x06, 0x834e);
22323                         MP_WritePhyUshort(sc, 0x06, 0x7804);
22324                         MP_WritePhyUshort(sc, 0x06, 0x9e04);
22325                         MP_WritePhyUshort(sc, 0x06, 0xee83);
22326                         MP_WritePhyUshort(sc, 0x06, 0x4e02);
22327                         MP_WritePhyUshort(sc, 0x06, 0xe083);
22328                         MP_WritePhyUshort(sc, 0x06, 0x32e1);
22329                         MP_WritePhyUshort(sc, 0x06, 0x8333);
22330                         MP_WritePhyUshort(sc, 0x06, 0x590f);
22331                         MP_WritePhyUshort(sc, 0x06, 0xe283);
22332                         MP_WritePhyUshort(sc, 0x06, 0x4d0c);
22333                         MP_WritePhyUshort(sc, 0x06, 0x245a);
22334                         MP_WritePhyUshort(sc, 0x06, 0xf01e);
22335                         MP_WritePhyUshort(sc, 0x06, 0x12e4);
22336                         MP_WritePhyUshort(sc, 0x06, 0xf88c);
22337                         MP_WritePhyUshort(sc, 0x06, 0xe5f8);
22338                         MP_WritePhyUshort(sc, 0x06, 0x8de0);
22339                         MP_WritePhyUshort(sc, 0x06, 0x8330);
22340                         MP_WritePhyUshort(sc, 0x06, 0xe183);
22341                         MP_WritePhyUshort(sc, 0x06, 0x3168);
22342                         MP_WritePhyUshort(sc, 0x06, 0x01e4);
22343                         MP_WritePhyUshort(sc, 0x06, 0xf88a);
22344                         MP_WritePhyUshort(sc, 0x06, 0xe5f8);
22345                         MP_WritePhyUshort(sc, 0x06, 0x8bae);
22346                         MP_WritePhyUshort(sc, 0x06, 0x37ee);
22347                         MP_WritePhyUshort(sc, 0x06, 0x834e);
22348                         MP_WritePhyUshort(sc, 0x06, 0x03e0);
22349                         MP_WritePhyUshort(sc, 0x06, 0x834c);
22350                         MP_WritePhyUshort(sc, 0x06, 0xe183);
22351                         MP_WritePhyUshort(sc, 0x06, 0x4d1b);
22352                         MP_WritePhyUshort(sc, 0x06, 0x019e);
22353                         MP_WritePhyUshort(sc, 0x06, 0x04aa);
22354                         MP_WritePhyUshort(sc, 0x06, 0xa1ae);
22355                         MP_WritePhyUshort(sc, 0x06, 0xa8ee);
22356                         MP_WritePhyUshort(sc, 0x06, 0x834e);
22357                         MP_WritePhyUshort(sc, 0x06, 0x04ee);
22358                         MP_WritePhyUshort(sc, 0x06, 0x834f);
22359                         MP_WritePhyUshort(sc, 0x06, 0x00ae);
22360                         MP_WritePhyUshort(sc, 0x06, 0xabe0);
22361                         MP_WritePhyUshort(sc, 0x06, 0x834f);
22362                         MP_WritePhyUshort(sc, 0x06, 0x7803);
22363                         MP_WritePhyUshort(sc, 0x06, 0x9f14);
22364                         MP_WritePhyUshort(sc, 0x06, 0xee83);
22365                         MP_WritePhyUshort(sc, 0x06, 0x4e05);
22366                         MP_WritePhyUshort(sc, 0x06, 0xd240);
22367                         MP_WritePhyUshort(sc, 0x06, 0xd655);
22368                         MP_WritePhyUshort(sc, 0x06, 0x5402);
22369                         MP_WritePhyUshort(sc, 0x06, 0x81c6);
22370                         MP_WritePhyUshort(sc, 0x06, 0xd2a0);
22371                         MP_WritePhyUshort(sc, 0x06, 0xd6ba);
22372                         MP_WritePhyUshort(sc, 0x06, 0x0002);
22373                         MP_WritePhyUshort(sc, 0x06, 0x81c6);
22374                         MP_WritePhyUshort(sc, 0x06, 0xfefd);
22375                         MP_WritePhyUshort(sc, 0x06, 0xfc05);
22376                         MP_WritePhyUshort(sc, 0x06, 0xf8e0);
22377                         MP_WritePhyUshort(sc, 0x06, 0xf860);
22378                         MP_WritePhyUshort(sc, 0x06, 0xe1f8);
22379                         MP_WritePhyUshort(sc, 0x06, 0x6168);
22380                         MP_WritePhyUshort(sc, 0x06, 0x02e4);
22381                         MP_WritePhyUshort(sc, 0x06, 0xf860);
22382                         MP_WritePhyUshort(sc, 0x06, 0xe5f8);
22383                         MP_WritePhyUshort(sc, 0x06, 0x61e0);
22384                         MP_WritePhyUshort(sc, 0x06, 0xf848);
22385                         MP_WritePhyUshort(sc, 0x06, 0xe1f8);
22386                         MP_WritePhyUshort(sc, 0x06, 0x4958);
22387                         MP_WritePhyUshort(sc, 0x06, 0x0f1e);
22388                         MP_WritePhyUshort(sc, 0x06, 0x02e4);
22389                         MP_WritePhyUshort(sc, 0x06, 0xf848);
22390                         MP_WritePhyUshort(sc, 0x06, 0xe5f8);
22391                         MP_WritePhyUshort(sc, 0x06, 0x49d0);
22392                         MP_WritePhyUshort(sc, 0x06, 0x0002);
22393                         MP_WritePhyUshort(sc, 0x06, 0x820a);
22394                         MP_WritePhyUshort(sc, 0x06, 0xbf83);
22395                         MP_WritePhyUshort(sc, 0x06, 0x50ef);
22396                         MP_WritePhyUshort(sc, 0x06, 0x46dc);
22397                         MP_WritePhyUshort(sc, 0x06, 0x19dd);
22398                         MP_WritePhyUshort(sc, 0x06, 0xd001);
22399                         MP_WritePhyUshort(sc, 0x06, 0x0282);
22400                         MP_WritePhyUshort(sc, 0x06, 0x0a02);
22401                         MP_WritePhyUshort(sc, 0x06, 0x8226);
22402                         MP_WritePhyUshort(sc, 0x06, 0xe0f8);
22403                         MP_WritePhyUshort(sc, 0x06, 0x60e1);
22404                         MP_WritePhyUshort(sc, 0x06, 0xf861);
22405                         MP_WritePhyUshort(sc, 0x06, 0x58fd);
22406                         MP_WritePhyUshort(sc, 0x06, 0xe4f8);
22407                         MP_WritePhyUshort(sc, 0x06, 0x60e5);
22408                         MP_WritePhyUshort(sc, 0x06, 0xf861);
22409                         MP_WritePhyUshort(sc, 0x06, 0xfc04);
22410                         MP_WritePhyUshort(sc, 0x06, 0xf9fa);
22411                         MP_WritePhyUshort(sc, 0x06, 0xfbc6);
22412                         MP_WritePhyUshort(sc, 0x06, 0xbff8);
22413                         MP_WritePhyUshort(sc, 0x06, 0x40be);
22414                         MP_WritePhyUshort(sc, 0x06, 0x8350);
22415                         MP_WritePhyUshort(sc, 0x06, 0xa001);
22416                         MP_WritePhyUshort(sc, 0x06, 0x0107);
22417                         MP_WritePhyUshort(sc, 0x06, 0x1b89);
22418                         MP_WritePhyUshort(sc, 0x06, 0xcfd2);
22419                         MP_WritePhyUshort(sc, 0x06, 0x08eb);
22420                         MP_WritePhyUshort(sc, 0x06, 0xdb19);
22421                         MP_WritePhyUshort(sc, 0x06, 0xb2fb);
22422                         MP_WritePhyUshort(sc, 0x06, 0xfffe);
22423                         MP_WritePhyUshort(sc, 0x06, 0xfd04);
22424                         MP_WritePhyUshort(sc, 0x06, 0xf8e0);
22425                         MP_WritePhyUshort(sc, 0x06, 0xf848);
22426                         MP_WritePhyUshort(sc, 0x06, 0xe1f8);
22427                         MP_WritePhyUshort(sc, 0x06, 0x4968);
22428                         MP_WritePhyUshort(sc, 0x06, 0x08e4);
22429                         MP_WritePhyUshort(sc, 0x06, 0xf848);
22430                         MP_WritePhyUshort(sc, 0x06, 0xe5f8);
22431                         MP_WritePhyUshort(sc, 0x06, 0x4958);
22432                         MP_WritePhyUshort(sc, 0x06, 0xf7e4);
22433                         MP_WritePhyUshort(sc, 0x06, 0xf848);
22434                         MP_WritePhyUshort(sc, 0x06, 0xe5f8);
22435                         MP_WritePhyUshort(sc, 0x06, 0x49fc);
22436                         MP_WritePhyUshort(sc, 0x06, 0x044d);
22437                         MP_WritePhyUshort(sc, 0x06, 0x2000);
22438                         MP_WritePhyUshort(sc, 0x06, 0x024e);
22439                         MP_WritePhyUshort(sc, 0x06, 0x2200);
22440                         MP_WritePhyUshort(sc, 0x06, 0x024d);
22441                         MP_WritePhyUshort(sc, 0x06, 0xdfff);
22442                         MP_WritePhyUshort(sc, 0x06, 0x014e);
22443                         MP_WritePhyUshort(sc, 0x06, 0xddff);
22444                         MP_WritePhyUshort(sc, 0x06, 0x01f8);
22445                         MP_WritePhyUshort(sc, 0x06, 0xfafb);
22446                         MP_WritePhyUshort(sc, 0x06, 0xef79);
22447                         MP_WritePhyUshort(sc, 0x06, 0xbff8);
22448                         MP_WritePhyUshort(sc, 0x06, 0x22d8);
22449                         MP_WritePhyUshort(sc, 0x06, 0x19d9);
22450                         MP_WritePhyUshort(sc, 0x06, 0x5884);
22451                         MP_WritePhyUshort(sc, 0x06, 0x9f09);
22452                         MP_WritePhyUshort(sc, 0x06, 0xbf82);
22453                         MP_WritePhyUshort(sc, 0x06, 0x6dd6);
22454                         MP_WritePhyUshort(sc, 0x06, 0x8275);
22455                         MP_WritePhyUshort(sc, 0x06, 0x0201);
22456                         MP_WritePhyUshort(sc, 0x06, 0x4fef);
22457                         MP_WritePhyUshort(sc, 0x06, 0x97ff);
22458                         MP_WritePhyUshort(sc, 0x06, 0xfefc);
22459                         MP_WritePhyUshort(sc, 0x06, 0x0517);
22460                         MP_WritePhyUshort(sc, 0x06, 0xfffe);
22461                         MP_WritePhyUshort(sc, 0x06, 0x0117);
22462                         MP_WritePhyUshort(sc, 0x06, 0x0001);
22463                         MP_WritePhyUshort(sc, 0x06, 0x0200);
22464                         MP_WritePhyUshort(sc, 0x05, 0x83d8);
22465                         MP_WritePhyUshort(sc, 0x06, 0x8000);
22466                         MP_WritePhyUshort(sc, 0x05, 0x83d6);
22467                         MP_WritePhyUshort(sc, 0x06, 0x824f);
22468                         MP_WritePhyUshort(sc, 0x02, 0x2010);
22469                         MP_WritePhyUshort(sc, 0x03, 0xdc00);
22470                         MP_WritePhyUshort(sc, 0x1f, 0x0000);
22471                         MP_WritePhyUshort(sc, 0x0b, 0x0600);
22472                         MP_WritePhyUshort(sc, 0x1f, 0x0005);
22473                         MP_WritePhyUshort(sc, 0x05, 0xfff6);
22474                         MP_WritePhyUshort(sc, 0x06, 0x00fc);
22475                         MP_WritePhyUshort(sc, 0x1f, 0x0000);
22476                 }
22477
22478                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
22479                 MP_WritePhyUshort(sc, 0x0D, 0xF880);
22480                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
22481         } else if (sc->re_type == MACFG_36 || sc->re_type == MACFG_37) {
22482                 MP_WritePhyUshort(sc, 0x1F, 0x0007);
22483                 MP_WritePhyUshort(sc, 0x1E, 0x0023);
22484                 Data = MP_ReadPhyUshort(sc, 0x17) | 0x0006;
22485                 if (sc->RequiredSecLanDonglePatch)
22486                         Data &= ~(BIT_2);
22487                 else
22488                         Data |= (BIT_2);
22489                 MP_WritePhyUshort(sc, 0x17, Data);
22490                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
22491
22492                 MP_WritePhyUshort(sc, 0x1f, 0x0005);
22493                 MP_WritePhyUshort(sc, 0x05, 0x8b80);
22494                 MP_WritePhyUshort(sc, 0x06, 0xc896);
22495                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
22496
22497                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
22498                 MP_WritePhyUshort(sc, 0x0B, 0x6C20);
22499                 MP_WritePhyUshort(sc, 0x07, 0x2872);
22500                 MP_WritePhyUshort(sc, 0x1C, 0xEFFF);
22501                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
22502                 MP_WritePhyUshort(sc, 0x14, 0x6420);
22503                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
22504
22505                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
22506                 Data = MP_ReadPhyUshort(sc, 0x08) & 0x00FF;
22507                 MP_WritePhyUshort(sc, 0x08, Data | 0x8000);
22508
22509                 MP_WritePhyUshort(sc, 0x1F, 0x0007);
22510                 MP_WritePhyUshort(sc, 0x1E, 0x002D);
22511                 Data = MP_ReadPhyUshort(sc, 0x18);
22512                 MP_WritePhyUshort(sc, 0x18, Data | 0x0050);
22513                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
22514                 Data = MP_ReadPhyUshort(sc, 0x14);
22515                 MP_WritePhyUshort(sc, 0x14, Data | 0x8000);
22516
22517                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
22518                 MP_WritePhyUshort(sc, 0x00, 0x080B);
22519                 MP_WritePhyUshort(sc, 0x0B, 0x09D7);
22520                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
22521                 MP_WritePhyUshort(sc, 0x15, 0x1006);
22522
22523                 MP_WritePhyUshort(sc, 0x1F, 0x0007);
22524                 MP_WritePhyUshort(sc, 0x1E, 0x002F);
22525                 MP_WritePhyUshort(sc, 0x15, 0x1919);
22526                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
22527
22528                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
22529                 MP_WritePhyUshort(sc, 0x19, 0x7F46);
22530                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
22531                 MP_WritePhyUshort(sc, 0x05, 0x8AD2);
22532                 MP_WritePhyUshort(sc, 0x06, 0x6810);
22533                 MP_WritePhyUshort(sc, 0x05, 0x8AD4);
22534                 MP_WritePhyUshort(sc, 0x06, 0x8002);
22535                 MP_WritePhyUshort(sc, 0x05, 0x8ADE);
22536                 MP_WritePhyUshort(sc, 0x06, 0x8025);
22537                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
22538         } else if (sc->re_type == MACFG_38) {
22539                 CSR_WRITE_1(sc, 0x6E, CSR_READ_1(sc, 0x6E)| (1<<6));
22540
22541                 Data_u32 = re_eri_read(sc, 0x1D0, 4, ERIAR_ExGMAC);
22542                 Data_u32 &= ~BIT_1;
22543                 re_eri_write(sc, 0x1D0, 4, Data_u32, ERIAR_ExGMAC);
22544
22545                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
22546                 MP_WritePhyUshort(sc, 0x05, 0x8B80);
22547                 Data = MP_ReadPhyUshort(sc, 0x06);
22548                 Data |= BIT_2 | BIT_1;
22549                 MP_WritePhyUshort(sc, 0x06, Data);
22550                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
22551
22552                 MP_WritePhyUshort(sc, 0x1f, 0x0004);
22553                 MP_WritePhyUshort(sc, 0x1f, 0x0007);
22554                 MP_WritePhyUshort(sc, 0x1e, 0x002D);
22555                 Data = MP_ReadPhyUshort(sc, 0x18);
22556                 Data |= BIT_4;
22557                 MP_WritePhyUshort(sc, 0x18, Data);
22558                 MP_WritePhyUshort(sc, 0x1f, 0x0002);
22559                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
22560                 Data = MP_ReadPhyUshort(sc, 0x14);
22561                 Data |= BIT_15;
22562                 MP_WritePhyUshort(sc, 0x14, Data);
22563
22564                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
22565                 MP_WritePhyUshort(sc, 0x05, 0x8B86);
22566                 Data = MP_ReadPhyUshort(sc, 0x06);
22567                 Data |= BIT_0;
22568                 MP_WritePhyUshort(sc, 0x06, Data);
22569                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
22570
22571                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
22572                 MP_WritePhyUshort(sc, 0x0B, 0x6C14);
22573                 MP_WritePhyUshort(sc, 0x14, 0x7F3D);
22574                 MP_WritePhyUshort(sc, 0x1C, 0xFAFE);
22575                 MP_WritePhyUshort(sc, 0x08, 0x07C5);
22576                 MP_WritePhyUshort(sc, 0x10, 0xF090);
22577                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
22578                 MP_WritePhyUshort(sc, 0x14, 0x641A);
22579                 MP_WritePhyUshort(sc, 0x1A, 0x0606);
22580                 MP_WritePhyUshort(sc, 0x12, 0xF480);
22581                 MP_WritePhyUshort(sc, 0x13, 0x0747);
22582                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
22583
22584                 MP_WritePhyUshort(sc, 0x1F, 0x0004);
22585                 MP_WritePhyUshort(sc, 0x1F, 0x0007);
22586                 MP_WritePhyUshort(sc, 0x1E, 0x0078);
22587                 MP_WritePhyUshort(sc, 0x15, 0xA408);
22588                 MP_WritePhyUshort(sc, 0x17, 0x5100);
22589                 MP_WritePhyUshort(sc, 0x19, 0x0008);
22590                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
22591                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
22592
22593                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
22594                 MP_WritePhyUshort(sc, 0x0D, 0x0207);
22595                 MP_WritePhyUshort(sc, 0x02, 0x5FD0);
22596                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
22597
22598                 MP_WritePhyUshort(sc, 0x1F, 0x0004);
22599                 MP_WritePhyUshort(sc, 0x1F, 0x0007);
22600                 MP_WritePhyUshort(sc, 0x1E, 0x00A1);
22601                 Data = MP_ReadPhyUshort(sc, 0x1A);
22602                 Data &= ~BIT_2;
22603                 MP_WritePhyUshort(sc, 0x1A, Data);
22604                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
22605                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
22606
22607                 MP_WritePhyUshort(sc, 0x1F, 0x0004);
22608                 MP_WritePhyUshort(sc, 0x1F, 0x0007);
22609                 MP_WritePhyUshort(sc, 0x1E, 0x002D);
22610                 Data = MP_ReadPhyUshort(sc, 0x16);
22611                 Data |= BIT_5;
22612                 MP_WritePhyUshort(sc, 0x16, Data);
22613                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
22614                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
22615
22616                 MP_WritePhyUshort(sc, 0x1F, 0x0004);
22617                 MP_WritePhyUshort(sc, 0x1F, 0x0007);
22618                 MP_WritePhyUshort(sc, 0x1E, 0x00AC);
22619                 MP_WritePhyUshort(sc, 0x18, 0x0006);
22620                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
22621                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
22622
22623                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
22624                 MP_WritePhyUshort(sc, 0x09, 0xA20F);
22625                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
22626
22627                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
22628                 MP_WritePhyUshort(sc, 0x05, 0x8B85);
22629                 Data = MP_ReadPhyUshort(sc, 0x06);
22630                 Data |= BIT_14;
22631                 MP_WritePhyUshort(sc, 0x06, Data);
22632                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
22633
22634                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
22635                 MP_WritePhyUshort(sc, 0x05, 0x8B54);
22636                 Data = MP_ReadPhyUshort(sc, 0x06);
22637                 Data &= ~BIT_11;
22638                 MP_WritePhyUshort(sc, 0x06, Data);
22639                 MP_WritePhyUshort(sc, 0x05, 0x8B5D);
22640                 Data = MP_ReadPhyUshort(sc, 0x06);
22641                 Data &= ~BIT_11;
22642                 MP_WritePhyUshort(sc, 0x06, Data);
22643                 MP_WritePhyUshort(sc, 0x05, 0x8A7C);
22644                 Data = MP_ReadPhyUshort(sc, 0x06);
22645                 Data &= ~BIT_8;
22646                 MP_WritePhyUshort(sc, 0x06, Data);
22647                 MP_WritePhyUshort(sc, 0x05, 0x8A7F);
22648                 Data = MP_ReadPhyUshort(sc, 0x06);
22649                 Data |= BIT_8;
22650                 MP_WritePhyUshort(sc, 0x06, Data);
22651                 MP_WritePhyUshort(sc, 0x05, 0x8A82);
22652                 Data = MP_ReadPhyUshort(sc, 0x06);
22653                 Data &= ~BIT_8;
22654                 MP_WritePhyUshort(sc, 0x06, Data);
22655                 MP_WritePhyUshort(sc, 0x05, 0x8A85);
22656                 Data = MP_ReadPhyUshort(sc, 0x06);
22657                 Data &= ~BIT_8;
22658                 MP_WritePhyUshort(sc, 0x06, Data);
22659                 MP_WritePhyUshort(sc, 0x05, 0x8A88);
22660                 Data = MP_ReadPhyUshort(sc, 0x06);
22661                 Data &= ~BIT_8;
22662                 MP_WritePhyUshort(sc, 0x06, Data);
22663                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
22664
22665                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
22666                 MP_WritePhyUshort(sc, 0x05, 0x8B85);
22667                 Data = MP_ReadPhyUshort(sc, 0x06);
22668                 Data |= BIT_15;
22669                 MP_WritePhyUshort(sc, 0x06, Data);
22670                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
22671
22672                 MP_WritePhyUshort(sc, 0x1f, 0x0003);
22673                 Data = MP_ReadPhyUshort(sc, 0x19);
22674                 Data &= ~BIT_0;
22675                 MP_WritePhyUshort(sc, 0x19, Data);
22676                 Data = MP_ReadPhyUshort(sc, 0x10);
22677                 Data &= ~BIT_10;
22678                 MP_WritePhyUshort(sc, 0x10, Data);
22679                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
22680         } else if (sc->re_type == MACFG_39) {
22681                 Data_u32 = re_eri_read(sc, 0x1D0, 4, ERIAR_ExGMAC);
22682                 Data_u32 &= ~BIT_1;
22683                 re_eri_write(sc, 0x1D0, 4, Data_u32, ERIAR_ExGMAC);
22684
22685                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
22686                 MP_WritePhyUshort(sc, 0x05, 0x8B80);
22687                 Data = MP_ReadPhyUshort(sc, 0x06);
22688                 Data |= BIT_2 | BIT_1;
22689                 MP_WritePhyUshort(sc, 0x06, Data);
22690                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
22691
22692                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
22693                 MP_WritePhyUshort(sc, 0x05, 0x8B85);
22694                 Data = MP_ReadPhyUshort(sc, 0x06);
22695                 Data |= BIT_15;
22696                 MP_WritePhyUshort(sc, 0x06, Data);
22697                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
22698
22699                 MP_WritePhyUshort(sc, 0x1f, 0x0004);
22700                 MP_WritePhyUshort(sc, 0x1f, 0x0007);
22701                 MP_WritePhyUshort(sc, 0x1e, 0x002D);
22702                 Data = MP_ReadPhyUshort(sc, 0x18);
22703                 Data |= BIT_4;
22704                 MP_WritePhyUshort(sc, 0x18, Data);
22705                 MP_WritePhyUshort(sc, 0x1f, 0x0002);
22706                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
22707                 Data = MP_ReadPhyUshort(sc, 0x14);
22708                 Data |= BIT_15;
22709                 MP_WritePhyUshort(sc, 0x14, Data);
22710
22711                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
22712                 MP_WritePhyUshort(sc, 0x05, 0x8B86);
22713                 Data = MP_ReadPhyUshort(sc, 0x06);
22714                 Data |= BIT_0;
22715                 MP_WritePhyUshort(sc, 0x06, Data);
22716                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
22717
22718                 MP_WritePhyUshort(sc, 0x1F, 0x0004);
22719                 MP_WritePhyUshort(sc, 0x1F, 0x0007);
22720                 MP_WritePhyUshort(sc, 0x1E, 0x00AC);
22721                 MP_WritePhyUshort(sc, 0x18, 0x0006);
22722                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
22723                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
22724
22725                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
22726                 MP_WritePhyUshort(sc, 0x09, 0xA20F);
22727                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
22728
22729                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
22730                 MP_WritePhyUshort(sc, 0x05, 0x8B85);
22731                 Data = MP_ReadPhyUshort(sc, 0x06);
22732                 Data |= BIT_14;
22733                 MP_WritePhyUshort(sc, 0x06, Data);
22734                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
22735
22736                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
22737                 MP_WritePhyUshort(sc, 0x05, 0x8B54);
22738                 Data = MP_ReadPhyUshort(sc, 0x06);
22739                 Data &= ~BIT_11;
22740                 MP_WritePhyUshort(sc, 0x06, Data);
22741                 MP_WritePhyUshort(sc, 0x05, 0x8B5D);
22742                 Data = MP_ReadPhyUshort(sc, 0x06);
22743                 Data &= ~BIT_11;
22744                 MP_WritePhyUshort(sc, 0x06, Data);
22745                 MP_WritePhyUshort(sc, 0x05, 0x8A7C);
22746                 Data = MP_ReadPhyUshort(sc, 0x06);
22747                 Data &= ~BIT_8;
22748                 MP_WritePhyUshort(sc, 0x06, Data);
22749                 MP_WritePhyUshort(sc, 0x05, 0x8A7F);
22750                 Data = MP_ReadPhyUshort(sc, 0x06);
22751                 Data |= BIT_8;
22752                 MP_WritePhyUshort(sc, 0x06, Data);
22753                 MP_WritePhyUshort(sc, 0x05, 0x8A82);
22754                 Data = MP_ReadPhyUshort(sc, 0x06);
22755                 Data &= ~BIT_8;
22756                 MP_WritePhyUshort(sc, 0x06, Data);
22757                 MP_WritePhyUshort(sc, 0x05, 0x8A85);
22758                 Data = MP_ReadPhyUshort(sc, 0x06);
22759                 Data &= ~BIT_8;
22760                 MP_WritePhyUshort(sc, 0x06, Data);
22761                 MP_WritePhyUshort(sc, 0x05, 0x8A88);
22762                 Data = MP_ReadPhyUshort(sc, 0x06);
22763                 Data &= ~BIT_8;
22764                 MP_WritePhyUshort(sc, 0x06, Data);
22765                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
22766
22767                 MP_WritePhyUshort(sc, 0x1f, 0x0003);
22768                 Data = MP_ReadPhyUshort(sc, 0x19);
22769                 Data &= ~BIT_0;
22770                 MP_WritePhyUshort(sc, 0x19, Data);
22771                 Data = MP_ReadPhyUshort(sc, 0x10);
22772                 Data &= ~BIT_10;
22773                 MP_WritePhyUshort(sc, 0x10, Data);
22774                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
22775         } else if (sc->re_type == MACFG_41) {
22776                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
22777                 MP_WritePhyUshort(sc, 0x11, MP_ReadPhyUshort(sc, 0x11) | 0x1000);
22778                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
22779                 MP_WritePhyUshort(sc, 0x0F, MP_ReadPhyUshort(sc, 0x0F) | 0x0003);
22780                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
22781
22782                 for (Data_u32=0x800E0068; Data_u32<0x800E006D; Data_u32++) {
22783                         CSR_WRITE_4(sc, 0xF8, Data_u32);
22784                         for (i=0; i<10; i++) {
22785                                 DELAY(400);
22786                                 if ((CSR_READ_4(sc, 0xF8)&0x80000000)==0)
22787                                         break;
22788                         }
22789                 }
22790         } else if (sc->re_type == MACFG_42 || sc->re_type == MACFG_43) {
22791                 Data_u32 = re_eri_read(sc, 0x1D0, 4, ERIAR_ExGMAC);
22792                 Data_u32 &= 0xFFFF0000;
22793                 re_eri_write(sc, 0x1D0, 4, Data_u32, ERIAR_ExGMAC);
22794
22795                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
22796                 MP_WritePhyUshort(sc, 0x18, 0x0310);
22797                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
22798
22799                 MP_WritePhyUshort(sc, 0x1f, 0x0004);
22800                 MP_WritePhyUshort(sc, 0x1f, 0x0004);
22801                 MP_WritePhyUshort(sc, 0x19, 0x7070);
22802                 MP_WritePhyUshort(sc, 0x1c, 0x0600);
22803                 MP_WritePhyUshort(sc, 0x1d, 0x9700);
22804                 MP_WritePhyUshort(sc, 0x1d, 0x7d00);
22805                 MP_WritePhyUshort(sc, 0x1d, 0x6900);
22806                 MP_WritePhyUshort(sc, 0x1d, 0x7d00);
22807                 MP_WritePhyUshort(sc, 0x1d, 0x6800);
22808                 MP_WritePhyUshort(sc, 0x1d, 0x4899);
22809                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
22810                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
22811                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
22812                 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
22813                 MP_WritePhyUshort(sc, 0x1d, 0x8000);
22814                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
22815                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
22816                 MP_WritePhyUshort(sc, 0x1d, 0x4007);
22817                 MP_WritePhyUshort(sc, 0x1d, 0x4400);
22818                 MP_WritePhyUshort(sc, 0x1d, 0x4800);
22819                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
22820                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
22821                 MP_WritePhyUshort(sc, 0x1d, 0x5310);
22822                 MP_WritePhyUshort(sc, 0x1d, 0x6000);
22823                 MP_WritePhyUshort(sc, 0x1d, 0x6800);
22824                 MP_WritePhyUshort(sc, 0x1d, 0x6736);
22825                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22826                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22827                 MP_WritePhyUshort(sc, 0x1d, 0x571f);
22828                 MP_WritePhyUshort(sc, 0x1d, 0x5ffb);
22829                 MP_WritePhyUshort(sc, 0x1d, 0xaa03);
22830                 MP_WritePhyUshort(sc, 0x1d, 0x5b58);
22831                 MP_WritePhyUshort(sc, 0x1d, 0x301e);
22832                 MP_WritePhyUshort(sc, 0x1d, 0x5b64);
22833                 MP_WritePhyUshort(sc, 0x1d, 0xa6fc);
22834                 MP_WritePhyUshort(sc, 0x1d, 0xdcdb);
22835                 MP_WritePhyUshort(sc, 0x1d, 0x0014);
22836                 MP_WritePhyUshort(sc, 0x1d, 0xd9a9);
22837                 MP_WritePhyUshort(sc, 0x1d, 0x0013);
22838                 MP_WritePhyUshort(sc, 0x1d, 0xd16b);
22839                 MP_WritePhyUshort(sc, 0x1d, 0x0011);
22840                 MP_WritePhyUshort(sc, 0x1d, 0xb40e);
22841                 MP_WritePhyUshort(sc, 0x1d, 0xd06b);
22842                 MP_WritePhyUshort(sc, 0x1d, 0x000c);
22843                 MP_WritePhyUshort(sc, 0x1d, 0xb206);
22844                 MP_WritePhyUshort(sc, 0x1d, 0x7c01);
22845                 MP_WritePhyUshort(sc, 0x1d, 0x5800);
22846                 MP_WritePhyUshort(sc, 0x1d, 0x7c04);
22847                 MP_WritePhyUshort(sc, 0x1d, 0x5c00);
22848                 MP_WritePhyUshort(sc, 0x1d, 0x301a);
22849                 MP_WritePhyUshort(sc, 0x1d, 0x7c01);
22850                 MP_WritePhyUshort(sc, 0x1d, 0x5801);
22851                 MP_WritePhyUshort(sc, 0x1d, 0x7c04);
22852                 MP_WritePhyUshort(sc, 0x1d, 0x5c04);
22853                 MP_WritePhyUshort(sc, 0x1d, 0x301e);
22854                 MP_WritePhyUshort(sc, 0x1d, 0x314d);
22855                 MP_WritePhyUshort(sc, 0x1d, 0x31f0);
22856                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
22857                 MP_WritePhyUshort(sc, 0x1d, 0x4c20);
22858                 MP_WritePhyUshort(sc, 0x1d, 0x6004);
22859                 MP_WritePhyUshort(sc, 0x1d, 0x5310);
22860                 MP_WritePhyUshort(sc, 0x1d, 0x4833);
22861                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
22862                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
22863                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
22864                 MP_WritePhyUshort(sc, 0x1d, 0x4c08);
22865                 MP_WritePhyUshort(sc, 0x1d, 0x8300);
22866                 MP_WritePhyUshort(sc, 0x1d, 0x6800);
22867                 MP_WritePhyUshort(sc, 0x1d, 0x6600);
22868                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22869                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22870                 MP_WritePhyUshort(sc, 0x1d, 0xb90c);
22871                 MP_WritePhyUshort(sc, 0x1d, 0x30d3);
22872                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
22873                 MP_WritePhyUshort(sc, 0x1d, 0x4de0);
22874                 MP_WritePhyUshort(sc, 0x1d, 0x7c04);
22875                 MP_WritePhyUshort(sc, 0x1d, 0x6000);
22876                 MP_WritePhyUshort(sc, 0x1d, 0x6800);
22877                 MP_WritePhyUshort(sc, 0x1d, 0x6736);
22878                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22879                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22880                 MP_WritePhyUshort(sc, 0x1d, 0x5310);
22881                 MP_WritePhyUshort(sc, 0x1d, 0x300b);
22882                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
22883                 MP_WritePhyUshort(sc, 0x1d, 0x4c60);
22884                 MP_WritePhyUshort(sc, 0x1d, 0x6803);
22885                 MP_WritePhyUshort(sc, 0x1d, 0x6520);
22886                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22887                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22888                 MP_WritePhyUshort(sc, 0x1d, 0xaf03);
22889                 MP_WritePhyUshort(sc, 0x1d, 0x6015);
22890                 MP_WritePhyUshort(sc, 0x1d, 0x3059);
22891                 MP_WritePhyUshort(sc, 0x1d, 0x6017);
22892                 MP_WritePhyUshort(sc, 0x1d, 0x57e0);
22893                 MP_WritePhyUshort(sc, 0x1d, 0x580c);
22894                 MP_WritePhyUshort(sc, 0x1d, 0x588c);
22895                 MP_WritePhyUshort(sc, 0x1d, 0x7ffc);
22896                 MP_WritePhyUshort(sc, 0x1d, 0x5fa3);
22897                 MP_WritePhyUshort(sc, 0x1d, 0x4827);
22898                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
22899                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
22900                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
22901                 MP_WritePhyUshort(sc, 0x1d, 0x4c10);
22902                 MP_WritePhyUshort(sc, 0x1d, 0x8400);
22903                 MP_WritePhyUshort(sc, 0x1d, 0x7c30);
22904                 MP_WritePhyUshort(sc, 0x1d, 0x6020);
22905                 MP_WritePhyUshort(sc, 0x1d, 0x48bf);
22906                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
22907                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
22908                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
22909                 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
22910                 MP_WritePhyUshort(sc, 0x1d, 0xad09);
22911                 MP_WritePhyUshort(sc, 0x1d, 0x7c03);
22912                 MP_WritePhyUshort(sc, 0x1d, 0x5c03);
22913                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22914                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22915                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22916                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22917                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22918                 MP_WritePhyUshort(sc, 0x1d, 0x4400);
22919                 MP_WritePhyUshort(sc, 0x1d, 0xad2c);
22920                 MP_WritePhyUshort(sc, 0x1d, 0xd6cf);
22921                 MP_WritePhyUshort(sc, 0x1d, 0x0002);
22922                 MP_WritePhyUshort(sc, 0x1d, 0x80f4);
22923                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
22924                 MP_WritePhyUshort(sc, 0x1d, 0x4c80);
22925                 MP_WritePhyUshort(sc, 0x1d, 0x7c20);
22926                 MP_WritePhyUshort(sc, 0x1d, 0x5c20);
22927                 MP_WritePhyUshort(sc, 0x1d, 0x481e);
22928                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
22929                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
22930                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
22931                 MP_WritePhyUshort(sc, 0x1d, 0x4c02);
22932                 MP_WritePhyUshort(sc, 0x1d, 0xad0a);
22933                 MP_WritePhyUshort(sc, 0x1d, 0x7c03);
22934                 MP_WritePhyUshort(sc, 0x1d, 0x5c03);
22935                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22936                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22937                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22938                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22939                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22940                 MP_WritePhyUshort(sc, 0x1d, 0x4400);
22941                 MP_WritePhyUshort(sc, 0x1d, 0x5310);
22942                 MP_WritePhyUshort(sc, 0x1d, 0x8d02);
22943                 MP_WritePhyUshort(sc, 0x1d, 0x4401);
22944                 MP_WritePhyUshort(sc, 0x1d, 0x81f4);
22945                 MP_WritePhyUshort(sc, 0x1d, 0x3114);
22946                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
22947                 MP_WritePhyUshort(sc, 0x1d, 0x4d00);
22948                 MP_WritePhyUshort(sc, 0x1d, 0x4832);
22949                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
22950                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
22951                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
22952                 MP_WritePhyUshort(sc, 0x1d, 0x4c10);
22953                 MP_WritePhyUshort(sc, 0x1d, 0x7c08);
22954                 MP_WritePhyUshort(sc, 0x1d, 0x6000);
22955                 MP_WritePhyUshort(sc, 0x1d, 0xa4b7);
22956                 MP_WritePhyUshort(sc, 0x1d, 0xd9b3);
22957                 MP_WritePhyUshort(sc, 0x1d, 0xfffe);
22958                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
22959                 MP_WritePhyUshort(sc, 0x1d, 0x4d20);
22960                 MP_WritePhyUshort(sc, 0x1d, 0x7e00);
22961                 MP_WritePhyUshort(sc, 0x1d, 0x6200);
22962                 MP_WritePhyUshort(sc, 0x1d, 0x3045);
22963                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
22964                 MP_WritePhyUshort(sc, 0x1d, 0x4d40);
22965                 MP_WritePhyUshort(sc, 0x1d, 0x7c40);
22966                 MP_WritePhyUshort(sc, 0x1d, 0x6000);
22967                 MP_WritePhyUshort(sc, 0x1d, 0x4401);
22968                 MP_WritePhyUshort(sc, 0x1d, 0x5210);
22969                 MP_WritePhyUshort(sc, 0x1d, 0x4833);
22970                 MP_WritePhyUshort(sc, 0x1d, 0x7c08);
22971                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
22972                 MP_WritePhyUshort(sc, 0x1d, 0x7c08);
22973                 MP_WritePhyUshort(sc, 0x1d, 0x4c08);
22974                 MP_WritePhyUshort(sc, 0x1d, 0x8300);
22975                 MP_WritePhyUshort(sc, 0x1d, 0x5f80);
22976                 MP_WritePhyUshort(sc, 0x1d, 0x55e0);
22977                 MP_WritePhyUshort(sc, 0x1d, 0xc06f);
22978                 MP_WritePhyUshort(sc, 0x1d, 0x0005);
22979                 MP_WritePhyUshort(sc, 0x1d, 0xd9b3);
22980                 MP_WritePhyUshort(sc, 0x1d, 0xfffd);
22981                 MP_WritePhyUshort(sc, 0x1d, 0x7c40);
22982                 MP_WritePhyUshort(sc, 0x1d, 0x6040);
22983                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
22984                 MP_WritePhyUshort(sc, 0x1d, 0x4d60);
22985                 MP_WritePhyUshort(sc, 0x1d, 0x57e0);
22986                 MP_WritePhyUshort(sc, 0x1d, 0x4814);
22987                 MP_WritePhyUshort(sc, 0x1d, 0x7c04);
22988                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
22989                 MP_WritePhyUshort(sc, 0x1d, 0x7c04);
22990                 MP_WritePhyUshort(sc, 0x1d, 0x4c04);
22991                 MP_WritePhyUshort(sc, 0x1d, 0x8200);
22992                 MP_WritePhyUshort(sc, 0x1d, 0x7c03);
22993                 MP_WritePhyUshort(sc, 0x1d, 0x5c03);
22994                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22995                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22996                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22997                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22998                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22999                 MP_WritePhyUshort(sc, 0x1d, 0xad02);
23000                 MP_WritePhyUshort(sc, 0x1d, 0x4400);
23001                 MP_WritePhyUshort(sc, 0x1d, 0xc0e9);
23002                 MP_WritePhyUshort(sc, 0x1d, 0x0003);
23003                 MP_WritePhyUshort(sc, 0x1d, 0xadd8);
23004                 MP_WritePhyUshort(sc, 0x1d, 0x30c6);
23005                 MP_WritePhyUshort(sc, 0x1d, 0x3078);
23006                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23007                 MP_WritePhyUshort(sc, 0x1d, 0x4dc0);
23008                 MP_WritePhyUshort(sc, 0x1d, 0x6730);
23009                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23010                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23011                 MP_WritePhyUshort(sc, 0x1d, 0xd09d);
23012                 MP_WritePhyUshort(sc, 0x1d, 0x0002);
23013                 MP_WritePhyUshort(sc, 0x1d, 0xb4fe);
23014                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23015                 MP_WritePhyUshort(sc, 0x1d, 0x4d80);
23016                 MP_WritePhyUshort(sc, 0x1d, 0x6802);
23017                 MP_WritePhyUshort(sc, 0x1d, 0x6600);
23018                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23019                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23020                 MP_WritePhyUshort(sc, 0x1d, 0x7c08);
23021                 MP_WritePhyUshort(sc, 0x1d, 0x6000);
23022                 MP_WritePhyUshort(sc, 0x1d, 0x486c);
23023                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23024                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
23025                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23026                 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
23027                 MP_WritePhyUshort(sc, 0x1d, 0x9503);
23028                 MP_WritePhyUshort(sc, 0x1d, 0x7e00);
23029                 MP_WritePhyUshort(sc, 0x1d, 0x6200);
23030                 MP_WritePhyUshort(sc, 0x1d, 0x571f);
23031                 MP_WritePhyUshort(sc, 0x1d, 0x5fbb);
23032                 MP_WritePhyUshort(sc, 0x1d, 0xaa03);
23033                 MP_WritePhyUshort(sc, 0x1d, 0x5b58);
23034                 MP_WritePhyUshort(sc, 0x1d, 0x30e9);
23035                 MP_WritePhyUshort(sc, 0x1d, 0x5b64);
23036                 MP_WritePhyUshort(sc, 0x1d, 0xcdab);
23037                 MP_WritePhyUshort(sc, 0x1d, 0xff5b);
23038                 MP_WritePhyUshort(sc, 0x1d, 0xcd8d);
23039                 MP_WritePhyUshort(sc, 0x1d, 0xff59);
23040                 MP_WritePhyUshort(sc, 0x1d, 0xd96b);
23041                 MP_WritePhyUshort(sc, 0x1d, 0xff57);
23042                 MP_WritePhyUshort(sc, 0x1d, 0xd0a0);
23043                 MP_WritePhyUshort(sc, 0x1d, 0xffdb);
23044                 MP_WritePhyUshort(sc, 0x1d, 0xcba0);
23045                 MP_WritePhyUshort(sc, 0x1d, 0x0003);
23046                 MP_WritePhyUshort(sc, 0x1d, 0x80f0);
23047                 MP_WritePhyUshort(sc, 0x1d, 0x30f6);
23048                 MP_WritePhyUshort(sc, 0x1d, 0x3109);
23049                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23050                 MP_WritePhyUshort(sc, 0x1d, 0x4ce0);
23051                 MP_WritePhyUshort(sc, 0x1d, 0x7d30);
23052                 MP_WritePhyUshort(sc, 0x1d, 0x6530);
23053                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23054                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23055                 MP_WritePhyUshort(sc, 0x1d, 0x7ce0);
23056                 MP_WritePhyUshort(sc, 0x1d, 0x5400);
23057                 MP_WritePhyUshort(sc, 0x1d, 0x4832);
23058                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23059                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
23060                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23061                 MP_WritePhyUshort(sc, 0x1d, 0x4c08);
23062                 MP_WritePhyUshort(sc, 0x1d, 0x7c08);
23063                 MP_WritePhyUshort(sc, 0x1d, 0x6008);
23064                 MP_WritePhyUshort(sc, 0x1d, 0x8300);
23065                 MP_WritePhyUshort(sc, 0x1d, 0xb902);
23066                 MP_WritePhyUshort(sc, 0x1d, 0x30d3);
23067                 MP_WritePhyUshort(sc, 0x1d, 0x308f);
23068                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23069                 MP_WritePhyUshort(sc, 0x1d, 0x4da0);
23070                 MP_WritePhyUshort(sc, 0x1d, 0x57a0);
23071                 MP_WritePhyUshort(sc, 0x1d, 0x590c);
23072                 MP_WritePhyUshort(sc, 0x1d, 0x5fa2);
23073                 MP_WritePhyUshort(sc, 0x1d, 0xcba4);
23074                 MP_WritePhyUshort(sc, 0x1d, 0x0005);
23075                 MP_WritePhyUshort(sc, 0x1d, 0xcd8d);
23076                 MP_WritePhyUshort(sc, 0x1d, 0x0003);
23077                 MP_WritePhyUshort(sc, 0x1d, 0x80fc);
23078                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23079                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23080                 MP_WritePhyUshort(sc, 0x1d, 0x4ca0);
23081                 MP_WritePhyUshort(sc, 0x1d, 0xb603);
23082                 MP_WritePhyUshort(sc, 0x1d, 0x7c10);
23083                 MP_WritePhyUshort(sc, 0x1d, 0x6010);
23084                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23085                 MP_WritePhyUshort(sc, 0x1d, 0x541f);
23086                 MP_WritePhyUshort(sc, 0x1d, 0x7ffc);
23087                 MP_WritePhyUshort(sc, 0x1d, 0x5fb3);
23088                 MP_WritePhyUshort(sc, 0x1d, 0x9403);
23089                 MP_WritePhyUshort(sc, 0x1d, 0x7c03);
23090                 MP_WritePhyUshort(sc, 0x1d, 0x5c03);
23091                 MP_WritePhyUshort(sc, 0x1d, 0xaa05);
23092                 MP_WritePhyUshort(sc, 0x1d, 0x7c80);
23093                 MP_WritePhyUshort(sc, 0x1d, 0x5800);
23094                 MP_WritePhyUshort(sc, 0x1d, 0x5b58);
23095                 MP_WritePhyUshort(sc, 0x1d, 0x3128);
23096                 MP_WritePhyUshort(sc, 0x1d, 0x7c80);
23097                 MP_WritePhyUshort(sc, 0x1d, 0x5800);
23098                 MP_WritePhyUshort(sc, 0x1d, 0x5b64);
23099                 MP_WritePhyUshort(sc, 0x1d, 0x4827);
23100                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23101                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
23102                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23103                 MP_WritePhyUshort(sc, 0x1d, 0x4c10);
23104                 MP_WritePhyUshort(sc, 0x1d, 0x8400);
23105                 MP_WritePhyUshort(sc, 0x1d, 0x7c10);
23106                 MP_WritePhyUshort(sc, 0x1d, 0x6000);
23107                 MP_WritePhyUshort(sc, 0x1d, 0x4824);
23108                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23109                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
23110                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23111                 MP_WritePhyUshort(sc, 0x1d, 0x4c04);
23112                 MP_WritePhyUshort(sc, 0x1d, 0x8200);
23113                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23114                 MP_WritePhyUshort(sc, 0x1d, 0x4cc0);
23115                 MP_WritePhyUshort(sc, 0x1d, 0x7d00);
23116                 MP_WritePhyUshort(sc, 0x1d, 0x6400);
23117                 MP_WritePhyUshort(sc, 0x1d, 0x7ffc);
23118                 MP_WritePhyUshort(sc, 0x1d, 0x5fbb);
23119                 MP_WritePhyUshort(sc, 0x1d, 0x4824);
23120                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23121                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
23122                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23123                 MP_WritePhyUshort(sc, 0x1d, 0x4c04);
23124                 MP_WritePhyUshort(sc, 0x1d, 0x8200);
23125                 MP_WritePhyUshort(sc, 0x1d, 0x7e00);
23126                 MP_WritePhyUshort(sc, 0x1d, 0x6a00);
23127                 MP_WritePhyUshort(sc, 0x1d, 0x4824);
23128                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23129                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
23130                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23131                 MP_WritePhyUshort(sc, 0x1d, 0x4c04);
23132                 MP_WritePhyUshort(sc, 0x1d, 0x8200);
23133                 MP_WritePhyUshort(sc, 0x1d, 0x7e00);
23134                 MP_WritePhyUshort(sc, 0x1d, 0x6800);
23135                 MP_WritePhyUshort(sc, 0x1d, 0x30f6);
23136                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23137                 MP_WritePhyUshort(sc, 0x1d, 0x4e00);
23138                 MP_WritePhyUshort(sc, 0x1d, 0x4007);
23139                 MP_WritePhyUshort(sc, 0x1d, 0x4400);
23140                 MP_WritePhyUshort(sc, 0x1d, 0x5310);
23141                 MP_WritePhyUshort(sc, 0x1d, 0x6800);
23142                 MP_WritePhyUshort(sc, 0x1d, 0x6736);
23143                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23144                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23145                 MP_WritePhyUshort(sc, 0x1d, 0x570f);
23146                 MP_WritePhyUshort(sc, 0x1d, 0x5fff);
23147                 MP_WritePhyUshort(sc, 0x1d, 0xaa03);
23148                 MP_WritePhyUshort(sc, 0x1d, 0x585b);
23149                 MP_WritePhyUshort(sc, 0x1d, 0x315c);
23150                 MP_WritePhyUshort(sc, 0x1d, 0x5867);
23151                 MP_WritePhyUshort(sc, 0x1d, 0x9402);
23152                 MP_WritePhyUshort(sc, 0x1d, 0x6200);
23153                 MP_WritePhyUshort(sc, 0x1d, 0xcda3);
23154                 MP_WritePhyUshort(sc, 0x1d, 0x009d);
23155                 MP_WritePhyUshort(sc, 0x1d, 0xcd85);
23156                 MP_WritePhyUshort(sc, 0x1d, 0x009b);
23157                 MP_WritePhyUshort(sc, 0x1d, 0xd96b);
23158                 MP_WritePhyUshort(sc, 0x1d, 0x0099);
23159                 MP_WritePhyUshort(sc, 0x1d, 0x96e9);
23160                 MP_WritePhyUshort(sc, 0x1d, 0x6800);
23161                 MP_WritePhyUshort(sc, 0x1d, 0x6736);
23162                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23163                 MP_WritePhyUshort(sc, 0x1d, 0x4e20);
23164                 MP_WritePhyUshort(sc, 0x1d, 0x96e4);
23165                 MP_WritePhyUshort(sc, 0x1d, 0x8b04);
23166                 MP_WritePhyUshort(sc, 0x1d, 0x7c08);
23167                 MP_WritePhyUshort(sc, 0x1d, 0x5008);
23168                 MP_WritePhyUshort(sc, 0x1d, 0xab03);
23169                 MP_WritePhyUshort(sc, 0x1d, 0x7c08);
23170                 MP_WritePhyUshort(sc, 0x1d, 0x5000);
23171                 MP_WritePhyUshort(sc, 0x1d, 0x6801);
23172                 MP_WritePhyUshort(sc, 0x1d, 0x6776);
23173                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23174                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23175                 MP_WritePhyUshort(sc, 0x1d, 0xdb7c);
23176                 MP_WritePhyUshort(sc, 0x1d, 0xfff0);
23177                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23178                 MP_WritePhyUshort(sc, 0x1d, 0x7fe1);
23179                 MP_WritePhyUshort(sc, 0x1d, 0x4e40);
23180                 MP_WritePhyUshort(sc, 0x1d, 0x4837);
23181                 MP_WritePhyUshort(sc, 0x1d, 0x4418);
23182                 MP_WritePhyUshort(sc, 0x1d, 0x41c7);
23183                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23184                 MP_WritePhyUshort(sc, 0x1d, 0x4e40);
23185                 MP_WritePhyUshort(sc, 0x1d, 0x7c40);
23186                 MP_WritePhyUshort(sc, 0x1d, 0x5400);
23187                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23188                 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
23189                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23190                 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
23191                 MP_WritePhyUshort(sc, 0x1d, 0x8fc9);
23192                 MP_WritePhyUshort(sc, 0x1d, 0xd2a0);
23193                 MP_WritePhyUshort(sc, 0x1d, 0x004a);
23194                 MP_WritePhyUshort(sc, 0x1d, 0x9203);
23195                 MP_WritePhyUshort(sc, 0x1d, 0xa041);
23196                 MP_WritePhyUshort(sc, 0x1d, 0x3184);
23197                 MP_WritePhyUshort(sc, 0x1d, 0x7fe1);
23198                 MP_WritePhyUshort(sc, 0x1d, 0x4e60);
23199                 MP_WritePhyUshort(sc, 0x1d, 0x489c);
23200                 MP_WritePhyUshort(sc, 0x1d, 0x4628);
23201                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23202                 MP_WritePhyUshort(sc, 0x1d, 0x4e60);
23203                 MP_WritePhyUshort(sc, 0x1d, 0x7e28);
23204                 MP_WritePhyUshort(sc, 0x1d, 0x4628);
23205                 MP_WritePhyUshort(sc, 0x1d, 0x7c40);
23206                 MP_WritePhyUshort(sc, 0x1d, 0x5400);
23207                 MP_WritePhyUshort(sc, 0x1d, 0x7c01);
23208                 MP_WritePhyUshort(sc, 0x1d, 0x5800);
23209                 MP_WritePhyUshort(sc, 0x1d, 0x7c04);
23210                 MP_WritePhyUshort(sc, 0x1d, 0x5c00);
23211                 MP_WritePhyUshort(sc, 0x1d, 0x41e8);
23212                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23213                 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
23214                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23215                 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
23216                 MP_WritePhyUshort(sc, 0x1d, 0x8fb0);
23217                 MP_WritePhyUshort(sc, 0x1d, 0xb241);
23218                 MP_WritePhyUshort(sc, 0x1d, 0xa02a);
23219                 MP_WritePhyUshort(sc, 0x1d, 0x319d);
23220                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23221                 MP_WritePhyUshort(sc, 0x1d, 0x4ea0);
23222                 MP_WritePhyUshort(sc, 0x1d, 0x7c02);
23223                 MP_WritePhyUshort(sc, 0x1d, 0x4402);
23224                 MP_WritePhyUshort(sc, 0x1d, 0x4448);
23225                 MP_WritePhyUshort(sc, 0x1d, 0x4894);
23226                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23227                 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
23228                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23229                 MP_WritePhyUshort(sc, 0x1d, 0x4c03);
23230                 MP_WritePhyUshort(sc, 0x1d, 0x4824);
23231                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23232                 MP_WritePhyUshort(sc, 0x1d, 0x4c07);
23233                 MP_WritePhyUshort(sc, 0x1d, 0x41ef);
23234                 MP_WritePhyUshort(sc, 0x1d, 0x41ff);
23235                 MP_WritePhyUshort(sc, 0x1d, 0x4891);
23236                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23237                 MP_WritePhyUshort(sc, 0x1d, 0x4c07);
23238                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23239                 MP_WritePhyUshort(sc, 0x1d, 0x4c17);
23240                 MP_WritePhyUshort(sc, 0x1d, 0x8400);
23241                 MP_WritePhyUshort(sc, 0x1d, 0x8ef8);
23242                 MP_WritePhyUshort(sc, 0x1d, 0x41c7);
23243                 MP_WritePhyUshort(sc, 0x1d, 0x8f95);
23244                 MP_WritePhyUshort(sc, 0x1d, 0x92d5);
23245                 MP_WritePhyUshort(sc, 0x1d, 0xa10f);
23246                 MP_WritePhyUshort(sc, 0x1d, 0xd480);
23247                 MP_WritePhyUshort(sc, 0x1d, 0x0008);
23248                 MP_WritePhyUshort(sc, 0x1d, 0xd580);
23249                 MP_WritePhyUshort(sc, 0x1d, 0xffb9);
23250                 MP_WritePhyUshort(sc, 0x1d, 0xa202);
23251                 MP_WritePhyUshort(sc, 0x1d, 0x31b8);
23252                 MP_WritePhyUshort(sc, 0x1d, 0x7c04);
23253                 MP_WritePhyUshort(sc, 0x1d, 0x4404);
23254                 MP_WritePhyUshort(sc, 0x1d, 0x31b8);
23255                 MP_WritePhyUshort(sc, 0x1d, 0xd484);
23256                 MP_WritePhyUshort(sc, 0x1d, 0xfff3);
23257                 MP_WritePhyUshort(sc, 0x1d, 0xd484);
23258                 MP_WritePhyUshort(sc, 0x1d, 0xfff1);
23259                 MP_WritePhyUshort(sc, 0x1d, 0x314d);
23260                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23261                 MP_WritePhyUshort(sc, 0x1d, 0x4ee0);
23262                 MP_WritePhyUshort(sc, 0x1d, 0x7c40);
23263                 MP_WritePhyUshort(sc, 0x1d, 0x5400);
23264                 MP_WritePhyUshort(sc, 0x1d, 0x4488);
23265                 MP_WritePhyUshort(sc, 0x1d, 0x41cf);
23266                 MP_WritePhyUshort(sc, 0x1d, 0x314d);
23267                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23268                 MP_WritePhyUshort(sc, 0x1d, 0x4ec0);
23269                 MP_WritePhyUshort(sc, 0x1d, 0x48f3);
23270                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23271                 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
23272                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23273                 MP_WritePhyUshort(sc, 0x1d, 0x4c09);
23274                 MP_WritePhyUshort(sc, 0x1d, 0x4508);
23275                 MP_WritePhyUshort(sc, 0x1d, 0x41c7);
23276                 MP_WritePhyUshort(sc, 0x1d, 0x8f24);
23277                 MP_WritePhyUshort(sc, 0x1d, 0xd218);
23278                 MP_WritePhyUshort(sc, 0x1d, 0x0022);
23279                 MP_WritePhyUshort(sc, 0x1d, 0xd2a4);
23280                 MP_WritePhyUshort(sc, 0x1d, 0xff9f);
23281                 MP_WritePhyUshort(sc, 0x1d, 0x31d9);
23282                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23283                 MP_WritePhyUshort(sc, 0x1d, 0x4e80);
23284                 MP_WritePhyUshort(sc, 0x1d, 0x4832);
23285                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23286                 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
23287                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23288                 MP_WritePhyUshort(sc, 0x1d, 0x4c11);
23289                 MP_WritePhyUshort(sc, 0x1d, 0x4428);
23290                 MP_WritePhyUshort(sc, 0x1d, 0x7c40);
23291                 MP_WritePhyUshort(sc, 0x1d, 0x5440);
23292                 MP_WritePhyUshort(sc, 0x1d, 0x7c01);
23293                 MP_WritePhyUshort(sc, 0x1d, 0x5801);
23294                 MP_WritePhyUshort(sc, 0x1d, 0x7c04);
23295                 MP_WritePhyUshort(sc, 0x1d, 0x5c04);
23296                 MP_WritePhyUshort(sc, 0x1d, 0x41e8);
23297                 MP_WritePhyUshort(sc, 0x1d, 0xa4b3);
23298                 MP_WritePhyUshort(sc, 0x1d, 0x31ee);
23299                 MP_WritePhyUshort(sc, 0x1d, 0x6800);
23300                 MP_WritePhyUshort(sc, 0x1d, 0x6736);
23301                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23302                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23303                 MP_WritePhyUshort(sc, 0x1d, 0x570f);
23304                 MP_WritePhyUshort(sc, 0x1d, 0x5fff);
23305                 MP_WritePhyUshort(sc, 0x1d, 0xaa03);
23306                 MP_WritePhyUshort(sc, 0x1d, 0x585b);
23307                 MP_WritePhyUshort(sc, 0x1d, 0x31fa);
23308                 MP_WritePhyUshort(sc, 0x1d, 0x5867);
23309                 MP_WritePhyUshort(sc, 0x1d, 0xbcf6);
23310                 MP_WritePhyUshort(sc, 0x1d, 0x300b);
23311                 MP_WritePhyUshort(sc, 0x1d, 0x300b);
23312                 MP_WritePhyUshort(sc, 0x1d, 0x314d);
23313                 MP_WritePhyUshort(sc, 0x1f, 0x0004);
23314                 MP_WritePhyUshort(sc, 0x1c, 0x0200);
23315                 MP_WritePhyUshort(sc, 0x19, 0x7030);
23316                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23317
23318                 if (CSR_READ_1(sc, 0xEF)&0x08) {
23319                         MP_WritePhyUshort(sc, 0x1F, 0x0005);
23320                         MP_WritePhyUshort(sc, 0x1A, 0x0004);
23321                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
23322                 } else {
23323                         MP_WritePhyUshort(sc, 0x1F, 0x0005);
23324                         MP_WritePhyUshort(sc, 0x1A, 0x0000);
23325                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
23326                 }
23327
23328                 if (CSR_READ_1(sc, 0xEF)&0x10) {
23329                         MP_WritePhyUshort(sc, 0x1F, 0x0004);
23330                         MP_WritePhyUshort(sc, 0x1C, 0x0000);
23331                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
23332                 } else {
23333                         MP_WritePhyUshort(sc, 0x1F, 0x0004);
23334                         MP_WritePhyUshort(sc, 0x1C, 0x0200);
23335                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
23336                 }
23337
23338                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
23339                 MP_WritePhyUshort(sc, 0x15, 0x7701);
23340                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
23341
23342                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
23343                 ClearEthPhyBit(sc, 0x1A, BIT_14);
23344
23345                 if (phy_power_saving == 1) {
23346                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
23347                         MP_WritePhyUshort(sc, 0x18, 0x8310);
23348                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
23349                 } else {
23350                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
23351                         MP_WritePhyUshort(sc, 0x18, 0x0310);
23352                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
23353                         DELAY(20000);
23354                 }
23355
23356                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
23357                 MP_WritePhyUshort(sc, 0x0D, 0x0007);
23358                 MP_WritePhyUshort(sc, 0x0E, 0x003C);
23359                 MP_WritePhyUshort(sc, 0x0D, 0x4007);
23360                 MP_WritePhyUshort(sc, 0x0E, 0x0000);
23361                 MP_WritePhyUshort(sc, 0x0D, 0x0000);
23362                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
23363                 MP_WritePhyUshort(sc, 0x0D, 0x0003);
23364                 MP_WritePhyUshort(sc, 0x0E, 0x0015);
23365                 MP_WritePhyUshort(sc, 0x0D, 0x4003);
23366                 MP_WritePhyUshort(sc, 0x0E, 0x0000);
23367                 MP_WritePhyUshort(sc, 0x0D, 0x0000);
23368
23369         } else if (sc->re_type == MACFG_50) {
23370                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
23371                 MP_WritePhyUshort(sc, 0x05, 0x8B80);
23372                 Data = MP_ReadPhyUshort(sc, 0x06);
23373                 Data |= BIT_2 | BIT_1;
23374                 MP_WritePhyUshort(sc, 0x06, Data);
23375                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23376
23377                 MP_WritePhyUshort(sc, 0x1F, 0x0007);
23378                 MP_WritePhyUshort(sc, 0x1E, 0x002D);
23379                 Data = MP_ReadPhyUshort(sc, 0x18);
23380                 Data |= BIT_4;
23381                 MP_WritePhyUshort(sc, 0x18, Data);
23382                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23383                 Data = MP_ReadPhyUshort(sc, 0x14);
23384                 Data |= BIT_15;
23385                 MP_WritePhyUshort(sc, 0x14, Data);
23386
23387                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
23388                 MP_WritePhyUshort(sc, 0x05, 0x8B86);
23389                 Data = MP_ReadPhyUshort(sc, 0x06);
23390                 Data |= BIT_0;
23391                 MP_WritePhyUshort(sc, 0x06, Data);
23392                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23393
23394                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
23395                 MP_WritePhyUshort(sc, 0x05, 0x8B85);
23396                 Data = MP_ReadPhyUshort(sc, 0x06);
23397                 Data |= BIT_14;
23398                 MP_WritePhyUshort(sc, 0x06, Data);
23399                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23400
23401                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
23402                 MP_WritePhyUshort(sc, 0x09, 0xA20F);
23403                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
23404
23405                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
23406                 MP_WritePhyUshort(sc, 0x05, 0x8B55);
23407                 MP_WritePhyUshort(sc, 0x06, 0x0000);
23408                 MP_WritePhyUshort(sc, 0x05, 0x8B5E);
23409                 MP_WritePhyUshort(sc, 0x06, 0x0000);
23410                 MP_WritePhyUshort(sc, 0x05, 0x8B67);
23411                 MP_WritePhyUshort(sc, 0x06, 0x0000);
23412                 MP_WritePhyUshort(sc, 0x05, 0x8B70);
23413                 MP_WritePhyUshort(sc, 0x06, 0x0000);
23414                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23415                 MP_WritePhyUshort(sc, 0x1F, 0x0007);
23416                 MP_WritePhyUshort(sc, 0x1E, 0x0078);
23417                 MP_WritePhyUshort(sc, 0x17, 0x0000);
23418                 MP_WritePhyUshort(sc, 0x19, 0x00FB);
23419                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23420
23421                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
23422                 MP_WritePhyUshort(sc, 0x05, 0x8B79);
23423                 MP_WritePhyUshort(sc, 0x06, 0xAA00);
23424                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23425
23426                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
23427                 MP_WritePhyUshort(sc, 0x01, 0x328A);
23428                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
23429
23430                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
23431                 MP_WritePhyUshort(sc, 0x05, 0x8B54);
23432                 Data = MP_ReadPhyUshort(sc, 0x06);
23433                 Data &= ~BIT_11;
23434                 MP_WritePhyUshort(sc, 0x06, Data);
23435                 MP_WritePhyUshort(sc, 0x05, 0x8B5D);
23436                 Data = MP_ReadPhyUshort(sc, 0x06);
23437                 Data &= ~BIT_11;
23438                 MP_WritePhyUshort(sc, 0x06, Data);
23439                 MP_WritePhyUshort(sc, 0x05, 0x8A7C);
23440                 Data = MP_ReadPhyUshort(sc, 0x06);
23441                 Data &= ~BIT_8;
23442                 MP_WritePhyUshort(sc, 0x06, Data);
23443                 MP_WritePhyUshort(sc, 0x05, 0x8A7F);
23444                 Data = MP_ReadPhyUshort(sc, 0x06);
23445                 Data |= BIT_8;
23446                 MP_WritePhyUshort(sc, 0x06, Data);
23447                 MP_WritePhyUshort(sc, 0x05, 0x8A82);
23448                 Data = MP_ReadPhyUshort(sc, 0x06);
23449                 Data &= ~BIT_8;
23450                 MP_WritePhyUshort(sc, 0x06, Data);
23451                 MP_WritePhyUshort(sc, 0x05, 0x8A85);
23452                 Data = MP_ReadPhyUshort(sc, 0x06);
23453                 Data &= ~BIT_8;
23454                 MP_WritePhyUshort(sc, 0x06, Data);
23455                 MP_WritePhyUshort(sc, 0x05, 0x8A88);
23456                 Data = MP_ReadPhyUshort(sc, 0x06);
23457                 Data &= ~BIT_8;
23458                 MP_WritePhyUshort(sc, 0x06, Data);
23459                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
23460
23461                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
23462                 MP_WritePhyUshort(sc, 0x05, 0x8B85);
23463                 Data = MP_ReadPhyUshort(sc, 0x06);
23464                 Data |= BIT_15;
23465                 MP_WritePhyUshort(sc, 0x06, Data);
23466                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23467
23468                 MP_WritePhyUshort(sc, 0x1f, 0x0003);
23469                 Data = MP_ReadPhyUshort(sc, 0x19);
23470                 Data &= ~BIT_0;
23471                 MP_WritePhyUshort(sc, 0x19, Data);
23472                 Data = MP_ReadPhyUshort(sc, 0x10);
23473                 Data &= ~BIT_10;
23474                 MP_WritePhyUshort(sc, 0x10, Data);
23475                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23476         } else if (sc->re_type == MACFG_51) {
23477                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
23478                 MP_WritePhyUshort(sc, 0x05, 0x8B80);
23479                 Data = MP_ReadPhyUshort(sc, 0x06);
23480                 Data |= BIT_2 | BIT_1;
23481                 MP_WritePhyUshort(sc, 0x06, Data);
23482                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23483
23484                 MP_WritePhyUshort(sc, 0x1F, 0x0007);
23485                 MP_WritePhyUshort(sc, 0x1E, 0x002D);
23486                 Data = MP_ReadPhyUshort(sc, 0x18);
23487                 Data |= BIT_4;
23488                 MP_WritePhyUshort(sc, 0x18, Data);
23489                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23490                 Data = MP_ReadPhyUshort(sc, 0x14);
23491                 Data |= BIT_15;
23492                 MP_WritePhyUshort(sc, 0x14, Data);
23493
23494                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
23495                 MP_WritePhyUshort(sc, 0x05, 0x8B86);
23496                 Data = MP_ReadPhyUshort(sc, 0x06);
23497                 Data |= BIT_0;
23498                 MP_WritePhyUshort(sc, 0x06, Data);
23499                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23500
23501                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
23502                 MP_WritePhyUshort(sc, 0x05, 0x8B54);
23503                 Data = MP_ReadPhyUshort(sc, 0x06);
23504                 Data &= ~BIT_11;
23505                 MP_WritePhyUshort(sc, 0x06, Data);
23506                 MP_WritePhyUshort(sc, 0x05, 0x8B5D);
23507                 Data = MP_ReadPhyUshort(sc, 0x06);
23508                 Data &= ~BIT_11;
23509                 MP_WritePhyUshort(sc, 0x06, Data);
23510                 MP_WritePhyUshort(sc, 0x05, 0x8A7C);
23511                 Data = MP_ReadPhyUshort(sc, 0x06);
23512                 Data &= ~BIT_8;
23513                 MP_WritePhyUshort(sc, 0x06, Data);
23514                 MP_WritePhyUshort(sc, 0x05, 0x8A7F);
23515                 Data = MP_ReadPhyUshort(sc, 0x06);
23516                 Data |= BIT_8;
23517                 MP_WritePhyUshort(sc, 0x06, Data);
23518                 MP_WritePhyUshort(sc, 0x05, 0x8A82);
23519                 Data = MP_ReadPhyUshort(sc, 0x06);
23520                 Data &= ~BIT_8;
23521                 MP_WritePhyUshort(sc, 0x06, Data);
23522                 MP_WritePhyUshort(sc, 0x05, 0x8A85);
23523                 Data = MP_ReadPhyUshort(sc, 0x06);
23524                 Data &= ~BIT_8;
23525                 MP_WritePhyUshort(sc, 0x06, Data);
23526                 MP_WritePhyUshort(sc, 0x05, 0x8A88);
23527                 Data = MP_ReadPhyUshort(sc, 0x06);
23528                 Data &= ~BIT_8;
23529                 MP_WritePhyUshort(sc, 0x06, Data);
23530                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
23531
23532                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
23533                 MP_WritePhyUshort(sc, 0x05, 0x8B85);
23534                 Data = MP_ReadPhyUshort(sc, 0x06);
23535                 Data |= BIT_15;
23536                 MP_WritePhyUshort(sc, 0x06, Data);
23537                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23538
23539                 MP_WritePhyUshort(sc, 0x1f, 0x0003);
23540                 Data = MP_ReadPhyUshort(sc, 0x19);
23541                 Data &= ~BIT_0;
23542                 MP_WritePhyUshort(sc, 0x19, Data);
23543                 Data = MP_ReadPhyUshort(sc, 0x10);
23544                 Data &= ~BIT_10;
23545                 MP_WritePhyUshort(sc, 0x10, Data);
23546                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23547         } else if (sc->re_type == MACFG_52) {
23548                 Data_u32 = re_eri_read(sc, 0x1D0, 4, ERIAR_ExGMAC);
23549                 Data_u32 &= ~BIT_1;
23550                 re_eri_write(sc, 0x1D0, 4, Data_u32, ERIAR_ExGMAC);
23551
23552                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
23553                 MP_WritePhyUshort(sc, 0x05, 0x8B80);
23554                 Data = MP_ReadPhyUshort(sc, 0x06);
23555                 Data |= BIT_2 | BIT_1;
23556                 MP_WritePhyUshort(sc, 0x06, Data);
23557                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23558
23559                 MP_WritePhyUshort(sc, 0x1F, 0x0007);
23560                 MP_WritePhyUshort(sc, 0x1E, 0x002D);
23561                 Data = MP_ReadPhyUshort(sc, 0x18);
23562                 Data |= BIT_4;
23563                 MP_WritePhyUshort(sc, 0x18, Data);
23564                 MP_WritePhyUshort(sc, 0x1f, 0x0002);
23565                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23566                 Data = MP_ReadPhyUshort(sc, 0x14);
23567                 Data |= BIT_15;
23568                 MP_WritePhyUshort(sc, 0x14, Data);
23569
23570                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
23571                 MP_WritePhyUshort(sc, 0x05, 0x8B86);
23572                 Data = MP_ReadPhyUshort(sc, 0x06);
23573                 Data |= BIT_0;
23574                 MP_WritePhyUshort(sc, 0x06, Data);
23575                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23576
23577                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
23578                 MP_WritePhyUshort(sc, 0x05, 0x8B85);
23579                 Data = MP_ReadPhyUshort(sc, 0x06);
23580                 Data |= BIT_14;
23581                 MP_WritePhyUshort(sc, 0x06, Data);
23582                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23583
23584                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
23585                 MP_WritePhyUshort(sc, 0x09, 0xA20F);
23586                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
23587
23588                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
23589                 MP_WritePhyUshort(sc, 0x05, 0x8B55);
23590                 MP_WritePhyUshort(sc, 0x06, 0x0000);
23591                 MP_WritePhyUshort(sc, 0x05, 0x8B5E);
23592                 MP_WritePhyUshort(sc, 0x06, 0x0000);
23593                 MP_WritePhyUshort(sc, 0x05, 0x8B67);
23594                 MP_WritePhyUshort(sc, 0x06, 0x0000);
23595                 MP_WritePhyUshort(sc, 0x05, 0x8B70);
23596                 MP_WritePhyUshort(sc, 0x06, 0x0000);
23597                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23598                 MP_WritePhyUshort(sc, 0x1F, 0x0007);
23599                 MP_WritePhyUshort(sc, 0x1E, 0x0078);
23600                 MP_WritePhyUshort(sc, 0x17, 0x0000);
23601                 MP_WritePhyUshort(sc, 0x19, 0x00FB);
23602                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23603
23604                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
23605                 MP_WritePhyUshort(sc, 0x05, 0x8B79);
23606                 MP_WritePhyUshort(sc, 0x06, 0xAA00);
23607                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23608
23609                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
23610                 MP_WritePhyUshort(sc, 0x01, 0x328A);
23611                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
23612
23613                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
23614                 MP_WritePhyUshort(sc, 0x05, 0x8B54);
23615                 Data = MP_ReadPhyUshort(sc, 0x06);
23616                 Data &= ~BIT_11;
23617                 MP_WritePhyUshort(sc, 0x06, Data);
23618                 MP_WritePhyUshort(sc, 0x05, 0x8B5D);
23619                 Data = MP_ReadPhyUshort(sc, 0x06);
23620                 Data &= ~BIT_11;
23621                 MP_WritePhyUshort(sc, 0x06, Data);
23622                 MP_WritePhyUshort(sc, 0x05, 0x8A7C);
23623                 Data = MP_ReadPhyUshort(sc, 0x06);
23624                 Data &= ~BIT_8;
23625                 MP_WritePhyUshort(sc, 0x06, Data);
23626                 MP_WritePhyUshort(sc, 0x05, 0x8A7F);
23627                 Data = MP_ReadPhyUshort(sc, 0x06);
23628                 Data |= BIT_8;
23629                 MP_WritePhyUshort(sc, 0x06, Data);
23630                 MP_WritePhyUshort(sc, 0x05, 0x8A82);
23631                 Data = MP_ReadPhyUshort(sc, 0x06);
23632                 Data &= ~BIT_8;
23633                 MP_WritePhyUshort(sc, 0x06, Data);
23634                 MP_WritePhyUshort(sc, 0x05, 0x8A85);
23635                 Data = MP_ReadPhyUshort(sc, 0x06);
23636                 Data &= ~BIT_8;
23637                 MP_WritePhyUshort(sc, 0x06, Data);
23638                 MP_WritePhyUshort(sc, 0x05, 0x8A88);
23639                 Data = MP_ReadPhyUshort(sc, 0x06);
23640                 Data &= ~BIT_8;
23641                 MP_WritePhyUshort(sc, 0x06, Data);
23642                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
23643
23644                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
23645                 MP_WritePhyUshort(sc, 0x05, 0x8B85);
23646                 Data = MP_ReadPhyUshort(sc, 0x06);
23647                 Data |= BIT_15;
23648                 MP_WritePhyUshort(sc, 0x06, Data);
23649                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23650
23651                 MP_WritePhyUshort(sc, 0x1f, 0x0003);
23652                 Data = MP_ReadPhyUshort(sc, 0x19);
23653                 Data &= ~BIT_0;
23654                 MP_WritePhyUshort(sc, 0x19, Data);
23655                 Data = MP_ReadPhyUshort(sc, 0x10);
23656                 Data &= ~BIT_10;
23657                 MP_WritePhyUshort(sc, 0x10, Data);
23658                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23659         } else if (sc->re_type == MACFG_53) {
23660                 Data_u32 = re_eri_read(sc, 0x1D0, 4, ERIAR_ExGMAC);
23661                 Data_u32 &= 0xFFFF0000;
23662                 re_eri_write(sc, 0x1D0, 4, Data_u32, ERIAR_ExGMAC);
23663
23664                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
23665                 MP_WritePhyUshort(sc, 0x18, 0x0310);
23666                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
23667
23668                 MP_WritePhyUshort(sc, 0x1f, 0x0004);
23669                 MP_WritePhyUshort(sc, 0x1f, 0x0004);
23670                 MP_WritePhyUshort(sc, 0x19, 0x7070);
23671                 MP_WritePhyUshort(sc, 0x1c, 0x0600);
23672                 MP_WritePhyUshort(sc, 0x1d, 0x9700);
23673                 MP_WritePhyUshort(sc, 0x1d, 0x7d00);
23674                 MP_WritePhyUshort(sc, 0x1d, 0x6900);
23675                 MP_WritePhyUshort(sc, 0x1d, 0x7d00);
23676                 MP_WritePhyUshort(sc, 0x1d, 0x6800);
23677                 MP_WritePhyUshort(sc, 0x1d, 0x4899);
23678                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23679                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
23680                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23681                 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
23682                 MP_WritePhyUshort(sc, 0x1d, 0x8000);
23683                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23684                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
23685                 MP_WritePhyUshort(sc, 0x1d, 0x4007);
23686                 MP_WritePhyUshort(sc, 0x1d, 0x4400);
23687                 MP_WritePhyUshort(sc, 0x1d, 0x4800);
23688                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23689                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
23690                 MP_WritePhyUshort(sc, 0x1d, 0x5310);
23691                 MP_WritePhyUshort(sc, 0x1d, 0x6000);
23692                 MP_WritePhyUshort(sc, 0x1d, 0x6800);
23693                 MP_WritePhyUshort(sc, 0x1d, 0x6736);
23694                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23695                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23696                 MP_WritePhyUshort(sc, 0x1d, 0x571f);
23697                 MP_WritePhyUshort(sc, 0x1d, 0x5ffb);
23698                 MP_WritePhyUshort(sc, 0x1d, 0xaa03);
23699                 MP_WritePhyUshort(sc, 0x1d, 0x5b58);
23700                 MP_WritePhyUshort(sc, 0x1d, 0x301e);
23701                 MP_WritePhyUshort(sc, 0x1d, 0x5b64);
23702                 MP_WritePhyUshort(sc, 0x1d, 0xa6fc);
23703                 MP_WritePhyUshort(sc, 0x1d, 0xdcdb);
23704                 MP_WritePhyUshort(sc, 0x1d, 0x0015);
23705                 MP_WritePhyUshort(sc, 0x1d, 0xb915);
23706                 MP_WritePhyUshort(sc, 0x1d, 0xb511);
23707                 MP_WritePhyUshort(sc, 0x1d, 0xd16b);
23708                 MP_WritePhyUshort(sc, 0x1d, 0x000f);
23709                 MP_WritePhyUshort(sc, 0x1d, 0xb40f);
23710                 MP_WritePhyUshort(sc, 0x1d, 0xd06b);
23711                 MP_WritePhyUshort(sc, 0x1d, 0x000d);
23712                 MP_WritePhyUshort(sc, 0x1d, 0xb206);
23713                 MP_WritePhyUshort(sc, 0x1d, 0x7c01);
23714                 MP_WritePhyUshort(sc, 0x1d, 0x5800);
23715                 MP_WritePhyUshort(sc, 0x1d, 0x7c04);
23716                 MP_WritePhyUshort(sc, 0x1d, 0x5c00);
23717                 MP_WritePhyUshort(sc, 0x1d, 0x301a);
23718                 MP_WritePhyUshort(sc, 0x1d, 0x7c01);
23719                 MP_WritePhyUshort(sc, 0x1d, 0x5801);
23720                 MP_WritePhyUshort(sc, 0x1d, 0x7c04);
23721                 MP_WritePhyUshort(sc, 0x1d, 0x5c04);
23722                 MP_WritePhyUshort(sc, 0x1d, 0x301e);
23723                 MP_WritePhyUshort(sc, 0x1d, 0x3079);
23724                 MP_WritePhyUshort(sc, 0x1d, 0x30f1);
23725                 MP_WritePhyUshort(sc, 0x1d, 0x3199);
23726                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23727                 MP_WritePhyUshort(sc, 0x1d, 0x4c60);
23728                 MP_WritePhyUshort(sc, 0x1d, 0x6803);
23729                 MP_WritePhyUshort(sc, 0x1d, 0x6420);
23730                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23731                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23732                 MP_WritePhyUshort(sc, 0x1d, 0xaf03);
23733                 MP_WritePhyUshort(sc, 0x1d, 0x6015);
23734                 MP_WritePhyUshort(sc, 0x1d, 0x3040);
23735                 MP_WritePhyUshort(sc, 0x1d, 0x6017);
23736                 MP_WritePhyUshort(sc, 0x1d, 0x57e0);
23737                 MP_WritePhyUshort(sc, 0x1d, 0x580c);
23738                 MP_WritePhyUshort(sc, 0x1d, 0x588c);
23739                 MP_WritePhyUshort(sc, 0x1d, 0x5fa3);
23740                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23741                 MP_WritePhyUshort(sc, 0x1d, 0x4827);
23742                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23743                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
23744                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23745                 MP_WritePhyUshort(sc, 0x1d, 0x4c10);
23746                 MP_WritePhyUshort(sc, 0x1d, 0x8400);
23747                 MP_WritePhyUshort(sc, 0x1d, 0x7c30);
23748                 MP_WritePhyUshort(sc, 0x1d, 0x6020);
23749                 MP_WritePhyUshort(sc, 0x1d, 0x48bf);
23750                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23751                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
23752                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23753                 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
23754                 MP_WritePhyUshort(sc, 0x1d, 0xd6cf);
23755                 MP_WritePhyUshort(sc, 0x1d, 0x0002);
23756                 MP_WritePhyUshort(sc, 0x1d, 0x80fe);
23757                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23758                 MP_WritePhyUshort(sc, 0x1d, 0x4c80);
23759                 MP_WritePhyUshort(sc, 0x1d, 0x7c20);
23760                 MP_WritePhyUshort(sc, 0x1d, 0x5c20);
23761                 MP_WritePhyUshort(sc, 0x1d, 0x481e);
23762                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23763                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
23764                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23765                 MP_WritePhyUshort(sc, 0x1d, 0x4c02);
23766                 MP_WritePhyUshort(sc, 0x1d, 0x5310);
23767                 MP_WritePhyUshort(sc, 0x1d, 0x81ff);
23768                 MP_WritePhyUshort(sc, 0x1d, 0x30ba);
23769                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23770                 MP_WritePhyUshort(sc, 0x1d, 0x4d00);
23771                 MP_WritePhyUshort(sc, 0x1d, 0x4832);
23772                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23773                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
23774                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23775                 MP_WritePhyUshort(sc, 0x1d, 0x4c10);
23776                 MP_WritePhyUshort(sc, 0x1d, 0x7c08);
23777                 MP_WritePhyUshort(sc, 0x1d, 0x6000);
23778                 MP_WritePhyUshort(sc, 0x1d, 0xa4cc);
23779                 MP_WritePhyUshort(sc, 0x1d, 0xd9b3);
23780                 MP_WritePhyUshort(sc, 0x1d, 0xfffe);
23781                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23782                 MP_WritePhyUshort(sc, 0x1d, 0x4d20);
23783                 MP_WritePhyUshort(sc, 0x1d, 0x7e00);
23784                 MP_WritePhyUshort(sc, 0x1d, 0x6200);
23785                 MP_WritePhyUshort(sc, 0x1d, 0x300b);
23786                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23787                 MP_WritePhyUshort(sc, 0x1d, 0x4dc0);
23788                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23789                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23790                 MP_WritePhyUshort(sc, 0x1d, 0xd09d);
23791                 MP_WritePhyUshort(sc, 0x1d, 0x0002);
23792                 MP_WritePhyUshort(sc, 0x1d, 0xb4fe);
23793                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23794                 MP_WritePhyUshort(sc, 0x1d, 0x4d80);
23795                 MP_WritePhyUshort(sc, 0x1d, 0x7c04);
23796                 MP_WritePhyUshort(sc, 0x1d, 0x6004);
23797                 MP_WritePhyUshort(sc, 0x1d, 0x5310);
23798                 MP_WritePhyUshort(sc, 0x1d, 0x6802);
23799                 MP_WritePhyUshort(sc, 0x1d, 0x6720);
23800                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23801                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23802                 MP_WritePhyUshort(sc, 0x1d, 0x7c08);
23803                 MP_WritePhyUshort(sc, 0x1d, 0x6000);
23804                 MP_WritePhyUshort(sc, 0x1d, 0x486c);
23805                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23806                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
23807                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23808                 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
23809                 MP_WritePhyUshort(sc, 0x1d, 0x9503);
23810                 MP_WritePhyUshort(sc, 0x1d, 0x7e00);
23811                 MP_WritePhyUshort(sc, 0x1d, 0x6200);
23812                 MP_WritePhyUshort(sc, 0x1d, 0x571f);
23813                 MP_WritePhyUshort(sc, 0x1d, 0x5fbb);
23814                 MP_WritePhyUshort(sc, 0x1d, 0xaa03);
23815                 MP_WritePhyUshort(sc, 0x1d, 0x5b58);
23816                 MP_WritePhyUshort(sc, 0x1d, 0x3092);
23817                 MP_WritePhyUshort(sc, 0x1d, 0x5b64);
23818                 MP_WritePhyUshort(sc, 0x1d, 0xcdab);
23819                 MP_WritePhyUshort(sc, 0x1d, 0xff78);
23820                 MP_WritePhyUshort(sc, 0x1d, 0xcd8d);
23821                 MP_WritePhyUshort(sc, 0x1d, 0xff76);
23822                 MP_WritePhyUshort(sc, 0x1d, 0xd96b);
23823                 MP_WritePhyUshort(sc, 0x1d, 0xff74);
23824                 MP_WritePhyUshort(sc, 0x1d, 0xd0a0);
23825                 MP_WritePhyUshort(sc, 0x1d, 0xffd9);
23826                 MP_WritePhyUshort(sc, 0x1d, 0xcba0);
23827                 MP_WritePhyUshort(sc, 0x1d, 0x0003);
23828                 MP_WritePhyUshort(sc, 0x1d, 0x80f0);
23829                 MP_WritePhyUshort(sc, 0x1d, 0x309f);
23830                 MP_WritePhyUshort(sc, 0x1d, 0x30ac);
23831                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23832                 MP_WritePhyUshort(sc, 0x1d, 0x4ce0);
23833                 MP_WritePhyUshort(sc, 0x1d, 0x4832);
23834                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23835                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
23836                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23837                 MP_WritePhyUshort(sc, 0x1d, 0x4c08);
23838                 MP_WritePhyUshort(sc, 0x1d, 0x7c08);
23839                 MP_WritePhyUshort(sc, 0x1d, 0x6008);
23840                 MP_WritePhyUshort(sc, 0x1d, 0x8300);
23841                 MP_WritePhyUshort(sc, 0x1d, 0xb902);
23842                 MP_WritePhyUshort(sc, 0x1d, 0x3079);
23843                 MP_WritePhyUshort(sc, 0x1d, 0x3061);
23844                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23845                 MP_WritePhyUshort(sc, 0x1d, 0x4da0);
23846                 MP_WritePhyUshort(sc, 0x1d, 0x6400);
23847                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23848                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23849                 MP_WritePhyUshort(sc, 0x1d, 0x57a0);
23850                 MP_WritePhyUshort(sc, 0x1d, 0x590c);
23851                 MP_WritePhyUshort(sc, 0x1d, 0x5fa3);
23852                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23853                 MP_WritePhyUshort(sc, 0x1d, 0xcba4);
23854                 MP_WritePhyUshort(sc, 0x1d, 0x0004);
23855                 MP_WritePhyUshort(sc, 0x1d, 0xcd8d);
23856                 MP_WritePhyUshort(sc, 0x1d, 0x0002);
23857                 MP_WritePhyUshort(sc, 0x1d, 0x80fc);
23858                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23859                 MP_WritePhyUshort(sc, 0x1d, 0x4ca0);
23860                 MP_WritePhyUshort(sc, 0x1d, 0xb603);
23861                 MP_WritePhyUshort(sc, 0x1d, 0x7c10);
23862                 MP_WritePhyUshort(sc, 0x1d, 0x6010);
23863                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23864                 MP_WritePhyUshort(sc, 0x1d, 0x541f);
23865                 MP_WritePhyUshort(sc, 0x1d, 0x5fb3);
23866                 MP_WritePhyUshort(sc, 0x1d, 0xaa05);
23867                 MP_WritePhyUshort(sc, 0x1d, 0x7c80);
23868                 MP_WritePhyUshort(sc, 0x1d, 0x5800);
23869                 MP_WritePhyUshort(sc, 0x1d, 0x5b58);
23870                 MP_WritePhyUshort(sc, 0x1d, 0x30ca);
23871                 MP_WritePhyUshort(sc, 0x1d, 0x7c80);
23872                 MP_WritePhyUshort(sc, 0x1d, 0x5800);
23873                 MP_WritePhyUshort(sc, 0x1d, 0x5b64);
23874                 MP_WritePhyUshort(sc, 0x1d, 0x4824);
23875                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23876                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
23877                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23878                 MP_WritePhyUshort(sc, 0x1d, 0x4c04);
23879                 MP_WritePhyUshort(sc, 0x1d, 0x8200);
23880                 MP_WritePhyUshort(sc, 0x1d, 0x4827);
23881                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23882                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
23883                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23884                 MP_WritePhyUshort(sc, 0x1d, 0x4c10);
23885                 MP_WritePhyUshort(sc, 0x1d, 0x8400);
23886                 MP_WritePhyUshort(sc, 0x1d, 0x7c10);
23887                 MP_WritePhyUshort(sc, 0x1d, 0x6000);
23888                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23889                 MP_WritePhyUshort(sc, 0x1d, 0x4cc0);
23890                 MP_WritePhyUshort(sc, 0x1d, 0x5fbb);
23891                 MP_WritePhyUshort(sc, 0x1d, 0x4824);
23892                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23893                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
23894                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23895                 MP_WritePhyUshort(sc, 0x1d, 0x4c04);
23896                 MP_WritePhyUshort(sc, 0x1d, 0x8200);
23897                 MP_WritePhyUshort(sc, 0x1d, 0x7ce0);
23898                 MP_WritePhyUshort(sc, 0x1d, 0x5400);
23899                 MP_WritePhyUshort(sc, 0x1d, 0x6720);
23900                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23901                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23902                 MP_WritePhyUshort(sc, 0x1d, 0x7e00);
23903                 MP_WritePhyUshort(sc, 0x1d, 0x6a00);
23904                 MP_WritePhyUshort(sc, 0x1d, 0x4824);
23905                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23906                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
23907                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23908                 MP_WritePhyUshort(sc, 0x1d, 0x4c04);
23909                 MP_WritePhyUshort(sc, 0x1d, 0x8200);
23910                 MP_WritePhyUshort(sc, 0x1d, 0x7e00);
23911                 MP_WritePhyUshort(sc, 0x1d, 0x6800);
23912                 MP_WritePhyUshort(sc, 0x1d, 0x309f);
23913                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23914                 MP_WritePhyUshort(sc, 0x1d, 0x4e00);
23915                 MP_WritePhyUshort(sc, 0x1d, 0x4007);
23916                 MP_WritePhyUshort(sc, 0x1d, 0x4400);
23917                 MP_WritePhyUshort(sc, 0x1d, 0x5310);
23918                 MP_WritePhyUshort(sc, 0x1d, 0x6800);
23919                 MP_WritePhyUshort(sc, 0x1d, 0x6736);
23920                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23921                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23922                 MP_WritePhyUshort(sc, 0x1d, 0x570f);
23923                 MP_WritePhyUshort(sc, 0x1d, 0x5fff);
23924                 MP_WritePhyUshort(sc, 0x1d, 0xaa03);
23925                 MP_WritePhyUshort(sc, 0x1d, 0x585b);
23926                 MP_WritePhyUshort(sc, 0x1d, 0x3100);
23927                 MP_WritePhyUshort(sc, 0x1d, 0x5867);
23928                 MP_WritePhyUshort(sc, 0x1d, 0x9403);
23929                 MP_WritePhyUshort(sc, 0x1d, 0x7e00);
23930                 MP_WritePhyUshort(sc, 0x1d, 0x6200);
23931                 MP_WritePhyUshort(sc, 0x1d, 0xcda3);
23932                 MP_WritePhyUshort(sc, 0x1d, 0x002d);
23933                 MP_WritePhyUshort(sc, 0x1d, 0xcd85);
23934                 MP_WritePhyUshort(sc, 0x1d, 0x002b);
23935                 MP_WritePhyUshort(sc, 0x1d, 0xd96b);
23936                 MP_WritePhyUshort(sc, 0x1d, 0x0029);
23937                 MP_WritePhyUshort(sc, 0x1d, 0x9629);
23938                 MP_WritePhyUshort(sc, 0x1d, 0x6800);
23939                 MP_WritePhyUshort(sc, 0x1d, 0x6736);
23940                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23941                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23942                 MP_WritePhyUshort(sc, 0x1d, 0x9624);
23943                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23944                 MP_WritePhyUshort(sc, 0x1d, 0x4e20);
23945                 MP_WritePhyUshort(sc, 0x1d, 0x8b04);
23946                 MP_WritePhyUshort(sc, 0x1d, 0x7c08);
23947                 MP_WritePhyUshort(sc, 0x1d, 0x5008);
23948                 MP_WritePhyUshort(sc, 0x1d, 0xab03);
23949                 MP_WritePhyUshort(sc, 0x1d, 0x7c08);
23950                 MP_WritePhyUshort(sc, 0x1d, 0x5000);
23951                 MP_WritePhyUshort(sc, 0x1d, 0x6801);
23952                 MP_WritePhyUshort(sc, 0x1d, 0x6776);
23953                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23954                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23955                 MP_WritePhyUshort(sc, 0x1d, 0xdb7c);
23956                 MP_WritePhyUshort(sc, 0x1d, 0xffee);
23957                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23958                 MP_WritePhyUshort(sc, 0x1d, 0x7fe1);
23959                 MP_WritePhyUshort(sc, 0x1d, 0x4e40);
23960                 MP_WritePhyUshort(sc, 0x1d, 0x4837);
23961                 MP_WritePhyUshort(sc, 0x1d, 0x4418);
23962                 MP_WritePhyUshort(sc, 0x1d, 0x41c7);
23963                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23964                 MP_WritePhyUshort(sc, 0x1d, 0x4e40);
23965                 MP_WritePhyUshort(sc, 0x1d, 0x7c40);
23966                 MP_WritePhyUshort(sc, 0x1d, 0x5400);
23967                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23968                 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
23969                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23970                 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
23971                 MP_WritePhyUshort(sc, 0x1d, 0x8f07);
23972                 MP_WritePhyUshort(sc, 0x1d, 0xd2a0);
23973                 MP_WritePhyUshort(sc, 0x1d, 0x004c);
23974                 MP_WritePhyUshort(sc, 0x1d, 0x9205);
23975                 MP_WritePhyUshort(sc, 0x1d, 0xa043);
23976                 MP_WritePhyUshort(sc, 0x1d, 0x312b);
23977                 MP_WritePhyUshort(sc, 0x1d, 0x300b);
23978                 MP_WritePhyUshort(sc, 0x1d, 0x30f1);
23979                 MP_WritePhyUshort(sc, 0x1d, 0x7fe1);
23980                 MP_WritePhyUshort(sc, 0x1d, 0x4e60);
23981                 MP_WritePhyUshort(sc, 0x1d, 0x489c);
23982                 MP_WritePhyUshort(sc, 0x1d, 0x4628);
23983                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23984                 MP_WritePhyUshort(sc, 0x1d, 0x4e60);
23985                 MP_WritePhyUshort(sc, 0x1d, 0x7e28);
23986                 MP_WritePhyUshort(sc, 0x1d, 0x4628);
23987                 MP_WritePhyUshort(sc, 0x1d, 0x7c40);
23988                 MP_WritePhyUshort(sc, 0x1d, 0x5400);
23989                 MP_WritePhyUshort(sc, 0x1d, 0x7c01);
23990                 MP_WritePhyUshort(sc, 0x1d, 0x5800);
23991                 MP_WritePhyUshort(sc, 0x1d, 0x7c04);
23992                 MP_WritePhyUshort(sc, 0x1d, 0x5c00);
23993                 MP_WritePhyUshort(sc, 0x1d, 0x41e8);
23994                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23995                 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
23996                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23997                 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
23998                 MP_WritePhyUshort(sc, 0x1d, 0x8fec);
23999                 MP_WritePhyUshort(sc, 0x1d, 0xb241);
24000                 MP_WritePhyUshort(sc, 0x1d, 0xa02a);
24001                 MP_WritePhyUshort(sc, 0x1d, 0x3146);
24002                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
24003                 MP_WritePhyUshort(sc, 0x1d, 0x4ea0);
24004                 MP_WritePhyUshort(sc, 0x1d, 0x7c02);
24005                 MP_WritePhyUshort(sc, 0x1d, 0x4402);
24006                 MP_WritePhyUshort(sc, 0x1d, 0x4448);
24007                 MP_WritePhyUshort(sc, 0x1d, 0x4894);
24008                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24009                 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
24010                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24011                 MP_WritePhyUshort(sc, 0x1d, 0x4c03);
24012                 MP_WritePhyUshort(sc, 0x1d, 0x4824);
24013                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24014                 MP_WritePhyUshort(sc, 0x1d, 0x4c07);
24015                 MP_WritePhyUshort(sc, 0x1d, 0x41ef);
24016                 MP_WritePhyUshort(sc, 0x1d, 0x41ff);
24017                 MP_WritePhyUshort(sc, 0x1d, 0x4891);
24018                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24019                 MP_WritePhyUshort(sc, 0x1d, 0x4c07);
24020                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24021                 MP_WritePhyUshort(sc, 0x1d, 0x4c17);
24022                 MP_WritePhyUshort(sc, 0x1d, 0x8400);
24023                 MP_WritePhyUshort(sc, 0x1d, 0x8ef8);
24024                 MP_WritePhyUshort(sc, 0x1d, 0x41c7);
24025                 MP_WritePhyUshort(sc, 0x1d, 0x8fd1);
24026                 MP_WritePhyUshort(sc, 0x1d, 0x92d5);
24027                 MP_WritePhyUshort(sc, 0x1d, 0xa10f);
24028                 MP_WritePhyUshort(sc, 0x1d, 0xd480);
24029                 MP_WritePhyUshort(sc, 0x1d, 0x0008);
24030                 MP_WritePhyUshort(sc, 0x1d, 0xd580);
24031                 MP_WritePhyUshort(sc, 0x1d, 0xffb7);
24032                 MP_WritePhyUshort(sc, 0x1d, 0xa202);
24033                 MP_WritePhyUshort(sc, 0x1d, 0x3161);
24034                 MP_WritePhyUshort(sc, 0x1d, 0x7c04);
24035                 MP_WritePhyUshort(sc, 0x1d, 0x4404);
24036                 MP_WritePhyUshort(sc, 0x1d, 0x3161);
24037                 MP_WritePhyUshort(sc, 0x1d, 0xd484);
24038                 MP_WritePhyUshort(sc, 0x1d, 0xfff3);
24039                 MP_WritePhyUshort(sc, 0x1d, 0xd484);
24040                 MP_WritePhyUshort(sc, 0x1d, 0xfff1);
24041                 MP_WritePhyUshort(sc, 0x1d, 0x30f1);
24042                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
24043                 MP_WritePhyUshort(sc, 0x1d, 0x4ee0);
24044                 MP_WritePhyUshort(sc, 0x1d, 0x7c40);
24045                 MP_WritePhyUshort(sc, 0x1d, 0x5400);
24046                 MP_WritePhyUshort(sc, 0x1d, 0x4488);
24047                 MP_WritePhyUshort(sc, 0x1d, 0x41cf);
24048                 MP_WritePhyUshort(sc, 0x1d, 0x30f1);
24049                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
24050                 MP_WritePhyUshort(sc, 0x1d, 0x4ec0);
24051                 MP_WritePhyUshort(sc, 0x1d, 0x48f3);
24052                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24053                 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
24054                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24055                 MP_WritePhyUshort(sc, 0x1d, 0x4c09);
24056                 MP_WritePhyUshort(sc, 0x1d, 0x4508);
24057                 MP_WritePhyUshort(sc, 0x1d, 0x41c7);
24058                 MP_WritePhyUshort(sc, 0x1d, 0x8fb0);
24059                 MP_WritePhyUshort(sc, 0x1d, 0xd218);
24060                 MP_WritePhyUshort(sc, 0x1d, 0xffae);
24061                 MP_WritePhyUshort(sc, 0x1d, 0xd2a4);
24062                 MP_WritePhyUshort(sc, 0x1d, 0xff9d);
24063                 MP_WritePhyUshort(sc, 0x1d, 0x3182);
24064                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
24065                 MP_WritePhyUshort(sc, 0x1d, 0x4e80);
24066                 MP_WritePhyUshort(sc, 0x1d, 0x4832);
24067                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24068                 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
24069                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24070                 MP_WritePhyUshort(sc, 0x1d, 0x4c11);
24071                 MP_WritePhyUshort(sc, 0x1d, 0x4428);
24072                 MP_WritePhyUshort(sc, 0x1d, 0x7c40);
24073                 MP_WritePhyUshort(sc, 0x1d, 0x5440);
24074                 MP_WritePhyUshort(sc, 0x1d, 0x7c01);
24075                 MP_WritePhyUshort(sc, 0x1d, 0x5801);
24076                 MP_WritePhyUshort(sc, 0x1d, 0x7c04);
24077                 MP_WritePhyUshort(sc, 0x1d, 0x5c04);
24078                 MP_WritePhyUshort(sc, 0x1d, 0x41e8);
24079                 MP_WritePhyUshort(sc, 0x1d, 0xa4b3);
24080                 MP_WritePhyUshort(sc, 0x1d, 0x3197);
24081                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
24082                 MP_WritePhyUshort(sc, 0x1d, 0x4f20);
24083                 MP_WritePhyUshort(sc, 0x1d, 0x6800);
24084                 MP_WritePhyUshort(sc, 0x1d, 0x6736);
24085                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
24086                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
24087                 MP_WritePhyUshort(sc, 0x1d, 0x570f);
24088                 MP_WritePhyUshort(sc, 0x1d, 0x5fff);
24089                 MP_WritePhyUshort(sc, 0x1d, 0xaa03);
24090                 MP_WritePhyUshort(sc, 0x1d, 0x585b);
24091                 MP_WritePhyUshort(sc, 0x1d, 0x31a5);
24092                 MP_WritePhyUshort(sc, 0x1d, 0x5867);
24093                 MP_WritePhyUshort(sc, 0x1d, 0xbcf4);
24094                 MP_WritePhyUshort(sc, 0x1d, 0x300b);
24095                 MP_WritePhyUshort(sc, 0x1f, 0x0004);
24096                 MP_WritePhyUshort(sc, 0x1c, 0x0200);
24097                 MP_WritePhyUshort(sc, 0x19, 0x7030);
24098                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
24099
24100                 if (phy_power_saving == 1) {
24101                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
24102                         MP_WritePhyUshort(sc, 0x18, 0x8310);
24103                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
24104                 } else {
24105                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
24106                         MP_WritePhyUshort(sc, 0x18, 0x0310);
24107                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
24108                         DELAY(20000);
24109                 }
24110
24111                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
24112                 MP_WritePhyUshort(sc, 0x0D, 0x0007);
24113                 MP_WritePhyUshort(sc, 0x0E, 0x003C);
24114                 MP_WritePhyUshort(sc, 0x0D, 0x4007);
24115                 MP_WritePhyUshort(sc, 0x0E, 0x0000);
24116                 MP_WritePhyUshort(sc, 0x0D, 0x0000);
24117         } else if (sc->re_type == MACFG_54 || sc->re_type == MACFG_55) {
24118                 Data_u32 = re_eri_read(sc, 0x1D0, 4, ERIAR_ExGMAC);
24119                 Data_u32 &= 0xFFFF0000;
24120                 re_eri_write(sc, 0x1D0, 4, Data_u32, ERIAR_ExGMAC);
24121
24122                 if (sc->re_type == MACFG_55) {
24123                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
24124                         MP_WritePhyUshort(sc, 0x18, 0x0310);
24125                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
24126
24127                         MP_WritePhyUshort(sc, 0x1f, 0x0004);
24128                         MP_WritePhyUshort(sc, 0x1f, 0x0004);
24129                         MP_WritePhyUshort(sc, 0x19, 0x7070);
24130                         MP_WritePhyUshort(sc, 0x1c, 0x0600);
24131                         MP_WritePhyUshort(sc, 0x1d, 0x9700);
24132                         MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
24133                         MP_WritePhyUshort(sc, 0x1d, 0x4c00);
24134                         MP_WritePhyUshort(sc, 0x1d, 0x4007);
24135                         MP_WritePhyUshort(sc, 0x1d, 0x4400);
24136                         MP_WritePhyUshort(sc, 0x1d, 0x4800);
24137                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24138                         MP_WritePhyUshort(sc, 0x1d, 0x4c00);
24139                         MP_WritePhyUshort(sc, 0x1d, 0x5310);
24140                         MP_WritePhyUshort(sc, 0x1d, 0x6000);
24141                         MP_WritePhyUshort(sc, 0x1d, 0x6800);
24142                         MP_WritePhyUshort(sc, 0x1d, 0x673e);
24143                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24144                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24145                         MP_WritePhyUshort(sc, 0x1d, 0x571f);
24146                         MP_WritePhyUshort(sc, 0x1d, 0x5ffb);
24147                         MP_WritePhyUshort(sc, 0x1d, 0xaa04);
24148                         MP_WritePhyUshort(sc, 0x1d, 0x5b58);
24149                         MP_WritePhyUshort(sc, 0x1d, 0x6100);
24150                         MP_WritePhyUshort(sc, 0x1d, 0x3016);
24151                         MP_WritePhyUshort(sc, 0x1d, 0x5b64);
24152                         MP_WritePhyUshort(sc, 0x1d, 0x6080);
24153                         MP_WritePhyUshort(sc, 0x1d, 0xa6fa);
24154                         MP_WritePhyUshort(sc, 0x1d, 0xdcdb);
24155                         MP_WritePhyUshort(sc, 0x1d, 0x0015);
24156                         MP_WritePhyUshort(sc, 0x1d, 0xb915);
24157                         MP_WritePhyUshort(sc, 0x1d, 0xb511);
24158                         MP_WritePhyUshort(sc, 0x1d, 0xd16b);
24159                         MP_WritePhyUshort(sc, 0x1d, 0x000f);
24160                         MP_WritePhyUshort(sc, 0x1d, 0xb40f);
24161                         MP_WritePhyUshort(sc, 0x1d, 0xd06b);
24162                         MP_WritePhyUshort(sc, 0x1d, 0x000d);
24163                         MP_WritePhyUshort(sc, 0x1d, 0xb206);
24164                         MP_WritePhyUshort(sc, 0x1d, 0x7c01);
24165                         MP_WritePhyUshort(sc, 0x1d, 0x5800);
24166                         MP_WritePhyUshort(sc, 0x1d, 0x7c04);
24167                         MP_WritePhyUshort(sc, 0x1d, 0x5c00);
24168                         MP_WritePhyUshort(sc, 0x1d, 0x3010);
24169                         MP_WritePhyUshort(sc, 0x1d, 0x7c01);
24170                         MP_WritePhyUshort(sc, 0x1d, 0x5801);
24171                         MP_WritePhyUshort(sc, 0x1d, 0x7c04);
24172                         MP_WritePhyUshort(sc, 0x1d, 0x5c04);
24173                         MP_WritePhyUshort(sc, 0x1d, 0x3016);
24174                         MP_WritePhyUshort(sc, 0x1d, 0x307e);
24175                         MP_WritePhyUshort(sc, 0x1d, 0x30f4);
24176                         MP_WritePhyUshort(sc, 0x1d, 0x319f);
24177                         MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
24178                         MP_WritePhyUshort(sc, 0x1d, 0x4c60);
24179                         MP_WritePhyUshort(sc, 0x1d, 0x6803);
24180                         MP_WritePhyUshort(sc, 0x1d, 0x7d00);
24181                         MP_WritePhyUshort(sc, 0x1d, 0x6900);
24182                         MP_WritePhyUshort(sc, 0x1d, 0x6520);
24183                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24184                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24185                         MP_WritePhyUshort(sc, 0x1d, 0xaf03);
24186                         MP_WritePhyUshort(sc, 0x1d, 0x6115);
24187                         MP_WritePhyUshort(sc, 0x1d, 0x303a);
24188                         MP_WritePhyUshort(sc, 0x1d, 0x6097);
24189                         MP_WritePhyUshort(sc, 0x1d, 0x57e0);
24190                         MP_WritePhyUshort(sc, 0x1d, 0x580c);
24191                         MP_WritePhyUshort(sc, 0x1d, 0x588c);
24192                         MP_WritePhyUshort(sc, 0x1d, 0x5f80);
24193                         MP_WritePhyUshort(sc, 0x1d, 0x4827);
24194                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24195                         MP_WritePhyUshort(sc, 0x1d, 0x4c00);
24196                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24197                         MP_WritePhyUshort(sc, 0x1d, 0x4c10);
24198                         MP_WritePhyUshort(sc, 0x1d, 0x8400);
24199                         MP_WritePhyUshort(sc, 0x1d, 0x7c30);
24200                         MP_WritePhyUshort(sc, 0x1d, 0x6020);
24201                         MP_WritePhyUshort(sc, 0x1d, 0x48bf);
24202                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24203                         MP_WritePhyUshort(sc, 0x1d, 0x4c00);
24204                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24205                         MP_WritePhyUshort(sc, 0x1d, 0x4c01);
24206                         MP_WritePhyUshort(sc, 0x1d, 0xb802);
24207                         MP_WritePhyUshort(sc, 0x1d, 0x3053);
24208                         MP_WritePhyUshort(sc, 0x1d, 0x7c08);
24209                         MP_WritePhyUshort(sc, 0x1d, 0x6808);
24210                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24211                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24212                         MP_WritePhyUshort(sc, 0x1d, 0x7c10);
24213                         MP_WritePhyUshort(sc, 0x1d, 0x6810);
24214                         MP_WritePhyUshort(sc, 0x1d, 0xd6cf);
24215                         MP_WritePhyUshort(sc, 0x1d, 0x0002);
24216                         MP_WritePhyUshort(sc, 0x1d, 0x80fe);
24217                         MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
24218                         MP_WritePhyUshort(sc, 0x1d, 0x4c80);
24219                         MP_WritePhyUshort(sc, 0x1d, 0x7c10);
24220                         MP_WritePhyUshort(sc, 0x1d, 0x6800);
24221                         MP_WritePhyUshort(sc, 0x1d, 0x7c08);
24222                         MP_WritePhyUshort(sc, 0x1d, 0x6800);
24223                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24224                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24225                         MP_WritePhyUshort(sc, 0x1d, 0x7c23);
24226                         MP_WritePhyUshort(sc, 0x1d, 0x5c23);
24227                         MP_WritePhyUshort(sc, 0x1d, 0x481e);
24228                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24229                         MP_WritePhyUshort(sc, 0x1d, 0x4c00);
24230                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24231                         MP_WritePhyUshort(sc, 0x1d, 0x4c02);
24232                         MP_WritePhyUshort(sc, 0x1d, 0x5310);
24233                         MP_WritePhyUshort(sc, 0x1d, 0x81ff);
24234                         MP_WritePhyUshort(sc, 0x1d, 0x30c1);
24235                         MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
24236                         MP_WritePhyUshort(sc, 0x1d, 0x4d00);
24237                         MP_WritePhyUshort(sc, 0x1d, 0x4832);
24238                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24239                         MP_WritePhyUshort(sc, 0x1d, 0x4c00);
24240                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24241                         MP_WritePhyUshort(sc, 0x1d, 0x4c10);
24242                         MP_WritePhyUshort(sc, 0x1d, 0x7c08);
24243                         MP_WritePhyUshort(sc, 0x1d, 0x6000);
24244                         MP_WritePhyUshort(sc, 0x1d, 0xa4bd);
24245                         MP_WritePhyUshort(sc, 0x1d, 0xd9b3);
24246                         MP_WritePhyUshort(sc, 0x1d, 0x00fe);
24247                         MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
24248                         MP_WritePhyUshort(sc, 0x1d, 0x4d20);
24249                         MP_WritePhyUshort(sc, 0x1d, 0x7e00);
24250                         MP_WritePhyUshort(sc, 0x1d, 0x6200);
24251                         MP_WritePhyUshort(sc, 0x1d, 0x3001);
24252                         MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
24253                         MP_WritePhyUshort(sc, 0x1d, 0x4dc0);
24254                         MP_WritePhyUshort(sc, 0x1d, 0xd09d);
24255                         MP_WritePhyUshort(sc, 0x1d, 0x0002);
24256                         MP_WritePhyUshort(sc, 0x1d, 0xb4fe);
24257                         MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
24258                         MP_WritePhyUshort(sc, 0x1d, 0x4d80);
24259                         MP_WritePhyUshort(sc, 0x1d, 0x7c04);
24260                         MP_WritePhyUshort(sc, 0x1d, 0x6004);
24261                         MP_WritePhyUshort(sc, 0x1d, 0x6802);
24262                         MP_WritePhyUshort(sc, 0x1d, 0x6728);
24263                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24264                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24265                         MP_WritePhyUshort(sc, 0x1d, 0x7c08);
24266                         MP_WritePhyUshort(sc, 0x1d, 0x6000);
24267                         MP_WritePhyUshort(sc, 0x1d, 0x486c);
24268                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24269                         MP_WritePhyUshort(sc, 0x1d, 0x4c00);
24270                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24271                         MP_WritePhyUshort(sc, 0x1d, 0x4c01);
24272                         MP_WritePhyUshort(sc, 0x1d, 0x9503);
24273                         MP_WritePhyUshort(sc, 0x1d, 0x7e00);
24274                         MP_WritePhyUshort(sc, 0x1d, 0x6200);
24275                         MP_WritePhyUshort(sc, 0x1d, 0x571f);
24276                         MP_WritePhyUshort(sc, 0x1d, 0x5fbb);
24277                         MP_WritePhyUshort(sc, 0x1d, 0xaa05);
24278                         MP_WritePhyUshort(sc, 0x1d, 0x5b58);
24279                         MP_WritePhyUshort(sc, 0x1d, 0x7d80);
24280                         MP_WritePhyUshort(sc, 0x1d, 0x6100);
24281                         MP_WritePhyUshort(sc, 0x1d, 0x309a);
24282                         MP_WritePhyUshort(sc, 0x1d, 0x5b64);
24283                         MP_WritePhyUshort(sc, 0x1d, 0x7d80);
24284                         MP_WritePhyUshort(sc, 0x1d, 0x6080);
24285                         MP_WritePhyUshort(sc, 0x1d, 0xcdab);
24286                         MP_WritePhyUshort(sc, 0x1d, 0x0058);
24287                         MP_WritePhyUshort(sc, 0x1d, 0xcd8d);
24288                         MP_WritePhyUshort(sc, 0x1d, 0x0056);
24289                         MP_WritePhyUshort(sc, 0x1d, 0xd96b);
24290                         MP_WritePhyUshort(sc, 0x1d, 0x0054);
24291                         MP_WritePhyUshort(sc, 0x1d, 0xd0a0);
24292                         MP_WritePhyUshort(sc, 0x1d, 0x00d8);
24293                         MP_WritePhyUshort(sc, 0x1d, 0xcba0);
24294                         MP_WritePhyUshort(sc, 0x1d, 0x0003);
24295                         MP_WritePhyUshort(sc, 0x1d, 0x80ec);
24296                         MP_WritePhyUshort(sc, 0x1d, 0x30a7);
24297                         MP_WritePhyUshort(sc, 0x1d, 0x30b4);
24298                         MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
24299                         MP_WritePhyUshort(sc, 0x1d, 0x4ce0);
24300                         MP_WritePhyUshort(sc, 0x1d, 0x4832);
24301                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24302                         MP_WritePhyUshort(sc, 0x1d, 0x4c00);
24303                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24304                         MP_WritePhyUshort(sc, 0x1d, 0x4c08);
24305                         MP_WritePhyUshort(sc, 0x1d, 0x7c08);
24306                         MP_WritePhyUshort(sc, 0x1d, 0x6008);
24307                         MP_WritePhyUshort(sc, 0x1d, 0x8300);
24308                         MP_WritePhyUshort(sc, 0x1d, 0xb902);
24309                         MP_WritePhyUshort(sc, 0x1d, 0x307e);
24310                         MP_WritePhyUshort(sc, 0x1d, 0x3068);
24311                         MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
24312                         MP_WritePhyUshort(sc, 0x1d, 0x4da0);
24313                         MP_WritePhyUshort(sc, 0x1d, 0x6608);
24314                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24315                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24316                         MP_WritePhyUshort(sc, 0x1d, 0x56a0);
24317                         MP_WritePhyUshort(sc, 0x1d, 0x590c);
24318                         MP_WritePhyUshort(sc, 0x1d, 0x5fa0);
24319                         MP_WritePhyUshort(sc, 0x1d, 0xcba4);
24320                         MP_WritePhyUshort(sc, 0x1d, 0x0004);
24321                         MP_WritePhyUshort(sc, 0x1d, 0xcd8d);
24322                         MP_WritePhyUshort(sc, 0x1d, 0x0002);
24323                         MP_WritePhyUshort(sc, 0x1d, 0x80fc);
24324                         MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
24325                         MP_WritePhyUshort(sc, 0x1d, 0x4ca0);
24326                         MP_WritePhyUshort(sc, 0x1d, 0x7c08);
24327                         MP_WritePhyUshort(sc, 0x1d, 0x6408);
24328                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24329                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24330                         MP_WritePhyUshort(sc, 0x1d, 0x7d00);
24331                         MP_WritePhyUshort(sc, 0x1d, 0x6800);
24332                         MP_WritePhyUshort(sc, 0x1d, 0xb603);
24333                         MP_WritePhyUshort(sc, 0x1d, 0x7c10);
24334                         MP_WritePhyUshort(sc, 0x1d, 0x6010);
24335                         MP_WritePhyUshort(sc, 0x1d, 0x7d1f);
24336                         MP_WritePhyUshort(sc, 0x1d, 0x551f);
24337                         MP_WritePhyUshort(sc, 0x1d, 0x5fb3);
24338                         MP_WritePhyUshort(sc, 0x1d, 0xaa05);
24339                         MP_WritePhyUshort(sc, 0x1d, 0x7c80);
24340                         MP_WritePhyUshort(sc, 0x1d, 0x5800);
24341                         MP_WritePhyUshort(sc, 0x1d, 0x5b58);
24342                         MP_WritePhyUshort(sc, 0x1d, 0x30d7);
24343                         MP_WritePhyUshort(sc, 0x1d, 0x7c80);
24344                         MP_WritePhyUshort(sc, 0x1d, 0x5800);
24345                         MP_WritePhyUshort(sc, 0x1d, 0x5b64);
24346                         MP_WritePhyUshort(sc, 0x1d, 0x4827);
24347                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24348                         MP_WritePhyUshort(sc, 0x1d, 0x4c00);
24349                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24350                         MP_WritePhyUshort(sc, 0x1d, 0x4c10);
24351                         MP_WritePhyUshort(sc, 0x1d, 0x8400);
24352                         MP_WritePhyUshort(sc, 0x1d, 0x7c10);
24353                         MP_WritePhyUshort(sc, 0x1d, 0x6000);
24354                         MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
24355                         MP_WritePhyUshort(sc, 0x1d, 0x4cc0);
24356                         MP_WritePhyUshort(sc, 0x1d, 0x7d00);
24357                         MP_WritePhyUshort(sc, 0x1d, 0x6400);
24358                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24359                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24360                         MP_WritePhyUshort(sc, 0x1d, 0x5fbb);
24361                         MP_WritePhyUshort(sc, 0x1d, 0x4824);
24362                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24363                         MP_WritePhyUshort(sc, 0x1d, 0x4c00);
24364                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24365                         MP_WritePhyUshort(sc, 0x1d, 0x4c04);
24366                         MP_WritePhyUshort(sc, 0x1d, 0x8200);
24367                         MP_WritePhyUshort(sc, 0x1d, 0x7ce0);
24368                         MP_WritePhyUshort(sc, 0x1d, 0x5400);
24369                         MP_WritePhyUshort(sc, 0x1d, 0x7d00);
24370                         MP_WritePhyUshort(sc, 0x1d, 0x6500);
24371                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24372                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24373                         MP_WritePhyUshort(sc, 0x1d, 0x30a7);
24374                         MP_WritePhyUshort(sc, 0x1d, 0x3001);
24375                         MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
24376                         MP_WritePhyUshort(sc, 0x1d, 0x4e00);
24377                         MP_WritePhyUshort(sc, 0x1d, 0x4007);
24378                         MP_WritePhyUshort(sc, 0x1d, 0x4400);
24379                         MP_WritePhyUshort(sc, 0x1d, 0x5310);
24380                         MP_WritePhyUshort(sc, 0x1d, 0x6800);
24381                         MP_WritePhyUshort(sc, 0x1d, 0x673e);
24382                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24383                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24384                         MP_WritePhyUshort(sc, 0x1d, 0x570f);
24385                         MP_WritePhyUshort(sc, 0x1d, 0x5fff);
24386                         MP_WritePhyUshort(sc, 0x1d, 0xaa05);
24387                         MP_WritePhyUshort(sc, 0x1d, 0x585b);
24388                         MP_WritePhyUshort(sc, 0x1d, 0x7d80);
24389                         MP_WritePhyUshort(sc, 0x1d, 0x6100);
24390                         MP_WritePhyUshort(sc, 0x1d, 0x3107);
24391                         MP_WritePhyUshort(sc, 0x1d, 0x5867);
24392                         MP_WritePhyUshort(sc, 0x1d, 0x7d80);
24393                         MP_WritePhyUshort(sc, 0x1d, 0x6080);
24394                         MP_WritePhyUshort(sc, 0x1d, 0x9403);
24395                         MP_WritePhyUshort(sc, 0x1d, 0x7e00);
24396                         MP_WritePhyUshort(sc, 0x1d, 0x6200);
24397                         MP_WritePhyUshort(sc, 0x1d, 0xcda3);
24398                         MP_WritePhyUshort(sc, 0x1d, 0x00e8);
24399                         MP_WritePhyUshort(sc, 0x1d, 0xcd85);
24400                         MP_WritePhyUshort(sc, 0x1d, 0x00e6);
24401                         MP_WritePhyUshort(sc, 0x1d, 0xd96b);
24402                         MP_WritePhyUshort(sc, 0x1d, 0x00e4);
24403                         MP_WritePhyUshort(sc, 0x1d, 0x96e4);
24404                         MP_WritePhyUshort(sc, 0x1d, 0x6800);
24405                         MP_WritePhyUshort(sc, 0x1d, 0x673e);
24406                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24407                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24408                         MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
24409                         MP_WritePhyUshort(sc, 0x1d, 0x4e20);
24410                         MP_WritePhyUshort(sc, 0x1d, 0x96dd);
24411                         MP_WritePhyUshort(sc, 0x1d, 0x8b04);
24412                         MP_WritePhyUshort(sc, 0x1d, 0x7c08);
24413                         MP_WritePhyUshort(sc, 0x1d, 0x5008);
24414                         MP_WritePhyUshort(sc, 0x1d, 0xab03);
24415                         MP_WritePhyUshort(sc, 0x1d, 0x7c08);
24416                         MP_WritePhyUshort(sc, 0x1d, 0x5000);
24417                         MP_WritePhyUshort(sc, 0x1d, 0x6801);
24418                         MP_WritePhyUshort(sc, 0x1d, 0x677e);
24419                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24420                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24421                         MP_WritePhyUshort(sc, 0x1d, 0xdb7c);
24422                         MP_WritePhyUshort(sc, 0x1d, 0x00ee);
24423                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24424                         MP_WritePhyUshort(sc, 0x1d, 0x7fe1);
24425                         MP_WritePhyUshort(sc, 0x1d, 0x4e40);
24426                         MP_WritePhyUshort(sc, 0x1d, 0x4837);
24427                         MP_WritePhyUshort(sc, 0x1d, 0x4418);
24428                         MP_WritePhyUshort(sc, 0x1d, 0x41c7);
24429                         MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
24430                         MP_WritePhyUshort(sc, 0x1d, 0x4e40);
24431                         MP_WritePhyUshort(sc, 0x1d, 0x7c40);
24432                         MP_WritePhyUshort(sc, 0x1d, 0x5400);
24433                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24434                         MP_WritePhyUshort(sc, 0x1d, 0x4c01);
24435                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24436                         MP_WritePhyUshort(sc, 0x1d, 0x4c01);
24437                         MP_WritePhyUshort(sc, 0x1d, 0x8fc2);
24438                         MP_WritePhyUshort(sc, 0x1d, 0xd2a0);
24439                         MP_WritePhyUshort(sc, 0x1d, 0x004b);
24440                         MP_WritePhyUshort(sc, 0x1d, 0x9204);
24441                         MP_WritePhyUshort(sc, 0x1d, 0xa042);
24442                         MP_WritePhyUshort(sc, 0x1d, 0x3132);
24443                         MP_WritePhyUshort(sc, 0x1d, 0x30f4);
24444                         MP_WritePhyUshort(sc, 0x1d, 0x7fe1);
24445                         MP_WritePhyUshort(sc, 0x1d, 0x4e60);
24446                         MP_WritePhyUshort(sc, 0x1d, 0x489c);
24447                         MP_WritePhyUshort(sc, 0x1d, 0x4628);
24448                         MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
24449                         MP_WritePhyUshort(sc, 0x1d, 0x4e60);
24450                         MP_WritePhyUshort(sc, 0x1d, 0x7e28);
24451                         MP_WritePhyUshort(sc, 0x1d, 0x4628);
24452                         MP_WritePhyUshort(sc, 0x1d, 0x7c40);
24453                         MP_WritePhyUshort(sc, 0x1d, 0x5400);
24454                         MP_WritePhyUshort(sc, 0x1d, 0x7c01);
24455                         MP_WritePhyUshort(sc, 0x1d, 0x5800);
24456                         MP_WritePhyUshort(sc, 0x1d, 0x7c04);
24457                         MP_WritePhyUshort(sc, 0x1d, 0x5c00);
24458                         MP_WritePhyUshort(sc, 0x1d, 0x41e8);
24459                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24460                         MP_WritePhyUshort(sc, 0x1d, 0x4c01);
24461                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24462                         MP_WritePhyUshort(sc, 0x1d, 0x4c01);
24463                         MP_WritePhyUshort(sc, 0x1d, 0x8fa8);
24464                         MP_WritePhyUshort(sc, 0x1d, 0xb241);
24465                         MP_WritePhyUshort(sc, 0x1d, 0xa02a);
24466                         MP_WritePhyUshort(sc, 0x1d, 0x314c);
24467                         MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
24468                         MP_WritePhyUshort(sc, 0x1d, 0x4ea0);
24469                         MP_WritePhyUshort(sc, 0x1d, 0x7c02);
24470                         MP_WritePhyUshort(sc, 0x1d, 0x4402);
24471                         MP_WritePhyUshort(sc, 0x1d, 0x4448);
24472                         MP_WritePhyUshort(sc, 0x1d, 0x4894);
24473                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24474                         MP_WritePhyUshort(sc, 0x1d, 0x4c01);
24475                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24476                         MP_WritePhyUshort(sc, 0x1d, 0x4c03);
24477                         MP_WritePhyUshort(sc, 0x1d, 0x4824);
24478                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24479                         MP_WritePhyUshort(sc, 0x1d, 0x4c07);
24480                         MP_WritePhyUshort(sc, 0x1d, 0x41ef);
24481                         MP_WritePhyUshort(sc, 0x1d, 0x41ff);
24482                         MP_WritePhyUshort(sc, 0x1d, 0x4891);
24483                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24484                         MP_WritePhyUshort(sc, 0x1d, 0x4c07);
24485                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24486                         MP_WritePhyUshort(sc, 0x1d, 0x4c17);
24487                         MP_WritePhyUshort(sc, 0x1d, 0x8400);
24488                         MP_WritePhyUshort(sc, 0x1d, 0x8ef8);
24489                         MP_WritePhyUshort(sc, 0x1d, 0x41c7);
24490                         MP_WritePhyUshort(sc, 0x1d, 0x8f8d);
24491                         MP_WritePhyUshort(sc, 0x1d, 0x92d5);
24492                         MP_WritePhyUshort(sc, 0x1d, 0xa10f);
24493                         MP_WritePhyUshort(sc, 0x1d, 0xd480);
24494                         MP_WritePhyUshort(sc, 0x1d, 0x0008);
24495                         MP_WritePhyUshort(sc, 0x1d, 0xd580);
24496                         MP_WritePhyUshort(sc, 0x1d, 0x00b8);
24497                         MP_WritePhyUshort(sc, 0x1d, 0xa202);
24498                         MP_WritePhyUshort(sc, 0x1d, 0x3167);
24499                         MP_WritePhyUshort(sc, 0x1d, 0x7c04);
24500                         MP_WritePhyUshort(sc, 0x1d, 0x4404);
24501                         MP_WritePhyUshort(sc, 0x1d, 0x3167);
24502                         MP_WritePhyUshort(sc, 0x1d, 0xd484);
24503                         MP_WritePhyUshort(sc, 0x1d, 0x00f3);
24504                         MP_WritePhyUshort(sc, 0x1d, 0xd484);
24505                         MP_WritePhyUshort(sc, 0x1d, 0x00f1);
24506                         MP_WritePhyUshort(sc, 0x1d, 0x30f4);
24507                         MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
24508                         MP_WritePhyUshort(sc, 0x1d, 0x4ee0);
24509                         MP_WritePhyUshort(sc, 0x1d, 0x7c40);
24510                         MP_WritePhyUshort(sc, 0x1d, 0x5400);
24511                         MP_WritePhyUshort(sc, 0x1d, 0x4488);
24512                         MP_WritePhyUshort(sc, 0x1d, 0x41cf);
24513                         MP_WritePhyUshort(sc, 0x1d, 0x30f4);
24514                         MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
24515                         MP_WritePhyUshort(sc, 0x1d, 0x4ec0);
24516                         MP_WritePhyUshort(sc, 0x1d, 0x48f3);
24517                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24518                         MP_WritePhyUshort(sc, 0x1d, 0x4c01);
24519                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24520                         MP_WritePhyUshort(sc, 0x1d, 0x4c09);
24521                         MP_WritePhyUshort(sc, 0x1d, 0x4508);
24522                         MP_WritePhyUshort(sc, 0x1d, 0x41c7);
24523                         MP_WritePhyUshort(sc, 0x1d, 0x8fb0);
24524                         MP_WritePhyUshort(sc, 0x1d, 0xd218);
24525                         MP_WritePhyUshort(sc, 0x1d, 0x00ae);
24526                         MP_WritePhyUshort(sc, 0x1d, 0xd2a4);
24527                         MP_WritePhyUshort(sc, 0x1d, 0x009e);
24528                         MP_WritePhyUshort(sc, 0x1d, 0x3188);
24529                         MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
24530                         MP_WritePhyUshort(sc, 0x1d, 0x4e80);
24531                         MP_WritePhyUshort(sc, 0x1d, 0x4832);
24532                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24533                         MP_WritePhyUshort(sc, 0x1d, 0x4c01);
24534                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24535                         MP_WritePhyUshort(sc, 0x1d, 0x4c11);
24536                         MP_WritePhyUshort(sc, 0x1d, 0x4428);
24537                         MP_WritePhyUshort(sc, 0x1d, 0x7c40);
24538                         MP_WritePhyUshort(sc, 0x1d, 0x5440);
24539                         MP_WritePhyUshort(sc, 0x1d, 0x7c01);
24540                         MP_WritePhyUshort(sc, 0x1d, 0x5801);
24541                         MP_WritePhyUshort(sc, 0x1d, 0x7c04);
24542                         MP_WritePhyUshort(sc, 0x1d, 0x5c04);
24543                         MP_WritePhyUshort(sc, 0x1d, 0x41e8);
24544                         MP_WritePhyUshort(sc, 0x1d, 0xa4b3);
24545                         MP_WritePhyUshort(sc, 0x1d, 0x319d);
24546                         MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
24547                         MP_WritePhyUshort(sc, 0x1d, 0x4f20);
24548                         MP_WritePhyUshort(sc, 0x1d, 0x6800);
24549                         MP_WritePhyUshort(sc, 0x1d, 0x673e);
24550                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24551                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24552                         MP_WritePhyUshort(sc, 0x1d, 0x570f);
24553                         MP_WritePhyUshort(sc, 0x1d, 0x5fff);
24554                         MP_WritePhyUshort(sc, 0x1d, 0xaa04);
24555                         MP_WritePhyUshort(sc, 0x1d, 0x585b);
24556                         MP_WritePhyUshort(sc, 0x1d, 0x6100);
24557                         MP_WritePhyUshort(sc, 0x1d, 0x31ad);
24558                         MP_WritePhyUshort(sc, 0x1d, 0x5867);
24559                         MP_WritePhyUshort(sc, 0x1d, 0x6080);
24560                         MP_WritePhyUshort(sc, 0x1d, 0xbcf2);
24561                         MP_WritePhyUshort(sc, 0x1d, 0x3001);
24562                         MP_WritePhyUshort(sc, 0x1f, 0x0004);
24563                         MP_WritePhyUshort(sc, 0x1c, 0x0200);
24564                         MP_WritePhyUshort(sc, 0x19, 0x7030);
24565                         MP_WritePhyUshort(sc, 0x1f, 0x0000);
24566                 }
24567
24568                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
24569                 MP_WritePhyUshort(sc, 0x11, 0x83BA);
24570                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
24571
24572                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
24573                 ClearEthPhyBit(sc, 0x1A, BIT_2);
24574                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
24575
24576                 if (phy_power_saving == 1) {
24577                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
24578                         MP_WritePhyUshort(sc, 0x18, 0x8310);
24579                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
24580                 } else {
24581                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
24582                         MP_WritePhyUshort(sc, 0x18, 0x0310);
24583                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
24584                         DELAY(20000);
24585                 }
24586
24587                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
24588                 MP_WritePhyUshort(sc, 0x0D, 0x0007);
24589                 MP_WritePhyUshort(sc, 0x0E, 0x003C);
24590                 MP_WritePhyUshort(sc, 0x0D, 0x4007);
24591                 MP_WritePhyUshort(sc, 0x0E, 0x0000);
24592                 MP_WritePhyUshort(sc, 0x0D, 0x0000);
24593                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
24594                 MP_WritePhyUshort(sc, 0x0D, 0x0003);
24595                 MP_WritePhyUshort(sc, 0x0E, 0x0015);
24596                 MP_WritePhyUshort(sc, 0x0D, 0x4003);
24597                 MP_WritePhyUshort(sc, 0x0E, 0x0000);
24598                 MP_WritePhyUshort(sc, 0x0D, 0x0000);
24599         } else if (sc->re_type == MACFG_56) {
24600                 MP_WritePhyUshort(sc, 0x1F, 0x0A46);
24601                 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
24602                 TmpUshort = (PhyRegValue & BIT_8) ? 0 : BIT_15;
24603
24604                 MP_WritePhyUshort(sc, 0x1F, 0x0BCC);
24605                 ClearEthPhyBit(sc, 0x12, BIT_15);
24606                 SetEthPhyBit(sc, 0x12, TmpUshort);
24607
24608
24609                 MP_WritePhyUshort(sc, 0x1F, 0x0A46);
24610                 PhyRegValue = MP_ReadPhyUshort(sc, 0x13);
24611                 TmpUshort = (PhyRegValue & BIT_8) ? BIT_1 : 0;
24612
24613                 MP_WritePhyUshort(sc, 0x1F, 0x0C41);
24614                 ClearEthPhyBit(sc, 0x15, BIT_1);
24615                 SetEthPhyBit(sc, 0x15, TmpUshort);
24616
24617                 MP_WritePhyUshort(sc, 0x1F, 0x0A44);
24618                 SetEthPhyBit(sc, 0x11, (BIT_3 | BIT_2));
24619                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
24620
24621
24622                 MP_WritePhyUshort(sc, 0x1F, 0x0BCC);
24623                 ClearEthPhyBit(sc, 0x14, BIT_8);
24624                 MP_WritePhyUshort(sc, 0x1F, 0x0A44);
24625                 SetEthPhyBit(sc, 0x11, BIT_7);
24626                 SetEthPhyBit(sc, 0x11, BIT_6);
24627                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24628                 MP_WritePhyUshort(sc, 0x13, 0x8084);
24629                 ClearEthPhyBit(sc, 0x14, (BIT_14 | BIT_13));
24630                 SetEthPhyBit(sc, 0x10, BIT_12);
24631                 SetEthPhyBit(sc, 0x10, BIT_1);
24632                 SetEthPhyBit(sc, 0x10, BIT_0);
24633                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
24634
24635
24636                 MP_WritePhyUshort(sc, 0x1F, 0x0A4B);
24637                 SetEthPhyBit(sc, 0x11, BIT_2);
24638                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
24639
24640
24641
24642                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24643                 MP_WritePhyUshort(sc, 0x13, 0x8012);
24644                 SetEthPhyBit(sc, 0x14, BIT_15);
24645                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
24646
24647
24648
24649                 MP_WritePhyUshort(sc, 0x1F, 0x0C42);
24650                 ClearAndSetEthPhyBit(sc,
24651                                      0x11,
24652                                      BIT_13,
24653                                      BIT_14
24654                                     );
24655                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
24656
24657                 if (phy_power_saving == 1) {
24658                         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24659                         SetEthPhyBit(sc, 0x10, BIT_2);
24660                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
24661                 } else {
24662                         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24663                         ClearEthPhyBit(sc, 0x10, BIT_2);
24664                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
24665                         DELAY(20000);
24666                 }
24667
24668                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24669                 MP_WritePhyUshort(sc, 0x13, 0x809A);
24670                 MP_WritePhyUshort(sc, 0x14, 0x8022);
24671                 MP_WritePhyUshort(sc, 0x13, 0x80A0);
24672                 ClearAndSetEthPhyBit(sc,
24673                                      0x14,
24674                                      0xFF00,
24675                                      0x1000
24676                                     );
24677                 MP_WritePhyUshort(sc, 0x13, 0x8088);
24678                 MP_WritePhyUshort(sc, 0x14, 0x9222);
24679                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
24680
24681                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24682                 MP_WritePhyUshort(sc, 0x13, 0x8011);
24683                 ClearEthPhyBit(sc, 0x14, BIT_14);
24684                 MP_WritePhyUshort(sc, 0x1F, 0x0A40);
24685                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
24686                 MP_WritePhyUshort(sc, 0x00, 0x9200);
24687         } else if (sc->re_type == MACFG_58) {
24688                 MP_WritePhyUshort(sc, 0x1F, 0x0BCC);
24689                 ClearEthPhyBit(sc, 0x14, BIT_8);
24690                 MP_WritePhyUshort(sc, 0x1F, 0x0A44);
24691                 SetEthPhyBit(sc, 0x11, BIT_7);
24692                 SetEthPhyBit(sc, 0x11, BIT_6);
24693                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24694                 MP_WritePhyUshort(sc, 0x13, 0x8084);
24695                 ClearEthPhyBit(sc, 0x14, (BIT_14 | BIT_13));
24696                 SetEthPhyBit(sc, 0x10, BIT_12);
24697                 SetEthPhyBit(sc, 0x10, BIT_1);
24698                 SetEthPhyBit(sc, 0x10, BIT_0);
24699                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
24700
24701                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24702                 MP_WritePhyUshort(sc, 0x13, 0x8012);
24703                 SetEthPhyBit(sc, 0x14, BIT_15);
24704                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
24705
24706                 MP_WritePhyUshort(sc, 0x1F, 0x0C42);
24707                 ClearAndSetEthPhyBit(sc,
24708                                      0x11,
24709                                      BIT_13,
24710                                      BIT_14
24711                                     );
24712                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
24713
24714                 if (phy_power_saving == 1) {
24715                         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24716                         SetEthPhyBit(sc, 0x10, BIT_2);
24717                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
24718                 } else {
24719                         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24720                         ClearEthPhyBit(sc, 0x10, BIT_2);
24721                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
24722                         DELAY(20000);
24723                 }
24724
24725                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24726                 MP_WritePhyUshort(sc, 0x13, 0x8011);
24727                 ClearEthPhyBit(sc, 0x14, BIT_14);
24728                 MP_WritePhyUshort(sc, 0x1F, 0x0A40);
24729                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
24730                 MP_WritePhyUshort(sc, 0x00, 0x9200);
24731         } else if (sc->re_type == MACFG_59) {
24732                 MP_WritePhyUshort(sc, 0x1F, 0x0BCC);
24733                 ClearEthPhyBit(sc, 0x14, BIT_8);
24734                 MP_WritePhyUshort(sc, 0x1F, 0x0A44);
24735                 SetEthPhyBit(sc, 0x11, BIT_7);
24736                 SetEthPhyBit(sc, 0x11, BIT_6);
24737                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24738                 MP_WritePhyUshort(sc, 0x13, 0x8084);
24739                 ClearEthPhyBit(sc, 0x14, (BIT_14 | BIT_13));
24740                 SetEthPhyBit(sc, 0x10, BIT_12);
24741                 SetEthPhyBit(sc, 0x10, BIT_1);
24742                 SetEthPhyBit(sc, 0x10, BIT_0);
24743
24744
24745                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24746                 MP_WritePhyUshort(sc, 0x13, 0x8012);
24747                 SetEthPhyBit(sc, 0x14, BIT_15);
24748                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
24749
24750                 MP_WritePhyUshort(sc, 0x1F, 0x0BCE);
24751                 MP_WritePhyUshort(sc, 0x12, 0x8860);
24752                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
24753
24754                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24755                 MP_WritePhyUshort(sc, 0x13, 0x80F3);
24756                 ClearAndSetEthPhyBit(sc,
24757                                      0x14,
24758                                      0xFF00,
24759                                      0x8B00
24760                                     );
24761                 MP_WritePhyUshort(sc, 0x13, 0x80F0);
24762                 ClearAndSetEthPhyBit(sc,
24763                                      0x14,
24764                                      0xFF00,
24765                                      0x3A00
24766                                     );
24767                 MP_WritePhyUshort(sc, 0x13, 0x80EF);
24768                 ClearAndSetEthPhyBit(sc,
24769                                      0x14,
24770                                      0xFF00,
24771                                      0x0500
24772                                     );
24773                 MP_WritePhyUshort(sc, 0x13, 0x80F6);
24774                 ClearAndSetEthPhyBit(sc,
24775                                      0x14,
24776                                      0xFF00,
24777                                      0x6E00
24778                                     );
24779                 MP_WritePhyUshort(sc, 0x13, 0x80EC);
24780                 ClearAndSetEthPhyBit(sc,
24781                                      0x14,
24782                                      0xFF00,
24783                                      0x6800
24784                                     );
24785                 MP_WritePhyUshort(sc, 0x13, 0x80ED);
24786                 ClearAndSetEthPhyBit(sc,
24787                                      0x14,
24788                                      0xFF00,
24789                                      0x7C00
24790                                     );
24791                 MP_WritePhyUshort(sc, 0x13, 0x80F2);
24792                 ClearAndSetEthPhyBit(sc,
24793                                      0x14,
24794                                      0xFF00,
24795                                      0xF400
24796                                     );
24797                 MP_WritePhyUshort(sc, 0x13, 0x80F4);
24798                 ClearAndSetEthPhyBit(sc,
24799                                      0x14,
24800                                      0xFF00,
24801                                      0x8500
24802                                     );
24803
24804                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24805                 MP_WritePhyUshort(sc, 0x13, 0x8110);
24806                 ClearAndSetEthPhyBit(sc,
24807                                      0x14,
24808                                      0xFF00,
24809                                      0xA800
24810                                     );
24811                 MP_WritePhyUshort(sc, 0x13, 0x810F);
24812                 ClearAndSetEthPhyBit(sc,
24813                                      0x14,
24814                                      0xFF00,
24815                                      0x1D00
24816                                     );
24817                 MP_WritePhyUshort(sc, 0x13, 0x8111);
24818                 ClearAndSetEthPhyBit(sc,
24819                                      0x14,
24820                                      0xFF00,
24821                                      0xF500
24822                                     );
24823                 MP_WritePhyUshort(sc, 0x13, 0x8113);
24824                 ClearAndSetEthPhyBit(sc,
24825                                      0x14,
24826                                      0xFF00,
24827                                      0x6100
24828                                     );
24829                 MP_WritePhyUshort(sc, 0x13, 0x8115);
24830                 ClearAndSetEthPhyBit(sc,
24831                                      0x14,
24832                                      0xFF00,
24833                                      0x9200
24834                                     );
24835                 MP_WritePhyUshort(sc, 0x13, 0x810E);
24836                 ClearAndSetEthPhyBit(sc,
24837                                      0x14,
24838                                      0xFF00,
24839                                      0x0400
24840                                     );
24841                 MP_WritePhyUshort(sc, 0x13, 0x810C);
24842                 ClearAndSetEthPhyBit(sc,
24843                                      0x14,
24844                                      0xFF00,
24845                                      0x7C00
24846                                     );
24847                 MP_WritePhyUshort(sc, 0x13, 0x810B);
24848                 ClearAndSetEthPhyBit(sc,
24849                                      0x14,
24850                                      0xFF00,
24851                                      0x5A00
24852                                     );
24853
24854                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24855                 MP_WritePhyUshort(sc, 0x13, 0x80D1);
24856                 ClearAndSetEthPhyBit(sc,
24857                                      0x14,
24858                                      0xFF00,
24859                                      0xFF00
24860                                     );
24861                 MP_WritePhyUshort(sc, 0x13, 0x80CD);
24862                 ClearAndSetEthPhyBit(sc,
24863                                      0x14,
24864                                      0xFF00,
24865                                      0x9E00
24866                                     );
24867                 MP_WritePhyUshort(sc, 0x13, 0x80D3);
24868                 ClearAndSetEthPhyBit(sc,
24869                                      0x14,
24870                                      0xFF00,
24871                                      0x0E00
24872                                     );
24873                 MP_WritePhyUshort(sc, 0x13, 0x80D5);
24874                 ClearAndSetEthPhyBit(sc,
24875                                      0x14,
24876                                      0xFF00,
24877                                      0xCA00
24878                                     );
24879                 MP_WritePhyUshort(sc, 0x13, 0x80D7);
24880                 ClearAndSetEthPhyBit(sc,
24881                                      0x14,
24882                                      0xFF00,
24883                                      0x8400
24884                                     );
24885
24886                 if (phy_power_saving == 1) {
24887                         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24888                         SetEthPhyBit(sc, 0x10, BIT_2);
24889                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
24890                 } else {
24891                         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24892                         ClearEthPhyBit(sc, 0x10, BIT_2);
24893                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
24894                         DELAY(20000);
24895                 }
24896
24897                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24898                 MP_WritePhyUshort(sc, 0x13, 0x8011);
24899                 ClearEthPhyBit(sc, 0x14, BIT_14);
24900                 MP_WritePhyUshort(sc, 0x1F, 0x0A40);
24901                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
24902                 MP_WritePhyUshort(sc, 0x00, 0x9200);
24903         } else if (sc->re_type == MACFG_60) {
24904                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24905                 MP_WritePhyUshort(sc, 0x13, 0x8012);
24906                 SetEthPhyBit(sc, 0x14, BIT_15);
24907                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
24908
24909                 MP_WritePhyUshort(sc, 0x1F, 0x0BCE);
24910                 MP_WritePhyUshort(sc, 0x12, 0x8860);
24911                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
24912
24913                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24914                 MP_WritePhyUshort(sc, 0x13, 0x80F3);
24915                 ClearAndSetEthPhyBit(sc,
24916                                      0x14,
24917                                      0xFF00,
24918                                      0x8B00
24919                                     );
24920                 MP_WritePhyUshort(sc, 0x13, 0x80F0);
24921                 ClearAndSetEthPhyBit(sc,
24922                                      0x14,
24923                                      0xFF00,
24924                                      0x3A00
24925                                     );
24926                 MP_WritePhyUshort(sc, 0x13, 0x80EF);
24927                 ClearAndSetEthPhyBit(sc,
24928                                      0x14,
24929                                      0xFF00,
24930                                      0x0500
24931                                     );
24932                 MP_WritePhyUshort(sc, 0x13, 0x80F6);
24933                 ClearAndSetEthPhyBit(sc,
24934                                      0x14,
24935                                      0xFF00,
24936                                      0x6E00
24937                                     );
24938                 MP_WritePhyUshort(sc, 0x13, 0x80EC);
24939                 ClearAndSetEthPhyBit(sc,
24940                                      0x14,
24941                                      0xFF00,
24942                                      0x6800
24943                                     );
24944                 MP_WritePhyUshort(sc, 0x13, 0x80ED);
24945                 ClearAndSetEthPhyBit(sc,
24946                                      0x14,
24947                                      0xFF00,
24948                                      0x7C00
24949                                     );
24950                 MP_WritePhyUshort(sc, 0x13, 0x80F2);
24951                 ClearAndSetEthPhyBit(sc,
24952                                      0x14,
24953                                      0xFF00,
24954                                      0xF400
24955                                     );
24956                 MP_WritePhyUshort(sc, 0x13, 0x80F4);
24957                 ClearAndSetEthPhyBit(sc,
24958                                      0x14,
24959                                      0xFF00,
24960                                      0x8500
24961                                     );
24962
24963                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24964                 MP_WritePhyUshort(sc, 0x13, 0x8110);
24965                 ClearAndSetEthPhyBit(sc,
24966                                      0x14,
24967                                      0xFF00,
24968                                      0xA800
24969                                     );
24970                 MP_WritePhyUshort(sc, 0x13, 0x810F);
24971                 ClearAndSetEthPhyBit(sc,
24972                                      0x14,
24973                                      0xFF00,
24974                                      0x1D00
24975                                     );
24976                 MP_WritePhyUshort(sc, 0x13, 0x8111);
24977                 ClearAndSetEthPhyBit(sc,
24978                                      0x14,
24979                                      0xFF00,
24980                                      0xF500
24981                                     );
24982                 MP_WritePhyUshort(sc, 0x13, 0x8113);
24983                 ClearAndSetEthPhyBit(sc,
24984                                      0x14,
24985                                      0xFF00,
24986                                      0x6100
24987                                     );
24988                 MP_WritePhyUshort(sc, 0x13, 0x8115);
24989                 ClearAndSetEthPhyBit(sc,
24990                                      0x14,
24991                                      0xFF00,
24992                                      0x9200
24993                                     );
24994                 MP_WritePhyUshort(sc, 0x13, 0x810E);
24995                 ClearAndSetEthPhyBit(sc,
24996                                      0x14,
24997                                      0xFF00,
24998                                      0x0400
24999                                     );
25000                 MP_WritePhyUshort(sc, 0x13, 0x810C);
25001                 ClearAndSetEthPhyBit(sc,
25002                                      0x14,
25003                                      0xFF00,
25004                                      0x7C00
25005                                     );
25006                 MP_WritePhyUshort(sc, 0x13, 0x810B);
25007                 ClearAndSetEthPhyBit(sc,
25008                                      0x14,
25009                                      0xFF00,
25010                                      0x5A00
25011                                     );
25012
25013                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25014                 MP_WritePhyUshort(sc, 0x13, 0x80D1);
25015                 ClearAndSetEthPhyBit(sc,
25016                                      0x14,
25017                                      0xFF00,
25018                                      0xFF00
25019                                     );
25020                 MP_WritePhyUshort(sc, 0x13, 0x80CD);
25021                 ClearAndSetEthPhyBit(sc,
25022                                      0x14,
25023                                      0xFF00,
25024                                      0x9E00
25025                                     );
25026                 MP_WritePhyUshort(sc, 0x13, 0x80D3);
25027                 ClearAndSetEthPhyBit(sc,
25028                                      0x14,
25029                                      0xFF00,
25030                                      0x0E00
25031                                     );
25032                 MP_WritePhyUshort(sc, 0x13, 0x80D5);
25033                 ClearAndSetEthPhyBit(sc,
25034                                      0x14,
25035                                      0xFF00,
25036                                      0xCA00
25037                                     );
25038                 MP_WritePhyUshort(sc, 0x13, 0x80D7);
25039                 ClearAndSetEthPhyBit(sc,
25040                                      0x14,
25041                                      0xFF00,
25042                                      0x8400
25043                                     );
25044
25045                 if (phy_power_saving == 1) {
25046                         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25047                         SetEthPhyBit(sc, 0x10, BIT_2);
25048                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
25049                 } else {
25050                         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25051                         ClearEthPhyBit(sc, 0x10, BIT_2);
25052                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
25053                         DELAY(20000);
25054                 }
25055
25056                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25057                 MP_WritePhyUshort(sc, 0x13, 0x8011);
25058                 ClearEthPhyBit(sc, 0x14, BIT_14);
25059                 MP_WritePhyUshort(sc, 0x1F, 0x0A40);
25060                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25061                 MP_WritePhyUshort(sc, 0x00, 0x9200);
25062         } else if (sc->re_type == MACFG_61) {
25063                 MP_WritePhyUshort(sc, 0x1f, 0x0A43);
25064                 MP_WritePhyUshort(sc, 0x13, 0x8146);
25065                 MP_WritePhyUshort(sc, 0x14, 0x0000);
25066
25067                 MP_WritePhyUshort(sc, 0x1f, 0x0B82);
25068                 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
25069                 PhyRegValue &= ~(BIT_4);
25070                 MP_WritePhyUshort(sc, 0x10, PhyRegValue);
25071
25072                 MP_WritePhyUshort(sc, 0x1F, 0x0A44);
25073                 SetEthPhyBit(sc, 0x11, (BIT_3 | BIT_2));
25074                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25075
25076
25077                 MP_WritePhyUshort(sc, 0x1F, 0x0BCC);
25078                 ClearEthPhyBit(sc, 0x14, BIT_8);
25079                 MP_WritePhyUshort(sc, 0x1F, 0x0A44);
25080                 SetEthPhyBit(sc, 0x11, BIT_7);
25081                 SetEthPhyBit(sc, 0x11, BIT_6);
25082                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25083                 MP_WritePhyUshort(sc, 0x13, 0x8084);
25084                 ClearEthPhyBit(sc, 0x14, (BIT_14 | BIT_13));
25085                 SetEthPhyBit(sc, 0x10, BIT_12);
25086                 SetEthPhyBit(sc, 0x10, BIT_1);
25087                 SetEthPhyBit(sc, 0x10, BIT_0);
25088                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25089
25090                 MP_WritePhyUshort(sc, 0x1F, 0x0A4B);
25091                 SetEthPhyBit(sc, 0x11, BIT_2);
25092                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25093
25094                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25095                 MP_WritePhyUshort(sc, 0x13, 0x8012);
25096                 SetEthPhyBit(sc, 0x14, BIT_15);
25097                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25098
25099                 MP_WritePhyUshort(sc, 0x1F, 0x0C42);
25100                 ClearAndSetEthPhyBit(sc,
25101                                      0x11,
25102                                      BIT_13,
25103                                      BIT_14
25104                                     );
25105                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25106
25107                 if (phy_power_saving == 1) {
25108                         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25109                         SetEthPhyBit(sc, 0x10, BIT_2);
25110                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
25111                 } else {
25112                         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25113                         ClearEthPhyBit(sc, 0x10, BIT_2);
25114                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
25115                         DELAY(20000);
25116                 }
25117
25118                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25119                 MP_WritePhyUshort(sc, 0x13, 0x8011);
25120                 ClearEthPhyBit(sc, 0x14, BIT_14);
25121                 MP_WritePhyUshort(sc, 0x1F, 0x0A40);
25122                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25123                 MP_WritePhyUshort(sc, 0x00, 0x9200);
25124         } else if (sc->re_type == MACFG_62 || sc->re_type == MACFG_67) {
25125                 MP_WritePhyUshort(sc, 0x1F, 0x0BCC);
25126                 ClearEthPhyBit(sc, 0x14, BIT_8);
25127                 MP_WritePhyUshort(sc, 0x1F, 0x0A44);
25128                 SetEthPhyBit(sc, 0x11, BIT_7);
25129                 SetEthPhyBit(sc, 0x11, BIT_6);
25130                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25131                 MP_WritePhyUshort(sc, 0x13, 0x8084);
25132                 ClearEthPhyBit(sc, 0x14, (BIT_14 | BIT_13));
25133                 SetEthPhyBit(sc, 0x10, BIT_12);
25134                 SetEthPhyBit(sc, 0x10, BIT_1);
25135                 SetEthPhyBit(sc, 0x10, BIT_0);
25136                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25137
25138                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25139                 MP_WritePhyUshort(sc, 0x13, 0x8012);
25140                 SetEthPhyBit(sc, 0x14, BIT_15);
25141                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25142
25143                 MP_WritePhyUshort(sc, 0x1F, 0x0C42);
25144                 ClearAndSetEthPhyBit(sc,
25145                                      0x11,
25146                                      BIT_13,
25147                                      BIT_14
25148                                     );
25149                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25150
25151                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25152                 MP_WritePhyUshort(sc, 0x13, 0x80F3);
25153                 ClearAndSetEthPhyBit(sc,
25154                                      0x14,
25155                                      0xFF00,
25156                                      0x8B00
25157                                     );
25158                 MP_WritePhyUshort(sc, 0x13, 0x80F0);
25159                 ClearAndSetEthPhyBit(sc,
25160                                      0x14,
25161                                      0xFF00,
25162                                      0x3A00
25163                                     );
25164                 MP_WritePhyUshort(sc, 0x13, 0x80EF);
25165                 ClearAndSetEthPhyBit(sc,
25166                                      0x14,
25167                                      0xFF00,
25168                                      0x0500
25169                                     );
25170                 MP_WritePhyUshort(sc, 0x13, 0x80F6);
25171                 ClearAndSetEthPhyBit(sc,
25172                                      0x14,
25173                                      0xFF00,
25174                                      0x6E00
25175                                     );
25176                 MP_WritePhyUshort(sc, 0x13, 0x80EC);
25177                 ClearAndSetEthPhyBit(sc,
25178                                      0x14,
25179                                      0xFF00,
25180                                      0x6800
25181                                     );
25182                 MP_WritePhyUshort(sc, 0x13, 0x80ED);
25183                 ClearAndSetEthPhyBit(sc,
25184                                      0x14,
25185                                      0xFF00,
25186                                      0x7C00
25187                                     );
25188                 MP_WritePhyUshort(sc, 0x13, 0x80F2);
25189                 ClearAndSetEthPhyBit(sc,
25190                                      0x14,
25191                                      0xFF00,
25192                                      0xF400
25193                                     );
25194                 MP_WritePhyUshort(sc, 0x13, 0x80F4);
25195                 ClearAndSetEthPhyBit(sc,
25196                                      0x14,
25197                                      0xFF00,
25198                                      0x8500
25199                                     );
25200
25201                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25202                 MP_WritePhyUshort(sc, 0x13, 0x8110);
25203                 ClearAndSetEthPhyBit(sc,
25204                                      0x14,
25205                                      0xFF00,
25206                                      0xA800
25207                                     );
25208                 MP_WritePhyUshort(sc, 0x13, 0x810F);
25209                 ClearAndSetEthPhyBit(sc,
25210                                      0x14,
25211                                      0xFF00,
25212                                      0x1D00
25213                                     );
25214                 MP_WritePhyUshort(sc, 0x13, 0x8111);
25215                 ClearAndSetEthPhyBit(sc,
25216                                      0x14,
25217                                      0xFF00,
25218                                      0xF500
25219                                     );
25220                 MP_WritePhyUshort(sc, 0x13, 0x8113);
25221                 ClearAndSetEthPhyBit(sc,
25222                                      0x14,
25223                                      0xFF00,
25224                                      0x6100
25225                                     );
25226                 MP_WritePhyUshort(sc, 0x13, 0x8115);
25227                 ClearAndSetEthPhyBit(sc,
25228                                      0x14,
25229                                      0xFF00,
25230                                      0x9200
25231                                     );
25232                 MP_WritePhyUshort(sc, 0x13, 0x810E);
25233                 ClearAndSetEthPhyBit(sc,
25234                                      0x14,
25235                                      0xFF00,
25236                                      0x0400
25237                                     );
25238                 MP_WritePhyUshort(sc, 0x13, 0x810C);
25239                 ClearAndSetEthPhyBit(sc,
25240                                      0x14,
25241                                      0xFF00,
25242                                      0x7C00
25243                                     );
25244                 MP_WritePhyUshort(sc, 0x13, 0x810B);
25245                 ClearAndSetEthPhyBit(sc,
25246                                      0x14,
25247                                      0xFF00,
25248                                      0x5A00
25249                                     );
25250
25251                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25252                 MP_WritePhyUshort(sc, 0x13, 0x80D1);
25253                 ClearAndSetEthPhyBit(sc,
25254                                      0x14,
25255                                      0xFF00,
25256                                      0xFF00
25257                                     );
25258                 MP_WritePhyUshort(sc, 0x13, 0x80CD);
25259                 ClearAndSetEthPhyBit(sc,
25260                                      0x14,
25261                                      0xFF00,
25262                                      0x9E00
25263                                     );
25264                 MP_WritePhyUshort(sc, 0x13, 0x80D3);
25265                 ClearAndSetEthPhyBit(sc,
25266                                      0x14,
25267                                      0xFF00,
25268                                      0x0E00
25269                                     );
25270                 MP_WritePhyUshort(sc, 0x13, 0x80D5);
25271                 ClearAndSetEthPhyBit(sc,
25272                                      0x14,
25273                                      0xFF00,
25274                                      0xCA00
25275                                     );
25276                 MP_WritePhyUshort(sc, 0x13, 0x80D7);
25277                 ClearAndSetEthPhyBit(sc,
25278                                      0x14,
25279                                      0xFF00,
25280                                      0x8400
25281                                     );
25282
25283                 if (phy_power_saving == 1) {
25284                         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25285                         SetEthPhyBit(sc, 0x10, BIT_2);
25286                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
25287                 } else {
25288                         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25289                         ClearEthPhyBit(sc, 0x10, BIT_2);
25290                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
25291                         DELAY(20000);
25292                 }
25293
25294                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25295                 MP_WritePhyUshort(sc, 0x13, 0x8011);
25296                 ClearEthPhyBit(sc, 0x14, BIT_14);
25297                 MP_WritePhyUshort(sc, 0x1F, 0x0A40);
25298                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25299                 MP_WritePhyUshort(sc, 0x00, 0x9200);
25300         } else if (sc->re_type == MACFG_63) {
25301                 MP_WritePhyUshort(sc, 0x1f, 0x0002);
25302                 MP_WritePhyUshort(sc, 0x10, 0x0008);
25303                 MP_WritePhyUshort(sc, 0x0d, 0x006c);
25304                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
25305
25306                 MP_WritePhyUshort(sc, 0x1f, 0x0001);
25307                 MP_WritePhyUshort(sc, 0x17, 0x0cc0);
25308                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
25309
25310                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
25311                 MP_WritePhyUshort(sc, 0x0B, 0xA4D8);
25312                 MP_WritePhyUshort(sc, 0x09, 0x281C);
25313                 MP_WritePhyUshort(sc, 0x07, 0x2883);
25314                 MP_WritePhyUshort(sc, 0x0A, 0x6B35);
25315                 MP_WritePhyUshort(sc, 0x1D, 0x3DA4);
25316                 MP_WritePhyUshort(sc, 0x1C, 0xEFFD);
25317                 MP_WritePhyUshort(sc, 0x14, 0x7F52);
25318                 MP_WritePhyUshort(sc, 0x18, 0x7FC6);
25319                 MP_WritePhyUshort(sc, 0x08, 0x0601);
25320                 MP_WritePhyUshort(sc, 0x06, 0x4063);
25321                 MP_WritePhyUshort(sc, 0x10, 0xF074);
25322                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
25323                 MP_WritePhyUshort(sc, 0x13, 0x0789);
25324                 MP_WritePhyUshort(sc, 0x12, 0xF4BD);
25325                 MP_WritePhyUshort(sc, 0x1A, 0x04FD);
25326                 MP_WritePhyUshort(sc, 0x14, 0x84B0);
25327                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25328
25329                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
25330                 MP_WritePhyUshort(sc, 0x01, 0x0340);
25331                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
25332                 MP_WritePhyUshort(sc, 0x04, 0x4000);
25333                 MP_WritePhyUshort(sc, 0x03, 0x1D21);
25334                 MP_WritePhyUshort(sc, 0x02, 0x0C32);
25335                 MP_WritePhyUshort(sc, 0x01, 0x0200);
25336                 MP_WritePhyUshort(sc, 0x00, 0x5554);
25337                 MP_WritePhyUshort(sc, 0x04, 0x4800);
25338                 MP_WritePhyUshort(sc, 0x04, 0x4000);
25339                 MP_WritePhyUshort(sc, 0x04, 0xF000);
25340                 MP_WritePhyUshort(sc, 0x03, 0xDF01);
25341                 MP_WritePhyUshort(sc, 0x02, 0xDF20);
25342                 MP_WritePhyUshort(sc, 0x01, 0x101A);
25343                 MP_WritePhyUshort(sc, 0x00, 0xA0FF);
25344                 MP_WritePhyUshort(sc, 0x04, 0xF800);
25345                 MP_WritePhyUshort(sc, 0x04, 0xF000);
25346                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25347
25348                 MP_WritePhyUshort(sc, 0x1F, 0x0007);
25349                 MP_WritePhyUshort(sc, 0x1E, 0x0023);
25350                 MP_WritePhyUshort(sc, 0x16, 0x0000);
25351                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25352
25353                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25354                 PhyRegValue = MP_ReadPhyUshort(sc, 0x0D);
25355                 PhyRegValue |= (BIT_5);
25356                 MP_WritePhyUshort(sc, 0x0D, PhyRegValue);
25357
25358                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
25359                 PhyRegValue = MP_ReadPhyUshort(sc, 0x0C);
25360                 PhyRegValue |= (BIT_10);
25361                 MP_WritePhyUshort(sc, 0x0C, PhyRegValue);
25362                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25363         } else if (sc->re_type == MACFG_64) {
25364                 MP_WritePhyUshort(sc, 0x1f, 0x0001);
25365                 MP_WritePhyUshort(sc, 0x17, 0x0cc0);
25366                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
25367
25368                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
25369                 MP_WritePhyUshort(sc, 0x01, 0x0340);
25370                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
25371                 MP_WritePhyUshort(sc, 0x04, 0x4000);
25372                 MP_WritePhyUshort(sc, 0x03, 0x1D21);
25373                 MP_WritePhyUshort(sc, 0x02, 0x0C32);
25374                 MP_WritePhyUshort(sc, 0x01, 0x0200);
25375                 MP_WritePhyUshort(sc, 0x00, 0x5554);
25376                 MP_WritePhyUshort(sc, 0x04, 0x4800);
25377                 MP_WritePhyUshort(sc, 0x04, 0x4000);
25378                 MP_WritePhyUshort(sc, 0x04, 0xF000);
25379                 MP_WritePhyUshort(sc, 0x03, 0xDF01);
25380                 MP_WritePhyUshort(sc, 0x02, 0xDF20);
25381                 MP_WritePhyUshort(sc, 0x01, 0x101A);
25382                 MP_WritePhyUshort(sc, 0x00, 0xA0FF);
25383                 MP_WritePhyUshort(sc, 0x04, 0xF800);
25384                 MP_WritePhyUshort(sc, 0x04, 0xF000);
25385                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25386
25387                 MP_WritePhyUshort(sc, 0x1F, 0x0007);
25388                 MP_WritePhyUshort(sc, 0x1E, 0x0023);
25389                 MP_WritePhyUshort(sc, 0x16, 0x0000);
25390                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25391
25392                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25393                 PhyRegValue = MP_ReadPhyUshort(sc, 0x0D);
25394                 PhyRegValue |= (BIT_5);
25395                 MP_WritePhyUshort(sc, 0x0D, PhyRegValue);
25396
25397                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
25398                 PhyRegValue = MP_ReadPhyUshort(sc, 0x0C);
25399                 PhyRegValue |= (BIT_10);
25400                 MP_WritePhyUshort(sc, 0x0C, PhyRegValue);
25401                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25402         } else if (sc->re_type == MACFG_65) {
25403                 MP_WritePhyUshort(sc, 0x1f, 0x0001);
25404                 MP_WritePhyUshort(sc, 0x17, 0x0cc0);
25405                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
25406
25407                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25408                 PhyRegValue = MP_ReadPhyUshort(sc, 0x0D);
25409                 PhyRegValue |= (BIT_5);
25410                 MP_WritePhyUshort(sc, 0x0D, PhyRegValue);
25411
25412                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
25413                 PhyRegValue = MP_ReadPhyUshort(sc, 0x0C);
25414                 PhyRegValue |= (BIT_10);
25415                 MP_WritePhyUshort(sc, 0x0C, PhyRegValue);
25416                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25417
25418                 MP_WritePhyUshort(sc, 0x1F, 0x0007);
25419                 MP_WritePhyUshort(sc, 0x1E, 0x002C);
25420                 MP_WritePhyUshort(sc, 0x15, 0x035D);
25421                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
25422                 MP_WritePhyUshort(sc, 0x01, 0x0300);
25423                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25424         } else if (sc->re_type == MACFG_66) {
25425                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25426                 PhyRegValue = MP_ReadPhyUshort(sc, 0x0D);
25427                 PhyRegValue |= (BIT_5);
25428                 MP_WritePhyUshort(sc, 0x0D, PhyRegValue);
25429
25430                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
25431                 PhyRegValue = MP_ReadPhyUshort(sc, 0x0C);
25432                 PhyRegValue |= (BIT_10);
25433                 MP_WritePhyUshort(sc, 0x0C, PhyRegValue);
25434                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25435         } else if (sc->re_type == MACFG_68) {
25436                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25437                 MP_WritePhyUshort(sc, 0x13, 0x809b);
25438                 ClearAndSetEthPhyBit(sc,
25439                                      0x14,
25440                                      0xF800,
25441                                      0x8000
25442                                     );
25443                 MP_WritePhyUshort(sc, 0x13, 0x80A2);
25444                 ClearAndSetEthPhyBit(sc,
25445                                      0x14,
25446                                      0xFF00,
25447                                      0x8000
25448                                     );
25449                 MP_WritePhyUshort(sc, 0x13, 0x80A4);
25450                 ClearAndSetEthPhyBit(sc,
25451                                      0x14,
25452                                      0xFF00,
25453                                      0x8500
25454                                     );
25455                 MP_WritePhyUshort(sc, 0x13, 0x809C);
25456                 ClearAndSetEthPhyBit(sc,
25457                                      0x14,
25458                                      0xFF00,
25459                                      0xbd00
25460                                     );
25461                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25462
25463                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25464                 MP_WritePhyUshort(sc, 0x13, 0x80AD);
25465                 ClearAndSetEthPhyBit(sc,
25466                                      0x14,
25467                                      0xF800,
25468                                      0x7000
25469                                     );
25470                 MP_WritePhyUshort(sc, 0x13, 0x80B4);
25471                 ClearAndSetEthPhyBit(sc,
25472                                      0x14,
25473                                      0xFF00,
25474                                      0x5000
25475                                     );
25476                 MP_WritePhyUshort(sc, 0x13, 0x80AC);
25477                 ClearAndSetEthPhyBit(sc,
25478                                      0x14,
25479                                      0xFF00,
25480                                      0x4000
25481                                     );
25482                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25483
25484                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25485                 MP_WritePhyUshort(sc, 0x13, 0x808E);
25486                 ClearAndSetEthPhyBit(sc,
25487                                      0x14,
25488                                      0xFF00,
25489                                      0x1200
25490                                     );
25491                 MP_WritePhyUshort(sc, 0x13, 0x8090);
25492                 ClearAndSetEthPhyBit(sc,
25493                                      0x14,
25494                                      0xFF00,
25495                                      0xE500
25496                                     );
25497                 MP_WritePhyUshort(sc, 0x13, 0x8092);
25498                 ClearAndSetEthPhyBit(sc,
25499                                      0x14,
25500                                      0xFF00,
25501                                      0x9F00
25502                                     );
25503                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25504
25505                 dout_tapbin = 0x0000;
25506                 MP_WritePhyUshort(sc, 0x1F, 0x0A46);
25507                 TmpUshort = MP_ReadPhyUshort(sc, 0x13);
25508                 TmpUshort &= (BIT_1|BIT_0);
25509                 TmpUshort <<= 2;
25510                 dout_tapbin |= TmpUshort;
25511
25512                 TmpUshort = MP_ReadPhyUshort(sc, 0x12);
25513                 TmpUshort &= (BIT_15|BIT_14);
25514                 TmpUshort >>= 14;
25515                 dout_tapbin |= TmpUshort;
25516
25517                 dout_tapbin = ~(dout_tapbin^BIT_3);
25518                 dout_tapbin <<= 12;
25519                 dout_tapbin &= 0xF000;
25520
25521                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25522
25523                 MP_WritePhyUshort(sc, 0x13, 0x827A);
25524                 ClearAndSetEthPhyBit(sc,
25525                                      0x14,
25526                                      BIT_15|BIT_14|BIT_13|BIT_12,
25527                                      dout_tapbin
25528                                     );
25529
25530
25531                 MP_WritePhyUshort(sc, 0x13, 0x827B);
25532                 ClearAndSetEthPhyBit(sc,
25533                                      0x14,
25534                                      BIT_15|BIT_14|BIT_13|BIT_12,
25535                                      dout_tapbin
25536                                     );
25537
25538
25539                 MP_WritePhyUshort(sc, 0x13, 0x827C);
25540                 ClearAndSetEthPhyBit(sc,
25541                                      0x14,
25542                                      BIT_15|BIT_14|BIT_13|BIT_12,
25543                                      dout_tapbin
25544                                     );
25545
25546
25547                 MP_WritePhyUshort(sc, 0x13, 0x827D);
25548                 ClearAndSetEthPhyBit(sc,
25549                                      0x14,
25550                                      BIT_15|BIT_14|BIT_13|BIT_12,
25551                                      dout_tapbin
25552                                     );
25553
25554                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25555                 MP_WritePhyUshort(sc, 0x13, 0x8011);
25556                 SetEthPhyBit(sc, 0x14, BIT_11);
25557                 MP_WritePhyUshort(sc, 0x1F, 0x0A42);
25558                 SetEthPhyBit(sc, 0x16, BIT_1);
25559
25560                 MP_WritePhyUshort(sc, 0x1F, 0x0A44);
25561                 SetEthPhyBit(sc, 0x11, BIT_11);
25562                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25563
25564                 MP_WritePhyUshort(sc, 0x1F, 0x0BCA);
25565                 ClearAndSetEthPhyBit(sc,
25566                                      0x17,
25567                                      (BIT_13 | BIT_12),
25568                                      BIT_14
25569                                     );
25570                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25571
25572                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25573                 MP_WritePhyUshort(sc, 0x13, 0x803F);
25574                 ClearEthPhyBit(sc, 0x14, (BIT_13 | BIT_12));
25575                 MP_WritePhyUshort(sc, 0x13, 0x8047);
25576                 ClearEthPhyBit(sc, 0x14, (BIT_13 | BIT_12));
25577                 MP_WritePhyUshort(sc, 0x13, 0x804F);
25578                 ClearEthPhyBit(sc, 0x14, (BIT_13 | BIT_12));
25579                 MP_WritePhyUshort(sc, 0x13, 0x8057);
25580                 ClearEthPhyBit(sc, 0x14, (BIT_13 | BIT_12));
25581                 MP_WritePhyUshort(sc, 0x13, 0x805F);
25582                 ClearEthPhyBit(sc, 0x14, (BIT_13 | BIT_12));
25583                 MP_WritePhyUshort(sc, 0x13, 0x8067);
25584                 ClearEthPhyBit(sc, 0x14, (BIT_13 | BIT_12));
25585                 MP_WritePhyUshort(sc, 0x13, 0x806F);
25586                 ClearEthPhyBit(sc, 0x14, (BIT_13 | BIT_12));
25587                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25588
25589                 if (phy_power_saving == 1) {
25590                         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25591                         SetEthPhyBit(sc, 0x10, BIT_2);
25592                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
25593                 } else {
25594                         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25595                         ClearEthPhyBit(sc, 0x10, BIT_2);
25596                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
25597                         DELAY(20000);
25598                 }
25599
25600                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25601                 MP_WritePhyUshort(sc, 0x13, 0x8045);
25602                 MP_WritePhyUshort(sc, 0x14, 0x2444);
25603                 MP_WritePhyUshort(sc, 0x13, 0x804d);
25604                 MP_WritePhyUshort(sc, 0x14, 0x2444);
25605                 MP_WritePhyUshort(sc, 0x13, 0x805d);
25606                 MP_WritePhyUshort(sc, 0x14, 0x2444);
25607                 MP_WritePhyUshort(sc, 0x13, 0x8011);
25608                 SetEthPhyBit(sc, 0x14, BIT_15);
25609                 MP_WritePhyUshort(sc, 0x1F, 0x0A40);
25610                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25611                 MP_WritePhyUshort(sc, 0x00, 0x9200);
25612         } else if (sc->re_type == MACFG_69) {
25613                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25614                 MP_WritePhyUshort(sc, 0x13, 0x808A);
25615                 ClearAndSetEthPhyBit(sc,
25616                                      0x14,
25617                                      BIT_5 | BIT_4 | BIT_3 | BIT_2 | BIT_1 | BIT_0,
25618                                      0x0A);
25619
25620                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25621                 MP_WritePhyUshort(sc, 0x13, 0x8011);
25622                 SetEthPhyBit(sc, 0x14, BIT_11);
25623                 MP_WritePhyUshort(sc, 0x1F, 0x0A42);
25624                 SetEthPhyBit(sc, 0x16, BIT_1);
25625
25626                 MP_WritePhyUshort(sc, 0x1F, 0x0A44);
25627                 SetEthPhyBit(sc, 0x11, BIT_11);
25628                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25629
25630                 if (sc->RequireAdcBiasPatch) {
25631                         MP_WritePhyUshort(sc, 0x1F, 0x0BCF);
25632                         MP_WritePhyUshort(sc, 0x16, sc->AdcBiasPatchIoffset);
25633                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
25634                 }
25635
25636                 {
25637                         u_int16_t rlen;
25638
25639                         MP_WritePhyUshort(sc, 0x1F, 0x0BCD);
25640                         PhyRegValue = MP_ReadPhyUshort(sc, 0x16);
25641                         PhyRegValue &= 0x000F;
25642
25643                         if (PhyRegValue > 3) {
25644                                 rlen = PhyRegValue - 3;
25645                         } else {
25646                                 rlen = 0;
25647                         }
25648
25649                         PhyRegValue = rlen | (rlen<<4) | (rlen<<8) | (rlen<<12);
25650
25651                         MP_WritePhyUshort(sc, 0x1F, 0x0BCD);
25652                         MP_WritePhyUshort(sc, 0x17, PhyRegValue);
25653                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
25654                 }
25655
25656                 if (phy_power_saving == 1) {
25657                         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25658                         SetEthPhyBit(sc, 0x10, BIT_2);
25659                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
25660                 } else {
25661                         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25662                         ClearEthPhyBit(sc, 0x10, BIT_2);
25663                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
25664                         DELAY(20000);
25665                 }
25666
25667                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25668                 MP_WritePhyUshort(sc, 0x13, 0x8045);
25669                 MP_WritePhyUshort(sc, 0x14, 0x2444);
25670                 MP_WritePhyUshort(sc, 0x13, 0x804d);
25671                 MP_WritePhyUshort(sc, 0x14, 0x2444);
25672                 MP_WritePhyUshort(sc, 0x13, 0x805d);
25673                 MP_WritePhyUshort(sc, 0x14, 0x2444);
25674                 MP_WritePhyUshort(sc, 0x13, 0x8011);
25675                 SetEthPhyBit(sc, 0x14, BIT_15);
25676                 MP_WritePhyUshort(sc, 0x1F, 0x0A40);
25677                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25678                 MP_WritePhyUshort(sc, 0x00, 0x9200);
25679         }  else if (sc->re_type == MACFG_70 || sc->re_type == MACFG_71) {
25680                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25681                 MP_WritePhyUshort(sc, 0x13, 0x808E);
25682                 ClearAndSetEthPhyBit(sc,
25683                                      0x14,
25684                                      0xFF00,
25685                                      0x4800);
25686                 MP_WritePhyUshort(sc, 0x13, 0x8090);
25687                 ClearAndSetEthPhyBit(sc,
25688                                      0x14,
25689                                      0xFF00,
25690                                      0xCC00);
25691                 MP_WritePhyUshort(sc, 0x13, 0x8092);
25692                 ClearAndSetEthPhyBit(sc,
25693                                      0x14,
25694                                      0xFF00,
25695                                      0xB000);
25696                 MP_WritePhyUshort(sc, 0x13, 0x8088);
25697                 ClearAndSetEthPhyBit(sc,
25698                                      0x14,
25699                                      0xFF00,
25700                                      0x6000);
25701                 MP_WritePhyUshort(sc, 0x13, 0x808B);
25702                 ClearAndSetEthPhyBit(sc,
25703                                      0x14,
25704                                      BIT_13|BIT_12|BIT_11|BIT_10|BIT_9|BIT_8,
25705                                      0x0B00);
25706                 MP_WritePhyUshort(sc, 0x13, 0x808D);
25707                 ClearAndSetEthPhyBit(sc,
25708                                      0x14,
25709                                      BIT_12|BIT_11|BIT_10|BIT_9|BIT_8,
25710                                      0x0600);
25711                 MP_WritePhyUshort(sc, 0x13, 0x808C);
25712                 ClearAndSetEthPhyBit(sc,
25713                                      0x14,
25714                                      0xFF00,
25715                                      0xB000);
25716
25717                 MP_WritePhyUshort(sc, 0x13, 0x80A0);
25718                 ClearAndSetEthPhyBit(sc,
25719                                      0x14,
25720                                      0xFF00,
25721                                      0x2800);
25722                 MP_WritePhyUshort(sc, 0x13, 0x80A2);
25723                 ClearAndSetEthPhyBit(sc,
25724                                      0x14,
25725                                      0xFF00,
25726                                      0x5000);
25727                 MP_WritePhyUshort(sc, 0x13, 0x809B);
25728                 ClearAndSetEthPhyBit(sc,
25729                                      0x14,
25730                                      BIT_15|BIT_14|BIT_13|BIT_12|BIT_11,
25731                                      BIT_15|BIT_13|BIT_12);
25732                 MP_WritePhyUshort(sc, 0x13, 0x809A);
25733                 ClearAndSetEthPhyBit(sc,
25734                                      0x14,
25735                                      0xFF00,
25736                                      0x4B00);
25737                 MP_WritePhyUshort(sc, 0x13, 0x809D);
25738                 ClearAndSetEthPhyBit(sc,
25739                                      0x14,
25740                                      BIT_13|BIT_12|BIT_11|BIT_10|BIT_9|BIT_8,
25741                                      0x0800);
25742                 MP_WritePhyUshort(sc, 0x13, 0x80A1);
25743                 ClearAndSetEthPhyBit(sc,
25744                                      0x14,
25745                                      0xFF00,
25746                                      0x7000);
25747                 MP_WritePhyUshort(sc, 0x13, 0x809F);
25748                 ClearAndSetEthPhyBit(sc,
25749                                      0x14,
25750                                      BIT_12|BIT_11|BIT_10|BIT_9|BIT_8,
25751                                      0x0300);
25752                 MP_WritePhyUshort(sc, 0x13, 0x809E);
25753                 ClearAndSetEthPhyBit(sc,
25754                                      0x14,
25755                                      0xFF00,
25756                                      0x8800);
25757
25758                 MP_WritePhyUshort(sc, 0x13, 0x80B2);
25759                 ClearAndSetEthPhyBit(sc,
25760                                      0x14,
25761                                      0xFF00,
25762                                      0x2200);
25763                 MP_WritePhyUshort(sc, 0x13, 0x80AD);
25764                 ClearAndSetEthPhyBit(sc,
25765                                      0x14,
25766                                      BIT_15|BIT_14|BIT_13|BIT_12|BIT_11,
25767                                      BIT_15|BIT_12|BIT_11);
25768                 MP_WritePhyUshort(sc, 0x13, 0x80AF);
25769                 ClearAndSetEthPhyBit(sc,
25770                                      0x14,
25771                                      BIT_13|BIT_12|BIT_11|BIT_10|BIT_9|BIT_8,
25772                                      0x0800);
25773                 MP_WritePhyUshort(sc, 0x13, 0x80B3);
25774                 ClearAndSetEthPhyBit(sc,
25775                                      0x14,
25776                                      0xFF00,
25777                                      0x6F00);
25778                 MP_WritePhyUshort(sc, 0x13, 0x80B1);
25779                 ClearAndSetEthPhyBit(sc,
25780                                      0x14,
25781                                      BIT_12|BIT_11|BIT_10|BIT_9|BIT_8,
25782                                      0x0300);
25783                 MP_WritePhyUshort(sc, 0x13, 0x80B0);
25784                 ClearAndSetEthPhyBit(sc,
25785                                      0x14,
25786                                      0xFF00,
25787                                      0x9300);
25788                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25789
25790                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25791                 MP_WritePhyUshort(sc, 0x13, 0x8011);
25792                 SetEthPhyBit(sc, 0x14, BIT_11);
25793                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25794
25795                 MP_WritePhyUshort(sc, 0x1F, 0x0A44);
25796                 SetEthPhyBit( sc, 0x11, BIT_11 );
25797                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25798
25799                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25800                 MP_WritePhyUshort(sc, 0x13, 0x8016);
25801                 SetEthPhyBit(sc, 0x14, BIT_10);
25802                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25803
25804                 if (phy_power_saving == 1) {
25805                         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25806                         SetEthPhyBit(sc, 0x10, BIT_2);
25807                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
25808                 } else {
25809                         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25810                         ClearEthPhyBit(sc, 0x10, BIT_2);
25811                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
25812                         DELAY(20000);
25813                 }
25814
25815                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25816                 MP_WritePhyUshort(sc, 0x13, 0x8045);
25817                 MP_WritePhyUshort(sc, 0x14, 0x2444);
25818                 MP_WritePhyUshort(sc, 0x13, 0x804d);
25819                 MP_WritePhyUshort(sc, 0x14, 0x2444);
25820                 MP_WritePhyUshort(sc, 0x13, 0x805d);
25821                 MP_WritePhyUshort(sc, 0x14, 0x2444);
25822                 MP_WritePhyUshort(sc, 0x13, 0x8011);
25823                 SetEthPhyBit(sc, 0x14, BIT_15);
25824                 MP_WritePhyUshort(sc, 0x1F, 0x0A40);
25825                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25826                 MP_WritePhyUshort(sc, 0x00, 0x9200);
25827         }
25828         //EthPhyPPSW
25829         if (sc->re_type == MACFG_56 || sc->re_type == MACFG_56 ||
25830             sc->re_type == MACFG_58 || sc->re_type == MACFG_58 ||
25831             sc->re_type == MACFG_60) {
25832                 //disable EthPhyPPSW
25833                 MP_WritePhyUshort(sc, 0x1F, 0x0BCD);
25834                 MP_WritePhyUshort(sc, 0x14, 0x5065);
25835                 MP_WritePhyUshort(sc, 0x14, 0xD065);
25836                 MP_WritePhyUshort(sc, 0x1F, 0x0BC8);
25837                 MP_WritePhyUshort(sc, 0x12, 0x00ED);
25838                 MP_WritePhyUshort(sc, 0x1F, 0x0BCD);
25839                 MP_WritePhyUshort(sc, 0x14, 0x1065);
25840                 MP_WritePhyUshort(sc, 0x14, 0x9065);
25841                 MP_WritePhyUshort(sc, 0x14, 0x1065);
25842                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25843         } else if (sc->re_type == MACFG_68 || sc->re_type == MACFG_69) {
25844                 //enable EthPhyPPSW
25845                 MP_WritePhyUshort(sc, 0x1F, 0x0A44);
25846                 SetEthPhyBit(sc, 0x11, BIT_7);
25847                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25848         }
25849
25850         switch(sc->re_type) {
25851         case MACFG_56:
25852         case MACFG_57:
25853         case MACFG_58:
25854         case MACFG_59:
25855         case MACFG_60:
25856         case MACFG_61:
25857         case MACFG_62:
25858         case MACFG_67:
25859         case MACFG_68:
25860         case MACFG_69:
25861         case MACFG_70:
25862         case MACFG_71:
25863                 if (phy_mdix_mode == RE_ETH_PHY_FORCE_MDI) {
25864                         //Force MDI
25865                         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25866                         SetEthPhyBit(sc, 0x10, BIT_8 | BIT_9);
25867                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
25868                 } else if (phy_mdix_mode == RE_ETH_PHY_FORCE_MDIX) {
25869                         //Force MDIX
25870                         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25871                         ClearEthPhyBit(sc, 0x10, BIT_8);
25872                         SetEthPhyBit(sc, 0x10, BIT_9);
25873                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
25874                 } else {
25875                         //Auto MDI/MDIX
25876                         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25877                         ClearEthPhyBit(sc, 0x10, BIT_8 | BIT_9);
25878                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
25879                 }
25880
25881                 break;
25882         }
25883
25884         if (phy_power_saving == 1) {
25885                 if (sc->re_type == MACFG_59 || sc->re_type == MACFG_60 ||
25886                     sc->re_type == MACFG_62 || sc->re_type == MACFG_67 ||
25887                     sc->re_type == MACFG_68 || sc->re_type == MACFG_69 ||
25888                     sc->re_type == MACFG_70 || sc->re_type == MACFG_71) {
25889                         MP_WritePhyOcpRegWord(sc, 0x0C41, 0x13, 0x0000);
25890                         MP_WritePhyOcpRegWord(sc, 0x0C41, 0x13, 0x0050);
25891                 }
25892         }
25893
25894         if (eee_enable == 1)
25895                 re_enable_EEE(sc);
25896         else
25897                 re_disable_EEE(sc);
25898
25899         MP_WritePhyUshort(sc, 0x1F, 0x0000);
25900 }
25901
25902 void MP_WritePhyUshort(struct re_softc *sc,u_int8_t RegAddr,u_int16_t RegData)
25903 {
25904         u_int32_t               TmpUlong=0x80000000;
25905         u_int32_t               Timeout=0;
25906
25907         if (RegAddr == 0x1F) {
25908                 sc->cur_page = RegData;
25909         }
25910
25911         if (sc->re_type == MACFG_63) {
25912                 int i;
25913                 CSR_WRITE_4(sc, RE_OCPDR, OCPDR_Write |
25914                             (RegAddr & OCPDR_Reg_Mask) << OCPDR_GPHY_Reg_shift |
25915                             (RegData & OCPDR_Data_Mask));
25916                 CSR_WRITE_4(sc, RE_OCPAR, OCPAR_GPHY_Write);
25917                 CSR_WRITE_4(sc, RE_EPHY_RXER_NUM, 0);
25918
25919                 for (i = 0; i < 100; i++) {
25920                         DELAY(1000);
25921                         if (!(CSR_READ_4(sc, RE_OCPAR) & OCPAR_Flag))
25922                                 break;
25923                 }
25924         } else if (sc->re_type == MACFG_56 || sc->re_type == MACFG_57 ||
25925                    sc->re_type == MACFG_58 || sc->re_type == MACFG_59 ||
25926                    sc->re_type == MACFG_60 || sc->re_type == MACFG_61 ||
25927                    sc->re_type == MACFG_62 || sc->re_type == MACFG_67 ||
25928                    sc->re_type == MACFG_69 || sc->re_type == MACFG_69 ||
25929                    sc->re_type == MACFG_70 || sc->re_type == MACFG_71) {
25930                 if (RegAddr == 0x1F) {
25931                         return;
25932                 }
25933
25934                 MP_WritePhyOcpRegWord(sc, sc->cur_page, RegAddr, RegData);
25935         } else {
25936                 if (sc->re_type == MACFG_65 || sc->re_type == MACFG_66)
25937                         CSR_WRITE_4(sc, 0xD0, CSR_READ_4(sc, 0xD0) & ~0x00020000);
25938
25939                 TmpUlong |= (((u_int32_t)RegAddr)<<16 | (u_int32_t)RegData);
25940
25941                 CSR_WRITE_4(sc, RE_PHYAR, TmpUlong);
25942
25943                 /* Wait for writing to Phy ok */
25944                 for (Timeout=0; Timeout<5; Timeout++) {
25945                         DELAY(1000);
25946                         if ((CSR_READ_4(sc, RE_PHYAR)&PHYAR_Flag)==0)
25947                                 break;
25948                 }
25949
25950                 if (sc->re_type == MACFG_65 || sc->re_type == MACFG_66)
25951                         CSR_WRITE_4(sc, 0xD0, CSR_READ_4(sc, 0xD0) | 0x00020000);
25952         }
25953 }
25954
25955 u_int16_t MP_ReadPhyUshort(struct re_softc *sc,u_int8_t RegAddr)
25956 {
25957         u_int16_t               RegData;
25958         u_int32_t               TmpUlong;
25959         u_int32_t               Timeout=0;
25960
25961         if (sc->re_type == MACFG_63) {
25962                 int i;
25963                 CSR_WRITE_4(sc, RE_OCPDR, OCPDR_Read |
25964                             (RegAddr & OCPDR_Reg_Mask) << OCPDR_GPHY_Reg_shift);
25965                 CSR_WRITE_4(sc, RE_OCPAR, OCPAR_GPHY_Write);
25966                 CSR_WRITE_4(sc, RE_EPHY_RXER_NUM, 0);
25967
25968                 for (i = 0; i < 100; i++) {
25969                         DELAY(1000);
25970                         if (!(CSR_READ_4(sc, RE_OCPAR) & OCPAR_Flag))
25971                                 break;
25972                 }
25973
25974                 DELAY(1000);
25975                 CSR_WRITE_4(sc, RE_OCPAR, OCPAR_GPHY_Read);
25976                 CSR_WRITE_4(sc, RE_EPHY_RXER_NUM, 0);
25977
25978                 for (i = 0; i < 100; i++) {
25979                         DELAY(1000);
25980                         if (CSR_READ_4(sc, RE_OCPAR) & OCPAR_Flag)
25981                                 break;
25982                 }
25983
25984                 RegData = CSR_READ_4(sc, RE_OCPDR) & OCPDR_Data_Mask;
25985         } else if (sc->re_type == MACFG_56 || sc->re_type == MACFG_57 ||
25986                    sc->re_type == MACFG_58 || sc->re_type == MACFG_59 ||
25987                    sc->re_type == MACFG_60 || sc->re_type == MACFG_61 ||
25988                    sc->re_type == MACFG_62 || sc->re_type == MACFG_67 ||
25989                    sc->re_type == MACFG_69 || sc->re_type == MACFG_69 ||
25990                    sc->re_type == MACFG_70 || sc->re_type == MACFG_71) {
25991                 RegData= MP_ReadPhyOcpRegWord(sc, sc->cur_page, RegAddr);
25992
25993         } else {
25994                 if (sc->re_type == MACFG_65 || sc->re_type == MACFG_66)
25995                         CSR_WRITE_4(sc, 0xD0, CSR_READ_4(sc, 0xD0) & ~0x00020000);
25996
25997                 TmpUlong = ((u_int32_t)RegAddr << 16);
25998                 CSR_WRITE_4(sc, RE_PHYAR, TmpUlong);
25999
26000                 /* Wait for writing to Phy ok */
26001                 for (Timeout=0; Timeout<5; Timeout++) {
26002                         DELAY(1000);
26003                         TmpUlong = CSR_READ_4(sc, RE_PHYAR);
26004                         if ((TmpUlong&PHYAR_Flag)!=0)
26005                                 break;
26006                 }
26007
26008                 RegData = (u_int16_t)(TmpUlong & 0x0000ffff);
26009
26010                 if (sc->re_type == MACFG_65 || sc->re_type == MACFG_66)
26011                         CSR_WRITE_4(sc, 0xD0, CSR_READ_4(sc, 0xD0) | 0x00020000);
26012         }
26013
26014         return RegData;
26015 }
26016
26017 void MP_WriteEPhyUshort(struct re_softc *sc, u_int8_t RegAddr, u_int16_t RegData)
26018 {
26019         u_int32_t               TmpUlong=0x80000000;
26020         u_int32_t               Timeout=0;
26021
26022         TmpUlong |= (((u_int32_t)RegAddr<<16) | (u_int32_t)RegData);
26023
26024         CSR_WRITE_4(sc, RE_EPHYAR, TmpUlong);
26025
26026         /* Wait for writing to Phy ok */
26027         for (Timeout=0; Timeout<5; Timeout++) {
26028                 DELAY(1000);
26029                 if ((CSR_READ_4(sc, RE_EPHYAR)&PHYAR_Flag)==0)
26030                         break;
26031         }
26032 }
26033
26034 u_int16_t MP_ReadEPhyUshort(struct re_softc *sc, u_int8_t RegAddr)
26035 {
26036         u_int16_t               RegData;
26037         u_int32_t               TmpUlong;
26038         u_int32_t               Timeout=0;
26039
26040         TmpUlong = ((u_int32_t)RegAddr << 16);
26041         CSR_WRITE_4(sc, RE_EPHYAR, TmpUlong);
26042
26043         /* Wait for writing to Phy ok */
26044         for (Timeout=0; Timeout<5; Timeout++) {
26045                 DELAY(1000);
26046                 TmpUlong = CSR_READ_4(sc, RE_EPHYAR);
26047                 if ((TmpUlong&PHYAR_Flag)!=0)
26048                         break;
26049         }
26050
26051         RegData = (u_int16_t)(TmpUlong & 0x0000ffff);
26052
26053         return RegData;
26054 }
26055
26056 static u_int8_t re_calc_efuse_dummy_bit(u_int16_t reg)
26057 {
26058         int s,a,b;
26059         u_int8_t dummyBitPos = 0;
26060
26061
26062         s=reg% 32;
26063         a=s % 16;
26064         b=s/16;
26065
26066         if (s/16) {
26067                 dummyBitPos = (u_int8_t)(16-a);
26068         } else {
26069                 dummyBitPos = (u_int8_t)a;
26070         }
26071
26072         return dummyBitPos;
26073 }
26074
26075 static u_int32_t re_decode_efuse_cmd(struct re_softc *sc, u_int32_t DwCmd)
26076 {
26077         u_int16_t reg = (u_int16_t)((DwCmd & 0x00FE0000) >> 17);
26078         u_int32_t DummyPos = re_calc_efuse_dummy_bit(reg);
26079         u_int32_t DeCodeDwCmd = DwCmd;
26080         u_int32_t Dw17BitData;
26081
26082
26083         if (sc->re_efuse_ver < 3) {
26084                 DeCodeDwCmd = (DwCmd>>(DummyPos+1))<<DummyPos;
26085                 if (DummyPos > 0) {
26086                         DeCodeDwCmd |= ((DwCmd<<(32-DummyPos))>>(32-DummyPos));
26087                 }
26088         } else {
26089                 reg = (u_int16_t)((DwCmd & 0x007F0000) >> 16);
26090                 DummyPos = re_calc_efuse_dummy_bit(reg);
26091                 Dw17BitData = ((DwCmd & BIT_23) >> 23);
26092                 Dw17BitData <<= 16;
26093                 Dw17BitData |= (DwCmd & 0x0000FFFF);
26094                 DeCodeDwCmd = (Dw17BitData>>(DummyPos+1))<<DummyPos;
26095                 if (DummyPos > 0) {
26096                         DeCodeDwCmd |= ((Dw17BitData<<(32-DummyPos))>>(32-DummyPos));
26097                 }
26098         }
26099
26100         return DeCodeDwCmd;
26101 }
26102
26103 #define EFUSE_WRITE 0x80000000
26104 #define EFUSE_WRITE_OK  0x00000000
26105 #define EFUSE_READ  0x00000000
26106 #define EFUSE_READ_OK  0x80000000
26107 #define EFUSE_Reg_Mask 0x03FF
26108 #define EFUSE_Reg_Shift 8
26109 #define EFUSE_Check_Cnt 300
26110 #define EFUSE_READ_FAIL 0xFF
26111 #define EFUSE_Data_Mask 0x000000FF
26112
26113 u_int8_t MP_ReadEfuse(struct re_softc *sc, u_int16_t reg)
26114 {
26115         u_int8_t efuse_data = 0;
26116         u_int32_t temp;
26117         u_int32_t cnt;
26118
26119         if (sc->re_efuse_ver == EFUSE_NOT_SUPPORT)
26120                 return EFUSE_READ_FAIL;
26121
26122         if (sc->re_efuse_ver == EFUSE_SUPPORT_V1) {
26123                 temp = EFUSE_READ | ((reg & EFUSE_Reg_Mask) << EFUSE_Reg_Shift);
26124                 CSR_WRITE_4(sc, RE_EFUSEAR, temp);
26125
26126                 cnt = 0;
26127                 do {
26128                         DELAY(100);
26129                         temp = CSR_READ_4(sc, RE_EFUSEAR);
26130                         cnt++;
26131                 } while (!(temp & EFUSE_READ_OK) && (cnt < EFUSE_Check_Cnt));
26132
26133                 if (cnt == EFUSE_Check_Cnt)
26134                         efuse_data = EFUSE_READ_FAIL;
26135                 else
26136                         efuse_data = (u_int8_t)(CSR_READ_4(sc, RE_EFUSEAR) & EFUSE_Data_Mask);
26137         } else  if (sc->re_efuse_ver == EFUSE_SUPPORT_V2) {
26138                 temp = (reg/2) & 0x03ff;
26139                 temp <<= 17;
26140                 temp |= EFUSE_READ;
26141                 CSR_WRITE_4(sc, RE_EFUSEAR, temp);
26142
26143                 cnt = 0;
26144                 do {
26145                         DELAY(100);
26146                         temp = CSR_READ_4(sc, RE_EFUSEAR);
26147                         cnt++;
26148                 } while (!(temp & EFUSE_READ_OK) && (cnt < EFUSE_Check_Cnt));
26149
26150                 if (cnt == EFUSE_Check_Cnt) {
26151                         efuse_data = EFUSE_READ_FAIL;
26152                 } else {
26153                         temp = CSR_READ_4(sc, RE_EFUSEAR);
26154                         temp = re_decode_efuse_cmd(sc, temp);
26155
26156                         if (reg%2) {
26157                                 temp >>= 8;
26158                                 efuse_data = (u_int8_t)temp;
26159                         } else {
26160                                 efuse_data = (u_int8_t)temp;
26161                         }
26162                 }
26163         } else  if (sc->re_efuse_ver == EFUSE_SUPPORT_V3) {
26164                 temp = (reg/2) & 0x03ff;
26165                 temp <<= 16;
26166                 temp |= EFUSE_READ;
26167                 CSR_WRITE_4(sc, RE_EFUSEAR, temp);
26168
26169                 cnt = 0;
26170                 do {
26171                         DELAY(100);
26172                         temp = CSR_READ_4(sc, RE_EFUSEAR);
26173                         cnt++;
26174                 } while (!(temp & EFUSE_READ_OK) && (cnt < EFUSE_Check_Cnt));
26175
26176                 if (cnt == EFUSE_Check_Cnt) {
26177                         efuse_data = EFUSE_READ_FAIL;
26178                 } else {
26179                         temp = CSR_READ_4(sc, RE_EFUSEAR);
26180                         temp = re_decode_efuse_cmd(sc, temp);
26181
26182                         if (reg%2) {
26183                                 temp >>= 8;
26184                                 efuse_data = (u_int8_t)temp;
26185                         } else {
26186                                 efuse_data = (u_int8_t)temp;
26187                         }
26188                 }
26189         }
26190
26191         DELAY(20);
26192
26193         return efuse_data;
26194 }
26195
26196 void MP_WriteOtherFunPciEConfigSpace(
26197         struct re_softc *sc,
26198         u_int8_t MultiFunSelBit,
26199         u_int16_t ByteEnAndAddr,
26200         u_int32_t RegData)
26201 {
26202         u_int32_t Timeout = 0, WaitCount = 10;
26203         u_int32_t TmpUlong = 0x80000000;
26204         u_int32_t WriteDone;
26205
26206         if (MultiFunSelBit > 7) {
26207                 return;
26208         }
26209
26210         TmpUlong |= MultiFunSelBit << 16;
26211
26212         CSR_WRITE_4(sc, RE_CSIDR, RegData);
26213         TmpUlong |= (u_int32_t) ByteEnAndAddr;
26214         CSR_WRITE_4(sc, RE_CSIAR, TmpUlong);
26215
26216         do {
26217                 DELAY(100);
26218
26219                 WriteDone = CSR_READ_4(sc, RE_CSIAR);
26220                 Timeout++;
26221         } while (((WriteDone & 0x80000000) != 0) && (Timeout < WaitCount));
26222
26223
26224         DELAY(50);
26225 }
26226
26227 u_int32_t MP_ReadOtherFunPciEConfigSpace(
26228         struct re_softc *sc,
26229         u_int8_t MultiFunSelBit,
26230         u_int16_t ByteEnAndAddr)
26231 {
26232         u_int32_t Timeout = 0, WaitCount = 10;
26233         u_int32_t TmpUlong = 0x00000000;
26234         u_int32_t ReadDone;
26235         u_int32_t RetVal = 0xffffffff;
26236
26237         if (MultiFunSelBit > 7) {
26238                 return 0xffffffff;
26239         }
26240
26241         TmpUlong |= MultiFunSelBit << 16;
26242
26243         TmpUlong |= (u_int32_t) ByteEnAndAddr;
26244         CSR_WRITE_4(sc, RE_CSIAR, TmpUlong);
26245
26246         do {
26247                 DELAY(100);
26248
26249                 ReadDone = CSR_READ_4(sc, RE_CSIAR);
26250                 Timeout++;
26251         } while (((ReadDone & 0x80000000) == 0)&& (Timeout < WaitCount));
26252
26253         DELAY(50);
26254
26255         return RetVal;
26256 }
26257
26258 void MP_WritePciEConfigSpace(
26259         struct re_softc *sc,
26260         u_int16_t ByteEnAndAddr,
26261         u_int32_t RegData)
26262 {
26263         u_int8_t MultiFunSelBit;
26264
26265         if (sc->re_type == MACFG_52 || sc->re_type == MACFG_53) {
26266                 MultiFunSelBit = 2;
26267         } else if (sc->re_type == MACFG_60) {
26268                 MultiFunSelBit = 1;
26269         } else {
26270                 MultiFunSelBit = 0;
26271         }
26272
26273         MP_WriteOtherFunPciEConfigSpace(sc, MultiFunSelBit, ByteEnAndAddr, RegData);
26274
26275 }
26276
26277 u_int32_t MP_ReadPciEConfigSpace(
26278         struct re_softc *sc,
26279         u_int16_t ByteEnAndAddr)
26280 {
26281         u_int8_t MultiFunSelBit;
26282
26283         if (sc->re_type == MACFG_52 || sc->re_type == MACFG_53) {
26284                 MultiFunSelBit = 2;
26285         } else if (sc->re_type == MACFG_60) {
26286                 MultiFunSelBit = 1;
26287         } else {
26288                 MultiFunSelBit = 0;
26289         }
26290
26291         return MP_ReadOtherFunPciEConfigSpace(sc, MultiFunSelBit, ByteEnAndAddr);
26292 }
26293
26294 static u_int16_t MappingPhyOcpAddress(
26295         struct re_softc *sc,
26296         u_int16_t   PageNum,
26297         u_int8_t  RegNum)
26298 {
26299         u_int16_t OcpPageNum = 0;
26300         u_int8_t OcpRegNum = 0;
26301         u_int16_t OcpPhyAddress = 0;
26302
26303         if (PageNum == 0) {
26304                 OcpPageNum = 0x0A40 + (RegNum / 8);
26305                 OcpRegNum = 0x10 + (RegNum % 8);
26306         } else {
26307                 OcpPageNum = PageNum;
26308                 OcpRegNum = RegNum;
26309         }
26310
26311         OcpPageNum <<= 4;
26312
26313         if (OcpRegNum < 16) {
26314                 OcpPhyAddress = 0;
26315         } else {
26316                 OcpRegNum -= 16;
26317                 OcpRegNum <<= 1;
26318
26319                 OcpPhyAddress = OcpPageNum + OcpRegNum;
26320         }
26321
26322         return OcpPhyAddress;
26323 }
26324
26325 static u_int16_t MP_RealReadPhyOcpRegWord(
26326         struct re_softc *sc,
26327         u_int16_t OcpRegAddr)
26328 {
26329         u_int32_t Timeout = 0, WaitCount = 100;
26330         u_int32_t TmpUlong;
26331         u_int16_t RetVal = 0xffff;
26332
26333         TmpUlong = OcpRegAddr / 2;
26334         TmpUlong <<= 16;
26335
26336         CSR_WRITE_4(sc, RE_PHYOCPACCESS, TmpUlong);
26337
26338         do {
26339                 DELAY(1);
26340
26341                 TmpUlong = CSR_READ_4(sc, RE_PHYOCPACCESS);
26342
26343                 Timeout++;
26344         } while ((!(TmpUlong & PHYAR_Flag)) && (Timeout < WaitCount));
26345
26346         RetVal = (u_int16_t)TmpUlong;
26347
26348         return RetVal;
26349 }
26350
26351 u_int16_t MP_ReadPhyOcpRegWord(
26352         struct re_softc *sc,
26353         u_int16_t PhyPage,
26354         u_int8_t PhyRegNum)
26355 {
26356         u_int16_t OcpRegAddr;
26357         u_int16_t RetVal = 0xffff;
26358
26359         OcpRegAddr = MappingPhyOcpAddress(sc, PhyPage, PhyRegNum);
26360
26361         if (OcpRegAddr % 2) {
26362                 u_int16_t tmpUshort;
26363
26364                 tmpUshort = MP_RealReadPhyOcpRegWord(sc, OcpRegAddr);
26365                 tmpUshort &= 0xFF00;
26366                 tmpUshort >>= 8;
26367                 RetVal = tmpUshort;
26368
26369
26370                 tmpUshort = MP_RealReadPhyOcpRegWord(sc, OcpRegAddr + 1);
26371                 tmpUshort &= 0x00FF;
26372                 tmpUshort <<= 8;
26373                 RetVal |= tmpUshort;
26374         } else {
26375                 RetVal = MP_RealReadPhyOcpRegWord(sc, OcpRegAddr);
26376         }
26377
26378         return RetVal;
26379 }
26380
26381 static void MP_RealWritePhyOcpRegWord(
26382         struct re_softc *sc,
26383         u_int16_t OcpRegAddr,
26384         u_int16_t RegData)
26385 {
26386         u_int32_t Timeout = 0, WaitCount = 100;
26387         u_int32_t TmpUlong;
26388
26389         TmpUlong = OcpRegAddr / 2;
26390         TmpUlong <<= 16;
26391         TmpUlong += RegData;
26392         TmpUlong |= BIT_31;
26393
26394         CSR_WRITE_4(sc, RE_PHYOCPACCESS, TmpUlong);
26395
26396         do {
26397                 DELAY(1);
26398
26399                 TmpUlong = CSR_READ_4(sc, RE_PHYOCPACCESS);
26400
26401                 Timeout++;
26402         } while ((TmpUlong & PHYAR_Flag) && (Timeout < WaitCount));
26403 }
26404
26405 void MP_WritePhyOcpRegWord(
26406         struct re_softc *sc,
26407         u_int16_t PhyPage,
26408         u_int8_t PhyRegNum,
26409         u_int16_t RegData)
26410 {
26411         u_int16_t OcpRegAddr;
26412
26413         OcpRegAddr = MappingPhyOcpAddress(sc, PhyPage, PhyRegNum);
26414
26415         if (OcpRegAddr % 2) {
26416                 u_int16_t tmpUshort;
26417
26418                 tmpUshort = MP_RealReadPhyOcpRegWord(sc, OcpRegAddr);
26419                 tmpUshort &= 0x00FF;
26420                 tmpUshort |= (RegData <<  8);
26421                 MP_RealWritePhyOcpRegWord(sc, OcpRegAddr, tmpUshort);
26422                 tmpUshort = MP_RealReadPhyOcpRegWord(sc, OcpRegAddr + 1);
26423                 tmpUshort &= 0xFF00;
26424                 tmpUshort |= (RegData >> 8);
26425                 MP_RealWritePhyOcpRegWord(sc, OcpRegAddr + 1, tmpUshort);
26426         } else {
26427                 MP_RealWritePhyOcpRegWord(sc, OcpRegAddr, RegData);
26428         }
26429 }
26430
26431 void MP_WriteMcuAccessRegWord(
26432         struct re_softc *sc,
26433         u_int16_t ExtRegAddr,
26434         u_int16_t RegData)
26435 {
26436         u_int32_t TmpUlong;
26437
26438         TmpUlong = ExtRegAddr / 2;
26439         TmpUlong <<= 16;
26440         TmpUlong += RegData;
26441         TmpUlong |= BIT_31;
26442
26443         CSR_WRITE_4(sc, RE_MCUACCESS, TmpUlong);
26444 }
26445
26446 u_int16_t MP_ReadMcuAccessRegWord(
26447         struct re_softc *sc,
26448         u_int16_t ExtRegAddr)
26449 {
26450         u_int32_t TmpUlong;
26451         u_int16_t RetVal = 0xffff;
26452
26453         TmpUlong = ExtRegAddr / 2;
26454         TmpUlong <<= 16;
26455
26456         CSR_WRITE_4(sc, RE_MCUACCESS, TmpUlong);
26457         TmpUlong = CSR_READ_4(sc, RE_MCUACCESS);
26458         RetVal = (u_int16_t)TmpUlong;
26459
26460         return RetVal;
26461 }
26462
26463 static u_int32_t real_ocp_read(struct re_softc *sc, u_int16_t addr, u_int8_t len)
26464 {
26465         int i, val_shift, shift = 0;
26466         u_int32_t value1 = 0, value2 = 0, mask;
26467
26468         if (len > 4 || len <= 0)
26469                 return -1;
26470
26471         while (len > 0) {
26472                 val_shift = addr % 4;
26473                 addr = addr & ~0x3;
26474
26475                 CSR_WRITE_4(sc, RE_OCPAR, (0x0F<<12) | (addr&0xFFF));
26476
26477                 for (i = 0; i < 20; i++) {
26478                         DELAY(100);
26479                         if (CSR_READ_4(sc, RE_OCPAR) & OCPAR_Flag)
26480                                 break;
26481                 }
26482
26483                 if (len == 1)       mask = (0xFF << (val_shift * 8)) & 0xFFFFFFFF;
26484                 else if (len == 2)  mask = (0xFFFF << (val_shift * 8)) & 0xFFFFFFFF;
26485                 else if (len == 3)  mask = (0xFFFFFF << (val_shift * 8)) & 0xFFFFFFFF;
26486                 else            mask = (0xFFFFFFFF << (val_shift * 8)) & 0xFFFFFFFF;
26487
26488                 value1 = CSR_READ_4(sc, RE_OCPDR) & mask;
26489                 value2 |= (value1 >> val_shift * 8) << shift * 8;
26490
26491                 if (len <= 4 - val_shift) {
26492                         len = 0;
26493                 } else {
26494                         len -= (4 - val_shift);
26495                         shift = 4 - val_shift;
26496                         addr += 4;
26497                 }
26498         }
26499
26500         DELAY(20);
26501
26502         return value2;
26503 }
26504
26505 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)
26506 {
26507         return re_eri_read_with_oob_base_address(sc, addr, len, ERIAR_OOB, base_address);
26508 }
26509
26510 static u_int32_t OCP_read(struct re_softc *sc, u_int16_t addr, u_int8_t len)
26511 {
26512         u_int32_t value = 0;
26513
26514         if (HW_DASH_SUPPORT_TYPE_2(sc))
26515                 value = re_eri_read(sc, addr, len, ERIAR_OOB);
26516         else if (HW_DASH_SUPPORT_TYPE_3(sc))
26517                 value = OCP_read_with_oob_base_address(sc, addr, len, RTL8168FP_OOBMAC_BASE);
26518         else
26519                 value = real_ocp_read(sc, addr, len);
26520
26521         return value;
26522 }
26523
26524 static int real_ocp_write(struct re_softc *sc, u_int16_t addr, u_int8_t len, u_int32_t value)
26525 {
26526         int i, val_shift, shift = 0;
26527         u_int32_t value1 = 0, mask;
26528
26529         if (len > 4 || len <= 0)
26530                 return -1;
26531
26532         while (len > 0) {
26533                 val_shift = addr % 4;
26534                 addr = addr & ~0x3;
26535
26536                 if (len == 1)       mask = (0xFF << (val_shift * 8)) & 0xFFFFFFFF;
26537                 else if (len == 2)  mask = (0xFFFF << (val_shift * 8)) & 0xFFFFFFFF;
26538                 else if (len == 3)  mask = (0xFFFFFF << (val_shift * 8)) & 0xFFFFFFFF;
26539                 else            mask = (0xFFFFFFFF << (val_shift * 8)) & 0xFFFFFFFF;
26540
26541                 value1 = OCP_read(sc, addr, 4) & ~mask;
26542                 value1 |= ((value << val_shift * 8) >> shift * 8);
26543
26544                 CSR_WRITE_4(sc, RE_OCPDR, value1);
26545                 CSR_WRITE_4(sc, RE_OCPAR, OCPAR_Flag | (0x0F<<12) | (addr&0xFFF));
26546
26547                 for (i = 0; i < 10; i++) {
26548                         DELAY(100);
26549
26550                         /* Check if the RTL8168 has completed ERI write */
26551                         if (!(CSR_READ_4(sc, RE_OCPAR) & OCPAR_Flag))
26552                                 break;
26553                 }
26554
26555                 if (len <= 4 - val_shift) {
26556                         len = 0;
26557                 } else {
26558                         len -= (4 - val_shift);
26559                         shift = 4 - val_shift;
26560                         addr += 4;
26561                 }
26562         }
26563
26564         DELAY(20);
26565
26566         return 0;
26567 }
26568
26569 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)
26570 {
26571         return re_eri_write_with_oob_base_address(sc, addr, len, value, ERIAR_OOB, base_address);
26572 }
26573
26574 static void OCP_write(struct re_softc *sc, u_int16_t addr, u_int8_t len, u_int32_t value)
26575 {
26576         if (HW_DASH_SUPPORT_TYPE_2(sc))
26577                 re_eri_write(sc, addr, len, value, ERIAR_OOB);
26578         else if (HW_DASH_SUPPORT_TYPE_3(sc))
26579                 OCP_write_with_oob_base_address(sc, addr, len, value, RTL8168FP_OOBMAC_BASE);
26580         else
26581                 real_ocp_write(sc, addr, len, value);
26582 }
26583
26584 static void OOB_mutex_lock(struct re_softc *sc)
26585 {
26586         u_int8_t reg_16, reg_a0;
26587         u_int32_t wait_cnt_0, wait_Cnt_1;
26588         u_int16_t ocp_reg_mutex_ib;
26589         u_int16_t ocp_reg_mutex_oob;
26590         u_int16_t ocp_reg_mutex_prio;
26591
26592         switch (sc->re_type) {
26593         case MACFG_63:
26594         case MACFG_64:
26595         case MACFG_65:
26596                 ocp_reg_mutex_oob = 0x16;
26597                 ocp_reg_mutex_ib = 0x17;
26598                 ocp_reg_mutex_prio = 0x9C;
26599                 break;
26600         case MACFG_66:
26601                 ocp_reg_mutex_oob = 0x06;
26602                 ocp_reg_mutex_ib = 0x07;
26603                 ocp_reg_mutex_prio = 0x9C;
26604                 break;
26605         case MACFG_61:
26606         case MACFG_62:
26607         case MACFG_67:
26608         case MACFG_70:
26609         case MACFG_71:
26610         default:
26611                 ocp_reg_mutex_oob = 0x110;
26612                 ocp_reg_mutex_ib = 0x114;
26613                 ocp_reg_mutex_prio = 0x11C;
26614                 break;
26615         }
26616
26617         OCP_write(sc, ocp_reg_mutex_ib, 1, BIT_0);
26618         reg_16 = OCP_read(sc, ocp_reg_mutex_oob, 1);
26619         wait_cnt_0 = 0;
26620         while(reg_16) {
26621                 reg_a0 = OCP_read(sc, ocp_reg_mutex_prio, 1);
26622                 if (reg_a0) {
26623                         OCP_write(sc, ocp_reg_mutex_ib, 1, 0x00);
26624                         reg_a0 = OCP_read(sc, ocp_reg_mutex_prio, 1);
26625                         wait_Cnt_1 = 0;
26626                         while(reg_a0) {
26627                                 reg_a0 = OCP_read(sc, ocp_reg_mutex_prio, 1);
26628
26629                                 wait_Cnt_1++;
26630
26631                                 if (wait_Cnt_1 > 2000)
26632                                         break;
26633                         };
26634                         OCP_write(sc, ocp_reg_mutex_ib, 1, BIT_0);
26635
26636                 }
26637                 reg_16 = OCP_read(sc, ocp_reg_mutex_oob, 1);
26638
26639                 wait_cnt_0++;
26640
26641                 if (wait_cnt_0 > 2000)
26642                         break;
26643         };
26644 }
26645
26646 static void OOB_mutex_unlock(struct re_softc *sc)
26647 {
26648         u_int16_t ocp_reg_mutex_ib;
26649         u_int16_t ocp_reg_mutex_oob;
26650         u_int16_t ocp_reg_mutex_prio;
26651
26652         switch (sc->re_type) {
26653         case MACFG_63:
26654         case MACFG_64:
26655         case MACFG_65:
26656                 ocp_reg_mutex_oob = 0x16;
26657                 ocp_reg_mutex_ib = 0x17;
26658                 ocp_reg_mutex_prio = 0x9C;
26659                 break;
26660         case MACFG_66:
26661                 ocp_reg_mutex_oob = 0x06;
26662                 ocp_reg_mutex_ib = 0x07;
26663                 ocp_reg_mutex_prio = 0x9C;
26664                 break;
26665         case MACFG_61:
26666         case MACFG_62:
26667         case MACFG_67:
26668         case MACFG_70:
26669         case MACFG_71:
26670         default:
26671                 ocp_reg_mutex_oob = 0x110;
26672                 ocp_reg_mutex_ib = 0x114;
26673                 ocp_reg_mutex_prio = 0x11C;
26674                 break;
26675         }
26676
26677         OCP_write(sc, ocp_reg_mutex_prio, 1, BIT_0);
26678         OCP_write(sc, ocp_reg_mutex_ib, 1, 0x00);
26679 }
26680
26681 static int re_check_dash(struct re_softc *sc)
26682 {
26683         switch(sc->re_type) {
26684         case MACFG_61:
26685         case MACFG_62:
26686         case MACFG_67:
26687         case MACFG_63:
26688         case MACFG_64:
26689         case MACFG_65:
26690         case MACFG_66:
26691         case MACFG_70:
26692         case MACFG_71:
26693                 if (HW_DASH_SUPPORT_TYPE_2(sc) || HW_DASH_SUPPORT_TYPE_3(sc)) {
26694                         if (OCP_read(sc, 0x128, 1) & BIT_0)
26695                                 return 1;
26696                         else
26697                                 return 0;
26698                 } else {
26699                         u_int32_t reg;
26700
26701                         if (sc->re_type == MACFG_66)
26702                                 reg = 0xb8;
26703                         else
26704                                 reg = 0x10;
26705
26706                         if (OCP_read(sc, reg, 2) & 0x00008000)
26707                                 return 1;
26708                         else
26709                                 return 0;
26710                 }
26711                 break;
26712         default:
26713                 return 0;
26714         }
26715 }
26716
26717 static void OOB_notify(struct re_softc *sc, u_int8_t cmd)
26718 {
26719         int i;
26720
26721         CSR_WRITE_1(sc, RE_ERIDR, cmd);
26722         CSR_WRITE_4(sc, RE_ERIAR, 0x800010E8);
26723         DELAY(2000);
26724         for (i = 0; i < 5; i++) {
26725                 DELAY(100);
26726                 if (!(CSR_READ_4(sc, RE_ERIAR) & ERIAR_Flag))
26727                         break;
26728         }
26729
26730         OCP_write(sc, 0x30, 1, 0x01);
26731 }
26732
26733 void re_driver_start(struct re_softc *sc)
26734 {
26735         if (HW_DASH_SUPPORT_TYPE_2(sc) || HW_DASH_SUPPORT_TYPE_3(sc)) {
26736                 u_int32_t tmp_value;
26737
26738                 if (!sc->re_dash)
26739                         return;
26740
26741                 OCP_write(sc, 0x180, 1, OOB_CMD_DRIVER_START);
26742                 tmp_value = OCP_read(sc, 0x30, 1);
26743                 tmp_value |= BIT_0;
26744                 OCP_write(sc, 0x30, 1, tmp_value);
26745         } else {
26746                 int timeout;
26747                 u_int32_t reg;
26748
26749                 if (sc->re_type == MACFG_66) {
26750                         CSR_WRITE_1(sc, RE_TwiCmdReg, CSR_READ_1(sc, RE_TwiCmdReg) | (BIT_7));
26751                 }
26752
26753                 OOB_notify(sc, OOB_CMD_DRIVER_START);
26754
26755                 if (sc->re_type == MACFG_66)
26756                         reg = 0xB8;
26757                 else
26758                         reg = 0x10;
26759
26760                 for (timeout = 0; timeout < 10; timeout++) {
26761                         DELAY(10000);
26762                         if (OCP_read(sc, reg, 2) & BIT_11)
26763                                 break;
26764                 }
26765         }
26766 }
26767
26768 void re_driver_stop(struct re_softc *sc)
26769 {
26770         if (HW_DASH_SUPPORT_TYPE_2(sc) || HW_DASH_SUPPORT_TYPE_3(sc)) {
26771                 u_int32_t tmp_value;
26772
26773                 if (!sc->re_dash)
26774                         return;
26775
26776                 Dash2DisableTxRx(sc);
26777
26778                 OCP_write(sc, 0x180, 1, OOB_CMD_DRIVER_STOP);
26779                 tmp_value = OCP_read(sc, 0x30, 1);
26780                 tmp_value |= BIT_0;
26781                 OCP_write(sc, 0x30, 1, tmp_value);
26782         } else {
26783                 int timeout;
26784                 u_int32_t reg;
26785
26786                 OOB_notify(sc, OOB_CMD_DRIVER_STOP);
26787
26788                 if (sc->re_type == MACFG_66)
26789                         reg = 0xB8;
26790                 else
26791                         reg = 0x10;
26792
26793                 for (timeout = 0; timeout < 10; timeout++) {
26794                         DELAY(10000);
26795                         if ((OCP_read(sc, reg, 4) & BIT_11) == 0)
26796                                 break;
26797                 }
26798
26799                 if (sc->re_type == MACFG_66) {
26800                         CSR_WRITE_1(sc, RE_TwiCmdReg, CSR_READ_1(sc, RE_TwiCmdReg) & ~(BIT_7));
26801                 }
26802         }
26803 }
26804
26805 /*----------------------------------------------------------------------------*/
26806 /*      8139 (CR9346) 9346 command register bits (offset 0x50, 1 byte)*/
26807 /*----------------------------------------------------------------------------*/
26808 #define CR9346_EEDO                             0x01                    /* 9346 data out*/
26809 #define CR9346_EEDI                             0x02                    /* 9346 data in*/
26810 #define CR9346_EESK                             0x04                    /* 9346 serial clock*/
26811 #define CR9346_EECS                             0x08                    /* 9346 chip select*/
26812 #define CR9346_EEM0                             0x40                    /* select 8139 operating mode*/
26813 #define CR9346_EEM1                             0x80                    /* 00: normal*/
26814 #define CR9346_CFGRW                    0xC0                    /* Config register write*/
26815 #define CR9346_NORM                     0x00
26816
26817 /*----------------------------------------------------------------------------*/
26818 /*      EEPROM bit definitions(EEPROM control register bits)*/
26819 /*----------------------------------------------------------------------------*/
26820 #define EN_TRNF                                 0x10                    /* Enable turnoff*/
26821 #define EEDO                                            CR9346_EEDO     /* EEPROM data out*/
26822 #define EEDI                                            CR9346_EEDI             /* EEPROM data in (set for writing data)*/
26823 #define EECS                                            CR9346_EECS             /* EEPROM chip select (1=high, 0=low)*/
26824 #define EESK                                            CR9346_EESK             /* EEPROM shift clock (1=high, 0=low)*/
26825
26826 /*----------------------------------------------------------------------------*/
26827 /*      EEPROM opcodes*/
26828 /*----------------------------------------------------------------------------*/
26829 #define EEPROM_READ_OPCODE      06
26830 #define EEPROM_WRITE_OPCODE     05
26831 #define EEPROM_ERASE_OPCODE     07
26832 #define EEPROM_EWEN_OPCODE      19                              /* Erase/write enable*/
26833 #define EEPROM_EWDS_OPCODE      16                              /* Erase/write disable*/
26834
26835 #define CLOCK_RATE                              50                              /* us*/
26836
26837 #define RaiseClock(_sc,_x)                              \
26838         (_x) = (_x) | EESK;                                     \
26839         CSR_WRITE_1((_sc), RE_EECMD, (_x));     \
26840         DELAY(CLOCK_RATE);
26841
26842 #define LowerClock(_sc,_x)                              \
26843         (_x) = (_x) & ~EESK;                                    \
26844         CSR_WRITE_1((_sc), RE_EECMD, (_x));     \
26845         DELAY(CLOCK_RATE);
26846
26847 /*
26848  * Shift out bit(s) to the EEPROM.
26849  */
26850 static void re_eeprom_ShiftOutBits(struct re_softc *sc, int data, int count)
26851 {
26852         u_int16_t x, mask;
26853
26854         mask = 0x01 << (count - 1);
26855         x = CSR_READ_1(sc, RE_EECMD);
26856
26857         x &= ~(EEDO | EEDI);
26858
26859         do {
26860                 x &= ~EEDI;
26861                 if (data & mask)
26862                         x |= EEDI;
26863
26864                 CSR_WRITE_1(sc, RE_EECMD, x);
26865                 DELAY(CLOCK_RATE);
26866                 RaiseClock(sc,x);
26867                 LowerClock(sc,x);
26868                 mask = mask >> 1;
26869         } while (mask);
26870
26871         x &= ~EEDI;
26872         CSR_WRITE_1(sc, RE_EECMD, x);
26873 }
26874
26875 /*
26876  * Shift in bit(s) from the EEPROM.
26877  */
26878 static u_int16_t re_eeprom_ShiftInBits(struct re_softc *sc)
26879 {
26880         u_int16_t x,d,i;
26881         x = CSR_READ_1(sc, RE_EECMD);
26882
26883         x &= ~(EEDO | EEDI);
26884         d = 0;
26885
26886         for (i=0; i<16; i++) {
26887                 d = d << 1;
26888                 RaiseClock(sc, x);
26889
26890                 x = CSR_READ_1(sc, RE_EECMD);
26891
26892                 x &= ~(EEDI);
26893                 if (x & EEDO)
26894                         d |= 1;
26895
26896                 LowerClock(sc, x);
26897         }
26898
26899         return d;
26900 }
26901
26902 /*
26903  * Clean up EEprom read/write setting
26904  */
26905 static void re_eeprom_EEpromCleanup(struct re_softc *sc)
26906 {
26907         u_int16_t x;
26908         x = CSR_READ_1(sc, RE_EECMD);
26909
26910         x &= ~(EECS | EEDI);
26911         CSR_WRITE_1(sc, RE_EECMD, x);
26912
26913         RaiseClock(sc, x);
26914         LowerClock(sc, x);
26915 }
26916
26917 /*
26918  * Read a word of data stored in the EEPROM at address 'addr.'
26919  */
26920 static void re_eeprom_getword(struct re_softc *sc, int addr, u_int16_t *dest)
26921 {
26922         u_int16_t x;
26923
26924         /* select EEPROM, reset bits, set EECS*/
26925         x = CSR_READ_1(sc, RE_EECMD);
26926
26927         x &= ~(EEDI | EEDO | EESK | CR9346_EEM0);
26928         x |= CR9346_EEM1 | EECS;
26929         CSR_WRITE_1(sc, RE_EECMD, x);
26930
26931         /* write the read opcode and register number in that order*/
26932         /* The opcode is 3bits in length, reg is 6 bits long*/
26933         re_eeprom_ShiftOutBits(sc, EEPROM_READ_OPCODE, 3);
26934
26935         if (CSR_READ_4(sc, RE_RXCFG) & RE_RXCFG_RX_9356SEL)
26936                 re_eeprom_ShiftOutBits(sc, addr,8);     /*93c56=8*/
26937         else
26938                 re_eeprom_ShiftOutBits(sc, addr,6);     /*93c46=6*/
26939
26940         /* Now read the data (16 bits) in from the selected EEPROM word*/
26941         *dest=re_eeprom_ShiftInBits(sc);
26942
26943         re_eeprom_EEpromCleanup(sc);
26944         return;
26945 }
26946
26947 /*
26948  * Read a sequence of words from the EEPROM.
26949  */
26950 static void re_read_eeprom(struct re_softc *sc, caddr_t dest, int off, int cnt, int swap)
26951 {
26952         int                     i;
26953         u_int16_t               word = 0, *ptr;
26954
26955         for (i = 0; i < cnt; i++) {
26956                 re_eeprom_getword(sc, off + i, &word);
26957                 ptr = (u_int16_t *)(dest + (i * 2));
26958                 if (swap)
26959                         *ptr = ntohs(word);
26960                 else
26961                         *ptr = word;
26962         }
26963
26964         return;
26965 }
26966
26967 #ifdef __DragonFly__
26968
26969 int
26970 rtl_check_mac_version(struct re_softc *sc)
26971 {
26972
26973         return (re_check_mac_version(sc));
26974 }
26975
26976 void
26977 rtl_init_software_variable(struct re_softc *sc)
26978 {
26979
26980         re_init_software_variable(sc);
26981 }
26982
26983 void
26984 rtl_exit_oob(struct re_softc *sc)
26985 {
26986
26987         re_exit_oob(sc);
26988 }
26989
26990 void
26991 rtl_hw_init(struct re_softc *sc)
26992 {
26993
26994         re_hw_init(sc);
26995 }
26996
26997 void
26998 rtl_reset(struct re_softc *sc)
26999 {
27000
27001         re_reset(sc);
27002 }
27003
27004 void
27005 rtl_get_hw_mac_address(struct re_softc *sc, u_int8_t *eaddr)
27006 {
27007
27008         re_get_hw_mac_address(sc, eaddr);
27009 }
27010
27011 void
27012 rtl_phy_power_up(struct re_softc *sc)
27013 {
27014
27015         re_phy_power_up(sc->dev);
27016 }
27017
27018 void
27019 rtl_hw_phy_config(struct re_softc *sc)
27020 {
27021
27022         re_hw_phy_config(sc);
27023 }
27024
27025 void
27026 rtl_clrwol(struct re_softc *sc)
27027 {
27028
27029         re_clrwol(sc);
27030 }
27031
27032 int
27033 rtl_ifmedia_upd(struct ifnet *ifp)
27034 {
27035
27036         return (re_ifmedia_upd(ifp));
27037 }
27038
27039 void
27040 rtl_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr)
27041 {
27042
27043         re_ifmedia_sts(ifp, ifmr);
27044 }
27045
27046 void
27047 rtl_stop(struct re_softc *sc)
27048 {
27049
27050         re_stop_rtl(sc);
27051 }
27052
27053 u_int8_t
27054 rtl_link_ok(struct re_softc *sc)
27055 {
27056
27057         return (re_link_ok(sc));
27058 }
27059
27060 void
27061 rtl_link_on_patch(struct re_softc *sc)
27062 {
27063
27064         re_link_on_patch(sc);
27065 }
27066
27067 void
27068 rtl_set_eaddr(struct re_softc *sc)
27069 {
27070
27071         re_init_unlock(sc);
27072 }
27073
27074 void
27075 rtl_hw_start(struct re_softc *sc)
27076 {
27077
27078         re_hw_start_unlock(sc);
27079 }
27080
27081 void
27082 rtl_set_rx_packet_filter(struct re_softc *sc)
27083 {
27084
27085         re_set_rx_packet_filter(sc);
27086 }
27087
27088 void
27089 rtl_hw_d3_para(struct re_softc *sc)
27090 {
27091
27092         re_hw_d3_para(sc);
27093 }
27094
27095 void
27096 rtl_phy_power_down(struct re_softc *sc)
27097 {
27098
27099         re_phy_power_down(sc->dev);
27100 }
27101
27102 void
27103 rtl_cmac_unmap(struct re_softc *sc)
27104 {
27105
27106         if (HW_DASH_SUPPORT_TYPE_3(sc) && sc->re_dash &&
27107             sc->re_mapped_cmac_handle != 0) {
27108                 bus_space_unmap(sc->re_cmac_tag, sc->re_mapped_cmac_handle,
27109                     RE_REGS_SIZE);
27110         }
27111 }
27112
27113 #endif  /* __DragonFly__ */