?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
re: Leverage Realtek driver's chip/PHY initialization/reset.
[dragonfly.git] / sys / dev / netif / re / re.c
blob021c26af858c791daf2299409486cec026d6059a
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.92 " __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
60 #include <net/if.h>
61 #include <net/if_arp.h>
62 #include <net/ethernet.h>
63 #include <net/if_dl.h>
64 #include <net/if_media.h>
65
66 #include <net/bpf.h>
67
68 #include <vm/vm.h> /* for vtophys */
69 #include <vm/pmap.h> /* for vtophys */
70 #include <machine/clock.h> /* for DELAY */
71
72 #include <machine/bus.h>
73 #include <machine/resource.h>
74 #include <sys/bus.h>
75 #include <sys/rman.h>
76 #include <sys/endian.h>
77
78 #include <dev/mii/mii.h>
79 #include <dev/re/if_rereg.h>
80
81 #if OS_VER < VERSION(5,3)
82 #include <pci/pcireg.h>
83 #include <pci/pcivar.h>
84 #include <machine/bus_pio.h>
85 #include <machine/bus_memio.h>
86 #else
87 #include <dev/pci/pcireg.h>
88 #include <dev/pci/pcivar.h>
89 #include <sys/module.h>
90 #endif
91
92 #if OS_VER > VERSION(5,9)
93 #include <sys/cdefs.h>
94 #include <sys/endian.h>
95 #include <net/if_types.h>
96 #include <net/if_vlan_var.h>
97 #endif
98 #else /* __DragonFly__ */
99
100 #include <sys/param.h>
101 #include <sys/bus.h>
102 #include <sys/endian.h>
103 #include <sys/kernel.h>
104 #include <sys/systm.h>
105
106 #include <net/ethernet.h>
107 #include <net/if.h>
108 #include <net/if_arp.h>
109 #include <net/if_dl.h>
110 #include <net/if_media.h>
111 #include <net/if_poll.h>
112 #include <net/vlan/if_vlan_var.h>
113
114 #include <bus/pci/pcireg.h>
115 #include <bus/pci/pcivar.h>
116
117 #include <dev/netif/mii_layer/mii.h>
118 #include <dev/netif/re/if_revar.h>
119 #include <dev/netif/re/re.h>
120 #include <dev/netif/re/re_dragonfly.h>
121
122 #define RE_LOCK(sc)
123 #define RE_UNLOCK(sc)
124 #define RE_LOCK_ASSERT(sc)
125
126 #define RE_GET_IFNET(sc) &(sc)->arpcom.ac_if
127
128 #endif /* !__DragonFly__ */
129
130 #define EE_SET(x) \
131 CSR_WRITE_1(sc, RE_EECMD, \
132 CSR_READ_1(sc, RE_EECMD) | x)
133
134 #define EE_CLR(x) \
135 CSR_WRITE_1(sc, RE_EECMD, \
136 CSR_READ_1(sc, RE_EECMD) & ~x)
137
138 #ifndef __DragonFly__
139 /*
140 * Various supported device vendors/types and their names.
141 */
142 static struct re_type re_devs[] = {
143 {
144 RT_VENDORID, RT_DEVICEID_8169,
145 "Realtek PCI GBE Family Controller"
146 },
147 {
148 RT_VENDORID, RT_DEVICEID_8169SC,
149 "Realtek PCI GBE Family Controller"
150 },
151 {
152 RT_VENDORID, RT_DEVICEID_8168,
153 "Realtek PCIe GBE Family Controller"
154 },
155 {
156 RT_VENDORID, RT_DEVICEID_8161,
157 "Realtek PCIe GBE Family Controller"
158 },
159 {
160 RT_VENDORID, RT_DEVICEID_8136,
161 "Realtek PCIe FE Family Controller"
162 },
163 {
164 DLINK_VENDORID, 0x4300,
165 "Realtek PCI GBE Family Controller"
166 },
167 { 0, 0, NULL }
168 };
169
170 static int re_probe __P((device_t));
171 static int re_attach __P((device_t));
172 static int re_detach __P((device_t));
173 static int re_suspend __P((device_t));
174 static int re_resume __P((device_t));
175 static int re_shutdown __P((device_t));
176
177 static void MP_WritePhyUshort __P((struct re_softc*, u_int8_t, u_int16_t));
178 static u_int16_t MP_ReadPhyUshort __P((struct re_softc*, u_int8_t));
179 static void MP_WriteEPhyUshort __P((struct re_softc*, u_int8_t, u_int16_t));
180 static u_int16_t MP_ReadEPhyUshort __P((struct re_softc*, u_int8_t));
181 static u_int8_t MP_ReadEfuse __P((struct re_softc*, u_int16_t));
182 static void MP_WritePhyOcpRegWord __P((struct re_softc*, u_int16_t, u_int8_t, u_int16_t));
183 static u_int16_t MP_ReadPhyOcpRegWord __P((struct re_softc*, u_int16_t, u_int8_t));
184 static void MP_WriteMcuAccessRegWord __P((struct re_softc*, u_int16_t, u_int16_t));
185 static u_int16_t MP_ReadMcuAccessRegWord __P((struct re_softc*, u_int16_t));
186 static void MP_WritePciEConfigSpace __P((struct re_softc*, u_int16_t, u_int32_t));
187 static u_int32_t MP_ReadPciEConfigSpace __P((struct re_softc*, u_int16_t));
188
189 static int re_check_dash __P((struct re_softc *));
190
191 static void re_driver_start __P((struct re_softc*));
192 static void re_driver_stop __P((struct re_softc*));
193
194 static void re_hw_phy_config __P((struct re_softc *));
195 static void re_init __P((void *));
196 static int re_var_init __P((struct re_softc *));
197 static void re_reset __P((struct re_softc *));
198 static void re_stop __P((struct re_softc *));
199 static void re_setwol __P((struct re_softc *));
200 #endif /* !__DragonFly__ */
201 static void re_clrwol __P((struct re_softc *));
202 #ifndef __DragonFly__
203 static void re_set_wol_linkspeed __P((struct re_softc *));
204
205 static void re_start __P((struct ifnet *));
206 static int re_encap __P((struct re_softc *, struct mbuf *));
207 static void WritePacket __P((struct re_softc *, caddr_t, int, int, int, uint32_t, uint32_t));
208 static int CountFreeTxDescNum __P((struct re_descriptor));
209 static int CountMbufNum __P((struct mbuf *));
210 #ifdef RE_FIXUP_RX
211 static __inline void re_fixup_rx __P((struct mbuf *));
212 #endif
213 static void re_txeof __P((struct re_softc *));
214
215 static void re_rxeof __P((struct re_softc *));
216
217 #if OS_VER < VERSION(7,0)
218 static void re_intr __P((void *));
219 #else
220 static int re_intr __P((void *));
221 #endif //OS_VER < VERSION(7,0)
222 #endif /* !__DragonFly__ */
223 static void re_set_multicast_reg __P((struct re_softc *, u_int32_t, u_int32_t));
224 #ifndef __DragonFly__
225 static void re_set_rx_packet_filter_in_sleep_state __P((struct re_softc *));
226 #endif
227 static void re_set_rx_packet_filter __P((struct re_softc *));
228 static void re_setmulti __P((struct re_softc *));
229 #ifndef __DragonFly__
230 static int re_ioctl __P((struct ifnet *, u_long, caddr_t));
231 #endif
232 static u_int8_t re_link_ok __P((struct re_softc *));
233 static void re_link_on_patch __P((struct re_softc *));
234 #ifndef __DragonFly__
235 static void re_link_down_patch __P((struct re_softc *));
236 static void re_init_timer __P((struct re_softc *));
237 static void re_stop_timer __P((struct re_softc *));
238 static void re_start_timer __P((struct re_softc *));
239 static void re_tick __P((void *));
240 #if OS_VER < VERSION(7,0)
241 static void re_watchdog __P((struct ifnet *));
242 #endif
243 #endif /* !__DragonFly__ */
244
245 static int re_ifmedia_upd __P((struct ifnet *));
246 static void re_ifmedia_sts __P((struct ifnet *, struct ifmediareq *));
247
248 static void re_eeprom_ShiftOutBits __P((struct re_softc *, int, int));
249 static u_int16_t re_eeprom_ShiftInBits __P((struct re_softc *));
250 static void re_eeprom_EEpromCleanup __P((struct re_softc *));
251 static void re_eeprom_getword __P((struct re_softc *, int, u_int16_t *));
252 static void re_read_eeprom __P((struct re_softc *, caddr_t, int, int, int));
253 #ifndef __DragonFly__
254 static void re_int_task (void *, int);
255 #endif /* !__DragonFly__ */
256
257 static void re_phy_power_up(device_t dev);
258 static void re_phy_power_down(device_t dev);
259 #ifndef __DragonFly__
260 static int re_alloc_buf(struct re_softc *);
261 static void re_release_buf(struct re_softc *);
262 static void set_rxbufsize(struct re_softc*);
263 static void re_release_rx_buf(struct re_softc *);
264 static void re_release_tx_buf(struct re_softc *);
265 #endif /* !__DragonFly__ */
266 static u_int32_t re_eri_read(struct re_softc *, int , int , int);
267 static int re_eri_write(struct re_softc *, int , int , u_int32_t, int);
268 static void OOB_mutex_lock(struct re_softc *);
269 static void OOB_mutex_unlock(struct re_softc *);
270
271 #ifdef __DragonFly__
272 u_int16_t MP_ReadMcuAccessRegWord(struct re_softc *, u_int16_t);
273 void MP_WriteMcuAccessRegWord(struct re_softc *, u_int16_t, u_int16_t);
274
275 u_int16_t MP_ReadPhyOcpRegWord(struct re_softc *, u_int16_t, u_int8_t);
276 void MP_WritePhyOcpRegWord(struct re_softc *, u_int16_t, u_int8_t, u_int16_t);
277
278 void MP_WritePhyUshort(struct re_softc *, u_int8_t, u_int16_t);
279 u_int16_t MP_ReadPhyUshort(struct re_softc *, u_int8_t);
280
281 u_int32_t MP_ReadPciEConfigSpace(struct re_softc *, u_int16_t);
282 void MP_WritePciEConfigSpace(struct re_softc *, u_int16_t, u_int32_t);
283
284 u_int16_t MP_ReadEPhyUshort(struct re_softc *, u_int8_t);
285 void MP_WriteEPhyUshort(struct re_softc *, u_int8_t, u_int16_t);
286
287 u_int8_t MP_ReadEfuse(struct re_softc *, u_int16_t);
288
289 void re_driver_start(struct re_softc *);
290 void re_driver_stop(struct re_softc *);
291 #endif /* __DragonFly__ */
292
293 /* Tunables. */
294 static int msi_disable = 1;
295 TUNABLE_INT("hw.re.msi_disable", &msi_disable);
296 static int msix_disable = 0;
297 TUNABLE_INT("hw.re.msix_disable", &msix_disable);
298 static int prefer_iomap = 0;
299 TUNABLE_INT("hw.re.prefer_iomap", &prefer_iomap);
300 static int eee_enable = 0;
301 TUNABLE_INT("hw.re.eee_enable", &eee_enable);
302 static int phy_power_saving = 1;
303 TUNABLE_INT("hw.re.phy_power_saving", &phy_power_saving);
304 static int phy_mdix_mode = RE_ETH_PHY_AUTO_MDI_MDIX;
305 TUNABLE_INT("hw.re.phy_mdix_mode", &phy_power_saving);
306
307 #define RE_CSUM_FEATURES (CSUM_IP | CSUM_TCP | CSUM_UDP)
308
309 #ifndef __DragonFly__
310 static device_method_t re_methods[] = {
311 /* Device interface */
312 DEVMETHOD(device_probe, re_probe),
313 DEVMETHOD(device_attach, re_attach),
314 DEVMETHOD(device_detach, re_detach),
315 DEVMETHOD(device_suspend, re_suspend),
316 DEVMETHOD(device_resume, re_resume),
317 DEVMETHOD(device_shutdown, re_shutdown),
318 { 0, 0 }
319 };
320
321 static driver_t re_driver = {
322 "re",
323 re_methods,
324 sizeof(struct re_softc)
325 };
326
327 static devclass_t re_devclass;
328
329 DRIVER_MODULE(if_re, pci, re_driver, re_devclass, 0, 0);
330 #endif /* !__DragonFly__ */
331
332 static int re_is_ups_resume(struct re_softc *sc)
333 {
334 return (MP_ReadMcuAccessRegWord(sc, 0xD408) & BIT_0);
335 }
336
337 static void re_clear_ups_resume_bit(struct re_softc *sc)
338 {
339 MP_WriteMcuAccessRegWord(sc, 0xD408, MP_ReadMcuAccessRegWord(sc, 0xD408) & ~(BIT_0));
340 }
341
342 static void re_wait_phy_ups_resume(struct re_softc *sc, u_int16_t PhyState)
343 {
344 u_int16_t TmpPhyState;
345 int i=0;
346
347 do {
348 TmpPhyState = MP_ReadPhyOcpRegWord(sc, 0x0A42, 0x10);
349 TmpPhyState &= 0x7;
350 DELAY(1000);
351 i++;
352 } while ((i < 100) && (TmpPhyState != 2));
353 }
354
355 static void re_phy_power_up(device_t dev)
356 {
357 struct re_softc *sc;
358 u_int8_t Data8;
359
360 sc = device_get_softc(dev);
361
362 if ((sc->re_if_flags & RL_FLAG_PHYWAKE_PM) != 0)
363 CSR_WRITE_1(sc, RE_PMCH, CSR_READ_1(sc, RE_PMCH) | (BIT_6|BIT_7));
364
365 MP_WritePhyUshort(sc, 0x1F, 0x0000);
366
367 switch (sc->re_type) {
368 case MACFG_4:
369 case MACFG_5:
370 case MACFG_6:
371 case MACFG_21:
372 case MACFG_22:
373 case MACFG_23:
374 case MACFG_24:
375 case MACFG_25:
376 case MACFG_26:
377 case MACFG_27:
378 case MACFG_28:
379 case MACFG_31:
380 case MACFG_32:
381 case MACFG_33:
382 case MACFG_63:
383 case MACFG_64:
384 case MACFG_65:
385 case MACFG_66:
386 MP_WritePhyUshort(sc, 0x0e, 0x0000);
387 break;
388 case MACFG_56:
389 case MACFG_57:
390 case MACFG_58:
391 case MACFG_61:
392 Data8 = re_eri_read(sc, 0x1AB, 1, ERIAR_ExGMAC);
393 Data8 |= (BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
394 re_eri_write(sc, 0x1AB, 1, Data8, ERIAR_ExGMAC);
395 break;
396 default:
397 break;
398 };
399
400
401 MP_WritePhyUshort(sc, MII_BMCR, BMCR_AUTOEN);
402
403 //wait mdc/mdio ready
404 switch(sc->re_type) {
405 case MACFG_61:
406 case MACFG_62:
407 case MACFG_67:
408 DELAY(10000);
409 break;
410 }
411
412 //wait ups resume (phy state 3)
413 switch(sc->re_type) {
414 case MACFG_68:
415 case MACFG_69:
416 re_wait_phy_ups_resume(sc, 3);
417 break;
418 };
419 }
420
421 static void re_phy_power_down(device_t dev)
422 {
423 struct re_softc *sc;
424 u_int8_t Data8;
425
426 sc = device_get_softc(dev);
427
428 MP_WritePhyUshort(sc, 0x1F, 0x0000);
429
430 switch (sc->re_type) {
431 case MACFG_21:
432 case MACFG_22:
433 case MACFG_23:
434 case MACFG_24:
435 case MACFG_25:
436 case MACFG_26:
437 case MACFG_27:
438 case MACFG_28:
439 case MACFG_31:
440 case MACFG_32:
441 case MACFG_33:
442 case MACFG_63:
443 case MACFG_64:
444 case MACFG_65:
445 case MACFG_66:
446 MP_WritePhyUshort(sc, 0x0e, 0x0200);
447 MP_WritePhyUshort(sc, MII_BMCR, (BMCR_AUTOEN|BMCR_PDOWN));
448 break;
449 case MACFG_56:
450 case MACFG_57:
451 case MACFG_58:
452 case MACFG_61:
453 Data8 = re_eri_read(sc, 0x1AB, 1, ERIAR_ExGMAC);
454 Data8 &= ~(BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
455 re_eri_write(sc, 0x1AB, 1, Data8, ERIAR_ExGMAC);
456
457 MP_WritePhyUshort(sc, MII_BMCR, (BMCR_AUTOEN|BMCR_PDOWN));
458 break;
459 default:
460 MP_WritePhyUshort(sc, MII_BMCR, (BMCR_AUTOEN|BMCR_PDOWN));
461 break;
462 }
463
464 switch (sc->re_type) {
465 case MACFG_56:
466 case MACFG_57:
467 CSR_WRITE_1(sc, 0xD0, CSR_READ_1(sc, 0xD0) & ~BIT_6);
468 break;
469 }
470
471 switch (sc->re_type) {
472 case MACFG_68:
473 case MACFG_69:
474 CSR_WRITE_1(sc, 0xD0, CSR_READ_1(sc, 0xD0) & ~BIT_6);
475 CSR_WRITE_1(sc, 0xF2, CSR_READ_1(sc, 0xF2) & ~BIT_6);
476 break;
477 }
478
479 if ((sc->re_if_flags & RL_FLAG_PHYWAKE_PM) != 0)
480 CSR_WRITE_1(sc, RE_PMCH, CSR_READ_1(sc, RE_PMCH) & ~(BIT_6|BIT_7));
481 }
482
483 #ifndef __DragonFly__
484 static void re_tx_dma_map_buf(void *arg, bus_dma_segment_t *segs, int nseg, int error)
485 {
486 union TxDesc *txptr = arg;
487
488 if (error) {
489 txptr->ul[0] &= ~htole32(RL_TDESC_CMD_BUFLEN);
490 txptr->so1.TxBuffL = 0;
491 txptr->so1.TxBuffH = 0;
492 return;
493 }
494
495 txptr->so1.TxBuffL = htole32(RL_ADDR_LO(segs->ds_addr));
496 txptr->so1.TxBuffH = htole32(RL_ADDR_HI(segs->ds_addr));
497 }
498
499 static void re_rx_dma_map_buf(void *arg, bus_dma_segment_t *segs, int nseg, int error)
500 {
501 union RxDesc *rxptr = arg;
502
503 if (error) {
504 rxptr->ul[0] &= ~htole32(RL_RDESC_CMD_BUFLEN);
505 rxptr->so0.RxBuffL = 0;
506 rxptr->so0.RxBuffH = 0;
507 return;
508 }
509
510 rxptr->so0.RxBuffL = htole32(RL_ADDR_LO(segs->ds_addr));
511 rxptr->so0.RxBuffH = htole32(RL_ADDR_HI(segs->ds_addr));
512 }
513
514 static void re_dma_map_rxdesc(void *arg, bus_dma_segment_t *segs, int nseg, int error)
515 {
516 struct re_softc *sc = arg;
517
518
519 if (error)
520 return;
521
522 CSR_WRITE_4(sc, 0xe4, RL_ADDR_LO(segs->ds_addr));
523 CSR_WRITE_4(sc, 0xe8, RL_ADDR_HI(segs->ds_addr));
524 }
525
526 static void re_dma_map_txdesc(void *arg, bus_dma_segment_t *segs, int nseg, int error)
527 {
528 struct re_softc *sc = arg;
529
530
531 if (error)
532 return;
533
534 CSR_WRITE_4(sc, 0x20, RL_ADDR_LO(segs->ds_addr));
535 CSR_WRITE_4(sc, 0x24, RL_ADDR_HI(segs->ds_addr));
536 }
537
538 /*
539 * Probe for a RealTek 8129/8139 chip. Check the PCI vendor and device
540 * IDs against our list and return a device name if we find a match.
541 */
542 static int re_probe(dev) /* Search for Realtek NIC chip */
543 device_t dev;
544 {
545 struct re_type *t;
546 t = re_devs;
547 while (t->re_name != NULL) {
548 if ((pci_get_vendor(dev) == t->re_vid) &&
549 (pci_get_device(dev) == t->re_did)) {
550 device_set_desc(dev, t->re_name);
551 return(0);
552 }
553 t++;
554 }
555
556 return(ENXIO);
557 }
558 #endif /* !__DragonFly__ */
559
560
561 static u_int32_t re_eri_read(struct re_softc *sc, int addr, int len, int type)
562 {
563 int i, val_shift, shift = 0;
564 u_int32_t value1 = 0, value2 = 0, mask;
565
566 if (len > 4 || len <= 0)
567 return -1;
568
569 while (len > 0) {
570 val_shift = addr % ERIAR_Addr_Align;
571 addr = addr & ~0x3;
572
573 CSR_WRITE_4(sc,RE_ERIAR,
574 ERIAR_Read |
575 type << ERIAR_Type_shift |
576 ERIAR_ByteEn << ERIAR_ByteEn_shift |
577 addr);
578
579 for (i = 0; i < 10; i++) {
580 DELAY(100);
581
582 /* Check if the RTL8168 has completed ERI read */
583 if (CSR_READ_4(sc,RE_ERIAR) & ERIAR_Flag)
584 break;
585 }
586
587 if (len == 1) mask = (0xFF << (val_shift * 8)) & 0xFFFFFFFF;
588 else if (len == 2) mask = (0xFFFF << (val_shift * 8)) & 0xFFFFFFFF;
589 else if (len == 3) mask = (0xFFFFFF << (val_shift * 8)) & 0xFFFFFFFF;
590 else mask = (0xFFFFFFFF << (val_shift * 8)) & 0xFFFFFFFF;
591
592 value1 = CSR_READ_4(sc,RE_ERIDR) & mask;
593 value2 |= (value1 >> val_shift * 8) << shift * 8;
594
595 if (len <= 4 - val_shift)
596 len = 0;
597 else {
598 len -= (4 - val_shift);
599 shift = 4 - val_shift;
600 addr += 4;
601 }
602 }
603
604 return value2;
605 }
606
607 static int re_eri_write(struct re_softc *sc, int addr, int len, u_int32_t value, int type)
608 {
609
610 int i, val_shift, shift = 0;
611 u_int32_t value1 = 0, mask;
612
613 if (len > 4 || len <= 0)
614 return -1;
615
616 while (len > 0) {
617 val_shift = addr % ERIAR_Addr_Align;
618 addr = addr & ~0x3;
619
620 if (len == 1) mask = (0xFF << (val_shift * 8)) & 0xFFFFFFFF;
621 else if (len == 2) mask = (0xFFFF << (val_shift * 8)) & 0xFFFFFFFF;
622 else if (len == 3) mask = (0xFFFFFF << (val_shift * 8)) & 0xFFFFFFFF;
623 else mask = (0xFFFFFFFF << (val_shift * 8)) & 0xFFFFFFFF;
624
625 value1 = re_eri_read(sc, addr, 4, type) & ~mask;
626 value1 |= ((value << val_shift * 8) >> shift * 8);
627
628 CSR_WRITE_4(sc,RE_ERIDR, value1);
629 CSR_WRITE_4(sc,RE_ERIAR,
630 ERIAR_Write |
631 type << ERIAR_Type_shift |
632 ERIAR_ByteEn << ERIAR_ByteEn_shift |
633 addr);
634
635 for (i = 0; i < 10; i++) {
636 DELAY(100);
637
638 /* Check if the RTL8168 has completed ERI write */
639 if (!(CSR_READ_4(sc,RE_ERIAR) & ERIAR_Flag))
640 break;
641 }
642
643 if (len <= 4 - val_shift)
644 len = 0;
645 else {
646 len -= (4 - val_shift);
647 shift = 4 - val_shift;
648 addr += 4;
649 }
650 }
651
652 return 0;
653 }
654
655 static void
656 ClearAndSetEthPhyBit(
657 struct re_softc *sc,
658 u_int8_t addr,
659 u_int16_t clearmask,
660 u_int16_t setmask
661 )
662 {
663 u_int16_t PhyRegValue;
664
665
666 PhyRegValue = MP_ReadPhyUshort(sc, addr);
667 PhyRegValue &= ~clearmask;
668 PhyRegValue |= setmask;
669 MP_WritePhyUshort(sc, addr, PhyRegValue);
670 }
671
672 static void
673 ClearEthPhyBit(
674 struct re_softc *sc,
675 u_int8_t addr,
676 u_int16_t mask
677 )
678 {
679 ClearAndSetEthPhyBit(sc,
680 addr,
681 mask,
682 0
683 );
684 }
685
686 static void
687 SetEthPhyBit(
688 struct re_softc *sc,
689 u_int8_t addr,
690 u_int16_t mask
691 )
692 {
693 ClearAndSetEthPhyBit(sc,
694 addr,
695 0,
696 mask
697 );
698 }
699
700 #ifndef __DragonFly__
701 static void re_release_rx_buf(struct re_softc *sc)
702 {
703 struct ifnet *ifp;
704 int i;
705 ifp = RE_GET_IFNET(sc);
706
707 if (sc->re_desc.re_rx_mtag) {
708 for (i = 0; i < RE_RX_BUF_NUM; i++) {
709 if (sc->re_desc.rx_buf[i]!=NULL) {
710 bus_dmamap_sync(sc->re_desc.re_rx_mtag,
711 sc->re_desc.re_rx_dmamap[i],
712 BUS_DMASYNC_POSTREAD);
713 bus_dmamap_unload(sc->re_desc.re_rx_mtag,
714 sc->re_desc.re_rx_dmamap[i]);
715 bus_dmamap_destroy(sc->re_desc.re_rx_mtag,
716 sc->re_desc.re_rx_dmamap[i]);
717 m_freem(sc->re_desc.rx_buf[i]);
718 sc->re_desc.rx_buf[i] =NULL;
719 }
720 }
721 bus_dma_tag_destroy(sc->re_desc.re_rx_mtag);
722 sc->re_desc.re_rx_mtag =0;
723 }
724
725 }
726 static void re_release_tx_buf(struct re_softc *sc)
727 {
728 struct ifnet *ifp;
729 int i;
730 ifp = RE_GET_IFNET(sc);
731
732 if (sc->re_desc.re_tx_mtag) {
733 for (i = 0; i < RE_TX_BUF_NUM; i++) {
734
735 bus_dmamap_destroy(sc->re_desc.re_tx_mtag,
736 sc->re_desc.re_tx_dmamap[i]);
737 m_freem(sc->re_desc.tx_buf[i]);
738
739 }
740 bus_dma_tag_destroy(sc->re_desc.re_tx_mtag);
741 sc->re_desc.re_tx_mtag = 0;
742 }
743
744
745 }
746 static void re_release_buf(struct re_softc *sc)
747 {
748 re_release_rx_buf(sc);
749 re_release_tx_buf(sc);
750 }
751
752
753
754 static int re_alloc_buf(struct re_softc *sc)
755 {
756 int error =0;
757 int i,size;
758
759 error = bus_dma_tag_create(sc->re_parent_tag, 1, 0,
760 BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR, NULL,
761 NULL, MCLBYTES* RE_NTXSEGS, RE_NTXSEGS, 4096, 0,
762 NULL, NULL, &sc->re_desc.re_tx_mtag);
763
764 if (error) {
765 //device_printf(dev,"re_tx_mtag fail\n");
766 //goto fail;
767 return error;
768 }
769
770 error = bus_dma_tag_create(
771 sc->re_parent_tag,
772 RE_RX_BUFFER_ALIGN, 0, /* alignment, boundary */
773 BUS_SPACE_MAXADDR, /* lowaddr */
774 BUS_SPACE_MAXADDR, /* highaddr */
775 NULL, NULL, /* filter, filterarg */
776 sc->re_rx_desc_buf_sz, 1, /* maxsize,nsegments */
777 sc->re_rx_desc_buf_sz, /* maxsegsize */
778 0, /* flags */
779 NULL, NULL, /* lockfunc, lockarg */
780 &sc->re_desc.re_rx_mtag);
781 if (error) {
782 //device_printf(dev,"re_rx_mtag fail\n");
783 //goto fail;
784 return error;
785 }
786
787 if (sc->re_rx_mbuf_sz <= MCLBYTES)
788 size = MCLBYTES;
789 else if (sc->re_rx_mbuf_sz <= MJUMPAGESIZE)
790 size = MJUMPAGESIZE;
791 else
792 size =MJUM9BYTES;
793 for (i = 0; i < RE_RX_BUF_NUM; i++) {
794 sc->re_desc.rx_buf[i] = m_getjcl(M_DONTWAIT, MT_DATA, M_PKTHDR, size);
795 if (!sc->re_desc.rx_buf[i]) {
796 //device_printf(dev, "m_getcl fail!!!\n");
797 error = ENXIO;
798 //goto fail;
799 return error;
800 }
801
802 sc->re_desc.rx_buf[i]->m_len = sc->re_desc.rx_buf[i]->m_pkthdr.len = size;
803 #ifdef RE_FIXUP_RX
804 /*
805 * This is part of an evil trick to deal with non-x86 platforms.
806 * The RealTek chip requires RX buffers to be aligned on 64-bit
807 * boundaries, but that will hose non-x86 machines. To get around
808 * this, we leave some empty space at the start of each buffer
809 * and for non-x86 hosts, we copy the buffer back six bytes
810 * to achieve word alignment. This is slightly more efficient
811 * than allocating a new buffer, copying the contents, and
812 * discarding the old buffer.
813 */
814 m_adj(sc->re_desc.rx_buf[i], RE_ETHER_ALIGN);
815 #endif
816
817 error = bus_dmamap_create(sc->re_desc.re_rx_mtag, BUS_DMA_NOWAIT, &sc->re_desc.re_rx_dmamap[i]);
818 if (error) {
819 //device_printf(dev, "bus_dmamap_create fail!!!\n");
820 //goto fail;
821 return error;
822 }
823 }
824
825 for (i = 0; i < RE_TX_BUF_NUM; i++) {
826 error = bus_dmamap_create(sc->re_desc.re_tx_mtag, BUS_DMA_NOWAIT, &sc->re_desc.re_tx_dmamap[i]);
827 if (error) {
828 //device_printf(dev, "bus_dmamap_create fail!!!\n");
829 //goto fail;
830 return error;
831 }
832 }
833
834 return 0;
835 }
836
837 static void set_rxbufsize(struct re_softc *sc)
838 {
839
840 //printf("set size\n");
841
842 struct ifnet *ifp;
843 ifp = RE_GET_IFNET(sc);
844 sc->re_rx_desc_buf_sz = (ifp->if_mtu > ETHERMTU) ? ifp->if_mtu: ETHERMTU;
845 sc->re_rx_desc_buf_sz += (ETHER_VLAN_ENCAP_LEN + ETHER_HDR_LEN + ETHER_CRC_LEN + 1);
846 CSR_WRITE_2(sc, RE_RxMaxSize, sc->re_rx_desc_buf_sz);
847 }
848 #endif /* !__DragonFly__ */
849
850 static void DisableMcuBPs(struct re_softc *sc)
851 {
852 switch(sc->re_type) {
853 case MACFG_56:
854 case MACFG_57:
855 case MACFG_58:
856 case MACFG_59:
857 case MACFG_60:
858 case MACFG_61:
859 case MACFG_62:
860 case MACFG_67:
861 case MACFG_68:
862 case MACFG_69:
863
864 MP_WriteMcuAccessRegWord(sc, 0xFC28, 0x0000);
865 MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x0000);
866 MP_WriteMcuAccessRegWord(sc, 0xFC2C, 0x0000);
867 MP_WriteMcuAccessRegWord(sc, 0xFC2E, 0x0000);
868 MP_WriteMcuAccessRegWord(sc, 0xFC30, 0x0000);
869 MP_WriteMcuAccessRegWord(sc, 0xFC32, 0x0000);
870 MP_WriteMcuAccessRegWord(sc, 0xFC34, 0x0000);
871 MP_WriteMcuAccessRegWord(sc, 0xFC36, 0x0000);
872
873 DELAY(3000);
874
875 MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x0000);
876 break;
877 }
878
879
880 }
881
882 static void re_hw_mac_mcu_config(struct re_softc *sc)
883 {
884 switch(sc->re_type) {
885 case MACFG_56:
886 MP_WriteMcuAccessRegWord(sc, 0xE43C, 0x0000);
887 MP_WriteMcuAccessRegWord(sc, 0xE43E, 0x0000);
888
889 MP_WriteMcuAccessRegWord(sc, 0xE434, 0x0004);
890 MP_WriteMcuAccessRegWord(sc, 0xE43C, 0x0004);
891
892 DisableMcuBPs(sc);
893
894 MP_WriteMcuAccessRegWord(sc, 0xF800, 0xE008);
895 MP_WriteMcuAccessRegWord(sc, 0xF802, 0xE01B);
896 MP_WriteMcuAccessRegWord(sc, 0xF804, 0xE022);
897 MP_WriteMcuAccessRegWord(sc, 0xF806, 0xE094);
898 MP_WriteMcuAccessRegWord(sc, 0xF808, 0xE097);
899 MP_WriteMcuAccessRegWord(sc, 0xF80A, 0xE09A);
900 MP_WriteMcuAccessRegWord(sc, 0xF80C, 0xE0B3);
901 MP_WriteMcuAccessRegWord(sc, 0xF80E, 0xE0BA);
902 MP_WriteMcuAccessRegWord(sc, 0xF810, 0x49D2);
903 MP_WriteMcuAccessRegWord(sc, 0xF812, 0xF10D);
904 MP_WriteMcuAccessRegWord(sc, 0xF814, 0x766C);
905 MP_WriteMcuAccessRegWord(sc, 0xF816, 0x49E2);
906 MP_WriteMcuAccessRegWord(sc, 0xF818, 0xF00A);
907 MP_WriteMcuAccessRegWord(sc, 0xF81A, 0x1EC0);
908 MP_WriteMcuAccessRegWord(sc, 0xF81C, 0x8EE1);
909 MP_WriteMcuAccessRegWord(sc, 0xF81E, 0xC60A);
910 MP_WriteMcuAccessRegWord(sc, 0xF820, 0x77C0);
911 MP_WriteMcuAccessRegWord(sc, 0xF822, 0x4870);
912 MP_WriteMcuAccessRegWord(sc, 0xF824, 0x9FC0);
913 MP_WriteMcuAccessRegWord(sc, 0xF826, 0x1EA0);
914 MP_WriteMcuAccessRegWord(sc, 0xF828, 0xC707);
915 MP_WriteMcuAccessRegWord(sc, 0xF82A, 0x8EE1);
916 MP_WriteMcuAccessRegWord(sc, 0xF82C, 0x9D6C);
917 MP_WriteMcuAccessRegWord(sc, 0xF82E, 0xC603);
918 MP_WriteMcuAccessRegWord(sc, 0xF830, 0xBE00);
919 MP_WriteMcuAccessRegWord(sc, 0xF832, 0xB416);
920 MP_WriteMcuAccessRegWord(sc, 0xF834, 0x0076);
921 MP_WriteMcuAccessRegWord(sc, 0xF836, 0xE86C);
922 MP_WriteMcuAccessRegWord(sc, 0xF838, 0xC406);
923 MP_WriteMcuAccessRegWord(sc, 0xF83A, 0x7580);
924 MP_WriteMcuAccessRegWord(sc, 0xF83C, 0x4852);
925 MP_WriteMcuAccessRegWord(sc, 0xF83E, 0x8D80);
926 MP_WriteMcuAccessRegWord(sc, 0xF840, 0xC403);
927 MP_WriteMcuAccessRegWord(sc, 0xF842, 0xBC00);
928 MP_WriteMcuAccessRegWord(sc, 0xF844, 0xD3E0);
929 MP_WriteMcuAccessRegWord(sc, 0xF846, 0x02C8);
930 MP_WriteMcuAccessRegWord(sc, 0xF848, 0x8918);
931 MP_WriteMcuAccessRegWord(sc, 0xF84A, 0xE815);
932 MP_WriteMcuAccessRegWord(sc, 0xF84C, 0x1100);
933 MP_WriteMcuAccessRegWord(sc, 0xF84E, 0xF011);
934 MP_WriteMcuAccessRegWord(sc, 0xF850, 0xE812);
935 MP_WriteMcuAccessRegWord(sc, 0xF852, 0x4990);
936 MP_WriteMcuAccessRegWord(sc, 0xF854, 0xF002);
937 MP_WriteMcuAccessRegWord(sc, 0xF856, 0xE817);
938 MP_WriteMcuAccessRegWord(sc, 0xF858, 0xE80E);
939 MP_WriteMcuAccessRegWord(sc, 0xF85A, 0x4992);
940 MP_WriteMcuAccessRegWord(sc, 0xF85C, 0xF002);
941 MP_WriteMcuAccessRegWord(sc, 0xF85E, 0xE80E);
942 MP_WriteMcuAccessRegWord(sc, 0xF860, 0xE80A);
943 MP_WriteMcuAccessRegWord(sc, 0xF862, 0x4993);
944 MP_WriteMcuAccessRegWord(sc, 0xF864, 0xF002);
945 MP_WriteMcuAccessRegWord(sc, 0xF866, 0xE818);
946 MP_WriteMcuAccessRegWord(sc, 0xF868, 0xE806);
947 MP_WriteMcuAccessRegWord(sc, 0xF86A, 0x4991);
948 MP_WriteMcuAccessRegWord(sc, 0xF86C, 0xF002);
949 MP_WriteMcuAccessRegWord(sc, 0xF86E, 0xE838);
950 MP_WriteMcuAccessRegWord(sc, 0xF870, 0xC25E);
951 MP_WriteMcuAccessRegWord(sc, 0xF872, 0xBA00);
952 MP_WriteMcuAccessRegWord(sc, 0xF874, 0xC056);
953 MP_WriteMcuAccessRegWord(sc, 0xF876, 0x7100);
954 MP_WriteMcuAccessRegWord(sc, 0xF878, 0xFF80);
955 MP_WriteMcuAccessRegWord(sc, 0xF87A, 0x7100);
956 MP_WriteMcuAccessRegWord(sc, 0xF87C, 0x4892);
957 MP_WriteMcuAccessRegWord(sc, 0xF87E, 0x4813);
958 MP_WriteMcuAccessRegWord(sc, 0xF880, 0x8900);
959 MP_WriteMcuAccessRegWord(sc, 0xF882, 0xE00A);
960 MP_WriteMcuAccessRegWord(sc, 0xF884, 0x7100);
961 MP_WriteMcuAccessRegWord(sc, 0xF886, 0x4890);
962 MP_WriteMcuAccessRegWord(sc, 0xF888, 0x4813);
963 MP_WriteMcuAccessRegWord(sc, 0xF88A, 0x8900);
964 MP_WriteMcuAccessRegWord(sc, 0xF88C, 0xC74B);
965 MP_WriteMcuAccessRegWord(sc, 0xF88E, 0x74F8);
966 MP_WriteMcuAccessRegWord(sc, 0xF890, 0x48C2);
967 MP_WriteMcuAccessRegWord(sc, 0xF892, 0x4841);
968 MP_WriteMcuAccessRegWord(sc, 0xF894, 0x8CF8);
969 MP_WriteMcuAccessRegWord(sc, 0xF896, 0xC746);
970 MP_WriteMcuAccessRegWord(sc, 0xF898, 0x74FC);
971 MP_WriteMcuAccessRegWord(sc, 0xF89A, 0x49C0);
972 MP_WriteMcuAccessRegWord(sc, 0xF89C, 0xF120);
973 MP_WriteMcuAccessRegWord(sc, 0xF89E, 0x49C1);
974 MP_WriteMcuAccessRegWord(sc, 0xF8A0, 0xF11E);
975 MP_WriteMcuAccessRegWord(sc, 0xF8A2, 0x74F8);
976 MP_WriteMcuAccessRegWord(sc, 0xF8A4, 0x49C0);
977 MP_WriteMcuAccessRegWord(sc, 0xF8A6, 0xF01B);
978 MP_WriteMcuAccessRegWord(sc, 0xF8A8, 0x49C6);
979 MP_WriteMcuAccessRegWord(sc, 0xF8AA, 0xF119);
980 MP_WriteMcuAccessRegWord(sc, 0xF8AC, 0x74F8);
981 MP_WriteMcuAccessRegWord(sc, 0xF8AE, 0x49C4);
982 MP_WriteMcuAccessRegWord(sc, 0xF8B0, 0xF013);
983 MP_WriteMcuAccessRegWord(sc, 0xF8B2, 0xC536);
984 MP_WriteMcuAccessRegWord(sc, 0xF8B4, 0x74B0);
985 MP_WriteMcuAccessRegWord(sc, 0xF8B6, 0x49C1);
986 MP_WriteMcuAccessRegWord(sc, 0xF8B8, 0xF1FD);
987 MP_WriteMcuAccessRegWord(sc, 0xF8BA, 0xC537);
988 MP_WriteMcuAccessRegWord(sc, 0xF8BC, 0xC434);
989 MP_WriteMcuAccessRegWord(sc, 0xF8BE, 0x9CA0);
990 MP_WriteMcuAccessRegWord(sc, 0xF8C0, 0xC435);
991 MP_WriteMcuAccessRegWord(sc, 0xF8C2, 0x1C13);
992 MP_WriteMcuAccessRegWord(sc, 0xF8C4, 0x484F);
993 MP_WriteMcuAccessRegWord(sc, 0xF8C6, 0x9CA2);
994 MP_WriteMcuAccessRegWord(sc, 0xF8C8, 0xC52B);
995 MP_WriteMcuAccessRegWord(sc, 0xF8CA, 0x74B0);
996 MP_WriteMcuAccessRegWord(sc, 0xF8CC, 0x49C1);
997 MP_WriteMcuAccessRegWord(sc, 0xF8CE, 0xF1FD);
998 MP_WriteMcuAccessRegWord(sc, 0xF8D0, 0x74F8);
999 MP_WriteMcuAccessRegWord(sc, 0xF8D2, 0x48C4);
1000 MP_WriteMcuAccessRegWord(sc, 0xF8D4, 0x8CF8);
1001 MP_WriteMcuAccessRegWord(sc, 0xF8D6, 0x7100);
1002 MP_WriteMcuAccessRegWord(sc, 0xF8D8, 0x4893);
1003 MP_WriteMcuAccessRegWord(sc, 0xF8DA, 0x8900);
1004 MP_WriteMcuAccessRegWord(sc, 0xF8DC, 0xFF80);
1005 MP_WriteMcuAccessRegWord(sc, 0xF8DE, 0xC520);
1006 MP_WriteMcuAccessRegWord(sc, 0xF8E0, 0x74B0);
1007 MP_WriteMcuAccessRegWord(sc, 0xF8E2, 0x49C1);
1008 MP_WriteMcuAccessRegWord(sc, 0xF8E4, 0xF11C);
1009 MP_WriteMcuAccessRegWord(sc, 0xF8E6, 0xC71E);
1010 MP_WriteMcuAccessRegWord(sc, 0xF8E8, 0x74FC);
1011 MP_WriteMcuAccessRegWord(sc, 0xF8EA, 0x49C1);
1012 MP_WriteMcuAccessRegWord(sc, 0xF8EC, 0xF118);
1013 MP_WriteMcuAccessRegWord(sc, 0xF8EE, 0x49C0);
1014 MP_WriteMcuAccessRegWord(sc, 0xF8F0, 0xF116);
1015 MP_WriteMcuAccessRegWord(sc, 0xF8F2, 0x74F8);
1016 MP_WriteMcuAccessRegWord(sc, 0xF8F4, 0x49C0);
1017 MP_WriteMcuAccessRegWord(sc, 0xF8F6, 0xF013);
1018 MP_WriteMcuAccessRegWord(sc, 0xF8F8, 0x48C3);
1019 MP_WriteMcuAccessRegWord(sc, 0xF8FA, 0x8CF8);
1020 MP_WriteMcuAccessRegWord(sc, 0xF8FC, 0xC516);
1021 MP_WriteMcuAccessRegWord(sc, 0xF8FE, 0x74A2);
1022 MP_WriteMcuAccessRegWord(sc, 0xF900, 0x49CE);
1023 MP_WriteMcuAccessRegWord(sc, 0xF902, 0xF1FE);
1024 MP_WriteMcuAccessRegWord(sc, 0xF904, 0xC411);
1025 MP_WriteMcuAccessRegWord(sc, 0xF906, 0x9CA0);
1026 MP_WriteMcuAccessRegWord(sc, 0xF908, 0xC411);
1027 MP_WriteMcuAccessRegWord(sc, 0xF90A, 0x1C13);
1028 MP_WriteMcuAccessRegWord(sc, 0xF90C, 0x484F);
1029 MP_WriteMcuAccessRegWord(sc, 0xF90E, 0x9CA2);
1030 MP_WriteMcuAccessRegWord(sc, 0xF910, 0x74A2);
1031 MP_WriteMcuAccessRegWord(sc, 0xF912, 0x49CF);
1032 MP_WriteMcuAccessRegWord(sc, 0xF914, 0xF1FE);
1033 MP_WriteMcuAccessRegWord(sc, 0xF916, 0x7100);
1034 MP_WriteMcuAccessRegWord(sc, 0xF918, 0x4891);
1035 MP_WriteMcuAccessRegWord(sc, 0xF91A, 0x8900);
1036 MP_WriteMcuAccessRegWord(sc, 0xF91C, 0xFF80);
1037 MP_WriteMcuAccessRegWord(sc, 0xF91E, 0xE400);
1038 MP_WriteMcuAccessRegWord(sc, 0xF920, 0xD3E0);
1039 MP_WriteMcuAccessRegWord(sc, 0xF922, 0xE000);
1040 MP_WriteMcuAccessRegWord(sc, 0xF924, 0x0481);
1041 MP_WriteMcuAccessRegWord(sc, 0xF926, 0x0C81);
1042 MP_WriteMcuAccessRegWord(sc, 0xF928, 0xDE20);
1043 MP_WriteMcuAccessRegWord(sc, 0xF92A, 0x0000);
1044 MP_WriteMcuAccessRegWord(sc, 0xF92C, 0x0992);
1045 MP_WriteMcuAccessRegWord(sc, 0xF92E, 0x1B76);
1046 MP_WriteMcuAccessRegWord(sc, 0xF930, 0xC602);
1047 MP_WriteMcuAccessRegWord(sc, 0xF932, 0xBE00);
1048 MP_WriteMcuAccessRegWord(sc, 0xF934, 0x059C);
1049 MP_WriteMcuAccessRegWord(sc, 0xF936, 0x1B76);
1050 MP_WriteMcuAccessRegWord(sc, 0xF938, 0xC602);
1051 MP_WriteMcuAccessRegWord(sc, 0xF93A, 0xBE00);
1052 MP_WriteMcuAccessRegWord(sc, 0xF93C, 0x065A);
1053 MP_WriteMcuAccessRegWord(sc, 0xF93E, 0xB400);
1054 MP_WriteMcuAccessRegWord(sc, 0xF940, 0x18DE);
1055 MP_WriteMcuAccessRegWord(sc, 0xF942, 0x2008);
1056 MP_WriteMcuAccessRegWord(sc, 0xF944, 0x4001);
1057 MP_WriteMcuAccessRegWord(sc, 0xF946, 0xF10F);
1058 MP_WriteMcuAccessRegWord(sc, 0xF948, 0x7342);
1059 MP_WriteMcuAccessRegWord(sc, 0xF94A, 0x1880);
1060 MP_WriteMcuAccessRegWord(sc, 0xF94C, 0x2008);
1061 MP_WriteMcuAccessRegWord(sc, 0xF94E, 0x0009);
1062 MP_WriteMcuAccessRegWord(sc, 0xF950, 0x4018);
1063 MP_WriteMcuAccessRegWord(sc, 0xF952, 0xF109);
1064 MP_WriteMcuAccessRegWord(sc, 0xF954, 0x7340);
1065 MP_WriteMcuAccessRegWord(sc, 0xF956, 0x25BC);
1066 MP_WriteMcuAccessRegWord(sc, 0xF958, 0x130F);
1067 MP_WriteMcuAccessRegWord(sc, 0xF95A, 0xF105);
1068 MP_WriteMcuAccessRegWord(sc, 0xF95C, 0xC00A);
1069 MP_WriteMcuAccessRegWord(sc, 0xF95E, 0x7300);
1070 MP_WriteMcuAccessRegWord(sc, 0xF960, 0x4831);
1071 MP_WriteMcuAccessRegWord(sc, 0xF962, 0x9B00);
1072 MP_WriteMcuAccessRegWord(sc, 0xF964, 0xB000);
1073 MP_WriteMcuAccessRegWord(sc, 0xF966, 0x7340);
1074 MP_WriteMcuAccessRegWord(sc, 0xF968, 0x8320);
1075 MP_WriteMcuAccessRegWord(sc, 0xF96A, 0xC302);
1076 MP_WriteMcuAccessRegWord(sc, 0xF96C, 0xBB00);
1077 MP_WriteMcuAccessRegWord(sc, 0xF96E, 0x0C12);
1078 MP_WriteMcuAccessRegWord(sc, 0xF970, 0xE860);
1079 MP_WriteMcuAccessRegWord(sc, 0xF972, 0xC406);
1080 MP_WriteMcuAccessRegWord(sc, 0xF974, 0x7580);
1081 MP_WriteMcuAccessRegWord(sc, 0xF976, 0x4851);
1082 MP_WriteMcuAccessRegWord(sc, 0xF978, 0x8D80);
1083 MP_WriteMcuAccessRegWord(sc, 0xF97A, 0xC403);
1084 MP_WriteMcuAccessRegWord(sc, 0xF97C, 0xBC00);
1085 MP_WriteMcuAccessRegWord(sc, 0xF97E, 0xD3E0);
1086 MP_WriteMcuAccessRegWord(sc, 0xF980, 0x02C8);
1087 MP_WriteMcuAccessRegWord(sc, 0xF982, 0xC406);
1088 MP_WriteMcuAccessRegWord(sc, 0xF984, 0x7580);
1089 MP_WriteMcuAccessRegWord(sc, 0xF986, 0x4850);
1090 MP_WriteMcuAccessRegWord(sc, 0xF988, 0x8D80);
1091 MP_WriteMcuAccessRegWord(sc, 0xF98A, 0xC403);
1092 MP_WriteMcuAccessRegWord(sc, 0xF98C, 0xBC00);
1093 MP_WriteMcuAccessRegWord(sc, 0xF98E, 0xD3E0);
1094 MP_WriteMcuAccessRegWord(sc, 0xF990, 0x0298);
1095
1096 MP_WriteMcuAccessRegWord(sc, 0xDE30, 0x0080);
1097
1098 MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000);
1099
1100 MP_WriteMcuAccessRegWord(sc, 0xFC28, 0x0075);
1101 MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x02B1);
1102 MP_WriteMcuAccessRegWord(sc, 0xFC2C, 0x0991);
1103 MP_WriteMcuAccessRegWord(sc, 0xFC2E, 0x059B);
1104 MP_WriteMcuAccessRegWord(sc, 0xFC30, 0x0659);
1105 MP_WriteMcuAccessRegWord(sc, 0xFC32, 0x0000);
1106 MP_WriteMcuAccessRegWord(sc, 0xFC34, 0x02BB);
1107 MP_WriteMcuAccessRegWord(sc, 0xFC36, 0x0279);
1108 break;
1109 case MACFG_58:
1110 DisableMcuBPs(sc);
1111
1112 MP_WriteMcuAccessRegWord(sc, 0xF800, 0xE008);
1113 MP_WriteMcuAccessRegWord(sc, 0xF802, 0xE011);
1114 MP_WriteMcuAccessRegWord(sc, 0xF804, 0xE015);
1115 MP_WriteMcuAccessRegWord(sc, 0xF806, 0xE018);
1116 MP_WriteMcuAccessRegWord(sc, 0xF808, 0xE01B);
1117 MP_WriteMcuAccessRegWord(sc, 0xF80A, 0xE027);
1118 MP_WriteMcuAccessRegWord(sc, 0xF80C, 0xE043);
1119 MP_WriteMcuAccessRegWord(sc, 0xF80E, 0xE065);
1120 MP_WriteMcuAccessRegWord(sc, 0xF810, 0x49E2);
1121 MP_WriteMcuAccessRegWord(sc, 0xF812, 0xF005);
1122 MP_WriteMcuAccessRegWord(sc, 0xF814, 0x49EA);
1123 MP_WriteMcuAccessRegWord(sc, 0xF816, 0xF003);
1124 MP_WriteMcuAccessRegWord(sc, 0xF818, 0xC404);
1125 MP_WriteMcuAccessRegWord(sc, 0xF81A, 0xBC00);
1126 MP_WriteMcuAccessRegWord(sc, 0xF81C, 0xC403);
1127 MP_WriteMcuAccessRegWord(sc, 0xF81E, 0xBC00);
1128 MP_WriteMcuAccessRegWord(sc, 0xF820, 0x0496);
1129 MP_WriteMcuAccessRegWord(sc, 0xF822, 0x051A);
1130 MP_WriteMcuAccessRegWord(sc, 0xF824, 0x1D01);
1131 MP_WriteMcuAccessRegWord(sc, 0xF826, 0x8DE8);
1132 MP_WriteMcuAccessRegWord(sc, 0xF828, 0xC602);
1133 MP_WriteMcuAccessRegWord(sc, 0xF82A, 0xBE00);
1134 MP_WriteMcuAccessRegWord(sc, 0xF82C, 0x0206);
1135 MP_WriteMcuAccessRegWord(sc, 0xF82E, 0x1B76);
1136 MP_WriteMcuAccessRegWord(sc, 0xF830, 0xC202);
1137 MP_WriteMcuAccessRegWord(sc, 0xF832, 0xBA00);
1138 MP_WriteMcuAccessRegWord(sc, 0xF834, 0x058A);
1139 MP_WriteMcuAccessRegWord(sc, 0xF836, 0x1B76);
1140 MP_WriteMcuAccessRegWord(sc, 0xF838, 0xC602);
1141 MP_WriteMcuAccessRegWord(sc, 0xF83A, 0xBE00);
1142 MP_WriteMcuAccessRegWord(sc, 0xF83C, 0x0648);
1143 MP_WriteMcuAccessRegWord(sc, 0xF83E, 0x74E6);
1144 MP_WriteMcuAccessRegWord(sc, 0xF840, 0x1B78);
1145 MP_WriteMcuAccessRegWord(sc, 0xF842, 0x46DC);
1146 MP_WriteMcuAccessRegWord(sc, 0xF844, 0x1300);
1147 MP_WriteMcuAccessRegWord(sc, 0xF846, 0xF005);
1148 MP_WriteMcuAccessRegWord(sc, 0xF848, 0x74F8);
1149 MP_WriteMcuAccessRegWord(sc, 0xF84A, 0x48C3);
1150 MP_WriteMcuAccessRegWord(sc, 0xF84C, 0x48C4);
1151 MP_WriteMcuAccessRegWord(sc, 0xF84E, 0x8CF8);
1152 MP_WriteMcuAccessRegWord(sc, 0xF850, 0x64E7);
1153 MP_WriteMcuAccessRegWord(sc, 0xF852, 0xC302);
1154 MP_WriteMcuAccessRegWord(sc, 0xF854, 0xBB00);
1155 MP_WriteMcuAccessRegWord(sc, 0xF856, 0x068E);
1156 MP_WriteMcuAccessRegWord(sc, 0xF858, 0x74E4);
1157 MP_WriteMcuAccessRegWord(sc, 0xF85A, 0x49C5);
1158 MP_WriteMcuAccessRegWord(sc, 0xF85C, 0xF106);
1159 MP_WriteMcuAccessRegWord(sc, 0xF85E, 0x49C6);
1160 MP_WriteMcuAccessRegWord(sc, 0xF860, 0xF107);
1161 MP_WriteMcuAccessRegWord(sc, 0xF862, 0x48C8);
1162 MP_WriteMcuAccessRegWord(sc, 0xF864, 0x48C9);
1163 MP_WriteMcuAccessRegWord(sc, 0xF866, 0xE011);
1164 MP_WriteMcuAccessRegWord(sc, 0xF868, 0x48C9);
1165 MP_WriteMcuAccessRegWord(sc, 0xF86A, 0x4848);
1166 MP_WriteMcuAccessRegWord(sc, 0xF86C, 0xE00E);
1167 MP_WriteMcuAccessRegWord(sc, 0xF86E, 0x4848);
1168 MP_WriteMcuAccessRegWord(sc, 0xF870, 0x49C7);
1169 MP_WriteMcuAccessRegWord(sc, 0xF872, 0xF00A);
1170 MP_WriteMcuAccessRegWord(sc, 0xF874, 0x48C9);
1171 MP_WriteMcuAccessRegWord(sc, 0xF876, 0xC60D);
1172 MP_WriteMcuAccessRegWord(sc, 0xF878, 0x1D1F);
1173 MP_WriteMcuAccessRegWord(sc, 0xF87A, 0x8DC2);
1174 MP_WriteMcuAccessRegWord(sc, 0xF87C, 0x1D00);
1175 MP_WriteMcuAccessRegWord(sc, 0xF87E, 0x8DC3);
1176 MP_WriteMcuAccessRegWord(sc, 0xF880, 0x1D11);
1177 MP_WriteMcuAccessRegWord(sc, 0xF882, 0x8DC0);
1178 MP_WriteMcuAccessRegWord(sc, 0xF884, 0xE002);
1179 MP_WriteMcuAccessRegWord(sc, 0xF886, 0x4849);
1180 MP_WriteMcuAccessRegWord(sc, 0xF888, 0x94E5);
1181 MP_WriteMcuAccessRegWord(sc, 0xF88A, 0xC602);
1182 MP_WriteMcuAccessRegWord(sc, 0xF88C, 0xBE00);
1183 MP_WriteMcuAccessRegWord(sc, 0xF88E, 0x0238);
1184 MP_WriteMcuAccessRegWord(sc, 0xF890, 0xE434);
1185 MP_WriteMcuAccessRegWord(sc, 0xF892, 0x49D9);
1186 MP_WriteMcuAccessRegWord(sc, 0xF894, 0xF01B);
1187 MP_WriteMcuAccessRegWord(sc, 0xF896, 0xC31E);
1188 MP_WriteMcuAccessRegWord(sc, 0xF898, 0x7464);
1189 MP_WriteMcuAccessRegWord(sc, 0xF89A, 0x49C4);
1190 MP_WriteMcuAccessRegWord(sc, 0xF89C, 0xF114);
1191 MP_WriteMcuAccessRegWord(sc, 0xF89E, 0xC31B);
1192 MP_WriteMcuAccessRegWord(sc, 0xF8A0, 0x6460);
1193 MP_WriteMcuAccessRegWord(sc, 0xF8A2, 0x14FA);
1194 MP_WriteMcuAccessRegWord(sc, 0xF8A4, 0xFA02);
1195 MP_WriteMcuAccessRegWord(sc, 0xF8A6, 0xE00F);
1196 MP_WriteMcuAccessRegWord(sc, 0xF8A8, 0xC317);
1197 MP_WriteMcuAccessRegWord(sc, 0xF8AA, 0x7460);
1198 MP_WriteMcuAccessRegWord(sc, 0xF8AC, 0x49C0);
1199 MP_WriteMcuAccessRegWord(sc, 0xF8AE, 0xF10B);
1200 MP_WriteMcuAccessRegWord(sc, 0xF8B0, 0xC311);
1201 MP_WriteMcuAccessRegWord(sc, 0xF8B2, 0x7462);
1202 MP_WriteMcuAccessRegWord(sc, 0xF8B4, 0x48C1);
1203 MP_WriteMcuAccessRegWord(sc, 0xF8B6, 0x9C62);
1204 MP_WriteMcuAccessRegWord(sc, 0xF8B8, 0x4841);
1205 MP_WriteMcuAccessRegWord(sc, 0xF8BA, 0x9C62);
1206 MP_WriteMcuAccessRegWord(sc, 0xF8BC, 0xC30A);
1207 MP_WriteMcuAccessRegWord(sc, 0xF8BE, 0x1C04);
1208 MP_WriteMcuAccessRegWord(sc, 0xF8C0, 0x8C60);
1209 MP_WriteMcuAccessRegWord(sc, 0xF8C2, 0xE004);
1210 MP_WriteMcuAccessRegWord(sc, 0xF8C4, 0x1C15);
1211 MP_WriteMcuAccessRegWord(sc, 0xF8C6, 0xC305);
1212 MP_WriteMcuAccessRegWord(sc, 0xF8C8, 0x8C60);
1213 MP_WriteMcuAccessRegWord(sc, 0xF8CA, 0xC602);
1214 MP_WriteMcuAccessRegWord(sc, 0xF8CC, 0xBE00);
1215 MP_WriteMcuAccessRegWord(sc, 0xF8CE, 0x0374);
1216 MP_WriteMcuAccessRegWord(sc, 0xF8D0, 0xE434);
1217 MP_WriteMcuAccessRegWord(sc, 0xF8D2, 0xE030);
1218 MP_WriteMcuAccessRegWord(sc, 0xF8D4, 0xE61C);
1219 MP_WriteMcuAccessRegWord(sc, 0xF8D6, 0xE906);
1220 MP_WriteMcuAccessRegWord(sc, 0xF8D8, 0xC602);
1221 MP_WriteMcuAccessRegWord(sc, 0xF8DA, 0xBE00);
1222 MP_WriteMcuAccessRegWord(sc, 0xF8DC, 0x0000);
1223
1224 MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000);
1225
1226 MP_WriteMcuAccessRegWord(sc, 0xFC28, 0x0493);
1227 MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x0205);
1228 MP_WriteMcuAccessRegWord(sc, 0xFC2C, 0x0589);
1229 MP_WriteMcuAccessRegWord(sc, 0xFC2E, 0x0647);
1230 MP_WriteMcuAccessRegWord(sc, 0xFC30, 0x0000);
1231 MP_WriteMcuAccessRegWord(sc, 0xFC32, 0x0215);
1232 MP_WriteMcuAccessRegWord(sc, 0xFC34, 0x0285);
1233 break;
1234 case MACFG_59:
1235 DisableMcuBPs(sc);
1236
1237 MP_WriteMcuAccessRegWord(sc, 0xF800, 0xE008);
1238 MP_WriteMcuAccessRegWord(sc, 0xF802, 0xE00A);
1239 MP_WriteMcuAccessRegWord(sc, 0xF804, 0xE01B);
1240 MP_WriteMcuAccessRegWord(sc, 0xF806, 0xE03D);
1241 MP_WriteMcuAccessRegWord(sc, 0xF808, 0xE04C);
1242 MP_WriteMcuAccessRegWord(sc, 0xF80A, 0xE053);
1243 MP_WriteMcuAccessRegWord(sc, 0xF80C, 0xE055);
1244 MP_WriteMcuAccessRegWord(sc, 0xF80E, 0xE079);
1245 MP_WriteMcuAccessRegWord(sc, 0xF810, 0xC602);
1246 MP_WriteMcuAccessRegWord(sc, 0xF812, 0xBE00);
1247 MP_WriteMcuAccessRegWord(sc, 0xF814, 0x0000);
1248 MP_WriteMcuAccessRegWord(sc, 0xF816, 0xC511);
1249 MP_WriteMcuAccessRegWord(sc, 0xF818, 0x74A2);
1250 MP_WriteMcuAccessRegWord(sc, 0xF81A, 0x8CA5);
1251 MP_WriteMcuAccessRegWord(sc, 0xF81C, 0x74A0);
1252 MP_WriteMcuAccessRegWord(sc, 0xF81E, 0xC50B);
1253 MP_WriteMcuAccessRegWord(sc, 0xF820, 0x9CA2);
1254 MP_WriteMcuAccessRegWord(sc, 0xF822, 0x1C11);
1255 MP_WriteMcuAccessRegWord(sc, 0xF824, 0x9CA0);
1256 MP_WriteMcuAccessRegWord(sc, 0xF826, 0xC506);
1257 MP_WriteMcuAccessRegWord(sc, 0xF828, 0xBD00);
1258 MP_WriteMcuAccessRegWord(sc, 0xF82A, 0x7444);
1259 MP_WriteMcuAccessRegWord(sc, 0xF82C, 0xC502);
1260 MP_WriteMcuAccessRegWord(sc, 0xF82E, 0xBD00);
1261 MP_WriteMcuAccessRegWord(sc, 0xF830, 0x0A30);
1262 MP_WriteMcuAccessRegWord(sc, 0xF832, 0x0A46);
1263 MP_WriteMcuAccessRegWord(sc, 0xF834, 0xE434);
1264 MP_WriteMcuAccessRegWord(sc, 0xF836, 0xE096);
1265 MP_WriteMcuAccessRegWord(sc, 0xF838, 0xD3C0);
1266 MP_WriteMcuAccessRegWord(sc, 0xF83A, 0x49D9);
1267 MP_WriteMcuAccessRegWord(sc, 0xF83C, 0xF019);
1268 MP_WriteMcuAccessRegWord(sc, 0xF83E, 0xC520);
1269 MP_WriteMcuAccessRegWord(sc, 0xF840, 0x64A5);
1270 MP_WriteMcuAccessRegWord(sc, 0xF842, 0x1400);
1271 MP_WriteMcuAccessRegWord(sc, 0xF844, 0xF007);
1272 MP_WriteMcuAccessRegWord(sc, 0xF846, 0x0C01);
1273 MP_WriteMcuAccessRegWord(sc, 0xF848, 0x8CA5);
1274 MP_WriteMcuAccessRegWord(sc, 0xF84A, 0x1C15);
1275 MP_WriteMcuAccessRegWord(sc, 0xF84C, 0xC515);
1276 MP_WriteMcuAccessRegWord(sc, 0xF84E, 0x9CA0);
1277 MP_WriteMcuAccessRegWord(sc, 0xF850, 0xE00F);
1278 MP_WriteMcuAccessRegWord(sc, 0xF852, 0xC513);
1279 MP_WriteMcuAccessRegWord(sc, 0xF854, 0x74A0);
1280 MP_WriteMcuAccessRegWord(sc, 0xF856, 0x48C8);
1281 MP_WriteMcuAccessRegWord(sc, 0xF858, 0x48CA);
1282 MP_WriteMcuAccessRegWord(sc, 0xF85A, 0x9CA0);
1283 MP_WriteMcuAccessRegWord(sc, 0xF85C, 0xC510);
1284 MP_WriteMcuAccessRegWord(sc, 0xF85E, 0x1B00);
1285 MP_WriteMcuAccessRegWord(sc, 0xF860, 0x9BA0);
1286 MP_WriteMcuAccessRegWord(sc, 0xF862, 0x1B1C);
1287 MP_WriteMcuAccessRegWord(sc, 0xF864, 0x483F);
1288 MP_WriteMcuAccessRegWord(sc, 0xF866, 0x9BA2);
1289 MP_WriteMcuAccessRegWord(sc, 0xF868, 0x1B04);
1290 MP_WriteMcuAccessRegWord(sc, 0xF86A, 0xC506);
1291 MP_WriteMcuAccessRegWord(sc, 0xF86C, 0x9BA0);
1292 MP_WriteMcuAccessRegWord(sc, 0xF86E, 0xC603);
1293 MP_WriteMcuAccessRegWord(sc, 0xF870, 0xBE00);
1294 MP_WriteMcuAccessRegWord(sc, 0xF872, 0x0298);
1295 MP_WriteMcuAccessRegWord(sc, 0xF874, 0x03DE);
1296 MP_WriteMcuAccessRegWord(sc, 0xF876, 0xE434);
1297 MP_WriteMcuAccessRegWord(sc, 0xF878, 0xE096);
1298 MP_WriteMcuAccessRegWord(sc, 0xF87A, 0xE860);
1299 MP_WriteMcuAccessRegWord(sc, 0xF87C, 0xDE20);
1300 MP_WriteMcuAccessRegWord(sc, 0xF87E, 0xD3C0);
1301 MP_WriteMcuAccessRegWord(sc, 0xF880, 0xC50F);
1302 MP_WriteMcuAccessRegWord(sc, 0xF882, 0x76A4);
1303 MP_WriteMcuAccessRegWord(sc, 0xF884, 0x49E3);
1304 MP_WriteMcuAccessRegWord(sc, 0xF886, 0xF007);
1305 MP_WriteMcuAccessRegWord(sc, 0xF888, 0x49C0);
1306 MP_WriteMcuAccessRegWord(sc, 0xF88A, 0xF103);
1307 MP_WriteMcuAccessRegWord(sc, 0xF88C, 0xC607);
1308 MP_WriteMcuAccessRegWord(sc, 0xF88E, 0xBE00);
1309 MP_WriteMcuAccessRegWord(sc, 0xF890, 0xC606);
1310 MP_WriteMcuAccessRegWord(sc, 0xF892, 0xBE00);
1311 MP_WriteMcuAccessRegWord(sc, 0xF894, 0xC602);
1312 MP_WriteMcuAccessRegWord(sc, 0xF896, 0xBE00);
1313 MP_WriteMcuAccessRegWord(sc, 0xF898, 0x0A88);
1314 MP_WriteMcuAccessRegWord(sc, 0xF89A, 0x0A64);
1315 MP_WriteMcuAccessRegWord(sc, 0xF89C, 0x0A68);
1316 MP_WriteMcuAccessRegWord(sc, 0xF89E, 0xDC00);
1317 MP_WriteMcuAccessRegWord(sc, 0xF8A0, 0xC707);
1318 MP_WriteMcuAccessRegWord(sc, 0xF8A2, 0x1D00);
1319 MP_WriteMcuAccessRegWord(sc, 0xF8A4, 0x8DE2);
1320 MP_WriteMcuAccessRegWord(sc, 0xF8A6, 0x48C1);
1321 MP_WriteMcuAccessRegWord(sc, 0xF8A8, 0xC502);
1322 MP_WriteMcuAccessRegWord(sc, 0xF8AA, 0xBD00);
1323 MP_WriteMcuAccessRegWord(sc, 0xF8AC, 0x00AA);
1324 MP_WriteMcuAccessRegWord(sc, 0xF8AE, 0xE0C0);
1325 MP_WriteMcuAccessRegWord(sc, 0xF8B0, 0xC502);
1326 MP_WriteMcuAccessRegWord(sc, 0xF8B2, 0xBD00);
1327 MP_WriteMcuAccessRegWord(sc, 0xF8B4, 0x0132);
1328 MP_WriteMcuAccessRegWord(sc, 0xF8B6, 0xC523);
1329 MP_WriteMcuAccessRegWord(sc, 0xF8B8, 0x9EA0);
1330 MP_WriteMcuAccessRegWord(sc, 0xF8BA, 0x1C1C);
1331 MP_WriteMcuAccessRegWord(sc, 0xF8BC, 0x484F);
1332 MP_WriteMcuAccessRegWord(sc, 0xF8BE, 0x9CA2);
1333 MP_WriteMcuAccessRegWord(sc, 0xF8C0, 0x74A2);
1334 MP_WriteMcuAccessRegWord(sc, 0xF8C2, 0x49CF);
1335 MP_WriteMcuAccessRegWord(sc, 0xF8C4, 0xF1FE);
1336 MP_WriteMcuAccessRegWord(sc, 0xF8C6, 0x1600);
1337 MP_WriteMcuAccessRegWord(sc, 0xF8C8, 0xF115);
1338 MP_WriteMcuAccessRegWord(sc, 0xF8CA, 0xC417);
1339 MP_WriteMcuAccessRegWord(sc, 0xF8CC, 0x9CA0);
1340 MP_WriteMcuAccessRegWord(sc, 0xF8CE, 0x1C13);
1341 MP_WriteMcuAccessRegWord(sc, 0xF8D0, 0x484F);
1342 MP_WriteMcuAccessRegWord(sc, 0xF8D2, 0x9CA2);
1343 MP_WriteMcuAccessRegWord(sc, 0xF8D4, 0x74A2);
1344 MP_WriteMcuAccessRegWord(sc, 0xF8D6, 0x49CF);
1345 MP_WriteMcuAccessRegWord(sc, 0xF8D8, 0xF1FE);
1346 MP_WriteMcuAccessRegWord(sc, 0xF8DA, 0xC410);
1347 MP_WriteMcuAccessRegWord(sc, 0xF8DC, 0x9CA0);
1348 MP_WriteMcuAccessRegWord(sc, 0xF8DE, 0x1C13);
1349 MP_WriteMcuAccessRegWord(sc, 0xF8E0, 0x484F);
1350 MP_WriteMcuAccessRegWord(sc, 0xF8E2, 0x9CA2);
1351 MP_WriteMcuAccessRegWord(sc, 0xF8E4, 0x74A2);
1352 MP_WriteMcuAccessRegWord(sc, 0xF8E6, 0x49CF);
1353 MP_WriteMcuAccessRegWord(sc, 0xF8E8, 0xF1FE);
1354 MP_WriteMcuAccessRegWord(sc, 0xF8EA, 0xC50A);
1355 MP_WriteMcuAccessRegWord(sc, 0xF8EC, 0x74B8);
1356 MP_WriteMcuAccessRegWord(sc, 0xF8EE, 0x48C3);
1357 MP_WriteMcuAccessRegWord(sc, 0xF8F0, 0x8CB8);
1358 MP_WriteMcuAccessRegWord(sc, 0xF8F2, 0xC502);
1359 MP_WriteMcuAccessRegWord(sc, 0xF8F4, 0xBD00);
1360 MP_WriteMcuAccessRegWord(sc, 0xF8F6, 0x0A46);
1361 MP_WriteMcuAccessRegWord(sc, 0xF8F8, 0x0481);
1362 MP_WriteMcuAccessRegWord(sc, 0xF8FA, 0x0C81);
1363 MP_WriteMcuAccessRegWord(sc, 0xF8FC, 0xDE20);
1364 MP_WriteMcuAccessRegWord(sc, 0xF8FE, 0xE000);
1365 MP_WriteMcuAccessRegWord(sc, 0xF900, 0xC602);
1366 MP_WriteMcuAccessRegWord(sc, 0xF902, 0xBE00);
1367 MP_WriteMcuAccessRegWord(sc, 0xF904, 0x0000);
1368
1369 MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000);
1370
1371 MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x0A2F);
1372 MP_WriteMcuAccessRegWord(sc, 0xFC2C, 0x0297);
1373 MP_WriteMcuAccessRegWord(sc, 0xFC2E, 0x0A61);
1374 MP_WriteMcuAccessRegWord(sc, 0xFC30, 0x00A9);
1375 MP_WriteMcuAccessRegWord(sc, 0xFC32, 0x012D);
1376 break;
1377 case MACFG_60:
1378 DisableMcuBPs(sc);
1379
1380 MP_WriteMcuAccessRegWord(sc, 0xF800, 0xE008);
1381 MP_WriteMcuAccessRegWord(sc, 0xF802, 0xE00A);
1382 MP_WriteMcuAccessRegWord(sc, 0xF804, 0xE00C);
1383 MP_WriteMcuAccessRegWord(sc, 0xF806, 0xE00E);
1384 MP_WriteMcuAccessRegWord(sc, 0xF808, 0xE027);
1385 MP_WriteMcuAccessRegWord(sc, 0xF80A, 0xE04F);
1386 MP_WriteMcuAccessRegWord(sc, 0xF80C, 0xE05E);
1387 MP_WriteMcuAccessRegWord(sc, 0xF80E, 0xE065);
1388 MP_WriteMcuAccessRegWord(sc, 0xF810, 0xC602);
1389 MP_WriteMcuAccessRegWord(sc, 0xF812, 0xBE00);
1390 MP_WriteMcuAccessRegWord(sc, 0xF814, 0x0000);
1391 MP_WriteMcuAccessRegWord(sc, 0xF816, 0xC502);
1392 MP_WriteMcuAccessRegWord(sc, 0xF818, 0xBD00);
1393 MP_WriteMcuAccessRegWord(sc, 0xF81A, 0x074C);
1394 MP_WriteMcuAccessRegWord(sc, 0xF81C, 0xC302);
1395 MP_WriteMcuAccessRegWord(sc, 0xF81E, 0xBB00);
1396 MP_WriteMcuAccessRegWord(sc, 0xF820, 0x080A);
1397 MP_WriteMcuAccessRegWord(sc, 0xF822, 0x6420);
1398 MP_WriteMcuAccessRegWord(sc, 0xF824, 0x48C2);
1399 MP_WriteMcuAccessRegWord(sc, 0xF826, 0x8C20);
1400 MP_WriteMcuAccessRegWord(sc, 0xF828, 0xC516);
1401 MP_WriteMcuAccessRegWord(sc, 0xF82A, 0x64A4);
1402 MP_WriteMcuAccessRegWord(sc, 0xF82C, 0x49C0);
1403 MP_WriteMcuAccessRegWord(sc, 0xF82E, 0xF009);
1404 MP_WriteMcuAccessRegWord(sc, 0xF830, 0x74A2);
1405 MP_WriteMcuAccessRegWord(sc, 0xF832, 0x8CA5);
1406 MP_WriteMcuAccessRegWord(sc, 0xF834, 0x74A0);
1407 MP_WriteMcuAccessRegWord(sc, 0xF836, 0xC50E);
1408 MP_WriteMcuAccessRegWord(sc, 0xF838, 0x9CA2);
1409 MP_WriteMcuAccessRegWord(sc, 0xF83A, 0x1C11);
1410 MP_WriteMcuAccessRegWord(sc, 0xF83C, 0x9CA0);
1411 MP_WriteMcuAccessRegWord(sc, 0xF83E, 0xE006);
1412 MP_WriteMcuAccessRegWord(sc, 0xF840, 0x74F8);
1413 MP_WriteMcuAccessRegWord(sc, 0xF842, 0x48C4);
1414 MP_WriteMcuAccessRegWord(sc, 0xF844, 0x8CF8);
1415 MP_WriteMcuAccessRegWord(sc, 0xF846, 0xC404);
1416 MP_WriteMcuAccessRegWord(sc, 0xF848, 0xBC00);
1417 MP_WriteMcuAccessRegWord(sc, 0xF84A, 0xC403);
1418 MP_WriteMcuAccessRegWord(sc, 0xF84C, 0xBC00);
1419 MP_WriteMcuAccessRegWord(sc, 0xF84E, 0x0BF2);
1420 MP_WriteMcuAccessRegWord(sc, 0xF850, 0x0C0A);
1421 MP_WriteMcuAccessRegWord(sc, 0xF852, 0xE434);
1422 MP_WriteMcuAccessRegWord(sc, 0xF854, 0xD3C0);
1423 MP_WriteMcuAccessRegWord(sc, 0xF856, 0x49D9);
1424 MP_WriteMcuAccessRegWord(sc, 0xF858, 0xF01F);
1425 MP_WriteMcuAccessRegWord(sc, 0xF85A, 0xC526);
1426 MP_WriteMcuAccessRegWord(sc, 0xF85C, 0x64A5);
1427 MP_WriteMcuAccessRegWord(sc, 0xF85E, 0x1400);
1428 MP_WriteMcuAccessRegWord(sc, 0xF860, 0xF007);
1429 MP_WriteMcuAccessRegWord(sc, 0xF862, 0x0C01);
1430 MP_WriteMcuAccessRegWord(sc, 0xF864, 0x8CA5);
1431 MP_WriteMcuAccessRegWord(sc, 0xF866, 0x1C15);
1432 MP_WriteMcuAccessRegWord(sc, 0xF868, 0xC51B);
1433 MP_WriteMcuAccessRegWord(sc, 0xF86A, 0x9CA0);
1434 MP_WriteMcuAccessRegWord(sc, 0xF86C, 0xE013);
1435 MP_WriteMcuAccessRegWord(sc, 0xF86E, 0xC519);
1436 MP_WriteMcuAccessRegWord(sc, 0xF870, 0x74A0);
1437 MP_WriteMcuAccessRegWord(sc, 0xF872, 0x48C4);
1438 MP_WriteMcuAccessRegWord(sc, 0xF874, 0x8CA0);
1439 MP_WriteMcuAccessRegWord(sc, 0xF876, 0xC516);
1440 MP_WriteMcuAccessRegWord(sc, 0xF878, 0x74A4);
1441 MP_WriteMcuAccessRegWord(sc, 0xF87A, 0x48C8);
1442 MP_WriteMcuAccessRegWord(sc, 0xF87C, 0x48CA);
1443 MP_WriteMcuAccessRegWord(sc, 0xF87E, 0x9CA4);
1444 MP_WriteMcuAccessRegWord(sc, 0xF880, 0xC512);
1445 MP_WriteMcuAccessRegWord(sc, 0xF882, 0x1B00);
1446 MP_WriteMcuAccessRegWord(sc, 0xF884, 0x9BA0);
1447 MP_WriteMcuAccessRegWord(sc, 0xF886, 0x1B1C);
1448 MP_WriteMcuAccessRegWord(sc, 0xF888, 0x483F);
1449 MP_WriteMcuAccessRegWord(sc, 0xF88A, 0x9BA2);
1450 MP_WriteMcuAccessRegWord(sc, 0xF88C, 0x1B04);
1451 MP_WriteMcuAccessRegWord(sc, 0xF88E, 0xC508);
1452 MP_WriteMcuAccessRegWord(sc, 0xF890, 0x9BA0);
1453 MP_WriteMcuAccessRegWord(sc, 0xF892, 0xC505);
1454 MP_WriteMcuAccessRegWord(sc, 0xF894, 0xBD00);
1455 MP_WriteMcuAccessRegWord(sc, 0xF896, 0xC502);
1456 MP_WriteMcuAccessRegWord(sc, 0xF898, 0xBD00);
1457 MP_WriteMcuAccessRegWord(sc, 0xF89A, 0x0300);
1458 MP_WriteMcuAccessRegWord(sc, 0xF89C, 0x051E);
1459 MP_WriteMcuAccessRegWord(sc, 0xF89E, 0xE434);
1460 MP_WriteMcuAccessRegWord(sc, 0xF8A0, 0xE018);
1461 MP_WriteMcuAccessRegWord(sc, 0xF8A2, 0xE092);
1462 MP_WriteMcuAccessRegWord(sc, 0xF8A4, 0xDE20);
1463 MP_WriteMcuAccessRegWord(sc, 0xF8A6, 0xD3C0);
1464 MP_WriteMcuAccessRegWord(sc, 0xF8A8, 0xC50F);
1465 MP_WriteMcuAccessRegWord(sc, 0xF8AA, 0x76A4);
1466 MP_WriteMcuAccessRegWord(sc, 0xF8AC, 0x49E3);
1467 MP_WriteMcuAccessRegWord(sc, 0xF8AE, 0xF007);
1468 MP_WriteMcuAccessRegWord(sc, 0xF8B0, 0x49C0);
1469 MP_WriteMcuAccessRegWord(sc, 0xF8B2, 0xF103);
1470 MP_WriteMcuAccessRegWord(sc, 0xF8B4, 0xC607);
1471 MP_WriteMcuAccessRegWord(sc, 0xF8B6, 0xBE00);
1472 MP_WriteMcuAccessRegWord(sc, 0xF8B8, 0xC606);
1473 MP_WriteMcuAccessRegWord(sc, 0xF8BA, 0xBE00);
1474 MP_WriteMcuAccessRegWord(sc, 0xF8BC, 0xC602);
1475 MP_WriteMcuAccessRegWord(sc, 0xF8BE, 0xBE00);
1476 MP_WriteMcuAccessRegWord(sc, 0xF8C0, 0x0C4C);
1477 MP_WriteMcuAccessRegWord(sc, 0xF8C2, 0x0C28);
1478 MP_WriteMcuAccessRegWord(sc, 0xF8C4, 0x0C2C);
1479 MP_WriteMcuAccessRegWord(sc, 0xF8C6, 0xDC00);
1480 MP_WriteMcuAccessRegWord(sc, 0xF8C8, 0xC707);
1481 MP_WriteMcuAccessRegWord(sc, 0xF8CA, 0x1D00);
1482 MP_WriteMcuAccessRegWord(sc, 0xF8CC, 0x8DE2);
1483 MP_WriteMcuAccessRegWord(sc, 0xF8CE, 0x48C1);
1484 MP_WriteMcuAccessRegWord(sc, 0xF8D0, 0xC502);
1485 MP_WriteMcuAccessRegWord(sc, 0xF8D2, 0xBD00);
1486 MP_WriteMcuAccessRegWord(sc, 0xF8D4, 0x00AA);
1487 MP_WriteMcuAccessRegWord(sc, 0xF8D6, 0xE0C0);
1488 MP_WriteMcuAccessRegWord(sc, 0xF8D8, 0xC502);
1489 MP_WriteMcuAccessRegWord(sc, 0xF8DA, 0xBD00);
1490 MP_WriteMcuAccessRegWord(sc, 0xF8DC, 0x0132);
1491
1492 MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000);
1493
1494 MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x0743);
1495 MP_WriteMcuAccessRegWord(sc, 0xFC2C, 0x0801);
1496 MP_WriteMcuAccessRegWord(sc, 0xFC2E, 0x0BE9);
1497 MP_WriteMcuAccessRegWord(sc, 0xFC30, 0x02FD);
1498 MP_WriteMcuAccessRegWord(sc, 0xFC32, 0x0C25);
1499 MP_WriteMcuAccessRegWord(sc, 0xFC34, 0x00A9);
1500 MP_WriteMcuAccessRegWord(sc, 0xFC36, 0x012D);
1501 break;
1502 case MACFG_62:
1503 DisableMcuBPs(sc);
1504
1505 MP_WriteMcuAccessRegWord(sc, 0xF800, 0xE008);
1506 MP_WriteMcuAccessRegWord(sc, 0xF802, 0xE0D3);
1507 MP_WriteMcuAccessRegWord(sc, 0xF804, 0xE0D6);
1508 MP_WriteMcuAccessRegWord(sc, 0xF806, 0xE0D9);
1509 MP_WriteMcuAccessRegWord(sc, 0xF808, 0xE0DB);
1510 MP_WriteMcuAccessRegWord(sc, 0xF80A, 0xE0DD);
1511 MP_WriteMcuAccessRegWord(sc, 0xF80C, 0xE0DF);
1512 MP_WriteMcuAccessRegWord(sc, 0xF80E, 0xE0E1);
1513 MP_WriteMcuAccessRegWord(sc, 0xF810, 0xC251);
1514 MP_WriteMcuAccessRegWord(sc, 0xF812, 0x7340);
1515 MP_WriteMcuAccessRegWord(sc, 0xF814, 0x49B1);
1516 MP_WriteMcuAccessRegWord(sc, 0xF816, 0xF010);
1517 MP_WriteMcuAccessRegWord(sc, 0xF818, 0x1D02);
1518 MP_WriteMcuAccessRegWord(sc, 0xF81A, 0x8D40);
1519 MP_WriteMcuAccessRegWord(sc, 0xF81C, 0xC202);
1520 MP_WriteMcuAccessRegWord(sc, 0xF81E, 0xBA00);
1521 MP_WriteMcuAccessRegWord(sc, 0xF820, 0x2C3A);
1522 MP_WriteMcuAccessRegWord(sc, 0xF822, 0xC0F0);
1523 MP_WriteMcuAccessRegWord(sc, 0xF824, 0xE8DE);
1524 MP_WriteMcuAccessRegWord(sc, 0xF826, 0x2000);
1525 MP_WriteMcuAccessRegWord(sc, 0xF828, 0x8000);
1526 MP_WriteMcuAccessRegWord(sc, 0xF82A, 0xC0B6);
1527 MP_WriteMcuAccessRegWord(sc, 0xF82C, 0x268C);
1528 MP_WriteMcuAccessRegWord(sc, 0xF82E, 0x752C);
1529 MP_WriteMcuAccessRegWord(sc, 0xF830, 0x49D4);
1530 MP_WriteMcuAccessRegWord(sc, 0xF832, 0xF112);
1531 MP_WriteMcuAccessRegWord(sc, 0xF834, 0xE025);
1532 MP_WriteMcuAccessRegWord(sc, 0xF836, 0xC2F6);
1533 MP_WriteMcuAccessRegWord(sc, 0xF838, 0x7146);
1534 MP_WriteMcuAccessRegWord(sc, 0xF83A, 0xC2F5);
1535 MP_WriteMcuAccessRegWord(sc, 0xF83C, 0x7340);
1536 MP_WriteMcuAccessRegWord(sc, 0xF83E, 0x49BE);
1537 MP_WriteMcuAccessRegWord(sc, 0xF840, 0xF103);
1538 MP_WriteMcuAccessRegWord(sc, 0xF842, 0xC7F2);
1539 MP_WriteMcuAccessRegWord(sc, 0xF844, 0xE002);
1540 MP_WriteMcuAccessRegWord(sc, 0xF846, 0xC7F1);
1541 MP_WriteMcuAccessRegWord(sc, 0xF848, 0x304F);
1542 MP_WriteMcuAccessRegWord(sc, 0xF84A, 0x6226);
1543 MP_WriteMcuAccessRegWord(sc, 0xF84C, 0x49A1);
1544 MP_WriteMcuAccessRegWord(sc, 0xF84E, 0xF1F0);
1545 MP_WriteMcuAccessRegWord(sc, 0xF850, 0x7222);
1546 MP_WriteMcuAccessRegWord(sc, 0xF852, 0x49A0);
1547 MP_WriteMcuAccessRegWord(sc, 0xF854, 0xF1ED);
1548 MP_WriteMcuAccessRegWord(sc, 0xF856, 0x2525);
1549 MP_WriteMcuAccessRegWord(sc, 0xF858, 0x1F28);
1550 MP_WriteMcuAccessRegWord(sc, 0xF85A, 0x3097);
1551 MP_WriteMcuAccessRegWord(sc, 0xF85C, 0x3091);
1552 MP_WriteMcuAccessRegWord(sc, 0xF85E, 0x9A36);
1553 MP_WriteMcuAccessRegWord(sc, 0xF860, 0x752C);
1554 MP_WriteMcuAccessRegWord(sc, 0xF862, 0x21DC);
1555 MP_WriteMcuAccessRegWord(sc, 0xF864, 0x25BC);
1556 MP_WriteMcuAccessRegWord(sc, 0xF866, 0xC6E2);
1557 MP_WriteMcuAccessRegWord(sc, 0xF868, 0x77C0);
1558 MP_WriteMcuAccessRegWord(sc, 0xF86A, 0x1304);
1559 MP_WriteMcuAccessRegWord(sc, 0xF86C, 0xF014);
1560 MP_WriteMcuAccessRegWord(sc, 0xF86E, 0x1303);
1561 MP_WriteMcuAccessRegWord(sc, 0xF870, 0xF014);
1562 MP_WriteMcuAccessRegWord(sc, 0xF872, 0x1302);
1563 MP_WriteMcuAccessRegWord(sc, 0xF874, 0xF014);
1564 MP_WriteMcuAccessRegWord(sc, 0xF876, 0x1301);
1565 MP_WriteMcuAccessRegWord(sc, 0xF878, 0xF014);
1566 MP_WriteMcuAccessRegWord(sc, 0xF87A, 0x49D4);
1567 MP_WriteMcuAccessRegWord(sc, 0xF87C, 0xF103);
1568 MP_WriteMcuAccessRegWord(sc, 0xF87E, 0xC3D7);
1569 MP_WriteMcuAccessRegWord(sc, 0xF880, 0xBB00);
1570 MP_WriteMcuAccessRegWord(sc, 0xF882, 0xC618);
1571 MP_WriteMcuAccessRegWord(sc, 0xF884, 0x67C6);
1572 MP_WriteMcuAccessRegWord(sc, 0xF886, 0x752E);
1573 MP_WriteMcuAccessRegWord(sc, 0xF888, 0x22D7);
1574 MP_WriteMcuAccessRegWord(sc, 0xF88A, 0x26DD);
1575 MP_WriteMcuAccessRegWord(sc, 0xF88C, 0x1505);
1576 MP_WriteMcuAccessRegWord(sc, 0xF88E, 0xF013);
1577 MP_WriteMcuAccessRegWord(sc, 0xF890, 0xC60A);
1578 MP_WriteMcuAccessRegWord(sc, 0xF892, 0xBE00);
1579 MP_WriteMcuAccessRegWord(sc, 0xF894, 0xC309);
1580 MP_WriteMcuAccessRegWord(sc, 0xF896, 0xBB00);
1581 MP_WriteMcuAccessRegWord(sc, 0xF898, 0xC308);
1582 MP_WriteMcuAccessRegWord(sc, 0xF89A, 0xBB00);
1583 MP_WriteMcuAccessRegWord(sc, 0xF89C, 0xC307);
1584 MP_WriteMcuAccessRegWord(sc, 0xF89E, 0xBB00);
1585 MP_WriteMcuAccessRegWord(sc, 0xF8A0, 0xC306);
1586 MP_WriteMcuAccessRegWord(sc, 0xF8A2, 0xBB00);
1587 MP_WriteMcuAccessRegWord(sc, 0xF8A4, 0x25C8);
1588 MP_WriteMcuAccessRegWord(sc, 0xF8A6, 0x25A6);
1589 MP_WriteMcuAccessRegWord(sc, 0xF8A8, 0x25AC);
1590 MP_WriteMcuAccessRegWord(sc, 0xF8AA, 0x25B2);
1591 MP_WriteMcuAccessRegWord(sc, 0xF8AC, 0x25B8);
1592 MP_WriteMcuAccessRegWord(sc, 0xF8AE, 0xCD08);
1593 MP_WriteMcuAccessRegWord(sc, 0xF8B0, 0x0000);
1594 MP_WriteMcuAccessRegWord(sc, 0xF8B2, 0xC0BC);
1595 MP_WriteMcuAccessRegWord(sc, 0xF8B4, 0xC2FF);
1596 MP_WriteMcuAccessRegWord(sc, 0xF8B6, 0x7340);
1597 MP_WriteMcuAccessRegWord(sc, 0xF8B8, 0x49B0);
1598 MP_WriteMcuAccessRegWord(sc, 0xF8BA, 0xF04E);
1599 MP_WriteMcuAccessRegWord(sc, 0xF8BC, 0x1F46);
1600 MP_WriteMcuAccessRegWord(sc, 0xF8BE, 0x308F);
1601 MP_WriteMcuAccessRegWord(sc, 0xF8C0, 0xC3F7);
1602 MP_WriteMcuAccessRegWord(sc, 0xF8C2, 0x1C04);
1603 MP_WriteMcuAccessRegWord(sc, 0xF8C4, 0xE84D);
1604 MP_WriteMcuAccessRegWord(sc, 0xF8C6, 0x1401);
1605 MP_WriteMcuAccessRegWord(sc, 0xF8C8, 0xF147);
1606 MP_WriteMcuAccessRegWord(sc, 0xF8CA, 0x7226);
1607 MP_WriteMcuAccessRegWord(sc, 0xF8CC, 0x49A7);
1608 MP_WriteMcuAccessRegWord(sc, 0xF8CE, 0xF044);
1609 MP_WriteMcuAccessRegWord(sc, 0xF8D0, 0x7222);
1610 MP_WriteMcuAccessRegWord(sc, 0xF8D2, 0x2525);
1611 MP_WriteMcuAccessRegWord(sc, 0xF8D4, 0x1F30);
1612 MP_WriteMcuAccessRegWord(sc, 0xF8D6, 0x3097);
1613 MP_WriteMcuAccessRegWord(sc, 0xF8D8, 0x3091);
1614 MP_WriteMcuAccessRegWord(sc, 0xF8DA, 0x7340);
1615 MP_WriteMcuAccessRegWord(sc, 0xF8DC, 0xC4EA);
1616 MP_WriteMcuAccessRegWord(sc, 0xF8DE, 0x401C);
1617 MP_WriteMcuAccessRegWord(sc, 0xF8E0, 0xF006);
1618 MP_WriteMcuAccessRegWord(sc, 0xF8E2, 0xC6E8);
1619 MP_WriteMcuAccessRegWord(sc, 0xF8E4, 0x75C0);
1620 MP_WriteMcuAccessRegWord(sc, 0xF8E6, 0x49D7);
1621 MP_WriteMcuAccessRegWord(sc, 0xF8E8, 0xF105);
1622 MP_WriteMcuAccessRegWord(sc, 0xF8EA, 0xE036);
1623 MP_WriteMcuAccessRegWord(sc, 0xF8EC, 0x1D08);
1624 MP_WriteMcuAccessRegWord(sc, 0xF8EE, 0x8DC1);
1625 MP_WriteMcuAccessRegWord(sc, 0xF8F0, 0x0208);
1626 MP_WriteMcuAccessRegWord(sc, 0xF8F2, 0x6640);
1627 MP_WriteMcuAccessRegWord(sc, 0xF8F4, 0x2764);
1628 MP_WriteMcuAccessRegWord(sc, 0xF8F6, 0x1606);
1629 MP_WriteMcuAccessRegWord(sc, 0xF8F8, 0xF12F);
1630 MP_WriteMcuAccessRegWord(sc, 0xF8FA, 0x6346);
1631 MP_WriteMcuAccessRegWord(sc, 0xF8FC, 0x133B);
1632 MP_WriteMcuAccessRegWord(sc, 0xF8FE, 0xF12C);
1633 MP_WriteMcuAccessRegWord(sc, 0xF900, 0x9B34);
1634 MP_WriteMcuAccessRegWord(sc, 0xF902, 0x1B18);
1635 MP_WriteMcuAccessRegWord(sc, 0xF904, 0x3093);
1636 MP_WriteMcuAccessRegWord(sc, 0xF906, 0xC32A);
1637 MP_WriteMcuAccessRegWord(sc, 0xF908, 0x1C10);
1638 MP_WriteMcuAccessRegWord(sc, 0xF90A, 0xE82A);
1639 MP_WriteMcuAccessRegWord(sc, 0xF90C, 0x1401);
1640 MP_WriteMcuAccessRegWord(sc, 0xF90E, 0xF124);
1641 MP_WriteMcuAccessRegWord(sc, 0xF910, 0x1A36);
1642 MP_WriteMcuAccessRegWord(sc, 0xF912, 0x308A);
1643 MP_WriteMcuAccessRegWord(sc, 0xF914, 0x7322);
1644 MP_WriteMcuAccessRegWord(sc, 0xF916, 0x25B5);
1645 MP_WriteMcuAccessRegWord(sc, 0xF918, 0x0B0E);
1646 MP_WriteMcuAccessRegWord(sc, 0xF91A, 0x1C00);
1647 MP_WriteMcuAccessRegWord(sc, 0xF91C, 0xE82C);
1648 MP_WriteMcuAccessRegWord(sc, 0xF91E, 0xC71F);
1649 MP_WriteMcuAccessRegWord(sc, 0xF920, 0x4027);
1650 MP_WriteMcuAccessRegWord(sc, 0xF922, 0xF11A);
1651 MP_WriteMcuAccessRegWord(sc, 0xF924, 0xE838);
1652 MP_WriteMcuAccessRegWord(sc, 0xF926, 0x1F42);
1653 MP_WriteMcuAccessRegWord(sc, 0xF928, 0x308F);
1654 MP_WriteMcuAccessRegWord(sc, 0xF92A, 0x1B08);
1655 MP_WriteMcuAccessRegWord(sc, 0xF92C, 0xE824);
1656 MP_WriteMcuAccessRegWord(sc, 0xF92E, 0x7236);
1657 MP_WriteMcuAccessRegWord(sc, 0xF930, 0x7746);
1658 MP_WriteMcuAccessRegWord(sc, 0xF932, 0x1700);
1659 MP_WriteMcuAccessRegWord(sc, 0xF934, 0xF00D);
1660 MP_WriteMcuAccessRegWord(sc, 0xF936, 0xC313);
1661 MP_WriteMcuAccessRegWord(sc, 0xF938, 0x401F);
1662 MP_WriteMcuAccessRegWord(sc, 0xF93A, 0xF103);
1663 MP_WriteMcuAccessRegWord(sc, 0xF93C, 0x1F00);
1664 MP_WriteMcuAccessRegWord(sc, 0xF93E, 0x9F46);
1665 MP_WriteMcuAccessRegWord(sc, 0xF940, 0x7744);
1666 MP_WriteMcuAccessRegWord(sc, 0xF942, 0x449F);
1667 MP_WriteMcuAccessRegWord(sc, 0xF944, 0x445F);
1668 MP_WriteMcuAccessRegWord(sc, 0xF946, 0xE817);
1669 MP_WriteMcuAccessRegWord(sc, 0xF948, 0xC70A);
1670 MP_WriteMcuAccessRegWord(sc, 0xF94A, 0x4027);
1671 MP_WriteMcuAccessRegWord(sc, 0xF94C, 0xF105);
1672 MP_WriteMcuAccessRegWord(sc, 0xF94E, 0xC302);
1673 MP_WriteMcuAccessRegWord(sc, 0xF950, 0xBB00);
1674 MP_WriteMcuAccessRegWord(sc, 0xF952, 0x2E08);
1675 MP_WriteMcuAccessRegWord(sc, 0xF954, 0x2DC2);
1676 MP_WriteMcuAccessRegWord(sc, 0xF956, 0xC7FF);
1677 MP_WriteMcuAccessRegWord(sc, 0xF958, 0xBF00);
1678 MP_WriteMcuAccessRegWord(sc, 0xF95A, 0xCDB8);
1679 MP_WriteMcuAccessRegWord(sc, 0xF95C, 0xFFFF);
1680 MP_WriteMcuAccessRegWord(sc, 0xF95E, 0x0C02);
1681 MP_WriteMcuAccessRegWord(sc, 0xF960, 0xA554);
1682 MP_WriteMcuAccessRegWord(sc, 0xF962, 0xA5DC);
1683 MP_WriteMcuAccessRegWord(sc, 0xF964, 0x402F);
1684 MP_WriteMcuAccessRegWord(sc, 0xF966, 0xF105);
1685 MP_WriteMcuAccessRegWord(sc, 0xF968, 0x1400);
1686 MP_WriteMcuAccessRegWord(sc, 0xF96A, 0xF1FA);
1687 MP_WriteMcuAccessRegWord(sc, 0xF96C, 0x1C01);
1688 MP_WriteMcuAccessRegWord(sc, 0xF96E, 0xE002);
1689 MP_WriteMcuAccessRegWord(sc, 0xF970, 0x1C00);
1690 MP_WriteMcuAccessRegWord(sc, 0xF972, 0xFF80);
1691 MP_WriteMcuAccessRegWord(sc, 0xF974, 0x49B0);
1692 MP_WriteMcuAccessRegWord(sc, 0xF976, 0xF004);
1693 MP_WriteMcuAccessRegWord(sc, 0xF978, 0x0B01);
1694 MP_WriteMcuAccessRegWord(sc, 0xF97A, 0xA1D3);
1695 MP_WriteMcuAccessRegWord(sc, 0xF97C, 0xE003);
1696 MP_WriteMcuAccessRegWord(sc, 0xF97E, 0x0B02);
1697 MP_WriteMcuAccessRegWord(sc, 0xF980, 0xA5D3);
1698 MP_WriteMcuAccessRegWord(sc, 0xF982, 0x3127);
1699 MP_WriteMcuAccessRegWord(sc, 0xF984, 0x3720);
1700 MP_WriteMcuAccessRegWord(sc, 0xF986, 0x0B02);
1701 MP_WriteMcuAccessRegWord(sc, 0xF988, 0xA5D3);
1702 MP_WriteMcuAccessRegWord(sc, 0xF98A, 0x3127);
1703 MP_WriteMcuAccessRegWord(sc, 0xF98C, 0x3720);
1704 MP_WriteMcuAccessRegWord(sc, 0xF98E, 0x1300);
1705 MP_WriteMcuAccessRegWord(sc, 0xF990, 0xF1FB);
1706 MP_WriteMcuAccessRegWord(sc, 0xF992, 0xFF80);
1707 MP_WriteMcuAccessRegWord(sc, 0xF994, 0x7322);
1708 MP_WriteMcuAccessRegWord(sc, 0xF996, 0x25B5);
1709 MP_WriteMcuAccessRegWord(sc, 0xF998, 0x1E28);
1710 MP_WriteMcuAccessRegWord(sc, 0xF99A, 0x30DE);
1711 MP_WriteMcuAccessRegWord(sc, 0xF99C, 0x30D9);
1712 MP_WriteMcuAccessRegWord(sc, 0xF99E, 0x7264);
1713 MP_WriteMcuAccessRegWord(sc, 0xF9A0, 0x1E11);
1714 MP_WriteMcuAccessRegWord(sc, 0xF9A2, 0x2368);
1715 MP_WriteMcuAccessRegWord(sc, 0xF9A4, 0x3116);
1716 MP_WriteMcuAccessRegWord(sc, 0xF9A6, 0xFF80);
1717 MP_WriteMcuAccessRegWord(sc, 0xF9A8, 0x1B7E);
1718 MP_WriteMcuAccessRegWord(sc, 0xF9AA, 0xC602);
1719 MP_WriteMcuAccessRegWord(sc, 0xF9AC, 0xBE00);
1720 MP_WriteMcuAccessRegWord(sc, 0xF9AE, 0x06A6);
1721 MP_WriteMcuAccessRegWord(sc, 0xF9B0, 0x1B7E);
1722 MP_WriteMcuAccessRegWord(sc, 0xF9B2, 0xC602);
1723 MP_WriteMcuAccessRegWord(sc, 0xF9B4, 0xBE00);
1724 MP_WriteMcuAccessRegWord(sc, 0xF9B6, 0x0764);
1725 MP_WriteMcuAccessRegWord(sc, 0xF9B8, 0xC602);
1726 MP_WriteMcuAccessRegWord(sc, 0xF9BA, 0xBE00);
1727 MP_WriteMcuAccessRegWord(sc, 0xF9BC, 0x0000);
1728 MP_WriteMcuAccessRegWord(sc, 0xF9BE, 0xC602);
1729 MP_WriteMcuAccessRegWord(sc, 0xF9C0, 0xBE00);
1730 MP_WriteMcuAccessRegWord(sc, 0xF9C2, 0x0000);
1731 MP_WriteMcuAccessRegWord(sc, 0xF9C4, 0xC602);
1732 MP_WriteMcuAccessRegWord(sc, 0xF9C6, 0xBE00);
1733 MP_WriteMcuAccessRegWord(sc, 0xF9C8, 0x0000);
1734 MP_WriteMcuAccessRegWord(sc, 0xF9CA, 0xC602);
1735 MP_WriteMcuAccessRegWord(sc, 0xF9CC, 0xBE00);
1736 MP_WriteMcuAccessRegWord(sc, 0xF9CE, 0x0000);
1737 MP_WriteMcuAccessRegWord(sc, 0xF9D0, 0xC602);
1738 MP_WriteMcuAccessRegWord(sc, 0xF9D2, 0xBE00);
1739 MP_WriteMcuAccessRegWord(sc, 0xF9D4, 0x0000);
1740
1741 MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000);
1742
1743 MP_WriteMcuAccessRegWord(sc, 0xFC28, 0x2549);
1744 MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x06A5);
1745 MP_WriteMcuAccessRegWord(sc, 0xFC2C, 0x0763);
1746 break;
1747 case MACFG_67:
1748 DisableMcuBPs(sc);
1749
1750 MP_WriteMcuAccessRegWord(sc, 0xF800, 0xE008);
1751 MP_WriteMcuAccessRegWord(sc, 0xF802, 0xE017);
1752 MP_WriteMcuAccessRegWord(sc, 0xF804, 0xE019);
1753 MP_WriteMcuAccessRegWord(sc, 0xF806, 0xE01B);
1754 MP_WriteMcuAccessRegWord(sc, 0xF808, 0xE01D);
1755 MP_WriteMcuAccessRegWord(sc, 0xF80A, 0xE01F);
1756 MP_WriteMcuAccessRegWord(sc, 0xF80C, 0xE021);
1757 MP_WriteMcuAccessRegWord(sc, 0xF80E, 0xE023);
1758 MP_WriteMcuAccessRegWord(sc, 0xF810, 0xC50F);
1759 MP_WriteMcuAccessRegWord(sc, 0xF812, 0x76A4);
1760 MP_WriteMcuAccessRegWord(sc, 0xF814, 0x49E3);
1761 MP_WriteMcuAccessRegWord(sc, 0xF816, 0xF007);
1762 MP_WriteMcuAccessRegWord(sc, 0xF818, 0x49C0);
1763 MP_WriteMcuAccessRegWord(sc, 0xF81A, 0xF103);
1764 MP_WriteMcuAccessRegWord(sc, 0xF81C, 0xC607);
1765 MP_WriteMcuAccessRegWord(sc, 0xF81E, 0xBE00);
1766 MP_WriteMcuAccessRegWord(sc, 0xF820, 0xC606);
1767 MP_WriteMcuAccessRegWord(sc, 0xF822, 0xBE00);
1768 MP_WriteMcuAccessRegWord(sc, 0xF824, 0xC602);
1769 MP_WriteMcuAccessRegWord(sc, 0xF826, 0xBE00);
1770 MP_WriteMcuAccessRegWord(sc, 0xF828, 0x0BDA);
1771 MP_WriteMcuAccessRegWord(sc, 0xF82A, 0x0BB0);
1772 MP_WriteMcuAccessRegWord(sc, 0xF82C, 0x0BBA);
1773 MP_WriteMcuAccessRegWord(sc, 0xF82E, 0xDC00);
1774 MP_WriteMcuAccessRegWord(sc, 0xF830, 0xC602);
1775 MP_WriteMcuAccessRegWord(sc, 0xF832, 0xBE00);
1776 MP_WriteMcuAccessRegWord(sc, 0xF834, 0x0000);
1777 MP_WriteMcuAccessRegWord(sc, 0xF836, 0xC602);
1778 MP_WriteMcuAccessRegWord(sc, 0xF838, 0xBE00);
1779 MP_WriteMcuAccessRegWord(sc, 0xF83A, 0x0000);
1780 MP_WriteMcuAccessRegWord(sc, 0xF83C, 0xC602);
1781 MP_WriteMcuAccessRegWord(sc, 0xF83E, 0xBE00);
1782 MP_WriteMcuAccessRegWord(sc, 0xF840, 0x0000);
1783 MP_WriteMcuAccessRegWord(sc, 0xF842, 0xC602);
1784 MP_WriteMcuAccessRegWord(sc, 0xF844, 0xBE00);
1785 MP_WriteMcuAccessRegWord(sc, 0xF846, 0x0000);
1786 MP_WriteMcuAccessRegWord(sc, 0xF848, 0xC602);
1787 MP_WriteMcuAccessRegWord(sc, 0xF84A, 0xBE00);
1788 MP_WriteMcuAccessRegWord(sc, 0xF84C, 0x0000);
1789 MP_WriteMcuAccessRegWord(sc, 0xF84E, 0xC602);
1790 MP_WriteMcuAccessRegWord(sc, 0xF850, 0xBE00);
1791 MP_WriteMcuAccessRegWord(sc, 0xF852, 0x0000);
1792 MP_WriteMcuAccessRegWord(sc, 0xF854, 0xC602);
1793 MP_WriteMcuAccessRegWord(sc, 0xF856, 0xBE00);
1794 MP_WriteMcuAccessRegWord(sc, 0xF858, 0x0000);
1795
1796 MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000);
1797
1798 MP_WriteMcuAccessRegWord(sc, 0xFC28, 0x0BB3);
1799 break;
1800 case MACFG_68:
1801 case MACFG_69:
1802 DisableMcuBPs(sc);
1803
1804 MP_WriteMcuAccessRegWord(sc, 0xF800, 0xE008);
1805 MP_WriteMcuAccessRegWord(sc, 0xF802, 0xE00F);
1806 MP_WriteMcuAccessRegWord(sc, 0xF804, 0xE011);
1807 MP_WriteMcuAccessRegWord(sc, 0xF806, 0xE047);
1808 MP_WriteMcuAccessRegWord(sc, 0xF808, 0xE049);
1809 MP_WriteMcuAccessRegWord(sc, 0xF80A, 0xE073);
1810 MP_WriteMcuAccessRegWord(sc, 0xF80C, 0xE075);
1811 MP_WriteMcuAccessRegWord(sc, 0xF80E, 0xE077);
1812 MP_WriteMcuAccessRegWord(sc, 0xF810, 0xC707);
1813 MP_WriteMcuAccessRegWord(sc, 0xF812, 0x1D00);
1814 MP_WriteMcuAccessRegWord(sc, 0xF814, 0x8DE2);
1815 MP_WriteMcuAccessRegWord(sc, 0xF816, 0x48C1);
1816 MP_WriteMcuAccessRegWord(sc, 0xF818, 0xC502);
1817 MP_WriteMcuAccessRegWord(sc, 0xF81A, 0xBD00);
1818 MP_WriteMcuAccessRegWord(sc, 0xF81C, 0x00E4);
1819 MP_WriteMcuAccessRegWord(sc, 0xF81E, 0xE0C0);
1820 MP_WriteMcuAccessRegWord(sc, 0xF820, 0xC502);
1821 MP_WriteMcuAccessRegWord(sc, 0xF822, 0xBD00);
1822 MP_WriteMcuAccessRegWord(sc, 0xF824, 0x0216);
1823 MP_WriteMcuAccessRegWord(sc, 0xF826, 0xC634);
1824 MP_WriteMcuAccessRegWord(sc, 0xF828, 0x75C0);
1825 MP_WriteMcuAccessRegWord(sc, 0xF82A, 0x49D3);
1826 MP_WriteMcuAccessRegWord(sc, 0xF82C, 0xF027);
1827 MP_WriteMcuAccessRegWord(sc, 0xF82E, 0xC631);
1828 MP_WriteMcuAccessRegWord(sc, 0xF830, 0x75C0);
1829 MP_WriteMcuAccessRegWord(sc, 0xF832, 0x49D3);
1830 MP_WriteMcuAccessRegWord(sc, 0xF834, 0xF123);
1831 MP_WriteMcuAccessRegWord(sc, 0xF836, 0xC627);
1832 MP_WriteMcuAccessRegWord(sc, 0xF838, 0x75C0);
1833 MP_WriteMcuAccessRegWord(sc, 0xF83A, 0xB405);
1834 MP_WriteMcuAccessRegWord(sc, 0xF83C, 0xC525);
1835 MP_WriteMcuAccessRegWord(sc, 0xF83E, 0x9DC0);
1836 MP_WriteMcuAccessRegWord(sc, 0xF840, 0xC621);
1837 MP_WriteMcuAccessRegWord(sc, 0xF842, 0x75C8);
1838 MP_WriteMcuAccessRegWord(sc, 0xF844, 0x49D5);
1839 MP_WriteMcuAccessRegWord(sc, 0xF846, 0xF00A);
1840 MP_WriteMcuAccessRegWord(sc, 0xF848, 0x49D6);
1841 MP_WriteMcuAccessRegWord(sc, 0xF84A, 0xF008);
1842 MP_WriteMcuAccessRegWord(sc, 0xF84C, 0x49D7);
1843 MP_WriteMcuAccessRegWord(sc, 0xF84E, 0xF006);
1844 MP_WriteMcuAccessRegWord(sc, 0xF850, 0x49D8);
1845 MP_WriteMcuAccessRegWord(sc, 0xF852, 0xF004);
1846 MP_WriteMcuAccessRegWord(sc, 0xF854, 0x75D2);
1847 MP_WriteMcuAccessRegWord(sc, 0xF856, 0x49D9);
1848 MP_WriteMcuAccessRegWord(sc, 0xF858, 0xF111);
1849 MP_WriteMcuAccessRegWord(sc, 0xF85A, 0xC517);
1850 MP_WriteMcuAccessRegWord(sc, 0xF85C, 0x9DC8);
1851 MP_WriteMcuAccessRegWord(sc, 0xF85E, 0xC516);
1852 MP_WriteMcuAccessRegWord(sc, 0xF860, 0x9DD2);
1853 MP_WriteMcuAccessRegWord(sc, 0xF862, 0xC618);
1854 MP_WriteMcuAccessRegWord(sc, 0xF864, 0x75C0);
1855 MP_WriteMcuAccessRegWord(sc, 0xF866, 0x49D4);
1856 MP_WriteMcuAccessRegWord(sc, 0xF868, 0xF003);
1857 MP_WriteMcuAccessRegWord(sc, 0xF86A, 0x49D0);
1858 MP_WriteMcuAccessRegWord(sc, 0xF86C, 0xF104);
1859 MP_WriteMcuAccessRegWord(sc, 0xF86E, 0xC60A);
1860 MP_WriteMcuAccessRegWord(sc, 0xF870, 0xC50E);
1861 MP_WriteMcuAccessRegWord(sc, 0xF872, 0x9DC0);
1862 MP_WriteMcuAccessRegWord(sc, 0xF874, 0xB005);
1863 MP_WriteMcuAccessRegWord(sc, 0xF876, 0xC607);
1864 MP_WriteMcuAccessRegWord(sc, 0xF878, 0x9DC0);
1865 MP_WriteMcuAccessRegWord(sc, 0xF87A, 0xB007);
1866 MP_WriteMcuAccessRegWord(sc, 0xF87C, 0xC602);
1867 MP_WriteMcuAccessRegWord(sc, 0xF87E, 0xBE00);
1868 MP_WriteMcuAccessRegWord(sc, 0xF880, 0x1A06);
1869 MP_WriteMcuAccessRegWord(sc, 0xF882, 0xB400);
1870 MP_WriteMcuAccessRegWord(sc, 0xF884, 0xE86C);
1871 MP_WriteMcuAccessRegWord(sc, 0xF886, 0xA000);
1872 MP_WriteMcuAccessRegWord(sc, 0xF888, 0x01E1);
1873 MP_WriteMcuAccessRegWord(sc, 0xF88A, 0x0200);
1874 MP_WriteMcuAccessRegWord(sc, 0xF88C, 0x9200);
1875 MP_WriteMcuAccessRegWord(sc, 0xF88E, 0xE84C);
1876 MP_WriteMcuAccessRegWord(sc, 0xF890, 0xE004);
1877 MP_WriteMcuAccessRegWord(sc, 0xF892, 0xE908);
1878 MP_WriteMcuAccessRegWord(sc, 0xF894, 0xC502);
1879 MP_WriteMcuAccessRegWord(sc, 0xF896, 0xBD00);
1880 MP_WriteMcuAccessRegWord(sc, 0xF898, 0x0B58);
1881 MP_WriteMcuAccessRegWord(sc, 0xF89A, 0xB407);
1882 MP_WriteMcuAccessRegWord(sc, 0xF89C, 0xB404);
1883 MP_WriteMcuAccessRegWord(sc, 0xF89E, 0x2195);
1884 MP_WriteMcuAccessRegWord(sc, 0xF8A0, 0x25BD);
1885 MP_WriteMcuAccessRegWord(sc, 0xF8A2, 0x9BE0);
1886 MP_WriteMcuAccessRegWord(sc, 0xF8A4, 0x1C1C);
1887 MP_WriteMcuAccessRegWord(sc, 0xF8A6, 0x484F);
1888 MP_WriteMcuAccessRegWord(sc, 0xF8A8, 0x9CE2);
1889 MP_WriteMcuAccessRegWord(sc, 0xF8AA, 0x72E2);
1890 MP_WriteMcuAccessRegWord(sc, 0xF8AC, 0x49AE);
1891 MP_WriteMcuAccessRegWord(sc, 0xF8AE, 0xF1FE);
1892 MP_WriteMcuAccessRegWord(sc, 0xF8B0, 0x0B00);
1893 MP_WriteMcuAccessRegWord(sc, 0xF8B2, 0xF116);
1894 MP_WriteMcuAccessRegWord(sc, 0xF8B4, 0xC71C);
1895 MP_WriteMcuAccessRegWord(sc, 0xF8B6, 0xC419);
1896 MP_WriteMcuAccessRegWord(sc, 0xF8B8, 0x9CE0);
1897 MP_WriteMcuAccessRegWord(sc, 0xF8BA, 0x1C13);
1898 MP_WriteMcuAccessRegWord(sc, 0xF8BC, 0x484F);
1899 MP_WriteMcuAccessRegWord(sc, 0xF8BE, 0x9CE2);
1900 MP_WriteMcuAccessRegWord(sc, 0xF8C0, 0x74E2);
1901 MP_WriteMcuAccessRegWord(sc, 0xF8C2, 0x49CE);
1902 MP_WriteMcuAccessRegWord(sc, 0xF8C4, 0xF1FE);
1903 MP_WriteMcuAccessRegWord(sc, 0xF8C6, 0xC412);
1904 MP_WriteMcuAccessRegWord(sc, 0xF8C8, 0x9CE0);
1905 MP_WriteMcuAccessRegWord(sc, 0xF8CA, 0x1C13);
1906 MP_WriteMcuAccessRegWord(sc, 0xF8CC, 0x484F);
1907 MP_WriteMcuAccessRegWord(sc, 0xF8CE, 0x9CE2);
1908 MP_WriteMcuAccessRegWord(sc, 0xF8D0, 0x74E2);
1909 MP_WriteMcuAccessRegWord(sc, 0xF8D2, 0x49CE);
1910 MP_WriteMcuAccessRegWord(sc, 0xF8D4, 0xF1FE);
1911 MP_WriteMcuAccessRegWord(sc, 0xF8D6, 0xC70C);
1912 MP_WriteMcuAccessRegWord(sc, 0xF8D8, 0x74F8);
1913 MP_WriteMcuAccessRegWord(sc, 0xF8DA, 0x48C3);
1914 MP_WriteMcuAccessRegWord(sc, 0xF8DC, 0x8CF8);
1915 MP_WriteMcuAccessRegWord(sc, 0xF8DE, 0xB004);
1916 MP_WriteMcuAccessRegWord(sc, 0xF8E0, 0xB007);
1917 MP_WriteMcuAccessRegWord(sc, 0xF8E2, 0xC502);
1918 MP_WriteMcuAccessRegWord(sc, 0xF8E4, 0xBD00);
1919 MP_WriteMcuAccessRegWord(sc, 0xF8E6, 0x0F24);
1920 MP_WriteMcuAccessRegWord(sc, 0xF8E8, 0x0481);
1921 MP_WriteMcuAccessRegWord(sc, 0xF8EA, 0x0C81);
1922 MP_WriteMcuAccessRegWord(sc, 0xF8EC, 0xDE24);
1923 MP_WriteMcuAccessRegWord(sc, 0xF8EE, 0xE000);
1924 MP_WriteMcuAccessRegWord(sc, 0xF8F0, 0xC602);
1925 MP_WriteMcuAccessRegWord(sc, 0xF8F2, 0xBE00);
1926 MP_WriteMcuAccessRegWord(sc, 0xF8F4, 0x0CA4);
1927 MP_WriteMcuAccessRegWord(sc, 0xF8F6, 0xC502);
1928 MP_WriteMcuAccessRegWord(sc, 0xF8F8, 0xBD00);
1929 MP_WriteMcuAccessRegWord(sc, 0xF8FA, 0x0000);
1930 MP_WriteMcuAccessRegWord(sc, 0xF8FC, 0xC602);
1931 MP_WriteMcuAccessRegWord(sc, 0xF8FE, 0xBE00);
1932 MP_WriteMcuAccessRegWord(sc, 0xF900, 0x0000);
1933
1934 MP_WriteMcuAccessRegWord(sc, 0xFC26, 0x8000);
1935
1936 MP_WriteMcuAccessRegWord(sc, 0xFC28, 0x00E2);
1937 MP_WriteMcuAccessRegWord(sc, 0xFC2A, 0x0210);
1938 MP_WriteMcuAccessRegWord(sc, 0xFC2C, 0x1A04);
1939 MP_WriteMcuAccessRegWord(sc, 0xFC2E, 0x0B26);
1940 MP_WriteMcuAccessRegWord(sc, 0xFC30, 0x0F02);
1941 MP_WriteMcuAccessRegWord(sc, 0xFC32, 0x0CA0);
1942
1943 if (sc->re_device_id == RT_DEVICEID_8136)
1944 MP_WriteMcuAccessRegWord(sc, 0xFC38, 0x0033);
1945 else
1946 MP_WriteMcuAccessRegWord(sc, 0xFC38, 0x003F);
1947
1948 break;
1949 }
1950 }
1951
1952 #define ISRIMR_DASH_TYPE2_TX_DISABLE_IDLE BIT_5
1953 static void Dash2DisableTx(struct re_softc *sc)
1954 {
1955 //if (!re_check_dash(sc)) return;
1956
1957 if (sc->re_type == MACFG_61 || sc->re_type == MACFG_62 ||
1958 sc->re_type == MACFG_67) {
1959 u_int16_t WaitCnt;
1960 u_int8_t TmpUchar;
1961
1962 //Disable oob Tx
1963 CSR_WRITE_1(sc, RE_IBCR2, CSR_READ_1(sc, RE_IBCR2) & ~(BIT_0));
1964 WaitCnt = 0;
1965
1966 //wait oob tx disable
1967 do {
1968 TmpUchar = CSR_READ_1(sc, RE_IBISR0);
1969
1970 if (TmpUchar & ISRIMR_DASH_TYPE2_TX_DISABLE_IDLE) {
1971 break;
1972 }
1973
1974 DELAY(50);
1975 WaitCnt++;
1976 } while(WaitCnt < 2000);
1977
1978 //Clear ISRIMR_DASH_TYPE2_TX_DISABLE_IDLE
1979 CSR_WRITE_1(sc, RE_IBISR0, CSR_READ_1(sc, RE_IBISR0) | ISRIMR_DASH_TYPE2_TX_DISABLE_IDLE);
1980 }
1981 }
1982
1983 static void Dash2DisableRx(struct re_softc *sc)
1984 {
1985 //if (!re_check_dash(sc)) return;
1986
1987 if (sc->re_type == MACFG_61 || sc->re_type == MACFG_62 ||
1988 sc->re_type == MACFG_67)
1989 CSR_WRITE_1(sc, RE_IBCR0, CSR_READ_1(sc, RE_IBCR0) & ~(BIT_0));
1990 }
1991
1992 static void Dash2DisableTxRx(struct re_softc *sc)
1993 {
1994 if (sc->re_type == MACFG_61 || sc->re_type == MACFG_62 ||
1995 sc->re_type == MACFG_67) {
1996 Dash2DisableTx(sc);
1997 Dash2DisableRx(sc);
1998 }
1999 }
2000
2001 static void re_disable_now_is_oob(struct re_softc *sc)
2002 {
2003 if (sc->re_hw_supp_now_is_oob_ver == 1)
2004 CSR_WRITE_1(sc, RE_MCU_CMD, CSR_READ_1(sc, RE_MCU_CMD) & ~RE_NOW_IS_OOB);
2005 }
2006
2007 static void re_exit_oob(struct re_softc *sc)
2008 {
2009 u_int16_t data16;
2010 int i;
2011
2012 CSR_WRITE_1(sc, RE_EECMD, RE_EEMODE_OFF);
2013
2014 switch(sc->re_type) {
2015 case MACFG_61:
2016 case MACFG_62:
2017 case MACFG_67:
2018 Dash2DisableTxRx(sc);
2019 break;
2020 }
2021
2022 switch(sc->re_type) {
2023 case MACFG_61:
2024 case MACFG_62:
2025 case MACFG_67:
2026 case MACFG_63:
2027 case MACFG_64:
2028 case MACFG_65:
2029 case MACFG_66:
2030 re_driver_start(sc);
2031 break;
2032 }
2033
2034 switch(sc->re_type) {
2035 case MACFG_56:
2036 case MACFG_57:
2037 case MACFG_58:
2038 case MACFG_59:
2039 case MACFG_60:
2040 case MACFG_61:
2041 case MACFG_62:
2042 case MACFG_67:
2043 case MACFG_68:
2044 case MACFG_69:
2045 CSR_WRITE_1(sc, 0xF2, CSR_READ_1(sc, 0xF2) | BIT_3);
2046 DELAY(2000);
2047
2048 for (i = 0; i < 10; i++) {
2049 DELAY(100);
2050 if (CSR_READ_4(sc, RE_TXCFG) & BIT_11)
2051 break;
2052 }
2053
2054 if (CSR_READ_1(sc, RE_COMMAND) & (RE_CMD_TX_ENB | RE_CMD_RX_ENB)) {
2055 DELAY(100);
2056 CSR_WRITE_1(sc, RE_COMMAND, CSR_READ_1(sc, RE_COMMAND) & ~(RE_CMD_TX_ENB | RE_CMD_RX_ENB));
2057 }
2058
2059 for (i = 0; i < 10; i++) {
2060 DELAY(100);
2061 if ((CSR_READ_1(sc, RE_MCU_CMD) & (RE_TXFIFO_EMPTY | RE_RXFIFO_EMPTY)) == (RE_TXFIFO_EMPTY | RE_RXFIFO_EMPTY))
2062 break;
2063
2064 }
2065 break;
2066 }
2067
2068 //Disable realwow function
2069 switch (sc->re_type) {
2070 case MACFG_50:
2071 case MACFG_51:
2072 CSR_WRITE_4(sc, RE_MCUACCESS, 0xE5A90000);
2073 CSR_WRITE_4(sc, RE_MCUACCESS, 0xF2100010);
2074 break;
2075 case MACFG_52:
2076 CSR_WRITE_4(sc, RE_MCUACCESS, 0xE5A90000);
2077 CSR_WRITE_4(sc, RE_MCUACCESS, 0xE4640000);
2078 CSR_WRITE_4(sc, RE_MCUACCESS, 0xF2100010);
2079 break;
2080 case MACFG_56:
2081 case MACFG_57:
2082 CSR_WRITE_4(sc, RE_MCUACCESS, 0x605E0000);
2083 CSR_WRITE_4(sc, RE_MCUACCESS, (0xE05E << 16) | (CSR_READ_4(sc, RE_MCUACCESS) & 0xFFFE));
2084 CSR_WRITE_4(sc, RE_MCUACCESS, 0xE9720000);
2085 CSR_WRITE_4(sc, RE_MCUACCESS, 0xF2140010);
2086 break;
2087 case MACFG_60:
2088 CSR_WRITE_4(sc, RE_MCUACCESS, 0xE05E00FF);
2089 CSR_WRITE_4(sc, RE_MCUACCESS, 0xE9720000);
2090 MP_WriteMcuAccessRegWord(sc, 0xE428, 0x0010);
2091 break;
2092 }
2093
2094 if (sc->re_hw_supp_now_is_oob_ver >0)
2095 re_disable_now_is_oob(sc);
2096
2097 switch(sc->re_type) {
2098 case MACFG_52:
2099 for (i = 0; i < 10; i++) {
2100 DELAY(100);
2101 if (CSR_READ_2(sc, 0xD2) & BIT_9)
2102 break;
2103 }
2104
2105 data16 = MP_ReadMcuAccessRegWord(sc, 0xD4DE) | BIT_15;
2106 MP_WriteMcuAccessRegWord(sc, 0xD4DE, data16);
2107
2108 for (i = 0; i < 10; i++) {
2109 DELAY(100);
2110 if (CSR_READ_2(sc, 0xD2) & BIT_9)
2111 break;
2112 }
2113 break;
2114 case MACFG_56:
2115 case MACFG_57:
2116 case MACFG_58:
2117 case MACFG_59:
2118 case MACFG_60:
2119 case MACFG_61:
2120 case MACFG_62:
2121 case MACFG_67:
2122 case MACFG_68:
2123 case MACFG_69:
2124 data16 = MP_ReadMcuAccessRegWord(sc, 0xE8DE) & ~BIT_14;
2125 MP_WriteMcuAccessRegWord(sc, 0xE8DE, data16);
2126 for (i = 0; i < 10; i++) {
2127 DELAY(100);
2128 if (CSR_READ_2(sc, 0xD2) & BIT_9)
2129 break;
2130 }
2131
2132 data16 = MP_ReadMcuAccessRegWord(sc, 0xE8DE) | BIT_15;
2133 MP_WriteMcuAccessRegWord(sc, 0xE8DE, data16);
2134
2135 for (i = 0; i < 10; i++) {
2136 DELAY(100);
2137 if (CSR_READ_2(sc, 0xD2) & BIT_9)
2138 break;
2139 }
2140 break;
2141 }
2142
2143 //wait ups resume (phy state 2)
2144 switch(sc->re_type) {
2145 case MACFG_68:
2146 case MACFG_69:
2147 if (re_is_ups_resume(sc)) {
2148 re_wait_phy_ups_resume(sc, 2);
2149 re_clear_ups_resume_bit(sc);
2150 }
2151 break;
2152 };
2153
2154 /*
2155 * Config MAC MCU
2156 */
2157 re_hw_mac_mcu_config(sc);
2158 }
2159
2160 static void re_hw_init(struct re_softc *sc)
2161 {
2162 /*
2163 * disable EDT.
2164 */
2165 switch(sc->re_type) {
2166 case MACFG_16:
2167 case MACFG_17:
2168 case MACFG_18:
2169 case MACFG_19:
2170 case MACFG_41:
2171 CSR_WRITE_1(sc, 0xF4, CSR_READ_1(sc, 0xF4) & ~(BIT_0|BIT_1));
2172 break;
2173 case MACFG_36:
2174 case MACFG_37:
2175 case MACFG_38:
2176 case MACFG_39:
2177 case MACFG_42:
2178 case MACFG_43:
2179 case MACFG_50:
2180 case MACFG_51:
2181 case MACFG_54:
2182 case MACFG_55:
2183 CSR_WRITE_1(sc, 0xF2, CSR_READ_1(sc, 0xF2) & ~(BIT_0|BIT_1|BIT_2));
2184 break;
2185 }
2186
2187 switch(sc->re_type) {
2188 case MACFG_5:
2189 if (CSR_READ_1(sc, RE_CFG2) & 1) {
2190 CSR_WRITE_4(sc, 0x7C, 0x000FFFFF);
2191 } else {
2192 CSR_WRITE_4(sc, 0x7C, 0x000FFF00);
2193 }
2194 break;
2195 case MACFG_6:
2196 if (CSR_READ_1(sc, RE_CFG2) & 1) {
2197 CSR_WRITE_4(sc, 0x7C, 0x003FFFFF);
2198 } else {
2199 CSR_WRITE_4(sc, 0x7C, 0x003FFF00);
2200 }
2201 break;
2202 }
2203
2204 switch(sc->re_type) {
2205 case MACFG_33:
2206 case MACFG_36:
2207 case MACFG_37:
2208 CSR_WRITE_1(sc, 0xF3, CSR_READ_1(sc, 0xF3) | BIT_2);
2209 break;
2210 }
2211
2212 switch(sc->re_type) {
2213 case MACFG_36:
2214 case MACFG_37:
2215 case MACFG_38:
2216 case MACFG_39:
2217 case MACFG_42:
2218 case MACFG_43:
2219 case MACFG_50:
2220 case MACFG_51:
2221 case MACFG_52:
2222 case MACFG_53:
2223 case MACFG_54:
2224 case MACFG_55:
2225 case MACFG_56:
2226 case MACFG_57:
2227 case MACFG_58:
2228 case MACFG_59:
2229 case MACFG_60:
2230 case MACFG_61:
2231 case MACFG_62:
2232 case MACFG_67:
2233 case MACFG_68:
2234 case MACFG_69:
2235 CSR_WRITE_1(sc, RE_EECMD, RE_EEMODE_WRITECFG);
2236 CSR_WRITE_1(sc, RE_CFG5, CSR_READ_1(sc, RE_CFG5) & ~BIT_0);
2237 CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2) & ~BIT_7);
2238 CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2) | BIT_5);
2239 CSR_WRITE_1(sc, RE_EECMD, RE_EEMODE_OFF);
2240 break;
2241 }
2242
2243 if (sc->re_if_flags & RL_FLAG_PCIE) {
2244 uint32_t Data32;
2245 //Set PCIE uncorrectable error status mask pcie 0x108
2246 Data32 = MP_ReadPciEConfigSpace(sc, 0xF108);
2247 Data32 |= BIT_20;
2248 MP_WritePciEConfigSpace(sc, 0xF108, Data32);
2249 }
2250 }
2251
2252 static void re_get_hw_mac_address(struct re_softc *sc, u_int8_t *eaddr)
2253 {
2254 u_int16_t re_eeid = 0;
2255 u_int8_t read_from_macio = 0;
2256 int i;
2257
2258 switch(sc->re_type) {
2259 case MACFG_50:
2260 case MACFG_51:
2261 case MACFG_52:
2262 case MACFG_53:
2263 case MACFG_56:
2264 case MACFG_57:
2265 case MACFG_58:
2266 case MACFG_59:
2267 case MACFG_60:
2268 case MACFG_61:
2269 case MACFG_62:
2270 case MACFG_67:
2271 case MACFG_68:
2272 case MACFG_69:
2273 *(u_int32_t *)&eaddr[0]= re_eri_read(sc, 0xE0, 4, ERIAR_ExGMAC);
2274 *(u_int16_t *)&eaddr[4] = (u_int16_t)re_eri_read(sc, 0xE4, 4, ERIAR_ExGMAC);
2275 break;
2276 case MACFG_63:
2277 case MACFG_64:
2278 case MACFG_65:
2279 case MACFG_66:
2280 read_from_macio = 1;
2281 break;
2282 default:
2283 re_read_eeprom(sc, (caddr_t)&re_eeid, RE_EE_ID, 1, 0);
2284 if (re_eeid == 0x8129)
2285 re_read_eeprom(sc, (caddr_t)&eaddr[0], RE_EE_EADDR, 3, 0);
2286 else
2287 read_from_macio = 1;
2288 break;
2289 }
2290
2291 if (eaddr[0] == 0x00 &&
2292 eaddr[1] == 0x00 &&
2293 eaddr[2] == 0x00 &&
2294 eaddr[3] == 0x00 &&
2295 eaddr[4] == 0x00 &&
2296 eaddr[5] == 0x00) {
2297 read_from_macio = 1;
2298 }
2299
2300 if (eaddr[0] == 0xFF &&
2301 eaddr[1] == 0xFF &&
2302 eaddr[2] == 0xFF &&
2303 eaddr[3] == 0xFF &&
2304 eaddr[4] == 0xFF &&
2305 eaddr[5] == 0xFF) {
2306 read_from_macio = 1;
2307 }
2308
2309 if (read_from_macio) {
2310 for (i = 0; i < ETHER_ADDR_LEN; i++)
2311 eaddr[i] = CSR_READ_1(sc, RE_IDR0 + i);
2312 }
2313
2314 switch (sc->re_type) {
2315 case MACFG_36:
2316 case MACFG_37:
2317 case MACFG_42:
2318 case MACFG_43:
2319 case MACFG_54:
2320 case MACFG_55:
2321 for (i = 0; i < ETHER_ADDR_LEN; i++)
2322 CSR_WRITE_1(sc, RE_SecMAC0 + i, eaddr[i]);
2323 break;
2324 }
2325 }
2326
2327 static int re_check_mac_version(struct re_softc *sc)
2328 {
2329 device_t dev = sc->dev;
2330 int error = 0;
2331
2332 switch(CSR_READ_4(sc, RE_TXCFG) & 0xFCF00000) {
2333 case 0x00800000:
2334 case 0x04000000:
2335 sc->re_type = MACFG_3;
2336 sc->max_jumbo_frame_size = Jumbo_Frame_7k;
2337 CSR_WRITE_4(sc, RE_RXCFG, 0xFF00);
2338 break;
2339 case 0x10000000:
2340 sc->re_type = MACFG_4;
2341 sc->max_jumbo_frame_size = Jumbo_Frame_7k;
2342 CSR_WRITE_4(sc, RE_RXCFG, 0xFF00);
2343 break;
2344 case 0x18000000:
2345 sc->re_type = MACFG_5;
2346 sc->max_jumbo_frame_size = Jumbo_Frame_7k;
2347 CSR_WRITE_4(sc, RE_RXCFG, 0xFF00);
2348 break;
2349 case 0x98000000:
2350 sc->re_type = MACFG_6;
2351 sc->max_jumbo_frame_size = Jumbo_Frame_7k;
2352 CSR_WRITE_4(sc, RE_RXCFG, 0xFF00);
2353 break;
2354 case 0x34000000:
2355 case 0xB4000000:
2356 sc->re_type = MACFG_11;
2357 sc->max_jumbo_frame_size = ETHERMTU;
2358 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
2359 break;
2360 case 0x34200000:
2361 case 0xB4200000:
2362 sc->re_type = MACFG_12;
2363 sc->max_jumbo_frame_size = ETHERMTU;
2364 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
2365 break;
2366 case 0x34300000:
2367 case 0xB4300000:
2368 sc->re_type = MACFG_13;
2369 sc->max_jumbo_frame_size = ETHERMTU;
2370 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
2371 break;
2372 case 0x34900000:
2373 case 0x24900000:
2374 sc->re_type = MACFG_14;
2375 sc->max_jumbo_frame_size = ETHERMTU;
2376 sc->re_if_flags |= RL_FLAG_DESCV2;
2377 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
2378 break;
2379 case 0x34A00000:
2380 case 0x24A00000:
2381 sc->re_type = MACFG_15;
2382 sc->max_jumbo_frame_size = ETHERMTU;
2383 sc->re_if_flags |= RL_FLAG_DESCV2;
2384 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
2385 break;
2386 case 0x34B00000:
2387 case 0x24B00000:
2388 sc->re_type = MACFG_16;
2389 sc->max_jumbo_frame_size = ETHERMTU;
2390 sc->re_if_flags |= RL_FLAG_DESCV2;
2391 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
2392 break;
2393 case 0x34C00000:
2394 case 0x24C00000:
2395 sc->re_type = MACFG_17;
2396 sc->max_jumbo_frame_size = ETHERMTU;
2397 sc->re_if_flags |= RL_FLAG_DESCV2;
2398 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
2399 break;
2400 case 0x34D00000:
2401 case 0x24D00000:
2402 sc->re_type = MACFG_18;
2403 sc->max_jumbo_frame_size = ETHERMTU;
2404 sc->re_if_flags |= RL_FLAG_DESCV2;
2405 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
2406 break;
2407 case 0x34E00000:
2408 case 0x24E00000:
2409 sc->re_type = MACFG_19;
2410 sc->max_jumbo_frame_size = ETHERMTU;
2411 sc->re_if_flags |= RL_FLAG_DESCV2;
2412 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
2413 break;
2414 case 0x30000000:
2415 sc->re_type = MACFG_21;
2416 sc->max_jumbo_frame_size = Jumbo_Frame_4k;
2417 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
2418 break;
2419 case 0x38000000:
2420 sc->re_type = MACFG_22;
2421 sc->max_jumbo_frame_size = Jumbo_Frame_4k;
2422 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
2423 break;
2424 case 0x38500000:
2425 case 0xB8500000:
2426 case 0x38700000:
2427 case 0xB8700000:
2428 sc->re_type = MACFG_23;
2429 sc->max_jumbo_frame_size = Jumbo_Frame_4k;
2430 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
2431 break;
2432 case 0x3C000000:
2433 sc->re_type = MACFG_24;
2434 sc->max_jumbo_frame_size = Jumbo_Frame_6k;
2435 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
2436 CSR_WRITE_4(sc, RE_RXCFG, 0xC700);
2437 break;
2438 case 0x3C200000:
2439 sc->re_type = MACFG_25;
2440 sc->max_jumbo_frame_size = Jumbo_Frame_6k;
2441 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
2442 CSR_WRITE_4(sc, RE_RXCFG, 0xC700);
2443 break;
2444 case 0x3C400000:
2445 sc->re_type = MACFG_26;
2446 sc->max_jumbo_frame_size = Jumbo_Frame_6k;
2447 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
2448 CSR_WRITE_4(sc, RE_RXCFG, 0xC700);
2449 break;
2450 case 0x3C900000:
2451 sc->re_type = MACFG_27;
2452 sc->max_jumbo_frame_size = Jumbo_Frame_6k;
2453 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
2454 CSR_WRITE_4(sc, RE_RXCFG, 0xC700);
2455 break;
2456 case 0x3CB00000:
2457 sc->re_type = MACFG_28;
2458 sc->max_jumbo_frame_size = Jumbo_Frame_6k;
2459 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
2460 CSR_WRITE_4(sc, RE_RXCFG, 0xC700);
2461 break;
2462 case 0x28100000:
2463 sc->re_type = MACFG_31;
2464 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
2465 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
2466 CSR_WRITE_4(sc, RE_RXCFG, 0x8700);
2467 break;
2468 case 0x28200000:
2469 sc->re_type = MACFG_32;
2470 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
2471 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
2472 CSR_WRITE_4(sc, RE_RXCFG, 0x8700);
2473 break;
2474 case 0x28300000:
2475 sc->re_type = MACFG_33;
2476 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
2477 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
2478 CSR_WRITE_4(sc, RE_RXCFG, 0x8700);
2479 break;
2480 case 0x2C100000:
2481 sc->re_type = MACFG_36;
2482 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
2483 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
2484 CSR_WRITE_4(sc, RE_RXCFG, 0x8700);
2485 break;
2486 case 0x2C200000:
2487 sc->re_type = MACFG_37;
2488 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
2489 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
2490 CSR_WRITE_4(sc, RE_RXCFG, 0x8700);
2491 break;
2492 case 0x2C800000:
2493 sc->re_type = MACFG_38;
2494 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
2495 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
2496 CSR_WRITE_4(sc, RE_RXCFG, 0xBF00);
2497 break;
2498 case 0x2C900000:
2499 sc->re_type = MACFG_39;
2500 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
2501 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
2502 CSR_WRITE_4(sc, RE_RXCFG, 0xBF00);
2503 break;
2504 case 0x24000000:
2505 sc->re_type = MACFG_41;
2506 sc->max_jumbo_frame_size = ETHERMTU;
2507 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM ;
2508 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
2509 break;
2510 case 0x40900000:
2511 sc->re_type = MACFG_42;
2512 sc->max_jumbo_frame_size = ETHERMTU;
2513 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM ;
2514 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
2515 break;
2516 case 0x40A00000:
2517 case 0x40B00000:
2518 case 0x40C00000:
2519 sc->re_type = MACFG_43;
2520 sc->max_jumbo_frame_size = ETHERMTU;
2521 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM ;
2522 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
2523 break;
2524 case 0x48000000:
2525 sc->re_type = MACFG_50;
2526 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
2527 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
2528 CSR_WRITE_4(sc, RE_RXCFG, 0xBF00);
2529 break;
2530 case 0x48100000:
2531 sc->re_type = MACFG_51;
2532 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
2533 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
2534 CSR_WRITE_4(sc, RE_RXCFG, 0xBF00);
2535 break;
2536 case 0x48800000:
2537 sc->re_type = MACFG_52;
2538 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
2539 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
2540 CSR_WRITE_4(sc, RE_RXCFG, 0xBF00);
2541 break;
2542 case 0x44000000:
2543 sc->re_type = MACFG_53;
2544 sc->max_jumbo_frame_size = ETHERMTU;
2545 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
2546 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
2547 break;
2548 case 0x44800000:
2549 sc->re_type = MACFG_54;
2550 sc->max_jumbo_frame_size = ETHERMTU;
2551 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
2552 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
2553 break;
2554 case 0x44900000:
2555 sc->re_type = MACFG_55;
2556 sc->max_jumbo_frame_size = ETHERMTU;
2557 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
2558 CSR_WRITE_4(sc, RE_RXCFG, 0xE700);
2559 break;
2560 case 0x4C000000:
2561 sc->re_type = MACFG_56;
2562 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
2563 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
2564 CSR_WRITE_4(sc, RE_RXCFG, 0xCF00);
2565 break;
2566 case 0x4C100000:
2567 sc->re_type = MACFG_57;
2568 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
2569 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
2570 CSR_WRITE_4(sc, RE_RXCFG, 0xCF00);
2571 break;
2572 case 0x50800000:
2573 sc->re_type = MACFG_58;
2574 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
2575 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
2576 CSR_WRITE_4(sc, RE_RXCFG, 0xCF00);
2577 break;
2578 case 0x50900000:
2579 sc->re_type = MACFG_59;
2580 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
2581 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
2582 CSR_WRITE_4(sc, RE_RXCFG, 0xCF00);
2583 break;
2584 case 0x5C800000:
2585 sc->re_type = MACFG_60;
2586 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
2587 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
2588 CSR_WRITE_4(sc, RE_RXCFG, 0xCF00);
2589 break;
2590 case 0x50000000:
2591 sc->re_type = MACFG_61;
2592 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
2593 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
2594 CSR_WRITE_4(sc, RE_RXCFG, 0xCF00);
2595 break;
2596 case 0x50100000:
2597 sc->re_type = MACFG_62;
2598 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
2599 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
2600 CSR_WRITE_4(sc, RE_RXCFG, 0xCF00);
2601 break;
2602 case 0x50200000:
2603 sc->re_type = MACFG_67;
2604 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
2605 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
2606 CSR_WRITE_4(sc, RE_RXCFG, 0xCF00);
2607 break;
2608 case 0x28800000:
2609 sc->re_type = MACFG_63;
2610 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
2611 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
2612 CSR_WRITE_4(sc, RE_RXCFG, 0x8700);
2613 break;
2614 case 0x28900000:
2615 sc->re_type = MACFG_64;
2616 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
2617 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
2618 CSR_WRITE_4(sc, RE_RXCFG, 0x8700);
2619 break;
2620 case 0x28A00000:
2621 sc->re_type = MACFG_65;
2622 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
2623 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
2624 CSR_WRITE_4(sc, RE_RXCFG, 0x8700);
2625 break;
2626 case 0x28B00000:
2627 sc->re_type = MACFG_66;
2628 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
2629 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM;
2630 CSR_WRITE_4(sc, RE_RXCFG, 0x8700);
2631 break;
2632 case 0x54000000:
2633 sc->re_type = MACFG_68;
2634 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
2635 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
2636 CSR_WRITE_4(sc, RE_RXCFG, 0xCF00);
2637 break;
2638 case 0x54100000:
2639 sc->re_type = MACFG_69;
2640 sc->max_jumbo_frame_size = Jumbo_Frame_9k;
2641 sc->re_if_flags |= RL_FLAG_DESCV2 | RL_FLAG_PHYWAKE_PM | RL_FLAG_MAGIC_PACKET_V2;
2642 CSR_WRITE_4(sc, RE_RXCFG, 0xCF00);
2643 break;
2644 default:
2645 device_printf(dev,"unknown device\n");
2646 sc->re_type = MACFG_FF;
2647 error = ENXIO;
2648 break;
2649 }
2650
2651 switch(sc->re_device_id) {
2652 case RT_DEVICEID_8169:
2653 case RT_DEVICEID_8169SC:
2654 case RT_DEVICEID_8168:
2655 case RT_DEVICEID_8161:
2656 //do nothing
2657 break;
2658 default:
2659 sc->max_jumbo_frame_size = ETHERMTU;
2660 break;
2661 }
2662
2663 return error;
2664 }
2665
2666 static void re_init_software_variable(struct re_softc *sc)
2667 {
2668 switch(sc->re_device_id) {
2669 case RT_DEVICEID_8168:
2670 case RT_DEVICEID_8161:
2671 case RT_DEVICEID_8136:
2672 sc->re_if_flags |= RL_FLAG_PCIE;
2673 break;
2674 }
2675
2676 sc->re_rx_mbuf_sz = sc->max_jumbo_frame_size + ETHER_VLAN_ENCAP_LEN + ETHER_HDR_LEN + ETHER_CRC_LEN + RE_ETHER_ALIGN + 1;
2677
2678 if (sc->re_rx_mbuf_sz > MJUM9BYTES) {
2679 sc->max_jumbo_frame_size -= (sc->re_rx_mbuf_sz - MJUM9BYTES);
2680 sc->re_rx_mbuf_sz = MJUM9BYTES;
2681 }
2682
2683 switch(sc->re_type) {
2684 case MACFG_69: {
2685 u_int16_t ioffset_p3, ioffset_p2, ioffset_p1, ioffset_p0;
2686 u_int16_t TmpUshort;
2687
2688 MP_WriteMcuAccessRegWord(sc, 0xDD02, 0x807D);
2689
2690 TmpUshort = MP_ReadMcuAccessRegWord(sc, 0xDD02);
2691 ioffset_p3 = ((TmpUshort & BIT_7) >>7);
2692 ioffset_p3 <<= 3;
2693 TmpUshort = MP_ReadMcuAccessRegWord(sc, 0xDD00);
2694
2695 ioffset_p3 |= ((TmpUshort & (BIT_15 | BIT_14 | BIT_13))>>13);
2696
2697 ioffset_p2 = ((TmpUshort & (BIT_12|BIT_11|BIT_10|BIT_9))>>9);
2698 ioffset_p1 = ((TmpUshort & (BIT_8|BIT_7|BIT_6|BIT_5))>>5);
2699
2700 ioffset_p0 = ((TmpUshort & BIT_4) >>4);
2701 ioffset_p0 <<= 3;
2702 ioffset_p0 |= (TmpUshort & (BIT_2| BIT_1 | BIT_0));
2703
2704 if ((ioffset_p3 == 0x0F) && (ioffset_p2 == 0x0F) && (ioffset_p1 == 0x0F) && (ioffset_p0 == 0x0F)) {
2705 sc->RequireAdcBiasPatch = FALSE;
2706 } else {
2707 sc->RequireAdcBiasPatch = TRUE;
2708 sc->AdcBiasPatchIoffset = (ioffset_p3<<12)|(ioffset_p2<<8)|(ioffset_p1<<4)|(ioffset_p0);
2709 }
2710 }
2711 break;
2712 }
2713
2714 switch(sc->re_type) {
2715 case MACFG_68:
2716 case MACFG_69: {
2717 u_int16_t rg_saw_cnt;
2718
2719 MP_WritePhyUshort(sc, 0x1F, 0x0C42);
2720 rg_saw_cnt = MP_ReadPhyUshort(sc, 0x13);
2721 rg_saw_cnt &= ~(BIT_15|BIT_14);
2722 MP_WritePhyUshort(sc, 0x1F, 0x0000);
2723
2724 if (rg_saw_cnt > 0) {
2725 sc->SwrCnt1msIni = 16000000/rg_saw_cnt;
2726 sc->SwrCnt1msIni &= 0x0FFF;
2727
2728 sc->RequireAdjustUpsTxLinkPulseTiming = TRUE;
2729 }
2730 }
2731 break;
2732 }
2733
2734 switch(sc->re_type) {
2735 case MACFG_31:
2736 case MACFG_32:
2737 case MACFG_33:
2738 case MACFG_36:
2739 case MACFG_37:
2740 case MACFG_38:
2741 case MACFG_39:
2742 case MACFG_42:
2743 case MACFG_43:
2744 case MACFG_50:
2745 case MACFG_51:
2746 case MACFG_52:
2747 case MACFG_53:
2748 case MACFG_54:
2749 case MACFG_55:
2750 case MACFG_56:
2751 case MACFG_57:
2752 case MACFG_58:
2753 case MACFG_59:
2754 case MACFG_60:
2755 case MACFG_61:
2756 case MACFG_62:
2757 case MACFG_63:
2758 case MACFG_64:
2759 case MACFG_65:
2760 case MACFG_66:
2761 case MACFG_67:
2762 case MACFG_68:
2763 case MACFG_69:
2764 sc->re_hw_enable_msi_msix = TRUE;
2765 break;
2766 }
2767
2768 switch(sc->re_type) {
2769 case MACFG_3:
2770 case MACFG_4:
2771 case MACFG_5:
2772 case MACFG_6:
2773 case MACFG_11:
2774 case MACFG_12:
2775 case MACFG_13:
2776 case MACFG_21:
2777 case MACFG_22:
2778 case MACFG_23:
2779 case MACFG_24:
2780 case MACFG_25:
2781 case MACFG_26:
2782 case MACFG_27:
2783 case MACFG_28:
2784 case MACFG_41:
2785 case MACFG_42:
2786 case MACFG_43:
2787 case MACFG_54:
2788 case MACFG_55:
2789 sc->re_coalesce_tx_pkt = TRUE;
2790 break;
2791 }
2792
2793 switch(sc->re_type) {
2794 case MACFG_36:
2795 case MACFG_37:
2796 case MACFG_38:
2797 case MACFG_39:
2798 case MACFG_42:
2799 case MACFG_43:
2800 case MACFG_50:
2801 case MACFG_51:
2802 case MACFG_52:
2803 case MACFG_53:
2804 case MACFG_54:
2805 case MACFG_55:
2806 case MACFG_56:
2807 case MACFG_57:
2808 case MACFG_58:
2809 case MACFG_59:
2810 case MACFG_60:
2811 case MACFG_61:
2812 case MACFG_62:
2813 case MACFG_67:
2814 case MACFG_68:
2815 case MACFG_69:
2816 sc->re_hw_supp_now_is_oob_ver = 1;
2817 break;
2818 }
2819
2820 sc->re_8169_MacVersion=(CSR_READ_4(sc, RE_TXCFG)&0x7c800000)>>25; /* Get bit 26~30 */
2821 sc->re_8169_MacVersion|=((CSR_READ_4(sc, RE_TXCFG)&0x00800000)!=0 ? 1:0); /* Get bit 23 */
2822 DBGPRINT1(sc->re_unit,"8169 Mac Version %d",sc->re_8169_MacVersion);
2823
2824 /* Rtl8169s single chip detected */
2825 if (sc->re_type == MACFG_3) {
2826 RE_LOCK(sc);
2827 sc->re_8169_PhyVersion=(MP_ReadPhyUshort(sc, 0x03)&0x000f);
2828 DBGPRINT1(sc->re_unit,"8169 Phy Version %d",sc->re_8169_PhyVersion);
2829 RE_UNLOCK(sc);
2830 }
2831
2832 #ifndef __DragonFly__
2833 sc->link_state = LINK_STATE_UNKNOWN;
2834 #endif
2835 }
2836
2837 static void re_hw_d3_para(struct re_softc *sc)
2838 {
2839 if (sc->re_type == MACFG_59 || sc->re_type == MACFG_60 ||
2840 sc->re_type == MACFG_62 || sc->re_type == MACFG_67 ||
2841 sc->re_type == MACFG_68 || sc->re_type == MACFG_69) {
2842 MP_WritePhyOcpRegWord(sc, 0x0C41, 0x13, 0x0000);
2843 MP_WritePhyOcpRegWord(sc, 0x0C41, 0x13, 0x0500);
2844 }
2845 }
2846
2847 #ifndef __DragonFly__
2848 /*
2849 * Attach the interface. Allocate softc structures, do ifmedia
2850 * setup and ethernet/BPF attach.
2851 */
2852 static int re_attach(device_t dev)
2853 {
2854 /*int s;*/
2855 u_char eaddr[ETHER_ADDR_LEN];
2856 u_int32_t command;
2857 struct re_softc *sc;
2858 struct ifnet *ifp;
2859 int unit, error = 0, rid, i;
2860 // int mac_version;
2861 // int mode;
2862 // u_int8_t data8;
2863 int reg;
2864 int msic=0, msixc=0;
2865
2866 /*s = splimp();*/
2867
2868 sc = device_get_softc(dev);
2869 unit = device_get_unit(dev);
2870 bzero(sc, sizeof(struct re_softc));
2871 RE_LOCK_INIT(sc,device_get_nameunit(dev));
2872 sc->dev = dev;
2873
2874 sc->driver_detach = 0;
2875
2876 sc->re_device_id = pci_get_device(dev);
2877 sc->re_revid = pci_get_revid(dev);
2878 pci_enable_busmaster(dev);
2879
2880 /*
2881 * Map control/status registers.
2882 */
2883 command = pci_read_config(dev, PCIR_COMMAND, 4);
2884 command |= (PCIM_CMD_PORTEN|PCIM_CMD_MEMEN|PCIM_CMD_BUSMASTEREN);
2885 pci_write_config(dev, PCIR_COMMAND, command, 4);
2886 command = pci_read_config(dev, PCIR_COMMAND, 4);
2887
2888 if (prefer_iomap == 0) {
2889 sc->re_res_id = PCIR_BAR(1);
2890 sc->re_res_type = SYS_RES_MEMORY;
2891 /* PCIE NIC use different BARs. */
2892 if (sc->re_device_id == RT_DEVICEID_8168 || sc->re_device_id == RT_DEVICEID_8161 ||
2893 sc->re_device_id == RT_DEVICEID_8136)
2894 sc->re_res_id = PCIR_BAR(2);
2895 } else {
2896 sc->re_res_id = PCIR_BAR(0);
2897 sc->re_res_type = SYS_RES_IOPORT;
2898 }
2899 sc->re_res = bus_alloc_resource(dev, sc->re_res_type, &sc->re_res_id,
2900 0, ~0, 1, RF_ACTIVE);
2901 if (sc->re_res == NULL && prefer_iomap == 0) {
2902 sc->re_res_id = PCIR_BAR(0);
2903 sc->re_res_type = SYS_RES_IOPORT;
2904 sc->re_res = bus_alloc_resource(dev, sc->re_res_type, &sc->re_res_id,
2905 0, ~0, 1, RF_ACTIVE);
2906 }
2907
2908 if (sc->re_res == NULL) {
2909 device_printf(dev,"couldn't map ports/memory\n");
2910 error = ENXIO;
2911 goto fail;
2912 }
2913
2914 if (sc->re_res_type == SYS_RES_IOPORT)
2915 device_printf(dev, "Using I/O Ports\n");
2916 else
2917 device_printf(dev, "Using Memory Mapping!\n");
2918
2919 sc->re_btag = rman_get_bustag(sc->re_res);
2920 sc->re_bhandle = rman_get_bushandle(sc->re_res);
2921
2922 error = re_check_mac_version(sc);
2923
2924 if (error) {
2925 goto fail;
2926 }
2927
2928 re_init_software_variable(sc);
2929
2930 #if OS_VER >= VERSION(7,0)
2931 msic = pci_msi_count(dev);
2932 msixc = pci_msix_count(dev);
2933 if (pci_find_cap(dev, PCIY_EXPRESS, &reg) == 0) {
2934 sc->re_if_flags |= RL_FLAG_PCIE;
2935 sc->re_expcap = reg;
2936 } else {
2937 sc->re_if_flags &= ~RL_FLAG_PCIE;
2938 sc->re_expcap = 0;
2939 }
2940
2941 //device_printf(dev, "MSI count : %d\n", msic);
2942 //device_printf(dev, "MSI-X count : %d\n", msixc);
2943 if (sc->re_hw_enable_msi_msix == FALSE) {
2944 msixc = 0;
2945 msic = 0;
2946 }
2947 if (msix_disable > 0)
2948 msixc = 0;
2949 if (msi_disable > 0)
2950 msic = 0;
2951
2952 /* Prefer MSI-X to MSI. */
2953 if (msixc > 0) {
2954 rid = PCIR_BAR(4);
2955 msixc = RL_MSI_MESSAGES;
2956 sc->re_res_pba = bus_alloc_resource_any(dev, SYS_RES_MEMORY,
2957 &rid, RF_ACTIVE);
2958 if (sc->re_res_pba == NULL) {
2959 device_printf(dev,
2960 "could not allocate MSI-X PBA resource\n");
2961 }
2962 if (sc->re_res_pba != NULL &&
2963 pci_alloc_msix(dev, &msixc) == 0) {
2964 if (msixc == RL_MSI_MESSAGES) {
2965 device_printf(dev, "Using %d MSI-X message\n",
2966 msixc);
2967 sc->re_if_flags |= RL_FLAG_MSIX;
2968 } else
2969 pci_release_msi(dev);
2970 }
2971 if ((sc->re_if_flags & RL_FLAG_MSIX) == 0) {
2972 if (sc->re_res_pba != NULL)
2973 bus_release_resource(dev, SYS_RES_MEMORY, rid,
2974 sc->re_res_pba);
2975 sc->re_res_pba = NULL;
2976 msixc = 0;
2977 }
2978 }
2979
2980 /* Prefer MSI to INTx. */
2981 if (msixc == 0 && msic > 0) {
2982 msic = RL_MSI_MESSAGES;
2983 if (pci_alloc_msi(dev, &msic) == 0) {
2984 if (msic == RL_MSI_MESSAGES) {
2985 device_printf(dev, "Using %d MSI message\n",
2986 msic);
2987 sc->re_if_flags |= RL_FLAG_MSI;
2988 } else
2989 pci_release_msi(dev);
2990 }
2991 if ((sc->re_if_flags & RL_FLAG_MSI) == 0)
2992 msic = 0;
2993 }
2994 #endif //OS_VER >= VERSION(7,0)
2995
2996 if ((sc->re_if_flags & (RL_FLAG_MSI | RL_FLAG_MSIX)) == 0) {
2997 rid = 0;
2998 sc->re_irq = bus_alloc_resource(dev, SYS_RES_IRQ, &rid, 0, ~0, 1,
2999 RF_SHAREABLE | RF_ACTIVE);
3000
3001 if (sc->re_irq == NULL) {
3002 device_printf(dev,"couldn't map interrupt\n");
3003 error = ENXIO;
3004 goto fail;
3005 }
3006 device_printf(dev, "Using line-based interrupt\n");
3007 } else {
3008 rid = 1;
3009 sc->re_irq = bus_alloc_resource_any(dev,
3010 SYS_RES_IRQ, &rid, RF_ACTIVE);
3011 if (sc->re_irq == NULL) {
3012 device_printf(dev,
3013 "couldn't allocate IRQ resources for "
3014 "message %d\n", rid);
3015 error = ENXIO;
3016 goto fail;
3017 }
3018 }
3019
3020 #if OS_VER >= VERSION(7,3)
3021 /* Disable ASPM L0S/L1 and Clock Request. */
3022 if (sc->re_expcap != 0) {
3023 u_int32_t cap, ctl;
3024 cap = pci_read_config(dev, sc->re_expcap +
3025 RE_PCIER_LINK_CAP, 2);
3026 if ((cap & RE_PCIEM_LINK_CAP_ASPM) != 0) {
3027 ctl = pci_read_config(dev, sc->re_expcap +
3028 RE_PCIER_LINK_CTL, 2);
3029 if ((ctl & 0x0103) != 0) {
3030 ctl &= ~0x0103;
3031 pci_write_config(dev, sc->re_expcap +
3032 RE_PCIER_LINK_CTL, ctl, 2);
3033 device_printf(dev, "ASPM disabled\n");
3034 }
3035 } else
3036 device_printf(dev, "no ASPM capability\n");
3037 }
3038 #endif //OS_VER >= VERSION(7,3)
3039
3040 re_init_timer(sc);
3041
3042 RE_LOCK(sc);
3043 re_exit_oob(sc);
3044 re_hw_init(sc);
3045 RE_UNLOCK(sc);
3046
3047 /*
3048 * Reset the adapter. Only take the lock here as it's needed in
3049 * order to call re_reset().
3050 */
3051 RE_LOCK(sc);
3052 re_reset(sc);
3053 RE_UNLOCK(sc);
3054
3055 /* Get station address. */
3056 re_get_hw_mac_address(sc, eaddr);
3057
3058 /*
3059 * A RealTek chip was detected. Inform the world.
3060 */
3061 device_printf(dev,"version:1.92\n");
3062 device_printf(dev,"Ethernet address: %6D\n", eaddr, ":");
3063 printf("\nThis product is covered by one or more of the following patents: \
3064 \nUS6,570,884, US6,115,776, and US6,327,625.\n");
3065
3066 sc->re_unit = unit;
3067
3068 #if OS_VER < VERSION(6,0)
3069 bcopy(eaddr, (char *)&sc->arpcom.ac_enaddr, ETHER_ADDR_LEN);
3070 #endif
3071
3072 if (sc->re_type == MACFG_3) { /* Change PCI Latency time*/
3073 pci_write_config(dev, RE_PCI_LATENCY_TIMER, 0x40, 1);
3074 }
3075
3076 error = bus_dma_tag_create(
3077 #if OS_VER < VERSION(7,0)
3078 NULL,
3079 #else
3080 bus_get_dma_tag(dev), /* parent */
3081 #endif
3082 1, 0, /* alignment, boundary */
3083 BUS_SPACE_MAXADDR, /* lowaddr */
3084 BUS_SPACE_MAXADDR, /* highaddr */
3085 NULL, NULL, /* filter, filterarg */
3086 BUS_SPACE_MAXSIZE_32BIT, /* maxsize */
3087 0, /* nsegments */
3088 BUS_SPACE_MAXSIZE_32BIT, /* maxsegsize */
3089 0, /* flags */
3090 NULL, NULL, /* lockfunc, lockarg */
3091 &sc->re_parent_tag);
3092
3093 i = roundup2(sizeof(union RxDesc)*RE_RX_BUF_NUM, RE_DESC_ALIGN);
3094 error = bus_dma_tag_create(
3095 sc->re_parent_tag,
3096 RE_DESC_ALIGN, 0, /* alignment, boundary */
3097 BUS_SPACE_MAXADDR, /* lowaddr */
3098 BUS_SPACE_MAXADDR, /* highaddr */
3099 NULL, NULL, /* filter, filterarg */
3100 i, /* maxsize */
3101 1, /* nsegments */
3102 i, /* maxsegsize */
3103 0, /* flags */
3104 NULL, NULL, /* lockfunc, lockarg */
3105 &sc->re_desc.rx_desc_tag);
3106 if (error) {
3107 device_printf(dev,"bus_dma_tag_create fail\n");
3108 goto fail;
3109 }
3110
3111 error = bus_dmamem_alloc(sc->re_desc.rx_desc_tag,
3112 (void**) &sc->re_desc.rx_desc,
3113 BUS_DMA_WAITOK|BUS_DMA_COHERENT|BUS_DMA_ZERO,
3114 &sc->re_desc.rx_desc_dmamap);
3115 if (error) {
3116 device_printf(dev,"bus_dmamem_alloc fail\n");
3117 goto fail;
3118 }
3119
3120 i = roundup2(sizeof(union TxDesc)*RE_TX_BUF_NUM, RE_DESC_ALIGN);
3121 error = bus_dma_tag_create(
3122 sc->re_parent_tag,
3123 RE_DESC_ALIGN, 0, /* alignment, boundary */
3124 BUS_SPACE_MAXADDR, /* lowaddr */
3125 BUS_SPACE_MAXADDR, /* highaddr */
3126 NULL, NULL, /* filter, filterarg */
3127 i, /* maxsize */
3128 1, /* nsegments */
3129 i, /* maxsegsize */
3130 0, /* flags */
3131 NULL, NULL, /* lockfunc, lockarg */
3132 &sc->re_desc.tx_desc_tag);
3133 if (error) {
3134 device_printf(dev,"bus_dma_tag_create fail\n");
3135 goto fail;
3136 }
3137
3138 error = bus_dmamem_alloc(sc->re_desc.tx_desc_tag,
3139 (void**) &sc->re_desc.tx_desc,
3140 BUS_DMA_WAITOK|BUS_DMA_COHERENT|BUS_DMA_ZERO,
3141 &sc->re_desc.tx_desc_dmamap);
3142
3143 if (error) {
3144 device_printf(dev,"bus_dmamem_alloc fail\n");
3145 goto fail;
3146 }
3147
3148 RE_LOCK(sc);
3149 re_phy_power_up(dev);
3150 re_hw_phy_config(sc);
3151 re_clrwol(sc);
3152 RE_UNLOCK(sc);
3153
3154 sc->re_tx_cstag =1;
3155 sc->re_rx_cstag =1;
3156
3157 #if OS_VER < VERSION(6,0)
3158 ifp = &sc->arpcom.ac_if;
3159 #else
3160 ifp = sc->re_ifp = if_alloc(IFT_ETHER);
3161 if (ifp == NULL) {
3162 device_printf(dev, "can not if_alloc()\n");
3163 error = ENOSPC;
3164 goto fail;
3165 }
3166 #endif
3167 ifp->if_softc = sc;
3168 #if OS_VER < VERSION(5,3)
3169 ifp->if_unit = unit;
3170 ifp->if_name = "re";
3171 #else
3172 if_initname(ifp, device_get_name(dev), device_get_unit(dev));
3173 #endif
3174 ifp->if_mtu = ETHERMTU;
3175 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
3176 ifp->if_ioctl = re_ioctl;
3177 ifp->if_output = ether_output;
3178 ifp->if_start = re_start;
3179 #if OS_VER < VERSION(7,0)
3180 ifp->if_watchdog = re_watchdog;
3181 #endif
3182 if ((sc->re_type == MACFG_24) || (sc->re_type == MACFG_25) || (sc->re_type == MACFG_26))
3183 ifp->if_hwassist |= CSUM_TCP | CSUM_UDP;
3184 else
3185 ifp->if_hwassist |= RE_CSUM_FEATURES;
3186
3187 ifp->if_capabilities = IFCAP_HWCSUM;
3188 ifp->if_capenable = ifp->if_capabilities;
3189 CSR_WRITE_2 (sc, RE_CPlusCmd,CSR_READ_2(sc, RE_CPlusCmd) |RL_RxChkSum);
3190 ifp->if_init = re_init;
3191 /* VLAN capability setup */
3192 ifp->if_capabilities |= IFCAP_VLAN_MTU | IFCAP_VLAN_HWTAGGING;
3193 ifp->if_capenable = ifp->if_capabilities;
3194
3195 /* Enable WOL if PM is supported. */
3196 if (pci_find_cap(sc->dev, PCIY_PMG, &reg) == 0)
3197 ifp->if_capabilities |= IFCAP_WOL;
3198 ifp->if_capenable = ifp->if_capabilities;
3199 ifp->if_capenable &= ~(IFCAP_WOL_UCAST | IFCAP_WOL_MCAST);
3200
3201 RE_LOCK(sc);
3202 set_rxbufsize(sc);
3203 error =re_alloc_buf(sc);
3204
3205 if (error) {
3206 RE_UNLOCK(sc);
3207 goto fail;
3208 }
3209 /* Init descriptors. */
3210 re_var_init(sc);
3211
3212 RE_UNLOCK(sc);
3213
3214 switch(sc->re_device_id) {
3215 case RT_DEVICEID_8169:
3216 case RT_DEVICEID_8169SC:
3217 case RT_DEVICEID_8168:
3218 case RT_DEVICEID_8161:
3219 ifp->if_baudrate = 1000000000;
3220 break;
3221
3222 default:
3223 ifp->if_baudrate = 100000000;
3224 break;
3225 }
3226 IFQ_SET_MAXLEN(&ifp->if_snd, IFQ_MAXLEN);
3227 ifp->if_snd.ifq_drv_maxlen = IFQ_MAXLEN;
3228 IFQ_SET_READY(&ifp->if_snd);
3229
3230 #if OS_VER>=VERSION(7,0)
3231 TASK_INIT(&sc->re_inttask, 0, re_int_task, sc);
3232 #endif
3233
3234 /*
3235 * Call MI attach routine.
3236 */
3237 /*#if OS_VER < VERSION(5, 1)*/
3238 #if OS_VER < VERSION(4,9)
3239 ether_ifattach(ifp, ETHER_BPF_SUPPORTED);
3240 #else
3241 ether_ifattach(ifp, eaddr);
3242 #endif
3243
3244 #if OS_VER < VERSION(7,0)
3245 error = bus_setup_intr(dev, sc->re_irq, INTR_TYPE_NET,
3246 re_intr, sc, &sc->re_intrhand);
3247 #else
3248 error = bus_setup_intr(dev, sc->re_irq, INTR_TYPE_NET|INTR_MPSAFE,
3249 re_intr, NULL, sc, &sc->re_intrhand);
3250 #endif
3251
3252 if (error) {
3253 #if OS_VER < VERSION(4,9)
3254 ether_ifdetach(ifp, ETHER_BPF_SUPPORTED);
3255 #else
3256 ether_ifdetach(ifp);
3257 #endif
3258 device_printf(dev,"couldn't set up irq\n");
3259 goto fail;
3260 }
3261
3262 /*
3263 * Specify the media types supported by this adapter and register
3264 * callbacks to update media and link information
3265 */
3266 ifmedia_init(&sc->media, IFM_IMASK, re_ifmedia_upd, re_ifmedia_sts);
3267 ifmedia_add(&sc->media, IFM_ETHER | IFM_10_T, 0, NULL);
3268 ifmedia_add(&sc->media, IFM_ETHER | IFM_10_T | IFM_FDX, 0, NULL);
3269 ifmedia_add(&sc->media, IFM_ETHER | IFM_100_TX, 0, NULL);
3270 ifmedia_add(&sc->media, IFM_ETHER | IFM_100_TX | IFM_FDX, 0, NULL);
3271 switch(sc->re_device_id) {
3272 case RT_DEVICEID_8169:
3273 case RT_DEVICEID_8169SC:
3274 case RT_DEVICEID_8168:
3275 case RT_DEVICEID_8161:
3276 ifmedia_add(&sc->media, IFM_ETHER | IFM_1000_T | IFM_FDX, 0, NULL);
3277 ifmedia_add(&sc->media, IFM_ETHER | IFM_1000_T, 0, NULL);
3278 break;
3279
3280 default:
3281 break;
3282 }
3283 ifmedia_add(&sc->media, IFM_ETHER | IFM_AUTO, 0, NULL);
3284 ifmedia_set(&sc->media, IFM_ETHER | IFM_AUTO);
3285 sc->media.ifm_media = IFM_ETHER | IFM_AUTO;
3286 re_ifmedia_upd(ifp);
3287
3288 fail:
3289 if (error)
3290 re_detach(dev);
3291
3292 return(error);
3293 }
3294
3295 static int re_detach(device_t dev)
3296 {
3297 struct re_softc *sc;
3298 struct ifnet *ifp;
3299 /*int s;*/
3300 int i;
3301 int rid;
3302
3303 /*s = splimp();*/
3304
3305 sc = device_get_softc(dev);
3306
3307 ifp = RE_GET_IFNET(sc);
3308
3309 /* These should only be active if attach succeeded */
3310 if (device_is_attached(dev)) {
3311 RE_LOCK(sc);
3312 re_stop(sc);
3313 RE_UNLOCK(sc);
3314 #if OS_VER>=VERSION(7,0)
3315 taskqueue_drain(taskqueue_fast, &sc->re_inttask);
3316 #endif
3317 #if OS_VER < VERSION(4,9)
3318 ether_ifdetach(ifp, ETHER_BPF_SUPPORTED);
3319 #else
3320 ether_ifdetach(ifp);
3321 #endif
3322 }
3323
3324 bus_generic_detach(dev);
3325
3326 sc->driver_detach = 1;
3327
3328 if (sc->re_intrhand)
3329 bus_teardown_intr(dev, sc->re_irq, sc->re_intrhand);
3330
3331 #if OS_VER>=VERSION(6,0)
3332 if (ifp)
3333 if_free(ifp);
3334 #endif
3335
3336 if ((sc->re_if_flags & (RL_FLAG_MSI | RL_FLAG_MSIX)) == 0)
3337 rid = 0;
3338 else
3339 rid = 1;
3340 if (sc->re_irq) {
3341 bus_release_resource(dev, SYS_RES_IRQ, rid, sc->re_irq);
3342 sc->re_irq = NULL;
3343 }
3344 if ((sc->re_if_flags & (RL_FLAG_MSI | RL_FLAG_MSIX)) != 0)
3345 pci_release_msi(dev);
3346 if (sc->re_res_pba) {
3347 rid = PCIR_BAR(4);
3348 bus_release_resource(dev, SYS_RES_MEMORY, rid, sc->re_res_pba);
3349 }
3350 if (sc->re_res)
3351 bus_release_resource(dev, sc->re_res_type, sc->re_res_id, sc->re_res);
3352
3353 if (sc->re_desc.re_rx_mtag) {
3354 for (i = 0; i < RE_RX_BUF_NUM; i++) {
3355 if (sc->re_desc.rx_buf[i]!=NULL) {
3356 bus_dmamap_sync(sc->re_desc.re_rx_mtag,
3357 sc->re_desc.re_rx_dmamap[i],
3358 BUS_DMASYNC_POSTREAD);
3359 bus_dmamap_unload(sc->re_desc.re_rx_mtag,
3360 sc->re_desc.re_rx_dmamap[i]);
3361 bus_dmamap_destroy(sc->re_desc.re_rx_mtag,
3362 sc->re_desc.re_rx_dmamap[i]);
3363 m_freem(sc->re_desc.rx_buf[i]);
3364 sc->re_desc.rx_buf[i] =NULL;
3365 }
3366 }
3367 bus_dma_tag_destroy(sc->re_desc.re_rx_mtag);
3368 sc->re_desc.re_rx_mtag =0;
3369 }
3370
3371 if (sc->re_desc.re_tx_mtag) {
3372 for (i = 0; i < RE_TX_BUF_NUM; i++) {
3373 bus_dmamap_destroy(sc->re_desc.re_tx_mtag,
3374 sc->re_desc.re_tx_dmamap[i]);
3375 }
3376 bus_dma_tag_destroy(sc->re_desc.re_tx_mtag);
3377 sc->re_desc.re_tx_mtag =0;
3378 }
3379
3380 if (sc->re_desc.rx_desc_tag) {
3381 bus_dmamap_sync(sc->re_desc.rx_desc_tag,
3382 sc->re_desc.rx_desc_dmamap,
3383 BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE);
3384 bus_dmamap_unload(sc->re_desc.rx_desc_tag,
3385 sc->re_desc.rx_desc_dmamap);
3386 bus_dmamem_free(sc->re_desc.rx_desc_tag,
3387 sc->re_desc.rx_desc,
3388 sc->re_desc.rx_desc_dmamap);
3389 bus_dma_tag_destroy(sc->re_desc.rx_desc_tag);
3390 }
3391
3392 if (sc->re_desc.tx_desc_tag) {
3393 bus_dmamap_sync(sc->re_desc.tx_desc_tag,
3394 sc->re_desc.tx_desc_dmamap,
3395 BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE);
3396 bus_dmamap_unload(sc->re_desc.tx_desc_tag,
3397 sc->re_desc.tx_desc_dmamap);
3398 bus_dmamem_free(sc->re_desc.tx_desc_tag,
3399 sc->re_desc.tx_desc,
3400 sc->re_desc.tx_desc_dmamap);
3401 bus_dma_tag_destroy(sc->re_desc.tx_desc_tag);
3402 }
3403
3404 if (sc->re_parent_tag) {
3405 bus_dma_tag_destroy(sc->re_parent_tag);
3406 }
3407
3408 /*splx(s);*/
3409 RE_LOCK_DESTROY(sc);
3410
3411 return(0);
3412 }
3413 #endif /* !__DragonFly__ */
3414
3415 #ifndef __DragonFly__
3416 static void
3417 re_link_state_change(struct ifnet *ifp, int link_state)
3418 {
3419 #if OS_VER>=VERSION(6,0)
3420 if_link_state_change(ifp, link_state);
3421 #else
3422 ifp->if_link_state = link_state
3423 #endif
3424 }
3425
3426 /*
3427 * Device suspend routine. Stop the interface and save some PCI
3428 * settings in case the BIOS doesn't restore them properly on
3429 * resume.
3430 */
3431 static int
3432 re_suspend(device_t dev)
3433 {
3434 struct re_softc *sc;
3435 struct ifnet *ifp;
3436
3437 sc = device_get_softc(dev);
3438 RE_LOCK(sc);
3439 ifp = RE_GET_IFNET(sc);
3440 sc->re_link_chg_det = 0;
3441 re_stop(sc);
3442 re_hw_d3_para(sc);
3443 re_setwol(sc);
3444 sc->suspended = 1;
3445 sc->link_state = LINK_STATE_UNKNOWN;
3446 re_link_state_change(ifp, sc->link_state);
3447 sc->prohibit_access_reg = 1;
3448 RE_UNLOCK(sc);
3449
3450 return (0);
3451 }
3452
3453 /*
3454 * Device resume routine. Restore some PCI settings in case the BIOS
3455 * doesn't, re-enable busmastering, and restart the interface if
3456 * appropriate.
3457 */
3458 static int
3459 re_resume(device_t dev)
3460 {
3461 struct re_softc *sc;
3462 struct ifnet *ifp;
3463
3464 sc = device_get_softc(dev);
3465
3466 RE_LOCK(sc);
3467
3468 ifp = RE_GET_IFNET(sc);
3469
3470 sc->prohibit_access_reg = 0;
3471
3472 re_exit_oob(sc);
3473
3474 re_hw_init(sc);
3475
3476 re_reset(sc);
3477
3478 re_phy_power_up(dev);
3479
3480 re_hw_phy_config(sc);
3481
3482 /*
3483 * Clear WOL matching such that normal Rx filtering
3484 * wouldn't interfere with WOL patterns.
3485 */
3486 re_clrwol(sc);
3487
3488 RE_UNLOCK(sc);
3489
3490 RE_LOCK(sc);
3491 re_ifmedia_upd(ifp);
3492 sc->suspended = 0;
3493 if (ifp->if_flags & IFF_UP) {
3494 sc->re_link_chg_det = 1;
3495 re_start_timer(sc);
3496 }
3497 RE_UNLOCK(sc);
3498
3499 return (0);
3500 }
3501 #endif /* !__DragonFly__ */
3502
3503
3504 static void
3505 ClearAndSetPCIePhyBit(
3506 struct re_softc *sc,
3507 u_int8_t addr,
3508 u_int16_t clearmask,
3509 u_int16_t setmask
3510 )
3511 {
3512 u_int16_t EphyValue;
3513
3514 EphyValue = MP_ReadEPhyUshort(sc, addr);
3515 EphyValue &= ~clearmask;
3516 EphyValue |= setmask;
3517 MP_WriteEPhyUshort(sc, addr, EphyValue);
3518 }
3519
3520 static void
3521 ClearPCIePhyBit(
3522 struct re_softc *sc,
3523 u_int8_t addr,
3524 u_int16_t mask
3525 )
3526 {
3527 ClearAndSetPCIePhyBit(sc,
3528 addr,
3529 mask,
3530 0
3531 );
3532 }
3533
3534 static void
3535 SetPCIePhyBit(
3536 struct re_softc *sc,
3537 u_int8_t addr,
3538 u_int16_t mask
3539 )
3540 {
3541 ClearAndSetPCIePhyBit(sc,
3542 addr,
3543 0,
3544 mask
3545 );
3546 }
3547
3548 #ifndef __DragonFly__
3549 /*
3550 * Stop all chip I/O so that the kernel's probe routines don't
3551 * get confused by errant DMAs when rebooting.
3552 */
3553 static int re_shutdown(dev) /* The same with re_stop(sc) */
3554 device_t dev;
3555 {
3556 struct re_softc *sc;
3557
3558 sc = device_get_softc(dev);
3559
3560 switch(sc->re_type) {
3561 case MACFG_61:
3562 case MACFG_62:
3563 case MACFG_67:
3564 case MACFG_63:
3565 case MACFG_64:
3566 case MACFG_65:
3567 case MACFG_66:
3568 re_driver_stop(sc);
3569 break;
3570 }
3571
3572 RE_LOCK(sc);
3573 sc->re_link_chg_det = 0;
3574 re_stop(sc);
3575 RE_UNLOCK(sc);
3576
3577 RE_LOCK(sc);
3578 re_hw_d3_para(sc);
3579 re_phy_power_down(dev);
3580 RE_UNLOCK(sc);
3581
3582 return 0;
3583 }
3584 #endif /* !__DragonFly__ */
3585
3586 static void re_hw_start_unlock(struct re_softc *sc)
3587 {
3588 struct ifnet *ifp;
3589 u_int32_t macver;
3590 u_int8_t data8;
3591 u_int16_t data16 = 0;
3592 u_int32_t Data32;
3593
3594 ifp = RE_GET_IFNET(sc);
3595
3596 #ifndef __DragonFly__
3597 /* Init descriptors. */
3598 re_var_init(sc);
3599 #endif
3600
3601 CSR_WRITE_1(sc, RE_EECMD, RE_EEMODE_WRITECFG);
3602
3603 /*disable Link Down Power Saving(non-LDPS)*/
3604 /*CSR_WRITE_1(sc, RE_LDPS, 0x05);*/
3605 /*ldps= CSR_READ_1(sc, RE_LDPS);*/
3606
3607 CSR_WRITE_2(sc, RE_CPCR, 0x2060);
3608
3609 CSR_WRITE_2(sc, RE_IM, 0x5151);
3610
3611 CSR_WRITE_1(sc, RE_MTPS, 0x3f);
3612
3613 if (sc->re_device_id == RT_DEVICEID_8169 || sc->re_device_id == RT_DEVICEID_8169SC) {
3614 //do nothing
3615 } else {
3616 /* Set the initial TX configuration.*/
3617 CSR_WRITE_4(sc, RE_TXCFG, RE_TXCFG_CONFIG);
3618 }
3619
3620 macver = CSR_READ_4(sc, RE_TXCFG) & 0xFC800000;
3621 if (macver == 0x00800000 || macver == 0x04000000 || macver == 0x10000000) {
3622 CSR_WRITE_2(sc, RE_CPlusCmd, 0x0063| ((sc->re_type == MACFG_3 && sc->re_8169_MacVersion==1) ? 0x4008:0));
3623 } else if (macver == 0x18000000 || macver == 0x98000000) {
3624 CSR_WRITE_2(sc, RE_CPlusCmd, 0x0068);
3625 CSR_WRITE_2(sc, 0xe2, 0x0000);
3626 } else if (macver == 0x30000000) {
3627 CSR_WRITE_2 (sc, RE_CPlusCmd, 0x2060);
3628 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0);
3629
3630 if (ifp->if_mtu > ETHERMTU) {
3631 data8 = pci_read_config(sc->dev, 0x69, 1);
3632 data8 &= ~0x70;
3633 data8 |= 0x28;
3634 pci_write_config(sc->dev, 0x69, data8, 1);
3635 } else {
3636 data8 = pci_read_config(sc->dev, 0x69, 1);
3637 data8 &= ~0x70;
3638 data8 |= 0x58;
3639 pci_write_config(sc->dev, 0x69, data8, 1);
3640 }
3641 } else if (macver == 0x38000000) {
3642 CSR_WRITE_2 (sc, RE_CPlusCmd, 0x2060);
3643 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0);
3644
3645 if (ifp->if_mtu > ETHERMTU) {
3646 data8 = pci_read_config(sc->dev, 0x69, 1);
3647 data8 &= ~0x70;
3648 data8 |= 0x28;
3649 pci_write_config(sc->dev, 0x69, data8, 1);
3650 CSR_WRITE_1(sc, RE_CFG4, CSR_READ_1(sc, RE_CFG4) | BIT_0);
3651 } else {
3652 data8 = pci_read_config(sc->dev, 0x69, 1);
3653 data8 &= ~0x70;
3654 data8 |= 0x58;
3655 pci_write_config(sc->dev, 0x69, data8, 1);
3656 CSR_WRITE_1(sc, RE_CFG4, CSR_READ_1(sc, RE_CFG4) & ~ BIT_0);
3657 }
3658 } else if (macver == 0x34000000 || macver == 0xB4000000) {
3659 CSR_WRITE_2 (sc, RE_CPlusCmd, 0x2060);
3660 } else if (macver == 0x34800000 || macver == 0x24800000) {
3661 if (pci_read_config(sc->dev, 0x81, 1) == 1) {
3662 CSR_WRITE_1(sc, RE_DBG_reg, 0x98);
3663 CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2) | 0x80);
3664 CSR_WRITE_1(sc, RE_CFG4, CSR_READ_1(sc, RE_CFG4) | 0x04);
3665 pci_write_config(sc->dev, 0x81, 1, 1);
3666 }
3667
3668 data8 = pci_read_config(sc->dev, 0x79, 1);
3669 data8 &= ~0x70;
3670 data8 |= 0x50;
3671 pci_write_config(sc->dev, 0x79, data8, 1);
3672
3673 /*set configuration space offset 0x70f to 0x3f*/
3674 Data32 = MP_ReadPciEConfigSpace(sc, 0x870c);
3675 Data32 &=0xC0FFFFFF;
3676 Data32 |= (0x3F << 24);
3677 MP_WritePciEConfigSpace(sc, 0x870c, Data32);
3678
3679 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0);
3680
3681 CSR_WRITE_2 (sc, RE_CPlusCmd, 0x2060);
3682 if (sc->re_type == MACFG_14) {
3683 CSR_WRITE_1(sc,RE_CFG1, 0x0f);
3684
3685 MP_WriteEPhyUshort(sc, 0x03, 0xC2F9);
3686 } else if (sc->re_type == MACFG_15) {
3687 CSR_WRITE_1(sc,RE_CFG1, 0x0f);
3688
3689 MP_WriteEPhyUshort(sc, 0x01, 0x6FE5);
3690 MP_WriteEPhyUshort(sc, 0x03, 0x07D9);
3691 } else if (sc->re_type == MACFG_17) {
3692 MP_WriteEPhyUshort(sc, 0x06, 0xAF35);
3693 } else if (sc->re_type == MACFG_18) {
3694 CSR_WRITE_1(sc, 0xF5, CSR_READ_1(sc, 0xF5)|0x04);
3695 MP_WriteEPhyUshort(sc, 0x19, 0xEC90);
3696 MP_WriteEPhyUshort(sc, 0x01, 0x6FE5);
3697 MP_WriteEPhyUshort(sc, 0x03, 0x05D9);
3698 MP_WriteEPhyUshort(sc, 0x06, 0xAF35);
3699 } else if (sc->re_type == MACFG_19) {
3700 if (pci_read_config(sc->dev, 0x80, 1)&3) {
3701 MP_WriteEPhyUshort(sc, 0x02, 0x011F);
3702 }
3703 CSR_WRITE_1(sc, 0xF4, CSR_READ_1(sc, 0xF4)|0x08);
3704 CSR_WRITE_1(sc, 0xF5, CSR_READ_1(sc, 0xF5)|0x04);
3705 MP_WriteEPhyUshort(sc, 0x19, 0xEC90);
3706 MP_WriteEPhyUshort(sc, 0x01, 0x6FE5);
3707 MP_WriteEPhyUshort(sc, 0x03, 0x05D9);
3708 MP_WriteEPhyUshort(sc, 0x06, 0xAF35);
3709 }
3710 } else if (macver == 0x3C000000) {
3711 /*set configuration space offset 0x70f to 0x27*/
3712 Data32 = MP_ReadPciEConfigSpace(sc, 0x870c);
3713 Data32 &=0xC0FFFFFF;
3714 Data32 |= (0x27 << 24);
3715 MP_WritePciEConfigSpace(sc, 0x870c, Data32);
3716
3717 CSR_WRITE_1(sc, RE_CFG1, CSR_READ_1(sc, RE_CFG1)|0x10);
3718 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0);
3719
3720 CSR_WRITE_2 (sc, RE_CPlusCmd, 0x2060);
3721 if (sc->re_type == MACFG_24) {
3722 /*set mac register offset 0xd1 to 0xf8*/
3723 CSR_WRITE_1(sc, RE_DBG_reg, 0xF8);
3724
3725 data16 = MP_ReadEPhyUshort(sc, 0x02) & ~0x1800;
3726 data16 |= 0x1000;
3727 MP_WriteEPhyUshort(sc, 0x02, data16);
3728
3729 data16 = MP_ReadEPhyUshort(sc, 0x03) | 0x0002;
3730 MP_WriteEPhyUshort(sc, 0x03, data16);
3731
3732 data16 = MP_ReadEPhyUshort(sc, 0x06) & ~0x0080;
3733 MP_WriteEPhyUshort(sc, 0x06, data16);
3734
3735 //disable clock request.
3736 pci_write_config(sc->dev, 0x81, 0, 1);
3737
3738 if (ifp->if_mtu > ETHERMTU) {
3739 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) | BIT_2); //Jumbo_en0
3740 CSR_WRITE_1(sc, RE_CFG4, CSR_READ_1(sc, RE_CFG4) | (1 << 1)); //Jumbo_en1
3741
3742 data8 = pci_read_config(sc->dev, 0x79, 1);
3743 data8 &= ~0x70;
3744 data8 |= 0x20;
3745 pci_write_config(sc->dev, 0x79, data8, 1);
3746 ifp->if_capenable &= ~IFCAP_HWCSUM;
3747 CSR_WRITE_2 (sc, RE_CPlusCmd,CSR_READ_2(sc, RE_CPlusCmd) & ~RL_RxChkSum);
3748 ifp->if_hwassist &= ~RE_CSUM_FEATURES;
3749
3750 } else {
3751 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_2); //Jumbo_en0
3752 CSR_WRITE_1(sc, RE_CFG4, CSR_READ_1(sc, RE_CFG4) & ~(1 << 1)); //Jumbo_en1
3753 data8 = pci_read_config(sc->dev, 0x79, 1);
3754 data8 &= ~0x70;
3755 data8 |= 0x50;
3756 pci_write_config(sc->dev, 0x79, data8, 1);
3757 if (sc->re_tx_cstag) {
3758 ifp->if_capenable |= IFCAP_TXCSUM;
3759 if ((sc->re_type == MACFG_24) || (sc->re_type == MACFG_25) || (sc->re_type == MACFG_26))
3760 ifp->if_hwassist |= CSUM_TCP | CSUM_UDP;
3761 else
3762 ifp->if_hwassist |= RE_CSUM_FEATURES;
3763 }
3764 if (sc->re_rx_cstag) {
3765 ifp->if_capenable |= IFCAP_RXCSUM;
3766 CSR_WRITE_2 (sc, RE_CPlusCmd,CSR_READ_2(sc, RE_CPlusCmd) |RL_RxChkSum);
3767 }
3768 }
3769
3770
3771 } else if (sc->re_type == MACFG_25) {
3772 data16 = MP_ReadEPhyUshort(sc, 0x01) | 0x0001;
3773 MP_WriteEPhyUshort(sc, 0x01, data16);
3774
3775 data16 = MP_ReadEPhyUshort(sc, 0x03) & ~0x0620;
3776 data16 |= 0x0220;
3777 MP_WriteEPhyUshort(sc, 0x03, data16);
3778
3779 //disable clock request.
3780 pci_write_config(sc->dev, 0x81, 0, 1);
3781
3782 if (ifp->if_mtu > ETHERMTU) {
3783 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) | BIT_2); //Jumbo_en0
3784 CSR_WRITE_1(sc, RE_CFG4, CSR_READ_1(sc, RE_CFG4) | (1<<1)); //Jumbo_en1
3785
3786 data8 = pci_read_config(sc->dev, 0x79, 1);
3787 data8 &= ~0x70;
3788 data8 |= 0x20;
3789 pci_write_config(sc->dev, 0x79, data8, 1);
3790 ifp->if_capenable &= ~IFCAP_HWCSUM;
3791 CSR_WRITE_2 (sc, RE_CPlusCmd,CSR_READ_2(sc, RE_CPlusCmd) & ~RL_RxChkSum);
3792 ifp->if_hwassist &= ~RE_CSUM_FEATURES;
3793
3794 } else {
3795 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_2); //Jumbo_en0
3796 CSR_WRITE_1(sc, RE_CFG4, CSR_READ_1(sc, RE_CFG4) & ~(1<<1)); //Jumbo_en1
3797 data8 = pci_read_config(sc->dev, 0x79, 1);
3798 data8 &= ~0x70;
3799 data8 |= 0x50;
3800 pci_write_config(sc->dev, 0x79, data8, 1);
3801 if (sc->re_tx_cstag) {
3802 ifp->if_capenable |= IFCAP_TXCSUM;
3803 if ((sc->re_type == MACFG_24) || (sc->re_type == MACFG_25) || (sc->re_type == MACFG_26))
3804 ifp->if_hwassist |= CSUM_TCP | CSUM_UDP;
3805 else
3806 ifp->if_hwassist |= RE_CSUM_FEATURES;
3807 }
3808 if (sc->re_rx_cstag) {
3809 ifp->if_capenable |= IFCAP_RXCSUM;
3810 CSR_WRITE_2 (sc, RE_CPlusCmd,CSR_READ_2(sc, RE_CPlusCmd) |RL_RxChkSum);
3811 }
3812
3813
3814 }
3815
3816 } else if (sc->re_type == MACFG_26) {
3817 //disable clock request.
3818 pci_write_config(sc->dev, 0x81, 0, 1);
3819
3820 if (ifp->if_mtu > ETHERMTU) {
3821 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) | BIT_2); //Jumbo_en0
3822 CSR_WRITE_1(sc, RE_CFG4, CSR_READ_1(sc, RE_CFG4) | (1<<1)); //Jumbo_en1
3823
3824 data8 = pci_read_config(sc->dev, 0x79, 1);
3825 data8 &= ~0x70;
3826 data8 |= 0x20;
3827 pci_write_config(sc->dev, 0x79, data8, 1);
3828 ifp->if_capenable &= ~IFCAP_HWCSUM;
3829 CSR_WRITE_2 (sc, RE_CPlusCmd,CSR_READ_2(sc, RE_CPlusCmd) & ~RL_RxChkSum);
3830 ifp->if_hwassist &= ~RE_CSUM_FEATURES;
3831 } else {
3832 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_2); //Jumbo_en0
3833 CSR_WRITE_1(sc, RE_CFG4, CSR_READ_1(sc, RE_CFG4) & ~(1<<1)); //Jumbo_en1
3834 data8 = pci_read_config(sc->dev, 0x79, 1);
3835 data8 &= ~0x70;
3836 data8 |= 0x50;
3837 pci_write_config(sc->dev, 0x79, data8, 1);
3838 if (sc->re_tx_cstag) {
3839 ifp->if_capenable |= IFCAP_TXCSUM;
3840 if ((sc->re_type == MACFG_24) || (sc->re_type == MACFG_25) || (sc->re_type == MACFG_26))
3841 ifp->if_hwassist |= CSUM_TCP | CSUM_UDP;
3842 else
3843 ifp->if_hwassist |= RE_CSUM_FEATURES;
3844 }
3845 if (sc->re_rx_cstag) {
3846 ifp->if_capenable |= IFCAP_RXCSUM;
3847 CSR_WRITE_2 (sc, RE_CPlusCmd,CSR_READ_2(sc, RE_CPlusCmd) |RL_RxChkSum);
3848 }
3849 }
3850 }
3851 } else if (macver == 0x3C800000) {
3852 /*set configuration space offset 0x70f to 0x27*/
3853 Data32 = MP_ReadPciEConfigSpace(sc, 0x870c);
3854 Data32 &=0xC0FFFFFF;
3855 Data32 |= (0x27 << 24);
3856 MP_WritePciEConfigSpace(sc, 0x870c, Data32);
3857
3858 re_eri_write(sc, 0x1EC, 1, 0x07, ERIAR_ASF);
3859
3860 //disable clock request.
3861 pci_write_config(sc->dev, 0x81, 0x00, 1);
3862
3863 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0);
3864 CSR_WRITE_2 (sc, RE_CPlusCmd, 0x2060);
3865 if (sc->re_type == MACFG_28)
3866 CSR_WRITE_1(sc, 0xD1, 0x20);
3867
3868 if (ifp->if_mtu > ETHERMTU) {
3869 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) | BIT_2); //Jumbo_en0
3870 CSR_WRITE_1(sc, RE_CFG4, CSR_READ_1(sc, RE_CFG4) | (1<<1)); //Jumbo_en1
3871
3872 data8 = pci_read_config(sc->dev, 0x79, 1);
3873 data8 &= ~0x70;
3874 data8 |= 0x20;
3875 pci_write_config(sc->dev, 0x79, data8, 1);
3876 ifp->if_capenable &= ~IFCAP_HWCSUM;
3877 CSR_WRITE_2 (sc, RE_CPlusCmd,CSR_READ_2(sc, RE_CPlusCmd) & ~RL_RxChkSum);
3878 ifp->if_hwassist &= ~RE_CSUM_FEATURES;
3879 } else {
3880 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_2); //Jumbo_en0
3881 CSR_WRITE_1(sc, RE_CFG4, CSR_READ_1(sc, RE_CFG4) & ~(1<<1)); //Jumbo_en1
3882 data8 = pci_read_config(sc->dev, 0x79, 1);
3883 data8 &= ~0x70;
3884 data8 |= 0x50;
3885 pci_write_config(sc->dev, 0x79, data8, 1);
3886 if (sc->re_tx_cstag) {
3887 ifp->if_capenable |= IFCAP_TXCSUM;
3888 ifp->if_hwassist |= RE_CSUM_FEATURES;
3889 }
3890 if (sc->re_rx_cstag) {
3891 ifp->if_capenable |= IFCAP_RXCSUM;
3892 CSR_WRITE_2 (sc, RE_CPlusCmd,CSR_READ_2(sc, RE_CPlusCmd) |RL_RxChkSum);
3893 }
3894 }
3895
3896
3897 } else if (macver == 0x28000000) {
3898 /*set configuration space offset 0x70f to 0x13*/
3899 Data32 = MP_ReadPciEConfigSpace(sc, 0x870c);
3900 Data32 &=0xC0FFFFFF;
3901 Data32 |= (0x13 << 24);
3902 MP_WritePciEConfigSpace(sc, 0x870c, Data32);
3903
3904 /* disable clock request. */
3905 pci_write_config(sc->dev, 0x81, 0x00, 1);
3906
3907 CSR_WRITE_1(sc, 0xD1, CSR_READ_1(sc, 0xD1) | 0x02);
3908
3909 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0);
3910 CSR_WRITE_1(sc, RE_DBG_reg, CSR_READ_1(sc, RE_DBG_reg)|0x82);
3911
3912 CSR_WRITE_2 (sc, RE_CPlusCmd, 0x2060);
3913
3914 if (ifp->if_mtu > ETHERMTU) {
3915 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) | BIT_2); //Jumbo_en0
3916 CSR_WRITE_1(sc, RE_CFG4, CSR_READ_1(sc, RE_CFG4) | (1<<1)); //Jumbo_en1
3917
3918 data8 = pci_read_config(sc->dev, 0x79, 1);
3919 data8 &= ~0x70;
3920 data8 |= 0x20;
3921 pci_write_config(sc->dev, 0x79, data8, 1);
3922 ifp->if_capenable &= ~IFCAP_HWCSUM;
3923 CSR_WRITE_2 (sc, RE_CPlusCmd,CSR_READ_2(sc, RE_CPlusCmd) & ~RL_RxChkSum);
3924 ifp->if_hwassist &= ~RE_CSUM_FEATURES;
3925
3926 } else {
3927 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_2); //Jumbo_en0
3928 CSR_WRITE_1(sc, RE_CFG4, CSR_READ_1(sc, RE_CFG4) & ~(1<<1)); //Jumbo_en1
3929 data8 = pci_read_config(sc->dev, 0x79, 1);
3930 data8 &= ~0x70;
3931 data8 |= 0x50;
3932 pci_write_config(sc->dev, 0x79, data8, 1);
3933 if (sc->re_tx_cstag) {
3934 ifp->if_capenable |= IFCAP_TXCSUM;
3935 ifp->if_hwassist |= RE_CSUM_FEATURES;
3936 }
3937 if (sc->re_rx_cstag) {
3938 ifp->if_capenable |= IFCAP_RXCSUM;
3939 CSR_WRITE_2 (sc, RE_CPlusCmd,CSR_READ_2(sc, RE_CPlusCmd) |RL_RxChkSum);
3940 }
3941 }
3942
3943 if (sc->re_type == MACFG_31) {
3944 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~(1<<4));
3945
3946 MP_WriteEPhyUshort(sc, 0x01, 0x7C7F);
3947 MP_WriteEPhyUshort(sc, 0x02, 0x011F);
3948 MP_WriteEPhyUshort(sc, 0x06, 0xB271);
3949 MP_WriteEPhyUshort(sc, 0x07, 0xCE00);
3950 } else if (sc->re_type == MACFG_32) {
3951 MP_WriteEPhyUshort(sc, 0x01, 0x7C7D);
3952 MP_WriteEPhyUshort(sc, 0x02, 0x091F);
3953 MP_WriteEPhyUshort(sc, 0x03, 0xC5BA);
3954 MP_WriteEPhyUshort(sc, 0x06, 0xB279);
3955 MP_WriteEPhyUshort(sc, 0x07, 0xAF00);
3956 MP_WriteEPhyUshort(sc, 0x1E, 0xB8EB);
3957 } else if (sc->re_type == MACFG_33) {
3958 CSR_WRITE_1(sc, RE_CFG1, CSR_READ_1(sc, RE_CFG1)|0x10);
3959
3960 MP_WriteEPhyUshort(sc, 0x01, 0x6C7F);
3961 MP_WriteEPhyUshort(sc, 0x02, 0x011F);
3962 ClearAndSetPCIePhyBit(sc,
3963 0x03,
3964 0xFFF0,
3965 0x01B0
3966 );
3967 MP_WriteEPhyUshort(sc, 0x1A, 0x0546);
3968 MP_WriteEPhyUshort(sc, 0x1C, 0x80C4);
3969 MP_WriteEPhyUshort(sc, 0x1D, 0x78E5);
3970 MP_WriteEPhyUshort(sc, 0x0A, 0x8100);
3971 }
3972 } else if (macver == 0x28800000) {
3973 /*set configuration space offset 0x70f to 0x17*/
3974 Data32 = MP_ReadPciEConfigSpace(sc, 0x870c);
3975 Data32 &=0xC0FFFFFF;
3976 Data32 |= (0x17 << 24);
3977 MP_WritePciEConfigSpace(sc, 0x870c, Data32);
3978
3979 /* disable clock request. */
3980 pci_write_config(sc->dev, 0x81, 0x00, 1);
3981
3982 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0);
3983 CSR_WRITE_1(sc, RE_DBG_reg, CSR_READ_1(sc, RE_DBG_reg)|0x82);
3984
3985 CSR_WRITE_2 (sc, RE_CPlusCmd, 0x2060);
3986
3987 if (ifp->if_mtu > ETHERMTU) {
3988 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) | BIT_2); //Jumbo_en0
3989 CSR_WRITE_1(sc, RE_CFG4, CSR_READ_1(sc, RE_CFG4) | (1<<1)); //Jumbo_en1
3990
3991 data8 = pci_read_config(sc->dev, 0x79, 1);
3992 data8 &= ~0x70;
3993 data8 |= 0x20;
3994 pci_write_config(sc->dev, 0x79, data8, 1);
3995 ifp->if_capenable &= ~IFCAP_HWCSUM;
3996 CSR_WRITE_2 (sc, RE_CPlusCmd,CSR_READ_2(sc, RE_CPlusCmd) & ~RL_RxChkSum);
3997 ifp->if_hwassist &= ~RE_CSUM_FEATURES;
3998
3999 } else {
4000 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_2); //Jumbo_en0
4001 CSR_WRITE_1(sc, RE_CFG4, CSR_READ_1(sc, RE_CFG4) & ~(1<<1)); //Jumbo_en1
4002 data8 = pci_read_config(sc->dev, 0x79, 1);
4003 data8 &= ~0x70;
4004 data8 |= 0x50;
4005 pci_write_config(sc->dev, 0x79, data8, 1);
4006 if (sc->re_tx_cstag) {
4007 ifp->if_capenable |= IFCAP_TXCSUM;
4008 ifp->if_hwassist |= RE_CSUM_FEATURES;
4009 }
4010 if (sc->re_rx_cstag) {
4011 ifp->if_capenable |= IFCAP_RXCSUM;
4012 CSR_WRITE_2 (sc, RE_CPlusCmd,CSR_READ_2(sc, RE_CPlusCmd) |RL_RxChkSum);
4013 }
4014 }
4015
4016 if (sc->re_type == MACFG_65 || sc->re_type == MACFG_66) {
4017 SetPCIePhyBit(sc, 0x0B, (BIT_3 | BIT_6));
4018
4019 ClearAndSetPCIePhyBit(sc,
4020 0x19,
4021 BIT_5,
4022 (BIT_4 | BIT_6)
4023 );
4024
4025 ClearAndSetPCIePhyBit(sc,
4026 0x0C,
4027 BIT_8,
4028 BIT_5
4029 );
4030
4031 ClearPCIePhyBit(sc, 0x10, (BIT_2));
4032 }
4033 } else if (macver == 0x2C000000) {
4034 /*set configuration space offset 0x70f to 0x20*/
4035 Data32 = MP_ReadPciEConfigSpace(sc, 0x870c);
4036 Data32 &=0xC0FFFFFF;
4037 Data32 |= (0x20 << 24);
4038 MP_WritePciEConfigSpace(sc, 0x870c, Data32);
4039
4040 CSR_WRITE_1(sc, 0xF3, CSR_READ_1(sc, 0xF3)|0x20);
4041 CSR_WRITE_1(sc, 0xF3, CSR_READ_1(sc, 0xF3)& ~0x20);
4042
4043 CSR_WRITE_1(sc, 0xD0, CSR_READ_1(sc, 0xD0)|0xC0);
4044 CSR_WRITE_1(sc, 0xF1, CSR_READ_1(sc, 0xF1)|0xF3);
4045 CSR_WRITE_1(sc, RE_CFG5, (CSR_READ_1(sc, RE_CFG5)& ~0x08)|0x01);
4046 CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2)|0x80);
4047 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0);
4048
4049 if (sc->re_type == MACFG_36 || sc->re_type == MACFG_37) {
4050 /* set EPHY registers */
4051 data16 = MP_ReadEPhyUshort(sc, 0x00) & ~0x0200;
4052 data16 |= 0x0100;
4053 MP_WriteEPhyUshort(sc, 0x00, data16);
4054
4055 data16 = MP_ReadEPhyUshort(sc, 0x00);
4056 data16 |= 0x0004;
4057 MP_WriteEPhyUshort(sc, 0x00, data16);
4058
4059 data16 = MP_ReadEPhyUshort(sc, 0x06) & ~0x0002;
4060 data16 |= 0x0001;
4061 MP_WriteEPhyUshort(sc, 0x06, data16);
4062
4063 data16 = MP_ReadEPhyUshort(sc, 0x06);
4064 data16 |= 0x0030;
4065 MP_WriteEPhyUshort(sc, 0x06, data16);
4066
4067 data16 = MP_ReadEPhyUshort(sc, 0x07);
4068 data16 |= 0x2000;
4069 MP_WriteEPhyUshort(sc, 0x07, data16);
4070
4071 data16 = MP_ReadEPhyUshort(sc, 0x00);
4072 data16 |= 0x0020;
4073 MP_WriteEPhyUshort(sc, 0x00, data16);
4074
4075 data16 = MP_ReadEPhyUshort(sc, 0x03) & ~0x5800;
4076 data16 |= 0x2000;
4077 MP_WriteEPhyUshort(sc, 0x03, data16);
4078
4079 data16 = MP_ReadEPhyUshort(sc, 0x03);
4080 data16 |= 0x0001;
4081 MP_WriteEPhyUshort(sc, 0x03, data16);
4082
4083 data16 = MP_ReadEPhyUshort(sc, 0x01) & ~0x0800;
4084 data16 |= 0x1000;
4085 MP_WriteEPhyUshort(sc, 0x01, data16);
4086
4087 data16 = MP_ReadEPhyUshort(sc, 0x07);
4088 data16 |= 0x4000;
4089 MP_WriteEPhyUshort(sc, 0x07, data16);
4090
4091 data16 = MP_ReadEPhyUshort(sc, 0x1E);
4092 data16 |= 0x2000;
4093 MP_WriteEPhyUshort(sc, 0x1E, data16);
4094
4095 MP_WriteEPhyUshort(sc, 0x19, 0xFE6C);
4096
4097 data16 = MP_ReadEPhyUshort(sc, 0x0A);
4098 data16 |= 0x0040;
4099 MP_WriteEPhyUshort(sc, 0x0A, data16);
4100
4101 if (ifp->if_mtu > ETHERMTU) {
4102 CSR_WRITE_1 (sc, RE_MTPS, 0x24);
4103 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) | BIT_2);
4104 CSR_WRITE_1(sc, RE_CFG4, CSR_READ_1(sc, RE_CFG4) |0x01);
4105 data8 = pci_read_config(sc->dev, 0x79, 1);
4106 data8 &= ~0x70;
4107 data8 |= 0x20;
4108 pci_write_config(sc->dev, 0x79, data8, 1);
4109 ifp->if_capenable &= ~IFCAP_HWCSUM;
4110 CSR_WRITE_2 (sc, RE_CPlusCmd,CSR_READ_2(sc, RE_CPlusCmd) & ~RL_RxChkSum);
4111 ifp->if_hwassist &= ~RE_CSUM_FEATURES;
4112 } else {
4113 CSR_WRITE_1 (sc, RE_MTPS, 0x0c);
4114 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_2);
4115 CSR_WRITE_1(sc, RE_CFG4, CSR_READ_1(sc, RE_CFG4) & ~0x01);
4116 data8 = pci_read_config(sc->dev, 0x79, 1);
4117 data8 &= ~0x70;
4118 data8 |= 0x50;
4119 pci_write_config(sc->dev, 0x79, data8, 1);
4120
4121 if (sc->re_tx_cstag) {
4122 ifp->if_capenable |= IFCAP_TXCSUM;
4123 ifp->if_hwassist |= RE_CSUM_FEATURES;
4124 }
4125 if (sc->re_rx_cstag) {
4126 ifp->if_capenable |= IFCAP_RXCSUM;
4127 CSR_WRITE_2 (sc, RE_CPlusCmd,CSR_READ_2(sc, RE_CPlusCmd) |RL_RxChkSum);
4128 }
4129 }
4130
4131 //disable clock request.
4132 pci_write_config(sc->dev, 0x81, 1, 1);
4133 }
4134 } else if (macver == 0x2C800000) {
4135 /*set configuration space offset 0x70f to 0x27*/
4136 Data32 = MP_ReadPciEConfigSpace(sc, 0x870c);
4137 Data32 &=0xC0FFFFFF;
4138 Data32 |= (0x27 << 24);
4139 MP_WritePciEConfigSpace(sc, 0x870c, Data32);
4140
4141 data8 = pci_read_config(sc->dev, 0x79, 1);
4142 data8 &= ~0x70;
4143 data8 |= 0x50;
4144 pci_write_config(sc->dev, 0x79, data8, 1);
4145
4146 Data32 = CSR_READ_2(sc, RE_IDR0);
4147 Data32 <<= 16;
4148 Data32 &= 0xFFFF0000;
4149 re_eri_write(sc, 0xF0, 4, Data32, ERIAR_ExGMAC);
4150 Data32 = CSR_READ_2(sc, RE_IDR4);
4151 Data32 <<= 16;
4152 Data32 += CSR_READ_2(sc, RE_IDR2);
4153 re_eri_write(sc, 0xF4, 4, Data32, ERIAR_ExGMAC);
4154
4155 re_eri_write(sc, 0xC0, 2, 0x0000, ERIAR_ExGMAC);
4156 re_eri_write(sc, 0xB8, 4, 0x00000000, ERIAR_ExGMAC);
4157 re_eri_write(sc, 0xC8, 4, 0x00100002, ERIAR_ExGMAC);
4158 re_eri_write(sc, 0xE8, 4, 0x00100006, ERIAR_ExGMAC);
4159 Data32 = re_eri_read(sc, 0xdc, 4, ERIAR_ExGMAC);
4160 Data32 &= ~BIT_0;
4161 re_eri_write(sc, 0xdc, 1, Data32, ERIAR_ExGMAC);
4162 Data32 |= BIT_0;
4163 re_eri_write(sc, 0xdc, 1, Data32, ERIAR_ExGMAC);
4164
4165 Data32 = re_eri_read(sc, 0xD4, 4, ERIAR_ExGMAC);
4166 Data32 |= BIT_11 | BIT_10;
4167 re_eri_write(sc, 0xD4, 4, Data32, ERIAR_ExGMAC);
4168 if (sc ->re_type == MACFG_39) {
4169 Data32 = re_eri_read(sc, 0x1B0, 4, ERIAR_ExGMAC);
4170 Data32 |= BIT_4;
4171 re_eri_write(sc, 0x1B0, 4, Data32, ERIAR_ExGMAC);
4172 re_eri_write(sc, 0xCC, 4, 0x00000050, ERIAR_ExGMAC);
4173 re_eri_write(sc, 0xD0, 4, 0x07ff0060, ERIAR_ExGMAC);
4174 }
4175
4176 CSR_WRITE_4(sc, RE_TXCFG, CSR_READ_4(sc, RE_TXCFG) |BIT_7);
4177 CSR_WRITE_1(sc, 0xD3, CSR_READ_1(sc, 0xD3) & ~BIT_7);
4178 CSR_WRITE_1(sc, 0x1B, CSR_READ_1(sc, 0x1B) & ~0x07);
4179 CSR_WRITE_1(sc, 0xF1,CSR_READ_1(sc, 0xF1) & ~ BIT_7);
4180
4181 CSR_WRITE_2 (sc, RE_CPlusCmd, 0x2060);
4182
4183 if (sc ->re_type == MACFG_38) {
4184 CSR_WRITE_4(sc, 0xB0, 0xEE480010);
4185 CSR_WRITE_1(sc, 0x1A, CSR_READ_1(sc, 0x1A) & ~(BIT_2 |BIT_3));
4186 re_eri_write(sc, 0x1DC, 1, 0x64, ERIAR_ExGMAC);
4187
4188 MP_WriteEPhyUshort(sc, 0x06, 0xF020);
4189 MP_WriteEPhyUshort(sc, 0x07, 0x01FF);
4190 MP_WriteEPhyUshort(sc, 0x00, 0x5027);
4191 MP_WriteEPhyUshort(sc, 0x01, 0x0003);
4192 MP_WriteEPhyUshort(sc, 0x02, 0x2D16);
4193 MP_WriteEPhyUshort(sc, 0x03, 0x6D49);
4194 MP_WriteEPhyUshort(sc, 0x08, 0x0006);
4195 MP_WriteEPhyUshort(sc, 0x0A, 0x00C8);
4196 }
4197
4198 data16 = MP_ReadEPhyUshort(sc, 0x09);
4199 data16 |= BIT_7;
4200 MP_WriteEPhyUshort(sc, 0x09, data16);
4201
4202 data16 = MP_ReadEPhyUshort(sc, 0x19);
4203 data16 |= (BIT_2 | BIT_5 | BIT_9);
4204 MP_WriteEPhyUshort(sc, 0x19, data16);
4205
4206 SetPCIePhyBit(sc, 0x00, BIT_3);
4207 ClearAndSetPCIePhyBit(sc,
4208 0x0C,
4209 (BIT_13|BIT_12|BIT_11|BIT_10|BIT_8|BIT_7|BIT_6|BIT_5|BIT_4),
4210 BIT_9
4211 );
4212
4213 CSR_WRITE_1(sc, RE_CFG5, CSR_READ_1(sc, RE_CFG5) | BIT_0);
4214 CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2) | BIT_5 |BIT_7);
4215 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0);
4216
4217 CSR_WRITE_1(sc, 0xD0, CSR_READ_1(sc, 0xD0) | BIT_6);
4218 CSR_WRITE_1(sc, 0xF2, CSR_READ_1(sc, 0xF2) | BIT_6);
4219
4220 CSR_WRITE_1 (sc, RE_MTPS, 0x27);
4221 ifp->if_capenable &= ~IFCAP_HWCSUM ;
4222 ifp->if_hwassist &= ~RE_CSUM_FEATURES;
4223
4224 /* disable clock request. */
4225 pci_write_config(sc->dev, 0x81, 0x00, 1);
4226 } else if (macver == 0x24000000) {
4227 if (pci_read_config(sc->dev, 0x81, 1)==1) {
4228 CSR_WRITE_1(sc, RE_DBG_reg, 0x98);
4229 CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2) | 0x80);
4230 CSR_WRITE_1(sc, RE_CFG4, CSR_READ_1(sc, RE_CFG4) | 0x04);
4231 pci_write_config(sc->dev, 0x81, 1, 1);
4232 }
4233 data8 = pci_read_config(sc->dev, 0x79, 1);
4234 data8 &= ~0x70;
4235 data8 |= 0x50;
4236 pci_write_config(sc->dev, 0x79, data8, 1);
4237
4238 /*set configuration space offset 0x70f to 0x3F*/
4239 Data32 = MP_ReadPciEConfigSpace(sc, 0x870c);
4240 Data32 &=0xC0FFFFFF;
4241 Data32 |= (0x3F << 24);
4242 MP_WritePciEConfigSpace(sc, 0x870c, Data32);
4243
4244 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0);
4245
4246 CSR_WRITE_2 (sc, RE_CPlusCmd, 0x2060);
4247
4248 MP_WriteEPhyUshort(sc, 0x06, 0xAF25);
4249 MP_WriteEPhyUshort(sc, 0x07, 0x8E68);
4250 } else if (macver == 0x40800000) {
4251 if (pci_read_config(sc->dev, 0x80, 1) & 0x03) {
4252 CSR_WRITE_1(sc, RE_CFG5, CSR_READ_1(sc, RE_CFG5) | 1);
4253 CSR_WRITE_1(sc, 0xF1, CSR_READ_1(sc, 0xF1) | 0x80);
4254 CSR_WRITE_1(sc, 0xF2, CSR_READ_1(sc, 0xF2) | 0x80);
4255 CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2) | 0x80);
4256 }
4257 CSR_WRITE_1(sc, 0xF1, CSR_READ_1(sc, 0xF1) | 0x28);
4258 CSR_WRITE_1(sc, 0xD3, CSR_READ_1(sc, 0xD3) | 0x0C);
4259 CSR_WRITE_1(sc, 0xD3, CSR_READ_1(sc, 0xD3) & ~BIT_7);
4260 CSR_WRITE_1(sc, 0xD0, CSR_READ_1(sc, 0xD0) | 0x40);
4261 CSR_WRITE_2(sc, 0xE0, CSR_READ_2(sc, 0xE0) & ~0xDF9C);
4262 CSR_WRITE_1(sc, 0xD1, CSR_READ_1(sc, 0xD1) | 0x02);
4263
4264 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0);
4265
4266 if (sc->re_type == MACFG_42) {
4267 /* set EPHY registers */
4268 SetPCIePhyBit(sc, 0x07, BIT_14);
4269 SetPCIePhyBit(sc, 0x19, BIT_9);
4270 SetPCIePhyBit(sc, 0x19, BIT_5);
4271 SetPCIePhyBit(sc, 0x1E, BIT_13);
4272 SetPCIePhyBit(sc, 0x03, BIT_0);
4273 SetPCIePhyBit(sc, 0x19, BIT_8);
4274 SetPCIePhyBit(sc, 0x19, BIT_2);
4275 SetPCIePhyBit(sc, 0x0A, BIT_5);
4276 SetPCIePhyBit(sc, 0x05, BIT_13);
4277 }
4278 if (sc->re_type == MACFG_43) {
4279 SetPCIePhyBit(sc, 0x07, BIT_14);
4280 SetPCIePhyBit(sc, 0x19, BIT_9);
4281 SetPCIePhyBit(sc, 0x19, BIT_5);
4282 SetPCIePhyBit(sc, 0x1E, BIT_13);
4283 SetPCIePhyBit(sc, 0x03, BIT_0);
4284 SetPCIePhyBit(sc, 0x19, BIT_8);
4285 SetPCIePhyBit(sc, 0x19, BIT_2);
4286 SetPCIePhyBit(sc, 0x0A, BIT_5);
4287 SetPCIePhyBit(sc, 0x1E, BIT_15);
4288 SetPCIePhyBit(sc, 0x05, BIT_13);
4289 }
4290 } else if (macver == 0x44000000) {
4291
4292 CSR_WRITE_2(sc, 0xE0, CSR_READ_2(sc, 0xE0) & ~0xDF9C);
4293
4294 re_eri_write(sc, 0xC8, 4, 0x00000002, ERIAR_ExGMAC);
4295 re_eri_write(sc, 0xE8, 4, 0x00000006, ERIAR_ExGMAC);
4296
4297 Data32 = re_eri_read(sc, 0xD4, 4, ERIAR_ExGMAC);
4298 Data32 |= BIT_11 | BIT_10;
4299 re_eri_write(sc, 0xD4, 4, Data32, ERIAR_ExGMAC);
4300
4301 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0);
4302
4303 /* set EPHY registers */
4304 MP_WriteEPhyUshort(sc, 0x19, 0xFF64);
4305
4306 CSR_WRITE_1 (sc, RE_MTPS, 0x27);
4307 } else if (macver == 0x48000000) {
4308 /*set configuration space offset 0x70f to 0x27*/
4309 Data32 = MP_ReadPciEConfigSpace(sc, 0x870c);
4310 Data32 &=0xC0FFFFFF;
4311 Data32 |= (0x27 << 24);
4312 MP_WritePciEConfigSpace(sc, 0x870c, Data32);
4313
4314 data8 = pci_read_config(sc->dev, 0x79, 1);
4315 data8 &= ~0x70;
4316 data8 |= 0x50;
4317 pci_write_config(sc->dev, 0x79, data8, 1);
4318
4319 Data32 = re_eri_read(sc, 0xD4, 4, ERIAR_ExGMAC);
4320 Data32 |= BIT_11 | BIT_10;
4321 re_eri_write(sc, 0xD4, 4, Data32, ERIAR_ExGMAC);
4322 re_eri_write(sc, 0xC0, 2, 0x0000, ERIAR_ExGMAC);
4323 re_eri_write(sc, 0xB8, 4, 0x00000000, ERIAR_ExGMAC);
4324 re_eri_write(sc, 0xC8, 4, 0x00100002, ERIAR_ExGMAC);
4325 re_eri_write(sc, 0xE8, 4, 0x00100006, ERIAR_ExGMAC);
4326 Data32 = re_eri_read(sc, 0xdc, 4, ERIAR_ExGMAC);
4327 Data32 &= ~BIT_0;
4328 re_eri_write(sc, 0xdc, 1, Data32, ERIAR_ExGMAC);
4329 Data32 |= BIT_0;
4330 re_eri_write(sc, 0xdc, 1, Data32, ERIAR_ExGMAC);
4331 Data32 = re_eri_read(sc, 0x1B0, 4, ERIAR_ExGMAC);
4332 Data32 |= BIT_4;
4333 re_eri_write(sc, 0x1B0, 4, Data32, ERIAR_ExGMAC);
4334 re_eri_write(sc, 0xCC, 4, 0x00000050, ERIAR_ExGMAC);
4335 re_eri_write(sc, 0xD0, 4, 0x00000060, ERIAR_ExGMAC);
4336 Data32 = re_eri_read(sc, 0x1D0, 4, ERIAR_ExGMAC);
4337 Data32 |= BIT_4;
4338 re_eri_write(sc, 0x1D0, 4, Data32, ERIAR_ExGMAC);
4339
4340 CSR_WRITE_4(sc, RE_TXCFG, CSR_READ_4(sc, RE_TXCFG) | BIT_7);
4341 CSR_WRITE_1(sc, 0xD3, CSR_READ_1(sc, 0xD3) & ~BIT_7);
4342 CSR_WRITE_1(sc, 0x1B, CSR_READ_1(sc, 0x1B) & ~0x07);
4343
4344 CSR_WRITE_2 (sc, RE_CPlusCmd, 0x2060);
4345
4346 if (sc->re_type == MACFG_50) {
4347 data16 = MP_ReadEPhyUshort(sc, 0x06);
4348 data16 &= ~(BIT_7 | BIT_6);
4349 data16 |= BIT_5;
4350 MP_WriteEPhyUshort(sc, 0x06, data16);
4351
4352 data16 = MP_ReadEPhyUshort(sc, 0x08);
4353 data16 &= ~BIT_0;
4354 data16 |= BIT_1;
4355 MP_WriteEPhyUshort(sc, 0x08, data16);
4356 }
4357
4358 data16 = MP_ReadEPhyUshort(sc, 0x09);
4359 data16 |= BIT_7;
4360 MP_WriteEPhyUshort(sc, 0x09, data16);
4361
4362 data16 = MP_ReadEPhyUshort(sc, 0x19);
4363 data16 |= (BIT_2 | BIT_5 | BIT_9);
4364 MP_WriteEPhyUshort(sc, 0x19, data16);
4365
4366 SetPCIePhyBit(sc, 0x00, BIT_3);
4367 ClearAndSetPCIePhyBit(sc,
4368 0x0C,
4369 (BIT_13|BIT_12|BIT_11|BIT_10|BIT_8|BIT_7|BIT_6|BIT_5|BIT_4),
4370 BIT_9
4371 );
4372
4373 CSR_WRITE_1(sc, RE_CFG5, CSR_READ_1(sc, RE_CFG5) | BIT_0);
4374 CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2) | BIT_7);
4375 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0);
4376
4377 CSR_WRITE_1(sc, 0xD0, CSR_READ_1(sc, 0xD0) | BIT_6);
4378 CSR_WRITE_1(sc, 0xF2, CSR_READ_1(sc, 0xF2) | BIT_6);
4379
4380 CSR_WRITE_1 (sc, RE_MTPS, 0x27);
4381
4382 if (ifp->if_mtu > ETHERMTU) {
4383 ifp->if_capenable &= ~IFCAP_HWCSUM ;
4384 ifp->if_hwassist &= ~RE_CSUM_FEATURES;
4385 } else {
4386 if (sc->re_tx_cstag) {
4387 ifp->if_capenable |= IFCAP_TXCSUM;
4388 ifp->if_hwassist |= RE_CSUM_FEATURES;
4389 }
4390 if (sc->re_rx_cstag) {
4391 ifp->if_capenable |= IFCAP_RXCSUM;
4392 }
4393 }
4394
4395 /* disable clock request. */
4396 pci_write_config(sc->dev, 0x81, 0x00, 1);
4397 } else if (macver == 0x48800000) {
4398 /*set configuration space offset 0x70f to 0x27*/
4399 Data32 = MP_ReadPciEConfigSpace(sc, 0x870c);
4400 Data32 &=0xC0FFFFFF;
4401 Data32 |= (0x27 << 24);
4402 MP_WritePciEConfigSpace(sc, 0x870c, Data32);
4403
4404 data8 = pci_read_config(sc->dev, 0x79, 1);
4405 data8 &= ~0x70;
4406 data8 |= 0x50;
4407 pci_write_config(sc->dev, 0x79, data8, 1);
4408
4409 Data32 = re_eri_read(sc, 0xD4, 4, ERIAR_ExGMAC);
4410 Data32 |= BIT_11 | BIT_10;
4411 re_eri_write(sc, 0xD4, 4, Data32, ERIAR_ExGMAC);
4412 re_eri_write(sc, 0xC0, 2, 0x0000, ERIAR_ExGMAC);
4413 re_eri_write(sc, 0xB8, 4, 0x00000000, ERIAR_ExGMAC);
4414 re_eri_write(sc, 0xC8, 4, 0x00100002, ERIAR_ExGMAC);
4415 re_eri_write(sc, 0xE8, 4, 0x00100006, ERIAR_ExGMAC);
4416 Data32 = re_eri_read(sc, 0xdc, 4, ERIAR_ExGMAC);
4417 Data32 &= ~BIT_0;
4418 re_eri_write(sc, 0xdc, 1, Data32, ERIAR_ExGMAC);
4419 Data32 |= BIT_0;
4420 re_eri_write(sc, 0xdc, 1, Data32, ERIAR_ExGMAC);
4421 Data32 = re_eri_read(sc, 0x1B0, 4, ERIAR_ExGMAC);
4422 Data32 |= BIT_4;
4423 re_eri_write(sc, 0x1B0, 4, Data32, ERIAR_ExGMAC);
4424 re_eri_write(sc, 0xCC, 4, 0x00000050, ERIAR_ExGMAC);
4425 re_eri_write(sc, 0xD0, 4, 0x00000060, ERIAR_ExGMAC);
4426 Data32 = re_eri_read(sc, 0x1D0, 4, ERIAR_ExGMAC);
4427 Data32 |= BIT_4;
4428 re_eri_write(sc, 0x1D0, 4, Data32, ERIAR_ExGMAC);
4429
4430 CSR_WRITE_4(sc, RE_TXCFG, CSR_READ_4(sc, RE_TXCFG) | BIT_7);
4431 CSR_WRITE_1(sc, 0xD3, CSR_READ_1(sc, 0xD3) & ~BIT_7);
4432 // CSR_WRITE_1(sc, 0x1B, CSR_READ_1(sc, 0x1B) & ~0x07);
4433
4434 CSR_WRITE_2 (sc, RE_CPlusCmd, 0x2060);
4435
4436 data16 = MP_ReadEPhyUshort(sc, 0x06);
4437 data16 &= ~(BIT_7 | BIT_6);
4438 data16 |= BIT_5;
4439 MP_WriteEPhyUshort(sc, 0x06, data16);
4440
4441 MP_WriteEPhyUshort(sc, 0x0f, 0x5200);
4442
4443 data16 = MP_ReadEPhyUshort(sc, 0x1e);
4444 data16 |= BIT_14;
4445 MP_WriteEPhyUshort(sc, 0x1e, data16);
4446
4447 data16 = MP_ReadEPhyUshort(sc, 0x19);
4448 data16 |= (BIT_2 | BIT_5 | BIT_9);
4449 MP_WriteEPhyUshort(sc, 0x19, data16);
4450
4451 SetPCIePhyBit(sc, 0x00, BIT_3);
4452 ClearAndSetPCIePhyBit(sc,
4453 0x0C,
4454 (BIT_13|BIT_12|BIT_11|BIT_10|BIT_8|BIT_7|BIT_6|BIT_5|BIT_4),
4455 BIT_9
4456 );
4457
4458 CSR_WRITE_1(sc, RE_CFG5, CSR_READ_1(sc, RE_CFG5) | BIT_0);
4459 CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2) | BIT_7);
4460 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0);
4461
4462 CSR_WRITE_1(sc, 0xD0, CSR_READ_1(sc, 0xD0) | BIT_6);
4463 CSR_WRITE_1(sc, 0xF2, CSR_READ_1(sc, 0xF2) | BIT_6);
4464
4465 CSR_WRITE_1 (sc, RE_MTPS, 0x27);
4466
4467 if (ifp->if_mtu > ETHERMTU) {
4468 ifp->if_capenable &= ~IFCAP_HWCSUM ;
4469 ifp->if_hwassist &= ~RE_CSUM_FEATURES;
4470 } else {
4471 if (sc->re_tx_cstag) {
4472 ifp->if_capenable |= IFCAP_TXCSUM;
4473 ifp->if_hwassist |= RE_CSUM_FEATURES;
4474 }
4475 if (sc->re_rx_cstag) {
4476 ifp->if_capenable |= IFCAP_RXCSUM;
4477 }
4478 }
4479
4480 /* disable clock request. */
4481 pci_write_config(sc->dev, 0x81, 0x00, 1);
4482 } else if (macver == 0x44800000) {
4483 if (pci_read_config(sc->dev, 0x80, 1) & 0x03) {
4484 CSR_WRITE_1(sc, RE_CFG5, CSR_READ_1(sc, RE_CFG5) | 1);
4485 CSR_WRITE_1(sc, 0xF1, CSR_READ_1(sc, 0xF1) | 0x80);
4486 CSR_WRITE_1(sc, 0xF2, CSR_READ_1(sc, 0xF2) | 0x80);
4487 CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2) | 0x80);
4488 }
4489 CSR_WRITE_1(sc, 0xF1, CSR_READ_1(sc, 0xF1) | 0x28);
4490 CSR_WRITE_1(sc, 0xD3, CSR_READ_1(sc, 0xD3) | 0x0C);
4491 CSR_WRITE_1(sc, 0xD3, CSR_READ_1(sc, 0xD3) & ~BIT_7);
4492 CSR_WRITE_1(sc, 0xD0, CSR_READ_1(sc, 0xD0) | 0x40);
4493 CSR_WRITE_2(sc, 0xE0, CSR_READ_2(sc, 0xE0) & ~0xDF9C);
4494
4495 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0);
4496 } else if (macver == 0x4C000000 || macver == 0x50800000 ||
4497 macver == 0x5C800000 || macver == 0x54000000) {
4498 CSR_WRITE_1(sc, RE_CFG5, CSR_READ_1(sc, RE_CFG5) & ~BIT_0);
4499 CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2) & ~BIT_7);
4500 CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2) | BIT_5);
4501
4502 if (sc->re_type == MACFG_59) {
4503 MP_WriteMcuAccessRegWord(sc, 0xD3C0, 0x03F8);
4504 MP_WriteMcuAccessRegWord(sc, 0xD3C2, 0x0000);
4505 }
4506
4507 if (sc->re_type == MACFG_68 || sc->re_type == MACFG_69) {
4508 MP_WriteMcuAccessRegWord(sc, 0xD400, MP_ReadMcuAccessRegWord(sc, 0xD400) & ~(BIT_0));
4509
4510 data16 = MP_ReadMcuAccessRegWord(sc, 0xE63E);
4511 data16 &= ~(BIT_3 | BIT_2 | BIT_1);
4512 MP_WriteMcuAccessRegWord(sc, 0xE63E, data16);
4513 data16 |= (BIT_0);
4514 MP_WriteMcuAccessRegWord(sc, 0xE63E, data16);
4515 data16 &= ~(BIT_0);
4516 MP_WriteMcuAccessRegWord(sc, 0xE63E, data16);
4517 MP_WriteMcuAccessRegWord(sc, 0xC094, 0x0);
4518 MP_WriteMcuAccessRegWord(sc, 0xC09E, 0x0);
4519
4520 MP_WriteMcuAccessRegWord(sc, 0xE098, 0x0AA2);
4521 }
4522
4523 /*set configuration space offset 0x70f to 0x17*/
4524 Data32 = MP_ReadPciEConfigSpace(sc, 0x870c);
4525 Data32 &=0xC0FFFFFF;
4526 Data32 |= (0x17 << 24);
4527 MP_WritePciEConfigSpace(sc, 0x870c, Data32);
4528
4529 data8 = pci_read_config(sc->dev, 0x79, 1);
4530 data8 &= ~0x70;
4531 data8 |= 0x50;
4532 pci_write_config(sc->dev, 0x79, data8, 1);
4533
4534 if (sc->re_type == MACFG_56 || sc->re_type == MACFG_57) {
4535 Data32 = MP_ReadPciEConfigSpace(sc, 0x2710);
4536 Data32 &=0xFFFF0FFF;
4537 Data32 |= (0x04 << 12);
4538 MP_WritePciEConfigSpace(sc, 0x2710, Data32);
4539 }
4540
4541 if (sc->re_type == MACFG_68 || sc->re_type == MACFG_69) {
4542 Data32 = re_eri_read(sc, 0xD4, 4, ERIAR_ExGMAC);
4543 Data32 |= (BIT_8 | BIT_9 | BIT_10 | BIT_11 | BIT_12);
4544 re_eri_write(sc, 0xD4, 4, Data32, ERIAR_ExGMAC);
4545
4546 Data32 = re_eri_read(sc, 0xDC, 4, ERIAR_ExGMAC);
4547 Data32 |= (BIT_2| BIT_3 | BIT_4);
4548 re_eri_write(sc, 0xDC, 4, Data32, ERIAR_ExGMAC);
4549 } else {
4550 Data32 = re_eri_read(sc, 0xD4, 4, ERIAR_ExGMAC);
4551 Data32 |= (BIT_7 | BIT_8 | BIT_9 | BIT_10 | BIT_11 | BIT_12);
4552 re_eri_write(sc, 0xD4, 4, Data32, ERIAR_ExGMAC);
4553 }
4554
4555 re_eri_write(sc, 0xC8, 4, 0x00080002, ERIAR_ExGMAC);
4556 re_eri_write(sc, 0xCC, 1, 0x38, ERIAR_ExGMAC);
4557 re_eri_write(sc, 0xD0, 1, 0x48, ERIAR_ExGMAC);
4558 re_eri_write(sc, 0xE8, 4, 0x00100006, ERIAR_ExGMAC);
4559
4560 re_eri_write(sc, 0x5F0, 4, 0x4F87, ERIAR_ExGMAC);
4561
4562 Data32 = re_eri_read(sc, 0xdc, 4, ERIAR_ExGMAC);
4563 Data32 &= ~BIT_0;
4564 re_eri_write(sc, 0xdc, 1, Data32, ERIAR_ExGMAC);
4565 Data32 |= BIT_0;
4566 re_eri_write(sc, 0xdc, 1, Data32, ERIAR_ExGMAC);
4567
4568 Data32 = re_eri_read(sc, 0x2FC, 4, ERIAR_ExGMAC);
4569 Data32 &= ~(BIT_0 | BIT_1 | BIT_2);
4570 Data32 |= (BIT_0);
4571 re_eri_write(sc, 0x2FC, 4, Data32, ERIAR_ExGMAC);
4572
4573 Data32 = re_eri_read(sc, 0x1B0, 4, ERIAR_ExGMAC);
4574 Data32 &= ~BIT_12;
4575 re_eri_write(sc, 0x1B0, 4, Data32, ERIAR_ExGMAC);
4576
4577 CSR_WRITE_4(sc, RE_TXCFG, CSR_READ_4(sc, RE_TXCFG) | BIT_7);
4578 CSR_WRITE_1(sc, 0xD3, CSR_READ_1(sc, 0xD3) & ~BIT_7);
4579 CSR_WRITE_1(sc, 0x1B, CSR_READ_1(sc, 0x1B) & ~0x07);
4580
4581 CSR_WRITE_2 (sc, RE_CPlusCmd, 0x2060);
4582
4583 if (sc->re_type == MACFG_56 || sc->re_type == MACFG_57) {
4584 ClearPCIePhyBit(sc, 0x00, BIT_3);
4585 ClearAndSetPCIePhyBit(sc,
4586 0x0C,
4587 (BIT_13|BIT_12|BIT_10|BIT_9|BIT_8|BIT_7|BIT_6|BIT_4),
4588 (BIT_11|BIT_5)
4589 );
4590 SetPCIePhyBit(sc, 0x1E, BIT_0);
4591 ClearPCIePhyBit(sc, 0x19, BIT_15);
4592 } else if (sc->re_type == MACFG_58) {
4593 SetPCIePhyBit(sc, 0x00, (BIT_3));
4594 ClearAndSetPCIePhyBit(sc,
4595 0x0C,
4596 (BIT_13 | BIT_12 | BIT_11 | BIT_10 | BIT_8 | BIT_7 | BIT_6 | BIT_5 | BIT_4),
4597 BIT_9
4598 );
4599 } else if (sc->re_type == MACFG_59) {
4600 ClearPCIePhyBit(sc, 0x00, BIT_3);
4601 ClearAndSetPCIePhyBit(sc,
4602 0x0C,
4603 (BIT_13 | BIT_12 | BIT_10 | BIT_9 | BIT_8 | BIT_7 | BIT_6 | BIT_4),
4604 (BIT_5 | BIT_11)
4605 );
4606
4607 SetPCIePhyBit(sc, 0x1E, BIT_0);
4608 ClearPCIePhyBit(sc, 0x19, BIT_15);
4609 MP_WriteEPhyUshort(sc, 0x19, 0x7C00);
4610 MP_WriteEPhyUshort(sc, 0x1E, 0x20EB);
4611 MP_WriteEPhyUshort(sc, 0x0D, 0x1666);
4612 MP_WriteEPhyUshort(sc, 0x00, 0x10A3);
4613
4614 MP_WriteEPhyUshort(sc, 0x06, 0xF050);
4615 } else if (sc->re_type == MACFG_60) {
4616 ClearPCIePhyBit(sc, 0x00, BIT_3);
4617 ClearAndSetPCIePhyBit(sc,
4618 0x0C,
4619 (BIT_13 | BIT_12 | BIT_10 | BIT_9 | BIT_8 | BIT_7 | BIT_6 | BIT_4),
4620 (BIT_5 | BIT_11)
4621 );
4622 SetPCIePhyBit(sc, 0x1E, BIT_0);
4623 ClearPCIePhyBit(sc, 0x19, BIT_15);
4624
4625 ClearPCIePhyBit(sc, 0x19, (BIT_5 | BIT_0));
4626
4627 SetPCIePhyBit(sc, 0x1E, BIT_13);
4628 ClearPCIePhyBit(sc, 0x0D, BIT_8);
4629 SetPCIePhyBit(sc, 0x0D, BIT_9);
4630 SetPCIePhyBit(sc, 0x00, BIT_7);
4631
4632 SetPCIePhyBit(sc, 0x06, BIT_4);
4633 } else if (sc->re_type == MACFG_68 || sc->re_type == MACFG_69) {
4634 ClearPCIePhyBit(sc, 0x1E, BIT_11);
4635
4636 SetPCIePhyBit(sc, 0x1E, BIT_0);
4637 SetPCIePhyBit(sc, 0x1D, BIT_11);
4638
4639 MP_WriteEPhyUshort(sc, 0x05, 0x2089);
4640 MP_WriteEPhyUshort(sc, 0x06, 0x5881);
4641
4642 MP_WriteEPhyUshort(sc, 0x04, 0x154A);
4643 MP_WriteEPhyUshort(sc, 0x01, 0x068B);
4644 }
4645
4646 if (sc->re_type == MACFG_60) {
4647 data16 = MP_ReadMcuAccessRegWord(sc, 0xD3C0);
4648 data16 &= 0xF000;
4649 data16 |= 0x3A9;
4650 MP_WriteMcuAccessRegWord(sc, 0xD3C0, data16);
4651
4652 data16 = MP_ReadMcuAccessRegWord(sc, 0xD3C2);
4653 data16 &= 0xFF00;
4654 MP_WriteMcuAccessRegWord(sc, 0xD3C2, data16);
4655
4656 data16 = MP_ReadMcuAccessRegWord(sc, 0xD3C4);
4657 data16 |= (BIT_0);
4658 MP_WriteMcuAccessRegWord(sc, 0xD3C4, data16);
4659 } else if (sc->re_type == MACFG_68 || sc->re_type == MACFG_69) {
4660 if (sc->RequireAdjustUpsTxLinkPulseTiming) {
4661 data16 = MP_ReadMcuAccessRegWord(sc, 0xD412);
4662 data16 &= ~(0x0FFF);
4663 data16 |= sc->SwrCnt1msIni ;
4664 MP_WriteMcuAccessRegWord(sc, 0xD412, data16);
4665 }
4666
4667 data16 = MP_ReadMcuAccessRegWord(sc, 0xE056);
4668 data16 &= ~(BIT_7 | BIT_6 | BIT_5 | BIT_4);
4669 data16 |= (BIT_6 | BIT_5 | BIT_4);
4670 MP_WriteMcuAccessRegWord(sc, 0xE056, data16);
4671
4672 data16 = MP_ReadMcuAccessRegWord(sc, 0xE052);
4673 data16 &= ~(BIT_14 | BIT_13);
4674 data16 |= BIT_15;
4675 data16 |= BIT_3;
4676 MP_WriteMcuAccessRegWord(sc, 0xE052, data16);
4677
4678 data16 = MP_ReadMcuAccessRegWord(sc, 0xD420);
4679 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);
4680 data16 |= 0x47F;
4681 MP_WriteMcuAccessRegWord(sc, 0xD420, data16);
4682
4683 data16 = MP_ReadMcuAccessRegWord(sc, 0xE0D6);
4684 data16 &= ~(BIT_8 | BIT_7 | BIT_6 | BIT_5 | BIT_4 | BIT_3 | BIT_2 | BIT_1 | BIT_0);
4685 data16 |= 0x17F;
4686 MP_WriteMcuAccessRegWord(sc, 0xE0D6, data16);
4687 }
4688
4689
4690 CSR_WRITE_1(sc, RE_CFG5, CSR_READ_1(sc, RE_CFG5) | BIT_0);
4691 CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2) | BIT_7);
4692 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0);
4693
4694 CSR_WRITE_1(sc, 0xD0, CSR_READ_1(sc, 0xD0) | BIT_6);
4695 CSR_WRITE_1(sc, 0xF2, CSR_READ_1(sc, 0xF2) | BIT_6);
4696
4697 CSR_WRITE_1(sc, 0xF2, CSR_READ_1(sc, 0xF2) & ~BIT_3);
4698
4699 CSR_WRITE_1 (sc, RE_MTPS, 0x27);
4700
4701 if (sc->re_type == MACFG_56 || sc->re_type == MACFG_57 ||
4702 sc->re_type == MACFG_58 || sc->re_type == MACFG_59) {
4703 MP_WriteMcuAccessRegWord(sc, 0xC140, 0xFFFF);
4704 } else if (sc->re_type == MACFG_68 || sc->re_type == MACFG_69) {
4705 MP_WriteMcuAccessRegWord(sc, 0xC140, 0xFFFF);
4706 MP_WriteMcuAccessRegWord(sc, 0xC142, 0xFFFF);
4707 }
4708
4709 if (ifp->if_mtu > ETHERMTU) {
4710 ifp->if_capenable &= ~IFCAP_HWCSUM ;
4711 ifp->if_hwassist &= ~RE_CSUM_FEATURES;
4712 } else {
4713 if (sc->re_tx_cstag) {
4714 ifp->if_capenable |= IFCAP_TXCSUM;
4715 ifp->if_hwassist |= RE_CSUM_FEATURES;
4716 }
4717 if (sc->re_rx_cstag) {
4718 ifp->if_capenable |= IFCAP_RXCSUM;
4719 }
4720 }
4721
4722 /* disable clock request. */
4723 pci_write_config(sc->dev, 0x81, 0x00, 1);
4724 } else if (macver == 0x50000000) {
4725
4726 CSR_WRITE_1(sc, RE_CFG5, CSR_READ_1(sc, RE_CFG5) & ~BIT_0);
4727 CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2) & ~BIT_7);
4728
4729 /*set configuration space offset 0x70f to 0x17*/
4730 Data32 = MP_ReadPciEConfigSpace(sc, 0x870c);
4731 Data32 &=0xC0FFFFFF;
4732 Data32 |= (0x17 << 24);
4733 MP_WritePciEConfigSpace(sc, 0x870c, Data32);
4734
4735 data8 = pci_read_config(sc->dev, 0x79, 1);
4736 data8 &= ~0x70;
4737 data8 |= 0x50;
4738 pci_write_config(sc->dev, 0x79, data8, 1);
4739
4740 Data32 = re_eri_read(sc, 0xD4, 4, ERIAR_ExGMAC);
4741 Data32 |= BIT_7 | BIT_8 | BIT_9 | BIT_10 | BIT_11 | BIT_12;
4742 re_eri_write(sc, 0xD4, 4, Data32, ERIAR_ExGMAC);
4743
4744 re_eri_write(sc, 0xC8, 4, 0x00080002, ERIAR_ExGMAC);
4745 re_eri_write(sc, 0xCC, 1, 0x2F, ERIAR_ExGMAC);
4746 re_eri_write(sc, 0xD0, 1, 0x5F, ERIAR_ExGMAC);
4747 re_eri_write(sc, 0xE8, 4, 0x00100006, ERIAR_ExGMAC);
4748
4749 if (sc->re_type == MACFG_62 || sc->re_type == MACFG_67) {
4750 OOB_mutex_lock(sc);
4751 re_eri_write(sc, 0x5F0, 4, 0x4F87, ERIAR_ExGMAC);
4752 OOB_mutex_unlock(sc);
4753 }
4754
4755 Data32 = re_eri_read(sc, 0xdc, 4, ERIAR_ExGMAC);
4756 Data32 &= ~BIT_0;
4757 re_eri_write(sc, 0xdc, 1, Data32, ERIAR_ExGMAC);
4758 Data32 |= BIT_0;
4759 re_eri_write(sc, 0xdc, 1, Data32, ERIAR_ExGMAC);
4760
4761 Data32 = re_eri_read(sc, 0x2FC, 4, ERIAR_ExGMAC);
4762 Data32 &= ~(BIT_0 | BIT_1 | BIT_2);
4763 Data32 |= (BIT_0);
4764 re_eri_write(sc, 0x2FC, 4, Data32, ERIAR_ExGMAC);
4765
4766 Data32 = re_eri_read(sc, 0x1B0, 4, ERIAR_ExGMAC);
4767 Data32 &= ~BIT_12;
4768 re_eri_write(sc, 0x1B0, 4, Data32, ERIAR_ExGMAC);
4769
4770 CSR_WRITE_4(sc, RE_TXCFG, CSR_READ_4(sc, RE_TXCFG) | BIT_7);
4771 CSR_WRITE_1(sc, 0xD3, CSR_READ_1(sc, 0xD3) & ~BIT_7);
4772 CSR_WRITE_1(sc, 0x1B, CSR_READ_1(sc, 0x1B) & ~0x07);
4773
4774 CSR_WRITE_2 (sc, RE_CPlusCmd, 0x2060);
4775
4776 if (sc->re_type == MACFG_61) {
4777 MP_WriteEPhyUshort(sc, 0x00, 0x10AB);
4778 MP_WriteEPhyUshort(sc, 0x06, 0xF030);
4779 MP_WriteEPhyUshort(sc, 0x08, 0x2006);
4780 MP_WriteEPhyUshort(sc, 0x0D, 0x1666);
4781 ClearPCIePhyBit(sc, 0x0C, (BIT_13 | BIT_12 | BIT_11 | BIT_10 | BIT_9 | BIT_8 | BIT_7 | BIT_6 | BIT_5 | BIT_4));
4782 } else if (sc->re_type == MACFG_62) {
4783 MP_WriteEPhyUshort(sc, 0x00, 0x10A3);
4784 MP_WriteEPhyUshort(sc, 0x19, 0xFC00);
4785 MP_WriteEPhyUshort(sc, 0x1E, 0x20EA);
4786 } else if (sc->re_type == MACFG_67) {
4787 SetPCIePhyBit(sc, 0x00, BIT_7);
4788 ClearAndSetPCIePhyBit(sc,
4789 0x0D,
4790 BIT_8,
4791 BIT_9
4792 );
4793 ClearPCIePhyBit(sc, 0x19, (BIT_15 | BIT_5 | BIT_0));
4794 SetPCIePhyBit(sc, 0x1E, BIT_13);
4795 }
4796
4797
4798 CSR_WRITE_1(sc, RE_CFG5, CSR_READ_1(sc, RE_CFG5) | BIT_0);
4799 CSR_WRITE_1(sc, RE_CFG2, CSR_READ_1(sc, RE_CFG2) | BIT_7);
4800 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_0);
4801
4802 CSR_WRITE_1(sc, 0xD0, CSR_READ_1(sc, 0xD0) | BIT_6);
4803 CSR_WRITE_1(sc, 0xF2, CSR_READ_1(sc, 0xF2) | BIT_6);
4804
4805 CSR_WRITE_1(sc, 0xF2, CSR_READ_1(sc, 0xF2) & ~BIT_3);
4806
4807 CSR_WRITE_1 (sc, RE_MTPS, 0x27);
4808
4809 if (sc->re_type == MACFG_67) {
4810 data16 = MP_ReadMcuAccessRegWord(sc, 0xD3E2);
4811 data16 &= 0xF000;
4812 data16 |= 0x3A9;
4813 MP_WriteMcuAccessRegWord(sc, 0xD3E2, data16);
4814
4815 data16 = MP_ReadMcuAccessRegWord(sc, 0xD3E4);
4816 data16 &= 0xFF00;
4817 MP_WriteMcuAccessRegWord(sc, 0xD3E4, data16);
4818
4819 data16 = MP_ReadMcuAccessRegWord(sc, 0xE860);
4820 data16 |= BIT_7;
4821 MP_WriteMcuAccessRegWord(sc, 0xE860, data16);
4822 }
4823
4824 MP_WriteMcuAccessRegWord(sc, 0xC140, 0xFFFF);
4825 MP_WriteMcuAccessRegWord(sc, 0xC142, 0xFFFF);
4826
4827 if (ifp->if_mtu > ETHERMTU) {
4828 ifp->if_capenable &= ~IFCAP_HWCSUM ;
4829 ifp->if_hwassist &= ~RE_CSUM_FEATURES;
4830 } else {
4831 if (sc->re_tx_cstag) {
4832 ifp->if_capenable |= IFCAP_TXCSUM;
4833 ifp->if_hwassist |= RE_CSUM_FEATURES;
4834 }
4835 if (sc->re_rx_cstag) {
4836 ifp->if_capenable |= IFCAP_RXCSUM;
4837 }
4838 }
4839
4840 /* disable clock request. */
4841 pci_write_config(sc->dev, 0x81, 0x00, 1);
4842 }
4843
4844 //clear io_rdy_l23
4845 switch (sc->re_type) {
4846 case MACFG_42:
4847 case MACFG_43:
4848 case MACFG_52:
4849 case MACFG_53:
4850 case MACFG_54:
4851 case MACFG_55:
4852 case MACFG_56:
4853 case MACFG_57:
4854 case MACFG_58:
4855 case MACFG_59:
4856 case MACFG_60:
4857 case MACFG_61:
4858 case MACFG_62:
4859 case MACFG_67:
4860 case MACFG_68:
4861 case MACFG_69:
4862 CSR_WRITE_1(sc, RE_CFG3, CSR_READ_1(sc, RE_CFG3) & ~BIT_1);
4863 break;
4864 }
4865
4866 //clear wol
4867 re_clrwol(sc);
4868
4869 data16 = CSR_READ_2(sc, RE_CPlusCmd);
4870 if ((ifp->if_capenable & IFCAP_VLAN_HWTAGGING) != 0)
4871 data16 |= RL_CPLUSCMD_VLANSTRIP;
4872 else
4873 data16 &= ~RL_CPLUSCMD_VLANSTRIP;
4874
4875 if ((ifp->if_capenable & IFCAP_RXCSUM) != 0)
4876 data16 |= RL_RxChkSum;
4877 else
4878 data16 &= ~RL_RxChkSum;
4879 CSR_WRITE_2 (sc, RE_CPlusCmd, data16);
4880
4881 CSR_WRITE_1(sc, RE_EECMD, RE_EEMODE_OFF);
4882 //CSR_WRITE_1(sc, 0xec, 0x3f);
4883
4884 if (sc->re_device_id == RT_DEVICEID_8169 || sc->re_device_id == RT_DEVICEID_8169SC) {
4885 /* Enable transmit and receive.*/
4886 CSR_WRITE_1(sc, RE_COMMAND, RE_CMD_TX_ENB | RE_CMD_RX_ENB);
4887
4888 /* Set the initial TX configuration.*/
4889 CSR_WRITE_4(sc, RE_TXCFG, RE_TXCFG_CONFIG);
4890
4891 /* Set the initial RX configuration.*/
4892 /*
4893 * Program the multicast filter, if necessary.
4894 */
4895 re_set_rx_packet_filter(sc);
4896 } else {
4897 /* Set the initial RX configuration.*/
4898 /*
4899 * Program the multicast filter, if necessary.
4900 */
4901 re_set_rx_packet_filter(sc);
4902
4903 /* Enable transmit and receive.*/
4904 CSR_WRITE_1(sc, RE_COMMAND, RE_CMD_TX_ENB | RE_CMD_RX_ENB);
4905 }
4906
4907 #ifndef __DragonFly__
4908 ifp->if_drv_flags |= IFF_DRV_RUNNING;
4909 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
4910
4911 /*
4912 * Enable interrupts.
4913 */
4914 CSR_WRITE_2(sc, RE_IMR, RE_INTRS);
4915 #endif
4916 }
4917
4918 static void re_init_unlock(void *xsc) /* Software & Hardware Initialize */
4919 {
4920 struct re_softc *sc = xsc;
4921 struct ifnet *ifp;
4922 #ifndef __DragonFly__
4923 #if OS_VER < VERSION(6,0)
4924 int i;
4925 #endif
4926 #endif /* !__DragonFly__ */
4927 union {
4928 uint32_t align_dummy;
4929 u_char eaddr[ETHER_ADDR_LEN];
4930 } eaddr;
4931
4932 ifp = RE_GET_IFNET(sc);
4933
4934 #ifndef __DragonFly__
4935 /*
4936 * Cancel pending I/O and free all RX/TX buffers.
4937 */
4938 re_stop(sc);
4939 #endif /* !__DragonFly__ */
4940
4941 /* Copy MAC address on stack to align. */
4942 #ifndef __DragonFly__
4943 #if OS_VER < VERSION(6,0)
4944 bcopy((char *)&sc->arpcom.ac_enaddr, eaddr.eaddr, ETHER_ADDR_LEN);
4945 #elif OS_VER < VERSION(7,0)
4946 bcopy(IFP2ENADDR(ifp), eaddr.eaddr, ETHER_ADDR_LEN);
4947 #else
4948 bcopy(IF_LLADDR(ifp), eaddr.eaddr, ETHER_ADDR_LEN);
4949 #endif
4950 #else /* __DragonFly__ */
4951 bcopy(IF_LLADDR(ifp), eaddr.eaddr, ETHER_ADDR_LEN);
4952 #endif /* !__DragonFly__ */
4953
4954 /* Init our MAC address */
4955 CSR_WRITE_1(sc, RE_EECMD, RE_EEMODE_WRITECFG);
4956 CSR_WRITE_4(sc, RE_IDR0,
4957 htole32(*(u_int32_t *)(&eaddr.eaddr[0])));
4958 CSR_WRITE_4(sc, RE_IDR4,
4959 htole32(*(u_int32_t *)(&eaddr.eaddr[4])));
4960
4961 switch (sc->re_type) {
4962 case MACFG_36:
4963 case MACFG_37:
4964 case MACFG_54:
4965 case MACFG_55:
4966 CSR_WRITE_4(sc, RE_SecMAC0,
4967 htole32(*(u_int32_t *)(&eaddr.eaddr[0])));
4968 CSR_WRITE_2(sc, RE_SecMAC4,
4969 htole16(*(u_int16_t *)(&eaddr.eaddr[4])));
4970 break;
4971 }
4972
4973 CSR_WRITE_1(sc, RE_EECMD, RE_EEMODE_OFF);
4974
4975 #ifndef __DragonFly__
4976 re_hw_start_unlock(sc);
4977 #endif
4978
4979 return;
4980 }
4981
4982 #ifndef __DragonFly__
4983 static void re_init(void *xsc) /* Software & Hardware Initialize */
4984 {
4985 struct re_softc *sc = xsc;
4986 struct ifnet *ifp;
4987
4988 RE_LOCK(sc);
4989 ifp = RE_GET_IFNET(sc);
4990
4991 if (re_link_ok(sc)) {
4992 sc->link_state = LINK_STATE_UP;
4993 re_link_state_change(ifp, sc->link_state);
4994 re_link_on_patch(sc);
4995 }
4996
4997 sc->re_link_chg_det = 1;
4998 re_start_timer(sc);
4999
5000 RE_UNLOCK(sc);
5001 }
5002
5003 /*
5004 * Initialize the transmit descriptors.
5005 */
5006 static int re_var_init(struct re_softc *sc)
5007 {
5008 int i;
5009 union RxDesc *rxptr;
5010 union TxDesc *txptr;
5011
5012 sc->re_desc.rx_cur_index = 0;
5013 sc->re_desc.rx_last_index = 0;
5014 rxptr = sc->re_desc.rx_desc;
5015 for (i = 0; i < RE_RX_BUF_NUM; i++) {
5016 memset(&rxptr[i], 0, sizeof(union RxDesc));
5017
5018 /* Init the RX buffer pointer register. */
5019 bus_dmamap_load(sc->re_desc.re_rx_mtag,
5020 sc->re_desc.re_rx_dmamap[i],
5021 sc->re_desc.rx_buf[i]->m_data, sc->re_rx_desc_buf_sz,
5022 re_rx_dma_map_buf,
5023 &rxptr[i],
5024 0);
5025 bus_dmamap_sync(sc->re_desc.re_rx_mtag,
5026 sc->re_desc.re_rx_dmamap[i],
5027 BUS_DMASYNC_PREREAD);
5028
5029 rxptr[i].ul[0] = htole32(sc->re_rx_desc_buf_sz);
5030 if (i == (RE_RX_BUF_NUM - 1))
5031 rxptr[i].ul[0] |= htole32(RL_RDESC_CMD_EOR);
5032 rxptr[i].ul[0] |= htole32(RL_RDESC_CMD_OWN);
5033 }
5034
5035 bus_dmamap_load(sc->re_desc.rx_desc_tag,
5036 sc->re_desc.rx_desc_dmamap,
5037 sc->re_desc.rx_desc,
5038 sizeof(union RxDesc)*RE_RX_BUF_NUM,
5039 re_dma_map_rxdesc,
5040 sc,
5041 0);
5042 bus_dmamap_sync(sc->re_desc.rx_desc_tag,
5043 sc->re_desc.rx_desc_dmamap,
5044 BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
5045
5046 sc->re_desc.tx_cur_index = 0;
5047 sc->re_desc.tx_last_index = 0;
5048 txptr = sc->re_desc.tx_desc;
5049 for (i = 0; i < RE_TX_BUF_NUM; i++) {
5050 memset(&txptr[i], 0, sizeof(union TxDesc));
5051 if (i == (RE_TX_BUF_NUM - 1))
5052 txptr[i].ul[0] = htole32(RL_TDESC_CMD_EOR);
5053 }
5054
5055 bus_dmamap_load(sc->re_desc.tx_desc_tag,
5056 sc->re_desc.tx_desc_dmamap,
5057 sc->re_desc.tx_desc,
5058 sizeof(union RxDesc) * RE_TX_BUF_NUM,
5059 re_dma_map_txdesc,
5060 sc,
5061 0);
5062 bus_dmamap_sync(sc->re_desc.tx_desc_tag,
5063 sc->re_desc.tx_desc_dmamap,
5064 BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
5065
5066 return 0;
5067 }
5068 #endif /* !__DragonFly__ */
5069
5070 static void re_reset(struct re_softc *sc)
5071 {
5072 register int i;
5073
5074 CSR_WRITE_4(sc, RE_RXCFG, CSR_READ_4(sc, RE_RXCFG)& ~0x3F);
5075
5076 switch (sc->re_type) {
5077 case MACFG_3:
5078 case MACFG_4:
5079 case MACFG_5:
5080 case MACFG_6:
5081 DELAY(10000);
5082 break;
5083 case MACFG_11:
5084 case MACFG_12:
5085 case MACFG_13:
5086 case MACFG_14:
5087 case MACFG_15:
5088 case MACFG_16:
5089 case MACFG_17:
5090 case MACFG_18:
5091 case MACFG_19:
5092 case MACFG_21:
5093 case MACFG_22:
5094 case MACFG_23:
5095 case MACFG_24:
5096 case MACFG_25:
5097 case MACFG_26:
5098 case MACFG_27:
5099 case MACFG_28:
5100 case MACFG_31:
5101 case MACFG_32:
5102 case MACFG_33:
5103 case MACFG_36:
5104 case MACFG_37:
5105 case MACFG_41:
5106 case MACFG_42:
5107 case MACFG_43:
5108 case MACFG_54:
5109 case MACFG_55:
5110 case MACFG_63:
5111 case MACFG_64:
5112 case MACFG_65:
5113 case MACFG_66:
5114 CSR_WRITE_1(sc, RE_COMMAND, 0x8C);
5115 break;
5116 case MACFG_38:
5117 case MACFG_39:
5118 case MACFG_50:
5119 case MACFG_51:
5120 case MACFG_52:
5121 case MACFG_53:
5122 CSR_WRITE_1(sc, RE_COMMAND, 0x8C);
5123 while (!(CSR_READ_4(sc,RE_TXCFG) & BIT_11)) DELAY(100);
5124 break;
5125 case MACFG_56:
5126 case MACFG_57:
5127 case MACFG_58:
5128 case MACFG_59:
5129 case MACFG_60:
5130 case MACFG_61:
5131 case MACFG_62:
5132 case MACFG_67:
5133 case MACFG_68:
5134 case MACFG_69:
5135 DELAY(2000);
5136 break;
5137 default:
5138 DELAY(10000);
5139 break;
5140 }
5141 DELAY(200);
5142 CSR_WRITE_1(sc, RE_COMMAND, RE_CMD_RESET);
5143
5144 for (i = 0; i < RE_TIMEOUT; i++) {
5145 DELAY(10);
5146 if (!(CSR_READ_1(sc, RE_COMMAND) & RE_CMD_RESET))
5147 break;
5148 }
5149
5150 if (i == RE_TIMEOUT)
5151 device_printf(sc->dev,"reset never completed!\n");
5152
5153 return;
5154 }
5155
5156 static u_int8_t re_link_ok(struct re_softc *sc)
5157 {
5158 u_int8_t retval;
5159
5160 retval = (CSR_READ_1(sc, RE_PHY_STATUS) & RL_PHY_STATUS_LINK_STS) ? 1 : 0;
5161
5162 return retval;
5163 }
5164
5165 #ifndef __DragonFly__
5166 static void
5167 re_set_wol_linkspeed(struct re_softc *sc)
5168 {
5169 u_int8_t wol_link_speed;
5170 u_int16_t anar;
5171
5172 MP_WritePhyUshort(sc, 0x1F, 0x0000);
5173
5174 wol_link_speed = RE_WOL_LINK_SPEED_100M_FIRST;
5175 if (!re_check_dash(sc)) {
5176 if (re_link_ok(sc)) {
5177 u_int16_t anlpar;
5178
5179 anlpar = MP_ReadPhyUshort(sc,MII_ANLPAR);
5180 if ((anlpar & ANLPAR_10_FD) || (anlpar & ANLPAR_10)) {
5181 wol_link_speed = RE_WOL_LINK_SPEED_10M_FIRST;
5182 } else {
5183 wol_link_speed = RE_WOL_LINK_SPEED_100M_FIRST;
5184 }
5185 }
5186 }
5187
5188 anar = MP_ReadPhyUshort(sc,MII_ANAR);
5189
5190 if (wol_link_speed == RE_WOL_LINK_SPEED_10M_FIRST)
5191 anar &= ~(ANAR_TX_FD | ANAR_TX);
5192
5193 if (sc->re_device_id==RT_DEVICEID_8169 || sc->re_device_id==RT_DEVICEID_8169SC ||
5194 sc->re_device_id==RT_DEVICEID_8168 || sc->re_device_id==RT_DEVICEID_8161) {
5195 u_int16_t gbcr;
5196
5197 gbcr = MP_ReadPhyUshort(sc,MII_100T2CR);
5198 gbcr &= ~(GTCR_ADV_1000TFDX|GTCR_ADV_1000THDX);
5199 MP_WritePhyUshort(sc, MII_100T2CR, gbcr);
5200 MP_WritePhyUshort(sc, MII_ANAR, anar);
5201 MP_WritePhyUshort(sc, MII_BMCR, BMCR_RESET | BMCR_AUTOEN | BMCR_STARTNEG);
5202 } else if (sc->re_type == MACFG_36) {
5203 MP_WritePhyUshort(sc, MII_ANAR, anar);
5204 MP_WritePhyUshort(sc, MII_BMCR, BMCR_RESET | BMCR_AUTOEN | BMCR_STARTNEG);
5205 } else {
5206 MP_WritePhyUshort(sc, MII_ANAR, anar);
5207 MP_WritePhyUshort(sc, MII_BMCR, BMCR_AUTOEN | BMCR_STARTNEG);
5208 }
5209 }
5210
5211 static void
5212 re_setwol(struct re_softc *sc)
5213 {
5214 struct ifnet *ifp;
5215 int pmc;
5216 uint16_t pmstat;
5217 uint8_t v;
5218
5219 RE_LOCK_ASSERT(sc);
5220
5221 ifp = RE_GET_IFNET(sc);
5222
5223 if ((ifp->if_capenable & IFCAP_WOL) == 0) {
5224 re_phy_power_down(sc->dev);
5225 return;
5226 }
5227
5228 if (pci_find_cap(sc->dev, PCIY_PMG, &pmc) != 0)
5229 return;
5230
5231 /* Enable config register write. */
5232 CSR_WRITE_1(sc, RE_EECMD, RE_EEMODE_WRITECFG);
5233
5234 /* Enable PME. */
5235 if (sc->re_device_id==RT_DEVICEID_8169 || sc->re_device_id==RT_DEVICEID_8169SC) {
5236 v = CSR_READ_1(sc, RE_CFG1);
5237 v &= ~RE_CFG1_PME;
5238 if ((ifp->if_capenable & IFCAP_WOL) != 0)
5239 v |= RE_CFG1_PME;
5240 CSR_WRITE_1(sc, RE_CFG1, v);
5241 }
5242
5243 if (sc->re_if_flags & RL_FLAG_MAGIC_PACKET_V2) {
5244 uint32_t Data32;
5245
5246 Data32 = re_eri_read(sc, 0xDC, 4, ERIAR_ExGMAC);
5247 Data32 &= ~(BIT_16);
5248 if ((ifp->if_capenable & IFCAP_WOL_MAGIC) != 0)
5249 Data32 |= BIT_16;
5250 re_eri_write(sc, 0xDC, 4, Data32, ERIAR_ExGMAC);
5251 } else {
5252 v = CSR_READ_1(sc, RE_CFG3);
5253 v &= ~(RL_CFG3_WOL_MAGIC);
5254 if ((ifp->if_capenable & IFCAP_WOL_MAGIC) != 0)
5255 v |= RL_CFG3_WOL_MAGIC;
5256 CSR_WRITE_1(sc, RE_CFG3, v);
5257 }
5258
5259 v = CSR_READ_1(sc, RE_CFG5);
5260 v &= ~(RL_CFG5_WOL_BCAST | RL_CFG5_WOL_MCAST | RL_CFG5_WOL_UCAST |
5261 RL_CFG5_WOL_LANWAKE);
5262
5263 if ((ifp->if_capenable & IFCAP_WOL_UCAST) != 0)
5264 v |= RL_CFG5_WOL_UCAST;
5265 if ((ifp->if_capenable & IFCAP_WOL_MCAST) != 0)
5266 v |= RL_CFG5_WOL_MCAST | RL_CFG5_WOL_BCAST;
5267 if ((ifp->if_capenable & IFCAP_WOL) != 0)
5268 v |= RL_CFG5_WOL_LANWAKE;
5269 CSR_WRITE_1(sc, RE_CFG5, v);
5270
5271 /* Config register write done. */
5272 CSR_WRITE_1(sc, RE_EECMD, RE_EEMODE_OFF);
5273
5274 /*
5275 * It seems that hardware resets its link speed to 100Mbps in
5276 * power down mode so switching to 100Mbps in driver is not
5277 * needed.
5278 */
5279
5280 /* Request PME if WOL is requested. */
5281 pmstat = pci_read_config(sc->dev, pmc + PCIR_POWER_STATUS, 2);
5282 pmstat &= ~(PCIM_PSTAT_PMEENABLE);
5283 if ((ifp->if_capenable & IFCAP_WOL) != 0)
5284 pmstat |= PCIM_PSTAT_PMEENABLE;
5285 pci_write_config(sc->dev, pmc + PCIR_POWER_STATUS, pmstat, 2);
5286
5287 /* Put controller into sleep mode. */
5288 if ((ifp->if_capenable & IFCAP_WOL) != 0) {
5289 re_set_rx_packet_filter_in_sleep_state(sc);
5290 re_set_wol_linkspeed(sc);
5291 if (sc->re_type == MACFG_21 || sc->re_type == MACFG_22)
5292 CSR_WRITE_1(sc, RE_COMMAND, RE_CMD_RX_ENB);
5293 }
5294 }
5295 #endif /* !__DragonFly__ */
5296
5297 static void
5298 re_clrwol(struct re_softc *sc)
5299 {
5300 int pmc;
5301 uint16_t pmstat;
5302 uint8_t v;
5303
5304 RE_LOCK_ASSERT(sc);
5305
5306 #ifndef __DragonFly__
5307 if (pci_find_cap(sc->dev, PCIY_PMG, &pmc) != 0)
5308 return;
5309 #else
5310 if (pci_find_extcap(sc->dev, PCIY_PMG, &pmc) != 0)
5311 return;
5312 #endif
5313
5314 /* Disable PME and clear PME status. */
5315 pmstat = pci_read_config(sc->dev, pmc + PCIR_POWER_STATUS, 2);
5316 pmstat &= ~PCIM_PSTAT_PMEENABLE;
5317 pci_write_config(sc->dev, pmc + PCIR_POWER_STATUS, pmstat, 2);
5318
5319 /* Enable config register write. */
5320 CSR_WRITE_1(sc, RE_EECMD, RE_EEMODE_WRITECFG);
5321
5322 if (sc->re_device_id==RT_DEVICEID_8169 || sc->re_device_id==RT_DEVICEID_8169SC) {
5323 v = CSR_READ_1(sc, RE_CFG1);
5324 v &= ~RE_CFG1_PME;
5325 CSR_WRITE_1(sc, RE_CFG1, v);
5326 }
5327
5328 v = CSR_READ_1(sc, RE_CFG3);
5329 v &= ~(RL_CFG3_WOL_LINK);
5330 CSR_WRITE_1(sc, RE_CFG3, v);
5331
5332 if (sc->re_if_flags & RL_FLAG_MAGIC_PACKET_V2) {
5333 uint32_t Data32;
5334
5335 Data32 = re_eri_read(sc, 0xDC, 4, ERIAR_ExGMAC);
5336 Data32 &= ~(BIT_16);
5337 re_eri_write(sc, 0xDC, 4, Data32, ERIAR_ExGMAC);
5338 } else {
5339 v = CSR_READ_1(sc, RE_CFG3);
5340 v &= ~(RL_CFG3_WOL_MAGIC);
5341 CSR_WRITE_1(sc, RE_CFG3, v);
5342 }
5343
5344 v = CSR_READ_1(sc, RE_CFG5);
5345 v &= ~(RL_CFG5_WOL_BCAST | RL_CFG5_WOL_MCAST | RL_CFG5_WOL_UCAST);
5346 v &= ~RL_CFG5_WOL_LANWAKE;
5347 CSR_WRITE_1(sc, RE_CFG5, v);
5348
5349 /* Config register write done. */
5350 CSR_WRITE_1(sc, RE_EECMD, RE_EEMODE_OFF);
5351 }
5352
5353 /*
5354 * Stop the adapter and free any mbufs allocated to the
5355 * RX and TX lists.
5356 */
5357 #ifndef __DragonFly__
5358 static void re_stop(struct re_softc *sc) /* Stop Driver */
5359 #else /* __DragonFly__ */
5360 static void
5361 re_stop_rtl(struct re_softc *sc)
5362 #endif /* !__DragonFly__ */
5363 {
5364 #ifndef __DragonFly__
5365 struct ifnet *ifp;
5366
5367 /* RE_LOCK_ASSERT(sc);*/
5368
5369 ifp = RE_GET_IFNET(sc);
5370 #if OS_VER < VERSION(9,0)
5371 ifp->if_timer = 0;
5372 #endif
5373
5374 re_stop_timer(sc);
5375 #endif /* !__DragonFly__ */
5376
5377 /*
5378 * Disable accepting frames to put RX MAC into idle state.
5379 * Otherwise it's possible to get frames while stop command
5380 * execution is in progress and controller can DMA the frame
5381 * to already freed RX buffer during that period.
5382 */
5383 CSR_WRITE_4(sc, RE_RXCFG, CSR_READ_4(sc, RE_RXCFG) &
5384 ~(RE_RXCFG_RX_ALLPHYS | RE_RXCFG_RX_INDIV | RE_RXCFG_RX_MULTI |
5385 RE_RXCFG_RX_BROAD | RE_RXCFG_RX_RUNT | RE_RXCFG_RX_ERRPKT));
5386
5387 CSR_WRITE_2(sc, RE_IMR, 0x0000);
5388 CSR_WRITE_2(sc, RE_ISR, 0xffff);
5389 if (sc->re_type == MACFG_50 || sc->re_type == MACFG_51 || sc->re_type == MACFG_52) {
5390 re_eri_write(sc, 0x1bc, 4, 0x0000001f, ERIAR_ExGMAC);
5391 re_eri_write(sc, 0x1dc, 4, 0x0000002d, ERIAR_ExGMAC);
5392 } else if (sc->re_type == MACFG_38) {
5393 re_eri_write(sc, 0x1bc, 4, 0x0000001f, ERIAR_ExGMAC);
5394 re_eri_write(sc, 0x1dc, 4, 0x0000003f, ERIAR_ExGMAC);
5395 }
5396 re_reset(sc);
5397
5398 #ifndef __DragonFly__
5399 /*
5400 * Free the TX list buffers.
5401 */
5402 while (sc->re_desc.tx_last_index!=sc->re_desc.tx_cur_index) {
5403 if (sc->re_desc.re_tx_mtag) {
5404 bus_dmamap_sync(sc->re_desc.re_tx_mtag,
5405 sc->re_desc.re_tx_dmamap[sc->re_desc.tx_last_index],
5406 BUS_DMASYNC_POSTWRITE);
5407 bus_dmamap_unload(sc->re_desc.re_tx_mtag,
5408 sc->re_desc.re_tx_dmamap[sc->re_desc.tx_last_index]);
5409 }
5410
5411 if (sc->re_desc.tx_buf[sc->re_desc.tx_last_index]!=NULL) {
5412 m_freem(sc->re_desc.tx_buf[sc->re_desc.tx_last_index]);
5413 sc->re_desc.tx_buf[sc->re_desc.tx_last_index] = NULL;
5414 }
5415 sc->re_desc.tx_last_index = (sc->re_desc.tx_last_index+1)%RE_TX_BUF_NUM;
5416 }
5417
5418 ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
5419
5420 return;
5421 #endif /* !__DragonFly__ */
5422 }
5423
5424 #ifndef __DragonFly__
5425 /*
5426 * Main transmit routine.
5427 */
5428 static void re_start(struct ifnet *ifp) /* Transmit Packet*/
5429 {
5430 struct re_softc *sc;
5431 struct mbuf *m_head = NULL;
5432
5433 sc = ifp->if_softc; /* Paste to ifp in function re_attach(dev) */
5434
5435 RE_LOCK(sc);
5436
5437 /* RE_LOCK_ASSERT(sc);*/
5438
5439 if ((sc->driver_detach == 1) || (sc->rx_fifo_overflow != 0)) {
5440 RE_UNLOCK(sc);
5441 return;
5442 }
5443
5444 while (1) {
5445 int fs = 1, ls = 0, TxLen = 0, PktLen;
5446 struct mbuf *ptr;
5447 uint32_t opts1 =0;
5448 uint32_t opts2 =0;
5449 IFQ_DRV_DEQUEUE(&ifp->if_snd, m_head); /* Remove(get) data from system transmit queue */
5450 if (m_head == NULL) {
5451 break;
5452 }
5453
5454 if (sc->re_coalesce_tx_pkt) {
5455 if (re_encap(sc, m_head)) {
5456 IFQ_DRV_PREPEND(&ifp->if_snd, m_head);
5457 ifp->if_drv_flags |= IFF_DRV_OACTIVE;
5458 break;
5459 }
5460
5461 m_head = sc->re_desc.tx_buf[sc->re_desc.tx_cur_index];
5462 }
5463
5464 if (CountMbufNum(m_head) > CountFreeTxDescNum(sc->re_desc)) { /* No enough descriptor */
5465 IFQ_DRV_PREPEND(&ifp->if_snd, m_head);
5466 ifp->if_drv_flags |= IFF_DRV_OACTIVE;
5467 break;
5468 }
5469
5470 if (ifp->if_bpf) { /* If there's a BPF listener, bounce a copy of this frame to him. */
5471 //printf("If there's a BPF listener, bounce a copy of this frame to him. \n");
5472
5473 /*#if OS_VER < VERSION(5, 1)*/
5474 #if OS_VER < VERSION(4,9)
5475 bpf_mtap(ifp, m_head);
5476 #else
5477 bpf_mtap(ifp->if_bpf, m_head);
5478 #endif
5479 }
5480
5481 //hw checksum
5482 if (ifp->if_capenable & IFCAP_TXCSUM) {
5483 if ((m_head->m_pkthdr.csum_flags & RE_CSUM_FEATURES) !=0) {
5484 if (!(sc->re_if_flags & RL_FLAG_DESCV2)) {
5485 opts1 |= RL_IPV4CS1;
5486 if ((m_head->m_pkthdr.csum_flags & CSUM_TCP)!=0)
5487 opts1 |=RL_TCPCS1;
5488 if ((m_head->m_pkthdr.csum_flags & CSUM_UDP)!=0)
5489 opts1 |=RL_UDPCS1;
5490 } else {
5491 opts2 |= RL_IPV4CS;
5492 if ((m_head->m_pkthdr.csum_flags & CSUM_TCP)!=0)
5493 opts2 |= RL_TCPCS;
5494 else if ((m_head->m_pkthdr.csum_flags & CSUM_UDP)!=0)
5495 opts2 |= RL_UDPCS;
5496 }
5497 }
5498 }
5499
5500 //vlan
5501 if (m_head->m_flags & M_VLANTAG)
5502 opts2 |= bswap16(m_head->m_pkthdr.ether_vtag) | RL_TDESC_VLANCTL_TAG ;
5503 ptr = m_head;
5504 PktLen = ptr->m_pkthdr.len;
5505 #ifdef _DEBUG_
5506 printf("PktLen=%d",PktLen);
5507 #endif
5508 while (ptr!=NULL) {
5509 if (ptr->m_len >0) {
5510 #ifdef _DEBUG_
5511 printf(", len=%d T=%d F=%d",ptr->m_len,ptr->m_type,ptr->m_flags);
5512 #endif
5513 TxLen += ptr->m_len;
5514 if (TxLen >= PktLen) {
5515 ls=1;
5516 sc->re_desc.tx_buf[sc->re_desc.tx_cur_index] = m_head;
5517 } else
5518 sc->re_desc.tx_buf[sc->re_desc.tx_cur_index] = NULL;
5519
5520 //vlan
5521 WritePacket(sc,ptr->m_data,ptr->m_len,fs,ls,opts2,opts1);
5522
5523 fs=0;
5524 }
5525 ptr = ptr->m_next;
5526 }
5527 #ifdef _DEBUG_
5528 printf("\n");
5529 #endif
5530 }
5531 #if OS_VER < VERSION(9,0)
5532 ifp->if_timer = 5;
5533 #endif
5534
5535 RE_UNLOCK(sc);
5536
5537 return;
5538 }
5539
5540 /*
5541 * Encapsulate an mbuf chain in a descriptor by coupling the mbuf data
5542 * pointers to the fragment pointers.
5543 */
5544 static int re_encap(struct re_softc *sc,struct mbuf *m_head)
5545 {
5546 struct mbuf *m_new = NULL;
5547
5548 m_new = m_defrag(m_head, M_DONTWAIT);
5549
5550 if (m_new == NULL) {
5551 printf("re%d: no memory for tx list", sc->re_unit);
5552 return (1);
5553 }
5554 m_head = m_new;
5555
5556 /* Pad frames to at least 60 bytes. */
5557 if (m_head->m_pkthdr.len < RE_MIN_FRAMELEN) { /* Case length < 60 bytes */
5558 /*
5559 * Make security concious people happy: zero out the
5560 * bytes in the pad area, since we don't know what
5561 * this mbuf cluster buffer's previous user might
5562 * have left in it.
5563 */
5564 bzero(mtod(m_head, char *) + m_head->m_pkthdr.len,
5565 RE_MIN_FRAMELEN - m_head->m_pkthdr.len);
5566 m_head->m_pkthdr.len = RE_MIN_FRAMELEN;
5567 m_head->m_len = m_head->m_pkthdr.len;
5568 }
5569
5570 sc->re_desc.tx_buf[sc->re_desc.tx_cur_index] = m_head;
5571
5572 return(0);
5573 }
5574
5575 static void WritePacket(struct re_softc *sc, caddr_t addr, int len,int fs_flag,int ls_flag, uint32_t opts2,uint32_t opts1)
5576 {
5577 union TxDesc *txptr;
5578
5579 txptr=&(sc->re_desc.tx_desc[sc->re_desc.tx_cur_index]);
5580
5581 txptr->ul[0] &= htole32(0x40000000);
5582 txptr->ul[0] |= htole32(opts1);
5583 txptr->ul[1] = htole32(opts2);
5584
5585 if (fs_flag)
5586 txptr->ul[0] |= htole32(RL_TDESC_CMD_SOF);
5587 if (ls_flag)
5588 txptr->ul[0] |= htole32(RL_TDESC_CMD_EOF);
5589 txptr->ul[0] |= htole32(len);
5590 bus_dmamap_load(sc->re_desc.re_tx_mtag,
5591 sc->re_desc.re_tx_dmamap[sc->re_desc.tx_cur_index],
5592 addr,
5593 len,
5594 re_tx_dma_map_buf, txptr,
5595 0);
5596 bus_dmamap_sync(sc->re_desc.re_tx_mtag,
5597 sc->re_desc.re_tx_dmamap[sc->re_desc.tx_cur_index],
5598 BUS_DMASYNC_PREWRITE);
5599 txptr->ul[0] |= htole32(RL_TDESC_CMD_OWN);
5600
5601 bus_dmamap_sync(sc->re_desc.tx_desc_tag,
5602 sc->re_desc.tx_desc_dmamap,
5603 BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
5604
5605 if (ls_flag) {
5606 CSR_WRITE_1(sc, RE_TPPOLL, RE_NPQ);
5607 CSR_WRITE_1(sc, RE_TPPOLL, RE_NPQ);
5608 }
5609
5610 sc->re_desc.tx_cur_index = (sc->re_desc.tx_cur_index+1)%RE_TX_BUF_NUM;
5611 }
5612
5613 static int CountFreeTxDescNum(struct re_descriptor desc)
5614 {
5615 int ret=desc.tx_last_index-desc.tx_cur_index;
5616 if (ret<=0)
5617 ret+=RE_TX_BUF_NUM;
5618 ret--;
5619 return ret;
5620 }
5621
5622 static int CountMbufNum(struct mbuf *m_head)
5623 {
5624 int ret=0;
5625 struct mbuf *ptr = m_head;
5626
5627 while (ptr!=NULL) {
5628 if (ptr->m_len >0)
5629 ret++;
5630 ptr=ptr->m_next;
5631 }
5632
5633 return ret;
5634 }
5635
5636 #ifdef RE_FIXUP_RX
5637 static __inline void re_fixup_rx(struct mbuf *m)
5638 {
5639 int i;
5640 uint16_t *src, *dst;
5641
5642 src = mtod(m, uint16_t *);
5643 dst = src - (RE_ETHER_ALIGN - ETHER_ALIGN) / sizeof *src;
5644
5645 for (i = 0; i < (m->m_len / sizeof(uint16_t) + 1); i++)
5646 *dst++ = *src++;
5647
5648 m->m_data -= RE_ETHER_ALIGN - ETHER_ALIGN;
5649 }
5650 #endif
5651
5652 /*
5653 * A frame was downloaded to the chip. It's safe for us to clean up
5654 * the list buffers.
5655 */
5656 static void re_txeof(struct re_softc *sc) /* Transmit OK/ERR handler */
5657 {
5658 union TxDesc *txptr;
5659 struct ifnet *ifp;
5660
5661 /* printf("X");*/
5662
5663 ifp = RE_GET_IFNET(sc);
5664
5665 #if OS_VER < VERSION(9,0)
5666 /* Clear the timeout timer. */
5667 ifp->if_timer = 0;
5668 #endif
5669
5670 bus_dmamap_sync(sc->re_desc.tx_desc_tag,
5671 sc->re_desc.tx_desc_dmamap,
5672 BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE);
5673
5674 txptr=&(sc->re_desc.tx_desc[sc->re_desc.tx_last_index]);
5675 while ((txptr->ul[0]&htole32(RL_TDESC_STAT_OWN))==0 && sc->re_desc.tx_last_index!=sc->re_desc.tx_cur_index) {
5676 #ifdef _DEBUG_
5677 printf("**** Tx OK ****\n");
5678 #endif
5679 bus_dmamap_sync(sc->re_desc.re_tx_mtag,
5680 sc->re_desc.re_tx_dmamap[sc->re_desc.tx_last_index],
5681 BUS_DMASYNC_POSTWRITE);
5682 bus_dmamap_unload(sc->re_desc.re_tx_mtag,
5683 sc->re_desc.re_tx_dmamap[sc->re_desc.tx_last_index]);
5684
5685 if (sc->re_desc.tx_buf[sc->re_desc.tx_last_index]!=NULL) {
5686 m_freem(sc->re_desc.tx_buf[sc->re_desc.tx_last_index]); /* Free Current MBuf in a Mbuf list*/
5687 sc->re_desc.tx_buf[sc->re_desc.tx_last_index] = NULL;
5688 }
5689
5690 sc->re_desc.tx_last_index = (sc->re_desc.tx_last_index+1)%RE_TX_BUF_NUM;
5691 txptr=&sc->re_desc.tx_desc[sc->re_desc.tx_last_index];
5692 ifp->if_opackets++;
5693 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
5694 }
5695
5696 return;
5697 }
5698
5699 /*
5700 * A frame has been uploaded: pass the resulting mbuf chain up to
5701 * the higher level protocols.
5702 *
5703 * You know there's something wrong with a PCI bus-master chip design
5704 * when you have to use m_devget().
5705 *
5706 * The receive operation is badly documented in the datasheet, so I'll
5707 * attempt to document it here. The driver provides a buffer area and
5708 * places its base address in the RX buffer start address register.
5709 * The chip then begins copying frames into the RX buffer. Each frame
5710 * is preceeded by a 32-bit RX status word which specifies the length
5711 * of the frame and certain other status bits. Each frame (starting with
5712 * the status word) is also 32-bit aligned. The frame length is in the
5713 * first 16 bits of the status word; the lower 15 bits correspond with
5714 * the 'rx status register' mentioned in the datasheet.
5715 *
5716 * Note: to make the Alpha happy, the frame payload needs to be aligned
5717 * on a 32-bit boundary. To achieve this, we cheat a bit by copying from
5718 * the ring buffer starting at an address two bytes before the actual
5719 * data location. We can then shave off the first two bytes using m_adj().
5720 * The reason we do this is because m_devget() doesn't let us specify an
5721 * offset into the mbuf storage space, so we have to artificially create
5722 * one. The ring is allocated in such a way that there are a few unused
5723 * bytes of space preceecing it so that it will be safe for us to do the
5724 * 2-byte backstep even if reading from the ring at offset 0.
5725 */
5726 static void re_rxeof(sc) /* Receive Data OK/ERR handler */
5727 struct re_softc *sc;
5728 {
5729 struct ether_header *eh;
5730 struct mbuf *m;
5731 struct ifnet *ifp;
5732 union RxDesc *rxptr;
5733 int bError;
5734 struct mbuf *buf;
5735 int size;
5736 int maxpkt = RE_RX_BUF_NUM;
5737
5738 u_int32_t opts2,opts1;
5739
5740 /* RE_LOCK_ASSERT(sc);*/
5741
5742 ifp = RE_GET_IFNET(sc);
5743
5744 bus_dmamap_sync(sc->re_desc.rx_desc_tag,
5745 sc->re_desc.rx_desc_dmamap,
5746 BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE);
5747
5748 rxptr=&(sc->re_desc.rx_desc[sc->re_desc.rx_cur_index]);
5749 while ((rxptr->ul[0]&htole32(RL_RDESC_STAT_OWN))==0) { /* Receive OK */
5750 bError = 0;
5751
5752 opts1 = le32toh(rxptr->ul[0]);
5753
5754 /* Check if this packet is received correctly*/
5755 if (opts1&0x200000) { /*Check RES bit*/
5756 bError=1;
5757 goto update_desc;
5758 }
5759 opts2 = le32toh(rxptr->ul[1]);
5760
5761 //buf = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR); /* Alloc a new mbuf */
5762
5763 if (sc->re_rx_mbuf_sz <= MCLBYTES)
5764 size = MCLBYTES;
5765 else if (sc->re_rx_mbuf_sz <= MJUMPAGESIZE)
5766 size = MJUMPAGESIZE;
5767 else
5768 size = MJUM9BYTES;
5769
5770 buf = m_getjcl(M_DONTWAIT, MT_DATA, M_PKTHDR, size);
5771 if (buf==NULL) {
5772 bError=1;
5773 goto update_desc;
5774 }
5775
5776 buf->m_len = buf->m_pkthdr.len = size;
5777 #ifdef RE_FIXUP_RX
5778 /*
5779 * This is part of an evil trick to deal with non-x86 platforms.
5780 * The RealTek chip requires RX buffers to be aligned on 64-bit
5781 * boundaries, but that will hose non-x86 machines. To get around
5782 * this, we leave some empty space at the start of each buffer
5783 * and for non-x86 hosts, we copy the buffer back six bytes
5784 * to achieve word alignment. This is slightly more efficient
5785 * than allocating a new buffer, copying the contents, and
5786 * discarding the old buffer.
5787 */
5788 m_adj(buf, RE_ETHER_ALIGN);
5789 #endif
5790
5791 bus_dmamap_sync(sc->re_desc.re_rx_mtag,
5792 sc->re_desc.re_rx_dmamap[sc->re_desc.rx_cur_index],
5793 BUS_DMASYNC_POSTREAD);
5794 bus_dmamap_unload(sc->re_desc.re_rx_mtag,
5795 sc->re_desc.re_rx_dmamap[sc->re_desc.rx_cur_index]);
5796
5797 m = sc->re_desc.rx_buf[sc->re_desc.rx_cur_index];
5798 sc->re_desc.rx_buf[sc->re_desc.rx_cur_index] = buf;
5799 m->m_pkthdr.len = m->m_len = (opts1&RL_RDESC_STAT_GFRAGLEN)-ETHER_CRC_LEN;
5800 m->m_pkthdr.rcvif = ifp;
5801
5802 #ifdef RE_FIXUP_RX
5803 re_fixup_rx(m);
5804 #endif
5805
5806 //vlan
5807 if (opts2 & RL_RDESC_VLANCTL_TAG) {
5808 m->m_pkthdr.ether_vtag =
5809 bswap16((opts2 & RL_RDESC_VLANCTL_DATA));
5810 m->m_flags |= M_VLANTAG;
5811 }
5812 if (ifp->if_capenable & IFCAP_RXCSUM) {
5813 if (!(sc->re_if_flags & RL_FLAG_DESCV2)) {
5814 if (opts1 & RL_ProtoIP)
5815 m->m_pkthdr.csum_flags |= CSUM_IP_CHECKED;
5816 if (!(opts1 & RL_IPF))
5817 m->m_pkthdr.csum_flags |= CSUM_IP_VALID;
5818 if ((((opts1 & RL_ProtoIP)==(1<<17)) && !(opts1 & RL_TCPF)) || (((opts1 & RL_ProtoIP)==(1<<18)) && !(opts1 & RL_UDPF))) {
5819 m->m_pkthdr.csum_flags |= CSUM_DATA_VALID|CSUM_PSEUDO_HDR;
5820 m->m_pkthdr.csum_data = 0xffff;
5821 }
5822 } else {
5823 if ((opts1 & RL_ProtoIP) && (opts2 & RL_V4F))
5824 m->m_pkthdr.csum_flags |= CSUM_IP_CHECKED;
5825 if (!(opts1 & RL_IPF) && (opts2 & RL_V4F))
5826 m->m_pkthdr.csum_flags |= CSUM_IP_VALID;
5827 if (((opts1 & RL_TCPT) && !(opts2 & RL_TCPF)) || ((opts1 & RL_UDPT) && !(opts2 & RL_UDPF))) {
5828 m->m_pkthdr.csum_flags |= CSUM_DATA_VALID|CSUM_PSEUDO_HDR;
5829 m->m_pkthdr.csum_data = 0xffff;
5830 }
5831 }
5832 }
5833
5834 eh = mtod(m, struct ether_header *);
5835 ifp->if_ipackets++;
5836 #ifdef _DEBUG_
5837 printf("Rcv Packet, Len=%d \n", m->m_len);
5838 #endif
5839
5840 RE_UNLOCK(sc);
5841
5842 /*#if OS_VER < VERSION(5, 1)*/
5843 #if OS_VER < VERSION(4,9)
5844 /* Remove header from mbuf and pass it on. */
5845 m_adj(m, sizeof(struct ether_header));
5846 ether_input(ifp, eh, m);
5847 #else
5848 (*ifp->if_input)(ifp, m);
5849 #endif
5850 RE_LOCK(sc);
5851
5852 update_desc:
5853 rxptr->ul[0]&=htole32(0x40000000); /* keep EOR bit */
5854 rxptr->ul[1]=0;
5855
5856 rxptr->ul[0] |= htole32(sc->re_rx_desc_buf_sz);
5857 if (!bError) {
5858 bus_dmamap_load(sc->re_desc.re_rx_mtag,
5859 sc->re_desc.re_rx_dmamap[sc->re_desc.rx_cur_index],
5860 sc->re_desc.rx_buf[sc->re_desc.rx_cur_index]->m_data,
5861 sc->re_rx_desc_buf_sz,
5862 re_rx_dma_map_buf, rxptr,
5863 0);
5864 bus_dmamap_sync(sc->re_desc.re_rx_mtag,
5865 sc->re_desc.re_rx_dmamap[sc->re_desc.rx_cur_index],
5866 BUS_DMASYNC_PREREAD);
5867 }
5868 rxptr->ul[0] |= htole32(RL_RDESC_CMD_OWN);
5869 sc->re_desc.rx_cur_index = (sc->re_desc.rx_cur_index+1)%RE_RX_BUF_NUM;
5870 rxptr=&sc->re_desc.rx_desc[sc->re_desc.rx_cur_index];
5871
5872 maxpkt--;
5873 if (maxpkt==0)
5874 break;
5875 }
5876
5877 bus_dmamap_sync(sc->re_desc.rx_desc_tag,
5878 sc->re_desc.rx_desc_dmamap,
5879 BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
5880
5881 return;
5882 }
5883
5884 #if OS_VER < VERSION(7,0)
5885 static void re_intr(void *arg) /* Interrupt Handler */
5886 #else
5887 static int re_intr(void *arg) /* Interrupt Handler */
5888 #endif //OS_VER < VERSION(7,0)
5889 {
5890 struct re_softc *sc;
5891
5892 sc = arg;
5893
5894 if ((sc->re_if_flags & (RL_FLAG_MSI | RL_FLAG_MSIX)) == 0) {
5895 if ((CSR_READ_2(sc, RE_ISR) & RE_INTRS) == 0) {
5896 #if OS_VER < VERSION(7,0)
5897 return;
5898 #else
5899 return (FILTER_STRAY);
5900 #endif
5901 }
5902 }
5903
5904 /* Disable interrupts. */
5905 CSR_WRITE_2(sc, RE_IMR, 0x0000);
5906
5907 #if OS_VER < VERSION(7,0)
5908 re_int_task(arg, 0);
5909 #else
5910 taskqueue_enqueue_fast(taskqueue_fast, &sc->re_inttask);
5911
5912 return (FILTER_HANDLED);
5913 #endif
5914 }
5915
5916 static void re_int_task(void *arg, int npending)
5917 {
5918 struct re_softc *sc;
5919 struct ifnet *ifp;
5920 u_int16_t status;
5921
5922 sc = arg;
5923
5924 RE_LOCK(sc);
5925
5926 ifp = RE_GET_IFNET(sc);
5927
5928 status = CSR_READ_2(sc, RE_ISR);
5929
5930 if (status) {
5931 CSR_WRITE_2(sc, RE_ISR, status & 0xffbf);
5932 }
5933
5934 if (sc->suspended ||
5935 (ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) {
5936 RE_UNLOCK(sc);
5937 return;
5938 }
5939
5940 re_rxeof(sc);
5941
5942 if (sc->re_type == MACFG_21) {
5943 if (status & RE_ISR_FIFO_OFLOW) {
5944 sc->rx_fifo_overflow = 1;
5945 CSR_WRITE_2(sc, 0x00e2, 0x0000);
5946 CSR_WRITE_4(sc, 0x0048, 0x4000);
5947 CSR_WRITE_4(sc, 0x0058, 0x4000);
5948 } else {
5949 sc->rx_fifo_overflow = 0;
5950 CSR_WRITE_4(sc,RE_CPCR, 0x51512082);
5951 }
5952
5953 if (status & RE_ISR_PCS_TIMEOUT) {
5954 if ((status & RE_ISR_FIFO_OFLOW) &&
5955 (!(status & (RE_ISR_RX_OK | RE_ISR_TX_OK | RE_ISR_RX_OVERRUN)))) {
5956 re_reset(sc);
5957 re_init(sc);
5958 sc->rx_fifo_overflow = 0;
5959 CSR_WRITE_2(sc, RE_ISR, RE_ISR_FIFO_OFLOW);
5960 }
5961 }
5962 }
5963
5964 re_txeof(sc);
5965
5966 if (status & RE_ISR_SYSTEM_ERR) {
5967 re_reset(sc);
5968 re_init(sc);
5969 }
5970
5971 switch(sc->re_type) {
5972 case MACFG_21:
5973 case MACFG_22:
5974 case MACFG_23:
5975 case MACFG_24:
5976 CSR_WRITE_1(sc, RE_TPPOLL, RE_NPQ);
5977 break;
5978
5979 default:
5980 break;
5981 }
5982
5983 RE_UNLOCK(sc);
5984
5985 if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd))
5986 re_start(ifp);
5987
5988 #if OS_VER>=VERSION(7,0)
5989 if (CSR_READ_2(sc, RE_ISR) & RE_INTRS) {
5990 taskqueue_enqueue_fast(taskqueue_fast, &sc->re_inttask);
5991 return;
5992 }
5993 #endif
5994
5995 /* Re-enable interrupts. */
5996 CSR_WRITE_2(sc, RE_IMR, RE_INTRS);
5997 }
5998 #endif /* !__DragonFly__ */
5999
6000 static void re_set_multicast_reg(struct re_softc *sc, u_int32_t mask0, u_int32_t mask4)
6001 {
6002 u_int8_t enable_cfg_reg_write = 0;
6003
6004 if (sc->re_type == MACFG_5 || sc->re_type == MACFG_6)
6005 enable_cfg_reg_write = 1;
6006
6007 if (enable_cfg_reg_write)
6008 CSR_WRITE_1(sc, RE_EECMD, RE_EEMODE_WRITECFG);
6009 CSR_WRITE_4(sc, RE_MAR0, mask0);
6010 CSR_WRITE_4(sc, RE_MAR4, mask4);
6011 if (enable_cfg_reg_write)
6012 CSR_WRITE_1(sc, RE_EECMD, RE_EEMODE_OFF);
6013
6014 return;
6015 }
6016
6017 #ifndef __DragonFly__
6018 static void re_set_rx_packet_filter_in_sleep_state(struct re_softc *sc)
6019 {
6020 struct ifnet *ifp;
6021 u_int32_t rxfilt;
6022
6023 ifp = RE_GET_IFNET(sc);
6024
6025 rxfilt = CSR_READ_4(sc, RE_RXCFG);
6026
6027 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);
6028 rxfilt |= (RE_RXCFG_RX_INDIV | RE_RXCFG_RX_MULTI | RE_RXCFG_RX_BROAD);
6029
6030 CSR_WRITE_4(sc, RE_RXCFG, rxfilt);
6031
6032 re_set_multicast_reg(sc, 0xFFFFFFFF, 0xFFFFFFFF);
6033
6034 return;
6035 }
6036 #endif /* !__DragonFly__ */
6037
6038 static void re_set_rx_packet_filter(struct re_softc *sc)
6039 {
6040 struct ifnet *ifp;
6041 u_int32_t rxfilt;
6042
6043 ifp = RE_GET_IFNET(sc);
6044
6045 rxfilt = CSR_READ_4(sc, RE_RXCFG);
6046
6047 rxfilt |= RE_RXCFG_RX_INDIV;
6048
6049 if (ifp->if_flags & (IFF_MULTICAST | IFF_ALLMULTI | IFF_PROMISC)) {
6050 rxfilt |= (RE_RXCFG_RX_ALLPHYS | RE_RXCFG_RX_MULTI);
6051 } else {
6052 rxfilt &= ~(RE_RXCFG_RX_MULTI);
6053 }
6054
6055 if (ifp->if_flags & IFF_PROMISC) {
6056 rxfilt |= (RE_RXCFG_RX_ALLPHYS | RE_RXCFG_RX_RUNT | RE_RXCFG_RX_ERRPKT);
6057 } else {
6058 rxfilt &= ~(RE_RXCFG_RX_ALLPHYS | RE_RXCFG_RX_RUNT | RE_RXCFG_RX_ERRPKT);
6059 }
6060
6061 if (ifp->if_flags & (IFF_BROADCAST | IFF_PROMISC)) {
6062 rxfilt |= RE_RXCFG_RX_BROAD;
6063 } else {
6064 rxfilt &= ~RE_RXCFG_RX_BROAD;
6065 }
6066
6067 CSR_WRITE_4(sc, RE_RXCFG, rxfilt);
6068
6069 re_setmulti(sc);
6070
6071 return;
6072 }
6073
6074 /*
6075 * Program the 64-bit multicast hash filter.
6076 */
6077 static void re_setmulti(struct re_softc *sc)
6078 {
6079 struct ifnet *ifp;
6080 int h = 0;
6081 u_int32_t hashes[2] = { 0, 0 };
6082 struct ifmultiaddr *ifma;
6083 u_int32_t rxfilt;
6084 int mcnt = 0;
6085
6086 ifp = RE_GET_IFNET(sc);
6087
6088 rxfilt = CSR_READ_4(sc, RE_RXCFG);
6089
6090 if (ifp->if_flags & IFF_ALLMULTI || ifp->if_flags & IFF_PROMISC) {
6091 rxfilt |= RE_RXCFG_RX_MULTI;
6092 CSR_WRITE_4(sc, RE_RXCFG, rxfilt);
6093 re_set_multicast_reg(sc, 0xFFFFFFFF, 0xFFFFFFFF);
6094
6095 return;
6096 }
6097
6098 #ifndef __DragonFly__
6099 /* now program new ones */
6100 #if OS_VER > VERSION(6,0)
6101 IF_ADDR_LOCK(ifp);
6102 #endif
6103 #if OS_VER < VERSION(4,9)
6104 for (ifma = ifp->if_multiaddrs.lh_first; ifma != NULL;
6105 ifma = ifma->ifma_link.le_next)
6106 #else
6107 TAILQ_FOREACH(ifma,&ifp->if_multiaddrs,ifma_link)
6108 #endif
6109 #else /* __DragonFly__ */
6110 TAILQ_FOREACH(ifma,&ifp->if_multiaddrs,ifma_link)
6111 #endif /* !__DragonFly__ */
6112 {
6113 if (ifma->ifma_addr->sa_family != AF_LINK)
6114 continue;
6115 h = ether_crc32_be(LLADDR((struct sockaddr_dl *)
6116 ifma->ifma_addr), ETHER_ADDR_LEN) >> 26;
6117 if (h < 32)
6118 hashes[0] |= (1 << h);
6119 else
6120 hashes[1] |= (1 << (h - 32));
6121 mcnt++;
6122 }
6123 #ifndef __DragonFly__
6124 #if OS_VER > VERSION(6,0)
6125 IF_ADDR_UNLOCK(ifp);
6126 #endif
6127 #endif /* !__DragonFly__ */
6128
6129 if (mcnt) {
6130 if ((sc->re_if_flags & RL_FLAG_PCIE) != 0) {
6131 h = bswap32(hashes[0]);
6132 hashes[0] = bswap32(hashes[1]);
6133 hashes[1] = h;
6134 }
6135 rxfilt |= RE_RXCFG_RX_MULTI;
6136 } else
6137 rxfilt &= ~RE_RXCFG_RX_MULTI;
6138
6139 CSR_WRITE_4(sc, RE_RXCFG, rxfilt);
6140 re_set_multicast_reg(sc, hashes[0], hashes[1]);
6141
6142 return;
6143 }
6144
6145 #ifndef __DragonFly__
6146 static int re_ioctl(ifp, command, data)
6147 struct ifnet *ifp;
6148 u_long command;
6149 caddr_t data;
6150 {
6151 struct re_softc *sc = ifp->if_softc;
6152 struct ifreq *ifr = (struct ifreq *) data;
6153 /*int s;*/
6154 int error = 0;
6155 int mask, reinit;
6156 /*s = splimp();*/
6157
6158 switch(command) {
6159 case SIOCSIFADDR:
6160 case SIOCGIFADDR:
6161 error = ether_ioctl(ifp, command, data);
6162
6163 break;
6164 case SIOCSIFMTU:
6165
6166 //printf("before mtu =%d\n",(int)ifp->if_mtu);
6167 if (ifr->ifr_mtu > sc->max_jumbo_frame_size)
6168 error = EINVAL;
6169 else {
6170 ifp->if_mtu = ifr->ifr_mtu;
6171
6172 //if running
6173 if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
6174 //printf("set mtu when running\n");
6175
6176 RE_LOCK(sc);
6177 re_stop(sc);
6178
6179 re_release_buf(sc);
6180 set_rxbufsize(sc);
6181 error =re_alloc_buf(sc);
6182
6183 if (error == 0) {
6184 re_init(sc);
6185 }
6186 RE_UNLOCK(sc);
6187
6188 } else {
6189 //if not running
6190 RE_LOCK(sc);
6191 re_release_buf(sc);
6192 set_rxbufsize(sc);
6193 error =re_alloc_buf(sc);
6194 if (error == 0) {
6195 /* Init descriptors. */
6196 re_var_init(sc);
6197 }
6198 RE_UNLOCK(sc);
6199 }
6200
6201 }
6202 // printf("after mtu =%d\n",(int)ifp->if_mtu);
6203 break;
6204 case SIOCSIFFLAGS:
6205 RE_LOCK(sc);
6206 if (ifp->if_flags & IFF_UP) {
6207 re_init(sc);
6208 } else if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
6209 re_stop(sc);
6210 }
6211 error = 0;
6212 RE_UNLOCK(sc);
6213 break;
6214 case SIOCADDMULTI:
6215 case SIOCDELMULTI:
6216 RE_LOCK(sc);
6217 re_set_rx_packet_filter(sc);
6218 RE_UNLOCK(sc);
6219 error = 0;
6220 break;
6221 case SIOCGIFMEDIA:
6222 case SIOCSIFMEDIA:
6223 error = ifmedia_ioctl(ifp, ifr, &sc->media, command);
6224 break;
6225 case SIOCSIFCAP:
6226
6227
6228 mask = ifr->ifr_reqcap ^ ifp->if_capenable;
6229 reinit = 0;
6230
6231 if ((mask & IFCAP_TXCSUM) != 0 && (ifp->if_capabilities & IFCAP_TXCSUM) != 0) {
6232 ifp->if_capenable ^= IFCAP_TXCSUM;
6233 if ((ifp->if_capenable & IFCAP_TXCSUM) != 0) {
6234 if ((sc->re_type == MACFG_24) || (sc->re_type == MACFG_24) || (sc->re_type == MACFG_26))
6235 ifp->if_hwassist |= CSUM_TCP | CSUM_UDP;
6236 else
6237 ifp->if_hwassist |= RE_CSUM_FEATURES;
6238 } else
6239 ifp->if_hwassist &= ~RE_CSUM_FEATURES;
6240 reinit = 1;
6241 }
6242
6243 if ((mask & IFCAP_RXCSUM) != 0 &&
6244 (ifp->if_capabilities & IFCAP_RXCSUM) != 0) {
6245 ifp->if_capenable ^= IFCAP_RXCSUM;
6246 reinit = 1;
6247 }
6248
6249 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))) {
6250 if (ifp->if_capenable & IFCAP_TXCSUM)
6251 sc->re_tx_cstag = 1;
6252 else
6253 sc->re_tx_cstag = 0;
6254
6255 if (ifp->if_capenable & IFCAP_RXCSUM)
6256 sc->re_rx_cstag = 1;
6257 else
6258 sc->re_rx_cstag = 0;
6259 }
6260 if ((mask & IFCAP_VLAN_HWTAGGING) != 0 &&
6261 (ifp->if_capabilities & IFCAP_VLAN_HWTAGGING) != 0) {
6262 ifp->if_capenable ^= IFCAP_VLAN_HWTAGGING;
6263 /* TSO over VLAN requires VLAN hardware tagging. */
6264 //if ((ifp->if_capenable & IFCAP_VLAN_HWTAGGING) == 0)
6265 // ifp->if_capenable &= ~IFCAP_VLAN_HWTSO;
6266 reinit = 1;
6267 }
6268
6269 if ((mask & IFCAP_WOL) != 0 &&
6270 (ifp->if_capabilities & IFCAP_WOL) != 0) {
6271 if ((mask & IFCAP_WOL_UCAST) != 0)
6272 ifp->if_capenable ^= IFCAP_WOL_UCAST;
6273 if ((mask & IFCAP_WOL_MCAST) != 0)
6274 ifp->if_capenable ^= IFCAP_WOL_MCAST;
6275 if ((mask & IFCAP_WOL_MAGIC) != 0)
6276 ifp->if_capenable ^= IFCAP_WOL_MAGIC;
6277 }
6278 if (reinit && ifp->if_drv_flags & IFF_DRV_RUNNING) {
6279 ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
6280 re_init(sc);
6281 }
6282 VLAN_CAPABILITIES(ifp);
6283 break;
6284 default:
6285 error = EINVAL;
6286 break;
6287 }
6288
6289 /*(void)splx(s);*/
6290
6291 return(error);
6292 }
6293 #endif /* !__DragonFly__ */
6294
6295 static void re_link_on_patch(struct re_softc *sc)
6296 {
6297 struct ifnet *ifp;
6298
6299 ifp = RE_GET_IFNET(sc);
6300
6301 if (sc->re_type == MACFG_50 || sc->re_type == MACFG_51 || sc->re_type == MACFG_52) {
6302 if (CSR_READ_1(sc, RE_PHY_STATUS) & RL_PHY_STATUS_1000MF) {
6303 re_eri_write(sc, 0x1bc, 4, 0x00000011, ERIAR_ExGMAC);
6304 re_eri_write(sc, 0x1dc, 4, 0x0000001f, ERIAR_ExGMAC);
6305 } else if (CSR_READ_1(sc, RE_PHY_STATUS) & RL_PHY_STATUS_100M) {
6306 re_eri_write(sc, 0x1bc, 4, 0x0000001f, ERIAR_ExGMAC);
6307 re_eri_write(sc, 0x1dc, 4, 0x0000001f, ERIAR_ExGMAC);
6308 } else {
6309 re_eri_write(sc, 0x1bc, 4, 0x0000001f, ERIAR_ExGMAC);
6310 re_eri_write(sc, 0x1dc, 4, 0x0000002d, ERIAR_ExGMAC);
6311 }
6312 } else if ((sc->re_type == MACFG_38 || sc->re_type == MACFG_39) && (ifp->if_flags & IFF_UP)) {
6313 if (sc->re_type == MACFG_38 && (CSR_READ_1(sc, RE_PHY_STATUS) & RL_PHY_STATUS_10M)) {
6314 CSR_WRITE_4(sc, RE_RXCFG, CSR_READ_4(sc, RE_RXCFG) | RE_RXCFG_RX_ALLPHYS);
6315 } else if (sc->re_type == MACFG_39) {
6316 if (CSR_READ_1(sc, RE_PHY_STATUS) & RL_PHY_STATUS_1000MF) {
6317 re_eri_write(sc, 0x1bc, 4, 0x00000011, ERIAR_ExGMAC);
6318 re_eri_write(sc, 0x1dc, 4, 0x00000005, ERIAR_ExGMAC);
6319 } else if (CSR_READ_1(sc, RE_PHY_STATUS) & RL_PHY_STATUS_100M) {
6320 re_eri_write(sc, 0x1bc, 4, 0x0000001f, ERIAR_ExGMAC);
6321 re_eri_write(sc, 0x1dc, 4, 0x00000005, ERIAR_ExGMAC);
6322 } else {
6323 re_eri_write(sc, 0x1bc, 4, 0x0000001f, ERIAR_ExGMAC);
6324 re_eri_write(sc, 0x1dc, 4, 0x0000003f, ERIAR_ExGMAC);
6325 }
6326 }
6327 } else if ((sc->re_type == MACFG_36 || sc->re_type == MACFG_37) && eee_enable ==1) {
6328 /*Full -Duplex mode*/
6329 if (CSR_READ_1(sc, RE_PHY_STATUS) & RL_PHY_STATUS_FULL_DUP) {
6330 MP_WritePhyUshort(sc, 0x1F, 0x0006);
6331 MP_WritePhyUshort(sc, 0x00, 0x5a30);
6332 MP_WritePhyUshort(sc, 0x1F, 0x0000);
6333 if (CSR_READ_1(sc, RE_PHY_STATUS) & (RL_PHY_STATUS_10M | RL_PHY_STATUS_100M))
6334 CSR_WRITE_4(sc, RE_TXCFG, (CSR_READ_4(sc, RE_TXCFG) & ~BIT_19) | BIT_25);
6335
6336 } else {
6337 MP_WritePhyUshort(sc, 0x1F, 0x0006);
6338 MP_WritePhyUshort(sc, 0x00, 0x5a00);
6339 MP_WritePhyUshort(sc, 0x1F, 0x0000);
6340 if (CSR_READ_1(sc, RE_PHY_STATUS) & (RL_PHY_STATUS_10M | RL_PHY_STATUS_100M))
6341 CSR_WRITE_4(sc, RE_TXCFG, (CSR_READ_4(sc, RE_TXCFG) & ~BIT_19) | RE_TXCFG_IFG);
6342 }
6343 } else if ((sc->re_type == MACFG_56 || sc->re_type == MACFG_57 ||
6344 sc->re_type == MACFG_58 || sc->re_type == MACFG_59 ||
6345 sc->re_type == MACFG_60 || sc->re_type == MACFG_61 ||
6346 sc->re_type == MACFG_62 || sc->re_type == MACFG_67 ||
6347 sc->re_type == MACFG_68 || sc->re_type == MACFG_69) &&
6348 (ifp->if_flags & IFF_UP)) {
6349 if (CSR_READ_1(sc, RE_PHY_STATUS) & RL_PHY_STATUS_FULL_DUP)
6350 CSR_WRITE_4(sc, RE_TXCFG, (CSR_READ_4(sc, RE_TXCFG) | (BIT_24 | BIT_25)) & ~BIT_19);
6351 else
6352 CSR_WRITE_4(sc, RE_TXCFG, (CSR_READ_4(sc, RE_TXCFG) | BIT_25) & ~(BIT_19 | BIT_24));
6353 }
6354
6355 if (sc->re_type == MACFG_56 || sc->re_type == MACFG_57 ||
6356 sc->re_type == MACFG_61 || sc->re_type == MACFG_62) {
6357 /*half mode*/
6358 if (!(CSR_READ_1(sc, RE_PHY_STATUS) & RL_PHY_STATUS_FULL_DUP)) {
6359 MP_WritePhyUshort(sc, 0x1F, 0x0000);
6360 MP_WritePhyUshort(sc, MII_ANAR, MP_ReadPhyUshort(sc, MII_ANAR)&~(ANAR_PAUSE_SYM |ANAR_PAUSE_ASYM));
6361 }
6362 }
6363
6364 #ifndef __DragonFly__
6365 re_init_unlock(sc);
6366 #endif
6367 }
6368
6369 #ifndef __DragonFly__
6370 static void re_link_down_patch(struct re_softc *sc)
6371 {
6372 struct ifnet *ifp;
6373
6374 ifp = RE_GET_IFNET(sc);
6375
6376 re_txeof(sc);
6377 re_rxeof(sc);
6378 re_stop(sc);
6379
6380 re_ifmedia_upd(ifp);
6381 }
6382
6383 /*
6384 * Check Link Status.
6385 */
6386 static void re_check_link_status(struct re_softc *sc)
6387 {
6388 u_int8_t link_state;
6389 struct ifnet *ifp;
6390
6391 ifp = RE_GET_IFNET(sc);
6392
6393 if (re_link_ok(sc)) {
6394 link_state = LINK_STATE_UP;
6395 } else {
6396 link_state = LINK_STATE_DOWN;
6397 }
6398
6399 if (link_state != sc->link_state) {
6400 sc->link_state = link_state;
6401 if (link_state == LINK_STATE_UP) {
6402 re_link_on_patch(sc);
6403 re_link_state_change(ifp, LINK_STATE_UP);
6404 } else {
6405 re_link_state_change(ifp, LINK_STATE_DOWN);
6406 re_link_down_patch(sc);
6407 }
6408 }
6409 }
6410
6411 static void re_init_timer(struct re_softc *sc)
6412 {
6413 #ifdef RE_USE_NEW_CALLOUT_FUN
6414 callout_init(&sc->re_stat_ch, CALLOUT_MPSAFE);
6415 #else
6416 callout_handle_init(&sc->re_stat_ch);
6417 #endif
6418 }
6419
6420 static void re_stop_timer(struct re_softc *sc)
6421 {
6422 #ifdef RE_USE_NEW_CALLOUT_FUN
6423 callout_stop(&sc->re_stat_ch);
6424 #else
6425 untimeout(re_tick, sc, sc->re_stat_ch);
6426 #endif
6427 }
6428
6429 static void re_start_timer(struct re_softc *sc)
6430 {
6431 #ifdef RE_USE_NEW_CALLOUT_FUN
6432 callout_reset(&sc->re_stat_ch, hz, re_tick, sc);
6433 #else
6434 re_stop_timer(sc);
6435 sc->re_stat_ch = timeout(re_tick, sc, hz);
6436 #endif
6437 }
6438
6439 static void re_tick(xsc)
6440 void *xsc;
6441 {
6442 /*called per second*/
6443 struct re_softc *sc;
6444 int s;
6445
6446 s = splimp();
6447
6448 sc = xsc;
6449 /*mii = device_get_softc(sc->re_miibus);
6450
6451 mii_tick(mii);*/
6452
6453 splx(s);
6454
6455 RE_LOCK(sc);
6456
6457 if (sc->re_link_chg_det == 1) {
6458 re_check_link_status(sc);
6459 re_start_timer(sc);
6460 }
6461
6462 RE_UNLOCK(sc);
6463
6464 return;
6465 }
6466
6467 #if OS_VER < VERSION(7,0)
6468 static void re_watchdog(ifp)
6469 struct ifnet *ifp;
6470 {
6471 struct re_softc *sc;
6472
6473 sc = ifp->if_softc;
6474
6475 printf("re%d: watchdog timeout\n", sc->re_unit);
6476 ifp->if_oerrors++;
6477
6478 re_txeof(sc);
6479 re_rxeof(sc);
6480 re_init(sc);
6481
6482 return;
6483 }
6484 #endif
6485 #endif /* !__DragonFly__ */
6486
6487 /*
6488 * Set media options.
6489 */
6490 static int re_ifmedia_upd(struct ifnet *ifp)
6491 {
6492 struct re_softc *sc = ifp->if_softc;
6493 struct ifmedia *ifm = &sc->media;
6494 int anar;
6495 int gbcr;
6496
6497 if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER)
6498 return(EINVAL);
6499
6500 if (sc->re_type == MACFG_68 || sc->re_type == MACFG_69) {
6501 //Disable Giga Lite
6502 MP_WritePhyUshort(sc, 0x1F, 0x0A42);
6503 ClearEthPhyBit(sc, 0x14, BIT_9);
6504 MP_WritePhyUshort(sc, 0x1F, 0x0A40);
6505 MP_WritePhyUshort(sc, 0x1F, 0x0000);
6506 }
6507
6508
6509 switch (IFM_SUBTYPE(ifm->ifm_media)) {
6510 case IFM_AUTO:
6511 anar = ANAR_TX_FD |
6512 ANAR_TX |
6513 ANAR_10_FD |
6514 ANAR_10;
6515 gbcr = GTCR_ADV_1000TFDX |
6516 GTCR_ADV_1000THDX;
6517 break;
6518 case IFM_1000_SX:
6519 #ifndef __DragonFly__
6520 #if OS_VER < 500000
6521 case IFM_1000_TX:
6522 #else
6523 case IFM_1000_T:
6524 #endif
6525 #else /* __DragonFly__ */
6526 case IFM_1000_T:
6527 #endif /* !__DragonFly__ */
6528 anar = ANAR_TX_FD |
6529 ANAR_TX |
6530 ANAR_10_FD |
6531 ANAR_10;
6532 gbcr = GTCR_ADV_1000TFDX |
6533 GTCR_ADV_1000THDX;
6534 break;
6535 case IFM_100_TX:
6536 gbcr = MP_ReadPhyUshort(sc, MII_100T2CR) &
6537 ~(GTCR_ADV_1000TFDX | GTCR_ADV_1000THDX);
6538 if ((ifm->ifm_media & IFM_GMASK) == IFM_FDX) {
6539 anar = ANAR_TX_FD |
6540 ANAR_TX |
6541 ANAR_10_FD |
6542 ANAR_10;
6543 } else {
6544 anar = ANAR_TX |
6545 ANAR_10_FD |
6546 ANAR_10;
6547 }
6548 break;
6549 case IFM_10_T:
6550 gbcr = MP_ReadPhyUshort(sc, MII_100T2CR) &
6551 ~(GTCR_ADV_1000TFDX | GTCR_ADV_1000THDX);
6552 if ((ifm->ifm_media & IFM_GMASK) == IFM_FDX) {
6553 anar = ANAR_10_FD |
6554 ANAR_10;
6555 } else {
6556 anar = ANAR_10;
6557 }
6558
6559 if (sc->re_type == MACFG_13) {
6560 MP_WritePhyUshort(sc, MII_BMCR, 0x8000);
6561 }
6562
6563 break;
6564 default:
6565 #ifndef __DragonFly__
6566 printf("re%d: Unsupported media type\n", sc->re_unit);
6567 return(0);
6568 #else
6569 if_printf(ifp, "Unsupported media type\n");
6570 return (EOPNOTSUPP);
6571 #endif
6572 }
6573
6574 MP_WritePhyUshort(sc, 0x1F, 0x0000);
6575 if (sc->re_device_id==RT_DEVICEID_8169 || sc->re_device_id==RT_DEVICEID_8169SC ||
6576 sc->re_device_id==RT_DEVICEID_8168 || sc->re_device_id==RT_DEVICEID_8161) {
6577 MP_WritePhyUshort(sc, MII_ANAR, anar | 0x0800 | ANAR_FC);
6578 MP_WritePhyUshort(sc, MII_100T2CR, gbcr);
6579 MP_WritePhyUshort(sc, MII_BMCR, BMCR_RESET | BMCR_AUTOEN | BMCR_STARTNEG);
6580 } else if (sc->re_type == MACFG_36) {
6581 MP_WritePhyUshort(sc, MII_ANAR, anar | 0x0800 | ANAR_FC);
6582 MP_WritePhyUshort(sc, MII_BMCR, BMCR_RESET | BMCR_AUTOEN | BMCR_STARTNEG);
6583 } else {
6584 MP_WritePhyUshort(sc, MII_ANAR, anar | 1);
6585 MP_WritePhyUshort(sc, MII_BMCR, BMCR_AUTOEN | BMCR_STARTNEG);
6586 }
6587
6588 return(0);
6589 }
6590
6591 /*
6592 * Report current media status.
6593 */
6594 static void re_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr)
6595 {
6596 struct re_softc *sc;
6597
6598 sc = ifp->if_softc;
6599
6600 RE_LOCK(sc);
6601
6602 ifmr->ifm_status = IFM_AVALID;
6603 ifmr->ifm_active = IFM_ETHER;
6604
6605 if (re_link_ok(sc)) {
6606 unsigned char msr;
6607
6608 ifmr->ifm_status |= IFM_ACTIVE;
6609
6610 msr = CSR_READ_1(sc, RE_PHY_STATUS);
6611 if (msr & RL_PHY_STATUS_FULL_DUP)
6612 ifmr->ifm_active |= IFM_FDX;
6613 else
6614 ifmr->ifm_active |= IFM_HDX;
6615
6616 if (msr & RL_PHY_STATUS_10M)
6617 ifmr->ifm_active |= IFM_10_T;
6618 else if (msr & RL_PHY_STATUS_100M)
6619 ifmr->ifm_active |= IFM_100_TX;
6620 else if (msr & RL_PHY_STATUS_1000MF)
6621 ifmr->ifm_active |= IFM_1000_T;
6622 #ifdef __DragonFly__
6623 } else {
6624 if (IFM_SUBTYPE(sc->media.ifm_media) == IFM_AUTO)
6625 ifmr->ifm_active |= IFM_NONE;
6626 else
6627 ifmr->ifm_active |= sc->media.ifm_media;
6628 #endif
6629 }
6630
6631 RE_UNLOCK(sc);
6632
6633 return;
6634 }
6635
6636 static int re_enable_EEE(struct re_softc *sc)
6637 {
6638 int ret;
6639 u_int16_t data;
6640 u_int16_t PhyRegValue;
6641 u_int32_t WaitCnt;
6642
6643 ret = 0;
6644 switch (sc->re_type) {
6645 case MACFG_42:
6646 case MACFG_43:
6647 re_eri_write(sc, 0x1B0, 2, 0xED03, ERIAR_ExGMAC);
6648 MP_WritePhyUshort(sc, 0x1F, 0x0004);
6649 if (CSR_READ_1(sc,0xEF) & 0x02) {
6650 MP_WritePhyUshort(sc, 0x10, 0x731F);
6651 MP_WritePhyUshort(sc, 0x19, 0x7630);
6652 } else {
6653 MP_WritePhyUshort(sc, 0x10, 0x711F);
6654 MP_WritePhyUshort(sc, 0x19, 0x7030);
6655 }
6656 MP_WritePhyUshort(sc, 0x1A, 0x1506);
6657 MP_WritePhyUshort(sc, 0x1B, 0x0551);
6658 MP_WritePhyUshort(sc, 0x1F, 0x0000);
6659 MP_WritePhyUshort(sc, 0x0D, 0x0007);
6660 MP_WritePhyUshort(sc, 0x0E, 0x003C);
6661 MP_WritePhyUshort(sc, 0x0D, 0x4007);
6662 MP_WritePhyUshort(sc, 0x0E, 0x0002);
6663 MP_WritePhyUshort(sc, 0x0D, 0x0000);
6664
6665 MP_WritePhyUshort(sc, 0x1F, 0x0000);
6666 MP_WritePhyUshort(sc, 0x0D, 0x0003);
6667 MP_WritePhyUshort(sc, 0x0E, 0x0015);
6668 MP_WritePhyUshort(sc, 0x0D, 0x4003);
6669 MP_WritePhyUshort(sc, 0x0E, 0x0002);
6670 MP_WritePhyUshort(sc, 0x0D, 0x0000);
6671
6672 MP_WritePhyUshort(sc, MII_BMCR, BMCR_AUTOEN | BMCR_STARTNEG);
6673 break;
6674
6675 case MACFG_53:
6676 case MACFG_54:
6677 case MACFG_55:
6678 re_eri_write(sc, 0x1B0, 2, 0xED03, ERIAR_ExGMAC);
6679 MP_WritePhyUshort(sc, 0x1F, 0x0004);
6680 MP_WritePhyUshort(sc, 0x10, 0x731F);
6681 MP_WritePhyUshort(sc, 0x19, 0x7630);
6682 MP_WritePhyUshort(sc, 0x1A, 0x1506);
6683 MP_WritePhyUshort(sc, 0x1F, 0x0000);
6684 MP_WritePhyUshort(sc, 0x0D, 0x0007);
6685 MP_WritePhyUshort(sc, 0x0E, 0x003C);
6686 MP_WritePhyUshort(sc, 0x0D, 0x4007);
6687 MP_WritePhyUshort(sc, 0x0E, 0x0002);
6688 MP_WritePhyUshort(sc, 0x0D, 0x0000);
6689
6690 MP_WritePhyUshort(sc, MII_BMCR, BMCR_AUTOEN | BMCR_STARTNEG);
6691 break;
6692
6693 case MACFG_36:
6694 case MACFG_37:
6695 MP_WritePhyUshort(sc, 0x1F, 0x0007);
6696 MP_WritePhyUshort(sc, 0x1E, 0x0020);
6697 data = MP_ReadPhyUshort(sc, 0x15) | 0x0100;
6698 MP_WritePhyUshort(sc, 0x15, data);
6699 MP_WritePhyUshort(sc, 0x1F, 0x0006);
6700 MP_WritePhyUshort(sc, 0x00, 0x5A30);
6701 MP_WritePhyUshort(sc, 0x1F, 0x0000);
6702 MP_WritePhyUshort(sc, 0x0D, 0x0007);
6703 MP_WritePhyUshort(sc, 0x0E, 0x003C);
6704 MP_WritePhyUshort(sc, 0x0D, 0x4007);
6705 MP_WritePhyUshort(sc, 0x0E, 0x0006);
6706 MP_WritePhyUshort(sc, 0x0D, 0x0000);
6707 if ((CSR_READ_1(sc, RE_CFG4)&RL_CFG4_CUSTOMIZED_LED) && (CSR_READ_1(sc, RE_MACDBG) & BIT_7)) {
6708 MP_WritePhyUshort(sc, 0x1F, 0x0005);
6709 MP_WritePhyUshort(sc, 0x05, 0x8AC8);
6710 MP_WritePhyUshort(sc, 0x06, CSR_READ_1(sc, RE_CUSTOM_LED));
6711 MP_WritePhyUshort(sc, 0x05, 0x8B82);
6712 data = MP_ReadPhyUshort(sc, 0x06) | 0x0010;
6713 MP_WritePhyUshort(sc, 0x05, 0x8B82);
6714 MP_WritePhyUshort(sc, 0x06, data);
6715 MP_WritePhyUshort(sc, 0x1F, 0x0000);
6716 }
6717 break;
6718
6719 case MACFG_50:
6720 case MACFG_51:
6721 case MACFG_52:
6722 data = re_eri_read(sc, 0x1B0 ,4,ERIAR_ExGMAC) | 0x0003;
6723 re_eri_write(sc, 0x1B0, 4, data, ERIAR_ExGMAC);
6724 MP_WritePhyUshort(sc,0x1F , 0x0007);
6725 MP_WritePhyUshort(sc,0x1E , 0x0020);
6726 data = MP_ReadPhyUshort(sc, 0x15)|0x0100;
6727 MP_WritePhyUshort(sc,0x15 , data);
6728 MP_WritePhyUshort(sc,0x1F , 0x0005);
6729 MP_WritePhyUshort(sc,0x05 , 0x8B85);
6730 data = MP_ReadPhyUshort(sc, 0x06)|0x2000;
6731 MP_WritePhyUshort(sc,0x06 , data);
6732 MP_WritePhyUshort(sc,0x1F , 0x0000);
6733 MP_WritePhyUshort(sc,0x0D , 0x0007);
6734 MP_WritePhyUshort(sc,0x0E , 0x003C);
6735 MP_WritePhyUshort(sc,0x0D , 0x4007);
6736 MP_WritePhyUshort(sc,0x0E , 0x0006);
6737 MP_WritePhyUshort(sc,0x1D , 0x0000);
6738 break;
6739
6740 case MACFG_38:
6741 case MACFG_39:
6742 data = re_eri_read(sc, 0x1B0 ,4,ERIAR_ExGMAC);
6743 data |= BIT_1 | BIT_0;
6744 re_eri_write(sc, 0x1B0, 4, data, ERIAR_ExGMAC);
6745 MP_WritePhyUshort(sc, 0x1F, 0x0004);
6746 MP_WritePhyUshort(sc, 0x1F, 0x0007);
6747 MP_WritePhyUshort(sc, 0x1e, 0x0020);
6748 data = MP_ReadPhyUshort(sc, 0x15);
6749 data |= BIT_8;
6750 MP_WritePhyUshort(sc, 0x15, data);
6751 MP_WritePhyUshort(sc, 0x1F, 0x0002);
6752 MP_WritePhyUshort(sc, 0x1F, 0x0005);
6753 MP_WritePhyUshort(sc, 0x05, 0x8B85);
6754 data = MP_ReadPhyUshort(sc, 0x06);
6755 data |= BIT_13;
6756 MP_WritePhyUshort(sc, 0x06, data);
6757 MP_WritePhyUshort(sc, 0x1F, 0x0000);
6758 MP_WritePhyUshort(sc, 0x0D, 0x0007);
6759 MP_WritePhyUshort(sc, 0x0E, 0x003C);
6760 MP_WritePhyUshort(sc, 0x0D, 0x4007);
6761 MP_WritePhyUshort(sc, 0x0E, 0x0006);
6762 MP_WritePhyUshort(sc, 0x0D, 0x0000);
6763 break;
6764
6765 case MACFG_56:
6766 case MACFG_57:
6767 case MACFG_58:
6768 case MACFG_59:
6769 case MACFG_60:
6770 case MACFG_61:
6771 case MACFG_62:
6772 case MACFG_67:
6773 case MACFG_68:
6774 case MACFG_69:
6775 data = re_eri_read(sc, 0x1B0, 4, ERIAR_ExGMAC);
6776 data |= BIT_1 | BIT_0;
6777 re_eri_write(sc, 0x1B0, 4, data, ERIAR_ExGMAC);
6778 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
6779 data = MP_ReadPhyUshort(sc, 0x11);
6780 MP_WritePhyUshort(sc, 0x11, data | BIT_4);
6781 MP_WritePhyUshort(sc, 0x1F, 0x0A5D);
6782 MP_WritePhyUshort(sc, 0x10, 0x0006);
6783 MP_WritePhyUshort(sc, 0x1F, 0x0000);
6784 break;
6785
6786 default:
6787 ret = -EOPNOTSUPP;
6788 break;
6789 }
6790
6791 switch (sc->re_type) {
6792 case MACFG_68:
6793 case MACFG_69:
6794 MP_WritePhyUshort(sc, 0x1F, 0x0A4A);
6795 SetEthPhyBit(sc, 0x11, BIT_9);
6796 MP_WritePhyUshort(sc, 0x1F, 0x0A42);
6797 SetEthPhyBit(sc, 0x14, BIT_7);
6798 MP_WritePhyUshort(sc, 0x1F, 0x0000);
6799 break;
6800 }
6801
6802 /*Advanced EEE*/
6803 switch (sc->re_type) {
6804 case MACFG_58:
6805 case MACFG_59:
6806 case MACFG_60:
6807 case MACFG_68:
6808 case MACFG_69:
6809 MP_WritePhyUshort(sc, 0x1F, 0x0B82);
6810 SetEthPhyBit(sc, 0x10, BIT_4);
6811 MP_WritePhyUshort(sc, 0x1F, 0x0000);
6812
6813 MP_WritePhyUshort(sc,0x1F, 0x0B80);
6814 WaitCnt = 0;
6815 do {
6816 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
6817 PhyRegValue &= 0x0040;
6818 DELAY(50);
6819 DELAY(50);
6820 WaitCnt++;
6821 } while(PhyRegValue != 0x0040 && WaitCnt <1000);
6822
6823 MP_WritePhyUshort(sc, 0x1F, 0x0000);
6824 break;
6825 }
6826
6827 switch (sc->re_type) {
6828 case MACFG_59:
6829 re_eri_write(sc, 0x1EA, 1, 0xFA, ERIAR_ExGMAC);
6830
6831 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
6832 data = MP_ReadPhyUshort(sc, 0x10);
6833 if (data & BIT_10) {
6834 MP_WritePhyUshort(sc, 0x1F, 0x0A42);
6835 data = MP_ReadPhyUshort(sc, 0x16);
6836 data &= ~(BIT_1);
6837 MP_WritePhyUshort(sc, 0x16, data);
6838 } else {
6839 MP_WritePhyUshort(sc, 0x1F, 0x0A42);
6840 data = MP_ReadPhyUshort(sc, 0x16);
6841 data |= BIT_1;
6842 MP_WritePhyUshort(sc, 0x16, data);
6843 }
6844 MP_WritePhyUshort(sc, 0x1F, 0x0000);
6845 break;
6846 case MACFG_60:
6847 data = MP_ReadMcuAccessRegWord(sc, 0xE052);
6848 data |= BIT_0;
6849 MP_WriteMcuAccessRegWord(sc, 0xE052, data);
6850 data = MP_ReadMcuAccessRegWord(sc, 0xE056);
6851 data &= 0xFF0F;
6852 data |= (BIT_4 | BIT_5 | BIT_6);
6853 MP_WriteMcuAccessRegWord(sc, 0xE056, data);
6854
6855 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
6856 data = MP_ReadPhyUshort(sc, 0x10);
6857 if (data & BIT_10) {
6858 MP_WritePhyUshort(sc, 0x1F, 0x0A42);
6859 data = MP_ReadPhyUshort(sc, 0x16);
6860 data &= ~(BIT_1);
6861 MP_WritePhyUshort(sc, 0x16, data);
6862 } else {
6863 MP_WritePhyUshort(sc, 0x1F, 0x0A42);
6864 data = MP_ReadPhyUshort(sc, 0x16);
6865 data |= BIT_1;
6866 MP_WritePhyUshort(sc, 0x16, data);
6867 }
6868 MP_WritePhyUshort(sc, 0x1F, 0x0000);
6869 break;
6870 case MACFG_61:
6871 case MACFG_62:
6872 case MACFG_67:
6873 OOB_mutex_lock(sc);
6874 data = MP_ReadMcuAccessRegWord(sc, 0xE052);
6875 data &= ~BIT_0;
6876 MP_WriteMcuAccessRegWord(sc, 0xE052, data);
6877 OOB_mutex_unlock(sc);
6878 data = MP_ReadMcuAccessRegWord(sc, 0xE056);
6879 data &= 0xFF0F;
6880 data |= (BIT_4 | BIT_5 | BIT_6);
6881 MP_WriteMcuAccessRegWord(sc, 0xE056, data);
6882 break;
6883 case MACFG_68:
6884 case MACFG_69:
6885 data = MP_ReadMcuAccessRegWord(sc, 0xE052);
6886 data |= BIT_0;
6887 MP_WriteMcuAccessRegWord(sc, 0xE052, data);
6888
6889 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
6890 data = MP_ReadPhyUshort(sc, 0x10) | BIT_15;
6891 MP_WritePhyUshort(sc, 0x10, data);
6892
6893 MP_WritePhyUshort(sc, 0x1F, 0x0A44);
6894 data = MP_ReadPhyUshort(sc, 0x11) | BIT_13 | BIT_14;
6895 data &= ~(BIT_12);
6896 MP_WritePhyUshort(sc, 0x11, data);
6897 break;
6898 }
6899
6900 switch (sc->re_type) {
6901 case MACFG_58:
6902 case MACFG_59:
6903 case MACFG_60:
6904 case MACFG_68:
6905 case MACFG_69:
6906 MP_WritePhyUshort(sc,0x1F, 0x0B82);
6907 ClearEthPhyBit(sc, 0x10, BIT_4);
6908 MP_WritePhyUshort(sc, 0x1F, 0x0000);
6909 break;
6910 }
6911
6912 return ret;
6913 }
6914
6915 static int re_disable_EEE(struct re_softc *sc)
6916 {
6917 int ret;
6918 u_int16_t data;
6919 u_int16_t PhyRegValue;
6920 u_int32_t WaitCnt;
6921
6922 ret = 0;
6923 switch (sc->re_type) {
6924 case MACFG_42:
6925 case MACFG_43:
6926 re_eri_write(sc, 0x1B0, 2, 0, ERIAR_ExGMAC);
6927 MP_WritePhyUshort(sc, 0x1F, 0x0004);
6928 MP_WritePhyUshort(sc, 0x10, 0x401F);
6929 MP_WritePhyUshort(sc, 0x19, 0x7030);
6930
6931 MP_WritePhyUshort(sc, 0x1F, 0x0000);
6932 MP_WritePhyUshort(sc, 0x0D, 0x0007);
6933 MP_WritePhyUshort(sc, 0x0E, 0x003C);
6934 MP_WritePhyUshort(sc, 0x0D, 0x4007);
6935 MP_WritePhyUshort(sc, 0x0E, 0x0000);
6936 MP_WritePhyUshort(sc, 0x0D, 0x0000);
6937
6938 MP_WritePhyUshort(sc, 0x1F, 0x0000);
6939 MP_WritePhyUshort(sc, 0x0D, 0x0003);
6940 MP_WritePhyUshort(sc, 0x0E, 0x0015);
6941 MP_WritePhyUshort(sc, 0x0D, 0x4003);
6942 MP_WritePhyUshort(sc, 0x0E, 0x0000);
6943 MP_WritePhyUshort(sc, 0x0D, 0x0000);
6944
6945 MP_WritePhyUshort(sc, MII_BMCR, BMCR_AUTOEN | BMCR_STARTNEG);
6946 break;
6947
6948 case MACFG_53:
6949 re_eri_write(sc, 0x1B0, 2, 0, ERIAR_ExGMAC);
6950 MP_WritePhyUshort(sc, 0x1F, 0x0004);
6951 MP_WritePhyUshort(sc, 0x10, 0x401F);
6952 MP_WritePhyUshort(sc, 0x19, 0x7030);
6953
6954 MP_WritePhyUshort(sc, 0x1F, 0x0000);
6955 MP_WritePhyUshort(sc, 0x0D, 0x0007);
6956 MP_WritePhyUshort(sc, 0x0E, 0x003C);
6957 MP_WritePhyUshort(sc, 0x0D, 0x4007);
6958 MP_WritePhyUshort(sc, 0x0E, 0x0000);
6959 MP_WritePhyUshort(sc, 0x0D, 0x0000);
6960
6961 MP_WritePhyUshort(sc, MII_BMCR, BMCR_AUTOEN | BMCR_STARTNEG);
6962 break;
6963
6964 case MACFG_54:
6965 case MACFG_55:
6966 re_eri_write(sc, 0x1B0, 2, 0, ERIAR_ExGMAC);
6967 MP_WritePhyUshort(sc, 0x1F, 0x0004);
6968 MP_WritePhyUshort(sc, 0x10, 0xC07F);
6969 MP_WritePhyUshort(sc, 0x19, 0x7030);
6970 MP_WritePhyUshort(sc, 0x1F, 0x0000);
6971
6972 MP_WritePhyUshort(sc, 0x1F, 0x0000);
6973 MP_WritePhyUshort(sc, 0x0D, 0x0007);
6974 MP_WritePhyUshort(sc, 0x0E, 0x003C);
6975 MP_WritePhyUshort(sc, 0x0D, 0x4007);
6976 MP_WritePhyUshort(sc, 0x0E, 0x0000);
6977 MP_WritePhyUshort(sc, 0x0D, 0x0000);
6978
6979 MP_WritePhyUshort(sc, MII_BMCR, BMCR_AUTOEN | BMCR_STARTNEG);
6980 break;
6981
6982 case MACFG_36:
6983 case MACFG_37:
6984 MP_WritePhyUshort(sc, 0x1F, 0x0007);
6985 MP_WritePhyUshort(sc, 0x1E, 0x0020);
6986 data = MP_ReadPhyUshort(sc, 0x15) & ~0x0100;
6987 MP_WritePhyUshort(sc, 0x15, data);
6988 MP_WritePhyUshort(sc, 0x1F, 0x0006);
6989 MP_WritePhyUshort(sc, 0x00, 0x5A00);
6990 MP_WritePhyUshort(sc, 0x1F, 0x0000);
6991 MP_WritePhyUshort(sc, 0x0D, 0x0007);
6992 MP_WritePhyUshort(sc, 0x0E, 0x003C);
6993 MP_WritePhyUshort(sc, 0x0D, 0x4007);
6994 MP_WritePhyUshort(sc, 0x0E, 0x0000);
6995 MP_WritePhyUshort(sc, 0x0D, 0x0000);
6996 MP_WritePhyUshort(sc, 0x1F, 0x0000);
6997 if (CSR_READ_1(sc, RE_CFG4) & RL_CFG4_CUSTOMIZED_LED) {
6998 MP_WritePhyUshort(sc, 0x1F, 0x0005);
6999 MP_WritePhyUshort(sc, 0x05, 0x8B82);
7000 data = MP_ReadPhyUshort(sc, 0x06) & ~0x0010;
7001 MP_WritePhyUshort(sc, 0x05, 0x8B82);
7002 MP_WritePhyUshort(sc, 0x06, data);
7003 MP_WritePhyUshort(sc, 0x1F, 0x0000);
7004 }
7005 break;
7006
7007 case MACFG_50:
7008 case MACFG_51:
7009 case MACFG_52:
7010 data = re_eri_read(sc,0x1B0 ,4,ERIAR_ExGMAC)& ~0x0003;
7011 re_eri_write(sc, 0x1B0, 4, data, ERIAR_ExGMAC);
7012 MP_WritePhyUshort(sc, 0x1F, 0x0005);
7013 MP_WritePhyUshort(sc, 0x05, 0x8B85);
7014 data = MP_ReadPhyUshort(sc, 0x06) & ~0x2000;
7015 MP_WritePhyUshort(sc, 0x06, data);
7016 MP_WritePhyUshort(sc, 0x1F, 0x0007);
7017 MP_WritePhyUshort(sc, 0x1E, 0x0020);
7018 data = MP_ReadPhyUshort(sc, 0x15) & ~0x0100;
7019 MP_WritePhyUshort(sc,0x15 , data);
7020 MP_WritePhyUshort(sc, 0x1F, 0x0000);
7021 MP_WritePhyUshort(sc, 0x0D, 0x0007);
7022 MP_WritePhyUshort(sc, 0x0E, 0x003C);
7023 MP_WritePhyUshort(sc, 0x0D, 0x4007);
7024 MP_WritePhyUshort(sc, 0x0E, 0x0000);
7025 MP_WritePhyUshort(sc, 0x0D, 0x0000);
7026 MP_WritePhyUshort(sc, 0x1F, 0x0000);
7027 break;
7028
7029 case MACFG_38:
7030 case MACFG_39:
7031 data = re_eri_read(sc,0x1B0 ,4,ERIAR_ExGMAC);
7032 data &= ~(BIT_1 | BIT_0);
7033 re_eri_write(sc, 0x1B0, 4, data, ERIAR_ExGMAC);
7034 MP_WritePhyUshort(sc, 0x1F, 0x0005);
7035 MP_WritePhyUshort(sc, 0x05, 0x8B85);
7036 data = MP_ReadPhyUshort(sc, 0x06);
7037 data &= ~BIT_13;
7038 MP_WritePhyUshort(sc, 0x06, data);
7039 MP_WritePhyUshort(sc, 0x1F, 0x0004);
7040 MP_WritePhyUshort(sc, 0x1F, 0x0007);
7041 MP_WritePhyUshort(sc, 0x1e, 0x0020);
7042 data = MP_ReadPhyUshort(sc, 0x15);
7043 data &= ~BIT_8;
7044 MP_WritePhyUshort(sc, 0x15, data);
7045 MP_WritePhyUshort(sc, 0x1F, 0x0002);
7046 MP_WritePhyUshort(sc, 0x1F, 0x0000);
7047 MP_WritePhyUshort(sc, 0x0D, 0x0007);
7048 MP_WritePhyUshort(sc, 0x0E, 0x003C);
7049 MP_WritePhyUshort(sc, 0x0D, 0x4007);
7050 MP_WritePhyUshort(sc, 0x0E, 0x0000);
7051 MP_WritePhyUshort(sc, 0x0D, 0x0000);
7052 MP_WritePhyUshort(sc, 0x1F, 0x0000);
7053 break;
7054
7055 case MACFG_56:
7056 case MACFG_57:
7057 case MACFG_58:
7058 case MACFG_59:
7059 case MACFG_60:
7060 case MACFG_61:
7061 case MACFG_62:
7062 case MACFG_67:
7063 case MACFG_68:
7064 case MACFG_69:
7065 data = re_eri_read(sc, 0x1B0, 4, ERIAR_ExGMAC);
7066 data &= ~(BIT_1 | BIT_0);
7067 re_eri_write(sc, 0x1B0, 4, data, ERIAR_ExGMAC);
7068 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
7069 data = MP_ReadPhyUshort(sc, 0x11);
7070 MP_WritePhyUshort(sc, 0x11, data & ~BIT_4);
7071 MP_WritePhyUshort(sc, 0x1F, 0x0A5D);
7072 MP_WritePhyUshort(sc, 0x10, 0x0000);
7073 MP_WritePhyUshort(sc, 0x1F, 0x0000);
7074 break;
7075
7076 default:
7077 ret = -EOPNOTSUPP;
7078 break;
7079 }
7080
7081 switch (sc->re_type) {
7082 case MACFG_68:
7083 case MACFG_69:
7084 MP_WritePhyUshort(sc, 0x1F, 0x0A42);
7085 ClearEthPhyBit(sc, 0x14, BIT_7);
7086 MP_WritePhyUshort(sc, 0x1F, 0x0A4A);
7087 ClearEthPhyBit(sc, 0x11, BIT_9);
7088 MP_WritePhyUshort(sc, 0x1F, 0x0000);
7089 break;
7090 }
7091
7092 /*Advanced EEE*/
7093 switch (sc->re_type) {
7094 case MACFG_58:
7095 case MACFG_59:
7096 case MACFG_60:
7097 case MACFG_68:
7098 case MACFG_69:
7099 MP_WritePhyUshort(sc, 0x1F, 0x0B82);
7100 SetEthPhyBit(sc, 0x10, BIT_4);
7101 MP_WritePhyUshort(sc, 0x1F, 0x0000);
7102
7103 MP_WritePhyUshort(sc,0x1F, 0x0B80);
7104 WaitCnt = 0;
7105 do {
7106 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
7107 PhyRegValue &= 0x0040;
7108 DELAY(50);
7109 DELAY(50);
7110 WaitCnt++;
7111 } while(PhyRegValue != 0x0040 && WaitCnt <1000);
7112
7113 MP_WritePhyUshort(sc, 0x1F, 0x0000);
7114 break;
7115 }
7116
7117 switch (sc->re_type) {
7118 case MACFG_59:
7119 re_eri_write(sc, 0x1EA, 1, 0x00, ERIAR_ExGMAC);
7120
7121 MP_WritePhyUshort(sc, 0x1F, 0x0A42);
7122 data = MP_ReadPhyUshort(sc, 0x16);
7123 data &= ~(BIT_1);
7124 MP_WritePhyUshort(sc, 0x16, data);
7125 MP_WritePhyUshort(sc, 0x1F, 0x0000);
7126 break;
7127 case MACFG_60:
7128 data = MP_ReadMcuAccessRegWord(sc, 0xE052);
7129 data &= ~(BIT_0);
7130 MP_WriteMcuAccessRegWord(sc, 0xE052, data);
7131
7132 MP_WritePhyUshort(sc, 0x1F, 0x0A42);
7133 data = MP_ReadPhyUshort(sc, 0x16);
7134 data &= ~(BIT_1);
7135 MP_WritePhyUshort(sc, 0x16, data);
7136 MP_WritePhyUshort(sc, 0x1F, 0x0000);
7137 break;
7138 case MACFG_61:
7139 case MACFG_62:
7140 case MACFG_67:
7141 data = MP_ReadMcuAccessRegWord(sc, 0xE052);
7142 data &= ~(BIT_0);
7143 MP_WriteMcuAccessRegWord(sc, 0xE052, data);
7144 break;
7145 case MACFG_68:
7146 case MACFG_69:
7147 data = MP_ReadMcuAccessRegWord(sc, 0xE052);
7148 data &= ~(BIT_0);
7149 MP_WriteMcuAccessRegWord(sc, 0xE052, data);
7150
7151 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
7152 data = MP_ReadPhyUshort(sc, 0x10) & ~(BIT_15);
7153 MP_WritePhyUshort(sc, 0x10, data);
7154
7155 MP_WritePhyUshort(sc, 0x1F, 0x0A44);
7156 data = MP_ReadPhyUshort(sc, 0x11) & ~(BIT_12 | BIT_13 | BIT_14);
7157 MP_WritePhyUshort(sc, 0x11, data);
7158 break;
7159 }
7160
7161 switch (sc->re_type) {
7162 case MACFG_58:
7163 case MACFG_59:
7164 case MACFG_60:
7165 case MACFG_68:
7166 case MACFG_69:
7167 MP_WritePhyUshort(sc,0x1F, 0x0B82);
7168 ClearEthPhyBit(sc, 0x10, BIT_4);
7169 MP_WritePhyUshort(sc, 0x1F, 0x0000);
7170 break;
7171 }
7172
7173 return ret;
7174 }
7175
7176 static int re_phy_ram_code_check(struct re_softc *sc)
7177 {
7178 u_int16_t PhyRegValue;
7179 u_int32_t WaitCnt;
7180 int retval = TRUE;
7181
7182 switch(sc->re_type) {
7183 case MACFG_56:
7184 MP_WritePhyUshort(sc, 0x1f, 0x0A40);
7185 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
7186 PhyRegValue &= ~(BIT_11);
7187 MP_WritePhyUshort(sc, 0x10, PhyRegValue);
7188
7189
7190 MP_WritePhyUshort(sc, 0x1f, 0x0A00);
7191 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
7192 PhyRegValue &= ~(BIT_12 | BIT_13 | BIT_14 | BIT_15);
7193 MP_WritePhyUshort(sc, 0x10, PhyRegValue);
7194
7195 MP_WritePhyUshort(sc, 0x1f, 0x0A43);
7196 MP_WritePhyUshort(sc, 0x13, 0x8010);
7197 PhyRegValue = MP_ReadPhyUshort(sc, 0x14);
7198 PhyRegValue &= ~(BIT_11);
7199 MP_WritePhyUshort(sc, 0x14, PhyRegValue);
7200
7201 MP_WritePhyUshort(sc,0x1f, 0x0B82);
7202 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
7203 PhyRegValue |= BIT_4;
7204 MP_WritePhyUshort(sc,0x10, PhyRegValue);
7205
7206 MP_WritePhyUshort(sc,0x1f, 0x0B80);
7207 WaitCnt = 0;
7208 do {
7209 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
7210 PhyRegValue &= 0x0040;
7211 DELAY(50);
7212 DELAY(50);
7213 WaitCnt++;
7214 } while(PhyRegValue != 0x0040 && WaitCnt <1000);
7215
7216 if (WaitCnt == 1000) {
7217 retval = FALSE ;
7218 }
7219
7220 MP_WritePhyUshort(sc, 0x1f, 0x0A40);
7221 MP_WritePhyUshort(sc, 0x10, 0x0140);
7222
7223 MP_WritePhyUshort(sc, 0x1f, 0x0A4A);
7224 PhyRegValue = MP_ReadPhyUshort(sc, 0x13);
7225 PhyRegValue &= ~(BIT_6);
7226 PhyRegValue |= (BIT_7);
7227 MP_WritePhyUshort(sc, 0x13, PhyRegValue);
7228
7229 MP_WritePhyUshort(sc, 0x1f, 0x0A44);
7230 PhyRegValue = MP_ReadPhyUshort(sc, 0x14);
7231 PhyRegValue |= (BIT_2);
7232 MP_WritePhyUshort(sc, 0x14, PhyRegValue);
7233
7234 MP_WritePhyUshort(sc, 0x1f, 0x0A50);
7235 PhyRegValue = MP_ReadPhyUshort(sc, 0x11);
7236 PhyRegValue |= (BIT_11|BIT_12);
7237 MP_WritePhyUshort(sc, 0x11, PhyRegValue);
7238
7239 MP_WritePhyUshort(sc, 0x1f, 0x0B82);
7240 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
7241 PhyRegValue &= ~(BIT_4);
7242 MP_WritePhyUshort(sc, 0x10, PhyRegValue);
7243
7244 MP_WritePhyUshort(sc,0x1f, 0x0A22);
7245 WaitCnt = 0;
7246 do {
7247 PhyRegValue = MP_ReadPhyUshort(sc, 0x12);
7248 PhyRegValue &= 0x0010;
7249 DELAY(50);
7250 DELAY(50);
7251 WaitCnt++;
7252 } while(PhyRegValue != 0x0010 && WaitCnt <1000);
7253
7254 if (WaitCnt == 1000) {
7255 retval = FALSE;
7256 }
7257
7258 MP_WritePhyUshort(sc, 0x1f, 0x0A40);
7259 MP_WritePhyUshort(sc, 0x10, 0x1040);
7260
7261 MP_WritePhyUshort(sc, 0x1f, 0x0A4A);
7262 PhyRegValue = MP_ReadPhyUshort(sc, 0x13);
7263 PhyRegValue &= ~(BIT_6|BIT_7);
7264 MP_WritePhyUshort(sc, 0x13, PhyRegValue);
7265
7266 MP_WritePhyUshort(sc, 0x1f, 0x0A44);
7267 PhyRegValue = MP_ReadPhyUshort(sc, 0x14);
7268 PhyRegValue &= ~(BIT_2);
7269 MP_WritePhyUshort(sc, 0x14, PhyRegValue);
7270
7271 MP_WritePhyUshort(sc, 0x1f, 0x0A50);
7272 PhyRegValue = MP_ReadPhyUshort(sc, 0x11);
7273 PhyRegValue &= ~(BIT_11|BIT_12);
7274 MP_WritePhyUshort(sc, 0x11, PhyRegValue);
7275
7276 MP_WritePhyUshort(sc, 0x1f, 0x0A43);
7277 MP_WritePhyUshort(sc, 0x13, 0x8010);
7278 PhyRegValue = MP_ReadPhyUshort(sc, 0x14);
7279 PhyRegValue |= (BIT_11);
7280 MP_WritePhyUshort(sc, 0x14, PhyRegValue);
7281
7282 MP_WritePhyUshort(sc,0x1f, 0x0B82);
7283 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
7284 PhyRegValue |= BIT_4;
7285 MP_WritePhyUshort(sc,0x10, PhyRegValue);
7286
7287 MP_WritePhyUshort(sc,0x1f, 0x0B80);
7288 WaitCnt = 0;
7289 do {
7290 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
7291 PhyRegValue &= 0x0040;
7292 DELAY(50);
7293 DELAY(50);
7294 WaitCnt++;
7295 } while(PhyRegValue != 0x0040 && WaitCnt <1000);
7296
7297 if (WaitCnt == 1000) {
7298 retval = FALSE;
7299 }
7300
7301 MP_WritePhyUshort(sc, 0x1f, 0x0A20);
7302 PhyRegValue = MP_ReadPhyUshort(sc, 0x13);
7303 if (PhyRegValue & BIT_11) {
7304 if (PhyRegValue & BIT_10) {
7305 retval = FALSE;
7306 }
7307 }
7308
7309 MP_WritePhyUshort(sc, 0x1f, 0x0B82);
7310 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
7311 PhyRegValue &= ~(BIT_4);
7312 MP_WritePhyUshort(sc, 0x10, PhyRegValue);
7313
7314 //delay 2ms
7315 DELAY(2000);
7316 break;
7317 default:
7318 break;
7319 }
7320
7321 MP_WritePhyUshort(sc, 0x1F, 0x0000);
7322
7323 return retval;
7324 }
7325
7326 static void re_set_phy_ram_code_check_fail_flag(struct re_softc *sc)
7327 {
7328 u_int16_t TmpUshort;
7329
7330 switch(sc->re_type) {
7331 case MACFG_56:
7332 TmpUshort = MP_ReadMcuAccessRegWord(sc, 0xD3C0);
7333 TmpUshort |= BIT_0;
7334 MP_WriteMcuAccessRegWord(sc, 0xD3C0, TmpUshort);
7335 break;
7336 }
7337 }
7338
7339 static void re_hw_phy_config(struct re_softc *sc)
7340 {
7341 u_int16_t Data, PhyRegValue, TmpUshort;
7342 u_int32_t Data_u32;
7343 u_int16_t dout_tapbin;
7344 int i;
7345 u_int32_t WaitCnt;
7346
7347 if (sc->re_type == MACFG_59 || sc->re_type == MACFG_60 ||
7348 sc->re_type == MACFG_62 || sc->re_type == MACFG_67 ||
7349 sc->re_type == MACFG_68 || sc->re_type == MACFG_69) {
7350 MP_WritePhyOcpRegWord(sc, 0x0C41, 0x13, 0x0000);
7351 MP_WritePhyOcpRegWord(sc, 0x0C41, 0x13, 0x0500);
7352 }
7353
7354 if (FALSE == re_phy_ram_code_check(sc)) {
7355 re_set_phy_ram_code_check_fail_flag(sc);
7356 return;
7357 }
7358
7359 MP_WritePhyUshort(sc, 0x1F, 0x0000);
7360
7361 if (sc->re_type == MACFG_3) {
7362 CSR_WRITE_1(sc, 0x82, CSR_READ_1(sc, 0x82)|BIT_0);
7363 MP_WritePhyUshort(sc, 0x1F, 0x0000);
7364 MP_WritePhyUshort(sc, 0x0b, 0x0000);
7365
7366 MP_WritePhyUshort(sc, 0x1f, 0x0001);
7367 MP_WritePhyUshort(sc, 0x06, 0x006e);
7368 MP_WritePhyUshort(sc, 0x08, 0x0708);
7369 MP_WritePhyUshort(sc, 0x15, 0x4000);
7370 MP_WritePhyUshort(sc, 0x18, 0x65c7);
7371
7372 MP_WritePhyUshort(sc, 0x1f, 0x0001);
7373 MP_WritePhyUshort(sc, 0x03, 0x00a1);
7374 MP_WritePhyUshort(sc, 0x02, 0x0008);
7375 MP_WritePhyUshort(sc, 0x01, 0x0120);
7376 MP_WritePhyUshort(sc, 0x00, 0x1000);
7377 MP_WritePhyUshort(sc, 0x04, 0x0800);
7378 MP_WritePhyUshort(sc, 0x04, 0x0000);
7379
7380 MP_WritePhyUshort(sc, 0x03, 0xff41);
7381 MP_WritePhyUshort(sc, 0x02, 0xdf60);
7382 MP_WritePhyUshort(sc, 0x01, 0x0140);
7383 MP_WritePhyUshort(sc, 0x00, 0x0077);
7384 MP_WritePhyUshort(sc, 0x04, 0x7800);
7385 MP_WritePhyUshort(sc, 0x04, 0x7000);
7386
7387 MP_WritePhyUshort(sc, 0x03, 0x802f);
7388 MP_WritePhyUshort(sc, 0x02, 0x4f02);
7389 MP_WritePhyUshort(sc, 0x01, 0x0409);
7390 MP_WritePhyUshort(sc, 0x00, 0xf0f9);
7391 MP_WritePhyUshort(sc, 0x04, 0x9800);
7392 MP_WritePhyUshort(sc, 0x04, 0x9000);
7393
7394 MP_WritePhyUshort(sc, 0x03, 0xdf01);
7395 MP_WritePhyUshort(sc, 0x02, 0xdf20);
7396 MP_WritePhyUshort(sc, 0x01, 0xff95);
7397 MP_WritePhyUshort(sc, 0x00, 0xba00);
7398 MP_WritePhyUshort(sc, 0x04, 0xa800);
7399 MP_WritePhyUshort(sc, 0x04, 0xa000);
7400
7401 MP_WritePhyUshort(sc, 0x03, 0xff41);
7402 MP_WritePhyUshort(sc, 0x02, 0xdf20);
7403 MP_WritePhyUshort(sc, 0x01, 0x0140);
7404 MP_WritePhyUshort(sc, 0x00, 0x00bb);
7405 MP_WritePhyUshort(sc, 0x04, 0xb800);
7406 MP_WritePhyUshort(sc, 0x04, 0xb000);
7407
7408 MP_WritePhyUshort(sc, 0x03, 0xdf41);
7409 MP_WritePhyUshort(sc, 0x02, 0xdc60);
7410 MP_WritePhyUshort(sc, 0x01, 0x6340);
7411 MP_WritePhyUshort(sc, 0x00, 0x007d);
7412 MP_WritePhyUshort(sc, 0x04, 0xd800);
7413 MP_WritePhyUshort(sc, 0x04, 0xd000);
7414
7415 MP_WritePhyUshort(sc, 0x03, 0xdf01);
7416 MP_WritePhyUshort(sc, 0x02, 0xdf20);
7417 MP_WritePhyUshort(sc, 0x01, 0x100a);
7418 MP_WritePhyUshort(sc, 0x00, 0xa0ff);
7419 MP_WritePhyUshort(sc, 0x04, 0xf800);
7420 MP_WritePhyUshort(sc, 0x04, 0xf000);
7421
7422 MP_WritePhyUshort(sc, 0x1f, 0x0000);
7423 MP_WritePhyUshort(sc, 0x0b, 0x0000);
7424 MP_WritePhyUshort(sc, 0x00, 0x9200);
7425
7426 CSR_WRITE_1(sc, 0x82, 0x0d);
7427 } else if (sc->re_type == MACFG_4) {
7428 MP_WritePhyUshort(sc, 0x1f, 0x0002);
7429 MP_WritePhyUshort(sc, 0x01, 0x90D0);
7430 MP_WritePhyUshort(sc, 0x1f, 0x0000);
7431 // MP_WritePhyUshort(sc, 0x1e, 0x8c00); /* PHY link down with some Giga switch */
7432 } else if (sc->re_type == MACFG_5) {
7433 MP_WritePhyUshort(sc, 0x1f, 0x0001);
7434 MP_WritePhyUshort(sc, 0x04, 0x0000);
7435 MP_WritePhyUshort(sc, 0x03, 0x00a1);
7436 MP_WritePhyUshort(sc, 0x02, 0x0008);
7437 MP_WritePhyUshort(sc, 0x01, 0x0120);
7438 MP_WritePhyUshort(sc, 0x00, 0x1000);
7439 MP_WritePhyUshort(sc, 0x04, 0x0800);
7440
7441 MP_WritePhyUshort(sc, 0x04, 0x9000);
7442 MP_WritePhyUshort(sc, 0x03, 0x802f);
7443 MP_WritePhyUshort(sc, 0x02, 0x4f02);
7444 MP_WritePhyUshort(sc, 0x01, 0x0409);
7445 MP_WritePhyUshort(sc, 0x00, 0xf099);
7446 MP_WritePhyUshort(sc, 0x04, 0x9800);
7447
7448 MP_WritePhyUshort(sc, 0x04, 0xa000);
7449 MP_WritePhyUshort(sc, 0x03, 0xdf01);
7450 MP_WritePhyUshort(sc, 0x02, 0xdf20);
7451 MP_WritePhyUshort(sc, 0x01, 0xff95);
7452 MP_WritePhyUshort(sc, 0x00, 0xba00);
7453 MP_WritePhyUshort(sc, 0x04, 0xa800);
7454
7455 MP_WritePhyUshort(sc, 0x04, 0xf000);
7456 MP_WritePhyUshort(sc, 0x03, 0xdf01);
7457 MP_WritePhyUshort(sc, 0x02, 0xdf20);
7458 MP_WritePhyUshort(sc, 0x01, 0x101a);
7459 MP_WritePhyUshort(sc, 0x00, 0xa0ff);
7460 MP_WritePhyUshort(sc, 0x04, 0xf800);
7461 MP_WritePhyUshort(sc, 0x04, 0x0000);
7462 MP_WritePhyUshort(sc, 0x1f, 0x0000);
7463
7464 MP_WritePhyUshort(sc, 0x1f, 0x0001);
7465 MP_WritePhyUshort(sc, 0x10, 0xf41b);
7466 MP_WritePhyUshort(sc, 0x14, 0xfb54);
7467 MP_WritePhyUshort(sc, 0x18, 0xf5c7);
7468 MP_WritePhyUshort(sc, 0x1f, 0x0000);
7469
7470 MP_WritePhyUshort(sc, 0x1f, 0x0001);
7471 MP_WritePhyUshort(sc, 0x17, 0x0CC0);
7472 MP_WritePhyUshort(sc, 0x1f, 0x0000);
7473
7474 MP_WritePhyUshort(sc, 0x1f, 0x0001);
7475 MP_WritePhyUshort(sc, 0x10, 0xf01b);
7476
7477 } else if (sc->re_type == MACFG_6) {
7478 MP_WritePhyUshort(sc, 0x1f, 0x0001);
7479 MP_WritePhyUshort(sc, 0x04, 0x0000);
7480 MP_WritePhyUshort(sc, 0x03, 0x00a1);
7481 MP_WritePhyUshort(sc, 0x02, 0x0008);
7482 MP_WritePhyUshort(sc, 0x01, 0x0120);
7483 MP_WritePhyUshort(sc, 0x00, 0x1000);
7484 MP_WritePhyUshort(sc, 0x04, 0x0800);
7485
7486 MP_WritePhyUshort(sc, 0x04, 0x9000);
7487 MP_WritePhyUshort(sc, 0x03, 0x802f);
7488 MP_WritePhyUshort(sc, 0x02, 0x4f02);
7489 MP_WritePhyUshort(sc, 0x01, 0x0409);
7490 MP_WritePhyUshort(sc, 0x00, 0xf099);
7491 MP_WritePhyUshort(sc, 0x04, 0x9800);
7492
7493 MP_WritePhyUshort(sc, 0x04, 0xa000);
7494 MP_WritePhyUshort(sc, 0x03, 0xdf01);
7495 MP_WritePhyUshort(sc, 0x02, 0xdf20);
7496 MP_WritePhyUshort(sc, 0x01, 0xff95);
7497 MP_WritePhyUshort(sc, 0x00, 0xba00);
7498 MP_WritePhyUshort(sc, 0x04, 0xa800);
7499
7500 MP_WritePhyUshort(sc, 0x04, 0xf000);
7501 MP_WritePhyUshort(sc, 0x03, 0xdf01);
7502 MP_WritePhyUshort(sc, 0x02, 0xdf20);
7503 MP_WritePhyUshort(sc, 0x01, 0x101a);
7504 MP_WritePhyUshort(sc, 0x00, 0xa0ff);
7505 MP_WritePhyUshort(sc, 0x04, 0xf800);
7506 MP_WritePhyUshort(sc, 0x04, 0x0000);
7507 MP_WritePhyUshort(sc, 0x1f, 0x0000);
7508
7509 MP_WritePhyUshort(sc, 0x1f, 0x0001);
7510 MP_WritePhyUshort(sc, 0x0b, 0x8480);
7511 MP_WritePhyUshort(sc, 0x1f, 0x0000);
7512
7513 MP_WritePhyUshort(sc, 0x1f, 0x0001);
7514 MP_WritePhyUshort(sc, 0x18, 0x67c7);
7515 MP_WritePhyUshort(sc, 0x04, 0x2000);
7516 MP_WritePhyUshort(sc, 0x03, 0x002f);
7517 MP_WritePhyUshort(sc, 0x02, 0x4360);
7518 MP_WritePhyUshort(sc, 0x01, 0x0109);
7519 MP_WritePhyUshort(sc, 0x00, 0x3022);
7520 MP_WritePhyUshort(sc, 0x04, 0x2800);
7521 MP_WritePhyUshort(sc, 0x1f, 0x0000);
7522
7523 MP_WritePhyUshort(sc, 0x1f, 0x0001);
7524 MP_WritePhyUshort(sc, 0x17, 0x0CC0);
7525 } else if (sc->re_type == MACFG_14) {
7526 MP_WritePhyUshort(sc, 0x1f, 0x0000);
7527 MP_WritePhyUshort(sc, 0x11, MP_ReadPhyUshort(sc, 0x11) | 0x1000);
7528 MP_WritePhyUshort(sc, 0x19, MP_ReadPhyUshort(sc, 0x19) | 0x2000);
7529 MP_WritePhyUshort(sc, 0x10, MP_ReadPhyUshort(sc, 0x10) | 0x8000);
7530
7531 MP_WritePhyUshort(sc, 0x1f, 0x0003);
7532 MP_WritePhyUshort(sc, 0x08, 0x441D);
7533 MP_WritePhyUshort(sc, 0x01, 0x9100);
7534 } else if (sc->re_type == MACFG_15) {
7535 MP_WritePhyUshort(sc, 0x1f, 0x0000);
7536 MP_WritePhyUshort(sc, 0x11, MP_ReadPhyUshort(sc, 0x11) | 0x1000);
7537 MP_WritePhyUshort(sc, 0x19, MP_ReadPhyUshort(sc, 0x19) | 0x2000);
7538 MP_WritePhyUshort(sc, 0x10, MP_ReadPhyUshort(sc, 0x10) | 0x8000);
7539
7540 MP_WritePhyUshort(sc, 0x1f, 0x0003);
7541 MP_WritePhyUshort(sc, 0x08, 0x441D);
7542 MP_WritePhyUshort(sc, 0x01, 0x9100);
7543 } else if (sc->re_type == MACFG_17) {
7544 MP_WritePhyUshort(sc, 0x1f, 0x0000);
7545 MP_WritePhyUshort(sc, 0x11, MP_ReadPhyUshort(sc, 0x11) | 0x1000);
7546 MP_WritePhyUshort(sc, 0x19, MP_ReadPhyUshort(sc, 0x19) | 0x2000);
7547 MP_WritePhyUshort(sc, 0x10, MP_ReadPhyUshort(sc, 0x10) | 0x8000);
7548
7549 MP_WritePhyUshort(sc, 0x1f, 0x0003);
7550 MP_WritePhyUshort(sc, 0x08, 0x441D);
7551
7552 MP_WritePhyUshort(sc, 0x1f, 0x0000);
7553 } else if (sc->re_type == MACFG_21) {
7554 MP_WritePhyUshort(sc, 0x1F, 0x0001);
7555 MP_WritePhyUshort(sc, 0x0B, 0x94B0);
7556
7557 MP_WritePhyUshort(sc, 0x1F, 0x0003);
7558 MP_WritePhyUshort(sc, 0x12, 0x6096);
7559 MP_WritePhyUshort(sc, 0x1F, 0x0000);
7560 } else if (sc->re_type == MACFG_22) {
7561 MP_WritePhyUshort(sc, 0x1F, 0x0001);
7562 MP_WritePhyUshort(sc, 0x0B, 0x94B0);
7563
7564 MP_WritePhyUshort(sc, 0x1F, 0x0003);
7565 MP_WritePhyUshort(sc, 0x12, 0x6096);
7566 } else if (sc->re_type == MACFG_23) {
7567 MP_WritePhyUshort(sc, 0x1F, 0x0001);
7568 MP_WritePhyUshort(sc, 0x0B, 0x94B0);
7569
7570 MP_WritePhyUshort(sc, 0x1F, 0x0003);
7571 MP_WritePhyUshort(sc, 0x12, 0x6096);
7572 } else if (sc->re_type == MACFG_24) {
7573 MP_WritePhyUshort(sc, 0x1F, 0x0001);
7574 MP_WritePhyUshort(sc, 0x12, 0x2300);
7575 MP_WritePhyUshort(sc, 0x1F, 0x0000);
7576 MP_WritePhyUshort(sc, 0x1F, 0x0003);
7577 MP_WritePhyUshort(sc, 0x16, 0x000A);
7578 MP_WritePhyUshort(sc, 0x1F, 0x0000);
7579
7580 MP_WritePhyUshort(sc, 0x1F, 0x0003);
7581 MP_WritePhyUshort(sc, 0x12, 0xC096);
7582 MP_WritePhyUshort(sc, 0x1F, 0x0000);
7583
7584 MP_WritePhyUshort(sc, 0x1F, 0x0002);
7585 MP_WritePhyUshort(sc, 0x00, 0x88DE);
7586 MP_WritePhyUshort(sc, 0x01, 0x82B1);
7587 MP_WritePhyUshort(sc, 0x1F, 0x0000);
7588
7589 MP_WritePhyUshort(sc, 0x1F, 0x0002);
7590 MP_WritePhyUshort(sc, 0x08, 0x9E30);
7591 MP_WritePhyUshort(sc, 0x09, 0x01F0);
7592 MP_WritePhyUshort(sc, 0x1F, 0x0000);
7593
7594 MP_WritePhyUshort(sc, 0x1F, 0x0002);
7595 MP_WritePhyUshort(sc, 0x0A, 0x5500);
7596 MP_WritePhyUshort(sc, 0x1F, 0x0000);
7597
7598 MP_WritePhyUshort(sc, 0x1F, 0x0002);
7599 MP_WritePhyUshort(sc, 0x03, 0x7002);
7600 MP_WritePhyUshort(sc, 0x1F, 0x0000);
7601
7602 MP_WritePhyUshort(sc, 0x1F, 0x0000);
7603 MP_WritePhyUshort(sc, 0x14, MP_ReadPhyUshort(sc, 0x14) | BIT_5);
7604 MP_WritePhyUshort(sc, 0x0d, MP_ReadPhyUshort(sc, 0x0d) | BIT_5);
7605 } else if (sc->re_type == MACFG_25) {
7606 MP_WritePhyUshort(sc, 0x1F, 0x0001);
7607 MP_WritePhyUshort(sc, 0x12, 0x2300);
7608 MP_WritePhyUshort(sc, 0x1F, 0x0003);
7609 MP_WritePhyUshort(sc, 0x16, 0x0F0A);
7610 MP_WritePhyUshort(sc, 0x1F, 0x0000);
7611
7612 MP_WritePhyUshort(sc, 0x1F, 0x0002);
7613 MP_WritePhyUshort(sc, 0x00, 0x88DE);
7614 MP_WritePhyUshort(sc, 0x01, 0x82B1);
7615 MP_WritePhyUshort(sc, 0x1F, 0x0000);
7616
7617 MP_WritePhyUshort(sc, 0x1F, 0x0002);
7618 MP_WritePhyUshort(sc, 0x0C, 0x7EB8);
7619 MP_WritePhyUshort(sc, 0x1F, 0x0000);
7620
7621 MP_WritePhyUshort(sc, 0x1F, 0x0002);
7622 MP_WritePhyUshort(sc, 0x06, 0x0761);
7623 MP_WritePhyUshort(sc, 0x1F, 0x0000);
7624
7625 MP_WritePhyUshort(sc, 0x1F, 0x0001);
7626 MP_WritePhyUshort(sc, 0x03, 0x802F);
7627 MP_WritePhyUshort(sc, 0x02, 0x4F02);
7628 MP_WritePhyUshort(sc, 0x01, 0x0409);
7629 MP_WritePhyUshort(sc, 0x00, 0xF099);
7630 MP_WritePhyUshort(sc, 0x04, 0x9800);
7631 MP_WritePhyUshort(sc, 0x04, 0x9000);
7632 MP_WritePhyUshort(sc, 0x1F, 0x0000);
7633
7634 MP_WritePhyUshort(sc, 0x1F, 0x0000);
7635 MP_WritePhyUshort(sc, 0x16, MP_ReadPhyUshort(sc , 0x16) | BIT_0);
7636
7637 MP_WritePhyUshort(sc, 0x1F, 0x0000);
7638 MP_WritePhyUshort(sc, 0x14, MP_ReadPhyUshort(sc , 0x14) | BIT_5);
7639 MP_WritePhyUshort(sc, 0x0D, MP_ReadPhyUshort(sc , 0x0D) & ~BIT_5);
7640
7641 MP_WritePhyUshort(sc, 0x1F, 0x0001);
7642 MP_WritePhyUshort(sc, 0x1D, 0x3D98);
7643 MP_WritePhyUshort(sc, 0x1F, 0x0000);
7644
7645 MP_WritePhyUshort(sc, 0x1F, 0x0001);
7646 MP_WritePhyUshort(sc, 0x17, 0x0CC0);
7647 MP_WritePhyUshort(sc, 0x1F, 0x0000);
7648 } else if (sc->re_type == MACFG_26) {
7649 MP_WritePhyUshort(sc, 0x1F, 0x0001);
7650 MP_WritePhyUshort(sc, 0x12, 0x2300);
7651 MP_WritePhyUshort(sc, 0x1F, 0x0003);
7652 MP_WritePhyUshort(sc, 0x16, 0x0F0A);
7653 MP_WritePhyUshort(sc, 0x1F, 0x0000);
7654
7655 MP_WritePhyUshort(sc, 0x1F, 0x0002);
7656 MP_WritePhyUshort(sc, 0x00, 0x88DE);
7657 MP_WritePhyUshort(sc, 0x01, 0x82B1);
7658 MP_WritePhyUshort(sc, 0x1F, 0x0000);
7659
7660 MP_WritePhyUshort(sc, 0x1F, 0x0002);
7661 MP_WritePhyUshort(sc, 0x0C, 0x7EB8);
7662 MP_WritePhyUshort(sc, 0x1F, 0x0000);
7663
7664 MP_WritePhyUshort(sc, 0x1F, 0x0002);
7665 MP_WritePhyUshort(sc, 0x06, 0x5461);
7666 MP_WritePhyUshort(sc, 0x1F, 0x0000);
7667
7668 MP_WritePhyUshort(sc, 0x1F, 0x0002);
7669 MP_WritePhyUshort(sc, 0x06, 0x5461);
7670 MP_WritePhyUshort(sc, 0x1F, 0x0000);
7671
7672 MP_WritePhyUshort(sc, 0x1F, 0x0000);
7673 MP_WritePhyUshort(sc, 0x16, MP_ReadPhyUshort(sc, 0x16) | BIT_0);
7674
7675 MP_WritePhyUshort(sc, 0x1F, 0x0000);
7676 MP_WritePhyUshort(sc, 0x14, MP_ReadPhyUshort(sc, 0x14) | BIT_5);
7677 MP_WritePhyUshort(sc, 0x0D, MP_ReadPhyUshort(sc, 0x0D) & ~BIT_5);
7678
7679 MP_WritePhyUshort(sc, 0x1F, 0x0001);
7680 MP_WritePhyUshort(sc, 0x1D, 0x3D98);
7681 MP_WritePhyUshort(sc, 0x1F, 0x0000);
7682
7683 MP_WritePhyUshort(sc, 0x1f, 0x0001);
7684 MP_WritePhyUshort(sc, 0x17, 0x0CC0);
7685 MP_WritePhyUshort(sc, 0x1F, 0x0000);
7686 } else if (sc->re_type == MACFG_27) {
7687 MP_WritePhyUshort(sc, 0x1F, 0x0000);
7688 MP_WritePhyUshort(sc, 0x0d, MP_ReadPhyUshort(sc, 0x0d) | BIT_5);
7689 MP_WritePhyUshort(sc, 0x1F, 0x0000);
7690
7691 MP_WritePhyUshort(sc, 0x1F, 0x0001);
7692 MP_WritePhyUshort(sc, 0x1D, 0x3D98);
7693 MP_WritePhyUshort(sc, 0x1F, 0x0000);
7694
7695 MP_WritePhyUshort(sc, 0x1F, 0x0001);
7696 MP_WritePhyUshort(sc, 0x14, 0xCAA3);
7697 MP_WritePhyUshort(sc, 0x1C, 0x000A);
7698 MP_WritePhyUshort(sc, 0x18, 0x65D0);
7699
7700 MP_WritePhyUshort(sc, 0x1F, 0x0003);
7701 MP_WritePhyUshort(sc, 0x17, 0xB580);
7702 MP_WritePhyUshort(sc, 0x18, 0xFF54);
7703 MP_WritePhyUshort(sc, 0x19, 0x3954);
7704
7705 MP_WritePhyUshort(sc, 0x1F, 0x0002);
7706 MP_WritePhyUshort(sc, 0x0D, 0x310C);
7707 MP_WritePhyUshort(sc, 0x0E, 0x310C);
7708 MP_WritePhyUshort(sc, 0x0F, 0x311C);
7709 MP_WritePhyUshort(sc, 0x06, 0x0761);
7710
7711 MP_WritePhyUshort(sc, 0x1F, 0x0003);
7712 MP_WritePhyUshort(sc, 0x18, 0xFF55);
7713 MP_WritePhyUshort(sc, 0x19, 0x3955);
7714 MP_WritePhyUshort(sc, 0x18, 0xFF54);
7715 MP_WritePhyUshort(sc, 0x19, 0x3954);
7716
7717 MP_WritePhyUshort(sc, 0x1f, 0x0001);
7718 MP_WritePhyUshort(sc, 0x17, 0x0CC0);
7719 } else if (sc->re_type == MACFG_28) {
7720 MP_WritePhyUshort(sc, 0x1F, 0x0000);
7721 MP_WritePhyUshort(sc, 0x14, MP_ReadPhyUshort(sc, 0x14) | BIT_5);
7722 MP_WritePhyUshort(sc, 0x0d, MP_ReadPhyUshort(sc, 0x0d) | BIT_5);
7723
7724 MP_WritePhyUshort(sc, 0x1F, 0x0001);
7725 MP_WritePhyUshort(sc, 0x14, 0xCAA3);
7726 MP_WritePhyUshort(sc, 0x1C, 0x000A);
7727 MP_WritePhyUshort(sc, 0x18, 0x65D0);
7728
7729 MP_WritePhyUshort(sc, 0x1F, 0x0003);
7730 MP_WritePhyUshort(sc, 0x17, 0xB580);
7731 MP_WritePhyUshort(sc, 0x18, 0xFF54);
7732 MP_WritePhyUshort(sc, 0x19, 0x3954);
7733
7734 MP_WritePhyUshort(sc, 0x1F, 0x0002);
7735 MP_WritePhyUshort(sc, 0x0D, 0x310C);
7736 MP_WritePhyUshort(sc, 0x0E, 0x310C);
7737 MP_WritePhyUshort(sc, 0x0F, 0x311C);
7738 MP_WritePhyUshort(sc, 0x06, 0x0761);
7739
7740 MP_WritePhyUshort(sc, 0x1F, 0x0003);
7741 MP_WritePhyUshort(sc, 0x18, 0xFF55);
7742 MP_WritePhyUshort(sc, 0x19, 0x3955);
7743 MP_WritePhyUshort(sc, 0x18, 0xFF54);
7744 MP_WritePhyUshort(sc, 0x19, 0x3954);
7745
7746 MP_WritePhyUshort(sc, 0x1f, 0x0001);
7747 MP_WritePhyUshort(sc, 0x17, 0x0CC0);
7748
7749 MP_WritePhyUshort(sc, 0x1F, 0x0000);
7750 MP_WritePhyUshort(sc, 0x16, MP_ReadPhyUshort(sc, 0x16) | BIT_0);
7751 MP_WritePhyUshort(sc, 0x1F, 0x0000);
7752 } else if (sc->re_type == MACFG_31) {
7753 MP_WritePhyUshort(sc, 0x1F, 0x0001);
7754 MP_WritePhyUshort(sc, 0x06, 0x4064);
7755 MP_WritePhyUshort(sc, 0x07, 0x2863);
7756 MP_WritePhyUshort(sc, 0x08, 0x059C);
7757 MP_WritePhyUshort(sc, 0x09, 0x26B4);
7758 MP_WritePhyUshort(sc, 0x0A, 0x6A19);
7759 MP_WritePhyUshort(sc, 0x0B, 0xDCC8);
7760 MP_WritePhyUshort(sc, 0x10, 0xF06D);
7761 MP_WritePhyUshort(sc, 0x14, 0x7F68);
7762 MP_WritePhyUshort(sc, 0x18, 0x7FD9);
7763 MP_WritePhyUshort(sc, 0x1C, 0xF0FF);
7764 MP_WritePhyUshort(sc, 0x1D, 0x3D9C);
7765 MP_WritePhyUshort(sc, 0x1F, 0x0003);
7766 MP_WritePhyUshort(sc, 0x12, 0xF49F);
7767 MP_WritePhyUshort(sc, 0x13, 0x070B);
7768 MP_WritePhyUshort(sc, 0x1A, 0x05AD);
7769 MP_WritePhyUshort(sc, 0x14, 0x94C0);
7770
7771 MP_WritePhyUshort(sc, 0x1F, 0x0002);
7772 Data = MP_ReadPhyUshort(sc, 0x0B) & 0xFF00;
7773 Data |= 0x10;
7774 MP_WritePhyUshort(sc, 0x0B, Data);
7775 Data = MP_ReadPhyUshort(sc, 0x0C) & 0x00FF;
7776 Data |= 0xA200;
7777 MP_WritePhyUshort(sc, 0x0C, Data);
7778
7779 MP_WritePhyUshort(sc, 0x1F, 0x0002);
7780 MP_WritePhyUshort(sc, 0x06, 0x5561);
7781 MP_WritePhyUshort(sc, 0x1F, 0x0005);
7782 MP_WritePhyUshort(sc, 0x05, 0x8332);
7783 MP_WritePhyUshort(sc, 0x06, 0x5561);
7784
7785 if (MP_ReadEfuse(sc, 0x01) == 0xb1) {
7786 MP_WritePhyUshort(sc, 0x1F, 0x0002);
7787 MP_WritePhyUshort(sc, 0x05, 0x669A);
7788 MP_WritePhyUshort(sc, 0x1F, 0x0005);
7789 MP_WritePhyUshort(sc, 0x05, 0x8330);
7790 MP_WritePhyUshort(sc, 0x06, 0x669A);
7791
7792 MP_WritePhyUshort(sc, 0x1F, 0x0002);
7793 Data = MP_ReadPhyUshort(sc, 0x0D);
7794 if ((Data & 0x00FF) != 0x006C) {
7795 Data &= 0xFF00;
7796 MP_WritePhyUshort(sc, 0x1F, 0x0002);
7797 MP_WritePhyUshort(sc, 0x0D, Data | 0x0065);
7798 MP_WritePhyUshort(sc, 0x0D, Data | 0x0066);
7799 MP_WritePhyUshort(sc, 0x0D, Data | 0x0067);
7800 MP_WritePhyUshort(sc, 0x0D, Data | 0x0068);
7801 MP_WritePhyUshort(sc, 0x0D, Data | 0x0069);
7802 MP_WritePhyUshort(sc, 0x0D, Data | 0x006A);
7803 MP_WritePhyUshort(sc, 0x0D, Data | 0x006B);
7804 MP_WritePhyUshort(sc, 0x0D, Data | 0x006C);
7805 }
7806 } else {
7807 MP_WritePhyUshort(sc, 0x1F, 0x0002);
7808 MP_WritePhyUshort(sc, 0x05, 0x6662);
7809 MP_WritePhyUshort(sc, 0x1F, 0x0005);
7810 MP_WritePhyUshort(sc, 0x05, 0x8330);
7811 MP_WritePhyUshort(sc, 0x06, 0x6662);
7812 }
7813
7814 MP_WritePhyUshort(sc, 0x1F, 0x0002);
7815 Data = MP_ReadPhyUshort(sc, 0x0D);
7816 Data |= 0x300;
7817 MP_WritePhyUshort(sc, 0x0D, Data);
7818 Data = MP_ReadPhyUshort(sc, 0x0F);
7819 Data |= 0x10;
7820 MP_WritePhyUshort(sc, 0x0F, Data);
7821
7822 MP_WritePhyUshort(sc, 0x1F, 0x0002);
7823 Data = MP_ReadPhyUshort(sc, 0x02);
7824 Data &= ~0x600;
7825 Data |= 0x100;
7826 MP_WritePhyUshort(sc, 0x02, Data);
7827 Data = MP_ReadPhyUshort(sc, 0x03);
7828 Data &= ~0xE000;
7829 MP_WritePhyUshort(sc, 0x03, Data);
7830
7831 MP_WritePhyUshort(sc, 0x1F, 0x0001);
7832 MP_WritePhyUshort(sc, 0x17, 0x0CC0);
7833
7834 MP_WritePhyUshort(sc, 0x1F, 0x0005);
7835 MP_WritePhyUshort(sc, 0x05, 0x001B);
7836 if (MP_ReadPhyUshort(sc, 0x06) == 0xBF00) {
7837 MP_WritePhyUshort(sc, 0x1f, 0x0005);
7838 MP_WritePhyUshort(sc, 0x05, 0xfff6);
7839 MP_WritePhyUshort(sc, 0x06, 0x0080);
7840 MP_WritePhyUshort(sc, 0x05, 0x8000);
7841 MP_WritePhyUshort(sc, 0x06, 0xf8f9);
7842 MP_WritePhyUshort(sc, 0x06, 0xfaef);
7843 MP_WritePhyUshort(sc, 0x06, 0x59ee);
7844 MP_WritePhyUshort(sc, 0x06, 0xf8ea);
7845 MP_WritePhyUshort(sc, 0x06, 0x00ee);
7846 MP_WritePhyUshort(sc, 0x06, 0xf8eb);
7847 MP_WritePhyUshort(sc, 0x06, 0x00e0);
7848 MP_WritePhyUshort(sc, 0x06, 0xf87c);
7849 MP_WritePhyUshort(sc, 0x06, 0xe1f8);
7850 MP_WritePhyUshort(sc, 0x06, 0x7d59);
7851 MP_WritePhyUshort(sc, 0x06, 0x0fef);
7852 MP_WritePhyUshort(sc, 0x06, 0x0139);
7853 MP_WritePhyUshort(sc, 0x06, 0x029e);
7854 MP_WritePhyUshort(sc, 0x06, 0x06ef);
7855 MP_WritePhyUshort(sc, 0x06, 0x1039);
7856 MP_WritePhyUshort(sc, 0x06, 0x089f);
7857 MP_WritePhyUshort(sc, 0x06, 0x2aee);
7858 MP_WritePhyUshort(sc, 0x06, 0xf8ea);
7859 MP_WritePhyUshort(sc, 0x06, 0x00ee);
7860 MP_WritePhyUshort(sc, 0x06, 0xf8eb);
7861 MP_WritePhyUshort(sc, 0x06, 0x01e0);
7862 MP_WritePhyUshort(sc, 0x06, 0xf87c);
7863 MP_WritePhyUshort(sc, 0x06, 0xe1f8);
7864 MP_WritePhyUshort(sc, 0x06, 0x7d58);
7865 MP_WritePhyUshort(sc, 0x06, 0x409e);
7866 MP_WritePhyUshort(sc, 0x06, 0x0f39);
7867 MP_WritePhyUshort(sc, 0x06, 0x46aa);
7868 MP_WritePhyUshort(sc, 0x06, 0x0bbf);
7869 MP_WritePhyUshort(sc, 0x06, 0x8290);
7870 MP_WritePhyUshort(sc, 0x06, 0xd682);
7871 MP_WritePhyUshort(sc, 0x06, 0x9802);
7872 MP_WritePhyUshort(sc, 0x06, 0x014f);
7873 MP_WritePhyUshort(sc, 0x06, 0xae09);
7874 MP_WritePhyUshort(sc, 0x06, 0xbf82);
7875 MP_WritePhyUshort(sc, 0x06, 0x98d6);
7876 MP_WritePhyUshort(sc, 0x06, 0x82a0);
7877 MP_WritePhyUshort(sc, 0x06, 0x0201);
7878 MP_WritePhyUshort(sc, 0x06, 0x4fef);
7879 MP_WritePhyUshort(sc, 0x06, 0x95fe);
7880 MP_WritePhyUshort(sc, 0x06, 0xfdfc);
7881 MP_WritePhyUshort(sc, 0x06, 0x05f8);
7882 MP_WritePhyUshort(sc, 0x06, 0xf9fa);
7883 MP_WritePhyUshort(sc, 0x06, 0xeef8);
7884 MP_WritePhyUshort(sc, 0x06, 0xea00);
7885 MP_WritePhyUshort(sc, 0x06, 0xeef8);
7886 MP_WritePhyUshort(sc, 0x06, 0xeb00);
7887 MP_WritePhyUshort(sc, 0x06, 0xe2f8);
7888 MP_WritePhyUshort(sc, 0x06, 0x7ce3);
7889 MP_WritePhyUshort(sc, 0x06, 0xf87d);
7890 MP_WritePhyUshort(sc, 0x06, 0xa511);
7891 MP_WritePhyUshort(sc, 0x06, 0x1112);
7892 MP_WritePhyUshort(sc, 0x06, 0xd240);
7893 MP_WritePhyUshort(sc, 0x06, 0xd644);
7894 MP_WritePhyUshort(sc, 0x06, 0x4402);
7895 MP_WritePhyUshort(sc, 0x06, 0x8217);
7896 MP_WritePhyUshort(sc, 0x06, 0xd2a0);
7897 MP_WritePhyUshort(sc, 0x06, 0xd6aa);
7898 MP_WritePhyUshort(sc, 0x06, 0xaa02);
7899 MP_WritePhyUshort(sc, 0x06, 0x8217);
7900 MP_WritePhyUshort(sc, 0x06, 0xae0f);
7901 MP_WritePhyUshort(sc, 0x06, 0xa544);
7902 MP_WritePhyUshort(sc, 0x06, 0x4402);
7903 MP_WritePhyUshort(sc, 0x06, 0xae4d);
7904 MP_WritePhyUshort(sc, 0x06, 0xa5aa);
7905 MP_WritePhyUshort(sc, 0x06, 0xaa02);
7906 MP_WritePhyUshort(sc, 0x06, 0xae47);
7907 MP_WritePhyUshort(sc, 0x06, 0xaf82);
7908 MP_WritePhyUshort(sc, 0x06, 0x13ee);
7909 MP_WritePhyUshort(sc, 0x06, 0x834e);
7910 MP_WritePhyUshort(sc, 0x06, 0x00ee);
7911 MP_WritePhyUshort(sc, 0x06, 0x834d);
7912 MP_WritePhyUshort(sc, 0x06, 0x0fee);
7913 MP_WritePhyUshort(sc, 0x06, 0x834c);
7914 MP_WritePhyUshort(sc, 0x06, 0x0fee);
7915 MP_WritePhyUshort(sc, 0x06, 0x834f);
7916 MP_WritePhyUshort(sc, 0x06, 0x00ee);
7917 MP_WritePhyUshort(sc, 0x06, 0x8351);
7918 MP_WritePhyUshort(sc, 0x06, 0x00ee);
7919 MP_WritePhyUshort(sc, 0x06, 0x834a);
7920 MP_WritePhyUshort(sc, 0x06, 0xffee);
7921 MP_WritePhyUshort(sc, 0x06, 0x834b);
7922 MP_WritePhyUshort(sc, 0x06, 0xffe0);
7923 MP_WritePhyUshort(sc, 0x06, 0x8330);
7924 MP_WritePhyUshort(sc, 0x06, 0xe183);
7925 MP_WritePhyUshort(sc, 0x06, 0x3158);
7926 MP_WritePhyUshort(sc, 0x06, 0xfee4);
7927 MP_WritePhyUshort(sc, 0x06, 0xf88a);
7928 MP_WritePhyUshort(sc, 0x06, 0xe5f8);
7929 MP_WritePhyUshort(sc, 0x06, 0x8be0);
7930 MP_WritePhyUshort(sc, 0x06, 0x8332);
7931 MP_WritePhyUshort(sc, 0x06, 0xe183);
7932 MP_WritePhyUshort(sc, 0x06, 0x3359);
7933 MP_WritePhyUshort(sc, 0x06, 0x0fe2);
7934 MP_WritePhyUshort(sc, 0x06, 0x834d);
7935 MP_WritePhyUshort(sc, 0x06, 0x0c24);
7936 MP_WritePhyUshort(sc, 0x06, 0x5af0);
7937 MP_WritePhyUshort(sc, 0x06, 0x1e12);
7938 MP_WritePhyUshort(sc, 0x06, 0xe4f8);
7939 MP_WritePhyUshort(sc, 0x06, 0x8ce5);
7940 MP_WritePhyUshort(sc, 0x06, 0xf88d);
7941 MP_WritePhyUshort(sc, 0x06, 0xaf82);
7942 MP_WritePhyUshort(sc, 0x06, 0x13e0);
7943 MP_WritePhyUshort(sc, 0x06, 0x834f);
7944 MP_WritePhyUshort(sc, 0x06, 0x10e4);
7945 MP_WritePhyUshort(sc, 0x06, 0x834f);
7946 MP_WritePhyUshort(sc, 0x06, 0xe083);
7947 MP_WritePhyUshort(sc, 0x06, 0x4e78);
7948 MP_WritePhyUshort(sc, 0x06, 0x009f);
7949 MP_WritePhyUshort(sc, 0x06, 0x0ae0);
7950 MP_WritePhyUshort(sc, 0x06, 0x834f);
7951 MP_WritePhyUshort(sc, 0x06, 0xa010);
7952 MP_WritePhyUshort(sc, 0x06, 0xa5ee);
7953 MP_WritePhyUshort(sc, 0x06, 0x834e);
7954 MP_WritePhyUshort(sc, 0x06, 0x01e0);
7955 MP_WritePhyUshort(sc, 0x06, 0x834e);
7956 MP_WritePhyUshort(sc, 0x06, 0x7805);
7957 MP_WritePhyUshort(sc, 0x06, 0x9e9a);
7958 MP_WritePhyUshort(sc, 0x06, 0xe083);
7959 MP_WritePhyUshort(sc, 0x06, 0x4e78);
7960 MP_WritePhyUshort(sc, 0x06, 0x049e);
7961 MP_WritePhyUshort(sc, 0x06, 0x10e0);
7962 MP_WritePhyUshort(sc, 0x06, 0x834e);
7963 MP_WritePhyUshort(sc, 0x06, 0x7803);
7964 MP_WritePhyUshort(sc, 0x06, 0x9e0f);
7965 MP_WritePhyUshort(sc, 0x06, 0xe083);
7966 MP_WritePhyUshort(sc, 0x06, 0x4e78);
7967 MP_WritePhyUshort(sc, 0x06, 0x019e);
7968 MP_WritePhyUshort(sc, 0x06, 0x05ae);
7969 MP_WritePhyUshort(sc, 0x06, 0x0caf);
7970 MP_WritePhyUshort(sc, 0x06, 0x81f8);
7971 MP_WritePhyUshort(sc, 0x06, 0xaf81);
7972 MP_WritePhyUshort(sc, 0x06, 0xa3af);
7973 MP_WritePhyUshort(sc, 0x06, 0x81dc);
7974 MP_WritePhyUshort(sc, 0x06, 0xaf82);
7975 MP_WritePhyUshort(sc, 0x06, 0x13ee);
7976 MP_WritePhyUshort(sc, 0x06, 0x8348);
7977 MP_WritePhyUshort(sc, 0x06, 0x00ee);
7978 MP_WritePhyUshort(sc, 0x06, 0x8349);
7979 MP_WritePhyUshort(sc, 0x06, 0x00e0);
7980 MP_WritePhyUshort(sc, 0x06, 0x8351);
7981 MP_WritePhyUshort(sc, 0x06, 0x10e4);
7982 MP_WritePhyUshort(sc, 0x06, 0x8351);
7983 MP_WritePhyUshort(sc, 0x06, 0x5801);
7984 MP_WritePhyUshort(sc, 0x06, 0x9fea);
7985 MP_WritePhyUshort(sc, 0x06, 0xd000);
7986 MP_WritePhyUshort(sc, 0x06, 0xd180);
7987 MP_WritePhyUshort(sc, 0x06, 0x1f66);
7988 MP_WritePhyUshort(sc, 0x06, 0xe2f8);
7989 MP_WritePhyUshort(sc, 0x06, 0xeae3);
7990 MP_WritePhyUshort(sc, 0x06, 0xf8eb);
7991 MP_WritePhyUshort(sc, 0x06, 0x5af8);
7992 MP_WritePhyUshort(sc, 0x06, 0x1e20);
7993 MP_WritePhyUshort(sc, 0x06, 0xe6f8);
7994 MP_WritePhyUshort(sc, 0x06, 0xeae5);
7995 MP_WritePhyUshort(sc, 0x06, 0xf8eb);
7996 MP_WritePhyUshort(sc, 0x06, 0xd302);
7997 MP_WritePhyUshort(sc, 0x06, 0xb3fe);
7998 MP_WritePhyUshort(sc, 0x06, 0xe2f8);
7999 MP_WritePhyUshort(sc, 0x06, 0x7cef);
8000 MP_WritePhyUshort(sc, 0x06, 0x325b);
8001 MP_WritePhyUshort(sc, 0x06, 0x80e3);
8002 MP_WritePhyUshort(sc, 0x06, 0xf87d);
8003 MP_WritePhyUshort(sc, 0x06, 0x9e03);
8004 MP_WritePhyUshort(sc, 0x06, 0x7dff);
8005 MP_WritePhyUshort(sc, 0x06, 0xff0d);
8006 MP_WritePhyUshort(sc, 0x06, 0x581c);
8007 MP_WritePhyUshort(sc, 0x06, 0x551a);
8008 MP_WritePhyUshort(sc, 0x06, 0x6511);
8009 MP_WritePhyUshort(sc, 0x06, 0xa190);
8010 MP_WritePhyUshort(sc, 0x06, 0xd3e2);
8011 MP_WritePhyUshort(sc, 0x06, 0x8348);
8012 MP_WritePhyUshort(sc, 0x06, 0xe383);
8013 MP_WritePhyUshort(sc, 0x06, 0x491b);
8014 MP_WritePhyUshort(sc, 0x06, 0x56ab);
8015 MP_WritePhyUshort(sc, 0x06, 0x08ef);
8016 MP_WritePhyUshort(sc, 0x06, 0x56e6);
8017 MP_WritePhyUshort(sc, 0x06, 0x8348);
8018 MP_WritePhyUshort(sc, 0x06, 0xe783);
8019 MP_WritePhyUshort(sc, 0x06, 0x4910);
8020 MP_WritePhyUshort(sc, 0x06, 0xd180);
8021 MP_WritePhyUshort(sc, 0x06, 0x1f66);
8022 MP_WritePhyUshort(sc, 0x06, 0xa004);
8023 MP_WritePhyUshort(sc, 0x06, 0xb9e2);
8024 MP_WritePhyUshort(sc, 0x06, 0x8348);
8025 MP_WritePhyUshort(sc, 0x06, 0xe383);
8026 MP_WritePhyUshort(sc, 0x06, 0x49ef);
8027 MP_WritePhyUshort(sc, 0x06, 0x65e2);
8028 MP_WritePhyUshort(sc, 0x06, 0x834a);
8029 MP_WritePhyUshort(sc, 0x06, 0xe383);
8030 MP_WritePhyUshort(sc, 0x06, 0x4b1b);
8031 MP_WritePhyUshort(sc, 0x06, 0x56aa);
8032 MP_WritePhyUshort(sc, 0x06, 0x0eef);
8033 MP_WritePhyUshort(sc, 0x06, 0x56e6);
8034 MP_WritePhyUshort(sc, 0x06, 0x834a);
8035 MP_WritePhyUshort(sc, 0x06, 0xe783);
8036 MP_WritePhyUshort(sc, 0x06, 0x4be2);
8037 MP_WritePhyUshort(sc, 0x06, 0x834d);
8038 MP_WritePhyUshort(sc, 0x06, 0xe683);
8039 MP_WritePhyUshort(sc, 0x06, 0x4ce0);
8040 MP_WritePhyUshort(sc, 0x06, 0x834d);
8041 MP_WritePhyUshort(sc, 0x06, 0xa000);
8042 MP_WritePhyUshort(sc, 0x06, 0x0caf);
8043 MP_WritePhyUshort(sc, 0x06, 0x81dc);
8044 MP_WritePhyUshort(sc, 0x06, 0xe083);
8045 MP_WritePhyUshort(sc, 0x06, 0x4d10);
8046 MP_WritePhyUshort(sc, 0x06, 0xe483);
8047 MP_WritePhyUshort(sc, 0x06, 0x4dae);
8048 MP_WritePhyUshort(sc, 0x06, 0x0480);
8049 MP_WritePhyUshort(sc, 0x06, 0xe483);
8050 MP_WritePhyUshort(sc, 0x06, 0x4de0);
8051 MP_WritePhyUshort(sc, 0x06, 0x834e);
8052 MP_WritePhyUshort(sc, 0x06, 0x7803);
8053 MP_WritePhyUshort(sc, 0x06, 0x9e0b);
8054 MP_WritePhyUshort(sc, 0x06, 0xe083);
8055 MP_WritePhyUshort(sc, 0x06, 0x4e78);
8056 MP_WritePhyUshort(sc, 0x06, 0x049e);
8057 MP_WritePhyUshort(sc, 0x06, 0x04ee);
8058 MP_WritePhyUshort(sc, 0x06, 0x834e);
8059 MP_WritePhyUshort(sc, 0x06, 0x02e0);
8060 MP_WritePhyUshort(sc, 0x06, 0x8332);
8061 MP_WritePhyUshort(sc, 0x06, 0xe183);
8062 MP_WritePhyUshort(sc, 0x06, 0x3359);
8063 MP_WritePhyUshort(sc, 0x06, 0x0fe2);
8064 MP_WritePhyUshort(sc, 0x06, 0x834d);
8065 MP_WritePhyUshort(sc, 0x06, 0x0c24);
8066 MP_WritePhyUshort(sc, 0x06, 0x5af0);
8067 MP_WritePhyUshort(sc, 0x06, 0x1e12);
8068 MP_WritePhyUshort(sc, 0x06, 0xe4f8);
8069 MP_WritePhyUshort(sc, 0x06, 0x8ce5);
8070 MP_WritePhyUshort(sc, 0x06, 0xf88d);
8071 MP_WritePhyUshort(sc, 0x06, 0xe083);
8072 MP_WritePhyUshort(sc, 0x06, 0x30e1);
8073 MP_WritePhyUshort(sc, 0x06, 0x8331);
8074 MP_WritePhyUshort(sc, 0x06, 0x6801);
8075 MP_WritePhyUshort(sc, 0x06, 0xe4f8);
8076 MP_WritePhyUshort(sc, 0x06, 0x8ae5);
8077 MP_WritePhyUshort(sc, 0x06, 0xf88b);
8078 MP_WritePhyUshort(sc, 0x06, 0xae37);
8079 MP_WritePhyUshort(sc, 0x06, 0xee83);
8080 MP_WritePhyUshort(sc, 0x06, 0x4e03);
8081 MP_WritePhyUshort(sc, 0x06, 0xe083);
8082 MP_WritePhyUshort(sc, 0x06, 0x4ce1);
8083 MP_WritePhyUshort(sc, 0x06, 0x834d);
8084 MP_WritePhyUshort(sc, 0x06, 0x1b01);
8085 MP_WritePhyUshort(sc, 0x06, 0x9e04);
8086 MP_WritePhyUshort(sc, 0x06, 0xaaa1);
8087 MP_WritePhyUshort(sc, 0x06, 0xaea8);
8088 MP_WritePhyUshort(sc, 0x06, 0xee83);
8089 MP_WritePhyUshort(sc, 0x06, 0x4e04);
8090 MP_WritePhyUshort(sc, 0x06, 0xee83);
8091 MP_WritePhyUshort(sc, 0x06, 0x4f00);
8092 MP_WritePhyUshort(sc, 0x06, 0xaeab);
8093 MP_WritePhyUshort(sc, 0x06, 0xe083);
8094 MP_WritePhyUshort(sc, 0x06, 0x4f78);
8095 MP_WritePhyUshort(sc, 0x06, 0x039f);
8096 MP_WritePhyUshort(sc, 0x06, 0x14ee);
8097 MP_WritePhyUshort(sc, 0x06, 0x834e);
8098 MP_WritePhyUshort(sc, 0x06, 0x05d2);
8099 MP_WritePhyUshort(sc, 0x06, 0x40d6);
8100 MP_WritePhyUshort(sc, 0x06, 0x5554);
8101 MP_WritePhyUshort(sc, 0x06, 0x0282);
8102 MP_WritePhyUshort(sc, 0x06, 0x17d2);
8103 MP_WritePhyUshort(sc, 0x06, 0xa0d6);
8104 MP_WritePhyUshort(sc, 0x06, 0xba00);
8105 MP_WritePhyUshort(sc, 0x06, 0x0282);
8106 MP_WritePhyUshort(sc, 0x06, 0x17fe);
8107 MP_WritePhyUshort(sc, 0x06, 0xfdfc);
8108 MP_WritePhyUshort(sc, 0x06, 0x05f8);
8109 MP_WritePhyUshort(sc, 0x06, 0xe0f8);
8110 MP_WritePhyUshort(sc, 0x06, 0x60e1);
8111 MP_WritePhyUshort(sc, 0x06, 0xf861);
8112 MP_WritePhyUshort(sc, 0x06, 0x6802);
8113 MP_WritePhyUshort(sc, 0x06, 0xe4f8);
8114 MP_WritePhyUshort(sc, 0x06, 0x60e5);
8115 MP_WritePhyUshort(sc, 0x06, 0xf861);
8116 MP_WritePhyUshort(sc, 0x06, 0xe0f8);
8117 MP_WritePhyUshort(sc, 0x06, 0x48e1);
8118 MP_WritePhyUshort(sc, 0x06, 0xf849);
8119 MP_WritePhyUshort(sc, 0x06, 0x580f);
8120 MP_WritePhyUshort(sc, 0x06, 0x1e02);
8121 MP_WritePhyUshort(sc, 0x06, 0xe4f8);
8122 MP_WritePhyUshort(sc, 0x06, 0x48e5);
8123 MP_WritePhyUshort(sc, 0x06, 0xf849);
8124 MP_WritePhyUshort(sc, 0x06, 0xd000);
8125 MP_WritePhyUshort(sc, 0x06, 0x0282);
8126 MP_WritePhyUshort(sc, 0x06, 0x5bbf);
8127 MP_WritePhyUshort(sc, 0x06, 0x8350);
8128 MP_WritePhyUshort(sc, 0x06, 0xef46);
8129 MP_WritePhyUshort(sc, 0x06, 0xdc19);
8130 MP_WritePhyUshort(sc, 0x06, 0xddd0);
8131 MP_WritePhyUshort(sc, 0x06, 0x0102);
8132 MP_WritePhyUshort(sc, 0x06, 0x825b);
8133 MP_WritePhyUshort(sc, 0x06, 0x0282);
8134 MP_WritePhyUshort(sc, 0x06, 0x77e0);
8135 MP_WritePhyUshort(sc, 0x06, 0xf860);
8136 MP_WritePhyUshort(sc, 0x06, 0xe1f8);
8137 MP_WritePhyUshort(sc, 0x06, 0x6158);
8138 MP_WritePhyUshort(sc, 0x06, 0xfde4);
8139 MP_WritePhyUshort(sc, 0x06, 0xf860);
8140 MP_WritePhyUshort(sc, 0x06, 0xe5f8);
8141 MP_WritePhyUshort(sc, 0x06, 0x61fc);
8142 MP_WritePhyUshort(sc, 0x06, 0x04f9);
8143 MP_WritePhyUshort(sc, 0x06, 0xfafb);
8144 MP_WritePhyUshort(sc, 0x06, 0xc6bf);
8145 MP_WritePhyUshort(sc, 0x06, 0xf840);
8146 MP_WritePhyUshort(sc, 0x06, 0xbe83);
8147 MP_WritePhyUshort(sc, 0x06, 0x50a0);
8148 MP_WritePhyUshort(sc, 0x06, 0x0101);
8149 MP_WritePhyUshort(sc, 0x06, 0x071b);
8150 MP_WritePhyUshort(sc, 0x06, 0x89cf);
8151 MP_WritePhyUshort(sc, 0x06, 0xd208);
8152 MP_WritePhyUshort(sc, 0x06, 0xebdb);
8153 MP_WritePhyUshort(sc, 0x06, 0x19b2);
8154 MP_WritePhyUshort(sc, 0x06, 0xfbff);
8155 MP_WritePhyUshort(sc, 0x06, 0xfefd);
8156 MP_WritePhyUshort(sc, 0x06, 0x04f8);
8157 MP_WritePhyUshort(sc, 0x06, 0xe0f8);
8158 MP_WritePhyUshort(sc, 0x06, 0x48e1);
8159 MP_WritePhyUshort(sc, 0x06, 0xf849);
8160 MP_WritePhyUshort(sc, 0x06, 0x6808);
8161 MP_WritePhyUshort(sc, 0x06, 0xe4f8);
8162 MP_WritePhyUshort(sc, 0x06, 0x48e5);
8163 MP_WritePhyUshort(sc, 0x06, 0xf849);
8164 MP_WritePhyUshort(sc, 0x06, 0x58f7);
8165 MP_WritePhyUshort(sc, 0x06, 0xe4f8);
8166 MP_WritePhyUshort(sc, 0x06, 0x48e5);
8167 MP_WritePhyUshort(sc, 0x06, 0xf849);
8168 MP_WritePhyUshort(sc, 0x06, 0xfc04);
8169 MP_WritePhyUshort(sc, 0x06, 0x4d20);
8170 MP_WritePhyUshort(sc, 0x06, 0x0002);
8171 MP_WritePhyUshort(sc, 0x06, 0x4e22);
8172 MP_WritePhyUshort(sc, 0x06, 0x0002);
8173 MP_WritePhyUshort(sc, 0x06, 0x4ddf);
8174 MP_WritePhyUshort(sc, 0x06, 0xff01);
8175 MP_WritePhyUshort(sc, 0x06, 0x4edd);
8176 MP_WritePhyUshort(sc, 0x06, 0xff01);
8177 MP_WritePhyUshort(sc, 0x06, 0xf8fa);
8178 MP_WritePhyUshort(sc, 0x06, 0xfbef);
8179 MP_WritePhyUshort(sc, 0x06, 0x79bf);
8180 MP_WritePhyUshort(sc, 0x06, 0xf822);
8181 MP_WritePhyUshort(sc, 0x06, 0xd819);
8182 MP_WritePhyUshort(sc, 0x06, 0xd958);
8183 MP_WritePhyUshort(sc, 0x06, 0x849f);
8184 MP_WritePhyUshort(sc, 0x06, 0x09bf);
8185 MP_WritePhyUshort(sc, 0x06, 0x82be);
8186 MP_WritePhyUshort(sc, 0x06, 0xd682);
8187 MP_WritePhyUshort(sc, 0x06, 0xc602);
8188 MP_WritePhyUshort(sc, 0x06, 0x014f);
8189 MP_WritePhyUshort(sc, 0x06, 0xef97);
8190 MP_WritePhyUshort(sc, 0x06, 0xfffe);
8191 MP_WritePhyUshort(sc, 0x06, 0xfc05);
8192 MP_WritePhyUshort(sc, 0x06, 0x17ff);
8193 MP_WritePhyUshort(sc, 0x06, 0xfe01);
8194 MP_WritePhyUshort(sc, 0x06, 0x1700);
8195 MP_WritePhyUshort(sc, 0x06, 0x0102);
8196 MP_WritePhyUshort(sc, 0x05, 0x83d8);
8197 MP_WritePhyUshort(sc, 0x06, 0x8051);
8198 MP_WritePhyUshort(sc, 0x05, 0x83d6);
8199 MP_WritePhyUshort(sc, 0x06, 0x82a0);
8200 MP_WritePhyUshort(sc, 0x05, 0x83d4);
8201 MP_WritePhyUshort(sc, 0x06, 0x8000);
8202 MP_WritePhyUshort(sc, 0x02, 0x2010);
8203 MP_WritePhyUshort(sc, 0x03, 0xdc00);
8204 MP_WritePhyUshort(sc, 0x1f, 0x0000);
8205 MP_WritePhyUshort(sc, 0x0b, 0x0600);
8206 MP_WritePhyUshort(sc, 0x1f, 0x0005);
8207 MP_WritePhyUshort(sc, 0x05, 0xfff6);
8208 MP_WritePhyUshort(sc, 0x06, 0x00fc);
8209 MP_WritePhyUshort(sc, 0x1f, 0x0000);
8210 }
8211
8212 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8213 MP_WritePhyUshort(sc, 0x0D, 0xF880);
8214 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8215 } else if (sc->re_type == MACFG_32) {
8216 MP_WritePhyUshort(sc, 0x1F, 0x0001);
8217 MP_WritePhyUshort(sc, 0x06, 0x4064);
8218 MP_WritePhyUshort(sc, 0x07, 0x2863);
8219 MP_WritePhyUshort(sc, 0x08, 0x059C);
8220 MP_WritePhyUshort(sc, 0x09, 0x26B4);
8221 MP_WritePhyUshort(sc, 0x0A, 0x6A19);
8222 MP_WritePhyUshort(sc, 0x0B, 0xBCC0);
8223 MP_WritePhyUshort(sc, 0x10, 0xF06D);
8224 MP_WritePhyUshort(sc, 0x14, 0x7F68);
8225 MP_WritePhyUshort(sc, 0x18, 0x7FD9);
8226 MP_WritePhyUshort(sc, 0x1C, 0xF0FF);
8227 MP_WritePhyUshort(sc, 0x1D, 0x3D9C);
8228 MP_WritePhyUshort(sc, 0x1F, 0x0003);
8229 MP_WritePhyUshort(sc, 0x12, 0xF49F);
8230 MP_WritePhyUshort(sc, 0x13, 0x070B);
8231 MP_WritePhyUshort(sc, 0x1A, 0x05AD);
8232 MP_WritePhyUshort(sc, 0x14, 0x94C0);
8233
8234 MP_WritePhyUshort(sc, 0x1F, 0x0002);
8235 MP_WritePhyUshort(sc, 0x06, 0x5571);
8236
8237 MP_WritePhyUshort(sc, 0x1F, 0x0002);
8238 MP_WritePhyUshort(sc, 0x05, 0x2642);
8239
8240 MP_WritePhyUshort(sc, 0x1F, 0x0002);
8241 MP_WritePhyUshort(sc, 0x02, 0xC107);
8242 MP_WritePhyUshort(sc, 0x03, 0x1002);
8243
8244 MP_WritePhyUshort(sc, 0x1F, 0x0001);
8245 MP_WritePhyUshort(sc, 0x16, 0x0CC0);
8246
8247 MP_WritePhyUshort(sc, 0x1F, 0x0002);
8248 MP_WritePhyUshort(sc, 0x0F, 0x0017);
8249
8250 MP_WritePhyUshort(sc, 0x1F, 0x0005);
8251 MP_WritePhyUshort(sc, 0x05, 0x8200);
8252 MP_WritePhyUshort(sc, 0x06, 0xF8F9);
8253 MP_WritePhyUshort(sc, 0x06, 0xFAEF);
8254 MP_WritePhyUshort(sc, 0x06, 0x59EE);
8255 MP_WritePhyUshort(sc, 0x06, 0xF8EA);
8256 MP_WritePhyUshort(sc, 0x06, 0x00EE);
8257 MP_WritePhyUshort(sc, 0x06, 0xF8EB);
8258 MP_WritePhyUshort(sc, 0x06, 0x00E0);
8259 MP_WritePhyUshort(sc, 0x06, 0xF87C);
8260 MP_WritePhyUshort(sc, 0x06, 0xE1F8);
8261 MP_WritePhyUshort(sc, 0x06, 0x7D59);
8262 MP_WritePhyUshort(sc, 0x06, 0x0FEF);
8263 MP_WritePhyUshort(sc, 0x06, 0x0139);
8264 MP_WritePhyUshort(sc, 0x06, 0x029E);
8265 MP_WritePhyUshort(sc, 0x06, 0x06EF);
8266 MP_WritePhyUshort(sc, 0x06, 0x1039);
8267 MP_WritePhyUshort(sc, 0x06, 0x089F);
8268 MP_WritePhyUshort(sc, 0x06, 0x2AEE);
8269 MP_WritePhyUshort(sc, 0x06, 0xF8EA);
8270 MP_WritePhyUshort(sc, 0x06, 0x00EE);
8271 MP_WritePhyUshort(sc, 0x06, 0xF8EB);
8272 MP_WritePhyUshort(sc, 0x06, 0x01E0);
8273 MP_WritePhyUshort(sc, 0x06, 0xF87C);
8274 MP_WritePhyUshort(sc, 0x06, 0xE1F8);
8275 MP_WritePhyUshort(sc, 0x06, 0x7D58);
8276 MP_WritePhyUshort(sc, 0x06, 0x409E);
8277 MP_WritePhyUshort(sc, 0x06, 0x0F39);
8278 MP_WritePhyUshort(sc, 0x06, 0x46AA);
8279 MP_WritePhyUshort(sc, 0x06, 0x0BBF);
8280 MP_WritePhyUshort(sc, 0x06, 0x8251);
8281 MP_WritePhyUshort(sc, 0x06, 0xD682);
8282 MP_WritePhyUshort(sc, 0x06, 0x5902);
8283 MP_WritePhyUshort(sc, 0x06, 0x014F);
8284 MP_WritePhyUshort(sc, 0x06, 0xAE09);
8285 MP_WritePhyUshort(sc, 0x06, 0xBF82);
8286 MP_WritePhyUshort(sc, 0x06, 0x59D6);
8287 MP_WritePhyUshort(sc, 0x06, 0x8261);
8288 MP_WritePhyUshort(sc, 0x06, 0x0201);
8289 MP_WritePhyUshort(sc, 0x06, 0x4FEF);
8290 MP_WritePhyUshort(sc, 0x06, 0x95FE);
8291 MP_WritePhyUshort(sc, 0x06, 0xFDFC);
8292 MP_WritePhyUshort(sc, 0x06, 0x054D);
8293 MP_WritePhyUshort(sc, 0x06, 0x2000);
8294 MP_WritePhyUshort(sc, 0x06, 0x024E);
8295 MP_WritePhyUshort(sc, 0x06, 0x2200);
8296 MP_WritePhyUshort(sc, 0x06, 0x024D);
8297 MP_WritePhyUshort(sc, 0x06, 0xDFFF);
8298 MP_WritePhyUshort(sc, 0x06, 0x014E);
8299 MP_WritePhyUshort(sc, 0x06, 0xDDFF);
8300 MP_WritePhyUshort(sc, 0x06, 0x0100);
8301 MP_WritePhyUshort(sc, 0x02, 0x6010);
8302 MP_WritePhyUshort(sc, 0x05, 0xFFF6);
8303 MP_WritePhyUshort(sc, 0x06, 0x00EC);
8304 MP_WritePhyUshort(sc, 0x05, 0x83D4);
8305 MP_WritePhyUshort(sc, 0x06, 0x8200);
8306
8307 } else if (sc->re_type == MACFG_33) {
8308 MP_WritePhyUshort(sc, 0x1F, 0x0001);
8309 MP_WritePhyUshort(sc, 0x06, 0x4064);
8310 MP_WritePhyUshort(sc, 0x07, 0x2863);
8311 MP_WritePhyUshort(sc, 0x08, 0x059C);
8312 MP_WritePhyUshort(sc, 0x09, 0x26B4);
8313 MP_WritePhyUshort(sc, 0x0A, 0x6A19);
8314 MP_WritePhyUshort(sc, 0x0B, 0xDCC8);
8315 MP_WritePhyUshort(sc, 0x10, 0xF06D);
8316 MP_WritePhyUshort(sc, 0x14, 0x7F68);
8317 MP_WritePhyUshort(sc, 0x18, 0x7FD9);
8318 MP_WritePhyUshort(sc, 0x1C, 0xF0FF);
8319 MP_WritePhyUshort(sc, 0x1D, 0x3D9C);
8320 MP_WritePhyUshort(sc, 0x1F, 0x0003);
8321 MP_WritePhyUshort(sc, 0x12, 0xF49F);
8322 MP_WritePhyUshort(sc, 0x13, 0x070B);
8323 MP_WritePhyUshort(sc, 0x1A, 0x05AD);
8324 MP_WritePhyUshort(sc, 0x14, 0x94C0);
8325
8326 MP_WritePhyUshort(sc, 0x1F, 0x0002);
8327 MP_WritePhyUshort(sc, 0x06, 0x5561);
8328 MP_WritePhyUshort(sc, 0x1F, 0x0005);
8329 MP_WritePhyUshort(sc, 0x05, 0x8332);
8330 MP_WritePhyUshort(sc, 0x06, 0x5561);
8331
8332 if (MP_ReadEfuse(sc, 0x01) == 0xb1) {
8333 MP_WritePhyUshort(sc, 0x1F, 0x0002);
8334 MP_WritePhyUshort(sc, 0x05, 0x669A);
8335 MP_WritePhyUshort(sc, 0x1F, 0x0005);
8336 MP_WritePhyUshort(sc, 0x05, 0x8330);
8337 MP_WritePhyUshort(sc, 0x06, 0x669A);
8338
8339 MP_WritePhyUshort(sc, 0x1F, 0x0002);
8340 Data = MP_ReadPhyUshort(sc, 0x0D);
8341 if ((Data & 0x00FF) != 0x006C) {
8342 Data &= 0xFF00;
8343 MP_WritePhyUshort(sc, 0x1F, 0x0002);
8344 MP_WritePhyUshort(sc, 0x0D, Data | 0x0065);
8345 MP_WritePhyUshort(sc, 0x0D, Data | 0x0066);
8346 MP_WritePhyUshort(sc, 0x0D, Data | 0x0067);
8347 MP_WritePhyUshort(sc, 0x0D, Data | 0x0068);
8348 MP_WritePhyUshort(sc, 0x0D, Data | 0x0069);
8349 MP_WritePhyUshort(sc, 0x0D, Data | 0x006A);
8350 MP_WritePhyUshort(sc, 0x0D, Data | 0x006B);
8351 MP_WritePhyUshort(sc, 0x0D, Data | 0x006C);
8352 }
8353 } else {
8354 MP_WritePhyUshort(sc, 0x1F, 0x0002);
8355 MP_WritePhyUshort(sc, 0x05, 0x2642);
8356 MP_WritePhyUshort(sc, 0x1F, 0x0005);
8357 MP_WritePhyUshort(sc, 0x05, 0x8330);
8358 MP_WritePhyUshort(sc, 0x06, 0x2642);
8359 }
8360
8361 if (MP_ReadEfuse(sc, 0x30) == 0x98) {
8362 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8363 MP_WritePhyUshort(sc, 0x11, MP_ReadPhyUshort(sc, 0x11) & ~0x02);
8364 MP_WritePhyUshort(sc, 0x1F, 0x0005);
8365 MP_WritePhyUshort(sc, 0x01, MP_ReadPhyUshort(sc, 0x01) | 0x200);
8366 } else if (MP_ReadEfuse(sc, 0x30) == 0x90) {
8367 MP_WritePhyUshort(sc, 0x1F, 0x0005);
8368 MP_WritePhyUshort(sc, 0x01, MP_ReadPhyUshort(sc, 0x01) & ~0x200);
8369 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8370 MP_WritePhyUshort(sc, 0x16, 0x5101);
8371 }
8372
8373 MP_WritePhyUshort(sc, 0x1F, 0x0002);
8374 Data = MP_ReadPhyUshort(sc, 0x02);
8375 Data &= ~0x600;
8376 Data |= 0x100;
8377 MP_WritePhyUshort(sc, 0x02, Data);
8378 Data = MP_ReadPhyUshort(sc, 0x03);
8379 Data &= ~0xE000;
8380 MP_WritePhyUshort(sc, 0x03, Data);
8381
8382 MP_WritePhyUshort(sc, 0x1F, 0x0001);
8383 MP_WritePhyUshort(sc, 0x17, 0x0CC0);
8384
8385 MP_WritePhyUshort(sc, 0x1F, 0x0002);
8386 Data = MP_ReadPhyUshort(sc, 0x0F);
8387 Data |= 0x17;
8388 MP_WritePhyUshort(sc, 0x0F, Data);
8389
8390 MP_WritePhyUshort(sc, 0x1F, 0x0005);
8391 MP_WritePhyUshort(sc, 0x05, 0x001B);
8392 if (MP_ReadPhyUshort(sc, 0x06) == 0xB300) {
8393 MP_WritePhyUshort(sc, 0x1f, 0x0005);
8394 MP_WritePhyUshort(sc, 0x05, 0xfff6);
8395 MP_WritePhyUshort(sc, 0x06, 0x0080);
8396 MP_WritePhyUshort(sc, 0x05, 0x8000);
8397 MP_WritePhyUshort(sc, 0x06, 0xf8f9);
8398 MP_WritePhyUshort(sc, 0x06, 0xfaee);
8399 MP_WritePhyUshort(sc, 0x06, 0xf8ea);
8400 MP_WritePhyUshort(sc, 0x06, 0x00ee);
8401 MP_WritePhyUshort(sc, 0x06, 0xf8eb);
8402 MP_WritePhyUshort(sc, 0x06, 0x00e2);
8403 MP_WritePhyUshort(sc, 0x06, 0xf87c);
8404 MP_WritePhyUshort(sc, 0x06, 0xe3f8);
8405 MP_WritePhyUshort(sc, 0x06, 0x7da5);
8406 MP_WritePhyUshort(sc, 0x06, 0x1111);
8407 MP_WritePhyUshort(sc, 0x06, 0x12d2);
8408 MP_WritePhyUshort(sc, 0x06, 0x40d6);
8409 MP_WritePhyUshort(sc, 0x06, 0x4444);
8410 MP_WritePhyUshort(sc, 0x06, 0x0281);
8411 MP_WritePhyUshort(sc, 0x06, 0xc6d2);
8412 MP_WritePhyUshort(sc, 0x06, 0xa0d6);
8413 MP_WritePhyUshort(sc, 0x06, 0xaaaa);
8414 MP_WritePhyUshort(sc, 0x06, 0x0281);
8415 MP_WritePhyUshort(sc, 0x06, 0xc6ae);
8416 MP_WritePhyUshort(sc, 0x06, 0x0fa5);
8417 MP_WritePhyUshort(sc, 0x06, 0x4444);
8418 MP_WritePhyUshort(sc, 0x06, 0x02ae);
8419 MP_WritePhyUshort(sc, 0x06, 0x4da5);
8420 MP_WritePhyUshort(sc, 0x06, 0xaaaa);
8421 MP_WritePhyUshort(sc, 0x06, 0x02ae);
8422 MP_WritePhyUshort(sc, 0x06, 0x47af);
8423 MP_WritePhyUshort(sc, 0x06, 0x81c2);
8424 MP_WritePhyUshort(sc, 0x06, 0xee83);
8425 MP_WritePhyUshort(sc, 0x06, 0x4e00);
8426 MP_WritePhyUshort(sc, 0x06, 0xee83);
8427 MP_WritePhyUshort(sc, 0x06, 0x4d0f);
8428 MP_WritePhyUshort(sc, 0x06, 0xee83);
8429 MP_WritePhyUshort(sc, 0x06, 0x4c0f);
8430 MP_WritePhyUshort(sc, 0x06, 0xee83);
8431 MP_WritePhyUshort(sc, 0x06, 0x4f00);
8432 MP_WritePhyUshort(sc, 0x06, 0xee83);
8433 MP_WritePhyUshort(sc, 0x06, 0x5100);
8434 MP_WritePhyUshort(sc, 0x06, 0xee83);
8435 MP_WritePhyUshort(sc, 0x06, 0x4aff);
8436 MP_WritePhyUshort(sc, 0x06, 0xee83);
8437 MP_WritePhyUshort(sc, 0x06, 0x4bff);
8438 MP_WritePhyUshort(sc, 0x06, 0xe083);
8439 MP_WritePhyUshort(sc, 0x06, 0x30e1);
8440 MP_WritePhyUshort(sc, 0x06, 0x8331);
8441 MP_WritePhyUshort(sc, 0x06, 0x58fe);
8442 MP_WritePhyUshort(sc, 0x06, 0xe4f8);
8443 MP_WritePhyUshort(sc, 0x06, 0x8ae5);
8444 MP_WritePhyUshort(sc, 0x06, 0xf88b);
8445 MP_WritePhyUshort(sc, 0x06, 0xe083);
8446 MP_WritePhyUshort(sc, 0x06, 0x32e1);
8447 MP_WritePhyUshort(sc, 0x06, 0x8333);
8448 MP_WritePhyUshort(sc, 0x06, 0x590f);
8449 MP_WritePhyUshort(sc, 0x06, 0xe283);
8450 MP_WritePhyUshort(sc, 0x06, 0x4d0c);
8451 MP_WritePhyUshort(sc, 0x06, 0x245a);
8452 MP_WritePhyUshort(sc, 0x06, 0xf01e);
8453 MP_WritePhyUshort(sc, 0x06, 0x12e4);
8454 MP_WritePhyUshort(sc, 0x06, 0xf88c);
8455 MP_WritePhyUshort(sc, 0x06, 0xe5f8);
8456 MP_WritePhyUshort(sc, 0x06, 0x8daf);
8457 MP_WritePhyUshort(sc, 0x06, 0x81c2);
8458 MP_WritePhyUshort(sc, 0x06, 0xe083);
8459 MP_WritePhyUshort(sc, 0x06, 0x4f10);
8460 MP_WritePhyUshort(sc, 0x06, 0xe483);
8461 MP_WritePhyUshort(sc, 0x06, 0x4fe0);
8462 MP_WritePhyUshort(sc, 0x06, 0x834e);
8463 MP_WritePhyUshort(sc, 0x06, 0x7800);
8464 MP_WritePhyUshort(sc, 0x06, 0x9f0a);
8465 MP_WritePhyUshort(sc, 0x06, 0xe083);
8466 MP_WritePhyUshort(sc, 0x06, 0x4fa0);
8467 MP_WritePhyUshort(sc, 0x06, 0x10a5);
8468 MP_WritePhyUshort(sc, 0x06, 0xee83);
8469 MP_WritePhyUshort(sc, 0x06, 0x4e01);
8470 MP_WritePhyUshort(sc, 0x06, 0xe083);
8471 MP_WritePhyUshort(sc, 0x06, 0x4e78);
8472 MP_WritePhyUshort(sc, 0x06, 0x059e);
8473 MP_WritePhyUshort(sc, 0x06, 0x9ae0);
8474 MP_WritePhyUshort(sc, 0x06, 0x834e);
8475 MP_WritePhyUshort(sc, 0x06, 0x7804);
8476 MP_WritePhyUshort(sc, 0x06, 0x9e10);
8477 MP_WritePhyUshort(sc, 0x06, 0xe083);
8478 MP_WritePhyUshort(sc, 0x06, 0x4e78);
8479 MP_WritePhyUshort(sc, 0x06, 0x039e);
8480 MP_WritePhyUshort(sc, 0x06, 0x0fe0);
8481 MP_WritePhyUshort(sc, 0x06, 0x834e);
8482 MP_WritePhyUshort(sc, 0x06, 0x7801);
8483 MP_WritePhyUshort(sc, 0x06, 0x9e05);
8484 MP_WritePhyUshort(sc, 0x06, 0xae0c);
8485 MP_WritePhyUshort(sc, 0x06, 0xaf81);
8486 MP_WritePhyUshort(sc, 0x06, 0xa7af);
8487 MP_WritePhyUshort(sc, 0x06, 0x8152);
8488 MP_WritePhyUshort(sc, 0x06, 0xaf81);
8489 MP_WritePhyUshort(sc, 0x06, 0x8baf);
8490 MP_WritePhyUshort(sc, 0x06, 0x81c2);
8491 MP_WritePhyUshort(sc, 0x06, 0xee83);
8492 MP_WritePhyUshort(sc, 0x06, 0x4800);
8493 MP_WritePhyUshort(sc, 0x06, 0xee83);
8494 MP_WritePhyUshort(sc, 0x06, 0x4900);
8495 MP_WritePhyUshort(sc, 0x06, 0xe083);
8496 MP_WritePhyUshort(sc, 0x06, 0x5110);
8497 MP_WritePhyUshort(sc, 0x06, 0xe483);
8498 MP_WritePhyUshort(sc, 0x06, 0x5158);
8499 MP_WritePhyUshort(sc, 0x06, 0x019f);
8500 MP_WritePhyUshort(sc, 0x06, 0xead0);
8501 MP_WritePhyUshort(sc, 0x06, 0x00d1);
8502 MP_WritePhyUshort(sc, 0x06, 0x801f);
8503 MP_WritePhyUshort(sc, 0x06, 0x66e2);
8504 MP_WritePhyUshort(sc, 0x06, 0xf8ea);
8505 MP_WritePhyUshort(sc, 0x06, 0xe3f8);
8506 MP_WritePhyUshort(sc, 0x06, 0xeb5a);
8507 MP_WritePhyUshort(sc, 0x06, 0xf81e);
8508 MP_WritePhyUshort(sc, 0x06, 0x20e6);
8509 MP_WritePhyUshort(sc, 0x06, 0xf8ea);
8510 MP_WritePhyUshort(sc, 0x06, 0xe5f8);
8511 MP_WritePhyUshort(sc, 0x06, 0xebd3);
8512 MP_WritePhyUshort(sc, 0x06, 0x02b3);
8513 MP_WritePhyUshort(sc, 0x06, 0xfee2);
8514 MP_WritePhyUshort(sc, 0x06, 0xf87c);
8515 MP_WritePhyUshort(sc, 0x06, 0xef32);
8516 MP_WritePhyUshort(sc, 0x06, 0x5b80);
8517 MP_WritePhyUshort(sc, 0x06, 0xe3f8);
8518 MP_WritePhyUshort(sc, 0x06, 0x7d9e);
8519 MP_WritePhyUshort(sc, 0x06, 0x037d);
8520 MP_WritePhyUshort(sc, 0x06, 0xffff);
8521 MP_WritePhyUshort(sc, 0x06, 0x0d58);
8522 MP_WritePhyUshort(sc, 0x06, 0x1c55);
8523 MP_WritePhyUshort(sc, 0x06, 0x1a65);
8524 MP_WritePhyUshort(sc, 0x06, 0x11a1);
8525 MP_WritePhyUshort(sc, 0x06, 0x90d3);
8526 MP_WritePhyUshort(sc, 0x06, 0xe283);
8527 MP_WritePhyUshort(sc, 0x06, 0x48e3);
8528 MP_WritePhyUshort(sc, 0x06, 0x8349);
8529 MP_WritePhyUshort(sc, 0x06, 0x1b56);
8530 MP_WritePhyUshort(sc, 0x06, 0xab08);
8531 MP_WritePhyUshort(sc, 0x06, 0xef56);
8532 MP_WritePhyUshort(sc, 0x06, 0xe683);
8533 MP_WritePhyUshort(sc, 0x06, 0x48e7);
8534 MP_WritePhyUshort(sc, 0x06, 0x8349);
8535 MP_WritePhyUshort(sc, 0x06, 0x10d1);
8536 MP_WritePhyUshort(sc, 0x06, 0x801f);
8537 MP_WritePhyUshort(sc, 0x06, 0x66a0);
8538 MP_WritePhyUshort(sc, 0x06, 0x04b9);
8539 MP_WritePhyUshort(sc, 0x06, 0xe283);
8540 MP_WritePhyUshort(sc, 0x06, 0x48e3);
8541 MP_WritePhyUshort(sc, 0x06, 0x8349);
8542 MP_WritePhyUshort(sc, 0x06, 0xef65);
8543 MP_WritePhyUshort(sc, 0x06, 0xe283);
8544 MP_WritePhyUshort(sc, 0x06, 0x4ae3);
8545 MP_WritePhyUshort(sc, 0x06, 0x834b);
8546 MP_WritePhyUshort(sc, 0x06, 0x1b56);
8547 MP_WritePhyUshort(sc, 0x06, 0xaa0e);
8548 MP_WritePhyUshort(sc, 0x06, 0xef56);
8549 MP_WritePhyUshort(sc, 0x06, 0xe683);
8550 MP_WritePhyUshort(sc, 0x06, 0x4ae7);
8551 MP_WritePhyUshort(sc, 0x06, 0x834b);
8552 MP_WritePhyUshort(sc, 0x06, 0xe283);
8553 MP_WritePhyUshort(sc, 0x06, 0x4de6);
8554 MP_WritePhyUshort(sc, 0x06, 0x834c);
8555 MP_WritePhyUshort(sc, 0x06, 0xe083);
8556 MP_WritePhyUshort(sc, 0x06, 0x4da0);
8557 MP_WritePhyUshort(sc, 0x06, 0x000c);
8558 MP_WritePhyUshort(sc, 0x06, 0xaf81);
8559 MP_WritePhyUshort(sc, 0x06, 0x8be0);
8560 MP_WritePhyUshort(sc, 0x06, 0x834d);
8561 MP_WritePhyUshort(sc, 0x06, 0x10e4);
8562 MP_WritePhyUshort(sc, 0x06, 0x834d);
8563 MP_WritePhyUshort(sc, 0x06, 0xae04);
8564 MP_WritePhyUshort(sc, 0x06, 0x80e4);
8565 MP_WritePhyUshort(sc, 0x06, 0x834d);
8566 MP_WritePhyUshort(sc, 0x06, 0xe083);
8567 MP_WritePhyUshort(sc, 0x06, 0x4e78);
8568 MP_WritePhyUshort(sc, 0x06, 0x039e);
8569 MP_WritePhyUshort(sc, 0x06, 0x0be0);
8570 MP_WritePhyUshort(sc, 0x06, 0x834e);
8571 MP_WritePhyUshort(sc, 0x06, 0x7804);
8572 MP_WritePhyUshort(sc, 0x06, 0x9e04);
8573 MP_WritePhyUshort(sc, 0x06, 0xee83);
8574 MP_WritePhyUshort(sc, 0x06, 0x4e02);
8575 MP_WritePhyUshort(sc, 0x06, 0xe083);
8576 MP_WritePhyUshort(sc, 0x06, 0x32e1);
8577 MP_WritePhyUshort(sc, 0x06, 0x8333);
8578 MP_WritePhyUshort(sc, 0x06, 0x590f);
8579 MP_WritePhyUshort(sc, 0x06, 0xe283);
8580 MP_WritePhyUshort(sc, 0x06, 0x4d0c);
8581 MP_WritePhyUshort(sc, 0x06, 0x245a);
8582 MP_WritePhyUshort(sc, 0x06, 0xf01e);
8583 MP_WritePhyUshort(sc, 0x06, 0x12e4);
8584 MP_WritePhyUshort(sc, 0x06, 0xf88c);
8585 MP_WritePhyUshort(sc, 0x06, 0xe5f8);
8586 MP_WritePhyUshort(sc, 0x06, 0x8de0);
8587 MP_WritePhyUshort(sc, 0x06, 0x8330);
8588 MP_WritePhyUshort(sc, 0x06, 0xe183);
8589 MP_WritePhyUshort(sc, 0x06, 0x3168);
8590 MP_WritePhyUshort(sc, 0x06, 0x01e4);
8591 MP_WritePhyUshort(sc, 0x06, 0xf88a);
8592 MP_WritePhyUshort(sc, 0x06, 0xe5f8);
8593 MP_WritePhyUshort(sc, 0x06, 0x8bae);
8594 MP_WritePhyUshort(sc, 0x06, 0x37ee);
8595 MP_WritePhyUshort(sc, 0x06, 0x834e);
8596 MP_WritePhyUshort(sc, 0x06, 0x03e0);
8597 MP_WritePhyUshort(sc, 0x06, 0x834c);
8598 MP_WritePhyUshort(sc, 0x06, 0xe183);
8599 MP_WritePhyUshort(sc, 0x06, 0x4d1b);
8600 MP_WritePhyUshort(sc, 0x06, 0x019e);
8601 MP_WritePhyUshort(sc, 0x06, 0x04aa);
8602 MP_WritePhyUshort(sc, 0x06, 0xa1ae);
8603 MP_WritePhyUshort(sc, 0x06, 0xa8ee);
8604 MP_WritePhyUshort(sc, 0x06, 0x834e);
8605 MP_WritePhyUshort(sc, 0x06, 0x04ee);
8606 MP_WritePhyUshort(sc, 0x06, 0x834f);
8607 MP_WritePhyUshort(sc, 0x06, 0x00ae);
8608 MP_WritePhyUshort(sc, 0x06, 0xabe0);
8609 MP_WritePhyUshort(sc, 0x06, 0x834f);
8610 MP_WritePhyUshort(sc, 0x06, 0x7803);
8611 MP_WritePhyUshort(sc, 0x06, 0x9f14);
8612 MP_WritePhyUshort(sc, 0x06, 0xee83);
8613 MP_WritePhyUshort(sc, 0x06, 0x4e05);
8614 MP_WritePhyUshort(sc, 0x06, 0xd240);
8615 MP_WritePhyUshort(sc, 0x06, 0xd655);
8616 MP_WritePhyUshort(sc, 0x06, 0x5402);
8617 MP_WritePhyUshort(sc, 0x06, 0x81c6);
8618 MP_WritePhyUshort(sc, 0x06, 0xd2a0);
8619 MP_WritePhyUshort(sc, 0x06, 0xd6ba);
8620 MP_WritePhyUshort(sc, 0x06, 0x0002);
8621 MP_WritePhyUshort(sc, 0x06, 0x81c6);
8622 MP_WritePhyUshort(sc, 0x06, 0xfefd);
8623 MP_WritePhyUshort(sc, 0x06, 0xfc05);
8624 MP_WritePhyUshort(sc, 0x06, 0xf8e0);
8625 MP_WritePhyUshort(sc, 0x06, 0xf860);
8626 MP_WritePhyUshort(sc, 0x06, 0xe1f8);
8627 MP_WritePhyUshort(sc, 0x06, 0x6168);
8628 MP_WritePhyUshort(sc, 0x06, 0x02e4);
8629 MP_WritePhyUshort(sc, 0x06, 0xf860);
8630 MP_WritePhyUshort(sc, 0x06, 0xe5f8);
8631 MP_WritePhyUshort(sc, 0x06, 0x61e0);
8632 MP_WritePhyUshort(sc, 0x06, 0xf848);
8633 MP_WritePhyUshort(sc, 0x06, 0xe1f8);
8634 MP_WritePhyUshort(sc, 0x06, 0x4958);
8635 MP_WritePhyUshort(sc, 0x06, 0x0f1e);
8636 MP_WritePhyUshort(sc, 0x06, 0x02e4);
8637 MP_WritePhyUshort(sc, 0x06, 0xf848);
8638 MP_WritePhyUshort(sc, 0x06, 0xe5f8);
8639 MP_WritePhyUshort(sc, 0x06, 0x49d0);
8640 MP_WritePhyUshort(sc, 0x06, 0x0002);
8641 MP_WritePhyUshort(sc, 0x06, 0x820a);
8642 MP_WritePhyUshort(sc, 0x06, 0xbf83);
8643 MP_WritePhyUshort(sc, 0x06, 0x50ef);
8644 MP_WritePhyUshort(sc, 0x06, 0x46dc);
8645 MP_WritePhyUshort(sc, 0x06, 0x19dd);
8646 MP_WritePhyUshort(sc, 0x06, 0xd001);
8647 MP_WritePhyUshort(sc, 0x06, 0x0282);
8648 MP_WritePhyUshort(sc, 0x06, 0x0a02);
8649 MP_WritePhyUshort(sc, 0x06, 0x8226);
8650 MP_WritePhyUshort(sc, 0x06, 0xe0f8);
8651 MP_WritePhyUshort(sc, 0x06, 0x60e1);
8652 MP_WritePhyUshort(sc, 0x06, 0xf861);
8653 MP_WritePhyUshort(sc, 0x06, 0x58fd);
8654 MP_WritePhyUshort(sc, 0x06, 0xe4f8);
8655 MP_WritePhyUshort(sc, 0x06, 0x60e5);
8656 MP_WritePhyUshort(sc, 0x06, 0xf861);
8657 MP_WritePhyUshort(sc, 0x06, 0xfc04);
8658 MP_WritePhyUshort(sc, 0x06, 0xf9fa);
8659 MP_WritePhyUshort(sc, 0x06, 0xfbc6);
8660 MP_WritePhyUshort(sc, 0x06, 0xbff8);
8661 MP_WritePhyUshort(sc, 0x06, 0x40be);
8662 MP_WritePhyUshort(sc, 0x06, 0x8350);
8663 MP_WritePhyUshort(sc, 0x06, 0xa001);
8664 MP_WritePhyUshort(sc, 0x06, 0x0107);
8665 MP_WritePhyUshort(sc, 0x06, 0x1b89);
8666 MP_WritePhyUshort(sc, 0x06, 0xcfd2);
8667 MP_WritePhyUshort(sc, 0x06, 0x08eb);
8668 MP_WritePhyUshort(sc, 0x06, 0xdb19);
8669 MP_WritePhyUshort(sc, 0x06, 0xb2fb);
8670 MP_WritePhyUshort(sc, 0x06, 0xfffe);
8671 MP_WritePhyUshort(sc, 0x06, 0xfd04);
8672 MP_WritePhyUshort(sc, 0x06, 0xf8e0);
8673 MP_WritePhyUshort(sc, 0x06, 0xf848);
8674 MP_WritePhyUshort(sc, 0x06, 0xe1f8);
8675 MP_WritePhyUshort(sc, 0x06, 0x4968);
8676 MP_WritePhyUshort(sc, 0x06, 0x08e4);
8677 MP_WritePhyUshort(sc, 0x06, 0xf848);
8678 MP_WritePhyUshort(sc, 0x06, 0xe5f8);
8679 MP_WritePhyUshort(sc, 0x06, 0x4958);
8680 MP_WritePhyUshort(sc, 0x06, 0xf7e4);
8681 MP_WritePhyUshort(sc, 0x06, 0xf848);
8682 MP_WritePhyUshort(sc, 0x06, 0xe5f8);
8683 MP_WritePhyUshort(sc, 0x06, 0x49fc);
8684 MP_WritePhyUshort(sc, 0x06, 0x044d);
8685 MP_WritePhyUshort(sc, 0x06, 0x2000);
8686 MP_WritePhyUshort(sc, 0x06, 0x024e);
8687 MP_WritePhyUshort(sc, 0x06, 0x2200);
8688 MP_WritePhyUshort(sc, 0x06, 0x024d);
8689 MP_WritePhyUshort(sc, 0x06, 0xdfff);
8690 MP_WritePhyUshort(sc, 0x06, 0x014e);
8691 MP_WritePhyUshort(sc, 0x06, 0xddff);
8692 MP_WritePhyUshort(sc, 0x06, 0x01f8);
8693 MP_WritePhyUshort(sc, 0x06, 0xfafb);
8694 MP_WritePhyUshort(sc, 0x06, 0xef79);
8695 MP_WritePhyUshort(sc, 0x06, 0xbff8);
8696 MP_WritePhyUshort(sc, 0x06, 0x22d8);
8697 MP_WritePhyUshort(sc, 0x06, 0x19d9);
8698 MP_WritePhyUshort(sc, 0x06, 0x5884);
8699 MP_WritePhyUshort(sc, 0x06, 0x9f09);
8700 MP_WritePhyUshort(sc, 0x06, 0xbf82);
8701 MP_WritePhyUshort(sc, 0x06, 0x6dd6);
8702 MP_WritePhyUshort(sc, 0x06, 0x8275);
8703 MP_WritePhyUshort(sc, 0x06, 0x0201);
8704 MP_WritePhyUshort(sc, 0x06, 0x4fef);
8705 MP_WritePhyUshort(sc, 0x06, 0x97ff);
8706 MP_WritePhyUshort(sc, 0x06, 0xfefc);
8707 MP_WritePhyUshort(sc, 0x06, 0x0517);
8708 MP_WritePhyUshort(sc, 0x06, 0xfffe);
8709 MP_WritePhyUshort(sc, 0x06, 0x0117);
8710 MP_WritePhyUshort(sc, 0x06, 0x0001);
8711 MP_WritePhyUshort(sc, 0x06, 0x0200);
8712 MP_WritePhyUshort(sc, 0x05, 0x83d8);
8713 MP_WritePhyUshort(sc, 0x06, 0x8000);
8714 MP_WritePhyUshort(sc, 0x05, 0x83d6);
8715 MP_WritePhyUshort(sc, 0x06, 0x824f);
8716 MP_WritePhyUshort(sc, 0x02, 0x2010);
8717 MP_WritePhyUshort(sc, 0x03, 0xdc00);
8718 MP_WritePhyUshort(sc, 0x1f, 0x0000);
8719 MP_WritePhyUshort(sc, 0x0b, 0x0600);
8720 MP_WritePhyUshort(sc, 0x1f, 0x0005);
8721 MP_WritePhyUshort(sc, 0x05, 0xfff6);
8722 MP_WritePhyUshort(sc, 0x06, 0x00fc);
8723 MP_WritePhyUshort(sc, 0x1f, 0x0000);
8724 }
8725
8726 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8727 MP_WritePhyUshort(sc, 0x0D, 0xF880);
8728 MP_WritePhyUshort(sc, 0x1F, 0x0000);
8729 } else if (sc->re_type == MACFG_36 || sc->re_type == MACFG_37) {
8730 if (sc->re_type == MACFG_36) {
8731 MP_WritePhyUshort(sc, 0x1f, 0x0000);
8732 MP_WritePhyUshort(sc, 0x00, 0x1800);
8733 MP_WritePhyUshort(sc, 0x1f, 0x0007);
8734 MP_WritePhyUshort(sc, 0x1e, 0x0023);
8735 MP_WritePhyUshort(sc, 0x17, 0x0117);
8736 MP_WritePhyUshort(sc, 0x1f, 0x0007);
8737 MP_WritePhyUshort(sc, 0x1E, 0x002C);
8738 MP_WritePhyUshort(sc, 0x1B, 0x5000);
8739 MP_WritePhyUshort(sc, 0x1f, 0x0000);
8740 MP_WritePhyUshort(sc, 0x16, 0x4104);
8741 for (i = 0; i < 200; i++) {
8742 DELAY(100);
8743 Data = MP_ReadPhyUshort(sc, 0x1E);
8744 Data &= 0x03FF;
8745 if (Data== 0x000C)
8746 break;
8747 }
8748 MP_WritePhyUshort(sc, 0x1f, 0x0005);
8749 for (i = 0; i < 200; i++) {
8750 DELAY(100);
8751 Data = MP_ReadPhyUshort(sc, 0x07);
8752 if ((Data & 0x0020)==0)
8753 break;
8754 }
8755 Data = MP_ReadPhyUshort(sc, 0x07);
8756 if (Data & 0x0020) {
8757 MP_WritePhyUshort(sc, 0x1f, 0x0007);
8758 MP_WritePhyUshort(sc, 0x1e, 0x00a1);
8759 MP_WritePhyUshort(sc, 0x17, 0x1000);
8760 MP_WritePhyUshort(sc, 0x17, 0x0000);
8761 MP_WritePhyUshort(sc, 0x17, 0x2000);
8762 MP_WritePhyUshort(sc, 0x1e, 0x002f);
8763 MP_WritePhyUshort(sc, 0x18, 0x9bfb);
8764 MP_WritePhyUshort(sc, 0x1f, 0x0005);
8765 MP_WritePhyUshort(sc, 0x07, 0x0000);
8766 MP_WritePhyUshort(sc, 0x1f, 0x0000);
8767 }
8768 MP_WritePhyUshort(sc, 0x1f, 0x0005);
8769 MP_WritePhyUshort(sc, 0x05, 0xfff6);
8770 MP_WritePhyUshort(sc, 0x06, 0x0080);
8771 Data = MP_ReadPhyUshort(sc, 0x00);
8772 Data &= ~(0x0080);
8773 MP_WritePhyUshort(sc, 0x00, Data);
8774 MP_WritePhyUshort(sc, 0x1f, 0x0002);
8775 Data = MP_ReadPhyUshort(sc, 0x08);
8776 Data &= ~(0x0080);
8777 MP_WritePhyUshort(sc, 0x08, Data);
8778 MP_WritePhyUshort(sc, 0x1f, 0x0000);
8779 MP_WritePhyUshort(sc, 0x1f, 0x0007);
8780 MP_WritePhyUshort(sc, 0x1e, 0x0023);
8781 MP_WritePhyUshort(sc, 0x16, 0x0306);
8782 MP_WritePhyUshort(sc, 0x16, 0x0307);
8783 MP_WritePhyUshort(sc, 0x15, 0x000e);
8784 MP_WritePhyUshort(sc, 0x19, 0x000a);
8785 MP_WritePhyUshort(sc, 0x15, 0x0010);
8786 MP_WritePhyUshort(sc, 0x19, 0x0008);
8787 MP_WritePhyUshort(sc, 0x15, 0x0018);
8788 MP_WritePhyUshort(sc, 0x19, 0x4801);
8789 MP_WritePhyUshort(sc, 0x15, 0x0019);
8790 MP_WritePhyUshort(sc, 0x19, 0x6801);
8791 MP_WritePhyUshort(sc, 0x15, 0x001a);
8792 MP_WritePhyUshort(sc, 0x19, 0x66a1);
8793 MP_WritePhyUshort(sc, 0x15, 0x001f);
8794 MP_WritePhyUshort(sc, 0x19, 0x0000);
8795 MP_WritePhyUshort(sc, 0x15, 0x0020);
8796 MP_WritePhyUshort(sc, 0x19, 0x0000);
8797 MP_WritePhyUshort(sc, 0x15, 0x0021);
8798 MP_WritePhyUshort(sc, 0x19, 0x0000);
8799 MP_WritePhyUshort(sc, 0x15, 0x0022);
8800 MP_WritePhyUshort(sc, 0x19, 0x0000);
8801 MP_WritePhyUshort(sc, 0x15, 0x0023);
8802 MP_WritePhyUshort(sc, 0x19, 0x0000);
8803 MP_WritePhyUshort(sc, 0x15, 0x0024);
8804 MP_WritePhyUshort(sc, 0x19, 0x0000);
8805 MP_WritePhyUshort(sc, 0x15, 0x0025);
8806 MP_WritePhyUshort(sc, 0x19, 0x64a1);
8807 MP_WritePhyUshort(sc, 0x15, 0x0026);
8808 MP_WritePhyUshort(sc, 0x19, 0x40ea);
8809 MP_WritePhyUshort(sc, 0x15, 0x0027);
8810 MP_WritePhyUshort(sc, 0x19, 0x4503);
8811 MP_WritePhyUshort(sc, 0x15, 0x0028);
8812 MP_WritePhyUshort(sc, 0x19, 0x9f00);
8813 MP_WritePhyUshort(sc, 0x15, 0x0029);
8814 MP_WritePhyUshort(sc, 0x19, 0xa631);
8815 MP_WritePhyUshort(sc, 0x15, 0x002a);
8816 MP_WritePhyUshort(sc, 0x19, 0x9717);
8817 MP_WritePhyUshort(sc, 0x15, 0x002b);
8818 MP_WritePhyUshort(sc, 0x19, 0x302c);
8819 MP_WritePhyUshort(sc, 0x15, 0x002c);
8820 MP_WritePhyUshort(sc, 0x19, 0x4802);
8821 MP_WritePhyUshort(sc, 0x15, 0x002d);
8822 MP_WritePhyUshort(sc, 0x19, 0x58da);
8823 MP_WritePhyUshort(sc, 0x15, 0x002e);
8824 MP_WritePhyUshort(sc, 0x19, 0x400d);
8825 MP_WritePhyUshort(sc, 0x15, 0x002f);
8826 MP_WritePhyUshort(sc, 0x19, 0x4488);
8827 MP_WritePhyUshort(sc, 0x15, 0x0030);
8828 MP_WritePhyUshort(sc, 0x19, 0x9e00);
8829 MP_WritePhyUshort(sc, 0x15, 0x0031);
8830 MP_WritePhyUshort(sc, 0x19, 0x63c8);
8831 MP_WritePhyUshort(sc, 0x15, 0x0032);
8832 MP_WritePhyUshort(sc, 0x19, 0x6481);
8833 MP_WritePhyUshort(sc, 0x15, 0x0033);
8834 MP_WritePhyUshort(sc, 0x19, 0x0000);
8835 MP_WritePhyUshort(sc, 0x15, 0x0034);
8836 MP_WritePhyUshort(sc, 0x19, 0x0000);
8837 MP_WritePhyUshort(sc, 0x15, 0x0035);
8838 MP_WritePhyUshort(sc, 0x19, 0x0000);
8839 MP_WritePhyUshort(sc, 0x15, 0x0036);
8840 MP_WritePhyUshort(sc, 0x19, 0x0000);
8841 MP_WritePhyUshort(sc, 0x15, 0x0037);
8842 MP_WritePhyUshort(sc, 0x19, 0x0000);
8843 MP_WritePhyUshort(sc, 0x15, 0x0038);
8844 MP_WritePhyUshort(sc, 0x19, 0x0000);
8845 MP_WritePhyUshort(sc, 0x15, 0x0039);
8846 MP_WritePhyUshort(sc, 0x19, 0x0000);
8847 MP_WritePhyUshort(sc, 0x15, 0x003a);
8848 MP_WritePhyUshort(sc, 0x19, 0x0000);
8849 MP_WritePhyUshort(sc, 0x15, 0x003b);
8850 MP_WritePhyUshort(sc, 0x19, 0x63e8);
8851 MP_WritePhyUshort(sc, 0x15, 0x003c);
8852 MP_WritePhyUshort(sc, 0x19, 0x7d00);
8853 MP_WritePhyUshort(sc, 0x15, 0x003d);
8854 MP_WritePhyUshort(sc, 0x19, 0x59d4);
8855 MP_WritePhyUshort(sc, 0x15, 0x003e);
8856 MP_WritePhyUshort(sc, 0x19, 0x63f8);
8857 MP_WritePhyUshort(sc, 0x15, 0x0040);
8858 MP_WritePhyUshort(sc, 0x19, 0x64a1);
8859 MP_WritePhyUshort(sc, 0x15, 0x0041);
8860 MP_WritePhyUshort(sc, 0x19, 0x30de);
8861 MP_WritePhyUshort(sc, 0x15, 0x0044);
8862 MP_WritePhyUshort(sc, 0x19, 0x480f);
8863 MP_WritePhyUshort(sc, 0x15, 0x0045);
8864 MP_WritePhyUshort(sc, 0x19, 0x6800);
8865 MP_WritePhyUshort(sc, 0x15, 0x0046);
8866 MP_WritePhyUshort(sc, 0x19, 0x6680);
8867 MP_WritePhyUshort(sc, 0x15, 0x0047);
8868 MP_WritePhyUshort(sc, 0x19, 0x7c10);
8869 MP_WritePhyUshort(sc, 0x15, 0x0048);
8870 MP_WritePhyUshort(sc, 0x19, 0x63c8);
8871 MP_WritePhyUshort(sc, 0x15, 0x0049);
8872 MP_WritePhyUshort(sc, 0x19, 0x0000);
8873 MP_WritePhyUshort(sc, 0x15, 0x004a);
8874 MP_WritePhyUshort(sc, 0x19, 0x0000);
8875 MP_WritePhyUshort(sc, 0x15, 0x004b);
8876 MP_WritePhyUshort(sc, 0x19, 0x0000);
8877 MP_WritePhyUshort(sc, 0x15, 0x004c);
8878 MP_WritePhyUshort(sc, 0x19, 0x0000);
8879 MP_WritePhyUshort(sc, 0x15, 0x004d);
8880 MP_WritePhyUshort(sc, 0x19, 0x0000);
8881 MP_WritePhyUshort(sc, 0x15, 0x004e);
8882 MP_WritePhyUshort(sc, 0x19, 0x0000);
8883 MP_WritePhyUshort(sc, 0x15, 0x004f);
8884 MP_WritePhyUshort(sc, 0x19, 0x40ea);
8885 MP_WritePhyUshort(sc, 0x15, 0x0050);
8886 MP_WritePhyUshort(sc, 0x19, 0x4503);
8887 MP_WritePhyUshort(sc, 0x15, 0x0051);
8888 MP_WritePhyUshort(sc, 0x19, 0x58ca);
8889 MP_WritePhyUshort(sc, 0x15, 0x0052);
8890 MP_WritePhyUshort(sc, 0x19, 0x63c8);
8891 MP_WritePhyUshort(sc, 0x15, 0x0053);
8892 MP_WritePhyUshort(sc, 0x19, 0x63d8);
8893 MP_WritePhyUshort(sc, 0x15, 0x0054);
8894 MP_WritePhyUshort(sc, 0x19, 0x66a0);
8895 MP_WritePhyUshort(sc, 0x15, 0x0055);
8896 MP_WritePhyUshort(sc, 0x19, 0x9f00);
8897 MP_WritePhyUshort(sc, 0x15, 0x0056);
8898 MP_WritePhyUshort(sc, 0x19, 0x3000);
8899 MP_WritePhyUshort(sc, 0x15, 0x006E);
8900 MP_WritePhyUshort(sc, 0x19, 0x9afa);
8901 MP_WritePhyUshort(sc, 0x15, 0x00a1);
8902 MP_WritePhyUshort(sc, 0x19, 0x3044);
8903 MP_WritePhyUshort(sc, 0x15, 0x00ab);
8904 MP_WritePhyUshort(sc, 0x19, 0x5820);
8905 MP_WritePhyUshort(sc, 0x15, 0x00ac);
8906 MP_WritePhyUshort(sc, 0x19, 0x5e04);
8907 MP_WritePhyUshort(sc, 0x15, 0x00ad);
8908 MP_WritePhyUshort(sc, 0x19, 0xb60c);
8909 MP_WritePhyUshort(sc, 0x15, 0x00af);
8910 MP_WritePhyUshort(sc, 0x19, 0x000a);
8911 MP_WritePhyUshort(sc, 0x15, 0x00b2);
8912 MP_WritePhyUshort(sc, 0x19, 0x30b9);
8913 MP_WritePhyUshort(sc, 0x15, 0x00b9);
8914 MP_WritePhyUshort(sc, 0x19, 0x4408);
8915 MP_WritePhyUshort(sc, 0x15, 0x00ba);
8916 MP_WritePhyUshort(sc, 0x19, 0x480b);
8917 MP_WritePhyUshort(sc, 0x15, 0x00bb);
8918 MP_WritePhyUshort(sc, 0x19, 0x5e00);
8919 MP_WritePhyUshort(sc, 0x15, 0x00bc);
8920 MP_WritePhyUshort(sc, 0x19, 0x405f);
8921 MP_WritePhyUshort(sc, 0x15, 0x00bd);
8922 MP_WritePhyUshort(sc, 0x19, 0x4448);
8923 MP_WritePhyUshort(sc, 0x15, 0x00be);
8924 MP_WritePhyUshort(sc, 0x19, 0x4020);
8925 MP_WritePhyUshort(sc, 0x15, 0x00bf);
8926 MP_WritePhyUshort(sc, 0x19, 0x4468);
8927 MP_WritePhyUshort(sc, 0x15, 0x00c0);
8928 MP_WritePhyUshort(sc, 0x19, 0x9c02);
8929 MP_WritePhyUshort(sc, 0x15, 0x00c1);
8930 MP_WritePhyUshort(sc, 0x19, 0x58a0);
8931 MP_WritePhyUshort(sc, 0x15, 0x00c2);
8932 MP_WritePhyUshort(sc, 0x19, 0xb605);
8933 MP_WritePhyUshort(sc, 0x15, 0x00c3);
8934 MP_WritePhyUshort(sc, 0x19, 0xc0d3);
8935 MP_WritePhyUshort(sc, 0x15, 0x00c4);
8936 MP_WritePhyUshort(sc, 0x19, 0x00e6);
8937 MP_WritePhyUshort(sc, 0x15, 0x00c5);
8938 MP_WritePhyUshort(sc, 0x19, 0xdaec);
8939 MP_WritePhyUshort(sc, 0x15, 0x00c6);
8940 MP_WritePhyUshort(sc, 0x19, 0x00fa);
8941 MP_WritePhyUshort(sc, 0x15, 0x00c7);
8942 MP_WritePhyUshort(sc, 0x19, 0x9df9);
8943 MP_WritePhyUshort(sc, 0x15, 0x00c8);
8944 MP_WritePhyUshort(sc, 0x19, 0x307a);
8945 MP_WritePhyUshort(sc, 0x15, 0x0112);
8946 MP_WritePhyUshort(sc, 0x19, 0x6421);
8947 MP_WritePhyUshort(sc, 0x15, 0x0113);
8948 MP_WritePhyUshort(sc, 0x19, 0x7c08);
8949 MP_WritePhyUshort(sc, 0x15, 0x0114);
8950 MP_WritePhyUshort(sc, 0x19, 0x63f0);
8951 MP_WritePhyUshort(sc, 0x15, 0x0115);
8952 MP_WritePhyUshort(sc, 0x19, 0x4003);
8953 MP_WritePhyUshort(sc, 0x15, 0x0116);
8954 MP_WritePhyUshort(sc, 0x19, 0x4418);
8955 MP_WritePhyUshort(sc, 0x15, 0x0117);
8956 MP_WritePhyUshort(sc, 0x19, 0x9b00);
8957 MP_WritePhyUshort(sc, 0x15, 0x0118);
8958 MP_WritePhyUshort(sc, 0x19, 0x6461);
8959 MP_WritePhyUshort(sc, 0x15, 0x0119);
8960 MP_WritePhyUshort(sc, 0x19, 0x64e1);
8961 MP_WritePhyUshort(sc, 0x15, 0x011a);
8962 MP_WritePhyUshort(sc, 0x19, 0x0000);
8963 MP_WritePhyUshort(sc, 0x15, 0x0150);
8964 MP_WritePhyUshort(sc, 0x19, 0x7c80);
8965 MP_WritePhyUshort(sc, 0x15, 0x0151);
8966 MP_WritePhyUshort(sc, 0x19, 0x6461);
8967 MP_WritePhyUshort(sc, 0x15, 0x0152);
8968 MP_WritePhyUshort(sc, 0x19, 0x4003);
8969 MP_WritePhyUshort(sc, 0x15, 0x0153);
8970 MP_WritePhyUshort(sc, 0x19, 0x4540);
8971 MP_WritePhyUshort(sc, 0x15, 0x0154);
8972 MP_WritePhyUshort(sc, 0x19, 0x9f00);
8973 MP_WritePhyUshort(sc, 0x15, 0x0155);
8974 MP_WritePhyUshort(sc, 0x19, 0x9d00);
8975 MP_WritePhyUshort(sc, 0x15, 0x0156);
8976 MP_WritePhyUshort(sc, 0x19, 0x7c40);
8977 MP_WritePhyUshort(sc, 0x15, 0x0157);
8978 MP_WritePhyUshort(sc, 0x19, 0x6421);
8979 MP_WritePhyUshort(sc, 0x15, 0x0158);
8980 MP_WritePhyUshort(sc, 0x19, 0x7c80);
8981 MP_WritePhyUshort(sc, 0x15, 0x0159);
8982 MP_WritePhyUshort(sc, 0x19, 0x64a1);
8983 MP_WritePhyUshort(sc, 0x15, 0x015a);
8984 MP_WritePhyUshort(sc, 0x19, 0x30fe);
8985 MP_WritePhyUshort(sc, 0x15, 0x021e);
8986 MP_WritePhyUshort(sc, 0x19, 0x5410);
8987 MP_WritePhyUshort(sc, 0x15, 0x0225);
8988 MP_WritePhyUshort(sc, 0x19, 0x5400);
8989 MP_WritePhyUshort(sc, 0x15, 0x023D);
8990 MP_WritePhyUshort(sc, 0x19, 0x4050);
8991 MP_WritePhyUshort(sc, 0x15, 0x0295);
8992 MP_WritePhyUshort(sc, 0x19, 0x6c08);
8993 MP_WritePhyUshort(sc, 0x15, 0x02bd);
8994 MP_WritePhyUshort(sc, 0x19, 0xa523);
8995 MP_WritePhyUshort(sc, 0x15, 0x02be);
8996 MP_WritePhyUshort(sc, 0x19, 0x32ca);
8997 MP_WritePhyUshort(sc, 0x15, 0x02ca);
8998 MP_WritePhyUshort(sc, 0x19, 0x48b3);
8999 MP_WritePhyUshort(sc, 0x15, 0x02cb);
9000 MP_WritePhyUshort(sc, 0x19, 0x4020);
9001 MP_WritePhyUshort(sc, 0x15, 0x02cc);
9002 MP_WritePhyUshort(sc, 0x19, 0x4823);
9003 MP_WritePhyUshort(sc, 0x15, 0x02cd);
9004 MP_WritePhyUshort(sc, 0x19, 0x4510);
9005 MP_WritePhyUshort(sc, 0x15, 0x02ce);
9006 MP_WritePhyUshort(sc, 0x19, 0xb63a);
9007 MP_WritePhyUshort(sc, 0x15, 0x02cf);
9008 MP_WritePhyUshort(sc, 0x19, 0x7dc8);
9009 MP_WritePhyUshort(sc, 0x15, 0x02d6);
9010 MP_WritePhyUshort(sc, 0x19, 0x9bf8);
9011 MP_WritePhyUshort(sc, 0x15, 0x02d8);
9012 MP_WritePhyUshort(sc, 0x19, 0x85f6);
9013 MP_WritePhyUshort(sc, 0x15, 0x02d9);
9014 MP_WritePhyUshort(sc, 0x19, 0x32e0);
9015 MP_WritePhyUshort(sc, 0x15, 0x02e0);
9016 MP_WritePhyUshort(sc, 0x19, 0x4834);
9017 MP_WritePhyUshort(sc, 0x15, 0x02e1);
9018 MP_WritePhyUshort(sc, 0x19, 0x6c08);
9019 MP_WritePhyUshort(sc, 0x15, 0x02e2);
9020 MP_WritePhyUshort(sc, 0x19, 0x4020);
9021 MP_WritePhyUshort(sc, 0x15, 0x02e3);
9022 MP_WritePhyUshort(sc, 0x19, 0x4824);
9023 MP_WritePhyUshort(sc, 0x15, 0x02e4);
9024 MP_WritePhyUshort(sc, 0x19, 0x4520);
9025 MP_WritePhyUshort(sc, 0x15, 0x02e5);
9026 MP_WritePhyUshort(sc, 0x19, 0x4008);
9027 MP_WritePhyUshort(sc, 0x15, 0x02e6);
9028 MP_WritePhyUshort(sc, 0x19, 0x4560);
9029 MP_WritePhyUshort(sc, 0x15, 0x02e7);
9030 MP_WritePhyUshort(sc, 0x19, 0x9d04);
9031 MP_WritePhyUshort(sc, 0x15, 0x02e8);
9032 MP_WritePhyUshort(sc, 0x19, 0x48c4);
9033 MP_WritePhyUshort(sc, 0x15, 0x02e9);
9034 MP_WritePhyUshort(sc, 0x19, 0x0000);
9035 MP_WritePhyUshort(sc, 0x15, 0x02ea);
9036 MP_WritePhyUshort(sc, 0x19, 0x4844);
9037 MP_WritePhyUshort(sc, 0x15, 0x02eb);
9038 MP_WritePhyUshort(sc, 0x19, 0x7dc8);
9039 MP_WritePhyUshort(sc, 0x15, 0x02f0);
9040 MP_WritePhyUshort(sc, 0x19, 0x9cf7);
9041 MP_WritePhyUshort(sc, 0x15, 0x02f1);
9042 MP_WritePhyUshort(sc, 0x19, 0xdf94);
9043 MP_WritePhyUshort(sc, 0x15, 0x02f2);
9044 MP_WritePhyUshort(sc, 0x19, 0x0002);
9045 MP_WritePhyUshort(sc, 0x15, 0x02f3);
9046 MP_WritePhyUshort(sc, 0x19, 0x6810);
9047 MP_WritePhyUshort(sc, 0x15, 0x02f4);
9048 MP_WritePhyUshort(sc, 0x19, 0xb614);
9049 MP_WritePhyUshort(sc, 0x15, 0x02f5);
9050 MP_WritePhyUshort(sc, 0x19, 0xc42b);
9051 MP_WritePhyUshort(sc, 0x15, 0x02f6);
9052 MP_WritePhyUshort(sc, 0x19, 0x00d4);
9053 MP_WritePhyUshort(sc, 0x15, 0x02f7);
9054 MP_WritePhyUshort(sc, 0x19, 0xc455);
9055 MP_WritePhyUshort(sc, 0x15, 0x02f8);
9056 MP_WritePhyUshort(sc, 0x19, 0x0093);
9057 MP_WritePhyUshort(sc, 0x15, 0x02f9);
9058 MP_WritePhyUshort(sc, 0x19, 0x92ee);
9059 MP_WritePhyUshort(sc, 0x15, 0x02fa);
9060 MP_WritePhyUshort(sc, 0x19, 0xefed);
9061 MP_WritePhyUshort(sc, 0x15, 0x02fb);
9062 MP_WritePhyUshort(sc, 0x19, 0x3312);
9063 MP_WritePhyUshort(sc, 0x15, 0x0312);
9064 MP_WritePhyUshort(sc, 0x19, 0x49b5);
9065 MP_WritePhyUshort(sc, 0x15, 0x0313);
9066 MP_WritePhyUshort(sc, 0x19, 0x7d00);
9067 MP_WritePhyUshort(sc, 0x15, 0x0314);
9068 MP_WritePhyUshort(sc, 0x19, 0x4d00);
9069 MP_WritePhyUshort(sc, 0x15, 0x0315);
9070 MP_WritePhyUshort(sc, 0x19, 0x6810);
9071 MP_WritePhyUshort(sc, 0x15, 0x031e);
9072 MP_WritePhyUshort(sc, 0x19, 0x404f);
9073 MP_WritePhyUshort(sc, 0x15, 0x031f);
9074 MP_WritePhyUshort(sc, 0x19, 0x44c8);
9075 MP_WritePhyUshort(sc, 0x15, 0x0320);
9076 MP_WritePhyUshort(sc, 0x19, 0xd64f);
9077 MP_WritePhyUshort(sc, 0x15, 0x0321);
9078 MP_WritePhyUshort(sc, 0x19, 0x00e7);
9079 MP_WritePhyUshort(sc, 0x15, 0x0322);
9080 MP_WritePhyUshort(sc, 0x19, 0x7c08);
9081 MP_WritePhyUshort(sc, 0x15, 0x0323);
9082 MP_WritePhyUshort(sc, 0x19, 0x8203);
9083 MP_WritePhyUshort(sc, 0x15, 0x0324);
9084 MP_WritePhyUshort(sc, 0x19, 0x4d48);
9085 MP_WritePhyUshort(sc, 0x15, 0x0325);
9086 MP_WritePhyUshort(sc, 0x19, 0x3327);
9087 MP_WritePhyUshort(sc, 0x15, 0x0326);
9088 MP_WritePhyUshort(sc, 0x19, 0x4d40);
9089 MP_WritePhyUshort(sc, 0x15, 0x0327);
9090 MP_WritePhyUshort(sc, 0x19, 0xc8d7);
9091 MP_WritePhyUshort(sc, 0x15, 0x0328);
9092 MP_WritePhyUshort(sc, 0x19, 0x0003);
9093 MP_WritePhyUshort(sc, 0x15, 0x0329);
9094 MP_WritePhyUshort(sc, 0x19, 0x7c20);
9095 MP_WritePhyUshort(sc, 0x15, 0x032a);
9096 MP_WritePhyUshort(sc, 0x19, 0x4c20);
9097 MP_WritePhyUshort(sc, 0x15, 0x032b);
9098 MP_WritePhyUshort(sc, 0x19, 0xc8ed);
9099 MP_WritePhyUshort(sc, 0x15, 0x032c);
9100 MP_WritePhyUshort(sc, 0x19, 0x00f4);
9101 MP_WritePhyUshort(sc, 0x15, 0x032d);
9102 MP_WritePhyUshort(sc, 0x19, 0x82b3);
9103 MP_WritePhyUshort(sc, 0x15, 0x032e);
9104 MP_WritePhyUshort(sc, 0x19, 0xd11d);
9105 MP_WritePhyUshort(sc, 0x15, 0x032f);
9106 MP_WritePhyUshort(sc, 0x19, 0x00b1);
9107 MP_WritePhyUshort(sc, 0x15, 0x0330);
9108 MP_WritePhyUshort(sc, 0x19, 0xde18);
9109 MP_WritePhyUshort(sc, 0x15, 0x0331);
9110 MP_WritePhyUshort(sc, 0x19, 0x0008);
9111 MP_WritePhyUshort(sc, 0x15, 0x0332);
9112 MP_WritePhyUshort(sc, 0x19, 0x91ee);
9113 MP_WritePhyUshort(sc, 0x15, 0x0333);
9114 MP_WritePhyUshort(sc, 0x19, 0x3339);
9115 MP_WritePhyUshort(sc, 0x15, 0x033a);
9116 MP_WritePhyUshort(sc, 0x19, 0x4064);
9117 MP_WritePhyUshort(sc, 0x15, 0x0340);
9118 MP_WritePhyUshort(sc, 0x19, 0x9e06);
9119 MP_WritePhyUshort(sc, 0x15, 0x0341);
9120 MP_WritePhyUshort(sc, 0x19, 0x7c08);
9121 MP_WritePhyUshort(sc, 0x15, 0x0342);
9122 MP_WritePhyUshort(sc, 0x19, 0x8203);
9123 MP_WritePhyUshort(sc, 0x15, 0x0343);
9124 MP_WritePhyUshort(sc, 0x19, 0x4d48);
9125 MP_WritePhyUshort(sc, 0x15, 0x0344);
9126 MP_WritePhyUshort(sc, 0x19, 0x3346);
9127 MP_WritePhyUshort(sc, 0x15, 0x0345);
9128 MP_WritePhyUshort(sc, 0x19, 0x4d40);
9129 MP_WritePhyUshort(sc, 0x15, 0x0346);
9130 MP_WritePhyUshort(sc, 0x19, 0xd11d);
9131 MP_WritePhyUshort(sc, 0x15, 0x0347);
9132 MP_WritePhyUshort(sc, 0x19, 0x0099);
9133 MP_WritePhyUshort(sc, 0x15, 0x0348);
9134 MP_WritePhyUshort(sc, 0x19, 0xbb17);
9135 MP_WritePhyUshort(sc, 0x15, 0x0349);
9136 MP_WritePhyUshort(sc, 0x19, 0x8102);
9137 MP_WritePhyUshort(sc, 0x15, 0x034a);
9138 MP_WritePhyUshort(sc, 0x19, 0x334d);
9139 MP_WritePhyUshort(sc, 0x15, 0x034b);
9140 MP_WritePhyUshort(sc, 0x19, 0xa22c);
9141 MP_WritePhyUshort(sc, 0x15, 0x034c);
9142 MP_WritePhyUshort(sc, 0x19, 0x3397);
9143 MP_WritePhyUshort(sc, 0x15, 0x034d);
9144 MP_WritePhyUshort(sc, 0x19, 0x91f2);
9145 MP_WritePhyUshort(sc, 0x15, 0x034e);
9146 MP_WritePhyUshort(sc, 0x19, 0xc218);
9147 MP_WritePhyUshort(sc, 0x15, 0x034f);
9148 MP_WritePhyUshort(sc, 0x19, 0x00f0);
9149 MP_WritePhyUshort(sc, 0x15, 0x0350);
9150 MP_WritePhyUshort(sc, 0x19, 0x3397);
9151 MP_WritePhyUshort(sc, 0x15, 0x0351);
9152 MP_WritePhyUshort(sc, 0x19, 0x0000);
9153 MP_WritePhyUshort(sc, 0x15, 0x0364);
9154 MP_WritePhyUshort(sc, 0x19, 0xbc05);
9155 MP_WritePhyUshort(sc, 0x15, 0x0367);
9156 MP_WritePhyUshort(sc, 0x19, 0xa1fc);
9157 MP_WritePhyUshort(sc, 0x15, 0x0368);
9158 MP_WritePhyUshort(sc, 0x19, 0x3377);
9159 MP_WritePhyUshort(sc, 0x15, 0x0369);
9160 MP_WritePhyUshort(sc, 0x19, 0x328b);
9161 MP_WritePhyUshort(sc, 0x15, 0x036a);
9162 MP_WritePhyUshort(sc, 0x19, 0x0000);
9163 MP_WritePhyUshort(sc, 0x15, 0x0377);
9164 MP_WritePhyUshort(sc, 0x19, 0x4b97);
9165 MP_WritePhyUshort(sc, 0x15, 0x0378);
9166 MP_WritePhyUshort(sc, 0x19, 0x6818);
9167 MP_WritePhyUshort(sc, 0x15, 0x0379);
9168 MP_WritePhyUshort(sc, 0x19, 0x4b07);
9169 MP_WritePhyUshort(sc, 0x15, 0x037a);
9170 MP_WritePhyUshort(sc, 0x19, 0x40ac);
9171 MP_WritePhyUshort(sc, 0x15, 0x037b);
9172 MP_WritePhyUshort(sc, 0x19, 0x4445);
9173 MP_WritePhyUshort(sc, 0x15, 0x037c);
9174 MP_WritePhyUshort(sc, 0x19, 0x404e);
9175 MP_WritePhyUshort(sc, 0x15, 0x037d);
9176 MP_WritePhyUshort(sc, 0x19, 0x4461);
9177 MP_WritePhyUshort(sc, 0x15, 0x037e);
9178 MP_WritePhyUshort(sc, 0x19, 0x9c09);
9179 MP_WritePhyUshort(sc, 0x15, 0x037f);
9180 MP_WritePhyUshort(sc, 0x19, 0x63da);
9181 MP_WritePhyUshort(sc, 0x15, 0x0380);
9182 MP_WritePhyUshort(sc, 0x19, 0x5440);
9183 MP_WritePhyUshort(sc, 0x15, 0x0381);
9184 MP_WritePhyUshort(sc, 0x19, 0x4b98);
9185 MP_WritePhyUshort(sc, 0x15, 0x0382);
9186 MP_WritePhyUshort(sc, 0x19, 0x7c60);
9187 MP_WritePhyUshort(sc, 0x15, 0x0383);
9188 MP_WritePhyUshort(sc, 0x19, 0x4c00);
9189 MP_WritePhyUshort(sc, 0x15, 0x0384);
9190 MP_WritePhyUshort(sc, 0x19, 0x4b08);
9191 MP_WritePhyUshort(sc, 0x15, 0x0385);
9192 MP_WritePhyUshort(sc, 0x19, 0x63d8);
9193 MP_WritePhyUshort(sc, 0x15, 0x0386);
9194 MP_WritePhyUshort(sc, 0x19, 0x338d);
9195 MP_WritePhyUshort(sc, 0x15, 0x0387);
9196 MP_WritePhyUshort(sc, 0x19, 0xd64f);
9197 MP_WritePhyUshort(sc, 0x15, 0x0388);
9198 MP_WritePhyUshort(sc, 0x19, 0x0080);
9199 MP_WritePhyUshort(sc, 0x15, 0x0389);
9200 MP_WritePhyUshort(sc, 0x19, 0x820c);
9201 MP_WritePhyUshort(sc, 0x15, 0x038a);
9202 MP_WritePhyUshort(sc, 0x19, 0xa10b);
9203 MP_WritePhyUshort(sc, 0x15, 0x038b);
9204 MP_WritePhyUshort(sc, 0x19, 0x9df3);
9205 MP_WritePhyUshort(sc, 0x15, 0x038c);
9206 MP_WritePhyUshort(sc, 0x19, 0x3395);
9207 MP_WritePhyUshort(sc, 0x15, 0x038d);
9208 MP_WritePhyUshort(sc, 0x19, 0xd64f);
9209 MP_WritePhyUshort(sc, 0x15, 0x038e);
9210 MP_WritePhyUshort(sc, 0x19, 0x00f9);
9211 MP_WritePhyUshort(sc, 0x15, 0x038f);
9212 MP_WritePhyUshort(sc, 0x19, 0xc017);
9213 MP_WritePhyUshort(sc, 0x15, 0x0390);
9214 MP_WritePhyUshort(sc, 0x19, 0x0005);
9215 MP_WritePhyUshort(sc, 0x15, 0x0391);
9216 MP_WritePhyUshort(sc, 0x19, 0x6c0b);
9217 MP_WritePhyUshort(sc, 0x15, 0x0392);
9218 MP_WritePhyUshort(sc, 0x19, 0xa103);
9219 MP_WritePhyUshort(sc, 0x15, 0x0393);
9220 MP_WritePhyUshort(sc, 0x19, 0x6c08);
9221 MP_WritePhyUshort(sc, 0x15, 0x0394);
9222 MP_WritePhyUshort(sc, 0x19, 0x9df9);
9223 MP_WritePhyUshort(sc, 0x15, 0x0395);
9224 MP_WritePhyUshort(sc, 0x19, 0x6c08);
9225 MP_WritePhyUshort(sc, 0x15, 0x0396);
9226 MP_WritePhyUshort(sc, 0x19, 0x3397);
9227 MP_WritePhyUshort(sc, 0x15, 0x0399);
9228 MP_WritePhyUshort(sc, 0x19, 0x6810);
9229 MP_WritePhyUshort(sc, 0x15, 0x03a4);
9230 MP_WritePhyUshort(sc, 0x19, 0x7c08);
9231 MP_WritePhyUshort(sc, 0x15, 0x03a5);
9232 MP_WritePhyUshort(sc, 0x19, 0x8203);
9233 MP_WritePhyUshort(sc, 0x15, 0x03a6);
9234 MP_WritePhyUshort(sc, 0x19, 0x4d08);
9235 MP_WritePhyUshort(sc, 0x15, 0x03a7);
9236 MP_WritePhyUshort(sc, 0x19, 0x33a9);
9237 MP_WritePhyUshort(sc, 0x15, 0x03a8);
9238 MP_WritePhyUshort(sc, 0x19, 0x4d00);
9239 MP_WritePhyUshort(sc, 0x15, 0x03a9);
9240 MP_WritePhyUshort(sc, 0x19, 0x9bfa);
9241 MP_WritePhyUshort(sc, 0x15, 0x03aa);
9242 MP_WritePhyUshort(sc, 0x19, 0x33b6);
9243 MP_WritePhyUshort(sc, 0x15, 0x03bb);
9244 MP_WritePhyUshort(sc, 0x19, 0x4056);
9245 MP_WritePhyUshort(sc, 0x15, 0x03bc);
9246 MP_WritePhyUshort(sc, 0x19, 0x44e9);
9247 MP_WritePhyUshort(sc, 0x15, 0x03bd);
9248 MP_WritePhyUshort(sc, 0x19, 0x405e);
9249 MP_WritePhyUshort(sc, 0x15, 0x03be);
9250 MP_WritePhyUshort(sc, 0x19, 0x44f8);
9251 MP_WritePhyUshort(sc, 0x15, 0x03bf);
9252 MP_WritePhyUshort(sc, 0x19, 0xd64f);
9253 MP_WritePhyUshort(sc, 0x15, 0x03c0);
9254 MP_WritePhyUshort(sc, 0x19, 0x0037);
9255 MP_WritePhyUshort(sc, 0x15, 0x03c1);
9256 MP_WritePhyUshort(sc, 0x19, 0xbd37);
9257 MP_WritePhyUshort(sc, 0x15, 0x03c2);
9258 MP_WritePhyUshort(sc, 0x19, 0x9cfd);
9259 MP_WritePhyUshort(sc, 0x15, 0x03c3);
9260 MP_WritePhyUshort(sc, 0x19, 0xc639);
9261 MP_WritePhyUshort(sc, 0x15, 0x03c4);
9262 MP_WritePhyUshort(sc, 0x19, 0x0011);
9263 MP_WritePhyUshort(sc, 0x15, 0x03c5);
9264 MP_WritePhyUshort(sc, 0x19, 0x9b03);
9265 MP_WritePhyUshort(sc, 0x15, 0x03c6);
9266 MP_WritePhyUshort(sc, 0x19, 0x7c01);
9267 MP_WritePhyUshort(sc, 0x15, 0x03c7);
9268 MP_WritePhyUshort(sc, 0x19, 0x4c01);
9269 MP_WritePhyUshort(sc, 0x15, 0x03c8);
9270 MP_WritePhyUshort(sc, 0x19, 0x9e03);
9271 MP_WritePhyUshort(sc, 0x15, 0x03c9);
9272 MP_WritePhyUshort(sc, 0x19, 0x7c20);
9273 MP_WritePhyUshort(sc, 0x15, 0x03ca);
9274 MP_WritePhyUshort(sc, 0x19, 0x4c20);
9275 MP_WritePhyUshort(sc, 0x15, 0x03cb);
9276 MP_WritePhyUshort(sc, 0x19, 0x9af4);
9277 MP_WritePhyUshort(sc, 0x15, 0x03cc);
9278 MP_WritePhyUshort(sc, 0x19, 0x7c12);
9279 MP_WritePhyUshort(sc, 0x15, 0x03cd);
9280 MP_WritePhyUshort(sc, 0x19, 0x4c52);
9281 MP_WritePhyUshort(sc, 0x15, 0x03ce);
9282 MP_WritePhyUshort(sc, 0x19, 0x4470);
9283 MP_WritePhyUshort(sc, 0x15, 0x03cf);
9284 MP_WritePhyUshort(sc, 0x19, 0x7c12);
9285 MP_WritePhyUshort(sc, 0x15, 0x03d0);
9286 MP_WritePhyUshort(sc, 0x19, 0x4c40);
9287 MP_WritePhyUshort(sc, 0x15, 0x03d1);
9288 MP_WritePhyUshort(sc, 0x19, 0x33bf);
9289 MP_WritePhyUshort(sc, 0x15, 0x03d6);
9290 MP_WritePhyUshort(sc, 0x19, 0x4047);
9291 MP_WritePhyUshort(sc, 0x15, 0x03d7);
9292 MP_WritePhyUshort(sc, 0x19, 0x4469);
9293 MP_WritePhyUshort(sc, 0x15, 0x03d8);
9294 MP_WritePhyUshort(sc, 0x19, 0x492b);
9295 MP_WritePhyUshort(sc, 0x15, 0x03d9);
9296 MP_WritePhyUshort(sc, 0x19, 0x4479);
9297 MP_WritePhyUshort(sc, 0x15, 0x03da);
9298 MP_WritePhyUshort(sc, 0x19, 0x7c09);
9299 MP_WritePhyUshort(sc, 0x15, 0x03db);
9300 MP_WritePhyUshort(sc, 0x19, 0x8203);
9301 MP_WritePhyUshort(sc, 0x15, 0x03dc);
9302 MP_WritePhyUshort(sc, 0x19, 0x4d48);
9303 MP_WritePhyUshort(sc, 0x15, 0x03dd);
9304 MP_WritePhyUshort(sc, 0x19, 0x33df);
9305 MP_WritePhyUshort(sc, 0x15, 0x03de);
9306 MP_WritePhyUshort(sc, 0x19, 0x4d40);
9307 MP_WritePhyUshort(sc, 0x15, 0x03df);
9308 MP_WritePhyUshort(sc, 0x19, 0xd64f);
9309 MP_WritePhyUshort(sc, 0x15, 0x03e0);
9310 MP_WritePhyUshort(sc, 0x19, 0x0017);
9311 MP_WritePhyUshort(sc, 0x15, 0x03e1);
9312 MP_WritePhyUshort(sc, 0x19, 0xbd17);
9313 MP_WritePhyUshort(sc, 0x15, 0x03e2);
9314 MP_WritePhyUshort(sc, 0x19, 0x9b03);
9315 MP_WritePhyUshort(sc, 0x15, 0x03e3);
9316 MP_WritePhyUshort(sc, 0x19, 0x7c20);
9317 MP_WritePhyUshort(sc, 0x15, 0x03e4);
9318 MP_WritePhyUshort(sc, 0x19, 0x4c20);
9319 MP_WritePhyUshort(sc, 0x15, 0x03e5);
9320 MP_WritePhyUshort(sc, 0x19, 0x88f5);
9321 MP_WritePhyUshort(sc, 0x15, 0x03e6);
9322 MP_WritePhyUshort(sc, 0x19, 0xc428);
9323 MP_WritePhyUshort(sc, 0x15, 0x03e7);
9324 MP_WritePhyUshort(sc, 0x19, 0x0008);
9325 MP_WritePhyUshort(sc, 0x15, 0x03e8);
9326 MP_WritePhyUshort(sc, 0x19, 0x9af2);
9327 MP_WritePhyUshort(sc, 0x15, 0x03e9);
9328 MP_WritePhyUshort(sc, 0x19, 0x7c12);
9329 MP_WritePhyUshort(sc, 0x15, 0x03ea);
9330 MP_WritePhyUshort(sc, 0x19, 0x4c52);
9331 MP_WritePhyUshort(sc, 0x15, 0x03eb);
9332 MP_WritePhyUshort(sc, 0x19, 0x4470);
9333 MP_WritePhyUshort(sc, 0x15, 0x03ec);
9334 MP_WritePhyUshort(sc, 0x19, 0x7c12);
9335 MP_WritePhyUshort(sc, 0x15, 0x03ed);
9336 MP_WritePhyUshort(sc, 0x19, 0x4c40);
9337 MP_WritePhyUshort(sc, 0x15, 0x03ee);
9338 MP_WritePhyUshort(sc, 0x19, 0x33da);
9339 MP_WritePhyUshort(sc, 0x15, 0x03ef);
9340 MP_WritePhyUshort(sc, 0x19, 0x3312);
9341 MP_WritePhyUshort(sc, 0x16, 0x0306);
9342 MP_WritePhyUshort(sc, 0x16, 0x0300);
9343 MP_WritePhyUshort(sc, 0x1f, 0x0000);
9344 MP_WritePhyUshort(sc, 0x17, 0x2179);
9345 MP_WritePhyUshort(sc, 0x1f, 0x0007);
9346 MP_WritePhyUshort(sc, 0x1e, 0x0040);
9347 MP_WritePhyUshort(sc, 0x18, 0x0645);
9348 MP_WritePhyUshort(sc, 0x19, 0xe200);
9349 MP_WritePhyUshort(sc, 0x18, 0x0655);
9350 MP_WritePhyUshort(sc, 0x19, 0x9000);
9351 MP_WritePhyUshort(sc, 0x18, 0x0d05);
9352 MP_WritePhyUshort(sc, 0x19, 0xbe00);
9353 MP_WritePhyUshort(sc, 0x18, 0x0d15);
9354 MP_WritePhyUshort(sc, 0x19, 0xd300);
9355 MP_WritePhyUshort(sc, 0x18, 0x0d25);
9356 MP_WritePhyUshort(sc, 0x19, 0xfe00);
9357 MP_WritePhyUshort(sc, 0x18, 0x0d35);
9358 MP_WritePhyUshort(sc, 0x19, 0x4000);
9359 MP_WritePhyUshort(sc, 0x18, 0x0d45);
9360 MP_WritePhyUshort(sc, 0x19, 0x7f00);
9361 MP_WritePhyUshort(sc, 0x18, 0x0d55);
9362 MP_WritePhyUshort(sc, 0x19, 0x1000);
9363 MP_WritePhyUshort(sc, 0x18, 0x0d65);
9364 MP_WritePhyUshort(sc, 0x19, 0x0000);
9365 MP_WritePhyUshort(sc, 0x18, 0x0d75);
9366 MP_WritePhyUshort(sc, 0x19, 0x8200);
9367 MP_WritePhyUshort(sc, 0x18, 0x0d85);
9368 MP_WritePhyUshort(sc, 0x19, 0x0000);
9369 MP_WritePhyUshort(sc, 0x18, 0x0d95);
9370 MP_WritePhyUshort(sc, 0x19, 0x7000);
9371 MP_WritePhyUshort(sc, 0x18, 0x0da5);
9372 MP_WritePhyUshort(sc, 0x19, 0x0f00);
9373 MP_WritePhyUshort(sc, 0x18, 0x0db5);
9374 MP_WritePhyUshort(sc, 0x19, 0x0100);
9375 MP_WritePhyUshort(sc, 0x18, 0x0dc5);
9376 MP_WritePhyUshort(sc, 0x19, 0x9b00);
9377 MP_WritePhyUshort(sc, 0x18, 0x0dd5);
9378 MP_WritePhyUshort(sc, 0x19, 0x7f00);
9379 MP_WritePhyUshort(sc, 0x18, 0x0de5);
9380 MP_WritePhyUshort(sc, 0x19, 0xe000);
9381 MP_WritePhyUshort(sc, 0x18, 0x0df5);
9382 MP_WritePhyUshort(sc, 0x19, 0xef00);
9383 MP_WritePhyUshort(sc, 0x18, 0x16d5);
9384 MP_WritePhyUshort(sc, 0x19, 0xe200);
9385 MP_WritePhyUshort(sc, 0x18, 0x16e5);
9386 MP_WritePhyUshort(sc, 0x19, 0xab00);
9387 MP_WritePhyUshort(sc, 0x18, 0x2904);
9388 MP_WritePhyUshort(sc, 0x19, 0x4000);
9389 MP_WritePhyUshort(sc, 0x18, 0x2914);
9390 MP_WritePhyUshort(sc, 0x19, 0x7f00);
9391 MP_WritePhyUshort(sc, 0x18, 0x2924);
9392 MP_WritePhyUshort(sc, 0x19, 0x0100);
9393 MP_WritePhyUshort(sc, 0x18, 0x2934);
9394 MP_WritePhyUshort(sc, 0x19, 0x2000);
9395 MP_WritePhyUshort(sc, 0x18, 0x2944);
9396 MP_WritePhyUshort(sc, 0x19, 0x0000);
9397 MP_WritePhyUshort(sc, 0x18, 0x2954);
9398 MP_WritePhyUshort(sc, 0x19, 0x4600);
9399 MP_WritePhyUshort(sc, 0x18, 0x2964);
9400 MP_WritePhyUshort(sc, 0x19, 0xfc00);
9401 MP_WritePhyUshort(sc, 0x18, 0x2974);
9402 MP_WritePhyUshort(sc, 0x19, 0x0000);
9403 MP_WritePhyUshort(sc, 0x18, 0x2984);
9404 MP_WritePhyUshort(sc, 0x19, 0x5000);
9405 MP_WritePhyUshort(sc, 0x18, 0x2994);
9406 MP_WritePhyUshort(sc, 0x19, 0x9d00);
9407 MP_WritePhyUshort(sc, 0x18, 0x29a4);
9408 MP_WritePhyUshort(sc, 0x19, 0xff00);
9409 MP_WritePhyUshort(sc, 0x18, 0x29b4);
9410 MP_WritePhyUshort(sc, 0x19, 0x4000);
9411 MP_WritePhyUshort(sc, 0x18, 0x29c4);
9412 MP_WritePhyUshort(sc, 0x19, 0x7f00);
9413 MP_WritePhyUshort(sc, 0x18, 0x29d4);
9414 MP_WritePhyUshort(sc, 0x19, 0x0000);
9415 MP_WritePhyUshort(sc, 0x18, 0x29e4);
9416 MP_WritePhyUshort(sc, 0x19, 0x2000);
9417 MP_WritePhyUshort(sc, 0x18, 0x29f4);
9418 MP_WritePhyUshort(sc, 0x19, 0x0000);
9419 MP_WritePhyUshort(sc, 0x18, 0x2a04);
9420 MP_WritePhyUshort(sc, 0x19, 0xe600);
9421 MP_WritePhyUshort(sc, 0x18, 0x2a14);
9422 MP_WritePhyUshort(sc, 0x19, 0xff00);
9423 MP_WritePhyUshort(sc, 0x18, 0x2a24);
9424 MP_WritePhyUshort(sc, 0x19, 0x0000);
9425 MP_WritePhyUshort(sc, 0x18, 0x2a34);
9426 MP_WritePhyUshort(sc, 0x19, 0x5000);
9427 MP_WritePhyUshort(sc, 0x18, 0x2a44);
9428 MP_WritePhyUshort(sc, 0x19, 0x8500);
9429 MP_WritePhyUshort(sc, 0x18, 0x2a54);
9430 MP_WritePhyUshort(sc, 0x19, 0x7f00);
9431 MP_WritePhyUshort(sc, 0x18, 0x2a64);
9432 MP_WritePhyUshort(sc, 0x19, 0xac00);
9433 MP_WritePhyUshort(sc, 0x18, 0x2a74);
9434 MP_WritePhyUshort(sc, 0x19, 0x0800);
9435 MP_WritePhyUshort(sc, 0x18, 0x2a84);
9436 MP_WritePhyUshort(sc, 0x19, 0xfc00);
9437 MP_WritePhyUshort(sc, 0x18, 0x2a94);
9438 MP_WritePhyUshort(sc, 0x19, 0xe000);
9439 MP_WritePhyUshort(sc, 0x18, 0x2aa4);
9440 MP_WritePhyUshort(sc, 0x19, 0x7400);
9441 MP_WritePhyUshort(sc, 0x18, 0x2ab4);
9442 MP_WritePhyUshort(sc, 0x19, 0x4000);
9443 MP_WritePhyUshort(sc, 0x18, 0x2ac4);
9444 MP_WritePhyUshort(sc, 0x19, 0x7f00);
9445 MP_WritePhyUshort(sc, 0x18, 0x2ad4);
9446 MP_WritePhyUshort(sc, 0x19, 0x0100);
9447 MP_WritePhyUshort(sc, 0x18, 0x2ae4);
9448 MP_WritePhyUshort(sc, 0x19, 0xff00);
9449 MP_WritePhyUshort(sc, 0x18, 0x2af4);
9450 MP_WritePhyUshort(sc, 0x19, 0x0000);
9451 MP_WritePhyUshort(sc, 0x18, 0x2b04);
9452 MP_WritePhyUshort(sc, 0x19, 0x4400);
9453 MP_WritePhyUshort(sc, 0x18, 0x2b14);
9454 MP_WritePhyUshort(sc, 0x19, 0xfc00);
9455 MP_WritePhyUshort(sc, 0x18, 0x2b24);
9456 MP_WritePhyUshort(sc, 0x19, 0x0000);
9457 MP_WritePhyUshort(sc, 0x18, 0x2b34);
9458 MP_WritePhyUshort(sc, 0x19, 0x4000);
9459 MP_WritePhyUshort(sc, 0x18, 0x2b44);
9460 MP_WritePhyUshort(sc, 0x19, 0x9d00);
9461 MP_WritePhyUshort(sc, 0x18, 0x2b54);
9462 MP_WritePhyUshort(sc, 0x19, 0xff00);
9463 MP_WritePhyUshort(sc, 0x18, 0x2b64);
9464 MP_WritePhyUshort(sc, 0x19, 0x4000);
9465 MP_WritePhyUshort(sc, 0x18, 0x2b74);
9466 MP_WritePhyUshort(sc, 0x19, 0x7f00);
9467 MP_WritePhyUshort(sc, 0x18, 0x2b84);
9468 MP_WritePhyUshort(sc, 0x19, 0x0000);
9469 MP_WritePhyUshort(sc, 0x18, 0x2b94);
9470 MP_WritePhyUshort(sc, 0x19, 0xff00);
9471 MP_WritePhyUshort(sc, 0x18, 0x2ba4);
9472 MP_WritePhyUshort(sc, 0x19, 0x0000);
9473 MP_WritePhyUshort(sc, 0x18, 0x2bb4);
9474 MP_WritePhyUshort(sc, 0x19, 0xfc00);
9475 MP_WritePhyUshort(sc, 0x18, 0x2bc4);
9476 MP_WritePhyUshort(sc, 0x19, 0xff00);
9477 MP_WritePhyUshort(sc, 0x18, 0x2bd4);
9478 MP_WritePhyUshort(sc, 0x19, 0x0000);
9479 MP_WritePhyUshort(sc, 0x18, 0x2be4);
9480 MP_WritePhyUshort(sc, 0x19, 0x4000);
9481 MP_WritePhyUshort(sc, 0x18, 0x2bf4);
9482 MP_WritePhyUshort(sc, 0x19, 0x8900);
9483 MP_WritePhyUshort(sc, 0x18, 0x2c04);
9484 MP_WritePhyUshort(sc, 0x19, 0x8300);
9485 MP_WritePhyUshort(sc, 0x18, 0x2c14);
9486 MP_WritePhyUshort(sc, 0x19, 0xe000);
9487 MP_WritePhyUshort(sc, 0x18, 0x2c24);
9488 MP_WritePhyUshort(sc, 0x19, 0x0000);
9489 MP_WritePhyUshort(sc, 0x18, 0x2c34);
9490 MP_WritePhyUshort(sc, 0x19, 0xac00);
9491 MP_WritePhyUshort(sc, 0x18, 0x2c44);
9492 MP_WritePhyUshort(sc, 0x19, 0x0800);
9493 MP_WritePhyUshort(sc, 0x18, 0x2c54);
9494 MP_WritePhyUshort(sc, 0x19, 0xfa00);
9495 MP_WritePhyUshort(sc, 0x18, 0x2c64);
9496 MP_WritePhyUshort(sc, 0x19, 0xe100);
9497 MP_WritePhyUshort(sc, 0x18, 0x2c74);
9498 MP_WritePhyUshort(sc, 0x19, 0x7f00);
9499 MP_WritePhyUshort(sc, 0x18, 0x0001);
9500 MP_WritePhyUshort(sc, 0x1f, 0x0000);
9501 MP_WritePhyUshort(sc, 0x17, 0x2100);
9502 MP_WritePhyUshort(sc, 0x1f, 0x0005);
9503 MP_WritePhyUshort(sc, 0x05, 0xfff6);
9504 MP_WritePhyUshort(sc, 0x06, 0x0080);
9505 MP_WritePhyUshort(sc, 0x05, 0x8b88);
9506 MP_WritePhyUshort(sc, 0x06, 0x0000);
9507 MP_WritePhyUshort(sc, 0x06, 0x0000);
9508 MP_WritePhyUshort(sc, 0x06, 0x0000);
9509 MP_WritePhyUshort(sc, 0x06, 0x0000);
9510 MP_WritePhyUshort(sc, 0x05, 0x8000);
9511 MP_WritePhyUshort(sc, 0x06, 0xd480);
9512 MP_WritePhyUshort(sc, 0x06, 0xc1e4);
9513 MP_WritePhyUshort(sc, 0x06, 0x8b9a);
9514 MP_WritePhyUshort(sc, 0x06, 0xe58b);
9515 MP_WritePhyUshort(sc, 0x06, 0x9bee);
9516 MP_WritePhyUshort(sc, 0x06, 0x8b83);
9517 MP_WritePhyUshort(sc, 0x06, 0x41bf);
9518 MP_WritePhyUshort(sc, 0x06, 0x8b88);
9519 MP_WritePhyUshort(sc, 0x06, 0xec00);
9520 MP_WritePhyUshort(sc, 0x06, 0x19a9);
9521 MP_WritePhyUshort(sc, 0x06, 0x8b90);
9522 MP_WritePhyUshort(sc, 0x06, 0xf9ee);
9523 MP_WritePhyUshort(sc, 0x06, 0xfff6);
9524 MP_WritePhyUshort(sc, 0x06, 0x00ee);
9525 MP_WritePhyUshort(sc, 0x06, 0xfff7);
9526 MP_WritePhyUshort(sc, 0x06, 0xffe0);
9527 MP_WritePhyUshort(sc, 0x06, 0xe140);
9528 MP_WritePhyUshort(sc, 0x06, 0xe1e1);
9529 MP_WritePhyUshort(sc, 0x06, 0x41f7);
9530 MP_WritePhyUshort(sc, 0x06, 0x2ff6);
9531 MP_WritePhyUshort(sc, 0x06, 0x28e4);
9532 MP_WritePhyUshort(sc, 0x06, 0xe140);
9533 MP_WritePhyUshort(sc, 0x06, 0xe5e1);
9534 MP_WritePhyUshort(sc, 0x06, 0x41f7);
9535 MP_WritePhyUshort(sc, 0x06, 0x0002);
9536 MP_WritePhyUshort(sc, 0x06, 0x020c);
9537 MP_WritePhyUshort(sc, 0x06, 0x0202);
9538 MP_WritePhyUshort(sc, 0x06, 0x1d02);
9539 MP_WritePhyUshort(sc, 0x06, 0x0230);
9540 MP_WritePhyUshort(sc, 0x06, 0x0202);
9541 MP_WritePhyUshort(sc, 0x06, 0x4002);
9542 MP_WritePhyUshort(sc, 0x06, 0x028b);
9543 MP_WritePhyUshort(sc, 0x06, 0x0280);
9544 MP_WritePhyUshort(sc, 0x06, 0x6c02);
9545 MP_WritePhyUshort(sc, 0x06, 0x8085);
9546 MP_WritePhyUshort(sc, 0x06, 0xe08b);
9547 MP_WritePhyUshort(sc, 0x06, 0x88e1);
9548 MP_WritePhyUshort(sc, 0x06, 0x8b89);
9549 MP_WritePhyUshort(sc, 0x06, 0x1e01);
9550 MP_WritePhyUshort(sc, 0x06, 0xe18b);
9551 MP_WritePhyUshort(sc, 0x06, 0x8a1e);
9552 MP_WritePhyUshort(sc, 0x06, 0x01e1);
9553 MP_WritePhyUshort(sc, 0x06, 0x8b8b);
9554 MP_WritePhyUshort(sc, 0x06, 0x1e01);
9555 MP_WritePhyUshort(sc, 0x06, 0xe18b);
9556 MP_WritePhyUshort(sc, 0x06, 0x8c1e);
9557 MP_WritePhyUshort(sc, 0x06, 0x01e1);
9558 MP_WritePhyUshort(sc, 0x06, 0x8b8d);
9559 MP_WritePhyUshort(sc, 0x06, 0x1e01);
9560 MP_WritePhyUshort(sc, 0x06, 0xe18b);
9561 MP_WritePhyUshort(sc, 0x06, 0x8e1e);
9562 MP_WritePhyUshort(sc, 0x06, 0x01a0);
9563 MP_WritePhyUshort(sc, 0x06, 0x00c7);
9564 MP_WritePhyUshort(sc, 0x06, 0xaec3);
9565 MP_WritePhyUshort(sc, 0x06, 0xf8e0);
9566 MP_WritePhyUshort(sc, 0x06, 0x8b8d);
9567 MP_WritePhyUshort(sc, 0x06, 0xad20);
9568 MP_WritePhyUshort(sc, 0x06, 0x10ee);
9569 MP_WritePhyUshort(sc, 0x06, 0x8b8d);
9570 MP_WritePhyUshort(sc, 0x06, 0x0002);
9571 MP_WritePhyUshort(sc, 0x06, 0x1310);
9572 MP_WritePhyUshort(sc, 0x06, 0x0280);
9573 MP_WritePhyUshort(sc, 0x06, 0xc602);
9574 MP_WritePhyUshort(sc, 0x06, 0x1f0c);
9575 MP_WritePhyUshort(sc, 0x06, 0x0227);
9576 MP_WritePhyUshort(sc, 0x06, 0x49fc);
9577 MP_WritePhyUshort(sc, 0x06, 0x04f8);
9578 MP_WritePhyUshort(sc, 0x06, 0xe08b);
9579 MP_WritePhyUshort(sc, 0x06, 0x8ead);
9580 MP_WritePhyUshort(sc, 0x06, 0x200b);
9581 MP_WritePhyUshort(sc, 0x06, 0xf620);
9582 MP_WritePhyUshort(sc, 0x06, 0xe48b);
9583 MP_WritePhyUshort(sc, 0x06, 0x8e02);
9584 MP_WritePhyUshort(sc, 0x06, 0x852d);
9585 MP_WritePhyUshort(sc, 0x06, 0x021b);
9586 MP_WritePhyUshort(sc, 0x06, 0x67ad);
9587 MP_WritePhyUshort(sc, 0x06, 0x2211);
9588 MP_WritePhyUshort(sc, 0x06, 0xf622);
9589 MP_WritePhyUshort(sc, 0x06, 0xe48b);
9590 MP_WritePhyUshort(sc, 0x06, 0x8e02);
9591 MP_WritePhyUshort(sc, 0x06, 0x2ba5);
9592 MP_WritePhyUshort(sc, 0x06, 0x022a);
9593 MP_WritePhyUshort(sc, 0x06, 0x2402);
9594 MP_WritePhyUshort(sc, 0x06, 0x82e5);
9595 MP_WritePhyUshort(sc, 0x06, 0x022a);
9596 MP_WritePhyUshort(sc, 0x06, 0xf0ad);
9597 MP_WritePhyUshort(sc, 0x06, 0x2511);
9598 MP_WritePhyUshort(sc, 0x06, 0xf625);
9599 MP_WritePhyUshort(sc, 0x06, 0xe48b);
9600 MP_WritePhyUshort(sc, 0x06, 0x8e02);
9601 MP_WritePhyUshort(sc, 0x06, 0x8445);
9602 MP_WritePhyUshort(sc, 0x06, 0x0204);
9603 MP_WritePhyUshort(sc, 0x06, 0x0302);
9604 MP_WritePhyUshort(sc, 0x06, 0x19cc);
9605 MP_WritePhyUshort(sc, 0x06, 0x022b);
9606 MP_WritePhyUshort(sc, 0x06, 0x5bfc);
9607 MP_WritePhyUshort(sc, 0x06, 0x04ee);
9608 MP_WritePhyUshort(sc, 0x06, 0x8b8d);
9609 MP_WritePhyUshort(sc, 0x06, 0x0105);
9610 MP_WritePhyUshort(sc, 0x06, 0xf8f9);
9611 MP_WritePhyUshort(sc, 0x06, 0xfae0);
9612 MP_WritePhyUshort(sc, 0x06, 0x8b81);
9613 MP_WritePhyUshort(sc, 0x06, 0xac26);
9614 MP_WritePhyUshort(sc, 0x06, 0x08e0);
9615 MP_WritePhyUshort(sc, 0x06, 0x8b81);
9616 MP_WritePhyUshort(sc, 0x06, 0xac21);
9617 MP_WritePhyUshort(sc, 0x06, 0x02ae);
9618 MP_WritePhyUshort(sc, 0x06, 0x6bee);
9619 MP_WritePhyUshort(sc, 0x06, 0xe0ea);
9620 MP_WritePhyUshort(sc, 0x06, 0x00ee);
9621 MP_WritePhyUshort(sc, 0x06, 0xe0eb);
9622 MP_WritePhyUshort(sc, 0x06, 0x00e2);
9623 MP_WritePhyUshort(sc, 0x06, 0xe07c);
9624 MP_WritePhyUshort(sc, 0x06, 0xe3e0);
9625 MP_WritePhyUshort(sc, 0x06, 0x7da5);
9626 MP_WritePhyUshort(sc, 0x06, 0x1111);
9627 MP_WritePhyUshort(sc, 0x06, 0x15d2);
9628 MP_WritePhyUshort(sc, 0x06, 0x60d6);
9629 MP_WritePhyUshort(sc, 0x06, 0x6666);
9630 MP_WritePhyUshort(sc, 0x06, 0x0207);
9631 MP_WritePhyUshort(sc, 0x06, 0x6cd2);
9632 MP_WritePhyUshort(sc, 0x06, 0xa0d6);
9633 MP_WritePhyUshort(sc, 0x06, 0xaaaa);
9634 MP_WritePhyUshort(sc, 0x06, 0x0207);
9635 MP_WritePhyUshort(sc, 0x06, 0x6c02);
9636 MP_WritePhyUshort(sc, 0x06, 0x201d);
9637 MP_WritePhyUshort(sc, 0x06, 0xae44);
9638 MP_WritePhyUshort(sc, 0x06, 0xa566);
9639 MP_WritePhyUshort(sc, 0x06, 0x6602);
9640 MP_WritePhyUshort(sc, 0x06, 0xae38);
9641 MP_WritePhyUshort(sc, 0x06, 0xa5aa);
9642 MP_WritePhyUshort(sc, 0x06, 0xaa02);
9643 MP_WritePhyUshort(sc, 0x06, 0xae32);
9644 MP_WritePhyUshort(sc, 0x06, 0xeee0);
9645 MP_WritePhyUshort(sc, 0x06, 0xea04);
9646 MP_WritePhyUshort(sc, 0x06, 0xeee0);
9647 MP_WritePhyUshort(sc, 0x06, 0xeb06);
9648 MP_WritePhyUshort(sc, 0x06, 0xe2e0);
9649 MP_WritePhyUshort(sc, 0x06, 0x7ce3);
9650 MP_WritePhyUshort(sc, 0x06, 0xe07d);
9651 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
9652 MP_WritePhyUshort(sc, 0x06, 0x38e1);
9653 MP_WritePhyUshort(sc, 0x06, 0xe039);
9654 MP_WritePhyUshort(sc, 0x06, 0xad2e);
9655 MP_WritePhyUshort(sc, 0x06, 0x21ad);
9656 MP_WritePhyUshort(sc, 0x06, 0x3f13);
9657 MP_WritePhyUshort(sc, 0x06, 0xe0e4);
9658 MP_WritePhyUshort(sc, 0x06, 0x14e1);
9659 MP_WritePhyUshort(sc, 0x06, 0xe415);
9660 MP_WritePhyUshort(sc, 0x06, 0x6880);
9661 MP_WritePhyUshort(sc, 0x06, 0xe4e4);
9662 MP_WritePhyUshort(sc, 0x06, 0x14e5);
9663 MP_WritePhyUshort(sc, 0x06, 0xe415);
9664 MP_WritePhyUshort(sc, 0x06, 0x0220);
9665 MP_WritePhyUshort(sc, 0x06, 0x1dae);
9666 MP_WritePhyUshort(sc, 0x06, 0x0bac);
9667 MP_WritePhyUshort(sc, 0x06, 0x3e02);
9668 MP_WritePhyUshort(sc, 0x06, 0xae06);
9669 MP_WritePhyUshort(sc, 0x06, 0x0281);
9670 MP_WritePhyUshort(sc, 0x06, 0x4602);
9671 MP_WritePhyUshort(sc, 0x06, 0x2057);
9672 MP_WritePhyUshort(sc, 0x06, 0xfefd);
9673 MP_WritePhyUshort(sc, 0x06, 0xfc04);
9674 MP_WritePhyUshort(sc, 0x06, 0xf8e0);
9675 MP_WritePhyUshort(sc, 0x06, 0x8b81);
9676 MP_WritePhyUshort(sc, 0x06, 0xad26);
9677 MP_WritePhyUshort(sc, 0x06, 0x0302);
9678 MP_WritePhyUshort(sc, 0x06, 0x20a7);
9679 MP_WritePhyUshort(sc, 0x06, 0xe08b);
9680 MP_WritePhyUshort(sc, 0x06, 0x81ad);
9681 MP_WritePhyUshort(sc, 0x06, 0x2109);
9682 MP_WritePhyUshort(sc, 0x06, 0xe08b);
9683 MP_WritePhyUshort(sc, 0x06, 0x2eac);
9684 MP_WritePhyUshort(sc, 0x06, 0x2003);
9685 MP_WritePhyUshort(sc, 0x06, 0x0281);
9686 MP_WritePhyUshort(sc, 0x06, 0x61fc);
9687 MP_WritePhyUshort(sc, 0x06, 0x04f8);
9688 MP_WritePhyUshort(sc, 0x06, 0xe08b);
9689 MP_WritePhyUshort(sc, 0x06, 0x81ac);
9690 MP_WritePhyUshort(sc, 0x06, 0x2505);
9691 MP_WritePhyUshort(sc, 0x06, 0x0222);
9692 MP_WritePhyUshort(sc, 0x06, 0xaeae);
9693 MP_WritePhyUshort(sc, 0x06, 0x0302);
9694 MP_WritePhyUshort(sc, 0x06, 0x8172);
9695 MP_WritePhyUshort(sc, 0x06, 0xfc04);
9696 MP_WritePhyUshort(sc, 0x06, 0xf8f9);
9697 MP_WritePhyUshort(sc, 0x06, 0xfaef);
9698 MP_WritePhyUshort(sc, 0x06, 0x69fa);
9699 MP_WritePhyUshort(sc, 0x06, 0xe086);
9700 MP_WritePhyUshort(sc, 0x06, 0x20a0);
9701 MP_WritePhyUshort(sc, 0x06, 0x8016);
9702 MP_WritePhyUshort(sc, 0x06, 0xe086);
9703 MP_WritePhyUshort(sc, 0x06, 0x21e1);
9704 MP_WritePhyUshort(sc, 0x06, 0x8b33);
9705 MP_WritePhyUshort(sc, 0x06, 0x1b10);
9706 MP_WritePhyUshort(sc, 0x06, 0x9e06);
9707 MP_WritePhyUshort(sc, 0x06, 0x0223);
9708 MP_WritePhyUshort(sc, 0x06, 0x91af);
9709 MP_WritePhyUshort(sc, 0x06, 0x8252);
9710 MP_WritePhyUshort(sc, 0x06, 0xee86);
9711 MP_WritePhyUshort(sc, 0x06, 0x2081);
9712 MP_WritePhyUshort(sc, 0x06, 0xaee4);
9713 MP_WritePhyUshort(sc, 0x06, 0xa081);
9714 MP_WritePhyUshort(sc, 0x06, 0x1402);
9715 MP_WritePhyUshort(sc, 0x06, 0x2399);
9716 MP_WritePhyUshort(sc, 0x06, 0xbf25);
9717 MP_WritePhyUshort(sc, 0x06, 0xcc02);
9718 MP_WritePhyUshort(sc, 0x06, 0x2d21);
9719 MP_WritePhyUshort(sc, 0x06, 0xee86);
9720 MP_WritePhyUshort(sc, 0x06, 0x2100);
9721 MP_WritePhyUshort(sc, 0x06, 0xee86);
9722 MP_WritePhyUshort(sc, 0x06, 0x2082);
9723 MP_WritePhyUshort(sc, 0x06, 0xaf82);
9724 MP_WritePhyUshort(sc, 0x06, 0x52a0);
9725 MP_WritePhyUshort(sc, 0x06, 0x8232);
9726 MP_WritePhyUshort(sc, 0x06, 0xe086);
9727 MP_WritePhyUshort(sc, 0x06, 0x21e1);
9728 MP_WritePhyUshort(sc, 0x06, 0x8b32);
9729 MP_WritePhyUshort(sc, 0x06, 0x1b10);
9730 MP_WritePhyUshort(sc, 0x06, 0x9e06);
9731 MP_WritePhyUshort(sc, 0x06, 0x0223);
9732 MP_WritePhyUshort(sc, 0x06, 0x91af);
9733 MP_WritePhyUshort(sc, 0x06, 0x8252);
9734 MP_WritePhyUshort(sc, 0x06, 0xee86);
9735 MP_WritePhyUshort(sc, 0x06, 0x2100);
9736 MP_WritePhyUshort(sc, 0x06, 0xd000);
9737 MP_WritePhyUshort(sc, 0x06, 0x0282);
9738 MP_WritePhyUshort(sc, 0x06, 0x5910);
9739 MP_WritePhyUshort(sc, 0x06, 0xa004);
9740 MP_WritePhyUshort(sc, 0x06, 0xf9e0);
9741 MP_WritePhyUshort(sc, 0x06, 0x861f);
9742 MP_WritePhyUshort(sc, 0x06, 0xa000);
9743 MP_WritePhyUshort(sc, 0x06, 0x07ee);
9744 MP_WritePhyUshort(sc, 0x06, 0x8620);
9745 MP_WritePhyUshort(sc, 0x06, 0x83af);
9746 MP_WritePhyUshort(sc, 0x06, 0x8178);
9747 MP_WritePhyUshort(sc, 0x06, 0x0224);
9748 MP_WritePhyUshort(sc, 0x06, 0x0102);
9749 MP_WritePhyUshort(sc, 0x06, 0x2399);
9750 MP_WritePhyUshort(sc, 0x06, 0xae72);
9751 MP_WritePhyUshort(sc, 0x06, 0xa083);
9752 MP_WritePhyUshort(sc, 0x06, 0x4b1f);
9753 MP_WritePhyUshort(sc, 0x06, 0x55d0);
9754 MP_WritePhyUshort(sc, 0x06, 0x04bf);
9755 MP_WritePhyUshort(sc, 0x06, 0x8615);
9756 MP_WritePhyUshort(sc, 0x06, 0x1a90);
9757 MP_WritePhyUshort(sc, 0x06, 0x0c54);
9758 MP_WritePhyUshort(sc, 0x06, 0xd91e);
9759 MP_WritePhyUshort(sc, 0x06, 0x31b0);
9760 MP_WritePhyUshort(sc, 0x06, 0xf4e0);
9761 MP_WritePhyUshort(sc, 0x06, 0xe022);
9762 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
9763 MP_WritePhyUshort(sc, 0x06, 0x23ad);
9764 MP_WritePhyUshort(sc, 0x06, 0x2e0c);
9765 MP_WritePhyUshort(sc, 0x06, 0xef02);
9766 MP_WritePhyUshort(sc, 0x06, 0xef12);
9767 MP_WritePhyUshort(sc, 0x06, 0x0e44);
9768 MP_WritePhyUshort(sc, 0x06, 0xef23);
9769 MP_WritePhyUshort(sc, 0x06, 0x0e54);
9770 MP_WritePhyUshort(sc, 0x06, 0xef21);
9771 MP_WritePhyUshort(sc, 0x06, 0xe6e4);
9772 MP_WritePhyUshort(sc, 0x06, 0x2ae7);
9773 MP_WritePhyUshort(sc, 0x06, 0xe42b);
9774 MP_WritePhyUshort(sc, 0x06, 0xe2e4);
9775 MP_WritePhyUshort(sc, 0x06, 0x28e3);
9776 MP_WritePhyUshort(sc, 0x06, 0xe429);
9777 MP_WritePhyUshort(sc, 0x06, 0x6d20);
9778 MP_WritePhyUshort(sc, 0x06, 0x00e6);
9779 MP_WritePhyUshort(sc, 0x06, 0xe428);
9780 MP_WritePhyUshort(sc, 0x06, 0xe7e4);
9781 MP_WritePhyUshort(sc, 0x06, 0x29bf);
9782 MP_WritePhyUshort(sc, 0x06, 0x25ca);
9783 MP_WritePhyUshort(sc, 0x06, 0x022d);
9784 MP_WritePhyUshort(sc, 0x06, 0x21ee);
9785 MP_WritePhyUshort(sc, 0x06, 0x8620);
9786 MP_WritePhyUshort(sc, 0x06, 0x84ee);
9787 MP_WritePhyUshort(sc, 0x06, 0x8621);
9788 MP_WritePhyUshort(sc, 0x06, 0x00af);
9789 MP_WritePhyUshort(sc, 0x06, 0x8178);
9790 MP_WritePhyUshort(sc, 0x06, 0xa084);
9791 MP_WritePhyUshort(sc, 0x06, 0x19e0);
9792 MP_WritePhyUshort(sc, 0x06, 0x8621);
9793 MP_WritePhyUshort(sc, 0x06, 0xe18b);
9794 MP_WritePhyUshort(sc, 0x06, 0x341b);
9795 MP_WritePhyUshort(sc, 0x06, 0x109e);
9796 MP_WritePhyUshort(sc, 0x06, 0x0602);
9797 MP_WritePhyUshort(sc, 0x06, 0x2391);
9798 MP_WritePhyUshort(sc, 0x06, 0xaf82);
9799 MP_WritePhyUshort(sc, 0x06, 0x5202);
9800 MP_WritePhyUshort(sc, 0x06, 0x241f);
9801 MP_WritePhyUshort(sc, 0x06, 0xee86);
9802 MP_WritePhyUshort(sc, 0x06, 0x2085);
9803 MP_WritePhyUshort(sc, 0x06, 0xae08);
9804 MP_WritePhyUshort(sc, 0x06, 0xa085);
9805 MP_WritePhyUshort(sc, 0x06, 0x02ae);
9806 MP_WritePhyUshort(sc, 0x06, 0x0302);
9807 MP_WritePhyUshort(sc, 0x06, 0x2442);
9808 MP_WritePhyUshort(sc, 0x06, 0xfeef);
9809 MP_WritePhyUshort(sc, 0x06, 0x96fe);
9810 MP_WritePhyUshort(sc, 0x06, 0xfdfc);
9811 MP_WritePhyUshort(sc, 0x06, 0x04f8);
9812 MP_WritePhyUshort(sc, 0x06, 0xf9fa);
9813 MP_WritePhyUshort(sc, 0x06, 0xef69);
9814 MP_WritePhyUshort(sc, 0x06, 0xfad1);
9815 MP_WritePhyUshort(sc, 0x06, 0x801f);
9816 MP_WritePhyUshort(sc, 0x06, 0x66e2);
9817 MP_WritePhyUshort(sc, 0x06, 0xe0ea);
9818 MP_WritePhyUshort(sc, 0x06, 0xe3e0);
9819 MP_WritePhyUshort(sc, 0x06, 0xeb5a);
9820 MP_WritePhyUshort(sc, 0x06, 0xf81e);
9821 MP_WritePhyUshort(sc, 0x06, 0x20e6);
9822 MP_WritePhyUshort(sc, 0x06, 0xe0ea);
9823 MP_WritePhyUshort(sc, 0x06, 0xe5e0);
9824 MP_WritePhyUshort(sc, 0x06, 0xebd3);
9825 MP_WritePhyUshort(sc, 0x06, 0x05b3);
9826 MP_WritePhyUshort(sc, 0x06, 0xfee2);
9827 MP_WritePhyUshort(sc, 0x06, 0xe07c);
9828 MP_WritePhyUshort(sc, 0x06, 0xe3e0);
9829 MP_WritePhyUshort(sc, 0x06, 0x7dad);
9830 MP_WritePhyUshort(sc, 0x06, 0x3703);
9831 MP_WritePhyUshort(sc, 0x06, 0x7dff);
9832 MP_WritePhyUshort(sc, 0x06, 0xff0d);
9833 MP_WritePhyUshort(sc, 0x06, 0x581c);
9834 MP_WritePhyUshort(sc, 0x06, 0x55f8);
9835 MP_WritePhyUshort(sc, 0x06, 0xef46);
9836 MP_WritePhyUshort(sc, 0x06, 0x0282);
9837 MP_WritePhyUshort(sc, 0x06, 0xc7ef);
9838 MP_WritePhyUshort(sc, 0x06, 0x65ef);
9839 MP_WritePhyUshort(sc, 0x06, 0x54fc);
9840 MP_WritePhyUshort(sc, 0x06, 0xac30);
9841 MP_WritePhyUshort(sc, 0x06, 0x2b11);
9842 MP_WritePhyUshort(sc, 0x06, 0xa188);
9843 MP_WritePhyUshort(sc, 0x06, 0xcabf);
9844 MP_WritePhyUshort(sc, 0x06, 0x860e);
9845 MP_WritePhyUshort(sc, 0x06, 0xef10);
9846 MP_WritePhyUshort(sc, 0x06, 0x0c11);
9847 MP_WritePhyUshort(sc, 0x06, 0x1a91);
9848 MP_WritePhyUshort(sc, 0x06, 0xda19);
9849 MP_WritePhyUshort(sc, 0x06, 0xdbf8);
9850 MP_WritePhyUshort(sc, 0x06, 0xef46);
9851 MP_WritePhyUshort(sc, 0x06, 0x021e);
9852 MP_WritePhyUshort(sc, 0x06, 0x17ef);
9853 MP_WritePhyUshort(sc, 0x06, 0x54fc);
9854 MP_WritePhyUshort(sc, 0x06, 0xad30);
9855 MP_WritePhyUshort(sc, 0x06, 0x0fef);
9856 MP_WritePhyUshort(sc, 0x06, 0x5689);
9857 MP_WritePhyUshort(sc, 0x06, 0xde19);
9858 MP_WritePhyUshort(sc, 0x06, 0xdfe2);
9859 MP_WritePhyUshort(sc, 0x06, 0x861f);
9860 MP_WritePhyUshort(sc, 0x06, 0xbf86);
9861 MP_WritePhyUshort(sc, 0x06, 0x161a);
9862 MP_WritePhyUshort(sc, 0x06, 0x90de);
9863 MP_WritePhyUshort(sc, 0x06, 0xfeef);
9864 MP_WritePhyUshort(sc, 0x06, 0x96fe);
9865 MP_WritePhyUshort(sc, 0x06, 0xfdfc);
9866 MP_WritePhyUshort(sc, 0x06, 0x04ac);
9867 MP_WritePhyUshort(sc, 0x06, 0x2707);
9868 MP_WritePhyUshort(sc, 0x06, 0xac37);
9869 MP_WritePhyUshort(sc, 0x06, 0x071a);
9870 MP_WritePhyUshort(sc, 0x06, 0x54ae);
9871 MP_WritePhyUshort(sc, 0x06, 0x11ac);
9872 MP_WritePhyUshort(sc, 0x06, 0x3707);
9873 MP_WritePhyUshort(sc, 0x06, 0xae00);
9874 MP_WritePhyUshort(sc, 0x06, 0x1a54);
9875 MP_WritePhyUshort(sc, 0x06, 0xac37);
9876 MP_WritePhyUshort(sc, 0x06, 0x07d0);
9877 MP_WritePhyUshort(sc, 0x06, 0x01d5);
9878 MP_WritePhyUshort(sc, 0x06, 0xffff);
9879 MP_WritePhyUshort(sc, 0x06, 0xae02);
9880 MP_WritePhyUshort(sc, 0x06, 0xd000);
9881 MP_WritePhyUshort(sc, 0x06, 0x04f8);
9882 MP_WritePhyUshort(sc, 0x06, 0xe08b);
9883 MP_WritePhyUshort(sc, 0x06, 0x83ad);
9884 MP_WritePhyUshort(sc, 0x06, 0x2444);
9885 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
9886 MP_WritePhyUshort(sc, 0x06, 0x22e1);
9887 MP_WritePhyUshort(sc, 0x06, 0xe023);
9888 MP_WritePhyUshort(sc, 0x06, 0xad22);
9889 MP_WritePhyUshort(sc, 0x06, 0x3be0);
9890 MP_WritePhyUshort(sc, 0x06, 0x8abe);
9891 MP_WritePhyUshort(sc, 0x06, 0xa000);
9892 MP_WritePhyUshort(sc, 0x06, 0x0502);
9893 MP_WritePhyUshort(sc, 0x06, 0x28de);
9894 MP_WritePhyUshort(sc, 0x06, 0xae42);
9895 MP_WritePhyUshort(sc, 0x06, 0xa001);
9896 MP_WritePhyUshort(sc, 0x06, 0x0502);
9897 MP_WritePhyUshort(sc, 0x06, 0x28f1);
9898 MP_WritePhyUshort(sc, 0x06, 0xae3a);
9899 MP_WritePhyUshort(sc, 0x06, 0xa002);
9900 MP_WritePhyUshort(sc, 0x06, 0x0502);
9901 MP_WritePhyUshort(sc, 0x06, 0x8344);
9902 MP_WritePhyUshort(sc, 0x06, 0xae32);
9903 MP_WritePhyUshort(sc, 0x06, 0xa003);
9904 MP_WritePhyUshort(sc, 0x06, 0x0502);
9905 MP_WritePhyUshort(sc, 0x06, 0x299a);
9906 MP_WritePhyUshort(sc, 0x06, 0xae2a);
9907 MP_WritePhyUshort(sc, 0x06, 0xa004);
9908 MP_WritePhyUshort(sc, 0x06, 0x0502);
9909 MP_WritePhyUshort(sc, 0x06, 0x29ae);
9910 MP_WritePhyUshort(sc, 0x06, 0xae22);
9911 MP_WritePhyUshort(sc, 0x06, 0xa005);
9912 MP_WritePhyUshort(sc, 0x06, 0x0502);
9913 MP_WritePhyUshort(sc, 0x06, 0x29d7);
9914 MP_WritePhyUshort(sc, 0x06, 0xae1a);
9915 MP_WritePhyUshort(sc, 0x06, 0xa006);
9916 MP_WritePhyUshort(sc, 0x06, 0x0502);
9917 MP_WritePhyUshort(sc, 0x06, 0x29fe);
9918 MP_WritePhyUshort(sc, 0x06, 0xae12);
9919 MP_WritePhyUshort(sc, 0x06, 0xee8a);
9920 MP_WritePhyUshort(sc, 0x06, 0xc000);
9921 MP_WritePhyUshort(sc, 0x06, 0xee8a);
9922 MP_WritePhyUshort(sc, 0x06, 0xc100);
9923 MP_WritePhyUshort(sc, 0x06, 0xee8a);
9924 MP_WritePhyUshort(sc, 0x06, 0xc600);
9925 MP_WritePhyUshort(sc, 0x06, 0xee8a);
9926 MP_WritePhyUshort(sc, 0x06, 0xbe00);
9927 MP_WritePhyUshort(sc, 0x06, 0xae00);
9928 MP_WritePhyUshort(sc, 0x06, 0xfc04);
9929 MP_WritePhyUshort(sc, 0x06, 0xf802);
9930 MP_WritePhyUshort(sc, 0x06, 0x2a67);
9931 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
9932 MP_WritePhyUshort(sc, 0x06, 0x22e1);
9933 MP_WritePhyUshort(sc, 0x06, 0xe023);
9934 MP_WritePhyUshort(sc, 0x06, 0x0d06);
9935 MP_WritePhyUshort(sc, 0x06, 0x5803);
9936 MP_WritePhyUshort(sc, 0x06, 0xa002);
9937 MP_WritePhyUshort(sc, 0x06, 0x02ae);
9938 MP_WritePhyUshort(sc, 0x06, 0x2da0);
9939 MP_WritePhyUshort(sc, 0x06, 0x0102);
9940 MP_WritePhyUshort(sc, 0x06, 0xae2d);
9941 MP_WritePhyUshort(sc, 0x06, 0xa000);
9942 MP_WritePhyUshort(sc, 0x06, 0x4de0);
9943 MP_WritePhyUshort(sc, 0x06, 0xe200);
9944 MP_WritePhyUshort(sc, 0x06, 0xe1e2);
9945 MP_WritePhyUshort(sc, 0x06, 0x01ad);
9946 MP_WritePhyUshort(sc, 0x06, 0x2444);
9947 MP_WritePhyUshort(sc, 0x06, 0xe08a);
9948 MP_WritePhyUshort(sc, 0x06, 0xc2e4);
9949 MP_WritePhyUshort(sc, 0x06, 0x8ac4);
9950 MP_WritePhyUshort(sc, 0x06, 0xe08a);
9951 MP_WritePhyUshort(sc, 0x06, 0xc3e4);
9952 MP_WritePhyUshort(sc, 0x06, 0x8ac5);
9953 MP_WritePhyUshort(sc, 0x06, 0xee8a);
9954 MP_WritePhyUshort(sc, 0x06, 0xbe03);
9955 MP_WritePhyUshort(sc, 0x06, 0xe08b);
9956 MP_WritePhyUshort(sc, 0x06, 0x83ad);
9957 MP_WritePhyUshort(sc, 0x06, 0x253a);
9958 MP_WritePhyUshort(sc, 0x06, 0xee8a);
9959 MP_WritePhyUshort(sc, 0x06, 0xbe05);
9960 MP_WritePhyUshort(sc, 0x06, 0xae34);
9961 MP_WritePhyUshort(sc, 0x06, 0xe08a);
9962 MP_WritePhyUshort(sc, 0x06, 0xceae);
9963 MP_WritePhyUshort(sc, 0x06, 0x03e0);
9964 MP_WritePhyUshort(sc, 0x06, 0x8acf);
9965 MP_WritePhyUshort(sc, 0x06, 0xe18a);
9966 MP_WritePhyUshort(sc, 0x06, 0xc249);
9967 MP_WritePhyUshort(sc, 0x06, 0x05e5);
9968 MP_WritePhyUshort(sc, 0x06, 0x8ac4);
9969 MP_WritePhyUshort(sc, 0x06, 0xe18a);
9970 MP_WritePhyUshort(sc, 0x06, 0xc349);
9971 MP_WritePhyUshort(sc, 0x06, 0x05e5);
9972 MP_WritePhyUshort(sc, 0x06, 0x8ac5);
9973 MP_WritePhyUshort(sc, 0x06, 0xee8a);
9974 MP_WritePhyUshort(sc, 0x06, 0xbe05);
9975 MP_WritePhyUshort(sc, 0x06, 0x022a);
9976 MP_WritePhyUshort(sc, 0x06, 0xb6ac);
9977 MP_WritePhyUshort(sc, 0x06, 0x2012);
9978 MP_WritePhyUshort(sc, 0x06, 0x0283);
9979 MP_WritePhyUshort(sc, 0x06, 0xbaac);
9980 MP_WritePhyUshort(sc, 0x06, 0x200c);
9981 MP_WritePhyUshort(sc, 0x06, 0xee8a);
9982 MP_WritePhyUshort(sc, 0x06, 0xc100);
9983 MP_WritePhyUshort(sc, 0x06, 0xee8a);
9984 MP_WritePhyUshort(sc, 0x06, 0xc600);
9985 MP_WritePhyUshort(sc, 0x06, 0xee8a);
9986 MP_WritePhyUshort(sc, 0x06, 0xbe02);
9987 MP_WritePhyUshort(sc, 0x06, 0xfc04);
9988 MP_WritePhyUshort(sc, 0x06, 0xd000);
9989 MP_WritePhyUshort(sc, 0x06, 0x0283);
9990 MP_WritePhyUshort(sc, 0x06, 0xcc59);
9991 MP_WritePhyUshort(sc, 0x06, 0x0f39);
9992 MP_WritePhyUshort(sc, 0x06, 0x02aa);
9993 MP_WritePhyUshort(sc, 0x06, 0x04d0);
9994 MP_WritePhyUshort(sc, 0x06, 0x01ae);
9995 MP_WritePhyUshort(sc, 0x06, 0x02d0);
9996 MP_WritePhyUshort(sc, 0x06, 0x0004);
9997 MP_WritePhyUshort(sc, 0x06, 0xf9fa);
9998 MP_WritePhyUshort(sc, 0x06, 0xe2e2);
9999 MP_WritePhyUshort(sc, 0x06, 0xd2e3);
10000 MP_WritePhyUshort(sc, 0x06, 0xe2d3);
10001 MP_WritePhyUshort(sc, 0x06, 0xf95a);
10002 MP_WritePhyUshort(sc, 0x06, 0xf7e6);
10003 MP_WritePhyUshort(sc, 0x06, 0xe2d2);
10004 MP_WritePhyUshort(sc, 0x06, 0xe7e2);
10005 MP_WritePhyUshort(sc, 0x06, 0xd3e2);
10006 MP_WritePhyUshort(sc, 0x06, 0xe02c);
10007 MP_WritePhyUshort(sc, 0x06, 0xe3e0);
10008 MP_WritePhyUshort(sc, 0x06, 0x2df9);
10009 MP_WritePhyUshort(sc, 0x06, 0x5be0);
10010 MP_WritePhyUshort(sc, 0x06, 0x1e30);
10011 MP_WritePhyUshort(sc, 0x06, 0xe6e0);
10012 MP_WritePhyUshort(sc, 0x06, 0x2ce7);
10013 MP_WritePhyUshort(sc, 0x06, 0xe02d);
10014 MP_WritePhyUshort(sc, 0x06, 0xe2e2);
10015 MP_WritePhyUshort(sc, 0x06, 0xcce3);
10016 MP_WritePhyUshort(sc, 0x06, 0xe2cd);
10017 MP_WritePhyUshort(sc, 0x06, 0xf95a);
10018 MP_WritePhyUshort(sc, 0x06, 0x0f6a);
10019 MP_WritePhyUshort(sc, 0x06, 0x50e6);
10020 MP_WritePhyUshort(sc, 0x06, 0xe2cc);
10021 MP_WritePhyUshort(sc, 0x06, 0xe7e2);
10022 MP_WritePhyUshort(sc, 0x06, 0xcde0);
10023 MP_WritePhyUshort(sc, 0x06, 0xe03c);
10024 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
10025 MP_WritePhyUshort(sc, 0x06, 0x3def);
10026 MP_WritePhyUshort(sc, 0x06, 0x64fd);
10027 MP_WritePhyUshort(sc, 0x06, 0xe0e2);
10028 MP_WritePhyUshort(sc, 0x06, 0xcce1);
10029 MP_WritePhyUshort(sc, 0x06, 0xe2cd);
10030 MP_WritePhyUshort(sc, 0x06, 0x580f);
10031 MP_WritePhyUshort(sc, 0x06, 0x5af0);
10032 MP_WritePhyUshort(sc, 0x06, 0x1e02);
10033 MP_WritePhyUshort(sc, 0x06, 0xe4e2);
10034 MP_WritePhyUshort(sc, 0x06, 0xcce5);
10035 MP_WritePhyUshort(sc, 0x06, 0xe2cd);
10036 MP_WritePhyUshort(sc, 0x06, 0xfde0);
10037 MP_WritePhyUshort(sc, 0x06, 0xe02c);
10038 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
10039 MP_WritePhyUshort(sc, 0x06, 0x2d59);
10040 MP_WritePhyUshort(sc, 0x06, 0xe05b);
10041 MP_WritePhyUshort(sc, 0x06, 0x1f1e);
10042 MP_WritePhyUshort(sc, 0x06, 0x13e4);
10043 MP_WritePhyUshort(sc, 0x06, 0xe02c);
10044 MP_WritePhyUshort(sc, 0x06, 0xe5e0);
10045 MP_WritePhyUshort(sc, 0x06, 0x2dfd);
10046 MP_WritePhyUshort(sc, 0x06, 0xe0e2);
10047 MP_WritePhyUshort(sc, 0x06, 0xd2e1);
10048 MP_WritePhyUshort(sc, 0x06, 0xe2d3);
10049 MP_WritePhyUshort(sc, 0x06, 0x58f7);
10050 MP_WritePhyUshort(sc, 0x06, 0x5a08);
10051 MP_WritePhyUshort(sc, 0x06, 0x1e02);
10052 MP_WritePhyUshort(sc, 0x06, 0xe4e2);
10053 MP_WritePhyUshort(sc, 0x06, 0xd2e5);
10054 MP_WritePhyUshort(sc, 0x06, 0xe2d3);
10055 MP_WritePhyUshort(sc, 0x06, 0xef46);
10056 MP_WritePhyUshort(sc, 0x06, 0xfefd);
10057 MP_WritePhyUshort(sc, 0x06, 0x04f8);
10058 MP_WritePhyUshort(sc, 0x06, 0xf9fa);
10059 MP_WritePhyUshort(sc, 0x06, 0xef69);
10060 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
10061 MP_WritePhyUshort(sc, 0x06, 0x22e1);
10062 MP_WritePhyUshort(sc, 0x06, 0xe023);
10063 MP_WritePhyUshort(sc, 0x06, 0x58c4);
10064 MP_WritePhyUshort(sc, 0x06, 0xe18b);
10065 MP_WritePhyUshort(sc, 0x06, 0x6e1f);
10066 MP_WritePhyUshort(sc, 0x06, 0x109e);
10067 MP_WritePhyUshort(sc, 0x06, 0x58e4);
10068 MP_WritePhyUshort(sc, 0x06, 0x8b6e);
10069 MP_WritePhyUshort(sc, 0x06, 0xad22);
10070 MP_WritePhyUshort(sc, 0x06, 0x22ac);
10071 MP_WritePhyUshort(sc, 0x06, 0x2755);
10072 MP_WritePhyUshort(sc, 0x06, 0xac26);
10073 MP_WritePhyUshort(sc, 0x06, 0x02ae);
10074 MP_WritePhyUshort(sc, 0x06, 0x1ad1);
10075 MP_WritePhyUshort(sc, 0x06, 0x06bf);
10076 MP_WritePhyUshort(sc, 0x06, 0x3bba);
10077 MP_WritePhyUshort(sc, 0x06, 0x022d);
10078 MP_WritePhyUshort(sc, 0x06, 0xc1d1);
10079 MP_WritePhyUshort(sc, 0x06, 0x07bf);
10080 MP_WritePhyUshort(sc, 0x06, 0x3bbd);
10081 MP_WritePhyUshort(sc, 0x06, 0x022d);
10082 MP_WritePhyUshort(sc, 0x06, 0xc1d1);
10083 MP_WritePhyUshort(sc, 0x06, 0x07bf);
10084 MP_WritePhyUshort(sc, 0x06, 0x3bc0);
10085 MP_WritePhyUshort(sc, 0x06, 0x022d);
10086 MP_WritePhyUshort(sc, 0x06, 0xc1ae);
10087 MP_WritePhyUshort(sc, 0x06, 0x30d1);
10088 MP_WritePhyUshort(sc, 0x06, 0x03bf);
10089 MP_WritePhyUshort(sc, 0x06, 0x3bc3);
10090 MP_WritePhyUshort(sc, 0x06, 0x022d);
10091 MP_WritePhyUshort(sc, 0x06, 0xc1d1);
10092 MP_WritePhyUshort(sc, 0x06, 0x00bf);
10093 MP_WritePhyUshort(sc, 0x06, 0x3bc6);
10094 MP_WritePhyUshort(sc, 0x06, 0x022d);
10095 MP_WritePhyUshort(sc, 0x06, 0xc1d1);
10096 MP_WritePhyUshort(sc, 0x06, 0x00bf);
10097 MP_WritePhyUshort(sc, 0x06, 0x84e9);
10098 MP_WritePhyUshort(sc, 0x06, 0x022d);
10099 MP_WritePhyUshort(sc, 0x06, 0xc1d1);
10100 MP_WritePhyUshort(sc, 0x06, 0x0fbf);
10101 MP_WritePhyUshort(sc, 0x06, 0x3bba);
10102 MP_WritePhyUshort(sc, 0x06, 0x022d);
10103 MP_WritePhyUshort(sc, 0x06, 0xc1d1);
10104 MP_WritePhyUshort(sc, 0x06, 0x01bf);
10105 MP_WritePhyUshort(sc, 0x06, 0x3bbd);
10106 MP_WritePhyUshort(sc, 0x06, 0x022d);
10107 MP_WritePhyUshort(sc, 0x06, 0xc1d1);
10108 MP_WritePhyUshort(sc, 0x06, 0x01bf);
10109 MP_WritePhyUshort(sc, 0x06, 0x3bc0);
10110 MP_WritePhyUshort(sc, 0x06, 0x022d);
10111 MP_WritePhyUshort(sc, 0x06, 0xc1ef);
10112 MP_WritePhyUshort(sc, 0x06, 0x96fe);
10113 MP_WritePhyUshort(sc, 0x06, 0xfdfc);
10114 MP_WritePhyUshort(sc, 0x06, 0x04d1);
10115 MP_WritePhyUshort(sc, 0x06, 0x00bf);
10116 MP_WritePhyUshort(sc, 0x06, 0x3bc3);
10117 MP_WritePhyUshort(sc, 0x06, 0x022d);
10118 MP_WritePhyUshort(sc, 0x06, 0xc1d0);
10119 MP_WritePhyUshort(sc, 0x06, 0x1102);
10120 MP_WritePhyUshort(sc, 0x06, 0x2bfb);
10121 MP_WritePhyUshort(sc, 0x06, 0x5903);
10122 MP_WritePhyUshort(sc, 0x06, 0xef01);
10123 MP_WritePhyUshort(sc, 0x06, 0xd100);
10124 MP_WritePhyUshort(sc, 0x06, 0xa000);
10125 MP_WritePhyUshort(sc, 0x06, 0x02d1);
10126 MP_WritePhyUshort(sc, 0x06, 0x01bf);
10127 MP_WritePhyUshort(sc, 0x06, 0x3bc6);
10128 MP_WritePhyUshort(sc, 0x06, 0x022d);
10129 MP_WritePhyUshort(sc, 0x06, 0xc1d1);
10130 MP_WritePhyUshort(sc, 0x06, 0x11ad);
10131 MP_WritePhyUshort(sc, 0x06, 0x2002);
10132 MP_WritePhyUshort(sc, 0x06, 0x0c11);
10133 MP_WritePhyUshort(sc, 0x06, 0xad21);
10134 MP_WritePhyUshort(sc, 0x06, 0x020c);
10135 MP_WritePhyUshort(sc, 0x06, 0x12bf);
10136 MP_WritePhyUshort(sc, 0x06, 0x84e9);
10137 MP_WritePhyUshort(sc, 0x06, 0x022d);
10138 MP_WritePhyUshort(sc, 0x06, 0xc1ae);
10139 MP_WritePhyUshort(sc, 0x06, 0xc870);
10140 MP_WritePhyUshort(sc, 0x06, 0xe426);
10141 MP_WritePhyUshort(sc, 0x06, 0x0284);
10142 MP_WritePhyUshort(sc, 0x06, 0xf005);
10143 MP_WritePhyUshort(sc, 0x06, 0xf8fa);
10144 MP_WritePhyUshort(sc, 0x06, 0xef69);
10145 MP_WritePhyUshort(sc, 0x06, 0xe0e2);
10146 MP_WritePhyUshort(sc, 0x06, 0xfee1);
10147 MP_WritePhyUshort(sc, 0x06, 0xe2ff);
10148 MP_WritePhyUshort(sc, 0x06, 0xad2d);
10149 MP_WritePhyUshort(sc, 0x06, 0x1ae0);
10150 MP_WritePhyUshort(sc, 0x06, 0xe14e);
10151 MP_WritePhyUshort(sc, 0x06, 0xe1e1);
10152 MP_WritePhyUshort(sc, 0x06, 0x4fac);
10153 MP_WritePhyUshort(sc, 0x06, 0x2d22);
10154 MP_WritePhyUshort(sc, 0x06, 0xf603);
10155 MP_WritePhyUshort(sc, 0x06, 0x0203);
10156 MP_WritePhyUshort(sc, 0x06, 0x3bf7);
10157 MP_WritePhyUshort(sc, 0x06, 0x03f7);
10158 MP_WritePhyUshort(sc, 0x06, 0x06bf);
10159 MP_WritePhyUshort(sc, 0x06, 0x85c4);
10160 MP_WritePhyUshort(sc, 0x06, 0x022d);
10161 MP_WritePhyUshort(sc, 0x06, 0x21ae);
10162 MP_WritePhyUshort(sc, 0x06, 0x11e0);
10163 MP_WritePhyUshort(sc, 0x06, 0xe14e);
10164 MP_WritePhyUshort(sc, 0x06, 0xe1e1);
10165 MP_WritePhyUshort(sc, 0x06, 0x4fad);
10166 MP_WritePhyUshort(sc, 0x06, 0x2d08);
10167 MP_WritePhyUshort(sc, 0x06, 0xbf85);
10168 MP_WritePhyUshort(sc, 0x06, 0xcf02);
10169 MP_WritePhyUshort(sc, 0x06, 0x2d21);
10170 MP_WritePhyUshort(sc, 0x06, 0xf606);
10171 MP_WritePhyUshort(sc, 0x06, 0xef96);
10172 MP_WritePhyUshort(sc, 0x06, 0xfefc);
10173 MP_WritePhyUshort(sc, 0x06, 0x04f8);
10174 MP_WritePhyUshort(sc, 0x06, 0xfaef);
10175 MP_WritePhyUshort(sc, 0x06, 0x6902);
10176 MP_WritePhyUshort(sc, 0x06, 0x8561);
10177 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
10178 MP_WritePhyUshort(sc, 0x06, 0x00e1);
10179 MP_WritePhyUshort(sc, 0x06, 0xe001);
10180 MP_WritePhyUshort(sc, 0x06, 0xad27);
10181 MP_WritePhyUshort(sc, 0x06, 0x1fd1);
10182 MP_WritePhyUshort(sc, 0x06, 0x01bf);
10183 MP_WritePhyUshort(sc, 0x06, 0x85be);
10184 MP_WritePhyUshort(sc, 0x06, 0x022d);
10185 MP_WritePhyUshort(sc, 0x06, 0xc1e0);
10186 MP_WritePhyUshort(sc, 0x06, 0xe020);
10187 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
10188 MP_WritePhyUshort(sc, 0x06, 0x21ad);
10189 MP_WritePhyUshort(sc, 0x06, 0x200e);
10190 MP_WritePhyUshort(sc, 0x06, 0xd100);
10191 MP_WritePhyUshort(sc, 0x06, 0xbf85);
10192 MP_WritePhyUshort(sc, 0x06, 0xbe02);
10193 MP_WritePhyUshort(sc, 0x06, 0x2dc1);
10194 MP_WritePhyUshort(sc, 0x06, 0xbf3b);
10195 MP_WritePhyUshort(sc, 0x06, 0x9602);
10196 MP_WritePhyUshort(sc, 0x06, 0x2d21);
10197 MP_WritePhyUshort(sc, 0x06, 0xef96);
10198 MP_WritePhyUshort(sc, 0x06, 0xfefc);
10199 MP_WritePhyUshort(sc, 0x06, 0x04f8);
10200 MP_WritePhyUshort(sc, 0x06, 0xf9fa);
10201 MP_WritePhyUshort(sc, 0x06, 0xef69);
10202 MP_WritePhyUshort(sc, 0x06, 0xe08b);
10203 MP_WritePhyUshort(sc, 0x06, 0x87ad);
10204 MP_WritePhyUshort(sc, 0x06, 0x204c);
10205 MP_WritePhyUshort(sc, 0x06, 0xd200);
10206 MP_WritePhyUshort(sc, 0x06, 0xe0e2);
10207 MP_WritePhyUshort(sc, 0x06, 0x0058);
10208 MP_WritePhyUshort(sc, 0x06, 0x010c);
10209 MP_WritePhyUshort(sc, 0x06, 0x021e);
10210 MP_WritePhyUshort(sc, 0x06, 0x20e0);
10211 MP_WritePhyUshort(sc, 0x06, 0xe000);
10212 MP_WritePhyUshort(sc, 0x06, 0x5810);
10213 MP_WritePhyUshort(sc, 0x06, 0x1e20);
10214 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
10215 MP_WritePhyUshort(sc, 0x06, 0x3658);
10216 MP_WritePhyUshort(sc, 0x06, 0x031e);
10217 MP_WritePhyUshort(sc, 0x06, 0x20e0);
10218 MP_WritePhyUshort(sc, 0x06, 0xe022);
10219 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
10220 MP_WritePhyUshort(sc, 0x06, 0x2358);
10221 MP_WritePhyUshort(sc, 0x06, 0xe01e);
10222 MP_WritePhyUshort(sc, 0x06, 0x20e0);
10223 MP_WritePhyUshort(sc, 0x06, 0x8b64);
10224 MP_WritePhyUshort(sc, 0x06, 0x1f02);
10225 MP_WritePhyUshort(sc, 0x06, 0x9e22);
10226 MP_WritePhyUshort(sc, 0x06, 0xe68b);
10227 MP_WritePhyUshort(sc, 0x06, 0x64ad);
10228 MP_WritePhyUshort(sc, 0x06, 0x3214);
10229 MP_WritePhyUshort(sc, 0x06, 0xad34);
10230 MP_WritePhyUshort(sc, 0x06, 0x11ef);
10231 MP_WritePhyUshort(sc, 0x06, 0x0258);
10232 MP_WritePhyUshort(sc, 0x06, 0x039e);
10233 MP_WritePhyUshort(sc, 0x06, 0x07ad);
10234 MP_WritePhyUshort(sc, 0x06, 0x3508);
10235 MP_WritePhyUshort(sc, 0x06, 0x5ac0);
10236 MP_WritePhyUshort(sc, 0x06, 0x9f04);
10237 MP_WritePhyUshort(sc, 0x06, 0xd101);
10238 MP_WritePhyUshort(sc, 0x06, 0xae02);
10239 MP_WritePhyUshort(sc, 0x06, 0xd100);
10240 MP_WritePhyUshort(sc, 0x06, 0xbf85);
10241 MP_WritePhyUshort(sc, 0x06, 0xc102);
10242 MP_WritePhyUshort(sc, 0x06, 0x2dc1);
10243 MP_WritePhyUshort(sc, 0x06, 0xef96);
10244 MP_WritePhyUshort(sc, 0x06, 0xfefd);
10245 MP_WritePhyUshort(sc, 0x06, 0xfc04);
10246 MP_WritePhyUshort(sc, 0x06, 0x00e2);
10247 MP_WritePhyUshort(sc, 0x06, 0x34cc);
10248 MP_WritePhyUshort(sc, 0x06, 0xe200);
10249 MP_WritePhyUshort(sc, 0x06, 0xa725);
10250 MP_WritePhyUshort(sc, 0x06, 0xe50a);
10251 MP_WritePhyUshort(sc, 0x06, 0x1de5);
10252 MP_WritePhyUshort(sc, 0x06, 0x0a2c);
10253 MP_WritePhyUshort(sc, 0x06, 0xe50a);
10254 MP_WritePhyUshort(sc, 0x06, 0x6de5);
10255 MP_WritePhyUshort(sc, 0x06, 0x0a1d);
10256 MP_WritePhyUshort(sc, 0x06, 0xe50a);
10257 MP_WritePhyUshort(sc, 0x06, 0x1ce5);
10258 MP_WritePhyUshort(sc, 0x06, 0x0a2d);
10259 MP_WritePhyUshort(sc, 0x06, 0xa755);
10260 MP_WritePhyUshort(sc, 0x05, 0x8b64);
10261 MP_WritePhyUshort(sc, 0x06, 0x0000);
10262 MP_WritePhyUshort(sc, 0x05, 0x8b94);
10263 MP_WritePhyUshort(sc, 0x06, 0x84ec);
10264 Data = MP_ReadPhyUshort(sc, 0x01);
10265 Data |= 0x0001;
10266 MP_WritePhyUshort(sc, 0x01, Data);
10267 MP_WritePhyUshort(sc, 0x00, 0x0005);
10268 MP_WritePhyUshort(sc, 0x1f, 0x0000);
10269 MP_WritePhyUshort(sc, 0x1f, 0x0005);
10270 for (i = 0; i < 200; i++) {
10271 DELAY(100);
10272 Data = MP_ReadPhyUshort(sc, 0x00);
10273 if (Data & 0x0080)
10274 break;
10275 }
10276 MP_WritePhyUshort(sc, 0x1f, 0x0007);
10277 MP_WritePhyUshort(sc, 0x1e, 0x0023);
10278 MP_WritePhyUshort(sc, 0x17, 0x0116);
10279 MP_WritePhyUshort(sc, 0x1f, 0x0007);
10280 MP_WritePhyUshort(sc, 0x1e, 0x0028);
10281 MP_WritePhyUshort(sc, 0x15, 0x0010);
10282 MP_WritePhyUshort(sc, 0x1f, 0x0007);
10283 //MP_WritePhyUshort(sc, 0x1e, 0x0020);
10284 //MP_WritePhyUshort(sc, 0x15, 0x0100);
10285 MP_WritePhyUshort(sc, 0x1f, 0x0007);
10286 MP_WritePhyUshort(sc, 0x1e, 0x0041);
10287 MP_WritePhyUshort(sc, 0x15, 0x0802);
10288 MP_WritePhyUshort(sc, 0x16, 0x2185);
10289 MP_WritePhyUshort(sc, 0x1f, 0x0000);
10290 } else if (sc->re_type == MACFG_37) {
10291 MP_WritePhyUshort(sc, 0x1f, 0x0000);
10292 MP_WritePhyUshort(sc, 0x00, 0x1800);
10293 MP_WritePhyUshort(sc, 0x1f, 0x0007);
10294 MP_WritePhyUshort(sc, 0x1e, 0x0023);
10295 MP_WritePhyUshort(sc, 0x17, 0x0117);
10296 MP_WritePhyUshort(sc, 0x1f, 0x0007);
10297 MP_WritePhyUshort(sc, 0x1E, 0x002C);
10298 MP_WritePhyUshort(sc, 0x1B, 0x5000);
10299 MP_WritePhyUshort(sc, 0x1f, 0x0000);
10300 MP_WritePhyUshort(sc, 0x16, 0x4104);
10301 for (i=0; i<200; i++) {
10302 DELAY(100);
10303 Data = MP_ReadPhyUshort(sc, 0x1E);
10304 Data &= 0x03FF;
10305 if (Data== 0x000C)
10306 break;
10307 }
10308 MP_WritePhyUshort(sc, 0x1f, 0x0005);
10309 for (i=0; i<200; i++) {
10310 DELAY(100);
10311 Data = MP_ReadPhyUshort(sc, 0x07);
10312 if ((Data&0x0020)==0)
10313 break;
10314 }
10315 Data = MP_ReadPhyUshort(sc, 0x07);
10316 if (Data & 0x0020) {
10317 MP_WritePhyUshort(sc, 0x1f, 0x0007);
10318 MP_WritePhyUshort(sc, 0x1e, 0x00a1);
10319 MP_WritePhyUshort(sc, 0x17, 0x1000);
10320 MP_WritePhyUshort(sc, 0x17, 0x0000);
10321 MP_WritePhyUshort(sc, 0x17, 0x2000);
10322 MP_WritePhyUshort(sc, 0x1e, 0x002f);
10323 MP_WritePhyUshort(sc, 0x18, 0x9bfb);
10324 MP_WritePhyUshort(sc, 0x1f, 0x0005);
10325 MP_WritePhyUshort(sc, 0x07, 0x0000);
10326 MP_WritePhyUshort(sc, 0x1f, 0x0000);
10327 }
10328 MP_WritePhyUshort(sc, 0x1f, 0x0005);
10329 MP_WritePhyUshort(sc, 0x05, 0xfff6);
10330 MP_WritePhyUshort(sc, 0x06, 0x0080);
10331 Data = MP_ReadPhyUshort(sc, 0x00);
10332 Data &= ~0x0080;
10333 MP_WritePhyUshort(sc, 0x00, Data);
10334 MP_WritePhyUshort(sc, 0x1f, 0x0002);
10335 Data = MP_ReadPhyUshort(sc, 0x08);
10336 Data &= ~0x0080;
10337 MP_WritePhyUshort(sc, 0x08, Data);
10338 MP_WritePhyUshort(sc, 0x1f, 0x0000);
10339 MP_WritePhyUshort(sc, 0x1f, 0x0007);
10340 MP_WritePhyUshort(sc, 0x1e, 0x0023);
10341 MP_WritePhyUshort(sc, 0x16, 0x0306);
10342 MP_WritePhyUshort(sc, 0x16, 0x0307);
10343 MP_WritePhyUshort(sc, 0x15, 0x000e);
10344 MP_WritePhyUshort(sc, 0x19, 0x000a);
10345 MP_WritePhyUshort(sc, 0x15, 0x0010);
10346 MP_WritePhyUshort(sc, 0x19, 0x0008);
10347 MP_WritePhyUshort(sc, 0x15, 0x0018);
10348 MP_WritePhyUshort(sc, 0x19, 0x4801);
10349 MP_WritePhyUshort(sc, 0x15, 0x0019);
10350 MP_WritePhyUshort(sc, 0x19, 0x6801);
10351 MP_WritePhyUshort(sc, 0x15, 0x001a);
10352 MP_WritePhyUshort(sc, 0x19, 0x66a1);
10353 MP_WritePhyUshort(sc, 0x15, 0x001f);
10354 MP_WritePhyUshort(sc, 0x19, 0x0000);
10355 MP_WritePhyUshort(sc, 0x15, 0x0020);
10356 MP_WritePhyUshort(sc, 0x19, 0x0000);
10357 MP_WritePhyUshort(sc, 0x15, 0x0021);
10358 MP_WritePhyUshort(sc, 0x19, 0x0000);
10359 MP_WritePhyUshort(sc, 0x15, 0x0022);
10360 MP_WritePhyUshort(sc, 0x19, 0x0000);
10361 MP_WritePhyUshort(sc, 0x15, 0x0023);
10362 MP_WritePhyUshort(sc, 0x19, 0x0000);
10363 MP_WritePhyUshort(sc, 0x15, 0x0024);
10364 MP_WritePhyUshort(sc, 0x19, 0x0000);
10365 MP_WritePhyUshort(sc, 0x15, 0x0025);
10366 MP_WritePhyUshort(sc, 0x19, 0x64a1);
10367 MP_WritePhyUshort(sc, 0x15, 0x0026);
10368 MP_WritePhyUshort(sc, 0x19, 0x40ea);
10369 MP_WritePhyUshort(sc, 0x15, 0x0027);
10370 MP_WritePhyUshort(sc, 0x19, 0x4503);
10371 MP_WritePhyUshort(sc, 0x15, 0x0028);
10372 MP_WritePhyUshort(sc, 0x19, 0x9f00);
10373 MP_WritePhyUshort(sc, 0x15, 0x0029);
10374 MP_WritePhyUshort(sc, 0x19, 0xa631);
10375 MP_WritePhyUshort(sc, 0x15, 0x002a);
10376 MP_WritePhyUshort(sc, 0x19, 0x9717);
10377 MP_WritePhyUshort(sc, 0x15, 0x002b);
10378 MP_WritePhyUshort(sc, 0x19, 0x302c);
10379 MP_WritePhyUshort(sc, 0x15, 0x002c);
10380 MP_WritePhyUshort(sc, 0x19, 0x4802);
10381 MP_WritePhyUshort(sc, 0x15, 0x002d);
10382 MP_WritePhyUshort(sc, 0x19, 0x58da);
10383 MP_WritePhyUshort(sc, 0x15, 0x002e);
10384 MP_WritePhyUshort(sc, 0x19, 0x400d);
10385 MP_WritePhyUshort(sc, 0x15, 0x002f);
10386 MP_WritePhyUshort(sc, 0x19, 0x4488);
10387 MP_WritePhyUshort(sc, 0x15, 0x0030);
10388 MP_WritePhyUshort(sc, 0x19, 0x9e00);
10389 MP_WritePhyUshort(sc, 0x15, 0x0031);
10390 MP_WritePhyUshort(sc, 0x19, 0x63c8);
10391 MP_WritePhyUshort(sc, 0x15, 0x0032);
10392 MP_WritePhyUshort(sc, 0x19, 0x6481);
10393 MP_WritePhyUshort(sc, 0x15, 0x0033);
10394 MP_WritePhyUshort(sc, 0x19, 0x0000);
10395 MP_WritePhyUshort(sc, 0x15, 0x0034);
10396 MP_WritePhyUshort(sc, 0x19, 0x0000);
10397 MP_WritePhyUshort(sc, 0x15, 0x0035);
10398 MP_WritePhyUshort(sc, 0x19, 0x0000);
10399 MP_WritePhyUshort(sc, 0x15, 0x0036);
10400 MP_WritePhyUshort(sc, 0x19, 0x0000);
10401 MP_WritePhyUshort(sc, 0x15, 0x0037);
10402 MP_WritePhyUshort(sc, 0x19, 0x0000);
10403 MP_WritePhyUshort(sc, 0x15, 0x0038);
10404 MP_WritePhyUshort(sc, 0x19, 0x0000);
10405 MP_WritePhyUshort(sc, 0x15, 0x0039);
10406 MP_WritePhyUshort(sc, 0x19, 0x0000);
10407 MP_WritePhyUshort(sc, 0x15, 0x003a);
10408 MP_WritePhyUshort(sc, 0x19, 0x0000);
10409 MP_WritePhyUshort(sc, 0x15, 0x003b);
10410 MP_WritePhyUshort(sc, 0x19, 0x63e8);
10411 MP_WritePhyUshort(sc, 0x15, 0x003c);
10412 MP_WritePhyUshort(sc, 0x19, 0x7d00);
10413 MP_WritePhyUshort(sc, 0x15, 0x003d);
10414 MP_WritePhyUshort(sc, 0x19, 0x59d4);
10415 MP_WritePhyUshort(sc, 0x15, 0x003e);
10416 MP_WritePhyUshort(sc, 0x19, 0x63f8);
10417 MP_WritePhyUshort(sc, 0x15, 0x0040);
10418 MP_WritePhyUshort(sc, 0x19, 0x64a1);
10419 MP_WritePhyUshort(sc, 0x15, 0x0041);
10420 MP_WritePhyUshort(sc, 0x19, 0x30de);
10421 MP_WritePhyUshort(sc, 0x15, 0x0044);
10422 MP_WritePhyUshort(sc, 0x19, 0x480f);
10423 MP_WritePhyUshort(sc, 0x15, 0x0045);
10424 MP_WritePhyUshort(sc, 0x19, 0x6800);
10425 MP_WritePhyUshort(sc, 0x15, 0x0046);
10426 MP_WritePhyUshort(sc, 0x19, 0x6680);
10427 MP_WritePhyUshort(sc, 0x15, 0x0047);
10428 MP_WritePhyUshort(sc, 0x19, 0x7c10);
10429 MP_WritePhyUshort(sc, 0x15, 0x0048);
10430 MP_WritePhyUshort(sc, 0x19, 0x63c8);
10431 MP_WritePhyUshort(sc, 0x15, 0x0049);
10432 MP_WritePhyUshort(sc, 0x19, 0x0000);
10433 MP_WritePhyUshort(sc, 0x15, 0x004a);
10434 MP_WritePhyUshort(sc, 0x19, 0x0000);
10435 MP_WritePhyUshort(sc, 0x15, 0x004b);
10436 MP_WritePhyUshort(sc, 0x19, 0x0000);
10437 MP_WritePhyUshort(sc, 0x15, 0x004c);
10438 MP_WritePhyUshort(sc, 0x19, 0x0000);
10439 MP_WritePhyUshort(sc, 0x15, 0x004d);
10440 MP_WritePhyUshort(sc, 0x19, 0x0000);
10441 MP_WritePhyUshort(sc, 0x15, 0x004e);
10442 MP_WritePhyUshort(sc, 0x19, 0x0000);
10443 MP_WritePhyUshort(sc, 0x15, 0x004f);
10444 MP_WritePhyUshort(sc, 0x19, 0x40ea);
10445 MP_WritePhyUshort(sc, 0x15, 0x0050);
10446 MP_WritePhyUshort(sc, 0x19, 0x4503);
10447 MP_WritePhyUshort(sc, 0x15, 0x0051);
10448 MP_WritePhyUshort(sc, 0x19, 0x58ca);
10449 MP_WritePhyUshort(sc, 0x15, 0x0052);
10450 MP_WritePhyUshort(sc, 0x19, 0x63c8);
10451 MP_WritePhyUshort(sc, 0x15, 0x0053);
10452 MP_WritePhyUshort(sc, 0x19, 0x63d8);
10453 MP_WritePhyUshort(sc, 0x15, 0x0054);
10454 MP_WritePhyUshort(sc, 0x19, 0x66a0);
10455 MP_WritePhyUshort(sc, 0x15, 0x0055);
10456 MP_WritePhyUshort(sc, 0x19, 0x9f00);
10457 MP_WritePhyUshort(sc, 0x15, 0x0056);
10458 MP_WritePhyUshort(sc, 0x19, 0x3000);
10459 MP_WritePhyUshort(sc, 0x15, 0x00a1);
10460 MP_WritePhyUshort(sc, 0x19, 0x3044);
10461 MP_WritePhyUshort(sc, 0x15, 0x00ab);
10462 MP_WritePhyUshort(sc, 0x19, 0x5820);
10463 MP_WritePhyUshort(sc, 0x15, 0x00ac);
10464 MP_WritePhyUshort(sc, 0x19, 0x5e04);
10465 MP_WritePhyUshort(sc, 0x15, 0x00ad);
10466 MP_WritePhyUshort(sc, 0x19, 0xb60c);
10467 MP_WritePhyUshort(sc, 0x15, 0x00af);
10468 MP_WritePhyUshort(sc, 0x19, 0x000a);
10469 MP_WritePhyUshort(sc, 0x15, 0x00b2);
10470 MP_WritePhyUshort(sc, 0x19, 0x30b9);
10471 MP_WritePhyUshort(sc, 0x15, 0x00b9);
10472 MP_WritePhyUshort(sc, 0x19, 0x4408);
10473 MP_WritePhyUshort(sc, 0x15, 0x00ba);
10474 MP_WritePhyUshort(sc, 0x19, 0x480b);
10475 MP_WritePhyUshort(sc, 0x15, 0x00bb);
10476 MP_WritePhyUshort(sc, 0x19, 0x5e00);
10477 MP_WritePhyUshort(sc, 0x15, 0x00bc);
10478 MP_WritePhyUshort(sc, 0x19, 0x405f);
10479 MP_WritePhyUshort(sc, 0x15, 0x00bd);
10480 MP_WritePhyUshort(sc, 0x19, 0x4448);
10481 MP_WritePhyUshort(sc, 0x15, 0x00be);
10482 MP_WritePhyUshort(sc, 0x19, 0x4020);
10483 MP_WritePhyUshort(sc, 0x15, 0x00bf);
10484 MP_WritePhyUshort(sc, 0x19, 0x4468);
10485 MP_WritePhyUshort(sc, 0x15, 0x00c0);
10486 MP_WritePhyUshort(sc, 0x19, 0x9c02);
10487 MP_WritePhyUshort(sc, 0x15, 0x00c1);
10488 MP_WritePhyUshort(sc, 0x19, 0x58a0);
10489 MP_WritePhyUshort(sc, 0x15, 0x00c2);
10490 MP_WritePhyUshort(sc, 0x19, 0xb605);
10491 MP_WritePhyUshort(sc, 0x15, 0x00c3);
10492 MP_WritePhyUshort(sc, 0x19, 0xc0d3);
10493 MP_WritePhyUshort(sc, 0x15, 0x00c4);
10494 MP_WritePhyUshort(sc, 0x19, 0x00e6);
10495 MP_WritePhyUshort(sc, 0x15, 0x00c5);
10496 MP_WritePhyUshort(sc, 0x19, 0xdaec);
10497 MP_WritePhyUshort(sc, 0x15, 0x00c6);
10498 MP_WritePhyUshort(sc, 0x19, 0x00fa);
10499 MP_WritePhyUshort(sc, 0x15, 0x00c7);
10500 MP_WritePhyUshort(sc, 0x19, 0x9df9);
10501 MP_WritePhyUshort(sc, 0x15, 0x0112);
10502 MP_WritePhyUshort(sc, 0x19, 0x6421);
10503 MP_WritePhyUshort(sc, 0x15, 0x0113);
10504 MP_WritePhyUshort(sc, 0x19, 0x7c08);
10505 MP_WritePhyUshort(sc, 0x15, 0x0114);
10506 MP_WritePhyUshort(sc, 0x19, 0x63f0);
10507 MP_WritePhyUshort(sc, 0x15, 0x0115);
10508 MP_WritePhyUshort(sc, 0x19, 0x4003);
10509 MP_WritePhyUshort(sc, 0x15, 0x0116);
10510 MP_WritePhyUshort(sc, 0x19, 0x4418);
10511 MP_WritePhyUshort(sc, 0x15, 0x0117);
10512 MP_WritePhyUshort(sc, 0x19, 0x9b00);
10513 MP_WritePhyUshort(sc, 0x15, 0x0118);
10514 MP_WritePhyUshort(sc, 0x19, 0x6461);
10515 MP_WritePhyUshort(sc, 0x15, 0x0119);
10516 MP_WritePhyUshort(sc, 0x19, 0x64e1);
10517 MP_WritePhyUshort(sc, 0x15, 0x011a);
10518 MP_WritePhyUshort(sc, 0x19, 0x0000);
10519 MP_WritePhyUshort(sc, 0x15, 0x0150);
10520 MP_WritePhyUshort(sc, 0x19, 0x7c80);
10521 MP_WritePhyUshort(sc, 0x15, 0x0151);
10522 MP_WritePhyUshort(sc, 0x19, 0x6461);
10523 MP_WritePhyUshort(sc, 0x15, 0x0152);
10524 MP_WritePhyUshort(sc, 0x19, 0x4003);
10525 MP_WritePhyUshort(sc, 0x15, 0x0153);
10526 MP_WritePhyUshort(sc, 0x19, 0x4540);
10527 MP_WritePhyUshort(sc, 0x15, 0x0154);
10528 MP_WritePhyUshort(sc, 0x19, 0x9f00);
10529 MP_WritePhyUshort(sc, 0x15, 0x0155);
10530 MP_WritePhyUshort(sc, 0x19, 0x9d00);
10531 MP_WritePhyUshort(sc, 0x15, 0x0156);
10532 MP_WritePhyUshort(sc, 0x19, 0x7c40);
10533 MP_WritePhyUshort(sc, 0x15, 0x0157);
10534 MP_WritePhyUshort(sc, 0x19, 0x6421);
10535 MP_WritePhyUshort(sc, 0x15, 0x0158);
10536 MP_WritePhyUshort(sc, 0x19, 0x7c80);
10537 MP_WritePhyUshort(sc, 0x15, 0x0159);
10538 MP_WritePhyUshort(sc, 0x19, 0x64a1);
10539 MP_WritePhyUshort(sc, 0x15, 0x015a);
10540 MP_WritePhyUshort(sc, 0x19, 0x30fe);
10541 MP_WritePhyUshort(sc, 0x15, 0x02e7);
10542 MP_WritePhyUshort(sc, 0x19, 0x0000);
10543 MP_WritePhyUshort(sc, 0x15, 0x0329);
10544 MP_WritePhyUshort(sc, 0x19, 0x7c00);
10545 MP_WritePhyUshort(sc, 0x15, 0x0382);
10546 MP_WritePhyUshort(sc, 0x19, 0x7c40);
10547 MP_WritePhyUshort(sc, 0x15, 0x03bd);
10548 MP_WritePhyUshort(sc, 0x19, 0x405e);
10549 MP_WritePhyUshort(sc, 0x15, 0x03c9);
10550 MP_WritePhyUshort(sc, 0x19, 0x7c00);
10551 MP_WritePhyUshort(sc, 0x15, 0x03e3);
10552 MP_WritePhyUshort(sc, 0x19, 0x7c00);
10553 MP_WritePhyUshort(sc, 0x16, 0x0306);
10554 MP_WritePhyUshort(sc, 0x16, 0x0300);
10555 MP_WritePhyUshort(sc, 0x1f, 0x0005);
10556 MP_WritePhyUshort(sc, 0x05, 0xfff6);
10557 MP_WritePhyUshort(sc, 0x06, 0x0080);
10558 MP_WritePhyUshort(sc, 0x05, 0x8000);
10559 MP_WritePhyUshort(sc, 0x06, 0x0280);
10560 MP_WritePhyUshort(sc, 0x06, 0x48f7);
10561 MP_WritePhyUshort(sc, 0x06, 0x00e0);
10562 MP_WritePhyUshort(sc, 0x06, 0xfff7);
10563 MP_WritePhyUshort(sc, 0x06, 0xa080);
10564 MP_WritePhyUshort(sc, 0x06, 0x02ae);
10565 MP_WritePhyUshort(sc, 0x06, 0xf602);
10566 MP_WritePhyUshort(sc, 0x06, 0x0200);
10567 MP_WritePhyUshort(sc, 0x06, 0x0202);
10568 MP_WritePhyUshort(sc, 0x06, 0x1102);
10569 MP_WritePhyUshort(sc, 0x06, 0x0224);
10570 MP_WritePhyUshort(sc, 0x06, 0x0202);
10571 MP_WritePhyUshort(sc, 0x06, 0x3402);
10572 MP_WritePhyUshort(sc, 0x06, 0x027f);
10573 MP_WritePhyUshort(sc, 0x06, 0x0202);
10574 MP_WritePhyUshort(sc, 0x06, 0x9202);
10575 MP_WritePhyUshort(sc, 0x06, 0x8078);
10576 MP_WritePhyUshort(sc, 0x06, 0xe08b);
10577 MP_WritePhyUshort(sc, 0x06, 0x88e1);
10578 MP_WritePhyUshort(sc, 0x06, 0x8b89);
10579 MP_WritePhyUshort(sc, 0x06, 0x1e01);
10580 MP_WritePhyUshort(sc, 0x06, 0xe18b);
10581 MP_WritePhyUshort(sc, 0x06, 0x8a1e);
10582 MP_WritePhyUshort(sc, 0x06, 0x01e1);
10583 MP_WritePhyUshort(sc, 0x06, 0x8b8b);
10584 MP_WritePhyUshort(sc, 0x06, 0x1e01);
10585 MP_WritePhyUshort(sc, 0x06, 0xe18b);
10586 MP_WritePhyUshort(sc, 0x06, 0x8c1e);
10587 MP_WritePhyUshort(sc, 0x06, 0x01e1);
10588 MP_WritePhyUshort(sc, 0x06, 0x8b8d);
10589 MP_WritePhyUshort(sc, 0x06, 0x1e01);
10590 MP_WritePhyUshort(sc, 0x06, 0xe18b);
10591 MP_WritePhyUshort(sc, 0x06, 0x8e1e);
10592 MP_WritePhyUshort(sc, 0x06, 0x01a0);
10593 MP_WritePhyUshort(sc, 0x06, 0x00c7);
10594 MP_WritePhyUshort(sc, 0x06, 0xaebb);
10595 MP_WritePhyUshort(sc, 0x06, 0xee85);
10596 MP_WritePhyUshort(sc, 0x06, 0x0000);
10597 MP_WritePhyUshort(sc, 0x06, 0xd480);
10598 MP_WritePhyUshort(sc, 0x06, 0xebe4);
10599 MP_WritePhyUshort(sc, 0x06, 0x8b94);
10600 MP_WritePhyUshort(sc, 0x06, 0xe58b);
10601 MP_WritePhyUshort(sc, 0x06, 0x95bf);
10602 MP_WritePhyUshort(sc, 0x06, 0x8b88);
10603 MP_WritePhyUshort(sc, 0x06, 0xec00);
10604 MP_WritePhyUshort(sc, 0x06, 0x19a9);
10605 MP_WritePhyUshort(sc, 0x06, 0x8b90);
10606 MP_WritePhyUshort(sc, 0x06, 0xf9ee);
10607 MP_WritePhyUshort(sc, 0x06, 0xfff6);
10608 MP_WritePhyUshort(sc, 0x06, 0x00ee);
10609 MP_WritePhyUshort(sc, 0x06, 0xfff7);
10610 MP_WritePhyUshort(sc, 0x06, 0xffe0);
10611 MP_WritePhyUshort(sc, 0x06, 0xe140);
10612 MP_WritePhyUshort(sc, 0x06, 0xe1e1);
10613 MP_WritePhyUshort(sc, 0x06, 0x41f7);
10614 MP_WritePhyUshort(sc, 0x06, 0x2ff6);
10615 MP_WritePhyUshort(sc, 0x06, 0x28e4);
10616 MP_WritePhyUshort(sc, 0x06, 0xe140);
10617 MP_WritePhyUshort(sc, 0x06, 0xe5e1);
10618 MP_WritePhyUshort(sc, 0x06, 0x4104);
10619 MP_WritePhyUshort(sc, 0x06, 0xf8e0);
10620 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
10621 MP_WritePhyUshort(sc, 0x06, 0xad20);
10622 MP_WritePhyUshort(sc, 0x06, 0x11f6);
10623 MP_WritePhyUshort(sc, 0x06, 0x20e4);
10624 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
10625 MP_WritePhyUshort(sc, 0x06, 0x0280);
10626 MP_WritePhyUshort(sc, 0x06, 0xba02);
10627 MP_WritePhyUshort(sc, 0x06, 0x1bf4);
10628 MP_WritePhyUshort(sc, 0x06, 0x022c);
10629 MP_WritePhyUshort(sc, 0x06, 0x9c02);
10630 MP_WritePhyUshort(sc, 0x06, 0x812c);
10631 MP_WritePhyUshort(sc, 0x06, 0xad22);
10632 MP_WritePhyUshort(sc, 0x06, 0x11f6);
10633 MP_WritePhyUshort(sc, 0x06, 0x22e4);
10634 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
10635 MP_WritePhyUshort(sc, 0x06, 0x022c);
10636 MP_WritePhyUshort(sc, 0x06, 0x4602);
10637 MP_WritePhyUshort(sc, 0x06, 0x2ac5);
10638 MP_WritePhyUshort(sc, 0x06, 0x0229);
10639 MP_WritePhyUshort(sc, 0x06, 0x2002);
10640 MP_WritePhyUshort(sc, 0x06, 0x2b91);
10641 MP_WritePhyUshort(sc, 0x06, 0xad25);
10642 MP_WritePhyUshort(sc, 0x06, 0x11f6);
10643 MP_WritePhyUshort(sc, 0x06, 0x25e4);
10644 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
10645 MP_WritePhyUshort(sc, 0x06, 0x0203);
10646 MP_WritePhyUshort(sc, 0x06, 0x5a02);
10647 MP_WritePhyUshort(sc, 0x06, 0x043a);
10648 MP_WritePhyUshort(sc, 0x06, 0x021a);
10649 MP_WritePhyUshort(sc, 0x06, 0x5902);
10650 MP_WritePhyUshort(sc, 0x06, 0x2bfc);
10651 MP_WritePhyUshort(sc, 0x06, 0xfc04);
10652 MP_WritePhyUshort(sc, 0x06, 0xf8fa);
10653 MP_WritePhyUshort(sc, 0x06, 0xef69);
10654 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
10655 MP_WritePhyUshort(sc, 0x06, 0x00e1);
10656 MP_WritePhyUshort(sc, 0x06, 0xe001);
10657 MP_WritePhyUshort(sc, 0x06, 0xad27);
10658 MP_WritePhyUshort(sc, 0x06, 0x1fd1);
10659 MP_WritePhyUshort(sc, 0x06, 0x01bf);
10660 MP_WritePhyUshort(sc, 0x06, 0x819f);
10661 MP_WritePhyUshort(sc, 0x06, 0x022f);
10662 MP_WritePhyUshort(sc, 0x06, 0x50e0);
10663 MP_WritePhyUshort(sc, 0x06, 0xe020);
10664 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
10665 MP_WritePhyUshort(sc, 0x06, 0x21ad);
10666 MP_WritePhyUshort(sc, 0x06, 0x200e);
10667 MP_WritePhyUshort(sc, 0x06, 0xd100);
10668 MP_WritePhyUshort(sc, 0x06, 0xbf81);
10669 MP_WritePhyUshort(sc, 0x06, 0x9f02);
10670 MP_WritePhyUshort(sc, 0x06, 0x2f50);
10671 MP_WritePhyUshort(sc, 0x06, 0xbf3d);
10672 MP_WritePhyUshort(sc, 0x06, 0x3902);
10673 MP_WritePhyUshort(sc, 0x06, 0x2eb0);
10674 MP_WritePhyUshort(sc, 0x06, 0xef96);
10675 MP_WritePhyUshort(sc, 0x06, 0xfefc);
10676 MP_WritePhyUshort(sc, 0x06, 0x0402);
10677 MP_WritePhyUshort(sc, 0x06, 0x80ef);
10678 MP_WritePhyUshort(sc, 0x06, 0x05f8);
10679 MP_WritePhyUshort(sc, 0x06, 0xfaef);
10680 MP_WritePhyUshort(sc, 0x06, 0x69e0);
10681 MP_WritePhyUshort(sc, 0x06, 0xe2fe);
10682 MP_WritePhyUshort(sc, 0x06, 0xe1e2);
10683 MP_WritePhyUshort(sc, 0x06, 0xffad);
10684 MP_WritePhyUshort(sc, 0x06, 0x2d1a);
10685 MP_WritePhyUshort(sc, 0x06, 0xe0e1);
10686 MP_WritePhyUshort(sc, 0x06, 0x4ee1);
10687 MP_WritePhyUshort(sc, 0x06, 0xe14f);
10688 MP_WritePhyUshort(sc, 0x06, 0xac2d);
10689 MP_WritePhyUshort(sc, 0x06, 0x22f6);
10690 MP_WritePhyUshort(sc, 0x06, 0x0302);
10691 MP_WritePhyUshort(sc, 0x06, 0x0336);
10692 MP_WritePhyUshort(sc, 0x06, 0xf703);
10693 MP_WritePhyUshort(sc, 0x06, 0xf706);
10694 MP_WritePhyUshort(sc, 0x06, 0xbf81);
10695 MP_WritePhyUshort(sc, 0x06, 0x8902);
10696 MP_WritePhyUshort(sc, 0x06, 0x2eb0);
10697 MP_WritePhyUshort(sc, 0x06, 0xae11);
10698 MP_WritePhyUshort(sc, 0x06, 0xe0e1);
10699 MP_WritePhyUshort(sc, 0x06, 0x4ee1);
10700 MP_WritePhyUshort(sc, 0x06, 0xe14f);
10701 MP_WritePhyUshort(sc, 0x06, 0xad2d);
10702 MP_WritePhyUshort(sc, 0x06, 0x08bf);
10703 MP_WritePhyUshort(sc, 0x06, 0x8194);
10704 MP_WritePhyUshort(sc, 0x06, 0x022e);
10705 MP_WritePhyUshort(sc, 0x06, 0xb0f6);
10706 MP_WritePhyUshort(sc, 0x06, 0x06ef);
10707 MP_WritePhyUshort(sc, 0x06, 0x96fe);
10708 MP_WritePhyUshort(sc, 0x06, 0xfc04);
10709 MP_WritePhyUshort(sc, 0x06, 0xf8f9);
10710 MP_WritePhyUshort(sc, 0x06, 0xfaef);
10711 MP_WritePhyUshort(sc, 0x06, 0x69e0);
10712 MP_WritePhyUshort(sc, 0x06, 0x8b87);
10713 MP_WritePhyUshort(sc, 0x06, 0xad20);
10714 MP_WritePhyUshort(sc, 0x06, 0x4cd2);
10715 MP_WritePhyUshort(sc, 0x06, 0x00e0);
10716 MP_WritePhyUshort(sc, 0x06, 0xe200);
10717 MP_WritePhyUshort(sc, 0x06, 0x5801);
10718 MP_WritePhyUshort(sc, 0x06, 0x0c02);
10719 MP_WritePhyUshort(sc, 0x06, 0x1e20);
10720 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
10721 MP_WritePhyUshort(sc, 0x06, 0x0058);
10722 MP_WritePhyUshort(sc, 0x06, 0x101e);
10723 MP_WritePhyUshort(sc, 0x06, 0x20e0);
10724 MP_WritePhyUshort(sc, 0x06, 0xe036);
10725 MP_WritePhyUshort(sc, 0x06, 0x5803);
10726 MP_WritePhyUshort(sc, 0x06, 0x1e20);
10727 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
10728 MP_WritePhyUshort(sc, 0x06, 0x22e1);
10729 MP_WritePhyUshort(sc, 0x06, 0xe023);
10730 MP_WritePhyUshort(sc, 0x06, 0x58e0);
10731 MP_WritePhyUshort(sc, 0x06, 0x1e20);
10732 MP_WritePhyUshort(sc, 0x06, 0xe085);
10733 MP_WritePhyUshort(sc, 0x06, 0x001f);
10734 MP_WritePhyUshort(sc, 0x06, 0x029e);
10735 MP_WritePhyUshort(sc, 0x06, 0x22e6);
10736 MP_WritePhyUshort(sc, 0x06, 0x8500);
10737 MP_WritePhyUshort(sc, 0x06, 0xad32);
10738 MP_WritePhyUshort(sc, 0x06, 0x14ad);
10739 MP_WritePhyUshort(sc, 0x06, 0x3411);
10740 MP_WritePhyUshort(sc, 0x06, 0xef02);
10741 MP_WritePhyUshort(sc, 0x06, 0x5803);
10742 MP_WritePhyUshort(sc, 0x06, 0x9e07);
10743 MP_WritePhyUshort(sc, 0x06, 0xad35);
10744 MP_WritePhyUshort(sc, 0x06, 0x085a);
10745 MP_WritePhyUshort(sc, 0x06, 0xc09f);
10746 MP_WritePhyUshort(sc, 0x06, 0x04d1);
10747 MP_WritePhyUshort(sc, 0x06, 0x01ae);
10748 MP_WritePhyUshort(sc, 0x06, 0x02d1);
10749 MP_WritePhyUshort(sc, 0x06, 0x00bf);
10750 MP_WritePhyUshort(sc, 0x06, 0x81a5);
10751 MP_WritePhyUshort(sc, 0x06, 0x022f);
10752 MP_WritePhyUshort(sc, 0x06, 0x50ef);
10753 MP_WritePhyUshort(sc, 0x06, 0x96fe);
10754 MP_WritePhyUshort(sc, 0x06, 0xfdfc);
10755 MP_WritePhyUshort(sc, 0x06, 0x04a7);
10756 MP_WritePhyUshort(sc, 0x06, 0x25e5);
10757 MP_WritePhyUshort(sc, 0x06, 0x0a1d);
10758 MP_WritePhyUshort(sc, 0x06, 0xe50a);
10759 MP_WritePhyUshort(sc, 0x06, 0x2ce5);
10760 MP_WritePhyUshort(sc, 0x06, 0x0a6d);
10761 MP_WritePhyUshort(sc, 0x06, 0xe50a);
10762 MP_WritePhyUshort(sc, 0x06, 0x1de5);
10763 MP_WritePhyUshort(sc, 0x06, 0x0a1c);
10764 MP_WritePhyUshort(sc, 0x06, 0xe50a);
10765 MP_WritePhyUshort(sc, 0x06, 0x2da7);
10766 MP_WritePhyUshort(sc, 0x06, 0x5500);
10767 MP_WritePhyUshort(sc, 0x06, 0xe234);
10768 MP_WritePhyUshort(sc, 0x06, 0x88e2);
10769 MP_WritePhyUshort(sc, 0x06, 0x00cc);
10770 MP_WritePhyUshort(sc, 0x06, 0xe200);
10771 MP_WritePhyUshort(sc, 0x05, 0x8b86);
10772 MP_WritePhyUshort(sc, 0x06, 0x0001);
10773 Data = MP_ReadPhyUshort(sc, 0x01);
10774 Data |= 0x0001;
10775 MP_WritePhyUshort(sc, 0x01, Data);
10776 MP_WritePhyUshort(sc, 0x00, 0x0005);
10777 MP_WritePhyUshort(sc, 0x1f, 0x0000);
10778 MP_WritePhyUshort(sc, 0x1f, 0x0000);
10779 MP_WritePhyUshort(sc, 0x17, 0x2179);
10780 MP_WritePhyUshort(sc, 0x1f, 0x0001);
10781 MP_WritePhyUshort(sc, 0x10, 0xf274);
10782 MP_WritePhyUshort(sc, 0x1f, 0x0007);
10783 MP_WritePhyUshort(sc, 0x1e, 0x0042);
10784 MP_WritePhyUshort(sc, 0x15, 0x0f00);
10785 MP_WritePhyUshort(sc, 0x15, 0x0f00);
10786 MP_WritePhyUshort(sc, 0x16, 0x7408);
10787 MP_WritePhyUshort(sc, 0x15, 0x0e00);
10788 MP_WritePhyUshort(sc, 0x15, 0x0f00);
10789 MP_WritePhyUshort(sc, 0x15, 0x0f01);
10790 MP_WritePhyUshort(sc, 0x16, 0x4000);
10791 MP_WritePhyUshort(sc, 0x15, 0x0e01);
10792 MP_WritePhyUshort(sc, 0x15, 0x0f01);
10793 MP_WritePhyUshort(sc, 0x15, 0x0f02);
10794 MP_WritePhyUshort(sc, 0x16, 0x9400);
10795 MP_WritePhyUshort(sc, 0x15, 0x0e02);
10796 MP_WritePhyUshort(sc, 0x15, 0x0f02);
10797 MP_WritePhyUshort(sc, 0x15, 0x0f03);
10798 MP_WritePhyUshort(sc, 0x16, 0x7408);
10799 MP_WritePhyUshort(sc, 0x15, 0x0e03);
10800 MP_WritePhyUshort(sc, 0x15, 0x0f03);
10801 MP_WritePhyUshort(sc, 0x15, 0x0f04);
10802 MP_WritePhyUshort(sc, 0x16, 0x4008);
10803 MP_WritePhyUshort(sc, 0x15, 0x0e04);
10804 MP_WritePhyUshort(sc, 0x15, 0x0f04);
10805 MP_WritePhyUshort(sc, 0x15, 0x0f05);
10806 MP_WritePhyUshort(sc, 0x16, 0x9400);
10807 MP_WritePhyUshort(sc, 0x15, 0x0e05);
10808 MP_WritePhyUshort(sc, 0x15, 0x0f05);
10809 MP_WritePhyUshort(sc, 0x15, 0x0f06);
10810 MP_WritePhyUshort(sc, 0x16, 0x0803);
10811 MP_WritePhyUshort(sc, 0x15, 0x0e06);
10812 MP_WritePhyUshort(sc, 0x15, 0x0f06);
10813 MP_WritePhyUshort(sc, 0x15, 0x0d00);
10814 MP_WritePhyUshort(sc, 0x15, 0x0100);
10815 MP_WritePhyUshort(sc, 0x1f, 0x0001);
10816 MP_WritePhyUshort(sc, 0x10, 0xf074);
10817 MP_WritePhyUshort(sc, 0x1f, 0x0000);
10818 MP_WritePhyUshort(sc, 0x17, 0x2149);
10819 MP_WritePhyUshort(sc, 0x1f, 0x0005);
10820 for (i=0; i<200; i++) {
10821 DELAY(100);
10822 Data = MP_ReadPhyUshort(sc, 0x00);
10823 if (Data&0x0080)
10824 break;
10825 }
10826 MP_WritePhyUshort(sc, 0x1f, 0x0007);
10827 MP_WritePhyUshort(sc, 0x1e, 0x0023);
10828 MP_WritePhyUshort(sc, 0x17, 0x0116);
10829 MP_WritePhyUshort(sc, 0x1f, 0x0000);
10830 MP_WritePhyUshort(sc, 0x1f, 0x0007);
10831 MP_WritePhyUshort(sc, 0x1e, 0x0023);
10832 Data = MP_ReadPhyUshort(sc, 0x17);
10833 Data |= 0x4000;
10834 MP_WritePhyUshort(sc, 0x17, Data);
10835 MP_WritePhyUshort(sc, 0x1e, 0x0020);
10836 Data = MP_ReadPhyUshort(sc, 0x1b);
10837 Data |= 0x0080;
10838 MP_WritePhyUshort(sc, 0x1b, Data);
10839 MP_WritePhyUshort(sc, 0x1e, 0x0041);
10840 MP_WritePhyUshort(sc, 0x15, 0x0e02);
10841 MP_WritePhyUshort(sc, 0x1e, 0x0028);
10842 Data = MP_ReadPhyUshort(sc, 0x19);
10843 Data |= 0x8000;
10844 MP_WritePhyUshort(sc, 0x19, Data);
10845 MP_WritePhyUshort(sc, 0x1f, 0x0000);
10846 }
10847
10848 MP_WritePhyUshort(sc, 0x1F, 0x0007);
10849 MP_WritePhyUshort(sc, 0x1E, 0x0023);
10850 Data = MP_ReadPhyUshort(sc, 0x17) | 0x0006;
10851 MP_WritePhyUshort(sc, 0x17, Data);
10852 MP_WritePhyUshort(sc, 0x1F, 0x0000);
10853
10854 MP_WritePhyUshort(sc, 0x1f, 0x0005);
10855 MP_WritePhyUshort(sc, 0x05, 0x8b80);
10856 MP_WritePhyUshort(sc, 0x06, 0xc896);
10857 MP_WritePhyUshort(sc, 0x1f, 0x0000);
10858
10859 MP_WritePhyUshort(sc, 0x1F, 0x0001);
10860 MP_WritePhyUshort(sc, 0x0B, 0x6C20);
10861 MP_WritePhyUshort(sc, 0x07, 0x2872);
10862 MP_WritePhyUshort(sc, 0x1C, 0xEFFF);
10863 MP_WritePhyUshort(sc, 0x1F, 0x0003);
10864 MP_WritePhyUshort(sc, 0x14, 0x6420);
10865 MP_WritePhyUshort(sc, 0x1F, 0x0000);
10866
10867 MP_WritePhyUshort(sc, 0x1F, 0x0002);
10868 Data = MP_ReadPhyUshort(sc, 0x08) & 0x00FF;
10869 MP_WritePhyUshort(sc, 0x08, Data | 0x8000);
10870
10871 MP_WritePhyUshort(sc, 0x1F, 0x0007);
10872 MP_WritePhyUshort(sc, 0x1E, 0x002D);
10873 Data = MP_ReadPhyUshort(sc, 0x18);
10874 MP_WritePhyUshort(sc, 0x18, Data | 0x0050);
10875 MP_WritePhyUshort(sc, 0x1F, 0x0000);
10876 Data = MP_ReadPhyUshort(sc, 0x14);
10877 MP_WritePhyUshort(sc, 0x14, Data | 0x8000);
10878
10879 MP_WritePhyUshort(sc, 0x1F, 0x0002);
10880 MP_WritePhyUshort(sc, 0x00, 0x080B);
10881 MP_WritePhyUshort(sc, 0x0B, 0x09D7);
10882 MP_WritePhyUshort(sc, 0x1f, 0x0000);
10883 MP_WritePhyUshort(sc, 0x15, 0x1006);
10884
10885 MP_WritePhyUshort(sc, 0x1F, 0x0007);
10886 MP_WritePhyUshort(sc, 0x1E, 0x002F);
10887 MP_WritePhyUshort(sc, 0x15, 0x1919);
10888 MP_WritePhyUshort(sc, 0x1F, 0x0000);
10889
10890 MP_WritePhyUshort(sc, 0x1F, 0x0003);
10891 MP_WritePhyUshort(sc, 0x19, 0x7F46);
10892 MP_WritePhyUshort(sc, 0x1F, 0x0005);
10893 MP_WritePhyUshort(sc, 0x05, 0x8AD2);
10894 MP_WritePhyUshort(sc, 0x06, 0x6810);
10895 MP_WritePhyUshort(sc, 0x05, 0x8AD4);
10896 MP_WritePhyUshort(sc, 0x06, 0x8002);
10897 MP_WritePhyUshort(sc, 0x05, 0x8ADE);
10898 MP_WritePhyUshort(sc, 0x06, 0x8025);
10899 MP_WritePhyUshort(sc, 0x1F, 0x0000);
10900 } else if (sc->re_type == MACFG_38) {
10901 CSR_WRITE_1(sc, 0x6E, CSR_READ_1(sc, 0x6E)| (1<<6));
10902
10903 Data_u32 = re_eri_read(sc, 0x1D0, 4, ERIAR_ExGMAC);
10904 Data_u32 &= ~BIT_1;
10905 re_eri_write(sc, 0x1D0, 4, Data_u32, ERIAR_ExGMAC);
10906
10907 MP_WritePhyUshort(sc, 0x1f, 0x0000);
10908 MP_WritePhyUshort(sc, 0x00, 0x1800);
10909 Data= MP_ReadPhyUshort(sc, 0x15);
10910 Data &= ~BIT_12;
10911 MP_WritePhyUshort(sc, 0x15, Data);
10912 DELAY(200);
10913 DELAY(200);
10914 MP_WritePhyUshort(sc, 0x1f, 0x0004);
10915 MP_WritePhyUshort(sc, 0x1f, 0x0007);
10916 MP_WritePhyUshort(sc, 0x1e, 0x0023);
10917 Data = MP_ReadPhyUshort(sc, 0x17);
10918 if ((Data & BIT_11) == 0x0000) {
10919 Data |= BIT_0;
10920 MP_WritePhyUshort(sc, 0x17, Data);
10921 for (i = 0; i < 200; i++) {
10922 DELAY(100);
10923 Data = MP_ReadPhyUshort(sc, 0x17);
10924 if (Data & BIT_11)
10925 break;
10926 }
10927 }
10928 Data = MP_ReadPhyUshort(sc, 0x17);
10929 Data |= BIT_11;
10930 MP_WritePhyUshort(sc, 0x17,Data);
10931 MP_WritePhyUshort(sc, 0x1f, 0x0004);
10932 MP_WritePhyUshort(sc, 0x1f, 0x0007);
10933 MP_WritePhyUshort(sc, 0x1E, 0x002C);
10934 MP_WritePhyUshort(sc, 0x1B, 0x5000);
10935 MP_WritePhyUshort(sc, 0x1E, 0x002d);
10936 MP_WritePhyUshort(sc, 0x19, 0x0004);
10937 MP_WritePhyUshort(sc, 0x1f, 0x0002);
10938 MP_WritePhyUshort(sc, 0x1f, 0x0000);
10939 for (i = 0; i < 200; i++) {
10940 DELAY(100);
10941 Data= MP_ReadPhyUshort(sc, 0x1E);
10942 if ((Data& 0x03FF) == 0x0014)
10943 break;
10944 }
10945 MP_WritePhyUshort(sc, 0x1f, 0x0005);
10946 for (i = 0; i < 200; i++) {
10947 DELAY(100);
10948 Data= MP_ReadPhyUshort(sc, 0x07);
10949 if ((Data& BIT_5) == 0)
10950 break;
10951 }
10952 Data = MP_ReadPhyUshort(sc, 0x07);
10953 if (Data & BIT_5) {
10954 MP_WritePhyUshort(sc, 0x1f, 0x0004);
10955 MP_WritePhyUshort(sc, 0x1f, 0x0007);
10956 MP_WritePhyUshort(sc, 0x1e, 0x00a1);
10957 MP_WritePhyUshort(sc, 0x17, 0x1000);
10958 MP_WritePhyUshort(sc, 0x17, 0x0000);
10959 MP_WritePhyUshort(sc, 0x17, 0x2000);
10960 MP_WritePhyUshort(sc, 0x1e, 0x002f);
10961 MP_WritePhyUshort(sc, 0x18, 0x9bfb);
10962 MP_WritePhyUshort(sc, 0x1f, 0x0005);
10963 MP_WritePhyUshort(sc, 0x07, 0x0000);
10964 MP_WritePhyUshort(sc, 0x1f, 0x0002);
10965 MP_WritePhyUshort(sc, 0x1f, 0x0000);
10966 }
10967 MP_WritePhyUshort(sc, 0x1f, 0x0005);
10968 MP_WritePhyUshort(sc, 0x05, 0xfff6);
10969 MP_WritePhyUshort(sc, 0x06, 0x0080);
10970 Data = MP_ReadPhyUshort(sc, 0x00);
10971 Data &= ~BIT_7;
10972 MP_WritePhyUshort(sc, 0x00, Data);
10973 MP_WritePhyUshort(sc, 0x1f, 0x0004);
10974 MP_WritePhyUshort(sc, 0x1f, 0x0007);
10975 MP_WritePhyUshort(sc, 0x1e, 0x0023);
10976 MP_WritePhyUshort(sc, 0x16, 0x0306);
10977 MP_WritePhyUshort(sc, 0x16, 0x0307);
10978 MP_WritePhyUshort(sc, 0x15, 0x0000);
10979 MP_WritePhyUshort(sc, 0x19, 0x407d);
10980 MP_WritePhyUshort(sc, 0x15, 0x0001);
10981 MP_WritePhyUshort(sc, 0x19, 0x440f);
10982 MP_WritePhyUshort(sc, 0x15, 0x0002);
10983 MP_WritePhyUshort(sc, 0x19, 0x7c03);
10984 MP_WritePhyUshort(sc, 0x15, 0x0003);
10985 MP_WritePhyUshort(sc, 0x19, 0x6c03);
10986 MP_WritePhyUshort(sc, 0x15, 0x0004);
10987 MP_WritePhyUshort(sc, 0x19, 0xc4d5);
10988 MP_WritePhyUshort(sc, 0x15, 0x0005);
10989 MP_WritePhyUshort(sc, 0x19, 0x00ff);
10990 MP_WritePhyUshort(sc, 0x15, 0x0006);
10991 MP_WritePhyUshort(sc, 0x19, 0x74f0);
10992 MP_WritePhyUshort(sc, 0x15, 0x0007);
10993 MP_WritePhyUshort(sc, 0x19, 0x4880);
10994 MP_WritePhyUshort(sc, 0x15, 0x0008);
10995 MP_WritePhyUshort(sc, 0x19, 0x4c00);
10996 MP_WritePhyUshort(sc, 0x15, 0x0009);
10997 MP_WritePhyUshort(sc, 0x19, 0x4800);
10998 MP_WritePhyUshort(sc, 0x15, 0x000a);
10999 MP_WritePhyUshort(sc, 0x19, 0x5000);
11000 MP_WritePhyUshort(sc, 0x15, 0x000b);
11001 MP_WritePhyUshort(sc, 0x19, 0x4400);
11002 MP_WritePhyUshort(sc, 0x15, 0x000c);
11003 MP_WritePhyUshort(sc, 0x19, 0x7801);
11004 MP_WritePhyUshort(sc, 0x15, 0x000d);
11005 MP_WritePhyUshort(sc, 0x19, 0x4000);
11006 MP_WritePhyUshort(sc, 0x15, 0x000e);
11007 MP_WritePhyUshort(sc, 0x19, 0x7800);
11008 MP_WritePhyUshort(sc, 0x15, 0x000f);
11009 MP_WritePhyUshort(sc, 0x19, 0x7010);
11010 MP_WritePhyUshort(sc, 0x15, 0x0010);
11011 MP_WritePhyUshort(sc, 0x19, 0x6804);
11012 MP_WritePhyUshort(sc, 0x15, 0x0011);
11013 MP_WritePhyUshort(sc, 0x19, 0x64a0);
11014 MP_WritePhyUshort(sc, 0x15, 0x0012);
11015 MP_WritePhyUshort(sc, 0x19, 0x63da);
11016 MP_WritePhyUshort(sc, 0x15, 0x0013);
11017 MP_WritePhyUshort(sc, 0x19, 0x63d8);
11018 MP_WritePhyUshort(sc, 0x15, 0x0014);
11019 MP_WritePhyUshort(sc, 0x19, 0x6f05);
11020 MP_WritePhyUshort(sc, 0x15, 0x0015);
11021 MP_WritePhyUshort(sc, 0x19, 0x5420);
11022 MP_WritePhyUshort(sc, 0x15, 0x0016);
11023 MP_WritePhyUshort(sc, 0x19, 0x58ce);
11024 MP_WritePhyUshort(sc, 0x15, 0x0017);
11025 MP_WritePhyUshort(sc, 0x19, 0x5cf3);
11026 MP_WritePhyUshort(sc, 0x15, 0x0018);
11027 MP_WritePhyUshort(sc, 0x19, 0xb600);
11028 MP_WritePhyUshort(sc, 0x15, 0x0019);
11029 MP_WritePhyUshort(sc, 0x19, 0xc659);
11030 MP_WritePhyUshort(sc, 0x15, 0x001a);
11031 MP_WritePhyUshort(sc, 0x19, 0x0018);
11032 MP_WritePhyUshort(sc, 0x15, 0x001b);
11033 MP_WritePhyUshort(sc, 0x19, 0xc403);
11034 MP_WritePhyUshort(sc, 0x15, 0x001c);
11035 MP_WritePhyUshort(sc, 0x19, 0x0016);
11036 MP_WritePhyUshort(sc, 0x15, 0x001d);
11037 MP_WritePhyUshort(sc, 0x19, 0xaa05);
11038 MP_WritePhyUshort(sc, 0x15, 0x001e);
11039 MP_WritePhyUshort(sc, 0x19, 0xc503);
11040 MP_WritePhyUshort(sc, 0x15, 0x001f);
11041 MP_WritePhyUshort(sc, 0x19, 0x0003);
11042 MP_WritePhyUshort(sc, 0x15, 0x0020);
11043 MP_WritePhyUshort(sc, 0x19, 0x89f8);
11044 MP_WritePhyUshort(sc, 0x15, 0x0021);
11045 MP_WritePhyUshort(sc, 0x19, 0x32ae);
11046 MP_WritePhyUshort(sc, 0x15, 0x0022);
11047 MP_WritePhyUshort(sc, 0x19, 0x7c03);
11048 MP_WritePhyUshort(sc, 0x15, 0x0023);
11049 MP_WritePhyUshort(sc, 0x19, 0x6c03);
11050 MP_WritePhyUshort(sc, 0x15, 0x0024);
11051 MP_WritePhyUshort(sc, 0x19, 0x7c03);
11052 MP_WritePhyUshort(sc, 0x15, 0x0025);
11053 MP_WritePhyUshort(sc, 0x19, 0x6801);
11054 MP_WritePhyUshort(sc, 0x15, 0x0026);
11055 MP_WritePhyUshort(sc, 0x19, 0x66a0);
11056 MP_WritePhyUshort(sc, 0x15, 0x0027);
11057 MP_WritePhyUshort(sc, 0x19, 0xa300);
11058 MP_WritePhyUshort(sc, 0x15, 0x0028);
11059 MP_WritePhyUshort(sc, 0x19, 0x64a0);
11060 MP_WritePhyUshort(sc, 0x15, 0x0029);
11061 MP_WritePhyUshort(sc, 0x19, 0x76f0);
11062 MP_WritePhyUshort(sc, 0x15, 0x002a);
11063 MP_WritePhyUshort(sc, 0x19, 0x7670);
11064 MP_WritePhyUshort(sc, 0x15, 0x002b);
11065 MP_WritePhyUshort(sc, 0x19, 0x7630);
11066 MP_WritePhyUshort(sc, 0x15, 0x002c);
11067 MP_WritePhyUshort(sc, 0x19, 0x31a6);
11068 MP_WritePhyUshort(sc, 0x15, 0x002d);
11069 MP_WritePhyUshort(sc, 0x19, 0x0000);
11070 MP_WritePhyUshort(sc, 0x15, 0x002e);
11071 MP_WritePhyUshort(sc, 0x19, 0x0000);
11072 MP_WritePhyUshort(sc, 0x15, 0x002f);
11073 MP_WritePhyUshort(sc, 0x19, 0x0000);
11074 MP_WritePhyUshort(sc, 0x15, 0x0030);
11075 MP_WritePhyUshort(sc, 0x19, 0x0000);
11076 MP_WritePhyUshort(sc, 0x15, 0x0031);
11077 MP_WritePhyUshort(sc, 0x19, 0x0000);
11078 MP_WritePhyUshort(sc, 0x15, 0x0032);
11079 MP_WritePhyUshort(sc, 0x19, 0x4801);
11080 MP_WritePhyUshort(sc, 0x15, 0x0033);
11081 MP_WritePhyUshort(sc, 0x19, 0x6803);
11082 MP_WritePhyUshort(sc, 0x15, 0x0034);
11083 MP_WritePhyUshort(sc, 0x19, 0x66a1);
11084 MP_WritePhyUshort(sc, 0x15, 0x0035);
11085 MP_WritePhyUshort(sc, 0x19, 0x7c03);
11086 MP_WritePhyUshort(sc, 0x15, 0x0036);
11087 MP_WritePhyUshort(sc, 0x19, 0x6c03);
11088 MP_WritePhyUshort(sc, 0x15, 0x0037);
11089 MP_WritePhyUshort(sc, 0x19, 0xa300);
11090 MP_WritePhyUshort(sc, 0x15, 0x0038);
11091 MP_WritePhyUshort(sc, 0x19, 0x64a1);
11092 MP_WritePhyUshort(sc, 0x15, 0x0039);
11093 MP_WritePhyUshort(sc, 0x19, 0x7c08);
11094 MP_WritePhyUshort(sc, 0x15, 0x003a);
11095 MP_WritePhyUshort(sc, 0x19, 0x74f8);
11096 MP_WritePhyUshort(sc, 0x15, 0x003b);
11097 MP_WritePhyUshort(sc, 0x19, 0x63d0);
11098 MP_WritePhyUshort(sc, 0x15, 0x003c);
11099 MP_WritePhyUshort(sc, 0x19, 0x7ff0);
11100 MP_WritePhyUshort(sc, 0x15, 0x003d);
11101 MP_WritePhyUshort(sc, 0x19, 0x77f0);
11102 MP_WritePhyUshort(sc, 0x15, 0x003e);
11103 MP_WritePhyUshort(sc, 0x19, 0x7ff0);
11104 MP_WritePhyUshort(sc, 0x15, 0x003f);
11105 MP_WritePhyUshort(sc, 0x19, 0x7750);
11106 MP_WritePhyUshort(sc, 0x15, 0x0040);
11107 MP_WritePhyUshort(sc, 0x19, 0x63d8);
11108 MP_WritePhyUshort(sc, 0x15, 0x0041);
11109 MP_WritePhyUshort(sc, 0x19, 0x7cf0);
11110 MP_WritePhyUshort(sc, 0x15, 0x0042);
11111 MP_WritePhyUshort(sc, 0x19, 0x7708);
11112 MP_WritePhyUshort(sc, 0x15, 0x0043);
11113 MP_WritePhyUshort(sc, 0x19, 0xa654);
11114 MP_WritePhyUshort(sc, 0x15, 0x0044);
11115 MP_WritePhyUshort(sc, 0x19, 0x304a);
11116 MP_WritePhyUshort(sc, 0x15, 0x0045);
11117 MP_WritePhyUshort(sc, 0x19, 0x0000);
11118 MP_WritePhyUshort(sc, 0x15, 0x0046);
11119 MP_WritePhyUshort(sc, 0x19, 0x0000);
11120 MP_WritePhyUshort(sc, 0x15, 0x0047);
11121 MP_WritePhyUshort(sc, 0x19, 0x0000);
11122 MP_WritePhyUshort(sc, 0x15, 0x0048);
11123 MP_WritePhyUshort(sc, 0x19, 0x0000);
11124 MP_WritePhyUshort(sc, 0x15, 0x0049);
11125 MP_WritePhyUshort(sc, 0x19, 0x0000);
11126 MP_WritePhyUshort(sc, 0x15, 0x004a);
11127 MP_WritePhyUshort(sc, 0x19, 0x4802);
11128 MP_WritePhyUshort(sc, 0x15, 0x004b);
11129 MP_WritePhyUshort(sc, 0x19, 0x4003);
11130 MP_WritePhyUshort(sc, 0x15, 0x004c);
11131 MP_WritePhyUshort(sc, 0x19, 0x4440);
11132 MP_WritePhyUshort(sc, 0x15, 0x004d);
11133 MP_WritePhyUshort(sc, 0x19, 0x63c8);
11134 MP_WritePhyUshort(sc, 0x15, 0x004e);
11135 MP_WritePhyUshort(sc, 0x19, 0x6481);
11136 MP_WritePhyUshort(sc, 0x15, 0x004f);
11137 MP_WritePhyUshort(sc, 0x19, 0x9d00);
11138 MP_WritePhyUshort(sc, 0x15, 0x0050);
11139 MP_WritePhyUshort(sc, 0x19, 0x63e8);
11140 MP_WritePhyUshort(sc, 0x15, 0x0051);
11141 MP_WritePhyUshort(sc, 0x19, 0x7d00);
11142 MP_WritePhyUshort(sc, 0x15, 0x0052);
11143 MP_WritePhyUshort(sc, 0x19, 0x5900);
11144 MP_WritePhyUshort(sc, 0x15, 0x0053);
11145 MP_WritePhyUshort(sc, 0x19, 0x63f8);
11146 MP_WritePhyUshort(sc, 0x15, 0x0054);
11147 MP_WritePhyUshort(sc, 0x19, 0x64a1);
11148 MP_WritePhyUshort(sc, 0x15, 0x0055);
11149 MP_WritePhyUshort(sc, 0x19, 0x3116);
11150 MP_WritePhyUshort(sc, 0x15, 0x0056);
11151 MP_WritePhyUshort(sc, 0x19, 0x0000);
11152 MP_WritePhyUshort(sc, 0x15, 0x0057);
11153 MP_WritePhyUshort(sc, 0x19, 0x0000);
11154 MP_WritePhyUshort(sc, 0x15, 0x0058);
11155 MP_WritePhyUshort(sc, 0x19, 0x0000);
11156 MP_WritePhyUshort(sc, 0x15, 0x0059);
11157 MP_WritePhyUshort(sc, 0x19, 0x0000);
11158 MP_WritePhyUshort(sc, 0x15, 0x005a);
11159 MP_WritePhyUshort(sc, 0x19, 0x7c03);
11160 MP_WritePhyUshort(sc, 0x15, 0x005b);
11161 MP_WritePhyUshort(sc, 0x19, 0x6c03);
11162 MP_WritePhyUshort(sc, 0x15, 0x005c);
11163 MP_WritePhyUshort(sc, 0x19, 0x7c08);
11164 MP_WritePhyUshort(sc, 0x15, 0x005d);
11165 MP_WritePhyUshort(sc, 0x19, 0x6000);
11166 MP_WritePhyUshort(sc, 0x15, 0x005e);
11167 MP_WritePhyUshort(sc, 0x19, 0x59ce);
11168 MP_WritePhyUshort(sc, 0x15, 0x005f);
11169 MP_WritePhyUshort(sc, 0x19, 0x4400);
11170 MP_WritePhyUshort(sc, 0x15, 0x0060);
11171 MP_WritePhyUshort(sc, 0x19, 0x7d00);
11172 MP_WritePhyUshort(sc, 0x15, 0x0061);
11173 MP_WritePhyUshort(sc, 0x19, 0x72b0);
11174 MP_WritePhyUshort(sc, 0x15, 0x0062);
11175 MP_WritePhyUshort(sc, 0x19, 0x400e);
11176 MP_WritePhyUshort(sc, 0x15, 0x0063);
11177 MP_WritePhyUshort(sc, 0x19, 0x4440);
11178 MP_WritePhyUshort(sc, 0x15, 0x0064);
11179 MP_WritePhyUshort(sc, 0x19, 0x9d00);
11180 MP_WritePhyUshort(sc, 0x15, 0x0065);
11181 MP_WritePhyUshort(sc, 0x19, 0x7f00);
11182 MP_WritePhyUshort(sc, 0x15, 0x0066);
11183 MP_WritePhyUshort(sc, 0x19, 0x70b0);
11184 MP_WritePhyUshort(sc, 0x15, 0x0067);
11185 MP_WritePhyUshort(sc, 0x19, 0x7c08);
11186 MP_WritePhyUshort(sc, 0x15, 0x0068);
11187 MP_WritePhyUshort(sc, 0x19, 0x6008);
11188 MP_WritePhyUshort(sc, 0x15, 0x0069);
11189 MP_WritePhyUshort(sc, 0x19, 0x7cf0);
11190 MP_WritePhyUshort(sc, 0x15, 0x006a);
11191 MP_WritePhyUshort(sc, 0x19, 0x7750);
11192 MP_WritePhyUshort(sc, 0x15, 0x006b);
11193 MP_WritePhyUshort(sc, 0x19, 0x4007);
11194 MP_WritePhyUshort(sc, 0x15, 0x006c);
11195 MP_WritePhyUshort(sc, 0x19, 0x4500);
11196 MP_WritePhyUshort(sc, 0x15, 0x006d);
11197 MP_WritePhyUshort(sc, 0x19, 0x4023);
11198 MP_WritePhyUshort(sc, 0x15, 0x006e);
11199 MP_WritePhyUshort(sc, 0x19, 0x4580);
11200 MP_WritePhyUshort(sc, 0x15, 0x006f);
11201 MP_WritePhyUshort(sc, 0x19, 0x9f00);
11202 MP_WritePhyUshort(sc, 0x15, 0x0070);
11203 MP_WritePhyUshort(sc, 0x19, 0xcd78);
11204 MP_WritePhyUshort(sc, 0x15, 0x0071);
11205 MP_WritePhyUshort(sc, 0x19, 0x0003);
11206 MP_WritePhyUshort(sc, 0x15, 0x0072);
11207 MP_WritePhyUshort(sc, 0x19, 0xbe02);
11208 MP_WritePhyUshort(sc, 0x15, 0x0073);
11209 MP_WritePhyUshort(sc, 0x19, 0x3070);
11210 MP_WritePhyUshort(sc, 0x15, 0x0074);
11211 MP_WritePhyUshort(sc, 0x19, 0x7cf0);
11212 MP_WritePhyUshort(sc, 0x15, 0x0075);
11213 MP_WritePhyUshort(sc, 0x19, 0x77f0);
11214 MP_WritePhyUshort(sc, 0x15, 0x0076);
11215 MP_WritePhyUshort(sc, 0x19, 0x4400);
11216 MP_WritePhyUshort(sc, 0x15, 0x0077);
11217 MP_WritePhyUshort(sc, 0x19, 0x4007);
11218 MP_WritePhyUshort(sc, 0x15, 0x0078);
11219 MP_WritePhyUshort(sc, 0x19, 0x4500);
11220 MP_WritePhyUshort(sc, 0x15, 0x0079);
11221 MP_WritePhyUshort(sc, 0x19, 0x4023);
11222 MP_WritePhyUshort(sc, 0x15, 0x007a);
11223 MP_WritePhyUshort(sc, 0x19, 0x4580);
11224 MP_WritePhyUshort(sc, 0x15, 0x007b);
11225 MP_WritePhyUshort(sc, 0x19, 0x9f00);
11226 MP_WritePhyUshort(sc, 0x15, 0x007c);
11227 MP_WritePhyUshort(sc, 0x19, 0xce80);
11228 MP_WritePhyUshort(sc, 0x15, 0x007d);
11229 MP_WritePhyUshort(sc, 0x19, 0x0004);
11230 MP_WritePhyUshort(sc, 0x15, 0x007e);
11231 MP_WritePhyUshort(sc, 0x19, 0xce80);
11232 MP_WritePhyUshort(sc, 0x15, 0x007f);
11233 MP_WritePhyUshort(sc, 0x19, 0x0002);
11234 MP_WritePhyUshort(sc, 0x15, 0x0080);
11235 MP_WritePhyUshort(sc, 0x19, 0x307c);
11236 MP_WritePhyUshort(sc, 0x15, 0x0081);
11237 MP_WritePhyUshort(sc, 0x19, 0x4400);
11238 MP_WritePhyUshort(sc, 0x15, 0x0082);
11239 MP_WritePhyUshort(sc, 0x19, 0x480f);
11240 MP_WritePhyUshort(sc, 0x15, 0x0083);
11241 MP_WritePhyUshort(sc, 0x19, 0x6802);
11242 MP_WritePhyUshort(sc, 0x15, 0x0084);
11243 MP_WritePhyUshort(sc, 0x19, 0x6680);
11244 MP_WritePhyUshort(sc, 0x15, 0x0085);
11245 MP_WritePhyUshort(sc, 0x19, 0x7c10);
11246 MP_WritePhyUshort(sc, 0x15, 0x0086);
11247 MP_WritePhyUshort(sc, 0x19, 0x6010);
11248 MP_WritePhyUshort(sc, 0x15, 0x0087);
11249 MP_WritePhyUshort(sc, 0x19, 0x400a);
11250 MP_WritePhyUshort(sc, 0x15, 0x0088);
11251 MP_WritePhyUshort(sc, 0x19, 0x4580);
11252 MP_WritePhyUshort(sc, 0x15, 0x0089);
11253 MP_WritePhyUshort(sc, 0x19, 0x9e00);
11254 MP_WritePhyUshort(sc, 0x15, 0x008a);
11255 MP_WritePhyUshort(sc, 0x19, 0x7d00);
11256 MP_WritePhyUshort(sc, 0x15, 0x008b);
11257 MP_WritePhyUshort(sc, 0x19, 0x5800);
11258 MP_WritePhyUshort(sc, 0x15, 0x008c);
11259 MP_WritePhyUshort(sc, 0x19, 0x63c8);
11260 MP_WritePhyUshort(sc, 0x15, 0x008d);
11261 MP_WritePhyUshort(sc, 0x19, 0x63d8);
11262 MP_WritePhyUshort(sc, 0x15, 0x008e);
11263 MP_WritePhyUshort(sc, 0x19, 0x66a0);
11264 MP_WritePhyUshort(sc, 0x15, 0x008f);
11265 MP_WritePhyUshort(sc, 0x19, 0x8300);
11266 MP_WritePhyUshort(sc, 0x15, 0x0090);
11267 MP_WritePhyUshort(sc, 0x19, 0x7ff0);
11268 MP_WritePhyUshort(sc, 0x15, 0x0091);
11269 MP_WritePhyUshort(sc, 0x19, 0x74f0);
11270 MP_WritePhyUshort(sc, 0x15, 0x0092);
11271 MP_WritePhyUshort(sc, 0x19, 0x3006);
11272 MP_WritePhyUshort(sc, 0x15, 0x0093);
11273 MP_WritePhyUshort(sc, 0x19, 0x0000);
11274 MP_WritePhyUshort(sc, 0x15, 0x0094);
11275 MP_WritePhyUshort(sc, 0x19, 0x0000);
11276 MP_WritePhyUshort(sc, 0x15, 0x0095);
11277 MP_WritePhyUshort(sc, 0x19, 0x0000);
11278 MP_WritePhyUshort(sc, 0x15, 0x0096);
11279 MP_WritePhyUshort(sc, 0x19, 0x0000);
11280 MP_WritePhyUshort(sc, 0x15, 0x0097);
11281 MP_WritePhyUshort(sc, 0x19, 0x4803);
11282 MP_WritePhyUshort(sc, 0x15, 0x0098);
11283 MP_WritePhyUshort(sc, 0x19, 0x7c03);
11284 MP_WritePhyUshort(sc, 0x15, 0x0099);
11285 MP_WritePhyUshort(sc, 0x19, 0x6c03);
11286 MP_WritePhyUshort(sc, 0x15, 0x009a);
11287 MP_WritePhyUshort(sc, 0x19, 0xa203);
11288 MP_WritePhyUshort(sc, 0x15, 0x009b);
11289 MP_WritePhyUshort(sc, 0x19, 0x64b1);
11290 MP_WritePhyUshort(sc, 0x15, 0x009c);
11291 MP_WritePhyUshort(sc, 0x19, 0x309e);
11292 MP_WritePhyUshort(sc, 0x15, 0x009d);
11293 MP_WritePhyUshort(sc, 0x19, 0x64b3);
11294 MP_WritePhyUshort(sc, 0x15, 0x009e);
11295 MP_WritePhyUshort(sc, 0x19, 0x4030);
11296 MP_WritePhyUshort(sc, 0x15, 0x009f);
11297 MP_WritePhyUshort(sc, 0x19, 0x440e);
11298 MP_WritePhyUshort(sc, 0x15, 0x00a0);
11299 MP_WritePhyUshort(sc, 0x19, 0x4020);
11300 MP_WritePhyUshort(sc, 0x15, 0x00a1);
11301 MP_WritePhyUshort(sc, 0x19, 0x4419);
11302 MP_WritePhyUshort(sc, 0x15, 0x00a2);
11303 MP_WritePhyUshort(sc, 0x19, 0x7801);
11304 MP_WritePhyUshort(sc, 0x15, 0x00a3);
11305 MP_WritePhyUshort(sc, 0x19, 0xc520);
11306 MP_WritePhyUshort(sc, 0x15, 0x00a4);
11307 MP_WritePhyUshort(sc, 0x19, 0x000b);
11308 MP_WritePhyUshort(sc, 0x15, 0x00a5);
11309 MP_WritePhyUshort(sc, 0x19, 0x4020);
11310 MP_WritePhyUshort(sc, 0x15, 0x00a6);
11311 MP_WritePhyUshort(sc, 0x19, 0x7800);
11312 MP_WritePhyUshort(sc, 0x15, 0x00a7);
11313 MP_WritePhyUshort(sc, 0x19, 0x58a4);
11314 MP_WritePhyUshort(sc, 0x15, 0x00a8);
11315 MP_WritePhyUshort(sc, 0x19, 0x63da);
11316 MP_WritePhyUshort(sc, 0x15, 0x00a9);
11317 MP_WritePhyUshort(sc, 0x19, 0x5cb0);
11318 MP_WritePhyUshort(sc, 0x15, 0x00aa);
11319 MP_WritePhyUshort(sc, 0x19, 0x7d00);
11320 MP_WritePhyUshort(sc, 0x15, 0x00ab);
11321 MP_WritePhyUshort(sc, 0x19, 0x72b0);
11322 MP_WritePhyUshort(sc, 0x15, 0x00ac);
11323 MP_WritePhyUshort(sc, 0x19, 0x7f00);
11324 MP_WritePhyUshort(sc, 0x15, 0x00ad);
11325 MP_WritePhyUshort(sc, 0x19, 0x70b0);
11326 MP_WritePhyUshort(sc, 0x15, 0x00ae);
11327 MP_WritePhyUshort(sc, 0x19, 0x30b8);
11328 MP_WritePhyUshort(sc, 0x15, 0x00AF);
11329 MP_WritePhyUshort(sc, 0x19, 0x4060);
11330 MP_WritePhyUshort(sc, 0x15, 0x00B0);
11331 MP_WritePhyUshort(sc, 0x19, 0x7800);
11332 MP_WritePhyUshort(sc, 0x15, 0x00B1);
11333 MP_WritePhyUshort(sc, 0x19, 0x7e00);
11334 MP_WritePhyUshort(sc, 0x15, 0x00B2);
11335 MP_WritePhyUshort(sc, 0x19, 0x72B0);
11336 MP_WritePhyUshort(sc, 0x15, 0x00B3);
11337 MP_WritePhyUshort(sc, 0x19, 0x7F00);
11338 MP_WritePhyUshort(sc, 0x15, 0x00B4);
11339 MP_WritePhyUshort(sc, 0x19, 0x73B0);
11340 MP_WritePhyUshort(sc, 0x15, 0x00b5);
11341 MP_WritePhyUshort(sc, 0x19, 0x58a0);
11342 MP_WritePhyUshort(sc, 0x15, 0x00b6);
11343 MP_WritePhyUshort(sc, 0x19, 0x63d2);
11344 MP_WritePhyUshort(sc, 0x15, 0x00b7);
11345 MP_WritePhyUshort(sc, 0x19, 0x5c00);
11346 MP_WritePhyUshort(sc, 0x15, 0x00b8);
11347 MP_WritePhyUshort(sc, 0x19, 0x5780);
11348 MP_WritePhyUshort(sc, 0x15, 0x00b9);
11349 MP_WritePhyUshort(sc, 0x19, 0xb60d);
11350 MP_WritePhyUshort(sc, 0x15, 0x00ba);
11351 MP_WritePhyUshort(sc, 0x19, 0x9bff);
11352 MP_WritePhyUshort(sc, 0x15, 0x00bb);
11353 MP_WritePhyUshort(sc, 0x19, 0x7c03);
11354 MP_WritePhyUshort(sc, 0x15, 0x00bc);
11355 MP_WritePhyUshort(sc, 0x19, 0x6001);
11356 MP_WritePhyUshort(sc, 0x15, 0x00bd);
11357 MP_WritePhyUshort(sc, 0x19, 0xc020);
11358 MP_WritePhyUshort(sc, 0x15, 0x00be);
11359 MP_WritePhyUshort(sc, 0x19, 0x002b);
11360 MP_WritePhyUshort(sc, 0x15, 0x00bf);
11361 MP_WritePhyUshort(sc, 0x19, 0xc137);
11362 MP_WritePhyUshort(sc, 0x15, 0x00c0);
11363 MP_WritePhyUshort(sc, 0x19, 0x0006);
11364 MP_WritePhyUshort(sc, 0x15, 0x00c1);
11365 MP_WritePhyUshort(sc, 0x19, 0x9af8);
11366 MP_WritePhyUshort(sc, 0x15, 0x00c2);
11367 MP_WritePhyUshort(sc, 0x19, 0x30c6);
11368 MP_WritePhyUshort(sc, 0x15, 0x00c3);
11369 MP_WritePhyUshort(sc, 0x19, 0x0000);
11370 MP_WritePhyUshort(sc, 0x15, 0x00c4);
11371 MP_WritePhyUshort(sc, 0x19, 0x0000);
11372 MP_WritePhyUshort(sc, 0x15, 0x00c5);
11373 MP_WritePhyUshort(sc, 0x19, 0x0000);
11374 MP_WritePhyUshort(sc, 0x15, 0x00c6);
11375 MP_WritePhyUshort(sc, 0x19, 0x7d00);
11376 MP_WritePhyUshort(sc, 0x15, 0x00c7);
11377 MP_WritePhyUshort(sc, 0x19, 0x70b0);
11378 MP_WritePhyUshort(sc, 0x15, 0x00c8);
11379 MP_WritePhyUshort(sc, 0x19, 0x4400);
11380 MP_WritePhyUshort(sc, 0x15, 0x00c9);
11381 MP_WritePhyUshort(sc, 0x19, 0x4804);
11382 MP_WritePhyUshort(sc, 0x15, 0x00ca);
11383 MP_WritePhyUshort(sc, 0x19, 0x7c80);
11384 MP_WritePhyUshort(sc, 0x15, 0x00cb);
11385 MP_WritePhyUshort(sc, 0x19, 0x5c80);
11386 MP_WritePhyUshort(sc, 0x15, 0x00cc);
11387 MP_WritePhyUshort(sc, 0x19, 0x4010);
11388 MP_WritePhyUshort(sc, 0x15, 0x00cd);
11389 MP_WritePhyUshort(sc, 0x19, 0x4415);
11390 MP_WritePhyUshort(sc, 0x15, 0x00ce);
11391 MP_WritePhyUshort(sc, 0x19, 0x9b00);
11392 MP_WritePhyUshort(sc, 0x15, 0x00cf);
11393 MP_WritePhyUshort(sc, 0x19, 0x7f00);
11394 MP_WritePhyUshort(sc, 0x15, 0x00d0);
11395 MP_WritePhyUshort(sc, 0x19, 0x70b0);
11396 MP_WritePhyUshort(sc, 0x15, 0x00d1);
11397 MP_WritePhyUshort(sc, 0x19, 0x3177);
11398 MP_WritePhyUshort(sc, 0x15, 0x00d2);
11399 MP_WritePhyUshort(sc, 0x19, 0x0000);
11400 MP_WritePhyUshort(sc, 0x15, 0x00d3);
11401 MP_WritePhyUshort(sc, 0x19, 0x0000);
11402 MP_WritePhyUshort(sc, 0x15, 0x00d4);
11403 MP_WritePhyUshort(sc, 0x19, 0x0000);
11404 MP_WritePhyUshort(sc, 0x15, 0x00d5);
11405 MP_WritePhyUshort(sc, 0x19, 0x4808);
11406 MP_WritePhyUshort(sc, 0x15, 0x00d6);
11407 MP_WritePhyUshort(sc, 0x19, 0x4007);
11408 MP_WritePhyUshort(sc, 0x15, 0x00d7);
11409 MP_WritePhyUshort(sc, 0x19, 0x4420);
11410 MP_WritePhyUshort(sc, 0x15, 0x00d8);
11411 MP_WritePhyUshort(sc, 0x19, 0x63d8);
11412 MP_WritePhyUshort(sc, 0x15, 0x00d9);
11413 MP_WritePhyUshort(sc, 0x19, 0xb608);
11414 MP_WritePhyUshort(sc, 0x15, 0x00da);
11415 MP_WritePhyUshort(sc, 0x19, 0xbcbd);
11416 MP_WritePhyUshort(sc, 0x15, 0x00db);
11417 MP_WritePhyUshort(sc, 0x19, 0xc60b);
11418 MP_WritePhyUshort(sc, 0x15, 0x00dc);
11419 MP_WritePhyUshort(sc, 0x19, 0x00fd);
11420 MP_WritePhyUshort(sc, 0x15, 0x00dd);
11421 MP_WritePhyUshort(sc, 0x19, 0x30e1);
11422 MP_WritePhyUshort(sc, 0x15, 0x00de);
11423 MP_WritePhyUshort(sc, 0x19, 0x0000);
11424 MP_WritePhyUshort(sc, 0x15, 0x00df);
11425 MP_WritePhyUshort(sc, 0x19, 0x0000);
11426 MP_WritePhyUshort(sc, 0x15, 0x00e0);
11427 MP_WritePhyUshort(sc, 0x19, 0x0000);
11428 MP_WritePhyUshort(sc, 0x15, 0x00e1);
11429 MP_WritePhyUshort(sc, 0x19, 0x4809);
11430 MP_WritePhyUshort(sc, 0x15, 0x00e2);
11431 MP_WritePhyUshort(sc, 0x19, 0x7e40);
11432 MP_WritePhyUshort(sc, 0x15, 0x00e3);
11433 MP_WritePhyUshort(sc, 0x19, 0x5a40);
11434 MP_WritePhyUshort(sc, 0x15, 0x00e4);
11435 MP_WritePhyUshort(sc, 0x19, 0x305a);
11436 MP_WritePhyUshort(sc, 0x15, 0x00e5);
11437 MP_WritePhyUshort(sc, 0x19, 0x0000);
11438 MP_WritePhyUshort(sc, 0x15, 0x00e6);
11439 MP_WritePhyUshort(sc, 0x19, 0x0000);
11440 MP_WritePhyUshort(sc, 0x15, 0x00e7);
11441 MP_WritePhyUshort(sc, 0x19, 0x0000);
11442 MP_WritePhyUshort(sc, 0x15, 0x00e8);
11443 MP_WritePhyUshort(sc, 0x19, 0x0000);
11444 MP_WritePhyUshort(sc, 0x15, 0x00e9);
11445 MP_WritePhyUshort(sc, 0x19, 0x480a);
11446 MP_WritePhyUshort(sc, 0x15, 0x00ea);
11447 MP_WritePhyUshort(sc, 0x19, 0x5820);
11448 MP_WritePhyUshort(sc, 0x15, 0x00eb);
11449 MP_WritePhyUshort(sc, 0x19, 0x6c03);
11450 MP_WritePhyUshort(sc, 0x15, 0x00ec);
11451 MP_WritePhyUshort(sc, 0x19, 0xb60a);
11452 MP_WritePhyUshort(sc, 0x15, 0x00ed);
11453 MP_WritePhyUshort(sc, 0x19, 0xda07);
11454 MP_WritePhyUshort(sc, 0x15, 0x00ee);
11455 MP_WritePhyUshort(sc, 0x19, 0x0008);
11456 MP_WritePhyUshort(sc, 0x15, 0x00ef);
11457 MP_WritePhyUshort(sc, 0x19, 0xc60b);
11458 MP_WritePhyUshort(sc, 0x15, 0x00f0);
11459 MP_WritePhyUshort(sc, 0x19, 0x00fc);
11460 MP_WritePhyUshort(sc, 0x15, 0x00f1);
11461 MP_WritePhyUshort(sc, 0x19, 0x30f6);
11462 MP_WritePhyUshort(sc, 0x15, 0x00f2);
11463 MP_WritePhyUshort(sc, 0x19, 0x0000);
11464 MP_WritePhyUshort(sc, 0x15, 0x00f3);
11465 MP_WritePhyUshort(sc, 0x19, 0x0000);
11466 MP_WritePhyUshort(sc, 0x15, 0x00f4);
11467 MP_WritePhyUshort(sc, 0x19, 0x0000);
11468 MP_WritePhyUshort(sc, 0x15, 0x00f5);
11469 MP_WritePhyUshort(sc, 0x19, 0x0000);
11470 MP_WritePhyUshort(sc, 0x15, 0x00f6);
11471 MP_WritePhyUshort(sc, 0x19, 0x4408);
11472 MP_WritePhyUshort(sc, 0x15, 0x00f7);
11473 MP_WritePhyUshort(sc, 0x19, 0x480b);
11474 MP_WritePhyUshort(sc, 0x15, 0x00f8);
11475 MP_WritePhyUshort(sc, 0x19, 0x6f03);
11476 MP_WritePhyUshort(sc, 0x15, 0x00f9);
11477 MP_WritePhyUshort(sc, 0x19, 0x405f);
11478 MP_WritePhyUshort(sc, 0x15, 0x00fa);
11479 MP_WritePhyUshort(sc, 0x19, 0x4448);
11480 MP_WritePhyUshort(sc, 0x15, 0x00fb);
11481 MP_WritePhyUshort(sc, 0x19, 0x4020);
11482 MP_WritePhyUshort(sc, 0x15, 0x00fc);
11483 MP_WritePhyUshort(sc, 0x19, 0x4468);
11484 MP_WritePhyUshort(sc, 0x15, 0x00fd);
11485 MP_WritePhyUshort(sc, 0x19, 0x9c03);
11486 MP_WritePhyUshort(sc, 0x15, 0x00fe);
11487 MP_WritePhyUshort(sc, 0x19, 0x6f07);
11488 MP_WritePhyUshort(sc, 0x15, 0x00ff);
11489 MP_WritePhyUshort(sc, 0x19, 0x58a0);
11490 MP_WritePhyUshort(sc, 0x15, 0x0100);
11491 MP_WritePhyUshort(sc, 0x19, 0xd6d1);
11492 MP_WritePhyUshort(sc, 0x15, 0x0101);
11493 MP_WritePhyUshort(sc, 0x19, 0x0004);
11494 MP_WritePhyUshort(sc, 0x15, 0x0102);
11495 MP_WritePhyUshort(sc, 0x19, 0xc137);
11496 MP_WritePhyUshort(sc, 0x15, 0x0103);
11497 MP_WritePhyUshort(sc, 0x19, 0x0002);
11498 MP_WritePhyUshort(sc, 0x15, 0x0104);
11499 MP_WritePhyUshort(sc, 0x19, 0xa0e5);
11500 MP_WritePhyUshort(sc, 0x15, 0x0105);
11501 MP_WritePhyUshort(sc, 0x19, 0x9df8);
11502 MP_WritePhyUshort(sc, 0x15, 0x0106);
11503 MP_WritePhyUshort(sc, 0x19, 0x30c6);
11504 MP_WritePhyUshort(sc, 0x15, 0x0107);
11505 MP_WritePhyUshort(sc, 0x19, 0x0000);
11506 MP_WritePhyUshort(sc, 0x15, 0x0108);
11507 MP_WritePhyUshort(sc, 0x19, 0x0000);
11508 MP_WritePhyUshort(sc, 0x15, 0x0109);
11509 MP_WritePhyUshort(sc, 0x19, 0x0000);
11510 MP_WritePhyUshort(sc, 0x15, 0x010a);
11511 MP_WritePhyUshort(sc, 0x19, 0x0000);
11512 MP_WritePhyUshort(sc, 0x15, 0x010b);
11513 MP_WritePhyUshort(sc, 0x19, 0x4808);
11514 MP_WritePhyUshort(sc, 0x15, 0x010c);
11515 MP_WritePhyUshort(sc, 0x19, 0xc32d);
11516 MP_WritePhyUshort(sc, 0x15, 0x010d);
11517 MP_WritePhyUshort(sc, 0x19, 0x0003);
11518 MP_WritePhyUshort(sc, 0x15, 0x010e);
11519 MP_WritePhyUshort(sc, 0x19, 0xc8b3);
11520 MP_WritePhyUshort(sc, 0x15, 0x010f);
11521 MP_WritePhyUshort(sc, 0x19, 0x00fc);
11522 MP_WritePhyUshort(sc, 0x15, 0x0110);
11523 MP_WritePhyUshort(sc, 0x19, 0x4400);
11524 MP_WritePhyUshort(sc, 0x15, 0x0111);
11525 MP_WritePhyUshort(sc, 0x19, 0x3116);
11526 MP_WritePhyUshort(sc, 0x15, 0x0112);
11527 MP_WritePhyUshort(sc, 0x19, 0x0000);
11528 MP_WritePhyUshort(sc, 0x15, 0x0113);
11529 MP_WritePhyUshort(sc, 0x19, 0x0000);
11530 MP_WritePhyUshort(sc, 0x15, 0x0114);
11531 MP_WritePhyUshort(sc, 0x19, 0x0000);
11532 MP_WritePhyUshort(sc, 0x15, 0x0115);
11533 MP_WritePhyUshort(sc, 0x19, 0x0000);
11534 MP_WritePhyUshort(sc, 0x15, 0x0116);
11535 MP_WritePhyUshort(sc, 0x19, 0x4803);
11536 MP_WritePhyUshort(sc, 0x15, 0x0117);
11537 MP_WritePhyUshort(sc, 0x19, 0x7c03);
11538 MP_WritePhyUshort(sc, 0x15, 0x0118);
11539 MP_WritePhyUshort(sc, 0x19, 0x6c02);
11540 MP_WritePhyUshort(sc, 0x15, 0x0119);
11541 MP_WritePhyUshort(sc, 0x19, 0x7c04);
11542 MP_WritePhyUshort(sc, 0x15, 0x011a);
11543 MP_WritePhyUshort(sc, 0x19, 0x6000);
11544 MP_WritePhyUshort(sc, 0x15, 0x011b);
11545 MP_WritePhyUshort(sc, 0x19, 0x5cf7);
11546 MP_WritePhyUshort(sc, 0x15, 0x011c);
11547 MP_WritePhyUshort(sc, 0x19, 0x7c2a);
11548 MP_WritePhyUshort(sc, 0x15, 0x011d);
11549 MP_WritePhyUshort(sc, 0x19, 0x5800);
11550 MP_WritePhyUshort(sc, 0x15, 0x011e);
11551 MP_WritePhyUshort(sc, 0x19, 0x5400);
11552 MP_WritePhyUshort(sc, 0x15, 0x011f);
11553 MP_WritePhyUshort(sc, 0x19, 0x7c08);
11554 MP_WritePhyUshort(sc, 0x15, 0x0120);
11555 MP_WritePhyUshort(sc, 0x19, 0x74f0);
11556 MP_WritePhyUshort(sc, 0x15, 0x0121);
11557 MP_WritePhyUshort(sc, 0x19, 0x4019);
11558 MP_WritePhyUshort(sc, 0x15, 0x0122);
11559 MP_WritePhyUshort(sc, 0x19, 0x440d);
11560 MP_WritePhyUshort(sc, 0x15, 0x0123);
11561 MP_WritePhyUshort(sc, 0x19, 0xb6c1);
11562 MP_WritePhyUshort(sc, 0x15, 0x0124);
11563 MP_WritePhyUshort(sc, 0x19, 0xc05b);
11564 MP_WritePhyUshort(sc, 0x15, 0x0125);
11565 MP_WritePhyUshort(sc, 0x19, 0x00bf);
11566 MP_WritePhyUshort(sc, 0x15, 0x0126);
11567 MP_WritePhyUshort(sc, 0x19, 0xc025);
11568 MP_WritePhyUshort(sc, 0x15, 0x0127);
11569 MP_WritePhyUshort(sc, 0x19, 0x00bd);
11570 MP_WritePhyUshort(sc, 0x15, 0x0128);
11571 MP_WritePhyUshort(sc, 0x19, 0xc603);
11572 MP_WritePhyUshort(sc, 0x15, 0x0129);
11573 MP_WritePhyUshort(sc, 0x19, 0x00bb);
11574 MP_WritePhyUshort(sc, 0x15, 0x012a);
11575 MP_WritePhyUshort(sc, 0x19, 0x8805);
11576 MP_WritePhyUshort(sc, 0x15, 0x012b);
11577 MP_WritePhyUshort(sc, 0x19, 0x7801);
11578 MP_WritePhyUshort(sc, 0x15, 0x012c);
11579 MP_WritePhyUshort(sc, 0x19, 0x4001);
11580 MP_WritePhyUshort(sc, 0x15, 0x012d);
11581 MP_WritePhyUshort(sc, 0x19, 0x7800);
11582 MP_WritePhyUshort(sc, 0x15, 0x012e);
11583 MP_WritePhyUshort(sc, 0x19, 0xa3dd);
11584 MP_WritePhyUshort(sc, 0x15, 0x012f);
11585 MP_WritePhyUshort(sc, 0x19, 0x7c03);
11586 MP_WritePhyUshort(sc, 0x15, 0x0130);
11587 MP_WritePhyUshort(sc, 0x19, 0x6c03);
11588 MP_WritePhyUshort(sc, 0x15, 0x0131);
11589 MP_WritePhyUshort(sc, 0x19, 0x8407);
11590 MP_WritePhyUshort(sc, 0x15, 0x0132);
11591 MP_WritePhyUshort(sc, 0x19, 0x7c03);
11592 MP_WritePhyUshort(sc, 0x15, 0x0133);
11593 MP_WritePhyUshort(sc, 0x19, 0x6c02);
11594 MP_WritePhyUshort(sc, 0x15, 0x0134);
11595 MP_WritePhyUshort(sc, 0x19, 0xd9b8);
11596 MP_WritePhyUshort(sc, 0x15, 0x0135);
11597 MP_WritePhyUshort(sc, 0x19, 0x0003);
11598 MP_WritePhyUshort(sc, 0x15, 0x0136);
11599 MP_WritePhyUshort(sc, 0x19, 0xc240);
11600 MP_WritePhyUshort(sc, 0x15, 0x0137);
11601 MP_WritePhyUshort(sc, 0x19, 0x0015);
11602 MP_WritePhyUshort(sc, 0x15, 0x0138);
11603 MP_WritePhyUshort(sc, 0x19, 0x7c03);
11604 MP_WritePhyUshort(sc, 0x15, 0x0139);
11605 MP_WritePhyUshort(sc, 0x19, 0x6c02);
11606 MP_WritePhyUshort(sc, 0x15, 0x013a);
11607 MP_WritePhyUshort(sc, 0x19, 0x9ae9);
11608 MP_WritePhyUshort(sc, 0x15, 0x013b);
11609 MP_WritePhyUshort(sc, 0x19, 0x3140);
11610 MP_WritePhyUshort(sc, 0x15, 0x013c);
11611 MP_WritePhyUshort(sc, 0x19, 0x0000);
11612 MP_WritePhyUshort(sc, 0x15, 0x013d);
11613 MP_WritePhyUshort(sc, 0x19, 0x0000);
11614 MP_WritePhyUshort(sc, 0x15, 0x013e);
11615 MP_WritePhyUshort(sc, 0x19, 0x0000);
11616 MP_WritePhyUshort(sc, 0x15, 0x013f);
11617 MP_WritePhyUshort(sc, 0x19, 0x0000);
11618 MP_WritePhyUshort(sc, 0x15, 0x0140);
11619 MP_WritePhyUshort(sc, 0x19, 0x4807);
11620 MP_WritePhyUshort(sc, 0x15, 0x0141);
11621 MP_WritePhyUshort(sc, 0x19, 0x4004);
11622 MP_WritePhyUshort(sc, 0x15, 0x0142);
11623 MP_WritePhyUshort(sc, 0x19, 0x4410);
11624 MP_WritePhyUshort(sc, 0x15, 0x0143);
11625 MP_WritePhyUshort(sc, 0x19, 0x7c0c);
11626 MP_WritePhyUshort(sc, 0x15, 0x0144);
11627 MP_WritePhyUshort(sc, 0x19, 0x600c);
11628 MP_WritePhyUshort(sc, 0x15, 0x0145);
11629 MP_WritePhyUshort(sc, 0x19, 0x9b00);
11630 MP_WritePhyUshort(sc, 0x15, 0x0146);
11631 MP_WritePhyUshort(sc, 0x19, 0xa68f);
11632 MP_WritePhyUshort(sc, 0x15, 0x0147);
11633 MP_WritePhyUshort(sc, 0x19, 0x3116);
11634 MP_WritePhyUshort(sc, 0x15, 0x0148);
11635 MP_WritePhyUshort(sc, 0x19, 0x0000);
11636 MP_WritePhyUshort(sc, 0x15, 0x0149);
11637 MP_WritePhyUshort(sc, 0x19, 0x0000);
11638 MP_WritePhyUshort(sc, 0x15, 0x014a);
11639 MP_WritePhyUshort(sc, 0x19, 0x0000);
11640 MP_WritePhyUshort(sc, 0x15, 0x014b);
11641 MP_WritePhyUshort(sc, 0x19, 0x0000);
11642 MP_WritePhyUshort(sc, 0x15, 0x014c);
11643 MP_WritePhyUshort(sc, 0x19, 0x4804);
11644 MP_WritePhyUshort(sc, 0x15, 0x014d);
11645 MP_WritePhyUshort(sc, 0x19, 0x54c0);
11646 MP_WritePhyUshort(sc, 0x15, 0x014e);
11647 MP_WritePhyUshort(sc, 0x19, 0xb703);
11648 MP_WritePhyUshort(sc, 0x15, 0x014f);
11649 MP_WritePhyUshort(sc, 0x19, 0x5cff);
11650 MP_WritePhyUshort(sc, 0x15, 0x0150);
11651 MP_WritePhyUshort(sc, 0x19, 0x315f);
11652 MP_WritePhyUshort(sc, 0x15, 0x0151);
11653 MP_WritePhyUshort(sc, 0x19, 0x7c08);
11654 MP_WritePhyUshort(sc, 0x15, 0x0152);
11655 MP_WritePhyUshort(sc, 0x19, 0x74f8);
11656 MP_WritePhyUshort(sc, 0x15, 0x0153);
11657 MP_WritePhyUshort(sc, 0x19, 0x6421);
11658 MP_WritePhyUshort(sc, 0x15, 0x0154);
11659 MP_WritePhyUshort(sc, 0x19, 0x7c08);
11660 MP_WritePhyUshort(sc, 0x15, 0x0155);
11661 MP_WritePhyUshort(sc, 0x19, 0x6000);
11662 MP_WritePhyUshort(sc, 0x15, 0x0156);
11663 MP_WritePhyUshort(sc, 0x19, 0x4003);
11664 MP_WritePhyUshort(sc, 0x15, 0x0157);
11665 MP_WritePhyUshort(sc, 0x19, 0x4418);
11666 MP_WritePhyUshort(sc, 0x15, 0x0158);
11667 MP_WritePhyUshort(sc, 0x19, 0x9b00);
11668 MP_WritePhyUshort(sc, 0x15, 0x0159);
11669 MP_WritePhyUshort(sc, 0x19, 0x6461);
11670 MP_WritePhyUshort(sc, 0x15, 0x015a);
11671 MP_WritePhyUshort(sc, 0x19, 0x64e1);
11672 MP_WritePhyUshort(sc, 0x15, 0x015b);
11673 MP_WritePhyUshort(sc, 0x19, 0x7c20);
11674 MP_WritePhyUshort(sc, 0x15, 0x015c);
11675 MP_WritePhyUshort(sc, 0x19, 0x5820);
11676 MP_WritePhyUshort(sc, 0x15, 0x015d);
11677 MP_WritePhyUshort(sc, 0x19, 0x5ccf);
11678 MP_WritePhyUshort(sc, 0x15, 0x015e);
11679 MP_WritePhyUshort(sc, 0x19, 0x7050);
11680 MP_WritePhyUshort(sc, 0x15, 0x015f);
11681 MP_WritePhyUshort(sc, 0x19, 0xd9b8);
11682 MP_WritePhyUshort(sc, 0x15, 0x0160);
11683 MP_WritePhyUshort(sc, 0x19, 0x0008);
11684 MP_WritePhyUshort(sc, 0x15, 0x0161);
11685 MP_WritePhyUshort(sc, 0x19, 0xdab1);
11686 MP_WritePhyUshort(sc, 0x15, 0x0162);
11687 MP_WritePhyUshort(sc, 0x19, 0x0015);
11688 MP_WritePhyUshort(sc, 0x15, 0x0163);
11689 MP_WritePhyUshort(sc, 0x19, 0xc244);
11690 MP_WritePhyUshort(sc, 0x15, 0x0164);
11691 MP_WritePhyUshort(sc, 0x19, 0x0013);
11692 MP_WritePhyUshort(sc, 0x15, 0x0165);
11693 MP_WritePhyUshort(sc, 0x19, 0xc021);
11694 MP_WritePhyUshort(sc, 0x15, 0x0166);
11695 MP_WritePhyUshort(sc, 0x19, 0x00f9);
11696 MP_WritePhyUshort(sc, 0x15, 0x0167);
11697 MP_WritePhyUshort(sc, 0x19, 0x3177);
11698 MP_WritePhyUshort(sc, 0x15, 0x0168);
11699 MP_WritePhyUshort(sc, 0x19, 0x5cf7);
11700 MP_WritePhyUshort(sc, 0x15, 0x0169);
11701 MP_WritePhyUshort(sc, 0x19, 0x4010);
11702 MP_WritePhyUshort(sc, 0x15, 0x016a);
11703 MP_WritePhyUshort(sc, 0x19, 0x4428);
11704 MP_WritePhyUshort(sc, 0x15, 0x016b);
11705 MP_WritePhyUshort(sc, 0x19, 0x9c00);
11706 MP_WritePhyUshort(sc, 0x15, 0x016c);
11707 MP_WritePhyUshort(sc, 0x19, 0x7c08);
11708 MP_WritePhyUshort(sc, 0x15, 0x016d);
11709 MP_WritePhyUshort(sc, 0x19, 0x6008);
11710 MP_WritePhyUshort(sc, 0x15, 0x016e);
11711 MP_WritePhyUshort(sc, 0x19, 0x7c08);
11712 MP_WritePhyUshort(sc, 0x15, 0x016f);
11713 MP_WritePhyUshort(sc, 0x19, 0x74f0);
11714 MP_WritePhyUshort(sc, 0x15, 0x0170);
11715 MP_WritePhyUshort(sc, 0x19, 0x6461);
11716 MP_WritePhyUshort(sc, 0x15, 0x0171);
11717 MP_WritePhyUshort(sc, 0x19, 0x6421);
11718 MP_WritePhyUshort(sc, 0x15, 0x0172);
11719 MP_WritePhyUshort(sc, 0x19, 0x64a1);
11720 MP_WritePhyUshort(sc, 0x15, 0x0173);
11721 MP_WritePhyUshort(sc, 0x19, 0x3116);
11722 MP_WritePhyUshort(sc, 0x15, 0x0174);
11723 MP_WritePhyUshort(sc, 0x19, 0x0000);
11724 MP_WritePhyUshort(sc, 0x15, 0x0175);
11725 MP_WritePhyUshort(sc, 0x19, 0x0000);
11726 MP_WritePhyUshort(sc, 0x15, 0x0176);
11727 MP_WritePhyUshort(sc, 0x19, 0x0000);
11728 MP_WritePhyUshort(sc, 0x15, 0x0177);
11729 MP_WritePhyUshort(sc, 0x19, 0x4805);
11730 MP_WritePhyUshort(sc, 0x15, 0x0178);
11731 MP_WritePhyUshort(sc, 0x19, 0xa103);
11732 MP_WritePhyUshort(sc, 0x15, 0x0179);
11733 MP_WritePhyUshort(sc, 0x19, 0x7c02);
11734 MP_WritePhyUshort(sc, 0x15, 0x017a);
11735 MP_WritePhyUshort(sc, 0x19, 0x6002);
11736 MP_WritePhyUshort(sc, 0x15, 0x017b);
11737 MP_WritePhyUshort(sc, 0x19, 0x7e00);
11738 MP_WritePhyUshort(sc, 0x15, 0x017c);
11739 MP_WritePhyUshort(sc, 0x19, 0x5400);
11740 MP_WritePhyUshort(sc, 0x15, 0x017d);
11741 MP_WritePhyUshort(sc, 0x19, 0x7c6b);
11742 MP_WritePhyUshort(sc, 0x15, 0x017e);
11743 MP_WritePhyUshort(sc, 0x19, 0x5c63);
11744 MP_WritePhyUshort(sc, 0x15, 0x017f);
11745 MP_WritePhyUshort(sc, 0x19, 0x407d);
11746 MP_WritePhyUshort(sc, 0x15, 0x0180);
11747 MP_WritePhyUshort(sc, 0x19, 0xa602);
11748 MP_WritePhyUshort(sc, 0x15, 0x0181);
11749 MP_WritePhyUshort(sc, 0x19, 0x4001);
11750 MP_WritePhyUshort(sc, 0x15, 0x0182);
11751 MP_WritePhyUshort(sc, 0x19, 0x4420);
11752 MP_WritePhyUshort(sc, 0x15, 0x0183);
11753 MP_WritePhyUshort(sc, 0x19, 0x4020);
11754 MP_WritePhyUshort(sc, 0x15, 0x0184);
11755 MP_WritePhyUshort(sc, 0x19, 0x44a1);
11756 MP_WritePhyUshort(sc, 0x15, 0x0185);
11757 MP_WritePhyUshort(sc, 0x19, 0xd6e0);
11758 MP_WritePhyUshort(sc, 0x15, 0x0186);
11759 MP_WritePhyUshort(sc, 0x19, 0x0009);
11760 MP_WritePhyUshort(sc, 0x15, 0x0187);
11761 MP_WritePhyUshort(sc, 0x19, 0x9efe);
11762 MP_WritePhyUshort(sc, 0x15, 0x0188);
11763 MP_WritePhyUshort(sc, 0x19, 0x7c02);
11764 MP_WritePhyUshort(sc, 0x15, 0x0189);
11765 MP_WritePhyUshort(sc, 0x19, 0x6000);
11766 MP_WritePhyUshort(sc, 0x15, 0x018a);
11767 MP_WritePhyUshort(sc, 0x19, 0x9c00);
11768 MP_WritePhyUshort(sc, 0x15, 0x018b);
11769 MP_WritePhyUshort(sc, 0x19, 0x318f);
11770 MP_WritePhyUshort(sc, 0x15, 0x018c);
11771 MP_WritePhyUshort(sc, 0x19, 0x0000);
11772 MP_WritePhyUshort(sc, 0x15, 0x018d);
11773 MP_WritePhyUshort(sc, 0x19, 0x0000);
11774 MP_WritePhyUshort(sc, 0x15, 0x018e);
11775 MP_WritePhyUshort(sc, 0x19, 0x0000);
11776 MP_WritePhyUshort(sc, 0x15, 0x018f);
11777 MP_WritePhyUshort(sc, 0x19, 0x4806);
11778 MP_WritePhyUshort(sc, 0x15, 0x0190);
11779 MP_WritePhyUshort(sc, 0x19, 0x7c10);
11780 MP_WritePhyUshort(sc, 0x15, 0x0191);
11781 MP_WritePhyUshort(sc, 0x19, 0x5c10);
11782 MP_WritePhyUshort(sc, 0x15, 0x0192);
11783 MP_WritePhyUshort(sc, 0x19, 0x40fa);
11784 MP_WritePhyUshort(sc, 0x15, 0x0193);
11785 MP_WritePhyUshort(sc, 0x19, 0xa602);
11786 MP_WritePhyUshort(sc, 0x15, 0x0194);
11787 MP_WritePhyUshort(sc, 0x19, 0x4010);
11788 MP_WritePhyUshort(sc, 0x15, 0x0195);
11789 MP_WritePhyUshort(sc, 0x19, 0x4440);
11790 MP_WritePhyUshort(sc, 0x15, 0x0196);
11791 MP_WritePhyUshort(sc, 0x19, 0x9d00);
11792 MP_WritePhyUshort(sc, 0x15, 0x0197);
11793 MP_WritePhyUshort(sc, 0x19, 0x7c80);
11794 MP_WritePhyUshort(sc, 0x15, 0x0198);
11795 MP_WritePhyUshort(sc, 0x19, 0x6400);
11796 MP_WritePhyUshort(sc, 0x15, 0x0199);
11797 MP_WritePhyUshort(sc, 0x19, 0x4003);
11798 MP_WritePhyUshort(sc, 0x15, 0x019a);
11799 MP_WritePhyUshort(sc, 0x19, 0x4540);
11800 MP_WritePhyUshort(sc, 0x15, 0x019b);
11801 MP_WritePhyUshort(sc, 0x19, 0x7c08);
11802 MP_WritePhyUshort(sc, 0x15, 0x019c);
11803 MP_WritePhyUshort(sc, 0x19, 0x6008);
11804 MP_WritePhyUshort(sc, 0x15, 0x019d);
11805 MP_WritePhyUshort(sc, 0x19, 0x9f00);
11806 MP_WritePhyUshort(sc, 0x15, 0x019e);
11807 MP_WritePhyUshort(sc, 0x19, 0x7c40);
11808 MP_WritePhyUshort(sc, 0x15, 0x019f);
11809 MP_WritePhyUshort(sc, 0x19, 0x6400);
11810 MP_WritePhyUshort(sc, 0x15, 0x01a0);
11811 MP_WritePhyUshort(sc, 0x19, 0x7c80);
11812 MP_WritePhyUshort(sc, 0x15, 0x01a1);
11813 MP_WritePhyUshort(sc, 0x19, 0x6480);
11814 MP_WritePhyUshort(sc, 0x15, 0x01a2);
11815 MP_WritePhyUshort(sc, 0x19, 0x3140);
11816 MP_WritePhyUshort(sc, 0x15, 0x01a3);
11817 MP_WritePhyUshort(sc, 0x19, 0x0000);
11818 MP_WritePhyUshort(sc, 0x15, 0x01a4);
11819 MP_WritePhyUshort(sc, 0x19, 0x0000);
11820 MP_WritePhyUshort(sc, 0x15, 0x01a5);
11821 MP_WritePhyUshort(sc, 0x19, 0x0000);
11822 MP_WritePhyUshort(sc, 0x15, 0x01a6);
11823 MP_WritePhyUshort(sc, 0x19, 0x4400);
11824 MP_WritePhyUshort(sc, 0x15, 0x01a7);
11825 MP_WritePhyUshort(sc, 0x19, 0x7c0b);
11826 MP_WritePhyUshort(sc, 0x15, 0x01a8);
11827 MP_WritePhyUshort(sc, 0x19, 0x6c01);
11828 MP_WritePhyUshort(sc, 0x15, 0x01a9);
11829 MP_WritePhyUshort(sc, 0x19, 0x64a8);
11830 MP_WritePhyUshort(sc, 0x15, 0x01aa);
11831 MP_WritePhyUshort(sc, 0x19, 0x6800);
11832 MP_WritePhyUshort(sc, 0x15, 0x01ab);
11833 MP_WritePhyUshort(sc, 0x19, 0x5cf0);
11834 MP_WritePhyUshort(sc, 0x15, 0x01ac);
11835 MP_WritePhyUshort(sc, 0x19, 0x588f);
11836 MP_WritePhyUshort(sc, 0x15, 0x01ad);
11837 MP_WritePhyUshort(sc, 0x19, 0xb628);
11838 MP_WritePhyUshort(sc, 0x15, 0x01ae);
11839 MP_WritePhyUshort(sc, 0x19, 0xc053);
11840 MP_WritePhyUshort(sc, 0x15, 0x01af);
11841 MP_WritePhyUshort(sc, 0x19, 0x0026);
11842 MP_WritePhyUshort(sc, 0x15, 0x01b0);
11843 MP_WritePhyUshort(sc, 0x19, 0xc02d);
11844 MP_WritePhyUshort(sc, 0x15, 0x01b1);
11845 MP_WritePhyUshort(sc, 0x19, 0x0024);
11846 MP_WritePhyUshort(sc, 0x15, 0x01b2);
11847 MP_WritePhyUshort(sc, 0x19, 0xc603);
11848 MP_WritePhyUshort(sc, 0x15, 0x01b3);
11849 MP_WritePhyUshort(sc, 0x19, 0x0022);
11850 MP_WritePhyUshort(sc, 0x15, 0x01b4);
11851 MP_WritePhyUshort(sc, 0x19, 0x8cf9);
11852 MP_WritePhyUshort(sc, 0x15, 0x01b5);
11853 MP_WritePhyUshort(sc, 0x19, 0x31ba);
11854 MP_WritePhyUshort(sc, 0x15, 0x01b6);
11855 MP_WritePhyUshort(sc, 0x19, 0x0000);
11856 MP_WritePhyUshort(sc, 0x15, 0x01b7);
11857 MP_WritePhyUshort(sc, 0x19, 0x0000);
11858 MP_WritePhyUshort(sc, 0x15, 0x01b8);
11859 MP_WritePhyUshort(sc, 0x19, 0x0000);
11860 MP_WritePhyUshort(sc, 0x15, 0x01b9);
11861 MP_WritePhyUshort(sc, 0x19, 0x0000);
11862 MP_WritePhyUshort(sc, 0x15, 0x01ba);
11863 MP_WritePhyUshort(sc, 0x19, 0x4400);
11864 MP_WritePhyUshort(sc, 0x15, 0x01bb);
11865 MP_WritePhyUshort(sc, 0x19, 0x5420);
11866 MP_WritePhyUshort(sc, 0x15, 0x01bc);
11867 MP_WritePhyUshort(sc, 0x19, 0x4811);
11868 MP_WritePhyUshort(sc, 0x15, 0x01bd);
11869 MP_WritePhyUshort(sc, 0x19, 0x5000);
11870 MP_WritePhyUshort(sc, 0x15, 0x01be);
11871 MP_WritePhyUshort(sc, 0x19, 0x4801);
11872 MP_WritePhyUshort(sc, 0x15, 0x01bf);
11873 MP_WritePhyUshort(sc, 0x19, 0x6800);
11874 MP_WritePhyUshort(sc, 0x15, 0x01c0);
11875 MP_WritePhyUshort(sc, 0x19, 0x31f5);
11876 MP_WritePhyUshort(sc, 0x15, 0x01c1);
11877 MP_WritePhyUshort(sc, 0x19, 0xb614);
11878 MP_WritePhyUshort(sc, 0x15, 0x01c2);
11879 MP_WritePhyUshort(sc, 0x19, 0x8ce4);
11880 MP_WritePhyUshort(sc, 0x15, 0x01c3);
11881 MP_WritePhyUshort(sc, 0x19, 0xb30c);
11882 MP_WritePhyUshort(sc, 0x15, 0x01c4);
11883 MP_WritePhyUshort(sc, 0x19, 0x7c03);
11884 MP_WritePhyUshort(sc, 0x15, 0x01c5);
11885 MP_WritePhyUshort(sc, 0x19, 0x6c02);
11886 MP_WritePhyUshort(sc, 0x15, 0x01c6);
11887 MP_WritePhyUshort(sc, 0x19, 0x8206);
11888 MP_WritePhyUshort(sc, 0x15, 0x01c7);
11889 MP_WritePhyUshort(sc, 0x19, 0x7c03);
11890 MP_WritePhyUshort(sc, 0x15, 0x01c8);
11891 MP_WritePhyUshort(sc, 0x19, 0x6c00);
11892 MP_WritePhyUshort(sc, 0x15, 0x01c9);
11893 MP_WritePhyUshort(sc, 0x19, 0x7c04);
11894 MP_WritePhyUshort(sc, 0x15, 0x01ca);
11895 MP_WritePhyUshort(sc, 0x19, 0x7404);
11896 MP_WritePhyUshort(sc, 0x15, 0x01cb);
11897 MP_WritePhyUshort(sc, 0x19, 0x31c0);
11898 MP_WritePhyUshort(sc, 0x15, 0x01cc);
11899 MP_WritePhyUshort(sc, 0x19, 0x7c04);
11900 MP_WritePhyUshort(sc, 0x15, 0x01cd);
11901 MP_WritePhyUshort(sc, 0x19, 0x7400);
11902 MP_WritePhyUshort(sc, 0x15, 0x01ce);
11903 MP_WritePhyUshort(sc, 0x19, 0x31c0);
11904 MP_WritePhyUshort(sc, 0x15, 0x01cf);
11905 MP_WritePhyUshort(sc, 0x19, 0x8df1);
11906 MP_WritePhyUshort(sc, 0x15, 0x01d0);
11907 MP_WritePhyUshort(sc, 0x19, 0x3248);
11908 MP_WritePhyUshort(sc, 0x15, 0x01d1);
11909 MP_WritePhyUshort(sc, 0x19, 0x0000);
11910 MP_WritePhyUshort(sc, 0x15, 0x01d2);
11911 MP_WritePhyUshort(sc, 0x19, 0x0000);
11912 MP_WritePhyUshort(sc, 0x15, 0x01d3);
11913 MP_WritePhyUshort(sc, 0x19, 0x0000);
11914 MP_WritePhyUshort(sc, 0x15, 0x01d4);
11915 MP_WritePhyUshort(sc, 0x19, 0x0000);
11916 MP_WritePhyUshort(sc, 0x15, 0x01d5);
11917 MP_WritePhyUshort(sc, 0x19, 0x4400);
11918 MP_WritePhyUshort(sc, 0x15, 0x01d6);
11919 MP_WritePhyUshort(sc, 0x19, 0x7c03);
11920 MP_WritePhyUshort(sc, 0x15, 0x01d7);
11921 MP_WritePhyUshort(sc, 0x19, 0x6c03);
11922 MP_WritePhyUshort(sc, 0x15, 0x01d8);
11923 MP_WritePhyUshort(sc, 0x19, 0x7670);
11924 MP_WritePhyUshort(sc, 0x15, 0x01d9);
11925 MP_WritePhyUshort(sc, 0x19, 0x4023);
11926 MP_WritePhyUshort(sc, 0x15, 0x01da);
11927 MP_WritePhyUshort(sc, 0x19, 0x4500);
11928 MP_WritePhyUshort(sc, 0x15, 0x01db);
11929 MP_WritePhyUshort(sc, 0x19, 0x4069);
11930 MP_WritePhyUshort(sc, 0x15, 0x01dc);
11931 MP_WritePhyUshort(sc, 0x19, 0x4580);
11932 MP_WritePhyUshort(sc, 0x15, 0x01dd);
11933 MP_WritePhyUshort(sc, 0x19, 0x9f00);
11934 MP_WritePhyUshort(sc, 0x15, 0x01de);
11935 MP_WritePhyUshort(sc, 0x19, 0xcff5);
11936 MP_WritePhyUshort(sc, 0x15, 0x01df);
11937 MP_WritePhyUshort(sc, 0x19, 0x00ff);
11938 MP_WritePhyUshort(sc, 0x15, 0x01e0);
11939 MP_WritePhyUshort(sc, 0x19, 0x76f0);
11940 MP_WritePhyUshort(sc, 0x15, 0x01e1);
11941 MP_WritePhyUshort(sc, 0x19, 0x4400);
11942 MP_WritePhyUshort(sc, 0x15, 0x01e2);
11943 MP_WritePhyUshort(sc, 0x19, 0x4023);
11944 MP_WritePhyUshort(sc, 0x15, 0x01e3);
11945 MP_WritePhyUshort(sc, 0x19, 0x4500);
11946 MP_WritePhyUshort(sc, 0x15, 0x01e4);
11947 MP_WritePhyUshort(sc, 0x19, 0x4069);
11948 MP_WritePhyUshort(sc, 0x15, 0x01e5);
11949 MP_WritePhyUshort(sc, 0x19, 0x4580);
11950 MP_WritePhyUshort(sc, 0x15, 0x01e6);
11951 MP_WritePhyUshort(sc, 0x19, 0x9f00);
11952 MP_WritePhyUshort(sc, 0x15, 0x01e7);
11953 MP_WritePhyUshort(sc, 0x19, 0xd0f5);
11954 MP_WritePhyUshort(sc, 0x15, 0x01e8);
11955 MP_WritePhyUshort(sc, 0x19, 0x00ff);
11956 MP_WritePhyUshort(sc, 0x15, 0x01e9);
11957 MP_WritePhyUshort(sc, 0x19, 0x4400);
11958 MP_WritePhyUshort(sc, 0x15, 0x01ea);
11959 MP_WritePhyUshort(sc, 0x19, 0x7c03);
11960 MP_WritePhyUshort(sc, 0x15, 0x01eb);
11961 MP_WritePhyUshort(sc, 0x19, 0x6800);
11962 MP_WritePhyUshort(sc, 0x15, 0x01ec);
11963 MP_WritePhyUshort(sc, 0x19, 0x66a0);
11964 MP_WritePhyUshort(sc, 0x15, 0x01ed);
11965 MP_WritePhyUshort(sc, 0x19, 0x8300);
11966 MP_WritePhyUshort(sc, 0x15, 0x01ee);
11967 MP_WritePhyUshort(sc, 0x19, 0x74f0);
11968 MP_WritePhyUshort(sc, 0x15, 0x01ef);
11969 MP_WritePhyUshort(sc, 0x19, 0x3006);
11970 MP_WritePhyUshort(sc, 0x15, 0x01f0);
11971 MP_WritePhyUshort(sc, 0x19, 0x0000);
11972 MP_WritePhyUshort(sc, 0x15, 0x01f1);
11973 MP_WritePhyUshort(sc, 0x19, 0x0000);
11974 MP_WritePhyUshort(sc, 0x15, 0x01f2);
11975 MP_WritePhyUshort(sc, 0x19, 0x0000);
11976 MP_WritePhyUshort(sc, 0x15, 0x01f3);
11977 MP_WritePhyUshort(sc, 0x19, 0x0000);
11978 MP_WritePhyUshort(sc, 0x15, 0x01f4);
11979 MP_WritePhyUshort(sc, 0x19, 0x0000);
11980 MP_WritePhyUshort(sc, 0x15, 0x01f5);
11981 MP_WritePhyUshort(sc, 0x19, 0x7c03);
11982 MP_WritePhyUshort(sc, 0x15, 0x01f6);
11983 MP_WritePhyUshort(sc, 0x19, 0x6c02);
11984 MP_WritePhyUshort(sc, 0x15, 0x01f7);
11985 MP_WritePhyUshort(sc, 0x19, 0x409d);
11986 MP_WritePhyUshort(sc, 0x15, 0x01f8);
11987 MP_WritePhyUshort(sc, 0x19, 0x7c87);
11988 MP_WritePhyUshort(sc, 0x15, 0x01f9);
11989 MP_WritePhyUshort(sc, 0x19, 0xae14);
11990 MP_WritePhyUshort(sc, 0x15, 0x01fa);
11991 MP_WritePhyUshort(sc, 0x19, 0x4400);
11992 MP_WritePhyUshort(sc, 0x15, 0x01fb);
11993 MP_WritePhyUshort(sc, 0x19, 0x7c40);
11994 MP_WritePhyUshort(sc, 0x15, 0x01fc);
11995 MP_WritePhyUshort(sc, 0x19, 0x6800);
11996 MP_WritePhyUshort(sc, 0x15, 0x01fd);
11997 MP_WritePhyUshort(sc, 0x19, 0x7801);
11998 MP_WritePhyUshort(sc, 0x15, 0x01fe);
11999 MP_WritePhyUshort(sc, 0x19, 0x980e);
12000 MP_WritePhyUshort(sc, 0x15, 0x01ff);
12001 MP_WritePhyUshort(sc, 0x19, 0x930c);
12002 MP_WritePhyUshort(sc, 0x15, 0x0200);
12003 MP_WritePhyUshort(sc, 0x19, 0x9206);
12004 MP_WritePhyUshort(sc, 0x15, 0x0201);
12005 MP_WritePhyUshort(sc, 0x19, 0x4002);
12006 MP_WritePhyUshort(sc, 0x15, 0x0202);
12007 MP_WritePhyUshort(sc, 0x19, 0x7800);
12008 MP_WritePhyUshort(sc, 0x15, 0x0203);
12009 MP_WritePhyUshort(sc, 0x19, 0x588f);
12010 MP_WritePhyUshort(sc, 0x15, 0x0204);
12011 MP_WritePhyUshort(sc, 0x19, 0x5520);
12012 MP_WritePhyUshort(sc, 0x15, 0x0205);
12013 MP_WritePhyUshort(sc, 0x19, 0x320c);
12014 MP_WritePhyUshort(sc, 0x15, 0x0206);
12015 MP_WritePhyUshort(sc, 0x19, 0x4000);
12016 MP_WritePhyUshort(sc, 0x15, 0x0207);
12017 MP_WritePhyUshort(sc, 0x19, 0x7800);
12018 MP_WritePhyUshort(sc, 0x15, 0x0208);
12019 MP_WritePhyUshort(sc, 0x19, 0x588d);
12020 MP_WritePhyUshort(sc, 0x15, 0x0209);
12021 MP_WritePhyUshort(sc, 0x19, 0x5500);
12022 MP_WritePhyUshort(sc, 0x15, 0x020a);
12023 MP_WritePhyUshort(sc, 0x19, 0x320c);
12024 MP_WritePhyUshort(sc, 0x15, 0x020b);
12025 MP_WritePhyUshort(sc, 0x19, 0x4002);
12026 MP_WritePhyUshort(sc, 0x15, 0x020c);
12027 MP_WritePhyUshort(sc, 0x19, 0x3220);
12028 MP_WritePhyUshort(sc, 0x15, 0x020d);
12029 MP_WritePhyUshort(sc, 0x19, 0x4480);
12030 MP_WritePhyUshort(sc, 0x15, 0x020e);
12031 MP_WritePhyUshort(sc, 0x19, 0x9e03);
12032 MP_WritePhyUshort(sc, 0x15, 0x020f);
12033 MP_WritePhyUshort(sc, 0x19, 0x7c40);
12034 MP_WritePhyUshort(sc, 0x15, 0x0210);
12035 MP_WritePhyUshort(sc, 0x19, 0x6840);
12036 MP_WritePhyUshort(sc, 0x15, 0x0211);
12037 MP_WritePhyUshort(sc, 0x19, 0x7801);
12038 MP_WritePhyUshort(sc, 0x15, 0x0212);
12039 MP_WritePhyUshort(sc, 0x19, 0x980e);
12040 MP_WritePhyUshort(sc, 0x15, 0x0213);
12041 MP_WritePhyUshort(sc, 0x19, 0x930c);
12042 MP_WritePhyUshort(sc, 0x15, 0x0214);
12043 MP_WritePhyUshort(sc, 0x19, 0x9206);
12044 MP_WritePhyUshort(sc, 0x15, 0x0215);
12045 MP_WritePhyUshort(sc, 0x19, 0x4000);
12046 MP_WritePhyUshort(sc, 0x15, 0x0216);
12047 MP_WritePhyUshort(sc, 0x19, 0x7800);
12048 MP_WritePhyUshort(sc, 0x15, 0x0217);
12049 MP_WritePhyUshort(sc, 0x19, 0x588f);
12050 MP_WritePhyUshort(sc, 0x15, 0x0218);
12051 MP_WritePhyUshort(sc, 0x19, 0x5520);
12052 MP_WritePhyUshort(sc, 0x15, 0x0219);
12053 MP_WritePhyUshort(sc, 0x19, 0x3220);
12054 MP_WritePhyUshort(sc, 0x15, 0x021a);
12055 MP_WritePhyUshort(sc, 0x19, 0x4002);
12056 MP_WritePhyUshort(sc, 0x15, 0x021b);
12057 MP_WritePhyUshort(sc, 0x19, 0x7800);
12058 MP_WritePhyUshort(sc, 0x15, 0x021c);
12059 MP_WritePhyUshort(sc, 0x19, 0x588d);
12060 MP_WritePhyUshort(sc, 0x15, 0x021d);
12061 MP_WritePhyUshort(sc, 0x19, 0x5540);
12062 MP_WritePhyUshort(sc, 0x15, 0x021e);
12063 MP_WritePhyUshort(sc, 0x19, 0x3220);
12064 MP_WritePhyUshort(sc, 0x15, 0x021f);
12065 MP_WritePhyUshort(sc, 0x19, 0x4000);
12066 MP_WritePhyUshort(sc, 0x15, 0x0220);
12067 MP_WritePhyUshort(sc, 0x19, 0x7800);
12068 MP_WritePhyUshort(sc, 0x15, 0x0221);
12069 MP_WritePhyUshort(sc, 0x19, 0x7c03);
12070 MP_WritePhyUshort(sc, 0x15, 0x0222);
12071 MP_WritePhyUshort(sc, 0x19, 0x6c00);
12072 MP_WritePhyUshort(sc, 0x15, 0x0223);
12073 MP_WritePhyUshort(sc, 0x19, 0x3231);
12074 MP_WritePhyUshort(sc, 0x15, 0x0224);
12075 MP_WritePhyUshort(sc, 0x19, 0xab06);
12076 MP_WritePhyUshort(sc, 0x15, 0x0225);
12077 MP_WritePhyUshort(sc, 0x19, 0xbf08);
12078 MP_WritePhyUshort(sc, 0x15, 0x0226);
12079 MP_WritePhyUshort(sc, 0x19, 0x4076);
12080 MP_WritePhyUshort(sc, 0x15, 0x0227);
12081 MP_WritePhyUshort(sc, 0x19, 0x7d07);
12082 MP_WritePhyUshort(sc, 0x15, 0x0228);
12083 MP_WritePhyUshort(sc, 0x19, 0x4502);
12084 MP_WritePhyUshort(sc, 0x15, 0x0229);
12085 MP_WritePhyUshort(sc, 0x19, 0x3231);
12086 MP_WritePhyUshort(sc, 0x15, 0x022a);
12087 MP_WritePhyUshort(sc, 0x19, 0x7d80);
12088 MP_WritePhyUshort(sc, 0x15, 0x022b);
12089 MP_WritePhyUshort(sc, 0x19, 0x5180);
12090 MP_WritePhyUshort(sc, 0x15, 0x022c);
12091 MP_WritePhyUshort(sc, 0x19, 0x322f);
12092 MP_WritePhyUshort(sc, 0x15, 0x022d);
12093 MP_WritePhyUshort(sc, 0x19, 0x7d80);
12094 MP_WritePhyUshort(sc, 0x15, 0x022e);
12095 MP_WritePhyUshort(sc, 0x19, 0x5000);
12096 MP_WritePhyUshort(sc, 0x15, 0x022f);
12097 MP_WritePhyUshort(sc, 0x19, 0x7d07);
12098 MP_WritePhyUshort(sc, 0x15, 0x0230);
12099 MP_WritePhyUshort(sc, 0x19, 0x4402);
12100 MP_WritePhyUshort(sc, 0x15, 0x0231);
12101 MP_WritePhyUshort(sc, 0x19, 0x7c03);
12102 MP_WritePhyUshort(sc, 0x15, 0x0232);
12103 MP_WritePhyUshort(sc, 0x19, 0x6c02);
12104 MP_WritePhyUshort(sc, 0x15, 0x0233);
12105 MP_WritePhyUshort(sc, 0x19, 0x7c03);
12106 MP_WritePhyUshort(sc, 0x15, 0x0234);
12107 MP_WritePhyUshort(sc, 0x19, 0xb309);
12108 MP_WritePhyUshort(sc, 0x15, 0x0235);
12109 MP_WritePhyUshort(sc, 0x19, 0xb204);
12110 MP_WritePhyUshort(sc, 0x15, 0x0236);
12111 MP_WritePhyUshort(sc, 0x19, 0xb105);
12112 MP_WritePhyUshort(sc, 0x15, 0x0237);
12113 MP_WritePhyUshort(sc, 0x19, 0x6c00);
12114 MP_WritePhyUshort(sc, 0x15, 0x0238);
12115 MP_WritePhyUshort(sc, 0x19, 0x31c1);
12116 MP_WritePhyUshort(sc, 0x15, 0x0239);
12117 MP_WritePhyUshort(sc, 0x19, 0x6c00);
12118 MP_WritePhyUshort(sc, 0x15, 0x023a);
12119 MP_WritePhyUshort(sc, 0x19, 0x3261);
12120 MP_WritePhyUshort(sc, 0x15, 0x023b);
12121 MP_WritePhyUshort(sc, 0x19, 0x6c00);
12122 MP_WritePhyUshort(sc, 0x15, 0x023c);
12123 MP_WritePhyUshort(sc, 0x19, 0x3250);
12124 MP_WritePhyUshort(sc, 0x15, 0x023d);
12125 MP_WritePhyUshort(sc, 0x19, 0xb203);
12126 MP_WritePhyUshort(sc, 0x15, 0x023e);
12127 MP_WritePhyUshort(sc, 0x19, 0x6c00);
12128 MP_WritePhyUshort(sc, 0x15, 0x023f);
12129 MP_WritePhyUshort(sc, 0x19, 0x327a);
12130 MP_WritePhyUshort(sc, 0x15, 0x0240);
12131 MP_WritePhyUshort(sc, 0x19, 0x6c00);
12132 MP_WritePhyUshort(sc, 0x15, 0x0241);
12133 MP_WritePhyUshort(sc, 0x19, 0x3293);
12134 MP_WritePhyUshort(sc, 0x15, 0x0242);
12135 MP_WritePhyUshort(sc, 0x19, 0x0000);
12136 MP_WritePhyUshort(sc, 0x15, 0x0243);
12137 MP_WritePhyUshort(sc, 0x19, 0x0000);
12138 MP_WritePhyUshort(sc, 0x15, 0x0244);
12139 MP_WritePhyUshort(sc, 0x19, 0x0000);
12140 MP_WritePhyUshort(sc, 0x15, 0x0245);
12141 MP_WritePhyUshort(sc, 0x19, 0x0000);
12142 MP_WritePhyUshort(sc, 0x15, 0x0246);
12143 MP_WritePhyUshort(sc, 0x19, 0x0000);
12144 MP_WritePhyUshort(sc, 0x15, 0x0247);
12145 MP_WritePhyUshort(sc, 0x19, 0x32a3);
12146 MP_WritePhyUshort(sc, 0x15, 0x0248);
12147 MP_WritePhyUshort(sc, 0x19, 0x5520);
12148 MP_WritePhyUshort(sc, 0x15, 0x0249);
12149 MP_WritePhyUshort(sc, 0x19, 0x403d);
12150 MP_WritePhyUshort(sc, 0x15, 0x024a);
12151 MP_WritePhyUshort(sc, 0x19, 0x440c);
12152 MP_WritePhyUshort(sc, 0x15, 0x024b);
12153 MP_WritePhyUshort(sc, 0x19, 0x4812);
12154 MP_WritePhyUshort(sc, 0x15, 0x024c);
12155 MP_WritePhyUshort(sc, 0x19, 0x5001);
12156 MP_WritePhyUshort(sc, 0x15, 0x024d);
12157 MP_WritePhyUshort(sc, 0x19, 0x4802);
12158 MP_WritePhyUshort(sc, 0x15, 0x024e);
12159 MP_WritePhyUshort(sc, 0x19, 0x6880);
12160 MP_WritePhyUshort(sc, 0x15, 0x024f);
12161 MP_WritePhyUshort(sc, 0x19, 0x31f5);
12162 MP_WritePhyUshort(sc, 0x15, 0x0250);
12163 MP_WritePhyUshort(sc, 0x19, 0xb685);
12164 MP_WritePhyUshort(sc, 0x15, 0x0251);
12165 MP_WritePhyUshort(sc, 0x19, 0x801c);
12166 MP_WritePhyUshort(sc, 0x15, 0x0252);
12167 MP_WritePhyUshort(sc, 0x19, 0xbaf5);
12168 MP_WritePhyUshort(sc, 0x15, 0x0253);
12169 MP_WritePhyUshort(sc, 0x19, 0xc07c);
12170 MP_WritePhyUshort(sc, 0x15, 0x0254);
12171 MP_WritePhyUshort(sc, 0x19, 0x00fb);
12172 MP_WritePhyUshort(sc, 0x15, 0x0255);
12173 MP_WritePhyUshort(sc, 0x19, 0x325a);
12174 MP_WritePhyUshort(sc, 0x15, 0x0256);
12175 MP_WritePhyUshort(sc, 0x19, 0x0000);
12176 MP_WritePhyUshort(sc, 0x15, 0x0257);
12177 MP_WritePhyUshort(sc, 0x19, 0x0000);
12178 MP_WritePhyUshort(sc, 0x15, 0x0258);
12179 MP_WritePhyUshort(sc, 0x19, 0x0000);
12180 MP_WritePhyUshort(sc, 0x15, 0x0259);
12181 MP_WritePhyUshort(sc, 0x19, 0x0000);
12182 MP_WritePhyUshort(sc, 0x15, 0x025a);
12183 MP_WritePhyUshort(sc, 0x19, 0x481a);
12184 MP_WritePhyUshort(sc, 0x15, 0x025b);
12185 MP_WritePhyUshort(sc, 0x19, 0x5001);
12186 MP_WritePhyUshort(sc, 0x15, 0x025c);
12187 MP_WritePhyUshort(sc, 0x19, 0x401b);
12188 MP_WritePhyUshort(sc, 0x15, 0x025d);
12189 MP_WritePhyUshort(sc, 0x19, 0x480a);
12190 MP_WritePhyUshort(sc, 0x15, 0x025e);
12191 MP_WritePhyUshort(sc, 0x19, 0x4418);
12192 MP_WritePhyUshort(sc, 0x15, 0x025f);
12193 MP_WritePhyUshort(sc, 0x19, 0x6900);
12194 MP_WritePhyUshort(sc, 0x15, 0x0260);
12195 MP_WritePhyUshort(sc, 0x19, 0x31f5);
12196 MP_WritePhyUshort(sc, 0x15, 0x0261);
12197 MP_WritePhyUshort(sc, 0x19, 0xb64b);
12198 MP_WritePhyUshort(sc, 0x15, 0x0262);
12199 MP_WritePhyUshort(sc, 0x19, 0xdb00);
12200 MP_WritePhyUshort(sc, 0x15, 0x0263);
12201 MP_WritePhyUshort(sc, 0x19, 0x0048);
12202 MP_WritePhyUshort(sc, 0x15, 0x0264);
12203 MP_WritePhyUshort(sc, 0x19, 0xdb7d);
12204 MP_WritePhyUshort(sc, 0x15, 0x0265);
12205 MP_WritePhyUshort(sc, 0x19, 0x0002);
12206 MP_WritePhyUshort(sc, 0x15, 0x0266);
12207 MP_WritePhyUshort(sc, 0x19, 0xa0fa);
12208 MP_WritePhyUshort(sc, 0x15, 0x0267);
12209 MP_WritePhyUshort(sc, 0x19, 0x4408);
12210 MP_WritePhyUshort(sc, 0x15, 0x0268);
12211 MP_WritePhyUshort(sc, 0x19, 0x3248);
12212 MP_WritePhyUshort(sc, 0x15, 0x0269);
12213 MP_WritePhyUshort(sc, 0x19, 0x0000);
12214 MP_WritePhyUshort(sc, 0x15, 0x026a);
12215 MP_WritePhyUshort(sc, 0x19, 0x0000);
12216 MP_WritePhyUshort(sc, 0x15, 0x026b);
12217 MP_WritePhyUshort(sc, 0x19, 0x0000);
12218 MP_WritePhyUshort(sc, 0x15, 0x026c);
12219 MP_WritePhyUshort(sc, 0x19, 0x0000);
12220 MP_WritePhyUshort(sc, 0x15, 0x026d);
12221 MP_WritePhyUshort(sc, 0x19, 0xb806);
12222 MP_WritePhyUshort(sc, 0x15, 0x026e);
12223 MP_WritePhyUshort(sc, 0x19, 0x588d);
12224 MP_WritePhyUshort(sc, 0x15, 0x026f);
12225 MP_WritePhyUshort(sc, 0x19, 0x5500);
12226 MP_WritePhyUshort(sc, 0x15, 0x0270);
12227 MP_WritePhyUshort(sc, 0x19, 0x7801);
12228 MP_WritePhyUshort(sc, 0x15, 0x0271);
12229 MP_WritePhyUshort(sc, 0x19, 0x4002);
12230 MP_WritePhyUshort(sc, 0x15, 0x0272);
12231 MP_WritePhyUshort(sc, 0x19, 0x7800);
12232 MP_WritePhyUshort(sc, 0x15, 0x0273);
12233 MP_WritePhyUshort(sc, 0x19, 0x4814);
12234 MP_WritePhyUshort(sc, 0x15, 0x0274);
12235 MP_WritePhyUshort(sc, 0x19, 0x500b);
12236 MP_WritePhyUshort(sc, 0x15, 0x0275);
12237 MP_WritePhyUshort(sc, 0x19, 0x4804);
12238 MP_WritePhyUshort(sc, 0x15, 0x0276);
12239 MP_WritePhyUshort(sc, 0x19, 0x40c4);
12240 MP_WritePhyUshort(sc, 0x15, 0x0277);
12241 MP_WritePhyUshort(sc, 0x19, 0x4425);
12242 MP_WritePhyUshort(sc, 0x15, 0x0278);
12243 MP_WritePhyUshort(sc, 0x19, 0x6a00);
12244 MP_WritePhyUshort(sc, 0x15, 0x0279);
12245 MP_WritePhyUshort(sc, 0x19, 0x31f5);
12246 MP_WritePhyUshort(sc, 0x15, 0x027a);
12247 MP_WritePhyUshort(sc, 0x19, 0xb632);
12248 MP_WritePhyUshort(sc, 0x15, 0x027b);
12249 MP_WritePhyUshort(sc, 0x19, 0xdc03);
12250 MP_WritePhyUshort(sc, 0x15, 0x027c);
12251 MP_WritePhyUshort(sc, 0x19, 0x0027);
12252 MP_WritePhyUshort(sc, 0x15, 0x027d);
12253 MP_WritePhyUshort(sc, 0x19, 0x80fc);
12254 MP_WritePhyUshort(sc, 0x15, 0x027e);
12255 MP_WritePhyUshort(sc, 0x19, 0x3283);
12256 MP_WritePhyUshort(sc, 0x15, 0x027f);
12257 MP_WritePhyUshort(sc, 0x19, 0x0000);
12258 MP_WritePhyUshort(sc, 0x15, 0x0280);
12259 MP_WritePhyUshort(sc, 0x19, 0x0000);
12260 MP_WritePhyUshort(sc, 0x15, 0x0281);
12261 MP_WritePhyUshort(sc, 0x19, 0x0000);
12262 MP_WritePhyUshort(sc, 0x15, 0x0282);
12263 MP_WritePhyUshort(sc, 0x19, 0x0000);
12264 MP_WritePhyUshort(sc, 0x15, 0x0283);
12265 MP_WritePhyUshort(sc, 0x19, 0xb806);
12266 MP_WritePhyUshort(sc, 0x15, 0x0284);
12267 MP_WritePhyUshort(sc, 0x19, 0x588f);
12268 MP_WritePhyUshort(sc, 0x15, 0x0285);
12269 MP_WritePhyUshort(sc, 0x19, 0x5520);
12270 MP_WritePhyUshort(sc, 0x15, 0x0286);
12271 MP_WritePhyUshort(sc, 0x19, 0x7801);
12272 MP_WritePhyUshort(sc, 0x15, 0x0287);
12273 MP_WritePhyUshort(sc, 0x19, 0x4000);
12274 MP_WritePhyUshort(sc, 0x15, 0x0288);
12275 MP_WritePhyUshort(sc, 0x19, 0x7800);
12276 MP_WritePhyUshort(sc, 0x15, 0x0289);
12277 MP_WritePhyUshort(sc, 0x19, 0x4818);
12278 MP_WritePhyUshort(sc, 0x15, 0x028a);
12279 MP_WritePhyUshort(sc, 0x19, 0x5051);
12280 MP_WritePhyUshort(sc, 0x15, 0x028b);
12281 MP_WritePhyUshort(sc, 0x19, 0x4808);
12282 MP_WritePhyUshort(sc, 0x15, 0x028c);
12283 MP_WritePhyUshort(sc, 0x19, 0x4050);
12284 MP_WritePhyUshort(sc, 0x15, 0x028d);
12285 MP_WritePhyUshort(sc, 0x19, 0x4462);
12286 MP_WritePhyUshort(sc, 0x15, 0x028e);
12287 MP_WritePhyUshort(sc, 0x19, 0x40c4);
12288 MP_WritePhyUshort(sc, 0x15, 0x028f);
12289 MP_WritePhyUshort(sc, 0x19, 0x4473);
12290 MP_WritePhyUshort(sc, 0x15, 0x0290);
12291 MP_WritePhyUshort(sc, 0x19, 0x5041);
12292 MP_WritePhyUshort(sc, 0x15, 0x0291);
12293 MP_WritePhyUshort(sc, 0x19, 0x6b00);
12294 MP_WritePhyUshort(sc, 0x15, 0x0292);
12295 MP_WritePhyUshort(sc, 0x19, 0x31f5);
12296 MP_WritePhyUshort(sc, 0x15, 0x0293);
12297 MP_WritePhyUshort(sc, 0x19, 0xb619);
12298 MP_WritePhyUshort(sc, 0x15, 0x0294);
12299 MP_WritePhyUshort(sc, 0x19, 0x80d9);
12300 MP_WritePhyUshort(sc, 0x15, 0x0295);
12301 MP_WritePhyUshort(sc, 0x19, 0xbd06);
12302 MP_WritePhyUshort(sc, 0x15, 0x0296);
12303 MP_WritePhyUshort(sc, 0x19, 0xbb0d);
12304 MP_WritePhyUshort(sc, 0x15, 0x0297);
12305 MP_WritePhyUshort(sc, 0x19, 0xaf14);
12306 MP_WritePhyUshort(sc, 0x15, 0x0298);
12307 MP_WritePhyUshort(sc, 0x19, 0x8efa);
12308 MP_WritePhyUshort(sc, 0x15, 0x0299);
12309 MP_WritePhyUshort(sc, 0x19, 0x5049);
12310 MP_WritePhyUshort(sc, 0x15, 0x029a);
12311 MP_WritePhyUshort(sc, 0x19, 0x3248);
12312 MP_WritePhyUshort(sc, 0x15, 0x029b);
12313 MP_WritePhyUshort(sc, 0x19, 0x4c10);
12314 MP_WritePhyUshort(sc, 0x15, 0x029c);
12315 MP_WritePhyUshort(sc, 0x19, 0x44b0);
12316 MP_WritePhyUshort(sc, 0x15, 0x029d);
12317 MP_WritePhyUshort(sc, 0x19, 0x4c00);
12318 MP_WritePhyUshort(sc, 0x15, 0x029e);
12319 MP_WritePhyUshort(sc, 0x19, 0x3292);
12320 MP_WritePhyUshort(sc, 0x15, 0x029f);
12321 MP_WritePhyUshort(sc, 0x19, 0x0000);
12322 MP_WritePhyUshort(sc, 0x15, 0x02a0);
12323 MP_WritePhyUshort(sc, 0x19, 0x0000);
12324 MP_WritePhyUshort(sc, 0x15, 0x02a1);
12325 MP_WritePhyUshort(sc, 0x19, 0x0000);
12326 MP_WritePhyUshort(sc, 0x15, 0x02a2);
12327 MP_WritePhyUshort(sc, 0x19, 0x0000);
12328 MP_WritePhyUshort(sc, 0x15, 0x02a3);
12329 MP_WritePhyUshort(sc, 0x19, 0x481f);
12330 MP_WritePhyUshort(sc, 0x15, 0x02a4);
12331 MP_WritePhyUshort(sc, 0x19, 0x5005);
12332 MP_WritePhyUshort(sc, 0x15, 0x02a5);
12333 MP_WritePhyUshort(sc, 0x19, 0x480f);
12334 MP_WritePhyUshort(sc, 0x15, 0x02a6);
12335 MP_WritePhyUshort(sc, 0x19, 0xac00);
12336 MP_WritePhyUshort(sc, 0x15, 0x02a7);
12337 MP_WritePhyUshort(sc, 0x19, 0x31a6);
12338 MP_WritePhyUshort(sc, 0x15, 0x02a8);
12339 MP_WritePhyUshort(sc, 0x19, 0x0000);
12340 MP_WritePhyUshort(sc, 0x15, 0x02a9);
12341 MP_WritePhyUshort(sc, 0x19, 0x0000);
12342 MP_WritePhyUshort(sc, 0x15, 0x02aa);
12343 MP_WritePhyUshort(sc, 0x19, 0x0000);
12344 MP_WritePhyUshort(sc, 0x15, 0x02ab);
12345 MP_WritePhyUshort(sc, 0x19, 0x31ba);
12346 MP_WritePhyUshort(sc, 0x15, 0x02ac);
12347 MP_WritePhyUshort(sc, 0x19, 0x31d5);
12348 MP_WritePhyUshort(sc, 0x15, 0x02ad);
12349 MP_WritePhyUshort(sc, 0x19, 0x0000);
12350 MP_WritePhyUshort(sc, 0x15, 0x02ae);
12351 MP_WritePhyUshort(sc, 0x19, 0x5cf0);
12352 MP_WritePhyUshort(sc, 0x15, 0x02af);
12353 MP_WritePhyUshort(sc, 0x19, 0x588c);
12354 MP_WritePhyUshort(sc, 0x15, 0x02b0);
12355 MP_WritePhyUshort(sc, 0x19, 0x542f);
12356 MP_WritePhyUshort(sc, 0x15, 0x02b1);
12357 MP_WritePhyUshort(sc, 0x19, 0x7ffb);
12358 MP_WritePhyUshort(sc, 0x15, 0x02b2);
12359 MP_WritePhyUshort(sc, 0x19, 0x6ff8);
12360 MP_WritePhyUshort(sc, 0x15, 0x02b3);
12361 MP_WritePhyUshort(sc, 0x19, 0x64a4);
12362 MP_WritePhyUshort(sc, 0x15, 0x02b4);
12363 MP_WritePhyUshort(sc, 0x19, 0x64a0);
12364 MP_WritePhyUshort(sc, 0x15, 0x02b5);
12365 MP_WritePhyUshort(sc, 0x19, 0x6800);
12366 MP_WritePhyUshort(sc, 0x15, 0x02b6);
12367 MP_WritePhyUshort(sc, 0x19, 0x4400);
12368 MP_WritePhyUshort(sc, 0x15, 0x02b7);
12369 MP_WritePhyUshort(sc, 0x19, 0x4020);
12370 MP_WritePhyUshort(sc, 0x15, 0x02b8);
12371 MP_WritePhyUshort(sc, 0x19, 0x4480);
12372 MP_WritePhyUshort(sc, 0x15, 0x02b9);
12373 MP_WritePhyUshort(sc, 0x19, 0x9e00);
12374 MP_WritePhyUshort(sc, 0x15, 0x02ba);
12375 MP_WritePhyUshort(sc, 0x19, 0x4891);
12376 MP_WritePhyUshort(sc, 0x15, 0x02bb);
12377 MP_WritePhyUshort(sc, 0x19, 0x4cc0);
12378 MP_WritePhyUshort(sc, 0x15, 0x02bc);
12379 MP_WritePhyUshort(sc, 0x19, 0x4801);
12380 MP_WritePhyUshort(sc, 0x15, 0x02bd);
12381 MP_WritePhyUshort(sc, 0x19, 0xa609);
12382 MP_WritePhyUshort(sc, 0x15, 0x02be);
12383 MP_WritePhyUshort(sc, 0x19, 0xd64f);
12384 MP_WritePhyUshort(sc, 0x15, 0x02bf);
12385 MP_WritePhyUshort(sc, 0x19, 0x004e);
12386 MP_WritePhyUshort(sc, 0x15, 0x02c0);
12387 MP_WritePhyUshort(sc, 0x19, 0x87fe);
12388 MP_WritePhyUshort(sc, 0x15, 0x02c1);
12389 MP_WritePhyUshort(sc, 0x19, 0x32c6);
12390 MP_WritePhyUshort(sc, 0x15, 0x02c2);
12391 MP_WritePhyUshort(sc, 0x19, 0x0000);
12392 MP_WritePhyUshort(sc, 0x15, 0x02c3);
12393 MP_WritePhyUshort(sc, 0x19, 0x0000);
12394 MP_WritePhyUshort(sc, 0x15, 0x02c4);
12395 MP_WritePhyUshort(sc, 0x19, 0x0000);
12396 MP_WritePhyUshort(sc, 0x15, 0x02c5);
12397 MP_WritePhyUshort(sc, 0x19, 0x0000);
12398 MP_WritePhyUshort(sc, 0x15, 0x02c6);
12399 MP_WritePhyUshort(sc, 0x19, 0x48b2);
12400 MP_WritePhyUshort(sc, 0x15, 0x02c7);
12401 MP_WritePhyUshort(sc, 0x19, 0x4020);
12402 MP_WritePhyUshort(sc, 0x15, 0x02c8);
12403 MP_WritePhyUshort(sc, 0x19, 0x4822);
12404 MP_WritePhyUshort(sc, 0x15, 0x02c9);
12405 MP_WritePhyUshort(sc, 0x19, 0x4488);
12406 MP_WritePhyUshort(sc, 0x15, 0x02ca);
12407 MP_WritePhyUshort(sc, 0x19, 0xd64f);
12408 MP_WritePhyUshort(sc, 0x15, 0x02cb);
12409 MP_WritePhyUshort(sc, 0x19, 0x0042);
12410 MP_WritePhyUshort(sc, 0x15, 0x02cc);
12411 MP_WritePhyUshort(sc, 0x19, 0x8203);
12412 MP_WritePhyUshort(sc, 0x15, 0x02cd);
12413 MP_WritePhyUshort(sc, 0x19, 0x4cc8);
12414 MP_WritePhyUshort(sc, 0x15, 0x02ce);
12415 MP_WritePhyUshort(sc, 0x19, 0x32d0);
12416 MP_WritePhyUshort(sc, 0x15, 0x02cf);
12417 MP_WritePhyUshort(sc, 0x19, 0x4cc0);
12418 MP_WritePhyUshort(sc, 0x15, 0x02d0);
12419 MP_WritePhyUshort(sc, 0x19, 0xc4d4);
12420 MP_WritePhyUshort(sc, 0x15, 0x02d1);
12421 MP_WritePhyUshort(sc, 0x19, 0x00f9);
12422 MP_WritePhyUshort(sc, 0x15, 0x02d2);
12423 MP_WritePhyUshort(sc, 0x19, 0xa51a);
12424 MP_WritePhyUshort(sc, 0x15, 0x02d3);
12425 MP_WritePhyUshort(sc, 0x19, 0x32d9);
12426 MP_WritePhyUshort(sc, 0x15, 0x02d4);
12427 MP_WritePhyUshort(sc, 0x19, 0x0000);
12428 MP_WritePhyUshort(sc, 0x15, 0x02d5);
12429 MP_WritePhyUshort(sc, 0x19, 0x0000);
12430 MP_WritePhyUshort(sc, 0x15, 0x02d6);
12431 MP_WritePhyUshort(sc, 0x19, 0x0000);
12432 MP_WritePhyUshort(sc, 0x15, 0x02d7);
12433 MP_WritePhyUshort(sc, 0x19, 0x0000);
12434 MP_WritePhyUshort(sc, 0x15, 0x02d8);
12435 MP_WritePhyUshort(sc, 0x19, 0x0000);
12436 MP_WritePhyUshort(sc, 0x15, 0x02d9);
12437 MP_WritePhyUshort(sc, 0x19, 0x48b3);
12438 MP_WritePhyUshort(sc, 0x15, 0x02da);
12439 MP_WritePhyUshort(sc, 0x19, 0x4020);
12440 MP_WritePhyUshort(sc, 0x15, 0x02db);
12441 MP_WritePhyUshort(sc, 0x19, 0x4823);
12442 MP_WritePhyUshort(sc, 0x15, 0x02dc);
12443 MP_WritePhyUshort(sc, 0x19, 0x4410);
12444 MP_WritePhyUshort(sc, 0x15, 0x02dd);
12445 MP_WritePhyUshort(sc, 0x19, 0xb630);
12446 MP_WritePhyUshort(sc, 0x15, 0x02de);
12447 MP_WritePhyUshort(sc, 0x19, 0x7dc8);
12448 MP_WritePhyUshort(sc, 0x15, 0x02df);
12449 MP_WritePhyUshort(sc, 0x19, 0x8203);
12450 MP_WritePhyUshort(sc, 0x15, 0x02e0);
12451 MP_WritePhyUshort(sc, 0x19, 0x4c48);
12452 MP_WritePhyUshort(sc, 0x15, 0x02e1);
12453 MP_WritePhyUshort(sc, 0x19, 0x32e3);
12454 MP_WritePhyUshort(sc, 0x15, 0x02e2);
12455 MP_WritePhyUshort(sc, 0x19, 0x4c40);
12456 MP_WritePhyUshort(sc, 0x15, 0x02e3);
12457 MP_WritePhyUshort(sc, 0x19, 0x9bfa);
12458 MP_WritePhyUshort(sc, 0x15, 0x02e4);
12459 MP_WritePhyUshort(sc, 0x19, 0x84ca);
12460 MP_WritePhyUshort(sc, 0x15, 0x02e5);
12461 MP_WritePhyUshort(sc, 0x19, 0x85f8);
12462 MP_WritePhyUshort(sc, 0x15, 0x02e6);
12463 MP_WritePhyUshort(sc, 0x19, 0x32ec);
12464 MP_WritePhyUshort(sc, 0x15, 0x02e7);
12465 MP_WritePhyUshort(sc, 0x19, 0x0000);
12466 MP_WritePhyUshort(sc, 0x15, 0x02e8);
12467 MP_WritePhyUshort(sc, 0x19, 0x0000);
12468 MP_WritePhyUshort(sc, 0x15, 0x02e9);
12469 MP_WritePhyUshort(sc, 0x19, 0x0000);
12470 MP_WritePhyUshort(sc, 0x15, 0x02ea);
12471 MP_WritePhyUshort(sc, 0x19, 0x0000);
12472 MP_WritePhyUshort(sc, 0x15, 0x02eb);
12473 MP_WritePhyUshort(sc, 0x19, 0x0000);
12474 MP_WritePhyUshort(sc, 0x15, 0x02ec);
12475 MP_WritePhyUshort(sc, 0x19, 0x48d4);
12476 MP_WritePhyUshort(sc, 0x15, 0x02ed);
12477 MP_WritePhyUshort(sc, 0x19, 0x4020);
12478 MP_WritePhyUshort(sc, 0x15, 0x02ee);
12479 MP_WritePhyUshort(sc, 0x19, 0x4844);
12480 MP_WritePhyUshort(sc, 0x15, 0x02ef);
12481 MP_WritePhyUshort(sc, 0x19, 0x4420);
12482 MP_WritePhyUshort(sc, 0x15, 0x02f0);
12483 MP_WritePhyUshort(sc, 0x19, 0x6800);
12484 MP_WritePhyUshort(sc, 0x15, 0x02f1);
12485 MP_WritePhyUshort(sc, 0x19, 0x7dc0);
12486 MP_WritePhyUshort(sc, 0x15, 0x02f2);
12487 MP_WritePhyUshort(sc, 0x19, 0x4c40);
12488 MP_WritePhyUshort(sc, 0x15, 0x02f3);
12489 MP_WritePhyUshort(sc, 0x19, 0x7c0b);
12490 MP_WritePhyUshort(sc, 0x15, 0x02f4);
12491 MP_WritePhyUshort(sc, 0x19, 0x6c08);
12492 MP_WritePhyUshort(sc, 0x15, 0x02f5);
12493 MP_WritePhyUshort(sc, 0x19, 0x3311);
12494 MP_WritePhyUshort(sc, 0x15, 0x02f6);
12495 MP_WritePhyUshort(sc, 0x19, 0x9cfd);
12496 MP_WritePhyUshort(sc, 0x15, 0x02f7);
12497 MP_WritePhyUshort(sc, 0x19, 0xb616);
12498 MP_WritePhyUshort(sc, 0x15, 0x02f8);
12499 MP_WritePhyUshort(sc, 0x19, 0xc42b);
12500 MP_WritePhyUshort(sc, 0x15, 0x02f9);
12501 MP_WritePhyUshort(sc, 0x19, 0x00e0);
12502 MP_WritePhyUshort(sc, 0x15, 0x02fa);
12503 MP_WritePhyUshort(sc, 0x19, 0xc455);
12504 MP_WritePhyUshort(sc, 0x15, 0x02fb);
12505 MP_WritePhyUshort(sc, 0x19, 0x00b3);
12506 MP_WritePhyUshort(sc, 0x15, 0x02fc);
12507 MP_WritePhyUshort(sc, 0x19, 0xb20a);
12508 MP_WritePhyUshort(sc, 0x15, 0x02fd);
12509 MP_WritePhyUshort(sc, 0x19, 0x7c03);
12510 MP_WritePhyUshort(sc, 0x15, 0x02fe);
12511 MP_WritePhyUshort(sc, 0x19, 0x6c02);
12512 MP_WritePhyUshort(sc, 0x15, 0x02ff);
12513 MP_WritePhyUshort(sc, 0x19, 0x8204);
12514 MP_WritePhyUshort(sc, 0x15, 0x0300);
12515 MP_WritePhyUshort(sc, 0x19, 0x7c04);
12516 MP_WritePhyUshort(sc, 0x15, 0x0301);
12517 MP_WritePhyUshort(sc, 0x19, 0x7404);
12518 MP_WritePhyUshort(sc, 0x15, 0x0302);
12519 MP_WritePhyUshort(sc, 0x19, 0x32f3);
12520 MP_WritePhyUshort(sc, 0x15, 0x0303);
12521 MP_WritePhyUshort(sc, 0x19, 0x7c04);
12522 MP_WritePhyUshort(sc, 0x15, 0x0304);
12523 MP_WritePhyUshort(sc, 0x19, 0x7400);
12524 MP_WritePhyUshort(sc, 0x15, 0x0305);
12525 MP_WritePhyUshort(sc, 0x19, 0x32f3);
12526 MP_WritePhyUshort(sc, 0x15, 0x0306);
12527 MP_WritePhyUshort(sc, 0x19, 0xefed);
12528 MP_WritePhyUshort(sc, 0x15, 0x0307);
12529 MP_WritePhyUshort(sc, 0x19, 0x3342);
12530 MP_WritePhyUshort(sc, 0x15, 0x0308);
12531 MP_WritePhyUshort(sc, 0x19, 0x0000);
12532 MP_WritePhyUshort(sc, 0x15, 0x0309);
12533 MP_WritePhyUshort(sc, 0x19, 0x0000);
12534 MP_WritePhyUshort(sc, 0x15, 0x030a);
12535 MP_WritePhyUshort(sc, 0x19, 0x0000);
12536 MP_WritePhyUshort(sc, 0x15, 0x030b);
12537 MP_WritePhyUshort(sc, 0x19, 0x0000);
12538 MP_WritePhyUshort(sc, 0x15, 0x030c);
12539 MP_WritePhyUshort(sc, 0x19, 0x0000);
12540 MP_WritePhyUshort(sc, 0x15, 0x030d);
12541 MP_WritePhyUshort(sc, 0x19, 0x3006);
12542 MP_WritePhyUshort(sc, 0x15, 0x030e);
12543 MP_WritePhyUshort(sc, 0x19, 0x0000);
12544 MP_WritePhyUshort(sc, 0x15, 0x030f);
12545 MP_WritePhyUshort(sc, 0x19, 0x0000);
12546 MP_WritePhyUshort(sc, 0x15, 0x0310);
12547 MP_WritePhyUshort(sc, 0x19, 0x0000);
12548 MP_WritePhyUshort(sc, 0x15, 0x0311);
12549 MP_WritePhyUshort(sc, 0x19, 0x7c08);
12550 MP_WritePhyUshort(sc, 0x15, 0x0312);
12551 MP_WritePhyUshort(sc, 0x19, 0xa207);
12552 MP_WritePhyUshort(sc, 0x15, 0x0313);
12553 MP_WritePhyUshort(sc, 0x19, 0x4c00);
12554 MP_WritePhyUshort(sc, 0x15, 0x0314);
12555 MP_WritePhyUshort(sc, 0x19, 0x3322);
12556 MP_WritePhyUshort(sc, 0x15, 0x0315);
12557 MP_WritePhyUshort(sc, 0x19, 0x4041);
12558 MP_WritePhyUshort(sc, 0x15, 0x0316);
12559 MP_WritePhyUshort(sc, 0x19, 0x7d07);
12560 MP_WritePhyUshort(sc, 0x15, 0x0317);
12561 MP_WritePhyUshort(sc, 0x19, 0x4502);
12562 MP_WritePhyUshort(sc, 0x15, 0x0318);
12563 MP_WritePhyUshort(sc, 0x19, 0x3322);
12564 MP_WritePhyUshort(sc, 0x15, 0x0319);
12565 MP_WritePhyUshort(sc, 0x19, 0x4c08);
12566 MP_WritePhyUshort(sc, 0x15, 0x031a);
12567 MP_WritePhyUshort(sc, 0x19, 0x3322);
12568 MP_WritePhyUshort(sc, 0x15, 0x031b);
12569 MP_WritePhyUshort(sc, 0x19, 0x7d80);
12570 MP_WritePhyUshort(sc, 0x15, 0x031c);
12571 MP_WritePhyUshort(sc, 0x19, 0x5180);
12572 MP_WritePhyUshort(sc, 0x15, 0x031d);
12573 MP_WritePhyUshort(sc, 0x19, 0x3320);
12574 MP_WritePhyUshort(sc, 0x15, 0x031e);
12575 MP_WritePhyUshort(sc, 0x19, 0x7d80);
12576 MP_WritePhyUshort(sc, 0x15, 0x031f);
12577 MP_WritePhyUshort(sc, 0x19, 0x5000);
12578 MP_WritePhyUshort(sc, 0x15, 0x0320);
12579 MP_WritePhyUshort(sc, 0x19, 0x7d07);
12580 MP_WritePhyUshort(sc, 0x15, 0x0321);
12581 MP_WritePhyUshort(sc, 0x19, 0x4402);
12582 MP_WritePhyUshort(sc, 0x15, 0x0322);
12583 MP_WritePhyUshort(sc, 0x19, 0x7c03);
12584 MP_WritePhyUshort(sc, 0x15, 0x0323);
12585 MP_WritePhyUshort(sc, 0x19, 0x6c02);
12586 MP_WritePhyUshort(sc, 0x15, 0x0324);
12587 MP_WritePhyUshort(sc, 0x19, 0x7c03);
12588 MP_WritePhyUshort(sc, 0x15, 0x0325);
12589 MP_WritePhyUshort(sc, 0x19, 0xb30c);
12590 MP_WritePhyUshort(sc, 0x15, 0x0326);
12591 MP_WritePhyUshort(sc, 0x19, 0xb206);
12592 MP_WritePhyUshort(sc, 0x15, 0x0327);
12593 MP_WritePhyUshort(sc, 0x19, 0xb103);
12594 MP_WritePhyUshort(sc, 0x15, 0x0328);
12595 MP_WritePhyUshort(sc, 0x19, 0x6c00);
12596 MP_WritePhyUshort(sc, 0x15, 0x0329);
12597 MP_WritePhyUshort(sc, 0x19, 0x32f6);
12598 MP_WritePhyUshort(sc, 0x15, 0x032a);
12599 MP_WritePhyUshort(sc, 0x19, 0x6c00);
12600 MP_WritePhyUshort(sc, 0x15, 0x032b);
12601 MP_WritePhyUshort(sc, 0x19, 0x3352);
12602 MP_WritePhyUshort(sc, 0x15, 0x032c);
12603 MP_WritePhyUshort(sc, 0x19, 0xb103);
12604 MP_WritePhyUshort(sc, 0x15, 0x032d);
12605 MP_WritePhyUshort(sc, 0x19, 0x6c00);
12606 MP_WritePhyUshort(sc, 0x15, 0x032e);
12607 MP_WritePhyUshort(sc, 0x19, 0x336a);
12608 MP_WritePhyUshort(sc, 0x15, 0x032f);
12609 MP_WritePhyUshort(sc, 0x19, 0x6c00);
12610 MP_WritePhyUshort(sc, 0x15, 0x0330);
12611 MP_WritePhyUshort(sc, 0x19, 0x3382);
12612 MP_WritePhyUshort(sc, 0x15, 0x0331);
12613 MP_WritePhyUshort(sc, 0x19, 0xb206);
12614 MP_WritePhyUshort(sc, 0x15, 0x0332);
12615 MP_WritePhyUshort(sc, 0x19, 0xb103);
12616 MP_WritePhyUshort(sc, 0x15, 0x0333);
12617 MP_WritePhyUshort(sc, 0x19, 0x6c00);
12618 MP_WritePhyUshort(sc, 0x15, 0x0334);
12619 MP_WritePhyUshort(sc, 0x19, 0x3395);
12620 MP_WritePhyUshort(sc, 0x15, 0x0335);
12621 MP_WritePhyUshort(sc, 0x19, 0x6c00);
12622 MP_WritePhyUshort(sc, 0x15, 0x0336);
12623 MP_WritePhyUshort(sc, 0x19, 0x33c6);
12624 MP_WritePhyUshort(sc, 0x15, 0x0337);
12625 MP_WritePhyUshort(sc, 0x19, 0xb103);
12626 MP_WritePhyUshort(sc, 0x15, 0x0338);
12627 MP_WritePhyUshort(sc, 0x19, 0x6c00);
12628 MP_WritePhyUshort(sc, 0x15, 0x0339);
12629 MP_WritePhyUshort(sc, 0x19, 0x33d7);
12630 MP_WritePhyUshort(sc, 0x15, 0x033a);
12631 MP_WritePhyUshort(sc, 0x19, 0x6c00);
12632 MP_WritePhyUshort(sc, 0x15, 0x033b);
12633 MP_WritePhyUshort(sc, 0x19, 0x33f2);
12634 MP_WritePhyUshort(sc, 0x15, 0x033c);
12635 MP_WritePhyUshort(sc, 0x19, 0x0000);
12636 MP_WritePhyUshort(sc, 0x15, 0x033d);
12637 MP_WritePhyUshort(sc, 0x19, 0x0000);
12638 MP_WritePhyUshort(sc, 0x15, 0x033e);
12639 MP_WritePhyUshort(sc, 0x19, 0x0000);
12640 MP_WritePhyUshort(sc, 0x15, 0x033f);
12641 MP_WritePhyUshort(sc, 0x19, 0x0000);
12642 MP_WritePhyUshort(sc, 0x15, 0x0340);
12643 MP_WritePhyUshort(sc, 0x19, 0x0000);
12644 MP_WritePhyUshort(sc, 0x15, 0x0341);
12645 MP_WritePhyUshort(sc, 0x19, 0x0000);
12646 MP_WritePhyUshort(sc, 0x15, 0x0342);
12647 MP_WritePhyUshort(sc, 0x19, 0x49b5);
12648 MP_WritePhyUshort(sc, 0x15, 0x0343);
12649 MP_WritePhyUshort(sc, 0x19, 0x7d00);
12650 MP_WritePhyUshort(sc, 0x15, 0x0344);
12651 MP_WritePhyUshort(sc, 0x19, 0x4d00);
12652 MP_WritePhyUshort(sc, 0x15, 0x0345);
12653 MP_WritePhyUshort(sc, 0x19, 0x6880);
12654 MP_WritePhyUshort(sc, 0x15, 0x0346);
12655 MP_WritePhyUshort(sc, 0x19, 0x7c08);
12656 MP_WritePhyUshort(sc, 0x15, 0x0347);
12657 MP_WritePhyUshort(sc, 0x19, 0x6c08);
12658 MP_WritePhyUshort(sc, 0x15, 0x0348);
12659 MP_WritePhyUshort(sc, 0x19, 0x4925);
12660 MP_WritePhyUshort(sc, 0x15, 0x0349);
12661 MP_WritePhyUshort(sc, 0x19, 0x403b);
12662 MP_WritePhyUshort(sc, 0x15, 0x034a);
12663 MP_WritePhyUshort(sc, 0x19, 0xa602);
12664 MP_WritePhyUshort(sc, 0x15, 0x034b);
12665 MP_WritePhyUshort(sc, 0x19, 0x402f);
12666 MP_WritePhyUshort(sc, 0x15, 0x034c);
12667 MP_WritePhyUshort(sc, 0x19, 0x4484);
12668 MP_WritePhyUshort(sc, 0x15, 0x034d);
12669 MP_WritePhyUshort(sc, 0x19, 0x40c8);
12670 MP_WritePhyUshort(sc, 0x15, 0x034e);
12671 MP_WritePhyUshort(sc, 0x19, 0x44c4);
12672 MP_WritePhyUshort(sc, 0x15, 0x034f);
12673 MP_WritePhyUshort(sc, 0x19, 0xd64f);
12674 MP_WritePhyUshort(sc, 0x15, 0x0350);
12675 MP_WritePhyUshort(sc, 0x19, 0x00bd);
12676 MP_WritePhyUshort(sc, 0x15, 0x0351);
12677 MP_WritePhyUshort(sc, 0x19, 0x3311);
12678 MP_WritePhyUshort(sc, 0x15, 0x0352);
12679 MP_WritePhyUshort(sc, 0x19, 0xc8ed);
12680 MP_WritePhyUshort(sc, 0x15, 0x0353);
12681 MP_WritePhyUshort(sc, 0x19, 0x00fc);
12682 MP_WritePhyUshort(sc, 0x15, 0x0354);
12683 MP_WritePhyUshort(sc, 0x19, 0x8221);
12684 MP_WritePhyUshort(sc, 0x15, 0x0355);
12685 MP_WritePhyUshort(sc, 0x19, 0xd11d);
12686 MP_WritePhyUshort(sc, 0x15, 0x0356);
12687 MP_WritePhyUshort(sc, 0x19, 0x001f);
12688 MP_WritePhyUshort(sc, 0x15, 0x0357);
12689 MP_WritePhyUshort(sc, 0x19, 0xde18);
12690 MP_WritePhyUshort(sc, 0x15, 0x0358);
12691 MP_WritePhyUshort(sc, 0x19, 0x0008);
12692 MP_WritePhyUshort(sc, 0x15, 0x0359);
12693 MP_WritePhyUshort(sc, 0x19, 0x91f6);
12694 MP_WritePhyUshort(sc, 0x15, 0x035a);
12695 MP_WritePhyUshort(sc, 0x19, 0x3360);
12696 MP_WritePhyUshort(sc, 0x15, 0x035b);
12697 MP_WritePhyUshort(sc, 0x19, 0x0000);
12698 MP_WritePhyUshort(sc, 0x15, 0x035c);
12699 MP_WritePhyUshort(sc, 0x19, 0x0000);
12700 MP_WritePhyUshort(sc, 0x15, 0x035d);
12701 MP_WritePhyUshort(sc, 0x19, 0x0000);
12702 MP_WritePhyUshort(sc, 0x15, 0x035e);
12703 MP_WritePhyUshort(sc, 0x19, 0x0000);
12704 MP_WritePhyUshort(sc, 0x15, 0x035f);
12705 MP_WritePhyUshort(sc, 0x19, 0x0000);
12706 MP_WritePhyUshort(sc, 0x15, 0x0360);
12707 MP_WritePhyUshort(sc, 0x19, 0x4bb6);
12708 MP_WritePhyUshort(sc, 0x15, 0x0361);
12709 MP_WritePhyUshort(sc, 0x19, 0x4064);
12710 MP_WritePhyUshort(sc, 0x15, 0x0362);
12711 MP_WritePhyUshort(sc, 0x19, 0x4b26);
12712 MP_WritePhyUshort(sc, 0x15, 0x0363);
12713 MP_WritePhyUshort(sc, 0x19, 0x4410);
12714 MP_WritePhyUshort(sc, 0x15, 0x0364);
12715 MP_WritePhyUshort(sc, 0x19, 0x4006);
12716 MP_WritePhyUshort(sc, 0x15, 0x0365);
12717 MP_WritePhyUshort(sc, 0x19, 0x4490);
12718 MP_WritePhyUshort(sc, 0x15, 0x0366);
12719 MP_WritePhyUshort(sc, 0x19, 0x6900);
12720 MP_WritePhyUshort(sc, 0x15, 0x0367);
12721 MP_WritePhyUshort(sc, 0x19, 0xb6a6);
12722 MP_WritePhyUshort(sc, 0x15, 0x0368);
12723 MP_WritePhyUshort(sc, 0x19, 0x9e02);
12724 MP_WritePhyUshort(sc, 0x15, 0x0369);
12725 MP_WritePhyUshort(sc, 0x19, 0x3311);
12726 MP_WritePhyUshort(sc, 0x15, 0x036a);
12727 MP_WritePhyUshort(sc, 0x19, 0xd11d);
12728 MP_WritePhyUshort(sc, 0x15, 0x036b);
12729 MP_WritePhyUshort(sc, 0x19, 0x000a);
12730 MP_WritePhyUshort(sc, 0x15, 0x036c);
12731 MP_WritePhyUshort(sc, 0x19, 0xbb0f);
12732 MP_WritePhyUshort(sc, 0x15, 0x036d);
12733 MP_WritePhyUshort(sc, 0x19, 0x8102);
12734 MP_WritePhyUshort(sc, 0x15, 0x036e);
12735 MP_WritePhyUshort(sc, 0x19, 0x3371);
12736 MP_WritePhyUshort(sc, 0x15, 0x036f);
12737 MP_WritePhyUshort(sc, 0x19, 0xa21e);
12738 MP_WritePhyUshort(sc, 0x15, 0x0370);
12739 MP_WritePhyUshort(sc, 0x19, 0x33b6);
12740 MP_WritePhyUshort(sc, 0x15, 0x0371);
12741 MP_WritePhyUshort(sc, 0x19, 0x91f6);
12742 MP_WritePhyUshort(sc, 0x15, 0x0372);
12743 MP_WritePhyUshort(sc, 0x19, 0xc218);
12744 MP_WritePhyUshort(sc, 0x15, 0x0373);
12745 MP_WritePhyUshort(sc, 0x19, 0x00f4);
12746 MP_WritePhyUshort(sc, 0x15, 0x0374);
12747 MP_WritePhyUshort(sc, 0x19, 0x33b6);
12748 MP_WritePhyUshort(sc, 0x15, 0x0375);
12749 MP_WritePhyUshort(sc, 0x19, 0x32ec);
12750 MP_WritePhyUshort(sc, 0x15, 0x0376);
12751 MP_WritePhyUshort(sc, 0x19, 0x0000);
12752 MP_WritePhyUshort(sc, 0x15, 0x0377);
12753 MP_WritePhyUshort(sc, 0x19, 0x0000);
12754 MP_WritePhyUshort(sc, 0x15, 0x0378);
12755 MP_WritePhyUshort(sc, 0x19, 0x0000);
12756 MP_WritePhyUshort(sc, 0x15, 0x0379);
12757 MP_WritePhyUshort(sc, 0x19, 0x0000);
12758 MP_WritePhyUshort(sc, 0x15, 0x037a);
12759 MP_WritePhyUshort(sc, 0x19, 0x0000);
12760 MP_WritePhyUshort(sc, 0x15, 0x037b);
12761 MP_WritePhyUshort(sc, 0x19, 0x4b97);
12762 MP_WritePhyUshort(sc, 0x15, 0x037c);
12763 MP_WritePhyUshort(sc, 0x19, 0x402b);
12764 MP_WritePhyUshort(sc, 0x15, 0x037d);
12765 MP_WritePhyUshort(sc, 0x19, 0x4b07);
12766 MP_WritePhyUshort(sc, 0x15, 0x037e);
12767 MP_WritePhyUshort(sc, 0x19, 0x4422);
12768 MP_WritePhyUshort(sc, 0x15, 0x037f);
12769 MP_WritePhyUshort(sc, 0x19, 0x6980);
12770 MP_WritePhyUshort(sc, 0x15, 0x0380);
12771 MP_WritePhyUshort(sc, 0x19, 0xb608);
12772 MP_WritePhyUshort(sc, 0x15, 0x0381);
12773 MP_WritePhyUshort(sc, 0x19, 0x3311);
12774 MP_WritePhyUshort(sc, 0x15, 0x0382);
12775 MP_WritePhyUshort(sc, 0x19, 0xbc05);
12776 MP_WritePhyUshort(sc, 0x15, 0x0383);
12777 MP_WritePhyUshort(sc, 0x19, 0xc21c);
12778 MP_WritePhyUshort(sc, 0x15, 0x0384);
12779 MP_WritePhyUshort(sc, 0x19, 0x0032);
12780 MP_WritePhyUshort(sc, 0x15, 0x0385);
12781 MP_WritePhyUshort(sc, 0x19, 0xa1fb);
12782 MP_WritePhyUshort(sc, 0x15, 0x0386);
12783 MP_WritePhyUshort(sc, 0x19, 0x338d);
12784 MP_WritePhyUshort(sc, 0x15, 0x0387);
12785 MP_WritePhyUshort(sc, 0x19, 0x32ae);
12786 MP_WritePhyUshort(sc, 0x15, 0x0388);
12787 MP_WritePhyUshort(sc, 0x19, 0x330d);
12788 MP_WritePhyUshort(sc, 0x15, 0x0389);
12789 MP_WritePhyUshort(sc, 0x19, 0x0000);
12790 MP_WritePhyUshort(sc, 0x15, 0x038a);
12791 MP_WritePhyUshort(sc, 0x19, 0x0000);
12792 MP_WritePhyUshort(sc, 0x15, 0x038b);
12793 MP_WritePhyUshort(sc, 0x19, 0x0000);
12794 MP_WritePhyUshort(sc, 0x15, 0x038c);
12795 MP_WritePhyUshort(sc, 0x19, 0x0000);
12796 MP_WritePhyUshort(sc, 0x15, 0x038d);
12797 MP_WritePhyUshort(sc, 0x19, 0x4b97);
12798 MP_WritePhyUshort(sc, 0x15, 0x038e);
12799 MP_WritePhyUshort(sc, 0x19, 0x6a08);
12800 MP_WritePhyUshort(sc, 0x15, 0x038f);
12801 MP_WritePhyUshort(sc, 0x19, 0x4b07);
12802 MP_WritePhyUshort(sc, 0x15, 0x0390);
12803 MP_WritePhyUshort(sc, 0x19, 0x40ac);
12804 MP_WritePhyUshort(sc, 0x15, 0x0391);
12805 MP_WritePhyUshort(sc, 0x19, 0x4445);
12806 MP_WritePhyUshort(sc, 0x15, 0x0392);
12807 MP_WritePhyUshort(sc, 0x19, 0x404e);
12808 MP_WritePhyUshort(sc, 0x15, 0x0393);
12809 MP_WritePhyUshort(sc, 0x19, 0x4461);
12810 MP_WritePhyUshort(sc, 0x15, 0x0394);
12811 MP_WritePhyUshort(sc, 0x19, 0x3311);
12812 MP_WritePhyUshort(sc, 0x15, 0x0395);
12813 MP_WritePhyUshort(sc, 0x19, 0x9c0a);
12814 MP_WritePhyUshort(sc, 0x15, 0x0396);
12815 MP_WritePhyUshort(sc, 0x19, 0x63da);
12816 MP_WritePhyUshort(sc, 0x15, 0x0397);
12817 MP_WritePhyUshort(sc, 0x19, 0x6f0c);
12818 MP_WritePhyUshort(sc, 0x15, 0x0398);
12819 MP_WritePhyUshort(sc, 0x19, 0x5440);
12820 MP_WritePhyUshort(sc, 0x15, 0x0399);
12821 MP_WritePhyUshort(sc, 0x19, 0x4b98);
12822 MP_WritePhyUshort(sc, 0x15, 0x039a);
12823 MP_WritePhyUshort(sc, 0x19, 0x7c40);
12824 MP_WritePhyUshort(sc, 0x15, 0x039b);
12825 MP_WritePhyUshort(sc, 0x19, 0x4c00);
12826 MP_WritePhyUshort(sc, 0x15, 0x039c);
12827 MP_WritePhyUshort(sc, 0x19, 0x4b08);
12828 MP_WritePhyUshort(sc, 0x15, 0x039d);
12829 MP_WritePhyUshort(sc, 0x19, 0x63d8);
12830 MP_WritePhyUshort(sc, 0x15, 0x039e);
12831 MP_WritePhyUshort(sc, 0x19, 0x33a5);
12832 MP_WritePhyUshort(sc, 0x15, 0x039f);
12833 MP_WritePhyUshort(sc, 0x19, 0xd64f);
12834 MP_WritePhyUshort(sc, 0x15, 0x03a0);
12835 MP_WritePhyUshort(sc, 0x19, 0x00e8);
12836 MP_WritePhyUshort(sc, 0x15, 0x03a1);
12837 MP_WritePhyUshort(sc, 0x19, 0x820e);
12838 MP_WritePhyUshort(sc, 0x15, 0x03a2);
12839 MP_WritePhyUshort(sc, 0x19, 0xa10d);
12840 MP_WritePhyUshort(sc, 0x15, 0x03a3);
12841 MP_WritePhyUshort(sc, 0x19, 0x9df1);
12842 MP_WritePhyUshort(sc, 0x15, 0x03a4);
12843 MP_WritePhyUshort(sc, 0x19, 0x33af);
12844 MP_WritePhyUshort(sc, 0x15, 0x03a5);
12845 MP_WritePhyUshort(sc, 0x19, 0xd64f);
12846 MP_WritePhyUshort(sc, 0x15, 0x03a6);
12847 MP_WritePhyUshort(sc, 0x19, 0x00f9);
12848 MP_WritePhyUshort(sc, 0x15, 0x03a7);
12849 MP_WritePhyUshort(sc, 0x19, 0xc017);
12850 MP_WritePhyUshort(sc, 0x15, 0x03a8);
12851 MP_WritePhyUshort(sc, 0x19, 0x0007);
12852 MP_WritePhyUshort(sc, 0x15, 0x03a9);
12853 MP_WritePhyUshort(sc, 0x19, 0x7c03);
12854 MP_WritePhyUshort(sc, 0x15, 0x03aa);
12855 MP_WritePhyUshort(sc, 0x19, 0x6c03);
12856 MP_WritePhyUshort(sc, 0x15, 0x03ab);
12857 MP_WritePhyUshort(sc, 0x19, 0xa104);
12858 MP_WritePhyUshort(sc, 0x15, 0x03ac);
12859 MP_WritePhyUshort(sc, 0x19, 0x7c03);
12860 MP_WritePhyUshort(sc, 0x15, 0x03ad);
12861 MP_WritePhyUshort(sc, 0x19, 0x6c00);
12862 MP_WritePhyUshort(sc, 0x15, 0x03ae);
12863 MP_WritePhyUshort(sc, 0x19, 0x9df7);
12864 MP_WritePhyUshort(sc, 0x15, 0x03af);
12865 MP_WritePhyUshort(sc, 0x19, 0x7c03);
12866 MP_WritePhyUshort(sc, 0x15, 0x03b0);
12867 MP_WritePhyUshort(sc, 0x19, 0x6c08);
12868 MP_WritePhyUshort(sc, 0x15, 0x03b1);
12869 MP_WritePhyUshort(sc, 0x19, 0x33b6);
12870 MP_WritePhyUshort(sc, 0x15, 0x03b2);
12871 MP_WritePhyUshort(sc, 0x19, 0x0000);
12872 MP_WritePhyUshort(sc, 0x15, 0x03b3);
12873 MP_WritePhyUshort(sc, 0x19, 0x0000);
12874 MP_WritePhyUshort(sc, 0x15, 0x03b4);
12875 MP_WritePhyUshort(sc, 0x19, 0x0000);
12876 MP_WritePhyUshort(sc, 0x15, 0x03b5);
12877 MP_WritePhyUshort(sc, 0x19, 0x0000);
12878 MP_WritePhyUshort(sc, 0x15, 0x03b6);
12879 MP_WritePhyUshort(sc, 0x19, 0x55af);
12880 MP_WritePhyUshort(sc, 0x15, 0x03b7);
12881 MP_WritePhyUshort(sc, 0x19, 0x7ff0);
12882 MP_WritePhyUshort(sc, 0x15, 0x03b8);
12883 MP_WritePhyUshort(sc, 0x19, 0x6ff0);
12884 MP_WritePhyUshort(sc, 0x15, 0x03b9);
12885 MP_WritePhyUshort(sc, 0x19, 0x4bb9);
12886 MP_WritePhyUshort(sc, 0x15, 0x03ba);
12887 MP_WritePhyUshort(sc, 0x19, 0x6a80);
12888 MP_WritePhyUshort(sc, 0x15, 0x03bb);
12889 MP_WritePhyUshort(sc, 0x19, 0x4b29);
12890 MP_WritePhyUshort(sc, 0x15, 0x03bc);
12891 MP_WritePhyUshort(sc, 0x19, 0x4041);
12892 MP_WritePhyUshort(sc, 0x15, 0x03bd);
12893 MP_WritePhyUshort(sc, 0x19, 0x440a);
12894 MP_WritePhyUshort(sc, 0x15, 0x03be);
12895 MP_WritePhyUshort(sc, 0x19, 0x4029);
12896 MP_WritePhyUshort(sc, 0x15, 0x03bf);
12897 MP_WritePhyUshort(sc, 0x19, 0x4418);
12898 MP_WritePhyUshort(sc, 0x15, 0x03c0);
12899 MP_WritePhyUshort(sc, 0x19, 0x4090);
12900 MP_WritePhyUshort(sc, 0x15, 0x03c1);
12901 MP_WritePhyUshort(sc, 0x19, 0x4438);
12902 MP_WritePhyUshort(sc, 0x15, 0x03c2);
12903 MP_WritePhyUshort(sc, 0x19, 0x40c4);
12904 MP_WritePhyUshort(sc, 0x15, 0x03c3);
12905 MP_WritePhyUshort(sc, 0x19, 0x447b);
12906 MP_WritePhyUshort(sc, 0x15, 0x03c4);
12907 MP_WritePhyUshort(sc, 0x19, 0xb6c4);
12908 MP_WritePhyUshort(sc, 0x15, 0x03c5);
12909 MP_WritePhyUshort(sc, 0x19, 0x3311);
12910 MP_WritePhyUshort(sc, 0x15, 0x03c6);
12911 MP_WritePhyUshort(sc, 0x19, 0x9bfe);
12912 MP_WritePhyUshort(sc, 0x15, 0x03c7);
12913 MP_WritePhyUshort(sc, 0x19, 0x33cc);
12914 MP_WritePhyUshort(sc, 0x15, 0x03c8);
12915 MP_WritePhyUshort(sc, 0x19, 0x0000);
12916 MP_WritePhyUshort(sc, 0x15, 0x03c9);
12917 MP_WritePhyUshort(sc, 0x19, 0x0000);
12918 MP_WritePhyUshort(sc, 0x15, 0x03ca);
12919 MP_WritePhyUshort(sc, 0x19, 0x0000);
12920 MP_WritePhyUshort(sc, 0x15, 0x03cb);
12921 MP_WritePhyUshort(sc, 0x19, 0x0000);
12922 MP_WritePhyUshort(sc, 0x15, 0x03cc);
12923 MP_WritePhyUshort(sc, 0x19, 0x542f);
12924 MP_WritePhyUshort(sc, 0x15, 0x03cd);
12925 MP_WritePhyUshort(sc, 0x19, 0x499a);
12926 MP_WritePhyUshort(sc, 0x15, 0x03ce);
12927 MP_WritePhyUshort(sc, 0x19, 0x7c40);
12928 MP_WritePhyUshort(sc, 0x15, 0x03cf);
12929 MP_WritePhyUshort(sc, 0x19, 0x4c40);
12930 MP_WritePhyUshort(sc, 0x15, 0x03d0);
12931 MP_WritePhyUshort(sc, 0x19, 0x490a);
12932 MP_WritePhyUshort(sc, 0x15, 0x03d1);
12933 MP_WritePhyUshort(sc, 0x19, 0x405e);
12934 MP_WritePhyUshort(sc, 0x15, 0x03d2);
12935 MP_WritePhyUshort(sc, 0x19, 0x44f8);
12936 MP_WritePhyUshort(sc, 0x15, 0x03d3);
12937 MP_WritePhyUshort(sc, 0x19, 0x6b00);
12938 MP_WritePhyUshort(sc, 0x15, 0x03d4);
12939 MP_WritePhyUshort(sc, 0x19, 0xd64f);
12940 MP_WritePhyUshort(sc, 0x15, 0x03d5);
12941 MP_WritePhyUshort(sc, 0x19, 0x0028);
12942 MP_WritePhyUshort(sc, 0x15, 0x03d6);
12943 MP_WritePhyUshort(sc, 0x19, 0x3311);
12944 MP_WritePhyUshort(sc, 0x15, 0x03d7);
12945 MP_WritePhyUshort(sc, 0x19, 0xbd27);
12946 MP_WritePhyUshort(sc, 0x15, 0x03d8);
12947 MP_WritePhyUshort(sc, 0x19, 0x9cfc);
12948 MP_WritePhyUshort(sc, 0x15, 0x03d9);
12949 MP_WritePhyUshort(sc, 0x19, 0xc639);
12950 MP_WritePhyUshort(sc, 0x15, 0x03da);
12951 MP_WritePhyUshort(sc, 0x19, 0x000f);
12952 MP_WritePhyUshort(sc, 0x15, 0x03db);
12953 MP_WritePhyUshort(sc, 0x19, 0x9e03);
12954 MP_WritePhyUshort(sc, 0x15, 0x03dc);
12955 MP_WritePhyUshort(sc, 0x19, 0x7c01);
12956 MP_WritePhyUshort(sc, 0x15, 0x03dd);
12957 MP_WritePhyUshort(sc, 0x19, 0x4c01);
12958 MP_WritePhyUshort(sc, 0x15, 0x03de);
12959 MP_WritePhyUshort(sc, 0x19, 0x9af6);
12960 MP_WritePhyUshort(sc, 0x15, 0x03df);
12961 MP_WritePhyUshort(sc, 0x19, 0x7c12);
12962 MP_WritePhyUshort(sc, 0x15, 0x03e0);
12963 MP_WritePhyUshort(sc, 0x19, 0x4c52);
12964 MP_WritePhyUshort(sc, 0x15, 0x03e1);
12965 MP_WritePhyUshort(sc, 0x19, 0x4470);
12966 MP_WritePhyUshort(sc, 0x15, 0x03e2);
12967 MP_WritePhyUshort(sc, 0x19, 0x7c12);
12968 MP_WritePhyUshort(sc, 0x15, 0x03e3);
12969 MP_WritePhyUshort(sc, 0x19, 0x4c40);
12970 MP_WritePhyUshort(sc, 0x15, 0x03e4);
12971 MP_WritePhyUshort(sc, 0x19, 0x33d4);
12972 MP_WritePhyUshort(sc, 0x15, 0x03e5);
12973 MP_WritePhyUshort(sc, 0x19, 0x0000);
12974 MP_WritePhyUshort(sc, 0x15, 0x03e6);
12975 MP_WritePhyUshort(sc, 0x19, 0x0000);
12976 MP_WritePhyUshort(sc, 0x15, 0x03e7);
12977 MP_WritePhyUshort(sc, 0x19, 0x0000);
12978 MP_WritePhyUshort(sc, 0x15, 0x03e8);
12979 MP_WritePhyUshort(sc, 0x19, 0x0000);
12980 MP_WritePhyUshort(sc, 0x15, 0x03e9);
12981 MP_WritePhyUshort(sc, 0x19, 0x49bb);
12982 MP_WritePhyUshort(sc, 0x15, 0x03ea);
12983 MP_WritePhyUshort(sc, 0x19, 0x4478);
12984 MP_WritePhyUshort(sc, 0x15, 0x03eb);
12985 MP_WritePhyUshort(sc, 0x19, 0x492b);
12986 MP_WritePhyUshort(sc, 0x15, 0x03ec);
12987 MP_WritePhyUshort(sc, 0x19, 0x6b80);
12988 MP_WritePhyUshort(sc, 0x15, 0x03ed);
12989 MP_WritePhyUshort(sc, 0x19, 0x7c01);
12990 MP_WritePhyUshort(sc, 0x15, 0x03ee);
12991 MP_WritePhyUshort(sc, 0x19, 0x4c00);
12992 MP_WritePhyUshort(sc, 0x15, 0x03ef);
12993 MP_WritePhyUshort(sc, 0x19, 0xd64f);
12994 MP_WritePhyUshort(sc, 0x15, 0x03f0);
12995 MP_WritePhyUshort(sc, 0x19, 0x000d);
12996 MP_WritePhyUshort(sc, 0x15, 0x03f1);
12997 MP_WritePhyUshort(sc, 0x19, 0x3311);
12998 MP_WritePhyUshort(sc, 0x15, 0x03f2);
12999 MP_WritePhyUshort(sc, 0x19, 0xbd0c);
13000 MP_WritePhyUshort(sc, 0x15, 0x03f3);
13001 MP_WritePhyUshort(sc, 0x19, 0xc428);
13002 MP_WritePhyUshort(sc, 0x15, 0x03f4);
13003 MP_WritePhyUshort(sc, 0x19, 0x0008);
13004 MP_WritePhyUshort(sc, 0x15, 0x03f5);
13005 MP_WritePhyUshort(sc, 0x19, 0x9afa);
13006 MP_WritePhyUshort(sc, 0x15, 0x03f6);
13007 MP_WritePhyUshort(sc, 0x19, 0x7c12);
13008 MP_WritePhyUshort(sc, 0x15, 0x03f7);
13009 MP_WritePhyUshort(sc, 0x19, 0x4c52);
13010 MP_WritePhyUshort(sc, 0x15, 0x03f8);
13011 MP_WritePhyUshort(sc, 0x19, 0x4470);
13012 MP_WritePhyUshort(sc, 0x15, 0x03f9);
13013 MP_WritePhyUshort(sc, 0x19, 0x7c12);
13014 MP_WritePhyUshort(sc, 0x15, 0x03fa);
13015 MP_WritePhyUshort(sc, 0x19, 0x4c40);
13016 MP_WritePhyUshort(sc, 0x15, 0x03fb);
13017 MP_WritePhyUshort(sc, 0x19, 0x33ef);
13018 MP_WritePhyUshort(sc, 0x15, 0x03fc);
13019 MP_WritePhyUshort(sc, 0x19, 0x3342);
13020 MP_WritePhyUshort(sc, 0x15, 0x03fd);
13021 MP_WritePhyUshort(sc, 0x19, 0x330d);
13022 MP_WritePhyUshort(sc, 0x15, 0x03fe);
13023 MP_WritePhyUshort(sc, 0x19, 0x32ae);
13024 MP_WritePhyUshort(sc, 0x15, 0x0000);
13025 MP_WritePhyUshort(sc, 0x16, 0x0306);
13026 MP_WritePhyUshort(sc, 0x16, 0x0300);
13027 MP_WritePhyUshort(sc, 0x1f, 0x0002);
13028 MP_WritePhyUshort(sc, 0x1f, 0x0000);
13029 MP_WritePhyUshort(sc, 0x1f, 0x0005);
13030 MP_WritePhyUshort(sc, 0x05, 0xfff6);
13031 MP_WritePhyUshort(sc, 0x06, 0x0080);
13032 MP_WritePhyUshort(sc, 0x05, 0x8000);
13033 MP_WritePhyUshort(sc, 0x06, 0x0280);
13034 MP_WritePhyUshort(sc, 0x06, 0x48f7);
13035 MP_WritePhyUshort(sc, 0x06, 0x00e0);
13036 MP_WritePhyUshort(sc, 0x06, 0xfff7);
13037 MP_WritePhyUshort(sc, 0x06, 0xa080);
13038 MP_WritePhyUshort(sc, 0x06, 0x02ae);
13039 MP_WritePhyUshort(sc, 0x06, 0xf602);
13040 MP_WritePhyUshort(sc, 0x06, 0x0112);
13041 MP_WritePhyUshort(sc, 0x06, 0x0201);
13042 MP_WritePhyUshort(sc, 0x06, 0x1f02);
13043 MP_WritePhyUshort(sc, 0x06, 0x012c);
13044 MP_WritePhyUshort(sc, 0x06, 0x0201);
13045 MP_WritePhyUshort(sc, 0x06, 0x3c02);
13046 MP_WritePhyUshort(sc, 0x06, 0x0156);
13047 MP_WritePhyUshort(sc, 0x06, 0x0201);
13048 MP_WritePhyUshort(sc, 0x06, 0x6d02);
13049 MP_WritePhyUshort(sc, 0x06, 0x809d);
13050 MP_WritePhyUshort(sc, 0x06, 0xe08b);
13051 MP_WritePhyUshort(sc, 0x06, 0x88e1);
13052 MP_WritePhyUshort(sc, 0x06, 0x8b89);
13053 MP_WritePhyUshort(sc, 0x06, 0x1e01);
13054 MP_WritePhyUshort(sc, 0x06, 0xe18b);
13055 MP_WritePhyUshort(sc, 0x06, 0x8a1e);
13056 MP_WritePhyUshort(sc, 0x06, 0x01e1);
13057 MP_WritePhyUshort(sc, 0x06, 0x8b8b);
13058 MP_WritePhyUshort(sc, 0x06, 0x1e01);
13059 MP_WritePhyUshort(sc, 0x06, 0xe18b);
13060 MP_WritePhyUshort(sc, 0x06, 0x8c1e);
13061 MP_WritePhyUshort(sc, 0x06, 0x01e1);
13062 MP_WritePhyUshort(sc, 0x06, 0x8b8d);
13063 MP_WritePhyUshort(sc, 0x06, 0x1e01);
13064 MP_WritePhyUshort(sc, 0x06, 0xe18b);
13065 MP_WritePhyUshort(sc, 0x06, 0x8e1e);
13066 MP_WritePhyUshort(sc, 0x06, 0x01a0);
13067 MP_WritePhyUshort(sc, 0x06, 0x00c7);
13068 MP_WritePhyUshort(sc, 0x06, 0xaebb);
13069 MP_WritePhyUshort(sc, 0x06, 0xd100);
13070 MP_WritePhyUshort(sc, 0x06, 0xbf82);
13071 MP_WritePhyUshort(sc, 0x06, 0xc702);
13072 MP_WritePhyUshort(sc, 0x06, 0x320a);
13073 MP_WritePhyUshort(sc, 0x06, 0xd105);
13074 MP_WritePhyUshort(sc, 0x06, 0xbf82);
13075 MP_WritePhyUshort(sc, 0x06, 0xcd02);
13076 MP_WritePhyUshort(sc, 0x06, 0x320a);
13077 MP_WritePhyUshort(sc, 0x06, 0xd100);
13078 MP_WritePhyUshort(sc, 0x06, 0xbf82);
13079 MP_WritePhyUshort(sc, 0x06, 0xca02);
13080 MP_WritePhyUshort(sc, 0x06, 0x320a);
13081 MP_WritePhyUshort(sc, 0x06, 0xd105);
13082 MP_WritePhyUshort(sc, 0x06, 0xbf82);
13083 MP_WritePhyUshort(sc, 0x06, 0xd002);
13084 MP_WritePhyUshort(sc, 0x06, 0x320a);
13085 MP_WritePhyUshort(sc, 0x06, 0xd481);
13086 MP_WritePhyUshort(sc, 0x06, 0xc9e4);
13087 MP_WritePhyUshort(sc, 0x06, 0x8b90);
13088 MP_WritePhyUshort(sc, 0x06, 0xe58b);
13089 MP_WritePhyUshort(sc, 0x06, 0x91d4);
13090 MP_WritePhyUshort(sc, 0x06, 0x81b8);
13091 MP_WritePhyUshort(sc, 0x06, 0xe48b);
13092 MP_WritePhyUshort(sc, 0x06, 0x92e5);
13093 MP_WritePhyUshort(sc, 0x06, 0x8b93);
13094 MP_WritePhyUshort(sc, 0x06, 0xbf8b);
13095 MP_WritePhyUshort(sc, 0x06, 0x88ec);
13096 MP_WritePhyUshort(sc, 0x06, 0x0019);
13097 MP_WritePhyUshort(sc, 0x06, 0xa98b);
13098 MP_WritePhyUshort(sc, 0x06, 0x90f9);
13099 MP_WritePhyUshort(sc, 0x06, 0xeeff);
13100 MP_WritePhyUshort(sc, 0x06, 0xf600);
13101 MP_WritePhyUshort(sc, 0x06, 0xeeff);
13102 MP_WritePhyUshort(sc, 0x06, 0xf7fc);
13103 MP_WritePhyUshort(sc, 0x06, 0xd100);
13104 MP_WritePhyUshort(sc, 0x06, 0xbf82);
13105 MP_WritePhyUshort(sc, 0x06, 0xc102);
13106 MP_WritePhyUshort(sc, 0x06, 0x320a);
13107 MP_WritePhyUshort(sc, 0x06, 0xd101);
13108 MP_WritePhyUshort(sc, 0x06, 0xbf82);
13109 MP_WritePhyUshort(sc, 0x06, 0xc402);
13110 MP_WritePhyUshort(sc, 0x06, 0x320a);
13111 MP_WritePhyUshort(sc, 0x06, 0x04f8);
13112 MP_WritePhyUshort(sc, 0x06, 0xe08b);
13113 MP_WritePhyUshort(sc, 0x06, 0x8ead);
13114 MP_WritePhyUshort(sc, 0x06, 0x201a);
13115 MP_WritePhyUshort(sc, 0x06, 0xf620);
13116 MP_WritePhyUshort(sc, 0x06, 0xe48b);
13117 MP_WritePhyUshort(sc, 0x06, 0x8e02);
13118 MP_WritePhyUshort(sc, 0x06, 0x824b);
13119 MP_WritePhyUshort(sc, 0x06, 0x0281);
13120 MP_WritePhyUshort(sc, 0x06, 0x1902);
13121 MP_WritePhyUshort(sc, 0x06, 0x2c9d);
13122 MP_WritePhyUshort(sc, 0x06, 0x0203);
13123 MP_WritePhyUshort(sc, 0x06, 0x9602);
13124 MP_WritePhyUshort(sc, 0x06, 0x0473);
13125 MP_WritePhyUshort(sc, 0x06, 0x022e);
13126 MP_WritePhyUshort(sc, 0x06, 0x3902);
13127 MP_WritePhyUshort(sc, 0x06, 0x044d);
13128 MP_WritePhyUshort(sc, 0x06, 0xe08b);
13129 MP_WritePhyUshort(sc, 0x06, 0x8ead);
13130 MP_WritePhyUshort(sc, 0x06, 0x210b);
13131 MP_WritePhyUshort(sc, 0x06, 0xf621);
13132 MP_WritePhyUshort(sc, 0x06, 0xe48b);
13133 MP_WritePhyUshort(sc, 0x06, 0x8e02);
13134 MP_WritePhyUshort(sc, 0x06, 0x0416);
13135 MP_WritePhyUshort(sc, 0x06, 0x021b);
13136 MP_WritePhyUshort(sc, 0x06, 0xa4e0);
13137 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
13138 MP_WritePhyUshort(sc, 0x06, 0xad22);
13139 MP_WritePhyUshort(sc, 0x06, 0x05f6);
13140 MP_WritePhyUshort(sc, 0x06, 0x22e4);
13141 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
13142 MP_WritePhyUshort(sc, 0x06, 0xe08b);
13143 MP_WritePhyUshort(sc, 0x06, 0x8ead);
13144 MP_WritePhyUshort(sc, 0x06, 0x2305);
13145 MP_WritePhyUshort(sc, 0x06, 0xf623);
13146 MP_WritePhyUshort(sc, 0x06, 0xe48b);
13147 MP_WritePhyUshort(sc, 0x06, 0x8ee0);
13148 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
13149 MP_WritePhyUshort(sc, 0x06, 0xad24);
13150 MP_WritePhyUshort(sc, 0x06, 0x05f6);
13151 MP_WritePhyUshort(sc, 0x06, 0x24e4);
13152 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
13153 MP_WritePhyUshort(sc, 0x06, 0xe08b);
13154 MP_WritePhyUshort(sc, 0x06, 0x8ead);
13155 MP_WritePhyUshort(sc, 0x06, 0x2505);
13156 MP_WritePhyUshort(sc, 0x06, 0xf625);
13157 MP_WritePhyUshort(sc, 0x06, 0xe48b);
13158 MP_WritePhyUshort(sc, 0x06, 0x8ee0);
13159 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
13160 MP_WritePhyUshort(sc, 0x06, 0xad26);
13161 MP_WritePhyUshort(sc, 0x06, 0x08f6);
13162 MP_WritePhyUshort(sc, 0x06, 0x26e4);
13163 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
13164 MP_WritePhyUshort(sc, 0x06, 0x0281);
13165 MP_WritePhyUshort(sc, 0x06, 0xdae0);
13166 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
13167 MP_WritePhyUshort(sc, 0x06, 0xad27);
13168 MP_WritePhyUshort(sc, 0x06, 0x05f6);
13169 MP_WritePhyUshort(sc, 0x06, 0x27e4);
13170 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
13171 MP_WritePhyUshort(sc, 0x06, 0x0203);
13172 MP_WritePhyUshort(sc, 0x06, 0x5cfc);
13173 MP_WritePhyUshort(sc, 0x06, 0x04f8);
13174 MP_WritePhyUshort(sc, 0x06, 0xfaef);
13175 MP_WritePhyUshort(sc, 0x06, 0x69e0);
13176 MP_WritePhyUshort(sc, 0x06, 0x8b85);
13177 MP_WritePhyUshort(sc, 0x06, 0xad21);
13178 MP_WritePhyUshort(sc, 0x06, 0x57e0);
13179 MP_WritePhyUshort(sc, 0x06, 0xe022);
13180 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
13181 MP_WritePhyUshort(sc, 0x06, 0x2358);
13182 MP_WritePhyUshort(sc, 0x06, 0xc059);
13183 MP_WritePhyUshort(sc, 0x06, 0x021e);
13184 MP_WritePhyUshort(sc, 0x06, 0x01e1);
13185 MP_WritePhyUshort(sc, 0x06, 0x8b3c);
13186 MP_WritePhyUshort(sc, 0x06, 0x1f10);
13187 MP_WritePhyUshort(sc, 0x06, 0x9e44);
13188 MP_WritePhyUshort(sc, 0x06, 0xe48b);
13189 MP_WritePhyUshort(sc, 0x06, 0x3cad);
13190 MP_WritePhyUshort(sc, 0x06, 0x211d);
13191 MP_WritePhyUshort(sc, 0x06, 0xe18b);
13192 MP_WritePhyUshort(sc, 0x06, 0x84f7);
13193 MP_WritePhyUshort(sc, 0x06, 0x29e5);
13194 MP_WritePhyUshort(sc, 0x06, 0x8b84);
13195 MP_WritePhyUshort(sc, 0x06, 0xac27);
13196 MP_WritePhyUshort(sc, 0x06, 0x0dac);
13197 MP_WritePhyUshort(sc, 0x06, 0x2605);
13198 MP_WritePhyUshort(sc, 0x06, 0x0281);
13199 MP_WritePhyUshort(sc, 0x06, 0x7fae);
13200 MP_WritePhyUshort(sc, 0x06, 0x2b02);
13201 MP_WritePhyUshort(sc, 0x06, 0x2c23);
13202 MP_WritePhyUshort(sc, 0x06, 0xae26);
13203 MP_WritePhyUshort(sc, 0x06, 0x022c);
13204 MP_WritePhyUshort(sc, 0x06, 0x41ae);
13205 MP_WritePhyUshort(sc, 0x06, 0x21e0);
13206 MP_WritePhyUshort(sc, 0x06, 0x8b87);
13207 MP_WritePhyUshort(sc, 0x06, 0xad22);
13208 MP_WritePhyUshort(sc, 0x06, 0x18e0);
13209 MP_WritePhyUshort(sc, 0x06, 0xfff7);
13210 MP_WritePhyUshort(sc, 0x06, 0x58fc);
13211 MP_WritePhyUshort(sc, 0x06, 0xe4ff);
13212 MP_WritePhyUshort(sc, 0x06, 0xf7d1);
13213 MP_WritePhyUshort(sc, 0x06, 0x00bf);
13214 MP_WritePhyUshort(sc, 0x06, 0x2eee);
13215 MP_WritePhyUshort(sc, 0x06, 0x0232);
13216 MP_WritePhyUshort(sc, 0x06, 0x0ad1);
13217 MP_WritePhyUshort(sc, 0x06, 0x00bf);
13218 MP_WritePhyUshort(sc, 0x06, 0x82e8);
13219 MP_WritePhyUshort(sc, 0x06, 0x0232);
13220 MP_WritePhyUshort(sc, 0x06, 0x0a02);
13221 MP_WritePhyUshort(sc, 0x06, 0x2bdf);
13222 MP_WritePhyUshort(sc, 0x06, 0xef96);
13223 MP_WritePhyUshort(sc, 0x06, 0xfefc);
13224 MP_WritePhyUshort(sc, 0x06, 0x04d0);
13225 MP_WritePhyUshort(sc, 0x06, 0x0202);
13226 MP_WritePhyUshort(sc, 0x06, 0x1e97);
13227 MP_WritePhyUshort(sc, 0x06, 0xe08b);
13228 MP_WritePhyUshort(sc, 0x06, 0x87ad);
13229 MP_WritePhyUshort(sc, 0x06, 0x2228);
13230 MP_WritePhyUshort(sc, 0x06, 0xd100);
13231 MP_WritePhyUshort(sc, 0x06, 0xbf82);
13232 MP_WritePhyUshort(sc, 0x06, 0xd302);
13233 MP_WritePhyUshort(sc, 0x06, 0x320a);
13234 MP_WritePhyUshort(sc, 0x06, 0xd10c);
13235 MP_WritePhyUshort(sc, 0x06, 0xbf82);
13236 MP_WritePhyUshort(sc, 0x06, 0xd602);
13237 MP_WritePhyUshort(sc, 0x06, 0x320a);
13238 MP_WritePhyUshort(sc, 0x06, 0xd104);
13239 MP_WritePhyUshort(sc, 0x06, 0xbf82);
13240 MP_WritePhyUshort(sc, 0x06, 0xd902);
13241 MP_WritePhyUshort(sc, 0x06, 0x320a);
13242 MP_WritePhyUshort(sc, 0x06, 0xd101);
13243 MP_WritePhyUshort(sc, 0x06, 0xbf82);
13244 MP_WritePhyUshort(sc, 0x06, 0xe802);
13245 MP_WritePhyUshort(sc, 0x06, 0x320a);
13246 MP_WritePhyUshort(sc, 0x06, 0xe0ff);
13247 MP_WritePhyUshort(sc, 0x06, 0xf768);
13248 MP_WritePhyUshort(sc, 0x06, 0x03e4);
13249 MP_WritePhyUshort(sc, 0x06, 0xfff7);
13250 MP_WritePhyUshort(sc, 0x06, 0xd004);
13251 MP_WritePhyUshort(sc, 0x06, 0x0228);
13252 MP_WritePhyUshort(sc, 0x06, 0x7a04);
13253 MP_WritePhyUshort(sc, 0x06, 0xf8e0);
13254 MP_WritePhyUshort(sc, 0x06, 0xe234);
13255 MP_WritePhyUshort(sc, 0x06, 0xe1e2);
13256 MP_WritePhyUshort(sc, 0x06, 0x35f6);
13257 MP_WritePhyUshort(sc, 0x06, 0x2be4);
13258 MP_WritePhyUshort(sc, 0x06, 0xe234);
13259 MP_WritePhyUshort(sc, 0x06, 0xe5e2);
13260 MP_WritePhyUshort(sc, 0x06, 0x35fc);
13261 MP_WritePhyUshort(sc, 0x06, 0x05f8);
13262 MP_WritePhyUshort(sc, 0x06, 0xe0e2);
13263 MP_WritePhyUshort(sc, 0x06, 0x34e1);
13264 MP_WritePhyUshort(sc, 0x06, 0xe235);
13265 MP_WritePhyUshort(sc, 0x06, 0xf72b);
13266 MP_WritePhyUshort(sc, 0x06, 0xe4e2);
13267 MP_WritePhyUshort(sc, 0x06, 0x34e5);
13268 MP_WritePhyUshort(sc, 0x06, 0xe235);
13269 MP_WritePhyUshort(sc, 0x06, 0xfc05);
13270 MP_WritePhyUshort(sc, 0x06, 0xf8f9);
13271 MP_WritePhyUshort(sc, 0x06, 0xfaef);
13272 MP_WritePhyUshort(sc, 0x06, 0x69ac);
13273 MP_WritePhyUshort(sc, 0x06, 0x1b4c);
13274 MP_WritePhyUshort(sc, 0x06, 0xbf2e);
13275 MP_WritePhyUshort(sc, 0x06, 0x3002);
13276 MP_WritePhyUshort(sc, 0x06, 0x31dd);
13277 MP_WritePhyUshort(sc, 0x06, 0xef01);
13278 MP_WritePhyUshort(sc, 0x06, 0xe28a);
13279 MP_WritePhyUshort(sc, 0x06, 0x76e4);
13280 MP_WritePhyUshort(sc, 0x06, 0x8a76);
13281 MP_WritePhyUshort(sc, 0x06, 0x1f12);
13282 MP_WritePhyUshort(sc, 0x06, 0x9e3a);
13283 MP_WritePhyUshort(sc, 0x06, 0xef12);
13284 MP_WritePhyUshort(sc, 0x06, 0x5907);
13285 MP_WritePhyUshort(sc, 0x06, 0x9f12);
13286 MP_WritePhyUshort(sc, 0x06, 0xf8e0);
13287 MP_WritePhyUshort(sc, 0x06, 0x8b40);
13288 MP_WritePhyUshort(sc, 0x06, 0xf721);
13289 MP_WritePhyUshort(sc, 0x06, 0xe48b);
13290 MP_WritePhyUshort(sc, 0x06, 0x40d0);
13291 MP_WritePhyUshort(sc, 0x06, 0x0302);
13292 MP_WritePhyUshort(sc, 0x06, 0x287a);
13293 MP_WritePhyUshort(sc, 0x06, 0x0282);
13294 MP_WritePhyUshort(sc, 0x06, 0x34fc);
13295 MP_WritePhyUshort(sc, 0x06, 0xa000);
13296 MP_WritePhyUshort(sc, 0x06, 0x1002);
13297 MP_WritePhyUshort(sc, 0x06, 0x2dc3);
13298 MP_WritePhyUshort(sc, 0x06, 0x022e);
13299 MP_WritePhyUshort(sc, 0x06, 0x21e0);
13300 MP_WritePhyUshort(sc, 0x06, 0x8b40);
13301 MP_WritePhyUshort(sc, 0x06, 0xf621);
13302 MP_WritePhyUshort(sc, 0x06, 0xe48b);
13303 MP_WritePhyUshort(sc, 0x06, 0x40ae);
13304 MP_WritePhyUshort(sc, 0x06, 0x0fbf);
13305 MP_WritePhyUshort(sc, 0x06, 0x3fa5);
13306 MP_WritePhyUshort(sc, 0x06, 0x0231);
13307 MP_WritePhyUshort(sc, 0x06, 0x6cbf);
13308 MP_WritePhyUshort(sc, 0x06, 0x3fa2);
13309 MP_WritePhyUshort(sc, 0x06, 0x0231);
13310 MP_WritePhyUshort(sc, 0x06, 0x6c02);
13311 MP_WritePhyUshort(sc, 0x06, 0x2dc3);
13312 MP_WritePhyUshort(sc, 0x06, 0xef96);
13313 MP_WritePhyUshort(sc, 0x06, 0xfefd);
13314 MP_WritePhyUshort(sc, 0x06, 0xfc04);
13315 MP_WritePhyUshort(sc, 0x06, 0xf8e0);
13316 MP_WritePhyUshort(sc, 0x06, 0xe2f4);
13317 MP_WritePhyUshort(sc, 0x06, 0xe1e2);
13318 MP_WritePhyUshort(sc, 0x06, 0xf5e4);
13319 MP_WritePhyUshort(sc, 0x06, 0x8a78);
13320 MP_WritePhyUshort(sc, 0x06, 0xe58a);
13321 MP_WritePhyUshort(sc, 0x06, 0x79ee);
13322 MP_WritePhyUshort(sc, 0x06, 0xe2f4);
13323 MP_WritePhyUshort(sc, 0x06, 0xd8ee);
13324 MP_WritePhyUshort(sc, 0x06, 0xe2f5);
13325 MP_WritePhyUshort(sc, 0x06, 0x20fc);
13326 MP_WritePhyUshort(sc, 0x06, 0x04f8);
13327 MP_WritePhyUshort(sc, 0x06, 0xf9fa);
13328 MP_WritePhyUshort(sc, 0x06, 0xef69);
13329 MP_WritePhyUshort(sc, 0x06, 0xe08b);
13330 MP_WritePhyUshort(sc, 0x06, 0x87ad);
13331 MP_WritePhyUshort(sc, 0x06, 0x2065);
13332 MP_WritePhyUshort(sc, 0x06, 0xd200);
13333 MP_WritePhyUshort(sc, 0x06, 0xbf2e);
13334 MP_WritePhyUshort(sc, 0x06, 0xe802);
13335 MP_WritePhyUshort(sc, 0x06, 0x31dd);
13336 MP_WritePhyUshort(sc, 0x06, 0x1e21);
13337 MP_WritePhyUshort(sc, 0x06, 0xbf82);
13338 MP_WritePhyUshort(sc, 0x06, 0xdf02);
13339 MP_WritePhyUshort(sc, 0x06, 0x31dd);
13340 MP_WritePhyUshort(sc, 0x06, 0x0c11);
13341 MP_WritePhyUshort(sc, 0x06, 0x1e21);
13342 MP_WritePhyUshort(sc, 0x06, 0xbf82);
13343 MP_WritePhyUshort(sc, 0x06, 0xe202);
13344 MP_WritePhyUshort(sc, 0x06, 0x31dd);
13345 MP_WritePhyUshort(sc, 0x06, 0x0c12);
13346 MP_WritePhyUshort(sc, 0x06, 0x1e21);
13347 MP_WritePhyUshort(sc, 0x06, 0xbf82);
13348 MP_WritePhyUshort(sc, 0x06, 0xe502);
13349 MP_WritePhyUshort(sc, 0x06, 0x31dd);
13350 MP_WritePhyUshort(sc, 0x06, 0x0c13);
13351 MP_WritePhyUshort(sc, 0x06, 0x1e21);
13352 MP_WritePhyUshort(sc, 0x06, 0xbf1f);
13353 MP_WritePhyUshort(sc, 0x06, 0x5302);
13354 MP_WritePhyUshort(sc, 0x06, 0x31dd);
13355 MP_WritePhyUshort(sc, 0x06, 0x0c14);
13356 MP_WritePhyUshort(sc, 0x06, 0x1e21);
13357 MP_WritePhyUshort(sc, 0x06, 0xbf82);
13358 MP_WritePhyUshort(sc, 0x06, 0xeb02);
13359 MP_WritePhyUshort(sc, 0x06, 0x31dd);
13360 MP_WritePhyUshort(sc, 0x06, 0x0c16);
13361 MP_WritePhyUshort(sc, 0x06, 0x1e21);
13362 MP_WritePhyUshort(sc, 0x06, 0xe083);
13363 MP_WritePhyUshort(sc, 0x06, 0xe01f);
13364 MP_WritePhyUshort(sc, 0x06, 0x029e);
13365 MP_WritePhyUshort(sc, 0x06, 0x22e6);
13366 MP_WritePhyUshort(sc, 0x06, 0x83e0);
13367 MP_WritePhyUshort(sc, 0x06, 0xad31);
13368 MP_WritePhyUshort(sc, 0x06, 0x14ad);
13369 MP_WritePhyUshort(sc, 0x06, 0x3011);
13370 MP_WritePhyUshort(sc, 0x06, 0xef02);
13371 MP_WritePhyUshort(sc, 0x06, 0x580c);
13372 MP_WritePhyUshort(sc, 0x06, 0x9e07);
13373 MP_WritePhyUshort(sc, 0x06, 0xad36);
13374 MP_WritePhyUshort(sc, 0x06, 0x085a);
13375 MP_WritePhyUshort(sc, 0x06, 0x309f);
13376 MP_WritePhyUshort(sc, 0x06, 0x04d1);
13377 MP_WritePhyUshort(sc, 0x06, 0x01ae);
13378 MP_WritePhyUshort(sc, 0x06, 0x02d1);
13379 MP_WritePhyUshort(sc, 0x06, 0x00bf);
13380 MP_WritePhyUshort(sc, 0x06, 0x82dc);
13381 MP_WritePhyUshort(sc, 0x06, 0x0232);
13382 MP_WritePhyUshort(sc, 0x06, 0x0aef);
13383 MP_WritePhyUshort(sc, 0x06, 0x96fe);
13384 MP_WritePhyUshort(sc, 0x06, 0xfdfc);
13385 MP_WritePhyUshort(sc, 0x06, 0x0400);
13386 MP_WritePhyUshort(sc, 0x06, 0xe140);
13387 MP_WritePhyUshort(sc, 0x06, 0x77e1);
13388 MP_WritePhyUshort(sc, 0x06, 0x4010);
13389 MP_WritePhyUshort(sc, 0x06, 0xe150);
13390 MP_WritePhyUshort(sc, 0x06, 0x32e1);
13391 MP_WritePhyUshort(sc, 0x06, 0x5030);
13392 MP_WritePhyUshort(sc, 0x06, 0xe144);
13393 MP_WritePhyUshort(sc, 0x06, 0x74e1);
13394 MP_WritePhyUshort(sc, 0x06, 0x44bb);
13395 MP_WritePhyUshort(sc, 0x06, 0xe2d2);
13396 MP_WritePhyUshort(sc, 0x06, 0x40e0);
13397 MP_WritePhyUshort(sc, 0x06, 0x2cfc);
13398 MP_WritePhyUshort(sc, 0x06, 0xe2cc);
13399 MP_WritePhyUshort(sc, 0x06, 0xcce2);
13400 MP_WritePhyUshort(sc, 0x06, 0x00cc);
13401 MP_WritePhyUshort(sc, 0x06, 0xe000);
13402 MP_WritePhyUshort(sc, 0x06, 0x99e0);
13403 MP_WritePhyUshort(sc, 0x06, 0x3688);
13404 MP_WritePhyUshort(sc, 0x06, 0xe036);
13405 MP_WritePhyUshort(sc, 0x06, 0x99e1);
13406 MP_WritePhyUshort(sc, 0x06, 0x40dd);
13407 MP_WritePhyUshort(sc, 0x06, 0xe022);
13408 MP_WritePhyUshort(sc, 0x05, 0xe142);
13409 Data = MP_ReadPhyUshort(sc, 0x06);
13410 Data |= BIT_0;
13411 MP_WritePhyUshort(sc, 0x06, Data);
13412 MP_WritePhyUshort(sc, 0x05, 0xe140);
13413 Data = MP_ReadPhyUshort(sc, 0x06);
13414 Data |= BIT_0;
13415 MP_WritePhyUshort(sc, 0x06, Data);
13416 MP_WritePhyUshort(sc, 0x1f, 0x0000);
13417 MP_WritePhyUshort(sc, 0x1f, 0x0005);
13418 for (i = 0; i < 200; i++) {
13419 DELAY(100);
13420 Data = MP_ReadPhyUshort(sc, 0x00);
13421 if (Data & BIT_7)
13422 break;
13423 }
13424 MP_WritePhyUshort(sc, 0x1f, 0x0004);
13425 MP_WritePhyUshort(sc, 0x1f, 0x0007);
13426 MP_WritePhyUshort(sc, 0x1e, 0x0023);
13427 Data = MP_ReadPhyUshort(sc, 0x17);
13428 Data &= ~BIT_0;
13429 Data |= BIT_2;
13430 MP_WritePhyUshort(sc, 0x17, Data);
13431 MP_WritePhyUshort(sc, 0x1f, 0x0002);
13432 MP_WritePhyUshort(sc, 0x1f, 0x0000);
13433 MP_WritePhyUshort(sc, 0x1F, 0x0003);
13434 MP_WritePhyUshort(sc, 0x09, 0xA20F);
13435 MP_WritePhyUshort(sc, 0x1F, 0x0000);
13436 MP_WritePhyUshort(sc, 0x1f, 0x0000);
13437 MP_WritePhyUshort(sc, 0x00, 0x9200);
13438
13439 MP_WritePhyUshort(sc, 0x1F, 0x0005);
13440 MP_WritePhyUshort(sc, 0x05, 0x8B80);
13441 Data = MP_ReadPhyUshort(sc, 0x06);
13442 Data |= BIT_2 | BIT_1;
13443 MP_WritePhyUshort(sc, 0x06, Data);
13444 MP_WritePhyUshort(sc, 0x1f, 0x0000);
13445
13446 MP_WritePhyUshort(sc, 0x1f, 0x0004);
13447 MP_WritePhyUshort(sc, 0x1f, 0x0007);
13448 MP_WritePhyUshort(sc, 0x1e, 0x002D);
13449 Data = MP_ReadPhyUshort(sc, 0x18);
13450 Data |= BIT_4;
13451 MP_WritePhyUshort(sc, 0x18, Data);
13452 MP_WritePhyUshort(sc, 0x1f, 0x0002);
13453 MP_WritePhyUshort(sc, 0x1f, 0x0000);
13454 Data = MP_ReadPhyUshort(sc, 0x14);
13455 Data |= BIT_15;
13456 MP_WritePhyUshort(sc, 0x14, Data);
13457
13458 MP_WritePhyUshort(sc, 0x1F, 0x0005);
13459 MP_WritePhyUshort(sc, 0x05, 0x8B86);
13460 Data = MP_ReadPhyUshort(sc, 0x06);
13461 Data |= BIT_0;
13462 MP_WritePhyUshort(sc, 0x06, Data);
13463 MP_WritePhyUshort(sc, 0x1F, 0x0000);
13464
13465 MP_WritePhyUshort(sc, 0x1F, 0x0001);
13466 MP_WritePhyUshort(sc, 0x0B, 0x6C14);
13467 MP_WritePhyUshort(sc, 0x14, 0x7F3D);
13468 MP_WritePhyUshort(sc, 0x1C, 0xFAFE);
13469 MP_WritePhyUshort(sc, 0x08, 0x07C5);
13470 MP_WritePhyUshort(sc, 0x10, 0xF090);
13471 MP_WritePhyUshort(sc, 0x1F, 0x0003);
13472 MP_WritePhyUshort(sc, 0x14, 0x641A);
13473 MP_WritePhyUshort(sc, 0x1A, 0x0606);
13474 MP_WritePhyUshort(sc, 0x12, 0xF480);
13475 MP_WritePhyUshort(sc, 0x13, 0x0747);
13476 MP_WritePhyUshort(sc, 0x1F, 0x0000);
13477
13478 MP_WritePhyUshort(sc, 0x1F, 0x0004);
13479 MP_WritePhyUshort(sc, 0x1F, 0x0007);
13480 MP_WritePhyUshort(sc, 0x1E, 0x0078);
13481 MP_WritePhyUshort(sc, 0x15, 0xA408);
13482 MP_WritePhyUshort(sc, 0x17, 0x5100);
13483 MP_WritePhyUshort(sc, 0x19, 0x0008);
13484 MP_WritePhyUshort(sc, 0x1F, 0x0002);
13485 MP_WritePhyUshort(sc, 0x1F, 0x0000);
13486
13487 MP_WritePhyUshort(sc, 0x1F, 0x0003);
13488 MP_WritePhyUshort(sc, 0x0D, 0x0207);
13489 MP_WritePhyUshort(sc, 0x02, 0x5FD0);
13490 MP_WritePhyUshort(sc, 0x1F, 0x0000);
13491
13492 MP_WritePhyUshort(sc, 0x1F, 0x0004);
13493 MP_WritePhyUshort(sc, 0x1F, 0x0007);
13494 MP_WritePhyUshort(sc, 0x1E, 0x00A1);
13495 Data = MP_ReadPhyUshort(sc, 0x1A);
13496 Data &= ~BIT_2;
13497 MP_WritePhyUshort(sc, 0x1A, Data);
13498 MP_WritePhyUshort(sc, 0x1F, 0x0002);
13499 MP_WritePhyUshort(sc, 0x1F, 0x0000);
13500
13501 MP_WritePhyUshort(sc, 0x1F, 0x0004);
13502 MP_WritePhyUshort(sc, 0x1F, 0x0007);
13503 MP_WritePhyUshort(sc, 0x1E, 0x002D);
13504 Data = MP_ReadPhyUshort(sc, 0x16);
13505 Data |= BIT_5;
13506 MP_WritePhyUshort(sc, 0x16, Data);
13507 MP_WritePhyUshort(sc, 0x1F, 0x0002);
13508 MP_WritePhyUshort(sc, 0x1F, 0x0000);
13509
13510 MP_WritePhyUshort(sc, 0x1F, 0x0004);
13511 MP_WritePhyUshort(sc, 0x1F, 0x0007);
13512 MP_WritePhyUshort(sc, 0x1E, 0x00AC);
13513 MP_WritePhyUshort(sc, 0x18, 0x0006);
13514 MP_WritePhyUshort(sc, 0x1F, 0x0002);
13515 MP_WritePhyUshort(sc, 0x1F, 0x0000);
13516
13517 MP_WritePhyUshort(sc, 0x1F, 0x0003);
13518 MP_WritePhyUshort(sc, 0x09, 0xA20F);
13519 MP_WritePhyUshort(sc, 0x1F, 0x0000);
13520
13521 MP_WritePhyUshort(sc, 0x1F, 0x0005);
13522 MP_WritePhyUshort(sc, 0x05, 0x8B85);
13523 Data = MP_ReadPhyUshort(sc, 0x06);
13524 Data |= BIT_14;
13525 MP_WritePhyUshort(sc, 0x06, Data);
13526 MP_WritePhyUshort(sc, 0x1F, 0x0000);
13527
13528 MP_WritePhyUshort(sc, 0x1F, 0x0005);
13529 MP_WritePhyUshort(sc, 0x05, 0x8B54);
13530 Data = MP_ReadPhyUshort(sc, 0x06);
13531 Data &= ~BIT_11;
13532 MP_WritePhyUshort(sc, 0x06, Data);
13533 MP_WritePhyUshort(sc, 0x05, 0x8B5D);
13534 Data = MP_ReadPhyUshort(sc, 0x06);
13535 Data &= ~BIT_11;
13536 MP_WritePhyUshort(sc, 0x06, Data);
13537 MP_WritePhyUshort(sc, 0x05, 0x8A7C);
13538 Data = MP_ReadPhyUshort(sc, 0x06);
13539 Data &= ~BIT_8;
13540 MP_WritePhyUshort(sc, 0x06, Data);
13541 MP_WritePhyUshort(sc, 0x05, 0x8A7F);
13542 Data = MP_ReadPhyUshort(sc, 0x06);
13543 Data |= BIT_8;
13544 MP_WritePhyUshort(sc, 0x06, Data);
13545 MP_WritePhyUshort(sc, 0x05, 0x8A82);
13546 Data = MP_ReadPhyUshort(sc, 0x06);
13547 Data &= ~BIT_8;
13548 MP_WritePhyUshort(sc, 0x06, Data);
13549 MP_WritePhyUshort(sc, 0x05, 0x8A85);
13550 Data = MP_ReadPhyUshort(sc, 0x06);
13551 Data &= ~BIT_8;
13552 MP_WritePhyUshort(sc, 0x06, Data);
13553 MP_WritePhyUshort(sc, 0x05, 0x8A88);
13554 Data = MP_ReadPhyUshort(sc, 0x06);
13555 Data &= ~BIT_8;
13556 MP_WritePhyUshort(sc, 0x06, Data);
13557 MP_WritePhyUshort(sc, 0x1F, 0x0000);
13558
13559 MP_WritePhyUshort(sc, 0x1F, 0x0005);
13560 MP_WritePhyUshort(sc, 0x05, 0x8B85);
13561 Data = MP_ReadPhyUshort(sc, 0x06);
13562 Data |= BIT_15;
13563 MP_WritePhyUshort(sc, 0x06, Data);
13564 MP_WritePhyUshort(sc, 0x1f, 0x0000);
13565
13566 MP_WritePhyUshort(sc, 0x1f, 0x0003);
13567 Data = MP_ReadPhyUshort(sc, 0x19);
13568 Data &= ~BIT_0;
13569 MP_WritePhyUshort(sc, 0x19, Data);
13570 Data = MP_ReadPhyUshort(sc, 0x10);
13571 Data &= ~BIT_10;
13572 MP_WritePhyUshort(sc, 0x10, Data);
13573 MP_WritePhyUshort(sc, 0x1f, 0x0000);
13574 } else if (sc->re_type == MACFG_39) {
13575 Data_u32 = re_eri_read(sc, 0x1D0, 4, ERIAR_ExGMAC);
13576 Data_u32 &= ~BIT_1;
13577 re_eri_write(sc, 0x1D0, 4, Data_u32, ERIAR_ExGMAC);
13578
13579 MP_WritePhyUshort(sc, 0x1f, 0x0000);
13580 MP_WritePhyUshort(sc, 0x00, 0x1800);
13581 Data = MP_ReadPhyUshort(sc, 0x15);
13582 Data &= ~(BIT_12);
13583 MP_WritePhyUshort(sc, 0x15, Data);
13584 MP_WritePhyUshort(sc, 0x00, 0x4800);
13585 MP_WritePhyUshort(sc, 0x1f, 0x0007);
13586 MP_WritePhyUshort(sc, 0x1e, 0x002f);
13587 for (i = 0; i < 1000; i++) {
13588 if (MP_ReadPhyUshort(sc, 0x1c) & BIT_7)
13589 break;
13590 DELAY(100);
13591 }
13592 MP_WritePhyUshort(sc, 0x1f, 0x0000);
13593 MP_WritePhyUshort(sc, 0x00, 0x1800);
13594 MP_WritePhyUshort(sc, 0x1f, 0x0007);
13595 MP_WritePhyUshort(sc, 0x1e, 0x0023);
13596 for (i = 0; i < 200; i++) {
13597 if ((MP_ReadPhyUshort(sc, 0x17) & BIT_0) == 0)
13598 break;
13599 DELAY(100);
13600 }
13601 MP_WritePhyUshort(sc, 0x1f, 0x0005);
13602 MP_WritePhyUshort(sc, 0x05, 0xfff6);
13603 MP_WritePhyUshort(sc, 0x06, 0x0080);
13604 MP_WritePhyUshort(sc, 0x1f, 0x0007);
13605 MP_WritePhyUshort(sc, 0x1e, 0x0023);
13606 MP_WritePhyUshort(sc, 0x16, 0x0306);
13607 MP_WritePhyUshort(sc, 0x16, 0x0307);
13608 MP_WritePhyUshort(sc, 0x15, 0x00AF);
13609 MP_WritePhyUshort(sc, 0x19, 0x4060);
13610 MP_WritePhyUshort(sc, 0x15, 0x00B0);
13611 MP_WritePhyUshort(sc, 0x19, 0x7800);
13612 MP_WritePhyUshort(sc, 0x15, 0x00B1);
13613 MP_WritePhyUshort(sc, 0x19, 0x7e00);
13614 MP_WritePhyUshort(sc, 0x15, 0x00B2);
13615 MP_WritePhyUshort(sc, 0x19, 0x72B0);
13616 MP_WritePhyUshort(sc, 0x15, 0x00B3);
13617 MP_WritePhyUshort(sc, 0x19, 0x7F00);
13618 MP_WritePhyUshort(sc, 0x15, 0x00B4);
13619 MP_WritePhyUshort(sc, 0x19, 0x73B0);
13620 MP_WritePhyUshort(sc, 0x15, 0x0101);
13621 MP_WritePhyUshort(sc, 0x19, 0x0005);
13622 MP_WritePhyUshort(sc, 0x15, 0x0103);
13623 MP_WritePhyUshort(sc, 0x19, 0x0003);
13624 MP_WritePhyUshort(sc, 0x15, 0x0105);
13625 MP_WritePhyUshort(sc, 0x19, 0x30FD);
13626 MP_WritePhyUshort(sc, 0x15, 0x0106);
13627 MP_WritePhyUshort(sc, 0x19, 0x9DF7);
13628 MP_WritePhyUshort(sc, 0x15, 0x0107);
13629 MP_WritePhyUshort(sc, 0x19, 0x30C6);
13630 MP_WritePhyUshort(sc, 0x15, 0x0098);
13631 MP_WritePhyUshort(sc, 0x19, 0x7c0b);
13632 MP_WritePhyUshort(sc, 0x15, 0x0099);
13633 MP_WritePhyUshort(sc, 0x19, 0x6c0b);
13634 MP_WritePhyUshort(sc, 0x15, 0x00eb);
13635 MP_WritePhyUshort(sc, 0x19, 0x6c0b);
13636 MP_WritePhyUshort(sc, 0x15, 0x00f8);
13637 MP_WritePhyUshort(sc, 0x19, 0x6f0b);
13638 MP_WritePhyUshort(sc, 0x15, 0x00fe);
13639 MP_WritePhyUshort(sc, 0x19, 0x6f0f);
13640 MP_WritePhyUshort(sc, 0x15, 0x00db);
13641 MP_WritePhyUshort(sc, 0x19, 0x6f09);
13642 MP_WritePhyUshort(sc, 0x15, 0x00dc);
13643 MP_WritePhyUshort(sc, 0x19, 0xaefd);
13644 MP_WritePhyUshort(sc, 0x15, 0x00dd);
13645 MP_WritePhyUshort(sc, 0x19, 0x6f0b);
13646 MP_WritePhyUshort(sc, 0x15, 0x00de);
13647 MP_WritePhyUshort(sc, 0x19, 0xc60b);
13648 MP_WritePhyUshort(sc, 0x15, 0x00df);
13649 MP_WritePhyUshort(sc, 0x19, 0x00fa);
13650 MP_WritePhyUshort(sc, 0x15, 0x00e0);
13651 MP_WritePhyUshort(sc, 0x19, 0x30e1);
13652 MP_WritePhyUshort(sc, 0x15, 0x020c);
13653 MP_WritePhyUshort(sc, 0x19, 0x3224);
13654 MP_WritePhyUshort(sc, 0x15, 0x020e);
13655 MP_WritePhyUshort(sc, 0x19, 0x9813);
13656 MP_WritePhyUshort(sc, 0x15, 0x020f);
13657 MP_WritePhyUshort(sc, 0x19, 0x7801);
13658 MP_WritePhyUshort(sc, 0x15, 0x0210);
13659 MP_WritePhyUshort(sc, 0x19, 0x930f);
13660 MP_WritePhyUshort(sc, 0x15, 0x0211);
13661 MP_WritePhyUshort(sc, 0x19, 0x9206);
13662 MP_WritePhyUshort(sc, 0x15, 0x0212);
13663 MP_WritePhyUshort(sc, 0x19, 0x4002);
13664 MP_WritePhyUshort(sc, 0x15, 0x0213);
13665 MP_WritePhyUshort(sc, 0x19, 0x7800);
13666 MP_WritePhyUshort(sc, 0x15, 0x0214);
13667 MP_WritePhyUshort(sc, 0x19, 0x588f);
13668 MP_WritePhyUshort(sc, 0x15, 0x0215);
13669 MP_WritePhyUshort(sc, 0x19, 0x5520);
13670 MP_WritePhyUshort(sc, 0x15, 0x0216);
13671 MP_WritePhyUshort(sc, 0x19, 0x3224);
13672 MP_WritePhyUshort(sc, 0x15, 0x0217);
13673 MP_WritePhyUshort(sc, 0x19, 0x4002);
13674 MP_WritePhyUshort(sc, 0x15, 0x0218);
13675 MP_WritePhyUshort(sc, 0x19, 0x7800);
13676 MP_WritePhyUshort(sc, 0x15, 0x0219);
13677 MP_WritePhyUshort(sc, 0x19, 0x588d);
13678 MP_WritePhyUshort(sc, 0x15, 0x021a);
13679 MP_WritePhyUshort(sc, 0x19, 0x5540);
13680 MP_WritePhyUshort(sc, 0x15, 0x021b);
13681 MP_WritePhyUshort(sc, 0x19, 0x9e03);
13682 MP_WritePhyUshort(sc, 0x15, 0x021c);
13683 MP_WritePhyUshort(sc, 0x19, 0x7c40);
13684 MP_WritePhyUshort(sc, 0x15, 0x021d);
13685 MP_WritePhyUshort(sc, 0x19, 0x6840);
13686 MP_WritePhyUshort(sc, 0x15, 0x021e);
13687 MP_WritePhyUshort(sc, 0x19, 0x3224);
13688 MP_WritePhyUshort(sc, 0x15, 0x021f);
13689 MP_WritePhyUshort(sc, 0x19, 0x4002);
13690 MP_WritePhyUshort(sc, 0x15, 0x0220);
13691 MP_WritePhyUshort(sc, 0x19, 0x3224);
13692 MP_WritePhyUshort(sc, 0x15, 0x0221);
13693 MP_WritePhyUshort(sc, 0x19, 0x9e03);
13694 MP_WritePhyUshort(sc, 0x15, 0x0222);
13695 MP_WritePhyUshort(sc, 0x19, 0x7c40);
13696 MP_WritePhyUshort(sc, 0x15, 0x0223);
13697 MP_WritePhyUshort(sc, 0x19, 0x6840);
13698 MP_WritePhyUshort(sc, 0x15, 0x0224);
13699 MP_WritePhyUshort(sc, 0x19, 0x7800);
13700 MP_WritePhyUshort(sc, 0x15, 0x0225);
13701 MP_WritePhyUshort(sc, 0x19, 0x3231);
13702 MP_WritePhyUshort(sc, 0x15, 0x0000);
13703 MP_WritePhyUshort(sc, 0x16, 0x0306);
13704 MP_WritePhyUshort(sc, 0x16, 0x0300);
13705 MP_WritePhyUshort(sc, 0x1f, 0x0002);
13706 MP_WritePhyUshort(sc, 0x1f, 0x0000);
13707 MP_WritePhyUshort(sc, 0x1f, 0x0000);
13708 MP_WritePhyUshort(sc, 0x17, 0x2160);
13709 MP_WritePhyUshort(sc, 0x1f, 0x0007);
13710 MP_WritePhyUshort(sc, 0x1e, 0x0040);
13711 MP_WritePhyUshort(sc, 0x18, 0x0004);
13712 MP_WritePhyUshort(sc, 0x18, 0x09d4);
13713 MP_WritePhyUshort(sc, 0x19, 0x4000);
13714 MP_WritePhyUshort(sc, 0x18, 0x09e4);
13715 MP_WritePhyUshort(sc, 0x19, 0x0800);
13716 MP_WritePhyUshort(sc, 0x18, 0x09f4);
13717 MP_WritePhyUshort(sc, 0x19, 0xff00);
13718 MP_WritePhyUshort(sc, 0x18, 0x0a04);
13719 MP_WritePhyUshort(sc, 0x19, 0x4000);
13720 MP_WritePhyUshort(sc, 0x18, 0x0a14);
13721 MP_WritePhyUshort(sc, 0x19, 0x0c00);
13722 MP_WritePhyUshort(sc, 0x18, 0x0a24);
13723 MP_WritePhyUshort(sc, 0x19, 0xff00);
13724 MP_WritePhyUshort(sc, 0x18, 0x0a74);
13725 MP_WritePhyUshort(sc, 0x19, 0xf600);
13726 MP_WritePhyUshort(sc, 0x18, 0x1a24);
13727 MP_WritePhyUshort(sc, 0x19, 0x7d00);
13728 MP_WritePhyUshort(sc, 0x18, 0x1a64);
13729 MP_WritePhyUshort(sc, 0x19, 0x0500);
13730 MP_WritePhyUshort(sc, 0x18, 0x1a74);
13731 MP_WritePhyUshort(sc, 0x19, 0x9500);
13732 MP_WritePhyUshort(sc, 0x18, 0x1a84);
13733 MP_WritePhyUshort(sc, 0x19, 0x8000);
13734 MP_WritePhyUshort(sc, 0x18, 0x1a94);
13735 MP_WritePhyUshort(sc, 0x19, 0x7d00);
13736 MP_WritePhyUshort(sc, 0x18, 0x1aa4);
13737 MP_WritePhyUshort(sc, 0x19, 0x9600);
13738 MP_WritePhyUshort(sc, 0x18, 0x1ac4);
13739 MP_WritePhyUshort(sc, 0x19, 0x4000);
13740 MP_WritePhyUshort(sc, 0x18, 0x1ad4);
13741 MP_WritePhyUshort(sc, 0x19, 0x0800);
13742 MP_WritePhyUshort(sc, 0x18, 0x1af4);
13743 MP_WritePhyUshort(sc, 0x19, 0xc400);
13744 MP_WritePhyUshort(sc, 0x18, 0x1b04);
13745 MP_WritePhyUshort(sc, 0x19, 0x4000);
13746 MP_WritePhyUshort(sc, 0x18, 0x1b14);
13747 MP_WritePhyUshort(sc, 0x19, 0x0800);
13748 MP_WritePhyUshort(sc, 0x18, 0x1b24);
13749 MP_WritePhyUshort(sc, 0x19, 0xfd00);
13750 MP_WritePhyUshort(sc, 0x18, 0x1b34);
13751 MP_WritePhyUshort(sc, 0x19, 0x4000);
13752 MP_WritePhyUshort(sc, 0x18, 0x1b44);
13753 MP_WritePhyUshort(sc, 0x19, 0x0400);
13754 MP_WritePhyUshort(sc, 0x18, 0x1b94);
13755 MP_WritePhyUshort(sc, 0x19, 0xf100);
13756 MP_WritePhyUshort(sc, 0x1f, 0x0000);
13757 MP_WritePhyUshort(sc, 0x17, 0x2100);
13758 MP_WritePhyUshort(sc, 0x1f, 0x0007);
13759 MP_WritePhyUshort(sc, 0x1e, 0x0040);
13760 MP_WritePhyUshort(sc, 0x18, 0x0000);
13761 MP_WritePhyUshort(sc, 0x1f, 0x0000);
13762 MP_WritePhyUshort(sc, 0x1f, 0x0005);
13763 MP_WritePhyUshort(sc, 0x05, 0xfff6);
13764 MP_WritePhyUshort(sc, 0x06, 0x0080);
13765 MP_WritePhyUshort(sc, 0x05, 0x8000);
13766 MP_WritePhyUshort(sc, 0x06, 0x0280);
13767 MP_WritePhyUshort(sc, 0x06, 0x48f7);
13768 MP_WritePhyUshort(sc, 0x06, 0x00e0);
13769 MP_WritePhyUshort(sc, 0x06, 0xfff7);
13770 MP_WritePhyUshort(sc, 0x06, 0xa080);
13771 MP_WritePhyUshort(sc, 0x06, 0x02ae);
13772 MP_WritePhyUshort(sc, 0x06, 0xf602);
13773 MP_WritePhyUshort(sc, 0x06, 0x0115);
13774 MP_WritePhyUshort(sc, 0x06, 0x0201);
13775 MP_WritePhyUshort(sc, 0x06, 0x2202);
13776 MP_WritePhyUshort(sc, 0x06, 0x80a0);
13777 MP_WritePhyUshort(sc, 0x06, 0x0201);
13778 MP_WritePhyUshort(sc, 0x06, 0x3f02);
13779 MP_WritePhyUshort(sc, 0x06, 0x0159);
13780 MP_WritePhyUshort(sc, 0x06, 0x0280);
13781 MP_WritePhyUshort(sc, 0x06, 0xbd02);
13782 MP_WritePhyUshort(sc, 0x06, 0x80da);
13783 MP_WritePhyUshort(sc, 0x06, 0xe08b);
13784 MP_WritePhyUshort(sc, 0x06, 0x88e1);
13785 MP_WritePhyUshort(sc, 0x06, 0x8b89);
13786 MP_WritePhyUshort(sc, 0x06, 0x1e01);
13787 MP_WritePhyUshort(sc, 0x06, 0xe18b);
13788 MP_WritePhyUshort(sc, 0x06, 0x8a1e);
13789 MP_WritePhyUshort(sc, 0x06, 0x01e1);
13790 MP_WritePhyUshort(sc, 0x06, 0x8b8b);
13791 MP_WritePhyUshort(sc, 0x06, 0x1e01);
13792 MP_WritePhyUshort(sc, 0x06, 0xe18b);
13793 MP_WritePhyUshort(sc, 0x06, 0x8c1e);
13794 MP_WritePhyUshort(sc, 0x06, 0x01e1);
13795 MP_WritePhyUshort(sc, 0x06, 0x8b8d);
13796 MP_WritePhyUshort(sc, 0x06, 0x1e01);
13797 MP_WritePhyUshort(sc, 0x06, 0xe18b);
13798 MP_WritePhyUshort(sc, 0x06, 0x8e1e);
13799 MP_WritePhyUshort(sc, 0x06, 0x01a0);
13800 MP_WritePhyUshort(sc, 0x06, 0x00c7);
13801 MP_WritePhyUshort(sc, 0x06, 0xaebb);
13802 MP_WritePhyUshort(sc, 0x06, 0xd481);
13803 MP_WritePhyUshort(sc, 0x06, 0xd2e4);
13804 MP_WritePhyUshort(sc, 0x06, 0x8b92);
13805 MP_WritePhyUshort(sc, 0x06, 0xe58b);
13806 MP_WritePhyUshort(sc, 0x06, 0x93d1);
13807 MP_WritePhyUshort(sc, 0x06, 0x03bf);
13808 MP_WritePhyUshort(sc, 0x06, 0x859e);
13809 MP_WritePhyUshort(sc, 0x06, 0x0237);
13810 MP_WritePhyUshort(sc, 0x06, 0x23d1);
13811 MP_WritePhyUshort(sc, 0x06, 0x02bf);
13812 MP_WritePhyUshort(sc, 0x06, 0x85a1);
13813 MP_WritePhyUshort(sc, 0x06, 0x0237);
13814 MP_WritePhyUshort(sc, 0x06, 0x23ee);
13815 MP_WritePhyUshort(sc, 0x06, 0x8608);
13816 MP_WritePhyUshort(sc, 0x06, 0x03ee);
13817 MP_WritePhyUshort(sc, 0x06, 0x860a);
13818 MP_WritePhyUshort(sc, 0x06, 0x60ee);
13819 MP_WritePhyUshort(sc, 0x06, 0x8610);
13820 MP_WritePhyUshort(sc, 0x06, 0x00ee);
13821 MP_WritePhyUshort(sc, 0x06, 0x8611);
13822 MP_WritePhyUshort(sc, 0x06, 0x00ee);
13823 MP_WritePhyUshort(sc, 0x06, 0x8abe);
13824 MP_WritePhyUshort(sc, 0x06, 0x07ee);
13825 MP_WritePhyUshort(sc, 0x06, 0x8abf);
13826 MP_WritePhyUshort(sc, 0x06, 0x73ee);
13827 MP_WritePhyUshort(sc, 0x06, 0x8a95);
13828 MP_WritePhyUshort(sc, 0x06, 0x02bf);
13829 MP_WritePhyUshort(sc, 0x06, 0x8b88);
13830 MP_WritePhyUshort(sc, 0x06, 0xec00);
13831 MP_WritePhyUshort(sc, 0x06, 0x19a9);
13832 MP_WritePhyUshort(sc, 0x06, 0x8b90);
13833 MP_WritePhyUshort(sc, 0x06, 0xf9ee);
13834 MP_WritePhyUshort(sc, 0x06, 0xfff6);
13835 MP_WritePhyUshort(sc, 0x06, 0x00ee);
13836 MP_WritePhyUshort(sc, 0x06, 0xfff7);
13837 MP_WritePhyUshort(sc, 0x06, 0xfed1);
13838 MP_WritePhyUshort(sc, 0x06, 0x00bf);
13839 MP_WritePhyUshort(sc, 0x06, 0x8595);
13840 MP_WritePhyUshort(sc, 0x06, 0x0237);
13841 MP_WritePhyUshort(sc, 0x06, 0x23d1);
13842 MP_WritePhyUshort(sc, 0x06, 0x01bf);
13843 MP_WritePhyUshort(sc, 0x06, 0x8598);
13844 MP_WritePhyUshort(sc, 0x06, 0x0237);
13845 MP_WritePhyUshort(sc, 0x06, 0x2304);
13846 MP_WritePhyUshort(sc, 0x06, 0xf8e0);
13847 MP_WritePhyUshort(sc, 0x06, 0x8b8a);
13848 MP_WritePhyUshort(sc, 0x06, 0xad20);
13849 MP_WritePhyUshort(sc, 0x06, 0x14ee);
13850 MP_WritePhyUshort(sc, 0x06, 0x8b8a);
13851 MP_WritePhyUshort(sc, 0x06, 0x0002);
13852 MP_WritePhyUshort(sc, 0x06, 0x1f9a);
13853 MP_WritePhyUshort(sc, 0x06, 0xe0e4);
13854 MP_WritePhyUshort(sc, 0x06, 0x26e1);
13855 MP_WritePhyUshort(sc, 0x06, 0xe427);
13856 MP_WritePhyUshort(sc, 0x06, 0xeee4);
13857 MP_WritePhyUshort(sc, 0x06, 0x2623);
13858 MP_WritePhyUshort(sc, 0x06, 0xe5e4);
13859 MP_WritePhyUshort(sc, 0x06, 0x27fc);
13860 MP_WritePhyUshort(sc, 0x06, 0x04f8);
13861 MP_WritePhyUshort(sc, 0x06, 0xe08b);
13862 MP_WritePhyUshort(sc, 0x06, 0x8dad);
13863 MP_WritePhyUshort(sc, 0x06, 0x2014);
13864 MP_WritePhyUshort(sc, 0x06, 0xee8b);
13865 MP_WritePhyUshort(sc, 0x06, 0x8d00);
13866 MP_WritePhyUshort(sc, 0x06, 0xe08a);
13867 MP_WritePhyUshort(sc, 0x06, 0x5a78);
13868 MP_WritePhyUshort(sc, 0x06, 0x039e);
13869 MP_WritePhyUshort(sc, 0x06, 0x0902);
13870 MP_WritePhyUshort(sc, 0x06, 0x05db);
13871 MP_WritePhyUshort(sc, 0x06, 0x0282);
13872 MP_WritePhyUshort(sc, 0x06, 0x7b02);
13873 MP_WritePhyUshort(sc, 0x06, 0x3231);
13874 MP_WritePhyUshort(sc, 0x06, 0xfc04);
13875 MP_WritePhyUshort(sc, 0x06, 0xf8e0);
13876 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
13877 MP_WritePhyUshort(sc, 0x06, 0xad20);
13878 MP_WritePhyUshort(sc, 0x06, 0x1df6);
13879 MP_WritePhyUshort(sc, 0x06, 0x20e4);
13880 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
13881 MP_WritePhyUshort(sc, 0x06, 0x0281);
13882 MP_WritePhyUshort(sc, 0x06, 0x5c02);
13883 MP_WritePhyUshort(sc, 0x06, 0x2bcb);
13884 MP_WritePhyUshort(sc, 0x06, 0x022d);
13885 MP_WritePhyUshort(sc, 0x06, 0x2902);
13886 MP_WritePhyUshort(sc, 0x06, 0x03b4);
13887 MP_WritePhyUshort(sc, 0x06, 0x0285);
13888 MP_WritePhyUshort(sc, 0x06, 0x6402);
13889 MP_WritePhyUshort(sc, 0x06, 0x2eca);
13890 MP_WritePhyUshort(sc, 0x06, 0x0284);
13891 MP_WritePhyUshort(sc, 0x06, 0xcd02);
13892 MP_WritePhyUshort(sc, 0x06, 0x046f);
13893 MP_WritePhyUshort(sc, 0x06, 0xe08b);
13894 MP_WritePhyUshort(sc, 0x06, 0x8ead);
13895 MP_WritePhyUshort(sc, 0x06, 0x210b);
13896 MP_WritePhyUshort(sc, 0x06, 0xf621);
13897 MP_WritePhyUshort(sc, 0x06, 0xe48b);
13898 MP_WritePhyUshort(sc, 0x06, 0x8e02);
13899 MP_WritePhyUshort(sc, 0x06, 0x8520);
13900 MP_WritePhyUshort(sc, 0x06, 0x021b);
13901 MP_WritePhyUshort(sc, 0x06, 0xe8e0);
13902 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
13903 MP_WritePhyUshort(sc, 0x06, 0xad22);
13904 MP_WritePhyUshort(sc, 0x06, 0x05f6);
13905 MP_WritePhyUshort(sc, 0x06, 0x22e4);
13906 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
13907 MP_WritePhyUshort(sc, 0x06, 0xe08b);
13908 MP_WritePhyUshort(sc, 0x06, 0x8ead);
13909 MP_WritePhyUshort(sc, 0x06, 0x2308);
13910 MP_WritePhyUshort(sc, 0x06, 0xf623);
13911 MP_WritePhyUshort(sc, 0x06, 0xe48b);
13912 MP_WritePhyUshort(sc, 0x06, 0x8e02);
13913 MP_WritePhyUshort(sc, 0x06, 0x311c);
13914 MP_WritePhyUshort(sc, 0x06, 0xe08b);
13915 MP_WritePhyUshort(sc, 0x06, 0x8ead);
13916 MP_WritePhyUshort(sc, 0x06, 0x2405);
13917 MP_WritePhyUshort(sc, 0x06, 0xf624);
13918 MP_WritePhyUshort(sc, 0x06, 0xe48b);
13919 MP_WritePhyUshort(sc, 0x06, 0x8ee0);
13920 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
13921 MP_WritePhyUshort(sc, 0x06, 0xad25);
13922 MP_WritePhyUshort(sc, 0x06, 0x05f6);
13923 MP_WritePhyUshort(sc, 0x06, 0x25e4);
13924 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
13925 MP_WritePhyUshort(sc, 0x06, 0xe08b);
13926 MP_WritePhyUshort(sc, 0x06, 0x8ead);
13927 MP_WritePhyUshort(sc, 0x06, 0x2608);
13928 MP_WritePhyUshort(sc, 0x06, 0xf626);
13929 MP_WritePhyUshort(sc, 0x06, 0xe48b);
13930 MP_WritePhyUshort(sc, 0x06, 0x8e02);
13931 MP_WritePhyUshort(sc, 0x06, 0x2df5);
13932 MP_WritePhyUshort(sc, 0x06, 0xe08b);
13933 MP_WritePhyUshort(sc, 0x06, 0x8ead);
13934 MP_WritePhyUshort(sc, 0x06, 0x2705);
13935 MP_WritePhyUshort(sc, 0x06, 0xf627);
13936 MP_WritePhyUshort(sc, 0x06, 0xe48b);
13937 MP_WritePhyUshort(sc, 0x06, 0x8e02);
13938 MP_WritePhyUshort(sc, 0x06, 0x037a);
13939 MP_WritePhyUshort(sc, 0x06, 0xfc04);
13940 MP_WritePhyUshort(sc, 0x06, 0xf8f9);
13941 MP_WritePhyUshort(sc, 0x06, 0xfaef);
13942 MP_WritePhyUshort(sc, 0x06, 0x69e0);
13943 MP_WritePhyUshort(sc, 0x06, 0x8b87);
13944 MP_WritePhyUshort(sc, 0x06, 0xad20);
13945 MP_WritePhyUshort(sc, 0x06, 0x65d2);
13946 MP_WritePhyUshort(sc, 0x06, 0x00bf);
13947 MP_WritePhyUshort(sc, 0x06, 0x2fe9);
13948 MP_WritePhyUshort(sc, 0x06, 0x0236);
13949 MP_WritePhyUshort(sc, 0x06, 0xf61e);
13950 MP_WritePhyUshort(sc, 0x06, 0x21bf);
13951 MP_WritePhyUshort(sc, 0x06, 0x2ff5);
13952 MP_WritePhyUshort(sc, 0x06, 0x0236);
13953 MP_WritePhyUshort(sc, 0x06, 0xf60c);
13954 MP_WritePhyUshort(sc, 0x06, 0x111e);
13955 MP_WritePhyUshort(sc, 0x06, 0x21bf);
13956 MP_WritePhyUshort(sc, 0x06, 0x2ff8);
13957 MP_WritePhyUshort(sc, 0x06, 0x0236);
13958 MP_WritePhyUshort(sc, 0x06, 0xf60c);
13959 MP_WritePhyUshort(sc, 0x06, 0x121e);
13960 MP_WritePhyUshort(sc, 0x06, 0x21bf);
13961 MP_WritePhyUshort(sc, 0x06, 0x2ffb);
13962 MP_WritePhyUshort(sc, 0x06, 0x0236);
13963 MP_WritePhyUshort(sc, 0x06, 0xf60c);
13964 MP_WritePhyUshort(sc, 0x06, 0x131e);
13965 MP_WritePhyUshort(sc, 0x06, 0x21bf);
13966 MP_WritePhyUshort(sc, 0x06, 0x1f97);
13967 MP_WritePhyUshort(sc, 0x06, 0x0236);
13968 MP_WritePhyUshort(sc, 0x06, 0xf60c);
13969 MP_WritePhyUshort(sc, 0x06, 0x141e);
13970 MP_WritePhyUshort(sc, 0x06, 0x21bf);
13971 MP_WritePhyUshort(sc, 0x06, 0x859b);
13972 MP_WritePhyUshort(sc, 0x06, 0x0236);
13973 MP_WritePhyUshort(sc, 0x06, 0xf60c);
13974 MP_WritePhyUshort(sc, 0x06, 0x161e);
13975 MP_WritePhyUshort(sc, 0x06, 0x21e0);
13976 MP_WritePhyUshort(sc, 0x06, 0x8a8c);
13977 MP_WritePhyUshort(sc, 0x06, 0x1f02);
13978 MP_WritePhyUshort(sc, 0x06, 0x9e22);
13979 MP_WritePhyUshort(sc, 0x06, 0xe68a);
13980 MP_WritePhyUshort(sc, 0x06, 0x8cad);
13981 MP_WritePhyUshort(sc, 0x06, 0x3114);
13982 MP_WritePhyUshort(sc, 0x06, 0xad30);
13983 MP_WritePhyUshort(sc, 0x06, 0x11ef);
13984 MP_WritePhyUshort(sc, 0x06, 0x0258);
13985 MP_WritePhyUshort(sc, 0x06, 0x0c9e);
13986 MP_WritePhyUshort(sc, 0x06, 0x07ad);
13987 MP_WritePhyUshort(sc, 0x06, 0x3608);
13988 MP_WritePhyUshort(sc, 0x06, 0x5a30);
13989 MP_WritePhyUshort(sc, 0x06, 0x9f04);
13990 MP_WritePhyUshort(sc, 0x06, 0xd101);
13991 MP_WritePhyUshort(sc, 0x06, 0xae02);
13992 MP_WritePhyUshort(sc, 0x06, 0xd100);
13993 MP_WritePhyUshort(sc, 0x06, 0xbf2f);
13994 MP_WritePhyUshort(sc, 0x06, 0xf202);
13995 MP_WritePhyUshort(sc, 0x06, 0x3723);
13996 MP_WritePhyUshort(sc, 0x06, 0xef96);
13997 MP_WritePhyUshort(sc, 0x06, 0xfefd);
13998 MP_WritePhyUshort(sc, 0x06, 0xfc04);
13999 MP_WritePhyUshort(sc, 0x06, 0xf8f9);
14000 MP_WritePhyUshort(sc, 0x06, 0xface);
14001 MP_WritePhyUshort(sc, 0x06, 0xfaef);
14002 MP_WritePhyUshort(sc, 0x06, 0x69fa);
14003 MP_WritePhyUshort(sc, 0x06, 0xd401);
14004 MP_WritePhyUshort(sc, 0x06, 0x55b4);
14005 MP_WritePhyUshort(sc, 0x06, 0xfebf);
14006 MP_WritePhyUshort(sc, 0x06, 0x85a7);
14007 MP_WritePhyUshort(sc, 0x06, 0x0236);
14008 MP_WritePhyUshort(sc, 0x06, 0xf6ac);
14009 MP_WritePhyUshort(sc, 0x06, 0x280b);
14010 MP_WritePhyUshort(sc, 0x06, 0xbf85);
14011 MP_WritePhyUshort(sc, 0x06, 0xa402);
14012 MP_WritePhyUshort(sc, 0x06, 0x36f6);
14013 MP_WritePhyUshort(sc, 0x06, 0xac28);
14014 MP_WritePhyUshort(sc, 0x06, 0x49ae);
14015 MP_WritePhyUshort(sc, 0x06, 0x64bf);
14016 MP_WritePhyUshort(sc, 0x06, 0x85a4);
14017 MP_WritePhyUshort(sc, 0x06, 0x0236);
14018 MP_WritePhyUshort(sc, 0x06, 0xf6ac);
14019 MP_WritePhyUshort(sc, 0x06, 0x285b);
14020 MP_WritePhyUshort(sc, 0x06, 0xd000);
14021 MP_WritePhyUshort(sc, 0x06, 0x0282);
14022 MP_WritePhyUshort(sc, 0x06, 0x60ac);
14023 MP_WritePhyUshort(sc, 0x06, 0x2105);
14024 MP_WritePhyUshort(sc, 0x06, 0xac22);
14025 MP_WritePhyUshort(sc, 0x06, 0x02ae);
14026 MP_WritePhyUshort(sc, 0x06, 0x4ebf);
14027 MP_WritePhyUshort(sc, 0x06, 0xe0c4);
14028 MP_WritePhyUshort(sc, 0x06, 0xbe86);
14029 MP_WritePhyUshort(sc, 0x06, 0x14d2);
14030 MP_WritePhyUshort(sc, 0x06, 0x04d8);
14031 MP_WritePhyUshort(sc, 0x06, 0x19d9);
14032 MP_WritePhyUshort(sc, 0x06, 0x1907);
14033 MP_WritePhyUshort(sc, 0x06, 0xdc19);
14034 MP_WritePhyUshort(sc, 0x06, 0xdd19);
14035 MP_WritePhyUshort(sc, 0x06, 0x0789);
14036 MP_WritePhyUshort(sc, 0x06, 0x89ef);
14037 MP_WritePhyUshort(sc, 0x06, 0x645e);
14038 MP_WritePhyUshort(sc, 0x06, 0x07ff);
14039 MP_WritePhyUshort(sc, 0x06, 0x0d65);
14040 MP_WritePhyUshort(sc, 0x06, 0x5cf8);
14041 MP_WritePhyUshort(sc, 0x06, 0x001e);
14042 MP_WritePhyUshort(sc, 0x06, 0x46dc);
14043 MP_WritePhyUshort(sc, 0x06, 0x19dd);
14044 MP_WritePhyUshort(sc, 0x06, 0x19b2);
14045 MP_WritePhyUshort(sc, 0x06, 0xe2d4);
14046 MP_WritePhyUshort(sc, 0x06, 0x0001);
14047 MP_WritePhyUshort(sc, 0x06, 0xbf85);
14048 MP_WritePhyUshort(sc, 0x06, 0xa402);
14049 MP_WritePhyUshort(sc, 0x06, 0x3723);
14050 MP_WritePhyUshort(sc, 0x06, 0xae1d);
14051 MP_WritePhyUshort(sc, 0x06, 0xbee0);
14052 MP_WritePhyUshort(sc, 0x06, 0xc4bf);
14053 MP_WritePhyUshort(sc, 0x06, 0x8614);
14054 MP_WritePhyUshort(sc, 0x06, 0xd204);
14055 MP_WritePhyUshort(sc, 0x06, 0xd819);
14056 MP_WritePhyUshort(sc, 0x06, 0xd919);
14057 MP_WritePhyUshort(sc, 0x06, 0x07dc);
14058 MP_WritePhyUshort(sc, 0x06, 0x19dd);
14059 MP_WritePhyUshort(sc, 0x06, 0x1907);
14060 MP_WritePhyUshort(sc, 0x06, 0xb2f4);
14061 MP_WritePhyUshort(sc, 0x06, 0xd400);
14062 MP_WritePhyUshort(sc, 0x06, 0x00bf);
14063 MP_WritePhyUshort(sc, 0x06, 0x85a4);
14064 MP_WritePhyUshort(sc, 0x06, 0x0237);
14065 MP_WritePhyUshort(sc, 0x06, 0x23fe);
14066 MP_WritePhyUshort(sc, 0x06, 0xef96);
14067 MP_WritePhyUshort(sc, 0x06, 0xfec6);
14068 MP_WritePhyUshort(sc, 0x06, 0xfefd);
14069 MP_WritePhyUshort(sc, 0x06, 0xfc05);
14070 MP_WritePhyUshort(sc, 0x06, 0xf9e2);
14071 MP_WritePhyUshort(sc, 0x06, 0xe0ea);
14072 MP_WritePhyUshort(sc, 0x06, 0xe3e0);
14073 MP_WritePhyUshort(sc, 0x06, 0xeb5a);
14074 MP_WritePhyUshort(sc, 0x06, 0x070c);
14075 MP_WritePhyUshort(sc, 0x06, 0x031e);
14076 MP_WritePhyUshort(sc, 0x06, 0x20e6);
14077 MP_WritePhyUshort(sc, 0x06, 0xe0ea);
14078 MP_WritePhyUshort(sc, 0x06, 0xe7e0);
14079 MP_WritePhyUshort(sc, 0x06, 0xebe0);
14080 MP_WritePhyUshort(sc, 0x06, 0xe0fc);
14081 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
14082 MP_WritePhyUshort(sc, 0x06, 0xfdfd);
14083 MP_WritePhyUshort(sc, 0x06, 0x04f8);
14084 MP_WritePhyUshort(sc, 0x06, 0xf9e0);
14085 MP_WritePhyUshort(sc, 0x06, 0x8b81);
14086 MP_WritePhyUshort(sc, 0x06, 0xac26);
14087 MP_WritePhyUshort(sc, 0x06, 0x1ae0);
14088 MP_WritePhyUshort(sc, 0x06, 0x8b81);
14089 MP_WritePhyUshort(sc, 0x06, 0xac21);
14090 MP_WritePhyUshort(sc, 0x06, 0x14e0);
14091 MP_WritePhyUshort(sc, 0x06, 0x8b85);
14092 MP_WritePhyUshort(sc, 0x06, 0xac20);
14093 MP_WritePhyUshort(sc, 0x06, 0x0ee0);
14094 MP_WritePhyUshort(sc, 0x06, 0x8b85);
14095 MP_WritePhyUshort(sc, 0x06, 0xac23);
14096 MP_WritePhyUshort(sc, 0x06, 0x08e0);
14097 MP_WritePhyUshort(sc, 0x06, 0x8b87);
14098 MP_WritePhyUshort(sc, 0x06, 0xac24);
14099 MP_WritePhyUshort(sc, 0x06, 0x02ae);
14100 MP_WritePhyUshort(sc, 0x06, 0x3802);
14101 MP_WritePhyUshort(sc, 0x06, 0x1ab5);
14102 MP_WritePhyUshort(sc, 0x06, 0xeee4);
14103 MP_WritePhyUshort(sc, 0x06, 0x1c04);
14104 MP_WritePhyUshort(sc, 0x06, 0xeee4);
14105 MP_WritePhyUshort(sc, 0x06, 0x1d04);
14106 MP_WritePhyUshort(sc, 0x06, 0xe2e0);
14107 MP_WritePhyUshort(sc, 0x06, 0x7ce3);
14108 MP_WritePhyUshort(sc, 0x06, 0xe07d);
14109 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
14110 MP_WritePhyUshort(sc, 0x06, 0x38e1);
14111 MP_WritePhyUshort(sc, 0x06, 0xe039);
14112 MP_WritePhyUshort(sc, 0x06, 0xad2e);
14113 MP_WritePhyUshort(sc, 0x06, 0x1bad);
14114 MP_WritePhyUshort(sc, 0x06, 0x390d);
14115 MP_WritePhyUshort(sc, 0x06, 0xd101);
14116 MP_WritePhyUshort(sc, 0x06, 0xbf21);
14117 MP_WritePhyUshort(sc, 0x06, 0xd502);
14118 MP_WritePhyUshort(sc, 0x06, 0x3723);
14119 MP_WritePhyUshort(sc, 0x06, 0x0282);
14120 MP_WritePhyUshort(sc, 0x06, 0xd8ae);
14121 MP_WritePhyUshort(sc, 0x06, 0x0bac);
14122 MP_WritePhyUshort(sc, 0x06, 0x3802);
14123 MP_WritePhyUshort(sc, 0x06, 0xae06);
14124 MP_WritePhyUshort(sc, 0x06, 0x0283);
14125 MP_WritePhyUshort(sc, 0x06, 0x1802);
14126 MP_WritePhyUshort(sc, 0x06, 0x8360);
14127 MP_WritePhyUshort(sc, 0x06, 0x021a);
14128 MP_WritePhyUshort(sc, 0x06, 0xc6fd);
14129 MP_WritePhyUshort(sc, 0x06, 0xfc04);
14130 MP_WritePhyUshort(sc, 0x06, 0xf8e1);
14131 MP_WritePhyUshort(sc, 0x06, 0x8af4);
14132 MP_WritePhyUshort(sc, 0x06, 0xe08b);
14133 MP_WritePhyUshort(sc, 0x06, 0x81ad);
14134 MP_WritePhyUshort(sc, 0x06, 0x2605);
14135 MP_WritePhyUshort(sc, 0x06, 0x0222);
14136 MP_WritePhyUshort(sc, 0x06, 0xa4f7);
14137 MP_WritePhyUshort(sc, 0x06, 0x28e0);
14138 MP_WritePhyUshort(sc, 0x06, 0x8b81);
14139 MP_WritePhyUshort(sc, 0x06, 0xad21);
14140 MP_WritePhyUshort(sc, 0x06, 0x0502);
14141 MP_WritePhyUshort(sc, 0x06, 0x23a9);
14142 MP_WritePhyUshort(sc, 0x06, 0xf729);
14143 MP_WritePhyUshort(sc, 0x06, 0xe08b);
14144 MP_WritePhyUshort(sc, 0x06, 0x85ad);
14145 MP_WritePhyUshort(sc, 0x06, 0x2005);
14146 MP_WritePhyUshort(sc, 0x06, 0x0214);
14147 MP_WritePhyUshort(sc, 0x06, 0xabf7);
14148 MP_WritePhyUshort(sc, 0x06, 0x2ae0);
14149 MP_WritePhyUshort(sc, 0x06, 0x8b85);
14150 MP_WritePhyUshort(sc, 0x06, 0xad23);
14151 MP_WritePhyUshort(sc, 0x06, 0x0502);
14152 MP_WritePhyUshort(sc, 0x06, 0x12e7);
14153 MP_WritePhyUshort(sc, 0x06, 0xf72b);
14154 MP_WritePhyUshort(sc, 0x06, 0xe08b);
14155 MP_WritePhyUshort(sc, 0x06, 0x87ad);
14156 MP_WritePhyUshort(sc, 0x06, 0x2405);
14157 MP_WritePhyUshort(sc, 0x06, 0x0283);
14158 MP_WritePhyUshort(sc, 0x06, 0xbcf7);
14159 MP_WritePhyUshort(sc, 0x06, 0x2ce5);
14160 MP_WritePhyUshort(sc, 0x06, 0x8af4);
14161 MP_WritePhyUshort(sc, 0x06, 0xfc04);
14162 MP_WritePhyUshort(sc, 0x06, 0xf8e0);
14163 MP_WritePhyUshort(sc, 0x06, 0x8b81);
14164 MP_WritePhyUshort(sc, 0x06, 0xad26);
14165 MP_WritePhyUshort(sc, 0x06, 0x0302);
14166 MP_WritePhyUshort(sc, 0x06, 0x21e5);
14167 MP_WritePhyUshort(sc, 0x06, 0xe08b);
14168 MP_WritePhyUshort(sc, 0x06, 0x81ad);
14169 MP_WritePhyUshort(sc, 0x06, 0x2109);
14170 MP_WritePhyUshort(sc, 0x06, 0xe08a);
14171 MP_WritePhyUshort(sc, 0x06, 0xf4ac);
14172 MP_WritePhyUshort(sc, 0x06, 0x2003);
14173 MP_WritePhyUshort(sc, 0x06, 0x0223);
14174 MP_WritePhyUshort(sc, 0x06, 0x98e0);
14175 MP_WritePhyUshort(sc, 0x06, 0x8b85);
14176 MP_WritePhyUshort(sc, 0x06, 0xad20);
14177 MP_WritePhyUshort(sc, 0x06, 0x09e0);
14178 MP_WritePhyUshort(sc, 0x06, 0x8af4);
14179 MP_WritePhyUshort(sc, 0x06, 0xac21);
14180 MP_WritePhyUshort(sc, 0x06, 0x0302);
14181 MP_WritePhyUshort(sc, 0x06, 0x13fb);
14182 MP_WritePhyUshort(sc, 0x06, 0xe08b);
14183 MP_WritePhyUshort(sc, 0x06, 0x85ad);
14184 MP_WritePhyUshort(sc, 0x06, 0x2309);
14185 MP_WritePhyUshort(sc, 0x06, 0xe08a);
14186 MP_WritePhyUshort(sc, 0x06, 0xf4ac);
14187 MP_WritePhyUshort(sc, 0x06, 0x2203);
14188 MP_WritePhyUshort(sc, 0x06, 0x0212);
14189 MP_WritePhyUshort(sc, 0x06, 0xfae0);
14190 MP_WritePhyUshort(sc, 0x06, 0x8b87);
14191 MP_WritePhyUshort(sc, 0x06, 0xad24);
14192 MP_WritePhyUshort(sc, 0x06, 0x09e0);
14193 MP_WritePhyUshort(sc, 0x06, 0x8af4);
14194 MP_WritePhyUshort(sc, 0x06, 0xac23);
14195 MP_WritePhyUshort(sc, 0x06, 0x0302);
14196 MP_WritePhyUshort(sc, 0x06, 0x83c1);
14197 MP_WritePhyUshort(sc, 0x06, 0xfc04);
14198 MP_WritePhyUshort(sc, 0x06, 0xf8e1);
14199 MP_WritePhyUshort(sc, 0x06, 0x8af4);
14200 MP_WritePhyUshort(sc, 0x06, 0xe08b);
14201 MP_WritePhyUshort(sc, 0x06, 0x81ad);
14202 MP_WritePhyUshort(sc, 0x06, 0x2608);
14203 MP_WritePhyUshort(sc, 0x06, 0xe083);
14204 MP_WritePhyUshort(sc, 0x06, 0xd2ad);
14205 MP_WritePhyUshort(sc, 0x06, 0x2502);
14206 MP_WritePhyUshort(sc, 0x06, 0xf628);
14207 MP_WritePhyUshort(sc, 0x06, 0xe08b);
14208 MP_WritePhyUshort(sc, 0x06, 0x81ad);
14209 MP_WritePhyUshort(sc, 0x06, 0x210a);
14210 MP_WritePhyUshort(sc, 0x06, 0xe084);
14211 MP_WritePhyUshort(sc, 0x06, 0x0af6);
14212 MP_WritePhyUshort(sc, 0x06, 0x27a0);
14213 MP_WritePhyUshort(sc, 0x06, 0x0502);
14214 MP_WritePhyUshort(sc, 0x06, 0xf629);
14215 MP_WritePhyUshort(sc, 0x06, 0xe08b);
14216 MP_WritePhyUshort(sc, 0x06, 0x85ad);
14217 MP_WritePhyUshort(sc, 0x06, 0x2008);
14218 MP_WritePhyUshort(sc, 0x06, 0xe08a);
14219 MP_WritePhyUshort(sc, 0x06, 0xe8ad);
14220 MP_WritePhyUshort(sc, 0x06, 0x2102);
14221 MP_WritePhyUshort(sc, 0x06, 0xf62a);
14222 MP_WritePhyUshort(sc, 0x06, 0xe08b);
14223 MP_WritePhyUshort(sc, 0x06, 0x85ad);
14224 MP_WritePhyUshort(sc, 0x06, 0x2308);
14225 MP_WritePhyUshort(sc, 0x06, 0xe08b);
14226 MP_WritePhyUshort(sc, 0x06, 0x20a0);
14227 MP_WritePhyUshort(sc, 0x06, 0x0302);
14228 MP_WritePhyUshort(sc, 0x06, 0xf62b);
14229 MP_WritePhyUshort(sc, 0x06, 0xe08b);
14230 MP_WritePhyUshort(sc, 0x06, 0x87ad);
14231 MP_WritePhyUshort(sc, 0x06, 0x2408);
14232 MP_WritePhyUshort(sc, 0x06, 0xe086);
14233 MP_WritePhyUshort(sc, 0x06, 0x02a0);
14234 MP_WritePhyUshort(sc, 0x06, 0x0302);
14235 MP_WritePhyUshort(sc, 0x06, 0xf62c);
14236 MP_WritePhyUshort(sc, 0x06, 0xe58a);
14237 MP_WritePhyUshort(sc, 0x06, 0xf4a1);
14238 MP_WritePhyUshort(sc, 0x06, 0x0008);
14239 MP_WritePhyUshort(sc, 0x06, 0xd100);
14240 MP_WritePhyUshort(sc, 0x06, 0xbf21);
14241 MP_WritePhyUshort(sc, 0x06, 0xd502);
14242 MP_WritePhyUshort(sc, 0x06, 0x3723);
14243 MP_WritePhyUshort(sc, 0x06, 0xfc04);
14244 MP_WritePhyUshort(sc, 0x06, 0xee86);
14245 MP_WritePhyUshort(sc, 0x06, 0x0200);
14246 MP_WritePhyUshort(sc, 0x06, 0x04f8);
14247 MP_WritePhyUshort(sc, 0x06, 0xe08b);
14248 MP_WritePhyUshort(sc, 0x06, 0x87ad);
14249 MP_WritePhyUshort(sc, 0x06, 0x241e);
14250 MP_WritePhyUshort(sc, 0x06, 0xe086);
14251 MP_WritePhyUshort(sc, 0x06, 0x02a0);
14252 MP_WritePhyUshort(sc, 0x06, 0x0005);
14253 MP_WritePhyUshort(sc, 0x06, 0x0283);
14254 MP_WritePhyUshort(sc, 0x06, 0xe8ae);
14255 MP_WritePhyUshort(sc, 0x06, 0xf5a0);
14256 MP_WritePhyUshort(sc, 0x06, 0x0105);
14257 MP_WritePhyUshort(sc, 0x06, 0x0283);
14258 MP_WritePhyUshort(sc, 0x06, 0xf8ae);
14259 MP_WritePhyUshort(sc, 0x06, 0x0ba0);
14260 MP_WritePhyUshort(sc, 0x06, 0x0205);
14261 MP_WritePhyUshort(sc, 0x06, 0x0284);
14262 MP_WritePhyUshort(sc, 0x06, 0x14ae);
14263 MP_WritePhyUshort(sc, 0x06, 0x03a0);
14264 MP_WritePhyUshort(sc, 0x06, 0x0300);
14265 MP_WritePhyUshort(sc, 0x06, 0xfc04);
14266 MP_WritePhyUshort(sc, 0x06, 0xf8fa);
14267 MP_WritePhyUshort(sc, 0x06, 0xef69);
14268 MP_WritePhyUshort(sc, 0x06, 0x0284);
14269 MP_WritePhyUshort(sc, 0x06, 0x2bee);
14270 MP_WritePhyUshort(sc, 0x06, 0x8602);
14271 MP_WritePhyUshort(sc, 0x06, 0x01ef);
14272 MP_WritePhyUshort(sc, 0x06, 0x96fe);
14273 MP_WritePhyUshort(sc, 0x06, 0xfc04);
14274 MP_WritePhyUshort(sc, 0x06, 0xf8ee);
14275 MP_WritePhyUshort(sc, 0x06, 0x8609);
14276 MP_WritePhyUshort(sc, 0x06, 0x0002);
14277 MP_WritePhyUshort(sc, 0x06, 0x8461);
14278 MP_WritePhyUshort(sc, 0x06, 0xfc04);
14279 MP_WritePhyUshort(sc, 0x06, 0xae10);
14280 MP_WritePhyUshort(sc, 0x06, 0x0000);
14281 MP_WritePhyUshort(sc, 0x06, 0x0000);
14282 MP_WritePhyUshort(sc, 0x06, 0x0000);
14283 MP_WritePhyUshort(sc, 0x06, 0x0000);
14284 MP_WritePhyUshort(sc, 0x06, 0x0000);
14285 MP_WritePhyUshort(sc, 0x06, 0x0000);
14286 MP_WritePhyUshort(sc, 0x06, 0x0000);
14287 MP_WritePhyUshort(sc, 0x06, 0x0000);
14288 MP_WritePhyUshort(sc, 0x06, 0xf8e0);
14289 MP_WritePhyUshort(sc, 0x06, 0x8608);
14290 MP_WritePhyUshort(sc, 0x06, 0xe186);
14291 MP_WritePhyUshort(sc, 0x06, 0x091f);
14292 MP_WritePhyUshort(sc, 0x06, 0x019e);
14293 MP_WritePhyUshort(sc, 0x06, 0x0611);
14294 MP_WritePhyUshort(sc, 0x06, 0xe586);
14295 MP_WritePhyUshort(sc, 0x06, 0x09ae);
14296 MP_WritePhyUshort(sc, 0x06, 0x04ee);
14297 MP_WritePhyUshort(sc, 0x06, 0x8602);
14298 MP_WritePhyUshort(sc, 0x06, 0x01fc);
14299 MP_WritePhyUshort(sc, 0x06, 0x04f8);
14300 MP_WritePhyUshort(sc, 0x06, 0xf9fa);
14301 MP_WritePhyUshort(sc, 0x06, 0xef69);
14302 MP_WritePhyUshort(sc, 0x06, 0xfbbf);
14303 MP_WritePhyUshort(sc, 0x06, 0x8604);
14304 MP_WritePhyUshort(sc, 0x06, 0xef79);
14305 MP_WritePhyUshort(sc, 0x06, 0xd200);
14306 MP_WritePhyUshort(sc, 0x06, 0xd400);
14307 MP_WritePhyUshort(sc, 0x06, 0x221e);
14308 MP_WritePhyUshort(sc, 0x06, 0x02bf);
14309 MP_WritePhyUshort(sc, 0x06, 0x2fec);
14310 MP_WritePhyUshort(sc, 0x06, 0x0237);
14311 MP_WritePhyUshort(sc, 0x06, 0x23bf);
14312 MP_WritePhyUshort(sc, 0x06, 0x13f2);
14313 MP_WritePhyUshort(sc, 0x06, 0x0236);
14314 MP_WritePhyUshort(sc, 0x06, 0xf60d);
14315 MP_WritePhyUshort(sc, 0x06, 0x4559);
14316 MP_WritePhyUshort(sc, 0x06, 0x1fef);
14317 MP_WritePhyUshort(sc, 0x06, 0x97dd);
14318 MP_WritePhyUshort(sc, 0x06, 0xd308);
14319 MP_WritePhyUshort(sc, 0x06, 0x1a93);
14320 MP_WritePhyUshort(sc, 0x06, 0xdd12);
14321 MP_WritePhyUshort(sc, 0x06, 0x17a2);
14322 MP_WritePhyUshort(sc, 0x06, 0x04de);
14323 MP_WritePhyUshort(sc, 0x06, 0xffef);
14324 MP_WritePhyUshort(sc, 0x06, 0x96fe);
14325 MP_WritePhyUshort(sc, 0x06, 0xfdfc);
14326 MP_WritePhyUshort(sc, 0x06, 0x04f8);
14327 MP_WritePhyUshort(sc, 0x06, 0xf9fa);
14328 MP_WritePhyUshort(sc, 0x06, 0xef69);
14329 MP_WritePhyUshort(sc, 0x06, 0xfbee);
14330 MP_WritePhyUshort(sc, 0x06, 0x8602);
14331 MP_WritePhyUshort(sc, 0x06, 0x03d5);
14332 MP_WritePhyUshort(sc, 0x06, 0x0080);
14333 MP_WritePhyUshort(sc, 0x06, 0xbf86);
14334 MP_WritePhyUshort(sc, 0x06, 0x04ef);
14335 MP_WritePhyUshort(sc, 0x06, 0x79ef);
14336 MP_WritePhyUshort(sc, 0x06, 0x45bf);
14337 MP_WritePhyUshort(sc, 0x06, 0x2fec);
14338 MP_WritePhyUshort(sc, 0x06, 0x0237);
14339 MP_WritePhyUshort(sc, 0x06, 0x23bf);
14340 MP_WritePhyUshort(sc, 0x06, 0x13f2);
14341 MP_WritePhyUshort(sc, 0x06, 0x0236);
14342 MP_WritePhyUshort(sc, 0x06, 0xf6ad);
14343 MP_WritePhyUshort(sc, 0x06, 0x2702);
14344 MP_WritePhyUshort(sc, 0x06, 0x78ff);
14345 MP_WritePhyUshort(sc, 0x06, 0xe186);
14346 MP_WritePhyUshort(sc, 0x06, 0x0a1b);
14347 MP_WritePhyUshort(sc, 0x06, 0x01aa);
14348 MP_WritePhyUshort(sc, 0x06, 0x2eef);
14349 MP_WritePhyUshort(sc, 0x06, 0x97d9);
14350 MP_WritePhyUshort(sc, 0x06, 0x7900);
14351 MP_WritePhyUshort(sc, 0x06, 0x9e2b);
14352 MP_WritePhyUshort(sc, 0x06, 0x81dd);
14353 MP_WritePhyUshort(sc, 0x06, 0xbf85);
14354 MP_WritePhyUshort(sc, 0x06, 0xad02);
14355 MP_WritePhyUshort(sc, 0x06, 0x3723);
14356 MP_WritePhyUshort(sc, 0x06, 0xd101);
14357 MP_WritePhyUshort(sc, 0x06, 0xef02);
14358 MP_WritePhyUshort(sc, 0x06, 0x100c);
14359 MP_WritePhyUshort(sc, 0x06, 0x11b0);
14360 MP_WritePhyUshort(sc, 0x06, 0xfc0d);
14361 MP_WritePhyUshort(sc, 0x06, 0x11bf);
14362 MP_WritePhyUshort(sc, 0x06, 0x85aa);
14363 MP_WritePhyUshort(sc, 0x06, 0x0237);
14364 MP_WritePhyUshort(sc, 0x06, 0x23d1);
14365 MP_WritePhyUshort(sc, 0x06, 0x00bf);
14366 MP_WritePhyUshort(sc, 0x06, 0x85aa);
14367 MP_WritePhyUshort(sc, 0x06, 0x0237);
14368 MP_WritePhyUshort(sc, 0x06, 0x23ee);
14369 MP_WritePhyUshort(sc, 0x06, 0x8602);
14370 MP_WritePhyUshort(sc, 0x06, 0x02ae);
14371 MP_WritePhyUshort(sc, 0x06, 0x0413);
14372 MP_WritePhyUshort(sc, 0x06, 0xa38b);
14373 MP_WritePhyUshort(sc, 0x06, 0xb4d3);
14374 MP_WritePhyUshort(sc, 0x06, 0x8012);
14375 MP_WritePhyUshort(sc, 0x06, 0x17a2);
14376 MP_WritePhyUshort(sc, 0x06, 0x04ad);
14377 MP_WritePhyUshort(sc, 0x06, 0xffef);
14378 MP_WritePhyUshort(sc, 0x06, 0x96fe);
14379 MP_WritePhyUshort(sc, 0x06, 0xfdfc);
14380 MP_WritePhyUshort(sc, 0x06, 0x04f8);
14381 MP_WritePhyUshort(sc, 0x06, 0xf9e0);
14382 MP_WritePhyUshort(sc, 0x06, 0x8b85);
14383 MP_WritePhyUshort(sc, 0x06, 0xad25);
14384 MP_WritePhyUshort(sc, 0x06, 0x48e0);
14385 MP_WritePhyUshort(sc, 0x06, 0x8a96);
14386 MP_WritePhyUshort(sc, 0x06, 0xe18a);
14387 MP_WritePhyUshort(sc, 0x06, 0x977c);
14388 MP_WritePhyUshort(sc, 0x06, 0x0000);
14389 MP_WritePhyUshort(sc, 0x06, 0x9e35);
14390 MP_WritePhyUshort(sc, 0x06, 0xee8a);
14391 MP_WritePhyUshort(sc, 0x06, 0x9600);
14392 MP_WritePhyUshort(sc, 0x06, 0xee8a);
14393 MP_WritePhyUshort(sc, 0x06, 0x9700);
14394 MP_WritePhyUshort(sc, 0x06, 0xe08a);
14395 MP_WritePhyUshort(sc, 0x06, 0xbee1);
14396 MP_WritePhyUshort(sc, 0x06, 0x8abf);
14397 MP_WritePhyUshort(sc, 0x06, 0xe286);
14398 MP_WritePhyUshort(sc, 0x06, 0x10e3);
14399 MP_WritePhyUshort(sc, 0x06, 0x8611);
14400 MP_WritePhyUshort(sc, 0x06, 0x0236);
14401 MP_WritePhyUshort(sc, 0x06, 0x1aad);
14402 MP_WritePhyUshort(sc, 0x06, 0x2012);
14403 MP_WritePhyUshort(sc, 0x06, 0xee8a);
14404 MP_WritePhyUshort(sc, 0x06, 0x9603);
14405 MP_WritePhyUshort(sc, 0x06, 0xee8a);
14406 MP_WritePhyUshort(sc, 0x06, 0x97b7);
14407 MP_WritePhyUshort(sc, 0x06, 0xee86);
14408 MP_WritePhyUshort(sc, 0x06, 0x1000);
14409 MP_WritePhyUshort(sc, 0x06, 0xee86);
14410 MP_WritePhyUshort(sc, 0x06, 0x1100);
14411 MP_WritePhyUshort(sc, 0x06, 0xae11);
14412 MP_WritePhyUshort(sc, 0x06, 0x15e6);
14413 MP_WritePhyUshort(sc, 0x06, 0x8610);
14414 MP_WritePhyUshort(sc, 0x06, 0xe786);
14415 MP_WritePhyUshort(sc, 0x06, 0x11ae);
14416 MP_WritePhyUshort(sc, 0x06, 0x08ee);
14417 MP_WritePhyUshort(sc, 0x06, 0x8610);
14418 MP_WritePhyUshort(sc, 0x06, 0x00ee);
14419 MP_WritePhyUshort(sc, 0x06, 0x8611);
14420 MP_WritePhyUshort(sc, 0x06, 0x00fd);
14421 MP_WritePhyUshort(sc, 0x06, 0xfc04);
14422 MP_WritePhyUshort(sc, 0x06, 0xf8fa);
14423 MP_WritePhyUshort(sc, 0x06, 0xef69);
14424 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
14425 MP_WritePhyUshort(sc, 0x06, 0x00e1);
14426 MP_WritePhyUshort(sc, 0x06, 0xe001);
14427 MP_WritePhyUshort(sc, 0x06, 0xad27);
14428 MP_WritePhyUshort(sc, 0x06, 0x32e0);
14429 MP_WritePhyUshort(sc, 0x06, 0x8b40);
14430 MP_WritePhyUshort(sc, 0x06, 0xf720);
14431 MP_WritePhyUshort(sc, 0x06, 0xe48b);
14432 MP_WritePhyUshort(sc, 0x06, 0x40bf);
14433 MP_WritePhyUshort(sc, 0x06, 0x31f5);
14434 MP_WritePhyUshort(sc, 0x06, 0x0236);
14435 MP_WritePhyUshort(sc, 0x06, 0xf6ad);
14436 MP_WritePhyUshort(sc, 0x06, 0x2821);
14437 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
14438 MP_WritePhyUshort(sc, 0x06, 0x20e1);
14439 MP_WritePhyUshort(sc, 0x06, 0xe021);
14440 MP_WritePhyUshort(sc, 0x06, 0xad20);
14441 MP_WritePhyUshort(sc, 0x06, 0x18e0);
14442 MP_WritePhyUshort(sc, 0x06, 0x8b40);
14443 MP_WritePhyUshort(sc, 0x06, 0xf620);
14444 MP_WritePhyUshort(sc, 0x06, 0xe48b);
14445 MP_WritePhyUshort(sc, 0x06, 0x40ee);
14446 MP_WritePhyUshort(sc, 0x06, 0x8b3b);
14447 MP_WritePhyUshort(sc, 0x06, 0xffe0);
14448 MP_WritePhyUshort(sc, 0x06, 0x8a8a);
14449 MP_WritePhyUshort(sc, 0x06, 0xe18a);
14450 MP_WritePhyUshort(sc, 0x06, 0x8be4);
14451 MP_WritePhyUshort(sc, 0x06, 0xe000);
14452 MP_WritePhyUshort(sc, 0x06, 0xe5e0);
14453 MP_WritePhyUshort(sc, 0x06, 0x01ef);
14454 MP_WritePhyUshort(sc, 0x06, 0x96fe);
14455 MP_WritePhyUshort(sc, 0x06, 0xfc04);
14456 MP_WritePhyUshort(sc, 0x06, 0xf8fa);
14457 MP_WritePhyUshort(sc, 0x06, 0xef69);
14458 MP_WritePhyUshort(sc, 0x06, 0xe08b);
14459 MP_WritePhyUshort(sc, 0x06, 0x80ad);
14460 MP_WritePhyUshort(sc, 0x06, 0x2722);
14461 MP_WritePhyUshort(sc, 0x06, 0xbf44);
14462 MP_WritePhyUshort(sc, 0x06, 0xfc02);
14463 MP_WritePhyUshort(sc, 0x06, 0x36f6);
14464 MP_WritePhyUshort(sc, 0x06, 0xe08b);
14465 MP_WritePhyUshort(sc, 0x06, 0x441f);
14466 MP_WritePhyUshort(sc, 0x06, 0x019e);
14467 MP_WritePhyUshort(sc, 0x06, 0x15e5);
14468 MP_WritePhyUshort(sc, 0x06, 0x8b44);
14469 MP_WritePhyUshort(sc, 0x06, 0xad29);
14470 MP_WritePhyUshort(sc, 0x06, 0x07ac);
14471 MP_WritePhyUshort(sc, 0x06, 0x2804);
14472 MP_WritePhyUshort(sc, 0x06, 0xd101);
14473 MP_WritePhyUshort(sc, 0x06, 0xae02);
14474 MP_WritePhyUshort(sc, 0x06, 0xd100);
14475 MP_WritePhyUshort(sc, 0x06, 0xbf85);
14476 MP_WritePhyUshort(sc, 0x06, 0xb002);
14477 MP_WritePhyUshort(sc, 0x06, 0x3723);
14478 MP_WritePhyUshort(sc, 0x06, 0xef96);
14479 MP_WritePhyUshort(sc, 0x06, 0xfefc);
14480 MP_WritePhyUshort(sc, 0x06, 0x0400);
14481 MP_WritePhyUshort(sc, 0x06, 0xe140);
14482 MP_WritePhyUshort(sc, 0x06, 0x77e1);
14483 MP_WritePhyUshort(sc, 0x06, 0x40dd);
14484 MP_WritePhyUshort(sc, 0x06, 0xe022);
14485 MP_WritePhyUshort(sc, 0x06, 0x32e1);
14486 MP_WritePhyUshort(sc, 0x06, 0x5074);
14487 MP_WritePhyUshort(sc, 0x06, 0xe144);
14488 MP_WritePhyUshort(sc, 0x06, 0xffe0);
14489 MP_WritePhyUshort(sc, 0x06, 0xdaff);
14490 MP_WritePhyUshort(sc, 0x06, 0xe0c0);
14491 MP_WritePhyUshort(sc, 0x06, 0x52e0);
14492 MP_WritePhyUshort(sc, 0x06, 0xeed9);
14493 MP_WritePhyUshort(sc, 0x06, 0xe04c);
14494 MP_WritePhyUshort(sc, 0x06, 0xbbe0);
14495 MP_WritePhyUshort(sc, 0x06, 0x2a00);
14496 MP_WritePhyUshort(sc, 0x05, 0xe142);
14497 Data = MP_ReadPhyUshort(sc, 0x06);
14498 Data |= BIT_0;
14499 MP_WritePhyUshort(sc, 0x06, Data);
14500 MP_WritePhyUshort(sc, 0x05, 0xe140);
14501 Data = MP_ReadPhyUshort(sc, 0x06);
14502 Data |= BIT_0;
14503 MP_WritePhyUshort(sc, 0x06, Data);
14504 MP_WritePhyUshort(sc, 0x1f, 0x0000);
14505 MP_WritePhyUshort(sc, 0x1f, 0x0005);
14506 for (i = 0; i < 200; i++) {
14507 DELAY(100);
14508 Data = MP_ReadPhyUshort(sc, 0x00);
14509 if (Data & BIT_7)
14510 break;
14511 }
14512 MP_WritePhyUshort(sc, 0x1f, 0x0007);
14513 MP_WritePhyUshort(sc, 0x1e, 0x0042);
14514 MP_WritePhyUshort(sc, 0x18, 0x2300);
14515 MP_WritePhyUshort(sc, 0x1f, 0x0000);
14516 MP_WritePhyUshort(sc, 0x1f, 0x0007);
14517 MP_WritePhyUshort(sc, 0x1e, 0x0023);
14518 Data = MP_ReadPhyUshort(sc, 0x17);
14519 MP_WritePhyUshort(sc, 0x17, Data);
14520
14521 MP_WritePhyUshort(sc, 0x1F, 0x0003);
14522 MP_WritePhyUshort(sc, 0x09, 0xA20F);
14523 MP_WritePhyUshort(sc, 0x1F, 0x0000);
14524 MP_WritePhyUshort(sc, 0x1f, 0x0000);
14525 MP_WritePhyUshort(sc, 0x00, 0x9200);
14526
14527 MP_WritePhyUshort(sc, 0x1F, 0x0005);
14528 MP_WritePhyUshort(sc, 0x05, 0x8B80);
14529 Data = MP_ReadPhyUshort(sc, 0x06);
14530 Data |= BIT_2 | BIT_1;
14531 MP_WritePhyUshort(sc, 0x06, Data);
14532 MP_WritePhyUshort(sc, 0x1f, 0x0000);
14533
14534 MP_WritePhyUshort(sc, 0x1F, 0x0005);
14535 MP_WritePhyUshort(sc, 0x05, 0x8B85);
14536 Data = MP_ReadPhyUshort(sc, 0x06);
14537 Data |= BIT_15;
14538 MP_WritePhyUshort(sc, 0x06, Data);
14539 MP_WritePhyUshort(sc, 0x1f, 0x0000);
14540
14541 MP_WritePhyUshort(sc, 0x1f, 0x0004);
14542 MP_WritePhyUshort(sc, 0x1f, 0x0007);
14543 MP_WritePhyUshort(sc, 0x1e, 0x002D);
14544 Data = MP_ReadPhyUshort(sc, 0x18);
14545 Data |= BIT_4;
14546 MP_WritePhyUshort(sc, 0x18, Data);
14547 MP_WritePhyUshort(sc, 0x1f, 0x0002);
14548 MP_WritePhyUshort(sc, 0x1f, 0x0000);
14549 Data = MP_ReadPhyUshort(sc, 0x14);
14550 Data |= BIT_15;
14551 MP_WritePhyUshort(sc, 0x14, Data);
14552
14553 MP_WritePhyUshort(sc, 0x1F, 0x0005);
14554 MP_WritePhyUshort(sc, 0x05, 0x8B86);
14555 Data = MP_ReadPhyUshort(sc, 0x06);
14556 Data |= BIT_0;
14557 MP_WritePhyUshort(sc, 0x06, Data);
14558 MP_WritePhyUshort(sc, 0x1f, 0x0000);
14559
14560 MP_WritePhyUshort(sc, 0x1F, 0x0004);
14561 MP_WritePhyUshort(sc, 0x1F, 0x0007);
14562 MP_WritePhyUshort(sc, 0x1E, 0x00AC);
14563 MP_WritePhyUshort(sc, 0x18, 0x0006);
14564 MP_WritePhyUshort(sc, 0x1F, 0x0002);
14565 MP_WritePhyUshort(sc, 0x1F, 0x0000);
14566
14567 MP_WritePhyUshort(sc, 0x1F, 0x0003);
14568 MP_WritePhyUshort(sc, 0x09, 0xA20F);
14569 MP_WritePhyUshort(sc, 0x1F, 0x0000);
14570
14571 MP_WritePhyUshort(sc, 0x1F, 0x0005);
14572 MP_WritePhyUshort(sc, 0x05, 0x8B85);
14573 Data = MP_ReadPhyUshort(sc, 0x06);
14574 Data |= BIT_14;
14575 MP_WritePhyUshort(sc, 0x06, Data);
14576 MP_WritePhyUshort(sc, 0x1f, 0x0000);
14577
14578 MP_WritePhyUshort(sc, 0x1F, 0x0005);
14579 MP_WritePhyUshort(sc, 0x05, 0x8B54);
14580 Data = MP_ReadPhyUshort(sc, 0x06);
14581 Data &= ~BIT_11;
14582 MP_WritePhyUshort(sc, 0x06, Data);
14583 MP_WritePhyUshort(sc, 0x05, 0x8B5D);
14584 Data = MP_ReadPhyUshort(sc, 0x06);
14585 Data &= ~BIT_11;
14586 MP_WritePhyUshort(sc, 0x06, Data);
14587 MP_WritePhyUshort(sc, 0x05, 0x8A7C);
14588 Data = MP_ReadPhyUshort(sc, 0x06);
14589 Data &= ~BIT_8;
14590 MP_WritePhyUshort(sc, 0x06, Data);
14591 MP_WritePhyUshort(sc, 0x05, 0x8A7F);
14592 Data = MP_ReadPhyUshort(sc, 0x06);
14593 Data |= BIT_8;
14594 MP_WritePhyUshort(sc, 0x06, Data);
14595 MP_WritePhyUshort(sc, 0x05, 0x8A82);
14596 Data = MP_ReadPhyUshort(sc, 0x06);
14597 Data &= ~BIT_8;
14598 MP_WritePhyUshort(sc, 0x06, Data);
14599 MP_WritePhyUshort(sc, 0x05, 0x8A85);
14600 Data = MP_ReadPhyUshort(sc, 0x06);
14601 Data &= ~BIT_8;
14602 MP_WritePhyUshort(sc, 0x06, Data);
14603 MP_WritePhyUshort(sc, 0x05, 0x8A88);
14604 Data = MP_ReadPhyUshort(sc, 0x06);
14605 Data &= ~BIT_8;
14606 MP_WritePhyUshort(sc, 0x06, Data);
14607 MP_WritePhyUshort(sc, 0x1F, 0x0000);
14608
14609 MP_WritePhyUshort(sc, 0x1f, 0x0003);
14610 Data = MP_ReadPhyUshort(sc, 0x19);
14611 Data &= ~BIT_0;
14612 MP_WritePhyUshort(sc, 0x19, Data);
14613 Data = MP_ReadPhyUshort(sc, 0x10);
14614 Data &= ~BIT_10;
14615 MP_WritePhyUshort(sc, 0x10, Data);
14616 MP_WritePhyUshort(sc, 0x1f, 0x0000);
14617 } else if (sc->re_type == MACFG_41) {
14618 MP_WritePhyUshort(sc, 0x1F, 0x0000);
14619 MP_WritePhyUshort(sc, 0x11, MP_ReadPhyUshort(sc, 0x11) | 0x1000);
14620 MP_WritePhyUshort(sc, 0x1F, 0x0002);
14621 MP_WritePhyUshort(sc, 0x0F, MP_ReadPhyUshort(sc, 0x0F) | 0x0003);
14622 MP_WritePhyUshort(sc, 0x1F, 0x0000);
14623
14624 for (Data_u32=0x800E0068; Data_u32<0x800E006D; Data_u32++) {
14625 CSR_WRITE_4(sc, 0xF8, Data_u32);
14626 for (i=0; i<10; i++) {
14627 DELAY(400);
14628 if ((CSR_READ_4(sc, 0xF8)&0x80000000)==0)
14629 break;
14630 }
14631 }
14632 } else if (sc->re_type == MACFG_42 || sc->re_type == MACFG_43) {
14633 Data_u32 = re_eri_read(sc, 0x1D0, 4, ERIAR_ExGMAC);
14634 Data_u32 &= 0xFFFF0000;
14635 re_eri_write(sc, 0x1D0, 4, Data_u32, ERIAR_ExGMAC);
14636
14637 MP_WritePhyUshort(sc, 0x1F, 0x0000);
14638 MP_WritePhyUshort(sc, 0x18, 0x0310);
14639 MP_WritePhyUshort(sc, 0x1F, 0x0000);
14640
14641 MP_WritePhyUshort(sc, 0x1f, 0x0004);
14642 MP_WritePhyUshort(sc, 0x1f, 0x0004);
14643 MP_WritePhyUshort(sc, 0x19, 0x7070);
14644 MP_WritePhyUshort(sc, 0x1c, 0x0600);
14645 MP_WritePhyUshort(sc, 0x1d, 0x9700);
14646 MP_WritePhyUshort(sc, 0x1d, 0x7d00);
14647 MP_WritePhyUshort(sc, 0x1d, 0x6900);
14648 MP_WritePhyUshort(sc, 0x1d, 0x7d00);
14649 MP_WritePhyUshort(sc, 0x1d, 0x6800);
14650 MP_WritePhyUshort(sc, 0x1d, 0x4899);
14651 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
14652 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
14653 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
14654 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
14655 MP_WritePhyUshort(sc, 0x1d, 0x8000);
14656 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
14657 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
14658 MP_WritePhyUshort(sc, 0x1d, 0x4007);
14659 MP_WritePhyUshort(sc, 0x1d, 0x4400);
14660 MP_WritePhyUshort(sc, 0x1d, 0x4800);
14661 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
14662 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
14663 MP_WritePhyUshort(sc, 0x1d, 0x5310);
14664 MP_WritePhyUshort(sc, 0x1d, 0x6000);
14665 MP_WritePhyUshort(sc, 0x1d, 0x6800);
14666 MP_WritePhyUshort(sc, 0x1d, 0x6736);
14667 MP_WritePhyUshort(sc, 0x1d, 0x0000);
14668 MP_WritePhyUshort(sc, 0x1d, 0x0000);
14669 MP_WritePhyUshort(sc, 0x1d, 0x571f);
14670 MP_WritePhyUshort(sc, 0x1d, 0x5ffb);
14671 MP_WritePhyUshort(sc, 0x1d, 0xaa03);
14672 MP_WritePhyUshort(sc, 0x1d, 0x5b58);
14673 MP_WritePhyUshort(sc, 0x1d, 0x301e);
14674 MP_WritePhyUshort(sc, 0x1d, 0x5b64);
14675 MP_WritePhyUshort(sc, 0x1d, 0xa6fc);
14676 MP_WritePhyUshort(sc, 0x1d, 0xdcdb);
14677 MP_WritePhyUshort(sc, 0x1d, 0x0014);
14678 MP_WritePhyUshort(sc, 0x1d, 0xd9a9);
14679 MP_WritePhyUshort(sc, 0x1d, 0x0013);
14680 MP_WritePhyUshort(sc, 0x1d, 0xd16b);
14681 MP_WritePhyUshort(sc, 0x1d, 0x0011);
14682 MP_WritePhyUshort(sc, 0x1d, 0xb40e);
14683 MP_WritePhyUshort(sc, 0x1d, 0xd06b);
14684 MP_WritePhyUshort(sc, 0x1d, 0x000c);
14685 MP_WritePhyUshort(sc, 0x1d, 0xb206);
14686 MP_WritePhyUshort(sc, 0x1d, 0x7c01);
14687 MP_WritePhyUshort(sc, 0x1d, 0x5800);
14688 MP_WritePhyUshort(sc, 0x1d, 0x7c04);
14689 MP_WritePhyUshort(sc, 0x1d, 0x5c00);
14690 MP_WritePhyUshort(sc, 0x1d, 0x301a);
14691 MP_WritePhyUshort(sc, 0x1d, 0x7c01);
14692 MP_WritePhyUshort(sc, 0x1d, 0x5801);
14693 MP_WritePhyUshort(sc, 0x1d, 0x7c04);
14694 MP_WritePhyUshort(sc, 0x1d, 0x5c04);
14695 MP_WritePhyUshort(sc, 0x1d, 0x301e);
14696 MP_WritePhyUshort(sc, 0x1d, 0x314d);
14697 MP_WritePhyUshort(sc, 0x1d, 0x31f0);
14698 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
14699 MP_WritePhyUshort(sc, 0x1d, 0x4c20);
14700 MP_WritePhyUshort(sc, 0x1d, 0x6004);
14701 MP_WritePhyUshort(sc, 0x1d, 0x5310);
14702 MP_WritePhyUshort(sc, 0x1d, 0x4833);
14703 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
14704 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
14705 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
14706 MP_WritePhyUshort(sc, 0x1d, 0x4c08);
14707 MP_WritePhyUshort(sc, 0x1d, 0x8300);
14708 MP_WritePhyUshort(sc, 0x1d, 0x6800);
14709 MP_WritePhyUshort(sc, 0x1d, 0x6600);
14710 MP_WritePhyUshort(sc, 0x1d, 0x0000);
14711 MP_WritePhyUshort(sc, 0x1d, 0x0000);
14712 MP_WritePhyUshort(sc, 0x1d, 0xb90c);
14713 MP_WritePhyUshort(sc, 0x1d, 0x30d3);
14714 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
14715 MP_WritePhyUshort(sc, 0x1d, 0x4de0);
14716 MP_WritePhyUshort(sc, 0x1d, 0x7c04);
14717 MP_WritePhyUshort(sc, 0x1d, 0x6000);
14718 MP_WritePhyUshort(sc, 0x1d, 0x6800);
14719 MP_WritePhyUshort(sc, 0x1d, 0x6736);
14720 MP_WritePhyUshort(sc, 0x1d, 0x0000);
14721 MP_WritePhyUshort(sc, 0x1d, 0x0000);
14722 MP_WritePhyUshort(sc, 0x1d, 0x5310);
14723 MP_WritePhyUshort(sc, 0x1d, 0x300b);
14724 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
14725 MP_WritePhyUshort(sc, 0x1d, 0x4c60);
14726 MP_WritePhyUshort(sc, 0x1d, 0x6803);
14727 MP_WritePhyUshort(sc, 0x1d, 0x6520);
14728 MP_WritePhyUshort(sc, 0x1d, 0x0000);
14729 MP_WritePhyUshort(sc, 0x1d, 0x0000);
14730 MP_WritePhyUshort(sc, 0x1d, 0xaf03);
14731 MP_WritePhyUshort(sc, 0x1d, 0x6015);
14732 MP_WritePhyUshort(sc, 0x1d, 0x3059);
14733 MP_WritePhyUshort(sc, 0x1d, 0x6017);
14734 MP_WritePhyUshort(sc, 0x1d, 0x57e0);
14735 MP_WritePhyUshort(sc, 0x1d, 0x580c);
14736 MP_WritePhyUshort(sc, 0x1d, 0x588c);
14737 MP_WritePhyUshort(sc, 0x1d, 0x7ffc);
14738 MP_WritePhyUshort(sc, 0x1d, 0x5fa3);
14739 MP_WritePhyUshort(sc, 0x1d, 0x4827);
14740 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
14741 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
14742 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
14743 MP_WritePhyUshort(sc, 0x1d, 0x4c10);
14744 MP_WritePhyUshort(sc, 0x1d, 0x8400);
14745 MP_WritePhyUshort(sc, 0x1d, 0x7c30);
14746 MP_WritePhyUshort(sc, 0x1d, 0x6020);
14747 MP_WritePhyUshort(sc, 0x1d, 0x48bf);
14748 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
14749 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
14750 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
14751 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
14752 MP_WritePhyUshort(sc, 0x1d, 0xad09);
14753 MP_WritePhyUshort(sc, 0x1d, 0x7c03);
14754 MP_WritePhyUshort(sc, 0x1d, 0x5c03);
14755 MP_WritePhyUshort(sc, 0x1d, 0x0000);
14756 MP_WritePhyUshort(sc, 0x1d, 0x0000);
14757 MP_WritePhyUshort(sc, 0x1d, 0x0000);
14758 MP_WritePhyUshort(sc, 0x1d, 0x0000);
14759 MP_WritePhyUshort(sc, 0x1d, 0x0000);
14760 MP_WritePhyUshort(sc, 0x1d, 0x4400);
14761 MP_WritePhyUshort(sc, 0x1d, 0xad2c);
14762 MP_WritePhyUshort(sc, 0x1d, 0xd6cf);
14763 MP_WritePhyUshort(sc, 0x1d, 0x0002);
14764 MP_WritePhyUshort(sc, 0x1d, 0x80f4);
14765 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
14766 MP_WritePhyUshort(sc, 0x1d, 0x4c80);
14767 MP_WritePhyUshort(sc, 0x1d, 0x7c20);
14768 MP_WritePhyUshort(sc, 0x1d, 0x5c20);
14769 MP_WritePhyUshort(sc, 0x1d, 0x481e);
14770 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
14771 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
14772 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
14773 MP_WritePhyUshort(sc, 0x1d, 0x4c02);
14774 MP_WritePhyUshort(sc, 0x1d, 0xad0a);
14775 MP_WritePhyUshort(sc, 0x1d, 0x7c03);
14776 MP_WritePhyUshort(sc, 0x1d, 0x5c03);
14777 MP_WritePhyUshort(sc, 0x1d, 0x0000);
14778 MP_WritePhyUshort(sc, 0x1d, 0x0000);
14779 MP_WritePhyUshort(sc, 0x1d, 0x0000);
14780 MP_WritePhyUshort(sc, 0x1d, 0x0000);
14781 MP_WritePhyUshort(sc, 0x1d, 0x0000);
14782 MP_WritePhyUshort(sc, 0x1d, 0x4400);
14783 MP_WritePhyUshort(sc, 0x1d, 0x5310);
14784 MP_WritePhyUshort(sc, 0x1d, 0x8d02);
14785 MP_WritePhyUshort(sc, 0x1d, 0x4401);
14786 MP_WritePhyUshort(sc, 0x1d, 0x81f4);
14787 MP_WritePhyUshort(sc, 0x1d, 0x3114);
14788 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
14789 MP_WritePhyUshort(sc, 0x1d, 0x4d00);
14790 MP_WritePhyUshort(sc, 0x1d, 0x4832);
14791 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
14792 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
14793 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
14794 MP_WritePhyUshort(sc, 0x1d, 0x4c10);
14795 MP_WritePhyUshort(sc, 0x1d, 0x7c08);
14796 MP_WritePhyUshort(sc, 0x1d, 0x6000);
14797 MP_WritePhyUshort(sc, 0x1d, 0xa4b7);
14798 MP_WritePhyUshort(sc, 0x1d, 0xd9b3);
14799 MP_WritePhyUshort(sc, 0x1d, 0xfffe);
14800 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
14801 MP_WritePhyUshort(sc, 0x1d, 0x4d20);
14802 MP_WritePhyUshort(sc, 0x1d, 0x7e00);
14803 MP_WritePhyUshort(sc, 0x1d, 0x6200);
14804 MP_WritePhyUshort(sc, 0x1d, 0x3045);
14805 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
14806 MP_WritePhyUshort(sc, 0x1d, 0x4d40);
14807 MP_WritePhyUshort(sc, 0x1d, 0x7c40);
14808 MP_WritePhyUshort(sc, 0x1d, 0x6000);
14809 MP_WritePhyUshort(sc, 0x1d, 0x4401);
14810 MP_WritePhyUshort(sc, 0x1d, 0x5210);
14811 MP_WritePhyUshort(sc, 0x1d, 0x4833);
14812 MP_WritePhyUshort(sc, 0x1d, 0x7c08);
14813 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
14814 MP_WritePhyUshort(sc, 0x1d, 0x7c08);
14815 MP_WritePhyUshort(sc, 0x1d, 0x4c08);
14816 MP_WritePhyUshort(sc, 0x1d, 0x8300);
14817 MP_WritePhyUshort(sc, 0x1d, 0x5f80);
14818 MP_WritePhyUshort(sc, 0x1d, 0x55e0);
14819 MP_WritePhyUshort(sc, 0x1d, 0xc06f);
14820 MP_WritePhyUshort(sc, 0x1d, 0x0005);
14821 MP_WritePhyUshort(sc, 0x1d, 0xd9b3);
14822 MP_WritePhyUshort(sc, 0x1d, 0xfffd);
14823 MP_WritePhyUshort(sc, 0x1d, 0x7c40);
14824 MP_WritePhyUshort(sc, 0x1d, 0x6040);
14825 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
14826 MP_WritePhyUshort(sc, 0x1d, 0x4d60);
14827 MP_WritePhyUshort(sc, 0x1d, 0x57e0);
14828 MP_WritePhyUshort(sc, 0x1d, 0x4814);
14829 MP_WritePhyUshort(sc, 0x1d, 0x7c04);
14830 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
14831 MP_WritePhyUshort(sc, 0x1d, 0x7c04);
14832 MP_WritePhyUshort(sc, 0x1d, 0x4c04);
14833 MP_WritePhyUshort(sc, 0x1d, 0x8200);
14834 MP_WritePhyUshort(sc, 0x1d, 0x7c03);
14835 MP_WritePhyUshort(sc, 0x1d, 0x5c03);
14836 MP_WritePhyUshort(sc, 0x1d, 0x0000);
14837 MP_WritePhyUshort(sc, 0x1d, 0x0000);
14838 MP_WritePhyUshort(sc, 0x1d, 0x0000);
14839 MP_WritePhyUshort(sc, 0x1d, 0x0000);
14840 MP_WritePhyUshort(sc, 0x1d, 0x0000);
14841 MP_WritePhyUshort(sc, 0x1d, 0xad02);
14842 MP_WritePhyUshort(sc, 0x1d, 0x4400);
14843 MP_WritePhyUshort(sc, 0x1d, 0xc0e9);
14844 MP_WritePhyUshort(sc, 0x1d, 0x0003);
14845 MP_WritePhyUshort(sc, 0x1d, 0xadd8);
14846 MP_WritePhyUshort(sc, 0x1d, 0x30c6);
14847 MP_WritePhyUshort(sc, 0x1d, 0x3078);
14848 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
14849 MP_WritePhyUshort(sc, 0x1d, 0x4dc0);
14850 MP_WritePhyUshort(sc, 0x1d, 0x6730);
14851 MP_WritePhyUshort(sc, 0x1d, 0x0000);
14852 MP_WritePhyUshort(sc, 0x1d, 0x0000);
14853 MP_WritePhyUshort(sc, 0x1d, 0xd09d);
14854 MP_WritePhyUshort(sc, 0x1d, 0x0002);
14855 MP_WritePhyUshort(sc, 0x1d, 0xb4fe);
14856 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
14857 MP_WritePhyUshort(sc, 0x1d, 0x4d80);
14858 MP_WritePhyUshort(sc, 0x1d, 0x6802);
14859 MP_WritePhyUshort(sc, 0x1d, 0x6600);
14860 MP_WritePhyUshort(sc, 0x1d, 0x0000);
14861 MP_WritePhyUshort(sc, 0x1d, 0x0000);
14862 MP_WritePhyUshort(sc, 0x1d, 0x7c08);
14863 MP_WritePhyUshort(sc, 0x1d, 0x6000);
14864 MP_WritePhyUshort(sc, 0x1d, 0x486c);
14865 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
14866 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
14867 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
14868 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
14869 MP_WritePhyUshort(sc, 0x1d, 0x9503);
14870 MP_WritePhyUshort(sc, 0x1d, 0x7e00);
14871 MP_WritePhyUshort(sc, 0x1d, 0x6200);
14872 MP_WritePhyUshort(sc, 0x1d, 0x571f);
14873 MP_WritePhyUshort(sc, 0x1d, 0x5fbb);
14874 MP_WritePhyUshort(sc, 0x1d, 0xaa03);
14875 MP_WritePhyUshort(sc, 0x1d, 0x5b58);
14876 MP_WritePhyUshort(sc, 0x1d, 0x30e9);
14877 MP_WritePhyUshort(sc, 0x1d, 0x5b64);
14878 MP_WritePhyUshort(sc, 0x1d, 0xcdab);
14879 MP_WritePhyUshort(sc, 0x1d, 0xff5b);
14880 MP_WritePhyUshort(sc, 0x1d, 0xcd8d);
14881 MP_WritePhyUshort(sc, 0x1d, 0xff59);
14882 MP_WritePhyUshort(sc, 0x1d, 0xd96b);
14883 MP_WritePhyUshort(sc, 0x1d, 0xff57);
14884 MP_WritePhyUshort(sc, 0x1d, 0xd0a0);
14885 MP_WritePhyUshort(sc, 0x1d, 0xffdb);
14886 MP_WritePhyUshort(sc, 0x1d, 0xcba0);
14887 MP_WritePhyUshort(sc, 0x1d, 0x0003);
14888 MP_WritePhyUshort(sc, 0x1d, 0x80f0);
14889 MP_WritePhyUshort(sc, 0x1d, 0x30f6);
14890 MP_WritePhyUshort(sc, 0x1d, 0x3109);
14891 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
14892 MP_WritePhyUshort(sc, 0x1d, 0x4ce0);
14893 MP_WritePhyUshort(sc, 0x1d, 0x7d30);
14894 MP_WritePhyUshort(sc, 0x1d, 0x6530);
14895 MP_WritePhyUshort(sc, 0x1d, 0x0000);
14896 MP_WritePhyUshort(sc, 0x1d, 0x0000);
14897 MP_WritePhyUshort(sc, 0x1d, 0x7ce0);
14898 MP_WritePhyUshort(sc, 0x1d, 0x5400);
14899 MP_WritePhyUshort(sc, 0x1d, 0x4832);
14900 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
14901 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
14902 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
14903 MP_WritePhyUshort(sc, 0x1d, 0x4c08);
14904 MP_WritePhyUshort(sc, 0x1d, 0x7c08);
14905 MP_WritePhyUshort(sc, 0x1d, 0x6008);
14906 MP_WritePhyUshort(sc, 0x1d, 0x8300);
14907 MP_WritePhyUshort(sc, 0x1d, 0xb902);
14908 MP_WritePhyUshort(sc, 0x1d, 0x30d3);
14909 MP_WritePhyUshort(sc, 0x1d, 0x308f);
14910 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
14911 MP_WritePhyUshort(sc, 0x1d, 0x4da0);
14912 MP_WritePhyUshort(sc, 0x1d, 0x57a0);
14913 MP_WritePhyUshort(sc, 0x1d, 0x590c);
14914 MP_WritePhyUshort(sc, 0x1d, 0x5fa2);
14915 MP_WritePhyUshort(sc, 0x1d, 0xcba4);
14916 MP_WritePhyUshort(sc, 0x1d, 0x0005);
14917 MP_WritePhyUshort(sc, 0x1d, 0xcd8d);
14918 MP_WritePhyUshort(sc, 0x1d, 0x0003);
14919 MP_WritePhyUshort(sc, 0x1d, 0x80fc);
14920 MP_WritePhyUshort(sc, 0x1d, 0x0000);
14921 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
14922 MP_WritePhyUshort(sc, 0x1d, 0x4ca0);
14923 MP_WritePhyUshort(sc, 0x1d, 0xb603);
14924 MP_WritePhyUshort(sc, 0x1d, 0x7c10);
14925 MP_WritePhyUshort(sc, 0x1d, 0x6010);
14926 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
14927 MP_WritePhyUshort(sc, 0x1d, 0x541f);
14928 MP_WritePhyUshort(sc, 0x1d, 0x7ffc);
14929 MP_WritePhyUshort(sc, 0x1d, 0x5fb3);
14930 MP_WritePhyUshort(sc, 0x1d, 0x9403);
14931 MP_WritePhyUshort(sc, 0x1d, 0x7c03);
14932 MP_WritePhyUshort(sc, 0x1d, 0x5c03);
14933 MP_WritePhyUshort(sc, 0x1d, 0xaa05);
14934 MP_WritePhyUshort(sc, 0x1d, 0x7c80);
14935 MP_WritePhyUshort(sc, 0x1d, 0x5800);
14936 MP_WritePhyUshort(sc, 0x1d, 0x5b58);
14937 MP_WritePhyUshort(sc, 0x1d, 0x3128);
14938 MP_WritePhyUshort(sc, 0x1d, 0x7c80);
14939 MP_WritePhyUshort(sc, 0x1d, 0x5800);
14940 MP_WritePhyUshort(sc, 0x1d, 0x5b64);
14941 MP_WritePhyUshort(sc, 0x1d, 0x4827);
14942 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
14943 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
14944 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
14945 MP_WritePhyUshort(sc, 0x1d, 0x4c10);
14946 MP_WritePhyUshort(sc, 0x1d, 0x8400);
14947 MP_WritePhyUshort(sc, 0x1d, 0x7c10);
14948 MP_WritePhyUshort(sc, 0x1d, 0x6000);
14949 MP_WritePhyUshort(sc, 0x1d, 0x4824);
14950 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
14951 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
14952 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
14953 MP_WritePhyUshort(sc, 0x1d, 0x4c04);
14954 MP_WritePhyUshort(sc, 0x1d, 0x8200);
14955 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
14956 MP_WritePhyUshort(sc, 0x1d, 0x4cc0);
14957 MP_WritePhyUshort(sc, 0x1d, 0x7d00);
14958 MP_WritePhyUshort(sc, 0x1d, 0x6400);
14959 MP_WritePhyUshort(sc, 0x1d, 0x7ffc);
14960 MP_WritePhyUshort(sc, 0x1d, 0x5fbb);
14961 MP_WritePhyUshort(sc, 0x1d, 0x4824);
14962 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
14963 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
14964 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
14965 MP_WritePhyUshort(sc, 0x1d, 0x4c04);
14966 MP_WritePhyUshort(sc, 0x1d, 0x8200);
14967 MP_WritePhyUshort(sc, 0x1d, 0x7e00);
14968 MP_WritePhyUshort(sc, 0x1d, 0x6a00);
14969 MP_WritePhyUshort(sc, 0x1d, 0x4824);
14970 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
14971 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
14972 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
14973 MP_WritePhyUshort(sc, 0x1d, 0x4c04);
14974 MP_WritePhyUshort(sc, 0x1d, 0x8200);
14975 MP_WritePhyUshort(sc, 0x1d, 0x7e00);
14976 MP_WritePhyUshort(sc, 0x1d, 0x6800);
14977 MP_WritePhyUshort(sc, 0x1d, 0x30f6);
14978 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
14979 MP_WritePhyUshort(sc, 0x1d, 0x4e00);
14980 MP_WritePhyUshort(sc, 0x1d, 0x4007);
14981 MP_WritePhyUshort(sc, 0x1d, 0x4400);
14982 MP_WritePhyUshort(sc, 0x1d, 0x5310);
14983 MP_WritePhyUshort(sc, 0x1d, 0x6800);
14984 MP_WritePhyUshort(sc, 0x1d, 0x6736);
14985 MP_WritePhyUshort(sc, 0x1d, 0x0000);
14986 MP_WritePhyUshort(sc, 0x1d, 0x0000);
14987 MP_WritePhyUshort(sc, 0x1d, 0x570f);
14988 MP_WritePhyUshort(sc, 0x1d, 0x5fff);
14989 MP_WritePhyUshort(sc, 0x1d, 0xaa03);
14990 MP_WritePhyUshort(sc, 0x1d, 0x585b);
14991 MP_WritePhyUshort(sc, 0x1d, 0x315c);
14992 MP_WritePhyUshort(sc, 0x1d, 0x5867);
14993 MP_WritePhyUshort(sc, 0x1d, 0x9402);
14994 MP_WritePhyUshort(sc, 0x1d, 0x6200);
14995 MP_WritePhyUshort(sc, 0x1d, 0xcda3);
14996 MP_WritePhyUshort(sc, 0x1d, 0x009d);
14997 MP_WritePhyUshort(sc, 0x1d, 0xcd85);
14998 MP_WritePhyUshort(sc, 0x1d, 0x009b);
14999 MP_WritePhyUshort(sc, 0x1d, 0xd96b);
15000 MP_WritePhyUshort(sc, 0x1d, 0x0099);
15001 MP_WritePhyUshort(sc, 0x1d, 0x96e9);
15002 MP_WritePhyUshort(sc, 0x1d, 0x6800);
15003 MP_WritePhyUshort(sc, 0x1d, 0x6736);
15004 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
15005 MP_WritePhyUshort(sc, 0x1d, 0x4e20);
15006 MP_WritePhyUshort(sc, 0x1d, 0x96e4);
15007 MP_WritePhyUshort(sc, 0x1d, 0x8b04);
15008 MP_WritePhyUshort(sc, 0x1d, 0x7c08);
15009 MP_WritePhyUshort(sc, 0x1d, 0x5008);
15010 MP_WritePhyUshort(sc, 0x1d, 0xab03);
15011 MP_WritePhyUshort(sc, 0x1d, 0x7c08);
15012 MP_WritePhyUshort(sc, 0x1d, 0x5000);
15013 MP_WritePhyUshort(sc, 0x1d, 0x6801);
15014 MP_WritePhyUshort(sc, 0x1d, 0x6776);
15015 MP_WritePhyUshort(sc, 0x1d, 0x0000);
15016 MP_WritePhyUshort(sc, 0x1d, 0x0000);
15017 MP_WritePhyUshort(sc, 0x1d, 0xdb7c);
15018 MP_WritePhyUshort(sc, 0x1d, 0xfff0);
15019 MP_WritePhyUshort(sc, 0x1d, 0x0000);
15020 MP_WritePhyUshort(sc, 0x1d, 0x7fe1);
15021 MP_WritePhyUshort(sc, 0x1d, 0x4e40);
15022 MP_WritePhyUshort(sc, 0x1d, 0x4837);
15023 MP_WritePhyUshort(sc, 0x1d, 0x4418);
15024 MP_WritePhyUshort(sc, 0x1d, 0x41c7);
15025 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
15026 MP_WritePhyUshort(sc, 0x1d, 0x4e40);
15027 MP_WritePhyUshort(sc, 0x1d, 0x7c40);
15028 MP_WritePhyUshort(sc, 0x1d, 0x5400);
15029 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
15030 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
15031 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
15032 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
15033 MP_WritePhyUshort(sc, 0x1d, 0x8fc9);
15034 MP_WritePhyUshort(sc, 0x1d, 0xd2a0);
15035 MP_WritePhyUshort(sc, 0x1d, 0x004a);
15036 MP_WritePhyUshort(sc, 0x1d, 0x9203);
15037 MP_WritePhyUshort(sc, 0x1d, 0xa041);
15038 MP_WritePhyUshort(sc, 0x1d, 0x3184);
15039 MP_WritePhyUshort(sc, 0x1d, 0x7fe1);
15040 MP_WritePhyUshort(sc, 0x1d, 0x4e60);
15041 MP_WritePhyUshort(sc, 0x1d, 0x489c);
15042 MP_WritePhyUshort(sc, 0x1d, 0x4628);
15043 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
15044 MP_WritePhyUshort(sc, 0x1d, 0x4e60);
15045 MP_WritePhyUshort(sc, 0x1d, 0x7e28);
15046 MP_WritePhyUshort(sc, 0x1d, 0x4628);
15047 MP_WritePhyUshort(sc, 0x1d, 0x7c40);
15048 MP_WritePhyUshort(sc, 0x1d, 0x5400);
15049 MP_WritePhyUshort(sc, 0x1d, 0x7c01);
15050 MP_WritePhyUshort(sc, 0x1d, 0x5800);
15051 MP_WritePhyUshort(sc, 0x1d, 0x7c04);
15052 MP_WritePhyUshort(sc, 0x1d, 0x5c00);
15053 MP_WritePhyUshort(sc, 0x1d, 0x41e8);
15054 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
15055 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
15056 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
15057 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
15058 MP_WritePhyUshort(sc, 0x1d, 0x8fb0);
15059 MP_WritePhyUshort(sc, 0x1d, 0xb241);
15060 MP_WritePhyUshort(sc, 0x1d, 0xa02a);
15061 MP_WritePhyUshort(sc, 0x1d, 0x319d);
15062 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
15063 MP_WritePhyUshort(sc, 0x1d, 0x4ea0);
15064 MP_WritePhyUshort(sc, 0x1d, 0x7c02);
15065 MP_WritePhyUshort(sc, 0x1d, 0x4402);
15066 MP_WritePhyUshort(sc, 0x1d, 0x4448);
15067 MP_WritePhyUshort(sc, 0x1d, 0x4894);
15068 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
15069 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
15070 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
15071 MP_WritePhyUshort(sc, 0x1d, 0x4c03);
15072 MP_WritePhyUshort(sc, 0x1d, 0x4824);
15073 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
15074 MP_WritePhyUshort(sc, 0x1d, 0x4c07);
15075 MP_WritePhyUshort(sc, 0x1d, 0x41ef);
15076 MP_WritePhyUshort(sc, 0x1d, 0x41ff);
15077 MP_WritePhyUshort(sc, 0x1d, 0x4891);
15078 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
15079 MP_WritePhyUshort(sc, 0x1d, 0x4c07);
15080 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
15081 MP_WritePhyUshort(sc, 0x1d, 0x4c17);
15082 MP_WritePhyUshort(sc, 0x1d, 0x8400);
15083 MP_WritePhyUshort(sc, 0x1d, 0x8ef8);
15084 MP_WritePhyUshort(sc, 0x1d, 0x41c7);
15085 MP_WritePhyUshort(sc, 0x1d, 0x8f95);
15086 MP_WritePhyUshort(sc, 0x1d, 0x92d5);
15087 MP_WritePhyUshort(sc, 0x1d, 0xa10f);
15088 MP_WritePhyUshort(sc, 0x1d, 0xd480);
15089 MP_WritePhyUshort(sc, 0x1d, 0x0008);
15090 MP_WritePhyUshort(sc, 0x1d, 0xd580);
15091 MP_WritePhyUshort(sc, 0x1d, 0xffb9);
15092 MP_WritePhyUshort(sc, 0x1d, 0xa202);
15093 MP_WritePhyUshort(sc, 0x1d, 0x31b8);
15094 MP_WritePhyUshort(sc, 0x1d, 0x7c04);
15095 MP_WritePhyUshort(sc, 0x1d, 0x4404);
15096 MP_WritePhyUshort(sc, 0x1d, 0x31b8);
15097 MP_WritePhyUshort(sc, 0x1d, 0xd484);
15098 MP_WritePhyUshort(sc, 0x1d, 0xfff3);
15099 MP_WritePhyUshort(sc, 0x1d, 0xd484);
15100 MP_WritePhyUshort(sc, 0x1d, 0xfff1);
15101 MP_WritePhyUshort(sc, 0x1d, 0x314d);
15102 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
15103 MP_WritePhyUshort(sc, 0x1d, 0x4ee0);
15104 MP_WritePhyUshort(sc, 0x1d, 0x7c40);
15105 MP_WritePhyUshort(sc, 0x1d, 0x5400);
15106 MP_WritePhyUshort(sc, 0x1d, 0x4488);
15107 MP_WritePhyUshort(sc, 0x1d, 0x41cf);
15108 MP_WritePhyUshort(sc, 0x1d, 0x314d);
15109 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
15110 MP_WritePhyUshort(sc, 0x1d, 0x4ec0);
15111 MP_WritePhyUshort(sc, 0x1d, 0x48f3);
15112 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
15113 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
15114 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
15115 MP_WritePhyUshort(sc, 0x1d, 0x4c09);
15116 MP_WritePhyUshort(sc, 0x1d, 0x4508);
15117 MP_WritePhyUshort(sc, 0x1d, 0x41c7);
15118 MP_WritePhyUshort(sc, 0x1d, 0x8f24);
15119 MP_WritePhyUshort(sc, 0x1d, 0xd218);
15120 MP_WritePhyUshort(sc, 0x1d, 0x0022);
15121 MP_WritePhyUshort(sc, 0x1d, 0xd2a4);
15122 MP_WritePhyUshort(sc, 0x1d, 0xff9f);
15123 MP_WritePhyUshort(sc, 0x1d, 0x31d9);
15124 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
15125 MP_WritePhyUshort(sc, 0x1d, 0x4e80);
15126 MP_WritePhyUshort(sc, 0x1d, 0x4832);
15127 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
15128 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
15129 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
15130 MP_WritePhyUshort(sc, 0x1d, 0x4c11);
15131 MP_WritePhyUshort(sc, 0x1d, 0x4428);
15132 MP_WritePhyUshort(sc, 0x1d, 0x7c40);
15133 MP_WritePhyUshort(sc, 0x1d, 0x5440);
15134 MP_WritePhyUshort(sc, 0x1d, 0x7c01);
15135 MP_WritePhyUshort(sc, 0x1d, 0x5801);
15136 MP_WritePhyUshort(sc, 0x1d, 0x7c04);
15137 MP_WritePhyUshort(sc, 0x1d, 0x5c04);
15138 MP_WritePhyUshort(sc, 0x1d, 0x41e8);
15139 MP_WritePhyUshort(sc, 0x1d, 0xa4b3);
15140 MP_WritePhyUshort(sc, 0x1d, 0x31ee);
15141 MP_WritePhyUshort(sc, 0x1d, 0x6800);
15142 MP_WritePhyUshort(sc, 0x1d, 0x6736);
15143 MP_WritePhyUshort(sc, 0x1d, 0x0000);
15144 MP_WritePhyUshort(sc, 0x1d, 0x0000);
15145 MP_WritePhyUshort(sc, 0x1d, 0x570f);
15146 MP_WritePhyUshort(sc, 0x1d, 0x5fff);
15147 MP_WritePhyUshort(sc, 0x1d, 0xaa03);
15148 MP_WritePhyUshort(sc, 0x1d, 0x585b);
15149 MP_WritePhyUshort(sc, 0x1d, 0x31fa);
15150 MP_WritePhyUshort(sc, 0x1d, 0x5867);
15151 MP_WritePhyUshort(sc, 0x1d, 0xbcf6);
15152 MP_WritePhyUshort(sc, 0x1d, 0x300b);
15153 MP_WritePhyUshort(sc, 0x1d, 0x300b);
15154 MP_WritePhyUshort(sc, 0x1d, 0x314d);
15155 MP_WritePhyUshort(sc, 0x1f, 0x0004);
15156 MP_WritePhyUshort(sc, 0x1c, 0x0200);
15157 MP_WritePhyUshort(sc, 0x19, 0x7030);
15158 MP_WritePhyUshort(sc, 0x1f, 0x0000);
15159
15160 if (CSR_READ_1(sc, 0xEF)&0x08) {
15161 MP_WritePhyUshort(sc, 0x1F, 0x0005);
15162 MP_WritePhyUshort(sc, 0x1A, 0x0004);
15163 MP_WritePhyUshort(sc, 0x1F, 0x0000);
15164 } else {
15165 MP_WritePhyUshort(sc, 0x1F, 0x0005);
15166 MP_WritePhyUshort(sc, 0x1A, 0x0000);
15167 MP_WritePhyUshort(sc, 0x1F, 0x0000);
15168 }
15169
15170 if (CSR_READ_1(sc, 0xEF)&0x10) {
15171 MP_WritePhyUshort(sc, 0x1F, 0x0004);
15172 MP_WritePhyUshort(sc, 0x1C, 0x0000);
15173 MP_WritePhyUshort(sc, 0x1F, 0x0000);
15174 } else {
15175 MP_WritePhyUshort(sc, 0x1F, 0x0004);
15176 MP_WritePhyUshort(sc, 0x1C, 0x0200);
15177 MP_WritePhyUshort(sc, 0x1F, 0x0000);
15178 }
15179
15180 MP_WritePhyUshort(sc, 0x1F, 0x0001);
15181 MP_WritePhyUshort(sc, 0x15, 0x7701);
15182 MP_WritePhyUshort(sc, 0x1F, 0x0000);
15183
15184 MP_WritePhyUshort(sc, 0x1F, 0x0000);
15185 ClearEthPhyBit(sc, 0x1A, BIT_14);
15186
15187 if (phy_power_saving == 1) {
15188 MP_WritePhyUshort(sc, 0x1F, 0x0000);
15189 MP_WritePhyUshort(sc, 0x18, 0x8310);
15190 MP_WritePhyUshort(sc, 0x1F, 0x0000);
15191 } else {
15192 MP_WritePhyUshort(sc, 0x1F, 0x0000);
15193 MP_WritePhyUshort(sc, 0x18, 0x0310);
15194 MP_WritePhyUshort(sc, 0x1F, 0x0000);
15195 DELAY(20000);
15196 }
15197
15198 MP_WritePhyUshort(sc, 0x1F, 0x0000);
15199 MP_WritePhyUshort(sc, 0x0D, 0x0007);
15200 MP_WritePhyUshort(sc, 0x0E, 0x003C);
15201 MP_WritePhyUshort(sc, 0x0D, 0x4007);
15202 MP_WritePhyUshort(sc, 0x0E, 0x0000);
15203 MP_WritePhyUshort(sc, 0x0D, 0x0000);
15204 MP_WritePhyUshort(sc, 0x1F, 0x0000);
15205 MP_WritePhyUshort(sc, 0x0D, 0x0003);
15206 MP_WritePhyUshort(sc, 0x0E, 0x0015);
15207 MP_WritePhyUshort(sc, 0x0D, 0x4003);
15208 MP_WritePhyUshort(sc, 0x0E, 0x0000);
15209 MP_WritePhyUshort(sc, 0x0D, 0x0000);
15210
15211 } else if (sc->re_type == MACFG_50) {
15212 MP_WritePhyUshort(sc,0x1f, 0x0000);
15213 MP_WritePhyUshort(sc,0x00, 0x1800);
15214 Data = MP_ReadPhyUshort(sc, 0x15);
15215 Data &= ~(BIT_12);
15216 MP_WritePhyUshort(sc,0x15, Data);
15217 MP_WritePhyUshort(sc,0x00, 0x4800);
15218 MP_WritePhyUshort(sc,0x1f, 0x0007);
15219 MP_WritePhyUshort(sc,0x1e, 0x002f);
15220 for (i = 0; i < 1000; i++) {
15221 DELAY(100);
15222 Data = MP_ReadPhyUshort(sc, 0x1c);
15223 if (Data & BIT_7)
15224 break;
15225 }
15226 MP_WritePhyUshort(sc,0x1f, 0x0000);
15227 MP_WritePhyUshort(sc,0x00, 0x1800);
15228 MP_WritePhyUshort(sc,0x1f, 0x0007);
15229 MP_WritePhyUshort(sc,0x1e, 0x0023);
15230 for (i = 0; i < 200; i++) {
15231 DELAY(100);
15232 Data = MP_ReadPhyUshort(sc, 0x18);
15233 if (!(Data & BIT_0))
15234 break;
15235 }
15236 MP_WritePhyUshort(sc, 0x1f, 0x0005);
15237 MP_WritePhyUshort(sc, 0x05, 0xfff6);
15238 MP_WritePhyUshort(sc, 0x06, 0x0080);
15239 MP_WritePhyUshort(sc, 0x1f, 0x0007);
15240 MP_WritePhyUshort(sc, 0x1e, 0x0023);
15241 MP_WritePhyUshort(sc, 0x16, 0x0306);
15242 MP_WritePhyUshort(sc, 0x16, 0x0307);
15243 MP_WritePhyUshort(sc, 0x15, 0x0194);
15244 MP_WritePhyUshort(sc, 0x19, 0x407D);
15245 MP_WritePhyUshort(sc, 0x15, 0x0098);
15246 MP_WritePhyUshort(sc, 0x19, 0x7c0b);
15247 MP_WritePhyUshort(sc, 0x15, 0x0099);
15248 MP_WritePhyUshort(sc, 0x19, 0x6c0b);
15249 MP_WritePhyUshort(sc, 0x15, 0x00eb);
15250 MP_WritePhyUshort(sc, 0x19, 0x6c0b);
15251 MP_WritePhyUshort(sc, 0x15, 0x00f8);
15252 MP_WritePhyUshort(sc, 0x19, 0x6f0b);
15253 MP_WritePhyUshort(sc, 0x15, 0x00fe);
15254 MP_WritePhyUshort(sc, 0x19, 0x6f0f);
15255 MP_WritePhyUshort(sc, 0x15, 0x00db);
15256 MP_WritePhyUshort(sc, 0x19, 0x6f09);
15257 MP_WritePhyUshort(sc, 0x15, 0x00dc);
15258 MP_WritePhyUshort(sc, 0x19, 0xaefd);
15259 MP_WritePhyUshort(sc, 0x15, 0x00dd);
15260 MP_WritePhyUshort(sc, 0x19, 0x6f0b);
15261 MP_WritePhyUshort(sc, 0x15, 0x00de);
15262 MP_WritePhyUshort(sc, 0x19, 0xc60b);
15263 MP_WritePhyUshort(sc, 0x15, 0x00df);
15264 MP_WritePhyUshort(sc, 0x19, 0x00fa);
15265 MP_WritePhyUshort(sc, 0x15, 0x00e0);
15266 MP_WritePhyUshort(sc, 0x19, 0x30e1);
15267 MP_WritePhyUshort(sc, 0x15, 0x020c);
15268 MP_WritePhyUshort(sc, 0x19, 0x3224);
15269 MP_WritePhyUshort(sc, 0x15, 0x020e);
15270 MP_WritePhyUshort(sc, 0x19, 0x9813);
15271 MP_WritePhyUshort(sc, 0x15, 0x020f);
15272 MP_WritePhyUshort(sc, 0x19, 0x7801);
15273 MP_WritePhyUshort(sc, 0x15, 0x0210);
15274 MP_WritePhyUshort(sc, 0x19, 0x930f);
15275 MP_WritePhyUshort(sc, 0x15, 0x0211);
15276 MP_WritePhyUshort(sc, 0x19, 0x9206);
15277 MP_WritePhyUshort(sc, 0x15, 0x0212);
15278 MP_WritePhyUshort(sc, 0x19, 0x4002);
15279 MP_WritePhyUshort(sc, 0x15, 0x0213);
15280 MP_WritePhyUshort(sc, 0x19, 0x7800);
15281 MP_WritePhyUshort(sc, 0x15, 0x0214);
15282 MP_WritePhyUshort(sc, 0x19, 0x588f);
15283 MP_WritePhyUshort(sc, 0x15, 0x0215);
15284 MP_WritePhyUshort(sc, 0x19, 0x5520);
15285 MP_WritePhyUshort(sc, 0x15, 0x0216);
15286 MP_WritePhyUshort(sc, 0x19, 0x3224);
15287 MP_WritePhyUshort(sc, 0x15, 0x0217);
15288 MP_WritePhyUshort(sc, 0x19, 0x4002);
15289 MP_WritePhyUshort(sc, 0x15, 0x0218);
15290 MP_WritePhyUshort(sc, 0x19, 0x7800);
15291 MP_WritePhyUshort(sc, 0x15, 0x0219);
15292 MP_WritePhyUshort(sc, 0x19, 0x588d);
15293 MP_WritePhyUshort(sc, 0x15, 0x021a);
15294 MP_WritePhyUshort(sc, 0x19, 0x5540);
15295 MP_WritePhyUshort(sc, 0x15, 0x021b);
15296 MP_WritePhyUshort(sc, 0x19, 0x9e03);
15297 MP_WritePhyUshort(sc, 0x15, 0x021c);
15298 MP_WritePhyUshort(sc, 0x19, 0x7c40);
15299 MP_WritePhyUshort(sc, 0x15, 0x021d);
15300 MP_WritePhyUshort(sc, 0x19, 0x6840);
15301 MP_WritePhyUshort(sc, 0x15, 0x021e);
15302 MP_WritePhyUshort(sc, 0x19, 0x3224);
15303 MP_WritePhyUshort(sc, 0x15, 0x021f);
15304 MP_WritePhyUshort(sc, 0x19, 0x4002);
15305 MP_WritePhyUshort(sc, 0x15, 0x0220);
15306 MP_WritePhyUshort(sc, 0x19, 0x3224);
15307 MP_WritePhyUshort(sc, 0x15, 0x0221);
15308 MP_WritePhyUshort(sc, 0x19, 0x9e03);
15309 MP_WritePhyUshort(sc, 0x15, 0x0222);
15310 MP_WritePhyUshort(sc, 0x19, 0x7c40);
15311 MP_WritePhyUshort(sc, 0x15, 0x0223);
15312 MP_WritePhyUshort(sc, 0x19, 0x6840);
15313 MP_WritePhyUshort(sc, 0x15, 0x0224);
15314 MP_WritePhyUshort(sc, 0x19, 0x7800);
15315 MP_WritePhyUshort(sc, 0x15, 0x0225);
15316 MP_WritePhyUshort(sc, 0x19, 0x3231);
15317 MP_WritePhyUshort(sc, 0x15, 0x0000);
15318 MP_WritePhyUshort(sc, 0x16, 0x0306);
15319 MP_WritePhyUshort(sc, 0x16, 0x0300);
15320 MP_WritePhyUshort(sc, 0x1f, 0x0000);
15321 MP_WritePhyUshort(sc, 0x1f, 0x0005);
15322 MP_WritePhyUshort(sc, 0x05, 0xfff6);
15323 MP_WritePhyUshort(sc, 0x06, 0x0080);
15324 MP_WritePhyUshort(sc, 0x05, 0x8000);
15325 MP_WritePhyUshort(sc, 0x06, 0x0280);
15326 MP_WritePhyUshort(sc, 0x06, 0x48f7);
15327 MP_WritePhyUshort(sc, 0x06, 0x00e0);
15328 MP_WritePhyUshort(sc, 0x06, 0xfff7);
15329 MP_WritePhyUshort(sc, 0x06, 0xa080);
15330 MP_WritePhyUshort(sc, 0x06, 0x02ae);
15331 MP_WritePhyUshort(sc, 0x06, 0xf602);
15332 MP_WritePhyUshort(sc, 0x06, 0x0118);
15333 MP_WritePhyUshort(sc, 0x06, 0x0201);
15334 MP_WritePhyUshort(sc, 0x06, 0x2502);
15335 MP_WritePhyUshort(sc, 0x06, 0x8090);
15336 MP_WritePhyUshort(sc, 0x06, 0x0201);
15337 MP_WritePhyUshort(sc, 0x06, 0x4202);
15338 MP_WritePhyUshort(sc, 0x06, 0x015c);
15339 MP_WritePhyUshort(sc, 0x06, 0x0280);
15340 MP_WritePhyUshort(sc, 0x06, 0xad02);
15341 MP_WritePhyUshort(sc, 0x06, 0x80ca);
15342 MP_WritePhyUshort(sc, 0x06, 0xe08b);
15343 MP_WritePhyUshort(sc, 0x06, 0x88e1);
15344 MP_WritePhyUshort(sc, 0x06, 0x8b89);
15345 MP_WritePhyUshort(sc, 0x06, 0x1e01);
15346 MP_WritePhyUshort(sc, 0x06, 0xe18b);
15347 MP_WritePhyUshort(sc, 0x06, 0x8a1e);
15348 MP_WritePhyUshort(sc, 0x06, 0x01e1);
15349 MP_WritePhyUshort(sc, 0x06, 0x8b8b);
15350 MP_WritePhyUshort(sc, 0x06, 0x1e01);
15351 MP_WritePhyUshort(sc, 0x06, 0xe18b);
15352 MP_WritePhyUshort(sc, 0x06, 0x8c1e);
15353 MP_WritePhyUshort(sc, 0x06, 0x01e1);
15354 MP_WritePhyUshort(sc, 0x06, 0x8b8d);
15355 MP_WritePhyUshort(sc, 0x06, 0x1e01);
15356 MP_WritePhyUshort(sc, 0x06, 0xe18b);
15357 MP_WritePhyUshort(sc, 0x06, 0x8e1e);
15358 MP_WritePhyUshort(sc, 0x06, 0x01a0);
15359 MP_WritePhyUshort(sc, 0x06, 0x00c7);
15360 MP_WritePhyUshort(sc, 0x06, 0xaebb);
15361 MP_WritePhyUshort(sc, 0x06, 0xd484);
15362 MP_WritePhyUshort(sc, 0x06, 0x3ce4);
15363 MP_WritePhyUshort(sc, 0x06, 0x8b92);
15364 MP_WritePhyUshort(sc, 0x06, 0xe58b);
15365 MP_WritePhyUshort(sc, 0x06, 0x93ee);
15366 MP_WritePhyUshort(sc, 0x06, 0x8ac8);
15367 MP_WritePhyUshort(sc, 0x06, 0x03ee);
15368 MP_WritePhyUshort(sc, 0x06, 0x8aca);
15369 MP_WritePhyUshort(sc, 0x06, 0x60ee);
15370 MP_WritePhyUshort(sc, 0x06, 0x8ac0);
15371 MP_WritePhyUshort(sc, 0x06, 0x00ee);
15372 MP_WritePhyUshort(sc, 0x06, 0x8ac1);
15373 MP_WritePhyUshort(sc, 0x06, 0x00ee);
15374 MP_WritePhyUshort(sc, 0x06, 0x8abe);
15375 MP_WritePhyUshort(sc, 0x06, 0x07ee);
15376 MP_WritePhyUshort(sc, 0x06, 0x8abf);
15377 MP_WritePhyUshort(sc, 0x06, 0x73ee);
15378 MP_WritePhyUshort(sc, 0x06, 0x8a95);
15379 MP_WritePhyUshort(sc, 0x06, 0x02bf);
15380 MP_WritePhyUshort(sc, 0x06, 0x8b88);
15381 MP_WritePhyUshort(sc, 0x06, 0xec00);
15382 MP_WritePhyUshort(sc, 0x06, 0x19a9);
15383 MP_WritePhyUshort(sc, 0x06, 0x8b90);
15384 MP_WritePhyUshort(sc, 0x06, 0xf9ee);
15385 MP_WritePhyUshort(sc, 0x06, 0xfff6);
15386 MP_WritePhyUshort(sc, 0x06, 0x00ee);
15387 MP_WritePhyUshort(sc, 0x06, 0xfff7);
15388 MP_WritePhyUshort(sc, 0x06, 0xfed1);
15389 MP_WritePhyUshort(sc, 0x06, 0x00bf);
15390 MP_WritePhyUshort(sc, 0x06, 0x85a4);
15391 MP_WritePhyUshort(sc, 0x06, 0x0238);
15392 MP_WritePhyUshort(sc, 0x06, 0x7dd1);
15393 MP_WritePhyUshort(sc, 0x06, 0x01bf);
15394 MP_WritePhyUshort(sc, 0x06, 0x85a7);
15395 MP_WritePhyUshort(sc, 0x06, 0x0238);
15396 MP_WritePhyUshort(sc, 0x06, 0x7d04);
15397 MP_WritePhyUshort(sc, 0x06, 0xf8e0);
15398 MP_WritePhyUshort(sc, 0x06, 0x8b8a);
15399 MP_WritePhyUshort(sc, 0x06, 0xad20);
15400 MP_WritePhyUshort(sc, 0x06, 0x14ee);
15401 MP_WritePhyUshort(sc, 0x06, 0x8b8a);
15402 MP_WritePhyUshort(sc, 0x06, 0x0002);
15403 MP_WritePhyUshort(sc, 0x06, 0x204b);
15404 MP_WritePhyUshort(sc, 0x06, 0xe0e4);
15405 MP_WritePhyUshort(sc, 0x06, 0x26e1);
15406 MP_WritePhyUshort(sc, 0x06, 0xe427);
15407 MP_WritePhyUshort(sc, 0x06, 0xeee4);
15408 MP_WritePhyUshort(sc, 0x06, 0x2623);
15409 MP_WritePhyUshort(sc, 0x06, 0xe5e4);
15410 MP_WritePhyUshort(sc, 0x06, 0x27fc);
15411 MP_WritePhyUshort(sc, 0x06, 0x04f8);
15412 MP_WritePhyUshort(sc, 0x06, 0xe08b);
15413 MP_WritePhyUshort(sc, 0x06, 0x8dad);
15414 MP_WritePhyUshort(sc, 0x06, 0x2014);
15415 MP_WritePhyUshort(sc, 0x06, 0xee8b);
15416 MP_WritePhyUshort(sc, 0x06, 0x8d00);
15417 MP_WritePhyUshort(sc, 0x06, 0xe08a);
15418 MP_WritePhyUshort(sc, 0x06, 0x5a78);
15419 MP_WritePhyUshort(sc, 0x06, 0x039e);
15420 MP_WritePhyUshort(sc, 0x06, 0x0902);
15421 MP_WritePhyUshort(sc, 0x06, 0x05e8);
15422 MP_WritePhyUshort(sc, 0x06, 0x0281);
15423 MP_WritePhyUshort(sc, 0x06, 0x4f02);
15424 MP_WritePhyUshort(sc, 0x06, 0x326c);
15425 MP_WritePhyUshort(sc, 0x06, 0xfc04);
15426 MP_WritePhyUshort(sc, 0x06, 0xf8e0);
15427 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
15428 MP_WritePhyUshort(sc, 0x06, 0xad20);
15429 MP_WritePhyUshort(sc, 0x06, 0x1df6);
15430 MP_WritePhyUshort(sc, 0x06, 0x20e4);
15431 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
15432 MP_WritePhyUshort(sc, 0x06, 0x022f);
15433 MP_WritePhyUshort(sc, 0x06, 0x0902);
15434 MP_WritePhyUshort(sc, 0x06, 0x2ab0);
15435 MP_WritePhyUshort(sc, 0x06, 0x0285);
15436 MP_WritePhyUshort(sc, 0x06, 0x1602);
15437 MP_WritePhyUshort(sc, 0x06, 0x03ba);
15438 MP_WritePhyUshort(sc, 0x06, 0x0284);
15439 MP_WritePhyUshort(sc, 0x06, 0xe502);
15440 MP_WritePhyUshort(sc, 0x06, 0x2df1);
15441 MP_WritePhyUshort(sc, 0x06, 0x0283);
15442 MP_WritePhyUshort(sc, 0x06, 0x8302);
15443 MP_WritePhyUshort(sc, 0x06, 0x0475);
15444 MP_WritePhyUshort(sc, 0x06, 0xe08b);
15445 MP_WritePhyUshort(sc, 0x06, 0x8ead);
15446 MP_WritePhyUshort(sc, 0x06, 0x210b);
15447 MP_WritePhyUshort(sc, 0x06, 0xf621);
15448 MP_WritePhyUshort(sc, 0x06, 0xe48b);
15449 MP_WritePhyUshort(sc, 0x06, 0x8e02);
15450 MP_WritePhyUshort(sc, 0x06, 0x83f8);
15451 MP_WritePhyUshort(sc, 0x06, 0x021c);
15452 MP_WritePhyUshort(sc, 0x06, 0x99e0);
15453 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
15454 MP_WritePhyUshort(sc, 0x06, 0xad22);
15455 MP_WritePhyUshort(sc, 0x06, 0x08f6);
15456 MP_WritePhyUshort(sc, 0x06, 0x22e4);
15457 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
15458 MP_WritePhyUshort(sc, 0x06, 0x0235);
15459 MP_WritePhyUshort(sc, 0x06, 0x63e0);
15460 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
15461 MP_WritePhyUshort(sc, 0x06, 0xad23);
15462 MP_WritePhyUshort(sc, 0x06, 0x08f6);
15463 MP_WritePhyUshort(sc, 0x06, 0x23e4);
15464 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
15465 MP_WritePhyUshort(sc, 0x06, 0x0231);
15466 MP_WritePhyUshort(sc, 0x06, 0x57e0);
15467 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
15468 MP_WritePhyUshort(sc, 0x06, 0xad24);
15469 MP_WritePhyUshort(sc, 0x06, 0x05f6);
15470 MP_WritePhyUshort(sc, 0x06, 0x24e4);
15471 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
15472 MP_WritePhyUshort(sc, 0x06, 0xe08b);
15473 MP_WritePhyUshort(sc, 0x06, 0x8ead);
15474 MP_WritePhyUshort(sc, 0x06, 0x2505);
15475 MP_WritePhyUshort(sc, 0x06, 0xf625);
15476 MP_WritePhyUshort(sc, 0x06, 0xe48b);
15477 MP_WritePhyUshort(sc, 0x06, 0x8ee0);
15478 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
15479 MP_WritePhyUshort(sc, 0x06, 0xad26);
15480 MP_WritePhyUshort(sc, 0x06, 0x08f6);
15481 MP_WritePhyUshort(sc, 0x06, 0x26e4);
15482 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
15483 MP_WritePhyUshort(sc, 0x06, 0x022d);
15484 MP_WritePhyUshort(sc, 0x06, 0x1ce0);
15485 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
15486 MP_WritePhyUshort(sc, 0x06, 0xad27);
15487 MP_WritePhyUshort(sc, 0x06, 0x05f6);
15488 MP_WritePhyUshort(sc, 0x06, 0x27e4);
15489 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
15490 MP_WritePhyUshort(sc, 0x06, 0x0203);
15491 MP_WritePhyUshort(sc, 0x06, 0x80fc);
15492 MP_WritePhyUshort(sc, 0x06, 0x04f8);
15493 MP_WritePhyUshort(sc, 0x06, 0xf9e0);
15494 MP_WritePhyUshort(sc, 0x06, 0x8b81);
15495 MP_WritePhyUshort(sc, 0x06, 0xac26);
15496 MP_WritePhyUshort(sc, 0x06, 0x1ae0);
15497 MP_WritePhyUshort(sc, 0x06, 0x8b81);
15498 MP_WritePhyUshort(sc, 0x06, 0xac21);
15499 MP_WritePhyUshort(sc, 0x06, 0x14e0);
15500 MP_WritePhyUshort(sc, 0x06, 0x8b85);
15501 MP_WritePhyUshort(sc, 0x06, 0xac20);
15502 MP_WritePhyUshort(sc, 0x06, 0x0ee0);
15503 MP_WritePhyUshort(sc, 0x06, 0x8b85);
15504 MP_WritePhyUshort(sc, 0x06, 0xac23);
15505 MP_WritePhyUshort(sc, 0x06, 0x08e0);
15506 MP_WritePhyUshort(sc, 0x06, 0x8b87);
15507 MP_WritePhyUshort(sc, 0x06, 0xac24);
15508 MP_WritePhyUshort(sc, 0x06, 0x02ae);
15509 MP_WritePhyUshort(sc, 0x06, 0x3802);
15510 MP_WritePhyUshort(sc, 0x06, 0x1ac2);
15511 MP_WritePhyUshort(sc, 0x06, 0xeee4);
15512 MP_WritePhyUshort(sc, 0x06, 0x1c04);
15513 MP_WritePhyUshort(sc, 0x06, 0xeee4);
15514 MP_WritePhyUshort(sc, 0x06, 0x1d04);
15515 MP_WritePhyUshort(sc, 0x06, 0xe2e0);
15516 MP_WritePhyUshort(sc, 0x06, 0x7ce3);
15517 MP_WritePhyUshort(sc, 0x06, 0xe07d);
15518 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
15519 MP_WritePhyUshort(sc, 0x06, 0x38e1);
15520 MP_WritePhyUshort(sc, 0x06, 0xe039);
15521 MP_WritePhyUshort(sc, 0x06, 0xad2e);
15522 MP_WritePhyUshort(sc, 0x06, 0x1bad);
15523 MP_WritePhyUshort(sc, 0x06, 0x390d);
15524 MP_WritePhyUshort(sc, 0x06, 0xd101);
15525 MP_WritePhyUshort(sc, 0x06, 0xbf22);
15526 MP_WritePhyUshort(sc, 0x06, 0x7a02);
15527 MP_WritePhyUshort(sc, 0x06, 0x387d);
15528 MP_WritePhyUshort(sc, 0x06, 0x0281);
15529 MP_WritePhyUshort(sc, 0x06, 0xacae);
15530 MP_WritePhyUshort(sc, 0x06, 0x0bac);
15531 MP_WritePhyUshort(sc, 0x06, 0x3802);
15532 MP_WritePhyUshort(sc, 0x06, 0xae06);
15533 MP_WritePhyUshort(sc, 0x06, 0x0281);
15534 MP_WritePhyUshort(sc, 0x06, 0xe902);
15535 MP_WritePhyUshort(sc, 0x06, 0x822e);
15536 MP_WritePhyUshort(sc, 0x06, 0x021a);
15537 MP_WritePhyUshort(sc, 0x06, 0xd3fd);
15538 MP_WritePhyUshort(sc, 0x06, 0xfc04);
15539 MP_WritePhyUshort(sc, 0x06, 0xf8e1);
15540 MP_WritePhyUshort(sc, 0x06, 0x8af4);
15541 MP_WritePhyUshort(sc, 0x06, 0xe08b);
15542 MP_WritePhyUshort(sc, 0x06, 0x81ad);
15543 MP_WritePhyUshort(sc, 0x06, 0x2602);
15544 MP_WritePhyUshort(sc, 0x06, 0xf728);
15545 MP_WritePhyUshort(sc, 0x06, 0xe08b);
15546 MP_WritePhyUshort(sc, 0x06, 0x81ad);
15547 MP_WritePhyUshort(sc, 0x06, 0x2105);
15548 MP_WritePhyUshort(sc, 0x06, 0x0222);
15549 MP_WritePhyUshort(sc, 0x06, 0x8ef7);
15550 MP_WritePhyUshort(sc, 0x06, 0x29e0);
15551 MP_WritePhyUshort(sc, 0x06, 0x8b85);
15552 MP_WritePhyUshort(sc, 0x06, 0xad20);
15553 MP_WritePhyUshort(sc, 0x06, 0x0502);
15554 MP_WritePhyUshort(sc, 0x06, 0x14b8);
15555 MP_WritePhyUshort(sc, 0x06, 0xf72a);
15556 MP_WritePhyUshort(sc, 0x06, 0xe08b);
15557 MP_WritePhyUshort(sc, 0x06, 0x85ad);
15558 MP_WritePhyUshort(sc, 0x06, 0x2305);
15559 MP_WritePhyUshort(sc, 0x06, 0x0212);
15560 MP_WritePhyUshort(sc, 0x06, 0xf4f7);
15561 MP_WritePhyUshort(sc, 0x06, 0x2be0);
15562 MP_WritePhyUshort(sc, 0x06, 0x8b87);
15563 MP_WritePhyUshort(sc, 0x06, 0xad24);
15564 MP_WritePhyUshort(sc, 0x06, 0x0502);
15565 MP_WritePhyUshort(sc, 0x06, 0x8284);
15566 MP_WritePhyUshort(sc, 0x06, 0xf72c);
15567 MP_WritePhyUshort(sc, 0x06, 0xe58a);
15568 MP_WritePhyUshort(sc, 0x06, 0xf4fc);
15569 MP_WritePhyUshort(sc, 0x06, 0x04f8);
15570 MP_WritePhyUshort(sc, 0x06, 0xe08b);
15571 MP_WritePhyUshort(sc, 0x06, 0x81ad);
15572 MP_WritePhyUshort(sc, 0x06, 0x2600);
15573 MP_WritePhyUshort(sc, 0x06, 0xe08b);
15574 MP_WritePhyUshort(sc, 0x06, 0x81ad);
15575 MP_WritePhyUshort(sc, 0x06, 0x2109);
15576 MP_WritePhyUshort(sc, 0x06, 0xe08a);
15577 MP_WritePhyUshort(sc, 0x06, 0xf4ac);
15578 MP_WritePhyUshort(sc, 0x06, 0x2003);
15579 MP_WritePhyUshort(sc, 0x06, 0x0222);
15580 MP_WritePhyUshort(sc, 0x06, 0x7de0);
15581 MP_WritePhyUshort(sc, 0x06, 0x8b85);
15582 MP_WritePhyUshort(sc, 0x06, 0xad20);
15583 MP_WritePhyUshort(sc, 0x06, 0x09e0);
15584 MP_WritePhyUshort(sc, 0x06, 0x8af4);
15585 MP_WritePhyUshort(sc, 0x06, 0xac21);
15586 MP_WritePhyUshort(sc, 0x06, 0x0302);
15587 MP_WritePhyUshort(sc, 0x06, 0x1408);
15588 MP_WritePhyUshort(sc, 0x06, 0xe08b);
15589 MP_WritePhyUshort(sc, 0x06, 0x85ad);
15590 MP_WritePhyUshort(sc, 0x06, 0x2309);
15591 MP_WritePhyUshort(sc, 0x06, 0xe08a);
15592 MP_WritePhyUshort(sc, 0x06, 0xf4ac);
15593 MP_WritePhyUshort(sc, 0x06, 0x2203);
15594 MP_WritePhyUshort(sc, 0x06, 0x0213);
15595 MP_WritePhyUshort(sc, 0x06, 0x07e0);
15596 MP_WritePhyUshort(sc, 0x06, 0x8b87);
15597 MP_WritePhyUshort(sc, 0x06, 0xad24);
15598 MP_WritePhyUshort(sc, 0x06, 0x09e0);
15599 MP_WritePhyUshort(sc, 0x06, 0x8af4);
15600 MP_WritePhyUshort(sc, 0x06, 0xac23);
15601 MP_WritePhyUshort(sc, 0x06, 0x0302);
15602 MP_WritePhyUshort(sc, 0x06, 0x8289);
15603 MP_WritePhyUshort(sc, 0x06, 0xfc04);
15604 MP_WritePhyUshort(sc, 0x06, 0xf8e1);
15605 MP_WritePhyUshort(sc, 0x06, 0x8af4);
15606 MP_WritePhyUshort(sc, 0x06, 0xe08b);
15607 MP_WritePhyUshort(sc, 0x06, 0x81ad);
15608 MP_WritePhyUshort(sc, 0x06, 0x2602);
15609 MP_WritePhyUshort(sc, 0x06, 0xf628);
15610 MP_WritePhyUshort(sc, 0x06, 0xe08b);
15611 MP_WritePhyUshort(sc, 0x06, 0x81ad);
15612 MP_WritePhyUshort(sc, 0x06, 0x210a);
15613 MP_WritePhyUshort(sc, 0x06, 0xe083);
15614 MP_WritePhyUshort(sc, 0x06, 0xecf6);
15615 MP_WritePhyUshort(sc, 0x06, 0x27a0);
15616 MP_WritePhyUshort(sc, 0x06, 0x0502);
15617 MP_WritePhyUshort(sc, 0x06, 0xf629);
15618 MP_WritePhyUshort(sc, 0x06, 0xe08b);
15619 MP_WritePhyUshort(sc, 0x06, 0x85ad);
15620 MP_WritePhyUshort(sc, 0x06, 0x2008);
15621 MP_WritePhyUshort(sc, 0x06, 0xe08a);
15622 MP_WritePhyUshort(sc, 0x06, 0xe8ad);
15623 MP_WritePhyUshort(sc, 0x06, 0x2102);
15624 MP_WritePhyUshort(sc, 0x06, 0xf62a);
15625 MP_WritePhyUshort(sc, 0x06, 0xe08b);
15626 MP_WritePhyUshort(sc, 0x06, 0x85ad);
15627 MP_WritePhyUshort(sc, 0x06, 0x2308);
15628 MP_WritePhyUshort(sc, 0x06, 0xe08b);
15629 MP_WritePhyUshort(sc, 0x06, 0x20a0);
15630 MP_WritePhyUshort(sc, 0x06, 0x0302);
15631 MP_WritePhyUshort(sc, 0x06, 0xf62b);
15632 MP_WritePhyUshort(sc, 0x06, 0xe08b);
15633 MP_WritePhyUshort(sc, 0x06, 0x87ad);
15634 MP_WritePhyUshort(sc, 0x06, 0x2408);
15635 MP_WritePhyUshort(sc, 0x06, 0xe08a);
15636 MP_WritePhyUshort(sc, 0x06, 0xc2a0);
15637 MP_WritePhyUshort(sc, 0x06, 0x0302);
15638 MP_WritePhyUshort(sc, 0x06, 0xf62c);
15639 MP_WritePhyUshort(sc, 0x06, 0xe58a);
15640 MP_WritePhyUshort(sc, 0x06, 0xf4a1);
15641 MP_WritePhyUshort(sc, 0x06, 0x0008);
15642 MP_WritePhyUshort(sc, 0x06, 0xd100);
15643 MP_WritePhyUshort(sc, 0x06, 0xbf22);
15644 MP_WritePhyUshort(sc, 0x06, 0x7a02);
15645 MP_WritePhyUshort(sc, 0x06, 0x387d);
15646 MP_WritePhyUshort(sc, 0x06, 0xfc04);
15647 MP_WritePhyUshort(sc, 0x06, 0xee8a);
15648 MP_WritePhyUshort(sc, 0x06, 0xc200);
15649 MP_WritePhyUshort(sc, 0x06, 0x04f8);
15650 MP_WritePhyUshort(sc, 0x06, 0xe08b);
15651 MP_WritePhyUshort(sc, 0x06, 0x87ad);
15652 MP_WritePhyUshort(sc, 0x06, 0x241e);
15653 MP_WritePhyUshort(sc, 0x06, 0xe08a);
15654 MP_WritePhyUshort(sc, 0x06, 0xc2a0);
15655 MP_WritePhyUshort(sc, 0x06, 0x0005);
15656 MP_WritePhyUshort(sc, 0x06, 0x0282);
15657 MP_WritePhyUshort(sc, 0x06, 0xb0ae);
15658 MP_WritePhyUshort(sc, 0x06, 0xf5a0);
15659 MP_WritePhyUshort(sc, 0x06, 0x0105);
15660 MP_WritePhyUshort(sc, 0x06, 0x0282);
15661 MP_WritePhyUshort(sc, 0x06, 0xc0ae);
15662 MP_WritePhyUshort(sc, 0x06, 0x0ba0);
15663 MP_WritePhyUshort(sc, 0x06, 0x0205);
15664 MP_WritePhyUshort(sc, 0x06, 0x0282);
15665 MP_WritePhyUshort(sc, 0x06, 0xcaae);
15666 MP_WritePhyUshort(sc, 0x06, 0x03a0);
15667 MP_WritePhyUshort(sc, 0x06, 0x0300);
15668 MP_WritePhyUshort(sc, 0x06, 0xfc04);
15669 MP_WritePhyUshort(sc, 0x06, 0xf8fa);
15670 MP_WritePhyUshort(sc, 0x06, 0xef69);
15671 MP_WritePhyUshort(sc, 0x06, 0x0282);
15672 MP_WritePhyUshort(sc, 0x06, 0xe1ee);
15673 MP_WritePhyUshort(sc, 0x06, 0x8ac2);
15674 MP_WritePhyUshort(sc, 0x06, 0x01ef);
15675 MP_WritePhyUshort(sc, 0x06, 0x96fe);
15676 MP_WritePhyUshort(sc, 0x06, 0xfc04);
15677 MP_WritePhyUshort(sc, 0x06, 0xf8ee);
15678 MP_WritePhyUshort(sc, 0x06, 0x8ac9);
15679 MP_WritePhyUshort(sc, 0x06, 0x0002);
15680 MP_WritePhyUshort(sc, 0x06, 0x8317);
15681 MP_WritePhyUshort(sc, 0x06, 0xfc04);
15682 MP_WritePhyUshort(sc, 0x06, 0xf8e0);
15683 MP_WritePhyUshort(sc, 0x06, 0x8ac8);
15684 MP_WritePhyUshort(sc, 0x06, 0xe18a);
15685 MP_WritePhyUshort(sc, 0x06, 0xc91f);
15686 MP_WritePhyUshort(sc, 0x06, 0x019e);
15687 MP_WritePhyUshort(sc, 0x06, 0x0611);
15688 MP_WritePhyUshort(sc, 0x06, 0xe58a);
15689 MP_WritePhyUshort(sc, 0x06, 0xc9ae);
15690 MP_WritePhyUshort(sc, 0x06, 0x04ee);
15691 MP_WritePhyUshort(sc, 0x06, 0x8ac2);
15692 MP_WritePhyUshort(sc, 0x06, 0x01fc);
15693 MP_WritePhyUshort(sc, 0x06, 0x04f8);
15694 MP_WritePhyUshort(sc, 0x06, 0xf9fa);
15695 MP_WritePhyUshort(sc, 0x06, 0xef69);
15696 MP_WritePhyUshort(sc, 0x06, 0xfbbf);
15697 MP_WritePhyUshort(sc, 0x06, 0x8ac4);
15698 MP_WritePhyUshort(sc, 0x06, 0xef79);
15699 MP_WritePhyUshort(sc, 0x06, 0xd200);
15700 MP_WritePhyUshort(sc, 0x06, 0xd400);
15701 MP_WritePhyUshort(sc, 0x06, 0x221e);
15702 MP_WritePhyUshort(sc, 0x06, 0x02bf);
15703 MP_WritePhyUshort(sc, 0x06, 0x3024);
15704 MP_WritePhyUshort(sc, 0x06, 0x0238);
15705 MP_WritePhyUshort(sc, 0x06, 0x7dbf);
15706 MP_WritePhyUshort(sc, 0x06, 0x13ff);
15707 MP_WritePhyUshort(sc, 0x06, 0x0238);
15708 MP_WritePhyUshort(sc, 0x06, 0x500d);
15709 MP_WritePhyUshort(sc, 0x06, 0x4559);
15710 MP_WritePhyUshort(sc, 0x06, 0x1fef);
15711 MP_WritePhyUshort(sc, 0x06, 0x97dd);
15712 MP_WritePhyUshort(sc, 0x06, 0xd308);
15713 MP_WritePhyUshort(sc, 0x06, 0x1a93);
15714 MP_WritePhyUshort(sc, 0x06, 0xdd12);
15715 MP_WritePhyUshort(sc, 0x06, 0x17a2);
15716 MP_WritePhyUshort(sc, 0x06, 0x04de);
15717 MP_WritePhyUshort(sc, 0x06, 0xffef);
15718 MP_WritePhyUshort(sc, 0x06, 0x96fe);
15719 MP_WritePhyUshort(sc, 0x06, 0xfdfc);
15720 MP_WritePhyUshort(sc, 0x06, 0x04f8);
15721 MP_WritePhyUshort(sc, 0x06, 0xf9fa);
15722 MP_WritePhyUshort(sc, 0x06, 0xef69);
15723 MP_WritePhyUshort(sc, 0x06, 0xfbee);
15724 MP_WritePhyUshort(sc, 0x06, 0x8ac2);
15725 MP_WritePhyUshort(sc, 0x06, 0x03d5);
15726 MP_WritePhyUshort(sc, 0x06, 0x0080);
15727 MP_WritePhyUshort(sc, 0x06, 0xbf8a);
15728 MP_WritePhyUshort(sc, 0x06, 0xc4ef);
15729 MP_WritePhyUshort(sc, 0x06, 0x79ef);
15730 MP_WritePhyUshort(sc, 0x06, 0x45bf);
15731 MP_WritePhyUshort(sc, 0x06, 0x3024);
15732 MP_WritePhyUshort(sc, 0x06, 0x0238);
15733 MP_WritePhyUshort(sc, 0x06, 0x7dbf);
15734 MP_WritePhyUshort(sc, 0x06, 0x13ff);
15735 MP_WritePhyUshort(sc, 0x06, 0x0238);
15736 MP_WritePhyUshort(sc, 0x06, 0x50ad);
15737 MP_WritePhyUshort(sc, 0x06, 0x2702);
15738 MP_WritePhyUshort(sc, 0x06, 0x78ff);
15739 MP_WritePhyUshort(sc, 0x06, 0xe18a);
15740 MP_WritePhyUshort(sc, 0x06, 0xca1b);
15741 MP_WritePhyUshort(sc, 0x06, 0x01aa);
15742 MP_WritePhyUshort(sc, 0x06, 0x2eef);
15743 MP_WritePhyUshort(sc, 0x06, 0x97d9);
15744 MP_WritePhyUshort(sc, 0x06, 0x7900);
15745 MP_WritePhyUshort(sc, 0x06, 0x9e2b);
15746 MP_WritePhyUshort(sc, 0x06, 0x81dd);
15747 MP_WritePhyUshort(sc, 0x06, 0xbf85);
15748 MP_WritePhyUshort(sc, 0x06, 0xad02);
15749 MP_WritePhyUshort(sc, 0x06, 0x387d);
15750 MP_WritePhyUshort(sc, 0x06, 0xd101);
15751 MP_WritePhyUshort(sc, 0x06, 0xef02);
15752 MP_WritePhyUshort(sc, 0x06, 0x100c);
15753 MP_WritePhyUshort(sc, 0x06, 0x11b0);
15754 MP_WritePhyUshort(sc, 0x06, 0xfc0d);
15755 MP_WritePhyUshort(sc, 0x06, 0x11bf);
15756 MP_WritePhyUshort(sc, 0x06, 0x85aa);
15757 MP_WritePhyUshort(sc, 0x06, 0x0238);
15758 MP_WritePhyUshort(sc, 0x06, 0x7dd1);
15759 MP_WritePhyUshort(sc, 0x06, 0x00bf);
15760 MP_WritePhyUshort(sc, 0x06, 0x85aa);
15761 MP_WritePhyUshort(sc, 0x06, 0x0238);
15762 MP_WritePhyUshort(sc, 0x06, 0x7dee);
15763 MP_WritePhyUshort(sc, 0x06, 0x8ac2);
15764 MP_WritePhyUshort(sc, 0x06, 0x02ae);
15765 MP_WritePhyUshort(sc, 0x06, 0x0413);
15766 MP_WritePhyUshort(sc, 0x06, 0xa38b);
15767 MP_WritePhyUshort(sc, 0x06, 0xb4d3);
15768 MP_WritePhyUshort(sc, 0x06, 0x8012);
15769 MP_WritePhyUshort(sc, 0x06, 0x17a2);
15770 MP_WritePhyUshort(sc, 0x06, 0x04ad);
15771 MP_WritePhyUshort(sc, 0x06, 0xffef);
15772 MP_WritePhyUshort(sc, 0x06, 0x96fe);
15773 MP_WritePhyUshort(sc, 0x06, 0xfdfc);
15774 MP_WritePhyUshort(sc, 0x06, 0x04f8);
15775 MP_WritePhyUshort(sc, 0x06, 0xf9e0);
15776 MP_WritePhyUshort(sc, 0x06, 0x8b85);
15777 MP_WritePhyUshort(sc, 0x06, 0xad25);
15778 MP_WritePhyUshort(sc, 0x06, 0x48e0);
15779 MP_WritePhyUshort(sc, 0x06, 0x8a96);
15780 MP_WritePhyUshort(sc, 0x06, 0xe18a);
15781 MP_WritePhyUshort(sc, 0x06, 0x977c);
15782 MP_WritePhyUshort(sc, 0x06, 0x0000);
15783 MP_WritePhyUshort(sc, 0x06, 0x9e35);
15784 MP_WritePhyUshort(sc, 0x06, 0xee8a);
15785 MP_WritePhyUshort(sc, 0x06, 0x9600);
15786 MP_WritePhyUshort(sc, 0x06, 0xee8a);
15787 MP_WritePhyUshort(sc, 0x06, 0x9700);
15788 MP_WritePhyUshort(sc, 0x06, 0xe08a);
15789 MP_WritePhyUshort(sc, 0x06, 0xbee1);
15790 MP_WritePhyUshort(sc, 0x06, 0x8abf);
15791 MP_WritePhyUshort(sc, 0x06, 0xe28a);
15792 MP_WritePhyUshort(sc, 0x06, 0xc0e3);
15793 MP_WritePhyUshort(sc, 0x06, 0x8ac1);
15794 MP_WritePhyUshort(sc, 0x06, 0x0237);
15795 MP_WritePhyUshort(sc, 0x06, 0x74ad);
15796 MP_WritePhyUshort(sc, 0x06, 0x2012);
15797 MP_WritePhyUshort(sc, 0x06, 0xee8a);
15798 MP_WritePhyUshort(sc, 0x06, 0x9603);
15799 MP_WritePhyUshort(sc, 0x06, 0xee8a);
15800 MP_WritePhyUshort(sc, 0x06, 0x97b7);
15801 MP_WritePhyUshort(sc, 0x06, 0xee8a);
15802 MP_WritePhyUshort(sc, 0x06, 0xc000);
15803 MP_WritePhyUshort(sc, 0x06, 0xee8a);
15804 MP_WritePhyUshort(sc, 0x06, 0xc100);
15805 MP_WritePhyUshort(sc, 0x06, 0xae11);
15806 MP_WritePhyUshort(sc, 0x06, 0x15e6);
15807 MP_WritePhyUshort(sc, 0x06, 0x8ac0);
15808 MP_WritePhyUshort(sc, 0x06, 0xe78a);
15809 MP_WritePhyUshort(sc, 0x06, 0xc1ae);
15810 MP_WritePhyUshort(sc, 0x06, 0x08ee);
15811 MP_WritePhyUshort(sc, 0x06, 0x8ac0);
15812 MP_WritePhyUshort(sc, 0x06, 0x00ee);
15813 MP_WritePhyUshort(sc, 0x06, 0x8ac1);
15814 MP_WritePhyUshort(sc, 0x06, 0x00fd);
15815 MP_WritePhyUshort(sc, 0x06, 0xfc04);
15816 MP_WritePhyUshort(sc, 0x06, 0xae20);
15817 MP_WritePhyUshort(sc, 0x06, 0x0000);
15818 MP_WritePhyUshort(sc, 0x06, 0x0000);
15819 MP_WritePhyUshort(sc, 0x06, 0x0000);
15820 MP_WritePhyUshort(sc, 0x06, 0x0000);
15821 MP_WritePhyUshort(sc, 0x06, 0x0000);
15822 MP_WritePhyUshort(sc, 0x06, 0x0000);
15823 MP_WritePhyUshort(sc, 0x06, 0x0000);
15824 MP_WritePhyUshort(sc, 0x06, 0x0000);
15825 MP_WritePhyUshort(sc, 0x06, 0x0000);
15826 MP_WritePhyUshort(sc, 0x06, 0x0000);
15827 MP_WritePhyUshort(sc, 0x06, 0x0000);
15828 MP_WritePhyUshort(sc, 0x06, 0x0000);
15829 MP_WritePhyUshort(sc, 0x06, 0x0000);
15830 MP_WritePhyUshort(sc, 0x06, 0x0000);
15831 MP_WritePhyUshort(sc, 0x06, 0x0000);
15832 MP_WritePhyUshort(sc, 0x06, 0x0000);
15833 MP_WritePhyUshort(sc, 0x06, 0xf8fa);
15834 MP_WritePhyUshort(sc, 0x06, 0xef69);
15835 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
15836 MP_WritePhyUshort(sc, 0x06, 0x00e1);
15837 MP_WritePhyUshort(sc, 0x06, 0xe001);
15838 MP_WritePhyUshort(sc, 0x06, 0xad27);
15839 MP_WritePhyUshort(sc, 0x06, 0x32e0);
15840 MP_WritePhyUshort(sc, 0x06, 0x8b40);
15841 MP_WritePhyUshort(sc, 0x06, 0xf720);
15842 MP_WritePhyUshort(sc, 0x06, 0xe48b);
15843 MP_WritePhyUshort(sc, 0x06, 0x40bf);
15844 MP_WritePhyUshort(sc, 0x06, 0x3230);
15845 MP_WritePhyUshort(sc, 0x06, 0x0238);
15846 MP_WritePhyUshort(sc, 0x06, 0x50ad);
15847 MP_WritePhyUshort(sc, 0x06, 0x2821);
15848 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
15849 MP_WritePhyUshort(sc, 0x06, 0x20e1);
15850 MP_WritePhyUshort(sc, 0x06, 0xe021);
15851 MP_WritePhyUshort(sc, 0x06, 0xad20);
15852 MP_WritePhyUshort(sc, 0x06, 0x18e0);
15853 MP_WritePhyUshort(sc, 0x06, 0x8b40);
15854 MP_WritePhyUshort(sc, 0x06, 0xf620);
15855 MP_WritePhyUshort(sc, 0x06, 0xe48b);
15856 MP_WritePhyUshort(sc, 0x06, 0x40ee);
15857 MP_WritePhyUshort(sc, 0x06, 0x8b3b);
15858 MP_WritePhyUshort(sc, 0x06, 0xffe0);
15859 MP_WritePhyUshort(sc, 0x06, 0x8a8a);
15860 MP_WritePhyUshort(sc, 0x06, 0xe18a);
15861 MP_WritePhyUshort(sc, 0x06, 0x8be4);
15862 MP_WritePhyUshort(sc, 0x06, 0xe000);
15863 MP_WritePhyUshort(sc, 0x06, 0xe5e0);
15864 MP_WritePhyUshort(sc, 0x06, 0x01ef);
15865 MP_WritePhyUshort(sc, 0x06, 0x96fe);
15866 MP_WritePhyUshort(sc, 0x06, 0xfc04);
15867 MP_WritePhyUshort(sc, 0x06, 0xf8f9);
15868 MP_WritePhyUshort(sc, 0x06, 0xface);
15869 MP_WritePhyUshort(sc, 0x06, 0xfaef);
15870 MP_WritePhyUshort(sc, 0x06, 0x69fa);
15871 MP_WritePhyUshort(sc, 0x06, 0xd401);
15872 MP_WritePhyUshort(sc, 0x06, 0x55b4);
15873 MP_WritePhyUshort(sc, 0x06, 0xfebf);
15874 MP_WritePhyUshort(sc, 0x06, 0x1c1e);
15875 MP_WritePhyUshort(sc, 0x06, 0x0238);
15876 MP_WritePhyUshort(sc, 0x06, 0x50ac);
15877 MP_WritePhyUshort(sc, 0x06, 0x280b);
15878 MP_WritePhyUshort(sc, 0x06, 0xbf1c);
15879 MP_WritePhyUshort(sc, 0x06, 0x1b02);
15880 MP_WritePhyUshort(sc, 0x06, 0x3850);
15881 MP_WritePhyUshort(sc, 0x06, 0xac28);
15882 MP_WritePhyUshort(sc, 0x06, 0x49ae);
15883 MP_WritePhyUshort(sc, 0x06, 0x64bf);
15884 MP_WritePhyUshort(sc, 0x06, 0x1c1b);
15885 MP_WritePhyUshort(sc, 0x06, 0x0238);
15886 MP_WritePhyUshort(sc, 0x06, 0x50ac);
15887 MP_WritePhyUshort(sc, 0x06, 0x285b);
15888 MP_WritePhyUshort(sc, 0x06, 0xd000);
15889 MP_WritePhyUshort(sc, 0x06, 0x0284);
15890 MP_WritePhyUshort(sc, 0x06, 0xcaac);
15891 MP_WritePhyUshort(sc, 0x06, 0x2105);
15892 MP_WritePhyUshort(sc, 0x06, 0xac22);
15893 MP_WritePhyUshort(sc, 0x06, 0x02ae);
15894 MP_WritePhyUshort(sc, 0x06, 0x4ebf);
15895 MP_WritePhyUshort(sc, 0x06, 0xe0c4);
15896 MP_WritePhyUshort(sc, 0x06, 0xbe85);
15897 MP_WritePhyUshort(sc, 0x06, 0xf6d2);
15898 MP_WritePhyUshort(sc, 0x06, 0x04d8);
15899 MP_WritePhyUshort(sc, 0x06, 0x19d9);
15900 MP_WritePhyUshort(sc, 0x06, 0x1907);
15901 MP_WritePhyUshort(sc, 0x06, 0xdc19);
15902 MP_WritePhyUshort(sc, 0x06, 0xdd19);
15903 MP_WritePhyUshort(sc, 0x06, 0x0789);
15904 MP_WritePhyUshort(sc, 0x06, 0x89ef);
15905 MP_WritePhyUshort(sc, 0x06, 0x645e);
15906 MP_WritePhyUshort(sc, 0x06, 0x07ff);
15907 MP_WritePhyUshort(sc, 0x06, 0x0d65);
15908 MP_WritePhyUshort(sc, 0x06, 0x5cf8);
15909 MP_WritePhyUshort(sc, 0x06, 0x001e);
15910 MP_WritePhyUshort(sc, 0x06, 0x46dc);
15911 MP_WritePhyUshort(sc, 0x06, 0x19dd);
15912 MP_WritePhyUshort(sc, 0x06, 0x19b2);
15913 MP_WritePhyUshort(sc, 0x06, 0xe2d4);
15914 MP_WritePhyUshort(sc, 0x06, 0x0001);
15915 MP_WritePhyUshort(sc, 0x06, 0xbf1c);
15916 MP_WritePhyUshort(sc, 0x06, 0x1b02);
15917 MP_WritePhyUshort(sc, 0x06, 0x387d);
15918 MP_WritePhyUshort(sc, 0x06, 0xae1d);
15919 MP_WritePhyUshort(sc, 0x06, 0xbee0);
15920 MP_WritePhyUshort(sc, 0x06, 0xc4bf);
15921 MP_WritePhyUshort(sc, 0x06, 0x85f6);
15922 MP_WritePhyUshort(sc, 0x06, 0xd204);
15923 MP_WritePhyUshort(sc, 0x06, 0xd819);
15924 MP_WritePhyUshort(sc, 0x06, 0xd919);
15925 MP_WritePhyUshort(sc, 0x06, 0x07dc);
15926 MP_WritePhyUshort(sc, 0x06, 0x19dd);
15927 MP_WritePhyUshort(sc, 0x06, 0x1907);
15928 MP_WritePhyUshort(sc, 0x06, 0xb2f4);
15929 MP_WritePhyUshort(sc, 0x06, 0xd400);
15930 MP_WritePhyUshort(sc, 0x06, 0x00bf);
15931 MP_WritePhyUshort(sc, 0x06, 0x1c1b);
15932 MP_WritePhyUshort(sc, 0x06, 0x0238);
15933 MP_WritePhyUshort(sc, 0x06, 0x7dfe);
15934 MP_WritePhyUshort(sc, 0x06, 0xef96);
15935 MP_WritePhyUshort(sc, 0x06, 0xfec6);
15936 MP_WritePhyUshort(sc, 0x06, 0xfefd);
15937 MP_WritePhyUshort(sc, 0x06, 0xfc05);
15938 MP_WritePhyUshort(sc, 0x06, 0xf9e2);
15939 MP_WritePhyUshort(sc, 0x06, 0xe0ea);
15940 MP_WritePhyUshort(sc, 0x06, 0xe3e0);
15941 MP_WritePhyUshort(sc, 0x06, 0xeb5a);
15942 MP_WritePhyUshort(sc, 0x06, 0x070c);
15943 MP_WritePhyUshort(sc, 0x06, 0x031e);
15944 MP_WritePhyUshort(sc, 0x06, 0x20e6);
15945 MP_WritePhyUshort(sc, 0x06, 0xe0ea);
15946 MP_WritePhyUshort(sc, 0x06, 0xe7e0);
15947 MP_WritePhyUshort(sc, 0x06, 0xebe0);
15948 MP_WritePhyUshort(sc, 0x06, 0xe0fc);
15949 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
15950 MP_WritePhyUshort(sc, 0x06, 0xfdfd);
15951 MP_WritePhyUshort(sc, 0x06, 0x04f8);
15952 MP_WritePhyUshort(sc, 0x06, 0xfaef);
15953 MP_WritePhyUshort(sc, 0x06, 0x69e0);
15954 MP_WritePhyUshort(sc, 0x06, 0x8b80);
15955 MP_WritePhyUshort(sc, 0x06, 0xad27);
15956 MP_WritePhyUshort(sc, 0x06, 0x22bf);
15957 MP_WritePhyUshort(sc, 0x06, 0x4616);
15958 MP_WritePhyUshort(sc, 0x06, 0x0238);
15959 MP_WritePhyUshort(sc, 0x06, 0x50e0);
15960 MP_WritePhyUshort(sc, 0x06, 0x8b44);
15961 MP_WritePhyUshort(sc, 0x06, 0x1f01);
15962 MP_WritePhyUshort(sc, 0x06, 0x9e15);
15963 MP_WritePhyUshort(sc, 0x06, 0xe58b);
15964 MP_WritePhyUshort(sc, 0x06, 0x44ad);
15965 MP_WritePhyUshort(sc, 0x06, 0x2907);
15966 MP_WritePhyUshort(sc, 0x06, 0xac28);
15967 MP_WritePhyUshort(sc, 0x06, 0x04d1);
15968 MP_WritePhyUshort(sc, 0x06, 0x01ae);
15969 MP_WritePhyUshort(sc, 0x06, 0x02d1);
15970 MP_WritePhyUshort(sc, 0x06, 0x00bf);
15971 MP_WritePhyUshort(sc, 0x06, 0x85b0);
15972 MP_WritePhyUshort(sc, 0x06, 0x0238);
15973 MP_WritePhyUshort(sc, 0x06, 0x7def);
15974 MP_WritePhyUshort(sc, 0x06, 0x96fe);
15975 MP_WritePhyUshort(sc, 0x06, 0xfc04);
15976 MP_WritePhyUshort(sc, 0x06, 0xf8e0);
15977 MP_WritePhyUshort(sc, 0x06, 0x8b85);
15978 MP_WritePhyUshort(sc, 0x06, 0xad26);
15979 MP_WritePhyUshort(sc, 0x06, 0x30e0);
15980 MP_WritePhyUshort(sc, 0x06, 0xe036);
15981 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
15982 MP_WritePhyUshort(sc, 0x06, 0x37e1);
15983 MP_WritePhyUshort(sc, 0x06, 0x8b3f);
15984 MP_WritePhyUshort(sc, 0x06, 0x1f10);
15985 MP_WritePhyUshort(sc, 0x06, 0x9e23);
15986 MP_WritePhyUshort(sc, 0x06, 0xe48b);
15987 MP_WritePhyUshort(sc, 0x06, 0x3fac);
15988 MP_WritePhyUshort(sc, 0x06, 0x200b);
15989 MP_WritePhyUshort(sc, 0x06, 0xac21);
15990 MP_WritePhyUshort(sc, 0x06, 0x0dac);
15991 MP_WritePhyUshort(sc, 0x06, 0x250f);
15992 MP_WritePhyUshort(sc, 0x06, 0xac27);
15993 MP_WritePhyUshort(sc, 0x06, 0x11ae);
15994 MP_WritePhyUshort(sc, 0x06, 0x1202);
15995 MP_WritePhyUshort(sc, 0x06, 0x2c47);
15996 MP_WritePhyUshort(sc, 0x06, 0xae0d);
15997 MP_WritePhyUshort(sc, 0x06, 0x0285);
15998 MP_WritePhyUshort(sc, 0x06, 0x4fae);
15999 MP_WritePhyUshort(sc, 0x06, 0x0802);
16000 MP_WritePhyUshort(sc, 0x06, 0x2c69);
16001 MP_WritePhyUshort(sc, 0x06, 0xae03);
16002 MP_WritePhyUshort(sc, 0x06, 0x022c);
16003 MP_WritePhyUshort(sc, 0x06, 0x7cfc);
16004 MP_WritePhyUshort(sc, 0x06, 0x04f8);
16005 MP_WritePhyUshort(sc, 0x06, 0xfaef);
16006 MP_WritePhyUshort(sc, 0x06, 0x6902);
16007 MP_WritePhyUshort(sc, 0x06, 0x856c);
16008 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
16009 MP_WritePhyUshort(sc, 0x06, 0x14e1);
16010 MP_WritePhyUshort(sc, 0x06, 0xe015);
16011 MP_WritePhyUshort(sc, 0x06, 0xad26);
16012 MP_WritePhyUshort(sc, 0x06, 0x08d1);
16013 MP_WritePhyUshort(sc, 0x06, 0x1ebf);
16014 MP_WritePhyUshort(sc, 0x06, 0x2cd9);
16015 MP_WritePhyUshort(sc, 0x06, 0x0238);
16016 MP_WritePhyUshort(sc, 0x06, 0x7def);
16017 MP_WritePhyUshort(sc, 0x06, 0x96fe);
16018 MP_WritePhyUshort(sc, 0x06, 0xfc04);
16019 MP_WritePhyUshort(sc, 0x06, 0xf8e0);
16020 MP_WritePhyUshort(sc, 0x06, 0x8b85);
16021 MP_WritePhyUshort(sc, 0x06, 0xad27);
16022 MP_WritePhyUshort(sc, 0x06, 0x2fd0);
16023 MP_WritePhyUshort(sc, 0x06, 0x0b02);
16024 MP_WritePhyUshort(sc, 0x06, 0x3682);
16025 MP_WritePhyUshort(sc, 0x06, 0x5882);
16026 MP_WritePhyUshort(sc, 0x06, 0x7882);
16027 MP_WritePhyUshort(sc, 0x06, 0x9f24);
16028 MP_WritePhyUshort(sc, 0x06, 0xe08b);
16029 MP_WritePhyUshort(sc, 0x06, 0x32e1);
16030 MP_WritePhyUshort(sc, 0x06, 0x8b33);
16031 MP_WritePhyUshort(sc, 0x06, 0x1f10);
16032 MP_WritePhyUshort(sc, 0x06, 0x9e1a);
16033 MP_WritePhyUshort(sc, 0x06, 0x10e4);
16034 MP_WritePhyUshort(sc, 0x06, 0x8b32);
16035 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
16036 MP_WritePhyUshort(sc, 0x06, 0x28e1);
16037 MP_WritePhyUshort(sc, 0x06, 0xe029);
16038 MP_WritePhyUshort(sc, 0x06, 0xf72c);
16039 MP_WritePhyUshort(sc, 0x06, 0xe4e0);
16040 MP_WritePhyUshort(sc, 0x06, 0x28e5);
16041 MP_WritePhyUshort(sc, 0x06, 0xe029);
16042 MP_WritePhyUshort(sc, 0x06, 0xf62c);
16043 MP_WritePhyUshort(sc, 0x06, 0xe4e0);
16044 MP_WritePhyUshort(sc, 0x06, 0x28e5);
16045 MP_WritePhyUshort(sc, 0x06, 0xe029);
16046 MP_WritePhyUshort(sc, 0x06, 0xfc04);
16047 MP_WritePhyUshort(sc, 0x06, 0x00e1);
16048 MP_WritePhyUshort(sc, 0x06, 0x4077);
16049 MP_WritePhyUshort(sc, 0x06, 0xe140);
16050 MP_WritePhyUshort(sc, 0x06, 0x52e0);
16051 MP_WritePhyUshort(sc, 0x06, 0xeed9);
16052 MP_WritePhyUshort(sc, 0x06, 0xe04c);
16053 MP_WritePhyUshort(sc, 0x06, 0xbbe0);
16054 MP_WritePhyUshort(sc, 0x06, 0x2a00);
16055 MP_WritePhyUshort(sc, 0x05, 0xe142);
16056 Data = MP_ReadPhyUshort(sc, 0x06);
16057 Data |= BIT_0;
16058 MP_WritePhyUshort(sc,0x06, Data);
16059 MP_WritePhyUshort(sc, 0x05, 0xe140);
16060 Data = MP_ReadPhyUshort(sc, 0x06);
16061 Data |= BIT_0;
16062 MP_WritePhyUshort(sc,0x06, Data);
16063 MP_WritePhyUshort(sc, 0x1f, 0x0000);
16064 MP_WritePhyUshort(sc,0x1f, 0x0005);
16065 for (i = 0; i < 200; i++) {
16066 DELAY(100);
16067 Data = MP_ReadPhyUshort(sc, 0x00);
16068 if (Data & BIT_7)
16069 break;
16070 }
16071 MP_WritePhyUshort(sc, 0x1f, 0x0007);
16072 MP_WritePhyUshort(sc, 0x1e, 0x0023);
16073 Data = MP_ReadPhyUshort(sc, 0x17);
16074 Data |= BIT_1;
16075 MP_WritePhyUshort(sc, 0x17, Data);
16076 MP_WritePhyUshort(sc, 0x1f, 0x0000);
16077 MP_WritePhyUshort(sc, 0x1f, 0x0003);
16078 MP_WritePhyUshort(sc, 0x09, 0xA20F);
16079 MP_WritePhyUshort(sc, 0x1f, 0x0000);
16080 MP_WritePhyUshort(sc, 0x1f, 0x0003);
16081 MP_WritePhyUshort(sc, 0x01, 0x328A);
16082 MP_WritePhyUshort(sc, 0x1f, 0x0000);
16083 MP_WritePhyUshort(sc, 0x1f, 0x0003);
16084 Data = MP_ReadPhyUshort(sc, 0x19);
16085 Data &= ~BIT_0;
16086 MP_WritePhyUshort(sc, 0x19, Data);
16087 Data = MP_ReadPhyUshort(sc, 0x10);
16088 Data &= ~BIT_10;
16089 MP_WritePhyUshort(sc, 0x10, Data);
16090 MP_WritePhyUshort(sc, 0x1f, 0x0000);
16091 MP_WritePhyUshort(sc, 0x00, 0x9200);
16092
16093 MP_WritePhyUshort(sc, 0x1F, 0x0005);
16094 MP_WritePhyUshort(sc, 0x05, 0x8B80);
16095 Data = MP_ReadPhyUshort(sc, 0x06);
16096 Data |= BIT_2 | BIT_1;
16097 MP_WritePhyUshort(sc, 0x06, Data);
16098 MP_WritePhyUshort(sc, 0x1f, 0x0000);
16099
16100 MP_WritePhyUshort(sc, 0x1F, 0x0007);
16101 MP_WritePhyUshort(sc, 0x1E, 0x002D);
16102 Data = MP_ReadPhyUshort(sc, 0x18);
16103 Data |= BIT_4;
16104 MP_WritePhyUshort(sc, 0x18, Data);
16105 MP_WritePhyUshort(sc, 0x1f, 0x0000);
16106 Data = MP_ReadPhyUshort(sc, 0x14);
16107 Data |= BIT_15;
16108 MP_WritePhyUshort(sc, 0x14, Data);
16109
16110 MP_WritePhyUshort(sc, 0x1F, 0x0005);
16111 MP_WritePhyUshort(sc, 0x05, 0x8B86);
16112 Data = MP_ReadPhyUshort(sc, 0x06);
16113 Data |= BIT_0;
16114 MP_WritePhyUshort(sc, 0x06, Data);
16115 MP_WritePhyUshort(sc, 0x1f, 0x0000);
16116
16117 MP_WritePhyUshort(sc, 0x1F, 0x0005);
16118 MP_WritePhyUshort(sc, 0x05, 0x8B85);
16119 Data = MP_ReadPhyUshort(sc, 0x06);
16120 Data |= BIT_14;
16121 MP_WritePhyUshort(sc, 0x06, Data);
16122 MP_WritePhyUshort(sc, 0x1f, 0x0000);
16123
16124 MP_WritePhyUshort(sc, 0x1F, 0x0003);
16125 MP_WritePhyUshort(sc, 0x09, 0xA20F);
16126 MP_WritePhyUshort(sc, 0x1F, 0x0000);
16127
16128 MP_WritePhyUshort(sc, 0x1F, 0x0005);
16129 MP_WritePhyUshort(sc, 0x05, 0x8B55);
16130 MP_WritePhyUshort(sc, 0x06, 0x0000);
16131 MP_WritePhyUshort(sc, 0x05, 0x8B5E);
16132 MP_WritePhyUshort(sc, 0x06, 0x0000);
16133 MP_WritePhyUshort(sc, 0x05, 0x8B67);
16134 MP_WritePhyUshort(sc, 0x06, 0x0000);
16135 MP_WritePhyUshort(sc, 0x05, 0x8B70);
16136 MP_WritePhyUshort(sc, 0x06, 0x0000);
16137 MP_WritePhyUshort(sc, 0x1f, 0x0000);
16138 MP_WritePhyUshort(sc, 0x1F, 0x0007);
16139 MP_WritePhyUshort(sc, 0x1E, 0x0078);
16140 MP_WritePhyUshort(sc, 0x17, 0x0000);
16141 MP_WritePhyUshort(sc, 0x19, 0x00FB);
16142 MP_WritePhyUshort(sc, 0x1f, 0x0000);
16143
16144 MP_WritePhyUshort(sc, 0x1F, 0x0005);
16145 MP_WritePhyUshort(sc, 0x05, 0x8B79);
16146 MP_WritePhyUshort(sc, 0x06, 0xAA00);
16147 MP_WritePhyUshort(sc, 0x1f, 0x0000);
16148
16149 MP_WritePhyUshort(sc, 0x1F, 0x0003);
16150 MP_WritePhyUshort(sc, 0x01, 0x328A);
16151 MP_WritePhyUshort(sc, 0x1F, 0x0000);
16152
16153 MP_WritePhyUshort(sc, 0x1F, 0x0005);
16154 MP_WritePhyUshort(sc, 0x05, 0x8B54);
16155 Data = MP_ReadPhyUshort(sc, 0x06);
16156 Data &= ~BIT_11;
16157 MP_WritePhyUshort(sc, 0x06, Data);
16158 MP_WritePhyUshort(sc, 0x05, 0x8B5D);
16159 Data = MP_ReadPhyUshort(sc, 0x06);
16160 Data &= ~BIT_11;
16161 MP_WritePhyUshort(sc, 0x06, Data);
16162 MP_WritePhyUshort(sc, 0x05, 0x8A7C);
16163 Data = MP_ReadPhyUshort(sc, 0x06);
16164 Data &= ~BIT_8;
16165 MP_WritePhyUshort(sc, 0x06, Data);
16166 MP_WritePhyUshort(sc, 0x05, 0x8A7F);
16167 Data = MP_ReadPhyUshort(sc, 0x06);
16168 Data |= BIT_8;
16169 MP_WritePhyUshort(sc, 0x06, Data);
16170 MP_WritePhyUshort(sc, 0x05, 0x8A82);
16171 Data = MP_ReadPhyUshort(sc, 0x06);
16172 Data &= ~BIT_8;
16173 MP_WritePhyUshort(sc, 0x06, Data);
16174 MP_WritePhyUshort(sc, 0x05, 0x8A85);
16175 Data = MP_ReadPhyUshort(sc, 0x06);
16176 Data &= ~BIT_8;
16177 MP_WritePhyUshort(sc, 0x06, Data);
16178 MP_WritePhyUshort(sc, 0x05, 0x8A88);
16179 Data = MP_ReadPhyUshort(sc, 0x06);
16180 Data &= ~BIT_8;
16181 MP_WritePhyUshort(sc, 0x06, Data);
16182 MP_WritePhyUshort(sc, 0x1F, 0x0000);
16183
16184 MP_WritePhyUshort(sc, 0x1F, 0x0005);
16185 MP_WritePhyUshort(sc, 0x05, 0x8B85);
16186 Data = MP_ReadPhyUshort(sc, 0x06);
16187 Data |= BIT_15;
16188 MP_WritePhyUshort(sc, 0x06, Data);
16189 MP_WritePhyUshort(sc, 0x1f, 0x0000);
16190
16191 MP_WritePhyUshort(sc, 0x1f, 0x0003);
16192 Data = MP_ReadPhyUshort(sc, 0x19);
16193 Data &= ~BIT_0;
16194 MP_WritePhyUshort(sc, 0x19, Data);
16195 Data = MP_ReadPhyUshort(sc, 0x10);
16196 Data &= ~BIT_10;
16197 MP_WritePhyUshort(sc, 0x10, Data);
16198 MP_WritePhyUshort(sc, 0x1f, 0x0000);
16199 } else if (sc->re_type == MACFG_51) {
16200 MP_WritePhyUshort(sc,0x1f, 0x0000);
16201 MP_WritePhyUshort(sc,0x00, 0x1800);
16202 Data = MP_ReadPhyUshort(sc, 0x15);
16203 Data &= ~(BIT_12);
16204 MP_WritePhyUshort(sc,0x15, Data);
16205 MP_WritePhyUshort(sc,0x00, 0x9800);
16206 MP_WritePhyUshort(sc,0x1f, 0x0007);
16207 MP_WritePhyUshort(sc,0x1e, 0x002f);
16208 for (i = 0; i < 1000; i++) {
16209 DELAY(100);
16210 Data = MP_ReadPhyUshort(sc, 0x1c);
16211 if (Data & BIT_7)
16212 break;
16213 }
16214 MP_WritePhyUshort(sc, 0x1f, 0x0007);
16215 MP_WritePhyUshort(sc, 0x1e, 0x0023);
16216 MP_WritePhyUshort(sc, 0x16, 0x0306);
16217 MP_WritePhyUshort(sc, 0x16, 0x0307);
16218 MP_WritePhyUshort(sc, 0x15, 0x0098);
16219 MP_WritePhyUshort(sc, 0x19, 0x7c0b);
16220 MP_WritePhyUshort(sc, 0x15, 0x0099);
16221 MP_WritePhyUshort(sc, 0x19, 0x6c0b);
16222 MP_WritePhyUshort(sc, 0x15, 0x00eb);
16223 MP_WritePhyUshort(sc, 0x19, 0x6c0b);
16224 MP_WritePhyUshort(sc, 0x15, 0x00f8);
16225 MP_WritePhyUshort(sc, 0x19, 0x6f0b);
16226 MP_WritePhyUshort(sc, 0x15, 0x00fe);
16227 MP_WritePhyUshort(sc, 0x19, 0x6f0f);
16228 MP_WritePhyUshort(sc, 0x15, 0x00db);
16229 MP_WritePhyUshort(sc, 0x19, 0x6f09);
16230 MP_WritePhyUshort(sc, 0x15, 0x00dc);
16231 MP_WritePhyUshort(sc, 0x19, 0xaefd);
16232 MP_WritePhyUshort(sc, 0x15, 0x00dd);
16233 MP_WritePhyUshort(sc, 0x19, 0x6f0b);
16234 MP_WritePhyUshort(sc, 0x15, 0x00de);
16235 MP_WritePhyUshort(sc, 0x19, 0xc60b);
16236 MP_WritePhyUshort(sc, 0x15, 0x00df);
16237 MP_WritePhyUshort(sc, 0x19, 0x00fa);
16238 MP_WritePhyUshort(sc, 0x15, 0x00e0);
16239 MP_WritePhyUshort(sc, 0x19, 0x30e1);
16240 MP_WritePhyUshort(sc, 0x15, 0x020c);
16241 MP_WritePhyUshort(sc, 0x19, 0x3224);
16242 MP_WritePhyUshort(sc, 0x15, 0x020e);
16243 MP_WritePhyUshort(sc, 0x19, 0x9813);
16244 MP_WritePhyUshort(sc, 0x15, 0x020f);
16245 MP_WritePhyUshort(sc, 0x19, 0x7801);
16246 MP_WritePhyUshort(sc, 0x15, 0x0210);
16247 MP_WritePhyUshort(sc, 0x19, 0x930f);
16248 MP_WritePhyUshort(sc, 0x15, 0x0211);
16249 MP_WritePhyUshort(sc, 0x19, 0x9206);
16250 MP_WritePhyUshort(sc, 0x15, 0x0212);
16251 MP_WritePhyUshort(sc, 0x19, 0x4002);
16252 MP_WritePhyUshort(sc, 0x15, 0x0213);
16253 MP_WritePhyUshort(sc, 0x19, 0x7800);
16254 MP_WritePhyUshort(sc, 0x15, 0x0214);
16255 MP_WritePhyUshort(sc, 0x19, 0x588f);
16256 MP_WritePhyUshort(sc, 0x15, 0x0215);
16257 MP_WritePhyUshort(sc, 0x19, 0x5520);
16258 MP_WritePhyUshort(sc, 0x15, 0x0216);
16259 MP_WritePhyUshort(sc, 0x19, 0x3224);
16260 MP_WritePhyUshort(sc, 0x15, 0x0217);
16261 MP_WritePhyUshort(sc, 0x19, 0x4002);
16262 MP_WritePhyUshort(sc, 0x15, 0x0218);
16263 MP_WritePhyUshort(sc, 0x19, 0x7800);
16264 MP_WritePhyUshort(sc, 0x15, 0x0219);
16265 MP_WritePhyUshort(sc, 0x19, 0x588d);
16266 MP_WritePhyUshort(sc, 0x15, 0x021a);
16267 MP_WritePhyUshort(sc, 0x19, 0x5540);
16268 MP_WritePhyUshort(sc, 0x15, 0x021b);
16269 MP_WritePhyUshort(sc, 0x19, 0x9e03);
16270 MP_WritePhyUshort(sc, 0x15, 0x021c);
16271 MP_WritePhyUshort(sc, 0x19, 0x7c40);
16272 MP_WritePhyUshort(sc, 0x15, 0x021d);
16273 MP_WritePhyUshort(sc, 0x19, 0x6840);
16274 MP_WritePhyUshort(sc, 0x15, 0x021e);
16275 MP_WritePhyUshort(sc, 0x19, 0x3224);
16276 MP_WritePhyUshort(sc, 0x15, 0x021f);
16277 MP_WritePhyUshort(sc, 0x19, 0x4002);
16278 MP_WritePhyUshort(sc, 0x15, 0x0220);
16279 MP_WritePhyUshort(sc, 0x19, 0x3224);
16280 MP_WritePhyUshort(sc, 0x15, 0x0221);
16281 MP_WritePhyUshort(sc, 0x19, 0x9e03);
16282 MP_WritePhyUshort(sc, 0x15, 0x0222);
16283 MP_WritePhyUshort(sc, 0x19, 0x7c40);
16284 MP_WritePhyUshort(sc, 0x15, 0x0223);
16285 MP_WritePhyUshort(sc, 0x19, 0x6840);
16286 MP_WritePhyUshort(sc, 0x15, 0x0224);
16287 MP_WritePhyUshort(sc, 0x19, 0x7800);
16288 MP_WritePhyUshort(sc, 0x15, 0x0225);
16289 MP_WritePhyUshort(sc, 0x19, 0x3231);
16290 MP_WritePhyUshort(sc, 0x15, 0x0000);
16291 MP_WritePhyUshort(sc, 0x16, 0x0306);
16292 MP_WritePhyUshort(sc, 0x16, 0x0300);
16293 MP_WritePhyUshort(sc, 0x1f, 0x0000);
16294 MP_WritePhyUshort(sc, 0x1f, 0x0005);
16295 MP_WritePhyUshort(sc, 0x05, 0xfff6);
16296 MP_WritePhyUshort(sc, 0x06, 0x0080);
16297 MP_WritePhyUshort(sc, 0x05, 0x8000);
16298 MP_WritePhyUshort(sc, 0x06, 0x0280);
16299 MP_WritePhyUshort(sc, 0x06, 0x48f7);
16300 MP_WritePhyUshort(sc, 0x06, 0x00e0);
16301 MP_WritePhyUshort(sc, 0x06, 0xfff7);
16302 MP_WritePhyUshort(sc, 0x06, 0xa080);
16303 MP_WritePhyUshort(sc, 0x06, 0x02ae);
16304 MP_WritePhyUshort(sc, 0x06, 0xf602);
16305 MP_WritePhyUshort(sc, 0x06, 0x011b);
16306 MP_WritePhyUshort(sc, 0x06, 0x0201);
16307 MP_WritePhyUshort(sc, 0x06, 0x2802);
16308 MP_WritePhyUshort(sc, 0x06, 0x0135);
16309 MP_WritePhyUshort(sc, 0x06, 0x0201);
16310 MP_WritePhyUshort(sc, 0x06, 0x4502);
16311 MP_WritePhyUshort(sc, 0x06, 0x015f);
16312 MP_WritePhyUshort(sc, 0x06, 0x0280);
16313 MP_WritePhyUshort(sc, 0x06, 0x6b02);
16314 MP_WritePhyUshort(sc, 0x06, 0x80e5);
16315 MP_WritePhyUshort(sc, 0x06, 0xe08b);
16316 MP_WritePhyUshort(sc, 0x06, 0x88e1);
16317 MP_WritePhyUshort(sc, 0x06, 0x8b89);
16318 MP_WritePhyUshort(sc, 0x06, 0x1e01);
16319 MP_WritePhyUshort(sc, 0x06, 0xe18b);
16320 MP_WritePhyUshort(sc, 0x06, 0x8a1e);
16321 MP_WritePhyUshort(sc, 0x06, 0x01e1);
16322 MP_WritePhyUshort(sc, 0x06, 0x8b8b);
16323 MP_WritePhyUshort(sc, 0x06, 0x1e01);
16324 MP_WritePhyUshort(sc, 0x06, 0xe18b);
16325 MP_WritePhyUshort(sc, 0x06, 0x8c1e);
16326 MP_WritePhyUshort(sc, 0x06, 0x01e1);
16327 MP_WritePhyUshort(sc, 0x06, 0x8b8d);
16328 MP_WritePhyUshort(sc, 0x06, 0x1e01);
16329 MP_WritePhyUshort(sc, 0x06, 0xe18b);
16330 MP_WritePhyUshort(sc, 0x06, 0x8e1e);
16331 MP_WritePhyUshort(sc, 0x06, 0x01a0);
16332 MP_WritePhyUshort(sc, 0x06, 0x00c7);
16333 MP_WritePhyUshort(sc, 0x06, 0xaebb);
16334 MP_WritePhyUshort(sc, 0x06, 0xbf8b);
16335 MP_WritePhyUshort(sc, 0x06, 0x88ec);
16336 MP_WritePhyUshort(sc, 0x06, 0x0019);
16337 MP_WritePhyUshort(sc, 0x06, 0xa98b);
16338 MP_WritePhyUshort(sc, 0x06, 0x90f9);
16339 MP_WritePhyUshort(sc, 0x06, 0xeeff);
16340 MP_WritePhyUshort(sc, 0x06, 0xf600);
16341 MP_WritePhyUshort(sc, 0x06, 0xeeff);
16342 MP_WritePhyUshort(sc, 0x06, 0xf7fe);
16343 MP_WritePhyUshort(sc, 0x06, 0xd100);
16344 MP_WritePhyUshort(sc, 0x06, 0xbf81);
16345 MP_WritePhyUshort(sc, 0x06, 0x9802);
16346 MP_WritePhyUshort(sc, 0x06, 0x39f3);
16347 MP_WritePhyUshort(sc, 0x06, 0xd101);
16348 MP_WritePhyUshort(sc, 0x06, 0xbf81);
16349 MP_WritePhyUshort(sc, 0x06, 0x9b02);
16350 MP_WritePhyUshort(sc, 0x06, 0x39f3);
16351 MP_WritePhyUshort(sc, 0x06, 0x04f8);
16352 MP_WritePhyUshort(sc, 0x06, 0xe08b);
16353 MP_WritePhyUshort(sc, 0x06, 0x8dad);
16354 MP_WritePhyUshort(sc, 0x06, 0x2014);
16355 MP_WritePhyUshort(sc, 0x06, 0xee8b);
16356 MP_WritePhyUshort(sc, 0x06, 0x8d00);
16357 MP_WritePhyUshort(sc, 0x06, 0xe08a);
16358 MP_WritePhyUshort(sc, 0x06, 0x5a78);
16359 MP_WritePhyUshort(sc, 0x06, 0x039e);
16360 MP_WritePhyUshort(sc, 0x06, 0x0902);
16361 MP_WritePhyUshort(sc, 0x06, 0x05fc);
16362 MP_WritePhyUshort(sc, 0x06, 0x0280);
16363 MP_WritePhyUshort(sc, 0x06, 0x8802);
16364 MP_WritePhyUshort(sc, 0x06, 0x32dd);
16365 MP_WritePhyUshort(sc, 0x06, 0xfc04);
16366 MP_WritePhyUshort(sc, 0x06, 0xf8f9);
16367 MP_WritePhyUshort(sc, 0x06, 0xe08b);
16368 MP_WritePhyUshort(sc, 0x06, 0x81ac);
16369 MP_WritePhyUshort(sc, 0x06, 0x261a);
16370 MP_WritePhyUshort(sc, 0x06, 0xe08b);
16371 MP_WritePhyUshort(sc, 0x06, 0x81ac);
16372 MP_WritePhyUshort(sc, 0x06, 0x2114);
16373 MP_WritePhyUshort(sc, 0x06, 0xe08b);
16374 MP_WritePhyUshort(sc, 0x06, 0x85ac);
16375 MP_WritePhyUshort(sc, 0x06, 0x200e);
16376 MP_WritePhyUshort(sc, 0x06, 0xe08b);
16377 MP_WritePhyUshort(sc, 0x06, 0x85ac);
16378 MP_WritePhyUshort(sc, 0x06, 0x2308);
16379 MP_WritePhyUshort(sc, 0x06, 0xe08b);
16380 MP_WritePhyUshort(sc, 0x06, 0x87ac);
16381 MP_WritePhyUshort(sc, 0x06, 0x2402);
16382 MP_WritePhyUshort(sc, 0x06, 0xae38);
16383 MP_WritePhyUshort(sc, 0x06, 0x021a);
16384 MP_WritePhyUshort(sc, 0x06, 0xd6ee);
16385 MP_WritePhyUshort(sc, 0x06, 0xe41c);
16386 MP_WritePhyUshort(sc, 0x06, 0x04ee);
16387 MP_WritePhyUshort(sc, 0x06, 0xe41d);
16388 MP_WritePhyUshort(sc, 0x06, 0x04e2);
16389 MP_WritePhyUshort(sc, 0x06, 0xe07c);
16390 MP_WritePhyUshort(sc, 0x06, 0xe3e0);
16391 MP_WritePhyUshort(sc, 0x06, 0x7de0);
16392 MP_WritePhyUshort(sc, 0x06, 0xe038);
16393 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
16394 MP_WritePhyUshort(sc, 0x06, 0x39ad);
16395 MP_WritePhyUshort(sc, 0x06, 0x2e1b);
16396 MP_WritePhyUshort(sc, 0x06, 0xad39);
16397 MP_WritePhyUshort(sc, 0x06, 0x0dd1);
16398 MP_WritePhyUshort(sc, 0x06, 0x01bf);
16399 MP_WritePhyUshort(sc, 0x06, 0x22c8);
16400 MP_WritePhyUshort(sc, 0x06, 0x0239);
16401 MP_WritePhyUshort(sc, 0x06, 0xf302);
16402 MP_WritePhyUshort(sc, 0x06, 0x21f0);
16403 MP_WritePhyUshort(sc, 0x06, 0xae0b);
16404 MP_WritePhyUshort(sc, 0x06, 0xac38);
16405 MP_WritePhyUshort(sc, 0x06, 0x02ae);
16406 MP_WritePhyUshort(sc, 0x06, 0x0602);
16407 MP_WritePhyUshort(sc, 0x06, 0x222d);
16408 MP_WritePhyUshort(sc, 0x06, 0x0222);
16409 MP_WritePhyUshort(sc, 0x06, 0x7202);
16410 MP_WritePhyUshort(sc, 0x06, 0x1ae7);
16411 MP_WritePhyUshort(sc, 0x06, 0xfdfc);
16412 MP_WritePhyUshort(sc, 0x06, 0x04f8);
16413 MP_WritePhyUshort(sc, 0x06, 0xe08b);
16414 MP_WritePhyUshort(sc, 0x06, 0x8ead);
16415 MP_WritePhyUshort(sc, 0x06, 0x201a);
16416 MP_WritePhyUshort(sc, 0x06, 0xf620);
16417 MP_WritePhyUshort(sc, 0x06, 0xe48b);
16418 MP_WritePhyUshort(sc, 0x06, 0x8e02);
16419 MP_WritePhyUshort(sc, 0x06, 0x2afe);
16420 MP_WritePhyUshort(sc, 0x06, 0x022c);
16421 MP_WritePhyUshort(sc, 0x06, 0x5c02);
16422 MP_WritePhyUshort(sc, 0x06, 0x03c5);
16423 MP_WritePhyUshort(sc, 0x06, 0x0281);
16424 MP_WritePhyUshort(sc, 0x06, 0x6702);
16425 MP_WritePhyUshort(sc, 0x06, 0x2e4f);
16426 MP_WritePhyUshort(sc, 0x06, 0x0204);
16427 MP_WritePhyUshort(sc, 0x06, 0x8902);
16428 MP_WritePhyUshort(sc, 0x06, 0x2f7a);
16429 MP_WritePhyUshort(sc, 0x06, 0xe08b);
16430 MP_WritePhyUshort(sc, 0x06, 0x8ead);
16431 MP_WritePhyUshort(sc, 0x06, 0x210b);
16432 MP_WritePhyUshort(sc, 0x06, 0xf621);
16433 MP_WritePhyUshort(sc, 0x06, 0xe48b);
16434 MP_WritePhyUshort(sc, 0x06, 0x8e02);
16435 MP_WritePhyUshort(sc, 0x06, 0x0445);
16436 MP_WritePhyUshort(sc, 0x06, 0x021c);
16437 MP_WritePhyUshort(sc, 0x06, 0xb8e0);
16438 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16439 MP_WritePhyUshort(sc, 0x06, 0xad22);
16440 MP_WritePhyUshort(sc, 0x06, 0x08f6);
16441 MP_WritePhyUshort(sc, 0x06, 0x22e4);
16442 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16443 MP_WritePhyUshort(sc, 0x06, 0x0235);
16444 MP_WritePhyUshort(sc, 0x06, 0xd4e0);
16445 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16446 MP_WritePhyUshort(sc, 0x06, 0xad23);
16447 MP_WritePhyUshort(sc, 0x06, 0x08f6);
16448 MP_WritePhyUshort(sc, 0x06, 0x23e4);
16449 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16450 MP_WritePhyUshort(sc, 0x06, 0x0231);
16451 MP_WritePhyUshort(sc, 0x06, 0xc8e0);
16452 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16453 MP_WritePhyUshort(sc, 0x06, 0xad24);
16454 MP_WritePhyUshort(sc, 0x06, 0x05f6);
16455 MP_WritePhyUshort(sc, 0x06, 0x24e4);
16456 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16457 MP_WritePhyUshort(sc, 0x06, 0xe08b);
16458 MP_WritePhyUshort(sc, 0x06, 0x8ead);
16459 MP_WritePhyUshort(sc, 0x06, 0x2505);
16460 MP_WritePhyUshort(sc, 0x06, 0xf625);
16461 MP_WritePhyUshort(sc, 0x06, 0xe48b);
16462 MP_WritePhyUshort(sc, 0x06, 0x8ee0);
16463 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16464 MP_WritePhyUshort(sc, 0x06, 0xad26);
16465 MP_WritePhyUshort(sc, 0x06, 0x08f6);
16466 MP_WritePhyUshort(sc, 0x06, 0x26e4);
16467 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16468 MP_WritePhyUshort(sc, 0x06, 0x022d);
16469 MP_WritePhyUshort(sc, 0x06, 0x6ae0);
16470 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16471 MP_WritePhyUshort(sc, 0x06, 0xad27);
16472 MP_WritePhyUshort(sc, 0x06, 0x05f6);
16473 MP_WritePhyUshort(sc, 0x06, 0x27e4);
16474 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16475 MP_WritePhyUshort(sc, 0x06, 0x0203);
16476 MP_WritePhyUshort(sc, 0x06, 0x8bfc);
16477 MP_WritePhyUshort(sc, 0x06, 0x04f8);
16478 MP_WritePhyUshort(sc, 0x06, 0xfaef);
16479 MP_WritePhyUshort(sc, 0x06, 0x69e0);
16480 MP_WritePhyUshort(sc, 0x06, 0x8b80);
16481 MP_WritePhyUshort(sc, 0x06, 0xad27);
16482 MP_WritePhyUshort(sc, 0x06, 0x22bf);
16483 MP_WritePhyUshort(sc, 0x06, 0x479a);
16484 MP_WritePhyUshort(sc, 0x06, 0x0239);
16485 MP_WritePhyUshort(sc, 0x06, 0xc6e0);
16486 MP_WritePhyUshort(sc, 0x06, 0x8b44);
16487 MP_WritePhyUshort(sc, 0x06, 0x1f01);
16488 MP_WritePhyUshort(sc, 0x06, 0x9e15);
16489 MP_WritePhyUshort(sc, 0x06, 0xe58b);
16490 MP_WritePhyUshort(sc, 0x06, 0x44ad);
16491 MP_WritePhyUshort(sc, 0x06, 0x2907);
16492 MP_WritePhyUshort(sc, 0x06, 0xac28);
16493 MP_WritePhyUshort(sc, 0x06, 0x04d1);
16494 MP_WritePhyUshort(sc, 0x06, 0x01ae);
16495 MP_WritePhyUshort(sc, 0x06, 0x02d1);
16496 MP_WritePhyUshort(sc, 0x06, 0x00bf);
16497 MP_WritePhyUshort(sc, 0x06, 0x819e);
16498 MP_WritePhyUshort(sc, 0x06, 0x0239);
16499 MP_WritePhyUshort(sc, 0x06, 0xf3ef);
16500 MP_WritePhyUshort(sc, 0x06, 0x96fe);
16501 MP_WritePhyUshort(sc, 0x06, 0xfc04);
16502 MP_WritePhyUshort(sc, 0x06, 0x00e1);
16503 MP_WritePhyUshort(sc, 0x06, 0x4077);
16504 MP_WritePhyUshort(sc, 0x06, 0xe140);
16505 MP_WritePhyUshort(sc, 0x06, 0xbbe0);
16506 MP_WritePhyUshort(sc, 0x06, 0x2a00);
16507 MP_WritePhyUshort(sc, 0x05, 0xe142);
16508 Data = MP_ReadPhyUshort(sc, 0x06);
16509 Data |= BIT_0;
16510 MP_WritePhyUshort(sc, 0x06, Data);
16511 MP_WritePhyUshort(sc, 0x05, 0xe140);
16512 Data = MP_ReadPhyUshort(sc, 0x06);
16513 Data |= BIT_0;
16514 MP_WritePhyUshort(sc, 0x06, Data);
16515 MP_WritePhyUshort(sc, 0x1f, 0x0000);
16516 MP_WritePhyUshort(sc, 0x1f, 0x0007);
16517 MP_WritePhyUshort(sc, 0x1e, 0x0023);
16518 Data = MP_ReadPhyUshort(sc, 0x17);
16519 Data |= BIT_1;
16520 MP_WritePhyUshort(sc, 0x17, Data);
16521 MP_WritePhyUshort(sc, 0x1f, 0x0000);
16522 MP_WritePhyUshort(sc, 0x1f, 0x0003);
16523 Data = MP_ReadPhyUshort(sc, 0x19);
16524 Data &= ~BIT_0;
16525 MP_WritePhyUshort(sc, 0x19, Data);
16526 Data = MP_ReadPhyUshort(sc, 0x10);
16527 Data &= ~BIT_10;
16528 MP_WritePhyUshort(sc, 0x10, Data);
16529 MP_WritePhyUshort(sc, 0x1f, 0x0000);
16530 MP_WritePhyUshort(sc, 0x00, 0x9200);
16531
16532 MP_WritePhyUshort(sc, 0x1F, 0x0005);
16533 MP_WritePhyUshort(sc, 0x05, 0x8B80);
16534 Data = MP_ReadPhyUshort(sc, 0x06);
16535 Data |= BIT_2 | BIT_1;
16536 MP_WritePhyUshort(sc, 0x06, Data);
16537 MP_WritePhyUshort(sc, 0x1f, 0x0000);
16538
16539 MP_WritePhyUshort(sc, 0x1F, 0x0007);
16540 MP_WritePhyUshort(sc, 0x1E, 0x002D);
16541 Data = MP_ReadPhyUshort(sc, 0x18);
16542 Data |= BIT_4;
16543 MP_WritePhyUshort(sc, 0x18, Data);
16544 MP_WritePhyUshort(sc, 0x1f, 0x0000);
16545 Data = MP_ReadPhyUshort(sc, 0x14);
16546 Data |= BIT_15;
16547 MP_WritePhyUshort(sc, 0x14, Data);
16548
16549 MP_WritePhyUshort(sc, 0x1F, 0x0005);
16550 MP_WritePhyUshort(sc, 0x05, 0x8B86);
16551 Data = MP_ReadPhyUshort(sc, 0x06);
16552 Data |= BIT_0;
16553 MP_WritePhyUshort(sc, 0x06, Data);
16554 MP_WritePhyUshort(sc, 0x1f, 0x0000);
16555
16556 MP_WritePhyUshort(sc, 0x1F, 0x0005);
16557 MP_WritePhyUshort(sc, 0x05, 0x8B54);
16558 Data = MP_ReadPhyUshort(sc, 0x06);
16559 Data &= ~BIT_11;
16560 MP_WritePhyUshort(sc, 0x06, Data);
16561 MP_WritePhyUshort(sc, 0x05, 0x8B5D);
16562 Data = MP_ReadPhyUshort(sc, 0x06);
16563 Data &= ~BIT_11;
16564 MP_WritePhyUshort(sc, 0x06, Data);
16565 MP_WritePhyUshort(sc, 0x05, 0x8A7C);
16566 Data = MP_ReadPhyUshort(sc, 0x06);
16567 Data &= ~BIT_8;
16568 MP_WritePhyUshort(sc, 0x06, Data);
16569 MP_WritePhyUshort(sc, 0x05, 0x8A7F);
16570 Data = MP_ReadPhyUshort(sc, 0x06);
16571 Data |= BIT_8;
16572 MP_WritePhyUshort(sc, 0x06, Data);
16573 MP_WritePhyUshort(sc, 0x05, 0x8A82);
16574 Data = MP_ReadPhyUshort(sc, 0x06);
16575 Data &= ~BIT_8;
16576 MP_WritePhyUshort(sc, 0x06, Data);
16577 MP_WritePhyUshort(sc, 0x05, 0x8A85);
16578 Data = MP_ReadPhyUshort(sc, 0x06);
16579 Data &= ~BIT_8;
16580 MP_WritePhyUshort(sc, 0x06, Data);
16581 MP_WritePhyUshort(sc, 0x05, 0x8A88);
16582 Data = MP_ReadPhyUshort(sc, 0x06);
16583 Data &= ~BIT_8;
16584 MP_WritePhyUshort(sc, 0x06, Data);
16585 MP_WritePhyUshort(sc, 0x1F, 0x0000);
16586
16587 MP_WritePhyUshort(sc, 0x1F, 0x0005);
16588 MP_WritePhyUshort(sc, 0x05, 0x8B85);
16589 Data = MP_ReadPhyUshort(sc, 0x06);
16590 Data |= BIT_15;
16591 MP_WritePhyUshort(sc, 0x06, Data);
16592 MP_WritePhyUshort(sc, 0x1f, 0x0000);
16593
16594 MP_WritePhyUshort(sc, 0x1f, 0x0003);
16595 Data = MP_ReadPhyUshort(sc, 0x19);
16596 Data &= ~BIT_0;
16597 MP_WritePhyUshort(sc, 0x19, Data);
16598 Data = MP_ReadPhyUshort(sc, 0x10);
16599 Data &= ~BIT_10;
16600 MP_WritePhyUshort(sc, 0x10, Data);
16601 MP_WritePhyUshort(sc, 0x1f, 0x0000);
16602 } else if (sc->re_type == MACFG_52) {
16603 Data_u32 = re_eri_read(sc, 0x1D0, 4, ERIAR_ExGMAC);
16604 Data_u32 &= ~BIT_1;
16605 re_eri_write(sc, 0x1D0, 4, Data_u32, ERIAR_ExGMAC);
16606
16607 MP_WritePhyUshort(sc,0x1f, 0x0000);
16608 MP_WritePhyUshort(sc,0x00, 0x1800);
16609 Data = MP_ReadPhyUshort(sc, 0x15);
16610 Data &= ~(BIT_12);
16611 MP_WritePhyUshort(sc,0x15, Data);
16612 MP_WritePhyUshort(sc,0x00, 0x4800);
16613 MP_WritePhyUshort(sc,0x1f, 0x0007);
16614 MP_WritePhyUshort(sc,0x1e, 0x002f);
16615 for (i = 0; i < 1000; i++) {
16616 DELAY(100);
16617 Data = MP_ReadPhyUshort(sc, 0x1c);
16618 if (Data & BIT_7)
16619 break;
16620 }
16621 MP_WritePhyUshort(sc,0x1f, 0x0000);
16622 MP_WritePhyUshort(sc,0x00, 0x1800);
16623 MP_WritePhyUshort(sc,0x1f, 0x0007);
16624 MP_WritePhyUshort(sc,0x1e, 0x0023);
16625 for (i = 0; i < 200; i++) {
16626 DELAY(100);
16627 Data = MP_ReadPhyUshort(sc, 0x18);
16628 if (!(Data & BIT_0))
16629 break;
16630 }
16631 MP_WritePhyUshort(sc,0x1f, 0x0005);
16632 MP_WritePhyUshort(sc,0x05, 0xfff6);
16633 MP_WritePhyUshort(sc,0x06, 0x0080);
16634 MP_WritePhyUshort(sc, 0x1f, 0x0007);
16635 MP_WritePhyUshort(sc, 0x1e, 0x0023);
16636 MP_WritePhyUshort(sc, 0x16, 0x0306);
16637 MP_WritePhyUshort(sc, 0x16, 0x0307);
16638 MP_WritePhyUshort(sc, 0x15, 0x0098);
16639 MP_WritePhyUshort(sc, 0x19, 0x7c0b);
16640 MP_WritePhyUshort(sc, 0x15, 0x0099);
16641 MP_WritePhyUshort(sc, 0x19, 0x6c0b);
16642 MP_WritePhyUshort(sc, 0x15, 0x00eb);
16643 MP_WritePhyUshort(sc, 0x19, 0x6c0b);
16644 MP_WritePhyUshort(sc, 0x15, 0x00f8);
16645 MP_WritePhyUshort(sc, 0x19, 0x6f0b);
16646 MP_WritePhyUshort(sc, 0x15, 0x00fe);
16647 MP_WritePhyUshort(sc, 0x19, 0x6f0f);
16648 MP_WritePhyUshort(sc, 0x15, 0x00db);
16649 MP_WritePhyUshort(sc, 0x19, 0x6f09);
16650 MP_WritePhyUshort(sc, 0x15, 0x00dc);
16651 MP_WritePhyUshort(sc, 0x19, 0xaefd);
16652 MP_WritePhyUshort(sc, 0x15, 0x00dd);
16653 MP_WritePhyUshort(sc, 0x19, 0x6f0b);
16654 MP_WritePhyUshort(sc, 0x15, 0x00de);
16655 MP_WritePhyUshort(sc, 0x19, 0xc60b);
16656 MP_WritePhyUshort(sc, 0x15, 0x00df);
16657 MP_WritePhyUshort(sc, 0x19, 0x00fa);
16658 MP_WritePhyUshort(sc, 0x15, 0x00e0);
16659 MP_WritePhyUshort(sc, 0x19, 0x30e1);
16660 MP_WritePhyUshort(sc, 0x15, 0x020c);
16661 MP_WritePhyUshort(sc, 0x19, 0x3224);
16662 MP_WritePhyUshort(sc, 0x15, 0x020e);
16663 MP_WritePhyUshort(sc, 0x19, 0x9813);
16664 MP_WritePhyUshort(sc, 0x15, 0x020f);
16665 MP_WritePhyUshort(sc, 0x19, 0x7801);
16666 MP_WritePhyUshort(sc, 0x15, 0x0210);
16667 MP_WritePhyUshort(sc, 0x19, 0x930f);
16668 MP_WritePhyUshort(sc, 0x15, 0x0211);
16669 MP_WritePhyUshort(sc, 0x19, 0x9206);
16670 MP_WritePhyUshort(sc, 0x15, 0x0212);
16671 MP_WritePhyUshort(sc, 0x19, 0x4002);
16672 MP_WritePhyUshort(sc, 0x15, 0x0213);
16673 MP_WritePhyUshort(sc, 0x19, 0x7800);
16674 MP_WritePhyUshort(sc, 0x15, 0x0214);
16675 MP_WritePhyUshort(sc, 0x19, 0x588f);
16676 MP_WritePhyUshort(sc, 0x15, 0x0215);
16677 MP_WritePhyUshort(sc, 0x19, 0x5520);
16678 MP_WritePhyUshort(sc, 0x15, 0x0216);
16679 MP_WritePhyUshort(sc, 0x19, 0x3224);
16680 MP_WritePhyUshort(sc, 0x15, 0x0217);
16681 MP_WritePhyUshort(sc, 0x19, 0x4002);
16682 MP_WritePhyUshort(sc, 0x15, 0x0218);
16683 MP_WritePhyUshort(sc, 0x19, 0x7800);
16684 MP_WritePhyUshort(sc, 0x15, 0x0219);
16685 MP_WritePhyUshort(sc, 0x19, 0x588d);
16686 MP_WritePhyUshort(sc, 0x15, 0x021a);
16687 MP_WritePhyUshort(sc, 0x19, 0x5540);
16688 MP_WritePhyUshort(sc, 0x15, 0x021b);
16689 MP_WritePhyUshort(sc, 0x19, 0x9e03);
16690 MP_WritePhyUshort(sc, 0x15, 0x021c);
16691 MP_WritePhyUshort(sc, 0x19, 0x7c40);
16692 MP_WritePhyUshort(sc, 0x15, 0x021d);
16693 MP_WritePhyUshort(sc, 0x19, 0x6840);
16694 MP_WritePhyUshort(sc, 0x15, 0x021e);
16695 MP_WritePhyUshort(sc, 0x19, 0x3224);
16696 MP_WritePhyUshort(sc, 0x15, 0x021f);
16697 MP_WritePhyUshort(sc, 0x19, 0x4002);
16698 MP_WritePhyUshort(sc, 0x15, 0x0220);
16699 MP_WritePhyUshort(sc, 0x19, 0x3224);
16700 MP_WritePhyUshort(sc, 0x15, 0x0221);
16701 MP_WritePhyUshort(sc, 0x19, 0x9e03);
16702 MP_WritePhyUshort(sc, 0x15, 0x0222);
16703 MP_WritePhyUshort(sc, 0x19, 0x7c40);
16704 MP_WritePhyUshort(sc, 0x15, 0x0223);
16705 MP_WritePhyUshort(sc, 0x19, 0x6840);
16706 MP_WritePhyUshort(sc, 0x15, 0x0224);
16707 MP_WritePhyUshort(sc, 0x19, 0x7800);
16708 MP_WritePhyUshort(sc, 0x15, 0x0225);
16709 MP_WritePhyUshort(sc, 0x19, 0x3231);
16710 MP_WritePhyUshort(sc, 0x15, 0x0000);
16711 MP_WritePhyUshort(sc, 0x16, 0x0306);
16712 MP_WritePhyUshort(sc, 0x16, 0x0300);
16713 MP_WritePhyUshort(sc, 0x1f, 0x0000);
16714 MP_WritePhyUshort(sc, 0x1f, 0x0005);
16715 MP_WritePhyUshort(sc, 0x05, 0xfff6);
16716 MP_WritePhyUshort(sc, 0x06, 0x0080);
16717 MP_WritePhyUshort(sc, 0x05, 0x8000);
16718 MP_WritePhyUshort(sc, 0x06, 0x0280);
16719 MP_WritePhyUshort(sc, 0x06, 0x48f7);
16720 MP_WritePhyUshort(sc, 0x06, 0x00e0);
16721 MP_WritePhyUshort(sc, 0x06, 0xfff7);
16722 MP_WritePhyUshort(sc, 0x06, 0xa080);
16723 MP_WritePhyUshort(sc, 0x06, 0x02ae);
16724 MP_WritePhyUshort(sc, 0x06, 0xf602);
16725 MP_WritePhyUshort(sc, 0x06, 0x011e);
16726 MP_WritePhyUshort(sc, 0x06, 0x0201);
16727 MP_WritePhyUshort(sc, 0x06, 0x2b02);
16728 MP_WritePhyUshort(sc, 0x06, 0x8077);
16729 MP_WritePhyUshort(sc, 0x06, 0x0201);
16730 MP_WritePhyUshort(sc, 0x06, 0x4802);
16731 MP_WritePhyUshort(sc, 0x06, 0x0162);
16732 MP_WritePhyUshort(sc, 0x06, 0x0280);
16733 MP_WritePhyUshort(sc, 0x06, 0x9402);
16734 MP_WritePhyUshort(sc, 0x06, 0x810e);
16735 MP_WritePhyUshort(sc, 0x06, 0xe08b);
16736 MP_WritePhyUshort(sc, 0x06, 0x88e1);
16737 MP_WritePhyUshort(sc, 0x06, 0x8b89);
16738 MP_WritePhyUshort(sc, 0x06, 0x1e01);
16739 MP_WritePhyUshort(sc, 0x06, 0xe18b);
16740 MP_WritePhyUshort(sc, 0x06, 0x8a1e);
16741 MP_WritePhyUshort(sc, 0x06, 0x01e1);
16742 MP_WritePhyUshort(sc, 0x06, 0x8b8b);
16743 MP_WritePhyUshort(sc, 0x06, 0x1e01);
16744 MP_WritePhyUshort(sc, 0x06, 0xe18b);
16745 MP_WritePhyUshort(sc, 0x06, 0x8c1e);
16746 MP_WritePhyUshort(sc, 0x06, 0x01e1);
16747 MP_WritePhyUshort(sc, 0x06, 0x8b8d);
16748 MP_WritePhyUshort(sc, 0x06, 0x1e01);
16749 MP_WritePhyUshort(sc, 0x06, 0xe18b);
16750 MP_WritePhyUshort(sc, 0x06, 0x8e1e);
16751 MP_WritePhyUshort(sc, 0x06, 0x01a0);
16752 MP_WritePhyUshort(sc, 0x06, 0x00c7);
16753 MP_WritePhyUshort(sc, 0x06, 0xaebb);
16754 MP_WritePhyUshort(sc, 0x06, 0xd481);
16755 MP_WritePhyUshort(sc, 0x06, 0xd4e4);
16756 MP_WritePhyUshort(sc, 0x06, 0x8b92);
16757 MP_WritePhyUshort(sc, 0x06, 0xe58b);
16758 MP_WritePhyUshort(sc, 0x06, 0x9302);
16759 MP_WritePhyUshort(sc, 0x06, 0x2e5a);
16760 MP_WritePhyUshort(sc, 0x06, 0xbf8b);
16761 MP_WritePhyUshort(sc, 0x06, 0x88ec);
16762 MP_WritePhyUshort(sc, 0x06, 0x0019);
16763 MP_WritePhyUshort(sc, 0x06, 0xa98b);
16764 MP_WritePhyUshort(sc, 0x06, 0x90f9);
16765 MP_WritePhyUshort(sc, 0x06, 0xeeff);
16766 MP_WritePhyUshort(sc, 0x06, 0xf600);
16767 MP_WritePhyUshort(sc, 0x06, 0xeeff);
16768 MP_WritePhyUshort(sc, 0x06, 0xf7fc);
16769 MP_WritePhyUshort(sc, 0x06, 0xd100);
16770 MP_WritePhyUshort(sc, 0x06, 0xbf83);
16771 MP_WritePhyUshort(sc, 0x06, 0x3c02);
16772 MP_WritePhyUshort(sc, 0x06, 0x3a21);
16773 MP_WritePhyUshort(sc, 0x06, 0xd101);
16774 MP_WritePhyUshort(sc, 0x06, 0xbf83);
16775 MP_WritePhyUshort(sc, 0x06, 0x3f02);
16776 MP_WritePhyUshort(sc, 0x06, 0x3a21);
16777 MP_WritePhyUshort(sc, 0x06, 0x04f8);
16778 MP_WritePhyUshort(sc, 0x06, 0xe08b);
16779 MP_WritePhyUshort(sc, 0x06, 0x8aad);
16780 MP_WritePhyUshort(sc, 0x06, 0x2014);
16781 MP_WritePhyUshort(sc, 0x06, 0xee8b);
16782 MP_WritePhyUshort(sc, 0x06, 0x8a00);
16783 MP_WritePhyUshort(sc, 0x06, 0x0220);
16784 MP_WritePhyUshort(sc, 0x06, 0x8be0);
16785 MP_WritePhyUshort(sc, 0x06, 0xe426);
16786 MP_WritePhyUshort(sc, 0x06, 0xe1e4);
16787 MP_WritePhyUshort(sc, 0x06, 0x27ee);
16788 MP_WritePhyUshort(sc, 0x06, 0xe426);
16789 MP_WritePhyUshort(sc, 0x06, 0x23e5);
16790 MP_WritePhyUshort(sc, 0x06, 0xe427);
16791 MP_WritePhyUshort(sc, 0x06, 0xfc04);
16792 MP_WritePhyUshort(sc, 0x06, 0xf8e0);
16793 MP_WritePhyUshort(sc, 0x06, 0x8b8d);
16794 MP_WritePhyUshort(sc, 0x06, 0xad20);
16795 MP_WritePhyUshort(sc, 0x06, 0x14ee);
16796 MP_WritePhyUshort(sc, 0x06, 0x8b8d);
16797 MP_WritePhyUshort(sc, 0x06, 0x00e0);
16798 MP_WritePhyUshort(sc, 0x06, 0x8a5a);
16799 MP_WritePhyUshort(sc, 0x06, 0x7803);
16800 MP_WritePhyUshort(sc, 0x06, 0x9e09);
16801 MP_WritePhyUshort(sc, 0x06, 0x0206);
16802 MP_WritePhyUshort(sc, 0x06, 0x2802);
16803 MP_WritePhyUshort(sc, 0x06, 0x80b1);
16804 MP_WritePhyUshort(sc, 0x06, 0x0232);
16805 MP_WritePhyUshort(sc, 0x06, 0xfdfc);
16806 MP_WritePhyUshort(sc, 0x06, 0x04f8);
16807 MP_WritePhyUshort(sc, 0x06, 0xf9e0);
16808 MP_WritePhyUshort(sc, 0x06, 0x8b81);
16809 MP_WritePhyUshort(sc, 0x06, 0xac26);
16810 MP_WritePhyUshort(sc, 0x06, 0x1ae0);
16811 MP_WritePhyUshort(sc, 0x06, 0x8b81);
16812 MP_WritePhyUshort(sc, 0x06, 0xac21);
16813 MP_WritePhyUshort(sc, 0x06, 0x14e0);
16814 MP_WritePhyUshort(sc, 0x06, 0x8b85);
16815 MP_WritePhyUshort(sc, 0x06, 0xac20);
16816 MP_WritePhyUshort(sc, 0x06, 0x0ee0);
16817 MP_WritePhyUshort(sc, 0x06, 0x8b85);
16818 MP_WritePhyUshort(sc, 0x06, 0xac23);
16819 MP_WritePhyUshort(sc, 0x06, 0x08e0);
16820 MP_WritePhyUshort(sc, 0x06, 0x8b87);
16821 MP_WritePhyUshort(sc, 0x06, 0xac24);
16822 MP_WritePhyUshort(sc, 0x06, 0x02ae);
16823 MP_WritePhyUshort(sc, 0x06, 0x3802);
16824 MP_WritePhyUshort(sc, 0x06, 0x1b02);
16825 MP_WritePhyUshort(sc, 0x06, 0xeee4);
16826 MP_WritePhyUshort(sc, 0x06, 0x1c04);
16827 MP_WritePhyUshort(sc, 0x06, 0xeee4);
16828 MP_WritePhyUshort(sc, 0x06, 0x1d04);
16829 MP_WritePhyUshort(sc, 0x06, 0xe2e0);
16830 MP_WritePhyUshort(sc, 0x06, 0x7ce3);
16831 MP_WritePhyUshort(sc, 0x06, 0xe07d);
16832 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
16833 MP_WritePhyUshort(sc, 0x06, 0x38e1);
16834 MP_WritePhyUshort(sc, 0x06, 0xe039);
16835 MP_WritePhyUshort(sc, 0x06, 0xad2e);
16836 MP_WritePhyUshort(sc, 0x06, 0x1bad);
16837 MP_WritePhyUshort(sc, 0x06, 0x390d);
16838 MP_WritePhyUshort(sc, 0x06, 0xd101);
16839 MP_WritePhyUshort(sc, 0x06, 0xbf22);
16840 MP_WritePhyUshort(sc, 0x06, 0xe802);
16841 MP_WritePhyUshort(sc, 0x06, 0x3a21);
16842 MP_WritePhyUshort(sc, 0x06, 0x0222);
16843 MP_WritePhyUshort(sc, 0x06, 0x10ae);
16844 MP_WritePhyUshort(sc, 0x06, 0x0bac);
16845 MP_WritePhyUshort(sc, 0x06, 0x3802);
16846 MP_WritePhyUshort(sc, 0x06, 0xae06);
16847 MP_WritePhyUshort(sc, 0x06, 0x0222);
16848 MP_WritePhyUshort(sc, 0x06, 0x4d02);
16849 MP_WritePhyUshort(sc, 0x06, 0x2292);
16850 MP_WritePhyUshort(sc, 0x06, 0x021b);
16851 MP_WritePhyUshort(sc, 0x06, 0x13fd);
16852 MP_WritePhyUshort(sc, 0x06, 0xfc04);
16853 MP_WritePhyUshort(sc, 0x06, 0xf8e0);
16854 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16855 MP_WritePhyUshort(sc, 0x06, 0xad20);
16856 MP_WritePhyUshort(sc, 0x06, 0x1af6);
16857 MP_WritePhyUshort(sc, 0x06, 0x20e4);
16858 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16859 MP_WritePhyUshort(sc, 0x06, 0x022b);
16860 MP_WritePhyUshort(sc, 0x06, 0x1e02);
16861 MP_WritePhyUshort(sc, 0x06, 0x82ae);
16862 MP_WritePhyUshort(sc, 0x06, 0x0203);
16863 MP_WritePhyUshort(sc, 0x06, 0xc002);
16864 MP_WritePhyUshort(sc, 0x06, 0x827d);
16865 MP_WritePhyUshort(sc, 0x06, 0x022e);
16866 MP_WritePhyUshort(sc, 0x06, 0x6f02);
16867 MP_WritePhyUshort(sc, 0x06, 0x047b);
16868 MP_WritePhyUshort(sc, 0x06, 0x022f);
16869 MP_WritePhyUshort(sc, 0x06, 0x9ae0);
16870 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16871 MP_WritePhyUshort(sc, 0x06, 0xad21);
16872 MP_WritePhyUshort(sc, 0x06, 0x0bf6);
16873 MP_WritePhyUshort(sc, 0x06, 0x21e4);
16874 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16875 MP_WritePhyUshort(sc, 0x06, 0x0281);
16876 MP_WritePhyUshort(sc, 0x06, 0x9002);
16877 MP_WritePhyUshort(sc, 0x06, 0x1cd9);
16878 MP_WritePhyUshort(sc, 0x06, 0xe08b);
16879 MP_WritePhyUshort(sc, 0x06, 0x8ead);
16880 MP_WritePhyUshort(sc, 0x06, 0x2208);
16881 MP_WritePhyUshort(sc, 0x06, 0xf622);
16882 MP_WritePhyUshort(sc, 0x06, 0xe48b);
16883 MP_WritePhyUshort(sc, 0x06, 0x8e02);
16884 MP_WritePhyUshort(sc, 0x06, 0x35f4);
16885 MP_WritePhyUshort(sc, 0x06, 0xe08b);
16886 MP_WritePhyUshort(sc, 0x06, 0x8ead);
16887 MP_WritePhyUshort(sc, 0x06, 0x2308);
16888 MP_WritePhyUshort(sc, 0x06, 0xf623);
16889 MP_WritePhyUshort(sc, 0x06, 0xe48b);
16890 MP_WritePhyUshort(sc, 0x06, 0x8e02);
16891 MP_WritePhyUshort(sc, 0x06, 0x31e8);
16892 MP_WritePhyUshort(sc, 0x06, 0xe08b);
16893 MP_WritePhyUshort(sc, 0x06, 0x8ead);
16894 MP_WritePhyUshort(sc, 0x06, 0x2405);
16895 MP_WritePhyUshort(sc, 0x06, 0xf624);
16896 MP_WritePhyUshort(sc, 0x06, 0xe48b);
16897 MP_WritePhyUshort(sc, 0x06, 0x8ee0);
16898 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16899 MP_WritePhyUshort(sc, 0x06, 0xad25);
16900 MP_WritePhyUshort(sc, 0x06, 0x05f6);
16901 MP_WritePhyUshort(sc, 0x06, 0x25e4);
16902 MP_WritePhyUshort(sc, 0x06, 0x8b8e);
16903 MP_WritePhyUshort(sc, 0x06, 0xe08b);
16904 MP_WritePhyUshort(sc, 0x06, 0x8ead);
16905 MP_WritePhyUshort(sc, 0x06, 0x2608);
16906 MP_WritePhyUshort(sc, 0x06, 0xf626);
16907 MP_WritePhyUshort(sc, 0x06, 0xe48b);
16908 MP_WritePhyUshort(sc, 0x06, 0x8e02);
16909 MP_WritePhyUshort(sc, 0x06, 0x2d8a);
16910 MP_WritePhyUshort(sc, 0x06, 0xe08b);
16911 MP_WritePhyUshort(sc, 0x06, 0x8ead);
16912 MP_WritePhyUshort(sc, 0x06, 0x2705);
16913 MP_WritePhyUshort(sc, 0x06, 0xf627);
16914 MP_WritePhyUshort(sc, 0x06, 0xe48b);
16915 MP_WritePhyUshort(sc, 0x06, 0x8e02);
16916 MP_WritePhyUshort(sc, 0x06, 0x0386);
16917 MP_WritePhyUshort(sc, 0x06, 0xfc04);
16918 MP_WritePhyUshort(sc, 0x06, 0xf8fa);
16919 MP_WritePhyUshort(sc, 0x06, 0xef69);
16920 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
16921 MP_WritePhyUshort(sc, 0x06, 0x00e1);
16922 MP_WritePhyUshort(sc, 0x06, 0xe001);
16923 MP_WritePhyUshort(sc, 0x06, 0xad27);
16924 MP_WritePhyUshort(sc, 0x06, 0x32e0);
16925 MP_WritePhyUshort(sc, 0x06, 0x8b40);
16926 MP_WritePhyUshort(sc, 0x06, 0xf720);
16927 MP_WritePhyUshort(sc, 0x06, 0xe48b);
16928 MP_WritePhyUshort(sc, 0x06, 0x40bf);
16929 MP_WritePhyUshort(sc, 0x06, 0x32c1);
16930 MP_WritePhyUshort(sc, 0x06, 0x0239);
16931 MP_WritePhyUshort(sc, 0x06, 0xf4ad);
16932 MP_WritePhyUshort(sc, 0x06, 0x2821);
16933 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
16934 MP_WritePhyUshort(sc, 0x06, 0x20e1);
16935 MP_WritePhyUshort(sc, 0x06, 0xe021);
16936 MP_WritePhyUshort(sc, 0x06, 0xad20);
16937 MP_WritePhyUshort(sc, 0x06, 0x18e0);
16938 MP_WritePhyUshort(sc, 0x06, 0x8b40);
16939 MP_WritePhyUshort(sc, 0x06, 0xf620);
16940 MP_WritePhyUshort(sc, 0x06, 0xe48b);
16941 MP_WritePhyUshort(sc, 0x06, 0x40ee);
16942 MP_WritePhyUshort(sc, 0x06, 0x8b3b);
16943 MP_WritePhyUshort(sc, 0x06, 0xffe0);
16944 MP_WritePhyUshort(sc, 0x06, 0x8a8a);
16945 MP_WritePhyUshort(sc, 0x06, 0xe18a);
16946 MP_WritePhyUshort(sc, 0x06, 0x8be4);
16947 MP_WritePhyUshort(sc, 0x06, 0xe000);
16948 MP_WritePhyUshort(sc, 0x06, 0xe5e0);
16949 MP_WritePhyUshort(sc, 0x06, 0x01ef);
16950 MP_WritePhyUshort(sc, 0x06, 0x96fe);
16951 MP_WritePhyUshort(sc, 0x06, 0xfc04);
16952 MP_WritePhyUshort(sc, 0x06, 0xf8f9);
16953 MP_WritePhyUshort(sc, 0x06, 0xface);
16954 MP_WritePhyUshort(sc, 0x06, 0xfaef);
16955 MP_WritePhyUshort(sc, 0x06, 0x69fa);
16956 MP_WritePhyUshort(sc, 0x06, 0xd401);
16957 MP_WritePhyUshort(sc, 0x06, 0x55b4);
16958 MP_WritePhyUshort(sc, 0x06, 0xfebf);
16959 MP_WritePhyUshort(sc, 0x06, 0x1c5e);
16960 MP_WritePhyUshort(sc, 0x06, 0x0239);
16961 MP_WritePhyUshort(sc, 0x06, 0xf4ac);
16962 MP_WritePhyUshort(sc, 0x06, 0x280b);
16963 MP_WritePhyUshort(sc, 0x06, 0xbf1c);
16964 MP_WritePhyUshort(sc, 0x06, 0x5b02);
16965 MP_WritePhyUshort(sc, 0x06, 0x39f4);
16966 MP_WritePhyUshort(sc, 0x06, 0xac28);
16967 MP_WritePhyUshort(sc, 0x06, 0x49ae);
16968 MP_WritePhyUshort(sc, 0x06, 0x64bf);
16969 MP_WritePhyUshort(sc, 0x06, 0x1c5b);
16970 MP_WritePhyUshort(sc, 0x06, 0x0239);
16971 MP_WritePhyUshort(sc, 0x06, 0xf4ac);
16972 MP_WritePhyUshort(sc, 0x06, 0x285b);
16973 MP_WritePhyUshort(sc, 0x06, 0xd000);
16974 MP_WritePhyUshort(sc, 0x06, 0x0282);
16975 MP_WritePhyUshort(sc, 0x06, 0x62ac);
16976 MP_WritePhyUshort(sc, 0x06, 0x2105);
16977 MP_WritePhyUshort(sc, 0x06, 0xac22);
16978 MP_WritePhyUshort(sc, 0x06, 0x02ae);
16979 MP_WritePhyUshort(sc, 0x06, 0x4ebf);
16980 MP_WritePhyUshort(sc, 0x06, 0xe0c4);
16981 MP_WritePhyUshort(sc, 0x06, 0xbe85);
16982 MP_WritePhyUshort(sc, 0x06, 0xecd2);
16983 MP_WritePhyUshort(sc, 0x06, 0x04d8);
16984 MP_WritePhyUshort(sc, 0x06, 0x19d9);
16985 MP_WritePhyUshort(sc, 0x06, 0x1907);
16986 MP_WritePhyUshort(sc, 0x06, 0xdc19);
16987 MP_WritePhyUshort(sc, 0x06, 0xdd19);
16988 MP_WritePhyUshort(sc, 0x06, 0x0789);
16989 MP_WritePhyUshort(sc, 0x06, 0x89ef);
16990 MP_WritePhyUshort(sc, 0x06, 0x645e);
16991 MP_WritePhyUshort(sc, 0x06, 0x07ff);
16992 MP_WritePhyUshort(sc, 0x06, 0x0d65);
16993 MP_WritePhyUshort(sc, 0x06, 0x5cf8);
16994 MP_WritePhyUshort(sc, 0x06, 0x001e);
16995 MP_WritePhyUshort(sc, 0x06, 0x46dc);
16996 MP_WritePhyUshort(sc, 0x06, 0x19dd);
16997 MP_WritePhyUshort(sc, 0x06, 0x19b2);
16998 MP_WritePhyUshort(sc, 0x06, 0xe2d4);
16999 MP_WritePhyUshort(sc, 0x06, 0x0001);
17000 MP_WritePhyUshort(sc, 0x06, 0xbf1c);
17001 MP_WritePhyUshort(sc, 0x06, 0x5b02);
17002 MP_WritePhyUshort(sc, 0x06, 0x3a21);
17003 MP_WritePhyUshort(sc, 0x06, 0xae1d);
17004 MP_WritePhyUshort(sc, 0x06, 0xbee0);
17005 MP_WritePhyUshort(sc, 0x06, 0xc4bf);
17006 MP_WritePhyUshort(sc, 0x06, 0x85ec);
17007 MP_WritePhyUshort(sc, 0x06, 0xd204);
17008 MP_WritePhyUshort(sc, 0x06, 0xd819);
17009 MP_WritePhyUshort(sc, 0x06, 0xd919);
17010 MP_WritePhyUshort(sc, 0x06, 0x07dc);
17011 MP_WritePhyUshort(sc, 0x06, 0x19dd);
17012 MP_WritePhyUshort(sc, 0x06, 0x1907);
17013 MP_WritePhyUshort(sc, 0x06, 0xb2f4);
17014 MP_WritePhyUshort(sc, 0x06, 0xd400);
17015 MP_WritePhyUshort(sc, 0x06, 0x00bf);
17016 MP_WritePhyUshort(sc, 0x06, 0x1c5b);
17017 MP_WritePhyUshort(sc, 0x06, 0x023a);
17018 MP_WritePhyUshort(sc, 0x06, 0x21fe);
17019 MP_WritePhyUshort(sc, 0x06, 0xef96);
17020 MP_WritePhyUshort(sc, 0x06, 0xfec6);
17021 MP_WritePhyUshort(sc, 0x06, 0xfefd);
17022 MP_WritePhyUshort(sc, 0x06, 0xfc05);
17023 MP_WritePhyUshort(sc, 0x06, 0xf9e2);
17024 MP_WritePhyUshort(sc, 0x06, 0xe0ea);
17025 MP_WritePhyUshort(sc, 0x06, 0xe3e0);
17026 MP_WritePhyUshort(sc, 0x06, 0xeb5a);
17027 MP_WritePhyUshort(sc, 0x06, 0x070c);
17028 MP_WritePhyUshort(sc, 0x06, 0x031e);
17029 MP_WritePhyUshort(sc, 0x06, 0x20e6);
17030 MP_WritePhyUshort(sc, 0x06, 0xe0ea);
17031 MP_WritePhyUshort(sc, 0x06, 0xe7e0);
17032 MP_WritePhyUshort(sc, 0x06, 0xebe0);
17033 MP_WritePhyUshort(sc, 0x06, 0xe0fc);
17034 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
17035 MP_WritePhyUshort(sc, 0x06, 0xfdfd);
17036 MP_WritePhyUshort(sc, 0x06, 0x04f8);
17037 MP_WritePhyUshort(sc, 0x06, 0xfaef);
17038 MP_WritePhyUshort(sc, 0x06, 0x69e0);
17039 MP_WritePhyUshort(sc, 0x06, 0x8b80);
17040 MP_WritePhyUshort(sc, 0x06, 0xad27);
17041 MP_WritePhyUshort(sc, 0x06, 0x22bf);
17042 MP_WritePhyUshort(sc, 0x06, 0x47ba);
17043 MP_WritePhyUshort(sc, 0x06, 0x0239);
17044 MP_WritePhyUshort(sc, 0x06, 0xf4e0);
17045 MP_WritePhyUshort(sc, 0x06, 0x8b44);
17046 MP_WritePhyUshort(sc, 0x06, 0x1f01);
17047 MP_WritePhyUshort(sc, 0x06, 0x9e15);
17048 MP_WritePhyUshort(sc, 0x06, 0xe58b);
17049 MP_WritePhyUshort(sc, 0x06, 0x44ad);
17050 MP_WritePhyUshort(sc, 0x06, 0x2907);
17051 MP_WritePhyUshort(sc, 0x06, 0xac28);
17052 MP_WritePhyUshort(sc, 0x06, 0x04d1);
17053 MP_WritePhyUshort(sc, 0x06, 0x01ae);
17054 MP_WritePhyUshort(sc, 0x06, 0x02d1);
17055 MP_WritePhyUshort(sc, 0x06, 0x00bf);
17056 MP_WritePhyUshort(sc, 0x06, 0x8342);
17057 MP_WritePhyUshort(sc, 0x06, 0x023a);
17058 MP_WritePhyUshort(sc, 0x06, 0x21ef);
17059 MP_WritePhyUshort(sc, 0x06, 0x96fe);
17060 MP_WritePhyUshort(sc, 0x06, 0xfc04);
17061 MP_WritePhyUshort(sc, 0x06, 0xf8e0);
17062 MP_WritePhyUshort(sc, 0x06, 0x8b85);
17063 MP_WritePhyUshort(sc, 0x06, 0xad26);
17064 MP_WritePhyUshort(sc, 0x06, 0x30e0);
17065 MP_WritePhyUshort(sc, 0x06, 0xe036);
17066 MP_WritePhyUshort(sc, 0x06, 0xe1e0);
17067 MP_WritePhyUshort(sc, 0x06, 0x37e1);
17068 MP_WritePhyUshort(sc, 0x06, 0x8b3f);
17069 MP_WritePhyUshort(sc, 0x06, 0x1f10);
17070 MP_WritePhyUshort(sc, 0x06, 0x9e23);
17071 MP_WritePhyUshort(sc, 0x06, 0xe48b);
17072 MP_WritePhyUshort(sc, 0x06, 0x3fac);
17073 MP_WritePhyUshort(sc, 0x06, 0x200b);
17074 MP_WritePhyUshort(sc, 0x06, 0xac21);
17075 MP_WritePhyUshort(sc, 0x06, 0x0dac);
17076 MP_WritePhyUshort(sc, 0x06, 0x250f);
17077 MP_WritePhyUshort(sc, 0x06, 0xac27);
17078 MP_WritePhyUshort(sc, 0x06, 0x11ae);
17079 MP_WritePhyUshort(sc, 0x06, 0x1202);
17080 MP_WritePhyUshort(sc, 0x06, 0x2cb5);
17081 MP_WritePhyUshort(sc, 0x06, 0xae0d);
17082 MP_WritePhyUshort(sc, 0x06, 0x0282);
17083 MP_WritePhyUshort(sc, 0x06, 0xe7ae);
17084 MP_WritePhyUshort(sc, 0x06, 0x0802);
17085 MP_WritePhyUshort(sc, 0x06, 0x2cd7);
17086 MP_WritePhyUshort(sc, 0x06, 0xae03);
17087 MP_WritePhyUshort(sc, 0x06, 0x022c);
17088 MP_WritePhyUshort(sc, 0x06, 0xeafc);
17089 MP_WritePhyUshort(sc, 0x06, 0x04f8);
17090 MP_WritePhyUshort(sc, 0x06, 0xfaef);
17091 MP_WritePhyUshort(sc, 0x06, 0x6902);
17092 MP_WritePhyUshort(sc, 0x06, 0x8304);
17093 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
17094 MP_WritePhyUshort(sc, 0x06, 0x14e1);
17095 MP_WritePhyUshort(sc, 0x06, 0xe015);
17096 MP_WritePhyUshort(sc, 0x06, 0xad26);
17097 MP_WritePhyUshort(sc, 0x06, 0x08d1);
17098 MP_WritePhyUshort(sc, 0x06, 0x1ebf);
17099 MP_WritePhyUshort(sc, 0x06, 0x2d47);
17100 MP_WritePhyUshort(sc, 0x06, 0x023a);
17101 MP_WritePhyUshort(sc, 0x06, 0x21ef);
17102 MP_WritePhyUshort(sc, 0x06, 0x96fe);
17103 MP_WritePhyUshort(sc, 0x06, 0xfc04);
17104 MP_WritePhyUshort(sc, 0x06, 0xf8e0);
17105 MP_WritePhyUshort(sc, 0x06, 0x8b85);
17106 MP_WritePhyUshort(sc, 0x06, 0xad27);
17107 MP_WritePhyUshort(sc, 0x06, 0x2fd0);
17108 MP_WritePhyUshort(sc, 0x06, 0x0b02);
17109 MP_WritePhyUshort(sc, 0x06, 0x3826);
17110 MP_WritePhyUshort(sc, 0x06, 0x5882);
17111 MP_WritePhyUshort(sc, 0x06, 0x7882);
17112 MP_WritePhyUshort(sc, 0x06, 0x9f24);
17113 MP_WritePhyUshort(sc, 0x06, 0xe08b);
17114 MP_WritePhyUshort(sc, 0x06, 0x32e1);
17115 MP_WritePhyUshort(sc, 0x06, 0x8b33);
17116 MP_WritePhyUshort(sc, 0x06, 0x1f10);
17117 MP_WritePhyUshort(sc, 0x06, 0x9e1a);
17118 MP_WritePhyUshort(sc, 0x06, 0x10e4);
17119 MP_WritePhyUshort(sc, 0x06, 0x8b32);
17120 MP_WritePhyUshort(sc, 0x06, 0xe0e0);
17121 MP_WritePhyUshort(sc, 0x06, 0x28e1);
17122 MP_WritePhyUshort(sc, 0x06, 0xe029);
17123 MP_WritePhyUshort(sc, 0x06, 0xf72c);
17124 MP_WritePhyUshort(sc, 0x06, 0xe4e0);
17125 MP_WritePhyUshort(sc, 0x06, 0x28e5);
17126 MP_WritePhyUshort(sc, 0x06, 0xe029);
17127 MP_WritePhyUshort(sc, 0x06, 0xf62c);
17128 MP_WritePhyUshort(sc, 0x06, 0xe4e0);
17129 MP_WritePhyUshort(sc, 0x06, 0x28e5);
17130 MP_WritePhyUshort(sc, 0x06, 0xe029);
17131 MP_WritePhyUshort(sc, 0x06, 0xfc04);
17132 MP_WritePhyUshort(sc, 0x06, 0x00e1);
17133 MP_WritePhyUshort(sc, 0x06, 0x4077);
17134 MP_WritePhyUshort(sc, 0x06, 0xe140);
17135 MP_WritePhyUshort(sc, 0x06, 0xbbe0);
17136 MP_WritePhyUshort(sc, 0x06, 0x2a00);
17137 MP_WritePhyUshort(sc, 0x05, 0xe142);
17138 Data = MP_ReadPhyUshort(sc, 0x06);
17139 Data |= BIT_0;
17140 MP_WritePhyUshort(sc,0x06, Data);
17141 MP_WritePhyUshort(sc, 0x05, 0xe140);
17142 Data = MP_ReadPhyUshort(sc, 0x06);
17143 Data |= BIT_0;
17144 MP_WritePhyUshort(sc,0x06, Data);
17145 MP_WritePhyUshort(sc, 0x1f, 0x0000);
17146 MP_WritePhyUshort(sc,0x1f, 0x0005);
17147 WaitCnt = 0;
17148 for (i = 0; i < 200; i++) {
17149 DELAY(100);
17150 Data = MP_ReadPhyUshort(sc, 0x00);
17151 if (Data & BIT_7)
17152 break;
17153 }
17154 MP_WritePhyUshort(sc,0x1f, 0x0007);
17155 MP_WritePhyUshort(sc,0x1e, 0x0023);
17156 Data = MP_ReadPhyUshort(sc, 0x17);
17157 Data |= BIT_1;
17158 MP_WritePhyUshort(sc, 0x17, Data);
17159 MP_WritePhyUshort(sc, 0x1f, 0x0000);
17160 MP_WritePhyUshort(sc, 0x1f, 0x0003);
17161 MP_WritePhyUshort(sc, 0x09, 0xA20F);
17162 MP_WritePhyUshort(sc, 0x1f, 0x0000);
17163 MP_WritePhyUshort(sc, 0x1f, 0x0003);
17164 MP_WritePhyUshort(sc, 0x01, 0x328A);
17165 MP_WritePhyUshort(sc, 0x1f, 0x0000);
17166 MP_WritePhyUshort(sc, 0x1f, 0x0003);
17167 Data = MP_ReadPhyUshort(sc, 0x19);
17168 Data &= ~BIT_0;
17169 MP_WritePhyUshort(sc, 0x19, Data);
17170 Data = MP_ReadPhyUshort(sc, 0x10);
17171 Data &= ~BIT_10;
17172 MP_WritePhyUshort(sc, 0x10, Data);
17173 MP_WritePhyUshort(sc, 0x1f, 0x0000);
17174 MP_WritePhyUshort(sc, 0x00, 0x9200);
17175
17176 MP_WritePhyUshort(sc, 0x1F, 0x0005);
17177 MP_WritePhyUshort(sc, 0x05, 0x8B80);
17178 Data = MP_ReadPhyUshort(sc, 0x06);
17179 Data |= BIT_2 | BIT_1;
17180 MP_WritePhyUshort(sc, 0x06, Data);
17181 MP_WritePhyUshort(sc, 0x1f, 0x0000);
17182
17183 MP_WritePhyUshort(sc, 0x1F, 0x0007);
17184 MP_WritePhyUshort(sc, 0x1E, 0x002D);
17185 Data = MP_ReadPhyUshort(sc, 0x18);
17186 Data |= BIT_4;
17187 MP_WritePhyUshort(sc, 0x18, Data);
17188 MP_WritePhyUshort(sc, 0x1f, 0x0002);
17189 MP_WritePhyUshort(sc, 0x1f, 0x0000);
17190 Data = MP_ReadPhyUshort(sc, 0x14);
17191 Data |= BIT_15;
17192 MP_WritePhyUshort(sc, 0x14, Data);
17193
17194 MP_WritePhyUshort(sc, 0x1F, 0x0005);
17195 MP_WritePhyUshort(sc, 0x05, 0x8B86);
17196 Data = MP_ReadPhyUshort(sc, 0x06);
17197 Data |= BIT_0;
17198 MP_WritePhyUshort(sc, 0x06, Data);
17199 MP_WritePhyUshort(sc, 0x1f, 0x0000);
17200
17201 MP_WritePhyUshort(sc, 0x1F, 0x0005);
17202 MP_WritePhyUshort(sc, 0x05, 0x8B85);
17203 Data = MP_ReadPhyUshort(sc, 0x06);
17204 Data |= BIT_14;
17205 MP_WritePhyUshort(sc, 0x06, Data);
17206 MP_WritePhyUshort(sc, 0x1f, 0x0000);
17207
17208 MP_WritePhyUshort(sc, 0x1F, 0x0003);
17209 MP_WritePhyUshort(sc, 0x09, 0xA20F);
17210 MP_WritePhyUshort(sc, 0x1F, 0x0000);
17211
17212 MP_WritePhyUshort(sc, 0x1F, 0x0005);
17213 MP_WritePhyUshort(sc, 0x05, 0x8B55);
17214 MP_WritePhyUshort(sc, 0x06, 0x0000);
17215 MP_WritePhyUshort(sc, 0x05, 0x8B5E);
17216 MP_WritePhyUshort(sc, 0x06, 0x0000);
17217 MP_WritePhyUshort(sc, 0x05, 0x8B67);
17218 MP_WritePhyUshort(sc, 0x06, 0x0000);
17219 MP_WritePhyUshort(sc, 0x05, 0x8B70);
17220 MP_WritePhyUshort(sc, 0x06, 0x0000);
17221 MP_WritePhyUshort(sc, 0x1f, 0x0000);
17222 MP_WritePhyUshort(sc, 0x1F, 0x0007);
17223 MP_WritePhyUshort(sc, 0x1E, 0x0078);
17224 MP_WritePhyUshort(sc, 0x17, 0x0000);
17225 MP_WritePhyUshort(sc, 0x19, 0x00FB);
17226 MP_WritePhyUshort(sc, 0x1f, 0x0000);
17227
17228 MP_WritePhyUshort(sc, 0x1F, 0x0005);
17229 MP_WritePhyUshort(sc, 0x05, 0x8B79);
17230 MP_WritePhyUshort(sc, 0x06, 0xAA00);
17231 MP_WritePhyUshort(sc, 0x1f, 0x0000);
17232
17233 MP_WritePhyUshort(sc, 0x1F, 0x0003);
17234 MP_WritePhyUshort(sc, 0x01, 0x328A);
17235 MP_WritePhyUshort(sc, 0x1F, 0x0000);
17236
17237 MP_WritePhyUshort(sc, 0x1F, 0x0005);
17238 MP_WritePhyUshort(sc, 0x05, 0x8B54);
17239 Data = MP_ReadPhyUshort(sc, 0x06);
17240 Data &= ~BIT_11;
17241 MP_WritePhyUshort(sc, 0x06, Data);
17242 MP_WritePhyUshort(sc, 0x05, 0x8B5D);
17243 Data = MP_ReadPhyUshort(sc, 0x06);
17244 Data &= ~BIT_11;
17245 MP_WritePhyUshort(sc, 0x06, Data);
17246 MP_WritePhyUshort(sc, 0x05, 0x8A7C);
17247 Data = MP_ReadPhyUshort(sc, 0x06);
17248 Data &= ~BIT_8;
17249 MP_WritePhyUshort(sc, 0x06, Data);
17250 MP_WritePhyUshort(sc, 0x05, 0x8A7F);
17251 Data = MP_ReadPhyUshort(sc, 0x06);
17252 Data |= BIT_8;
17253 MP_WritePhyUshort(sc, 0x06, Data);
17254 MP_WritePhyUshort(sc, 0x05, 0x8A82);
17255 Data = MP_ReadPhyUshort(sc, 0x06);
17256 Data &= ~BIT_8;
17257 MP_WritePhyUshort(sc, 0x06, Data);
17258 MP_WritePhyUshort(sc, 0x05, 0x8A85);
17259 Data = MP_ReadPhyUshort(sc, 0x06);
17260 Data &= ~BIT_8;
17261 MP_WritePhyUshort(sc, 0x06, Data);
17262 MP_WritePhyUshort(sc, 0x05, 0x8A88);
17263 Data = MP_ReadPhyUshort(sc, 0x06);
17264 Data &= ~BIT_8;
17265 MP_WritePhyUshort(sc, 0x06, Data);
17266 MP_WritePhyUshort(sc, 0x1F, 0x0000);
17267
17268 MP_WritePhyUshort(sc, 0x1F, 0x0005);
17269 MP_WritePhyUshort(sc, 0x05, 0x8B85);
17270 Data = MP_ReadPhyUshort(sc, 0x06);
17271 Data |= BIT_15;
17272 MP_WritePhyUshort(sc, 0x06, Data);
17273 MP_WritePhyUshort(sc, 0x1f, 0x0000);
17274
17275 MP_WritePhyUshort(sc, 0x1f, 0x0003);
17276 Data = MP_ReadPhyUshort(sc, 0x19);
17277 Data &= ~BIT_0;
17278 MP_WritePhyUshort(sc, 0x19, Data);
17279 Data = MP_ReadPhyUshort(sc, 0x10);
17280 Data &= ~BIT_10;
17281 MP_WritePhyUshort(sc, 0x10, Data);
17282 MP_WritePhyUshort(sc, 0x1f, 0x0000);
17283 } else if (sc->re_type == MACFG_53) {
17284 Data_u32 = re_eri_read(sc, 0x1D0, 4, ERIAR_ExGMAC);
17285 Data_u32 &= 0xFFFF0000;
17286 re_eri_write(sc, 0x1D0, 4, Data_u32, ERIAR_ExGMAC);
17287
17288 MP_WritePhyUshort(sc, 0x1F, 0x0000);
17289 MP_WritePhyUshort(sc, 0x18, 0x0310);
17290 MP_WritePhyUshort(sc, 0x1F, 0x0000);
17291
17292 MP_WritePhyUshort(sc, 0x1f, 0x0004);
17293 MP_WritePhyUshort(sc, 0x1f, 0x0004);
17294 MP_WritePhyUshort(sc, 0x19, 0x7070);
17295 MP_WritePhyUshort(sc, 0x1c, 0x0600);
17296 MP_WritePhyUshort(sc, 0x1d, 0x9700);
17297 MP_WritePhyUshort(sc, 0x1d, 0x7d00);
17298 MP_WritePhyUshort(sc, 0x1d, 0x6900);
17299 MP_WritePhyUshort(sc, 0x1d, 0x7d00);
17300 MP_WritePhyUshort(sc, 0x1d, 0x6800);
17301 MP_WritePhyUshort(sc, 0x1d, 0x4899);
17302 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17303 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
17304 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17305 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
17306 MP_WritePhyUshort(sc, 0x1d, 0x8000);
17307 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
17308 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
17309 MP_WritePhyUshort(sc, 0x1d, 0x4007);
17310 MP_WritePhyUshort(sc, 0x1d, 0x4400);
17311 MP_WritePhyUshort(sc, 0x1d, 0x4800);
17312 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17313 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
17314 MP_WritePhyUshort(sc, 0x1d, 0x5310);
17315 MP_WritePhyUshort(sc, 0x1d, 0x6000);
17316 MP_WritePhyUshort(sc, 0x1d, 0x6800);
17317 MP_WritePhyUshort(sc, 0x1d, 0x6736);
17318 MP_WritePhyUshort(sc, 0x1d, 0x0000);
17319 MP_WritePhyUshort(sc, 0x1d, 0x0000);
17320 MP_WritePhyUshort(sc, 0x1d, 0x571f);
17321 MP_WritePhyUshort(sc, 0x1d, 0x5ffb);
17322 MP_WritePhyUshort(sc, 0x1d, 0xaa03);
17323 MP_WritePhyUshort(sc, 0x1d, 0x5b58);
17324 MP_WritePhyUshort(sc, 0x1d, 0x301e);
17325 MP_WritePhyUshort(sc, 0x1d, 0x5b64);
17326 MP_WritePhyUshort(sc, 0x1d, 0xa6fc);
17327 MP_WritePhyUshort(sc, 0x1d, 0xdcdb);
17328 MP_WritePhyUshort(sc, 0x1d, 0x0015);
17329 MP_WritePhyUshort(sc, 0x1d, 0xb915);
17330 MP_WritePhyUshort(sc, 0x1d, 0xb511);
17331 MP_WritePhyUshort(sc, 0x1d, 0xd16b);
17332 MP_WritePhyUshort(sc, 0x1d, 0x000f);
17333 MP_WritePhyUshort(sc, 0x1d, 0xb40f);
17334 MP_WritePhyUshort(sc, 0x1d, 0xd06b);
17335 MP_WritePhyUshort(sc, 0x1d, 0x000d);
17336 MP_WritePhyUshort(sc, 0x1d, 0xb206);
17337 MP_WritePhyUshort(sc, 0x1d, 0x7c01);
17338 MP_WritePhyUshort(sc, 0x1d, 0x5800);
17339 MP_WritePhyUshort(sc, 0x1d, 0x7c04);
17340 MP_WritePhyUshort(sc, 0x1d, 0x5c00);
17341 MP_WritePhyUshort(sc, 0x1d, 0x301a);
17342 MP_WritePhyUshort(sc, 0x1d, 0x7c01);
17343 MP_WritePhyUshort(sc, 0x1d, 0x5801);
17344 MP_WritePhyUshort(sc, 0x1d, 0x7c04);
17345 MP_WritePhyUshort(sc, 0x1d, 0x5c04);
17346 MP_WritePhyUshort(sc, 0x1d, 0x301e);
17347 MP_WritePhyUshort(sc, 0x1d, 0x3079);
17348 MP_WritePhyUshort(sc, 0x1d, 0x30f1);
17349 MP_WritePhyUshort(sc, 0x1d, 0x3199);
17350 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
17351 MP_WritePhyUshort(sc, 0x1d, 0x4c60);
17352 MP_WritePhyUshort(sc, 0x1d, 0x6803);
17353 MP_WritePhyUshort(sc, 0x1d, 0x6420);
17354 MP_WritePhyUshort(sc, 0x1d, 0x0000);
17355 MP_WritePhyUshort(sc, 0x1d, 0x0000);
17356 MP_WritePhyUshort(sc, 0x1d, 0xaf03);
17357 MP_WritePhyUshort(sc, 0x1d, 0x6015);
17358 MP_WritePhyUshort(sc, 0x1d, 0x3040);
17359 MP_WritePhyUshort(sc, 0x1d, 0x6017);
17360 MP_WritePhyUshort(sc, 0x1d, 0x57e0);
17361 MP_WritePhyUshort(sc, 0x1d, 0x580c);
17362 MP_WritePhyUshort(sc, 0x1d, 0x588c);
17363 MP_WritePhyUshort(sc, 0x1d, 0x5fa3);
17364 MP_WritePhyUshort(sc, 0x1d, 0x0000);
17365 MP_WritePhyUshort(sc, 0x1d, 0x4827);
17366 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17367 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
17368 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17369 MP_WritePhyUshort(sc, 0x1d, 0x4c10);
17370 MP_WritePhyUshort(sc, 0x1d, 0x8400);
17371 MP_WritePhyUshort(sc, 0x1d, 0x7c30);
17372 MP_WritePhyUshort(sc, 0x1d, 0x6020);
17373 MP_WritePhyUshort(sc, 0x1d, 0x48bf);
17374 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17375 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
17376 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17377 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
17378 MP_WritePhyUshort(sc, 0x1d, 0xd6cf);
17379 MP_WritePhyUshort(sc, 0x1d, 0x0002);
17380 MP_WritePhyUshort(sc, 0x1d, 0x80fe);
17381 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
17382 MP_WritePhyUshort(sc, 0x1d, 0x4c80);
17383 MP_WritePhyUshort(sc, 0x1d, 0x7c20);
17384 MP_WritePhyUshort(sc, 0x1d, 0x5c20);
17385 MP_WritePhyUshort(sc, 0x1d, 0x481e);
17386 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17387 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
17388 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17389 MP_WritePhyUshort(sc, 0x1d, 0x4c02);
17390 MP_WritePhyUshort(sc, 0x1d, 0x5310);
17391 MP_WritePhyUshort(sc, 0x1d, 0x81ff);
17392 MP_WritePhyUshort(sc, 0x1d, 0x30ba);
17393 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
17394 MP_WritePhyUshort(sc, 0x1d, 0x4d00);
17395 MP_WritePhyUshort(sc, 0x1d, 0x4832);
17396 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17397 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
17398 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17399 MP_WritePhyUshort(sc, 0x1d, 0x4c10);
17400 MP_WritePhyUshort(sc, 0x1d, 0x7c08);
17401 MP_WritePhyUshort(sc, 0x1d, 0x6000);
17402 MP_WritePhyUshort(sc, 0x1d, 0xa4cc);
17403 MP_WritePhyUshort(sc, 0x1d, 0xd9b3);
17404 MP_WritePhyUshort(sc, 0x1d, 0xfffe);
17405 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
17406 MP_WritePhyUshort(sc, 0x1d, 0x4d20);
17407 MP_WritePhyUshort(sc, 0x1d, 0x7e00);
17408 MP_WritePhyUshort(sc, 0x1d, 0x6200);
17409 MP_WritePhyUshort(sc, 0x1d, 0x300b);
17410 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
17411 MP_WritePhyUshort(sc, 0x1d, 0x4dc0);
17412 MP_WritePhyUshort(sc, 0x1d, 0x0000);
17413 MP_WritePhyUshort(sc, 0x1d, 0x0000);
17414 MP_WritePhyUshort(sc, 0x1d, 0xd09d);
17415 MP_WritePhyUshort(sc, 0x1d, 0x0002);
17416 MP_WritePhyUshort(sc, 0x1d, 0xb4fe);
17417 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
17418 MP_WritePhyUshort(sc, 0x1d, 0x4d80);
17419 MP_WritePhyUshort(sc, 0x1d, 0x7c04);
17420 MP_WritePhyUshort(sc, 0x1d, 0x6004);
17421 MP_WritePhyUshort(sc, 0x1d, 0x5310);
17422 MP_WritePhyUshort(sc, 0x1d, 0x6802);
17423 MP_WritePhyUshort(sc, 0x1d, 0x6720);
17424 MP_WritePhyUshort(sc, 0x1d, 0x0000);
17425 MP_WritePhyUshort(sc, 0x1d, 0x0000);
17426 MP_WritePhyUshort(sc, 0x1d, 0x7c08);
17427 MP_WritePhyUshort(sc, 0x1d, 0x6000);
17428 MP_WritePhyUshort(sc, 0x1d, 0x486c);
17429 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17430 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
17431 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17432 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
17433 MP_WritePhyUshort(sc, 0x1d, 0x9503);
17434 MP_WritePhyUshort(sc, 0x1d, 0x7e00);
17435 MP_WritePhyUshort(sc, 0x1d, 0x6200);
17436 MP_WritePhyUshort(sc, 0x1d, 0x571f);
17437 MP_WritePhyUshort(sc, 0x1d, 0x5fbb);
17438 MP_WritePhyUshort(sc, 0x1d, 0xaa03);
17439 MP_WritePhyUshort(sc, 0x1d, 0x5b58);
17440 MP_WritePhyUshort(sc, 0x1d, 0x3092);
17441 MP_WritePhyUshort(sc, 0x1d, 0x5b64);
17442 MP_WritePhyUshort(sc, 0x1d, 0xcdab);
17443 MP_WritePhyUshort(sc, 0x1d, 0xff78);
17444 MP_WritePhyUshort(sc, 0x1d, 0xcd8d);
17445 MP_WritePhyUshort(sc, 0x1d, 0xff76);
17446 MP_WritePhyUshort(sc, 0x1d, 0xd96b);
17447 MP_WritePhyUshort(sc, 0x1d, 0xff74);
17448 MP_WritePhyUshort(sc, 0x1d, 0xd0a0);
17449 MP_WritePhyUshort(sc, 0x1d, 0xffd9);
17450 MP_WritePhyUshort(sc, 0x1d, 0xcba0);
17451 MP_WritePhyUshort(sc, 0x1d, 0x0003);
17452 MP_WritePhyUshort(sc, 0x1d, 0x80f0);
17453 MP_WritePhyUshort(sc, 0x1d, 0x309f);
17454 MP_WritePhyUshort(sc, 0x1d, 0x30ac);
17455 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
17456 MP_WritePhyUshort(sc, 0x1d, 0x4ce0);
17457 MP_WritePhyUshort(sc, 0x1d, 0x4832);
17458 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17459 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
17460 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17461 MP_WritePhyUshort(sc, 0x1d, 0x4c08);
17462 MP_WritePhyUshort(sc, 0x1d, 0x7c08);
17463 MP_WritePhyUshort(sc, 0x1d, 0x6008);
17464 MP_WritePhyUshort(sc, 0x1d, 0x8300);
17465 MP_WritePhyUshort(sc, 0x1d, 0xb902);
17466 MP_WritePhyUshort(sc, 0x1d, 0x3079);
17467 MP_WritePhyUshort(sc, 0x1d, 0x3061);
17468 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
17469 MP_WritePhyUshort(sc, 0x1d, 0x4da0);
17470 MP_WritePhyUshort(sc, 0x1d, 0x6400);
17471 MP_WritePhyUshort(sc, 0x1d, 0x0000);
17472 MP_WritePhyUshort(sc, 0x1d, 0x0000);
17473 MP_WritePhyUshort(sc, 0x1d, 0x57a0);
17474 MP_WritePhyUshort(sc, 0x1d, 0x590c);
17475 MP_WritePhyUshort(sc, 0x1d, 0x5fa3);
17476 MP_WritePhyUshort(sc, 0x1d, 0x0000);
17477 MP_WritePhyUshort(sc, 0x1d, 0xcba4);
17478 MP_WritePhyUshort(sc, 0x1d, 0x0004);
17479 MP_WritePhyUshort(sc, 0x1d, 0xcd8d);
17480 MP_WritePhyUshort(sc, 0x1d, 0x0002);
17481 MP_WritePhyUshort(sc, 0x1d, 0x80fc);
17482 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
17483 MP_WritePhyUshort(sc, 0x1d, 0x4ca0);
17484 MP_WritePhyUshort(sc, 0x1d, 0xb603);
17485 MP_WritePhyUshort(sc, 0x1d, 0x7c10);
17486 MP_WritePhyUshort(sc, 0x1d, 0x6010);
17487 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17488 MP_WritePhyUshort(sc, 0x1d, 0x541f);
17489 MP_WritePhyUshort(sc, 0x1d, 0x5fb3);
17490 MP_WritePhyUshort(sc, 0x1d, 0xaa05);
17491 MP_WritePhyUshort(sc, 0x1d, 0x7c80);
17492 MP_WritePhyUshort(sc, 0x1d, 0x5800);
17493 MP_WritePhyUshort(sc, 0x1d, 0x5b58);
17494 MP_WritePhyUshort(sc, 0x1d, 0x30ca);
17495 MP_WritePhyUshort(sc, 0x1d, 0x7c80);
17496 MP_WritePhyUshort(sc, 0x1d, 0x5800);
17497 MP_WritePhyUshort(sc, 0x1d, 0x5b64);
17498 MP_WritePhyUshort(sc, 0x1d, 0x4824);
17499 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17500 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
17501 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17502 MP_WritePhyUshort(sc, 0x1d, 0x4c04);
17503 MP_WritePhyUshort(sc, 0x1d, 0x8200);
17504 MP_WritePhyUshort(sc, 0x1d, 0x4827);
17505 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17506 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
17507 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17508 MP_WritePhyUshort(sc, 0x1d, 0x4c10);
17509 MP_WritePhyUshort(sc, 0x1d, 0x8400);
17510 MP_WritePhyUshort(sc, 0x1d, 0x7c10);
17511 MP_WritePhyUshort(sc, 0x1d, 0x6000);
17512 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
17513 MP_WritePhyUshort(sc, 0x1d, 0x4cc0);
17514 MP_WritePhyUshort(sc, 0x1d, 0x5fbb);
17515 MP_WritePhyUshort(sc, 0x1d, 0x4824);
17516 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17517 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
17518 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17519 MP_WritePhyUshort(sc, 0x1d, 0x4c04);
17520 MP_WritePhyUshort(sc, 0x1d, 0x8200);
17521 MP_WritePhyUshort(sc, 0x1d, 0x7ce0);
17522 MP_WritePhyUshort(sc, 0x1d, 0x5400);
17523 MP_WritePhyUshort(sc, 0x1d, 0x6720);
17524 MP_WritePhyUshort(sc, 0x1d, 0x0000);
17525 MP_WritePhyUshort(sc, 0x1d, 0x0000);
17526 MP_WritePhyUshort(sc, 0x1d, 0x7e00);
17527 MP_WritePhyUshort(sc, 0x1d, 0x6a00);
17528 MP_WritePhyUshort(sc, 0x1d, 0x4824);
17529 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17530 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
17531 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17532 MP_WritePhyUshort(sc, 0x1d, 0x4c04);
17533 MP_WritePhyUshort(sc, 0x1d, 0x8200);
17534 MP_WritePhyUshort(sc, 0x1d, 0x7e00);
17535 MP_WritePhyUshort(sc, 0x1d, 0x6800);
17536 MP_WritePhyUshort(sc, 0x1d, 0x309f);
17537 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
17538 MP_WritePhyUshort(sc, 0x1d, 0x4e00);
17539 MP_WritePhyUshort(sc, 0x1d, 0x4007);
17540 MP_WritePhyUshort(sc, 0x1d, 0x4400);
17541 MP_WritePhyUshort(sc, 0x1d, 0x5310);
17542 MP_WritePhyUshort(sc, 0x1d, 0x6800);
17543 MP_WritePhyUshort(sc, 0x1d, 0x6736);
17544 MP_WritePhyUshort(sc, 0x1d, 0x0000);
17545 MP_WritePhyUshort(sc, 0x1d, 0x0000);
17546 MP_WritePhyUshort(sc, 0x1d, 0x570f);
17547 MP_WritePhyUshort(sc, 0x1d, 0x5fff);
17548 MP_WritePhyUshort(sc, 0x1d, 0xaa03);
17549 MP_WritePhyUshort(sc, 0x1d, 0x585b);
17550 MP_WritePhyUshort(sc, 0x1d, 0x3100);
17551 MP_WritePhyUshort(sc, 0x1d, 0x5867);
17552 MP_WritePhyUshort(sc, 0x1d, 0x9403);
17553 MP_WritePhyUshort(sc, 0x1d, 0x7e00);
17554 MP_WritePhyUshort(sc, 0x1d, 0x6200);
17555 MP_WritePhyUshort(sc, 0x1d, 0xcda3);
17556 MP_WritePhyUshort(sc, 0x1d, 0x002d);
17557 MP_WritePhyUshort(sc, 0x1d, 0xcd85);
17558 MP_WritePhyUshort(sc, 0x1d, 0x002b);
17559 MP_WritePhyUshort(sc, 0x1d, 0xd96b);
17560 MP_WritePhyUshort(sc, 0x1d, 0x0029);
17561 MP_WritePhyUshort(sc, 0x1d, 0x9629);
17562 MP_WritePhyUshort(sc, 0x1d, 0x6800);
17563 MP_WritePhyUshort(sc, 0x1d, 0x6736);
17564 MP_WritePhyUshort(sc, 0x1d, 0x0000);
17565 MP_WritePhyUshort(sc, 0x1d, 0x0000);
17566 MP_WritePhyUshort(sc, 0x1d, 0x9624);
17567 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
17568 MP_WritePhyUshort(sc, 0x1d, 0x4e20);
17569 MP_WritePhyUshort(sc, 0x1d, 0x8b04);
17570 MP_WritePhyUshort(sc, 0x1d, 0x7c08);
17571 MP_WritePhyUshort(sc, 0x1d, 0x5008);
17572 MP_WritePhyUshort(sc, 0x1d, 0xab03);
17573 MP_WritePhyUshort(sc, 0x1d, 0x7c08);
17574 MP_WritePhyUshort(sc, 0x1d, 0x5000);
17575 MP_WritePhyUshort(sc, 0x1d, 0x6801);
17576 MP_WritePhyUshort(sc, 0x1d, 0x6776);
17577 MP_WritePhyUshort(sc, 0x1d, 0x0000);
17578 MP_WritePhyUshort(sc, 0x1d, 0x0000);
17579 MP_WritePhyUshort(sc, 0x1d, 0xdb7c);
17580 MP_WritePhyUshort(sc, 0x1d, 0xffee);
17581 MP_WritePhyUshort(sc, 0x1d, 0x0000);
17582 MP_WritePhyUshort(sc, 0x1d, 0x7fe1);
17583 MP_WritePhyUshort(sc, 0x1d, 0x4e40);
17584 MP_WritePhyUshort(sc, 0x1d, 0x4837);
17585 MP_WritePhyUshort(sc, 0x1d, 0x4418);
17586 MP_WritePhyUshort(sc, 0x1d, 0x41c7);
17587 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
17588 MP_WritePhyUshort(sc, 0x1d, 0x4e40);
17589 MP_WritePhyUshort(sc, 0x1d, 0x7c40);
17590 MP_WritePhyUshort(sc, 0x1d, 0x5400);
17591 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17592 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
17593 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17594 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
17595 MP_WritePhyUshort(sc, 0x1d, 0x8f07);
17596 MP_WritePhyUshort(sc, 0x1d, 0xd2a0);
17597 MP_WritePhyUshort(sc, 0x1d, 0x004c);
17598 MP_WritePhyUshort(sc, 0x1d, 0x9205);
17599 MP_WritePhyUshort(sc, 0x1d, 0xa043);
17600 MP_WritePhyUshort(sc, 0x1d, 0x312b);
17601 MP_WritePhyUshort(sc, 0x1d, 0x300b);
17602 MP_WritePhyUshort(sc, 0x1d, 0x30f1);
17603 MP_WritePhyUshort(sc, 0x1d, 0x7fe1);
17604 MP_WritePhyUshort(sc, 0x1d, 0x4e60);
17605 MP_WritePhyUshort(sc, 0x1d, 0x489c);
17606 MP_WritePhyUshort(sc, 0x1d, 0x4628);
17607 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
17608 MP_WritePhyUshort(sc, 0x1d, 0x4e60);
17609 MP_WritePhyUshort(sc, 0x1d, 0x7e28);
17610 MP_WritePhyUshort(sc, 0x1d, 0x4628);
17611 MP_WritePhyUshort(sc, 0x1d, 0x7c40);
17612 MP_WritePhyUshort(sc, 0x1d, 0x5400);
17613 MP_WritePhyUshort(sc, 0x1d, 0x7c01);
17614 MP_WritePhyUshort(sc, 0x1d, 0x5800);
17615 MP_WritePhyUshort(sc, 0x1d, 0x7c04);
17616 MP_WritePhyUshort(sc, 0x1d, 0x5c00);
17617 MP_WritePhyUshort(sc, 0x1d, 0x41e8);
17618 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17619 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
17620 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17621 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
17622 MP_WritePhyUshort(sc, 0x1d, 0x8fec);
17623 MP_WritePhyUshort(sc, 0x1d, 0xb241);
17624 MP_WritePhyUshort(sc, 0x1d, 0xa02a);
17625 MP_WritePhyUshort(sc, 0x1d, 0x3146);
17626 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
17627 MP_WritePhyUshort(sc, 0x1d, 0x4ea0);
17628 MP_WritePhyUshort(sc, 0x1d, 0x7c02);
17629 MP_WritePhyUshort(sc, 0x1d, 0x4402);
17630 MP_WritePhyUshort(sc, 0x1d, 0x4448);
17631 MP_WritePhyUshort(sc, 0x1d, 0x4894);
17632 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17633 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
17634 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17635 MP_WritePhyUshort(sc, 0x1d, 0x4c03);
17636 MP_WritePhyUshort(sc, 0x1d, 0x4824);
17637 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17638 MP_WritePhyUshort(sc, 0x1d, 0x4c07);
17639 MP_WritePhyUshort(sc, 0x1d, 0x41ef);
17640 MP_WritePhyUshort(sc, 0x1d, 0x41ff);
17641 MP_WritePhyUshort(sc, 0x1d, 0x4891);
17642 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17643 MP_WritePhyUshort(sc, 0x1d, 0x4c07);
17644 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17645 MP_WritePhyUshort(sc, 0x1d, 0x4c17);
17646 MP_WritePhyUshort(sc, 0x1d, 0x8400);
17647 MP_WritePhyUshort(sc, 0x1d, 0x8ef8);
17648 MP_WritePhyUshort(sc, 0x1d, 0x41c7);
17649 MP_WritePhyUshort(sc, 0x1d, 0x8fd1);
17650 MP_WritePhyUshort(sc, 0x1d, 0x92d5);
17651 MP_WritePhyUshort(sc, 0x1d, 0xa10f);
17652 MP_WritePhyUshort(sc, 0x1d, 0xd480);
17653 MP_WritePhyUshort(sc, 0x1d, 0x0008);
17654 MP_WritePhyUshort(sc, 0x1d, 0xd580);
17655 MP_WritePhyUshort(sc, 0x1d, 0xffb7);
17656 MP_WritePhyUshort(sc, 0x1d, 0xa202);
17657 MP_WritePhyUshort(sc, 0x1d, 0x3161);
17658 MP_WritePhyUshort(sc, 0x1d, 0x7c04);
17659 MP_WritePhyUshort(sc, 0x1d, 0x4404);
17660 MP_WritePhyUshort(sc, 0x1d, 0x3161);
17661 MP_WritePhyUshort(sc, 0x1d, 0xd484);
17662 MP_WritePhyUshort(sc, 0x1d, 0xfff3);
17663 MP_WritePhyUshort(sc, 0x1d, 0xd484);
17664 MP_WritePhyUshort(sc, 0x1d, 0xfff1);
17665 MP_WritePhyUshort(sc, 0x1d, 0x30f1);
17666 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
17667 MP_WritePhyUshort(sc, 0x1d, 0x4ee0);
17668 MP_WritePhyUshort(sc, 0x1d, 0x7c40);
17669 MP_WritePhyUshort(sc, 0x1d, 0x5400);
17670 MP_WritePhyUshort(sc, 0x1d, 0x4488);
17671 MP_WritePhyUshort(sc, 0x1d, 0x41cf);
17672 MP_WritePhyUshort(sc, 0x1d, 0x30f1);
17673 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
17674 MP_WritePhyUshort(sc, 0x1d, 0x4ec0);
17675 MP_WritePhyUshort(sc, 0x1d, 0x48f3);
17676 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17677 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
17678 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17679 MP_WritePhyUshort(sc, 0x1d, 0x4c09);
17680 MP_WritePhyUshort(sc, 0x1d, 0x4508);
17681 MP_WritePhyUshort(sc, 0x1d, 0x41c7);
17682 MP_WritePhyUshort(sc, 0x1d, 0x8fb0);
17683 MP_WritePhyUshort(sc, 0x1d, 0xd218);
17684 MP_WritePhyUshort(sc, 0x1d, 0xffae);
17685 MP_WritePhyUshort(sc, 0x1d, 0xd2a4);
17686 MP_WritePhyUshort(sc, 0x1d, 0xff9d);
17687 MP_WritePhyUshort(sc, 0x1d, 0x3182);
17688 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
17689 MP_WritePhyUshort(sc, 0x1d, 0x4e80);
17690 MP_WritePhyUshort(sc, 0x1d, 0x4832);
17691 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17692 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
17693 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17694 MP_WritePhyUshort(sc, 0x1d, 0x4c11);
17695 MP_WritePhyUshort(sc, 0x1d, 0x4428);
17696 MP_WritePhyUshort(sc, 0x1d, 0x7c40);
17697 MP_WritePhyUshort(sc, 0x1d, 0x5440);
17698 MP_WritePhyUshort(sc, 0x1d, 0x7c01);
17699 MP_WritePhyUshort(sc, 0x1d, 0x5801);
17700 MP_WritePhyUshort(sc, 0x1d, 0x7c04);
17701 MP_WritePhyUshort(sc, 0x1d, 0x5c04);
17702 MP_WritePhyUshort(sc, 0x1d, 0x41e8);
17703 MP_WritePhyUshort(sc, 0x1d, 0xa4b3);
17704 MP_WritePhyUshort(sc, 0x1d, 0x3197);
17705 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
17706 MP_WritePhyUshort(sc, 0x1d, 0x4f20);
17707 MP_WritePhyUshort(sc, 0x1d, 0x6800);
17708 MP_WritePhyUshort(sc, 0x1d, 0x6736);
17709 MP_WritePhyUshort(sc, 0x1d, 0x0000);
17710 MP_WritePhyUshort(sc, 0x1d, 0x0000);
17711 MP_WritePhyUshort(sc, 0x1d, 0x570f);
17712 MP_WritePhyUshort(sc, 0x1d, 0x5fff);
17713 MP_WritePhyUshort(sc, 0x1d, 0xaa03);
17714 MP_WritePhyUshort(sc, 0x1d, 0x585b);
17715 MP_WritePhyUshort(sc, 0x1d, 0x31a5);
17716 MP_WritePhyUshort(sc, 0x1d, 0x5867);
17717 MP_WritePhyUshort(sc, 0x1d, 0xbcf4);
17718 MP_WritePhyUshort(sc, 0x1d, 0x300b);
17719 MP_WritePhyUshort(sc, 0x1f, 0x0004);
17720 MP_WritePhyUshort(sc, 0x1c, 0x0200);
17721 MP_WritePhyUshort(sc, 0x19, 0x7030);
17722 MP_WritePhyUshort(sc, 0x1f, 0x0000);
17723
17724 if (phy_power_saving == 1) {
17725 MP_WritePhyUshort(sc, 0x1F, 0x0000);
17726 MP_WritePhyUshort(sc, 0x18, 0x8310);
17727 MP_WritePhyUshort(sc, 0x1F, 0x0000);
17728 } else {
17729 MP_WritePhyUshort(sc, 0x1F, 0x0000);
17730 MP_WritePhyUshort(sc, 0x18, 0x0310);
17731 MP_WritePhyUshort(sc, 0x1F, 0x0000);
17732 DELAY(20000);
17733 }
17734
17735 MP_WritePhyUshort(sc, 0x1F, 0x0000);
17736 MP_WritePhyUshort(sc, 0x0D, 0x0007);
17737 MP_WritePhyUshort(sc, 0x0E, 0x003C);
17738 MP_WritePhyUshort(sc, 0x0D, 0x4007);
17739 MP_WritePhyUshort(sc, 0x0E, 0x0000);
17740 MP_WritePhyUshort(sc, 0x0D, 0x0000);
17741 } else if (sc->re_type == MACFG_54 || sc->re_type == MACFG_55) {
17742 Data_u32 = re_eri_read(sc, 0x1D0, 4, ERIAR_ExGMAC);
17743 Data_u32 &= 0xFFFF0000;
17744 re_eri_write(sc, 0x1D0, 4, Data_u32, ERIAR_ExGMAC);
17745
17746 if (sc->re_type == MACFG_55) {
17747 MP_WritePhyUshort(sc, 0x1F, 0x0000);
17748 MP_WritePhyUshort(sc, 0x18, 0x0310);
17749 MP_WritePhyUshort(sc, 0x1F, 0x0000);
17750
17751 MP_WritePhyUshort(sc, 0x1f, 0x0004);
17752 MP_WritePhyUshort(sc, 0x1f, 0x0004);
17753 MP_WritePhyUshort(sc, 0x19, 0x7070);
17754 MP_WritePhyUshort(sc, 0x1c, 0x0600);
17755 MP_WritePhyUshort(sc, 0x1d, 0x9700);
17756 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
17757 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
17758 MP_WritePhyUshort(sc, 0x1d, 0x4007);
17759 MP_WritePhyUshort(sc, 0x1d, 0x4400);
17760 MP_WritePhyUshort(sc, 0x1d, 0x4800);
17761 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17762 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
17763 MP_WritePhyUshort(sc, 0x1d, 0x5310);
17764 MP_WritePhyUshort(sc, 0x1d, 0x6000);
17765 MP_WritePhyUshort(sc, 0x1d, 0x6800);
17766 MP_WritePhyUshort(sc, 0x1d, 0x673e);
17767 MP_WritePhyUshort(sc, 0x1d, 0x0000);
17768 MP_WritePhyUshort(sc, 0x1d, 0x0000);
17769 MP_WritePhyUshort(sc, 0x1d, 0x571f);
17770 MP_WritePhyUshort(sc, 0x1d, 0x5ffb);
17771 MP_WritePhyUshort(sc, 0x1d, 0xaa04);
17772 MP_WritePhyUshort(sc, 0x1d, 0x5b58);
17773 MP_WritePhyUshort(sc, 0x1d, 0x6100);
17774 MP_WritePhyUshort(sc, 0x1d, 0x3016);
17775 MP_WritePhyUshort(sc, 0x1d, 0x5b64);
17776 MP_WritePhyUshort(sc, 0x1d, 0x6080);
17777 MP_WritePhyUshort(sc, 0x1d, 0xa6fa);
17778 MP_WritePhyUshort(sc, 0x1d, 0xdcdb);
17779 MP_WritePhyUshort(sc, 0x1d, 0x0015);
17780 MP_WritePhyUshort(sc, 0x1d, 0xb915);
17781 MP_WritePhyUshort(sc, 0x1d, 0xb511);
17782 MP_WritePhyUshort(sc, 0x1d, 0xd16b);
17783 MP_WritePhyUshort(sc, 0x1d, 0x000f);
17784 MP_WritePhyUshort(sc, 0x1d, 0xb40f);
17785 MP_WritePhyUshort(sc, 0x1d, 0xd06b);
17786 MP_WritePhyUshort(sc, 0x1d, 0x000d);
17787 MP_WritePhyUshort(sc, 0x1d, 0xb206);
17788 MP_WritePhyUshort(sc, 0x1d, 0x7c01);
17789 MP_WritePhyUshort(sc, 0x1d, 0x5800);
17790 MP_WritePhyUshort(sc, 0x1d, 0x7c04);
17791 MP_WritePhyUshort(sc, 0x1d, 0x5c00);
17792 MP_WritePhyUshort(sc, 0x1d, 0x3010);
17793 MP_WritePhyUshort(sc, 0x1d, 0x7c01);
17794 MP_WritePhyUshort(sc, 0x1d, 0x5801);
17795 MP_WritePhyUshort(sc, 0x1d, 0x7c04);
17796 MP_WritePhyUshort(sc, 0x1d, 0x5c04);
17797 MP_WritePhyUshort(sc, 0x1d, 0x3016);
17798 MP_WritePhyUshort(sc, 0x1d, 0x307e);
17799 MP_WritePhyUshort(sc, 0x1d, 0x30f4);
17800 MP_WritePhyUshort(sc, 0x1d, 0x319f);
17801 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
17802 MP_WritePhyUshort(sc, 0x1d, 0x4c60);
17803 MP_WritePhyUshort(sc, 0x1d, 0x6803);
17804 MP_WritePhyUshort(sc, 0x1d, 0x7d00);
17805 MP_WritePhyUshort(sc, 0x1d, 0x6900);
17806 MP_WritePhyUshort(sc, 0x1d, 0x6520);
17807 MP_WritePhyUshort(sc, 0x1d, 0x0000);
17808 MP_WritePhyUshort(sc, 0x1d, 0x0000);
17809 MP_WritePhyUshort(sc, 0x1d, 0xaf03);
17810 MP_WritePhyUshort(sc, 0x1d, 0x6115);
17811 MP_WritePhyUshort(sc, 0x1d, 0x303a);
17812 MP_WritePhyUshort(sc, 0x1d, 0x6097);
17813 MP_WritePhyUshort(sc, 0x1d, 0x57e0);
17814 MP_WritePhyUshort(sc, 0x1d, 0x580c);
17815 MP_WritePhyUshort(sc, 0x1d, 0x588c);
17816 MP_WritePhyUshort(sc, 0x1d, 0x5f80);
17817 MP_WritePhyUshort(sc, 0x1d, 0x4827);
17818 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17819 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
17820 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17821 MP_WritePhyUshort(sc, 0x1d, 0x4c10);
17822 MP_WritePhyUshort(sc, 0x1d, 0x8400);
17823 MP_WritePhyUshort(sc, 0x1d, 0x7c30);
17824 MP_WritePhyUshort(sc, 0x1d, 0x6020);
17825 MP_WritePhyUshort(sc, 0x1d, 0x48bf);
17826 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17827 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
17828 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17829 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
17830 MP_WritePhyUshort(sc, 0x1d, 0xb802);
17831 MP_WritePhyUshort(sc, 0x1d, 0x3053);
17832 MP_WritePhyUshort(sc, 0x1d, 0x7c08);
17833 MP_WritePhyUshort(sc, 0x1d, 0x6808);
17834 MP_WritePhyUshort(sc, 0x1d, 0x0000);
17835 MP_WritePhyUshort(sc, 0x1d, 0x0000);
17836 MP_WritePhyUshort(sc, 0x1d, 0x7c10);
17837 MP_WritePhyUshort(sc, 0x1d, 0x6810);
17838 MP_WritePhyUshort(sc, 0x1d, 0xd6cf);
17839 MP_WritePhyUshort(sc, 0x1d, 0x0002);
17840 MP_WritePhyUshort(sc, 0x1d, 0x80fe);
17841 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
17842 MP_WritePhyUshort(sc, 0x1d, 0x4c80);
17843 MP_WritePhyUshort(sc, 0x1d, 0x7c10);
17844 MP_WritePhyUshort(sc, 0x1d, 0x6800);
17845 MP_WritePhyUshort(sc, 0x1d, 0x7c08);
17846 MP_WritePhyUshort(sc, 0x1d, 0x6800);
17847 MP_WritePhyUshort(sc, 0x1d, 0x0000);
17848 MP_WritePhyUshort(sc, 0x1d, 0x0000);
17849 MP_WritePhyUshort(sc, 0x1d, 0x7c23);
17850 MP_WritePhyUshort(sc, 0x1d, 0x5c23);
17851 MP_WritePhyUshort(sc, 0x1d, 0x481e);
17852 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17853 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
17854 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17855 MP_WritePhyUshort(sc, 0x1d, 0x4c02);
17856 MP_WritePhyUshort(sc, 0x1d, 0x5310);
17857 MP_WritePhyUshort(sc, 0x1d, 0x81ff);
17858 MP_WritePhyUshort(sc, 0x1d, 0x30c1);
17859 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
17860 MP_WritePhyUshort(sc, 0x1d, 0x4d00);
17861 MP_WritePhyUshort(sc, 0x1d, 0x4832);
17862 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17863 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
17864 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17865 MP_WritePhyUshort(sc, 0x1d, 0x4c10);
17866 MP_WritePhyUshort(sc, 0x1d, 0x7c08);
17867 MP_WritePhyUshort(sc, 0x1d, 0x6000);
17868 MP_WritePhyUshort(sc, 0x1d, 0xa4bd);
17869 MP_WritePhyUshort(sc, 0x1d, 0xd9b3);
17870 MP_WritePhyUshort(sc, 0x1d, 0x00fe);
17871 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
17872 MP_WritePhyUshort(sc, 0x1d, 0x4d20);
17873 MP_WritePhyUshort(sc, 0x1d, 0x7e00);
17874 MP_WritePhyUshort(sc, 0x1d, 0x6200);
17875 MP_WritePhyUshort(sc, 0x1d, 0x3001);
17876 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
17877 MP_WritePhyUshort(sc, 0x1d, 0x4dc0);
17878 MP_WritePhyUshort(sc, 0x1d, 0xd09d);
17879 MP_WritePhyUshort(sc, 0x1d, 0x0002);
17880 MP_WritePhyUshort(sc, 0x1d, 0xb4fe);
17881 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
17882 MP_WritePhyUshort(sc, 0x1d, 0x4d80);
17883 MP_WritePhyUshort(sc, 0x1d, 0x7c04);
17884 MP_WritePhyUshort(sc, 0x1d, 0x6004);
17885 MP_WritePhyUshort(sc, 0x1d, 0x6802);
17886 MP_WritePhyUshort(sc, 0x1d, 0x6728);
17887 MP_WritePhyUshort(sc, 0x1d, 0x0000);
17888 MP_WritePhyUshort(sc, 0x1d, 0x0000);
17889 MP_WritePhyUshort(sc, 0x1d, 0x7c08);
17890 MP_WritePhyUshort(sc, 0x1d, 0x6000);
17891 MP_WritePhyUshort(sc, 0x1d, 0x486c);
17892 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17893 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
17894 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17895 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
17896 MP_WritePhyUshort(sc, 0x1d, 0x9503);
17897 MP_WritePhyUshort(sc, 0x1d, 0x7e00);
17898 MP_WritePhyUshort(sc, 0x1d, 0x6200);
17899 MP_WritePhyUshort(sc, 0x1d, 0x571f);
17900 MP_WritePhyUshort(sc, 0x1d, 0x5fbb);
17901 MP_WritePhyUshort(sc, 0x1d, 0xaa05);
17902 MP_WritePhyUshort(sc, 0x1d, 0x5b58);
17903 MP_WritePhyUshort(sc, 0x1d, 0x7d80);
17904 MP_WritePhyUshort(sc, 0x1d, 0x6100);
17905 MP_WritePhyUshort(sc, 0x1d, 0x309a);
17906 MP_WritePhyUshort(sc, 0x1d, 0x5b64);
17907 MP_WritePhyUshort(sc, 0x1d, 0x7d80);
17908 MP_WritePhyUshort(sc, 0x1d, 0x6080);
17909 MP_WritePhyUshort(sc, 0x1d, 0xcdab);
17910 MP_WritePhyUshort(sc, 0x1d, 0x0058);
17911 MP_WritePhyUshort(sc, 0x1d, 0xcd8d);
17912 MP_WritePhyUshort(sc, 0x1d, 0x0056);
17913 MP_WritePhyUshort(sc, 0x1d, 0xd96b);
17914 MP_WritePhyUshort(sc, 0x1d, 0x0054);
17915 MP_WritePhyUshort(sc, 0x1d, 0xd0a0);
17916 MP_WritePhyUshort(sc, 0x1d, 0x00d8);
17917 MP_WritePhyUshort(sc, 0x1d, 0xcba0);
17918 MP_WritePhyUshort(sc, 0x1d, 0x0003);
17919 MP_WritePhyUshort(sc, 0x1d, 0x80ec);
17920 MP_WritePhyUshort(sc, 0x1d, 0x30a7);
17921 MP_WritePhyUshort(sc, 0x1d, 0x30b4);
17922 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
17923 MP_WritePhyUshort(sc, 0x1d, 0x4ce0);
17924 MP_WritePhyUshort(sc, 0x1d, 0x4832);
17925 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17926 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
17927 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17928 MP_WritePhyUshort(sc, 0x1d, 0x4c08);
17929 MP_WritePhyUshort(sc, 0x1d, 0x7c08);
17930 MP_WritePhyUshort(sc, 0x1d, 0x6008);
17931 MP_WritePhyUshort(sc, 0x1d, 0x8300);
17932 MP_WritePhyUshort(sc, 0x1d, 0xb902);
17933 MP_WritePhyUshort(sc, 0x1d, 0x307e);
17934 MP_WritePhyUshort(sc, 0x1d, 0x3068);
17935 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
17936 MP_WritePhyUshort(sc, 0x1d, 0x4da0);
17937 MP_WritePhyUshort(sc, 0x1d, 0x6608);
17938 MP_WritePhyUshort(sc, 0x1d, 0x0000);
17939 MP_WritePhyUshort(sc, 0x1d, 0x0000);
17940 MP_WritePhyUshort(sc, 0x1d, 0x56a0);
17941 MP_WritePhyUshort(sc, 0x1d, 0x590c);
17942 MP_WritePhyUshort(sc, 0x1d, 0x5fa0);
17943 MP_WritePhyUshort(sc, 0x1d, 0xcba4);
17944 MP_WritePhyUshort(sc, 0x1d, 0x0004);
17945 MP_WritePhyUshort(sc, 0x1d, 0xcd8d);
17946 MP_WritePhyUshort(sc, 0x1d, 0x0002);
17947 MP_WritePhyUshort(sc, 0x1d, 0x80fc);
17948 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
17949 MP_WritePhyUshort(sc, 0x1d, 0x4ca0);
17950 MP_WritePhyUshort(sc, 0x1d, 0x7c08);
17951 MP_WritePhyUshort(sc, 0x1d, 0x6408);
17952 MP_WritePhyUshort(sc, 0x1d, 0x0000);
17953 MP_WritePhyUshort(sc, 0x1d, 0x0000);
17954 MP_WritePhyUshort(sc, 0x1d, 0x7d00);
17955 MP_WritePhyUshort(sc, 0x1d, 0x6800);
17956 MP_WritePhyUshort(sc, 0x1d, 0xb603);
17957 MP_WritePhyUshort(sc, 0x1d, 0x7c10);
17958 MP_WritePhyUshort(sc, 0x1d, 0x6010);
17959 MP_WritePhyUshort(sc, 0x1d, 0x7d1f);
17960 MP_WritePhyUshort(sc, 0x1d, 0x551f);
17961 MP_WritePhyUshort(sc, 0x1d, 0x5fb3);
17962 MP_WritePhyUshort(sc, 0x1d, 0xaa05);
17963 MP_WritePhyUshort(sc, 0x1d, 0x7c80);
17964 MP_WritePhyUshort(sc, 0x1d, 0x5800);
17965 MP_WritePhyUshort(sc, 0x1d, 0x5b58);
17966 MP_WritePhyUshort(sc, 0x1d, 0x30d7);
17967 MP_WritePhyUshort(sc, 0x1d, 0x7c80);
17968 MP_WritePhyUshort(sc, 0x1d, 0x5800);
17969 MP_WritePhyUshort(sc, 0x1d, 0x5b64);
17970 MP_WritePhyUshort(sc, 0x1d, 0x4827);
17971 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17972 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
17973 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17974 MP_WritePhyUshort(sc, 0x1d, 0x4c10);
17975 MP_WritePhyUshort(sc, 0x1d, 0x8400);
17976 MP_WritePhyUshort(sc, 0x1d, 0x7c10);
17977 MP_WritePhyUshort(sc, 0x1d, 0x6000);
17978 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
17979 MP_WritePhyUshort(sc, 0x1d, 0x4cc0);
17980 MP_WritePhyUshort(sc, 0x1d, 0x7d00);
17981 MP_WritePhyUshort(sc, 0x1d, 0x6400);
17982 MP_WritePhyUshort(sc, 0x1d, 0x0000);
17983 MP_WritePhyUshort(sc, 0x1d, 0x0000);
17984 MP_WritePhyUshort(sc, 0x1d, 0x5fbb);
17985 MP_WritePhyUshort(sc, 0x1d, 0x4824);
17986 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17987 MP_WritePhyUshort(sc, 0x1d, 0x4c00);
17988 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
17989 MP_WritePhyUshort(sc, 0x1d, 0x4c04);
17990 MP_WritePhyUshort(sc, 0x1d, 0x8200);
17991 MP_WritePhyUshort(sc, 0x1d, 0x7ce0);
17992 MP_WritePhyUshort(sc, 0x1d, 0x5400);
17993 MP_WritePhyUshort(sc, 0x1d, 0x7d00);
17994 MP_WritePhyUshort(sc, 0x1d, 0x6500);
17995 MP_WritePhyUshort(sc, 0x1d, 0x0000);
17996 MP_WritePhyUshort(sc, 0x1d, 0x0000);
17997 MP_WritePhyUshort(sc, 0x1d, 0x30a7);
17998 MP_WritePhyUshort(sc, 0x1d, 0x3001);
17999 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
18000 MP_WritePhyUshort(sc, 0x1d, 0x4e00);
18001 MP_WritePhyUshort(sc, 0x1d, 0x4007);
18002 MP_WritePhyUshort(sc, 0x1d, 0x4400);
18003 MP_WritePhyUshort(sc, 0x1d, 0x5310);
18004 MP_WritePhyUshort(sc, 0x1d, 0x6800);
18005 MP_WritePhyUshort(sc, 0x1d, 0x673e);
18006 MP_WritePhyUshort(sc, 0x1d, 0x0000);
18007 MP_WritePhyUshort(sc, 0x1d, 0x0000);
18008 MP_WritePhyUshort(sc, 0x1d, 0x570f);
18009 MP_WritePhyUshort(sc, 0x1d, 0x5fff);
18010 MP_WritePhyUshort(sc, 0x1d, 0xaa05);
18011 MP_WritePhyUshort(sc, 0x1d, 0x585b);
18012 MP_WritePhyUshort(sc, 0x1d, 0x7d80);
18013 MP_WritePhyUshort(sc, 0x1d, 0x6100);
18014 MP_WritePhyUshort(sc, 0x1d, 0x3107);
18015 MP_WritePhyUshort(sc, 0x1d, 0x5867);
18016 MP_WritePhyUshort(sc, 0x1d, 0x7d80);
18017 MP_WritePhyUshort(sc, 0x1d, 0x6080);
18018 MP_WritePhyUshort(sc, 0x1d, 0x9403);
18019 MP_WritePhyUshort(sc, 0x1d, 0x7e00);
18020 MP_WritePhyUshort(sc, 0x1d, 0x6200);
18021 MP_WritePhyUshort(sc, 0x1d, 0xcda3);
18022 MP_WritePhyUshort(sc, 0x1d, 0x00e8);
18023 MP_WritePhyUshort(sc, 0x1d, 0xcd85);
18024 MP_WritePhyUshort(sc, 0x1d, 0x00e6);
18025 MP_WritePhyUshort(sc, 0x1d, 0xd96b);
18026 MP_WritePhyUshort(sc, 0x1d, 0x00e4);
18027 MP_WritePhyUshort(sc, 0x1d, 0x96e4);
18028 MP_WritePhyUshort(sc, 0x1d, 0x6800);
18029 MP_WritePhyUshort(sc, 0x1d, 0x673e);
18030 MP_WritePhyUshort(sc, 0x1d, 0x0000);
18031 MP_WritePhyUshort(sc, 0x1d, 0x0000);
18032 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
18033 MP_WritePhyUshort(sc, 0x1d, 0x4e20);
18034 MP_WritePhyUshort(sc, 0x1d, 0x96dd);
18035 MP_WritePhyUshort(sc, 0x1d, 0x8b04);
18036 MP_WritePhyUshort(sc, 0x1d, 0x7c08);
18037 MP_WritePhyUshort(sc, 0x1d, 0x5008);
18038 MP_WritePhyUshort(sc, 0x1d, 0xab03);
18039 MP_WritePhyUshort(sc, 0x1d, 0x7c08);
18040 MP_WritePhyUshort(sc, 0x1d, 0x5000);
18041 MP_WritePhyUshort(sc, 0x1d, 0x6801);
18042 MP_WritePhyUshort(sc, 0x1d, 0x677e);
18043 MP_WritePhyUshort(sc, 0x1d, 0x0000);
18044 MP_WritePhyUshort(sc, 0x1d, 0x0000);
18045 MP_WritePhyUshort(sc, 0x1d, 0xdb7c);
18046 MP_WritePhyUshort(sc, 0x1d, 0x00ee);
18047 MP_WritePhyUshort(sc, 0x1d, 0x0000);
18048 MP_WritePhyUshort(sc, 0x1d, 0x7fe1);
18049 MP_WritePhyUshort(sc, 0x1d, 0x4e40);
18050 MP_WritePhyUshort(sc, 0x1d, 0x4837);
18051 MP_WritePhyUshort(sc, 0x1d, 0x4418);
18052 MP_WritePhyUshort(sc, 0x1d, 0x41c7);
18053 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
18054 MP_WritePhyUshort(sc, 0x1d, 0x4e40);
18055 MP_WritePhyUshort(sc, 0x1d, 0x7c40);
18056 MP_WritePhyUshort(sc, 0x1d, 0x5400);
18057 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
18058 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
18059 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
18060 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
18061 MP_WritePhyUshort(sc, 0x1d, 0x8fc2);
18062 MP_WritePhyUshort(sc, 0x1d, 0xd2a0);
18063 MP_WritePhyUshort(sc, 0x1d, 0x004b);
18064 MP_WritePhyUshort(sc, 0x1d, 0x9204);
18065 MP_WritePhyUshort(sc, 0x1d, 0xa042);
18066 MP_WritePhyUshort(sc, 0x1d, 0x3132);
18067 MP_WritePhyUshort(sc, 0x1d, 0x30f4);
18068 MP_WritePhyUshort(sc, 0x1d, 0x7fe1);
18069 MP_WritePhyUshort(sc, 0x1d, 0x4e60);
18070 MP_WritePhyUshort(sc, 0x1d, 0x489c);
18071 MP_WritePhyUshort(sc, 0x1d, 0x4628);
18072 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
18073 MP_WritePhyUshort(sc, 0x1d, 0x4e60);
18074 MP_WritePhyUshort(sc, 0x1d, 0x7e28);
18075 MP_WritePhyUshort(sc, 0x1d, 0x4628);
18076 MP_WritePhyUshort(sc, 0x1d, 0x7c40);
18077 MP_WritePhyUshort(sc, 0x1d, 0x5400);
18078 MP_WritePhyUshort(sc, 0x1d, 0x7c01);
18079 MP_WritePhyUshort(sc, 0x1d, 0x5800);
18080 MP_WritePhyUshort(sc, 0x1d, 0x7c04);
18081 MP_WritePhyUshort(sc, 0x1d, 0x5c00);
18082 MP_WritePhyUshort(sc, 0x1d, 0x41e8);
18083 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
18084 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
18085 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
18086 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
18087 MP_WritePhyUshort(sc, 0x1d, 0x8fa8);
18088 MP_WritePhyUshort(sc, 0x1d, 0xb241);
18089 MP_WritePhyUshort(sc, 0x1d, 0xa02a);
18090 MP_WritePhyUshort(sc, 0x1d, 0x314c);
18091 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
18092 MP_WritePhyUshort(sc, 0x1d, 0x4ea0);
18093 MP_WritePhyUshort(sc, 0x1d, 0x7c02);
18094 MP_WritePhyUshort(sc, 0x1d, 0x4402);
18095 MP_WritePhyUshort(sc, 0x1d, 0x4448);
18096 MP_WritePhyUshort(sc, 0x1d, 0x4894);
18097 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
18098 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
18099 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
18100 MP_WritePhyUshort(sc, 0x1d, 0x4c03);
18101 MP_WritePhyUshort(sc, 0x1d, 0x4824);
18102 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
18103 MP_WritePhyUshort(sc, 0x1d, 0x4c07);
18104 MP_WritePhyUshort(sc, 0x1d, 0x41ef);
18105 MP_WritePhyUshort(sc, 0x1d, 0x41ff);
18106 MP_WritePhyUshort(sc, 0x1d, 0x4891);
18107 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
18108 MP_WritePhyUshort(sc, 0x1d, 0x4c07);
18109 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
18110 MP_WritePhyUshort(sc, 0x1d, 0x4c17);
18111 MP_WritePhyUshort(sc, 0x1d, 0x8400);
18112 MP_WritePhyUshort(sc, 0x1d, 0x8ef8);
18113 MP_WritePhyUshort(sc, 0x1d, 0x41c7);
18114 MP_WritePhyUshort(sc, 0x1d, 0x8f8d);
18115 MP_WritePhyUshort(sc, 0x1d, 0x92d5);
18116 MP_WritePhyUshort(sc, 0x1d, 0xa10f);
18117 MP_WritePhyUshort(sc, 0x1d, 0xd480);
18118 MP_WritePhyUshort(sc, 0x1d, 0x0008);
18119 MP_WritePhyUshort(sc, 0x1d, 0xd580);
18120 MP_WritePhyUshort(sc, 0x1d, 0x00b8);
18121 MP_WritePhyUshort(sc, 0x1d, 0xa202);
18122 MP_WritePhyUshort(sc, 0x1d, 0x3167);
18123 MP_WritePhyUshort(sc, 0x1d, 0x7c04);
18124 MP_WritePhyUshort(sc, 0x1d, 0x4404);
18125 MP_WritePhyUshort(sc, 0x1d, 0x3167);
18126 MP_WritePhyUshort(sc, 0x1d, 0xd484);
18127 MP_WritePhyUshort(sc, 0x1d, 0x00f3);
18128 MP_WritePhyUshort(sc, 0x1d, 0xd484);
18129 MP_WritePhyUshort(sc, 0x1d, 0x00f1);
18130 MP_WritePhyUshort(sc, 0x1d, 0x30f4);
18131 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
18132 MP_WritePhyUshort(sc, 0x1d, 0x4ee0);
18133 MP_WritePhyUshort(sc, 0x1d, 0x7c40);
18134 MP_WritePhyUshort(sc, 0x1d, 0x5400);
18135 MP_WritePhyUshort(sc, 0x1d, 0x4488);
18136 MP_WritePhyUshort(sc, 0x1d, 0x41cf);
18137 MP_WritePhyUshort(sc, 0x1d, 0x30f4);
18138 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
18139 MP_WritePhyUshort(sc, 0x1d, 0x4ec0);
18140 MP_WritePhyUshort(sc, 0x1d, 0x48f3);
18141 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
18142 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
18143 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
18144 MP_WritePhyUshort(sc, 0x1d, 0x4c09);
18145 MP_WritePhyUshort(sc, 0x1d, 0x4508);
18146 MP_WritePhyUshort(sc, 0x1d, 0x41c7);
18147 MP_WritePhyUshort(sc, 0x1d, 0x8fb0);
18148 MP_WritePhyUshort(sc, 0x1d, 0xd218);
18149 MP_WritePhyUshort(sc, 0x1d, 0x00ae);
18150 MP_WritePhyUshort(sc, 0x1d, 0xd2a4);
18151 MP_WritePhyUshort(sc, 0x1d, 0x009e);
18152 MP_WritePhyUshort(sc, 0x1d, 0x3188);
18153 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
18154 MP_WritePhyUshort(sc, 0x1d, 0x4e80);
18155 MP_WritePhyUshort(sc, 0x1d, 0x4832);
18156 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
18157 MP_WritePhyUshort(sc, 0x1d, 0x4c01);
18158 MP_WritePhyUshort(sc, 0x1d, 0x7c1f);
18159 MP_WritePhyUshort(sc, 0x1d, 0x4c11);
18160 MP_WritePhyUshort(sc, 0x1d, 0x4428);
18161 MP_WritePhyUshort(sc, 0x1d, 0x7c40);
18162 MP_WritePhyUshort(sc, 0x1d, 0x5440);
18163 MP_WritePhyUshort(sc, 0x1d, 0x7c01);
18164 MP_WritePhyUshort(sc, 0x1d, 0x5801);
18165 MP_WritePhyUshort(sc, 0x1d, 0x7c04);
18166 MP_WritePhyUshort(sc, 0x1d, 0x5c04);
18167 MP_WritePhyUshort(sc, 0x1d, 0x41e8);
18168 MP_WritePhyUshort(sc, 0x1d, 0xa4b3);
18169 MP_WritePhyUshort(sc, 0x1d, 0x319d);
18170 MP_WritePhyUshort(sc, 0x1d, 0x7fe0);
18171 MP_WritePhyUshort(sc, 0x1d, 0x4f20);
18172 MP_WritePhyUshort(sc, 0x1d, 0x6800);
18173 MP_WritePhyUshort(sc, 0x1d, 0x673e);
18174 MP_WritePhyUshort(sc, 0x1d, 0x0000);
18175 MP_WritePhyUshort(sc, 0x1d, 0x0000);
18176 MP_WritePhyUshort(sc, 0x1d, 0x570f);
18177 MP_WritePhyUshort(sc, 0x1d, 0x5fff);
18178 MP_WritePhyUshort(sc, 0x1d, 0xaa04);
18179 MP_WritePhyUshort(sc, 0x1d, 0x585b);
18180 MP_WritePhyUshort(sc, 0x1d, 0x6100);
18181 MP_WritePhyUshort(sc, 0x1d, 0x31ad);
18182 MP_WritePhyUshort(sc, 0x1d, 0x5867);
18183 MP_WritePhyUshort(sc, 0x1d, 0x6080);
18184 MP_WritePhyUshort(sc, 0x1d, 0xbcf2);
18185 MP_WritePhyUshort(sc, 0x1d, 0x3001);
18186 MP_WritePhyUshort(sc, 0x1f, 0x0004);
18187 MP_WritePhyUshort(sc, 0x1c, 0x0200);
18188 MP_WritePhyUshort(sc, 0x19, 0x7030);
18189 MP_WritePhyUshort(sc, 0x1f, 0x0000);
18190 }
18191
18192 MP_WritePhyUshort(sc, 0x1F, 0x0001);
18193 MP_WritePhyUshort(sc, 0x11, 0x83BA);
18194 MP_WritePhyUshort(sc, 0x1F, 0x0000);
18195
18196 MP_WritePhyUshort(sc, 0x1F, 0x0005);
18197 ClearEthPhyBit(sc, 0x1A, BIT_2);
18198 MP_WritePhyUshort(sc, 0x1F, 0x0000);
18199
18200 if (phy_power_saving == 1) {
18201 MP_WritePhyUshort(sc, 0x1F, 0x0000);
18202 MP_WritePhyUshort(sc, 0x18, 0x8310);
18203 MP_WritePhyUshort(sc, 0x1F, 0x0000);
18204 } else {
18205 MP_WritePhyUshort(sc, 0x1F, 0x0000);
18206 MP_WritePhyUshort(sc, 0x18, 0x0310);
18207 MP_WritePhyUshort(sc, 0x1F, 0x0000);
18208 DELAY(20000);
18209 }
18210
18211 MP_WritePhyUshort(sc, 0x1F, 0x0000);
18212 MP_WritePhyUshort(sc, 0x0D, 0x0007);
18213 MP_WritePhyUshort(sc, 0x0E, 0x003C);
18214 MP_WritePhyUshort(sc, 0x0D, 0x4007);
18215 MP_WritePhyUshort(sc, 0x0E, 0x0000);
18216 MP_WritePhyUshort(sc, 0x0D, 0x0000);
18217 MP_WritePhyUshort(sc, 0x1F, 0x0000);
18218 MP_WritePhyUshort(sc, 0x0D, 0x0003);
18219 MP_WritePhyUshort(sc, 0x0E, 0x0015);
18220 MP_WritePhyUshort(sc, 0x0D, 0x4003);
18221 MP_WritePhyUshort(sc, 0x0E, 0x0000);
18222 MP_WritePhyUshort(sc, 0x0D, 0x0000);
18223 } else if (sc->re_type == MACFG_56) {
18224 MP_WritePhyUshort(sc, 0x1f, 0x0B82);
18225 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
18226 PhyRegValue |= BIT_4;
18227 MP_WritePhyUshort(sc, 0x10, PhyRegValue);
18228
18229 MP_WritePhyUshort(sc, 0x1f, 0x0B80);
18230 WaitCnt = 0;
18231 do {
18232 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
18233 PhyRegValue &= 0x0040;
18234 DELAY(50);
18235 DELAY(50);
18236 WaitCnt++;
18237 } while(PhyRegValue != 0x0040 && WaitCnt <1000);
18238
18239 MP_WritePhyUshort(sc, 0x1f, 0x0A43);
18240 MP_WritePhyUshort(sc, 0x13, 0x8146);
18241 MP_WritePhyUshort(sc, 0x14, 0x2300);
18242 MP_WritePhyUshort(sc, 0x13, 0xB820);
18243 MP_WritePhyUshort(sc, 0x14, 0x0210);
18244
18245 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
18246 MP_WritePhyUshort(sc, 0x13, 0xB820);
18247 MP_WritePhyUshort(sc, 0x14, 0x0290);
18248 MP_WritePhyUshort(sc, 0x13, 0xA012);
18249 MP_WritePhyUshort(sc, 0x14, 0x0000);
18250 MP_WritePhyUshort(sc, 0x13, 0xA014);
18251 MP_WritePhyUshort(sc, 0x14, 0x2c04);
18252 MP_WritePhyUshort(sc, 0x14, 0x2c0c);
18253 MP_WritePhyUshort(sc, 0x14, 0x2c6c);
18254 MP_WritePhyUshort(sc, 0x14, 0x2d0d);
18255 MP_WritePhyUshort(sc, 0x14, 0x31ce);
18256 MP_WritePhyUshort(sc, 0x14, 0x506d);
18257 MP_WritePhyUshort(sc, 0x14, 0xd708);
18258 MP_WritePhyUshort(sc, 0x14, 0x3108);
18259 MP_WritePhyUshort(sc, 0x14, 0x106d);
18260 MP_WritePhyUshort(sc, 0x14, 0x1560);
18261 MP_WritePhyUshort(sc, 0x14, 0x15a9);
18262 MP_WritePhyUshort(sc, 0x14, 0x206e);
18263 MP_WritePhyUshort(sc, 0x14, 0x175b);
18264 MP_WritePhyUshort(sc, 0x14, 0x6062);
18265 MP_WritePhyUshort(sc, 0x14, 0xd700);
18266 MP_WritePhyUshort(sc, 0x14, 0x5fae);
18267 MP_WritePhyUshort(sc, 0x14, 0xd708);
18268 MP_WritePhyUshort(sc, 0x14, 0x3107);
18269 MP_WritePhyUshort(sc, 0x14, 0x4c1e);
18270 MP_WritePhyUshort(sc, 0x14, 0x4169);
18271 MP_WritePhyUshort(sc, 0x14, 0x316a);
18272 MP_WritePhyUshort(sc, 0x14, 0x0c19);
18273 MP_WritePhyUshort(sc, 0x14, 0x31aa);
18274 MP_WritePhyUshort(sc, 0x14, 0x0c19);
18275 MP_WritePhyUshort(sc, 0x14, 0x2c1b);
18276 MP_WritePhyUshort(sc, 0x14, 0x5e62);
18277 MP_WritePhyUshort(sc, 0x14, 0x26b5);
18278 MP_WritePhyUshort(sc, 0x14, 0x31ab);
18279 MP_WritePhyUshort(sc, 0x14, 0x5c1e);
18280 MP_WritePhyUshort(sc, 0x14, 0x2c0c);
18281 MP_WritePhyUshort(sc, 0x14, 0xc040);
18282 MP_WritePhyUshort(sc, 0x14, 0x8808);
18283 MP_WritePhyUshort(sc, 0x14, 0xc520);
18284 MP_WritePhyUshort(sc, 0x14, 0xc421);
18285 MP_WritePhyUshort(sc, 0x14, 0xd05a);
18286 MP_WritePhyUshort(sc, 0x14, 0xd19a);
18287 MP_WritePhyUshort(sc, 0x14, 0xd709);
18288 MP_WritePhyUshort(sc, 0x14, 0x608f);
18289 MP_WritePhyUshort(sc, 0x14, 0xd06b);
18290 MP_WritePhyUshort(sc, 0x14, 0xd18a);
18291 MP_WritePhyUshort(sc, 0x14, 0x2c2c);
18292 MP_WritePhyUshort(sc, 0x14, 0xd0be);
18293 MP_WritePhyUshort(sc, 0x14, 0xd188);
18294 MP_WritePhyUshort(sc, 0x14, 0x2c2c);
18295 MP_WritePhyUshort(sc, 0x14, 0xd708);
18296 MP_WritePhyUshort(sc, 0x14, 0x4072);
18297 MP_WritePhyUshort(sc, 0x14, 0xc104);
18298 MP_WritePhyUshort(sc, 0x14, 0x2c3e);
18299 MP_WritePhyUshort(sc, 0x14, 0x4076);
18300 MP_WritePhyUshort(sc, 0x14, 0xc110);
18301 MP_WritePhyUshort(sc, 0x14, 0x2c3e);
18302 MP_WritePhyUshort(sc, 0x14, 0x4071);
18303 MP_WritePhyUshort(sc, 0x14, 0xc102);
18304 MP_WritePhyUshort(sc, 0x14, 0x2c3e);
18305 MP_WritePhyUshort(sc, 0x14, 0x4070);
18306 MP_WritePhyUshort(sc, 0x14, 0xc101);
18307 MP_WritePhyUshort(sc, 0x14, 0x2c3e);
18308 MP_WritePhyUshort(sc, 0x14, 0x175b);
18309 MP_WritePhyUshort(sc, 0x14, 0xd709);
18310 MP_WritePhyUshort(sc, 0x14, 0x3390);
18311 MP_WritePhyUshort(sc, 0x14, 0x5c39);
18312 MP_WritePhyUshort(sc, 0x14, 0x2c4e);
18313 MP_WritePhyUshort(sc, 0x14, 0x175b);
18314 MP_WritePhyUshort(sc, 0x14, 0xd708);
18315 MP_WritePhyUshort(sc, 0x14, 0x6193);
18316 MP_WritePhyUshort(sc, 0x14, 0xd709);
18317 MP_WritePhyUshort(sc, 0x14, 0x5f9d);
18318 MP_WritePhyUshort(sc, 0x14, 0x408b);
18319 MP_WritePhyUshort(sc, 0x14, 0xd71e);
18320 MP_WritePhyUshort(sc, 0x14, 0x6042);
18321 MP_WritePhyUshort(sc, 0x14, 0xb401);
18322 MP_WritePhyUshort(sc, 0x14, 0x175b);
18323 MP_WritePhyUshort(sc, 0x14, 0xd708);
18324 MP_WritePhyUshort(sc, 0x14, 0x6073);
18325 MP_WritePhyUshort(sc, 0x14, 0x5fbc);
18326 MP_WritePhyUshort(sc, 0x14, 0x2c4d);
18327 MP_WritePhyUshort(sc, 0x14, 0x26ed);
18328 MP_WritePhyUshort(sc, 0x14, 0xb280);
18329 MP_WritePhyUshort(sc, 0x14, 0xa841);
18330 MP_WritePhyUshort(sc, 0x14, 0x9420);
18331 MP_WritePhyUshort(sc, 0x14, 0x8710);
18332 MP_WritePhyUshort(sc, 0x14, 0xd709);
18333 MP_WritePhyUshort(sc, 0x14, 0x42ec);
18334 MP_WritePhyUshort(sc, 0x14, 0x606d);
18335 MP_WritePhyUshort(sc, 0x14, 0xd207);
18336 MP_WritePhyUshort(sc, 0x14, 0x2c57);
18337 MP_WritePhyUshort(sc, 0x14, 0xd203);
18338 MP_WritePhyUshort(sc, 0x14, 0x33ff);
18339 MP_WritePhyUshort(sc, 0x14, 0x563b);
18340 MP_WritePhyUshort(sc, 0x14, 0x3275);
18341 MP_WritePhyUshort(sc, 0x14, 0x7c5e);
18342 MP_WritePhyUshort(sc, 0x14, 0xb240);
18343 MP_WritePhyUshort(sc, 0x14, 0xb402);
18344 MP_WritePhyUshort(sc, 0x14, 0x263b);
18345 MP_WritePhyUshort(sc, 0x14, 0x6096);
18346 MP_WritePhyUshort(sc, 0x14, 0xb240);
18347 MP_WritePhyUshort(sc, 0x14, 0xb406);
18348 MP_WritePhyUshort(sc, 0x14, 0x263b);
18349 MP_WritePhyUshort(sc, 0x14, 0x31d7);
18350 MP_WritePhyUshort(sc, 0x14, 0x7c67);
18351 MP_WritePhyUshort(sc, 0x14, 0xb240);
18352 MP_WritePhyUshort(sc, 0x14, 0xb40e);
18353 MP_WritePhyUshort(sc, 0x14, 0x263b);
18354 MP_WritePhyUshort(sc, 0x14, 0xb410);
18355 MP_WritePhyUshort(sc, 0x14, 0x8802);
18356 MP_WritePhyUshort(sc, 0x14, 0xb240);
18357 MP_WritePhyUshort(sc, 0x14, 0x940e);
18358 MP_WritePhyUshort(sc, 0x14, 0x263b);
18359 MP_WritePhyUshort(sc, 0x14, 0xba04);
18360 MP_WritePhyUshort(sc, 0x14, 0x1cd6);
18361 MP_WritePhyUshort(sc, 0x14, 0xa902);
18362 MP_WritePhyUshort(sc, 0x14, 0xd711);
18363 MP_WritePhyUshort(sc, 0x14, 0x4045);
18364 MP_WritePhyUshort(sc, 0x14, 0xa980);
18365 MP_WritePhyUshort(sc, 0x14, 0x3003);
18366 MP_WritePhyUshort(sc, 0x14, 0x59b1);
18367 MP_WritePhyUshort(sc, 0x14, 0xa540);
18368 MP_WritePhyUshort(sc, 0x14, 0xa601);
18369 MP_WritePhyUshort(sc, 0x14, 0xd710);
18370 MP_WritePhyUshort(sc, 0x14, 0x4043);
18371 MP_WritePhyUshort(sc, 0x14, 0xa910);
18372 MP_WritePhyUshort(sc, 0x14, 0xd711);
18373 MP_WritePhyUshort(sc, 0x14, 0x60a0);
18374 MP_WritePhyUshort(sc, 0x14, 0xca33);
18375 MP_WritePhyUshort(sc, 0x14, 0xcb33);
18376 MP_WritePhyUshort(sc, 0x14, 0xa941);
18377 MP_WritePhyUshort(sc, 0x14, 0x2c82);
18378 MP_WritePhyUshort(sc, 0x14, 0xcaff);
18379 MP_WritePhyUshort(sc, 0x14, 0xcbff);
18380 MP_WritePhyUshort(sc, 0x14, 0xa921);
18381 MP_WritePhyUshort(sc, 0x14, 0xce02);
18382 MP_WritePhyUshort(sc, 0x14, 0xe070);
18383 MP_WritePhyUshort(sc, 0x14, 0x0f10);
18384 MP_WritePhyUshort(sc, 0x14, 0xaf01);
18385 MP_WritePhyUshort(sc, 0x14, 0x8f01);
18386 MP_WritePhyUshort(sc, 0x14, 0x1766);
18387 MP_WritePhyUshort(sc, 0x14, 0x8e02);
18388 MP_WritePhyUshort(sc, 0x14, 0x1787);
18389 MP_WritePhyUshort(sc, 0x14, 0xd710);
18390 MP_WritePhyUshort(sc, 0x14, 0x609c);
18391 MP_WritePhyUshort(sc, 0x14, 0xd71e);
18392 MP_WritePhyUshort(sc, 0x14, 0x7fa4);
18393 MP_WritePhyUshort(sc, 0x14, 0x2cd4);
18394 MP_WritePhyUshort(sc, 0x14, 0x1ce9);
18395 MP_WritePhyUshort(sc, 0x14, 0xce04);
18396 MP_WritePhyUshort(sc, 0x14, 0xe070);
18397 MP_WritePhyUshort(sc, 0x14, 0x0f20);
18398 MP_WritePhyUshort(sc, 0x14, 0xaf01);
18399 MP_WritePhyUshort(sc, 0x14, 0x8f01);
18400 MP_WritePhyUshort(sc, 0x14, 0x1766);
18401 MP_WritePhyUshort(sc, 0x14, 0x8e04);
18402 MP_WritePhyUshort(sc, 0x14, 0x6044);
18403 MP_WritePhyUshort(sc, 0x14, 0x2cd4);
18404 MP_WritePhyUshort(sc, 0x14, 0xa520);
18405 MP_WritePhyUshort(sc, 0x14, 0xd710);
18406 MP_WritePhyUshort(sc, 0x14, 0x4043);
18407 MP_WritePhyUshort(sc, 0x14, 0x2cc1);
18408 MP_WritePhyUshort(sc, 0x14, 0xe00f);
18409 MP_WritePhyUshort(sc, 0x14, 0x0501);
18410 MP_WritePhyUshort(sc, 0x14, 0x1cef);
18411 MP_WritePhyUshort(sc, 0x14, 0xb801);
18412 MP_WritePhyUshort(sc, 0x14, 0xd71e);
18413 MP_WritePhyUshort(sc, 0x14, 0x4060);
18414 MP_WritePhyUshort(sc, 0x14, 0x7fc4);
18415 MP_WritePhyUshort(sc, 0x14, 0x2cd4);
18416 MP_WritePhyUshort(sc, 0x14, 0x1cf5);
18417 MP_WritePhyUshort(sc, 0x14, 0xe00f);
18418 MP_WritePhyUshort(sc, 0x14, 0x0502);
18419 MP_WritePhyUshort(sc, 0x14, 0x1cef);
18420 MP_WritePhyUshort(sc, 0x14, 0xb802);
18421 MP_WritePhyUshort(sc, 0x14, 0xd71e);
18422 MP_WritePhyUshort(sc, 0x14, 0x4061);
18423 MP_WritePhyUshort(sc, 0x14, 0x7fc4);
18424 MP_WritePhyUshort(sc, 0x14, 0x2cd4);
18425 MP_WritePhyUshort(sc, 0x14, 0x1cf5);
18426 MP_WritePhyUshort(sc, 0x14, 0xe00f);
18427 MP_WritePhyUshort(sc, 0x14, 0x0504);
18428 MP_WritePhyUshort(sc, 0x14, 0xd710);
18429 MP_WritePhyUshort(sc, 0x14, 0x6099);
18430 MP_WritePhyUshort(sc, 0x14, 0xd71e);
18431 MP_WritePhyUshort(sc, 0x14, 0x7fa4);
18432 MP_WritePhyUshort(sc, 0x14, 0x2cd4);
18433 MP_WritePhyUshort(sc, 0x14, 0xc17f);
18434 MP_WritePhyUshort(sc, 0x14, 0xc200);
18435 MP_WritePhyUshort(sc, 0x14, 0xc43f);
18436 MP_WritePhyUshort(sc, 0x14, 0xcc03);
18437 MP_WritePhyUshort(sc, 0x14, 0xa701);
18438 MP_WritePhyUshort(sc, 0x14, 0xa510);
18439 MP_WritePhyUshort(sc, 0x14, 0xd710);
18440 MP_WritePhyUshort(sc, 0x14, 0x4018);
18441 MP_WritePhyUshort(sc, 0x14, 0x9910);
18442 MP_WritePhyUshort(sc, 0x14, 0x8510);
18443 MP_WritePhyUshort(sc, 0x14, 0x2860);
18444 MP_WritePhyUshort(sc, 0x14, 0xe00f);
18445 MP_WritePhyUshort(sc, 0x14, 0x0504);
18446 MP_WritePhyUshort(sc, 0x14, 0xd710);
18447 MP_WritePhyUshort(sc, 0x14, 0x6099);
18448 MP_WritePhyUshort(sc, 0x14, 0xd71e);
18449 MP_WritePhyUshort(sc, 0x14, 0x7fa4);
18450 MP_WritePhyUshort(sc, 0x14, 0x2cd4);
18451 MP_WritePhyUshort(sc, 0x14, 0xa608);
18452 MP_WritePhyUshort(sc, 0x14, 0xc17d);
18453 MP_WritePhyUshort(sc, 0x14, 0xc200);
18454 MP_WritePhyUshort(sc, 0x14, 0xc43f);
18455 MP_WritePhyUshort(sc, 0x14, 0xcc03);
18456 MP_WritePhyUshort(sc, 0x14, 0xa701);
18457 MP_WritePhyUshort(sc, 0x14, 0xa510);
18458 MP_WritePhyUshort(sc, 0x14, 0xd710);
18459 MP_WritePhyUshort(sc, 0x14, 0x4018);
18460 MP_WritePhyUshort(sc, 0x14, 0x9910);
18461 MP_WritePhyUshort(sc, 0x14, 0x8510);
18462 MP_WritePhyUshort(sc, 0x14, 0x2926);
18463 MP_WritePhyUshort(sc, 0x14, 0x1792);
18464 MP_WritePhyUshort(sc, 0x14, 0x27db);
18465 MP_WritePhyUshort(sc, 0x14, 0xc000);
18466 MP_WritePhyUshort(sc, 0x14, 0xc100);
18467 MP_WritePhyUshort(sc, 0x14, 0xc200);
18468 MP_WritePhyUshort(sc, 0x14, 0xc300);
18469 MP_WritePhyUshort(sc, 0x14, 0xc400);
18470 MP_WritePhyUshort(sc, 0x14, 0xc500);
18471 MP_WritePhyUshort(sc, 0x14, 0xc600);
18472 MP_WritePhyUshort(sc, 0x14, 0xc7c1);
18473 MP_WritePhyUshort(sc, 0x14, 0xc800);
18474 MP_WritePhyUshort(sc, 0x14, 0xcc00);
18475 MP_WritePhyUshort(sc, 0x14, 0x0800);
18476 MP_WritePhyUshort(sc, 0x14, 0xca0f);
18477 MP_WritePhyUshort(sc, 0x14, 0xcbff);
18478 MP_WritePhyUshort(sc, 0x14, 0xa901);
18479 MP_WritePhyUshort(sc, 0x14, 0x8902);
18480 MP_WritePhyUshort(sc, 0x14, 0xc900);
18481 MP_WritePhyUshort(sc, 0x14, 0xca00);
18482 MP_WritePhyUshort(sc, 0x14, 0xcb00);
18483 MP_WritePhyUshort(sc, 0x14, 0x0800);
18484 MP_WritePhyUshort(sc, 0x14, 0xb804);
18485 MP_WritePhyUshort(sc, 0x14, 0x0800);
18486 MP_WritePhyUshort(sc, 0x14, 0xd71e);
18487 MP_WritePhyUshort(sc, 0x14, 0x6044);
18488 MP_WritePhyUshort(sc, 0x14, 0x9804);
18489 MP_WritePhyUshort(sc, 0x14, 0x0800);
18490 MP_WritePhyUshort(sc, 0x14, 0xd710);
18491 MP_WritePhyUshort(sc, 0x14, 0x6099);
18492 MP_WritePhyUshort(sc, 0x14, 0xd71e);
18493 MP_WritePhyUshort(sc, 0x14, 0x7fa4);
18494 MP_WritePhyUshort(sc, 0x14, 0x2cd4);
18495 MP_WritePhyUshort(sc, 0x14, 0x0800);
18496 MP_WritePhyUshort(sc, 0x14, 0xa510);
18497 MP_WritePhyUshort(sc, 0x14, 0xd710);
18498 MP_WritePhyUshort(sc, 0x14, 0x6098);
18499 MP_WritePhyUshort(sc, 0x14, 0xd71e);
18500 MP_WritePhyUshort(sc, 0x14, 0x7fa4);
18501 MP_WritePhyUshort(sc, 0x14, 0x2cd4);
18502 MP_WritePhyUshort(sc, 0x14, 0x8510);
18503 MP_WritePhyUshort(sc, 0x14, 0x0800);
18504 MP_WritePhyUshort(sc, 0x14, 0xd711);
18505 MP_WritePhyUshort(sc, 0x14, 0x3003);
18506 MP_WritePhyUshort(sc, 0x14, 0x1d01);
18507 MP_WritePhyUshort(sc, 0x14, 0x2d0b);
18508 MP_WritePhyUshort(sc, 0x14, 0xd710);
18509 MP_WritePhyUshort(sc, 0x14, 0x60be);
18510 MP_WritePhyUshort(sc, 0x14, 0xe060);
18511 MP_WritePhyUshort(sc, 0x14, 0x0920);
18512 MP_WritePhyUshort(sc, 0x14, 0x1cd6);
18513 MP_WritePhyUshort(sc, 0x14, 0x2c89);
18514 MP_WritePhyUshort(sc, 0x14, 0xd71e);
18515 MP_WritePhyUshort(sc, 0x14, 0x3063);
18516 MP_WritePhyUshort(sc, 0x14, 0x1948);
18517 MP_WritePhyUshort(sc, 0x14, 0x288a);
18518 MP_WritePhyUshort(sc, 0x14, 0x1cd6);
18519 MP_WritePhyUshort(sc, 0x14, 0x29bd);
18520 MP_WritePhyUshort(sc, 0x14, 0xa802);
18521 MP_WritePhyUshort(sc, 0x14, 0xa303);
18522 MP_WritePhyUshort(sc, 0x14, 0x843f);
18523 MP_WritePhyUshort(sc, 0x14, 0x81ff);
18524 MP_WritePhyUshort(sc, 0x14, 0x8208);
18525 MP_WritePhyUshort(sc, 0x14, 0xa201);
18526 MP_WritePhyUshort(sc, 0x14, 0xc001);
18527 MP_WritePhyUshort(sc, 0x14, 0xd710);
18528 MP_WritePhyUshort(sc, 0x14, 0x30a0);
18529 MP_WritePhyUshort(sc, 0x14, 0x0d1c);
18530 MP_WritePhyUshort(sc, 0x14, 0x30a0);
18531 MP_WritePhyUshort(sc, 0x14, 0x3d13);
18532 MP_WritePhyUshort(sc, 0x14, 0xd71e);
18533 MP_WritePhyUshort(sc, 0x14, 0x7f4c);
18534 MP_WritePhyUshort(sc, 0x14, 0x2ab6);
18535 MP_WritePhyUshort(sc, 0x14, 0xe003);
18536 MP_WritePhyUshort(sc, 0x14, 0x0202);
18537 MP_WritePhyUshort(sc, 0x14, 0xd710);
18538 MP_WritePhyUshort(sc, 0x14, 0x6090);
18539 MP_WritePhyUshort(sc, 0x14, 0xd71e);
18540 MP_WritePhyUshort(sc, 0x14, 0x7fac);
18541 MP_WritePhyUshort(sc, 0x14, 0x2ab6);
18542 MP_WritePhyUshort(sc, 0x14, 0xa20c);
18543 MP_WritePhyUshort(sc, 0x14, 0xd710);
18544 MP_WritePhyUshort(sc, 0x14, 0x6091);
18545 MP_WritePhyUshort(sc, 0x14, 0xd71e);
18546 MP_WritePhyUshort(sc, 0x14, 0x7fac);
18547 MP_WritePhyUshort(sc, 0x14, 0x2ab6);
18548 MP_WritePhyUshort(sc, 0x14, 0x820e);
18549 MP_WritePhyUshort(sc, 0x14, 0xa3e0);
18550 MP_WritePhyUshort(sc, 0x14, 0xa520);
18551 MP_WritePhyUshort(sc, 0x14, 0xd710);
18552 MP_WritePhyUshort(sc, 0x14, 0x609d);
18553 MP_WritePhyUshort(sc, 0x14, 0xd71e);
18554 MP_WritePhyUshort(sc, 0x14, 0x7fac);
18555 MP_WritePhyUshort(sc, 0x14, 0x2ab6);
18556 MP_WritePhyUshort(sc, 0x14, 0x8520);
18557 MP_WritePhyUshort(sc, 0x14, 0x6703);
18558 MP_WritePhyUshort(sc, 0x14, 0x2d34);
18559 MP_WritePhyUshort(sc, 0x14, 0xa13e);
18560 MP_WritePhyUshort(sc, 0x14, 0xc001);
18561 MP_WritePhyUshort(sc, 0x14, 0xd710);
18562 MP_WritePhyUshort(sc, 0x14, 0x4000);
18563 MP_WritePhyUshort(sc, 0x14, 0x6046);
18564 MP_WritePhyUshort(sc, 0x14, 0x2d0d);
18565 MP_WritePhyUshort(sc, 0x14, 0xa43f);
18566 MP_WritePhyUshort(sc, 0x14, 0xa101);
18567 MP_WritePhyUshort(sc, 0x14, 0xc020);
18568 MP_WritePhyUshort(sc, 0x14, 0xd710);
18569 MP_WritePhyUshort(sc, 0x14, 0x3121);
18570 MP_WritePhyUshort(sc, 0x14, 0x0d45);
18571 MP_WritePhyUshort(sc, 0x14, 0x30c0);
18572 MP_WritePhyUshort(sc, 0x14, 0x3d0d);
18573 MP_WritePhyUshort(sc, 0x14, 0xd71e);
18574 MP_WritePhyUshort(sc, 0x14, 0x7f4c);
18575 MP_WritePhyUshort(sc, 0x14, 0x2ab6);
18576 MP_WritePhyUshort(sc, 0x14, 0xa540);
18577 MP_WritePhyUshort(sc, 0x14, 0xc001);
18578 MP_WritePhyUshort(sc, 0x14, 0xd710);
18579 MP_WritePhyUshort(sc, 0x14, 0x4001);
18580 MP_WritePhyUshort(sc, 0x14, 0xe00f);
18581 MP_WritePhyUshort(sc, 0x14, 0x0501);
18582 MP_WritePhyUshort(sc, 0x14, 0x1dac);
18583 MP_WritePhyUshort(sc, 0x14, 0xc1c4);
18584 MP_WritePhyUshort(sc, 0x14, 0xa268);
18585 MP_WritePhyUshort(sc, 0x14, 0xa303);
18586 MP_WritePhyUshort(sc, 0x14, 0x8420);
18587 MP_WritePhyUshort(sc, 0x14, 0xe00f);
18588 MP_WritePhyUshort(sc, 0x14, 0x0502);
18589 MP_WritePhyUshort(sc, 0x14, 0x1dac);
18590 MP_WritePhyUshort(sc, 0x14, 0xc002);
18591 MP_WritePhyUshort(sc, 0x14, 0xd710);
18592 MP_WritePhyUshort(sc, 0x14, 0x4000);
18593 MP_WritePhyUshort(sc, 0x14, 0x8208);
18594 MP_WritePhyUshort(sc, 0x14, 0x8410);
18595 MP_WritePhyUshort(sc, 0x14, 0xa121);
18596 MP_WritePhyUshort(sc, 0x14, 0xc002);
18597 MP_WritePhyUshort(sc, 0x14, 0xd710);
18598 MP_WritePhyUshort(sc, 0x14, 0x4000);
18599 MP_WritePhyUshort(sc, 0x14, 0x8120);
18600 MP_WritePhyUshort(sc, 0x14, 0x8180);
18601 MP_WritePhyUshort(sc, 0x14, 0x1d97);
18602 MP_WritePhyUshort(sc, 0x14, 0xa180);
18603 MP_WritePhyUshort(sc, 0x14, 0xa13a);
18604 MP_WritePhyUshort(sc, 0x14, 0x8240);
18605 MP_WritePhyUshort(sc, 0x14, 0xa430);
18606 MP_WritePhyUshort(sc, 0x14, 0xc010);
18607 MP_WritePhyUshort(sc, 0x14, 0xd710);
18608 MP_WritePhyUshort(sc, 0x14, 0x30e1);
18609 MP_WritePhyUshort(sc, 0x14, 0x0abc);
18610 MP_WritePhyUshort(sc, 0x14, 0xd71e);
18611 MP_WritePhyUshort(sc, 0x14, 0x7f8c);
18612 MP_WritePhyUshort(sc, 0x14, 0x2ab6);
18613 MP_WritePhyUshort(sc, 0x14, 0xa480);
18614 MP_WritePhyUshort(sc, 0x14, 0xa230);
18615 MP_WritePhyUshort(sc, 0x14, 0xa303);
18616 MP_WritePhyUshort(sc, 0x14, 0xc001);
18617 MP_WritePhyUshort(sc, 0x14, 0xd70c);
18618 MP_WritePhyUshort(sc, 0x14, 0x4124);
18619 MP_WritePhyUshort(sc, 0x14, 0xd710);
18620 MP_WritePhyUshort(sc, 0x14, 0x6120);
18621 MP_WritePhyUshort(sc, 0x14, 0xd711);
18622 MP_WritePhyUshort(sc, 0x14, 0x3128);
18623 MP_WritePhyUshort(sc, 0x14, 0x3d76);
18624 MP_WritePhyUshort(sc, 0x14, 0x2d70);
18625 MP_WritePhyUshort(sc, 0x14, 0xa801);
18626 MP_WritePhyUshort(sc, 0x14, 0x2d6c);
18627 MP_WritePhyUshort(sc, 0x14, 0xd710);
18628 MP_WritePhyUshort(sc, 0x14, 0x4000);
18629 MP_WritePhyUshort(sc, 0x14, 0xe018);
18630 MP_WritePhyUshort(sc, 0x14, 0x0208);
18631 MP_WritePhyUshort(sc, 0x14, 0xa1f8);
18632 MP_WritePhyUshort(sc, 0x14, 0x8480);
18633 MP_WritePhyUshort(sc, 0x14, 0xc004);
18634 MP_WritePhyUshort(sc, 0x14, 0xd710);
18635 MP_WritePhyUshort(sc, 0x14, 0x4000);
18636 MP_WritePhyUshort(sc, 0x14, 0x6046);
18637 MP_WritePhyUshort(sc, 0x14, 0x2d0d);
18638 MP_WritePhyUshort(sc, 0x14, 0xa43f);
18639 MP_WritePhyUshort(sc, 0x14, 0xa105);
18640 MP_WritePhyUshort(sc, 0x14, 0x8228);
18641 MP_WritePhyUshort(sc, 0x14, 0xc004);
18642 MP_WritePhyUshort(sc, 0x14, 0xd710);
18643 MP_WritePhyUshort(sc, 0x14, 0x4000);
18644 MP_WritePhyUshort(sc, 0x14, 0x81bc);
18645 MP_WritePhyUshort(sc, 0x14, 0xa220);
18646 MP_WritePhyUshort(sc, 0x14, 0x1d97);
18647 MP_WritePhyUshort(sc, 0x14, 0x8220);
18648 MP_WritePhyUshort(sc, 0x14, 0xa1bc);
18649 MP_WritePhyUshort(sc, 0x14, 0xc040);
18650 MP_WritePhyUshort(sc, 0x14, 0xd710);
18651 MP_WritePhyUshort(sc, 0x14, 0x30e1);
18652 MP_WritePhyUshort(sc, 0x14, 0x0abc);
18653 MP_WritePhyUshort(sc, 0x14, 0x30e1);
18654 MP_WritePhyUshort(sc, 0x14, 0x3d0d);
18655 MP_WritePhyUshort(sc, 0x14, 0xd71e);
18656 MP_WritePhyUshort(sc, 0x14, 0x7f4c);
18657 MP_WritePhyUshort(sc, 0x14, 0x2ab6);
18658 MP_WritePhyUshort(sc, 0x14, 0xa802);
18659 MP_WritePhyUshort(sc, 0x14, 0xd70c);
18660 MP_WritePhyUshort(sc, 0x14, 0x4244);
18661 MP_WritePhyUshort(sc, 0x14, 0xa301);
18662 MP_WritePhyUshort(sc, 0x14, 0xc004);
18663 MP_WritePhyUshort(sc, 0x14, 0xd711);
18664 MP_WritePhyUshort(sc, 0x14, 0x3128);
18665 MP_WritePhyUshort(sc, 0x14, 0x3da5);
18666 MP_WritePhyUshort(sc, 0x14, 0xd710);
18667 MP_WritePhyUshort(sc, 0x14, 0x5f80);
18668 MP_WritePhyUshort(sc, 0x14, 0xd711);
18669 MP_WritePhyUshort(sc, 0x14, 0x3109);
18670 MP_WritePhyUshort(sc, 0x14, 0x3da7);
18671 MP_WritePhyUshort(sc, 0x14, 0x2dab);
18672 MP_WritePhyUshort(sc, 0x14, 0xa801);
18673 MP_WritePhyUshort(sc, 0x14, 0x2d9a);
18674 MP_WritePhyUshort(sc, 0x14, 0xa802);
18675 MP_WritePhyUshort(sc, 0x14, 0xc004);
18676 MP_WritePhyUshort(sc, 0x14, 0xd710);
18677 MP_WritePhyUshort(sc, 0x14, 0x4000);
18678 MP_WritePhyUshort(sc, 0x14, 0x0800);
18679 MP_WritePhyUshort(sc, 0x14, 0xa510);
18680 MP_WritePhyUshort(sc, 0x14, 0xd710);
18681 MP_WritePhyUshort(sc, 0x14, 0x609a);
18682 MP_WritePhyUshort(sc, 0x14, 0xd71e);
18683 MP_WritePhyUshort(sc, 0x14, 0x7fac);
18684 MP_WritePhyUshort(sc, 0x14, 0x2ab6);
18685 MP_WritePhyUshort(sc, 0x14, 0x8510);
18686 MP_WritePhyUshort(sc, 0x14, 0x0800);
18687 MP_WritePhyUshort(sc, 0x13, 0xA01A);
18688 MP_WritePhyUshort(sc, 0x14, 0x0000);
18689 MP_WritePhyUshort(sc, 0x13, 0xA006);
18690 MP_WritePhyUshort(sc, 0x14, 0x0ad6);
18691 MP_WritePhyUshort(sc, 0x13, 0xA004);
18692 MP_WritePhyUshort(sc, 0x14, 0x07f5);
18693 MP_WritePhyUshort(sc, 0x13, 0xA002);
18694 MP_WritePhyUshort(sc, 0x14, 0x06a9);
18695 MP_WritePhyUshort(sc, 0x13, 0xA000);
18696 MP_WritePhyUshort(sc, 0x14, 0xf069);
18697 MP_WritePhyUshort(sc, 0x13, 0xB820);
18698 MP_WritePhyUshort(sc, 0x14, 0x0210);
18699
18700 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
18701 MP_WritePhyUshort(sc, 0x13, 0x83a0);
18702 MP_WritePhyUshort(sc, 0x14, 0xaf83);
18703 MP_WritePhyUshort(sc, 0x14, 0xacaf);
18704 MP_WritePhyUshort(sc, 0x14, 0x83b8);
18705 MP_WritePhyUshort(sc, 0x14, 0xaf83);
18706 MP_WritePhyUshort(sc, 0x14, 0xcdaf);
18707 MP_WritePhyUshort(sc, 0x14, 0x83d3);
18708 MP_WritePhyUshort(sc, 0x14, 0x0204);
18709 MP_WritePhyUshort(sc, 0x14, 0x9a02);
18710 MP_WritePhyUshort(sc, 0x14, 0x09a9);
18711 MP_WritePhyUshort(sc, 0x14, 0x0284);
18712 MP_WritePhyUshort(sc, 0x14, 0x61af);
18713 MP_WritePhyUshort(sc, 0x14, 0x02fc);
18714 MP_WritePhyUshort(sc, 0x14, 0xad20);
18715 MP_WritePhyUshort(sc, 0x14, 0x0302);
18716 MP_WritePhyUshort(sc, 0x14, 0x867c);
18717 MP_WritePhyUshort(sc, 0x14, 0xad21);
18718 MP_WritePhyUshort(sc, 0x14, 0x0302);
18719 MP_WritePhyUshort(sc, 0x14, 0x85c9);
18720 MP_WritePhyUshort(sc, 0x14, 0xad22);
18721 MP_WritePhyUshort(sc, 0x14, 0x0302);
18722 MP_WritePhyUshort(sc, 0x14, 0x1bc0);
18723 MP_WritePhyUshort(sc, 0x14, 0xaf17);
18724 MP_WritePhyUshort(sc, 0x14, 0xe302);
18725 MP_WritePhyUshort(sc, 0x14, 0x8703);
18726 MP_WritePhyUshort(sc, 0x14, 0xaf18);
18727 MP_WritePhyUshort(sc, 0x14, 0x6201);
18728 MP_WritePhyUshort(sc, 0x14, 0x06e0);
18729 MP_WritePhyUshort(sc, 0x14, 0x8148);
18730 MP_WritePhyUshort(sc, 0x14, 0xaf3c);
18731 MP_WritePhyUshort(sc, 0x14, 0x69f8);
18732 MP_WritePhyUshort(sc, 0x14, 0xf9fa);
18733 MP_WritePhyUshort(sc, 0x14, 0xef69);
18734 MP_WritePhyUshort(sc, 0x14, 0xee80);
18735 MP_WritePhyUshort(sc, 0x14, 0x10f7);
18736 MP_WritePhyUshort(sc, 0x14, 0xee80);
18737 MP_WritePhyUshort(sc, 0x14, 0x131f);
18738 MP_WritePhyUshort(sc, 0x14, 0xd104);
18739 MP_WritePhyUshort(sc, 0x14, 0xbf87);
18740 MP_WritePhyUshort(sc, 0x14, 0xf302);
18741 MP_WritePhyUshort(sc, 0x14, 0x4259);
18742 MP_WritePhyUshort(sc, 0x14, 0x0287);
18743 MP_WritePhyUshort(sc, 0x14, 0x88bf);
18744 MP_WritePhyUshort(sc, 0x14, 0x87cf);
18745 MP_WritePhyUshort(sc, 0x14, 0xd7b8);
18746 MP_WritePhyUshort(sc, 0x14, 0x22d0);
18747 MP_WritePhyUshort(sc, 0x14, 0x0c02);
18748 MP_WritePhyUshort(sc, 0x14, 0x4252);
18749 MP_WritePhyUshort(sc, 0x14, 0xee80);
18750 MP_WritePhyUshort(sc, 0x14, 0xcda0);
18751 MP_WritePhyUshort(sc, 0x14, 0xee80);
18752 MP_WritePhyUshort(sc, 0x14, 0xce8b);
18753 MP_WritePhyUshort(sc, 0x14, 0xee80);
18754 MP_WritePhyUshort(sc, 0x14, 0xd1f5);
18755 MP_WritePhyUshort(sc, 0x14, 0xee80);
18756 MP_WritePhyUshort(sc, 0x14, 0xd2a9);
18757 MP_WritePhyUshort(sc, 0x14, 0xee80);
18758 MP_WritePhyUshort(sc, 0x14, 0xd30a);
18759 MP_WritePhyUshort(sc, 0x14, 0xee80);
18760 MP_WritePhyUshort(sc, 0x14, 0xf010);
18761 MP_WritePhyUshort(sc, 0x14, 0xee80);
18762 MP_WritePhyUshort(sc, 0x14, 0xf38f);
18763 MP_WritePhyUshort(sc, 0x14, 0xee81);
18764 MP_WritePhyUshort(sc, 0x14, 0x011e);
18765 MP_WritePhyUshort(sc, 0x14, 0xee81);
18766 MP_WritePhyUshort(sc, 0x14, 0x0b4a);
18767 MP_WritePhyUshort(sc, 0x14, 0xee81);
18768 MP_WritePhyUshort(sc, 0x14, 0x0c7c);
18769 MP_WritePhyUshort(sc, 0x14, 0xee81);
18770 MP_WritePhyUshort(sc, 0x14, 0x127f);
18771 MP_WritePhyUshort(sc, 0x14, 0xd100);
18772 MP_WritePhyUshort(sc, 0x14, 0x0210);
18773 MP_WritePhyUshort(sc, 0x14, 0xb5ee);
18774 MP_WritePhyUshort(sc, 0x14, 0x8088);
18775 MP_WritePhyUshort(sc, 0x14, 0xa4ee);
18776 MP_WritePhyUshort(sc, 0x14, 0x8089);
18777 MP_WritePhyUshort(sc, 0x14, 0x44ee);
18778 MP_WritePhyUshort(sc, 0x14, 0x809a);
18779 MP_WritePhyUshort(sc, 0x14, 0xa4ee);
18780 MP_WritePhyUshort(sc, 0x14, 0x809b);
18781 MP_WritePhyUshort(sc, 0x14, 0x44ee);
18782 MP_WritePhyUshort(sc, 0x14, 0x809c);
18783 MP_WritePhyUshort(sc, 0x14, 0xa7ee);
18784 MP_WritePhyUshort(sc, 0x14, 0x80a5);
18785 MP_WritePhyUshort(sc, 0x14, 0xa7d2);
18786 MP_WritePhyUshort(sc, 0x14, 0x0002);
18787 MP_WritePhyUshort(sc, 0x14, 0x0e66);
18788 MP_WritePhyUshort(sc, 0x14, 0x0285);
18789 MP_WritePhyUshort(sc, 0x14, 0xc0ee);
18790 MP_WritePhyUshort(sc, 0x14, 0x87fc);
18791 MP_WritePhyUshort(sc, 0x14, 0x00e0);
18792 MP_WritePhyUshort(sc, 0x14, 0x8245);
18793 MP_WritePhyUshort(sc, 0x14, 0xf622);
18794 MP_WritePhyUshort(sc, 0x14, 0xe482);
18795 MP_WritePhyUshort(sc, 0x14, 0x45ef);
18796 MP_WritePhyUshort(sc, 0x14, 0x96fe);
18797 MP_WritePhyUshort(sc, 0x14, 0xfdfc);
18798 MP_WritePhyUshort(sc, 0x14, 0x0402);
18799 MP_WritePhyUshort(sc, 0x14, 0x847a);
18800 MP_WritePhyUshort(sc, 0x14, 0x0284);
18801 MP_WritePhyUshort(sc, 0x14, 0xb302);
18802 MP_WritePhyUshort(sc, 0x14, 0x0cab);
18803 MP_WritePhyUshort(sc, 0x14, 0x020c);
18804 MP_WritePhyUshort(sc, 0x14, 0xc402);
18805 MP_WritePhyUshort(sc, 0x14, 0x0cef);
18806 MP_WritePhyUshort(sc, 0x14, 0x020d);
18807 MP_WritePhyUshort(sc, 0x14, 0x0802);
18808 MP_WritePhyUshort(sc, 0x14, 0x0d33);
18809 MP_WritePhyUshort(sc, 0x14, 0x020c);
18810 MP_WritePhyUshort(sc, 0x14, 0x3d04);
18811 MP_WritePhyUshort(sc, 0x14, 0xf8fa);
18812 MP_WritePhyUshort(sc, 0x14, 0xef69);
18813 MP_WritePhyUshort(sc, 0x14, 0xe182);
18814 MP_WritePhyUshort(sc, 0x14, 0x2fac);
18815 MP_WritePhyUshort(sc, 0x14, 0x291a);
18816 MP_WritePhyUshort(sc, 0x14, 0xe082);
18817 MP_WritePhyUshort(sc, 0x14, 0x24ac);
18818 MP_WritePhyUshort(sc, 0x14, 0x2102);
18819 MP_WritePhyUshort(sc, 0x14, 0xae22);
18820 MP_WritePhyUshort(sc, 0x14, 0x0210);
18821 MP_WritePhyUshort(sc, 0x14, 0x57f6);
18822 MP_WritePhyUshort(sc, 0x14, 0x21e4);
18823 MP_WritePhyUshort(sc, 0x14, 0x8224);
18824 MP_WritePhyUshort(sc, 0x14, 0xd101);
18825 MP_WritePhyUshort(sc, 0x14, 0xbf44);
18826 MP_WritePhyUshort(sc, 0x14, 0xd202);
18827 MP_WritePhyUshort(sc, 0x14, 0x4259);
18828 MP_WritePhyUshort(sc, 0x14, 0xae10);
18829 MP_WritePhyUshort(sc, 0x14, 0x0212);
18830 MP_WritePhyUshort(sc, 0x14, 0x4cf6);
18831 MP_WritePhyUshort(sc, 0x14, 0x29e5);
18832 MP_WritePhyUshort(sc, 0x14, 0x822f);
18833 MP_WritePhyUshort(sc, 0x14, 0xe082);
18834 MP_WritePhyUshort(sc, 0x14, 0x24f6);
18835 MP_WritePhyUshort(sc, 0x14, 0x21e4);
18836 MP_WritePhyUshort(sc, 0x14, 0x8224);
18837 MP_WritePhyUshort(sc, 0x14, 0xef96);
18838 MP_WritePhyUshort(sc, 0x14, 0xfefc);
18839 MP_WritePhyUshort(sc, 0x14, 0x04f8);
18840 MP_WritePhyUshort(sc, 0x14, 0xe182);
18841 MP_WritePhyUshort(sc, 0x14, 0x2fac);
18842 MP_WritePhyUshort(sc, 0x14, 0x2a18);
18843 MP_WritePhyUshort(sc, 0x14, 0xe082);
18844 MP_WritePhyUshort(sc, 0x14, 0x24ac);
18845 MP_WritePhyUshort(sc, 0x14, 0x2202);
18846 MP_WritePhyUshort(sc, 0x14, 0xae26);
18847 MP_WritePhyUshort(sc, 0x14, 0x0284);
18848 MP_WritePhyUshort(sc, 0x14, 0xf802);
18849 MP_WritePhyUshort(sc, 0x14, 0x8565);
18850 MP_WritePhyUshort(sc, 0x14, 0xd101);
18851 MP_WritePhyUshort(sc, 0x14, 0xbf44);
18852 MP_WritePhyUshort(sc, 0x14, 0xd502);
18853 MP_WritePhyUshort(sc, 0x14, 0x4259);
18854 MP_WritePhyUshort(sc, 0x14, 0xae0e);
18855 MP_WritePhyUshort(sc, 0x14, 0x0284);
18856 MP_WritePhyUshort(sc, 0x14, 0xea02);
18857 MP_WritePhyUshort(sc, 0x14, 0x85a9);
18858 MP_WritePhyUshort(sc, 0x14, 0xe182);
18859 MP_WritePhyUshort(sc, 0x14, 0x2ff6);
18860 MP_WritePhyUshort(sc, 0x14, 0x2ae5);
18861 MP_WritePhyUshort(sc, 0x14, 0x822f);
18862 MP_WritePhyUshort(sc, 0x14, 0xe082);
18863 MP_WritePhyUshort(sc, 0x14, 0x24f6);
18864 MP_WritePhyUshort(sc, 0x14, 0x22e4);
18865 MP_WritePhyUshort(sc, 0x14, 0x8224);
18866 MP_WritePhyUshort(sc, 0x14, 0xfc04);
18867 MP_WritePhyUshort(sc, 0x14, 0xf9e2);
18868 MP_WritePhyUshort(sc, 0x14, 0x8011);
18869 MP_WritePhyUshort(sc, 0x14, 0xad31);
18870 MP_WritePhyUshort(sc, 0x14, 0x05d2);
18871 MP_WritePhyUshort(sc, 0x14, 0x0002);
18872 MP_WritePhyUshort(sc, 0x14, 0x0e66);
18873 MP_WritePhyUshort(sc, 0x14, 0xfd04);
18874 MP_WritePhyUshort(sc, 0x14, 0xf8f9);
18875 MP_WritePhyUshort(sc, 0x14, 0xfaef);
18876 MP_WritePhyUshort(sc, 0x14, 0x69e0);
18877 MP_WritePhyUshort(sc, 0x14, 0x8011);
18878 MP_WritePhyUshort(sc, 0x14, 0xad21);
18879 MP_WritePhyUshort(sc, 0x14, 0x5cbf);
18880 MP_WritePhyUshort(sc, 0x14, 0x43be);
18881 MP_WritePhyUshort(sc, 0x14, 0x0242);
18882 MP_WritePhyUshort(sc, 0x14, 0x97ac);
18883 MP_WritePhyUshort(sc, 0x14, 0x281b);
18884 MP_WritePhyUshort(sc, 0x14, 0xbf43);
18885 MP_WritePhyUshort(sc, 0x14, 0xc102);
18886 MP_WritePhyUshort(sc, 0x14, 0x4297);
18887 MP_WritePhyUshort(sc, 0x14, 0xac28);
18888 MP_WritePhyUshort(sc, 0x14, 0x12bf);
18889 MP_WritePhyUshort(sc, 0x14, 0x43c7);
18890 MP_WritePhyUshort(sc, 0x14, 0x0242);
18891 MP_WritePhyUshort(sc, 0x14, 0x97ac);
18892 MP_WritePhyUshort(sc, 0x14, 0x2804);
18893 MP_WritePhyUshort(sc, 0x14, 0xd300);
18894 MP_WritePhyUshort(sc, 0x14, 0xae07);
18895 MP_WritePhyUshort(sc, 0x14, 0xd306);
18896 MP_WritePhyUshort(sc, 0x14, 0xaf85);
18897 MP_WritePhyUshort(sc, 0x14, 0x56d3);
18898 MP_WritePhyUshort(sc, 0x14, 0x03e0);
18899 MP_WritePhyUshort(sc, 0x14, 0x8011);
18900 MP_WritePhyUshort(sc, 0x14, 0xad26);
18901 MP_WritePhyUshort(sc, 0x14, 0x25bf);
18902 MP_WritePhyUshort(sc, 0x14, 0x4559);
18903 MP_WritePhyUshort(sc, 0x14, 0x0242);
18904 MP_WritePhyUshort(sc, 0x14, 0x97e2);
18905 MP_WritePhyUshort(sc, 0x14, 0x8073);
18906 MP_WritePhyUshort(sc, 0x14, 0x0d21);
18907 MP_WritePhyUshort(sc, 0x14, 0xf637);
18908 MP_WritePhyUshort(sc, 0x14, 0x0d11);
18909 MP_WritePhyUshort(sc, 0x14, 0xf62f);
18910 MP_WritePhyUshort(sc, 0x14, 0x1b21);
18911 MP_WritePhyUshort(sc, 0x14, 0xaa02);
18912 MP_WritePhyUshort(sc, 0x14, 0xae10);
18913 MP_WritePhyUshort(sc, 0x14, 0xe280);
18914 MP_WritePhyUshort(sc, 0x14, 0x740d);
18915 MP_WritePhyUshort(sc, 0x14, 0x21f6);
18916 MP_WritePhyUshort(sc, 0x14, 0x371b);
18917 MP_WritePhyUshort(sc, 0x14, 0x21aa);
18918 MP_WritePhyUshort(sc, 0x14, 0x0313);
18919 MP_WritePhyUshort(sc, 0x14, 0xae02);
18920 MP_WritePhyUshort(sc, 0x14, 0x2b02);
18921 MP_WritePhyUshort(sc, 0x14, 0x020e);
18922 MP_WritePhyUshort(sc, 0x14, 0x5102);
18923 MP_WritePhyUshort(sc, 0x14, 0x0e66);
18924 MP_WritePhyUshort(sc, 0x14, 0x020f);
18925 MP_WritePhyUshort(sc, 0x14, 0xa3ef);
18926 MP_WritePhyUshort(sc, 0x14, 0x96fe);
18927 MP_WritePhyUshort(sc, 0x14, 0xfdfc);
18928 MP_WritePhyUshort(sc, 0x14, 0x04f8);
18929 MP_WritePhyUshort(sc, 0x14, 0xf9fa);
18930 MP_WritePhyUshort(sc, 0x14, 0xef69);
18931 MP_WritePhyUshort(sc, 0x14, 0xe080);
18932 MP_WritePhyUshort(sc, 0x14, 0x12ad);
18933 MP_WritePhyUshort(sc, 0x14, 0x2733);
18934 MP_WritePhyUshort(sc, 0x14, 0xbf43);
18935 MP_WritePhyUshort(sc, 0x14, 0xbe02);
18936 MP_WritePhyUshort(sc, 0x14, 0x4297);
18937 MP_WritePhyUshort(sc, 0x14, 0xac28);
18938 MP_WritePhyUshort(sc, 0x14, 0x09bf);
18939 MP_WritePhyUshort(sc, 0x14, 0x43c1);
18940 MP_WritePhyUshort(sc, 0x14, 0x0242);
18941 MP_WritePhyUshort(sc, 0x14, 0x97ad);
18942 MP_WritePhyUshort(sc, 0x14, 0x2821);
18943 MP_WritePhyUshort(sc, 0x14, 0xbf45);
18944 MP_WritePhyUshort(sc, 0x14, 0x5902);
18945 MP_WritePhyUshort(sc, 0x14, 0x4297);
18946 MP_WritePhyUshort(sc, 0x14, 0xe387);
18947 MP_WritePhyUshort(sc, 0x14, 0xffd2);
18948 MP_WritePhyUshort(sc, 0x14, 0x001b);
18949 MP_WritePhyUshort(sc, 0x14, 0x45ac);
18950 MP_WritePhyUshort(sc, 0x14, 0x2711);
18951 MP_WritePhyUshort(sc, 0x14, 0xe187);
18952 MP_WritePhyUshort(sc, 0x14, 0xfebf);
18953 MP_WritePhyUshort(sc, 0x14, 0x87e4);
18954 MP_WritePhyUshort(sc, 0x14, 0x0242);
18955 MP_WritePhyUshort(sc, 0x14, 0x590d);
18956 MP_WritePhyUshort(sc, 0x14, 0x11bf);
18957 MP_WritePhyUshort(sc, 0x14, 0x87e7);
18958 MP_WritePhyUshort(sc, 0x14, 0x0242);
18959 MP_WritePhyUshort(sc, 0x14, 0x59ef);
18960 MP_WritePhyUshort(sc, 0x14, 0x96fe);
18961 MP_WritePhyUshort(sc, 0x14, 0xfdfc);
18962 MP_WritePhyUshort(sc, 0x14, 0x04f8);
18963 MP_WritePhyUshort(sc, 0x14, 0xfaef);
18964 MP_WritePhyUshort(sc, 0x14, 0x69d1);
18965 MP_WritePhyUshort(sc, 0x14, 0x00bf);
18966 MP_WritePhyUshort(sc, 0x14, 0x87e4);
18967 MP_WritePhyUshort(sc, 0x14, 0x0242);
18968 MP_WritePhyUshort(sc, 0x14, 0x59bf);
18969 MP_WritePhyUshort(sc, 0x14, 0x87e7);
18970 MP_WritePhyUshort(sc, 0x14, 0x0242);
18971 MP_WritePhyUshort(sc, 0x14, 0x59ef);
18972 MP_WritePhyUshort(sc, 0x14, 0x96fe);
18973 MP_WritePhyUshort(sc, 0x14, 0xfc04);
18974 MP_WritePhyUshort(sc, 0x14, 0xee87);
18975 MP_WritePhyUshort(sc, 0x14, 0xff46);
18976 MP_WritePhyUshort(sc, 0x14, 0xee87);
18977 MP_WritePhyUshort(sc, 0x14, 0xfe01);
18978 MP_WritePhyUshort(sc, 0x14, 0x04f8);
18979 MP_WritePhyUshort(sc, 0x14, 0xfaef);
18980 MP_WritePhyUshort(sc, 0x14, 0x69e0);
18981 MP_WritePhyUshort(sc, 0x14, 0x8241);
18982 MP_WritePhyUshort(sc, 0x14, 0xa000);
18983 MP_WritePhyUshort(sc, 0x14, 0x0502);
18984 MP_WritePhyUshort(sc, 0x14, 0x85eb);
18985 MP_WritePhyUshort(sc, 0x14, 0xae0e);
18986 MP_WritePhyUshort(sc, 0x14, 0xa001);
18987 MP_WritePhyUshort(sc, 0x14, 0x0502);
18988 MP_WritePhyUshort(sc, 0x14, 0x1a5a);
18989 MP_WritePhyUshort(sc, 0x14, 0xae06);
18990 MP_WritePhyUshort(sc, 0x14, 0xa002);
18991 MP_WritePhyUshort(sc, 0x14, 0x0302);
18992 MP_WritePhyUshort(sc, 0x14, 0x1ae6);
18993 MP_WritePhyUshort(sc, 0x14, 0xef96);
18994 MP_WritePhyUshort(sc, 0x14, 0xfefc);
18995 MP_WritePhyUshort(sc, 0x14, 0x04f8);
18996 MP_WritePhyUshort(sc, 0x14, 0xf9fa);
18997 MP_WritePhyUshort(sc, 0x14, 0xef69);
18998 MP_WritePhyUshort(sc, 0x14, 0xe082);
18999 MP_WritePhyUshort(sc, 0x14, 0x29f6);
19000 MP_WritePhyUshort(sc, 0x14, 0x21e4);
19001 MP_WritePhyUshort(sc, 0x14, 0x8229);
19002 MP_WritePhyUshort(sc, 0x14, 0xe080);
19003 MP_WritePhyUshort(sc, 0x14, 0x10ac);
19004 MP_WritePhyUshort(sc, 0x14, 0x2202);
19005 MP_WritePhyUshort(sc, 0x14, 0xae76);
19006 MP_WritePhyUshort(sc, 0x14, 0xe082);
19007 MP_WritePhyUshort(sc, 0x14, 0x27f7);
19008 MP_WritePhyUshort(sc, 0x14, 0x21e4);
19009 MP_WritePhyUshort(sc, 0x14, 0x8227);
19010 MP_WritePhyUshort(sc, 0x14, 0xbf43);
19011 MP_WritePhyUshort(sc, 0x14, 0x1302);
19012 MP_WritePhyUshort(sc, 0x14, 0x4297);
19013 MP_WritePhyUshort(sc, 0x14, 0xef21);
19014 MP_WritePhyUshort(sc, 0x14, 0xbf43);
19015 MP_WritePhyUshort(sc, 0x14, 0x1602);
19016 MP_WritePhyUshort(sc, 0x14, 0x4297);
19017 MP_WritePhyUshort(sc, 0x14, 0x0c11);
19018 MP_WritePhyUshort(sc, 0x14, 0x1e21);
19019 MP_WritePhyUshort(sc, 0x14, 0xbf43);
19020 MP_WritePhyUshort(sc, 0x14, 0x1902);
19021 MP_WritePhyUshort(sc, 0x14, 0x4297);
19022 MP_WritePhyUshort(sc, 0x14, 0x0c12);
19023 MP_WritePhyUshort(sc, 0x14, 0x1e21);
19024 MP_WritePhyUshort(sc, 0x14, 0xe682);
19025 MP_WritePhyUshort(sc, 0x14, 0x43a2);
19026 MP_WritePhyUshort(sc, 0x14, 0x000a);
19027 MP_WritePhyUshort(sc, 0x14, 0xe182);
19028 MP_WritePhyUshort(sc, 0x14, 0x27f6);
19029 MP_WritePhyUshort(sc, 0x14, 0x29e5);
19030 MP_WritePhyUshort(sc, 0x14, 0x8227);
19031 MP_WritePhyUshort(sc, 0x14, 0xae42);
19032 MP_WritePhyUshort(sc, 0x14, 0xe082);
19033 MP_WritePhyUshort(sc, 0x14, 0x44f7);
19034 MP_WritePhyUshort(sc, 0x14, 0x21e4);
19035 MP_WritePhyUshort(sc, 0x14, 0x8244);
19036 MP_WritePhyUshort(sc, 0x14, 0x0246);
19037 MP_WritePhyUshort(sc, 0x14, 0xaebf);
19038 MP_WritePhyUshort(sc, 0x14, 0x4325);
19039 MP_WritePhyUshort(sc, 0x14, 0x0242);
19040 MP_WritePhyUshort(sc, 0x14, 0x97ef);
19041 MP_WritePhyUshort(sc, 0x14, 0x21bf);
19042 MP_WritePhyUshort(sc, 0x14, 0x431c);
19043 MP_WritePhyUshort(sc, 0x14, 0x0242);
19044 MP_WritePhyUshort(sc, 0x14, 0x970c);
19045 MP_WritePhyUshort(sc, 0x14, 0x121e);
19046 MP_WritePhyUshort(sc, 0x14, 0x21bf);
19047 MP_WritePhyUshort(sc, 0x14, 0x431f);
19048 MP_WritePhyUshort(sc, 0x14, 0x0242);
19049 MP_WritePhyUshort(sc, 0x14, 0x970c);
19050 MP_WritePhyUshort(sc, 0x14, 0x131e);
19051 MP_WritePhyUshort(sc, 0x14, 0x21bf);
19052 MP_WritePhyUshort(sc, 0x14, 0x4328);
19053 MP_WritePhyUshort(sc, 0x14, 0x0242);
19054 MP_WritePhyUshort(sc, 0x14, 0x970c);
19055 MP_WritePhyUshort(sc, 0x14, 0x141e);
19056 MP_WritePhyUshort(sc, 0x14, 0x21bf);
19057 MP_WritePhyUshort(sc, 0x14, 0x44b1);
19058 MP_WritePhyUshort(sc, 0x14, 0x0242);
19059 MP_WritePhyUshort(sc, 0x14, 0x970c);
19060 MP_WritePhyUshort(sc, 0x14, 0x161e);
19061 MP_WritePhyUshort(sc, 0x14, 0x21e6);
19062 MP_WritePhyUshort(sc, 0x14, 0x8242);
19063 MP_WritePhyUshort(sc, 0x14, 0xee82);
19064 MP_WritePhyUshort(sc, 0x14, 0x4101);
19065 MP_WritePhyUshort(sc, 0x14, 0xef96);
19066 MP_WritePhyUshort(sc, 0x14, 0xfefd);
19067 MP_WritePhyUshort(sc, 0x14, 0xfc04);
19068 MP_WritePhyUshort(sc, 0x14, 0xf8fa);
19069 MP_WritePhyUshort(sc, 0x14, 0xef69);
19070 MP_WritePhyUshort(sc, 0x14, 0xe082);
19071 MP_WritePhyUshort(sc, 0x14, 0x46a0);
19072 MP_WritePhyUshort(sc, 0x14, 0x0005);
19073 MP_WritePhyUshort(sc, 0x14, 0x0286);
19074 MP_WritePhyUshort(sc, 0x14, 0x96ae);
19075 MP_WritePhyUshort(sc, 0x14, 0x06a0);
19076 MP_WritePhyUshort(sc, 0x14, 0x0103);
19077 MP_WritePhyUshort(sc, 0x14, 0x0219);
19078 MP_WritePhyUshort(sc, 0x14, 0x19ef);
19079 MP_WritePhyUshort(sc, 0x14, 0x96fe);
19080 MP_WritePhyUshort(sc, 0x14, 0xfc04);
19081 MP_WritePhyUshort(sc, 0x14, 0xf8fa);
19082 MP_WritePhyUshort(sc, 0x14, 0xef69);
19083 MP_WritePhyUshort(sc, 0x14, 0xe082);
19084 MP_WritePhyUshort(sc, 0x14, 0x29f6);
19085 MP_WritePhyUshort(sc, 0x14, 0x20e4);
19086 MP_WritePhyUshort(sc, 0x14, 0x8229);
19087 MP_WritePhyUshort(sc, 0x14, 0xe080);
19088 MP_WritePhyUshort(sc, 0x14, 0x10ac);
19089 MP_WritePhyUshort(sc, 0x14, 0x2102);
19090 MP_WritePhyUshort(sc, 0x14, 0xae54);
19091 MP_WritePhyUshort(sc, 0x14, 0xe082);
19092 MP_WritePhyUshort(sc, 0x14, 0x27f7);
19093 MP_WritePhyUshort(sc, 0x14, 0x20e4);
19094 MP_WritePhyUshort(sc, 0x14, 0x8227);
19095 MP_WritePhyUshort(sc, 0x14, 0xbf42);
19096 MP_WritePhyUshort(sc, 0x14, 0xe602);
19097 MP_WritePhyUshort(sc, 0x14, 0x4297);
19098 MP_WritePhyUshort(sc, 0x14, 0xac28);
19099 MP_WritePhyUshort(sc, 0x14, 0x22bf);
19100 MP_WritePhyUshort(sc, 0x14, 0x430d);
19101 MP_WritePhyUshort(sc, 0x14, 0x0242);
19102 MP_WritePhyUshort(sc, 0x14, 0x97e5);
19103 MP_WritePhyUshort(sc, 0x14, 0x8247);
19104 MP_WritePhyUshort(sc, 0x14, 0xac28);
19105 MP_WritePhyUshort(sc, 0x14, 0x20d1);
19106 MP_WritePhyUshort(sc, 0x14, 0x03bf);
19107 MP_WritePhyUshort(sc, 0x14, 0x4307);
19108 MP_WritePhyUshort(sc, 0x14, 0x0242);
19109 MP_WritePhyUshort(sc, 0x14, 0x59ee);
19110 MP_WritePhyUshort(sc, 0x14, 0x8246);
19111 MP_WritePhyUshort(sc, 0x14, 0x00e1);
19112 MP_WritePhyUshort(sc, 0x14, 0x8227);
19113 MP_WritePhyUshort(sc, 0x14, 0xf628);
19114 MP_WritePhyUshort(sc, 0x14, 0xe582);
19115 MP_WritePhyUshort(sc, 0x14, 0x27ae);
19116 MP_WritePhyUshort(sc, 0x14, 0x21d1);
19117 MP_WritePhyUshort(sc, 0x14, 0x04bf);
19118 MP_WritePhyUshort(sc, 0x14, 0x4307);
19119 MP_WritePhyUshort(sc, 0x14, 0x0242);
19120 MP_WritePhyUshort(sc, 0x14, 0x59ae);
19121 MP_WritePhyUshort(sc, 0x14, 0x08d1);
19122 MP_WritePhyUshort(sc, 0x14, 0x05bf);
19123 MP_WritePhyUshort(sc, 0x14, 0x4307);
19124 MP_WritePhyUshort(sc, 0x14, 0x0242);
19125 MP_WritePhyUshort(sc, 0x14, 0x59e0);
19126 MP_WritePhyUshort(sc, 0x14, 0x8244);
19127 MP_WritePhyUshort(sc, 0x14, 0xf720);
19128 MP_WritePhyUshort(sc, 0x14, 0xe482);
19129 MP_WritePhyUshort(sc, 0x14, 0x4402);
19130 MP_WritePhyUshort(sc, 0x14, 0x46ae);
19131 MP_WritePhyUshort(sc, 0x14, 0xee82);
19132 MP_WritePhyUshort(sc, 0x14, 0x4601);
19133 MP_WritePhyUshort(sc, 0x14, 0xef96);
19134 MP_WritePhyUshort(sc, 0x14, 0xfefc);
19135 MP_WritePhyUshort(sc, 0x14, 0x04f8);
19136 MP_WritePhyUshort(sc, 0x14, 0xfaef);
19137 MP_WritePhyUshort(sc, 0x14, 0x69e0);
19138 MP_WritePhyUshort(sc, 0x14, 0x8013);
19139 MP_WritePhyUshort(sc, 0x14, 0xad24);
19140 MP_WritePhyUshort(sc, 0x14, 0x1cbf);
19141 MP_WritePhyUshort(sc, 0x14, 0x87f0);
19142 MP_WritePhyUshort(sc, 0x14, 0x0242);
19143 MP_WritePhyUshort(sc, 0x14, 0x97ad);
19144 MP_WritePhyUshort(sc, 0x14, 0x2813);
19145 MP_WritePhyUshort(sc, 0x14, 0xe087);
19146 MP_WritePhyUshort(sc, 0x14, 0xfca0);
19147 MP_WritePhyUshort(sc, 0x14, 0x0005);
19148 MP_WritePhyUshort(sc, 0x14, 0x0287);
19149 MP_WritePhyUshort(sc, 0x14, 0x36ae);
19150 MP_WritePhyUshort(sc, 0x14, 0x10a0);
19151 MP_WritePhyUshort(sc, 0x14, 0x0105);
19152 MP_WritePhyUshort(sc, 0x14, 0x0287);
19153 MP_WritePhyUshort(sc, 0x14, 0x48ae);
19154 MP_WritePhyUshort(sc, 0x14, 0x08e0);
19155 MP_WritePhyUshort(sc, 0x14, 0x8230);
19156 MP_WritePhyUshort(sc, 0x14, 0xf626);
19157 MP_WritePhyUshort(sc, 0x14, 0xe482);
19158 MP_WritePhyUshort(sc, 0x14, 0x30ef);
19159 MP_WritePhyUshort(sc, 0x14, 0x96fe);
19160 MP_WritePhyUshort(sc, 0x14, 0xfc04);
19161 MP_WritePhyUshort(sc, 0x14, 0xf8e0);
19162 MP_WritePhyUshort(sc, 0x14, 0x8245);
19163 MP_WritePhyUshort(sc, 0x14, 0xf722);
19164 MP_WritePhyUshort(sc, 0x14, 0xe482);
19165 MP_WritePhyUshort(sc, 0x14, 0x4502);
19166 MP_WritePhyUshort(sc, 0x14, 0x46ae);
19167 MP_WritePhyUshort(sc, 0x14, 0xee87);
19168 MP_WritePhyUshort(sc, 0x14, 0xfc01);
19169 MP_WritePhyUshort(sc, 0x14, 0xfc04);
19170 MP_WritePhyUshort(sc, 0x14, 0xf8fa);
19171 MP_WritePhyUshort(sc, 0x14, 0xef69);
19172 MP_WritePhyUshort(sc, 0x14, 0xfb02);
19173 MP_WritePhyUshort(sc, 0x14, 0x46d3);
19174 MP_WritePhyUshort(sc, 0x14, 0xad50);
19175 MP_WritePhyUshort(sc, 0x14, 0x2fbf);
19176 MP_WritePhyUshort(sc, 0x14, 0x87ed);
19177 MP_WritePhyUshort(sc, 0x14, 0xd101);
19178 MP_WritePhyUshort(sc, 0x14, 0x0242);
19179 MP_WritePhyUshort(sc, 0x14, 0x59bf);
19180 MP_WritePhyUshort(sc, 0x14, 0x87ed);
19181 MP_WritePhyUshort(sc, 0x14, 0xd100);
19182 MP_WritePhyUshort(sc, 0x14, 0x0242);
19183 MP_WritePhyUshort(sc, 0x14, 0x59e0);
19184 MP_WritePhyUshort(sc, 0x14, 0x8245);
19185 MP_WritePhyUshort(sc, 0x14, 0xf622);
19186 MP_WritePhyUshort(sc, 0x14, 0xe482);
19187 MP_WritePhyUshort(sc, 0x14, 0x4502);
19188 MP_WritePhyUshort(sc, 0x14, 0x46ae);
19189 MP_WritePhyUshort(sc, 0x14, 0xd100);
19190 MP_WritePhyUshort(sc, 0x14, 0xbf87);
19191 MP_WritePhyUshort(sc, 0x14, 0xf002);
19192 MP_WritePhyUshort(sc, 0x14, 0x4259);
19193 MP_WritePhyUshort(sc, 0x14, 0xee87);
19194 MP_WritePhyUshort(sc, 0x14, 0xfc00);
19195 MP_WritePhyUshort(sc, 0x14, 0xe082);
19196 MP_WritePhyUshort(sc, 0x14, 0x30f6);
19197 MP_WritePhyUshort(sc, 0x14, 0x26e4);
19198 MP_WritePhyUshort(sc, 0x14, 0x8230);
19199 MP_WritePhyUshort(sc, 0x14, 0xffef);
19200 MP_WritePhyUshort(sc, 0x14, 0x96fe);
19201 MP_WritePhyUshort(sc, 0x14, 0xfc04);
19202 MP_WritePhyUshort(sc, 0x14, 0xf8f9);
19203 MP_WritePhyUshort(sc, 0x14, 0xface);
19204 MP_WritePhyUshort(sc, 0x14, 0xfaef);
19205 MP_WritePhyUshort(sc, 0x14, 0x69fb);
19206 MP_WritePhyUshort(sc, 0x14, 0xbf87);
19207 MP_WritePhyUshort(sc, 0x14, 0xb3d7);
19208 MP_WritePhyUshort(sc, 0x14, 0x001c);
19209 MP_WritePhyUshort(sc, 0x14, 0xd819);
19210 MP_WritePhyUshort(sc, 0x14, 0xd919);
19211 MP_WritePhyUshort(sc, 0x14, 0xda19);
19212 MP_WritePhyUshort(sc, 0x14, 0xdb19);
19213 MP_WritePhyUshort(sc, 0x14, 0x07ef);
19214 MP_WritePhyUshort(sc, 0x14, 0x9502);
19215 MP_WritePhyUshort(sc, 0x14, 0x4259);
19216 MP_WritePhyUshort(sc, 0x14, 0x073f);
19217 MP_WritePhyUshort(sc, 0x14, 0x0004);
19218 MP_WritePhyUshort(sc, 0x14, 0x9fec);
19219 MP_WritePhyUshort(sc, 0x14, 0xffef);
19220 MP_WritePhyUshort(sc, 0x14, 0x96fe);
19221 MP_WritePhyUshort(sc, 0x14, 0xc6fe);
19222 MP_WritePhyUshort(sc, 0x14, 0xfdfc);
19223 MP_WritePhyUshort(sc, 0x14, 0x0400);
19224 MP_WritePhyUshort(sc, 0x14, 0x0145);
19225 MP_WritePhyUshort(sc, 0x14, 0x7d00);
19226 MP_WritePhyUshort(sc, 0x14, 0x0345);
19227 MP_WritePhyUshort(sc, 0x14, 0x5c00);
19228 MP_WritePhyUshort(sc, 0x14, 0x0143);
19229 MP_WritePhyUshort(sc, 0x14, 0x4f00);
19230 MP_WritePhyUshort(sc, 0x14, 0x0387);
19231 MP_WritePhyUshort(sc, 0x14, 0xdb00);
19232 MP_WritePhyUshort(sc, 0x14, 0x0987);
19233 MP_WritePhyUshort(sc, 0x14, 0xde00);
19234 MP_WritePhyUshort(sc, 0x14, 0x0987);
19235 MP_WritePhyUshort(sc, 0x14, 0xe100);
19236 MP_WritePhyUshort(sc, 0x14, 0x0087);
19237 MP_WritePhyUshort(sc, 0x14, 0xeaa4);
19238 MP_WritePhyUshort(sc, 0x14, 0x00b8);
19239 MP_WritePhyUshort(sc, 0x14, 0x20c4);
19240 MP_WritePhyUshort(sc, 0x14, 0x1600);
19241 MP_WritePhyUshort(sc, 0x14, 0x000f);
19242 MP_WritePhyUshort(sc, 0x14, 0xf800);
19243 MP_WritePhyUshort(sc, 0x14, 0x7098);
19244 MP_WritePhyUshort(sc, 0x14, 0xa58a);
19245 MP_WritePhyUshort(sc, 0x14, 0xb6a8);
19246 MP_WritePhyUshort(sc, 0x14, 0x3e50);
19247 MP_WritePhyUshort(sc, 0x14, 0xa83e);
19248 MP_WritePhyUshort(sc, 0x14, 0x33bc);
19249 MP_WritePhyUshort(sc, 0x14, 0xc622);
19250 MP_WritePhyUshort(sc, 0x14, 0xbcc6);
19251 MP_WritePhyUshort(sc, 0x14, 0xaaa4);
19252 MP_WritePhyUshort(sc, 0x14, 0x42ff);
19253 MP_WritePhyUshort(sc, 0x14, 0xc408);
19254 MP_WritePhyUshort(sc, 0x14, 0x00c4);
19255 MP_WritePhyUshort(sc, 0x14, 0x16a8);
19256 MP_WritePhyUshort(sc, 0x14, 0xbcc0);
19257 MP_WritePhyUshort(sc, 0x13, 0xb818);
19258 MP_WritePhyUshort(sc, 0x14, 0x02f3);
19259 MP_WritePhyUshort(sc, 0x13, 0xb81a);
19260 MP_WritePhyUshort(sc, 0x14, 0x17d1);
19261 MP_WritePhyUshort(sc, 0x13, 0xb81c);
19262 MP_WritePhyUshort(sc, 0x14, 0x185a);
19263 MP_WritePhyUshort(sc, 0x13, 0xb81e);
19264 MP_WritePhyUshort(sc, 0x14, 0x3c66);
19265 MP_WritePhyUshort(sc, 0x13, 0xb820);
19266 MP_WritePhyUshort(sc, 0x14, 0x021f);
19267 MP_WritePhyUshort(sc, 0x13, 0xc416);
19268 MP_WritePhyUshort(sc, 0x14, 0x0500);
19269 MP_WritePhyUshort(sc, 0x13, 0xb82e);
19270 MP_WritePhyUshort(sc, 0x14, 0xfffc);
19271
19272 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19273 MP_WritePhyUshort(sc, 0x13, 0x0000);
19274 MP_WritePhyUshort(sc, 0x14, 0x0000);
19275 MP_WritePhyUshort(sc, 0x1f, 0x0B82);
19276 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
19277 PhyRegValue &= ~(BIT_9);
19278 MP_WritePhyUshort(sc, 0x10, PhyRegValue);
19279 MP_WritePhyUshort(sc, 0x1f, 0x0A43);
19280 MP_WritePhyUshort(sc, 0x13, 0x8146);
19281 MP_WritePhyUshort(sc, 0x14, 0x0000);
19282
19283 MP_WritePhyUshort(sc, 0x1f, 0x0B82);
19284 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
19285 PhyRegValue &= ~(BIT_4);
19286 MP_WritePhyUshort(sc, 0x10, PhyRegValue); // release patch request
19287
19288
19289 MP_WritePhyUshort(sc, 0x1F, 0x0A46);
19290 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
19291 TmpUshort = (PhyRegValue & BIT_8) ? 0 : BIT_15;
19292
19293 MP_WritePhyUshort(sc, 0x1F, 0x0BCC);
19294 ClearEthPhyBit(sc, 0x12, BIT_15);
19295 SetEthPhyBit(sc, 0x12, TmpUshort);
19296
19297
19298 MP_WritePhyUshort(sc, 0x1F, 0x0A46);
19299 PhyRegValue = MP_ReadPhyUshort(sc, 0x13);
19300 TmpUshort = (PhyRegValue & BIT_8) ? BIT_1 : 0;
19301
19302 MP_WritePhyUshort(sc, 0x1F, 0x0C41);
19303 ClearEthPhyBit(sc, 0x15, BIT_1);
19304 SetEthPhyBit(sc, 0x15, TmpUshort);
19305
19306 MP_WritePhyUshort(sc, 0x1F, 0x0A44);
19307 SetEthPhyBit(sc, 0x11, (BIT_3 | BIT_2));
19308 MP_WritePhyUshort(sc, 0x1F, 0x0000);
19309
19310
19311 MP_WritePhyUshort(sc, 0x1F, 0x0BCC);
19312 ClearEthPhyBit(sc, 0x14, BIT_8);
19313 MP_WritePhyUshort(sc, 0x1F, 0x0A44);
19314 SetEthPhyBit(sc, 0x11, BIT_7);
19315 SetEthPhyBit(sc, 0x11, BIT_6);
19316 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19317 MP_WritePhyUshort(sc, 0x13, 0x8084);
19318 ClearEthPhyBit(sc, 0x14, (BIT_14 | BIT_13));
19319 SetEthPhyBit(sc, 0x10, BIT_12);
19320 SetEthPhyBit(sc, 0x10, BIT_1);
19321 SetEthPhyBit(sc, 0x10, BIT_0);
19322 MP_WritePhyUshort(sc, 0x1F, 0x0000);
19323
19324
19325 MP_WritePhyUshort(sc, 0x1F, 0x0A4B);
19326 SetEthPhyBit(sc, 0x11, BIT_2);
19327 MP_WritePhyUshort(sc, 0x1F, 0x0000);
19328
19329
19330
19331 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19332 MP_WritePhyUshort(sc, 0x13, 0x8012);
19333 SetEthPhyBit(sc, 0x14, BIT_15);
19334 MP_WritePhyUshort(sc, 0x1F, 0x0000);
19335
19336
19337
19338 MP_WritePhyUshort(sc, 0x1F, 0x0C42);
19339 ClearAndSetEthPhyBit(sc,
19340 0x11,
19341 BIT_13 ,
19342 BIT_14
19343 );
19344 MP_WritePhyUshort(sc, 0x1F, 0x0000);
19345
19346 if (phy_power_saving == 1) {
19347 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19348 SetEthPhyBit(sc, 0x10, BIT_2);
19349 MP_WritePhyUshort(sc, 0x1F, 0x0000);
19350 } else {
19351 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19352 ClearEthPhyBit(sc, 0x10, BIT_2);
19353 MP_WritePhyUshort(sc, 0x1F, 0x0000);
19354 DELAY(20000);
19355 }
19356
19357 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19358 MP_WritePhyUshort(sc, 0x13, 0x809A);
19359 MP_WritePhyUshort(sc, 0x14, 0x8022);
19360 MP_WritePhyUshort(sc, 0x13, 0x80A0);
19361 ClearAndSetEthPhyBit(sc,
19362 0x14,
19363 0xFF00,
19364 0x1000
19365 );
19366 MP_WritePhyUshort(sc, 0x13, 0x8088);
19367 MP_WritePhyUshort(sc, 0x14, 0x9222);
19368 MP_WritePhyUshort(sc, 0x1F, 0x0000);
19369
19370 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19371 MP_WritePhyUshort(sc, 0x13, 0x8011);
19372 ClearEthPhyBit(sc, 0x14, BIT_14);
19373 MP_WritePhyUshort(sc, 0x1F, 0x0A40);
19374 MP_WritePhyUshort(sc, 0x1F, 0x0000);
19375 MP_WritePhyUshort(sc, 0x00, 0x9200);
19376 } else if (sc->re_type == MACFG_58) {
19377 MP_WritePhyUshort(sc, 0x1F, 0x0BCC);
19378 ClearEthPhyBit(sc, 0x14, BIT_8);
19379 MP_WritePhyUshort(sc, 0x1F, 0x0A44);
19380 SetEthPhyBit(sc, 0x11, BIT_7);
19381 SetEthPhyBit(sc, 0x11, BIT_6);
19382 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19383 MP_WritePhyUshort(sc, 0x13, 0x8084);
19384 ClearEthPhyBit(sc, 0x14, (BIT_14 | BIT_13));
19385 SetEthPhyBit(sc, 0x10, BIT_12);
19386 SetEthPhyBit(sc, 0x10, BIT_1);
19387 SetEthPhyBit(sc, 0x10, BIT_0);
19388 MP_WritePhyUshort(sc, 0x1F, 0x0000);
19389
19390 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19391 MP_WritePhyUshort(sc, 0x13, 0x8012);
19392 SetEthPhyBit(sc, 0x14, BIT_15);
19393 MP_WritePhyUshort(sc, 0x1F, 0x0000);
19394
19395 MP_WritePhyUshort(sc, 0x1F, 0x0C42);
19396 ClearAndSetEthPhyBit(sc,
19397 0x11,
19398 BIT_13 ,
19399 BIT_14
19400 );
19401 MP_WritePhyUshort(sc, 0x1F, 0x0000);
19402
19403 if (phy_power_saving == 1) {
19404 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19405 SetEthPhyBit(sc, 0x10, BIT_2);
19406 MP_WritePhyUshort(sc, 0x1F, 0x0000);
19407 } else {
19408 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19409 ClearEthPhyBit(sc, 0x10, BIT_2);
19410 MP_WritePhyUshort(sc, 0x1F, 0x0000);
19411 DELAY(20000);
19412 }
19413
19414 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19415 MP_WritePhyUshort(sc, 0x13, 0x8011);
19416 ClearEthPhyBit(sc, 0x14, BIT_14);
19417 MP_WritePhyUshort(sc, 0x1F, 0x0A40);
19418 MP_WritePhyUshort(sc, 0x1F, 0x0000);
19419 MP_WritePhyUshort(sc, 0x00, 0x9200);
19420 } else if (sc->re_type == MACFG_59) {
19421 MP_WritePhyUshort(sc, 0x1f, 0x0B82);
19422 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
19423 PhyRegValue |= BIT_4;
19424 MP_WritePhyUshort(sc, 0x10, PhyRegValue);
19425
19426 MP_WritePhyUshort(sc, 0x1f, 0x0B80);
19427 WaitCnt = 0;
19428 do {
19429 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
19430 PhyRegValue &= 0x0040;
19431 DELAY(50);
19432 DELAY(50);
19433 WaitCnt++;
19434 } while(PhyRegValue != 0x0040 && WaitCnt <1000);
19435
19436 MP_WritePhyUshort(sc, 0x1f, 0x0A43);
19437 MP_WritePhyUshort(sc, 0x13, 0x8146);
19438 MP_WritePhyUshort(sc, 0x14, 0x0300);
19439 MP_WritePhyUshort(sc, 0x13, 0xB82E);
19440 MP_WritePhyUshort(sc, 0x14, 0x0001);
19441
19442 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19443 MP_WritePhyUshort(sc, 0x13, 0xb820);
19444 MP_WritePhyUshort(sc, 0x14, 0x0290);
19445 MP_WritePhyUshort(sc, 0x13, 0xa012);
19446 MP_WritePhyUshort(sc, 0x14, 0x0000);
19447 MP_WritePhyUshort(sc, 0x13, 0xa014);
19448 MP_WritePhyUshort(sc, 0x14, 0x2c04);
19449 MP_WritePhyUshort(sc, 0x14, 0x2c07);
19450 MP_WritePhyUshort(sc, 0x14, 0x2c07);
19451 MP_WritePhyUshort(sc, 0x14, 0x2c07);
19452 MP_WritePhyUshort(sc, 0x14, 0xa304);
19453 MP_WritePhyUshort(sc, 0x14, 0xa301);
19454 MP_WritePhyUshort(sc, 0x14, 0x207e);
19455 MP_WritePhyUshort(sc, 0x13, 0xa01a);
19456 MP_WritePhyUshort(sc, 0x14, 0x0000);
19457 MP_WritePhyUshort(sc, 0x13, 0xa006);
19458 MP_WritePhyUshort(sc, 0x14, 0x0fff);
19459 MP_WritePhyUshort(sc, 0x13, 0xa004);
19460 MP_WritePhyUshort(sc, 0x14, 0x0fff);
19461 MP_WritePhyUshort(sc, 0x13, 0xa002);
19462 MP_WritePhyUshort(sc, 0x14, 0x0fff);
19463 MP_WritePhyUshort(sc, 0x13, 0xa000);
19464 MP_WritePhyUshort(sc, 0x14, 0x107c);
19465 MP_WritePhyUshort(sc, 0x13, 0xb820);
19466 MP_WritePhyUshort(sc, 0x14, 0x0210);
19467
19468 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19469 MP_WritePhyUshort(sc, 0x13, 0x0000);
19470 MP_WritePhyUshort(sc, 0x14, 0x0000);
19471 MP_WritePhyUshort(sc, 0x1f, 0x0B82);
19472 PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
19473 PhyRegValue &= ~(BIT_0);
19474 MP_WritePhyUshort(sc, 0x17, PhyRegValue);
19475 MP_WritePhyUshort(sc, 0x1f, 0x0A43);
19476 MP_WritePhyUshort(sc, 0x13, 0x8146);
19477 MP_WritePhyUshort(sc, 0x14, 0x0000);
19478
19479 MP_WritePhyUshort(sc, 0x1f, 0x0B82);
19480 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
19481 PhyRegValue &= ~(BIT_4);
19482 MP_WritePhyUshort(sc, 0x10, PhyRegValue);
19483
19484 MP_WritePhyUshort(sc, 0x1F, 0x0BCC);
19485 ClearEthPhyBit(sc, 0x14, BIT_8);
19486 MP_WritePhyUshort(sc, 0x1F, 0x0A44);
19487 SetEthPhyBit(sc, 0x11, BIT_7);
19488 SetEthPhyBit(sc, 0x11, BIT_6);
19489 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19490 MP_WritePhyUshort(sc, 0x13, 0x8084);
19491 ClearEthPhyBit(sc, 0x14, (BIT_14 | BIT_13));
19492 SetEthPhyBit(sc, 0x10, BIT_12);
19493 SetEthPhyBit(sc, 0x10, BIT_1);
19494 SetEthPhyBit(sc, 0x10, BIT_0);
19495
19496
19497 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19498 MP_WritePhyUshort(sc, 0x13, 0x8012);
19499 SetEthPhyBit(sc, 0x14, BIT_15);
19500 MP_WritePhyUshort(sc, 0x1F, 0x0000);
19501
19502 MP_WritePhyUshort(sc, 0x1F, 0x0BCE);
19503 MP_WritePhyUshort(sc, 0x12, 0x8860);
19504 MP_WritePhyUshort(sc, 0x1F, 0x0000);
19505
19506 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19507 MP_WritePhyUshort(sc, 0x13, 0x80F3);
19508 ClearAndSetEthPhyBit(sc,
19509 0x14,
19510 0xFF00 ,
19511 0x8B00
19512 );
19513 MP_WritePhyUshort(sc, 0x13, 0x80F0);
19514 ClearAndSetEthPhyBit(sc,
19515 0x14,
19516 0xFF00 ,
19517 0x3A00
19518 );
19519 MP_WritePhyUshort(sc, 0x13, 0x80EF);
19520 ClearAndSetEthPhyBit(sc,
19521 0x14,
19522 0xFF00 ,
19523 0x0500
19524 );
19525 MP_WritePhyUshort(sc, 0x13, 0x80F6);
19526 ClearAndSetEthPhyBit(sc,
19527 0x14,
19528 0xFF00 ,
19529 0x6E00
19530 );
19531 MP_WritePhyUshort(sc, 0x13, 0x80EC);
19532 ClearAndSetEthPhyBit(sc,
19533 0x14,
19534 0xFF00 ,
19535 0x6800
19536 );
19537 MP_WritePhyUshort(sc, 0x13, 0x80ED);
19538 ClearAndSetEthPhyBit(sc,
19539 0x14,
19540 0xFF00 ,
19541 0x7C00
19542 );
19543 MP_WritePhyUshort(sc, 0x13, 0x80F2);
19544 ClearAndSetEthPhyBit(sc,
19545 0x14,
19546 0xFF00 ,
19547 0xF400
19548 );
19549 MP_WritePhyUshort(sc, 0x13, 0x80F4);
19550 ClearAndSetEthPhyBit(sc,
19551 0x14,
19552 0xFF00 ,
19553 0x8500
19554 );
19555
19556 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19557 MP_WritePhyUshort(sc, 0x13, 0x8110);
19558 ClearAndSetEthPhyBit(sc,
19559 0x14,
19560 0xFF00 ,
19561 0xA800
19562 );
19563 MP_WritePhyUshort(sc, 0x13, 0x810F);
19564 ClearAndSetEthPhyBit(sc,
19565 0x14,
19566 0xFF00 ,
19567 0x1D00
19568 );
19569 MP_WritePhyUshort(sc, 0x13, 0x8111);
19570 ClearAndSetEthPhyBit(sc,
19571 0x14,
19572 0xFF00 ,
19573 0xF500
19574 );
19575 MP_WritePhyUshort(sc, 0x13, 0x8113);
19576 ClearAndSetEthPhyBit(sc,
19577 0x14,
19578 0xFF00 ,
19579 0x6100
19580 );
19581 MP_WritePhyUshort(sc, 0x13, 0x8115);
19582 ClearAndSetEthPhyBit(sc,
19583 0x14,
19584 0xFF00 ,
19585 0x9200
19586 );
19587 MP_WritePhyUshort(sc, 0x13, 0x810E);
19588 ClearAndSetEthPhyBit(sc,
19589 0x14,
19590 0xFF00 ,
19591 0x0400
19592 );
19593 MP_WritePhyUshort(sc, 0x13, 0x810C);
19594 ClearAndSetEthPhyBit(sc,
19595 0x14,
19596 0xFF00 ,
19597 0x7C00
19598 );
19599 MP_WritePhyUshort(sc, 0x13, 0x810B);
19600 ClearAndSetEthPhyBit(sc,
19601 0x14,
19602 0xFF00 ,
19603 0x5A00
19604 );
19605
19606 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19607 MP_WritePhyUshort(sc, 0x13, 0x80D1);
19608 ClearAndSetEthPhyBit(sc,
19609 0x14,
19610 0xFF00 ,
19611 0xFF00
19612 );
19613 MP_WritePhyUshort(sc, 0x13, 0x80CD);
19614 ClearAndSetEthPhyBit(sc,
19615 0x14,
19616 0xFF00 ,
19617 0x9E00
19618 );
19619 MP_WritePhyUshort(sc, 0x13, 0x80D3);
19620 ClearAndSetEthPhyBit(sc,
19621 0x14,
19622 0xFF00 ,
19623 0x0E00
19624 );
19625 MP_WritePhyUshort(sc, 0x13, 0x80D5);
19626 ClearAndSetEthPhyBit(sc,
19627 0x14,
19628 0xFF00 ,
19629 0xCA00
19630 );
19631 MP_WritePhyUshort(sc, 0x13, 0x80D7);
19632 ClearAndSetEthPhyBit(sc,
19633 0x14,
19634 0xFF00 ,
19635 0x8400
19636 );
19637
19638 if (phy_power_saving == 1) {
19639 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19640 SetEthPhyBit(sc, 0x10, BIT_2);
19641 MP_WritePhyUshort(sc, 0x1F, 0x0000);
19642 } else {
19643 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19644 ClearEthPhyBit(sc, 0x10, BIT_2);
19645 MP_WritePhyUshort(sc, 0x1F, 0x0000);
19646 DELAY(20000);
19647 }
19648
19649 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19650 MP_WritePhyUshort(sc, 0x13, 0x8011);
19651 ClearEthPhyBit(sc, 0x14, BIT_14);
19652 MP_WritePhyUshort(sc, 0x1F, 0x0A40);
19653 MP_WritePhyUshort(sc, 0x1F, 0x0000);
19654 MP_WritePhyUshort(sc, 0x00, 0x9200);
19655 } else if (sc->re_type == MACFG_60) {
19656 MP_WritePhyUshort(sc, 0x1f, 0x0B82);
19657 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
19658 PhyRegValue |= BIT_4;
19659 MP_WritePhyUshort(sc, 0x10, PhyRegValue);
19660
19661 MP_WritePhyUshort(sc, 0x1f, 0x0B80);
19662 WaitCnt = 0;
19663 do {
19664 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
19665 PhyRegValue &= 0x0040;
19666 DELAY(50);
19667 DELAY(50);
19668 WaitCnt++;
19669 } while(PhyRegValue != 0x0040 && WaitCnt <1000);
19670
19671 MP_WritePhyUshort(sc, 0x1f, 0x0A43);
19672 MP_WritePhyUshort(sc, 0x13, 0x8146);
19673 MP_WritePhyUshort(sc, 0x14, 0x0100);
19674 MP_WritePhyUshort(sc, 0x13, 0xB82E);
19675 MP_WritePhyUshort(sc, 0x14, 0x0001);
19676
19677 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19678 MP_WritePhyUshort(sc, 0x13, 0xb820);
19679 MP_WritePhyUshort(sc, 0x14, 0x0290);
19680 MP_WritePhyUshort(sc, 0x13, 0xa012);
19681 MP_WritePhyUshort(sc, 0x14, 0x0000);
19682 MP_WritePhyUshort(sc, 0x13, 0xa014);
19683 MP_WritePhyUshort(sc, 0x14, 0x2c04);
19684 MP_WritePhyUshort(sc, 0x14, 0x2c07);
19685 MP_WritePhyUshort(sc, 0x14, 0x2c07);
19686 MP_WritePhyUshort(sc, 0x14, 0x2c07);
19687 MP_WritePhyUshort(sc, 0x14, 0xa304);
19688 MP_WritePhyUshort(sc, 0x14, 0xa301);
19689 MP_WritePhyUshort(sc, 0x14, 0x207e);
19690 MP_WritePhyUshort(sc, 0x13, 0xa01a);
19691 MP_WritePhyUshort(sc, 0x14, 0x0000);
19692 MP_WritePhyUshort(sc, 0x13, 0xa006);
19693 MP_WritePhyUshort(sc, 0x14, 0x0fff);
19694 MP_WritePhyUshort(sc, 0x13, 0xa004);
19695 MP_WritePhyUshort(sc, 0x14, 0x0fff);
19696 MP_WritePhyUshort(sc, 0x13, 0xa002);
19697 MP_WritePhyUshort(sc, 0x14, 0x0fff);
19698 MP_WritePhyUshort(sc, 0x13, 0xa000);
19699 MP_WritePhyUshort(sc, 0x14, 0x107c);
19700 MP_WritePhyUshort(sc, 0x13, 0xb820);
19701 MP_WritePhyUshort(sc, 0x14, 0x0210);
19702
19703 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19704 MP_WritePhyUshort(sc, 0x13, 0x0000);
19705 MP_WritePhyUshort(sc, 0x14, 0x0000);
19706 MP_WritePhyUshort(sc, 0x1f, 0x0B82);
19707 PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
19708 PhyRegValue &= ~(BIT_0);
19709 MP_WritePhyUshort(sc, 0x17, PhyRegValue);
19710 MP_WritePhyUshort(sc, 0x1f, 0x0A43);
19711 MP_WritePhyUshort(sc, 0x13, 0x8146);
19712 MP_WritePhyUshort(sc, 0x14, 0x0000);
19713
19714 MP_WritePhyUshort(sc,0x1f, 0x0B82);
19715 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
19716 PhyRegValue &= ~(BIT_4);
19717 MP_WritePhyUshort(sc,0x10, PhyRegValue);
19718
19719 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19720 MP_WritePhyUshort(sc, 0x13, 0x8012);
19721 SetEthPhyBit(sc, 0x14, BIT_15);
19722 MP_WritePhyUshort(sc, 0x1F, 0x0000);
19723
19724 MP_WritePhyUshort(sc, 0x1F, 0x0BCE);
19725 MP_WritePhyUshort(sc, 0x12, 0x8860);
19726 MP_WritePhyUshort(sc, 0x1F, 0x0000);
19727
19728 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19729 MP_WritePhyUshort(sc, 0x13, 0x80F3);
19730 ClearAndSetEthPhyBit(sc,
19731 0x14,
19732 0xFF00 ,
19733 0x8B00
19734 );
19735 MP_WritePhyUshort(sc, 0x13, 0x80F0);
19736 ClearAndSetEthPhyBit(sc,
19737 0x14,
19738 0xFF00 ,
19739 0x3A00
19740 );
19741 MP_WritePhyUshort(sc, 0x13, 0x80EF);
19742 ClearAndSetEthPhyBit(sc,
19743 0x14,
19744 0xFF00 ,
19745 0x0500
19746 );
19747 MP_WritePhyUshort(sc, 0x13, 0x80F6);
19748 ClearAndSetEthPhyBit(sc,
19749 0x14,
19750 0xFF00 ,
19751 0x6E00
19752 );
19753 MP_WritePhyUshort(sc, 0x13, 0x80EC);
19754 ClearAndSetEthPhyBit(sc,
19755 0x14,
19756 0xFF00 ,
19757 0x6800
19758 );
19759 MP_WritePhyUshort(sc, 0x13, 0x80ED);
19760 ClearAndSetEthPhyBit(sc,
19761 0x14,
19762 0xFF00 ,
19763 0x7C00
19764 );
19765 MP_WritePhyUshort(sc, 0x13, 0x80F2);
19766 ClearAndSetEthPhyBit(sc,
19767 0x14,
19768 0xFF00 ,
19769 0xF400
19770 );
19771 MP_WritePhyUshort(sc, 0x13, 0x80F4);
19772 ClearAndSetEthPhyBit(sc,
19773 0x14,
19774 0xFF00 ,
19775 0x8500
19776 );
19777
19778 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19779 MP_WritePhyUshort(sc, 0x13, 0x8110);
19780 ClearAndSetEthPhyBit(sc,
19781 0x14,
19782 0xFF00 ,
19783 0xA800
19784 );
19785 MP_WritePhyUshort(sc, 0x13, 0x810F);
19786 ClearAndSetEthPhyBit(sc,
19787 0x14,
19788 0xFF00 ,
19789 0x1D00
19790 );
19791 MP_WritePhyUshort(sc, 0x13, 0x8111);
19792 ClearAndSetEthPhyBit(sc,
19793 0x14,
19794 0xFF00 ,
19795 0xF500
19796 );
19797 MP_WritePhyUshort(sc, 0x13, 0x8113);
19798 ClearAndSetEthPhyBit(sc,
19799 0x14,
19800 0xFF00 ,
19801 0x6100
19802 );
19803 MP_WritePhyUshort(sc, 0x13, 0x8115);
19804 ClearAndSetEthPhyBit(sc,
19805 0x14,
19806 0xFF00 ,
19807 0x9200
19808 );
19809 MP_WritePhyUshort(sc, 0x13, 0x810E);
19810 ClearAndSetEthPhyBit(sc,
19811 0x14,
19812 0xFF00 ,
19813 0x0400
19814 );
19815 MP_WritePhyUshort(sc, 0x13, 0x810C);
19816 ClearAndSetEthPhyBit(sc,
19817 0x14,
19818 0xFF00 ,
19819 0x7C00
19820 );
19821 MP_WritePhyUshort(sc, 0x13, 0x810B);
19822 ClearAndSetEthPhyBit(sc,
19823 0x14,
19824 0xFF00 ,
19825 0x5A00
19826 );
19827
19828 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19829 MP_WritePhyUshort(sc, 0x13, 0x80D1);
19830 ClearAndSetEthPhyBit(sc,
19831 0x14,
19832 0xFF00 ,
19833 0xFF00
19834 );
19835 MP_WritePhyUshort(sc, 0x13, 0x80CD);
19836 ClearAndSetEthPhyBit(sc,
19837 0x14,
19838 0xFF00 ,
19839 0x9E00
19840 );
19841 MP_WritePhyUshort(sc, 0x13, 0x80D3);
19842 ClearAndSetEthPhyBit(sc,
19843 0x14,
19844 0xFF00 ,
19845 0x0E00
19846 );
19847 MP_WritePhyUshort(sc, 0x13, 0x80D5);
19848 ClearAndSetEthPhyBit(sc,
19849 0x14,
19850 0xFF00 ,
19851 0xCA00
19852 );
19853 MP_WritePhyUshort(sc, 0x13, 0x80D7);
19854 ClearAndSetEthPhyBit(sc,
19855 0x14,
19856 0xFF00 ,
19857 0x8400
19858 );
19859
19860 if (phy_power_saving == 1) {
19861 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19862 SetEthPhyBit(sc, 0x10, BIT_2);
19863 MP_WritePhyUshort(sc, 0x1F, 0x0000);
19864 } else {
19865 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19866 ClearEthPhyBit(sc, 0x10, BIT_2);
19867 MP_WritePhyUshort(sc, 0x1F, 0x0000);
19868 DELAY(20000);
19869 }
19870
19871 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
19872 MP_WritePhyUshort(sc, 0x13, 0x8011);
19873 ClearEthPhyBit(sc, 0x14, BIT_14);
19874 MP_WritePhyUshort(sc, 0x1F, 0x0A40);
19875 MP_WritePhyUshort(sc, 0x1F, 0x0000);
19876 MP_WritePhyUshort(sc, 0x00, 0x9200);
19877 } else if (sc->re_type == MACFG_61) {
19878 MP_WritePhyUshort(sc,0x1f, 0x0B82);
19879 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
19880 PhyRegValue |= BIT_4;
19881 MP_WritePhyUshort(sc,0x10, PhyRegValue);
19882
19883 MP_WritePhyUshort(sc,0x1f, 0x0B80);
19884 WaitCnt = 0;
19885 do {
19886 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
19887 PhyRegValue &= 0x0040;
19888 DELAY(50);
19889 DELAY(50);
19890 WaitCnt++;
19891 } while(PhyRegValue != 0x0040 && WaitCnt <1000);
19892
19893 MP_WritePhyUshort(sc,0x1f, 0x0A43);
19894 MP_WritePhyUshort(sc,0x13, 0x8146);
19895 MP_WritePhyUshort(sc,0x14, 0x2700);
19896 MP_WritePhyUshort(sc,0x13, 0xB82E);
19897 MP_WritePhyUshort(sc,0x14, 0x0001);
19898
19899 MP_WritePhyUshort(sc,0x1F, 0x0A43);
19900 MP_WritePhyUshort(sc, 0x13, 0xb820);
19901 MP_WritePhyUshort(sc, 0x14, 0x0090);
19902 MP_WritePhyUshort(sc, 0x13, 0xa012);
19903 MP_WritePhyUshort(sc, 0x14, 0x0000);
19904 MP_WritePhyUshort(sc, 0x13, 0xa014);
19905 MP_WritePhyUshort(sc, 0x14, 0x2c04);
19906 MP_WritePhyUshort(sc, 0x14, 0x2c1b);
19907 MP_WritePhyUshort(sc, 0x14, 0x2c65);
19908 MP_WritePhyUshort(sc, 0x14, 0x2d14);
19909 MP_WritePhyUshort(sc, 0x14, 0xd71e);
19910 MP_WritePhyUshort(sc, 0x14, 0x4092);
19911 MP_WritePhyUshort(sc, 0x14, 0xba04);
19912 MP_WritePhyUshort(sc, 0x14, 0x3084);
19913 MP_WritePhyUshort(sc, 0x14, 0x1d04);
19914 MP_WritePhyUshort(sc, 0x14, 0x1cdd);
19915 MP_WritePhyUshort(sc, 0x14, 0x1ce8);
19916 MP_WritePhyUshort(sc, 0x14, 0xaeff);
19917 MP_WritePhyUshort(sc, 0x14, 0xaf02);
19918 MP_WritePhyUshort(sc, 0x14, 0x8f02);
19919 MP_WritePhyUshort(sc, 0x14, 0x8eff);
19920 MP_WritePhyUshort(sc, 0x14, 0xce01);
19921 MP_WritePhyUshort(sc, 0x14, 0xe070);
19922 MP_WritePhyUshort(sc, 0x14, 0x0f00);
19923 MP_WritePhyUshort(sc, 0x14, 0xaf01);
19924 MP_WritePhyUshort(sc, 0x14, 0x8f01);
19925 MP_WritePhyUshort(sc, 0x14, 0xd712);
19926 MP_WritePhyUshort(sc, 0x14, 0x5fe8);
19927 MP_WritePhyUshort(sc, 0x14, 0xaf02);
19928 MP_WritePhyUshort(sc, 0x14, 0x8f02);
19929 MP_WritePhyUshort(sc, 0x14, 0x8e01);
19930 MP_WritePhyUshort(sc, 0x14, 0x1cf2);
19931 MP_WritePhyUshort(sc, 0x14, 0x2825);
19932 MP_WritePhyUshort(sc, 0x14, 0xd05a);
19933 MP_WritePhyUshort(sc, 0x14, 0xd19a);
19934 MP_WritePhyUshort(sc, 0x14, 0xd709);
19935 MP_WritePhyUshort(sc, 0x14, 0x608f);
19936 MP_WritePhyUshort(sc, 0x14, 0xd06b);
19937 MP_WritePhyUshort(sc, 0x14, 0xd18a);
19938 MP_WritePhyUshort(sc, 0x14, 0x2c25);
19939 MP_WritePhyUshort(sc, 0x14, 0xd0be);
19940 MP_WritePhyUshort(sc, 0x14, 0xd188);
19941 MP_WritePhyUshort(sc, 0x14, 0x2c25);
19942 MP_WritePhyUshort(sc, 0x14, 0xd708);
19943 MP_WritePhyUshort(sc, 0x14, 0x4072);
19944 MP_WritePhyUshort(sc, 0x14, 0xc104);
19945 MP_WritePhyUshort(sc, 0x14, 0x2c37);
19946 MP_WritePhyUshort(sc, 0x14, 0x4076);
19947 MP_WritePhyUshort(sc, 0x14, 0xc110);
19948 MP_WritePhyUshort(sc, 0x14, 0x2c37);
19949 MP_WritePhyUshort(sc, 0x14, 0x4071);
19950 MP_WritePhyUshort(sc, 0x14, 0xc102);
19951 MP_WritePhyUshort(sc, 0x14, 0x2c37);
19952 MP_WritePhyUshort(sc, 0x14, 0x4070);
19953 MP_WritePhyUshort(sc, 0x14, 0xc101);
19954 MP_WritePhyUshort(sc, 0x14, 0x2c37);
19955 MP_WritePhyUshort(sc, 0x14, 0x1786);
19956 MP_WritePhyUshort(sc, 0x14, 0xd709);
19957 MP_WritePhyUshort(sc, 0x14, 0x3390);
19958 MP_WritePhyUshort(sc, 0x14, 0x5c32);
19959 MP_WritePhyUshort(sc, 0x14, 0x2c47);
19960 MP_WritePhyUshort(sc, 0x14, 0x1786);
19961 MP_WritePhyUshort(sc, 0x14, 0xd708);
19962 MP_WritePhyUshort(sc, 0x14, 0x6193);
19963 MP_WritePhyUshort(sc, 0x14, 0xd709);
19964 MP_WritePhyUshort(sc, 0x14, 0x5f9d);
19965 MP_WritePhyUshort(sc, 0x14, 0x408b);
19966 MP_WritePhyUshort(sc, 0x14, 0xd71e);
19967 MP_WritePhyUshort(sc, 0x14, 0x6042);
19968 MP_WritePhyUshort(sc, 0x14, 0xb401);
19969 MP_WritePhyUshort(sc, 0x14, 0x1786);
19970 MP_WritePhyUshort(sc, 0x14, 0xd708);
19971 MP_WritePhyUshort(sc, 0x14, 0x6073);
19972 MP_WritePhyUshort(sc, 0x14, 0x5fbc);
19973 MP_WritePhyUshort(sc, 0x14, 0x2c46);
19974 MP_WritePhyUshort(sc, 0x14, 0x26fe);
19975 MP_WritePhyUshort(sc, 0x14, 0xb280);
19976 MP_WritePhyUshort(sc, 0x14, 0xa841);
19977 MP_WritePhyUshort(sc, 0x14, 0x94e0);
19978 MP_WritePhyUshort(sc, 0x14, 0x8710);
19979 MP_WritePhyUshort(sc, 0x14, 0xd709);
19980 MP_WritePhyUshort(sc, 0x14, 0x42ec);
19981 MP_WritePhyUshort(sc, 0x14, 0x606d);
19982 MP_WritePhyUshort(sc, 0x14, 0xd207);
19983 MP_WritePhyUshort(sc, 0x14, 0x2c50);
19984 MP_WritePhyUshort(sc, 0x14, 0xd203);
19985 MP_WritePhyUshort(sc, 0x14, 0x33ff);
19986 MP_WritePhyUshort(sc, 0x14, 0x5647);
19987 MP_WritePhyUshort(sc, 0x14, 0x3275);
19988 MP_WritePhyUshort(sc, 0x14, 0x7c57);
19989 MP_WritePhyUshort(sc, 0x14, 0xb240);
19990 MP_WritePhyUshort(sc, 0x14, 0xb402);
19991 MP_WritePhyUshort(sc, 0x14, 0x2647);
19992 MP_WritePhyUshort(sc, 0x14, 0x6096);
19993 MP_WritePhyUshort(sc, 0x14, 0xb240);
19994 MP_WritePhyUshort(sc, 0x14, 0xb406);
19995 MP_WritePhyUshort(sc, 0x14, 0x2647);
19996 MP_WritePhyUshort(sc, 0x14, 0x31d7);
19997 MP_WritePhyUshort(sc, 0x14, 0x7c60);
19998 MP_WritePhyUshort(sc, 0x14, 0xb240);
19999 MP_WritePhyUshort(sc, 0x14, 0xb40e);
20000 MP_WritePhyUshort(sc, 0x14, 0x2647);
20001 MP_WritePhyUshort(sc, 0x14, 0xb410);
20002 MP_WritePhyUshort(sc, 0x14, 0x8802);
20003 MP_WritePhyUshort(sc, 0x14, 0xb240);
20004 MP_WritePhyUshort(sc, 0x14, 0x940e);
20005 MP_WritePhyUshort(sc, 0x14, 0x2647);
20006 MP_WritePhyUshort(sc, 0x14, 0xba04);
20007 MP_WritePhyUshort(sc, 0x14, 0x1cdd);
20008 MP_WritePhyUshort(sc, 0x14, 0xa902);
20009 MP_WritePhyUshort(sc, 0x14, 0xd711);
20010 MP_WritePhyUshort(sc, 0x14, 0x4045);
20011 MP_WritePhyUshort(sc, 0x14, 0xa980);
20012 MP_WritePhyUshort(sc, 0x14, 0x3003);
20013 MP_WritePhyUshort(sc, 0x14, 0x5a19);
20014 MP_WritePhyUshort(sc, 0x14, 0xa540);
20015 MP_WritePhyUshort(sc, 0x14, 0xa601);
20016 MP_WritePhyUshort(sc, 0x14, 0xd710);
20017 MP_WritePhyUshort(sc, 0x14, 0x4043);
20018 MP_WritePhyUshort(sc, 0x14, 0xa910);
20019 MP_WritePhyUshort(sc, 0x14, 0xd711);
20020 MP_WritePhyUshort(sc, 0x14, 0x60a0);
20021 MP_WritePhyUshort(sc, 0x14, 0xca33);
20022 MP_WritePhyUshort(sc, 0x14, 0xcb33);
20023 MP_WritePhyUshort(sc, 0x14, 0xa941);
20024 MP_WritePhyUshort(sc, 0x14, 0x2c7b);
20025 MP_WritePhyUshort(sc, 0x14, 0xcaff);
20026 MP_WritePhyUshort(sc, 0x14, 0xcbff);
20027 MP_WritePhyUshort(sc, 0x14, 0xa921);
20028 MP_WritePhyUshort(sc, 0x14, 0xce02);
20029 MP_WritePhyUshort(sc, 0x14, 0xe070);
20030 MP_WritePhyUshort(sc, 0x14, 0x0f10);
20031 MP_WritePhyUshort(sc, 0x14, 0xaf01);
20032 MP_WritePhyUshort(sc, 0x14, 0x8f01);
20033 MP_WritePhyUshort(sc, 0x14, 0x1791);
20034 MP_WritePhyUshort(sc, 0x14, 0x8e02);
20035 MP_WritePhyUshort(sc, 0x14, 0xd710);
20036 MP_WritePhyUshort(sc, 0x14, 0x41a3);
20037 MP_WritePhyUshort(sc, 0x14, 0xa140);
20038 MP_WritePhyUshort(sc, 0x14, 0xa220);
20039 MP_WritePhyUshort(sc, 0x14, 0xce10);
20040 MP_WritePhyUshort(sc, 0x14, 0xe070);
20041 MP_WritePhyUshort(sc, 0x14, 0x0f40);
20042 MP_WritePhyUshort(sc, 0x14, 0xaf01);
20043 MP_WritePhyUshort(sc, 0x14, 0x8f01);
20044 MP_WritePhyUshort(sc, 0x14, 0x1791);
20045 MP_WritePhyUshort(sc, 0x14, 0x8e10);
20046 MP_WritePhyUshort(sc, 0x14, 0x8140);
20047 MP_WritePhyUshort(sc, 0x14, 0x8220);
20048 MP_WritePhyUshort(sc, 0x14, 0xa301);
20049 MP_WritePhyUshort(sc, 0x14, 0x17b2);
20050 MP_WritePhyUshort(sc, 0x14, 0xd710);
20051 MP_WritePhyUshort(sc, 0x14, 0x609c);
20052 MP_WritePhyUshort(sc, 0x14, 0xd71e);
20053 MP_WritePhyUshort(sc, 0x14, 0x7fa4);
20054 MP_WritePhyUshort(sc, 0x14, 0x2cdb);
20055 MP_WritePhyUshort(sc, 0x14, 0x1cf0);
20056 MP_WritePhyUshort(sc, 0x14, 0xce04);
20057 MP_WritePhyUshort(sc, 0x14, 0xe070);
20058 MP_WritePhyUshort(sc, 0x14, 0x0f20);
20059 MP_WritePhyUshort(sc, 0x14, 0xaf01);
20060 MP_WritePhyUshort(sc, 0x14, 0x8f01);
20061 MP_WritePhyUshort(sc, 0x14, 0x1791);
20062 MP_WritePhyUshort(sc, 0x14, 0x8e04);
20063 MP_WritePhyUshort(sc, 0x14, 0x6044);
20064 MP_WritePhyUshort(sc, 0x14, 0x2cdb);
20065 MP_WritePhyUshort(sc, 0x14, 0xa520);
20066 MP_WritePhyUshort(sc, 0x14, 0xd710);
20067 MP_WritePhyUshort(sc, 0x14, 0x4043);
20068 MP_WritePhyUshort(sc, 0x14, 0x2cc8);
20069 MP_WritePhyUshort(sc, 0x14, 0xe00f);
20070 MP_WritePhyUshort(sc, 0x14, 0x0501);
20071 MP_WritePhyUshort(sc, 0x14, 0x1cf6);
20072 MP_WritePhyUshort(sc, 0x14, 0xb801);
20073 MP_WritePhyUshort(sc, 0x14, 0xd71e);
20074 MP_WritePhyUshort(sc, 0x14, 0x4060);
20075 MP_WritePhyUshort(sc, 0x14, 0x7fc4);
20076 MP_WritePhyUshort(sc, 0x14, 0x2cdb);
20077 MP_WritePhyUshort(sc, 0x14, 0x1cfc);
20078 MP_WritePhyUshort(sc, 0x14, 0xe00f);
20079 MP_WritePhyUshort(sc, 0x14, 0x0502);
20080 MP_WritePhyUshort(sc, 0x14, 0x1cf6);
20081 MP_WritePhyUshort(sc, 0x14, 0xb802);
20082 MP_WritePhyUshort(sc, 0x14, 0xd71e);
20083 MP_WritePhyUshort(sc, 0x14, 0x4061);
20084 MP_WritePhyUshort(sc, 0x14, 0x7fc4);
20085 MP_WritePhyUshort(sc, 0x14, 0x2cdb);
20086 MP_WritePhyUshort(sc, 0x14, 0x1cfc);
20087 MP_WritePhyUshort(sc, 0x14, 0xe00f);
20088 MP_WritePhyUshort(sc, 0x14, 0x0504);
20089 MP_WritePhyUshort(sc, 0x14, 0xd710);
20090 MP_WritePhyUshort(sc, 0x14, 0x6099);
20091 MP_WritePhyUshort(sc, 0x14, 0xd71e);
20092 MP_WritePhyUshort(sc, 0x14, 0x7fa4);
20093 MP_WritePhyUshort(sc, 0x14, 0x2cdb);
20094 MP_WritePhyUshort(sc, 0x14, 0xc17f);
20095 MP_WritePhyUshort(sc, 0x14, 0xc200);
20096 MP_WritePhyUshort(sc, 0x14, 0xc43f);
20097 MP_WritePhyUshort(sc, 0x14, 0xcc03);
20098 MP_WritePhyUshort(sc, 0x14, 0xa701);
20099 MP_WritePhyUshort(sc, 0x14, 0xa510);
20100 MP_WritePhyUshort(sc, 0x14, 0xd710);
20101 MP_WritePhyUshort(sc, 0x14, 0x4018);
20102 MP_WritePhyUshort(sc, 0x14, 0x9910);
20103 MP_WritePhyUshort(sc, 0x14, 0x8510);
20104 MP_WritePhyUshort(sc, 0x14, 0x28a1);
20105 MP_WritePhyUshort(sc, 0x14, 0xe00f);
20106 MP_WritePhyUshort(sc, 0x14, 0x0504);
20107 MP_WritePhyUshort(sc, 0x14, 0xd710);
20108 MP_WritePhyUshort(sc, 0x14, 0x6099);
20109 MP_WritePhyUshort(sc, 0x14, 0xd71e);
20110 MP_WritePhyUshort(sc, 0x14, 0x7fa4);
20111 MP_WritePhyUshort(sc, 0x14, 0x2cdb);
20112 MP_WritePhyUshort(sc, 0x14, 0xa608);
20113 MP_WritePhyUshort(sc, 0x14, 0xc17d);
20114 MP_WritePhyUshort(sc, 0x14, 0xc200);
20115 MP_WritePhyUshort(sc, 0x14, 0xc43f);
20116 MP_WritePhyUshort(sc, 0x14, 0xcc03);
20117 MP_WritePhyUshort(sc, 0x14, 0xa701);
20118 MP_WritePhyUshort(sc, 0x14, 0xa510);
20119 MP_WritePhyUshort(sc, 0x14, 0xd710);
20120 MP_WritePhyUshort(sc, 0x14, 0x4018);
20121 MP_WritePhyUshort(sc, 0x14, 0x9910);
20122 MP_WritePhyUshort(sc, 0x14, 0x8510);
20123 MP_WritePhyUshort(sc, 0x14, 0x298e);
20124 MP_WritePhyUshort(sc, 0x14, 0x17bd);
20125 MP_WritePhyUshort(sc, 0x14, 0x2815);
20126 MP_WritePhyUshort(sc, 0x14, 0xc000);
20127 MP_WritePhyUshort(sc, 0x14, 0xc100);
20128 MP_WritePhyUshort(sc, 0x14, 0xc200);
20129 MP_WritePhyUshort(sc, 0x14, 0xc300);
20130 MP_WritePhyUshort(sc, 0x14, 0xc400);
20131 MP_WritePhyUshort(sc, 0x14, 0xc500);
20132 MP_WritePhyUshort(sc, 0x14, 0xc600);
20133 MP_WritePhyUshort(sc, 0x14, 0xc7c1);
20134 MP_WritePhyUshort(sc, 0x14, 0xc800);
20135 MP_WritePhyUshort(sc, 0x14, 0xcc00);
20136 MP_WritePhyUshort(sc, 0x14, 0x0800);
20137 MP_WritePhyUshort(sc, 0x14, 0xca0f);
20138 MP_WritePhyUshort(sc, 0x14, 0xcbff);
20139 MP_WritePhyUshort(sc, 0x14, 0xa901);
20140 MP_WritePhyUshort(sc, 0x14, 0x8902);
20141 MP_WritePhyUshort(sc, 0x14, 0xc900);
20142 MP_WritePhyUshort(sc, 0x14, 0xca00);
20143 MP_WritePhyUshort(sc, 0x14, 0xcb00);
20144 MP_WritePhyUshort(sc, 0x14, 0x0800);
20145 MP_WritePhyUshort(sc, 0x14, 0xb804);
20146 MP_WritePhyUshort(sc, 0x14, 0x0800);
20147 MP_WritePhyUshort(sc, 0x14, 0xd71e);
20148 MP_WritePhyUshort(sc, 0x14, 0x6044);
20149 MP_WritePhyUshort(sc, 0x14, 0x9804);
20150 MP_WritePhyUshort(sc, 0x14, 0x0800);
20151 MP_WritePhyUshort(sc, 0x14, 0xd710);
20152 MP_WritePhyUshort(sc, 0x14, 0x6099);
20153 MP_WritePhyUshort(sc, 0x14, 0xd71e);
20154 MP_WritePhyUshort(sc, 0x14, 0x7fa4);
20155 MP_WritePhyUshort(sc, 0x14, 0x2cdb);
20156 MP_WritePhyUshort(sc, 0x14, 0x0800);
20157 MP_WritePhyUshort(sc, 0x14, 0xa510);
20158 MP_WritePhyUshort(sc, 0x14, 0xd710);
20159 MP_WritePhyUshort(sc, 0x14, 0x6098);
20160 MP_WritePhyUshort(sc, 0x14, 0xd71e);
20161 MP_WritePhyUshort(sc, 0x14, 0x7fa4);
20162 MP_WritePhyUshort(sc, 0x14, 0x2cdb);
20163 MP_WritePhyUshort(sc, 0x14, 0x8510);
20164 MP_WritePhyUshort(sc, 0x14, 0x0800);
20165 MP_WritePhyUshort(sc, 0x14, 0xd711);
20166 MP_WritePhyUshort(sc, 0x14, 0x3003);
20167 MP_WritePhyUshort(sc, 0x14, 0x1d08);
20168 MP_WritePhyUshort(sc, 0x14, 0x2d12);
20169 MP_WritePhyUshort(sc, 0x14, 0xd710);
20170 MP_WritePhyUshort(sc, 0x14, 0x60be);
20171 MP_WritePhyUshort(sc, 0x14, 0xe060);
20172 MP_WritePhyUshort(sc, 0x14, 0x0920);
20173 MP_WritePhyUshort(sc, 0x14, 0x1cdd);
20174 MP_WritePhyUshort(sc, 0x14, 0x2c90);
20175 MP_WritePhyUshort(sc, 0x14, 0xd71e);
20176 MP_WritePhyUshort(sc, 0x14, 0x3063);
20177 MP_WritePhyUshort(sc, 0x14, 0x19b0);
20178 MP_WritePhyUshort(sc, 0x14, 0x28d5);
20179 MP_WritePhyUshort(sc, 0x14, 0x1cdd);
20180 MP_WritePhyUshort(sc, 0x14, 0x2a25);
20181 MP_WritePhyUshort(sc, 0x14, 0xa802);
20182 MP_WritePhyUshort(sc, 0x14, 0xa303);
20183 MP_WritePhyUshort(sc, 0x14, 0x843f);
20184 MP_WritePhyUshort(sc, 0x14, 0x81ff);
20185 MP_WritePhyUshort(sc, 0x14, 0x8208);
20186 MP_WritePhyUshort(sc, 0x14, 0xa201);
20187 MP_WritePhyUshort(sc, 0x14, 0xc001);
20188 MP_WritePhyUshort(sc, 0x14, 0xd710);
20189 MP_WritePhyUshort(sc, 0x14, 0x30a0);
20190 MP_WritePhyUshort(sc, 0x14, 0x0d23);
20191 MP_WritePhyUshort(sc, 0x14, 0x30a0);
20192 MP_WritePhyUshort(sc, 0x14, 0x3d1a);
20193 MP_WritePhyUshort(sc, 0x14, 0xd71e);
20194 MP_WritePhyUshort(sc, 0x14, 0x7f4c);
20195 MP_WritePhyUshort(sc, 0x14, 0x2b1e);
20196 MP_WritePhyUshort(sc, 0x14, 0xe003);
20197 MP_WritePhyUshort(sc, 0x14, 0x0202);
20198 MP_WritePhyUshort(sc, 0x14, 0xd710);
20199 MP_WritePhyUshort(sc, 0x14, 0x6090);
20200 MP_WritePhyUshort(sc, 0x14, 0xd71e);
20201 MP_WritePhyUshort(sc, 0x14, 0x7fac);
20202 MP_WritePhyUshort(sc, 0x14, 0x2b1e);
20203 MP_WritePhyUshort(sc, 0x14, 0xa20c);
20204 MP_WritePhyUshort(sc, 0x14, 0xd710);
20205 MP_WritePhyUshort(sc, 0x14, 0x6091);
20206 MP_WritePhyUshort(sc, 0x14, 0xd71e);
20207 MP_WritePhyUshort(sc, 0x14, 0x7fac);
20208 MP_WritePhyUshort(sc, 0x14, 0x2b1e);
20209 MP_WritePhyUshort(sc, 0x14, 0x820e);
20210 MP_WritePhyUshort(sc, 0x14, 0xa3e0);
20211 MP_WritePhyUshort(sc, 0x14, 0xa520);
20212 MP_WritePhyUshort(sc, 0x14, 0xd710);
20213 MP_WritePhyUshort(sc, 0x14, 0x609d);
20214 MP_WritePhyUshort(sc, 0x14, 0xd71e);
20215 MP_WritePhyUshort(sc, 0x14, 0x7fac);
20216 MP_WritePhyUshort(sc, 0x14, 0x2b1e);
20217 MP_WritePhyUshort(sc, 0x14, 0x8520);
20218 MP_WritePhyUshort(sc, 0x14, 0x6703);
20219 MP_WritePhyUshort(sc, 0x14, 0x2d3b);
20220 MP_WritePhyUshort(sc, 0x14, 0xa13e);
20221 MP_WritePhyUshort(sc, 0x14, 0xc001);
20222 MP_WritePhyUshort(sc, 0x14, 0xd710);
20223 MP_WritePhyUshort(sc, 0x14, 0x4000);
20224 MP_WritePhyUshort(sc, 0x14, 0x6046);
20225 MP_WritePhyUshort(sc, 0x14, 0x2d14);
20226 MP_WritePhyUshort(sc, 0x14, 0xa43f);
20227 MP_WritePhyUshort(sc, 0x14, 0xa101);
20228 MP_WritePhyUshort(sc, 0x14, 0xc020);
20229 MP_WritePhyUshort(sc, 0x14, 0xd710);
20230 MP_WritePhyUshort(sc, 0x14, 0x3121);
20231 MP_WritePhyUshort(sc, 0x14, 0x0d4c);
20232 MP_WritePhyUshort(sc, 0x14, 0x30c0);
20233 MP_WritePhyUshort(sc, 0x14, 0x3d14);
20234 MP_WritePhyUshort(sc, 0x14, 0xd71e);
20235 MP_WritePhyUshort(sc, 0x14, 0x7f4c);
20236 MP_WritePhyUshort(sc, 0x14, 0x2b1e);
20237 MP_WritePhyUshort(sc, 0x14, 0xa540);
20238 MP_WritePhyUshort(sc, 0x14, 0xc001);
20239 MP_WritePhyUshort(sc, 0x14, 0xd710);
20240 MP_WritePhyUshort(sc, 0x14, 0x4001);
20241 MP_WritePhyUshort(sc, 0x14, 0xe00f);
20242 MP_WritePhyUshort(sc, 0x14, 0x0501);
20243 MP_WritePhyUshort(sc, 0x14, 0x1db3);
20244 MP_WritePhyUshort(sc, 0x14, 0xc1c4);
20245 MP_WritePhyUshort(sc, 0x14, 0xa268);
20246 MP_WritePhyUshort(sc, 0x14, 0xa303);
20247 MP_WritePhyUshort(sc, 0x14, 0x8420);
20248 MP_WritePhyUshort(sc, 0x14, 0xe00f);
20249 MP_WritePhyUshort(sc, 0x14, 0x0502);
20250 MP_WritePhyUshort(sc, 0x14, 0x1db3);
20251 MP_WritePhyUshort(sc, 0x14, 0xc002);
20252 MP_WritePhyUshort(sc, 0x14, 0xd710);
20253 MP_WritePhyUshort(sc, 0x14, 0x4000);
20254 MP_WritePhyUshort(sc, 0x14, 0x8208);
20255 MP_WritePhyUshort(sc, 0x14, 0x8410);
20256 MP_WritePhyUshort(sc, 0x14, 0xa121);
20257 MP_WritePhyUshort(sc, 0x14, 0xc002);
20258 MP_WritePhyUshort(sc, 0x14, 0xd710);
20259 MP_WritePhyUshort(sc, 0x14, 0x4000);
20260 MP_WritePhyUshort(sc, 0x14, 0x8120);
20261 MP_WritePhyUshort(sc, 0x14, 0x8180);
20262 MP_WritePhyUshort(sc, 0x14, 0x1d9e);
20263 MP_WritePhyUshort(sc, 0x14, 0xa180);
20264 MP_WritePhyUshort(sc, 0x14, 0xa13a);
20265 MP_WritePhyUshort(sc, 0x14, 0x8240);
20266 MP_WritePhyUshort(sc, 0x14, 0xa430);
20267 MP_WritePhyUshort(sc, 0x14, 0xc010);
20268 MP_WritePhyUshort(sc, 0x14, 0xd710);
20269 MP_WritePhyUshort(sc, 0x14, 0x30e1);
20270 MP_WritePhyUshort(sc, 0x14, 0x0b24);
20271 MP_WritePhyUshort(sc, 0x14, 0xd71e);
20272 MP_WritePhyUshort(sc, 0x14, 0x7f8c);
20273 MP_WritePhyUshort(sc, 0x14, 0x2b1e);
20274 MP_WritePhyUshort(sc, 0x14, 0xa480);
20275 MP_WritePhyUshort(sc, 0x14, 0xa230);
20276 MP_WritePhyUshort(sc, 0x14, 0xa303);
20277 MP_WritePhyUshort(sc, 0x14, 0xc001);
20278 MP_WritePhyUshort(sc, 0x14, 0xd70c);
20279 MP_WritePhyUshort(sc, 0x14, 0x4124);
20280 MP_WritePhyUshort(sc, 0x14, 0xd710);
20281 MP_WritePhyUshort(sc, 0x14, 0x6120);
20282 MP_WritePhyUshort(sc, 0x14, 0xd711);
20283 MP_WritePhyUshort(sc, 0x14, 0x3128);
20284 MP_WritePhyUshort(sc, 0x14, 0x3d7d);
20285 MP_WritePhyUshort(sc, 0x14, 0x2d77);
20286 MP_WritePhyUshort(sc, 0x14, 0xa801);
20287 MP_WritePhyUshort(sc, 0x14, 0x2d73);
20288 MP_WritePhyUshort(sc, 0x14, 0xd710);
20289 MP_WritePhyUshort(sc, 0x14, 0x4000);
20290 MP_WritePhyUshort(sc, 0x14, 0xe018);
20291 MP_WritePhyUshort(sc, 0x14, 0x0208);
20292 MP_WritePhyUshort(sc, 0x14, 0xa1f8);
20293 MP_WritePhyUshort(sc, 0x14, 0x8480);
20294 MP_WritePhyUshort(sc, 0x14, 0xc004);
20295 MP_WritePhyUshort(sc, 0x14, 0xd710);
20296 MP_WritePhyUshort(sc, 0x14, 0x4000);
20297 MP_WritePhyUshort(sc, 0x14, 0x6046);
20298 MP_WritePhyUshort(sc, 0x14, 0x2d14);
20299 MP_WritePhyUshort(sc, 0x14, 0xa43f);
20300 MP_WritePhyUshort(sc, 0x14, 0xa105);
20301 MP_WritePhyUshort(sc, 0x14, 0x8228);
20302 MP_WritePhyUshort(sc, 0x14, 0xc004);
20303 MP_WritePhyUshort(sc, 0x14, 0xd710);
20304 MP_WritePhyUshort(sc, 0x14, 0x4000);
20305 MP_WritePhyUshort(sc, 0x14, 0x81bc);
20306 MP_WritePhyUshort(sc, 0x14, 0xa220);
20307 MP_WritePhyUshort(sc, 0x14, 0x1d9e);
20308 MP_WritePhyUshort(sc, 0x14, 0x8220);
20309 MP_WritePhyUshort(sc, 0x14, 0xa1bc);
20310 MP_WritePhyUshort(sc, 0x14, 0xc040);
20311 MP_WritePhyUshort(sc, 0x14, 0xd710);
20312 MP_WritePhyUshort(sc, 0x14, 0x30e1);
20313 MP_WritePhyUshort(sc, 0x14, 0x0b24);
20314 MP_WritePhyUshort(sc, 0x14, 0x30e1);
20315 MP_WritePhyUshort(sc, 0x14, 0x3d14);
20316 MP_WritePhyUshort(sc, 0x14, 0xd71e);
20317 MP_WritePhyUshort(sc, 0x14, 0x7f4c);
20318 MP_WritePhyUshort(sc, 0x14, 0x2b1e);
20319 MP_WritePhyUshort(sc, 0x14, 0xa802);
20320 MP_WritePhyUshort(sc, 0x14, 0xd70c);
20321 MP_WritePhyUshort(sc, 0x14, 0x4244);
20322 MP_WritePhyUshort(sc, 0x14, 0xa301);
20323 MP_WritePhyUshort(sc, 0x14, 0xc004);
20324 MP_WritePhyUshort(sc, 0x14, 0xd711);
20325 MP_WritePhyUshort(sc, 0x14, 0x3128);
20326 MP_WritePhyUshort(sc, 0x14, 0x3dac);
20327 MP_WritePhyUshort(sc, 0x14, 0xd710);
20328 MP_WritePhyUshort(sc, 0x14, 0x5f80);
20329 MP_WritePhyUshort(sc, 0x14, 0xd711);
20330 MP_WritePhyUshort(sc, 0x14, 0x3109);
20331 MP_WritePhyUshort(sc, 0x14, 0x3dae);
20332 MP_WritePhyUshort(sc, 0x14, 0x2db2);
20333 MP_WritePhyUshort(sc, 0x14, 0xa801);
20334 MP_WritePhyUshort(sc, 0x14, 0x2da1);
20335 MP_WritePhyUshort(sc, 0x14, 0xa802);
20336 MP_WritePhyUshort(sc, 0x14, 0xc004);
20337 MP_WritePhyUshort(sc, 0x14, 0xd710);
20338 MP_WritePhyUshort(sc, 0x14, 0x4000);
20339 MP_WritePhyUshort(sc, 0x14, 0x0800);
20340 MP_WritePhyUshort(sc, 0x14, 0xa510);
20341 MP_WritePhyUshort(sc, 0x14, 0xd710);
20342 MP_WritePhyUshort(sc, 0x14, 0x609a);
20343 MP_WritePhyUshort(sc, 0x14, 0xd71e);
20344 MP_WritePhyUshort(sc, 0x14, 0x7fac);
20345 MP_WritePhyUshort(sc, 0x14, 0x2b1e);
20346 MP_WritePhyUshort(sc, 0x14, 0x8510);
20347 MP_WritePhyUshort(sc, 0x14, 0x0800);
20348 MP_WritePhyUshort(sc, 0x13, 0xa01a);
20349 MP_WritePhyUshort(sc, 0x14, 0x0000);
20350 MP_WritePhyUshort(sc, 0x13, 0xa006);
20351 MP_WritePhyUshort(sc, 0x14, 0x0b3e);
20352 MP_WritePhyUshort(sc, 0x13, 0xa004);
20353 MP_WritePhyUshort(sc, 0x14, 0x0828);
20354 MP_WritePhyUshort(sc, 0x13, 0xa002);
20355 MP_WritePhyUshort(sc, 0x14, 0x06dd);
20356 MP_WritePhyUshort(sc, 0x13, 0xa000);
20357 MP_WritePhyUshort(sc, 0x14, 0xf815);
20358 MP_WritePhyUshort(sc, 0x13, 0xb820);
20359 MP_WritePhyUshort(sc, 0x14, 0x0010);
20360
20361 MP_WritePhyUshort(sc,0x1F, 0x0A43);
20362 MP_WritePhyUshort(sc, 0x13, 0x83b0);
20363 MP_WritePhyUshort(sc, 0x14, 0xaf83);
20364 MP_WritePhyUshort(sc, 0x14, 0xbcaf);
20365 MP_WritePhyUshort(sc, 0x14, 0x83c8);
20366 MP_WritePhyUshort(sc, 0x14, 0xaf83);
20367 MP_WritePhyUshort(sc, 0x14, 0xddaf);
20368 MP_WritePhyUshort(sc, 0x14, 0x83e0);
20369 MP_WritePhyUshort(sc, 0x14, 0x0204);
20370 MP_WritePhyUshort(sc, 0x14, 0xa102);
20371 MP_WritePhyUshort(sc, 0x14, 0x09b4);
20372 MP_WritePhyUshort(sc, 0x14, 0x0284);
20373 MP_WritePhyUshort(sc, 0x14, 0x62af);
20374 MP_WritePhyUshort(sc, 0x14, 0x02ec);
20375 MP_WritePhyUshort(sc, 0x14, 0xad20);
20376 MP_WritePhyUshort(sc, 0x14, 0x0302);
20377 MP_WritePhyUshort(sc, 0x14, 0x867d);
20378 MP_WritePhyUshort(sc, 0x14, 0xad21);
20379 MP_WritePhyUshort(sc, 0x14, 0x0302);
20380 MP_WritePhyUshort(sc, 0x14, 0x85ca);
20381 MP_WritePhyUshort(sc, 0x14, 0xad22);
20382 MP_WritePhyUshort(sc, 0x14, 0x0302);
20383 MP_WritePhyUshort(sc, 0x14, 0x1bce);
20384 MP_WritePhyUshort(sc, 0x14, 0xaf18);
20385 MP_WritePhyUshort(sc, 0x14, 0x11af);
20386 MP_WritePhyUshort(sc, 0x14, 0x1811);
20387 MP_WritePhyUshort(sc, 0x14, 0x0106);
20388 MP_WritePhyUshort(sc, 0x14, 0xe081);
20389 MP_WritePhyUshort(sc, 0x14, 0x48af);
20390 MP_WritePhyUshort(sc, 0x14, 0x3b1f);
20391 MP_WritePhyUshort(sc, 0x14, 0xf8f9);
20392 MP_WritePhyUshort(sc, 0x14, 0xfaef);
20393 MP_WritePhyUshort(sc, 0x14, 0x69ee);
20394 MP_WritePhyUshort(sc, 0x14, 0x8010);
20395 MP_WritePhyUshort(sc, 0x14, 0xf7d1);
20396 MP_WritePhyUshort(sc, 0x14, 0x04bf);
20397 MP_WritePhyUshort(sc, 0x14, 0x8776);
20398 MP_WritePhyUshort(sc, 0x14, 0x0241);
20399 MP_WritePhyUshort(sc, 0x14, 0x0a02);
20400 MP_WritePhyUshort(sc, 0x14, 0x8704);
20401 MP_WritePhyUshort(sc, 0x14, 0xbf87);
20402 MP_WritePhyUshort(sc, 0x14, 0x4fd7);
20403 MP_WritePhyUshort(sc, 0x14, 0xb822);
20404 MP_WritePhyUshort(sc, 0x14, 0xd00c);
20405 MP_WritePhyUshort(sc, 0x14, 0x0241);
20406 MP_WritePhyUshort(sc, 0x14, 0x03ee);
20407 MP_WritePhyUshort(sc, 0x14, 0x80cd);
20408 MP_WritePhyUshort(sc, 0x14, 0xa0ee);
20409 MP_WritePhyUshort(sc, 0x14, 0x80ce);
20410 MP_WritePhyUshort(sc, 0x14, 0x8bee);
20411 MP_WritePhyUshort(sc, 0x14, 0x80d1);
20412 MP_WritePhyUshort(sc, 0x14, 0xf5ee);
20413 MP_WritePhyUshort(sc, 0x14, 0x80d2);
20414 MP_WritePhyUshort(sc, 0x14, 0xa9ee);
20415 MP_WritePhyUshort(sc, 0x14, 0x80d3);
20416 MP_WritePhyUshort(sc, 0x14, 0x0aee);
20417 MP_WritePhyUshort(sc, 0x14, 0x80f0);
20418 MP_WritePhyUshort(sc, 0x14, 0x10ee);
20419 MP_WritePhyUshort(sc, 0x14, 0x80f3);
20420 MP_WritePhyUshort(sc, 0x14, 0x8fee);
20421 MP_WritePhyUshort(sc, 0x14, 0x8101);
20422 MP_WritePhyUshort(sc, 0x14, 0x1eee);
20423 MP_WritePhyUshort(sc, 0x14, 0x810b);
20424 MP_WritePhyUshort(sc, 0x14, 0x4aee);
20425 MP_WritePhyUshort(sc, 0x14, 0x810c);
20426 MP_WritePhyUshort(sc, 0x14, 0x7cee);
20427 MP_WritePhyUshort(sc, 0x14, 0x8112);
20428 MP_WritePhyUshort(sc, 0x14, 0x7fd1);
20429 MP_WritePhyUshort(sc, 0x14, 0x0002);
20430 MP_WritePhyUshort(sc, 0x14, 0x10e3);
20431 MP_WritePhyUshort(sc, 0x14, 0xee80);
20432 MP_WritePhyUshort(sc, 0x14, 0x8892);
20433 MP_WritePhyUshort(sc, 0x14, 0xee80);
20434 MP_WritePhyUshort(sc, 0x14, 0x8922);
20435 MP_WritePhyUshort(sc, 0x14, 0xee80);
20436 MP_WritePhyUshort(sc, 0x14, 0x9a80);
20437 MP_WritePhyUshort(sc, 0x14, 0xee80);
20438 MP_WritePhyUshort(sc, 0x14, 0x9b22);
20439 MP_WritePhyUshort(sc, 0x14, 0xee80);
20440 MP_WritePhyUshort(sc, 0x14, 0x9ca7);
20441 MP_WritePhyUshort(sc, 0x14, 0xee80);
20442 MP_WritePhyUshort(sc, 0x14, 0xa010);
20443 MP_WritePhyUshort(sc, 0x14, 0xee80);
20444 MP_WritePhyUshort(sc, 0x14, 0xa5a7);
20445 MP_WritePhyUshort(sc, 0x14, 0xd200);
20446 MP_WritePhyUshort(sc, 0x14, 0x020e);
20447 MP_WritePhyUshort(sc, 0x14, 0x4b02);
20448 MP_WritePhyUshort(sc, 0x14, 0x85c1);
20449 MP_WritePhyUshort(sc, 0x14, 0xef96);
20450 MP_WritePhyUshort(sc, 0x14, 0xfefd);
20451 MP_WritePhyUshort(sc, 0x14, 0xfc04);
20452 MP_WritePhyUshort(sc, 0x14, 0x0284);
20453 MP_WritePhyUshort(sc, 0x14, 0x7b02);
20454 MP_WritePhyUshort(sc, 0x14, 0x84b4);
20455 MP_WritePhyUshort(sc, 0x14, 0x020c);
20456 MP_WritePhyUshort(sc, 0x14, 0x9202);
20457 MP_WritePhyUshort(sc, 0x14, 0x0cab);
20458 MP_WritePhyUshort(sc, 0x14, 0x020c);
20459 MP_WritePhyUshort(sc, 0x14, 0xd602);
20460 MP_WritePhyUshort(sc, 0x14, 0x0cef);
20461 MP_WritePhyUshort(sc, 0x14, 0x020d);
20462 MP_WritePhyUshort(sc, 0x14, 0x1a02);
20463 MP_WritePhyUshort(sc, 0x14, 0x0c24);
20464 MP_WritePhyUshort(sc, 0x14, 0x04f8);
20465 MP_WritePhyUshort(sc, 0x14, 0xfaef);
20466 MP_WritePhyUshort(sc, 0x14, 0x69e1);
20467 MP_WritePhyUshort(sc, 0x14, 0x8234);
20468 MP_WritePhyUshort(sc, 0x14, 0xac29);
20469 MP_WritePhyUshort(sc, 0x14, 0x1ae0);
20470 MP_WritePhyUshort(sc, 0x14, 0x8229);
20471 MP_WritePhyUshort(sc, 0x14, 0xac21);
20472 MP_WritePhyUshort(sc, 0x14, 0x02ae);
20473 MP_WritePhyUshort(sc, 0x14, 0x2202);
20474 MP_WritePhyUshort(sc, 0x14, 0x1085);
20475 MP_WritePhyUshort(sc, 0x14, 0xf621);
20476 MP_WritePhyUshort(sc, 0x14, 0xe482);
20477 MP_WritePhyUshort(sc, 0x14, 0x29d1);
20478 MP_WritePhyUshort(sc, 0x14, 0x01bf);
20479 MP_WritePhyUshort(sc, 0x14, 0x4364);
20480 MP_WritePhyUshort(sc, 0x14, 0x0241);
20481 MP_WritePhyUshort(sc, 0x14, 0x0aae);
20482 MP_WritePhyUshort(sc, 0x14, 0x1002);
20483 MP_WritePhyUshort(sc, 0x14, 0x127a);
20484 MP_WritePhyUshort(sc, 0x14, 0xf629);
20485 MP_WritePhyUshort(sc, 0x14, 0xe582);
20486 MP_WritePhyUshort(sc, 0x14, 0x34e0);
20487 MP_WritePhyUshort(sc, 0x14, 0x8229);
20488 MP_WritePhyUshort(sc, 0x14, 0xf621);
20489 MP_WritePhyUshort(sc, 0x14, 0xe482);
20490 MP_WritePhyUshort(sc, 0x14, 0x29ef);
20491 MP_WritePhyUshort(sc, 0x14, 0x96fe);
20492 MP_WritePhyUshort(sc, 0x14, 0xfc04);
20493 MP_WritePhyUshort(sc, 0x14, 0xf8e1);
20494 MP_WritePhyUshort(sc, 0x14, 0x8234);
20495 MP_WritePhyUshort(sc, 0x14, 0xac2a);
20496 MP_WritePhyUshort(sc, 0x14, 0x18e0);
20497 MP_WritePhyUshort(sc, 0x14, 0x8229);
20498 MP_WritePhyUshort(sc, 0x14, 0xac22);
20499 MP_WritePhyUshort(sc, 0x14, 0x02ae);
20500 MP_WritePhyUshort(sc, 0x14, 0x2602);
20501 MP_WritePhyUshort(sc, 0x14, 0x84f9);
20502 MP_WritePhyUshort(sc, 0x14, 0x0285);
20503 MP_WritePhyUshort(sc, 0x14, 0x66d1);
20504 MP_WritePhyUshort(sc, 0x14, 0x01bf);
20505 MP_WritePhyUshort(sc, 0x14, 0x4367);
20506 MP_WritePhyUshort(sc, 0x14, 0x0241);
20507 MP_WritePhyUshort(sc, 0x14, 0x0aae);
20508 MP_WritePhyUshort(sc, 0x14, 0x0e02);
20509 MP_WritePhyUshort(sc, 0x14, 0x84eb);
20510 MP_WritePhyUshort(sc, 0x14, 0x0285);
20511 MP_WritePhyUshort(sc, 0x14, 0xaae1);
20512 MP_WritePhyUshort(sc, 0x14, 0x8234);
20513 MP_WritePhyUshort(sc, 0x14, 0xf62a);
20514 MP_WritePhyUshort(sc, 0x14, 0xe582);
20515 MP_WritePhyUshort(sc, 0x14, 0x34e0);
20516 MP_WritePhyUshort(sc, 0x14, 0x8229);
20517 MP_WritePhyUshort(sc, 0x14, 0xf622);
20518 MP_WritePhyUshort(sc, 0x14, 0xe482);
20519 MP_WritePhyUshort(sc, 0x14, 0x29fc);
20520 MP_WritePhyUshort(sc, 0x14, 0x04f9);
20521 MP_WritePhyUshort(sc, 0x14, 0xe280);
20522 MP_WritePhyUshort(sc, 0x14, 0x11ad);
20523 MP_WritePhyUshort(sc, 0x14, 0x3105);
20524 MP_WritePhyUshort(sc, 0x14, 0xd200);
20525 MP_WritePhyUshort(sc, 0x14, 0x020e);
20526 MP_WritePhyUshort(sc, 0x14, 0x4bfd);
20527 MP_WritePhyUshort(sc, 0x14, 0x04f8);
20528 MP_WritePhyUshort(sc, 0x14, 0xf9fa);
20529 MP_WritePhyUshort(sc, 0x14, 0xef69);
20530 MP_WritePhyUshort(sc, 0x14, 0xe080);
20531 MP_WritePhyUshort(sc, 0x14, 0x11ad);
20532 MP_WritePhyUshort(sc, 0x14, 0x215c);
20533 MP_WritePhyUshort(sc, 0x14, 0xbf42);
20534 MP_WritePhyUshort(sc, 0x14, 0x5002);
20535 MP_WritePhyUshort(sc, 0x14, 0x4148);
20536 MP_WritePhyUshort(sc, 0x14, 0xac28);
20537 MP_WritePhyUshort(sc, 0x14, 0x1bbf);
20538 MP_WritePhyUshort(sc, 0x14, 0x4253);
20539 MP_WritePhyUshort(sc, 0x14, 0x0241);
20540 MP_WritePhyUshort(sc, 0x14, 0x48ac);
20541 MP_WritePhyUshort(sc, 0x14, 0x2812);
20542 MP_WritePhyUshort(sc, 0x14, 0xbf42);
20543 MP_WritePhyUshort(sc, 0x14, 0x5902);
20544 MP_WritePhyUshort(sc, 0x14, 0x4148);
20545 MP_WritePhyUshort(sc, 0x14, 0xac28);
20546 MP_WritePhyUshort(sc, 0x14, 0x04d3);
20547 MP_WritePhyUshort(sc, 0x14, 0x00ae);
20548 MP_WritePhyUshort(sc, 0x14, 0x07d3);
20549 MP_WritePhyUshort(sc, 0x14, 0x06af);
20550 MP_WritePhyUshort(sc, 0x14, 0x8557);
20551 MP_WritePhyUshort(sc, 0x14, 0xd303);
20552 MP_WritePhyUshort(sc, 0x14, 0xe080);
20553 MP_WritePhyUshort(sc, 0x14, 0x11ad);
20554 MP_WritePhyUshort(sc, 0x14, 0x2625);
20555 MP_WritePhyUshort(sc, 0x14, 0xbf43);
20556 MP_WritePhyUshort(sc, 0x14, 0xeb02);
20557 MP_WritePhyUshort(sc, 0x14, 0x4148);
20558 MP_WritePhyUshort(sc, 0x14, 0xe280);
20559 MP_WritePhyUshort(sc, 0x14, 0x730d);
20560 MP_WritePhyUshort(sc, 0x14, 0x21f6);
20561 MP_WritePhyUshort(sc, 0x14, 0x370d);
20562 MP_WritePhyUshort(sc, 0x14, 0x11f6);
20563 MP_WritePhyUshort(sc, 0x14, 0x2f1b);
20564 MP_WritePhyUshort(sc, 0x14, 0x21aa);
20565 MP_WritePhyUshort(sc, 0x14, 0x02ae);
20566 MP_WritePhyUshort(sc, 0x14, 0x10e2);
20567 MP_WritePhyUshort(sc, 0x14, 0x8074);
20568 MP_WritePhyUshort(sc, 0x14, 0x0d21);
20569 MP_WritePhyUshort(sc, 0x14, 0xf637);
20570 MP_WritePhyUshort(sc, 0x14, 0x1b21);
20571 MP_WritePhyUshort(sc, 0x14, 0xaa03);
20572 MP_WritePhyUshort(sc, 0x14, 0x13ae);
20573 MP_WritePhyUshort(sc, 0x14, 0x022b);
20574 MP_WritePhyUshort(sc, 0x14, 0x0202);
20575 MP_WritePhyUshort(sc, 0x14, 0x0e36);
20576 MP_WritePhyUshort(sc, 0x14, 0x020e);
20577 MP_WritePhyUshort(sc, 0x14, 0x4b02);
20578 MP_WritePhyUshort(sc, 0x14, 0x0f91);
20579 MP_WritePhyUshort(sc, 0x14, 0xef96);
20580 MP_WritePhyUshort(sc, 0x14, 0xfefd);
20581 MP_WritePhyUshort(sc, 0x14, 0xfc04);
20582 MP_WritePhyUshort(sc, 0x14, 0xf8f9);
20583 MP_WritePhyUshort(sc, 0x14, 0xfaef);
20584 MP_WritePhyUshort(sc, 0x14, 0x69e0);
20585 MP_WritePhyUshort(sc, 0x14, 0x8012);
20586 MP_WritePhyUshort(sc, 0x14, 0xad27);
20587 MP_WritePhyUshort(sc, 0x14, 0x33bf);
20588 MP_WritePhyUshort(sc, 0x14, 0x4250);
20589 MP_WritePhyUshort(sc, 0x14, 0x0241);
20590 MP_WritePhyUshort(sc, 0x14, 0x48ac);
20591 MP_WritePhyUshort(sc, 0x14, 0x2809);
20592 MP_WritePhyUshort(sc, 0x14, 0xbf42);
20593 MP_WritePhyUshort(sc, 0x14, 0x5302);
20594 MP_WritePhyUshort(sc, 0x14, 0x4148);
20595 MP_WritePhyUshort(sc, 0x14, 0xad28);
20596 MP_WritePhyUshort(sc, 0x14, 0x21bf);
20597 MP_WritePhyUshort(sc, 0x14, 0x43eb);
20598 MP_WritePhyUshort(sc, 0x14, 0x0241);
20599 MP_WritePhyUshort(sc, 0x14, 0x48e3);
20600 MP_WritePhyUshort(sc, 0x14, 0x87ff);
20601 MP_WritePhyUshort(sc, 0x14, 0xd200);
20602 MP_WritePhyUshort(sc, 0x14, 0x1b45);
20603 MP_WritePhyUshort(sc, 0x14, 0xac27);
20604 MP_WritePhyUshort(sc, 0x14, 0x11e1);
20605 MP_WritePhyUshort(sc, 0x14, 0x87fe);
20606 MP_WritePhyUshort(sc, 0x14, 0xbf87);
20607 MP_WritePhyUshort(sc, 0x14, 0x6702);
20608 MP_WritePhyUshort(sc, 0x14, 0x410a);
20609 MP_WritePhyUshort(sc, 0x14, 0x0d11);
20610 MP_WritePhyUshort(sc, 0x14, 0xbf87);
20611 MP_WritePhyUshort(sc, 0x14, 0x6a02);
20612 MP_WritePhyUshort(sc, 0x14, 0x410a);
20613 MP_WritePhyUshort(sc, 0x14, 0xef96);
20614 MP_WritePhyUshort(sc, 0x14, 0xfefd);
20615 MP_WritePhyUshort(sc, 0x14, 0xfc04);
20616 MP_WritePhyUshort(sc, 0x14, 0xf8fa);
20617 MP_WritePhyUshort(sc, 0x14, 0xef69);
20618 MP_WritePhyUshort(sc, 0x14, 0xd100);
20619 MP_WritePhyUshort(sc, 0x14, 0xbf87);
20620 MP_WritePhyUshort(sc, 0x14, 0x6702);
20621 MP_WritePhyUshort(sc, 0x14, 0x410a);
20622 MP_WritePhyUshort(sc, 0x14, 0xbf87);
20623 MP_WritePhyUshort(sc, 0x14, 0x6a02);
20624 MP_WritePhyUshort(sc, 0x14, 0x410a);
20625 MP_WritePhyUshort(sc, 0x14, 0xef96);
20626 MP_WritePhyUshort(sc, 0x14, 0xfefc);
20627 MP_WritePhyUshort(sc, 0x14, 0x04ee);
20628 MP_WritePhyUshort(sc, 0x14, 0x87ff);
20629 MP_WritePhyUshort(sc, 0x14, 0x46ee);
20630 MP_WritePhyUshort(sc, 0x14, 0x87fe);
20631 MP_WritePhyUshort(sc, 0x14, 0x0104);
20632 MP_WritePhyUshort(sc, 0x14, 0xf8fa);
20633 MP_WritePhyUshort(sc, 0x14, 0xef69);
20634 MP_WritePhyUshort(sc, 0x14, 0xe082);
20635 MP_WritePhyUshort(sc, 0x14, 0x46a0);
20636 MP_WritePhyUshort(sc, 0x14, 0x0005);
20637 MP_WritePhyUshort(sc, 0x14, 0x0285);
20638 MP_WritePhyUshort(sc, 0x14, 0xecae);
20639 MP_WritePhyUshort(sc, 0x14, 0x0ea0);
20640 MP_WritePhyUshort(sc, 0x14, 0x0105);
20641 MP_WritePhyUshort(sc, 0x14, 0x021a);
20642 MP_WritePhyUshort(sc, 0x14, 0x68ae);
20643 MP_WritePhyUshort(sc, 0x14, 0x06a0);
20644 MP_WritePhyUshort(sc, 0x14, 0x0203);
20645 MP_WritePhyUshort(sc, 0x14, 0x021a);
20646 MP_WritePhyUshort(sc, 0x14, 0xf4ef);
20647 MP_WritePhyUshort(sc, 0x14, 0x96fe);
20648 MP_WritePhyUshort(sc, 0x14, 0xfc04);
20649 MP_WritePhyUshort(sc, 0x14, 0xf8f9);
20650 MP_WritePhyUshort(sc, 0x14, 0xfaef);
20651 MP_WritePhyUshort(sc, 0x14, 0x69e0);
20652 MP_WritePhyUshort(sc, 0x14, 0x822e);
20653 MP_WritePhyUshort(sc, 0x14, 0xf621);
20654 MP_WritePhyUshort(sc, 0x14, 0xe482);
20655 MP_WritePhyUshort(sc, 0x14, 0x2ee0);
20656 MP_WritePhyUshort(sc, 0x14, 0x8010);
20657 MP_WritePhyUshort(sc, 0x14, 0xac22);
20658 MP_WritePhyUshort(sc, 0x14, 0x02ae);
20659 MP_WritePhyUshort(sc, 0x14, 0x76e0);
20660 MP_WritePhyUshort(sc, 0x14, 0x822c);
20661 MP_WritePhyUshort(sc, 0x14, 0xf721);
20662 MP_WritePhyUshort(sc, 0x14, 0xe482);
20663 MP_WritePhyUshort(sc, 0x14, 0x2cbf);
20664 MP_WritePhyUshort(sc, 0x14, 0x41a5);
20665 MP_WritePhyUshort(sc, 0x14, 0x0241);
20666 MP_WritePhyUshort(sc, 0x14, 0x48ef);
20667 MP_WritePhyUshort(sc, 0x14, 0x21bf);
20668 MP_WritePhyUshort(sc, 0x14, 0x41a8);
20669 MP_WritePhyUshort(sc, 0x14, 0x0241);
20670 MP_WritePhyUshort(sc, 0x14, 0x480c);
20671 MP_WritePhyUshort(sc, 0x14, 0x111e);
20672 MP_WritePhyUshort(sc, 0x14, 0x21bf);
20673 MP_WritePhyUshort(sc, 0x14, 0x41ab);
20674 MP_WritePhyUshort(sc, 0x14, 0x0241);
20675 MP_WritePhyUshort(sc, 0x14, 0x480c);
20676 MP_WritePhyUshort(sc, 0x14, 0x121e);
20677 MP_WritePhyUshort(sc, 0x14, 0x21e6);
20678 MP_WritePhyUshort(sc, 0x14, 0x8248);
20679 MP_WritePhyUshort(sc, 0x14, 0xa200);
20680 MP_WritePhyUshort(sc, 0x14, 0x0ae1);
20681 MP_WritePhyUshort(sc, 0x14, 0x822c);
20682 MP_WritePhyUshort(sc, 0x14, 0xf629);
20683 MP_WritePhyUshort(sc, 0x14, 0xe582);
20684 MP_WritePhyUshort(sc, 0x14, 0x2cae);
20685 MP_WritePhyUshort(sc, 0x14, 0x42e0);
20686 MP_WritePhyUshort(sc, 0x14, 0x8249);
20687 MP_WritePhyUshort(sc, 0x14, 0xf721);
20688 MP_WritePhyUshort(sc, 0x14, 0xe482);
20689 MP_WritePhyUshort(sc, 0x14, 0x4902);
20690 MP_WritePhyUshort(sc, 0x14, 0x4520);
20691 MP_WritePhyUshort(sc, 0x14, 0xbf41);
20692 MP_WritePhyUshort(sc, 0x14, 0xb702);
20693 MP_WritePhyUshort(sc, 0x14, 0x4148);
20694 MP_WritePhyUshort(sc, 0x14, 0xef21);
20695 MP_WritePhyUshort(sc, 0x14, 0xbf41);
20696 MP_WritePhyUshort(sc, 0x14, 0xae02);
20697 MP_WritePhyUshort(sc, 0x14, 0x4148);
20698 MP_WritePhyUshort(sc, 0x14, 0x0c12);
20699 MP_WritePhyUshort(sc, 0x14, 0x1e21);
20700 MP_WritePhyUshort(sc, 0x14, 0xbf41);
20701 MP_WritePhyUshort(sc, 0x14, 0xb102);
20702 MP_WritePhyUshort(sc, 0x14, 0x4148);
20703 MP_WritePhyUshort(sc, 0x14, 0x0c13);
20704 MP_WritePhyUshort(sc, 0x14, 0x1e21);
20705 MP_WritePhyUshort(sc, 0x14, 0xbf41);
20706 MP_WritePhyUshort(sc, 0x14, 0xba02);
20707 MP_WritePhyUshort(sc, 0x14, 0x4148);
20708 MP_WritePhyUshort(sc, 0x14, 0x0c14);
20709 MP_WritePhyUshort(sc, 0x14, 0x1e21);
20710 MP_WritePhyUshort(sc, 0x14, 0xbf43);
20711 MP_WritePhyUshort(sc, 0x14, 0x4602);
20712 MP_WritePhyUshort(sc, 0x14, 0x4148);
20713 MP_WritePhyUshort(sc, 0x14, 0x0c16);
20714 MP_WritePhyUshort(sc, 0x14, 0x1e21);
20715 MP_WritePhyUshort(sc, 0x14, 0xe682);
20716 MP_WritePhyUshort(sc, 0x14, 0x47ee);
20717 MP_WritePhyUshort(sc, 0x14, 0x8246);
20718 MP_WritePhyUshort(sc, 0x14, 0x01ef);
20719 MP_WritePhyUshort(sc, 0x14, 0x96fe);
20720 MP_WritePhyUshort(sc, 0x14, 0xfdfc);
20721 MP_WritePhyUshort(sc, 0x14, 0x04f8);
20722 MP_WritePhyUshort(sc, 0x14, 0xfaef);
20723 MP_WritePhyUshort(sc, 0x14, 0x69e0);
20724 MP_WritePhyUshort(sc, 0x14, 0x824b);
20725 MP_WritePhyUshort(sc, 0x14, 0xa000);
20726 MP_WritePhyUshort(sc, 0x14, 0x0502);
20727 MP_WritePhyUshort(sc, 0x14, 0x8697);
20728 MP_WritePhyUshort(sc, 0x14, 0xae06);
20729 MP_WritePhyUshort(sc, 0x14, 0xa001);
20730 MP_WritePhyUshort(sc, 0x14, 0x0302);
20731 MP_WritePhyUshort(sc, 0x14, 0x1937);
20732 MP_WritePhyUshort(sc, 0x14, 0xef96);
20733 MP_WritePhyUshort(sc, 0x14, 0xfefc);
20734 MP_WritePhyUshort(sc, 0x14, 0x04f8);
20735 MP_WritePhyUshort(sc, 0x14, 0xfaef);
20736 MP_WritePhyUshort(sc, 0x14, 0x69e0);
20737 MP_WritePhyUshort(sc, 0x14, 0x822e);
20738 MP_WritePhyUshort(sc, 0x14, 0xf620);
20739 MP_WritePhyUshort(sc, 0x14, 0xe482);
20740 MP_WritePhyUshort(sc, 0x14, 0x2ee0);
20741 MP_WritePhyUshort(sc, 0x14, 0x8010);
20742 MP_WritePhyUshort(sc, 0x14, 0xac21);
20743 MP_WritePhyUshort(sc, 0x14, 0x02ae);
20744 MP_WritePhyUshort(sc, 0x14, 0x54e0);
20745 MP_WritePhyUshort(sc, 0x14, 0x822c);
20746 MP_WritePhyUshort(sc, 0x14, 0xf720);
20747 MP_WritePhyUshort(sc, 0x14, 0xe482);
20748 MP_WritePhyUshort(sc, 0x14, 0x2cbf);
20749 MP_WritePhyUshort(sc, 0x14, 0x4175);
20750 MP_WritePhyUshort(sc, 0x14, 0x0241);
20751 MP_WritePhyUshort(sc, 0x14, 0x48ac);
20752 MP_WritePhyUshort(sc, 0x14, 0x2822);
20753 MP_WritePhyUshort(sc, 0x14, 0xbf41);
20754 MP_WritePhyUshort(sc, 0x14, 0x9f02);
20755 MP_WritePhyUshort(sc, 0x14, 0x4148);
20756 MP_WritePhyUshort(sc, 0x14, 0xe582);
20757 MP_WritePhyUshort(sc, 0x14, 0x4cac);
20758 MP_WritePhyUshort(sc, 0x14, 0x2820);
20759 MP_WritePhyUshort(sc, 0x14, 0xd103);
20760 MP_WritePhyUshort(sc, 0x14, 0xbf41);
20761 MP_WritePhyUshort(sc, 0x14, 0x9902);
20762 MP_WritePhyUshort(sc, 0x14, 0x410a);
20763 MP_WritePhyUshort(sc, 0x14, 0xee82);
20764 MP_WritePhyUshort(sc, 0x14, 0x4b00);
20765 MP_WritePhyUshort(sc, 0x14, 0xe182);
20766 MP_WritePhyUshort(sc, 0x14, 0x2cf6);
20767 MP_WritePhyUshort(sc, 0x14, 0x28e5);
20768 MP_WritePhyUshort(sc, 0x14, 0x822c);
20769 MP_WritePhyUshort(sc, 0x14, 0xae21);
20770 MP_WritePhyUshort(sc, 0x14, 0xd104);
20771 MP_WritePhyUshort(sc, 0x14, 0xbf41);
20772 MP_WritePhyUshort(sc, 0x14, 0x9902);
20773 MP_WritePhyUshort(sc, 0x14, 0x410a);
20774 MP_WritePhyUshort(sc, 0x14, 0xae08);
20775 MP_WritePhyUshort(sc, 0x14, 0xd105);
20776 MP_WritePhyUshort(sc, 0x14, 0xbf41);
20777 MP_WritePhyUshort(sc, 0x14, 0x9902);
20778 MP_WritePhyUshort(sc, 0x14, 0x410a);
20779 MP_WritePhyUshort(sc, 0x14, 0xe082);
20780 MP_WritePhyUshort(sc, 0x14, 0x49f7);
20781 MP_WritePhyUshort(sc, 0x14, 0x20e4);
20782 MP_WritePhyUshort(sc, 0x14, 0x8249);
20783 MP_WritePhyUshort(sc, 0x14, 0x0245);
20784 MP_WritePhyUshort(sc, 0x14, 0x20ee);
20785 MP_WritePhyUshort(sc, 0x14, 0x824b);
20786 MP_WritePhyUshort(sc, 0x14, 0x01ef);
20787 MP_WritePhyUshort(sc, 0x14, 0x96fe);
20788 MP_WritePhyUshort(sc, 0x14, 0xfc04);
20789 MP_WritePhyUshort(sc, 0x14, 0xf8f9);
20790 MP_WritePhyUshort(sc, 0x14, 0xface);
20791 MP_WritePhyUshort(sc, 0x14, 0xfaef);
20792 MP_WritePhyUshort(sc, 0x14, 0x69fb);
20793 MP_WritePhyUshort(sc, 0x14, 0xbf87);
20794 MP_WritePhyUshort(sc, 0x14, 0x2fd7);
20795 MP_WritePhyUshort(sc, 0x14, 0x0020);
20796 MP_WritePhyUshort(sc, 0x14, 0xd819);
20797 MP_WritePhyUshort(sc, 0x14, 0xd919);
20798 MP_WritePhyUshort(sc, 0x14, 0xda19);
20799 MP_WritePhyUshort(sc, 0x14, 0xdb19);
20800 MP_WritePhyUshort(sc, 0x14, 0x07ef);
20801 MP_WritePhyUshort(sc, 0x14, 0x9502);
20802 MP_WritePhyUshort(sc, 0x14, 0x410a);
20803 MP_WritePhyUshort(sc, 0x14, 0x073f);
20804 MP_WritePhyUshort(sc, 0x14, 0x0004);
20805 MP_WritePhyUshort(sc, 0x14, 0x9fec);
20806 MP_WritePhyUshort(sc, 0x14, 0xffef);
20807 MP_WritePhyUshort(sc, 0x14, 0x96fe);
20808 MP_WritePhyUshort(sc, 0x14, 0xc6fe);
20809 MP_WritePhyUshort(sc, 0x14, 0xfdfc);
20810 MP_WritePhyUshort(sc, 0x14, 0x0400);
20811 MP_WritePhyUshort(sc, 0x14, 0x0144);
20812 MP_WritePhyUshort(sc, 0x14, 0x0000);
20813 MP_WritePhyUshort(sc, 0x14, 0x0343);
20814 MP_WritePhyUshort(sc, 0x14, 0xee00);
20815 MP_WritePhyUshort(sc, 0x14, 0x0087);
20816 MP_WritePhyUshort(sc, 0x14, 0x5b00);
20817 MP_WritePhyUshort(sc, 0x14, 0x0141);
20818 MP_WritePhyUshort(sc, 0x14, 0xe100);
20819 MP_WritePhyUshort(sc, 0x14, 0x0387);
20820 MP_WritePhyUshort(sc, 0x14, 0x5e00);
20821 MP_WritePhyUshort(sc, 0x14, 0x0987);
20822 MP_WritePhyUshort(sc, 0x14, 0x6100);
20823 MP_WritePhyUshort(sc, 0x14, 0x0987);
20824 MP_WritePhyUshort(sc, 0x14, 0x6400);
20825 MP_WritePhyUshort(sc, 0x14, 0x0087);
20826 MP_WritePhyUshort(sc, 0x14, 0x6da4);
20827 MP_WritePhyUshort(sc, 0x14, 0x00b8);
20828 MP_WritePhyUshort(sc, 0x14, 0x20c4);
20829 MP_WritePhyUshort(sc, 0x14, 0x1600);
20830 MP_WritePhyUshort(sc, 0x14, 0x000f);
20831 MP_WritePhyUshort(sc, 0x14, 0xf800);
20832 MP_WritePhyUshort(sc, 0x14, 0x7000);
20833 MP_WritePhyUshort(sc, 0x14, 0xb82e);
20834 MP_WritePhyUshort(sc, 0x14, 0x98a5);
20835 MP_WritePhyUshort(sc, 0x14, 0x8ab6);
20836 MP_WritePhyUshort(sc, 0x14, 0xa83e);
20837 MP_WritePhyUshort(sc, 0x14, 0x50a8);
20838 MP_WritePhyUshort(sc, 0x14, 0x3e33);
20839 MP_WritePhyUshort(sc, 0x14, 0xbcc6);
20840 MP_WritePhyUshort(sc, 0x14, 0x22bc);
20841 MP_WritePhyUshort(sc, 0x14, 0xc6aa);
20842 MP_WritePhyUshort(sc, 0x14, 0xa442);
20843 MP_WritePhyUshort(sc, 0x14, 0xffc4);
20844 MP_WritePhyUshort(sc, 0x14, 0x0800);
20845 MP_WritePhyUshort(sc, 0x14, 0xc416);
20846 MP_WritePhyUshort(sc, 0x14, 0xa8bc);
20847 MP_WritePhyUshort(sc, 0x14, 0xc000);
20848 MP_WritePhyUshort(sc, 0x13, 0xb818);
20849 MP_WritePhyUshort(sc, 0x14, 0x02e3);
20850 MP_WritePhyUshort(sc, 0x13, 0xb81a);
20851 MP_WritePhyUshort(sc, 0x14, 0x17ff);
20852 MP_WritePhyUshort(sc, 0x13, 0xb81e);
20853 MP_WritePhyUshort(sc, 0x14, 0x3b1c);
20854 MP_WritePhyUshort(sc, 0x13, 0xb820);
20855 MP_WritePhyUshort(sc, 0x14, 0x021b);
20856 MP_WritePhyUshort(sc, 0x1f, 0x0000);
20857
20858 MP_WritePhyUshort(sc,0x1F, 0x0A43);
20859 MP_WritePhyUshort(sc,0x13, 0x0000);
20860 MP_WritePhyUshort(sc,0x14, 0x0000);
20861 MP_WritePhyUshort(sc,0x1f, 0x0B82);
20862 PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
20863 PhyRegValue &= ~(BIT_0);
20864 MP_WritePhyUshort(sc,0x17, PhyRegValue);
20865 MP_WritePhyUshort(sc,0x1f, 0x0A43);
20866 MP_WritePhyUshort(sc,0x13, 0x8146);
20867 MP_WritePhyUshort(sc,0x14, 0x0000);
20868
20869 MP_WritePhyUshort(sc,0x1f, 0x0B82);
20870 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
20871 PhyRegValue &= ~(BIT_4);
20872 MP_WritePhyUshort(sc,0x10, PhyRegValue);
20873
20874 MP_WritePhyUshort(sc, 0x1F, 0x0A44);
20875 SetEthPhyBit(sc, 0x11, (BIT_3 | BIT_2));
20876 MP_WritePhyUshort(sc, 0x1F, 0x0000);
20877
20878
20879 MP_WritePhyUshort(sc, 0x1F, 0x0BCC);
20880 ClearEthPhyBit(sc, 0x14, BIT_8);
20881 MP_WritePhyUshort(sc, 0x1F, 0x0A44);
20882 SetEthPhyBit(sc, 0x11, BIT_7);
20883 SetEthPhyBit(sc, 0x11, BIT_6);
20884 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
20885 MP_WritePhyUshort(sc, 0x13, 0x8084);
20886 ClearEthPhyBit(sc, 0x14, (BIT_14 | BIT_13));
20887 SetEthPhyBit(sc, 0x10, BIT_12);
20888 SetEthPhyBit(sc, 0x10, BIT_1);
20889 SetEthPhyBit(sc, 0x10, BIT_0);
20890 MP_WritePhyUshort(sc, 0x1F, 0x0000);
20891
20892 MP_WritePhyUshort(sc, 0x1F, 0x0A4B);
20893 SetEthPhyBit(sc, 0x11, BIT_2);
20894 MP_WritePhyUshort(sc, 0x1F, 0x0000);
20895
20896 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
20897 MP_WritePhyUshort(sc, 0x13, 0x8012);
20898 SetEthPhyBit(sc, 0x14, BIT_15);
20899 MP_WritePhyUshort(sc, 0x1F, 0x0000);
20900
20901 MP_WritePhyUshort(sc, 0x1F, 0x0C42);
20902 ClearAndSetEthPhyBit(sc,
20903 0x11,
20904 BIT_13 ,
20905 BIT_14
20906 );
20907 MP_WritePhyUshort(sc, 0x1F, 0x0000);
20908
20909 if (phy_power_saving == 1) {
20910 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
20911 SetEthPhyBit(sc, 0x10, BIT_2);
20912 MP_WritePhyUshort(sc, 0x1F, 0x0000);
20913 } else {
20914 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
20915 ClearEthPhyBit(sc, 0x10, BIT_2);
20916 MP_WritePhyUshort(sc, 0x1F, 0x0000);
20917 DELAY(20000);
20918 }
20919
20920 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
20921 MP_WritePhyUshort(sc, 0x13, 0x8011);
20922 ClearEthPhyBit(sc, 0x14, BIT_14);
20923 MP_WritePhyUshort(sc, 0x1F, 0x0A40);
20924 MP_WritePhyUshort(sc, 0x1F, 0x0000);
20925 MP_WritePhyUshort(sc, 0x00, 0x9200);
20926 } else if (sc->re_type == MACFG_62 || sc->re_type == MACFG_67) {
20927 MP_WritePhyUshort(sc, 0x1F, 0x0BCC);
20928 ClearEthPhyBit(sc, 0x14, BIT_8);
20929 MP_WritePhyUshort(sc, 0x1F, 0x0A44);
20930 SetEthPhyBit(sc, 0x11, BIT_7);
20931 SetEthPhyBit(sc, 0x11, BIT_6);
20932 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
20933 MP_WritePhyUshort(sc, 0x13, 0x8084);
20934 ClearEthPhyBit(sc, 0x14, (BIT_14 | BIT_13));
20935 SetEthPhyBit(sc, 0x10, BIT_12);
20936 SetEthPhyBit(sc, 0x10, BIT_1);
20937 SetEthPhyBit(sc, 0x10, BIT_0);
20938 MP_WritePhyUshort(sc, 0x1F, 0x0000);
20939
20940 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
20941 MP_WritePhyUshort(sc, 0x13, 0x8012);
20942 SetEthPhyBit(sc, 0x14, BIT_15);
20943 MP_WritePhyUshort(sc, 0x1F, 0x0000);
20944
20945 MP_WritePhyUshort(sc, 0x1F, 0x0C42);
20946 ClearAndSetEthPhyBit(sc,
20947 0x11,
20948 BIT_13 ,
20949 BIT_14
20950 );
20951 MP_WritePhyUshort(sc, 0x1F, 0x0000);
20952
20953 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
20954 MP_WritePhyUshort(sc, 0x13, 0x80F3);
20955 ClearAndSetEthPhyBit(sc,
20956 0x14,
20957 0xFF00 ,
20958 0x8B00
20959 );
20960 MP_WritePhyUshort(sc, 0x13, 0x80F0);
20961 ClearAndSetEthPhyBit(sc,
20962 0x14,
20963 0xFF00 ,
20964 0x3A00
20965 );
20966 MP_WritePhyUshort(sc, 0x13, 0x80EF);
20967 ClearAndSetEthPhyBit(sc,
20968 0x14,
20969 0xFF00 ,
20970 0x0500
20971 );
20972 MP_WritePhyUshort(sc, 0x13, 0x80F6);
20973 ClearAndSetEthPhyBit(sc,
20974 0x14,
20975 0xFF00 ,
20976 0x6E00
20977 );
20978 MP_WritePhyUshort(sc, 0x13, 0x80EC);
20979 ClearAndSetEthPhyBit(sc,
20980 0x14,
20981 0xFF00 ,
20982 0x6800
20983 );
20984 MP_WritePhyUshort(sc, 0x13, 0x80ED);
20985 ClearAndSetEthPhyBit(sc,
20986 0x14,
20987 0xFF00 ,
20988 0x7C00
20989 );
20990 MP_WritePhyUshort(sc, 0x13, 0x80F2);
20991 ClearAndSetEthPhyBit(sc,
20992 0x14,
20993 0xFF00 ,
20994 0xF400
20995 );
20996 MP_WritePhyUshort(sc, 0x13, 0x80F4);
20997 ClearAndSetEthPhyBit(sc,
20998 0x14,
20999 0xFF00 ,
21000 0x8500
21001 );
21002
21003 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
21004 MP_WritePhyUshort(sc, 0x13, 0x8110);
21005 ClearAndSetEthPhyBit(sc,
21006 0x14,
21007 0xFF00 ,
21008 0xA800
21009 );
21010 MP_WritePhyUshort(sc, 0x13, 0x810F);
21011 ClearAndSetEthPhyBit(sc,
21012 0x14,
21013 0xFF00 ,
21014 0x1D00
21015 );
21016 MP_WritePhyUshort(sc, 0x13, 0x8111);
21017 ClearAndSetEthPhyBit(sc,
21018 0x14,
21019 0xFF00 ,
21020 0xF500
21021 );
21022 MP_WritePhyUshort(sc, 0x13, 0x8113);
21023 ClearAndSetEthPhyBit(sc,
21024 0x14,
21025 0xFF00 ,
21026 0x6100
21027 );
21028 MP_WritePhyUshort(sc, 0x13, 0x8115);
21029 ClearAndSetEthPhyBit(sc,
21030 0x14,
21031 0xFF00 ,
21032 0x9200
21033 );
21034 MP_WritePhyUshort(sc, 0x13, 0x810E);
21035 ClearAndSetEthPhyBit(sc,
21036 0x14,
21037 0xFF00 ,
21038 0x0400
21039 );
21040 MP_WritePhyUshort(sc, 0x13, 0x810C);
21041 ClearAndSetEthPhyBit(sc,
21042 0x14,
21043 0xFF00 ,
21044 0x7C00
21045 );
21046 MP_WritePhyUshort(sc, 0x13, 0x810B);
21047 ClearAndSetEthPhyBit(sc,
21048 0x14,
21049 0xFF00 ,
21050 0x5A00
21051 );
21052
21053 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
21054 MP_WritePhyUshort(sc, 0x13, 0x80D1);
21055 ClearAndSetEthPhyBit(sc,
21056 0x14,
21057 0xFF00 ,
21058 0xFF00
21059 );
21060 MP_WritePhyUshort(sc, 0x13, 0x80CD);
21061 ClearAndSetEthPhyBit(sc,
21062 0x14,
21063 0xFF00 ,
21064 0x9E00
21065 );
21066 MP_WritePhyUshort(sc, 0x13, 0x80D3);
21067 ClearAndSetEthPhyBit(sc,
21068 0x14,
21069 0xFF00 ,
21070 0x0E00
21071 );
21072 MP_WritePhyUshort(sc, 0x13, 0x80D5);
21073 ClearAndSetEthPhyBit(sc,
21074 0x14,
21075 0xFF00 ,
21076 0xCA00
21077 );
21078 MP_WritePhyUshort(sc, 0x13, 0x80D7);
21079 ClearAndSetEthPhyBit(sc,
21080 0x14,
21081 0xFF00 ,
21082 0x8400
21083 );
21084
21085 if (phy_power_saving == 1) {
21086 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
21087 SetEthPhyBit(sc, 0x10, BIT_2);
21088 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21089 } else {
21090 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
21091 ClearEthPhyBit(sc, 0x10, BIT_2);
21092 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21093 DELAY(20000);
21094 }
21095
21096 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
21097 MP_WritePhyUshort(sc, 0x13, 0x8011);
21098 ClearEthPhyBit(sc, 0x14, BIT_14);
21099 MP_WritePhyUshort(sc, 0x1F, 0x0A40);
21100 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21101 MP_WritePhyUshort(sc, 0x00, 0x9200);
21102 } else if (sc->re_type == MACFG_63) {
21103 MP_WritePhyUshort(sc, 0x1f, 0x0002);
21104 MP_WritePhyUshort(sc, 0x10, 0x0008);
21105 MP_WritePhyUshort(sc, 0x0d, 0x006c);
21106 MP_WritePhyUshort(sc, 0x1f, 0x0000);
21107
21108 MP_WritePhyUshort(sc, 0x1f, 0x0001);
21109 MP_WritePhyUshort(sc, 0x17, 0x0cc0);
21110 MP_WritePhyUshort(sc, 0x1f, 0x0000);
21111
21112 MP_WritePhyUshort(sc, 0x1F, 0x0001);
21113 MP_WritePhyUshort(sc, 0x0B, 0xA4D8);
21114 MP_WritePhyUshort(sc, 0x09, 0x281C);
21115 MP_WritePhyUshort(sc, 0x07, 0x2883);
21116 MP_WritePhyUshort(sc, 0x0A, 0x6B35);
21117 MP_WritePhyUshort(sc, 0x1D, 0x3DA4);
21118 MP_WritePhyUshort(sc, 0x1C, 0xEFFD);
21119 MP_WritePhyUshort(sc, 0x14, 0x7F52);
21120 MP_WritePhyUshort(sc, 0x18, 0x7FC6);
21121 MP_WritePhyUshort(sc, 0x08, 0x0601);
21122 MP_WritePhyUshort(sc, 0x06, 0x4063);
21123 MP_WritePhyUshort(sc, 0x10, 0xF074);
21124 MP_WritePhyUshort(sc, 0x1F, 0x0003);
21125 MP_WritePhyUshort(sc, 0x13, 0x0789);
21126 MP_WritePhyUshort(sc, 0x12, 0xF4BD);
21127 MP_WritePhyUshort(sc, 0x1A, 0x04FD);
21128 MP_WritePhyUshort(sc, 0x14, 0x84B0);
21129 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21130
21131 MP_WritePhyUshort(sc, 0x1F, 0x0005);
21132 MP_WritePhyUshort(sc, 0x01, 0x0340);
21133 MP_WritePhyUshort(sc, 0x1F, 0x0001);
21134 MP_WritePhyUshort(sc, 0x04, 0x4000);
21135 MP_WritePhyUshort(sc, 0x03, 0x1D21);
21136 MP_WritePhyUshort(sc, 0x02, 0x0C32);
21137 MP_WritePhyUshort(sc, 0x01, 0x0200);
21138 MP_WritePhyUshort(sc, 0x00, 0x5554);
21139 MP_WritePhyUshort(sc, 0x04, 0x4800);
21140 MP_WritePhyUshort(sc, 0x04, 0x4000);
21141 MP_WritePhyUshort(sc, 0x04, 0xF000);
21142 MP_WritePhyUshort(sc, 0x03, 0xDF01);
21143 MP_WritePhyUshort(sc, 0x02, 0xDF20);
21144 MP_WritePhyUshort(sc, 0x01, 0x101A);
21145 MP_WritePhyUshort(sc, 0x00, 0xA0FF);
21146 MP_WritePhyUshort(sc, 0x04, 0xF800);
21147 MP_WritePhyUshort(sc, 0x04, 0xF000);
21148 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21149
21150 MP_WritePhyUshort(sc, 0x1F, 0x0007);
21151 MP_WritePhyUshort(sc, 0x1E, 0x0023);
21152 MP_WritePhyUshort(sc, 0x16, 0x0000);
21153 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21154
21155 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21156 PhyRegValue = MP_ReadPhyUshort(sc, 0x0D);
21157 PhyRegValue |= (BIT_5);
21158 MP_WritePhyUshort(sc, 0x0D, PhyRegValue);
21159
21160 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21161 PhyRegValue = MP_ReadPhyUshort(sc, 0x0C);
21162 PhyRegValue |= (BIT_10);
21163 MP_WritePhyUshort(sc, 0x0C, PhyRegValue);
21164 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21165 } else if (sc->re_type == MACFG_64) {
21166 MP_WritePhyUshort(sc, 0x1f, 0x0001);
21167 MP_WritePhyUshort(sc, 0x17, 0x0cc0);
21168 MP_WritePhyUshort(sc, 0x1f, 0x0000);
21169
21170 MP_WritePhyUshort(sc, 0x1F, 0x0005);
21171 MP_WritePhyUshort(sc, 0x01, 0x0340);
21172 MP_WritePhyUshort(sc, 0x1F, 0x0001);
21173 MP_WritePhyUshort(sc, 0x04, 0x4000);
21174 MP_WritePhyUshort(sc, 0x03, 0x1D21);
21175 MP_WritePhyUshort(sc, 0x02, 0x0C32);
21176 MP_WritePhyUshort(sc, 0x01, 0x0200);
21177 MP_WritePhyUshort(sc, 0x00, 0x5554);
21178 MP_WritePhyUshort(sc, 0x04, 0x4800);
21179 MP_WritePhyUshort(sc, 0x04, 0x4000);
21180 MP_WritePhyUshort(sc, 0x04, 0xF000);
21181 MP_WritePhyUshort(sc, 0x03, 0xDF01);
21182 MP_WritePhyUshort(sc, 0x02, 0xDF20);
21183 MP_WritePhyUshort(sc, 0x01, 0x101A);
21184 MP_WritePhyUshort(sc, 0x00, 0xA0FF);
21185 MP_WritePhyUshort(sc, 0x04, 0xF800);
21186 MP_WritePhyUshort(sc, 0x04, 0xF000);
21187 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21188
21189 MP_WritePhyUshort(sc, 0x1F, 0x0007);
21190 MP_WritePhyUshort(sc, 0x1E, 0x0023);
21191 MP_WritePhyUshort(sc, 0x16, 0x0000);
21192 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21193
21194 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21195 PhyRegValue = MP_ReadPhyUshort(sc, 0x0D);
21196 PhyRegValue |= (BIT_5);
21197 MP_WritePhyUshort(sc, 0x0D, PhyRegValue);
21198
21199 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21200 PhyRegValue = MP_ReadPhyUshort(sc, 0x0C);
21201 PhyRegValue |= (BIT_10);
21202 MP_WritePhyUshort(sc, 0x0C, PhyRegValue);
21203 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21204 } else if (sc->re_type == MACFG_65) {
21205 MP_WritePhyUshort(sc, 0x1f, 0x0001);
21206 MP_WritePhyUshort(sc, 0x17, 0x0cc0);
21207 MP_WritePhyUshort(sc, 0x1f, 0x0000);
21208
21209 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21210 PhyRegValue = MP_ReadPhyUshort(sc, 0x0D);
21211 PhyRegValue |= (BIT_5);
21212 MP_WritePhyUshort(sc, 0x0D, PhyRegValue);
21213
21214 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21215 PhyRegValue = MP_ReadPhyUshort(sc, 0x0C);
21216 PhyRegValue |= (BIT_10);
21217 MP_WritePhyUshort(sc, 0x0C, PhyRegValue);
21218 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21219
21220 MP_WritePhyUshort(sc, 0x1F, 0x0007);
21221 MP_WritePhyUshort(sc, 0x1E, 0x002C);
21222 MP_WritePhyUshort(sc, 0x15, 0x035D);
21223 MP_WritePhyUshort(sc, 0x1F, 0x0005);
21224 MP_WritePhyUshort(sc, 0x01, 0x0300);
21225 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21226 } else if (sc->re_type == MACFG_66) {
21227 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21228 PhyRegValue = MP_ReadPhyUshort(sc, 0x0D);
21229 PhyRegValue |= (BIT_5);
21230 MP_WritePhyUshort(sc, 0x0D, PhyRegValue);
21231
21232 MP_WritePhyUshort(sc, 0x1F, 0x0002);
21233 PhyRegValue = MP_ReadPhyUshort(sc, 0x0C);
21234 PhyRegValue |= (BIT_10);
21235 MP_WritePhyUshort(sc, 0x0C, PhyRegValue);
21236 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21237 } else if (sc->re_type == MACFG_68) {
21238 MP_WritePhyUshort(sc,0x1f, 0x0B82);
21239 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
21240 PhyRegValue |= BIT_4;
21241 MP_WritePhyUshort(sc,0x10, PhyRegValue);
21242
21243 MP_WritePhyUshort(sc,0x1f, 0x0B80);
21244 WaitCnt = 0;
21245 do {
21246 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
21247 PhyRegValue &= 0x0040;
21248 DELAY(50);
21249 DELAY(50);
21250 WaitCnt++;
21251 } while(PhyRegValue != 0x0040 && WaitCnt <1000);
21252
21253 MP_WritePhyUshort(sc,0x1f, 0x0A43);
21254 MP_WritePhyUshort(sc,0x13, 0x8028);
21255 MP_WritePhyUshort(sc,0x14, 0x6200);
21256 MP_WritePhyUshort(sc,0x13, 0xB82E);
21257 MP_WritePhyUshort(sc,0x14, 0x0001);
21258
21259 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
21260 MP_WritePhyUshort(sc, 0x13, 0xB820);
21261 MP_WritePhyUshort(sc, 0x14, 0x0290);
21262 MP_WritePhyUshort(sc, 0x13, 0xA012);
21263 MP_WritePhyUshort(sc, 0x14, 0x0000);
21264 MP_WritePhyUshort(sc, 0x13, 0xA014);
21265 MP_WritePhyUshort(sc, 0x14, 0x2c04);
21266 MP_WritePhyUshort(sc, 0x14, 0x2c10);
21267 MP_WritePhyUshort(sc, 0x14, 0x2c10);
21268 MP_WritePhyUshort(sc, 0x14, 0x2c10);
21269 MP_WritePhyUshort(sc, 0x14, 0xa210);
21270 MP_WritePhyUshort(sc, 0x14, 0xa101);
21271 MP_WritePhyUshort(sc, 0x14, 0xce10);
21272 MP_WritePhyUshort(sc, 0x14, 0xe070);
21273 MP_WritePhyUshort(sc, 0x14, 0x0f40);
21274 MP_WritePhyUshort(sc, 0x14, 0xaf01);
21275 MP_WritePhyUshort(sc, 0x14, 0x8f01);
21276 MP_WritePhyUshort(sc, 0x14, 0x183e);
21277 MP_WritePhyUshort(sc, 0x14, 0x8e10);
21278 MP_WritePhyUshort(sc, 0x14, 0x8101);
21279 MP_WritePhyUshort(sc, 0x14, 0x8210);
21280 MP_WritePhyUshort(sc, 0x14, 0x28da);
21281 MP_WritePhyUshort(sc, 0x13, 0xA01A);
21282 MP_WritePhyUshort(sc, 0x14, 0x0000);
21283 MP_WritePhyUshort(sc, 0x13, 0xA006);
21284 MP_WritePhyUshort(sc, 0x14, 0x0017);
21285 MP_WritePhyUshort(sc, 0x13, 0xA004);
21286 MP_WritePhyUshort(sc, 0x14, 0x0015);
21287 MP_WritePhyUshort(sc, 0x13, 0xA002);
21288 MP_WritePhyUshort(sc, 0x14, 0x0013);
21289 MP_WritePhyUshort(sc, 0x13, 0xA000);
21290 MP_WritePhyUshort(sc, 0x14, 0x18d1);
21291 MP_WritePhyUshort(sc, 0x13, 0xB820);
21292 MP_WritePhyUshort(sc, 0x14, 0x0210);
21293
21294 MP_WritePhyUshort(sc,0x1F, 0x0A43);
21295 MP_WritePhyUshort(sc,0x13, 0x0000);
21296 MP_WritePhyUshort(sc,0x14, 0x0000);
21297 MP_WritePhyUshort(sc,0x1f, 0x0B82);
21298 PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
21299 PhyRegValue &= ~(BIT_0);
21300 MP_WritePhyUshort(sc,0x17, PhyRegValue);
21301 MP_WritePhyUshort(sc,0x1f, 0x0A43);
21302 MP_WritePhyUshort(sc,0x13, 0x8028);
21303 MP_WritePhyUshort(sc,0x14, 0x0000);
21304
21305 MP_WritePhyUshort(sc,0x1f, 0x0B82);
21306 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
21307 PhyRegValue &= ~(BIT_4);
21308 MP_WritePhyUshort(sc,0x10, PhyRegValue);
21309
21310
21311
21312 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
21313 MP_WritePhyUshort(sc, 0x13, 0x809b);
21314 ClearAndSetEthPhyBit(sc,
21315 0x14,
21316 0xF800 ,
21317 0x8000
21318 );
21319 MP_WritePhyUshort(sc, 0x13, 0x80A2);
21320 ClearAndSetEthPhyBit(sc,
21321 0x14,
21322 0xFF00 ,
21323 0x8000
21324 );
21325 MP_WritePhyUshort(sc, 0x13, 0x80A4);
21326 ClearAndSetEthPhyBit(sc,
21327 0x14,
21328 0xFF00 ,
21329 0x8500
21330 );
21331 MP_WritePhyUshort(sc, 0x13, 0x809C);
21332 ClearAndSetEthPhyBit(sc,
21333 0x14,
21334 0xFF00 ,
21335 0xbd00
21336 );
21337 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21338
21339 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
21340 MP_WritePhyUshort(sc, 0x13, 0x80AD);
21341 ClearAndSetEthPhyBit(sc,
21342 0x14,
21343 0xF800 ,
21344 0x7000
21345 );
21346 MP_WritePhyUshort(sc, 0x13, 0x80B4);
21347 ClearAndSetEthPhyBit(sc,
21348 0x14,
21349 0xFF00 ,
21350 0x5000
21351 );
21352 MP_WritePhyUshort(sc, 0x13, 0x80AC);
21353 ClearAndSetEthPhyBit(sc,
21354 0x14,
21355 0xFF00 ,
21356 0x4000
21357 );
21358 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21359
21360 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
21361 MP_WritePhyUshort(sc, 0x13, 0x808E);
21362 ClearAndSetEthPhyBit(sc,
21363 0x14,
21364 0xFF00 ,
21365 0x1200
21366 );
21367 MP_WritePhyUshort(sc, 0x13, 0x8090);
21368 ClearAndSetEthPhyBit(sc,
21369 0x14,
21370 0xFF00 ,
21371 0xE500
21372 );
21373 MP_WritePhyUshort(sc, 0x13, 0x8092);
21374 ClearAndSetEthPhyBit(sc,
21375 0x14,
21376 0xFF00 ,
21377 0x9F00
21378 );
21379 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21380
21381 dout_tapbin = 0x0000;
21382 MP_WritePhyUshort(sc, 0x1F, 0x0A46);
21383 TmpUshort = MP_ReadPhyUshort(sc, 0x13);
21384 TmpUshort &= (BIT_1|BIT_0);
21385 TmpUshort <<= 2;
21386 dout_tapbin |= TmpUshort;
21387
21388 TmpUshort = MP_ReadPhyUshort(sc, 0x12);
21389 TmpUshort &= (BIT_15|BIT_14);
21390 TmpUshort >>= 14;
21391 dout_tapbin |= TmpUshort;
21392
21393 dout_tapbin = ~(dout_tapbin^BIT_3);
21394 dout_tapbin <<= 12;
21395 dout_tapbin &= 0xF000;
21396
21397 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
21398
21399 MP_WritePhyUshort(sc, 0x13, 0x827A);
21400 ClearAndSetEthPhyBit(sc,
21401 0x14,
21402 BIT_15|BIT_14|BIT_13|BIT_12,
21403 dout_tapbin
21404 );
21405
21406
21407 MP_WritePhyUshort(sc, 0x13, 0x827B);
21408 ClearAndSetEthPhyBit(sc,
21409 0x14,
21410 BIT_15|BIT_14|BIT_13|BIT_12,
21411 dout_tapbin
21412 );
21413
21414
21415 MP_WritePhyUshort(sc, 0x13, 0x827C);
21416 ClearAndSetEthPhyBit(sc,
21417 0x14,
21418 BIT_15|BIT_14|BIT_13|BIT_12,
21419 dout_tapbin
21420 );
21421
21422
21423 MP_WritePhyUshort(sc, 0x13, 0x827D);
21424 ClearAndSetEthPhyBit(sc,
21425 0x14,
21426 BIT_15|BIT_14|BIT_13|BIT_12,
21427 dout_tapbin
21428 );
21429
21430 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
21431 MP_WritePhyUshort(sc, 0x13, 0x8011);
21432 SetEthPhyBit(sc, 0x14, BIT_11);
21433 MP_WritePhyUshort(sc, 0x1F, 0x0A42);
21434 SetEthPhyBit(sc, 0x16, BIT_1);
21435
21436 MP_WritePhyUshort(sc, 0x1F, 0x0A44);
21437 SetEthPhyBit(sc, 0x11, BIT_11);
21438 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21439
21440 MP_WritePhyUshort(sc, 0x1F, 0x0BCA);
21441 ClearAndSetEthPhyBit(sc,
21442 0x17,
21443 (BIT_13 | BIT_12) ,
21444 BIT_14
21445 );
21446 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21447
21448 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
21449 MP_WritePhyUshort(sc, 0x13, 0x803F);
21450 ClearEthPhyBit(sc, 0x14, (BIT_13 | BIT_12));
21451 MP_WritePhyUshort(sc, 0x13, 0x8047);
21452 ClearEthPhyBit(sc, 0x14, (BIT_13 | BIT_12));
21453 MP_WritePhyUshort(sc, 0x13, 0x804F);
21454 ClearEthPhyBit(sc, 0x14, (BIT_13 | BIT_12));
21455 MP_WritePhyUshort(sc, 0x13, 0x8057);
21456 ClearEthPhyBit(sc, 0x14, (BIT_13 | BIT_12));
21457 MP_WritePhyUshort(sc, 0x13, 0x805F);
21458 ClearEthPhyBit(sc, 0x14, (BIT_13 | BIT_12));
21459 MP_WritePhyUshort(sc, 0x13, 0x8067);
21460 ClearEthPhyBit(sc, 0x14, (BIT_13 | BIT_12));
21461 MP_WritePhyUshort(sc, 0x13, 0x806F);
21462 ClearEthPhyBit(sc, 0x14, (BIT_13 | BIT_12));
21463 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21464
21465 if (phy_power_saving == 1) {
21466 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
21467 SetEthPhyBit(sc, 0x10, BIT_2);
21468 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21469 } else {
21470 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
21471 ClearEthPhyBit(sc, 0x10, BIT_2);
21472 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21473 DELAY(20000);
21474 }
21475
21476 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
21477 MP_WritePhyUshort(sc, 0x13, 0x8011);
21478 ClearEthPhyBit(sc, 0x14, BIT_15);
21479 MP_WritePhyUshort(sc, 0x1F, 0x0A40);
21480 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21481 MP_WritePhyUshort(sc, 0x00, 0x9200);
21482 } else if (sc->re_type == MACFG_69) {
21483 MP_WritePhyUshort(sc,0x1f, 0x0B82);
21484 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
21485 PhyRegValue |= BIT_4;
21486 MP_WritePhyUshort(sc,0x10, PhyRegValue);
21487
21488 MP_WritePhyUshort(sc,0x1f, 0x0B80);
21489 WaitCnt = 0;
21490 do {
21491 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
21492 PhyRegValue &= 0x0040;
21493 DELAY(50);
21494 DELAY(50);
21495 WaitCnt++;
21496 } while(PhyRegValue != 0x0040 && WaitCnt <1000);
21497
21498 MP_WritePhyUshort(sc,0x1f, 0x0A43);
21499 MP_WritePhyUshort(sc,0x13, 0x8028);
21500 MP_WritePhyUshort(sc,0x14, 0x6201);
21501 MP_WritePhyUshort(sc,0x13, 0xB82E);
21502 MP_WritePhyUshort(sc,0x14, 0x0001);
21503
21504 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
21505 MP_WritePhyUshort(sc, 0x13, 0xB820);
21506 MP_WritePhyUshort(sc, 0x14, 0x0290);
21507 MP_WritePhyUshort(sc, 0x13, 0xA012);
21508 MP_WritePhyUshort(sc, 0x14, 0x0000);
21509 MP_WritePhyUshort(sc, 0x13, 0xA014);
21510 MP_WritePhyUshort(sc, 0x14, 0x2c04);
21511 MP_WritePhyUshort(sc, 0x14, 0x2c09);
21512 MP_WritePhyUshort(sc, 0x14, 0x2c09);
21513 MP_WritePhyUshort(sc, 0x14, 0x2c09);
21514 MP_WritePhyUshort(sc, 0x14, 0xad01);
21515 MP_WritePhyUshort(sc, 0x14, 0xad01);
21516 MP_WritePhyUshort(sc, 0x14, 0xad01);
21517 MP_WritePhyUshort(sc, 0x14, 0xad01);
21518 MP_WritePhyUshort(sc, 0x14, 0x236c);
21519 MP_WritePhyUshort(sc, 0x13, 0xA01A);
21520 MP_WritePhyUshort(sc, 0x14, 0x0000);
21521 MP_WritePhyUshort(sc, 0x13, 0xA006);
21522 MP_WritePhyUshort(sc, 0x14, 0x0fff);
21523 MP_WritePhyUshort(sc, 0x13, 0xA004);
21524 MP_WritePhyUshort(sc, 0x14, 0x0fff);
21525 MP_WritePhyUshort(sc, 0x13, 0xA002);
21526 MP_WritePhyUshort(sc, 0x14, 0x0fff);
21527 MP_WritePhyUshort(sc, 0x13, 0xA000);
21528 MP_WritePhyUshort(sc, 0x14, 0x136b);
21529 MP_WritePhyUshort(sc, 0x13, 0xB820);
21530 MP_WritePhyUshort(sc, 0x14, 0x0210);
21531
21532 MP_WritePhyUshort(sc,0x1F, 0x0A43);
21533 MP_WritePhyUshort(sc,0x13, 0x0000);
21534 MP_WritePhyUshort(sc,0x14, 0x0000);
21535 MP_WritePhyUshort(sc,0x1f, 0x0B82);
21536 PhyRegValue = MP_ReadPhyUshort(sc, 0x17);
21537 PhyRegValue &= ~(BIT_0);
21538 MP_WritePhyUshort(sc,0x17, PhyRegValue);
21539 MP_WritePhyUshort(sc,0x1f, 0x0A43);
21540 MP_WritePhyUshort(sc,0x13, 0x8028);
21541 MP_WritePhyUshort(sc,0x14, 0x0000);
21542
21543 MP_WritePhyUshort(sc,0x1f, 0x0B82);
21544 PhyRegValue = MP_ReadPhyUshort(sc, 0x10);
21545 PhyRegValue &= ~(BIT_4);
21546 MP_WritePhyUshort(sc,0x10, PhyRegValue);
21547
21548
21549 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
21550 MP_WritePhyUshort(sc, 0x13, 0x808A);
21551 ClearAndSetEthPhyBit(sc,
21552 0x14,
21553 BIT_5 | BIT_4 | BIT_3 | BIT_2 | BIT_1 | BIT_0,
21554 0x0A);
21555
21556 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
21557 MP_WritePhyUshort(sc, 0x13, 0x8011);
21558 SetEthPhyBit(sc, 0x14, BIT_11);
21559 MP_WritePhyUshort(sc, 0x1F, 0x0A42);
21560 SetEthPhyBit(sc, 0x16, BIT_1);
21561
21562 MP_WritePhyUshort(sc, 0x1F, 0x0A44);
21563 SetEthPhyBit(sc, 0x11, BIT_11);
21564 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21565
21566 if (sc->RequireAdcBiasPatch) {
21567 MP_WritePhyUshort(sc, 0x1F, 0x0BCF);
21568 MP_WritePhyUshort(sc, 0x16, sc->AdcBiasPatchIoffset);
21569 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21570 }
21571
21572 {
21573 u_int16_t rlen;
21574
21575 MP_WritePhyUshort(sc, 0x1F, 0x0BCD);
21576 PhyRegValue = MP_ReadPhyUshort(sc, 0x16);
21577 PhyRegValue &= 0x000F;
21578
21579 if (PhyRegValue > 3) {
21580 rlen = PhyRegValue - 3;
21581 } else {
21582 rlen = 0;
21583 }
21584
21585 PhyRegValue = rlen | (rlen<<4) | (rlen<<8) | (rlen<<12);
21586
21587 MP_WritePhyUshort(sc, 0x1F, 0x0BCD);
21588 MP_WritePhyUshort(sc, 0x17, PhyRegValue);
21589 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21590 }
21591
21592 if (phy_power_saving == 1) {
21593 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
21594 SetEthPhyBit(sc, 0x10, BIT_2);
21595 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21596 } else {
21597 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
21598 ClearEthPhyBit(sc, 0x10, BIT_2);
21599 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21600 DELAY(20000);
21601 }
21602
21603 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
21604 MP_WritePhyUshort(sc, 0x13, 0x8011);
21605 ClearEthPhyBit(sc, 0x14, BIT_15);
21606 MP_WritePhyUshort(sc, 0x1F, 0x0A40);
21607 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21608 MP_WritePhyUshort(sc, 0x00, 0x9200);
21609 }
21610 //EthPhyPPSW
21611 if (sc->re_type == MACFG_56 || sc->re_type == MACFG_56 ||
21612 sc->re_type == MACFG_58 || sc->re_type == MACFG_58 ||
21613 sc->re_type == MACFG_60) {
21614 //disable EthPhyPPSW
21615 MP_WritePhyUshort(sc, 0x1F, 0x0BCD);
21616 MP_WritePhyUshort(sc, 0x14, 0x5065);
21617 MP_WritePhyUshort(sc, 0x14, 0xD065);
21618 MP_WritePhyUshort(sc, 0x1F, 0x0BC8);
21619 MP_WritePhyUshort(sc, 0x12, 0x00ED);
21620 MP_WritePhyUshort(sc, 0x1F, 0x0BCD);
21621 MP_WritePhyUshort(sc, 0x14, 0x1065);
21622 MP_WritePhyUshort(sc, 0x14, 0x9065);
21623 MP_WritePhyUshort(sc, 0x14, 0x1065);
21624 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21625 } else if (sc->re_type == MACFG_68 || sc->re_type == MACFG_69) {
21626 //enable EthPhyPPSW
21627 MP_WritePhyUshort(sc, 0x1F, 0x0A44);
21628 SetEthPhyBit(sc, 0x11, BIT_7);
21629 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21630 }
21631
21632 switch(sc->re_type) {
21633 case MACFG_56:
21634 case MACFG_57:
21635 case MACFG_58:
21636 case MACFG_59:
21637 case MACFG_60:
21638 case MACFG_61:
21639 case MACFG_62:
21640 case MACFG_67:
21641 case MACFG_68:
21642 case MACFG_69:
21643 if (phy_mdix_mode == RE_ETH_PHY_FORCE_MDI) {
21644 //Force MDI
21645 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
21646 SetEthPhyBit(sc, 0x10, BIT_8 | BIT_9);
21647 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21648 } else if (phy_mdix_mode == RE_ETH_PHY_FORCE_MDIX) {
21649 //Force MDIX
21650 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
21651 ClearEthPhyBit(sc, 0x10, BIT_8);
21652 SetEthPhyBit(sc, 0x10, BIT_9);
21653 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21654 } else {
21655 //Auto MDI/MDIX
21656 MP_WritePhyUshort(sc, 0x1F, 0x0A43);
21657 ClearEthPhyBit(sc, 0x10, BIT_8 | BIT_9);
21658 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21659 }
21660
21661 break;
21662 }
21663
21664 if (phy_power_saving == 1) {
21665 if (sc->re_type == MACFG_59 || sc->re_type == MACFG_60 ||
21666 sc->re_type == MACFG_62 || sc->re_type == MACFG_67 ||
21667 sc->re_type == MACFG_68 || sc->re_type == MACFG_69) {
21668 MP_WritePhyOcpRegWord(sc, 0x0C41, 0x13, 0x0000);
21669 MP_WritePhyOcpRegWord(sc, 0x0C41, 0x13, 0x0050);
21670 }
21671 }
21672
21673 if (eee_enable == 1)
21674 re_enable_EEE(sc);
21675 else
21676 re_disable_EEE(sc);
21677
21678 MP_WritePhyUshort(sc, 0x1F, 0x0000);
21679 }
21680
21681 void MP_WritePhyUshort(struct re_softc *sc,u_int8_t RegAddr,u_int16_t RegData)
21682 {
21683 u_int32_t TmpUlong=0x80000000;
21684 u_int32_t Timeout=0;
21685
21686 if (RegAddr == 0x1F) {
21687 sc->cur_page = RegData;
21688 }
21689
21690 if (sc->re_type == MACFG_63) {
21691 int i;
21692 CSR_WRITE_4(sc, RE_OCPDR, OCPDR_Write |
21693 (RegAddr & OCPDR_Reg_Mask) << OCPDR_GPHY_Reg_shift |
21694 (RegData & OCPDR_Data_Mask));
21695 CSR_WRITE_4(sc, RE_OCPAR, OCPAR_GPHY_Write);
21696 CSR_WRITE_4(sc, RE_EPHY_RXER_NUM, 0);
21697
21698 for (i = 0; i < 100; i++) {
21699 DELAY(1000);
21700 if (!(CSR_READ_4(sc, RE_OCPAR) & OCPAR_Flag))
21701 break;
21702 }
21703 } else if (sc->re_type == MACFG_56 || sc->re_type == MACFG_57 ||
21704 sc->re_type == MACFG_58 || sc->re_type == MACFG_59 ||
21705 sc->re_type == MACFG_60 || sc->re_type == MACFG_61 ||
21706 sc->re_type == MACFG_62 || sc->re_type == MACFG_67 ||
21707 sc->re_type == MACFG_69 || sc->re_type == MACFG_69) {
21708 if (RegAddr == 0x1F) {
21709 return;
21710 }
21711
21712 MP_WritePhyOcpRegWord(sc, sc->cur_page, RegAddr, RegData);
21713 } else {
21714 if (sc->re_type == MACFG_65 || sc->re_type == MACFG_66)
21715 CSR_WRITE_4(sc, 0xD0, CSR_READ_4(sc,0xD0) & ~0x00020000);
21716
21717 TmpUlong |= (((u_int32_t)RegAddr)<<16 | (u_int32_t)RegData);
21718
21719 CSR_WRITE_4(sc, RE_PHYAR, TmpUlong);
21720
21721 /* Wait for writing to Phy ok */
21722 for (Timeout=0; Timeout<5; Timeout++) {
21723 DELAY(1000);
21724 if ((CSR_READ_4(sc, RE_PHYAR)&PHYAR_Flag)==0)
21725 break;
21726 }
21727
21728 if (sc->re_type == MACFG_65 || sc->re_type == MACFG_66)
21729 CSR_WRITE_4(sc, 0xD0, CSR_READ_4(sc,0xD0) | 0x00020000);
21730 }
21731 }
21732
21733 u_int16_t MP_ReadPhyUshort(struct re_softc *sc,u_int8_t RegAddr)
21734 {
21735 u_int16_t RegData;
21736 u_int32_t TmpUlong;
21737 u_int32_t Timeout=0;
21738
21739 if (sc->re_type == MACFG_63) {
21740 int i;
21741 CSR_WRITE_4(sc, RE_OCPDR, OCPDR_Read |
21742 (RegAddr & OCPDR_Reg_Mask) << OCPDR_GPHY_Reg_shift);
21743 CSR_WRITE_4(sc, RE_OCPAR, OCPAR_GPHY_Write);
21744 CSR_WRITE_4(sc, RE_EPHY_RXER_NUM, 0);
21745
21746 for (i = 0; i < 100; i++) {
21747 DELAY(1000);
21748 if (!(CSR_READ_4(sc, RE_OCPAR) & OCPAR_Flag))
21749 break;
21750 }
21751
21752 DELAY(1000);
21753 CSR_WRITE_4(sc, RE_OCPAR, OCPAR_GPHY_Read);
21754 CSR_WRITE_4(sc, RE_EPHY_RXER_NUM, 0);
21755
21756 for (i = 0; i < 100; i++) {
21757 DELAY(1000);
21758 if (CSR_READ_4(sc, RE_OCPAR) & OCPAR_Flag)
21759 break;
21760 }
21761
21762 RegData = CSR_READ_4(sc, RE_OCPDR) & OCPDR_Data_Mask;
21763 } else if (sc->re_type == MACFG_56 || sc->re_type == MACFG_57 ||
21764 sc->re_type == MACFG_58 || sc->re_type == MACFG_59 ||
21765 sc->re_type == MACFG_60 || sc->re_type == MACFG_61 ||
21766 sc->re_type == MACFG_62 || sc->re_type == MACFG_67 ||
21767 sc->re_type == MACFG_69 || sc->re_type == MACFG_69) {
21768 RegData= MP_ReadPhyOcpRegWord(sc, sc->cur_page, RegAddr);
21769
21770 } else {
21771 if (sc->re_type == MACFG_65 || sc->re_type == MACFG_66)
21772 CSR_WRITE_4(sc, 0xD0, CSR_READ_4(sc,0xD0) & ~0x00020000);
21773
21774 TmpUlong = ((u_int32_t)RegAddr << 16);
21775 CSR_WRITE_4(sc, RE_PHYAR, TmpUlong);
21776
21777 /* Wait for writing to Phy ok */
21778 for (Timeout=0; Timeout<5; Timeout++) {
21779 DELAY(1000);
21780 TmpUlong = CSR_READ_4(sc, RE_PHYAR);
21781 if ((TmpUlong&PHYAR_Flag)!=0)
21782 break;
21783 }
21784
21785 RegData = (u_int16_t)(TmpUlong & 0x0000ffff);
21786
21787 if (sc->re_type == MACFG_65 || sc->re_type == MACFG_66)
21788 CSR_WRITE_4(sc, 0xD0, CSR_READ_4(sc,0xD0) | 0x00020000);
21789 }
21790
21791 return RegData;
21792 }
21793
21794 void MP_WriteEPhyUshort(struct re_softc *sc, u_int8_t RegAddr, u_int16_t RegData)
21795 {
21796 u_int32_t TmpUlong=0x80000000;
21797 u_int32_t Timeout=0;
21798
21799 TmpUlong |= (((u_int32_t)RegAddr<<16) | (u_int32_t)RegData);
21800
21801 CSR_WRITE_4(sc, RE_EPHYAR, TmpUlong);
21802
21803 /* Wait for writing to Phy ok */
21804 for (Timeout=0; Timeout<5; Timeout++) {
21805 DELAY(1000);
21806 if ((CSR_READ_4(sc, RE_EPHYAR)&PHYAR_Flag)==0)
21807 break;
21808 }
21809 }
21810
21811 u_int16_t MP_ReadEPhyUshort(struct re_softc *sc, u_int8_t RegAddr)
21812 {
21813 u_int16_t RegData;
21814 u_int32_t TmpUlong;
21815 u_int32_t Timeout=0;
21816
21817 TmpUlong = ((u_int32_t)RegAddr << 16);
21818 CSR_WRITE_4(sc, RE_EPHYAR, TmpUlong);
21819
21820 /* Wait for writing to Phy ok */
21821 for (Timeout=0; Timeout<5; Timeout++) {
21822 DELAY(1000);
21823 TmpUlong = CSR_READ_4(sc, RE_EPHYAR);
21824 if ((TmpUlong&PHYAR_Flag)!=0)
21825 break;
21826 }
21827
21828 RegData = (u_int16_t)(TmpUlong & 0x0000ffff);
21829
21830 return RegData;
21831 }
21832
21833 u_int8_t MP_ReadEfuse(struct re_softc *sc, u_int16_t RegAddr)
21834 {
21835 u_int8_t RegData;
21836 u_int32_t TmpUlong;
21837 u_int32_t Timeout=0;
21838
21839 RegAddr &= 0x3FF;
21840 TmpUlong = ((u_int32_t)RegAddr << 8);
21841 CSR_WRITE_4(sc, 0xDC, TmpUlong);
21842
21843 /* Wait for writing to Phy ok */
21844 for (Timeout=0; Timeout<5; Timeout++) {
21845 DELAY(1000);
21846 TmpUlong = CSR_READ_4(sc, 0xDC);
21847 if ((TmpUlong&PHYAR_Flag)!=0)
21848 break;
21849 }
21850
21851 RegData = (u_int8_t)(TmpUlong & 0x000000ff);
21852
21853 return RegData;
21854 }
21855
21856 static void MP_WriteOtherFunPciEConfigSpace(
21857 struct re_softc *sc,
21858 u_int8_t MultiFunSelBit,
21859 u_int16_t ByteEnAndAddr,
21860 u_int32_t RegData)
21861 {
21862 u_int32_t Timeout = 0, WaitCount = 10;
21863 u_int32_t TmpUlong = 0x80000000;
21864 u_int32_t WriteDone;
21865
21866 if (MultiFunSelBit > 7) {
21867 return;
21868 }
21869
21870 TmpUlong |= MultiFunSelBit << 16;
21871
21872 CSR_WRITE_4(sc, RE_CSIDR, RegData);
21873 TmpUlong |= (u_int32_t) ByteEnAndAddr;
21874 CSR_WRITE_4(sc, RE_CSIAR, TmpUlong);
21875
21876 do {
21877 DELAY(100);
21878
21879 WriteDone = CSR_READ_4(sc, RE_CSIAR);
21880 Timeout++;
21881 } while (((WriteDone & 0x80000000) != 0) && (Timeout < WaitCount));
21882
21883
21884 DELAY(50);
21885 }
21886
21887 static u_int32_t MP_ReadOtherFunPciEConfigSpace(
21888 struct re_softc *sc,
21889 u_int8_t MultiFunSelBit,
21890 u_int16_t ByteEnAndAddr)
21891 {
21892 u_int32_t Timeout = 0, WaitCount = 10;
21893 u_int32_t TmpUlong = 0x00000000;
21894 u_int32_t ReadDone;
21895 u_int32_t RetVal = 0xffffffff;
21896
21897 if (MultiFunSelBit > 7) {
21898 return 0xffffffff;
21899 }
21900
21901 TmpUlong |= MultiFunSelBit << 16;
21902
21903 TmpUlong |= (u_int32_t) ByteEnAndAddr;
21904 CSR_WRITE_4(sc, RE_CSIAR, TmpUlong);
21905
21906 do {
21907 DELAY(100);
21908
21909 ReadDone = CSR_READ_4(sc, RE_CSIAR);
21910 Timeout++;
21911 } while (((ReadDone & 0x80000000) == 0)&& (Timeout < WaitCount));
21912
21913 DELAY(50);
21914
21915 return RetVal;
21916 }
21917
21918 void MP_WritePciEConfigSpace(
21919 struct re_softc *sc,
21920 u_int16_t ByteEnAndAddr,
21921 u_int32_t RegData)
21922 {
21923 u_int8_t MultiFunSelBit;
21924
21925 if (sc->re_type == MACFG_52 || sc->re_type == MACFG_53) {
21926 MultiFunSelBit = 2;
21927 } else if (sc->re_type == MACFG_60) {
21928 MultiFunSelBit = 1;
21929 } else {
21930 MultiFunSelBit = 0;
21931 }
21932
21933 MP_WriteOtherFunPciEConfigSpace(sc, MultiFunSelBit, ByteEnAndAddr, RegData);
21934
21935 }
21936
21937 u_int32_t MP_ReadPciEConfigSpace(
21938 struct re_softc *sc,
21939 u_int16_t ByteEnAndAddr)
21940 {
21941 u_int8_t MultiFunSelBit;
21942
21943 if (sc->re_type == MACFG_52 || sc->re_type == MACFG_53) {
21944 MultiFunSelBit = 2;
21945 } else if (sc->re_type == MACFG_60) {
21946 MultiFunSelBit = 1;
21947 } else {
21948 MultiFunSelBit = 0;
21949 }
21950
21951 return MP_ReadOtherFunPciEConfigSpace(sc, MultiFunSelBit, ByteEnAndAddr);
21952 }
21953
21954 static u_int16_t MappingPhyOcpAddress(
21955 struct re_softc *sc,
21956 u_int16_t PageNum,
21957 u_int8_t RegNum)
21958 {
21959 u_int16_t OcpPageNum = 0;
21960 u_int8_t OcpRegNum = 0;
21961 u_int16_t OcpPhyAddress = 0;
21962
21963 if (PageNum == 0) {
21964 OcpPageNum = 0x0A40 + (RegNum / 8);
21965 OcpRegNum = 0x10 + (RegNum % 8);
21966 } else {
21967 OcpPageNum = PageNum;
21968 OcpRegNum = RegNum;
21969 }
21970
21971 OcpPageNum <<= 4;
21972
21973 if (OcpRegNum < 16) {
21974 OcpPhyAddress = 0;
21975 } else {
21976 OcpRegNum -= 16;
21977 OcpRegNum <<= 1;
21978
21979 OcpPhyAddress = OcpPageNum + OcpRegNum;
21980 }
21981
21982 return OcpPhyAddress;
21983 }
21984
21985 static u_int16_t MP_RealReadPhyOcpRegWord(
21986 struct re_softc *sc,
21987 u_int16_t OcpRegAddr)
21988 {
21989 u_int32_t Timeout = 0, WaitCount = 100;
21990 u_int32_t TmpUlong;
21991 u_int16_t RetVal = 0xffff;
21992
21993 TmpUlong = OcpRegAddr / 2;
21994 TmpUlong <<= 16;
21995
21996 CSR_WRITE_4(sc, RE_PHYOCPACCESS, TmpUlong);
21997
21998 do {
21999 DELAY(1);
22000
22001 TmpUlong = CSR_READ_4(sc, RE_PHYOCPACCESS);
22002
22003 Timeout++;
22004 } while ((!(TmpUlong & PHYAR_Flag)) && (Timeout < WaitCount));
22005
22006 RetVal = (u_int16_t)TmpUlong;
22007
22008 return RetVal;
22009 }
22010
22011 u_int16_t MP_ReadPhyOcpRegWord(
22012 struct re_softc *sc,
22013 u_int16_t PhyPage,
22014 u_int8_t PhyRegNum)
22015 {
22016 u_int16_t OcpRegAddr;
22017 u_int16_t RetVal = 0xffff;
22018
22019 OcpRegAddr = MappingPhyOcpAddress(sc, PhyPage, PhyRegNum);
22020
22021 if (OcpRegAddr % 2) {
22022 u_int16_t tmpUshort;
22023
22024 tmpUshort = MP_RealReadPhyOcpRegWord(sc, OcpRegAddr);
22025 tmpUshort &= 0xFF00;
22026 tmpUshort >>= 8;
22027 RetVal = tmpUshort;
22028
22029
22030 tmpUshort = MP_RealReadPhyOcpRegWord(sc, OcpRegAddr + 1);
22031 tmpUshort &= 0x00FF;
22032 tmpUshort <<= 8;
22033 RetVal |= tmpUshort;
22034 } else {
22035 RetVal = MP_RealReadPhyOcpRegWord(sc, OcpRegAddr);
22036 }
22037
22038 return RetVal;
22039 }
22040
22041 static void MP_RealWritePhyOcpRegWord(
22042 struct re_softc *sc,
22043 u_int16_t OcpRegAddr,
22044 u_int16_t RegData)
22045 {
22046 u_int32_t Timeout = 0, WaitCount = 100;
22047 u_int32_t TmpUlong;
22048
22049 TmpUlong = OcpRegAddr / 2;
22050 TmpUlong <<= 16;
22051 TmpUlong += RegData;
22052 TmpUlong |= BIT_31;
22053
22054 CSR_WRITE_4(sc, RE_PHYOCPACCESS, TmpUlong);
22055
22056 do {
22057 DELAY(1);
22058
22059 TmpUlong = CSR_READ_4(sc, RE_PHYOCPACCESS);
22060
22061 Timeout++;
22062 } while ((TmpUlong & PHYAR_Flag) && (Timeout < WaitCount));
22063 }
22064
22065 void MP_WritePhyOcpRegWord(
22066 struct re_softc *sc,
22067 u_int16_t PhyPage,
22068 u_int8_t PhyRegNum,
22069 u_int16_t RegData)
22070 {
22071 u_int16_t OcpRegAddr;
22072
22073 OcpRegAddr = MappingPhyOcpAddress(sc, PhyPage, PhyRegNum);
22074
22075 if (OcpRegAddr % 2) {
22076 u_int16_t tmpUshort;
22077
22078 tmpUshort = MP_RealReadPhyOcpRegWord(sc, OcpRegAddr);
22079 tmpUshort &= 0x00FF;
22080 tmpUshort |= (RegData << 8);
22081 MP_RealWritePhyOcpRegWord(sc, OcpRegAddr, tmpUshort);
22082 tmpUshort = MP_RealReadPhyOcpRegWord(sc, OcpRegAddr + 1);
22083 tmpUshort &= 0xFF00;
22084 tmpUshort |= (RegData >> 8);
22085 MP_RealWritePhyOcpRegWord(sc, OcpRegAddr + 1, tmpUshort);
22086 } else {
22087 MP_RealWritePhyOcpRegWord(sc, OcpRegAddr, RegData);
22088 }
22089 }
22090
22091 void MP_WriteMcuAccessRegWord(
22092 struct re_softc *sc,
22093 u_int16_t ExtRegAddr,
22094 u_int16_t RegData)
22095 {
22096 u_int32_t TmpUlong;
22097
22098 TmpUlong = ExtRegAddr / 2;
22099 TmpUlong <<= 16;
22100 TmpUlong += RegData;
22101 TmpUlong |= BIT_31;
22102
22103 CSR_WRITE_4(sc, RE_MCUACCESS, TmpUlong);
22104 }
22105
22106 u_int16_t MP_ReadMcuAccessRegWord(
22107 struct re_softc *sc,
22108 u_int16_t ExtRegAddr)
22109 {
22110 u_int32_t TmpUlong;
22111 u_int16_t RetVal = 0xffff;
22112
22113 TmpUlong = ExtRegAddr / 2;
22114 TmpUlong <<= 16;
22115
22116 CSR_WRITE_4(sc, RE_MCUACCESS, TmpUlong);
22117 TmpUlong = CSR_READ_4(sc, RE_MCUACCESS);
22118 RetVal = (u_int16_t)TmpUlong;
22119
22120 return RetVal;
22121 }
22122
22123 static u_int32_t real_ocp_read(struct re_softc *sc, u_int16_t addr, u_int8_t len)
22124 {
22125 int i, val_shift, shift = 0;
22126 u_int32_t value1 = 0, value2 = 0, mask;
22127
22128 if (len > 4 || len <= 0)
22129 return -1;
22130
22131 while (len > 0) {
22132 val_shift = addr % 4;
22133 addr = addr & ~0x3;
22134
22135 CSR_WRITE_4(sc, RE_OCPAR, (0x0F<<12) | (addr&0xFFF));
22136
22137 for (i = 0; i < 20; i++) {
22138 DELAY(100);
22139 if (CSR_READ_4(sc, RE_OCPAR) & OCPAR_Flag)
22140 break;
22141 }
22142
22143 if (len == 1) mask = (0xFF << (val_shift * 8)) & 0xFFFFFFFF;
22144 else if (len == 2) mask = (0xFFFF << (val_shift * 8)) & 0xFFFFFFFF;
22145 else if (len == 3) mask = (0xFFFFFF << (val_shift * 8)) & 0xFFFFFFFF;
22146 else mask = (0xFFFFFFFF << (val_shift * 8)) & 0xFFFFFFFF;
22147
22148 value1 = CSR_READ_4(sc, RE_OCPDR) & mask;
22149 value2 |= (value1 >> val_shift * 8) << shift * 8;
22150
22151 if (len <= 4 - val_shift) {
22152 len = 0;
22153 } else {
22154 len -= (4 - val_shift);
22155 shift = 4 - val_shift;
22156 addr += 4;
22157 }
22158 }
22159
22160 DELAY(20);
22161
22162 return value2;
22163 }
22164
22165 static u_int32_t OCP_read(struct re_softc *sc, u_int16_t addr, u_int8_t len)
22166 {
22167 u_int32_t value = 0;
22168
22169 if (sc->re_type == MACFG_61 || sc->re_type == MACFG_62 ||
22170 sc->re_type == MACFG_67) {
22171 value = re_eri_read(sc, addr, len, ERIAR_OOB);
22172 } else {
22173 value = real_ocp_read(sc, addr, len);
22174 }
22175
22176 return value;
22177 }
22178
22179 static int real_ocp_write(struct re_softc *sc, u_int16_t addr, u_int8_t len, u_int32_t value)
22180 {
22181 int i, val_shift, shift = 0;
22182 u_int32_t value1 = 0, mask;
22183
22184 if (len > 4 || len <= 0)
22185 return -1;
22186
22187 while (len > 0) {
22188 val_shift = addr % 4;
22189 addr = addr & ~0x3;
22190
22191 if (len == 1) mask = (0xFF << (val_shift * 8)) & 0xFFFFFFFF;
22192 else if (len == 2) mask = (0xFFFF << (val_shift * 8)) & 0xFFFFFFFF;
22193 else if (len == 3) mask = (0xFFFFFF << (val_shift * 8)) & 0xFFFFFFFF;
22194 else mask = (0xFFFFFFFF << (val_shift * 8)) & 0xFFFFFFFF;
22195
22196 value1 = OCP_read(sc, addr, 4) & ~mask;
22197 value1 |= ((value << val_shift * 8) >> shift * 8);
22198
22199 CSR_WRITE_4(sc, RE_OCPDR, value1);
22200 CSR_WRITE_4(sc, RE_OCPAR, OCPAR_Flag | (0x0F<<12) | (addr&0xFFF));
22201
22202 for (i = 0; i < 10; i++) {
22203 DELAY(100);
22204
22205 /* Check if the RTL8168 has completed ERI write */
22206 if (!(CSR_READ_4(sc, RE_OCPAR) & OCPAR_Flag))
22207 break;
22208 }
22209
22210 if (len <= 4 - val_shift) {
22211 len = 0;
22212 } else {
22213 len -= (4 - val_shift);
22214 shift = 4 - val_shift;
22215 addr += 4;
22216 }
22217 }
22218
22219 DELAY(20);
22220
22221 return 0;
22222 }
22223
22224 static void OCP_write(struct re_softc *sc, u_int16_t addr, u_int8_t len, u_int32_t value)
22225 {
22226 if (sc->re_type == MACFG_61 || sc->re_type == MACFG_62 ||
22227 sc->re_type == MACFG_67) {
22228 re_eri_write(sc, addr, len, value, ERIAR_OOB);
22229 } else {
22230 real_ocp_write(sc, addr, len, value);
22231 }
22232 }
22233
22234 static void OOB_mutex_lock(struct re_softc *sc)
22235 {
22236 u_int8_t reg_16, reg_a0;
22237 u_int32_t wait_cnt_0, wait_Cnt_1;
22238 u_int16_t ocp_reg_mutex_ib;
22239 u_int16_t ocp_reg_mutex_oob;
22240 u_int16_t ocp_reg_mutex_prio;
22241
22242 switch (sc->re_type) {
22243 case MACFG_63:
22244 case MACFG_64:
22245 case MACFG_65:
22246 ocp_reg_mutex_oob = 0x16;
22247 ocp_reg_mutex_ib = 0x17;
22248 ocp_reg_mutex_prio = 0x9C;
22249 break;
22250 case MACFG_66:
22251 ocp_reg_mutex_oob = 0x06;
22252 ocp_reg_mutex_ib = 0x07;
22253 ocp_reg_mutex_prio = 0x9C;
22254 break;
22255 case MACFG_61:
22256 case MACFG_62:
22257 case MACFG_67:
22258 default:
22259 ocp_reg_mutex_oob = 0x110;
22260 ocp_reg_mutex_ib = 0x114;
22261 ocp_reg_mutex_prio = 0x11C;
22262 break;
22263 }
22264
22265 OCP_write(sc, ocp_reg_mutex_ib, 1, BIT_0);
22266 reg_16 = OCP_read(sc, ocp_reg_mutex_oob, 1);
22267 wait_cnt_0 = 0;
22268 while(reg_16) {
22269 reg_a0 = OCP_read(sc, ocp_reg_mutex_prio, 1);
22270 if (reg_a0) {
22271 OCP_write(sc, ocp_reg_mutex_ib, 1, 0x00);
22272 reg_a0 = OCP_read(sc, ocp_reg_mutex_prio, 1);
22273 wait_Cnt_1 = 0;
22274 while(reg_a0) {
22275 reg_a0 = OCP_read(sc, ocp_reg_mutex_prio, 1);
22276
22277 wait_Cnt_1++;
22278
22279 if (wait_Cnt_1 > 2000)
22280 break;
22281 };
22282 OCP_write(sc, ocp_reg_mutex_ib, 1, BIT_0);
22283
22284 }
22285 reg_16 = OCP_read(sc, ocp_reg_mutex_oob, 1);
22286
22287 wait_cnt_0++;
22288
22289 if (wait_cnt_0 > 2000)
22290 break;
22291 };
22292 }
22293
22294 static void OOB_mutex_unlock(struct re_softc *sc)
22295 {
22296 u_int16_t ocp_reg_mutex_ib;
22297 u_int16_t ocp_reg_mutex_oob;
22298 u_int16_t ocp_reg_mutex_prio;
22299
22300 switch (sc->re_type) {
22301 case MACFG_63:
22302 case MACFG_64:
22303 case MACFG_65:
22304 ocp_reg_mutex_oob = 0x16;
22305 ocp_reg_mutex_ib = 0x17;
22306 ocp_reg_mutex_prio = 0x9C;
22307 break;
22308 case MACFG_66:
22309 ocp_reg_mutex_oob = 0x06;
22310 ocp_reg_mutex_ib = 0x07;
22311 ocp_reg_mutex_prio = 0x9C;
22312 break;
22313 case MACFG_61:
22314 case MACFG_62:
22315 case MACFG_67:
22316 default:
22317 ocp_reg_mutex_oob = 0x110;
22318 ocp_reg_mutex_ib = 0x114;
22319 ocp_reg_mutex_prio = 0x11C;
22320 break;
22321 }
22322
22323 OCP_write(sc, ocp_reg_mutex_prio, 1, BIT_0);
22324 OCP_write(sc, ocp_reg_mutex_ib, 1, 0x00);
22325 }
22326
22327 static int re_check_dash(struct re_softc *sc)
22328 {
22329 if (sc->re_type == MACFG_61 || sc->re_type == MACFG_62 ||
22330 sc->re_type == MACFG_67) {
22331 if (OCP_read(sc, 0x128, 1) & BIT_0)
22332 return 1;
22333 else
22334 return 0;
22335 } else {
22336 u_int32_t reg;
22337
22338 if (sc->re_type == MACFG_66)
22339 reg = 0xb8;
22340 else
22341 reg = 0x10;
22342
22343 if (OCP_read(sc, reg, 2) & 0x00008000)
22344 return 1;
22345 else
22346 return 0;
22347 }
22348 }
22349
22350 static void OOB_notify(struct re_softc *sc, u_int8_t cmd)
22351 {
22352 int i;
22353
22354 CSR_WRITE_1(sc, RE_ERIDR, cmd);
22355 CSR_WRITE_4(sc, RE_ERIAR, 0x800010E8);
22356 DELAY(2000);
22357 for (i = 0; i < 5; i++) {
22358 DELAY(100);
22359 if (!(CSR_READ_4(sc, RE_ERIAR) & ERIAR_Flag))
22360 break;
22361 }
22362
22363 OCP_write(sc, 0x30, 1, 0x01);
22364 }
22365
22366 void re_driver_start(struct re_softc *sc)
22367 {
22368 if (sc->re_type == MACFG_61 || sc->re_type == MACFG_62 ||
22369 sc->re_type == MACFG_67) {
22370 u_int32_t tmp_value;
22371
22372 if (!re_check_dash(sc))
22373 return;
22374
22375 OCP_write(sc, 0x180, 1, OOB_CMD_DRIVER_START);
22376 tmp_value = OCP_read(sc, 0x30, 1);
22377 tmp_value |= BIT_0;
22378 OCP_write(sc, 0x30, 1, tmp_value);
22379 } else {
22380 int timeout;
22381 u_int32_t reg;
22382
22383 if (sc->re_type == MACFG_66) {
22384 CSR_WRITE_1(sc, RE_TwiCmdReg, CSR_READ_1(sc, RE_TwiCmdReg) | (BIT_7));
22385 }
22386
22387 OOB_notify(sc, OOB_CMD_DRIVER_START);
22388
22389 if (sc->re_type == MACFG_66)
22390 reg = 0xB8;
22391 else
22392 reg = 0x10;
22393
22394 for (timeout = 0; timeout < 10; timeout++) {
22395 DELAY(10000);
22396 if (OCP_read(sc, reg, 2) & BIT_11)
22397 break;
22398 }
22399 }
22400 }
22401
22402 void re_driver_stop(struct re_softc *sc)
22403 {
22404 if (sc->re_type == MACFG_61 || sc->re_type == MACFG_62 ||
22405 sc->re_type == MACFG_67) {
22406 u_int32_t tmp_value;
22407
22408 if (!re_check_dash(sc))
22409 return;
22410
22411 Dash2DisableTxRx(sc);
22412
22413 OCP_write(sc, 0x180, 1, OOB_CMD_DRIVER_STOP);
22414 tmp_value = OCP_read(sc, 0x30, 1);
22415 tmp_value |= BIT_0;
22416 OCP_write(sc, 0x30, 1, tmp_value);
22417 } else {
22418 int timeout;
22419 u_int32_t reg;
22420
22421 OOB_notify(sc, OOB_CMD_DRIVER_STOP);
22422
22423 if (sc->re_type == MACFG_66)
22424 reg = 0xB8;
22425 else
22426 reg = 0x10;
22427
22428 for (timeout = 0; timeout < 10; timeout++) {
22429 DELAY(10000);
22430 if ((OCP_read(sc, reg, 4) & BIT_11) == 0)
22431 break;
22432 }
22433
22434 if (sc->re_type == MACFG_66) {
22435 CSR_WRITE_1(sc, RE_TwiCmdReg, CSR_READ_1(sc, RE_TwiCmdReg) & ~(BIT_7));
22436 }
22437 }
22438 }
22439
22440 /*----------------------------------------------------------------------------*/
22441 /* 8139 (CR9346) 9346 command register bits (offset 0x50, 1 byte)*/
22442 /*----------------------------------------------------------------------------*/
22443 #define CR9346_EEDO 0x01 /* 9346 data out*/
22444 #define CR9346_EEDI 0x02 /* 9346 data in*/
22445 #define CR9346_EESK 0x04 /* 9346 serial clock*/
22446 #define CR9346_EECS 0x08 /* 9346 chip select*/
22447 #define CR9346_EEM0 0x40 /* select 8139 operating mode*/
22448 #define CR9346_EEM1 0x80 /* 00: normal*/
22449 #define CR9346_CFGRW 0xC0 /* Config register write*/
22450 #define CR9346_NORM 0x00
22451
22452 /*----------------------------------------------------------------------------*/
22453 /* EEPROM bit definitions(EEPROM control register bits)*/
22454 /*----------------------------------------------------------------------------*/
22455 #define EN_TRNF 0x10 /* Enable turnoff*/
22456 #define EEDO CR9346_EEDO /* EEPROM data out*/
22457 #define EEDI CR9346_EEDI /* EEPROM data in (set for writing data)*/
22458 #define EECS CR9346_EECS /* EEPROM chip select (1=high, 0=low)*/
22459 #define EESK CR9346_EESK /* EEPROM shift clock (1=high, 0=low)*/
22460
22461 /*----------------------------------------------------------------------------*/
22462 /* EEPROM opcodes*/
22463 /*----------------------------------------------------------------------------*/
22464 #define EEPROM_READ_OPCODE 06
22465 #define EEPROM_WRITE_OPCODE 05
22466 #define EEPROM_ERASE_OPCODE 07
22467 #define EEPROM_EWEN_OPCODE 19 /* Erase/write enable*/
22468 #define EEPROM_EWDS_OPCODE 16 /* Erase/write disable*/
22469
22470 #define CLOCK_RATE 50 /* us*/
22471
22472 #define RaiseClock(_sc,_x) \
22473 (_x) = (_x) | EESK; \
22474 CSR_WRITE_1((_sc), RE_EECMD, (_x)); \
22475 DELAY(CLOCK_RATE);
22476
22477 #define LowerClock(_sc,_x) \
22478 (_x) = (_x) & ~EESK; \
22479 CSR_WRITE_1((_sc), RE_EECMD, (_x)); \
22480 DELAY(CLOCK_RATE);
22481
22482 /*
22483 * Shift out bit(s) to the EEPROM.
22484 */
22485 static void re_eeprom_ShiftOutBits(struct re_softc *sc, int data, int count)
22486 {
22487 u_int16_t x, mask;
22488
22489 mask = 0x01 << (count - 1);
22490 x = CSR_READ_1(sc, RE_EECMD);
22491
22492 x &= ~(EEDO | EEDI);
22493
22494 do {
22495 x &= ~EEDI;
22496 if (data & mask)
22497 x |= EEDI;
22498
22499 CSR_WRITE_1(sc, RE_EECMD, x);
22500 DELAY(CLOCK_RATE);
22501 RaiseClock(sc,x);
22502 LowerClock(sc,x);
22503 mask = mask >> 1;
22504 } while (mask);
22505
22506 x &= ~EEDI;
22507 CSR_WRITE_1(sc, RE_EECMD, x);
22508 }
22509
22510 /*
22511 * Shift in bit(s) from the EEPROM.
22512 */
22513 static u_int16_t re_eeprom_ShiftInBits(struct re_softc *sc)
22514 {
22515 u_int16_t x,d,i;
22516 x = CSR_READ_1(sc, RE_EECMD);
22517
22518 x &= ~(EEDO | EEDI);
22519 d = 0;
22520
22521 for (i=0; i<16; i++) {
22522 d = d << 1;
22523 RaiseClock(sc, x);
22524
22525 x = CSR_READ_1(sc, RE_EECMD);
22526
22527 x &= ~(EEDI);
22528 if (x & EEDO)
22529 d |= 1;
22530
22531 LowerClock(sc, x);
22532 }
22533
22534 return d;
22535 }
22536
22537 /*
22538 * Clean up EEprom read/write setting
22539 */
22540 static void re_eeprom_EEpromCleanup(struct re_softc *sc)
22541 {
22542 u_int16_t x;
22543 x = CSR_READ_1(sc, RE_EECMD);
22544
22545 x &= ~(EECS | EEDI);
22546 CSR_WRITE_1(sc, RE_EECMD, x);
22547
22548 RaiseClock(sc, x);
22549 LowerClock(sc, x);
22550 }
22551
22552 /*
22553 * Read a word of data stored in the EEPROM at address 'addr.'
22554 */
22555 static void re_eeprom_getword(struct re_softc *sc, int addr, u_int16_t *dest)
22556 {
22557 u_int16_t x;
22558
22559 /* select EEPROM, reset bits, set EECS*/
22560 x = CSR_READ_1(sc, RE_EECMD);
22561
22562 x &= ~(EEDI | EEDO | EESK | CR9346_EEM0);
22563 x |= CR9346_EEM1 | EECS;
22564 CSR_WRITE_1(sc, RE_EECMD, x);
22565
22566 /* write the read opcode and register number in that order*/
22567 /* The opcode is 3bits in length, reg is 6 bits long*/
22568 re_eeprom_ShiftOutBits(sc, EEPROM_READ_OPCODE, 3);
22569
22570 if (CSR_READ_4(sc, RE_RXCFG) & RE_RXCFG_RX_9356SEL)
22571 re_eeprom_ShiftOutBits(sc, addr,8); /*93c56=8*/
22572 else
22573 re_eeprom_ShiftOutBits(sc, addr,6); /*93c46=6*/
22574
22575 /* Now read the data (16 bits) in from the selected EEPROM word*/
22576 *dest=re_eeprom_ShiftInBits(sc);
22577
22578 re_eeprom_EEpromCleanup(sc);
22579 return;
22580 }
22581
22582 /*
22583 * Read a sequence of words from the EEPROM.
22584 */
22585 static void re_read_eeprom(struct re_softc *sc, caddr_t dest, int off, int cnt, int swap)
22586 {
22587 int i;
22588 u_int16_t word = 0, *ptr;
22589
22590 for (i = 0; i < cnt; i++) {
22591 re_eeprom_getword(sc, off + i, &word);
22592 ptr = (u_int16_t *)(dest + (i * 2));
22593 if (swap)
22594 *ptr = ntohs(word);
22595 else
22596 *ptr = word;
22597 }
22598
22599 return;
22600 }
22601
22602 #ifdef __DragonFly__
22603
22604 int
22605 rtl_check_mac_version(struct re_softc *sc)
22606 {
22607
22608 return (re_check_mac_version(sc));
22609 }
22610
22611 void
22612 rtl_init_software_variable(struct re_softc *sc)
22613 {
22614
22615 re_init_software_variable(sc);
22616 }
22617
22618 void
22619 rtl_exit_oob(struct re_softc *sc)
22620 {
22621
22622 re_exit_oob(sc);
22623 }
22624
22625 void
22626 rtl_hw_init(struct re_softc *sc)
22627 {
22628
22629 re_hw_init(sc);
22630 }
22631
22632 void
22633 rtl_reset(struct re_softc *sc)
22634 {
22635
22636 re_reset(sc);
22637 }
22638
22639 void
22640 rtl_get_hw_mac_address(struct re_softc *sc, u_int8_t *eaddr)
22641 {
22642
22643 re_get_hw_mac_address(sc, eaddr);
22644 }
22645
22646 void
22647 rtl_phy_power_up(struct re_softc *sc)
22648 {
22649
22650 re_phy_power_up(sc->dev);
22651 }
22652
22653 void
22654 rtl_hw_phy_config(struct re_softc *sc)
22655 {
22656
22657 re_hw_phy_config(sc);
22658 }
22659
22660 void
22661 rtl_clrwol(struct re_softc *sc)
22662 {
22663
22664 re_clrwol(sc);
22665 }
22666
22667 int
22668 rtl_ifmedia_upd(struct ifnet *ifp)
22669 {
22670
22671 return (re_ifmedia_upd(ifp));
22672 }
22673
22674 void
22675 rtl_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr)
22676 {
22677
22678 re_ifmedia_sts(ifp, ifmr);
22679 }
22680
22681 void
22682 rtl_stop(struct re_softc *sc)
22683 {
22684
22685 re_stop_rtl(sc);
22686 }
22687
22688 u_int8_t
22689 rtl_link_ok(struct re_softc *sc)
22690 {
22691
22692 return (re_link_ok(sc));
22693 }
22694
22695 void
22696 rtl_link_on_patch(struct re_softc *sc)
22697 {
22698
22699 re_link_on_patch(sc);
22700 }
22701
22702 void
22703 rtl_set_eaddr(struct re_softc *sc)
22704 {
22705
22706 re_init_unlock(sc);
22707 }
22708
22709 void
22710 rtl_hw_start(struct re_softc *sc)
22711 {
22712
22713 re_hw_start_unlock(sc);
22714 }
22715
22716 void
22717 rtl_set_rx_packet_filter(struct re_softc *sc)
22718 {
22719
22720 re_set_rx_packet_filter(sc);
22721 }
22722
22723 void
22724 rtl_hw_d3_para(struct re_softc *sc)
22725 {
22726
22727 re_hw_d3_para(sc);
22728 }
22729
22730 void
22731 rtl_phy_power_down(struct re_softc *sc)
22732 {
22733
22734 re_phy_power_down(sc->dev);
22735 }
22736
22737 #endif /* __DragonFly__ */
DragonFly BSD