1 //<MStar Software>
2 //******************************************************************************
3 // MStar Software
4 // Copyright (c) 2010 - 2012 MStar Semiconductor, Inc. All rights reserved.
5 // All software, firmware and related documentation herein ("MStar Software") are
6 // intellectual property of MStar Semiconductor, Inc. ("MStar") and protected by
7 // law, including, but not limited to, copyright law and international treaties.
8 // Any use, modification, reproduction, retransmission, or republication of all
9 // or part of MStar Software is expressly prohibited, unless prior written
10 // permission has been granted by MStar.
11 //
12 // By accessing, browsing and/or using MStar Software, you acknowledge that you
13 // have read, understood, and agree, to be bound by below terms ("Terms") and to
14 // comply with all applicable laws and regulations:
15 //
16 // 1. MStar shall retain any and all right, ownership and interest to MStar
17 // Software and any modification/derivatives thereof.
18 // No right, ownership, or interest to MStar Software and any
19 // modification/derivatives thereof is transferred to you under Terms.
20 //
21 // 2. You understand that MStar Software might include, incorporate or be
22 // supplied together with third party`s software and the use of MStar
23 // Software may require additional licenses from third parties.
24 // Therefore, you hereby agree it is your sole responsibility to separately
25 // obtain any and all third party right and license necessary for your use of
26 // such third party`s software.
27 //
28 // 3. MStar Software and any modification/derivatives thereof shall be deemed as
29 // MStar`s confidential information and you agree to keep MStar`s
30 // confidential information in strictest confidence and not disclose to any
31 // third party.
32 //
33 // 4. MStar Software is provided on an "AS IS" basis without warranties of any
34 // kind. Any warranties are hereby expressly disclaimed by MStar, including
35 // without limitation, any warranties of merchantability, non-infringement of
36 // intellectual property rights, fitness for a particular purpose, error free
37 // and in conformity with any international standard. You agree to waive any
38 // claim against MStar for any loss, damage, cost or expense that you may
39 // incur related to your use of MStar Software.
40 // In no event shall MStar be liable for any direct, indirect, incidental or
41 // consequential damages, including without limitation, lost of profit or
42 // revenues, lost or damage of data, and unauthorized system use.
43 // You agree that this Section 4 shall still apply without being affected
44 // even if MStar Software has been modified by MStar in accordance with your
45 // request or instruction for your use, except otherwise agreed by both
46 // parties in writing.
47 //
48 // 5. If requested, MStar may from time to time provide technical supports or
49 // services in relation with MStar Software to you for your use of
50 // MStar Software in conjunction with your or your customer`s product
51 // ("Services").
52 // You understand and agree that, except otherwise agreed by both parties in
53 // writing, Services are provided on an "AS IS" basis and the warranty
54 // disclaimer set forth in Section 4 above shall apply.
55 //
56 // 6. Nothing contained herein shall be construed as by implication, estoppels
57 // or otherwise:
58 // (a) conferring any license or right to use MStar name, trademark, service
59 // mark, symbol or any other identification;
60 // (b) obligating MStar or any of its affiliates to furnish any person,
61 // including without limitation, you and your customers, any assistance
62 // of any kind whatsoever, or any information; or
63 // (c) conferring any license or right under any intellectual property right.
64 //
65 // 7. These terms shall be governed by and construed in accordance with the laws
66 // of Taiwan, R.O.C., excluding its conflict of law rules.
67 // Any and all dispute arising out hereof or related hereto shall be finally
68 // settled by arbitration referred to the Chinese Arbitration Association,
69 // Taipei in accordance with the ROC Arbitration Law and the Arbitration
70 // Rules of the Association by three (3) arbitrators appointed in accordance
71 // with the said Rules.
72 // The place of arbitration shall be in Taipei, Taiwan and the language shall
73 // be English.
74 // The arbitration award shall be final and binding to both parties.
75 //
76 //******************************************************************************
77 //<MStar Software>
78 ///////////////////////////////////////////////////////////////////////////////
79 //
80 // File name: drvUsbMain.C
81 // Version: 0.1
82 // Date: 2004/9/20
83 // Company: Faraday Tech. Corp.
84 ///////////////////////////////////////////////////////////////////////////////
85 #if defined(MSOS_TYPE_NOS)
86 #include "MsVersion.h"
87 #include "../USBHostConfig.h"
88 #include "../../include/hal_arch.h"
89 #include "../../include/hal_cache.h"
90 //#include <stdlib.h>
91 //#include <stdarg.h>
92 #ifndef ATV_SERISE_USE
93 #include <stdio.h>
94 #endif
95 #include <string.h>
96 //#include "chipset.h"
97 //#include "flib.h"
98 //#include <MsCommon.h>
99 #ifndef ATV_SERISE_USE
100 #include "../../include/datatype.h"
101 #else
102 #include "UsbHostDataDef.h"
103 #endif
104 #include "../drvHostLib.h"
105 #include "../drvHost200.h"
106 #include "../drvUsbMain.h"
107 #ifndef ATV_SERISE_USE
108
109 #endif
110 #include "../../include/_drvUSB.h"
111 #include "../drvscsi.h"
112 #ifdef ATV_SERISE_USE
113 #include "common.h"
114 #include "uart.h"
115 #include "command.h"
116 #endif
117 #ifdef CERAMAL_SERISE_USE
118 #include "drvtimer.h"
119 #include "Board.h"
120 #include "drvUTMI.h"
121 #else
122 #endif
123
124 #ifdef OnePort_OTG_EHCI
125 #include "MsCompiler.h"
126 #include "msusb.h"
127 #include "msDRC.h"
128 #include "msconfig.h"
129 #include "mscpu.h"
130 #include "drvisr.h"
131 #endif
132
133 #include "../../include/drvGlobal.h"
134
135 #include "../drvUSBHost_PTP.h"
136
137 #include "MsCommon.h"
138 #include "MsIRQ.h"
139 #include "MsOS.h"
140 #include "halUSB.h"
141
142 #ifdef DEVICE_ENUM_SEGMENT
143 U8 MDrv_Usb_Device_Enum_EX(void);
144 #endif
145 extern void msAPI_Timer_ResetWDT(void);
146
147 #define DRV_USB_DBG(x) //x;
148 #define MINI_DEBUG(x) //x;
149
150 U8 gUsbStatus=USB_OK;
151 U8 gUsbTimeout=5;
152 U8 gUsbRetryCount=3;
153 U16 gUsbChipID = 0xFFFF;
154 U8 gUsbChipVersion = 0xFF;
155 U8 g_Port0_Switch = 0;
156 BOOLEAN g_Port0_AutoSwitchEnable = TRUE;
157 U8 g_Port0_CurntSwitch = 0;
158 U8 g_Port0_SwithDelay = 0;
159
160 #if 1
161 extern U8 gUsbDeviceState;
162 extern U8 gUsbDeviceState_Port2;
163 #else
164 #ifdef USB_POWER_SAVING_MODE
165 U8 gUsbDeviceState=POWER_SAVING;
166 #ifdef USBHOST2PORT
167 extern U8 gUsbDeviceState_Port2;
168 #endif
169 #else
170 U8 gUsbDeviceState=NO_DEVICE;
171 #endif
172 #endif
173 U8 NowIsHub;
174
175 extern U8 gSpeed;
176 //static U32 original_xdwin1_Base=0xFFFFFFFF; //use 0xFFFFFFFF to represent void
177 static U8 xdwin1_lockCount=0;
178 #if 0
179 U8 code USB_VBuf[32] = {'M', 'S', 'V', 'C', '0', '0', // 0, 0 fixed
180 'Z', '2', // Library ID
181 #ifdef DTV_STANDARD_LIB
182 'A', '0', '0', '1', '4', '8', // build number
183 #endif
184 #ifdef ATV_SERISE_USE
185 'B', '0', '0', '1', '2', '4', // build number
186 #endif
187 #ifdef CERAMAL_SERISE_USE
188 'C', '0', '0', '1', '2', '4', // build number
189 #endif
190
191 '0', '0', '0', '0', '0', '0', '0', '0', // change list 46058
192 'A', '4', 'A', '0', '0', '0', '0', '0', '0',// A4: Saturn, A:LG
193 'T'};
194 #endif
195
196 #define USB_HOST_P1_DRV_VERSION /* Character String for DRV/API version */ \
197 MSIF_TAG, /* 'MSIF' */ \
198 MSIF_CLASS, /* '00' */ \
199 MSIF_CUS, /* 0x0000 */ \
200 MSIF_MOD, /* 0x0000 */ \
201 MSIF_CHIP, \
202 MSIF_CPU, \
203 {'U','S','B','1'}, /* IP__ */ \
204 {'0','2'}, /* 0.0 ~ Z.Z */ \
205 {'1','4'}, /* 00 ~ 99 */ \
206 {'0','0','2','5','9','5','9','0'}, /* CL# */ \
207 MSIF_OS
208
209 static MSIF_Version _drv_usb_host_p1_version = {
210 .DDI = { USB_HOST_P1_DRV_VERSION },
211 };
212
213 #ifdef OnePort_OTG_EHCI
214 U8 USBMode=0; //set default status=OTG device mode ,{default=0, otg=1, uhci=2}
215 extern U8 volatile usbUSBState;
216 #endif
217
218 extern U8 RecoveryFlag;
219 //extern BOOLEAN gDeviceFatalError;
220
221 #ifdef OnePort_OTG_EHCI
222 extern void MDrv_OTG_Init(void);
223 extern U8 usbIsUSBConfiged(void);
224 enum
225 {
226 USBHostMode_disconnect = 0,
227 USBHostMode_connect,
228 USBDeivceMode_disconnect,
229 USBDeivceMode_connect
230 };
231 #endif
232
233 struct stDontReEnumList
234 {
235 U16 VID;
236 U16 PID;
237 };
238
239 struct stDontReEnumList gDontReEnumList[] =
240 {
241 {0x0951, 0x1603},
242 {0x05E3, 0x0718},
243 {0x0BC2, 0xA013},
244
245 {0, 0}
246 };
247
248 BOOLEAN xfirst=FALSE;
249 extern void drvUSBHost_TurnOffPowerDownMode(void);
250 extern void drvUSBHost_TurnOnPowerDownMode(void);
251 extern BOOLEAN drvUSBHost_isPowerSaveModeEnable(void);
252 extern void drvUSBHost_UTMIInitial(void);
253 extern void drvUSBHost_UTMIInitial_Port2(void);
254 extern void UsbTurnOffPowerDownMode(void);
255 extern void UsbTurnOnPowerDownMode(void);
256
257 extern void drvUSBHost_TurnOffPowerDownMode(void);
258 extern void drvUSBHost_TurnOnPowerDownMode(void);
259
260 extern BOOLEAN drvUSBHost_isPort2Enable(void);
261 extern U8 drvUSBHost_PTP_Init(U8 u8UsbPort);
262 extern void XBYTE_OR(U32 Addr, U8 offset, U8 val);
263 extern void XBYTE_AND(U32 Addr, U8 offset,U8 val);
264 extern void XBYTE_SET(U32 Addr, U8 offset,U8 val);
265 extern U8 XBYTE_READ(U32 Addr, U8 offset);
266 extern U8 drvUSBHost_HID_Init(U8 u8UsbPort);
267 extern BOOLEAN Support_HID(void);
268 void MDrv_USBGetVIDPID(U16 *pVID, U16 *pPID);
269
MDrv_USB_Host_GetLibVer(const MSIF_Version ** ppVersion)270 U8 MDrv_USB_Host_GetLibVer(const MSIF_Version **ppVersion)
271 {
272 if(!ppVersion)
273 return 1;
274
275 *ppVersion = &_drv_usb_host_p1_version;
276 return 0;
277 }
278
MDrv_USBGetChipID(void)279 U16 MDrv_USBGetChipID(void)
280 {
281 if (gUsbChipID == 0xFFFF)
282 gUsbChipID = HAL_USB_GetChipID();
283
284 return gUsbChipID;
285 }
286
287 extern MS_U8 MDrv_SYS_GetChipRev(void);
MDrv_USBGetChipVersion(void)288 U8 MDrv_USBGetChipVersion(void)
289 {
290 if (gUsbChipVersion == 0xFF)
291 gUsbChipVersion = MDrv_SYS_GetChipRev();
292
293 return gUsbChipVersion;
294 }
295
MDrv_USBGetPortAutoSwitchStatus(void)296 BOOLEAN MDrv_USBGetPortAutoSwitchStatus(void)
297 {
298 return g_Port0_AutoSwitchEnable;
299 }
300
MDrv_USBSetPortAutoSwitchStatus(BOOLEAN bEnable)301 void MDrv_USBSetPortAutoSwitchStatus(BOOLEAN bEnable)
302 {
303 if ( (CHIPID_MARIA10== MDrv_USBGetChipID()) ||
304 (CHIPID_MACAW12==MDrv_USBGetChipID()) ||
305 (CHIPID_EDEN==MDrv_USBGetChipID()) ||
306 (CHIPID_JANUS2== MDrv_USBGetChipID()) ||
307 (CHIPID_AMBER6== MDrv_USBGetChipID()) ||
308 (CHIPID_EULER== MDrv_USBGetChipID()) )
309 {
310 printf("set USB port auto switch to %d\n", bEnable);
311 g_Port0_AutoSwitchEnable = bEnable;
312 }
313 }
314
MDrv_USBSetPortSwitch(U8 uPort)315 void MDrv_USBSetPortSwitch(U8 uPort)
316 {
317 if ( (CHIPID_MARIA10== MDrv_USBGetChipID()) ||
318 (CHIPID_MACAW12==MDrv_USBGetChipID()) ||
319 (CHIPID_EDEN==MDrv_USBGetChipID()) ||
320 (CHIPID_JANUS2== MDrv_USBGetChipID()) ||
321 (CHIPID_AMBER6== MDrv_USBGetChipID()) ||
322 (CHIPID_EULER== MDrv_USBGetChipID()) )
323 {
324 if (MDrv_USBGetPortAutoSwitchStatus())
325 MDrv_USBSetPortAutoSwitchStatus(FALSE);
326
327 printf("Force to set USB port switch to %d\n", uPort);
328 if (uPort ==0)
329 UTMI_ANDXBYTE(0x38, ~BIT2);
330 else if (uPort ==1)
331 UTMI_ORXBYTE(0x38, BIT2);
332
333 g_Port0_SwithDelay = 3;
334 }
335 }
336
UsbGetVerString(U8 * pVerString)337 void UsbGetVerString(U8 *pVerString)
338 {
339
340 #if 0
341 memcpy(pVerString, &USB_VBuf[0], sizeof(USB_VBuf));
342 #endif
343 }
344
SetUsbTimeout(U8 x)345 void SetUsbTimeout(U8 x)
346 {
347 gUsbTimeout=x;
348 }
349
UTMI_ORXBYTE(U8 offset,U8 val)350 void UTMI_ORXBYTE(U8 offset,U8 val)
351 {
352 XBYTE_OR(gUTMI_BASE, offset, val);
353 }
354
UTMI_ANDXBYTE(U8 offset,U8 val)355 void UTMI_ANDXBYTE(U8 offset,U8 val)
356 {
357 XBYTE_AND(gUTMI_BASE, offset, val);
358 }
359
UTMI_SETXBYTE(U8 offset,U8 val)360 void UTMI_SETXBYTE(U8 offset,U8 val)
361 {
362 XBYTE_SET(gUTMI_BASE, offset, val);
363 }
364
UTMI_READXBYTE(U8 offset)365 U8 UTMI_READXBYTE(U8 offset)
366 {
367 return XBYTE_READ(gUTMI_BASE, offset);
368 }
369
UHC_ORXBYTE(U8 offset,U8 val)370 void UHC_ORXBYTE(U8 offset,U8 val)
371 {
372 XBYTE_OR(gUHC_BASE, offset, val);
373 }
374
UHC_ANDXBYTE(U8 offset,U8 val)375 void UHC_ANDXBYTE(U8 offset,U8 val)
376 {
377 XBYTE_AND(gUHC_BASE, offset, val);
378 }
379
UHC_SETXBYTE(U8 offset,U8 val)380 void UHC_SETXBYTE(U8 offset,U8 val)
381 {
382 XBYTE_SET(gUHC_BASE, offset, val);
383 }
384
UHC_READXBYTE(U8 offset)385 U8 UHC_READXBYTE(U8 offset)
386 {
387 return XBYTE_READ(gUHC_BASE, offset);
388 }
389
USBC_ORXBYTE(U8 offset,U8 val)390 void USBC_ORXBYTE(U8 offset,U8 val)
391 {
392 XBYTE_OR(gUSBC_BASE, offset, val);
393 }
394
USBC_ANDXBYTE(U8 offset,U8 val)395 void USBC_ANDXBYTE(U8 offset,U8 val)
396 {
397 XBYTE_AND(gUSBC_BASE, offset, val);
398 }
399
USBC_SETXBYTE(U8 offset,U8 val)400 void USBC_SETXBYTE(U8 offset,U8 val)
401 {
402 XBYTE_SET(gUSBC_BASE, offset, val);
403 }
404
USBC_READXBYTE(U8 offset)405 U8 USBC_READXBYTE(U8 offset)
406 {
407 return XBYTE_READ(gUSBC_BASE, offset);
408 }
409
410 #if defined(Enable_Performance_Read_Test) ||\
411 defined(Enable_Performance_Write_Test)
412 #define TEST_SIZE_TOTAL (1024*1024*1024) //1GB, multiple of sector (512)
413 #define TEST_SIZE_PER_LOOP (128*1024) //128KB, multiple of sector (512)
414 static U8 rw_buf[TEST_SIZE_PER_LOOP] __attribute__ ((aligned (8)));
415 #endif
416
417 #ifdef Enable_Performance_Read_Test
UsbPerformanceReadTest(void)418 void UsbPerformanceReadTest(void)
419 {
420 U32 idx=0,xxx;
421 U8 VailLun,LunIndex=0;
422 UINT32 StartTime, EndTime;
423
424 printf("\n USB Performance Read Test\n");
425 printf("rw_buf: %x\n", (UINT)rw_buf);
426
427 VailLun=MDrv_GET_MASS_VALID_LUN();
428 printf("VailLun: %d\n", VailLun);
429
430 switch (VailLun)
431 {
432 case 0x01:
433 LunIndex=0;
434 break;
435 case 0x02:
436 LunIndex=1;
437 break;
438 case 0x04:
439 LunIndex=2;
440 break;
441 case 0x08:
442 LunIndex=3;
443 break;
444 case 0x10:
445 LunIndex=4;
446 break;
447 case 0x20:
448 LunIndex=5;
449 break;
450 case 0x40:
451 LunIndex=6;
452 break;
453 case 0x80:
454 LunIndex=7;
455 break;
456 }
457
458 printf("gSpeed: %d\n", gSpeed);
459
460 StartTime = MsOS_GetSystemTime();
461
462 while (1)
463 {
464 idx++;
465 xxx=idx % 10000;
466
467 if (MDrv_UsbBlockReadToMIU(LunIndex,50+xxx, TEST_SIZE_PER_LOOP>>9, (U32)VirtoPhyAddr(rw_buf))==FALSE)
468 {
469 printf("\n read failed\n");
470 break;
471 }
472
473 if(idx == TEST_SIZE_TOTAL/TEST_SIZE_PER_LOOP)
474 {
475 EndTime = MsOS_GetSystemTime();
476 printf("total bytes transfer: %x B\n", TEST_SIZE_TOTAL);
477 printf("star time %lu -- end time %lu -- spend time %lu\n", StartTime, EndTime, EndTime - StartTime);
478 printf("==> Read Performance: %d MB/s\n", (int)(((TEST_SIZE_TOTAL)/((EndTime - StartTime)/1000))/(1024*1024)));
479 break;
480 }
481 }
482 }
483 #endif
484
485 #ifdef Enable_Performance_Write_Test
UsbPerformanceWriteTest(void)486 void UsbPerformanceWriteTest(void)
487 {
488 U32 i, idx=0,xxx;
489 U8 VailLun,LunIndex=0;
490 UINT32 StartTime, EndTime;
491
492 printf("\n USB Performance Write Test\n");
493 printf("rw_buf: %x\n", (UINT)rw_buf);
494
495 VailLun=MDrv_GET_MASS_VALID_LUN();
496 printf("VailLun: %d\n", VailLun);
497
498 switch (VailLun)
499 {
500 case 0x01:
501 LunIndex=0;
502 break;
503 case 0x02:
504 LunIndex=1;
505 break;
506 case 0x04:
507 LunIndex=2;
508 break;
509 case 0x08:
510 LunIndex=3;
511 break;
512 case 0x10:
513 LunIndex=4;
514 break;
515 case 0x20:
516 LunIndex=5;
517 break;
518 case 0x40:
519 LunIndex=6;
520 break;
521 case 0x80:
522 LunIndex=7;
523 break;
524 }
525
526 printf("gSpeed: %d\n", gSpeed);
527
528 for (i=0 ; i < TEST_SIZE_PER_LOOP; i++)
529 {
530 rw_buf[i]= (i & 0xff);
531 }
532
533 StartTime = MsOS_GetSystemTime();
534
535 while (1)
536 {
537 idx++;
538 xxx=idx % 10000;
539
540 if (MDrv_UsbBlockWriteFromMIU(LunIndex,50+xxx, TEST_SIZE_PER_LOOP>>9, (U32)VirtoPhyAddr(rw_buf))==FALSE)
541 {
542 printf("\n write failed\n");
543 break;
544 }
545
546 if(idx == TEST_SIZE_TOTAL/TEST_SIZE_PER_LOOP)
547 {
548 EndTime = MsOS_GetSystemTime();
549 printf("total bytes transfer: %x B\n", TEST_SIZE_TOTAL);
550 printf("star time %lu -- end time %lu -- spend time %lu\n", StartTime, EndTime, EndTime - StartTime);
551 printf("==> Write Performance: %d MB/s\n", (int)(((TEST_SIZE_TOTAL)/((EndTime - StartTime)/1000))/(1024*1024)));
552 break;
553 }
554 }
555 }
556 #endif
557
558 #ifdef Enable_Burning_Test
559 U8 buf1[512];
560 #if 0
561 // UsbTest for Performance test
562 U8 buf1[16384];
563 void UsbTest(void)
564 {
565 U16 i,j;
566 U32 idx=0,xxx;
567 U8 VailLun,LunIndex=0;
568 U8 /**buf1,*/ *PTestBuf;
569 U32 StartTime, EndTime;
570 U32 uTransLen;
571
572 printf("\r\n USB Transfer Test\n",0);
573
574 // buf1 = (U8*) msAPI_Memory_Allocate(65536, BUF_ID_USB_HOST );
575 printf("buf1: %X\n", buf1);
576 PTestBuf = KSEG02KSEG1(buf1);
577
578 VailLun=MDrv_GET_MASS_VALID_LUN();
579 printf("VailLun: %bd\n", VailLun);
580 switch (VailLun)
581 {
582 case 0x01:
583 LunIndex=0;
584 break;
585 case 0x02:
586 LunIndex=1;
587 break;
588 case 0x04:
589 LunIndex=2;
590 break;
591 case 0x08:
592 LunIndex=3;
593 break;
594 case 0x10:
595 LunIndex=4;
596 break;
597 case 0x20:
598 LunIndex=5;
599 break;
600 case 0x40:
601 LunIndex=6;
602 break;
603 case 0x80:
604 LunIndex=7;
605 break;
606 }
607
608 //printf("buf1 real addr: 0x%X\n", buf1);
609 //printf("\r\n addr=%x",(VirtoPhyAddr((U32)buf1)>>16));
610 //printf(",%x\n",(VirtoPhyAddr((U32)buf1)));
611 printf("gSpeed: %bd\n", gSpeed);
612
613 idx = 0;
614 uTransLen = 10*1024*1024;
615 StartTime = MsOS_GetSystemTime();
616 while (uTransLen > 0)
617 {
618 #ifndef CERAMAL_SERISE_USE
619 msAPI_Timer_ResetWDT();
620 #endif
621
622 if (MDrv_UsbBlockWriteFromMIU(LunIndex,idx,32,(U32)PTestBuf)==FALSE)
623 {
624 printf("\r\n write failed\n",0);
625 break;
626 }
627
628 idx+=32;
629 uTransLen -= 32*512;
630 }
631 EndTime = MsOS_GetSystemTime();
632 printf("Time to wirte 10MB is %d ms\n", EndTime-StartTime);
633
634 idx = 0;
635 uTransLen = 10*1024*1024;
636 StartTime = MsOS_GetSystemTime();
637 while (uTransLen > 0)
638 {
639 #ifndef CERAMAL_SERISE_USE
640 msAPI_Timer_ResetWDT();
641 #endif
642
643 if (MDrv_UsbBlockReadToMIU(LunIndex,idx,32,(U32)PTestBuf)==FALSE)
644 {
645 printf("\r\n read failed\n",0);
646 break;
647 }
648
649 idx+=32;
650 uTransLen -= 32*512;
651 }
652 EndTime = MsOS_GetSystemTime();
653 printf("Time to Read 10MB is %d ms\n", EndTime-StartTime);
654
655 //msAPI_Memory_Free((void*)buf1,BUF_ID_USB_HOST);
656 }
657 #else
UsbTest(void)658 void UsbTest(void)
659 {
660 U16 i,j;
661 U32 idx=0,xxx;
662 U8 VailLun,LunIndex=0;
663 //U8 *buf1;
664
665 printf("\r\n USB Burning Test\n");
666 //printf("maxlun :%02bx lunbyte:%02bx\n",maxlun,lunbyte);
667 //MDrv_UsbHost_Init();
668
669 //buf1 = (U8*) msAPI_Memory_Allocate(0x200, BUF_ID_USB_HOST );
670 printf("buf1: %x\n", (UINT)buf1);
671
672 VailLun=MDrv_GET_MASS_VALID_LUN();
673 printf("VailLun: %d\n", VailLun);
674 switch (VailLun)
675 {
676 case 0x01:
677 LunIndex=0;
678 break;
679 case 0x02:
680 LunIndex=1;
681 break;
682 case 0x04:
683 LunIndex=2;
684 break;
685 case 0x08:
686 LunIndex=3;
687 break;
688 case 0x10:
689 LunIndex=4;
690 break;
691 case 0x20:
692 LunIndex=5;
693 break;
694 case 0x40:
695 LunIndex=6;
696 break;
697 case 0x80:
698 LunIndex=7;
699 break;
700 }
701
702 //printf("buf1 real addr: 0x%X\n", buf1);
703 //printf("\r\n addr=%x",(VirtoPhyAddr((U32)buf1)>>16));
704 //printf(",%x\n",(VirtoPhyAddr((U32)buf1)));
705 printf("gSpeed: %d\n", gSpeed);
706
707 while (1)
708 {
709 #ifndef CERAMAL_SERISE_USE
710 msAPI_Timer_ResetWDT();
711 #endif
712
713 for (i=0 ; i < 0x200 ; i++)
714 {
715 buf1[i]= (i & 0xff);
716 }
717
718 idx++;
719 //if ((idx & 0x3f)==0)
720 {
721 printf("\r\n Loop:%x",(U16)(idx>>16));
722 printf(",%x",(U16)(idx));
723 }
724 //MDrv_MIU_Copy
725 xxx=idx % 10000;
726 if (MDrv_UsbBlockWriteFromMIU(LunIndex,50+xxx,1,(U32)VirtoPhyAddr(buf1))==FALSE)
727 {
728 printf("\r\n write failed\n");
729 break;
730 }
731 if (MDrv_UsbBlockReadToMIU(LunIndex,50+xxx,1,(U32)VirtoPhyAddr(buf1))==FALSE)
732 {
733 printf("\r\n read failed\n");
734 break;
735 }
736 //MsOS_DelayTask(10);
737 for (j=0 ; j < 0x200 ; j++)
738 {
739 if (buf1[j]!= (j&0xff))
740 {
741 printf("\r\n LBA:%d data error\n", (U16)(50+xxx));
742 while(1);
743 }
744 }
745 MsOS_DelayTask(5);
746 }
747
748 //msAPI_Memory_Free((void*)buf1,BUF_ID_USB_HOST);
749 }
750 #endif
751 #endif
752 #if 0
753 U8 MDrv_UsbGetInterfaceClass(U8 i,U8 j)
754 {
755 U8 tmp;
756 #ifdef USE_XDATA_ADDRESS_0XF000
757 MDrv_USB_SetXdataWindow1();
758 #endif
759 tmp=sAttachDevice.saCD[i].sInterface[j].bInterfaceClass;
760 #ifdef USE_XDATA_ADDRESS_0XF000
761 MDrv_USB_ReleaseXdataWindow1();
762 #endif
763
764 return tmp;
765 }
766 #endif
767
768 //====================================================================
769 // * Function Name: main
770 // * Description:
771 // * Input:
772 // * OutPut:
773 //====================================================================
774 #ifndef DEVICE_ENUM_SEGMENT
MDrv_UsbHost_Init(void)775 BOOLEAN MDrv_UsbHost_Init(void)
776 {
777 BOOLEAN result=FALSE;
778
779 DRV_USB_DBG(printf("HOST200_main\n"));
780 xfirst=TRUE;
781
782 MINI_DEBUG(printf("uinit\n"));
783 if (gUsbStatus==USB_EJECT)
784 {
785 //printf("2430:%02bx\n",XBYTE[0x2430]);
786 if (UHC_READXBYTE(0x30)&2) //device connect
787 {
788 gUsbStatus=USB_OK;
789 }
790 else
791 return FALSE; //eject state
792 }
793
794
795 UTMI_ORXBYTE(0x06,0x40); //Force HS TX current enable and CDR stage select
796 UTMI_ANDXBYTE(0x06,~0x20); //clear bit 5
797 if (MDrv_USBGetChipID() == CHIPID_EMERALD)
798 UTMI_ORXBYTE(0x06, 0x04); //Force HS TX current source enable, for MHL noise issue, for Emerald only
799
800 UTMI_ORXBYTE(0x06,0x03); //reset UTMI
801 MsOS_DelayTask(2);
802 UTMI_ANDXBYTE(0x06,0xfc);
803 if ( (MDrv_USBGetChipID() == CHIPID_NEPTUNE) ||
804 (MDrv_USBGetChipID() == CHIPID_ERIS) ||
805 (MDrv_USBGetChipID() == CHIPID_TITANIA) ||
806 (MDrv_USBGetChipID() == CHIPID_PLUTO) ||
807 (MDrv_USBGetChipID() == CHIPID_TRITON) ||
808 (MDrv_USBGetChipID() == CHIPID_TITANIA2) )
809 {
810 UTMI_SETXBYTE(0x29,0x08);
811 }
812 else if (MDrv_USBGetChipID()==CHIPID_EUCLID) // Euclid
813 {
814 UTMI_ANDXBYTE(0x29,0xF7); //disable full speed retime
815 }
816
817 #if defined(Enable_Issue_TestPacket) && !defined(ENABLE_HOST_TEST)
818 UTMI_SETXBYTE(0x03,0); //for device disconnect status bit
819 #else
820 UTMI_SETXBYTE(0x03,0xa8); //for device disconnect status bit
821 #endif
822 //XBYTE[gUTMI_BASE+0x07]|=0x02; //
823 #ifdef DTV_STANDARD_LIB
824 if (MDrv_USBGetChipID()==CHIPID_NEPTUNE) //Neptune , after U06
825 {
826 if (MDrv_USBGetChipVersion()>= 0x6) //U07
827 {
828 UTMI_ORXBYTE(0x07, 0x02);
829 UTMI_SETXBYTE(0x2c,0xc1);
830 UTMI_SETXBYTE(0x2d,0x3b);//enable TX common mode,
831 UTMI_ORXBYTE(0x2f, 0x0e); //preemsis
832 }
833 }
834 else if ((MDrv_USBGetChipID()>=CHIPID_ERIS)&&(MDrv_USBGetChipID()<=CHIPID_TITANIA)) //Eris: 3 ,Titania: 4,
835 {
836 UTMI_SETXBYTE(0x2c,0xc5);
837 UTMI_SETXBYTE(0x2d,0x3b);//enable TX common mode,
838 UTMI_ORXBYTE(0x2f, 0x0e); //preemsis
839 }
840 else if (MDrv_USBGetChipID()==CHIPID_PLUTO) // Pluto: 5
841 {
842 UTMI_ORXBYTE(0x2c, 0xc5);
843 UTMI_ORXBYTE(0x2d, 0x3);//enable TX common mode,
844 UTMI_ORXBYTE(0x2f, 0x4a); //preemsis
845 UTMI_ORXBYTE(0x13, 0x70);
846 }
847 else if (MDrv_USBGetChipID()==CHIPID_TITANIA2) // Titania 2
848 {
849 UTMI_ORXBYTE(0x2c, 0xc1);
850 UTMI_ORXBYTE(0x2d, 0x3);//enable TX common mode,
851 UTMI_ORXBYTE(0x2f, 0x4a); //preemsis
852 }
853 else if (MDrv_USBGetChipID()==CHIPID_TRITON) //Triton=6
854 {
855 UTMI_SETXBYTE(0x2c,0xc1);
856 UTMI_SETXBYTE(0x2d,0x3b);//enable TX common mode,
857 UTMI_ORXBYTE(0x2f,0x0e); //preemsis
858 }
859 else if (MDrv_USBGetChipID()==CHIPID_EUCLID) // Euclid
860 {
861 UTMI_ORXBYTE(0x2c, 0xc1);
862 UTMI_ORXBYTE(0x2d, 0x3);//enable TX common mode,
863 UTMI_ORXBYTE(0x2f, 0x4a); //preemsis
864 }
865 else if ( (MDrv_USBGetChipID()==CHIPID_TITANIA3) || // Titania 3, Titania 4
866 (MDrv_USBGetChipID()==CHIPID_TITANIA4) ||
867 (MDrv_USBGetChipID()==CHIPID_TITANIA7) ||
868 (MDrv_USBGetChipID()==CHIPID_TITANIA8) ||
869 (MDrv_USBGetChipID()==CHIPID_TITANIA9) ||
870 (MDrv_USBGetChipID()==CHIPID_TITANIA12) ||
871 (MDrv_USBGetChipID()==CHIPID_TITANIA13) ||
872 (MDrv_USBGetChipID()==CHIPID_JANUS) ||
873 (MDrv_USBGetChipID() == CHIPID_MARIA10) ||
874 (MDrv_USBGetChipID() == CHIPID_JANUS2) ||
875 (MDrv_USBGetChipID() == CHIPID_AMBER6) )
876 {
877 UTMI_ORXBYTE(0x2c, 0x10); //TX-current adjust to 105%
878 UTMI_ORXBYTE(0x2d, 0x02); //Pre-emphasis enable
879 UTMI_ORXBYTE(0x2f, 0x81); //HS_TX common mode current enable (100mV);Pre-emphasis enable (10%)
880 UTMI_ORXBYTE(0x09,0x81); //UTMI RX anti-dead-lock, ISI improvement
881 }
882 else if( (MDrv_USBGetChipID() == CHIPID_MACAW12) )
883 {
884 //PreEmphasis +40%, CM +20%
885 UTMI_ORXBYTE(0x2c, 0x90);
886 UTMI_ORXBYTE(0x2d, 0x03);
887 UTMI_ORXBYTE(0x2f, 0x81);
888 UTMI_ORXBYTE(0x09,0x81); //UTMI RX anti-dead-lock, ISI improvement
889 }
890 else if ( (MDrv_USBGetChipID()==CHIPID_AMBER1) ||
891 (MDrv_USBGetChipID()==CHIPID_AMBER5) ||
892 (MDrv_USBGetChipID()==CHIPID_AMBER7) ||
893 (MDrv_USBGetChipID()==CHIPID_AMBER3) ||
894 (MDrv_USBGetChipID()==CHIPID_AMETHYST) ||
895 (MDrv_USBGetChipID()==CHIPID_EAGLE))
896 {
897 //for Amber1 later 40nm before Agate
898 UTMI_ORXBYTE(0x2c, 0x98);
899 UTMI_ORXBYTE(0x2d, 0x02);
900 UTMI_ORXBYTE(0x2e, 0x10);
901 UTMI_ORXBYTE(0x2f, 0x01);
902 UTMI_ORXBYTE(0x09,0x81); //UTMI RX anti-dead-lock, ISI improvement
903 }
904 else if ( (MDrv_USBGetChipID() == CHIPID_EDISON) ||
905 (MDrv_USBGetChipID() == CHIPID_EIFFEL) )
906 {
907 //for Agate later 40nm, same as 55nm setting2
908 UTMI_ORXBYTE(0x2c, 0x90); //TX-current adjust to 105%
909 UTMI_ORXBYTE(0x2d, 0x02); //Pre-emphasis enable
910 UTMI_ORXBYTE(0x2f, 0x81); //HS_TX common mode current enable (100mV);Pre-emphasis enable (10%)
911 UTMI_ORXBYTE(0x09,0x81); //UTMI RX anti-dead-lock, ISI improvement
912 }
913 else //for Agate later 40nm, same as 55nm setting1
914 {
915 UTMI_ORXBYTE(0x2c, 0x10); //TX-current adjust to 105%
916 UTMI_ORXBYTE(0x2d, 0x02); //Pre-emphasis enable
917 UTMI_ORXBYTE(0x2f, 0x81); //HS_TX common mode current enable (100mV);Pre-emphasis enable (10%)
918 UTMI_ORXBYTE(0x09,0x81); //UTMI RX anti-dead-lock, ISI improvement
919 }
920 #endif
921
922 if ( (MDrv_USBGetChipID() == CHIPID_EIFFEL) )
923 UTMI_ANDXBYTE(0x08, ~0x08); //Special setting for Eiffel analog LIB issue
924 else
925 {
926 //for Edison later 240M clock enhance, early chip will ignore this 2 bits
927 UTMI_ORXBYTE(0x08,0x08); //bit<3> for 240's phase as 120's clock set 1, bit<4> for 240Mhz in mac 0 for faraday 1 for etron
928 }
929
930 /* Enable Cross Point ECO 2012/03/20 */
931 if ((MDrv_USBGetChipID() == CHIPID_MACAW12) ||
932 (MDrv_USBGetChipID() == CHIPID_EDEN) ||
933 (MDrv_USBGetChipID() == CHIPID_ELK) ||
934 (MDrv_USBGetChipID() == CHIPID_AMBER5) ||
935 (MDrv_USBGetChipID() == CHIPID_EAGLE) ||
936 (MDrv_USBGetChipID() == CHIPID_EMERALD) ||
937 (MDrv_USBGetChipID() == CHIPID_EDISON) ||
938 (MDrv_USBGetChipID() == CHIPID_AGATE) ||
939 (MDrv_USBGetChipID() == CHIPID_EULER))
940 {
941 UTMI_ORXBYTE(0x04,0x40); //deglitch SE0 (low-speed cross point)
942 }
943 else if((MDrv_USBGetChipID() == CHIPID_JANUS2))
944 {
945 UTMI_ORXBYTE(0x0a,0x80); //deglitch SE0 (low-speed cross point)
946 }
947
948 /* Enable Power Noice ECO 2012/03/20 */
949 if ((MDrv_USBGetChipID() == CHIPID_JANUS2) ||
950 (MDrv_USBGetChipID() == CHIPID_MACAW12) ||
951 (MDrv_USBGetChipID() == CHIPID_EDEN) ||
952 (MDrv_USBGetChipID() == CHIPID_ELK) ||
953 (MDrv_USBGetChipID() == CHIPID_AMBER5) ||
954 (MDrv_USBGetChipID() == CHIPID_EAGLE) ||
955 (MDrv_USBGetChipID() == CHIPID_EMERALD) ||
956 (MDrv_USBGetChipID() == CHIPID_EDISON) ||
957 (MDrv_USBGetChipID() == CHIPID_AGATE))
958 {
959 USBC_ORXBYTE(0x02,0x40); //use eof2 to reset state machine (power noise)
960 }
961
962 /* Enable Tx/Rx Reset Clock Gatting ECO 2012/03/27 */
963 if((MDrv_USBGetChipID() == CHIPID_ELK) ||
964 (MDrv_USBGetChipID() == CHIPID_AMBER5) ||
965 (MDrv_USBGetChipID() == CHIPID_EAGLE) ||
966 (MDrv_USBGetChipID() == CHIPID_EMERALD) ||
967 (MDrv_USBGetChipID() == CHIPID_EDISON) ||
968 (MDrv_USBGetChipID() == CHIPID_AGATE) ||
969 (MDrv_USBGetChipID() == CHIPID_EDEN) ||
970 (MDrv_USBGetChipID() == CHIPID_EULER))
971 {
972 UTMI_ORXBYTE(0x04,0x20); //hw auto deassert sw reset (tx/rx reset)
973 }
974
975 /* enable patch for the assertion of interrupt(Lose short packet interrupt) 2012/03/28 */
976 if((MDrv_USBGetChipID() == CHIPID_AMBER5) ||
977 (MDrv_USBGetChipID() == CHIPID_AGATE))
978 {
979 USBC_ORXBYTE(0x04,0x80); //patch for the assertion of interrupt
980 }
981
982 /* enable add patch to Period_EOF1(babble problem) 2012/03/28 */
983 if((MDrv_USBGetChipID() == CHIPID_AMBER5) ||
984 (MDrv_USBGetChipID() == CHIPID_AGATE))
985 {
986 USBC_ORXBYTE(0x04,0x40); //add patch to Period_EOF1
987 }
988
989 /* enable eco for short packet MDATA 2012/07/05 */
990 if((MDrv_USBGetChipID() == CHIPID_EDISON) ||
991 (MDrv_USBGetChipID() == CHIPID_EMERALD))
992 {
993 USBC_ORXBYTE(0x00,0x10); //short packet MDATA in Split transaction clears ACT bit (LS dev under a HS hub)
994 }
995
996 /* enable eco for pv2mi bridge mis-behavior 2012/12/05 */
997 if((MDrv_USBGetChipID() == CHIPID_EDEN) ||
998 (MDrv_USBGetChipID() == CHIPID_EULER) ||
999 (MDrv_USBGetChipID() == CHIPID_EINSTEIN) ||
1000 (MDrv_USBGetChipID() == CHIPID_NAPOLI)||
1001 (MDrv_USBGetChipID() == CHIPID_MIAMI))
1002 {
1003 USBC_ORXBYTE(0x0A,0x40); //fix pv2mi bridge mis-behavior
1004 }
1005
1006 if (MDrv_USBGetChipID()==CHIPID_PLUTO) // If is Pluto
1007 UTMI_ORXBYTE(0x09,0x01); //ISI improvement
1008 else
1009 UTMI_ORXBYTE(0x13,0x02); //ISI improvement
1010
1011 if ( (MDrv_USBGetChipID() == CHIPID_NEPTUNE) ||
1012 (MDrv_USBGetChipID() == CHIPID_ERIS) ||
1013 (MDrv_USBGetChipID() == CHIPID_TITANIA) ||
1014 (MDrv_USBGetChipID() == CHIPID_PLUTO) ||
1015 (MDrv_USBGetChipID() == CHIPID_TRITON) ||
1016 (MDrv_USBGetChipID() == CHIPID_TITANIA2) )
1017 {
1018 }
1019 else
1020 {
1021 UTMI_ORXBYTE(0x0b, 0x80); //TX timing select latch path
1022 }
1023
1024 if (MDrv_USBGetChipID()==CHIPID_EUCLID) // Euclid
1025 {
1026 UTMI_SETXBYTE(0x09,0x81);//0x20; //patch low tempture,FL meta issue and enable new FL RX engin
1027 }
1028 else
1029 {
1030 UTMI_ORXBYTE(0x09,0x60);//0x20; //patch low tempture,FL meta issue and enable new FL RX engin
1031 }
1032
1033 DRV_USB_DBG(printf("Host: %X\n", mwOTG20_Control_HOST_SPD_TYP_Rd()));
1034 if (mwOTG20_Control_HOST_SPD_TYP_Rd()==1) //low speed,for HID
1035 UTMI_ANDXBYTE(0x09,~0x40); //old setting
1036
1037 if ( (MDrv_USBGetChipID() == CHIPID_NEPTUNE) ||
1038 (MDrv_USBGetChipID() == CHIPID_ERIS) ||
1039 (MDrv_USBGetChipID() == CHIPID_TITANIA) ||
1040 (MDrv_USBGetChipID() == CHIPID_PLUTO) ||
1041 (MDrv_USBGetChipID() == CHIPID_TRITON) ||
1042 (MDrv_USBGetChipID() == CHIPID_TITANIA2) )
1043 {
1044 UTMI_ANDXBYTE(0x27,0xf3);
1045 UTMI_ORXBYTE(0x27,0x08); //(1) Offset 27 (��h3AA7) bit <3:2> set 2��b10 // RX bias current => 60uA (default 40uA)
1046
1047 //(2) Offset 2A (��h3AAA) bit <3:2> set 2��b11 // Squelch voltage => 100mV (default 150mV)
1048 #ifdef DTV_STANDARD_LIB
1049 UTMI_SETXBYTE(0x2a,0x07);
1050 #endif
1051 }
1052
1053 if ( (MDrv_USBGetChipID() == CHIPID_NEPTUNE) ||
1054 (MDrv_USBGetChipID() == CHIPID_ERIS) ||
1055 (MDrv_USBGetChipID() == CHIPID_TITANIA) ||
1056 (MDrv_USBGetChipID() == CHIPID_PLUTO) ||
1057 (MDrv_USBGetChipID() == CHIPID_TRITON) ||
1058 (MDrv_USBGetChipID() == CHIPID_TITANIA2) ||
1059 (MDrv_USBGetChipID() == CHIPID_TITANIA3) ||
1060 (MDrv_USBGetChipID() == CHIPID_TITANIA4) ||
1061 (MDrv_USBGetChipID() == CHIPID_TITANIA7) ||
1062 (MDrv_USBGetChipID() == CHIPID_TITANIA8) ||
1063 (MDrv_USBGetChipID() == CHIPID_TITANIA9) ||
1064 (MDrv_USBGetChipID() == CHIPID_TITANIA12) ||
1065 (MDrv_USBGetChipID() == CHIPID_TITANIA13) ||
1066 (MDrv_USBGetChipID() == CHIPID_JANUS) ||
1067 (MDrv_USBGetChipID() == CHIPID_MARIA10) ||
1068 (MDrv_USBGetChipID() == CHIPID_MACAW12) ||
1069 (MDrv_USBGetChipID() == CHIPID_JANUS2) ||
1070 (MDrv_USBGetChipID() == CHIPID_AMBER1) ||
1071 (MDrv_USBGetChipID() == CHIPID_AMBER3) ||
1072 (MDrv_USBGetChipID() == CHIPID_AMBER5) ||
1073 (MDrv_USBGetChipID() == CHIPID_AMBER6) ||
1074 (MDrv_USBGetChipID() == CHIPID_AMBER7) ||
1075 (MDrv_USBGetChipID() == CHIPID_AMETHYST) )
1076 {
1077 UTMI_ORXBYTE(0x15,0x20); //HOST CHIRP Detect
1078 }
1079 else
1080 {
1081 UTMI_ORXBYTE(0x15,0x60); // change to 55 interface (bit6)
1082 }
1083
1084 //(3) Offset 2D (��h3AAD) bit <5:3> set 3��b111 // HS_RTERM bias current 5/6
1085 //XBYTE[0x128a]=0x87; //change UHC priority
1086 //XBYTE[0x128d]&=0x0f; //clear bit 12~15
1087 //XBYTE[0x128e]|=0xf; //upgrade UHC priority, set bit 0~3
1088 MsOS_DelayTask(USB_HOST_INIT_DELAY);
1089
1090
1091 //MDrv_Sys_SetXdataWindow1Base(USB_BUFFER_START_ADR_4K_ALIGN>>12); //switch window 1
1092 gUsbStatus=USB_OK;
1093 // gUsbTimeout=3; //set at flib_Host20_Enumerate()
1094 RecoveryFlag=0; //initialize recovery flag
1095 gUsbDeviceState=USB11_DEVICE; //1.1 at first
1096
1097 //gDeviceFatalError=FALSE;
1098 if(flib_OTGH_Init(0))
1099 result =TRUE;
1100
1101 return result;
1102
1103 }
1104 #else // support device enumeration dividable
_MDrv_UsbHost_Init0(void)1105 BOOLEAN _MDrv_UsbHost_Init0(void)
1106 {
1107 //BOOLEAN result=FALSE;
1108
1109 DRV_USB_DBG(printf("HOST200_main\n"));
1110 xfirst=TRUE;
1111
1112 MINI_DEBUG(printf("uinit\n"));
1113 if (gUsbStatus==USB_EJECT)
1114 {
1115 //printf("2430:%02bx\n",XBYTE[0x2430]);
1116 if (UHC_READXBYTE(0x30)&2) //device connect
1117 {
1118 gUsbStatus=USB_OK;
1119 }
1120 else
1121 return FALSE; //eject state
1122 }
1123
1124
1125 UTMI_ORXBYTE(0x06,0x40); //Force HS TX current enable and CDR stage select
1126 UTMI_ANDXBYTE(0x06,~0x20); //clear bit 5
1127 if (MDrv_USBGetChipID() == CHIPID_EMERALD)
1128 UTMI_ORXBYTE(0x06, 0x04); //Force HS TX current source enable, for MHL noise issue, for Emerald only
1129
1130 UTMI_ORXBYTE(0x06,0x03); //reset UTMI
1131 MsOS_DelayTask(2);
1132 UTMI_ANDXBYTE(0x06,0xfc);
1133
1134 if ( (MDrv_USBGetChipID() == CHIPID_NEPTUNE) ||
1135 (MDrv_USBGetChipID() == CHIPID_ERIS) ||
1136 (MDrv_USBGetChipID() == CHIPID_TITANIA) ||
1137 (MDrv_USBGetChipID() == CHIPID_PLUTO) ||
1138 (MDrv_USBGetChipID() == CHIPID_TRITON) ||
1139 (MDrv_USBGetChipID() == CHIPID_TITANIA2) )
1140 {
1141 UTMI_SETXBYTE(0x29,0x08);
1142 }
1143 else if (MDrv_USBGetChipID()==CHIPID_EUCLID) // Euclid
1144 {
1145 UTMI_ANDXBYTE(0x29,0xF7); //disable full speed retime
1146 }
1147
1148 #if defined(Enable_Issue_TestPacket) && !defined(ENABLE_HOST_TEST)
1149 UTMI_SETXBYTE(0x03,0); //for device disconnect status bit
1150 #else
1151 UTMI_SETXBYTE(0x03,0xa8); //for device disconnect status bit
1152 #endif
1153 //XBYTE[gUTMI_BASE+0x07]|=0x02; //
1154 #ifdef DTV_STANDARD_LIB
1155 if (MDrv_USBGetChipID()==CHIPID_NEPTUNE) //Neptune , after U06
1156 {
1157 if (MDrv_USBGetChipVersion()>= 0x6) //U07
1158 {
1159 UTMI_ORXBYTE(0x07, 0x02);
1160 UTMI_SETXBYTE(0x2c,0xc1);
1161 UTMI_SETXBYTE(0x2d,0x3b);//enable TX common mode,
1162 UTMI_ORXBYTE(0x2f, 0x0e); //preemsis
1163 }
1164 }
1165 else if ((MDrv_USBGetChipID()>=CHIPID_ERIS)&&(MDrv_USBGetChipID()<=CHIPID_TITANIA)) //Eris: 3 ,Titania: 4,
1166 {
1167 UTMI_SETXBYTE(0x2c,0xc5);
1168 UTMI_SETXBYTE(0x2d,0x3b);//enable TX common mode,
1169 UTMI_ORXBYTE(0x2f, 0x0e); //preemsis
1170 }
1171 else if (MDrv_USBGetChipID()==CHIPID_PLUTO) // Pluto: 5
1172 {
1173 UTMI_ORXBYTE(0x2c, 0xc5);
1174 UTMI_ORXBYTE(0x2d, 0x3);//enable TX common mode,
1175 UTMI_ORXBYTE(0x2f, 0x4a); //preemsis
1176 UTMI_ORXBYTE(0x13, 0x70);
1177 }
1178 else if (MDrv_USBGetChipID()==CHIPID_TITANIA2) // Titania 2
1179 {
1180 UTMI_ORXBYTE(0x2c, 0xc1);
1181 UTMI_ORXBYTE(0x2d, 0x3);//enable TX common mode,
1182 UTMI_ORXBYTE(0x2f, 0x4a); //preemsis
1183 }
1184 else if (MDrv_USBGetChipID()==CHIPID_TRITON) //Triton=6
1185 {
1186 UTMI_SETXBYTE(0x2c,0xc1);
1187 UTMI_SETXBYTE(0x2d,0x3b);//enable TX common mode,
1188 UTMI_ORXBYTE(0x2f,0x0e); //preemsis
1189 }
1190 else if (MDrv_USBGetChipID()==CHIPID_EUCLID) // Euclid
1191 {
1192 UTMI_ORXBYTE(0x2c, 0xc1);
1193 UTMI_ORXBYTE(0x2d, 0x3);//enable TX common mode,
1194 UTMI_ORXBYTE(0x2f, 0x4a); //preemsis
1195 }
1196 else if ( (MDrv_USBGetChipID()==CHIPID_TITANIA3) || // Titania 3, Titania 4
1197 (MDrv_USBGetChipID()==CHIPID_TITANIA4) ||
1198 (MDrv_USBGetChipID()==CHIPID_TITANIA7) ||
1199 (MDrv_USBGetChipID()==CHIPID_TITANIA8) ||
1200 (MDrv_USBGetChipID()==CHIPID_TITANIA9) ||
1201 (MDrv_USBGetChipID()==CHIPID_TITANIA12) ||
1202 (MDrv_USBGetChipID()==CHIPID_TITANIA13) ||
1203 (MDrv_USBGetChipID()==CHIPID_JANUS) ||
1204 (MDrv_USBGetChipID() == CHIPID_MARIA10) ||
1205 (MDrv_USBGetChipID() == CHIPID_JANUS2) ||
1206 (MDrv_USBGetChipID() == CHIPID_AMBER6) )
1207 {
1208 UTMI_ORXBYTE(0x2c, 0x10); //TX-current adjust to 105%
1209 UTMI_ORXBYTE(0x2d, 0x02); //Pre-emphasis enable
1210 UTMI_ORXBYTE(0x2f, 0x81); //HS_TX common mode current enable (100mV);Pre-emphasis enable (10%)
1211 UTMI_ORXBYTE(0x09,0x81); //UTMI RX anti-dead-lock, ISI improvement
1212 }
1213 else if ( (MDrv_USBGetChipID() == CHIPID_MACAW12) )
1214 {
1215 //PreEmphasis +40%, CM +20%
1216 UTMI_ORXBYTE(0x2c, 0x90);
1217 UTMI_ORXBYTE(0x2d, 0x03);
1218 UTMI_ORXBYTE(0x2f, 0x81);
1219 UTMI_ORXBYTE(0x09,0x81); //UTMI RX anti-dead-lock, ISI improvement
1220 }
1221 else if ( (MDrv_USBGetChipID()==CHIPID_AMBER1) ||
1222 (MDrv_USBGetChipID()==CHIPID_AMBER5) ||
1223 (MDrv_USBGetChipID()==CHIPID_AMBER7) ||
1224 (MDrv_USBGetChipID()==CHIPID_AMBER3) ||
1225 (MDrv_USBGetChipID()==CHIPID_AMETHYST) ||
1226 (MDrv_USBGetChipID()==CHIPID_EAGLE))
1227 {
1228 //for Amber1 later 40nm before Agate
1229 UTMI_ORXBYTE(0x2c, 0x98);
1230 UTMI_ORXBYTE(0x2d, 0x02);
1231 UTMI_ORXBYTE(0x2e, 0x10);
1232 UTMI_ORXBYTE(0x2f, 0x01);
1233 UTMI_ORXBYTE(0x09,0x81); //UTMI RX anti-dead-lock, ISI improvement
1234 }
1235 else if ( (MDrv_USBGetChipID() == CHIPID_EDISON) ||
1236 (MDrv_USBGetChipID() == CHIPID_EIFFEL) )
1237 {
1238 //for Agate later 40nm, same as 55nm setting2
1239 UTMI_ORXBYTE(0x2c, 0x90); //TX-current adjust to 105%
1240 UTMI_ORXBYTE(0x2d, 0x02); //Pre-emphasis enable
1241 UTMI_ORXBYTE(0x2f, 0x81); //HS_TX common mode current enable (100mV);Pre-emphasis enable (10%)
1242 UTMI_ORXBYTE(0x09,0x81); //UTMI RX anti-dead-lock, ISI improvement
1243 }
1244 else //for Agate later 40nm, same as 55nm setting1
1245 {
1246 UTMI_ORXBYTE(0x2c, 0x10); //TX-current adjust to 105%
1247 UTMI_ORXBYTE(0x2d, 0x02); //Pre-emphasis enable
1248 UTMI_ORXBYTE(0x2f, 0x81); //HS_TX common mode current enable (100mV);Pre-emphasis enable (10%)
1249 UTMI_ORXBYTE(0x09,0x81); //UTMI RX anti-dead-lock, ISI improvement
1250 }
1251 #endif
1252
1253 if ( (MDrv_USBGetChipID() == CHIPID_EIFFEL) )
1254 UTMI_ANDXBYTE(0x08, ~0x08); //Special setting for Eiffel analog LIB issue
1255 else
1256 {
1257 //for Edison later 240M clock enhance, early chip will ignore this 2 bits
1258 UTMI_ORXBYTE(0x08,0x08); //bit<3> for 240's phase as 120's clock set 1, bit<4> for 240Mhz in mac 0 for faraday 1 for etron
1259 }
1260
1261 /* Enable Cross Point ECO 2012/03/20 */
1262 if ((MDrv_USBGetChipID() == CHIPID_MACAW12) ||
1263 (MDrv_USBGetChipID() == CHIPID_EDEN) ||
1264 (MDrv_USBGetChipID() == CHIPID_ELK) ||
1265 (MDrv_USBGetChipID() == CHIPID_AMBER5) ||
1266 (MDrv_USBGetChipID() == CHIPID_EAGLE) ||
1267 (MDrv_USBGetChipID() == CHIPID_EMERALD) ||
1268 (MDrv_USBGetChipID() == CHIPID_EDISON) ||
1269 (MDrv_USBGetChipID() == CHIPID_AGATE) ||
1270 (MDrv_USBGetChipID() == CHIPID_EULER))
1271 {
1272 UTMI_ORXBYTE(0x04,0x40); //deglitch SE0 (low-speed cross point)
1273 }
1274 else if((MDrv_USBGetChipID() == CHIPID_JANUS2))
1275 {
1276 UTMI_ORXBYTE(0x0a,0x80); //deglitch SE0 (low-speed cross point)
1277 }
1278
1279 /* Enable Power Noice ECO 2012/03/20 */
1280 if ((MDrv_USBGetChipID() == CHIPID_JANUS2) ||
1281 (MDrv_USBGetChipID() == CHIPID_MACAW12) ||
1282 (MDrv_USBGetChipID() == CHIPID_EDEN) ||
1283 (MDrv_USBGetChipID() == CHIPID_ELK) ||
1284 (MDrv_USBGetChipID() == CHIPID_AMBER5) ||
1285 (MDrv_USBGetChipID() == CHIPID_EAGLE) ||
1286 (MDrv_USBGetChipID() == CHIPID_EMERALD) ||
1287 (MDrv_USBGetChipID() == CHIPID_EDISON) ||
1288 (MDrv_USBGetChipID() == CHIPID_AGATE))
1289 {
1290 USBC_ORXBYTE(0x02,0x40); //use eof2 to reset state machine (power noise)
1291 }
1292
1293 /* Enable Tx/Rx Reset Clock Gatting ECO 2012/03/27 */
1294 if((MDrv_USBGetChipID() == CHIPID_ELK) ||
1295 (MDrv_USBGetChipID() == CHIPID_AMBER5) ||
1296 (MDrv_USBGetChipID() == CHIPID_EAGLE) ||
1297 (MDrv_USBGetChipID() == CHIPID_EMERALD) ||
1298 (MDrv_USBGetChipID() == CHIPID_EDISON) ||
1299 (MDrv_USBGetChipID() == CHIPID_AGATE) ||
1300 (MDrv_USBGetChipID() == CHIPID_EDEN) ||
1301 (MDrv_USBGetChipID() == CHIPID_EULER))
1302 {
1303 UTMI_ORXBYTE(0x04,0x20); //hw auto deassert sw reset (tx/rx reset)
1304 }
1305
1306 /* enable patch for the assertion of interrupt(Lose short packet interrupt) 2012/03/28 */
1307 if((MDrv_USBGetChipID() == CHIPID_AMBER5) ||
1308 (MDrv_USBGetChipID() == CHIPID_AGATE))
1309 {
1310 USBC_ORXBYTE(0x04,0x80); //patch for the assertion of interrupt
1311 }
1312
1313 /* enable add patch to Period_EOF1(babble problem) 2012/03/28 */
1314 if((MDrv_USBGetChipID() == CHIPID_AMBER5) ||
1315 (MDrv_USBGetChipID() == CHIPID_AGATE))
1316 {
1317 USBC_ORXBYTE(0x04,0x40); //add patch to Period_EOF1s
1318 }
1319
1320 /* enable eco for short packet MDATA 2012/07/05 */
1321 if((MDrv_USBGetChipID() == CHIPID_EDISON) ||
1322 (MDrv_USBGetChipID() == CHIPID_EMERALD))
1323 {
1324 USBC_ORXBYTE(0x00,0x10); //short packet MDATA in Split transaction clears ACT bit (LS dev under a HS hub)
1325 }
1326
1327 /* enable eco for pv2mi bridge mis-behavior 2012/12/05 */
1328 if((MDrv_USBGetChipID() == CHIPID_EDEN) ||
1329 (MDrv_USBGetChipID() == CHIPID_EULER) ||
1330 (MDrv_USBGetChipID() == CHIPID_EINSTEIN) ||
1331 (MDrv_USBGetChipID() == CHIPID_NAPOLI) ||
1332 (MDrv_USBGetChipID() == CHIPID_MIAMI))
1333 {
1334 USBC_ORXBYTE(0x0A,0x40); //fix pv2mi bridge mis-behavior
1335 }
1336
1337 if (MDrv_USBGetChipID()==CHIPID_PLUTO) // If is Pluto
1338 UTMI_ORXBYTE(0x09,0x01); //ISI improvement
1339 else
1340 UTMI_ORXBYTE(0x13,0x02); //ISI improvement
1341
1342 if ( (MDrv_USBGetChipID() == CHIPID_NEPTUNE) ||
1343 (MDrv_USBGetChipID() == CHIPID_ERIS) ||
1344 (MDrv_USBGetChipID() == CHIPID_TITANIA) ||
1345 (MDrv_USBGetChipID() == CHIPID_PLUTO) ||
1346 (MDrv_USBGetChipID() == CHIPID_TRITON) ||
1347 (MDrv_USBGetChipID() == CHIPID_TITANIA2) )
1348 {
1349 }
1350 else
1351 {
1352 UTMI_ORXBYTE(0x0b, 0x80); //TX timing select latch path
1353 }
1354
1355 if (MDrv_USBGetChipID()==CHIPID_EUCLID) // Euclid
1356 {
1357 UTMI_SETXBYTE(0x09,0x81);//0x20; //patch low tempture,FL meta issue and enable new FL RX engin
1358 }
1359 else
1360 {
1361 UTMI_ORXBYTE(0x09,0x60);//0x20; //patch low tempture,FL meta issue and enable new FL RX engin
1362 }
1363
1364 DRV_USB_DBG(printf("Host: %X\n", mwOTG20_Control_HOST_SPD_TYP_Rd()));
1365 if (mwOTG20_Control_HOST_SPD_TYP_Rd()==1) //low speed,for HID
1366 UTMI_ANDXBYTE(0x09,~0x40); //old setting
1367
1368 if ( (MDrv_USBGetChipID() == CHIPID_NEPTUNE) ||
1369 (MDrv_USBGetChipID() == CHIPID_ERIS) ||
1370 (MDrv_USBGetChipID() == CHIPID_TITANIA) ||
1371 (MDrv_USBGetChipID() == CHIPID_PLUTO) ||
1372 (MDrv_USBGetChipID() == CHIPID_TRITON) ||
1373 (MDrv_USBGetChipID() == CHIPID_TITANIA2) )
1374 {
1375 UTMI_ANDXBYTE(0x27,0xf3);
1376 UTMI_ORXBYTE(0x27,0x08); //(1) Offset 27 (��h3AA7) bit <3:2> set 2��b10 // RX bias current => 60uA (default 40uA)
1377
1378 //(2) Offset 2A (��h3AAA) bit <3:2> set 2��b11 // Squelch voltage => 100mV (default 150mV)
1379 #ifdef DTV_STANDARD_LIB
1380 UTMI_SETXBYTE(0x2a,0x07);
1381 #endif
1382 }
1383
1384 if ( (MDrv_USBGetChipID() == CHIPID_NEPTUNE) ||
1385 (MDrv_USBGetChipID() == CHIPID_ERIS) ||
1386 (MDrv_USBGetChipID() == CHIPID_TITANIA) ||
1387 (MDrv_USBGetChipID() == CHIPID_PLUTO) ||
1388 (MDrv_USBGetChipID() == CHIPID_TRITON) ||
1389 (MDrv_USBGetChipID() == CHIPID_TITANIA2) ||
1390 (MDrv_USBGetChipID() == CHIPID_TITANIA3) ||
1391 (MDrv_USBGetChipID() == CHIPID_TITANIA4) ||
1392 (MDrv_USBGetChipID() == CHIPID_TITANIA7) ||
1393 (MDrv_USBGetChipID() == CHIPID_TITANIA8) ||
1394 (MDrv_USBGetChipID() == CHIPID_TITANIA9) ||
1395 (MDrv_USBGetChipID() == CHIPID_TITANIA12) ||
1396 (MDrv_USBGetChipID() == CHIPID_TITANIA13) ||
1397 (MDrv_USBGetChipID() == CHIPID_JANUS) ||
1398 (MDrv_USBGetChipID() == CHIPID_MARIA10) ||
1399 (MDrv_USBGetChipID() == CHIPID_MACAW12) ||
1400 (MDrv_USBGetChipID() == CHIPID_JANUS2) ||
1401 (MDrv_USBGetChipID() == CHIPID_AMBER1) ||
1402 (MDrv_USBGetChipID() == CHIPID_AMBER3) ||
1403 (MDrv_USBGetChipID() == CHIPID_AMBER5) ||
1404 (MDrv_USBGetChipID() == CHIPID_AMBER6) ||
1405 (MDrv_USBGetChipID() == CHIPID_AMBER7) ||
1406 (MDrv_USBGetChipID() == CHIPID_AMETHYST) )
1407 {
1408 UTMI_ORXBYTE(0x15,0x20); //HOST CHIRP Detect
1409 }
1410 else
1411 {
1412 UTMI_ORXBYTE(0x15,0x60); // change to 55 interface (bit6)
1413 }
1414
1415 //(3) Offset 2D (��h3AAD) bit <5:3> set 3��b111 // HS_RTERM bias current 5/6
1416 //XBYTE[0x128a]=0x87; //change UHC priority
1417 //XBYTE[0x128d]&=0x0f; //clear bit 12~15
1418 //XBYTE[0x128e]|=0xf; //upgrade UHC priority, set bit 0~3
1419 //MDrv_Sys_SetXdataWindow1Base(USB_BUFFER_START_ADR_4K_ALIGN>>12); //switch window 1
1420 gUsbStatus=USB_OK;
1421 // gUsbTimeout=3; //set at flib_Host20_Enumerate()
1422 RecoveryFlag=0; //initialize recovery flag
1423 gUsbDeviceState=USB11_DEVICE; //1.1 at first
1424
1425 //gDeviceFatalError=FALSE;
1426
1427 return TRUE;
1428 }
1429 //MsOS_DelayTask(500);
1430
_MDrv_UsbHost_Init1(void)1431 BOOLEAN _MDrv_UsbHost_Init1(void)
1432 {
1433 BOOLEAN result=FALSE;
1434
1435 if(flib_OTGH_Init(0))
1436 result =TRUE;
1437
1438 return result;
1439
1440 }
MDrv_UsbHost_Init(void)1441 BOOLEAN MDrv_UsbHost_Init(void)
1442 {
1443 BOOLEAN result;
1444
1445 result = _MDrv_UsbHost_Init0();
1446 if (result == FALSE)
1447 return FALSE;
1448
1449 MsOS_DelayTask(USB_HOST_INIT_DELAY);
1450 return(_MDrv_UsbHost_Init1());
1451 }
1452 #endif
MDrv_UsbHost_Init_Enum(void)1453 BOOLEAN MDrv_UsbHost_Init_Enum(void)
1454 {
1455 BOOLEAN result;
1456 result=MDrv_Usb_Device_Enum();
1457 return result;
1458 }
MDrv_UsbGetMaxLUNCount()1459 U8 MDrv_UsbGetMaxLUNCount()
1460 {
1461 if (gUsbDeviceState==BAD_DEVICE)
1462 return 0;
1463
1464 if (mwHost20_PORTSC_ConnectStatus_Rd()==0)
1465 return 0;
1466 else return (Mass_stor_us1.max_lun+1);
1467 }
MDrv_GET_MASS_MAX_LUN()1468 U8 MDrv_GET_MASS_MAX_LUN()
1469 {
1470 //printf("Get max lun func:%02bx\n",Mass_stor_us1.max_lun);
1471 if (mwHost20_PORTSC_ConnectStatus_Rd()==0)
1472 return 0;
1473 else return Mass_stor_us1.max_lun;
1474 }
1475
1476 extern void GetValidLun(void);
1477
1478 #ifdef ATV_SERISE_USE
DisableINT(void)1479 void DisableINT(void)
1480 {
1481 XBYTE[0x2B03]|=0x20;
1482 XBYTE[0x2B18]|=0x80;
1483 XBYTE[0x2B19]|=0x04;
1484 XBYTE[0x2B1A]|=0x80;
1485 }
EnableINT(void)1486 void EnableINT(void)
1487 {
1488 XBYTE[0x2B03]&=0xDF;
1489 XBYTE[0x2B18]&=0x7F;
1490 XBYTE[0x2B19]&=0xFB;
1491 XBYTE[0x2B1A]&=0x7F;
1492 }
1493 #endif
1494 extern U8 ValidLunNum;
MDrv_GET_VALID_LUN_NUM(void)1495 U8 MDrv_GET_VALID_LUN_NUM(void)
1496 {
1497 return ValidLunNum;
1498 }
MDrv_GET_MASS_VALID_LUN()1499 U8 MDrv_GET_MASS_VALID_LUN()
1500 {
1501 U8 LunMatrix=0,i;
1502 struct LUN_Device* LunDevice;
1503 //printf("Get valid lun func\n");
1504 if (mwHost20_PORTSC_ConnectStatus_Rd()==0)
1505 return USB_NOT_RESPONSE; //device is not connected
1506
1507 if (gUsbDeviceState==BAD_DEVICE) return 0;
1508
1509 if (gSpeed==1) return 0; //low speed device
1510
1511 //if (gDeviceFatalError) return USB_NOT_RESPONSE;
1512 if (gUsbStatus==USB_EJECT) return USB_NOT_RESPONSE;
1513
1514
1515 LunDevice = Mass_stor_us1.Mass_stor_device;
1516 if (sAttachDevice.saCD[0].sInterface[0].bInterfaceClass != USB_INTERFACE_CLASS_MSD)
1517 {
1518 DRV_USB_DBG(printf(" LUN structure not initialized!!\n"));
1519 return USB_NOT_RESPONSE;
1520 }
1521
1522 #ifdef ATV_SERISE_USE
1523 #ifdef Enable_Close_INT
1524 //XBYTE[0x2B00]|=0x02;
1525 DisableINT();
1526 #endif
1527 #endif
1528 GetValidLun();
1529 #ifdef ATV_SERISE_USE
1530 #ifdef Enable_Close_INT
1531 //XBYTE[0x2B00]&=0xFD;
1532 EnableINT();
1533 #endif
1534 #endif
1535
1536 if (gUsbStatus==USB_TIMEOUT)
1537 {
1538 #ifdef USE_XDATA_ADDRESS_0XF000
1539 MDrv_USB_ReleaseXdataWindow1();
1540 #endif
1541 return USB_NOT_RESPONSE; //USB DEVICE not responding
1542 }
1543
1544 for (i=0; i <= Mass_stor_us1.max_lun ; i++)
1545 {
1546 LunMatrix=LunMatrix<<1 ;
1547 //printf("bDeviceReady:%02bx\n",LunDevice[Mass_stor_us1.max_lun-i].bDeviceReady);
1548 if (LunDevice[Mass_stor_us1.max_lun-i].bDeviceReady == TRUE)
1549 {
1550 LunMatrix|=1;
1551 }
1552 }
1553
1554 return LunMatrix;
1555 }
1556 U32 USB_BUFFER_START_ADR_4K_ALIGN_Var;
MDrv_USB_Init(U32 USBAdr)1557 void MDrv_USB_Init(U32 USBAdr)
1558 {
1559 //gProjectCode=ProjectCode;
1560 //gDeviceFatalError=FALSE;
1561
1562 USB_BUFFER_START_ADR_4K_ALIGN_Var=USBAdr;
1563
1564 gUsbRetryCount=3;
1565
1566 if (USB_BUFFER_START_ADR_4K_ALIGN_Var % 4096 != 0)
1567 {
1568 DRV_USB_DBG( printf("Error USB Starting address is not 4K alignmented\n"));
1569 }
1570
1571 if (!drvUSBHost_isPowerSaveModeEnable())
1572 {
1573 mbFUSBH200_VBUS_ON_Set();
1574
1575 if ( (MDrv_USBGetChipID()==CHIPID_NEPTUNE) || //Neptune
1576 (MDrv_USBGetChipID()==CHIPID_ERIS) || //Eris
1577 (MDrv_USBGetChipID()==CHIPID_TITANIA) || //Titania
1578 (MDrv_USBGetChipID()==CHIPID_PLUTO) || //Pluto
1579 (MDrv_USBGetChipID()==CHIPID_TRITON) || //Triton
1580 (MDrv_USBGetChipID()==CHIPID_TITANIA2) ) // Titania 2
1581 {
1582 UHC_ANDXBYTE(0x34,0xBF); //set suspend
1583 UHC_ORXBYTE(0x34,0x40); //clr suspend
1584 MsOS_DelayTask(2);
1585 UTMI_ORXBYTE(0x00,0x01); // override mode enable for power down control
1586 UTMI_ORXBYTE(0x01,0x40); // enable IREF power down
1587 UTMI_ORXBYTE(0x01,0x02); // enable PLL power down
1588 UTMI_ANDXBYTE(0x01,0xFD); // disable PLL power down
1589 }
1590
1591 mbHost20_USBCMD_HCReset_Set();
1592 }
1593
1594 }
1595
MDrv_GetUsbDeviceStatus()1596 U8 MDrv_GetUsbDeviceStatus()
1597 {
1598 return gUsbDeviceState;
1599 }
1600
MDrv_SetUsbDeviceStatus(U8 status)1601 void MDrv_SetUsbDeviceStatus(U8 status)
1602 {
1603 gUsbDeviceState = status;
1604 }
1605
MDrv_ClearUsbDeviceStatus()1606 void MDrv_ClearUsbDeviceStatus()
1607 {
1608 //if (gUsbDeviceState==BAD_DEVICE)
1609 //{
1610 // printf("Clear bad device\n");
1611 // gUsbDeviceState=USB11_DEVICE;
1612 //}
1613 }
ResetUsbHardware(void)1614 void ResetUsbHardware(void)
1615 {
1616 UTMI_ORXBYTE(0x06,0x03); //reset UTMI
1617 UTMI_ANDXBYTE(0x06,0xfc);
1618 mbHost20_USBCMD_HCReset_Set();
1619 //MsOS_DelayTask(200);
1620 }
1621 UINT32 UsbStartTime=0;
1622 UINT32 UsbPowerSavingTimer=0;
1623 UINT32 UsbPortSwitchTimer=0;
1624
1625
1626 #if 1
UsbPort0UTMIInitial(void)1627 void UsbPort0UTMIInitial(void)
1628 {
1629 mbFUSBH200_VBUS_ON_Set();
1630 UHC_ANDXBYTE(0x34,0xBF); //set suspend
1631 UHC_ORXBYTE(0x34,0x40); //clr suspend
1632 MsOS_DelayTask(2);
1633 UTMI_ORXBYTE(0x00,0x01); // override mode enable for power down control
1634 UTMI_ORXBYTE(0x01,0x40); // enable IREF power down
1635 UTMI_ORXBYTE(0x01,0x02); // enable PLL power down
1636 UTMI_ANDXBYTE(0x01,0xFD); // disable PLL power down
1637 UTMI_ANDXBYTE(0x00,~0x01); // override mode enable for power down control
1638
1639 mbHost20_USBCMD_HCReset_Set();
1640 }
1641 #else
1642 #ifdef USB_POWER_SAVING_MODE
UsbTurnOffPowerDownMode(void)1643 void UsbTurnOffPowerDownMode(void)
1644 {
1645 //Power On
1646 XBYTE[gUTMI_BASE+8]&=0x7F; //PD_BG_CURRENT
1647 XBYTE[gUTMI_BASE+0x2c]|=0x04; //Switch current from DVI
1648
1649 //Port0
1650 XBYTE[gUTMI_BASE+1]=0x6f;
1651 XBYTE[gUTMI_BASE]=0xc4;
1652 XBYTE[gUTMI_BASE+0x11]=0x00;
1653 XBYTE[gUTMI_BASE+0x10]=0x00;
1654 #ifdef USBHOST2PORT
1655 //Port1
1656 XBYTE[gUTMI2_BASE+1]=0x6f;
1657 XBYTE[gUTMI2_BASE]=0xc4;
1658 XBYTE[gUTMI2_BASE+0x11]=0x00;
1659 XBYTE[gUTMI2_BASE+0x10]=0x00;
1660 //Power On End
1661 #endif
1662 //open port 0
1663 XBYTE[gUTMI_BASE+1]=0x00;
1664 XBYTE[gUTMI_BASE]=0x00;
1665 XBYTE[gUSBC_BASE]|=0x08; //disable init suspend state
1666 XBYTE[gUSBC_BASE]|=0x20; //Enable UHC XIU
1667 MsOS_DelayTask(3);
1668 XBYTE[gUSBC_BASE+2]|=0x01; //UHC select enable
1669 //end
1670
1671 // Power On USB UHC0
1672 XBYTE[gUHC_BASE+0x34] |= 0x40;
1673
1674 MsOS_DelayTask(2);
1675 XBYTE[gUHC_BASE+0x40] &=~0x10;
1676
1677 #ifdef USBHOST2PORT
1678 //open port 1
1679 XBYTE[gUTMI2_BASE]=0x00; //disable power down over write
1680 XBYTE[gUTMI2_BASE+1]=0x00; //disable power down over write high byte
1681 XBYTE[gUSBC_BASE]|=0x08; //disable init suspend state
1682 XBYTE[gUSBC_BASE]|=0x20; //Enable UHC XIU
1683 MsOS_DelayTask(3);
1684 XBYTE[gUSBC_BASE+2]|=0x01; //UHC select enable
1685 //end
1686
1687 // Power On USB UHC1
1688 XBYTE[UHC2_BASE+0x34] |= 0x40;
1689 MsOS_DelayTask(2);
1690 XBYTE[UHC2_BASE+0x40] &=~0x10;
1691 #endif
1692 }
1693
UsbTurnOnPowerDownMode(void)1694 void UsbTurnOnPowerDownMode(void)
1695 {
1696 MsOS_DelayTask(2);
1697
1698 XBYTE[gUSBC_BASE]&=0xD0; //Disable Port0 UHC XIU
1699 #ifdef USBHOST2PORT
1700 XBYTE[gUSBC2_BASE]&=0xD0; //Disable Port1 UHC XIU
1701 #endif
1702 XBYTE[gUTMI_BASE+8]|=0x80; //PD_BG_CURRENT
1703 XBYTE[gUTMI_BASE+0x2c]&=0xFB; //Switch current from REXT, not DVI
1704
1705 //Port 0
1706 XBYTE[gUTMI_BASE+0x11]=0x88; //bit<15>:HS_TX_OVERRIDE, bit<11>:FL_TX_OVERRIDE
1707 XBYTE[gUTMI_BASE+0x10]=0x00;
1708 XBYTE[gUTMI_BASE+3]=0x90; //bit<15>:reg_hs_rterm_pdn, bit<7>:reg_bond_sel
1709 XBYTE[gUTMI_BASE+2]=0x80;
1710 XBYTE[gUTMI_BASE+1]=0xef; //bit<15>:reg_pdn
1711 XBYTE[gUTMI_BASE]=0xc7;
1712 #ifdef USBHOST2PORT
1713 //Port 1
1714 XBYTE[gUTMI2_BASE+0x11]=0x88;
1715 XBYTE[gUTMI2_BASE+0x10]=0x00;
1716 XBYTE[gUTMI2_BASE+3]=0x90;
1717 XBYTE[gUTMI2_BASE+2]=0x80;
1718 XBYTE[gUTMI2_BASE+1]=0xef;
1719 XBYTE[gUTMI2_BASE]=0xc7;
1720 #endif
1721 }
1722
UsbPort0UTMIInitial(void)1723 void UsbPort0UTMIInitial(void)
1724 {
1725 mbFUSBH200_VBUS_ON_Set();
1726 UHC_XBYTE(0x34)&=0xBF; //set suspend
1727 UHC_XBYTE(0x34)|=0x40; //clr suspend
1728 MsOS_DelayTask(2);
1729 XBYTE[gUTMI_BASE+0x00]|=0x01; // override mode enable for power down control
1730 XBYTE[gUTMI_BASE+0x01]|=0x40; // enable IREF power down
1731 XBYTE[gUTMI_BASE+0x01]|=0x02; // enable PLL power down
1732 XBYTE[gUTMI_BASE+0x01]&=0xFD; // disable PLL power down
1733 XBYTE[gUTMI_BASE+0x00]&=~0x01; // override mode enable for power down control
1734
1735 mbHost20_USBCMD_HCReset_Set();
1736 }
1737 extern void UsbPort1UTMIInitial(void);
1738 #endif
1739 #endif
1740
1741 #ifdef Enable_Issue_TestPacketByHW
1742 BOOLEAN isInitForTestPkt = TRUE;
1743 void MDrv_UsbSendTestPacket(void);
1744 #endif
1745
MDrv_UsbDeviceConnect(void)1746 BOOLEAN MDrv_UsbDeviceConnect(void)
1747 {
1748 static int pre_connection = 0;
1749
1750 /*
1751 if (gDeviceFatalError)
1752 {
1753 gDeviceFatalError=FALSE;
1754 ResetUsbHardware();
1755 return FALSE;
1756 }*/
1757 #ifdef Enable_Issue_TestPacketByHW
1758 if (isInitForTestPkt)
1759 {
1760 isInitForTestPkt = FALSE;
1761 MDrv_UsbSendTestPacket();
1762 }
1763 return FALSE;
1764 #endif
1765
1766 #if 1
1767 if (drvUSBHost_isPowerSaveModeEnable())
1768 {
1769 if (gUsbDeviceState==WAIT_INIT)
1770 {
1771 if (MsOS_Timer_DiffTimeFromNow(UsbPowerSavingTimer) < 300 )
1772 return FALSE;
1773 }
1774 if (gUsbDeviceState==POWER_SAVING)
1775 {
1776 #ifdef ENABLE_HOST_TEST
1777 if (USBC_READXBYTE(8)&0xC0)
1778 #else
1779 if (USBC_READXBYTE(8)&0x40)
1780 #endif
1781 {
1782 drvUSBHost_TurnOffPowerDownMode();
1783
1784 UsbPowerSavingTimer = MsOS_GetSystemTime();
1785 gUsbDeviceState=WAIT_INIT;
1786 return FALSE;
1787 }
1788 else
1789 {
1790 return FALSE;
1791 }
1792 }
1793 }
1794 #else
1795 #ifdef USB_POWER_SAVING_MODE
1796 #ifdef USBHOST2PORT
1797 if (gUsbDeviceState_Port2==WAIT_INIT)
1798 return FALSE;
1799 #endif
1800 if (gUsbDeviceState==WAIT_INIT)
1801 {
1802 if (MsOS_Timer_DiffTimeFromNow(UsbPowerSavingTimer) < 300 )
1803 return FALSE;
1804 }
1805 if (gUsbDeviceState==POWER_SAVING)
1806 {
1807 if (XBYTE[gUSBC_BASE+8]&0x40)
1808 {
1809 UsbTurnOffPowerDownMode();
1810 UsbPort0UTMIInitial();
1811 #ifdef USBHOST2PORT
1812 UsbPort1UTMIInitial();
1813 if (gUsbDeviceState_Port2==POWER_SAVING)
1814 gUsbDeviceState_Port2=NO_DEVICE;
1815 #endif
1816 UsbPowerSavingTimer = MsOS_GetSystemTime();
1817 gUsbDeviceState=WAIT_INIT;
1818 return FALSE;
1819 //MsOS_DelayTask(300);
1820 }
1821 else
1822 {
1823 return FALSE;
1824 }
1825 }
1826 #endif
1827 #endif
1828 if (gUsbStatus==USB_EJECT)
1829 {
1830 if (UHC_READXBYTE(0x30)&2)
1831 {
1832 gUsbStatus=USB_OK;
1833 }
1834 else
1835 return FALSE; //eject state
1836 }
1837
1838 if (g_Port0_SwithDelay > 0)
1839 {
1840 //printf("Return false for switch USB port %d\n", g_Port0_SwithDelay);
1841 g_Port0_SwithDelay--;
1842 return FALSE;
1843 }
1844
1845 //FUSBH200_Driver_VBUS(); //make sure device is connected , then turn on VBUS
1846
1847 if (mwHost20_PORTSC_ConnectStatus_Rd())
1848 {
1849 pre_connection = 1;
1850
1851 if ( (gUsbDeviceState==USB11_DEVICE) ||(gUsbDeviceState==USB20_DEVICE) )
1852 {
1853 // If the device is connected and we get a connection change.
1854 // It means that the user change the device and we just missed.
1855 if (mwHost20_PORTSC_ConnectChange_Rd())
1856 {
1857 printf("dev changed, we missed\n");
1858 gSpeed=0xff; //reset this value
1859 UHC_ANDXBYTE(0x40, (U8)~0x80);//clear force enter FSmode
1860 gUsbDeviceState = NO_DEVICE;
1861 return FALSE;
1862 }
1863 }
1864
1865 if (gUsbDeviceState==BAD_DEVICE) return FALSE; //not repeating doing emunerate
1866
1867 #if 0
1868 if (mwOTG20_Control_HOST_SPD_TYP_Rd()==0x01)
1869 //if (gSpeed==0x01)
1870 {
1871 #if 0
1872 U16 result;
1873
1874 MINI_DEBUG(printf("ls-exit\n"));
1875 // if (Support_HID()==FALSE) return FALSE;
1876 printf("is LS device\n");
1877 #if 0
1878 if (xfirst)
1879 {
1880 MDrv_Usb_Device_Enum();
1881 xfirst=FALSE;
1882 }
1883 #endif
1884 if (MDrv_GetUsbDeviceType() == USB_INTERFACE_CLASS_HID)
1885 result= MDrv_GET_JOYSTICK_STATUS();
1886 #endif
1887 return FALSE;
1888 }
1889 #endif
1890 if (gUsbDeviceState==NO_DEVICE)
1891 gUsbDeviceState=CONNECT_DEVICE;
1892 return TRUE;
1893 }
1894 else
1895 {
1896 #if 1
1897 if ( ( (CHIPID_MARIA10== MDrv_USBGetChipID()) ||
1898 (CHIPID_MACAW12== MDrv_USBGetChipID()) ||
1899 (CHIPID_EDEN== MDrv_USBGetChipID()) ||
1900 (CHIPID_JANUS2== MDrv_USBGetChipID()) ||
1901 (CHIPID_AMBER6== MDrv_USBGetChipID()) ||
1902 (CHIPID_EULER== MDrv_USBGetChipID()) ) &&
1903 (MDrv_USBGetPortAutoSwitchStatus()) )
1904 {
1905 if(pre_connection == 1)
1906 {
1907 UsbPortSwitchTimer = MsOS_GetSystemTime();
1908 }
1909 pre_connection = 0;
1910
1911 if(MsOS_Timer_DiffTimeFromNow(UsbPortSwitchTimer) > 500)
1912 {
1913 UsbPortSwitchTimer = MsOS_GetSystemTime();
1914 //The Janus has an internal switch for two ports.
1915 //We must set the switch and scan both ports.
1916 //printf("&");
1917 if (g_Port0_Switch == 0)
1918 {
1919 UTMI_ANDXBYTE(0x38, ~BIT2);
1920 g_Port0_Switch = 1;
1921 }
1922 else
1923 {
1924 UTMI_ORXBYTE(0x38, BIT2);
1925 g_Port0_Switch = 0;
1926 }
1927 }
1928 }
1929 #endif
1930
1931 gSpeed=0xff; //reset this value
1932 UHC_ANDXBYTE(0x40,(U8)~0x80);//clear force enter FSmode
1933 #if 1
1934 if (drvUSBHost_isPowerSaveModeEnable())
1935 {
1936 if (gUsbDeviceState!=POWER_SAVING)
1937 drvUSBHost_TurnOnPowerDownMode();
1938
1939 gUsbDeviceState=POWER_SAVING;
1940 }
1941 else
1942 gUsbDeviceState=NO_DEVICE;
1943 #else
1944 #ifdef USB_POWER_SAVING_MODE
1945 #ifdef USBHOST2PORT
1946 if ((gUsbDeviceState_Port2==NO_DEVICE)||(gUsbDeviceState_Port2==POWER_SAVING))
1947 #endif
1948 {
1949 if (gUsbDeviceState!=POWER_SAVING)
1950 UsbTurnOnPowerDownMode();
1951 gUsbDeviceState=POWER_SAVING;
1952 #ifdef USBHOST2PORT
1953 gUsbDeviceState_Port2=POWER_SAVING;
1954 #endif
1955 }
1956 #ifdef USBHOST2PORT
1957 else
1958 gUsbDeviceState=NO_DEVICE;
1959 #endif
1960 #else
1961 gUsbDeviceState=NO_DEVICE;
1962 #endif
1963 #endif
1964
1965 #ifndef ATV_SERISE_USE
1966 if (MsOS_Timer_DiffTimeFromNow(UsbStartTime) > 1000 )
1967 {
1968
1969 UsbStartTime=MsOS_GetSystemTime();
1970 ResetUsbHardware();
1971
1972 }
1973 #else
1974 UsbStartTime++;
1975 if(UsbStartTime>0x600)
1976 {
1977 UsbStartTime=0;
1978 ResetUsbHardware();
1979 }
1980 #endif
1981 //MINI_DEBUG( printf("no_con \n"));
1982 return FALSE;
1983 }
1984 }
1985
MDrv_EjectUsbDevice(void)1986 void MDrv_EjectUsbDevice(void)
1987 {
1988 struct LUN_Device* LunDevice;
1989 U8 i;
1990
1991
1992 //printf("eject\n");
1993 LunDevice = Mass_stor_us1.Mass_stor_device;
1994 for (i=0; i <= Mass_stor_us1.max_lun ; i++)
1995 {
1996
1997 if (LunDevice[i].bDeviceReady == TRUE)
1998 {
1999 vSCSI_EJECT_DEVICE(i);
2000 gUsbStatus=USB_EJECT;
2001 mwHost20_PORTSC_ConnectChange_Set(); //clear port connect change bit
2002 //printf("ej_ok\n");
2003 }
2004 }
2005 flib_Host20_Close();
2006
2007 }
MDrv_UsbClose(void)2008 void MDrv_UsbClose(void)
2009 {
2010 flib_Host20_Close();
2011 }
2012
MDrv_UsbBlockReadToMIU(U8 lun,U32 u32BlockAddr,U32 u32BlockNum,U32 u32MIUAddr)2013 BOOLEAN MDrv_UsbBlockReadToMIU(U8 lun,U32 u32BlockAddr, U32 u32BlockNum,U32 u32MIUAddr)
2014 {
2015 BOOLEAN result;
2016 U8 retrycnt=0;
2017 struct LUN_Device* LunDevice = Mass_stor_us1.Mass_stor_device;
2018
2019 if (mwHost20_PORTSC_ConnectStatus_Rd()==0)
2020 return FALSE; //device is not connected
2021
2022 if (gUsbDeviceState==BAD_DEVICE) return FALSE;
2023
2024
2025 if (u32BlockAddr > Mass_stor_us1.Mass_stor_device[lun].u32BlockTotalNum)
2026 {
2027 MINI_DEBUG(printf("USBRead address is over the range:%lx\n",u32BlockAddr));
2028 return FALSE;
2029 }
2030 //printf("usb read sector:%lx\n",u32BlockNum);
2031
2032 #ifdef ATV_SERISE_USE
2033 #ifdef Enable_Close_INT
2034 XBYTE[0x2B00]|=0x02;
2035 DisableINT();
2036 #endif
2037 #endif
2038 //result= bSCSI_Read_Write10(FALSE,lun, u32BlockAddr, u32BlockNum, u32MIUAddr);
2039 while (1)
2040 {
2041 retrycnt++;
2042 result= bSCSI_Read_Write10(FALSE,lun, u32BlockAddr, u32BlockNum, PhytoCacheAddr(u32MIUAddr));
2043 if (result==TRUE) break;
2044 if (result==FALSE)
2045 {
2046 if (retrycnt > gUsbRetryCount)
2047 {
2048 if (gUsbStatus==USB_TIMEOUT)
2049 gUsbDeviceState=BAD_DEVICE; //mark as bad device
2050 else if(gUsbStatus == USB_OK)
2051 {//give another chance : to restart the host & device(for example : read failed with device STALL)
2052 if(retrycnt > gUsbRetryCount+1)
2053 break;
2054 if (MDrv_Usb_Device_Enum()==FALSE)
2055 {
2056 result=FALSE;
2057 break;
2058 }
2059 continue;
2060 }
2061 else
2062 LunDevice[lun].bDeviceValid=FALSE; //mark as bad lun
2063
2064 break; //return FALSE
2065 }
2066 MINI_DEBUG( printf("USBDisk Read failed\n"));
2067 if (gUsbStatus==USB_TIMEOUT)
2068 {
2069 if ((retrycnt==2)&&(mwOTG20_Control_HOST_SPD_TYP_Rd()==2) ) //make sure it is hi speed
2070 {
2071 MINI_DEBUG(printf("Force FS\n"));
2072 UHC_ORXBYTE(0x40,0x80);//force enter FSmode
2073 }
2074 #ifndef ATV_SERISE_USE
2075 msAPI_Timer_ResetWDT();
2076 #else
2077 #ifdef Enable_Close_INT
2078 XBYTE[0x2B00]&=0xFD;
2079 EnableINT();
2080 #endif
2081 #endif
2082
2083 #ifdef Enable_Low_Temperature_Patch
2084 if(gSpeed==0)
2085 {
2086 //printf("\r\n CDR toggle!!",0);
2087 UTMI_SETXBYTE(0x0a, UTMI_READXBYTE(0x0a)^0x10); //invert CDR_CLOCK
2088 UTMI_ORXBYTE(0x06,0x03); //reset UTMI
2089 UTMI_ANDXBYTE(0x06,0xfc);
2090 }
2091 #endif
2092
2093 // MDrv_Usb_Device_Enum(); //reinit usb device
2094 if (MDrv_Usb_Device_Enum()==FALSE)
2095 {
2096 result=FALSE;
2097 break;
2098 }
2099 }
2100 }
2101
2102 }
2103
2104 #ifdef ATV_SERISE_USE
2105 #ifdef Enable_Close_INT
2106 XBYTE[0x2B00]&=0xFD;
2107 EnableINT();
2108 #endif
2109 #endif
2110 //MDrv_Sys_ReleaseXdataWindow1();
2111 if (result==FALSE)
2112 {
2113 DRV_USB_DBG(printf("USBDisk Read failed\n"));
2114 //printf("read failed\n");
2115 }
2116
2117 return result;
2118
2119 }
2120
MDrv_UsbBlockWriteFromMIU(U8 lun,U32 u32BlockAddr,U32 u32BlockNum,U32 u32MIUAddr)2121 BOOLEAN MDrv_UsbBlockWriteFromMIU(U8 lun, U32 u32BlockAddr, U32 u32BlockNum,U32 u32MIUAddr)
2122 {
2123 BOOLEAN result;
2124 if (mwHost20_PORTSC_ConnectStatus_Rd()==0)
2125 return FALSE; //device is not connected
2126
2127 if (gUsbDeviceState==BAD_DEVICE) return FALSE;
2128
2129 if (u32BlockAddr > Mass_stor_us1.Mass_stor_device[lun].u32BlockTotalNum)
2130 {
2131 MINI_DEBUG(printf("USBWrite address is over the range:%lx\n",u32BlockAddr));
2132 return FALSE;
2133 }
2134
2135
2136 result= bSCSI_Read_Write10(TRUE,lun, u32BlockAddr, u32BlockNum, PhytoCacheAddr(u32MIUAddr));
2137
2138
2139 return result;
2140
2141 }
MDrv_GetUsbBlockSize(U8 lun)2142 U32 MDrv_GetUsbBlockSize(U8 lun)
2143 {
2144 return Mass_stor_us1.Mass_stor_device[lun].u32BlockSize;
2145 }
2146
MDrv_GetUsbBlockNum(U8 lun)2147 U32 MDrv_GetUsbBlockNum(U8 lun)
2148 {
2149 return Mass_stor_us1.Mass_stor_device[lun].u32BlockTotalNum;
2150 }
2151
2152
MDrv_USB_GetXDataExtStackCount(void)2153 U8 MDrv_USB_GetXDataExtStackCount(void)
2154 {
2155 return xdwin1_lockCount;
2156 }
2157 //---if you don't know how to use it, don't use it
2158
2159 #if 0
2160 void EnterUXBMode(void)
2161 {
2162 MINI_DEBUG( printf("Enter UXB mode\n"));
2163 UHC_XBYTE(0x40)|=0x80;//force enter FSmode
2164 MDrv_Usb_Device_Enum();
2165 }
2166 void LeaveUXBMode(oid)
2167 {
2168 MINI_DEBUG(printf("leave UXB mode \n"));
2169 UHC_XBYTE(0x40)&=~0x80;//leave FSmode
2170 MDrv_Usb_Device_Enum();
2171
2172 }
2173 #endif
2174 #ifndef DEVICE_ENUM_SEGMENT
MDrv_Usb_Device_Enum(void)2175 BOOLEAN MDrv_Usb_Device_Enum(void)
2176 {
2177 BOOLEAN result=FALSE;
2178 U8 RetryCount=0;
2179
2180 U8 rootUSBDeviceInterfaceClass = USB_INTERFACE_CLASS_NONE;
2181
2182 if (gUsbDeviceState==BAD_DEVICE) return FALSE; //bad device , no more enumerate
2183
2184 //20120820, Patch for devices, can't repeat to re-enumerate.
2185 if ( (gUsbDeviceState==USB11_DEVICE) ||(gUsbDeviceState==USB20_DEVICE) )
2186 {
2187 U16 uVID, uPID;
2188 U8 ii;
2189
2190 MDrv_USBGetVIDPID(&uVID, &uPID);
2191 ii = 0;
2192 while ( (gDontReEnumList[ii].VID != 0) && (gDontReEnumList[ii].PID != 0) )
2193 {
2194 if ( (uVID == gDontReEnumList[ii].VID) && (uPID == gDontReEnumList[ii].PID) )
2195 {
2196 printf("Don't re-enumerate for special device.");
2197 return TRUE;
2198 }
2199
2200 ii++;
2201 if (ii >= (sizeof(gDontReEnumList) / sizeof(struct stDontReEnumList)))
2202 break;
2203 }
2204 }
2205
2206 NowIsHub=0;
2207
2208 #ifdef Enable_SOF_Only
2209 UHC_ORXBYTE(0x40,0x80);//force enter FSmode
2210 #endif
2211 redo_init:
2212 //USB ROOT
2213 RetryCount++;
2214 if (MDrv_UsbHost_Init()==FALSE) goto fail_exit;
2215 if (flib_Host20_Enumerate(1,3)==0)
2216 {
2217 if ((gUsbStatus==USB_TIMEOUT)||(gUsbStatus==USB_INIT_FAIL))
2218 {
2219 #ifdef DTV_STANDARD_LIB
2220 if ((RetryCount==2)&&(mwOTG20_Control_HOST_SPD_TYP_Rd()==2))
2221 { //make sure it is hi speed
2222 MINI_DEBUG(printf("Force FS\n"));
2223 UHC_ORXBYTE(0x40,0x80);//force enter FSmode
2224 }
2225 #endif
2226 if (RetryCount >= 3)
2227 {
2228 MINI_DEBUG(printf("bad device\n"));
2229 gUsbDeviceState=BAD_DEVICE;
2230 goto fail_exit;
2231 }
2232 #ifndef ATV_SERISE_USE
2233 msAPI_Timer_ResetWDT();
2234 #endif
2235 goto redo_init;
2236 }
2237 gUsbDeviceState=BAD_DEVICE;
2238 goto fail_exit;
2239 }
2240 else
2241 {
2242 UTMI_SETXBYTE(0x2a,0);
2243
2244 rootUSBDeviceInterfaceClass= sAttachDevice.saCD[0].sInterface[0].bInterfaceClass;
2245 //MDrv_UsbGetInterfaceClass(0, 0);
2246 DRV_USB_DBG(printf("Check USD Device 4\n"););
2247 #if 0 // We don't need to check here
2248 if(rootUSBDeviceInterfaceClass != 0x08 && rootUSBDeviceInterfaceClass != 0x09)
2249 {
2250 //printf("unsupport class\n",0);
2251 DRV_USB_DBG(printf("unsupport USB root class=%02bx\n", rootUSBDeviceInterfaceClass););
2252 result= FALSE;
2253 goto fail_exit;
2254 }
2255 #endif
2256
2257 DRV_USB_DBG(printf("USB root class=%02bx\n",rootUSBDeviceInterfaceClass););
2258 if (rootUSBDeviceInterfaceClass==USB_INTERFACE_CLASS_HUB)//HUB
2259 {
2260 U8 PortNum,i,devaddr,stor_devs;
2261
2262 #ifdef ENABLE_HOST_TEST
2263 printf("Unsupport USB hub\n");
2264 gUsbDeviceState=BAD_DEVICE;
2265 goto fail_exit;
2266 #endif
2267
2268 devaddr=6;
2269 stor_devs = 0;
2270 DRV_USB_DBG(printf("Hub class!\n"));
2271
2272 PortNum=Usb_Hub_Port_Num();
2273 for (i=1; i <=PortNum ; i++)
2274 {
2275 sAttachDevice.bAdd=3;
2276 pHost20_qHD_List_Control1->bDeviceAddress=sAttachDevice.bAdd;
2277 if (USB_Hub_Handle(i)==FALSE)
2278 {
2279 result=FALSE;
2280 continue;
2281 }
2282 devaddr++;
2283 NowIsHub=1;
2284 if (flib_Host20_Enumerate(1,devaddr)==0)
2285 {
2286 result=FALSE;
2287 continue;
2288 }
2289
2290 //MStar, 20111110, For card reader with internal hub
2291 if (sAttachDevice.saCD[0].sInterface[0].bInterfaceClass == 0x08)
2292 stor_devs++;
2293
2294 sAttachDevice.bAdd=devaddr;
2295 result=MassStorage_Init(); //do mass storage class init
2296 if (result==TRUE) break;
2297 }
2298
2299 if ( (result==FALSE) && (stor_devs == 0) )
2300 {
2301 MINI_DEBUG(printf("unsupport hub class device,->bad device\n"));
2302 gUsbDeviceState=BAD_DEVICE;
2303 }
2304 }
2305
2306 //else if(rootUSBDeviceInterfaceClass==USB_INTERFACE_CLASS_MSD)//Mass storage class
2307 else if ( (rootUSBDeviceInterfaceClass == USB_INTERFACE_CLASS_MSD) &&
2308 (sAttachDevice.saCD[0].sInterface[0].bInterfaceProtocol == 0x50) )
2309 {
2310 result=MassStorage_Init();
2311 #ifdef Enable_Burning_Test
2312 UsbTest();
2313 #endif
2314
2315 #ifdef Enable_Performance_Read_Test
2316 UsbPerformanceReadTest();
2317 #endif
2318
2319 #ifdef Enable_Performance_Write_Test
2320 UsbPerformanceWriteTest();
2321 #endif
2322
2323 #ifdef Enable_Low_Temperature_Patch
2324 if((gSpeed==0)&&(gUsbStatus==USB_TIMEOUT))
2325 {
2326 //printf("\r\n CDR toggle!!",0);
2327 UTMI_SETXBYTE(0x0a, UTMI_READXBYTE(0x0a)^0x10); //invert CDR_CLOCK
2328 UTMI_ORXBYTE(0x06,0x03); //reset UTMI
2329 UTMI_ANDXBYTE(0x06,0xfc);
2330 }
2331 #endif
2332
2333 }
2334 #ifdef ENABLE_CBI_HOST
2335 else if ( (rootUSBDeviceInterfaceClass == USB_INTERFACE_CLASS_MSD) &&
2336 ((sAttachDevice.saCD[0].sInterface[0].bInterfaceProtocol == 0x00)||
2337 (sAttachDevice.saCD[0].sInterface[0].bInterfaceProtocol == 0x01)) )
2338 {
2339 DRV_USB_DBG(printf("My CBI MassStorage Device!!!\n"));
2340
2341 result=MassStorage_Init(); //do mass storage class init
2342 return result;
2343 }
2344 #endif
2345 else if (rootUSBDeviceInterfaceClass == USB_INTERFACE_CLASS_IMAGE)
2346 {
2347 if (drvUSBHost_PTP_Init(USB_PORT_0) == PTP_OK)
2348 {
2349 result = TRUE;
2350 DRV_USB_DBG(printf("PTP initial ok\r\n"));
2351 }
2352 }
2353 else if (rootUSBDeviceInterfaceClass==USB_INTERFACE_CLASS_HID)//HID
2354 {
2355 if (drvUSBHost_HID_Init(USB_PORT_0) == 0)
2356 {
2357 result = TRUE;
2358 DRV_USB_DBG(printf("HID initial ok\r\n"));
2359 }
2360 }
2361 else
2362 {
2363 MINI_DEBUG(printf("unsupport %02bx class device->bad device\n",rootUSBDeviceInterfaceClass));
2364 gUsbDeviceState=BAD_DEVICE; //not belong to any above
2365 }
2366
2367 DRV_USB_DBG(printf("USB_CON\n"););
2368 //return result;
2369 }
2370
2371 fail_exit:
2372
2373 if (mwHost20_PORTSC_ConnectChange_Rd())
2374 mwHost20_PORTSC_ConnectChange_Set();
2375
2376 return result;
2377 }
2378 #else // support device enumeration dividable
_MDrv_Usb_Device_Enum0(void)2379 U8 _MDrv_Usb_Device_Enum0(void)
2380 {
2381 if (gUsbDeviceState==BAD_DEVICE)
2382 return 0; //bad device , no more enumerate
2383
2384 //20120820, Patch for devices, can't repeat to re-enumerate.
2385 if ( (gUsbDeviceState==USB11_DEVICE) ||(gUsbDeviceState==USB20_DEVICE) )
2386 {
2387 U16 uVID, uPID;
2388 U8 ii;
2389
2390 MDrv_USBGetVIDPID(&uVID, &uPID);
2391 ii = 0;
2392 while ( (gDontReEnumList[ii].VID != 0) && (gDontReEnumList[ii].PID != 0) )
2393 {
2394 if ( (uVID == gDontReEnumList[ii].VID) && (uPID == gDontReEnumList[ii].PID) )
2395 {
2396 printf("Don't re-enumerate for special device.");
2397 return 1;
2398 }
2399
2400 ii++;
2401 if (ii >= (sizeof(gDontReEnumList) / sizeof(struct stDontReEnumList)))
2402 break;
2403 }
2404 }
2405
2406 NowIsHub=0;
2407
2408 #ifdef Enable_SOF_Only
2409 UHC_ORXBYTE(0x40,0x80);//force enter FSmode
2410 #endif
2411
2412 return 2;
2413 }
2414
_MDrv_Usb_Device_Enum_OK(void)2415 BOOLEAN _MDrv_Usb_Device_Enum_OK(void)
2416 {
2417 BOOLEAN result=FALSE;
2418 U8 rootUSBDeviceInterfaceClass = USB_INTERFACE_CLASS_NONE;
2419
2420 UTMI_SETXBYTE(0x2a,0);
2421
2422 rootUSBDeviceInterfaceClass= sAttachDevice.saCD[0].sInterface[0].bInterfaceClass;
2423 //MDrv_UsbGetInterfaceClass(0, 0);
2424 DRV_USB_DBG(printf("Check USD Device 4\n"););
2425 #if 0 // We don't need to check here
2426 if(rootUSBDeviceInterfaceClass != 0x08 && rootUSBDeviceInterfaceClass != 0x09)
2427 {
2428 //printf("unsupport class\n",0);
2429 DRV_USB_DBG(printf("unsupport USB root class=%02bx\n", rootUSBDeviceInterfaceClass););
2430 result= FALSE;
2431 goto fail_exit;
2432 }
2433 #endif
2434
2435 DRV_USB_DBG(printf("USB root class=%02bx\n",rootUSBDeviceInterfaceClass););
2436 if (rootUSBDeviceInterfaceClass==USB_INTERFACE_CLASS_HUB)//HUB
2437 {
2438 U8 PortNum,i,devaddr,stor_devs;
2439
2440 #ifdef ENABLE_HOST_TEST
2441 printf("Unsupport USB hub\n");
2442 gUsbDeviceState=BAD_DEVICE;
2443 return FALSE;
2444 #endif
2445
2446 devaddr=6;
2447 stor_devs = 0;
2448 DRV_USB_DBG(printf("Hub class!\n"));
2449
2450 PortNum=Usb_Hub_Port_Num();
2451 for (i=1; i <=PortNum ; i++)
2452 {
2453 sAttachDevice.bAdd=3;
2454 pHost20_qHD_List_Control1->bDeviceAddress=sAttachDevice.bAdd;
2455 if (USB_Hub_Handle(i)==FALSE)
2456 {
2457 result=FALSE;
2458 continue;
2459 }
2460 devaddr++;
2461 NowIsHub=1;
2462 if (flib_Host20_Enumerate(1,devaddr)==0)
2463 {
2464 result=FALSE;
2465 continue;
2466 }
2467
2468 //MStar, 20111110, For card reader with internal hub
2469 if (sAttachDevice.saCD[0].sInterface[0].bInterfaceClass == 0x08)
2470 stor_devs++;
2471
2472 sAttachDevice.bAdd=devaddr;
2473 result=MassStorage_Init(); //do mass storage class init
2474 if (result==TRUE) break;
2475 }
2476
2477 if ( (result==FALSE) && (stor_devs == 0) )
2478 {
2479 MINI_DEBUG(printf("unsupport hub class device,->bad device\n"));
2480 gUsbDeviceState=BAD_DEVICE;
2481 }
2482 }
2483
2484 //else if(rootUSBDeviceInterfaceClass==USB_INTERFACE_CLASS_MSD)//Mass storage class
2485 else if ( (rootUSBDeviceInterfaceClass == USB_INTERFACE_CLASS_MSD) &&
2486 (sAttachDevice.saCD[0].sInterface[0].bInterfaceProtocol == 0x50) )
2487 {
2488 result=MassStorage_Init();
2489 #ifdef Enable_Burning_Test
2490 UsbTest();
2491 #endif
2492
2493 #ifdef Enable_Performance_Read_Test
2494 UsbPerformanceReadTest();
2495 #endif
2496
2497 #ifdef Enable_Performance_Write_Test
2498 UsbPerformanceWriteTest();
2499 #endif
2500
2501 #ifdef Enable_Low_Temperature_Patch
2502 if((gSpeed==0)&&(gUsbStatus==USB_TIMEOUT))
2503 {
2504 //printf("\r\n CDR toggle!!",0);
2505 UTMI_SETXBYTE(0x0a, UTMI_READXBYTE(0x0a)^0x10); //invert CDR_CLOCK
2506 UTMI_ORXBYTE(0x06,0x03); //reset UTMI
2507 UTMI_ANDXBYTE(0x06,0xfc);
2508 }
2509 #endif
2510
2511 }
2512 #ifdef ENABLE_CBI_HOST
2513 else if ( (rootUSBDeviceInterfaceClass == USB_INTERFACE_CLASS_MSD) &&
2514 ((sAttachDevice.saCD[0].sInterface[0].bInterfaceProtocol == 0x00)||
2515 (sAttachDevice.saCD[0].sInterface[0].bInterfaceProtocol == 0x01)) )
2516 {
2517 DRV_USB_DBG(printf("My CBI MassStorage Device!!!\n"));
2518
2519 result=MassStorage_Init(); //do mass storage class init
2520 //return result;
2521 }
2522 #endif
2523 else if (rootUSBDeviceInterfaceClass == USB_INTERFACE_CLASS_IMAGE)
2524 {
2525 if (drvUSBHost_PTP_Init(USB_PORT_0) == PTP_OK)
2526 {
2527 result = TRUE;
2528 DRV_USB_DBG(printf("PTP initial ok\r\n"));
2529 }
2530 }
2531 else if (rootUSBDeviceInterfaceClass==USB_INTERFACE_CLASS_HID)//HID
2532 {
2533 if (drvUSBHost_HID_Init(USB_PORT_0) == 0)
2534 {
2535 result = TRUE;
2536 DRV_USB_DBG(printf("HID initial ok\r\n"));
2537 }
2538 }
2539 else
2540 {
2541 MINI_DEBUG(printf("unsupport %02bx class device->bad device\n",rootUSBDeviceInterfaceClass));
2542 gUsbDeviceState=BAD_DEVICE; //not belong to any above
2543 }
2544
2545 DRV_USB_DBG(printf("USB_CON\n"););
2546 //return result;
2547
2548 return result;
2549 }
MDrv_Usb_Device_Enum(void)2550 BOOLEAN MDrv_Usb_Device_Enum(void)
2551 {
2552 BOOLEAN result=FALSE;
2553 U8 RetryCount=0, retval;
2554
2555 retval = _MDrv_Usb_Device_Enum0();
2556 if (retval != 2)
2557 return (retval == 0 ? FALSE: TRUE);
2558
2559 redo_init:
2560 //USB ROOT
2561 RetryCount++;
2562 if (MDrv_UsbHost_Init()==FALSE) goto fail_exit;
2563 if (flib_Host20_Enumerate(1,3)==0)
2564 {
2565 if ((gUsbStatus==USB_TIMEOUT)||(gUsbStatus==USB_INIT_FAIL))
2566 {
2567 #ifdef DTV_STANDARD_LIB
2568 if ((RetryCount==2)&&(mwOTG20_Control_HOST_SPD_TYP_Rd()==2))
2569 { //make sure it is hi speed
2570 MINI_DEBUG(printf("Force FS\n"));
2571 UHC_ORXBYTE(0x40,0x80);//force enter FSmode
2572 }
2573 #endif
2574 if (RetryCount >= 3)
2575 {
2576 MINI_DEBUG(printf("bad device\n"));
2577 gUsbDeviceState=BAD_DEVICE;
2578 goto fail_exit;
2579 }
2580 #ifndef ATV_SERISE_USE
2581 msAPI_Timer_ResetWDT();
2582 #endif
2583 goto redo_init;
2584 }
2585 gUsbDeviceState=BAD_DEVICE;
2586 goto fail_exit;
2587 }
2588 else
2589 {
2590 result = _MDrv_Usb_Device_Enum_OK();
2591 }
2592
2593 fail_exit:
2594
2595 if (mwHost20_PORTSC_ConnectChange_Rd())
2596 mwHost20_PORTSC_ConnectChange_Set();
2597
2598 return result;
2599 }
2600
2601 /*
2602 Device Enumerate State:
2603 0: global variable initial
2604 1: ready to start new enumerating process
2605 2: in-progress, stage 1
2606 3: in-progress, stage 2
2607 return value:
2608 0: success
2609 1: in-progress
2610 2: fail
2611 */
2612 U8 enum_state = 0;
2613 U32 usbDevEnumTimer;
MDrv_Usb_Device_Enum_EX(void)2614 U8 MDrv_Usb_Device_Enum_EX(void)
2615 {
2616 BOOLEAN result=FALSE;
2617 U8 retval;
2618 static U8 RetryCount;
2619 static U8 fr;
2620
2621 redo_init_ex:
2622 //USB ROOT
2623 switch (enum_state)
2624 {
2625 case 0: // initial global variables
2626 RetryCount = 0;
2627 retval = _MDrv_Usb_Device_Enum0();
2628 if (retval != 2)
2629 return (retval == 0 ? DEVENUM_FAIL: DEVENUM_OK);
2630
2631 case 1: // first entry
2632 RetryCount++;
2633 if (_MDrv_UsbHost_Init0()==FALSE)
2634 goto fail_exit_ex; // MDrv_UsbHost_Init() part 1
2635 enum_state = 2;
2636 usbDevEnumTimer = MsOS_GetSystemTime();
2637 return DEVENUM_INPROGRESS;
2638
2639 case 2: // in-progress stage 1
2640 if (MsOS_Timer_DiffTimeFromNow(usbDevEnumTimer) < USB_HOST_INIT_DELAY)
2641 return DEVENUM_INPROGRESS;
2642
2643 if (_MDrv_UsbHost_Init1()==FALSE) // MDrv_UsbHost_Init() part 2
2644 goto fail_exit_ex;
2645
2646 fr = _flib_Host20_Enumerate(1, 3); // flib_Host20_Enumerate() part 1
2647 if (fr ==0)
2648 break;
2649
2650 enum_state = 3;
2651 usbDevEnumTimer = MsOS_GetSystemTime();
2652 return DEVENUM_INPROGRESS;
2653
2654 case 3: // in-progress stage 2
2655 if (MsOS_Timer_DiffTimeFromNow(usbDevEnumTimer) < USB_ENUM_DELAY)
2656 return DEVENUM_INPROGRESS;
2657
2658 }
2659
2660 if (fr==0)
2661 {
2662 if ((gUsbStatus==USB_TIMEOUT)||(gUsbStatus==USB_INIT_FAIL))
2663 {
2664 #ifdef DTV_STANDARD_LIB
2665 if ((RetryCount==2)&&(mwOTG20_Control_HOST_SPD_TYP_Rd()==2))
2666 { //make sure it is hi speed
2667 MINI_DEBUG(printf("Force FS\n"));
2668 UHC_ORXBYTE(0x40,0x80);//force enter FSmode
2669 }
2670 #endif
2671 if (RetryCount >= 3)
2672 {
2673 MINI_DEBUG(printf("bad device\n"));
2674 gUsbDeviceState=BAD_DEVICE;
2675 goto fail_exit_ex;
2676 }
2677 #ifndef ATV_SERISE_USE
2678 msAPI_Timer_ResetWDT();
2679 #endif
2680 enum_state = 1; // retry use
2681 goto redo_init_ex;
2682 }
2683 gUsbDeviceState=BAD_DEVICE;
2684 goto fail_exit_ex;
2685 }
2686 else
2687 {
2688 result = _MDrv_Usb_Device_Enum_OK();
2689 }
2690
2691 fail_exit_ex:
2692
2693 if (mwHost20_PORTSC_ConnectChange_Rd())
2694 mwHost20_PORTSC_ConnectChange_Set();
2695 enum_state = 0; // reset to initial
2696
2697 //return result;
2698 return ( result ? DEVENUM_OK : DEVENUM_FAIL);
2699 }
2700 #endif
2701 //////////////////////////////////////////////////////////////////////////////////////////
2702 //
2703 // USB Issue Test packet function !!
2704 //
2705 /////////////////////////////////////////////////////////////////////////////////////////
2706 U8 UTMI_Reg_14 = 0xff, UTMI_Reg_15 = 0xff;
Port0_IssueTestPacket_Initial(void)2707 void Port0_IssueTestPacket_Initial(void)
2708 {
2709 UTMI_SETXBYTE(0x02, 0x84);
2710 UTMI_SETXBYTE(0x03, 0x20);
2711
2712 USBC_SETXBYTE(0x00, 0x0A);
2713 USBC_SETXBYTE(0x00, 0x28);
2714
2715 UTMI_SETXBYTE(0x06, 0x00);
2716 UTMI_SETXBYTE(0x07, 0x00);
2717 UTMI_SETXBYTE(0x10, 0x00);
2718 UTMI_SETXBYTE(0x11, 0x00);
2719 UTMI_SETXBYTE(0x2c, 0x00);
2720 UTMI_SETXBYTE(0x2d, 0x00);
2721 UTMI_SETXBYTE(0x2e, 0x00);
2722 UTMI_SETXBYTE(0x2f, 0x00);
2723 if (UTMI_Reg_14 == 0xff)
2724 UTMI_Reg_14 = UTMI_READXBYTE(0x14);
2725 else
2726 UTMI_SETXBYTE(0x14, UTMI_Reg_14);
2727
2728 if (UTMI_Reg_15 == 0xff)
2729 UTMI_Reg_15 = UTMI_READXBYTE(0x15);
2730 else
2731 UTMI_SETXBYTE(0x15, UTMI_Reg_15);
2732
2733 UTMI_ORXBYTE(0x06,0x40); //Force HS TX current enable and CDR stage select
2734 UTMI_ANDXBYTE(0x06,~0x20); //clear bit 5
2735
2736 UTMI_ORXBYTE(0x06,0x03); //reset UTMI
2737 MsOS_DelayTask(2);
2738 UTMI_ANDXBYTE(0x06,0xfc);
2739
2740 UTMI_SETXBYTE(0x03, 0xa8); //for device disconnect status bit
2741 //XBYTE[UTMIBaseAddr+0x07]|=0x02; //
2742
2743 if (MDrv_USBGetChipID()==CHIPID_NEPTUNE) //Neptune , after U06
2744 {
2745 if (MDrv_USBGetChipVersion()>= 0x6) //U07
2746 {
2747 UTMI_ORXBYTE(0x07, 0x02);
2748 UTMI_SETXBYTE(0x2c,0xc1);
2749 UTMI_SETXBYTE(0x2d,0x3b);//enable TX common mode,
2750 UTMI_ORXBYTE(0x2f, 0x0e); //preemsis
2751 }
2752 }
2753 else if ((MDrv_USBGetChipID()>=CHIPID_ERIS)&&(MDrv_USBGetChipID()<=CHIPID_TITANIA)) //Eris: 3 ,Titania: 4,
2754 {
2755 UTMI_SETXBYTE(0x2c,0xc5);
2756 UTMI_SETXBYTE(0x2d,0x3b);//enable TX common mode,
2757 UTMI_ORXBYTE(0x2f, 0x0e); //preemsis
2758 }
2759 else if (MDrv_USBGetChipID()==CHIPID_PLUTO) // Pluto: 5
2760 {
2761 UTMI_ORXBYTE(0x2c, 0xc5);
2762 UTMI_ORXBYTE(0x2d, 0x3);//enable TX common mode,
2763 UTMI_ORXBYTE(0x2f, 0x4a); //preemsis
2764 UTMI_ORXBYTE(0x13, 0x70);
2765 }
2766 else if (MDrv_USBGetChipID()==CHIPID_TITANIA2) // Titania 2
2767 {
2768 UTMI_ORXBYTE(0x2c, 0xc1);
2769 UTMI_ORXBYTE(0x2d, 0x3);//enable TX common mode,
2770 UTMI_ORXBYTE(0x2f, 0x4a); //preemsis
2771 }
2772 else if (MDrv_USBGetChipID()==CHIPID_TRITON) //Triton=6
2773 {
2774 UTMI_SETXBYTE(0x2c,0xc1);
2775 UTMI_SETXBYTE(0x2d,0x3b);//enable TX common mode,
2776 UTMI_ORXBYTE(0x2f,0x0e); //preemsis
2777 }
2778 else if (MDrv_USBGetChipID()==CHIPID_EUCLID) // Euclid
2779 {
2780 UTMI_ORXBYTE(0x2c, 0xc1);
2781 UTMI_ORXBYTE(0x2d, 0x3);//enable TX common mode,
2782 UTMI_ORXBYTE(0x2f, 0x4a); //preemsis
2783 }
2784 else if ( (MDrv_USBGetChipID()==CHIPID_TITANIA3) || // Titania 3, Titania 4
2785 (MDrv_USBGetChipID()==CHIPID_TITANIA4) ||
2786 (MDrv_USBGetChipID()==CHIPID_TITANIA7) ||
2787 (MDrv_USBGetChipID()==CHIPID_TITANIA8) ||
2788 (MDrv_USBGetChipID()==CHIPID_TITANIA9) ||
2789 (MDrv_USBGetChipID()==CHIPID_TITANIA12) ||
2790 (MDrv_USBGetChipID()==CHIPID_TITANIA13) ||
2791 (MDrv_USBGetChipID()==CHIPID_JANUS) ||
2792 (MDrv_USBGetChipID() == CHIPID_MARIA10) ||
2793 (MDrv_USBGetChipID() == CHIPID_MACAW12) ||
2794 (MDrv_USBGetChipID() == CHIPID_JANUS2) ||
2795 (MDrv_USBGetChipID() == CHIPID_AMBER6) )
2796 {
2797 UTMI_ORXBYTE(0x2c, 0x10); //TX-current adjust to 105%
2798 UTMI_ORXBYTE(0x2d, 0x02); //Pre-emphasis enable
2799 UTMI_ORXBYTE(0x2f, 0x81); //HS_TX common mode current enable (100mV);Pre-emphasis enable (10%)
2800 UTMI_ORXBYTE(0x09,0x81); //UTMI RX anti-dead-lock, ISI improvement
2801 }
2802 else //for Amber1 later 40nm
2803 {
2804 UTMI_ORXBYTE(0x2c, 0x50);
2805 UTMI_ORXBYTE(0x2d, 0x02);
2806 UTMI_ORXBYTE(0x2f, 0x01);
2807 UTMI_ORXBYTE(0x09,0x81); //UTMI RX anti-dead-lock, ISI improvement
2808 }
2809
2810 if (MDrv_USBGetChipID()==CHIPID_PLUTO) // If is Pluto
2811 UTMI_ORXBYTE(0x09,0x01); //ISI improvement
2812 else
2813 UTMI_ORXBYTE(0x13,0x02); //ISI improvement
2814
2815 if ( (MDrv_USBGetChipID() == CHIPID_NEPTUNE) ||
2816 (MDrv_USBGetChipID() == CHIPID_ERIS) ||
2817 (MDrv_USBGetChipID() == CHIPID_TITANIA) ||
2818 (MDrv_USBGetChipID() == CHIPID_PLUTO) ||
2819 (MDrv_USBGetChipID() == CHIPID_TRITON) ||
2820 (MDrv_USBGetChipID() == CHIPID_TITANIA2) )
2821 {
2822 }
2823 else
2824 {
2825 UTMI_ORXBYTE(0x0b, 0x80); //TX timing select latch path
2826 }
2827
2828 UTMI_ORXBYTE(0x09,0x60);//0x20; //patch low tempture,FL meta issue and enable new FL RX engin
2829
2830 if ( (MDrv_USBGetChipID() == CHIPID_NEPTUNE) ||
2831 (MDrv_USBGetChipID() == CHIPID_ERIS) ||
2832 (MDrv_USBGetChipID() == CHIPID_TITANIA) ||
2833 (MDrv_USBGetChipID() == CHIPID_PLUTO) ||
2834 (MDrv_USBGetChipID() == CHIPID_TRITON) ||
2835 (MDrv_USBGetChipID() == CHIPID_TITANIA2) ||
2836 (MDrv_USBGetChipID() == CHIPID_TITANIA3) ||
2837 (MDrv_USBGetChipID() == CHIPID_TITANIA4) ||
2838 (MDrv_USBGetChipID() == CHIPID_TITANIA7) ||
2839 (MDrv_USBGetChipID() == CHIPID_TITANIA8) ||
2840 (MDrv_USBGetChipID() == CHIPID_TITANIA9) ||
2841 (MDrv_USBGetChipID() == CHIPID_TITANIA12) ||
2842 (MDrv_USBGetChipID() == CHIPID_TITANIA13) ||
2843 (MDrv_USBGetChipID() == CHIPID_JANUS) ||
2844 (MDrv_USBGetChipID() == CHIPID_MARIA10) ||
2845 (MDrv_USBGetChipID() == CHIPID_MACAW12) ||
2846 (MDrv_USBGetChipID() == CHIPID_JANUS2) ||
2847 (MDrv_USBGetChipID() == CHIPID_AMBER1) ||
2848 (MDrv_USBGetChipID() == CHIPID_AMBER3) ||
2849 (MDrv_USBGetChipID() == CHIPID_AMBER5) ||
2850 (MDrv_USBGetChipID() == CHIPID_AMBER6) ||
2851 (MDrv_USBGetChipID() == CHIPID_AMBER7) ||
2852 (MDrv_USBGetChipID() == CHIPID_AMETHYST) )
2853 {
2854 UTMI_ORXBYTE(0x15,0x20); //HOST CHIRP Detect
2855 }
2856 else
2857 {
2858 UTMI_ORXBYTE(0x15,0x60); // change to 55 interface (bit6)
2859 }
2860
2861 //UHC_ORXBYTE(0x32,0x01); //Force issue test packet
2862 MsOS_DelayTask(10);
2863 }
2864
2865 #ifdef Enable_Issue_TestPacket
2866
2867 extern void USB_DACHE_FLUSH(U32 addr, U32 length);
2868
IssueTestPacket(U8 xdata * TestDataAddr)2869 void IssueTestPacket(U8 xdata *TestDataAddr)
2870 {
2871 U32 DMAAddress,datreg32;
2872 U8 xdata *TestData;
2873 #ifdef Issue_TestPacket
2874 U16 i;
2875 #endif
2876
2877 printf("Start Test Packet on Port0\n");
2878
2879 TestData=(U8*) KSEG02KSEG1(TestDataAddr);
2880
2881 #ifdef Issue_OUTTestPacket
2882 TestData[0]=0x55;
2883 TestData[1]=0x53;
2884 TestData[2]=0x42;
2885 TestData[3]=0x43;
2886 TestData[4]=0x88;
2887 TestData[5]=0x88;
2888 TestData[6]=0x89;
2889 TestData[7]=0xa0;
2890 TestData[8]=0x00;
2891 TestData[9]=0x02;
2892 TestData[10]=0x00;
2893 TestData[11]=0x00;
2894 TestData[12]=0x80;
2895 TestData[13]=0x00;
2896 TestData[14]=0x0a;
2897 TestData[15]=0x28;
2898 TestData[16]=0x00;
2899 TestData[17]=0x00;
2900 TestData[18]=0x00;
2901 TestData[19]=0x00;
2902 TestData[20]=0x84;
2903 TestData[21]=0x00;
2904 TestData[22]=0x00;
2905 TestData[23]=0x01;
2906 TestData[24]=0x00;
2907 TestData[25]=0x00;
2908 TestData[26]=0x00;
2909 TestData[27]=0x00;
2910 TestData[28]=0x00;
2911 TestData[29]=0x00;
2912 TestData[30]=0x00;
2913 #endif
2914
2915 //printf("3AAC:%x\n",XBYTE[ 0x3AAC]);
2916 //printf("UTMI(0x2c):%x\n",XBYTE[gUTMI_BASE+0x2C]);
2917 #ifdef Issue_TestPacket
2918 TestData[0]=0x0;
2919 TestData[1]=0x0;
2920 TestData[2]=0x0;
2921 TestData[3]=0x0;
2922 TestData[4]=0x0;
2923 TestData[5]=0x0;
2924 TestData[6]=0x0;
2925 TestData[7]=0x0;
2926 TestData[8]=0x0;
2927 TestData[9]=0xaa;
2928 TestData[10]=0xaa;
2929 TestData[11]=0xaa;
2930 TestData[12]=0xaa;
2931 TestData[13]=0xaa;
2932 TestData[14]=0xaa;
2933 TestData[15]=0xaa;
2934 TestData[16]=0xaa;
2935 TestData[17]=0xee;
2936 TestData[18]=0xee;
2937 TestData[19]=0xee;
2938 TestData[20]=0xee;
2939 TestData[21]=0xee;
2940 TestData[22]=0xee;
2941 TestData[23]=0xee;
2942 TestData[24]=0xee;
2943 TestData[25]=0xfe;
2944 TestData[26]=0xff;
2945 TestData[27]=0xff;
2946 TestData[28]=0xff;
2947 TestData[29]=0xff;
2948 TestData[30]=0xff;
2949 TestData[31]=0xff;
2950 TestData[32]=0xff;
2951 TestData[33]=0xff;
2952 TestData[34]=0xff;
2953 TestData[35]=0xff;
2954 TestData[36]=0xff;
2955 TestData[37]=0x7f;
2956 TestData[38]=0xbf;
2957 TestData[39]=0xdf;
2958 TestData[40]=0xef;
2959 TestData[41]=0xf7;
2960 TestData[42]=0xfb;
2961 TestData[43]=0xfd;
2962 TestData[44]=0xfc;
2963 TestData[45]=0x7e;
2964 TestData[46]=0xbf;
2965 TestData[47]=0xdf;
2966 TestData[48]=0xfb;
2967 TestData[49]=0xfd;
2968 TestData[50]=0xfb;
2969 TestData[51]=0xfd;
2970 TestData[52]=0x7e;
2971
2972 for (i=53; i<128; i++)
2973 TestData[i]= 0;
2974
2975 #endif
2976
2977 USB_DACHE_FLUSH((U32)TestDataAddr, 128);
2978
2979 //printf("[9]=%2bx\n", XBYTE[((U16)TestData)+9]);
2980
2981 //DbgPortEanble();
2982
2983 //UHC_XBYTE(0x50)|=0x14; //enable test packet and lookback
2984 UHC_ORXBYTE(0x50,0x14); //enable test packet and lookback
2985
2986 UTMI_ORXBYTE(0x06,0x03); //TR/RX reset
2987 UTMI_ANDXBYTE(0x06,0xFC);
2988
2989 while(1)
2990 {
2991
2992 DMAAddress=(U32)VA2PA(TestData);
2993
2994 //set DMA memory base address
2995 UHC_SETXBYTE(0x74,(U8)DMAAddress);
2996 UHC_SETXBYTE(0x75,(U8)(DMAAddress>>8));
2997 UHC_SETXBYTE(0x76,(U8)(DMAAddress>>16));
2998 UHC_SETXBYTE(0x77,(U8)(DMAAddress>>24));
2999
3000 //printf("start check 2474=%2bx\n",XBYTE[0x2474]);
3001 //printf("start check 2475=%2bx\n",XBYTE[0x2475]);
3002 //printf("start check 2476=%2bx\n",XBYTE[0x2476]);
3003 //printf("start check 2477=%2bx\n",XBYTE[0x2477]);
3004
3005
3006 //set DMA data Length and type(memory to FIFO)
3007 #ifdef Issue_TestPacket
3008 datreg32 = 53;
3009 #else
3010 datreg32 = 31;
3011 #endif
3012
3013 datreg32 = datreg32 << 8;
3014 datreg32 = datreg32 | 0x02;
3015
3016 UHC_SETXBYTE(0x70,(U8)datreg32);
3017 UHC_SETXBYTE(0x71,(U8)(datreg32>>8));
3018 UHC_SETXBYTE(0x72,(U8)(datreg32>>16));
3019 UHC_SETXBYTE(0x73,(U8)(datreg32>>24));
3020
3021 UHC_ORXBYTE(0x70,0x01);//DMA start
3022
3023 //printf("start check 2470=%2bx\n",XBYTE[0x2470]);
3024 //printf("start check 2471=%2bx\n",XBYTE[0x2471]);
3025 //printf("start check 2472=%2bx\n",XBYTE[0x2472]);
3026 //printf("start check 2473=%2bx\n",XBYTE[0x2473]);
3027
3028 //MsOS_DelayTask(1000);
3029
3030 //printf("start check 2444=%2bx\n",XBYTE[0x2444]);
3031
3032 while(!(UHC_READXBYTE(0x44) &0x08))
3033 {
3034 //printf("XBYTE[0x2444]=%2bx\n",XBYTE[0x2444]);
3035 //MsOS_DelayTask(10);//delay
3036 }
3037
3038 // printf("Dma success\n",0);
3039
3040 MsOS_DelayTask(10);
3041 }
3042
3043 }
3044
3045 #endif
3046
MDrv_SendTestPacketByHW(void)3047 void MDrv_SendTestPacketByHW(void)
3048 {
3049 printf("Start test packet on port 0\n");
3050 UTMI_SETXBYTE(0x14, 0x00);
3051 UTMI_SETXBYTE(0x15, 0x06);
3052
3053 UTMI_SETXBYTE(0x10, 0x38);
3054 UTMI_SETXBYTE(0x11, 0x00);
3055
3056 UTMI_SETXBYTE(0x32, 0xFE);
3057 UTMI_SETXBYTE(0x33, 0x0B);
3058 }
3059
IssueTestJ(void)3060 void IssueTestJ(void)
3061 {
3062 printf("TEST_J on Port0\n");
3063
3064 UTMI_SETXBYTE(0x2c, 0x04);
3065 UTMI_SETXBYTE(0x2d, 0x20);
3066 UTMI_SETXBYTE(0x2e, 0x00);
3067 UTMI_SETXBYTE(0x2f, 0x00);
3068
3069 USBC_ORXBYTE(0, 0x02); //Enable UHC_RST
3070 MsOS_DelayTask(10);
3071 USBC_ANDXBYTE(0, 0xFD);
3072
3073 //UHCREG(0x32)|=0x01;
3074 UHC_ORXBYTE(0x32,0x01);
3075 MsOS_DelayTask(10);
3076 //UHCREG(0x32)&=0xfe;
3077 UHC_ANDXBYTE(0x32,0xfe);
3078
3079 UHC_ORXBYTE(0x50,0x01); //enable test J
3080 }
3081
IssueTestK(void)3082 void IssueTestK(void)
3083 {
3084 printf("TEST_K on port0\n");
3085
3086 UTMI_SETXBYTE(0x2c, 0x04);
3087 UTMI_SETXBYTE(0x2d, 0x20);
3088 UTMI_SETXBYTE(0x2e, 0x00);
3089 UTMI_SETXBYTE(0x2f, 0x00);
3090
3091 USBC_ORXBYTE(0, 0x02); //Enable UHC_RST
3092 MsOS_DelayTask(10);
3093 USBC_ANDXBYTE(0, 0xFD);
3094
3095 //UHCREG(0x32)|=0x01;
3096 UHC_ORXBYTE(0x32,0x01);
3097 MsOS_DelayTask(10);
3098 //UHCREG(0x32)&=0xfe;
3099 UHC_ANDXBYTE(0x32,0xfe);
3100
3101 MsOS_DelayTask(10);
3102 UHC_ORXBYTE(0x50,0x02); //enable test K
3103 }
3104
IssueSE0(void)3105 void IssueSE0(void)
3106 {
3107 printf("SE0 on port0\n");
3108
3109 UTMI_SETXBYTE(0x06, 0xA0);
3110 UTMI_SETXBYTE(0x07, 0x04);
3111
3112 MsOS_DelayTask(10);
3113 USBC_ORXBYTE(0, 0x02); //Enable UHC_RST
3114 MsOS_DelayTask(10);
3115 USBC_ANDXBYTE(0, 0xFD);
3116
3117 UHC_ORXBYTE(0x32,0x01);
3118 MsOS_DelayTask(10);
3119 //UHCREG(0x32)&=0xfe;
3120 UHC_ANDXBYTE(0x32,0xfe);
3121 }
3122
3123
MDrv_UsbSendTestPacket(void)3124 void MDrv_UsbSendTestPacket(void)
3125 {
3126 drvUSBHost_TurnOffPowerDownMode();
3127 MsOS_DelayTask(500);
3128 Port0_IssueTestPacket_Initial();
3129 MDrv_SendTestPacketByHW();
3130 }
3131
MDrv_UsbSendSE0(void)3132 void MDrv_UsbSendSE0(void)
3133 {
3134 drvUSBHost_TurnOffPowerDownMode();
3135 MsOS_DelayTask(500);
3136 Port0_IssueTestPacket_Initial();
3137 IssueSE0();
3138 }
3139
MDrv_UsbSendTestJ(void)3140 void MDrv_UsbSendTestJ(void)
3141 {
3142 drvUSBHost_TurnOffPowerDownMode();
3143 MsOS_DelayTask(500);
3144 Port0_IssueTestPacket_Initial();
3145 IssueTestJ();
3146 }
3147
MDrv_UsbSendTestK(void)3148 void MDrv_UsbSendTestK(void)
3149 {
3150 drvUSBHost_TurnOffPowerDownMode();
3151 MsOS_DelayTask(500);
3152 Port0_IssueTestPacket_Initial();
3153 IssueTestK();
3154 }
3155
MDrv_GetUsbDeviceType()3156 U8 MDrv_GetUsbDeviceType()
3157 {
3158 U8 u8DevType;
3159
3160 if ( (gUsbDeviceState==BAD_DEVICE) ||
3161 (gUsbDeviceState==NO_DEVICE) ||
3162 (gUsbDeviceState==POWER_SAVING) )
3163 return USB_INTERFACE_CLASS_NONE;
3164
3165 u8DevType = sAttachDevice.saCD[0].sInterface[0].bInterfaceClass;
3166
3167
3168 return (u8DevType);
3169 }
3170
3171
MDrv_GetUsbString(U8 u8StrID,S8 * pStrBuf,U8 u8BufLen)3172 void MDrv_GetUsbString(U8 u8StrID, S8 *pStrBuf, U8 u8BufLen)
3173 {
3174 U8 ii;
3175
3176
3177 pStrBuf[0] = 0;
3178
3179 if (u8StrID == USB_STR_VENDOR)
3180 {
3181 for (ii=0; ii<u8BufLen; ii++)
3182 {
3183 pStrBuf[ii] = sAttachDevice.bStringManufacture[ii];
3184 if (pStrBuf[ii] == 0)
3185 break;
3186 }
3187 }
3188 else if (u8StrID == USB_STR_PRODUCT)
3189 {
3190 for (ii=0; ii<u8BufLen; ii++)
3191 {
3192 pStrBuf[ii] = sAttachDevice.bStringProduct[ii];
3193 if (pStrBuf[ii] == 0)
3194 break;
3195 }
3196 }
3197
3198
3199 }
3200
MDrv_USBGetqTDTimeoutValue(void)3201 U8 MDrv_USBGetqTDTimeoutValue(void)
3202 {
3203 return gUsbTimeout;
3204 }
3205
MDrv_USBSetqTDTimeoutValue(U8 u8Value)3206 void MDrv_USBSetqTDTimeoutValue(U8 u8Value)
3207 {
3208 gUsbTimeout = u8Value;
3209 }
3210
MDrv_USBGetIORetryCount(void)3211 U8 MDrv_USBGetIORetryCount(void)
3212 {
3213 return gUsbRetryCount;
3214 }
3215
MDrv_USBSetIORetryCount(U8 u8Value)3216 void MDrv_USBSetIORetryCount(U8 u8Value)
3217 {
3218 gUsbRetryCount = u8Value;
3219 }
3220
MDrv_USBGetVIDPID(U16 * pVID,U16 * pPID)3221 void MDrv_USBGetVIDPID(U16 *pVID, U16 *pPID)
3222 {
3223 *pVID = ((U16) sAttachDevice.sDD.bVIDHighByte << 8 ) |
3224 (U16) sAttachDevice.sDD.bVIDLowByte;
3225
3226 *pPID = ((U16) sAttachDevice.sDD.bPIDHighByte<< 8 ) |
3227 (U16) sAttachDevice.sDD.bPIDLowByte;
3228 }
3229
MDrv_GetUsbStorString(U8 uLun,U8 u8StrID,S8 * pStrBuf,U8 u8BufLen)3230 void MDrv_GetUsbStorString(U8 uLun, U8 u8StrID, S8 *pStrBuf, U8 u8BufLen)
3231 {
3232 U8 ii;
3233
3234 pStrBuf[0] = 0;
3235
3236 if (u8StrID == USB_STR_VENDOR)
3237 {
3238 for (ii=0; ii<u8BufLen; ii++)
3239 {
3240 if (ii >= 8)
3241 break;
3242
3243 pStrBuf[ii] = Mass_stor_us1.Mass_stor_device[uLun].u8VendorID[ii];
3244 }
3245 pStrBuf[ii] = 0; //Null terminal
3246 }
3247 else if (u8StrID == USB_STR_PRODUCT)
3248 {
3249 for (ii=0; ii<u8BufLen; ii++)
3250 {
3251 if (ii >= 16)
3252 break;
3253
3254 pStrBuf[ii] = Mass_stor_us1.Mass_stor_device[uLun].u8ProductID[ii];
3255 }
3256 pStrBuf[ii] = 0; //Null terminal
3257 }
3258
3259 }
3260
MDrv_GetUsbDevInterfaceClass(void)3261 U8 MDrv_GetUsbDevInterfaceClass(void)
3262 {
3263 U8 u8DevType;
3264
3265 u8DevType = sAttachDevice.saCD[0].sInterface[0].bInterfaceClass;
3266
3267 return (u8DevType);
3268 }
3269
3270 #endif //#if defined(MSOS_TYPE_NOS)
3271
3272
3273