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.94.01 " __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, 0, 0);
 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.94.01\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_11 | BIT_10;
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_11 | BIT_10;
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, 0x03F8);
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                 re_eri_write(sc, 0xD4, 4, Data32, ERIAR_ExGMAC);
6235
6236                 re_eri_write(sc, 0xC8, 4, 0x00080002, ERIAR_ExGMAC);
6237                 re_eri_write(sc, 0xCC, 1, 0x2F, ERIAR_ExGMAC);
6238                 re_eri_write(sc, 0xD0, 1, 0x5F, ERIAR_ExGMAC);
6239                 re_eri_write(sc, 0xE8, 4, 0x00100006, ERIAR_ExGMAC);
6240
6241                 MP_WriteMcuAccessRegWord(sc, 0xE054, 0xFC01);
6242
6243                 OOB_mutex_lock(sc);
6244                 Data32 = re_eri_read(sc, 0x5F0, 4, ERIAR_ExGMAC);
6245                 Data32 |= (BIT_8 | BIT_9 | BIT_10 | BIT_11);
6246                 re_eri_write(sc, 0x5F0, 4, Data32, ERIAR_ExGMAC);
6247                 OOB_mutex_unlock(sc);
6248
6249                 Data32 = re_eri_read(sc, 0xdc, 4, ERIAR_ExGMAC);
6250                 Data32 &= ~BIT_0;
6251                 re_eri_write(sc, 0xdc, 1, Data32, ERIAR_ExGMAC);
6252                 Data32 |= BIT_0;
6253                 re_eri_write(sc, 0xdc, 1, Data32, ERIAR_ExGMAC);
6254
6255                 Data32 = re_eri_read(sc, 0x2FC, 4, ERIAR_ExGMAC);
6256                 Data32 &= ~(BIT_0 | BIT_1 | BIT_2);
6257                 Data32 |= (BIT_0);
6258                 re_eri_write(sc, 0x2FC, 4, Data32, ERIAR_ExGMAC);
6259
6260                 Data32 = re_eri_read(sc, 0x1B0, 4, ERIAR_ExGMAC);
6261                 Data32 &= ~BIT_12;
6262                 re_eri_write(sc, 0x1B0, 4, Data32, ERIAR_ExGMAC);
6263
6264                 Data32 = re_eri_read(sc, 0x1D0, 1, ERIAR_ExGMAC);
6265                 Data32 &= ~BIT_1;
6266                 re_eri_write(sc, 0x1D0, 1, Data32, ERIAR_ExGMAC);
6267
6268                 re_eri_write(sc, 0xC0, 2, 0x0000, ERIAR_ExGMAC);
6269                 re_eri_write(sc, 0xB8, 4, 0x00000000, ERIAR_ExGMAC);
6270
6271                 CSR_WRITE_4(sc, RE_TXCFG, CSR_READ_4(sc, RE_TXCFG) | BIT_7);
6272                 CSR_WRITE_1(sc, 0xD3, CSR_READ_1(sc, 0xD3) & ~BIT_7);
6273                 CSR_WRITE_1(sc, 0x1B, CSR_READ_1(sc, 0x1B) & ~0x07);
6274
6275                 CSR_WRITE_2 (sc, RE_CPlusCmd, 0x2060);
6276
6277                 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0);
6278
6279                 CSR_WRITE_1(sc, 0xD0, CSR_READ_1(sc, 0xD0) | BIT_6);
6280                 CSR_WRITE_1(sc, 0xF2, CSR_READ_1(sc, 0xF2) | BIT_6);
6281
6282                 CSR_WRITE_1(sc, 0xD0, CSR_READ_1(sc, 0xD0) | BIT_7);
6283
6284                 CSR_WRITE_1(sc, 0xF2, CSR_READ_1(sc, 0xF2) & ~BIT_3);
6285
6286                 if (ifp->if_mtu > ETHERMTU)
6287                         CSR_WRITE_1 (sc, RE_MTPS, 0x27);
6288
6289                 data16 = MP_ReadMcuAccessRegWord(sc, 0xD3E2);
6290                 data16 &= 0xF000;
6291                 data16 |= 0x3A9;
6292                 MP_WriteMcuAccessRegWord(sc, 0xD3E2, data16);
6293
6294                 data16 = MP_ReadMcuAccessRegWord(sc, 0xD3E4);
6295                 data16 &= 0xFF00;
6296                 MP_WriteMcuAccessRegWord(sc, 0xD3E4, data16);
6297
6298                 data16 = MP_ReadMcuAccessRegWord(sc, 0xE860);
6299                 data16 |= BIT_7;
6300                 MP_WriteMcuAccessRegWord(sc, 0xE860, data16);
6301
6302                 MP_WriteMcuAccessRegWord(sc, 0xC140, 0xFFFF);
6303                 MP_WriteMcuAccessRegWord(sc, 0xC142, 0xFFFF);
6304
6305                 if (ifp->if_mtu > ETHERMTU) {
6306                         ifp->if_capenable &= ~IFCAP_HWCSUM;
6307                         ifp->if_hwassist &= ~RE_CSUM_FEATURES;
6308                 } else {
6309                         if (sc->re_tx_cstag) {
6310                                 ifp->if_capenable |= IFCAP_TXCSUM;
6311                                 ifp->if_hwassist |= RE_CSUM_FEATURES;
6312                         }
6313                         if (sc->re_rx_cstag) {
6314                                 ifp->if_capenable |= IFCAP_RXCSUM;
6315                         }
6316                 }
6317         }
6318
6319         //clear io_rdy_l23
6320         switch (sc->re_type) {
6321         case MACFG_42:
6322         case MACFG_43:
6323         case MACFG_52:
6324         case MACFG_53:
6325         case MACFG_54:
6326         case MACFG_55:
6327         case MACFG_56:
6328         case MACFG_57:
6329         case MACFG_58:
6330         case MACFG_59:
6331         case MACFG_60:
6332         case MACFG_61:
6333         case MACFG_62:
6334         case MACFG_67:
6335         case MACFG_68:
6336         case MACFG_69:
6337         case MACFG_70:
6338         case MACFG_71:
6339                 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_1);
6340                 break;
6341         }
6342
6343         switch(sc->re_type) {
6344         case MACFG_36:
6345         case MACFG_37:
6346         case MACFG_38:
6347         case MACFG_39:
6348         case MACFG_42:
6349         case MACFG_43:
6350         case MACFG_50:
6351         case MACFG_51:
6352         case MACFG_52:
6353         case MACFG_53:
6354         case MACFG_54:
6355         case MACFG_55:
6356         case MACFG_56:
6357         case MACFG_57:
6358         case MACFG_58:
6359         case MACFG_59:
6360         case MACFG_60:
6361         case MACFG_61:
6362         case MACFG_62:
6363         case MACFG_67:
6364         case MACFG_68:
6365         case MACFG_69:
6366         case MACFG_70:
6367         case MACFG_71:
6368                 CSR_WRITE_1(sc, RE_CFG5, CSR_READ_1(sc, RE_CFG5) | BIT_0);
6369                 CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2) | BIT_7);
6370                 CSR_WRITE_1(sc, 0xF1, CSR_READ_1(sc, 0xF1) | BIT_7);
6371                 break;
6372         }
6373
6374         //clear wol
6375         re_clrwol(sc);
6376
6377         data16 = CSR_READ_2(sc, RE_CPlusCmd);
6378         if ((ifp->if_capenable & IFCAP_VLAN_HWTAGGING) != 0)
6379                 data16 |= RL_CPLUSCMD_VLANSTRIP;
6380         else
6381                 data16 &= ~RL_CPLUSCMD_VLANSTRIP;
6382
6383         if ((ifp->if_capenable & IFCAP_RXCSUM) != 0)
6384                 data16 |= RL_RxChkSum;
6385         else
6386                 data16 &= ~RL_RxChkSum;
6387         CSR_WRITE_2 (sc, RE_CPlusCmd, data16);
6388
6389         re_disable_cfg9346_write(sc);
6390         //CSR_WRITE_1(sc, 0xec, 0x3f);
6391
6392         if (sc->re_device_id == RT_DEVICEID_8169 || sc->re_device_id == RT_DEVICEID_8169SC) {
6393                 /* Enable transmit and receive.*/
6394                 CSR_WRITE_1(sc, RE_COMMAND, RE_CMD_TX_ENB | RE_CMD_RX_ENB);
6395
6396                 /* Set the initial TX configuration.*/
6397                 CSR_WRITE_4(sc, RE_TXCFG, RE_TXCFG_CONFIG);
6398
6399                 /* Set the initial RX configuration.*/
6400                 /*
6401                  * Program the multicast filter, if necessary.
6402                  */
6403                 re_set_rx_packet_filter(sc);
6404         } else {
6405                 /* Set the initial RX configuration.*/
6406                 /*
6407                  * Program the multicast filter, if necessary.
6408                  */
6409                 re_set_rx_packet_filter(sc);
6410
6411                 /* Enable transmit and receive.*/
6412                 CSR_WRITE_1(sc, RE_COMMAND, RE_CMD_TX_ENB | RE_CMD_RX_ENB);
6413         }
6414
6415 #ifndef __DragonFly__
6416         ifp->if_drv_flags |= IFF_DRV_RUNNING;
6417         ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
6418
6419         /*
6420         * Enable interrupts.
6421         */
6422         CSR_WRITE_2(sc, RE_IMR, RE_INTRS);
6423 #endif
6424 }
6425
6426 static void re_init_unlock(void *xsc)   /* Software & Hardware Initialize */
6427 {
6428         struct re_softc         *sc = xsc;
6429         struct ifnet            *ifp;
6430 #ifndef __DragonFly__
6431 #if OS_VER < VERSION(6,0)
6432         int                     i;
6433 #endif
6434 #endif  /* !__DragonFly__ */
6435         union {
6436                 uint32_t align_dummy;
6437                 u_char eaddr[ETHER_ADDR_LEN];
6438         } eaddr;
6439
6440         ifp = RE_GET_IFNET(sc);
6441
6442 #ifndef __DragonFly__
6443         /*
6444          * Cancel pending I/O and free all RX/TX buffers.
6445          */
6446         re_stop(sc);
6447 #endif  /* !__DragonFly__ */
6448
6449         /* Copy MAC address on stack to align. */
6450 #ifndef __DragonFly__
6451 #if OS_VER < VERSION(6,0)
6452         bcopy((char *)&sc->arpcom.ac_enaddr, eaddr.eaddr, ETHER_ADDR_LEN);
6453 #elif OS_VER < VERSION(7,0)
6454         bcopy(IFP2ENADDR(ifp), eaddr.eaddr, ETHER_ADDR_LEN);
6455 #else
6456         bcopy(IF_LLADDR(ifp), eaddr.eaddr, ETHER_ADDR_LEN);
6457 #endif
6458 #else   /* __DragonFly__ */
6459         bcopy(IF_LLADDR(ifp), eaddr.eaddr, ETHER_ADDR_LEN);
6460 #endif  /* !__DragonFly__ */
6461
6462         /* Init our MAC address */
6463         re_rar_set(sc, eaddr.eaddr);
6464
6465 #ifndef __DragonFly__
6466         re_hw_start_unlock(sc);
6467 #endif
6468
6469         return;
6470 }
6471
6472 #ifndef __DragonFly__
6473 static void re_init(void *xsc)          /* Software & Hardware Initialize */
6474 {
6475         struct re_softc         *sc = xsc;
6476         struct ifnet            *ifp;
6477
6478         RE_LOCK(sc);
6479         ifp = RE_GET_IFNET(sc);
6480
6481         if (re_link_ok(sc)) {
6482                 sc->link_state = LINK_STATE_UP;
6483                 re_link_state_change(ifp, sc->link_state);
6484                 re_link_on_patch(sc);
6485         }
6486
6487         sc->re_link_chg_det = 1;
6488         re_start_timer(sc);
6489
6490         RE_UNLOCK(sc);
6491 }
6492
6493 /*
6494  * Initialize the transmit descriptors.
6495  */
6496 static int re_var_init(struct re_softc *sc)
6497 {
6498         int                     i;
6499         union RxDesc *rxptr;
6500         union TxDesc *txptr;
6501
6502         sc->re_desc.rx_cur_index = 0;
6503         sc->re_desc.rx_last_index = 0;
6504         rxptr = sc->re_desc.rx_desc;
6505         for (i = 0; i < RE_RX_BUF_NUM; i++) {
6506                 memset(&rxptr[i], 0, sizeof(union RxDesc));
6507
6508                 /* Init the RX buffer pointer register. */
6509                 bus_dmamap_load(sc->re_desc.re_rx_mtag,
6510                                 sc->re_desc.re_rx_dmamap[i],
6511                                 sc->re_desc.rx_buf[i]->m_data, sc->re_rx_desc_buf_sz,
6512                                 re_rx_dma_map_buf,
6513                                 &rxptr[i],
6514                                 0);
6515                 bus_dmamap_sync(sc->re_desc.re_rx_mtag,
6516                                 sc->re_desc.re_rx_dmamap[i],
6517                                 BUS_DMASYNC_PREREAD);
6518
6519                 rxptr[i].ul[0] = htole32(sc->re_rx_desc_buf_sz);
6520                 if (i == (RE_RX_BUF_NUM - 1))
6521                         rxptr[i].ul[0] |= htole32(RL_RDESC_CMD_EOR);
6522                 rxptr[i].ul[0] |= htole32(RL_RDESC_CMD_OWN);
6523         }
6524
6525         bus_dmamap_load(sc->re_desc.rx_desc_tag,
6526                         sc->re_desc.rx_desc_dmamap,
6527                         sc->re_desc.rx_desc,
6528                         sizeof(union RxDesc)*RE_RX_BUF_NUM,
6529                         re_dma_map_rxdesc,
6530                         sc,
6531                         0);
6532         bus_dmamap_sync(sc->re_desc.rx_desc_tag,
6533                         sc->re_desc.rx_desc_dmamap,
6534                         BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
6535
6536         sc->re_desc.tx_cur_index = 0;
6537         sc->re_desc.tx_last_index = 0;
6538         txptr = sc->re_desc.tx_desc;
6539         for (i = 0; i < RE_TX_BUF_NUM; i++) {
6540                 memset(&txptr[i], 0, sizeof(union TxDesc));
6541                 if (i == (RE_TX_BUF_NUM - 1))
6542                         txptr[i].ul[0] = htole32(RL_TDESC_CMD_EOR);
6543         }
6544
6545         bus_dmamap_load(sc->re_desc.tx_desc_tag,
6546                         sc->re_desc.tx_desc_dmamap,
6547                         sc->re_desc.tx_desc,
6548                         sizeof(union RxDesc) * RE_TX_BUF_NUM,
6549                         re_dma_map_txdesc,
6550                         sc,
6551                         0);
6552         bus_dmamap_sync(sc->re_desc.tx_desc_tag,
6553                         sc->re_desc.tx_desc_dmamap,
6554                         BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
6555
6556         return 0;
6557 }
6558 #endif  /* !__DragonFly__ */
6559
6560 static void re_reset(struct re_softc *sc)
6561 {
6562         register int            i;
6563
6564         CSR_WRITE_4(sc, RE_RXCFG, CSR_READ_4(sc, RE_RXCFG)& ~0x3F);
6565
6566         switch (sc->re_type) {
6567         case MACFG_3:
6568         case MACFG_4:
6569         case MACFG_5:
6570         case MACFG_6:
6571                 DELAY(10000);
6572                 break;
6573         case MACFG_11:
6574         case MACFG_12:
6575         case MACFG_13:
6576         case MACFG_14:
6577         case MACFG_15:
6578         case MACFG_16:
6579         case MACFG_17:
6580         case MACFG_18:
6581         case MACFG_19:
6582         case MACFG_21:
6583         case MACFG_22:
6584         case MACFG_23:
6585         case MACFG_24:
6586         case MACFG_25:
6587         case MACFG_26:
6588         case MACFG_27:
6589         case MACFG_28:
6590         case MACFG_31:
6591         case MACFG_32:
6592         case MACFG_33:
6593         case MACFG_36:
6594         case MACFG_37:
6595         case MACFG_41:
6596         case MACFG_42:
6597         case MACFG_43:
6598         case MACFG_54:
6599         case MACFG_55:
6600         case MACFG_63:
6601         case MACFG_64:
6602         case MACFG_65:
6603         case MACFG_66:
6604                 CSR_WRITE_1(sc, RE_COMMAND, 0x8C);
6605                 break;
6606         case MACFG_38:
6607         case MACFG_39:
6608         case MACFG_50:
6609         case MACFG_51:
6610         case MACFG_52:
6611         case MACFG_53:
6612                 CSR_WRITE_1(sc, RE_COMMAND, 0x8C);
6613                 while (!(CSR_READ_4(sc,RE_TXCFG) & BIT_11)) DELAY(100);
6614                 break;
6615         case MACFG_56:
6616         case MACFG_57:
6617         case MACFG_58:
6618         case MACFG_59:
6619         case MACFG_60:
6620         case MACFG_61:
6621         case MACFG_62:
6622         case MACFG_67:
6623         case MACFG_68:
6624         case MACFG_69:
6625         case MACFG_70:
6626         case MACFG_71:
6627                 DELAY(2000);
6628                 break;
6629         default:
6630                 DELAY(10000);
6631                 break;
6632         }
6633         DELAY(200);
6634         CSR_WRITE_1(sc, RE_COMMAND, RE_CMD_RESET);
6635
6636         for (i = 0; i < RE_TIMEOUT; i++) {
6637                 DELAY(10);
6638                 if (!(CSR_READ_1(sc, RE_COMMAND) & RE_CMD_RESET))
6639                         break;
6640         }
6641
6642         if (i == RE_TIMEOUT)
6643                 device_printf(sc->dev,"reset never completed!\n");
6644
6645         return;
6646 }
6647
6648 static u_int8_t re_link_ok(struct re_softc *sc)
6649 {
6650         u_int8_t        retval;
6651
6652         retval = (CSR_READ_1(sc, RE_PHY_STATUS) & RL_PHY_STATUS_LINK_STS) ? 1 : 0;
6653
6654         return retval;
6655 }
6656
6657 static void
6658 re_set_wol_linkspeed(struct re_softc *sc)
6659 {
6660         u_int8_t wol_link_speed;
6661         u_int16_t anar;
6662
6663         MP_WritePhyUshort(sc, 0x1F, 0x0000);
6664
6665         wol_link_speed = RE_WOL_LINK_SPEED_100M_FIRST;
6666         if (!sc->re_dash) {
6667                 if (re_link_ok(sc)) {
6668                         u_int16_t anlpar;
6669
6670                         anlpar = MP_ReadPhyUshort(sc,MII_ANLPAR);
6671                         if ((anlpar & ANLPAR_10_FD) || (anlpar & ANLPAR_10)) {
6672                                 wol_link_speed = RE_WOL_LINK_SPEED_10M_FIRST;
6673                         } else {
6674                                 wol_link_speed = RE_WOL_LINK_SPEED_100M_FIRST;
6675                         }
6676                 }
6677         }
6678
6679         anar = MP_ReadPhyUshort(sc,MII_ANAR);
6680
6681         if (wol_link_speed == RE_WOL_LINK_SPEED_10M_FIRST)
6682                 anar &= ~(ANAR_TX_FD | ANAR_TX);
6683
6684         if (sc->re_device_id==RT_DEVICEID_8169 || sc->re_device_id==RT_DEVICEID_8169SC ||
6685             sc->re_device_id==RT_DEVICEID_8168 || sc->re_device_id==RT_DEVICEID_8161) {
6686                 u_int16_t gbcr;
6687
6688                 gbcr = MP_ReadPhyUshort(sc,MII_100T2CR);
6689                 gbcr &= ~(GTCR_ADV_1000TFDX|GTCR_ADV_1000THDX);
6690                 MP_WritePhyUshort(sc, MII_100T2CR, gbcr);
6691                 MP_WritePhyUshort(sc, MII_ANAR, anar);
6692                 MP_WritePhyUshort(sc, MII_BMCR, BMCR_RESET | BMCR_AUTOEN | BMCR_STARTNEG);
6693         } else if (sc->re_type == MACFG_36) {
6694                 MP_WritePhyUshort(sc, MII_ANAR, anar);
6695                 MP_WritePhyUshort(sc, MII_BMCR, BMCR_RESET | BMCR_AUTOEN | BMCR_STARTNEG);
6696         } else {
6697                 MP_WritePhyUshort(sc, MII_ANAR, anar);
6698                 MP_WritePhyUshort(sc, MII_BMCR, BMCR_AUTOEN | BMCR_STARTNEG);
6699         }
6700 }
6701
6702 #ifndef __DragonFly__
6703 static void
6704 re_setwol(struct re_softc *sc)
6705 {
6706         struct ifnet            *ifp;
6707         int                     pmc;
6708         uint16_t                pmstat;
6709         uint8_t                 v;
6710
6711         RE_LOCK_ASSERT(sc);
6712
6713         ifp = RE_GET_IFNET(sc);
6714
6715         if ((ifp->if_capenable & IFCAP_WOL) == 0) {
6716                 re_phy_power_down(sc->dev);
6717                 return;
6718         }
6719
6720         if (pci_find_cap(sc->dev, PCIY_PMG, &pmc) != 0)
6721                 return;
6722
6723         /* Enable config register write. */
6724         re_enable_cfg9346_write(sc);
6725
6726         /* Enable PME. */
6727         if (sc->re_device_id==RT_DEVICEID_8169 || sc->re_device_id==RT_DEVICEID_8169SC) {
6728                 v = CSR_READ_1(sc, RE_CFG1);
6729                 v &= ~RE_CFG1_PME;
6730                 if ((ifp->if_capenable & IFCAP_WOL) != 0)
6731                         v |= RE_CFG1_PME;
6732                 CSR_WRITE_1(sc, RE_CFG1, v);
6733         }
6734
6735         if (sc->re_if_flags & RL_FLAG_MAGIC_PACKET_V2) {
6736                 uint32_t                Data32;
6737
6738                 Data32 = re_eri_read(sc, 0xDC, 4, ERIAR_ExGMAC);
6739                 Data32 &= ~(BIT_16);
6740                 if ((ifp->if_capenable & IFCAP_WOL_MAGIC) != 0)
6741                         Data32 |= BIT_16;
6742                 re_eri_write(sc, 0xDC, 4, Data32, ERIAR_ExGMAC);
6743         } else {
6744                 v = CSR_READ_1(sc, RE_CFG3);
6745                 v &= ~(RL_CFG3_WOL_MAGIC);
6746                 if ((ifp->if_capenable & IFCAP_WOL_MAGIC) != 0)
6747                         v |= RL_CFG3_WOL_MAGIC;
6748                 CSR_WRITE_1(sc, RE_CFG3, v);
6749         }
6750
6751         v = CSR_READ_1(sc, RE_CFG5);
6752         v &= ~(RL_CFG5_WOL_BCAST | RL_CFG5_WOL_MCAST | RL_CFG5_WOL_UCAST |
6753                RL_CFG5_WOL_LANWAKE);
6754
6755         if ((ifp->if_capenable & IFCAP_WOL_UCAST) != 0)
6756                 v |= RL_CFG5_WOL_UCAST;
6757         if ((ifp->if_capenable & IFCAP_WOL_MCAST) != 0)
6758                 v |= RL_CFG5_WOL_MCAST | RL_CFG5_WOL_BCAST;
6759         if ((ifp->if_capenable & IFCAP_WOL) != 0)
6760                 v |= RL_CFG5_WOL_LANWAKE;
6761         CSR_WRITE_1(sc, RE_CFG5, v);
6762
6763         /* Config register write done. */
6764         re_disable_cfg9346_write(sc);
6765
6766         /*
6767          * It seems that hardware resets its link speed to 100Mbps in
6768          * power down mode so switching to 100Mbps in driver is not
6769          * needed.
6770          */
6771
6772         /* Request PME if WOL is requested. */
6773         pmstat = pci_read_config(sc->dev, pmc + PCIR_POWER_STATUS, 2);
6774         pmstat &= ~(PCIM_PSTAT_PMEENABLE);
6775         if ((ifp->if_capenable & IFCAP_WOL) != 0)
6776                 pmstat |= PCIM_PSTAT_PMEENABLE;
6777         pci_write_config(sc->dev, pmc + PCIR_POWER_STATUS, pmstat, 2);
6778
6779         /* Put controller into sleep mode. */
6780         if ((ifp->if_capenable & IFCAP_WOL) != 0) {
6781                 re_set_rx_packet_filter_in_sleep_state(sc);
6782                 re_set_wol_linkspeed(sc);
6783                 if (sc->re_type == MACFG_21 || sc->re_type == MACFG_22)
6784                         CSR_WRITE_1(sc, RE_COMMAND, RE_CMD_RX_ENB);
6785         }
6786 }
6787 #endif  /* !__DragonFly__ */
6788
6789 static void
6790 re_clrwol(struct re_softc *sc)
6791 {
6792         int                     pmc;
6793         uint16_t                pmstat;
6794         uint8_t                 v;
6795
6796         RE_LOCK_ASSERT(sc);
6797
6798 #ifndef __DragonFly__
6799         if (pci_find_cap(sc->dev, PCIY_PMG, &pmc) != 0)
6800                 return;
6801 #else
6802         if (pci_find_extcap(sc->dev, PCIY_PMG, &pmc) != 0)
6803                 return;
6804 #endif
6805
6806         /* Disable PME and clear PME status. */
6807         pmstat = pci_read_config(sc->dev, pmc + PCIR_POWER_STATUS, 2);
6808         pmstat &= ~PCIM_PSTAT_PMEENABLE;
6809         pci_write_config(sc->dev, pmc + PCIR_POWER_STATUS, pmstat, 2);
6810
6811         /* Enable config register write. */
6812         re_enable_cfg9346_write(sc);
6813
6814         if (sc->re_device_id==RT_DEVICEID_8169 || sc->re_device_id==RT_DEVICEID_8169SC) {
6815                 v = CSR_READ_1(sc, RE_CFG1);
6816                 v &= ~RE_CFG1_PME;
6817                 CSR_WRITE_1(sc, RE_CFG1, v);
6818         }
6819
6820         v = CSR_READ_1(sc, RE_CFG3);
6821         v &= ~(RL_CFG3_WOL_LINK);
6822         CSR_WRITE_1(sc, RE_CFG3, v);
6823
6824         if (sc->re_if_flags & RL_FLAG_MAGIC_PACKET_V2) {
6825                 uint32_t                Data32;
6826
6827                 Data32 = re_eri_read(sc, 0xDC, 4, ERIAR_ExGMAC);
6828                 Data32 &= ~(BIT_16);
6829                 re_eri_write(sc, 0xDC, 4, Data32, ERIAR_ExGMAC);
6830         } else {
6831                 v = CSR_READ_1(sc, RE_CFG3);
6832                 v &= ~(RL_CFG3_WOL_MAGIC);
6833                 CSR_WRITE_1(sc, RE_CFG3, v);
6834         }
6835
6836         v = CSR_READ_1(sc, RE_CFG5);
6837         v &= ~(RL_CFG5_WOL_BCAST | RL_CFG5_WOL_MCAST | RL_CFG5_WOL_UCAST);
6838         v &= ~RL_CFG5_WOL_LANWAKE;
6839         CSR_WRITE_1(sc, RE_CFG5, v);
6840
6841         /* Config register write done. */
6842         re_disable_cfg9346_write(sc);
6843 }
6844
6845 /*
6846  * Stop the adapter and free any mbufs allocated to the
6847  * RX and TX lists.
6848  */
6849 #ifndef __DragonFly__
6850 static void re_stop(struct re_softc *sc)        /* Stop Driver */
6851 #else   /* __DragonFly__ */
6852 static void
6853 re_stop_rtl(struct re_softc *sc)
6854 #endif  /* !__DragonFly__ */
6855 {
6856 #ifndef __DragonFly__
6857         struct ifnet            *ifp;
6858
6859         /*      RE_LOCK_ASSERT(sc);*/
6860
6861         ifp = RE_GET_IFNET(sc);
6862 #if OS_VER < VERSION(9,0)
6863         ifp->if_timer = 0;
6864 #endif
6865
6866         re_stop_timer(sc);
6867 #endif  /* !__DragonFly__ */
6868
6869         /*
6870          * Disable accepting frames to put RX MAC into idle state.
6871          * Otherwise it's possible to get frames while stop command
6872          * execution is in progress and controller can DMA the frame
6873          * to already freed RX buffer during that period.
6874          */
6875         CSR_WRITE_4(sc, RE_RXCFG, CSR_READ_4(sc, RE_RXCFG) &
6876                     ~(RE_RXCFG_RX_ALLPHYS | RE_RXCFG_RX_INDIV | RE_RXCFG_RX_MULTI |
6877                       RE_RXCFG_RX_BROAD | RE_RXCFG_RX_RUNT | RE_RXCFG_RX_ERRPKT));
6878
6879         CSR_WRITE_2(sc, RE_IMR, 0x0000);
6880         CSR_WRITE_2(sc, RE_ISR, 0xffff);
6881         if (sc->re_type == MACFG_50 || sc->re_type == MACFG_51 || sc->re_type == MACFG_52) {
6882                 re_eri_write(sc, 0x1bc, 4, 0x0000001f, ERIAR_ExGMAC);
6883                 re_eri_write(sc, 0x1dc, 4, 0x0000002d, ERIAR_ExGMAC);
6884         } else if (sc->re_type == MACFG_38) {
6885                 re_eri_write(sc, 0x1bc, 4, 0x0000001f, ERIAR_ExGMAC);
6886                 re_eri_write(sc, 0x1dc, 4, 0x0000003f, ERIAR_ExGMAC);
6887         }
6888         re_reset(sc);
6889
6890 #ifndef __DragonFly__
6891         /*
6892          * Free the TX list buffers.
6893          */
6894         while (sc->re_desc.tx_last_index!=sc->re_desc.tx_cur_index) {
6895                 if (sc->re_desc.re_tx_mtag) {
6896                         bus_dmamap_sync(sc->re_desc.re_tx_mtag,
6897                                         sc->re_desc.re_tx_dmamap[sc->re_desc.tx_last_index],
6898                                         BUS_DMASYNC_POSTWRITE);
6899                         bus_dmamap_unload(sc->re_desc.re_tx_mtag,
6900                                           sc->re_desc.re_tx_dmamap[sc->re_desc.tx_last_index]);
6901                 }
6902
6903                 if (sc->re_desc.tx_buf[sc->re_desc.tx_last_index]!=NULL) {
6904                         m_freem(sc->re_desc.tx_buf[sc->re_desc.tx_last_index]);
6905                         sc->re_desc.tx_buf[sc->re_desc.tx_last_index] = NULL;
6906                 }
6907                 sc->re_desc.tx_last_index = (sc->re_desc.tx_last_index+1)%RE_TX_BUF_NUM;
6908         }
6909
6910         ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
6911
6912         return;
6913 #endif  /* !__DragonFly__ */
6914 }
6915
6916 #ifndef __DragonFly__
6917 /*
6918  * Main transmit routine.
6919  */
6920 static void re_start(struct ifnet *ifp)         /* Transmit Packet*/
6921 {
6922         struct re_softc         *sc;
6923         struct mbuf             *m_head = NULL;
6924
6925         sc = ifp->if_softc;     /* Paste to ifp in function re_attach(dev) */
6926
6927         RE_LOCK(sc);
6928
6929         /*      RE_LOCK_ASSERT(sc);*/
6930
6931         if ((sc->driver_detach == 1) || (sc->rx_fifo_overflow != 0)) {
6932                 RE_UNLOCK(sc);
6933                 return;
6934         }
6935
6936         while (1) {
6937                 int fs = 1, ls = 0, TxLen = 0, PktLen;
6938                 struct mbuf *ptr;
6939                 uint32_t  opts1 =0;
6940                 uint32_t  opts2 =0;
6941                 IFQ_DRV_DEQUEUE(&ifp->if_snd, m_head);  /* Remove(get) data from system transmit queue */
6942                 if (m_head == NULL) {
6943                         break;
6944                 }
6945
6946                 if (sc->re_coalesce_tx_pkt) {
6947                         if (re_encap(sc, m_head)) {
6948                                 IFQ_DRV_PREPEND(&ifp->if_snd, m_head);
6949                                 ifp->if_drv_flags |= IFF_DRV_OACTIVE;
6950                                 break;
6951                         }
6952
6953                         m_head = sc->re_desc.tx_buf[sc->re_desc.tx_cur_index];
6954                 }
6955
6956                 if (CountMbufNum(m_head) > CountFreeTxDescNum(sc->re_desc)) {   /* No enough descriptor */
6957                         IFQ_DRV_PREPEND(&ifp->if_snd, m_head);
6958                         ifp->if_drv_flags |= IFF_DRV_OACTIVE;
6959                         break;
6960                 }
6961
6962                 if (ifp->if_bpf) {              /* If there's a BPF listener, bounce a copy of this frame to him. */
6963                         //printf("If there's a BPF listener, bounce a copy of this frame to him. \n");
6964
6965                         /*#if OS_VER < VERSION(5, 1)*/
6966 #if OS_VER < VERSION(4,9)
6967                         bpf_mtap(ifp, m_head);
6968 #else
6969                         bpf_mtap(ifp->if_bpf, m_head);
6970 #endif
6971                 }
6972
6973                 //hw checksum
6974                 if (ifp->if_capenable & IFCAP_TXCSUM) {
6975                         if ((m_head->m_pkthdr.csum_flags & RE_CSUM_FEATURES) !=0)       {
6976                                 if (!(sc->re_if_flags & RL_FLAG_DESCV2)) {
6977                                         opts1 |= RL_IPV4CS1;
6978                                         if ((m_head->m_pkthdr.csum_flags & CSUM_TCP)!=0)
6979                                                 opts1 |=RL_TCPCS1;
6980                                         if ((m_head->m_pkthdr.csum_flags & CSUM_UDP)!=0)
6981                                                 opts1 |=RL_UDPCS1;
6982                                 } else {
6983                                         opts2 |=  RL_IPV4CS;
6984                                         if ((m_head->m_pkthdr.csum_flags & CSUM_TCP)!=0)
6985                                                 opts2 |= RL_TCPCS;
6986                                         else if ((m_head->m_pkthdr.csum_flags & CSUM_UDP)!=0)
6987                                                 opts2 |= RL_UDPCS;
6988                                 }
6989                         }
6990                 }
6991
6992                 //vlan
6993                 if (m_head->m_flags & M_VLANTAG)
6994                         opts2 |= bswap16(m_head->m_pkthdr.ether_vtag) | RL_TDESC_VLANCTL_TAG;
6995                 ptr = m_head;
6996                 PktLen = ptr->m_pkthdr.len;
6997 #ifdef _DEBUG_
6998                 printf("PktLen=%d",PktLen);
6999 #endif
7000                 while (ptr!=NULL) {
7001                         if (ptr->m_len >0) {
7002 #ifdef _DEBUG_
7003                                 printf(", len=%d T=%d F=%d",ptr->m_len,ptr->m_type,ptr->m_flags);
7004 #endif
7005                                 TxLen += ptr->m_len;
7006                                 if (TxLen >= PktLen) {
7007                                         ls=1;
7008                                         sc->re_desc.tx_buf[sc->re_desc.tx_cur_index] = m_head;
7009                                 } else
7010                                         sc->re_desc.tx_buf[sc->re_desc.tx_cur_index] = NULL;
7011
7012                                 //vlan
7013                                 WritePacket(sc,ptr->m_data,ptr->m_len,fs,ls,opts2,opts1);
7014
7015                                 fs=0;
7016                         }
7017                         ptr = ptr->m_next;
7018                 }
7019 #ifdef _DEBUG_
7020                 printf("\n");
7021 #endif
7022         }
7023 #if OS_VER < VERSION(9,0)
7024         ifp->if_timer = 5;
7025 #endif
7026
7027         RE_UNLOCK(sc);
7028
7029         return;
7030 }
7031
7032 /*
7033  * Encapsulate an mbuf chain in a descriptor by coupling the mbuf data
7034  * pointers to the fragment pointers.
7035  */
7036 static int re_encap(struct re_softc *sc,struct mbuf *m_head)
7037 {
7038         struct mbuf             *m_new = NULL;
7039
7040         m_new = m_defrag(m_head, M_DONTWAIT);
7041
7042         if (m_new == NULL) {
7043                 printf("re%d: no memory for tx list", sc->re_unit);
7044                 return (1);
7045         }
7046         m_head = m_new;
7047
7048         /* Pad frames to at least 60 bytes. */
7049         if (m_head->m_pkthdr.len < RE_MIN_FRAMELEN) {   /* Case length < 60 bytes */
7050                 /*
7051                  * Make security concious people happy: zero out the
7052                  * bytes in the pad area, since we don't know what
7053                  * this mbuf cluster buffer's previous user might
7054                  * have left in it.
7055                  */
7056                 bzero(mtod(m_head, char *) + m_head->m_pkthdr.len,
7057                       RE_MIN_FRAMELEN - m_head->m_pkthdr.len);
7058                 m_head->m_pkthdr.len = RE_MIN_FRAMELEN;
7059                 m_head->m_len = m_head->m_pkthdr.len;
7060         }
7061
7062         sc->re_desc.tx_buf[sc->re_desc.tx_cur_index] = m_head;
7063
7064         return(0);
7065 }
7066
7067 static void WritePacket(struct re_softc *sc, caddr_t addr, int len,int fs_flag,int ls_flag, uint32_t opts2,uint32_t opts1)
7068 {
7069         union TxDesc *txptr;
7070
7071         txptr=&(sc->re_desc.tx_desc[sc->re_desc.tx_cur_index]);
7072
7073         txptr->ul[0] &= htole32(0x40000000);
7074         txptr->ul[0] |= htole32(opts1);
7075         txptr->ul[1] = htole32(opts2);
7076
7077         if (fs_flag)
7078                 txptr->ul[0] |= htole32(RL_TDESC_CMD_SOF);
7079         if (ls_flag)
7080                 txptr->ul[0] |= htole32(RL_TDESC_CMD_EOF);
7081         txptr->ul[0] |= htole32(len);
7082         bus_dmamap_load(sc->re_desc.re_tx_mtag,
7083                         sc->re_desc.re_tx_dmamap[sc->re_desc.tx_cur_index],
7084                         addr,
7085                         len,
7086                         re_tx_dma_map_buf, txptr,
7087                         0);
7088         bus_dmamap_sync(sc->re_desc.re_tx_mtag,
7089                         sc->re_desc.re_tx_dmamap[sc->re_desc.tx_cur_index],
7090                         BUS_DMASYNC_PREWRITE);
7091         txptr->ul[0] |= htole32(RL_TDESC_CMD_OWN);
7092
7093         bus_dmamap_sync(sc->re_desc.tx_desc_tag,
7094                         sc->re_desc.tx_desc_dmamap,
7095                         BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
7096
7097         if (ls_flag) {
7098                 CSR_WRITE_1(sc, RE_TPPOLL, RE_NPQ);
7099                 CSR_WRITE_1(sc, RE_TPPOLL, RE_NPQ);
7100         }
7101
7102         sc->re_desc.tx_cur_index = (sc->re_desc.tx_cur_index+1)%RE_TX_BUF_NUM;
7103 }
7104
7105 static int CountFreeTxDescNum(struct re_descriptor desc)
7106 {
7107         int ret=desc.tx_last_index-desc.tx_cur_index;
7108         if (ret<=0)
7109                 ret+=RE_TX_BUF_NUM;
7110         ret--;
7111         return ret;
7112 }
7113
7114 static int CountMbufNum(struct mbuf *m_head)
7115 {
7116         int ret=0;
7117         struct mbuf *ptr = m_head;
7118
7119         while (ptr!=NULL) {
7120                 if (ptr->m_len >0)
7121                         ret++;
7122                 ptr=ptr->m_next;
7123         }
7124
7125         return ret;
7126 }
7127
7128 #ifdef RE_FIXUP_RX
7129 static __inline void re_fixup_rx(struct mbuf *m)
7130 {
7131         int                     i;
7132         uint16_t                *src, *dst;
7133
7134         src = mtod(m, uint16_t *);
7135         dst = src - (RE_ETHER_ALIGN - ETHER_ALIGN) / sizeof *src;
7136
7137         for (i = 0; i < (m->m_len / sizeof(uint16_t) + 1); i++)
7138                 *dst++ = *src++;
7139
7140         m->m_data -= RE_ETHER_ALIGN - ETHER_ALIGN;
7141 }
7142 #endif
7143
7144 /*
7145  * A frame was downloaded to the chip. It's safe for us to clean up
7146  * the list buffers.
7147  */
7148 static void re_txeof(struct re_softc *sc)       /* Transmit OK/ERR handler */
7149 {
7150         union TxDesc *txptr;
7151         struct ifnet            *ifp;
7152         u_int32_t           txstat;
7153
7154         /*      printf("X");*/
7155
7156         ifp = RE_GET_IFNET(sc);
7157
7158 #if OS_VER < VERSION(9,0)
7159         /* Clear the timeout timer. */
7160         ifp->if_timer = 0;
7161 #endif
7162
7163         bus_dmamap_sync(sc->re_desc.tx_desc_tag,
7164                         sc->re_desc.tx_desc_dmamap,
7165                         BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE);
7166
7167         while (sc->re_desc.tx_last_index!=sc->re_desc.tx_cur_index) {
7168                 txptr=&(sc->re_desc.tx_desc[sc->re_desc.tx_last_index]);
7169                 txstat = le32toh(txptr->ul[0]);
7170                 if (txstat & RL_TDESC_STAT_OWN)
7171                         break;
7172 #ifdef _DEBUG_
7173                 printf("**** Tx OK  ****\n");
7174 #endif
7175                 bus_dmamap_sync(sc->re_desc.re_tx_mtag,
7176                                 sc->re_desc.re_tx_dmamap[sc->re_desc.tx_last_index],
7177                                 BUS_DMASYNC_POSTWRITE);
7178                 bus_dmamap_unload(sc->re_desc.re_tx_mtag,
7179                                   sc->re_desc.re_tx_dmamap[sc->re_desc.tx_last_index]);
7180
7181                 if (sc->re_desc.tx_buf[sc->re_desc.tx_last_index]!=NULL) {
7182                         m_freem(sc->re_desc.tx_buf[sc->re_desc.tx_last_index]); /* Free Current MBuf in a Mbuf list*/
7183                         sc->re_desc.tx_buf[sc->re_desc.tx_last_index] = NULL;
7184                 }
7185
7186                 sc->re_desc.tx_last_index = (sc->re_desc.tx_last_index+1)%RE_TX_BUF_NUM;
7187 #if OS_VER < VERSION(11,0)
7188                 if (txstat & (RL_TDESC_STAT_EXCESSCOL|
7189                               RL_TDESC_STAT_COLCNT))
7190                         ifp->if_collisions++;
7191                 if (txstat & RL_TDESC_STAT_TXERRSUM)
7192                         ifp->if_oerrors++;
7193                 else
7194                         ifp->if_opackets++;
7195 #else
7196                 if (txstat & (RL_TDESC_STAT_EXCESSCOL|
7197                               RL_TDESC_STAT_COLCNT))
7198                         if_inc_counter(ifp, IFCOUNTER_COLLISIONS, 1);
7199                 if (txstat & RL_TDESC_STAT_TXERRSUM)
7200                         if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
7201                 else
7202                         if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1);
7203 #endif
7204                 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
7205         }
7206
7207         return;
7208 }
7209
7210 /*
7211  * A frame has been uploaded: pass the resulting mbuf chain up to
7212  * the higher level protocols.
7213  *
7214  * You know there's something wrong with a PCI bus-master chip design
7215  * when you have to use m_devget().
7216  *
7217  * The receive operation is badly documented in the datasheet, so I'll
7218  * attempt to document it here. The driver provides a buffer area and
7219  * places its base address in the RX buffer start address register.
7220  * The chip then begins copying frames into the RX buffer. Each frame
7221  * is preceeded by a 32-bit RX status word which specifies the length
7222  * of the frame and certain other status bits. Each frame (starting with
7223  * the status word) is also 32-bit aligned. The frame length is in the
7224  * first 16 bits of the status word; the lower 15 bits correspond with
7225  * the 'rx status register' mentioned in the datasheet.
7226  *
7227  * Note: to make the Alpha happy, the frame payload needs to be aligned
7228  * on a 32-bit boundary. To achieve this, we cheat a bit by copying from
7229  * the ring buffer starting at an address two bytes before the actual
7230  * data location. We can then shave off the first two bytes using m_adj().
7231  * The reason we do this is because m_devget() doesn't let us specify an
7232  * offset into the mbuf storage space, so we have to artificially create
7233  * one. The ring is allocated in such a way that there are a few unused
7234  * bytes of space preceecing it so that it will be safe for us to do the
7235  * 2-byte backstep even if reading from the ring at offset 0.
7236  */
7237 static void re_rxeof(sc)        /* Receive Data OK/ERR handler */
7238 struct re_softc         *sc;
7239 {
7240         struct ether_header     *eh;
7241         struct mbuf             *m;
7242         struct ifnet            *ifp;
7243         union RxDesc *rxptr;
7244         int bError;
7245         struct mbuf *buf;
7246         int size;
7247         int maxpkt = RE_RX_BUF_NUM;
7248
7249         u_int32_t opts2,opts1;
7250
7251         /*              RE_LOCK_ASSERT(sc);*/
7252
7253         ifp = RE_GET_IFNET(sc);
7254
7255         bus_dmamap_sync(sc->re_desc.rx_desc_tag,
7256                         sc->re_desc.rx_desc_dmamap,
7257                         BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE);
7258
7259         rxptr=&(sc->re_desc.rx_desc[sc->re_desc.rx_cur_index]);
7260         while ((rxptr->ul[0]&htole32(RL_RDESC_STAT_OWN))==0) {  /* Receive OK */
7261                 bError = 0;
7262
7263                 opts1 = le32toh(rxptr->ul[0]);
7264
7265                 /* Check if this packet is received correctly*/
7266                 if (opts1&0x200000) {   /*Check RES bit*/
7267                         bError=1;
7268 #if OS_VER < VERSION(11,0)
7269                         ifp->if_ierrors++;
7270 #else
7271                         if_inc_counter(ifp, IFCOUNTER_IERRORS, 1);
7272 #endif
7273                         goto update_desc;
7274                 }
7275                 opts2 = le32toh(rxptr->ul[1]);
7276
7277                 //buf = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR); /* Alloc a new mbuf */
7278
7279                 if (sc->re_rx_mbuf_sz <= MCLBYTES)
7280                         size = MCLBYTES;
7281                 else if (sc->re_rx_mbuf_sz <= MJUMPAGESIZE)
7282                         size = MJUMPAGESIZE;
7283                 else
7284                         size = MJUM9BYTES;
7285
7286                 buf = m_getjcl(M_DONTWAIT, MT_DATA, M_PKTHDR, size);
7287                 if (buf==NULL) {
7288                         bError=1;
7289 #if OS_VER < VERSION(11,0)
7290                         ifp->if_iqdrops++;
7291 #else
7292                         if_inc_counter(ifp, IFCOUNTER_IQDROPS, 1);
7293 #endif
7294                         goto update_desc;
7295                 }
7296
7297                 buf->m_len = buf->m_pkthdr.len = size;
7298 #ifdef RE_FIXUP_RX
7299                 /*
7300                  * This is part of an evil trick to deal with non-x86 platforms.
7301                  * The RealTek chip requires RX buffers to be aligned on 64-bit
7302                  * boundaries, but that will hose non-x86 machines. To get around
7303                  * this, we leave some empty space at the start of each buffer
7304                  * and for non-x86 hosts, we copy the buffer back six bytes
7305                  * to achieve word alignment. This is slightly more efficient
7306                  * than allocating a new buffer, copying the contents, and
7307                  * discarding the old buffer.
7308                  */
7309                 m_adj(buf, RE_ETHER_ALIGN);
7310 #endif
7311
7312                 bus_dmamap_sync(sc->re_desc.re_rx_mtag,
7313                                 sc->re_desc.re_rx_dmamap[sc->re_desc.rx_cur_index],
7314                                 BUS_DMASYNC_POSTREAD);
7315                 bus_dmamap_unload(sc->re_desc.re_rx_mtag,
7316                                   sc->re_desc.re_rx_dmamap[sc->re_desc.rx_cur_index]);
7317
7318                 m = sc->re_desc.rx_buf[sc->re_desc.rx_cur_index];
7319                 sc->re_desc.rx_buf[sc->re_desc.rx_cur_index] = buf;
7320                 m->m_pkthdr.len = m->m_len = (opts1&RL_RDESC_STAT_GFRAGLEN)-ETHER_CRC_LEN;
7321                 m->m_pkthdr.rcvif = ifp;
7322
7323 #ifdef RE_FIXUP_RX
7324                 re_fixup_rx(m);
7325 #endif
7326
7327                 //vlan
7328                 if (opts2 & RL_RDESC_VLANCTL_TAG) {
7329                         m->m_pkthdr.ether_vtag =
7330                                 bswap16((opts2 & RL_RDESC_VLANCTL_DATA));
7331                         m->m_flags |= M_VLANTAG;
7332                 }
7333                 if (ifp->if_capenable & IFCAP_RXCSUM) {
7334                         if (!(sc->re_if_flags & RL_FLAG_DESCV2)) {
7335                                 if (opts1 & RL_ProtoIP)
7336                                         m->m_pkthdr.csum_flags |=  CSUM_IP_CHECKED;
7337                                 if (!(opts1 & RL_IPF))
7338                                         m->m_pkthdr.csum_flags |= CSUM_IP_VALID;
7339                                 if ((((opts1 & RL_ProtoIP)==(1<<17)) && !(opts1 & RL_TCPF))   || (((opts1 & RL_ProtoIP)==(1<<18)) && !(opts1 & RL_UDPF))) {
7340                                         m->m_pkthdr.csum_flags |= CSUM_DATA_VALID|CSUM_PSEUDO_HDR;
7341                                         m->m_pkthdr.csum_data = 0xffff;
7342                                 }
7343                         } else {
7344                                 if ((opts1 & RL_ProtoIP) && (opts2 & RL_V4F))
7345                                         m->m_pkthdr.csum_flags |=  CSUM_IP_CHECKED;
7346                                 if (!(opts1 & RL_IPF) && (opts2 & RL_V4F))
7347                                         m->m_pkthdr.csum_flags |= CSUM_IP_VALID;
7348                                 if (((opts1 & RL_TCPT) && !(opts2 & RL_TCPF)) || ((opts1 & RL_UDPT) && !(opts2 & RL_UDPF))) {
7349                                         m->m_pkthdr.csum_flags |= CSUM_DATA_VALID|CSUM_PSEUDO_HDR;
7350                                         m->m_pkthdr.csum_data = 0xffff;
7351                                 }
7352                         }
7353                 }
7354
7355                 eh = mtod(m, struct ether_header *);
7356 #if OS_VER < VERSION(11,0)
7357                 ifp->if_ipackets++;
7358 #else
7359                 if_inc_counter(ifp, IFCOUNTER_IPACKETS, 1);
7360 #endif
7361 #ifdef _DEBUG_
7362                 printf("Rcv Packet, Len=%d \n", m->m_len);
7363 #endif
7364
7365                 RE_UNLOCK(sc);
7366
7367                 /*#if OS_VER < VERSION(5, 1)*/
7368 #if OS_VER < VERSION(4,9)
7369                 /* Remove header from mbuf and pass it on. */
7370                 m_adj(m, sizeof(struct ether_header));
7371                 ether_input(ifp, eh, m);
7372 #else
7373                 (*ifp->if_input)(ifp, m);
7374 #endif
7375                 RE_LOCK(sc);
7376
7377 update_desc:
7378                 rxptr->ul[0]&=htole32(0x40000000);      /* keep EOR bit */
7379                 rxptr->ul[1]=0;
7380
7381                 rxptr->ul[0] |= htole32(sc->re_rx_desc_buf_sz);
7382                 if (!bError) {
7383                         bus_dmamap_load(sc->re_desc.re_rx_mtag,
7384                                         sc->re_desc.re_rx_dmamap[sc->re_desc.rx_cur_index],
7385                                         sc->re_desc.rx_buf[sc->re_desc.rx_cur_index]->m_data,
7386                                         sc->re_rx_desc_buf_sz,
7387                                         re_rx_dma_map_buf, rxptr,
7388                                         0);
7389                         bus_dmamap_sync(sc->re_desc.re_rx_mtag,
7390                                         sc->re_desc.re_rx_dmamap[sc->re_desc.rx_cur_index],
7391                                         BUS_DMASYNC_PREREAD);
7392                 }
7393                 rxptr->ul[0] |= htole32(RL_RDESC_CMD_OWN);
7394                 sc->re_desc.rx_cur_index = (sc->re_desc.rx_cur_index+1)%RE_RX_BUF_NUM;
7395                 rxptr=&sc->re_desc.rx_desc[sc->re_desc.rx_cur_index];
7396
7397                 maxpkt--;
7398                 if (maxpkt==0)
7399                         break;
7400         }
7401
7402         bus_dmamap_sync(sc->re_desc.rx_desc_tag,
7403                         sc->re_desc.rx_desc_dmamap,
7404                         BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
7405
7406         return;
7407 }
7408
7409 #if OS_VER < VERSION(7,0)
7410 static void re_intr(void *arg)          /* Interrupt Handler */
7411 #else
7412 static int re_intr(void *arg)   /* Interrupt Handler */
7413 #endif //OS_VER < VERSION(7,0)
7414 {
7415         struct re_softc         *sc;
7416
7417         sc = arg;
7418
7419         if ((sc->re_if_flags & (RL_FLAG_MSI | RL_FLAG_MSIX)) == 0) {
7420                 if ((CSR_READ_2(sc, RE_ISR) & RE_INTRS) == 0) {
7421 #if OS_VER < VERSION(7,0)
7422                         return;
7423 #else
7424                         return (FILTER_STRAY);
7425 #endif
7426                 }
7427         }
7428
7429         /* Disable interrupts. */
7430         CSR_WRITE_2(sc, RE_IMR, 0x0000);
7431
7432 #if OS_VER < VERSION(7,0)
7433         re_int_task(arg, 0);
7434 #else //OS_VER < VERSION(7,0)
7435 #if OS_VER < VERSION(11,0)
7436         taskqueue_enqueue_fast(taskqueue_fast, &sc->re_inttask);
7437 #else ////OS_VER < VERSION(11,0)
7438         taskqueue_enqueue(taskqueue_fast, &sc->re_inttask);
7439 #endif //OS_VER < VERSION(11,0)
7440         return (FILTER_HANDLED);
7441 #endif //OS_VER < VERSION(7,0)
7442 }
7443
7444 static void re_int_task(void *arg, int npending)
7445 {
7446         struct re_softc         *sc;
7447         struct ifnet            *ifp;
7448         u_int16_t               status;
7449
7450         sc = arg;
7451
7452         RE_LOCK(sc);
7453
7454         ifp = RE_GET_IFNET(sc);
7455
7456         status = CSR_READ_2(sc, RE_ISR);
7457
7458         if (status) {
7459                 CSR_WRITE_2(sc, RE_ISR, status & 0xffbf);
7460         }
7461
7462         if (sc->suspended ||
7463             (ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) {
7464                 RE_UNLOCK(sc);
7465                 return;
7466         }
7467
7468         re_rxeof(sc);
7469
7470         if (sc->re_type == MACFG_21) {
7471                 if (status & RE_ISR_FIFO_OFLOW) {
7472                         sc->rx_fifo_overflow = 1;
7473                         CSR_WRITE_2(sc, 0x00e2, 0x0000);
7474                         CSR_WRITE_4(sc, 0x0048, 0x4000);
7475                         CSR_WRITE_4(sc, 0x0058, 0x4000);
7476                 } else {
7477                         sc->rx_fifo_overflow = 0;
7478                         CSR_WRITE_4(sc,RE_CPCR, 0x51512082);
7479                 }
7480
7481                 if (status & RE_ISR_PCS_TIMEOUT) {
7482                         if ((status & RE_ISR_FIFO_OFLOW) &&
7483                             (!(status & (RE_ISR_RX_OK | RE_ISR_TX_OK | RE_ISR_RX_OVERRUN)))) {
7484                                 re_reset(sc);
7485                                 re_init(sc);
7486                                 sc->rx_fifo_overflow = 0;
7487                                 CSR_WRITE_2(sc, RE_ISR, RE_ISR_FIFO_OFLOW);
7488                         }
7489                 }
7490         }
7491
7492         re_txeof(sc);
7493
7494         if (status & RE_ISR_SYSTEM_ERR) {
7495                 re_reset(sc);
7496                 re_init(sc);
7497         }
7498
7499         switch(sc->re_type) {
7500         case MACFG_21:
7501         case MACFG_22:
7502         case MACFG_23:
7503         case MACFG_24:
7504                 CSR_WRITE_1(sc, RE_TPPOLL, RE_NPQ);
7505                 break;
7506
7507         default:
7508                 break;
7509         }
7510
7511         RE_UNLOCK(sc);
7512
7513         if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd))
7514                 re_start(ifp);
7515
7516 #if OS_VER>=VERSION(7,0)
7517         if (CSR_READ_2(sc, RE_ISR) & RE_INTRS) {
7518 #if OS_VER < VERSION(11,0)
7519                 taskqueue_enqueue_fast(taskqueue_fast, &sc->re_inttask);
7520 #else ////OS_VER < VERSION(11,0)
7521                 taskqueue_enqueue(taskqueue_fast, &sc->re_inttask);
7522 #endif //OS_VER < VERSION(11,0)
7523                 return;
7524         }
7525 #endif //OS_VER>=VERSION(7,0)
7526
7527         /* Re-enable interrupts. */
7528         CSR_WRITE_2(sc, RE_IMR, RE_INTRS);
7529 }
7530 #endif  /* !__DragonFly__ */
7531
7532 static void re_set_multicast_reg(struct re_softc *sc, u_int32_t mask0, u_int32_t mask4)
7533 {
7534         u_int8_t  enable_cfg_reg_write = 0;
7535
7536         if (sc->re_type == MACFG_5 || sc->re_type == MACFG_6)
7537                 enable_cfg_reg_write = 1;
7538
7539         if (enable_cfg_reg_write)
7540                 re_enable_cfg9346_write(sc);
7541         CSR_WRITE_4(sc, RE_MAR0, mask0);
7542         CSR_WRITE_4(sc, RE_MAR4, mask4);
7543         if (enable_cfg_reg_write)
7544                 re_disable_cfg9346_write(sc);
7545
7546         return;
7547 }
7548
7549 #ifndef __DragonFly__
7550 static void re_set_rx_packet_filter_in_sleep_state(struct re_softc *sc)
7551 {
7552         struct ifnet            *ifp;
7553         u_int32_t               rxfilt;
7554
7555         ifp = RE_GET_IFNET(sc);
7556
7557         rxfilt = CSR_READ_4(sc, RE_RXCFG);
7558
7559         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);
7560         rxfilt |= (RE_RXCFG_RX_INDIV | RE_RXCFG_RX_MULTI | RE_RXCFG_RX_BROAD);
7561
7562         CSR_WRITE_4(sc, RE_RXCFG, rxfilt);
7563
7564         re_set_multicast_reg(sc, 0xFFFFFFFF, 0xFFFFFFFF);
7565
7566         return;
7567 }
7568 #endif  /* !__DragonFly__ */
7569
7570 static void re_set_rx_packet_filter(struct re_softc *sc)
7571 {
7572         struct ifnet            *ifp;
7573         u_int32_t               rxfilt;
7574
7575         ifp = RE_GET_IFNET(sc);
7576
7577         rxfilt = CSR_READ_4(sc, RE_RXCFG);
7578
7579         rxfilt |= RE_RXCFG_RX_INDIV;
7580
7581         if (ifp->if_flags & (IFF_MULTICAST | IFF_ALLMULTI | IFF_PROMISC)) {
7582                 rxfilt |= (RE_RXCFG_RX_ALLPHYS | RE_RXCFG_RX_MULTI);
7583         } else {
7584                 rxfilt &= ~(RE_RXCFG_RX_MULTI);
7585         }
7586
7587         if (ifp->if_flags & IFF_PROMISC) {
7588                 rxfilt |= (RE_RXCFG_RX_ALLPHYS | RE_RXCFG_RX_RUNT | RE_RXCFG_RX_ERRPKT);
7589         } else {
7590                 rxfilt &= ~(RE_RXCFG_RX_ALLPHYS | RE_RXCFG_RX_RUNT | RE_RXCFG_RX_ERRPKT);
7591         }
7592
7593         if (ifp->if_flags & (IFF_BROADCAST | IFF_PROMISC)) {
7594                 rxfilt |= RE_RXCFG_RX_BROAD;
7595         } else {
7596                 rxfilt &= ~RE_RXCFG_RX_BROAD;
7597         }
7598
7599         CSR_WRITE_4(sc, RE_RXCFG, rxfilt);
7600
7601         re_setmulti(sc);
7602
7603         return;
7604 }
7605
7606 /*
7607  * Program the 64-bit multicast hash filter.
7608  */
7609 static void re_setmulti(struct re_softc *sc)
7610 {
7611         struct ifnet            *ifp;
7612         int                     h = 0;
7613         u_int32_t               hashes[2] = { 0, 0 };
7614         struct ifmultiaddr      *ifma;
7615         u_int32_t               rxfilt;
7616         int                     mcnt = 0;
7617
7618         ifp = RE_GET_IFNET(sc);
7619
7620         rxfilt = CSR_READ_4(sc, RE_RXCFG);
7621
7622         if (ifp->if_flags & IFF_ALLMULTI || ifp->if_flags & IFF_PROMISC) {
7623                 rxfilt |= RE_RXCFG_RX_MULTI;
7624                 CSR_WRITE_4(sc, RE_RXCFG, rxfilt);
7625                 re_set_multicast_reg(sc, 0xFFFFFFFF, 0xFFFFFFFF);
7626
7627                 return;
7628         }
7629
7630 #ifndef __DragonFly__
7631         /* now program new ones */
7632 #if OS_VER > VERSION(6,0)
7633         IF_ADDR_LOCK(ifp);
7634 #endif
7635 #if OS_VER < VERSION(4,9)
7636         for (ifma = ifp->if_multiaddrs.lh_first; ifma != NULL;
7637              ifma = ifma->ifma_link.le_next)
7638 #else
7639         TAILQ_FOREACH(ifma,&ifp->if_multiaddrs,ifma_link)
7640 #endif
7641 #else   /* __DragonFly__ */
7642         TAILQ_FOREACH(ifma,&ifp->if_multiaddrs,ifma_link)
7643 #endif  /* !__DragonFly__ */
7644         {
7645                 if (ifma->ifma_addr->sa_family != AF_LINK)
7646                         continue;
7647                 h = ether_crc32_be(LLADDR((struct sockaddr_dl *)
7648                                           ifma->ifma_addr), ETHER_ADDR_LEN) >> 26;
7649                 if (h < 32)
7650                         hashes[0] |= (1 << h);
7651                 else
7652                         hashes[1] |= (1 << (h - 32));
7653                 mcnt++;
7654         }
7655 #ifndef __DragonFly__
7656 #if OS_VER > VERSION(6,0)
7657         IF_ADDR_UNLOCK(ifp);
7658 #endif
7659 #endif  /* !__DragonFly__ */
7660
7661         if (mcnt) {
7662                 if ((sc->re_if_flags & RL_FLAG_PCIE) != 0) {
7663                         h = bswap32(hashes[0]);
7664                         hashes[0] = bswap32(hashes[1]);
7665                         hashes[1] = h;
7666                 }
7667                 rxfilt |= RE_RXCFG_RX_MULTI;
7668         } else
7669                 rxfilt &= ~RE_RXCFG_RX_MULTI;
7670
7671         CSR_WRITE_4(sc, RE_RXCFG, rxfilt);
7672         re_set_multicast_reg(sc, hashes[0], hashes[1]);
7673
7674         return;
7675 }
7676
7677 #ifndef __DragonFly__
7678 static int re_ioctl(ifp, command, data)
7679 struct ifnet            *ifp;
7680 u_long                  command;
7681 caddr_t                 data;
7682 {
7683         struct re_softc         *sc = ifp->if_softc;
7684         struct ifreq            *ifr = (struct ifreq *) data;
7685         /*int                   s;*/
7686         int                     error = 0;
7687         int mask, reinit;
7688         /*s = splimp();*/
7689
7690         switch(command) {
7691         case SIOCSIFADDR:
7692         case SIOCGIFADDR:
7693                 error = ether_ioctl(ifp, command, data);
7694
7695                 break;
7696         case SIOCSIFMTU:
7697
7698                 //printf("before mtu =%d\n",(int)ifp->if_mtu);
7699                 if (ifr->ifr_mtu > sc->max_jumbo_frame_size)
7700                         error = EINVAL;
7701                 else {
7702                         ifp->if_mtu = ifr->ifr_mtu;
7703
7704                         //if running
7705                         if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
7706                                 //printf("set mtu when running\n");
7707
7708                                 RE_LOCK(sc);
7709                                 re_stop(sc);
7710
7711                                 re_release_buf(sc);
7712                                 set_rxbufsize(sc);
7713                                 error =re_alloc_buf(sc);
7714
7715                                 if (error == 0) {
7716                                         re_init(sc);
7717                                 }
7718                                 RE_UNLOCK(sc);
7719
7720                         } else {
7721                                 //if not running
7722                                 RE_LOCK(sc);
7723                                 re_release_buf(sc);
7724                                 set_rxbufsize(sc);
7725                                 error =re_alloc_buf(sc);
7726                                 if (error == 0) {
7727                                         /* Init descriptors. */
7728                                         re_var_init(sc);
7729                                 }
7730                                 RE_UNLOCK(sc);
7731                         }
7732
7733                 }
7734                 //      printf("after mtu =%d\n",(int)ifp->if_mtu);
7735                 break;
7736         case SIOCSIFFLAGS:
7737                 RE_LOCK(sc);
7738                 if (ifp->if_flags & IFF_UP) {
7739                         re_init(sc);
7740                 } else if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
7741                         re_stop(sc);
7742                 }
7743                 error = 0;
7744                 RE_UNLOCK(sc);
7745                 break;
7746         case SIOCADDMULTI:
7747         case SIOCDELMULTI:
7748                 RE_LOCK(sc);
7749                 re_set_rx_packet_filter(sc);
7750                 RE_UNLOCK(sc);
7751                 error = 0;
7752                 break;
7753         case SIOCGIFMEDIA:
7754         case SIOCSIFMEDIA:
7755                 error = ifmedia_ioctl(ifp, ifr, &sc->media, command);
7756                 break;
7757         case SIOCSIFCAP:
7758
7759
7760                 mask = ifr->ifr_reqcap ^ ifp->if_capenable;
7761                 reinit = 0;
7762
7763                 if ((mask & IFCAP_TXCSUM) != 0 && (ifp->if_capabilities & IFCAP_TXCSUM) != 0) {
7764                         ifp->if_capenable ^= IFCAP_TXCSUM;
7765                         if ((ifp->if_capenable & IFCAP_TXCSUM) != 0)  {
7766                                 if ((sc->re_type == MACFG_24) || (sc->re_type == MACFG_24) || (sc->re_type == MACFG_26))
7767                                         ifp->if_hwassist |= CSUM_TCP | CSUM_UDP;
7768                                 else
7769                                         ifp->if_hwassist |= RE_CSUM_FEATURES;
7770                         } else
7771                                 ifp->if_hwassist &= ~RE_CSUM_FEATURES;
7772                         reinit = 1;
7773                 }
7774
7775                 if ((mask & IFCAP_RXCSUM) != 0 &&
7776                     (ifp->if_capabilities & IFCAP_RXCSUM) != 0) {
7777                         ifp->if_capenable ^= IFCAP_RXCSUM;
7778                         reinit = 1;
7779                 }
7780
7781                 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))) {
7782                         if (ifp->if_capenable & IFCAP_TXCSUM)
7783                                 sc->re_tx_cstag = 1;
7784                         else
7785                                 sc->re_tx_cstag = 0;
7786
7787                         if (ifp->if_capenable & IFCAP_RXCSUM)
7788                                 sc->re_rx_cstag = 1;
7789                         else
7790                                 sc->re_rx_cstag = 0;
7791                 }
7792                 if ((mask & IFCAP_VLAN_HWTAGGING) != 0 &&
7793                     (ifp->if_capabilities & IFCAP_VLAN_HWTAGGING) != 0) {
7794                         ifp->if_capenable ^= IFCAP_VLAN_HWTAGGING;
7795                         /* TSO over VLAN requires VLAN hardware tagging. */
7796                         //if ((ifp->if_capenable & IFCAP_VLAN_HWTAGGING) == 0)
7797                         //      ifp->if_capenable &= ~IFCAP_VLAN_HWTSO;
7798                         reinit = 1;
7799                 }
7800
7801                 if ((mask & IFCAP_WOL) != 0 &&
7802                     (ifp->if_capabilities & IFCAP_WOL) != 0) {
7803                         if ((mask & IFCAP_WOL_UCAST) != 0)
7804                                 ifp->if_capenable ^= IFCAP_WOL_UCAST;
7805                         if ((mask & IFCAP_WOL_MCAST) != 0)
7806                                 ifp->if_capenable ^= IFCAP_WOL_MCAST;
7807                         if ((mask & IFCAP_WOL_MAGIC) != 0)
7808                                 ifp->if_capenable ^= IFCAP_WOL_MAGIC;
7809                 }
7810                 if (reinit && ifp->if_drv_flags & IFF_DRV_RUNNING) {
7811                         ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
7812                         re_init(sc);
7813                 }
7814                 VLAN_CAPABILITIES(ifp);
7815                 break;
7816         default:
7817                 error = EINVAL;
7818                 break;
7819         }
7820
7821         /*(void)splx(s);*/
7822
7823         return(error);
7824 }
7825 #endif  /* !__DragonFly__ */
7826
7827 static void re_link_on_patch(struct re_softc *sc)
7828 {
7829         struct ifnet            *ifp;
7830
7831         ifp = RE_GET_IFNET(sc);
7832
7833         if (sc->re_type == MACFG_50 || sc->re_type == MACFG_51 || sc->re_type == MACFG_52) {
7834                 if (CSR_READ_1(sc, RE_PHY_STATUS) & RL_PHY_STATUS_1000MF) {
7835                         re_eri_write(sc, 0x1bc, 4, 0x00000011, ERIAR_ExGMAC);
7836                         re_eri_write(sc, 0x1dc, 4, 0x0000001f, ERIAR_ExGMAC);
7837                 } else if (CSR_READ_1(sc, RE_PHY_STATUS) & RL_PHY_STATUS_100M) {
7838                         re_eri_write(sc, 0x1bc, 4, 0x0000001f, ERIAR_ExGMAC);
7839                         re_eri_write(sc, 0x1dc, 4, 0x0000001f, ERIAR_ExGMAC);
7840                 } else {
7841                         re_eri_write(sc, 0x1bc, 4, 0x0000001f, ERIAR_ExGMAC);
7842                         re_eri_write(sc, 0x1dc, 4, 0x0000002d, ERIAR_ExGMAC);
7843                 }
7844         } else if ((sc->re_type == MACFG_38 || sc->re_type == MACFG_39) && (ifp->if_flags & IFF_UP)) {
7845                 if (sc->re_type == MACFG_38 && (CSR_READ_1(sc, RE_PHY_STATUS) & RL_PHY_STATUS_10M)) {
7846                         CSR_WRITE_4(sc, RE_RXCFG, CSR_READ_4(sc, RE_RXCFG) | RE_RXCFG_RX_ALLPHYS);
7847                 } else if (sc->re_type == MACFG_39) {
7848                         if (CSR_READ_1(sc, RE_PHY_STATUS) & RL_PHY_STATUS_1000MF) {
7849                                 re_eri_write(sc, 0x1bc, 4, 0x00000011, ERIAR_ExGMAC);
7850                                 re_eri_write(sc, 0x1dc, 4, 0x00000005, ERIAR_ExGMAC);
7851                         } else if (CSR_READ_1(sc, RE_PHY_STATUS) & RL_PHY_STATUS_100M) {
7852                                 re_eri_write(sc, 0x1bc, 4, 0x0000001f, ERIAR_ExGMAC);
7853                                 re_eri_write(sc, 0x1dc, 4, 0x00000005, ERIAR_ExGMAC);
7854                         } else {
7855                                 re_eri_write(sc, 0x1bc, 4, 0x0000001f, ERIAR_ExGMAC);
7856                                 re_eri_write(sc, 0x1dc, 4, 0x0000003f, ERIAR_ExGMAC);
7857                         }
7858                 }
7859         } else if ((sc->re_type == MACFG_36 || sc->re_type == MACFG_37) && eee_enable ==1) {
7860                 /*Full -Duplex  mode*/
7861                 if (CSR_READ_1(sc, RE_PHY_STATUS) & RL_PHY_STATUS_FULL_DUP) {
7862                         MP_WritePhyUshort(sc, 0x1F, 0x0006);
7863                         MP_WritePhyUshort(sc, 0x00, 0x5a30);
7864                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
7865                         if (CSR_READ_1(sc, RE_PHY_STATUS) & (RL_PHY_STATUS_10M | RL_PHY_STATUS_100M))
7866                                 CSR_WRITE_4(sc, RE_TXCFG, (CSR_READ_4(sc, RE_TXCFG) & ~BIT_19) | BIT_25);
7867
7868                 } else {
7869                         MP_WritePhyUshort(sc, 0x1F, 0x0006);
7870                         MP_WritePhyUshort(sc, 0x00, 0x5a00);
7871                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
7872                         if (CSR_READ_1(sc, RE_PHY_STATUS) & (RL_PHY_STATUS_10M | RL_PHY_STATUS_100M))
7873                                 CSR_WRITE_4(sc, RE_TXCFG, (CSR_READ_4(sc, RE_TXCFG) & ~BIT_19) | RE_TXCFG_IFG);
7874                 }
7875         } else if ((sc->re_type == MACFG_56 || sc->re_type == MACFG_57 ||
7876                     sc->re_type == MACFG_58 || sc->re_type == MACFG_59 ||
7877                     sc->re_type == MACFG_60 || sc->re_type == MACFG_61 ||
7878                     sc->re_type == MACFG_62 || sc->re_type == MACFG_67 ||
7879                     sc->re_type == MACFG_68 || sc->re_type == MACFG_69 ||
7880                     sc->re_type == MACFG_70 || sc->re_type == MACFG_71) &&
7881                    (ifp->if_flags & IFF_UP)) {
7882                 if (CSR_READ_1(sc, RE_PHY_STATUS) & RL_PHY_STATUS_FULL_DUP)
7883                         CSR_WRITE_4(sc, RE_TXCFG, (CSR_READ_4(sc, RE_TXCFG) | (BIT_24 | BIT_25)) & ~BIT_19);
7884                 else
7885                         CSR_WRITE_4(sc, RE_TXCFG, (CSR_READ_4(sc, RE_TXCFG) | BIT_25) & ~(BIT_19 | BIT_24));
7886         }
7887
7888         if (sc->re_type == MACFG_56 || sc->re_type == MACFG_57 ||
7889             sc->re_type == MACFG_61 || sc->re_type == MACFG_62) {
7890                 /*half mode*/
7891                 if (!(CSR_READ_1(sc, RE_PHY_STATUS) & RL_PHY_STATUS_FULL_DUP)) {
7892                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
7893                         MP_WritePhyUshort(sc, MII_ANAR, MP_ReadPhyUshort(sc, MII_ANAR)&~(ANAR_PAUSE_SYM |ANAR_PAUSE_ASYM));
7894                 }
7895         }
7896
7897         if ((sc->re_type == MACFG_70 || sc->re_type == MACFG_71) &&
7898             (CSR_READ_1(sc, RE_PHY_STATUS) & RL_PHY_STATUS_10M)) {
7899                 uint32_t Data32;
7900
7901                 Data32 = re_eri_read(sc, 0x1D0, 1, ERIAR_ExGMAC);
7902                 Data32 |= BIT_1;
7903                 re_eri_write(sc, 0x1D0, 1, Data32, ERIAR_ExGMAC);
7904         }
7905
7906 #ifndef __DragonFly__
7907         re_init_unlock(sc);
7908 #endif
7909 }
7910
7911 #ifndef __DragonFly__
7912 static void re_link_down_patch(struct re_softc *sc)
7913 {
7914         struct ifnet            *ifp;
7915
7916         ifp = RE_GET_IFNET(sc);
7917
7918         re_txeof(sc);
7919         re_rxeof(sc);
7920         re_stop(sc);
7921
7922         re_ifmedia_upd(ifp);
7923 }
7924
7925 /*
7926  * Check Link Status.
7927  */
7928 static void re_check_link_status(struct re_softc *sc)
7929 {
7930         u_int8_t        link_state;
7931         struct ifnet            *ifp;
7932
7933         ifp = RE_GET_IFNET(sc);
7934
7935         if (re_link_ok(sc)) {
7936                 link_state = LINK_STATE_UP;
7937         } else {
7938                 link_state = LINK_STATE_DOWN;
7939         }
7940
7941         if (link_state != sc->link_state) {
7942                 sc->link_state = link_state;
7943                 if (link_state == LINK_STATE_UP) {
7944                         re_link_on_patch(sc);
7945                         re_link_state_change(ifp, LINK_STATE_UP);
7946                 } else {
7947                         re_link_state_change(ifp, LINK_STATE_DOWN);
7948                         re_link_down_patch(sc);
7949                 }
7950         }
7951 }
7952
7953 static void re_init_timer(struct re_softc *sc)
7954 {
7955 #ifdef RE_USE_NEW_CALLOUT_FUN
7956         callout_init(&sc->re_stat_ch, CALLOUT_MPSAFE);
7957 #else
7958         callout_handle_init(&sc->re_stat_ch);
7959 #endif
7960 }
7961
7962 static void re_stop_timer(struct re_softc *sc)
7963 {
7964 #ifdef RE_USE_NEW_CALLOUT_FUN
7965         callout_stop(&sc->re_stat_ch);
7966 #else
7967         untimeout(re_tick, sc, sc->re_stat_ch);
7968 #endif
7969 }
7970
7971 static void re_start_timer(struct re_softc *sc)
7972 {
7973 #ifdef RE_USE_NEW_CALLOUT_FUN
7974         callout_reset(&sc->re_stat_ch, hz, re_tick, sc);
7975 #else
7976         re_stop_timer(sc);
7977         sc->re_stat_ch = timeout(re_tick, sc, hz);
7978 #endif
7979 }
7980
7981 static void re_tick(xsc)
7982 void                    *xsc;
7983 {
7984         /*called per second*/
7985         struct re_softc         *sc;
7986         int                     s;
7987
7988         s = splimp();
7989
7990         sc = xsc;
7991         /*mii = device_get_softc(sc->re_miibus);
7992
7993         mii_tick(mii);*/
7994
7995         splx(s);
7996
7997         RE_LOCK(sc);
7998
7999         if (sc->re_link_chg_det == 1) {
8000                 re_check_link_status(sc);
8001                 re_start_timer(sc);
8002         }
8003
8004         RE_UNLOCK(sc);
8005
8006         return;
8007 }
8008
8009 #if OS_VER < VERSION(7,0)
8010 static void re_watchdog(ifp)
8011 struct ifnet            *ifp;
8012 {
8013         struct re_softc         *sc;
8014
8015         sc = ifp->if_softc;
8016
8017         printf("re%d: watchdog timeout\n", sc->re_unit);
8018 #if OS_VER < VERSION(11,0)
8019         ifp->if_oerrors++;
8020 #else
8021         if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
8022 #endif
8023
8024         re_txeof(sc);
8025         re_rxeof(sc);
8026         re_init(sc);
8027
8028         return;
8029 }
8030 #endif
8031 #endif  /* !__DragonFly__ */
8032
8033 /*
8034  * Set media options.
8035  */
8036 static int re_ifmedia_upd(struct ifnet *ifp)
8037 {
8038         struct re_softc *sc = ifp->if_softc;
8039         struct ifmedia  *ifm = &sc->media;
8040         int anar;
8041         int gbcr;
8042
8043         if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER)
8044                 return(EINVAL);
8045
8046         if (sc->re_type == MACFG_68 || sc->re_type == MACFG_69 ||
8047             sc->re_type == MACFG_70 || sc->re_type == MACFG_71) {
8048                 //Disable Giga Lite
8049                 MP_WritePhyUshort(sc, 0x1F, 0x0A42);
8050                 ClearEthPhyBit(sc, 0x14, BIT_9);
8051                 MP_WritePhyUshort(sc, 0x1F, 0x0A40);
8052                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8053         }
8054
8055
8056         switch (IFM_SUBTYPE(ifm->ifm_media)) {
8057         case IFM_AUTO:
8058                 anar = ANAR_TX_FD |
8059                        ANAR_TX |
8060                        ANAR_10_FD |
8061                        ANAR_10;
8062                 gbcr = GTCR_ADV_1000TFDX |
8063                        GTCR_ADV_1000THDX;
8064                 break;
8065         case IFM_1000_SX:
8066 #ifndef __DragonFly__
8067 #if OS_VER < 500000
8068         case IFM_1000_TX:
8069 #else
8070         case IFM_1000_T:
8071 #endif
8072 #else   /* __DragonFly__ */
8073         case IFM_1000_T:
8074 #endif  /* !__DragonFly__ */
8075                 anar = ANAR_TX_FD |
8076                        ANAR_TX |
8077                        ANAR_10_FD |
8078                        ANAR_10;
8079                 gbcr = GTCR_ADV_1000TFDX |
8080                        GTCR_ADV_1000THDX;
8081                 break;
8082         case IFM_100_TX:
8083                 gbcr = MP_ReadPhyUshort(sc, MII_100T2CR) &
8084                        ~(GTCR_ADV_1000TFDX | GTCR_ADV_1000THDX);
8085                 if ((ifm->ifm_media & IFM_GMASK) == IFM_FDX) {
8086                         anar = ANAR_TX_FD |
8087                                ANAR_TX |
8088                                ANAR_10_FD |
8089                                ANAR_10;
8090                 } else {
8091                         anar = ANAR_TX |
8092                                ANAR_10_FD |
8093                                ANAR_10;
8094                 }
8095                 break;
8096         case IFM_10_T:
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_10_FD |
8101                                ANAR_10;
8102                 } else {
8103                         anar = ANAR_10;
8104                 }
8105
8106                 if (sc->re_type == MACFG_13) {
8107                         MP_WritePhyUshort(sc, MII_BMCR, 0x8000);
8108                 }
8109
8110                 break;
8111         default:
8112 #ifndef __DragonFly__
8113                 printf("re%d: Unsupported media type\n", sc->re_unit);
8114                 return(0);
8115 #else
8116                 if_printf(ifp, "Unsupported media type\n");
8117                 return (EOPNOTSUPP);
8118 #endif
8119         }
8120
8121         MP_WritePhyUshort(sc, 0x1F, 0x0000);
8122         if (sc->re_device_id==RT_DEVICEID_8169 || sc->re_device_id==RT_DEVICEID_8169SC ||
8123             sc->re_device_id==RT_DEVICEID_8168 || sc->re_device_id==RT_DEVICEID_8161) {
8124                 MP_WritePhyUshort(sc, MII_ANAR, anar | 0x0800 | ANAR_FC);
8125                 MP_WritePhyUshort(sc, MII_100T2CR, gbcr);
8126                 MP_WritePhyUshort(sc, MII_BMCR, BMCR_RESET | BMCR_AUTOEN | BMCR_STARTNEG);
8127         } else if (sc->re_type == MACFG_36) {
8128                 MP_WritePhyUshort(sc, MII_ANAR, anar | 0x0800 | ANAR_FC);
8129                 MP_WritePhyUshort(sc, MII_BMCR, BMCR_RESET | BMCR_AUTOEN | BMCR_STARTNEG);
8130         } else {
8131                 MP_WritePhyUshort(sc, MII_ANAR, anar | 1);
8132                 MP_WritePhyUshort(sc, MII_BMCR, BMCR_AUTOEN | BMCR_STARTNEG);
8133         }
8134
8135         return(0);
8136 }
8137
8138 /*
8139  * Report current media status.
8140  */
8141 static void re_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr)
8142 {
8143         struct re_softc         *sc;
8144
8145         sc = ifp->if_softc;
8146
8147         RE_LOCK(sc);
8148
8149         ifmr->ifm_status = IFM_AVALID;
8150         ifmr->ifm_active = IFM_ETHER;
8151
8152         if (re_link_ok(sc)) {
8153                 unsigned char msr;
8154
8155                 ifmr->ifm_status |= IFM_ACTIVE;
8156
8157                 msr = CSR_READ_1(sc, RE_PHY_STATUS);
8158                 if (msr & RL_PHY_STATUS_FULL_DUP)
8159                         ifmr->ifm_active |= IFM_FDX;
8160                 else
8161                         ifmr->ifm_active |= IFM_HDX;
8162
8163                 if (msr & RL_PHY_STATUS_10M)
8164                         ifmr->ifm_active |= IFM_10_T;
8165                 else if (msr & RL_PHY_STATUS_100M)
8166                         ifmr->ifm_active |= IFM_100_TX;
8167                 else if (msr & RL_PHY_STATUS_1000MF)
8168                         ifmr->ifm_active |= IFM_1000_T;
8169 #ifdef __DragonFly__
8170         } else {
8171                 if (IFM_SUBTYPE(sc->media.ifm_media) == IFM_AUTO)
8172                         ifmr->ifm_active |= IFM_NONE;
8173                 else
8174                         ifmr->ifm_active |= sc->media.ifm_media;
8175 #endif
8176         }
8177
8178         RE_UNLOCK(sc);
8179
8180         return;
8181 }
8182
8183 static int re_enable_EEE(struct re_softc *sc)
8184 {
8185         int ret;
8186         u_int16_t data;
8187         u_int16_t PhyRegValue;
8188         u_int32_t WaitCnt;
8189
8190         ret = 0;
8191         switch (sc->re_type) {
8192         case MACFG_42:
8193         case MACFG_43:
8194                 re_eri_write(sc, 0x1B0, 2, 0xED03, ERIAR_ExGMAC);
8195                 MP_WritePhyUshort(sc, 0x1F, 0x0004);
8196                 if (CSR_READ_1(sc, 0xEF) & 0x02) {
8197                         MP_WritePhyUshort(sc, 0x10, 0x731F);
8198                         MP_WritePhyUshort(sc, 0x19, 0x7630);
8199                 } else {
8200                         MP_WritePhyUshort(sc, 0x10, 0x711F);
8201                         MP_WritePhyUshort(sc, 0x19, 0x7030);
8202                 }
8203                 MP_WritePhyUshort(sc, 0x1A, 0x1506);
8204                 MP_WritePhyUshort(sc, 0x1B, 0x0551);
8205                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8206                 MP_WritePhyUshort(sc, 0x0D, 0x0007);
8207                 MP_WritePhyUshort(sc, 0x0E, 0x003C);
8208                 MP_WritePhyUshort(sc, 0x0D, 0x4007);
8209                 MP_WritePhyUshort(sc, 0x0E, 0x0002);
8210                 MP_WritePhyUshort(sc, 0x0D, 0x0000);
8211
8212                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8213                 MP_WritePhyUshort(sc, 0x0D, 0x0003);
8214                 MP_WritePhyUshort(sc, 0x0E, 0x0015);
8215                 MP_WritePhyUshort(sc, 0x0D, 0x4003);
8216                 MP_WritePhyUshort(sc, 0x0E, 0x0002);
8217                 MP_WritePhyUshort(sc, 0x0D, 0x0000);
8218
8219                 MP_WritePhyUshort(sc, MII_BMCR, BMCR_AUTOEN | BMCR_STARTNEG);
8220                 break;
8221
8222         case MACFG_53:
8223         case MACFG_54:
8224         case MACFG_55:
8225                 re_eri_write(sc, 0x1B0, 2, 0xED03, ERIAR_ExGMAC);
8226                 MP_WritePhyUshort(sc, 0x1F, 0x0004);
8227                 MP_WritePhyUshort(sc, 0x10, 0x731F);
8228                 MP_WritePhyUshort(sc, 0x19, 0x7630);
8229                 MP_WritePhyUshort(sc, 0x1A, 0x1506);
8230                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8231                 MP_WritePhyUshort(sc, 0x0D, 0x0007);
8232                 MP_WritePhyUshort(sc, 0x0E, 0x003C);
8233                 MP_WritePhyUshort(sc, 0x0D, 0x4007);
8234                 MP_WritePhyUshort(sc, 0x0E, 0x0002);
8235                 MP_WritePhyUshort(sc, 0x0D, 0x0000);
8236
8237                 MP_WritePhyUshort(sc, MII_BMCR, BMCR_AUTOEN | BMCR_STARTNEG);
8238                 break;
8239
8240         case MACFG_36:
8241         case MACFG_37:
8242                 MP_WritePhyUshort(sc, 0x1F, 0x0007);
8243                 MP_WritePhyUshort(sc, 0x1E, 0x0020);
8244                 data = MP_ReadPhyUshort(sc, 0x15) | 0x0100;
8245                 MP_WritePhyUshort(sc, 0x15, data);
8246                 MP_WritePhyUshort(sc, 0x1F, 0x0006);
8247                 MP_WritePhyUshort(sc, 0x00, 0x5A30);
8248                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8249                 MP_WritePhyUshort(sc, 0x0D, 0x0007);
8250                 MP_WritePhyUshort(sc, 0x0E, 0x003C);
8251                 MP_WritePhyUshort(sc, 0x0D, 0x4007);
8252                 MP_WritePhyUshort(sc, 0x0E, 0x0006);
8253                 MP_WritePhyUshort(sc, 0x0D, 0x0000);
8254                 if ((CSR_READ_1(sc, RE_CFG4)&RL_CFG4_CUSTOMIZED_LED) && (CSR_READ_1(sc, RE_MACDBG) & BIT_7)) {
8255                         MP_WritePhyUshort(sc, 0x1F, 0x0005);
8256                         MP_WritePhyUshort(sc, 0x05, 0x8AC8);
8257                         MP_WritePhyUshort(sc, 0x06, CSR_READ_1(sc, RE_CUSTOM_LED));
8258                         MP_WritePhyUshort(sc, 0x05, 0x8B82);
8259                         data = MP_ReadPhyUshort(sc, 0x06) | 0x0010;
8260                         MP_WritePhyUshort(sc, 0x05, 0x8B82);
8261                         MP_WritePhyUshort(sc, 0x06, data);
8262                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
8263                 }
8264                 break;
8265
8266         case MACFG_50:
8267         case MACFG_51:
8268         case MACFG_52:
8269                 data = re_eri_read(sc, 0x1B0, 4, ERIAR_ExGMAC) | 0x0003;
8270                 re_eri_write(sc, 0x1B0, 4, data, ERIAR_ExGMAC);
8271                 MP_WritePhyUshort(sc, 0x1F, 0x0007);
8272                 MP_WritePhyUshort(sc, 0x1E, 0x0020);
8273                 data = MP_ReadPhyUshort(sc, 0x15)|0x0100;
8274                 MP_WritePhyUshort(sc, 0x15, data);
8275                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
8276                 MP_WritePhyUshort(sc, 0x05, 0x8B85);
8277                 data = MP_ReadPhyUshort(sc, 0x06)|0x2000;
8278                 MP_WritePhyUshort(sc, 0x06, data);
8279                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8280                 MP_WritePhyUshort(sc, 0x0D, 0x0007);
8281                 MP_WritePhyUshort(sc, 0x0E, 0x003C);
8282                 MP_WritePhyUshort(sc, 0x0D, 0x4007);
8283                 MP_WritePhyUshort(sc, 0x0E, 0x0006);
8284                 MP_WritePhyUshort(sc, 0x1D, 0x0000);
8285                 break;
8286
8287         case MACFG_38:
8288         case MACFG_39:
8289                 data = re_eri_read(sc, 0x1B0, 4, ERIAR_ExGMAC);
8290                 data |= BIT_1 | BIT_0;
8291                 re_eri_write(sc, 0x1B0, 4, data, ERIAR_ExGMAC);
8292                 MP_WritePhyUshort(sc, 0x1F, 0x0004);
8293                 MP_WritePhyUshort(sc, 0x1F, 0x0007);
8294                 MP_WritePhyUshort(sc, 0x1e, 0x0020);
8295                 data = MP_ReadPhyUshort(sc, 0x15);
8296                 data |= BIT_8;
8297                 MP_WritePhyUshort(sc, 0x15, data);
8298                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
8299                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
8300                 MP_WritePhyUshort(sc, 0x05, 0x8B85);
8301                 data = MP_ReadPhyUshort(sc, 0x06);
8302                 data |= BIT_13;
8303                 MP_WritePhyUshort(sc, 0x06, data);
8304                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8305                 MP_WritePhyUshort(sc, 0x0D, 0x0007);
8306                 MP_WritePhyUshort(sc, 0x0E, 0x003C);
8307                 MP_WritePhyUshort(sc, 0x0D, 0x4007);
8308                 MP_WritePhyUshort(sc, 0x0E, 0x0006);
8309                 MP_WritePhyUshort(sc, 0x0D, 0x0000);
8310                 break;
8311
8312         case MACFG_56:
8313         case MACFG_57:
8314         case MACFG_58:
8315         case MACFG_59:
8316         case MACFG_60:
8317         case MACFG_61:
8318         case MACFG_62:
8319         case MACFG_67:
8320         case MACFG_68:
8321         case MACFG_69:
8322         case MACFG_70:
8323         case MACFG_71:
8324                 data = re_eri_read(sc, 0x1B0, 4, ERIAR_ExGMAC);
8325                 data |= BIT_1 | BIT_0;
8326                 re_eri_write(sc, 0x1B0, 4, data, ERIAR_ExGMAC);
8327                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
8328                 data = MP_ReadPhyUshort(sc, 0x11);
8329                 MP_WritePhyUshort(sc, 0x11, data | BIT_4);
8330                 MP_WritePhyUshort(sc, 0x1F, 0x0A5D);
8331                 MP_WritePhyUshort(sc, 0x10, 0x0006);
8332                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8333                 break;
8334
8335         default:
8336                 ret = -EOPNOTSUPP;
8337                 break;
8338         }
8339
8340         switch (sc->re_type) {
8341         case MACFG_68:
8342         case MACFG_69:
8343                 MP_WritePhyUshort(sc, 0x1F, 0x0A4A);
8344                 SetEthPhyBit(sc, 0x11, BIT_9);
8345                 MP_WritePhyUshort(sc, 0x1F, 0x0A42);
8346                 SetEthPhyBit(sc, 0x14, BIT_7);
8347                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8348                 break;
8349         }
8350
8351         /*Advanced EEE*/
8352         switch (sc->re_type) {
8353         case MACFG_58:
8354         case MACFG_59:
8355         case MACFG_60:
8356         case MACFG_68:
8357         case MACFG_69:
8358                 MP_WritePhyUshort(sc, 0x1F, 0x0B82);
8359                 SetEthPhyBit(sc, 0x10, BIT_4);
8360                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8361
8362                 MP_WritePhyUshort(sc, 0x1F, 0x0B80);
8363                 WaitCnt = 0;
8364                 do {
8365                         PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
8366                         PhyRegValue &= 0x0040;
8367                         DELAY(50);
8368                         DELAY(50);
8369                         WaitCnt++;
8370                 } while(PhyRegValue != 0x0040 && WaitCnt <1000);
8371
8372                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8373                 break;
8374         }
8375
8376         switch (sc->re_type) {
8377         case MACFG_59:
8378                 re_eri_write(sc, 0x1EA, 1, 0xFA, ERIAR_ExGMAC);
8379
8380                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
8381                 data = MP_ReadPhyUshort(sc, 0x10);
8382                 if (data & BIT_10) {
8383                         MP_WritePhyUshort(sc, 0x1F, 0x0A42);
8384                         data = MP_ReadPhyUshort(sc, 0x16);
8385                         data &= ~(BIT_1);
8386                         MP_WritePhyUshort(sc, 0x16, data);
8387                 } else {
8388                         MP_WritePhyUshort(sc, 0x1F, 0x0A42);
8389                         data = MP_ReadPhyUshort(sc, 0x16);
8390                         data |= BIT_1;
8391                         MP_WritePhyUshort(sc, 0x16, data);
8392                 }
8393                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8394                 break;
8395         case MACFG_60:
8396                 data = MP_ReadMcuAccessRegWord(sc, 0xE052);
8397                 data |= BIT_0;
8398                 MP_WriteMcuAccessRegWord(sc, 0xE052, data);
8399                 data = MP_ReadMcuAccessRegWord(sc, 0xE056);
8400                 data &= 0xFF0F;
8401                 data |= (BIT_4 | BIT_5 | BIT_6);
8402                 MP_WriteMcuAccessRegWord(sc, 0xE056, data);
8403
8404                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
8405                 data = MP_ReadPhyUshort(sc, 0x10);
8406                 if (data & BIT_10) {
8407                         MP_WritePhyUshort(sc, 0x1F, 0x0A42);
8408                         data = MP_ReadPhyUshort(sc, 0x16);
8409                         data &= ~(BIT_1);
8410                         MP_WritePhyUshort(sc, 0x16, data);
8411                 } else {
8412                         MP_WritePhyUshort(sc, 0x1F, 0x0A42);
8413                         data = MP_ReadPhyUshort(sc, 0x16);
8414                         data |= BIT_1;
8415                         MP_WritePhyUshort(sc, 0x16, data);
8416                 }
8417                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8418                 break;
8419         case MACFG_61:
8420         case MACFG_62:
8421         case MACFG_67:
8422                 OOB_mutex_lock(sc);
8423                 data = MP_ReadMcuAccessRegWord(sc, 0xE052);
8424                 data &= ~BIT_0;
8425                 MP_WriteMcuAccessRegWord(sc, 0xE052, data);
8426                 OOB_mutex_unlock(sc);
8427                 data = MP_ReadMcuAccessRegWord(sc, 0xE056);
8428                 data &= 0xFF0F;
8429                 data |= (BIT_4 | BIT_5 | BIT_6);
8430                 MP_WriteMcuAccessRegWord(sc, 0xE056, data);
8431                 break;
8432         case MACFG_70:
8433         case MACFG_71:
8434                 OOB_mutex_lock(sc);
8435                 data = MP_ReadMcuAccessRegWord(sc, 0xE052);
8436                 data &= ~BIT_0;
8437                 MP_WriteMcuAccessRegWord(sc, 0xE052, data);
8438                 OOB_mutex_unlock(sc);
8439                 data = MP_ReadMcuAccessRegWord(sc, 0xE056);
8440                 data &= 0xFF0F;
8441                 data |= (BIT_4 | BIT_5 | BIT_6);
8442                 MP_WriteMcuAccessRegWord(sc, 0xE056, data);
8443                 MP_WriteMcuAccessRegWord(sc, 0xEA80, 0x0003);
8444                 break;
8445         case MACFG_68:
8446         case MACFG_69:
8447                 data = MP_ReadMcuAccessRegWord(sc, 0xE052);
8448                 data |= BIT_0;
8449                 MP_WriteMcuAccessRegWord(sc, 0xE052, data);
8450
8451                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
8452                 data = MP_ReadPhyUshort(sc, 0x10) | BIT_15;
8453                 MP_WritePhyUshort(sc, 0x10, data);
8454
8455                 MP_WritePhyUshort(sc, 0x1F, 0x0A44);
8456                 data = MP_ReadPhyUshort(sc, 0x11) | BIT_13 | BIT_14;
8457                 data &= ~(BIT_12);
8458                 MP_WritePhyUshort(sc, 0x11, data);
8459                 break;
8460         }
8461
8462         switch (sc->re_type) {
8463         case MACFG_58:
8464         case MACFG_59:
8465         case MACFG_60:
8466         case MACFG_68:
8467         case MACFG_69:
8468                 MP_WritePhyUshort(sc, 0x1F, 0x0B82);
8469                 ClearEthPhyBit(sc, 0x10, BIT_4);
8470                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8471                 break;
8472         }
8473
8474         return ret;
8475 }
8476
8477 static int re_disable_EEE(struct re_softc *sc)
8478 {
8479         int ret;
8480         u_int16_t data;
8481         u_int16_t PhyRegValue;
8482         u_int32_t WaitCnt;
8483
8484         ret = 0;
8485         switch (sc->re_type) {
8486         case MACFG_42:
8487         case MACFG_43:
8488                 re_eri_write(sc, 0x1B0, 2, 0, ERIAR_ExGMAC);
8489                 MP_WritePhyUshort(sc, 0x1F, 0x0004);
8490                 MP_WritePhyUshort(sc, 0x10, 0x401F);
8491                 MP_WritePhyUshort(sc, 0x19, 0x7030);
8492
8493                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8494                 MP_WritePhyUshort(sc, 0x0D, 0x0007);
8495                 MP_WritePhyUshort(sc, 0x0E, 0x003C);
8496                 MP_WritePhyUshort(sc, 0x0D, 0x4007);
8497                 MP_WritePhyUshort(sc, 0x0E, 0x0000);
8498                 MP_WritePhyUshort(sc, 0x0D, 0x0000);
8499
8500                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8501                 MP_WritePhyUshort(sc, 0x0D, 0x0003);
8502                 MP_WritePhyUshort(sc, 0x0E, 0x0015);
8503                 MP_WritePhyUshort(sc, 0x0D, 0x4003);
8504                 MP_WritePhyUshort(sc, 0x0E, 0x0000);
8505                 MP_WritePhyUshort(sc, 0x0D, 0x0000);
8506
8507                 MP_WritePhyUshort(sc, MII_BMCR, BMCR_AUTOEN | BMCR_STARTNEG);
8508                 break;
8509
8510         case MACFG_53:
8511                 re_eri_write(sc, 0x1B0, 2, 0, ERIAR_ExGMAC);
8512                 MP_WritePhyUshort(sc, 0x1F, 0x0004);
8513                 MP_WritePhyUshort(sc, 0x10, 0x401F);
8514                 MP_WritePhyUshort(sc, 0x19, 0x7030);
8515
8516                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8517                 MP_WritePhyUshort(sc, 0x0D, 0x0007);
8518                 MP_WritePhyUshort(sc, 0x0E, 0x003C);
8519                 MP_WritePhyUshort(sc, 0x0D, 0x4007);
8520                 MP_WritePhyUshort(sc, 0x0E, 0x0000);
8521                 MP_WritePhyUshort(sc, 0x0D, 0x0000);
8522
8523                 MP_WritePhyUshort(sc, MII_BMCR, BMCR_AUTOEN | BMCR_STARTNEG);
8524                 break;
8525
8526         case MACFG_54:
8527         case MACFG_55:
8528                 re_eri_write(sc, 0x1B0, 2, 0, ERIAR_ExGMAC);
8529                 MP_WritePhyUshort(sc, 0x1F, 0x0004);
8530                 MP_WritePhyUshort(sc, 0x10, 0xC07F);
8531                 MP_WritePhyUshort(sc, 0x19, 0x7030);
8532                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8533
8534                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8535                 MP_WritePhyUshort(sc, 0x0D, 0x0007);
8536                 MP_WritePhyUshort(sc, 0x0E, 0x003C);
8537                 MP_WritePhyUshort(sc, 0x0D, 0x4007);
8538                 MP_WritePhyUshort(sc, 0x0E, 0x0000);
8539                 MP_WritePhyUshort(sc, 0x0D, 0x0000);
8540
8541                 MP_WritePhyUshort(sc, MII_BMCR, BMCR_AUTOEN | BMCR_STARTNEG);
8542                 break;
8543
8544         case MACFG_36:
8545         case MACFG_37:
8546                 MP_WritePhyUshort(sc, 0x1F, 0x0007);
8547                 MP_WritePhyUshort(sc, 0x1E, 0x0020);
8548                 data = MP_ReadPhyUshort(sc, 0x15) & ~0x0100;
8549                 MP_WritePhyUshort(sc, 0x15, data);
8550                 MP_WritePhyUshort(sc, 0x1F, 0x0006);
8551                 MP_WritePhyUshort(sc, 0x00, 0x5A00);
8552                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8553                 MP_WritePhyUshort(sc, 0x0D, 0x0007);
8554                 MP_WritePhyUshort(sc, 0x0E, 0x003C);
8555                 MP_WritePhyUshort(sc, 0x0D, 0x4007);
8556                 MP_WritePhyUshort(sc, 0x0E, 0x0000);
8557                 MP_WritePhyUshort(sc, 0x0D, 0x0000);
8558                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8559                 if (CSR_READ_1(sc, RE_CFG4) & RL_CFG4_CUSTOMIZED_LED) {
8560                         MP_WritePhyUshort(sc, 0x1F, 0x0005);
8561                         MP_WritePhyUshort(sc, 0x05, 0x8B82);
8562                         data = MP_ReadPhyUshort(sc, 0x06) & ~0x0010;
8563                         MP_WritePhyUshort(sc, 0x05, 0x8B82);
8564                         MP_WritePhyUshort(sc, 0x06, data);
8565                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
8566                 }
8567                 break;
8568
8569         case MACFG_50:
8570         case MACFG_51:
8571         case MACFG_52:
8572                 data = re_eri_read(sc, 0x1B0, 4, ERIAR_ExGMAC)& ~0x0003;
8573                 re_eri_write(sc, 0x1B0, 4, data, ERIAR_ExGMAC);
8574                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
8575                 MP_WritePhyUshort(sc, 0x05, 0x8B85);
8576                 data = MP_ReadPhyUshort(sc, 0x06) & ~0x2000;
8577                 MP_WritePhyUshort(sc, 0x06, data);
8578                 MP_WritePhyUshort(sc, 0x1F, 0x0007);
8579                 MP_WritePhyUshort(sc, 0x1E, 0x0020);
8580                 data = MP_ReadPhyUshort(sc, 0x15) & ~0x0100;
8581                 MP_WritePhyUshort(sc, 0x15, data);
8582                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8583                 MP_WritePhyUshort(sc, 0x0D, 0x0007);
8584                 MP_WritePhyUshort(sc, 0x0E, 0x003C);
8585                 MP_WritePhyUshort(sc, 0x0D, 0x4007);
8586                 MP_WritePhyUshort(sc, 0x0E, 0x0000);
8587                 MP_WritePhyUshort(sc, 0x0D, 0x0000);
8588                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8589                 break;
8590
8591         case MACFG_38:
8592         case MACFG_39:
8593                 data = re_eri_read(sc, 0x1B0, 4, ERIAR_ExGMAC);
8594                 data &= ~(BIT_1 | BIT_0);
8595                 re_eri_write(sc, 0x1B0, 4, data, ERIAR_ExGMAC);
8596                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
8597                 MP_WritePhyUshort(sc, 0x05, 0x8B85);
8598                 data = MP_ReadPhyUshort(sc, 0x06);
8599                 data &= ~BIT_13;
8600                 MP_WritePhyUshort(sc, 0x06, data);
8601                 MP_WritePhyUshort(sc, 0x1F, 0x0004);
8602                 MP_WritePhyUshort(sc, 0x1F, 0x0007);
8603                 MP_WritePhyUshort(sc, 0x1e, 0x0020);
8604                 data = MP_ReadPhyUshort(sc, 0x15);
8605                 data &= ~BIT_8;
8606                 MP_WritePhyUshort(sc, 0x15, data);
8607                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
8608                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8609                 MP_WritePhyUshort(sc, 0x0D, 0x0007);
8610                 MP_WritePhyUshort(sc, 0x0E, 0x003C);
8611                 MP_WritePhyUshort(sc, 0x0D, 0x4007);
8612                 MP_WritePhyUshort(sc, 0x0E, 0x0000);
8613                 MP_WritePhyUshort(sc, 0x0D, 0x0000);
8614                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8615                 break;
8616
8617         case MACFG_56:
8618         case MACFG_57:
8619         case MACFG_58:
8620         case MACFG_59:
8621         case MACFG_60:
8622         case MACFG_61:
8623         case MACFG_62:
8624         case MACFG_67:
8625         case MACFG_68:
8626         case MACFG_69:
8627         case MACFG_70:
8628         case MACFG_71:
8629                 data = re_eri_read(sc, 0x1B0, 4, ERIAR_ExGMAC);
8630                 data &= ~(BIT_1 | BIT_0);
8631                 re_eri_write(sc, 0x1B0, 4, data, ERIAR_ExGMAC);
8632                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
8633                 data = MP_ReadPhyUshort(sc, 0x11);
8634                 MP_WritePhyUshort(sc, 0x11, data & ~BIT_4);
8635                 MP_WritePhyUshort(sc, 0x1F, 0x0A5D);
8636                 MP_WritePhyUshort(sc, 0x10, 0x0000);
8637                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8638                 break;
8639
8640         default:
8641                 ret = -EOPNOTSUPP;
8642                 break;
8643         }
8644
8645         switch (sc->re_type) {
8646         case MACFG_68:
8647         case MACFG_69:
8648                 MP_WritePhyUshort(sc, 0x1F, 0x0A42);
8649                 ClearEthPhyBit(sc, 0x14, BIT_7);
8650                 MP_WritePhyUshort(sc, 0x1F, 0x0A4A);
8651                 ClearEthPhyBit(sc, 0x11, BIT_9);
8652                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8653                 break;
8654         }
8655
8656         /*Advanced EEE*/
8657         switch (sc->re_type) {
8658         case MACFG_58:
8659         case MACFG_59:
8660         case MACFG_60:
8661         case MACFG_68:
8662         case MACFG_69:
8663                 MP_WritePhyUshort(sc, 0x1F, 0x0B82);
8664                 SetEthPhyBit(sc, 0x10, BIT_4);
8665                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8666
8667                 MP_WritePhyUshort(sc, 0x1F, 0x0B80);
8668                 WaitCnt = 0;
8669                 do {
8670                         PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
8671                         PhyRegValue &= 0x0040;
8672                         DELAY(50);
8673                         DELAY(50);
8674                         WaitCnt++;
8675                 } while(PhyRegValue != 0x0040 && WaitCnt <1000);
8676
8677                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8678                 break;
8679         }
8680
8681         switch (sc->re_type) {
8682         case MACFG_59:
8683                 re_eri_write(sc, 0x1EA, 1, 0x00, ERIAR_ExGMAC);
8684
8685                 MP_WritePhyUshort(sc, 0x1F, 0x0A42);
8686                 data = MP_ReadPhyUshort(sc, 0x16);
8687                 data &= ~(BIT_1);
8688                 MP_WritePhyUshort(sc, 0x16, data);
8689                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8690                 break;
8691         case MACFG_60:
8692                 data = MP_ReadMcuAccessRegWord(sc, 0xE052);
8693                 data &= ~(BIT_0);
8694                 MP_WriteMcuAccessRegWord(sc, 0xE052, data);
8695
8696                 MP_WritePhyUshort(sc, 0x1F, 0x0A42);
8697                 data = MP_ReadPhyUshort(sc, 0x16);
8698                 data &= ~(BIT_1);
8699                 MP_WritePhyUshort(sc, 0x16, data);
8700                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8701                 break;
8702         case MACFG_61:
8703         case MACFG_62:
8704         case MACFG_67:
8705         case MACFG_70:
8706         case MACFG_71:
8707                 data = MP_ReadMcuAccessRegWord(sc, 0xE052);
8708                 data &= ~(BIT_0);
8709                 MP_WriteMcuAccessRegWord(sc, 0xE052, data);
8710                 break;
8711         case MACFG_68:
8712         case MACFG_69:
8713                 data = MP_ReadMcuAccessRegWord(sc, 0xE052);
8714                 data &= ~(BIT_0);
8715                 MP_WriteMcuAccessRegWord(sc, 0xE052, data);
8716
8717                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
8718                 data = MP_ReadPhyUshort(sc, 0x10) & ~(BIT_15);
8719                 MP_WritePhyUshort(sc, 0x10, data);
8720
8721                 MP_WritePhyUshort(sc, 0x1F, 0x0A44);
8722                 data = MP_ReadPhyUshort(sc, 0x11) & ~(BIT_12 | BIT_13 | BIT_14);
8723                 MP_WritePhyUshort(sc, 0x11, data);
8724                 break;
8725         }
8726
8727         switch (sc->re_type) {
8728         case MACFG_58:
8729         case MACFG_59:
8730         case MACFG_60:
8731         case MACFG_68:
8732         case MACFG_69:
8733                 MP_WritePhyUshort(sc, 0x1F, 0x0B82);
8734                 ClearEthPhyBit(sc, 0x10, BIT_4);
8735                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8736                 break;
8737         }
8738
8739         return ret;
8740 }
8741
8742 static int re_phy_ram_code_check(struct re_softc *sc)
8743 {
8744         u_int16_t PhyRegValue;
8745         u_int32_t WaitCnt;
8746         int retval = TRUE;
8747
8748         switch(sc->re_type) {
8749         case MACFG_56:
8750                 MP_WritePhyUshort(sc, 0x1f, 0x0A40);
8751                 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
8752                 PhyRegValue &= ~(BIT_11);
8753                 MP_WritePhyUshort(sc, 0x10, PhyRegValue);
8754
8755
8756                 MP_WritePhyUshort(sc, 0x1f, 0x0A00);
8757                 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
8758                 PhyRegValue &= ~(BIT_12 | BIT_13 | BIT_14 | BIT_15);
8759                 MP_WritePhyUshort(sc, 0x10, PhyRegValue);
8760
8761                 MP_WritePhyUshort(sc, 0x1f, 0x0A43);
8762                 MP_WritePhyUshort(sc, 0x13, 0x8010);
8763                 PhyRegValue = MP_ReadPhyUshort(sc, 0x14);
8764                 PhyRegValue &= ~(BIT_11);
8765                 MP_WritePhyUshort(sc, 0x14, PhyRegValue);
8766
8767                 MP_WritePhyUshort(sc, 0x1f, 0x0B82);
8768                 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
8769                 PhyRegValue |= BIT_4;
8770                 MP_WritePhyUshort(sc, 0x10, PhyRegValue);
8771
8772                 MP_WritePhyUshort(sc, 0x1f, 0x0B80);
8773                 WaitCnt = 0;
8774                 do {
8775                         PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
8776                         PhyRegValue &= 0x0040;
8777                         DELAY(50);
8778                         DELAY(50);
8779                         WaitCnt++;
8780                 } while(PhyRegValue != 0x0040 && WaitCnt <1000);
8781
8782                 if (WaitCnt == 1000) {
8783                         retval = FALSE;
8784                 }
8785
8786                 MP_WritePhyUshort(sc, 0x1f, 0x0A40);
8787                 MP_WritePhyUshort(sc, 0x10, 0x0140);
8788
8789                 MP_WritePhyUshort(sc, 0x1f, 0x0A4A);
8790                 PhyRegValue = MP_ReadPhyUshort(sc, 0x13);
8791                 PhyRegValue &= ~(BIT_6);
8792                 PhyRegValue |= (BIT_7);
8793                 MP_WritePhyUshort(sc, 0x13, PhyRegValue);
8794
8795                 MP_WritePhyUshort(sc, 0x1f, 0x0A44);
8796                 PhyRegValue = MP_ReadPhyUshort(sc, 0x14);
8797                 PhyRegValue |= (BIT_2);
8798                 MP_WritePhyUshort(sc, 0x14, PhyRegValue);
8799
8800                 MP_WritePhyUshort(sc, 0x1f, 0x0A50);
8801                 PhyRegValue = MP_ReadPhyUshort(sc, 0x11);
8802                 PhyRegValue |= (BIT_11|BIT_12);
8803                 MP_WritePhyUshort(sc, 0x11, PhyRegValue);
8804
8805                 MP_WritePhyUshort(sc, 0x1f, 0x0B82);
8806                 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
8807                 PhyRegValue &= ~(BIT_4);
8808                 MP_WritePhyUshort(sc, 0x10, PhyRegValue);
8809
8810                 MP_WritePhyUshort(sc, 0x1f, 0x0A22);
8811                 WaitCnt = 0;
8812                 do {
8813                         PhyRegValue = MP_ReadPhyUshort(sc, 0x12);
8814                         PhyRegValue &= 0x0010;
8815                         DELAY(50);
8816                         DELAY(50);
8817                         WaitCnt++;
8818                 } while(PhyRegValue != 0x0010 && WaitCnt <1000);
8819
8820                 if (WaitCnt == 1000) {
8821                         retval = FALSE;
8822                 }
8823
8824                 MP_WritePhyUshort(sc, 0x1f, 0x0A40);
8825                 MP_WritePhyUshort(sc, 0x10, 0x1040);
8826
8827                 MP_WritePhyUshort(sc, 0x1f, 0x0A4A);
8828                 PhyRegValue = MP_ReadPhyUshort(sc, 0x13);
8829                 PhyRegValue &= ~(BIT_6|BIT_7);
8830                 MP_WritePhyUshort(sc, 0x13, PhyRegValue);
8831
8832                 MP_WritePhyUshort(sc, 0x1f, 0x0A44);
8833                 PhyRegValue = MP_ReadPhyUshort(sc, 0x14);
8834                 PhyRegValue &= ~(BIT_2);
8835                 MP_WritePhyUshort(sc, 0x14, PhyRegValue);
8836
8837                 MP_WritePhyUshort(sc, 0x1f, 0x0A50);
8838                 PhyRegValue = MP_ReadPhyUshort(sc, 0x11);
8839                 PhyRegValue &= ~(BIT_11|BIT_12);
8840                 MP_WritePhyUshort(sc, 0x11, PhyRegValue);
8841
8842                 MP_WritePhyUshort(sc, 0x1f, 0x0A43);
8843                 MP_WritePhyUshort(sc, 0x13, 0x8010);
8844                 PhyRegValue = MP_ReadPhyUshort(sc, 0x14);
8845                 PhyRegValue |= (BIT_11);
8846                 MP_WritePhyUshort(sc, 0x14, PhyRegValue);
8847
8848                 MP_WritePhyUshort(sc, 0x1f, 0x0B82);
8849                 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
8850                 PhyRegValue |= BIT_4;
8851                 MP_WritePhyUshort(sc, 0x10, PhyRegValue);
8852
8853                 MP_WritePhyUshort(sc, 0x1f, 0x0B80);
8854                 WaitCnt = 0;
8855                 do {
8856                         PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
8857                         PhyRegValue &= 0x0040;
8858                         DELAY(50);
8859                         DELAY(50);
8860                         WaitCnt++;
8861                 } while(PhyRegValue != 0x0040 && WaitCnt <1000);
8862
8863                 if (WaitCnt == 1000) {
8864                         retval = FALSE;
8865                 }
8866
8867                 MP_WritePhyUshort(sc, 0x1f, 0x0A20);
8868                 PhyRegValue = MP_ReadPhyUshort(sc, 0x13);
8869                 if (PhyRegValue & BIT_11) {
8870                         if (PhyRegValue & BIT_10) {
8871                                 retval = FALSE;
8872                         }
8873                 }
8874
8875                 MP_WritePhyUshort(sc, 0x1f, 0x0B82);
8876                 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
8877                 PhyRegValue &= ~(BIT_4);
8878                 MP_WritePhyUshort(sc, 0x10, PhyRegValue);
8879
8880                 //delay 2ms
8881                 DELAY(2000);
8882                 break;
8883         default:
8884                 break;
8885         }
8886
8887         MP_WritePhyUshort(sc, 0x1F, 0x0000);
8888
8889         return retval;
8890 }
8891
8892 static void re_set_phy_ram_code_check_fail_flag(struct re_softc *sc)
8893 {
8894         u_int16_t TmpUshort;
8895
8896         switch(sc->re_type) {
8897         case MACFG_56:
8898                 TmpUshort = MP_ReadMcuAccessRegWord(sc, 0xD3C0);
8899                 TmpUshort |= BIT_0;
8900                 MP_WriteMcuAccessRegWord(sc, 0xD3C0, TmpUshort);
8901                 break;
8902         }
8903 }
8904
8905 static int re_hw_phy_mcu_code_ver_matched(struct re_softc *sc)
8906 {
8907         int ram_code_ver_match = 0;
8908
8909         switch (sc->re_type) {
8910         case MACFG_36:
8911         case MACFG_37:
8912                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
8913                 MP_WritePhyUshort(sc, 0x05, 0x8B60);
8914                 sc->re_hw_ram_code_ver = MP_ReadPhyUshort(sc, 0x06);
8915                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8916                 break;
8917         case MACFG_38:
8918         case MACFG_39:
8919         case MACFG_50:
8920         case MACFG_51:
8921         case MACFG_52:
8922                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
8923                 MP_WritePhyUshort(sc, 0x05, 0x8B30);
8924                 sc->re_hw_ram_code_ver = MP_ReadPhyUshort(sc, 0x06);
8925                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8926                 break;
8927         case MACFG_56:
8928         case MACFG_57:
8929         case MACFG_58:
8930         case MACFG_59:
8931         case MACFG_60:
8932         case MACFG_61:
8933         case MACFG_62:
8934         case MACFG_67:
8935         case MACFG_68:
8936         case MACFG_69:
8937         case MACFG_70:
8938         case MACFG_71:
8939                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
8940                 MP_WritePhyUshort(sc, 0x13, 0x801E);
8941                 sc->re_hw_ram_code_ver = MP_ReadPhyUshort(sc, 0x14);
8942                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8943                 break;
8944         default:
8945                 sc->re_hw_ram_code_ver = ~0;
8946                 break;
8947         }
8948
8949         if (sc->re_hw_ram_code_ver == sc->re_sw_ram_code_ver)
8950                 ram_code_ver_match = 1;
8951
8952         return ram_code_ver_match;
8953 }
8954
8955 static void re_write_hw_phy_mcu_code_ver(struct re_softc *sc)
8956 {
8957         switch (sc->re_type) {
8958         case MACFG_36:
8959         case MACFG_37:
8960                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
8961                 MP_WritePhyUshort(sc, 0x05, 0x8B60);
8962                 MP_WritePhyUshort(sc, 0x06, sc->re_sw_ram_code_ver);
8963                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8964                 sc->re_hw_ram_code_ver = sc->re_sw_ram_code_ver;
8965                 break;
8966         case MACFG_38:
8967         case MACFG_39:
8968         case MACFG_50:
8969         case MACFG_51:
8970         case MACFG_52:
8971                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
8972                 MP_WritePhyUshort(sc, 0x05, 0x8B30);
8973                 MP_WritePhyUshort(sc, 0x06, sc->re_sw_ram_code_ver);
8974                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8975                 sc->re_hw_ram_code_ver = sc->re_sw_ram_code_ver;
8976                 break;
8977         case MACFG_56:
8978         case MACFG_57:
8979         case MACFG_58:
8980         case MACFG_59:
8981         case MACFG_60:
8982         case MACFG_61:
8983         case MACFG_62:
8984         case MACFG_67:
8985         case MACFG_68:
8986         case MACFG_69:
8987         case MACFG_70:
8988         case MACFG_71:
8989                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
8990                 MP_WritePhyUshort(sc, 0x13, 0x801E);
8991                 MP_WritePhyUshort(sc, 0x14, sc->re_sw_ram_code_ver);
8992                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8993                 sc->re_hw_ram_code_ver = sc->re_sw_ram_code_ver;
8994                 break;
8995         }
8996 }
8997
8998 static void re_set_phy_mcu_8168e_1(struct re_softc *sc)
8999 {
9000         u_int16_t PhyRegValue;
9001         int i;
9002
9003         MP_WritePhyUshort(sc, 0x1f, 0x0000);
9004         MP_WritePhyUshort(sc, 0x00, 0x1800);
9005         MP_WritePhyUshort(sc, 0x1f, 0x0007);
9006         MP_WritePhyUshort(sc, 0x1e, 0x0023);
9007         MP_WritePhyUshort(sc, 0x17, 0x0117);
9008         MP_WritePhyUshort(sc, 0x1f, 0x0007);
9009         MP_WritePhyUshort(sc, 0x1E, 0x002C);
9010         MP_WritePhyUshort(sc, 0x1B, 0x5000);
9011         MP_WritePhyUshort(sc, 0x1f, 0x0000);
9012         MP_WritePhyUshort(sc, 0x16, 0x4104);
9013         for (i=0; i<200; i++) {
9014                 DELAY(100);
9015                 PhyRegValue = MP_ReadPhyUshort(sc, 0x1E);
9016                 PhyRegValue &= 0x03FF;
9017                 if (PhyRegValue== 0x000C)
9018                         break;
9019         }
9020         MP_WritePhyUshort(sc, 0x1f, 0x0005);
9021         for (i=0; i<200; i++) {
9022                 DELAY(100);
9023                 PhyRegValue = MP_ReadPhyUshort(sc, 0x07);
9024                 if ((PhyRegValue&0x0020)==0)
9025                         break;
9026         }
9027         PhyRegValue = MP_ReadPhyUshort(sc, 0x07);
9028         if (PhyRegValue & 0x0020) {
9029                 MP_WritePhyUshort(sc, 0x1f, 0x0007);
9030                 MP_WritePhyUshort(sc, 0x1e, 0x00a1);
9031                 MP_WritePhyUshort(sc, 0x17, 0x1000);
9032                 MP_WritePhyUshort(sc, 0x17, 0x0000);
9033                 MP_WritePhyUshort(sc, 0x17, 0x2000);
9034                 MP_WritePhyUshort(sc, 0x1e, 0x002f);
9035                 MP_WritePhyUshort(sc, 0x18, 0x9bfb);
9036                 MP_WritePhyUshort(sc, 0x1f, 0x0005);
9037                 MP_WritePhyUshort(sc, 0x07, 0x0000);
9038                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
9039         }
9040
9041         MP_WritePhyUshort(sc, 0x1f, 0x0005);
9042         MP_WritePhyUshort(sc, 0x05, 0xfff6);
9043         MP_WritePhyUshort(sc, 0x06, 0x0080);
9044         PhyRegValue = MP_ReadPhyUshort(sc, 0x00);
9045         PhyRegValue &= ~(BIT_7);
9046         MP_WritePhyUshort(sc, 0x00, PhyRegValue);
9047         MP_WritePhyUshort(sc, 0x1f, 0x0002);
9048         PhyRegValue = MP_ReadPhyUshort(sc, 0x08);
9049         PhyRegValue &= ~(BIT_7);
9050         MP_WritePhyUshort(sc, 0x08, PhyRegValue);
9051         MP_WritePhyUshort(sc, 0x1f, 0x0000);
9052         MP_WritePhyUshort(sc, 0x1f, 0x0007);
9053         MP_WritePhyUshort(sc, 0x1e, 0x0023);
9054         MP_WritePhyUshort(sc, 0x16, 0x0306);
9055         MP_WritePhyUshort(sc, 0x16, 0x0307);
9056         MP_WritePhyUshort(sc, 0x15, 0x000e);
9057         MP_WritePhyUshort(sc, 0x19, 0x000a);
9058         MP_WritePhyUshort(sc, 0x15, 0x0010);
9059         MP_WritePhyUshort(sc, 0x19, 0x0008);
9060         MP_WritePhyUshort(sc, 0x15, 0x0018);
9061         MP_WritePhyUshort(sc, 0x19, 0x4801);
9062         MP_WritePhyUshort(sc, 0x15, 0x0019);
9063         MP_WritePhyUshort(sc, 0x19, 0x6801);
9064         MP_WritePhyUshort(sc, 0x15, 0x001a);
9065         MP_WritePhyUshort(sc, 0x19, 0x66a1);
9066         MP_WritePhyUshort(sc, 0x15, 0x001f);
9067         MP_WritePhyUshort(sc, 0x19, 0x0000);
9068         MP_WritePhyUshort(sc, 0x15, 0x0020);
9069         MP_WritePhyUshort(sc, 0x19, 0x0000);
9070         MP_WritePhyUshort(sc, 0x15, 0x0021);
9071         MP_WritePhyUshort(sc, 0x19, 0x0000);
9072         MP_WritePhyUshort(sc, 0x15, 0x0022);
9073         MP_WritePhyUshort(sc, 0x19, 0x0000);
9074         MP_WritePhyUshort(sc, 0x15, 0x0023);
9075         MP_WritePhyUshort(sc, 0x19, 0x0000);
9076         MP_WritePhyUshort(sc, 0x15, 0x0024);
9077         MP_WritePhyUshort(sc, 0x19, 0x0000);
9078         MP_WritePhyUshort(sc, 0x15, 0x0025);
9079         MP_WritePhyUshort(sc, 0x19, 0x64a1);
9080         MP_WritePhyUshort(sc, 0x15, 0x0026);
9081         MP_WritePhyUshort(sc, 0x19, 0x40ea);
9082         MP_WritePhyUshort(sc, 0x15, 0x0027);
9083         MP_WritePhyUshort(sc, 0x19, 0x4503);
9084         MP_WritePhyUshort(sc, 0x15, 0x0028);
9085         MP_WritePhyUshort(sc, 0x19, 0x9f00);
9086         MP_WritePhyUshort(sc, 0x15, 0x0029);
9087         MP_WritePhyUshort(sc, 0x19, 0xa631);
9088         MP_WritePhyUshort(sc, 0x15, 0x002a);
9089         MP_WritePhyUshort(sc, 0x19, 0x9717);
9090         MP_WritePhyUshort(sc, 0x15, 0x002b);
9091         MP_WritePhyUshort(sc, 0x19, 0x302c);
9092         MP_WritePhyUshort(sc, 0x15, 0x002c);
9093         MP_WritePhyUshort(sc, 0x19, 0x4802);
9094         MP_WritePhyUshort(sc, 0x15, 0x002d);
9095         MP_WritePhyUshort(sc, 0x19, 0x58da);
9096         MP_WritePhyUshort(sc, 0x15, 0x002e);
9097         MP_WritePhyUshort(sc, 0x19, 0x400d);
9098         MP_WritePhyUshort(sc, 0x15, 0x002f);
9099         MP_WritePhyUshort(sc, 0x19, 0x4488);
9100         MP_WritePhyUshort(sc, 0x15, 0x0030);
9101         MP_WritePhyUshort(sc, 0x19, 0x9e00);
9102         MP_WritePhyUshort(sc, 0x15, 0x0031);
9103         MP_WritePhyUshort(sc, 0x19, 0x63c8);
9104         MP_WritePhyUshort(sc, 0x15, 0x0032);
9105         MP_WritePhyUshort(sc, 0x19, 0x6481);
9106         MP_WritePhyUshort(sc, 0x15, 0x0033);
9107         MP_WritePhyUshort(sc, 0x19, 0x0000);
9108         MP_WritePhyUshort(sc, 0x15, 0x0034);
9109         MP_WritePhyUshort(sc, 0x19, 0x0000);
9110         MP_WritePhyUshort(sc, 0x15, 0x0035);
9111         MP_WritePhyUshort(sc, 0x19, 0x0000);
9112         MP_WritePhyUshort(sc, 0x15, 0x0036);
9113         MP_WritePhyUshort(sc, 0x19, 0x0000);
9114         MP_WritePhyUshort(sc, 0x15, 0x0037);
9115         MP_WritePhyUshort(sc, 0x19, 0x0000);
9116         MP_WritePhyUshort(sc, 0x15, 0x0038);
9117         MP_WritePhyUshort(sc, 0x19, 0x0000);
9118         MP_WritePhyUshort(sc, 0x15, 0x0039);
9119         MP_WritePhyUshort(sc, 0x19, 0x0000);
9120         MP_WritePhyUshort(sc, 0x15, 0x003a);
9121         MP_WritePhyUshort(sc, 0x19, 0x0000);
9122         MP_WritePhyUshort(sc, 0x15, 0x003b);
9123         MP_WritePhyUshort(sc, 0x19, 0x63e8);
9124         MP_WritePhyUshort(sc, 0x15, 0x003c);
9125         MP_WritePhyUshort(sc, 0x19, 0x7d00);
9126         MP_WritePhyUshort(sc, 0x15, 0x003d);
9127         MP_WritePhyUshort(sc, 0x19, 0x59d4);
9128         MP_WritePhyUshort(sc, 0x15, 0x003e);
9129         MP_WritePhyUshort(sc, 0x19, 0x63f8);
9130         MP_WritePhyUshort(sc, 0x15, 0x0040);
9131         MP_WritePhyUshort(sc, 0x19, 0x64a1);
9132         MP_WritePhyUshort(sc, 0x15, 0x0041);
9133         MP_WritePhyUshort(sc, 0x19, 0x30de);
9134         MP_WritePhyUshort(sc, 0x15, 0x0044);
9135         MP_WritePhyUshort(sc, 0x19, 0x480f);
9136         MP_WritePhyUshort(sc, 0x15, 0x0045);
9137         MP_WritePhyUshort(sc, 0x19, 0x6800);
9138         MP_WritePhyUshort(sc, 0x15, 0x0046);
9139         MP_WritePhyUshort(sc, 0x19, 0x6680);
9140         MP_WritePhyUshort(sc, 0x15, 0x0047);
9141         MP_WritePhyUshort(sc, 0x19, 0x7c10);
9142         MP_WritePhyUshort(sc, 0x15, 0x0048);
9143         MP_WritePhyUshort(sc, 0x19, 0x63c8);
9144         MP_WritePhyUshort(sc, 0x15, 0x0049);
9145         MP_WritePhyUshort(sc, 0x19, 0x0000);
9146         MP_WritePhyUshort(sc, 0x15, 0x004a);
9147         MP_WritePhyUshort(sc, 0x19, 0x0000);
9148         MP_WritePhyUshort(sc, 0x15, 0x004b);
9149         MP_WritePhyUshort(sc, 0x19, 0x0000);
9150         MP_WritePhyUshort(sc, 0x15, 0x004c);
9151         MP_WritePhyUshort(sc, 0x19, 0x0000);
9152         MP_WritePhyUshort(sc, 0x15, 0x004d);
9153         MP_WritePhyUshort(sc, 0x19, 0x0000);
9154         MP_WritePhyUshort(sc, 0x15, 0x004e);
9155         MP_WritePhyUshort(sc, 0x19, 0x0000);
9156         MP_WritePhyUshort(sc, 0x15, 0x004f);
9157         MP_WritePhyUshort(sc, 0x19, 0x40ea);
9158         MP_WritePhyUshort(sc, 0x15, 0x0050);
9159         MP_WritePhyUshort(sc, 0x19, 0x4503);
9160         MP_WritePhyUshort(sc, 0x15, 0x0051);
9161         MP_WritePhyUshort(sc, 0x19, 0x58ca);
9162         MP_WritePhyUshort(sc, 0x15, 0x0052);
9163         MP_WritePhyUshort(sc, 0x19, 0x63c8);
9164         MP_WritePhyUshort(sc, 0x15, 0x0053);
9165         MP_WritePhyUshort(sc, 0x19, 0x63d8);
9166         MP_WritePhyUshort(sc, 0x15, 0x0054);
9167         MP_WritePhyUshort(sc, 0x19, 0x66a0);
9168         MP_WritePhyUshort(sc, 0x15, 0x0055);
9169         MP_WritePhyUshort(sc, 0x19, 0x9f00);
9170         MP_WritePhyUshort(sc, 0x15, 0x0056);
9171         MP_WritePhyUshort(sc, 0x19, 0x3000);
9172         MP_WritePhyUshort(sc, 0x15, 0x006E);
9173         MP_WritePhyUshort(sc, 0x19, 0x9afa);
9174         MP_WritePhyUshort(sc, 0x15, 0x00a1);
9175         MP_WritePhyUshort(sc, 0x19, 0x3044);
9176         MP_WritePhyUshort(sc, 0x15, 0x00ab);
9177         MP_WritePhyUshort(sc, 0x19, 0x5820);
9178         MP_WritePhyUshort(sc, 0x15, 0x00ac);
9179         MP_WritePhyUshort(sc, 0x19, 0x5e04);
9180         MP_WritePhyUshort(sc, 0x15, 0x00ad);
9181         MP_WritePhyUshort(sc, 0x19, 0xb60c);
9182         MP_WritePhyUshort(sc, 0x15, 0x00af);
9183         MP_WritePhyUshort(sc, 0x19, 0x000a);
9184         MP_WritePhyUshort(sc, 0x15, 0x00b2);
9185         MP_WritePhyUshort(sc, 0x19, 0x30b9);
9186         MP_WritePhyUshort(sc, 0x15, 0x00b9);
9187         MP_WritePhyUshort(sc, 0x19, 0x4408);
9188         MP_WritePhyUshort(sc, 0x15, 0x00ba);
9189         MP_WritePhyUshort(sc, 0x19, 0x480b);
9190         MP_WritePhyUshort(sc, 0x15, 0x00bb);
9191         MP_WritePhyUshort(sc, 0x19, 0x5e00);
9192         MP_WritePhyUshort(sc, 0x15, 0x00bc);
9193         MP_WritePhyUshort(sc, 0x19, 0x405f);
9194         MP_WritePhyUshort(sc, 0x15, 0x00bd);
9195         MP_WritePhyUshort(sc, 0x19, 0x4448);
9196         MP_WritePhyUshort(sc, 0x15, 0x00be);
9197         MP_WritePhyUshort(sc, 0x19, 0x4020);
9198         MP_WritePhyUshort(sc, 0x15, 0x00bf);
9199         MP_WritePhyUshort(sc, 0x19, 0x4468);
9200         MP_WritePhyUshort(sc, 0x15, 0x00c0);
9201         MP_WritePhyUshort(sc, 0x19, 0x9c02);
9202         MP_WritePhyUshort(sc, 0x15, 0x00c1);
9203         MP_WritePhyUshort(sc, 0x19, 0x58a0);
9204         MP_WritePhyUshort(sc, 0x15, 0x00c2);
9205         MP_WritePhyUshort(sc, 0x19, 0xb605);
9206         MP_WritePhyUshort(sc, 0x15, 0x00c3);
9207         MP_WritePhyUshort(sc, 0x19, 0xc0d3);
9208         MP_WritePhyUshort(sc, 0x15, 0x00c4);
9209         MP_WritePhyUshort(sc, 0x19, 0x00e6);
9210         MP_WritePhyUshort(sc, 0x15, 0x00c5);
9211         MP_WritePhyUshort(sc, 0x19, 0xdaec);
9212         MP_WritePhyUshort(sc, 0x15, 0x00c6);
9213         MP_WritePhyUshort(sc, 0x19, 0x00fa);
9214         MP_WritePhyUshort(sc, 0x15, 0x00c7);
9215         MP_WritePhyUshort(sc, 0x19, 0x9df9);
9216         MP_WritePhyUshort(sc, 0x15, 0x00c8);
9217         MP_WritePhyUshort(sc, 0x19, 0x307a);
9218         MP_WritePhyUshort(sc, 0x15, 0x0112);
9219         MP_WritePhyUshort(sc, 0x19, 0x6421);
9220         MP_WritePhyUshort(sc, 0x15, 0x0113);
9221         MP_WritePhyUshort(sc, 0x19, 0x7c08);
9222         MP_WritePhyUshort(sc, 0x15, 0x0114);
9223         MP_WritePhyUshort(sc, 0x19, 0x63f0);
9224         MP_WritePhyUshort(sc, 0x15, 0x0115);
9225         MP_WritePhyUshort(sc, 0x19, 0x4003);
9226         MP_WritePhyUshort(sc, 0x15, 0x0116);
9227         MP_WritePhyUshort(sc, 0x19, 0x4418);
9228         MP_WritePhyUshort(sc, 0x15, 0x0117);
9229         MP_WritePhyUshort(sc, 0x19, 0x9b00);
9230         MP_WritePhyUshort(sc, 0x15, 0x0118);
9231         MP_WritePhyUshort(sc, 0x19, 0x6461);
9232         MP_WritePhyUshort(sc, 0x15, 0x0119);
9233         MP_WritePhyUshort(sc, 0x19, 0x64e1);
9234         MP_WritePhyUshort(sc, 0x15, 0x011a);
9235         MP_WritePhyUshort(sc, 0x19, 0x0000);
9236         MP_WritePhyUshort(sc, 0x15, 0x0150);
9237         MP_WritePhyUshort(sc, 0x19, 0x7c80);
9238         MP_WritePhyUshort(sc, 0x15, 0x0151);
9239         MP_WritePhyUshort(sc, 0x19, 0x6461);
9240         MP_WritePhyUshort(sc, 0x15, 0x0152);
9241         MP_WritePhyUshort(sc, 0x19, 0x4003);
9242         MP_WritePhyUshort(sc, 0x15, 0x0153);
9243         MP_WritePhyUshort(sc, 0x19, 0x4540);
9244         MP_WritePhyUshort(sc, 0x15, 0x0154);
9245         MP_WritePhyUshort(sc, 0x19, 0x9f00);
9246         MP_WritePhyUshort(sc, 0x15, 0x0155);
9247         MP_WritePhyUshort(sc, 0x19, 0x9d00);
9248         MP_WritePhyUshort(sc, 0x15, 0x0156);
9249         MP_WritePhyUshort(sc, 0x19, 0x7c40);
9250         MP_WritePhyUshort(sc, 0x15, 0x0157);
9251         MP_WritePhyUshort(sc, 0x19, 0x6421);
9252         MP_WritePhyUshort(sc, 0x15, 0x0158);
9253         MP_WritePhyUshort(sc, 0x19, 0x7c80);
9254         MP_WritePhyUshort(sc, 0x15, 0x0159);
9255         MP_WritePhyUshort(sc, 0x19, 0x64a1);
9256         MP_WritePhyUshort(sc, 0x15, 0x015a);
9257         MP_WritePhyUshort(sc, 0x19, 0x30fe);
9258         MP_WritePhyUshort(sc, 0x15, 0x021e);
9259         MP_WritePhyUshort(sc, 0x19, 0x5410);
9260         MP_WritePhyUshort(sc, 0x15, 0x0225);
9261         MP_WritePhyUshort(sc, 0x19, 0x5400);
9262         MP_WritePhyUshort(sc, 0x15, 0x023D);
9263         MP_WritePhyUshort(sc, 0x19, 0x4050);
9264         MP_WritePhyUshort(sc, 0x15, 0x0295);
9265         MP_WritePhyUshort(sc, 0x19, 0x6c08);
9266         MP_WritePhyUshort(sc, 0x15, 0x02bd);
9267         MP_WritePhyUshort(sc, 0x19, 0xa523);
9268         MP_WritePhyUshort(sc, 0x15, 0x02be);
9269         MP_WritePhyUshort(sc, 0x19, 0x32ca);
9270         MP_WritePhyUshort(sc, 0x15, 0x02ca);
9271         MP_WritePhyUshort(sc, 0x19, 0x48b3);
9272         MP_WritePhyUshort(sc, 0x15, 0x02cb);
9273         MP_WritePhyUshort(sc, 0x19, 0x4020);
9274         MP_WritePhyUshort(sc, 0x15, 0x02cc);
9275         MP_WritePhyUshort(sc, 0x19, 0x4823);
9276         MP_WritePhyUshort(sc, 0x15, 0x02cd);
9277         MP_WritePhyUshort(sc, 0x19, 0x4510);
9278         MP_WritePhyUshort(sc, 0x15, 0x02ce);
9279         MP_WritePhyUshort(sc, 0x19, 0xb63a);
9280         MP_WritePhyUshort(sc, 0x15, 0x02cf);
9281         MP_WritePhyUshort(sc, 0x19, 0x7dc8);
9282         MP_WritePhyUshort(sc, 0x15, 0x02d6);
9283         MP_WritePhyUshort(sc, 0x19, 0x9bf8);
9284         MP_WritePhyUshort(sc, 0x15, 0x02d8);
9285         MP_WritePhyUshort(sc, 0x19, 0x85f6);
9286         MP_WritePhyUshort(sc, 0x15, 0x02d9);
9287         MP_WritePhyUshort(sc, 0x19, 0x32e0);
9288         MP_WritePhyUshort(sc, 0x15, 0x02e0);
9289         MP_WritePhyUshort(sc, 0x19, 0x4834);
9290         MP_WritePhyUshort(sc, 0x15, 0x02e1);
9291         MP_WritePhyUshort(sc, 0x19, 0x6c08);
9292         MP_WritePhyUshort(sc, 0x15, 0x02e2);
9293         MP_WritePhyUshort(sc, 0x19, 0x4020);
9294         MP_WritePhyUshort(sc, 0x15, 0x02e3);
9295         MP_WritePhyUshort(sc, 0x19, 0x4824);
9296         MP_WritePhyUshort(sc, 0x15, 0x02e4);
9297         MP_WritePhyUshort(sc, 0x19, 0x4520);
9298         MP_WritePhyUshort(sc, 0x15, 0x02e5);
9299         MP_WritePhyUshort(sc, 0x19, 0x4008);
9300         MP_WritePhyUshort(sc, 0x15, 0x02e6);
9301         MP_WritePhyUshort(sc, 0x19, 0x4560);
9302         MP_WritePhyUshort(sc, 0x15, 0x02e7);
9303         MP_WritePhyUshort(sc, 0x19, 0x9d04);
9304         MP_WritePhyUshort(sc, 0x15, 0x02e8);
9305         MP_WritePhyUshort(sc, 0x19, 0x48c4);
9306         MP_WritePhyUshort(sc, 0x15, 0x02e9);
9307         MP_WritePhyUshort(sc, 0x19, 0x0000);
9308         MP_WritePhyUshort(sc, 0x15, 0x02ea);
9309         MP_WritePhyUshort(sc, 0x19, 0x4844);
9310         MP_WritePhyUshort(sc, 0x15, 0x02eb);
9311         MP_WritePhyUshort(sc, 0x19, 0x7dc8);
9312         MP_WritePhyUshort(sc, 0x15, 0x02f0);
9313         MP_WritePhyUshort(sc, 0x19, 0x9cf7);
9314         MP_WritePhyUshort(sc, 0x15, 0x02f1);
9315         MP_WritePhyUshort(sc, 0x19, 0xdf94);
9316         MP_WritePhyUshort(sc, 0x15, 0x02f2);
9317         MP_WritePhyUshort(sc, 0x19, 0x0002);
9318         MP_WritePhyUshort(sc, 0x15, 0x02f3);
9319         MP_WritePhyUshort(sc, 0x19, 0x6810);
9320         MP_WritePhyUshort(sc, 0x15, 0x02f4);
9321         MP_WritePhyUshort(sc, 0x19, 0xb614);
9322         MP_WritePhyUshort(sc, 0x15, 0x02f5);
9323         MP_WritePhyUshort(sc, 0x19, 0xc42b);
9324         MP_WritePhyUshort(sc, 0x15, 0x02f6);
9325         MP_WritePhyUshort(sc, 0x19, 0x00d4);
9326         MP_WritePhyUshort(sc, 0x15, 0x02f7);
9327         MP_WritePhyUshort(sc, 0x19, 0xc455);
9328         MP_WritePhyUshort(sc, 0x15, 0x02f8);
9329         MP_WritePhyUshort(sc, 0x19, 0x0093);
9330         MP_WritePhyUshort(sc, 0x15, 0x02f9);
9331         MP_WritePhyUshort(sc, 0x19, 0x92ee);
9332         MP_WritePhyUshort(sc, 0x15, 0x02fa);
9333         MP_WritePhyUshort(sc, 0x19, 0xefed);
9334         MP_WritePhyUshort(sc, 0x15, 0x02fb);
9335         MP_WritePhyUshort(sc, 0x19, 0x3312);
9336         MP_WritePhyUshort(sc, 0x15, 0x0312);
9337         MP_WritePhyUshort(sc, 0x19, 0x49b5);
9338         MP_WritePhyUshort(sc, 0x15, 0x0313);
9339         MP_WritePhyUshort(sc, 0x19, 0x7d00);
9340         MP_WritePhyUshort(sc, 0x15, 0x0314);
9341         MP_WritePhyUshort(sc, 0x19, 0x4d00);
9342         MP_WritePhyUshort(sc, 0x15, 0x0315);
9343         MP_WritePhyUshort(sc, 0x19, 0x6810);
9344         MP_WritePhyUshort(sc, 0x15, 0x031e);
9345         MP_WritePhyUshort(sc, 0x19, 0x404f);
9346         MP_WritePhyUshort(sc, 0x15, 0x031f);
9347         MP_WritePhyUshort(sc, 0x19, 0x44c8);
9348         MP_WritePhyUshort(sc, 0x15, 0x0320);
9349         MP_WritePhyUshort(sc, 0x19, 0xd64f);
9350         MP_WritePhyUshort(sc, 0x15, 0x0321);
9351         MP_WritePhyUshort(sc, 0x19, 0x00e7);
9352         MP_WritePhyUshort(sc, 0x15, 0x0322);
9353         MP_WritePhyUshort(sc, 0x19, 0x7c08);
9354         MP_WritePhyUshort(sc, 0x15, 0x0323);
9355         MP_WritePhyUshort(sc, 0x19, 0x8203);
9356         MP_WritePhyUshort(sc, 0x15, 0x0324);
9357         MP_WritePhyUshort(sc, 0x19, 0x4d48);
9358         MP_WritePhyUshort(sc, 0x15, 0x0325);
9359         MP_WritePhyUshort(sc, 0x19, 0x3327);
9360         MP_WritePhyUshort(sc, 0x15, 0x0326);
9361         MP_WritePhyUshort(sc, 0x19, 0x4d40);
9362         MP_WritePhyUshort(sc, 0x15, 0x0327);
9363         MP_WritePhyUshort(sc, 0x19, 0xc8d7);
9364         MP_WritePhyUshort(sc, 0x15, 0x0328);
9365         MP_WritePhyUshort(sc, 0x19, 0x0003);
9366         MP_WritePhyUshort(sc, 0x15, 0x0329);
9367         MP_WritePhyUshort(sc, 0x19, 0x7c20);
9368         MP_WritePhyUshort(sc, 0x15, 0x032a);
9369         MP_WritePhyUshort(sc, 0x19, 0x4c20);
9370         MP_WritePhyUshort(sc, 0x15, 0x032b);
9371         MP_WritePhyUshort(sc, 0x19, 0xc8ed);
9372         MP_WritePhyUshort(sc, 0x15, 0x032c);
9373         MP_WritePhyUshort(sc, 0x19, 0x00f4);
9374         MP_WritePhyUshort(sc, 0x15, 0x032d);
9375         MP_WritePhyUshort(sc, 0x19, 0x82b3);
9376         MP_WritePhyUshort(sc, 0x15, 0x032e);
9377         MP_WritePhyUshort(sc, 0x19, 0xd11d);
9378         MP_WritePhyUshort(sc, 0x15, 0x032f);
9379         MP_WritePhyUshort(sc, 0x19, 0x00b1);
9380         MP_WritePhyUshort(sc, 0x15, 0x0330);
9381         MP_WritePhyUshort(sc, 0x19, 0xde18);
9382         MP_WritePhyUshort(sc, 0x15, 0x0331);
9383         MP_WritePhyUshort(sc, 0x19, 0x0008);
9384         MP_WritePhyUshort(sc, 0x15, 0x0332);
9385         MP_WritePhyUshort(sc, 0x19, 0x91ee);
9386         MP_WritePhyUshort(sc, 0x15, 0x0333);
9387         MP_WritePhyUshort(sc, 0x19, 0x3339);
9388         MP_WritePhyUshort(sc, 0x15, 0x033a);
9389         MP_WritePhyUshort(sc, 0x19, 0x4064);
9390         MP_WritePhyUshort(sc, 0x15, 0x0340);
9391         MP_WritePhyUshort(sc, 0x19, 0x9e06);
9392         MP_WritePhyUshort(sc, 0x15, 0x0341);
9393         MP_WritePhyUshort(sc, 0x19, 0x7c08);
9394         MP_WritePhyUshort(sc, 0x15, 0x0342);
9395         MP_WritePhyUshort(sc, 0x19, 0x8203);
9396         MP_WritePhyUshort(sc, 0x15, 0x0343);
9397         MP_WritePhyUshort(sc, 0x19, 0x4d48);
9398         MP_WritePhyUshort(sc, 0x15, 0x0344);
9399         MP_WritePhyUshort(sc, 0x19, 0x3346);
9400         MP_WritePhyUshort(sc, 0x15, 0x0345);
9401         MP_WritePhyUshort(sc, 0x19, 0x4d40);
9402         MP_WritePhyUshort(sc, 0x15, 0x0346);
9403         MP_WritePhyUshort(sc, 0x19, 0xd11d);
9404         MP_WritePhyUshort(sc, 0x15, 0x0347);
9405         MP_WritePhyUshort(sc, 0x19, 0x0099);
9406         MP_WritePhyUshort(sc, 0x15, 0x0348);
9407         MP_WritePhyUshort(sc, 0x19, 0xbb17);
9408         MP_WritePhyUshort(sc, 0x15, 0x0349);
9409         MP_WritePhyUshort(sc, 0x19, 0x8102);
9410         MP_WritePhyUshort(sc, 0x15, 0x034a);
9411         MP_WritePhyUshort(sc, 0x19, 0x334d);
9412         MP_WritePhyUshort(sc, 0x15, 0x034b);
9413         MP_WritePhyUshort(sc, 0x19, 0xa22c);
9414         MP_WritePhyUshort(sc, 0x15, 0x034c);
9415         MP_WritePhyUshort(sc, 0x19, 0x3397);
9416         MP_WritePhyUshort(sc, 0x15, 0x034d);
9417         MP_WritePhyUshort(sc, 0x19, 0x91f2);
9418         MP_WritePhyUshort(sc, 0x15, 0x034e);
9419         MP_WritePhyUshort(sc, 0x19, 0xc218);
9420         MP_WritePhyUshort(sc, 0x15, 0x034f);
9421         MP_WritePhyUshort(sc, 0x19, 0x00f0);
9422         MP_WritePhyUshort(sc, 0x15, 0x0350);
9423         MP_WritePhyUshort(sc, 0x19, 0x3397);
9424         MP_WritePhyUshort(sc, 0x15, 0x0351);
9425         MP_WritePhyUshort(sc, 0x19, 0x0000);
9426         MP_WritePhyUshort(sc, 0x15, 0x0364);
9427         MP_WritePhyUshort(sc, 0x19, 0xbc05);
9428         MP_WritePhyUshort(sc, 0x15, 0x0367);
9429         MP_WritePhyUshort(sc, 0x19, 0xa1fc);
9430         MP_WritePhyUshort(sc, 0x15, 0x0368);
9431         MP_WritePhyUshort(sc, 0x19, 0x3377);
9432         MP_WritePhyUshort(sc, 0x15, 0x0369);
9433         MP_WritePhyUshort(sc, 0x19, 0x328b);
9434         MP_WritePhyUshort(sc, 0x15, 0x036a);
9435         MP_WritePhyUshort(sc, 0x19, 0x0000);
9436         MP_WritePhyUshort(sc, 0x15, 0x0377);
9437         MP_WritePhyUshort(sc, 0x19, 0x4b97);
9438         MP_WritePhyUshort(sc, 0x15, 0x0378);
9439         MP_WritePhyUshort(sc, 0x19, 0x6818);
9440         MP_WritePhyUshort(sc, 0x15, 0x0379);
9441         MP_WritePhyUshort(sc, 0x19, 0x4b07);
9442         MP_WritePhyUshort(sc, 0x15, 0x037a);
9443         MP_WritePhyUshort(sc, 0x19, 0x40ac);
9444         MP_WritePhyUshort(sc, 0x15, 0x037b);
9445         MP_WritePhyUshort(sc, 0x19, 0x4445);
9446         MP_WritePhyUshort(sc, 0x15, 0x037c);
9447         MP_WritePhyUshort(sc, 0x19, 0x404e);
9448         MP_WritePhyUshort(sc, 0x15, 0x037d);
9449         MP_WritePhyUshort(sc, 0x19, 0x4461);
9450         MP_WritePhyUshort(sc, 0x15, 0x037e);
9451         MP_WritePhyUshort(sc, 0x19, 0x9c09);
9452         MP_WritePhyUshort(sc, 0x15, 0x037f);
9453         MP_WritePhyUshort(sc, 0x19, 0x63da);
9454         MP_WritePhyUshort(sc, 0x15, 0x0380);
9455         MP_WritePhyUshort(sc, 0x19, 0x5440);
9456         MP_WritePhyUshort(sc, 0x15, 0x0381);
9457         MP_WritePhyUshort(sc, 0x19, 0x4b98);
9458         MP_WritePhyUshort(sc, 0x15, 0x0382);
9459         MP_WritePhyUshort(sc, 0x19, 0x7c60);
9460         MP_WritePhyUshort(sc, 0x15, 0x0383);
9461         MP_WritePhyUshort(sc, 0x19, 0x4c00);
9462         MP_WritePhyUshort(sc, 0x15, 0x0384);
9463         MP_WritePhyUshort(sc, 0x19, 0x4b08);
9464         MP_WritePhyUshort(sc, 0x15, 0x0385);
9465         MP_WritePhyUshort(sc, 0x19, 0x63d8);
9466         MP_WritePhyUshort(sc, 0x15, 0x0386);
9467         MP_WritePhyUshort(sc, 0x19, 0x338d);
9468         MP_WritePhyUshort(sc, 0x15, 0x0387);
9469         MP_WritePhyUshort(sc, 0x19, 0xd64f);
9470         MP_WritePhyUshort(sc, 0x15, 0x0388);
9471         MP_WritePhyUshort(sc, 0x19, 0x0080);
9472         MP_WritePhyUshort(sc, 0x15, 0x0389);
9473         MP_WritePhyUshort(sc, 0x19, 0x820c);
9474         MP_WritePhyUshort(sc, 0x15, 0x038a);
9475         MP_WritePhyUshort(sc, 0x19, 0xa10b);
9476         MP_WritePhyUshort(sc, 0x15, 0x038b);
9477         MP_WritePhyUshort(sc, 0x19, 0x9df3);
9478         MP_WritePhyUshort(sc, 0x15, 0x038c);
9479         MP_WritePhyUshort(sc, 0x19, 0x3395);
9480         MP_WritePhyUshort(sc, 0x15, 0x038d);
9481         MP_WritePhyUshort(sc, 0x19, 0xd64f);
9482         MP_WritePhyUshort(sc, 0x15, 0x038e);
9483         MP_WritePhyUshort(sc, 0x19, 0x00f9);
9484         MP_WritePhyUshort(sc, 0x15, 0x038f);
9485         MP_WritePhyUshort(sc, 0x19, 0xc017);
9486         MP_WritePhyUshort(sc, 0x15, 0x0390);
9487         MP_WritePhyUshort(sc, 0x19, 0x0005);
9488         MP_WritePhyUshort(sc, 0x15, 0x0391);
9489         MP_WritePhyUshort(sc, 0x19, 0x6c0b);
9490         MP_WritePhyUshort(sc, 0x15, 0x0392);
9491         MP_WritePhyUshort(sc, 0x19, 0xa103);
9492         MP_WritePhyUshort(sc, 0x15, 0x0393);
9493         MP_WritePhyUshort(sc, 0x19, 0x6c08);
9494         MP_WritePhyUshort(sc, 0x15, 0x0394);
9495         MP_WritePhyUshort(sc, 0x19, 0x9df9);
9496         MP_WritePhyUshort(sc, 0x15, 0x0395);
9497         MP_WritePhyUshort(sc, 0x19, 0x6c08);
9498         MP_WritePhyUshort(sc, 0x15, 0x0396);
9499         MP_WritePhyUshort(sc, 0x19, 0x3397);
9500         MP_WritePhyUshort(sc, 0x15, 0x0399);
9501         MP_WritePhyUshort(sc, 0x19, 0x6810);
9502         MP_WritePhyUshort(sc, 0x15, 0x03a4);
9503         MP_WritePhyUshort(sc, 0x19, 0x7c08);
9504         MP_WritePhyUshort(sc, 0x15, 0x03a5);
9505         MP_WritePhyUshort(sc, 0x19, 0x8203);
9506         MP_WritePhyUshort(sc, 0x15, 0x03a6);
9507         MP_WritePhyUshort(sc, 0x19, 0x4d08);
9508         MP_WritePhyUshort(sc, 0x15, 0x03a7);
9509         MP_WritePhyUshort(sc, 0x19, 0x33a9);
9510         MP_WritePhyUshort(sc, 0x15, 0x03a8);
9511         MP_WritePhyUshort(sc, 0x19, 0x4d00);
9512         MP_WritePhyUshort(sc, 0x15, 0x03a9);
9513         MP_WritePhyUshort(sc, 0x19, 0x9bfa);
9514         MP_WritePhyUshort(sc, 0x15, 0x03aa);
9515         MP_WritePhyUshort(sc, 0x19, 0x33b6);
9516         MP_WritePhyUshort(sc, 0x15, 0x03bb);
9517         MP_WritePhyUshort(sc, 0x19, 0x4056);
9518         MP_WritePhyUshort(sc, 0x15, 0x03bc);
9519         MP_WritePhyUshort(sc, 0x19, 0x44e9);
9520         MP_WritePhyUshort(sc, 0x15, 0x03bd);
9521         MP_WritePhyUshort(sc, 0x19, 0x405e);
9522         MP_WritePhyUshort(sc, 0x15, 0x03be);
9523         MP_WritePhyUshort(sc, 0x19, 0x44f8);
9524         MP_WritePhyUshort(sc, 0x15, 0x03bf);
9525         MP_WritePhyUshort(sc, 0x19, 0xd64f);
9526         MP_WritePhyUshort(sc, 0x15, 0x03c0);
9527         MP_WritePhyUshort(sc, 0x19, 0x0037);
9528         MP_WritePhyUshort(sc, 0x15, 0x03c1);
9529         MP_WritePhyUshort(sc, 0x19, 0xbd37);
9530         MP_WritePhyUshort(sc, 0x15, 0x03c2);
9531         MP_WritePhyUshort(sc, 0x19, 0x9cfd);
9532         MP_WritePhyUshort(sc, 0x15, 0x03c3);
9533         MP_WritePhyUshort(sc, 0x19, 0xc639);
9534         MP_WritePhyUshort(sc, 0x15, 0x03c4);
9535         MP_WritePhyUshort(sc, 0x19, 0x0011);
9536         MP_WritePhyUshort(sc, 0x15, 0x03c5);
9537         MP_WritePhyUshort(sc, 0x19, 0x9b03);
9538         MP_WritePhyUshort(sc, 0x15, 0x03c6);
9539         MP_WritePhyUshort(sc, 0x19, 0x7c01);
9540         MP_WritePhyUshort(sc, 0x15, 0x03c7);
9541         MP_WritePhyUshort(sc, 0x19, 0x4c01);
9542         MP_WritePhyUshort(sc, 0x15, 0x03c8);
9543         MP_WritePhyUshort(sc, 0x19, 0x9e03);
9544         MP_WritePhyUshort(sc, 0x15, 0x03c9);
9545         MP_WritePhyUshort(sc, 0x19, 0x7c20);
9546         MP_WritePhyUshort(sc, 0x15, 0x03ca);
9547         MP_WritePhyUshort(sc, 0x19, 0x4c20);
9548         MP_WritePhyUshort(sc, 0x15, 0x03cb);
9549         MP_WritePhyUshort(sc, 0x19, 0x9af4);
9550         MP_WritePhyUshort(sc, 0x15, 0x03cc);
9551         MP_WritePhyUshort(sc, 0x19, 0x7c12);
9552         MP_WritePhyUshort(sc, 0x15, 0x03cd);
9553         MP_WritePhyUshort(sc, 0x19, 0x4c52);
9554         MP_WritePhyUshort(sc, 0x15, 0x03ce);
9555         MP_WritePhyUshort(sc, 0x19, 0x4470);
9556         MP_WritePhyUshort(sc, 0x15, 0x03cf);
9557         MP_WritePhyUshort(sc, 0x19, 0x7c12);
9558         MP_WritePhyUshort(sc, 0x15, 0x03d0);
9559         MP_WritePhyUshort(sc, 0x19, 0x4c40);
9560         MP_WritePhyUshort(sc, 0x15, 0x03d1);
9561         MP_WritePhyUshort(sc, 0x19, 0x33bf);
9562         MP_WritePhyUshort(sc, 0x15, 0x03d6);
9563         MP_WritePhyUshort(sc, 0x19, 0x4047);
9564         MP_WritePhyUshort(sc, 0x15, 0x03d7);
9565         MP_WritePhyUshort(sc, 0x19, 0x4469);
9566         MP_WritePhyUshort(sc, 0x15, 0x03d8);
9567         MP_WritePhyUshort(sc, 0x19, 0x492b);
9568         MP_WritePhyUshort(sc, 0x15, 0x03d9);
9569         MP_WritePhyUshort(sc, 0x19, 0x4479);
9570         MP_WritePhyUshort(sc, 0x15, 0x03da);
9571         MP_WritePhyUshort(sc, 0x19, 0x7c09);
9572         MP_WritePhyUshort(sc, 0x15, 0x03db);
9573         MP_WritePhyUshort(sc, 0x19, 0x8203);
9574         MP_WritePhyUshort(sc, 0x15, 0x03dc);
9575         MP_WritePhyUshort(sc, 0x19, 0x4d48);
9576         MP_WritePhyUshort(sc, 0x15, 0x03dd);
9577         MP_WritePhyUshort(sc, 0x19, 0x33df);
9578         MP_WritePhyUshort(sc, 0x15, 0x03de);
9579         MP_WritePhyUshort(sc, 0x19, 0x4d40);
9580         MP_WritePhyUshort(sc, 0x15, 0x03df);
9581         MP_WritePhyUshort(sc, 0x19, 0xd64f);
9582         MP_WritePhyUshort(sc, 0x15, 0x03e0);
9583         MP_WritePhyUshort(sc, 0x19, 0x0017);
9584         MP_WritePhyUshort(sc, 0x15, 0x03e1);
9585         MP_WritePhyUshort(sc, 0x19, 0xbd17);
9586         MP_WritePhyUshort(sc, 0x15, 0x03e2);
9587         MP_WritePhyUshort(sc, 0x19, 0x9b03);
9588         MP_WritePhyUshort(sc, 0x15, 0x03e3);
9589         MP_WritePhyUshort(sc, 0x19, 0x7c20);
9590         MP_WritePhyUshort(sc, 0x15, 0x03e4);
9591         MP_WritePhyUshort(sc, 0x19, 0x4c20);
9592         MP_WritePhyUshort(sc, 0x15, 0x03e5);
9593         MP_WritePhyUshort(sc, 0x19, 0x88f5);
9594         MP_WritePhyUshort(sc, 0x15, 0x03e6);
9595         MP_WritePhyUshort(sc, 0x19, 0xc428);
9596         MP_WritePhyUshort(sc, 0x15, 0x03e7);
9597         MP_WritePhyUshort(sc, 0x19, 0x0008);
9598         MP_WritePhyUshort(sc, 0x15, 0x03e8);
9599         MP_WritePhyUshort(sc, 0x19, 0x9af2);
9600         MP_WritePhyUshort(sc, 0x15, 0x03e9);
9601         MP_WritePhyUshort(sc, 0x19, 0x7c12);
9602         MP_WritePhyUshort(sc, 0x15, 0x03ea);
9603         MP_WritePhyUshort(sc, 0x19, 0x4c52);
9604         MP_WritePhyUshort(sc, 0x15, 0x03eb);
9605         MP_WritePhyUshort(sc, 0x19, 0x4470);
9606         MP_WritePhyUshort(sc, 0x15, 0x03ec);
9607         MP_WritePhyUshort(sc, 0x19, 0x7c12);
9608         MP_WritePhyUshort(sc, 0x15, 0x03ed);
9609         MP_WritePhyUshort(sc, 0x19, 0x4c40);
9610         MP_WritePhyUshort(sc, 0x15, 0x03ee);
9611         MP_WritePhyUshort(sc, 0x19, 0x33da);
9612         MP_WritePhyUshort(sc, 0x15, 0x03ef);
9613         MP_WritePhyUshort(sc, 0x19, 0x3312);
9614         MP_WritePhyUshort(sc, 0x16, 0x0306);
9615         MP_WritePhyUshort(sc, 0x16, 0x0300);
9616         MP_WritePhyUshort(sc, 0x1f, 0x0000);
9617         MP_WritePhyUshort(sc, 0x17, 0x2179);
9618         MP_WritePhyUshort(sc, 0x1f, 0x0007);
9619         MP_WritePhyUshort(sc, 0x1e, 0x0040);
9620         MP_WritePhyUshort(sc, 0x18, 0x0645);
9621         MP_WritePhyUshort(sc, 0x19, 0xe200);
9622         MP_WritePhyUshort(sc, 0x18, 0x0655);
9623         MP_WritePhyUshort(sc, 0x19, 0x9000);
9624         MP_WritePhyUshort(sc, 0x18, 0x0d05);
9625         MP_WritePhyUshort(sc, 0x19, 0xbe00);
9626         MP_WritePhyUshort(sc, 0x18, 0x0d15);
9627         MP_WritePhyUshort(sc, 0x19, 0xd300);
9628         MP_WritePhyUshort(sc, 0x18, 0x0d25);
9629         MP_WritePhyUshort(sc, 0x19, 0xfe00);
9630         MP_WritePhyUshort(sc, 0x18, 0x0d35);
9631         MP_WritePhyUshort(sc, 0x19, 0x4000);
9632         MP_WritePhyUshort(sc, 0x18, 0x0d45);
9633         MP_WritePhyUshort(sc, 0x19, 0x7f00);
9634         MP_WritePhyUshort(sc, 0x18, 0x0d55);
9635         MP_WritePhyUshort(sc, 0x19, 0x1000);
9636         MP_WritePhyUshort(sc, 0x18, 0x0d65);
9637         MP_WritePhyUshort(sc, 0x19, 0x0000);
9638         MP_WritePhyUshort(sc, 0x18, 0x0d75);
9639         MP_WritePhyUshort(sc, 0x19, 0x8200);
9640         MP_WritePhyUshort(sc, 0x18, 0x0d85);
9641         MP_WritePhyUshort(sc, 0x19, 0x0000);
9642         MP_WritePhyUshort(sc, 0x18, 0x0d95);
9643         MP_WritePhyUshort(sc, 0x19, 0x7000);
9644         MP_WritePhyUshort(sc, 0x18, 0x0da5);
9645         MP_WritePhyUshort(sc, 0x19, 0x0f00);
9646         MP_WritePhyUshort(sc, 0x18, 0x0db5);
9647         MP_WritePhyUshort(sc, 0x19, 0x0100);
9648         MP_WritePhyUshort(sc, 0x18, 0x0dc5);
9649         MP_WritePhyUshort(sc, 0x19, 0x9b00);
9650         MP_WritePhyUshort(sc, 0x18, 0x0dd5);
9651         MP_WritePhyUshort(sc, 0x19, 0x7f00);
9652         MP_WritePhyUshort(sc, 0x18, 0x0de5);
9653         MP_WritePhyUshort(sc, 0x19, 0xe000);
9654         MP_WritePhyUshort(sc, 0x18, 0x0df5);
9655         MP_WritePhyUshort(sc, 0x19, 0xef00);
9656         MP_WritePhyUshort(sc, 0x18, 0x16d5);
9657         MP_WritePhyUshort(sc, 0x19, 0xe200);
9658         MP_WritePhyUshort(sc, 0x18, 0x16e5);
9659         MP_WritePhyUshort(sc, 0x19, 0xab00);
9660         MP_WritePhyUshort(sc, 0x18, 0x2904);
9661         MP_WritePhyUshort(sc, 0x19, 0x4000);
9662         MP_WritePhyUshort(sc, 0x18, 0x2914);
9663         MP_WritePhyUshort(sc, 0x19, 0x7f00);
9664         MP_WritePhyUshort(sc, 0x18, 0x2924);
9665         MP_WritePhyUshort(sc, 0x19, 0x0100);
9666         MP_WritePhyUshort(sc, 0x18, 0x2934);
9667         MP_WritePhyUshort(sc, 0x19, 0x2000);
9668         MP_WritePhyUshort(sc, 0x18, 0x2944);
9669         MP_WritePhyUshort(sc, 0x19, 0x0000);
9670         MP_WritePhyUshort(sc, 0x18, 0x2954);
9671         MP_WritePhyUshort(sc, 0x19, 0x4600);
9672         MP_WritePhyUshort(sc, 0x18, 0x2964);
9673         MP_WritePhyUshort(sc, 0x19, 0xfc00);
9674         MP_WritePhyUshort(sc, 0x18, 0x2974);
9675         MP_WritePhyUshort(sc, 0x19, 0x0000);
9676         MP_WritePhyUshort(sc, 0x18, 0x2984);
9677         MP_WritePhyUshort(sc, 0x19, 0x5000);
9678         MP_WritePhyUshort(sc, 0x18, 0x2994);
9679         MP_WritePhyUshort(sc, 0x19, 0x9d00);
9680         MP_WritePhyUshort(sc, 0x18, 0x29a4);
9681         MP_WritePhyUshort(sc, 0x19, 0xff00);
9682         MP_WritePhyUshort(sc, 0x18, 0x29b4);
9683         MP_WritePhyUshort(sc, 0x19, 0x4000);
9684         MP_WritePhyUshort(sc, 0x18, 0x29c4);
9685         MP_WritePhyUshort(sc, 0x19, 0x7f00);
9686         MP_WritePhyUshort(sc, 0x18, 0x29d4);
9687         MP_WritePhyUshort(sc, 0x19, 0x0000);
9688         MP_WritePhyUshort(sc, 0x18, 0x29e4);
9689         MP_WritePhyUshort(sc, 0x19, 0x2000);
9690         MP_WritePhyUshort(sc, 0x18, 0x29f4);
9691         MP_WritePhyUshort(sc, 0x19, 0x0000);
9692         MP_WritePhyUshort(sc, 0x18, 0x2a04);
9693         MP_WritePhyUshort(sc, 0x19, 0xe600);
9694         MP_WritePhyUshort(sc, 0x18, 0x2a14);
9695         MP_WritePhyUshort(sc, 0x19, 0xff00);
9696         MP_WritePhyUshort(sc, 0x18, 0x2a24);
9697         MP_WritePhyUshort(sc, 0x19, 0x0000);
9698         MP_WritePhyUshort(sc, 0x18, 0x2a34);
9699         MP_WritePhyUshort(sc, 0x19, 0x5000);
9700         MP_WritePhyUshort(sc, 0x18, 0x2a44);
9701         MP_WritePhyUshort(sc, 0x19, 0x8500);
9702         MP_WritePhyUshort(sc, 0x18, 0x2a54);
9703         MP_WritePhyUshort(sc, 0x19, 0x7f00);
9704         MP_WritePhyUshort(sc, 0x18, 0x2a64);
9705         MP_WritePhyUshort(sc, 0x19, 0xac00);
9706         MP_WritePhyUshort(sc, 0x18, 0x2a74);
9707         MP_WritePhyUshort(sc, 0x19, 0x0800);
9708         MP_WritePhyUshort(sc, 0x18, 0x2a84);
9709         MP_WritePhyUshort(sc, 0x19, 0xfc00);
9710         MP_WritePhyUshort(sc, 0x18, 0x2a94);
9711         MP_WritePhyUshort(sc, 0x19, 0xe000);
9712         MP_WritePhyUshort(sc, 0x18, 0x2aa4);
9713         MP_WritePhyUshort(sc, 0x19, 0x7400);
9714         MP_WritePhyUshort(sc, 0x18, 0x2ab4);
9715         MP_WritePhyUshort(sc, 0x19, 0x4000);
9716         MP_WritePhyUshort(sc, 0x18, 0x2ac4);
9717         MP_WritePhyUshort(sc, 0x19, 0x7f00);
9718         MP_WritePhyUshort(sc, 0x18, 0x2ad4);
9719         MP_WritePhyUshort(sc, 0x19, 0x0100);
9720         MP_WritePhyUshort(sc, 0x18, 0x2ae4);
9721         MP_WritePhyUshort(sc, 0x19, 0xff00);
9722         MP_WritePhyUshort(sc, 0x18, 0x2af4);
9723         MP_WritePhyUshort(sc, 0x19, 0x0000);
9724         MP_WritePhyUshort(sc, 0x18, 0x2b04);
9725         MP_WritePhyUshort(sc, 0x19, 0x4400);
9726         MP_WritePhyUshort(sc, 0x18, 0x2b14);
9727         MP_WritePhyUshort(sc, 0x19, 0xfc00);
9728         MP_WritePhyUshort(sc, 0x18, 0x2b24);
9729         MP_WritePhyUshort(sc, 0x19, 0x0000);
9730         MP_WritePhyUshort(sc, 0x18, 0x2b34);
9731         MP_WritePhyUshort(sc, 0x19, 0x4000);
9732         MP_WritePhyUshort(sc, 0x18, 0x2b44);
9733         MP_WritePhyUshort(sc, 0x19, 0x9d00);
9734         MP_WritePhyUshort(sc, 0x18, 0x2b54);
9735         MP_WritePhyUshort(sc, 0x19, 0xff00);
9736         MP_WritePhyUshort(sc, 0x18, 0x2b64);
9737         MP_WritePhyUshort(sc, 0x19, 0x4000);
9738         MP_WritePhyUshort(sc, 0x18, 0x2b74);
9739         MP_WritePhyUshort(sc, 0x19, 0x7f00);
9740         MP_WritePhyUshort(sc, 0x18, 0x2b84);
9741         MP_WritePhyUshort(sc, 0x19, 0x0000);
9742         MP_WritePhyUshort(sc, 0x18, 0x2b94);
9743         MP_WritePhyUshort(sc, 0x19, 0xff00);
9744         MP_WritePhyUshort(sc, 0x18, 0x2ba4);
9745         MP_WritePhyUshort(sc, 0x19, 0x0000);
9746         MP_WritePhyUshort(sc, 0x18, 0x2bb4);
9747         MP_WritePhyUshort(sc, 0x19, 0xfc00);
9748         MP_WritePhyUshort(sc, 0x18, 0x2bc4);
9749         MP_WritePhyUshort(sc, 0x19, 0xff00);
9750         MP_WritePhyUshort(sc, 0x18, 0x2bd4);
9751         MP_WritePhyUshort(sc, 0x19, 0x0000);
9752         MP_WritePhyUshort(sc, 0x18, 0x2be4);
9753         MP_WritePhyUshort(sc, 0x19, 0x4000);
9754         MP_WritePhyUshort(sc, 0x18, 0x2bf4);
9755         MP_WritePhyUshort(sc, 0x19, 0x8900);
9756         MP_WritePhyUshort(sc, 0x18, 0x2c04);
9757         MP_WritePhyUshort(sc, 0x19, 0x8300);
9758         MP_WritePhyUshort(sc, 0x18, 0x2c14);
9759         MP_WritePhyUshort(sc, 0x19, 0xe000);
9760         MP_WritePhyUshort(sc, 0x18, 0x2c24);
9761         MP_WritePhyUshort(sc, 0x19, 0x0000);
9762         MP_WritePhyUshort(sc, 0x18, 0x2c34);
9763         MP_WritePhyUshort(sc, 0x19, 0xac00);
9764         MP_WritePhyUshort(sc, 0x18, 0x2c44);
9765         MP_WritePhyUshort(sc, 0x19, 0x0800);
9766         MP_WritePhyUshort(sc, 0x18, 0x2c54);
9767         MP_WritePhyUshort(sc, 0x19, 0xfa00);
9768         MP_WritePhyUshort(sc, 0x18, 0x2c64);
9769         MP_WritePhyUshort(sc, 0x19, 0xe100);
9770         MP_WritePhyUshort(sc, 0x18, 0x2c74);
9771         MP_WritePhyUshort(sc, 0x19, 0x7f00);
9772         MP_WritePhyUshort(sc, 0x18, 0x0001);
9773         MP_WritePhyUshort(sc, 0x1f, 0x0000);
9774         MP_WritePhyUshort(sc, 0x17, 0x2100);
9775         MP_WritePhyUshort(sc, 0x1f, 0x0005);
9776         MP_WritePhyUshort(sc, 0x05, 0xfff6);
9777         MP_WritePhyUshort(sc, 0x06, 0x0080);
9778         MP_WritePhyUshort(sc, 0x05, 0x8b88);
9779         MP_WritePhyUshort(sc, 0x06, 0x0000);
9780         MP_WritePhyUshort(sc, 0x06, 0x0000);
9781         MP_WritePhyUshort(sc, 0x06, 0x0000);
9782         MP_WritePhyUshort(sc, 0x06, 0x0000);
9783         MP_WritePhyUshort(sc, 0x05, 0x8000);
9784         MP_WritePhyUshort(sc, 0x06, 0xd480);
9785         MP_WritePhyUshort(sc, 0x06, 0xc1e4);
9786         MP_WritePhyUshort(sc, 0x06, 0x8b9a);
9787         MP_WritePhyUshort(sc, 0x06, 0xe58b);
9788         MP_WritePhyUshort(sc, 0x06, 0x9bee);
9789         MP_WritePhyUshort(sc, 0x06, 0x8b83);
9790         MP_WritePhyUshort(sc, 0x06, 0x41bf);
9791         MP_WritePhyUshort(sc, 0x06, 0x8b88);
9792         MP_WritePhyUshort(sc, 0x06, 0xec00);
9793         MP_WritePhyUshort(sc, 0x06, 0x19a9);
9794         MP_WritePhyUshort(sc, 0x06, 0x8b90);
9795         MP_WritePhyUshort(sc, 0x06, 0xf9ee);
9796         MP_WritePhyUshort(sc, 0x06, 0xfff6);
9797         MP_WritePhyUshort(sc, 0x06, 0x00ee);
9798         MP_WritePhyUshort(sc, 0x06, 0xfff7);
9799         MP_WritePhyUshort(sc, 0x06, 0xffe0);
9800         MP_WritePhyUshort(sc, 0x06, 0xe140);
9801         MP_WritePhyUshort(sc, 0x06, 0xe1e1);
9802         MP_WritePhyUshort(sc, 0x06, 0x41f7);
9803         MP_WritePhyUshort(sc, 0x06, 0x2ff6);
9804         MP_WritePhyUshort(sc, 0x06, 0x28e4);
9805         MP_WritePhyUshort(sc, 0x06, 0xe140);
9806         MP_WritePhyUshort(sc, 0x06, 0xe5e1);
9807         MP_WritePhyUshort(sc, 0x06, 0x41f7);
9808         MP_WritePhyUshort(sc, 0x06, 0x0002);
9809         MP_WritePhyUshort(sc, 0x06, 0x020c);
9810         MP_WritePhyUshort(sc, 0x06, 0x0202);
9811         MP_WritePhyUshort(sc, 0x06, 0x1d02);
9812         MP_WritePhyUshort(sc, 0x06, 0x0230);
9813         MP_WritePhyUshort(sc, 0x06, 0x0202);
9814         MP_WritePhyUshort(sc, 0x06, 0x4002);
9815         MP_WritePhyUshort(sc, 0x06, 0x028b);
9816         MP_WritePhyUshort(sc, 0x06, 0x0280);
9817         MP_WritePhyUshort(sc, 0x06, 0x6c02);
9818         MP_WritePhyUshort(sc, 0x06, 0x8085);
9819         MP_WritePhyUshort(sc, 0x06, 0xe08b);
9820         MP_WritePhyUshort(sc, 0x06, 0x88e1);
9821         MP_WritePhyUshort(sc, 0x06, 0x8b89);
9822         MP_WritePhyUshort(sc, 0x06, 0x1e01);
9823         MP_WritePhyUshort(sc, 0x06, 0xe18b);
9824         MP_WritePhyUshort(sc, 0x06, 0x8a1e);
9825         MP_WritePhyUshort(sc, 0x06, 0x01e1);
9826         MP_WritePhyUshort(sc, 0x06, 0x8b8b);
9827         MP_WritePhyUshort(sc, 0x06, 0x1e01);
9828         MP_WritePhyUshort(sc, 0x06, 0xe18b);
9829         MP_WritePhyUshort(sc, 0x06, 0x8c1e);
9830         MP_WritePhyUshort(sc, 0x06, 0x01e1);
9831         MP_WritePhyUshort(sc, 0x06, 0x8b8d);
9832         MP_WritePhyUshort(sc, 0x06, 0x1e01);
9833         MP_WritePhyUshort(sc, 0x06, 0xe18b);
9834         MP_WritePhyUshort(sc, 0x06, 0x8e1e);
9835         MP_WritePhyUshort(sc, 0x06, 0x01a0);
9836         MP_WritePhyUshort(sc, 0x06, 0x00c7);
9837         MP_WritePhyUshort(sc, 0x06, 0xaec3);
9838         MP_WritePhyUshort(sc, 0x06, 0xf8e0);
9839         MP_WritePhyUshort(sc, 0x06, 0x8b8d);
9840         MP_WritePhyUshort(sc, 0x06, 0xad20);
9841         MP_WritePhyUshort(sc, 0x06, 0x10ee);
9842         MP_WritePhyUshort(sc, 0x06, 0x8b8d);
9843         MP_WritePhyUshort(sc, 0x06, 0x0002);
9844         MP_WritePhyUshort(sc, 0x06, 0x1310);
9845         MP_WritePhyUshort(sc, 0x06, 0x021f);
9846         MP_WritePhyUshort(sc, 0x06, 0x9d02);
9847         MP_WritePhyUshort(sc, 0x06, 0x1f0c);
9848         MP_WritePhyUshort(sc, 0x06, 0x0227);
9849         MP_WritePhyUshort(sc, 0x06, 0x49fc);
9850         MP_WritePhyUshort(sc, 0x06, 0x04f8);
9851         MP_WritePhyUshort(sc, 0x06, 0xe08b);
9852         MP_WritePhyUshort(sc, 0x06, 0x8ead);
9853         MP_WritePhyUshort(sc, 0x06, 0x200b);
9854         MP_WritePhyUshort(sc, 0x06, 0xf620);
9855         MP_WritePhyUshort(sc, 0x06, 0xe48b);
9856         MP_WritePhyUshort(sc, 0x06, 0x8e02);
9857         MP_WritePhyUshort(sc, 0x06, 0x830e);
9858         MP_WritePhyUshort(sc, 0x06, 0x021b);
9859         MP_WritePhyUshort(sc, 0x06, 0x67ad);
9860         MP_WritePhyUshort(sc, 0x06, 0x2211);
9861         MP_WritePhyUshort(sc, 0x06, 0xf622);
9862         MP_WritePhyUshort(sc, 0x06, 0xe48b);
9863         MP_WritePhyUshort(sc, 0x06, 0x8e02);
9864         MP_WritePhyUshort(sc, 0x06, 0x2ba5);
9865         MP_WritePhyUshort(sc, 0x06, 0x022a);
9866         MP_WritePhyUshort(sc, 0x06, 0x2402);
9867         MP_WritePhyUshort(sc, 0x06, 0x80c6);
9868         MP_WritePhyUshort(sc, 0x06, 0x022a);
9869         MP_WritePhyUshort(sc, 0x06, 0xf0ad);
9870         MP_WritePhyUshort(sc, 0x06, 0x2511);
9871         MP_WritePhyUshort(sc, 0x06, 0xf625);
9872         MP_WritePhyUshort(sc, 0x06, 0xe48b);
9873         MP_WritePhyUshort(sc, 0x06, 0x8e02);
9874         MP_WritePhyUshort(sc, 0x06, 0x8226);
9875         MP_WritePhyUshort(sc, 0x06, 0x0204);
9876         MP_WritePhyUshort(sc, 0x06, 0x0302);
9877         MP_WritePhyUshort(sc, 0x06, 0x19cc);
9878         MP_WritePhyUshort(sc, 0x06, 0x022b);
9879         MP_WritePhyUshort(sc, 0x06, 0x5bfc);
9880         MP_WritePhyUshort(sc, 0x06, 0x04ee);
9881         MP_WritePhyUshort(sc, 0x06, 0x8b8d);
9882         MP_WritePhyUshort(sc, 0x06, 0x0105);
9883         MP_WritePhyUshort(sc, 0x06, 0xf8e0);
9884         MP_WritePhyUshort(sc, 0x06, 0x8b83);
9885         MP_WritePhyUshort(sc, 0x06, 0xad24);
9886         MP_WritePhyUshort(sc, 0x06, 0x44e0);
9887         MP_WritePhyUshort(sc, 0x06, 0xe022);
9888         MP_WritePhyUshort(sc, 0x06, 0xe1e0);
9889         MP_WritePhyUshort(sc, 0x06, 0x23ad);
9890         MP_WritePhyUshort(sc, 0x06, 0x223b);
9891         MP_WritePhyUshort(sc, 0x06, 0xe08a);
9892         MP_WritePhyUshort(sc, 0x06, 0xbea0);
9893         MP_WritePhyUshort(sc, 0x06, 0x0005);
9894         MP_WritePhyUshort(sc, 0x06, 0x0228);
9895         MP_WritePhyUshort(sc, 0x06, 0xdeae);
9896         MP_WritePhyUshort(sc, 0x06, 0x42a0);
9897         MP_WritePhyUshort(sc, 0x06, 0x0105);
9898         MP_WritePhyUshort(sc, 0x06, 0x0228);
9899         MP_WritePhyUshort(sc, 0x06, 0xf1ae);
9900         MP_WritePhyUshort(sc, 0x06, 0x3aa0);
9901         MP_WritePhyUshort(sc, 0x06, 0x0205);
9902         MP_WritePhyUshort(sc, 0x06, 0x0281);
9903         MP_WritePhyUshort(sc, 0x06, 0x25ae);
9904         MP_WritePhyUshort(sc, 0x06, 0x32a0);
9905         MP_WritePhyUshort(sc, 0x06, 0x0305);
9906         MP_WritePhyUshort(sc, 0x06, 0x0229);
9907         MP_WritePhyUshort(sc, 0x06, 0x9aae);
9908         MP_WritePhyUshort(sc, 0x06, 0x2aa0);
9909         MP_WritePhyUshort(sc, 0x06, 0x0405);
9910         MP_WritePhyUshort(sc, 0x06, 0x0229);
9911         MP_WritePhyUshort(sc, 0x06, 0xaeae);
9912         MP_WritePhyUshort(sc, 0x06, 0x22a0);
9913         MP_WritePhyUshort(sc, 0x06, 0x0505);
9914         MP_WritePhyUshort(sc, 0x06, 0x0229);
9915         MP_WritePhyUshort(sc, 0x06, 0xd7ae);
9916         MP_WritePhyUshort(sc, 0x06, 0x1aa0);
9917         MP_WritePhyUshort(sc, 0x06, 0x0605);
9918         MP_WritePhyUshort(sc, 0x06, 0x0229);
9919         MP_WritePhyUshort(sc, 0x06, 0xfeae);
9920         MP_WritePhyUshort(sc, 0x06, 0x12ee);
9921         MP_WritePhyUshort(sc, 0x06, 0x8ac0);
9922         MP_WritePhyUshort(sc, 0x06, 0x00ee);
9923         MP_WritePhyUshort(sc, 0x06, 0x8ac1);
9924         MP_WritePhyUshort(sc, 0x06, 0x00ee);
9925         MP_WritePhyUshort(sc, 0x06, 0x8ac6);
9926         MP_WritePhyUshort(sc, 0x06, 0x00ee);
9927         MP_WritePhyUshort(sc, 0x06, 0x8abe);
9928         MP_WritePhyUshort(sc, 0x06, 0x00ae);
9929         MP_WritePhyUshort(sc, 0x06, 0x00fc);
9930         MP_WritePhyUshort(sc, 0x06, 0x04f8);
9931         MP_WritePhyUshort(sc, 0x06, 0x022a);
9932         MP_WritePhyUshort(sc, 0x06, 0x67e0);
9933         MP_WritePhyUshort(sc, 0x06, 0xe022);
9934         MP_WritePhyUshort(sc, 0x06, 0xe1e0);
9935         MP_WritePhyUshort(sc, 0x06, 0x230d);
9936         MP_WritePhyUshort(sc, 0x06, 0x0658);
9937         MP_WritePhyUshort(sc, 0x06, 0x03a0);
9938         MP_WritePhyUshort(sc, 0x06, 0x0202);
9939         MP_WritePhyUshort(sc, 0x06, 0xae2d);
9940         MP_WritePhyUshort(sc, 0x06, 0xa001);
9941         MP_WritePhyUshort(sc, 0x06, 0x02ae);
9942         MP_WritePhyUshort(sc, 0x06, 0x2da0);
9943         MP_WritePhyUshort(sc, 0x06, 0x004d);
9944         MP_WritePhyUshort(sc, 0x06, 0xe0e2);
9945         MP_WritePhyUshort(sc, 0x06, 0x00e1);
9946         MP_WritePhyUshort(sc, 0x06, 0xe201);
9947         MP_WritePhyUshort(sc, 0x06, 0xad24);
9948         MP_WritePhyUshort(sc, 0x06, 0x44e0);
9949         MP_WritePhyUshort(sc, 0x06, 0x8ac2);
9950         MP_WritePhyUshort(sc, 0x06, 0xe48a);
9951         MP_WritePhyUshort(sc, 0x06, 0xc4e0);
9952         MP_WritePhyUshort(sc, 0x06, 0x8ac3);
9953         MP_WritePhyUshort(sc, 0x06, 0xe48a);
9954         MP_WritePhyUshort(sc, 0x06, 0xc5ee);
9955         MP_WritePhyUshort(sc, 0x06, 0x8abe);
9956         MP_WritePhyUshort(sc, 0x06, 0x03e0);
9957         MP_WritePhyUshort(sc, 0x06, 0x8b83);
9958         MP_WritePhyUshort(sc, 0x06, 0xad25);
9959         MP_WritePhyUshort(sc, 0x06, 0x3aee);
9960         MP_WritePhyUshort(sc, 0x06, 0x8abe);
9961         MP_WritePhyUshort(sc, 0x06, 0x05ae);
9962         MP_WritePhyUshort(sc, 0x06, 0x34e0);
9963         MP_WritePhyUshort(sc, 0x06, 0x8ace);
9964         MP_WritePhyUshort(sc, 0x06, 0xae03);
9965         MP_WritePhyUshort(sc, 0x06, 0xe08a);
9966         MP_WritePhyUshort(sc, 0x06, 0xcfe1);
9967         MP_WritePhyUshort(sc, 0x06, 0x8ac2);
9968         MP_WritePhyUshort(sc, 0x06, 0x4905);
9969         MP_WritePhyUshort(sc, 0x06, 0xe58a);
9970         MP_WritePhyUshort(sc, 0x06, 0xc4e1);
9971         MP_WritePhyUshort(sc, 0x06, 0x8ac3);
9972         MP_WritePhyUshort(sc, 0x06, 0x4905);
9973         MP_WritePhyUshort(sc, 0x06, 0xe58a);
9974         MP_WritePhyUshort(sc, 0x06, 0xc5ee);
9975         MP_WritePhyUshort(sc, 0x06, 0x8abe);
9976         MP_WritePhyUshort(sc, 0x06, 0x0502);
9977         MP_WritePhyUshort(sc, 0x06, 0x2ab6);
9978         MP_WritePhyUshort(sc, 0x06, 0xac20);
9979         MP_WritePhyUshort(sc, 0x06, 0x1202);
9980         MP_WritePhyUshort(sc, 0x06, 0x819b);
9981         MP_WritePhyUshort(sc, 0x06, 0xac20);
9982         MP_WritePhyUshort(sc, 0x06, 0x0cee);
9983         MP_WritePhyUshort(sc, 0x06, 0x8ac1);
9984         MP_WritePhyUshort(sc, 0x06, 0x00ee);
9985         MP_WritePhyUshort(sc, 0x06, 0x8ac6);
9986         MP_WritePhyUshort(sc, 0x06, 0x00ee);
9987         MP_WritePhyUshort(sc, 0x06, 0x8abe);
9988         MP_WritePhyUshort(sc, 0x06, 0x02fc);
9989         MP_WritePhyUshort(sc, 0x06, 0x04d0);
9990         MP_WritePhyUshort(sc, 0x06, 0x0002);
9991         MP_WritePhyUshort(sc, 0x06, 0x81ad);
9992         MP_WritePhyUshort(sc, 0x06, 0x590f);
9993         MP_WritePhyUshort(sc, 0x06, 0x3902);
9994         MP_WritePhyUshort(sc, 0x06, 0xaa04);
9995         MP_WritePhyUshort(sc, 0x06, 0xd001);
9996         MP_WritePhyUshort(sc, 0x06, 0xae02);
9997         MP_WritePhyUshort(sc, 0x06, 0xd000);
9998         MP_WritePhyUshort(sc, 0x06, 0x04f9);
9999         MP_WritePhyUshort(sc, 0x06, 0xfae2);
10000         MP_WritePhyUshort(sc, 0x06, 0xe2d2);
10001         MP_WritePhyUshort(sc, 0x06, 0xe3e2);
10002         MP_WritePhyUshort(sc, 0x06, 0xd3f9);
10003         MP_WritePhyUshort(sc, 0x06, 0x5af7);
10004         MP_WritePhyUshort(sc, 0x06, 0xe6e2);
10005         MP_WritePhyUshort(sc, 0x06, 0xd2e7);
10006         MP_WritePhyUshort(sc, 0x06, 0xe2d3);
10007         MP_WritePhyUshort(sc, 0x06, 0xe2e0);
10008         MP_WritePhyUshort(sc, 0x06, 0x2ce3);
10009         MP_WritePhyUshort(sc, 0x06, 0xe02d);
10010         MP_WritePhyUshort(sc, 0x06, 0xf95b);
10011         MP_WritePhyUshort(sc, 0x06, 0xe01e);
10012         MP_WritePhyUshort(sc, 0x06, 0x30e6);
10013         MP_WritePhyUshort(sc, 0x06, 0xe02c);
10014         MP_WritePhyUshort(sc, 0x06, 0xe7e0);
10015         MP_WritePhyUshort(sc, 0x06, 0x2de2);
10016         MP_WritePhyUshort(sc, 0x06, 0xe2cc);
10017         MP_WritePhyUshort(sc, 0x06, 0xe3e2);
10018         MP_WritePhyUshort(sc, 0x06, 0xcdf9);
10019         MP_WritePhyUshort(sc, 0x06, 0x5a0f);
10020         MP_WritePhyUshort(sc, 0x06, 0x6a50);
10021         MP_WritePhyUshort(sc, 0x06, 0xe6e2);
10022         MP_WritePhyUshort(sc, 0x06, 0xcce7);
10023         MP_WritePhyUshort(sc, 0x06, 0xe2cd);
10024         MP_WritePhyUshort(sc, 0x06, 0xe0e0);
10025         MP_WritePhyUshort(sc, 0x06, 0x3ce1);
10026         MP_WritePhyUshort(sc, 0x06, 0xe03d);
10027         MP_WritePhyUshort(sc, 0x06, 0xef64);
10028         MP_WritePhyUshort(sc, 0x06, 0xfde0);
10029         MP_WritePhyUshort(sc, 0x06, 0xe2cc);
10030         MP_WritePhyUshort(sc, 0x06, 0xe1e2);
10031         MP_WritePhyUshort(sc, 0x06, 0xcd58);
10032         MP_WritePhyUshort(sc, 0x06, 0x0f5a);
10033         MP_WritePhyUshort(sc, 0x06, 0xf01e);
10034         MP_WritePhyUshort(sc, 0x06, 0x02e4);
10035         MP_WritePhyUshort(sc, 0x06, 0xe2cc);
10036         MP_WritePhyUshort(sc, 0x06, 0xe5e2);
10037         MP_WritePhyUshort(sc, 0x06, 0xcdfd);
10038         MP_WritePhyUshort(sc, 0x06, 0xe0e0);
10039         MP_WritePhyUshort(sc, 0x06, 0x2ce1);
10040         MP_WritePhyUshort(sc, 0x06, 0xe02d);
10041         MP_WritePhyUshort(sc, 0x06, 0x59e0);
10042         MP_WritePhyUshort(sc, 0x06, 0x5b1f);
10043         MP_WritePhyUshort(sc, 0x06, 0x1e13);
10044         MP_WritePhyUshort(sc, 0x06, 0xe4e0);
10045         MP_WritePhyUshort(sc, 0x06, 0x2ce5);
10046         MP_WritePhyUshort(sc, 0x06, 0xe02d);
10047         MP_WritePhyUshort(sc, 0x06, 0xfde0);
10048         MP_WritePhyUshort(sc, 0x06, 0xe2d2);
10049         MP_WritePhyUshort(sc, 0x06, 0xe1e2);
10050         MP_WritePhyUshort(sc, 0x06, 0xd358);
10051         MP_WritePhyUshort(sc, 0x06, 0xf75a);
10052         MP_WritePhyUshort(sc, 0x06, 0x081e);
10053         MP_WritePhyUshort(sc, 0x06, 0x02e4);
10054         MP_WritePhyUshort(sc, 0x06, 0xe2d2);
10055         MP_WritePhyUshort(sc, 0x06, 0xe5e2);
10056         MP_WritePhyUshort(sc, 0x06, 0xd3ef);
10057         MP_WritePhyUshort(sc, 0x06, 0x46fe);
10058         MP_WritePhyUshort(sc, 0x06, 0xfd04);
10059         MP_WritePhyUshort(sc, 0x06, 0xf8f9);
10060         MP_WritePhyUshort(sc, 0x06, 0xfaef);
10061         MP_WritePhyUshort(sc, 0x06, 0x69e0);
10062         MP_WritePhyUshort(sc, 0x06, 0xe022);
10063         MP_WritePhyUshort(sc, 0x06, 0xe1e0);
10064         MP_WritePhyUshort(sc, 0x06, 0x2358);
10065         MP_WritePhyUshort(sc, 0x06, 0xc4e1);
10066         MP_WritePhyUshort(sc, 0x06, 0x8b6e);
10067         MP_WritePhyUshort(sc, 0x06, 0x1f10);
10068         MP_WritePhyUshort(sc, 0x06, 0x9e58);
10069         MP_WritePhyUshort(sc, 0x06, 0xe48b);
10070         MP_WritePhyUshort(sc, 0x06, 0x6ead);
10071         MP_WritePhyUshort(sc, 0x06, 0x2222);
10072         MP_WritePhyUshort(sc, 0x06, 0xac27);
10073         MP_WritePhyUshort(sc, 0x06, 0x55ac);
10074         MP_WritePhyUshort(sc, 0x06, 0x2602);
10075         MP_WritePhyUshort(sc, 0x06, 0xae1a);
10076         MP_WritePhyUshort(sc, 0x06, 0xd106);
10077         MP_WritePhyUshort(sc, 0x06, 0xbf3b);
10078         MP_WritePhyUshort(sc, 0x06, 0xba02);
10079         MP_WritePhyUshort(sc, 0x06, 0x2dc1);
10080         MP_WritePhyUshort(sc, 0x06, 0xd107);
10081         MP_WritePhyUshort(sc, 0x06, 0xbf3b);
10082         MP_WritePhyUshort(sc, 0x06, 0xbd02);
10083         MP_WritePhyUshort(sc, 0x06, 0x2dc1);
10084         MP_WritePhyUshort(sc, 0x06, 0xd107);
10085         MP_WritePhyUshort(sc, 0x06, 0xbf3b);
10086         MP_WritePhyUshort(sc, 0x06, 0xc002);
10087         MP_WritePhyUshort(sc, 0x06, 0x2dc1);
10088         MP_WritePhyUshort(sc, 0x06, 0xae30);
10089         MP_WritePhyUshort(sc, 0x06, 0xd103);
10090         MP_WritePhyUshort(sc, 0x06, 0xbf3b);
10091         MP_WritePhyUshort(sc, 0x06, 0xc302);
10092         MP_WritePhyUshort(sc, 0x06, 0x2dc1);
10093         MP_WritePhyUshort(sc, 0x06, 0xd100);
10094         MP_WritePhyUshort(sc, 0x06, 0xbf3b);
10095         MP_WritePhyUshort(sc, 0x06, 0xc602);
10096         MP_WritePhyUshort(sc, 0x06, 0x2dc1);
10097         MP_WritePhyUshort(sc, 0x06, 0xd100);
10098         MP_WritePhyUshort(sc, 0x06, 0xbf82);
10099         MP_WritePhyUshort(sc, 0x06, 0xca02);
10100         MP_WritePhyUshort(sc, 0x06, 0x2dc1);
10101         MP_WritePhyUshort(sc, 0x06, 0xd10f);
10102         MP_WritePhyUshort(sc, 0x06, 0xbf3b);
10103         MP_WritePhyUshort(sc, 0x06, 0xba02);
10104         MP_WritePhyUshort(sc, 0x06, 0x2dc1);
10105         MP_WritePhyUshort(sc, 0x06, 0xd101);
10106         MP_WritePhyUshort(sc, 0x06, 0xbf3b);
10107         MP_WritePhyUshort(sc, 0x06, 0xbd02);
10108         MP_WritePhyUshort(sc, 0x06, 0x2dc1);
10109         MP_WritePhyUshort(sc, 0x06, 0xd101);
10110         MP_WritePhyUshort(sc, 0x06, 0xbf3b);
10111         MP_WritePhyUshort(sc, 0x06, 0xc002);
10112         MP_WritePhyUshort(sc, 0x06, 0x2dc1);
10113         MP_WritePhyUshort(sc, 0x06, 0xef96);
10114         MP_WritePhyUshort(sc, 0x06, 0xfefd);
10115         MP_WritePhyUshort(sc, 0x06, 0xfc04);
10116         MP_WritePhyUshort(sc, 0x06, 0xd100);
10117         MP_WritePhyUshort(sc, 0x06, 0xbf3b);
10118         MP_WritePhyUshort(sc, 0x06, 0xc302);
10119         MP_WritePhyUshort(sc, 0x06, 0x2dc1);
10120         MP_WritePhyUshort(sc, 0x06, 0xd011);
10121         MP_WritePhyUshort(sc, 0x06, 0x022b);
10122         MP_WritePhyUshort(sc, 0x06, 0xfb59);
10123         MP_WritePhyUshort(sc, 0x06, 0x03ef);
10124         MP_WritePhyUshort(sc, 0x06, 0x01d1);
10125         MP_WritePhyUshort(sc, 0x06, 0x00a0);
10126         MP_WritePhyUshort(sc, 0x06, 0x0002);
10127         MP_WritePhyUshort(sc, 0x06, 0xd101);
10128         MP_WritePhyUshort(sc, 0x06, 0xbf3b);
10129         MP_WritePhyUshort(sc, 0x06, 0xc602);
10130         MP_WritePhyUshort(sc, 0x06, 0x2dc1);
10131         MP_WritePhyUshort(sc, 0x06, 0xd111);
10132         MP_WritePhyUshort(sc, 0x06, 0xad20);
10133         MP_WritePhyUshort(sc, 0x06, 0x020c);
10134         MP_WritePhyUshort(sc, 0x06, 0x11ad);
10135         MP_WritePhyUshort(sc, 0x06, 0x2102);
10136         MP_WritePhyUshort(sc, 0x06, 0x0c12);
10137         MP_WritePhyUshort(sc, 0x06, 0xbf82);
10138         MP_WritePhyUshort(sc, 0x06, 0xca02);
10139         MP_WritePhyUshort(sc, 0x06, 0x2dc1);
10140         MP_WritePhyUshort(sc, 0x06, 0xaec8);
10141         MP_WritePhyUshort(sc, 0x06, 0x70e4);
10142         MP_WritePhyUshort(sc, 0x06, 0x2602);
10143         MP_WritePhyUshort(sc, 0x06, 0x82d1);
10144         MP_WritePhyUshort(sc, 0x06, 0x05f8);
10145         MP_WritePhyUshort(sc, 0x06, 0xfaef);
10146         MP_WritePhyUshort(sc, 0x06, 0x69e0);
10147         MP_WritePhyUshort(sc, 0x06, 0xe2fe);
10148         MP_WritePhyUshort(sc, 0x06, 0xe1e2);
10149         MP_WritePhyUshort(sc, 0x06, 0xffad);
10150         MP_WritePhyUshort(sc, 0x06, 0x2d1a);
10151         MP_WritePhyUshort(sc, 0x06, 0xe0e1);
10152         MP_WritePhyUshort(sc, 0x06, 0x4ee1);
10153         MP_WritePhyUshort(sc, 0x06, 0xe14f);
10154         MP_WritePhyUshort(sc, 0x06, 0xac2d);
10155         MP_WritePhyUshort(sc, 0x06, 0x22f6);
10156         MP_WritePhyUshort(sc, 0x06, 0x0302);
10157         MP_WritePhyUshort(sc, 0x06, 0x033b);
10158         MP_WritePhyUshort(sc, 0x06, 0xf703);
10159         MP_WritePhyUshort(sc, 0x06, 0xf706);
10160         MP_WritePhyUshort(sc, 0x06, 0xbf84);
10161         MP_WritePhyUshort(sc, 0x06, 0x4402);
10162         MP_WritePhyUshort(sc, 0x06, 0x2d21);
10163         MP_WritePhyUshort(sc, 0x06, 0xae11);
10164         MP_WritePhyUshort(sc, 0x06, 0xe0e1);
10165         MP_WritePhyUshort(sc, 0x06, 0x4ee1);
10166         MP_WritePhyUshort(sc, 0x06, 0xe14f);
10167         MP_WritePhyUshort(sc, 0x06, 0xad2d);
10168         MP_WritePhyUshort(sc, 0x06, 0x08bf);
10169         MP_WritePhyUshort(sc, 0x06, 0x844f);
10170         MP_WritePhyUshort(sc, 0x06, 0x022d);
10171         MP_WritePhyUshort(sc, 0x06, 0x21f6);
10172         MP_WritePhyUshort(sc, 0x06, 0x06ef);
10173         MP_WritePhyUshort(sc, 0x06, 0x96fe);
10174         MP_WritePhyUshort(sc, 0x06, 0xfc04);
10175         MP_WritePhyUshort(sc, 0x06, 0xf8fa);
10176         MP_WritePhyUshort(sc, 0x06, 0xef69);
10177         MP_WritePhyUshort(sc, 0x06, 0x0283);
10178         MP_WritePhyUshort(sc, 0x06, 0x4502);
10179         MP_WritePhyUshort(sc, 0x06, 0x83a2);
10180         MP_WritePhyUshort(sc, 0x06, 0xe0e0);
10181         MP_WritePhyUshort(sc, 0x06, 0x00e1);
10182         MP_WritePhyUshort(sc, 0x06, 0xe001);
10183         MP_WritePhyUshort(sc, 0x06, 0xad27);
10184         MP_WritePhyUshort(sc, 0x06, 0x1fd1);
10185         MP_WritePhyUshort(sc, 0x06, 0x01bf);
10186         MP_WritePhyUshort(sc, 0x06, 0x843b);
10187         MP_WritePhyUshort(sc, 0x06, 0x022d);
10188         MP_WritePhyUshort(sc, 0x06, 0xc1e0);
10189         MP_WritePhyUshort(sc, 0x06, 0xe020);
10190         MP_WritePhyUshort(sc, 0x06, 0xe1e0);
10191         MP_WritePhyUshort(sc, 0x06, 0x21ad);
10192         MP_WritePhyUshort(sc, 0x06, 0x200e);
10193         MP_WritePhyUshort(sc, 0x06, 0xd100);
10194         MP_WritePhyUshort(sc, 0x06, 0xbf84);
10195         MP_WritePhyUshort(sc, 0x06, 0x3b02);
10196         MP_WritePhyUshort(sc, 0x06, 0x2dc1);
10197         MP_WritePhyUshort(sc, 0x06, 0xbf3b);
10198         MP_WritePhyUshort(sc, 0x06, 0x9602);
10199         MP_WritePhyUshort(sc, 0x06, 0x2d21);
10200         MP_WritePhyUshort(sc, 0x06, 0xef96);
10201         MP_WritePhyUshort(sc, 0x06, 0xfefc);
10202         MP_WritePhyUshort(sc, 0x06, 0x04f8);
10203         MP_WritePhyUshort(sc, 0x06, 0xf9fa);
10204         MP_WritePhyUshort(sc, 0x06, 0xef69);
10205         MP_WritePhyUshort(sc, 0x06, 0xe08b);
10206         MP_WritePhyUshort(sc, 0x06, 0x87ad);
10207         MP_WritePhyUshort(sc, 0x06, 0x204c);
10208         MP_WritePhyUshort(sc, 0x06, 0xd200);
10209         MP_WritePhyUshort(sc, 0x06, 0xe0e2);
10210         MP_WritePhyUshort(sc, 0x06, 0x0058);
10211         MP_WritePhyUshort(sc, 0x06, 0x010c);
10212         MP_WritePhyUshort(sc, 0x06, 0x021e);
10213         MP_WritePhyUshort(sc, 0x06, 0x20e0);
10214         MP_WritePhyUshort(sc, 0x06, 0xe000);
10215         MP_WritePhyUshort(sc, 0x06, 0x5810);
10216         MP_WritePhyUshort(sc, 0x06, 0x1e20);
10217         MP_WritePhyUshort(sc, 0x06, 0xe0e0);
10218         MP_WritePhyUshort(sc, 0x06, 0x3658);
10219         MP_WritePhyUshort(sc, 0x06, 0x031e);
10220         MP_WritePhyUshort(sc, 0x06, 0x20e0);
10221         MP_WritePhyUshort(sc, 0x06, 0xe022);
10222         MP_WritePhyUshort(sc, 0x06, 0xe1e0);
10223         MP_WritePhyUshort(sc, 0x06, 0x2358);
10224         MP_WritePhyUshort(sc, 0x06, 0xe01e);
10225         MP_WritePhyUshort(sc, 0x06, 0x20e0);
10226         MP_WritePhyUshort(sc, 0x06, 0x8b64);
10227         MP_WritePhyUshort(sc, 0x06, 0x1f02);
10228         MP_WritePhyUshort(sc, 0x06, 0x9e22);
10229         MP_WritePhyUshort(sc, 0x06, 0xe68b);
10230         MP_WritePhyUshort(sc, 0x06, 0x64ad);
10231         MP_WritePhyUshort(sc, 0x06, 0x3214);
10232         MP_WritePhyUshort(sc, 0x06, 0xad34);
10233         MP_WritePhyUshort(sc, 0x06, 0x11ef);
10234         MP_WritePhyUshort(sc, 0x06, 0x0258);
10235         MP_WritePhyUshort(sc, 0x06, 0x039e);
10236         MP_WritePhyUshort(sc, 0x06, 0x07ad);
10237         MP_WritePhyUshort(sc, 0x06, 0x3508);
10238         MP_WritePhyUshort(sc, 0x06, 0x5ac0);
10239         MP_WritePhyUshort(sc, 0x06, 0x9f04);
10240         MP_WritePhyUshort(sc, 0x06, 0xd101);
10241         MP_WritePhyUshort(sc, 0x06, 0xae02);
10242         MP_WritePhyUshort(sc, 0x06, 0xd100);
10243         MP_WritePhyUshort(sc, 0x06, 0xbf84);
10244         MP_WritePhyUshort(sc, 0x06, 0x3e02);
10245         MP_WritePhyUshort(sc, 0x06, 0x2dc1);
10246         MP_WritePhyUshort(sc, 0x06, 0xef96);
10247         MP_WritePhyUshort(sc, 0x06, 0xfefd);
10248         MP_WritePhyUshort(sc, 0x06, 0xfc04);
10249         MP_WritePhyUshort(sc, 0x06, 0xf8f9);
10250         MP_WritePhyUshort(sc, 0x06, 0xfbe0);
10251         MP_WritePhyUshort(sc, 0x06, 0x8b85);
10252         MP_WritePhyUshort(sc, 0x06, 0xad25);
10253         MP_WritePhyUshort(sc, 0x06, 0x22e0);
10254         MP_WritePhyUshort(sc, 0x06, 0xe022);
10255         MP_WritePhyUshort(sc, 0x06, 0xe1e0);
10256         MP_WritePhyUshort(sc, 0x06, 0x23e2);
10257         MP_WritePhyUshort(sc, 0x06, 0xe036);
10258         MP_WritePhyUshort(sc, 0x06, 0xe3e0);
10259         MP_WritePhyUshort(sc, 0x06, 0x375a);
10260         MP_WritePhyUshort(sc, 0x06, 0xc40d);
10261         MP_WritePhyUshort(sc, 0x06, 0x0158);
10262         MP_WritePhyUshort(sc, 0x06, 0x021e);
10263         MP_WritePhyUshort(sc, 0x06, 0x20e3);
10264         MP_WritePhyUshort(sc, 0x06, 0x8ae7);
10265         MP_WritePhyUshort(sc, 0x06, 0xac31);
10266         MP_WritePhyUshort(sc, 0x06, 0x60ac);
10267         MP_WritePhyUshort(sc, 0x06, 0x3a08);
10268         MP_WritePhyUshort(sc, 0x06, 0xac3e);
10269         MP_WritePhyUshort(sc, 0x06, 0x26ae);
10270         MP_WritePhyUshort(sc, 0x06, 0x67af);
10271         MP_WritePhyUshort(sc, 0x06, 0x8437);
10272         MP_WritePhyUshort(sc, 0x06, 0xad37);
10273         MP_WritePhyUshort(sc, 0x06, 0x61e0);
10274         MP_WritePhyUshort(sc, 0x06, 0x8ae8);
10275         MP_WritePhyUshort(sc, 0x06, 0x10e4);
10276         MP_WritePhyUshort(sc, 0x06, 0x8ae8);
10277         MP_WritePhyUshort(sc, 0x06, 0xe18a);
10278         MP_WritePhyUshort(sc, 0x06, 0xe91b);
10279         MP_WritePhyUshort(sc, 0x06, 0x109e);
10280         MP_WritePhyUshort(sc, 0x06, 0x02ae);
10281         MP_WritePhyUshort(sc, 0x06, 0x51d1);
10282         MP_WritePhyUshort(sc, 0x06, 0x00bf);
10283         MP_WritePhyUshort(sc, 0x06, 0x8441);
10284         MP_WritePhyUshort(sc, 0x06, 0x022d);
10285         MP_WritePhyUshort(sc, 0x06, 0xc1ee);
10286         MP_WritePhyUshort(sc, 0x06, 0x8ae8);
10287         MP_WritePhyUshort(sc, 0x06, 0x00ae);
10288         MP_WritePhyUshort(sc, 0x06, 0x43ad);
10289         MP_WritePhyUshort(sc, 0x06, 0x3627);
10290         MP_WritePhyUshort(sc, 0x06, 0xe08a);
10291         MP_WritePhyUshort(sc, 0x06, 0xeee1);
10292         MP_WritePhyUshort(sc, 0x06, 0x8aef);
10293         MP_WritePhyUshort(sc, 0x06, 0xef74);
10294         MP_WritePhyUshort(sc, 0x06, 0xe08a);
10295         MP_WritePhyUshort(sc, 0x06, 0xeae1);
10296         MP_WritePhyUshort(sc, 0x06, 0x8aeb);
10297         MP_WritePhyUshort(sc, 0x06, 0x1b74);
10298         MP_WritePhyUshort(sc, 0x06, 0x9e2e);
10299         MP_WritePhyUshort(sc, 0x06, 0x14e4);
10300         MP_WritePhyUshort(sc, 0x06, 0x8aea);
10301         MP_WritePhyUshort(sc, 0x06, 0xe58a);
10302         MP_WritePhyUshort(sc, 0x06, 0xebef);
10303         MP_WritePhyUshort(sc, 0x06, 0x74e0);
10304         MP_WritePhyUshort(sc, 0x06, 0x8aee);
10305         MP_WritePhyUshort(sc, 0x06, 0xe18a);
10306         MP_WritePhyUshort(sc, 0x06, 0xef1b);
10307         MP_WritePhyUshort(sc, 0x06, 0x479e);
10308         MP_WritePhyUshort(sc, 0x06, 0x0fae);
10309         MP_WritePhyUshort(sc, 0x06, 0x19ee);
10310         MP_WritePhyUshort(sc, 0x06, 0x8aea);
10311         MP_WritePhyUshort(sc, 0x06, 0x00ee);
10312         MP_WritePhyUshort(sc, 0x06, 0x8aeb);
10313         MP_WritePhyUshort(sc, 0x06, 0x00ae);
10314         MP_WritePhyUshort(sc, 0x06, 0x0fac);
10315         MP_WritePhyUshort(sc, 0x06, 0x390c);
10316         MP_WritePhyUshort(sc, 0x06, 0xd101);
10317         MP_WritePhyUshort(sc, 0x06, 0xbf84);
10318         MP_WritePhyUshort(sc, 0x06, 0x4102);
10319         MP_WritePhyUshort(sc, 0x06, 0x2dc1);
10320         MP_WritePhyUshort(sc, 0x06, 0xee8a);
10321         MP_WritePhyUshort(sc, 0x06, 0xe800);
10322         MP_WritePhyUshort(sc, 0x06, 0xe68a);
10323         MP_WritePhyUshort(sc, 0x06, 0xe7ff);
10324         MP_WritePhyUshort(sc, 0x06, 0xfdfc);
10325         MP_WritePhyUshort(sc, 0x06, 0x0400);
10326         MP_WritePhyUshort(sc, 0x06, 0xe234);
10327         MP_WritePhyUshort(sc, 0x06, 0xcce2);
10328         MP_WritePhyUshort(sc, 0x06, 0x0088);
10329         MP_WritePhyUshort(sc, 0x06, 0xe200);
10330         MP_WritePhyUshort(sc, 0x06, 0xa725);
10331         MP_WritePhyUshort(sc, 0x06, 0xe50a);
10332         MP_WritePhyUshort(sc, 0x06, 0x1de5);
10333         MP_WritePhyUshort(sc, 0x06, 0x0a2c);
10334         MP_WritePhyUshort(sc, 0x06, 0xe50a);
10335         MP_WritePhyUshort(sc, 0x06, 0x6de5);
10336         MP_WritePhyUshort(sc, 0x06, 0x0a1d);
10337         MP_WritePhyUshort(sc, 0x06, 0xe50a);
10338         MP_WritePhyUshort(sc, 0x06, 0x1ce5);
10339         MP_WritePhyUshort(sc, 0x06, 0x0a2d);
10340         MP_WritePhyUshort(sc, 0x06, 0xa755);
10341         MP_WritePhyUshort(sc, 0x05, 0x8b64);
10342         MP_WritePhyUshort(sc, 0x06, 0x0000);
10343         MP_WritePhyUshort(sc, 0x05, 0x8b94);
10344         MP_WritePhyUshort(sc, 0x06, 0x82cd);
10345         MP_WritePhyUshort(sc, 0x05, 0x8b85);
10346         MP_WritePhyUshort(sc, 0x06, 0x2000);
10347         MP_WritePhyUshort(sc, 0x05, 0x8aee);
10348         MP_WritePhyUshort(sc, 0x06, 0x03b8);
10349         MP_WritePhyUshort(sc, 0x05, 0x8ae8);
10350         MP_WritePhyUshort(sc, 0x06, 0x0002);
10351         PhyRegValue = MP_ReadPhyUshort(sc, 0x01);
10352         PhyRegValue |= BIT_0;
10353         MP_WritePhyUshort(sc, 0x01, PhyRegValue);
10354         PhyRegValue = MP_ReadPhyUshort(sc, 0x00);
10355         PhyRegValue |= BIT_0;
10356         MP_WritePhyUshort(sc, 0x00, PhyRegValue);
10357         MP_WritePhyUshort(sc, 0x1f, 0x0);
10358         MP_WritePhyUshort(sc, 0x1f, 0x0005);
10359         for (i=0; i<200; i++) {
10360                 DELAY(100);
10361                 PhyRegValue = MP_ReadPhyUshort(sc, 0x00);
10362                 if (PhyRegValue&0x0080)
10363                         break;
10364         }
10365         MP_WritePhyUshort(sc, 0x1f, 0x0007);
10366         MP_WritePhyUshort(sc, 0x1e, 0x0023);
10367         PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
10368         PhyRegValue &= ~(BIT_0);
10369         if (sc->RequiredSecLanDonglePatch)
10370                 PhyRegValue &= ~(BIT_2);
10371         MP_WritePhyUshort(sc, 0x17, PhyRegValue);
10372         MP_WritePhyUshort(sc, 0x1f, 0x0007);
10373         MP_WritePhyUshort(sc, 0x1e, 0x0028);
10374         MP_WritePhyUshort(sc, 0x15, 0x0010);
10375         MP_WritePhyUshort(sc, 0x1f, 0x0007);
10376         MP_WritePhyUshort(sc, 0x1e, 0x0041);
10377         MP_WritePhyUshort(sc, 0x15, 0x0802);
10378         MP_WritePhyUshort(sc, 0x16, 0x2185);
10379         MP_WritePhyUshort(sc, 0x1f, 0x0000);
10380 }
10381
10382 static void re_set_phy_mcu_8168e_2(struct re_softc *sc)
10383 {
10384         u_int16_t PhyRegValue;
10385         int     i;
10386
10387         if (MP_ReadEfuse(sc, 0x22) == 0x0c) {
10388                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
10389                 MP_WritePhyUshort(sc, 0x00, 0x1800);
10390                 MP_WritePhyUshort(sc, 0x1f, 0x0007);
10391                 MP_WritePhyUshort(sc, 0x1e, 0x0023);
10392                 MP_WritePhyUshort(sc, 0x17, 0x0117);
10393                 MP_WritePhyUshort(sc, 0x1f, 0x0007);
10394                 MP_WritePhyUshort(sc, 0x1E, 0x002C);
10395                 MP_WritePhyUshort(sc, 0x1B, 0x5000);
10396                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
10397                 MP_WritePhyUshort(sc, 0x16, 0x4104);
10398                 for (i=0; i<200; i++) {
10399                         DELAY(100);
10400                         PhyRegValue = MP_ReadPhyUshort(sc, 0x1E);
10401                         PhyRegValue &= 0x03FF;
10402                         if (PhyRegValue== 0x000C)
10403                                 break;
10404                 }
10405                 MP_WritePhyUshort(sc, 0x1f, 0x0005);
10406                 for (i=0; i<200; i++) {
10407                         DELAY(100);
10408                         PhyRegValue = MP_ReadPhyUshort(sc, 0x07);
10409                         if ((PhyRegValue&0x0020)==0)
10410                                 break;
10411                 }
10412                 PhyRegValue = MP_ReadPhyUshort(sc, 0x07);
10413                 if (PhyRegValue & 0x0020) {
10414                         MP_WritePhyUshort(sc, 0x1f, 0x0007);
10415                         MP_WritePhyUshort(sc, 0x1e, 0x00a1);
10416                         MP_WritePhyUshort(sc, 0x17, 0x1000);
10417                         MP_WritePhyUshort(sc, 0x17, 0x0000);
10418                         MP_WritePhyUshort(sc, 0x17, 0x2000);
10419                         MP_WritePhyUshort(sc, 0x1e, 0x002f);
10420                         MP_WritePhyUshort(sc, 0x18, 0x9bfb);
10421                         MP_WritePhyUshort(sc, 0x1f, 0x0005);
10422                         MP_WritePhyUshort(sc, 0x07, 0x0000);
10423                         MP_WritePhyUshort(sc, 0x1f, 0x0000);
10424                 }
10425                 MP_WritePhyUshort(sc, 0x1f, 0x0005);
10426                 MP_WritePhyUshort(sc, 0x05, 0xfff6);
10427                 MP_WritePhyUshort(sc, 0x06, 0x0080);
10428                 PhyRegValue = MP_ReadPhyUshort(sc, 0x00);
10429                 PhyRegValue &= ~(BIT_7);
10430                 MP_WritePhyUshort(sc, 0x00, PhyRegValue);
10431                 MP_WritePhyUshort(sc, 0x1f, 0x0002);
10432                 PhyRegValue = MP_ReadPhyUshort(sc, 0x08);
10433                 PhyRegValue &= ~(BIT_7);
10434                 MP_WritePhyUshort(sc, 0x08, PhyRegValue);
10435                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
10436                 MP_WritePhyUshort(sc, 0x1f, 0x0007);
10437                 MP_WritePhyUshort(sc, 0x1e, 0x0023);
10438                 MP_WritePhyUshort(sc, 0x16, 0x0306);
10439                 MP_WritePhyUshort(sc, 0x16, 0x0307);
10440                 MP_WritePhyUshort(sc, 0x15, 0x000e);
10441                 MP_WritePhyUshort(sc, 0x19, 0x000a);
10442                 MP_WritePhyUshort(sc, 0x15, 0x0010);
10443                 MP_WritePhyUshort(sc, 0x19, 0x0008);
10444                 MP_WritePhyUshort(sc, 0x15, 0x0018);
10445                 MP_WritePhyUshort(sc, 0x19, 0x4801);
10446                 MP_WritePhyUshort(sc, 0x15, 0x0019);
10447                 MP_WritePhyUshort(sc, 0x19, 0x6801);
10448                 MP_WritePhyUshort(sc, 0x15, 0x001a);
10449                 MP_WritePhyUshort(sc, 0x19, 0x66a1);
10450                 MP_WritePhyUshort(sc, 0x15, 0x001f);
10451                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10452                 MP_WritePhyUshort(sc, 0x15, 0x0020);
10453                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10454                 MP_WritePhyUshort(sc, 0x15, 0x0021);
10455                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10456                 MP_WritePhyUshort(sc, 0x15, 0x0022);
10457                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10458                 MP_WritePhyUshort(sc, 0x15, 0x0023);
10459                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10460                 MP_WritePhyUshort(sc, 0x15, 0x0024);
10461                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10462                 MP_WritePhyUshort(sc, 0x15, 0x0025);
10463                 MP_WritePhyUshort(sc, 0x19, 0x64a1);
10464                 MP_WritePhyUshort(sc, 0x15, 0x0026);
10465                 MP_WritePhyUshort(sc, 0x19, 0x40ea);
10466                 MP_WritePhyUshort(sc, 0x15, 0x0027);
10467                 MP_WritePhyUshort(sc, 0x19, 0x4503);
10468                 MP_WritePhyUshort(sc, 0x15, 0x0028);
10469                 MP_WritePhyUshort(sc, 0x19, 0x9f00);
10470                 MP_WritePhyUshort(sc, 0x15, 0x0029);
10471                 MP_WritePhyUshort(sc, 0x19, 0xa631);
10472                 MP_WritePhyUshort(sc, 0x15, 0x002a);
10473                 MP_WritePhyUshort(sc, 0x19, 0x9717);
10474                 MP_WritePhyUshort(sc, 0x15, 0x002b);
10475                 MP_WritePhyUshort(sc, 0x19, 0x302c);
10476                 MP_WritePhyUshort(sc, 0x15, 0x002c);
10477                 MP_WritePhyUshort(sc, 0x19, 0x4802);
10478                 MP_WritePhyUshort(sc, 0x15, 0x002d);
10479                 MP_WritePhyUshort(sc, 0x19, 0x58da);
10480                 MP_WritePhyUshort(sc, 0x15, 0x002e);
10481                 MP_WritePhyUshort(sc, 0x19, 0x400d);
10482                 MP_WritePhyUshort(sc, 0x15, 0x002f);
10483                 MP_WritePhyUshort(sc, 0x19, 0x4488);
10484                 MP_WritePhyUshort(sc, 0x15, 0x0030);
10485                 MP_WritePhyUshort(sc, 0x19, 0x9e00);
10486                 MP_WritePhyUshort(sc, 0x15, 0x0031);
10487                 MP_WritePhyUshort(sc, 0x19, 0x63c8);
10488                 MP_WritePhyUshort(sc, 0x15, 0x0032);
10489                 MP_WritePhyUshort(sc, 0x19, 0x6481);
10490                 MP_WritePhyUshort(sc, 0x15, 0x0033);
10491                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10492                 MP_WritePhyUshort(sc, 0x15, 0x0034);
10493                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10494                 MP_WritePhyUshort(sc, 0x15, 0x0035);
10495                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10496                 MP_WritePhyUshort(sc, 0x15, 0x0036);
10497                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10498                 MP_WritePhyUshort(sc, 0x15, 0x0037);
10499                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10500                 MP_WritePhyUshort(sc, 0x15, 0x0038);
10501                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10502                 MP_WritePhyUshort(sc, 0x15, 0x0039);
10503                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10504                 MP_WritePhyUshort(sc, 0x15, 0x003a);
10505                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10506                 MP_WritePhyUshort(sc, 0x15, 0x003b);
10507                 MP_WritePhyUshort(sc, 0x19, 0x63e8);
10508                 MP_WritePhyUshort(sc, 0x15, 0x003c);
10509                 MP_WritePhyUshort(sc, 0x19, 0x7d00);
10510                 MP_WritePhyUshort(sc, 0x15, 0x003d);
10511                 MP_WritePhyUshort(sc, 0x19, 0x59d4);
10512                 MP_WritePhyUshort(sc, 0x15, 0x003e);
10513                 MP_WritePhyUshort(sc, 0x19, 0x63f8);
10514                 MP_WritePhyUshort(sc, 0x15, 0x0040);
10515                 MP_WritePhyUshort(sc, 0x19, 0x64a1);
10516                 MP_WritePhyUshort(sc, 0x15, 0x0041);
10517                 MP_WritePhyUshort(sc, 0x19, 0x30de);
10518                 MP_WritePhyUshort(sc, 0x15, 0x0044);
10519                 MP_WritePhyUshort(sc, 0x19, 0x480f);
10520                 MP_WritePhyUshort(sc, 0x15, 0x0045);
10521                 MP_WritePhyUshort(sc, 0x19, 0x6800);
10522                 MP_WritePhyUshort(sc, 0x15, 0x0046);
10523                 MP_WritePhyUshort(sc, 0x19, 0x6680);
10524                 MP_WritePhyUshort(sc, 0x15, 0x0047);
10525                 MP_WritePhyUshort(sc, 0x19, 0x7c10);
10526                 MP_WritePhyUshort(sc, 0x15, 0x0048);
10527                 MP_WritePhyUshort(sc, 0x19, 0x63c8);
10528                 MP_WritePhyUshort(sc, 0x15, 0x0049);
10529                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10530                 MP_WritePhyUshort(sc, 0x15, 0x004a);
10531                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10532                 MP_WritePhyUshort(sc, 0x15, 0x004b);
10533                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10534                 MP_WritePhyUshort(sc, 0x15, 0x004c);
10535                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10536                 MP_WritePhyUshort(sc, 0x15, 0x004d);
10537                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10538                 MP_WritePhyUshort(sc, 0x15, 0x004e);
10539                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10540                 MP_WritePhyUshort(sc, 0x15, 0x004f);
10541                 MP_WritePhyUshort(sc, 0x19, 0x40ea);
10542                 MP_WritePhyUshort(sc, 0x15, 0x0050);
10543                 MP_WritePhyUshort(sc, 0x19, 0x4503);
10544                 MP_WritePhyUshort(sc, 0x15, 0x0051);
10545                 MP_WritePhyUshort(sc, 0x19, 0x58ca);
10546                 MP_WritePhyUshort(sc, 0x15, 0x0052);
10547                 MP_WritePhyUshort(sc, 0x19, 0x63c8);
10548                 MP_WritePhyUshort(sc, 0x15, 0x0053);
10549                 MP_WritePhyUshort(sc, 0x19, 0x63d8);
10550                 MP_WritePhyUshort(sc, 0x15, 0x0054);
10551                 MP_WritePhyUshort(sc, 0x19, 0x66a0);
10552                 MP_WritePhyUshort(sc, 0x15, 0x0055);
10553                 MP_WritePhyUshort(sc, 0x19, 0x9f00);
10554                 MP_WritePhyUshort(sc, 0x15, 0x0056);
10555                 MP_WritePhyUshort(sc, 0x19, 0x3000);
10556                 MP_WritePhyUshort(sc, 0x15, 0x00a1);
10557                 MP_WritePhyUshort(sc, 0x19, 0x3044);
10558                 MP_WritePhyUshort(sc, 0x15, 0x00ab);
10559                 MP_WritePhyUshort(sc, 0x19, 0x5820);
10560                 MP_WritePhyUshort(sc, 0x15, 0x00ac);
10561                 MP_WritePhyUshort(sc, 0x19, 0x5e04);
10562                 MP_WritePhyUshort(sc, 0x15, 0x00ad);
10563                 MP_WritePhyUshort(sc, 0x19, 0xb60c);
10564                 MP_WritePhyUshort(sc, 0x15, 0x00af);
10565                 MP_WritePhyUshort(sc, 0x19, 0x000a);
10566                 MP_WritePhyUshort(sc, 0x15, 0x00b2);
10567                 MP_WritePhyUshort(sc, 0x19, 0x30b9);
10568                 MP_WritePhyUshort(sc, 0x15, 0x00b9);
10569                 MP_WritePhyUshort(sc, 0x19, 0x4408);
10570                 MP_WritePhyUshort(sc, 0x15, 0x00ba);
10571                 MP_WritePhyUshort(sc, 0x19, 0x480b);
10572                 MP_WritePhyUshort(sc, 0x15, 0x00bb);
10573                 MP_WritePhyUshort(sc, 0x19, 0x5e00);
10574                 MP_WritePhyUshort(sc, 0x15, 0x00bc);
10575                 MP_WritePhyUshort(sc, 0x19, 0x405f);
10576                 MP_WritePhyUshort(sc, 0x15, 0x00bd);
10577                 MP_WritePhyUshort(sc, 0x19, 0x4448);
10578                 MP_WritePhyUshort(sc, 0x15, 0x00be);
10579                 MP_WritePhyUshort(sc, 0x19, 0x4020);
10580                 MP_WritePhyUshort(sc, 0x15, 0x00bf);
10581                 MP_WritePhyUshort(sc, 0x19, 0x4468);
10582                 MP_WritePhyUshort(sc, 0x15, 0x00c0);
10583                 MP_WritePhyUshort(sc, 0x19, 0x9c02);
10584                 MP_WritePhyUshort(sc, 0x15, 0x00c1);
10585                 MP_WritePhyUshort(sc, 0x19, 0x58a0);
10586                 MP_WritePhyUshort(sc, 0x15, 0x00c2);
10587                 MP_WritePhyUshort(sc, 0x19, 0xb605);
10588                 MP_WritePhyUshort(sc, 0x15, 0x00c3);
10589                 MP_WritePhyUshort(sc, 0x19, 0xc0d3);
10590                 MP_WritePhyUshort(sc, 0x15, 0x00c4);
10591                 MP_WritePhyUshort(sc, 0x19, 0x00e6);
10592                 MP_WritePhyUshort(sc, 0x15, 0x00c5);
10593                 MP_WritePhyUshort(sc, 0x19, 0xdaec);
10594                 MP_WritePhyUshort(sc, 0x15, 0x00c6);
10595                 MP_WritePhyUshort(sc, 0x19, 0x00fa);
10596                 MP_WritePhyUshort(sc, 0x15, 0x00c7);
10597                 MP_WritePhyUshort(sc, 0x19, 0x9df9);
10598                 MP_WritePhyUshort(sc, 0x15, 0x0112);
10599                 MP_WritePhyUshort(sc, 0x19, 0x6421);
10600                 MP_WritePhyUshort(sc, 0x15, 0x0113);
10601                 MP_WritePhyUshort(sc, 0x19, 0x7c08);
10602                 MP_WritePhyUshort(sc, 0x15, 0x0114);
10603                 MP_WritePhyUshort(sc, 0x19, 0x63f0);
10604                 MP_WritePhyUshort(sc, 0x15, 0x0115);
10605                 MP_WritePhyUshort(sc, 0x19, 0x4003);
10606                 MP_WritePhyUshort(sc, 0x15, 0x0116);
10607                 MP_WritePhyUshort(sc, 0x19, 0x4418);
10608                 MP_WritePhyUshort(sc, 0x15, 0x0117);
10609                 MP_WritePhyUshort(sc, 0x19, 0x9b00);
10610                 MP_WritePhyUshort(sc, 0x15, 0x0118);
10611                 MP_WritePhyUshort(sc, 0x19, 0x6461);
10612                 MP_WritePhyUshort(sc, 0x15, 0x0119);
10613                 MP_WritePhyUshort(sc, 0x19, 0x64e1);
10614                 MP_WritePhyUshort(sc, 0x15, 0x011a);
10615                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10616                 MP_WritePhyUshort(sc, 0x15, 0x0150);
10617                 MP_WritePhyUshort(sc, 0x19, 0x7c80);
10618                 MP_WritePhyUshort(sc, 0x15, 0x0151);
10619                 MP_WritePhyUshort(sc, 0x19, 0x6461);
10620                 MP_WritePhyUshort(sc, 0x15, 0x0152);
10621                 MP_WritePhyUshort(sc, 0x19, 0x4003);
10622                 MP_WritePhyUshort(sc, 0x15, 0x0153);
10623                 MP_WritePhyUshort(sc, 0x19, 0x4540);
10624                 MP_WritePhyUshort(sc, 0x15, 0x0154);
10625                 MP_WritePhyUshort(sc, 0x19, 0x9f00);
10626                 MP_WritePhyUshort(sc, 0x15, 0x0155);
10627                 MP_WritePhyUshort(sc, 0x19, 0x9d00);
10628                 MP_WritePhyUshort(sc, 0x15, 0x0156);
10629                 MP_WritePhyUshort(sc, 0x19, 0x7c40);
10630                 MP_WritePhyUshort(sc, 0x15, 0x0157);
10631                 MP_WritePhyUshort(sc, 0x19, 0x6421);
10632                 MP_WritePhyUshort(sc, 0x15, 0x0158);
10633                 MP_WritePhyUshort(sc, 0x19, 0x7c80);
10634                 MP_WritePhyUshort(sc, 0x15, 0x0159);
10635                 MP_WritePhyUshort(sc, 0x19, 0x64a1);
10636                 MP_WritePhyUshort(sc, 0x15, 0x015a);
10637                 MP_WritePhyUshort(sc, 0x19, 0x30fe);
10638                 MP_WritePhyUshort(sc, 0x15, 0x029c);
10639                 MP_WritePhyUshort(sc, 0x19, 0x0070);
10640                 MP_WritePhyUshort(sc, 0x15, 0x02b2);
10641                 MP_WritePhyUshort(sc, 0x19, 0x005a);
10642                 MP_WritePhyUshort(sc, 0x15, 0x02bd);
10643                 MP_WritePhyUshort(sc, 0x19, 0xa522);
10644                 MP_WritePhyUshort(sc, 0x15, 0x02ce);
10645                 MP_WritePhyUshort(sc, 0x19, 0xb63e);
10646                 MP_WritePhyUshort(sc, 0x15, 0x02d9);
10647                 MP_WritePhyUshort(sc, 0x19, 0x32df);
10648                 MP_WritePhyUshort(sc, 0x15, 0x02df);
10649                 MP_WritePhyUshort(sc, 0x19, 0x4500);
10650                 MP_WritePhyUshort(sc, 0x15, 0x02e7);
10651                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10652                 MP_WritePhyUshort(sc, 0x15, 0x02f4);
10653                 MP_WritePhyUshort(sc, 0x19, 0xb618);
10654                 MP_WritePhyUshort(sc, 0x15, 0x02fb);
10655                 MP_WritePhyUshort(sc, 0x19, 0xb900);
10656                 MP_WritePhyUshort(sc, 0x15, 0x02fc);
10657                 MP_WritePhyUshort(sc, 0x19, 0x49b5);
10658                 MP_WritePhyUshort(sc, 0x15, 0x02fd);
10659                 MP_WritePhyUshort(sc, 0x19, 0x6812);
10660                 MP_WritePhyUshort(sc, 0x15, 0x02fe);
10661                 MP_WritePhyUshort(sc, 0x19, 0x66a0);
10662                 MP_WritePhyUshort(sc, 0x15, 0x02ff);
10663                 MP_WritePhyUshort(sc, 0x19, 0x9900);
10664                 MP_WritePhyUshort(sc, 0x15, 0x0300);
10665                 MP_WritePhyUshort(sc, 0x19, 0x64a0);
10666                 MP_WritePhyUshort(sc, 0x15, 0x0301);
10667                 MP_WritePhyUshort(sc, 0x19, 0x3316);
10668                 MP_WritePhyUshort(sc, 0x15, 0x0308);
10669                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10670                 MP_WritePhyUshort(sc, 0x15, 0x030c);
10671                 MP_WritePhyUshort(sc, 0x19, 0x3000);
10672                 MP_WritePhyUshort(sc, 0x15, 0x0312);
10673                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10674                 MP_WritePhyUshort(sc, 0x15, 0x0313);
10675                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10676                 MP_WritePhyUshort(sc, 0x15, 0x0314);
10677                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10678                 MP_WritePhyUshort(sc, 0x15, 0x0315);
10679                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10680                 MP_WritePhyUshort(sc, 0x15, 0x0316);
10681                 MP_WritePhyUshort(sc, 0x19, 0x49b5);
10682                 MP_WritePhyUshort(sc, 0x15, 0x0317);
10683                 MP_WritePhyUshort(sc, 0x19, 0x7d00);
10684                 MP_WritePhyUshort(sc, 0x15, 0x0318);
10685                 MP_WritePhyUshort(sc, 0x19, 0x4d00);
10686                 MP_WritePhyUshort(sc, 0x15, 0x0319);
10687                 MP_WritePhyUshort(sc, 0x19, 0x6810);
10688                 MP_WritePhyUshort(sc, 0x15, 0x031a);
10689                 MP_WritePhyUshort(sc, 0x19, 0x6c08);
10690                 MP_WritePhyUshort(sc, 0x15, 0x031b);
10691                 MP_WritePhyUshort(sc, 0x19, 0x4925);
10692                 MP_WritePhyUshort(sc, 0x15, 0x031c);
10693                 MP_WritePhyUshort(sc, 0x19, 0x403b);
10694                 MP_WritePhyUshort(sc, 0x15, 0x031d);
10695                 MP_WritePhyUshort(sc, 0x19, 0xa602);
10696                 MP_WritePhyUshort(sc, 0x15, 0x031e);
10697                 MP_WritePhyUshort(sc, 0x19, 0x402f);
10698                 MP_WritePhyUshort(sc, 0x15, 0x031f);
10699                 MP_WritePhyUshort(sc, 0x19, 0x4484);
10700                 MP_WritePhyUshort(sc, 0x15, 0x0320);
10701                 MP_WritePhyUshort(sc, 0x19, 0x40c8);
10702                 MP_WritePhyUshort(sc, 0x15, 0x0321);
10703                 MP_WritePhyUshort(sc, 0x19, 0x44c4);
10704                 MP_WritePhyUshort(sc, 0x15, 0x0322);
10705                 MP_WritePhyUshort(sc, 0x19, 0x404f);
10706                 MP_WritePhyUshort(sc, 0x15, 0x0323);
10707                 MP_WritePhyUshort(sc, 0x19, 0x44c8);
10708                 MP_WritePhyUshort(sc, 0x15, 0x0324);
10709                 MP_WritePhyUshort(sc, 0x19, 0xd64f);
10710                 MP_WritePhyUshort(sc, 0x15, 0x0325);
10711                 MP_WritePhyUshort(sc, 0x19, 0x00e7);
10712                 MP_WritePhyUshort(sc, 0x15, 0x0326);
10713                 MP_WritePhyUshort(sc, 0x19, 0x7c08);
10714                 MP_WritePhyUshort(sc, 0x15, 0x0327);
10715                 MP_WritePhyUshort(sc, 0x19, 0x8203);
10716                 MP_WritePhyUshort(sc, 0x15, 0x0328);
10717                 MP_WritePhyUshort(sc, 0x19, 0x4d48);
10718                 MP_WritePhyUshort(sc, 0x15, 0x0329);
10719                 MP_WritePhyUshort(sc, 0x19, 0x332b);
10720                 MP_WritePhyUshort(sc, 0x15, 0x032a);
10721                 MP_WritePhyUshort(sc, 0x19, 0x4d40);
10722                 MP_WritePhyUshort(sc, 0x15, 0x032c);
10723                 MP_WritePhyUshort(sc, 0x19, 0x00f8);
10724                 MP_WritePhyUshort(sc, 0x15, 0x032d);
10725                 MP_WritePhyUshort(sc, 0x19, 0x82b2);
10726                 MP_WritePhyUshort(sc, 0x15, 0x032f);
10727                 MP_WritePhyUshort(sc, 0x19, 0x00b0);
10728                 MP_WritePhyUshort(sc, 0x15, 0x0332);
10729                 MP_WritePhyUshort(sc, 0x19, 0x91f2);
10730                 MP_WritePhyUshort(sc, 0x15, 0x033f);
10731                 MP_WritePhyUshort(sc, 0x19, 0xb6cd);
10732                 MP_WritePhyUshort(sc, 0x15, 0x0340);
10733                 MP_WritePhyUshort(sc, 0x19, 0x9e01);
10734                 MP_WritePhyUshort(sc, 0x15, 0x0341);
10735                 MP_WritePhyUshort(sc, 0x19, 0xd11d);
10736                 MP_WritePhyUshort(sc, 0x15, 0x0342);
10737                 MP_WritePhyUshort(sc, 0x19, 0x009d);
10738                 MP_WritePhyUshort(sc, 0x15, 0x0343);
10739                 MP_WritePhyUshort(sc, 0x19, 0xbb1c);
10740                 MP_WritePhyUshort(sc, 0x15, 0x0344);
10741                 MP_WritePhyUshort(sc, 0x19, 0x8102);
10742                 MP_WritePhyUshort(sc, 0x15, 0x0345);
10743                 MP_WritePhyUshort(sc, 0x19, 0x3348);
10744                 MP_WritePhyUshort(sc, 0x15, 0x0346);
10745                 MP_WritePhyUshort(sc, 0x19, 0xa231);
10746                 MP_WritePhyUshort(sc, 0x15, 0x0347);
10747                 MP_WritePhyUshort(sc, 0x19, 0x335b);
10748                 MP_WritePhyUshort(sc, 0x15, 0x0348);
10749                 MP_WritePhyUshort(sc, 0x19, 0x91f7);
10750                 MP_WritePhyUshort(sc, 0x15, 0x0349);
10751                 MP_WritePhyUshort(sc, 0x19, 0xc218);
10752                 MP_WritePhyUshort(sc, 0x15, 0x034a);
10753                 MP_WritePhyUshort(sc, 0x19, 0x00f5);
10754                 MP_WritePhyUshort(sc, 0x15, 0x034b);
10755                 MP_WritePhyUshort(sc, 0x19, 0x335b);
10756                 MP_WritePhyUshort(sc, 0x15, 0x034c);
10757                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10758                 MP_WritePhyUshort(sc, 0x15, 0x034d);
10759                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10760                 MP_WritePhyUshort(sc, 0x15, 0x034e);
10761                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10762                 MP_WritePhyUshort(sc, 0x15, 0x034f);
10763                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10764                 MP_WritePhyUshort(sc, 0x15, 0x0350);
10765                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10766                 MP_WritePhyUshort(sc, 0x15, 0x035b);
10767                 MP_WritePhyUshort(sc, 0x19, 0xa23c);
10768                 MP_WritePhyUshort(sc, 0x15, 0x035c);
10769                 MP_WritePhyUshort(sc, 0x19, 0x7c08);
10770                 MP_WritePhyUshort(sc, 0x15, 0x035d);
10771                 MP_WritePhyUshort(sc, 0x19, 0x4c00);
10772                 MP_WritePhyUshort(sc, 0x15, 0x035e);
10773                 MP_WritePhyUshort(sc, 0x19, 0x3397);
10774                 MP_WritePhyUshort(sc, 0x15, 0x0363);
10775                 MP_WritePhyUshort(sc, 0x19, 0xb6a9);
10776                 MP_WritePhyUshort(sc, 0x15, 0x0366);
10777                 MP_WritePhyUshort(sc, 0x19, 0x00f5);
10778                 MP_WritePhyUshort(sc, 0x15, 0x0382);
10779                 MP_WritePhyUshort(sc, 0x19, 0x7c40);
10780                 MP_WritePhyUshort(sc, 0x15, 0x0388);
10781                 MP_WritePhyUshort(sc, 0x19, 0x0084);
10782                 MP_WritePhyUshort(sc, 0x15, 0x0389);
10783                 MP_WritePhyUshort(sc, 0x19, 0xdd17);
10784                 MP_WritePhyUshort(sc, 0x15, 0x038a);
10785                 MP_WritePhyUshort(sc, 0x19, 0x000b);
10786                 MP_WritePhyUshort(sc, 0x15, 0x038b);
10787                 MP_WritePhyUshort(sc, 0x19, 0xa10a);
10788                 MP_WritePhyUshort(sc, 0x15, 0x038c);
10789                 MP_WritePhyUshort(sc, 0x19, 0x337e);
10790                 MP_WritePhyUshort(sc, 0x15, 0x038d);
10791                 MP_WritePhyUshort(sc, 0x19, 0x6c0b);
10792                 MP_WritePhyUshort(sc, 0x15, 0x038e);
10793                 MP_WritePhyUshort(sc, 0x19, 0xa107);
10794                 MP_WritePhyUshort(sc, 0x15, 0x038f);
10795                 MP_WritePhyUshort(sc, 0x19, 0x6c08);
10796                 MP_WritePhyUshort(sc, 0x15, 0x0390);
10797                 MP_WritePhyUshort(sc, 0x19, 0xc017);
10798                 MP_WritePhyUshort(sc, 0x15, 0x0391);
10799                 MP_WritePhyUshort(sc, 0x19, 0x0004);
10800                 MP_WritePhyUshort(sc, 0x15, 0x0392);
10801                 MP_WritePhyUshort(sc, 0x19, 0xd64f);
10802                 MP_WritePhyUshort(sc, 0x15, 0x0393);
10803                 MP_WritePhyUshort(sc, 0x19, 0x00f4);
10804                 MP_WritePhyUshort(sc, 0x15, 0x0397);
10805                 MP_WritePhyUshort(sc, 0x19, 0x4098);
10806                 MP_WritePhyUshort(sc, 0x15, 0x0398);
10807                 MP_WritePhyUshort(sc, 0x19, 0x4408);
10808                 MP_WritePhyUshort(sc, 0x15, 0x0399);
10809                 MP_WritePhyUshort(sc, 0x19, 0x55bf);
10810                 MP_WritePhyUshort(sc, 0x15, 0x039a);
10811                 MP_WritePhyUshort(sc, 0x19, 0x4bb9);
10812                 MP_WritePhyUshort(sc, 0x15, 0x039b);
10813                 MP_WritePhyUshort(sc, 0x19, 0x6810);
10814                 MP_WritePhyUshort(sc, 0x15, 0x039c);
10815                 MP_WritePhyUshort(sc, 0x19, 0x4b29);
10816                 MP_WritePhyUshort(sc, 0x15, 0x039d);
10817                 MP_WritePhyUshort(sc, 0x19, 0x4041);
10818                 MP_WritePhyUshort(sc, 0x15, 0x039e);
10819                 MP_WritePhyUshort(sc, 0x19, 0x442a);
10820                 MP_WritePhyUshort(sc, 0x15, 0x039f);
10821                 MP_WritePhyUshort(sc, 0x19, 0x4029);
10822                 MP_WritePhyUshort(sc, 0x15, 0x03aa);
10823                 MP_WritePhyUshort(sc, 0x19, 0x33b8);
10824                 MP_WritePhyUshort(sc, 0x15, 0x03b6);
10825                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10826                 MP_WritePhyUshort(sc, 0x15, 0x03b7);
10827                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10828                 MP_WritePhyUshort(sc, 0x15, 0x03b8);
10829                 MP_WritePhyUshort(sc, 0x19, 0x543f);
10830                 MP_WritePhyUshort(sc, 0x15, 0x03b9);
10831                 MP_WritePhyUshort(sc, 0x19, 0x499a);
10832                 MP_WritePhyUshort(sc, 0x15, 0x03ba);
10833                 MP_WritePhyUshort(sc, 0x19, 0x7c40);
10834                 MP_WritePhyUshort(sc, 0x15, 0x03bb);
10835                 MP_WritePhyUshort(sc, 0x19, 0x4c40);
10836                 MP_WritePhyUshort(sc, 0x15, 0x03bc);
10837                 MP_WritePhyUshort(sc, 0x19, 0x490a);
10838                 MP_WritePhyUshort(sc, 0x15, 0x03bd);
10839                 MP_WritePhyUshort(sc, 0x19, 0x405e);
10840                 MP_WritePhyUshort(sc, 0x15, 0x03c2);
10841                 MP_WritePhyUshort(sc, 0x19, 0x9a03);
10842                 MP_WritePhyUshort(sc, 0x15, 0x03c4);
10843                 MP_WritePhyUshort(sc, 0x19, 0x0015);
10844                 MP_WritePhyUshort(sc, 0x15, 0x03c5);
10845                 MP_WritePhyUshort(sc, 0x19, 0x9e03);
10846                 MP_WritePhyUshort(sc, 0x15, 0x03c8);
10847                 MP_WritePhyUshort(sc, 0x19, 0x9cf7);
10848                 MP_WritePhyUshort(sc, 0x15, 0x03c9);
10849                 MP_WritePhyUshort(sc, 0x19, 0x7c12);
10850                 MP_WritePhyUshort(sc, 0x15, 0x03ca);
10851                 MP_WritePhyUshort(sc, 0x19, 0x4c52);
10852                 MP_WritePhyUshort(sc, 0x15, 0x03cb);
10853                 MP_WritePhyUshort(sc, 0x19, 0x4458);
10854                 MP_WritePhyUshort(sc, 0x15, 0x03cd);
10855                 MP_WritePhyUshort(sc, 0x19, 0x4c40);
10856                 MP_WritePhyUshort(sc, 0x15, 0x03ce);
10857                 MP_WritePhyUshort(sc, 0x19, 0x33bf);
10858                 MP_WritePhyUshort(sc, 0x15, 0x03cf);
10859                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10860                 MP_WritePhyUshort(sc, 0x15, 0x03d0);
10861                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10862                 MP_WritePhyUshort(sc, 0x15, 0x03d1);
10863                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10864                 MP_WritePhyUshort(sc, 0x15, 0x03d5);
10865                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10866                 MP_WritePhyUshort(sc, 0x15, 0x03d6);
10867                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10868                 MP_WritePhyUshort(sc, 0x15, 0x03d7);
10869                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10870                 MP_WritePhyUshort(sc, 0x15, 0x03d8);
10871                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10872                 MP_WritePhyUshort(sc, 0x15, 0x03d9);
10873                 MP_WritePhyUshort(sc, 0x19, 0x49bb);
10874                 MP_WritePhyUshort(sc, 0x15, 0x03da);
10875                 MP_WritePhyUshort(sc, 0x19, 0x4478);
10876                 MP_WritePhyUshort(sc, 0x15, 0x03db);
10877                 MP_WritePhyUshort(sc, 0x19, 0x492b);
10878                 MP_WritePhyUshort(sc, 0x15, 0x03dc);
10879                 MP_WritePhyUshort(sc, 0x19, 0x7c01);
10880                 MP_WritePhyUshort(sc, 0x15, 0x03dd);
10881                 MP_WritePhyUshort(sc, 0x19, 0x4c00);
10882                 MP_WritePhyUshort(sc, 0x15, 0x03de);
10883                 MP_WritePhyUshort(sc, 0x19, 0xbd1a);
10884                 MP_WritePhyUshort(sc, 0x15, 0x03df);
10885                 MP_WritePhyUshort(sc, 0x19, 0xc428);
10886                 MP_WritePhyUshort(sc, 0x15, 0x03e0);
10887                 MP_WritePhyUshort(sc, 0x19, 0x0008);
10888                 MP_WritePhyUshort(sc, 0x15, 0x03e1);
10889                 MP_WritePhyUshort(sc, 0x19, 0x9cfd);
10890                 MP_WritePhyUshort(sc, 0x15, 0x03e2);
10891                 MP_WritePhyUshort(sc, 0x19, 0x7c12);
10892                 MP_WritePhyUshort(sc, 0x15, 0x03e3);
10893                 MP_WritePhyUshort(sc, 0x19, 0x4c52);
10894                 MP_WritePhyUshort(sc, 0x15, 0x03e4);
10895                 MP_WritePhyUshort(sc, 0x19, 0x4458);
10896                 MP_WritePhyUshort(sc, 0x15, 0x03e5);
10897                 MP_WritePhyUshort(sc, 0x19, 0x7c12);
10898                 MP_WritePhyUshort(sc, 0x15, 0x03e6);
10899                 MP_WritePhyUshort(sc, 0x19, 0x4c40);
10900                 MP_WritePhyUshort(sc, 0x15, 0x03e7);
10901                 MP_WritePhyUshort(sc, 0x19, 0x33de);
10902                 MP_WritePhyUshort(sc, 0x15, 0x03e8);
10903                 MP_WritePhyUshort(sc, 0x19, 0xc218);
10904                 MP_WritePhyUshort(sc, 0x15, 0x03e9);
10905                 MP_WritePhyUshort(sc, 0x19, 0x0002);
10906                 MP_WritePhyUshort(sc, 0x15, 0x03ea);
10907                 MP_WritePhyUshort(sc, 0x19, 0x32df);
10908                 MP_WritePhyUshort(sc, 0x15, 0x03eb);
10909                 MP_WritePhyUshort(sc, 0x19, 0x3316);
10910                 MP_WritePhyUshort(sc, 0x15, 0x03ec);
10911                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10912                 MP_WritePhyUshort(sc, 0x15, 0x03ed);
10913                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10914                 MP_WritePhyUshort(sc, 0x15, 0x03ee);
10915                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10916                 MP_WritePhyUshort(sc, 0x15, 0x03ef);
10917                 MP_WritePhyUshort(sc, 0x19, 0x0000);
10918                 MP_WritePhyUshort(sc, 0x15, 0x03f7);
10919                 MP_WritePhyUshort(sc, 0x19, 0x330c);
10920                 MP_WritePhyUshort(sc, 0x16, 0x0306);
10921                 MP_WritePhyUshort(sc, 0x16, 0x0300);
10922                 MP_WritePhyUshort(sc, 0x1f, 0x0005);
10923                 MP_WritePhyUshort(sc, 0x05, 0xfff6);
10924                 MP_WritePhyUshort(sc, 0x06, 0x0080);
10925                 MP_WritePhyUshort(sc, 0x05, 0x8000);
10926                 MP_WritePhyUshort(sc, 0x06, 0x0280);
10927                 MP_WritePhyUshort(sc, 0x06, 0x48f7);
10928                 MP_WritePhyUshort(sc, 0x06, 0x00e0);
10929                 MP_WritePhyUshort(sc, 0x06, 0xfff7);
10930                 MP_WritePhyUshort(sc, 0x06, 0xa080);
10931                 MP_WritePhyUshort(sc, 0x06, 0x02ae);
10932                 MP_WritePhyUshort(sc, 0x06, 0xf602);
10933                 MP_WritePhyUshort(sc, 0x06, 0x0200);
10934                 MP_WritePhyUshort(sc, 0x06, 0x0280);
10935                 MP_WritePhyUshort(sc, 0x06, 0x9002);
10936                 MP_WritePhyUshort(sc, 0x06, 0x0224);
10937                 MP_WritePhyUshort(sc, 0x06, 0x0202);
10938                 MP_WritePhyUshort(sc, 0x06, 0x3402);
10939                 MP_WritePhyUshort(sc, 0x06, 0x027f);
10940                 MP_WritePhyUshort(sc, 0x06, 0x0280);
10941                 MP_WritePhyUshort(sc, 0x06, 0xa602);
10942                 MP_WritePhyUshort(sc, 0x06, 0x80bf);
10943                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
10944                 MP_WritePhyUshort(sc, 0x06, 0x88e1);
10945                 MP_WritePhyUshort(sc, 0x06, 0x8b89);
10946                 MP_WritePhyUshort(sc, 0x06, 0x1e01);
10947                 MP_WritePhyUshort(sc, 0x06, 0xe18b);
10948                 MP_WritePhyUshort(sc, 0x06, 0x8a1e);
10949                 MP_WritePhyUshort(sc, 0x06, 0x01e1);
10950                 MP_WritePhyUshort(sc, 0x06, 0x8b8b);
10951                 MP_WritePhyUshort(sc, 0x06, 0x1e01);
10952                 MP_WritePhyUshort(sc, 0x06, 0xe18b);
10953                 MP_WritePhyUshort(sc, 0x06, 0x8c1e);
10954                 MP_WritePhyUshort(sc, 0x06, 0x01e1);
10955                 MP_WritePhyUshort(sc, 0x06, 0x8b8d);
10956                 MP_WritePhyUshort(sc, 0x06, 0x1e01);
10957                 MP_WritePhyUshort(sc, 0x06, 0xe18b);
10958                 MP_WritePhyUshort(sc, 0x06, 0x8e1e);
10959                 MP_WritePhyUshort(sc, 0x06, 0x01a0);
10960                 MP_WritePhyUshort(sc, 0x06, 0x00c7);
10961                 MP_WritePhyUshort(sc, 0x06, 0xaebb);
10962                 MP_WritePhyUshort(sc, 0x06, 0xee8a);
10963                 MP_WritePhyUshort(sc, 0x06, 0xe600);
10964                 MP_WritePhyUshort(sc, 0x06, 0xee8a);
10965                 MP_WritePhyUshort(sc, 0x06, 0xee03);
10966                 MP_WritePhyUshort(sc, 0x06, 0xee8a);
10967                 MP_WritePhyUshort(sc, 0x06, 0xefb8);
10968                 MP_WritePhyUshort(sc, 0x06, 0xee8a);
10969                 MP_WritePhyUshort(sc, 0x06, 0xe902);
10970                 MP_WritePhyUshort(sc, 0x06, 0xee8b);
10971                 MP_WritePhyUshort(sc, 0x06, 0x8285);
10972                 MP_WritePhyUshort(sc, 0x06, 0xee8b);
10973                 MP_WritePhyUshort(sc, 0x06, 0x8520);
10974                 MP_WritePhyUshort(sc, 0x06, 0xee8b);
10975                 MP_WritePhyUshort(sc, 0x06, 0x8701);
10976                 MP_WritePhyUshort(sc, 0x06, 0xd481);
10977                 MP_WritePhyUshort(sc, 0x06, 0x35e4);
10978                 MP_WritePhyUshort(sc, 0x06, 0x8b94);
10979                 MP_WritePhyUshort(sc, 0x06, 0xe58b);
10980                 MP_WritePhyUshort(sc, 0x06, 0x95bf);
10981                 MP_WritePhyUshort(sc, 0x06, 0x8b88);
10982                 MP_WritePhyUshort(sc, 0x06, 0xec00);
10983                 MP_WritePhyUshort(sc, 0x06, 0x19a9);
10984                 MP_WritePhyUshort(sc, 0x06, 0x8b90);
10985                 MP_WritePhyUshort(sc, 0x06, 0xf9ee);
10986                 MP_WritePhyUshort(sc, 0x06, 0xfff6);
10987                 MP_WritePhyUshort(sc, 0x06, 0x00ee);
10988                 MP_WritePhyUshort(sc, 0x06, 0xfff7);
10989                 MP_WritePhyUshort(sc, 0x06, 0xffe0);
10990                 MP_WritePhyUshort(sc, 0x06, 0xe140);
10991                 MP_WritePhyUshort(sc, 0x06, 0xe1e1);
10992                 MP_WritePhyUshort(sc, 0x06, 0x41f7);
10993                 MP_WritePhyUshort(sc, 0x06, 0x2ff6);
10994                 MP_WritePhyUshort(sc, 0x06, 0x28e4);
10995                 MP_WritePhyUshort(sc, 0x06, 0xe140);
10996                 MP_WritePhyUshort(sc, 0x06, 0xe5e1);
10997                 MP_WritePhyUshort(sc, 0x06, 0x4104);
10998                 MP_WritePhyUshort(sc, 0x06, 0xf8e0);
10999                 MP_WritePhyUshort(sc, 0x06, 0x8b89);
11000                 MP_WritePhyUshort(sc, 0x06, 0xad20);
11001                 MP_WritePhyUshort(sc, 0x06, 0x0dee);
11002                 MP_WritePhyUshort(sc, 0x06, 0x8b89);
11003                 MP_WritePhyUshort(sc, 0x06, 0x0002);
11004                 MP_WritePhyUshort(sc, 0x06, 0x82f4);
11005                 MP_WritePhyUshort(sc, 0x06, 0x021f);
11006                 MP_WritePhyUshort(sc, 0x06, 0x4102);
11007                 MP_WritePhyUshort(sc, 0x06, 0x2812);
11008                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
11009                 MP_WritePhyUshort(sc, 0x06, 0xf8e0);
11010                 MP_WritePhyUshort(sc, 0x06, 0x8b8d);
11011                 MP_WritePhyUshort(sc, 0x06, 0xad20);
11012                 MP_WritePhyUshort(sc, 0x06, 0x10ee);
11013                 MP_WritePhyUshort(sc, 0x06, 0x8b8d);
11014                 MP_WritePhyUshort(sc, 0x06, 0x0002);
11015                 MP_WritePhyUshort(sc, 0x06, 0x139d);
11016                 MP_WritePhyUshort(sc, 0x06, 0x0281);
11017                 MP_WritePhyUshort(sc, 0x06, 0xd602);
11018                 MP_WritePhyUshort(sc, 0x06, 0x1f99);
11019                 MP_WritePhyUshort(sc, 0x06, 0x0227);
11020                 MP_WritePhyUshort(sc, 0x06, 0xeafc);
11021                 MP_WritePhyUshort(sc, 0x06, 0x04f8);
11022                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
11023                 MP_WritePhyUshort(sc, 0x06, 0x8ead);
11024                 MP_WritePhyUshort(sc, 0x06, 0x2014);
11025                 MP_WritePhyUshort(sc, 0x06, 0xf620);
11026                 MP_WritePhyUshort(sc, 0x06, 0xe48b);
11027                 MP_WritePhyUshort(sc, 0x06, 0x8e02);
11028                 MP_WritePhyUshort(sc, 0x06, 0x8104);
11029                 MP_WritePhyUshort(sc, 0x06, 0x021b);
11030                 MP_WritePhyUshort(sc, 0x06, 0xf402);
11031                 MP_WritePhyUshort(sc, 0x06, 0x2c9c);
11032                 MP_WritePhyUshort(sc, 0x06, 0x0281);
11033                 MP_WritePhyUshort(sc, 0x06, 0x7902);
11034                 MP_WritePhyUshort(sc, 0x06, 0x8443);
11035                 MP_WritePhyUshort(sc, 0x06, 0xad22);
11036                 MP_WritePhyUshort(sc, 0x06, 0x11f6);
11037                 MP_WritePhyUshort(sc, 0x06, 0x22e4);
11038                 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
11039                 MP_WritePhyUshort(sc, 0x06, 0x022c);
11040                 MP_WritePhyUshort(sc, 0x06, 0x4602);
11041                 MP_WritePhyUshort(sc, 0x06, 0x2ac5);
11042                 MP_WritePhyUshort(sc, 0x06, 0x0229);
11043                 MP_WritePhyUshort(sc, 0x06, 0x2002);
11044                 MP_WritePhyUshort(sc, 0x06, 0x2b91);
11045                 MP_WritePhyUshort(sc, 0x06, 0xad25);
11046                 MP_WritePhyUshort(sc, 0x06, 0x11f6);
11047                 MP_WritePhyUshort(sc, 0x06, 0x25e4);
11048                 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
11049                 MP_WritePhyUshort(sc, 0x06, 0x0284);
11050                 MP_WritePhyUshort(sc, 0x06, 0xe202);
11051                 MP_WritePhyUshort(sc, 0x06, 0x043a);
11052                 MP_WritePhyUshort(sc, 0x06, 0x021a);
11053                 MP_WritePhyUshort(sc, 0x06, 0x5902);
11054                 MP_WritePhyUshort(sc, 0x06, 0x2bfc);
11055                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
11056                 MP_WritePhyUshort(sc, 0x06, 0xf8fa);
11057                 MP_WritePhyUshort(sc, 0x06, 0xef69);
11058                 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
11059                 MP_WritePhyUshort(sc, 0x06, 0x00e1);
11060                 MP_WritePhyUshort(sc, 0x06, 0xe001);
11061                 MP_WritePhyUshort(sc, 0x06, 0xad27);
11062                 MP_WritePhyUshort(sc, 0x06, 0x1fd1);
11063                 MP_WritePhyUshort(sc, 0x06, 0x01bf);
11064                 MP_WritePhyUshort(sc, 0x06, 0x8638);
11065                 MP_WritePhyUshort(sc, 0x06, 0x022f);
11066                 MP_WritePhyUshort(sc, 0x06, 0x50e0);
11067                 MP_WritePhyUshort(sc, 0x06, 0xe020);
11068                 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
11069                 MP_WritePhyUshort(sc, 0x06, 0x21ad);
11070                 MP_WritePhyUshort(sc, 0x06, 0x200e);
11071                 MP_WritePhyUshort(sc, 0x06, 0xd100);
11072                 MP_WritePhyUshort(sc, 0x06, 0xbf86);
11073                 MP_WritePhyUshort(sc, 0x06, 0x3802);
11074                 MP_WritePhyUshort(sc, 0x06, 0x2f50);
11075                 MP_WritePhyUshort(sc, 0x06, 0xbf3d);
11076                 MP_WritePhyUshort(sc, 0x06, 0x3902);
11077                 MP_WritePhyUshort(sc, 0x06, 0x2eb0);
11078                 MP_WritePhyUshort(sc, 0x06, 0xef96);
11079                 MP_WritePhyUshort(sc, 0x06, 0xfefc);
11080                 MP_WritePhyUshort(sc, 0x06, 0x0402);
11081                 MP_WritePhyUshort(sc, 0x06, 0x8591);
11082                 MP_WritePhyUshort(sc, 0x06, 0x0281);
11083                 MP_WritePhyUshort(sc, 0x06, 0x3c05);
11084                 MP_WritePhyUshort(sc, 0x06, 0xf8fa);
11085                 MP_WritePhyUshort(sc, 0x06, 0xef69);
11086                 MP_WritePhyUshort(sc, 0x06, 0xe0e2);
11087                 MP_WritePhyUshort(sc, 0x06, 0xfee1);
11088                 MP_WritePhyUshort(sc, 0x06, 0xe2ff);
11089                 MP_WritePhyUshort(sc, 0x06, 0xad2d);
11090                 MP_WritePhyUshort(sc, 0x06, 0x1ae0);
11091                 MP_WritePhyUshort(sc, 0x06, 0xe14e);
11092                 MP_WritePhyUshort(sc, 0x06, 0xe1e1);
11093                 MP_WritePhyUshort(sc, 0x06, 0x4fac);
11094                 MP_WritePhyUshort(sc, 0x06, 0x2d22);
11095                 MP_WritePhyUshort(sc, 0x06, 0xf603);
11096                 MP_WritePhyUshort(sc, 0x06, 0x0203);
11097                 MP_WritePhyUshort(sc, 0x06, 0x36f7);
11098                 MP_WritePhyUshort(sc, 0x06, 0x03f7);
11099                 MP_WritePhyUshort(sc, 0x06, 0x06bf);
11100                 MP_WritePhyUshort(sc, 0x06, 0x8622);
11101                 MP_WritePhyUshort(sc, 0x06, 0x022e);
11102                 MP_WritePhyUshort(sc, 0x06, 0xb0ae);
11103                 MP_WritePhyUshort(sc, 0x06, 0x11e0);
11104                 MP_WritePhyUshort(sc, 0x06, 0xe14e);
11105                 MP_WritePhyUshort(sc, 0x06, 0xe1e1);
11106                 MP_WritePhyUshort(sc, 0x06, 0x4fad);
11107                 MP_WritePhyUshort(sc, 0x06, 0x2d08);
11108                 MP_WritePhyUshort(sc, 0x06, 0xbf86);
11109                 MP_WritePhyUshort(sc, 0x06, 0x2d02);
11110                 MP_WritePhyUshort(sc, 0x06, 0x2eb0);
11111                 MP_WritePhyUshort(sc, 0x06, 0xf606);
11112                 MP_WritePhyUshort(sc, 0x06, 0xef96);
11113                 MP_WritePhyUshort(sc, 0x06, 0xfefc);
11114                 MP_WritePhyUshort(sc, 0x06, 0x04f8);
11115                 MP_WritePhyUshort(sc, 0x06, 0xf9fa);
11116                 MP_WritePhyUshort(sc, 0x06, 0xef69);
11117                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
11118                 MP_WritePhyUshort(sc, 0x06, 0x87ad);
11119                 MP_WritePhyUshort(sc, 0x06, 0x204c);
11120                 MP_WritePhyUshort(sc, 0x06, 0xd200);
11121                 MP_WritePhyUshort(sc, 0x06, 0xe0e2);
11122                 MP_WritePhyUshort(sc, 0x06, 0x0058);
11123                 MP_WritePhyUshort(sc, 0x06, 0x010c);
11124                 MP_WritePhyUshort(sc, 0x06, 0x021e);
11125                 MP_WritePhyUshort(sc, 0x06, 0x20e0);
11126                 MP_WritePhyUshort(sc, 0x06, 0xe000);
11127                 MP_WritePhyUshort(sc, 0x06, 0x5810);
11128                 MP_WritePhyUshort(sc, 0x06, 0x1e20);
11129                 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
11130                 MP_WritePhyUshort(sc, 0x06, 0x3658);
11131                 MP_WritePhyUshort(sc, 0x06, 0x031e);
11132                 MP_WritePhyUshort(sc, 0x06, 0x20e0);
11133                 MP_WritePhyUshort(sc, 0x06, 0xe022);
11134                 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
11135                 MP_WritePhyUshort(sc, 0x06, 0x2358);
11136                 MP_WritePhyUshort(sc, 0x06, 0xe01e);
11137                 MP_WritePhyUshort(sc, 0x06, 0x20e0);
11138                 MP_WritePhyUshort(sc, 0x06, 0x8ae6);
11139                 MP_WritePhyUshort(sc, 0x06, 0x1f02);
11140                 MP_WritePhyUshort(sc, 0x06, 0x9e22);
11141                 MP_WritePhyUshort(sc, 0x06, 0xe68a);
11142                 MP_WritePhyUshort(sc, 0x06, 0xe6ad);
11143                 MP_WritePhyUshort(sc, 0x06, 0x3214);
11144                 MP_WritePhyUshort(sc, 0x06, 0xad34);
11145                 MP_WritePhyUshort(sc, 0x06, 0x11ef);
11146                 MP_WritePhyUshort(sc, 0x06, 0x0258);
11147                 MP_WritePhyUshort(sc, 0x06, 0x039e);
11148                 MP_WritePhyUshort(sc, 0x06, 0x07ad);
11149                 MP_WritePhyUshort(sc, 0x06, 0x3508);
11150                 MP_WritePhyUshort(sc, 0x06, 0x5ac0);
11151                 MP_WritePhyUshort(sc, 0x06, 0x9f04);
11152                 MP_WritePhyUshort(sc, 0x06, 0xd101);
11153                 MP_WritePhyUshort(sc, 0x06, 0xae02);
11154                 MP_WritePhyUshort(sc, 0x06, 0xd100);
11155                 MP_WritePhyUshort(sc, 0x06, 0xbf86);
11156                 MP_WritePhyUshort(sc, 0x06, 0x3e02);
11157                 MP_WritePhyUshort(sc, 0x06, 0x2f50);
11158                 MP_WritePhyUshort(sc, 0x06, 0xef96);
11159                 MP_WritePhyUshort(sc, 0x06, 0xfefd);
11160                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
11161                 MP_WritePhyUshort(sc, 0x06, 0xf8f9);
11162                 MP_WritePhyUshort(sc, 0x06, 0xfae0);
11163                 MP_WritePhyUshort(sc, 0x06, 0x8b81);
11164                 MP_WritePhyUshort(sc, 0x06, 0xac26);
11165                 MP_WritePhyUshort(sc, 0x06, 0x0ee0);
11166                 MP_WritePhyUshort(sc, 0x06, 0x8b81);
11167                 MP_WritePhyUshort(sc, 0x06, 0xac21);
11168                 MP_WritePhyUshort(sc, 0x06, 0x08e0);
11169                 MP_WritePhyUshort(sc, 0x06, 0x8b87);
11170                 MP_WritePhyUshort(sc, 0x06, 0xac24);
11171                 MP_WritePhyUshort(sc, 0x06, 0x02ae);
11172                 MP_WritePhyUshort(sc, 0x06, 0x6bee);
11173                 MP_WritePhyUshort(sc, 0x06, 0xe0ea);
11174                 MP_WritePhyUshort(sc, 0x06, 0x00ee);
11175                 MP_WritePhyUshort(sc, 0x06, 0xe0eb);
11176                 MP_WritePhyUshort(sc, 0x06, 0x00e2);
11177                 MP_WritePhyUshort(sc, 0x06, 0xe07c);
11178                 MP_WritePhyUshort(sc, 0x06, 0xe3e0);
11179                 MP_WritePhyUshort(sc, 0x06, 0x7da5);
11180                 MP_WritePhyUshort(sc, 0x06, 0x1111);
11181                 MP_WritePhyUshort(sc, 0x06, 0x15d2);
11182                 MP_WritePhyUshort(sc, 0x06, 0x60d6);
11183                 MP_WritePhyUshort(sc, 0x06, 0x6666);
11184                 MP_WritePhyUshort(sc, 0x06, 0x0207);
11185                 MP_WritePhyUshort(sc, 0x06, 0xf9d2);
11186                 MP_WritePhyUshort(sc, 0x06, 0xa0d6);
11187                 MP_WritePhyUshort(sc, 0x06, 0xaaaa);
11188                 MP_WritePhyUshort(sc, 0x06, 0x0207);
11189                 MP_WritePhyUshort(sc, 0x06, 0xf902);
11190                 MP_WritePhyUshort(sc, 0x06, 0x825c);
11191                 MP_WritePhyUshort(sc, 0x06, 0xae44);
11192                 MP_WritePhyUshort(sc, 0x06, 0xa566);
11193                 MP_WritePhyUshort(sc, 0x06, 0x6602);
11194                 MP_WritePhyUshort(sc, 0x06, 0xae38);
11195                 MP_WritePhyUshort(sc, 0x06, 0xa5aa);
11196                 MP_WritePhyUshort(sc, 0x06, 0xaa02);
11197                 MP_WritePhyUshort(sc, 0x06, 0xae32);
11198                 MP_WritePhyUshort(sc, 0x06, 0xeee0);
11199                 MP_WritePhyUshort(sc, 0x06, 0xea04);
11200                 MP_WritePhyUshort(sc, 0x06, 0xeee0);
11201                 MP_WritePhyUshort(sc, 0x06, 0xeb06);
11202                 MP_WritePhyUshort(sc, 0x06, 0xe2e0);
11203                 MP_WritePhyUshort(sc, 0x06, 0x7ce3);
11204                 MP_WritePhyUshort(sc, 0x06, 0xe07d);
11205                 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
11206                 MP_WritePhyUshort(sc, 0x06, 0x38e1);
11207                 MP_WritePhyUshort(sc, 0x06, 0xe039);
11208                 MP_WritePhyUshort(sc, 0x06, 0xad2e);
11209                 MP_WritePhyUshort(sc, 0x06, 0x21ad);
11210                 MP_WritePhyUshort(sc, 0x06, 0x3f13);
11211                 MP_WritePhyUshort(sc, 0x06, 0xe0e4);
11212                 MP_WritePhyUshort(sc, 0x06, 0x14e1);
11213                 MP_WritePhyUshort(sc, 0x06, 0xe415);
11214                 MP_WritePhyUshort(sc, 0x06, 0x6880);
11215                 MP_WritePhyUshort(sc, 0x06, 0xe4e4);
11216                 MP_WritePhyUshort(sc, 0x06, 0x14e5);
11217                 MP_WritePhyUshort(sc, 0x06, 0xe415);
11218                 MP_WritePhyUshort(sc, 0x06, 0x0282);
11219                 MP_WritePhyUshort(sc, 0x06, 0x5cae);
11220                 MP_WritePhyUshort(sc, 0x06, 0x0bac);
11221                 MP_WritePhyUshort(sc, 0x06, 0x3e02);
11222                 MP_WritePhyUshort(sc, 0x06, 0xae06);
11223                 MP_WritePhyUshort(sc, 0x06, 0x0282);
11224                 MP_WritePhyUshort(sc, 0x06, 0x8602);
11225                 MP_WritePhyUshort(sc, 0x06, 0x82b0);
11226                 MP_WritePhyUshort(sc, 0x06, 0xfefd);
11227                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
11228                 MP_WritePhyUshort(sc, 0x06, 0xf8e1);
11229                 MP_WritePhyUshort(sc, 0x06, 0x8b2e);
11230                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
11231                 MP_WritePhyUshort(sc, 0x06, 0x81ad);
11232                 MP_WritePhyUshort(sc, 0x06, 0x2605);
11233                 MP_WritePhyUshort(sc, 0x06, 0x0221);
11234                 MP_WritePhyUshort(sc, 0x06, 0xf3f7);
11235                 MP_WritePhyUshort(sc, 0x06, 0x28e0);
11236                 MP_WritePhyUshort(sc, 0x06, 0x8b81);
11237                 MP_WritePhyUshort(sc, 0x06, 0xad21);
11238                 MP_WritePhyUshort(sc, 0x06, 0x0502);
11239                 MP_WritePhyUshort(sc, 0x06, 0x22f8);
11240                 MP_WritePhyUshort(sc, 0x06, 0xf729);
11241                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
11242                 MP_WritePhyUshort(sc, 0x06, 0x87ad);
11243                 MP_WritePhyUshort(sc, 0x06, 0x2405);
11244                 MP_WritePhyUshort(sc, 0x06, 0x0282);
11245                 MP_WritePhyUshort(sc, 0x06, 0xebf7);
11246                 MP_WritePhyUshort(sc, 0x06, 0x2ae5);
11247                 MP_WritePhyUshort(sc, 0x06, 0x8b2e);
11248                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
11249                 MP_WritePhyUshort(sc, 0x06, 0xf8e0);
11250                 MP_WritePhyUshort(sc, 0x06, 0x8b81);
11251                 MP_WritePhyUshort(sc, 0x06, 0xad26);
11252                 MP_WritePhyUshort(sc, 0x06, 0x0302);
11253                 MP_WritePhyUshort(sc, 0x06, 0x2134);
11254                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
11255                 MP_WritePhyUshort(sc, 0x06, 0x81ad);
11256                 MP_WritePhyUshort(sc, 0x06, 0x2109);
11257                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
11258                 MP_WritePhyUshort(sc, 0x06, 0x2eac);
11259                 MP_WritePhyUshort(sc, 0x06, 0x2003);
11260                 MP_WritePhyUshort(sc, 0x06, 0x0283);
11261                 MP_WritePhyUshort(sc, 0x06, 0x52e0);
11262                 MP_WritePhyUshort(sc, 0x06, 0x8b87);
11263                 MP_WritePhyUshort(sc, 0x06, 0xad24);
11264                 MP_WritePhyUshort(sc, 0x06, 0x09e0);
11265                 MP_WritePhyUshort(sc, 0x06, 0x8b2e);
11266                 MP_WritePhyUshort(sc, 0x06, 0xac21);
11267                 MP_WritePhyUshort(sc, 0x06, 0x0302);
11268                 MP_WritePhyUshort(sc, 0x06, 0x8337);
11269                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
11270                 MP_WritePhyUshort(sc, 0x06, 0xf8e1);
11271                 MP_WritePhyUshort(sc, 0x06, 0x8b2e);
11272                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
11273                 MP_WritePhyUshort(sc, 0x06, 0x81ad);
11274                 MP_WritePhyUshort(sc, 0x06, 0x2608);
11275                 MP_WritePhyUshort(sc, 0x06, 0xe085);
11276                 MP_WritePhyUshort(sc, 0x06, 0xd2ad);
11277                 MP_WritePhyUshort(sc, 0x06, 0x2502);
11278                 MP_WritePhyUshort(sc, 0x06, 0xf628);
11279                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
11280                 MP_WritePhyUshort(sc, 0x06, 0x81ad);
11281                 MP_WritePhyUshort(sc, 0x06, 0x210a);
11282                 MP_WritePhyUshort(sc, 0x06, 0xe086);
11283                 MP_WritePhyUshort(sc, 0x06, 0x0af6);
11284                 MP_WritePhyUshort(sc, 0x06, 0x27a0);
11285                 MP_WritePhyUshort(sc, 0x06, 0x0502);
11286                 MP_WritePhyUshort(sc, 0x06, 0xf629);
11287                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
11288                 MP_WritePhyUshort(sc, 0x06, 0x87ad);
11289                 MP_WritePhyUshort(sc, 0x06, 0x2408);
11290                 MP_WritePhyUshort(sc, 0x06, 0xe08a);
11291                 MP_WritePhyUshort(sc, 0x06, 0xedad);
11292                 MP_WritePhyUshort(sc, 0x06, 0x2002);
11293                 MP_WritePhyUshort(sc, 0x06, 0xf62a);
11294                 MP_WritePhyUshort(sc, 0x06, 0xe58b);
11295                 MP_WritePhyUshort(sc, 0x06, 0x2ea1);
11296                 MP_WritePhyUshort(sc, 0x06, 0x0003);
11297                 MP_WritePhyUshort(sc, 0x06, 0x0221);
11298                 MP_WritePhyUshort(sc, 0x06, 0x11fc);
11299                 MP_WritePhyUshort(sc, 0x06, 0x04ee);
11300                 MP_WritePhyUshort(sc, 0x06, 0x8aed);
11301                 MP_WritePhyUshort(sc, 0x06, 0x00ee);
11302                 MP_WritePhyUshort(sc, 0x06, 0x8aec);
11303                 MP_WritePhyUshort(sc, 0x06, 0x0004);
11304                 MP_WritePhyUshort(sc, 0x06, 0xf8e0);
11305                 MP_WritePhyUshort(sc, 0x06, 0x8b87);
11306                 MP_WritePhyUshort(sc, 0x06, 0xad24);
11307                 MP_WritePhyUshort(sc, 0x06, 0x3ae0);
11308                 MP_WritePhyUshort(sc, 0x06, 0xe0ea);
11309                 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
11310                 MP_WritePhyUshort(sc, 0x06, 0xeb58);
11311                 MP_WritePhyUshort(sc, 0x06, 0xf8d1);
11312                 MP_WritePhyUshort(sc, 0x06, 0x01e4);
11313                 MP_WritePhyUshort(sc, 0x06, 0xe0ea);
11314                 MP_WritePhyUshort(sc, 0x06, 0xe5e0);
11315                 MP_WritePhyUshort(sc, 0x06, 0xebe0);
11316                 MP_WritePhyUshort(sc, 0x06, 0xe07c);
11317                 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
11318                 MP_WritePhyUshort(sc, 0x06, 0x7d5c);
11319                 MP_WritePhyUshort(sc, 0x06, 0x00ff);
11320                 MP_WritePhyUshort(sc, 0x06, 0x3c00);
11321                 MP_WritePhyUshort(sc, 0x06, 0x1eab);
11322                 MP_WritePhyUshort(sc, 0x06, 0x1ce0);
11323                 MP_WritePhyUshort(sc, 0x06, 0xe04c);
11324                 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
11325                 MP_WritePhyUshort(sc, 0x06, 0x4d58);
11326                 MP_WritePhyUshort(sc, 0x06, 0xc1e4);
11327                 MP_WritePhyUshort(sc, 0x06, 0xe04c);
11328                 MP_WritePhyUshort(sc, 0x06, 0xe5e0);
11329                 MP_WritePhyUshort(sc, 0x06, 0x4de0);
11330                 MP_WritePhyUshort(sc, 0x06, 0xe0ee);
11331                 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
11332                 MP_WritePhyUshort(sc, 0x06, 0xef69);
11333                 MP_WritePhyUshort(sc, 0x06, 0x3ce4);
11334                 MP_WritePhyUshort(sc, 0x06, 0xe0ee);
11335                 MP_WritePhyUshort(sc, 0x06, 0xe5e0);
11336                 MP_WritePhyUshort(sc, 0x06, 0xeffc);
11337                 MP_WritePhyUshort(sc, 0x06, 0x04f8);
11338                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
11339                 MP_WritePhyUshort(sc, 0x06, 0x87ad);
11340                 MP_WritePhyUshort(sc, 0x06, 0x2412);
11341                 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
11342                 MP_WritePhyUshort(sc, 0x06, 0xeee1);
11343                 MP_WritePhyUshort(sc, 0x06, 0xe0ef);
11344                 MP_WritePhyUshort(sc, 0x06, 0x59c3);
11345                 MP_WritePhyUshort(sc, 0x06, 0xe4e0);
11346                 MP_WritePhyUshort(sc, 0x06, 0xeee5);
11347                 MP_WritePhyUshort(sc, 0x06, 0xe0ef);
11348                 MP_WritePhyUshort(sc, 0x06, 0xee8a);
11349                 MP_WritePhyUshort(sc, 0x06, 0xed01);
11350                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
11351                 MP_WritePhyUshort(sc, 0x06, 0xf8e0);
11352                 MP_WritePhyUshort(sc, 0x06, 0x8b81);
11353                 MP_WritePhyUshort(sc, 0x06, 0xac25);
11354                 MP_WritePhyUshort(sc, 0x06, 0x0502);
11355                 MP_WritePhyUshort(sc, 0x06, 0x8363);
11356                 MP_WritePhyUshort(sc, 0x06, 0xae03);
11357                 MP_WritePhyUshort(sc, 0x06, 0x0225);
11358                 MP_WritePhyUshort(sc, 0x06, 0x16fc);
11359                 MP_WritePhyUshort(sc, 0x06, 0x04f8);
11360                 MP_WritePhyUshort(sc, 0x06, 0xf9fa);
11361                 MP_WritePhyUshort(sc, 0x06, 0xef69);
11362                 MP_WritePhyUshort(sc, 0x06, 0xfae0);
11363                 MP_WritePhyUshort(sc, 0x06, 0x860a);
11364                 MP_WritePhyUshort(sc, 0x06, 0xa000);
11365                 MP_WritePhyUshort(sc, 0x06, 0x19e0);
11366                 MP_WritePhyUshort(sc, 0x06, 0x860b);
11367                 MP_WritePhyUshort(sc, 0x06, 0xe18b);
11368                 MP_WritePhyUshort(sc, 0x06, 0x331b);
11369                 MP_WritePhyUshort(sc, 0x06, 0x109e);
11370                 MP_WritePhyUshort(sc, 0x06, 0x04aa);
11371                 MP_WritePhyUshort(sc, 0x06, 0x02ae);
11372                 MP_WritePhyUshort(sc, 0x06, 0x06ee);
11373                 MP_WritePhyUshort(sc, 0x06, 0x860a);
11374                 MP_WritePhyUshort(sc, 0x06, 0x01ae);
11375                 MP_WritePhyUshort(sc, 0x06, 0xe602);
11376                 MP_WritePhyUshort(sc, 0x06, 0x241e);
11377                 MP_WritePhyUshort(sc, 0x06, 0xae14);
11378                 MP_WritePhyUshort(sc, 0x06, 0xa001);
11379                 MP_WritePhyUshort(sc, 0x06, 0x1402);
11380                 MP_WritePhyUshort(sc, 0x06, 0x2426);
11381                 MP_WritePhyUshort(sc, 0x06, 0xbf26);
11382                 MP_WritePhyUshort(sc, 0x06, 0x6d02);
11383                 MP_WritePhyUshort(sc, 0x06, 0x2eb0);
11384                 MP_WritePhyUshort(sc, 0x06, 0xee86);
11385                 MP_WritePhyUshort(sc, 0x06, 0x0b00);
11386                 MP_WritePhyUshort(sc, 0x06, 0xee86);
11387                 MP_WritePhyUshort(sc, 0x06, 0x0a02);
11388                 MP_WritePhyUshort(sc, 0x06, 0xaf84);
11389                 MP_WritePhyUshort(sc, 0x06, 0x3ca0);
11390                 MP_WritePhyUshort(sc, 0x06, 0x0252);
11391                 MP_WritePhyUshort(sc, 0x06, 0xee86);
11392                 MP_WritePhyUshort(sc, 0x06, 0x0400);
11393                 MP_WritePhyUshort(sc, 0x06, 0xee86);
11394                 MP_WritePhyUshort(sc, 0x06, 0x0500);
11395                 MP_WritePhyUshort(sc, 0x06, 0xe086);
11396                 MP_WritePhyUshort(sc, 0x06, 0x0be1);
11397                 MP_WritePhyUshort(sc, 0x06, 0x8b32);
11398                 MP_WritePhyUshort(sc, 0x06, 0x1b10);
11399                 MP_WritePhyUshort(sc, 0x06, 0x9e04);
11400                 MP_WritePhyUshort(sc, 0x06, 0xaa02);
11401                 MP_WritePhyUshort(sc, 0x06, 0xaecb);
11402                 MP_WritePhyUshort(sc, 0x06, 0xee86);
11403                 MP_WritePhyUshort(sc, 0x06, 0x0b00);
11404                 MP_WritePhyUshort(sc, 0x06, 0x0224);
11405                 MP_WritePhyUshort(sc, 0x06, 0x3ae2);
11406                 MP_WritePhyUshort(sc, 0x06, 0x8604);
11407                 MP_WritePhyUshort(sc, 0x06, 0xe386);
11408                 MP_WritePhyUshort(sc, 0x06, 0x05ef);
11409                 MP_WritePhyUshort(sc, 0x06, 0x65e2);
11410                 MP_WritePhyUshort(sc, 0x06, 0x8606);
11411                 MP_WritePhyUshort(sc, 0x06, 0xe386);
11412                 MP_WritePhyUshort(sc, 0x06, 0x071b);
11413                 MP_WritePhyUshort(sc, 0x06, 0x56aa);
11414                 MP_WritePhyUshort(sc, 0x06, 0x0eef);
11415                 MP_WritePhyUshort(sc, 0x06, 0x56e6);
11416                 MP_WritePhyUshort(sc, 0x06, 0x8606);
11417                 MP_WritePhyUshort(sc, 0x06, 0xe786);
11418                 MP_WritePhyUshort(sc, 0x06, 0x07e2);
11419                 MP_WritePhyUshort(sc, 0x06, 0x8609);
11420                 MP_WritePhyUshort(sc, 0x06, 0xe686);
11421                 MP_WritePhyUshort(sc, 0x06, 0x08e0);
11422                 MP_WritePhyUshort(sc, 0x06, 0x8609);
11423                 MP_WritePhyUshort(sc, 0x06, 0xa000);
11424                 MP_WritePhyUshort(sc, 0x06, 0x07ee);
11425                 MP_WritePhyUshort(sc, 0x06, 0x860a);
11426                 MP_WritePhyUshort(sc, 0x06, 0x03af);
11427                 MP_WritePhyUshort(sc, 0x06, 0x8369);
11428                 MP_WritePhyUshort(sc, 0x06, 0x0224);
11429                 MP_WritePhyUshort(sc, 0x06, 0x8e02);
11430                 MP_WritePhyUshort(sc, 0x06, 0x2426);
11431                 MP_WritePhyUshort(sc, 0x06, 0xae48);
11432                 MP_WritePhyUshort(sc, 0x06, 0xa003);
11433                 MP_WritePhyUshort(sc, 0x06, 0x21e0);
11434                 MP_WritePhyUshort(sc, 0x06, 0x8608);
11435                 MP_WritePhyUshort(sc, 0x06, 0xe186);
11436                 MP_WritePhyUshort(sc, 0x06, 0x091b);
11437                 MP_WritePhyUshort(sc, 0x06, 0x019e);
11438                 MP_WritePhyUshort(sc, 0x06, 0x0caa);
11439                 MP_WritePhyUshort(sc, 0x06, 0x0502);
11440                 MP_WritePhyUshort(sc, 0x06, 0x249d);
11441                 MP_WritePhyUshort(sc, 0x06, 0xaee7);
11442                 MP_WritePhyUshort(sc, 0x06, 0x0224);
11443                 MP_WritePhyUshort(sc, 0x06, 0x8eae);
11444                 MP_WritePhyUshort(sc, 0x06, 0xe2ee);
11445                 MP_WritePhyUshort(sc, 0x06, 0x860a);
11446                 MP_WritePhyUshort(sc, 0x06, 0x04ee);
11447                 MP_WritePhyUshort(sc, 0x06, 0x860b);
11448                 MP_WritePhyUshort(sc, 0x06, 0x00af);
11449                 MP_WritePhyUshort(sc, 0x06, 0x8369);
11450                 MP_WritePhyUshort(sc, 0x06, 0xa004);
11451                 MP_WritePhyUshort(sc, 0x06, 0x15e0);
11452                 MP_WritePhyUshort(sc, 0x06, 0x860b);
11453                 MP_WritePhyUshort(sc, 0x06, 0xe18b);
11454                 MP_WritePhyUshort(sc, 0x06, 0x341b);
11455                 MP_WritePhyUshort(sc, 0x06, 0x109e);
11456                 MP_WritePhyUshort(sc, 0x06, 0x05aa);
11457                 MP_WritePhyUshort(sc, 0x06, 0x03af);
11458                 MP_WritePhyUshort(sc, 0x06, 0x8383);
11459                 MP_WritePhyUshort(sc, 0x06, 0xee86);
11460                 MP_WritePhyUshort(sc, 0x06, 0x0a05);
11461                 MP_WritePhyUshort(sc, 0x06, 0xae0c);
11462                 MP_WritePhyUshort(sc, 0x06, 0xa005);
11463                 MP_WritePhyUshort(sc, 0x06, 0x02ae);
11464                 MP_WritePhyUshort(sc, 0x06, 0x0702);
11465                 MP_WritePhyUshort(sc, 0x06, 0x2309);
11466                 MP_WritePhyUshort(sc, 0x06, 0xee86);
11467                 MP_WritePhyUshort(sc, 0x06, 0x0a00);
11468                 MP_WritePhyUshort(sc, 0x06, 0xfeef);
11469                 MP_WritePhyUshort(sc, 0x06, 0x96fe);
11470                 MP_WritePhyUshort(sc, 0x06, 0xfdfc);
11471                 MP_WritePhyUshort(sc, 0x06, 0x04f8);
11472                 MP_WritePhyUshort(sc, 0x06, 0xf9fa);
11473                 MP_WritePhyUshort(sc, 0x06, 0xef69);
11474                 MP_WritePhyUshort(sc, 0x06, 0xfbe0);
11475                 MP_WritePhyUshort(sc, 0x06, 0x8b85);
11476                 MP_WritePhyUshort(sc, 0x06, 0xad25);
11477                 MP_WritePhyUshort(sc, 0x06, 0x22e0);
11478                 MP_WritePhyUshort(sc, 0x06, 0xe022);
11479                 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
11480                 MP_WritePhyUshort(sc, 0x06, 0x23e2);
11481                 MP_WritePhyUshort(sc, 0x06, 0xe036);
11482                 MP_WritePhyUshort(sc, 0x06, 0xe3e0);
11483                 MP_WritePhyUshort(sc, 0x06, 0x375a);
11484                 MP_WritePhyUshort(sc, 0x06, 0xc40d);
11485                 MP_WritePhyUshort(sc, 0x06, 0x0158);
11486                 MP_WritePhyUshort(sc, 0x06, 0x021e);
11487                 MP_WritePhyUshort(sc, 0x06, 0x20e3);
11488                 MP_WritePhyUshort(sc, 0x06, 0x8ae7);
11489                 MP_WritePhyUshort(sc, 0x06, 0xac31);
11490                 MP_WritePhyUshort(sc, 0x06, 0x60ac);
11491                 MP_WritePhyUshort(sc, 0x06, 0x3a08);
11492                 MP_WritePhyUshort(sc, 0x06, 0xac3e);
11493                 MP_WritePhyUshort(sc, 0x06, 0x26ae);
11494                 MP_WritePhyUshort(sc, 0x06, 0x67af);
11495                 MP_WritePhyUshort(sc, 0x06, 0x84db);
11496                 MP_WritePhyUshort(sc, 0x06, 0xad37);
11497                 MP_WritePhyUshort(sc, 0x06, 0x61e0);
11498                 MP_WritePhyUshort(sc, 0x06, 0x8ae8);
11499                 MP_WritePhyUshort(sc, 0x06, 0x10e4);
11500                 MP_WritePhyUshort(sc, 0x06, 0x8ae8);
11501                 MP_WritePhyUshort(sc, 0x06, 0xe18a);
11502                 MP_WritePhyUshort(sc, 0x06, 0xe91b);
11503                 MP_WritePhyUshort(sc, 0x06, 0x109e);
11504                 MP_WritePhyUshort(sc, 0x06, 0x02ae);
11505                 MP_WritePhyUshort(sc, 0x06, 0x51d1);
11506                 MP_WritePhyUshort(sc, 0x06, 0x00bf);
11507                 MP_WritePhyUshort(sc, 0x06, 0x863b);
11508                 MP_WritePhyUshort(sc, 0x06, 0x022f);
11509                 MP_WritePhyUshort(sc, 0x06, 0x50ee);
11510                 MP_WritePhyUshort(sc, 0x06, 0x8ae8);
11511                 MP_WritePhyUshort(sc, 0x06, 0x00ae);
11512                 MP_WritePhyUshort(sc, 0x06, 0x43ad);
11513                 MP_WritePhyUshort(sc, 0x06, 0x3627);
11514                 MP_WritePhyUshort(sc, 0x06, 0xe08a);
11515                 MP_WritePhyUshort(sc, 0x06, 0xeee1);
11516                 MP_WritePhyUshort(sc, 0x06, 0x8aef);
11517                 MP_WritePhyUshort(sc, 0x06, 0xef74);
11518                 MP_WritePhyUshort(sc, 0x06, 0xe08a);
11519                 MP_WritePhyUshort(sc, 0x06, 0xeae1);
11520                 MP_WritePhyUshort(sc, 0x06, 0x8aeb);
11521                 MP_WritePhyUshort(sc, 0x06, 0x1b74);
11522                 MP_WritePhyUshort(sc, 0x06, 0x9e2e);
11523                 MP_WritePhyUshort(sc, 0x06, 0x14e4);
11524                 MP_WritePhyUshort(sc, 0x06, 0x8aea);
11525                 MP_WritePhyUshort(sc, 0x06, 0xe58a);
11526                 MP_WritePhyUshort(sc, 0x06, 0xebef);
11527                 MP_WritePhyUshort(sc, 0x06, 0x74e0);
11528                 MP_WritePhyUshort(sc, 0x06, 0x8aee);
11529                 MP_WritePhyUshort(sc, 0x06, 0xe18a);
11530                 MP_WritePhyUshort(sc, 0x06, 0xef1b);
11531                 MP_WritePhyUshort(sc, 0x06, 0x479e);
11532                 MP_WritePhyUshort(sc, 0x06, 0x0fae);
11533                 MP_WritePhyUshort(sc, 0x06, 0x19ee);
11534                 MP_WritePhyUshort(sc, 0x06, 0x8aea);
11535                 MP_WritePhyUshort(sc, 0x06, 0x00ee);
11536                 MP_WritePhyUshort(sc, 0x06, 0x8aeb);
11537                 MP_WritePhyUshort(sc, 0x06, 0x00ae);
11538                 MP_WritePhyUshort(sc, 0x06, 0x0fac);
11539                 MP_WritePhyUshort(sc, 0x06, 0x390c);
11540                 MP_WritePhyUshort(sc, 0x06, 0xd101);
11541                 MP_WritePhyUshort(sc, 0x06, 0xbf86);
11542                 MP_WritePhyUshort(sc, 0x06, 0x3b02);
11543                 MP_WritePhyUshort(sc, 0x06, 0x2f50);
11544                 MP_WritePhyUshort(sc, 0x06, 0xee8a);
11545                 MP_WritePhyUshort(sc, 0x06, 0xe800);
11546                 MP_WritePhyUshort(sc, 0x06, 0xe68a);
11547                 MP_WritePhyUshort(sc, 0x06, 0xe7ff);
11548                 MP_WritePhyUshort(sc, 0x06, 0xef96);
11549                 MP_WritePhyUshort(sc, 0x06, 0xfefd);
11550                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
11551                 MP_WritePhyUshort(sc, 0x06, 0xf8f9);
11552                 MP_WritePhyUshort(sc, 0x06, 0xfaef);
11553                 MP_WritePhyUshort(sc, 0x06, 0x69e0);
11554                 MP_WritePhyUshort(sc, 0x06, 0xe022);
11555                 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
11556                 MP_WritePhyUshort(sc, 0x06, 0x2358);
11557                 MP_WritePhyUshort(sc, 0x06, 0xc4e1);
11558                 MP_WritePhyUshort(sc, 0x06, 0x8b6e);
11559                 MP_WritePhyUshort(sc, 0x06, 0x1f10);
11560                 MP_WritePhyUshort(sc, 0x06, 0x9e24);
11561                 MP_WritePhyUshort(sc, 0x06, 0xe48b);
11562                 MP_WritePhyUshort(sc, 0x06, 0x6ead);
11563                 MP_WritePhyUshort(sc, 0x06, 0x2218);
11564                 MP_WritePhyUshort(sc, 0x06, 0xac27);
11565                 MP_WritePhyUshort(sc, 0x06, 0x0dac);
11566                 MP_WritePhyUshort(sc, 0x06, 0x2605);
11567                 MP_WritePhyUshort(sc, 0x06, 0x0203);
11568                 MP_WritePhyUshort(sc, 0x06, 0x8fae);
11569                 MP_WritePhyUshort(sc, 0x06, 0x1302);
11570                 MP_WritePhyUshort(sc, 0x06, 0x03c8);
11571                 MP_WritePhyUshort(sc, 0x06, 0xae0e);
11572                 MP_WritePhyUshort(sc, 0x06, 0x0203);
11573                 MP_WritePhyUshort(sc, 0x06, 0xe102);
11574                 MP_WritePhyUshort(sc, 0x06, 0x8520);
11575                 MP_WritePhyUshort(sc, 0x06, 0xae06);
11576                 MP_WritePhyUshort(sc, 0x06, 0x0203);
11577                 MP_WritePhyUshort(sc, 0x06, 0x8f02);
11578                 MP_WritePhyUshort(sc, 0x06, 0x8566);
11579                 MP_WritePhyUshort(sc, 0x06, 0xef96);
11580                 MP_WritePhyUshort(sc, 0x06, 0xfefd);
11581                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
11582                 MP_WritePhyUshort(sc, 0x06, 0xf8fa);
11583                 MP_WritePhyUshort(sc, 0x06, 0xef69);
11584                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
11585                 MP_WritePhyUshort(sc, 0x06, 0x82ad);
11586                 MP_WritePhyUshort(sc, 0x06, 0x2737);
11587                 MP_WritePhyUshort(sc, 0x06, 0xbf86);
11588                 MP_WritePhyUshort(sc, 0x06, 0x4402);
11589                 MP_WritePhyUshort(sc, 0x06, 0x2f23);
11590                 MP_WritePhyUshort(sc, 0x06, 0xac28);
11591                 MP_WritePhyUshort(sc, 0x06, 0x2ed1);
11592                 MP_WritePhyUshort(sc, 0x06, 0x01bf);
11593                 MP_WritePhyUshort(sc, 0x06, 0x8647);
11594                 MP_WritePhyUshort(sc, 0x06, 0x022f);
11595                 MP_WritePhyUshort(sc, 0x06, 0x50bf);
11596                 MP_WritePhyUshort(sc, 0x06, 0x8641);
11597                 MP_WritePhyUshort(sc, 0x06, 0x022f);
11598                 MP_WritePhyUshort(sc, 0x06, 0x23e5);
11599                 MP_WritePhyUshort(sc, 0x06, 0x8af0);
11600                 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
11601                 MP_WritePhyUshort(sc, 0x06, 0x22e1);
11602                 MP_WritePhyUshort(sc, 0x06, 0xe023);
11603                 MP_WritePhyUshort(sc, 0x06, 0xac2e);
11604                 MP_WritePhyUshort(sc, 0x06, 0x04d1);
11605                 MP_WritePhyUshort(sc, 0x06, 0x01ae);
11606                 MP_WritePhyUshort(sc, 0x06, 0x02d1);
11607                 MP_WritePhyUshort(sc, 0x06, 0x00bf);
11608                 MP_WritePhyUshort(sc, 0x06, 0x8641);
11609                 MP_WritePhyUshort(sc, 0x06, 0x022f);
11610                 MP_WritePhyUshort(sc, 0x06, 0x50d1);
11611                 MP_WritePhyUshort(sc, 0x06, 0x01bf);
11612                 MP_WritePhyUshort(sc, 0x06, 0x8644);
11613                 MP_WritePhyUshort(sc, 0x06, 0x022f);
11614                 MP_WritePhyUshort(sc, 0x06, 0x50ef);
11615                 MP_WritePhyUshort(sc, 0x06, 0x96fe);
11616                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
11617                 MP_WritePhyUshort(sc, 0x06, 0xf8fa);
11618                 MP_WritePhyUshort(sc, 0x06, 0xef69);
11619                 MP_WritePhyUshort(sc, 0x06, 0xbf86);
11620                 MP_WritePhyUshort(sc, 0x06, 0x4702);
11621                 MP_WritePhyUshort(sc, 0x06, 0x2f23);
11622                 MP_WritePhyUshort(sc, 0x06, 0xad28);
11623                 MP_WritePhyUshort(sc, 0x06, 0x19d1);
11624                 MP_WritePhyUshort(sc, 0x06, 0x00bf);
11625                 MP_WritePhyUshort(sc, 0x06, 0x8644);
11626                 MP_WritePhyUshort(sc, 0x06, 0x022f);
11627                 MP_WritePhyUshort(sc, 0x06, 0x50e1);
11628                 MP_WritePhyUshort(sc, 0x06, 0x8af0);
11629                 MP_WritePhyUshort(sc, 0x06, 0xbf86);
11630                 MP_WritePhyUshort(sc, 0x06, 0x4102);
11631                 MP_WritePhyUshort(sc, 0x06, 0x2f50);
11632                 MP_WritePhyUshort(sc, 0x06, 0xd100);
11633                 MP_WritePhyUshort(sc, 0x06, 0xbf86);
11634                 MP_WritePhyUshort(sc, 0x06, 0x4702);
11635                 MP_WritePhyUshort(sc, 0x06, 0x2f50);
11636                 MP_WritePhyUshort(sc, 0x06, 0xef96);
11637                 MP_WritePhyUshort(sc, 0x06, 0xfefc);
11638                 MP_WritePhyUshort(sc, 0x06, 0x04f8);
11639                 MP_WritePhyUshort(sc, 0x06, 0xe0e2);
11640                 MP_WritePhyUshort(sc, 0x06, 0xfee1);
11641                 MP_WritePhyUshort(sc, 0x06, 0xe2ff);
11642                 MP_WritePhyUshort(sc, 0x06, 0xad2e);
11643                 MP_WritePhyUshort(sc, 0x06, 0x63e0);
11644                 MP_WritePhyUshort(sc, 0x06, 0xe038);
11645                 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
11646                 MP_WritePhyUshort(sc, 0x06, 0x39ad);
11647                 MP_WritePhyUshort(sc, 0x06, 0x2f10);
11648                 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
11649                 MP_WritePhyUshort(sc, 0x06, 0x34e1);
11650                 MP_WritePhyUshort(sc, 0x06, 0xe035);
11651                 MP_WritePhyUshort(sc, 0x06, 0xf726);
11652                 MP_WritePhyUshort(sc, 0x06, 0xe4e0);
11653                 MP_WritePhyUshort(sc, 0x06, 0x34e5);
11654                 MP_WritePhyUshort(sc, 0x06, 0xe035);
11655                 MP_WritePhyUshort(sc, 0x06, 0xae0e);
11656                 MP_WritePhyUshort(sc, 0x06, 0xe0e2);
11657                 MP_WritePhyUshort(sc, 0x06, 0xd6e1);
11658                 MP_WritePhyUshort(sc, 0x06, 0xe2d7);
11659                 MP_WritePhyUshort(sc, 0x06, 0xf728);
11660                 MP_WritePhyUshort(sc, 0x06, 0xe4e2);
11661                 MP_WritePhyUshort(sc, 0x06, 0xd6e5);
11662                 MP_WritePhyUshort(sc, 0x06, 0xe2d7);
11663                 MP_WritePhyUshort(sc, 0x06, 0xe0e2);
11664                 MP_WritePhyUshort(sc, 0x06, 0x34e1);
11665                 MP_WritePhyUshort(sc, 0x06, 0xe235);
11666                 MP_WritePhyUshort(sc, 0x06, 0xf72b);
11667                 MP_WritePhyUshort(sc, 0x06, 0xe4e2);
11668                 MP_WritePhyUshort(sc, 0x06, 0x34e5);
11669                 MP_WritePhyUshort(sc, 0x06, 0xe235);
11670                 MP_WritePhyUshort(sc, 0x06, 0xd07d);
11671                 MP_WritePhyUshort(sc, 0x06, 0xb0fe);
11672                 MP_WritePhyUshort(sc, 0x06, 0xe0e2);
11673                 MP_WritePhyUshort(sc, 0x06, 0x34e1);
11674                 MP_WritePhyUshort(sc, 0x06, 0xe235);
11675                 MP_WritePhyUshort(sc, 0x06, 0xf62b);
11676                 MP_WritePhyUshort(sc, 0x06, 0xe4e2);
11677                 MP_WritePhyUshort(sc, 0x06, 0x34e5);
11678                 MP_WritePhyUshort(sc, 0x06, 0xe235);
11679                 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
11680                 MP_WritePhyUshort(sc, 0x06, 0x34e1);
11681                 MP_WritePhyUshort(sc, 0x06, 0xe035);
11682                 MP_WritePhyUshort(sc, 0x06, 0xf626);
11683                 MP_WritePhyUshort(sc, 0x06, 0xe4e0);
11684                 MP_WritePhyUshort(sc, 0x06, 0x34e5);
11685                 MP_WritePhyUshort(sc, 0x06, 0xe035);
11686                 MP_WritePhyUshort(sc, 0x06, 0xe0e2);
11687                 MP_WritePhyUshort(sc, 0x06, 0xd6e1);
11688                 MP_WritePhyUshort(sc, 0x06, 0xe2d7);
11689                 MP_WritePhyUshort(sc, 0x06, 0xf628);
11690                 MP_WritePhyUshort(sc, 0x06, 0xe4e2);
11691                 MP_WritePhyUshort(sc, 0x06, 0xd6e5);
11692                 MP_WritePhyUshort(sc, 0x06, 0xe2d7);
11693                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
11694                 MP_WritePhyUshort(sc, 0x06, 0xae20);
11695                 MP_WritePhyUshort(sc, 0x06, 0x0000);
11696                 MP_WritePhyUshort(sc, 0x06, 0x0000);
11697                 MP_WritePhyUshort(sc, 0x06, 0x0000);
11698                 MP_WritePhyUshort(sc, 0x06, 0x0000);
11699                 MP_WritePhyUshort(sc, 0x06, 0x0000);
11700                 MP_WritePhyUshort(sc, 0x06, 0x0000);
11701                 MP_WritePhyUshort(sc, 0x06, 0x0000);
11702                 MP_WritePhyUshort(sc, 0x06, 0x0000);
11703                 MP_WritePhyUshort(sc, 0x06, 0x0000);
11704                 MP_WritePhyUshort(sc, 0x06, 0x0000);
11705                 MP_WritePhyUshort(sc, 0x06, 0x0000);
11706                 MP_WritePhyUshort(sc, 0x06, 0x0000);
11707                 MP_WritePhyUshort(sc, 0x06, 0x0000);
11708                 MP_WritePhyUshort(sc, 0x06, 0x0000);
11709                 MP_WritePhyUshort(sc, 0x06, 0x0000);
11710                 MP_WritePhyUshort(sc, 0x06, 0x0000);
11711                 MP_WritePhyUshort(sc, 0x06, 0xa725);
11712                 MP_WritePhyUshort(sc, 0x06, 0xe50a);
11713                 MP_WritePhyUshort(sc, 0x06, 0x1de5);
11714                 MP_WritePhyUshort(sc, 0x06, 0x0a2c);
11715                 MP_WritePhyUshort(sc, 0x06, 0xe50a);
11716                 MP_WritePhyUshort(sc, 0x06, 0x6de5);
11717                 MP_WritePhyUshort(sc, 0x06, 0x0a1d);
11718                 MP_WritePhyUshort(sc, 0x06, 0xe50a);
11719                 MP_WritePhyUshort(sc, 0x06, 0x1ce5);
11720                 MP_WritePhyUshort(sc, 0x06, 0x0a2d);
11721                 MP_WritePhyUshort(sc, 0x06, 0xa755);
11722                 MP_WritePhyUshort(sc, 0x06, 0x00e2);
11723                 MP_WritePhyUshort(sc, 0x06, 0x3488);
11724                 MP_WritePhyUshort(sc, 0x06, 0xe200);
11725                 MP_WritePhyUshort(sc, 0x06, 0xcce2);
11726                 MP_WritePhyUshort(sc, 0x06, 0x0055);
11727                 MP_WritePhyUshort(sc, 0x06, 0xe020);
11728                 MP_WritePhyUshort(sc, 0x06, 0x55e2);
11729                 MP_WritePhyUshort(sc, 0x06, 0xd600);
11730                 MP_WritePhyUshort(sc, 0x06, 0xe24a);
11731                 PhyRegValue = MP_ReadPhyUshort(sc, 0x01);
11732                 PhyRegValue |= BIT_0;
11733                 MP_WritePhyUshort(sc, 0x01, PhyRegValue);
11734                 PhyRegValue = MP_ReadPhyUshort(sc, 0x00);
11735                 PhyRegValue |= BIT_0;
11736                 MP_WritePhyUshort(sc, 0x00, PhyRegValue);
11737                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
11738                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
11739                 MP_WritePhyUshort(sc, 0x17, 0x2179);
11740                 MP_WritePhyUshort(sc, 0x1f, 0x0001);
11741                 MP_WritePhyUshort(sc, 0x10, 0xf274);
11742                 MP_WritePhyUshort(sc, 0x1f, 0x0007);
11743                 MP_WritePhyUshort(sc, 0x1e, 0x0042);
11744                 MP_WritePhyUshort(sc, 0x15, 0x0f00);
11745                 MP_WritePhyUshort(sc, 0x15, 0x0f00);
11746                 MP_WritePhyUshort(sc, 0x16, 0x7408);
11747                 MP_WritePhyUshort(sc, 0x15, 0x0e00);
11748                 MP_WritePhyUshort(sc, 0x15, 0x0f00);
11749                 MP_WritePhyUshort(sc, 0x15, 0x0f01);
11750                 MP_WritePhyUshort(sc, 0x16, 0x4000);
11751                 MP_WritePhyUshort(sc, 0x15, 0x0e01);
11752                 MP_WritePhyUshort(sc, 0x15, 0x0f01);
11753                 MP_WritePhyUshort(sc, 0x15, 0x0f02);
11754                 MP_WritePhyUshort(sc, 0x16, 0x9400);
11755                 MP_WritePhyUshort(sc, 0x15, 0x0e02);
11756                 MP_WritePhyUshort(sc, 0x15, 0x0f02);
11757                 MP_WritePhyUshort(sc, 0x15, 0x0f03);
11758                 MP_WritePhyUshort(sc, 0x16, 0x7408);
11759                 MP_WritePhyUshort(sc, 0x15, 0x0e03);
11760                 MP_WritePhyUshort(sc, 0x15, 0x0f03);
11761                 MP_WritePhyUshort(sc, 0x15, 0x0f04);
11762                 MP_WritePhyUshort(sc, 0x16, 0x4008);
11763                 MP_WritePhyUshort(sc, 0x15, 0x0e04);
11764                 MP_WritePhyUshort(sc, 0x15, 0x0f04);
11765                 MP_WritePhyUshort(sc, 0x15, 0x0f05);
11766                 MP_WritePhyUshort(sc, 0x16, 0x9400);
11767                 MP_WritePhyUshort(sc, 0x15, 0x0e05);
11768                 MP_WritePhyUshort(sc, 0x15, 0x0f05);
11769                 MP_WritePhyUshort(sc, 0x15, 0x0f06);
11770                 MP_WritePhyUshort(sc, 0x16, 0x0803);
11771                 MP_WritePhyUshort(sc, 0x15, 0x0e06);
11772                 MP_WritePhyUshort(sc, 0x15, 0x0f06);
11773                 MP_WritePhyUshort(sc, 0x15, 0x0d00);
11774                 MP_WritePhyUshort(sc, 0x15, 0x0100);
11775                 MP_WritePhyUshort(sc, 0x1f, 0x0001);
11776                 MP_WritePhyUshort(sc, 0x10, 0xf074);
11777                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
11778                 MP_WritePhyUshort(sc, 0x17, 0x2149);
11779                 MP_WritePhyUshort(sc, 0x1f, 0x0005);
11780                 for (i=0; i<200; i++) {
11781                         DELAY(100);
11782                         PhyRegValue = MP_ReadPhyUshort(sc, 0x00);
11783                         if (PhyRegValue&0x0080)
11784                                 break;
11785                 }
11786                 MP_WritePhyUshort(sc, 0x1f, 0x0007);
11787                 MP_WritePhyUshort(sc, 0x1e, 0x0023);
11788                 PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
11789                 PhyRegValue &= ~(BIT_0);
11790                 if (sc->RequiredSecLanDonglePatch)
11791                         PhyRegValue &= ~(BIT_2);
11792                 MP_WritePhyUshort(sc, 0x17, PhyRegValue);
11793                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
11794                 MP_WritePhyUshort(sc, 0x1f, 0x0007);
11795                 MP_WritePhyUshort(sc, 0x1e, 0x0023);
11796                 PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
11797                 PhyRegValue |= BIT_14;
11798                 MP_WritePhyUshort(sc, 0x17, PhyRegValue);
11799                 MP_WritePhyUshort(sc, 0x1e, 0x0020);
11800                 PhyRegValue = MP_ReadPhyUshort(sc, 0x1b);
11801                 PhyRegValue |= BIT_7;
11802                 MP_WritePhyUshort(sc, 0x1b, PhyRegValue);
11803                 MP_WritePhyUshort(sc, 0x1e, 0x0041);
11804                 MP_WritePhyUshort(sc, 0x15, 0x0e02);
11805                 MP_WritePhyUshort(sc, 0x1e, 0x0028);
11806                 PhyRegValue = MP_ReadPhyUshort(sc, 0x19);
11807                 PhyRegValue |= BIT_15;
11808                 MP_WritePhyUshort(sc, 0x19, PhyRegValue);
11809                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
11810         } else {
11811                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
11812                 MP_WritePhyUshort(sc, 0x00, 0x1800);
11813                 MP_WritePhyUshort(sc, 0x1f, 0x0007);
11814                 MP_WritePhyUshort(sc, 0x1e, 0x0023);
11815                 MP_WritePhyUshort(sc, 0x17, 0x0117);
11816                 MP_WritePhyUshort(sc, 0x1f, 0x0007);
11817                 MP_WritePhyUshort(sc, 0x1E, 0x002C);
11818                 MP_WritePhyUshort(sc, 0x1B, 0x5000);
11819                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
11820                 MP_WritePhyUshort(sc, 0x16, 0x4104);
11821                 for (i = 0; i < 200; i++) {
11822                         DELAY(100);
11823                         PhyRegValue = MP_ReadPhyUshort(sc, 0x1E);
11824                         PhyRegValue &= 0x03FF;
11825                         if (PhyRegValue==0x000C)
11826                                 break;
11827                 }
11828                 MP_WritePhyUshort(sc, 0x1f, 0x0005);
11829                 for (i = 0; i < 200; i++) {
11830                         DELAY(100);
11831                         PhyRegValue = MP_ReadPhyUshort(sc, 0x07);
11832                         if ((PhyRegValue & BIT_5) == 0)
11833                                 break;
11834                 }
11835                 PhyRegValue = MP_ReadPhyUshort(sc, 0x07);
11836                 if (PhyRegValue & BIT_5) {
11837                         MP_WritePhyUshort(sc, 0x1f, 0x0007);
11838                         MP_WritePhyUshort(sc, 0x1e, 0x00a1);
11839                         MP_WritePhyUshort(sc, 0x17, 0x1000);
11840                         MP_WritePhyUshort(sc, 0x17, 0x0000);
11841                         MP_WritePhyUshort(sc, 0x17, 0x2000);
11842                         MP_WritePhyUshort(sc, 0x1e, 0x002f);
11843                         MP_WritePhyUshort(sc, 0x18, 0x9bfb);
11844                         MP_WritePhyUshort(sc, 0x1f, 0x0005);
11845                         MP_WritePhyUshort(sc, 0x07, 0x0000);
11846                         MP_WritePhyUshort(sc, 0x1f, 0x0000);
11847                 }
11848                 MP_WritePhyUshort(sc, 0x1f, 0x0005);
11849                 MP_WritePhyUshort(sc, 0x05, 0xfff6);
11850                 MP_WritePhyUshort(sc, 0x06, 0x0080);
11851                 PhyRegValue = MP_ReadPhyUshort(sc, 0x00);
11852                 PhyRegValue &= ~(BIT_7);
11853                 MP_WritePhyUshort(sc, 0x00, PhyRegValue);
11854                 MP_WritePhyUshort(sc, 0x1f, 0x0002);
11855                 PhyRegValue = MP_ReadPhyUshort(sc, 0x08);
11856                 PhyRegValue &= ~(BIT_7);
11857                 MP_WritePhyUshort(sc, 0x08, PhyRegValue);
11858                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
11859
11860                 MP_WritePhyUshort(sc, 0x1f, 0x0007);
11861                 MP_WritePhyUshort(sc, 0x1e, 0x0023);
11862                 MP_WritePhyUshort(sc, 0x16, 0x0306);
11863                 MP_WritePhyUshort(sc, 0x16, 0x0307);
11864                 MP_WritePhyUshort(sc, 0x15, 0x000e);
11865                 MP_WritePhyUshort(sc, 0x19, 0x000a);
11866                 MP_WritePhyUshort(sc, 0x15, 0x0010);
11867                 MP_WritePhyUshort(sc, 0x19, 0x0008);
11868                 MP_WritePhyUshort(sc, 0x15, 0x0018);
11869                 MP_WritePhyUshort(sc, 0x19, 0x4801);
11870                 MP_WritePhyUshort(sc, 0x15, 0x0019);
11871                 MP_WritePhyUshort(sc, 0x19, 0x6801);
11872                 MP_WritePhyUshort(sc, 0x15, 0x001a);
11873                 MP_WritePhyUshort(sc, 0x19, 0x66a1);
11874                 MP_WritePhyUshort(sc, 0x15, 0x001f);
11875                 MP_WritePhyUshort(sc, 0x19, 0x0000);
11876                 MP_WritePhyUshort(sc, 0x15, 0x0020);
11877                 MP_WritePhyUshort(sc, 0x19, 0x0000);
11878                 MP_WritePhyUshort(sc, 0x15, 0x0021);
11879                 MP_WritePhyUshort(sc, 0x19, 0x0000);
11880                 MP_WritePhyUshort(sc, 0x15, 0x0022);
11881                 MP_WritePhyUshort(sc, 0x19, 0x0000);
11882                 MP_WritePhyUshort(sc, 0x15, 0x0023);
11883                 MP_WritePhyUshort(sc, 0x19, 0x0000);
11884                 MP_WritePhyUshort(sc, 0x15, 0x0024);
11885                 MP_WritePhyUshort(sc, 0x19, 0x0000);
11886                 MP_WritePhyUshort(sc, 0x15, 0x0025);
11887                 MP_WritePhyUshort(sc, 0x19, 0x64a1);
11888                 MP_WritePhyUshort(sc, 0x15, 0x0026);
11889                 MP_WritePhyUshort(sc, 0x19, 0x40ea);
11890                 MP_WritePhyUshort(sc, 0x15, 0x0027);
11891                 MP_WritePhyUshort(sc, 0x19, 0x4503);
11892                 MP_WritePhyUshort(sc, 0x15, 0x0028);
11893                 MP_WritePhyUshort(sc, 0x19, 0x9f00);
11894                 MP_WritePhyUshort(sc, 0x15, 0x0029);
11895                 MP_WritePhyUshort(sc, 0x19, 0xa631);
11896                 MP_WritePhyUshort(sc, 0x15, 0x002a);
11897                 MP_WritePhyUshort(sc, 0x19, 0x9717);
11898                 MP_WritePhyUshort(sc, 0x15, 0x002b);
11899                 MP_WritePhyUshort(sc, 0x19, 0x302c);
11900                 MP_WritePhyUshort(sc, 0x15, 0x002c);
11901                 MP_WritePhyUshort(sc, 0x19, 0x4802);
11902                 MP_WritePhyUshort(sc, 0x15, 0x002d);
11903                 MP_WritePhyUshort(sc, 0x19, 0x58da);
11904                 MP_WritePhyUshort(sc, 0x15, 0x002e);
11905                 MP_WritePhyUshort(sc, 0x19, 0x400d);
11906                 MP_WritePhyUshort(sc, 0x15, 0x002f);
11907                 MP_WritePhyUshort(sc, 0x19, 0x4488);
11908                 MP_WritePhyUshort(sc, 0x15, 0x0030);
11909                 MP_WritePhyUshort(sc, 0x19, 0x9e00);
11910                 MP_WritePhyUshort(sc, 0x15, 0x0031);
11911                 MP_WritePhyUshort(sc, 0x19, 0x63c8);
11912                 MP_WritePhyUshort(sc, 0x15, 0x0032);
11913                 MP_WritePhyUshort(sc, 0x19, 0x6481);
11914                 MP_WritePhyUshort(sc, 0x15, 0x0033);
11915                 MP_WritePhyUshort(sc, 0x19, 0x0000);
11916                 MP_WritePhyUshort(sc, 0x15, 0x0034);
11917                 MP_WritePhyUshort(sc, 0x19, 0x0000);
11918                 MP_WritePhyUshort(sc, 0x15, 0x0035);
11919                 MP_WritePhyUshort(sc, 0x19, 0x0000);
11920                 MP_WritePhyUshort(sc, 0x15, 0x0036);
11921                 MP_WritePhyUshort(sc, 0x19, 0x0000);
11922                 MP_WritePhyUshort(sc, 0x15, 0x0037);
11923                 MP_WritePhyUshort(sc, 0x19, 0x0000);
11924                 MP_WritePhyUshort(sc, 0x15, 0x0038);
11925                 MP_WritePhyUshort(sc, 0x19, 0x0000);
11926                 MP_WritePhyUshort(sc, 0x15, 0x0039);
11927                 MP_WritePhyUshort(sc, 0x19, 0x0000);
11928                 MP_WritePhyUshort(sc, 0x15, 0x003a);
11929                 MP_WritePhyUshort(sc, 0x19, 0x0000);
11930                 MP_WritePhyUshort(sc, 0x15, 0x003b);
11931                 MP_WritePhyUshort(sc, 0x19, 0x63e8);
11932                 MP_WritePhyUshort(sc, 0x15, 0x003c);
11933                 MP_WritePhyUshort(sc, 0x19, 0x7d00);
11934                 MP_WritePhyUshort(sc, 0x15, 0x003d);
11935                 MP_WritePhyUshort(sc, 0x19, 0x59d4);
11936                 MP_WritePhyUshort(sc, 0x15, 0x003e);
11937                 MP_WritePhyUshort(sc, 0x19, 0x63f8);
11938                 MP_WritePhyUshort(sc, 0x15, 0x0040);
11939                 MP_WritePhyUshort(sc, 0x19, 0x64a1);
11940                 MP_WritePhyUshort(sc, 0x15, 0x0041);
11941                 MP_WritePhyUshort(sc, 0x19, 0x30de);
11942                 MP_WritePhyUshort(sc, 0x15, 0x0044);
11943                 MP_WritePhyUshort(sc, 0x19, 0x480f);
11944                 MP_WritePhyUshort(sc, 0x15, 0x0045);
11945                 MP_WritePhyUshort(sc, 0x19, 0x6800);
11946                 MP_WritePhyUshort(sc, 0x15, 0x0046);
11947                 MP_WritePhyUshort(sc, 0x19, 0x6680);
11948                 MP_WritePhyUshort(sc, 0x15, 0x0047);
11949                 MP_WritePhyUshort(sc, 0x19, 0x7c10);
11950                 MP_WritePhyUshort(sc, 0x15, 0x0048);
11951                 MP_WritePhyUshort(sc, 0x19, 0x63c8);
11952                 MP_WritePhyUshort(sc, 0x15, 0x0049);
11953                 MP_WritePhyUshort(sc, 0x19, 0x0000);
11954                 MP_WritePhyUshort(sc, 0x15, 0x004a);
11955                 MP_WritePhyUshort(sc, 0x19, 0x0000);
11956                 MP_WritePhyUshort(sc, 0x15, 0x004b);
11957                 MP_WritePhyUshort(sc, 0x19, 0x0000);
11958                 MP_WritePhyUshort(sc, 0x15, 0x004c);
11959                 MP_WritePhyUshort(sc, 0x19, 0x0000);
11960                 MP_WritePhyUshort(sc, 0x15, 0x004d);
11961                 MP_WritePhyUshort(sc, 0x19, 0x0000);
11962                 MP_WritePhyUshort(sc, 0x15, 0x004e);
11963                 MP_WritePhyUshort(sc, 0x19, 0x0000);
11964                 MP_WritePhyUshort(sc, 0x15, 0x004f);
11965                 MP_WritePhyUshort(sc, 0x19, 0x40ea);
11966                 MP_WritePhyUshort(sc, 0x15, 0x0050);
11967                 MP_WritePhyUshort(sc, 0x19, 0x4503);
11968                 MP_WritePhyUshort(sc, 0x15, 0x0051);
11969                 MP_WritePhyUshort(sc, 0x19, 0x58ca);
11970                 MP_WritePhyUshort(sc, 0x15, 0x0052);
11971                 MP_WritePhyUshort(sc, 0x19, 0x63c8);
11972                 MP_WritePhyUshort(sc, 0x15, 0x0053);
11973                 MP_WritePhyUshort(sc, 0x19, 0x63d8);
11974                 MP_WritePhyUshort(sc, 0x15, 0x0054);
11975                 MP_WritePhyUshort(sc, 0x19, 0x66a0);
11976                 MP_WritePhyUshort(sc, 0x15, 0x0055);
11977                 MP_WritePhyUshort(sc, 0x19, 0x9f00);
11978                 MP_WritePhyUshort(sc, 0x15, 0x0056);
11979                 MP_WritePhyUshort(sc, 0x19, 0x3000);
11980                 MP_WritePhyUshort(sc, 0x15, 0x00a1);
11981                 MP_WritePhyUshort(sc, 0x19, 0x3044);
11982                 MP_WritePhyUshort(sc, 0x15, 0x00ab);
11983                 MP_WritePhyUshort(sc, 0x19, 0x5820);
11984                 MP_WritePhyUshort(sc, 0x15, 0x00ac);
11985                 MP_WritePhyUshort(sc, 0x19, 0x5e04);
11986                 MP_WritePhyUshort(sc, 0x15, 0x00ad);
11987                 MP_WritePhyUshort(sc, 0x19, 0xb60c);
11988                 MP_WritePhyUshort(sc, 0x15, 0x00af);
11989                 MP_WritePhyUshort(sc, 0x19, 0x000a);
11990                 MP_WritePhyUshort(sc, 0x15, 0x00b2);
11991                 MP_WritePhyUshort(sc, 0x19, 0x30b9);
11992                 MP_WritePhyUshort(sc, 0x15, 0x00b9);
11993                 MP_WritePhyUshort(sc, 0x19, 0x4408);
11994                 MP_WritePhyUshort(sc, 0x15, 0x00ba);
11995                 MP_WritePhyUshort(sc, 0x19, 0x480b);
11996                 MP_WritePhyUshort(sc, 0x15, 0x00bb);
11997                 MP_WritePhyUshort(sc, 0x19, 0x5e00);
11998                 MP_WritePhyUshort(sc, 0x15, 0x00bc);
11999                 MP_WritePhyUshort(sc, 0x19, 0x405f);
12000                 MP_WritePhyUshort(sc, 0x15, 0x00bd);
12001                 MP_WritePhyUshort(sc, 0x19, 0x4448);
12002                 MP_WritePhyUshort(sc, 0x15, 0x00be);
12003                 MP_WritePhyUshort(sc, 0x19, 0x4020);
12004                 MP_WritePhyUshort(sc, 0x15, 0x00bf);
12005                 MP_WritePhyUshort(sc, 0x19, 0x4468);
12006                 MP_WritePhyUshort(sc, 0x15, 0x00c0);
12007                 MP_WritePhyUshort(sc, 0x19, 0x9c02);
12008                 MP_WritePhyUshort(sc, 0x15, 0x00c1);
12009                 MP_WritePhyUshort(sc, 0x19, 0x58a0);
12010                 MP_WritePhyUshort(sc, 0x15, 0x00c2);
12011                 MP_WritePhyUshort(sc, 0x19, 0xb605);
12012                 MP_WritePhyUshort(sc, 0x15, 0x00c3);
12013                 MP_WritePhyUshort(sc, 0x19, 0xc0d3);
12014                 MP_WritePhyUshort(sc, 0x15, 0x00c4);
12015                 MP_WritePhyUshort(sc, 0x19, 0x00e6);
12016                 MP_WritePhyUshort(sc, 0x15, 0x00c5);
12017                 MP_WritePhyUshort(sc, 0x19, 0xdaec);
12018                 MP_WritePhyUshort(sc, 0x15, 0x00c6);
12019                 MP_WritePhyUshort(sc, 0x19, 0x00fa);
12020                 MP_WritePhyUshort(sc, 0x15, 0x00c7);
12021                 MP_WritePhyUshort(sc, 0x19, 0x9df9);
12022                 MP_WritePhyUshort(sc, 0x15, 0x0112);
12023                 MP_WritePhyUshort(sc, 0x19, 0x6421);
12024                 MP_WritePhyUshort(sc, 0x15, 0x0113);
12025                 MP_WritePhyUshort(sc, 0x19, 0x7c08);
12026                 MP_WritePhyUshort(sc, 0x15, 0x0114);
12027                 MP_WritePhyUshort(sc, 0x19, 0x63f0);
12028                 MP_WritePhyUshort(sc, 0x15, 0x0115);
12029                 MP_WritePhyUshort(sc, 0x19, 0x4003);
12030                 MP_WritePhyUshort(sc, 0x15, 0x0116);
12031                 MP_WritePhyUshort(sc, 0x19, 0x4418);
12032                 MP_WritePhyUshort(sc, 0x15, 0x0117);
12033                 MP_WritePhyUshort(sc, 0x19, 0x9b00);
12034                 MP_WritePhyUshort(sc, 0x15, 0x0118);
12035                 MP_WritePhyUshort(sc, 0x19, 0x6461);
12036                 MP_WritePhyUshort(sc, 0x15, 0x0119);
12037                 MP_WritePhyUshort(sc, 0x19, 0x64e1);
12038                 MP_WritePhyUshort(sc, 0x15, 0x011a);
12039                 MP_WritePhyUshort(sc, 0x19, 0x0000);
12040                 MP_WritePhyUshort(sc, 0x15, 0x0150);
12041                 MP_WritePhyUshort(sc, 0x19, 0x7c80);
12042                 MP_WritePhyUshort(sc, 0x15, 0x0151);
12043                 MP_WritePhyUshort(sc, 0x19, 0x6461);
12044                 MP_WritePhyUshort(sc, 0x15, 0x0152);
12045                 MP_WritePhyUshort(sc, 0x19, 0x4003);
12046                 MP_WritePhyUshort(sc, 0x15, 0x0153);
12047                 MP_WritePhyUshort(sc, 0x19, 0x4540);
12048                 MP_WritePhyUshort(sc, 0x15, 0x0154);
12049                 MP_WritePhyUshort(sc, 0x19, 0x9f00);
12050                 MP_WritePhyUshort(sc, 0x15, 0x0155);
12051                 MP_WritePhyUshort(sc, 0x19, 0x9d00);
12052                 MP_WritePhyUshort(sc, 0x15, 0x0156);
12053                 MP_WritePhyUshort(sc, 0x19, 0x7c40);
12054                 MP_WritePhyUshort(sc, 0x15, 0x0157);
12055                 MP_WritePhyUshort(sc, 0x19, 0x6421);
12056                 MP_WritePhyUshort(sc, 0x15, 0x0158);
12057                 MP_WritePhyUshort(sc, 0x19, 0x7c80);
12058                 MP_WritePhyUshort(sc, 0x15, 0x0159);
12059                 MP_WritePhyUshort(sc, 0x19, 0x64a1);
12060                 MP_WritePhyUshort(sc, 0x15, 0x015a);
12061                 MP_WritePhyUshort(sc, 0x19, 0x30fe);
12062                 MP_WritePhyUshort(sc, 0x15, 0x029c);
12063                 MP_WritePhyUshort(sc, 0x19, 0x0070);
12064                 MP_WritePhyUshort(sc, 0x15, 0x02b2);
12065                 MP_WritePhyUshort(sc, 0x19, 0x005a);
12066                 MP_WritePhyUshort(sc, 0x15, 0x02bd);
12067                 MP_WritePhyUshort(sc, 0x19, 0xa522);
12068                 MP_WritePhyUshort(sc, 0x15, 0x02ce);
12069                 MP_WritePhyUshort(sc, 0x19, 0xb63e);
12070                 MP_WritePhyUshort(sc, 0x15, 0x02d9);
12071                 MP_WritePhyUshort(sc, 0x19, 0x32df);
12072                 MP_WritePhyUshort(sc, 0x15, 0x02df);
12073                 MP_WritePhyUshort(sc, 0x19, 0x4500);
12074                 MP_WritePhyUshort(sc, 0x15, 0x02f4);
12075                 MP_WritePhyUshort(sc, 0x19, 0xb618);
12076                 MP_WritePhyUshort(sc, 0x15, 0x02fb);
12077                 MP_WritePhyUshort(sc, 0x19, 0xb900);
12078                 MP_WritePhyUshort(sc, 0x15, 0x02fc);
12079                 MP_WritePhyUshort(sc, 0x19, 0x49b5);
12080                 MP_WritePhyUshort(sc, 0x15, 0x02fd);
12081                 MP_WritePhyUshort(sc, 0x19, 0x6812);
12082                 MP_WritePhyUshort(sc, 0x15, 0x02fe);
12083                 MP_WritePhyUshort(sc, 0x19, 0x66a0);
12084                 MP_WritePhyUshort(sc, 0x15, 0x02ff);
12085                 MP_WritePhyUshort(sc, 0x19, 0x9900);
12086                 MP_WritePhyUshort(sc, 0x15, 0x0300);
12087                 MP_WritePhyUshort(sc, 0x19, 0x64a0);
12088                 MP_WritePhyUshort(sc, 0x15, 0x0301);
12089                 MP_WritePhyUshort(sc, 0x19, 0x3316);
12090                 MP_WritePhyUshort(sc, 0x15, 0x0308);
12091                 MP_WritePhyUshort(sc, 0x19, 0x0000);
12092                 MP_WritePhyUshort(sc, 0x15, 0x030c);
12093                 MP_WritePhyUshort(sc, 0x19, 0x3000);
12094                 MP_WritePhyUshort(sc, 0x15, 0x0312);
12095                 MP_WritePhyUshort(sc, 0x19, 0x0000);
12096                 MP_WritePhyUshort(sc, 0x15, 0x0313);
12097                 MP_WritePhyUshort(sc, 0x19, 0x0000);
12098                 MP_WritePhyUshort(sc, 0x15, 0x0314);
12099                 MP_WritePhyUshort(sc, 0x19, 0x0000);
12100                 MP_WritePhyUshort(sc, 0x15, 0x0315);
12101                 MP_WritePhyUshort(sc, 0x19, 0x0000);
12102                 MP_WritePhyUshort(sc, 0x15, 0x0316);
12103                 MP_WritePhyUshort(sc, 0x19, 0x49b5);
12104                 MP_WritePhyUshort(sc, 0x15, 0x0317);
12105                 MP_WritePhyUshort(sc, 0x19, 0x7d00);
12106                 MP_WritePhyUshort(sc, 0x15, 0x0318);
12107                 MP_WritePhyUshort(sc, 0x19, 0x4d00);
12108                 MP_WritePhyUshort(sc, 0x15, 0x0319);
12109                 MP_WritePhyUshort(sc, 0x19, 0x6810);
12110                 MP_WritePhyUshort(sc, 0x15, 0x031a);
12111                 MP_WritePhyUshort(sc, 0x19, 0x6c08);
12112                 MP_WritePhyUshort(sc, 0x15, 0x031b);
12113                 MP_WritePhyUshort(sc, 0x19, 0x4925);
12114                 MP_WritePhyUshort(sc, 0x15, 0x031c);
12115                 MP_WritePhyUshort(sc, 0x19, 0x403b);
12116                 MP_WritePhyUshort(sc, 0x15, 0x031d);
12117                 MP_WritePhyUshort(sc, 0x19, 0xa602);
12118                 MP_WritePhyUshort(sc, 0x15, 0x031e);
12119                 MP_WritePhyUshort(sc, 0x19, 0x402f);
12120                 MP_WritePhyUshort(sc, 0x15, 0x031f);
12121                 MP_WritePhyUshort(sc, 0x19, 0x4484);
12122                 MP_WritePhyUshort(sc, 0x15, 0x0320);
12123                 MP_WritePhyUshort(sc, 0x19, 0x40c8);
12124                 MP_WritePhyUshort(sc, 0x15, 0x0321);
12125                 MP_WritePhyUshort(sc, 0x19, 0x44c4);
12126                 MP_WritePhyUshort(sc, 0x15, 0x0322);
12127                 MP_WritePhyUshort(sc, 0x19, 0x404f);
12128                 MP_WritePhyUshort(sc, 0x15, 0x0323);
12129                 MP_WritePhyUshort(sc, 0x19, 0x44c8);
12130                 MP_WritePhyUshort(sc, 0x15, 0x0324);
12131                 MP_WritePhyUshort(sc, 0x19, 0xd64f);
12132                 MP_WritePhyUshort(sc, 0x15, 0x0325);
12133                 MP_WritePhyUshort(sc, 0x19, 0x00e7);
12134                 MP_WritePhyUshort(sc, 0x15, 0x0326);
12135                 MP_WritePhyUshort(sc, 0x19, 0x7c08);
12136                 MP_WritePhyUshort(sc, 0x15, 0x0327);
12137                 MP_WritePhyUshort(sc, 0x19, 0x8203);
12138                 MP_WritePhyUshort(sc, 0x15, 0x0328);
12139                 MP_WritePhyUshort(sc, 0x19, 0x4d48);
12140                 MP_WritePhyUshort(sc, 0x15, 0x0329);
12141                 MP_WritePhyUshort(sc, 0x19, 0x332b);
12142                 MP_WritePhyUshort(sc, 0x15, 0x032a);
12143                 MP_WritePhyUshort(sc, 0x19, 0x4d40);
12144                 MP_WritePhyUshort(sc, 0x15, 0x032c);
12145                 MP_WritePhyUshort(sc, 0x19, 0x00f8);
12146                 MP_WritePhyUshort(sc, 0x15, 0x032d);
12147                 MP_WritePhyUshort(sc, 0x19, 0x82b2);
12148                 MP_WritePhyUshort(sc, 0x15, 0x032f);
12149                 MP_WritePhyUshort(sc, 0x19, 0x00b0);
12150                 MP_WritePhyUshort(sc, 0x15, 0x0332);
12151                 MP_WritePhyUshort(sc, 0x19, 0x91f2);
12152                 MP_WritePhyUshort(sc, 0x15, 0x033f);
12153                 MP_WritePhyUshort(sc, 0x19, 0xb6cd);
12154                 MP_WritePhyUshort(sc, 0x15, 0x0340);
12155                 MP_WritePhyUshort(sc, 0x19, 0x9e01);
12156                 MP_WritePhyUshort(sc, 0x15, 0x0341);
12157                 MP_WritePhyUshort(sc, 0x19, 0xd11d);
12158                 MP_WritePhyUshort(sc, 0x15, 0x0342);
12159                 MP_WritePhyUshort(sc, 0x19, 0x009d);
12160                 MP_WritePhyUshort(sc, 0x15, 0x0343);
12161                 MP_WritePhyUshort(sc, 0x19, 0xbb1c);
12162                 MP_WritePhyUshort(sc, 0x15, 0x0344);
12163                 MP_WritePhyUshort(sc, 0x19, 0x8102);
12164                 MP_WritePhyUshort(sc, 0x15, 0x0345);
12165                 MP_WritePhyUshort(sc, 0x19, 0x3348);
12166                 MP_WritePhyUshort(sc, 0x15, 0x0346);
12167                 MP_WritePhyUshort(sc, 0x19, 0xa231);
12168                 MP_WritePhyUshort(sc, 0x15, 0x0347);
12169                 MP_WritePhyUshort(sc, 0x19, 0x335b);
12170                 MP_WritePhyUshort(sc, 0x15, 0x0348);
12171                 MP_WritePhyUshort(sc, 0x19, 0x91f7);
12172                 MP_WritePhyUshort(sc, 0x15, 0x0349);
12173                 MP_WritePhyUshort(sc, 0x19, 0xc218);
12174                 MP_WritePhyUshort(sc, 0x15, 0x034a);
12175                 MP_WritePhyUshort(sc, 0x19, 0x00f5);
12176                 MP_WritePhyUshort(sc, 0x15, 0x034b);
12177                 MP_WritePhyUshort(sc, 0x19, 0x335b);
12178                 MP_WritePhyUshort(sc, 0x15, 0x034c);
12179                 MP_WritePhyUshort(sc, 0x19, 0x0000);
12180                 MP_WritePhyUshort(sc, 0x15, 0x034d);
12181                 MP_WritePhyUshort(sc, 0x19, 0x0000);
12182                 MP_WritePhyUshort(sc, 0x15, 0x034e);
12183                 MP_WritePhyUshort(sc, 0x19, 0x0000);
12184                 MP_WritePhyUshort(sc, 0x15, 0x034f);
12185                 MP_WritePhyUshort(sc, 0x19, 0x0000);
12186                 MP_WritePhyUshort(sc, 0x15, 0x0350);
12187                 MP_WritePhyUshort(sc, 0x19, 0x0000);
12188                 MP_WritePhyUshort(sc, 0x15, 0x035b);
12189                 MP_WritePhyUshort(sc, 0x19, 0xa23c);
12190                 MP_WritePhyUshort(sc, 0x15, 0x035c);
12191                 MP_WritePhyUshort(sc, 0x19, 0x7c08);
12192                 MP_WritePhyUshort(sc, 0x15, 0x035d);
12193                 MP_WritePhyUshort(sc, 0x19, 0x4c00);
12194                 MP_WritePhyUshort(sc, 0x15, 0x035e);
12195                 MP_WritePhyUshort(sc, 0x19, 0x3397);
12196                 MP_WritePhyUshort(sc, 0x15, 0x0363);
12197                 MP_WritePhyUshort(sc, 0x19, 0xb6a9);
12198                 MP_WritePhyUshort(sc, 0x15, 0x0366);
12199                 MP_WritePhyUshort(sc, 0x19, 0x00f5);
12200                 MP_WritePhyUshort(sc, 0x15, 0x0382);
12201                 MP_WritePhyUshort(sc, 0x19, 0x7c40);
12202                 MP_WritePhyUshort(sc, 0x15, 0x0388);
12203                 MP_WritePhyUshort(sc, 0x19, 0x0084);
12204                 MP_WritePhyUshort(sc, 0x15, 0x0389);
12205                 MP_WritePhyUshort(sc, 0x19, 0xdd17);
12206                 MP_WritePhyUshort(sc, 0x15, 0x038a);
12207                 MP_WritePhyUshort(sc, 0x19, 0x000b);
12208                 MP_WritePhyUshort(sc, 0x15, 0x038b);
12209                 MP_WritePhyUshort(sc, 0x19, 0xa10a);
12210                 MP_WritePhyUshort(sc, 0x15, 0x038c);
12211                 MP_WritePhyUshort(sc, 0x19, 0x337e);
12212                 MP_WritePhyUshort(sc, 0x15, 0x038d);
12213                 MP_WritePhyUshort(sc, 0x19, 0x6c0b);
12214                 MP_WritePhyUshort(sc, 0x15, 0x038e);
12215                 MP_WritePhyUshort(sc, 0x19, 0xa107);
12216                 MP_WritePhyUshort(sc, 0x15, 0x038f);
12217                 MP_WritePhyUshort(sc, 0x19, 0x6c08);
12218                 MP_WritePhyUshort(sc, 0x15, 0x0390);
12219                 MP_WritePhyUshort(sc, 0x19, 0xc017);
12220                 MP_WritePhyUshort(sc, 0x15, 0x0391);
12221                 MP_WritePhyUshort(sc, 0x19, 0x0004);
12222                 MP_WritePhyUshort(sc, 0x15, 0x0392);
12223                 MP_WritePhyUshort(sc, 0x19, 0xd64f);
12224                 MP_WritePhyUshort(sc, 0x15, 0x0393);
12225                 MP_WritePhyUshort(sc, 0x19, 0x00f4);
12226                 MP_WritePhyUshort(sc, 0x15, 0x0397);
12227                 MP_WritePhyUshort(sc, 0x19, 0x4098);
12228                 MP_WritePhyUshort(sc, 0x15, 0x0398);
12229                 MP_WritePhyUshort(sc, 0x19, 0x4408);
12230                 MP_WritePhyUshort(sc, 0x15, 0x0399);
12231                 MP_WritePhyUshort(sc, 0x19, 0x55bf);
12232                 MP_WritePhyUshort(sc, 0x15, 0x039a);
12233                 MP_WritePhyUshort(sc, 0x19, 0x4bb9);
12234                 MP_WritePhyUshort(sc, 0x15, 0x039b);
12235                 MP_WritePhyUshort(sc, 0x19, 0x6810);
12236                 MP_WritePhyUshort(sc, 0x15, 0x039c);
12237                 MP_WritePhyUshort(sc, 0x19, 0x4b29);
12238                 MP_WritePhyUshort(sc, 0x15, 0x039d);
12239                 MP_WritePhyUshort(sc, 0x19, 0x4041);
12240                 MP_WritePhyUshort(sc, 0x15, 0x039e);
12241                 MP_WritePhyUshort(sc, 0x19, 0x442a);
12242                 MP_WritePhyUshort(sc, 0x15, 0x039f);
12243                 MP_WritePhyUshort(sc, 0x19, 0x4029);
12244                 MP_WritePhyUshort(sc, 0x15, 0x03aa);
12245                 MP_WritePhyUshort(sc, 0x19, 0x33b8);
12246                 MP_WritePhyUshort(sc, 0x15, 0x03b6);
12247                 MP_WritePhyUshort(sc, 0x19, 0x0000);
12248                 MP_WritePhyUshort(sc, 0x15, 0x03b7);
12249                 MP_WritePhyUshort(sc, 0x19, 0x0000);
12250                 MP_WritePhyUshort(sc, 0x15, 0x03b8);
12251                 MP_WritePhyUshort(sc, 0x19, 0x543f);
12252                 MP_WritePhyUshort(sc, 0x15, 0x03b9);
12253                 MP_WritePhyUshort(sc, 0x19, 0x499a);
12254                 MP_WritePhyUshort(sc, 0x15, 0x03ba);
12255                 MP_WritePhyUshort(sc, 0x19, 0x7c40);
12256                 MP_WritePhyUshort(sc, 0x15, 0x03bb);
12257                 MP_WritePhyUshort(sc, 0x19, 0x4c40);
12258                 MP_WritePhyUshort(sc, 0x15, 0x03bc);
12259                 MP_WritePhyUshort(sc, 0x19, 0x490a);
12260                 MP_WritePhyUshort(sc, 0x15, 0x03bd);
12261                 MP_WritePhyUshort(sc, 0x19, 0x405e);
12262                 MP_WritePhyUshort(sc, 0x15, 0x03c2);
12263                 MP_WritePhyUshort(sc, 0x19, 0x9a03);
12264                 MP_WritePhyUshort(sc, 0x15, 0x03c4);
12265                 MP_WritePhyUshort(sc, 0x19, 0x0015);
12266                 MP_WritePhyUshort(sc, 0x15, 0x03c5);
12267                 MP_WritePhyUshort(sc, 0x19, 0x9e03);
12268                 MP_WritePhyUshort(sc, 0x15, 0x03c8);
12269                 MP_WritePhyUshort(sc, 0x19, 0x9cf7);
12270                 MP_WritePhyUshort(sc, 0x15, 0x03c9);
12271                 MP_WritePhyUshort(sc, 0x19, 0x7c12);
12272                 MP_WritePhyUshort(sc, 0x15, 0x03ca);
12273                 MP_WritePhyUshort(sc, 0x19, 0x4c52);
12274                 MP_WritePhyUshort(sc, 0x15, 0x03cb);
12275                 MP_WritePhyUshort(sc, 0x19, 0x4458);
12276                 MP_WritePhyUshort(sc, 0x15, 0x03cd);
12277                 MP_WritePhyUshort(sc, 0x19, 0x4c40);
12278                 MP_WritePhyUshort(sc, 0x15, 0x03ce);
12279                 MP_WritePhyUshort(sc, 0x19, 0x33bf);
12280                 MP_WritePhyUshort(sc, 0x15, 0x03cf);
12281                 MP_WritePhyUshort(sc, 0x19, 0x0000);
12282                 MP_WritePhyUshort(sc, 0x15, 0x03d0);
12283                 MP_WritePhyUshort(sc, 0x19, 0x0000);
12284                 MP_WritePhyUshort(sc, 0x15, 0x03d1);
12285                 MP_WritePhyUshort(sc, 0x19, 0x0000);
12286                 MP_WritePhyUshort(sc, 0x15, 0x03d5);
12287                 MP_WritePhyUshort(sc, 0x19, 0x0000);
12288                 MP_WritePhyUshort(sc, 0x15, 0x03d6);
12289                 MP_WritePhyUshort(sc, 0x19, 0x0000);
12290                 MP_WritePhyUshort(sc, 0x15, 0x03d7);
12291                 MP_WritePhyUshort(sc, 0x19, 0x0000);
12292                 MP_WritePhyUshort(sc, 0x15, 0x03d8);
12293                 MP_WritePhyUshort(sc, 0x19, 0x0000);
12294                 MP_WritePhyUshort(sc, 0x15, 0x03d9);
12295                 MP_WritePhyUshort(sc, 0x19, 0x49bb);
12296                 MP_WritePhyUshort(sc, 0x15, 0x03da);
12297                 MP_WritePhyUshort(sc, 0x19, 0x4478);
12298                 MP_WritePhyUshort(sc, 0x15, 0x03db);
12299                 MP_WritePhyUshort(sc, 0x19, 0x492b);
12300                 MP_WritePhyUshort(sc, 0x15, 0x03dc);
12301                 MP_WritePhyUshort(sc, 0x19, 0x7c01);
12302                 MP_WritePhyUshort(sc, 0x15, 0x03dd);
12303                 MP_WritePhyUshort(sc, 0x19, 0x4c00);
12304                 MP_WritePhyUshort(sc, 0x15, 0x03de);
12305                 MP_WritePhyUshort(sc, 0x19, 0xbd1a);
12306                 MP_WritePhyUshort(sc, 0x15, 0x03df);
12307                 MP_WritePhyUshort(sc, 0x19, 0xc428);
12308                 MP_WritePhyUshort(sc, 0x15, 0x03e0);
12309                 MP_WritePhyUshort(sc, 0x19, 0x0008);
12310                 MP_WritePhyUshort(sc, 0x15, 0x03e1);
12311                 MP_WritePhyUshort(sc, 0x19, 0x9cfd);
12312                 MP_WritePhyUshort(sc, 0x15, 0x03e2);
12313                 MP_WritePhyUshort(sc, 0x19, 0x7c12);
12314                 MP_WritePhyUshort(sc, 0x15, 0x03e3);
12315                 MP_WritePhyUshort(sc, 0x19, 0x4c52);
12316                 MP_WritePhyUshort(sc, 0x15, 0x03e4);
12317                 MP_WritePhyUshort(sc, 0x19, 0x4458);
12318                 MP_WritePhyUshort(sc, 0x15, 0x03e5);
12319                 MP_WritePhyUshort(sc, 0x19, 0x7c12);
12320                 MP_WritePhyUshort(sc, 0x15, 0x03e6);
12321                 MP_WritePhyUshort(sc, 0x19, 0x4c40);
12322                 MP_WritePhyUshort(sc, 0x15, 0x03e7);
12323                 MP_WritePhyUshort(sc, 0x19, 0x33de);
12324                 MP_WritePhyUshort(sc, 0x15, 0x03e8);
12325                 MP_WritePhyUshort(sc, 0x19, 0xc218);
12326                 MP_WritePhyUshort(sc, 0x15, 0x03e9);
12327                 MP_WritePhyUshort(sc, 0x19, 0x0002);
12328                 MP_WritePhyUshort(sc, 0x15, 0x03ea);
12329                 MP_WritePhyUshort(sc, 0x19, 0x32df);
12330                 MP_WritePhyUshort(sc, 0x15, 0x03eb);
12331                 MP_WritePhyUshort(sc, 0x19, 0x3316);
12332                 MP_WritePhyUshort(sc, 0x15, 0x03ec);
12333                 MP_WritePhyUshort(sc, 0x19, 0x0000);
12334                 MP_WritePhyUshort(sc, 0x15, 0x03ed);
12335                 MP_WritePhyUshort(sc, 0x19, 0x0000);
12336                 MP_WritePhyUshort(sc, 0x15, 0x03ee);
12337                 MP_WritePhyUshort(sc, 0x19, 0x0000);
12338                 MP_WritePhyUshort(sc, 0x15, 0x03ef);
12339                 MP_WritePhyUshort(sc, 0x19, 0x0000);
12340                 MP_WritePhyUshort(sc, 0x15, 0x03f7);
12341                 MP_WritePhyUshort(sc, 0x19, 0x330c);
12342                 MP_WritePhyUshort(sc, 0x16, 0x0306);
12343                 MP_WritePhyUshort(sc, 0x16, 0x0300);
12344
12345                 MP_WritePhyUshort(sc, 0x1f, 0x0005);
12346                 MP_WritePhyUshort(sc, 0x05, 0xfff6);
12347                 MP_WritePhyUshort(sc, 0x06, 0x0080);
12348                 MP_WritePhyUshort(sc, 0x05, 0x8000);
12349                 MP_WritePhyUshort(sc, 0x06, 0x0280);
12350                 MP_WritePhyUshort(sc, 0x06, 0x48f7);
12351                 MP_WritePhyUshort(sc, 0x06, 0x00e0);
12352                 MP_WritePhyUshort(sc, 0x06, 0xfff7);
12353                 MP_WritePhyUshort(sc, 0x06, 0xa080);
12354                 MP_WritePhyUshort(sc, 0x06, 0x02ae);
12355                 MP_WritePhyUshort(sc, 0x06, 0xf602);
12356                 MP_WritePhyUshort(sc, 0x06, 0x0200);
12357                 MP_WritePhyUshort(sc, 0x06, 0x0280);
12358                 MP_WritePhyUshort(sc, 0x06, 0x9002);
12359                 MP_WritePhyUshort(sc, 0x06, 0x0224);
12360                 MP_WritePhyUshort(sc, 0x06, 0x0202);
12361                 MP_WritePhyUshort(sc, 0x06, 0x3402);
12362                 MP_WritePhyUshort(sc, 0x06, 0x027f);
12363                 MP_WritePhyUshort(sc, 0x06, 0x0280);
12364                 MP_WritePhyUshort(sc, 0x06, 0xa602);
12365                 MP_WritePhyUshort(sc, 0x06, 0x80bf);
12366                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
12367                 MP_WritePhyUshort(sc, 0x06, 0x88e1);
12368                 MP_WritePhyUshort(sc, 0x06, 0x8b89);
12369                 MP_WritePhyUshort(sc, 0x06, 0x1e01);
12370                 MP_WritePhyUshort(sc, 0x06, 0xe18b);
12371                 MP_WritePhyUshort(sc, 0x06, 0x8a1e);
12372                 MP_WritePhyUshort(sc, 0x06, 0x01e1);
12373                 MP_WritePhyUshort(sc, 0x06, 0x8b8b);
12374                 MP_WritePhyUshort(sc, 0x06, 0x1e01);
12375                 MP_WritePhyUshort(sc, 0x06, 0xe18b);
12376                 MP_WritePhyUshort(sc, 0x06, 0x8c1e);
12377                 MP_WritePhyUshort(sc, 0x06, 0x01e1);
12378                 MP_WritePhyUshort(sc, 0x06, 0x8b8d);
12379                 MP_WritePhyUshort(sc, 0x06, 0x1e01);
12380                 MP_WritePhyUshort(sc, 0x06, 0xe18b);
12381                 MP_WritePhyUshort(sc, 0x06, 0x8e1e);
12382                 MP_WritePhyUshort(sc, 0x06, 0x01a0);
12383                 MP_WritePhyUshort(sc, 0x06, 0x00c7);
12384                 MP_WritePhyUshort(sc, 0x06, 0xaebb);
12385                 MP_WritePhyUshort(sc, 0x06, 0xee8a);
12386                 MP_WritePhyUshort(sc, 0x06, 0xe600);
12387                 MP_WritePhyUshort(sc, 0x06, 0xee8a);
12388                 MP_WritePhyUshort(sc, 0x06, 0xee03);
12389                 MP_WritePhyUshort(sc, 0x06, 0xee8a);
12390                 MP_WritePhyUshort(sc, 0x06, 0xefb8);
12391                 MP_WritePhyUshort(sc, 0x06, 0xee8a);
12392                 MP_WritePhyUshort(sc, 0x06, 0xe902);
12393                 MP_WritePhyUshort(sc, 0x06, 0xee8b);
12394                 MP_WritePhyUshort(sc, 0x06, 0x8285);
12395                 MP_WritePhyUshort(sc, 0x06, 0xee8b);
12396                 MP_WritePhyUshort(sc, 0x06, 0x8520);
12397                 MP_WritePhyUshort(sc, 0x06, 0xee8b);
12398                 MP_WritePhyUshort(sc, 0x06, 0x8701);
12399                 MP_WritePhyUshort(sc, 0x06, 0xd481);
12400                 MP_WritePhyUshort(sc, 0x06, 0x35e4);
12401                 MP_WritePhyUshort(sc, 0x06, 0x8b94);
12402                 MP_WritePhyUshort(sc, 0x06, 0xe58b);
12403                 MP_WritePhyUshort(sc, 0x06, 0x95bf);
12404                 MP_WritePhyUshort(sc, 0x06, 0x8b88);
12405                 MP_WritePhyUshort(sc, 0x06, 0xec00);
12406                 MP_WritePhyUshort(sc, 0x06, 0x19a9);
12407                 MP_WritePhyUshort(sc, 0x06, 0x8b90);
12408                 MP_WritePhyUshort(sc, 0x06, 0xf9ee);
12409                 MP_WritePhyUshort(sc, 0x06, 0xfff6);
12410                 MP_WritePhyUshort(sc, 0x06, 0x00ee);
12411                 MP_WritePhyUshort(sc, 0x06, 0xfff7);
12412                 MP_WritePhyUshort(sc, 0x06, 0xffe0);
12413                 MP_WritePhyUshort(sc, 0x06, 0xe140);
12414                 MP_WritePhyUshort(sc, 0x06, 0xe1e1);
12415                 MP_WritePhyUshort(sc, 0x06, 0x41f7);
12416                 MP_WritePhyUshort(sc, 0x06, 0x2ff6);
12417                 MP_WritePhyUshort(sc, 0x06, 0x28e4);
12418                 MP_WritePhyUshort(sc, 0x06, 0xe140);
12419                 MP_WritePhyUshort(sc, 0x06, 0xe5e1);
12420                 MP_WritePhyUshort(sc, 0x06, 0x4104);
12421                 MP_WritePhyUshort(sc, 0x06, 0xf8e0);
12422                 MP_WritePhyUshort(sc, 0x06, 0x8b89);
12423                 MP_WritePhyUshort(sc, 0x06, 0xad20);
12424                 MP_WritePhyUshort(sc, 0x06, 0x0dee);
12425                 MP_WritePhyUshort(sc, 0x06, 0x8b89);
12426                 MP_WritePhyUshort(sc, 0x06, 0x0002);
12427                 MP_WritePhyUshort(sc, 0x06, 0x82f4);
12428                 MP_WritePhyUshort(sc, 0x06, 0x021f);
12429                 MP_WritePhyUshort(sc, 0x06, 0x4102);
12430                 MP_WritePhyUshort(sc, 0x06, 0x2812);
12431                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
12432                 MP_WritePhyUshort(sc, 0x06, 0xf8e0);
12433                 MP_WritePhyUshort(sc, 0x06, 0x8b8d);
12434                 MP_WritePhyUshort(sc, 0x06, 0xad20);
12435                 MP_WritePhyUshort(sc, 0x06, 0x10ee);
12436                 MP_WritePhyUshort(sc, 0x06, 0x8b8d);
12437                 MP_WritePhyUshort(sc, 0x06, 0x0002);
12438                 MP_WritePhyUshort(sc, 0x06, 0x139d);
12439                 MP_WritePhyUshort(sc, 0x06, 0x0281);
12440                 MP_WritePhyUshort(sc, 0x06, 0xd602);
12441                 MP_WritePhyUshort(sc, 0x06, 0x1f99);
12442                 MP_WritePhyUshort(sc, 0x06, 0x0227);
12443                 MP_WritePhyUshort(sc, 0x06, 0xeafc);
12444                 MP_WritePhyUshort(sc, 0x06, 0x04f8);
12445                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
12446                 MP_WritePhyUshort(sc, 0x06, 0x8ead);
12447                 MP_WritePhyUshort(sc, 0x06, 0x2014);
12448                 MP_WritePhyUshort(sc, 0x06, 0xf620);
12449                 MP_WritePhyUshort(sc, 0x06, 0xe48b);
12450                 MP_WritePhyUshort(sc, 0x06, 0x8e02);
12451                 MP_WritePhyUshort(sc, 0x06, 0x8104);
12452                 MP_WritePhyUshort(sc, 0x06, 0x021b);
12453                 MP_WritePhyUshort(sc, 0x06, 0xf402);
12454                 MP_WritePhyUshort(sc, 0x06, 0x2c9c);
12455                 MP_WritePhyUshort(sc, 0x06, 0x0281);
12456                 MP_WritePhyUshort(sc, 0x06, 0x7902);
12457                 MP_WritePhyUshort(sc, 0x06, 0x8443);
12458                 MP_WritePhyUshort(sc, 0x06, 0xad22);
12459                 MP_WritePhyUshort(sc, 0x06, 0x11f6);
12460                 MP_WritePhyUshort(sc, 0x06, 0x22e4);
12461                 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
12462                 MP_WritePhyUshort(sc, 0x06, 0x022c);
12463                 MP_WritePhyUshort(sc, 0x06, 0x4602);
12464                 MP_WritePhyUshort(sc, 0x06, 0x2ac5);
12465                 MP_WritePhyUshort(sc, 0x06, 0x0229);
12466                 MP_WritePhyUshort(sc, 0x06, 0x2002);
12467                 MP_WritePhyUshort(sc, 0x06, 0x2b91);
12468                 MP_WritePhyUshort(sc, 0x06, 0xad25);
12469                 MP_WritePhyUshort(sc, 0x06, 0x11f6);
12470                 MP_WritePhyUshort(sc, 0x06, 0x25e4);
12471                 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
12472                 MP_WritePhyUshort(sc, 0x06, 0x0284);
12473                 MP_WritePhyUshort(sc, 0x06, 0xe202);
12474                 MP_WritePhyUshort(sc, 0x06, 0x043a);
12475                 MP_WritePhyUshort(sc, 0x06, 0x021a);
12476                 MP_WritePhyUshort(sc, 0x06, 0x5902);
12477                 MP_WritePhyUshort(sc, 0x06, 0x2bfc);
12478                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
12479                 MP_WritePhyUshort(sc, 0x06, 0xf8fa);
12480                 MP_WritePhyUshort(sc, 0x06, 0xef69);
12481                 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
12482                 MP_WritePhyUshort(sc, 0x06, 0x00e1);
12483                 MP_WritePhyUshort(sc, 0x06, 0xe001);
12484                 MP_WritePhyUshort(sc, 0x06, 0xad27);
12485                 MP_WritePhyUshort(sc, 0x06, 0x1fd1);
12486                 MP_WritePhyUshort(sc, 0x06, 0x01bf);
12487                 MP_WritePhyUshort(sc, 0x06, 0x8638);
12488                 MP_WritePhyUshort(sc, 0x06, 0x022f);
12489                 MP_WritePhyUshort(sc, 0x06, 0x50e0);
12490                 MP_WritePhyUshort(sc, 0x06, 0xe020);
12491                 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
12492                 MP_WritePhyUshort(sc, 0x06, 0x21ad);
12493                 MP_WritePhyUshort(sc, 0x06, 0x200e);
12494                 MP_WritePhyUshort(sc, 0x06, 0xd100);
12495                 MP_WritePhyUshort(sc, 0x06, 0xbf86);
12496                 MP_WritePhyUshort(sc, 0x06, 0x3802);
12497                 MP_WritePhyUshort(sc, 0x06, 0x2f50);
12498                 MP_WritePhyUshort(sc, 0x06, 0xbf3d);
12499                 MP_WritePhyUshort(sc, 0x06, 0x3902);
12500                 MP_WritePhyUshort(sc, 0x06, 0x2eb0);
12501                 MP_WritePhyUshort(sc, 0x06, 0xef96);
12502                 MP_WritePhyUshort(sc, 0x06, 0xfefc);
12503                 MP_WritePhyUshort(sc, 0x06, 0x0402);
12504                 MP_WritePhyUshort(sc, 0x06, 0x8591);
12505                 MP_WritePhyUshort(sc, 0x06, 0x0281);
12506                 MP_WritePhyUshort(sc, 0x06, 0x3c05);
12507                 MP_WritePhyUshort(sc, 0x06, 0xf8fa);
12508                 MP_WritePhyUshort(sc, 0x06, 0xef69);
12509                 MP_WritePhyUshort(sc, 0x06, 0xe0e2);
12510                 MP_WritePhyUshort(sc, 0x06, 0xfee1);
12511                 MP_WritePhyUshort(sc, 0x06, 0xe2ff);
12512                 MP_WritePhyUshort(sc, 0x06, 0xad2d);
12513                 MP_WritePhyUshort(sc, 0x06, 0x1ae0);
12514                 MP_WritePhyUshort(sc, 0x06, 0xe14e);
12515                 MP_WritePhyUshort(sc, 0x06, 0xe1e1);
12516                 MP_WritePhyUshort(sc, 0x06, 0x4fac);
12517                 MP_WritePhyUshort(sc, 0x06, 0x2d22);
12518                 MP_WritePhyUshort(sc, 0x06, 0xf603);
12519                 MP_WritePhyUshort(sc, 0x06, 0x0203);
12520                 MP_WritePhyUshort(sc, 0x06, 0x36f7);
12521                 MP_WritePhyUshort(sc, 0x06, 0x03f7);
12522                 MP_WritePhyUshort(sc, 0x06, 0x06bf);
12523                 MP_WritePhyUshort(sc, 0x06, 0x8622);
12524                 MP_WritePhyUshort(sc, 0x06, 0x022e);
12525                 MP_WritePhyUshort(sc, 0x06, 0xb0ae);
12526                 MP_WritePhyUshort(sc, 0x06, 0x11e0);
12527                 MP_WritePhyUshort(sc, 0x06, 0xe14e);
12528                 MP_WritePhyUshort(sc, 0x06, 0xe1e1);
12529                 MP_WritePhyUshort(sc, 0x06, 0x4fad);
12530                 MP_WritePhyUshort(sc, 0x06, 0x2d08);
12531                 MP_WritePhyUshort(sc, 0x06, 0xbf86);
12532                 MP_WritePhyUshort(sc, 0x06, 0x2d02);
12533                 MP_WritePhyUshort(sc, 0x06, 0x2eb0);
12534                 MP_WritePhyUshort(sc, 0x06, 0xf606);
12535                 MP_WritePhyUshort(sc, 0x06, 0xef96);
12536                 MP_WritePhyUshort(sc, 0x06, 0xfefc);
12537                 MP_WritePhyUshort(sc, 0x06, 0x04f8);
12538                 MP_WritePhyUshort(sc, 0x06, 0xf9fa);
12539                 MP_WritePhyUshort(sc, 0x06, 0xef69);
12540                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
12541                 MP_WritePhyUshort(sc, 0x06, 0x87ad);
12542                 MP_WritePhyUshort(sc, 0x06, 0x204c);
12543                 MP_WritePhyUshort(sc, 0x06, 0xd200);
12544                 MP_WritePhyUshort(sc, 0x06, 0xe0e2);
12545                 MP_WritePhyUshort(sc, 0x06, 0x0058);
12546                 MP_WritePhyUshort(sc, 0x06, 0x010c);
12547                 MP_WritePhyUshort(sc, 0x06, 0x021e);
12548                 MP_WritePhyUshort(sc, 0x06, 0x20e0);
12549                 MP_WritePhyUshort(sc, 0x06, 0xe000);
12550                 MP_WritePhyUshort(sc, 0x06, 0x5810);
12551                 MP_WritePhyUshort(sc, 0x06, 0x1e20);
12552                 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
12553                 MP_WritePhyUshort(sc, 0x06, 0x3658);
12554                 MP_WritePhyUshort(sc, 0x06, 0x031e);
12555                 MP_WritePhyUshort(sc, 0x06, 0x20e0);
12556                 MP_WritePhyUshort(sc, 0x06, 0xe022);
12557                 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
12558                 MP_WritePhyUshort(sc, 0x06, 0x2358);
12559                 MP_WritePhyUshort(sc, 0x06, 0xe01e);
12560                 MP_WritePhyUshort(sc, 0x06, 0x20e0);
12561                 MP_WritePhyUshort(sc, 0x06, 0x8ae6);
12562                 MP_WritePhyUshort(sc, 0x06, 0x1f02);
12563                 MP_WritePhyUshort(sc, 0x06, 0x9e22);
12564                 MP_WritePhyUshort(sc, 0x06, 0xe68a);
12565                 MP_WritePhyUshort(sc, 0x06, 0xe6ad);
12566                 MP_WritePhyUshort(sc, 0x06, 0x3214);
12567                 MP_WritePhyUshort(sc, 0x06, 0xad34);
12568                 MP_WritePhyUshort(sc, 0x06, 0x11ef);
12569                 MP_WritePhyUshort(sc, 0x06, 0x0258);
12570                 MP_WritePhyUshort(sc, 0x06, 0x039e);
12571                 MP_WritePhyUshort(sc, 0x06, 0x07ad);
12572                 MP_WritePhyUshort(sc, 0x06, 0x3508);
12573                 MP_WritePhyUshort(sc, 0x06, 0x5ac0);
12574                 MP_WritePhyUshort(sc, 0x06, 0x9f04);
12575                 MP_WritePhyUshort(sc, 0x06, 0xd101);
12576                 MP_WritePhyUshort(sc, 0x06, 0xae02);
12577                 MP_WritePhyUshort(sc, 0x06, 0xd100);
12578                 MP_WritePhyUshort(sc, 0x06, 0xbf86);
12579                 MP_WritePhyUshort(sc, 0x06, 0x3e02);
12580                 MP_WritePhyUshort(sc, 0x06, 0x2f50);
12581                 MP_WritePhyUshort(sc, 0x06, 0xef96);
12582                 MP_WritePhyUshort(sc, 0x06, 0xfefd);
12583                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
12584                 MP_WritePhyUshort(sc, 0x06, 0xf8f9);
12585                 MP_WritePhyUshort(sc, 0x06, 0xfae0);
12586                 MP_WritePhyUshort(sc, 0x06, 0x8b81);
12587                 MP_WritePhyUshort(sc, 0x06, 0xac26);
12588                 MP_WritePhyUshort(sc, 0x06, 0x0ee0);
12589                 MP_WritePhyUshort(sc, 0x06, 0x8b81);
12590                 MP_WritePhyUshort(sc, 0x06, 0xac21);
12591                 MP_WritePhyUshort(sc, 0x06, 0x08e0);
12592                 MP_WritePhyUshort(sc, 0x06, 0x8b87);
12593                 MP_WritePhyUshort(sc, 0x06, 0xac24);
12594                 MP_WritePhyUshort(sc, 0x06, 0x02ae);
12595                 MP_WritePhyUshort(sc, 0x06, 0x6bee);
12596                 MP_WritePhyUshort(sc, 0x06, 0xe0ea);
12597                 MP_WritePhyUshort(sc, 0x06, 0x00ee);
12598                 MP_WritePhyUshort(sc, 0x06, 0xe0eb);
12599                 MP_WritePhyUshort(sc, 0x06, 0x00e2);
12600                 MP_WritePhyUshort(sc, 0x06, 0xe07c);
12601                 MP_WritePhyUshort(sc, 0x06, 0xe3e0);
12602                 MP_WritePhyUshort(sc, 0x06, 0x7da5);
12603                 MP_WritePhyUshort(sc, 0x06, 0x1111);
12604                 MP_WritePhyUshort(sc, 0x06, 0x15d2);
12605                 MP_WritePhyUshort(sc, 0x06, 0x60d6);
12606                 MP_WritePhyUshort(sc, 0x06, 0x6666);
12607                 MP_WritePhyUshort(sc, 0x06, 0x0207);
12608                 MP_WritePhyUshort(sc, 0x06, 0xf9d2);
12609                 MP_WritePhyUshort(sc, 0x06, 0xa0d6);
12610                 MP_WritePhyUshort(sc, 0x06, 0xaaaa);
12611                 MP_WritePhyUshort(sc, 0x06, 0x0207);
12612                 MP_WritePhyUshort(sc, 0x06, 0xf902);
12613                 MP_WritePhyUshort(sc, 0x06, 0x825c);
12614                 MP_WritePhyUshort(sc, 0x06, 0xae44);
12615                 MP_WritePhyUshort(sc, 0x06, 0xa566);
12616                 MP_WritePhyUshort(sc, 0x06, 0x6602);
12617                 MP_WritePhyUshort(sc, 0x06, 0xae38);
12618                 MP_WritePhyUshort(sc, 0x06, 0xa5aa);
12619                 MP_WritePhyUshort(sc, 0x06, 0xaa02);
12620                 MP_WritePhyUshort(sc, 0x06, 0xae32);
12621                 MP_WritePhyUshort(sc, 0x06, 0xeee0);
12622                 MP_WritePhyUshort(sc, 0x06, 0xea04);
12623                 MP_WritePhyUshort(sc, 0x06, 0xeee0);
12624                 MP_WritePhyUshort(sc, 0x06, 0xeb06);
12625                 MP_WritePhyUshort(sc, 0x06, 0xe2e0);
12626                 MP_WritePhyUshort(sc, 0x06, 0x7ce3);
12627                 MP_WritePhyUshort(sc, 0x06, 0xe07d);
12628                 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
12629                 MP_WritePhyUshort(sc, 0x06, 0x38e1);
12630                 MP_WritePhyUshort(sc, 0x06, 0xe039);
12631                 MP_WritePhyUshort(sc, 0x06, 0xad2e);
12632                 MP_WritePhyUshort(sc, 0x06, 0x21ad);
12633                 MP_WritePhyUshort(sc, 0x06, 0x3f13);
12634                 MP_WritePhyUshort(sc, 0x06, 0xe0e4);
12635                 MP_WritePhyUshort(sc, 0x06, 0x14e1);
12636                 MP_WritePhyUshort(sc, 0x06, 0xe415);
12637                 MP_WritePhyUshort(sc, 0x06, 0x6880);
12638                 MP_WritePhyUshort(sc, 0x06, 0xe4e4);
12639                 MP_WritePhyUshort(sc, 0x06, 0x14e5);
12640                 MP_WritePhyUshort(sc, 0x06, 0xe415);
12641                 MP_WritePhyUshort(sc, 0x06, 0x0282);
12642                 MP_WritePhyUshort(sc, 0x06, 0x5cae);
12643                 MP_WritePhyUshort(sc, 0x06, 0x0bac);
12644                 MP_WritePhyUshort(sc, 0x06, 0x3e02);
12645                 MP_WritePhyUshort(sc, 0x06, 0xae06);
12646                 MP_WritePhyUshort(sc, 0x06, 0x0282);
12647                 MP_WritePhyUshort(sc, 0x06, 0x8602);
12648                 MP_WritePhyUshort(sc, 0x06, 0x82b0);
12649                 MP_WritePhyUshort(sc, 0x06, 0xfefd);
12650                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
12651                 MP_WritePhyUshort(sc, 0x06, 0xf8e1);
12652                 MP_WritePhyUshort(sc, 0x06, 0x8b2e);
12653                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
12654                 MP_WritePhyUshort(sc, 0x06, 0x81ad);
12655                 MP_WritePhyUshort(sc, 0x06, 0x2605);
12656                 MP_WritePhyUshort(sc, 0x06, 0x0221);
12657                 MP_WritePhyUshort(sc, 0x06, 0xf3f7);
12658                 MP_WritePhyUshort(sc, 0x06, 0x28e0);
12659                 MP_WritePhyUshort(sc, 0x06, 0x8b81);
12660                 MP_WritePhyUshort(sc, 0x06, 0xad21);
12661                 MP_WritePhyUshort(sc, 0x06, 0x0502);
12662                 MP_WritePhyUshort(sc, 0x06, 0x22f8);
12663                 MP_WritePhyUshort(sc, 0x06, 0xf729);
12664                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
12665                 MP_WritePhyUshort(sc, 0x06, 0x87ad);
12666                 MP_WritePhyUshort(sc, 0x06, 0x2405);
12667                 MP_WritePhyUshort(sc, 0x06, 0x0282);
12668                 MP_WritePhyUshort(sc, 0x06, 0xebf7);
12669                 MP_WritePhyUshort(sc, 0x06, 0x2ae5);
12670                 MP_WritePhyUshort(sc, 0x06, 0x8b2e);
12671                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
12672                 MP_WritePhyUshort(sc, 0x06, 0xf8e0);
12673                 MP_WritePhyUshort(sc, 0x06, 0x8b81);
12674                 MP_WritePhyUshort(sc, 0x06, 0xad26);
12675                 MP_WritePhyUshort(sc, 0x06, 0x0302);
12676                 MP_WritePhyUshort(sc, 0x06, 0x2134);
12677                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
12678                 MP_WritePhyUshort(sc, 0x06, 0x81ad);
12679                 MP_WritePhyUshort(sc, 0x06, 0x2109);
12680                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
12681                 MP_WritePhyUshort(sc, 0x06, 0x2eac);
12682                 MP_WritePhyUshort(sc, 0x06, 0x2003);
12683                 MP_WritePhyUshort(sc, 0x06, 0x0283);
12684                 MP_WritePhyUshort(sc, 0x06, 0x52e0);
12685                 MP_WritePhyUshort(sc, 0x06, 0x8b87);
12686                 MP_WritePhyUshort(sc, 0x06, 0xad24);
12687                 MP_WritePhyUshort(sc, 0x06, 0x09e0);
12688                 MP_WritePhyUshort(sc, 0x06, 0x8b2e);
12689                 MP_WritePhyUshort(sc, 0x06, 0xac21);
12690                 MP_WritePhyUshort(sc, 0x06, 0x0302);
12691                 MP_WritePhyUshort(sc, 0x06, 0x8337);
12692                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
12693                 MP_WritePhyUshort(sc, 0x06, 0xf8e1);
12694                 MP_WritePhyUshort(sc, 0x06, 0x8b2e);
12695                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
12696                 MP_WritePhyUshort(sc, 0x06, 0x81ad);
12697                 MP_WritePhyUshort(sc, 0x06, 0x2608);
12698                 MP_WritePhyUshort(sc, 0x06, 0xe085);
12699                 MP_WritePhyUshort(sc, 0x06, 0xd2ad);
12700                 MP_WritePhyUshort(sc, 0x06, 0x2502);
12701                 MP_WritePhyUshort(sc, 0x06, 0xf628);
12702                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
12703                 MP_WritePhyUshort(sc, 0x06, 0x81ad);
12704                 MP_WritePhyUshort(sc, 0x06, 0x210a);
12705                 MP_WritePhyUshort(sc, 0x06, 0xe086);
12706                 MP_WritePhyUshort(sc, 0x06, 0x0af6);
12707                 MP_WritePhyUshort(sc, 0x06, 0x27a0);
12708                 MP_WritePhyUshort(sc, 0x06, 0x0502);
12709                 MP_WritePhyUshort(sc, 0x06, 0xf629);
12710                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
12711                 MP_WritePhyUshort(sc, 0x06, 0x87ad);
12712                 MP_WritePhyUshort(sc, 0x06, 0x2408);
12713                 MP_WritePhyUshort(sc, 0x06, 0xe08a);
12714                 MP_WritePhyUshort(sc, 0x06, 0xedad);
12715                 MP_WritePhyUshort(sc, 0x06, 0x2002);
12716                 MP_WritePhyUshort(sc, 0x06, 0xf62a);
12717                 MP_WritePhyUshort(sc, 0x06, 0xe58b);
12718                 MP_WritePhyUshort(sc, 0x06, 0x2ea1);
12719                 MP_WritePhyUshort(sc, 0x06, 0x0003);
12720                 MP_WritePhyUshort(sc, 0x06, 0x0221);
12721                 MP_WritePhyUshort(sc, 0x06, 0x11fc);
12722                 MP_WritePhyUshort(sc, 0x06, 0x04ee);
12723                 MP_WritePhyUshort(sc, 0x06, 0x8aed);
12724                 MP_WritePhyUshort(sc, 0x06, 0x00ee);
12725                 MP_WritePhyUshort(sc, 0x06, 0x8aec);
12726                 MP_WritePhyUshort(sc, 0x06, 0x0004);
12727                 MP_WritePhyUshort(sc, 0x06, 0xf8e0);
12728                 MP_WritePhyUshort(sc, 0x06, 0x8b87);
12729                 MP_WritePhyUshort(sc, 0x06, 0xad24);
12730                 MP_WritePhyUshort(sc, 0x06, 0x3ae0);
12731                 MP_WritePhyUshort(sc, 0x06, 0xe0ea);
12732                 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
12733                 MP_WritePhyUshort(sc, 0x06, 0xeb58);
12734                 MP_WritePhyUshort(sc, 0x06, 0xf8d1);
12735                 MP_WritePhyUshort(sc, 0x06, 0x01e4);
12736                 MP_WritePhyUshort(sc, 0x06, 0xe0ea);
12737                 MP_WritePhyUshort(sc, 0x06, 0xe5e0);
12738                 MP_WritePhyUshort(sc, 0x06, 0xebe0);
12739                 MP_WritePhyUshort(sc, 0x06, 0xe07c);
12740                 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
12741                 MP_WritePhyUshort(sc, 0x06, 0x7d5c);
12742                 MP_WritePhyUshort(sc, 0x06, 0x00ff);
12743                 MP_WritePhyUshort(sc, 0x06, 0x3c00);
12744                 MP_WritePhyUshort(sc, 0x06, 0x1eab);
12745                 MP_WritePhyUshort(sc, 0x06, 0x1ce0);
12746                 MP_WritePhyUshort(sc, 0x06, 0xe04c);
12747                 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
12748                 MP_WritePhyUshort(sc, 0x06, 0x4d58);
12749                 MP_WritePhyUshort(sc, 0x06, 0xc1e4);
12750                 MP_WritePhyUshort(sc, 0x06, 0xe04c);
12751                 MP_WritePhyUshort(sc, 0x06, 0xe5e0);
12752                 MP_WritePhyUshort(sc, 0x06, 0x4de0);
12753                 MP_WritePhyUshort(sc, 0x06, 0xe0ee);
12754                 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
12755                 MP_WritePhyUshort(sc, 0x06, 0xef69);
12756                 MP_WritePhyUshort(sc, 0x06, 0x3ce4);
12757                 MP_WritePhyUshort(sc, 0x06, 0xe0ee);
12758                 MP_WritePhyUshort(sc, 0x06, 0xe5e0);
12759                 MP_WritePhyUshort(sc, 0x06, 0xeffc);
12760                 MP_WritePhyUshort(sc, 0x06, 0x04f8);
12761                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
12762                 MP_WritePhyUshort(sc, 0x06, 0x87ad);
12763                 MP_WritePhyUshort(sc, 0x06, 0x2412);
12764                 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
12765                 MP_WritePhyUshort(sc, 0x06, 0xeee1);
12766                 MP_WritePhyUshort(sc, 0x06, 0xe0ef);
12767                 MP_WritePhyUshort(sc, 0x06, 0x59c3);
12768                 MP_WritePhyUshort(sc, 0x06, 0xe4e0);
12769                 MP_WritePhyUshort(sc, 0x06, 0xeee5);
12770                 MP_WritePhyUshort(sc, 0x06, 0xe0ef);
12771                 MP_WritePhyUshort(sc, 0x06, 0xee8a);
12772                 MP_WritePhyUshort(sc, 0x06, 0xed01);
12773                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
12774                 MP_WritePhyUshort(sc, 0x06, 0xf8e0);
12775                 MP_WritePhyUshort(sc, 0x06, 0x8b81);
12776                 MP_WritePhyUshort(sc, 0x06, 0xac25);
12777                 MP_WritePhyUshort(sc, 0x06, 0x0502);
12778                 MP_WritePhyUshort(sc, 0x06, 0x8363);
12779                 MP_WritePhyUshort(sc, 0x06, 0xae03);
12780                 MP_WritePhyUshort(sc, 0x06, 0x0225);
12781                 MP_WritePhyUshort(sc, 0x06, 0x16fc);
12782                 MP_WritePhyUshort(sc, 0x06, 0x04f8);
12783                 MP_WritePhyUshort(sc, 0x06, 0xf9fa);
12784                 MP_WritePhyUshort(sc, 0x06, 0xef69);
12785                 MP_WritePhyUshort(sc, 0x06, 0xfae0);
12786                 MP_WritePhyUshort(sc, 0x06, 0x860a);
12787                 MP_WritePhyUshort(sc, 0x06, 0xa000);
12788                 MP_WritePhyUshort(sc, 0x06, 0x19e0);
12789                 MP_WritePhyUshort(sc, 0x06, 0x860b);
12790                 MP_WritePhyUshort(sc, 0x06, 0xe18b);
12791                 MP_WritePhyUshort(sc, 0x06, 0x331b);
12792                 MP_WritePhyUshort(sc, 0x06, 0x109e);
12793                 MP_WritePhyUshort(sc, 0x06, 0x04aa);
12794                 MP_WritePhyUshort(sc, 0x06, 0x02ae);
12795                 MP_WritePhyUshort(sc, 0x06, 0x06ee);
12796                 MP_WritePhyUshort(sc, 0x06, 0x860a);
12797                 MP_WritePhyUshort(sc, 0x06, 0x01ae);
12798                 MP_WritePhyUshort(sc, 0x06, 0xe602);
12799                 MP_WritePhyUshort(sc, 0x06, 0x241e);
12800                 MP_WritePhyUshort(sc, 0x06, 0xae14);
12801                 MP_WritePhyUshort(sc, 0x06, 0xa001);
12802                 MP_WritePhyUshort(sc, 0x06, 0x1402);
12803                 MP_WritePhyUshort(sc, 0x06, 0x2426);
12804                 MP_WritePhyUshort(sc, 0x06, 0xbf26);
12805                 MP_WritePhyUshort(sc, 0x06, 0x6d02);
12806                 MP_WritePhyUshort(sc, 0x06, 0x2eb0);
12807                 MP_WritePhyUshort(sc, 0x06, 0xee86);
12808                 MP_WritePhyUshort(sc, 0x06, 0x0b00);
12809                 MP_WritePhyUshort(sc, 0x06, 0xee86);
12810                 MP_WritePhyUshort(sc, 0x06, 0x0a02);
12811                 MP_WritePhyUshort(sc, 0x06, 0xaf84);
12812                 MP_WritePhyUshort(sc, 0x06, 0x3ca0);
12813                 MP_WritePhyUshort(sc, 0x06, 0x0252);
12814                 MP_WritePhyUshort(sc, 0x06, 0xee86);
12815                 MP_WritePhyUshort(sc, 0x06, 0x0400);
12816                 MP_WritePhyUshort(sc, 0x06, 0xee86);
12817                 MP_WritePhyUshort(sc, 0x06, 0x0500);
12818                 MP_WritePhyUshort(sc, 0x06, 0xe086);
12819                 MP_WritePhyUshort(sc, 0x06, 0x0be1);
12820                 MP_WritePhyUshort(sc, 0x06, 0x8b32);
12821                 MP_WritePhyUshort(sc, 0x06, 0x1b10);
12822                 MP_WritePhyUshort(sc, 0x06, 0x9e04);
12823                 MP_WritePhyUshort(sc, 0x06, 0xaa02);
12824                 MP_WritePhyUshort(sc, 0x06, 0xaecb);
12825                 MP_WritePhyUshort(sc, 0x06, 0xee86);
12826                 MP_WritePhyUshort(sc, 0x06, 0x0b00);
12827                 MP_WritePhyUshort(sc, 0x06, 0x0224);
12828                 MP_WritePhyUshort(sc, 0x06, 0x3ae2);
12829                 MP_WritePhyUshort(sc, 0x06, 0x8604);
12830                 MP_WritePhyUshort(sc, 0x06, 0xe386);
12831                 MP_WritePhyUshort(sc, 0x06, 0x05ef);
12832                 MP_WritePhyUshort(sc, 0x06, 0x65e2);
12833                 MP_WritePhyUshort(sc, 0x06, 0x8606);
12834                 MP_WritePhyUshort(sc, 0x06, 0xe386);
12835                 MP_WritePhyUshort(sc, 0x06, 0x071b);
12836                 MP_WritePhyUshort(sc, 0x06, 0x56aa);
12837                 MP_WritePhyUshort(sc, 0x06, 0x0eef);
12838                 MP_WritePhyUshort(sc, 0x06, 0x56e6);
12839                 MP_WritePhyUshort(sc, 0x06, 0x8606);
12840                 MP_WritePhyUshort(sc, 0x06, 0xe786);
12841                 MP_WritePhyUshort(sc, 0x06, 0x07e2);
12842                 MP_WritePhyUshort(sc, 0x06, 0x8609);
12843                 MP_WritePhyUshort(sc, 0x06, 0xe686);
12844                 MP_WritePhyUshort(sc, 0x06, 0x08e0);
12845                 MP_WritePhyUshort(sc, 0x06, 0x8609);
12846                 MP_WritePhyUshort(sc, 0x06, 0xa000);
12847                 MP_WritePhyUshort(sc, 0x06, 0x07ee);
12848                 MP_WritePhyUshort(sc, 0x06, 0x860a);
12849                 MP_WritePhyUshort(sc, 0x06, 0x03af);
12850                 MP_WritePhyUshort(sc, 0x06, 0x8369);
12851                 MP_WritePhyUshort(sc, 0x06, 0x0224);
12852                 MP_WritePhyUshort(sc, 0x06, 0x8e02);
12853                 MP_WritePhyUshort(sc, 0x06, 0x2426);
12854                 MP_WritePhyUshort(sc, 0x06, 0xae48);
12855                 MP_WritePhyUshort(sc, 0x06, 0xa003);
12856                 MP_WritePhyUshort(sc, 0x06, 0x21e0);
12857                 MP_WritePhyUshort(sc, 0x06, 0x8608);
12858                 MP_WritePhyUshort(sc, 0x06, 0xe186);
12859                 MP_WritePhyUshort(sc, 0x06, 0x091b);
12860                 MP_WritePhyUshort(sc, 0x06, 0x019e);
12861                 MP_WritePhyUshort(sc, 0x06, 0x0caa);
12862                 MP_WritePhyUshort(sc, 0x06, 0x0502);
12863                 MP_WritePhyUshort(sc, 0x06, 0x249d);
12864                 MP_WritePhyUshort(sc, 0x06, 0xaee7);
12865                 MP_WritePhyUshort(sc, 0x06, 0x0224);
12866                 MP_WritePhyUshort(sc, 0x06, 0x8eae);
12867                 MP_WritePhyUshort(sc, 0x06, 0xe2ee);
12868                 MP_WritePhyUshort(sc, 0x06, 0x860a);
12869                 MP_WritePhyUshort(sc, 0x06, 0x04ee);
12870                 MP_WritePhyUshort(sc, 0x06, 0x860b);
12871                 MP_WritePhyUshort(sc, 0x06, 0x00af);
12872                 MP_WritePhyUshort(sc, 0x06, 0x8369);
12873                 MP_WritePhyUshort(sc, 0x06, 0xa004);
12874                 MP_WritePhyUshort(sc, 0x06, 0x15e0);
12875                 MP_WritePhyUshort(sc, 0x06, 0x860b);
12876                 MP_WritePhyUshort(sc, 0x06, 0xe18b);
12877                 MP_WritePhyUshort(sc, 0x06, 0x341b);
12878                 MP_WritePhyUshort(sc, 0x06, 0x109e);
12879                 MP_WritePhyUshort(sc, 0x06, 0x05aa);
12880                 MP_WritePhyUshort(sc, 0x06, 0x03af);
12881                 MP_WritePhyUshort(sc, 0x06, 0x8383);
12882                 MP_WritePhyUshort(sc, 0x06, 0xee86);
12883                 MP_WritePhyUshort(sc, 0x06, 0x0a05);
12884                 MP_WritePhyUshort(sc, 0x06, 0xae0c);
12885                 MP_WritePhyUshort(sc, 0x06, 0xa005);
12886                 MP_WritePhyUshort(sc, 0x06, 0x02ae);
12887                 MP_WritePhyUshort(sc, 0x06, 0x0702);
12888                 MP_WritePhyUshort(sc, 0x06, 0x2309);
12889                 MP_WritePhyUshort(sc, 0x06, 0xee86);
12890                 MP_WritePhyUshort(sc, 0x06, 0x0a00);
12891                 MP_WritePhyUshort(sc, 0x06, 0xfeef);
12892                 MP_WritePhyUshort(sc, 0x06, 0x96fe);
12893                 MP_WritePhyUshort(sc, 0x06, 0xfdfc);
12894                 MP_WritePhyUshort(sc, 0x06, 0x04f8);
12895                 MP_WritePhyUshort(sc, 0x06, 0xf9fa);
12896                 MP_WritePhyUshort(sc, 0x06, 0xef69);
12897                 MP_WritePhyUshort(sc, 0x06, 0xfbe0);
12898                 MP_WritePhyUshort(sc, 0x06, 0x8b85);
12899                 MP_WritePhyUshort(sc, 0x06, 0xad25);
12900                 MP_WritePhyUshort(sc, 0x06, 0x22e0);
12901                 MP_WritePhyUshort(sc, 0x06, 0xe022);
12902                 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
12903                 MP_WritePhyUshort(sc, 0x06, 0x23e2);
12904                 MP_WritePhyUshort(sc, 0x06, 0xe036);
12905                 MP_WritePhyUshort(sc, 0x06, 0xe3e0);
12906                 MP_WritePhyUshort(sc, 0x06, 0x375a);
12907                 MP_WritePhyUshort(sc, 0x06, 0xc40d);
12908                 MP_WritePhyUshort(sc, 0x06, 0x0158);
12909                 MP_WritePhyUshort(sc, 0x06, 0x021e);
12910                 MP_WritePhyUshort(sc, 0x06, 0x20e3);
12911                 MP_WritePhyUshort(sc, 0x06, 0x8ae7);
12912                 MP_WritePhyUshort(sc, 0x06, 0xac31);
12913                 MP_WritePhyUshort(sc, 0x06, 0x60ac);
12914                 MP_WritePhyUshort(sc, 0x06, 0x3a08);
12915                 MP_WritePhyUshort(sc, 0x06, 0xac3e);
12916                 MP_WritePhyUshort(sc, 0x06, 0x26ae);
12917                 MP_WritePhyUshort(sc, 0x06, 0x67af);
12918                 MP_WritePhyUshort(sc, 0x06, 0x84db);
12919                 MP_WritePhyUshort(sc, 0x06, 0xad37);
12920                 MP_WritePhyUshort(sc, 0x06, 0x61e0);
12921                 MP_WritePhyUshort(sc, 0x06, 0x8ae8);
12922                 MP_WritePhyUshort(sc, 0x06, 0x10e4);
12923                 MP_WritePhyUshort(sc, 0x06, 0x8ae8);
12924                 MP_WritePhyUshort(sc, 0x06, 0xe18a);
12925                 MP_WritePhyUshort(sc, 0x06, 0xe91b);
12926                 MP_WritePhyUshort(sc, 0x06, 0x109e);
12927                 MP_WritePhyUshort(sc, 0x06, 0x02ae);
12928                 MP_WritePhyUshort(sc, 0x06, 0x51d1);
12929                 MP_WritePhyUshort(sc, 0x06, 0x00bf);
12930                 MP_WritePhyUshort(sc, 0x06, 0x863b);
12931                 MP_WritePhyUshort(sc, 0x06, 0x022f);
12932                 MP_WritePhyUshort(sc, 0x06, 0x50ee);
12933                 MP_WritePhyUshort(sc, 0x06, 0x8ae8);
12934                 MP_WritePhyUshort(sc, 0x06, 0x00ae);
12935                 MP_WritePhyUshort(sc, 0x06, 0x43ad);
12936                 MP_WritePhyUshort(sc, 0x06, 0x3627);
12937                 MP_WritePhyUshort(sc, 0x06, 0xe08a);
12938                 MP_WritePhyUshort(sc, 0x06, 0xeee1);
12939                 MP_WritePhyUshort(sc, 0x06, 0x8aef);
12940                 MP_WritePhyUshort(sc, 0x06, 0xef74);
12941                 MP_WritePhyUshort(sc, 0x06, 0xe08a);
12942                 MP_WritePhyUshort(sc, 0x06, 0xeae1);
12943                 MP_WritePhyUshort(sc, 0x06, 0x8aeb);
12944                 MP_WritePhyUshort(sc, 0x06, 0x1b74);
12945                 MP_WritePhyUshort(sc, 0x06, 0x9e2e);
12946                 MP_WritePhyUshort(sc, 0x06, 0x14e4);
12947                 MP_WritePhyUshort(sc, 0x06, 0x8aea);
12948                 MP_WritePhyUshort(sc, 0x06, 0xe58a);
12949                 MP_WritePhyUshort(sc, 0x06, 0xebef);
12950                 MP_WritePhyUshort(sc, 0x06, 0x74e0);
12951                 MP_WritePhyUshort(sc, 0x06, 0x8aee);
12952                 MP_WritePhyUshort(sc, 0x06, 0xe18a);
12953                 MP_WritePhyUshort(sc, 0x06, 0xef1b);
12954                 MP_WritePhyUshort(sc, 0x06, 0x479e);
12955                 MP_WritePhyUshort(sc, 0x06, 0x0fae);
12956                 MP_WritePhyUshort(sc, 0x06, 0x19ee);
12957                 MP_WritePhyUshort(sc, 0x06, 0x8aea);
12958                 MP_WritePhyUshort(sc, 0x06, 0x00ee);
12959                 MP_WritePhyUshort(sc, 0x06, 0x8aeb);
12960                 MP_WritePhyUshort(sc, 0x06, 0x00ae);
12961                 MP_WritePhyUshort(sc, 0x06, 0x0fac);
12962                 MP_WritePhyUshort(sc, 0x06, 0x390c);
12963                 MP_WritePhyUshort(sc, 0x06, 0xd101);
12964                 MP_WritePhyUshort(sc, 0x06, 0xbf86);
12965                 MP_WritePhyUshort(sc, 0x06, 0x3b02);
12966                 MP_WritePhyUshort(sc, 0x06, 0x2f50);
12967                 MP_WritePhyUshort(sc, 0x06, 0xee8a);
12968                 MP_WritePhyUshort(sc, 0x06, 0xe800);
12969                 MP_WritePhyUshort(sc, 0x06, 0xe68a);
12970                 MP_WritePhyUshort(sc, 0x06, 0xe7ff);
12971                 MP_WritePhyUshort(sc, 0x06, 0xef96);
12972                 MP_WritePhyUshort(sc, 0x06, 0xfefd);
12973                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
12974                 MP_WritePhyUshort(sc, 0x06, 0xf8f9);
12975                 MP_WritePhyUshort(sc, 0x06, 0xfaef);
12976                 MP_WritePhyUshort(sc, 0x06, 0x69e0);
12977                 MP_WritePhyUshort(sc, 0x06, 0xe022);
12978                 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
12979                 MP_WritePhyUshort(sc, 0x06, 0x2358);
12980                 MP_WritePhyUshort(sc, 0x06, 0xc4e1);
12981                 MP_WritePhyUshort(sc, 0x06, 0x8b6e);
12982                 MP_WritePhyUshort(sc, 0x06, 0x1f10);
12983                 MP_WritePhyUshort(sc, 0x06, 0x9e24);
12984                 MP_WritePhyUshort(sc, 0x06, 0xe48b);
12985                 MP_WritePhyUshort(sc, 0x06, 0x6ead);
12986                 MP_WritePhyUshort(sc, 0x06, 0x2218);
12987                 MP_WritePhyUshort(sc, 0x06, 0xac27);
12988                 MP_WritePhyUshort(sc, 0x06, 0x0dac);
12989                 MP_WritePhyUshort(sc, 0x06, 0x2605);
12990                 MP_WritePhyUshort(sc, 0x06, 0x0203);
12991                 MP_WritePhyUshort(sc, 0x06, 0x8fae);
12992                 MP_WritePhyUshort(sc, 0x06, 0x1302);
12993                 MP_WritePhyUshort(sc, 0x06, 0x03c8);
12994                 MP_WritePhyUshort(sc, 0x06, 0xae0e);
12995                 MP_WritePhyUshort(sc, 0x06, 0x0203);
12996                 MP_WritePhyUshort(sc, 0x06, 0xe102);
12997                 MP_WritePhyUshort(sc, 0x06, 0x8520);
12998                 MP_WritePhyUshort(sc, 0x06, 0xae06);
12999                 MP_WritePhyUshort(sc, 0x06, 0x0203);
13000                 MP_WritePhyUshort(sc, 0x06, 0x8f02);
13001                 MP_WritePhyUshort(sc, 0x06, 0x8566);
13002                 MP_WritePhyUshort(sc, 0x06, 0xef96);
13003                 MP_WritePhyUshort(sc, 0x06, 0xfefd);
13004                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
13005                 MP_WritePhyUshort(sc, 0x06, 0xf8fa);
13006                 MP_WritePhyUshort(sc, 0x06, 0xef69);
13007                 MP_WritePhyUshort(sc, 0x06, 0xe08b);
13008                 MP_WritePhyUshort(sc, 0x06, 0x82ad);
13009                 MP_WritePhyUshort(sc, 0x06, 0x2737);
13010                 MP_WritePhyUshort(sc, 0x06, 0xbf86);
13011                 MP_WritePhyUshort(sc, 0x06, 0x4402);
13012                 MP_WritePhyUshort(sc, 0x06, 0x2f23);
13013                 MP_WritePhyUshort(sc, 0x06, 0xac28);
13014                 MP_WritePhyUshort(sc, 0x06, 0x2ed1);
13015                 MP_WritePhyUshort(sc, 0x06, 0x01bf);
13016                 MP_WritePhyUshort(sc, 0x06, 0x8647);
13017                 MP_WritePhyUshort(sc, 0x06, 0x022f);
13018                 MP_WritePhyUshort(sc, 0x06, 0x50bf);
13019                 MP_WritePhyUshort(sc, 0x06, 0x8641);
13020                 MP_WritePhyUshort(sc, 0x06, 0x022f);
13021                 MP_WritePhyUshort(sc, 0x06, 0x23e5);
13022                 MP_WritePhyUshort(sc, 0x06, 0x8af0);
13023                 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
13024                 MP_WritePhyUshort(sc, 0x06, 0x22e1);
13025                 MP_WritePhyUshort(sc, 0x06, 0xe023);
13026                 MP_WritePhyUshort(sc, 0x06, 0xac2e);
13027                 MP_WritePhyUshort(sc, 0x06, 0x04d1);
13028                 MP_WritePhyUshort(sc, 0x06, 0x01ae);
13029                 MP_WritePhyUshort(sc, 0x06, 0x02d1);
13030                 MP_WritePhyUshort(sc, 0x06, 0x00bf);
13031                 MP_WritePhyUshort(sc, 0x06, 0x8641);
13032                 MP_WritePhyUshort(sc, 0x06, 0x022f);
13033                 MP_WritePhyUshort(sc, 0x06, 0x50d1);
13034                 MP_WritePhyUshort(sc, 0x06, 0x01bf);
13035                 MP_WritePhyUshort(sc, 0x06, 0x8644);
13036                 MP_WritePhyUshort(sc, 0x06, 0x022f);
13037                 MP_WritePhyUshort(sc, 0x06, 0x50ef);
13038                 MP_WritePhyUshort(sc, 0x06, 0x96fe);
13039                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
13040                 MP_WritePhyUshort(sc, 0x06, 0xf8fa);
13041                 MP_WritePhyUshort(sc, 0x06, 0xef69);
13042                 MP_WritePhyUshort(sc, 0x06, 0xbf86);
13043                 MP_WritePhyUshort(sc, 0x06, 0x4702);
13044                 MP_WritePhyUshort(sc, 0x06, 0x2f23);
13045                 MP_WritePhyUshort(sc, 0x06, 0xad28);
13046                 MP_WritePhyUshort(sc, 0x06, 0x19d1);
13047                 MP_WritePhyUshort(sc, 0x06, 0x00bf);
13048                 MP_WritePhyUshort(sc, 0x06, 0x8644);
13049                 MP_WritePhyUshort(sc, 0x06, 0x022f);
13050                 MP_WritePhyUshort(sc, 0x06, 0x50e1);
13051                 MP_WritePhyUshort(sc, 0x06, 0x8af0);
13052                 MP_WritePhyUshort(sc, 0x06, 0xbf86);
13053                 MP_WritePhyUshort(sc, 0x06, 0x4102);
13054                 MP_WritePhyUshort(sc, 0x06, 0x2f50);
13055                 MP_WritePhyUshort(sc, 0x06, 0xd100);
13056                 MP_WritePhyUshort(sc, 0x06, 0xbf86);
13057                 MP_WritePhyUshort(sc, 0x06, 0x4702);
13058                 MP_WritePhyUshort(sc, 0x06, 0x2f50);
13059                 MP_WritePhyUshort(sc, 0x06, 0xef96);
13060                 MP_WritePhyUshort(sc, 0x06, 0xfefc);
13061                 MP_WritePhyUshort(sc, 0x06, 0x04f8);
13062                 MP_WritePhyUshort(sc, 0x06, 0xe0e2);
13063                 MP_WritePhyUshort(sc, 0x06, 0xfee1);
13064                 MP_WritePhyUshort(sc, 0x06, 0xe2ff);
13065                 MP_WritePhyUshort(sc, 0x06, 0xad2e);
13066                 MP_WritePhyUshort(sc, 0x06, 0x63e0);
13067                 MP_WritePhyUshort(sc, 0x06, 0xe038);
13068                 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
13069                 MP_WritePhyUshort(sc, 0x06, 0x39ad);
13070                 MP_WritePhyUshort(sc, 0x06, 0x2f10);
13071                 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
13072                 MP_WritePhyUshort(sc, 0x06, 0x34e1);
13073                 MP_WritePhyUshort(sc, 0x06, 0xe035);
13074                 MP_WritePhyUshort(sc, 0x06, 0xf726);
13075                 MP_WritePhyUshort(sc, 0x06, 0xe4e0);
13076                 MP_WritePhyUshort(sc, 0x06, 0x34e5);
13077                 MP_WritePhyUshort(sc, 0x06, 0xe035);
13078                 MP_WritePhyUshort(sc, 0x06, 0xae0e);
13079                 MP_WritePhyUshort(sc, 0x06, 0xe0e2);
13080                 MP_WritePhyUshort(sc, 0x06, 0xd6e1);
13081                 MP_WritePhyUshort(sc, 0x06, 0xe2d7);
13082                 MP_WritePhyUshort(sc, 0x06, 0xf728);
13083                 MP_WritePhyUshort(sc, 0x06, 0xe4e2);
13084                 MP_WritePhyUshort(sc, 0x06, 0xd6e5);
13085                 MP_WritePhyUshort(sc, 0x06, 0xe2d7);
13086                 MP_WritePhyUshort(sc, 0x06, 0xe0e2);
13087                 MP_WritePhyUshort(sc, 0x06, 0x34e1);
13088                 MP_WritePhyUshort(sc, 0x06, 0xe235);
13089                 MP_WritePhyUshort(sc, 0x06, 0xf72b);
13090                 MP_WritePhyUshort(sc, 0x06, 0xe4e2);
13091                 MP_WritePhyUshort(sc, 0x06, 0x34e5);
13092                 MP_WritePhyUshort(sc, 0x06, 0xe235);
13093                 MP_WritePhyUshort(sc, 0x06, 0xd07d);
13094                 MP_WritePhyUshort(sc, 0x06, 0xb0fe);
13095                 MP_WritePhyUshort(sc, 0x06, 0xe0e2);
13096                 MP_WritePhyUshort(sc, 0x06, 0x34e1);
13097                 MP_WritePhyUshort(sc, 0x06, 0xe235);
13098                 MP_WritePhyUshort(sc, 0x06, 0xf62b);
13099                 MP_WritePhyUshort(sc, 0x06, 0xe4e2);
13100                 MP_WritePhyUshort(sc, 0x06, 0x34e5);
13101                 MP_WritePhyUshort(sc, 0x06, 0xe235);
13102                 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
13103                 MP_WritePhyUshort(sc, 0x06, 0x34e1);
13104                 MP_WritePhyUshort(sc, 0x06, 0xe035);
13105                 MP_WritePhyUshort(sc, 0x06, 0xf626);
13106                 MP_WritePhyUshort(sc, 0x06, 0xe4e0);
13107                 MP_WritePhyUshort(sc, 0x06, 0x34e5);
13108                 MP_WritePhyUshort(sc, 0x06, 0xe035);
13109                 MP_WritePhyUshort(sc, 0x06, 0xe0e2);
13110                 MP_WritePhyUshort(sc, 0x06, 0xd6e1);
13111                 MP_WritePhyUshort(sc, 0x06, 0xe2d7);
13112                 MP_WritePhyUshort(sc, 0x06, 0xf628);
13113                 MP_WritePhyUshort(sc, 0x06, 0xe4e2);
13114                 MP_WritePhyUshort(sc, 0x06, 0xd6e5);
13115                 MP_WritePhyUshort(sc, 0x06, 0xe2d7);
13116                 MP_WritePhyUshort(sc, 0x06, 0xfc04);
13117                 MP_WritePhyUshort(sc, 0x06, 0xae20);
13118                 MP_WritePhyUshort(sc, 0x06, 0x0000);
13119                 MP_WritePhyUshort(sc, 0x06, 0x0000);
13120                 MP_WritePhyUshort(sc, 0x06, 0x0000);
13121                 MP_WritePhyUshort(sc, 0x06, 0x0000);
13122                 MP_WritePhyUshort(sc, 0x06, 0x0000);
13123                 MP_WritePhyUshort(sc, 0x06, 0x0000);
13124                 MP_WritePhyUshort(sc, 0x06, 0x0000);
13125                 MP_WritePhyUshort(sc, 0x06, 0x0000);
13126                 MP_WritePhyUshort(sc, 0x06, 0x0000);
13127                 MP_WritePhyUshort(sc, 0x06, 0x0000);
13128                 MP_WritePhyUshort(sc, 0x06, 0x0000);
13129                 MP_WritePhyUshort(sc, 0x06, 0x0000);
13130                 MP_WritePhyUshort(sc, 0x06, 0x0000);
13131                 MP_WritePhyUshort(sc, 0x06, 0x0000);
13132                 MP_WritePhyUshort(sc, 0x06, 0x0000);
13133                 MP_WritePhyUshort(sc, 0x06, 0x0000);
13134                 MP_WritePhyUshort(sc, 0x06, 0xa725);
13135                 MP_WritePhyUshort(sc, 0x06, 0xe50a);
13136                 MP_WritePhyUshort(sc, 0x06, 0x1de5);
13137                 MP_WritePhyUshort(sc, 0x06, 0x0a2c);
13138                 MP_WritePhyUshort(sc, 0x06, 0xe50a);
13139                 MP_WritePhyUshort(sc, 0x06, 0x6de5);
13140                 MP_WritePhyUshort(sc, 0x06, 0x0a1d);
13141                 MP_WritePhyUshort(sc, 0x06, 0xe50a);
13142                 MP_WritePhyUshort(sc, 0x06, 0x1ce5);
13143                 MP_WritePhyUshort(sc, 0x06, 0x0a2d);
13144                 MP_WritePhyUshort(sc, 0x06, 0xa755);
13145                 MP_WritePhyUshort(sc, 0x06, 0x00e2);
13146                 MP_WritePhyUshort(sc, 0x06, 0x3488);
13147                 MP_WritePhyUshort(sc, 0x06, 0xe200);
13148                 MP_WritePhyUshort(sc, 0x06, 0xcce2);
13149                 MP_WritePhyUshort(sc, 0x06, 0x0055);
13150                 MP_WritePhyUshort(sc, 0x06, 0xe020);
13151                 MP_WritePhyUshort(sc, 0x06, 0x55e2);
13152                 MP_WritePhyUshort(sc, 0x06, 0xd600);
13153                 MP_WritePhyUshort(sc, 0x06, 0xe24a);
13154                 PhyRegValue = MP_ReadPhyUshort(sc, 0x01);
13155                 PhyRegValue |= BIT_0;
13156                 MP_WritePhyUshort(sc, 0x01, PhyRegValue);
13157                 PhyRegValue = MP_ReadPhyUshort(sc, 0x00);
13158                 PhyRegValue |= BIT_0;
13159                 MP_WritePhyUshort(sc, 0x00, PhyRegValue);
13160                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
13161
13162                 MP_WritePhyUshort(sc, 0x1f, 0x0005);
13163                 for (i = 0; i < 200; i++) {
13164                         DELAY(100);
13165                         PhyRegValue = MP_ReadPhyUshort(sc, 0x00);
13166                         if (PhyRegValue & BIT_7)
13167                                 break;
13168                 }
13169                 MP_WritePhyUshort(sc, 0x1f, 0x0007);
13170                 MP_WritePhyUshort(sc, 0x1e, 0x0023);
13171                 PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
13172                 PhyRegValue &= ~(BIT_0);
13173                 if (sc->RequiredSecLanDonglePatch)
13174                         PhyRegValue &= ~(BIT_2);
13175                 MP_WritePhyUshort(sc, 0x17, PhyRegValue);
13176                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
13177         }
13178 }
13179
13180 static void re_set_phy_mcu_8168evl_1(struct re_softc *sc)
13181 {
13182         u_int16_t PhyRegValue;
13183         int i;
13184
13185         MP_WritePhyUshort(sc, 0x1f, 0x0000);
13186         MP_WritePhyUshort(sc, 0x00, 0x1800);
13187         PhyRegValue= MP_ReadPhyUshort(sc, 0x15);
13188         PhyRegValue &= ~BIT_12;
13189         MP_WritePhyUshort(sc, 0x15, PhyRegValue);
13190         DELAY(200);
13191         DELAY(200);
13192         MP_WritePhyUshort(sc, 0x1f, 0x0004);
13193         MP_WritePhyUshort(sc, 0x1f, 0x0007);
13194         MP_WritePhyUshort(sc, 0x1e, 0x0023);
13195         PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
13196         if ((PhyRegValue & BIT_11) == 0x0000) {
13197                 PhyRegValue |= BIT_0;
13198                 MP_WritePhyUshort(sc, 0x17, PhyRegValue);
13199                 for (i = 0; i < 200; i++) {
13200                         DELAY(100);
13201                         PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
13202                         if (PhyRegValue & BIT_11)
13203                                 break;
13204                 }
13205         }
13206         PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
13207         PhyRegValue |= BIT_11;
13208         MP_WritePhyUshort(sc, 0x17,PhyRegValue);
13209         MP_WritePhyUshort(sc, 0x1f, 0x0004);
13210         MP_WritePhyUshort(sc, 0x1f, 0x0007);
13211         MP_WritePhyUshort(sc, 0x1E, 0x002C);
13212         MP_WritePhyUshort(sc, 0x1B, 0x5000);
13213         MP_WritePhyUshort(sc, 0x1E, 0x002d);
13214         MP_WritePhyUshort(sc, 0x19, 0x0004);
13215         MP_WritePhyUshort(sc, 0x1f, 0x0002);
13216         MP_WritePhyUshort(sc, 0x1f, 0x0000);
13217         for (i = 0; i < 200; i++) {
13218                 DELAY(100);
13219                 PhyRegValue= MP_ReadPhyUshort(sc, 0x1E);
13220                 if ((PhyRegValue& 0x03FF) == 0x0014)
13221                         break;
13222         }
13223         MP_WritePhyUshort(sc, 0x1f, 0x0005);
13224         for (i = 0; i < 200; i++) {
13225                 DELAY(100);
13226                 PhyRegValue= MP_ReadPhyUshort(sc, 0x07);
13227                 if ((PhyRegValue& BIT_5) == 0)
13228                         break;
13229         }
13230         PhyRegValue = MP_ReadPhyUshort(sc, 0x07);
13231         if (PhyRegValue & BIT_5) {
13232                 MP_WritePhyUshort(sc, 0x1f, 0x0004);
13233                 MP_WritePhyUshort(sc, 0x1f, 0x0007);
13234                 MP_WritePhyUshort(sc, 0x1e, 0x00a1);
13235                 MP_WritePhyUshort(sc, 0x17, 0x1000);
13236                 MP_WritePhyUshort(sc, 0x17, 0x0000);
13237                 MP_WritePhyUshort(sc, 0x17, 0x2000);
13238                 MP_WritePhyUshort(sc, 0x1e, 0x002f);
13239                 MP_WritePhyUshort(sc, 0x18, 0x9bfb);
13240                 MP_WritePhyUshort(sc, 0x1f, 0x0005);
13241                 MP_WritePhyUshort(sc, 0x07, 0x0000);
13242                 MP_WritePhyUshort(sc, 0x1f, 0x0002);
13243                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
13244         }
13245         MP_WritePhyUshort(sc, 0x1f, 0x0005);
13246         MP_WritePhyUshort(sc, 0x05, 0xfff6);
13247         MP_WritePhyUshort(sc, 0x06, 0x0080);
13248         PhyRegValue = MP_ReadPhyUshort(sc, 0x00);
13249         PhyRegValue &= ~BIT_7;
13250         MP_WritePhyUshort(sc, 0x00, PhyRegValue);
13251         MP_WritePhyUshort(sc, 0x1f, 0x0004);
13252         MP_WritePhyUshort(sc, 0x1f, 0x0007);
13253         MP_WritePhyUshort(sc, 0x1e, 0x0023);
13254         MP_WritePhyUshort(sc, 0x16, 0x0306);
13255         MP_WritePhyUshort(sc, 0x16, 0x0307);
13256         MP_WritePhyUshort(sc, 0x15, 0x0000);
13257         MP_WritePhyUshort(sc, 0x19, 0x407d);
13258         MP_WritePhyUshort(sc, 0x15, 0x0001);
13259         MP_WritePhyUshort(sc, 0x19, 0x440f);
13260         MP_WritePhyUshort(sc, 0x15, 0x0002);
13261         MP_WritePhyUshort(sc, 0x19, 0x7c03);
13262         MP_WritePhyUshort(sc, 0x15, 0x0003);
13263         MP_WritePhyUshort(sc, 0x19, 0x6c03);
13264         MP_WritePhyUshort(sc, 0x15, 0x0004);
13265         MP_WritePhyUshort(sc, 0x19, 0xc4d5);
13266         MP_WritePhyUshort(sc, 0x15, 0x0005);
13267         MP_WritePhyUshort(sc, 0x19, 0x00ff);
13268         MP_WritePhyUshort(sc, 0x15, 0x0006);
13269         MP_WritePhyUshort(sc, 0x19, 0x74f0);
13270         MP_WritePhyUshort(sc, 0x15, 0x0007);
13271         MP_WritePhyUshort(sc, 0x19, 0x4880);
13272         MP_WritePhyUshort(sc, 0x15, 0x0008);
13273         MP_WritePhyUshort(sc, 0x19, 0x4c00);
13274         MP_WritePhyUshort(sc, 0x15, 0x0009);
13275         MP_WritePhyUshort(sc, 0x19, 0x4800);
13276         MP_WritePhyUshort(sc, 0x15, 0x000a);
13277         MP_WritePhyUshort(sc, 0x19, 0x5000);
13278         MP_WritePhyUshort(sc, 0x15, 0x000b);
13279         MP_WritePhyUshort(sc, 0x19, 0x4400);
13280         MP_WritePhyUshort(sc, 0x15, 0x000c);
13281         MP_WritePhyUshort(sc, 0x19, 0x7801);
13282         MP_WritePhyUshort(sc, 0x15, 0x000d);
13283         MP_WritePhyUshort(sc, 0x19, 0x4000);
13284         MP_WritePhyUshort(sc, 0x15, 0x000e);
13285         MP_WritePhyUshort(sc, 0x19, 0x7800);
13286         MP_WritePhyUshort(sc, 0x15, 0x000f);
13287         MP_WritePhyUshort(sc, 0x19, 0x7010);
13288         MP_WritePhyUshort(sc, 0x15, 0x0010);
13289         MP_WritePhyUshort(sc, 0x19, 0x6804);
13290         MP_WritePhyUshort(sc, 0x15, 0x0011);
13291         MP_WritePhyUshort(sc, 0x19, 0x64a0);
13292         MP_WritePhyUshort(sc, 0x15, 0x0012);
13293         MP_WritePhyUshort(sc, 0x19, 0x63da);
13294         MP_WritePhyUshort(sc, 0x15, 0x0013);
13295         MP_WritePhyUshort(sc, 0x19, 0x63d8);
13296         MP_WritePhyUshort(sc, 0x15, 0x0014);
13297         MP_WritePhyUshort(sc, 0x19, 0x6f05);
13298         MP_WritePhyUshort(sc, 0x15, 0x0015);
13299         MP_WritePhyUshort(sc, 0x19, 0x5420);
13300         MP_WritePhyUshort(sc, 0x15, 0x0016);
13301         MP_WritePhyUshort(sc, 0x19, 0x58ce);
13302         MP_WritePhyUshort(sc, 0x15, 0x0017);
13303         MP_WritePhyUshort(sc, 0x19, 0x5cf3);
13304         MP_WritePhyUshort(sc, 0x15, 0x0018);
13305         MP_WritePhyUshort(sc, 0x19, 0xb600);
13306         MP_WritePhyUshort(sc, 0x15, 0x0019);
13307         MP_WritePhyUshort(sc, 0x19, 0xc659);
13308         MP_WritePhyUshort(sc, 0x15, 0x001a);
13309         MP_WritePhyUshort(sc, 0x19, 0x0018);
13310         MP_WritePhyUshort(sc, 0x15, 0x001b);
13311         MP_WritePhyUshort(sc, 0x19, 0xc403);
13312         MP_WritePhyUshort(sc, 0x15, 0x001c);
13313         MP_WritePhyUshort(sc, 0x19, 0x0016);
13314         MP_WritePhyUshort(sc, 0x15, 0x001d);
13315         MP_WritePhyUshort(sc, 0x19, 0xaa05);
13316         MP_WritePhyUshort(sc, 0x15, 0x001e);
13317         MP_WritePhyUshort(sc, 0x19, 0xc503);
13318         MP_WritePhyUshort(sc, 0x15, 0x001f);
13319         MP_WritePhyUshort(sc, 0x19, 0x0003);
13320         MP_WritePhyUshort(sc, 0x15, 0x0020);
13321         MP_WritePhyUshort(sc, 0x19, 0x89f8);
13322         MP_WritePhyUshort(sc, 0x15, 0x0021);
13323         MP_WritePhyUshort(sc, 0x19, 0x32ae);
13324         MP_WritePhyUshort(sc, 0x15, 0x0022);
13325         MP_WritePhyUshort(sc, 0x19, 0x7c03);
13326         MP_WritePhyUshort(sc, 0x15, 0x0023);
13327         MP_WritePhyUshort(sc, 0x19, 0x6c03);
13328         MP_WritePhyUshort(sc, 0x15, 0x0024);
13329         MP_WritePhyUshort(sc, 0x19, 0x7c03);
13330         MP_WritePhyUshort(sc, 0x15, 0x0025);
13331         MP_WritePhyUshort(sc, 0x19, 0x6801);
13332         MP_WritePhyUshort(sc, 0x15, 0x0026);
13333         MP_WritePhyUshort(sc, 0x19, 0x66a0);
13334         MP_WritePhyUshort(sc, 0x15, 0x0027);
13335         MP_WritePhyUshort(sc, 0x19, 0xa300);
13336         MP_WritePhyUshort(sc, 0x15, 0x0028);
13337         MP_WritePhyUshort(sc, 0x19, 0x64a0);
13338         MP_WritePhyUshort(sc, 0x15, 0x0029);
13339         MP_WritePhyUshort(sc, 0x19, 0x76f0);
13340         MP_WritePhyUshort(sc, 0x15, 0x002a);
13341         MP_WritePhyUshort(sc, 0x19, 0x7670);
13342         MP_WritePhyUshort(sc, 0x15, 0x002b);
13343         MP_WritePhyUshort(sc, 0x19, 0x7630);
13344         MP_WritePhyUshort(sc, 0x15, 0x002c);
13345         MP_WritePhyUshort(sc, 0x19, 0x31a6);
13346         MP_WritePhyUshort(sc, 0x15, 0x002d);
13347         MP_WritePhyUshort(sc, 0x19, 0x0000);
13348         MP_WritePhyUshort(sc, 0x15, 0x002e);
13349         MP_WritePhyUshort(sc, 0x19, 0x0000);
13350         MP_WritePhyUshort(sc, 0x15, 0x002f);
13351         MP_WritePhyUshort(sc, 0x19, 0x0000);
13352         MP_WritePhyUshort(sc, 0x15, 0x0030);
13353         MP_WritePhyUshort(sc, 0x19, 0x0000);
13354         MP_WritePhyUshort(sc, 0x15, 0x0031);
13355         MP_WritePhyUshort(sc, 0x19, 0x0000);
13356         MP_WritePhyUshort(sc, 0x15, 0x0032);
13357         MP_WritePhyUshort(sc, 0x19, 0x4801);
13358         MP_WritePhyUshort(sc, 0x15, 0x0033);
13359         MP_WritePhyUshort(sc, 0x19, 0x6803);
13360         MP_WritePhyUshort(sc, 0x15, 0x0034);
13361         MP_WritePhyUshort(sc, 0x19, 0x66a1);
13362         MP_WritePhyUshort(sc, 0x15, 0x0035);
13363         MP_WritePhyUshort(sc, 0x19, 0x7c03);
13364         MP_WritePhyUshort(sc, 0x15, 0x0036);
13365         MP_WritePhyUshort(sc, 0x19, 0x6c03);
13366         MP_WritePhyUshort(sc, 0x15, 0x0037);
13367         MP_WritePhyUshort(sc, 0x19, 0xa300);
13368         MP_WritePhyUshort(sc, 0x15, 0x0038);
13369         MP_WritePhyUshort(sc, 0x19, 0x64a1);
13370         MP_WritePhyUshort(sc, 0x15, 0x0039);
13371         MP_WritePhyUshort(sc, 0x19, 0x7c08);
13372         MP_WritePhyUshort(sc, 0x15, 0x003a);
13373         MP_WritePhyUshort(sc, 0x19, 0x74f8);
13374         MP_WritePhyUshort(sc, 0x15, 0x003b);
13375         MP_WritePhyUshort(sc, 0x19, 0x63d0);
13376         MP_WritePhyUshort(sc, 0x15, 0x003c);
13377         MP_WritePhyUshort(sc, 0x19, 0x7ff0);
13378         MP_WritePhyUshort(sc, 0x15, 0x003d);
13379         MP_WritePhyUshort(sc, 0x19, 0x77f0);
13380         MP_WritePhyUshort(sc, 0x15, 0x003e);
13381         MP_WritePhyUshort(sc, 0x19, 0x7ff0);
13382         MP_WritePhyUshort(sc, 0x15, 0x003f);
13383         MP_WritePhyUshort(sc, 0x19, 0x7750);
13384         MP_WritePhyUshort(sc, 0x15, 0x0040);
13385         MP_WritePhyUshort(sc, 0x19, 0x63d8);
13386         MP_WritePhyUshort(sc, 0x15, 0x0041);
13387         MP_WritePhyUshort(sc, 0x19, 0x7cf0);
13388         MP_WritePhyUshort(sc, 0x15, 0x0042);
13389         MP_WritePhyUshort(sc, 0x19, 0x7708);
13390         MP_WritePhyUshort(sc, 0x15, 0x0043);
13391         MP_WritePhyUshort(sc, 0x19, 0xa654);
13392         MP_WritePhyUshort(sc, 0x15, 0x0044);
13393         MP_WritePhyUshort(sc, 0x19, 0x304a);
13394         MP_WritePhyUshort(sc, 0x15, 0x0045);
13395         MP_WritePhyUshort(sc, 0x19, 0x0000);
13396         MP_WritePhyUshort(sc, 0x15, 0x0046);
13397         MP_WritePhyUshort(sc, 0x19, 0x0000);
13398         MP_WritePhyUshort(sc, 0x15, 0x0047);
13399         MP_WritePhyUshort(sc, 0x19, 0x0000);
13400         MP_WritePhyUshort(sc, 0x15, 0x0048);
13401         MP_WritePhyUshort(sc, 0x19, 0x0000);
13402         MP_WritePhyUshort(sc, 0x15, 0x0049);
13403         MP_WritePhyUshort(sc, 0x19, 0x0000);
13404         MP_WritePhyUshort(sc, 0x15, 0x004a);
13405         MP_WritePhyUshort(sc, 0x19, 0x4802);
13406         MP_WritePhyUshort(sc, 0x15, 0x004b);
13407         MP_WritePhyUshort(sc, 0x19, 0x4003);
13408         MP_WritePhyUshort(sc, 0x15, 0x004c);
13409         MP_WritePhyUshort(sc, 0x19, 0x4440);
13410         MP_WritePhyUshort(sc, 0x15, 0x004d);
13411         MP_WritePhyUshort(sc, 0x19, 0x63c8);
13412         MP_WritePhyUshort(sc, 0x15, 0x004e);
13413         MP_WritePhyUshort(sc, 0x19, 0x6481);
13414         MP_WritePhyUshort(sc, 0x15, 0x004f);
13415         MP_WritePhyUshort(sc, 0x19, 0x9d00);
13416         MP_WritePhyUshort(sc, 0x15, 0x0050);
13417         MP_WritePhyUshort(sc, 0x19, 0x63e8);
13418         MP_WritePhyUshort(sc, 0x15, 0x0051);
13419         MP_WritePhyUshort(sc, 0x19, 0x7d00);
13420         MP_WritePhyUshort(sc, 0x15, 0x0052);
13421         MP_WritePhyUshort(sc, 0x19, 0x5900);
13422         MP_WritePhyUshort(sc, 0x15, 0x0053);
13423         MP_WritePhyUshort(sc, 0x19, 0x63f8);
13424         MP_WritePhyUshort(sc, 0x15, 0x0054);
13425         MP_WritePhyUshort(sc, 0x19, 0x64a1);
13426         MP_WritePhyUshort(sc, 0x15, 0x0055);
13427         MP_WritePhyUshort(sc, 0x19, 0x3116);
13428         MP_WritePhyUshort(sc, 0x15, 0x0056);
13429         MP_WritePhyUshort(sc, 0x19, 0x0000);
13430         MP_WritePhyUshort(sc, 0x15, 0x0057);
13431         MP_WritePhyUshort(sc, 0x19, 0x0000);
13432         MP_WritePhyUshort(sc, 0x15, 0x0058);
13433         MP_WritePhyUshort(sc, 0x19, 0x0000);
13434         MP_WritePhyUshort(sc, 0x15, 0x0059);
13435         MP_WritePhyUshort(sc, 0x19, 0x0000);
13436         MP_WritePhyUshort(sc, 0x15, 0x005a);
13437         MP_WritePhyUshort(sc, 0x19, 0x7c03);
13438         MP_WritePhyUshort(sc, 0x15, 0x005b);
13439         MP_WritePhyUshort(sc, 0x19, 0x6c03);
13440         MP_WritePhyUshort(sc, 0x15, 0x005c);
13441         MP_WritePhyUshort(sc, 0x19, 0x7c08);
13442         MP_WritePhyUshort(sc, 0x15, 0x005d);
13443         MP_WritePhyUshort(sc, 0x19, 0x6000);
13444         MP_WritePhyUshort(sc, 0x15, 0x005e);
13445         MP_WritePhyUshort(sc, 0x19, 0x59ce);
13446         MP_WritePhyUshort(sc, 0x15, 0x005f);
13447         MP_WritePhyUshort(sc, 0x19, 0x4400);
13448         MP_WritePhyUshort(sc, 0x15, 0x0060);
13449         MP_WritePhyUshort(sc, 0x19, 0x7d00);
13450         MP_WritePhyUshort(sc, 0x15, 0x0061);
13451         MP_WritePhyUshort(sc, 0x19, 0x72b0);
13452         MP_WritePhyUshort(sc, 0x15, 0x0062);
13453         MP_WritePhyUshort(sc, 0x19, 0x400e);
13454         MP_WritePhyUshort(sc, 0x15, 0x0063);
13455         MP_WritePhyUshort(sc, 0x19, 0x4440);
13456         MP_WritePhyUshort(sc, 0x15, 0x0064);
13457         MP_WritePhyUshort(sc, 0x19, 0x9d00);
13458         MP_WritePhyUshort(sc, 0x15, 0x0065);
13459         MP_WritePhyUshort(sc, 0x19, 0x7f00);
13460         MP_WritePhyUshort(sc, 0x15, 0x0066);
13461         MP_WritePhyUshort(sc, 0x19, 0x70b0);
13462         MP_WritePhyUshort(sc, 0x15, 0x0067);
13463         MP_WritePhyUshort(sc, 0x19, 0x7c08);
13464         MP_WritePhyUshort(sc, 0x15, 0x0068);
13465         MP_WritePhyUshort(sc, 0x19, 0x6008);
13466         MP_WritePhyUshort(sc, 0x15, 0x0069);
13467         MP_WritePhyUshort(sc, 0x19, 0x7cf0);
13468         MP_WritePhyUshort(sc, 0x15, 0x006a);
13469         MP_WritePhyUshort(sc, 0x19, 0x7750);
13470         MP_WritePhyUshort(sc, 0x15, 0x006b);
13471         MP_WritePhyUshort(sc, 0x19, 0x4007);
13472         MP_WritePhyUshort(sc, 0x15, 0x006c);
13473         MP_WritePhyUshort(sc, 0x19, 0x4500);
13474         MP_WritePhyUshort(sc, 0x15, 0x006d);
13475         MP_WritePhyUshort(sc, 0x19, 0x4023);
13476         MP_WritePhyUshort(sc, 0x15, 0x006e);
13477         MP_WritePhyUshort(sc, 0x19, 0x4580);
13478         MP_WritePhyUshort(sc, 0x15, 0x006f);
13479         MP_WritePhyUshort(sc, 0x19, 0x9f00);
13480         MP_WritePhyUshort(sc, 0x15, 0x0070);
13481         MP_WritePhyUshort(sc, 0x19, 0xcd78);
13482         MP_WritePhyUshort(sc, 0x15, 0x0071);
13483         MP_WritePhyUshort(sc, 0x19, 0x0003);
13484         MP_WritePhyUshort(sc, 0x15, 0x0072);
13485         MP_WritePhyUshort(sc, 0x19, 0xbe02);
13486         MP_WritePhyUshort(sc, 0x15, 0x0073);
13487         MP_WritePhyUshort(sc, 0x19, 0x3070);
13488         MP_WritePhyUshort(sc, 0x15, 0x0074);
13489         MP_WritePhyUshort(sc, 0x19, 0x7cf0);
13490         MP_WritePhyUshort(sc, 0x15, 0x0075);
13491         MP_WritePhyUshort(sc, 0x19, 0x77f0);
13492         MP_WritePhyUshort(sc, 0x15, 0x0076);
13493         MP_WritePhyUshort(sc, 0x19, 0x4400);
13494         MP_WritePhyUshort(sc, 0x15, 0x0077);
13495         MP_WritePhyUshort(sc, 0x19, 0x4007);
13496         MP_WritePhyUshort(sc, 0x15, 0x0078);
13497         MP_WritePhyUshort(sc, 0x19, 0x4500);
13498         MP_WritePhyUshort(sc, 0x15, 0x0079);
13499         MP_WritePhyUshort(sc, 0x19, 0x4023);
13500         MP_WritePhyUshort(sc, 0x15, 0x007a);
13501         MP_WritePhyUshort(sc, 0x19, 0x4580);
13502         MP_WritePhyUshort(sc, 0x15, 0x007b);
13503         MP_WritePhyUshort(sc, 0x19, 0x9f00);
13504         MP_WritePhyUshort(sc, 0x15, 0x007c);
13505         MP_WritePhyUshort(sc, 0x19, 0xce80);
13506         MP_WritePhyUshort(sc, 0x15, 0x007d);
13507         MP_WritePhyUshort(sc, 0x19, 0x0004);
13508         MP_WritePhyUshort(sc, 0x15, 0x007e);
13509         MP_WritePhyUshort(sc, 0x19, 0xce80);
13510         MP_WritePhyUshort(sc, 0x15, 0x007f);
13511         MP_WritePhyUshort(sc, 0x19, 0x0002);
13512         MP_WritePhyUshort(sc, 0x15, 0x0080);
13513         MP_WritePhyUshort(sc, 0x19, 0x307c);
13514         MP_WritePhyUshort(sc, 0x15, 0x0081);
13515         MP_WritePhyUshort(sc, 0x19, 0x4400);
13516         MP_WritePhyUshort(sc, 0x15, 0x0082);
13517         MP_WritePhyUshort(sc, 0x19, 0x480f);
13518         MP_WritePhyUshort(sc, 0x15, 0x0083);
13519         MP_WritePhyUshort(sc, 0x19, 0x6802);
13520         MP_WritePhyUshort(sc, 0x15, 0x0084);
13521         MP_WritePhyUshort(sc, 0x19, 0x6680);
13522         MP_WritePhyUshort(sc, 0x15, 0x0085);
13523         MP_WritePhyUshort(sc, 0x19, 0x7c10);
13524         MP_WritePhyUshort(sc, 0x15, 0x0086);
13525         MP_WritePhyUshort(sc, 0x19, 0x6010);
13526         MP_WritePhyUshort(sc, 0x15, 0x0087);
13527         MP_WritePhyUshort(sc, 0x19, 0x400a);
13528         MP_WritePhyUshort(sc, 0x15, 0x0088);
13529         MP_WritePhyUshort(sc, 0x19, 0x4580);
13530         MP_WritePhyUshort(sc, 0x15, 0x0089);
13531         MP_WritePhyUshort(sc, 0x19, 0x9e00);
13532         MP_WritePhyUshort(sc, 0x15, 0x008a);
13533         MP_WritePhyUshort(sc, 0x19, 0x7d00);
13534         MP_WritePhyUshort(sc, 0x15, 0x008b);
13535         MP_WritePhyUshort(sc, 0x19, 0x5800);
13536         MP_WritePhyUshort(sc, 0x15, 0x008c);
13537         MP_WritePhyUshort(sc, 0x19, 0x63c8);
13538         MP_WritePhyUshort(sc, 0x15, 0x008d);
13539         MP_WritePhyUshort(sc, 0x19, 0x63d8);
13540         MP_WritePhyUshort(sc, 0x15, 0x008e);
13541         MP_WritePhyUshort(sc, 0x19, 0x66a0);
13542         MP_WritePhyUshort(sc, 0x15, 0x008f);
13543         MP_WritePhyUshort(sc, 0x19, 0x8300);
13544         MP_WritePhyUshort(sc, 0x15, 0x0090);
13545         MP_WritePhyUshort(sc, 0x19, 0x7ff0);
13546         MP_WritePhyUshort(sc, 0x15, 0x0091);
13547         MP_WritePhyUshort(sc, 0x19, 0x74f0);
13548         MP_WritePhyUshort(sc, 0x15, 0x0092);
13549         MP_WritePhyUshort(sc, 0x19, 0x3006);
13550         MP_WritePhyUshort(sc, 0x15, 0x0093);
13551         MP_WritePhyUshort(sc, 0x19, 0x0000);
13552         MP_WritePhyUshort(sc, 0x15, 0x0094);
13553         MP_WritePhyUshort(sc, 0x19, 0x0000);
13554         MP_WritePhyUshort(sc, 0x15, 0x0095);
13555         MP_WritePhyUshort(sc, 0x19, 0x0000);
13556         MP_WritePhyUshort(sc, 0x15, 0x0096);
13557         MP_WritePhyUshort(sc, 0x19, 0x0000);
13558         MP_WritePhyUshort(sc, 0x15, 0x0097);
13559         MP_WritePhyUshort(sc, 0x19, 0x4803);
13560         MP_WritePhyUshort(sc, 0x15, 0x0098);
13561         MP_WritePhyUshort(sc, 0x19, 0x7c03);
13562         MP_WritePhyUshort(sc, 0x15, 0x0099);
13563         MP_WritePhyUshort(sc, 0x19, 0x6c03);
13564         MP_WritePhyUshort(sc, 0x15, 0x009a);
13565         MP_WritePhyUshort(sc, 0x19, 0xa203);
13566         MP_WritePhyUshort(sc, 0x15, 0x009b);
13567         MP_WritePhyUshort(sc, 0x19, 0x64b1);
13568         MP_WritePhyUshort(sc, 0x15, 0x009c);
13569         MP_WritePhyUshort(sc, 0x19, 0x309e);
13570         MP_WritePhyUshort(sc, 0x15, 0x009d);
13571         MP_WritePhyUshort(sc, 0x19, 0x64b3);
13572         MP_WritePhyUshort(sc, 0x15, 0x009e);
13573         MP_WritePhyUshort(sc, 0x19, 0x4030);
13574         MP_WritePhyUshort(sc, 0x15, 0x009f);
13575         MP_WritePhyUshort(sc, 0x19, 0x440e);
13576         MP_WritePhyUshort(sc, 0x15, 0x00a0);
13577         MP_WritePhyUshort(sc, 0x19, 0x4020);
13578         MP_WritePhyUshort(sc, 0x15, 0x00a1);
13579         MP_WritePhyUshort(sc, 0x19, 0x4419);
13580         MP_WritePhyUshort(sc, 0x15, 0x00a2);
13581         MP_WritePhyUshort(sc, 0x19, 0x7801);
13582         MP_WritePhyUshort(sc, 0x15, 0x00a3);
13583         MP_WritePhyUshort(sc, 0x19, 0xc520);
13584         MP_WritePhyUshort(sc, 0x15, 0x00a4);
13585         MP_WritePhyUshort(sc, 0x19, 0x000b);
13586         MP_WritePhyUshort(sc, 0x15, 0x00a5);
13587         MP_WritePhyUshort(sc, 0x19, 0x4020);
13588         MP_WritePhyUshort(sc, 0x15, 0x00a6);
13589         MP_WritePhyUshort(sc, 0x19, 0x7800);
13590         MP_WritePhyUshort(sc, 0x15, 0x00a7);
13591         MP_WritePhyUshort(sc, 0x19, 0x58a4);
13592         MP_WritePhyUshort(sc, 0x15, 0x00a8);
13593         MP_WritePhyUshort(sc, 0x19, 0x63da);
13594         MP_WritePhyUshort(sc, 0x15, 0x00a9);
13595         MP_WritePhyUshort(sc, 0x19, 0x5cb0);
13596         MP_WritePhyUshort(sc, 0x15, 0x00aa);
13597         MP_WritePhyUshort(sc, 0x19, 0x7d00);
13598         MP_WritePhyUshort(sc, 0x15, 0x00ab);
13599         MP_WritePhyUshort(sc, 0x19, 0x72b0);
13600         MP_WritePhyUshort(sc, 0x15, 0x00ac);
13601         MP_WritePhyUshort(sc, 0x19, 0x7f00);
13602         MP_WritePhyUshort(sc, 0x15, 0x00ad);
13603         MP_WritePhyUshort(sc, 0x19, 0x70b0);
13604         MP_WritePhyUshort(sc, 0x15, 0x00ae);
13605         MP_WritePhyUshort(sc, 0x19, 0x30b8);
13606         MP_WritePhyUshort(sc, 0x15, 0x00AF);
13607         MP_WritePhyUshort(sc, 0x19, 0x4060);
13608         MP_WritePhyUshort(sc, 0x15, 0x00B0);
13609         MP_WritePhyUshort(sc, 0x19, 0x7800);
13610         MP_WritePhyUshort(sc, 0x15, 0x00B1);
13611         MP_WritePhyUshort(sc, 0x19, 0x7e00);
13612         MP_WritePhyUshort(sc, 0x15, 0x00B2);
13613         MP_WritePhyUshort(sc, 0x19, 0x72B0);
13614         MP_WritePhyUshort(sc, 0x15, 0x00B3);
13615         MP_WritePhyUshort(sc, 0x19, 0x7F00);
13616         MP_WritePhyUshort(sc, 0x15, 0x00B4);
13617         MP_WritePhyUshort(sc, 0x19, 0x73B0);
13618         MP_WritePhyUshort(sc, 0x15, 0x00b5);
13619         MP_WritePhyUshort(sc, 0x19, 0x58a0);
13620         MP_WritePhyUshort(sc, 0x15, 0x00b6);
13621         MP_WritePhyUshort(sc, 0x19, 0x63d2);
13622         MP_WritePhyUshort(sc, 0x15, 0x00b7);
13623         MP_WritePhyUshort(sc, 0x19, 0x5c00);
13624         MP_WritePhyUshort(sc, 0x15, 0x00b8);
13625         MP_WritePhyUshort(sc, 0x19, 0x5780);
13626         MP_WritePhyUshort(sc, 0x15, 0x00b9);
13627         MP_WritePhyUshort(sc, 0x19, 0xb60d);
13628         MP_WritePhyUshort(sc, 0x15, 0x00ba);
13629         MP_WritePhyUshort(sc, 0x19, 0x9bff);
13630         MP_WritePhyUshort(sc, 0x15, 0x00bb);
13631         MP_WritePhyUshort(sc, 0x19, 0x7c03);
13632         MP_WritePhyUshort(sc, 0x15, 0x00bc);
13633         MP_WritePhyUshort(sc, 0x19, 0x6001);
13634         MP_WritePhyUshort(sc, 0x15, 0x00bd);
13635         MP_WritePhyUshort(sc, 0x19, 0xc020);
13636         MP_WritePhyUshort(sc, 0x15, 0x00be);
13637         MP_WritePhyUshort(sc, 0x19, 0x002b);
13638         MP_WritePhyUshort(sc, 0x15, 0x00bf);
13639         MP_WritePhyUshort(sc, 0x19, 0xc137);
13640         MP_WritePhyUshort(sc, 0x15, 0x00c0);
13641         MP_WritePhyUshort(sc, 0x19, 0x0006);
13642         MP_WritePhyUshort(sc, 0x15, 0x00c1);
13643         MP_WritePhyUshort(sc, 0x19, 0x9af8);
13644         MP_WritePhyUshort(sc, 0x15, 0x00c2);
13645         MP_WritePhyUshort(sc, 0x19, 0x30c6);
13646         MP_WritePhyUshort(sc, 0x15, 0x00c3);
13647         MP_WritePhyUshort(sc, 0x19, 0x0000);
13648         MP_WritePhyUshort(sc, 0x15, 0x00c4);
13649         MP_WritePhyUshort(sc, 0x19, 0x0000);
13650         MP_WritePhyUshort(sc, 0x15, 0x00c5);
13651         MP_WritePhyUshort(sc, 0x19, 0x0000);
13652         MP_WritePhyUshort(sc, 0x15, 0x00c6);
13653         MP_WritePhyUshort(sc, 0x19, 0x7d00);
13654         MP_WritePhyUshort(sc, 0x15, 0x00c7);
13655         MP_WritePhyUshort(sc, 0x19, 0x70b0);
13656         MP_WritePhyUshort(sc, 0x15, 0x00c8);
13657         MP_WritePhyUshort(sc, 0x19, 0x4400);
13658         MP_WritePhyUshort(sc, 0x15, 0x00c9);
13659         MP_WritePhyUshort(sc, 0x19, 0x4804);
13660         MP_WritePhyUshort(sc, 0x15, 0x00ca);
13661         MP_WritePhyUshort(sc, 0x19, 0x7c80);
13662         MP_WritePhyUshort(sc, 0x15, 0x00cb);
13663         MP_WritePhyUshort(sc, 0x19, 0x5c80);
13664         MP_WritePhyUshort(sc, 0x15, 0x00cc);
13665         MP_WritePhyUshort(sc, 0x19, 0x4010);
13666         MP_WritePhyUshort(sc, 0x15, 0x00cd);
13667         MP_WritePhyUshort(sc, 0x19, 0x4415);
13668         MP_WritePhyUshort(sc, 0x15, 0x00ce);
13669         MP_WritePhyUshort(sc, 0x19, 0x9b00);
13670         MP_WritePhyUshort(sc, 0x15, 0x00cf);
13671         MP_WritePhyUshort(sc, 0x19, 0x7f00);
13672         MP_WritePhyUshort(sc, 0x15, 0x00d0);
13673         MP_WritePhyUshort(sc, 0x19, 0x70b0);
13674         MP_WritePhyUshort(sc, 0x15, 0x00d1);
13675         MP_WritePhyUshort(sc, 0x19, 0x3177);
13676         MP_WritePhyUshort(sc, 0x15, 0x00d2);
13677         MP_WritePhyUshort(sc, 0x19, 0x0000);
13678         MP_WritePhyUshort(sc, 0x15, 0x00d3);
13679         MP_WritePhyUshort(sc, 0x19, 0x0000);
13680         MP_WritePhyUshort(sc, 0x15, 0x00d4);
13681         MP_WritePhyUshort(sc, 0x19, 0x0000);
13682         MP_WritePhyUshort(sc, 0x15, 0x00d5);
13683         MP_WritePhyUshort(sc, 0x19, 0x4808);
13684         MP_WritePhyUshort(sc, 0x15, 0x00d6);
13685         MP_WritePhyUshort(sc, 0x19, 0x4007);
13686         MP_WritePhyUshort(sc, 0x15, 0x00d7);
13687         MP_WritePhyUshort(sc, 0x19, 0x4420);
13688         MP_WritePhyUshort(sc, 0x15, 0x00d8);
13689         MP_WritePhyUshort(sc, 0x19, 0x63d8);
13690         MP_WritePhyUshort(sc, 0x15, 0x00d9);
13691         MP_WritePhyUshort(sc, 0x19, 0xb608);
13692         MP_WritePhyUshort(sc, 0x15, 0x00da);
13693         MP_WritePhyUshort(sc, 0x19, 0xbcbd);
13694         MP_WritePhyUshort(sc, 0x15, 0x00db);
13695         MP_WritePhyUshort(sc, 0x19, 0xc60b);
13696         MP_WritePhyUshort(sc, 0x15, 0x00dc);
13697         MP_WritePhyUshort(sc, 0x19, 0x00fd);
13698         MP_WritePhyUshort(sc, 0x15, 0x00dd);
13699         MP_WritePhyUshort(sc, 0x19, 0x30e1);
13700         MP_WritePhyUshort(sc, 0x15, 0x00de);
13701         MP_WritePhyUshort(sc, 0x19, 0x0000);
13702         MP_WritePhyUshort(sc, 0x15, 0x00df);
13703         MP_WritePhyUshort(sc, 0x19, 0x0000);
13704         MP_WritePhyUshort(sc, 0x15, 0x00e0);
13705         MP_WritePhyUshort(sc, 0x19, 0x0000);
13706         MP_WritePhyUshort(sc, 0x15, 0x00e1);
13707         MP_WritePhyUshort(sc, 0x19, 0x4809);
13708         MP_WritePhyUshort(sc, 0x15, 0x00e2);
13709         MP_WritePhyUshort(sc, 0x19, 0x7e40);
13710         MP_WritePhyUshort(sc, 0x15, 0x00e3);
13711         MP_WritePhyUshort(sc, 0x19, 0x5a40);
13712         MP_WritePhyUshort(sc, 0x15, 0x00e4);
13713         MP_WritePhyUshort(sc, 0x19, 0x305a);
13714         MP_WritePhyUshort(sc, 0x15, 0x00e5);
13715         MP_WritePhyUshort(sc, 0x19, 0x0000);
13716         MP_WritePhyUshort(sc, 0x15, 0x00e6);
13717         MP_WritePhyUshort(sc, 0x19, 0x0000);
13718         MP_WritePhyUshort(sc, 0x15, 0x00e7);
13719         MP_WritePhyUshort(sc, 0x19, 0x0000);
13720         MP_WritePhyUshort(sc, 0x15, 0x00e8);
13721         MP_WritePhyUshort(sc, 0x19, 0x0000);
13722         MP_WritePhyUshort(sc, 0x15, 0x00e9);
13723         MP_WritePhyUshort(sc, 0x19, 0x480a);
13724         MP_WritePhyUshort(sc, 0x15, 0x00ea);
13725         MP_WritePhyUshort(sc, 0x19, 0x5820);
13726         MP_WritePhyUshort(sc, 0x15, 0x00eb);
13727         MP_WritePhyUshort(sc, 0x19, 0x6c03);
13728         MP_WritePhyUshort(sc, 0x15, 0x00ec);
13729         MP_WritePhyUshort(sc, 0x19, 0xb60a);
13730         MP_WritePhyUshort(sc, 0x15, 0x00ed);
13731         MP_WritePhyUshort(sc, 0x19, 0xda07);
13732         MP_WritePhyUshort(sc, 0x15, 0x00ee);
13733         MP_WritePhyUshort(sc, 0x19, 0x0008);
13734         MP_WritePhyUshort(sc, 0x15, 0x00ef);
13735         MP_WritePhyUshort(sc, 0x19, 0xc60b);
13736         MP_WritePhyUshort(sc, 0x15, 0x00f0);
13737         MP_WritePhyUshort(sc, 0x19, 0x00fc);
13738         MP_WritePhyUshort(sc, 0x15, 0x00f1);
13739         MP_WritePhyUshort(sc, 0x19, 0x30f6);
13740         MP_WritePhyUshort(sc, 0x15, 0x00f2);
13741         MP_WritePhyUshort(sc, 0x19, 0x0000);
13742         MP_WritePhyUshort(sc, 0x15, 0x00f3);
13743         MP_WritePhyUshort(sc, 0x19, 0x0000);
13744         MP_WritePhyUshort(sc, 0x15, 0x00f4);
13745         MP_WritePhyUshort(sc, 0x19, 0x0000);
13746         MP_WritePhyUshort(sc, 0x15, 0x00f5);
13747         MP_WritePhyUshort(sc, 0x19, 0x0000);
13748         MP_WritePhyUshort(sc, 0x15, 0x00f6);
13749         MP_WritePhyUshort(sc, 0x19, 0x4408);
13750         MP_WritePhyUshort(sc, 0x15, 0x00f7);
13751         MP_WritePhyUshort(sc, 0x19, 0x480b);
13752         MP_WritePhyUshort(sc, 0x15, 0x00f8);
13753         MP_WritePhyUshort(sc, 0x19, 0x6f03);
13754         MP_WritePhyUshort(sc, 0x15, 0x00f9);
13755         MP_WritePhyUshort(sc, 0x19, 0x405f);
13756         MP_WritePhyUshort(sc, 0x15, 0x00fa);
13757         MP_WritePhyUshort(sc, 0x19, 0x4448);
13758         MP_WritePhyUshort(sc, 0x15, 0x00fb);
13759         MP_WritePhyUshort(sc, 0x19, 0x4020);
13760         MP_WritePhyUshort(sc, 0x15, 0x00fc);
13761         MP_WritePhyUshort(sc, 0x19, 0x4468);
13762         MP_WritePhyUshort(sc, 0x15, 0x00fd);
13763         MP_WritePhyUshort(sc, 0x19, 0x9c03);
13764         MP_WritePhyUshort(sc, 0x15, 0x00fe);
13765         MP_WritePhyUshort(sc, 0x19, 0x6f07);
13766         MP_WritePhyUshort(sc, 0x15, 0x00ff);
13767         MP_WritePhyUshort(sc, 0x19, 0x58a0);
13768         MP_WritePhyUshort(sc, 0x15, 0x0100);
13769         MP_WritePhyUshort(sc, 0x19, 0xd6d1);
13770         MP_WritePhyUshort(sc, 0x15, 0x0101);
13771         MP_WritePhyUshort(sc, 0x19, 0x0004);
13772         MP_WritePhyUshort(sc, 0x15, 0x0102);
13773         MP_WritePhyUshort(sc, 0x19, 0xc137);
13774         MP_WritePhyUshort(sc, 0x15, 0x0103);
13775         MP_WritePhyUshort(sc, 0x19, 0x0002);
13776         MP_WritePhyUshort(sc, 0x15, 0x0104);
13777         MP_WritePhyUshort(sc, 0x19, 0xa0e5);
13778         MP_WritePhyUshort(sc, 0x15, 0x0105);
13779         MP_WritePhyUshort(sc, 0x19, 0x9df8);
13780         MP_WritePhyUshort(sc, 0x15, 0x0106);
13781         MP_WritePhyUshort(sc, 0x19, 0x30c6);
13782         MP_WritePhyUshort(sc, 0x15, 0x0107);
13783         MP_WritePhyUshort(sc, 0x19, 0x0000);
13784         MP_WritePhyUshort(sc, 0x15, 0x0108);
13785         MP_WritePhyUshort(sc, 0x19, 0x0000);
13786         MP_WritePhyUshort(sc, 0x15, 0x0109);
13787         MP_WritePhyUshort(sc, 0x19, 0x0000);
13788         MP_WritePhyUshort(sc, 0x15, 0x010a);
13789         MP_WritePhyUshort(sc, 0x19, 0x0000);
13790         MP_WritePhyUshort(sc, 0x15, 0x010b);
13791         MP_WritePhyUshort(sc, 0x19, 0x4808);
13792         MP_WritePhyUshort(sc, 0x15, 0x010c);
13793         MP_WritePhyUshort(sc, 0x19, 0xc32d);
13794         MP_WritePhyUshort(sc, 0x15, 0x010d);
13795         MP_WritePhyUshort(sc, 0x19, 0x0003);
13796         MP_WritePhyUshort(sc, 0x15, 0x010e);
13797         MP_WritePhyUshort(sc, 0x19, 0xc8b3);
13798         MP_WritePhyUshort(sc, 0x15, 0x010f);
13799         MP_WritePhyUshort(sc, 0x19, 0x00fc);
13800         MP_WritePhyUshort(sc, 0x15, 0x0110);
13801         MP_WritePhyUshort(sc, 0x19, 0x4400);
13802         MP_WritePhyUshort(sc, 0x15, 0x0111);
13803         MP_WritePhyUshort(sc, 0x19, 0x3116);
13804         MP_WritePhyUshort(sc, 0x15, 0x0112);
13805         MP_WritePhyUshort(sc, 0x19, 0x0000);
13806         MP_WritePhyUshort(sc, 0x15, 0x0113);
13807         MP_WritePhyUshort(sc, 0x19, 0x0000);
13808         MP_WritePhyUshort(sc, 0x15, 0x0114);
13809         MP_WritePhyUshort(sc, 0x19, 0x0000);
13810         MP_WritePhyUshort(sc, 0x15, 0x0115);
13811         MP_WritePhyUshort(sc, 0x19, 0x0000);
13812         MP_WritePhyUshort(sc, 0x15, 0x0116);
13813         MP_WritePhyUshort(sc, 0x19, 0x4803);
13814         MP_WritePhyUshort(sc, 0x15, 0x0117);
13815         MP_WritePhyUshort(sc, 0x19, 0x7c03);
13816         MP_WritePhyUshort(sc, 0x15, 0x0118);
13817         MP_WritePhyUshort(sc, 0x19, 0x6c02);
13818         MP_WritePhyUshort(sc, 0x15, 0x0119);
13819         MP_WritePhyUshort(sc, 0x19, 0x7c04);
13820         MP_WritePhyUshort(sc, 0x15, 0x011a);
13821         MP_WritePhyUshort(sc, 0x19, 0x6000);
13822         MP_WritePhyUshort(sc, 0x15, 0x011b);
13823         MP_WritePhyUshort(sc, 0x19, 0x5cf7);
13824         MP_WritePhyUshort(sc, 0x15, 0x011c);
13825         MP_WritePhyUshort(sc, 0x19, 0x7c2a);
13826         MP_WritePhyUshort(sc, 0x15, 0x011d);
13827         MP_WritePhyUshort(sc, 0x19, 0x5800);
13828         MP_WritePhyUshort(sc, 0x15, 0x011e);
13829         MP_WritePhyUshort(sc, 0x19, 0x5400);
13830         MP_WritePhyUshort(sc, 0x15, 0x011f);
13831         MP_WritePhyUshort(sc, 0x19, 0x7c08);
13832         MP_WritePhyUshort(sc, 0x15, 0x0120);
13833         MP_WritePhyUshort(sc, 0x19, 0x74f0);
13834         MP_WritePhyUshort(sc, 0x15, 0x0121);
13835         MP_WritePhyUshort(sc, 0x19, 0x4019);
13836         MP_WritePhyUshort(sc, 0x15, 0x0122);
13837         MP_WritePhyUshort(sc, 0x19, 0x440d);
13838         MP_WritePhyUshort(sc, 0x15, 0x0123);
13839         MP_WritePhyUshort(sc, 0x19, 0xb6c1);
13840         MP_WritePhyUshort(sc, 0x15, 0x0124);
13841         MP_WritePhyUshort(sc, 0x19, 0xc05b);
13842         MP_WritePhyUshort(sc, 0x15, 0x0125);
13843         MP_WritePhyUshort(sc, 0x19, 0x00bf);
13844         MP_WritePhyUshort(sc, 0x15, 0x0126);
13845         MP_WritePhyUshort(sc, 0x19, 0xc025);
13846         MP_WritePhyUshort(sc, 0x15, 0x0127);
13847         MP_WritePhyUshort(sc, 0x19, 0x00bd);
13848         MP_WritePhyUshort(sc, 0x15, 0x0128);
13849         MP_WritePhyUshort(sc, 0x19, 0xc603);
13850         MP_WritePhyUshort(sc, 0x15, 0x0129);
13851         MP_WritePhyUshort(sc, 0x19, 0x00bb);
13852         MP_WritePhyUshort(sc, 0x15, 0x012a);
13853         MP_WritePhyUshort(sc, 0x19, 0x8805);
13854         MP_WritePhyUshort(sc, 0x15, 0x012b);
13855         MP_WritePhyUshort(sc, 0x19, 0x7801);
13856         MP_WritePhyUshort(sc, 0x15, 0x012c);
13857         MP_WritePhyUshort(sc, 0x19, 0x4001);
13858         MP_WritePhyUshort(sc, 0x15, 0x012d);
13859         MP_WritePhyUshort(sc, 0x19, 0x7800);
13860         MP_WritePhyUshort(sc, 0x15, 0x012e);
13861         MP_WritePhyUshort(sc, 0x19, 0xa3dd);
13862         MP_WritePhyUshort(sc, 0x15, 0x012f);
13863         MP_WritePhyUshort(sc, 0x19, 0x7c03);
13864         MP_WritePhyUshort(sc, 0x15, 0x0130);
13865         MP_WritePhyUshort(sc, 0x19, 0x6c03);
13866         MP_WritePhyUshort(sc, 0x15, 0x0131);
13867         MP_WritePhyUshort(sc, 0x19, 0x8407);
13868         MP_WritePhyUshort(sc, 0x15, 0x0132);
13869         MP_WritePhyUshort(sc, 0x19, 0x7c03);
13870         MP_WritePhyUshort(sc, 0x15, 0x0133);
13871         MP_WritePhyUshort(sc, 0x19, 0x6c02);
13872         MP_WritePhyUshort(sc, 0x15, 0x0134);
13873         MP_WritePhyUshort(sc, 0x19, 0xd9b8);
13874         MP_WritePhyUshort(sc, 0x15, 0x0135);
13875         MP_WritePhyUshort(sc, 0x19, 0x0003);
13876         MP_WritePhyUshort(sc, 0x15, 0x0136);
13877         MP_WritePhyUshort(sc, 0x19, 0xc240);
13878         MP_WritePhyUshort(sc, 0x15, 0x0137);
13879         MP_WritePhyUshort(sc, 0x19, 0x0015);
13880         MP_WritePhyUshort(sc, 0x15, 0x0138);
13881         MP_WritePhyUshort(sc, 0x19, 0x7c03);
13882         MP_WritePhyUshort(sc, 0x15, 0x0139);
13883         MP_WritePhyUshort(sc, 0x19, 0x6c02);
13884         MP_WritePhyUshort(sc, 0x15, 0x013a);
13885         MP_WritePhyUshort(sc, 0x19, 0x9ae9);
13886         MP_WritePhyUshort(sc, 0x15, 0x013b);
13887         MP_WritePhyUshort(sc, 0x19, 0x3140);
13888         MP_WritePhyUshort(sc, 0x15, 0x013c);
13889         MP_WritePhyUshort(sc, 0x19, 0x0000);
13890         MP_WritePhyUshort(sc, 0x15, 0x013d);
13891         MP_WritePhyUshort(sc, 0x19, 0x0000);
13892         MP_WritePhyUshort(sc, 0x15, 0x013e);
13893         MP_WritePhyUshort(sc, 0x19, 0x0000);
13894         MP_WritePhyUshort(sc, 0x15, 0x013f);
13895         MP_WritePhyUshort(sc, 0x19, 0x0000);
13896         MP_WritePhyUshort(sc, 0x15, 0x0140);
13897         MP_WritePhyUshort(sc, 0x19, 0x4807);
13898         MP_WritePhyUshort(sc, 0x15, 0x0141);
13899         MP_WritePhyUshort(sc, 0x19, 0x4004);
13900         MP_WritePhyUshort(sc, 0x15, 0x0142);
13901         MP_WritePhyUshort(sc, 0x19, 0x4410);
13902         MP_WritePhyUshort(sc, 0x15, 0x0143);
13903         MP_WritePhyUshort(sc, 0x19, 0x7c0c);
13904         MP_WritePhyUshort(sc, 0x15, 0x0144);
13905         MP_WritePhyUshort(sc, 0x19, 0x600c);
13906         MP_WritePhyUshort(sc, 0x15, 0x0145);
13907         MP_WritePhyUshort(sc, 0x19, 0x9b00);
13908         MP_WritePhyUshort(sc, 0x15, 0x0146);
13909         MP_WritePhyUshort(sc, 0x19, 0xa68f);
13910         MP_WritePhyUshort(sc, 0x15, 0x0147);
13911         MP_WritePhyUshort(sc, 0x19, 0x3116);
13912         MP_WritePhyUshort(sc, 0x15, 0x0148);
13913         MP_WritePhyUshort(sc, 0x19, 0x0000);
13914         MP_WritePhyUshort(sc, 0x15, 0x0149);
13915         MP_WritePhyUshort(sc, 0x19, 0x0000);
13916         MP_WritePhyUshort(sc, 0x15, 0x014a);
13917         MP_WritePhyUshort(sc, 0x19, 0x0000);
13918         MP_WritePhyUshort(sc, 0x15, 0x014b);
13919         MP_WritePhyUshort(sc, 0x19, 0x0000);
13920         MP_WritePhyUshort(sc, 0x15, 0x014c);
13921         MP_WritePhyUshort(sc, 0x19, 0x4804);
13922         MP_WritePhyUshort(sc, 0x15, 0x014d);
13923         MP_WritePhyUshort(sc, 0x19, 0x54c0);
13924         MP_WritePhyUshort(sc, 0x15, 0x014e);
13925         MP_WritePhyUshort(sc, 0x19, 0xb703);
13926         MP_WritePhyUshort(sc, 0x15, 0x014f);
13927         MP_WritePhyUshort(sc, 0x19, 0x5cff);
13928         MP_WritePhyUshort(sc, 0x15, 0x0150);
13929         MP_WritePhyUshort(sc, 0x19, 0x315f);
13930         MP_WritePhyUshort(sc, 0x15, 0x0151);
13931         MP_WritePhyUshort(sc, 0x19, 0x7c08);
13932         MP_WritePhyUshort(sc, 0x15, 0x0152);
13933         MP_WritePhyUshort(sc, 0x19, 0x74f8);
13934         MP_WritePhyUshort(sc, 0x15, 0x0153);
13935         MP_WritePhyUshort(sc, 0x19, 0x6421);
13936         MP_WritePhyUshort(sc, 0x15, 0x0154);
13937         MP_WritePhyUshort(sc, 0x19, 0x7c08);
13938         MP_WritePhyUshort(sc, 0x15, 0x0155);
13939         MP_WritePhyUshort(sc, 0x19, 0x6000);
13940         MP_WritePhyUshort(sc, 0x15, 0x0156);
13941         MP_WritePhyUshort(sc, 0x19, 0x4003);
13942         MP_WritePhyUshort(sc, 0x15, 0x0157);
13943         MP_WritePhyUshort(sc, 0x19, 0x4418);
13944         MP_WritePhyUshort(sc, 0x15, 0x0158);
13945         MP_WritePhyUshort(sc, 0x19, 0x9b00);
13946         MP_WritePhyUshort(sc, 0x15, 0x0159);
13947         MP_WritePhyUshort(sc, 0x19, 0x6461);
13948         MP_WritePhyUshort(sc, 0x15, 0x015a);
13949         MP_WritePhyUshort(sc, 0x19, 0x64e1);
13950         MP_WritePhyUshort(sc, 0x15, 0x015b);
13951         MP_WritePhyUshort(sc, 0x19, 0x7c20);
13952         MP_WritePhyUshort(sc, 0x15, 0x015c);
13953         MP_WritePhyUshort(sc, 0x19, 0x5820);
13954         MP_WritePhyUshort(sc, 0x15, 0x015d);
13955         MP_WritePhyUshort(sc, 0x19, 0x5ccf);
13956         MP_WritePhyUshort(sc, 0x15, 0x015e);
13957         MP_WritePhyUshort(sc, 0x19, 0x7050);
13958         MP_WritePhyUshort(sc, 0x15, 0x015f);
13959         MP_WritePhyUshort(sc, 0x19, 0xd9b8);
13960         MP_WritePhyUshort(sc, 0x15, 0x0160);
13961         MP_WritePhyUshort(sc, 0x19, 0x0008);
13962         MP_WritePhyUshort(sc, 0x15, 0x0161);
13963         MP_WritePhyUshort(sc, 0x19, 0xdab1);
13964         MP_WritePhyUshort(sc, 0x15, 0x0162);
13965         MP_WritePhyUshort(sc, 0x19, 0x0015);
13966         MP_WritePhyUshort(sc, 0x15, 0x0163);
13967         MP_WritePhyUshort(sc, 0x19, 0xc244);
13968         MP_WritePhyUshort(sc, 0x15, 0x0164);
13969         MP_WritePhyUshort(sc, 0x19, 0x0013);
13970         MP_WritePhyUshort(sc, 0x15, 0x0165);
13971         MP_WritePhyUshort(sc, 0x19, 0xc021);
13972         MP_WritePhyUshort(sc, 0x15, 0x0166);
13973         MP_WritePhyUshort(sc, 0x19, 0x00f9);
13974         MP_WritePhyUshort(sc, 0x15, 0x0167);
13975         MP_WritePhyUshort(sc, 0x19, 0x3177);
13976         MP_WritePhyUshort(sc, 0x15, 0x0168);
13977         MP_WritePhyUshort(sc, 0x19, 0x5cf7);
13978         MP_WritePhyUshort(sc, 0x15, 0x0169);
13979         MP_WritePhyUshort(sc, 0x19, 0x4010);
13980         MP_WritePhyUshort(sc, 0x15, 0x016a);
13981         MP_WritePhyUshort(sc, 0x19, 0x4428);
13982         MP_WritePhyUshort(sc, 0x15, 0x016b);
13983         MP_WritePhyUshort(sc, 0x19, 0x9c00);
13984         MP_WritePhyUshort(sc, 0x15, 0x016c);
13985         MP_WritePhyUshort(sc, 0x19, 0x7c08);
13986         MP_WritePhyUshort(sc, 0x15, 0x016d);
13987         MP_WritePhyUshort(sc, 0x19, 0x6008);
13988         MP_WritePhyUshort(sc, 0x15, 0x016e);
13989         MP_WritePhyUshort(sc, 0x19, 0x7c08);
13990         MP_WritePhyUshort(sc, 0x15, 0x016f);
13991         MP_WritePhyUshort(sc, 0x19, 0x74f0);
13992         MP_WritePhyUshort(sc, 0x15, 0x0170);
13993         MP_WritePhyUshort(sc, 0x19, 0x6461);
13994         MP_WritePhyUshort(sc, 0x15, 0x0171);
13995         MP_WritePhyUshort(sc, 0x19, 0x6421);
13996         MP_WritePhyUshort(sc, 0x15, 0x0172);
13997         MP_WritePhyUshort(sc, 0x19, 0x64a1);
13998         MP_WritePhyUshort(sc, 0x15, 0x0173);
13999         MP_WritePhyUshort(sc, 0x19, 0x3116);
14000         MP_WritePhyUshort(sc, 0x15, 0x0174);
14001         MP_WritePhyUshort(sc, 0x19, 0x0000);
14002         MP_WritePhyUshort(sc, 0x15, 0x0175);
14003         MP_WritePhyUshort(sc, 0x19, 0x0000);
14004         MP_WritePhyUshort(sc, 0x15, 0x0176);
14005         MP_WritePhyUshort(sc, 0x19, 0x0000);
14006         MP_WritePhyUshort(sc, 0x15, 0x0177);
14007         MP_WritePhyUshort(sc, 0x19, 0x4805);
14008         MP_WritePhyUshort(sc, 0x15, 0x0178);
14009         MP_WritePhyUshort(sc, 0x19, 0xa103);
14010         MP_WritePhyUshort(sc, 0x15, 0x0179);
14011         MP_WritePhyUshort(sc, 0x19, 0x7c02);
14012         MP_WritePhyUshort(sc, 0x15, 0x017a);
14013         MP_WritePhyUshort(sc, 0x19, 0x6002);
14014         MP_WritePhyUshort(sc, 0x15, 0x017b);
14015         MP_WritePhyUshort(sc, 0x19, 0x7e00);
14016         MP_WritePhyUshort(sc, 0x15, 0x017c);
14017         MP_WritePhyUshort(sc, 0x19, 0x5400);
14018         MP_WritePhyUshort(sc, 0x15, 0x017d);
14019         MP_WritePhyUshort(sc, 0x19, 0x7c6b);
14020         MP_WritePhyUshort(sc, 0x15, 0x017e);
14021         MP_WritePhyUshort(sc, 0x19, 0x5c63);
14022         MP_WritePhyUshort(sc, 0x15, 0x017f);
14023         MP_WritePhyUshort(sc, 0x19, 0x407d);
14024         MP_WritePhyUshort(sc, 0x15, 0x0180);
14025         MP_WritePhyUshort(sc, 0x19, 0xa602);
14026         MP_WritePhyUshort(sc, 0x15, 0x0181);
14027         MP_WritePhyUshort(sc, 0x19, 0x4001);
14028         MP_WritePhyUshort(sc, 0x15, 0x0182);
14029         MP_WritePhyUshort(sc, 0x19, 0x4420);
14030         MP_WritePhyUshort(sc, 0x15, 0x0183);
14031         MP_WritePhyUshort(sc, 0x19, 0x4020);
14032         MP_WritePhyUshort(sc, 0x15, 0x0184);
14033         MP_WritePhyUshort(sc, 0x19, 0x44a1);
14034         MP_WritePhyUshort(sc, 0x15, 0x0185);
14035         MP_WritePhyUshort(sc, 0x19, 0xd6e0);
14036         MP_WritePhyUshort(sc, 0x15, 0x0186);
14037         MP_WritePhyUshort(sc, 0x19, 0x0009);
14038         MP_WritePhyUshort(sc, 0x15, 0x0187);
14039         MP_WritePhyUshort(sc, 0x19, 0x9efe);
14040         MP_WritePhyUshort(sc, 0x15, 0x0188);
14041         MP_WritePhyUshort(sc, 0x19, 0x7c02);
14042         MP_WritePhyUshort(sc, 0x15, 0x0189);
14043         MP_WritePhyUshort(sc, 0x19, 0x6000);
14044         MP_WritePhyUshort(sc, 0x15, 0x018a);
14045         MP_WritePhyUshort(sc, 0x19, 0x9c00);
14046         MP_WritePhyUshort(sc, 0x15, 0x018b);
14047         MP_WritePhyUshort(sc, 0x19, 0x318f);
14048         MP_WritePhyUshort(sc, 0x15, 0x018c);
14049         MP_WritePhyUshort(sc, 0x19, 0x0000);
14050         MP_WritePhyUshort(sc, 0x15, 0x018d);
14051         MP_WritePhyUshort(sc, 0x19, 0x0000);
14052         MP_WritePhyUshort(sc, 0x15, 0x018e);
14053         MP_WritePhyUshort(sc, 0x19, 0x0000);
14054         MP_WritePhyUshort(sc, 0x15, 0x018f);
14055         MP_WritePhyUshort(sc, 0x19, 0x4806);
14056         MP_WritePhyUshort(sc, 0x15, 0x0190);
14057         MP_WritePhyUshort(sc, 0x19, 0x7c10);
14058         MP_WritePhyUshort(sc, 0x15, 0x0191);
14059         MP_WritePhyUshort(sc, 0x19, 0x5c10);
14060         MP_WritePhyUshort(sc, 0x15, 0x0192);
14061         MP_WritePhyUshort(sc, 0x19, 0x40fa);
14062         MP_WritePhyUshort(sc, 0x15, 0x0193);
14063         MP_WritePhyUshort(sc, 0x19, 0xa602);
14064         MP_WritePhyUshort(sc, 0x15, 0x0194);
14065         MP_WritePhyUshort(sc, 0x19, 0x4010);
14066         MP_WritePhyUshort(sc, 0x15, 0x0195);
14067         MP_WritePhyUshort(sc, 0x19, 0x4440);
14068         MP_WritePhyUshort(sc, 0x15, 0x0196);
14069         MP_WritePhyUshort(sc, 0x19, 0x9d00);
14070         MP_WritePhyUshort(sc, 0x15, 0x0197);
14071         MP_WritePhyUshort(sc, 0x19, 0x7c80);
14072         MP_WritePhyUshort(sc, 0x15, 0x0198);
14073         MP_WritePhyUshort(sc, 0x19, 0x6400);
14074         MP_WritePhyUshort(sc, 0x15, 0x0199);
14075         MP_WritePhyUshort(sc, 0x19, 0x4003);
14076         MP_WritePhyUshort(sc, 0x15, 0x019a);
14077         MP_WritePhyUshort(sc, 0x19, 0x4540);
14078         MP_WritePhyUshort(sc, 0x15, 0x019b);
14079         MP_WritePhyUshort(sc, 0x19, 0x7c08);
14080         MP_WritePhyUshort(sc, 0x15, 0x019c);
14081         MP_WritePhyUshort(sc, 0x19, 0x6008);
14082         MP_WritePhyUshort(sc, 0x15, 0x019d);
14083         MP_WritePhyUshort(sc, 0x19, 0x9f00);
14084         MP_WritePhyUshort(sc, 0x15, 0x019e);
14085         MP_WritePhyUshort(sc, 0x19, 0x7c40);
14086         MP_WritePhyUshort(sc, 0x15, 0x019f);
14087         MP_WritePhyUshort(sc, 0x19, 0x6400);
14088         MP_WritePhyUshort(sc, 0x15, 0x01a0);
14089         MP_WritePhyUshort(sc, 0x19, 0x7c80);
14090         MP_WritePhyUshort(sc, 0x15, 0x01a1);
14091         MP_WritePhyUshort(sc, 0x19, 0x6480);
14092         MP_WritePhyUshort(sc, 0x15, 0x01a2);
14093         MP_WritePhyUshort(sc, 0x19, 0x3140);
14094         MP_WritePhyUshort(sc, 0x15, 0x01a3);
14095         MP_WritePhyUshort(sc, 0x19, 0x0000);
14096         MP_WritePhyUshort(sc, 0x15, 0x01a4);
14097         MP_WritePhyUshort(sc, 0x19, 0x0000);
14098         MP_WritePhyUshort(sc, 0x15, 0x01a5);
14099         MP_WritePhyUshort(sc, 0x19, 0x0000);
14100         MP_WritePhyUshort(sc, 0x15, 0x01a6);
14101         MP_WritePhyUshort(sc, 0x19, 0x4400);
14102         MP_WritePhyUshort(sc, 0x15, 0x01a7);
14103         MP_WritePhyUshort(sc, 0x19, 0x7c0b);
14104         MP_WritePhyUshort(sc, 0x15, 0x01a8);
14105         MP_WritePhyUshort(sc, 0x19, 0x6c01);
14106         MP_WritePhyUshort(sc, 0x15, 0x01a9);
14107         MP_WritePhyUshort(sc, 0x19, 0x64a8);
14108         MP_WritePhyUshort(sc, 0x15, 0x01aa);
14109         MP_WritePhyUshort(sc, 0x19, 0x6800);
14110         MP_WritePhyUshort(sc, 0x15, 0x01ab);
14111         MP_WritePhyUshort(sc, 0x19, 0x5cf0);
14112         MP_WritePhyUshort(sc, 0x15, 0x01ac);
14113         MP_WritePhyUshort(sc, 0x19, 0x588f);
14114         MP_WritePhyUshort(sc, 0x15, 0x01ad);
14115         MP_WritePhyUshort(sc, 0x19, 0xb628);
14116         MP_WritePhyUshort(sc, 0x15, 0x01ae);
14117         MP_WritePhyUshort(sc, 0x19, 0xc053);
14118         MP_WritePhyUshort(sc, 0x15, 0x01af);
14119         MP_WritePhyUshort(sc, 0x19, 0x0026);
14120         MP_WritePhyUshort(sc, 0x15, 0x01b0);
14121         MP_WritePhyUshort(sc, 0x19, 0xc02d);
14122         MP_WritePhyUshort(sc, 0x15, 0x01b1);
14123         MP_WritePhyUshort(sc, 0x19, 0x0024);
14124         MP_WritePhyUshort(sc, 0x15, 0x01b2);
14125         MP_WritePhyUshort(sc, 0x19, 0xc603);
14126         MP_WritePhyUshort(sc, 0x15, 0x01b3);
14127         MP_WritePhyUshort(sc, 0x19, 0x0022);
14128         MP_WritePhyUshort(sc, 0x15, 0x01b4);
14129         MP_WritePhyUshort(sc, 0x19, 0x8cf9);
14130         MP_WritePhyUshort(sc, 0x15, 0x01b5);
14131         MP_WritePhyUshort(sc, 0x19, 0x31ba);
14132         MP_WritePhyUshort(sc, 0x15, 0x01b6);
14133         MP_WritePhyUshort(sc, 0x19, 0x0000);
14134         MP_WritePhyUshort(sc, 0x15, 0x01b7);
14135         MP_WritePhyUshort(sc, 0x19, 0x0000);
14136         MP_WritePhyUshort(sc, 0x15, 0x01b8);
14137         MP_WritePhyUshort(sc, 0x19, 0x0000);
14138         MP_WritePhyUshort(sc, 0x15, 0x01b9);
14139         MP_WritePhyUshort(sc, 0x19, 0x0000);
14140         MP_WritePhyUshort(sc, 0x15, 0x01ba);
14141         MP_WritePhyUshort(sc, 0x19, 0x4400);
14142         MP_WritePhyUshort(sc, 0x15, 0x01bb);
14143         MP_WritePhyUshort(sc, 0x19, 0x5420);
14144         MP_WritePhyUshort(sc, 0x15, 0x01bc);
14145         MP_WritePhyUshort(sc, 0x19, 0x4811);
14146         MP_WritePhyUshort(sc, 0x15, 0x01bd);
14147         MP_WritePhyUshort(sc, 0x19, 0x5000);
14148         MP_WritePhyUshort(sc, 0x15, 0x01be);
14149         MP_WritePhyUshort(sc, 0x19, 0x4801);
14150         MP_WritePhyUshort(sc, 0x15, 0x01bf);
14151         MP_WritePhyUshort(sc, 0x19, 0x6800);
14152         MP_WritePhyUshort(sc, 0x15, 0x01c0);
14153         MP_WritePhyUshort(sc, 0x19, 0x31f5);
14154         MP_WritePhyUshort(sc, 0x15, 0x01c1);
14155         MP_WritePhyUshort(sc, 0x19, 0xb614);
14156         MP_WritePhyUshort(sc, 0x15, 0x01c2);
14157         MP_WritePhyUshort(sc, 0x19, 0x8ce4);
14158         MP_WritePhyUshort(sc, 0x15, 0x01c3);
14159         MP_WritePhyUshort(sc, 0x19, 0xb30c);
14160         MP_WritePhyUshort(sc, 0x15, 0x01c4);
14161         MP_WritePhyUshort(sc, 0x19, 0x7c03);
14162         MP_WritePhyUshort(sc, 0x15, 0x01c5);
14163         MP_WritePhyUshort(sc, 0x19, 0x6c02);
14164         MP_WritePhyUshort(sc, 0x15, 0x01c6);
14165         MP_WritePhyUshort(sc, 0x19, 0x8206);
14166         MP_WritePhyUshort(sc, 0x15, 0x01c7);
14167         MP_WritePhyUshort(sc, 0x19, 0x7c03);
14168         MP_WritePhyUshort(sc, 0x15, 0x01c8);
14169         MP_WritePhyUshort(sc, 0x19, 0x6c00);
14170         MP_WritePhyUshort(sc, 0x15, 0x01c9);
14171         MP_WritePhyUshort(sc, 0x19, 0x7c04);
14172         MP_WritePhyUshort(sc, 0x15, 0x01ca);
14173         MP_WritePhyUshort(sc, 0x19, 0x7404);
14174         MP_WritePhyUshort(sc, 0x15, 0x01cb);
14175         MP_WritePhyUshort(sc, 0x19, 0x31c0);
14176         MP_WritePhyUshort(sc, 0x15, 0x01cc);
14177         MP_WritePhyUshort(sc, 0x19, 0x7c04);
14178         MP_WritePhyUshort(sc, 0x15, 0x01cd);
14179         MP_WritePhyUshort(sc, 0x19, 0x7400);
14180         MP_WritePhyUshort(sc, 0x15, 0x01ce);
14181         MP_WritePhyUshort(sc, 0x19, 0x31c0);
14182         MP_WritePhyUshort(sc, 0x15, 0x01cf);
14183         MP_WritePhyUshort(sc, 0x19, 0x8df1);
14184         MP_WritePhyUshort(sc, 0x15, 0x01d0);
14185         MP_WritePhyUshort(sc, 0x19, 0x3248);
14186         MP_WritePhyUshort(sc, 0x15, 0x01d1);
14187         MP_WritePhyUshort(sc, 0x19, 0x0000);
14188         MP_WritePhyUshort(sc, 0x15, 0x01d2);
14189         MP_WritePhyUshort(sc, 0x19, 0x0000);
14190         MP_WritePhyUshort(sc, 0x15, 0x01d3);
14191         MP_WritePhyUshort(sc, 0x19, 0x0000);
14192         MP_WritePhyUshort(sc, 0x15, 0x01d4);
14193         MP_WritePhyUshort(sc, 0x19, 0x0000);
14194         MP_WritePhyUshort(sc, 0x15, 0x01d5);
14195         MP_WritePhyUshort(sc, 0x19, 0x4400);
14196         MP_WritePhyUshort(sc, 0x15, 0x01d6);
14197         MP_WritePhyUshort(sc, 0x19, 0x7c03);
14198         MP_WritePhyUshort(sc, 0x15, 0x01d7);
14199         MP_WritePhyUshort(sc, 0x19, 0x6c03);
14200         MP_WritePhyUshort(sc, 0x15, 0x01d8);
14201         MP_WritePhyUshort(sc, 0x19, 0x7670);
14202         MP_WritePhyUshort(sc, 0x15, 0x01d9);
14203         MP_WritePhyUshort(sc, 0x19, 0x4023);
14204         MP_WritePhyUshort(sc, 0x15, 0x01da);
14205         MP_WritePhyUshort(sc, 0x19, 0x4500);
14206         MP_WritePhyUshort(sc, 0x15, 0x01db);
14207         MP_WritePhyUshort(sc, 0x19, 0x4069);
14208         MP_WritePhyUshort(sc, 0x15, 0x01dc);
14209         MP_WritePhyUshort(sc, 0x19, 0x4580);
14210         MP_WritePhyUshort(sc, 0x15, 0x01dd);
14211         MP_WritePhyUshort(sc, 0x19, 0x9f00);
14212         MP_WritePhyUshort(sc, 0x15, 0x01de);
14213         MP_WritePhyUshort(sc, 0x19, 0xcff5);
14214         MP_WritePhyUshort(sc, 0x15, 0x01df);
14215         MP_WritePhyUshort(sc, 0x19, 0x00ff);
14216         MP_WritePhyUshort(sc, 0x15, 0x01e0);
14217         MP_WritePhyUshort(sc, 0x19, 0x76f0);
14218         MP_WritePhyUshort(sc, 0x15, 0x01e1);
14219         MP_WritePhyUshort(sc, 0x19, 0x4400);
14220         MP_WritePhyUshort(sc, 0x15, 0x01e2);
14221         MP_WritePhyUshort(sc, 0x19, 0x4023);
14222         MP_WritePhyUshort(sc, 0x15, 0x01e3);
14223         MP_WritePhyUshort(sc, 0x19, 0x4500);
14224         MP_WritePhyUshort(sc, 0x15, 0x01e4);
14225         MP_WritePhyUshort(sc, 0x19, 0x4069);
14226         MP_WritePhyUshort(sc, 0x15, 0x01e5);
14227         MP_WritePhyUshort(sc, 0x19, 0x4580);
14228         MP_WritePhyUshort(sc, 0x15, 0x01e6);
14229         MP_WritePhyUshort(sc, 0x19, 0x9f00);
14230         MP_WritePhyUshort(sc, 0x15, 0x01e7);
14231         MP_WritePhyUshort(sc, 0x19, 0xd0f5);
14232         MP_WritePhyUshort(sc, 0x15, 0x01e8);
14233         MP_WritePhyUshort(sc, 0x19, 0x00ff);
14234         MP_WritePhyUshort(sc, 0x15, 0x01e9);
14235         MP_WritePhyUshort(sc, 0x19, 0x4400);
14236         MP_WritePhyUshort(sc, 0x15, 0x01ea);
14237         MP_WritePhyUshort(sc, 0x19, 0x7c03);
14238         MP_WritePhyUshort(sc, 0x15, 0x01eb);
14239         MP_WritePhyUshort(sc, 0x19, 0x6800);
14240         MP_WritePhyUshort(sc, 0x15, 0x01ec);
14241         MP_WritePhyUshort(sc, 0x19, 0x66a0);
14242         MP_WritePhyUshort(sc, 0x15, 0x01ed);
14243         MP_WritePhyUshort(sc, 0x19, 0x8300);
14244         MP_WritePhyUshort(sc, 0x15, 0x01ee);
14245         MP_WritePhyUshort(sc, 0x19, 0x74f0);
14246         MP_WritePhyUshort(sc, 0x15, 0x01ef);
14247         MP_WritePhyUshort(sc, 0x19, 0x3006);
14248         MP_WritePhyUshort(sc, 0x15, 0x01f0);
14249         MP_WritePhyUshort(sc, 0x19, 0x0000);
14250         MP_WritePhyUshort(sc, 0x15, 0x01f1);
14251         MP_WritePhyUshort(sc, 0x19, 0x0000);
14252         MP_WritePhyUshort(sc, 0x15, 0x01f2);
14253         MP_WritePhyUshort(sc, 0x19, 0x0000);
14254         MP_WritePhyUshort(sc, 0x15, 0x01f3);
14255         MP_WritePhyUshort(sc, 0x19, 0x0000);
14256         MP_WritePhyUshort(sc, 0x15, 0x01f4);
14257         MP_WritePhyUshort(sc, 0x19, 0x0000);
14258         MP_WritePhyUshort(sc, 0x15, 0x01f5);
14259         MP_WritePhyUshort(sc, 0x19, 0x7c03);
14260         MP_WritePhyUshort(sc, 0x15, 0x01f6);
14261         MP_WritePhyUshort(sc, 0x19, 0x6c02);
14262         MP_WritePhyUshort(sc, 0x15, 0x01f7);
14263         MP_WritePhyUshort(sc, 0x19, 0x409d);
14264         MP_WritePhyUshort(sc, 0x15, 0x01f8);
14265         MP_WritePhyUshort(sc, 0x19, 0x7c87);
14266         MP_WritePhyUshort(sc, 0x15, 0x01f9);
14267         MP_WritePhyUshort(sc, 0x19, 0xae14);
14268         MP_WritePhyUshort(sc, 0x15, 0x01fa);
14269         MP_WritePhyUshort(sc, 0x19, 0x4400);
14270         MP_WritePhyUshort(sc, 0x15, 0x01fb);
14271         MP_WritePhyUshort(sc, 0x19, 0x7c40);
14272         MP_WritePhyUshort(sc, 0x15, 0x01fc);
14273         MP_WritePhyUshort(sc, 0x19, 0x6800);
14274         MP_WritePhyUshort(sc, 0x15, 0x01fd);
14275         MP_WritePhyUshort(sc, 0x19, 0x7801);
14276         MP_WritePhyUshort(sc, 0x15, 0x01fe);
14277         MP_WritePhyUshort(sc, 0x19, 0x980e);
14278         MP_WritePhyUshort(sc, 0x15, 0x01ff);
14279         MP_WritePhyUshort(sc, 0x19, 0x930c);
14280         MP_WritePhyUshort(sc, 0x15, 0x0200);
14281         MP_WritePhyUshort(sc, 0x19, 0x9206);
14282         MP_WritePhyUshort(sc, 0x15, 0x0201);
14283         MP_WritePhyUshort(sc, 0x19, 0x4002);
14284         MP_WritePhyUshort(sc, 0x15, 0x0202);
14285         MP_WritePhyUshort(sc, 0x19, 0x7800);
14286         MP_WritePhyUshort(sc, 0x15, 0x0203);
14287         MP_WritePhyUshort(sc, 0x19, 0x588f);
14288         MP_WritePhyUshort(sc, 0x15, 0x0204);
14289         MP_WritePhyUshort(sc, 0x19, 0x5520);
14290         MP_WritePhyUshort(sc, 0x15, 0x0205);
14291         MP_WritePhyUshort(sc, 0x19, 0x320c);
14292         MP_WritePhyUshort(sc, 0x15, 0x0206);
14293         MP_WritePhyUshort(sc, 0x19, 0x4000);
14294         MP_WritePhyUshort(sc, 0x15, 0x0207);
14295         MP_WritePhyUshort(sc, 0x19, 0x7800);
14296         MP_WritePhyUshort(sc, 0x15, 0x0208);
14297         MP_WritePhyUshort(sc, 0x19, 0x588d);
14298         MP_WritePhyUshort(sc, 0x15, 0x0209);
14299         MP_WritePhyUshort(sc, 0x19, 0x5500);
14300         MP_WritePhyUshort(sc, 0x15, 0x020a);
14301         MP_WritePhyUshort(sc, 0x19, 0x320c);
14302         MP_WritePhyUshort(sc, 0x15, 0x020b);
14303         MP_WritePhyUshort(sc, 0x19, 0x4002);
14304         MP_WritePhyUshort(sc, 0x15, 0x020c);
14305         MP_WritePhyUshort(sc, 0x19, 0x3220);
14306         MP_WritePhyUshort(sc, 0x15, 0x020d);
14307         MP_WritePhyUshort(sc, 0x19, 0x4480);
14308         MP_WritePhyUshort(sc, 0x15, 0x020e);
14309         MP_WritePhyUshort(sc, 0x19, 0x9e03);
14310         MP_WritePhyUshort(sc, 0x15, 0x020f);
14311         MP_WritePhyUshort(sc, 0x19, 0x7c40);
14312         MP_WritePhyUshort(sc, 0x15, 0x0210);
14313         MP_WritePhyUshort(sc, 0x19, 0x6840);
14314         MP_WritePhyUshort(sc, 0x15, 0x0211);
14315         MP_WritePhyUshort(sc, 0x19, 0x7801);
14316         MP_WritePhyUshort(sc, 0x15, 0x0212);
14317         MP_WritePhyUshort(sc, 0x19, 0x980e);
14318         MP_WritePhyUshort(sc, 0x15, 0x0213);
14319         MP_WritePhyUshort(sc, 0x19, 0x930c);
14320         MP_WritePhyUshort(sc, 0x15, 0x0214);
14321         MP_WritePhyUshort(sc, 0x19, 0x9206);
14322         MP_WritePhyUshort(sc, 0x15, 0x0215);
14323         MP_WritePhyUshort(sc, 0x19, 0x4000);
14324         MP_WritePhyUshort(sc, 0x15, 0x0216);
14325         MP_WritePhyUshort(sc, 0x19, 0x7800);
14326         MP_WritePhyUshort(sc, 0x15, 0x0217);
14327         MP_WritePhyUshort(sc, 0x19, 0x588f);
14328         MP_WritePhyUshort(sc, 0x15, 0x0218);
14329         MP_WritePhyUshort(sc, 0x19, 0x5520);
14330         MP_WritePhyUshort(sc, 0x15, 0x0219);
14331         MP_WritePhyUshort(sc, 0x19, 0x3220);
14332         MP_WritePhyUshort(sc, 0x15, 0x021a);
14333         MP_WritePhyUshort(sc, 0x19, 0x4002);
14334         MP_WritePhyUshort(sc, 0x15, 0x021b);
14335         MP_WritePhyUshort(sc, 0x19, 0x7800);
14336         MP_WritePhyUshort(sc, 0x15, 0x021c);
14337         MP_WritePhyUshort(sc, 0x19, 0x588d);
14338         MP_WritePhyUshort(sc, 0x15, 0x021d);
14339         MP_WritePhyUshort(sc, 0x19, 0x5540);
14340         MP_WritePhyUshort(sc, 0x15, 0x021e);
14341         MP_WritePhyUshort(sc, 0x19, 0x3220);
14342         MP_WritePhyUshort(sc, 0x15, 0x021f);
14343         MP_WritePhyUshort(sc, 0x19, 0x4000);
14344         MP_WritePhyUshort(sc, 0x15, 0x0220);
14345         MP_WritePhyUshort(sc, 0x19, 0x7800);
14346         MP_WritePhyUshort(sc, 0x15, 0x0221);
14347         MP_WritePhyUshort(sc, 0x19, 0x7c03);
14348         MP_WritePhyUshort(sc, 0x15, 0x0222);
14349         MP_WritePhyUshort(sc, 0x19, 0x6c00);
14350         MP_WritePhyUshort(sc, 0x15, 0x0223);
14351         MP_WritePhyUshort(sc, 0x19, 0x3231);
14352         MP_WritePhyUshort(sc, 0x15, 0x0224);
14353         MP_WritePhyUshort(sc, 0x19, 0xab06);
14354         MP_WritePhyUshort(sc, 0x15, 0x0225);
14355         MP_WritePhyUshort(sc, 0x19, 0xbf08);
14356         MP_WritePhyUshort(sc, 0x15, 0x0226);
14357         MP_WritePhyUshort(sc, 0x19, 0x4076);
14358         MP_WritePhyUshort(sc, 0x15, 0x0227);
14359         MP_WritePhyUshort(sc, 0x19, 0x7d07);
14360         MP_WritePhyUshort(sc, 0x15, 0x0228);
14361         MP_WritePhyUshort(sc, 0x19, 0x4502);
14362         MP_WritePhyUshort(sc, 0x15, 0x0229);
14363         MP_WritePhyUshort(sc, 0x19, 0x3231);
14364         MP_WritePhyUshort(sc, 0x15, 0x022a);
14365         MP_WritePhyUshort(sc, 0x19, 0x7d80);
14366         MP_WritePhyUshort(sc, 0x15, 0x022b);
14367         MP_WritePhyUshort(sc, 0x19, 0x5180);
14368         MP_WritePhyUshort(sc, 0x15, 0x022c);
14369         MP_WritePhyUshort(sc, 0x19, 0x322f);
14370         MP_WritePhyUshort(sc, 0x15, 0x022d);
14371         MP_WritePhyUshort(sc, 0x19, 0x7d80);
14372         MP_WritePhyUshort(sc, 0x15, 0x022e);
14373         MP_WritePhyUshort(sc, 0x19, 0x5000);
14374         MP_WritePhyUshort(sc, 0x15, 0x022f);
14375         MP_WritePhyUshort(sc, 0x19, 0x7d07);
14376         MP_WritePhyUshort(sc, 0x15, 0x0230);
14377         MP_WritePhyUshort(sc, 0x19, 0x4402);
14378         MP_WritePhyUshort(sc, 0x15, 0x0231);
14379         MP_WritePhyUshort(sc, 0x19, 0x7c03);
14380         MP_WritePhyUshort(sc, 0x15, 0x0232);
14381         MP_WritePhyUshort(sc, 0x19, 0x6c02);
14382         MP_WritePhyUshort(sc, 0x15, 0x0233);
14383         MP_WritePhyUshort(sc, 0x19, 0x7c03);
14384         MP_WritePhyUshort(sc, 0x15, 0x0234);
14385         MP_WritePhyUshort(sc, 0x19, 0xb309);
14386         MP_WritePhyUshort(sc, 0x15, 0x0235);
14387         MP_WritePhyUshort(sc, 0x19, 0xb204);
14388         MP_WritePhyUshort(sc, 0x15, 0x0236);
14389         MP_WritePhyUshort(sc, 0x19, 0xb105);
14390         MP_WritePhyUshort(sc, 0x15, 0x0237);
14391         MP_WritePhyUshort(sc, 0x19, 0x6c00);
14392         MP_WritePhyUshort(sc, 0x15, 0x0238);
14393         MP_WritePhyUshort(sc, 0x19, 0x31c1);
14394         MP_WritePhyUshort(sc, 0x15, 0x0239);
14395         MP_WritePhyUshort(sc, 0x19, 0x6c00);
14396         MP_WritePhyUshort(sc, 0x15, 0x023a);
14397         MP_WritePhyUshort(sc, 0x19, 0x3261);
14398         MP_WritePhyUshort(sc, 0x15, 0x023b);
14399         MP_WritePhyUshort(sc, 0x19, 0x6c00);
14400         MP_WritePhyUshort(sc, 0x15, 0x023c);
14401         MP_WritePhyUshort(sc, 0x19, 0x3250);
14402         MP_WritePhyUshort(sc, 0x15, 0x023d);
14403         MP_WritePhyUshort(sc, 0x19, 0xb203);
14404         MP_WritePhyUshort(sc, 0x15, 0x023e);
14405         MP_WritePhyUshort(sc, 0x19, 0x6c00);
14406         MP_WritePhyUshort(sc, 0x15, 0x023f);
14407         MP_WritePhyUshort(sc, 0x19, 0x327a);
14408         MP_WritePhyUshort(sc, 0x15, 0x0240);
14409         MP_WritePhyUshort(sc, 0x19, 0x6c00);
14410         MP_WritePhyUshort(sc, 0x15, 0x0241);
14411         MP_WritePhyUshort(sc, 0x19, 0x3293);
14412         MP_WritePhyUshort(sc, 0x15, 0x0242);
14413         MP_WritePhyUshort(sc, 0x19, 0x0000);
14414         MP_WritePhyUshort(sc, 0x15, 0x0243);
14415         MP_WritePhyUshort(sc, 0x19, 0x0000);
14416         MP_WritePhyUshort(sc, 0x15, 0x0244);
14417         MP_WritePhyUshort(sc, 0x19, 0x0000);
14418         MP_WritePhyUshort(sc, 0x15, 0x0245);
14419         MP_WritePhyUshort(sc, 0x19, 0x0000);
14420         MP_WritePhyUshort(sc, 0x15, 0x0246);
14421         MP_WritePhyUshort(sc, 0x19, 0x0000);
14422         MP_WritePhyUshort(sc, 0x15, 0x0247);
14423         MP_WritePhyUshort(sc, 0x19, 0x32a3);
14424         MP_WritePhyUshort(sc, 0x15, 0x0248);
14425         MP_WritePhyUshort(sc, 0x19, 0x5520);
14426         MP_WritePhyUshort(sc, 0x15, 0x0249);
14427         MP_WritePhyUshort(sc, 0x19, 0x403d);
14428         MP_WritePhyUshort(sc, 0x15, 0x024a);
14429         MP_WritePhyUshort(sc, 0x19, 0x440c);
14430         MP_WritePhyUshort(sc, 0x15, 0x024b);
14431         MP_WritePhyUshort(sc, 0x19, 0x4812);
14432         MP_WritePhyUshort(sc, 0x15, 0x024c);
14433         MP_WritePhyUshort(sc, 0x19, 0x5001);
14434         MP_WritePhyUshort(sc, 0x15, 0x024d);
14435         MP_WritePhyUshort(sc, 0x19, 0x4802);
14436         MP_WritePhyUshort(sc, 0x15, 0x024e);
14437         MP_WritePhyUshort(sc, 0x19, 0x6880);
14438         MP_WritePhyUshort(sc, 0x15, 0x024f);
14439         MP_WritePhyUshort(sc, 0x19, 0x31f5);
14440         MP_WritePhyUshort(sc, 0x15, 0x0250);
14441         MP_WritePhyUshort(sc, 0x19, 0xb685);
14442         MP_WritePhyUshort(sc, 0x15, 0x0251);
14443         MP_WritePhyUshort(sc, 0x19, 0x801c);
14444         MP_WritePhyUshort(sc, 0x15, 0x0252);
14445         MP_WritePhyUshort(sc, 0x19, 0xbaf5);
14446         MP_WritePhyUshort(sc, 0x15, 0x0253);
14447         MP_WritePhyUshort(sc, 0x19, 0xc07c);
14448         MP_WritePhyUshort(sc, 0x15, 0x0254);
14449         MP_WritePhyUshort(sc, 0x19, 0x00fb);
14450         MP_WritePhyUshort(sc, 0x15, 0x0255);
14451         MP_WritePhyUshort(sc, 0x19, 0x325a);
14452         MP_WritePhyUshort(sc, 0x15, 0x0256);
14453         MP_WritePhyUshort(sc, 0x19, 0x0000);
14454         MP_WritePhyUshort(sc, 0x15, 0x0257);
14455         MP_WritePhyUshort(sc, 0x19, 0x0000);
14456         MP_WritePhyUshort(sc, 0x15, 0x0258);
14457         MP_WritePhyUshort(sc, 0x19, 0x0000);
14458         MP_WritePhyUshort(sc, 0x15, 0x0259);
14459         MP_WritePhyUshort(sc, 0x19, 0x0000);
14460         MP_WritePhyUshort(sc, 0x15, 0x025a);
14461         MP_WritePhyUshort(sc, 0x19, 0x481a);
14462         MP_WritePhyUshort(sc, 0x15, 0x025b);
14463         MP_WritePhyUshort(sc, 0x19, 0x5001);
14464         MP_WritePhyUshort(sc, 0x15, 0x025c);
14465         MP_WritePhyUshort(sc, 0x19, 0x401b);
14466         MP_WritePhyUshort(sc, 0x15, 0x025d);
14467         MP_WritePhyUshort(sc, 0x19, 0x480a);
14468         MP_WritePhyUshort(sc, 0x15, 0x025e);
14469         MP_WritePhyUshort(sc, 0x19, 0x4418);
14470         MP_WritePhyUshort(sc, 0x15, 0x025f);
14471         MP_WritePhyUshort(sc, 0x19, 0x6900);
14472         MP_WritePhyUshort(sc, 0x15, 0x0260);
14473         MP_WritePhyUshort(sc, 0x19, 0x31f5);
14474         MP_WritePhyUshort(sc, 0x15, 0x0261);
14475         MP_WritePhyUshort(sc, 0x19, 0xb64b);
14476         MP_WritePhyUshort(sc, 0x15, 0x0262);
14477         MP_WritePhyUshort(sc, 0x19, 0xdb00);
14478         MP_WritePhyUshort(sc, 0x15, 0x0263);
14479         MP_WritePhyUshort(sc, 0x19, 0x0048);
14480         MP_WritePhyUshort(sc, 0x15, 0x0264);
14481         MP_WritePhyUshort(sc, 0x19, 0xdb7d);
14482         MP_WritePhyUshort(sc, 0x15, 0x0265);
14483         MP_WritePhyUshort(sc, 0x19, 0x0002);
14484         MP_WritePhyUshort(sc, 0x15, 0x0266);
14485         MP_WritePhyUshort(sc, 0x19, 0xa0fa);
14486         MP_WritePhyUshort(sc, 0x15, 0x0267);
14487         MP_WritePhyUshort(sc, 0x19, 0x4408);
14488         MP_WritePhyUshort(sc, 0x15, 0x0268);
14489         MP_WritePhyUshort(sc, 0x19, 0x3248);
14490         MP_WritePhyUshort(sc, 0x15, 0x0269);
14491         MP_WritePhyUshort(sc, 0x19, 0x0000);
14492         MP_WritePhyUshort(sc, 0x15, 0x026a);
14493         MP_WritePhyUshort(sc, 0x19, 0x0000);
14494         MP_WritePhyUshort(sc, 0x15, 0x026b);
14495         MP_WritePhyUshort(sc, 0x19, 0x0000);
14496         MP_WritePhyUshort(sc, 0x15, 0x026c);
14497         MP_WritePhyUshort(sc, 0x19, 0x0000);
14498         MP_WritePhyUshort(sc, 0x15, 0x026d);
14499         MP_WritePhyUshort(sc, 0x19, 0xb806);
14500         MP_WritePhyUshort(sc, 0x15, 0x026e);
14501         MP_WritePhyUshort(sc, 0x19, 0x588d);
14502         MP_WritePhyUshort(sc, 0x15, 0x026f);
14503         MP_WritePhyUshort(sc, 0x19, 0x5500);
14504         MP_WritePhyUshort(sc, 0x15, 0x0270);
14505         MP_WritePhyUshort(sc, 0x19, 0x7801);
14506         MP_WritePhyUshort(sc, 0x15, 0x0271);
14507         MP_WritePhyUshort(sc, 0x19, 0x4002);
14508         MP_WritePhyUshort(sc, 0x15, 0x0272);
14509         MP_WritePhyUshort(sc, 0x19, 0x7800);
14510         MP_WritePhyUshort(sc, 0x15, 0x0273);
14511         MP_WritePhyUshort(sc, 0x19, 0x4814);
14512         MP_WritePhyUshort(sc, 0x15, 0x0274);
14513         MP_WritePhyUshort(sc, 0x19, 0x500b);
14514         MP_WritePhyUshort(sc, 0x15, 0x0275);
14515         MP_WritePhyUshort(sc, 0x19, 0x4804);
14516         MP_WritePhyUshort(sc, 0x15, 0x0276);
14517         MP_WritePhyUshort(sc, 0x19, 0x40c4);
14518         MP_WritePhyUshort(sc, 0x15, 0x0277);
14519         MP_WritePhyUshort(sc, 0x19, 0x4425);
14520         MP_WritePhyUshort(sc, 0x15, 0x0278);
14521         MP_WritePhyUshort(sc, 0x19, 0x6a00);
14522         MP_WritePhyUshort(sc, 0x15, 0x0279);
14523         MP_WritePhyUshort(sc, 0x19, 0x31f5);
14524         MP_WritePhyUshort(sc, 0x15, 0x027a);
14525         MP_WritePhyUshort(sc, 0x19, 0xb632);
14526         MP_WritePhyUshort(sc, 0x15, 0x027b);
14527         MP_WritePhyUshort(sc, 0x19, 0xdc03);
14528         MP_WritePhyUshort(sc, 0x15, 0x027c);
14529         MP_WritePhyUshort(sc, 0x19, 0x0027);
14530         MP_WritePhyUshort(sc, 0x15, 0x027d);
14531         MP_WritePhyUshort(sc, 0x19, 0x80fc);
14532         MP_WritePhyUshort(sc, 0x15, 0x027e);
14533         MP_WritePhyUshort(sc, 0x19, 0x3283);
14534         MP_WritePhyUshort(sc, 0x15, 0x027f);
14535         MP_WritePhyUshort(sc, 0x19, 0x0000);
14536         MP_WritePhyUshort(sc, 0x15, 0x0280);
14537         MP_WritePhyUshort(sc, 0x19, 0x0000);
14538         MP_WritePhyUshort(sc, 0x15, 0x0281);
14539         MP_WritePhyUshort(sc, 0x19, 0x0000);
14540         MP_WritePhyUshort(sc, 0x15, 0x0282);
14541         MP_WritePhyUshort(sc, 0x19, 0x0000);
14542         MP_WritePhyUshort(sc, 0x15, 0x0283);
14543         MP_WritePhyUshort(sc, 0x19, 0xb806);
14544         MP_WritePhyUshort(sc, 0x15, 0x0284);
14545         MP_WritePhyUshort(sc, 0x19, 0x588f);
14546         MP_WritePhyUshort(sc, 0x15, 0x0285);
14547         MP_WritePhyUshort(sc, 0x19, 0x5520);
14548         MP_WritePhyUshort(sc, 0x15, 0x0286);
14549         MP_WritePhyUshort(sc, 0x19, 0x7801);
14550         MP_WritePhyUshort(sc, 0x15, 0x0287);
14551         MP_WritePhyUshort(sc, 0x19, 0x4000);
14552         MP_WritePhyUshort(sc, 0x15, 0x0288);
14553         MP_WritePhyUshort(sc, 0x19, 0x7800);
14554         MP_WritePhyUshort(sc, 0x15, 0x0289);
14555         MP_WritePhyUshort(sc, 0x19, 0x4818);
14556         MP_WritePhyUshort(sc, 0x15, 0x028a);
14557         MP_WritePhyUshort(sc, 0x19, 0x5051);
14558         MP_WritePhyUshort(sc, 0x15, 0x028b);
14559         MP_WritePhyUshort(sc, 0x19, 0x4808);
14560         MP_WritePhyUshort(sc, 0x15, 0x028c);
14561         MP_WritePhyUshort(sc, 0x19, 0x4050);
14562         MP_WritePhyUshort(sc, 0x15, 0x028d);
14563         MP_WritePhyUshort(sc, 0x19, 0x4462);
14564         MP_WritePhyUshort(sc, 0x15, 0x028e);
14565         MP_WritePhyUshort(sc, 0x19, 0x40c4);
14566         MP_WritePhyUshort(sc, 0x15, 0x028f);
14567         MP_WritePhyUshort(sc, 0x19, 0x4473);
14568         MP_WritePhyUshort(sc, 0x15, 0x0290);
14569         MP_WritePhyUshort(sc, 0x19, 0x5041);
14570         MP_WritePhyUshort(sc, 0x15, 0x0291);
14571         MP_WritePhyUshort(sc, 0x19, 0x6b00);
14572         MP_WritePhyUshort(sc, 0x15, 0x0292);
14573         MP_WritePhyUshort(sc, 0x19, 0x31f5);
14574         MP_WritePhyUshort(sc, 0x15, 0x0293);
14575         MP_WritePhyUshort(sc, 0x19, 0xb619);
14576         MP_WritePhyUshort(sc, 0x15, 0x0294);
14577         MP_WritePhyUshort(sc, 0x19, 0x80d9);
14578         MP_WritePhyUshort(sc, 0x15, 0x0295);
14579         MP_WritePhyUshort(sc, 0x19, 0xbd06);
14580         MP_WritePhyUshort(sc, 0x15, 0x0296);
14581         MP_WritePhyUshort(sc, 0x19, 0xbb0d);
14582         MP_WritePhyUshort(sc, 0x15, 0x0297);
14583         MP_WritePhyUshort(sc, 0x19, 0xaf14);
14584         MP_WritePhyUshort(sc, 0x15, 0x0298);
14585         MP_WritePhyUshort(sc, 0x19, 0x8efa);
14586         MP_WritePhyUshort(sc, 0x15, 0x0299);
14587         MP_WritePhyUshort(sc, 0x19, 0x5049);
14588         MP_WritePhyUshort(sc, 0x15, 0x029a);
14589         MP_WritePhyUshort(sc, 0x19, 0x3248);
14590         MP_WritePhyUshort(sc, 0x15, 0x029b);
14591         MP_WritePhyUshort(sc, 0x19, 0x4c10);
14592         MP_WritePhyUshort(sc, 0x15, 0x029c);
14593         MP_WritePhyUshort(sc, 0x19, 0x44b0);
14594         MP_WritePhyUshort(sc, 0x15, 0x029d);
14595         MP_WritePhyUshort(sc, 0x19, 0x4c00);
14596         MP_WritePhyUshort(sc, 0x15, 0x029e);
14597         MP_WritePhyUshort(sc, 0x19, 0x3292);
14598         MP_WritePhyUshort(sc, 0x15, 0x029f);
14599         MP_WritePhyUshort(sc, 0x19, 0x0000);
14600         MP_WritePhyUshort(sc, 0x15, 0x02a0);
14601         MP_WritePhyUshort(sc, 0x19, 0x0000);
14602         MP_WritePhyUshort(sc, 0x15, 0x02a1);
14603         MP_WritePhyUshort(sc, 0x19, 0x0000);
14604         MP_WritePhyUshort(sc, 0x15, 0x02a2);
14605         MP_WritePhyUshort(sc, 0x19, 0x0000);
14606         MP_WritePhyUshort(sc, 0x15, 0x02a3);
14607         MP_WritePhyUshort(sc, 0x19, 0x481f);
14608         MP_WritePhyUshort(sc, 0x15, 0x02a4);
14609         MP_WritePhyUshort(sc, 0x19, 0x5005);
14610         MP_WritePhyUshort(sc, 0x15, 0x02a5);
14611         MP_WritePhyUshort(sc, 0x19, 0x480f);
14612         MP_WritePhyUshort(sc, 0x15, 0x02a6);
14613         MP_WritePhyUshort(sc, 0x19, 0xac00);
14614         MP_WritePhyUshort(sc, 0x15, 0x02a7);
14615         MP_WritePhyUshort(sc, 0x19, 0x31a6);
14616         MP_WritePhyUshort(sc, 0x15, 0x02a8);
14617         MP_WritePhyUshort(sc, 0x19, 0x0000);
14618         MP_WritePhyUshort(sc, 0x15, 0x02a9);
14619         MP_WritePhyUshort(sc, 0x19, 0x0000);
14620         MP_WritePhyUshort(sc, 0x15, 0x02aa);
14621         MP_WritePhyUshort(sc, 0x19, 0x0000);
14622         MP_WritePhyUshort(sc, 0x15, 0x02ab);
14623         MP_WritePhyUshort(sc, 0x19, 0x31ba);
14624         MP_WritePhyUshort(sc, 0x15, 0x02ac);
14625         MP_WritePhyUshort(sc, 0x19, 0x31d5);
14626         MP_WritePhyUshort(sc, 0x15, 0x02ad);
14627         MP_WritePhyUshort(sc, 0x19, 0x0000);
14628         MP_WritePhyUshort(sc, 0x15, 0x02ae);
14629         MP_WritePhyUshort(sc, 0x19, 0x5cf0);
14630         MP_WritePhyUshort(sc, 0x15, 0x02af);
14631         MP_WritePhyUshort(sc, 0x19, 0x588c);
14632         MP_WritePhyUshort(sc, 0x15, 0x02b0);
14633         MP_WritePhyUshort(sc, 0x19, 0x542f);
14634         MP_WritePhyUshort(sc, 0x15, 0x02b1);
14635         MP_WritePhyUshort(sc, 0x19, 0x7ffb);
14636         MP_WritePhyUshort(sc, 0x15, 0x02b2);
14637         MP_WritePhyUshort(sc, 0x19, 0x6ff8);
14638         MP_WritePhyUshort(sc, 0x15, 0x02b3);
14639         MP_WritePhyUshort(sc, 0x19, 0x64a4);
14640         MP_WritePhyUshort(sc, 0x15, 0x02b4);
14641         MP_WritePhyUshort(sc, 0x19, 0x64a0);
14642         MP_WritePhyUshort(sc, 0x15, 0x02b5);
14643         MP_WritePhyUshort(sc, 0x19, 0x6800);
14644         MP_WritePhyUshort(sc, 0x15, 0x02b6);
14645         MP_WritePhyUshort(sc, 0x19, 0x4400);
14646         MP_WritePhyUshort(sc, 0x15, 0x02b7);
14647         MP_WritePhyUshort(sc, 0x19, 0x4020);
14648         MP_WritePhyUshort(sc, 0x15, 0x02b8);
14649         MP_WritePhyUshort(sc, 0x19, 0x4480);
14650         MP_WritePhyUshort(sc, 0x15, 0x02b9);
14651         MP_WritePhyUshort(sc, 0x19, 0x9e00);
14652         MP_WritePhyUshort(sc, 0x15, 0x02ba);
14653         MP_WritePhyUshort(sc, 0x19, 0x4891);
14654         MP_WritePhyUshort(sc, 0x15, 0x02bb);
14655         MP_WritePhyUshort(sc, 0x19, 0x4cc0);
14656         MP_WritePhyUshort(sc, 0x15, 0x02bc);
14657         MP_WritePhyUshort(sc, 0x19, 0x4801);
14658         MP_WritePhyUshort(sc, 0x15, 0x02bd);
14659         MP_WritePhyUshort(sc, 0x19, 0xa609);
14660         MP_WritePhyUshort(sc, 0x15, 0x02be);
14661         MP_WritePhyUshort(sc, 0x19, 0xd64f);
14662         MP_WritePhyUshort(sc, 0x15, 0x02bf);
14663         MP_WritePhyUshort(sc, 0x19, 0x004e);
14664         MP_WritePhyUshort(sc, 0x15, 0x02c0);
14665         MP_WritePhyUshort(sc, 0x19, 0x87fe);
14666         MP_WritePhyUshort(sc, 0x15, 0x02c1);
14667         MP_WritePhyUshort(sc, 0x19, 0x32c6);
14668         MP_WritePhyUshort(sc, 0x15, 0x02c2);
14669         MP_WritePhyUshort(sc, 0x19, 0x0000);
14670         MP_WritePhyUshort(sc, 0x15, 0x02c3);
14671         MP_WritePhyUshort(sc, 0x19, 0x0000);
14672         MP_WritePhyUshort(sc, 0x15, 0x02c4);
14673         MP_WritePhyUshort(sc, 0x19, 0x0000);
14674         MP_WritePhyUshort(sc, 0x15, 0x02c5);
14675         MP_WritePhyUshort(sc, 0x19, 0x0000);
14676         MP_WritePhyUshort(sc, 0x15, 0x02c6);
14677         MP_WritePhyUshort(sc, 0x19, 0x48b2);
14678         MP_WritePhyUshort(sc, 0x15, 0x02c7);
14679         MP_WritePhyUshort(sc, 0x19, 0x4020);
14680         MP_WritePhyUshort(sc, 0x15, 0x02c8);
14681         MP_WritePhyUshort(sc, 0x19, 0x4822);
14682         MP_WritePhyUshort(sc, 0x15, 0x02c9);
14683         MP_WritePhyUshort(sc, 0x19, 0x4488);
14684         MP_WritePhyUshort(sc, 0x15, 0x02ca);
14685         MP_WritePhyUshort(sc, 0x19, 0xd64f);
14686         MP_WritePhyUshort(sc, 0x15, 0x02cb);
14687         MP_WritePhyUshort(sc, 0x19, 0x0042);
14688         MP_WritePhyUshort(sc, 0x15, 0x02cc);
14689         MP_WritePhyUshort(sc, 0x19, 0x8203);
14690         MP_WritePhyUshort(sc, 0x15, 0x02cd);
14691         MP_WritePhyUshort(sc, 0x19, 0x4cc8);
14692         MP_WritePhyUshort(sc, 0x15, 0x02ce);
14693         MP_WritePhyUshort(sc, 0x19, 0x32d0);
14694         MP_WritePhyUshort(sc, 0x15, 0x02cf);
14695         MP_WritePhyUshort(sc, 0x19, 0x4cc0);
14696         MP_WritePhyUshort(sc, 0x15, 0x02d0);
14697         MP_WritePhyUshort(sc, 0x19, 0xc4d4);
14698         MP_WritePhyUshort(sc, 0x15, 0x02d1);
14699         MP_WritePhyUshort(sc, 0x19, 0x00f9);
14700         MP_WritePhyUshort(sc, 0x15, 0x02d2);
14701         MP_WritePhyUshort(sc, 0x19, 0xa51a);
14702         MP_WritePhyUshort(sc, 0x15, 0x02d3);
14703         MP_WritePhyUshort(sc, 0x19, 0x32d9);
14704         MP_WritePhyUshort(sc, 0x15, 0x02d4);
14705         MP_WritePhyUshort(sc, 0x19, 0x0000);
14706         MP_WritePhyUshort(sc, 0x15, 0x02d5);
14707         MP_WritePhyUshort(sc, 0x19, 0x0000);
14708         MP_WritePhyUshort(sc, 0x15, 0x02d6);
14709         MP_WritePhyUshort(sc, 0x19, 0x0000);
14710         MP_WritePhyUshort(sc, 0x15, 0x02d7);
14711         MP_WritePhyUshort(sc, 0x19, 0x0000);
14712         MP_WritePhyUshort(sc, 0x15, 0x02d8);
14713         MP_WritePhyUshort(sc, 0x19, 0x0000);
14714         MP_WritePhyUshort(sc, 0x15, 0x02d9);
14715         MP_WritePhyUshort(sc, 0x19, 0x48b3);
14716         MP_WritePhyUshort(sc, 0x15, 0x02da);
14717         MP_WritePhyUshort(sc, 0x19, 0x4020);
14718         MP_WritePhyUshort(sc, 0x15, 0x02db);
14719         MP_WritePhyUshort(sc, 0x19, 0x4823);
14720         MP_WritePhyUshort(sc, 0x15, 0x02dc);
14721         MP_WritePhyUshort(sc, 0x19, 0x4410);
14722         MP_WritePhyUshort(sc, 0x15, 0x02dd);
14723         MP_WritePhyUshort(sc, 0x19, 0xb630);
14724         MP_WritePhyUshort(sc, 0x15, 0x02de);
14725         MP_WritePhyUshort(sc, 0x19, 0x7dc8);
14726         MP_WritePhyUshort(sc, 0x15, 0x02df);
14727         MP_WritePhyUshort(sc, 0x19, 0x8203);
14728         MP_WritePhyUshort(sc, 0x15, 0x02e0);
14729         MP_WritePhyUshort(sc, 0x19, 0x4c48);
14730         MP_WritePhyUshort(sc, 0x15, 0x02e1);
14731         MP_WritePhyUshort(sc, 0x19, 0x32e3);
14732         MP_WritePhyUshort(sc, 0x15, 0x02e2);
14733         MP_WritePhyUshort(sc, 0x19, 0x4c40);
14734         MP_WritePhyUshort(sc, 0x15, 0x02e3);
14735         MP_WritePhyUshort(sc, 0x19, 0x9bfa);
14736         MP_WritePhyUshort(sc, 0x15, 0x02e4);
14737         MP_WritePhyUshort(sc, 0x19, 0x84ca);
14738         MP_WritePhyUshort(sc, 0x15, 0x02e5);
14739         MP_WritePhyUshort(sc, 0x19, 0x85f8);
14740         MP_WritePhyUshort(sc, 0x15, 0x02e6);
14741         MP_WritePhyUshort(sc, 0x19, 0x32ec);
14742         MP_WritePhyUshort(sc, 0x15, 0x02e7);
14743         MP_WritePhyUshort(sc, 0x19, 0x0000);
14744         MP_WritePhyUshort(sc, 0x15, 0x02e8);
14745         MP_WritePhyUshort(sc, 0x19, 0x0000);
14746         MP_WritePhyUshort(sc, 0x15, 0x02e9);
14747         MP_WritePhyUshort(sc, 0x19, 0x0000);
14748         MP_WritePhyUshort(sc, 0x15, 0x02ea);
14749         MP_WritePhyUshort(sc, 0x19, 0x0000);
14750         MP_WritePhyUshort(sc, 0x15, 0x02eb);
14751         MP_WritePhyUshort(sc, 0x19, 0x0000);
14752         MP_WritePhyUshort(sc, 0x15, 0x02ec);
14753         MP_WritePhyUshort(sc, 0x19, 0x48d4);
14754         MP_WritePhyUshort(sc, 0x15, 0x02ed);
14755         MP_WritePhyUshort(sc, 0x19, 0x4020);
14756         MP_WritePhyUshort(sc, 0x15, 0x02ee);
14757         MP_WritePhyUshort(sc, 0x19, 0x4844);
14758         MP_WritePhyUshort(sc, 0x15, 0x02ef);
14759         MP_WritePhyUshort(sc, 0x19, 0x4420);
14760         MP_WritePhyUshort(sc, 0x15, 0x02f0);
14761         MP_WritePhyUshort(sc, 0x19, 0x6800);
14762         MP_WritePhyUshort(sc, 0x15, 0x02f1);
14763         MP_WritePhyUshort(sc, 0x19, 0x7dc0);
14764         MP_WritePhyUshort(sc, 0x15, 0x02f2);
14765         MP_WritePhyUshort(sc, 0x19, 0x4c40);
14766         MP_WritePhyUshort(sc, 0x15, 0x02f3);
14767         MP_WritePhyUshort(sc, 0x19, 0x7c0b);
14768         MP_WritePhyUshort(sc, 0x15, 0x02f4);
14769         MP_WritePhyUshort(sc, 0x19, 0x6c08);
14770         MP_WritePhyUshort(sc, 0x15, 0x02f5);
14771         MP_WritePhyUshort(sc, 0x19, 0x3311);
14772         MP_WritePhyUshort(sc, 0x15, 0x02f6);
14773         MP_WritePhyUshort(sc, 0x19, 0x9cfd);
14774         MP_WritePhyUshort(sc, 0x15, 0x02f7);
14775         MP_WritePhyUshort(sc, 0x19, 0xb616);
14776         MP_WritePhyUshort(sc, 0x15, 0x02f8);
14777         MP_WritePhyUshort(sc, 0x19, 0xc42b);
14778         MP_WritePhyUshort(sc, 0x15, 0x02f9);
14779         MP_WritePhyUshort(sc, 0x19, 0x00e0);
14780         MP_WritePhyUshort(sc, 0x15, 0x02fa);
14781         MP_WritePhyUshort(sc, 0x19, 0xc455);
14782         MP_WritePhyUshort(sc, 0x15, 0x02fb);
14783         MP_WritePhyUshort(sc, 0x19, 0x00b3);
14784         MP_WritePhyUshort(sc, 0x15, 0x02fc);
14785         MP_WritePhyUshort(sc, 0x19, 0xb20a);
14786         MP_WritePhyUshort(sc, 0x15, 0x02fd);
14787         MP_WritePhyUshort(sc, 0x19, 0x7c03);
14788         MP_WritePhyUshort(sc, 0x15, 0x02fe);
14789         MP_WritePhyUshort(sc, 0x19, 0x6c02);
14790         MP_WritePhyUshort(sc, 0x15, 0x02ff);
14791         MP_WritePhyUshort(sc, 0x19, 0x8204);
14792         MP_WritePhyUshort(sc, 0x15, 0x0300);
14793         MP_WritePhyUshort(sc, 0x19, 0x7c04);
14794         MP_WritePhyUshort(sc, 0x15, 0x0301);
14795         MP_WritePhyUshort(sc, 0x19, 0x7404);
14796         MP_WritePhyUshort(sc, 0x15, 0x0302);
14797         MP_WritePhyUshort(sc, 0x19, 0x32f3);
14798         MP_WritePhyUshort(sc, 0x15, 0x0303);
14799         MP_WritePhyUshort(sc, 0x19, 0x7c04);
14800         MP_WritePhyUshort(sc, 0x15, 0x0304);
14801         MP_WritePhyUshort(sc, 0x19, 0x7400);
14802         MP_WritePhyUshort(sc, 0x15, 0x0305);
14803         MP_WritePhyUshort(sc, 0x19, 0x32f3);
14804         MP_WritePhyUshort(sc, 0x15, 0x0306);
14805         MP_WritePhyUshort(sc, 0x19, 0xefed);
14806         MP_WritePhyUshort(sc, 0x15, 0x0307);
14807         MP_WritePhyUshort(sc, 0x19, 0x3342);
14808         MP_WritePhyUshort(sc, 0x15, 0x0308);
14809         MP_WritePhyUshort(sc, 0x19, 0x0000);
14810         MP_WritePhyUshort(sc, 0x15, 0x0309);
14811         MP_WritePhyUshort(sc, 0x19, 0x0000);
14812         MP_WritePhyUshort(sc, 0x15, 0x030a);
14813         MP_WritePhyUshort(sc, 0x19, 0x0000);
14814         MP_WritePhyUshort(sc, 0x15, 0x030b);
14815         MP_WritePhyUshort(sc, 0x19, 0x0000);
14816         MP_WritePhyUshort(sc, 0x15, 0x030c);
14817         MP_WritePhyUshort(sc, 0x19, 0x0000);
14818         MP_WritePhyUshort(sc, 0x15, 0x030d);
14819         MP_WritePhyUshort(sc, 0x19, 0x3006);
14820         MP_WritePhyUshort(sc, 0x15, 0x030e);
14821         MP_WritePhyUshort(sc, 0x19, 0x0000);
14822         MP_WritePhyUshort(sc, 0x15, 0x030f);
14823         MP_WritePhyUshort(sc, 0x19, 0x0000);
14824         MP_WritePhyUshort(sc, 0x15, 0x0310);
14825         MP_WritePhyUshort(sc, 0x19, 0x0000);
14826         MP_WritePhyUshort(sc, 0x15, 0x0311);
14827         MP_WritePhyUshort(sc, 0x19, 0x7c08);
14828         MP_WritePhyUshort(sc, 0x15, 0x0312);
14829         MP_WritePhyUshort(sc, 0x19, 0xa207);
14830         MP_WritePhyUshort(sc, 0x15, 0x0313);
14831         MP_WritePhyUshort(sc, 0x19, 0x4c00);
14832         MP_WritePhyUshort(sc, 0x15, 0x0314);
14833         MP_WritePhyUshort(sc, 0x19, 0x3322);
14834         MP_WritePhyUshort(sc, 0x15, 0x0315);
14835         MP_WritePhyUshort(sc, 0x19, 0x4041);
14836         MP_WritePhyUshort(sc, 0x15, 0x0316);
14837         MP_WritePhyUshort(sc, 0x19, 0x7d07);
14838         MP_WritePhyUshort(sc, 0x15, 0x0317);
14839         MP_WritePhyUshort(sc, 0x19, 0x4502);
14840         MP_WritePhyUshort(sc, 0x15, 0x0318);
14841         MP_WritePhyUshort(sc, 0x19, 0x3322);
14842         MP_WritePhyUshort(sc, 0x15, 0x0319);
14843         MP_WritePhyUshort(sc, 0x19, 0x4c08);
14844         MP_WritePhyUshort(sc, 0x15, 0x031a);
14845         MP_WritePhyUshort(sc, 0x19, 0x3322);
14846         MP_WritePhyUshort(sc, 0x15, 0x031b);
14847         MP_WritePhyUshort(sc, 0x19, 0x7d80);
14848         MP_WritePhyUshort(sc, 0x15, 0x031c);
14849         MP_WritePhyUshort(sc, 0x19, 0x5180);
14850         MP_WritePhyUshort(sc, 0x15, 0x031d);
14851         MP_WritePhyUshort(sc, 0x19, 0x3320);
14852         MP_WritePhyUshort(sc, 0x15, 0x031e);
14853         MP_WritePhyUshort(sc, 0x19, 0x7d80);
14854         MP_WritePhyUshort(sc, 0x15, 0x031f);
14855         MP_WritePhyUshort(sc, 0x19, 0x5000);
14856         MP_WritePhyUshort(sc, 0x15, 0x0320);
14857         MP_WritePhyUshort(sc, 0x19, 0x7d07);
14858         MP_WritePhyUshort(sc, 0x15, 0x0321);
14859         MP_WritePhyUshort(sc, 0x19, 0x4402);
14860         MP_WritePhyUshort(sc, 0x15, 0x0322);
14861         MP_WritePhyUshort(sc, 0x19, 0x7c03);
14862         MP_WritePhyUshort(sc, 0x15, 0x0323);
14863         MP_WritePhyUshort(sc, 0x19, 0x6c02);
14864         MP_WritePhyUshort(sc, 0x15, 0x0324);
14865         MP_WritePhyUshort(sc, 0x19, 0x7c03);
14866         MP_WritePhyUshort(sc, 0x15, 0x0325);
14867         MP_WritePhyUshort(sc, 0x19, 0xb30c);
14868         MP_WritePhyUshort(sc, 0x15, 0x0326);
14869         MP_WritePhyUshort(sc, 0x19, 0xb206);
14870         MP_WritePhyUshort(sc, 0x15, 0x0327);
14871         MP_WritePhyUshort(sc, 0x19, 0xb103);
14872         MP_WritePhyUshort(sc, 0x15, 0x0328);
14873         MP_WritePhyUshort(sc, 0x19, 0x6c00);
14874         MP_WritePhyUshort(sc, 0x15, 0x0329);
14875         MP_WritePhyUshort(sc, 0x19, 0x32f6);
14876         MP_WritePhyUshort(sc, 0x15, 0x032a);
14877         MP_WritePhyUshort(sc, 0x19, 0x6c00);
14878         MP_WritePhyUshort(sc, 0x15, 0x032b);
14879         MP_WritePhyUshort(sc, 0x19, 0x3352);
14880         MP_WritePhyUshort(sc, 0x15, 0x032c);
14881         MP_WritePhyUshort(sc, 0x19, 0xb103);
14882         MP_WritePhyUshort(sc, 0x15, 0x032d);
14883         MP_WritePhyUshort(sc, 0x19, 0x6c00);
14884         MP_WritePhyUshort(sc, 0x15, 0x032e);
14885         MP_WritePhyUshort(sc, 0x19, 0x336a);
14886         MP_WritePhyUshort(sc, 0x15, 0x032f);
14887         MP_WritePhyUshort(sc, 0x19, 0x6c00);
14888         MP_WritePhyUshort(sc, 0x15, 0x0330);
14889         MP_WritePhyUshort(sc, 0x19, 0x3382);
14890         MP_WritePhyUshort(sc, 0x15, 0x0331);
14891         MP_WritePhyUshort(sc, 0x19, 0xb206);
14892         MP_WritePhyUshort(sc, 0x15, 0x0332);
14893         MP_WritePhyUshort(sc, 0x19, 0xb103);
14894         MP_WritePhyUshort(sc, 0x15, 0x0333);
14895         MP_WritePhyUshort(sc, 0x19, 0x6c00);
14896         MP_WritePhyUshort(sc, 0x15, 0x0334);
14897         MP_WritePhyUshort(sc, 0x19, 0x3395);
14898         MP_WritePhyUshort(sc, 0x15, 0x0335);
14899         MP_WritePhyUshort(sc, 0x19, 0x6c00);
14900         MP_WritePhyUshort(sc, 0x15, 0x0336);
14901         MP_WritePhyUshort(sc, 0x19, 0x33c6);
14902         MP_WritePhyUshort(sc, 0x15, 0x0337);
14903         MP_WritePhyUshort(sc, 0x19, 0xb103);
14904         MP_WritePhyUshort(sc, 0x15, 0x0338);
14905         MP_WritePhyUshort(sc, 0x19, 0x6c00);
14906         MP_WritePhyUshort(sc, 0x15, 0x0339);
14907         MP_WritePhyUshort(sc, 0x19, 0x33d7);
14908         MP_WritePhyUshort(sc, 0x15, 0x033a);
14909         MP_WritePhyUshort(sc, 0x19, 0x6c00);
14910         MP_WritePhyUshort(sc, 0x15, 0x033b);
14911         MP_WritePhyUshort(sc, 0x19, 0x33f2);
14912         MP_WritePhyUshort(sc, 0x15, 0x033c);
14913         MP_WritePhyUshort(sc, 0x19, 0x0000);
14914         MP_WritePhyUshort(sc, 0x15, 0x033d);
14915         MP_WritePhyUshort(sc, 0x19, 0x0000);
14916         MP_WritePhyUshort(sc, 0x15, 0x033e);
14917         MP_WritePhyUshort(sc, 0x19, 0x0000);
14918         MP_WritePhyUshort(sc, 0x15, 0x033f);
14919         MP_WritePhyUshort(sc, 0x19, 0x0000);
14920         MP_WritePhyUshort(sc, 0x15, 0x0340);
14921         MP_WritePhyUshort(sc, 0x19, 0x0000);
14922         MP_WritePhyUshort(sc, 0x15, 0x0341);
14923         MP_WritePhyUshort(sc, 0x19, 0x0000);
14924         MP_WritePhyUshort(sc, 0x15, 0x0342);
14925         MP_WritePhyUshort(sc, 0x19, 0x49b5);
14926         MP_WritePhyUshort(sc, 0x15, 0x0343);
14927         MP_WritePhyUshort(sc, 0x19, 0x7d00);
14928         MP_WritePhyUshort(sc, 0x15, 0x0344);
14929         MP_WritePhyUshort(sc, 0x19, 0x4d00);
14930         MP_WritePhyUshort(sc, 0x15, 0x0345);
14931         MP_WritePhyUshort(sc, 0x19, 0x6880);
14932         MP_WritePhyUshort(sc, 0x15, 0x0346);
14933         MP_WritePhyUshort(sc, 0x19, 0x7c08);
14934         MP_WritePhyUshort(sc, 0x15, 0x0347);
14935         MP_WritePhyUshort(sc, 0x19, 0x6c08);
14936         MP_WritePhyUshort(sc, 0x15, 0x0348);
14937         MP_WritePhyUshort(sc, 0x19, 0x4925);
14938         MP_WritePhyUshort(sc, 0x15, 0x0349);
14939         MP_WritePhyUshort(sc, 0x19, 0x403b);
14940         MP_WritePhyUshort(sc, 0x15, 0x034a);
14941         MP_WritePhyUshort(sc, 0x19, 0xa602);
14942         MP_WritePhyUshort(sc, 0x15, 0x034b);
14943         MP_WritePhyUshort(sc, 0x19, 0x402f);
14944         MP_WritePhyUshort(sc, 0x15, 0x034c);
14945         MP_WritePhyUshort(sc, 0x19, 0x4484);
14946         MP_WritePhyUshort(sc, 0x15, 0x034d);
14947         MP_WritePhyUshort(sc, 0x19, 0x40c8);
14948         MP_WritePhyUshort(sc, 0x15, 0x034e);
14949         MP_WritePhyUshort(sc, 0x19, 0x44c4);
14950         MP_WritePhyUshort(sc, 0x15, 0x034f);
14951         MP_WritePhyUshort(sc, 0x19, 0xd64f);
14952         MP_WritePhyUshort(sc, 0x15, 0x0350);
14953         MP_WritePhyUshort(sc, 0x19, 0x00bd);
14954         MP_WritePhyUshort(sc, 0x15, 0x0351);
14955         MP_WritePhyUshort(sc, 0x19, 0x3311);
14956         MP_WritePhyUshort(sc, 0x15, 0x0352);
14957         MP_WritePhyUshort(sc, 0x19, 0xc8ed);
14958         MP_WritePhyUshort(sc, 0x15, 0x0353);
14959         MP_WritePhyUshort(sc, 0x19, 0x00fc);
14960         MP_WritePhyUshort(sc, 0x15, 0x0354);
14961         MP_WritePhyUshort(sc, 0x19, 0x8221);
14962         MP_WritePhyUshort(sc, 0x15, 0x0355);
14963         MP_WritePhyUshort(sc, 0x19, 0xd11d);
14964         MP_WritePhyUshort(sc, 0x15, 0x0356);
14965         MP_WritePhyUshort(sc, 0x19, 0x001f);
14966         MP_WritePhyUshort(sc, 0x15, 0x0357);
14967         MP_WritePhyUshort(sc, 0x19, 0xde18);
14968         MP_WritePhyUshort(sc, 0x15, 0x0358);
14969         MP_WritePhyUshort(sc, 0x19, 0x0008);
14970         MP_WritePhyUshort(sc, 0x15, 0x0359);
14971         MP_WritePhyUshort(sc, 0x19, 0x91f6);
14972         MP_WritePhyUshort(sc, 0x15, 0x035a);
14973         MP_WritePhyUshort(sc, 0x19, 0x3360);
14974         MP_WritePhyUshort(sc, 0x15, 0x035b);
14975         MP_WritePhyUshort(sc, 0x19, 0x0000);
14976         MP_WritePhyUshort(sc, 0x15, 0x035c);
14977         MP_WritePhyUshort(sc, 0x19, 0x0000);
14978         MP_WritePhyUshort(sc, 0x15, 0x035d);
14979         MP_WritePhyUshort(sc, 0x19, 0x0000);
14980         MP_WritePhyUshort(sc, 0x15, 0x035e);
14981         MP_WritePhyUshort(sc, 0x19, 0x0000);
14982         MP_WritePhyUshort(sc, 0x15, 0x035f);
14983         MP_WritePhyUshort(sc, 0x19, 0x0000);
14984         MP_WritePhyUshort(sc, 0x15, 0x0360);
14985         MP_WritePhyUshort(sc, 0x19, 0x4bb6);
14986         MP_WritePhyUshort(sc, 0x15, 0x0361);
14987         MP_WritePhyUshort(sc, 0x19, 0x4064);
14988         MP_WritePhyUshort(sc, 0x15, 0x0362);
14989         MP_WritePhyUshort(sc, 0x19, 0x4b26);
14990         MP_WritePhyUshort(sc, 0x15, 0x0363);
14991         MP_WritePhyUshort(sc, 0x19, 0x4410);
14992         MP_WritePhyUshort(sc, 0x15, 0x0364);
14993         MP_WritePhyUshort(sc, 0x19, 0x4006);
14994         MP_WritePhyUshort(sc, 0x15, 0x0365);
14995         MP_WritePhyUshort(sc, 0x19, 0x4490);
14996         MP_WritePhyUshort(sc, 0x15, 0x0366);
14997         MP_WritePhyUshort(sc, 0x19, 0x6900);
14998         MP_WritePhyUshort(sc, 0x15, 0x0367);
14999         MP_WritePhyUshort(sc, 0x19, 0xb6a6);
15000         MP_WritePhyUshort(sc, 0x15, 0x0368);
15001         MP_WritePhyUshort(sc, 0x19, 0x9e02);
15002         MP_WritePhyUshort(sc, 0x15, 0x0369);
15003         MP_WritePhyUshort(sc, 0x19, 0x3311);
15004         MP_WritePhyUshort(sc, 0x15, 0x036a);
15005         MP_WritePhyUshort(sc, 0x19, 0xd11d);
15006         MP_WritePhyUshort(sc, 0x15, 0x036b);
15007         MP_WritePhyUshort(sc, 0x19, 0x000a);
15008         MP_WritePhyUshort(sc, 0x15, 0x036c);
15009         MP_WritePhyUshort(sc, 0x19, 0xbb0f);
15010         MP_WritePhyUshort(sc, 0x15, 0x036d);
15011         MP_WritePhyUshort(sc, 0x19, 0x8102);
15012         MP_WritePhyUshort(sc, 0x15, 0x036e);
15013         MP_WritePhyUshort(sc, 0x19, 0x3371);
15014         MP_WritePhyUshort(sc, 0x15, 0x036f);
15015         MP_WritePhyUshort(sc, 0x19, 0xa21e);
15016         MP_WritePhyUshort(sc, 0x15, 0x0370);
15017         MP_WritePhyUshort(sc, 0x19, 0x33b6);
15018         MP_WritePhyUshort(sc, 0x15, 0x0371);
15019         MP_WritePhyUshort(sc, 0x19, 0x91f6);
15020         MP_WritePhyUshort(sc, 0x15, 0x0372);
15021         MP_WritePhyUshort(sc, 0x19, 0xc218);
15022         MP_WritePhyUshort(sc, 0x15, 0x0373);
15023         MP_WritePhyUshort(sc, 0x19, 0x00f4);
15024         MP_WritePhyUshort(sc, 0x15, 0x0374);
15025         MP_WritePhyUshort(sc, 0x19, 0x33b6);
15026         MP_WritePhyUshort(sc, 0x15, 0x0375);
15027         MP_WritePhyUshort(sc, 0x19, 0x32ec);
15028         MP_WritePhyUshort(sc, 0x15, 0x0376);
15029         MP_WritePhyUshort(sc, 0x19, 0x0000);
15030         MP_WritePhyUshort(sc, 0x15, 0x0377);
15031         MP_WritePhyUshort(sc, 0x19, 0x0000);
15032         MP_WritePhyUshort(sc, 0x15, 0x0378);
15033         MP_WritePhyUshort(sc, 0x19, 0x0000);
15034         MP_WritePhyUshort(sc, 0x15, 0x0379);
15035         MP_WritePhyUshort(sc, 0x19, 0x0000);
15036         MP_WritePhyUshort(sc, 0x15, 0x037a);
15037         MP_WritePhyUshort(sc, 0x19, 0x0000);
15038         MP_WritePhyUshort(sc, 0x15, 0x037b);
15039         MP_WritePhyUshort(sc, 0x19, 0x4b97);
15040         MP_WritePhyUshort(sc, 0x15, 0x037c);
15041         MP_WritePhyUshort(sc, 0x19, 0x402b);
15042         MP_WritePhyUshort(sc, 0x15, 0x037d);
15043         MP_WritePhyUshort(sc, 0x19, 0x4b07);
15044         MP_WritePhyUshort(sc, 0x15, 0x037e);
15045         MP_WritePhyUshort(sc, 0x19, 0x4422);
15046         MP_WritePhyUshort(sc, 0x15, 0x037f);
15047         MP_WritePhyUshort(sc, 0x19, 0x6980);
15048         MP_WritePhyUshort(sc, 0x15, 0x0380);
15049         MP_WritePhyUshort(sc, 0x19, 0xb608);
15050         MP_WritePhyUshort(sc, 0x15, 0x0381);
15051         MP_WritePhyUshort(sc, 0x19, 0x3311);
15052         MP_WritePhyUshort(sc, 0x15, 0x0382);
15053         MP_WritePhyUshort(sc, 0x19, 0xbc05);
15054         MP_WritePhyUshort(sc, 0x15, 0x0383);
15055         MP_WritePhyUshort(sc, 0x19, 0xc21c);
15056         MP_WritePhyUshort(sc, 0x15, 0x0384);
15057         MP_WritePhyUshort(sc, 0x19, 0x0032);
15058         MP_WritePhyUshort(sc, 0x15, 0x0385);
15059         MP_WritePhyUshort(sc, 0x19, 0xa1fb);
15060         MP_WritePhyUshort(sc, 0x15, 0x0386);
15061         MP_WritePhyUshort(sc, 0x19, 0x338d);
15062         MP_WritePhyUshort(sc, 0x15, 0x0387);
15063         MP_WritePhyUshort(sc, 0x19, 0x32ae);
15064         MP_WritePhyUshort(sc, 0x15, 0x0388);
15065         MP_WritePhyUshort(sc, 0x19, 0x330d);
15066         MP_WritePhyUshort(sc, 0x15, 0x0389);
15067         MP_WritePhyUshort(sc, 0x19, 0x0000);
15068         MP_WritePhyUshort(sc, 0x15, 0x038a);
15069         MP_WritePhyUshort(sc, 0x19, 0x0000);
15070         MP_WritePhyUshort(sc, 0x15, 0x038b);
15071         MP_WritePhyUshort(sc, 0x19, 0x0000);
15072         MP_WritePhyUshort(sc, 0x15, 0x038c);
15073         MP_WritePhyUshort(sc, 0x19, 0x0000);
15074         MP_WritePhyUshort(sc, 0x15, 0x038d);
15075         MP_WritePhyUshort(sc, 0x19, 0x4b97);
15076         MP_WritePhyUshort(sc, 0x15, 0x038e);
15077         MP_WritePhyUshort(sc, 0x19, 0x6a08);
15078         MP_WritePhyUshort(sc, 0x15, 0x038f);
15079         MP_WritePhyUshort(sc, 0x19, 0x4b07);
15080         MP_WritePhyUshort(sc, 0x15, 0x0390);
15081         MP_WritePhyUshort(sc, 0x19, 0x40ac);
15082         MP_WritePhyUshort(sc, 0x15, 0x0391);
15083         MP_WritePhyUshort(sc, 0x19, 0x4445);
15084         MP_WritePhyUshort(sc, 0x15, 0x0392);
15085         MP_WritePhyUshort(sc, 0x19, 0x404e);
15086         MP_WritePhyUshort(sc, 0x15, 0x0393);
15087         MP_WritePhyUshort(sc, 0x19, 0x4461);
15088         MP_WritePhyUshort(sc, 0x15, 0x0394);
15089         MP_WritePhyUshort(sc, 0x19, 0x3311);
15090         MP_WritePhyUshort(sc, 0x15, 0x0395);
15091         MP_WritePhyUshort(sc, 0x19, 0x9c0a);
15092         MP_WritePhyUshort(sc, 0x15, 0x0396);
15093         MP_WritePhyUshort(sc, 0x19, 0x63da);
15094         MP_WritePhyUshort(sc, 0x15, 0x0397);
15095         MP_WritePhyUshort(sc, 0x19, 0x6f0c);
15096         MP_WritePhyUshort(sc, 0x15, 0x0398);
15097         MP_WritePhyUshort(sc, 0x19, 0x5440);
15098         MP_WritePhyUshort(sc, 0x15, 0x0399);
15099         MP_WritePhyUshort(sc, 0x19, 0x4b98);
15100         MP_WritePhyUshort(sc, 0x15, 0x039a);
15101         MP_WritePhyUshort(sc, 0x19, 0x7c40);
15102         MP_WritePhyUshort(sc, 0x15, 0x039b);
15103         MP_WritePhyUshort(sc, 0x19, 0x4c00);
15104         MP_WritePhyUshort(sc, 0x15, 0x039c);
15105         MP_WritePhyUshort(sc, 0x19, 0x4b08);
15106         MP_WritePhyUshort(sc, 0x15, 0x039d);
15107         MP_WritePhyUshort(sc, 0x19, 0x63d8);
15108         MP_WritePhyUshort(sc, 0x15, 0x039e);
15109         MP_WritePhyUshort(sc, 0x19, 0x33a5);
15110         MP_WritePhyUshort(sc, 0x15, 0x039f);
15111         MP_WritePhyUshort(sc, 0x19, 0xd64f);
15112         MP_WritePhyUshort(sc, 0x15, 0x03a0);
15113         MP_WritePhyUshort(sc, 0x19, 0x00e8);
15114         MP_WritePhyUshort(sc, 0x15, 0x03a1);
15115         MP_WritePhyUshort(sc, 0x19, 0x820e);
15116         MP_WritePhyUshort(sc, 0x15, 0x03a2);
15117         MP_WritePhyUshort(sc, 0x19, 0xa10d);
15118         MP_WritePhyUshort(sc, 0x15, 0x03a3);
15119         MP_WritePhyUshort(sc, 0x19, 0x9df1);
15120         MP_WritePhyUshort(sc, 0x15, 0x03a4);
15121         MP_WritePhyUshort(sc, 0x19, 0x33af);
15122         MP_WritePhyUshort(sc, 0x15, 0x03a5);
15123         MP_WritePhyUshort(sc, 0x19, 0xd64f);
15124         MP_WritePhyUshort(sc, 0x15, 0x03a6);
15125         MP_WritePhyUshort(sc, 0x19, 0x00f9);
15126         MP_WritePhyUshort(sc, 0x15, 0x03a7);
15127         MP_WritePhyUshort(sc, 0x19, 0xc017);
15128         MP_WritePhyUshort(sc, 0x15, 0x03a8);
15129         MP_WritePhyUshort(sc, 0x19, 0x0007);
15130         MP_WritePhyUshort(sc, 0x15, 0x03a9);
15131         MP_WritePhyUshort(sc, 0x19, 0x7c03);
15132         MP_WritePhyUshort(sc, 0x15, 0x03aa);
15133         MP_WritePhyUshort(sc, 0x19, 0x6c03);
15134         MP_WritePhyUshort(sc, 0x15, 0x03ab);
15135         MP_WritePhyUshort(sc, 0x19, 0xa104);
15136         MP_WritePhyUshort(sc, 0x15, 0x03ac);
15137         MP_WritePhyUshort(sc, 0x19, 0x7c03);
15138         MP_WritePhyUshort(sc, 0x15, 0x03ad);
15139         MP_WritePhyUshort(sc, 0x19, 0x6c00);
15140         MP_WritePhyUshort(sc, 0x15, 0x03ae);
15141         MP_WritePhyUshort(sc, 0x19, 0x9df7);
15142         MP_WritePhyUshort(sc, 0x15, 0x03af);
15143         MP_WritePhyUshort(sc, 0x19, 0x7c03);
15144         MP_WritePhyUshort(sc, 0x15, 0x03b0);
15145         MP_WritePhyUshort(sc, 0x19, 0x6c08);
15146         MP_WritePhyUshort(sc, 0x15, 0x03b1);
15147         MP_WritePhyUshort(sc, 0x19, 0x33b6);
15148         MP_WritePhyUshort(sc, 0x15, 0x03b2);
15149         MP_WritePhyUshort(sc, 0x19, 0x0000);
15150         MP_WritePhyUshort(sc, 0x15, 0x03b3);
15151         MP_WritePhyUshort(sc, 0x19, 0x0000);
15152         MP_WritePhyUshort(sc, 0x15, 0x03b4);
15153         MP_WritePhyUshort(sc, 0x19, 0x0000);
15154         MP_WritePhyUshort(sc, 0x15, 0x03b5);
15155         MP_WritePhyUshort(sc, 0x19, 0x0000);
15156         MP_WritePhyUshort(sc, 0x15, 0x03b6);
15157         MP_WritePhyUshort(sc, 0x19, 0x55af);
15158         MP_WritePhyUshort(sc, 0x15, 0x03b7);
15159         MP_WritePhyUshort(sc, 0x19, 0x7ff0);
15160         MP_WritePhyUshort(sc, 0x15, 0x03b8);
15161         MP_WritePhyUshort(sc, 0x19, 0x6ff0);
15162         MP_WritePhyUshort(sc, 0x15, 0x03b9);
15163         MP_WritePhyUshort(sc, 0x19, 0x4bb9);
15164         MP_WritePhyUshort(sc, 0x15, 0x03ba);
15165         MP_WritePhyUshort(sc, 0x19, 0x6a80);
15166         MP_WritePhyUshort(sc, 0x15, 0x03bb);
15167         MP_WritePhyUshort(sc, 0x19, 0x4b29);
15168         MP_WritePhyUshort(sc, 0x15, 0x03bc);
15169         MP_WritePhyUshort(sc, 0x19, 0x4041);
15170         MP_WritePhyUshort(sc, 0x15, 0x03bd);
15171         MP_WritePhyUshort(sc, 0x19, 0x440a);
15172         MP_WritePhyUshort(sc, 0x15, 0x03be);
15173         MP_WritePhyUshort(sc, 0x19, 0x4029);
15174         MP_WritePhyUshort(sc, 0x15, 0x03bf);
15175         MP_WritePhyUshort(sc, 0x19, 0x4418);
15176         MP_WritePhyUshort(sc, 0x15, 0x03c0);
15177         MP_WritePhyUshort(sc, 0x19, 0x4090);
15178         MP_WritePhyUshort(sc, 0x15, 0x03c1);
15179         MP_WritePhyUshort(sc, 0x19, 0x4438);
15180         MP_WritePhyUshort(sc, 0x15, 0x03c2);
15181         MP_WritePhyUshort(sc, 0x19, 0x40c4);
15182         MP_WritePhyUshort(sc, 0x15, 0x03c3);
15183         MP_WritePhyUshort(sc, 0x19, 0x447b);
15184         MP_WritePhyUshort(sc, 0x15, 0x03c4);
15185         MP_WritePhyUshort(sc, 0x19, 0xb6c4);
15186         MP_WritePhyUshort(sc, 0x15, 0x03c5);
15187         MP_WritePhyUshort(sc, 0x19, 0x3311);
15188         MP_WritePhyUshort(sc, 0x15, 0x03c6);
15189         MP_WritePhyUshort(sc, 0x19, 0x9bfe);
15190         MP_WritePhyUshort(sc, 0x15, 0x03c7);
15191         MP_WritePhyUshort(sc, 0x19, 0x33cc);
15192         MP_WritePhyUshort(sc, 0x15, 0x03c8);
15193         MP_WritePhyUshort(sc, 0x19, 0x0000);
15194         MP_WritePhyUshort(sc, 0x15, 0x03c9);
15195         MP_WritePhyUshort(sc, 0x19, 0x0000);
15196         MP_WritePhyUshort(sc, 0x15, 0x03ca);
15197         MP_WritePhyUshort(sc, 0x19, 0x0000);
15198         MP_WritePhyUshort(sc, 0x15, 0x03cb);
15199         MP_WritePhyUshort(sc, 0x19, 0x0000);
15200         MP_WritePhyUshort(sc, 0x15, 0x03cc);
15201         MP_WritePhyUshort(sc, 0x19, 0x542f);
15202         MP_WritePhyUshort(sc, 0x15, 0x03cd);
15203         MP_WritePhyUshort(sc, 0x19, 0x499a);
15204         MP_WritePhyUshort(sc, 0x15, 0x03ce);
15205         MP_WritePhyUshort(sc, 0x19, 0x7c40);
15206         MP_WritePhyUshort(sc, 0x15, 0x03cf);
15207         MP_WritePhyUshort(sc, 0x19, 0x4c40);
15208         MP_WritePhyUshort(sc, 0x15, 0x03d0);
15209         MP_WritePhyUshort(sc, 0x19, 0x490a);
15210         MP_WritePhyUshort(sc, 0x15, 0x03d1);
15211         MP_WritePhyUshort(sc, 0x19, 0x405e);
15212         MP_WritePhyUshort(sc, 0x15, 0x03d2);
15213         MP_WritePhyUshort(sc, 0x19, 0x44f8);
15214         MP_WritePhyUshort(sc, 0x15, 0x03d3);
15215         MP_WritePhyUshort(sc, 0x19, 0x6b00);
15216         MP_WritePhyUshort(sc, 0x15, 0x03d4);
15217         MP_WritePhyUshort(sc, 0x19, 0xd64f);
15218         MP_WritePhyUshort(sc, 0x15, 0x03d5);
15219         MP_WritePhyUshort(sc, 0x19, 0x0028);
15220         MP_WritePhyUshort(sc, 0x15, 0x03d6);
15221         MP_WritePhyUshort(sc, 0x19, 0x3311);
15222         MP_WritePhyUshort(sc, 0x15, 0x03d7);
15223         MP_WritePhyUshort(sc, 0x19, 0xbd27);
15224         MP_WritePhyUshort(sc, 0x15, 0x03d8);
15225         MP_WritePhyUshort(sc, 0x19, 0x9cfc);
15226         MP_WritePhyUshort(sc, 0x15, 0x03d9);
15227         MP_WritePhyUshort(sc, 0x19, 0xc639);
15228         MP_WritePhyUshort(sc, 0x15, 0x03da);
15229         MP_WritePhyUshort(sc, 0x19, 0x000f);
15230         MP_WritePhyUshort(sc, 0x15, 0x03db);
15231         MP_WritePhyUshort(sc, 0x19, 0x9e03);
15232         MP_WritePhyUshort(sc, 0x15, 0x03dc);
15233         MP_WritePhyUshort(sc, 0x19, 0x7c01);
15234         MP_WritePhyUshort(sc, 0x15, 0x03dd);
15235         MP_WritePhyUshort(sc, 0x19, 0x4c01);
15236         MP_WritePhyUshort(sc, 0x15, 0x03de);
15237         MP_WritePhyUshort(sc, 0x19, 0x9af6);
15238         MP_WritePhyUshort(sc, 0x15, 0x03df);
15239         MP_WritePhyUshort(sc, 0x19, 0x7c12);
15240         MP_WritePhyUshort(sc, 0x15, 0x03e0);
15241         MP_WritePhyUshort(sc, 0x19, 0x4c52);
15242         MP_WritePhyUshort(sc, 0x15, 0x03e1);
15243         MP_WritePhyUshort(sc, 0x19, 0x4470);
15244         MP_WritePhyUshort(sc, 0x15, 0x03e2);
15245         MP_WritePhyUshort(sc, 0x19, 0x7c12);
15246         MP_WritePhyUshort(sc, 0x15, 0x03e3);
15247         MP_WritePhyUshort(sc, 0x19, 0x4c40);
15248         MP_WritePhyUshort(sc, 0x15, 0x03e4);
15249         MP_WritePhyUshort(sc, 0x19, 0x33d4);
15250         MP_WritePhyUshort(sc, 0x15, 0x03e5);
15251         MP_WritePhyUshort(sc, 0x19, 0x0000);
15252         MP_WritePhyUshort(sc, 0x15, 0x03e6);
15253         MP_WritePhyUshort(sc, 0x19, 0x0000);
15254         MP_WritePhyUshort(sc, 0x15, 0x03e7);
15255         MP_WritePhyUshort(sc, 0x19, 0x0000);
15256         MP_WritePhyUshort(sc, 0x15, 0x03e8);
15257         MP_WritePhyUshort(sc, 0x19, 0x0000);
15258         MP_WritePhyUshort(sc, 0x15, 0x03e9);
15259         MP_WritePhyUshort(sc, 0x19, 0x49bb);
15260         MP_WritePhyUshort(sc, 0x15, 0x03ea);
15261         MP_WritePhyUshort(sc, 0x19, 0x4478);
15262         MP_WritePhyUshort(sc, 0x15, 0x03eb);
15263         MP_WritePhyUshort(sc, 0x19, 0x492b);
15264         MP_WritePhyUshort(sc, 0x15, 0x03ec);
15265         MP_WritePhyUshort(sc, 0x19, 0x6b80);
15266         MP_WritePhyUshort(sc, 0x15, 0x03ed);
15267         MP_WritePhyUshort(sc, 0x19, 0x7c01);
15268         MP_WritePhyUshort(sc, 0x15, 0x03ee);
15269         MP_WritePhyUshort(sc, 0x19, 0x4c00);
15270         MP_WritePhyUshort(sc, 0x15, 0x03ef);
15271         MP_WritePhyUshort(sc, 0x19, 0xd64f);
15272         MP_WritePhyUshort(sc, 0x15, 0x03f0);
15273         MP_WritePhyUshort(sc, 0x19, 0x000d);
15274         MP_WritePhyUshort(sc, 0x15, 0x03f1);
15275         MP_WritePhyUshort(sc, 0x19, 0x3311);
15276         MP_WritePhyUshort(sc, 0x15, 0x03f2);
15277         MP_WritePhyUshort(sc, 0x19, 0xbd0c);
15278         MP_WritePhyUshort(sc, 0x15, 0x03f3);
15279         MP_WritePhyUshort(sc, 0x19, 0xc428);
15280         MP_WritePhyUshort(sc, 0x15, 0x03f4);
15281         MP_WritePhyUshort(sc, 0x19, 0x0008);
15282         MP_WritePhyUshort(sc, 0x15, 0x03f5);
15283         MP_WritePhyUshort(sc, 0x19, 0x9afa);
15284         MP_WritePhyUshort(sc, 0x15, 0x03f6);
15285         MP_WritePhyUshort(sc, 0x19, 0x7c12);
15286         MP_WritePhyUshort(sc, 0x15, 0x03f7);
15287         MP_WritePhyUshort(sc, 0x19, 0x4c52);
15288         MP_WritePhyUshort(sc, 0x15, 0x03f8);
15289         MP_WritePhyUshort(sc, 0x19, 0x4470);
15290         MP_WritePhyUshort(sc, 0x15, 0x03f9);
15291         MP_WritePhyUshort(sc, 0x19, 0x7c12);
15292         MP_WritePhyUshort(sc, 0x15, 0x03fa);
15293         MP_WritePhyUshort(sc, 0x19, 0x4c40);
15294         MP_WritePhyUshort(sc, 0x15, 0x03fb);
15295         MP_WritePhyUshort(sc, 0x19, 0x33ef);
15296         MP_WritePhyUshort(sc, 0x15, 0x03fc);
15297         MP_WritePhyUshort(sc, 0x19, 0x3342);
15298         MP_WritePhyUshort(sc, 0x15, 0x03fd);
15299         MP_WritePhyUshort(sc, 0x19, 0x330d);
15300         MP_WritePhyUshort(sc, 0x15, 0x03fe);
15301         MP_WritePhyUshort(sc, 0x19, 0x32ae);
15302         MP_WritePhyUshort(sc, 0x15, 0x0000);
15303         MP_WritePhyUshort(sc, 0x16, 0x0306);
15304         MP_WritePhyUshort(sc, 0x16, 0x0300);
15305         MP_WritePhyUshort(sc, 0x1f, 0x0002);
15306         MP_WritePhyUshort(sc, 0x1f, 0x0000);
15307         MP_WritePhyUshort(sc, 0x1f, 0x0005);
15308         MP_WritePhyUshort(sc, 0x05, 0xfff6);
15309         MP_WritePhyUshort(sc, 0x06, 0x0080);
15310         MP_WritePhyUshort(sc, 0x05, 0x8000);
15311         MP_WritePhyUshort(sc, 0x06, 0x0280);
15312         MP_WritePhyUshort(sc, 0x06, 0x48f7);
15313         MP_WritePhyUshort(sc, 0x06, 0x00e0);
15314         MP_WritePhyUshort(sc, 0x06, 0xfff7);
15315         MP_WritePhyUshort(sc, 0x06, 0xa080);
15316         MP_WritePhyUshort(sc, 0x06, 0x02ae);
15317         MP_WritePhyUshort(sc, 0x06, 0xf602);
15318         MP_WritePhyUshort(sc, 0x06, 0x0112);
15319         MP_WritePhyUshort(sc, 0x06, 0x0201);
15320         MP_WritePhyUshort(sc, 0x06, 0x1f02);
15321         MP_WritePhyUshort(sc, 0x06, 0x012c);
15322         MP_WritePhyUshort(sc, 0x06, 0x0201);
15323         MP_WritePhyUshort(sc, 0x06, 0x3c02);
15324         MP_WritePhyUshort(sc, 0x06, 0x0156);
15325         MP_WritePhyUshort(sc, 0x06, 0x0201);
15326         MP_WritePhyUshort(sc, 0x06, 0x6d02);
15327         MP_WritePhyUshort(sc, 0x06, 0x809d);
15328         MP_WritePhyUshort(sc, 0x06, 0xe08b);
15329         MP_WritePhyUshort(sc, 0x06, 0x88e1);
15330         MP_WritePhyUshort(sc, 0x06, 0x8b89);
15331         MP_WritePhyUshort(sc, 0x06, 0x1e01);
15332         MP_WritePhyUshort(sc, 0x06, 0xe18b);
15333         MP_WritePhyUshort(sc, 0x06, 0x8a1e);
15334         MP_WritePhyUshort(sc, 0x06, 0x01e1);
15335         MP_WritePhyUshort(sc, 0x06, 0x8b8b);
15336         MP_WritePhyUshort(sc, 0x06, 0x1e01);
15337         MP_WritePhyUshort(sc, 0x06, 0xe18b);
15338         MP_WritePhyUshort(sc, 0x06, 0x8c1e);
15339         MP_WritePhyUshort(sc, 0x06, 0x01e1);
15340         MP_WritePhyUshort(sc, 0x06, 0x8b8d);
15341         MP_WritePhyUshort(sc, 0x06, 0x1e01);
15342         MP_WritePhyUshort(sc, 0x06, 0xe18b);
15343         MP_WritePhyUshort(sc, 0x06, 0x8e1e);
15344         MP_WritePhyUshort(sc, 0x06, 0x01a0);
15345         MP_WritePhyUshort(sc, 0x06, 0x00c7);
15346         MP_WritePhyUshort(sc, 0x06, 0xaebb);
15347         MP_WritePhyUshort(sc, 0x06, 0xd100);
15348         MP_WritePhyUshort(sc, 0x06, 0xbf82);
15349         MP_WritePhyUshort(sc, 0x06, 0xc702);
15350         MP_WritePhyUshort(sc, 0x06, 0x320a);
15351         MP_WritePhyUshort(sc, 0x06, 0xd105);
15352         MP_WritePhyUshort(sc, 0x06, 0xbf82);
15353         MP_WritePhyUshort(sc, 0x06, 0xcd02);
15354         MP_WritePhyUshort(sc, 0x06, 0x320a);
15355         MP_WritePhyUshort(sc, 0x06, 0xd100);
15356         MP_WritePhyUshort(sc, 0x06, 0xbf82);
15357         MP_WritePhyUshort(sc, 0x06, 0xca02);
15358         MP_WritePhyUshort(sc, 0x06, 0x320a);
15359         MP_WritePhyUshort(sc, 0x06, 0xd105);
15360         MP_WritePhyUshort(sc, 0x06, 0xbf82);
15361         MP_WritePhyUshort(sc, 0x06, 0xd002);
15362         MP_WritePhyUshort(sc, 0x06, 0x320a);
15363         MP_WritePhyUshort(sc, 0x06, 0xd481);
15364         MP_WritePhyUshort(sc, 0x06, 0xc9e4);
15365         MP_WritePhyUshort(sc, 0x06, 0x8b90);
15366         MP_WritePhyUshort(sc, 0x06, 0xe58b);
15367         MP_WritePhyUshort(sc, 0x06, 0x91d4);
15368         MP_WritePhyUshort(sc, 0x06, 0x81b8);
15369         MP_WritePhyUshort(sc, 0x06, 0xe48b);
15370         MP_WritePhyUshort(sc, 0x06, 0x92e5);
15371         MP_WritePhyUshort(sc, 0x06, 0x8b93);
15372         MP_WritePhyUshort(sc, 0x06, 0xbf8b);
15373         MP_WritePhyUshort(sc, 0x06, 0x88ec);
15374         MP_WritePhyUshort(sc, 0x06, 0x0019);
15375         MP_WritePhyUshort(sc, 0x06, 0xa98b);
15376         MP_WritePhyUshort(sc, 0x06, 0x90f9);
15377         MP_WritePhyUshort(sc, 0x06, 0xeeff);
15378         MP_WritePhyUshort(sc, 0x06, 0xf600);
15379         MP_WritePhyUshort(sc, 0x06, 0xeeff);
15380         MP_WritePhyUshort(sc, 0x06, 0xf7fc);
15381         MP_WritePhyUshort(sc, 0x06, 0xd100);
15382         MP_WritePhyUshort(sc, 0x06, 0xbf82);
15383         MP_WritePhyUshort(sc, 0x06, 0xc102);
15384         MP_WritePhyUshort(sc, 0x06, 0x320a);
15385         MP_WritePhyUshort(sc, 0x06, 0xd101);
15386         MP_WritePhyUshort(sc, 0x06, 0xbf82);
15387         MP_WritePhyUshort(sc, 0x06, 0xc402);
15388         MP_WritePhyUshort(sc, 0x06, 0x320a);
15389         MP_WritePhyUshort(sc, 0x06, 0x04f8);
15390         MP_WritePhyUshort(sc, 0x06, 0xe08b);
15391         MP_WritePhyUshort(sc, 0x06, 0x8ead);
15392         MP_WritePhyUshort(sc, 0x06, 0x201a);
15393         MP_WritePhyUshort(sc, 0x06, 0xf620);
15394         MP_WritePhyUshort(sc, 0x06, 0xe48b);
15395         MP_WritePhyUshort(sc, 0x06, 0x8e02);
15396         MP_WritePhyUshort(sc, 0x06, 0x824b);
15397         MP_WritePhyUshort(sc, 0x06, 0x0281);
15398         MP_WritePhyUshort(sc, 0x06, 0x1902);
15399         MP_WritePhyUshort(sc, 0x06, 0x2c9d);
15400         MP_WritePhyUshort(sc, 0x06, 0x0203);
15401         MP_WritePhyUshort(sc, 0x06, 0x9602);
15402         MP_WritePhyUshort(sc, 0x06, 0x0473);
15403         MP_WritePhyUshort(sc, 0x06, 0x022e);
15404         MP_WritePhyUshort(sc, 0x06, 0x3902);
15405         MP_WritePhyUshort(sc, 0x06, 0x044d);
15406         MP_WritePhyUshort(sc, 0x06, 0xe08b);
15407         MP_WritePhyUshort(sc, 0x06, 0x8ead);
15408         MP_WritePhyUshort(sc, 0x06, 0x210b);
15409         MP_WritePhyUshort(sc, 0x06, 0xf621);
15410         MP_WritePhyUshort(sc, 0x06, 0xe48b);
15411         MP_WritePhyUshort(sc, 0x06, 0x8e02);
15412         MP_WritePhyUshort(sc, 0x06, 0x0416);
15413         MP_WritePhyUshort(sc, 0x06, 0x021b);
15414         MP_WritePhyUshort(sc, 0x06, 0xa4e0);
15415         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
15416         MP_WritePhyUshort(sc, 0x06, 0xad22);
15417         MP_WritePhyUshort(sc, 0x06, 0x05f6);
15418         MP_WritePhyUshort(sc, 0x06, 0x22e4);
15419         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
15420         MP_WritePhyUshort(sc, 0x06, 0xe08b);
15421         MP_WritePhyUshort(sc, 0x06, 0x8ead);
15422         MP_WritePhyUshort(sc, 0x06, 0x2305);
15423         MP_WritePhyUshort(sc, 0x06, 0xf623);
15424         MP_WritePhyUshort(sc, 0x06, 0xe48b);
15425         MP_WritePhyUshort(sc, 0x06, 0x8ee0);
15426         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
15427         MP_WritePhyUshort(sc, 0x06, 0xad24);
15428         MP_WritePhyUshort(sc, 0x06, 0x05f6);
15429         MP_WritePhyUshort(sc, 0x06, 0x24e4);
15430         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
15431         MP_WritePhyUshort(sc, 0x06, 0xe08b);
15432         MP_WritePhyUshort(sc, 0x06, 0x8ead);
15433         MP_WritePhyUshort(sc, 0x06, 0x2505);
15434         MP_WritePhyUshort(sc, 0x06, 0xf625);
15435         MP_WritePhyUshort(sc, 0x06, 0xe48b);
15436         MP_WritePhyUshort(sc, 0x06, 0x8ee0);
15437         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
15438         MP_WritePhyUshort(sc, 0x06, 0xad26);
15439         MP_WritePhyUshort(sc, 0x06, 0x08f6);
15440         MP_WritePhyUshort(sc, 0x06, 0x26e4);
15441         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
15442         MP_WritePhyUshort(sc, 0x06, 0x0281);
15443         MP_WritePhyUshort(sc, 0x06, 0xdae0);
15444         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
15445         MP_WritePhyUshort(sc, 0x06, 0xad27);
15446         MP_WritePhyUshort(sc, 0x06, 0x05f6);
15447         MP_WritePhyUshort(sc, 0x06, 0x27e4);
15448         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
15449         MP_WritePhyUshort(sc, 0x06, 0x0203);
15450         MP_WritePhyUshort(sc, 0x06, 0x5cfc);
15451         MP_WritePhyUshort(sc, 0x06, 0x04f8);
15452         MP_WritePhyUshort(sc, 0x06, 0xfaef);
15453         MP_WritePhyUshort(sc, 0x06, 0x69e0);
15454         MP_WritePhyUshort(sc, 0x06, 0x8b85);
15455         MP_WritePhyUshort(sc, 0x06, 0xad21);
15456         MP_WritePhyUshort(sc, 0x06, 0x57e0);
15457         MP_WritePhyUshort(sc, 0x06, 0xe022);
15458         MP_WritePhyUshort(sc, 0x06, 0xe1e0);
15459         MP_WritePhyUshort(sc, 0x06, 0x2358);
15460         MP_WritePhyUshort(sc, 0x06, 0xc059);
15461         MP_WritePhyUshort(sc, 0x06, 0x021e);
15462         MP_WritePhyUshort(sc, 0x06, 0x01e1);
15463         MP_WritePhyUshort(sc, 0x06, 0x8b3c);
15464         MP_WritePhyUshort(sc, 0x06, 0x1f10);
15465         MP_WritePhyUshort(sc, 0x06, 0x9e44);
15466         MP_WritePhyUshort(sc, 0x06, 0xe48b);
15467         MP_WritePhyUshort(sc, 0x06, 0x3cad);
15468         MP_WritePhyUshort(sc, 0x06, 0x211d);
15469         MP_WritePhyUshort(sc, 0x06, 0xe18b);
15470         MP_WritePhyUshort(sc, 0x06, 0x84f7);
15471         MP_WritePhyUshort(sc, 0x06, 0x29e5);
15472         MP_WritePhyUshort(sc, 0x06, 0x8b84);
15473         MP_WritePhyUshort(sc, 0x06, 0xac27);
15474         MP_WritePhyUshort(sc, 0x06, 0x0dac);
15475         MP_WritePhyUshort(sc, 0x06, 0x2605);
15476         MP_WritePhyUshort(sc, 0x06, 0x0281);
15477         MP_WritePhyUshort(sc, 0x06, 0x7fae);
15478         MP_WritePhyUshort(sc, 0x06, 0x2b02);
15479         MP_WritePhyUshort(sc, 0x06, 0x2c23);
15480         MP_WritePhyUshort(sc, 0x06, 0xae26);
15481         MP_WritePhyUshort(sc, 0x06, 0x022c);
15482         MP_WritePhyUshort(sc, 0x06, 0x41ae);
15483         MP_WritePhyUshort(sc, 0x06, 0x21e0);
15484         MP_WritePhyUshort(sc, 0x06, 0x8b87);
15485         MP_WritePhyUshort(sc, 0x06, 0xad22);
15486         MP_WritePhyUshort(sc, 0x06, 0x18e0);
15487         MP_WritePhyUshort(sc, 0x06, 0xfff7);
15488         MP_WritePhyUshort(sc, 0x06, 0x58fc);
15489         MP_WritePhyUshort(sc, 0x06, 0xe4ff);
15490         MP_WritePhyUshort(sc, 0x06, 0xf7d1);
15491         MP_WritePhyUshort(sc, 0x06, 0x00bf);
15492         MP_WritePhyUshort(sc, 0x06, 0x2eee);
15493         MP_WritePhyUshort(sc, 0x06, 0x0232);
15494         MP_WritePhyUshort(sc, 0x06, 0x0ad1);
15495         MP_WritePhyUshort(sc, 0x06, 0x00bf);
15496         MP_WritePhyUshort(sc, 0x06, 0x82e8);
15497         MP_WritePhyUshort(sc, 0x06, 0x0232);
15498         MP_WritePhyUshort(sc, 0x06, 0x0a02);
15499         MP_WritePhyUshort(sc, 0x06, 0x2bdf);
15500         MP_WritePhyUshort(sc, 0x06, 0xef96);
15501         MP_WritePhyUshort(sc, 0x06, 0xfefc);
15502         MP_WritePhyUshort(sc, 0x06, 0x04d0);
15503         MP_WritePhyUshort(sc, 0x06, 0x0202);
15504         MP_WritePhyUshort(sc, 0x06, 0x1e97);
15505         MP_WritePhyUshort(sc, 0x06, 0xe08b);
15506         MP_WritePhyUshort(sc, 0x06, 0x87ad);
15507         MP_WritePhyUshort(sc, 0x06, 0x2228);
15508         MP_WritePhyUshort(sc, 0x06, 0xd100);
15509         MP_WritePhyUshort(sc, 0x06, 0xbf82);
15510         MP_WritePhyUshort(sc, 0x06, 0xd302);
15511         MP_WritePhyUshort(sc, 0x06, 0x320a);
15512         MP_WritePhyUshort(sc, 0x06, 0xd10c);
15513         MP_WritePhyUshort(sc, 0x06, 0xbf82);
15514         MP_WritePhyUshort(sc, 0x06, 0xd602);
15515         MP_WritePhyUshort(sc, 0x06, 0x320a);
15516         MP_WritePhyUshort(sc, 0x06, 0xd104);
15517         MP_WritePhyUshort(sc, 0x06, 0xbf82);
15518         MP_WritePhyUshort(sc, 0x06, 0xd902);
15519         MP_WritePhyUshort(sc, 0x06, 0x320a);
15520         MP_WritePhyUshort(sc, 0x06, 0xd101);
15521         MP_WritePhyUshort(sc, 0x06, 0xbf82);
15522         MP_WritePhyUshort(sc, 0x06, 0xe802);
15523         MP_WritePhyUshort(sc, 0x06, 0x320a);
15524         MP_WritePhyUshort(sc, 0x06, 0xe0ff);
15525         MP_WritePhyUshort(sc, 0x06, 0xf768);
15526         MP_WritePhyUshort(sc, 0x06, 0x03e4);
15527         MP_WritePhyUshort(sc, 0x06, 0xfff7);
15528         MP_WritePhyUshort(sc, 0x06, 0xd004);
15529         MP_WritePhyUshort(sc, 0x06, 0x0228);
15530         MP_WritePhyUshort(sc, 0x06, 0x7a04);
15531         MP_WritePhyUshort(sc, 0x06, 0xf8e0);
15532         MP_WritePhyUshort(sc, 0x06, 0xe234);
15533         MP_WritePhyUshort(sc, 0x06, 0xe1e2);
15534         MP_WritePhyUshort(sc, 0x06, 0x35f6);
15535         MP_WritePhyUshort(sc, 0x06, 0x2be4);
15536         MP_WritePhyUshort(sc, 0x06, 0xe234);
15537         MP_WritePhyUshort(sc, 0x06, 0xe5e2);
15538         MP_WritePhyUshort(sc, 0x06, 0x35fc);
15539         MP_WritePhyUshort(sc, 0x06, 0x05f8);
15540         MP_WritePhyUshort(sc, 0x06, 0xe0e2);
15541         MP_WritePhyUshort(sc, 0x06, 0x34e1);
15542         MP_WritePhyUshort(sc, 0x06, 0xe235);
15543         MP_WritePhyUshort(sc, 0x06, 0xf72b);
15544         MP_WritePhyUshort(sc, 0x06, 0xe4e2);
15545         MP_WritePhyUshort(sc, 0x06, 0x34e5);
15546         MP_WritePhyUshort(sc, 0x06, 0xe235);
15547         MP_WritePhyUshort(sc, 0x06, 0xfc05);
15548         MP_WritePhyUshort(sc, 0x06, 0xf8f9);
15549         MP_WritePhyUshort(sc, 0x06, 0xfaef);
15550         MP_WritePhyUshort(sc, 0x06, 0x69ac);
15551         MP_WritePhyUshort(sc, 0x06, 0x1b4c);
15552         MP_WritePhyUshort(sc, 0x06, 0xbf2e);
15553         MP_WritePhyUshort(sc, 0x06, 0x3002);
15554         MP_WritePhyUshort(sc, 0x06, 0x31dd);
15555         MP_WritePhyUshort(sc, 0x06, 0xef01);
15556         MP_WritePhyUshort(sc, 0x06, 0xe28a);
15557         MP_WritePhyUshort(sc, 0x06, 0x76e4);
15558         MP_WritePhyUshort(sc, 0x06, 0x8a76);
15559         MP_WritePhyUshort(sc, 0x06, 0x1f12);
15560         MP_WritePhyUshort(sc, 0x06, 0x9e3a);
15561         MP_WritePhyUshort(sc, 0x06, 0xef12);
15562         MP_WritePhyUshort(sc, 0x06, 0x5907);
15563         MP_WritePhyUshort(sc, 0x06, 0x9f12);
15564         MP_WritePhyUshort(sc, 0x06, 0xf8e0);
15565         MP_WritePhyUshort(sc, 0x06, 0x8b40);
15566         MP_WritePhyUshort(sc, 0x06, 0xf721);
15567         MP_WritePhyUshort(sc, 0x06, 0xe48b);
15568         MP_WritePhyUshort(sc, 0x06, 0x40d0);
15569         MP_WritePhyUshort(sc, 0x06, 0x0302);
15570         MP_WritePhyUshort(sc, 0x06, 0x287a);
15571         MP_WritePhyUshort(sc, 0x06, 0x0282);
15572         MP_WritePhyUshort(sc, 0x06, 0x34fc);
15573         MP_WritePhyUshort(sc, 0x06, 0xa000);
15574         MP_WritePhyUshort(sc, 0x06, 0x1002);
15575         MP_WritePhyUshort(sc, 0x06, 0x2dc3);
15576         MP_WritePhyUshort(sc, 0x06, 0x022e);
15577         MP_WritePhyUshort(sc, 0x06, 0x21e0);
15578         MP_WritePhyUshort(sc, 0x06, 0x8b40);
15579         MP_WritePhyUshort(sc, 0x06, 0xf621);
15580         MP_WritePhyUshort(sc, 0x06, 0xe48b);
15581         MP_WritePhyUshort(sc, 0x06, 0x40ae);
15582         MP_WritePhyUshort(sc, 0x06, 0x0fbf);
15583         MP_WritePhyUshort(sc, 0x06, 0x3fa5);
15584         MP_WritePhyUshort(sc, 0x06, 0x0231);
15585         MP_WritePhyUshort(sc, 0x06, 0x6cbf);
15586         MP_WritePhyUshort(sc, 0x06, 0x3fa2);
15587         MP_WritePhyUshort(sc, 0x06, 0x0231);
15588         MP_WritePhyUshort(sc, 0x06, 0x6c02);
15589         MP_WritePhyUshort(sc, 0x06, 0x2dc3);
15590         MP_WritePhyUshort(sc, 0x06, 0xef96);
15591         MP_WritePhyUshort(sc, 0x06, 0xfefd);
15592         MP_WritePhyUshort(sc, 0x06, 0xfc04);
15593         MP_WritePhyUshort(sc, 0x06, 0xf8e0);
15594         MP_WritePhyUshort(sc, 0x06, 0xe2f4);
15595         MP_WritePhyUshort(sc, 0x06, 0xe1e2);
15596         MP_WritePhyUshort(sc, 0x06, 0xf5e4);
15597         MP_WritePhyUshort(sc, 0x06, 0x8a78);
15598         MP_WritePhyUshort(sc, 0x06, 0xe58a);
15599         MP_WritePhyUshort(sc, 0x06, 0x79ee);
15600         MP_WritePhyUshort(sc, 0x06, 0xe2f4);
15601         MP_WritePhyUshort(sc, 0x06, 0xd8ee);
15602         MP_WritePhyUshort(sc, 0x06, 0xe2f5);
15603         MP_WritePhyUshort(sc, 0x06, 0x20fc);
15604         MP_WritePhyUshort(sc, 0x06, 0x04f8);
15605         MP_WritePhyUshort(sc, 0x06, 0xf9fa);
15606         MP_WritePhyUshort(sc, 0x06, 0xef69);
15607         MP_WritePhyUshort(sc, 0x06, 0xe08b);
15608         MP_WritePhyUshort(sc, 0x06, 0x87ad);
15609         MP_WritePhyUshort(sc, 0x06, 0x2065);
15610         MP_WritePhyUshort(sc, 0x06, 0xd200);
15611         MP_WritePhyUshort(sc, 0x06, 0xbf2e);
15612         MP_WritePhyUshort(sc, 0x06, 0xe802);
15613         MP_WritePhyUshort(sc, 0x06, 0x31dd);
15614         MP_WritePhyUshort(sc, 0x06, 0x1e21);
15615         MP_WritePhyUshort(sc, 0x06, 0xbf82);
15616         MP_WritePhyUshort(sc, 0x06, 0xdf02);
15617         MP_WritePhyUshort(sc, 0x06, 0x31dd);
15618         MP_WritePhyUshort(sc, 0x06, 0x0c11);
15619         MP_WritePhyUshort(sc, 0x06, 0x1e21);
15620         MP_WritePhyUshort(sc, 0x06, 0xbf82);
15621         MP_WritePhyUshort(sc, 0x06, 0xe202);
15622         MP_WritePhyUshort(sc, 0x06, 0x31dd);
15623         MP_WritePhyUshort(sc, 0x06, 0x0c12);
15624         MP_WritePhyUshort(sc, 0x06, 0x1e21);
15625         MP_WritePhyUshort(sc, 0x06, 0xbf82);
15626         MP_WritePhyUshort(sc, 0x06, 0xe502);
15627         MP_WritePhyUshort(sc, 0x06, 0x31dd);
15628         MP_WritePhyUshort(sc, 0x06, 0x0c13);
15629         MP_WritePhyUshort(sc, 0x06, 0x1e21);
15630         MP_WritePhyUshort(sc, 0x06, 0xbf1f);
15631         MP_WritePhyUshort(sc, 0x06, 0x5302);
15632         MP_WritePhyUshort(sc, 0x06, 0x31dd);
15633         MP_WritePhyUshort(sc, 0x06, 0x0c14);
15634         MP_WritePhyUshort(sc, 0x06, 0x1e21);
15635         MP_WritePhyUshort(sc, 0x06, 0xbf82);
15636         MP_WritePhyUshort(sc, 0x06, 0xeb02);
15637         MP_WritePhyUshort(sc, 0x06, 0x31dd);
15638         MP_WritePhyUshort(sc, 0x06, 0x0c16);
15639         MP_WritePhyUshort(sc, 0x06, 0x1e21);
15640         MP_WritePhyUshort(sc, 0x06, 0xe083);
15641         MP_WritePhyUshort(sc, 0x06, 0xe01f);
15642         MP_WritePhyUshort(sc, 0x06, 0x029e);
15643         MP_WritePhyUshort(sc, 0x06, 0x22e6);
15644         MP_WritePhyUshort(sc, 0x06, 0x83e0);
15645         MP_WritePhyUshort(sc, 0x06, 0xad31);
15646         MP_WritePhyUshort(sc, 0x06, 0x14ad);
15647         MP_WritePhyUshort(sc, 0x06, 0x3011);
15648         MP_WritePhyUshort(sc, 0x06, 0xef02);
15649         MP_WritePhyUshort(sc, 0x06, 0x580c);
15650         MP_WritePhyUshort(sc, 0x06, 0x9e07);
15651         MP_WritePhyUshort(sc, 0x06, 0xad36);
15652         MP_WritePhyUshort(sc, 0x06, 0x085a);
15653         MP_WritePhyUshort(sc, 0x06, 0x309f);
15654         MP_WritePhyUshort(sc, 0x06, 0x04d1);
15655         MP_WritePhyUshort(sc, 0x06, 0x01ae);
15656         MP_WritePhyUshort(sc, 0x06, 0x02d1);
15657         MP_WritePhyUshort(sc, 0x06, 0x00bf);
15658         MP_WritePhyUshort(sc, 0x06, 0x82dc);
15659         MP_WritePhyUshort(sc, 0x06, 0x0232);
15660         MP_WritePhyUshort(sc, 0x06, 0x0aef);
15661         MP_WritePhyUshort(sc, 0x06, 0x96fe);
15662         MP_WritePhyUshort(sc, 0x06, 0xfdfc);
15663         MP_WritePhyUshort(sc, 0x06, 0x0400);
15664         MP_WritePhyUshort(sc, 0x06, 0xe140);
15665         MP_WritePhyUshort(sc, 0x06, 0x77e1);
15666         MP_WritePhyUshort(sc, 0x06, 0x4010);
15667         MP_WritePhyUshort(sc, 0x06, 0xe150);
15668         MP_WritePhyUshort(sc, 0x06, 0x32e1);
15669         MP_WritePhyUshort(sc, 0x06, 0x5030);
15670         MP_WritePhyUshort(sc, 0x06, 0xe144);
15671         MP_WritePhyUshort(sc, 0x06, 0x74e1);
15672         MP_WritePhyUshort(sc, 0x06, 0x44bb);
15673         MP_WritePhyUshort(sc, 0x06, 0xe2d2);
15674         MP_WritePhyUshort(sc, 0x06, 0x40e0);
15675         MP_WritePhyUshort(sc, 0x06, 0x2cfc);
15676         MP_WritePhyUshort(sc, 0x06, 0xe2cc);
15677         MP_WritePhyUshort(sc, 0x06, 0xcce2);
15678         MP_WritePhyUshort(sc, 0x06, 0x00cc);
15679         MP_WritePhyUshort(sc, 0x06, 0xe000);
15680         MP_WritePhyUshort(sc, 0x06, 0x99e0);
15681         MP_WritePhyUshort(sc, 0x06, 0x3688);
15682         MP_WritePhyUshort(sc, 0x06, 0xe036);
15683         MP_WritePhyUshort(sc, 0x06, 0x99e1);
15684         MP_WritePhyUshort(sc, 0x06, 0x40dd);
15685         MP_WritePhyUshort(sc, 0x06, 0xe022);
15686         MP_WritePhyUshort(sc, 0x05, 0xe142);
15687         PhyRegValue = MP_ReadPhyUshort(sc, 0x06);
15688         PhyRegValue |= BIT_0;
15689         MP_WritePhyUshort(sc, 0x06, PhyRegValue);
15690         MP_WritePhyUshort(sc, 0x05, 0xe140);
15691         PhyRegValue = MP_ReadPhyUshort(sc, 0x06);
15692         PhyRegValue |= BIT_0;
15693         MP_WritePhyUshort(sc, 0x06, PhyRegValue);
15694         MP_WritePhyUshort(sc, 0x1f, 0x0000);
15695         MP_WritePhyUshort(sc, 0x1f, 0x0005);
15696         for (i = 0; i < 200; i++) {
15697                 DELAY(100);
15698                 PhyRegValue = MP_ReadPhyUshort(sc, 0x00);
15699                 if (PhyRegValue & BIT_7)
15700                         break;
15701         }
15702
15703         MP_WritePhyUshort(sc, 0x1F, 0x0001);
15704         MP_WritePhyUshort(sc, 0x0B, 0x6C14);
15705         MP_WritePhyUshort(sc, 0x14, 0x7F3D);
15706         MP_WritePhyUshort(sc, 0x1C, 0xFAFE);
15707         MP_WritePhyUshort(sc, 0x08, 0x07C5);
15708         MP_WritePhyUshort(sc, 0x10, 0xF090);
15709         MP_WritePhyUshort(sc, 0x1F, 0x0003);
15710         MP_WritePhyUshort(sc, 0x14, 0x641A);
15711         MP_WritePhyUshort(sc, 0x1A, 0x0606);
15712         MP_WritePhyUshort(sc, 0x12, 0xF480);
15713         MP_WritePhyUshort(sc, 0x13, 0x0747);
15714         MP_WritePhyUshort(sc, 0x1F, 0x0000);
15715
15716         MP_WritePhyUshort(sc, 0x1F, 0x0003);
15717         MP_WritePhyUshort(sc, 0x0D, 0x0207);
15718         MP_WritePhyUshort(sc, 0x02, 0x5FD0);
15719         MP_WritePhyUshort(sc, 0x1F, 0x0000);
15720
15721         MP_WritePhyUshort(sc, 0x1F, 0x0003);
15722         MP_WritePhyUshort(sc, 0x09, 0xA20F);
15723         MP_WritePhyUshort(sc, 0x1F, 0x0000);
15724
15725         MP_WritePhyUshort(sc, 0x1f, 0x0003);
15726         PhyRegValue = MP_ReadPhyUshort(sc, 0x19);
15727         PhyRegValue &= ~BIT_0;
15728         MP_WritePhyUshort(sc, 0x19, PhyRegValue);
15729         PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
15730         PhyRegValue &= ~BIT_10;
15731         MP_WritePhyUshort(sc, 0x10, PhyRegValue);
15732         MP_WritePhyUshort(sc, 0x1f, 0x0000);
15733
15734         MP_WritePhyUshort(sc, 0x1f, 0x0004);
15735         MP_WritePhyUshort(sc, 0x1f, 0x0007);
15736         MP_WritePhyUshort(sc, 0x1e, 0x0023);
15737         PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
15738         PhyRegValue &= ~BIT_0;
15739         PhyRegValue |= BIT_2;
15740         MP_WritePhyUshort(sc, 0x17, PhyRegValue);
15741         MP_WritePhyUshort(sc, 0x1f, 0x0002);
15742         MP_WritePhyUshort(sc, 0x1f, 0x0000);
15743 }
15744
15745 static void re_set_phy_mcu_8168evl_2(struct re_softc *sc)
15746 {
15747         u_int16_t PhyRegValue;
15748         int i;
15749
15750         MP_WritePhyUshort(sc, 0x1f, 0x0000);
15751         MP_WritePhyUshort(sc, 0x00, 0x1800);
15752         PhyRegValue = MP_ReadPhyUshort(sc, 0x15);
15753         PhyRegValue &= ~(BIT_12);
15754         MP_WritePhyUshort(sc, 0x15, PhyRegValue);
15755         MP_WritePhyUshort(sc, 0x00, 0x4800);
15756         MP_WritePhyUshort(sc, 0x1f, 0x0007);
15757         MP_WritePhyUshort(sc, 0x1e, 0x002f);
15758         for (i = 0; i < 1000; i++) {
15759                 if (MP_ReadPhyUshort(sc, 0x1c) & BIT_7)
15760                         break;
15761                 DELAY(100);
15762         }
15763         MP_WritePhyUshort(sc, 0x1f, 0x0000);
15764         MP_WritePhyUshort(sc, 0x00, 0x1800);
15765         MP_WritePhyUshort(sc, 0x1f, 0x0007);
15766         MP_WritePhyUshort(sc, 0x1e, 0x0023);
15767         for (i = 0; i < 200; i++) {
15768                 if ((MP_ReadPhyUshort(sc, 0x17) & BIT_0) == 0)
15769                         break;
15770                 DELAY(100);
15771         }
15772         MP_WritePhyUshort(sc, 0x1f, 0x0005);
15773         MP_WritePhyUshort(sc, 0x05, 0xfff6);
15774         MP_WritePhyUshort(sc, 0x06, 0x0080);
15775         MP_WritePhyUshort(sc, 0x1f, 0x0007);
15776         MP_WritePhyUshort(sc, 0x1e, 0x0023);
15777         MP_WritePhyUshort(sc, 0x16, 0x0306);
15778         MP_WritePhyUshort(sc, 0x16, 0x0307);
15779         MP_WritePhyUshort(sc, 0x15, 0x00AF);
15780         MP_WritePhyUshort(sc, 0x19, 0x4060);
15781         MP_WritePhyUshort(sc, 0x15, 0x00B0);
15782         MP_WritePhyUshort(sc, 0x19, 0x7800);
15783         MP_WritePhyUshort(sc, 0x15, 0x00B1);
15784         MP_WritePhyUshort(sc, 0x19, 0x7e00);
15785         MP_WritePhyUshort(sc, 0x15, 0x00B2);
15786         MP_WritePhyUshort(sc, 0x19, 0x72B0);
15787         MP_WritePhyUshort(sc, 0x15, 0x00B3);
15788         MP_WritePhyUshort(sc, 0x19, 0x7F00);
15789         MP_WritePhyUshort(sc, 0x15, 0x00B4);
15790         MP_WritePhyUshort(sc, 0x19, 0x73B0);
15791         MP_WritePhyUshort(sc, 0x15, 0x0101);
15792         MP_WritePhyUshort(sc, 0x19, 0x0005);
15793         MP_WritePhyUshort(sc, 0x15, 0x0103);
15794         MP_WritePhyUshort(sc, 0x19, 0x0003);
15795         MP_WritePhyUshort(sc, 0x15, 0x0105);
15796         MP_WritePhyUshort(sc, 0x19, 0x30FD);
15797         MP_WritePhyUshort(sc, 0x15, 0x0106);
15798         MP_WritePhyUshort(sc, 0x19, 0x9DF7);
15799         MP_WritePhyUshort(sc, 0x15, 0x0107);
15800         MP_WritePhyUshort(sc, 0x19, 0x30C6);
15801         MP_WritePhyUshort(sc, 0x15, 0x0098);
15802         MP_WritePhyUshort(sc, 0x19, 0x7c0b);
15803         MP_WritePhyUshort(sc, 0x15, 0x0099);
15804         MP_WritePhyUshort(sc, 0x19, 0x6c0b);
15805         MP_WritePhyUshort(sc, 0x15, 0x00eb);
15806         MP_WritePhyUshort(sc, 0x19, 0x6c0b);
15807         MP_WritePhyUshort(sc, 0x15, 0x00f8);
15808         MP_WritePhyUshort(sc, 0x19, 0x6f0b);
15809         MP_WritePhyUshort(sc, 0x15, 0x00fe);
15810         MP_WritePhyUshort(sc, 0x19, 0x6f0f);
15811         MP_WritePhyUshort(sc, 0x15, 0x00db);
15812         MP_WritePhyUshort(sc, 0x19, 0x6f09);
15813         MP_WritePhyUshort(sc, 0x15, 0x00dc);
15814         MP_WritePhyUshort(sc, 0x19, 0xaefd);
15815         MP_WritePhyUshort(sc, 0x15, 0x00dd);
15816         MP_WritePhyUshort(sc, 0x19, 0x6f0b);
15817         MP_WritePhyUshort(sc, 0x15, 0x00de);
15818         MP_WritePhyUshort(sc, 0x19, 0xc60b);
15819         MP_WritePhyUshort(sc, 0x15, 0x00df);
15820         MP_WritePhyUshort(sc, 0x19, 0x00fa);
15821         MP_WritePhyUshort(sc, 0x15, 0x00e0);
15822         MP_WritePhyUshort(sc, 0x19, 0x30e1);
15823         MP_WritePhyUshort(sc, 0x15, 0x020c);
15824         MP_WritePhyUshort(sc, 0x19, 0x3224);
15825         MP_WritePhyUshort(sc, 0x15, 0x020e);
15826         MP_WritePhyUshort(sc, 0x19, 0x9813);
15827         MP_WritePhyUshort(sc, 0x15, 0x020f);
15828         MP_WritePhyUshort(sc, 0x19, 0x7801);
15829         MP_WritePhyUshort(sc, 0x15, 0x0210);
15830         MP_WritePhyUshort(sc, 0x19, 0x930f);
15831         MP_WritePhyUshort(sc, 0x15, 0x0211);
15832         MP_WritePhyUshort(sc, 0x19, 0x9206);
15833         MP_WritePhyUshort(sc, 0x15, 0x0212);
15834         MP_WritePhyUshort(sc, 0x19, 0x4002);
15835         MP_WritePhyUshort(sc, 0x15, 0x0213);
15836         MP_WritePhyUshort(sc, 0x19, 0x7800);
15837         MP_WritePhyUshort(sc, 0x15, 0x0214);
15838         MP_WritePhyUshort(sc, 0x19, 0x588f);
15839         MP_WritePhyUshort(sc, 0x15, 0x0215);
15840         MP_WritePhyUshort(sc, 0x19, 0x5520);
15841         MP_WritePhyUshort(sc, 0x15, 0x0216);
15842         MP_WritePhyUshort(sc, 0x19, 0x3224);
15843         MP_WritePhyUshort(sc, 0x15, 0x0217);
15844         MP_WritePhyUshort(sc, 0x19, 0x4002);
15845         MP_WritePhyUshort(sc, 0x15, 0x0218);
15846         MP_WritePhyUshort(sc, 0x19, 0x7800);
15847         MP_WritePhyUshort(sc, 0x15, 0x0219);
15848         MP_WritePhyUshort(sc, 0x19, 0x588d);
15849         MP_WritePhyUshort(sc, 0x15, 0x021a);
15850         MP_WritePhyUshort(sc, 0x19, 0x5540);
15851         MP_WritePhyUshort(sc, 0x15, 0x021b);
15852         MP_WritePhyUshort(sc, 0x19, 0x9e03);
15853         MP_WritePhyUshort(sc, 0x15, 0x021c);
15854         MP_WritePhyUshort(sc, 0x19, 0x7c40);
15855         MP_WritePhyUshort(sc, 0x15, 0x021d);
15856         MP_WritePhyUshort(sc, 0x19, 0x6840);
15857         MP_WritePhyUshort(sc, 0x15, 0x021e);
15858         MP_WritePhyUshort(sc, 0x19, 0x3224);
15859         MP_WritePhyUshort(sc, 0x15, 0x021f);
15860         MP_WritePhyUshort(sc, 0x19, 0x4002);
15861         MP_WritePhyUshort(sc, 0x15, 0x0220);
15862         MP_WritePhyUshort(sc, 0x19, 0x3224);
15863         MP_WritePhyUshort(sc, 0x15, 0x0221);
15864         MP_WritePhyUshort(sc, 0x19, 0x9e03);
15865         MP_WritePhyUshort(sc, 0x15, 0x0222);
15866         MP_WritePhyUshort(sc, 0x19, 0x7c40);
15867         MP_WritePhyUshort(sc, 0x15, 0x0223);
15868         MP_WritePhyUshort(sc, 0x19, 0x6840);
15869         MP_WritePhyUshort(sc, 0x15, 0x0224);
15870         MP_WritePhyUshort(sc, 0x19, 0x7800);
15871         MP_WritePhyUshort(sc, 0x15, 0x0225);
15872         MP_WritePhyUshort(sc, 0x19, 0x3231);
15873         MP_WritePhyUshort(sc, 0x15, 0x0000);
15874         MP_WritePhyUshort(sc, 0x16, 0x0306);
15875         MP_WritePhyUshort(sc, 0x16, 0x0300);
15876         MP_WritePhyUshort(sc, 0x1f, 0x0002);
15877         MP_WritePhyUshort(sc, 0x1f, 0x0000);
15878         MP_WritePhyUshort(sc, 0x1f, 0x0000);
15879         MP_WritePhyUshort(sc, 0x17, 0x2160);
15880         MP_WritePhyUshort(sc, 0x1f, 0x0007);
15881         MP_WritePhyUshort(sc, 0x1e, 0x0040);
15882         MP_WritePhyUshort(sc, 0x18, 0x0004);
15883         MP_WritePhyUshort(sc, 0x18, 0x09d4);
15884         MP_WritePhyUshort(sc, 0x19, 0x4000);
15885         MP_WritePhyUshort(sc, 0x18, 0x09e4);
15886         MP_WritePhyUshort(sc, 0x19, 0x0800);
15887         MP_WritePhyUshort(sc, 0x18, 0x09f4);
15888         MP_WritePhyUshort(sc, 0x19, 0xff00);
15889         MP_WritePhyUshort(sc, 0x18, 0x0a04);
15890         MP_WritePhyUshort(sc, 0x19, 0x4000);
15891         MP_WritePhyUshort(sc, 0x18, 0x0a14);
15892         MP_WritePhyUshort(sc, 0x19, 0x0c00);
15893         MP_WritePhyUshort(sc, 0x18, 0x0a24);
15894         MP_WritePhyUshort(sc, 0x19, 0xff00);
15895         MP_WritePhyUshort(sc, 0x18, 0x0a74);
15896         MP_WritePhyUshort(sc, 0x19, 0xf600);
15897         MP_WritePhyUshort(sc, 0x18, 0x1a24);
15898         MP_WritePhyUshort(sc, 0x19, 0x7d00);
15899         MP_WritePhyUshort(sc, 0x18, 0x1a64);
15900         MP_WritePhyUshort(sc, 0x19, 0x0500);
15901         MP_WritePhyUshort(sc, 0x18, 0x1a74);
15902         MP_WritePhyUshort(sc, 0x19, 0x9500);
15903         MP_WritePhyUshort(sc, 0x18, 0x1a84);
15904         MP_WritePhyUshort(sc, 0x19, 0x8000);
15905         MP_WritePhyUshort(sc, 0x18, 0x1a94);
15906         MP_WritePhyUshort(sc, 0x19, 0x7d00);
15907         MP_WritePhyUshort(sc, 0x18, 0x1aa4);
15908         MP_WritePhyUshort(sc, 0x19, 0x9600);
15909         MP_WritePhyUshort(sc, 0x18, 0x1ac4);
15910         MP_WritePhyUshort(sc, 0x19, 0x4000);
15911         MP_WritePhyUshort(sc, 0x18, 0x1ad4);
15912         MP_WritePhyUshort(sc, 0x19, 0x0800);
15913         MP_WritePhyUshort(sc, 0x18, 0x1af4);
15914         MP_WritePhyUshort(sc, 0x19, 0xc400);
15915         MP_WritePhyUshort(sc, 0x18, 0x1b04);
15916         MP_WritePhyUshort(sc, 0x19, 0x4000);
15917         MP_WritePhyUshort(sc, 0x18, 0x1b14);
15918         MP_WritePhyUshort(sc, 0x19, 0x0800);
15919         MP_WritePhyUshort(sc, 0x18, 0x1b24);
15920         MP_WritePhyUshort(sc, 0x19, 0xfd00);
15921         MP_WritePhyUshort(sc, 0x18, 0x1b34);
15922         MP_WritePhyUshort(sc, 0x19, 0x4000);
15923         MP_WritePhyUshort(sc, 0x18, 0x1b44);
15924         MP_WritePhyUshort(sc, 0x19, 0x0400);
15925         MP_WritePhyUshort(sc, 0x18, 0x1b94);
15926         MP_WritePhyUshort(sc, 0x19, 0xf100);
15927         MP_WritePhyUshort(sc, 0x1f, 0x0000);
15928         MP_WritePhyUshort(sc, 0x17, 0x2100);
15929         MP_WritePhyUshort(sc, 0x1f, 0x0007);
15930         MP_WritePhyUshort(sc, 0x1e, 0x0040);
15931         MP_WritePhyUshort(sc, 0x18, 0x0000);
15932         MP_WritePhyUshort(sc, 0x1f, 0x0000);
15933         MP_WritePhyUshort(sc, 0x1f, 0x0005);
15934         MP_WritePhyUshort(sc, 0x05, 0xfff6);
15935         MP_WritePhyUshort(sc, 0x06, 0x0080);
15936         MP_WritePhyUshort(sc, 0x05, 0x8000);
15937         MP_WritePhyUshort(sc, 0x06, 0x0280);
15938         MP_WritePhyUshort(sc, 0x06, 0x48f7);
15939         MP_WritePhyUshort(sc, 0x06, 0x00e0);
15940         MP_WritePhyUshort(sc, 0x06, 0xfff7);
15941         MP_WritePhyUshort(sc, 0x06, 0xa080);
15942         MP_WritePhyUshort(sc, 0x06, 0x02ae);
15943         MP_WritePhyUshort(sc, 0x06, 0xf602);
15944         MP_WritePhyUshort(sc, 0x06, 0x0115);
15945         MP_WritePhyUshort(sc, 0x06, 0x0201);
15946         MP_WritePhyUshort(sc, 0x06, 0x2202);
15947         MP_WritePhyUshort(sc, 0x06, 0x80a0);
15948         MP_WritePhyUshort(sc, 0x06, 0x0201);
15949         MP_WritePhyUshort(sc, 0x06, 0x3f02);
15950         MP_WritePhyUshort(sc, 0x06, 0x0159);
15951         MP_WritePhyUshort(sc, 0x06, 0x0280);
15952         MP_WritePhyUshort(sc, 0x06, 0xbd02);
15953         MP_WritePhyUshort(sc, 0x06, 0x80da);
15954         MP_WritePhyUshort(sc, 0x06, 0xe08b);
15955         MP_WritePhyUshort(sc, 0x06, 0x88e1);
15956         MP_WritePhyUshort(sc, 0x06, 0x8b89);
15957         MP_WritePhyUshort(sc, 0x06, 0x1e01);
15958         MP_WritePhyUshort(sc, 0x06, 0xe18b);
15959         MP_WritePhyUshort(sc, 0x06, 0x8a1e);
15960         MP_WritePhyUshort(sc, 0x06, 0x01e1);
15961         MP_WritePhyUshort(sc, 0x06, 0x8b8b);
15962         MP_WritePhyUshort(sc, 0x06, 0x1e01);
15963         MP_WritePhyUshort(sc, 0x06, 0xe18b);
15964         MP_WritePhyUshort(sc, 0x06, 0x8c1e);
15965         MP_WritePhyUshort(sc, 0x06, 0x01e1);
15966         MP_WritePhyUshort(sc, 0x06, 0x8b8d);
15967         MP_WritePhyUshort(sc, 0x06, 0x1e01);
15968         MP_WritePhyUshort(sc, 0x06, 0xe18b);
15969         MP_WritePhyUshort(sc, 0x06, 0x8e1e);
15970         MP_WritePhyUshort(sc, 0x06, 0x01a0);
15971         MP_WritePhyUshort(sc, 0x06, 0x00c7);
15972         MP_WritePhyUshort(sc, 0x06, 0xaebb);
15973         MP_WritePhyUshort(sc, 0x06, 0xd481);
15974         MP_WritePhyUshort(sc, 0x06, 0xd2e4);
15975         MP_WritePhyUshort(sc, 0x06, 0x8b92);
15976         MP_WritePhyUshort(sc, 0x06, 0xe58b);
15977         MP_WritePhyUshort(sc, 0x06, 0x93d1);
15978         MP_WritePhyUshort(sc, 0x06, 0x03bf);
15979         MP_WritePhyUshort(sc, 0x06, 0x859e);
15980         MP_WritePhyUshort(sc, 0x06, 0x0237);
15981         MP_WritePhyUshort(sc, 0x06, 0x23d1);
15982         MP_WritePhyUshort(sc, 0x06, 0x02bf);
15983         MP_WritePhyUshort(sc, 0x06, 0x85a1);
15984         MP_WritePhyUshort(sc, 0x06, 0x0237);
15985         MP_WritePhyUshort(sc, 0x06, 0x23ee);
15986         MP_WritePhyUshort(sc, 0x06, 0x8608);
15987         MP_WritePhyUshort(sc, 0x06, 0x03ee);
15988         MP_WritePhyUshort(sc, 0x06, 0x860a);
15989         MP_WritePhyUshort(sc, 0x06, 0x60ee);
15990         MP_WritePhyUshort(sc, 0x06, 0x8610);
15991         MP_WritePhyUshort(sc, 0x06, 0x00ee);
15992         MP_WritePhyUshort(sc, 0x06, 0x8611);
15993         MP_WritePhyUshort(sc, 0x06, 0x00ee);
15994         MP_WritePhyUshort(sc, 0x06, 0x8abe);
15995         MP_WritePhyUshort(sc, 0x06, 0x07ee);
15996         MP_WritePhyUshort(sc, 0x06, 0x8abf);
15997         MP_WritePhyUshort(sc, 0x06, 0x73ee);
15998         MP_WritePhyUshort(sc, 0x06, 0x8a95);
15999         MP_WritePhyUshort(sc, 0x06, 0x02bf);
16000         MP_WritePhyUshort(sc, 0x06, 0x8b88);
16001         MP_WritePhyUshort(sc, 0x06, 0xec00);
16002         MP_WritePhyUshort(sc, 0x06, 0x19a9);
16003         MP_WritePhyUshort(sc, 0x06, 0x8b90);
16004         MP_WritePhyUshort(sc, 0x06, 0xf9ee);
16005         MP_WritePhyUshort(sc, 0x06, 0xfff6);
16006         MP_WritePhyUshort(sc, 0x06, 0x00ee);
16007         MP_WritePhyUshort(sc, 0x06, 0xfff7);
16008         MP_WritePhyUshort(sc, 0x06, 0xfed1);
16009         MP_WritePhyUshort(sc, 0x06, 0x00bf);
16010         MP_WritePhyUshort(sc, 0x06, 0x8595);
16011         MP_WritePhyUshort(sc, 0x06, 0x0237);
16012         MP_WritePhyUshort(sc, 0x06, 0x23d1);
16013         MP_WritePhyUshort(sc, 0x06, 0x01bf);
16014         MP_WritePhyUshort(sc, 0x06, 0x8598);
16015         MP_WritePhyUshort(sc, 0x06, 0x0237);
16016         MP_WritePhyUshort(sc, 0x06, 0x2304);
16017         MP_WritePhyUshort(sc, 0x06, 0xf8e0);
16018         MP_WritePhyUshort(sc, 0x06, 0x8b8a);
16019         MP_WritePhyUshort(sc, 0x06, 0xad20);
16020         MP_WritePhyUshort(sc, 0x06, 0x14ee);
16021         MP_WritePhyUshort(sc, 0x06, 0x8b8a);
16022         MP_WritePhyUshort(sc, 0x06, 0x0002);
16023         MP_WritePhyUshort(sc, 0x06, 0x1f9a);
16024         MP_WritePhyUshort(sc, 0x06, 0xe0e4);
16025         MP_WritePhyUshort(sc, 0x06, 0x26e1);
16026         MP_WritePhyUshort(sc, 0x06, 0xe427);
16027         MP_WritePhyUshort(sc, 0x06, 0xeee4);
16028         MP_WritePhyUshort(sc, 0x06, 0x2623);
16029         MP_WritePhyUshort(sc, 0x06, 0xe5e4);
16030         MP_WritePhyUshort(sc, 0x06, 0x27fc);
16031         MP_WritePhyUshort(sc, 0x06, 0x04f8);
16032         MP_WritePhyUshort(sc, 0x06, 0xe08b);
16033         MP_WritePhyUshort(sc, 0x06, 0x8dad);
16034         MP_WritePhyUshort(sc, 0x06, 0x2014);
16035         MP_WritePhyUshort(sc, 0x06, 0xee8b);
16036         MP_WritePhyUshort(sc, 0x06, 0x8d00);
16037         MP_WritePhyUshort(sc, 0x06, 0xe08a);
16038         MP_WritePhyUshort(sc, 0x06, 0x5a78);
16039         MP_WritePhyUshort(sc, 0x06, 0x039e);
16040         MP_WritePhyUshort(sc, 0x06, 0x0902);
16041         MP_WritePhyUshort(sc, 0x06, 0x05db);
16042         MP_WritePhyUshort(sc, 0x06, 0x0282);
16043         MP_WritePhyUshort(sc, 0x06, 0x7b02);
16044         MP_WritePhyUshort(sc, 0x06, 0x3231);
16045         MP_WritePhyUshort(sc, 0x06, 0xfc04);
16046         MP_WritePhyUshort(sc, 0x06, 0xf8e0);
16047         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16048         MP_WritePhyUshort(sc, 0x06, 0xad20);
16049         MP_WritePhyUshort(sc, 0x06, 0x1df6);
16050         MP_WritePhyUshort(sc, 0x06, 0x20e4);
16051         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16052         MP_WritePhyUshort(sc, 0x06, 0x0281);
16053         MP_WritePhyUshort(sc, 0x06, 0x5c02);
16054         MP_WritePhyUshort(sc, 0x06, 0x2bcb);
16055         MP_WritePhyUshort(sc, 0x06, 0x022d);
16056         MP_WritePhyUshort(sc, 0x06, 0x2902);
16057         MP_WritePhyUshort(sc, 0x06, 0x03b4);
16058         MP_WritePhyUshort(sc, 0x06, 0x0285);
16059         MP_WritePhyUshort(sc, 0x06, 0x6402);
16060         MP_WritePhyUshort(sc, 0x06, 0x2eca);
16061         MP_WritePhyUshort(sc, 0x06, 0x0284);
16062         MP_WritePhyUshort(sc, 0x06, 0xcd02);
16063         MP_WritePhyUshort(sc, 0x06, 0x046f);
16064         MP_WritePhyUshort(sc, 0x06, 0xe08b);
16065         MP_WritePhyUshort(sc, 0x06, 0x8ead);
16066         MP_WritePhyUshort(sc, 0x06, 0x210b);
16067         MP_WritePhyUshort(sc, 0x06, 0xf621);
16068         MP_WritePhyUshort(sc, 0x06, 0xe48b);
16069         MP_WritePhyUshort(sc, 0x06, 0x8e02);
16070         MP_WritePhyUshort(sc, 0x06, 0x8520);
16071         MP_WritePhyUshort(sc, 0x06, 0x021b);
16072         MP_WritePhyUshort(sc, 0x06, 0xe8e0);
16073         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16074         MP_WritePhyUshort(sc, 0x06, 0xad22);
16075         MP_WritePhyUshort(sc, 0x06, 0x05f6);
16076         MP_WritePhyUshort(sc, 0x06, 0x22e4);
16077         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16078         MP_WritePhyUshort(sc, 0x06, 0xe08b);
16079         MP_WritePhyUshort(sc, 0x06, 0x8ead);
16080         MP_WritePhyUshort(sc, 0x06, 0x2308);
16081         MP_WritePhyUshort(sc, 0x06, 0xf623);
16082         MP_WritePhyUshort(sc, 0x06, 0xe48b);
16083         MP_WritePhyUshort(sc, 0x06, 0x8e02);
16084         MP_WritePhyUshort(sc, 0x06, 0x311c);
16085         MP_WritePhyUshort(sc, 0x06, 0xe08b);
16086         MP_WritePhyUshort(sc, 0x06, 0x8ead);
16087         MP_WritePhyUshort(sc, 0x06, 0x2405);
16088         MP_WritePhyUshort(sc, 0x06, 0xf624);
16089         MP_WritePhyUshort(sc, 0x06, 0xe48b);
16090         MP_WritePhyUshort(sc, 0x06, 0x8ee0);
16091         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16092         MP_WritePhyUshort(sc, 0x06, 0xad25);
16093         MP_WritePhyUshort(sc, 0x06, 0x05f6);
16094         MP_WritePhyUshort(sc, 0x06, 0x25e4);
16095         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16096         MP_WritePhyUshort(sc, 0x06, 0xe08b);
16097         MP_WritePhyUshort(sc, 0x06, 0x8ead);
16098         MP_WritePhyUshort(sc, 0x06, 0x2608);
16099         MP_WritePhyUshort(sc, 0x06, 0xf626);
16100         MP_WritePhyUshort(sc, 0x06, 0xe48b);
16101         MP_WritePhyUshort(sc, 0x06, 0x8e02);
16102         MP_WritePhyUshort(sc, 0x06, 0x2df5);
16103         MP_WritePhyUshort(sc, 0x06, 0xe08b);
16104         MP_WritePhyUshort(sc, 0x06, 0x8ead);
16105         MP_WritePhyUshort(sc, 0x06, 0x2705);
16106         MP_WritePhyUshort(sc, 0x06, 0xf627);
16107         MP_WritePhyUshort(sc, 0x06, 0xe48b);
16108         MP_WritePhyUshort(sc, 0x06, 0x8e02);
16109         MP_WritePhyUshort(sc, 0x06, 0x037a);
16110         MP_WritePhyUshort(sc, 0x06, 0xfc04);
16111         MP_WritePhyUshort(sc, 0x06, 0xf8f9);
16112         MP_WritePhyUshort(sc, 0x06, 0xfaef);
16113         MP_WritePhyUshort(sc, 0x06, 0x69e0);
16114         MP_WritePhyUshort(sc, 0x06, 0x8b87);
16115         MP_WritePhyUshort(sc, 0x06, 0xad20);
16116         MP_WritePhyUshort(sc, 0x06, 0x65d2);
16117         MP_WritePhyUshort(sc, 0x06, 0x00bf);
16118         MP_WritePhyUshort(sc, 0x06, 0x2fe9);
16119         MP_WritePhyUshort(sc, 0x06, 0x0236);
16120         MP_WritePhyUshort(sc, 0x06, 0xf61e);
16121         MP_WritePhyUshort(sc, 0x06, 0x21bf);
16122         MP_WritePhyUshort(sc, 0x06, 0x2ff5);
16123         MP_WritePhyUshort(sc, 0x06, 0x0236);
16124         MP_WritePhyUshort(sc, 0x06, 0xf60c);
16125         MP_WritePhyUshort(sc, 0x06, 0x111e);
16126         MP_WritePhyUshort(sc, 0x06, 0x21bf);
16127         MP_WritePhyUshort(sc, 0x06, 0x2ff8);
16128         MP_WritePhyUshort(sc, 0x06, 0x0236);
16129         MP_WritePhyUshort(sc, 0x06, 0xf60c);
16130         MP_WritePhyUshort(sc, 0x06, 0x121e);
16131         MP_WritePhyUshort(sc, 0x06, 0x21bf);
16132         MP_WritePhyUshort(sc, 0x06, 0x2ffb);
16133         MP_WritePhyUshort(sc, 0x06, 0x0236);
16134         MP_WritePhyUshort(sc, 0x06, 0xf60c);
16135         MP_WritePhyUshort(sc, 0x06, 0x131e);
16136         MP_WritePhyUshort(sc, 0x06, 0x21bf);
16137         MP_WritePhyUshort(sc, 0x06, 0x1f97);
16138         MP_WritePhyUshort(sc, 0x06, 0x0236);
16139         MP_WritePhyUshort(sc, 0x06, 0xf60c);
16140         MP_WritePhyUshort(sc, 0x06, 0x141e);
16141         MP_WritePhyUshort(sc, 0x06, 0x21bf);
16142         MP_WritePhyUshort(sc, 0x06, 0x859b);
16143         MP_WritePhyUshort(sc, 0x06, 0x0236);
16144         MP_WritePhyUshort(sc, 0x06, 0xf60c);
16145         MP_WritePhyUshort(sc, 0x06, 0x161e);
16146         MP_WritePhyUshort(sc, 0x06, 0x21e0);
16147         MP_WritePhyUshort(sc, 0x06, 0x8a8c);
16148         MP_WritePhyUshort(sc, 0x06, 0x1f02);
16149         MP_WritePhyUshort(sc, 0x06, 0x9e22);
16150         MP_WritePhyUshort(sc, 0x06, 0xe68a);
16151         MP_WritePhyUshort(sc, 0x06, 0x8cad);
16152         MP_WritePhyUshort(sc, 0x06, 0x3114);
16153         MP_WritePhyUshort(sc, 0x06, 0xad30);
16154         MP_WritePhyUshort(sc, 0x06, 0x11ef);
16155         MP_WritePhyUshort(sc, 0x06, 0x0258);
16156         MP_WritePhyUshort(sc, 0x06, 0x0c9e);
16157         MP_WritePhyUshort(sc, 0x06, 0x07ad);
16158         MP_WritePhyUshort(sc, 0x06, 0x3608);
16159         MP_WritePhyUshort(sc, 0x06, 0x5a30);
16160         MP_WritePhyUshort(sc, 0x06, 0x9f04);
16161         MP_WritePhyUshort(sc, 0x06, 0xd101);
16162         MP_WritePhyUshort(sc, 0x06, 0xae02);
16163         MP_WritePhyUshort(sc, 0x06, 0xd100);
16164         MP_WritePhyUshort(sc, 0x06, 0xbf2f);
16165         MP_WritePhyUshort(sc, 0x06, 0xf202);
16166         MP_WritePhyUshort(sc, 0x06, 0x3723);
16167         MP_WritePhyUshort(sc, 0x06, 0xef96);
16168         MP_WritePhyUshort(sc, 0x06, 0xfefd);
16169         MP_WritePhyUshort(sc, 0x06, 0xfc04);
16170         MP_WritePhyUshort(sc, 0x06, 0xf8f9);
16171         MP_WritePhyUshort(sc, 0x06, 0xface);
16172         MP_WritePhyUshort(sc, 0x06, 0xfaef);
16173         MP_WritePhyUshort(sc, 0x06, 0x69fa);
16174         MP_WritePhyUshort(sc, 0x06, 0xd401);
16175         MP_WritePhyUshort(sc, 0x06, 0x55b4);
16176         MP_WritePhyUshort(sc, 0x06, 0xfebf);
16177         MP_WritePhyUshort(sc, 0x06, 0x85a7);
16178         MP_WritePhyUshort(sc, 0x06, 0x0236);
16179         MP_WritePhyUshort(sc, 0x06, 0xf6ac);
16180         MP_WritePhyUshort(sc, 0x06, 0x280b);
16181         MP_WritePhyUshort(sc, 0x06, 0xbf85);
16182         MP_WritePhyUshort(sc, 0x06, 0xa402);
16183         MP_WritePhyUshort(sc, 0x06, 0x36f6);
16184         MP_WritePhyUshort(sc, 0x06, 0xac28);
16185         MP_WritePhyUshort(sc, 0x06, 0x49ae);
16186         MP_WritePhyUshort(sc, 0x06, 0x64bf);
16187         MP_WritePhyUshort(sc, 0x06, 0x85a4);
16188         MP_WritePhyUshort(sc, 0x06, 0x0236);
16189         MP_WritePhyUshort(sc, 0x06, 0xf6ac);
16190         MP_WritePhyUshort(sc, 0x06, 0x285b);
16191         MP_WritePhyUshort(sc, 0x06, 0xd000);
16192         MP_WritePhyUshort(sc, 0x06, 0x0282);
16193         MP_WritePhyUshort(sc, 0x06, 0x60ac);
16194         MP_WritePhyUshort(sc, 0x06, 0x2105);
16195         MP_WritePhyUshort(sc, 0x06, 0xac22);
16196         MP_WritePhyUshort(sc, 0x06, 0x02ae);
16197         MP_WritePhyUshort(sc, 0x06, 0x4ebf);
16198         MP_WritePhyUshort(sc, 0x06, 0xe0c4);
16199         MP_WritePhyUshort(sc, 0x06, 0xbe86);
16200         MP_WritePhyUshort(sc, 0x06, 0x14d2);
16201         MP_WritePhyUshort(sc, 0x06, 0x04d8);
16202         MP_WritePhyUshort(sc, 0x06, 0x19d9);
16203         MP_WritePhyUshort(sc, 0x06, 0x1907);
16204         MP_WritePhyUshort(sc, 0x06, 0xdc19);
16205         MP_WritePhyUshort(sc, 0x06, 0xdd19);
16206         MP_WritePhyUshort(sc, 0x06, 0x0789);
16207         MP_WritePhyUshort(sc, 0x06, 0x89ef);
16208         MP_WritePhyUshort(sc, 0x06, 0x645e);
16209         MP_WritePhyUshort(sc, 0x06, 0x07ff);
16210         MP_WritePhyUshort(sc, 0x06, 0x0d65);
16211         MP_WritePhyUshort(sc, 0x06, 0x5cf8);
16212         MP_WritePhyUshort(sc, 0x06, 0x001e);
16213         MP_WritePhyUshort(sc, 0x06, 0x46dc);
16214         MP_WritePhyUshort(sc, 0x06, 0x19dd);
16215         MP_WritePhyUshort(sc, 0x06, 0x19b2);
16216         MP_WritePhyUshort(sc, 0x06, 0xe2d4);
16217         MP_WritePhyUshort(sc, 0x06, 0x0001);
16218         MP_WritePhyUshort(sc, 0x06, 0xbf85);
16219         MP_WritePhyUshort(sc, 0x06, 0xa402);
16220         MP_WritePhyUshort(sc, 0x06, 0x3723);
16221         MP_WritePhyUshort(sc, 0x06, 0xae1d);
16222         MP_WritePhyUshort(sc, 0x06, 0xbee0);
16223         MP_WritePhyUshort(sc, 0x06, 0xc4bf);
16224         MP_WritePhyUshort(sc, 0x06, 0x8614);
16225         MP_WritePhyUshort(sc, 0x06, 0xd204);
16226         MP_WritePhyUshort(sc, 0x06, 0xd819);
16227         MP_WritePhyUshort(sc, 0x06, 0xd919);
16228         MP_WritePhyUshort(sc, 0x06, 0x07dc);
16229         MP_WritePhyUshort(sc, 0x06, 0x19dd);
16230         MP_WritePhyUshort(sc, 0x06, 0x1907);
16231         MP_WritePhyUshort(sc, 0x06, 0xb2f4);
16232         MP_WritePhyUshort(sc, 0x06, 0xd400);
16233         MP_WritePhyUshort(sc, 0x06, 0x00bf);
16234         MP_WritePhyUshort(sc, 0x06, 0x85a4);
16235         MP_WritePhyUshort(sc, 0x06, 0x0237);
16236         MP_WritePhyUshort(sc, 0x06, 0x23fe);
16237         MP_WritePhyUshort(sc, 0x06, 0xef96);
16238         MP_WritePhyUshort(sc, 0x06, 0xfec6);
16239         MP_WritePhyUshort(sc, 0x06, 0xfefd);
16240         MP_WritePhyUshort(sc, 0x06, 0xfc05);
16241         MP_WritePhyUshort(sc, 0x06, 0xf9e2);
16242         MP_WritePhyUshort(sc, 0x06, 0xe0ea);
16243         MP_WritePhyUshort(sc, 0x06, 0xe3e0);
16244         MP_WritePhyUshort(sc, 0x06, 0xeb5a);
16245         MP_WritePhyUshort(sc, 0x06, 0x070c);
16246         MP_WritePhyUshort(sc, 0x06, 0x031e);
16247         MP_WritePhyUshort(sc, 0x06, 0x20e6);
16248         MP_WritePhyUshort(sc, 0x06, 0xe0ea);
16249         MP_WritePhyUshort(sc, 0x06, 0xe7e0);
16250         MP_WritePhyUshort(sc, 0x06, 0xebe0);
16251         MP_WritePhyUshort(sc, 0x06, 0xe0fc);
16252         MP_WritePhyUshort(sc, 0x06, 0xe1e0);
16253         MP_WritePhyUshort(sc, 0x06, 0xfdfd);
16254         MP_WritePhyUshort(sc, 0x06, 0x04f8);
16255         MP_WritePhyUshort(sc, 0x06, 0xf9e0);
16256         MP_WritePhyUshort(sc, 0x06, 0x8b81);
16257         MP_WritePhyUshort(sc, 0x06, 0xac26);
16258         MP_WritePhyUshort(sc, 0x06, 0x1ae0);
16259         MP_WritePhyUshort(sc, 0x06, 0x8b81);
16260         MP_WritePhyUshort(sc, 0x06, 0xac21);
16261         MP_WritePhyUshort(sc, 0x06, 0x14e0);
16262         MP_WritePhyUshort(sc, 0x06, 0x8b85);
16263         MP_WritePhyUshort(sc, 0x06, 0xac20);
16264         MP_WritePhyUshort(sc, 0x06, 0x0ee0);
16265         MP_WritePhyUshort(sc, 0x06, 0x8b85);
16266         MP_WritePhyUshort(sc, 0x06, 0xac23);
16267         MP_WritePhyUshort(sc, 0x06, 0x08e0);
16268         MP_WritePhyUshort(sc, 0x06, 0x8b87);
16269         MP_WritePhyUshort(sc, 0x06, 0xac24);
16270         MP_WritePhyUshort(sc, 0x06, 0x02ae);
16271         MP_WritePhyUshort(sc, 0x06, 0x3802);
16272         MP_WritePhyUshort(sc, 0x06, 0x1ab5);
16273         MP_WritePhyUshort(sc, 0x06, 0xeee4);
16274         MP_WritePhyUshort(sc, 0x06, 0x1c04);
16275         MP_WritePhyUshort(sc, 0x06, 0xeee4);
16276         MP_WritePhyUshort(sc, 0x06, 0x1d04);
16277         MP_WritePhyUshort(sc, 0x06, 0xe2e0);
16278         MP_WritePhyUshort(sc, 0x06, 0x7ce3);
16279         MP_WritePhyUshort(sc, 0x06, 0xe07d);
16280         MP_WritePhyUshort(sc, 0x06, 0xe0e0);
16281         MP_WritePhyUshort(sc, 0x06, 0x38e1);
16282         MP_WritePhyUshort(sc, 0x06, 0xe039);
16283         MP_WritePhyUshort(sc, 0x06, 0xad2e);
16284         MP_WritePhyUshort(sc, 0x06, 0x1bad);
16285         MP_WritePhyUshort(sc, 0x06, 0x390d);
16286         MP_WritePhyUshort(sc, 0x06, 0xd101);
16287         MP_WritePhyUshort(sc, 0x06, 0xbf21);
16288         MP_WritePhyUshort(sc, 0x06, 0xd502);
16289         MP_WritePhyUshort(sc, 0x06, 0x3723);
16290         MP_WritePhyUshort(sc, 0x06, 0x0282);
16291         MP_WritePhyUshort(sc, 0x06, 0xd8ae);
16292         MP_WritePhyUshort(sc, 0x06, 0x0bac);
16293         MP_WritePhyUshort(sc, 0x06, 0x3802);
16294         MP_WritePhyUshort(sc, 0x06, 0xae06);
16295         MP_WritePhyUshort(sc, 0x06, 0x0283);
16296         MP_WritePhyUshort(sc, 0x06, 0x1802);
16297         MP_WritePhyUshort(sc, 0x06, 0x8360);
16298         MP_WritePhyUshort(sc, 0x06, 0x021a);
16299         MP_WritePhyUshort(sc, 0x06, 0xc6fd);
16300         MP_WritePhyUshort(sc, 0x06, 0xfc04);
16301         MP_WritePhyUshort(sc, 0x06, 0xf8e1);
16302         MP_WritePhyUshort(sc, 0x06, 0x8af4);
16303         MP_WritePhyUshort(sc, 0x06, 0xe08b);
16304         MP_WritePhyUshort(sc, 0x06, 0x81ad);
16305         MP_WritePhyUshort(sc, 0x06, 0x2605);
16306         MP_WritePhyUshort(sc, 0x06, 0x0222);
16307         MP_WritePhyUshort(sc, 0x06, 0xa4f7);
16308         MP_WritePhyUshort(sc, 0x06, 0x28e0);
16309         MP_WritePhyUshort(sc, 0x06, 0x8b81);
16310         MP_WritePhyUshort(sc, 0x06, 0xad21);
16311         MP_WritePhyUshort(sc, 0x06, 0x0502);
16312         MP_WritePhyUshort(sc, 0x06, 0x23a9);
16313         MP_WritePhyUshort(sc, 0x06, 0xf729);
16314         MP_WritePhyUshort(sc, 0x06, 0xe08b);
16315         MP_WritePhyUshort(sc, 0x06, 0x85ad);
16316         MP_WritePhyUshort(sc, 0x06, 0x2005);
16317         MP_WritePhyUshort(sc, 0x06, 0x0214);
16318         MP_WritePhyUshort(sc, 0x06, 0xabf7);
16319         MP_WritePhyUshort(sc, 0x06, 0x2ae0);
16320         MP_WritePhyUshort(sc, 0x06, 0x8b85);
16321         MP_WritePhyUshort(sc, 0x06, 0xad23);
16322         MP_WritePhyUshort(sc, 0x06, 0x0502);
16323         MP_WritePhyUshort(sc, 0x06, 0x12e7);
16324         MP_WritePhyUshort(sc, 0x06, 0xf72b);
16325         MP_WritePhyUshort(sc, 0x06, 0xe08b);
16326         MP_WritePhyUshort(sc, 0x06, 0x87ad);
16327         MP_WritePhyUshort(sc, 0x06, 0x2405);
16328         MP_WritePhyUshort(sc, 0x06, 0x0283);
16329         MP_WritePhyUshort(sc, 0x06, 0xbcf7);
16330         MP_WritePhyUshort(sc, 0x06, 0x2ce5);
16331         MP_WritePhyUshort(sc, 0x06, 0x8af4);
16332         MP_WritePhyUshort(sc, 0x06, 0xfc04);
16333         MP_WritePhyUshort(sc, 0x06, 0xf8e0);
16334         MP_WritePhyUshort(sc, 0x06, 0x8b81);
16335         MP_WritePhyUshort(sc, 0x06, 0xad26);
16336         MP_WritePhyUshort(sc, 0x06, 0x0302);
16337         MP_WritePhyUshort(sc, 0x06, 0x21e5);
16338         MP_WritePhyUshort(sc, 0x06, 0xe08b);
16339         MP_WritePhyUshort(sc, 0x06, 0x81ad);
16340         MP_WritePhyUshort(sc, 0x06, 0x2109);
16341         MP_WritePhyUshort(sc, 0x06, 0xe08a);
16342         MP_WritePhyUshort(sc, 0x06, 0xf4ac);
16343         MP_WritePhyUshort(sc, 0x06, 0x2003);
16344         MP_WritePhyUshort(sc, 0x06, 0x0223);
16345         MP_WritePhyUshort(sc, 0x06, 0x98e0);
16346         MP_WritePhyUshort(sc, 0x06, 0x8b85);
16347         MP_WritePhyUshort(sc, 0x06, 0xad20);
16348         MP_WritePhyUshort(sc, 0x06, 0x09e0);
16349         MP_WritePhyUshort(sc, 0x06, 0x8af4);
16350         MP_WritePhyUshort(sc, 0x06, 0xac21);
16351         MP_WritePhyUshort(sc, 0x06, 0x0302);
16352         MP_WritePhyUshort(sc, 0x06, 0x13fb);
16353         MP_WritePhyUshort(sc, 0x06, 0xe08b);
16354         MP_WritePhyUshort(sc, 0x06, 0x85ad);
16355         MP_WritePhyUshort(sc, 0x06, 0x2309);
16356         MP_WritePhyUshort(sc, 0x06, 0xe08a);
16357         MP_WritePhyUshort(sc, 0x06, 0xf4ac);
16358         MP_WritePhyUshort(sc, 0x06, 0x2203);
16359         MP_WritePhyUshort(sc, 0x06, 0x0212);
16360         MP_WritePhyUshort(sc, 0x06, 0xfae0);
16361         MP_WritePhyUshort(sc, 0x06, 0x8b87);
16362         MP_WritePhyUshort(sc, 0x06, 0xad24);
16363         MP_WritePhyUshort(sc, 0x06, 0x09e0);
16364         MP_WritePhyUshort(sc, 0x06, 0x8af4);
16365         MP_WritePhyUshort(sc, 0x06, 0xac23);
16366         MP_WritePhyUshort(sc, 0x06, 0x0302);
16367         MP_WritePhyUshort(sc, 0x06, 0x83c1);
16368         MP_WritePhyUshort(sc, 0x06, 0xfc04);
16369         MP_WritePhyUshort(sc, 0x06, 0xf8e1);
16370         MP_WritePhyUshort(sc, 0x06, 0x8af4);
16371         MP_WritePhyUshort(sc, 0x06, 0xe08b);
16372         MP_WritePhyUshort(sc, 0x06, 0x81ad);
16373         MP_WritePhyUshort(sc, 0x06, 0x2608);
16374         MP_WritePhyUshort(sc, 0x06, 0xe083);
16375         MP_WritePhyUshort(sc, 0x06, 0xd2ad);
16376         MP_WritePhyUshort(sc, 0x06, 0x2502);
16377         MP_WritePhyUshort(sc, 0x06, 0xf628);
16378         MP_WritePhyUshort(sc, 0x06, 0xe08b);
16379         MP_WritePhyUshort(sc, 0x06, 0x81ad);
16380         MP_WritePhyUshort(sc, 0x06, 0x210a);
16381         MP_WritePhyUshort(sc, 0x06, 0xe084);
16382         MP_WritePhyUshort(sc, 0x06, 0x0af6);
16383         MP_WritePhyUshort(sc, 0x06, 0x27a0);
16384         MP_WritePhyUshort(sc, 0x06, 0x0502);
16385         MP_WritePhyUshort(sc, 0x06, 0xf629);
16386         MP_WritePhyUshort(sc, 0x06, 0xe08b);
16387         MP_WritePhyUshort(sc, 0x06, 0x85ad);
16388         MP_WritePhyUshort(sc, 0x06, 0x2008);
16389         MP_WritePhyUshort(sc, 0x06, 0xe08a);
16390         MP_WritePhyUshort(sc, 0x06, 0xe8ad);
16391         MP_WritePhyUshort(sc, 0x06, 0x2102);
16392         MP_WritePhyUshort(sc, 0x06, 0xf62a);
16393         MP_WritePhyUshort(sc, 0x06, 0xe08b);
16394         MP_WritePhyUshort(sc, 0x06, 0x85ad);
16395         MP_WritePhyUshort(sc, 0x06, 0x2308);
16396         MP_WritePhyUshort(sc, 0x06, 0xe08b);
16397         MP_WritePhyUshort(sc, 0x06, 0x20a0);
16398         MP_WritePhyUshort(sc, 0x06, 0x0302);
16399         MP_WritePhyUshort(sc, 0x06, 0xf62b);
16400         MP_WritePhyUshort(sc, 0x06, 0xe08b);
16401         MP_WritePhyUshort(sc, 0x06, 0x87ad);
16402         MP_WritePhyUshort(sc, 0x06, 0x2408);
16403         MP_WritePhyUshort(sc, 0x06, 0xe086);
16404         MP_WritePhyUshort(sc, 0x06, 0x02a0);
16405         MP_WritePhyUshort(sc, 0x06, 0x0302);
16406         MP_WritePhyUshort(sc, 0x06, 0xf62c);
16407         MP_WritePhyUshort(sc, 0x06, 0xe58a);
16408         MP_WritePhyUshort(sc, 0x06, 0xf4a1);
16409         MP_WritePhyUshort(sc, 0x06, 0x0008);
16410         MP_WritePhyUshort(sc, 0x06, 0xd100);
16411         MP_WritePhyUshort(sc, 0x06, 0xbf21);
16412         MP_WritePhyUshort(sc, 0x06, 0xd502);
16413         MP_WritePhyUshort(sc, 0x06, 0x3723);
16414         MP_WritePhyUshort(sc, 0x06, 0xfc04);
16415         MP_WritePhyUshort(sc, 0x06, 0xee86);
16416         MP_WritePhyUshort(sc, 0x06, 0x0200);
16417         MP_WritePhyUshort(sc, 0x06, 0x04f8);
16418         MP_WritePhyUshort(sc, 0x06, 0xe08b);
16419         MP_WritePhyUshort(sc, 0x06, 0x87ad);
16420         MP_WritePhyUshort(sc, 0x06, 0x241e);
16421         MP_WritePhyUshort(sc, 0x06, 0xe086);
16422         MP_WritePhyUshort(sc, 0x06, 0x02a0);
16423         MP_WritePhyUshort(sc, 0x06, 0x0005);
16424         MP_WritePhyUshort(sc, 0x06, 0x0283);
16425         MP_WritePhyUshort(sc, 0x06, 0xe8ae);
16426         MP_WritePhyUshort(sc, 0x06, 0xf5a0);
16427         MP_WritePhyUshort(sc, 0x06, 0x0105);
16428         MP_WritePhyUshort(sc, 0x06, 0x0283);
16429         MP_WritePhyUshort(sc, 0x06, 0xf8ae);
16430         MP_WritePhyUshort(sc, 0x06, 0x0ba0);
16431         MP_WritePhyUshort(sc, 0x06, 0x0205);
16432         MP_WritePhyUshort(sc, 0x06, 0x0284);
16433         MP_WritePhyUshort(sc, 0x06, 0x14ae);
16434         MP_WritePhyUshort(sc, 0x06, 0x03a0);
16435         MP_WritePhyUshort(sc, 0x06, 0x0300);
16436         MP_WritePhyUshort(sc, 0x06, 0xfc04);
16437         MP_WritePhyUshort(sc, 0x06, 0xf8fa);
16438         MP_WritePhyUshort(sc, 0x06, 0xef69);
16439         MP_WritePhyUshort(sc, 0x06, 0x0284);
16440         MP_WritePhyUshort(sc, 0x06, 0x2bee);
16441         MP_WritePhyUshort(sc, 0x06, 0x8602);
16442         MP_WritePhyUshort(sc, 0x06, 0x01ef);
16443         MP_WritePhyUshort(sc, 0x06, 0x96fe);
16444         MP_WritePhyUshort(sc, 0x06, 0xfc04);
16445         MP_WritePhyUshort(sc, 0x06, 0xf8ee);
16446         MP_WritePhyUshort(sc, 0x06, 0x8609);
16447         MP_WritePhyUshort(sc, 0x06, 0x0002);
16448         MP_WritePhyUshort(sc, 0x06, 0x8461);
16449         MP_WritePhyUshort(sc, 0x06, 0xfc04);
16450         MP_WritePhyUshort(sc, 0x06, 0xae10);
16451         MP_WritePhyUshort(sc, 0x06, 0x0000);
16452         MP_WritePhyUshort(sc, 0x06, 0x0000);
16453         MP_WritePhyUshort(sc, 0x06, 0x0000);
16454         MP_WritePhyUshort(sc, 0x06, 0x0000);
16455         MP_WritePhyUshort(sc, 0x06, 0x0000);
16456         MP_WritePhyUshort(sc, 0x06, 0x0000);
16457         MP_WritePhyUshort(sc, 0x06, 0x0000);
16458         MP_WritePhyUshort(sc, 0x06, 0x0000);
16459         MP_WritePhyUshort(sc, 0x06, 0xf8e0);
16460         MP_WritePhyUshort(sc, 0x06, 0x8608);
16461         MP_WritePhyUshort(sc, 0x06, 0xe186);
16462         MP_WritePhyUshort(sc, 0x06, 0x091f);
16463         MP_WritePhyUshort(sc, 0x06, 0x019e);
16464         MP_WritePhyUshort(sc, 0x06, 0x0611);
16465         MP_WritePhyUshort(sc, 0x06, 0xe586);
16466         MP_WritePhyUshort(sc, 0x06, 0x09ae);
16467         MP_WritePhyUshort(sc, 0x06, 0x04ee);
16468         MP_WritePhyUshort(sc, 0x06, 0x8602);
16469         MP_WritePhyUshort(sc, 0x06, 0x01fc);
16470         MP_WritePhyUshort(sc, 0x06, 0x04f8);
16471         MP_WritePhyUshort(sc, 0x06, 0xf9fa);
16472         MP_WritePhyUshort(sc, 0x06, 0xef69);
16473         MP_WritePhyUshort(sc, 0x06, 0xfbbf);
16474         MP_WritePhyUshort(sc, 0x06, 0x8604);
16475         MP_WritePhyUshort(sc, 0x06, 0xef79);
16476         MP_WritePhyUshort(sc, 0x06, 0xd200);
16477         MP_WritePhyUshort(sc, 0x06, 0xd400);
16478         MP_WritePhyUshort(sc, 0x06, 0x221e);
16479         MP_WritePhyUshort(sc, 0x06, 0x02bf);
16480         MP_WritePhyUshort(sc, 0x06, 0x2fec);
16481         MP_WritePhyUshort(sc, 0x06, 0x0237);
16482         MP_WritePhyUshort(sc, 0x06, 0x23bf);
16483         MP_WritePhyUshort(sc, 0x06, 0x13f2);
16484         MP_WritePhyUshort(sc, 0x06, 0x0236);
16485         MP_WritePhyUshort(sc, 0x06, 0xf60d);
16486         MP_WritePhyUshort(sc, 0x06, 0x4559);
16487         MP_WritePhyUshort(sc, 0x06, 0x1fef);
16488         MP_WritePhyUshort(sc, 0x06, 0x97dd);
16489         MP_WritePhyUshort(sc, 0x06, 0xd308);
16490         MP_WritePhyUshort(sc, 0x06, 0x1a93);
16491         MP_WritePhyUshort(sc, 0x06, 0xdd12);
16492         MP_WritePhyUshort(sc, 0x06, 0x17a2);
16493         MP_WritePhyUshort(sc, 0x06, 0x04de);
16494         MP_WritePhyUshort(sc, 0x06, 0xffef);
16495         MP_WritePhyUshort(sc, 0x06, 0x96fe);
16496         MP_WritePhyUshort(sc, 0x06, 0xfdfc);
16497         MP_WritePhyUshort(sc, 0x06, 0x04f8);
16498         MP_WritePhyUshort(sc, 0x06, 0xf9fa);
16499         MP_WritePhyUshort(sc, 0x06, 0xef69);
16500         MP_WritePhyUshort(sc, 0x06, 0xfbee);
16501         MP_WritePhyUshort(sc, 0x06, 0x8602);
16502         MP_WritePhyUshort(sc, 0x06, 0x03d5);
16503         MP_WritePhyUshort(sc, 0x06, 0x0080);
16504         MP_WritePhyUshort(sc, 0x06, 0xbf86);
16505         MP_WritePhyUshort(sc, 0x06, 0x04ef);
16506         MP_WritePhyUshort(sc, 0x06, 0x79ef);
16507         MP_WritePhyUshort(sc, 0x06, 0x45bf);
16508         MP_WritePhyUshort(sc, 0x06, 0x2fec);
16509         MP_WritePhyUshort(sc, 0x06, 0x0237);
16510         MP_WritePhyUshort(sc, 0x06, 0x23bf);
16511         MP_WritePhyUshort(sc, 0x06, 0x13f2);
16512         MP_WritePhyUshort(sc, 0x06, 0x0236);
16513         MP_WritePhyUshort(sc, 0x06, 0xf6ad);
16514         MP_WritePhyUshort(sc, 0x06, 0x2702);
16515         MP_WritePhyUshort(sc, 0x06, 0x78ff);
16516         MP_WritePhyUshort(sc, 0x06, 0xe186);
16517         MP_WritePhyUshort(sc, 0x06, 0x0a1b);
16518         MP_WritePhyUshort(sc, 0x06, 0x01aa);
16519         MP_WritePhyUshort(sc, 0x06, 0x2eef);
16520         MP_WritePhyUshort(sc, 0x06, 0x97d9);
16521         MP_WritePhyUshort(sc, 0x06, 0x7900);
16522         MP_WritePhyUshort(sc, 0x06, 0x9e2b);
16523         MP_WritePhyUshort(sc, 0x06, 0x81dd);
16524         MP_WritePhyUshort(sc, 0x06, 0xbf85);
16525         MP_WritePhyUshort(sc, 0x06, 0xad02);
16526         MP_WritePhyUshort(sc, 0x06, 0x3723);
16527         MP_WritePhyUshort(sc, 0x06, 0xd101);
16528         MP_WritePhyUshort(sc, 0x06, 0xef02);
16529         MP_WritePhyUshort(sc, 0x06, 0x100c);
16530         MP_WritePhyUshort(sc, 0x06, 0x11b0);
16531         MP_WritePhyUshort(sc, 0x06, 0xfc0d);
16532         MP_WritePhyUshort(sc, 0x06, 0x11bf);
16533         MP_WritePhyUshort(sc, 0x06, 0x85aa);
16534         MP_WritePhyUshort(sc, 0x06, 0x0237);
16535         MP_WritePhyUshort(sc, 0x06, 0x23d1);
16536         MP_WritePhyUshort(sc, 0x06, 0x00bf);
16537         MP_WritePhyUshort(sc, 0x06, 0x85aa);
16538         MP_WritePhyUshort(sc, 0x06, 0x0237);
16539         MP_WritePhyUshort(sc, 0x06, 0x23ee);
16540         MP_WritePhyUshort(sc, 0x06, 0x8602);
16541         MP_WritePhyUshort(sc, 0x06, 0x02ae);
16542         MP_WritePhyUshort(sc, 0x06, 0x0413);
16543         MP_WritePhyUshort(sc, 0x06, 0xa38b);
16544         MP_WritePhyUshort(sc, 0x06, 0xb4d3);
16545         MP_WritePhyUshort(sc, 0x06, 0x8012);
16546         MP_WritePhyUshort(sc, 0x06, 0x17a2);
16547         MP_WritePhyUshort(sc, 0x06, 0x04ad);
16548         MP_WritePhyUshort(sc, 0x06, 0xffef);
16549         MP_WritePhyUshort(sc, 0x06, 0x96fe);
16550         MP_WritePhyUshort(sc, 0x06, 0xfdfc);
16551         MP_WritePhyUshort(sc, 0x06, 0x04f8);
16552         MP_WritePhyUshort(sc, 0x06, 0xf9e0);
16553         MP_WritePhyUshort(sc, 0x06, 0x8b85);
16554         MP_WritePhyUshort(sc, 0x06, 0xad25);
16555         MP_WritePhyUshort(sc, 0x06, 0x48e0);
16556         MP_WritePhyUshort(sc, 0x06, 0x8a96);
16557         MP_WritePhyUshort(sc, 0x06, 0xe18a);
16558         MP_WritePhyUshort(sc, 0x06, 0x977c);
16559         MP_WritePhyUshort(sc, 0x06, 0x0000);
16560         MP_WritePhyUshort(sc, 0x06, 0x9e35);
16561         MP_WritePhyUshort(sc, 0x06, 0xee8a);
16562         MP_WritePhyUshort(sc, 0x06, 0x9600);
16563         MP_WritePhyUshort(sc, 0x06, 0xee8a);
16564         MP_WritePhyUshort(sc, 0x06, 0x9700);
16565         MP_WritePhyUshort(sc, 0x06, 0xe08a);
16566         MP_WritePhyUshort(sc, 0x06, 0xbee1);
16567         MP_WritePhyUshort(sc, 0x06, 0x8abf);
16568         MP_WritePhyUshort(sc, 0x06, 0xe286);
16569         MP_WritePhyUshort(sc, 0x06, 0x10e3);
16570         MP_WritePhyUshort(sc, 0x06, 0x8611);
16571         MP_WritePhyUshort(sc, 0x06, 0x0236);
16572         MP_WritePhyUshort(sc, 0x06, 0x1aad);
16573         MP_WritePhyUshort(sc, 0x06, 0x2012);
16574         MP_WritePhyUshort(sc, 0x06, 0xee8a);
16575         MP_WritePhyUshort(sc, 0x06, 0x9603);
16576         MP_WritePhyUshort(sc, 0x06, 0xee8a);
16577         MP_WritePhyUshort(sc, 0x06, 0x97b7);
16578         MP_WritePhyUshort(sc, 0x06, 0xee86);
16579         MP_WritePhyUshort(sc, 0x06, 0x1000);
16580         MP_WritePhyUshort(sc, 0x06, 0xee86);
16581         MP_WritePhyUshort(sc, 0x06, 0x1100);
16582         MP_WritePhyUshort(sc, 0x06, 0xae11);
16583         MP_WritePhyUshort(sc, 0x06, 0x15e6);
16584         MP_WritePhyUshort(sc, 0x06, 0x8610);
16585         MP_WritePhyUshort(sc, 0x06, 0xe786);
16586         MP_WritePhyUshort(sc, 0x06, 0x11ae);
16587         MP_WritePhyUshort(sc, 0x06, 0x08ee);
16588         MP_WritePhyUshort(sc, 0x06, 0x8610);
16589         MP_WritePhyUshort(sc, 0x06, 0x00ee);
16590         MP_WritePhyUshort(sc, 0x06, 0x8611);
16591         MP_WritePhyUshort(sc, 0x06, 0x00fd);
16592         MP_WritePhyUshort(sc, 0x06, 0xfc04);
16593         MP_WritePhyUshort(sc, 0x06, 0xf8fa);
16594         MP_WritePhyUshort(sc, 0x06, 0xef69);
16595         MP_WritePhyUshort(sc, 0x06, 0xe0e0);
16596         MP_WritePhyUshort(sc, 0x06, 0x00e1);
16597         MP_WritePhyUshort(sc, 0x06, 0xe001);
16598         MP_WritePhyUshort(sc, 0x06, 0xad27);
16599         MP_WritePhyUshort(sc, 0x06, 0x32e0);
16600         MP_WritePhyUshort(sc, 0x06, 0x8b40);
16601         MP_WritePhyUshort(sc, 0x06, 0xf720);
16602         MP_WritePhyUshort(sc, 0x06, 0xe48b);
16603         MP_WritePhyUshort(sc, 0x06, 0x40bf);
16604         MP_WritePhyUshort(sc, 0x06, 0x31f5);
16605         MP_WritePhyUshort(sc, 0x06, 0x0236);
16606         MP_WritePhyUshort(sc, 0x06, 0xf6ad);
16607         MP_WritePhyUshort(sc, 0x06, 0x2821);
16608         MP_WritePhyUshort(sc, 0x06, 0xe0e0);
16609         MP_WritePhyUshort(sc, 0x06, 0x20e1);
16610         MP_WritePhyUshort(sc, 0x06, 0xe021);
16611         MP_WritePhyUshort(sc, 0x06, 0xad20);
16612         MP_WritePhyUshort(sc, 0x06, 0x18e0);
16613         MP_WritePhyUshort(sc, 0x06, 0x8b40);
16614         MP_WritePhyUshort(sc, 0x06, 0xf620);
16615         MP_WritePhyUshort(sc, 0x06, 0xe48b);
16616         MP_WritePhyUshort(sc, 0x06, 0x40ee);
16617         MP_WritePhyUshort(sc, 0x06, 0x8b3b);
16618         MP_WritePhyUshort(sc, 0x06, 0xffe0);
16619         MP_WritePhyUshort(sc, 0x06, 0x8a8a);
16620         MP_WritePhyUshort(sc, 0x06, 0xe18a);
16621         MP_WritePhyUshort(sc, 0x06, 0x8be4);
16622         MP_WritePhyUshort(sc, 0x06, 0xe000);
16623         MP_WritePhyUshort(sc, 0x06, 0xe5e0);
16624         MP_WritePhyUshort(sc, 0x06, 0x01ef);
16625         MP_WritePhyUshort(sc, 0x06, 0x96fe);
16626         MP_WritePhyUshort(sc, 0x06, 0xfc04);
16627         MP_WritePhyUshort(sc, 0x06, 0xf8fa);
16628         MP_WritePhyUshort(sc, 0x06, 0xef69);
16629         MP_WritePhyUshort(sc, 0x06, 0xe08b);
16630         MP_WritePhyUshort(sc, 0x06, 0x80ad);
16631         MP_WritePhyUshort(sc, 0x06, 0x2722);
16632         MP_WritePhyUshort(sc, 0x06, 0xbf44);
16633         MP_WritePhyUshort(sc, 0x06, 0xfc02);
16634         MP_WritePhyUshort(sc, 0x06, 0x36f6);
16635         MP_WritePhyUshort(sc, 0x06, 0xe08b);
16636         MP_WritePhyUshort(sc, 0x06, 0x441f);
16637         MP_WritePhyUshort(sc, 0x06, 0x019e);
16638         MP_WritePhyUshort(sc, 0x06, 0x15e5);
16639         MP_WritePhyUshort(sc, 0x06, 0x8b44);
16640         MP_WritePhyUshort(sc, 0x06, 0xad29);
16641         MP_WritePhyUshort(sc, 0x06, 0x07ac);
16642         MP_WritePhyUshort(sc, 0x06, 0x2804);
16643         MP_WritePhyUshort(sc, 0x06, 0xd101);
16644         MP_WritePhyUshort(sc, 0x06, 0xae02);
16645         MP_WritePhyUshort(sc, 0x06, 0xd100);
16646         MP_WritePhyUshort(sc, 0x06, 0xbf85);
16647         MP_WritePhyUshort(sc, 0x06, 0xb002);
16648         MP_WritePhyUshort(sc, 0x06, 0x3723);
16649         MP_WritePhyUshort(sc, 0x06, 0xef96);
16650         MP_WritePhyUshort(sc, 0x06, 0xfefc);
16651         MP_WritePhyUshort(sc, 0x06, 0x0400);
16652         MP_WritePhyUshort(sc, 0x06, 0xe140);
16653         MP_WritePhyUshort(sc, 0x06, 0x77e1);
16654         MP_WritePhyUshort(sc, 0x06, 0x40dd);
16655         MP_WritePhyUshort(sc, 0x06, 0xe022);
16656         MP_WritePhyUshort(sc, 0x06, 0x32e1);
16657         MP_WritePhyUshort(sc, 0x06, 0x5074);
16658         MP_WritePhyUshort(sc, 0x06, 0xe144);
16659         MP_WritePhyUshort(sc, 0x06, 0xffe0);
16660         MP_WritePhyUshort(sc, 0x06, 0xdaff);
16661         MP_WritePhyUshort(sc, 0x06, 0xe0c0);
16662         MP_WritePhyUshort(sc, 0x06, 0x52e0);
16663         MP_WritePhyUshort(sc, 0x06, 0xeed9);
16664         MP_WritePhyUshort(sc, 0x06, 0xe04c);
16665         MP_WritePhyUshort(sc, 0x06, 0xbbe0);
16666         MP_WritePhyUshort(sc, 0x06, 0x2a00);
16667         MP_WritePhyUshort(sc, 0x05, 0xe142);
16668         PhyRegValue = MP_ReadPhyUshort(sc, 0x06);
16669         PhyRegValue |= BIT_0;
16670         MP_WritePhyUshort(sc, 0x06, PhyRegValue);
16671         MP_WritePhyUshort(sc, 0x05, 0xe140);
16672         PhyRegValue = MP_ReadPhyUshort(sc, 0x06);
16673         PhyRegValue |= BIT_0;
16674         MP_WritePhyUshort(sc, 0x06, PhyRegValue);
16675         MP_WritePhyUshort(sc, 0x1f, 0x0000);
16676         MP_WritePhyUshort(sc, 0x1f, 0x0005);
16677         for (i = 0; i < 200; i++) {
16678                 DELAY(100);
16679                 PhyRegValue = MP_ReadPhyUshort(sc, 0x00);
16680                 if (PhyRegValue & BIT_7)
16681                         break;
16682         }
16683
16684         MP_WritePhyUshort(sc, 0x1F, 0x0003);
16685         MP_WritePhyUshort(sc, 0x09, 0xA20F);
16686         MP_WritePhyUshort(sc, 0x1F, 0x0000);
16687
16688         MP_WritePhyUshort(sc, 0x1f, 0x0003);
16689         PhyRegValue = MP_ReadPhyUshort(sc, 0x19);
16690         PhyRegValue &= ~BIT_0;
16691         MP_WritePhyUshort(sc, 0x19, PhyRegValue);
16692         PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
16693         PhyRegValue &= ~BIT_10;
16694         MP_WritePhyUshort(sc, 0x10, PhyRegValue);
16695         MP_WritePhyUshort(sc, 0x1f, 0x0000);
16696
16697         MP_WritePhyUshort(sc, 0x1f, 0x0007);
16698         MP_WritePhyUshort(sc, 0x1e, 0x0042);
16699         MP_WritePhyUshort(sc, 0x18, 0x2300);
16700         MP_WritePhyUshort(sc, 0x1f, 0x0000);
16701         MP_WritePhyUshort(sc, 0x1f, 0x0007);
16702         MP_WritePhyUshort(sc, 0x1e, 0x0023);
16703         PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
16704         if (sc->RequiredSecLanDonglePatch)
16705                 PhyRegValue &= ~(BIT_2);
16706         MP_WritePhyUshort(sc, 0x17, PhyRegValue);
16707         MP_WritePhyUshort(sc, 0x1f, 0x0000);
16708         MP_WritePhyUshort(sc, 0x00, 0x9200);
16709 }
16710
16711 static void re_set_phy_mcu_8168f_1(struct re_softc *sc)
16712 {
16713         u_int16_t PhyRegValue;
16714         int i;
16715
16716         MP_WritePhyUshort(sc, 0x1f, 0x0000);
16717         MP_WritePhyUshort(sc, 0x00, 0x1800);
16718         PhyRegValue = MP_ReadPhyUshort(sc, 0x15);
16719         PhyRegValue &= ~(BIT_12);
16720         MP_WritePhyUshort(sc, 0x15, PhyRegValue);
16721         MP_WritePhyUshort(sc, 0x00, 0x4800);
16722         MP_WritePhyUshort(sc, 0x1f, 0x0007);
16723         MP_WritePhyUshort(sc, 0x1e, 0x002f);
16724         for (i = 0; i < 1000; i++) {
16725                 DELAY(100);
16726                 PhyRegValue = MP_ReadPhyUshort(sc, 0x1c);
16727                 if (PhyRegValue & BIT_7)
16728                         break;
16729         }
16730         MP_WritePhyUshort(sc, 0x1f, 0x0000);
16731         MP_WritePhyUshort(sc, 0x00, 0x1800);
16732         MP_WritePhyUshort(sc, 0x1f, 0x0007);
16733         MP_WritePhyUshort(sc, 0x1e, 0x0023);
16734         for (i = 0; i < 200; i++) {
16735                 DELAY(100);
16736                 PhyRegValue = MP_ReadPhyUshort(sc, 0x18);
16737                 if (!(PhyRegValue & BIT_0))
16738                         break;
16739         }
16740         MP_WritePhyUshort(sc, 0x1f, 0x0005);
16741         MP_WritePhyUshort(sc, 0x05, 0xfff6);
16742         MP_WritePhyUshort(sc, 0x06, 0x0080);
16743         MP_WritePhyUshort(sc, 0x1f, 0x0007);
16744         MP_WritePhyUshort(sc, 0x1e, 0x0023);
16745         MP_WritePhyUshort(sc, 0x16, 0x0306);
16746         MP_WritePhyUshort(sc, 0x16, 0x0307);
16747         MP_WritePhyUshort(sc, 0x15, 0x0194);
16748         MP_WritePhyUshort(sc, 0x19, 0x407D);
16749         MP_WritePhyUshort(sc, 0x15, 0x0098);
16750         MP_WritePhyUshort(sc, 0x19, 0x7c0b);
16751         MP_WritePhyUshort(sc, 0x15, 0x0099);
16752         MP_WritePhyUshort(sc, 0x19, 0x6c0b);
16753         MP_WritePhyUshort(sc, 0x15, 0x00eb);
16754         MP_WritePhyUshort(sc, 0x19, 0x6c0b);
16755         MP_WritePhyUshort(sc, 0x15, 0x00f8);
16756         MP_WritePhyUshort(sc, 0x19, 0x6f0b);
16757         MP_WritePhyUshort(sc, 0x15, 0x00fe);
16758         MP_WritePhyUshort(sc, 0x19, 0x6f0f);
16759         MP_WritePhyUshort(sc, 0x15, 0x00db);
16760         MP_WritePhyUshort(sc, 0x19, 0x6f09);
16761         MP_WritePhyUshort(sc, 0x15, 0x00dc);
16762         MP_WritePhyUshort(sc, 0x19, 0xaefd);
16763         MP_WritePhyUshort(sc, 0x15, 0x00dd);
16764         MP_WritePhyUshort(sc, 0x19, 0x6f0b);
16765         MP_WritePhyUshort(sc, 0x15, 0x00de);
16766         MP_WritePhyUshort(sc, 0x19, 0xc60b);
16767         MP_WritePhyUshort(sc, 0x15, 0x00df);
16768         MP_WritePhyUshort(sc, 0x19, 0x00fa);
16769         MP_WritePhyUshort(sc, 0x15, 0x00e0);
16770         MP_WritePhyUshort(sc, 0x19, 0x30e1);
16771         MP_WritePhyUshort(sc, 0x15, 0x020c);
16772         MP_WritePhyUshort(sc, 0x19, 0x3224);
16773         MP_WritePhyUshort(sc, 0x15, 0x020e);
16774         MP_WritePhyUshort(sc, 0x19, 0x9813);
16775         MP_WritePhyUshort(sc, 0x15, 0x020f);
16776         MP_WritePhyUshort(sc, 0x19, 0x7801);
16777         MP_WritePhyUshort(sc, 0x15, 0x0210);
16778         MP_WritePhyUshort(sc, 0x19, 0x930f);
16779         MP_WritePhyUshort(sc, 0x15, 0x0211);
16780         MP_WritePhyUshort(sc, 0x19, 0x9206);
16781         MP_WritePhyUshort(sc, 0x15, 0x0212);
16782         MP_WritePhyUshort(sc, 0x19, 0x4002);
16783         MP_WritePhyUshort(sc, 0x15, 0x0213);
16784         MP_WritePhyUshort(sc, 0x19, 0x7800);
16785         MP_WritePhyUshort(sc, 0x15, 0x0214);
16786         MP_WritePhyUshort(sc, 0x19, 0x588f);
16787         MP_WritePhyUshort(sc, 0x15, 0x0215);
16788         MP_WritePhyUshort(sc, 0x19, 0x5520);
16789         MP_WritePhyUshort(sc, 0x15, 0x0216);
16790         MP_WritePhyUshort(sc, 0x19, 0x3224);
16791         MP_WritePhyUshort(sc, 0x15, 0x0217);
16792         MP_WritePhyUshort(sc, 0x19, 0x4002);
16793         MP_WritePhyUshort(sc, 0x15, 0x0218);
16794         MP_WritePhyUshort(sc, 0x19, 0x7800);
16795         MP_WritePhyUshort(sc, 0x15, 0x0219);
16796         MP_WritePhyUshort(sc, 0x19, 0x588d);
16797         MP_WritePhyUshort(sc, 0x15, 0x021a);
16798         MP_WritePhyUshort(sc, 0x19, 0x5540);
16799         MP_WritePhyUshort(sc, 0x15, 0x021b);
16800         MP_WritePhyUshort(sc, 0x19, 0x9e03);
16801         MP_WritePhyUshort(sc, 0x15, 0x021c);
16802         MP_WritePhyUshort(sc, 0x19, 0x7c40);
16803         MP_WritePhyUshort(sc, 0x15, 0x021d);
16804         MP_WritePhyUshort(sc, 0x19, 0x6840);
16805         MP_WritePhyUshort(sc, 0x15, 0x021e);
16806         MP_WritePhyUshort(sc, 0x19, 0x3224);
16807         MP_WritePhyUshort(sc, 0x15, 0x021f);
16808         MP_WritePhyUshort(sc, 0x19, 0x4002);
16809         MP_WritePhyUshort(sc, 0x15, 0x0220);
16810         MP_WritePhyUshort(sc, 0x19, 0x3224);
16811         MP_WritePhyUshort(sc, 0x15, 0x0221);
16812         MP_WritePhyUshort(sc, 0x19, 0x9e03);
16813         MP_WritePhyUshort(sc, 0x15, 0x0222);
16814         MP_WritePhyUshort(sc, 0x19, 0x7c40);
16815         MP_WritePhyUshort(sc, 0x15, 0x0223);
16816         MP_WritePhyUshort(sc, 0x19, 0x6840);
16817         MP_WritePhyUshort(sc, 0x15, 0x0224);
16818         MP_WritePhyUshort(sc, 0x19, 0x7800);
16819         MP_WritePhyUshort(sc, 0x15, 0x0225);
16820         MP_WritePhyUshort(sc, 0x19, 0x3231);
16821         MP_WritePhyUshort(sc, 0x15, 0x0000);
16822         MP_WritePhyUshort(sc, 0x16, 0x0306);
16823         MP_WritePhyUshort(sc, 0x16, 0x0300);
16824         MP_WritePhyUshort(sc, 0x1f, 0x0000);
16825         MP_WritePhyUshort(sc, 0x1f, 0x0005);
16826         MP_WritePhyUshort(sc, 0x05, 0xfff6);
16827         MP_WritePhyUshort(sc, 0x06, 0x0080);
16828         MP_WritePhyUshort(sc, 0x05, 0x8000);
16829         MP_WritePhyUshort(sc, 0x06, 0x0280);
16830         MP_WritePhyUshort(sc, 0x06, 0x48f7);
16831         MP_WritePhyUshort(sc, 0x06, 0x00e0);
16832         MP_WritePhyUshort(sc, 0x06, 0xfff7);
16833         MP_WritePhyUshort(sc, 0x06, 0xa080);
16834         MP_WritePhyUshort(sc, 0x06, 0x02ae);
16835         MP_WritePhyUshort(sc, 0x06, 0xf602);
16836         MP_WritePhyUshort(sc, 0x06, 0x0118);
16837         MP_WritePhyUshort(sc, 0x06, 0x0201);
16838         MP_WritePhyUshort(sc, 0x06, 0x2502);
16839         MP_WritePhyUshort(sc, 0x06, 0x8090);
16840         MP_WritePhyUshort(sc, 0x06, 0x0201);
16841         MP_WritePhyUshort(sc, 0x06, 0x4202);
16842         MP_WritePhyUshort(sc, 0x06, 0x015c);
16843         MP_WritePhyUshort(sc, 0x06, 0x0280);
16844         MP_WritePhyUshort(sc, 0x06, 0xad02);
16845         MP_WritePhyUshort(sc, 0x06, 0x80ca);
16846         MP_WritePhyUshort(sc, 0x06, 0xe08b);
16847         MP_WritePhyUshort(sc, 0x06, 0x88e1);
16848         MP_WritePhyUshort(sc, 0x06, 0x8b89);
16849         MP_WritePhyUshort(sc, 0x06, 0x1e01);
16850         MP_WritePhyUshort(sc, 0x06, 0xe18b);
16851         MP_WritePhyUshort(sc, 0x06, 0x8a1e);
16852         MP_WritePhyUshort(sc, 0x06, 0x01e1);
16853         MP_WritePhyUshort(sc, 0x06, 0x8b8b);
16854         MP_WritePhyUshort(sc, 0x06, 0x1e01);
16855         MP_WritePhyUshort(sc, 0x06, 0xe18b);
16856         MP_WritePhyUshort(sc, 0x06, 0x8c1e);
16857         MP_WritePhyUshort(sc, 0x06, 0x01e1);
16858         MP_WritePhyUshort(sc, 0x06, 0x8b8d);
16859         MP_WritePhyUshort(sc, 0x06, 0x1e01);
16860         MP_WritePhyUshort(sc, 0x06, 0xe18b);
16861         MP_WritePhyUshort(sc, 0x06, 0x8e1e);
16862         MP_WritePhyUshort(sc, 0x06, 0x01a0);
16863         MP_WritePhyUshort(sc, 0x06, 0x00c7);
16864         MP_WritePhyUshort(sc, 0x06, 0xaebb);
16865         MP_WritePhyUshort(sc, 0x06, 0xd484);
16866         MP_WritePhyUshort(sc, 0x06, 0x3ce4);
16867         MP_WritePhyUshort(sc, 0x06, 0x8b92);
16868         MP_WritePhyUshort(sc, 0x06, 0xe58b);
16869         MP_WritePhyUshort(sc, 0x06, 0x93ee);
16870         MP_WritePhyUshort(sc, 0x06, 0x8ac8);
16871         MP_WritePhyUshort(sc, 0x06, 0x03ee);
16872         MP_WritePhyUshort(sc, 0x06, 0x8aca);
16873         MP_WritePhyUshort(sc, 0x06, 0x60ee);
16874         MP_WritePhyUshort(sc, 0x06, 0x8ac0);
16875         MP_WritePhyUshort(sc, 0x06, 0x00ee);
16876         MP_WritePhyUshort(sc, 0x06, 0x8ac1);
16877         MP_WritePhyUshort(sc, 0x06, 0x00ee);
16878         MP_WritePhyUshort(sc, 0x06, 0x8abe);
16879         MP_WritePhyUshort(sc, 0x06, 0x07ee);
16880         MP_WritePhyUshort(sc, 0x06, 0x8abf);
16881         MP_WritePhyUshort(sc, 0x06, 0x73ee);
16882         MP_WritePhyUshort(sc, 0x06, 0x8a95);
16883         MP_WritePhyUshort(sc, 0x06, 0x02bf);
16884         MP_WritePhyUshort(sc, 0x06, 0x8b88);
16885         MP_WritePhyUshort(sc, 0x06, 0xec00);
16886         MP_WritePhyUshort(sc, 0x06, 0x19a9);
16887         MP_WritePhyUshort(sc, 0x06, 0x8b90);
16888         MP_WritePhyUshort(sc, 0x06, 0xf9ee);
16889         MP_WritePhyUshort(sc, 0x06, 0xfff6);
16890         MP_WritePhyUshort(sc, 0x06, 0x00ee);
16891         MP_WritePhyUshort(sc, 0x06, 0xfff7);
16892         MP_WritePhyUshort(sc, 0x06, 0xfed1);
16893         MP_WritePhyUshort(sc, 0x06, 0x00bf);
16894         MP_WritePhyUshort(sc, 0x06, 0x85a4);
16895         MP_WritePhyUshort(sc, 0x06, 0x0238);
16896         MP_WritePhyUshort(sc, 0x06, 0x7dd1);
16897         MP_WritePhyUshort(sc, 0x06, 0x01bf);
16898         MP_WritePhyUshort(sc, 0x06, 0x85a7);
16899         MP_WritePhyUshort(sc, 0x06, 0x0238);
16900         MP_WritePhyUshort(sc, 0x06, 0x7d04);
16901         MP_WritePhyUshort(sc, 0x06, 0xf8e0);
16902         MP_WritePhyUshort(sc, 0x06, 0x8b8a);
16903         MP_WritePhyUshort(sc, 0x06, 0xad20);
16904         MP_WritePhyUshort(sc, 0x06, 0x14ee);
16905         MP_WritePhyUshort(sc, 0x06, 0x8b8a);
16906         MP_WritePhyUshort(sc, 0x06, 0x0002);
16907         MP_WritePhyUshort(sc, 0x06, 0x204b);
16908         MP_WritePhyUshort(sc, 0x06, 0xe0e4);
16909         MP_WritePhyUshort(sc, 0x06, 0x26e1);
16910         MP_WritePhyUshort(sc, 0x06, 0xe427);
16911         MP_WritePhyUshort(sc, 0x06, 0xeee4);
16912         MP_WritePhyUshort(sc, 0x06, 0x2623);
16913         MP_WritePhyUshort(sc, 0x06, 0xe5e4);
16914         MP_WritePhyUshort(sc, 0x06, 0x27fc);
16915         MP_WritePhyUshort(sc, 0x06, 0x04f8);
16916         MP_WritePhyUshort(sc, 0x06, 0xe08b);
16917         MP_WritePhyUshort(sc, 0x06, 0x8dad);
16918         MP_WritePhyUshort(sc, 0x06, 0x2014);
16919         MP_WritePhyUshort(sc, 0x06, 0xee8b);
16920         MP_WritePhyUshort(sc, 0x06, 0x8d00);
16921         MP_WritePhyUshort(sc, 0x06, 0xe08a);
16922         MP_WritePhyUshort(sc, 0x06, 0x5a78);
16923         MP_WritePhyUshort(sc, 0x06, 0x039e);
16924         MP_WritePhyUshort(sc, 0x06, 0x0902);
16925         MP_WritePhyUshort(sc, 0x06, 0x05e8);
16926         MP_WritePhyUshort(sc, 0x06, 0x0281);
16927         MP_WritePhyUshort(sc, 0x06, 0x4f02);
16928         MP_WritePhyUshort(sc, 0x06, 0x326c);
16929         MP_WritePhyUshort(sc, 0x06, 0xfc04);
16930         MP_WritePhyUshort(sc, 0x06, 0xf8e0);
16931         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16932         MP_WritePhyUshort(sc, 0x06, 0xad20);
16933         MP_WritePhyUshort(sc, 0x06, 0x1df6);
16934         MP_WritePhyUshort(sc, 0x06, 0x20e4);
16935         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16936         MP_WritePhyUshort(sc, 0x06, 0x022f);
16937         MP_WritePhyUshort(sc, 0x06, 0x0902);
16938         MP_WritePhyUshort(sc, 0x06, 0x2ab0);
16939         MP_WritePhyUshort(sc, 0x06, 0x0285);
16940         MP_WritePhyUshort(sc, 0x06, 0x1602);
16941         MP_WritePhyUshort(sc, 0x06, 0x03ba);
16942         MP_WritePhyUshort(sc, 0x06, 0x0284);
16943         MP_WritePhyUshort(sc, 0x06, 0xe502);
16944         MP_WritePhyUshort(sc, 0x06, 0x2df1);
16945         MP_WritePhyUshort(sc, 0x06, 0x0283);
16946         MP_WritePhyUshort(sc, 0x06, 0x8302);
16947         MP_WritePhyUshort(sc, 0x06, 0x0475);
16948         MP_WritePhyUshort(sc, 0x06, 0xe08b);
16949         MP_WritePhyUshort(sc, 0x06, 0x8ead);
16950         MP_WritePhyUshort(sc, 0x06, 0x210b);
16951         MP_WritePhyUshort(sc, 0x06, 0xf621);
16952         MP_WritePhyUshort(sc, 0x06, 0xe48b);
16953         MP_WritePhyUshort(sc, 0x06, 0x8e02);
16954         MP_WritePhyUshort(sc, 0x06, 0x83f8);
16955         MP_WritePhyUshort(sc, 0x06, 0x021c);
16956         MP_WritePhyUshort(sc, 0x06, 0x99e0);
16957         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16958         MP_WritePhyUshort(sc, 0x06, 0xad22);
16959         MP_WritePhyUshort(sc, 0x06, 0x08f6);
16960         MP_WritePhyUshort(sc, 0x06, 0x22e4);
16961         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16962         MP_WritePhyUshort(sc, 0x06, 0x0235);
16963         MP_WritePhyUshort(sc, 0x06, 0x63e0);
16964         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16965         MP_WritePhyUshort(sc, 0x06, 0xad23);
16966         MP_WritePhyUshort(sc, 0x06, 0x08f6);
16967         MP_WritePhyUshort(sc, 0x06, 0x23e4);
16968         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16969         MP_WritePhyUshort(sc, 0x06, 0x0231);
16970         MP_WritePhyUshort(sc, 0x06, 0x57e0);
16971         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16972         MP_WritePhyUshort(sc, 0x06, 0xad24);
16973         MP_WritePhyUshort(sc, 0x06, 0x05f6);
16974         MP_WritePhyUshort(sc, 0x06, 0x24e4);
16975         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16976         MP_WritePhyUshort(sc, 0x06, 0xe08b);
16977         MP_WritePhyUshort(sc, 0x06, 0x8ead);
16978         MP_WritePhyUshort(sc, 0x06, 0x2505);
16979         MP_WritePhyUshort(sc, 0x06, 0xf625);
16980         MP_WritePhyUshort(sc, 0x06, 0xe48b);
16981         MP_WritePhyUshort(sc, 0x06, 0x8ee0);
16982         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16983         MP_WritePhyUshort(sc, 0x06, 0xad26);
16984         MP_WritePhyUshort(sc, 0x06, 0x08f6);
16985         MP_WritePhyUshort(sc, 0x06, 0x26e4);
16986         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16987         MP_WritePhyUshort(sc, 0x06, 0x022d);
16988         MP_WritePhyUshort(sc, 0x06, 0x1ce0);
16989         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16990         MP_WritePhyUshort(sc, 0x06, 0xad27);
16991         MP_WritePhyUshort(sc, 0x06, 0x05f6);
16992         MP_WritePhyUshort(sc, 0x06, 0x27e4);
16993         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16994         MP_WritePhyUshort(sc, 0x06, 0x0203);
16995         MP_WritePhyUshort(sc, 0x06, 0x80fc);
16996         MP_WritePhyUshort(sc, 0x06, 0x04f8);
16997         MP_WritePhyUshort(sc, 0x06, 0xf9e0);
16998         MP_WritePhyUshort(sc, 0x06, 0x8b81);
16999         MP_WritePhyUshort(sc, 0x06, 0xac26);
17000         MP_WritePhyUshort(sc, 0x06, 0x1ae0);
17001         MP_WritePhyUshort(sc, 0x06, 0x8b81);
17002         MP_WritePhyUshort(sc, 0x06, 0xac21);
17003         MP_WritePhyUshort(sc, 0x06, 0x14e0);
17004         MP_WritePhyUshort(sc, 0x06, 0x8b85);
17005         MP_WritePhyUshort(sc, 0x06, 0xac20);
17006         MP_WritePhyUshort(sc, 0x06, 0x0ee0);
17007         MP_WritePhyUshort(sc, 0x06, 0x8b85);
17008         MP_WritePhyUshort(sc, 0x06, 0xac23);
17009         MP_WritePhyUshort(sc, 0x06, 0x08e0);
17010         MP_WritePhyUshort(sc, 0x06, 0x8b87);
17011         MP_WritePhyUshort(sc, 0x06, 0xac24);
17012         MP_WritePhyUshort(sc, 0x06, 0x02ae);
17013         MP_WritePhyUshort(sc, 0x06, 0x3802);
17014         MP_WritePhyUshort(sc, 0x06, 0x1ac2);
17015         MP_WritePhyUshort(sc, 0x06, 0xeee4);
17016         MP_WritePhyUshort(sc, 0x06, 0x1c04);
17017         MP_WritePhyUshort(sc, 0x06, 0xeee4);
17018         MP_WritePhyUshort(sc, 0x06, 0x1d04);
17019         MP_WritePhyUshort(sc, 0x06, 0xe2e0);
17020         MP_WritePhyUshort(sc, 0x06, 0x7ce3);
17021         MP_WritePhyUshort(sc, 0x06, 0xe07d);
17022         MP_WritePhyUshort(sc, 0x06, 0xe0e0);
17023         MP_WritePhyUshort(sc, 0x06, 0x38e1);
17024         MP_WritePhyUshort(sc, 0x06, 0xe039);
17025         MP_WritePhyUshort(sc, 0x06, 0xad2e);
17026         MP_WritePhyUshort(sc, 0x06, 0x1bad);
17027         MP_WritePhyUshort(sc, 0x06, 0x390d);
17028         MP_WritePhyUshort(sc, 0x06, 0xd101);
17029         MP_WritePhyUshort(sc, 0x06, 0xbf22);
17030         MP_WritePhyUshort(sc, 0x06, 0x7a02);
17031         MP_WritePhyUshort(sc, 0x06, 0x387d);
17032         MP_WritePhyUshort(sc, 0x06, 0x0281);
17033         MP_WritePhyUshort(sc, 0x06, 0xacae);
17034         MP_WritePhyUshort(sc, 0x06, 0x0bac);
17035         MP_WritePhyUshort(sc, 0x06, 0x3802);
17036         MP_WritePhyUshort(sc, 0x06, 0xae06);
17037         MP_WritePhyUshort(sc, 0x06, 0x0281);
17038         MP_WritePhyUshort(sc, 0x06, 0xe902);
17039         MP_WritePhyUshort(sc, 0x06, 0x822e);
17040         MP_WritePhyUshort(sc, 0x06, 0x021a);
17041         MP_WritePhyUshort(sc, 0x06, 0xd3fd);
17042         MP_WritePhyUshort(sc, 0x06, 0xfc04);
17043         MP_WritePhyUshort(sc, 0x06, 0xf8e1);
17044         MP_WritePhyUshort(sc, 0x06, 0x8af4);
17045         MP_WritePhyUshort(sc, 0x06, 0xe08b);
17046         MP_WritePhyUshort(sc, 0x06, 0x81ad);
17047         MP_WritePhyUshort(sc, 0x06, 0x2602);
17048         MP_WritePhyUshort(sc, 0x06, 0xf728);
17049         MP_WritePhyUshort(sc, 0x06, 0xe08b);
17050         MP_WritePhyUshort(sc, 0x06, 0x81ad);
17051         MP_WritePhyUshort(sc, 0x06, 0x2105);
17052         MP_WritePhyUshort(sc, 0x06, 0x0222);
17053         MP_WritePhyUshort(sc, 0x06, 0x8ef7);
17054         MP_WritePhyUshort(sc, 0x06, 0x29e0);
17055         MP_WritePhyUshort(sc, 0x06, 0x8b85);
17056         MP_WritePhyUshort(sc, 0x06, 0xad20);
17057         MP_WritePhyUshort(sc, 0x06, 0x0502);
17058         MP_WritePhyUshort(sc, 0x06, 0x14b8);
17059         MP_WritePhyUshort(sc, 0x06, 0xf72a);
17060         MP_WritePhyUshort(sc, 0x06, 0xe08b);
17061         MP_WritePhyUshort(sc, 0x06, 0x85ad);
17062         MP_WritePhyUshort(sc, 0x06, 0x2305);
17063         MP_WritePhyUshort(sc, 0x06, 0x0212);
17064         MP_WritePhyUshort(sc, 0x06, 0xf4f7);
17065         MP_WritePhyUshort(sc, 0x06, 0x2be0);
17066         MP_WritePhyUshort(sc, 0x06, 0x8b87);
17067         MP_WritePhyUshort(sc, 0x06, 0xad24);
17068         MP_WritePhyUshort(sc, 0x06, 0x0502);
17069         MP_WritePhyUshort(sc, 0x06, 0x8284);
17070         MP_WritePhyUshort(sc, 0x06, 0xf72c);
17071         MP_WritePhyUshort(sc, 0x06, 0xe58a);
17072         MP_WritePhyUshort(sc, 0x06, 0xf4fc);
17073         MP_WritePhyUshort(sc, 0x06, 0x04f8);
17074         MP_WritePhyUshort(sc, 0x06, 0xe08b);
17075         MP_WritePhyUshort(sc, 0x06, 0x81ad);
17076         MP_WritePhyUshort(sc, 0x06, 0x2600);
17077         MP_WritePhyUshort(sc, 0x06, 0xe08b);
17078         MP_WritePhyUshort(sc, 0x06, 0x81ad);
17079         MP_WritePhyUshort(sc, 0x06, 0x2109);
17080         MP_WritePhyUshort(sc, 0x06, 0xe08a);
17081         MP_WritePhyUshort(sc, 0x06, 0xf4ac);
17082         MP_WritePhyUshort(sc, 0x06, 0x2003);
17083         MP_WritePhyUshort(sc, 0x06, 0x0222);
17084         MP_WritePhyUshort(sc, 0x06, 0x7de0);
17085         MP_WritePhyUshort(sc, 0x06, 0x8b85);
17086         MP_WritePhyUshort(sc, 0x06, 0xad20);
17087         MP_WritePhyUshort(sc, 0x06, 0x09e0);
17088         MP_WritePhyUshort(sc, 0x06, 0x8af4);
17089         MP_WritePhyUshort(sc, 0x06, 0xac21);
17090         MP_WritePhyUshort(sc, 0x06, 0x0302);
17091         MP_WritePhyUshort(sc, 0x06, 0x1408);
17092         MP_WritePhyUshort(sc, 0x06, 0xe08b);
17093         MP_WritePhyUshort(sc, 0x06, 0x85ad);
17094         MP_WritePhyUshort(sc, 0x06, 0x2309);
17095         MP_WritePhyUshort(sc, 0x06, 0xe08a);
17096         MP_WritePhyUshort(sc, 0x06, 0xf4ac);
17097         MP_WritePhyUshort(sc, 0x06, 0x2203);
17098         MP_WritePhyUshort(sc, 0x06, 0x0213);
17099         MP_WritePhyUshort(sc, 0x06, 0x07e0);
17100         MP_WritePhyUshort(sc, 0x06, 0x8b87);
17101         MP_WritePhyUshort(sc, 0x06, 0xad24);
17102         MP_WritePhyUshort(sc, 0x06, 0x09e0);
17103         MP_WritePhyUshort(sc, 0x06, 0x8af4);
17104         MP_WritePhyUshort(sc, 0x06, 0xac23);
17105         MP_WritePhyUshort(sc, 0x06, 0x0302);
17106         MP_WritePhyUshort(sc, 0x06, 0x8289);
17107         MP_WritePhyUshort(sc, 0x06, 0xfc04);
17108         MP_WritePhyUshort(sc, 0x06, 0xf8e1);
17109         MP_WritePhyUshort(sc, 0x06, 0x8af4);
17110         MP_WritePhyUshort(sc, 0x06, 0xe08b);
17111         MP_WritePhyUshort(sc, 0x06, 0x81ad);
17112         MP_WritePhyUshort(sc, 0x06, 0x2602);
17113         MP_WritePhyUshort(sc, 0x06, 0xf628);
17114         MP_WritePhyUshort(sc, 0x06, 0xe08b);
17115         MP_WritePhyUshort(sc, 0x06, 0x81ad);
17116         MP_WritePhyUshort(sc, 0x06, 0x210a);
17117         MP_WritePhyUshort(sc, 0x06, 0xe083);
17118         MP_WritePhyUshort(sc, 0x06, 0xecf6);
17119         MP_WritePhyUshort(sc, 0x06, 0x27a0);
17120         MP_WritePhyUshort(sc, 0x06, 0x0502);
17121         MP_WritePhyUshort(sc, 0x06, 0xf629);
17122         MP_WritePhyUshort(sc, 0x06, 0xe08b);
17123         MP_WritePhyUshort(sc, 0x06, 0x85ad);
17124         MP_WritePhyUshort(sc, 0x06, 0x2008);
17125         MP_WritePhyUshort(sc, 0x06, 0xe08a);
17126         MP_WritePhyUshort(sc, 0x06, 0xe8ad);
17127         MP_WritePhyUshort(sc, 0x06, 0x2102);
17128         MP_WritePhyUshort(sc, 0x06, 0xf62a);
17129         MP_WritePhyUshort(sc, 0x06, 0xe08b);
17130         MP_WritePhyUshort(sc, 0x06, 0x85ad);
17131         MP_WritePhyUshort(sc, 0x06, 0x2308);
17132         MP_WritePhyUshort(sc, 0x06, 0xe08b);
17133         MP_WritePhyUshort(sc, 0x06, 0x20a0);
17134         MP_WritePhyUshort(sc, 0x06, 0x0302);
17135         MP_WritePhyUshort(sc, 0x06, 0xf62b);
17136         MP_WritePhyUshort(sc, 0x06, 0xe08b);
17137         MP_WritePhyUshort(sc, 0x06, 0x87ad);
17138         MP_WritePhyUshort(sc, 0x06, 0x2408);
17139         MP_WritePhyUshort(sc, 0x06, 0xe08a);
17140         MP_WritePhyUshort(sc, 0x06, 0xc2a0);
17141         MP_WritePhyUshort(sc, 0x06, 0x0302);
17142         MP_WritePhyUshort(sc, 0x06, 0xf62c);
17143         MP_WritePhyUshort(sc, 0x06, 0xe58a);
17144         MP_WritePhyUshort(sc, 0x06, 0xf4a1);
17145         MP_WritePhyUshort(sc, 0x06, 0x0008);
17146         MP_WritePhyUshort(sc, 0x06, 0xd100);
17147         MP_WritePhyUshort(sc, 0x06, 0xbf22);
17148         MP_WritePhyUshort(sc, 0x06, 0x7a02);
17149         MP_WritePhyUshort(sc, 0x06, 0x387d);
17150         MP_WritePhyUshort(sc, 0x06, 0xfc04);
17151         MP_WritePhyUshort(sc, 0x06, 0xee8a);
17152         MP_WritePhyUshort(sc, 0x06, 0xc200);
17153         MP_WritePhyUshort(sc, 0x06, 0x04f8);
17154         MP_WritePhyUshort(sc, 0x06, 0xe08b);
17155         MP_WritePhyUshort(sc, 0x06, 0x87ad);
17156         MP_WritePhyUshort(sc, 0x06, 0x241e);
17157         MP_WritePhyUshort(sc, 0x06, 0xe08a);
17158         MP_WritePhyUshort(sc, 0x06, 0xc2a0);
17159         MP_WritePhyUshort(sc, 0x06, 0x0005);
17160         MP_WritePhyUshort(sc, 0x06, 0x0282);
17161         MP_WritePhyUshort(sc, 0x06, 0xb0ae);
17162         MP_WritePhyUshort(sc, 0x06, 0xf5a0);
17163         MP_WritePhyUshort(sc, 0x06, 0x0105);
17164         MP_WritePhyUshort(sc, 0x06, 0x0282);
17165         MP_WritePhyUshort(sc, 0x06, 0xc0ae);
17166         MP_WritePhyUshort(sc, 0x06, 0x0ba0);
17167         MP_WritePhyUshort(sc, 0x06, 0x0205);
17168         MP_WritePhyUshort(sc, 0x06, 0x0282);
17169         MP_WritePhyUshort(sc, 0x06, 0xcaae);
17170         MP_WritePhyUshort(sc, 0x06, 0x03a0);
17171         MP_WritePhyUshort(sc, 0x06, 0x0300);
17172         MP_WritePhyUshort(sc, 0x06, 0xfc04);
17173         MP_WritePhyUshort(sc, 0x06, 0xf8fa);
17174         MP_WritePhyUshort(sc, 0x06, 0xef69);
17175         MP_WritePhyUshort(sc, 0x06, 0x0282);
17176         MP_WritePhyUshort(sc, 0x06, 0xe1ee);
17177         MP_WritePhyUshort(sc, 0x06, 0x8ac2);
17178         MP_WritePhyUshort(sc, 0x06, 0x01ef);
17179         MP_WritePhyUshort(sc, 0x06, 0x96fe);
17180         MP_WritePhyUshort(sc, 0x06, 0xfc04);
17181         MP_WritePhyUshort(sc, 0x06, 0xf8ee);
17182         MP_WritePhyUshort(sc, 0x06, 0x8ac9);
17183         MP_WritePhyUshort(sc, 0x06, 0x0002);
17184         MP_WritePhyUshort(sc, 0x06, 0x8317);
17185         MP_WritePhyUshort(sc, 0x06, 0xfc04);
17186         MP_WritePhyUshort(sc, 0x06, 0xf8e0);
17187         MP_WritePhyUshort(sc, 0x06, 0x8ac8);
17188         MP_WritePhyUshort(sc, 0x06, 0xe18a);
17189         MP_WritePhyUshort(sc, 0x06, 0xc91f);
17190         MP_WritePhyUshort(sc, 0x06, 0x019e);
17191         MP_WritePhyUshort(sc, 0x06, 0x0611);
17192         MP_WritePhyUshort(sc, 0x06, 0xe58a);
17193         MP_WritePhyUshort(sc, 0x06, 0xc9ae);
17194         MP_WritePhyUshort(sc, 0x06, 0x04ee);
17195         MP_WritePhyUshort(sc, 0x06, 0x8ac2);
17196         MP_WritePhyUshort(sc, 0x06, 0x01fc);
17197         MP_WritePhyUshort(sc, 0x06, 0x04f8);
17198         MP_WritePhyUshort(sc, 0x06, 0xf9fa);
17199         MP_WritePhyUshort(sc, 0x06, 0xef69);
17200         MP_WritePhyUshort(sc, 0x06, 0xfbbf);
17201         MP_WritePhyUshort(sc, 0x06, 0x8ac4);
17202         MP_WritePhyUshort(sc, 0x06, 0xef79);
17203         MP_WritePhyUshort(sc, 0x06, 0xd200);
17204         MP_WritePhyUshort(sc, 0x06, 0xd400);
17205         MP_WritePhyUshort(sc, 0x06, 0x221e);
17206         MP_WritePhyUshort(sc, 0x06, 0x02bf);
17207         MP_WritePhyUshort(sc, 0x06, 0x3024);
17208         MP_WritePhyUshort(sc, 0x06, 0x0238);
17209         MP_WritePhyUshort(sc, 0x06, 0x7dbf);
17210         MP_WritePhyUshort(sc, 0x06, 0x13ff);
17211         MP_WritePhyUshort(sc, 0x06, 0x0238);
17212         MP_WritePhyUshort(sc, 0x06, 0x500d);
17213         MP_WritePhyUshort(sc, 0x06, 0x4559);
17214         MP_WritePhyUshort(sc, 0x06, 0x1fef);
17215         MP_WritePhyUshort(sc, 0x06, 0x97dd);
17216         MP_WritePhyUshort(sc, 0x06, 0xd308);
17217         MP_WritePhyUshort(sc, 0x06, 0x1a93);
17218         MP_WritePhyUshort(sc, 0x06, 0xdd12);
17219         MP_WritePhyUshort(sc, 0x06, 0x17a2);
17220         MP_WritePhyUshort(sc, 0x06, 0x04de);
17221         MP_WritePhyUshort(sc, 0x06, 0xffef);
17222         MP_WritePhyUshort(sc, 0x06, 0x96fe);
17223         MP_WritePhyUshort(sc, 0x06, 0xfdfc);
17224         MP_WritePhyUshort(sc, 0x06, 0x04f8);
17225         MP_WritePhyUshort(sc, 0x06, 0xf9fa);
17226         MP_WritePhyUshort(sc, 0x06, 0xef69);
17227         MP_WritePhyUshort(sc, 0x06, 0xfbee);
17228         MP_WritePhyUshort(sc, 0x06, 0x8ac2);
17229         MP_WritePhyUshort(sc, 0x06, 0x03d5);
17230         MP_WritePhyUshort(sc, 0x06, 0x0080);
17231         MP_WritePhyUshort(sc, 0x06, 0xbf8a);
17232         MP_WritePhyUshort(sc, 0x06, 0xc4ef);
17233         MP_WritePhyUshort(sc, 0x06, 0x79ef);
17234         MP_WritePhyUshort(sc, 0x06, 0x45bf);
17235         MP_WritePhyUshort(sc, 0x06, 0x3024);
17236         MP_WritePhyUshort(sc, 0x06, 0x0238);
17237         MP_WritePhyUshort(sc, 0x06, 0x7dbf);
17238         MP_WritePhyUshort(sc, 0x06, 0x13ff);
17239         MP_WritePhyUshort(sc, 0x06, 0x0238);
17240         MP_WritePhyUshort(sc, 0x06, 0x50ad);
17241         MP_WritePhyUshort(sc, 0x06, 0x2702);
17242         MP_WritePhyUshort(sc, 0x06, 0x78ff);
17243         MP_WritePhyUshort(sc, 0x06, 0xe18a);
17244         MP_WritePhyUshort(sc, 0x06, 0xca1b);
17245         MP_WritePhyUshort(sc, 0x06, 0x01aa);
17246         MP_WritePhyUshort(sc, 0x06, 0x2eef);
17247         MP_WritePhyUshort(sc, 0x06, 0x97d9);
17248         MP_WritePhyUshort(sc, 0x06, 0x7900);
17249         MP_WritePhyUshort(sc, 0x06, 0x9e2b);
17250         MP_WritePhyUshort(sc, 0x06, 0x81dd);
17251         MP_WritePhyUshort(sc, 0x06, 0xbf85);
17252         MP_WritePhyUshort(sc, 0x06, 0xad02);
17253         MP_WritePhyUshort(sc, 0x06, 0x387d);
17254         MP_WritePhyUshort(sc, 0x06, 0xd101);
17255         MP_WritePhyUshort(sc, 0x06, 0xef02);
17256         MP_WritePhyUshort(sc, 0x06, 0x100c);
17257         MP_WritePhyUshort(sc, 0x06, 0x11b0);
17258         MP_WritePhyUshort(sc, 0x06, 0xfc0d);
17259         MP_WritePhyUshort(sc, 0x06, 0x11bf);
17260         MP_WritePhyUshort(sc, 0x06, 0x85aa);
17261         MP_WritePhyUshort(sc, 0x06, 0x0238);
17262         MP_WritePhyUshort(sc, 0x06, 0x7dd1);
17263         MP_WritePhyUshort(sc, 0x06, 0x00bf);
17264         MP_WritePhyUshort(sc, 0x06, 0x85aa);
17265         MP_WritePhyUshort(sc, 0x06, 0x0238);
17266         MP_WritePhyUshort(sc, 0x06, 0x7dee);
17267         MP_WritePhyUshort(sc, 0x06, 0x8ac2);
17268         MP_WritePhyUshort(sc, 0x06, 0x02ae);
17269         MP_WritePhyUshort(sc, 0x06, 0x0413);
17270         MP_WritePhyUshort(sc, 0x06, 0xa38b);
17271         MP_WritePhyUshort(sc, 0x06, 0xb4d3);
17272         MP_WritePhyUshort(sc, 0x06, 0x8012);
17273         MP_WritePhyUshort(sc, 0x06, 0x17a2);
17274         MP_WritePhyUshort(sc, 0x06, 0x04ad);
17275         MP_WritePhyUshort(sc, 0x06, 0xffef);
17276         MP_WritePhyUshort(sc, 0x06, 0x96fe);
17277         MP_WritePhyUshort(sc, 0x06, 0xfdfc);
17278         MP_WritePhyUshort(sc, 0x06, 0x04f8);
17279         MP_WritePhyUshort(sc, 0x06, 0xf9e0);
17280         MP_WritePhyUshort(sc, 0x06, 0x8b85);
17281         MP_WritePhyUshort(sc, 0x06, 0xad25);
17282         MP_WritePhyUshort(sc, 0x06, 0x48e0);
17283         MP_WritePhyUshort(sc, 0x06, 0x8a96);
17284         MP_WritePhyUshort(sc, 0x06, 0xe18a);
17285         MP_WritePhyUshort(sc, 0x06, 0x977c);
17286         MP_WritePhyUshort(sc, 0x06, 0x0000);
17287         MP_WritePhyUshort(sc, 0x06, 0x9e35);
17288         MP_WritePhyUshort(sc, 0x06, 0xee8a);
17289         MP_WritePhyUshort(sc, 0x06, 0x9600);
17290         MP_WritePhyUshort(sc, 0x06, 0xee8a);
17291         MP_WritePhyUshort(sc, 0x06, 0x9700);
17292         MP_WritePhyUshort(sc, 0x06, 0xe08a);
17293         MP_WritePhyUshort(sc, 0x06, 0xbee1);
17294         MP_WritePhyUshort(sc, 0x06, 0x8abf);
17295         MP_WritePhyUshort(sc, 0x06, 0xe28a);
17296         MP_WritePhyUshort(sc, 0x06, 0xc0e3);
17297         MP_WritePhyUshort(sc, 0x06, 0x8ac1);
17298         MP_WritePhyUshort(sc, 0x06, 0x0237);
17299         MP_WritePhyUshort(sc, 0x06, 0x74ad);
17300         MP_WritePhyUshort(sc, 0x06, 0x2012);
17301         MP_WritePhyUshort(sc, 0x06, 0xee8a);
17302         MP_WritePhyUshort(sc, 0x06, 0x9603);
17303         MP_WritePhyUshort(sc, 0x06, 0xee8a);
17304         MP_WritePhyUshort(sc, 0x06, 0x97b7);
17305         MP_WritePhyUshort(sc, 0x06, 0xee8a);
17306         MP_WritePhyUshort(sc, 0x06, 0xc000);
17307         MP_WritePhyUshort(sc, 0x06, 0xee8a);
17308         MP_WritePhyUshort(sc, 0x06, 0xc100);
17309         MP_WritePhyUshort(sc, 0x06, 0xae11);
17310         MP_WritePhyUshort(sc, 0x06, 0x15e6);
17311         MP_WritePhyUshort(sc, 0x06, 0x8ac0);
17312         MP_WritePhyUshort(sc, 0x06, 0xe78a);
17313         MP_WritePhyUshort(sc, 0x06, 0xc1ae);
17314         MP_WritePhyUshort(sc, 0x06, 0x08ee);
17315         MP_WritePhyUshort(sc, 0x06, 0x8ac0);
17316         MP_WritePhyUshort(sc, 0x06, 0x00ee);
17317         MP_WritePhyUshort(sc, 0x06, 0x8ac1);
17318         MP_WritePhyUshort(sc, 0x06, 0x00fd);
17319         MP_WritePhyUshort(sc, 0x06, 0xfc04);
17320         MP_WritePhyUshort(sc, 0x06, 0xae20);
17321         MP_WritePhyUshort(sc, 0x06, 0x0000);
17322         MP_WritePhyUshort(sc, 0x06, 0x0000);
17323         MP_WritePhyUshort(sc, 0x06, 0x0000);
17324         MP_WritePhyUshort(sc, 0x06, 0x0000);
17325         MP_WritePhyUshort(sc, 0x06, 0x0000);
17326         MP_WritePhyUshort(sc, 0x06, 0x0000);
17327         MP_WritePhyUshort(sc, 0x06, 0x0000);
17328         MP_WritePhyUshort(sc, 0x06, 0x0000);
17329         MP_WritePhyUshort(sc, 0x06, 0x0000);
17330         MP_WritePhyUshort(sc, 0x06, 0x0000);
17331         MP_WritePhyUshort(sc, 0x06, 0x0000);
17332         MP_WritePhyUshort(sc, 0x06, 0x0000);
17333         MP_WritePhyUshort(sc, 0x06, 0x0000);
17334         MP_WritePhyUshort(sc, 0x06, 0x0000);
17335         MP_WritePhyUshort(sc, 0x06, 0x0000);
17336         MP_WritePhyUshort(sc, 0x06, 0x0000);
17337         MP_WritePhyUshort(sc, 0x06, 0xf8fa);
17338         MP_WritePhyUshort(sc, 0x06, 0xef69);
17339         MP_WritePhyUshort(sc, 0x06, 0xe0e0);
17340         MP_WritePhyUshort(sc, 0x06, 0x00e1);
17341         MP_WritePhyUshort(sc, 0x06, 0xe001);
17342         MP_WritePhyUshort(sc, 0x06, 0xad27);
17343         MP_WritePhyUshort(sc, 0x06, 0x32e0);
17344         MP_WritePhyUshort(sc, 0x06, 0x8b40);
17345         MP_WritePhyUshort(sc, 0x06, 0xf720);
17346         MP_WritePhyUshort(sc, 0x06, 0xe48b);
17347         MP_WritePhyUshort(sc, 0x06, 0x40bf);
17348         MP_WritePhyUshort(sc, 0x06, 0x3230);
17349         MP_WritePhyUshort(sc, 0x06, 0x0238);
17350         MP_WritePhyUshort(sc, 0x06, 0x50ad);
17351         MP_WritePhyUshort(sc, 0x06, 0x2821);
17352         MP_WritePhyUshort(sc, 0x06, 0xe0e0);
17353         MP_WritePhyUshort(sc, 0x06, 0x20e1);
17354         MP_WritePhyUshort(sc, 0x06, 0xe021);
17355         MP_WritePhyUshort(sc, 0x06, 0xad20);
17356         MP_WritePhyUshort(sc, 0x06, 0x18e0);
17357         MP_WritePhyUshort(sc, 0x06, 0x8b40);
17358         MP_WritePhyUshort(sc, 0x06, 0xf620);
17359         MP_WritePhyUshort(sc, 0x06, 0xe48b);
17360         MP_WritePhyUshort(sc, 0x06, 0x40ee);
17361         MP_WritePhyUshort(sc, 0x06, 0x8b3b);
17362         MP_WritePhyUshort(sc, 0x06, 0xffe0);
17363         MP_WritePhyUshort(sc, 0x06, 0x8a8a);
17364         MP_WritePhyUshort(sc, 0x06, 0xe18a);
17365         MP_WritePhyUshort(sc, 0x06, 0x8be4);
17366         MP_WritePhyUshort(sc, 0x06, 0xe000);
17367         MP_WritePhyUshort(sc, 0x06, 0xe5e0);
17368         MP_WritePhyUshort(sc, 0x06, 0x01ef);
17369         MP_WritePhyUshort(sc, 0x06, 0x96fe);
17370         MP_WritePhyUshort(sc, 0x06, 0xfc04);
17371         MP_WritePhyUshort(sc, 0x06, 0xf8f9);
17372         MP_WritePhyUshort(sc, 0x06, 0xface);
17373         MP_WritePhyUshort(sc, 0x06, 0xfaef);
17374         MP_WritePhyUshort(sc, 0x06, 0x69fa);
17375         MP_WritePhyUshort(sc, 0x06, 0xd401);
17376         MP_WritePhyUshort(sc, 0x06, 0x55b4);
17377         MP_WritePhyUshort(sc, 0x06, 0xfebf);
17378         MP_WritePhyUshort(sc, 0x06, 0x1c1e);
17379         MP_WritePhyUshort(sc, 0x06, 0x0238);
17380         MP_WritePhyUshort(sc, 0x06, 0x50ac);
17381         MP_WritePhyUshort(sc, 0x06, 0x280b);
17382         MP_WritePhyUshort(sc, 0x06, 0xbf1c);
17383         MP_WritePhyUshort(sc, 0x06, 0x1b02);
17384         MP_WritePhyUshort(sc, 0x06, 0x3850);
17385         MP_WritePhyUshort(sc, 0x06, 0xac28);
17386         MP_WritePhyUshort(sc, 0x06, 0x49ae);
17387         MP_WritePhyUshort(sc, 0x06, 0x64bf);
17388         MP_WritePhyUshort(sc, 0x06, 0x1c1b);
17389         MP_WritePhyUshort(sc, 0x06, 0x0238);
17390         MP_WritePhyUshort(sc, 0x06, 0x50ac);
17391         MP_WritePhyUshort(sc, 0x06, 0x285b);
17392         MP_WritePhyUshort(sc, 0x06, 0xd000);
17393         MP_WritePhyUshort(sc, 0x06, 0x0284);
17394         MP_WritePhyUshort(sc, 0x06, 0xcaac);
17395         MP_WritePhyUshort(sc, 0x06, 0x2105);
17396         MP_WritePhyUshort(sc, 0x06, 0xac22);
17397         MP_WritePhyUshort(sc, 0x06, 0x02ae);
17398         MP_WritePhyUshort(sc, 0x06, 0x4ebf);
17399         MP_WritePhyUshort(sc, 0x06, 0xe0c4);
17400         MP_WritePhyUshort(sc, 0x06, 0xbe85);
17401         MP_WritePhyUshort(sc, 0x06, 0xf6d2);
17402         MP_WritePhyUshort(sc, 0x06, 0x04d8);
17403         MP_WritePhyUshort(sc, 0x06, 0x19d9);
17404         MP_WritePhyUshort(sc, 0x06, 0x1907);
17405         MP_WritePhyUshort(sc, 0x06, 0xdc19);
17406         MP_WritePhyUshort(sc, 0x06, 0xdd19);
17407         MP_WritePhyUshort(sc, 0x06, 0x0789);
17408         MP_WritePhyUshort(sc, 0x06, 0x89ef);
17409         MP_WritePhyUshort(sc, 0x06, 0x645e);
17410         MP_WritePhyUshort(sc, 0x06, 0x07ff);
17411         MP_WritePhyUshort(sc, 0x06, 0x0d65);
17412         MP_WritePhyUshort(sc, 0x06, 0x5cf8);
17413         MP_WritePhyUshort(sc, 0x06, 0x001e);
17414         MP_WritePhyUshort(sc, 0x06, 0x46dc);
17415         MP_WritePhyUshort(sc, 0x06, 0x19dd);
17416         MP_WritePhyUshort(sc, 0x06, 0x19b2);
17417         MP_WritePhyUshort(sc, 0x06, 0xe2d4);
17418         MP_WritePhyUshort(sc, 0x06, 0x0001);
17419         MP_WritePhyUshort(sc, 0x06, 0xbf1c);
17420         MP_WritePhyUshort(sc, 0x06, 0x1b02);
17421         MP_WritePhyUshort(sc, 0x06, 0x387d);
17422         MP_WritePhyUshort(sc, 0x06, 0xae1d);
17423         MP_WritePhyUshort(sc, 0x06, 0xbee0);
17424         MP_WritePhyUshort(sc, 0x06, 0xc4bf);
17425         MP_WritePhyUshort(sc, 0x06, 0x85f6);
17426         MP_WritePhyUshort(sc, 0x06, 0xd204);
17427         MP_WritePhyUshort(sc, 0x06, 0xd819);
17428         MP_WritePhyUshort(sc, 0x06, 0xd919);
17429         MP_WritePhyUshort(sc, 0x06, 0x07dc);
17430         MP_WritePhyUshort(sc, 0x06, 0x19dd);
17431         MP_WritePhyUshort(sc, 0x06, 0x1907);
17432         MP_WritePhyUshort(sc, 0x06, 0xb2f4);
17433         MP_WritePhyUshort(sc, 0x06, 0xd400);
17434         MP_WritePhyUshort(sc, 0x06, 0x00bf);
17435         MP_WritePhyUshort(sc, 0x06, 0x1c1b);
17436         MP_WritePhyUshort(sc, 0x06, 0x0238);
17437         MP_WritePhyUshort(sc, 0x06, 0x7dfe);
17438         MP_WritePhyUshort(sc, 0x06, 0xef96);
17439         MP_WritePhyUshort(sc, 0x06, 0xfec6);
17440         MP_WritePhyUshort(sc, 0x06, 0xfefd);
17441         MP_WritePhyUshort(sc, 0x06, 0xfc05);
17442         MP_WritePhyUshort(sc, 0x06, 0xf9e2);
17443         MP_WritePhyUshort(sc, 0x06, 0xe0ea);
17444         MP_WritePhyUshort(sc, 0x06, 0xe3e0);
17445         MP_WritePhyUshort(sc, 0x06, 0xeb5a);
17446         MP_WritePhyUshort(sc, 0x06, 0x070c);
17447         MP_WritePhyUshort(sc, 0x06, 0x031e);
17448         MP_WritePhyUshort(sc, 0x06, 0x20e6);
17449         MP_WritePhyUshort(sc, 0x06, 0xe0ea);
17450         MP_WritePhyUshort(sc, 0x06, 0xe7e0);
17451         MP_WritePhyUshort(sc, 0x06, 0xebe0);
17452         MP_WritePhyUshort(sc, 0x06, 0xe0fc);
17453         MP_WritePhyUshort(sc, 0x06, 0xe1e0);
17454         MP_WritePhyUshort(sc, 0x06, 0xfdfd);
17455         MP_WritePhyUshort(sc, 0x06, 0x04f8);
17456         MP_WritePhyUshort(sc, 0x06, 0xfaef);
17457         MP_WritePhyUshort(sc, 0x06, 0x69e0);
17458         MP_WritePhyUshort(sc, 0x06, 0x8b80);
17459         MP_WritePhyUshort(sc, 0x06, 0xad27);
17460         MP_WritePhyUshort(sc, 0x06, 0x22bf);
17461         MP_WritePhyUshort(sc, 0x06, 0x4616);
17462         MP_WritePhyUshort(sc, 0x06, 0x0238);
17463         MP_WritePhyUshort(sc, 0x06, 0x50e0);
17464         MP_WritePhyUshort(sc, 0x06, 0x8b44);
17465         MP_WritePhyUshort(sc, 0x06, 0x1f01);
17466         MP_WritePhyUshort(sc, 0x06, 0x9e15);
17467         MP_WritePhyUshort(sc, 0x06, 0xe58b);
17468         MP_WritePhyUshort(sc, 0x06, 0x44ad);
17469         MP_WritePhyUshort(sc, 0x06, 0x2907);
17470         MP_WritePhyUshort(sc, 0x06, 0xac28);
17471         MP_WritePhyUshort(sc, 0x06, 0x04d1);
17472         MP_WritePhyUshort(sc, 0x06, 0x01ae);
17473         MP_WritePhyUshort(sc, 0x06, 0x02d1);
17474         MP_WritePhyUshort(sc, 0x06, 0x00bf);
17475         MP_WritePhyUshort(sc, 0x06, 0x85b0);
17476         MP_WritePhyUshort(sc, 0x06, 0x0238);
17477         MP_WritePhyUshort(sc, 0x06, 0x7def);
17478         MP_WritePhyUshort(sc, 0x06, 0x96fe);
17479         MP_WritePhyUshort(sc, 0x06, 0xfc04);
17480         MP_WritePhyUshort(sc, 0x06, 0xf8e0);
17481         MP_WritePhyUshort(sc, 0x06, 0x8b85);
17482         MP_WritePhyUshort(sc, 0x06, 0xad26);
17483         MP_WritePhyUshort(sc, 0x06, 0x30e0);
17484         MP_WritePhyUshort(sc, 0x06, 0xe036);
17485         MP_WritePhyUshort(sc, 0x06, 0xe1e0);
17486         MP_WritePhyUshort(sc, 0x06, 0x37e1);
17487         MP_WritePhyUshort(sc, 0x06, 0x8b3f);
17488         MP_WritePhyUshort(sc, 0x06, 0x1f10);
17489         MP_WritePhyUshort(sc, 0x06, 0x9e23);
17490         MP_WritePhyUshort(sc, 0x06, 0xe48b);
17491         MP_WritePhyUshort(sc, 0x06, 0x3fac);
17492         MP_WritePhyUshort(sc, 0x06, 0x200b);
17493         MP_WritePhyUshort(sc, 0x06, 0xac21);
17494         MP_WritePhyUshort(sc, 0x06, 0x0dac);
17495         MP_WritePhyUshort(sc, 0x06, 0x250f);
17496         MP_WritePhyUshort(sc, 0x06, 0xac27);
17497         MP_WritePhyUshort(sc, 0x06, 0x11ae);
17498         MP_WritePhyUshort(sc, 0x06, 0x1202);
17499         MP_WritePhyUshort(sc, 0x06, 0x2c47);
17500         MP_WritePhyUshort(sc, 0x06, 0xae0d);
17501         MP_WritePhyUshort(sc, 0x06, 0x0285);
17502         MP_WritePhyUshort(sc, 0x06, 0x4fae);
17503         MP_WritePhyUshort(sc, 0x06, 0x0802);
17504         MP_WritePhyUshort(sc, 0x06, 0x2c69);
17505         MP_WritePhyUshort(sc, 0x06, 0xae03);
17506         MP_WritePhyUshort(sc, 0x06, 0x022c);
17507         MP_WritePhyUshort(sc, 0x06, 0x7cfc);
17508         MP_WritePhyUshort(sc, 0x06, 0x04f8);
17509         MP_WritePhyUshort(sc, 0x06, 0xfaef);
17510         MP_WritePhyUshort(sc, 0x06, 0x6902);
17511         MP_WritePhyUshort(sc, 0x06, 0x856c);
17512         MP_WritePhyUshort(sc, 0x06, 0xe0e0);
17513         MP_WritePhyUshort(sc, 0x06, 0x14e1);
17514         MP_WritePhyUshort(sc, 0x06, 0xe015);
17515         MP_WritePhyUshort(sc, 0x06, 0xad26);
17516         MP_WritePhyUshort(sc, 0x06, 0x08d1);
17517         MP_WritePhyUshort(sc, 0x06, 0x1ebf);
17518         MP_WritePhyUshort(sc, 0x06, 0x2cd9);
17519         MP_WritePhyUshort(sc, 0x06, 0x0238);
17520         MP_WritePhyUshort(sc, 0x06, 0x7def);
17521         MP_WritePhyUshort(sc, 0x06, 0x96fe);
17522         MP_WritePhyUshort(sc, 0x06, 0xfc04);
17523         MP_WritePhyUshort(sc, 0x06, 0xf8e0);
17524         MP_WritePhyUshort(sc, 0x06, 0x8b85);
17525         MP_WritePhyUshort(sc, 0x06, 0xad27);
17526         MP_WritePhyUshort(sc, 0x06, 0x2fd0);
17527         MP_WritePhyUshort(sc, 0x06, 0x0b02);
17528         MP_WritePhyUshort(sc, 0x06, 0x3682);
17529         MP_WritePhyUshort(sc, 0x06, 0x5882);
17530         MP_WritePhyUshort(sc, 0x06, 0x7882);
17531         MP_WritePhyUshort(sc, 0x06, 0x9f24);
17532         MP_WritePhyUshort(sc, 0x06, 0xe08b);
17533         MP_WritePhyUshort(sc, 0x06, 0x32e1);
17534         MP_WritePhyUshort(sc, 0x06, 0x8b33);
17535         MP_WritePhyUshort(sc, 0x06, 0x1f10);
17536         MP_WritePhyUshort(sc, 0x06, 0x9e1a);
17537         MP_WritePhyUshort(sc, 0x06, 0x10e4);
17538         MP_WritePhyUshort(sc, 0x06, 0x8b32);
17539         MP_WritePhyUshort(sc, 0x06, 0xe0e0);
17540         MP_WritePhyUshort(sc, 0x06, 0x28e1);
17541         MP_WritePhyUshort(sc, 0x06, 0xe029);
17542         MP_WritePhyUshort(sc, 0x06, 0xf72c);
17543         MP_WritePhyUshort(sc, 0x06, 0xe4e0);
17544         MP_WritePhyUshort(sc, 0x06, 0x28e5);
17545         MP_WritePhyUshort(sc, 0x06, 0xe029);
17546         MP_WritePhyUshort(sc, 0x06, 0xf62c);
17547         MP_WritePhyUshort(sc, 0x06, 0xe4e0);
17548         MP_WritePhyUshort(sc, 0x06, 0x28e5);
17549         MP_WritePhyUshort(sc, 0x06, 0xe029);
17550         MP_WritePhyUshort(sc, 0x06, 0xfc04);
17551         MP_WritePhyUshort(sc, 0x06, 0x00e1);
17552         MP_WritePhyUshort(sc, 0x06, 0x4077);
17553         MP_WritePhyUshort(sc, 0x06, 0xe140);
17554         MP_WritePhyUshort(sc, 0x06, 0x52e0);
17555         MP_WritePhyUshort(sc, 0x06, 0xeed9);
17556         MP_WritePhyUshort(sc, 0x06, 0xe04c);
17557         MP_WritePhyUshort(sc, 0x06, 0xbbe0);
17558         MP_WritePhyUshort(sc, 0x06, 0x2a00);
17559         MP_WritePhyUshort(sc, 0x05, 0xe142);
17560         PhyRegValue = MP_ReadPhyUshort(sc, 0x06);
17561         PhyRegValue |= BIT_0;
17562         MP_WritePhyUshort(sc, 0x06, PhyRegValue);
17563         MP_WritePhyUshort(sc, 0x05, 0xe140);
17564         PhyRegValue = MP_ReadPhyUshort(sc, 0x06);
17565         PhyRegValue |= BIT_0;
17566         MP_WritePhyUshort(sc, 0x06, PhyRegValue);
17567         MP_WritePhyUshort(sc, 0x1f, 0x0000);
17568         MP_WritePhyUshort(sc, 0x1f, 0x0005);
17569         for (i = 0; i < 200; i++) {
17570                 DELAY(100);
17571                 PhyRegValue = MP_ReadPhyUshort(sc, 0x00);
17572                 if (PhyRegValue & BIT_7)
17573                         break;
17574         }
17575
17576         MP_WritePhyUshort(sc, 0x1f, 0x0007);
17577         MP_WritePhyUshort(sc, 0x1e, 0x0023);
17578         PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
17579         PhyRegValue |= BIT_1;
17580         if (sc->RequiredSecLanDonglePatch)
17581                 PhyRegValue &= ~(BIT_2);
17582         MP_WritePhyUshort(sc, 0x17, PhyRegValue);
17583         MP_WritePhyUshort(sc, 0x1f, 0x0000);
17584
17585         MP_WritePhyUshort(sc, 0x1f, 0x0003);
17586         MP_WritePhyUshort(sc, 0x09, 0xA20F);
17587         MP_WritePhyUshort(sc, 0x1f, 0x0000);
17588
17589         MP_WritePhyUshort(sc, 0x1f, 0x0003);
17590         MP_WritePhyUshort(sc, 0x01, 0x328A);
17591         MP_WritePhyUshort(sc, 0x1f, 0x0000);
17592
17593         MP_WritePhyUshort(sc, 0x1f, 0x0003);
17594         PhyRegValue = MP_ReadPhyUshort(sc, 0x19);
17595         PhyRegValue &= ~BIT_0;
17596         MP_WritePhyUshort(sc, 0x19, PhyRegValue);
17597         PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
17598         PhyRegValue &= ~BIT_10;
17599         MP_WritePhyUshort(sc, 0x10, PhyRegValue);
17600         MP_WritePhyUshort(sc, 0x1f, 0x0000);
17601
17602
17603         MP_WritePhyUshort(sc, 0x1f, 0x0000);
17604         MP_WritePhyUshort(sc, 0x00, 0x9200);
17605 }
17606
17607 static void re_set_phy_mcu_8168f_2(struct re_softc *sc)
17608 {
17609         u_int16_t PhyRegValue;
17610         int i;
17611
17612         MP_WritePhyUshort(sc, 0x1f, 0x0000);
17613         MP_WritePhyUshort(sc, 0x00, 0x1800);
17614         PhyRegValue = MP_ReadPhyUshort(sc, 0x15);
17615         PhyRegValue &= ~(BIT_12);
17616         MP_WritePhyUshort(sc, 0x15, PhyRegValue);
17617         MP_WritePhyUshort(sc, 0x00, 0x9800);
17618         MP_WritePhyUshort(sc, 0x1f, 0x0007);
17619         MP_WritePhyUshort(sc, 0x1e, 0x002f);
17620         for (i = 0; i < 1000; i++) {
17621                 DELAY(100);
17622                 PhyRegValue = MP_ReadPhyUshort(sc, 0x1c);
17623                 if (PhyRegValue & BIT_7)
17624                         break;
17625         }
17626         MP_WritePhyUshort(sc, 0x1f, 0x0007);
17627         MP_WritePhyUshort(sc, 0x1e, 0x0023);
17628         MP_WritePhyUshort(sc, 0x16, 0x0306);
17629         MP_WritePhyUshort(sc, 0x16, 0x0307);
17630         MP_WritePhyUshort(sc, 0x15, 0x0098);
17631         MP_WritePhyUshort(sc, 0x19, 0x7c0b);
17632         MP_WritePhyUshort(sc, 0x15, 0x0099);
17633         MP_WritePhyUshort(sc, 0x19, 0x6c0b);
17634         MP_WritePhyUshort(sc, 0x15, 0x00eb);
17635         MP_WritePhyUshort(sc, 0x19, 0x6c0b);
17636         MP_WritePhyUshort(sc, 0x15, 0x00f8);
17637         MP_WritePhyUshort(sc, 0x19, 0x6f0b);
17638         MP_WritePhyUshort(sc, 0x15, 0x00fe);
17639         MP_WritePhyUshort(sc, 0x19, 0x6f0f);
17640         MP_WritePhyUshort(sc, 0x15, 0x00db);
17641         MP_WritePhyUshort(sc, 0x19, 0x6f09);
17642         MP_WritePhyUshort(sc, 0x15, 0x00dc);
17643         MP_WritePhyUshort(sc, 0x19, 0xaefd);
17644         MP_WritePhyUshort(sc, 0x15, 0x00dd);
17645         MP_WritePhyUshort(sc, 0x19, 0x6f0b);
17646         MP_WritePhyUshort(sc, 0x15, 0x00de);
17647         MP_WritePhyUshort(sc, 0x19, 0xc60b);
17648         MP_WritePhyUshort(sc, 0x15, 0x00df);
17649         MP_WritePhyUshort(sc, 0x19, 0x00fa);
17650         MP_WritePhyUshort(sc, 0x15, 0x00e0);
17651         MP_WritePhyUshort(sc, 0x19, 0x30e1);
17652         MP_WritePhyUshort(sc, 0x15, 0x020c);
17653         MP_WritePhyUshort(sc, 0x19, 0x3224);
17654         MP_WritePhyUshort(sc, 0x15, 0x020e);
17655         MP_WritePhyUshort(sc, 0x19, 0x9813);
17656         MP_WritePhyUshort(sc, 0x15, 0x020f);
17657         MP_WritePhyUshort(sc, 0x19, 0x7801);
17658         MP_WritePhyUshort(sc, 0x15, 0x0210);
17659         MP_WritePhyUshort(sc, 0x19, 0x930f);
17660         MP_WritePhyUshort(sc, 0x15, 0x0211);
17661         MP_WritePhyUshort(sc, 0x19, 0x9206);
17662         MP_WritePhyUshort(sc, 0x15, 0x0212);
17663         MP_WritePhyUshort(sc, 0x19, 0x4002);
17664         MP_WritePhyUshort(sc, 0x15, 0x0213);
17665         MP_WritePhyUshort(sc, 0x19, 0x7800);
17666         MP_WritePhyUshort(sc, 0x15, 0x0214);
17667         MP_WritePhyUshort(sc, 0x19, 0x588f);
17668         MP_WritePhyUshort(sc, 0x15, 0x0215);
17669         MP_WritePhyUshort(sc, 0x19, 0x5520);
17670         MP_WritePhyUshort(sc, 0x15, 0x0216);
17671         MP_WritePhyUshort(sc, 0x19, 0x3224);
17672         MP_WritePhyUshort(sc, 0x15, 0x0217);
17673         MP_WritePhyUshort(sc, 0x19, 0x4002);
17674         MP_WritePhyUshort(sc, 0x15, 0x0218);
17675         MP_WritePhyUshort(sc, 0x19, 0x7800);
17676         MP_WritePhyUshort(sc, 0x15, 0x0219);
17677         MP_WritePhyUshort(sc, 0x19, 0x588d);
17678         MP_WritePhyUshort(sc, 0x15, 0x021a);
17679         MP_WritePhyUshort(sc, 0x19, 0x5540);
17680         MP_WritePhyUshort(sc, 0x15, 0x021b);
17681         MP_WritePhyUshort(sc, 0x19, 0x9e03);
17682         MP_WritePhyUshort(sc, 0x15, 0x021c);
17683         MP_WritePhyUshort(sc, 0x19, 0x7c40);
17684         MP_WritePhyUshort(sc, 0x15, 0x021d);
17685         MP_WritePhyUshort(sc, 0x19, 0x6840);
17686         MP_WritePhyUshort(sc, 0x15, 0x021e);
17687         MP_WritePhyUshort(sc, 0x19, 0x3224);
17688         MP_WritePhyUshort(sc, 0x15, 0x021f);
17689         MP_WritePhyUshort(sc, 0x19, 0x4002);
17690         MP_WritePhyUshort(sc, 0x15, 0x0220);
17691         MP_WritePhyUshort(sc, 0x19, 0x3224);
17692         MP_WritePhyUshort(sc, 0x15, 0x0221);
17693         MP_WritePhyUshort(sc, 0x19, 0x9e03);
17694         MP_WritePhyUshort(sc, 0x15, 0x0222);
17695         MP_WritePhyUshort(sc, 0x19, 0x7c40);
17696         MP_WritePhyUshort(sc, 0x15, 0x0223);
17697         MP_WritePhyUshort(sc, 0x19, 0x6840);
17698         MP_WritePhyUshort(sc, 0x15, 0x0224);
17699         MP_WritePhyUshort(sc, 0x19, 0x7800);
17700         MP_WritePhyUshort(sc, 0x15, 0x0225);
17701         MP_WritePhyUshort(sc, 0x19, 0x3231);
17702         MP_WritePhyUshort(sc, 0x15, 0x0000);
17703         MP_WritePhyUshort(sc, 0x16, 0x0306);
17704         MP_WritePhyUshort(sc, 0x16, 0x0300);
17705         MP_WritePhyUshort(sc, 0x1f, 0x0000);
17706         MP_WritePhyUshort(sc, 0x1f, 0x0005);
17707         MP_WritePhyUshort(sc, 0x05, 0xfff6);
17708         MP_WritePhyUshort(sc, 0x06, 0x0080);
17709         MP_WritePhyUshort(sc, 0x05, 0x8000);
17710         MP_WritePhyUshort(sc, 0x06, 0x0280);
17711         MP_WritePhyUshort(sc, 0x06, 0x48f7);
17712         MP_WritePhyUshort(sc, 0x06, 0x00e0);
17713         MP_WritePhyUshort(sc, 0x06, 0xfff7);
17714         MP_WritePhyUshort(sc, 0x06, 0xa080);
17715         MP_WritePhyUshort(sc, 0x06, 0x02ae);
17716         MP_WritePhyUshort(sc, 0x06, 0xf602);
17717         MP_WritePhyUshort(sc, 0x06, 0x011b);
17718         MP_WritePhyUshort(sc, 0x06, 0x0201);
17719         MP_WritePhyUshort(sc, 0x06, 0x2802);
17720         MP_WritePhyUshort(sc, 0x06, 0x0135);
17721         MP_WritePhyUshort(sc, 0x06, 0x0201);
17722         MP_WritePhyUshort(sc, 0x06, 0x4502);
17723         MP_WritePhyUshort(sc, 0x06, 0x015f);
17724         MP_WritePhyUshort(sc, 0x06, 0x0280);
17725         MP_WritePhyUshort(sc, 0x06, 0x6b02);
17726         MP_WritePhyUshort(sc, 0x06, 0x80e5);
17727         MP_WritePhyUshort(sc, 0x06, 0xe08b);
17728         MP_WritePhyUshort(sc, 0x06, 0x88e1);
17729         MP_WritePhyUshort(sc, 0x06, 0x8b89);
17730         MP_WritePhyUshort(sc, 0x06, 0x1e01);
17731         MP_WritePhyUshort(sc, 0x06, 0xe18b);
17732         MP_WritePhyUshort(sc, 0x06, 0x8a1e);
17733         MP_WritePhyUshort(sc, 0x06, 0x01e1);
17734         MP_WritePhyUshort(sc, 0x06, 0x8b8b);
17735         MP_WritePhyUshort(sc, 0x06, 0x1e01);
17736         MP_WritePhyUshort(sc, 0x06, 0xe18b);
17737         MP_WritePhyUshort(sc, 0x06, 0x8c1e);
17738         MP_WritePhyUshort(sc, 0x06, 0x01e1);
17739         MP_WritePhyUshort(sc, 0x06, 0x8b8d);
17740         MP_WritePhyUshort(sc, 0x06, 0x1e01);
17741         MP_WritePhyUshort(sc, 0x06, 0xe18b);
17742         MP_WritePhyUshort(sc, 0x06, 0x8e1e);
17743         MP_WritePhyUshort(sc, 0x06, 0x01a0);
17744         MP_WritePhyUshort(sc, 0x06, 0x00c7);
17745         MP_WritePhyUshort(sc, 0x06, 0xaebb);
17746         MP_WritePhyUshort(sc, 0x06, 0xbf8b);
17747         MP_WritePhyUshort(sc, 0x06, 0x88ec);
17748         MP_WritePhyUshort(sc, 0x06, 0x0019);
17749         MP_WritePhyUshort(sc, 0x06, 0xa98b);
17750         MP_WritePhyUshort(sc, 0x06, 0x90f9);
17751         MP_WritePhyUshort(sc, 0x06, 0xeeff);
17752         MP_WritePhyUshort(sc, 0x06, 0xf600);
17753         MP_WritePhyUshort(sc, 0x06, 0xeeff);
17754         MP_WritePhyUshort(sc, 0x06, 0xf7fe);
17755         MP_WritePhyUshort(sc, 0x06, 0xd100);
17756         MP_WritePhyUshort(sc, 0x06, 0xbf81);
17757         MP_WritePhyUshort(sc, 0x06, 0x9802);
17758         MP_WritePhyUshort(sc, 0x06, 0x39f3);
17759         MP_WritePhyUshort(sc, 0x06, 0xd101);
17760         MP_WritePhyUshort(sc, 0x06, 0xbf81);
17761         MP_WritePhyUshort(sc, 0x06, 0x9b02);
17762         MP_WritePhyUshort(sc, 0x06, 0x39f3);
17763         MP_WritePhyUshort(sc, 0x06, 0x04f8);
17764         MP_WritePhyUshort(sc, 0x06, 0xe08b);
17765         MP_WritePhyUshort(sc, 0x06, 0x8dad);
17766         MP_WritePhyUshort(sc, 0x06, 0x2014);
17767         MP_WritePhyUshort(sc, 0x06, 0xee8b);
17768         MP_WritePhyUshort(sc, 0x06, 0x8d00);
17769         MP_WritePhyUshort(sc, 0x06, 0xe08a);
17770         MP_WritePhyUshort(sc, 0x06, 0x5a78);
17771         MP_WritePhyUshort(sc, 0x06, 0x039e);
17772         MP_WritePhyUshort(sc, 0x06, 0x0902);
17773         MP_WritePhyUshort(sc, 0x06, 0x05fc);
17774         MP_WritePhyUshort(sc, 0x06, 0x0280);
17775         MP_WritePhyUshort(sc, 0x06, 0x8802);
17776         MP_WritePhyUshort(sc, 0x06, 0x32dd);
17777         MP_WritePhyUshort(sc, 0x06, 0xfc04);
17778         MP_WritePhyUshort(sc, 0x06, 0xf8f9);
17779         MP_WritePhyUshort(sc, 0x06, 0xe08b);
17780         MP_WritePhyUshort(sc, 0x06, 0x81ac);
17781         MP_WritePhyUshort(sc, 0x06, 0x261a);
17782         MP_WritePhyUshort(sc, 0x06, 0xe08b);
17783         MP_WritePhyUshort(sc, 0x06, 0x81ac);
17784         MP_WritePhyUshort(sc, 0x06, 0x2114);
17785         MP_WritePhyUshort(sc, 0x06, 0xe08b);
17786         MP_WritePhyUshort(sc, 0x06, 0x85ac);
17787         MP_WritePhyUshort(sc, 0x06, 0x200e);
17788         MP_WritePhyUshort(sc, 0x06, 0xe08b);
17789         MP_WritePhyUshort(sc, 0x06, 0x85ac);
17790         MP_WritePhyUshort(sc, 0x06, 0x2308);
17791         MP_WritePhyUshort(sc, 0x06, 0xe08b);
17792         MP_WritePhyUshort(sc, 0x06, 0x87ac);
17793         MP_WritePhyUshort(sc, 0x06, 0x2402);
17794         MP_WritePhyUshort(sc, 0x06, 0xae38);
17795         MP_WritePhyUshort(sc, 0x06, 0x021a);
17796         MP_WritePhyUshort(sc, 0x06, 0xd6ee);
17797         MP_WritePhyUshort(sc, 0x06, 0xe41c);
17798         MP_WritePhyUshort(sc, 0x06, 0x04ee);
17799         MP_WritePhyUshort(sc, 0x06, 0xe41d);
17800         MP_WritePhyUshort(sc, 0x06, 0x04e2);
17801         MP_WritePhyUshort(sc, 0x06, 0xe07c);
17802         MP_WritePhyUshort(sc, 0x06, 0xe3e0);
17803         MP_WritePhyUshort(sc, 0x06, 0x7de0);
17804         MP_WritePhyUshort(sc, 0x06, 0xe038);
17805         MP_WritePhyUshort(sc, 0x06, 0xe1e0);
17806         MP_WritePhyUshort(sc, 0x06, 0x39ad);
17807         MP_WritePhyUshort(sc, 0x06, 0x2e1b);
17808         MP_WritePhyUshort(sc, 0x06, 0xad39);
17809         MP_WritePhyUshort(sc, 0x06, 0x0dd1);
17810         MP_WritePhyUshort(sc, 0x06, 0x01bf);
17811         MP_WritePhyUshort(sc, 0x06, 0x22c8);
17812         MP_WritePhyUshort(sc, 0x06, 0x0239);
17813         MP_WritePhyUshort(sc, 0x06, 0xf302);
17814         MP_WritePhyUshort(sc, 0x06, 0x21f0);
17815         MP_WritePhyUshort(sc, 0x06, 0xae0b);
17816         MP_WritePhyUshort(sc, 0x06, 0xac38);
17817         MP_WritePhyUshort(sc, 0x06, 0x02ae);
17818         MP_WritePhyUshort(sc, 0x06, 0x0602);
17819         MP_WritePhyUshort(sc, 0x06, 0x222d);
17820         MP_WritePhyUshort(sc, 0x06, 0x0222);
17821         MP_WritePhyUshort(sc, 0x06, 0x7202);
17822         MP_WritePhyUshort(sc, 0x06, 0x1ae7);
17823         MP_WritePhyUshort(sc, 0x06, 0xfdfc);
17824         MP_WritePhyUshort(sc, 0x06, 0x04f8);
17825         MP_WritePhyUshort(sc, 0x06, 0xe08b);
17826         MP_WritePhyUshort(sc, 0x06, 0x8ead);
17827         MP_WritePhyUshort(sc, 0x06, 0x201a);
17828         MP_WritePhyUshort(sc, 0x06, 0xf620);
17829         MP_WritePhyUshort(sc, 0x06, 0xe48b);
17830         MP_WritePhyUshort(sc, 0x06, 0x8e02);
17831         MP_WritePhyUshort(sc, 0x06, 0x2afe);
17832         MP_WritePhyUshort(sc, 0x06, 0x022c);
17833         MP_WritePhyUshort(sc, 0x06, 0x5c02);
17834         MP_WritePhyUshort(sc, 0x06, 0x03c5);
17835         MP_WritePhyUshort(sc, 0x06, 0x0281);
17836         MP_WritePhyUshort(sc, 0x06, 0x6702);
17837         MP_WritePhyUshort(sc, 0x06, 0x2e4f);
17838         MP_WritePhyUshort(sc, 0x06, 0x0204);
17839         MP_WritePhyUshort(sc, 0x06, 0x8902);
17840         MP_WritePhyUshort(sc, 0x06, 0x2f7a);
17841         MP_WritePhyUshort(sc, 0x06, 0xe08b);
17842         MP_WritePhyUshort(sc, 0x06, 0x8ead);
17843         MP_WritePhyUshort(sc, 0x06, 0x210b);
17844         MP_WritePhyUshort(sc, 0x06, 0xf621);
17845         MP_WritePhyUshort(sc, 0x06, 0xe48b);
17846         MP_WritePhyUshort(sc, 0x06, 0x8e02);
17847         MP_WritePhyUshort(sc, 0x06, 0x0445);
17848         MP_WritePhyUshort(sc, 0x06, 0x021c);
17849         MP_WritePhyUshort(sc, 0x06, 0xb8e0);
17850         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
17851         MP_WritePhyUshort(sc, 0x06, 0xad22);
17852         MP_WritePhyUshort(sc, 0x06, 0x08f6);
17853         MP_WritePhyUshort(sc, 0x06, 0x22e4);
17854         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
17855         MP_WritePhyUshort(sc, 0x06, 0x0235);
17856         MP_WritePhyUshort(sc, 0x06, 0xd4e0);
17857         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
17858         MP_WritePhyUshort(sc, 0x06, 0xad23);
17859         MP_WritePhyUshort(sc, 0x06, 0x08f6);
17860         MP_WritePhyUshort(sc, 0x06, 0x23e4);
17861         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
17862         MP_WritePhyUshort(sc, 0x06, 0x0231);
17863         MP_WritePhyUshort(sc, 0x06, 0xc8e0);
17864         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
17865         MP_WritePhyUshort(sc, 0x06, 0xad24);
17866         MP_WritePhyUshort(sc, 0x06, 0x05f6);
17867         MP_WritePhyUshort(sc, 0x06, 0x24e4);
17868         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
17869         MP_WritePhyUshort(sc, 0x06, 0xe08b);
17870         MP_WritePhyUshort(sc, 0x06, 0x8ead);
17871         MP_WritePhyUshort(sc, 0x06, 0x2505);
17872         MP_WritePhyUshort(sc, 0x06, 0xf625);
17873         MP_WritePhyUshort(sc, 0x06, 0xe48b);
17874         MP_WritePhyUshort(sc, 0x06, 0x8ee0);
17875         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
17876         MP_WritePhyUshort(sc, 0x06, 0xad26);
17877         MP_WritePhyUshort(sc, 0x06, 0x08f6);
17878         MP_WritePhyUshort(sc, 0x06, 0x26e4);
17879         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
17880         MP_WritePhyUshort(sc, 0x06, 0x022d);
17881         MP_WritePhyUshort(sc, 0x06, 0x6ae0);
17882         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
17883         MP_WritePhyUshort(sc, 0x06, 0xad27);
17884         MP_WritePhyUshort(sc, 0x06, 0x05f6);
17885         MP_WritePhyUshort(sc, 0x06, 0x27e4);
17886         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
17887         MP_WritePhyUshort(sc, 0x06, 0x0203);
17888         MP_WritePhyUshort(sc, 0x06, 0x8bfc);
17889         MP_WritePhyUshort(sc, 0x06, 0x04f8);
17890         MP_WritePhyUshort(sc, 0x06, 0xfaef);
17891         MP_WritePhyUshort(sc, 0x06, 0x69e0);
17892         MP_WritePhyUshort(sc, 0x06, 0x8b80);
17893         MP_WritePhyUshort(sc, 0x06, 0xad27);
17894         MP_WritePhyUshort(sc, 0x06, 0x22bf);
17895         MP_WritePhyUshort(sc, 0x06, 0x479a);
17896         MP_WritePhyUshort(sc, 0x06, 0x0239);
17897         MP_WritePhyUshort(sc, 0x06, 0xc6e0);
17898         MP_WritePhyUshort(sc, 0x06, 0x8b44);
17899         MP_WritePhyUshort(sc, 0x06, 0x1f01);
17900         MP_WritePhyUshort(sc, 0x06, 0x9e15);
17901         MP_WritePhyUshort(sc, 0x06, 0xe58b);
17902         MP_WritePhyUshort(sc, 0x06, 0x44ad);
17903         MP_WritePhyUshort(sc, 0x06, 0x2907);
17904         MP_WritePhyUshort(sc, 0x06, 0xac28);
17905         MP_WritePhyUshort(sc, 0x06, 0x04d1);
17906         MP_WritePhyUshort(sc, 0x06, 0x01ae);
17907         MP_WritePhyUshort(sc, 0x06, 0x02d1);
17908         MP_WritePhyUshort(sc, 0x06, 0x00bf);
17909         MP_WritePhyUshort(sc, 0x06, 0x819e);
17910         MP_WritePhyUshort(sc, 0x06, 0x0239);
17911         MP_WritePhyUshort(sc, 0x06, 0xf3ef);
17912         MP_WritePhyUshort(sc, 0x06, 0x96fe);
17913         MP_WritePhyUshort(sc, 0x06, 0xfc04);
17914         MP_WritePhyUshort(sc, 0x06, 0x00e1);
17915         MP_WritePhyUshort(sc, 0x06, 0x4077);
17916         MP_WritePhyUshort(sc, 0x06, 0xe140);
17917         MP_WritePhyUshort(sc, 0x06, 0xbbe0);
17918         MP_WritePhyUshort(sc, 0x06, 0x2a00);
17919         MP_WritePhyUshort(sc, 0x05, 0xe142);
17920         PhyRegValue = MP_ReadPhyUshort(sc, 0x06);
17921         PhyRegValue |= BIT_0;
17922         MP_WritePhyUshort(sc, 0x06, PhyRegValue);
17923         MP_WritePhyUshort(sc, 0x05, 0xe140);
17924         PhyRegValue = MP_ReadPhyUshort(sc, 0x06);
17925         PhyRegValue |= BIT_0;
17926         MP_WritePhyUshort(sc, 0x06, PhyRegValue);
17927         MP_WritePhyUshort(sc, 0x1f, 0x0000);
17928         MP_WritePhyUshort(sc, 0x1f, 0x0007);
17929         MP_WritePhyUshort(sc, 0x1e, 0x0023);
17930         PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
17931         PhyRegValue |= BIT_1;
17932         if (sc->RequiredSecLanDonglePatch)
17933                 PhyRegValue &= ~(BIT_2);
17934         MP_WritePhyUshort(sc, 0x17, PhyRegValue);
17935         MP_WritePhyUshort(sc, 0x1f, 0x0000);
17936
17937         MP_WritePhyUshort(sc, 0x1f, 0x0003);
17938         PhyRegValue = MP_ReadPhyUshort(sc, 0x19);
17939         PhyRegValue &= ~BIT_0;
17940         MP_WritePhyUshort(sc, 0x19, PhyRegValue);
17941         PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
17942         PhyRegValue &= ~BIT_10;
17943         MP_WritePhyUshort(sc, 0x10, PhyRegValue);
17944
17945         MP_WritePhyUshort(sc, 0x1f, 0x0000);
17946         MP_WritePhyUshort(sc, 0x00, 0x9200);
17947 }
17948
17949 static void re_set_phy_mcu_8411_1(struct re_softc *sc)
17950 {
17951         u_int16_t PhyRegValue;
17952         int i;
17953
17954         MP_WritePhyUshort(sc, 0x1f, 0x0000);
17955         MP_WritePhyUshort(sc, 0x00, 0x1800);
17956         PhyRegValue = MP_ReadPhyUshort(sc, 0x15);
17957         PhyRegValue &= ~(BIT_12);
17958         MP_WritePhyUshort(sc, 0x15, PhyRegValue);
17959         MP_WritePhyUshort(sc, 0x00, 0x4800);
17960         MP_WritePhyUshort(sc, 0x1f, 0x0007);
17961         MP_WritePhyUshort(sc, 0x1e, 0x002f);
17962         for (i = 0; i < 1000; i++) {
17963                 DELAY(100);
17964                 PhyRegValue = MP_ReadPhyUshort(sc, 0x1c);
17965                 if (PhyRegValue & BIT_7)
17966                         break;
17967         }
17968         MP_WritePhyUshort(sc, 0x1f, 0x0000);
17969         MP_WritePhyUshort(sc, 0x00, 0x1800);
17970         MP_WritePhyUshort(sc, 0x1f, 0x0007);
17971         MP_WritePhyUshort(sc, 0x1e, 0x0023);
17972         for (i = 0; i < 200; i++) {
17973                 DELAY(100);
17974                 PhyRegValue = MP_ReadPhyUshort(sc, 0x18);
17975                 if (!(PhyRegValue & BIT_0))
17976                         break;
17977         }
17978         MP_WritePhyUshort(sc, 0x1f, 0x0005);
17979         MP_WritePhyUshort(sc, 0x05, 0xfff6);
17980         MP_WritePhyUshort(sc, 0x06, 0x0080);
17981         MP_WritePhyUshort(sc, 0x1f, 0x0007);
17982         MP_WritePhyUshort(sc, 0x1e, 0x0023);
17983         MP_WritePhyUshort(sc, 0x16, 0x0306);
17984         MP_WritePhyUshort(sc, 0x16, 0x0307);
17985         MP_WritePhyUshort(sc, 0x15, 0x0098);
17986         MP_WritePhyUshort(sc, 0x19, 0x7c0b);
17987         MP_WritePhyUshort(sc, 0x15, 0x0099);
17988         MP_WritePhyUshort(sc, 0x19, 0x6c0b);
17989         MP_WritePhyUshort(sc, 0x15, 0x00eb);
17990         MP_WritePhyUshort(sc, 0x19, 0x6c0b);
17991         MP_WritePhyUshort(sc, 0x15, 0x00f8);
17992         MP_WritePhyUshort(sc, 0x19, 0x6f0b);
17993         MP_WritePhyUshort(sc, 0x15, 0x00fe);
17994         MP_WritePhyUshort(sc, 0x19, 0x6f0f);
17995         MP_WritePhyUshort(sc, 0x15, 0x00db);
17996         MP_WritePhyUshort(sc, 0x19, 0x6f09);
17997         MP_WritePhyUshort(sc, 0x15, 0x00dc);
17998         MP_WritePhyUshort(sc, 0x19, 0xaefd);
17999         MP_WritePhyUshort(sc, 0x15, 0x00dd);
18000         MP_WritePhyUshort(sc, 0x19, 0x6f0b);
18001         MP_WritePhyUshort(sc, 0x15, 0x00de);
18002         MP_WritePhyUshort(sc, 0x19, 0xc60b);
18003         MP_WritePhyUshort(sc, 0x15, 0x00df);
18004         MP_WritePhyUshort(sc, 0x19, 0x00fa);
18005         MP_WritePhyUshort(sc, 0x15, 0x00e0);
18006         MP_WritePhyUshort(sc, 0x19, 0x30e1);
18007         MP_WritePhyUshort(sc, 0x15, 0x020c);
18008         MP_WritePhyUshort(sc, 0x19, 0x3224);
18009         MP_WritePhyUshort(sc, 0x15, 0x020e);
18010         MP_WritePhyUshort(sc, 0x19, 0x9813);
18011         MP_WritePhyUshort(sc, 0x15, 0x020f);
18012         MP_WritePhyUshort(sc, 0x19, 0x7801);
18013         MP_WritePhyUshort(sc, 0x15, 0x0210);
18014         MP_WritePhyUshort(sc, 0x19, 0x930f);
18015         MP_WritePhyUshort(sc, 0x15, 0x0211);
18016         MP_WritePhyUshort(sc, 0x19, 0x9206);
18017         MP_WritePhyUshort(sc, 0x15, 0x0212);
18018         MP_WritePhyUshort(sc, 0x19, 0x4002);
18019         MP_WritePhyUshort(sc, 0x15, 0x0213);
18020         MP_WritePhyUshort(sc, 0x19, 0x7800);
18021         MP_WritePhyUshort(sc, 0x15, 0x0214);
18022         MP_WritePhyUshort(sc, 0x19, 0x588f);
18023         MP_WritePhyUshort(sc, 0x15, 0x0215);
18024         MP_WritePhyUshort(sc, 0x19, 0x5520);
18025         MP_WritePhyUshort(sc, 0x15, 0x0216);
18026         MP_WritePhyUshort(sc, 0x19, 0x3224);
18027         MP_WritePhyUshort(sc, 0x15, 0x0217);
18028         MP_WritePhyUshort(sc, 0x19, 0x4002);
18029         MP_WritePhyUshort(sc, 0x15, 0x0218);
18030         MP_WritePhyUshort(sc, 0x19, 0x7800);
18031         MP_WritePhyUshort(sc, 0x15, 0x0219);
18032         MP_WritePhyUshort(sc, 0x19, 0x588d);
18033         MP_WritePhyUshort(sc, 0x15, 0x021a);
18034         MP_WritePhyUshort(sc, 0x19, 0x5540);
18035         MP_WritePhyUshort(sc, 0x15, 0x021b);
18036         MP_WritePhyUshort(sc, 0x19, 0x9e03);
18037         MP_WritePhyUshort(sc, 0x15, 0x021c);
18038         MP_WritePhyUshort(sc, 0x19, 0x7c40);
18039         MP_WritePhyUshort(sc, 0x15, 0x021d);
18040         MP_WritePhyUshort(sc, 0x19, 0x6840);
18041         MP_WritePhyUshort(sc, 0x15, 0x021e);
18042         MP_WritePhyUshort(sc, 0x19, 0x3224);
18043         MP_WritePhyUshort(sc, 0x15, 0x021f);
18044         MP_WritePhyUshort(sc, 0x19, 0x4002);
18045         MP_WritePhyUshort(sc, 0x15, 0x0220);
18046         MP_WritePhyUshort(sc, 0x19, 0x3224);
18047         MP_WritePhyUshort(sc, 0x15, 0x0221);
18048         MP_WritePhyUshort(sc, 0x19, 0x9e03);
18049         MP_WritePhyUshort(sc, 0x15, 0x0222);
18050         MP_WritePhyUshort(sc, 0x19, 0x7c40);
18051         MP_WritePhyUshort(sc, 0x15, 0x0223);
18052         MP_WritePhyUshort(sc, 0x19, 0x6840);
18053         MP_WritePhyUshort(sc, 0x15, 0x0224);
18054         MP_WritePhyUshort(sc, 0x19, 0x7800);
18055         MP_WritePhyUshort(sc, 0x15, 0x0225);
18056         MP_WritePhyUshort(sc, 0x19, 0x3231);
18057         MP_WritePhyUshort(sc, 0x15, 0x0000);
18058         MP_WritePhyUshort(sc, 0x16, 0x0306);
18059         MP_WritePhyUshort(sc, 0x16, 0x0300);
18060         MP_WritePhyUshort(sc, 0x1f, 0x0000);
18061         MP_WritePhyUshort(sc, 0x1f, 0x0005);
18062         MP_WritePhyUshort(sc, 0x05, 0xfff6);
18063         MP_WritePhyUshort(sc, 0x06, 0x0080);
18064         MP_WritePhyUshort(sc, 0x05, 0x8000);
18065         MP_WritePhyUshort(sc, 0x06, 0x0280);
18066         MP_WritePhyUshort(sc, 0x06, 0x48f7);
18067         MP_WritePhyUshort(sc, 0x06, 0x00e0);
18068         MP_WritePhyUshort(sc, 0x06, 0xfff7);
18069         MP_WritePhyUshort(sc, 0x06, 0xa080);
18070         MP_WritePhyUshort(sc, 0x06, 0x02ae);
18071         MP_WritePhyUshort(sc, 0x06, 0xf602);
18072         MP_WritePhyUshort(sc, 0x06, 0x011e);
18073         MP_WritePhyUshort(sc, 0x06, 0x0201);
18074         MP_WritePhyUshort(sc, 0x06, 0x2b02);
18075         MP_WritePhyUshort(sc, 0x06, 0x8077);
18076         MP_WritePhyUshort(sc, 0x06, 0x0201);
18077         MP_WritePhyUshort(sc, 0x06, 0x4802);
18078         MP_WritePhyUshort(sc, 0x06, 0x0162);
18079         MP_WritePhyUshort(sc, 0x06, 0x0280);
18080         MP_WritePhyUshort(sc, 0x06, 0x9402);
18081         MP_WritePhyUshort(sc, 0x06, 0x810e);
18082         MP_WritePhyUshort(sc, 0x06, 0xe08b);
18083         MP_WritePhyUshort(sc, 0x06, 0x88e1);
18084         MP_WritePhyUshort(sc, 0x06, 0x8b89);
18085         MP_WritePhyUshort(sc, 0x06, 0x1e01);
18086         MP_WritePhyUshort(sc, 0x06, 0xe18b);
18087         MP_WritePhyUshort(sc, 0x06, 0x8a1e);
18088         MP_WritePhyUshort(sc, 0x06, 0x01e1);
18089         MP_WritePhyUshort(sc, 0x06, 0x8b8b);
18090         MP_WritePhyUshort(sc, 0x06, 0x1e01);
18091         MP_WritePhyUshort(sc, 0x06, 0xe18b);
18092         MP_WritePhyUshort(sc, 0x06, 0x8c1e);
18093         MP_WritePhyUshort(sc, 0x06, 0x01e1);
18094         MP_WritePhyUshort(sc, 0x06, 0x8b8d);
18095         MP_WritePhyUshort(sc, 0x06, 0x1e01);
18096         MP_WritePhyUshort(sc, 0x06, 0xe18b);
18097         MP_WritePhyUshort(sc, 0x06, 0x8e1e);
18098         MP_WritePhyUshort(sc, 0x06, 0x01a0);
18099         MP_WritePhyUshort(sc, 0x06, 0x00c7);
18100         MP_WritePhyUshort(sc, 0x06, 0xaebb);
18101         MP_WritePhyUshort(sc, 0x06, 0xd481);
18102         MP_WritePhyUshort(sc, 0x06, 0xd4e4);
18103         MP_WritePhyUshort(sc, 0x06, 0x8b92);
18104         MP_WritePhyUshort(sc, 0x06, 0xe58b);
18105         MP_WritePhyUshort(sc, 0x06, 0x9302);
18106         MP_WritePhyUshort(sc, 0x06, 0x2e5a);
18107         MP_WritePhyUshort(sc, 0x06, 0xbf8b);
18108         MP_WritePhyUshort(sc, 0x06, 0x88ec);
18109         MP_WritePhyUshort(sc, 0x06, 0x0019);
18110         MP_WritePhyUshort(sc, 0x06, 0xa98b);
18111         MP_WritePhyUshort(sc, 0x06, 0x90f9);
18112         MP_WritePhyUshort(sc, 0x06, 0xeeff);
18113         MP_WritePhyUshort(sc, 0x06, 0xf600);
18114         MP_WritePhyUshort(sc, 0x06, 0xeeff);
18115         MP_WritePhyUshort(sc, 0x06, 0xf7fc);
18116         MP_WritePhyUshort(sc, 0x06, 0xd100);
18117         MP_WritePhyUshort(sc, 0x06, 0xbf83);
18118         MP_WritePhyUshort(sc, 0x06, 0x3c02);
18119         MP_WritePhyUshort(sc, 0x06, 0x3a21);
18120         MP_WritePhyUshort(sc, 0x06, 0xd101);
18121         MP_WritePhyUshort(sc, 0x06, 0xbf83);
18122         MP_WritePhyUshort(sc, 0x06, 0x3f02);
18123         MP_WritePhyUshort(sc, 0x06, 0x3a21);
18124         MP_WritePhyUshort(sc, 0x06, 0x04f8);
18125         MP_WritePhyUshort(sc, 0x06, 0xe08b);
18126         MP_WritePhyUshort(sc, 0x06, 0x8aad);
18127         MP_WritePhyUshort(sc, 0x06, 0x2014);
18128         MP_WritePhyUshort(sc, 0x06, 0xee8b);
18129         MP_WritePhyUshort(sc, 0x06, 0x8a00);
18130         MP_WritePhyUshort(sc, 0x06, 0x0220);
18131         MP_WritePhyUshort(sc, 0x06, 0x8be0);
18132         MP_WritePhyUshort(sc, 0x06, 0xe426);
18133         MP_WritePhyUshort(sc, 0x06, 0xe1e4);
18134         MP_WritePhyUshort(sc, 0x06, 0x27ee);
18135         MP_WritePhyUshort(sc, 0x06, 0xe426);
18136         MP_WritePhyUshort(sc, 0x06, 0x23e5);
18137         MP_WritePhyUshort(sc, 0x06, 0xe427);
18138         MP_WritePhyUshort(sc, 0x06, 0xfc04);
18139         MP_WritePhyUshort(sc, 0x06, 0xf8e0);
18140         MP_WritePhyUshort(sc, 0x06, 0x8b8d);
18141         MP_WritePhyUshort(sc, 0x06, 0xad20);
18142         MP_WritePhyUshort(sc, 0x06, 0x14ee);
18143         MP_WritePhyUshort(sc, 0x06, 0x8b8d);
18144         MP_WritePhyUshort(sc, 0x06, 0x00e0);
18145         MP_WritePhyUshort(sc, 0x06, 0x8a5a);
18146         MP_WritePhyUshort(sc, 0x06, 0x7803);
18147         MP_WritePhyUshort(sc, 0x06, 0x9e09);
18148         MP_WritePhyUshort(sc, 0x06, 0x0206);
18149         MP_WritePhyUshort(sc, 0x06, 0x2802);
18150         MP_WritePhyUshort(sc, 0x06, 0x80b1);
18151         MP_WritePhyUshort(sc, 0x06, 0x0232);
18152         MP_WritePhyUshort(sc, 0x06, 0xfdfc);
18153         MP_WritePhyUshort(sc, 0x06, 0x04f8);
18154         MP_WritePhyUshort(sc, 0x06, 0xf9e0);
18155         MP_WritePhyUshort(sc, 0x06, 0x8b81);
18156         MP_WritePhyUshort(sc, 0x06, 0xac26);
18157         MP_WritePhyUshort(sc, 0x06, 0x1ae0);
18158         MP_WritePhyUshort(sc, 0x06, 0x8b81);
18159         MP_WritePhyUshort(sc, 0x06, 0xac21);
18160         MP_WritePhyUshort(sc, 0x06, 0x14e0);
18161         MP_WritePhyUshort(sc, 0x06, 0x8b85);
18162         MP_WritePhyUshort(sc, 0x06, 0xac20);
18163         MP_WritePhyUshort(sc, 0x06, 0x0ee0);
18164         MP_WritePhyUshort(sc, 0x06, 0x8b85);
18165         MP_WritePhyUshort(sc, 0x06, 0xac23);
18166         MP_WritePhyUshort(sc, 0x06, 0x08e0);
18167         MP_WritePhyUshort(sc, 0x06, 0x8b87);
18168         MP_WritePhyUshort(sc, 0x06, 0xac24);
18169         MP_WritePhyUshort(sc, 0x06, 0x02ae);
18170         MP_WritePhyUshort(sc, 0x06, 0x3802);
18171         MP_WritePhyUshort(sc, 0x06, 0x1b02);
18172         MP_WritePhyUshort(sc, 0x06, 0xeee4);
18173         MP_WritePhyUshort(sc, 0x06, 0x1c04);
18174         MP_WritePhyUshort(sc, 0x06, 0xeee4);
18175         MP_WritePhyUshort(sc, 0x06, 0x1d04);
18176         MP_WritePhyUshort(sc, 0x06, 0xe2e0);
18177         MP_WritePhyUshort(sc, 0x06, 0x7ce3);
18178         MP_WritePhyUshort(sc, 0x06, 0xe07d);
18179         MP_WritePhyUshort(sc, 0x06, 0xe0e0);
18180         MP_WritePhyUshort(sc, 0x06, 0x38e1);
18181         MP_WritePhyUshort(sc, 0x06, 0xe039);
18182         MP_WritePhyUshort(sc, 0x06, 0xad2e);
18183         MP_WritePhyUshort(sc, 0x06, 0x1bad);
18184         MP_WritePhyUshort(sc, 0x06, 0x390d);
18185         MP_WritePhyUshort(sc, 0x06, 0xd101);
18186         MP_WritePhyUshort(sc, 0x06, 0xbf22);
18187         MP_WritePhyUshort(sc, 0x06, 0xe802);
18188         MP_WritePhyUshort(sc, 0x06, 0x3a21);
18189         MP_WritePhyUshort(sc, 0x06, 0x0222);
18190         MP_WritePhyUshort(sc, 0x06, 0x10ae);
18191         MP_WritePhyUshort(sc, 0x06, 0x0bac);
18192         MP_WritePhyUshort(sc, 0x06, 0x3802);
18193         MP_WritePhyUshort(sc, 0x06, 0xae06);
18194         MP_WritePhyUshort(sc, 0x06, 0x0222);
18195         MP_WritePhyUshort(sc, 0x06, 0x4d02);
18196         MP_WritePhyUshort(sc, 0x06, 0x2292);
18197         MP_WritePhyUshort(sc, 0x06, 0x021b);
18198         MP_WritePhyUshort(sc, 0x06, 0x13fd);
18199         MP_WritePhyUshort(sc, 0x06, 0xfc04);
18200         MP_WritePhyUshort(sc, 0x06, 0xf8e0);
18201         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
18202         MP_WritePhyUshort(sc, 0x06, 0xad20);
18203         MP_WritePhyUshort(sc, 0x06, 0x1af6);
18204         MP_WritePhyUshort(sc, 0x06, 0x20e4);
18205         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
18206         MP_WritePhyUshort(sc, 0x06, 0x022b);
18207         MP_WritePhyUshort(sc, 0x06, 0x1e02);
18208         MP_WritePhyUshort(sc, 0x06, 0x82ae);
18209         MP_WritePhyUshort(sc, 0x06, 0x0203);
18210         MP_WritePhyUshort(sc, 0x06, 0xc002);
18211         MP_WritePhyUshort(sc, 0x06, 0x827d);
18212         MP_WritePhyUshort(sc, 0x06, 0x022e);
18213         MP_WritePhyUshort(sc, 0x06, 0x6f02);
18214         MP_WritePhyUshort(sc, 0x06, 0x047b);
18215         MP_WritePhyUshort(sc, 0x06, 0x022f);
18216         MP_WritePhyUshort(sc, 0x06, 0x9ae0);
18217         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
18218         MP_WritePhyUshort(sc, 0x06, 0xad21);
18219         MP_WritePhyUshort(sc, 0x06, 0x0bf6);
18220         MP_WritePhyUshort(sc, 0x06, 0x21e4);
18221         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
18222         MP_WritePhyUshort(sc, 0x06, 0x0281);
18223         MP_WritePhyUshort(sc, 0x06, 0x9002);
18224         MP_WritePhyUshort(sc, 0x06, 0x1cd9);
18225         MP_WritePhyUshort(sc, 0x06, 0xe08b);
18226         MP_WritePhyUshort(sc, 0x06, 0x8ead);
18227         MP_WritePhyUshort(sc, 0x06, 0x2208);
18228         MP_WritePhyUshort(sc, 0x06, 0xf622);
18229         MP_WritePhyUshort(sc, 0x06, 0xe48b);
18230         MP_WritePhyUshort(sc, 0x06, 0x8e02);
18231         MP_WritePhyUshort(sc, 0x06, 0x35f4);
18232         MP_WritePhyUshort(sc, 0x06, 0xe08b);
18233         MP_WritePhyUshort(sc, 0x06, 0x8ead);
18234         MP_WritePhyUshort(sc, 0x06, 0x2308);
18235         MP_WritePhyUshort(sc, 0x06, 0xf623);
18236         MP_WritePhyUshort(sc, 0x06, 0xe48b);
18237         MP_WritePhyUshort(sc, 0x06, 0x8e02);
18238         MP_WritePhyUshort(sc, 0x06, 0x31e8);
18239         MP_WritePhyUshort(sc, 0x06, 0xe08b);
18240         MP_WritePhyUshort(sc, 0x06, 0x8ead);
18241         MP_WritePhyUshort(sc, 0x06, 0x2405);
18242         MP_WritePhyUshort(sc, 0x06, 0xf624);
18243         MP_WritePhyUshort(sc, 0x06, 0xe48b);
18244         MP_WritePhyUshort(sc, 0x06, 0x8ee0);
18245         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
18246         MP_WritePhyUshort(sc, 0x06, 0xad25);
18247         MP_WritePhyUshort(sc, 0x06, 0x05f6);
18248         MP_WritePhyUshort(sc, 0x06, 0x25e4);
18249         MP_WritePhyUshort(sc, 0x06, 0x8b8e);
18250         MP_WritePhyUshort(sc, 0x06, 0xe08b);
18251         MP_WritePhyUshort(sc, 0x06, 0x8ead);
18252         MP_WritePhyUshort(sc, 0x06, 0x2608);
18253         MP_WritePhyUshort(sc, 0x06, 0xf626);
18254         MP_WritePhyUshort(sc, 0x06, 0xe48b);
18255         MP_WritePhyUshort(sc, 0x06, 0x8e02);
18256         MP_WritePhyUshort(sc, 0x06, 0x2d8a);
18257         MP_WritePhyUshort(sc, 0x06, 0xe08b);
18258         MP_WritePhyUshort(sc, 0x06, 0x8ead);
18259         MP_WritePhyUshort(sc, 0x06, 0x2705);
18260         MP_WritePhyUshort(sc, 0x06, 0xf627);
18261         MP_WritePhyUshort(sc, 0x06, 0xe48b);
18262         MP_WritePhyUshort(sc, 0x06, 0x8e02);
18263         MP_WritePhyUshort(sc, 0x06, 0x0386);
18264         MP_WritePhyUshort(sc, 0x06, 0xfc04);
18265         MP_WritePhyUshort(sc, 0x06, 0xf8fa);
18266         MP_WritePhyUshort(sc, 0x06, 0xef69);
18267         MP_WritePhyUshort(sc, 0x06, 0xe0e0);
18268         MP_WritePhyUshort(sc, 0x06, 0x00e1);
18269         MP_WritePhyUshort(sc, 0x06, 0xe001);
18270         MP_WritePhyUshort(sc, 0x06, 0xad27);
18271         MP_WritePhyUshort(sc, 0x06, 0x32e0);
18272         MP_WritePhyUshort(sc, 0x06, 0x8b40);
18273         MP_WritePhyUshort(sc, 0x06, 0xf720);
18274         MP_WritePhyUshort(sc, 0x06, 0xe48b);
18275         MP_WritePhyUshort(sc, 0x06, 0x40bf);
18276         MP_WritePhyUshort(sc, 0x06, 0x32c1);
18277         MP_WritePhyUshort(sc, 0x06, 0x0239);
18278         MP_WritePhyUshort(sc, 0x06, 0xf4ad);
18279         MP_WritePhyUshort(sc, 0x06, 0x2821);
18280         MP_WritePhyUshort(sc, 0x06, 0xe0e0);
18281         MP_WritePhyUshort(sc, 0x06, 0x20e1);
18282         MP_WritePhyUshort(sc, 0x06, 0xe021);
18283         MP_WritePhyUshort(sc, 0x06, 0xad20);
18284         MP_WritePhyUshort(sc, 0x06, 0x18e0);
18285         MP_WritePhyUshort(sc, 0x06, 0x8b40);
18286         MP_WritePhyUshort(sc, 0x06, 0xf620);
18287         MP_WritePhyUshort(sc, 0x06, 0xe48b);
18288         MP_WritePhyUshort(sc, 0x06, 0x40ee);
18289         MP_WritePhyUshort(sc, 0x06, 0x8b3b);
18290         MP_WritePhyUshort(sc, 0x06, 0xffe0);
18291         MP_WritePhyUshort(sc, 0x06, 0x8a8a);
18292         MP_WritePhyUshort(sc, 0x06, 0xe18a);
18293         MP_WritePhyUshort(sc, 0x06, 0x8be4);
18294         MP_WritePhyUshort(sc, 0x06, 0xe000);
18295         MP_WritePhyUshort(sc, 0x06, 0xe5e0);
18296         MP_WritePhyUshort(sc, 0x06, 0x01ef);
18297         MP_WritePhyUshort(sc, 0x06, 0x96fe);
18298         MP_WritePhyUshort(sc, 0x06, 0xfc04);
18299         MP_WritePhyUshort(sc, 0x06, 0xf8f9);
18300         MP_WritePhyUshort(sc, 0x06, 0xface);
18301         MP_WritePhyUshort(sc, 0x06, 0xfaef);
18302         MP_WritePhyUshort(sc, 0x06, 0x69fa);
18303         MP_WritePhyUshort(sc, 0x06, 0xd401);
18304         MP_WritePhyUshort(sc, 0x06, 0x55b4);
18305         MP_WritePhyUshort(sc, 0x06, 0xfebf);
18306         MP_WritePhyUshort(sc, 0x06, 0x1c5e);
18307         MP_WritePhyUshort(sc, 0x06, 0x0239);
18308         MP_WritePhyUshort(sc, 0x06, 0xf4ac);
18309         MP_WritePhyUshort(sc, 0x06, 0x280b);
18310         MP_WritePhyUshort(sc, 0x06, 0xbf1c);
18311         MP_WritePhyUshort(sc, 0x06, 0x5b02);
18312         MP_WritePhyUshort(sc, 0x06, 0x39f4);
18313         MP_WritePhyUshort(sc, 0x06, 0xac28);
18314         MP_WritePhyUshort(sc, 0x06, 0x49ae);
18315         MP_WritePhyUshort(sc, 0x06, 0x64bf);
18316         MP_WritePhyUshort(sc, 0x06, 0x1c5b);
18317         MP_WritePhyUshort(sc, 0x06, 0x0239);
18318         MP_WritePhyUshort(sc, 0x06, 0xf4ac);
18319         MP_WritePhyUshort(sc, 0x06, 0x285b);
18320         MP_WritePhyUshort(sc, 0x06, 0xd000);
18321         MP_WritePhyUshort(sc, 0x06, 0x0282);
18322         MP_WritePhyUshort(sc, 0x06, 0x62ac);
18323         MP_WritePhyUshort(sc, 0x06, 0x2105);
18324         MP_WritePhyUshort(sc, 0x06, 0xac22);
18325         MP_WritePhyUshort(sc, 0x06, 0x02ae);
18326         MP_WritePhyUshort(sc, 0x06, 0x4ebf);
18327         MP_WritePhyUshort(sc, 0x06, 0xe0c4);
18328         MP_WritePhyUshort(sc, 0x06, 0xbe85);
18329         MP_WritePhyUshort(sc, 0x06, 0xecd2);
18330         MP_WritePhyUshort(sc, 0x06, 0x04d8);
18331         MP_WritePhyUshort(sc, 0x06, 0x19d9);
18332         MP_WritePhyUshort(sc, 0x06, 0x1907);
18333         MP_WritePhyUshort(sc, 0x06, 0xdc19);
18334         MP_WritePhyUshort(sc, 0x06, 0xdd19);
18335         MP_WritePhyUshort(sc, 0x06, 0x0789);
18336         MP_WritePhyUshort(sc, 0x06, 0x89ef);
18337         MP_WritePhyUshort(sc, 0x06, 0x645e);
18338         MP_WritePhyUshort(sc, 0x06, 0x07ff);
18339         MP_WritePhyUshort(sc, 0x06, 0x0d65);
18340         MP_WritePhyUshort(sc, 0x06, 0x5cf8);
18341         MP_WritePhyUshort(sc, 0x06, 0x001e);
18342         MP_WritePhyUshort(sc, 0x06, 0x46dc);
18343         MP_WritePhyUshort(sc, 0x06, 0x19dd);
18344         MP_WritePhyUshort(sc, 0x06, 0x19b2);
18345         MP_WritePhyUshort(sc, 0x06, 0xe2d4);
18346         MP_WritePhyUshort(sc, 0x06, 0x0001);
18347         MP_WritePhyUshort(sc, 0x06, 0xbf1c);
18348         MP_WritePhyUshort(sc, 0x06, 0x5b02);
18349         MP_WritePhyUshort(sc, 0x06, 0x3a21);
18350         MP_WritePhyUshort(sc, 0x06, 0xae1d);
18351         MP_WritePhyUshort(sc, 0x06, 0xbee0);
18352         MP_WritePhyUshort(sc, 0x06, 0xc4bf);
18353         MP_WritePhyUshort(sc, 0x06, 0x85ec);
18354         MP_WritePhyUshort(sc, 0x06, 0xd204);
18355         MP_WritePhyUshort(sc, 0x06, 0xd819);
18356         MP_WritePhyUshort(sc, 0x06, 0xd919);
18357         MP_WritePhyUshort(sc, 0x06, 0x07dc);
18358         MP_WritePhyUshort(sc, 0x06, 0x19dd);
18359         MP_WritePhyUshort(sc, 0x06, 0x1907);
18360         MP_WritePhyUshort(sc, 0x06, 0xb2f4);
18361         MP_WritePhyUshort(sc, 0x06, 0xd400);
18362         MP_WritePhyUshort(sc, 0x06, 0x00bf);
18363         MP_WritePhyUshort(sc, 0x06, 0x1c5b);
18364         MP_WritePhyUshort(sc, 0x06, 0x023a);
18365         MP_WritePhyUshort(sc, 0x06, 0x21fe);
18366         MP_WritePhyUshort(sc, 0x06, 0xef96);
18367         MP_WritePhyUshort(sc, 0x06, 0xfec6);
18368         MP_WritePhyUshort(sc, 0x06, 0xfefd);
18369         MP_WritePhyUshort(sc, 0x06, 0xfc05);
18370         MP_WritePhyUshort(sc, 0x06, 0xf9e2);
18371         MP_WritePhyUshort(sc, 0x06, 0xe0ea);
18372         MP_WritePhyUshort(sc, 0x06, 0xe3e0);
18373         MP_WritePhyUshort(sc, 0x06, 0xeb5a);
18374         MP_WritePhyUshort(sc, 0x06, 0x070c);
18375         MP_WritePhyUshort(sc, 0x06, 0x031e);
18376         MP_WritePhyUshort(sc, 0x06, 0x20e6);
18377         MP_WritePhyUshort(sc, 0x06, 0xe0ea);
18378         MP_WritePhyUshort(sc, 0x06, 0xe7e0);
18379         MP_WritePhyUshort(sc, 0x06, 0xebe0);
18380         MP_WritePhyUshort(sc, 0x06, 0xe0fc);
18381         MP_WritePhyUshort(sc, 0x06, 0xe1e0);
18382         MP_WritePhyUshort(sc, 0x06, 0xfdfd);
18383         MP_WritePhyUshort(sc, 0x06, 0x04f8);
18384         MP_WritePhyUshort(sc, 0x06, 0xfaef);
18385         MP_WritePhyUshort(sc, 0x06, 0x69e0);
18386         MP_WritePhyUshort(sc, 0x06, 0x8b80);
18387         MP_WritePhyUshort(sc, 0x06, 0xad27);
18388         MP_WritePhyUshort(sc, 0x06, 0x22bf);
18389         MP_WritePhyUshort(sc, 0x06, 0x47ba);
18390         MP_WritePhyUshort(sc, 0x06, 0x0239);
18391         MP_WritePhyUshort(sc, 0x06, 0xf4e0);
18392         MP_WritePhyUshort(sc, 0x06, 0x8b44);
18393         MP_WritePhyUshort(sc, 0x06, 0x1f01);
18394         MP_WritePhyUshort(sc, 0x06, 0x9e15);
18395         MP_WritePhyUshort(sc, 0x06, 0xe58b);
18396         MP_WritePhyUshort(sc, 0x06, 0x44ad);
18397         MP_WritePhyUshort(sc, 0x06, 0x2907);
18398         MP_WritePhyUshort(sc, 0x06, 0xac28);
18399         MP_WritePhyUshort(sc, 0x06, 0x04d1);
18400         MP_WritePhyUshort(sc, 0x06, 0x01ae);
18401         MP_WritePhyUshort(sc, 0x06, 0x02d1);
18402         MP_WritePhyUshort(sc, 0x06, 0x00bf);
18403         MP_WritePhyUshort(sc, 0x06, 0x8342);
18404         MP_WritePhyUshort(sc, 0x06, 0x023a);
18405         MP_WritePhyUshort(sc, 0x06, 0x21ef);
18406         MP_WritePhyUshort(sc, 0x06, 0x96fe);
18407         MP_WritePhyUshort(sc, 0x06, 0xfc04);
18408         MP_WritePhyUshort(sc, 0x06, 0xf8e0);
18409         MP_WritePhyUshort(sc, 0x06, 0x8b85);
18410         MP_WritePhyUshort(sc, 0x06, 0xad26);
18411         MP_WritePhyUshort(sc, 0x06, 0x30e0);
18412         MP_WritePhyUshort(sc, 0x06, 0xe036);
18413         MP_WritePhyUshort(sc, 0x06, 0xe1e0);
18414         MP_WritePhyUshort(sc, 0x06, 0x37e1);
18415         MP_WritePhyUshort(sc, 0x06, 0x8b3f);
18416         MP_WritePhyUshort(sc, 0x06, 0x1f10);
18417         MP_WritePhyUshort(sc, 0x06, 0x9e23);
18418         MP_WritePhyUshort(sc, 0x06, 0xe48b);
18419         MP_WritePhyUshort(sc, 0x06, 0x3fac);
18420         MP_WritePhyUshort(sc, 0x06, 0x200b);
18421         MP_WritePhyUshort(sc, 0x06, 0xac21);
18422         MP_WritePhyUshort(sc, 0x06, 0x0dac);
18423         MP_WritePhyUshort(sc, 0x06, 0x250f);
18424         MP_WritePhyUshort(sc, 0x06, 0xac27);
18425         MP_WritePhyUshort(sc, 0x06, 0x11ae);
18426         MP_WritePhyUshort(sc, 0x06, 0x1202);
18427         MP_WritePhyUshort(sc, 0x06, 0x2cb5);
18428         MP_WritePhyUshort(sc, 0x06, 0xae0d);
18429         MP_WritePhyUshort(sc, 0x06, 0x0282);
18430         MP_WritePhyUshort(sc, 0x06, 0xe7ae);
18431         MP_WritePhyUshort(sc, 0x06, 0x0802);
18432         MP_WritePhyUshort(sc, 0x06, 0x2cd7);
18433         MP_WritePhyUshort(sc, 0x06, 0xae03);
18434         MP_WritePhyUshort(sc, 0x06, 0x022c);
18435         MP_WritePhyUshort(sc, 0x06, 0xeafc);
18436         MP_WritePhyUshort(sc, 0x06, 0x04f8);
18437         MP_WritePhyUshort(sc, 0x06, 0xfaef);
18438         MP_WritePhyUshort(sc, 0x06, 0x6902);
18439         MP_WritePhyUshort(sc, 0x06, 0x8304);
18440         MP_WritePhyUshort(sc, 0x06, 0xe0e0);
18441         MP_WritePhyUshort(sc, 0x06, 0x14e1);
18442         MP_WritePhyUshort(sc, 0x06, 0xe015);
18443         MP_WritePhyUshort(sc, 0x06, 0xad26);
18444         MP_WritePhyUshort(sc, 0x06, 0x08d1);
18445         MP_WritePhyUshort(sc, 0x06, 0x1ebf);
18446         MP_WritePhyUshort(sc, 0x06, 0x2d47);
18447         MP_WritePhyUshort(sc, 0x06, 0x023a);
18448         MP_WritePhyUshort(sc, 0x06, 0x21ef);
18449         MP_WritePhyUshort(sc, 0x06, 0x96fe);
18450         MP_WritePhyUshort(sc, 0x06, 0xfc04);
18451         MP_WritePhyUshort(sc, 0x06, 0xf8e0);
18452         MP_WritePhyUshort(sc, 0x06, 0x8b85);
18453         MP_WritePhyUshort(sc, 0x06, 0xad27);
18454         MP_WritePhyUshort(sc, 0x06, 0x2fd0);
18455         MP_WritePhyUshort(sc, 0x06, 0x0b02);
18456         MP_WritePhyUshort(sc, 0x06, 0x3826);
18457         MP_WritePhyUshort(sc, 0x06, 0x5882);
18458         MP_WritePhyUshort(sc, 0x06, 0x7882);
18459         MP_WritePhyUshort(sc, 0x06, 0x9f24);
18460         MP_WritePhyUshort(sc, 0x06, 0xe08b);
18461         MP_WritePhyUshort(sc, 0x06, 0x32e1);
18462         MP_WritePhyUshort(sc, 0x06, 0x8b33);
18463         MP_WritePhyUshort(sc, 0x06, 0x1f10);
18464         MP_WritePhyUshort(sc, 0x06, 0x9e1a);
18465         MP_WritePhyUshort(sc, 0x06, 0x10e4);
18466         MP_WritePhyUshort(sc, 0x06, 0x8b32);
18467         MP_WritePhyUshort(sc, 0x06, 0xe0e0);
18468         MP_WritePhyUshort(sc, 0x06, 0x28e1);
18469         MP_WritePhyUshort(sc, 0x06, 0xe029);
18470         MP_WritePhyUshort(sc, 0x06, 0xf72c);
18471         MP_WritePhyUshort(sc, 0x06, 0xe4e0);
18472         MP_WritePhyUshort(sc, 0x06, 0x28e5);
18473         MP_WritePhyUshort(sc, 0x06, 0xe029);
18474         MP_WritePhyUshort(sc, 0x06, 0xf62c);
18475         MP_WritePhyUshort(sc, 0x06, 0xe4e0);
18476         MP_WritePhyUshort(sc, 0x06, 0x28e5);
18477         MP_WritePhyUshort(sc, 0x06, 0xe029);
18478         MP_WritePhyUshort(sc, 0x06, 0xfc04);
18479         MP_WritePhyUshort(sc, 0x06, 0x00e1);
18480         MP_WritePhyUshort(sc, 0x06, 0x4077);
18481         MP_WritePhyUshort(sc, 0x06, 0xe140);
18482         MP_WritePhyUshort(sc, 0x06, 0xbbe0);
18483         MP_WritePhyUshort(sc, 0x06, 0x2a00);
18484         MP_WritePhyUshort(sc, 0x05, 0xe142);
18485         PhyRegValue = MP_ReadPhyUshort(sc, 0x06);
18486         PhyRegValue |= BIT_0;
18487         MP_WritePhyUshort(sc, 0x06,PhyRegValue);
18488         MP_WritePhyUshort(sc, 0x05, 0xe140);
18489         PhyRegValue = MP_ReadPhyUshort(sc, 0x06);
18490         PhyRegValue |= BIT_0;
18491         MP_WritePhyUshort(sc, 0x06, PhyRegValue);
18492         MP_WritePhyUshort(sc, 0x1f, 0x0000);
18493         MP_WritePhyUshort(sc, 0x1f, 0x0005);
18494         for (i = 0; i < 200; i++) {
18495                 DELAY(100);
18496                 PhyRegValue = MP_ReadPhyUshort(sc, 0x00);
18497                 if (PhyRegValue & BIT_7)
18498                         break;
18499         }
18500         MP_WritePhyUshort(sc, 0x1f, 0x0007);
18501         MP_WritePhyUshort(sc, 0x1e, 0x0023);
18502         PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
18503         PhyRegValue |= BIT_1;
18504         if (sc->RequiredSecLanDonglePatch)
18505                 PhyRegValue &= ~(BIT_2);
18506         MP_WritePhyUshort(sc, 0x17, PhyRegValue);
18507         MP_WritePhyUshort(sc, 0x1f, 0x0000);
18508         MP_WritePhyUshort(sc, 0x1f, 0x0003);
18509         MP_WritePhyUshort(sc, 0x09, 0xA20F);
18510         MP_WritePhyUshort(sc, 0x1f, 0x0000);
18511         MP_WritePhyUshort(sc, 0x1f, 0x0003);
18512         MP_WritePhyUshort(sc, 0x01, 0x328A);
18513         MP_WritePhyUshort(sc, 0x1f, 0x0000);
18514         MP_WritePhyUshort(sc, 0x1f, 0x0003);
18515         PhyRegValue = MP_ReadPhyUshort(sc, 0x19);
18516         PhyRegValue &= ~BIT_0;
18517         MP_WritePhyUshort(sc, 0x19, PhyRegValue);
18518         PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
18519         PhyRegValue &= ~BIT_10;
18520         MP_WritePhyUshort(sc, 0x10, PhyRegValue);
18521         MP_WritePhyUshort(sc, 0x1f, 0x0000);
18522         MP_WritePhyUshort(sc, 0x00, 0x9200);
18523 }
18524
18525 static void re_set_phy_mcu_8168g_1(struct re_softc *sc)
18526 {
18527         u_int16_t PhyRegValue;
18528         u_int32_t WaitCnt;
18529
18530         MP_WritePhyUshort(sc, 0x1f, 0x0B82);
18531         PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
18532         PhyRegValue |= BIT_4;
18533         MP_WritePhyUshort(sc, 0x10, PhyRegValue);
18534
18535         MP_WritePhyUshort(sc, 0x1f, 0x0B80);
18536         WaitCnt = 0;
18537         do {
18538                 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
18539                 PhyRegValue &= 0x0040;
18540                 DELAY(50);
18541                 DELAY(50);
18542                 WaitCnt++;
18543         } while(PhyRegValue != 0x0040 && WaitCnt <1000);
18544
18545         MP_WritePhyUshort(sc, 0x1f, 0x0A43);
18546         MP_WritePhyUshort(sc, 0x13, 0x8146);
18547         MP_WritePhyUshort(sc, 0x14, 0x2300);
18548         MP_WritePhyUshort(sc, 0x13, 0xB820);
18549         MP_WritePhyUshort(sc, 0x14, 0x0210);
18550
18551         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
18552         MP_WritePhyUshort(sc, 0x13, 0xB820);
18553         MP_WritePhyUshort(sc, 0x14, 0x0290);
18554         MP_WritePhyUshort(sc, 0x13, 0xA012);
18555         MP_WritePhyUshort(sc, 0x14, 0x0000);
18556         MP_WritePhyUshort(sc, 0x13, 0xA014);
18557         MP_WritePhyUshort(sc, 0x14, 0x2c04);
18558         MP_WritePhyUshort(sc, 0x14, 0x2c0c);
18559         MP_WritePhyUshort(sc, 0x14, 0x2c6c);
18560         MP_WritePhyUshort(sc, 0x14, 0x2d0d);
18561         MP_WritePhyUshort(sc, 0x14, 0x31ce);
18562         MP_WritePhyUshort(sc, 0x14, 0x506d);
18563         MP_WritePhyUshort(sc, 0x14, 0xd708);
18564         MP_WritePhyUshort(sc, 0x14, 0x3108);
18565         MP_WritePhyUshort(sc, 0x14, 0x106d);
18566         MP_WritePhyUshort(sc, 0x14, 0x1560);
18567         MP_WritePhyUshort(sc, 0x14, 0x15a9);
18568         MP_WritePhyUshort(sc, 0x14, 0x206e);
18569         MP_WritePhyUshort(sc, 0x14, 0x175b);
18570         MP_WritePhyUshort(sc, 0x14, 0x6062);
18571         MP_WritePhyUshort(sc, 0x14, 0xd700);
18572         MP_WritePhyUshort(sc, 0x14, 0x5fae);
18573         MP_WritePhyUshort(sc, 0x14, 0xd708);
18574         MP_WritePhyUshort(sc, 0x14, 0x3107);
18575         MP_WritePhyUshort(sc, 0x14, 0x4c1e);
18576         MP_WritePhyUshort(sc, 0x14, 0x4169);
18577         MP_WritePhyUshort(sc, 0x14, 0x316a);
18578         MP_WritePhyUshort(sc, 0x14, 0x0c19);
18579         MP_WritePhyUshort(sc, 0x14, 0x31aa);
18580         MP_WritePhyUshort(sc, 0x14, 0x0c19);
18581         MP_WritePhyUshort(sc, 0x14, 0x2c1b);
18582         MP_WritePhyUshort(sc, 0x14, 0x5e62);
18583         MP_WritePhyUshort(sc, 0x14, 0x26b5);
18584         MP_WritePhyUshort(sc, 0x14, 0x31ab);
18585         MP_WritePhyUshort(sc, 0x14, 0x5c1e);
18586         MP_WritePhyUshort(sc, 0x14, 0x2c0c);
18587         MP_WritePhyUshort(sc, 0x14, 0xc040);
18588         MP_WritePhyUshort(sc, 0x14, 0x8808);
18589         MP_WritePhyUshort(sc, 0x14, 0xc520);
18590         MP_WritePhyUshort(sc, 0x14, 0xc421);
18591         MP_WritePhyUshort(sc, 0x14, 0xd05a);
18592         MP_WritePhyUshort(sc, 0x14, 0xd19a);
18593         MP_WritePhyUshort(sc, 0x14, 0xd709);
18594         MP_WritePhyUshort(sc, 0x14, 0x608f);
18595         MP_WritePhyUshort(sc, 0x14, 0xd06b);
18596         MP_WritePhyUshort(sc, 0x14, 0xd18a);
18597         MP_WritePhyUshort(sc, 0x14, 0x2c2c);
18598         MP_WritePhyUshort(sc, 0x14, 0xd0be);
18599         MP_WritePhyUshort(sc, 0x14, 0xd188);
18600         MP_WritePhyUshort(sc, 0x14, 0x2c2c);
18601         MP_WritePhyUshort(sc, 0x14, 0xd708);
18602         MP_WritePhyUshort(sc, 0x14, 0x4072);
18603         MP_WritePhyUshort(sc, 0x14, 0xc104);
18604         MP_WritePhyUshort(sc, 0x14, 0x2c3e);
18605         MP_WritePhyUshort(sc, 0x14, 0x4076);
18606         MP_WritePhyUshort(sc, 0x14, 0xc110);
18607         MP_WritePhyUshort(sc, 0x14, 0x2c3e);
18608         MP_WritePhyUshort(sc, 0x14, 0x4071);
18609         MP_WritePhyUshort(sc, 0x14, 0xc102);
18610         MP_WritePhyUshort(sc, 0x14, 0x2c3e);
18611         MP_WritePhyUshort(sc, 0x14, 0x4070);
18612         MP_WritePhyUshort(sc, 0x14, 0xc101);
18613         MP_WritePhyUshort(sc, 0x14, 0x2c3e);
18614         MP_WritePhyUshort(sc, 0x14, 0x175b);
18615         MP_WritePhyUshort(sc, 0x14, 0xd709);
18616         MP_WritePhyUshort(sc, 0x14, 0x3390);
18617         MP_WritePhyUshort(sc, 0x14, 0x5c39);
18618         MP_WritePhyUshort(sc, 0x14, 0x2c4e);
18619         MP_WritePhyUshort(sc, 0x14, 0x175b);
18620         MP_WritePhyUshort(sc, 0x14, 0xd708);
18621         MP_WritePhyUshort(sc, 0x14, 0x6193);
18622         MP_WritePhyUshort(sc, 0x14, 0xd709);
18623         MP_WritePhyUshort(sc, 0x14, 0x5f9d);
18624         MP_WritePhyUshort(sc, 0x14, 0x408b);
18625         MP_WritePhyUshort(sc, 0x14, 0xd71e);
18626         MP_WritePhyUshort(sc, 0x14, 0x6042);
18627         MP_WritePhyUshort(sc, 0x14, 0xb401);
18628         MP_WritePhyUshort(sc, 0x14, 0x175b);
18629         MP_WritePhyUshort(sc, 0x14, 0xd708);
18630         MP_WritePhyUshort(sc, 0x14, 0x6073);
18631         MP_WritePhyUshort(sc, 0x14, 0x5fbc);
18632         MP_WritePhyUshort(sc, 0x14, 0x2c4d);
18633         MP_WritePhyUshort(sc, 0x14, 0x26ed);
18634         MP_WritePhyUshort(sc, 0x14, 0xb280);
18635         MP_WritePhyUshort(sc, 0x14, 0xa841);
18636         MP_WritePhyUshort(sc, 0x14, 0x9420);
18637         MP_WritePhyUshort(sc, 0x14, 0x8710);
18638         MP_WritePhyUshort(sc, 0x14, 0xd709);
18639         MP_WritePhyUshort(sc, 0x14, 0x42ec);
18640         MP_WritePhyUshort(sc, 0x14, 0x606d);
18641         MP_WritePhyUshort(sc, 0x14, 0xd207);
18642         MP_WritePhyUshort(sc, 0x14, 0x2c57);
18643         MP_WritePhyUshort(sc, 0x14, 0xd203);
18644         MP_WritePhyUshort(sc, 0x14, 0x33ff);
18645         MP_WritePhyUshort(sc, 0x14, 0x563b);
18646         MP_WritePhyUshort(sc, 0x14, 0x3275);
18647         MP_WritePhyUshort(sc, 0x14, 0x7c5e);
18648         MP_WritePhyUshort(sc, 0x14, 0xb240);
18649         MP_WritePhyUshort(sc, 0x14, 0xb402);
18650         MP_WritePhyUshort(sc, 0x14, 0x263b);
18651         MP_WritePhyUshort(sc, 0x14, 0x6096);
18652         MP_WritePhyUshort(sc, 0x14, 0xb240);
18653         MP_WritePhyUshort(sc, 0x14, 0xb406);
18654         MP_WritePhyUshort(sc, 0x14, 0x263b);
18655         MP_WritePhyUshort(sc, 0x14, 0x31d7);
18656         MP_WritePhyUshort(sc, 0x14, 0x7c67);
18657         MP_WritePhyUshort(sc, 0x14, 0xb240);
18658         MP_WritePhyUshort(sc, 0x14, 0xb40e);
18659         MP_WritePhyUshort(sc, 0x14, 0x263b);
18660         MP_WritePhyUshort(sc, 0x14, 0xb410);
18661         MP_WritePhyUshort(sc, 0x14, 0x8802);
18662         MP_WritePhyUshort(sc, 0x14, 0xb240);
18663         MP_WritePhyUshort(sc, 0x14, 0x940e);
18664         MP_WritePhyUshort(sc, 0x14, 0x263b);
18665         MP_WritePhyUshort(sc, 0x14, 0xba04);
18666         MP_WritePhyUshort(sc, 0x14, 0x1cd6);
18667         MP_WritePhyUshort(sc, 0x14, 0xa902);
18668         MP_WritePhyUshort(sc, 0x14, 0xd711);
18669         MP_WritePhyUshort(sc, 0x14, 0x4045);
18670         MP_WritePhyUshort(sc, 0x14, 0xa980);
18671         MP_WritePhyUshort(sc, 0x14, 0x3003);
18672         MP_WritePhyUshort(sc, 0x14, 0x59b1);
18673         MP_WritePhyUshort(sc, 0x14, 0xa540);
18674         MP_WritePhyUshort(sc, 0x14, 0xa601);
18675         MP_WritePhyUshort(sc, 0x14, 0xd710);
18676         MP_WritePhyUshort(sc, 0x14, 0x4043);
18677         MP_WritePhyUshort(sc, 0x14, 0xa910);
18678         MP_WritePhyUshort(sc, 0x14, 0xd711);
18679         MP_WritePhyUshort(sc, 0x14, 0x60a0);
18680         MP_WritePhyUshort(sc, 0x14, 0xca33);
18681         MP_WritePhyUshort(sc, 0x14, 0xcb33);
18682         MP_WritePhyUshort(sc, 0x14, 0xa941);
18683         MP_WritePhyUshort(sc, 0x14, 0x2c82);
18684         MP_WritePhyUshort(sc, 0x14, 0xcaff);
18685         MP_WritePhyUshort(sc, 0x14, 0xcbff);
18686         MP_WritePhyUshort(sc, 0x14, 0xa921);
18687         MP_WritePhyUshort(sc, 0x14, 0xce02);
18688         MP_WritePhyUshort(sc, 0x14, 0xe070);
18689         MP_WritePhyUshort(sc, 0x14, 0x0f10);
18690         MP_WritePhyUshort(sc, 0x14, 0xaf01);
18691         MP_WritePhyUshort(sc, 0x14, 0x8f01);
18692         MP_WritePhyUshort(sc, 0x14, 0x1766);
18693         MP_WritePhyUshort(sc, 0x14, 0x8e02);
18694         MP_WritePhyUshort(sc, 0x14, 0x1787);
18695         MP_WritePhyUshort(sc, 0x14, 0xd710);
18696         MP_WritePhyUshort(sc, 0x14, 0x609c);
18697         MP_WritePhyUshort(sc, 0x14, 0xd71e);
18698         MP_WritePhyUshort(sc, 0x14, 0x7fa4);
18699         MP_WritePhyUshort(sc, 0x14, 0x2cd4);
18700         MP_WritePhyUshort(sc, 0x14, 0x1ce9);
18701         MP_WritePhyUshort(sc, 0x14, 0xce04);
18702         MP_WritePhyUshort(sc, 0x14, 0xe070);
18703         MP_WritePhyUshort(sc, 0x14, 0x0f20);
18704         MP_WritePhyUshort(sc, 0x14, 0xaf01);
18705         MP_WritePhyUshort(sc, 0x14, 0x8f01);
18706         MP_WritePhyUshort(sc, 0x14, 0x1766);
18707         MP_WritePhyUshort(sc, 0x14, 0x8e04);
18708         MP_WritePhyUshort(sc, 0x14, 0x6044);
18709         MP_WritePhyUshort(sc, 0x14, 0x2cd4);
18710         MP_WritePhyUshort(sc, 0x14, 0xa520);
18711         MP_WritePhyUshort(sc, 0x14, 0xd710);
18712         MP_WritePhyUshort(sc, 0x14, 0x4043);
18713         MP_WritePhyUshort(sc, 0x14, 0x2cc1);
18714         MP_WritePhyUshort(sc, 0x14, 0xe00f);
18715         MP_WritePhyUshort(sc, 0x14, 0x0501);
18716         MP_WritePhyUshort(sc, 0x14, 0x1cef);
18717         MP_WritePhyUshort(sc, 0x14, 0xb801);
18718         MP_WritePhyUshort(sc, 0x14, 0xd71e);
18719         MP_WritePhyUshort(sc, 0x14, 0x4060);
18720         MP_WritePhyUshort(sc, 0x14, 0x7fc4);
18721         MP_WritePhyUshort(sc, 0x14, 0x2cd4);
18722         MP_WritePhyUshort(sc, 0x14, 0x1cf5);
18723         MP_WritePhyUshort(sc, 0x14, 0xe00f);
18724         MP_WritePhyUshort(sc, 0x14, 0x0502);
18725         MP_WritePhyUshort(sc, 0x14, 0x1cef);
18726         MP_WritePhyUshort(sc, 0x14, 0xb802);
18727         MP_WritePhyUshort(sc, 0x14, 0xd71e);
18728         MP_WritePhyUshort(sc, 0x14, 0x4061);
18729         MP_WritePhyUshort(sc, 0x14, 0x7fc4);
18730         MP_WritePhyUshort(sc, 0x14, 0x2cd4);
18731         MP_WritePhyUshort(sc, 0x14, 0x1cf5);
18732         MP_WritePhyUshort(sc, 0x14, 0xe00f);
18733         MP_WritePhyUshort(sc, 0x14, 0x0504);
18734         MP_WritePhyUshort(sc, 0x14, 0xd710);
18735         MP_WritePhyUshort(sc, 0x14, 0x6099);
18736         MP_WritePhyUshort(sc, 0x14, 0xd71e);
18737         MP_WritePhyUshort(sc, 0x14, 0x7fa4);
18738         MP_WritePhyUshort(sc, 0x14, 0x2cd4);
18739         MP_WritePhyUshort(sc, 0x14, 0xc17f);
18740         MP_WritePhyUshort(sc, 0x14, 0xc200);
18741         MP_WritePhyUshort(sc, 0x14, 0xc43f);
18742         MP_WritePhyUshort(sc, 0x14, 0xcc03);
18743         MP_WritePhyUshort(sc, 0x14, 0xa701);
18744         MP_WritePhyUshort(sc, 0x14, 0xa510);
18745         MP_WritePhyUshort(sc, 0x14, 0xd710);
18746         MP_WritePhyUshort(sc, 0x14, 0x4018);
18747         MP_WritePhyUshort(sc, 0x14, 0x9910);
18748         MP_WritePhyUshort(sc, 0x14, 0x8510);
18749         MP_WritePhyUshort(sc, 0x14, 0x2860);
18750         MP_WritePhyUshort(sc, 0x14, 0xe00f);
18751         MP_WritePhyUshort(sc, 0x14, 0x0504);
18752         MP_WritePhyUshort(sc, 0x14, 0xd710);
18753         MP_WritePhyUshort(sc, 0x14, 0x6099);
18754         MP_WritePhyUshort(sc, 0x14, 0xd71e);
18755         MP_WritePhyUshort(sc, 0x14, 0x7fa4);
18756         MP_WritePhyUshort(sc, 0x14, 0x2cd4);
18757         MP_WritePhyUshort(sc, 0x14, 0xa608);
18758         MP_WritePhyUshort(sc, 0x14, 0xc17d);
18759         MP_WritePhyUshort(sc, 0x14, 0xc200);
18760         MP_WritePhyUshort(sc, 0x14, 0xc43f);
18761         MP_WritePhyUshort(sc, 0x14, 0xcc03);
18762         MP_WritePhyUshort(sc, 0x14, 0xa701);
18763         MP_WritePhyUshort(sc, 0x14, 0xa510);
18764         MP_WritePhyUshort(sc, 0x14, 0xd710);
18765         MP_WritePhyUshort(sc, 0x14, 0x4018);
18766         MP_WritePhyUshort(sc, 0x14, 0x9910);
18767         MP_WritePhyUshort(sc, 0x14, 0x8510);
18768         MP_WritePhyUshort(sc, 0x14, 0x2926);
18769         MP_WritePhyUshort(sc, 0x14, 0x1792);
18770         MP_WritePhyUshort(sc, 0x14, 0x27db);
18771         MP_WritePhyUshort(sc, 0x14, 0xc000);
18772         MP_WritePhyUshort(sc, 0x14, 0xc100);
18773         MP_WritePhyUshort(sc, 0x14, 0xc200);
18774         MP_WritePhyUshort(sc, 0x14, 0xc300);
18775         MP_WritePhyUshort(sc, 0x14, 0xc400);
18776         MP_WritePhyUshort(sc, 0x14, 0xc500);
18777         MP_WritePhyUshort(sc, 0x14, 0xc600);
18778         MP_WritePhyUshort(sc, 0x14, 0xc7c1);
18779         MP_WritePhyUshort(sc, 0x14, 0xc800);
18780         MP_WritePhyUshort(sc, 0x14, 0xcc00);
18781         MP_WritePhyUshort(sc, 0x14, 0x0800);
18782         MP_WritePhyUshort(sc, 0x14, 0xca0f);
18783         MP_WritePhyUshort(sc, 0x14, 0xcbff);
18784         MP_WritePhyUshort(sc, 0x14, 0xa901);
18785         MP_WritePhyUshort(sc, 0x14, 0x8902);
18786         MP_WritePhyUshort(sc, 0x14, 0xc900);
18787         MP_WritePhyUshort(sc, 0x14, 0xca00);
18788         MP_WritePhyUshort(sc, 0x14, 0xcb00);
18789         MP_WritePhyUshort(sc, 0x14, 0x0800);
18790         MP_WritePhyUshort(sc, 0x14, 0xb804);
18791         MP_WritePhyUshort(sc, 0x14, 0x0800);
18792         MP_WritePhyUshort(sc, 0x14, 0xd71e);
18793         MP_WritePhyUshort(sc, 0x14, 0x6044);
18794         MP_WritePhyUshort(sc, 0x14, 0x9804);
18795         MP_WritePhyUshort(sc, 0x14, 0x0800);
18796         MP_WritePhyUshort(sc, 0x14, 0xd710);
18797         MP_WritePhyUshort(sc, 0x14, 0x6099);
18798         MP_WritePhyUshort(sc, 0x14, 0xd71e);
18799         MP_WritePhyUshort(sc, 0x14, 0x7fa4);
18800         MP_WritePhyUshort(sc, 0x14, 0x2cd4);
18801         MP_WritePhyUshort(sc, 0x14, 0x0800);
18802         MP_WritePhyUshort(sc, 0x14, 0xa510);
18803         MP_WritePhyUshort(sc, 0x14, 0xd710);
18804         MP_WritePhyUshort(sc, 0x14, 0x6098);
18805         MP_WritePhyUshort(sc, 0x14, 0xd71e);
18806         MP_WritePhyUshort(sc, 0x14, 0x7fa4);
18807         MP_WritePhyUshort(sc, 0x14, 0x2cd4);
18808         MP_WritePhyUshort(sc, 0x14, 0x8510);
18809         MP_WritePhyUshort(sc, 0x14, 0x0800);
18810         MP_WritePhyUshort(sc, 0x14, 0xd711);
18811         MP_WritePhyUshort(sc, 0x14, 0x3003);
18812         MP_WritePhyUshort(sc, 0x14, 0x1d01);
18813         MP_WritePhyUshort(sc, 0x14, 0x2d0b);
18814         MP_WritePhyUshort(sc, 0x14, 0xd710);
18815         MP_WritePhyUshort(sc, 0x14, 0x60be);
18816         MP_WritePhyUshort(sc, 0x14, 0xe060);
18817         MP_WritePhyUshort(sc, 0x14, 0x0920);
18818         MP_WritePhyUshort(sc, 0x14, 0x1cd6);
18819         MP_WritePhyUshort(sc, 0x14, 0x2c89);
18820         MP_WritePhyUshort(sc, 0x14, 0xd71e);
18821         MP_WritePhyUshort(sc, 0x14, 0x3063);
18822         MP_WritePhyUshort(sc, 0x14, 0x1948);
18823         MP_WritePhyUshort(sc, 0x14, 0x288a);
18824         MP_WritePhyUshort(sc, 0x14, 0x1cd6);
18825         MP_WritePhyUshort(sc, 0x14, 0x29bd);
18826         MP_WritePhyUshort(sc, 0x14, 0xa802);
18827         MP_WritePhyUshort(sc, 0x14, 0xa303);
18828         MP_WritePhyUshort(sc, 0x14, 0x843f);
18829         MP_WritePhyUshort(sc, 0x14, 0x81ff);
18830         MP_WritePhyUshort(sc, 0x14, 0x8208);
18831         MP_WritePhyUshort(sc, 0x14, 0xa201);
18832         MP_WritePhyUshort(sc, 0x14, 0xc001);
18833         MP_WritePhyUshort(sc, 0x14, 0xd710);
18834         MP_WritePhyUshort(sc, 0x14, 0x30a0);
18835         MP_WritePhyUshort(sc, 0x14, 0x0d1c);
18836         MP_WritePhyUshort(sc, 0x14, 0x30a0);
18837         MP_WritePhyUshort(sc, 0x14, 0x3d13);
18838         MP_WritePhyUshort(sc, 0x14, 0xd71e);
18839         MP_WritePhyUshort(sc, 0x14, 0x7f4c);
18840         MP_WritePhyUshort(sc, 0x14, 0x2ab6);
18841         MP_WritePhyUshort(sc, 0x14, 0xe003);
18842         MP_WritePhyUshort(sc, 0x14, 0x0202);
18843         MP_WritePhyUshort(sc, 0x14, 0xd710);
18844         MP_WritePhyUshort(sc, 0x14, 0x6090);
18845         MP_WritePhyUshort(sc, 0x14, 0xd71e);
18846         MP_WritePhyUshort(sc, 0x14, 0x7fac);
18847         MP_WritePhyUshort(sc, 0x14, 0x2ab6);
18848         MP_WritePhyUshort(sc, 0x14, 0xa20c);
18849         MP_WritePhyUshort(sc, 0x14, 0xd710);
18850         MP_WritePhyUshort(sc, 0x14, 0x6091);
18851         MP_WritePhyUshort(sc, 0x14, 0xd71e);
18852         MP_WritePhyUshort(sc, 0x14, 0x7fac);
18853         MP_WritePhyUshort(sc, 0x14, 0x2ab6);
18854         MP_WritePhyUshort(sc, 0x14, 0x820e);
18855         MP_WritePhyUshort(sc, 0x14, 0xa3e0);
18856         MP_WritePhyUshort(sc, 0x14, 0xa520);
18857         MP_WritePhyUshort(sc, 0x14, 0xd710);
18858         MP_WritePhyUshort(sc, 0x14, 0x609d);
18859         MP_WritePhyUshort(sc, 0x14, 0xd71e);
18860         MP_WritePhyUshort(sc, 0x14, 0x7fac);
18861         MP_WritePhyUshort(sc, 0x14, 0x2ab6);
18862         MP_WritePhyUshort(sc, 0x14, 0x8520);
18863         MP_WritePhyUshort(sc, 0x14, 0x6703);
18864         MP_WritePhyUshort(sc, 0x14, 0x2d34);
18865         MP_WritePhyUshort(sc, 0x14, 0xa13e);
18866         MP_WritePhyUshort(sc, 0x14, 0xc001);
18867         MP_WritePhyUshort(sc, 0x14, 0xd710);
18868         MP_WritePhyUshort(sc, 0x14, 0x4000);
18869         MP_WritePhyUshort(sc, 0x14, 0x6046);
18870         MP_WritePhyUshort(sc, 0x14, 0x2d0d);
18871         MP_WritePhyUshort(sc, 0x14, 0xa43f);
18872         MP_WritePhyUshort(sc, 0x14, 0xa101);
18873         MP_WritePhyUshort(sc, 0x14, 0xc020);
18874         MP_WritePhyUshort(sc, 0x14, 0xd710);
18875         MP_WritePhyUshort(sc, 0x14, 0x3121);
18876         MP_WritePhyUshort(sc, 0x14, 0x0d45);
18877         MP_WritePhyUshort(sc, 0x14, 0x30c0);
18878         MP_WritePhyUshort(sc, 0x14, 0x3d0d);
18879         MP_WritePhyUshort(sc, 0x14, 0xd71e);
18880         MP_WritePhyUshort(sc, 0x14, 0x7f4c);
18881         MP_WritePhyUshort(sc, 0x14, 0x2ab6);
18882         MP_WritePhyUshort(sc, 0x14, 0xa540);
18883         MP_WritePhyUshort(sc, 0x14, 0xc001);
18884         MP_WritePhyUshort(sc, 0x14, 0xd710);
18885         MP_WritePhyUshort(sc, 0x14, 0x4001);
18886         MP_WritePhyUshort(sc, 0x14, 0xe00f);
18887         MP_WritePhyUshort(sc, 0x14, 0x0501);
18888         MP_WritePhyUshort(sc, 0x14, 0x1dac);
18889         MP_WritePhyUshort(sc, 0x14, 0xc1c4);
18890         MP_WritePhyUshort(sc, 0x14, 0xa268);
18891         MP_WritePhyUshort(sc, 0x14, 0xa303);
18892         MP_WritePhyUshort(sc, 0x14, 0x8420);
18893         MP_WritePhyUshort(sc, 0x14, 0xe00f);
18894         MP_WritePhyUshort(sc, 0x14, 0x0502);
18895         MP_WritePhyUshort(sc, 0x14, 0x1dac);
18896         MP_WritePhyUshort(sc, 0x14, 0xc002);
18897         MP_WritePhyUshort(sc, 0x14, 0xd710);
18898         MP_WritePhyUshort(sc, 0x14, 0x4000);
18899         MP_WritePhyUshort(sc, 0x14, 0x8208);
18900         MP_WritePhyUshort(sc, 0x14, 0x8410);
18901         MP_WritePhyUshort(sc, 0x14, 0xa121);
18902         MP_WritePhyUshort(sc, 0x14, 0xc002);
18903         MP_WritePhyUshort(sc, 0x14, 0xd710);
18904         MP_WritePhyUshort(sc, 0x14, 0x4000);
18905         MP_WritePhyUshort(sc, 0x14, 0x8120);
18906         MP_WritePhyUshort(sc, 0x14, 0x8180);
18907         MP_WritePhyUshort(sc, 0x14, 0x1d97);
18908         MP_WritePhyUshort(sc, 0x14, 0xa180);
18909         MP_WritePhyUshort(sc, 0x14, 0xa13a);
18910         MP_WritePhyUshort(sc, 0x14, 0x8240);
18911         MP_WritePhyUshort(sc, 0x14, 0xa430);
18912         MP_WritePhyUshort(sc, 0x14, 0xc010);
18913         MP_WritePhyUshort(sc, 0x14, 0xd710);
18914         MP_WritePhyUshort(sc, 0x14, 0x30e1);
18915         MP_WritePhyUshort(sc, 0x14, 0x0abc);
18916         MP_WritePhyUshort(sc, 0x14, 0xd71e);
18917         MP_WritePhyUshort(sc, 0x14, 0x7f8c);
18918         MP_WritePhyUshort(sc, 0x14, 0x2ab6);
18919         MP_WritePhyUshort(sc, 0x14, 0xa480);
18920         MP_WritePhyUshort(sc, 0x14, 0xa230);
18921         MP_WritePhyUshort(sc, 0x14, 0xa303);
18922         MP_WritePhyUshort(sc, 0x14, 0xc001);
18923         MP_WritePhyUshort(sc, 0x14, 0xd70c);
18924         MP_WritePhyUshort(sc, 0x14, 0x4124);
18925         MP_WritePhyUshort(sc, 0x14, 0xd710);
18926         MP_WritePhyUshort(sc, 0x14, 0x6120);
18927         MP_WritePhyUshort(sc, 0x14, 0xd711);
18928         MP_WritePhyUshort(sc, 0x14, 0x3128);
18929         MP_WritePhyUshort(sc, 0x14, 0x3d76);
18930         MP_WritePhyUshort(sc, 0x14, 0x2d70);
18931         MP_WritePhyUshort(sc, 0x14, 0xa801);
18932         MP_WritePhyUshort(sc, 0x14, 0x2d6c);
18933         MP_WritePhyUshort(sc, 0x14, 0xd710);
18934         MP_WritePhyUshort(sc, 0x14, 0x4000);
18935         MP_WritePhyUshort(sc, 0x14, 0xe018);
18936         MP_WritePhyUshort(sc, 0x14, 0x0208);
18937         MP_WritePhyUshort(sc, 0x14, 0xa1f8);
18938         MP_WritePhyUshort(sc, 0x14, 0x8480);
18939         MP_WritePhyUshort(sc, 0x14, 0xc004);
18940         MP_WritePhyUshort(sc, 0x14, 0xd710);
18941         MP_WritePhyUshort(sc, 0x14, 0x4000);
18942         MP_WritePhyUshort(sc, 0x14, 0x6046);
18943         MP_WritePhyUshort(sc, 0x14, 0x2d0d);
18944         MP_WritePhyUshort(sc, 0x14, 0xa43f);
18945         MP_WritePhyUshort(sc, 0x14, 0xa105);
18946         MP_WritePhyUshort(sc, 0x14, 0x8228);
18947         MP_WritePhyUshort(sc, 0x14, 0xc004);
18948         MP_WritePhyUshort(sc, 0x14, 0xd710);
18949         MP_WritePhyUshort(sc, 0x14, 0x4000);
18950         MP_WritePhyUshort(sc, 0x14, 0x81bc);
18951         MP_WritePhyUshort(sc, 0x14, 0xa220);
18952         MP_WritePhyUshort(sc, 0x14, 0x1d97);
18953         MP_WritePhyUshort(sc, 0x14, 0x8220);
18954         MP_WritePhyUshort(sc, 0x14, 0xa1bc);
18955         MP_WritePhyUshort(sc, 0x14, 0xc040);
18956         MP_WritePhyUshort(sc, 0x14, 0xd710);
18957         MP_WritePhyUshort(sc, 0x14, 0x30e1);
18958         MP_WritePhyUshort(sc, 0x14, 0x0abc);
18959         MP_WritePhyUshort(sc, 0x14, 0x30e1);
18960         MP_WritePhyUshort(sc, 0x14, 0x3d0d);
18961         MP_WritePhyUshort(sc, 0x14, 0xd71e);
18962         MP_WritePhyUshort(sc, 0x14, 0x7f4c);
18963         MP_WritePhyUshort(sc, 0x14, 0x2ab6);
18964         MP_WritePhyUshort(sc, 0x14, 0xa802);
18965         MP_WritePhyUshort(sc, 0x14, 0xd70c);
18966         MP_WritePhyUshort(sc, 0x14, 0x4244);
18967         MP_WritePhyUshort(sc, 0x14, 0xa301);
18968         MP_WritePhyUshort(sc, 0x14, 0xc004);
18969         MP_WritePhyUshort(sc, 0x14, 0xd711);
18970         MP_WritePhyUshort(sc, 0x14, 0x3128);
18971         MP_WritePhyUshort(sc, 0x14, 0x3da5);
18972         MP_WritePhyUshort(sc, 0x14, 0xd710);
18973         MP_WritePhyUshort(sc, 0x14, 0x5f80);
18974         MP_WritePhyUshort(sc, 0x14, 0xd711);
18975         MP_WritePhyUshort(sc, 0x14, 0x3109);
18976         MP_WritePhyUshort(sc, 0x14, 0x3da7);
18977         MP_WritePhyUshort(sc, 0x14, 0x2dab);
18978         MP_WritePhyUshort(sc, 0x14, 0xa801);
18979         MP_WritePhyUshort(sc, 0x14, 0x2d9a);
18980         MP_WritePhyUshort(sc, 0x14, 0xa802);
18981         MP_WritePhyUshort(sc, 0x14, 0xc004);
18982         MP_WritePhyUshort(sc, 0x14, 0xd710);
18983         MP_WritePhyUshort(sc, 0x14, 0x4000);
18984         MP_WritePhyUshort(sc, 0x14, 0x0800);
18985         MP_WritePhyUshort(sc, 0x14, 0xa510);
18986         MP_WritePhyUshort(sc, 0x14, 0xd710);
18987         MP_WritePhyUshort(sc, 0x14, 0x609a);
18988         MP_WritePhyUshort(sc, 0x14, 0xd71e);
18989         MP_WritePhyUshort(sc, 0x14, 0x7fac);
18990         MP_WritePhyUshort(sc, 0x14, 0x2ab6);
18991         MP_WritePhyUshort(sc, 0x14, 0x8510);
18992         MP_WritePhyUshort(sc, 0x14, 0x0800);
18993         MP_WritePhyUshort(sc, 0x13, 0xA01A);
18994         MP_WritePhyUshort(sc, 0x14, 0x0000);
18995         MP_WritePhyUshort(sc, 0x13, 0xA006);
18996         MP_WritePhyUshort(sc, 0x14, 0x0ad6);
18997         MP_WritePhyUshort(sc, 0x13, 0xA004);
18998         MP_WritePhyUshort(sc, 0x14, 0x07f5);
18999         MP_WritePhyUshort(sc, 0x13, 0xA002);
19000         MP_WritePhyUshort(sc, 0x14, 0x06a9);
19001         MP_WritePhyUshort(sc, 0x13, 0xA000);
19002         MP_WritePhyUshort(sc, 0x14, 0xf069);
19003         MP_WritePhyUshort(sc, 0x13, 0xB820);
19004         MP_WritePhyUshort(sc, 0x14, 0x0210);
19005
19006         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19007         MP_WritePhyUshort(sc, 0x13, 0x83a0);
19008         MP_WritePhyUshort(sc, 0x14, 0xaf83);
19009         MP_WritePhyUshort(sc, 0x14, 0xacaf);
19010         MP_WritePhyUshort(sc, 0x14, 0x83b8);
19011         MP_WritePhyUshort(sc, 0x14, 0xaf83);
19012         MP_WritePhyUshort(sc, 0x14, 0xcdaf);
19013         MP_WritePhyUshort(sc, 0x14, 0x83d3);
19014         MP_WritePhyUshort(sc, 0x14, 0x0204);
19015         MP_WritePhyUshort(sc, 0x14, 0x9a02);
19016         MP_WritePhyUshort(sc, 0x14, 0x09a9);
19017         MP_WritePhyUshort(sc, 0x14, 0x0284);
19018         MP_WritePhyUshort(sc, 0x14, 0x61af);
19019         MP_WritePhyUshort(sc, 0x14, 0x02fc);
19020         MP_WritePhyUshort(sc, 0x14, 0xad20);
19021         MP_WritePhyUshort(sc, 0x14, 0x0302);
19022         MP_WritePhyUshort(sc, 0x14, 0x867c);
19023         MP_WritePhyUshort(sc, 0x14, 0xad21);
19024         MP_WritePhyUshort(sc, 0x14, 0x0302);
19025         MP_WritePhyUshort(sc, 0x14, 0x85c9);
19026         MP_WritePhyUshort(sc, 0x14, 0xad22);
19027         MP_WritePhyUshort(sc, 0x14, 0x0302);
19028         MP_WritePhyUshort(sc, 0x14, 0x1bc0);
19029         MP_WritePhyUshort(sc, 0x14, 0xaf17);
19030         MP_WritePhyUshort(sc, 0x14, 0xe302);
19031         MP_WritePhyUshort(sc, 0x14, 0x8703);
19032         MP_WritePhyUshort(sc, 0x14, 0xaf18);
19033         MP_WritePhyUshort(sc, 0x14, 0x6201);
19034         MP_WritePhyUshort(sc, 0x14, 0x06e0);
19035         MP_WritePhyUshort(sc, 0x14, 0x8148);
19036         MP_WritePhyUshort(sc, 0x14, 0xaf3c);
19037         MP_WritePhyUshort(sc, 0x14, 0x69f8);
19038         MP_WritePhyUshort(sc, 0x14, 0xf9fa);
19039         MP_WritePhyUshort(sc, 0x14, 0xef69);
19040         MP_WritePhyUshort(sc, 0x14, 0xee80);
19041         MP_WritePhyUshort(sc, 0x14, 0x10f7);
19042         MP_WritePhyUshort(sc, 0x14, 0xee80);
19043         MP_WritePhyUshort(sc, 0x14, 0x131f);
19044         MP_WritePhyUshort(sc, 0x14, 0xd104);
19045         MP_WritePhyUshort(sc, 0x14, 0xbf87);
19046         MP_WritePhyUshort(sc, 0x14, 0xf302);
19047         MP_WritePhyUshort(sc, 0x14, 0x4259);
19048         MP_WritePhyUshort(sc, 0x14, 0x0287);
19049         MP_WritePhyUshort(sc, 0x14, 0x88bf);
19050         MP_WritePhyUshort(sc, 0x14, 0x87cf);
19051         MP_WritePhyUshort(sc, 0x14, 0xd7b8);
19052         MP_WritePhyUshort(sc, 0x14, 0x22d0);
19053         MP_WritePhyUshort(sc, 0x14, 0x0c02);
19054         MP_WritePhyUshort(sc, 0x14, 0x4252);
19055         MP_WritePhyUshort(sc, 0x14, 0xee80);
19056         MP_WritePhyUshort(sc, 0x14, 0xcda0);
19057         MP_WritePhyUshort(sc, 0x14, 0xee80);
19058         MP_WritePhyUshort(sc, 0x14, 0xce8b);
19059         MP_WritePhyUshort(sc, 0x14, 0xee80);
19060         MP_WritePhyUshort(sc, 0x14, 0xd1f5);
19061         MP_WritePhyUshort(sc, 0x14, 0xee80);
19062         MP_WritePhyUshort(sc, 0x14, 0xd2a9);
19063         MP_WritePhyUshort(sc, 0x14, 0xee80);
19064         MP_WritePhyUshort(sc, 0x14, 0xd30a);
19065         MP_WritePhyUshort(sc, 0x14, 0xee80);
19066         MP_WritePhyUshort(sc, 0x14, 0xf010);
19067         MP_WritePhyUshort(sc, 0x14, 0xee80);
19068         MP_WritePhyUshort(sc, 0x14, 0xf38f);
19069         MP_WritePhyUshort(sc, 0x14, 0xee81);
19070         MP_WritePhyUshort(sc, 0x14, 0x011e);
19071         MP_WritePhyUshort(sc, 0x14, 0xee81);
19072         MP_WritePhyUshort(sc, 0x14, 0x0b4a);
19073         MP_WritePhyUshort(sc, 0x14, 0xee81);
19074         MP_WritePhyUshort(sc, 0x14, 0x0c7c);
19075         MP_WritePhyUshort(sc, 0x14, 0xee81);
19076         MP_WritePhyUshort(sc, 0x14, 0x127f);
19077         MP_WritePhyUshort(sc, 0x14, 0xd100);
19078         MP_WritePhyUshort(sc, 0x14, 0x0210);
19079         MP_WritePhyUshort(sc, 0x14, 0xb5ee);
19080         MP_WritePhyUshort(sc, 0x14, 0x8088);
19081         MP_WritePhyUshort(sc, 0x14, 0xa4ee);
19082         MP_WritePhyUshort(sc, 0x14, 0x8089);
19083         MP_WritePhyUshort(sc, 0x14, 0x44ee);
19084         MP_WritePhyUshort(sc, 0x14, 0x809a);
19085         MP_WritePhyUshort(sc, 0x14, 0xa4ee);
19086         MP_WritePhyUshort(sc, 0x14, 0x809b);
19087         MP_WritePhyUshort(sc, 0x14, 0x44ee);
19088         MP_WritePhyUshort(sc, 0x14, 0x809c);
19089         MP_WritePhyUshort(sc, 0x14, 0xa7ee);
19090         MP_WritePhyUshort(sc, 0x14, 0x80a5);
19091         MP_WritePhyUshort(sc, 0x14, 0xa7d2);
19092         MP_WritePhyUshort(sc, 0x14, 0x0002);
19093         MP_WritePhyUshort(sc, 0x14, 0x0e66);
19094         MP_WritePhyUshort(sc, 0x14, 0x0285);
19095         MP_WritePhyUshort(sc, 0x14, 0xc0ee);
19096         MP_WritePhyUshort(sc, 0x14, 0x87fc);
19097         MP_WritePhyUshort(sc, 0x14, 0x00e0);
19098         MP_WritePhyUshort(sc, 0x14, 0x8245);
19099         MP_WritePhyUshort(sc, 0x14, 0xf622);
19100         MP_WritePhyUshort(sc, 0x14, 0xe482);
19101         MP_WritePhyUshort(sc, 0x14, 0x45ef);
19102         MP_WritePhyUshort(sc, 0x14, 0x96fe);
19103         MP_WritePhyUshort(sc, 0x14, 0xfdfc);
19104         MP_WritePhyUshort(sc, 0x14, 0x0402);
19105         MP_WritePhyUshort(sc, 0x14, 0x847a);
19106         MP_WritePhyUshort(sc, 0x14, 0x0284);
19107         MP_WritePhyUshort(sc, 0x14, 0xb302);
19108         MP_WritePhyUshort(sc, 0x14, 0x0cab);
19109         MP_WritePhyUshort(sc, 0x14, 0x020c);
19110         MP_WritePhyUshort(sc, 0x14, 0xc402);
19111         MP_WritePhyUshort(sc, 0x14, 0x0cef);
19112         MP_WritePhyUshort(sc, 0x14, 0x020d);
19113         MP_WritePhyUshort(sc, 0x14, 0x0802);
19114         MP_WritePhyUshort(sc, 0x14, 0x0d33);
19115         MP_WritePhyUshort(sc, 0x14, 0x020c);
19116         MP_WritePhyUshort(sc, 0x14, 0x3d04);
19117         MP_WritePhyUshort(sc, 0x14, 0xf8fa);
19118         MP_WritePhyUshort(sc, 0x14, 0xef69);
19119         MP_WritePhyUshort(sc, 0x14, 0xe182);
19120         MP_WritePhyUshort(sc, 0x14, 0x2fac);
19121         MP_WritePhyUshort(sc, 0x14, 0x291a);
19122         MP_WritePhyUshort(sc, 0x14, 0xe082);
19123         MP_WritePhyUshort(sc, 0x14, 0x24ac);
19124         MP_WritePhyUshort(sc, 0x14, 0x2102);
19125         MP_WritePhyUshort(sc, 0x14, 0xae22);
19126         MP_WritePhyUshort(sc, 0x14, 0x0210);
19127         MP_WritePhyUshort(sc, 0x14, 0x57f6);
19128         MP_WritePhyUshort(sc, 0x14, 0x21e4);
19129         MP_WritePhyUshort(sc, 0x14, 0x8224);
19130         MP_WritePhyUshort(sc, 0x14, 0xd101);
19131         MP_WritePhyUshort(sc, 0x14, 0xbf44);
19132         MP_WritePhyUshort(sc, 0x14, 0xd202);
19133         MP_WritePhyUshort(sc, 0x14, 0x4259);
19134         MP_WritePhyUshort(sc, 0x14, 0xae10);
19135         MP_WritePhyUshort(sc, 0x14, 0x0212);
19136         MP_WritePhyUshort(sc, 0x14, 0x4cf6);
19137         MP_WritePhyUshort(sc, 0x14, 0x29e5);
19138         MP_WritePhyUshort(sc, 0x14, 0x822f);
19139         MP_WritePhyUshort(sc, 0x14, 0xe082);
19140         MP_WritePhyUshort(sc, 0x14, 0x24f6);
19141         MP_WritePhyUshort(sc, 0x14, 0x21e4);
19142         MP_WritePhyUshort(sc, 0x14, 0x8224);
19143         MP_WritePhyUshort(sc, 0x14, 0xef96);
19144         MP_WritePhyUshort(sc, 0x14, 0xfefc);
19145         MP_WritePhyUshort(sc, 0x14, 0x04f8);
19146         MP_WritePhyUshort(sc, 0x14, 0xe182);
19147         MP_WritePhyUshort(sc, 0x14, 0x2fac);
19148         MP_WritePhyUshort(sc, 0x14, 0x2a18);
19149         MP_WritePhyUshort(sc, 0x14, 0xe082);
19150         MP_WritePhyUshort(sc, 0x14, 0x24ac);
19151         MP_WritePhyUshort(sc, 0x14, 0x2202);
19152         MP_WritePhyUshort(sc, 0x14, 0xae26);
19153         MP_WritePhyUshort(sc, 0x14, 0x0284);
19154         MP_WritePhyUshort(sc, 0x14, 0xf802);
19155         MP_WritePhyUshort(sc, 0x14, 0x8565);
19156         MP_WritePhyUshort(sc, 0x14, 0xd101);
19157         MP_WritePhyUshort(sc, 0x14, 0xbf44);
19158         MP_WritePhyUshort(sc, 0x14, 0xd502);
19159         MP_WritePhyUshort(sc, 0x14, 0x4259);
19160         MP_WritePhyUshort(sc, 0x14, 0xae0e);
19161         MP_WritePhyUshort(sc, 0x14, 0x0284);
19162         MP_WritePhyUshort(sc, 0x14, 0xea02);
19163         MP_WritePhyUshort(sc, 0x14, 0x85a9);
19164         MP_WritePhyUshort(sc, 0x14, 0xe182);
19165         MP_WritePhyUshort(sc, 0x14, 0x2ff6);
19166         MP_WritePhyUshort(sc, 0x14, 0x2ae5);
19167         MP_WritePhyUshort(sc, 0x14, 0x822f);
19168         MP_WritePhyUshort(sc, 0x14, 0xe082);
19169         MP_WritePhyUshort(sc, 0x14, 0x24f6);
19170         MP_WritePhyUshort(sc, 0x14, 0x22e4);
19171         MP_WritePhyUshort(sc, 0x14, 0x8224);
19172         MP_WritePhyUshort(sc, 0x14, 0xfc04);
19173         MP_WritePhyUshort(sc, 0x14, 0xf9e2);
19174         MP_WritePhyUshort(sc, 0x14, 0x8011);
19175         MP_WritePhyUshort(sc, 0x14, 0xad31);
19176         MP_WritePhyUshort(sc, 0x14, 0x05d2);
19177         MP_WritePhyUshort(sc, 0x14, 0x0002);
19178         MP_WritePhyUshort(sc, 0x14, 0x0e66);
19179         MP_WritePhyUshort(sc, 0x14, 0xfd04);
19180         MP_WritePhyUshort(sc, 0x14, 0xf8f9);
19181         MP_WritePhyUshort(sc, 0x14, 0xfaef);
19182         MP_WritePhyUshort(sc, 0x14, 0x69e0);
19183         MP_WritePhyUshort(sc, 0x14, 0x8011);
19184         MP_WritePhyUshort(sc, 0x14, 0xad21);
19185         MP_WritePhyUshort(sc, 0x14, 0x5cbf);
19186         MP_WritePhyUshort(sc, 0x14, 0x43be);
19187         MP_WritePhyUshort(sc, 0x14, 0x0242);
19188         MP_WritePhyUshort(sc, 0x14, 0x97ac);
19189         MP_WritePhyUshort(sc, 0x14, 0x281b);
19190         MP_WritePhyUshort(sc, 0x14, 0xbf43);
19191         MP_WritePhyUshort(sc, 0x14, 0xc102);
19192         MP_WritePhyUshort(sc, 0x14, 0x4297);
19193         MP_WritePhyUshort(sc, 0x14, 0xac28);
19194         MP_WritePhyUshort(sc, 0x14, 0x12bf);
19195         MP_WritePhyUshort(sc, 0x14, 0x43c7);
19196         MP_WritePhyUshort(sc, 0x14, 0x0242);
19197         MP_WritePhyUshort(sc, 0x14, 0x97ac);
19198         MP_WritePhyUshort(sc, 0x14, 0x2804);
19199         MP_WritePhyUshort(sc, 0x14, 0xd300);
19200         MP_WritePhyUshort(sc, 0x14, 0xae07);
19201         MP_WritePhyUshort(sc, 0x14, 0xd306);
19202         MP_WritePhyUshort(sc, 0x14, 0xaf85);
19203         MP_WritePhyUshort(sc, 0x14, 0x56d3);
19204         MP_WritePhyUshort(sc, 0x14, 0x03e0);
19205         MP_WritePhyUshort(sc, 0x14, 0x8011);
19206         MP_WritePhyUshort(sc, 0x14, 0xad26);
19207         MP_WritePhyUshort(sc, 0x14, 0x25bf);
19208         MP_WritePhyUshort(sc, 0x14, 0x4559);
19209         MP_WritePhyUshort(sc, 0x14, 0x0242);
19210         MP_WritePhyUshort(sc, 0x14, 0x97e2);
19211         MP_WritePhyUshort(sc, 0x14, 0x8073);
19212         MP_WritePhyUshort(sc, 0x14, 0x0d21);
19213         MP_WritePhyUshort(sc, 0x14, 0xf637);
19214         MP_WritePhyUshort(sc, 0x14, 0x0d11);
19215         MP_WritePhyUshort(sc, 0x14, 0xf62f);
19216         MP_WritePhyUshort(sc, 0x14, 0x1b21);
19217         MP_WritePhyUshort(sc, 0x14, 0xaa02);
19218         MP_WritePhyUshort(sc, 0x14, 0xae10);
19219         MP_WritePhyUshort(sc, 0x14, 0xe280);
19220         MP_WritePhyUshort(sc, 0x14, 0x740d);
19221         MP_WritePhyUshort(sc, 0x14, 0x21f6);
19222         MP_WritePhyUshort(sc, 0x14, 0x371b);
19223         MP_WritePhyUshort(sc, 0x14, 0x21aa);
19224         MP_WritePhyUshort(sc, 0x14, 0x0313);
19225         MP_WritePhyUshort(sc, 0x14, 0xae02);
19226         MP_WritePhyUshort(sc, 0x14, 0x2b02);
19227         MP_WritePhyUshort(sc, 0x14, 0x020e);
19228         MP_WritePhyUshort(sc, 0x14, 0x5102);
19229         MP_WritePhyUshort(sc, 0x14, 0x0e66);
19230         MP_WritePhyUshort(sc, 0x14, 0x020f);
19231         MP_WritePhyUshort(sc, 0x14, 0xa3ef);
19232         MP_WritePhyUshort(sc, 0x14, 0x96fe);
19233         MP_WritePhyUshort(sc, 0x14, 0xfdfc);
19234         MP_WritePhyUshort(sc, 0x14, 0x04f8);
19235         MP_WritePhyUshort(sc, 0x14, 0xf9fa);
19236         MP_WritePhyUshort(sc, 0x14, 0xef69);
19237         MP_WritePhyUshort(sc, 0x14, 0xe080);
19238         MP_WritePhyUshort(sc, 0x14, 0x12ad);
19239         MP_WritePhyUshort(sc, 0x14, 0x2733);
19240         MP_WritePhyUshort(sc, 0x14, 0xbf43);
19241         MP_WritePhyUshort(sc, 0x14, 0xbe02);
19242         MP_WritePhyUshort(sc, 0x14, 0x4297);
19243         MP_WritePhyUshort(sc, 0x14, 0xac28);
19244         MP_WritePhyUshort(sc, 0x14, 0x09bf);
19245         MP_WritePhyUshort(sc, 0x14, 0x43c1);
19246         MP_WritePhyUshort(sc, 0x14, 0x0242);
19247         MP_WritePhyUshort(sc, 0x14, 0x97ad);
19248         MP_WritePhyUshort(sc, 0x14, 0x2821);
19249         MP_WritePhyUshort(sc, 0x14, 0xbf45);
19250         MP_WritePhyUshort(sc, 0x14, 0x5902);
19251         MP_WritePhyUshort(sc, 0x14, 0x4297);
19252         MP_WritePhyUshort(sc, 0x14, 0xe387);
19253         MP_WritePhyUshort(sc, 0x14, 0xffd2);
19254         MP_WritePhyUshort(sc, 0x14, 0x001b);
19255         MP_WritePhyUshort(sc, 0x14, 0x45ac);
19256         MP_WritePhyUshort(sc, 0x14, 0x2711);
19257         MP_WritePhyUshort(sc, 0x14, 0xe187);
19258         MP_WritePhyUshort(sc, 0x14, 0xfebf);
19259         MP_WritePhyUshort(sc, 0x14, 0x87e4);
19260         MP_WritePhyUshort(sc, 0x14, 0x0242);
19261         MP_WritePhyUshort(sc, 0x14, 0x590d);
19262         MP_WritePhyUshort(sc, 0x14, 0x11bf);
19263         MP_WritePhyUshort(sc, 0x14, 0x87e7);
19264         MP_WritePhyUshort(sc, 0x14, 0x0242);
19265         MP_WritePhyUshort(sc, 0x14, 0x59ef);
19266         MP_WritePhyUshort(sc, 0x14, 0x96fe);
19267         MP_WritePhyUshort(sc, 0x14, 0xfdfc);
19268         MP_WritePhyUshort(sc, 0x14, 0x04f8);
19269         MP_WritePhyUshort(sc, 0x14, 0xfaef);
19270         MP_WritePhyUshort(sc, 0x14, 0x69d1);
19271         MP_WritePhyUshort(sc, 0x14, 0x00bf);
19272         MP_WritePhyUshort(sc, 0x14, 0x87e4);
19273         MP_WritePhyUshort(sc, 0x14, 0x0242);
19274         MP_WritePhyUshort(sc, 0x14, 0x59bf);
19275         MP_WritePhyUshort(sc, 0x14, 0x87e7);
19276         MP_WritePhyUshort(sc, 0x14, 0x0242);
19277         MP_WritePhyUshort(sc, 0x14, 0x59ef);
19278         MP_WritePhyUshort(sc, 0x14, 0x96fe);
19279         MP_WritePhyUshort(sc, 0x14, 0xfc04);
19280         MP_WritePhyUshort(sc, 0x14, 0xee87);
19281         MP_WritePhyUshort(sc, 0x14, 0xff46);
19282         MP_WritePhyUshort(sc, 0x14, 0xee87);
19283         MP_WritePhyUshort(sc, 0x14, 0xfe01);
19284         MP_WritePhyUshort(sc, 0x14, 0x04f8);
19285         MP_WritePhyUshort(sc, 0x14, 0xfaef);
19286         MP_WritePhyUshort(sc, 0x14, 0x69e0);
19287         MP_WritePhyUshort(sc, 0x14, 0x8241);
19288         MP_WritePhyUshort(sc, 0x14, 0xa000);
19289         MP_WritePhyUshort(sc, 0x14, 0x0502);
19290         MP_WritePhyUshort(sc, 0x14, 0x85eb);
19291         MP_WritePhyUshort(sc, 0x14, 0xae0e);
19292         MP_WritePhyUshort(sc, 0x14, 0xa001);
19293         MP_WritePhyUshort(sc, 0x14, 0x0502);
19294         MP_WritePhyUshort(sc, 0x14, 0x1a5a);
19295         MP_WritePhyUshort(sc, 0x14, 0xae06);
19296         MP_WritePhyUshort(sc, 0x14, 0xa002);
19297         MP_WritePhyUshort(sc, 0x14, 0x0302);
19298         MP_WritePhyUshort(sc, 0x14, 0x1ae6);
19299         MP_WritePhyUshort(sc, 0x14, 0xef96);
19300         MP_WritePhyUshort(sc, 0x14, 0xfefc);
19301         MP_WritePhyUshort(sc, 0x14, 0x04f8);
19302         MP_WritePhyUshort(sc, 0x14, 0xf9fa);
19303         MP_WritePhyUshort(sc, 0x14, 0xef69);
19304         MP_WritePhyUshort(sc, 0x14, 0xe082);
19305         MP_WritePhyUshort(sc, 0x14, 0x29f6);
19306         MP_WritePhyUshort(sc, 0x14, 0x21e4);
19307         MP_WritePhyUshort(sc, 0x14, 0x8229);
19308         MP_WritePhyUshort(sc, 0x14, 0xe080);
19309         MP_WritePhyUshort(sc, 0x14, 0x10ac);
19310         MP_WritePhyUshort(sc, 0x14, 0x2202);
19311         MP_WritePhyUshort(sc, 0x14, 0xae76);
19312         MP_WritePhyUshort(sc, 0x14, 0xe082);
19313         MP_WritePhyUshort(sc, 0x14, 0x27f7);
19314         MP_WritePhyUshort(sc, 0x14, 0x21e4);
19315         MP_WritePhyUshort(sc, 0x14, 0x8227);
19316         MP_WritePhyUshort(sc, 0x14, 0xbf43);
19317         MP_WritePhyUshort(sc, 0x14, 0x1302);
19318         MP_WritePhyUshort(sc, 0x14, 0x4297);
19319         MP_WritePhyUshort(sc, 0x14, 0xef21);
19320         MP_WritePhyUshort(sc, 0x14, 0xbf43);
19321         MP_WritePhyUshort(sc, 0x14, 0x1602);
19322         MP_WritePhyUshort(sc, 0x14, 0x4297);
19323         MP_WritePhyUshort(sc, 0x14, 0x0c11);
19324         MP_WritePhyUshort(sc, 0x14, 0x1e21);
19325         MP_WritePhyUshort(sc, 0x14, 0xbf43);
19326         MP_WritePhyUshort(sc, 0x14, 0x1902);
19327         MP_WritePhyUshort(sc, 0x14, 0x4297);
19328         MP_WritePhyUshort(sc, 0x14, 0x0c12);
19329         MP_WritePhyUshort(sc, 0x14, 0x1e21);
19330         MP_WritePhyUshort(sc, 0x14, 0xe682);
19331         MP_WritePhyUshort(sc, 0x14, 0x43a2);
19332         MP_WritePhyUshort(sc, 0x14, 0x000a);
19333         MP_WritePhyUshort(sc, 0x14, 0xe182);
19334         MP_WritePhyUshort(sc, 0x14, 0x27f6);
19335         MP_WritePhyUshort(sc, 0x14, 0x29e5);
19336         MP_WritePhyUshort(sc, 0x14, 0x8227);
19337         MP_WritePhyUshort(sc, 0x14, 0xae42);
19338         MP_WritePhyUshort(sc, 0x14, 0xe082);
19339         MP_WritePhyUshort(sc, 0x14, 0x44f7);
19340         MP_WritePhyUshort(sc, 0x14, 0x21e4);
19341         MP_WritePhyUshort(sc, 0x14, 0x8244);
19342         MP_WritePhyUshort(sc, 0x14, 0x0246);
19343         MP_WritePhyUshort(sc, 0x14, 0xaebf);
19344         MP_WritePhyUshort(sc, 0x14, 0x4325);
19345         MP_WritePhyUshort(sc, 0x14, 0x0242);
19346         MP_WritePhyUshort(sc, 0x14, 0x97ef);
19347         MP_WritePhyUshort(sc, 0x14, 0x21bf);
19348         MP_WritePhyUshort(sc, 0x14, 0x431c);
19349         MP_WritePhyUshort(sc, 0x14, 0x0242);
19350         MP_WritePhyUshort(sc, 0x14, 0x970c);
19351         MP_WritePhyUshort(sc, 0x14, 0x121e);
19352         MP_WritePhyUshort(sc, 0x14, 0x21bf);
19353         MP_WritePhyUshort(sc, 0x14, 0x431f);
19354         MP_WritePhyUshort(sc, 0x14, 0x0242);
19355         MP_WritePhyUshort(sc, 0x14, 0x970c);
19356         MP_WritePhyUshort(sc, 0x14, 0x131e);
19357         MP_WritePhyUshort(sc, 0x14, 0x21bf);
19358         MP_WritePhyUshort(sc, 0x14, 0x4328);
19359         MP_WritePhyUshort(sc, 0x14, 0x0242);
19360         MP_WritePhyUshort(sc, 0x14, 0x970c);
19361         MP_WritePhyUshort(sc, 0x14, 0x141e);
19362         MP_WritePhyUshort(sc, 0x14, 0x21bf);
19363         MP_WritePhyUshort(sc, 0x14, 0x44b1);
19364         MP_WritePhyUshort(sc, 0x14, 0x0242);
19365         MP_WritePhyUshort(sc, 0x14, 0x970c);
19366         MP_WritePhyUshort(sc, 0x14, 0x161e);
19367         MP_WritePhyUshort(sc, 0x14, 0x21e6);
19368         MP_WritePhyUshort(sc, 0x14, 0x8242);
19369         MP_WritePhyUshort(sc, 0x14, 0xee82);
19370         MP_WritePhyUshort(sc, 0x14, 0x4101);
19371         MP_WritePhyUshort(sc, 0x14, 0xef96);
19372         MP_WritePhyUshort(sc, 0x14, 0xfefd);
19373         MP_WritePhyUshort(sc, 0x14, 0xfc04);
19374         MP_WritePhyUshort(sc, 0x14, 0xf8fa);
19375         MP_WritePhyUshort(sc, 0x14, 0xef69);
19376         MP_WritePhyUshort(sc, 0x14, 0xe082);
19377         MP_WritePhyUshort(sc, 0x14, 0x46a0);
19378         MP_WritePhyUshort(sc, 0x14, 0x0005);
19379         MP_WritePhyUshort(sc, 0x14, 0x0286);
19380         MP_WritePhyUshort(sc, 0x14, 0x96ae);
19381         MP_WritePhyUshort(sc, 0x14, 0x06a0);
19382         MP_WritePhyUshort(sc, 0x14, 0x0103);
19383         MP_WritePhyUshort(sc, 0x14, 0x0219);
19384         MP_WritePhyUshort(sc, 0x14, 0x19ef);
19385         MP_WritePhyUshort(sc, 0x14, 0x96fe);
19386         MP_WritePhyUshort(sc, 0x14, 0xfc04);
19387         MP_WritePhyUshort(sc, 0x14, 0xf8fa);
19388         MP_WritePhyUshort(sc, 0x14, 0xef69);
19389         MP_WritePhyUshort(sc, 0x14, 0xe082);
19390         MP_WritePhyUshort(sc, 0x14, 0x29f6);
19391         MP_WritePhyUshort(sc, 0x14, 0x20e4);
19392         MP_WritePhyUshort(sc, 0x14, 0x8229);
19393         MP_WritePhyUshort(sc, 0x14, 0xe080);
19394         MP_WritePhyUshort(sc, 0x14, 0x10ac);
19395         MP_WritePhyUshort(sc, 0x14, 0x2102);
19396         MP_WritePhyUshort(sc, 0x14, 0xae54);
19397         MP_WritePhyUshort(sc, 0x14, 0xe082);
19398         MP_WritePhyUshort(sc, 0x14, 0x27f7);
19399         MP_WritePhyUshort(sc, 0x14, 0x20e4);
19400         MP_WritePhyUshort(sc, 0x14, 0x8227);
19401         MP_WritePhyUshort(sc, 0x14, 0xbf42);
19402         MP_WritePhyUshort(sc, 0x14, 0xe602);
19403         MP_WritePhyUshort(sc, 0x14, 0x4297);
19404         MP_WritePhyUshort(sc, 0x14, 0xac28);
19405         MP_WritePhyUshort(sc, 0x14, 0x22bf);
19406         MP_WritePhyUshort(sc, 0x14, 0x430d);
19407         MP_WritePhyUshort(sc, 0x14, 0x0242);
19408         MP_WritePhyUshort(sc, 0x14, 0x97e5);
19409         MP_WritePhyUshort(sc, 0x14, 0x8247);
19410         MP_WritePhyUshort(sc, 0x14, 0xac28);
19411         MP_WritePhyUshort(sc, 0x14, 0x20d1);
19412         MP_WritePhyUshort(sc, 0x14, 0x03bf);
19413         MP_WritePhyUshort(sc, 0x14, 0x4307);
19414         MP_WritePhyUshort(sc, 0x14, 0x0242);
19415         MP_WritePhyUshort(sc, 0x14, 0x59ee);
19416         MP_WritePhyUshort(sc, 0x14, 0x8246);
19417         MP_WritePhyUshort(sc, 0x14, 0x00e1);
19418         MP_WritePhyUshort(sc, 0x14, 0x8227);
19419         MP_WritePhyUshort(sc, 0x14, 0xf628);
19420         MP_WritePhyUshort(sc, 0x14, 0xe582);
19421         MP_WritePhyUshort(sc, 0x14, 0x27ae);
19422         MP_WritePhyUshort(sc, 0x14, 0x21d1);
19423         MP_WritePhyUshort(sc, 0x14, 0x04bf);
19424         MP_WritePhyUshort(sc, 0x14, 0x4307);
19425         MP_WritePhyUshort(sc, 0x14, 0x0242);
19426         MP_WritePhyUshort(sc, 0x14, 0x59ae);
19427         MP_WritePhyUshort(sc, 0x14, 0x08d1);
19428         MP_WritePhyUshort(sc, 0x14, 0x05bf);
19429         MP_WritePhyUshort(sc, 0x14, 0x4307);
19430         MP_WritePhyUshort(sc, 0x14, 0x0242);
19431         MP_WritePhyUshort(sc, 0x14, 0x59e0);
19432         MP_WritePhyUshort(sc, 0x14, 0x8244);
19433         MP_WritePhyUshort(sc, 0x14, 0xf720);
19434         MP_WritePhyUshort(sc, 0x14, 0xe482);
19435         MP_WritePhyUshort(sc, 0x14, 0x4402);
19436         MP_WritePhyUshort(sc, 0x14, 0x46ae);
19437         MP_WritePhyUshort(sc, 0x14, 0xee82);
19438         MP_WritePhyUshort(sc, 0x14, 0x4601);
19439         MP_WritePhyUshort(sc, 0x14, 0xef96);
19440         MP_WritePhyUshort(sc, 0x14, 0xfefc);
19441         MP_WritePhyUshort(sc, 0x14, 0x04f8);
19442         MP_WritePhyUshort(sc, 0x14, 0xfaef);
19443         MP_WritePhyUshort(sc, 0x14, 0x69e0);
19444         MP_WritePhyUshort(sc, 0x14, 0x8013);
19445         MP_WritePhyUshort(sc, 0x14, 0xad24);
19446         MP_WritePhyUshort(sc, 0x14, 0x1cbf);
19447         MP_WritePhyUshort(sc, 0x14, 0x87f0);
19448         MP_WritePhyUshort(sc, 0x14, 0x0242);
19449         MP_WritePhyUshort(sc, 0x14, 0x97ad);
19450         MP_WritePhyUshort(sc, 0x14, 0x2813);
19451         MP_WritePhyUshort(sc, 0x14, 0xe087);
19452         MP_WritePhyUshort(sc, 0x14, 0xfca0);
19453         MP_WritePhyUshort(sc, 0x14, 0x0005);
19454         MP_WritePhyUshort(sc, 0x14, 0x0287);
19455         MP_WritePhyUshort(sc, 0x14, 0x36ae);
19456         MP_WritePhyUshort(sc, 0x14, 0x10a0);
19457         MP_WritePhyUshort(sc, 0x14, 0x0105);
19458         MP_WritePhyUshort(sc, 0x14, 0x0287);
19459         MP_WritePhyUshort(sc, 0x14, 0x48ae);
19460         MP_WritePhyUshort(sc, 0x14, 0x08e0);
19461         MP_WritePhyUshort(sc, 0x14, 0x8230);
19462         MP_WritePhyUshort(sc, 0x14, 0xf626);
19463         MP_WritePhyUshort(sc, 0x14, 0xe482);
19464         MP_WritePhyUshort(sc, 0x14, 0x30ef);
19465         MP_WritePhyUshort(sc, 0x14, 0x96fe);
19466         MP_WritePhyUshort(sc, 0x14, 0xfc04);
19467         MP_WritePhyUshort(sc, 0x14, 0xf8e0);
19468         MP_WritePhyUshort(sc, 0x14, 0x8245);
19469         MP_WritePhyUshort(sc, 0x14, 0xf722);
19470         MP_WritePhyUshort(sc, 0x14, 0xe482);
19471         MP_WritePhyUshort(sc, 0x14, 0x4502);
19472         MP_WritePhyUshort(sc, 0x14, 0x46ae);
19473         MP_WritePhyUshort(sc, 0x14, 0xee87);
19474         MP_WritePhyUshort(sc, 0x14, 0xfc01);
19475         MP_WritePhyUshort(sc, 0x14, 0xfc04);
19476         MP_WritePhyUshort(sc, 0x14, 0xf8fa);
19477         MP_WritePhyUshort(sc, 0x14, 0xef69);
19478         MP_WritePhyUshort(sc, 0x14, 0xfb02);
19479         MP_WritePhyUshort(sc, 0x14, 0x46d3);
19480         MP_WritePhyUshort(sc, 0x14, 0xad50);
19481         MP_WritePhyUshort(sc, 0x14, 0x2fbf);
19482         MP_WritePhyUshort(sc, 0x14, 0x87ed);
19483         MP_WritePhyUshort(sc, 0x14, 0xd101);
19484         MP_WritePhyUshort(sc, 0x14, 0x0242);
19485         MP_WritePhyUshort(sc, 0x14, 0x59bf);
19486         MP_WritePhyUshort(sc, 0x14, 0x87ed);
19487         MP_WritePhyUshort(sc, 0x14, 0xd100);
19488         MP_WritePhyUshort(sc, 0x14, 0x0242);
19489         MP_WritePhyUshort(sc, 0x14, 0x59e0);
19490         MP_WritePhyUshort(sc, 0x14, 0x8245);
19491         MP_WritePhyUshort(sc, 0x14, 0xf622);
19492         MP_WritePhyUshort(sc, 0x14, 0xe482);
19493         MP_WritePhyUshort(sc, 0x14, 0x4502);
19494         MP_WritePhyUshort(sc, 0x14, 0x46ae);
19495         MP_WritePhyUshort(sc, 0x14, 0xd100);
19496         MP_WritePhyUshort(sc, 0x14, 0xbf87);
19497         MP_WritePhyUshort(sc, 0x14, 0xf002);
19498         MP_WritePhyUshort(sc, 0x14, 0x4259);
19499         MP_WritePhyUshort(sc, 0x14, 0xee87);
19500         MP_WritePhyUshort(sc, 0x14, 0xfc00);
19501         MP_WritePhyUshort(sc, 0x14, 0xe082);
19502         MP_WritePhyUshort(sc, 0x14, 0x30f6);
19503         MP_WritePhyUshort(sc, 0x14, 0x26e4);
19504         MP_WritePhyUshort(sc, 0x14, 0x8230);
19505         MP_WritePhyUshort(sc, 0x14, 0xffef);
19506         MP_WritePhyUshort(sc, 0x14, 0x96fe);
19507         MP_WritePhyUshort(sc, 0x14, 0xfc04);
19508         MP_WritePhyUshort(sc, 0x14, 0xf8f9);
19509         MP_WritePhyUshort(sc, 0x14, 0xface);
19510         MP_WritePhyUshort(sc, 0x14, 0xfaef);
19511         MP_WritePhyUshort(sc, 0x14, 0x69fb);
19512         MP_WritePhyUshort(sc, 0x14, 0xbf87);
19513         MP_WritePhyUshort(sc, 0x14, 0xb3d7);
19514         MP_WritePhyUshort(sc, 0x14, 0x001c);
19515         MP_WritePhyUshort(sc, 0x14, 0xd819);
19516         MP_WritePhyUshort(sc, 0x14, 0xd919);
19517         MP_WritePhyUshort(sc, 0x14, 0xda19);
19518         MP_WritePhyUshort(sc, 0x14, 0xdb19);
19519         MP_WritePhyUshort(sc, 0x14, 0x07ef);
19520         MP_WritePhyUshort(sc, 0x14, 0x9502);
19521         MP_WritePhyUshort(sc, 0x14, 0x4259);
19522         MP_WritePhyUshort(sc, 0x14, 0x073f);
19523         MP_WritePhyUshort(sc, 0x14, 0x0004);
19524         MP_WritePhyUshort(sc, 0x14, 0x9fec);
19525         MP_WritePhyUshort(sc, 0x14, 0xffef);
19526         MP_WritePhyUshort(sc, 0x14, 0x96fe);
19527         MP_WritePhyUshort(sc, 0x14, 0xc6fe);
19528         MP_WritePhyUshort(sc, 0x14, 0xfdfc);
19529         MP_WritePhyUshort(sc, 0x14, 0x0400);
19530         MP_WritePhyUshort(sc, 0x14, 0x0145);
19531         MP_WritePhyUshort(sc, 0x14, 0x7d00);
19532         MP_WritePhyUshort(sc, 0x14, 0x0345);
19533         MP_WritePhyUshort(sc, 0x14, 0x5c00);
19534         MP_WritePhyUshort(sc, 0x14, 0x0143);
19535         MP_WritePhyUshort(sc, 0x14, 0x4f00);
19536         MP_WritePhyUshort(sc, 0x14, 0x0387);
19537         MP_WritePhyUshort(sc, 0x14, 0xdb00);
19538         MP_WritePhyUshort(sc, 0x14, 0x0987);
19539         MP_WritePhyUshort(sc, 0x14, 0xde00);
19540         MP_WritePhyUshort(sc, 0x14, 0x0987);
19541         MP_WritePhyUshort(sc, 0x14, 0xe100);
19542         MP_WritePhyUshort(sc, 0x14, 0x0087);
19543         MP_WritePhyUshort(sc, 0x14, 0xeaa4);
19544         MP_WritePhyUshort(sc, 0x14, 0x00b8);
19545         MP_WritePhyUshort(sc, 0x14, 0x20c4);
19546         MP_WritePhyUshort(sc, 0x14, 0x1600);
19547         MP_WritePhyUshort(sc, 0x14, 0x000f);
19548         MP_WritePhyUshort(sc, 0x14, 0xf800);
19549         MP_WritePhyUshort(sc, 0x14, 0x7098);
19550         MP_WritePhyUshort(sc, 0x14, 0xa58a);
19551         MP_WritePhyUshort(sc, 0x14, 0xb6a8);
19552         MP_WritePhyUshort(sc, 0x14, 0x3e50);
19553         MP_WritePhyUshort(sc, 0x14, 0xa83e);
19554         MP_WritePhyUshort(sc, 0x14, 0x33bc);
19555         MP_WritePhyUshort(sc, 0x14, 0xc622);
19556         MP_WritePhyUshort(sc, 0x14, 0xbcc6);
19557         MP_WritePhyUshort(sc, 0x14, 0xaaa4);
19558         MP_WritePhyUshort(sc, 0x14, 0x42ff);
19559         MP_WritePhyUshort(sc, 0x14, 0xc408);
19560         MP_WritePhyUshort(sc, 0x14, 0x00c4);
19561         MP_WritePhyUshort(sc, 0x14, 0x16a8);
19562         MP_WritePhyUshort(sc, 0x14, 0xbcc0);
19563         MP_WritePhyUshort(sc, 0x13, 0xb818);
19564         MP_WritePhyUshort(sc, 0x14, 0x02f3);
19565         MP_WritePhyUshort(sc, 0x13, 0xb81a);
19566         MP_WritePhyUshort(sc, 0x14, 0x17d1);
19567         MP_WritePhyUshort(sc, 0x13, 0xb81c);
19568         MP_WritePhyUshort(sc, 0x14, 0x185a);
19569         MP_WritePhyUshort(sc, 0x13, 0xb81e);
19570         MP_WritePhyUshort(sc, 0x14, 0x3c66);
19571         MP_WritePhyUshort(sc, 0x13, 0xb820);
19572         MP_WritePhyUshort(sc, 0x14, 0x021f);
19573         MP_WritePhyUshort(sc, 0x13, 0xc416);
19574         MP_WritePhyUshort(sc, 0x14, 0x0500);
19575         MP_WritePhyUshort(sc, 0x13, 0xb82e);
19576         MP_WritePhyUshort(sc, 0x14, 0xfffc);
19577
19578         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19579         MP_WritePhyUshort(sc, 0x13, 0x0000);
19580         MP_WritePhyUshort(sc, 0x14, 0x0000);
19581         MP_WritePhyUshort(sc, 0x1f, 0x0B82);
19582         PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
19583         PhyRegValue &= ~(BIT_9);
19584         MP_WritePhyUshort(sc, 0x10, PhyRegValue);
19585         MP_WritePhyUshort(sc, 0x1f, 0x0A43);
19586         MP_WritePhyUshort(sc, 0x13, 0x8146);
19587         MP_WritePhyUshort(sc, 0x14, 0x0000);
19588
19589         MP_WritePhyUshort(sc, 0x1f, 0x0B82);
19590         PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
19591         PhyRegValue &= ~(BIT_4);
19592         MP_WritePhyUshort(sc, 0x10, PhyRegValue);
19593         if (sc->RequiredSecLanDonglePatch) {
19594                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19595                 PhyRegValue = MP_ReadPhyUshort(sc, 0x11);
19596                 PhyRegValue &= ~(BIT_6);
19597                 MP_WritePhyUshort(sc, 0x11, PhyRegValue);
19598         }
19599 }
19600
19601 static void re_set_phy_mcu_8168gu_2(struct re_softc *sc)
19602 {
19603         u_int16_t PhyRegValue;
19604         u_int32_t WaitCnt;
19605
19606         MP_WritePhyUshort(sc, 0x1f, 0x0B82);
19607         PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
19608         PhyRegValue |= BIT_4;
19609         MP_WritePhyUshort(sc, 0x10, PhyRegValue);
19610
19611         MP_WritePhyUshort(sc, 0x1f, 0x0B80);
19612         WaitCnt = 0;
19613         do {
19614                 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
19615                 PhyRegValue &= 0x0040;
19616                 DELAY(50);
19617                 DELAY(50);
19618                 WaitCnt++;
19619         } while(PhyRegValue != 0x0040 && WaitCnt <1000);
19620
19621         MP_WritePhyUshort(sc, 0x1f, 0x0A43);
19622         MP_WritePhyUshort(sc, 0x13, 0x8146);
19623         MP_WritePhyUshort(sc, 0x14, 0x0300);
19624         MP_WritePhyUshort(sc, 0x13, 0xB82E);
19625         MP_WritePhyUshort(sc, 0x14, 0x0001);
19626
19627         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19628         MP_WritePhyUshort(sc, 0x13, 0xb820);
19629         MP_WritePhyUshort(sc, 0x14, 0x0290);
19630         MP_WritePhyUshort(sc, 0x13, 0xa012);
19631         MP_WritePhyUshort(sc, 0x14, 0x0000);
19632         MP_WritePhyUshort(sc, 0x13, 0xa014);
19633         MP_WritePhyUshort(sc, 0x14, 0x2c04);
19634         MP_WritePhyUshort(sc, 0x14, 0x2c07);
19635         MP_WritePhyUshort(sc, 0x14, 0x2c07);
19636         MP_WritePhyUshort(sc, 0x14, 0x2c07);
19637         MP_WritePhyUshort(sc, 0x14, 0xa304);
19638         MP_WritePhyUshort(sc, 0x14, 0xa301);
19639         MP_WritePhyUshort(sc, 0x14, 0x207e);
19640         MP_WritePhyUshort(sc, 0x13, 0xa01a);
19641         MP_WritePhyUshort(sc, 0x14, 0x0000);
19642         MP_WritePhyUshort(sc, 0x13, 0xa006);
19643         MP_WritePhyUshort(sc, 0x14, 0x0fff);
19644         MP_WritePhyUshort(sc, 0x13, 0xa004);
19645         MP_WritePhyUshort(sc, 0x14, 0x0fff);
19646         MP_WritePhyUshort(sc, 0x13, 0xa002);
19647         MP_WritePhyUshort(sc, 0x14, 0x0fff);
19648         MP_WritePhyUshort(sc, 0x13, 0xa000);
19649         MP_WritePhyUshort(sc, 0x14, 0x107c);
19650         MP_WritePhyUshort(sc, 0x13, 0xb820);
19651         MP_WritePhyUshort(sc, 0x14, 0x0210);
19652
19653         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19654         MP_WritePhyUshort(sc, 0x13, 0x0000);
19655         MP_WritePhyUshort(sc, 0x14, 0x0000);
19656         MP_WritePhyUshort(sc, 0x1f, 0x0B82);
19657         PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
19658         PhyRegValue &= ~(BIT_0);
19659         MP_WritePhyUshort(sc, 0x17, PhyRegValue);
19660         MP_WritePhyUshort(sc, 0x1f, 0x0A43);
19661         MP_WritePhyUshort(sc, 0x13, 0x8146);
19662         MP_WritePhyUshort(sc, 0x14, 0x0000);
19663
19664         MP_WritePhyUshort(sc, 0x1f, 0x0B82);
19665         PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
19666         PhyRegValue &= ~(BIT_4);
19667         MP_WritePhyUshort(sc, 0x10, PhyRegValue);
19668         if (sc->RequiredSecLanDonglePatch) {
19669                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19670                 PhyRegValue = MP_ReadPhyUshort(sc, 0x11);
19671                 PhyRegValue &= ~(BIT_6);
19672                 MP_WritePhyUshort(sc, 0x11, PhyRegValue);
19673         }
19674 }
19675
19676 static void re_set_phy_mcu_8411b_1(struct re_softc *sc)
19677 {
19678         u_int16_t PhyRegValue;
19679         u_int32_t WaitCnt;
19680
19681         MP_WritePhyUshort(sc, 0x1f, 0x0B82);
19682         PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
19683         PhyRegValue |= BIT_4;
19684         MP_WritePhyUshort(sc, 0x10, PhyRegValue);
19685
19686         MP_WritePhyUshort(sc, 0x1f, 0x0B80);
19687         WaitCnt = 0;
19688         do {
19689                 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
19690                 PhyRegValue &= 0x0040;
19691                 DELAY(50);
19692                 DELAY(50);
19693                 WaitCnt++;
19694         } while(PhyRegValue != 0x0040 && WaitCnt <1000);
19695
19696         MP_WritePhyUshort(sc, 0x1f, 0x0A43);
19697         MP_WritePhyUshort(sc, 0x13, 0x8146);
19698         MP_WritePhyUshort(sc, 0x14, 0x0100);
19699         MP_WritePhyUshort(sc, 0x13, 0xB82E);
19700         MP_WritePhyUshort(sc, 0x14, 0x0001);
19701
19702         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19703         MP_WritePhyUshort(sc, 0x13, 0xb820);
19704         MP_WritePhyUshort(sc, 0x14, 0x0290);
19705         MP_WritePhyUshort(sc, 0x13, 0xa012);
19706         MP_WritePhyUshort(sc, 0x14, 0x0000);
19707         MP_WritePhyUshort(sc, 0x13, 0xa014);
19708         MP_WritePhyUshort(sc, 0x14, 0x2c04);
19709         MP_WritePhyUshort(sc, 0x14, 0x2c07);
19710         MP_WritePhyUshort(sc, 0x14, 0x2c07);
19711         MP_WritePhyUshort(sc, 0x14, 0x2c07);
19712         MP_WritePhyUshort(sc, 0x14, 0xa304);
19713         MP_WritePhyUshort(sc, 0x14, 0xa301);
19714         MP_WritePhyUshort(sc, 0x14, 0x207e);
19715         MP_WritePhyUshort(sc, 0x13, 0xa01a);
19716         MP_WritePhyUshort(sc, 0x14, 0x0000);
19717         MP_WritePhyUshort(sc, 0x13, 0xa006);
19718         MP_WritePhyUshort(sc, 0x14, 0x0fff);
19719         MP_WritePhyUshort(sc, 0x13, 0xa004);
19720         MP_WritePhyUshort(sc, 0x14, 0x0fff);
19721         MP_WritePhyUshort(sc, 0x13, 0xa002);
19722         MP_WritePhyUshort(sc, 0x14, 0x0fff);
19723         MP_WritePhyUshort(sc, 0x13, 0xa000);
19724         MP_WritePhyUshort(sc, 0x14, 0x107c);
19725         MP_WritePhyUshort(sc, 0x13, 0xb820);
19726         MP_WritePhyUshort(sc, 0x14, 0x0210);
19727
19728         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19729         MP_WritePhyUshort(sc, 0x13, 0x0000);
19730         MP_WritePhyUshort(sc, 0x14, 0x0000);
19731         MP_WritePhyUshort(sc, 0x1f, 0x0B82);
19732         PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
19733         PhyRegValue &= ~(BIT_0);
19734         MP_WritePhyUshort(sc, 0x17, PhyRegValue);
19735         MP_WritePhyUshort(sc, 0x1f, 0x0A43);
19736         MP_WritePhyUshort(sc, 0x13, 0x8146);
19737         MP_WritePhyUshort(sc, 0x14, 0x0000);
19738
19739         MP_WritePhyUshort(sc, 0x1f, 0x0B82);
19740         PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
19741         PhyRegValue &= ~(BIT_4);
19742         MP_WritePhyUshort(sc, 0x10, PhyRegValue);
19743         if (sc->RequiredSecLanDonglePatch) {
19744                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19745                 PhyRegValue = MP_ReadPhyUshort(sc, 0x11);
19746                 PhyRegValue &= ~(BIT_6);
19747                 MP_WritePhyUshort(sc, 0x11, PhyRegValue);
19748         }
19749 }
19750
19751 static void re_set_phy_mcu_8168h_1(struct re_softc *sc)
19752 {
19753         u_int16_t PhyRegValue;
19754         u_int32_t WaitCnt;
19755
19756         MP_WritePhyUshort(sc, 0x1f, 0x0B82);
19757         PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
19758         PhyRegValue |= BIT_4;
19759         MP_WritePhyUshort(sc, 0x10, PhyRegValue);
19760
19761         MP_WritePhyUshort(sc, 0x1f, 0x0B80);
19762         WaitCnt = 0;
19763         do {
19764                 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
19765                 PhyRegValue &= 0x0040;
19766                 DELAY(50);
19767                 DELAY(50);
19768                 WaitCnt++;
19769         } while(PhyRegValue != 0x0040 && WaitCnt <1000);
19770
19771         MP_WritePhyUshort(sc, 0x1f, 0x0A43);
19772         MP_WritePhyUshort(sc, 0x13, 0x8028);
19773         MP_WritePhyUshort(sc, 0x14, 0x6200);
19774         MP_WritePhyUshort(sc, 0x13, 0xB82E);
19775         MP_WritePhyUshort(sc, 0x14, 0x0001);
19776
19777         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19778         MP_WritePhyUshort(sc, 0x13, 0xB820);
19779         MP_WritePhyUshort(sc, 0x14, 0x0290);
19780         MP_WritePhyUshort(sc, 0x13, 0xA012);
19781         MP_WritePhyUshort(sc, 0x14, 0x0000);
19782         MP_WritePhyUshort(sc, 0x13, 0xA014);
19783         MP_WritePhyUshort(sc, 0x14, 0x2c04);
19784         MP_WritePhyUshort(sc, 0x14, 0x2c10);
19785         MP_WritePhyUshort(sc, 0x14, 0x2c10);
19786         MP_WritePhyUshort(sc, 0x14, 0x2c10);
19787         MP_WritePhyUshort(sc, 0x14, 0xa210);
19788         MP_WritePhyUshort(sc, 0x14, 0xa101);
19789         MP_WritePhyUshort(sc, 0x14, 0xce10);
19790         MP_WritePhyUshort(sc, 0x14, 0xe070);
19791         MP_WritePhyUshort(sc, 0x14, 0x0f40);
19792         MP_WritePhyUshort(sc, 0x14, 0xaf01);
19793         MP_WritePhyUshort(sc, 0x14, 0x8f01);
19794         MP_WritePhyUshort(sc, 0x14, 0x183e);
19795         MP_WritePhyUshort(sc, 0x14, 0x8e10);
19796         MP_WritePhyUshort(sc, 0x14, 0x8101);
19797         MP_WritePhyUshort(sc, 0x14, 0x8210);
19798         MP_WritePhyUshort(sc, 0x14, 0x28da);
19799         MP_WritePhyUshort(sc, 0x13, 0xA01A);
19800         MP_WritePhyUshort(sc, 0x14, 0x0000);
19801         MP_WritePhyUshort(sc, 0x13, 0xA006);
19802         MP_WritePhyUshort(sc, 0x14, 0x0017);
19803         MP_WritePhyUshort(sc, 0x13, 0xA004);
19804         MP_WritePhyUshort(sc, 0x14, 0x0015);
19805         MP_WritePhyUshort(sc, 0x13, 0xA002);
19806         MP_WritePhyUshort(sc, 0x14, 0x0013);
19807         MP_WritePhyUshort(sc, 0x13, 0xA000);
19808         MP_WritePhyUshort(sc, 0x14, 0x18d1);
19809         MP_WritePhyUshort(sc, 0x13, 0xB820);
19810         MP_WritePhyUshort(sc, 0x14, 0x0210);
19811
19812         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19813         MP_WritePhyUshort(sc, 0x13, 0x0000);
19814         MP_WritePhyUshort(sc, 0x14, 0x0000);
19815         MP_WritePhyUshort(sc, 0x1f, 0x0B82);
19816         PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
19817         PhyRegValue &= ~(BIT_0);
19818         MP_WritePhyUshort(sc, 0x17, PhyRegValue);
19819         MP_WritePhyUshort(sc, 0x1f, 0x0A43);
19820         MP_WritePhyUshort(sc, 0x13, 0x8028);
19821         MP_WritePhyUshort(sc, 0x14, 0x0000);
19822
19823         MP_WritePhyUshort(sc, 0x1f, 0x0B82);
19824         PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
19825         PhyRegValue &= ~(BIT_4);
19826         MP_WritePhyUshort(sc, 0x10, PhyRegValue);
19827         if (sc->RequiredSecLanDonglePatch) {
19828                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19829                 PhyRegValue = MP_ReadPhyUshort(sc, 0x11);
19830                 PhyRegValue &= ~(BIT_6);
19831                 MP_WritePhyUshort(sc, 0x11, PhyRegValue);
19832         }
19833 }
19834
19835 static void re_set_phy_mcu_8168h_2(struct re_softc *sc)
19836 {
19837         u_int16_t PhyRegValue;
19838         u_int32_t WaitCnt;
19839
19840         MP_WritePhyUshort(sc, 0x1f, 0x0B82);
19841         PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
19842         PhyRegValue |= BIT_4;
19843         MP_WritePhyUshort(sc, 0x10, PhyRegValue);
19844
19845         MP_WritePhyUshort(sc, 0x1f, 0x0B80);
19846         WaitCnt = 0;
19847         do {
19848                 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
19849                 PhyRegValue &= 0x0040;
19850                 DELAY(50);
19851                 DELAY(50);
19852                 WaitCnt++;
19853         } while(PhyRegValue != 0x0040 && WaitCnt <1000);
19854
19855         MP_WritePhyUshort(sc, 0x1f, 0x0A43);
19856         MP_WritePhyUshort(sc, 0x13, 0x8028);
19857         MP_WritePhyUshort(sc, 0x14, 0x6201);
19858         MP_WritePhyUshort(sc, 0x13, 0xB82E);
19859         MP_WritePhyUshort(sc, 0x14, 0x0001);
19860
19861         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19862         MP_WritePhyUshort(sc, 0x13, 0xB820);
19863         MP_WritePhyUshort(sc, 0x14, 0x0290);
19864         MP_WritePhyUshort(sc, 0x13, 0xA012);
19865         MP_WritePhyUshort(sc, 0x14, 0x0000);
19866         MP_WritePhyUshort(sc, 0x13, 0xA014);
19867         MP_WritePhyUshort(sc, 0x14, 0x2c04);
19868         MP_WritePhyUshort(sc, 0x14, 0x2c09);
19869         MP_WritePhyUshort(sc, 0x14, 0x2c09);
19870         MP_WritePhyUshort(sc, 0x14, 0x2c09);
19871         MP_WritePhyUshort(sc, 0x14, 0xad01);
19872         MP_WritePhyUshort(sc, 0x14, 0xad01);
19873         MP_WritePhyUshort(sc, 0x14, 0xad01);
19874         MP_WritePhyUshort(sc, 0x14, 0xad01);
19875         MP_WritePhyUshort(sc, 0x14, 0x236c);
19876         MP_WritePhyUshort(sc, 0x13, 0xA01A);
19877         MP_WritePhyUshort(sc, 0x14, 0x0000);
19878         MP_WritePhyUshort(sc, 0x13, 0xA006);
19879         MP_WritePhyUshort(sc, 0x14, 0x0fff);
19880         MP_WritePhyUshort(sc, 0x13, 0xA004);
19881         MP_WritePhyUshort(sc, 0x14, 0x0fff);
19882         MP_WritePhyUshort(sc, 0x13, 0xA002);
19883         MP_WritePhyUshort(sc, 0x14, 0x0fff);
19884         MP_WritePhyUshort(sc, 0x13, 0xA000);
19885         MP_WritePhyUshort(sc, 0x14, 0x136b);
19886         MP_WritePhyUshort(sc, 0x13, 0xB820);
19887         MP_WritePhyUshort(sc, 0x14, 0x0210);
19888
19889         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19890         MP_WritePhyUshort(sc, 0x13, 0x0000);
19891         MP_WritePhyUshort(sc, 0x14, 0x0000);
19892         MP_WritePhyUshort(sc, 0x1f, 0x0B82);
19893         PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
19894         PhyRegValue &= ~(BIT_0);
19895         MP_WritePhyUshort(sc, 0x17, PhyRegValue);
19896         MP_WritePhyUshort(sc, 0x1f, 0x0A43);
19897         MP_WritePhyUshort(sc, 0x13, 0x8028);
19898         MP_WritePhyUshort(sc, 0x14, 0x0000);
19899
19900         MP_WritePhyUshort(sc, 0x1f, 0x0B82);
19901         PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
19902         PhyRegValue &= ~(BIT_4);
19903         MP_WritePhyUshort(sc, 0x10, PhyRegValue);
19904         if (sc->RequiredSecLanDonglePatch) {
19905                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19906                 PhyRegValue = MP_ReadPhyUshort(sc, 0x11);
19907                 PhyRegValue &= ~(BIT_6);
19908                 MP_WritePhyUshort(sc, 0x11, PhyRegValue);
19909         }
19910 }
19911
19912 static void re_set_phy_mcu_8168ep_1(struct re_softc *sc)
19913 {
19914         u_int16_t PhyRegValue;
19915         u_int32_t WaitCnt;
19916
19917         MP_WritePhyUshort(sc, 0x1f, 0x0B82);
19918         PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
19919         PhyRegValue |= BIT_4;
19920         MP_WritePhyUshort(sc, 0x10, PhyRegValue);
19921
19922         MP_WritePhyUshort(sc, 0x1f, 0x0B80);
19923         WaitCnt = 0;
19924         do {
19925                 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
19926                 PhyRegValue &= 0x0040;
19927                 DELAY(50);
19928                 DELAY(50);
19929                 WaitCnt++;
19930         } while(PhyRegValue != 0x0040 && WaitCnt <1000);
19931
19932         MP_WritePhyUshort(sc, 0x1f, 0x0A43);
19933         MP_WritePhyUshort(sc, 0x13, 0x8146);
19934         MP_WritePhyUshort(sc, 0x14, 0x2700);
19935         MP_WritePhyUshort(sc, 0x13, 0xB82E);
19936         MP_WritePhyUshort(sc, 0x14, 0x0001);
19937
19938         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19939         MP_WritePhyUshort(sc, 0x13, 0xb820);
19940         MP_WritePhyUshort(sc, 0x14, 0x0090);
19941         MP_WritePhyUshort(sc, 0x13, 0xa012);
19942         MP_WritePhyUshort(sc, 0x14, 0x0000);
19943         MP_WritePhyUshort(sc, 0x13, 0xa014);
19944         MP_WritePhyUshort(sc, 0x14, 0x2c04);
19945         MP_WritePhyUshort(sc, 0x14, 0x2c1b);
19946         MP_WritePhyUshort(sc, 0x14, 0x2c65);
19947         MP_WritePhyUshort(sc, 0x14, 0x2d14);
19948         MP_WritePhyUshort(sc, 0x14, 0xd71e);
19949         MP_WritePhyUshort(sc, 0x14, 0x4092);
19950         MP_WritePhyUshort(sc, 0x14, 0xba04);
19951         MP_WritePhyUshort(sc, 0x14, 0x3084);
19952         MP_WritePhyUshort(sc, 0x14, 0x1d04);
19953         MP_WritePhyUshort(sc, 0x14, 0x1cdd);
19954         MP_WritePhyUshort(sc, 0x14, 0x1ce8);
19955         MP_WritePhyUshort(sc, 0x14, 0xaeff);
19956         MP_WritePhyUshort(sc, 0x14, 0xaf02);
19957         MP_WritePhyUshort(sc, 0x14, 0x8f02);
19958         MP_WritePhyUshort(sc, 0x14, 0x8eff);
19959         MP_WritePhyUshort(sc, 0x14, 0xce01);
19960         MP_WritePhyUshort(sc, 0x14, 0xe070);
19961         MP_WritePhyUshort(sc, 0x14, 0x0f00);
19962         MP_WritePhyUshort(sc, 0x14, 0xaf01);
19963         MP_WritePhyUshort(sc, 0x14, 0x8f01);
19964         MP_WritePhyUshort(sc, 0x14, 0xd712);
19965         MP_WritePhyUshort(sc, 0x14, 0x5fe8);
19966         MP_WritePhyUshort(sc, 0x14, 0xaf02);
19967         MP_WritePhyUshort(sc, 0x14, 0x8f02);
19968         MP_WritePhyUshort(sc, 0x14, 0x8e01);
19969         MP_WritePhyUshort(sc, 0x14, 0x1cf2);
19970         MP_WritePhyUshort(sc, 0x14, 0x2825);
19971         MP_WritePhyUshort(sc, 0x14, 0xd05a);
19972         MP_WritePhyUshort(sc, 0x14, 0xd19a);
19973         MP_WritePhyUshort(sc, 0x14, 0xd709);
19974         MP_WritePhyUshort(sc, 0x14, 0x608f);
19975         MP_WritePhyUshort(sc, 0x14, 0xd06b);
19976         MP_WritePhyUshort(sc, 0x14, 0xd18a);
19977         MP_WritePhyUshort(sc, 0x14, 0x2c25);
19978         MP_WritePhyUshort(sc, 0x14, 0xd0be);
19979         MP_WritePhyUshort(sc, 0x14, 0xd188);
19980         MP_WritePhyUshort(sc, 0x14, 0x2c25);
19981         MP_WritePhyUshort(sc, 0x14, 0xd708);
19982         MP_WritePhyUshort(sc, 0x14, 0x4072);
19983         MP_WritePhyUshort(sc, 0x14, 0xc104);
19984         MP_WritePhyUshort(sc, 0x14, 0x2c37);
19985         MP_WritePhyUshort(sc, 0x14, 0x4076);
19986         MP_WritePhyUshort(sc, 0x14, 0xc110);
19987         MP_WritePhyUshort(sc, 0x14, 0x2c37);
19988         MP_WritePhyUshort(sc, 0x14, 0x4071);
19989         MP_WritePhyUshort(sc, 0x14, 0xc102);
19990         MP_WritePhyUshort(sc, 0x14, 0x2c37);
19991         MP_WritePhyUshort(sc, 0x14, 0x4070);
19992         MP_WritePhyUshort(sc, 0x14, 0xc101);
19993         MP_WritePhyUshort(sc, 0x14, 0x2c37);
19994         MP_WritePhyUshort(sc, 0x14, 0x1786);
19995         MP_WritePhyUshort(sc, 0x14, 0xd709);
19996         MP_WritePhyUshort(sc, 0x14, 0x3390);
19997         MP_WritePhyUshort(sc, 0x14, 0x5c32);
19998         MP_WritePhyUshort(sc, 0x14, 0x2c47);
19999         MP_WritePhyUshort(sc, 0x14, 0x1786);
20000         MP_WritePhyUshort(sc, 0x14, 0xd708);
20001         MP_WritePhyUshort(sc, 0x14, 0x6193);
20002         MP_WritePhyUshort(sc, 0x14, 0xd709);
20003         MP_WritePhyUshort(sc, 0x14, 0x5f9d);
20004         MP_WritePhyUshort(sc, 0x14, 0x408b);
20005         MP_WritePhyUshort(sc, 0x14, 0xd71e);
20006         MP_WritePhyUshort(sc, 0x14, 0x6042);
20007         MP_WritePhyUshort(sc, 0x14, 0xb401);
20008         MP_WritePhyUshort(sc, 0x14, 0x1786);
20009         MP_WritePhyUshort(sc, 0x14, 0xd708);
20010         MP_WritePhyUshort(sc, 0x14, 0x6073);
20011         MP_WritePhyUshort(sc, 0x14, 0x5fbc);
20012         MP_WritePhyUshort(sc, 0x14, 0x2c46);
20013         MP_WritePhyUshort(sc, 0x14, 0x26fe);
20014         MP_WritePhyUshort(sc, 0x14, 0xb280);
20015         MP_WritePhyUshort(sc, 0x14, 0xa841);
20016         MP_WritePhyUshort(sc, 0x14, 0x94e0);
20017         MP_WritePhyUshort(sc, 0x14, 0x8710);
20018         MP_WritePhyUshort(sc, 0x14, 0xd709);
20019         MP_WritePhyUshort(sc, 0x14, 0x42ec);
20020         MP_WritePhyUshort(sc, 0x14, 0x606d);
20021         MP_WritePhyUshort(sc, 0x14, 0xd207);
20022         MP_WritePhyUshort(sc, 0x14, 0x2c50);
20023         MP_WritePhyUshort(sc, 0x14, 0xd203);
20024         MP_WritePhyUshort(sc, 0x14, 0x33ff);
20025         MP_WritePhyUshort(sc, 0x14, 0x5647);
20026         MP_WritePhyUshort(sc, 0x14, 0x3275);
20027         MP_WritePhyUshort(sc, 0x14, 0x7c57);
20028         MP_WritePhyUshort(sc, 0x14, 0xb240);
20029         MP_WritePhyUshort(sc, 0x14, 0xb402);
20030         MP_WritePhyUshort(sc, 0x14, 0x2647);
20031         MP_WritePhyUshort(sc, 0x14, 0x6096);
20032         MP_WritePhyUshort(sc, 0x14, 0xb240);
20033         MP_WritePhyUshort(sc, 0x14, 0xb406);
20034         MP_WritePhyUshort(sc, 0x14, 0x2647);
20035         MP_WritePhyUshort(sc, 0x14, 0x31d7);
20036         MP_WritePhyUshort(sc, 0x14, 0x7c60);
20037         MP_WritePhyUshort(sc, 0x14, 0xb240);
20038         MP_WritePhyUshort(sc, 0x14, 0xb40e);
20039         MP_WritePhyUshort(sc, 0x14, 0x2647);
20040         MP_WritePhyUshort(sc, 0x14, 0xb410);
20041         MP_WritePhyUshort(sc, 0x14, 0x8802);
20042         MP_WritePhyUshort(sc, 0x14, 0xb240);
20043         MP_WritePhyUshort(sc, 0x14, 0x940e);
20044         MP_WritePhyUshort(sc, 0x14, 0x2647);
20045         MP_WritePhyUshort(sc, 0x14, 0xba04);
20046         MP_WritePhyUshort(sc, 0x14, 0x1cdd);
20047         MP_WritePhyUshort(sc, 0x14, 0xa902);
20048         MP_WritePhyUshort(sc, 0x14, 0xd711);
20049         MP_WritePhyUshort(sc, 0x14, 0x4045);
20050         MP_WritePhyUshort(sc, 0x14, 0xa980);
20051         MP_WritePhyUshort(sc, 0x14, 0x3003);
20052         MP_WritePhyUshort(sc, 0x14, 0x5a19);
20053         MP_WritePhyUshort(sc, 0x14, 0xa540);
20054         MP_WritePhyUshort(sc, 0x14, 0xa601);
20055         MP_WritePhyUshort(sc, 0x14, 0xd710);
20056         MP_WritePhyUshort(sc, 0x14, 0x4043);
20057         MP_WritePhyUshort(sc, 0x14, 0xa910);
20058         MP_WritePhyUshort(sc, 0x14, 0xd711);
20059         MP_WritePhyUshort(sc, 0x14, 0x60a0);
20060         MP_WritePhyUshort(sc, 0x14, 0xca33);
20061         MP_WritePhyUshort(sc, 0x14, 0xcb33);
20062         MP_WritePhyUshort(sc, 0x14, 0xa941);
20063         MP_WritePhyUshort(sc, 0x14, 0x2c7b);
20064         MP_WritePhyUshort(sc, 0x14, 0xcaff);
20065         MP_WritePhyUshort(sc, 0x14, 0xcbff);
20066         MP_WritePhyUshort(sc, 0x14, 0xa921);
20067         MP_WritePhyUshort(sc, 0x14, 0xce02);
20068         MP_WritePhyUshort(sc, 0x14, 0xe070);
20069         MP_WritePhyUshort(sc, 0x14, 0x0f10);
20070         MP_WritePhyUshort(sc, 0x14, 0xaf01);
20071         MP_WritePhyUshort(sc, 0x14, 0x8f01);
20072         MP_WritePhyUshort(sc, 0x14, 0x1791);
20073         MP_WritePhyUshort(sc, 0x14, 0x8e02);
20074         MP_WritePhyUshort(sc, 0x14, 0xd710);
20075         MP_WritePhyUshort(sc, 0x14, 0x41a3);
20076         MP_WritePhyUshort(sc, 0x14, 0xa140);
20077         MP_WritePhyUshort(sc, 0x14, 0xa220);
20078         MP_WritePhyUshort(sc, 0x14, 0xce10);
20079         MP_WritePhyUshort(sc, 0x14, 0xe070);
20080         MP_WritePhyUshort(sc, 0x14, 0x0f40);
20081         MP_WritePhyUshort(sc, 0x14, 0xaf01);
20082         MP_WritePhyUshort(sc, 0x14, 0x8f01);
20083         MP_WritePhyUshort(sc, 0x14, 0x1791);
20084         MP_WritePhyUshort(sc, 0x14, 0x8e10);
20085         MP_WritePhyUshort(sc, 0x14, 0x8140);
20086         MP_WritePhyUshort(sc, 0x14, 0x8220);
20087         MP_WritePhyUshort(sc, 0x14, 0xa301);
20088         MP_WritePhyUshort(sc, 0x14, 0x17b2);
20089         MP_WritePhyUshort(sc, 0x14, 0xd710);
20090         MP_WritePhyUshort(sc, 0x14, 0x609c);
20091         MP_WritePhyUshort(sc, 0x14, 0xd71e);
20092         MP_WritePhyUshort(sc, 0x14, 0x7fa4);
20093         MP_WritePhyUshort(sc, 0x14, 0x2cdb);
20094         MP_WritePhyUshort(sc, 0x14, 0x1cf0);
20095         MP_WritePhyUshort(sc, 0x14, 0xce04);
20096         MP_WritePhyUshort(sc, 0x14, 0xe070);
20097         MP_WritePhyUshort(sc, 0x14, 0x0f20);
20098         MP_WritePhyUshort(sc, 0x14, 0xaf01);
20099         MP_WritePhyUshort(sc, 0x14, 0x8f01);
20100         MP_WritePhyUshort(sc, 0x14, 0x1791);
20101         MP_WritePhyUshort(sc, 0x14, 0x8e04);
20102         MP_WritePhyUshort(sc, 0x14, 0x6044);
20103         MP_WritePhyUshort(sc, 0x14, 0x2cdb);
20104         MP_WritePhyUshort(sc, 0x14, 0xa520);
20105         MP_WritePhyUshort(sc, 0x14, 0xd710);
20106         MP_WritePhyUshort(sc, 0x14, 0x4043);
20107         MP_WritePhyUshort(sc, 0x14, 0x2cc8);
20108         MP_WritePhyUshort(sc, 0x14, 0xe00f);
20109         MP_WritePhyUshort(sc, 0x14, 0x0501);
20110         MP_WritePhyUshort(sc, 0x14, 0x1cf6);
20111         MP_WritePhyUshort(sc, 0x14, 0xb801);
20112         MP_WritePhyUshort(sc, 0x14, 0xd71e);
20113         MP_WritePhyUshort(sc, 0x14, 0x4060);
20114         MP_WritePhyUshort(sc, 0x14, 0x7fc4);
20115         MP_WritePhyUshort(sc, 0x14, 0x2cdb);
20116         MP_WritePhyUshort(sc, 0x14, 0x1cfc);
20117         MP_WritePhyUshort(sc, 0x14, 0xe00f);
20118         MP_WritePhyUshort(sc, 0x14, 0x0502);
20119         MP_WritePhyUshort(sc, 0x14, 0x1cf6);
20120         MP_WritePhyUshort(sc, 0x14, 0xb802);
20121         MP_WritePhyUshort(sc, 0x14, 0xd71e);
20122         MP_WritePhyUshort(sc, 0x14, 0x4061);
20123         MP_WritePhyUshort(sc, 0x14, 0x7fc4);
20124         MP_WritePhyUshort(sc, 0x14, 0x2cdb);
20125         MP_WritePhyUshort(sc, 0x14, 0x1cfc);
20126         MP_WritePhyUshort(sc, 0x14, 0xe00f);
20127         MP_WritePhyUshort(sc, 0x14, 0x0504);
20128         MP_WritePhyUshort(sc, 0x14, 0xd710);
20129         MP_WritePhyUshort(sc, 0x14, 0x6099);
20130         MP_WritePhyUshort(sc, 0x14, 0xd71e);
20131         MP_WritePhyUshort(sc, 0x14, 0x7fa4);
20132         MP_WritePhyUshort(sc, 0x14, 0x2cdb);
20133         MP_WritePhyUshort(sc, 0x14, 0xc17f);
20134         MP_WritePhyUshort(sc, 0x14, 0xc200);
20135         MP_WritePhyUshort(sc, 0x14, 0xc43f);
20136         MP_WritePhyUshort(sc, 0x14, 0xcc03);
20137         MP_WritePhyUshort(sc, 0x14, 0xa701);
20138         MP_WritePhyUshort(sc, 0x14, 0xa510);
20139         MP_WritePhyUshort(sc, 0x14, 0xd710);
20140         MP_WritePhyUshort(sc, 0x14, 0x4018);
20141         MP_WritePhyUshort(sc, 0x14, 0x9910);
20142         MP_WritePhyUshort(sc, 0x14, 0x8510);
20143         MP_WritePhyUshort(sc, 0x14, 0x28a1);
20144         MP_WritePhyUshort(sc, 0x14, 0xe00f);
20145         MP_WritePhyUshort(sc, 0x14, 0x0504);
20146         MP_WritePhyUshort(sc, 0x14, 0xd710);
20147         MP_WritePhyUshort(sc, 0x14, 0x6099);
20148         MP_WritePhyUshort(sc, 0x14, 0xd71e);
20149         MP_WritePhyUshort(sc, 0x14, 0x7fa4);
20150         MP_WritePhyUshort(sc, 0x14, 0x2cdb);
20151         MP_WritePhyUshort(sc, 0x14, 0xa608);
20152         MP_WritePhyUshort(sc, 0x14, 0xc17d);
20153         MP_WritePhyUshort(sc, 0x14, 0xc200);
20154         MP_WritePhyUshort(sc, 0x14, 0xc43f);
20155         MP_WritePhyUshort(sc, 0x14, 0xcc03);
20156         MP_WritePhyUshort(sc, 0x14, 0xa701);
20157         MP_WritePhyUshort(sc, 0x14, 0xa510);
20158         MP_WritePhyUshort(sc, 0x14, 0xd710);
20159         MP_WritePhyUshort(sc, 0x14, 0x4018);
20160         MP_WritePhyUshort(sc, 0x14, 0x9910);
20161         MP_WritePhyUshort(sc, 0x14, 0x8510);
20162         MP_WritePhyUshort(sc, 0x14, 0x298e);
20163         MP_WritePhyUshort(sc, 0x14, 0x17bd);
20164         MP_WritePhyUshort(sc, 0x14, 0x2815);
20165         MP_WritePhyUshort(sc, 0x14, 0xc000);
20166         MP_WritePhyUshort(sc, 0x14, 0xc100);
20167         MP_WritePhyUshort(sc, 0x14, 0xc200);
20168         MP_WritePhyUshort(sc, 0x14, 0xc300);
20169         MP_WritePhyUshort(sc, 0x14, 0xc400);
20170         MP_WritePhyUshort(sc, 0x14, 0xc500);
20171         MP_WritePhyUshort(sc, 0x14, 0xc600);
20172         MP_WritePhyUshort(sc, 0x14, 0xc7c1);
20173         MP_WritePhyUshort(sc, 0x14, 0xc800);
20174         MP_WritePhyUshort(sc, 0x14, 0xcc00);
20175         MP_WritePhyUshort(sc, 0x14, 0x0800);
20176         MP_WritePhyUshort(sc, 0x14, 0xca0f);
20177         MP_WritePhyUshort(sc, 0x14, 0xcbff);
20178         MP_WritePhyUshort(sc, 0x14, 0xa901);
20179         MP_WritePhyUshort(sc, 0x14, 0x8902);
20180         MP_WritePhyUshort(sc, 0x14, 0xc900);
20181         MP_WritePhyUshort(sc, 0x14, 0xca00);
20182         MP_WritePhyUshort(sc, 0x14, 0xcb00);
20183         MP_WritePhyUshort(sc, 0x14, 0x0800);
20184         MP_WritePhyUshort(sc, 0x14, 0xb804);
20185         MP_WritePhyUshort(sc, 0x14, 0x0800);
20186         MP_WritePhyUshort(sc, 0x14, 0xd71e);
20187         MP_WritePhyUshort(sc, 0x14, 0x6044);
20188         MP_WritePhyUshort(sc, 0x14, 0x9804);
20189         MP_WritePhyUshort(sc, 0x14, 0x0800);
20190         MP_WritePhyUshort(sc, 0x14, 0xd710);
20191         MP_WritePhyUshort(sc, 0x14, 0x6099);
20192         MP_WritePhyUshort(sc, 0x14, 0xd71e);
20193         MP_WritePhyUshort(sc, 0x14, 0x7fa4);
20194         MP_WritePhyUshort(sc, 0x14, 0x2cdb);
20195         MP_WritePhyUshort(sc, 0x14, 0x0800);
20196         MP_WritePhyUshort(sc, 0x14, 0xa510);
20197         MP_WritePhyUshort(sc, 0x14, 0xd710);
20198         MP_WritePhyUshort(sc, 0x14, 0x6098);
20199         MP_WritePhyUshort(sc, 0x14, 0xd71e);
20200         MP_WritePhyUshort(sc, 0x14, 0x7fa4);
20201         MP_WritePhyUshort(sc, 0x14, 0x2cdb);
20202         MP_WritePhyUshort(sc, 0x14, 0x8510);
20203         MP_WritePhyUshort(sc, 0x14, 0x0800);
20204         MP_WritePhyUshort(sc, 0x14, 0xd711);
20205         MP_WritePhyUshort(sc, 0x14, 0x3003);
20206         MP_WritePhyUshort(sc, 0x14, 0x1d08);
20207         MP_WritePhyUshort(sc, 0x14, 0x2d12);
20208         MP_WritePhyUshort(sc, 0x14, 0xd710);
20209         MP_WritePhyUshort(sc, 0x14, 0x60be);
20210         MP_WritePhyUshort(sc, 0x14, 0xe060);
20211         MP_WritePhyUshort(sc, 0x14, 0x0920);
20212         MP_WritePhyUshort(sc, 0x14, 0x1cdd);
20213         MP_WritePhyUshort(sc, 0x14, 0x2c90);
20214         MP_WritePhyUshort(sc, 0x14, 0xd71e);
20215         MP_WritePhyUshort(sc, 0x14, 0x3063);
20216         MP_WritePhyUshort(sc, 0x14, 0x19b0);
20217         MP_WritePhyUshort(sc, 0x14, 0x28d5);
20218         MP_WritePhyUshort(sc, 0x14, 0x1cdd);
20219         MP_WritePhyUshort(sc, 0x14, 0x2a25);
20220         MP_WritePhyUshort(sc, 0x14, 0xa802);
20221         MP_WritePhyUshort(sc, 0x14, 0xa303);
20222         MP_WritePhyUshort(sc, 0x14, 0x843f);
20223         MP_WritePhyUshort(sc, 0x14, 0x81ff);
20224         MP_WritePhyUshort(sc, 0x14, 0x8208);
20225         MP_WritePhyUshort(sc, 0x14, 0xa201);
20226         MP_WritePhyUshort(sc, 0x14, 0xc001);
20227         MP_WritePhyUshort(sc, 0x14, 0xd710);
20228         MP_WritePhyUshort(sc, 0x14, 0x30a0);
20229         MP_WritePhyUshort(sc, 0x14, 0x0d23);
20230         MP_WritePhyUshort(sc, 0x14, 0x30a0);
20231         MP_WritePhyUshort(sc, 0x14, 0x3d1a);
20232         MP_WritePhyUshort(sc, 0x14, 0xd71e);
20233         MP_WritePhyUshort(sc, 0x14, 0x7f4c);
20234         MP_WritePhyUshort(sc, 0x14, 0x2b1e);
20235         MP_WritePhyUshort(sc, 0x14, 0xe003);
20236         MP_WritePhyUshort(sc, 0x14, 0x0202);
20237         MP_WritePhyUshort(sc, 0x14, 0xd710);
20238         MP_WritePhyUshort(sc, 0x14, 0x6090);
20239         MP_WritePhyUshort(sc, 0x14, 0xd71e);
20240         MP_WritePhyUshort(sc, 0x14, 0x7fac);
20241         MP_WritePhyUshort(sc, 0x14, 0x2b1e);
20242         MP_WritePhyUshort(sc, 0x14, 0xa20c);
20243         MP_WritePhyUshort(sc, 0x14, 0xd710);
20244         MP_WritePhyUshort(sc, 0x14, 0x6091);
20245         MP_WritePhyUshort(sc, 0x14, 0xd71e);
20246         MP_WritePhyUshort(sc, 0x14, 0x7fac);
20247         MP_WritePhyUshort(sc, 0x14, 0x2b1e);
20248         MP_WritePhyUshort(sc, 0x14, 0x820e);
20249         MP_WritePhyUshort(sc, 0x14, 0xa3e0);
20250         MP_WritePhyUshort(sc, 0x14, 0xa520);
20251         MP_WritePhyUshort(sc, 0x14, 0xd710);
20252         MP_WritePhyUshort(sc, 0x14, 0x609d);
20253         MP_WritePhyUshort(sc, 0x14, 0xd71e);
20254         MP_WritePhyUshort(sc, 0x14, 0x7fac);
20255         MP_WritePhyUshort(sc, 0x14, 0x2b1e);
20256         MP_WritePhyUshort(sc, 0x14, 0x8520);
20257         MP_WritePhyUshort(sc, 0x14, 0x6703);
20258         MP_WritePhyUshort(sc, 0x14, 0x2d3b);
20259         MP_WritePhyUshort(sc, 0x14, 0xa13e);
20260         MP_WritePhyUshort(sc, 0x14, 0xc001);
20261         MP_WritePhyUshort(sc, 0x14, 0xd710);
20262         MP_WritePhyUshort(sc, 0x14, 0x4000);
20263         MP_WritePhyUshort(sc, 0x14, 0x6046);
20264         MP_WritePhyUshort(sc, 0x14, 0x2d14);
20265         MP_WritePhyUshort(sc, 0x14, 0xa43f);
20266         MP_WritePhyUshort(sc, 0x14, 0xa101);
20267         MP_WritePhyUshort(sc, 0x14, 0xc020);
20268         MP_WritePhyUshort(sc, 0x14, 0xd710);
20269         MP_WritePhyUshort(sc, 0x14, 0x3121);
20270         MP_WritePhyUshort(sc, 0x14, 0x0d4c);
20271         MP_WritePhyUshort(sc, 0x14, 0x30c0);
20272         MP_WritePhyUshort(sc, 0x14, 0x3d14);
20273         MP_WritePhyUshort(sc, 0x14, 0xd71e);
20274         MP_WritePhyUshort(sc, 0x14, 0x7f4c);
20275         MP_WritePhyUshort(sc, 0x14, 0x2b1e);
20276         MP_WritePhyUshort(sc, 0x14, 0xa540);
20277         MP_WritePhyUshort(sc, 0x14, 0xc001);
20278         MP_WritePhyUshort(sc, 0x14, 0xd710);
20279         MP_WritePhyUshort(sc, 0x14, 0x4001);
20280         MP_WritePhyUshort(sc, 0x14, 0xe00f);
20281         MP_WritePhyUshort(sc, 0x14, 0x0501);
20282         MP_WritePhyUshort(sc, 0x14, 0x1db3);
20283         MP_WritePhyUshort(sc, 0x14, 0xc1c4);
20284         MP_WritePhyUshort(sc, 0x14, 0xa268);
20285         MP_WritePhyUshort(sc, 0x14, 0xa303);
20286         MP_WritePhyUshort(sc, 0x14, 0x8420);
20287         MP_WritePhyUshort(sc, 0x14, 0xe00f);
20288         MP_WritePhyUshort(sc, 0x14, 0x0502);
20289         MP_WritePhyUshort(sc, 0x14, 0x1db3);
20290         MP_WritePhyUshort(sc, 0x14, 0xc002);
20291         MP_WritePhyUshort(sc, 0x14, 0xd710);
20292         MP_WritePhyUshort(sc, 0x14, 0x4000);
20293         MP_WritePhyUshort(sc, 0x14, 0x8208);
20294         MP_WritePhyUshort(sc, 0x14, 0x8410);
20295         MP_WritePhyUshort(sc, 0x14, 0xa121);
20296         MP_WritePhyUshort(sc, 0x14, 0xc002);
20297         MP_WritePhyUshort(sc, 0x14, 0xd710);
20298         MP_WritePhyUshort(sc, 0x14, 0x4000);
20299         MP_WritePhyUshort(sc, 0x14, 0x8120);
20300         MP_WritePhyUshort(sc, 0x14, 0x8180);
20301         MP_WritePhyUshort(sc, 0x14, 0x1d9e);
20302         MP_WritePhyUshort(sc, 0x14, 0xa180);
20303         MP_WritePhyUshort(sc, 0x14, 0xa13a);
20304         MP_WritePhyUshort(sc, 0x14, 0x8240);
20305         MP_WritePhyUshort(sc, 0x14, 0xa430);
20306         MP_WritePhyUshort(sc, 0x14, 0xc010);
20307         MP_WritePhyUshort(sc, 0x14, 0xd710);
20308         MP_WritePhyUshort(sc, 0x14, 0x30e1);
20309         MP_WritePhyUshort(sc, 0x14, 0x0b24);
20310         MP_WritePhyUshort(sc, 0x14, 0xd71e);
20311         MP_WritePhyUshort(sc, 0x14, 0x7f8c);
20312         MP_WritePhyUshort(sc, 0x14, 0x2b1e);
20313         MP_WritePhyUshort(sc, 0x14, 0xa480);
20314         MP_WritePhyUshort(sc, 0x14, 0xa230);
20315         MP_WritePhyUshort(sc, 0x14, 0xa303);
20316         MP_WritePhyUshort(sc, 0x14, 0xc001);
20317         MP_WritePhyUshort(sc, 0x14, 0xd70c);
20318         MP_WritePhyUshort(sc, 0x14, 0x4124);
20319         MP_WritePhyUshort(sc, 0x14, 0xd710);
20320         MP_WritePhyUshort(sc, 0x14, 0x6120);
20321         MP_WritePhyUshort(sc, 0x14, 0xd711);
20322         MP_WritePhyUshort(sc, 0x14, 0x3128);
20323         MP_WritePhyUshort(sc, 0x14, 0x3d7d);
20324         MP_WritePhyUshort(sc, 0x14, 0x2d77);
20325         MP_WritePhyUshort(sc, 0x14, 0xa801);
20326         MP_WritePhyUshort(sc, 0x14, 0x2d73);
20327         MP_WritePhyUshort(sc, 0x14, 0xd710);
20328         MP_WritePhyUshort(sc, 0x14, 0x4000);
20329         MP_WritePhyUshort(sc, 0x14, 0xe018);
20330         MP_WritePhyUshort(sc, 0x14, 0x0208);
20331         MP_WritePhyUshort(sc, 0x14, 0xa1f8);
20332         MP_WritePhyUshort(sc, 0x14, 0x8480);
20333         MP_WritePhyUshort(sc, 0x14, 0xc004);
20334         MP_WritePhyUshort(sc, 0x14, 0xd710);
20335         MP_WritePhyUshort(sc, 0x14, 0x4000);
20336         MP_WritePhyUshort(sc, 0x14, 0x6046);
20337         MP_WritePhyUshort(sc, 0x14, 0x2d14);
20338         MP_WritePhyUshort(sc, 0x14, 0xa43f);
20339         MP_WritePhyUshort(sc, 0x14, 0xa105);
20340         MP_WritePhyUshort(sc, 0x14, 0x8228);
20341         MP_WritePhyUshort(sc, 0x14, 0xc004);
20342         MP_WritePhyUshort(sc, 0x14, 0xd710);
20343         MP_WritePhyUshort(sc, 0x14, 0x4000);
20344         MP_WritePhyUshort(sc, 0x14, 0x81bc);
20345         MP_WritePhyUshort(sc, 0x14, 0xa220);
20346         MP_WritePhyUshort(sc, 0x14, 0x1d9e);
20347         MP_WritePhyUshort(sc, 0x14, 0x8220);
20348         MP_WritePhyUshort(sc, 0x14, 0xa1bc);
20349         MP_WritePhyUshort(sc, 0x14, 0xc040);
20350         MP_WritePhyUshort(sc, 0x14, 0xd710);
20351         MP_WritePhyUshort(sc, 0x14, 0x30e1);
20352         MP_WritePhyUshort(sc, 0x14, 0x0b24);
20353         MP_WritePhyUshort(sc, 0x14, 0x30e1);
20354         MP_WritePhyUshort(sc, 0x14, 0x3d14);
20355         MP_WritePhyUshort(sc, 0x14, 0xd71e);
20356         MP_WritePhyUshort(sc, 0x14, 0x7f4c);
20357         MP_WritePhyUshort(sc, 0x14, 0x2b1e);
20358         MP_WritePhyUshort(sc, 0x14, 0xa802);
20359         MP_WritePhyUshort(sc, 0x14, 0xd70c);
20360         MP_WritePhyUshort(sc, 0x14, 0x4244);
20361         MP_WritePhyUshort(sc, 0x14, 0xa301);
20362         MP_WritePhyUshort(sc, 0x14, 0xc004);
20363         MP_WritePhyUshort(sc, 0x14, 0xd711);
20364         MP_WritePhyUshort(sc, 0x14, 0x3128);
20365         MP_WritePhyUshort(sc, 0x14, 0x3dac);
20366         MP_WritePhyUshort(sc, 0x14, 0xd710);
20367         MP_WritePhyUshort(sc, 0x14, 0x5f80);
20368         MP_WritePhyUshort(sc, 0x14, 0xd711);
20369         MP_WritePhyUshort(sc, 0x14, 0x3109);
20370         MP_WritePhyUshort(sc, 0x14, 0x3dae);
20371         MP_WritePhyUshort(sc, 0x14, 0x2db2);
20372         MP_WritePhyUshort(sc, 0x14, 0xa801);
20373         MP_WritePhyUshort(sc, 0x14, 0x2da1);
20374         MP_WritePhyUshort(sc, 0x14, 0xa802);
20375         MP_WritePhyUshort(sc, 0x14, 0xc004);
20376         MP_WritePhyUshort(sc, 0x14, 0xd710);
20377         MP_WritePhyUshort(sc, 0x14, 0x4000);
20378         MP_WritePhyUshort(sc, 0x14, 0x0800);
20379         MP_WritePhyUshort(sc, 0x14, 0xa510);
20380         MP_WritePhyUshort(sc, 0x14, 0xd710);
20381         MP_WritePhyUshort(sc, 0x14, 0x609a);
20382         MP_WritePhyUshort(sc, 0x14, 0xd71e);
20383         MP_WritePhyUshort(sc, 0x14, 0x7fac);
20384         MP_WritePhyUshort(sc, 0x14, 0x2b1e);
20385         MP_WritePhyUshort(sc, 0x14, 0x8510);
20386         MP_WritePhyUshort(sc, 0x14, 0x0800);
20387         MP_WritePhyUshort(sc, 0x13, 0xa01a);
20388         MP_WritePhyUshort(sc, 0x14, 0x0000);
20389         MP_WritePhyUshort(sc, 0x13, 0xa006);
20390         MP_WritePhyUshort(sc, 0x14, 0x0b3e);
20391         MP_WritePhyUshort(sc, 0x13, 0xa004);
20392         MP_WritePhyUshort(sc, 0x14, 0x0828);
20393         MP_WritePhyUshort(sc, 0x13, 0xa002);
20394         MP_WritePhyUshort(sc, 0x14, 0x06dd);
20395         MP_WritePhyUshort(sc, 0x13, 0xa000);
20396         MP_WritePhyUshort(sc, 0x14, 0xf815);
20397         MP_WritePhyUshort(sc, 0x13, 0xb820);
20398         MP_WritePhyUshort(sc, 0x14, 0x0010);
20399
20400         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
20401         MP_WritePhyUshort(sc, 0x13, 0x83b0);
20402         MP_WritePhyUshort(sc, 0x14, 0xaf83);
20403         MP_WritePhyUshort(sc, 0x14, 0xbcaf);
20404         MP_WritePhyUshort(sc, 0x14, 0x83c8);
20405         MP_WritePhyUshort(sc, 0x14, 0xaf83);
20406         MP_WritePhyUshort(sc, 0x14, 0xddaf);
20407         MP_WritePhyUshort(sc, 0x14, 0x83e0);
20408         MP_WritePhyUshort(sc, 0x14, 0x0204);
20409         MP_WritePhyUshort(sc, 0x14, 0xa102);
20410         MP_WritePhyUshort(sc, 0x14, 0x09b4);
20411         MP_WritePhyUshort(sc, 0x14, 0x0284);
20412         MP_WritePhyUshort(sc, 0x14, 0x62af);
20413         MP_WritePhyUshort(sc, 0x14, 0x02ec);
20414         MP_WritePhyUshort(sc, 0x14, 0xad20);
20415         MP_WritePhyUshort(sc, 0x14, 0x0302);
20416         MP_WritePhyUshort(sc, 0x14, 0x867d);
20417         MP_WritePhyUshort(sc, 0x14, 0xad21);
20418         MP_WritePhyUshort(sc, 0x14, 0x0302);
20419         MP_WritePhyUshort(sc, 0x14, 0x85ca);
20420         MP_WritePhyUshort(sc, 0x14, 0xad22);
20421         MP_WritePhyUshort(sc, 0x14, 0x0302);
20422         MP_WritePhyUshort(sc, 0x14, 0x1bce);
20423         MP_WritePhyUshort(sc, 0x14, 0xaf18);
20424         MP_WritePhyUshort(sc, 0x14, 0x11af);
20425         MP_WritePhyUshort(sc, 0x14, 0x1811);
20426         MP_WritePhyUshort(sc, 0x14, 0x0106);
20427         MP_WritePhyUshort(sc, 0x14, 0xe081);
20428         MP_WritePhyUshort(sc, 0x14, 0x48af);
20429         MP_WritePhyUshort(sc, 0x14, 0x3b1f);
20430         MP_WritePhyUshort(sc, 0x14, 0xf8f9);
20431         MP_WritePhyUshort(sc, 0x14, 0xfaef);
20432         MP_WritePhyUshort(sc, 0x14, 0x69ee);
20433         MP_WritePhyUshort(sc, 0x14, 0x8010);
20434         MP_WritePhyUshort(sc, 0x14, 0xf7d1);
20435         MP_WritePhyUshort(sc, 0x14, 0x04bf);
20436         MP_WritePhyUshort(sc, 0x14, 0x8776);
20437         MP_WritePhyUshort(sc, 0x14, 0x0241);
20438         MP_WritePhyUshort(sc, 0x14, 0x0a02);
20439         MP_WritePhyUshort(sc, 0x14, 0x8704);
20440         MP_WritePhyUshort(sc, 0x14, 0xbf87);
20441         MP_WritePhyUshort(sc, 0x14, 0x4fd7);
20442         MP_WritePhyUshort(sc, 0x14, 0xb822);
20443         MP_WritePhyUshort(sc, 0x14, 0xd00c);
20444         MP_WritePhyUshort(sc, 0x14, 0x0241);
20445         MP_WritePhyUshort(sc, 0x14, 0x03ee);
20446         MP_WritePhyUshort(sc, 0x14, 0x80cd);
20447         MP_WritePhyUshort(sc, 0x14, 0xa0ee);
20448         MP_WritePhyUshort(sc, 0x14, 0x80ce);
20449         MP_WritePhyUshort(sc, 0x14, 0x8bee);
20450         MP_WritePhyUshort(sc, 0x14, 0x80d1);
20451         MP_WritePhyUshort(sc, 0x14, 0xf5ee);
20452         MP_WritePhyUshort(sc, 0x14, 0x80d2);
20453         MP_WritePhyUshort(sc, 0x14, 0xa9ee);
20454         MP_WritePhyUshort(sc, 0x14, 0x80d3);
20455         MP_WritePhyUshort(sc, 0x14, 0x0aee);
20456         MP_WritePhyUshort(sc, 0x14, 0x80f0);
20457         MP_WritePhyUshort(sc, 0x14, 0x10ee);
20458         MP_WritePhyUshort(sc, 0x14, 0x80f3);
20459         MP_WritePhyUshort(sc, 0x14, 0x8fee);
20460         MP_WritePhyUshort(sc, 0x14, 0x8101);
20461         MP_WritePhyUshort(sc, 0x14, 0x1eee);
20462         MP_WritePhyUshort(sc, 0x14, 0x810b);
20463         MP_WritePhyUshort(sc, 0x14, 0x4aee);
20464         MP_WritePhyUshort(sc, 0x14, 0x810c);
20465         MP_WritePhyUshort(sc, 0x14, 0x7cee);
20466         MP_WritePhyUshort(sc, 0x14, 0x8112);
20467         MP_WritePhyUshort(sc, 0x14, 0x7fd1);
20468         MP_WritePhyUshort(sc, 0x14, 0x0002);
20469         MP_WritePhyUshort(sc, 0x14, 0x10e3);
20470         MP_WritePhyUshort(sc, 0x14, 0xee80);
20471         MP_WritePhyUshort(sc, 0x14, 0x8892);
20472         MP_WritePhyUshort(sc, 0x14, 0xee80);
20473         MP_WritePhyUshort(sc, 0x14, 0x8922);
20474         MP_WritePhyUshort(sc, 0x14, 0xee80);
20475         MP_WritePhyUshort(sc, 0x14, 0x9a80);
20476         MP_WritePhyUshort(sc, 0x14, 0xee80);
20477         MP_WritePhyUshort(sc, 0x14, 0x9b22);
20478         MP_WritePhyUshort(sc, 0x14, 0xee80);
20479         MP_WritePhyUshort(sc, 0x14, 0x9ca7);
20480         MP_WritePhyUshort(sc, 0x14, 0xee80);
20481         MP_WritePhyUshort(sc, 0x14, 0xa010);
20482         MP_WritePhyUshort(sc, 0x14, 0xee80);
20483         MP_WritePhyUshort(sc, 0x14, 0xa5a7);
20484         MP_WritePhyUshort(sc, 0x14, 0xd200);
20485         MP_WritePhyUshort(sc, 0x14, 0x020e);
20486         MP_WritePhyUshort(sc, 0x14, 0x4b02);
20487         MP_WritePhyUshort(sc, 0x14, 0x85c1);
20488         MP_WritePhyUshort(sc, 0x14, 0xef96);
20489         MP_WritePhyUshort(sc, 0x14, 0xfefd);
20490         MP_WritePhyUshort(sc, 0x14, 0xfc04);
20491         MP_WritePhyUshort(sc, 0x14, 0x0284);
20492         MP_WritePhyUshort(sc, 0x14, 0x7b02);
20493         MP_WritePhyUshort(sc, 0x14, 0x84b4);
20494         MP_WritePhyUshort(sc, 0x14, 0x020c);
20495         MP_WritePhyUshort(sc, 0x14, 0x9202);
20496         MP_WritePhyUshort(sc, 0x14, 0x0cab);
20497         MP_WritePhyUshort(sc, 0x14, 0x020c);
20498         MP_WritePhyUshort(sc, 0x14, 0xd602);
20499         MP_WritePhyUshort(sc, 0x14, 0x0cef);
20500         MP_WritePhyUshort(sc, 0x14, 0x020d);
20501         MP_WritePhyUshort(sc, 0x14, 0x1a02);
20502         MP_WritePhyUshort(sc, 0x14, 0x0c24);
20503         MP_WritePhyUshort(sc, 0x14, 0x04f8);
20504         MP_WritePhyUshort(sc, 0x14, 0xfaef);
20505         MP_WritePhyUshort(sc, 0x14, 0x69e1);
20506         MP_WritePhyUshort(sc, 0x14, 0x8234);
20507         MP_WritePhyUshort(sc, 0x14, 0xac29);
20508         MP_WritePhyUshort(sc, 0x14, 0x1ae0);
20509         MP_WritePhyUshort(sc, 0x14, 0x8229);
20510         MP_WritePhyUshort(sc, 0x14, 0xac21);
20511         MP_WritePhyUshort(sc, 0x14, 0x02ae);
20512         MP_WritePhyUshort(sc, 0x14, 0x2202);
20513         MP_WritePhyUshort(sc, 0x14, 0x1085);
20514         MP_WritePhyUshort(sc, 0x14, 0xf621);
20515         MP_WritePhyUshort(sc, 0x14, 0xe482);
20516         MP_WritePhyUshort(sc, 0x14, 0x29d1);
20517         MP_WritePhyUshort(sc, 0x14, 0x01bf);
20518         MP_WritePhyUshort(sc, 0x14, 0x4364);
20519         MP_WritePhyUshort(sc, 0x14, 0x0241);
20520         MP_WritePhyUshort(sc, 0x14, 0x0aae);
20521         MP_WritePhyUshort(sc, 0x14, 0x1002);
20522         MP_WritePhyUshort(sc, 0x14, 0x127a);
20523         MP_WritePhyUshort(sc, 0x14, 0xf629);
20524         MP_WritePhyUshort(sc, 0x14, 0xe582);
20525         MP_WritePhyUshort(sc, 0x14, 0x34e0);
20526         MP_WritePhyUshort(sc, 0x14, 0x8229);
20527         MP_WritePhyUshort(sc, 0x14, 0xf621);
20528         MP_WritePhyUshort(sc, 0x14, 0xe482);
20529         MP_WritePhyUshort(sc, 0x14, 0x29ef);
20530         MP_WritePhyUshort(sc, 0x14, 0x96fe);
20531         MP_WritePhyUshort(sc, 0x14, 0xfc04);
20532         MP_WritePhyUshort(sc, 0x14, 0xf8e1);
20533         MP_WritePhyUshort(sc, 0x14, 0x8234);
20534         MP_WritePhyUshort(sc, 0x14, 0xac2a);
20535         MP_WritePhyUshort(sc, 0x14, 0x18e0);
20536         MP_WritePhyUshort(sc, 0x14, 0x8229);
20537         MP_WritePhyUshort(sc, 0x14, 0xac22);
20538         MP_WritePhyUshort(sc, 0x14, 0x02ae);
20539         MP_WritePhyUshort(sc, 0x14, 0x2602);
20540         MP_WritePhyUshort(sc, 0x14, 0x84f9);
20541         MP_WritePhyUshort(sc, 0x14, 0x0285);
20542         MP_WritePhyUshort(sc, 0x14, 0x66d1);
20543         MP_WritePhyUshort(sc, 0x14, 0x01bf);
20544         MP_WritePhyUshort(sc, 0x14, 0x4367);
20545         MP_WritePhyUshort(sc, 0x14, 0x0241);
20546         MP_WritePhyUshort(sc, 0x14, 0x0aae);
20547         MP_WritePhyUshort(sc, 0x14, 0x0e02);
20548         MP_WritePhyUshort(sc, 0x14, 0x84eb);
20549         MP_WritePhyUshort(sc, 0x14, 0x0285);
20550         MP_WritePhyUshort(sc, 0x14, 0xaae1);
20551         MP_WritePhyUshort(sc, 0x14, 0x8234);
20552         MP_WritePhyUshort(sc, 0x14, 0xf62a);
20553         MP_WritePhyUshort(sc, 0x14, 0xe582);
20554         MP_WritePhyUshort(sc, 0x14, 0x34e0);
20555         MP_WritePhyUshort(sc, 0x14, 0x8229);
20556         MP_WritePhyUshort(sc, 0x14, 0xf622);
20557         MP_WritePhyUshort(sc, 0x14, 0xe482);
20558         MP_WritePhyUshort(sc, 0x14, 0x29fc);
20559         MP_WritePhyUshort(sc, 0x14, 0x04f9);
20560         MP_WritePhyUshort(sc, 0x14, 0xe280);
20561         MP_WritePhyUshort(sc, 0x14, 0x11ad);
20562         MP_WritePhyUshort(sc, 0x14, 0x3105);
20563         MP_WritePhyUshort(sc, 0x14, 0xd200);
20564         MP_WritePhyUshort(sc, 0x14, 0x020e);
20565         MP_WritePhyUshort(sc, 0x14, 0x4bfd);
20566         MP_WritePhyUshort(sc, 0x14, 0x04f8);
20567         MP_WritePhyUshort(sc, 0x14, 0xf9fa);
20568         MP_WritePhyUshort(sc, 0x14, 0xef69);
20569         MP_WritePhyUshort(sc, 0x14, 0xe080);
20570         MP_WritePhyUshort(sc, 0x14, 0x11ad);
20571         MP_WritePhyUshort(sc, 0x14, 0x215c);
20572         MP_WritePhyUshort(sc, 0x14, 0xbf42);
20573         MP_WritePhyUshort(sc, 0x14, 0x5002);
20574         MP_WritePhyUshort(sc, 0x14, 0x4148);
20575         MP_WritePhyUshort(sc, 0x14, 0xac28);
20576         MP_WritePhyUshort(sc, 0x14, 0x1bbf);
20577         MP_WritePhyUshort(sc, 0x14, 0x4253);
20578         MP_WritePhyUshort(sc, 0x14, 0x0241);
20579         MP_WritePhyUshort(sc, 0x14, 0x48ac);
20580         MP_WritePhyUshort(sc, 0x14, 0x2812);
20581         MP_WritePhyUshort(sc, 0x14, 0xbf42);
20582         MP_WritePhyUshort(sc, 0x14, 0x5902);
20583         MP_WritePhyUshort(sc, 0x14, 0x4148);
20584         MP_WritePhyUshort(sc, 0x14, 0xac28);
20585         MP_WritePhyUshort(sc, 0x14, 0x04d3);
20586         MP_WritePhyUshort(sc, 0x14, 0x00ae);
20587         MP_WritePhyUshort(sc, 0x14, 0x07d3);
20588         MP_WritePhyUshort(sc, 0x14, 0x06af);
20589         MP_WritePhyUshort(sc, 0x14, 0x8557);
20590         MP_WritePhyUshort(sc, 0x14, 0xd303);
20591         MP_WritePhyUshort(sc, 0x14, 0xe080);
20592         MP_WritePhyUshort(sc, 0x14, 0x11ad);
20593         MP_WritePhyUshort(sc, 0x14, 0x2625);
20594         MP_WritePhyUshort(sc, 0x14, 0xbf43);
20595         MP_WritePhyUshort(sc, 0x14, 0xeb02);
20596         MP_WritePhyUshort(sc, 0x14, 0x4148);
20597         MP_WritePhyUshort(sc, 0x14, 0xe280);
20598         MP_WritePhyUshort(sc, 0x14, 0x730d);
20599         MP_WritePhyUshort(sc, 0x14, 0x21f6);
20600         MP_WritePhyUshort(sc, 0x14, 0x370d);
20601         MP_WritePhyUshort(sc, 0x14, 0x11f6);
20602         MP_WritePhyUshort(sc, 0x14, 0x2f1b);
20603         MP_WritePhyUshort(sc, 0x14, 0x21aa);
20604         MP_WritePhyUshort(sc, 0x14, 0x02ae);
20605         MP_WritePhyUshort(sc, 0x14, 0x10e2);
20606         MP_WritePhyUshort(sc, 0x14, 0x8074);
20607         MP_WritePhyUshort(sc, 0x14, 0x0d21);
20608         MP_WritePhyUshort(sc, 0x14, 0xf637);
20609         MP_WritePhyUshort(sc, 0x14, 0x1b21);
20610         MP_WritePhyUshort(sc, 0x14, 0xaa03);
20611         MP_WritePhyUshort(sc, 0x14, 0x13ae);
20612         MP_WritePhyUshort(sc, 0x14, 0x022b);
20613         MP_WritePhyUshort(sc, 0x14, 0x0202);
20614         MP_WritePhyUshort(sc, 0x14, 0x0e36);
20615         MP_WritePhyUshort(sc, 0x14, 0x020e);
20616         MP_WritePhyUshort(sc, 0x14, 0x4b02);
20617         MP_WritePhyUshort(sc, 0x14, 0x0f91);
20618         MP_WritePhyUshort(sc, 0x14, 0xef96);
20619         MP_WritePhyUshort(sc, 0x14, 0xfefd);
20620         MP_WritePhyUshort(sc, 0x14, 0xfc04);
20621         MP_WritePhyUshort(sc, 0x14, 0xf8f9);
20622         MP_WritePhyUshort(sc, 0x14, 0xfaef);
20623         MP_WritePhyUshort(sc, 0x14, 0x69e0);
20624         MP_WritePhyUshort(sc, 0x14, 0x8012);
20625         MP_WritePhyUshort(sc, 0x14, 0xad27);
20626         MP_WritePhyUshort(sc, 0x14, 0x33bf);
20627         MP_WritePhyUshort(sc, 0x14, 0x4250);
20628         MP_WritePhyUshort(sc, 0x14, 0x0241);
20629         MP_WritePhyUshort(sc, 0x14, 0x48ac);
20630         MP_WritePhyUshort(sc, 0x14, 0x2809);
20631         MP_WritePhyUshort(sc, 0x14, 0xbf42);
20632         MP_WritePhyUshort(sc, 0x14, 0x5302);
20633         MP_WritePhyUshort(sc, 0x14, 0x4148);
20634         MP_WritePhyUshort(sc, 0x14, 0xad28);
20635         MP_WritePhyUshort(sc, 0x14, 0x21bf);
20636         MP_WritePhyUshort(sc, 0x14, 0x43eb);
20637         MP_WritePhyUshort(sc, 0x14, 0x0241);
20638         MP_WritePhyUshort(sc, 0x14, 0x48e3);
20639         MP_WritePhyUshort(sc, 0x14, 0x87ff);
20640         MP_WritePhyUshort(sc, 0x14, 0xd200);
20641         MP_WritePhyUshort(sc, 0x14, 0x1b45);
20642         MP_WritePhyUshort(sc, 0x14, 0xac27);
20643         MP_WritePhyUshort(sc, 0x14, 0x11e1);
20644         MP_WritePhyUshort(sc, 0x14, 0x87fe);
20645         MP_WritePhyUshort(sc, 0x14, 0xbf87);
20646         MP_WritePhyUshort(sc, 0x14, 0x6702);
20647         MP_WritePhyUshort(sc, 0x14, 0x410a);
20648         MP_WritePhyUshort(sc, 0x14, 0x0d11);
20649         MP_WritePhyUshort(sc, 0x14, 0xbf87);
20650         MP_WritePhyUshort(sc, 0x14, 0x6a02);
20651         MP_WritePhyUshort(sc, 0x14, 0x410a);
20652         MP_WritePhyUshort(sc, 0x14, 0xef96);
20653         MP_WritePhyUshort(sc, 0x14, 0xfefd);
20654         MP_WritePhyUshort(sc, 0x14, 0xfc04);
20655         MP_WritePhyUshort(sc, 0x14, 0xf8fa);
20656         MP_WritePhyUshort(sc, 0x14, 0xef69);
20657         MP_WritePhyUshort(sc, 0x14, 0xd100);
20658         MP_WritePhyUshort(sc, 0x14, 0xbf87);
20659         MP_WritePhyUshort(sc, 0x14, 0x6702);
20660         MP_WritePhyUshort(sc, 0x14, 0x410a);
20661         MP_WritePhyUshort(sc, 0x14, 0xbf87);
20662         MP_WritePhyUshort(sc, 0x14, 0x6a02);
20663         MP_WritePhyUshort(sc, 0x14, 0x410a);
20664         MP_WritePhyUshort(sc, 0x14, 0xef96);
20665         MP_WritePhyUshort(sc, 0x14, 0xfefc);
20666         MP_WritePhyUshort(sc, 0x14, 0x04ee);
20667         MP_WritePhyUshort(sc, 0x14, 0x87ff);
20668         MP_WritePhyUshort(sc, 0x14, 0x46ee);
20669         MP_WritePhyUshort(sc, 0x14, 0x87fe);
20670         MP_WritePhyUshort(sc, 0x14, 0x0104);
20671         MP_WritePhyUshort(sc, 0x14, 0xf8fa);
20672         MP_WritePhyUshort(sc, 0x14, 0xef69);
20673         MP_WritePhyUshort(sc, 0x14, 0xe082);
20674         MP_WritePhyUshort(sc, 0x14, 0x46a0);
20675         MP_WritePhyUshort(sc, 0x14, 0x0005);
20676         MP_WritePhyUshort(sc, 0x14, 0x0285);
20677         MP_WritePhyUshort(sc, 0x14, 0xecae);
20678         MP_WritePhyUshort(sc, 0x14, 0x0ea0);
20679         MP_WritePhyUshort(sc, 0x14, 0x0105);
20680         MP_WritePhyUshort(sc, 0x14, 0x021a);
20681         MP_WritePhyUshort(sc, 0x14, 0x68ae);
20682         MP_WritePhyUshort(sc, 0x14, 0x06a0);
20683         MP_WritePhyUshort(sc, 0x14, 0x0203);
20684         MP_WritePhyUshort(sc, 0x14, 0x021a);
20685         MP_WritePhyUshort(sc, 0x14, 0xf4ef);
20686         MP_WritePhyUshort(sc, 0x14, 0x96fe);
20687         MP_WritePhyUshort(sc, 0x14, 0xfc04);
20688         MP_WritePhyUshort(sc, 0x14, 0xf8f9);
20689         MP_WritePhyUshort(sc, 0x14, 0xfaef);
20690         MP_WritePhyUshort(sc, 0x14, 0x69e0);
20691         MP_WritePhyUshort(sc, 0x14, 0x822e);
20692         MP_WritePhyUshort(sc, 0x14, 0xf621);
20693         MP_WritePhyUshort(sc, 0x14, 0xe482);
20694         MP_WritePhyUshort(sc, 0x14, 0x2ee0);
20695         MP_WritePhyUshort(sc, 0x14, 0x8010);
20696         MP_WritePhyUshort(sc, 0x14, 0xac22);
20697         MP_WritePhyUshort(sc, 0x14, 0x02ae);
20698         MP_WritePhyUshort(sc, 0x14, 0x76e0);
20699         MP_WritePhyUshort(sc, 0x14, 0x822c);
20700         MP_WritePhyUshort(sc, 0x14, 0xf721);
20701         MP_WritePhyUshort(sc, 0x14, 0xe482);
20702         MP_WritePhyUshort(sc, 0x14, 0x2cbf);
20703         MP_WritePhyUshort(sc, 0x14, 0x41a5);
20704         MP_WritePhyUshort(sc, 0x14, 0x0241);
20705         MP_WritePhyUshort(sc, 0x14, 0x48ef);
20706         MP_WritePhyUshort(sc, 0x14, 0x21bf);
20707         MP_WritePhyUshort(sc, 0x14, 0x41a8);
20708         MP_WritePhyUshort(sc, 0x14, 0x0241);
20709         MP_WritePhyUshort(sc, 0x14, 0x480c);
20710         MP_WritePhyUshort(sc, 0x14, 0x111e);
20711         MP_WritePhyUshort(sc, 0x14, 0x21bf);
20712         MP_WritePhyUshort(sc, 0x14, 0x41ab);
20713         MP_WritePhyUshort(sc, 0x14, 0x0241);
20714         MP_WritePhyUshort(sc, 0x14, 0x480c);
20715         MP_WritePhyUshort(sc, 0x14, 0x121e);
20716         MP_WritePhyUshort(sc, 0x14, 0x21e6);
20717         MP_WritePhyUshort(sc, 0x14, 0x8248);
20718         MP_WritePhyUshort(sc, 0x14, 0xa200);
20719         MP_WritePhyUshort(sc, 0x14, 0x0ae1);
20720         MP_WritePhyUshort(sc, 0x14, 0x822c);
20721         MP_WritePhyUshort(sc, 0x14, 0xf629);
20722         MP_WritePhyUshort(sc, 0x14, 0xe582);
20723         MP_WritePhyUshort(sc, 0x14, 0x2cae);
20724         MP_WritePhyUshort(sc, 0x14, 0x42e0);
20725         MP_WritePhyUshort(sc, 0x14, 0x8249);
20726         MP_WritePhyUshort(sc, 0x14, 0xf721);
20727         MP_WritePhyUshort(sc, 0x14, 0xe482);
20728         MP_WritePhyUshort(sc, 0x14, 0x4902);
20729         MP_WritePhyUshort(sc, 0x14, 0x4520);
20730         MP_WritePhyUshort(sc, 0x14, 0xbf41);
20731         MP_WritePhyUshort(sc, 0x14, 0xb702);
20732         MP_WritePhyUshort(sc, 0x14, 0x4148);
20733         MP_WritePhyUshort(sc, 0x14, 0xef21);
20734         MP_WritePhyUshort(sc, 0x14, 0xbf41);
20735         MP_WritePhyUshort(sc, 0x14, 0xae02);
20736         MP_WritePhyUshort(sc, 0x14, 0x4148);
20737         MP_WritePhyUshort(sc, 0x14, 0x0c12);
20738         MP_WritePhyUshort(sc, 0x14, 0x1e21);
20739         MP_WritePhyUshort(sc, 0x14, 0xbf41);
20740         MP_WritePhyUshort(sc, 0x14, 0xb102);
20741         MP_WritePhyUshort(sc, 0x14, 0x4148);
20742         MP_WritePhyUshort(sc, 0x14, 0x0c13);
20743         MP_WritePhyUshort(sc, 0x14, 0x1e21);
20744         MP_WritePhyUshort(sc, 0x14, 0xbf41);
20745         MP_WritePhyUshort(sc, 0x14, 0xba02);
20746         MP_WritePhyUshort(sc, 0x14, 0x4148);
20747         MP_WritePhyUshort(sc, 0x14, 0x0c14);
20748         MP_WritePhyUshort(sc, 0x14, 0x1e21);
20749         MP_WritePhyUshort(sc, 0x14, 0xbf43);
20750         MP_WritePhyUshort(sc, 0x14, 0x4602);
20751         MP_WritePhyUshort(sc, 0x14, 0x4148);
20752         MP_WritePhyUshort(sc, 0x14, 0x0c16);
20753         MP_WritePhyUshort(sc, 0x14, 0x1e21);
20754         MP_WritePhyUshort(sc, 0x14, 0xe682);
20755         MP_WritePhyUshort(sc, 0x14, 0x47ee);
20756         MP_WritePhyUshort(sc, 0x14, 0x8246);
20757         MP_WritePhyUshort(sc, 0x14, 0x01ef);
20758         MP_WritePhyUshort(sc, 0x14, 0x96fe);
20759         MP_WritePhyUshort(sc, 0x14, 0xfdfc);
20760         MP_WritePhyUshort(sc, 0x14, 0x04f8);
20761         MP_WritePhyUshort(sc, 0x14, 0xfaef);
20762         MP_WritePhyUshort(sc, 0x14, 0x69e0);
20763         MP_WritePhyUshort(sc, 0x14, 0x824b);
20764         MP_WritePhyUshort(sc, 0x14, 0xa000);
20765         MP_WritePhyUshort(sc, 0x14, 0x0502);
20766         MP_WritePhyUshort(sc, 0x14, 0x8697);
20767         MP_WritePhyUshort(sc, 0x14, 0xae06);
20768         MP_WritePhyUshort(sc, 0x14, 0xa001);
20769         MP_WritePhyUshort(sc, 0x14, 0x0302);
20770         MP_WritePhyUshort(sc, 0x14, 0x1937);
20771         MP_WritePhyUshort(sc, 0x14, 0xef96);
20772         MP_WritePhyUshort(sc, 0x14, 0xfefc);
20773         MP_WritePhyUshort(sc, 0x14, 0x04f8);
20774         MP_WritePhyUshort(sc, 0x14, 0xfaef);
20775         MP_WritePhyUshort(sc, 0x14, 0x69e0);
20776         MP_WritePhyUshort(sc, 0x14, 0x822e);
20777         MP_WritePhyUshort(sc, 0x14, 0xf620);
20778         MP_WritePhyUshort(sc, 0x14, 0xe482);
20779         MP_WritePhyUshort(sc, 0x14, 0x2ee0);
20780         MP_WritePhyUshort(sc, 0x14, 0x8010);
20781         MP_WritePhyUshort(sc, 0x14, 0xac21);
20782         MP_WritePhyUshort(sc, 0x14, 0x02ae);
20783         MP_WritePhyUshort(sc, 0x14, 0x54e0);
20784         MP_WritePhyUshort(sc, 0x14, 0x822c);
20785         MP_WritePhyUshort(sc, 0x14, 0xf720);
20786         MP_WritePhyUshort(sc, 0x14, 0xe482);
20787         MP_WritePhyUshort(sc, 0x14, 0x2cbf);
20788         MP_WritePhyUshort(sc, 0x14, 0x4175);
20789         MP_WritePhyUshort(sc, 0x14, 0x0241);
20790         MP_WritePhyUshort(sc, 0x14, 0x48ac);
20791         MP_WritePhyUshort(sc, 0x14, 0x2822);
20792         MP_WritePhyUshort(sc, 0x14, 0xbf41);
20793         MP_WritePhyUshort(sc, 0x14, 0x9f02);
20794         MP_WritePhyUshort(sc, 0x14, 0x4148);
20795         MP_WritePhyUshort(sc, 0x14, 0xe582);
20796         MP_WritePhyUshort(sc, 0x14, 0x4cac);
20797         MP_WritePhyUshort(sc, 0x14, 0x2820);
20798         MP_WritePhyUshort(sc, 0x14, 0xd103);
20799         MP_WritePhyUshort(sc, 0x14, 0xbf41);
20800         MP_WritePhyUshort(sc, 0x14, 0x9902);
20801         MP_WritePhyUshort(sc, 0x14, 0x410a);
20802         MP_WritePhyUshort(sc, 0x14, 0xee82);
20803         MP_WritePhyUshort(sc, 0x14, 0x4b00);
20804         MP_WritePhyUshort(sc, 0x14, 0xe182);
20805         MP_WritePhyUshort(sc, 0x14, 0x2cf6);
20806         MP_WritePhyUshort(sc, 0x14, 0x28e5);
20807         MP_WritePhyUshort(sc, 0x14, 0x822c);
20808         MP_WritePhyUshort(sc, 0x14, 0xae21);
20809         MP_WritePhyUshort(sc, 0x14, 0xd104);
20810         MP_WritePhyUshort(sc, 0x14, 0xbf41);
20811         MP_WritePhyUshort(sc, 0x14, 0x9902);
20812         MP_WritePhyUshort(sc, 0x14, 0x410a);
20813         MP_WritePhyUshort(sc, 0x14, 0xae08);
20814         MP_WritePhyUshort(sc, 0x14, 0xd105);
20815         MP_WritePhyUshort(sc, 0x14, 0xbf41);
20816         MP_WritePhyUshort(sc, 0x14, 0x9902);
20817         MP_WritePhyUshort(sc, 0x14, 0x410a);
20818         MP_WritePhyUshort(sc, 0x14, 0xe082);
20819         MP_WritePhyUshort(sc, 0x14, 0x49f7);
20820         MP_WritePhyUshort(sc, 0x14, 0x20e4);
20821         MP_WritePhyUshort(sc, 0x14, 0x8249);
20822         MP_WritePhyUshort(sc, 0x14, 0x0245);
20823         MP_WritePhyUshort(sc, 0x14, 0x20ee);
20824         MP_WritePhyUshort(sc, 0x14, 0x824b);
20825         MP_WritePhyUshort(sc, 0x14, 0x01ef);
20826         MP_WritePhyUshort(sc, 0x14, 0x96fe);
20827         MP_WritePhyUshort(sc, 0x14, 0xfc04);
20828         MP_WritePhyUshort(sc, 0x14, 0xf8f9);
20829         MP_WritePhyUshort(sc, 0x14, 0xface);
20830         MP_WritePhyUshort(sc, 0x14, 0xfaef);
20831         MP_WritePhyUshort(sc, 0x14, 0x69fb);
20832         MP_WritePhyUshort(sc, 0x14, 0xbf87);
20833         MP_WritePhyUshort(sc, 0x14, 0x2fd7);
20834         MP_WritePhyUshort(sc, 0x14, 0x0020);
20835         MP_WritePhyUshort(sc, 0x14, 0xd819);
20836         MP_WritePhyUshort(sc, 0x14, 0xd919);
20837         MP_WritePhyUshort(sc, 0x14, 0xda19);
20838         MP_WritePhyUshort(sc, 0x14, 0xdb19);
20839         MP_WritePhyUshort(sc, 0x14, 0x07ef);
20840         MP_WritePhyUshort(sc, 0x14, 0x9502);
20841         MP_WritePhyUshort(sc, 0x14, 0x410a);
20842         MP_WritePhyUshort(sc, 0x14, 0x073f);
20843         MP_WritePhyUshort(sc, 0x14, 0x0004);
20844         MP_WritePhyUshort(sc, 0x14, 0x9fec);
20845         MP_WritePhyUshort(sc, 0x14, 0xffef);
20846         MP_WritePhyUshort(sc, 0x14, 0x96fe);
20847         MP_WritePhyUshort(sc, 0x14, 0xc6fe);
20848         MP_WritePhyUshort(sc, 0x14, 0xfdfc);
20849         MP_WritePhyUshort(sc, 0x14, 0x0400);
20850         MP_WritePhyUshort(sc, 0x14, 0x0144);
20851         MP_WritePhyUshort(sc, 0x14, 0x0000);
20852         MP_WritePhyUshort(sc, 0x14, 0x0343);
20853         MP_WritePhyUshort(sc, 0x14, 0xee00);
20854         MP_WritePhyUshort(sc, 0x14, 0x0087);
20855         MP_WritePhyUshort(sc, 0x14, 0x5b00);
20856         MP_WritePhyUshort(sc, 0x14, 0x0141);
20857         MP_WritePhyUshort(sc, 0x14, 0xe100);
20858         MP_WritePhyUshort(sc, 0x14, 0x0387);
20859         MP_WritePhyUshort(sc, 0x14, 0x5e00);
20860         MP_WritePhyUshort(sc, 0x14, 0x0987);
20861         MP_WritePhyUshort(sc, 0x14, 0x6100);
20862         MP_WritePhyUshort(sc, 0x14, 0x0987);
20863         MP_WritePhyUshort(sc, 0x14, 0x6400);
20864         MP_WritePhyUshort(sc, 0x14, 0x0087);
20865         MP_WritePhyUshort(sc, 0x14, 0x6da4);
20866         MP_WritePhyUshort(sc, 0x14, 0x00b8);
20867         MP_WritePhyUshort(sc, 0x14, 0x20c4);
20868         MP_WritePhyUshort(sc, 0x14, 0x1600);
20869         MP_WritePhyUshort(sc, 0x14, 0x000f);
20870         MP_WritePhyUshort(sc, 0x14, 0xf800);
20871         MP_WritePhyUshort(sc, 0x14, 0x7000);
20872         MP_WritePhyUshort(sc, 0x14, 0xb82e);
20873         MP_WritePhyUshort(sc, 0x14, 0x98a5);
20874         MP_WritePhyUshort(sc, 0x14, 0x8ab6);
20875         MP_WritePhyUshort(sc, 0x14, 0xa83e);
20876         MP_WritePhyUshort(sc, 0x14, 0x50a8);
20877         MP_WritePhyUshort(sc, 0x14, 0x3e33);
20878         MP_WritePhyUshort(sc, 0x14, 0xbcc6);
20879         MP_WritePhyUshort(sc, 0x14, 0x22bc);
20880         MP_WritePhyUshort(sc, 0x14, 0xc6aa);
20881         MP_WritePhyUshort(sc, 0x14, 0xa442);
20882         MP_WritePhyUshort(sc, 0x14, 0xffc4);
20883         MP_WritePhyUshort(sc, 0x14, 0x0800);
20884         MP_WritePhyUshort(sc, 0x14, 0xc416);
20885         MP_WritePhyUshort(sc, 0x14, 0xa8bc);
20886         MP_WritePhyUshort(sc, 0x14, 0xc000);
20887         MP_WritePhyUshort(sc, 0x13, 0xb818);
20888         MP_WritePhyUshort(sc, 0x14, 0x02e3);
20889         MP_WritePhyUshort(sc, 0x13, 0xb81a);
20890         MP_WritePhyUshort(sc, 0x14, 0x17ff);
20891         MP_WritePhyUshort(sc, 0x13, 0xb81e);
20892         MP_WritePhyUshort(sc, 0x14, 0x3b1c);
20893         MP_WritePhyUshort(sc, 0x13, 0xb820);
20894         MP_WritePhyUshort(sc, 0x14, 0x021b);
20895         MP_WritePhyUshort(sc, 0x1f, 0x0000);
20896
20897         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
20898         MP_WritePhyUshort(sc, 0x13, 0x0000);
20899         MP_WritePhyUshort(sc, 0x14, 0x0000);
20900         MP_WritePhyUshort(sc, 0x1f, 0x0B82);
20901         PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
20902         PhyRegValue &= ~(BIT_0);
20903         MP_WritePhyUshort(sc, 0x17, PhyRegValue);
20904         if (sc->RequiredSecLanDonglePatch)
20905                 PhyRegValue &= ~(BIT_2);
20906         MP_WritePhyUshort(sc,0x1f, 0x0000);
20907
20908         MP_WritePhyUshort(sc, 0x1F, 0x0003);
20909         MP_WritePhyUshort(sc, 0x09, 0xA20F);
20910         MP_WritePhyUshort(sc, 0x1F, 0x0000);
20911         MP_WritePhyUshort(sc, 0x1F, 0x0003);
20912         MP_WritePhyUshort(sc, 0x01, 0x328A);
20913         MP_WritePhyUshort(sc, 0x1F, 0x0000);
20914         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
20915         MP_WritePhyUshort(sc, 0x13, 0x8011);
20916         ClearEthPhyBit(sc, 0x14, BIT_14);
20917         MP_WritePhyUshort(sc, 0x1F, 0x0A40);
20918         MP_WritePhyUshort(sc, 0x1F, 0x0000);
20919         MP_WritePhyUshort(sc,0x1f, 0x0000);
20920         MP_WritePhyUshort(sc,0x00, 0x9200);
20921 }
20922
20923 static void re_init_hw_phy_mcu(struct re_softc *sc)
20924 {
20925         if (re_hw_phy_mcu_code_ver_matched(sc)) return;
20926
20927         switch (sc->re_type) {
20928         case MACFG_36:
20929                 re_set_phy_mcu_8168e_1(sc);
20930                 break;
20931         case MACFG_37:
20932                 re_set_phy_mcu_8168e_2(sc);
20933                 break;
20934         case MACFG_38:
20935                 re_set_phy_mcu_8168evl_1(sc);
20936                 break;
20937         case MACFG_39:
20938                 re_set_phy_mcu_8168evl_2(sc);
20939                 break;
20940         case MACFG_50:
20941                 re_set_phy_mcu_8168f_1(sc);
20942                 break;
20943         case MACFG_51:
20944                 re_set_phy_mcu_8168f_2(sc);
20945                 break;
20946         case MACFG_52:
20947                 re_set_phy_mcu_8411_1(sc);
20948                 break;
20949         case MACFG_56:
20950                 re_set_phy_mcu_8168g_1(sc);
20951                 break;
20952         case MACFG_59:
20953                 re_set_phy_mcu_8168gu_2(sc);
20954                 break;
20955         case MACFG_60:
20956                 re_set_phy_mcu_8411b_1(sc);
20957                 break;
20958         case MACFG_61:
20959                 re_set_phy_mcu_8168ep_1(sc);
20960                 break;
20961         case MACFG_68:
20962                 re_set_phy_mcu_8168h_1(sc);
20963                 break;
20964         case MACFG_69:
20965                 re_set_phy_mcu_8168h_2(sc);
20966                 break;
20967         }
20968
20969         re_write_hw_phy_mcu_code_ver(sc);
20970
20971         MP_WritePhyUshort(sc, 0x1F, 0x0000);
20972 }
20973
20974 static void re_hw_phy_config(struct re_softc *sc)
20975 {
20976         u_int16_t Data, PhyRegValue, TmpUshort;
20977         u_int32_t Data_u32;
20978         u_int16_t dout_tapbin;
20979         int     i;
20980
20981         if (sc->re_type == MACFG_59 || sc->re_type == MACFG_60 ||
20982             sc->re_type == MACFG_62 || sc->re_type == MACFG_67 ||
20983             sc->re_type == MACFG_68 || sc->re_type == MACFG_69 ||
20984             sc->re_type == MACFG_70 || sc->re_type == MACFG_71) {
20985                 MP_WritePhyOcpRegWord(sc, 0x0C41, 0x13, 0x0000);
20986                 MP_WritePhyOcpRegWord(sc, 0x0C41, 0x13, 0x0500);
20987         }
20988
20989         if (HW_DASH_SUPPORT_TYPE_3(sc) && sc->HwPkgDet == 0x06) return;
20990
20991         if (FALSE == re_phy_ram_code_check(sc)) {
20992                 re_set_phy_ram_code_check_fail_flag(sc);
20993                 return;
20994         }
20995
20996         re_init_hw_phy_mcu(sc);
20997
20998         MP_WritePhyUshort(sc, 0x1F, 0x0000);
20999
21000         if (sc->re_type == MACFG_3) {
21001                 CSR_WRITE_1(sc, 0x82, CSR_READ_1(sc, 0x82)|BIT_0);
21002                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21003                 MP_WritePhyUshort(sc, 0x0b, 0x0000);
21004
21005                 MP_WritePhyUshort(sc, 0x1f, 0x0001);
21006                 MP_WritePhyUshort(sc, 0x06, 0x006e);
21007                 MP_WritePhyUshort(sc, 0x08, 0x0708);
21008                 MP_WritePhyUshort(sc, 0x15, 0x4000);
21009                 MP_WritePhyUshort(sc, 0x18, 0x65c7);
21010
21011                 MP_WritePhyUshort(sc, 0x1f, 0x0001);
21012                 MP_WritePhyUshort(sc, 0x03, 0x00a1);
21013                 MP_WritePhyUshort(sc, 0x02, 0x0008);
21014                 MP_WritePhyUshort(sc, 0x01, 0x0120);
21015                 MP_WritePhyUshort(sc, 0x00, 0x1000);
21016                 MP_WritePhyUshort(sc, 0x04, 0x0800);
21017                 MP_WritePhyUshort(sc, 0x04, 0x0000);
21018
21019                 MP_WritePhyUshort(sc, 0x03, 0xff41);
21020                 MP_WritePhyUshort(sc, 0x02, 0xdf60);
21021                 MP_WritePhyUshort(sc, 0x01, 0x0140);
21022                 MP_WritePhyUshort(sc, 0x00, 0x0077);
21023                 MP_WritePhyUshort(sc, 0x04, 0x7800);
21024                 MP_WritePhyUshort(sc, 0x04, 0x7000);
21025
21026                 MP_WritePhyUshort(sc, 0x03, 0x802f);
21027                 MP_WritePhyUshort(sc, 0x02, 0x4f02);
21028                 MP_WritePhyUshort(sc, 0x01, 0x0409);
21029                 MP_WritePhyUshort(sc, 0x00, 0xf0f9);
21030                 MP_WritePhyUshort(sc, 0x04, 0x9800);
21031                 MP_WritePhyUshort(sc, 0x04, 0x9000);
21032
21033                 MP_WritePhyUshort(sc, 0x03, 0xdf01);
21034                 MP_WritePhyUshort(sc, 0x02, 0xdf20);
21035                 MP_WritePhyUshort(sc, 0x01, 0xff95);
21036                 MP_WritePhyUshort(sc, 0x00, 0xba00);
21037                 MP_WritePhyUshort(sc, 0x04, 0xa800);
21038                 MP_WritePhyUshort(sc, 0x04, 0xa000);
21039
21040                 MP_WritePhyUshort(sc, 0x03, 0xff41);
21041                 MP_WritePhyUshort(sc, 0x02, 0xdf20);
21042                 MP_WritePhyUshort(sc, 0x01, 0x0140);
21043                 MP_WritePhyUshort(sc, 0x00, 0x00bb);
21044                 MP_WritePhyUshort(sc, 0x04, 0xb800);
21045                 MP_WritePhyUshort(sc, 0x04, 0xb000);
21046
21047                 MP_WritePhyUshort(sc, 0x03, 0xdf41);
21048                 MP_WritePhyUshort(sc, 0x02, 0xdc60);
21049                 MP_WritePhyUshort(sc, 0x01, 0x6340);
21050                 MP_WritePhyUshort(sc, 0x00, 0x007d);
21051                 MP_WritePhyUshort(sc, 0x04, 0xd800);
21052                 MP_WritePhyUshort(sc, 0x04, 0xd000);
21053
21054                 MP_WritePhyUshort(sc, 0x03, 0xdf01);
21055                 MP_WritePhyUshort(sc, 0x02, 0xdf20);
21056                 MP_WritePhyUshort(sc, 0x01, 0x100a);
21057                 MP_WritePhyUshort(sc, 0x00, 0xa0ff);
21058                 MP_WritePhyUshort(sc, 0x04, 0xf800);
21059                 MP_WritePhyUshort(sc, 0x04, 0xf000);
21060
21061                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
21062                 MP_WritePhyUshort(sc, 0x0b, 0x0000);
21063                 MP_WritePhyUshort(sc, 0x00, 0x9200);
21064
21065                 CSR_WRITE_1(sc, 0x82, 0x0d);
21066         } else if (sc->re_type == MACFG_4) {
21067                 MP_WritePhyUshort(sc, 0x1f, 0x0002);
21068                 MP_WritePhyUshort(sc, 0x01, 0x90D0);
21069                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
21070                 // MP_WritePhyUshort(sc, 0x1e, 0x8c00); /* PHY link down with some Giga switch */
21071         } else if (sc->re_type == MACFG_5) {
21072                 MP_WritePhyUshort(sc, 0x1f, 0x0001);
21073                 MP_WritePhyUshort(sc, 0x04, 0x0000);
21074                 MP_WritePhyUshort(sc, 0x03, 0x00a1);
21075                 MP_WritePhyUshort(sc, 0x02, 0x0008);
21076                 MP_WritePhyUshort(sc, 0x01, 0x0120);
21077                 MP_WritePhyUshort(sc, 0x00, 0x1000);
21078                 MP_WritePhyUshort(sc, 0x04, 0x0800);
21079
21080                 MP_WritePhyUshort(sc, 0x04, 0x9000);
21081                 MP_WritePhyUshort(sc, 0x03, 0x802f);
21082                 MP_WritePhyUshort(sc, 0x02, 0x4f02);
21083                 MP_WritePhyUshort(sc, 0x01, 0x0409);
21084                 MP_WritePhyUshort(sc, 0x00, 0xf099);
21085                 MP_WritePhyUshort(sc, 0x04, 0x9800);
21086
21087                 MP_WritePhyUshort(sc, 0x04, 0xa000);
21088                 MP_WritePhyUshort(sc, 0x03, 0xdf01);
21089                 MP_WritePhyUshort(sc, 0x02, 0xdf20);
21090                 MP_WritePhyUshort(sc, 0x01, 0xff95);
21091                 MP_WritePhyUshort(sc, 0x00, 0xba00);
21092                 MP_WritePhyUshort(sc, 0x04, 0xa800);
21093
21094                 MP_WritePhyUshort(sc, 0x04, 0xf000);
21095                 MP_WritePhyUshort(sc, 0x03, 0xdf01);
21096                 MP_WritePhyUshort(sc, 0x02, 0xdf20);
21097                 MP_WritePhyUshort(sc, 0x01, 0x101a);
21098                 MP_WritePhyUshort(sc, 0x00, 0xa0ff);
21099                 MP_WritePhyUshort(sc, 0x04, 0xf800);
21100                 MP_WritePhyUshort(sc, 0x04, 0x0000);
21101                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
21102
21103                 MP_WritePhyUshort(sc, 0x1f, 0x0001);
21104                 MP_WritePhyUshort(sc, 0x10, 0xf41b);
21105                 MP_WritePhyUshort(sc, 0x14, 0xfb54);
21106                 MP_WritePhyUshort(sc, 0x18, 0xf5c7);
21107                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
21108
21109                 MP_WritePhyUshort(sc, 0x1f, 0x0001);
21110                 MP_WritePhyUshort(sc, 0x17, 0x0CC0);
21111                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
21112
21113                 MP_WritePhyUshort(sc, 0x1f, 0x0001);
21114                 MP_WritePhyUshort(sc, 0x10, 0xf01b);
21115
21116         } else if (sc->re_type == MACFG_6) {
21117                 MP_WritePhyUshort(sc, 0x1f, 0x0001);
21118                 MP_WritePhyUshort(sc, 0x04, 0x0000);
21119                 MP_WritePhyUshort(sc, 0x03, 0x00a1);
21120                 MP_WritePhyUshort(sc, 0x02, 0x0008);
21121                 MP_WritePhyUshort(sc, 0x01, 0x0120);
21122                 MP_WritePhyUshort(sc, 0x00, 0x1000);
21123                 MP_WritePhyUshort(sc, 0x04, 0x0800);
21124
21125                 MP_WritePhyUshort(sc, 0x04, 0x9000);
21126                 MP_WritePhyUshort(sc, 0x03, 0x802f);
21127                 MP_WritePhyUshort(sc, 0x02, 0x4f02);
21128                 MP_WritePhyUshort(sc, 0x01, 0x0409);
21129                 MP_WritePhyUshort(sc, 0x00, 0xf099);
21130                 MP_WritePhyUshort(sc, 0x04, 0x9800);
21131
21132                 MP_WritePhyUshort(sc, 0x04, 0xa000);
21133                 MP_WritePhyUshort(sc, 0x03, 0xdf01);
21134                 MP_WritePhyUshort(sc, 0x02, 0xdf20);
21135                 MP_WritePhyUshort(sc, 0x01, 0xff95);
21136                 MP_WritePhyUshort(sc, 0x00, 0xba00);
21137                 MP_WritePhyUshort(sc, 0x04, 0xa800);
21138
21139                 MP_WritePhyUshort(sc, 0x04, 0xf000);
21140                 MP_WritePhyUshort(sc, 0x03, 0xdf01);
21141                 MP_WritePhyUshort(sc, 0x02, 0xdf20);
21142                 MP_WritePhyUshort(sc, 0x01, 0x101a);
21143                 MP_WritePhyUshort(sc, 0x00, 0xa0ff);
21144                 MP_WritePhyUshort(sc, 0x04, 0xf800);
21145                 MP_WritePhyUshort(sc, 0x04, 0x0000);
21146                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
21147
21148                 MP_WritePhyUshort(sc, 0x1f, 0x0001);
21149                 MP_WritePhyUshort(sc, 0x0b, 0x8480);
21150                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
21151
21152                 MP_WritePhyUshort(sc, 0x1f, 0x0001);
21153                 MP_WritePhyUshort(sc, 0x18, 0x67c7);
21154                 MP_WritePhyUshort(sc, 0x04, 0x2000);
21155                 MP_WritePhyUshort(sc, 0x03, 0x002f);
21156                 MP_WritePhyUshort(sc, 0x02, 0x4360);
21157                 MP_WritePhyUshort(sc, 0x01, 0x0109);
21158                 MP_WritePhyUshort(sc, 0x00, 0x3022);
21159                 MP_WritePhyUshort(sc, 0x04, 0x2800);
21160                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
21161
21162                 MP_WritePhyUshort(sc, 0x1f, 0x0001);
21163                 MP_WritePhyUshort(sc, 0x17, 0x0CC0);
21164         } else if (sc->re_type == MACFG_14) {
21165                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
21166                 MP_WritePhyUshort(sc, 0x11, MP_ReadPhyUshort(sc, 0x11) | 0x1000);
21167                 MP_WritePhyUshort(sc, 0x19, MP_ReadPhyUshort(sc, 0x19) | 0x2000);
21168                 MP_WritePhyUshort(sc, 0x10, MP_ReadPhyUshort(sc, 0x10) | 0x8000);
21169
21170                 MP_WritePhyUshort(sc, 0x1f, 0x0003);
21171                 MP_WritePhyUshort(sc, 0x08, 0x441D);
21172                 MP_WritePhyUshort(sc, 0x01, 0x9100);
21173         } else if (sc->re_type == MACFG_15) {
21174                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
21175                 MP_WritePhyUshort(sc, 0x11, MP_ReadPhyUshort(sc, 0x11) | 0x1000);
21176                 MP_WritePhyUshort(sc, 0x19, MP_ReadPhyUshort(sc, 0x19) | 0x2000);
21177                 MP_WritePhyUshort(sc, 0x10, MP_ReadPhyUshort(sc, 0x10) | 0x8000);
21178
21179                 MP_WritePhyUshort(sc, 0x1f, 0x0003);
21180                 MP_WritePhyUshort(sc, 0x08, 0x441D);
21181                 MP_WritePhyUshort(sc, 0x01, 0x9100);
21182         } else if (sc->re_type == MACFG_17) {
21183                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
21184                 MP_WritePhyUshort(sc, 0x11, MP_ReadPhyUshort(sc, 0x11) | 0x1000);
21185                 MP_WritePhyUshort(sc, 0x19, MP_ReadPhyUshort(sc, 0x19) | 0x2000);
21186                 MP_WritePhyUshort(sc, 0x10, MP_ReadPhyUshort(sc, 0x10) | 0x8000);
21187
21188                 MP_WritePhyUshort(sc, 0x1f, 0x0003);
21189                 MP_WritePhyUshort(sc, 0x08, 0x441D);
21190
21191                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
21192         } else if (sc->re_type == MACFG_21) {
21193                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
21194                 MP_WritePhyUshort(sc, 0x0B, 0x94B0);
21195
21196                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
21197                 MP_WritePhyUshort(sc, 0x12, 0x6096);
21198                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21199         } else if (sc->re_type == MACFG_22) {
21200                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
21201                 MP_WritePhyUshort(sc, 0x0B, 0x94B0);
21202
21203                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
21204                 MP_WritePhyUshort(sc, 0x12, 0x6096);
21205         } else if (sc->re_type == MACFG_23) {
21206                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
21207                 MP_WritePhyUshort(sc, 0x0B, 0x94B0);
21208
21209                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
21210                 MP_WritePhyUshort(sc, 0x12, 0x6096);
21211         } else if (sc->re_type == MACFG_24) {
21212                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
21213                 MP_WritePhyUshort(sc, 0x12, 0x2300);
21214                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21215                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
21216                 MP_WritePhyUshort(sc, 0x16, 0x000A);
21217                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21218
21219                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
21220                 MP_WritePhyUshort(sc, 0x12, 0xC096);
21221                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21222
21223                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21224                 MP_WritePhyUshort(sc, 0x00, 0x88DE);
21225                 MP_WritePhyUshort(sc, 0x01, 0x82B1);
21226                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21227
21228                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21229                 MP_WritePhyUshort(sc, 0x08, 0x9E30);
21230                 MP_WritePhyUshort(sc, 0x09, 0x01F0);
21231                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21232
21233                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21234                 MP_WritePhyUshort(sc, 0x0A, 0x5500);
21235                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21236
21237                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21238                 MP_WritePhyUshort(sc, 0x03, 0x7002);
21239                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21240
21241                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21242                 MP_WritePhyUshort(sc, 0x14, MP_ReadPhyUshort(sc, 0x14) | BIT_5);
21243                 MP_WritePhyUshort(sc, 0x0d, MP_ReadPhyUshort(sc, 0x0d) | BIT_5);
21244         } else if (sc->re_type == MACFG_25) {
21245                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
21246                 MP_WritePhyUshort(sc, 0x12, 0x2300);
21247                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
21248                 MP_WritePhyUshort(sc, 0x16, 0x0F0A);
21249                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21250
21251                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21252                 MP_WritePhyUshort(sc, 0x00, 0x88DE);
21253                 MP_WritePhyUshort(sc, 0x01, 0x82B1);
21254                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21255
21256                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21257                 MP_WritePhyUshort(sc, 0x0C, 0x7EB8);
21258                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21259
21260                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21261                 MP_WritePhyUshort(sc, 0x06, 0x0761);
21262                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21263
21264                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
21265                 MP_WritePhyUshort(sc, 0x03, 0x802F);
21266                 MP_WritePhyUshort(sc, 0x02, 0x4F02);
21267                 MP_WritePhyUshort(sc, 0x01, 0x0409);
21268                 MP_WritePhyUshort(sc, 0x00, 0xF099);
21269                 MP_WritePhyUshort(sc, 0x04, 0x9800);
21270                 MP_WritePhyUshort(sc, 0x04, 0x9000);
21271                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21272
21273                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21274                 MP_WritePhyUshort(sc, 0x16, MP_ReadPhyUshort(sc, 0x16) | BIT_0);
21275
21276                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21277                 MP_WritePhyUshort(sc, 0x14, MP_ReadPhyUshort(sc, 0x14) | BIT_5);
21278                 MP_WritePhyUshort(sc, 0x0D, MP_ReadPhyUshort(sc, 0x0D) & ~BIT_5);
21279
21280                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
21281                 MP_WritePhyUshort(sc, 0x1D, 0x3D98);
21282                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21283
21284                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
21285                 MP_WritePhyUshort(sc, 0x17, 0x0CC0);
21286                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21287         } else if (sc->re_type == MACFG_26) {
21288                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
21289                 MP_WritePhyUshort(sc, 0x12, 0x2300);
21290                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
21291                 MP_WritePhyUshort(sc, 0x16, 0x0F0A);
21292                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21293
21294                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21295                 MP_WritePhyUshort(sc, 0x00, 0x88DE);
21296                 MP_WritePhyUshort(sc, 0x01, 0x82B1);
21297                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21298
21299                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21300                 MP_WritePhyUshort(sc, 0x0C, 0x7EB8);
21301                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21302
21303                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21304                 MP_WritePhyUshort(sc, 0x06, 0x5461);
21305                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21306
21307                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21308                 MP_WritePhyUshort(sc, 0x06, 0x5461);
21309                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21310
21311                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21312                 MP_WritePhyUshort(sc, 0x16, MP_ReadPhyUshort(sc, 0x16) | BIT_0);
21313
21314                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21315                 MP_WritePhyUshort(sc, 0x14, MP_ReadPhyUshort(sc, 0x14) | BIT_5);
21316                 MP_WritePhyUshort(sc, 0x0D, MP_ReadPhyUshort(sc, 0x0D) & ~BIT_5);
21317
21318                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
21319                 MP_WritePhyUshort(sc, 0x1D, 0x3D98);
21320                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21321
21322                 MP_WritePhyUshort(sc, 0x1f, 0x0001);
21323                 MP_WritePhyUshort(sc, 0x17, 0x0CC0);
21324                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21325         } else if (sc->re_type == MACFG_27) {
21326                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21327                 MP_WritePhyUshort(sc, 0x0d, MP_ReadPhyUshort(sc, 0x0d) | BIT_5);
21328                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21329
21330                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
21331                 MP_WritePhyUshort(sc, 0x1D, 0x3D98);
21332                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21333
21334                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
21335                 MP_WritePhyUshort(sc, 0x14, 0xCAA3);
21336                 MP_WritePhyUshort(sc, 0x1C, 0x000A);
21337                 MP_WritePhyUshort(sc, 0x18, 0x65D0);
21338
21339                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
21340                 MP_WritePhyUshort(sc, 0x17, 0xB580);
21341                 MP_WritePhyUshort(sc, 0x18, 0xFF54);
21342                 MP_WritePhyUshort(sc, 0x19, 0x3954);
21343
21344                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21345                 MP_WritePhyUshort(sc, 0x0D, 0x310C);
21346                 MP_WritePhyUshort(sc, 0x0E, 0x310C);
21347                 MP_WritePhyUshort(sc, 0x0F, 0x311C);
21348                 MP_WritePhyUshort(sc, 0x06, 0x0761);
21349
21350                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
21351                 MP_WritePhyUshort(sc, 0x18, 0xFF55);
21352                 MP_WritePhyUshort(sc, 0x19, 0x3955);
21353                 MP_WritePhyUshort(sc, 0x18, 0xFF54);
21354                 MP_WritePhyUshort(sc, 0x19, 0x3954);
21355
21356                 MP_WritePhyUshort(sc, 0x1f, 0x0001);
21357                 MP_WritePhyUshort(sc, 0x17, 0x0CC0);
21358         } else if (sc->re_type == MACFG_28) {
21359                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21360                 MP_WritePhyUshort(sc, 0x14, MP_ReadPhyUshort(sc, 0x14) | BIT_5);
21361                 MP_WritePhyUshort(sc, 0x0d, MP_ReadPhyUshort(sc, 0x0d) | BIT_5);
21362
21363                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
21364                 MP_WritePhyUshort(sc, 0x14, 0xCAA3);
21365                 MP_WritePhyUshort(sc, 0x1C, 0x000A);
21366                 MP_WritePhyUshort(sc, 0x18, 0x65D0);
21367
21368                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
21369                 MP_WritePhyUshort(sc, 0x17, 0xB580);
21370                 MP_WritePhyUshort(sc, 0x18, 0xFF54);
21371                 MP_WritePhyUshort(sc, 0x19, 0x3954);
21372
21373                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21374                 MP_WritePhyUshort(sc, 0x0D, 0x310C);
21375                 MP_WritePhyUshort(sc, 0x0E, 0x310C);
21376                 MP_WritePhyUshort(sc, 0x0F, 0x311C);
21377                 MP_WritePhyUshort(sc, 0x06, 0x0761);
21378
21379                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
21380                 MP_WritePhyUshort(sc, 0x18, 0xFF55);
21381                 MP_WritePhyUshort(sc, 0x19, 0x3955);
21382                 MP_WritePhyUshort(sc, 0x18, 0xFF54);
21383                 MP_WritePhyUshort(sc, 0x19, 0x3954);
21384
21385                 MP_WritePhyUshort(sc, 0x1f, 0x0001);
21386                 MP_WritePhyUshort(sc, 0x17, 0x0CC0);
21387
21388                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21389                 MP_WritePhyUshort(sc, 0x16, MP_ReadPhyUshort(sc, 0x16) | BIT_0);
21390                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21391         } else if (sc->re_type == MACFG_31) {
21392                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
21393                 MP_WritePhyUshort(sc, 0x06, 0x4064);
21394                 MP_WritePhyUshort(sc, 0x07, 0x2863);
21395                 MP_WritePhyUshort(sc, 0x08, 0x059C);
21396                 MP_WritePhyUshort(sc, 0x09, 0x26B4);
21397                 MP_WritePhyUshort(sc, 0x0A, 0x6A19);
21398                 MP_WritePhyUshort(sc, 0x0B, 0xDCC8);
21399                 MP_WritePhyUshort(sc, 0x10, 0xF06D);
21400                 MP_WritePhyUshort(sc, 0x14, 0x7F68);
21401                 MP_WritePhyUshort(sc, 0x18, 0x7FD9);
21402                 MP_WritePhyUshort(sc, 0x1C, 0xF0FF);
21403                 MP_WritePhyUshort(sc, 0x1D, 0x3D9C);
21404                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
21405                 MP_WritePhyUshort(sc, 0x12, 0xF49F);
21406                 MP_WritePhyUshort(sc, 0x13, 0x070B);
21407                 MP_WritePhyUshort(sc, 0x1A, 0x05AD);
21408                 MP_WritePhyUshort(sc, 0x14, 0x94C0);
21409
21410                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21411                 Data = MP_ReadPhyUshort(sc, 0x0B) & 0xFF00;
21412                 Data |= 0x10;
21413                 MP_WritePhyUshort(sc, 0x0B, Data);
21414                 Data = MP_ReadPhyUshort(sc, 0x0C) & 0x00FF;
21415                 Data |= 0xA200;
21416                 MP_WritePhyUshort(sc, 0x0C, Data);
21417
21418                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21419                 MP_WritePhyUshort(sc, 0x06, 0x5561);
21420                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
21421                 MP_WritePhyUshort(sc, 0x05, 0x8332);
21422                 MP_WritePhyUshort(sc, 0x06, 0x5561);
21423
21424                 if (MP_ReadEfuse(sc, 0x01) == 0xb1) {
21425                         MP_WritePhyUshort(sc, 0x1F, 0x0002);
21426                         MP_WritePhyUshort(sc, 0x05, 0x669A);
21427                         MP_WritePhyUshort(sc, 0x1F, 0x0005);
21428                         MP_WritePhyUshort(sc, 0x05, 0x8330);
21429                         MP_WritePhyUshort(sc, 0x06, 0x669A);
21430
21431                         MP_WritePhyUshort(sc, 0x1F, 0x0002);
21432                         Data = MP_ReadPhyUshort(sc, 0x0D);
21433                         if ((Data & 0x00FF) != 0x006C) {
21434                                 Data &= 0xFF00;
21435                                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21436                                 MP_WritePhyUshort(sc, 0x0D, Data | 0x0065);
21437                                 MP_WritePhyUshort(sc, 0x0D, Data | 0x0066);
21438                                 MP_WritePhyUshort(sc, 0x0D, Data | 0x0067);
21439                                 MP_WritePhyUshort(sc, 0x0D, Data | 0x0068);
21440                                 MP_WritePhyUshort(sc, 0x0D, Data | 0x0069);
21441                                 MP_WritePhyUshort(sc, 0x0D, Data | 0x006A);
21442                                 MP_WritePhyUshort(sc, 0x0D, Data | 0x006B);
21443                                 MP_WritePhyUshort(sc, 0x0D, Data | 0x006C);
21444                         }
21445                 } else {
21446                         MP_WritePhyUshort(sc, 0x1F, 0x0002);
21447                         MP_WritePhyUshort(sc, 0x05, 0x6662);
21448                         MP_WritePhyUshort(sc, 0x1F, 0x0005);
21449                         MP_WritePhyUshort(sc, 0x05, 0x8330);
21450                         MP_WritePhyUshort(sc, 0x06, 0x6662);
21451                 }
21452
21453                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21454                 Data = MP_ReadPhyUshort(sc, 0x0D);
21455                 Data |= 0x300;
21456                 MP_WritePhyUshort(sc, 0x0D, Data);
21457                 Data = MP_ReadPhyUshort(sc, 0x0F);
21458                 Data |= 0x10;
21459                 MP_WritePhyUshort(sc, 0x0F, Data);
21460
21461                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21462                 Data = MP_ReadPhyUshort(sc, 0x02);
21463                 Data &= ~0x600;
21464                 Data |= 0x100;
21465                 MP_WritePhyUshort(sc, 0x02, Data);
21466                 Data = MP_ReadPhyUshort(sc, 0x03);
21467                 Data &= ~0xE000;
21468                 MP_WritePhyUshort(sc, 0x03, Data);
21469
21470                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
21471                 MP_WritePhyUshort(sc, 0x17, 0x0CC0);
21472
21473                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
21474                 MP_WritePhyUshort(sc, 0x05, 0x001B);
21475                 if (MP_ReadPhyUshort(sc, 0x06) == 0xBF00) {
21476                         MP_WritePhyUshort(sc, 0x1f, 0x0005);
21477                         MP_WritePhyUshort(sc, 0x05, 0xfff6);
21478                         MP_WritePhyUshort(sc, 0x06, 0x0080);
21479                         MP_WritePhyUshort(sc, 0x05, 0x8000);
21480                         MP_WritePhyUshort(sc, 0x06, 0xf8f9);
21481                         MP_WritePhyUshort(sc, 0x06, 0xfaef);
21482                         MP_WritePhyUshort(sc, 0x06, 0x59ee);
21483                         MP_WritePhyUshort(sc, 0x06, 0xf8ea);
21484                         MP_WritePhyUshort(sc, 0x06, 0x00ee);
21485                         MP_WritePhyUshort(sc, 0x06, 0xf8eb);
21486                         MP_WritePhyUshort(sc, 0x06, 0x00e0);
21487                         MP_WritePhyUshort(sc, 0x06, 0xf87c);
21488                         MP_WritePhyUshort(sc, 0x06, 0xe1f8);
21489                         MP_WritePhyUshort(sc, 0x06, 0x7d59);
21490                         MP_WritePhyUshort(sc, 0x06, 0x0fef);
21491                         MP_WritePhyUshort(sc, 0x06, 0x0139);
21492                         MP_WritePhyUshort(sc, 0x06, 0x029e);
21493                         MP_WritePhyUshort(sc, 0x06, 0x06ef);
21494                         MP_WritePhyUshort(sc, 0x06, 0x1039);
21495                         MP_WritePhyUshort(sc, 0x06, 0x089f);
21496                         MP_WritePhyUshort(sc, 0x06, 0x2aee);
21497                         MP_WritePhyUshort(sc, 0x06, 0xf8ea);
21498                         MP_WritePhyUshort(sc, 0x06, 0x00ee);
21499                         MP_WritePhyUshort(sc, 0x06, 0xf8eb);
21500                         MP_WritePhyUshort(sc, 0x06, 0x01e0);
21501                         MP_WritePhyUshort(sc, 0x06, 0xf87c);
21502                         MP_WritePhyUshort(sc, 0x06, 0xe1f8);
21503                         MP_WritePhyUshort(sc, 0x06, 0x7d58);
21504                         MP_WritePhyUshort(sc, 0x06, 0x409e);
21505                         MP_WritePhyUshort(sc, 0x06, 0x0f39);
21506                         MP_WritePhyUshort(sc, 0x06, 0x46aa);
21507                         MP_WritePhyUshort(sc, 0x06, 0x0bbf);
21508                         MP_WritePhyUshort(sc, 0x06, 0x8290);
21509                         MP_WritePhyUshort(sc, 0x06, 0xd682);
21510                         MP_WritePhyUshort(sc, 0x06, 0x9802);
21511                         MP_WritePhyUshort(sc, 0x06, 0x014f);
21512                         MP_WritePhyUshort(sc, 0x06, 0xae09);
21513                         MP_WritePhyUshort(sc, 0x06, 0xbf82);
21514                         MP_WritePhyUshort(sc, 0x06, 0x98d6);
21515                         MP_WritePhyUshort(sc, 0x06, 0x82a0);
21516                         MP_WritePhyUshort(sc, 0x06, 0x0201);
21517                         MP_WritePhyUshort(sc, 0x06, 0x4fef);
21518                         MP_WritePhyUshort(sc, 0x06, 0x95fe);
21519                         MP_WritePhyUshort(sc, 0x06, 0xfdfc);
21520                         MP_WritePhyUshort(sc, 0x06, 0x05f8);
21521                         MP_WritePhyUshort(sc, 0x06, 0xf9fa);
21522                         MP_WritePhyUshort(sc, 0x06, 0xeef8);
21523                         MP_WritePhyUshort(sc, 0x06, 0xea00);
21524                         MP_WritePhyUshort(sc, 0x06, 0xeef8);
21525                         MP_WritePhyUshort(sc, 0x06, 0xeb00);
21526                         MP_WritePhyUshort(sc, 0x06, 0xe2f8);
21527                         MP_WritePhyUshort(sc, 0x06, 0x7ce3);
21528                         MP_WritePhyUshort(sc, 0x06, 0xf87d);
21529                         MP_WritePhyUshort(sc, 0x06, 0xa511);
21530                         MP_WritePhyUshort(sc, 0x06, 0x1112);
21531                         MP_WritePhyUshort(sc, 0x06, 0xd240);
21532                         MP_WritePhyUshort(sc, 0x06, 0xd644);
21533                         MP_WritePhyUshort(sc, 0x06, 0x4402);
21534                         MP_WritePhyUshort(sc, 0x06, 0x8217);
21535                         MP_WritePhyUshort(sc, 0x06, 0xd2a0);
21536                         MP_WritePhyUshort(sc, 0x06, 0xd6aa);
21537                         MP_WritePhyUshort(sc, 0x06, 0xaa02);
21538                         MP_WritePhyUshort(sc, 0x06, 0x8217);
21539                         MP_WritePhyUshort(sc, 0x06, 0xae0f);
21540                         MP_WritePhyUshort(sc, 0x06, 0xa544);
21541                         MP_WritePhyUshort(sc, 0x06, 0x4402);
21542                         MP_WritePhyUshort(sc, 0x06, 0xae4d);
21543                         MP_WritePhyUshort(sc, 0x06, 0xa5aa);
21544                         MP_WritePhyUshort(sc, 0x06, 0xaa02);
21545                         MP_WritePhyUshort(sc, 0x06, 0xae47);
21546                         MP_WritePhyUshort(sc, 0x06, 0xaf82);
21547                         MP_WritePhyUshort(sc, 0x06, 0x13ee);
21548                         MP_WritePhyUshort(sc, 0x06, 0x834e);
21549                         MP_WritePhyUshort(sc, 0x06, 0x00ee);
21550                         MP_WritePhyUshort(sc, 0x06, 0x834d);
21551                         MP_WritePhyUshort(sc, 0x06, 0x0fee);
21552                         MP_WritePhyUshort(sc, 0x06, 0x834c);
21553                         MP_WritePhyUshort(sc, 0x06, 0x0fee);
21554                         MP_WritePhyUshort(sc, 0x06, 0x834f);
21555                         MP_WritePhyUshort(sc, 0x06, 0x00ee);
21556                         MP_WritePhyUshort(sc, 0x06, 0x8351);
21557                         MP_WritePhyUshort(sc, 0x06, 0x00ee);
21558                         MP_WritePhyUshort(sc, 0x06, 0x834a);
21559                         MP_WritePhyUshort(sc, 0x06, 0xffee);
21560                         MP_WritePhyUshort(sc, 0x06, 0x834b);
21561                         MP_WritePhyUshort(sc, 0x06, 0xffe0);
21562                         MP_WritePhyUshort(sc, 0x06, 0x8330);
21563                         MP_WritePhyUshort(sc, 0x06, 0xe183);
21564                         MP_WritePhyUshort(sc, 0x06, 0x3158);
21565                         MP_WritePhyUshort(sc, 0x06, 0xfee4);
21566                         MP_WritePhyUshort(sc, 0x06, 0xf88a);
21567                         MP_WritePhyUshort(sc, 0x06, 0xe5f8);
21568                         MP_WritePhyUshort(sc, 0x06, 0x8be0);
21569                         MP_WritePhyUshort(sc, 0x06, 0x8332);
21570                         MP_WritePhyUshort(sc, 0x06, 0xe183);
21571                         MP_WritePhyUshort(sc, 0x06, 0x3359);
21572                         MP_WritePhyUshort(sc, 0x06, 0x0fe2);
21573                         MP_WritePhyUshort(sc, 0x06, 0x834d);
21574                         MP_WritePhyUshort(sc, 0x06, 0x0c24);
21575                         MP_WritePhyUshort(sc, 0x06, 0x5af0);
21576                         MP_WritePhyUshort(sc, 0x06, 0x1e12);
21577                         MP_WritePhyUshort(sc, 0x06, 0xe4f8);
21578                         MP_WritePhyUshort(sc, 0x06, 0x8ce5);
21579                         MP_WritePhyUshort(sc, 0x06, 0xf88d);
21580                         MP_WritePhyUshort(sc, 0x06, 0xaf82);
21581                         MP_WritePhyUshort(sc, 0x06, 0x13e0);
21582                         MP_WritePhyUshort(sc, 0x06, 0x834f);
21583                         MP_WritePhyUshort(sc, 0x06, 0x10e4);
21584                         MP_WritePhyUshort(sc, 0x06, 0x834f);
21585                         MP_WritePhyUshort(sc, 0x06, 0xe083);
21586                         MP_WritePhyUshort(sc, 0x06, 0x4e78);
21587                         MP_WritePhyUshort(sc, 0x06, 0x009f);
21588                         MP_WritePhyUshort(sc, 0x06, 0x0ae0);
21589                         MP_WritePhyUshort(sc, 0x06, 0x834f);
21590                         MP_WritePhyUshort(sc, 0x06, 0xa010);
21591                         MP_WritePhyUshort(sc, 0x06, 0xa5ee);
21592                         MP_WritePhyUshort(sc, 0x06, 0x834e);
21593                         MP_WritePhyUshort(sc, 0x06, 0x01e0);
21594                         MP_WritePhyUshort(sc, 0x06, 0x834e);
21595                         MP_WritePhyUshort(sc, 0x06, 0x7805);
21596                         MP_WritePhyUshort(sc, 0x06, 0x9e9a);
21597                         MP_WritePhyUshort(sc, 0x06, 0xe083);
21598                         MP_WritePhyUshort(sc, 0x06, 0x4e78);
21599                         MP_WritePhyUshort(sc, 0x06, 0x049e);
21600                         MP_WritePhyUshort(sc, 0x06, 0x10e0);
21601                         MP_WritePhyUshort(sc, 0x06, 0x834e);
21602                         MP_WritePhyUshort(sc, 0x06, 0x7803);
21603                         MP_WritePhyUshort(sc, 0x06, 0x9e0f);
21604                         MP_WritePhyUshort(sc, 0x06, 0xe083);
21605                         MP_WritePhyUshort(sc, 0x06, 0x4e78);
21606                         MP_WritePhyUshort(sc, 0x06, 0x019e);
21607                         MP_WritePhyUshort(sc, 0x06, 0x05ae);
21608                         MP_WritePhyUshort(sc, 0x06, 0x0caf);
21609                         MP_WritePhyUshort(sc, 0x06, 0x81f8);
21610                         MP_WritePhyUshort(sc, 0x06, 0xaf81);
21611                         MP_WritePhyUshort(sc, 0x06, 0xa3af);
21612                         MP_WritePhyUshort(sc, 0x06, 0x81dc);
21613                         MP_WritePhyUshort(sc, 0x06, 0xaf82);
21614                         MP_WritePhyUshort(sc, 0x06, 0x13ee);
21615                         MP_WritePhyUshort(sc, 0x06, 0x8348);
21616                         MP_WritePhyUshort(sc, 0x06, 0x00ee);
21617                         MP_WritePhyUshort(sc, 0x06, 0x8349);
21618                         MP_WritePhyUshort(sc, 0x06, 0x00e0);
21619                         MP_WritePhyUshort(sc, 0x06, 0x8351);
21620                         MP_WritePhyUshort(sc, 0x06, 0x10e4);
21621                         MP_WritePhyUshort(sc, 0x06, 0x8351);
21622                         MP_WritePhyUshort(sc, 0x06, 0x5801);
21623                         MP_WritePhyUshort(sc, 0x06, 0x9fea);
21624                         MP_WritePhyUshort(sc, 0x06, 0xd000);
21625                         MP_WritePhyUshort(sc, 0x06, 0xd180);
21626                         MP_WritePhyUshort(sc, 0x06, 0x1f66);
21627                         MP_WritePhyUshort(sc, 0x06, 0xe2f8);
21628                         MP_WritePhyUshort(sc, 0x06, 0xeae3);
21629                         MP_WritePhyUshort(sc, 0x06, 0xf8eb);
21630                         MP_WritePhyUshort(sc, 0x06, 0x5af8);
21631                         MP_WritePhyUshort(sc, 0x06, 0x1e20);
21632                         MP_WritePhyUshort(sc, 0x06, 0xe6f8);
21633                         MP_WritePhyUshort(sc, 0x06, 0xeae5);
21634                         MP_WritePhyUshort(sc, 0x06, 0xf8eb);
21635                         MP_WritePhyUshort(sc, 0x06, 0xd302);
21636                         MP_WritePhyUshort(sc, 0x06, 0xb3fe);
21637                         MP_WritePhyUshort(sc, 0x06, 0xe2f8);
21638                         MP_WritePhyUshort(sc, 0x06, 0x7cef);
21639                         MP_WritePhyUshort(sc, 0x06, 0x325b);
21640                         MP_WritePhyUshort(sc, 0x06, 0x80e3);
21641                         MP_WritePhyUshort(sc, 0x06, 0xf87d);
21642                         MP_WritePhyUshort(sc, 0x06, 0x9e03);
21643                         MP_WritePhyUshort(sc, 0x06, 0x7dff);
21644                         MP_WritePhyUshort(sc, 0x06, 0xff0d);
21645                         MP_WritePhyUshort(sc, 0x06, 0x581c);
21646                         MP_WritePhyUshort(sc, 0x06, 0x551a);
21647                         MP_WritePhyUshort(sc, 0x06, 0x6511);
21648                         MP_WritePhyUshort(sc, 0x06, 0xa190);
21649                         MP_WritePhyUshort(sc, 0x06, 0xd3e2);
21650                         MP_WritePhyUshort(sc, 0x06, 0x8348);
21651                         MP_WritePhyUshort(sc, 0x06, 0xe383);
21652                         MP_WritePhyUshort(sc, 0x06, 0x491b);
21653                         MP_WritePhyUshort(sc, 0x06, 0x56ab);
21654                         MP_WritePhyUshort(sc, 0x06, 0x08ef);
21655                         MP_WritePhyUshort(sc, 0x06, 0x56e6);
21656                         MP_WritePhyUshort(sc, 0x06, 0x8348);
21657                         MP_WritePhyUshort(sc, 0x06, 0xe783);
21658                         MP_WritePhyUshort(sc, 0x06, 0x4910);
21659                         MP_WritePhyUshort(sc, 0x06, 0xd180);
21660                         MP_WritePhyUshort(sc, 0x06, 0x1f66);
21661                         MP_WritePhyUshort(sc, 0x06, 0xa004);
21662                         MP_WritePhyUshort(sc, 0x06, 0xb9e2);
21663                         MP_WritePhyUshort(sc, 0x06, 0x8348);
21664                         MP_WritePhyUshort(sc, 0x06, 0xe383);
21665                         MP_WritePhyUshort(sc, 0x06, 0x49ef);
21666                         MP_WritePhyUshort(sc, 0x06, 0x65e2);
21667                         MP_WritePhyUshort(sc, 0x06, 0x834a);
21668                         MP_WritePhyUshort(sc, 0x06, 0xe383);
21669                         MP_WritePhyUshort(sc, 0x06, 0x4b1b);
21670                         MP_WritePhyUshort(sc, 0x06, 0x56aa);
21671                         MP_WritePhyUshort(sc, 0x06, 0x0eef);
21672                         MP_WritePhyUshort(sc, 0x06, 0x56e6);
21673                         MP_WritePhyUshort(sc, 0x06, 0x834a);
21674                         MP_WritePhyUshort(sc, 0x06, 0xe783);
21675                         MP_WritePhyUshort(sc, 0x06, 0x4be2);
21676                         MP_WritePhyUshort(sc, 0x06, 0x834d);
21677                         MP_WritePhyUshort(sc, 0x06, 0xe683);
21678                         MP_WritePhyUshort(sc, 0x06, 0x4ce0);
21679                         MP_WritePhyUshort(sc, 0x06, 0x834d);
21680                         MP_WritePhyUshort(sc, 0x06, 0xa000);
21681                         MP_WritePhyUshort(sc, 0x06, 0x0caf);
21682                         MP_WritePhyUshort(sc, 0x06, 0x81dc);
21683                         MP_WritePhyUshort(sc, 0x06, 0xe083);
21684                         MP_WritePhyUshort(sc, 0x06, 0x4d10);
21685                         MP_WritePhyUshort(sc, 0x06, 0xe483);
21686                         MP_WritePhyUshort(sc, 0x06, 0x4dae);
21687                         MP_WritePhyUshort(sc, 0x06, 0x0480);
21688                         MP_WritePhyUshort(sc, 0x06, 0xe483);
21689                         MP_WritePhyUshort(sc, 0x06, 0x4de0);
21690                         MP_WritePhyUshort(sc, 0x06, 0x834e);
21691                         MP_WritePhyUshort(sc, 0x06, 0x7803);
21692                         MP_WritePhyUshort(sc, 0x06, 0x9e0b);
21693                         MP_WritePhyUshort(sc, 0x06, 0xe083);
21694                         MP_WritePhyUshort(sc, 0x06, 0x4e78);
21695                         MP_WritePhyUshort(sc, 0x06, 0x049e);
21696                         MP_WritePhyUshort(sc, 0x06, 0x04ee);
21697                         MP_WritePhyUshort(sc, 0x06, 0x834e);
21698                         MP_WritePhyUshort(sc, 0x06, 0x02e0);
21699                         MP_WritePhyUshort(sc, 0x06, 0x8332);
21700                         MP_WritePhyUshort(sc, 0x06, 0xe183);
21701                         MP_WritePhyUshort(sc, 0x06, 0x3359);
21702                         MP_WritePhyUshort(sc, 0x06, 0x0fe2);
21703                         MP_WritePhyUshort(sc, 0x06, 0x834d);
21704                         MP_WritePhyUshort(sc, 0x06, 0x0c24);
21705                         MP_WritePhyUshort(sc, 0x06, 0x5af0);
21706                         MP_WritePhyUshort(sc, 0x06, 0x1e12);
21707                         MP_WritePhyUshort(sc, 0x06, 0xe4f8);
21708                         MP_WritePhyUshort(sc, 0x06, 0x8ce5);
21709                         MP_WritePhyUshort(sc, 0x06, 0xf88d);
21710                         MP_WritePhyUshort(sc, 0x06, 0xe083);
21711                         MP_WritePhyUshort(sc, 0x06, 0x30e1);
21712                         MP_WritePhyUshort(sc, 0x06, 0x8331);
21713                         MP_WritePhyUshort(sc, 0x06, 0x6801);
21714                         MP_WritePhyUshort(sc, 0x06, 0xe4f8);
21715                         MP_WritePhyUshort(sc, 0x06, 0x8ae5);
21716                         MP_WritePhyUshort(sc, 0x06, 0xf88b);
21717                         MP_WritePhyUshort(sc, 0x06, 0xae37);
21718                         MP_WritePhyUshort(sc, 0x06, 0xee83);
21719                         MP_WritePhyUshort(sc, 0x06, 0x4e03);
21720                         MP_WritePhyUshort(sc, 0x06, 0xe083);
21721                         MP_WritePhyUshort(sc, 0x06, 0x4ce1);
21722                         MP_WritePhyUshort(sc, 0x06, 0x834d);
21723                         MP_WritePhyUshort(sc, 0x06, 0x1b01);
21724                         MP_WritePhyUshort(sc, 0x06, 0x9e04);
21725                         MP_WritePhyUshort(sc, 0x06, 0xaaa1);
21726                         MP_WritePhyUshort(sc, 0x06, 0xaea8);
21727                         MP_WritePhyUshort(sc, 0x06, 0xee83);
21728                         MP_WritePhyUshort(sc, 0x06, 0x4e04);
21729                         MP_WritePhyUshort(sc, 0x06, 0xee83);
21730                         MP_WritePhyUshort(sc, 0x06, 0x4f00);
21731                         MP_WritePhyUshort(sc, 0x06, 0xaeab);
21732                         MP_WritePhyUshort(sc, 0x06, 0xe083);
21733                         MP_WritePhyUshort(sc, 0x06, 0x4f78);
21734                         MP_WritePhyUshort(sc, 0x06, 0x039f);
21735                         MP_WritePhyUshort(sc, 0x06, 0x14ee);
21736                         MP_WritePhyUshort(sc, 0x06, 0x834e);
21737                         MP_WritePhyUshort(sc, 0x06, 0x05d2);
21738                         MP_WritePhyUshort(sc, 0x06, 0x40d6);
21739                         MP_WritePhyUshort(sc, 0x06, 0x5554);
21740                         MP_WritePhyUshort(sc, 0x06, 0x0282);
21741                         MP_WritePhyUshort(sc, 0x06, 0x17d2);
21742                         MP_WritePhyUshort(sc, 0x06, 0xa0d6);
21743                         MP_WritePhyUshort(sc, 0x06, 0xba00);
21744                         MP_WritePhyUshort(sc, 0x06, 0x0282);
21745                         MP_WritePhyUshort(sc, 0x06, 0x17fe);
21746                         MP_WritePhyUshort(sc, 0x06, 0xfdfc);
21747                         MP_WritePhyUshort(sc, 0x06, 0x05f8);
21748                         MP_WritePhyUshort(sc, 0x06, 0xe0f8);
21749                         MP_WritePhyUshort(sc, 0x06, 0x60e1);
21750                         MP_WritePhyUshort(sc, 0x06, 0xf861);
21751                         MP_WritePhyUshort(sc, 0x06, 0x6802);
21752                         MP_WritePhyUshort(sc, 0x06, 0xe4f8);
21753                         MP_WritePhyUshort(sc, 0x06, 0x60e5);
21754                         MP_WritePhyUshort(sc, 0x06, 0xf861);
21755                         MP_WritePhyUshort(sc, 0x06, 0xe0f8);
21756                         MP_WritePhyUshort(sc, 0x06, 0x48e1);
21757                         MP_WritePhyUshort(sc, 0x06, 0xf849);
21758                         MP_WritePhyUshort(sc, 0x06, 0x580f);
21759                         MP_WritePhyUshort(sc, 0x06, 0x1e02);
21760                         MP_WritePhyUshort(sc, 0x06, 0xe4f8);
21761                         MP_WritePhyUshort(sc, 0x06, 0x48e5);
21762                         MP_WritePhyUshort(sc, 0x06, 0xf849);
21763                         MP_WritePhyUshort(sc, 0x06, 0xd000);
21764                         MP_WritePhyUshort(sc, 0x06, 0x0282);
21765                         MP_WritePhyUshort(sc, 0x06, 0x5bbf);
21766                         MP_WritePhyUshort(sc, 0x06, 0x8350);
21767                         MP_WritePhyUshort(sc, 0x06, 0xef46);
21768                         MP_WritePhyUshort(sc, 0x06, 0xdc19);
21769                         MP_WritePhyUshort(sc, 0x06, 0xddd0);
21770                         MP_WritePhyUshort(sc, 0x06, 0x0102);
21771                         MP_WritePhyUshort(sc, 0x06, 0x825b);
21772                         MP_WritePhyUshort(sc, 0x06, 0x0282);
21773                         MP_WritePhyUshort(sc, 0x06, 0x77e0);
21774                         MP_WritePhyUshort(sc, 0x06, 0xf860);
21775                         MP_WritePhyUshort(sc, 0x06, 0xe1f8);
21776                         MP_WritePhyUshort(sc, 0x06, 0x6158);
21777                         MP_WritePhyUshort(sc, 0x06, 0xfde4);
21778                         MP_WritePhyUshort(sc, 0x06, 0xf860);
21779                         MP_WritePhyUshort(sc, 0x06, 0xe5f8);
21780                         MP_WritePhyUshort(sc, 0x06, 0x61fc);
21781                         MP_WritePhyUshort(sc, 0x06, 0x04f9);
21782                         MP_WritePhyUshort(sc, 0x06, 0xfafb);
21783                         MP_WritePhyUshort(sc, 0x06, 0xc6bf);
21784                         MP_WritePhyUshort(sc, 0x06, 0xf840);
21785                         MP_WritePhyUshort(sc, 0x06, 0xbe83);
21786                         MP_WritePhyUshort(sc, 0x06, 0x50a0);
21787                         MP_WritePhyUshort(sc, 0x06, 0x0101);
21788                         MP_WritePhyUshort(sc, 0x06, 0x071b);
21789                         MP_WritePhyUshort(sc, 0x06, 0x89cf);
21790                         MP_WritePhyUshort(sc, 0x06, 0xd208);
21791                         MP_WritePhyUshort(sc, 0x06, 0xebdb);
21792                         MP_WritePhyUshort(sc, 0x06, 0x19b2);
21793                         MP_WritePhyUshort(sc, 0x06, 0xfbff);
21794                         MP_WritePhyUshort(sc, 0x06, 0xfefd);
21795                         MP_WritePhyUshort(sc, 0x06, 0x04f8);
21796                         MP_WritePhyUshort(sc, 0x06, 0xe0f8);
21797                         MP_WritePhyUshort(sc, 0x06, 0x48e1);
21798                         MP_WritePhyUshort(sc, 0x06, 0xf849);
21799                         MP_WritePhyUshort(sc, 0x06, 0x6808);
21800                         MP_WritePhyUshort(sc, 0x06, 0xe4f8);
21801                         MP_WritePhyUshort(sc, 0x06, 0x48e5);
21802                         MP_WritePhyUshort(sc, 0x06, 0xf849);
21803                         MP_WritePhyUshort(sc, 0x06, 0x58f7);
21804                         MP_WritePhyUshort(sc, 0x06, 0xe4f8);
21805                         MP_WritePhyUshort(sc, 0x06, 0x48e5);
21806                         MP_WritePhyUshort(sc, 0x06, 0xf849);
21807                         MP_WritePhyUshort(sc, 0x06, 0xfc04);
21808                         MP_WritePhyUshort(sc, 0x06, 0x4d20);
21809                         MP_WritePhyUshort(sc, 0x06, 0x0002);
21810                         MP_WritePhyUshort(sc, 0x06, 0x4e22);
21811                         MP_WritePhyUshort(sc, 0x06, 0x0002);
21812                         MP_WritePhyUshort(sc, 0x06, 0x4ddf);
21813                         MP_WritePhyUshort(sc, 0x06, 0xff01);
21814                         MP_WritePhyUshort(sc, 0x06, 0x4edd);
21815                         MP_WritePhyUshort(sc, 0x06, 0xff01);
21816                         MP_WritePhyUshort(sc, 0x06, 0xf8fa);
21817                         MP_WritePhyUshort(sc, 0x06, 0xfbef);
21818                         MP_WritePhyUshort(sc, 0x06, 0x79bf);
21819                         MP_WritePhyUshort(sc, 0x06, 0xf822);
21820                         MP_WritePhyUshort(sc, 0x06, 0xd819);
21821                         MP_WritePhyUshort(sc, 0x06, 0xd958);
21822                         MP_WritePhyUshort(sc, 0x06, 0x849f);
21823                         MP_WritePhyUshort(sc, 0x06, 0x09bf);
21824                         MP_WritePhyUshort(sc, 0x06, 0x82be);
21825                         MP_WritePhyUshort(sc, 0x06, 0xd682);
21826                         MP_WritePhyUshort(sc, 0x06, 0xc602);
21827                         MP_WritePhyUshort(sc, 0x06, 0x014f);
21828                         MP_WritePhyUshort(sc, 0x06, 0xef97);
21829                         MP_WritePhyUshort(sc, 0x06, 0xfffe);
21830                         MP_WritePhyUshort(sc, 0x06, 0xfc05);
21831                         MP_WritePhyUshort(sc, 0x06, 0x17ff);
21832                         MP_WritePhyUshort(sc, 0x06, 0xfe01);
21833                         MP_WritePhyUshort(sc, 0x06, 0x1700);
21834                         MP_WritePhyUshort(sc, 0x06, 0x0102);
21835                         MP_WritePhyUshort(sc, 0x05, 0x83d8);
21836                         MP_WritePhyUshort(sc, 0x06, 0x8051);
21837                         MP_WritePhyUshort(sc, 0x05, 0x83d6);
21838                         MP_WritePhyUshort(sc, 0x06, 0x82a0);
21839                         MP_WritePhyUshort(sc, 0x05, 0x83d4);
21840                         MP_WritePhyUshort(sc, 0x06, 0x8000);
21841                         MP_WritePhyUshort(sc, 0x02, 0x2010);
21842                         MP_WritePhyUshort(sc, 0x03, 0xdc00);
21843                         MP_WritePhyUshort(sc, 0x1f, 0x0000);
21844                         MP_WritePhyUshort(sc, 0x0b, 0x0600);
21845                         MP_WritePhyUshort(sc, 0x1f, 0x0005);
21846                         MP_WritePhyUshort(sc, 0x05, 0xfff6);
21847                         MP_WritePhyUshort(sc, 0x06, 0x00fc);
21848                         MP_WritePhyUshort(sc, 0x1f, 0x0000);
21849                 }
21850
21851                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21852                 MP_WritePhyUshort(sc, 0x0D, 0xF880);
21853                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21854         } else if (sc->re_type == MACFG_32) {
21855                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
21856                 MP_WritePhyUshort(sc, 0x06, 0x4064);
21857                 MP_WritePhyUshort(sc, 0x07, 0x2863);
21858                 MP_WritePhyUshort(sc, 0x08, 0x059C);
21859                 MP_WritePhyUshort(sc, 0x09, 0x26B4);
21860                 MP_WritePhyUshort(sc, 0x0A, 0x6A19);
21861                 MP_WritePhyUshort(sc, 0x0B, 0xBCC0);
21862                 MP_WritePhyUshort(sc, 0x10, 0xF06D);
21863                 MP_WritePhyUshort(sc, 0x14, 0x7F68);
21864                 MP_WritePhyUshort(sc, 0x18, 0x7FD9);
21865                 MP_WritePhyUshort(sc, 0x1C, 0xF0FF);
21866                 MP_WritePhyUshort(sc, 0x1D, 0x3D9C);
21867                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
21868                 MP_WritePhyUshort(sc, 0x12, 0xF49F);
21869                 MP_WritePhyUshort(sc, 0x13, 0x070B);
21870                 MP_WritePhyUshort(sc, 0x1A, 0x05AD);
21871                 MP_WritePhyUshort(sc, 0x14, 0x94C0);
21872
21873                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21874                 MP_WritePhyUshort(sc, 0x06, 0x5571);
21875
21876                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21877                 MP_WritePhyUshort(sc, 0x05, 0x2642);
21878
21879                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21880                 MP_WritePhyUshort(sc, 0x02, 0xC107);
21881                 MP_WritePhyUshort(sc, 0x03, 0x1002);
21882
21883                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
21884                 MP_WritePhyUshort(sc, 0x16, 0x0CC0);
21885
21886                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21887                 MP_WritePhyUshort(sc, 0x0F, 0x0017);
21888
21889                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
21890                 MP_WritePhyUshort(sc, 0x05, 0x8200);
21891                 MP_WritePhyUshort(sc, 0x06, 0xF8F9);
21892                 MP_WritePhyUshort(sc, 0x06, 0xFAEF);
21893                 MP_WritePhyUshort(sc, 0x06, 0x59EE);
21894                 MP_WritePhyUshort(sc, 0x06, 0xF8EA);
21895                 MP_WritePhyUshort(sc, 0x06, 0x00EE);
21896                 MP_WritePhyUshort(sc, 0x06, 0xF8EB);
21897                 MP_WritePhyUshort(sc, 0x06, 0x00E0);
21898                 MP_WritePhyUshort(sc, 0x06, 0xF87C);
21899                 MP_WritePhyUshort(sc, 0x06, 0xE1F8);
21900                 MP_WritePhyUshort(sc, 0x06, 0x7D59);
21901                 MP_WritePhyUshort(sc, 0x06, 0x0FEF);
21902                 MP_WritePhyUshort(sc, 0x06, 0x0139);
21903                 MP_WritePhyUshort(sc, 0x06, 0x029E);
21904                 MP_WritePhyUshort(sc, 0x06, 0x06EF);
21905                 MP_WritePhyUshort(sc, 0x06, 0x1039);
21906                 MP_WritePhyUshort(sc, 0x06, 0x089F);
21907                 MP_WritePhyUshort(sc, 0x06, 0x2AEE);
21908                 MP_WritePhyUshort(sc, 0x06, 0xF8EA);
21909                 MP_WritePhyUshort(sc, 0x06, 0x00EE);
21910                 MP_WritePhyUshort(sc, 0x06, 0xF8EB);
21911                 MP_WritePhyUshort(sc, 0x06, 0x01E0);
21912                 MP_WritePhyUshort(sc, 0x06, 0xF87C);
21913                 MP_WritePhyUshort(sc, 0x06, 0xE1F8);
21914                 MP_WritePhyUshort(sc, 0x06, 0x7D58);
21915                 MP_WritePhyUshort(sc, 0x06, 0x409E);
21916                 MP_WritePhyUshort(sc, 0x06, 0x0F39);
21917                 MP_WritePhyUshort(sc, 0x06, 0x46AA);
21918                 MP_WritePhyUshort(sc, 0x06, 0x0BBF);
21919                 MP_WritePhyUshort(sc, 0x06, 0x8251);
21920                 MP_WritePhyUshort(sc, 0x06, 0xD682);
21921                 MP_WritePhyUshort(sc, 0x06, 0x5902);
21922                 MP_WritePhyUshort(sc, 0x06, 0x014F);
21923                 MP_WritePhyUshort(sc, 0x06, 0xAE09);
21924                 MP_WritePhyUshort(sc, 0x06, 0xBF82);
21925                 MP_WritePhyUshort(sc, 0x06, 0x59D6);
21926                 MP_WritePhyUshort(sc, 0x06, 0x8261);
21927                 MP_WritePhyUshort(sc, 0x06, 0x0201);
21928                 MP_WritePhyUshort(sc, 0x06, 0x4FEF);
21929                 MP_WritePhyUshort(sc, 0x06, 0x95FE);
21930                 MP_WritePhyUshort(sc, 0x06, 0xFDFC);
21931                 MP_WritePhyUshort(sc, 0x06, 0x054D);
21932                 MP_WritePhyUshort(sc, 0x06, 0x2000);
21933                 MP_WritePhyUshort(sc, 0x06, 0x024E);
21934                 MP_WritePhyUshort(sc, 0x06, 0x2200);
21935                 MP_WritePhyUshort(sc, 0x06, 0x024D);
21936                 MP_WritePhyUshort(sc, 0x06, 0xDFFF);
21937                 MP_WritePhyUshort(sc, 0x06, 0x014E);
21938                 MP_WritePhyUshort(sc, 0x06, 0xDDFF);
21939                 MP_WritePhyUshort(sc, 0x06, 0x0100);
21940                 MP_WritePhyUshort(sc, 0x02, 0x6010);
21941                 MP_WritePhyUshort(sc, 0x05, 0xFFF6);
21942                 MP_WritePhyUshort(sc, 0x06, 0x00EC);
21943                 MP_WritePhyUshort(sc, 0x05, 0x83D4);
21944                 MP_WritePhyUshort(sc, 0x06, 0x8200);
21945
21946         } else if (sc->re_type == MACFG_33) {
21947                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
21948                 MP_WritePhyUshort(sc, 0x06, 0x4064);
21949                 MP_WritePhyUshort(sc, 0x07, 0x2863);
21950                 MP_WritePhyUshort(sc, 0x08, 0x059C);
21951                 MP_WritePhyUshort(sc, 0x09, 0x26B4);
21952                 MP_WritePhyUshort(sc, 0x0A, 0x6A19);
21953                 MP_WritePhyUshort(sc, 0x0B, 0xDCC8);
21954                 MP_WritePhyUshort(sc, 0x10, 0xF06D);
21955                 MP_WritePhyUshort(sc, 0x14, 0x7F68);
21956                 MP_WritePhyUshort(sc, 0x18, 0x7FD9);
21957                 MP_WritePhyUshort(sc, 0x1C, 0xF0FF);
21958                 MP_WritePhyUshort(sc, 0x1D, 0x3D9C);
21959                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
21960                 MP_WritePhyUshort(sc, 0x12, 0xF49F);
21961                 MP_WritePhyUshort(sc, 0x13, 0x070B);
21962                 MP_WritePhyUshort(sc, 0x1A, 0x05AD);
21963                 MP_WritePhyUshort(sc, 0x14, 0x94C0);
21964
21965                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21966                 MP_WritePhyUshort(sc, 0x06, 0x5561);
21967                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
21968                 MP_WritePhyUshort(sc, 0x05, 0x8332);
21969                 MP_WritePhyUshort(sc, 0x06, 0x5561);
21970
21971                 if (MP_ReadEfuse(sc, 0x01) == 0xb1) {
21972                         MP_WritePhyUshort(sc, 0x1F, 0x0002);
21973                         MP_WritePhyUshort(sc, 0x05, 0x669A);
21974                         MP_WritePhyUshort(sc, 0x1F, 0x0005);
21975                         MP_WritePhyUshort(sc, 0x05, 0x8330);
21976                         MP_WritePhyUshort(sc, 0x06, 0x669A);
21977
21978                         MP_WritePhyUshort(sc, 0x1F, 0x0002);
21979                         Data = MP_ReadPhyUshort(sc, 0x0D);
21980                         if ((Data & 0x00FF) != 0x006C) {
21981                                 Data &= 0xFF00;
21982                                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21983                                 MP_WritePhyUshort(sc, 0x0D, Data | 0x0065);
21984                                 MP_WritePhyUshort(sc, 0x0D, Data | 0x0066);
21985                                 MP_WritePhyUshort(sc, 0x0D, Data | 0x0067);
21986                                 MP_WritePhyUshort(sc, 0x0D, Data | 0x0068);
21987                                 MP_WritePhyUshort(sc, 0x0D, Data | 0x0069);
21988                                 MP_WritePhyUshort(sc, 0x0D, Data | 0x006A);
21989                                 MP_WritePhyUshort(sc, 0x0D, Data | 0x006B);
21990                                 MP_WritePhyUshort(sc, 0x0D, Data | 0x006C);
21991                         }
21992                 } else {
21993                         MP_WritePhyUshort(sc, 0x1F, 0x0002);
21994                         MP_WritePhyUshort(sc, 0x05, 0x2642);
21995                         MP_WritePhyUshort(sc, 0x1F, 0x0005);
21996                         MP_WritePhyUshort(sc, 0x05, 0x8330);
21997                         MP_WritePhyUshort(sc, 0x06, 0x2642);
21998                 }
21999
22000                 if (MP_ReadEfuse(sc, 0x30) == 0x98) {
22001                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
22002                         MP_WritePhyUshort(sc, 0x11, MP_ReadPhyUshort(sc, 0x11) & ~0x02);
22003                         MP_WritePhyUshort(sc, 0x1F, 0x0005);
22004                         MP_WritePhyUshort(sc, 0x01, MP_ReadPhyUshort(sc, 0x01) | 0x200);
22005                 } else if (MP_ReadEfuse(sc, 0x30) == 0x90) {
22006                         MP_WritePhyUshort(sc, 0x1F, 0x0005);
22007                         MP_WritePhyUshort(sc, 0x01, MP_ReadPhyUshort(sc, 0x01) & ~0x200);
22008                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
22009                         MP_WritePhyUshort(sc, 0x16, 0x5101);
22010                 }
22011
22012                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
22013                 Data = MP_ReadPhyUshort(sc, 0x02);
22014                 Data &= ~0x600;
22015                 Data |= 0x100;
22016                 MP_WritePhyUshort(sc, 0x02, Data);
22017                 Data = MP_ReadPhyUshort(sc, 0x03);
22018                 Data &= ~0xE000;
22019                 MP_WritePhyUshort(sc, 0x03, Data);
22020
22021                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
22022                 MP_WritePhyUshort(sc, 0x17, 0x0CC0);
22023
22024                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
22025                 Data = MP_ReadPhyUshort(sc, 0x0F);
22026                 Data |= 0x17;
22027                 MP_WritePhyUshort(sc, 0x0F, Data);
22028
22029                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
22030                 MP_WritePhyUshort(sc, 0x05, 0x001B);
22031                 if (MP_ReadPhyUshort(sc, 0x06) == 0xB300) {
22032                         MP_WritePhyUshort(sc, 0x1f, 0x0005);
22033                         MP_WritePhyUshort(sc, 0x05, 0xfff6);
22034                         MP_WritePhyUshort(sc, 0x06, 0x0080);
22035                         MP_WritePhyUshort(sc, 0x05, 0x8000);
22036                         MP_WritePhyUshort(sc, 0x06, 0xf8f9);
22037                         MP_WritePhyUshort(sc, 0x06, 0xfaee);
22038                         MP_WritePhyUshort(sc, 0x06, 0xf8ea);
22039                         MP_WritePhyUshort(sc, 0x06, 0x00ee);
22040                         MP_WritePhyUshort(sc, 0x06, 0xf8eb);
22041                         MP_WritePhyUshort(sc, 0x06, 0x00e2);
22042                         MP_WritePhyUshort(sc, 0x06, 0xf87c);
22043                         MP_WritePhyUshort(sc, 0x06, 0xe3f8);
22044                         MP_WritePhyUshort(sc, 0x06, 0x7da5);
22045                         MP_WritePhyUshort(sc, 0x06, 0x1111);
22046                         MP_WritePhyUshort(sc, 0x06, 0x12d2);
22047                         MP_WritePhyUshort(sc, 0x06, 0x40d6);
22048                         MP_WritePhyUshort(sc, 0x06, 0x4444);
22049                         MP_WritePhyUshort(sc, 0x06, 0x0281);
22050                         MP_WritePhyUshort(sc, 0x06, 0xc6d2);
22051                         MP_WritePhyUshort(sc, 0x06, 0xa0d6);
22052                         MP_WritePhyUshort(sc, 0x06, 0xaaaa);
22053                         MP_WritePhyUshort(sc, 0x06, 0x0281);
22054                         MP_WritePhyUshort(sc, 0x06, 0xc6ae);
22055                         MP_WritePhyUshort(sc, 0x06, 0x0fa5);
22056                         MP_WritePhyUshort(sc, 0x06, 0x4444);
22057                         MP_WritePhyUshort(sc, 0x06, 0x02ae);
22058                         MP_WritePhyUshort(sc, 0x06, 0x4da5);
22059                         MP_WritePhyUshort(sc, 0x06, 0xaaaa);
22060                         MP_WritePhyUshort(sc, 0x06, 0x02ae);
22061                         MP_WritePhyUshort(sc, 0x06, 0x47af);
22062                         MP_WritePhyUshort(sc, 0x06, 0x81c2);
22063                         MP_WritePhyUshort(sc, 0x06, 0xee83);
22064                         MP_WritePhyUshort(sc, 0x06, 0x4e00);
22065                         MP_WritePhyUshort(sc, 0x06, 0xee83);
22066                         MP_WritePhyUshort(sc, 0x06, 0x4d0f);
22067                         MP_WritePhyUshort(sc, 0x06, 0xee83);
22068                         MP_WritePhyUshort(sc, 0x06, 0x4c0f);
22069                         MP_WritePhyUshort(sc, 0x06, 0xee83);
22070                         MP_WritePhyUshort(sc, 0x06, 0x4f00);
22071                         MP_WritePhyUshort(sc, 0x06, 0xee83);
22072                         MP_WritePhyUshort(sc, 0x06, 0x5100);
22073                         MP_WritePhyUshort(sc, 0x06, 0xee83);
22074                         MP_WritePhyUshort(sc, 0x06, 0x4aff);
22075                         MP_WritePhyUshort(sc, 0x06, 0xee83);
22076                         MP_WritePhyUshort(sc, 0x06, 0x4bff);
22077                         MP_WritePhyUshort(sc, 0x06, 0xe083);
22078                         MP_WritePhyUshort(sc, 0x06, 0x30e1);
22079                         MP_WritePhyUshort(sc, 0x06, 0x8331);
22080                         MP_WritePhyUshort(sc, 0x06, 0x58fe);
22081                         MP_WritePhyUshort(sc, 0x06, 0xe4f8);
22082                         MP_WritePhyUshort(sc, 0x06, 0x8ae5);
22083                         MP_WritePhyUshort(sc, 0x06, 0xf88b);
22084                         MP_WritePhyUshort(sc, 0x06, 0xe083);
22085                         MP_WritePhyUshort(sc, 0x06, 0x32e1);
22086                         MP_WritePhyUshort(sc, 0x06, 0x8333);
22087                         MP_WritePhyUshort(sc, 0x06, 0x590f);
22088                         MP_WritePhyUshort(sc, 0x06, 0xe283);
22089                         MP_WritePhyUshort(sc, 0x06, 0x4d0c);
22090                         MP_WritePhyUshort(sc, 0x06, 0x245a);
22091                         MP_WritePhyUshort(sc, 0x06, 0xf01e);
22092                         MP_WritePhyUshort(sc, 0x06, 0x12e4);
22093                         MP_WritePhyUshort(sc, 0x06, 0xf88c);
22094                         MP_WritePhyUshort(sc, 0x06, 0xe5f8);
22095                         MP_WritePhyUshort(sc, 0x06, 0x8daf);
22096                         MP_WritePhyUshort(sc, 0x06, 0x81c2);
22097                         MP_WritePhyUshort(sc, 0x06, 0xe083);
22098                         MP_WritePhyUshort(sc, 0x06, 0x4f10);
22099                         MP_WritePhyUshort(sc, 0x06, 0xe483);
22100                         MP_WritePhyUshort(sc, 0x06, 0x4fe0);
22101                         MP_WritePhyUshort(sc, 0x06, 0x834e);
22102                         MP_WritePhyUshort(sc, 0x06, 0x7800);
22103                         MP_WritePhyUshort(sc, 0x06, 0x9f0a);
22104                         MP_WritePhyUshort(sc, 0x06, 0xe083);
22105                         MP_WritePhyUshort(sc, 0x06, 0x4fa0);
22106                         MP_WritePhyUshort(sc, 0x06, 0x10a5);
22107                         MP_WritePhyUshort(sc, 0x06, 0xee83);
22108                         MP_WritePhyUshort(sc, 0x06, 0x4e01);
22109                         MP_WritePhyUshort(sc, 0x06, 0xe083);
22110                         MP_WritePhyUshort(sc, 0x06, 0x4e78);
22111                         MP_WritePhyUshort(sc, 0x06, 0x059e);
22112                         MP_WritePhyUshort(sc, 0x06, 0x9ae0);
22113                         MP_WritePhyUshort(sc, 0x06, 0x834e);
22114                         MP_WritePhyUshort(sc, 0x06, 0x7804);
22115                         MP_WritePhyUshort(sc, 0x06, 0x9e10);
22116                         MP_WritePhyUshort(sc, 0x06, 0xe083);
22117                         MP_WritePhyUshort(sc, 0x06, 0x4e78);
22118                         MP_WritePhyUshort(sc, 0x06, 0x039e);
22119                         MP_WritePhyUshort(sc, 0x06, 0x0fe0);
22120                         MP_WritePhyUshort(sc, 0x06, 0x834e);
22121                         MP_WritePhyUshort(sc, 0x06, 0x7801);
22122                         MP_WritePhyUshort(sc, 0x06, 0x9e05);
22123                         MP_WritePhyUshort(sc, 0x06, 0xae0c);
22124                         MP_WritePhyUshort(sc, 0x06, 0xaf81);
22125                         MP_WritePhyUshort(sc, 0x06, 0xa7af);
22126                         MP_WritePhyUshort(sc, 0x06, 0x8152);
22127                         MP_WritePhyUshort(sc, 0x06, 0xaf81);
22128                         MP_WritePhyUshort(sc, 0x06, 0x8baf);
22129                         MP_WritePhyUshort(sc, 0x06, 0x81c2);
22130                         MP_WritePhyUshort(sc, 0x06, 0xee83);
22131                         MP_WritePhyUshort(sc, 0x06, 0x4800);
22132                         MP_WritePhyUshort(sc, 0x06, 0xee83);
22133                         MP_WritePhyUshort(sc, 0x06, 0x4900);
22134                         MP_WritePhyUshort(sc, 0x06, 0xe083);
22135                         MP_WritePhyUshort(sc, 0x06, 0x5110);
22136                         MP_WritePhyUshort(sc, 0x06, 0xe483);
22137                         MP_WritePhyUshort(sc, 0x06, 0x5158);
22138                         MP_WritePhyUshort(sc, 0x06, 0x019f);
22139                         MP_WritePhyUshort(sc, 0x06, 0xead0);
22140                         MP_WritePhyUshort(sc, 0x06, 0x00d1);
22141                         MP_WritePhyUshort(sc, 0x06, 0x801f);
22142                         MP_WritePhyUshort(sc, 0x06, 0x66e2);
22143                         MP_WritePhyUshort(sc, 0x06, 0xf8ea);
22144                         MP_WritePhyUshort(sc, 0x06, 0xe3f8);
22145                         MP_WritePhyUshort(sc, 0x06, 0xeb5a);
22146                         MP_WritePhyUshort(sc, 0x06, 0xf81e);
22147                         MP_WritePhyUshort(sc, 0x06, 0x20e6);
22148                         MP_WritePhyUshort(sc, 0x06, 0xf8ea);
22149                         MP_WritePhyUshort(sc, 0x06, 0xe5f8);
22150                         MP_WritePhyUshort(sc, 0x06, 0xebd3);
22151                         MP_WritePhyUshort(sc, 0x06, 0x02b3);
22152                         MP_WritePhyUshort(sc, 0x06, 0xfee2);
22153                         MP_WritePhyUshort(sc, 0x06, 0xf87c);
22154                         MP_WritePhyUshort(sc, 0x06, 0xef32);
22155                         MP_WritePhyUshort(sc, 0x06, 0x5b80);
22156                         MP_WritePhyUshort(sc, 0x06, 0xe3f8);
22157                         MP_WritePhyUshort(sc, 0x06, 0x7d9e);
22158                         MP_WritePhyUshort(sc, 0x06, 0x037d);
22159                         MP_WritePhyUshort(sc, 0x06, 0xffff);
22160                         MP_WritePhyUshort(sc, 0x06, 0x0d58);
22161                         MP_WritePhyUshort(sc, 0x06, 0x1c55);
22162                         MP_WritePhyUshort(sc, 0x06, 0x1a65);
22163                         MP_WritePhyUshort(sc, 0x06, 0x11a1);
22164                         MP_WritePhyUshort(sc, 0x06, 0x90d3);
22165                         MP_WritePhyUshort(sc, 0x06, 0xe283);
22166                         MP_WritePhyUshort(sc, 0x06, 0x48e3);
22167                         MP_WritePhyUshort(sc, 0x06, 0x8349);
22168                         MP_WritePhyUshort(sc, 0x06, 0x1b56);
22169                         MP_WritePhyUshort(sc, 0x06, 0xab08);
22170                         MP_WritePhyUshort(sc, 0x06, 0xef56);
22171                         MP_WritePhyUshort(sc, 0x06, 0xe683);
22172                         MP_WritePhyUshort(sc, 0x06, 0x48e7);
22173                         MP_WritePhyUshort(sc, 0x06, 0x8349);
22174                         MP_WritePhyUshort(sc, 0x06, 0x10d1);
22175                         MP_WritePhyUshort(sc, 0x06, 0x801f);
22176                         MP_WritePhyUshort(sc, 0x06, 0x66a0);
22177                         MP_WritePhyUshort(sc, 0x06, 0x04b9);
22178                         MP_WritePhyUshort(sc, 0x06, 0xe283);
22179                         MP_WritePhyUshort(sc, 0x06, 0x48e3);
22180                         MP_WritePhyUshort(sc, 0x06, 0x8349);
22181                         MP_WritePhyUshort(sc, 0x06, 0xef65);
22182                         MP_WritePhyUshort(sc, 0x06, 0xe283);
22183                         MP_WritePhyUshort(sc, 0x06, 0x4ae3);
22184                         MP_WritePhyUshort(sc, 0x06, 0x834b);
22185                         MP_WritePhyUshort(sc, 0x06, 0x1b56);
22186                         MP_WritePhyUshort(sc, 0x06, 0xaa0e);
22187                         MP_WritePhyUshort(sc, 0x06, 0xef56);
22188                         MP_WritePhyUshort(sc, 0x06, 0xe683);
22189                         MP_WritePhyUshort(sc, 0x06, 0x4ae7);
22190                         MP_WritePhyUshort(sc, 0x06, 0x834b);
22191                         MP_WritePhyUshort(sc, 0x06, 0xe283);
22192                         MP_WritePhyUshort(sc, 0x06, 0x4de6);
22193                         MP_WritePhyUshort(sc, 0x06, 0x834c);
22194                         MP_WritePhyUshort(sc, 0x06, 0xe083);
22195                         MP_WritePhyUshort(sc, 0x06, 0x4da0);
22196                         MP_WritePhyUshort(sc, 0x06, 0x000c);
22197                         MP_WritePhyUshort(sc, 0x06, 0xaf81);
22198                         MP_WritePhyUshort(sc, 0x06, 0x8be0);
22199                         MP_WritePhyUshort(sc, 0x06, 0x834d);
22200                         MP_WritePhyUshort(sc, 0x06, 0x10e4);
22201                         MP_WritePhyUshort(sc, 0x06, 0x834d);
22202                         MP_WritePhyUshort(sc, 0x06, 0xae04);
22203                         MP_WritePhyUshort(sc, 0x06, 0x80e4);
22204                         MP_WritePhyUshort(sc, 0x06, 0x834d);
22205                         MP_WritePhyUshort(sc, 0x06, 0xe083);
22206                         MP_WritePhyUshort(sc, 0x06, 0x4e78);
22207                         MP_WritePhyUshort(sc, 0x06, 0x039e);
22208                         MP_WritePhyUshort(sc, 0x06, 0x0be0);
22209                         MP_WritePhyUshort(sc, 0x06, 0x834e);
22210                         MP_WritePhyUshort(sc, 0x06, 0x7804);
22211                         MP_WritePhyUshort(sc, 0x06, 0x9e04);
22212                         MP_WritePhyUshort(sc, 0x06, 0xee83);
22213                         MP_WritePhyUshort(sc, 0x06, 0x4e02);
22214                         MP_WritePhyUshort(sc, 0x06, 0xe083);
22215                         MP_WritePhyUshort(sc, 0x06, 0x32e1);
22216                         MP_WritePhyUshort(sc, 0x06, 0x8333);
22217                         MP_WritePhyUshort(sc, 0x06, 0x590f);
22218                         MP_WritePhyUshort(sc, 0x06, 0xe283);
22219                         MP_WritePhyUshort(sc, 0x06, 0x4d0c);
22220                         MP_WritePhyUshort(sc, 0x06, 0x245a);
22221                         MP_WritePhyUshort(sc, 0x06, 0xf01e);
22222                         MP_WritePhyUshort(sc, 0x06, 0x12e4);
22223                         MP_WritePhyUshort(sc, 0x06, 0xf88c);
22224                         MP_WritePhyUshort(sc, 0x06, 0xe5f8);
22225                         MP_WritePhyUshort(sc, 0x06, 0x8de0);
22226                         MP_WritePhyUshort(sc, 0x06, 0x8330);
22227                         MP_WritePhyUshort(sc, 0x06, 0xe183);
22228                         MP_WritePhyUshort(sc, 0x06, 0x3168);
22229                         MP_WritePhyUshort(sc, 0x06, 0x01e4);
22230                         MP_WritePhyUshort(sc, 0x06, 0xf88a);
22231                         MP_WritePhyUshort(sc, 0x06, 0xe5f8);
22232                         MP_WritePhyUshort(sc, 0x06, 0x8bae);
22233                         MP_WritePhyUshort(sc, 0x06, 0x37ee);
22234                         MP_WritePhyUshort(sc, 0x06, 0x834e);
22235                         MP_WritePhyUshort(sc, 0x06, 0x03e0);
22236                         MP_WritePhyUshort(sc, 0x06, 0x834c);
22237                         MP_WritePhyUshort(sc, 0x06, 0xe183);
22238                         MP_WritePhyUshort(sc, 0x06, 0x4d1b);
22239                         MP_WritePhyUshort(sc, 0x06, 0x019e);
22240                         MP_WritePhyUshort(sc, 0x06, 0x04aa);
22241                         MP_WritePhyUshort(sc, 0x06, 0xa1ae);
22242                         MP_WritePhyUshort(sc, 0x06, 0xa8ee);
22243                         MP_WritePhyUshort(sc, 0x06, 0x834e);
22244                         MP_WritePhyUshort(sc, 0x06, 0x04ee);
22245                         MP_WritePhyUshort(sc, 0x06, 0x834f);
22246                         MP_WritePhyUshort(sc, 0x06, 0x00ae);
22247                         MP_WritePhyUshort(sc, 0x06, 0xabe0);
22248                         MP_WritePhyUshort(sc, 0x06, 0x834f);
22249                         MP_WritePhyUshort(sc, 0x06, 0x7803);
22250                         MP_WritePhyUshort(sc, 0x06, 0x9f14);
22251                         MP_WritePhyUshort(sc, 0x06, 0xee83);
22252                         MP_WritePhyUshort(sc, 0x06, 0x4e05);
22253                         MP_WritePhyUshort(sc, 0x06, 0xd240);
22254                         MP_WritePhyUshort(sc, 0x06, 0xd655);
22255                         MP_WritePhyUshort(sc, 0x06, 0x5402);
22256                         MP_WritePhyUshort(sc, 0x06, 0x81c6);
22257                         MP_WritePhyUshort(sc, 0x06, 0xd2a0);
22258                         MP_WritePhyUshort(sc, 0x06, 0xd6ba);
22259                         MP_WritePhyUshort(sc, 0x06, 0x0002);
22260                         MP_WritePhyUshort(sc, 0x06, 0x81c6);
22261                         MP_WritePhyUshort(sc, 0x06, 0xfefd);
22262                         MP_WritePhyUshort(sc, 0x06, 0xfc05);
22263                         MP_WritePhyUshort(sc, 0x06, 0xf8e0);
22264                         MP_WritePhyUshort(sc, 0x06, 0xf860);
22265                         MP_WritePhyUshort(sc, 0x06, 0xe1f8);
22266                         MP_WritePhyUshort(sc, 0x06, 0x6168);
22267                         MP_WritePhyUshort(sc, 0x06, 0x02e4);
22268                         MP_WritePhyUshort(sc, 0x06, 0xf860);
22269                         MP_WritePhyUshort(sc, 0x06, 0xe5f8);
22270                         MP_WritePhyUshort(sc, 0x06, 0x61e0);
22271                         MP_WritePhyUshort(sc, 0x06, 0xf848);
22272                         MP_WritePhyUshort(sc, 0x06, 0xe1f8);
22273                         MP_WritePhyUshort(sc, 0x06, 0x4958);
22274                         MP_WritePhyUshort(sc, 0x06, 0x0f1e);
22275                         MP_WritePhyUshort(sc, 0x06, 0x02e4);
22276                         MP_WritePhyUshort(sc, 0x06, 0xf848);
22277                         MP_WritePhyUshort(sc, 0x06, 0xe5f8);
22278                         MP_WritePhyUshort(sc, 0x06, 0x49d0);
22279                         MP_WritePhyUshort(sc, 0x06, 0x0002);
22280                         MP_WritePhyUshort(sc, 0x06, 0x820a);
22281                         MP_WritePhyUshort(sc, 0x06, 0xbf83);
22282                         MP_WritePhyUshort(sc, 0x06, 0x50ef);
22283                         MP_WritePhyUshort(sc, 0x06, 0x46dc);
22284                         MP_WritePhyUshort(sc, 0x06, 0x19dd);
22285                         MP_WritePhyUshort(sc, 0x06, 0xd001);
22286                         MP_WritePhyUshort(sc, 0x06, 0x0282);
22287                         MP_WritePhyUshort(sc, 0x06, 0x0a02);
22288                         MP_WritePhyUshort(sc, 0x06, 0x8226);
22289                         MP_WritePhyUshort(sc, 0x06, 0xe0f8);
22290                         MP_WritePhyUshort(sc, 0x06, 0x60e1);
22291                         MP_WritePhyUshort(sc, 0x06, 0xf861);
22292                         MP_WritePhyUshort(sc, 0x06, 0x58fd);
22293                         MP_WritePhyUshort(sc, 0x06, 0xe4f8);
22294                         MP_WritePhyUshort(sc, 0x06, 0x60e5);
22295                         MP_WritePhyUshort(sc, 0x06, 0xf861);
22296                         MP_WritePhyUshort(sc, 0x06, 0xfc04);
22297                         MP_WritePhyUshort(sc, 0x06, 0xf9fa);
22298                         MP_WritePhyUshort(sc, 0x06, 0xfbc6);
22299                         MP_WritePhyUshort(sc, 0x06, 0xbff8);
22300                         MP_WritePhyUshort(sc, 0x06, 0x40be);
22301                         MP_WritePhyUshort(sc, 0x06, 0x8350);
22302                         MP_WritePhyUshort(sc, 0x06, 0xa001);
22303                         MP_WritePhyUshort(sc, 0x06, 0x0107);
22304                         MP_WritePhyUshort(sc, 0x06, 0x1b89);
22305                         MP_WritePhyUshort(sc, 0x06, 0xcfd2);
22306                         MP_WritePhyUshort(sc, 0x06, 0x08eb);
22307                         MP_WritePhyUshort(sc, 0x06, 0xdb19);
22308                         MP_WritePhyUshort(sc, 0x06, 0xb2fb);
22309                         MP_WritePhyUshort(sc, 0x06, 0xfffe);
22310                         MP_WritePhyUshort(sc, 0x06, 0xfd04);
22311                         MP_WritePhyUshort(sc, 0x06, 0xf8e0);
22312                         MP_WritePhyUshort(sc, 0x06, 0xf848);
22313                         MP_WritePhyUshort(sc, 0x06, 0xe1f8);
22314                         MP_WritePhyUshort(sc, 0x06, 0x4968);
22315                         MP_WritePhyUshort(sc, 0x06, 0x08e4);
22316                         MP_WritePhyUshort(sc, 0x06, 0xf848);
22317                         MP_WritePhyUshort(sc, 0x06, 0xe5f8);
22318                         MP_WritePhyUshort(sc, 0x06, 0x4958);
22319                         MP_WritePhyUshort(sc, 0x06, 0xf7e4);
22320                         MP_WritePhyUshort(sc, 0x06, 0xf848);
22321                         MP_WritePhyUshort(sc, 0x06, 0xe5f8);
22322                         MP_WritePhyUshort(sc, 0x06, 0x49fc);
22323                         MP_WritePhyUshort(sc, 0x06, 0x044d);
22324                         MP_WritePhyUshort(sc, 0x06, 0x2000);
22325                         MP_WritePhyUshort(sc, 0x06, 0x024e);
22326                         MP_WritePhyUshort(sc, 0x06, 0x2200);
22327                         MP_WritePhyUshort(sc, 0x06, 0x024d);
22328                         MP_WritePhyUshort(sc, 0x06, 0xdfff);
22329                         MP_WritePhyUshort(sc, 0x06, 0x014e);
22330                         MP_WritePhyUshort(sc, 0x06, 0xddff);
22331                         MP_WritePhyUshort(sc, 0x06, 0x01f8);
22332                         MP_WritePhyUshort(sc, 0x06, 0xfafb);
22333                         MP_WritePhyUshort(sc, 0x06, 0xef79);
22334                         MP_WritePhyUshort(sc, 0x06, 0xbff8);
22335                         MP_WritePhyUshort(sc, 0x06, 0x22d8);
22336                         MP_WritePhyUshort(sc, 0x06, 0x19d9);
22337                         MP_WritePhyUshort(sc, 0x06, 0x5884);
22338                         MP_WritePhyUshort(sc, 0x06, 0x9f09);
22339                         MP_WritePhyUshort(sc, 0x06, 0xbf82);
22340                         MP_WritePhyUshort(sc, 0x06, 0x6dd6);
22341                         MP_WritePhyUshort(sc, 0x06, 0x8275);
22342                         MP_WritePhyUshort(sc, 0x06, 0x0201);
22343                         MP_WritePhyUshort(sc, 0x06, 0x4fef);
22344                         MP_WritePhyUshort(sc, 0x06, 0x97ff);
22345                         MP_WritePhyUshort(sc, 0x06, 0xfefc);
22346                         MP_WritePhyUshort(sc, 0x06, 0x0517);
22347                         MP_WritePhyUshort(sc, 0x06, 0xfffe);
22348                         MP_WritePhyUshort(sc, 0x06, 0x0117);
22349                         MP_WritePhyUshort(sc, 0x06, 0x0001);
22350                         MP_WritePhyUshort(sc, 0x06, 0x0200);
22351                         MP_WritePhyUshort(sc, 0x05, 0x83d8);
22352                         MP_WritePhyUshort(sc, 0x06, 0x8000);
22353                         MP_WritePhyUshort(sc, 0x05, 0x83d6);
22354                         MP_WritePhyUshort(sc, 0x06, 0x824f);
22355                         MP_WritePhyUshort(sc, 0x02, 0x2010);
22356                         MP_WritePhyUshort(sc, 0x03, 0xdc00);
22357                         MP_WritePhyUshort(sc, 0x1f, 0x0000);
22358                         MP_WritePhyUshort(sc, 0x0b, 0x0600);
22359                         MP_WritePhyUshort(sc, 0x1f, 0x0005);
22360                         MP_WritePhyUshort(sc, 0x05, 0xfff6);
22361                         MP_WritePhyUshort(sc, 0x06, 0x00fc);
22362                         MP_WritePhyUshort(sc, 0x1f, 0x0000);
22363                 }
22364
22365                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
22366                 MP_WritePhyUshort(sc, 0x0D, 0xF880);
22367                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
22368         } else if (sc->re_type == MACFG_36 || sc->re_type == MACFG_37) {
22369                 MP_WritePhyUshort(sc, 0x1F, 0x0007);
22370                 MP_WritePhyUshort(sc, 0x1E, 0x0023);
22371                 Data = MP_ReadPhyUshort(sc, 0x17) | 0x0006;
22372                 if (sc->RequiredSecLanDonglePatch)
22373                         Data &= ~(BIT_2);
22374                 else
22375                         Data |= (BIT_2);
22376                 MP_WritePhyUshort(sc, 0x17, Data);
22377                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
22378
22379                 MP_WritePhyUshort(sc, 0x1f, 0x0005);
22380                 MP_WritePhyUshort(sc, 0x05, 0x8b80);
22381                 MP_WritePhyUshort(sc, 0x06, 0xc896);
22382                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
22383
22384                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
22385                 MP_WritePhyUshort(sc, 0x0B, 0x6C20);
22386                 MP_WritePhyUshort(sc, 0x07, 0x2872);
22387                 MP_WritePhyUshort(sc, 0x1C, 0xEFFF);
22388                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
22389                 MP_WritePhyUshort(sc, 0x14, 0x6420);
22390                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
22391
22392                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
22393                 Data = MP_ReadPhyUshort(sc, 0x08) & 0x00FF;
22394                 MP_WritePhyUshort(sc, 0x08, Data | 0x8000);
22395
22396                 MP_WritePhyUshort(sc, 0x1F, 0x0007);
22397                 MP_WritePhyUshort(sc, 0x1E, 0x002D);
22398                 Data = MP_ReadPhyUshort(sc, 0x18);
22399                 MP_WritePhyUshort(sc, 0x18, Data | 0x0050);
22400                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
22401                 Data = MP_ReadPhyUshort(sc, 0x14);
22402                 MP_WritePhyUshort(sc, 0x14, Data | 0x8000);
22403
22404                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
22405                 MP_WritePhyUshort(sc, 0x00, 0x080B);
22406                 MP_WritePhyUshort(sc, 0x0B, 0x09D7);
22407                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
22408                 MP_WritePhyUshort(sc, 0x15, 0x1006);
22409
22410                 MP_WritePhyUshort(sc, 0x1F, 0x0007);
22411                 MP_WritePhyUshort(sc, 0x1E, 0x002F);
22412                 MP_WritePhyUshort(sc, 0x15, 0x1919);
22413                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
22414
22415                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
22416                 MP_WritePhyUshort(sc, 0x19, 0x7F46);
22417                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
22418                 MP_WritePhyUshort(sc, 0x05, 0x8AD2);
22419                 MP_WritePhyUshort(sc, 0x06, 0x6810);
22420                 MP_WritePhyUshort(sc, 0x05, 0x8AD4);
22421                 MP_WritePhyUshort(sc, 0x06, 0x8002);
22422                 MP_WritePhyUshort(sc, 0x05, 0x8ADE);
22423                 MP_WritePhyUshort(sc, 0x06, 0x8025);
22424                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
22425         } else if (sc->re_type == MACFG_38) {
22426                 CSR_WRITE_1(sc, 0x6E, CSR_READ_1(sc, 0x6E)| (1<<6));
22427
22428                 Data_u32 = re_eri_read(sc, 0x1D0, 4, ERIAR_ExGMAC);
22429                 Data_u32 &= ~BIT_1;
22430                 re_eri_write(sc, 0x1D0, 4, Data_u32, ERIAR_ExGMAC);
22431
22432                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
22433                 MP_WritePhyUshort(sc, 0x05, 0x8B80);
22434                 Data = MP_ReadPhyUshort(sc, 0x06);
22435                 Data |= BIT_2 | BIT_1;
22436                 MP_WritePhyUshort(sc, 0x06, Data);
22437                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
22438
22439                 MP_WritePhyUshort(sc, 0x1f, 0x0004);
22440                 MP_WritePhyUshort(sc, 0x1f, 0x0007);
22441                 MP_WritePhyUshort(sc, 0x1e, 0x002D);
22442                 Data = MP_ReadPhyUshort(sc, 0x18);
22443                 Data |= BIT_4;
22444                 MP_WritePhyUshort(sc, 0x18, Data);
22445                 MP_WritePhyUshort(sc, 0x1f, 0x0002);
22446                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
22447                 Data = MP_ReadPhyUshort(sc, 0x14);
22448                 Data |= BIT_15;
22449                 MP_WritePhyUshort(sc, 0x14, Data);
22450
22451                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
22452                 MP_WritePhyUshort(sc, 0x05, 0x8B86);
22453                 Data = MP_ReadPhyUshort(sc, 0x06);
22454                 Data |= BIT_0;
22455                 MP_WritePhyUshort(sc, 0x06, Data);
22456                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
22457
22458                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
22459                 MP_WritePhyUshort(sc, 0x0B, 0x6C14);
22460                 MP_WritePhyUshort(sc, 0x14, 0x7F3D);
22461                 MP_WritePhyUshort(sc, 0x1C, 0xFAFE);
22462                 MP_WritePhyUshort(sc, 0x08, 0x07C5);
22463                 MP_WritePhyUshort(sc, 0x10, 0xF090);
22464                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
22465                 MP_WritePhyUshort(sc, 0x14, 0x641A);
22466                 MP_WritePhyUshort(sc, 0x1A, 0x0606);
22467                 MP_WritePhyUshort(sc, 0x12, 0xF480);
22468                 MP_WritePhyUshort(sc, 0x13, 0x0747);
22469                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
22470
22471                 MP_WritePhyUshort(sc, 0x1F, 0x0004);
22472                 MP_WritePhyUshort(sc, 0x1F, 0x0007);
22473                 MP_WritePhyUshort(sc, 0x1E, 0x0078);
22474                 MP_WritePhyUshort(sc, 0x15, 0xA408);
22475                 MP_WritePhyUshort(sc, 0x17, 0x5100);
22476                 MP_WritePhyUshort(sc, 0x19, 0x0008);
22477                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
22478                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
22479
22480                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
22481                 MP_WritePhyUshort(sc, 0x0D, 0x0207);
22482                 MP_WritePhyUshort(sc, 0x02, 0x5FD0);
22483                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
22484
22485                 MP_WritePhyUshort(sc, 0x1F, 0x0004);
22486                 MP_WritePhyUshort(sc, 0x1F, 0x0007);
22487                 MP_WritePhyUshort(sc, 0x1E, 0x00A1);
22488                 Data = MP_ReadPhyUshort(sc, 0x1A);
22489                 Data &= ~BIT_2;
22490                 MP_WritePhyUshort(sc, 0x1A, Data);
22491                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
22492                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
22493
22494                 MP_WritePhyUshort(sc, 0x1F, 0x0004);
22495                 MP_WritePhyUshort(sc, 0x1F, 0x0007);
22496                 MP_WritePhyUshort(sc, 0x1E, 0x002D);
22497                 Data = MP_ReadPhyUshort(sc, 0x16);
22498                 Data |= BIT_5;
22499                 MP_WritePhyUshort(sc, 0x16, Data);
22500                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
22501                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
22502
22503                 MP_WritePhyUshort(sc, 0x1F, 0x0004);
22504                 MP_WritePhyUshort(sc, 0x1F, 0x0007);
22505                 MP_WritePhyUshort(sc, 0x1E, 0x00AC);
22506                 MP_WritePhyUshort(sc, 0x18, 0x0006);
22507                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
22508                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
22509
22510                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
22511                 MP_WritePhyUshort(sc, 0x09, 0xA20F);
22512                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
22513
22514                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
22515                 MP_WritePhyUshort(sc, 0x05, 0x8B85);
22516                 Data = MP_ReadPhyUshort(sc, 0x06);
22517                 Data |= BIT_14;
22518                 MP_WritePhyUshort(sc, 0x06, Data);
22519                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
22520
22521                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
22522                 MP_WritePhyUshort(sc, 0x05, 0x8B54);
22523                 Data = MP_ReadPhyUshort(sc, 0x06);
22524                 Data &= ~BIT_11;
22525                 MP_WritePhyUshort(sc, 0x06, Data);
22526                 MP_WritePhyUshort(sc, 0x05, 0x8B5D);
22527                 Data = MP_ReadPhyUshort(sc, 0x06);
22528                 Data &= ~BIT_11;
22529                 MP_WritePhyUshort(sc, 0x06, Data);
22530                 MP_WritePhyUshort(sc, 0x05, 0x8A7C);
22531                 Data = MP_ReadPhyUshort(sc, 0x06);
22532                 Data &= ~BIT_8;
22533                 MP_WritePhyUshort(sc, 0x06, Data);
22534                 MP_WritePhyUshort(sc, 0x05, 0x8A7F);
22535                 Data = MP_ReadPhyUshort(sc, 0x06);
22536                 Data |= BIT_8;
22537                 MP_WritePhyUshort(sc, 0x06, Data);
22538                 MP_WritePhyUshort(sc, 0x05, 0x8A82);
22539                 Data = MP_ReadPhyUshort(sc, 0x06);
22540                 Data &= ~BIT_8;
22541                 MP_WritePhyUshort(sc, 0x06, Data);
22542                 MP_WritePhyUshort(sc, 0x05, 0x8A85);
22543                 Data = MP_ReadPhyUshort(sc, 0x06);
22544                 Data &= ~BIT_8;
22545                 MP_WritePhyUshort(sc, 0x06, Data);
22546                 MP_WritePhyUshort(sc, 0x05, 0x8A88);
22547                 Data = MP_ReadPhyUshort(sc, 0x06);
22548                 Data &= ~BIT_8;
22549                 MP_WritePhyUshort(sc, 0x06, Data);
22550                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
22551
22552                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
22553                 MP_WritePhyUshort(sc, 0x05, 0x8B85);
22554                 Data = MP_ReadPhyUshort(sc, 0x06);
22555                 Data |= BIT_15;
22556                 MP_WritePhyUshort(sc, 0x06, Data);
22557                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
22558
22559                 MP_WritePhyUshort(sc, 0x1f, 0x0003);
22560                 Data = MP_ReadPhyUshort(sc, 0x19);
22561                 Data &= ~BIT_0;
22562                 MP_WritePhyUshort(sc, 0x19, Data);
22563                 Data = MP_ReadPhyUshort(sc, 0x10);
22564                 Data &= ~BIT_10;
22565                 MP_WritePhyUshort(sc, 0x10, Data);
22566                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
22567         } else if (sc->re_type == MACFG_39) {
22568                 Data_u32 = re_eri_read(sc, 0x1D0, 4, ERIAR_ExGMAC);
22569                 Data_u32 &= ~BIT_1;
22570                 re_eri_write(sc, 0x1D0, 4, Data_u32, ERIAR_ExGMAC);
22571
22572                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
22573                 MP_WritePhyUshort(sc, 0x05, 0x8B80);
22574                 Data = MP_ReadPhyUshort(sc, 0x06);
22575                 Data |= BIT_2 | BIT_1;
22576                 MP_WritePhyUshort(sc, 0x06, Data);
22577                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
22578
22579                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
22580                 MP_WritePhyUshort(sc, 0x05, 0x8B85);
22581                 Data = MP_ReadPhyUshort(sc, 0x06);
22582                 Data |= BIT_15;
22583                 MP_WritePhyUshort(sc, 0x06, Data);
22584                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
22585
22586                 MP_WritePhyUshort(sc, 0x1f, 0x0004);
22587                 MP_WritePhyUshort(sc, 0x1f, 0x0007);
22588                 MP_WritePhyUshort(sc, 0x1e, 0x002D);
22589                 Data = MP_ReadPhyUshort(sc, 0x18);
22590                 Data |= BIT_4;
22591                 MP_WritePhyUshort(sc, 0x18, Data);
22592                 MP_WritePhyUshort(sc, 0x1f, 0x0002);
22593                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
22594                 Data = MP_ReadPhyUshort(sc, 0x14);
22595                 Data |= BIT_15;
22596                 MP_WritePhyUshort(sc, 0x14, Data);
22597
22598                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
22599                 MP_WritePhyUshort(sc, 0x05, 0x8B86);
22600                 Data = MP_ReadPhyUshort(sc, 0x06);
22601                 Data |= BIT_0;
22602                 MP_WritePhyUshort(sc, 0x06, Data);
22603                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
22604
22605                 MP_WritePhyUshort(sc, 0x1F, 0x0004);
22606                 MP_WritePhyUshort(sc, 0x1F, 0x0007);
22607                 MP_WritePhyUshort(sc, 0x1E, 0x00AC);
22608                 MP_WritePhyUshort(sc, 0x18, 0x0006);
22609                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
22610                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
22611
22612                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
22613                 MP_WritePhyUshort(sc, 0x09, 0xA20F);
22614                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
22615
22616                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
22617                 MP_WritePhyUshort(sc, 0x05, 0x8B85);
22618                 Data = MP_ReadPhyUshort(sc, 0x06);
22619                 Data |= BIT_14;
22620                 MP_WritePhyUshort(sc, 0x06, Data);
22621                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
22622
22623                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
22624                 MP_WritePhyUshort(sc, 0x05, 0x8B54);
22625                 Data = MP_ReadPhyUshort(sc, 0x06);
22626                 Data &= ~BIT_11;
22627                 MP_WritePhyUshort(sc, 0x06, Data);
22628                 MP_WritePhyUshort(sc, 0x05, 0x8B5D);
22629                 Data = MP_ReadPhyUshort(sc, 0x06);
22630                 Data &= ~BIT_11;
22631                 MP_WritePhyUshort(sc, 0x06, Data);
22632                 MP_WritePhyUshort(sc, 0x05, 0x8A7C);
22633                 Data = MP_ReadPhyUshort(sc, 0x06);
22634                 Data &= ~BIT_8;
22635                 MP_WritePhyUshort(sc, 0x06, Data);
22636                 MP_WritePhyUshort(sc, 0x05, 0x8A7F);
22637                 Data = MP_ReadPhyUshort(sc, 0x06);
22638                 Data |= BIT_8;
22639                 MP_WritePhyUshort(sc, 0x06, Data);
22640                 MP_WritePhyUshort(sc, 0x05, 0x8A82);
22641                 Data = MP_ReadPhyUshort(sc, 0x06);
22642                 Data &= ~BIT_8;
22643                 MP_WritePhyUshort(sc, 0x06, Data);
22644                 MP_WritePhyUshort(sc, 0x05, 0x8A85);
22645                 Data = MP_ReadPhyUshort(sc, 0x06);
22646                 Data &= ~BIT_8;
22647                 MP_WritePhyUshort(sc, 0x06, Data);
22648                 MP_WritePhyUshort(sc, 0x05, 0x8A88);
22649                 Data = MP_ReadPhyUshort(sc, 0x06);
22650                 Data &= ~BIT_8;
22651                 MP_WritePhyUshort(sc, 0x06, Data);
22652                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
22653
22654                 MP_WritePhyUshort(sc, 0x1f, 0x0003);
22655                 Data = MP_ReadPhyUshort(sc, 0x19);
22656                 Data &= ~BIT_0;
22657                 MP_WritePhyUshort(sc, 0x19, Data);
22658                 Data = MP_ReadPhyUshort(sc, 0x10);
22659                 Data &= ~BIT_10;
22660                 MP_WritePhyUshort(sc, 0x10, Data);
22661                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
22662         } else if (sc->re_type == MACFG_41) {
22663                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
22664                 MP_WritePhyUshort(sc, 0x11, MP_ReadPhyUshort(sc, 0x11) | 0x1000);
22665                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
22666                 MP_WritePhyUshort(sc, 0x0F, MP_ReadPhyUshort(sc, 0x0F) | 0x0003);
22667                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
22668
22669                 for (Data_u32=0x800E0068; Data_u32<0x800E006D; Data_u32++) {
22670                         CSR_WRITE_4(sc, 0xF8, Data_u32);
22671                         for (i=0; i<10; i++) {
22672                                 DELAY(400);
22673                                 if ((CSR_READ_4(sc, 0xF8)&0x80000000)==0)
22674                                         break;
22675                         }
22676                 }
22677         } else if (sc->re_type == MACFG_42 || sc->re_type == MACFG_43) {
22678                 Data_u32 = re_eri_read(sc, 0x1D0, 4, ERIAR_ExGMAC);
22679                 Data_u32 &= 0xFFFF0000;
22680                 re_eri_write(sc, 0x1D0, 4, Data_u32, ERIAR_ExGMAC);
22681
22682                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
22683                 MP_WritePhyUshort(sc, 0x18, 0x0310);
22684                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
22685
22686                 MP_WritePhyUshort(sc, 0x1f, 0x0004);
22687                 MP_WritePhyUshort(sc, 0x1f, 0x0004);
22688                 MP_WritePhyUshort(sc, 0x19, 0x7070);
22689                 MP_WritePhyUshort(sc, 0x1c, 0x0600);
22690                 MP_WritePhyUshort(sc, 0x1d, 0x9700);
22691                 MP_WritePhyUshort(sc, 0x1d, 0x7d00);
22692                 MP_WritePhyUshort(sc, 0x1d, 0x6900);
22693                 MP_WritePhyUshort(sc, 0x1d, 0x7d00);
22694                 MP_WritePhyUshort(sc, 0x1d, 0x6800);
22695                 MP_WritePhyUshort(sc, 0x1d, 0x4899);
22696                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
22697                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
22698                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
22699                 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
22700                 MP_WritePhyUshort(sc, 0x1d, 0x8000);
22701                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
22702                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
22703                 MP_WritePhyUshort(sc, 0x1d, 0x4007);
22704                 MP_WritePhyUshort(sc, 0x1d, 0x4400);
22705                 MP_WritePhyUshort(sc, 0x1d, 0x4800);
22706                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
22707                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
22708                 MP_WritePhyUshort(sc, 0x1d, 0x5310);
22709                 MP_WritePhyUshort(sc, 0x1d, 0x6000);
22710                 MP_WritePhyUshort(sc, 0x1d, 0x6800);
22711                 MP_WritePhyUshort(sc, 0x1d, 0x6736);
22712                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22713                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22714                 MP_WritePhyUshort(sc, 0x1d, 0x571f);
22715                 MP_WritePhyUshort(sc, 0x1d, 0x5ffb);
22716                 MP_WritePhyUshort(sc, 0x1d, 0xaa03);
22717                 MP_WritePhyUshort(sc, 0x1d, 0x5b58);
22718                 MP_WritePhyUshort(sc, 0x1d, 0x301e);
22719                 MP_WritePhyUshort(sc, 0x1d, 0x5b64);
22720                 MP_WritePhyUshort(sc, 0x1d, 0xa6fc);
22721                 MP_WritePhyUshort(sc, 0x1d, 0xdcdb);
22722                 MP_WritePhyUshort(sc, 0x1d, 0x0014);
22723                 MP_WritePhyUshort(sc, 0x1d, 0xd9a9);
22724                 MP_WritePhyUshort(sc, 0x1d, 0x0013);
22725                 MP_WritePhyUshort(sc, 0x1d, 0xd16b);
22726                 MP_WritePhyUshort(sc, 0x1d, 0x0011);
22727                 MP_WritePhyUshort(sc, 0x1d, 0xb40e);
22728                 MP_WritePhyUshort(sc, 0x1d, 0xd06b);
22729                 MP_WritePhyUshort(sc, 0x1d, 0x000c);
22730                 MP_WritePhyUshort(sc, 0x1d, 0xb206);
22731                 MP_WritePhyUshort(sc, 0x1d, 0x7c01);
22732                 MP_WritePhyUshort(sc, 0x1d, 0x5800);
22733                 MP_WritePhyUshort(sc, 0x1d, 0x7c04);
22734                 MP_WritePhyUshort(sc, 0x1d, 0x5c00);
22735                 MP_WritePhyUshort(sc, 0x1d, 0x301a);
22736                 MP_WritePhyUshort(sc, 0x1d, 0x7c01);
22737                 MP_WritePhyUshort(sc, 0x1d, 0x5801);
22738                 MP_WritePhyUshort(sc, 0x1d, 0x7c04);
22739                 MP_WritePhyUshort(sc, 0x1d, 0x5c04);
22740                 MP_WritePhyUshort(sc, 0x1d, 0x301e);
22741                 MP_WritePhyUshort(sc, 0x1d, 0x314d);
22742                 MP_WritePhyUshort(sc, 0x1d, 0x31f0);
22743                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
22744                 MP_WritePhyUshort(sc, 0x1d, 0x4c20);
22745                 MP_WritePhyUshort(sc, 0x1d, 0x6004);
22746                 MP_WritePhyUshort(sc, 0x1d, 0x5310);
22747                 MP_WritePhyUshort(sc, 0x1d, 0x4833);
22748                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
22749                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
22750                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
22751                 MP_WritePhyUshort(sc, 0x1d, 0x4c08);
22752                 MP_WritePhyUshort(sc, 0x1d, 0x8300);
22753                 MP_WritePhyUshort(sc, 0x1d, 0x6800);
22754                 MP_WritePhyUshort(sc, 0x1d, 0x6600);
22755                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22756                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22757                 MP_WritePhyUshort(sc, 0x1d, 0xb90c);
22758                 MP_WritePhyUshort(sc, 0x1d, 0x30d3);
22759                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
22760                 MP_WritePhyUshort(sc, 0x1d, 0x4de0);
22761                 MP_WritePhyUshort(sc, 0x1d, 0x7c04);
22762                 MP_WritePhyUshort(sc, 0x1d, 0x6000);
22763                 MP_WritePhyUshort(sc, 0x1d, 0x6800);
22764                 MP_WritePhyUshort(sc, 0x1d, 0x6736);
22765                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22766                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22767                 MP_WritePhyUshort(sc, 0x1d, 0x5310);
22768                 MP_WritePhyUshort(sc, 0x1d, 0x300b);
22769                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
22770                 MP_WritePhyUshort(sc, 0x1d, 0x4c60);
22771                 MP_WritePhyUshort(sc, 0x1d, 0x6803);
22772                 MP_WritePhyUshort(sc, 0x1d, 0x6520);
22773                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22774                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22775                 MP_WritePhyUshort(sc, 0x1d, 0xaf03);
22776                 MP_WritePhyUshort(sc, 0x1d, 0x6015);
22777                 MP_WritePhyUshort(sc, 0x1d, 0x3059);
22778                 MP_WritePhyUshort(sc, 0x1d, 0x6017);
22779                 MP_WritePhyUshort(sc, 0x1d, 0x57e0);
22780                 MP_WritePhyUshort(sc, 0x1d, 0x580c);
22781                 MP_WritePhyUshort(sc, 0x1d, 0x588c);
22782                 MP_WritePhyUshort(sc, 0x1d, 0x7ffc);
22783                 MP_WritePhyUshort(sc, 0x1d, 0x5fa3);
22784                 MP_WritePhyUshort(sc, 0x1d, 0x4827);
22785                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
22786                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
22787                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
22788                 MP_WritePhyUshort(sc, 0x1d, 0x4c10);
22789                 MP_WritePhyUshort(sc, 0x1d, 0x8400);
22790                 MP_WritePhyUshort(sc, 0x1d, 0x7c30);
22791                 MP_WritePhyUshort(sc, 0x1d, 0x6020);
22792                 MP_WritePhyUshort(sc, 0x1d, 0x48bf);
22793                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
22794                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
22795                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
22796                 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
22797                 MP_WritePhyUshort(sc, 0x1d, 0xad09);
22798                 MP_WritePhyUshort(sc, 0x1d, 0x7c03);
22799                 MP_WritePhyUshort(sc, 0x1d, 0x5c03);
22800                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22801                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22802                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22803                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22804                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22805                 MP_WritePhyUshort(sc, 0x1d, 0x4400);
22806                 MP_WritePhyUshort(sc, 0x1d, 0xad2c);
22807                 MP_WritePhyUshort(sc, 0x1d, 0xd6cf);
22808                 MP_WritePhyUshort(sc, 0x1d, 0x0002);
22809                 MP_WritePhyUshort(sc, 0x1d, 0x80f4);
22810                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
22811                 MP_WritePhyUshort(sc, 0x1d, 0x4c80);
22812                 MP_WritePhyUshort(sc, 0x1d, 0x7c20);
22813                 MP_WritePhyUshort(sc, 0x1d, 0x5c20);
22814                 MP_WritePhyUshort(sc, 0x1d, 0x481e);
22815                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
22816                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
22817                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
22818                 MP_WritePhyUshort(sc, 0x1d, 0x4c02);
22819                 MP_WritePhyUshort(sc, 0x1d, 0xad0a);
22820                 MP_WritePhyUshort(sc, 0x1d, 0x7c03);
22821                 MP_WritePhyUshort(sc, 0x1d, 0x5c03);
22822                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22823                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22824                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22825                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22826                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22827                 MP_WritePhyUshort(sc, 0x1d, 0x4400);
22828                 MP_WritePhyUshort(sc, 0x1d, 0x5310);
22829                 MP_WritePhyUshort(sc, 0x1d, 0x8d02);
22830                 MP_WritePhyUshort(sc, 0x1d, 0x4401);
22831                 MP_WritePhyUshort(sc, 0x1d, 0x81f4);
22832                 MP_WritePhyUshort(sc, 0x1d, 0x3114);
22833                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
22834                 MP_WritePhyUshort(sc, 0x1d, 0x4d00);
22835                 MP_WritePhyUshort(sc, 0x1d, 0x4832);
22836                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
22837                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
22838                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
22839                 MP_WritePhyUshort(sc, 0x1d, 0x4c10);
22840                 MP_WritePhyUshort(sc, 0x1d, 0x7c08);
22841                 MP_WritePhyUshort(sc, 0x1d, 0x6000);
22842                 MP_WritePhyUshort(sc, 0x1d, 0xa4b7);
22843                 MP_WritePhyUshort(sc, 0x1d, 0xd9b3);
22844                 MP_WritePhyUshort(sc, 0x1d, 0xfffe);
22845                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
22846                 MP_WritePhyUshort(sc, 0x1d, 0x4d20);
22847                 MP_WritePhyUshort(sc, 0x1d, 0x7e00);
22848                 MP_WritePhyUshort(sc, 0x1d, 0x6200);
22849                 MP_WritePhyUshort(sc, 0x1d, 0x3045);
22850                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
22851                 MP_WritePhyUshort(sc, 0x1d, 0x4d40);
22852                 MP_WritePhyUshort(sc, 0x1d, 0x7c40);
22853                 MP_WritePhyUshort(sc, 0x1d, 0x6000);
22854                 MP_WritePhyUshort(sc, 0x1d, 0x4401);
22855                 MP_WritePhyUshort(sc, 0x1d, 0x5210);
22856                 MP_WritePhyUshort(sc, 0x1d, 0x4833);
22857                 MP_WritePhyUshort(sc, 0x1d, 0x7c08);
22858                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
22859                 MP_WritePhyUshort(sc, 0x1d, 0x7c08);
22860                 MP_WritePhyUshort(sc, 0x1d, 0x4c08);
22861                 MP_WritePhyUshort(sc, 0x1d, 0x8300);
22862                 MP_WritePhyUshort(sc, 0x1d, 0x5f80);
22863                 MP_WritePhyUshort(sc, 0x1d, 0x55e0);
22864                 MP_WritePhyUshort(sc, 0x1d, 0xc06f);
22865                 MP_WritePhyUshort(sc, 0x1d, 0x0005);
22866                 MP_WritePhyUshort(sc, 0x1d, 0xd9b3);
22867                 MP_WritePhyUshort(sc, 0x1d, 0xfffd);
22868                 MP_WritePhyUshort(sc, 0x1d, 0x7c40);
22869                 MP_WritePhyUshort(sc, 0x1d, 0x6040);
22870                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
22871                 MP_WritePhyUshort(sc, 0x1d, 0x4d60);
22872                 MP_WritePhyUshort(sc, 0x1d, 0x57e0);
22873                 MP_WritePhyUshort(sc, 0x1d, 0x4814);
22874                 MP_WritePhyUshort(sc, 0x1d, 0x7c04);
22875                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
22876                 MP_WritePhyUshort(sc, 0x1d, 0x7c04);
22877                 MP_WritePhyUshort(sc, 0x1d, 0x4c04);
22878                 MP_WritePhyUshort(sc, 0x1d, 0x8200);
22879                 MP_WritePhyUshort(sc, 0x1d, 0x7c03);
22880                 MP_WritePhyUshort(sc, 0x1d, 0x5c03);
22881                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22882                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22883                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22884                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22885                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22886                 MP_WritePhyUshort(sc, 0x1d, 0xad02);
22887                 MP_WritePhyUshort(sc, 0x1d, 0x4400);
22888                 MP_WritePhyUshort(sc, 0x1d, 0xc0e9);
22889                 MP_WritePhyUshort(sc, 0x1d, 0x0003);
22890                 MP_WritePhyUshort(sc, 0x1d, 0xadd8);
22891                 MP_WritePhyUshort(sc, 0x1d, 0x30c6);
22892                 MP_WritePhyUshort(sc, 0x1d, 0x3078);
22893                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
22894                 MP_WritePhyUshort(sc, 0x1d, 0x4dc0);
22895                 MP_WritePhyUshort(sc, 0x1d, 0x6730);
22896                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22897                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22898                 MP_WritePhyUshort(sc, 0x1d, 0xd09d);
22899                 MP_WritePhyUshort(sc, 0x1d, 0x0002);
22900                 MP_WritePhyUshort(sc, 0x1d, 0xb4fe);
22901                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
22902                 MP_WritePhyUshort(sc, 0x1d, 0x4d80);
22903                 MP_WritePhyUshort(sc, 0x1d, 0x6802);
22904                 MP_WritePhyUshort(sc, 0x1d, 0x6600);
22905                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22906                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22907                 MP_WritePhyUshort(sc, 0x1d, 0x7c08);
22908                 MP_WritePhyUshort(sc, 0x1d, 0x6000);
22909                 MP_WritePhyUshort(sc, 0x1d, 0x486c);
22910                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
22911                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
22912                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
22913                 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
22914                 MP_WritePhyUshort(sc, 0x1d, 0x9503);
22915                 MP_WritePhyUshort(sc, 0x1d, 0x7e00);
22916                 MP_WritePhyUshort(sc, 0x1d, 0x6200);
22917                 MP_WritePhyUshort(sc, 0x1d, 0x571f);
22918                 MP_WritePhyUshort(sc, 0x1d, 0x5fbb);
22919                 MP_WritePhyUshort(sc, 0x1d, 0xaa03);
22920                 MP_WritePhyUshort(sc, 0x1d, 0x5b58);
22921                 MP_WritePhyUshort(sc, 0x1d, 0x30e9);
22922                 MP_WritePhyUshort(sc, 0x1d, 0x5b64);
22923                 MP_WritePhyUshort(sc, 0x1d, 0xcdab);
22924                 MP_WritePhyUshort(sc, 0x1d, 0xff5b);
22925                 MP_WritePhyUshort(sc, 0x1d, 0xcd8d);
22926                 MP_WritePhyUshort(sc, 0x1d, 0xff59);
22927                 MP_WritePhyUshort(sc, 0x1d, 0xd96b);
22928                 MP_WritePhyUshort(sc, 0x1d, 0xff57);
22929                 MP_WritePhyUshort(sc, 0x1d, 0xd0a0);
22930                 MP_WritePhyUshort(sc, 0x1d, 0xffdb);
22931                 MP_WritePhyUshort(sc, 0x1d, 0xcba0);
22932                 MP_WritePhyUshort(sc, 0x1d, 0x0003);
22933                 MP_WritePhyUshort(sc, 0x1d, 0x80f0);
22934                 MP_WritePhyUshort(sc, 0x1d, 0x30f6);
22935                 MP_WritePhyUshort(sc, 0x1d, 0x3109);
22936                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
22937                 MP_WritePhyUshort(sc, 0x1d, 0x4ce0);
22938                 MP_WritePhyUshort(sc, 0x1d, 0x7d30);
22939                 MP_WritePhyUshort(sc, 0x1d, 0x6530);
22940                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22941                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22942                 MP_WritePhyUshort(sc, 0x1d, 0x7ce0);
22943                 MP_WritePhyUshort(sc, 0x1d, 0x5400);
22944                 MP_WritePhyUshort(sc, 0x1d, 0x4832);
22945                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
22946                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
22947                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
22948                 MP_WritePhyUshort(sc, 0x1d, 0x4c08);
22949                 MP_WritePhyUshort(sc, 0x1d, 0x7c08);
22950                 MP_WritePhyUshort(sc, 0x1d, 0x6008);
22951                 MP_WritePhyUshort(sc, 0x1d, 0x8300);
22952                 MP_WritePhyUshort(sc, 0x1d, 0xb902);
22953                 MP_WritePhyUshort(sc, 0x1d, 0x30d3);
22954                 MP_WritePhyUshort(sc, 0x1d, 0x308f);
22955                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
22956                 MP_WritePhyUshort(sc, 0x1d, 0x4da0);
22957                 MP_WritePhyUshort(sc, 0x1d, 0x57a0);
22958                 MP_WritePhyUshort(sc, 0x1d, 0x590c);
22959                 MP_WritePhyUshort(sc, 0x1d, 0x5fa2);
22960                 MP_WritePhyUshort(sc, 0x1d, 0xcba4);
22961                 MP_WritePhyUshort(sc, 0x1d, 0x0005);
22962                 MP_WritePhyUshort(sc, 0x1d, 0xcd8d);
22963                 MP_WritePhyUshort(sc, 0x1d, 0x0003);
22964                 MP_WritePhyUshort(sc, 0x1d, 0x80fc);
22965                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
22966                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
22967                 MP_WritePhyUshort(sc, 0x1d, 0x4ca0);
22968                 MP_WritePhyUshort(sc, 0x1d, 0xb603);
22969                 MP_WritePhyUshort(sc, 0x1d, 0x7c10);
22970                 MP_WritePhyUshort(sc, 0x1d, 0x6010);
22971                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
22972                 MP_WritePhyUshort(sc, 0x1d, 0x541f);
22973                 MP_WritePhyUshort(sc, 0x1d, 0x7ffc);
22974                 MP_WritePhyUshort(sc, 0x1d, 0x5fb3);
22975                 MP_WritePhyUshort(sc, 0x1d, 0x9403);
22976                 MP_WritePhyUshort(sc, 0x1d, 0x7c03);
22977                 MP_WritePhyUshort(sc, 0x1d, 0x5c03);
22978                 MP_WritePhyUshort(sc, 0x1d, 0xaa05);
22979                 MP_WritePhyUshort(sc, 0x1d, 0x7c80);
22980                 MP_WritePhyUshort(sc, 0x1d, 0x5800);
22981                 MP_WritePhyUshort(sc, 0x1d, 0x5b58);
22982                 MP_WritePhyUshort(sc, 0x1d, 0x3128);
22983                 MP_WritePhyUshort(sc, 0x1d, 0x7c80);
22984                 MP_WritePhyUshort(sc, 0x1d, 0x5800);
22985                 MP_WritePhyUshort(sc, 0x1d, 0x5b64);
22986                 MP_WritePhyUshort(sc, 0x1d, 0x4827);
22987                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
22988                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
22989                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
22990                 MP_WritePhyUshort(sc, 0x1d, 0x4c10);
22991                 MP_WritePhyUshort(sc, 0x1d, 0x8400);
22992                 MP_WritePhyUshort(sc, 0x1d, 0x7c10);
22993                 MP_WritePhyUshort(sc, 0x1d, 0x6000);
22994                 MP_WritePhyUshort(sc, 0x1d, 0x4824);
22995                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
22996                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
22997                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
22998                 MP_WritePhyUshort(sc, 0x1d, 0x4c04);
22999                 MP_WritePhyUshort(sc, 0x1d, 0x8200);
23000                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23001                 MP_WritePhyUshort(sc, 0x1d, 0x4cc0);
23002                 MP_WritePhyUshort(sc, 0x1d, 0x7d00);
23003                 MP_WritePhyUshort(sc, 0x1d, 0x6400);
23004                 MP_WritePhyUshort(sc, 0x1d, 0x7ffc);
23005                 MP_WritePhyUshort(sc, 0x1d, 0x5fbb);
23006                 MP_WritePhyUshort(sc, 0x1d, 0x4824);
23007                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23008                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
23009                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23010                 MP_WritePhyUshort(sc, 0x1d, 0x4c04);
23011                 MP_WritePhyUshort(sc, 0x1d, 0x8200);
23012                 MP_WritePhyUshort(sc, 0x1d, 0x7e00);
23013                 MP_WritePhyUshort(sc, 0x1d, 0x6a00);
23014                 MP_WritePhyUshort(sc, 0x1d, 0x4824);
23015                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23016                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
23017                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23018                 MP_WritePhyUshort(sc, 0x1d, 0x4c04);
23019                 MP_WritePhyUshort(sc, 0x1d, 0x8200);
23020                 MP_WritePhyUshort(sc, 0x1d, 0x7e00);
23021                 MP_WritePhyUshort(sc, 0x1d, 0x6800);
23022                 MP_WritePhyUshort(sc, 0x1d, 0x30f6);
23023                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23024                 MP_WritePhyUshort(sc, 0x1d, 0x4e00);
23025                 MP_WritePhyUshort(sc, 0x1d, 0x4007);
23026                 MP_WritePhyUshort(sc, 0x1d, 0x4400);
23027                 MP_WritePhyUshort(sc, 0x1d, 0x5310);
23028                 MP_WritePhyUshort(sc, 0x1d, 0x6800);
23029                 MP_WritePhyUshort(sc, 0x1d, 0x6736);
23030                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23031                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23032                 MP_WritePhyUshort(sc, 0x1d, 0x570f);
23033                 MP_WritePhyUshort(sc, 0x1d, 0x5fff);
23034                 MP_WritePhyUshort(sc, 0x1d, 0xaa03);
23035                 MP_WritePhyUshort(sc, 0x1d, 0x585b);
23036                 MP_WritePhyUshort(sc, 0x1d, 0x315c);
23037                 MP_WritePhyUshort(sc, 0x1d, 0x5867);
23038                 MP_WritePhyUshort(sc, 0x1d, 0x9402);
23039                 MP_WritePhyUshort(sc, 0x1d, 0x6200);
23040                 MP_WritePhyUshort(sc, 0x1d, 0xcda3);
23041                 MP_WritePhyUshort(sc, 0x1d, 0x009d);
23042                 MP_WritePhyUshort(sc, 0x1d, 0xcd85);
23043                 MP_WritePhyUshort(sc, 0x1d, 0x009b);
23044                 MP_WritePhyUshort(sc, 0x1d, 0xd96b);
23045                 MP_WritePhyUshort(sc, 0x1d, 0x0099);
23046                 MP_WritePhyUshort(sc, 0x1d, 0x96e9);
23047                 MP_WritePhyUshort(sc, 0x1d, 0x6800);
23048                 MP_WritePhyUshort(sc, 0x1d, 0x6736);
23049                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23050                 MP_WritePhyUshort(sc, 0x1d, 0x4e20);
23051                 MP_WritePhyUshort(sc, 0x1d, 0x96e4);
23052                 MP_WritePhyUshort(sc, 0x1d, 0x8b04);
23053                 MP_WritePhyUshort(sc, 0x1d, 0x7c08);
23054                 MP_WritePhyUshort(sc, 0x1d, 0x5008);
23055                 MP_WritePhyUshort(sc, 0x1d, 0xab03);
23056                 MP_WritePhyUshort(sc, 0x1d, 0x7c08);
23057                 MP_WritePhyUshort(sc, 0x1d, 0x5000);
23058                 MP_WritePhyUshort(sc, 0x1d, 0x6801);
23059                 MP_WritePhyUshort(sc, 0x1d, 0x6776);
23060                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23061                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23062                 MP_WritePhyUshort(sc, 0x1d, 0xdb7c);
23063                 MP_WritePhyUshort(sc, 0x1d, 0xfff0);
23064                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23065                 MP_WritePhyUshort(sc, 0x1d, 0x7fe1);
23066                 MP_WritePhyUshort(sc, 0x1d, 0x4e40);
23067                 MP_WritePhyUshort(sc, 0x1d, 0x4837);
23068                 MP_WritePhyUshort(sc, 0x1d, 0x4418);
23069                 MP_WritePhyUshort(sc, 0x1d, 0x41c7);
23070                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23071                 MP_WritePhyUshort(sc, 0x1d, 0x4e40);
23072                 MP_WritePhyUshort(sc, 0x1d, 0x7c40);
23073                 MP_WritePhyUshort(sc, 0x1d, 0x5400);
23074                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23075                 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
23076                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23077                 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
23078                 MP_WritePhyUshort(sc, 0x1d, 0x8fc9);
23079                 MP_WritePhyUshort(sc, 0x1d, 0xd2a0);
23080                 MP_WritePhyUshort(sc, 0x1d, 0x004a);
23081                 MP_WritePhyUshort(sc, 0x1d, 0x9203);
23082                 MP_WritePhyUshort(sc, 0x1d, 0xa041);
23083                 MP_WritePhyUshort(sc, 0x1d, 0x3184);
23084                 MP_WritePhyUshort(sc, 0x1d, 0x7fe1);
23085                 MP_WritePhyUshort(sc, 0x1d, 0x4e60);
23086                 MP_WritePhyUshort(sc, 0x1d, 0x489c);
23087                 MP_WritePhyUshort(sc, 0x1d, 0x4628);
23088                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23089                 MP_WritePhyUshort(sc, 0x1d, 0x4e60);
23090                 MP_WritePhyUshort(sc, 0x1d, 0x7e28);
23091                 MP_WritePhyUshort(sc, 0x1d, 0x4628);
23092                 MP_WritePhyUshort(sc, 0x1d, 0x7c40);
23093                 MP_WritePhyUshort(sc, 0x1d, 0x5400);
23094                 MP_WritePhyUshort(sc, 0x1d, 0x7c01);
23095                 MP_WritePhyUshort(sc, 0x1d, 0x5800);
23096                 MP_WritePhyUshort(sc, 0x1d, 0x7c04);
23097                 MP_WritePhyUshort(sc, 0x1d, 0x5c00);
23098                 MP_WritePhyUshort(sc, 0x1d, 0x41e8);
23099                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23100                 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
23101                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23102                 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
23103                 MP_WritePhyUshort(sc, 0x1d, 0x8fb0);
23104                 MP_WritePhyUshort(sc, 0x1d, 0xb241);
23105                 MP_WritePhyUshort(sc, 0x1d, 0xa02a);
23106                 MP_WritePhyUshort(sc, 0x1d, 0x319d);
23107                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23108                 MP_WritePhyUshort(sc, 0x1d, 0x4ea0);
23109                 MP_WritePhyUshort(sc, 0x1d, 0x7c02);
23110                 MP_WritePhyUshort(sc, 0x1d, 0x4402);
23111                 MP_WritePhyUshort(sc, 0x1d, 0x4448);
23112                 MP_WritePhyUshort(sc, 0x1d, 0x4894);
23113                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23114                 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
23115                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23116                 MP_WritePhyUshort(sc, 0x1d, 0x4c03);
23117                 MP_WritePhyUshort(sc, 0x1d, 0x4824);
23118                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23119                 MP_WritePhyUshort(sc, 0x1d, 0x4c07);
23120                 MP_WritePhyUshort(sc, 0x1d, 0x41ef);
23121                 MP_WritePhyUshort(sc, 0x1d, 0x41ff);
23122                 MP_WritePhyUshort(sc, 0x1d, 0x4891);
23123                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23124                 MP_WritePhyUshort(sc, 0x1d, 0x4c07);
23125                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23126                 MP_WritePhyUshort(sc, 0x1d, 0x4c17);
23127                 MP_WritePhyUshort(sc, 0x1d, 0x8400);
23128                 MP_WritePhyUshort(sc, 0x1d, 0x8ef8);
23129                 MP_WritePhyUshort(sc, 0x1d, 0x41c7);
23130                 MP_WritePhyUshort(sc, 0x1d, 0x8f95);
23131                 MP_WritePhyUshort(sc, 0x1d, 0x92d5);
23132                 MP_WritePhyUshort(sc, 0x1d, 0xa10f);
23133                 MP_WritePhyUshort(sc, 0x1d, 0xd480);
23134                 MP_WritePhyUshort(sc, 0x1d, 0x0008);
23135                 MP_WritePhyUshort(sc, 0x1d, 0xd580);
23136                 MP_WritePhyUshort(sc, 0x1d, 0xffb9);
23137                 MP_WritePhyUshort(sc, 0x1d, 0xa202);
23138                 MP_WritePhyUshort(sc, 0x1d, 0x31b8);
23139                 MP_WritePhyUshort(sc, 0x1d, 0x7c04);
23140                 MP_WritePhyUshort(sc, 0x1d, 0x4404);
23141                 MP_WritePhyUshort(sc, 0x1d, 0x31b8);
23142                 MP_WritePhyUshort(sc, 0x1d, 0xd484);
23143                 MP_WritePhyUshort(sc, 0x1d, 0xfff3);
23144                 MP_WritePhyUshort(sc, 0x1d, 0xd484);
23145                 MP_WritePhyUshort(sc, 0x1d, 0xfff1);
23146                 MP_WritePhyUshort(sc, 0x1d, 0x314d);
23147                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23148                 MP_WritePhyUshort(sc, 0x1d, 0x4ee0);
23149                 MP_WritePhyUshort(sc, 0x1d, 0x7c40);
23150                 MP_WritePhyUshort(sc, 0x1d, 0x5400);
23151                 MP_WritePhyUshort(sc, 0x1d, 0x4488);
23152                 MP_WritePhyUshort(sc, 0x1d, 0x41cf);
23153                 MP_WritePhyUshort(sc, 0x1d, 0x314d);
23154                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23155                 MP_WritePhyUshort(sc, 0x1d, 0x4ec0);
23156                 MP_WritePhyUshort(sc, 0x1d, 0x48f3);
23157                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23158                 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
23159                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23160                 MP_WritePhyUshort(sc, 0x1d, 0x4c09);
23161                 MP_WritePhyUshort(sc, 0x1d, 0x4508);
23162                 MP_WritePhyUshort(sc, 0x1d, 0x41c7);
23163                 MP_WritePhyUshort(sc, 0x1d, 0x8f24);
23164                 MP_WritePhyUshort(sc, 0x1d, 0xd218);
23165                 MP_WritePhyUshort(sc, 0x1d, 0x0022);
23166                 MP_WritePhyUshort(sc, 0x1d, 0xd2a4);
23167                 MP_WritePhyUshort(sc, 0x1d, 0xff9f);
23168                 MP_WritePhyUshort(sc, 0x1d, 0x31d9);
23169                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23170                 MP_WritePhyUshort(sc, 0x1d, 0x4e80);
23171                 MP_WritePhyUshort(sc, 0x1d, 0x4832);
23172                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23173                 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
23174                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23175                 MP_WritePhyUshort(sc, 0x1d, 0x4c11);
23176                 MP_WritePhyUshort(sc, 0x1d, 0x4428);
23177                 MP_WritePhyUshort(sc, 0x1d, 0x7c40);
23178                 MP_WritePhyUshort(sc, 0x1d, 0x5440);
23179                 MP_WritePhyUshort(sc, 0x1d, 0x7c01);
23180                 MP_WritePhyUshort(sc, 0x1d, 0x5801);
23181                 MP_WritePhyUshort(sc, 0x1d, 0x7c04);
23182                 MP_WritePhyUshort(sc, 0x1d, 0x5c04);
23183                 MP_WritePhyUshort(sc, 0x1d, 0x41e8);
23184                 MP_WritePhyUshort(sc, 0x1d, 0xa4b3);
23185                 MP_WritePhyUshort(sc, 0x1d, 0x31ee);
23186                 MP_WritePhyUshort(sc, 0x1d, 0x6800);
23187                 MP_WritePhyUshort(sc, 0x1d, 0x6736);
23188                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23189                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23190                 MP_WritePhyUshort(sc, 0x1d, 0x570f);
23191                 MP_WritePhyUshort(sc, 0x1d, 0x5fff);
23192                 MP_WritePhyUshort(sc, 0x1d, 0xaa03);
23193                 MP_WritePhyUshort(sc, 0x1d, 0x585b);
23194                 MP_WritePhyUshort(sc, 0x1d, 0x31fa);
23195                 MP_WritePhyUshort(sc, 0x1d, 0x5867);
23196                 MP_WritePhyUshort(sc, 0x1d, 0xbcf6);
23197                 MP_WritePhyUshort(sc, 0x1d, 0x300b);
23198                 MP_WritePhyUshort(sc, 0x1d, 0x300b);
23199                 MP_WritePhyUshort(sc, 0x1d, 0x314d);
23200                 MP_WritePhyUshort(sc, 0x1f, 0x0004);
23201                 MP_WritePhyUshort(sc, 0x1c, 0x0200);
23202                 MP_WritePhyUshort(sc, 0x19, 0x7030);
23203                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23204
23205                 if (CSR_READ_1(sc, 0xEF)&0x08) {
23206                         MP_WritePhyUshort(sc, 0x1F, 0x0005);
23207                         MP_WritePhyUshort(sc, 0x1A, 0x0004);
23208                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
23209                 } else {
23210                         MP_WritePhyUshort(sc, 0x1F, 0x0005);
23211                         MP_WritePhyUshort(sc, 0x1A, 0x0000);
23212                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
23213                 }
23214
23215                 if (CSR_READ_1(sc, 0xEF)&0x10) {
23216                         MP_WritePhyUshort(sc, 0x1F, 0x0004);
23217                         MP_WritePhyUshort(sc, 0x1C, 0x0000);
23218                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
23219                 } else {
23220                         MP_WritePhyUshort(sc, 0x1F, 0x0004);
23221                         MP_WritePhyUshort(sc, 0x1C, 0x0200);
23222                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
23223                 }
23224
23225                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
23226                 MP_WritePhyUshort(sc, 0x15, 0x7701);
23227                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
23228
23229                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
23230                 ClearEthPhyBit(sc, 0x1A, BIT_14);
23231
23232                 if (phy_power_saving == 1) {
23233                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
23234                         MP_WritePhyUshort(sc, 0x18, 0x8310);
23235                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
23236                 } else {
23237                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
23238                         MP_WritePhyUshort(sc, 0x18, 0x0310);
23239                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
23240                         DELAY(20000);
23241                 }
23242
23243                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
23244                 MP_WritePhyUshort(sc, 0x0D, 0x0007);
23245                 MP_WritePhyUshort(sc, 0x0E, 0x003C);
23246                 MP_WritePhyUshort(sc, 0x0D, 0x4007);
23247                 MP_WritePhyUshort(sc, 0x0E, 0x0000);
23248                 MP_WritePhyUshort(sc, 0x0D, 0x0000);
23249                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
23250                 MP_WritePhyUshort(sc, 0x0D, 0x0003);
23251                 MP_WritePhyUshort(sc, 0x0E, 0x0015);
23252                 MP_WritePhyUshort(sc, 0x0D, 0x4003);
23253                 MP_WritePhyUshort(sc, 0x0E, 0x0000);
23254                 MP_WritePhyUshort(sc, 0x0D, 0x0000);
23255
23256         } else if (sc->re_type == MACFG_50) {
23257                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
23258                 MP_WritePhyUshort(sc, 0x05, 0x8B80);
23259                 Data = MP_ReadPhyUshort(sc, 0x06);
23260                 Data |= BIT_2 | BIT_1;
23261                 MP_WritePhyUshort(sc, 0x06, Data);
23262                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23263
23264                 MP_WritePhyUshort(sc, 0x1F, 0x0007);
23265                 MP_WritePhyUshort(sc, 0x1E, 0x002D);
23266                 Data = MP_ReadPhyUshort(sc, 0x18);
23267                 Data |= BIT_4;
23268                 MP_WritePhyUshort(sc, 0x18, Data);
23269                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23270                 Data = MP_ReadPhyUshort(sc, 0x14);
23271                 Data |= BIT_15;
23272                 MP_WritePhyUshort(sc, 0x14, Data);
23273
23274                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
23275                 MP_WritePhyUshort(sc, 0x05, 0x8B86);
23276                 Data = MP_ReadPhyUshort(sc, 0x06);
23277                 Data |= BIT_0;
23278                 MP_WritePhyUshort(sc, 0x06, Data);
23279                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23280
23281                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
23282                 MP_WritePhyUshort(sc, 0x05, 0x8B85);
23283                 Data = MP_ReadPhyUshort(sc, 0x06);
23284                 Data |= BIT_14;
23285                 MP_WritePhyUshort(sc, 0x06, Data);
23286                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23287
23288                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
23289                 MP_WritePhyUshort(sc, 0x09, 0xA20F);
23290                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
23291
23292                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
23293                 MP_WritePhyUshort(sc, 0x05, 0x8B55);
23294                 MP_WritePhyUshort(sc, 0x06, 0x0000);
23295                 MP_WritePhyUshort(sc, 0x05, 0x8B5E);
23296                 MP_WritePhyUshort(sc, 0x06, 0x0000);
23297                 MP_WritePhyUshort(sc, 0x05, 0x8B67);
23298                 MP_WritePhyUshort(sc, 0x06, 0x0000);
23299                 MP_WritePhyUshort(sc, 0x05, 0x8B70);
23300                 MP_WritePhyUshort(sc, 0x06, 0x0000);
23301                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23302                 MP_WritePhyUshort(sc, 0x1F, 0x0007);
23303                 MP_WritePhyUshort(sc, 0x1E, 0x0078);
23304                 MP_WritePhyUshort(sc, 0x17, 0x0000);
23305                 MP_WritePhyUshort(sc, 0x19, 0x00FB);
23306                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23307
23308                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
23309                 MP_WritePhyUshort(sc, 0x05, 0x8B79);
23310                 MP_WritePhyUshort(sc, 0x06, 0xAA00);
23311                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23312
23313                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
23314                 MP_WritePhyUshort(sc, 0x01, 0x328A);
23315                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
23316
23317                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
23318                 MP_WritePhyUshort(sc, 0x05, 0x8B54);
23319                 Data = MP_ReadPhyUshort(sc, 0x06);
23320                 Data &= ~BIT_11;
23321                 MP_WritePhyUshort(sc, 0x06, Data);
23322                 MP_WritePhyUshort(sc, 0x05, 0x8B5D);
23323                 Data = MP_ReadPhyUshort(sc, 0x06);
23324                 Data &= ~BIT_11;
23325                 MP_WritePhyUshort(sc, 0x06, Data);
23326                 MP_WritePhyUshort(sc, 0x05, 0x8A7C);
23327                 Data = MP_ReadPhyUshort(sc, 0x06);
23328                 Data &= ~BIT_8;
23329                 MP_WritePhyUshort(sc, 0x06, Data);
23330                 MP_WritePhyUshort(sc, 0x05, 0x8A7F);
23331                 Data = MP_ReadPhyUshort(sc, 0x06);
23332                 Data |= BIT_8;
23333                 MP_WritePhyUshort(sc, 0x06, Data);
23334                 MP_WritePhyUshort(sc, 0x05, 0x8A82);
23335                 Data = MP_ReadPhyUshort(sc, 0x06);
23336                 Data &= ~BIT_8;
23337                 MP_WritePhyUshort(sc, 0x06, Data);
23338                 MP_WritePhyUshort(sc, 0x05, 0x8A85);
23339                 Data = MP_ReadPhyUshort(sc, 0x06);
23340                 Data &= ~BIT_8;
23341                 MP_WritePhyUshort(sc, 0x06, Data);
23342                 MP_WritePhyUshort(sc, 0x05, 0x8A88);
23343                 Data = MP_ReadPhyUshort(sc, 0x06);
23344                 Data &= ~BIT_8;
23345                 MP_WritePhyUshort(sc, 0x06, Data);
23346                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
23347
23348                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
23349                 MP_WritePhyUshort(sc, 0x05, 0x8B85);
23350                 Data = MP_ReadPhyUshort(sc, 0x06);
23351                 Data |= BIT_15;
23352                 MP_WritePhyUshort(sc, 0x06, Data);
23353                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23354
23355                 MP_WritePhyUshort(sc, 0x1f, 0x0003);
23356                 Data = MP_ReadPhyUshort(sc, 0x19);
23357                 Data &= ~BIT_0;
23358                 MP_WritePhyUshort(sc, 0x19, Data);
23359                 Data = MP_ReadPhyUshort(sc, 0x10);
23360                 Data &= ~BIT_10;
23361                 MP_WritePhyUshort(sc, 0x10, Data);
23362                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23363         } else if (sc->re_type == MACFG_51) {
23364                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
23365                 MP_WritePhyUshort(sc, 0x05, 0x8B80);
23366                 Data = MP_ReadPhyUshort(sc, 0x06);
23367                 Data |= BIT_2 | BIT_1;
23368                 MP_WritePhyUshort(sc, 0x06, Data);
23369                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23370
23371                 MP_WritePhyUshort(sc, 0x1F, 0x0007);
23372                 MP_WritePhyUshort(sc, 0x1E, 0x002D);
23373                 Data = MP_ReadPhyUshort(sc, 0x18);
23374                 Data |= BIT_4;
23375                 MP_WritePhyUshort(sc, 0x18, Data);
23376                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23377                 Data = MP_ReadPhyUshort(sc, 0x14);
23378                 Data |= BIT_15;
23379                 MP_WritePhyUshort(sc, 0x14, Data);
23380
23381                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
23382                 MP_WritePhyUshort(sc, 0x05, 0x8B86);
23383                 Data = MP_ReadPhyUshort(sc, 0x06);
23384                 Data |= BIT_0;
23385                 MP_WritePhyUshort(sc, 0x06, Data);
23386                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23387
23388                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
23389                 MP_WritePhyUshort(sc, 0x05, 0x8B54);
23390                 Data = MP_ReadPhyUshort(sc, 0x06);
23391                 Data &= ~BIT_11;
23392                 MP_WritePhyUshort(sc, 0x06, Data);
23393                 MP_WritePhyUshort(sc, 0x05, 0x8B5D);
23394                 Data = MP_ReadPhyUshort(sc, 0x06);
23395                 Data &= ~BIT_11;
23396                 MP_WritePhyUshort(sc, 0x06, Data);
23397                 MP_WritePhyUshort(sc, 0x05, 0x8A7C);
23398                 Data = MP_ReadPhyUshort(sc, 0x06);
23399                 Data &= ~BIT_8;
23400                 MP_WritePhyUshort(sc, 0x06, Data);
23401                 MP_WritePhyUshort(sc, 0x05, 0x8A7F);
23402                 Data = MP_ReadPhyUshort(sc, 0x06);
23403                 Data |= BIT_8;
23404                 MP_WritePhyUshort(sc, 0x06, Data);
23405                 MP_WritePhyUshort(sc, 0x05, 0x8A82);
23406                 Data = MP_ReadPhyUshort(sc, 0x06);
23407                 Data &= ~BIT_8;
23408                 MP_WritePhyUshort(sc, 0x06, Data);
23409                 MP_WritePhyUshort(sc, 0x05, 0x8A85);
23410                 Data = MP_ReadPhyUshort(sc, 0x06);
23411                 Data &= ~BIT_8;
23412                 MP_WritePhyUshort(sc, 0x06, Data);
23413                 MP_WritePhyUshort(sc, 0x05, 0x8A88);
23414                 Data = MP_ReadPhyUshort(sc, 0x06);
23415                 Data &= ~BIT_8;
23416                 MP_WritePhyUshort(sc, 0x06, Data);
23417                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
23418
23419                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
23420                 MP_WritePhyUshort(sc, 0x05, 0x8B85);
23421                 Data = MP_ReadPhyUshort(sc, 0x06);
23422                 Data |= BIT_15;
23423                 MP_WritePhyUshort(sc, 0x06, Data);
23424                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23425
23426                 MP_WritePhyUshort(sc, 0x1f, 0x0003);
23427                 Data = MP_ReadPhyUshort(sc, 0x19);
23428                 Data &= ~BIT_0;
23429                 MP_WritePhyUshort(sc, 0x19, Data);
23430                 Data = MP_ReadPhyUshort(sc, 0x10);
23431                 Data &= ~BIT_10;
23432                 MP_WritePhyUshort(sc, 0x10, Data);
23433                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23434         } else if (sc->re_type == MACFG_52) {
23435                 Data_u32 = re_eri_read(sc, 0x1D0, 4, ERIAR_ExGMAC);
23436                 Data_u32 &= ~BIT_1;
23437                 re_eri_write(sc, 0x1D0, 4, Data_u32, ERIAR_ExGMAC);
23438
23439                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
23440                 MP_WritePhyUshort(sc, 0x05, 0x8B80);
23441                 Data = MP_ReadPhyUshort(sc, 0x06);
23442                 Data |= BIT_2 | BIT_1;
23443                 MP_WritePhyUshort(sc, 0x06, Data);
23444                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23445
23446                 MP_WritePhyUshort(sc, 0x1F, 0x0007);
23447                 MP_WritePhyUshort(sc, 0x1E, 0x002D);
23448                 Data = MP_ReadPhyUshort(sc, 0x18);
23449                 Data |= BIT_4;
23450                 MP_WritePhyUshort(sc, 0x18, Data);
23451                 MP_WritePhyUshort(sc, 0x1f, 0x0002);
23452                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23453                 Data = MP_ReadPhyUshort(sc, 0x14);
23454                 Data |= BIT_15;
23455                 MP_WritePhyUshort(sc, 0x14, Data);
23456
23457                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
23458                 MP_WritePhyUshort(sc, 0x05, 0x8B86);
23459                 Data = MP_ReadPhyUshort(sc, 0x06);
23460                 Data |= BIT_0;
23461                 MP_WritePhyUshort(sc, 0x06, Data);
23462                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23463
23464                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
23465                 MP_WritePhyUshort(sc, 0x05, 0x8B85);
23466                 Data = MP_ReadPhyUshort(sc, 0x06);
23467                 Data |= BIT_14;
23468                 MP_WritePhyUshort(sc, 0x06, Data);
23469                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23470
23471                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
23472                 MP_WritePhyUshort(sc, 0x09, 0xA20F);
23473                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
23474
23475                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
23476                 MP_WritePhyUshort(sc, 0x05, 0x8B55);
23477                 MP_WritePhyUshort(sc, 0x06, 0x0000);
23478                 MP_WritePhyUshort(sc, 0x05, 0x8B5E);
23479                 MP_WritePhyUshort(sc, 0x06, 0x0000);
23480                 MP_WritePhyUshort(sc, 0x05, 0x8B67);
23481                 MP_WritePhyUshort(sc, 0x06, 0x0000);
23482                 MP_WritePhyUshort(sc, 0x05, 0x8B70);
23483                 MP_WritePhyUshort(sc, 0x06, 0x0000);
23484                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23485                 MP_WritePhyUshort(sc, 0x1F, 0x0007);
23486                 MP_WritePhyUshort(sc, 0x1E, 0x0078);
23487                 MP_WritePhyUshort(sc, 0x17, 0x0000);
23488                 MP_WritePhyUshort(sc, 0x19, 0x00FB);
23489                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23490
23491                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
23492                 MP_WritePhyUshort(sc, 0x05, 0x8B79);
23493                 MP_WritePhyUshort(sc, 0x06, 0xAA00);
23494                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23495
23496                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
23497                 MP_WritePhyUshort(sc, 0x01, 0x328A);
23498                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
23499
23500                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
23501                 MP_WritePhyUshort(sc, 0x05, 0x8B54);
23502                 Data = MP_ReadPhyUshort(sc, 0x06);
23503                 Data &= ~BIT_11;
23504                 MP_WritePhyUshort(sc, 0x06, Data);
23505                 MP_WritePhyUshort(sc, 0x05, 0x8B5D);
23506                 Data = MP_ReadPhyUshort(sc, 0x06);
23507                 Data &= ~BIT_11;
23508                 MP_WritePhyUshort(sc, 0x06, Data);
23509                 MP_WritePhyUshort(sc, 0x05, 0x8A7C);
23510                 Data = MP_ReadPhyUshort(sc, 0x06);
23511                 Data &= ~BIT_8;
23512                 MP_WritePhyUshort(sc, 0x06, Data);
23513                 MP_WritePhyUshort(sc, 0x05, 0x8A7F);
23514                 Data = MP_ReadPhyUshort(sc, 0x06);
23515                 Data |= BIT_8;
23516                 MP_WritePhyUshort(sc, 0x06, Data);
23517                 MP_WritePhyUshort(sc, 0x05, 0x8A82);
23518                 Data = MP_ReadPhyUshort(sc, 0x06);
23519                 Data &= ~BIT_8;
23520                 MP_WritePhyUshort(sc, 0x06, Data);
23521                 MP_WritePhyUshort(sc, 0x05, 0x8A85);
23522                 Data = MP_ReadPhyUshort(sc, 0x06);
23523                 Data &= ~BIT_8;
23524                 MP_WritePhyUshort(sc, 0x06, Data);
23525                 MP_WritePhyUshort(sc, 0x05, 0x8A88);
23526                 Data = MP_ReadPhyUshort(sc, 0x06);
23527                 Data &= ~BIT_8;
23528                 MP_WritePhyUshort(sc, 0x06, Data);
23529                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
23530
23531                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
23532                 MP_WritePhyUshort(sc, 0x05, 0x8B85);
23533                 Data = MP_ReadPhyUshort(sc, 0x06);
23534                 Data |= BIT_15;
23535                 MP_WritePhyUshort(sc, 0x06, Data);
23536                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23537
23538                 MP_WritePhyUshort(sc, 0x1f, 0x0003);
23539                 Data = MP_ReadPhyUshort(sc, 0x19);
23540                 Data &= ~BIT_0;
23541                 MP_WritePhyUshort(sc, 0x19, Data);
23542                 Data = MP_ReadPhyUshort(sc, 0x10);
23543                 Data &= ~BIT_10;
23544                 MP_WritePhyUshort(sc, 0x10, Data);
23545                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23546         } else if (sc->re_type == MACFG_53) {
23547                 Data_u32 = re_eri_read(sc, 0x1D0, 4, ERIAR_ExGMAC);
23548                 Data_u32 &= 0xFFFF0000;
23549                 re_eri_write(sc, 0x1D0, 4, Data_u32, ERIAR_ExGMAC);
23550
23551                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
23552                 MP_WritePhyUshort(sc, 0x18, 0x0310);
23553                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
23554
23555                 MP_WritePhyUshort(sc, 0x1f, 0x0004);
23556                 MP_WritePhyUshort(sc, 0x1f, 0x0004);
23557                 MP_WritePhyUshort(sc, 0x19, 0x7070);
23558                 MP_WritePhyUshort(sc, 0x1c, 0x0600);
23559                 MP_WritePhyUshort(sc, 0x1d, 0x9700);
23560                 MP_WritePhyUshort(sc, 0x1d, 0x7d00);
23561                 MP_WritePhyUshort(sc, 0x1d, 0x6900);
23562                 MP_WritePhyUshort(sc, 0x1d, 0x7d00);
23563                 MP_WritePhyUshort(sc, 0x1d, 0x6800);
23564                 MP_WritePhyUshort(sc, 0x1d, 0x4899);
23565                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23566                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
23567                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23568                 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
23569                 MP_WritePhyUshort(sc, 0x1d, 0x8000);
23570                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23571                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
23572                 MP_WritePhyUshort(sc, 0x1d, 0x4007);
23573                 MP_WritePhyUshort(sc, 0x1d, 0x4400);
23574                 MP_WritePhyUshort(sc, 0x1d, 0x4800);
23575                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23576                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
23577                 MP_WritePhyUshort(sc, 0x1d, 0x5310);
23578                 MP_WritePhyUshort(sc, 0x1d, 0x6000);
23579                 MP_WritePhyUshort(sc, 0x1d, 0x6800);
23580                 MP_WritePhyUshort(sc, 0x1d, 0x6736);
23581                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23582                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23583                 MP_WritePhyUshort(sc, 0x1d, 0x571f);
23584                 MP_WritePhyUshort(sc, 0x1d, 0x5ffb);
23585                 MP_WritePhyUshort(sc, 0x1d, 0xaa03);
23586                 MP_WritePhyUshort(sc, 0x1d, 0x5b58);
23587                 MP_WritePhyUshort(sc, 0x1d, 0x301e);
23588                 MP_WritePhyUshort(sc, 0x1d, 0x5b64);
23589                 MP_WritePhyUshort(sc, 0x1d, 0xa6fc);
23590                 MP_WritePhyUshort(sc, 0x1d, 0xdcdb);
23591                 MP_WritePhyUshort(sc, 0x1d, 0x0015);
23592                 MP_WritePhyUshort(sc, 0x1d, 0xb915);
23593                 MP_WritePhyUshort(sc, 0x1d, 0xb511);
23594                 MP_WritePhyUshort(sc, 0x1d, 0xd16b);
23595                 MP_WritePhyUshort(sc, 0x1d, 0x000f);
23596                 MP_WritePhyUshort(sc, 0x1d, 0xb40f);
23597                 MP_WritePhyUshort(sc, 0x1d, 0xd06b);
23598                 MP_WritePhyUshort(sc, 0x1d, 0x000d);
23599                 MP_WritePhyUshort(sc, 0x1d, 0xb206);
23600                 MP_WritePhyUshort(sc, 0x1d, 0x7c01);
23601                 MP_WritePhyUshort(sc, 0x1d, 0x5800);
23602                 MP_WritePhyUshort(sc, 0x1d, 0x7c04);
23603                 MP_WritePhyUshort(sc, 0x1d, 0x5c00);
23604                 MP_WritePhyUshort(sc, 0x1d, 0x301a);
23605                 MP_WritePhyUshort(sc, 0x1d, 0x7c01);
23606                 MP_WritePhyUshort(sc, 0x1d, 0x5801);
23607                 MP_WritePhyUshort(sc, 0x1d, 0x7c04);
23608                 MP_WritePhyUshort(sc, 0x1d, 0x5c04);
23609                 MP_WritePhyUshort(sc, 0x1d, 0x301e);
23610                 MP_WritePhyUshort(sc, 0x1d, 0x3079);
23611                 MP_WritePhyUshort(sc, 0x1d, 0x30f1);
23612                 MP_WritePhyUshort(sc, 0x1d, 0x3199);
23613                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23614                 MP_WritePhyUshort(sc, 0x1d, 0x4c60);
23615                 MP_WritePhyUshort(sc, 0x1d, 0x6803);
23616                 MP_WritePhyUshort(sc, 0x1d, 0x6420);
23617                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23618                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23619                 MP_WritePhyUshort(sc, 0x1d, 0xaf03);
23620                 MP_WritePhyUshort(sc, 0x1d, 0x6015);
23621                 MP_WritePhyUshort(sc, 0x1d, 0x3040);
23622                 MP_WritePhyUshort(sc, 0x1d, 0x6017);
23623                 MP_WritePhyUshort(sc, 0x1d, 0x57e0);
23624                 MP_WritePhyUshort(sc, 0x1d, 0x580c);
23625                 MP_WritePhyUshort(sc, 0x1d, 0x588c);
23626                 MP_WritePhyUshort(sc, 0x1d, 0x5fa3);
23627                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23628                 MP_WritePhyUshort(sc, 0x1d, 0x4827);
23629                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23630                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
23631                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23632                 MP_WritePhyUshort(sc, 0x1d, 0x4c10);
23633                 MP_WritePhyUshort(sc, 0x1d, 0x8400);
23634                 MP_WritePhyUshort(sc, 0x1d, 0x7c30);
23635                 MP_WritePhyUshort(sc, 0x1d, 0x6020);
23636                 MP_WritePhyUshort(sc, 0x1d, 0x48bf);
23637                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23638                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
23639                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23640                 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
23641                 MP_WritePhyUshort(sc, 0x1d, 0xd6cf);
23642                 MP_WritePhyUshort(sc, 0x1d, 0x0002);
23643                 MP_WritePhyUshort(sc, 0x1d, 0x80fe);
23644                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23645                 MP_WritePhyUshort(sc, 0x1d, 0x4c80);
23646                 MP_WritePhyUshort(sc, 0x1d, 0x7c20);
23647                 MP_WritePhyUshort(sc, 0x1d, 0x5c20);
23648                 MP_WritePhyUshort(sc, 0x1d, 0x481e);
23649                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23650                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
23651                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23652                 MP_WritePhyUshort(sc, 0x1d, 0x4c02);
23653                 MP_WritePhyUshort(sc, 0x1d, 0x5310);
23654                 MP_WritePhyUshort(sc, 0x1d, 0x81ff);
23655                 MP_WritePhyUshort(sc, 0x1d, 0x30ba);
23656                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23657                 MP_WritePhyUshort(sc, 0x1d, 0x4d00);
23658                 MP_WritePhyUshort(sc, 0x1d, 0x4832);
23659                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23660                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
23661                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23662                 MP_WritePhyUshort(sc, 0x1d, 0x4c10);
23663                 MP_WritePhyUshort(sc, 0x1d, 0x7c08);
23664                 MP_WritePhyUshort(sc, 0x1d, 0x6000);
23665                 MP_WritePhyUshort(sc, 0x1d, 0xa4cc);
23666                 MP_WritePhyUshort(sc, 0x1d, 0xd9b3);
23667                 MP_WritePhyUshort(sc, 0x1d, 0xfffe);
23668                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23669                 MP_WritePhyUshort(sc, 0x1d, 0x4d20);
23670                 MP_WritePhyUshort(sc, 0x1d, 0x7e00);
23671                 MP_WritePhyUshort(sc, 0x1d, 0x6200);
23672                 MP_WritePhyUshort(sc, 0x1d, 0x300b);
23673                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23674                 MP_WritePhyUshort(sc, 0x1d, 0x4dc0);
23675                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23676                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23677                 MP_WritePhyUshort(sc, 0x1d, 0xd09d);
23678                 MP_WritePhyUshort(sc, 0x1d, 0x0002);
23679                 MP_WritePhyUshort(sc, 0x1d, 0xb4fe);
23680                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23681                 MP_WritePhyUshort(sc, 0x1d, 0x4d80);
23682                 MP_WritePhyUshort(sc, 0x1d, 0x7c04);
23683                 MP_WritePhyUshort(sc, 0x1d, 0x6004);
23684                 MP_WritePhyUshort(sc, 0x1d, 0x5310);
23685                 MP_WritePhyUshort(sc, 0x1d, 0x6802);
23686                 MP_WritePhyUshort(sc, 0x1d, 0x6720);
23687                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23688                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23689                 MP_WritePhyUshort(sc, 0x1d, 0x7c08);
23690                 MP_WritePhyUshort(sc, 0x1d, 0x6000);
23691                 MP_WritePhyUshort(sc, 0x1d, 0x486c);
23692                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23693                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
23694                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23695                 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
23696                 MP_WritePhyUshort(sc, 0x1d, 0x9503);
23697                 MP_WritePhyUshort(sc, 0x1d, 0x7e00);
23698                 MP_WritePhyUshort(sc, 0x1d, 0x6200);
23699                 MP_WritePhyUshort(sc, 0x1d, 0x571f);
23700                 MP_WritePhyUshort(sc, 0x1d, 0x5fbb);
23701                 MP_WritePhyUshort(sc, 0x1d, 0xaa03);
23702                 MP_WritePhyUshort(sc, 0x1d, 0x5b58);
23703                 MP_WritePhyUshort(sc, 0x1d, 0x3092);
23704                 MP_WritePhyUshort(sc, 0x1d, 0x5b64);
23705                 MP_WritePhyUshort(sc, 0x1d, 0xcdab);
23706                 MP_WritePhyUshort(sc, 0x1d, 0xff78);
23707                 MP_WritePhyUshort(sc, 0x1d, 0xcd8d);
23708                 MP_WritePhyUshort(sc, 0x1d, 0xff76);
23709                 MP_WritePhyUshort(sc, 0x1d, 0xd96b);
23710                 MP_WritePhyUshort(sc, 0x1d, 0xff74);
23711                 MP_WritePhyUshort(sc, 0x1d, 0xd0a0);
23712                 MP_WritePhyUshort(sc, 0x1d, 0xffd9);
23713                 MP_WritePhyUshort(sc, 0x1d, 0xcba0);
23714                 MP_WritePhyUshort(sc, 0x1d, 0x0003);
23715                 MP_WritePhyUshort(sc, 0x1d, 0x80f0);
23716                 MP_WritePhyUshort(sc, 0x1d, 0x309f);
23717                 MP_WritePhyUshort(sc, 0x1d, 0x30ac);
23718                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23719                 MP_WritePhyUshort(sc, 0x1d, 0x4ce0);
23720                 MP_WritePhyUshort(sc, 0x1d, 0x4832);
23721                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23722                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
23723                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23724                 MP_WritePhyUshort(sc, 0x1d, 0x4c08);
23725                 MP_WritePhyUshort(sc, 0x1d, 0x7c08);
23726                 MP_WritePhyUshort(sc, 0x1d, 0x6008);
23727                 MP_WritePhyUshort(sc, 0x1d, 0x8300);
23728                 MP_WritePhyUshort(sc, 0x1d, 0xb902);
23729                 MP_WritePhyUshort(sc, 0x1d, 0x3079);
23730                 MP_WritePhyUshort(sc, 0x1d, 0x3061);
23731                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23732                 MP_WritePhyUshort(sc, 0x1d, 0x4da0);
23733                 MP_WritePhyUshort(sc, 0x1d, 0x6400);
23734                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23735                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23736                 MP_WritePhyUshort(sc, 0x1d, 0x57a0);
23737                 MP_WritePhyUshort(sc, 0x1d, 0x590c);
23738                 MP_WritePhyUshort(sc, 0x1d, 0x5fa3);
23739                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23740                 MP_WritePhyUshort(sc, 0x1d, 0xcba4);
23741                 MP_WritePhyUshort(sc, 0x1d, 0x0004);
23742                 MP_WritePhyUshort(sc, 0x1d, 0xcd8d);
23743                 MP_WritePhyUshort(sc, 0x1d, 0x0002);
23744                 MP_WritePhyUshort(sc, 0x1d, 0x80fc);
23745                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23746                 MP_WritePhyUshort(sc, 0x1d, 0x4ca0);
23747                 MP_WritePhyUshort(sc, 0x1d, 0xb603);
23748                 MP_WritePhyUshort(sc, 0x1d, 0x7c10);
23749                 MP_WritePhyUshort(sc, 0x1d, 0x6010);
23750                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23751                 MP_WritePhyUshort(sc, 0x1d, 0x541f);
23752                 MP_WritePhyUshort(sc, 0x1d, 0x5fb3);
23753                 MP_WritePhyUshort(sc, 0x1d, 0xaa05);
23754                 MP_WritePhyUshort(sc, 0x1d, 0x7c80);
23755                 MP_WritePhyUshort(sc, 0x1d, 0x5800);
23756                 MP_WritePhyUshort(sc, 0x1d, 0x5b58);
23757                 MP_WritePhyUshort(sc, 0x1d, 0x30ca);
23758                 MP_WritePhyUshort(sc, 0x1d, 0x7c80);
23759                 MP_WritePhyUshort(sc, 0x1d, 0x5800);
23760                 MP_WritePhyUshort(sc, 0x1d, 0x5b64);
23761                 MP_WritePhyUshort(sc, 0x1d, 0x4824);
23762                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23763                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
23764                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23765                 MP_WritePhyUshort(sc, 0x1d, 0x4c04);
23766                 MP_WritePhyUshort(sc, 0x1d, 0x8200);
23767                 MP_WritePhyUshort(sc, 0x1d, 0x4827);
23768                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23769                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
23770                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23771                 MP_WritePhyUshort(sc, 0x1d, 0x4c10);
23772                 MP_WritePhyUshort(sc, 0x1d, 0x8400);
23773                 MP_WritePhyUshort(sc, 0x1d, 0x7c10);
23774                 MP_WritePhyUshort(sc, 0x1d, 0x6000);
23775                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23776                 MP_WritePhyUshort(sc, 0x1d, 0x4cc0);
23777                 MP_WritePhyUshort(sc, 0x1d, 0x5fbb);
23778                 MP_WritePhyUshort(sc, 0x1d, 0x4824);
23779                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23780                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
23781                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23782                 MP_WritePhyUshort(sc, 0x1d, 0x4c04);
23783                 MP_WritePhyUshort(sc, 0x1d, 0x8200);
23784                 MP_WritePhyUshort(sc, 0x1d, 0x7ce0);
23785                 MP_WritePhyUshort(sc, 0x1d, 0x5400);
23786                 MP_WritePhyUshort(sc, 0x1d, 0x6720);
23787                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23788                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23789                 MP_WritePhyUshort(sc, 0x1d, 0x7e00);
23790                 MP_WritePhyUshort(sc, 0x1d, 0x6a00);
23791                 MP_WritePhyUshort(sc, 0x1d, 0x4824);
23792                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23793                 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
23794                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23795                 MP_WritePhyUshort(sc, 0x1d, 0x4c04);
23796                 MP_WritePhyUshort(sc, 0x1d, 0x8200);
23797                 MP_WritePhyUshort(sc, 0x1d, 0x7e00);
23798                 MP_WritePhyUshort(sc, 0x1d, 0x6800);
23799                 MP_WritePhyUshort(sc, 0x1d, 0x309f);
23800                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23801                 MP_WritePhyUshort(sc, 0x1d, 0x4e00);
23802                 MP_WritePhyUshort(sc, 0x1d, 0x4007);
23803                 MP_WritePhyUshort(sc, 0x1d, 0x4400);
23804                 MP_WritePhyUshort(sc, 0x1d, 0x5310);
23805                 MP_WritePhyUshort(sc, 0x1d, 0x6800);
23806                 MP_WritePhyUshort(sc, 0x1d, 0x6736);
23807                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23808                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23809                 MP_WritePhyUshort(sc, 0x1d, 0x570f);
23810                 MP_WritePhyUshort(sc, 0x1d, 0x5fff);
23811                 MP_WritePhyUshort(sc, 0x1d, 0xaa03);
23812                 MP_WritePhyUshort(sc, 0x1d, 0x585b);
23813                 MP_WritePhyUshort(sc, 0x1d, 0x3100);
23814                 MP_WritePhyUshort(sc, 0x1d, 0x5867);
23815                 MP_WritePhyUshort(sc, 0x1d, 0x9403);
23816                 MP_WritePhyUshort(sc, 0x1d, 0x7e00);
23817                 MP_WritePhyUshort(sc, 0x1d, 0x6200);
23818                 MP_WritePhyUshort(sc, 0x1d, 0xcda3);
23819                 MP_WritePhyUshort(sc, 0x1d, 0x002d);
23820                 MP_WritePhyUshort(sc, 0x1d, 0xcd85);
23821                 MP_WritePhyUshort(sc, 0x1d, 0x002b);
23822                 MP_WritePhyUshort(sc, 0x1d, 0xd96b);
23823                 MP_WritePhyUshort(sc, 0x1d, 0x0029);
23824                 MP_WritePhyUshort(sc, 0x1d, 0x9629);
23825                 MP_WritePhyUshort(sc, 0x1d, 0x6800);
23826                 MP_WritePhyUshort(sc, 0x1d, 0x6736);
23827                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23828                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23829                 MP_WritePhyUshort(sc, 0x1d, 0x9624);
23830                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23831                 MP_WritePhyUshort(sc, 0x1d, 0x4e20);
23832                 MP_WritePhyUshort(sc, 0x1d, 0x8b04);
23833                 MP_WritePhyUshort(sc, 0x1d, 0x7c08);
23834                 MP_WritePhyUshort(sc, 0x1d, 0x5008);
23835                 MP_WritePhyUshort(sc, 0x1d, 0xab03);
23836                 MP_WritePhyUshort(sc, 0x1d, 0x7c08);
23837                 MP_WritePhyUshort(sc, 0x1d, 0x5000);
23838                 MP_WritePhyUshort(sc, 0x1d, 0x6801);
23839                 MP_WritePhyUshort(sc, 0x1d, 0x6776);
23840                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23841                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23842                 MP_WritePhyUshort(sc, 0x1d, 0xdb7c);
23843                 MP_WritePhyUshort(sc, 0x1d, 0xffee);
23844                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23845                 MP_WritePhyUshort(sc, 0x1d, 0x7fe1);
23846                 MP_WritePhyUshort(sc, 0x1d, 0x4e40);
23847                 MP_WritePhyUshort(sc, 0x1d, 0x4837);
23848                 MP_WritePhyUshort(sc, 0x1d, 0x4418);
23849                 MP_WritePhyUshort(sc, 0x1d, 0x41c7);
23850                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23851                 MP_WritePhyUshort(sc, 0x1d, 0x4e40);
23852                 MP_WritePhyUshort(sc, 0x1d, 0x7c40);
23853                 MP_WritePhyUshort(sc, 0x1d, 0x5400);
23854                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23855                 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
23856                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23857                 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
23858                 MP_WritePhyUshort(sc, 0x1d, 0x8f07);
23859                 MP_WritePhyUshort(sc, 0x1d, 0xd2a0);
23860                 MP_WritePhyUshort(sc, 0x1d, 0x004c);
23861                 MP_WritePhyUshort(sc, 0x1d, 0x9205);
23862                 MP_WritePhyUshort(sc, 0x1d, 0xa043);
23863                 MP_WritePhyUshort(sc, 0x1d, 0x312b);
23864                 MP_WritePhyUshort(sc, 0x1d, 0x300b);
23865                 MP_WritePhyUshort(sc, 0x1d, 0x30f1);
23866                 MP_WritePhyUshort(sc, 0x1d, 0x7fe1);
23867                 MP_WritePhyUshort(sc, 0x1d, 0x4e60);
23868                 MP_WritePhyUshort(sc, 0x1d, 0x489c);
23869                 MP_WritePhyUshort(sc, 0x1d, 0x4628);
23870                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23871                 MP_WritePhyUshort(sc, 0x1d, 0x4e60);
23872                 MP_WritePhyUshort(sc, 0x1d, 0x7e28);
23873                 MP_WritePhyUshort(sc, 0x1d, 0x4628);
23874                 MP_WritePhyUshort(sc, 0x1d, 0x7c40);
23875                 MP_WritePhyUshort(sc, 0x1d, 0x5400);
23876                 MP_WritePhyUshort(sc, 0x1d, 0x7c01);
23877                 MP_WritePhyUshort(sc, 0x1d, 0x5800);
23878                 MP_WritePhyUshort(sc, 0x1d, 0x7c04);
23879                 MP_WritePhyUshort(sc, 0x1d, 0x5c00);
23880                 MP_WritePhyUshort(sc, 0x1d, 0x41e8);
23881                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23882                 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
23883                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23884                 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
23885                 MP_WritePhyUshort(sc, 0x1d, 0x8fec);
23886                 MP_WritePhyUshort(sc, 0x1d, 0xb241);
23887                 MP_WritePhyUshort(sc, 0x1d, 0xa02a);
23888                 MP_WritePhyUshort(sc, 0x1d, 0x3146);
23889                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23890                 MP_WritePhyUshort(sc, 0x1d, 0x4ea0);
23891                 MP_WritePhyUshort(sc, 0x1d, 0x7c02);
23892                 MP_WritePhyUshort(sc, 0x1d, 0x4402);
23893                 MP_WritePhyUshort(sc, 0x1d, 0x4448);
23894                 MP_WritePhyUshort(sc, 0x1d, 0x4894);
23895                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23896                 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
23897                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23898                 MP_WritePhyUshort(sc, 0x1d, 0x4c03);
23899                 MP_WritePhyUshort(sc, 0x1d, 0x4824);
23900                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23901                 MP_WritePhyUshort(sc, 0x1d, 0x4c07);
23902                 MP_WritePhyUshort(sc, 0x1d, 0x41ef);
23903                 MP_WritePhyUshort(sc, 0x1d, 0x41ff);
23904                 MP_WritePhyUshort(sc, 0x1d, 0x4891);
23905                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23906                 MP_WritePhyUshort(sc, 0x1d, 0x4c07);
23907                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23908                 MP_WritePhyUshort(sc, 0x1d, 0x4c17);
23909                 MP_WritePhyUshort(sc, 0x1d, 0x8400);
23910                 MP_WritePhyUshort(sc, 0x1d, 0x8ef8);
23911                 MP_WritePhyUshort(sc, 0x1d, 0x41c7);
23912                 MP_WritePhyUshort(sc, 0x1d, 0x8fd1);
23913                 MP_WritePhyUshort(sc, 0x1d, 0x92d5);
23914                 MP_WritePhyUshort(sc, 0x1d, 0xa10f);
23915                 MP_WritePhyUshort(sc, 0x1d, 0xd480);
23916                 MP_WritePhyUshort(sc, 0x1d, 0x0008);
23917                 MP_WritePhyUshort(sc, 0x1d, 0xd580);
23918                 MP_WritePhyUshort(sc, 0x1d, 0xffb7);
23919                 MP_WritePhyUshort(sc, 0x1d, 0xa202);
23920                 MP_WritePhyUshort(sc, 0x1d, 0x3161);
23921                 MP_WritePhyUshort(sc, 0x1d, 0x7c04);
23922                 MP_WritePhyUshort(sc, 0x1d, 0x4404);
23923                 MP_WritePhyUshort(sc, 0x1d, 0x3161);
23924                 MP_WritePhyUshort(sc, 0x1d, 0xd484);
23925                 MP_WritePhyUshort(sc, 0x1d, 0xfff3);
23926                 MP_WritePhyUshort(sc, 0x1d, 0xd484);
23927                 MP_WritePhyUshort(sc, 0x1d, 0xfff1);
23928                 MP_WritePhyUshort(sc, 0x1d, 0x30f1);
23929                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23930                 MP_WritePhyUshort(sc, 0x1d, 0x4ee0);
23931                 MP_WritePhyUshort(sc, 0x1d, 0x7c40);
23932                 MP_WritePhyUshort(sc, 0x1d, 0x5400);
23933                 MP_WritePhyUshort(sc, 0x1d, 0x4488);
23934                 MP_WritePhyUshort(sc, 0x1d, 0x41cf);
23935                 MP_WritePhyUshort(sc, 0x1d, 0x30f1);
23936                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23937                 MP_WritePhyUshort(sc, 0x1d, 0x4ec0);
23938                 MP_WritePhyUshort(sc, 0x1d, 0x48f3);
23939                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23940                 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
23941                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23942                 MP_WritePhyUshort(sc, 0x1d, 0x4c09);
23943                 MP_WritePhyUshort(sc, 0x1d, 0x4508);
23944                 MP_WritePhyUshort(sc, 0x1d, 0x41c7);
23945                 MP_WritePhyUshort(sc, 0x1d, 0x8fb0);
23946                 MP_WritePhyUshort(sc, 0x1d, 0xd218);
23947                 MP_WritePhyUshort(sc, 0x1d, 0xffae);
23948                 MP_WritePhyUshort(sc, 0x1d, 0xd2a4);
23949                 MP_WritePhyUshort(sc, 0x1d, 0xff9d);
23950                 MP_WritePhyUshort(sc, 0x1d, 0x3182);
23951                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23952                 MP_WritePhyUshort(sc, 0x1d, 0x4e80);
23953                 MP_WritePhyUshort(sc, 0x1d, 0x4832);
23954                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23955                 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
23956                 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
23957                 MP_WritePhyUshort(sc, 0x1d, 0x4c11);
23958                 MP_WritePhyUshort(sc, 0x1d, 0x4428);
23959                 MP_WritePhyUshort(sc, 0x1d, 0x7c40);
23960                 MP_WritePhyUshort(sc, 0x1d, 0x5440);
23961                 MP_WritePhyUshort(sc, 0x1d, 0x7c01);
23962                 MP_WritePhyUshort(sc, 0x1d, 0x5801);
23963                 MP_WritePhyUshort(sc, 0x1d, 0x7c04);
23964                 MP_WritePhyUshort(sc, 0x1d, 0x5c04);
23965                 MP_WritePhyUshort(sc, 0x1d, 0x41e8);
23966                 MP_WritePhyUshort(sc, 0x1d, 0xa4b3);
23967                 MP_WritePhyUshort(sc, 0x1d, 0x3197);
23968                 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
23969                 MP_WritePhyUshort(sc, 0x1d, 0x4f20);
23970                 MP_WritePhyUshort(sc, 0x1d, 0x6800);
23971                 MP_WritePhyUshort(sc, 0x1d, 0x6736);
23972                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23973                 MP_WritePhyUshort(sc, 0x1d, 0x0000);
23974                 MP_WritePhyUshort(sc, 0x1d, 0x570f);
23975                 MP_WritePhyUshort(sc, 0x1d, 0x5fff);
23976                 MP_WritePhyUshort(sc, 0x1d, 0xaa03);
23977                 MP_WritePhyUshort(sc, 0x1d, 0x585b);
23978                 MP_WritePhyUshort(sc, 0x1d, 0x31a5);
23979                 MP_WritePhyUshort(sc, 0x1d, 0x5867);
23980                 MP_WritePhyUshort(sc, 0x1d, 0xbcf4);
23981                 MP_WritePhyUshort(sc, 0x1d, 0x300b);
23982                 MP_WritePhyUshort(sc, 0x1f, 0x0004);
23983                 MP_WritePhyUshort(sc, 0x1c, 0x0200);
23984                 MP_WritePhyUshort(sc, 0x19, 0x7030);
23985                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
23986
23987                 if (phy_power_saving == 1) {
23988                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
23989                         MP_WritePhyUshort(sc, 0x18, 0x8310);
23990                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
23991                 } else {
23992                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
23993                         MP_WritePhyUshort(sc, 0x18, 0x0310);
23994                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
23995                         DELAY(20000);
23996                 }
23997
23998                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
23999                 MP_WritePhyUshort(sc, 0x0D, 0x0007);
24000                 MP_WritePhyUshort(sc, 0x0E, 0x003C);
24001                 MP_WritePhyUshort(sc, 0x0D, 0x4007);
24002                 MP_WritePhyUshort(sc, 0x0E, 0x0000);
24003                 MP_WritePhyUshort(sc, 0x0D, 0x0000);
24004         } else if (sc->re_type == MACFG_54 || sc->re_type == MACFG_55) {
24005                 Data_u32 = re_eri_read(sc, 0x1D0, 4, ERIAR_ExGMAC);
24006                 Data_u32 &= 0xFFFF0000;
24007                 re_eri_write(sc, 0x1D0, 4, Data_u32, ERIAR_ExGMAC);
24008
24009                 if (sc->re_type == MACFG_55) {
24010                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
24011                         MP_WritePhyUshort(sc, 0x18, 0x0310);
24012                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
24013
24014                         MP_WritePhyUshort(sc, 0x1f, 0x0004);
24015                         MP_WritePhyUshort(sc, 0x1f, 0x0004);
24016                         MP_WritePhyUshort(sc, 0x19, 0x7070);
24017                         MP_WritePhyUshort(sc, 0x1c, 0x0600);
24018                         MP_WritePhyUshort(sc, 0x1d, 0x9700);
24019                         MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
24020                         MP_WritePhyUshort(sc, 0x1d, 0x4c00);
24021                         MP_WritePhyUshort(sc, 0x1d, 0x4007);
24022                         MP_WritePhyUshort(sc, 0x1d, 0x4400);
24023                         MP_WritePhyUshort(sc, 0x1d, 0x4800);
24024                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24025                         MP_WritePhyUshort(sc, 0x1d, 0x4c00);
24026                         MP_WritePhyUshort(sc, 0x1d, 0x5310);
24027                         MP_WritePhyUshort(sc, 0x1d, 0x6000);
24028                         MP_WritePhyUshort(sc, 0x1d, 0x6800);
24029                         MP_WritePhyUshort(sc, 0x1d, 0x673e);
24030                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24031                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24032                         MP_WritePhyUshort(sc, 0x1d, 0x571f);
24033                         MP_WritePhyUshort(sc, 0x1d, 0x5ffb);
24034                         MP_WritePhyUshort(sc, 0x1d, 0xaa04);
24035                         MP_WritePhyUshort(sc, 0x1d, 0x5b58);
24036                         MP_WritePhyUshort(sc, 0x1d, 0x6100);
24037                         MP_WritePhyUshort(sc, 0x1d, 0x3016);
24038                         MP_WritePhyUshort(sc, 0x1d, 0x5b64);
24039                         MP_WritePhyUshort(sc, 0x1d, 0x6080);
24040                         MP_WritePhyUshort(sc, 0x1d, 0xa6fa);
24041                         MP_WritePhyUshort(sc, 0x1d, 0xdcdb);
24042                         MP_WritePhyUshort(sc, 0x1d, 0x0015);
24043                         MP_WritePhyUshort(sc, 0x1d, 0xb915);
24044                         MP_WritePhyUshort(sc, 0x1d, 0xb511);
24045                         MP_WritePhyUshort(sc, 0x1d, 0xd16b);
24046                         MP_WritePhyUshort(sc, 0x1d, 0x000f);
24047                         MP_WritePhyUshort(sc, 0x1d, 0xb40f);
24048                         MP_WritePhyUshort(sc, 0x1d, 0xd06b);
24049                         MP_WritePhyUshort(sc, 0x1d, 0x000d);
24050                         MP_WritePhyUshort(sc, 0x1d, 0xb206);
24051                         MP_WritePhyUshort(sc, 0x1d, 0x7c01);
24052                         MP_WritePhyUshort(sc, 0x1d, 0x5800);
24053                         MP_WritePhyUshort(sc, 0x1d, 0x7c04);
24054                         MP_WritePhyUshort(sc, 0x1d, 0x5c00);
24055                         MP_WritePhyUshort(sc, 0x1d, 0x3010);
24056                         MP_WritePhyUshort(sc, 0x1d, 0x7c01);
24057                         MP_WritePhyUshort(sc, 0x1d, 0x5801);
24058                         MP_WritePhyUshort(sc, 0x1d, 0x7c04);
24059                         MP_WritePhyUshort(sc, 0x1d, 0x5c04);
24060                         MP_WritePhyUshort(sc, 0x1d, 0x3016);
24061                         MP_WritePhyUshort(sc, 0x1d, 0x307e);
24062                         MP_WritePhyUshort(sc, 0x1d, 0x30f4);
24063                         MP_WritePhyUshort(sc, 0x1d, 0x319f);
24064                         MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
24065                         MP_WritePhyUshort(sc, 0x1d, 0x4c60);
24066                         MP_WritePhyUshort(sc, 0x1d, 0x6803);
24067                         MP_WritePhyUshort(sc, 0x1d, 0x7d00);
24068                         MP_WritePhyUshort(sc, 0x1d, 0x6900);
24069                         MP_WritePhyUshort(sc, 0x1d, 0x6520);
24070                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24071                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24072                         MP_WritePhyUshort(sc, 0x1d, 0xaf03);
24073                         MP_WritePhyUshort(sc, 0x1d, 0x6115);
24074                         MP_WritePhyUshort(sc, 0x1d, 0x303a);
24075                         MP_WritePhyUshort(sc, 0x1d, 0x6097);
24076                         MP_WritePhyUshort(sc, 0x1d, 0x57e0);
24077                         MP_WritePhyUshort(sc, 0x1d, 0x580c);
24078                         MP_WritePhyUshort(sc, 0x1d, 0x588c);
24079                         MP_WritePhyUshort(sc, 0x1d, 0x5f80);
24080                         MP_WritePhyUshort(sc, 0x1d, 0x4827);
24081                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24082                         MP_WritePhyUshort(sc, 0x1d, 0x4c00);
24083                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24084                         MP_WritePhyUshort(sc, 0x1d, 0x4c10);
24085                         MP_WritePhyUshort(sc, 0x1d, 0x8400);
24086                         MP_WritePhyUshort(sc, 0x1d, 0x7c30);
24087                         MP_WritePhyUshort(sc, 0x1d, 0x6020);
24088                         MP_WritePhyUshort(sc, 0x1d, 0x48bf);
24089                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24090                         MP_WritePhyUshort(sc, 0x1d, 0x4c00);
24091                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24092                         MP_WritePhyUshort(sc, 0x1d, 0x4c01);
24093                         MP_WritePhyUshort(sc, 0x1d, 0xb802);
24094                         MP_WritePhyUshort(sc, 0x1d, 0x3053);
24095                         MP_WritePhyUshort(sc, 0x1d, 0x7c08);
24096                         MP_WritePhyUshort(sc, 0x1d, 0x6808);
24097                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24098                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24099                         MP_WritePhyUshort(sc, 0x1d, 0x7c10);
24100                         MP_WritePhyUshort(sc, 0x1d, 0x6810);
24101                         MP_WritePhyUshort(sc, 0x1d, 0xd6cf);
24102                         MP_WritePhyUshort(sc, 0x1d, 0x0002);
24103                         MP_WritePhyUshort(sc, 0x1d, 0x80fe);
24104                         MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
24105                         MP_WritePhyUshort(sc, 0x1d, 0x4c80);
24106                         MP_WritePhyUshort(sc, 0x1d, 0x7c10);
24107                         MP_WritePhyUshort(sc, 0x1d, 0x6800);
24108                         MP_WritePhyUshort(sc, 0x1d, 0x7c08);
24109                         MP_WritePhyUshort(sc, 0x1d, 0x6800);
24110                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24111                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24112                         MP_WritePhyUshort(sc, 0x1d, 0x7c23);
24113                         MP_WritePhyUshort(sc, 0x1d, 0x5c23);
24114                         MP_WritePhyUshort(sc, 0x1d, 0x481e);
24115                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24116                         MP_WritePhyUshort(sc, 0x1d, 0x4c00);
24117                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24118                         MP_WritePhyUshort(sc, 0x1d, 0x4c02);
24119                         MP_WritePhyUshort(sc, 0x1d, 0x5310);
24120                         MP_WritePhyUshort(sc, 0x1d, 0x81ff);
24121                         MP_WritePhyUshort(sc, 0x1d, 0x30c1);
24122                         MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
24123                         MP_WritePhyUshort(sc, 0x1d, 0x4d00);
24124                         MP_WritePhyUshort(sc, 0x1d, 0x4832);
24125                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24126                         MP_WritePhyUshort(sc, 0x1d, 0x4c00);
24127                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24128                         MP_WritePhyUshort(sc, 0x1d, 0x4c10);
24129                         MP_WritePhyUshort(sc, 0x1d, 0x7c08);
24130                         MP_WritePhyUshort(sc, 0x1d, 0x6000);
24131                         MP_WritePhyUshort(sc, 0x1d, 0xa4bd);
24132                         MP_WritePhyUshort(sc, 0x1d, 0xd9b3);
24133                         MP_WritePhyUshort(sc, 0x1d, 0x00fe);
24134                         MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
24135                         MP_WritePhyUshort(sc, 0x1d, 0x4d20);
24136                         MP_WritePhyUshort(sc, 0x1d, 0x7e00);
24137                         MP_WritePhyUshort(sc, 0x1d, 0x6200);
24138                         MP_WritePhyUshort(sc, 0x1d, 0x3001);
24139                         MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
24140                         MP_WritePhyUshort(sc, 0x1d, 0x4dc0);
24141                         MP_WritePhyUshort(sc, 0x1d, 0xd09d);
24142                         MP_WritePhyUshort(sc, 0x1d, 0x0002);
24143                         MP_WritePhyUshort(sc, 0x1d, 0xb4fe);
24144                         MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
24145                         MP_WritePhyUshort(sc, 0x1d, 0x4d80);
24146                         MP_WritePhyUshort(sc, 0x1d, 0x7c04);
24147                         MP_WritePhyUshort(sc, 0x1d, 0x6004);
24148                         MP_WritePhyUshort(sc, 0x1d, 0x6802);
24149                         MP_WritePhyUshort(sc, 0x1d, 0x6728);
24150                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24151                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24152                         MP_WritePhyUshort(sc, 0x1d, 0x7c08);
24153                         MP_WritePhyUshort(sc, 0x1d, 0x6000);
24154                         MP_WritePhyUshort(sc, 0x1d, 0x486c);
24155                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24156                         MP_WritePhyUshort(sc, 0x1d, 0x4c00);
24157                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24158                         MP_WritePhyUshort(sc, 0x1d, 0x4c01);
24159                         MP_WritePhyUshort(sc, 0x1d, 0x9503);
24160                         MP_WritePhyUshort(sc, 0x1d, 0x7e00);
24161                         MP_WritePhyUshort(sc, 0x1d, 0x6200);
24162                         MP_WritePhyUshort(sc, 0x1d, 0x571f);
24163                         MP_WritePhyUshort(sc, 0x1d, 0x5fbb);
24164                         MP_WritePhyUshort(sc, 0x1d, 0xaa05);
24165                         MP_WritePhyUshort(sc, 0x1d, 0x5b58);
24166                         MP_WritePhyUshort(sc, 0x1d, 0x7d80);
24167                         MP_WritePhyUshort(sc, 0x1d, 0x6100);
24168                         MP_WritePhyUshort(sc, 0x1d, 0x309a);
24169                         MP_WritePhyUshort(sc, 0x1d, 0x5b64);
24170                         MP_WritePhyUshort(sc, 0x1d, 0x7d80);
24171                         MP_WritePhyUshort(sc, 0x1d, 0x6080);
24172                         MP_WritePhyUshort(sc, 0x1d, 0xcdab);
24173                         MP_WritePhyUshort(sc, 0x1d, 0x0058);
24174                         MP_WritePhyUshort(sc, 0x1d, 0xcd8d);
24175                         MP_WritePhyUshort(sc, 0x1d, 0x0056);
24176                         MP_WritePhyUshort(sc, 0x1d, 0xd96b);
24177                         MP_WritePhyUshort(sc, 0x1d, 0x0054);
24178                         MP_WritePhyUshort(sc, 0x1d, 0xd0a0);
24179                         MP_WritePhyUshort(sc, 0x1d, 0x00d8);
24180                         MP_WritePhyUshort(sc, 0x1d, 0xcba0);
24181                         MP_WritePhyUshort(sc, 0x1d, 0x0003);
24182                         MP_WritePhyUshort(sc, 0x1d, 0x80ec);
24183                         MP_WritePhyUshort(sc, 0x1d, 0x30a7);
24184                         MP_WritePhyUshort(sc, 0x1d, 0x30b4);
24185                         MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
24186                         MP_WritePhyUshort(sc, 0x1d, 0x4ce0);
24187                         MP_WritePhyUshort(sc, 0x1d, 0x4832);
24188                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24189                         MP_WritePhyUshort(sc, 0x1d, 0x4c00);
24190                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24191                         MP_WritePhyUshort(sc, 0x1d, 0x4c08);
24192                         MP_WritePhyUshort(sc, 0x1d, 0x7c08);
24193                         MP_WritePhyUshort(sc, 0x1d, 0x6008);
24194                         MP_WritePhyUshort(sc, 0x1d, 0x8300);
24195                         MP_WritePhyUshort(sc, 0x1d, 0xb902);
24196                         MP_WritePhyUshort(sc, 0x1d, 0x307e);
24197                         MP_WritePhyUshort(sc, 0x1d, 0x3068);
24198                         MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
24199                         MP_WritePhyUshort(sc, 0x1d, 0x4da0);
24200                         MP_WritePhyUshort(sc, 0x1d, 0x6608);
24201                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24202                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24203                         MP_WritePhyUshort(sc, 0x1d, 0x56a0);
24204                         MP_WritePhyUshort(sc, 0x1d, 0x590c);
24205                         MP_WritePhyUshort(sc, 0x1d, 0x5fa0);
24206                         MP_WritePhyUshort(sc, 0x1d, 0xcba4);
24207                         MP_WritePhyUshort(sc, 0x1d, 0x0004);
24208                         MP_WritePhyUshort(sc, 0x1d, 0xcd8d);
24209                         MP_WritePhyUshort(sc, 0x1d, 0x0002);
24210                         MP_WritePhyUshort(sc, 0x1d, 0x80fc);
24211                         MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
24212                         MP_WritePhyUshort(sc, 0x1d, 0x4ca0);
24213                         MP_WritePhyUshort(sc, 0x1d, 0x7c08);
24214                         MP_WritePhyUshort(sc, 0x1d, 0x6408);
24215                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24216                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24217                         MP_WritePhyUshort(sc, 0x1d, 0x7d00);
24218                         MP_WritePhyUshort(sc, 0x1d, 0x6800);
24219                         MP_WritePhyUshort(sc, 0x1d, 0xb603);
24220                         MP_WritePhyUshort(sc, 0x1d, 0x7c10);
24221                         MP_WritePhyUshort(sc, 0x1d, 0x6010);
24222                         MP_WritePhyUshort(sc, 0x1d, 0x7d1f);
24223                         MP_WritePhyUshort(sc, 0x1d, 0x551f);
24224                         MP_WritePhyUshort(sc, 0x1d, 0x5fb3);
24225                         MP_WritePhyUshort(sc, 0x1d, 0xaa05);
24226                         MP_WritePhyUshort(sc, 0x1d, 0x7c80);
24227                         MP_WritePhyUshort(sc, 0x1d, 0x5800);
24228                         MP_WritePhyUshort(sc, 0x1d, 0x5b58);
24229                         MP_WritePhyUshort(sc, 0x1d, 0x30d7);
24230                         MP_WritePhyUshort(sc, 0x1d, 0x7c80);
24231                         MP_WritePhyUshort(sc, 0x1d, 0x5800);
24232                         MP_WritePhyUshort(sc, 0x1d, 0x5b64);
24233                         MP_WritePhyUshort(sc, 0x1d, 0x4827);
24234                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24235                         MP_WritePhyUshort(sc, 0x1d, 0x4c00);
24236                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24237                         MP_WritePhyUshort(sc, 0x1d, 0x4c10);
24238                         MP_WritePhyUshort(sc, 0x1d, 0x8400);
24239                         MP_WritePhyUshort(sc, 0x1d, 0x7c10);
24240                         MP_WritePhyUshort(sc, 0x1d, 0x6000);
24241                         MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
24242                         MP_WritePhyUshort(sc, 0x1d, 0x4cc0);
24243                         MP_WritePhyUshort(sc, 0x1d, 0x7d00);
24244                         MP_WritePhyUshort(sc, 0x1d, 0x6400);
24245                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24246                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24247                         MP_WritePhyUshort(sc, 0x1d, 0x5fbb);
24248                         MP_WritePhyUshort(sc, 0x1d, 0x4824);
24249                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24250                         MP_WritePhyUshort(sc, 0x1d, 0x4c00);
24251                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24252                         MP_WritePhyUshort(sc, 0x1d, 0x4c04);
24253                         MP_WritePhyUshort(sc, 0x1d, 0x8200);
24254                         MP_WritePhyUshort(sc, 0x1d, 0x7ce0);
24255                         MP_WritePhyUshort(sc, 0x1d, 0x5400);
24256                         MP_WritePhyUshort(sc, 0x1d, 0x7d00);
24257                         MP_WritePhyUshort(sc, 0x1d, 0x6500);
24258                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24259                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24260                         MP_WritePhyUshort(sc, 0x1d, 0x30a7);
24261                         MP_WritePhyUshort(sc, 0x1d, 0x3001);
24262                         MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
24263                         MP_WritePhyUshort(sc, 0x1d, 0x4e00);
24264                         MP_WritePhyUshort(sc, 0x1d, 0x4007);
24265                         MP_WritePhyUshort(sc, 0x1d, 0x4400);
24266                         MP_WritePhyUshort(sc, 0x1d, 0x5310);
24267                         MP_WritePhyUshort(sc, 0x1d, 0x6800);
24268                         MP_WritePhyUshort(sc, 0x1d, 0x673e);
24269                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24270                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24271                         MP_WritePhyUshort(sc, 0x1d, 0x570f);
24272                         MP_WritePhyUshort(sc, 0x1d, 0x5fff);
24273                         MP_WritePhyUshort(sc, 0x1d, 0xaa05);
24274                         MP_WritePhyUshort(sc, 0x1d, 0x585b);
24275                         MP_WritePhyUshort(sc, 0x1d, 0x7d80);
24276                         MP_WritePhyUshort(sc, 0x1d, 0x6100);
24277                         MP_WritePhyUshort(sc, 0x1d, 0x3107);
24278                         MP_WritePhyUshort(sc, 0x1d, 0x5867);
24279                         MP_WritePhyUshort(sc, 0x1d, 0x7d80);
24280                         MP_WritePhyUshort(sc, 0x1d, 0x6080);
24281                         MP_WritePhyUshort(sc, 0x1d, 0x9403);
24282                         MP_WritePhyUshort(sc, 0x1d, 0x7e00);
24283                         MP_WritePhyUshort(sc, 0x1d, 0x6200);
24284                         MP_WritePhyUshort(sc, 0x1d, 0xcda3);
24285                         MP_WritePhyUshort(sc, 0x1d, 0x00e8);
24286                         MP_WritePhyUshort(sc, 0x1d, 0xcd85);
24287                         MP_WritePhyUshort(sc, 0x1d, 0x00e6);
24288                         MP_WritePhyUshort(sc, 0x1d, 0xd96b);
24289                         MP_WritePhyUshort(sc, 0x1d, 0x00e4);
24290                         MP_WritePhyUshort(sc, 0x1d, 0x96e4);
24291                         MP_WritePhyUshort(sc, 0x1d, 0x6800);
24292                         MP_WritePhyUshort(sc, 0x1d, 0x673e);
24293                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24294                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24295                         MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
24296                         MP_WritePhyUshort(sc, 0x1d, 0x4e20);
24297                         MP_WritePhyUshort(sc, 0x1d, 0x96dd);
24298                         MP_WritePhyUshort(sc, 0x1d, 0x8b04);
24299                         MP_WritePhyUshort(sc, 0x1d, 0x7c08);
24300                         MP_WritePhyUshort(sc, 0x1d, 0x5008);
24301                         MP_WritePhyUshort(sc, 0x1d, 0xab03);
24302                         MP_WritePhyUshort(sc, 0x1d, 0x7c08);
24303                         MP_WritePhyUshort(sc, 0x1d, 0x5000);
24304                         MP_WritePhyUshort(sc, 0x1d, 0x6801);
24305                         MP_WritePhyUshort(sc, 0x1d, 0x677e);
24306                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24307                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24308                         MP_WritePhyUshort(sc, 0x1d, 0xdb7c);
24309                         MP_WritePhyUshort(sc, 0x1d, 0x00ee);
24310                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24311                         MP_WritePhyUshort(sc, 0x1d, 0x7fe1);
24312                         MP_WritePhyUshort(sc, 0x1d, 0x4e40);
24313                         MP_WritePhyUshort(sc, 0x1d, 0x4837);
24314                         MP_WritePhyUshort(sc, 0x1d, 0x4418);
24315                         MP_WritePhyUshort(sc, 0x1d, 0x41c7);
24316                         MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
24317                         MP_WritePhyUshort(sc, 0x1d, 0x4e40);
24318                         MP_WritePhyUshort(sc, 0x1d, 0x7c40);
24319                         MP_WritePhyUshort(sc, 0x1d, 0x5400);
24320                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24321                         MP_WritePhyUshort(sc, 0x1d, 0x4c01);
24322                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24323                         MP_WritePhyUshort(sc, 0x1d, 0x4c01);
24324                         MP_WritePhyUshort(sc, 0x1d, 0x8fc2);
24325                         MP_WritePhyUshort(sc, 0x1d, 0xd2a0);
24326                         MP_WritePhyUshort(sc, 0x1d, 0x004b);
24327                         MP_WritePhyUshort(sc, 0x1d, 0x9204);
24328                         MP_WritePhyUshort(sc, 0x1d, 0xa042);
24329                         MP_WritePhyUshort(sc, 0x1d, 0x3132);
24330                         MP_WritePhyUshort(sc, 0x1d, 0x30f4);
24331                         MP_WritePhyUshort(sc, 0x1d, 0x7fe1);
24332                         MP_WritePhyUshort(sc, 0x1d, 0x4e60);
24333                         MP_WritePhyUshort(sc, 0x1d, 0x489c);
24334                         MP_WritePhyUshort(sc, 0x1d, 0x4628);
24335                         MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
24336                         MP_WritePhyUshort(sc, 0x1d, 0x4e60);
24337                         MP_WritePhyUshort(sc, 0x1d, 0x7e28);
24338                         MP_WritePhyUshort(sc, 0x1d, 0x4628);
24339                         MP_WritePhyUshort(sc, 0x1d, 0x7c40);
24340                         MP_WritePhyUshort(sc, 0x1d, 0x5400);
24341                         MP_WritePhyUshort(sc, 0x1d, 0x7c01);
24342                         MP_WritePhyUshort(sc, 0x1d, 0x5800);
24343                         MP_WritePhyUshort(sc, 0x1d, 0x7c04);
24344                         MP_WritePhyUshort(sc, 0x1d, 0x5c00);
24345                         MP_WritePhyUshort(sc, 0x1d, 0x41e8);
24346                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24347                         MP_WritePhyUshort(sc, 0x1d, 0x4c01);
24348                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24349                         MP_WritePhyUshort(sc, 0x1d, 0x4c01);
24350                         MP_WritePhyUshort(sc, 0x1d, 0x8fa8);
24351                         MP_WritePhyUshort(sc, 0x1d, 0xb241);
24352                         MP_WritePhyUshort(sc, 0x1d, 0xa02a);
24353                         MP_WritePhyUshort(sc, 0x1d, 0x314c);
24354                         MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
24355                         MP_WritePhyUshort(sc, 0x1d, 0x4ea0);
24356                         MP_WritePhyUshort(sc, 0x1d, 0x7c02);
24357                         MP_WritePhyUshort(sc, 0x1d, 0x4402);
24358                         MP_WritePhyUshort(sc, 0x1d, 0x4448);
24359                         MP_WritePhyUshort(sc, 0x1d, 0x4894);
24360                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24361                         MP_WritePhyUshort(sc, 0x1d, 0x4c01);
24362                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24363                         MP_WritePhyUshort(sc, 0x1d, 0x4c03);
24364                         MP_WritePhyUshort(sc, 0x1d, 0x4824);
24365                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24366                         MP_WritePhyUshort(sc, 0x1d, 0x4c07);
24367                         MP_WritePhyUshort(sc, 0x1d, 0x41ef);
24368                         MP_WritePhyUshort(sc, 0x1d, 0x41ff);
24369                         MP_WritePhyUshort(sc, 0x1d, 0x4891);
24370                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24371                         MP_WritePhyUshort(sc, 0x1d, 0x4c07);
24372                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24373                         MP_WritePhyUshort(sc, 0x1d, 0x4c17);
24374                         MP_WritePhyUshort(sc, 0x1d, 0x8400);
24375                         MP_WritePhyUshort(sc, 0x1d, 0x8ef8);
24376                         MP_WritePhyUshort(sc, 0x1d, 0x41c7);
24377                         MP_WritePhyUshort(sc, 0x1d, 0x8f8d);
24378                         MP_WritePhyUshort(sc, 0x1d, 0x92d5);
24379                         MP_WritePhyUshort(sc, 0x1d, 0xa10f);
24380                         MP_WritePhyUshort(sc, 0x1d, 0xd480);
24381                         MP_WritePhyUshort(sc, 0x1d, 0x0008);
24382                         MP_WritePhyUshort(sc, 0x1d, 0xd580);
24383                         MP_WritePhyUshort(sc, 0x1d, 0x00b8);
24384                         MP_WritePhyUshort(sc, 0x1d, 0xa202);
24385                         MP_WritePhyUshort(sc, 0x1d, 0x3167);
24386                         MP_WritePhyUshort(sc, 0x1d, 0x7c04);
24387                         MP_WritePhyUshort(sc, 0x1d, 0x4404);
24388                         MP_WritePhyUshort(sc, 0x1d, 0x3167);
24389                         MP_WritePhyUshort(sc, 0x1d, 0xd484);
24390                         MP_WritePhyUshort(sc, 0x1d, 0x00f3);
24391                         MP_WritePhyUshort(sc, 0x1d, 0xd484);
24392                         MP_WritePhyUshort(sc, 0x1d, 0x00f1);
24393                         MP_WritePhyUshort(sc, 0x1d, 0x30f4);
24394                         MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
24395                         MP_WritePhyUshort(sc, 0x1d, 0x4ee0);
24396                         MP_WritePhyUshort(sc, 0x1d, 0x7c40);
24397                         MP_WritePhyUshort(sc, 0x1d, 0x5400);
24398                         MP_WritePhyUshort(sc, 0x1d, 0x4488);
24399                         MP_WritePhyUshort(sc, 0x1d, 0x41cf);
24400                         MP_WritePhyUshort(sc, 0x1d, 0x30f4);
24401                         MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
24402                         MP_WritePhyUshort(sc, 0x1d, 0x4ec0);
24403                         MP_WritePhyUshort(sc, 0x1d, 0x48f3);
24404                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24405                         MP_WritePhyUshort(sc, 0x1d, 0x4c01);
24406                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24407                         MP_WritePhyUshort(sc, 0x1d, 0x4c09);
24408                         MP_WritePhyUshort(sc, 0x1d, 0x4508);
24409                         MP_WritePhyUshort(sc, 0x1d, 0x41c7);
24410                         MP_WritePhyUshort(sc, 0x1d, 0x8fb0);
24411                         MP_WritePhyUshort(sc, 0x1d, 0xd218);
24412                         MP_WritePhyUshort(sc, 0x1d, 0x00ae);
24413                         MP_WritePhyUshort(sc, 0x1d, 0xd2a4);
24414                         MP_WritePhyUshort(sc, 0x1d, 0x009e);
24415                         MP_WritePhyUshort(sc, 0x1d, 0x3188);
24416                         MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
24417                         MP_WritePhyUshort(sc, 0x1d, 0x4e80);
24418                         MP_WritePhyUshort(sc, 0x1d, 0x4832);
24419                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24420                         MP_WritePhyUshort(sc, 0x1d, 0x4c01);
24421                         MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
24422                         MP_WritePhyUshort(sc, 0x1d, 0x4c11);
24423                         MP_WritePhyUshort(sc, 0x1d, 0x4428);
24424                         MP_WritePhyUshort(sc, 0x1d, 0x7c40);
24425                         MP_WritePhyUshort(sc, 0x1d, 0x5440);
24426                         MP_WritePhyUshort(sc, 0x1d, 0x7c01);
24427                         MP_WritePhyUshort(sc, 0x1d, 0x5801);
24428                         MP_WritePhyUshort(sc, 0x1d, 0x7c04);
24429                         MP_WritePhyUshort(sc, 0x1d, 0x5c04);
24430                         MP_WritePhyUshort(sc, 0x1d, 0x41e8);
24431                         MP_WritePhyUshort(sc, 0x1d, 0xa4b3);
24432                         MP_WritePhyUshort(sc, 0x1d, 0x319d);
24433                         MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
24434                         MP_WritePhyUshort(sc, 0x1d, 0x4f20);
24435                         MP_WritePhyUshort(sc, 0x1d, 0x6800);
24436                         MP_WritePhyUshort(sc, 0x1d, 0x673e);
24437                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24438                         MP_WritePhyUshort(sc, 0x1d, 0x0000);
24439                         MP_WritePhyUshort(sc, 0x1d, 0x570f);
24440                         MP_WritePhyUshort(sc, 0x1d, 0x5fff);
24441                         MP_WritePhyUshort(sc, 0x1d, 0xaa04);
24442                         MP_WritePhyUshort(sc, 0x1d, 0x585b);
24443                         MP_WritePhyUshort(sc, 0x1d, 0x6100);
24444                         MP_WritePhyUshort(sc, 0x1d, 0x31ad);
24445                         MP_WritePhyUshort(sc, 0x1d, 0x5867);
24446                         MP_WritePhyUshort(sc, 0x1d, 0x6080);
24447                         MP_WritePhyUshort(sc, 0x1d, 0xbcf2);
24448                         MP_WritePhyUshort(sc, 0x1d, 0x3001);
24449                         MP_WritePhyUshort(sc, 0x1f, 0x0004);
24450                         MP_WritePhyUshort(sc, 0x1c, 0x0200);
24451                         MP_WritePhyUshort(sc, 0x19, 0x7030);
24452                         MP_WritePhyUshort(sc, 0x1f, 0x0000);
24453                 }
24454
24455                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
24456                 MP_WritePhyUshort(sc, 0x11, 0x83BA);
24457                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
24458
24459                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
24460                 ClearEthPhyBit(sc, 0x1A, BIT_2);
24461                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
24462
24463                 if (phy_power_saving == 1) {
24464                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
24465                         MP_WritePhyUshort(sc, 0x18, 0x8310);
24466                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
24467                 } else {
24468                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
24469                         MP_WritePhyUshort(sc, 0x18, 0x0310);
24470                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
24471                         DELAY(20000);
24472                 }
24473
24474                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
24475                 MP_WritePhyUshort(sc, 0x0D, 0x0007);
24476                 MP_WritePhyUshort(sc, 0x0E, 0x003C);
24477                 MP_WritePhyUshort(sc, 0x0D, 0x4007);
24478                 MP_WritePhyUshort(sc, 0x0E, 0x0000);
24479                 MP_WritePhyUshort(sc, 0x0D, 0x0000);
24480                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
24481                 MP_WritePhyUshort(sc, 0x0D, 0x0003);
24482                 MP_WritePhyUshort(sc, 0x0E, 0x0015);
24483                 MP_WritePhyUshort(sc, 0x0D, 0x4003);
24484                 MP_WritePhyUshort(sc, 0x0E, 0x0000);
24485                 MP_WritePhyUshort(sc, 0x0D, 0x0000);
24486         } else if (sc->re_type == MACFG_56) {
24487                 MP_WritePhyUshort(sc, 0x1F, 0x0A46);
24488                 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
24489                 TmpUshort = (PhyRegValue & BIT_8) ? 0 : BIT_15;
24490
24491                 MP_WritePhyUshort(sc, 0x1F, 0x0BCC);
24492                 ClearEthPhyBit(sc, 0x12, BIT_15);
24493                 SetEthPhyBit(sc, 0x12, TmpUshort);
24494
24495
24496                 MP_WritePhyUshort(sc, 0x1F, 0x0A46);
24497                 PhyRegValue = MP_ReadPhyUshort(sc, 0x13);
24498                 TmpUshort = (PhyRegValue & BIT_8) ? BIT_1 : 0;
24499
24500                 MP_WritePhyUshort(sc, 0x1F, 0x0C41);
24501                 ClearEthPhyBit(sc, 0x15, BIT_1);
24502                 SetEthPhyBit(sc, 0x15, TmpUshort);
24503
24504                 MP_WritePhyUshort(sc, 0x1F, 0x0A44);
24505                 SetEthPhyBit(sc, 0x11, (BIT_3 | BIT_2));
24506                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
24507
24508
24509                 MP_WritePhyUshort(sc, 0x1F, 0x0BCC);
24510                 ClearEthPhyBit(sc, 0x14, BIT_8);
24511                 MP_WritePhyUshort(sc, 0x1F, 0x0A44);
24512                 SetEthPhyBit(sc, 0x11, BIT_7);
24513                 SetEthPhyBit(sc, 0x11, BIT_6);
24514                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24515                 MP_WritePhyUshort(sc, 0x13, 0x8084);
24516                 ClearEthPhyBit(sc, 0x14, (BIT_14 | BIT_13));
24517                 SetEthPhyBit(sc, 0x10, BIT_12);
24518                 SetEthPhyBit(sc, 0x10, BIT_1);
24519                 SetEthPhyBit(sc, 0x10, BIT_0);
24520                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
24521
24522
24523                 MP_WritePhyUshort(sc, 0x1F, 0x0A4B);
24524                 SetEthPhyBit(sc, 0x11, BIT_2);
24525                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
24526
24527
24528
24529                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24530                 MP_WritePhyUshort(sc, 0x13, 0x8012);
24531                 SetEthPhyBit(sc, 0x14, BIT_15);
24532                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
24533
24534
24535
24536                 MP_WritePhyUshort(sc, 0x1F, 0x0C42);
24537                 ClearAndSetEthPhyBit(sc,
24538                                      0x11,
24539                                      BIT_13,
24540                                      BIT_14
24541                                     );
24542                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
24543
24544                 if (phy_power_saving == 1) {
24545                         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24546                         SetEthPhyBit(sc, 0x10, BIT_2);
24547                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
24548                 } else {
24549                         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24550                         ClearEthPhyBit(sc, 0x10, BIT_2);
24551                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
24552                         DELAY(20000);
24553                 }
24554
24555                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24556                 MP_WritePhyUshort(sc, 0x13, 0x809A);
24557                 MP_WritePhyUshort(sc, 0x14, 0x8022);
24558                 MP_WritePhyUshort(sc, 0x13, 0x80A0);
24559                 ClearAndSetEthPhyBit(sc,
24560                                      0x14,
24561                                      0xFF00,
24562                                      0x1000
24563                                     );
24564                 MP_WritePhyUshort(sc, 0x13, 0x8088);
24565                 MP_WritePhyUshort(sc, 0x14, 0x9222);
24566                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
24567
24568                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24569                 MP_WritePhyUshort(sc, 0x13, 0x8011);
24570                 ClearEthPhyBit(sc, 0x14, BIT_14);
24571                 MP_WritePhyUshort(sc, 0x1F, 0x0A40);
24572                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
24573                 MP_WritePhyUshort(sc, 0x00, 0x9200);
24574         } else if (sc->re_type == MACFG_58) {
24575                 MP_WritePhyUshort(sc, 0x1F, 0x0BCC);
24576                 ClearEthPhyBit(sc, 0x14, BIT_8);
24577                 MP_WritePhyUshort(sc, 0x1F, 0x0A44);
24578                 SetEthPhyBit(sc, 0x11, BIT_7);
24579                 SetEthPhyBit(sc, 0x11, BIT_6);
24580                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24581                 MP_WritePhyUshort(sc, 0x13, 0x8084);
24582                 ClearEthPhyBit(sc, 0x14, (BIT_14 | BIT_13));
24583                 SetEthPhyBit(sc, 0x10, BIT_12);
24584                 SetEthPhyBit(sc, 0x10, BIT_1);
24585                 SetEthPhyBit(sc, 0x10, BIT_0);
24586                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
24587
24588                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24589                 MP_WritePhyUshort(sc, 0x13, 0x8012);
24590                 SetEthPhyBit(sc, 0x14, BIT_15);
24591                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
24592
24593                 MP_WritePhyUshort(sc, 0x1F, 0x0C42);
24594                 ClearAndSetEthPhyBit(sc,
24595                                      0x11,
24596                                      BIT_13,
24597                                      BIT_14
24598                                     );
24599                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
24600
24601                 if (phy_power_saving == 1) {
24602                         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24603                         SetEthPhyBit(sc, 0x10, BIT_2);
24604                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
24605                 } else {
24606                         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24607                         ClearEthPhyBit(sc, 0x10, BIT_2);
24608                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
24609                         DELAY(20000);
24610                 }
24611
24612                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24613                 MP_WritePhyUshort(sc, 0x13, 0x8011);
24614                 ClearEthPhyBit(sc, 0x14, BIT_14);
24615                 MP_WritePhyUshort(sc, 0x1F, 0x0A40);
24616                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
24617                 MP_WritePhyUshort(sc, 0x00, 0x9200);
24618         } else if (sc->re_type == MACFG_59) {
24619                 MP_WritePhyUshort(sc, 0x1F, 0x0BCC);
24620                 ClearEthPhyBit(sc, 0x14, BIT_8);
24621                 MP_WritePhyUshort(sc, 0x1F, 0x0A44);
24622                 SetEthPhyBit(sc, 0x11, BIT_7);
24623                 SetEthPhyBit(sc, 0x11, BIT_6);
24624                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24625                 MP_WritePhyUshort(sc, 0x13, 0x8084);
24626                 ClearEthPhyBit(sc, 0x14, (BIT_14 | BIT_13));
24627                 SetEthPhyBit(sc, 0x10, BIT_12);
24628                 SetEthPhyBit(sc, 0x10, BIT_1);
24629                 SetEthPhyBit(sc, 0x10, BIT_0);
24630
24631
24632                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24633                 MP_WritePhyUshort(sc, 0x13, 0x8012);
24634                 SetEthPhyBit(sc, 0x14, BIT_15);
24635                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
24636
24637                 MP_WritePhyUshort(sc, 0x1F, 0x0BCE);
24638                 MP_WritePhyUshort(sc, 0x12, 0x8860);
24639                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
24640
24641                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24642                 MP_WritePhyUshort(sc, 0x13, 0x80F3);
24643                 ClearAndSetEthPhyBit(sc,
24644                                      0x14,
24645                                      0xFF00,
24646                                      0x8B00
24647                                     );
24648                 MP_WritePhyUshort(sc, 0x13, 0x80F0);
24649                 ClearAndSetEthPhyBit(sc,
24650                                      0x14,
24651                                      0xFF00,
24652                                      0x3A00
24653                                     );
24654                 MP_WritePhyUshort(sc, 0x13, 0x80EF);
24655                 ClearAndSetEthPhyBit(sc,
24656                                      0x14,
24657                                      0xFF00,
24658                                      0x0500
24659                                     );
24660                 MP_WritePhyUshort(sc, 0x13, 0x80F6);
24661                 ClearAndSetEthPhyBit(sc,
24662                                      0x14,
24663                                      0xFF00,
24664                                      0x6E00
24665                                     );
24666                 MP_WritePhyUshort(sc, 0x13, 0x80EC);
24667                 ClearAndSetEthPhyBit(sc,
24668                                      0x14,
24669                                      0xFF00,
24670                                      0x6800
24671                                     );
24672                 MP_WritePhyUshort(sc, 0x13, 0x80ED);
24673                 ClearAndSetEthPhyBit(sc,
24674                                      0x14,
24675                                      0xFF00,
24676                                      0x7C00
24677                                     );
24678                 MP_WritePhyUshort(sc, 0x13, 0x80F2);
24679                 ClearAndSetEthPhyBit(sc,
24680                                      0x14,
24681                                      0xFF00,
24682                                      0xF400
24683                                     );
24684                 MP_WritePhyUshort(sc, 0x13, 0x80F4);
24685                 ClearAndSetEthPhyBit(sc,
24686                                      0x14,
24687                                      0xFF00,
24688                                      0x8500
24689                                     );
24690
24691                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24692                 MP_WritePhyUshort(sc, 0x13, 0x8110);
24693                 ClearAndSetEthPhyBit(sc,
24694                                      0x14,
24695                                      0xFF00,
24696                                      0xA800
24697                                     );
24698                 MP_WritePhyUshort(sc, 0x13, 0x810F);
24699                 ClearAndSetEthPhyBit(sc,
24700                                      0x14,
24701                                      0xFF00,
24702                                      0x1D00
24703                                     );
24704                 MP_WritePhyUshort(sc, 0x13, 0x8111);
24705                 ClearAndSetEthPhyBit(sc,
24706                                      0x14,
24707                                      0xFF00,
24708                                      0xF500
24709                                     );
24710                 MP_WritePhyUshort(sc, 0x13, 0x8113);
24711                 ClearAndSetEthPhyBit(sc,
24712                                      0x14,
24713                                      0xFF00,
24714                                      0x6100
24715                                     );
24716                 MP_WritePhyUshort(sc, 0x13, 0x8115);
24717                 ClearAndSetEthPhyBit(sc,
24718                                      0x14,
24719                                      0xFF00,
24720                                      0x9200
24721                                     );
24722                 MP_WritePhyUshort(sc, 0x13, 0x810E);
24723                 ClearAndSetEthPhyBit(sc,
24724                                      0x14,
24725                                      0xFF00,
24726                                      0x0400
24727                                     );
24728                 MP_WritePhyUshort(sc, 0x13, 0x810C);
24729                 ClearAndSetEthPhyBit(sc,
24730                                      0x14,
24731                                      0xFF00,
24732                                      0x7C00
24733                                     );
24734                 MP_WritePhyUshort(sc, 0x13, 0x810B);
24735                 ClearAndSetEthPhyBit(sc,
24736                                      0x14,
24737                                      0xFF00,
24738                                      0x5A00
24739                                     );
24740
24741                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24742                 MP_WritePhyUshort(sc, 0x13, 0x80D1);
24743                 ClearAndSetEthPhyBit(sc,
24744                                      0x14,
24745                                      0xFF00,
24746                                      0xFF00
24747                                     );
24748                 MP_WritePhyUshort(sc, 0x13, 0x80CD);
24749                 ClearAndSetEthPhyBit(sc,
24750                                      0x14,
24751                                      0xFF00,
24752                                      0x9E00
24753                                     );
24754                 MP_WritePhyUshort(sc, 0x13, 0x80D3);
24755                 ClearAndSetEthPhyBit(sc,
24756                                      0x14,
24757                                      0xFF00,
24758                                      0x0E00
24759                                     );
24760                 MP_WritePhyUshort(sc, 0x13, 0x80D5);
24761                 ClearAndSetEthPhyBit(sc,
24762                                      0x14,
24763                                      0xFF00,
24764                                      0xCA00
24765                                     );
24766                 MP_WritePhyUshort(sc, 0x13, 0x80D7);
24767                 ClearAndSetEthPhyBit(sc,
24768                                      0x14,
24769                                      0xFF00,
24770                                      0x8400
24771                                     );
24772
24773                 if (phy_power_saving == 1) {
24774                         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24775                         SetEthPhyBit(sc, 0x10, BIT_2);
24776                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
24777                 } else {
24778                         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24779                         ClearEthPhyBit(sc, 0x10, BIT_2);
24780                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
24781                         DELAY(20000);
24782                 }
24783
24784                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24785                 MP_WritePhyUshort(sc, 0x13, 0x8011);
24786                 ClearEthPhyBit(sc, 0x14, BIT_14);
24787                 MP_WritePhyUshort(sc, 0x1F, 0x0A40);
24788                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
24789                 MP_WritePhyUshort(sc, 0x00, 0x9200);
24790         } else if (sc->re_type == MACFG_60) {
24791                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24792                 MP_WritePhyUshort(sc, 0x13, 0x8012);
24793                 SetEthPhyBit(sc, 0x14, BIT_15);
24794                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
24795
24796                 MP_WritePhyUshort(sc, 0x1F, 0x0BCE);
24797                 MP_WritePhyUshort(sc, 0x12, 0x8860);
24798                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
24799
24800                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24801                 MP_WritePhyUshort(sc, 0x13, 0x80F3);
24802                 ClearAndSetEthPhyBit(sc,
24803                                      0x14,
24804                                      0xFF00,
24805                                      0x8B00
24806                                     );
24807                 MP_WritePhyUshort(sc, 0x13, 0x80F0);
24808                 ClearAndSetEthPhyBit(sc,
24809                                      0x14,
24810                                      0xFF00,
24811                                      0x3A00
24812                                     );
24813                 MP_WritePhyUshort(sc, 0x13, 0x80EF);
24814                 ClearAndSetEthPhyBit(sc,
24815                                      0x14,
24816                                      0xFF00,
24817                                      0x0500
24818                                     );
24819                 MP_WritePhyUshort(sc, 0x13, 0x80F6);
24820                 ClearAndSetEthPhyBit(sc,
24821                                      0x14,
24822                                      0xFF00,
24823                                      0x6E00
24824                                     );
24825                 MP_WritePhyUshort(sc, 0x13, 0x80EC);
24826                 ClearAndSetEthPhyBit(sc,
24827                                      0x14,
24828                                      0xFF00,
24829                                      0x6800
24830                                     );
24831                 MP_WritePhyUshort(sc, 0x13, 0x80ED);
24832                 ClearAndSetEthPhyBit(sc,
24833                                      0x14,
24834                                      0xFF00,
24835                                      0x7C00
24836                                     );
24837                 MP_WritePhyUshort(sc, 0x13, 0x80F2);
24838                 ClearAndSetEthPhyBit(sc,
24839                                      0x14,
24840                                      0xFF00,
24841                                      0xF400
24842                                     );
24843                 MP_WritePhyUshort(sc, 0x13, 0x80F4);
24844                 ClearAndSetEthPhyBit(sc,
24845                                      0x14,
24846                                      0xFF00,
24847                                      0x8500
24848                                     );
24849
24850                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24851                 MP_WritePhyUshort(sc, 0x13, 0x8110);
24852                 ClearAndSetEthPhyBit(sc,
24853                                      0x14,
24854                                      0xFF00,
24855                                      0xA800
24856                                     );
24857                 MP_WritePhyUshort(sc, 0x13, 0x810F);
24858                 ClearAndSetEthPhyBit(sc,
24859                                      0x14,
24860                                      0xFF00,
24861                                      0x1D00
24862                                     );
24863                 MP_WritePhyUshort(sc, 0x13, 0x8111);
24864                 ClearAndSetEthPhyBit(sc,
24865                                      0x14,
24866                                      0xFF00,
24867                                      0xF500
24868                                     );
24869                 MP_WritePhyUshort(sc, 0x13, 0x8113);
24870                 ClearAndSetEthPhyBit(sc,
24871                                      0x14,
24872                                      0xFF00,
24873                                      0x6100
24874                                     );
24875                 MP_WritePhyUshort(sc, 0x13, 0x8115);
24876                 ClearAndSetEthPhyBit(sc,
24877                                      0x14,
24878                                      0xFF00,
24879                                      0x9200
24880                                     );
24881                 MP_WritePhyUshort(sc, 0x13, 0x810E);
24882                 ClearAndSetEthPhyBit(sc,
24883                                      0x14,
24884                                      0xFF00,
24885                                      0x0400
24886                                     );
24887                 MP_WritePhyUshort(sc, 0x13, 0x810C);
24888                 ClearAndSetEthPhyBit(sc,
24889                                      0x14,
24890                                      0xFF00,
24891                                      0x7C00
24892                                     );
24893                 MP_WritePhyUshort(sc, 0x13, 0x810B);
24894                 ClearAndSetEthPhyBit(sc,
24895                                      0x14,
24896                                      0xFF00,
24897                                      0x5A00
24898                                     );
24899
24900                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24901                 MP_WritePhyUshort(sc, 0x13, 0x80D1);
24902                 ClearAndSetEthPhyBit(sc,
24903                                      0x14,
24904                                      0xFF00,
24905                                      0xFF00
24906                                     );
24907                 MP_WritePhyUshort(sc, 0x13, 0x80CD);
24908                 ClearAndSetEthPhyBit(sc,
24909                                      0x14,
24910                                      0xFF00,
24911                                      0x9E00
24912                                     );
24913                 MP_WritePhyUshort(sc, 0x13, 0x80D3);
24914                 ClearAndSetEthPhyBit(sc,
24915                                      0x14,
24916                                      0xFF00,
24917                                      0x0E00
24918                                     );
24919                 MP_WritePhyUshort(sc, 0x13, 0x80D5);
24920                 ClearAndSetEthPhyBit(sc,
24921                                      0x14,
24922                                      0xFF00,
24923                                      0xCA00
24924                                     );
24925                 MP_WritePhyUshort(sc, 0x13, 0x80D7);
24926                 ClearAndSetEthPhyBit(sc,
24927                                      0x14,
24928                                      0xFF00,
24929                                      0x8400
24930                                     );
24931
24932                 if (phy_power_saving == 1) {
24933                         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24934                         SetEthPhyBit(sc, 0x10, BIT_2);
24935                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
24936                 } else {
24937                         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24938                         ClearEthPhyBit(sc, 0x10, BIT_2);
24939                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
24940                         DELAY(20000);
24941                 }
24942
24943                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24944                 MP_WritePhyUshort(sc, 0x13, 0x8011);
24945                 ClearEthPhyBit(sc, 0x14, BIT_14);
24946                 MP_WritePhyUshort(sc, 0x1F, 0x0A40);
24947                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
24948                 MP_WritePhyUshort(sc, 0x00, 0x9200);
24949         } else if (sc->re_type == MACFG_61) {
24950                 MP_WritePhyUshort(sc, 0x1f, 0x0A43);
24951                 MP_WritePhyUshort(sc, 0x13, 0x8146);
24952                 MP_WritePhyUshort(sc, 0x14, 0x0000);
24953
24954                 MP_WritePhyUshort(sc, 0x1f, 0x0B82);
24955                 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
24956                 PhyRegValue &= ~(BIT_4);
24957                 MP_WritePhyUshort(sc, 0x10, PhyRegValue);
24958
24959                 MP_WritePhyUshort(sc, 0x1F, 0x0A44);
24960                 SetEthPhyBit(sc, 0x11, (BIT_3 | BIT_2));
24961                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
24962
24963
24964                 MP_WritePhyUshort(sc, 0x1F, 0x0BCC);
24965                 ClearEthPhyBit(sc, 0x14, BIT_8);
24966                 MP_WritePhyUshort(sc, 0x1F, 0x0A44);
24967                 SetEthPhyBit(sc, 0x11, BIT_7);
24968                 SetEthPhyBit(sc, 0x11, BIT_6);
24969                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24970                 MP_WritePhyUshort(sc, 0x13, 0x8084);
24971                 ClearEthPhyBit(sc, 0x14, (BIT_14 | BIT_13));
24972                 SetEthPhyBit(sc, 0x10, BIT_12);
24973                 SetEthPhyBit(sc, 0x10, BIT_1);
24974                 SetEthPhyBit(sc, 0x10, BIT_0);
24975                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
24976
24977                 MP_WritePhyUshort(sc, 0x1F, 0x0A4B);
24978                 SetEthPhyBit(sc, 0x11, BIT_2);
24979                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
24980
24981                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24982                 MP_WritePhyUshort(sc, 0x13, 0x8012);
24983                 SetEthPhyBit(sc, 0x14, BIT_15);
24984                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
24985
24986                 MP_WritePhyUshort(sc, 0x1F, 0x0C42);
24987                 ClearAndSetEthPhyBit(sc,
24988                                      0x11,
24989                                      BIT_13,
24990                                      BIT_14
24991                                     );
24992                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
24993
24994                 if (phy_power_saving == 1) {
24995                         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
24996                         SetEthPhyBit(sc, 0x10, BIT_2);
24997                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
24998                 } else {
24999                         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25000                         ClearEthPhyBit(sc, 0x10, BIT_2);
25001                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
25002                         DELAY(20000);
25003                 }
25004
25005                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25006                 MP_WritePhyUshort(sc, 0x13, 0x8011);
25007                 ClearEthPhyBit(sc, 0x14, BIT_14);
25008                 MP_WritePhyUshort(sc, 0x1F, 0x0A40);
25009                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25010                 MP_WritePhyUshort(sc, 0x00, 0x9200);
25011         } else if (sc->re_type == MACFG_62 || sc->re_type == MACFG_67) {
25012                 MP_WritePhyUshort(sc, 0x1F, 0x0BCC);
25013                 ClearEthPhyBit(sc, 0x14, BIT_8);
25014                 MP_WritePhyUshort(sc, 0x1F, 0x0A44);
25015                 SetEthPhyBit(sc, 0x11, BIT_7);
25016                 SetEthPhyBit(sc, 0x11, BIT_6);
25017                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25018                 MP_WritePhyUshort(sc, 0x13, 0x8084);
25019                 ClearEthPhyBit(sc, 0x14, (BIT_14 | BIT_13));
25020                 SetEthPhyBit(sc, 0x10, BIT_12);
25021                 SetEthPhyBit(sc, 0x10, BIT_1);
25022                 SetEthPhyBit(sc, 0x10, BIT_0);
25023                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25024
25025                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25026                 MP_WritePhyUshort(sc, 0x13, 0x8012);
25027                 SetEthPhyBit(sc, 0x14, BIT_15);
25028                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25029
25030                 MP_WritePhyUshort(sc, 0x1F, 0x0C42);
25031                 ClearAndSetEthPhyBit(sc,
25032                                      0x11,
25033                                      BIT_13,
25034                                      BIT_14
25035                                     );
25036                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25037
25038                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25039                 MP_WritePhyUshort(sc, 0x13, 0x80F3);
25040                 ClearAndSetEthPhyBit(sc,
25041                                      0x14,
25042                                      0xFF00,
25043                                      0x8B00
25044                                     );
25045                 MP_WritePhyUshort(sc, 0x13, 0x80F0);
25046                 ClearAndSetEthPhyBit(sc,
25047                                      0x14,
25048                                      0xFF00,
25049                                      0x3A00
25050                                     );
25051                 MP_WritePhyUshort(sc, 0x13, 0x80EF);
25052                 ClearAndSetEthPhyBit(sc,
25053                                      0x14,
25054                                      0xFF00,
25055                                      0x0500
25056                                     );
25057                 MP_WritePhyUshort(sc, 0x13, 0x80F6);
25058                 ClearAndSetEthPhyBit(sc,
25059                                      0x14,
25060                                      0xFF00,
25061                                      0x6E00
25062                                     );
25063                 MP_WritePhyUshort(sc, 0x13, 0x80EC);
25064                 ClearAndSetEthPhyBit(sc,
25065                                      0x14,
25066                                      0xFF00,
25067                                      0x6800
25068                                     );
25069                 MP_WritePhyUshort(sc, 0x13, 0x80ED);
25070                 ClearAndSetEthPhyBit(sc,
25071                                      0x14,
25072                                      0xFF00,
25073                                      0x7C00
25074                                     );
25075                 MP_WritePhyUshort(sc, 0x13, 0x80F2);
25076                 ClearAndSetEthPhyBit(sc,
25077                                      0x14,
25078                                      0xFF00,
25079                                      0xF400
25080                                     );
25081                 MP_WritePhyUshort(sc, 0x13, 0x80F4);
25082                 ClearAndSetEthPhyBit(sc,
25083                                      0x14,
25084                                      0xFF00,
25085                                      0x8500
25086                                     );
25087
25088                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25089                 MP_WritePhyUshort(sc, 0x13, 0x8110);
25090                 ClearAndSetEthPhyBit(sc,
25091                                      0x14,
25092                                      0xFF00,
25093                                      0xA800
25094                                     );
25095                 MP_WritePhyUshort(sc, 0x13, 0x810F);
25096                 ClearAndSetEthPhyBit(sc,
25097                                      0x14,
25098                                      0xFF00,
25099                                      0x1D00
25100                                     );
25101                 MP_WritePhyUshort(sc, 0x13, 0x8111);
25102                 ClearAndSetEthPhyBit(sc,
25103                                      0x14,
25104                                      0xFF00,
25105                                      0xF500
25106                                     );
25107                 MP_WritePhyUshort(sc, 0x13, 0x8113);
25108                 ClearAndSetEthPhyBit(sc,
25109                                      0x14,
25110                                      0xFF00,
25111                                      0x6100
25112                                     );
25113                 MP_WritePhyUshort(sc, 0x13, 0x8115);
25114                 ClearAndSetEthPhyBit(sc,
25115                                      0x14,
25116                                      0xFF00,
25117                                      0x9200
25118                                     );
25119                 MP_WritePhyUshort(sc, 0x13, 0x810E);
25120                 ClearAndSetEthPhyBit(sc,
25121                                      0x14,
25122                                      0xFF00,
25123                                      0x0400
25124                                     );
25125                 MP_WritePhyUshort(sc, 0x13, 0x810C);
25126                 ClearAndSetEthPhyBit(sc,
25127                                      0x14,
25128                                      0xFF00,
25129                                      0x7C00
25130                                     );
25131                 MP_WritePhyUshort(sc, 0x13, 0x810B);
25132                 ClearAndSetEthPhyBit(sc,
25133                                      0x14,
25134                                      0xFF00,
25135                                      0x5A00
25136                                     );
25137
25138                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25139                 MP_WritePhyUshort(sc, 0x13, 0x80D1);
25140                 ClearAndSetEthPhyBit(sc,
25141                                      0x14,
25142                                      0xFF00,
25143                                      0xFF00
25144                                     );
25145                 MP_WritePhyUshort(sc, 0x13, 0x80CD);
25146                 ClearAndSetEthPhyBit(sc,
25147                                      0x14,
25148                                      0xFF00,
25149                                      0x9E00
25150                                     );
25151                 MP_WritePhyUshort(sc, 0x13, 0x80D3);
25152                 ClearAndSetEthPhyBit(sc,
25153                                      0x14,
25154                                      0xFF00,
25155                                      0x0E00
25156                                     );
25157                 MP_WritePhyUshort(sc, 0x13, 0x80D5);
25158                 ClearAndSetEthPhyBit(sc,
25159                                      0x14,
25160                                      0xFF00,
25161                                      0xCA00
25162                                     );
25163                 MP_WritePhyUshort(sc, 0x13, 0x80D7);
25164                 ClearAndSetEthPhyBit(sc,
25165                                      0x14,
25166                                      0xFF00,
25167                                      0x8400
25168                                     );
25169
25170                 if (phy_power_saving == 1) {
25171                         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25172                         SetEthPhyBit(sc, 0x10, BIT_2);
25173                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
25174                 } else {
25175                         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25176                         ClearEthPhyBit(sc, 0x10, BIT_2);
25177                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
25178                         DELAY(20000);
25179                 }
25180
25181                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25182                 MP_WritePhyUshort(sc, 0x13, 0x8011);
25183                 ClearEthPhyBit(sc, 0x14, BIT_14);
25184                 MP_WritePhyUshort(sc, 0x1F, 0x0A40);
25185                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25186                 MP_WritePhyUshort(sc, 0x00, 0x9200);
25187         } else if (sc->re_type == MACFG_63) {
25188                 MP_WritePhyUshort(sc, 0x1f, 0x0002);
25189                 MP_WritePhyUshort(sc, 0x10, 0x0008);
25190                 MP_WritePhyUshort(sc, 0x0d, 0x006c);
25191                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
25192
25193                 MP_WritePhyUshort(sc, 0x1f, 0x0001);
25194                 MP_WritePhyUshort(sc, 0x17, 0x0cc0);
25195                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
25196
25197                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
25198                 MP_WritePhyUshort(sc, 0x0B, 0xA4D8);
25199                 MP_WritePhyUshort(sc, 0x09, 0x281C);
25200                 MP_WritePhyUshort(sc, 0x07, 0x2883);
25201                 MP_WritePhyUshort(sc, 0x0A, 0x6B35);
25202                 MP_WritePhyUshort(sc, 0x1D, 0x3DA4);
25203                 MP_WritePhyUshort(sc, 0x1C, 0xEFFD);
25204                 MP_WritePhyUshort(sc, 0x14, 0x7F52);
25205                 MP_WritePhyUshort(sc, 0x18, 0x7FC6);
25206                 MP_WritePhyUshort(sc, 0x08, 0x0601);
25207                 MP_WritePhyUshort(sc, 0x06, 0x4063);
25208                 MP_WritePhyUshort(sc, 0x10, 0xF074);
25209                 MP_WritePhyUshort(sc, 0x1F, 0x0003);
25210                 MP_WritePhyUshort(sc, 0x13, 0x0789);
25211                 MP_WritePhyUshort(sc, 0x12, 0xF4BD);
25212                 MP_WritePhyUshort(sc, 0x1A, 0x04FD);
25213                 MP_WritePhyUshort(sc, 0x14, 0x84B0);
25214                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25215
25216                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
25217                 MP_WritePhyUshort(sc, 0x01, 0x0340);
25218                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
25219                 MP_WritePhyUshort(sc, 0x04, 0x4000);
25220                 MP_WritePhyUshort(sc, 0x03, 0x1D21);
25221                 MP_WritePhyUshort(sc, 0x02, 0x0C32);
25222                 MP_WritePhyUshort(sc, 0x01, 0x0200);
25223                 MP_WritePhyUshort(sc, 0x00, 0x5554);
25224                 MP_WritePhyUshort(sc, 0x04, 0x4800);
25225                 MP_WritePhyUshort(sc, 0x04, 0x4000);
25226                 MP_WritePhyUshort(sc, 0x04, 0xF000);
25227                 MP_WritePhyUshort(sc, 0x03, 0xDF01);
25228                 MP_WritePhyUshort(sc, 0x02, 0xDF20);
25229                 MP_WritePhyUshort(sc, 0x01, 0x101A);
25230                 MP_WritePhyUshort(sc, 0x00, 0xA0FF);
25231                 MP_WritePhyUshort(sc, 0x04, 0xF800);
25232                 MP_WritePhyUshort(sc, 0x04, 0xF000);
25233                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25234
25235                 MP_WritePhyUshort(sc, 0x1F, 0x0007);
25236                 MP_WritePhyUshort(sc, 0x1E, 0x0023);
25237                 MP_WritePhyUshort(sc, 0x16, 0x0000);
25238                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25239
25240                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25241                 PhyRegValue = MP_ReadPhyUshort(sc, 0x0D);
25242                 PhyRegValue |= (BIT_5);
25243                 MP_WritePhyUshort(sc, 0x0D, PhyRegValue);
25244
25245                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
25246                 PhyRegValue = MP_ReadPhyUshort(sc, 0x0C);
25247                 PhyRegValue |= (BIT_10);
25248                 MP_WritePhyUshort(sc, 0x0C, PhyRegValue);
25249                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25250         } else if (sc->re_type == MACFG_64) {
25251                 MP_WritePhyUshort(sc, 0x1f, 0x0001);
25252                 MP_WritePhyUshort(sc, 0x17, 0x0cc0);
25253                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
25254
25255                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
25256                 MP_WritePhyUshort(sc, 0x01, 0x0340);
25257                 MP_WritePhyUshort(sc, 0x1F, 0x0001);
25258                 MP_WritePhyUshort(sc, 0x04, 0x4000);
25259                 MP_WritePhyUshort(sc, 0x03, 0x1D21);
25260                 MP_WritePhyUshort(sc, 0x02, 0x0C32);
25261                 MP_WritePhyUshort(sc, 0x01, 0x0200);
25262                 MP_WritePhyUshort(sc, 0x00, 0x5554);
25263                 MP_WritePhyUshort(sc, 0x04, 0x4800);
25264                 MP_WritePhyUshort(sc, 0x04, 0x4000);
25265                 MP_WritePhyUshort(sc, 0x04, 0xF000);
25266                 MP_WritePhyUshort(sc, 0x03, 0xDF01);
25267                 MP_WritePhyUshort(sc, 0x02, 0xDF20);
25268                 MP_WritePhyUshort(sc, 0x01, 0x101A);
25269                 MP_WritePhyUshort(sc, 0x00, 0xA0FF);
25270                 MP_WritePhyUshort(sc, 0x04, 0xF800);
25271                 MP_WritePhyUshort(sc, 0x04, 0xF000);
25272                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25273
25274                 MP_WritePhyUshort(sc, 0x1F, 0x0007);
25275                 MP_WritePhyUshort(sc, 0x1E, 0x0023);
25276                 MP_WritePhyUshort(sc, 0x16, 0x0000);
25277                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25278
25279                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25280                 PhyRegValue = MP_ReadPhyUshort(sc, 0x0D);
25281                 PhyRegValue |= (BIT_5);
25282                 MP_WritePhyUshort(sc, 0x0D, PhyRegValue);
25283
25284                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
25285                 PhyRegValue = MP_ReadPhyUshort(sc, 0x0C);
25286                 PhyRegValue |= (BIT_10);
25287                 MP_WritePhyUshort(sc, 0x0C, PhyRegValue);
25288                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25289         } else if (sc->re_type == MACFG_65) {
25290                 MP_WritePhyUshort(sc, 0x1f, 0x0001);
25291                 MP_WritePhyUshort(sc, 0x17, 0x0cc0);
25292                 MP_WritePhyUshort(sc, 0x1f, 0x0000);
25293
25294                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25295                 PhyRegValue = MP_ReadPhyUshort(sc, 0x0D);
25296                 PhyRegValue |= (BIT_5);
25297                 MP_WritePhyUshort(sc, 0x0D, PhyRegValue);
25298
25299                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
25300                 PhyRegValue = MP_ReadPhyUshort(sc, 0x0C);
25301                 PhyRegValue |= (BIT_10);
25302                 MP_WritePhyUshort(sc, 0x0C, PhyRegValue);
25303                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25304
25305                 MP_WritePhyUshort(sc, 0x1F, 0x0007);
25306                 MP_WritePhyUshort(sc, 0x1E, 0x002C);
25307                 MP_WritePhyUshort(sc, 0x15, 0x035D);
25308                 MP_WritePhyUshort(sc, 0x1F, 0x0005);
25309                 MP_WritePhyUshort(sc, 0x01, 0x0300);
25310                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25311         } else if (sc->re_type == MACFG_66) {
25312                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25313                 PhyRegValue = MP_ReadPhyUshort(sc, 0x0D);
25314                 PhyRegValue |= (BIT_5);
25315                 MP_WritePhyUshort(sc, 0x0D, PhyRegValue);
25316
25317                 MP_WritePhyUshort(sc, 0x1F, 0x0002);
25318                 PhyRegValue = MP_ReadPhyUshort(sc, 0x0C);
25319                 PhyRegValue |= (BIT_10);
25320                 MP_WritePhyUshort(sc, 0x0C, PhyRegValue);
25321                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25322         } else if (sc->re_type == MACFG_68) {
25323                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25324                 MP_WritePhyUshort(sc, 0x13, 0x809b);
25325                 ClearAndSetEthPhyBit(sc,
25326                                      0x14,
25327                                      0xF800,
25328                                      0x8000
25329                                     );
25330                 MP_WritePhyUshort(sc, 0x13, 0x80A2);
25331                 ClearAndSetEthPhyBit(sc,
25332                                      0x14,
25333                                      0xFF00,
25334                                      0x8000
25335                                     );
25336                 MP_WritePhyUshort(sc, 0x13, 0x80A4);
25337                 ClearAndSetEthPhyBit(sc,
25338                                      0x14,
25339                                      0xFF00,
25340                                      0x8500
25341                                     );
25342                 MP_WritePhyUshort(sc, 0x13, 0x809C);
25343                 ClearAndSetEthPhyBit(sc,
25344                                      0x14,
25345                                      0xFF00,
25346                                      0xbd00
25347                                     );
25348                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25349
25350                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25351                 MP_WritePhyUshort(sc, 0x13, 0x80AD);
25352                 ClearAndSetEthPhyBit(sc,
25353                                      0x14,
25354                                      0xF800,
25355                                      0x7000
25356                                     );
25357                 MP_WritePhyUshort(sc, 0x13, 0x80B4);
25358                 ClearAndSetEthPhyBit(sc,
25359                                      0x14,
25360                                      0xFF00,
25361                                      0x5000
25362                                     );
25363                 MP_WritePhyUshort(sc, 0x13, 0x80AC);
25364                 ClearAndSetEthPhyBit(sc,
25365                                      0x14,
25366                                      0xFF00,
25367                                      0x4000
25368                                     );
25369                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25370
25371                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25372                 MP_WritePhyUshort(sc, 0x13, 0x808E);
25373                 ClearAndSetEthPhyBit(sc,
25374                                      0x14,
25375                                      0xFF00,
25376                                      0x1200
25377                                     );
25378                 MP_WritePhyUshort(sc, 0x13, 0x8090);
25379                 ClearAndSetEthPhyBit(sc,
25380                                      0x14,
25381                                      0xFF00,
25382                                      0xE500
25383                                     );
25384                 MP_WritePhyUshort(sc, 0x13, 0x8092);
25385                 ClearAndSetEthPhyBit(sc,
25386                                      0x14,
25387                                      0xFF00,
25388                                      0x9F00
25389                                     );
25390                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25391
25392                 dout_tapbin = 0x0000;
25393                 MP_WritePhyUshort(sc, 0x1F, 0x0A46);
25394                 TmpUshort = MP_ReadPhyUshort(sc, 0x13);
25395                 TmpUshort &= (BIT_1|BIT_0);
25396                 TmpUshort <<= 2;
25397                 dout_tapbin |= TmpUshort;
25398
25399                 TmpUshort = MP_ReadPhyUshort(sc, 0x12);
25400                 TmpUshort &= (BIT_15|BIT_14);
25401                 TmpUshort >>= 14;
25402                 dout_tapbin |= TmpUshort;
25403
25404                 dout_tapbin = ~(dout_tapbin^BIT_3);
25405                 dout_tapbin <<= 12;
25406                 dout_tapbin &= 0xF000;
25407
25408                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25409
25410                 MP_WritePhyUshort(sc, 0x13, 0x827A);
25411                 ClearAndSetEthPhyBit(sc,
25412                                      0x14,
25413                                      BIT_15|BIT_14|BIT_13|BIT_12,
25414                                      dout_tapbin
25415                                     );
25416
25417
25418                 MP_WritePhyUshort(sc, 0x13, 0x827B);
25419                 ClearAndSetEthPhyBit(sc,
25420                                      0x14,
25421                                      BIT_15|BIT_14|BIT_13|BIT_12,
25422                                      dout_tapbin
25423                                     );
25424
25425
25426                 MP_WritePhyUshort(sc, 0x13, 0x827C);
25427                 ClearAndSetEthPhyBit(sc,
25428                                      0x14,
25429                                      BIT_15|BIT_14|BIT_13|BIT_12,
25430                                      dout_tapbin
25431                                     );
25432
25433
25434                 MP_WritePhyUshort(sc, 0x13, 0x827D);
25435                 ClearAndSetEthPhyBit(sc,
25436                                      0x14,
25437                                      BIT_15|BIT_14|BIT_13|BIT_12,
25438                                      dout_tapbin
25439                                     );
25440
25441                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25442                 MP_WritePhyUshort(sc, 0x13, 0x8011);
25443                 SetEthPhyBit(sc, 0x14, BIT_11);
25444                 MP_WritePhyUshort(sc, 0x1F, 0x0A42);
25445                 SetEthPhyBit(sc, 0x16, BIT_1);
25446
25447                 MP_WritePhyUshort(sc, 0x1F, 0x0A44);
25448                 SetEthPhyBit(sc, 0x11, BIT_11);
25449                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25450
25451                 MP_WritePhyUshort(sc, 0x1F, 0x0BCA);
25452                 ClearAndSetEthPhyBit(sc,
25453                                      0x17,
25454                                      (BIT_13 | BIT_12),
25455                                      BIT_14
25456                                     );
25457                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25458
25459                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25460                 MP_WritePhyUshort(sc, 0x13, 0x803F);
25461                 ClearEthPhyBit(sc, 0x14, (BIT_13 | BIT_12));
25462                 MP_WritePhyUshort(sc, 0x13, 0x8047);
25463                 ClearEthPhyBit(sc, 0x14, (BIT_13 | BIT_12));
25464                 MP_WritePhyUshort(sc, 0x13, 0x804F);
25465                 ClearEthPhyBit(sc, 0x14, (BIT_13 | BIT_12));
25466                 MP_WritePhyUshort(sc, 0x13, 0x8057);
25467                 ClearEthPhyBit(sc, 0x14, (BIT_13 | BIT_12));
25468                 MP_WritePhyUshort(sc, 0x13, 0x805F);
25469                 ClearEthPhyBit(sc, 0x14, (BIT_13 | BIT_12));
25470                 MP_WritePhyUshort(sc, 0x13, 0x8067);
25471                 ClearEthPhyBit(sc, 0x14, (BIT_13 | BIT_12));
25472                 MP_WritePhyUshort(sc, 0x13, 0x806F);
25473                 ClearEthPhyBit(sc, 0x14, (BIT_13 | BIT_12));
25474                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25475
25476                 if (phy_power_saving == 1) {
25477                         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25478                         SetEthPhyBit(sc, 0x10, BIT_2);
25479                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
25480                 } else {
25481                         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25482                         ClearEthPhyBit(sc, 0x10, BIT_2);
25483                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
25484                         DELAY(20000);
25485                 }
25486
25487                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25488                 MP_WritePhyUshort(sc, 0x13, 0x8045);
25489                 MP_WritePhyUshort(sc, 0x14, 0x2444);
25490                 MP_WritePhyUshort(sc, 0x13, 0x804d);
25491                 MP_WritePhyUshort(sc, 0x14, 0x2444);
25492                 MP_WritePhyUshort(sc, 0x13, 0x805d);
25493                 MP_WritePhyUshort(sc, 0x14, 0x2444);
25494                 MP_WritePhyUshort(sc, 0x13, 0x8011);
25495                 SetEthPhyBit(sc, 0x14, BIT_15);
25496                 MP_WritePhyUshort(sc, 0x1F, 0x0A40);
25497                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25498                 MP_WritePhyUshort(sc, 0x00, 0x9200);
25499         } else if (sc->re_type == MACFG_69) {
25500                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25501                 MP_WritePhyUshort(sc, 0x13, 0x808A);
25502                 ClearAndSetEthPhyBit(sc,
25503                                      0x14,
25504                                      BIT_5 | BIT_4 | BIT_3 | BIT_2 | BIT_1 | BIT_0,
25505                                      0x0A);
25506
25507                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25508                 MP_WritePhyUshort(sc, 0x13, 0x8011);
25509                 SetEthPhyBit(sc, 0x14, BIT_11);
25510                 MP_WritePhyUshort(sc, 0x1F, 0x0A42);
25511                 SetEthPhyBit(sc, 0x16, BIT_1);
25512
25513                 MP_WritePhyUshort(sc, 0x1F, 0x0A44);
25514                 SetEthPhyBit(sc, 0x11, BIT_11);
25515                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25516
25517                 if (sc->RequireAdcBiasPatch) {
25518                         MP_WritePhyUshort(sc, 0x1F, 0x0BCF);
25519                         MP_WritePhyUshort(sc, 0x16, sc->AdcBiasPatchIoffset);
25520                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
25521                 }
25522
25523                 {
25524                         u_int16_t rlen;
25525
25526                         MP_WritePhyUshort(sc, 0x1F, 0x0BCD);
25527                         PhyRegValue = MP_ReadPhyUshort(sc, 0x16);
25528                         PhyRegValue &= 0x000F;
25529
25530                         if (PhyRegValue > 3) {
25531                                 rlen = PhyRegValue - 3;
25532                         } else {
25533                                 rlen = 0;
25534                         }
25535
25536                         PhyRegValue = rlen | (rlen<<4) | (rlen<<8) | (rlen<<12);
25537
25538                         MP_WritePhyUshort(sc, 0x1F, 0x0BCD);
25539                         MP_WritePhyUshort(sc, 0x17, PhyRegValue);
25540                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
25541                 }
25542
25543                 if (phy_power_saving == 1) {
25544                         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25545                         SetEthPhyBit(sc, 0x10, BIT_2);
25546                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
25547                 } else {
25548                         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25549                         ClearEthPhyBit(sc, 0x10, BIT_2);
25550                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
25551                         DELAY(20000);
25552                 }
25553
25554                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25555                 MP_WritePhyUshort(sc, 0x13, 0x8045);
25556                 MP_WritePhyUshort(sc, 0x14, 0x2444);
25557                 MP_WritePhyUshort(sc, 0x13, 0x804d);
25558                 MP_WritePhyUshort(sc, 0x14, 0x2444);
25559                 MP_WritePhyUshort(sc, 0x13, 0x805d);
25560                 MP_WritePhyUshort(sc, 0x14, 0x2444);
25561                 MP_WritePhyUshort(sc, 0x13, 0x8011);
25562                 SetEthPhyBit(sc, 0x14, BIT_15);
25563                 MP_WritePhyUshort(sc, 0x1F, 0x0A40);
25564                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25565                 MP_WritePhyUshort(sc, 0x00, 0x9200);
25566         }  else if (sc->re_type == MACFG_70 || sc->re_type == MACFG_71) {
25567                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25568                 MP_WritePhyUshort(sc, 0x13, 0x808E);
25569                 ClearAndSetEthPhyBit( sc,
25570                                       0x14,
25571                                       0xFF00,
25572                                       0x4000
25573                                     );
25574                 MP_WritePhyUshort(sc, 0x13, 0x8090);
25575                 ClearAndSetEthPhyBit( sc,
25576                                       0x14,
25577                                       0xFF00,
25578                                       0xCC00
25579                                     );
25580                 MP_WritePhyUshort(sc, 0x13, 0x8092);
25581                 ClearAndSetEthPhyBit( sc,
25582                                       0x14,
25583                                       0xFF00,
25584                                       0xB000
25585                                     );
25586                 MP_WritePhyUshort(sc, 0x13, 0x8088);
25587                 ClearAndSetEthPhyBit( sc,
25588                                       0x14,
25589                                       0xFF00,
25590                                       0x8000
25591                                     );
25592                 MP_WritePhyUshort(sc, 0x13, 0x808B);
25593                 ClearAndSetEthPhyBit( sc,
25594                                       0x14,
25595                                       0x3F00,
25596                                       0x0B00
25597                                     );
25598                 MP_WritePhyUshort(sc, 0x13, 0x808D);
25599                 ClearAndSetEthPhyBit( sc,
25600                                       0x14,
25601                                       0x1F00,
25602                                       0x0600
25603                                     );
25604                 MP_WritePhyUshort(sc, 0x13, 0x808C);
25605                 ClearAndSetEthPhyBit( sc,
25606                                       0x14,
25607                                       0xFF00,
25608                                       0xB000
25609                                     );
25610
25611                 MP_WritePhyUshort(sc, 0x13, 0x80A0);
25612                 ClearAndSetEthPhyBit( sc,
25613                                       0x14,
25614                                       0xFF00,
25615                                       0x2000
25616                                     );
25617                 MP_WritePhyUshort(sc, 0x13, 0x80A2);
25618                 ClearAndSetEthPhyBit( sc,
25619                                       0x14,
25620                                       0xFF00,
25621                                       0x5000
25622                                     );
25623                 MP_WritePhyUshort(sc, 0x13, 0x809B);
25624                 ClearAndSetEthPhyBit( sc,
25625                                       0x14,
25626                                       0xF800,
25627                                       0xB000
25628                                     );
25629                 MP_WritePhyUshort(sc, 0x13, 0x809A);
25630                 ClearAndSetEthPhyBit( sc,
25631                                       0x14,
25632                                       0xFF00,
25633                                       0x4B00
25634                                     );
25635                 MP_WritePhyUshort(sc, 0x13, 0x809D);
25636                 ClearAndSetEthPhyBit( sc,
25637                                       0x14,
25638                                       0x3F00,
25639                                       0x0800
25640                                     );
25641                 MP_WritePhyUshort(sc, 0x13, 0x80A1);
25642                 ClearAndSetEthPhyBit( sc,
25643                                       0x14,
25644                                       0xFF00,
25645                                       0x7000
25646                                     );
25647                 MP_WritePhyUshort(sc, 0x13, 0x809F);
25648                 ClearAndSetEthPhyBit( sc,
25649                                       0x14,
25650                                       0x1F00,
25651                                       0x0300
25652                                     );
25653                 MP_WritePhyUshort(sc, 0x13, 0x809E);
25654                 ClearAndSetEthPhyBit( sc,
25655                                       0x14,
25656                                       0xFF00,
25657                                       0x8800
25658                                     );
25659
25660                 MP_WritePhyUshort(sc, 0x13, 0x80B2);
25661                 ClearAndSetEthPhyBit( sc,
25662                                       0x14,
25663                                       0xFF00,
25664                                       0x2200
25665                                     );
25666                 MP_WritePhyUshort(sc, 0x13, 0x80AD);
25667                 ClearAndSetEthPhyBit( sc,
25668                                       0x14,
25669                                       0xF800,
25670                                       0x9800
25671                                     );
25672                 MP_WritePhyUshort(sc, 0x13, 0x80AF);
25673                 ClearAndSetEthPhyBit( sc,
25674                                       0x14,
25675                                       0x3F00,
25676                                       0x0800
25677                                     );
25678                 MP_WritePhyUshort(sc, 0x13, 0x80B3);
25679                 ClearAndSetEthPhyBit( sc,
25680                                       0x14,
25681                                       0xFF00,
25682                                       0x6F00
25683                                     );
25684                 MP_WritePhyUshort(sc, 0x13, 0x80B1);
25685                 ClearAndSetEthPhyBit( sc,
25686                                       0x14,
25687                                       0x1F00,
25688                                       0x0300
25689                                     );
25690                 MP_WritePhyUshort(sc, 0x13, 0x80B0);
25691                 ClearAndSetEthPhyBit( sc,
25692                                       0x14,
25693                                       0xFF00,
25694                                       0x9300
25695                                     );
25696                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25697
25698                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25699                 MP_WritePhyUshort(sc, 0x13, 0x8011);
25700                 SetEthPhyBit(sc, 0x14, BIT_11);
25701                 MP_WritePhyUshort(sc, 0x1F, 0x0A42);
25702                 SetEthPhyBit(sc, 0x16, BIT_1);
25703
25704                 MP_WritePhyUshort(sc, 0x1F, 0x0A44);
25705                 SetEthPhyBit( sc, 0x11, BIT_11 );
25706                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25707
25708                 if (phy_power_saving == 1) {
25709                         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25710                         SetEthPhyBit(sc, 0x10, BIT_2);
25711                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
25712                 } else {
25713                         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25714                         ClearEthPhyBit(sc, 0x10, BIT_2);
25715                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
25716                         DELAY(20000);
25717                 }
25718
25719                 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25720                 MP_WritePhyUshort(sc, 0x13, 0x8045);
25721                 MP_WritePhyUshort(sc, 0x14, 0x2444);
25722                 MP_WritePhyUshort(sc, 0x13, 0x804d);
25723                 MP_WritePhyUshort(sc, 0x14, 0x2444);
25724                 MP_WritePhyUshort(sc, 0x13, 0x805d);
25725                 MP_WritePhyUshort(sc, 0x14, 0x2444);
25726                 MP_WritePhyUshort(sc, 0x13, 0x8011);
25727                 SetEthPhyBit(sc, 0x14, BIT_15);
25728                 MP_WritePhyUshort(sc, 0x1F, 0x0A40);
25729                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25730                 MP_WritePhyUshort(sc, 0x00, 0x9200);
25731         }
25732         //EthPhyPPSW
25733         if (sc->re_type == MACFG_56 || sc->re_type == MACFG_56 ||
25734             sc->re_type == MACFG_58 || sc->re_type == MACFG_58 ||
25735             sc->re_type == MACFG_60) {
25736                 //disable EthPhyPPSW
25737                 MP_WritePhyUshort(sc, 0x1F, 0x0BCD);
25738                 MP_WritePhyUshort(sc, 0x14, 0x5065);
25739                 MP_WritePhyUshort(sc, 0x14, 0xD065);
25740                 MP_WritePhyUshort(sc, 0x1F, 0x0BC8);
25741                 MP_WritePhyUshort(sc, 0x12, 0x00ED);
25742                 MP_WritePhyUshort(sc, 0x1F, 0x0BCD);
25743                 MP_WritePhyUshort(sc, 0x14, 0x1065);
25744                 MP_WritePhyUshort(sc, 0x14, 0x9065);
25745                 MP_WritePhyUshort(sc, 0x14, 0x1065);
25746                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25747         } else if (sc->re_type == MACFG_68 || sc->re_type == MACFG_69) {
25748                 //enable EthPhyPPSW
25749                 MP_WritePhyUshort(sc, 0x1F, 0x0A44);
25750                 SetEthPhyBit(sc, 0x11, BIT_7);
25751                 MP_WritePhyUshort(sc, 0x1F, 0x0000);
25752         }
25753
25754         switch(sc->re_type) {
25755         case MACFG_56:
25756         case MACFG_57:
25757         case MACFG_58:
25758         case MACFG_59:
25759         case MACFG_60:
25760         case MACFG_61:
25761         case MACFG_62:
25762         case MACFG_67:
25763         case MACFG_68:
25764         case MACFG_69:
25765         case MACFG_70:
25766         case MACFG_71:
25767                 if (phy_mdix_mode == RE_ETH_PHY_FORCE_MDI) {
25768                         //Force MDI
25769                         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25770                         SetEthPhyBit(sc, 0x10, BIT_8 | BIT_9);
25771                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
25772                 } else if (phy_mdix_mode == RE_ETH_PHY_FORCE_MDIX) {
25773                         //Force MDIX
25774                         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25775                         ClearEthPhyBit(sc, 0x10, BIT_8);
25776                         SetEthPhyBit(sc, 0x10, BIT_9);
25777                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
25778                 } else {
25779                         //Auto MDI/MDIX
25780                         MP_WritePhyUshort(sc, 0x1F, 0x0A43);
25781                         ClearEthPhyBit(sc, 0x10, BIT_8 | BIT_9);
25782                         MP_WritePhyUshort(sc, 0x1F, 0x0000);
25783                 }
25784
25785                 break;
25786         }
25787
25788         if (phy_power_saving == 1) {
25789                 if (sc->re_type == MACFG_59 || sc->re_type == MACFG_60 ||
25790                     sc->re_type == MACFG_62 || sc->re_type == MACFG_67 ||
25791                     sc->re_type == MACFG_68 || sc->re_type == MACFG_69 ||
25792                     sc->re_type == MACFG_70 || sc->re_type == MACFG_71) {
25793                         MP_WritePhyOcpRegWord(sc, 0x0C41, 0x13, 0x0000);
25794                         MP_WritePhyOcpRegWord(sc, 0x0C41, 0x13, 0x0050);
25795                 }
25796         }
25797
25798         if (eee_enable == 1)
25799                 re_enable_EEE(sc);
25800         else
25801                 re_disable_EEE(sc);
25802
25803         MP_WritePhyUshort(sc, 0x1F, 0x0000);
25804 }
25805
25806 void MP_WritePhyUshort(struct re_softc *sc,u_int8_t RegAddr,u_int16_t RegData)
25807 {
25808         u_int32_t               TmpUlong=0x80000000;
25809         u_int32_t               Timeout=0;
25810
25811         if (RegAddr == 0x1F) {
25812                 sc->cur_page = RegData;
25813         }
25814
25815         if (sc->re_type == MACFG_63) {
25816                 int i;
25817                 CSR_WRITE_4(sc, RE_OCPDR, OCPDR_Write |
25818                             (RegAddr & OCPDR_Reg_Mask) << OCPDR_GPHY_Reg_shift |
25819                             (RegData & OCPDR_Data_Mask));
25820                 CSR_WRITE_4(sc, RE_OCPAR, OCPAR_GPHY_Write);
25821                 CSR_WRITE_4(sc, RE_EPHY_RXER_NUM, 0);
25822
25823                 for (i = 0; i < 100; i++) {
25824                         DELAY(1000);
25825                         if (!(CSR_READ_4(sc, RE_OCPAR) & OCPAR_Flag))
25826                                 break;
25827                 }
25828         } else if (sc->re_type == MACFG_56 || sc->re_type == MACFG_57 ||
25829                    sc->re_type == MACFG_58 || sc->re_type == MACFG_59 ||
25830                    sc->re_type == MACFG_60 || sc->re_type == MACFG_61 ||
25831                    sc->re_type == MACFG_62 || sc->re_type == MACFG_67 ||
25832                    sc->re_type == MACFG_69 || sc->re_type == MACFG_69 ||
25833                    sc->re_type == MACFG_70 || sc->re_type == MACFG_71) {
25834                 if (RegAddr == 0x1F) {
25835                         return;
25836                 }
25837
25838                 MP_WritePhyOcpRegWord(sc, sc->cur_page, RegAddr, RegData);
25839         } else {
25840                 if (sc->re_type == MACFG_65 || sc->re_type == MACFG_66)
25841                         CSR_WRITE_4(sc, 0xD0, CSR_READ_4(sc, 0xD0) & ~0x00020000);
25842
25843                 TmpUlong |= (((u_int32_t)RegAddr)<<16 | (u_int32_t)RegData);
25844
25845                 CSR_WRITE_4(sc, RE_PHYAR, TmpUlong);
25846
25847                 /* Wait for writing to Phy ok */
25848                 for (Timeout=0; Timeout<5; Timeout++) {
25849                         DELAY(1000);
25850                         if ((CSR_READ_4(sc, RE_PHYAR)&PHYAR_Flag)==0)
25851                                 break;
25852                 }
25853
25854                 if (sc->re_type == MACFG_65 || sc->re_type == MACFG_66)
25855                         CSR_WRITE_4(sc, 0xD0, CSR_READ_4(sc, 0xD0) | 0x00020000);
25856         }
25857 }
25858
25859 u_int16_t MP_ReadPhyUshort(struct re_softc *sc,u_int8_t RegAddr)
25860 {
25861         u_int16_t               RegData;
25862         u_int32_t               TmpUlong;
25863         u_int32_t               Timeout=0;
25864
25865         if (sc->re_type == MACFG_63) {
25866                 int i;
25867                 CSR_WRITE_4(sc, RE_OCPDR, OCPDR_Read |
25868                             (RegAddr & OCPDR_Reg_Mask) << OCPDR_GPHY_Reg_shift);
25869                 CSR_WRITE_4(sc, RE_OCPAR, OCPAR_GPHY_Write);
25870                 CSR_WRITE_4(sc, RE_EPHY_RXER_NUM, 0);
25871
25872                 for (i = 0; i < 100; i++) {
25873                         DELAY(1000);
25874                         if (!(CSR_READ_4(sc, RE_OCPAR) & OCPAR_Flag))
25875                                 break;
25876                 }
25877
25878                 DELAY(1000);
25879                 CSR_WRITE_4(sc, RE_OCPAR, OCPAR_GPHY_Read);
25880                 CSR_WRITE_4(sc, RE_EPHY_RXER_NUM, 0);
25881
25882                 for (i = 0; i < 100; i++) {
25883                         DELAY(1000);
25884                         if (CSR_READ_4(sc, RE_OCPAR) & OCPAR_Flag)
25885                                 break;
25886                 }
25887
25888                 RegData = CSR_READ_4(sc, RE_OCPDR) & OCPDR_Data_Mask;
25889         } else if (sc->re_type == MACFG_56 || sc->re_type == MACFG_57 ||
25890                    sc->re_type == MACFG_58 || sc->re_type == MACFG_59 ||
25891                    sc->re_type == MACFG_60 || sc->re_type == MACFG_61 ||
25892                    sc->re_type == MACFG_62 || sc->re_type == MACFG_67 ||
25893                    sc->re_type == MACFG_69 || sc->re_type == MACFG_69 ||
25894                    sc->re_type == MACFG_70 || sc->re_type == MACFG_71) {
25895                 RegData= MP_ReadPhyOcpRegWord(sc, sc->cur_page, RegAddr);
25896
25897         } else {
25898                 if (sc->re_type == MACFG_65 || sc->re_type == MACFG_66)
25899                         CSR_WRITE_4(sc, 0xD0, CSR_READ_4(sc, 0xD0) & ~0x00020000);
25900
25901                 TmpUlong = ((u_int32_t)RegAddr << 16);
25902                 CSR_WRITE_4(sc, RE_PHYAR, TmpUlong);
25903
25904                 /* Wait for writing to Phy ok */
25905                 for (Timeout=0; Timeout<5; Timeout++) {
25906                         DELAY(1000);
25907                         TmpUlong = CSR_READ_4(sc, RE_PHYAR);
25908                         if ((TmpUlong&PHYAR_Flag)!=0)
25909                                 break;
25910                 }
25911
25912                 RegData = (u_int16_t)(TmpUlong & 0x0000ffff);
25913
25914                 if (sc->re_type == MACFG_65 || sc->re_type == MACFG_66)
25915                         CSR_WRITE_4(sc, 0xD0, CSR_READ_4(sc, 0xD0) | 0x00020000);
25916         }
25917
25918         return RegData;
25919 }
25920
25921 void MP_WriteEPhyUshort(struct re_softc *sc, u_int8_t RegAddr, u_int16_t RegData)
25922 {
25923         u_int32_t               TmpUlong=0x80000000;
25924         u_int32_t               Timeout=0;
25925
25926         TmpUlong |= (((u_int32_t)RegAddr<<16) | (u_int32_t)RegData);
25927
25928         CSR_WRITE_4(sc, RE_EPHYAR, TmpUlong);
25929
25930         /* Wait for writing to Phy ok */
25931         for (Timeout=0; Timeout<5; Timeout++) {
25932                 DELAY(1000);
25933                 if ((CSR_READ_4(sc, RE_EPHYAR)&PHYAR_Flag)==0)
25934                         break;
25935         }
25936 }
25937
25938 u_int16_t MP_ReadEPhyUshort(struct re_softc *sc, u_int8_t RegAddr)
25939 {
25940         u_int16_t               RegData;
25941         u_int32_t               TmpUlong;
25942         u_int32_t               Timeout=0;
25943
25944         TmpUlong = ((u_int32_t)RegAddr << 16);
25945         CSR_WRITE_4(sc, RE_EPHYAR, TmpUlong);
25946
25947         /* Wait for writing to Phy ok */
25948         for (Timeout=0; Timeout<5; Timeout++) {
25949                 DELAY(1000);
25950                 TmpUlong = CSR_READ_4(sc, RE_EPHYAR);
25951                 if ((TmpUlong&PHYAR_Flag)!=0)
25952                         break;
25953         }
25954
25955         RegData = (u_int16_t)(TmpUlong & 0x0000ffff);
25956
25957         return RegData;
25958 }
25959
25960 static u_int8_t re_calc_efuse_dummy_bit(u_int16_t reg)
25961 {
25962         int s,a,b;
25963         u_int8_t dummyBitPos = 0;
25964
25965
25966         s=reg% 32;
25967         a=s % 16;
25968         b=s/16;
25969
25970         if (s/16) {
25971                 dummyBitPos = (u_int8_t)(16-a);
25972         } else {
25973                 dummyBitPos = (u_int8_t)a;
25974         }
25975
25976         return dummyBitPos;
25977 }
25978
25979 static u_int32_t re_decode_efuse_cmd(struct re_softc *sc, u_int32_t DwCmd)
25980 {
25981         u_int16_t reg = (u_int16_t)((DwCmd & 0x00FE0000) >> 17);
25982         u_int32_t DummyPos = re_calc_efuse_dummy_bit(reg);
25983         u_int32_t DeCodeDwCmd = DwCmd;
25984         u_int32_t Dw17BitData;
25985
25986
25987         if (sc->re_efuse_ver < 3) {
25988                 DeCodeDwCmd = (DwCmd>>(DummyPos+1))<<DummyPos;
25989                 if (DummyPos > 0) {
25990                         DeCodeDwCmd |= ((DwCmd<<(32-DummyPos))>>(32-DummyPos));
25991                 }
25992         } else {
25993                 reg = (u_int16_t)((DwCmd & 0x007F0000) >> 16);
25994                 DummyPos = re_calc_efuse_dummy_bit(reg);
25995                 Dw17BitData = ((DwCmd & BIT_23) >> 23);
25996                 Dw17BitData <<= 16;
25997                 Dw17BitData |= (DwCmd & 0x0000FFFF);
25998                 DeCodeDwCmd = (Dw17BitData>>(DummyPos+1))<<DummyPos;
25999                 if (DummyPos > 0) {
26000                         DeCodeDwCmd |= ((Dw17BitData<<(32-DummyPos))>>(32-DummyPos));
26001                 }
26002         }
26003
26004         return DeCodeDwCmd;
26005 }
26006
26007 #define EFUSE_WRITE 0x80000000
26008 #define EFUSE_WRITE_OK  0x00000000
26009 #define EFUSE_READ  0x00000000
26010 #define EFUSE_READ_OK  0x80000000
26011 #define EFUSE_Reg_Mask 0x03FF
26012 #define EFUSE_Reg_Shift 8
26013 #define EFUSE_Check_Cnt 300
26014 #define EFUSE_READ_FAIL 0xFF
26015 #define EFUSE_Data_Mask 0x000000FF
26016
26017 u_int8_t MP_ReadEfuse(struct re_softc *sc, u_int16_t reg)
26018 {
26019         u_int8_t efuse_data = 0;
26020         u_int32_t temp;
26021         u_int32_t cnt;
26022
26023         if (sc->re_efuse_ver == EFUSE_NOT_SUPPORT)
26024                 return EFUSE_READ_FAIL;
26025
26026         if (sc->re_efuse_ver == EFUSE_SUPPORT_V1) {
26027                 temp = EFUSE_READ | ((reg & EFUSE_Reg_Mask) << EFUSE_Reg_Shift);
26028                 CSR_WRITE_4(sc, RE_EFUSEAR, temp);
26029
26030                 cnt = 0;
26031                 do {
26032                         DELAY(100);
26033                         temp = CSR_READ_4(sc, RE_EFUSEAR);
26034                         cnt++;
26035                 } while (!(temp & EFUSE_READ_OK) && (cnt < EFUSE_Check_Cnt));
26036
26037                 if (cnt == EFUSE_Check_Cnt)
26038                         efuse_data = EFUSE_READ_FAIL;
26039                 else
26040                         efuse_data = (u_int8_t)(CSR_READ_4(sc, RE_EFUSEAR) & EFUSE_Data_Mask);
26041         } else  if (sc->re_efuse_ver == EFUSE_SUPPORT_V2) {
26042                 temp = (reg/2) & 0x03ff;
26043                 temp <<= 17;
26044                 temp |= EFUSE_READ;
26045                 CSR_WRITE_4(sc, RE_EFUSEAR, temp);
26046
26047                 cnt = 0;
26048                 do {
26049                         DELAY(100);
26050                         temp = CSR_READ_4(sc, RE_EFUSEAR);
26051                         cnt++;
26052                 } while (!(temp & EFUSE_READ_OK) && (cnt < EFUSE_Check_Cnt));
26053
26054                 if (cnt == EFUSE_Check_Cnt) {
26055                         efuse_data = EFUSE_READ_FAIL;
26056                 } else {
26057                         temp = CSR_READ_4(sc, RE_EFUSEAR);
26058                         temp = re_decode_efuse_cmd(sc, temp);
26059
26060                         if (reg%2) {
26061                                 temp >>= 8;
26062                                 efuse_data = (u_int8_t)temp;
26063                         } else {
26064                                 efuse_data = (u_int8_t)temp;
26065                         }
26066                 }
26067         } else  if (sc->re_efuse_ver == EFUSE_SUPPORT_V3) {
26068                 temp = (reg/2) & 0x03ff;
26069                 temp <<= 16;
26070                 temp |= EFUSE_READ;
26071                 CSR_WRITE_4(sc, RE_EFUSEAR, temp);
26072
26073                 cnt = 0;
26074                 do {
26075                         DELAY(100);
26076                         temp = CSR_READ_4(sc, RE_EFUSEAR);
26077                         cnt++;
26078                 } while (!(temp & EFUSE_READ_OK) && (cnt < EFUSE_Check_Cnt));
26079
26080                 if (cnt == EFUSE_Check_Cnt) {
26081                         efuse_data = EFUSE_READ_FAIL;
26082                 } else {
26083                         temp = CSR_READ_4(sc, RE_EFUSEAR);
26084                         temp = re_decode_efuse_cmd(sc, temp);
26085
26086                         if (reg%2) {
26087                                 temp >>= 8;
26088                                 efuse_data = (u_int8_t)temp;
26089                         } else {
26090                                 efuse_data = (u_int8_t)temp;
26091                         }
26092                 }
26093         }
26094
26095         DELAY(20);
26096
26097         return efuse_data;
26098 }
26099
26100 void MP_WriteOtherFunPciEConfigSpace(
26101         struct re_softc *sc,
26102         u_int8_t MultiFunSelBit,
26103         u_int16_t ByteEnAndAddr,
26104         u_int32_t RegData)
26105 {
26106         u_int32_t Timeout = 0, WaitCount = 10;
26107         u_int32_t TmpUlong = 0x80000000;
26108         u_int32_t WriteDone;
26109
26110         if (MultiFunSelBit > 7) {
26111                 return;
26112         }
26113
26114         TmpUlong |= MultiFunSelBit << 16;
26115
26116         CSR_WRITE_4(sc, RE_CSIDR, RegData);
26117         TmpUlong |= (u_int32_t) ByteEnAndAddr;
26118         CSR_WRITE_4(sc, RE_CSIAR, TmpUlong);
26119
26120         do {
26121                 DELAY(100);
26122
26123                 WriteDone = CSR_READ_4(sc, RE_CSIAR);
26124                 Timeout++;
26125         } while (((WriteDone & 0x80000000) != 0) && (Timeout < WaitCount));
26126
26127
26128         DELAY(50);
26129 }
26130
26131 u_int32_t MP_ReadOtherFunPciEConfigSpace(
26132         struct re_softc *sc,
26133         u_int8_t MultiFunSelBit,
26134         u_int16_t ByteEnAndAddr)
26135 {
26136         u_int32_t Timeout = 0, WaitCount = 10;
26137         u_int32_t TmpUlong = 0x00000000;
26138         u_int32_t ReadDone;
26139         u_int32_t RetVal = 0xffffffff;
26140
26141         if (MultiFunSelBit > 7) {
26142                 return 0xffffffff;
26143         }
26144
26145         TmpUlong |= MultiFunSelBit << 16;
26146
26147         TmpUlong |= (u_int32_t) ByteEnAndAddr;
26148         CSR_WRITE_4(sc, RE_CSIAR, TmpUlong);
26149
26150         do {
26151                 DELAY(100);
26152
26153                 ReadDone = CSR_READ_4(sc, RE_CSIAR);
26154                 Timeout++;
26155         } while (((ReadDone & 0x80000000) == 0)&& (Timeout < WaitCount));
26156
26157         DELAY(50);
26158
26159         return RetVal;
26160 }
26161
26162 void MP_WritePciEConfigSpace(
26163         struct re_softc *sc,
26164         u_int16_t ByteEnAndAddr,
26165         u_int32_t RegData)
26166 {
26167         u_int8_t MultiFunSelBit;
26168
26169         if (sc->re_type == MACFG_52 || sc->re_type == MACFG_53) {
26170                 MultiFunSelBit = 2;
26171         } else if (sc->re_type == MACFG_60) {
26172                 MultiFunSelBit = 1;
26173         } else {
26174                 MultiFunSelBit = 0;
26175         }
26176
26177         MP_WriteOtherFunPciEConfigSpace(sc, MultiFunSelBit, ByteEnAndAddr, RegData);
26178
26179 }
26180
26181 u_int32_t MP_ReadPciEConfigSpace(
26182         struct re_softc *sc,
26183         u_int16_t ByteEnAndAddr)
26184 {
26185         u_int8_t MultiFunSelBit;
26186
26187         if (sc->re_type == MACFG_52 || sc->re_type == MACFG_53) {
26188                 MultiFunSelBit = 2;
26189         } else if (sc->re_type == MACFG_60) {
26190                 MultiFunSelBit = 1;
26191         } else {
26192                 MultiFunSelBit = 0;
26193         }
26194
26195         return MP_ReadOtherFunPciEConfigSpace(sc, MultiFunSelBit, ByteEnAndAddr);
26196 }
26197
26198 static u_int16_t MappingPhyOcpAddress(
26199         struct re_softc *sc,
26200         u_int16_t   PageNum,
26201         u_int8_t  RegNum)
26202 {
26203         u_int16_t OcpPageNum = 0;
26204         u_int8_t OcpRegNum = 0;
26205         u_int16_t OcpPhyAddress = 0;
26206
26207         if (PageNum == 0) {
26208                 OcpPageNum = 0x0A40 + (RegNum / 8);
26209                 OcpRegNum = 0x10 + (RegNum % 8);
26210         } else {
26211                 OcpPageNum = PageNum;
26212                 OcpRegNum = RegNum;
26213         }
26214
26215         OcpPageNum <<= 4;
26216
26217         if (OcpRegNum < 16) {
26218                 OcpPhyAddress = 0;
26219         } else {
26220                 OcpRegNum -= 16;
26221                 OcpRegNum <<= 1;
26222
26223                 OcpPhyAddress = OcpPageNum + OcpRegNum;
26224         }
26225
26226         return OcpPhyAddress;
26227 }
26228
26229 static u_int16_t MP_RealReadPhyOcpRegWord(
26230         struct re_softc *sc,
26231         u_int16_t OcpRegAddr)
26232 {
26233         u_int32_t Timeout = 0, WaitCount = 100;
26234         u_int32_t TmpUlong;
26235         u_int16_t RetVal = 0xffff;
26236
26237         TmpUlong = OcpRegAddr / 2;
26238         TmpUlong <<= 16;
26239
26240         CSR_WRITE_4(sc, RE_PHYOCPACCESS, TmpUlong);
26241
26242         do {
26243                 DELAY(1);
26244
26245                 TmpUlong = CSR_READ_4(sc, RE_PHYOCPACCESS);
26246
26247                 Timeout++;
26248         } while ((!(TmpUlong & PHYAR_Flag)) && (Timeout < WaitCount));
26249
26250         RetVal = (u_int16_t)TmpUlong;
26251
26252         return RetVal;
26253 }
26254
26255 u_int16_t MP_ReadPhyOcpRegWord(
26256         struct re_softc *sc,
26257         u_int16_t PhyPage,
26258         u_int8_t PhyRegNum)
26259 {
26260         u_int16_t OcpRegAddr;
26261         u_int16_t RetVal = 0xffff;
26262
26263         OcpRegAddr = MappingPhyOcpAddress(sc, PhyPage, PhyRegNum);
26264
26265         if (OcpRegAddr % 2) {
26266                 u_int16_t tmpUshort;
26267
26268                 tmpUshort = MP_RealReadPhyOcpRegWord(sc, OcpRegAddr);
26269                 tmpUshort &= 0xFF00;
26270                 tmpUshort >>= 8;
26271                 RetVal = tmpUshort;
26272
26273
26274                 tmpUshort = MP_RealReadPhyOcpRegWord(sc, OcpRegAddr + 1);
26275                 tmpUshort &= 0x00FF;
26276                 tmpUshort <<= 8;
26277                 RetVal |= tmpUshort;
26278         } else {
26279                 RetVal = MP_RealReadPhyOcpRegWord(sc, OcpRegAddr);
26280         }
26281
26282         return RetVal;
26283 }
26284
26285 static void MP_RealWritePhyOcpRegWord(
26286         struct re_softc *sc,
26287         u_int16_t OcpRegAddr,
26288         u_int16_t RegData)
26289 {
26290         u_int32_t Timeout = 0, WaitCount = 100;
26291         u_int32_t TmpUlong;
26292
26293         TmpUlong = OcpRegAddr / 2;
26294         TmpUlong <<= 16;
26295         TmpUlong += RegData;
26296         TmpUlong |= BIT_31;
26297
26298         CSR_WRITE_4(sc, RE_PHYOCPACCESS, TmpUlong);
26299
26300         do {
26301                 DELAY(1);
26302
26303                 TmpUlong = CSR_READ_4(sc, RE_PHYOCPACCESS);
26304
26305                 Timeout++;
26306         } while ((TmpUlong & PHYAR_Flag) && (Timeout < WaitCount));
26307 }
26308
26309 void MP_WritePhyOcpRegWord(
26310         struct re_softc *sc,
26311         u_int16_t PhyPage,
26312         u_int8_t PhyRegNum,
26313         u_int16_t RegData)
26314 {
26315         u_int16_t OcpRegAddr;
26316
26317         OcpRegAddr = MappingPhyOcpAddress(sc, PhyPage, PhyRegNum);
26318
26319         if (OcpRegAddr % 2) {
26320                 u_int16_t tmpUshort;
26321
26322                 tmpUshort = MP_RealReadPhyOcpRegWord(sc, OcpRegAddr);
26323                 tmpUshort &= 0x00FF;
26324                 tmpUshort |= (RegData <<  8);
26325                 MP_RealWritePhyOcpRegWord(sc, OcpRegAddr, tmpUshort);
26326                 tmpUshort = MP_RealReadPhyOcpRegWord(sc, OcpRegAddr + 1);
26327                 tmpUshort &= 0xFF00;
26328                 tmpUshort |= (RegData >> 8);
26329                 MP_RealWritePhyOcpRegWord(sc, OcpRegAddr + 1, tmpUshort);
26330         } else {
26331                 MP_RealWritePhyOcpRegWord(sc, OcpRegAddr, RegData);
26332         }
26333 }
26334
26335 void MP_WriteMcuAccessRegWord(
26336         struct re_softc *sc,
26337         u_int16_t ExtRegAddr,
26338         u_int16_t RegData)
26339 {
26340         u_int32_t TmpUlong;
26341
26342         TmpUlong = ExtRegAddr / 2;
26343         TmpUlong <<= 16;
26344         TmpUlong += RegData;
26345         TmpUlong |= BIT_31;
26346
26347         CSR_WRITE_4(sc, RE_MCUACCESS, TmpUlong);
26348 }
26349
26350 u_int16_t MP_ReadMcuAccessRegWord(
26351         struct re_softc *sc,
26352         u_int16_t ExtRegAddr)
26353 {
26354         u_int32_t TmpUlong;
26355         u_int16_t RetVal = 0xffff;
26356
26357         TmpUlong = ExtRegAddr / 2;
26358         TmpUlong <<= 16;
26359
26360         CSR_WRITE_4(sc, RE_MCUACCESS, TmpUlong);
26361         TmpUlong = CSR_READ_4(sc, RE_MCUACCESS);
26362         RetVal = (u_int16_t)TmpUlong;
26363
26364         return RetVal;
26365 }
26366
26367 static u_int32_t real_ocp_read(struct re_softc *sc, u_int16_t addr, u_int8_t len)
26368 {
26369         int i, val_shift, shift = 0;
26370         u_int32_t value1 = 0, value2 = 0, mask;
26371
26372         if (len > 4 || len <= 0)
26373                 return -1;
26374
26375         while (len > 0) {
26376                 val_shift = addr % 4;
26377                 addr = addr & ~0x3;
26378
26379                 CSR_WRITE_4(sc, RE_OCPAR, (0x0F<<12) | (addr&0xFFF));
26380
26381                 for (i = 0; i < 20; i++) {
26382                         DELAY(100);
26383                         if (CSR_READ_4(sc, RE_OCPAR) & OCPAR_Flag)
26384                                 break;
26385                 }
26386
26387                 if (len == 1)       mask = (0xFF << (val_shift * 8)) & 0xFFFFFFFF;
26388                 else if (len == 2)  mask = (0xFFFF << (val_shift * 8)) & 0xFFFFFFFF;
26389                 else if (len == 3)  mask = (0xFFFFFF << (val_shift * 8)) & 0xFFFFFFFF;
26390                 else            mask = (0xFFFFFFFF << (val_shift * 8)) & 0xFFFFFFFF;
26391
26392                 value1 = CSR_READ_4(sc, RE_OCPDR) & mask;
26393                 value2 |= (value1 >> val_shift * 8) << shift * 8;
26394
26395                 if (len <= 4 - val_shift) {
26396                         len = 0;
26397                 } else {
26398                         len -= (4 - val_shift);
26399                         shift = 4 - val_shift;
26400                         addr += 4;
26401                 }
26402         }
26403
26404         DELAY(20);
26405
26406         return value2;
26407 }
26408
26409 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)
26410 {
26411         return re_eri_read_with_oob_base_address(sc, addr, len, ERIAR_OOB, base_address);
26412 }
26413
26414 static u_int32_t OCP_read(struct re_softc *sc, u_int16_t addr, u_int8_t len)
26415 {
26416         u_int32_t value = 0;
26417
26418         if (HW_DASH_SUPPORT_TYPE_2(sc))
26419                 value = re_eri_read(sc, addr, len, ERIAR_OOB);
26420         else if (HW_DASH_SUPPORT_TYPE_3(sc))
26421                 value = OCP_read_with_oob_base_address(sc, addr, len, RTL8168FP_OOBMAC_BASE);
26422         else
26423                 value = real_ocp_read(sc, addr, len);
26424
26425         return value;
26426 }
26427
26428 static int real_ocp_write(struct re_softc *sc, u_int16_t addr, u_int8_t len, u_int32_t value)
26429 {
26430         int i, val_shift, shift = 0;
26431         u_int32_t value1 = 0, mask;
26432
26433         if (len > 4 || len <= 0)
26434                 return -1;
26435
26436         while (len > 0) {
26437                 val_shift = addr % 4;
26438                 addr = addr & ~0x3;
26439
26440                 if (len == 1)       mask = (0xFF << (val_shift * 8)) & 0xFFFFFFFF;
26441                 else if (len == 2)  mask = (0xFFFF << (val_shift * 8)) & 0xFFFFFFFF;
26442                 else if (len == 3)  mask = (0xFFFFFF << (val_shift * 8)) & 0xFFFFFFFF;
26443                 else            mask = (0xFFFFFFFF << (val_shift * 8)) & 0xFFFFFFFF;
26444
26445                 value1 = OCP_read(sc, addr, 4) & ~mask;
26446                 value1 |= ((value << val_shift * 8) >> shift * 8);
26447
26448                 CSR_WRITE_4(sc, RE_OCPDR, value1);
26449                 CSR_WRITE_4(sc, RE_OCPAR, OCPAR_Flag | (0x0F<<12) | (addr&0xFFF));
26450
26451                 for (i = 0; i < 10; i++) {
26452                         DELAY(100);
26453
26454                         /* Check if the RTL8168 has completed ERI write */
26455                         if (!(CSR_READ_4(sc, RE_OCPAR) & OCPAR_Flag))
26456                                 break;
26457                 }
26458
26459                 if (len <= 4 - val_shift) {
26460                         len = 0;
26461                 } else {
26462                         len -= (4 - val_shift);
26463                         shift = 4 - val_shift;
26464                         addr += 4;
26465                 }
26466         }
26467
26468         DELAY(20);
26469
26470         return 0;
26471 }
26472
26473 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)
26474 {
26475         return re_eri_write_with_oob_base_address(sc, addr, len, value, ERIAR_OOB, base_address);
26476 }
26477
26478 static void OCP_write(struct re_softc *sc, u_int16_t addr, u_int8_t len, u_int32_t value)
26479 {
26480         if (HW_DASH_SUPPORT_TYPE_2(sc))
26481                 re_eri_write(sc, addr, len, value, ERIAR_OOB);
26482         else if (HW_DASH_SUPPORT_TYPE_3(sc))
26483                 OCP_write_with_oob_base_address(sc, addr, len, value, RTL8168FP_OOBMAC_BASE);
26484         else
26485                 real_ocp_write(sc, addr, len, value);
26486 }
26487
26488 static void OOB_mutex_lock(struct re_softc *sc)
26489 {
26490         u_int8_t reg_16, reg_a0;
26491         u_int32_t wait_cnt_0, wait_Cnt_1;
26492         u_int16_t ocp_reg_mutex_ib;
26493         u_int16_t ocp_reg_mutex_oob;
26494         u_int16_t ocp_reg_mutex_prio;
26495
26496         switch (sc->re_type) {
26497         case MACFG_63:
26498         case MACFG_64:
26499         case MACFG_65:
26500                 ocp_reg_mutex_oob = 0x16;
26501                 ocp_reg_mutex_ib = 0x17;
26502                 ocp_reg_mutex_prio = 0x9C;
26503                 break;
26504         case MACFG_66:
26505                 ocp_reg_mutex_oob = 0x06;
26506                 ocp_reg_mutex_ib = 0x07;
26507                 ocp_reg_mutex_prio = 0x9C;
26508                 break;
26509         case MACFG_61:
26510         case MACFG_62:
26511         case MACFG_67:
26512         case MACFG_70:
26513         case MACFG_71:
26514         default:
26515                 ocp_reg_mutex_oob = 0x110;
26516                 ocp_reg_mutex_ib = 0x114;
26517                 ocp_reg_mutex_prio = 0x11C;
26518                 break;
26519         }
26520
26521         OCP_write(sc, ocp_reg_mutex_ib, 1, BIT_0);
26522         reg_16 = OCP_read(sc, ocp_reg_mutex_oob, 1);
26523         wait_cnt_0 = 0;
26524         while(reg_16) {
26525                 reg_a0 = OCP_read(sc, ocp_reg_mutex_prio, 1);
26526                 if (reg_a0) {
26527                         OCP_write(sc, ocp_reg_mutex_ib, 1, 0x00);
26528                         reg_a0 = OCP_read(sc, ocp_reg_mutex_prio, 1);
26529                         wait_Cnt_1 = 0;
26530                         while(reg_a0) {
26531                                 reg_a0 = OCP_read(sc, ocp_reg_mutex_prio, 1);
26532
26533                                 wait_Cnt_1++;
26534
26535                                 if (wait_Cnt_1 > 2000)
26536                                         break;
26537                         };
26538                         OCP_write(sc, ocp_reg_mutex_ib, 1, BIT_0);
26539
26540                 }
26541                 reg_16 = OCP_read(sc, ocp_reg_mutex_oob, 1);
26542
26543                 wait_cnt_0++;
26544
26545                 if (wait_cnt_0 > 2000)
26546                         break;
26547         };
26548 }
26549
26550 static void OOB_mutex_unlock(struct re_softc *sc)
26551 {
26552         u_int16_t ocp_reg_mutex_ib;
26553         u_int16_t ocp_reg_mutex_oob;
26554         u_int16_t ocp_reg_mutex_prio;
26555
26556         switch (sc->re_type) {
26557         case MACFG_63:
26558         case MACFG_64:
26559         case MACFG_65:
26560                 ocp_reg_mutex_oob = 0x16;
26561                 ocp_reg_mutex_ib = 0x17;
26562                 ocp_reg_mutex_prio = 0x9C;
26563                 break;
26564         case MACFG_66:
26565                 ocp_reg_mutex_oob = 0x06;
26566                 ocp_reg_mutex_ib = 0x07;
26567                 ocp_reg_mutex_prio = 0x9C;
26568                 break;
26569         case MACFG_61:
26570         case MACFG_62:
26571         case MACFG_67:
26572         case MACFG_70:
26573         case MACFG_71:
26574         default:
26575                 ocp_reg_mutex_oob = 0x110;
26576                 ocp_reg_mutex_ib = 0x114;
26577                 ocp_reg_mutex_prio = 0x11C;
26578                 break;
26579         }
26580
26581         OCP_write(sc, ocp_reg_mutex_prio, 1, BIT_0);
26582         OCP_write(sc, ocp_reg_mutex_ib, 1, 0x00);
26583 }
26584
26585 static int re_check_dash(struct re_softc *sc)
26586 {
26587         switch(sc->re_type) {
26588         case MACFG_61:
26589         case MACFG_62:
26590         case MACFG_67:
26591         case MACFG_63:
26592         case MACFG_64:
26593         case MACFG_65:
26594         case MACFG_66:
26595         case MACFG_70:
26596         case MACFG_71:
26597                 if (HW_DASH_SUPPORT_TYPE_2(sc) || HW_DASH_SUPPORT_TYPE_3(sc)) {
26598                         if (OCP_read(sc, 0x128, 1) & BIT_0)
26599                                 return 1;
26600                         else
26601                                 return 0;
26602                 } else {
26603                         u_int32_t reg;
26604
26605                         if (sc->re_type == MACFG_66)
26606                                 reg = 0xb8;
26607                         else
26608                                 reg = 0x10;
26609
26610                         if (OCP_read(sc, reg, 2) & 0x00008000)
26611                                 return 1;
26612                         else
26613                                 return 0;
26614                 }
26615                 break;
26616         default:
26617                 return 0;
26618         }
26619 }
26620
26621 static void OOB_notify(struct re_softc *sc, u_int8_t cmd)
26622 {
26623         int i;
26624
26625         CSR_WRITE_1(sc, RE_ERIDR, cmd);
26626         CSR_WRITE_4(sc, RE_ERIAR, 0x800010E8);
26627         DELAY(2000);
26628         for (i = 0; i < 5; i++) {
26629                 DELAY(100);
26630                 if (!(CSR_READ_4(sc, RE_ERIAR) & ERIAR_Flag))
26631                         break;
26632         }
26633
26634         OCP_write(sc, 0x30, 1, 0x01);
26635 }
26636
26637 void re_driver_start(struct re_softc *sc)
26638 {
26639         if (HW_DASH_SUPPORT_TYPE_2(sc) || HW_DASH_SUPPORT_TYPE_3(sc)) {
26640                 u_int32_t tmp_value;
26641
26642                 if (!sc->re_dash)
26643                         return;
26644
26645                 OCP_write(sc, 0x180, 1, OOB_CMD_DRIVER_START);
26646                 tmp_value = OCP_read(sc, 0x30, 1);
26647                 tmp_value |= BIT_0;
26648                 OCP_write(sc, 0x30, 1, tmp_value);
26649         } else {
26650                 int timeout;
26651                 u_int32_t reg;
26652
26653                 if (sc->re_type == MACFG_66) {
26654                         CSR_WRITE_1(sc, RE_TwiCmdReg, CSR_READ_1(sc, RE_TwiCmdReg) | (BIT_7));
26655                 }
26656
26657                 OOB_notify(sc, OOB_CMD_DRIVER_START);
26658
26659                 if (sc->re_type == MACFG_66)
26660                         reg = 0xB8;
26661                 else
26662                         reg = 0x10;
26663
26664                 for (timeout = 0; timeout < 10; timeout++) {
26665                         DELAY(10000);
26666                         if (OCP_read(sc, reg, 2) & BIT_11)
26667                                 break;
26668                 }
26669         }
26670 }
26671
26672 void re_driver_stop(struct re_softc *sc)
26673 {
26674         if (HW_DASH_SUPPORT_TYPE_2(sc) || HW_DASH_SUPPORT_TYPE_3(sc)) {
26675                 u_int32_t tmp_value;
26676
26677                 if (!sc->re_dash)
26678                         return;
26679
26680                 Dash2DisableTxRx(sc);
26681
26682                 OCP_write(sc, 0x180, 1, OOB_CMD_DRIVER_STOP);
26683                 tmp_value = OCP_read(sc, 0x30, 1);
26684                 tmp_value |= BIT_0;
26685                 OCP_write(sc, 0x30, 1, tmp_value);
26686         } else {
26687                 int timeout;
26688                 u_int32_t reg;
26689
26690                 OOB_notify(sc, OOB_CMD_DRIVER_STOP);
26691
26692                 if (sc->re_type == MACFG_66)
26693                         reg = 0xB8;
26694                 else
26695                         reg = 0x10;
26696
26697                 for (timeout = 0; timeout < 10; timeout++) {
26698                         DELAY(10000);
26699                         if ((OCP_read(sc, reg, 4) & BIT_11) == 0)
26700                                 break;
26701                 }
26702
26703                 if (sc->re_type == MACFG_66) {
26704                         CSR_WRITE_1(sc, RE_TwiCmdReg, CSR_READ_1(sc, RE_TwiCmdReg) & ~(BIT_7));
26705                 }
26706         }
26707 }
26708
26709 /*----------------------------------------------------------------------------*/
26710 /*      8139 (CR9346) 9346 command register bits (offset 0x50, 1 byte)*/
26711 /*----------------------------------------------------------------------------*/
26712 #define CR9346_EEDO                             0x01                    /* 9346 data out*/
26713 #define CR9346_EEDI                             0x02                    /* 9346 data in*/
26714 #define CR9346_EESK                             0x04                    /* 9346 serial clock*/
26715 #define CR9346_EECS                             0x08                    /* 9346 chip select*/
26716 #define CR9346_EEM0                             0x40                    /* select 8139 operating mode*/
26717 #define CR9346_EEM1                             0x80                    /* 00: normal*/
26718 #define CR9346_CFGRW                    0xC0                    /* Config register write*/
26719 #define CR9346_NORM                     0x00
26720
26721 /*----------------------------------------------------------------------------*/
26722 /*      EEPROM bit definitions(EEPROM control register bits)*/
26723 /*----------------------------------------------------------------------------*/
26724 #define EN_TRNF                                 0x10                    /* Enable turnoff*/
26725 #define EEDO                                            CR9346_EEDO     /* EEPROM data out*/
26726 #define EEDI                                            CR9346_EEDI             /* EEPROM data in (set for writing data)*/
26727 #define EECS                                            CR9346_EECS             /* EEPROM chip select (1=high, 0=low)*/
26728 #define EESK                                            CR9346_EESK             /* EEPROM shift clock (1=high, 0=low)*/
26729
26730 /*----------------------------------------------------------------------------*/
26731 /*      EEPROM opcodes*/
26732 /*----------------------------------------------------------------------------*/
26733 #define EEPROM_READ_OPCODE      06
26734 #define EEPROM_WRITE_OPCODE     05
26735 #define EEPROM_ERASE_OPCODE     07
26736 #define EEPROM_EWEN_OPCODE      19                              /* Erase/write enable*/
26737 #define EEPROM_EWDS_OPCODE      16                              /* Erase/write disable*/
26738
26739 #define CLOCK_RATE                              50                              /* us*/
26740
26741 #define RaiseClock(_sc,_x)                              \
26742         (_x) = (_x) | EESK;                                     \
26743         CSR_WRITE_1((_sc), RE_EECMD, (_x));     \
26744         DELAY(CLOCK_RATE);
26745
26746 #define LowerClock(_sc,_x)                              \
26747         (_x) = (_x) & ~EESK;                                    \
26748         CSR_WRITE_1((_sc), RE_EECMD, (_x));     \
26749         DELAY(CLOCK_RATE);
26750
26751 /*
26752  * Shift out bit(s) to the EEPROM.
26753  */
26754 static void re_eeprom_ShiftOutBits(struct re_softc *sc, int data, int count)
26755 {
26756         u_int16_t x, mask;
26757
26758         mask = 0x01 << (count - 1);
26759         x = CSR_READ_1(sc, RE_EECMD);
26760
26761         x &= ~(EEDO | EEDI);
26762
26763         do {
26764                 x &= ~EEDI;
26765                 if (data & mask)
26766                         x |= EEDI;
26767
26768                 CSR_WRITE_1(sc, RE_EECMD, x);
26769                 DELAY(CLOCK_RATE);
26770                 RaiseClock(sc,x);
26771                 LowerClock(sc,x);
26772                 mask = mask >> 1;
26773         } while (mask);
26774
26775         x &= ~EEDI;
26776         CSR_WRITE_1(sc, RE_EECMD, x);
26777 }
26778
26779 /*
26780  * Shift in bit(s) from the EEPROM.
26781  */
26782 static u_int16_t re_eeprom_ShiftInBits(struct re_softc *sc)
26783 {
26784         u_int16_t x,d,i;
26785         x = CSR_READ_1(sc, RE_EECMD);
26786
26787         x &= ~(EEDO | EEDI);
26788         d = 0;
26789
26790         for (i=0; i<16; i++) {
26791                 d = d << 1;
26792                 RaiseClock(sc, x);
26793
26794                 x = CSR_READ_1(sc, RE_EECMD);
26795
26796                 x &= ~(EEDI);
26797                 if (x & EEDO)
26798                         d |= 1;
26799
26800                 LowerClock(sc, x);
26801         }
26802
26803         return d;
26804 }
26805
26806 /*
26807  * Clean up EEprom read/write setting
26808  */
26809 static void re_eeprom_EEpromCleanup(struct re_softc *sc)
26810 {
26811         u_int16_t x;
26812         x = CSR_READ_1(sc, RE_EECMD);
26813
26814         x &= ~(EECS | EEDI);
26815         CSR_WRITE_1(sc, RE_EECMD, x);
26816
26817         RaiseClock(sc, x);
26818         LowerClock(sc, x);
26819 }
26820
26821 /*
26822  * Read a word of data stored in the EEPROM at address 'addr.'
26823  */
26824 static void re_eeprom_getword(struct re_softc *sc, int addr, u_int16_t *dest)
26825 {
26826         u_int16_t x;
26827
26828         /* select EEPROM, reset bits, set EECS*/
26829         x = CSR_READ_1(sc, RE_EECMD);
26830
26831         x &= ~(EEDI | EEDO | EESK | CR9346_EEM0);
26832         x |= CR9346_EEM1 | EECS;
26833         CSR_WRITE_1(sc, RE_EECMD, x);
26834
26835         /* write the read opcode and register number in that order*/
26836         /* The opcode is 3bits in length, reg is 6 bits long*/
26837         re_eeprom_ShiftOutBits(sc, EEPROM_READ_OPCODE, 3);
26838
26839         if (CSR_READ_4(sc, RE_RXCFG) & RE_RXCFG_RX_9356SEL)
26840                 re_eeprom_ShiftOutBits(sc, addr,8);     /*93c56=8*/
26841         else
26842                 re_eeprom_ShiftOutBits(sc, addr,6);     /*93c46=6*/
26843
26844         /* Now read the data (16 bits) in from the selected EEPROM word*/
26845         *dest=re_eeprom_ShiftInBits(sc);
26846
26847         re_eeprom_EEpromCleanup(sc);
26848         return;
26849 }
26850
26851 /*
26852  * Read a sequence of words from the EEPROM.
26853  */
26854 static void re_read_eeprom(struct re_softc *sc, caddr_t dest, int off, int cnt, int swap)
26855 {
26856         int                     i;
26857         u_int16_t               word = 0, *ptr;
26858
26859         for (i = 0; i < cnt; i++) {
26860                 re_eeprom_getword(sc, off + i, &word);
26861                 ptr = (u_int16_t *)(dest + (i * 2));
26862                 if (swap)
26863                         *ptr = ntohs(word);
26864                 else
26865                         *ptr = word;
26866         }
26867
26868         return;
26869 }
26870
26871 #ifdef __DragonFly__
26872
26873 int
26874 rtl_check_mac_version(struct re_softc *sc)
26875 {
26876
26877         return (re_check_mac_version(sc));
26878 }
26879
26880 void
26881 rtl_init_software_variable(struct re_softc *sc)
26882 {
26883
26884         re_init_software_variable(sc);
26885 }
26886
26887 void
26888 rtl_exit_oob(struct re_softc *sc)
26889 {
26890
26891         re_exit_oob(sc);
26892 }
26893
26894 void
26895 rtl_hw_init(struct re_softc *sc)
26896 {
26897
26898         re_hw_init(sc);
26899 }
26900
26901 void
26902 rtl_reset(struct re_softc *sc)
26903 {
26904
26905         re_reset(sc);
26906 }
26907
26908 void
26909 rtl_get_hw_mac_address(struct re_softc *sc, u_int8_t *eaddr)
26910 {
26911
26912         re_get_hw_mac_address(sc, eaddr);
26913 }
26914
26915 void
26916 rtl_phy_power_up(struct re_softc *sc)
26917 {
26918
26919         re_phy_power_up(sc->dev);
26920 }
26921
26922 void
26923 rtl_hw_phy_config(struct re_softc *sc)
26924 {
26925
26926         re_hw_phy_config(sc);
26927 }
26928
26929 void
26930 rtl_clrwol(struct re_softc *sc)
26931 {
26932
26933         re_clrwol(sc);
26934 }
26935
26936 int
26937 rtl_ifmedia_upd(struct ifnet *ifp)
26938 {
26939
26940         return (re_ifmedia_upd(ifp));
26941 }
26942
26943 void
26944 rtl_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr)
26945 {
26946
26947         re_ifmedia_sts(ifp, ifmr);
26948 }
26949
26950 void
26951 rtl_stop(struct re_softc *sc)
26952 {
26953
26954         re_stop_rtl(sc);
26955 }
26956
26957 u_int8_t
26958 rtl_link_ok(struct re_softc *sc)
26959 {
26960
26961         return (re_link_ok(sc));
26962 }
26963
26964 void
26965 rtl_link_on_patch(struct re_softc *sc)
26966 {
26967
26968         re_link_on_patch(sc);
26969 }
26970
26971 void
26972 rtl_set_eaddr(struct re_softc *sc)
26973 {
26974
26975         re_init_unlock(sc);
26976 }
26977
26978 void
26979 rtl_hw_start(struct re_softc *sc)
26980 {
26981
26982         re_hw_start_unlock(sc);
26983 }
26984
26985 void
26986 rtl_set_rx_packet_filter(struct re_softc *sc)
26987 {
26988
26989         re_set_rx_packet_filter(sc);
26990 }
26991
26992 void
26993 rtl_hw_d3_para(struct re_softc *sc)
26994 {
26995
26996         re_hw_d3_para(sc);
26997 }
26998
26999 void
27000 rtl_phy_power_down(struct re_softc *sc)
27001 {
27002
27003         re_phy_power_down(sc->dev);
27004 }
27005
27006 void
27007 rtl_cmac_unmap(struct re_softc *sc)
27008 {
27009
27010         if (HW_DASH_SUPPORT_TYPE_3(sc) && sc->re_dash &&
27011             sc->re_mapped_cmac_handle != 0) {
27012                 bus_space_unmap(sc->re_cmac_tag, sc->re_mapped_cmac_handle,
27013                     RE_REGS_SIZE);
27014         }
27015 }
27016
27017 #endif  /* __DragonFly__ */