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_4.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_4.h"
105 #include "../drvHost200_4.h"
106 #include "../drvUsbMain_4.h"
107 #ifndef ATV_SERISE_USE
108
109 #endif
110 #include "../../include/_drvUSB.h"
111 #include "../drvscsi_4.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_4.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_Port4(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_Port4=USB_OK;
151 U8 gUsbTimeout_Port4=5;
152 U8 gUsbRetryCount_Port4=3;
153 U16 gUsbChipID_Port4 = 0xFFFF;
154 U8 gUsbChipVersion_Port4 = 0xFF;
155
156 #if 1
157 extern U8 gUsbDeviceState;
158 extern U8 gUsbDeviceState_Port4;
159 #else
160 U8 gUsbDeviceState_Port4=POWER_SAVING;
161 #ifdef USB_POWER_SAVING_MODE
162 extern U8 gUsbDeviceState;
163 #endif
164 #endif
165 U8 NowIsHubPort4;
166
167 extern U8 gSpeed_Port4;
168
169 //static U32 original_xdwin1_Base_Port4=0xFFFFFFFF; //use 0xFFFFFFFF to represent void
170 static U8 xdwin1_lockCount_Port4=0;
171 #if 0
172 U8 code USB_VBuf_Port4[32] = {'M', 'S', 'V', 'C', '0', '0', // 0, 0 fixed
173 'Z', '2', // Library ID
174 #ifdef DTV_STANDARD_LIB
175 'A', '0', '0', '1', '4', '8', // build number
176 #endif
177 #ifdef ATV_SERISE_USE
178 'B', '0', '0', '1', '2', '3', // build number
179 #endif
180 #ifdef CERAMAL_SERISE_USE
181 'C', '0', '0', '1', '2', '3', // build number
182 #endif
183
184 '0', '0', '0', '0', '0', '0', '0', '0', // change list 46058
185 'A', '4', 'A', '0', '0', '0', '0', '0', '0',// A4: Saturn, A:LG
186 'T'};
187 #endif
188
189 #define USB_HOST_P4_DRV_VERSION /* Character String for DRV/API version */ \
190 MSIF_TAG, /* 'MSIF' */ \
191 MSIF_CLASS, /* '00' */ \
192 MSIF_CUS, /* 0x0000 */ \
193 MSIF_MOD, /* 0x0000 */ \
194 MSIF_CHIP, \
195 MSIF_CPU, \
196 {'U','S','B','3'}, /* IP__ */ \
197 {'0','2'}, /* 0.0 ~ Z.Z */ \
198 {'1','3'}, /* 00 ~ 99 */ \
199 {'0','0','2','5','9','5','9','0'}, /* CL# */ \
200 MSIF_OS
201
202 static MSIF_Version _drv_usb_host_p4_version = {
203 .DDI = { USB_HOST_P4_DRV_VERSION },
204 };
205
206 #ifdef OnePort_OTG_EHCI
207 U8 USBMode=0; //set default status=OTG device mode ,{default=0, otg=1, uhci=2}
208 extern U8 volatile usbUSBState;
209 #endif
210
211 extern U8 RecoveryFlag_Port4;
212 //extern BOOLEAN gDeviceFatalError;
213
214 #ifdef OnePort_OTG_EHCI
215 extern void MDrv_OTG_Init(void);
216 extern U8 usbIsUSBConfiged(void);
217 enum
218 {
219 USBHostMode_disconnect = 0,
220 USBHostMode_connect,
221 USBDeivceMode_disconnect,
222 USBDeivceMode_connect
223 };
224 #endif
225
226 struct stDontReEnumList
227 {
228 U16 VID;
229 U16 PID;
230 };
231
232 struct stDontReEnumList gDontReEnumList_Port4[] =
233 {
234 {0x0951, 0x1603},
235 {0x05E3, 0x0718},
236 {0x0BC2, 0xA013},
237
238 {0, 0}
239 };
240
241 extern void drvUSBHost_TurnOffPowerDownMode(void);
242 extern void drvUSBHost_TurnOnPowerDownMode(void);
243 extern BOOLEAN drvUSBHost_isPowerSaveModeEnable(void);
244 extern void drvUSBHost_UTMIInitial(void);
245 extern void UsbTurnOffPowerDownMode(void);
246 extern void UsbTurnOnPowerDownMode(void);
247
248 extern void drvUSBHost_TurnOffPowerDownMode_Port4(void);
249 extern void drvUSBHost_TurnOnPowerDownMode_Port4(void);
250
251 extern U8 drvUSBHost_PTP_Init(U8 u8UsbPort);
252 extern void XBYTE_OR(U32 Addr, U8 offset, U8 val);
253 extern void XBYTE_AND(U32 Addr, U8 offset,U8 val);
254 extern void XBYTE_SET(U32 Addr, U8 offset,U8 val);
255 extern U8 XBYTE_READ(U32 Addr, U8 offset);
256 extern U8 drvUSBHost_HID_Init(U8 u8UsbPort);
257 void MDrv_USBGetVIDPID_Port4(U16 *pVID, U16 *pPID);
258
MDrv_USB_Host_GetLibVer_Port4(const MSIF_Version ** ppVersion)259 U8 MDrv_USB_Host_GetLibVer_Port4(const MSIF_Version **ppVersion)
260 {
261 if(!ppVersion)
262 return 1;
263
264 *ppVersion = &_drv_usb_host_p4_version;
265 return 0;
266 }
267
MDrv_USBGetChipID_Port4(void)268 U16 MDrv_USBGetChipID_Port4(void)
269 {
270 if (gUsbChipID_Port4== 0xFFFF)
271 gUsbChipID_Port4 = HAL_USB_GetChipID();
272
273 return gUsbChipID_Port4;
274 }
275
276 extern MS_U8 MDrv_SYS_GetChipRev(void);
MDrv_USBGetChipVersion_Port4(void)277 U8 MDrv_USBGetChipVersion_Port4(void)
278 {
279 if (gUsbChipVersion_Port4== 0xFF)
280 gUsbChipVersion_Port4 = MDrv_SYS_GetChipRev();
281
282 return gUsbChipVersion_Port4;
283 }
284
UsbGetVerStringPort4(U8 * pVerString)285 void UsbGetVerStringPort4(U8 *pVerString)
286 {
287 #if 0
288 memcpy(pVerString, &USB_VBuf_Port4[0], sizeof(USB_VBuf_Port4));
289 #endif
290 }
291
SetUsbTimeoutPort4(U8 x)292 void SetUsbTimeoutPort4(U8 x)
293 {
294 gUsbTimeout_Port4=x;
295 }
296
UTMI4_ORXBYTE(U8 offset,U8 val)297 void UTMI4_ORXBYTE(U8 offset,U8 val)
298 {
299 XBYTE_OR(gUTMI4_BASE, offset, val);
300 }
301
UTMI4_ANDXBYTE(U8 offset,U8 val)302 void UTMI4_ANDXBYTE(U8 offset,U8 val)
303 {
304 XBYTE_AND(gUTMI4_BASE, offset, val);
305 }
306
UTMI4_SETXBYTE(U8 offset,U8 val)307 void UTMI4_SETXBYTE(U8 offset,U8 val)
308 {
309 XBYTE_SET(gUTMI4_BASE, offset, val);
310 }
311
UTMI4_READXBYTE(U8 offset)312 U8 UTMI4_READXBYTE(U8 offset)
313 {
314 return XBYTE_READ(gUTMI4_BASE, offset);
315 }
316
UHC4_ORXBYTE(U8 offset,U8 val)317 void UHC4_ORXBYTE(U8 offset,U8 val)
318 {
319 XBYTE_OR(gUHC4_BASE, offset, val);
320 }
321
UHC4_ANDXBYTE(U8 offset,U8 val)322 void UHC4_ANDXBYTE(U8 offset,U8 val)
323 {
324 XBYTE_AND(gUHC4_BASE, offset, val);
325 }
326
UHC4_SETXBYTE(U8 offset,U8 val)327 void UHC4_SETXBYTE(U8 offset,U8 val)
328 {
329 XBYTE_SET(gUHC4_BASE, offset, val);
330 }
331
UHC4_READXBYTE(U8 offset)332 U8 UHC4_READXBYTE(U8 offset)
333 {
334 return XBYTE_READ(gUHC4_BASE, offset);
335 }
336
USBC4_ORXBYTE(U8 offset,U8 val)337 void USBC4_ORXBYTE(U8 offset,U8 val)
338 {
339 XBYTE_OR(gUSBC4_BASE, offset, val);
340 }
341
USBC4_ANDXBYTE(U8 offset,U8 val)342 void USBC4_ANDXBYTE(U8 offset,U8 val)
343 {
344 XBYTE_AND(gUSBC4_BASE, offset, val);
345 }
346
USBC4_SETXBYTE(U8 offset,U8 val)347 void USBC4_SETXBYTE(U8 offset,U8 val)
348 {
349 XBYTE_SET(gUSBC4_BASE, offset, val);
350 }
351
USBC4_READXBYTE(U8 offset)352 U8 USBC4_READXBYTE(U8 offset)
353 {
354 return XBYTE_READ(gUSBC4_BASE, offset);
355 }
356
357 #ifdef Enable_Burning_Test
358 U8 buf4[512];
UsbTestPort4(void)359 void UsbTestPort4(void)
360 {
361 U16 i,j;
362 U32 idx=0,xxx;
363 U8 VailLun,LunIndex=0;
364 //U8 *buf4;
365
366 printf("\r\n USB Port4 Burning Test\n");
367 //printf("maxlun :%02bx lunbyte:%02bx\n",maxlun,lunbyte);
368 //MDrv_UsbHost_Init();
369
370 //buf4 = (U8*) msAPI_Memory_Allocate(0x200, BUF_ID_USB_HOST );
371 printf("buf4: %X\n", (UINT)buf4);
372
373 VailLun=MDrv_GET_MASS_VALID_LUN_PORT4();
374 switch (VailLun)
375 {
376 case 0x01:
377 LunIndex=0;
378 break;
379 case 0x02:
380 LunIndex=1;
381 break;
382 case 0x04:
383 LunIndex=2;
384 break;
385 case 0x08:
386 LunIndex=3;
387 break;
388 case 0x10:
389 LunIndex=4;
390 break;
391 case 0x20:
392 LunIndex=5;
393 break;
394 case 0x40:
395 LunIndex=6;
396 break;
397 case 0x80:
398 LunIndex=7;
399 break;
400 }
401
402 //printf("\r\n addr=%x",(VirtoPhyAddr((U32)buf1)>>16));
403 //printf(",%x",(VirtoPhyAddr((U32)buf1)));
404 printf("gSpeed: %d\n", gSpeed_Port4);
405 while (1)
406 {
407 #ifndef CERAMAL_SERISE_USE
408 msAPI_Timer_ResetWDT();
409 #endif
410 for (i=0 ; i < 0x200 ; i++)
411 {
412 buf4[i]= (i & 0xff);
413 }
414
415 idx++;
416 //if ((idx & 0x3f)==0)
417 {
418 printf("\r\n Loop:%x",(U16)(idx>>16));
419 printf(",%x",(U16)(idx));
420 }
421 //MDrv_MIU_Copy
422 xxx=idx % 10000;
423 if (MDrv_UsbBlockWriteFromMIU_Port4(LunIndex,50+xxx,1,(U32)VirtoPhyAddr(buf4))==FALSE)
424 {
425 printf("\r\n write failed\n");
426 break;
427 }
428
429 if (MDrv_UsbBlockReadToMIU_Port4(LunIndex,50+xxx,1,(U32)VirtoPhyAddr(buf4))==FALSE)
430 {
431 printf("\r\n read failed\n");
432 break;
433 }
434 //MsOS_DelayTask(10);
435 for (j=0 ; j < 0x200 ; j++)
436 {
437 if (buf4[j]!= (j&0xff))
438 {
439 printf("\r\n LBA:%d data error\n", (U16)(50+xxx));
440 while(1);
441 }
442 }
443 MsOS_DelayTask(5);
444 }
445
446 //msAPI_Memory_Free((void*)buf4,BUF_ID_USB_HOST);
447 }
448 #endif
449 #if 0
450 U8 MDrv_UsbGetInterfaceClass(U8 i,U8 j)
451 {
452 U8 tmp;
453 #ifdef USE_XDATA_ADDRESS_0XF000
454 MDrv_USB_SetXdataWindow1();
455 #endif
456 tmp=psAttachDevice_Port4->saCD[i].sInterface[j].bInterfaceClass;
457 #ifdef USE_XDATA_ADDRESS_0XF000
458 MDrv_USB_ReleaseXdataWindow1();
459 #endif
460
461 return tmp;
462 }
463 #endif
464
465 //====================================================================
466 // * Function Name: main
467 // * Description:
468 // * Input:
469 // * OutPut:
470 //====================================================================
471 #ifndef DEVICE_ENUM_SEGMENT
MDrv_UsbHost_Init_Port4(void)472 BOOLEAN MDrv_UsbHost_Init_Port4(void)
473 {
474 BOOLEAN result=FALSE;
475
476 DRV_USB_DBG(printf("HOST200_main\n"));
477
478 MINI_DEBUG(printf("uinit\n"));
479 if (gUsbStatus_Port4==USB_EJECT)
480 {
481 //printf("2430:%02bx\n",XBYTE[0x2430]);
482 if (UHC4_READXBYTE(0x30)&2)
483 {
484 gUsbStatus_Port4=USB_OK;
485 }
486 else
487 return FALSE; //eject state
488 }
489
490 UTMI4_ORXBYTE(0x06,0x40); //Force HS TX current enable and CDR stage select
491 UTMI4_ANDXBYTE(0x06,~0x20); //clear bit 5
492 if (MDrv_USBGetChipID_Port4() == CHIPID_EMERALD)
493 UTMI4_ORXBYTE(0x06, 0x04); //Force HS TX current source enable, for MHL noise issue, for Emerald only
494
495 UTMI4_ORXBYTE(0x06,0x03); //reset UTMI
496 MsOS_DelayTask(2);
497 UTMI4_ANDXBYTE(0x06,0xfc);
498
499 if ( (MDrv_USBGetChipID_Port4() == CHIPID_NEPTUNE) ||
500 (MDrv_USBGetChipID_Port4() == CHIPID_ERIS) ||
501 (MDrv_USBGetChipID_Port4() == CHIPID_TITANIA) ||
502 (MDrv_USBGetChipID_Port4() == CHIPID_PLUTO) ||
503 (MDrv_USBGetChipID_Port4() == CHIPID_TRITON) ||
504 (MDrv_USBGetChipID_Port4() == CHIPID_TITANIA2) )
505 {
506 UTMI4_SETXBYTE(0x29,0x08);
507 }
508 else if (MDrv_USBGetChipID_Port4()==CHIPID_EUCLID) // Euclid
509 {
510 UTMI4_ANDXBYTE(0x29,0xF7); //disable full speed retime
511 }
512
513 #if defined(Enable_Issue_TestPacket) && !defined(ENABLE_HOST_TEST)
514 UTMI4_SETXBYTE(0x03,0); //for device disconnect status bit
515 #else
516 UTMI4_SETXBYTE(0x03,0xa8); //for device disconnect status bit
517 #endif
518
519 //XBYTE[gUTMI4_BASE+0x07]|=0x02; //
520 #ifdef DTV_STANDARD_LIB
521 if (MDrv_USBGetChipID_Port4()==CHIPID_NEPTUNE) //Neptune , after U06
522 {
523 if (MDrv_USBGetChipVersion_Port4()>= 0x06) //U07
524 {
525 UTMI4_ORXBYTE(0x07, 0x02);
526 UTMI4_SETXBYTE(0x2c,0xc1);
527 UTMI4_SETXBYTE(0x2d,0x3b);//enable TX common mode,
528 UTMI4_ORXBYTE(0x2f, 0x0e); //preemsis
529 }
530 }
531 else if ((MDrv_USBGetChipID_Port4()>=CHIPID_ERIS)&&(MDrv_USBGetChipID_Port4()<=CHIPID_TITANIA)) //Eris: 3 ,Titania: 4, Pluto: 5
532 {
533 UTMI4_SETXBYTE(0x2c,0xc5);
534 UTMI4_SETXBYTE(0x2d,0x3b);//enable TX common mode,
535 UTMI4_ORXBYTE(0x2f, 0x0e); //preemsis
536 }
537 else if (MDrv_USBGetChipID_Port4()==CHIPID_PLUTO) // Pluto: 5
538 {
539 UTMI4_ORXBYTE(0x2c, 0xc1);
540 UTMI4_ORXBYTE(0x2d, 0x3);//enable TX common mode,
541 UTMI4_ORXBYTE(0x2f, 0x4a); //preemsis
542 UTMI4_ORXBYTE(0x13, 0x70);
543 XBYTE_AND(gUTMI_BASE,0,0xfe); //clear port 0 IREF
544 }
545 else if (MDrv_USBGetChipID_Port4()==CHIPID_TITANIA2) // Titania 2
546 {
547 UTMI4_ORXBYTE(0x2c, 0xc1);
548 UTMI4_ORXBYTE(0x2d, 0x3);//enable TX common mode,
549 UTMI4_ORXBYTE(0x2f, 0x4a); //preemsis
550 }
551 else if (MDrv_USBGetChipID_Port4()==CHIPID_TRITON) //Triton=6
552 {
553 UTMI4_SETXBYTE(0x2c,0xc1);
554 UTMI4_SETXBYTE(0x2d,0x3b);//enable TX common mode,
555 UTMI4_ORXBYTE(0x2f,0x0e); //preemsis
556 }
557 else if (MDrv_USBGetChipID_Port4()==CHIPID_EUCLID) // Euclid
558 {
559 UTMI4_ORXBYTE(0x2c, 0xc1);
560 UTMI4_ORXBYTE(0x2d, 0x3);//enable TX common mode,
561 UTMI4_ORXBYTE(0x2f, 0x4a); //preemsis
562 }
563 else if ( (MDrv_USBGetChipID_Port4()==CHIPID_TITANIA3) || // Titania 3, Titania 4
564 (MDrv_USBGetChipID_Port4()==CHIPID_TITANIA4) ||
565 (MDrv_USBGetChipID_Port4()==CHIPID_TITANIA7) ||
566 (MDrv_USBGetChipID_Port4()==CHIPID_TITANIA8) ||
567 (MDrv_USBGetChipID_Port4()==CHIPID_TITANIA9) ||
568 (MDrv_USBGetChipID_Port4()==CHIPID_TITANIA12) ||
569 (MDrv_USBGetChipID_Port4() == CHIPID_JANUS) ||
570 (MDrv_USBGetChipID_Port4() == CHIPID_JANUS2) ||
571 (MDrv_USBGetChipID_Port4() == CHIPID_AMBER6) )
572 {
573 UTMI4_ORXBYTE(0x2c, 0x10); //TX-current adjust to 105%
574 UTMI4_ORXBYTE(0x2d, 0x02); //Pre-emphasis enable
575 UTMI4_ORXBYTE(0x2f, 0x81); //HS_TX common mode current enable (100mV);Pre-emphasis enable (10%)
576 UTMI4_ORXBYTE(0x09,0x81); //UTMI RX anti-dead-lock, ISI improvement
577 }
578 else if ( (MDrv_USBGetChipID_Port4()==CHIPID_AMBER1) ||
579 (MDrv_USBGetChipID_Port4()==CHIPID_AMBER5) ||
580 (MDrv_USBGetChipID_Port4()==CHIPID_AMBER7) ||
581 (MDrv_USBGetChipID_Port4()==CHIPID_AMBER3) ||
582 (MDrv_USBGetChipID_Port4()==CHIPID_AMETHYST) ||
583 (MDrv_USBGetChipID_Port4()==CHIPID_EAGLE))
584 {
585 //for Amber1 later 40nm before Agate
586 UTMI4_ORXBYTE(0x2c, 0x98);
587 UTMI4_ORXBYTE(0x2d, 0x02);
588 UTMI4_ORXBYTE(0x2e, 0x10);
589 UTMI4_ORXBYTE(0x2f, 0x01);
590 UTMI4_ORXBYTE(0x09,0x81); //UTMI RX anti-dead-lock, ISI improvement
591 }
592 else //for Agate later 40nm, same as 55nm setting
593 {
594 UTMI4_ORXBYTE(0x2c, 0x10); //TX-current adjust to 105%
595 UTMI4_ORXBYTE(0x2d, 0x02); //Pre-emphasis enable
596 UTMI4_ORXBYTE(0x2f, 0x81); //HS_TX common mode current enable (100mV);Pre-emphasis enable (10%)
597 UTMI4_ORXBYTE(0x09,0x81); //UTMI RX anti-dead-lock, ISI improvement
598 }
599 #endif
600
601 //for Edison later 240M clock enhance, early chip will ignore this 2 bits
602 UTMI4_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
603
604 /* Enable Cross Point ECO 2012/03/20 */
605 if ((MDrv_USBGetChipID_Port4() == CHIPID_ELK) ||
606 (MDrv_USBGetChipID_Port4() == CHIPID_AMBER5) ||
607 (MDrv_USBGetChipID_Port4() == CHIPID_EAGLE) ||
608 (MDrv_USBGetChipID_Port4() == CHIPID_EMERALD) ||
609 (MDrv_USBGetChipID_Port4() == CHIPID_EDISON) ||
610 (MDrv_USBGetChipID_Port4() == CHIPID_AGATE))
611 {
612 UTMI4_ORXBYTE(0x04,0x40); //deglitch SE0 (low-speed cross point)
613 }
614 else if((MDrv_USBGetChipID_Port4() == CHIPID_JANUS2))
615 {
616 UTMI4_ORXBYTE(0x0a,0x80); //deglitch SE0 (low-speed cross point)
617 }
618
619 /* Enable Power Noice ECO 2012/03/20 */
620 if ((MDrv_USBGetChipID_Port4() == CHIPID_JANUS2) ||
621 (MDrv_USBGetChipID_Port4() == CHIPID_ELK) ||
622 (MDrv_USBGetChipID_Port4() == CHIPID_AMBER5) ||
623 (MDrv_USBGetChipID_Port4() == CHIPID_EAGLE) ||
624 (MDrv_USBGetChipID_Port4() == CHIPID_EMERALD) ||
625 (MDrv_USBGetChipID_Port4() == CHIPID_EDISON) ||
626 (MDrv_USBGetChipID_Port4() == CHIPID_AGATE))
627 {
628 USBC4_ORXBYTE(0x02,0x40); //use eof2 to reset state machine (power noise)
629 }
630
631 /* Enable Tx/Rx Reset Clock Gatting ECO 2012/03/27 */
632 if((MDrv_USBGetChipID_Port4() == CHIPID_ELK) ||
633 (MDrv_USBGetChipID_Port4() == CHIPID_AMBER5) ||
634 (MDrv_USBGetChipID_Port4() == CHIPID_EAGLE) ||
635 (MDrv_USBGetChipID_Port4() == CHIPID_EMERALD) ||
636 (MDrv_USBGetChipID_Port4() == CHIPID_EDISON) ||
637 (MDrv_USBGetChipID_Port4() == CHIPID_AGATE))
638 {
639 UTMI4_ORXBYTE(0x04,0x20); //hw auto deassert sw reset (tx/rx reset)
640 }
641
642 /* enable patch for the assertion of interrupt(Lose short packet interrupt) 2012/03/28 */
643 if((MDrv_USBGetChipID_Port4() == CHIPID_AMBER5) ||
644 (MDrv_USBGetChipID_Port4() == CHIPID_AGATE))
645 {
646 USBC4_ORXBYTE(0x04,0x80); //patch for the assertion of interrupt
647 }
648
649 /* enable add patch to Period_EOF1(babble problem) 2012/03/28 */
650 if((MDrv_USBGetChipID_Port4() == CHIPID_AMBER5) ||
651 (MDrv_USBGetChipID_Port4() == CHIPID_AGATE))
652 {
653 USBC4_ORXBYTE(0x04,0x40); //add patch to Period_EOF1
654 }
655
656 /* enable eco for short packet MDATA 2012/07/05 */
657 if( (MDrv_USBGetChipID_Port4() == CHIPID_EDISON) )
658 {
659 USBC4_ORXBYTE(0x00,0x10); //short packet MDATA in Split transaction clears ACT bit (LS dev under a HS hub)
660 }
661
662 /* enable eco for pv2mi bridge mis-behavior 2012/12/05 */
663 if((MDrv_USBGetChipID_Port4() == CHIPID_EINSTEIN) ||
664 (MDrv_USBGetChipID_Port4() == CHIPID_NAPOLI) ||
665 (MDrv_USBGetChipID_Port4() == CHIPID_MIAMI))
666 {
667 USBC4_ORXBYTE(0x0A,0x40); //fix pv2mi bridge mis-behavior
668 }
669
670 if (MDrv_USBGetChipID_Port4()==CHIPID_PLUTO) // If is Pluto
671 UTMI4_ORXBYTE(0x09,0x01); //ISI improvement
672 else
673 UTMI4_ORXBYTE(0x13,0x02); //ISI improvement
674
675 if ( (MDrv_USBGetChipID_Port4() == CHIPID_NEPTUNE) ||
676 (MDrv_USBGetChipID_Port4() == CHIPID_ERIS) ||
677 (MDrv_USBGetChipID_Port4() == CHIPID_TITANIA) ||
678 (MDrv_USBGetChipID_Port4() == CHIPID_PLUTO) ||
679 (MDrv_USBGetChipID_Port4() == CHIPID_TRITON) ||
680 (MDrv_USBGetChipID_Port4() == CHIPID_TITANIA2) )
681 {
682 }
683 else
684 {
685 UTMI4_ORXBYTE(0x0b, 0x80); //TX timing select latch path
686 }
687
688 if (MDrv_USBGetChipID_Port4()==CHIPID_EUCLID) // Euclid
689 {
690 UTMI4_SETXBYTE(0x09,0x81);//0x20; //patch low tempture,FL meta issue and enable new FL RX engin
691 }
692 else
693 {
694 UTMI4_ORXBYTE(0x09,0x60);//0x20; //patch low tempture,FL meta issue and enable new FL RX engin
695 }
696
697 #if 1
698 DRV_USB_DBG(printf("Host: %X\n", mwOTG20_Control_HOST_SPD_TYP_Rd()));
699 if (mwOTG20_Control_HOST_SPD_TYP_Rd()==1) //low speed,for HID
700 UTMI4_ANDXBYTE(0x09,~0x40); //old setting
701 #endif
702
703 if ( (MDrv_USBGetChipID_Port4() == CHIPID_NEPTUNE) ||
704 (MDrv_USBGetChipID_Port4() == CHIPID_ERIS) ||
705 (MDrv_USBGetChipID_Port4() == CHIPID_TITANIA) ||
706 (MDrv_USBGetChipID_Port4() == CHIPID_PLUTO) ||
707 (MDrv_USBGetChipID_Port4() == CHIPID_TRITON) ||
708 (MDrv_USBGetChipID_Port4() == CHIPID_TITANIA2) )
709 {
710 UTMI4_ANDXBYTE(0x27,0xf3);
711 UTMI4_ORXBYTE(0x27,0x08); //(1) Offset 27 (��h3AA7) bit <3:2> set 2��b10 // RX bias current => 60uA (default 40uA)
712
713 //(2) Offset 2A (��h3AAA) bit <3:2> set 2��b11 // Squelch voltage => 100mV (default 150mV)
714 #ifdef DTV_STANDARD_LIB
715 UTMI4_SETXBYTE(0x2a,0x07);
716 #endif
717 }
718
719 if ( (MDrv_USBGetChipID_Port4() == CHIPID_NEPTUNE) ||
720 (MDrv_USBGetChipID_Port4() == CHIPID_ERIS) ||
721 (MDrv_USBGetChipID_Port4() == CHIPID_TITANIA) ||
722 (MDrv_USBGetChipID_Port4() == CHIPID_PLUTO) ||
723 (MDrv_USBGetChipID_Port4() == CHIPID_TRITON) ||
724 (MDrv_USBGetChipID_Port4() == CHIPID_TITANIA2) ||
725 (MDrv_USBGetChipID_Port4() == CHIPID_TITANIA3) ||
726 (MDrv_USBGetChipID_Port4() == CHIPID_TITANIA4) ||
727 (MDrv_USBGetChipID_Port4() == CHIPID_TITANIA7) ||
728 (MDrv_USBGetChipID_Port4() == CHIPID_TITANIA8) ||
729 (MDrv_USBGetChipID_Port4() == CHIPID_TITANIA9) ||
730 (MDrv_USBGetChipID_Port4() == CHIPID_TITANIA12) ||
731 (MDrv_USBGetChipID_Port4() == CHIPID_TITANIA13) ||
732 (MDrv_USBGetChipID_Port4() == CHIPID_JANUS) ||
733 (MDrv_USBGetChipID_Port4() == CHIPID_MARIA10) ||
734 (MDrv_USBGetChipID_Port4() == CHIPID_MACAW12) ||
735 (MDrv_USBGetChipID_Port4() == CHIPID_JANUS2) ||
736 (MDrv_USBGetChipID_Port4() == CHIPID_AMBER1) ||
737 (MDrv_USBGetChipID_Port4() == CHIPID_AMBER3) ||
738 (MDrv_USBGetChipID_Port4() == CHIPID_AMBER5) ||
739 (MDrv_USBGetChipID_Port4() == CHIPID_AMBER6) ||
740 (MDrv_USBGetChipID_Port4() == CHIPID_AMBER7) ||
741 (MDrv_USBGetChipID_Port4() == CHIPID_AMETHYST) )
742 {
743 UTMI4_ORXBYTE(0x15,0x20); //HOST CHIRP Detect
744 }
745 else
746 {
747 UTMI4_ORXBYTE(0x15,0x60); // change to 55 interface (bit6)
748 }
749
750 //(3) Offset 2D (��h3AAD) bit <5:3> set 3��b111 // HS_RTERM bias current 5/6
751 //XBYTE[0x128a]=0x87; //change UHC priority
752 //XBYTE[0x128d]&=0x0f; //clear bit 12~15
753 //XBYTE[0x128e]|=0xf; //upgrade UHC priority, set bit 0~3
754 MsOS_DelayTask(USB_HOST_INIT_DELAY);
755
756
757 //MDrv_Sys_SetXdataWindow1Base(USB_BUFFER_START_ADR_4K_ALIGN>>12); //switch window 1
758 gUsbStatus_Port4=USB_OK;
759 // gUsbTimeout=3; //set at flib_Host20_Enumerate_Port4()
760 RecoveryFlag_Port4=0; //initialize recovery flag
761 gUsbDeviceState_Port4=USB11_DEVICE; //1.1 at first
762
763 //gDeviceFatalError=FALSE;
764 if(flib_OTGH_Init_Port4(0))
765 result =TRUE;
766
767 return result;
768
769 }
770 #else // support device enumeration dividable
_MDrv_UsbHost_Init0_Port4(void)771 BOOLEAN _MDrv_UsbHost_Init0_Port4(void)
772 {
773 //BOOLEAN result=FALSE;
774
775 DRV_USB_DBG(printf("HOST200_main\n"));
776
777 MINI_DEBUG(printf("uinit\n"));
778 if (gUsbStatus_Port4==USB_EJECT)
779 {
780 //printf("2430:%02bx\n",XBYTE[0x2430]);
781 if (UHC4_READXBYTE(0x30)&2)
782 {
783 gUsbStatus_Port4=USB_OK;
784 }
785 else
786 return FALSE; //eject state
787 }
788
789 UTMI4_ORXBYTE(0x06,0x40); //Force HS TX current enable and CDR stage select
790 UTMI4_ANDXBYTE(0x06,~0x20); //clear bit 5
791 if (MDrv_USBGetChipID_Port4() == CHIPID_EMERALD)
792 UTMI4_ORXBYTE(0x06, 0x04); //Force HS TX current source enable, for MHL noise issue, for Emerald only
793
794 UTMI4_ORXBYTE(0x06,0x03); //reset UTMI
795 MsOS_DelayTask(2);
796 UTMI4_ANDXBYTE(0x06,0xfc);
797
798 if ( (MDrv_USBGetChipID_Port4() == CHIPID_NEPTUNE) ||
799 (MDrv_USBGetChipID_Port4() == CHIPID_ERIS) ||
800 (MDrv_USBGetChipID_Port4() == CHIPID_TITANIA) ||
801 (MDrv_USBGetChipID_Port4() == CHIPID_PLUTO) ||
802 (MDrv_USBGetChipID_Port4() == CHIPID_TRITON) ||
803 (MDrv_USBGetChipID_Port4() == CHIPID_TITANIA2) )
804 {
805 UTMI4_SETXBYTE(0x29,0x08);
806 }
807 else if (MDrv_USBGetChipID_Port4()==CHIPID_EUCLID) // Euclid
808 {
809 UTMI4_ANDXBYTE(0x29,0xF7); //disable full speed retime
810 }
811
812 #if defined(Enable_Issue_TestPacket) && !defined(ENABLE_HOST_TEST)
813 UTMI4_SETXBYTE(0x03,0); //for device disconnect status bit
814 #else
815 UTMI4_SETXBYTE(0x03,0xa8); //for device disconnect status bit
816 #endif
817
818 //XBYTE[gUTMI4_BASE+0x07]|=0x02; //
819 #ifdef DTV_STANDARD_LIB
820 if (MDrv_USBGetChipID_Port4()==CHIPID_NEPTUNE) //Neptune , after U06
821 {
822 if (MDrv_USBGetChipVersion_Port4()>= 0x06) //U07
823 {
824 UTMI4_ORXBYTE(0x07, 0x02);
825 UTMI4_SETXBYTE(0x2c,0xc1);
826 UTMI4_SETXBYTE(0x2d,0x3b);//enable TX common mode,
827 UTMI4_ORXBYTE(0x2f, 0x0e); //preemsis
828 }
829 }
830 else if ((MDrv_USBGetChipID_Port4()>=CHIPID_ERIS)&&(MDrv_USBGetChipID_Port4()<=CHIPID_TITANIA)) //Eris: 3 ,Titania: 4, Pluto: 5
831 {
832 UTMI4_SETXBYTE(0x2c,0xc5);
833 UTMI4_SETXBYTE(0x2d,0x3b);//enable TX common mode,
834 UTMI4_ORXBYTE(0x2f, 0x0e); //preemsis
835 }
836 else if (MDrv_USBGetChipID_Port4()==CHIPID_PLUTO) // Pluto: 5
837 {
838 UTMI4_ORXBYTE(0x2c, 0xc1);
839 UTMI4_ORXBYTE(0x2d, 0x3);//enable TX common mode,
840 UTMI4_ORXBYTE(0x2f, 0x4a); //preemsis
841 UTMI4_ORXBYTE(0x13, 0x70);
842 XBYTE_AND(gUTMI_BASE,0,0xfe); //clear port 0 IREF
843 }
844 else if (MDrv_USBGetChipID_Port4()==CHIPID_TITANIA2) // Titania 2
845 {
846 UTMI4_ORXBYTE(0x2c, 0xc1);
847 UTMI4_ORXBYTE(0x2d, 0x3);//enable TX common mode,
848 UTMI4_ORXBYTE(0x2f, 0x4a); //preemsis
849 }
850 else if (MDrv_USBGetChipID_Port4()==CHIPID_TRITON) //Triton=6
851 {
852 UTMI4_SETXBYTE(0x2c,0xc1);
853 UTMI4_SETXBYTE(0x2d,0x3b);//enable TX common mode,
854 UTMI4_ORXBYTE(0x2f,0x0e); //preemsis
855 }
856 else if (MDrv_USBGetChipID_Port4()==CHIPID_EUCLID) // Euclid
857 {
858 UTMI4_ORXBYTE(0x2c, 0xc1);
859 UTMI4_ORXBYTE(0x2d, 0x3);//enable TX common mode,
860 UTMI4_ORXBYTE(0x2f, 0x4a); //preemsis
861 }
862 else if ( (MDrv_USBGetChipID_Port4()==CHIPID_TITANIA3) || // Titania 3, Titania 4
863 (MDrv_USBGetChipID_Port4()==CHIPID_TITANIA4) ||
864 (MDrv_USBGetChipID_Port4()==CHIPID_TITANIA7) ||
865 (MDrv_USBGetChipID_Port4()==CHIPID_TITANIA8) ||
866 (MDrv_USBGetChipID_Port4()==CHIPID_TITANIA9) ||
867 (MDrv_USBGetChipID_Port4()==CHIPID_TITANIA12) ||
868 (MDrv_USBGetChipID_Port4() == CHIPID_JANUS) ||
869 (MDrv_USBGetChipID_Port4() == CHIPID_JANUS2) ||
870 (MDrv_USBGetChipID_Port4() == CHIPID_AMBER6) )
871 {
872 UTMI4_ORXBYTE(0x2c, 0x10); //TX-current adjust to 105%
873 UTMI4_ORXBYTE(0x2d, 0x02); //Pre-emphasis enable
874 UTMI4_ORXBYTE(0x2f, 0x81); //HS_TX common mode current enable (100mV);Pre-emphasis enable (10%)
875 UTMI4_ORXBYTE(0x09,0x81); //UTMI RX anti-dead-lock, ISI improvement
876 }
877 else if ( (MDrv_USBGetChipID_Port4()==CHIPID_AMBER1) ||
878 (MDrv_USBGetChipID_Port4()==CHIPID_AMBER5) ||
879 (MDrv_USBGetChipID_Port4()==CHIPID_AMBER7) ||
880 (MDrv_USBGetChipID_Port4()==CHIPID_AMBER3) ||
881 (MDrv_USBGetChipID_Port4()==CHIPID_AMETHYST) ||
882 (MDrv_USBGetChipID_Port4()==CHIPID_EAGLE))
883 {
884 //for Amber1 later 40nm before Agate
885 UTMI4_ORXBYTE(0x2c, 0x98);
886 UTMI4_ORXBYTE(0x2d, 0x02);
887 UTMI4_ORXBYTE(0x2e, 0x10);
888 UTMI4_ORXBYTE(0x2f, 0x01);
889 UTMI4_ORXBYTE(0x09,0x81); //UTMI RX anti-dead-lock, ISI improvement
890 }
891 else //for Agate later 40nm, same as 55nm setting
892 {
893 UTMI4_ORXBYTE(0x2c, 0x10); //TX-current adjust to 105%
894 UTMI4_ORXBYTE(0x2d, 0x02); //Pre-emphasis enable
895 UTMI4_ORXBYTE(0x2f, 0x81); //HS_TX common mode current enable (100mV);Pre-emphasis enable (10%)
896 UTMI4_ORXBYTE(0x09,0x81); //UTMI RX anti-dead-lock, ISI improvement
897 }
898 #endif
899
900 //for Edison later 240M clock enhance, early chip will ignore this 2 bits
901 UTMI4_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
902
903 /* Enable Cross Point ECO 2012/03/20 */
904 if ((MDrv_USBGetChipID_Port4() == CHIPID_ELK) ||
905 (MDrv_USBGetChipID_Port4() == CHIPID_AMBER5) ||
906 (MDrv_USBGetChipID_Port4() == CHIPID_EAGLE) ||
907 (MDrv_USBGetChipID_Port4() == CHIPID_EMERALD) ||
908 (MDrv_USBGetChipID_Port4() == CHIPID_EDISON) ||
909 (MDrv_USBGetChipID_Port4() == CHIPID_AGATE))
910 {
911 UTMI4_ORXBYTE(0x04,0x40); //deglitch SE0 (low-speed cross point)
912 }
913 else if((MDrv_USBGetChipID_Port4() == CHIPID_JANUS2))
914 {
915 UTMI4_ORXBYTE(0x0a,0x80); //deglitch SE0 (low-speed cross point)
916 }
917
918 /* Enable Power Noice ECO 2012/03/20 */
919 if ((MDrv_USBGetChipID_Port4() == CHIPID_JANUS2) ||
920 (MDrv_USBGetChipID_Port4() == CHIPID_ELK) ||
921 (MDrv_USBGetChipID_Port4() == CHIPID_AMBER5) ||
922 (MDrv_USBGetChipID_Port4() == CHIPID_EAGLE) ||
923 (MDrv_USBGetChipID_Port4() == CHIPID_EMERALD) ||
924 (MDrv_USBGetChipID_Port4() == CHIPID_EDISON) ||
925 (MDrv_USBGetChipID_Port4() == CHIPID_AGATE))
926 {
927 USBC4_ORXBYTE(0x02,0x40); //use eof2 to reset state machine (power noise)
928 }
929
930 /* Enable Tx/Rx Reset Clock Gatting ECO 2012/03/27 */
931 if((MDrv_USBGetChipID_Port4() == CHIPID_ELK) ||
932 (MDrv_USBGetChipID_Port4() == CHIPID_AMBER5) ||
933 (MDrv_USBGetChipID_Port4() == CHIPID_EAGLE) ||
934 (MDrv_USBGetChipID_Port4() == CHIPID_EMERALD) ||
935 (MDrv_USBGetChipID_Port4() == CHIPID_EDISON) ||
936 (MDrv_USBGetChipID_Port4() == CHIPID_AGATE))
937 {
938 UTMI4_ORXBYTE(0x04,0x20); //hw auto deassert sw reset (tx/rx reset)
939 }
940
941 /* enable patch for the assertion of interrupt(Lose short packet interrupt) 2012/03/28 */
942 if((MDrv_USBGetChipID_Port4() == CHIPID_AMBER5) ||
943 (MDrv_USBGetChipID_Port4() == CHIPID_AGATE))
944 {
945 USBC4_ORXBYTE(0x04,0x80); //patch for the assertion of interrupt
946 }
947
948 /* enable add patch to Period_EOF1(babble problem) 2012/03/28 */
949 if((MDrv_USBGetChipID_Port4() == CHIPID_AMBER5) ||
950 (MDrv_USBGetChipID_Port4() == CHIPID_AGATE))
951 {
952 USBC4_ORXBYTE(0x04,0x40); //add patch to Period_EOF1
953 }
954
955 /* enable eco for short packet MDATA 2012/07/05 */
956 if( (MDrv_USBGetChipID_Port4() == CHIPID_EDISON) )
957 {
958 USBC4_ORXBYTE(0x00,0x10); //short packet MDATA in Split transaction clears ACT bit (LS dev under a HS hub)
959 }
960
961 /* enable eco for pv2mi bridge mis-behavior 2012/12/05 */
962 if((MDrv_USBGetChipID_Port4() == CHIPID_EINSTEIN) ||
963 (MDrv_USBGetChipID_Port4() == CHIPID_NAPOLI) ||
964 (MDrv_USBGetChipID_Port4() == CHIPID_MIAMI))
965 {
966 USBC4_ORXBYTE(0x0A,0x40); //fix pv2mi bridge mis-behavior
967 }
968
969 if (MDrv_USBGetChipID_Port4()==CHIPID_PLUTO) // If is Pluto
970 UTMI4_ORXBYTE(0x09,0x01); //ISI improvement
971 else
972 UTMI4_ORXBYTE(0x13,0x02); //ISI improvement
973
974 if ( (MDrv_USBGetChipID_Port4() == CHIPID_NEPTUNE) ||
975 (MDrv_USBGetChipID_Port4() == CHIPID_ERIS) ||
976 (MDrv_USBGetChipID_Port4() == CHIPID_TITANIA) ||
977 (MDrv_USBGetChipID_Port4() == CHIPID_PLUTO) ||
978 (MDrv_USBGetChipID_Port4() == CHIPID_TRITON) ||
979 (MDrv_USBGetChipID_Port4() == CHIPID_TITANIA2) )
980 {
981 }
982 else
983 {
984 UTMI4_ORXBYTE(0x0b, 0x80); //TX timing select latch path
985 }
986
987 if (MDrv_USBGetChipID_Port4()==CHIPID_EUCLID) // Euclid
988 {
989 UTMI4_SETXBYTE(0x09,0x81);//0x20; //patch low tempture,FL meta issue and enable new FL RX engin
990 }
991 else
992 {
993 UTMI4_ORXBYTE(0x09,0x60);//0x20; //patch low tempture,FL meta issue and enable new FL RX engin
994 }
995
996 #if 1
997 DRV_USB_DBG(printf("Host: %X\n", mwOTG20_Control_HOST_SPD_TYP_Rd()));
998 if (mwOTG20_Control_HOST_SPD_TYP_Rd()==1) //low speed,for HID
999 UTMI4_ANDXBYTE(0x09,~0x40); //old setting
1000 #endif
1001
1002 if ( (MDrv_USBGetChipID_Port4() == CHIPID_NEPTUNE) ||
1003 (MDrv_USBGetChipID_Port4() == CHIPID_ERIS) ||
1004 (MDrv_USBGetChipID_Port4() == CHIPID_TITANIA) ||
1005 (MDrv_USBGetChipID_Port4() == CHIPID_PLUTO) ||
1006 (MDrv_USBGetChipID_Port4() == CHIPID_TRITON) ||
1007 (MDrv_USBGetChipID_Port4() == CHIPID_TITANIA2) )
1008 {
1009 UTMI4_ANDXBYTE(0x27,0xf3);
1010 UTMI4_ORXBYTE(0x27,0x08); //(1) Offset 27 (��h3AA7) bit <3:2> set 2��b10 // RX bias current => 60uA (default 40uA)
1011
1012 //(2) Offset 2A (��h3AAA) bit <3:2> set 2��b11 // Squelch voltage => 100mV (default 150mV)
1013 #ifdef DTV_STANDARD_LIB
1014 UTMI4_SETXBYTE(0x2a,0x07);
1015 #endif
1016 }
1017
1018 if ( (MDrv_USBGetChipID_Port4() == CHIPID_NEPTUNE) ||
1019 (MDrv_USBGetChipID_Port4() == CHIPID_ERIS) ||
1020 (MDrv_USBGetChipID_Port4() == CHIPID_TITANIA) ||
1021 (MDrv_USBGetChipID_Port4() == CHIPID_PLUTO) ||
1022 (MDrv_USBGetChipID_Port4() == CHIPID_TRITON) ||
1023 (MDrv_USBGetChipID_Port4() == CHIPID_TITANIA2) ||
1024 (MDrv_USBGetChipID_Port4() == CHIPID_TITANIA3) ||
1025 (MDrv_USBGetChipID_Port4() == CHIPID_TITANIA4) ||
1026 (MDrv_USBGetChipID_Port4() == CHIPID_TITANIA7) ||
1027 (MDrv_USBGetChipID_Port4() == CHIPID_TITANIA8) ||
1028 (MDrv_USBGetChipID_Port4() == CHIPID_TITANIA9) ||
1029 (MDrv_USBGetChipID_Port4() == CHIPID_TITANIA12) ||
1030 (MDrv_USBGetChipID_Port4() == CHIPID_TITANIA13) ||
1031 (MDrv_USBGetChipID_Port4() == CHIPID_JANUS) ||
1032 (MDrv_USBGetChipID_Port4() == CHIPID_MARIA10) ||
1033 (MDrv_USBGetChipID_Port4() == CHIPID_MACAW12) ||
1034 (MDrv_USBGetChipID_Port4() == CHIPID_JANUS2) ||
1035 (MDrv_USBGetChipID_Port4() == CHIPID_AMBER1) ||
1036 (MDrv_USBGetChipID_Port4() == CHIPID_AMBER3) ||
1037 (MDrv_USBGetChipID_Port4() == CHIPID_AMBER5) ||
1038 (MDrv_USBGetChipID_Port4() == CHIPID_AMBER6) ||
1039 (MDrv_USBGetChipID_Port4() == CHIPID_AMBER7) ||
1040 (MDrv_USBGetChipID_Port4() == CHIPID_AMETHYST) )
1041 {
1042 UTMI4_ORXBYTE(0x15,0x20); //HOST CHIRP Detect
1043 }
1044 else
1045 {
1046 UTMI4_ORXBYTE(0x15,0x60); // change to 55 interface (bit6)
1047 }
1048
1049 //(3) Offset 2D (��h3AAD) bit <5:3> set 3��b111 // HS_RTERM bias current 5/6
1050 //XBYTE[0x128a]=0x87; //change UHC priority
1051 //XBYTE[0x128d]&=0x0f; //clear bit 12~15
1052 //XBYTE[0x128e]|=0xf; //upgrade UHC priority, set bit 0~3
1053 //MDrv_Sys_SetXdataWindow1Base(USB_BUFFER_START_ADR_4K_ALIGN>>12); //switch window 1
1054 gUsbStatus_Port4=USB_OK;
1055 // gUsbTimeout=3; //set at flib_Host20_Enumerate_Port4()
1056 RecoveryFlag_Port4=0; //initialize recovery flag
1057 gUsbDeviceState_Port4=USB11_DEVICE; //1.1 at first
1058
1059 //gDeviceFatalError=FALSE;
1060
1061 return TRUE;
1062 }
1063 //MsOS_DelayTask(500);
1064
_MDrv_UsbHost_Init1_Port4(void)1065 BOOLEAN _MDrv_UsbHost_Init1_Port4(void)
1066 {
1067 BOOLEAN result=FALSE;
1068
1069 if(flib_OTGH_Init_Port4(0))
1070 result =TRUE;
1071
1072 return result;
1073
1074 }
MDrv_UsbHost_Init_Port4(void)1075 BOOLEAN MDrv_UsbHost_Init_Port4(void)
1076 {
1077 BOOLEAN result;
1078
1079 result = _MDrv_UsbHost_Init0_Port4();
1080 if (result == FALSE)
1081 return FALSE;
1082
1083 MsOS_DelayTask(USB_HOST_INIT_DELAY);
1084 return(_MDrv_UsbHost_Init1_Port4());
1085 }
1086
1087 #endif
MDrv_UsbHost_Init_Enum_Port4(void)1088 BOOLEAN MDrv_UsbHost_Init_Enum_Port4(void)
1089 {
1090 BOOLEAN result;
1091 result=MDrv_Usb_Device_Enum_Port4();
1092 return result;
1093 }
MDrv_UsbGetMaxLUNCount_Port4()1094 U8 MDrv_UsbGetMaxLUNCount_Port4()
1095 {
1096 if (gUsbDeviceState_Port4==BAD_DEVICE)
1097 return 0;
1098
1099 if (mwHost20_PORTSC_ConnectStatus_Rd()==0)
1100 return 0;
1101 else return (Mass_stor_us1_port4.max_lun+1);
1102 }
MDrv_GET_MASS_MAX_LUN_PORT4()1103 U8 MDrv_GET_MASS_MAX_LUN_PORT4()
1104 {
1105 //printf("Get max lun func:%02bx\n",Mass_stor_us1.max_lun);
1106 if (mwHost20_PORTSC_ConnectStatus_Rd()==0)
1107 return 0;
1108 else return Mass_stor_us1_port4.max_lun;
1109 }
1110
1111 extern void GetValidLun_Port4(void);
1112
1113 #ifdef ATV_SERISE_USE
DisableINT(void)1114 void DisableINT(void)
1115 {
1116 XBYTE[0x2B03]|=0x20;
1117 XBYTE[0x2B18]|=0x80;
1118 XBYTE[0x2B19]|=0x04;
1119 XBYTE[0x2B1A]|=0x80;
1120 }
EnableINT(void)1121 void EnableINT(void)
1122 {
1123 XBYTE[0x2B03]&=0xDF;
1124 XBYTE[0x2B18]&=0x7F;
1125 XBYTE[0x2B19]&=0xFB;
1126 XBYTE[0x2B1A]&=0x7F;
1127 }
1128 #endif
1129 extern U8 ValidLunNum_Port4;
MDrv_GET_VALID_LUN_NUM_PORT4(void)1130 U8 MDrv_GET_VALID_LUN_NUM_PORT4(void)
1131 {
1132 return ValidLunNum_Port4;
1133 }
MDrv_GET_MASS_VALID_LUN_PORT4()1134 U8 MDrv_GET_MASS_VALID_LUN_PORT4()
1135 {
1136 U8 LunMatrix=0,i;
1137 struct LUN_Device* LunDevice;
1138 //printf("Get valid lun func\n");
1139 if (mwHost20_PORTSC_ConnectStatus_Rd()==0)
1140 return USB_NOT_RESPONSE; //device is not connected
1141
1142 if (gUsbDeviceState_Port4==BAD_DEVICE) return 0;
1143
1144 if (gSpeed_Port4==1) return 0; //low speed device
1145
1146 //if (gDeviceFatalError) return USB_NOT_RESPONSE;
1147 if (gUsbStatus_Port4==USB_EJECT) return USB_NOT_RESPONSE;
1148
1149 LunDevice = Mass_stor_us1_port4.Mass_stor_device;
1150 if (psAttachDevice_Port4->saCD[0].sInterface[0].bInterfaceClass != USB_INTERFACE_CLASS_MSD)
1151 {
1152 DRV_USB_DBG(printf(" LUN structure not initialized!!\n"));
1153 return USB_NOT_RESPONSE;
1154 }
1155
1156 #ifdef ATV_SERISE_USE
1157 #ifdef Enable_Close_INT
1158 //XBYTE[0x2B00]|=0x02;
1159 DisableINT();
1160 #endif
1161 #endif
1162 GetValidLun_Port4();
1163 #ifdef ATV_SERISE_USE
1164 #ifdef Enable_Close_INT
1165 //XBYTE[0x2B00]&=0xFD;
1166 EnableINT();
1167 #endif
1168 #endif
1169
1170 if (gUsbStatus_Port4==USB_TIMEOUT)
1171 {
1172 #ifdef USE_XDATA_ADDRESS_0XF000
1173 MDrv_USB_ReleaseXdataWindow1_Port4();
1174 #endif
1175 return USB_NOT_RESPONSE; //USB DEVICE not responding
1176 }
1177
1178 for (i=0; i <= Mass_stor_us1_port4.max_lun ; i++)
1179 {
1180 LunMatrix=LunMatrix<<1 ;
1181 //printf("bDeviceReady:%02bx\n",LunDevice[Mass_stor_us1.max_lun-i].bDeviceReady);
1182 if (LunDevice[Mass_stor_us1_port4.max_lun-i].bDeviceReady == TRUE)
1183 {
1184 LunMatrix|=1;
1185 }
1186 }
1187
1188 return LunMatrix;
1189 }
1190 U32 USB_BUFFER_START_ADR_4K_ALIGN_Var_Port4;
MDrv_USB_Init_Port4(U32 USBAdr)1191 void MDrv_USB_Init_Port4(U32 USBAdr)
1192 {
1193 //gProjectCode=ProjectCode;
1194 //gDeviceFatalError=FALSE;
1195
1196 USB_BUFFER_START_ADR_4K_ALIGN_Var_Port4=USBAdr;
1197
1198 gUsbRetryCount_Port4=3;
1199
1200 if (USB_BUFFER_START_ADR_4K_ALIGN_Var_Port4 % 4096 != 0)
1201 {
1202 DRV_USB_DBG( printf("Error USB Port4 Starting address is not 4K alignmented\n"));
1203 }
1204
1205 //#ifndef USB_POWER_SAVING_MODE
1206 if (!drvUSBHost_isPowerSaveModeEnable())
1207 {
1208 mbFUSBH200_VBUS_ON_Set();
1209 if ( (MDrv_USBGetChipID_Port4()==CHIPID_NEPTUNE) || //Neptune
1210 (MDrv_USBGetChipID_Port4()==CHIPID_ERIS) || //Eris
1211 (MDrv_USBGetChipID_Port4()==CHIPID_TITANIA) || //Titania
1212 (MDrv_USBGetChipID_Port4()==CHIPID_PLUTO) || //Pluto
1213 (MDrv_USBGetChipID_Port4()==CHIPID_TRITON) || //Triton
1214 (MDrv_USBGetChipID_Port4()==CHIPID_TITANIA2) ) // Titania 2
1215 {
1216 UHC4_ANDXBYTE(0x34,0xBF); //set suspend
1217 UHC4_ORXBYTE(0x34,0x40); //clr suspend
1218 MsOS_DelayTask(2);
1219 UTMI4_ORXBYTE(0x00,0x01); // override mode enable for power down control
1220 UTMI4_ORXBYTE(0x01,0x40); // enable IREF power down
1221 UTMI4_ORXBYTE(0x01,0x02); // enable PLL power down
1222 UTMI4_ANDXBYTE(0x01,0xFD); // disable PLL power down
1223 }
1224 mbHost20_USBCMD_HCReset_Set();
1225 }
1226 //#endif
1227 }
1228
MDrv_GetUsbDeviceStatusPort4()1229 U8 MDrv_GetUsbDeviceStatusPort4()
1230 {
1231 return gUsbDeviceState_Port4;
1232 }
1233
MDrv_SetUsbDeviceStatus_Port4(U8 status)1234 void MDrv_SetUsbDeviceStatus_Port4(U8 status)
1235 {
1236 gUsbDeviceState_Port4 = status;
1237 }
1238
MDrv_ClearUsbDeviceStatusPort4(void)1239 void MDrv_ClearUsbDeviceStatusPort4(void)
1240 {
1241 //if (gUsbDeviceState_Port4==BAD_DEVICE)
1242 //{
1243 // printf("Clear bad device\n");
1244 // gUsbDeviceState_Port4=USB11_DEVICE;
1245 //}
1246 }
ResetUsbHardwarePort4(void)1247 void ResetUsbHardwarePort4(void)
1248 {
1249 UTMI4_ORXBYTE(0x06,0x03); //reset UTMI
1250 UTMI4_ANDXBYTE(0x06,0xfc);
1251 mbHost20_USBCMD_HCReset_Set();
1252 //MsOS_DelayTask(200);
1253 }
1254 UINT32 UsbStartTimePort4=0;
1255 UINT32 UsbPowerSavingTimerPort4=0;
1256
1257 //#ifdef USB_POWER_SAVING_MODE
1258 extern void UsbTurnOffPowerDownMode(void);
1259 extern void UsbTurnOnPowerDownMode(void);
UsbPort4UTMIInitial(void)1260 void UsbPort4UTMIInitial(void)
1261 {
1262 mbFUSBH200_VBUS_ON_Set();
1263 UHC4_ANDXBYTE(0x34,0xBF); //set suspend
1264 UHC4_ORXBYTE(0x34,0x40); //clr suspend
1265 MsOS_DelayTask(2);
1266 UTMI4_ORXBYTE(0x00,0x01); // override mode enable for power down control
1267 UTMI4_ORXBYTE(0x01,0x40); // enable IREF power down
1268 UTMI4_ORXBYTE(0x01,0x02); // enable PLL power down
1269 UTMI4_ANDXBYTE(0x01,0xFD); // disable PLL power down
1270 UTMI4_ANDXBYTE(0x00,~0x01); // override mode enable for power down control
1271
1272 mbHost20_USBCMD_HCReset_Set();
1273 }
1274 //#endif
1275
1276 #ifdef Enable_Issue_TestPacketByHW
1277 BOOLEAN isInitForTestPkt_Port4 = TRUE;
1278 void MDrv_UsbSendTestPacket_Port4(void);
1279 #endif
1280
MDrv_UsbDeviceConnect_Port4(void)1281 BOOLEAN MDrv_UsbDeviceConnect_Port4(void)
1282 {
1283 /*
1284 if (gDeviceFatalError)
1285 {
1286 gDeviceFatalError=FALSE;
1287 ResetUsbHardware();
1288 return FALSE;
1289 }*/
1290 /*
1291 if (XBYTE[0x0B04]&0x40)
1292 {
1293 XBYTE[0x3AC0] &= 0xFE;
1294 }
1295 */
1296 #ifdef Enable_Issue_TestPacketByHW
1297 if (isInitForTestPkt_Port4)
1298 {
1299 isInitForTestPkt_Port4= FALSE;
1300 MDrv_UsbSendTestPacket_Port4();
1301 }
1302 return FALSE;
1303 #endif
1304
1305 #if 1
1306 if (drvUSBHost_isPowerSaveModeEnable())
1307 {
1308 if (gUsbDeviceState_Port4==WAIT_INIT)
1309 {
1310 if (MsOS_Timer_DiffTimeFromNow(UsbPowerSavingTimerPort4) < 300 )
1311 return FALSE;
1312 }
1313 if (gUsbDeviceState_Port4==POWER_SAVING)
1314 {
1315 #ifdef ENABLE_HOST_TEST
1316 if (USBC4_READXBYTE(8)&0xC0)
1317 #else
1318 if (USBC4_READXBYTE(8)&0x40)
1319 #endif
1320 {
1321 drvUSBHost_TurnOffPowerDownMode_Port4();
1322
1323 UsbPowerSavingTimerPort4 = MsOS_GetSystemTime();
1324 gUsbDeviceState_Port4=WAIT_INIT;
1325 return FALSE;
1326 }
1327 else
1328 {
1329 return FALSE;
1330 }
1331 }
1332 }
1333 #else
1334 #ifdef USB_POWER_SAVING_MODE
1335 //#ifdef USBHOST2PORT
1336 if (gUsbDeviceState==WAIT_INIT)
1337 return FALSE;
1338 //#endif
1339 if (gUsbDeviceState_Port4==WAIT_INIT)
1340 {
1341 if (MsOS_Timer_DiffTimeFromNow(UsbPowerSavingTimerPort4) < 300 )
1342 return FALSE;
1343 }
1344 if (gUsbDeviceState_Port4==POWER_SAVING)
1345 {
1346 if (XBYTE[gUSBC4_BASE+8]&0x40)
1347 {
1348 UsbTurnOffPowerDownMode();
1349 //UsbPort0UTMIInitial();
1350 drvUSBHost_UTMIInitial();
1351 //#ifdef USBHOST2PORT
1352 UsbPort1UTMIInitial();
1353 if (gUsbDeviceState==POWER_SAVING)
1354 gUsbDeviceState=NO_DEVICE;
1355 //#endif
1356 UsbPowerSavingTimerPort4 = MsOS_GetSystemTime();
1357 gUsbDeviceState_Port4=WAIT_INIT;
1358 return FALSE;
1359 //MsOS_DelayTask(300);
1360 }
1361 else
1362 {
1363 return FALSE;
1364 }
1365 }
1366 #endif
1367 #endif
1368 if (gUsbStatus_Port4==USB_EJECT)
1369 {
1370 if (UHC4_READXBYTE(0x30)&2)
1371 {
1372 gUsbStatus_Port4=USB_OK;
1373 }
1374 else
1375 return FALSE; //eject state
1376 }
1377 //FUSBH200_Driver_VBUS(); //make sure device is connected , then turn on VBUS
1378
1379 if (mwHost20_PORTSC_ConnectStatus_Rd())
1380 {
1381 if ( (gUsbDeviceState_Port4==USB11_DEVICE) ||(gUsbDeviceState_Port4==USB20_DEVICE) )
1382 {
1383 // If the device is connected and we get a connection change.
1384 // It means that the user change the device and we just missed.
1385 if (mwHost20_PORTSC_ConnectChange_Rd())
1386 {
1387 printf("dev changed, we missed\n");
1388 gSpeed_Port4=0xff; //reset this value
1389 UHC4_ANDXBYTE(0x40, (U8)~0x80);//clear force enter FSmode
1390 gUsbDeviceState_Port4= NO_DEVICE;
1391 return FALSE;
1392 }
1393 }
1394
1395 if (gUsbDeviceState_Port4==BAD_DEVICE) return FALSE; //not repeating doing emunerate
1396
1397 #if 0
1398 if (gSpeed_Port4==0x01)
1399 {
1400 MINI_DEBUG(printf("ls-exit\n"));
1401 return FALSE;
1402 }
1403 #endif
1404
1405 if (gUsbDeviceState_Port4==NO_DEVICE)
1406 gUsbDeviceState_Port4=CONNECT_DEVICE;
1407
1408 return TRUE;
1409 }
1410 else
1411 {
1412 gSpeed_Port4 = 0xFF;
1413 UHC4_ANDXBYTE(0x40,(U8)~0x80);//clear force enter FSmode
1414 #if 1
1415 if (drvUSBHost_isPowerSaveModeEnable())
1416 {
1417 if (gUsbDeviceState_Port4!=POWER_SAVING)
1418 drvUSBHost_TurnOnPowerDownMode_Port4();
1419
1420 gUsbDeviceState_Port4=POWER_SAVING;
1421 }
1422 else
1423 gUsbDeviceState_Port4=NO_DEVICE;
1424 #else
1425 #ifdef USB_POWER_SAVING_MODE
1426 if ((gUsbDeviceState==NO_DEVICE)||(gUsbDeviceState==POWER_SAVING))
1427 {
1428 if (gUsbDeviceState_Port4!=POWER_SAVING)
1429 UsbTurnOnPowerDownMode();
1430 gUsbDeviceState=POWER_SAVING;
1431 gUsbDeviceState_Port4=POWER_SAVING;
1432 }
1433 else
1434 gUsbDeviceState_Port4=NO_DEVICE;
1435 #else
1436 gUsbDeviceState_Port4=NO_DEVICE;
1437 #endif
1438 #endif
1439
1440
1441 #ifndef ATV_SERISE_USE
1442 if (MsOS_Timer_DiffTimeFromNow(UsbStartTimePort4) > 1000 )
1443 {
1444
1445 UsbStartTimePort4=MsOS_GetSystemTime();
1446 ResetUsbHardwarePort4();
1447
1448 }
1449 #else
1450 UsbStartTimePort4++;
1451 if(UsbStartTimePort4>0x600)
1452 {
1453 UsbStartTimePort4=0;
1454 ResetUsbHardwarePort4();
1455 }
1456 #endif
1457 //MINI_DEBUG( printf("no_con \n"));
1458 return FALSE;
1459 }
1460 }
1461
MDrv_EjectUsbDevice_Port4(void)1462 void MDrv_EjectUsbDevice_Port4(void)
1463 {
1464 struct LUN_Device* LunDevice;
1465 U8 i;
1466
1467 //printf("eject\n");
1468 LunDevice = Mass_stor_us1_port4.Mass_stor_device;
1469 for (i=0; i <= Mass_stor_us1_port4.max_lun ; i++)
1470 {
1471
1472 if (LunDevice[i].bDeviceReady == TRUE)
1473 {
1474 vSCSI_EJECT_DEVICE_Port4(i);
1475 gUsbStatus_Port4=USB_EJECT;
1476 mwHost20_PORTSC_ConnectChange_Set(); //clear port connect change bit
1477 //printf("ej_ok\n");
1478 }
1479 }
1480 flib_Host20_Close_Port4();
1481
1482 }
MDrv_UsbClose_Port4(void)1483 void MDrv_UsbClose_Port4(void)
1484 {
1485 flib_Host20_Close_Port4();
1486 }
1487
MDrv_UsbBlockReadToMIU_Port4(U8 lun,U32 u32BlockAddr,U32 u32BlockNum,U32 u32MIUAddr)1488 BOOLEAN MDrv_UsbBlockReadToMIU_Port4(U8 lun,U32 u32BlockAddr, U32 u32BlockNum,U32 u32MIUAddr)
1489 {
1490 BOOLEAN result;
1491 U8 retrycnt=0;
1492 struct LUN_Device* LunDevice = Mass_stor_us1_port4.Mass_stor_device;
1493
1494 if (mwHost20_PORTSC_ConnectStatus_Rd()==0)
1495 return FALSE; //device is not connected
1496
1497 if (gUsbDeviceState_Port4==BAD_DEVICE) return FALSE;
1498
1499
1500 if (u32BlockAddr > Mass_stor_us1_port4.Mass_stor_device[lun].u32BlockTotalNum)
1501 {
1502 MINI_DEBUG(printf("USBRead address is over the range:%lx\n",u32BlockAddr));
1503 return FALSE;
1504 }
1505 //printf("usb read sector:%lx\n",u32BlockNum);
1506
1507 #ifdef ATV_SERISE_USE
1508 #ifdef Enable_Close_INT
1509 XBYTE[0x2B00]|=0x02;
1510 DisableINT();
1511 #endif
1512 #endif
1513 //result= bSCSI_Read_Write10_Port4(FALSE,lun, u32BlockAddr, u32BlockNum, u32MIUAddr);
1514 while (1)
1515 {
1516 retrycnt++;
1517 result= bSCSI_Read_Write10_Port4(FALSE,lun, u32BlockAddr, u32BlockNum, PhytoCacheAddr(u32MIUAddr));
1518 if (result==TRUE) break;
1519 if (result==FALSE)
1520 {
1521 if (retrycnt > gUsbRetryCount_Port4)
1522 {
1523 if (gUsbStatus_Port4==USB_TIMEOUT)
1524 gUsbDeviceState_Port4=BAD_DEVICE; //mark as bad device
1525 else if(gUsbStatus_Port4 == USB_OK)
1526 {//give another chance : to restart the host & device(for example : read failed with device STALL)
1527 if(retrycnt > gUsbRetryCount_Port4+1)
1528 break;
1529 if (MDrv_Usb_Device_Enum_Port4()==FALSE)
1530 {
1531 result=FALSE;
1532 break;
1533 }
1534 continue;
1535 }
1536 else
1537 LunDevice[lun].bDeviceValid=FALSE; //mark as bad lun
1538
1539 break; //return FALSE
1540 }
1541 MINI_DEBUG( printf("USBDisk Read failed\n"));
1542 if (gUsbStatus_Port4==USB_TIMEOUT)
1543 {
1544 if ((retrycnt==2)&&(mwOTG20_Control_HOST_SPD_TYP_Rd()==2) ) //make sure it is hi speed
1545 {
1546 MINI_DEBUG(printf("Force FS\n"));
1547 UHC4_ORXBYTE(0x40,0x80);//force enter FSmode
1548 }
1549 #ifndef ATV_SERISE_USE
1550 msAPI_Timer_ResetWDT();
1551 #else
1552 #ifdef Enable_Close_INT
1553 XBYTE[0x2B00]&=0xFD;
1554 EnableINT();
1555 #endif
1556 #endif
1557
1558 #ifdef Enable_Low_Temperature_Patch
1559 if(gSpeed_Port4==0)
1560 {
1561 //printf("\r\n CDR toggle!!",0);
1562 UTMI4_SETXBYTE(0x0a, UTMI4_READXBYTE(0x0a)^0x10); //invert CDR_CLOCK
1563 UTMI4_ORXBYTE(0x06,0x03); //reset UTMI
1564 UTMI4_ANDXBYTE(0x06,0xfc);
1565 }
1566 #endif
1567
1568 // MDrv_Usb_Device_Enum(); //reinit usb device
1569 if (MDrv_Usb_Device_Enum_Port4()==FALSE)
1570 {
1571 result=FALSE;
1572 break;
1573 }
1574 }
1575 }
1576
1577 }
1578
1579 #ifdef ATV_SERISE_USE
1580 #ifdef Enable_Close_INT
1581 XBYTE[0x2B00]&=0xFD;
1582 EnableINT();
1583 #endif
1584 #endif
1585 //MDrv_Sys_ReleaseXdataWindow1();
1586 if (result==FALSE)
1587 {
1588 DRV_USB_DBG(printf("USBDisk Read failed\n"));
1589 //printf("read failed\n");
1590 }
1591
1592 return result;
1593
1594 }
1595
MDrv_UsbBlockWriteFromMIU_Port4(U8 lun,U32 u32BlockAddr,U32 u32BlockNum,U32 u32MIUAddr)1596 BOOLEAN MDrv_UsbBlockWriteFromMIU_Port4(U8 lun, U32 u32BlockAddr, U32 u32BlockNum,U32 u32MIUAddr)
1597 {
1598 BOOLEAN result;
1599 if (mwHost20_PORTSC_ConnectStatus_Rd()==0)
1600 return FALSE; //device is not connected
1601
1602 if (gUsbDeviceState_Port4==BAD_DEVICE) return FALSE;
1603
1604 if (u32BlockAddr > Mass_stor_us1_port4.Mass_stor_device[lun].u32BlockTotalNum)
1605 {
1606 MINI_DEBUG(printf("USBWrite address is over the range:%lx\n",u32BlockAddr));
1607 return FALSE;
1608 }
1609
1610 result= bSCSI_Read_Write10_Port4(TRUE,lun, u32BlockAddr, u32BlockNum, PhytoCacheAddr(u32MIUAddr));
1611
1612 return result;
1613
1614 }
MDrv_GetUsbBlockSize_Port4(U8 lun)1615 U32 MDrv_GetUsbBlockSize_Port4(U8 lun)
1616 {
1617 return Mass_stor_us1_port4.Mass_stor_device[lun].u32BlockSize;
1618 }
1619
MDrv_GetUsbBlockNum_Port4(U8 lun)1620 U32 MDrv_GetUsbBlockNum_Port4(U8 lun)
1621 {
1622 return Mass_stor_us1_port4.Mass_stor_device[lun].u32BlockTotalNum;
1623 }
1624
1625
MDrv_USB_GetXDataExtStackCountPort4(void)1626 U8 MDrv_USB_GetXDataExtStackCountPort4(void)
1627 {
1628 return xdwin1_lockCount_Port4;
1629 }
1630 //---if you don't know how to use it, don't use it
1631 #if 0
1632 void EnterUXBModePort4()
1633 {
1634 MINI_DEBUG( printf("Enter UXB mode\n"));
1635 UHC_XBYTE(0x40)|=0x80;//force enter FSmode
1636 MDrv_Usb_Device_Enum_Port4();
1637 }
1638 void LeaveUXBModePort4()
1639 {
1640 MINI_DEBUG(printf("leave UXB mode \n"));
1641 UHC_XBYTE(0x40)&=~0x80;//leave FSmode
1642 MDrv_Usb_Device_Enum_Port4();
1643
1644 }
1645 #endif
1646 #ifndef DEVICE_ENUM_SEGMENT
MDrv_Usb_Device_Enum_Port4(void)1647 BOOLEAN MDrv_Usb_Device_Enum_Port4(void)
1648 {
1649 BOOLEAN result=FALSE;
1650 U8 RetryCount=0;
1651
1652 U8 rootUSBDeviceInterfaceClass = USB_INTERFACE_CLASS_NONE;
1653
1654 if (gUsbDeviceState_Port4==BAD_DEVICE) return FALSE; //bad device , no more enumerate
1655
1656 //20120820, Patch for devices, can't repeat to re-enumerate.
1657 if ( (gUsbDeviceState_Port4==USB11_DEVICE) ||(gUsbDeviceState_Port4==USB20_DEVICE) )
1658 {
1659 U16 uVID, uPID;
1660 U8 ii;
1661
1662 MDrv_USBGetVIDPID_Port4(&uVID, &uPID);
1663 ii = 0;
1664 while ( (gDontReEnumList_Port4[ii].VID != 0) && (gDontReEnumList_Port4[ii].PID != 0) )
1665 {
1666 if ( (uVID == gDontReEnumList_Port4[ii].VID) && (uPID == gDontReEnumList_Port4[ii].PID) )
1667 {
1668 printf("Don't re-enumerate for special device.");
1669 return TRUE;
1670 }
1671
1672 ii++;
1673 if (ii >= (sizeof(gDontReEnumList_Port4) / sizeof(struct stDontReEnumList)))
1674 break;
1675 }
1676 }
1677
1678 NowIsHubPort4=0;
1679
1680 #ifdef Enable_SOF_Only
1681 UHC4_ORXBYTE(0x40,0x80);//force enter FSmode
1682 #endif
1683 port4_redo_init:
1684 //USB ROOT
1685 RetryCount++;
1686 if (MDrv_UsbHost_Init_Port4()==FALSE) goto port4_fail_exit;
1687 if (flib_Host20_Enumerate_Port4(1,3)==0)
1688 {
1689 if ((gUsbStatus_Port4==USB_TIMEOUT)||(gUsbStatus_Port4==USB_INIT_FAIL))
1690 {
1691 if ((RetryCount==2)&&(mwOTG20_Control_HOST_SPD_TYP_Rd()==2))
1692 { //make sure it is hi speed
1693 MINI_DEBUG(printf("Force FS\n"));
1694 UHC4_ORXBYTE(0x40,0x80);//force enter FSmode
1695 }
1696 if (RetryCount >= 3)
1697 {
1698 MINI_DEBUG(printf("bad device\n"));
1699 gUsbDeviceState_Port4=BAD_DEVICE;
1700 goto port4_fail_exit;
1701 }
1702 #ifndef ATV_SERISE_USE
1703 msAPI_Timer_ResetWDT();
1704 #endif
1705 goto port4_redo_init;
1706 }
1707 gUsbDeviceState_Port4=BAD_DEVICE;
1708 goto port4_fail_exit;
1709 }
1710 else
1711 {
1712 UTMI4_SETXBYTE(0x2a,0);
1713
1714 rootUSBDeviceInterfaceClass= psAttachDevice_Port4->saCD[0].sInterface[0].bInterfaceClass;
1715 //MDrv_UsbGetInterfaceClass(0, 0);
1716 DRV_USB_DBG(printf("Check USD Device 4\n"););
1717 #if 0 //We don't need to check here
1718 if(rootUSBDeviceInterfaceClass != 0x08 && rootUSBDeviceInterfaceClass != 0x09)
1719 {
1720 //printf("unsupport class\n",0);
1721 DRV_USB_DBG(printf("unsupport USB root class=%02bx\n", rootUSBDeviceInterfaceClass););
1722 result= FALSE;
1723 goto port4_fail_exit;
1724 }
1725 #endif
1726
1727 DRV_USB_DBG(printf("USB root class=%02bx\n",rootUSBDeviceInterfaceClass););
1728 if (rootUSBDeviceInterfaceClass==USB_INTERFACE_CLASS_HUB)//HUB
1729 {
1730 U8 PortNum,i,devaddr,stor_devs;
1731
1732 #ifdef ENABLE_HOST_TEST
1733 printf("Unsupport USB hub\n");
1734 gUsbDeviceState_Port4=BAD_DEVICE;
1735 goto port4_fail_exit;
1736 #endif
1737
1738 devaddr=6;
1739 stor_devs = 0;
1740 DRV_USB_DBG(printf("Hub class!\n"));
1741
1742 PortNum=Usb_Hub_Port_Num_Port4();
1743 for (i=1; i <= PortNum ; i++)
1744 {
1745 psAttachDevice_Port4->bAdd=3;
1746 pHost20_qHD_List_Control1_Port4->bDeviceAddress=psAttachDevice_Port4->bAdd;
1747 if (USB_Hub_Handle_Port4(i)==FALSE)
1748 {
1749 result=FALSE;
1750 continue;
1751 }
1752 devaddr++;
1753 NowIsHubPort4=1;
1754 if (flib_Host20_Enumerate_Port4(1,devaddr)==0)
1755 {
1756 result=FALSE;
1757 continue;
1758 }
1759
1760 //MStar, 20111110, For card reader with internal hub
1761 if (psAttachDevice_Port4->saCD[0].sInterface[0].bInterfaceClass == 0x08)
1762 stor_devs++;
1763
1764 psAttachDevice_Port4->bAdd=devaddr;
1765 result=MassStorage_Init_Port4(); //do mass storage class init
1766 if (result==TRUE) break;
1767 }
1768 if ( (result==FALSE) && (stor_devs == 0) )
1769 {
1770 MINI_DEBUG(printf("unsupport hub class device,->bad device\n"));
1771 gUsbDeviceState_Port4=BAD_DEVICE;
1772 }
1773 }
1774 //else if(rootUSBDeviceInterfaceClass==USB_INTERFACE_CLASS_MSD)//Mass storage class
1775 else if ( (rootUSBDeviceInterfaceClass == USB_INTERFACE_CLASS_MSD) &&
1776 (psAttachDevice_Port4->saCD[0].sInterface[0].bInterfaceProtocol == 0x50) )
1777 {
1778 result=MassStorage_Init_Port4();
1779 #ifdef Enable_Burning_Test
1780 UsbTestPort4();
1781 #endif
1782
1783 #ifdef Enable_Low_Temperature_Patch
1784 if((gSpeed_Port4==0)&&(gUsbStatus_Port4==USB_TIMEOUT))
1785 {
1786 //printf("\r\n CDR toggle!!",0);
1787 UTMI4_SETXBYTE(0x0a, UTMI4_READXBYTE(0x0a)^0x10); //invert CDR_CLOCK
1788 UTMI4_ORXBYTE(0x06,0x03); //reset UTMI
1789 UTMI4_ANDXBYTE(0x06,0xfc);
1790 }
1791 #endif
1792
1793 }
1794 #ifdef ENABLE_CBI_HOST
1795 else if ( (rootUSBDeviceInterfaceClass == USB_INTERFACE_CLASS_MSD) &&
1796 ((psAttachDevice_Port4->saCD[0].sInterface[0].bInterfaceProtocol == 0x00)||
1797 (psAttachDevice_Port4->saCD[0].sInterface[0].bInterfaceProtocol == 0x01)) )
1798 {
1799 DRV_USB_DBG(printf("My CBI MassStorage Device!!!\n"));
1800
1801 result=MassStorage_Init_Port4(); //do mass storage class init
1802 return result;
1803 }
1804 #endif
1805 #ifndef ENABLE_HOST_TEST
1806 else if (rootUSBDeviceInterfaceClass == USB_INTERFACE_CLASS_IMAGE)
1807 {
1808 if (drvUSBHost_PTP_Init(USB_PORT_4) == PTP_OK)
1809 {
1810 result = TRUE;
1811 DRV_USB_DBG(printf("PTP initial ok\r\n"));
1812 }
1813 }
1814 else if (rootUSBDeviceInterfaceClass==USB_INTERFACE_CLASS_HID)//HID
1815 {
1816 if (drvUSBHost_HID_Init(USB_PORT_4) == 0)
1817 {
1818 result = TRUE;
1819 DRV_USB_DBG(printf("HID initial ok\r\n"));
1820 }
1821 }
1822 #endif
1823 else
1824 {
1825 MINI_DEBUG(printf("unsupport %02bx class device->bad device\n",rootUSBDeviceInterfaceClass));
1826 gUsbDeviceState_Port4=BAD_DEVICE; //not belong to any above
1827 }
1828
1829 DRV_USB_DBG(printf("USB_CON\n"););
1830 //return result;
1831 }
1832
1833 port4_fail_exit:
1834
1835 if (mwHost20_PORTSC_ConnectChange_Rd())
1836 mwHost20_PORTSC_ConnectChange_Set();
1837
1838 return result;
1839 }
1840 #else // support device enumeration dividable
_MDrv_Usb_Device_Enum0_Port4(void)1841 U8 _MDrv_Usb_Device_Enum0_Port4(void)
1842 {
1843 if (gUsbDeviceState_Port4==BAD_DEVICE)
1844 return 0; //bad device , no more enumerate
1845
1846 //20120820, Patch for devices, can't repeat to re-enumerate.
1847 if ( (gUsbDeviceState_Port4==USB11_DEVICE) ||(gUsbDeviceState_Port4==USB20_DEVICE) )
1848 {
1849 U16 uVID, uPID;
1850 U8 ii;
1851
1852 MDrv_USBGetVIDPID_Port4(&uVID, &uPID);
1853 ii = 0;
1854 while ( (gDontReEnumList_Port4[ii].VID != 0) && (gDontReEnumList_Port4[ii].PID != 0) )
1855 {
1856 if ( (uVID == gDontReEnumList_Port4[ii].VID) && (uPID == gDontReEnumList_Port4[ii].PID) )
1857 {
1858 printf("Don't re-enumerate for special device.");
1859 return 1;
1860 }
1861
1862 ii++;
1863 if (ii >= (sizeof(gDontReEnumList_Port4) / sizeof(struct stDontReEnumList)))
1864 break;
1865 }
1866 }
1867
1868 NowIsHubPort4=0;
1869
1870 #ifdef Enable_SOF_Only
1871 UHC4_ORXBYTE(0x40,0x80);//force enter FSmode
1872 #endif
1873
1874 return 2;
1875 }
1876
_MDrv_Usb_Device_Enum_OK_Port4(void)1877 BOOLEAN _MDrv_Usb_Device_Enum_OK_Port4(void)
1878 {
1879 BOOLEAN result=FALSE;
1880 U8 rootUSBDeviceInterfaceClass = USB_INTERFACE_CLASS_NONE;
1881
1882 UTMI4_SETXBYTE(0x2a,0);
1883
1884 rootUSBDeviceInterfaceClass= psAttachDevice_Port4->saCD[0].sInterface[0].bInterfaceClass;
1885 //MDrv_UsbGetInterfaceClass(0, 0);
1886 DRV_USB_DBG(printf("Check USD Device 4\n"););
1887 #if 0 //We don't need to check here
1888 if(rootUSBDeviceInterfaceClass != 0x08 && rootUSBDeviceInterfaceClass != 0x09)
1889 {
1890 //printf("unsupport class\n",0);
1891 DRV_USB_DBG(printf("unsupport USB root class=%02bx\n", rootUSBDeviceInterfaceClass););
1892 result= FALSE;
1893 goto port4_fail_exit;
1894 }
1895 #endif
1896
1897 DRV_USB_DBG(printf("USB root class=%02bx\n",rootUSBDeviceInterfaceClass););
1898 if (rootUSBDeviceInterfaceClass==USB_INTERFACE_CLASS_HUB)//HUB
1899 {
1900 U8 PortNum,i,devaddr,stor_devs;
1901
1902 #ifdef ENABLE_HOST_TEST
1903 printf("Unsupport USB hub\n");
1904 gUsbDeviceState_Port4=BAD_DEVICE;
1905 return FALSE;
1906 #endif
1907
1908 devaddr=6;
1909 stor_devs = 0;
1910 DRV_USB_DBG(printf("Hub class!\n"));
1911
1912 PortNum=Usb_Hub_Port_Num_Port4();
1913 for (i=1; i <= PortNum ; i++)
1914 {
1915 psAttachDevice_Port4->bAdd=3;
1916 pHost20_qHD_List_Control1_Port4->bDeviceAddress=psAttachDevice_Port4->bAdd;
1917 if (USB_Hub_Handle_Port4(i)==FALSE)
1918 {
1919 result=FALSE;
1920 continue;
1921 }
1922 devaddr++;
1923 NowIsHubPort4=1;
1924 if (flib_Host20_Enumerate_Port4(1,devaddr)==0)
1925 {
1926 result=FALSE;
1927 continue;
1928 }
1929
1930 //MStar, 20111110, For card reader with internal hub
1931 if (psAttachDevice_Port4->saCD[0].sInterface[0].bInterfaceClass == 0x08)
1932 stor_devs++;
1933
1934 psAttachDevice_Port4->bAdd=devaddr;
1935 result=MassStorage_Init_Port4(); //do mass storage class init
1936 if (result==TRUE) break;
1937 }
1938 if ( (result==FALSE) && (stor_devs == 0) )
1939 {
1940 MINI_DEBUG(printf("unsupport hub class device,->bad device\n"));
1941 gUsbDeviceState_Port4=BAD_DEVICE;
1942 }
1943 }
1944 //else if(rootUSBDeviceInterfaceClass==USB_INTERFACE_CLASS_MSD)//Mass storage class
1945 else if ( (rootUSBDeviceInterfaceClass == USB_INTERFACE_CLASS_MSD) &&
1946 (psAttachDevice_Port4->saCD[0].sInterface[0].bInterfaceProtocol == 0x50) )
1947 {
1948 result=MassStorage_Init_Port4();
1949 #ifdef Enable_Burning_Test
1950 UsbTestPort4();
1951 #endif
1952
1953 #ifdef Enable_Low_Temperature_Patch
1954 if((gSpeed_Port4==0)&&(gUsbStatus_Port4==USB_TIMEOUT))
1955 {
1956 //printf("\r\n CDR toggle!!",0);
1957 UTMI4_SETXBYTE(0x0a, UTMI4_READXBYTE(0x0a)^0x10); //invert CDR_CLOCK
1958 UTMI4_ORXBYTE(0x06,0x03); //reset UTMI
1959 UTMI4_ANDXBYTE(0x06,0xfc);
1960 }
1961 #endif
1962
1963 }
1964 #ifdef ENABLE_CBI_HOST
1965 else if ( (rootUSBDeviceInterfaceClass == USB_INTERFACE_CLASS_MSD) &&
1966 ((psAttachDevice_Port4->saCD[0].sInterface[0].bInterfaceProtocol == 0x00)||
1967 (psAttachDevice_Port4->saCD[0].sInterface[0].bInterfaceProtocol == 0x01)) )
1968 {
1969 DRV_USB_DBG(printf("My CBI MassStorage Device!!!\n"));
1970
1971 result=MassStorage_Init_Port4(); //do mass storage class init
1972 //return result;
1973 }
1974 #endif
1975 else if (rootUSBDeviceInterfaceClass == USB_INTERFACE_CLASS_IMAGE)
1976 {
1977 if (drvUSBHost_PTP_Init(USB_PORT_4) == PTP_OK)
1978 {
1979 result = TRUE;
1980 DRV_USB_DBG(printf("PTP initial ok\r\n"));
1981 }
1982 }
1983 else if (rootUSBDeviceInterfaceClass==USB_INTERFACE_CLASS_HID)//HID
1984 {
1985 if (drvUSBHost_HID_Init(USB_PORT_4) == 0)
1986 {
1987 result = TRUE;
1988 DRV_USB_DBG(printf("HID initial ok\r\n"));
1989 }
1990 }
1991 else
1992 {
1993 MINI_DEBUG(printf("unsupport %02bx class device->bad device\n",rootUSBDeviceInterfaceClass));
1994 gUsbDeviceState_Port4=BAD_DEVICE; //not belong to any above
1995 }
1996
1997 DRV_USB_DBG(printf("USB_CON\n"););
1998 //return result;
1999
2000 return result;
2001 }
MDrv_Usb_Device_Enum_Port4(void)2002 BOOLEAN MDrv_Usb_Device_Enum_Port4(void)
2003 {
2004 BOOLEAN result=FALSE;
2005 U8 RetryCount=0, retval;
2006
2007 retval = _MDrv_Usb_Device_Enum0_Port4();
2008 if (retval != 2)
2009 return (retval == 0 ? FALSE: TRUE);
2010
2011 port4_redo_init:
2012 //USB ROOT
2013 RetryCount++;
2014 if (MDrv_UsbHost_Init_Port4()==FALSE) goto port4_fail_exit;
2015 if (flib_Host20_Enumerate_Port4(1,3)==0)
2016 {
2017 if ((gUsbStatus_Port4==USB_TIMEOUT)||(gUsbStatus_Port4==USB_INIT_FAIL))
2018 {
2019 if ((RetryCount==2)&&(mwOTG20_Control_HOST_SPD_TYP_Rd()==2))
2020 { //make sure it is hi speed
2021 MINI_DEBUG(printf("Force FS\n"));
2022 UHC4_ORXBYTE(0x40,0x80);//force enter FSmode
2023 }
2024 if (RetryCount >= 3)
2025 {
2026 MINI_DEBUG(printf("bad device\n"));
2027 gUsbDeviceState_Port4=BAD_DEVICE;
2028 goto port4_fail_exit;
2029 }
2030 #ifndef ATV_SERISE_USE
2031 msAPI_Timer_ResetWDT();
2032 #endif
2033 goto port4_redo_init;
2034 }
2035 gUsbDeviceState_Port4=BAD_DEVICE;
2036 goto port4_fail_exit;
2037 }
2038 else
2039 {
2040 result = _MDrv_Usb_Device_Enum_OK_Port4();
2041 }
2042
2043 port4_fail_exit:
2044
2045 if (mwHost20_PORTSC_ConnectChange_Rd())
2046 mwHost20_PORTSC_ConnectChange_Set();
2047 return result;
2048 }
2049
2050 /*
2051 Device Enumerate State:
2052 0: global variable initial
2053 1: ready to start new enumerating process
2054 2: in-progress, stage 1
2055 3: in-progress, stage 2
2056 return value:
2057 0: success
2058 1: in-progress
2059 2: fail
2060 */
2061 U8 enum_state_port4 = 0;
2062 U32 usbDevEnumTimer_port4;
MDrv_Usb_Device_Enum_EX_Port4(void)2063 U8 MDrv_Usb_Device_Enum_EX_Port4(void)
2064 {
2065 BOOLEAN result=FALSE;
2066 U8 retval;
2067 static U8 RetryCount;
2068 static U8 fr;
2069
2070 port4_redo_init_ex:
2071 //USB ROOT
2072
2073 switch (enum_state_port4)
2074 {
2075 case 0: // initial global variables
2076 RetryCount = 0;
2077 retval = _MDrv_Usb_Device_Enum0_Port4();
2078 if (retval != 2)
2079 return (retval == 0 ? DEVENUM_FAIL: DEVENUM_OK);
2080
2081 case 1: // first entry
2082 RetryCount++;
2083 if (_MDrv_UsbHost_Init0_Port4()==FALSE)
2084 goto port4_fail_exit_ex; // MDrv_UsbHost_Init() part 1
2085 enum_state_port4 = 2;
2086 usbDevEnumTimer_port4 = MsOS_GetSystemTime();
2087 return DEVENUM_INPROGRESS;
2088
2089 case 2: // in-progress stage 1
2090 if (MsOS_Timer_DiffTimeFromNow(usbDevEnumTimer_port4) < USB_HOST_INIT_DELAY)
2091 return DEVENUM_INPROGRESS;
2092
2093 if (_MDrv_UsbHost_Init1_Port4()==FALSE) // MDrv_UsbHost_Init() part 2
2094 goto port4_fail_exit_ex;
2095
2096 fr = _flib_Host20_Enumerate_Port4(1, 3); // flib_Host20_Enumerate() part 1
2097 if (fr ==0)
2098 break;
2099 enum_state_port4 = 3;
2100 usbDevEnumTimer_port4 = MsOS_GetSystemTime();
2101 return DEVENUM_INPROGRESS;
2102
2103 case 3: // in-progress stage 2
2104 if (MsOS_Timer_DiffTimeFromNow(usbDevEnumTimer_port4) < USB_ENUM_DELAY)
2105 return DEVENUM_INPROGRESS;
2106 }
2107
2108 if (fr==0)
2109 {
2110 if ((gUsbStatus_Port4==USB_TIMEOUT)||(gUsbStatus_Port4==USB_INIT_FAIL))
2111 {
2112 #ifdef DTV_STANDARD_LIB
2113 if ((RetryCount==2)&&(mwOTG20_Control_HOST_SPD_TYP_Rd()==2))
2114 { //make sure it is hi speed
2115 MINI_DEBUG(printf("Force FS\n"));
2116 UHC4_ORXBYTE(0x40,0x80);//force enter FSmode
2117 }
2118 #endif
2119 if (RetryCount >= 3)
2120 {
2121 MINI_DEBUG(printf("bad device\n"));
2122 gUsbDeviceState_Port4=BAD_DEVICE;
2123 goto port4_fail_exit_ex;
2124 }
2125 #ifndef ATV_SERISE_USE
2126 msAPI_Timer_ResetWDT();
2127 #endif
2128 enum_state_port4 = 1; // retry use
2129 goto port4_redo_init_ex;
2130 }
2131 gUsbDeviceState_Port4=BAD_DEVICE;
2132 goto port4_fail_exit_ex;
2133 }
2134 else
2135 {
2136 result = _MDrv_Usb_Device_Enum_OK_Port4();
2137 }
2138
2139 port4_fail_exit_ex:
2140
2141 if (mwHost20_PORTSC_ConnectChange_Rd())
2142 mwHost20_PORTSC_ConnectChange_Set();
2143 enum_state_port4 = 0; // reset to initial
2144
2145 //return result;
2146 return ( result ? DEVENUM_OK : DEVENUM_FAIL);
2147 }
2148 #endif
2149 //////////////////////////////////////////////////////////////////////////////////////////
2150 //
2151 // USB Issue Test packet function !!
2152 //
2153 /////////////////////////////////////////////////////////////////////////////////////////
2154 U8 UTMI_Reg_14_Port4 = 0xff, UTMI_Reg_15_Port4 = 0xff;
Port3_IssueTestPacket_Initial(void)2155 void Port3_IssueTestPacket_Initial(void)
2156 {
2157 UTMI4_SETXBYTE(0x02, 0x84);
2158 UTMI4_SETXBYTE(0x03, 0x20);
2159
2160 USBC4_SETXBYTE(0x00, 0x0A);
2161 USBC4_SETXBYTE(0x00, 0x28);
2162
2163 UTMI4_SETXBYTE(0x06, 0x00);
2164 UTMI4_SETXBYTE(0x07, 0x00);
2165 UTMI4_SETXBYTE(0x10, 0x00);
2166 UTMI4_SETXBYTE(0x11, 0x00);
2167 UTMI4_SETXBYTE(0x2c, 0x00);
2168 UTMI4_SETXBYTE(0x2d, 0x00);
2169 UTMI4_SETXBYTE(0x2e, 0x00);
2170 UTMI4_SETXBYTE(0x2f, 0x00);
2171 if (UTMI_Reg_14_Port4== 0xff)
2172 UTMI_Reg_14_Port4= UTMI4_READXBYTE(0x14);
2173 else
2174 UTMI4_SETXBYTE(0x14, UTMI_Reg_14_Port4);
2175
2176 if (UTMI_Reg_15_Port4== 0xff)
2177 UTMI_Reg_15_Port4= UTMI4_READXBYTE(0x15);
2178 else
2179 UTMI4_SETXBYTE(0x15, UTMI_Reg_15_Port4);
2180
2181 UTMI4_ORXBYTE(0x06,0x40); //Force HS TX current enable and CDR stage select
2182 UTMI4_ANDXBYTE(0x06,~0x20); //clear bit 5
2183
2184 UTMI4_ORXBYTE(0x06,0x03); //reset UTMI
2185 MsOS_DelayTask(2);
2186 UTMI4_ANDXBYTE(0x06,0xfc);
2187
2188 UTMI4_SETXBYTE(0x03, 0xa8); //for device disconnect status bit
2189 //XBYTE[UTMIBaseAddr+0x07]|=0x02; //
2190
2191 if (MDrv_USBGetChipID_Port4()==CHIPID_NEPTUNE) //Neptune , after U06
2192 {
2193 if (MDrv_USBGetChipVersion_Port4()>= 0x6) //U07
2194 {
2195 UTMI4_ORXBYTE(0x07, 0x02);
2196 UTMI4_SETXBYTE(0x2c,0xc1);
2197 UTMI4_SETXBYTE(0x2d,0x3b);//enable TX common mode,
2198 UTMI4_ORXBYTE(0x2f, 0x0e); //preemsis
2199 }
2200 }
2201 else if ((MDrv_USBGetChipID_Port4()>=CHIPID_ERIS)&&(MDrv_USBGetChipID_Port4()<=CHIPID_TITANIA)) //Eris: 3 ,Titania: 4,
2202 {
2203 UTMI4_SETXBYTE(0x2c,0xc5);
2204 UTMI4_SETXBYTE(0x2d,0x3b);//enable TX common mode,
2205 UTMI4_ORXBYTE(0x2f, 0x0e); //preemsis
2206 }
2207 else if (MDrv_USBGetChipID_Port4()==CHIPID_PLUTO) // Pluto: 5
2208 {
2209 UTMI4_ORXBYTE(0x2c, 0xc5);
2210 UTMI4_ORXBYTE(0x2d, 0x3);//enable TX common mode,
2211 UTMI4_ORXBYTE(0x2f, 0x4a); //preemsis
2212 UTMI4_ORXBYTE(0x13, 0x70);
2213 }
2214 else if (MDrv_USBGetChipID_Port4()==CHIPID_TITANIA2) // Titania 2
2215 {
2216 UTMI4_ORXBYTE(0x2c, 0xc1);
2217 UTMI4_ORXBYTE(0x2d, 0x3);//enable TX common mode,
2218 UTMI4_ORXBYTE(0x2f, 0x4a); //preemsis
2219 }
2220 else if (MDrv_USBGetChipID_Port4()==CHIPID_TRITON) //Triton=6
2221 {
2222 UTMI4_SETXBYTE(0x2c,0xc1);
2223 UTMI4_SETXBYTE(0x2d,0x3b);//enable TX common mode,
2224 UTMI4_ORXBYTE(0x2f,0x0e); //preemsis
2225 }
2226 else if (MDrv_USBGetChipID_Port4()==CHIPID_EUCLID) // Euclid
2227 {
2228 UTMI4_ORXBYTE(0x2c, 0xc1);
2229 UTMI4_ORXBYTE(0x2d, 0x3);//enable TX common mode,
2230 UTMI4_ORXBYTE(0x2f, 0x4a); //preemsis
2231 }
2232 else if ( (MDrv_USBGetChipID_Port4()==CHIPID_TITANIA3) || // Titania 3, Titania 4
2233 (MDrv_USBGetChipID_Port4()==CHIPID_TITANIA4) ||
2234 (MDrv_USBGetChipID_Port4()==CHIPID_TITANIA7) ||
2235 (MDrv_USBGetChipID_Port4()==CHIPID_TITANIA8) ||
2236 (MDrv_USBGetChipID_Port4()==CHIPID_TITANIA9) ||
2237 (MDrv_USBGetChipID_Port4()==CHIPID_TITANIA12) ||
2238 (MDrv_USBGetChipID_Port4()==CHIPID_TITANIA13) ||
2239 (MDrv_USBGetChipID_Port4()==CHIPID_JANUS) ||
2240 (MDrv_USBGetChipID_Port4() == CHIPID_MARIA10) ||
2241 (MDrv_USBGetChipID_Port4() == CHIPID_MACAW12) ||
2242 (MDrv_USBGetChipID_Port4() == CHIPID_JANUS2) ||
2243 (MDrv_USBGetChipID_Port4() == CHIPID_AMBER6) )
2244 {
2245 UTMI4_ORXBYTE(0x2c, 0x10); //TX-current adjust to 105%
2246 UTMI4_ORXBYTE(0x2d, 0x02); //Pre-emphasis enable
2247 UTMI4_ORXBYTE(0x2f, 0x81); //HS_TX common mode current enable (100mV);Pre-emphasis enable (10%)
2248 UTMI4_ORXBYTE(0x09,0x81); //UTMI RX anti-dead-lock, ISI improvement
2249 }
2250 else //for Amber1 later 40nm
2251 {
2252 UTMI4_ORXBYTE(0x2c, 0x50);
2253 UTMI4_ORXBYTE(0x2d, 0x02);
2254 UTMI4_ORXBYTE(0x2f, 0x01);
2255 UTMI4_ORXBYTE(0x09,0x81); //UTMI RX anti-dead-lock, ISI improvement
2256 }
2257
2258 if (MDrv_USBGetChipID_Port4()==CHIPID_PLUTO) // If is Pluto
2259 UTMI4_ORXBYTE(0x09,0x01); //ISI improvement
2260 else
2261 UTMI4_ORXBYTE(0x13,0x02); //ISI improvement
2262
2263 if ( (MDrv_USBGetChipID_Port4() == CHIPID_NEPTUNE) ||
2264 (MDrv_USBGetChipID_Port4() == CHIPID_ERIS) ||
2265 (MDrv_USBGetChipID_Port4() == CHIPID_TITANIA) ||
2266 (MDrv_USBGetChipID_Port4() == CHIPID_PLUTO) ||
2267 (MDrv_USBGetChipID_Port4() == CHIPID_TRITON) ||
2268 (MDrv_USBGetChipID_Port4() == CHIPID_TITANIA2) )
2269 {
2270 }
2271 else
2272 {
2273 UTMI4_ORXBYTE(0x0b, 0x80); //TX timing select latch path
2274 }
2275
2276 UTMI4_ORXBYTE(0x09,0x60);//0x20; //patch low tempture,FL meta issue and enable new FL RX engin
2277
2278 if ( (MDrv_USBGetChipID_Port4() == CHIPID_NEPTUNE) ||
2279 (MDrv_USBGetChipID_Port4() == CHIPID_ERIS) ||
2280 (MDrv_USBGetChipID_Port4() == CHIPID_TITANIA) ||
2281 (MDrv_USBGetChipID_Port4() == CHIPID_PLUTO) ||
2282 (MDrv_USBGetChipID_Port4() == CHIPID_TRITON) ||
2283 (MDrv_USBGetChipID_Port4() == CHIPID_TITANIA2) ||
2284 (MDrv_USBGetChipID_Port4() == CHIPID_TITANIA3) ||
2285 (MDrv_USBGetChipID_Port4() == CHIPID_TITANIA4) ||
2286 (MDrv_USBGetChipID_Port4() == CHIPID_TITANIA7) ||
2287 (MDrv_USBGetChipID_Port4() == CHIPID_TITANIA8) ||
2288 (MDrv_USBGetChipID_Port4() == CHIPID_TITANIA9) ||
2289 (MDrv_USBGetChipID_Port4() == CHIPID_TITANIA12) ||
2290 (MDrv_USBGetChipID_Port4() == CHIPID_TITANIA13) ||
2291 (MDrv_USBGetChipID_Port4() == CHIPID_JANUS) ||
2292 (MDrv_USBGetChipID_Port4() == CHIPID_MARIA10) ||
2293 (MDrv_USBGetChipID_Port4() == CHIPID_MACAW12) ||
2294 (MDrv_USBGetChipID_Port4() == CHIPID_JANUS2) ||
2295 (MDrv_USBGetChipID_Port4() == CHIPID_AMBER1) ||
2296 (MDrv_USBGetChipID_Port4() == CHIPID_AMBER3) ||
2297 (MDrv_USBGetChipID_Port4() == CHIPID_AMBER5) ||
2298 (MDrv_USBGetChipID_Port4() == CHIPID_AMBER6) ||
2299 (MDrv_USBGetChipID_Port4() == CHIPID_AMBER7) ||
2300 (MDrv_USBGetChipID_Port4() == CHIPID_AMETHYST) )
2301 {
2302 UTMI4_ORXBYTE(0x15,0x20); //HOST CHIRP Detect
2303 }
2304 else
2305 {
2306 UTMI4_ORXBYTE(0x15,0x60); // change to 55 interface (bit6)
2307 }
2308 MsOS_DelayTask(10);
2309 }
2310
2311 #ifdef Enable_Issue_TestPacket
2312
2313 extern void USB_DACHE_FLUSH_Port4(U32 addr, U32 length);
2314
IssueTestPacket_Port4(U8 * TestDataAddr)2315 void IssueTestPacket_Port4(U8 *TestDataAddr)
2316 {
2317 U32 DMAAddress,datreg32;
2318 U8 *TestData;
2319 #ifdef Issue_TestPacket
2320 U16 i;
2321 #endif
2322
2323 printf("Start Test Packet on Port3\n");
2324 TestData=(U8*) KSEG02KSEG1(TestDataAddr);
2325
2326 #ifdef Issue_OUTTestPacket
2327 TestData[0]=0x55;
2328 TestData[1]=0x53;
2329 TestData[2]=0x42;
2330 TestData[3]=0x43;
2331 TestData[4]=0x88;
2332 TestData[5]=0x88;
2333 TestData[6]=0x89;
2334 TestData[7]=0xa0;
2335 TestData[8]=0x00;
2336 TestData[9]=0x02;
2337 TestData[10]=0x00;
2338 TestData[11]=0x00;
2339 TestData[12]=0x80;
2340 TestData[13]=0x00;
2341 TestData[14]=0x0a;
2342 TestData[15]=0x28;
2343 TestData[16]=0x00;
2344 TestData[17]=0x00;
2345 TestData[18]=0x00;
2346 TestData[19]=0x00;
2347 TestData[20]=0x84;
2348 TestData[21]=0x00;
2349 TestData[22]=0x00;
2350 TestData[23]=0x01;
2351 TestData[24]=0x00;
2352 TestData[25]=0x00;
2353 TestData[26]=0x00;
2354 TestData[27]=0x00;
2355 TestData[28]=0x00;
2356 TestData[29]=0x00;
2357 TestData[30]=0x00;
2358 #endif
2359
2360 //printf("3AAC:%x\n",XBYTE[0x3AAC]);
2361 //printf("UTMI(0x2c):%x\n",XBYTE[gUTMI4_BASE+0x2C]);
2362 #ifdef Issue_TestPacket
2363 TestData[0]=0x0;
2364 TestData[1]=0x0;
2365 TestData[2]=0x0;
2366 TestData[3]=0x0;
2367 TestData[4]=0x0;
2368 TestData[5]=0x0;
2369 TestData[6]=0x0;
2370 TestData[7]=0x0;
2371 TestData[8]=0x0;
2372 TestData[9]=0xaa;
2373 TestData[10]=0xaa;
2374 TestData[11]=0xaa;
2375 TestData[12]=0xaa;
2376 TestData[13]=0xaa;
2377 TestData[14]=0xaa;
2378 TestData[15]=0xaa;
2379 TestData[16]=0xaa;
2380 TestData[17]=0xee;
2381 TestData[18]=0xee;
2382 TestData[19]=0xee;
2383 TestData[20]=0xee;
2384 TestData[21]=0xee;
2385 TestData[22]=0xee;
2386 TestData[23]=0xee;
2387 TestData[24]=0xee;
2388 TestData[25]=0xfe;
2389 TestData[26]=0xff;
2390 TestData[27]=0xff;
2391 TestData[28]=0xff;
2392 TestData[29]=0xff;
2393 TestData[30]=0xff;
2394 TestData[31]=0xff;
2395 TestData[32]=0xff;
2396 TestData[33]=0xff;
2397 TestData[34]=0xff;
2398 TestData[35]=0xff;
2399 TestData[36]=0xff;
2400 TestData[37]=0x7f;
2401 TestData[38]=0xbf;
2402 TestData[39]=0xdf;
2403 TestData[40]=0xef;
2404 TestData[41]=0xf7;
2405 TestData[42]=0xfb;
2406 TestData[43]=0xfd;
2407 TestData[44]=0xfc;
2408 TestData[45]=0x7e;
2409 TestData[46]=0xbf;
2410 TestData[47]=0xdf;
2411 TestData[48]=0xfb;
2412 TestData[49]=0xfd;
2413 TestData[50]=0xfb;
2414 TestData[51]=0xfd;
2415 TestData[52]=0x7e;
2416
2417 for (i=53; i<128; i++)
2418 TestData[i]= 0;
2419
2420 #endif
2421
2422 USB_DACHE_FLUSH_Port4((U32)TestDataAddr, 128);
2423 //printf("[9]=0x%bx\n", TestData[9]);
2424
2425 //DbgPortEanble();
2426
2427 UHC4_ORXBYTE(0x50,0x14); //enable test packet and lookback
2428
2429 UTMI4_ORXBYTE(0x06,0x03); //TR/RX reset
2430 UTMI4_ANDXBYTE(0x06,0xFC);
2431
2432 while(1)
2433 {
2434 DMAAddress=(U32)VA2PA(TestData);
2435
2436 //set DMA memory base address
2437 UHC4_SETXBYTE(0x74,(U8)DMAAddress);
2438 UHC4_SETXBYTE(0x75,(U8)(DMAAddress>>8));
2439 UHC4_SETXBYTE(0x76,(U8)(DMAAddress>>16));
2440 UHC4_SETXBYTE(0x77,(U8)(DMAAddress>>24));
2441
2442 //printf("start check 2474=%2bx\n",XBYTE[0x2474]);
2443 //printf("start check 2475=%2bx\n",XBYTE[0x2475]);
2444 //printf("start check 2476=%2bx\n",XBYTE[0x2476]);
2445 //printf("start check 2477=%2bx\n",XBYTE[0x2477]);
2446
2447
2448 //set DMA data Length and type(memory to FIFO)
2449 #ifdef Issue_TestPacket
2450 datreg32 = 53;
2451 #else
2452 datreg32 = 31;
2453 #endif
2454
2455 datreg32 = datreg32 << 8;
2456 datreg32 = datreg32 | 0x02;
2457
2458 UHC4_SETXBYTE(0x70,(U8)datreg32);
2459 UHC4_SETXBYTE(0x71,(U8)(datreg32>>8));
2460 UHC4_SETXBYTE(0x72,(U8)(datreg32>>16));
2461 UHC4_SETXBYTE(0x73,(U8)(datreg32>>24));
2462
2463 UHC4_ORXBYTE(0x70,0x01);//DMA start
2464
2465
2466 //printf("start check 2470=%2bx\n",XBYTE[0x2470]);
2467 //printf("start check 2471=%2bx\n",XBYTE[0x2471]);
2468 //printf("start check 2472=%2bx\n",XBYTE[0x2472]);
2469 //printf("start check 2473=%2bx\n",XBYTE[0x2473]);
2470
2471 //MsOS_DelayTask(1000);
2472
2473 //printf("start check 2444=%2bx\n",XBYTE[0x2444]);
2474
2475 while(!(UHC4_READXBYTE(0x44) &0x08))
2476 {
2477 //printf("XBYTE[0x2444]=%2bx\n",XBYTE[0x2444]);
2478 //MsOS_DelayTask(10);//delay
2479 }
2480
2481 //printf("Dma success\n",0);
2482
2483 MsOS_DelayTask(10);
2484 }
2485
2486 }
2487 #endif
2488
2489 //#ifdef Enable_Issue_TestPacketByHW
2490 #if 1
MDrv_SendTestPacketByHW_Port4(void)2491 void MDrv_SendTestPacketByHW_Port4(void)
2492 {
2493 printf("Start test packet on port 3\n");
2494 UTMI4_SETXBYTE(0x14, 0x00);
2495 UTMI4_SETXBYTE(0x15, 0x06);
2496
2497 UTMI4_SETXBYTE(0x10, 0x38);
2498 UTMI4_SETXBYTE(0x11, 0x00);
2499
2500 UTMI4_SETXBYTE(0x32, 0xFE);
2501 UTMI4_SETXBYTE(0x33, 0x0B);
2502 }
2503 #endif
2504
IssueTestJ_Port4(void)2505 void IssueTestJ_Port4(void)
2506 {
2507 printf("TEST_J on Port3\n");
2508
2509 UTMI4_SETXBYTE(0x2c, 0x04);
2510 UTMI4_SETXBYTE(0x2d, 0x20);
2511 UTMI4_SETXBYTE(0x2e, 0x00);
2512 UTMI4_SETXBYTE(0x2f, 0x00);
2513
2514 USBC4_ORXBYTE(0, 0x02); //Enable UHC_RST
2515 MsOS_DelayTask(10);
2516 USBC4_ANDXBYTE(0, 0xFD);
2517
2518 //UHCREG(0x32)|=0x01;
2519 UHC4_ORXBYTE(0x32,0x01);
2520 MsOS_DelayTask(10);
2521 //UHCREG(0x32)&=0xfe;
2522 UHC4_ANDXBYTE(0x32,0xfe);
2523
2524 MsOS_DelayTask(10);
2525 UHC4_ORXBYTE(0x50,0x01); //enable test J
2526 }
2527
IssueTestK_Port4(void)2528 void IssueTestK_Port4(void)
2529 {
2530 printf("TEST_K on port3\n");
2531
2532 UTMI4_SETXBYTE(0x2c, 0x04);
2533 UTMI4_SETXBYTE(0x2d, 0x20);
2534 UTMI4_SETXBYTE(0x2e, 0x00);
2535 UTMI4_SETXBYTE(0x2f, 0x00);
2536
2537 USBC4_ORXBYTE(0, 0x02); //Enable UHC_RST
2538 MsOS_DelayTask(10);
2539 USBC4_ANDXBYTE(0, 0xFD);
2540
2541 //UHCREG(0x32)|=0x01;
2542 UHC4_ORXBYTE(0x32,0x01);
2543 MsOS_DelayTask(10);
2544 //UHCREG(0x32)&=0xfe;
2545 UHC4_ANDXBYTE(0x32,0xfe);
2546
2547 MsOS_DelayTask(10);
2548 UHC4_ORXBYTE(0x50,0x02); //enable test K
2549 }
2550
IssueSE0_Port4(void)2551 void IssueSE0_Port4(void)
2552 {
2553 printf("SE0 on port3\n");
2554
2555 UTMI4_SETXBYTE(0x06, 0xA0);
2556 UTMI4_SETXBYTE(0x07, 0x04);
2557
2558 MsOS_DelayTask(10);
2559 USBC4_ORXBYTE(0, 0x02); //Enable UHC_RST
2560 MsOS_DelayTask(10);
2561 USBC4_ANDXBYTE(0, 0xFD);
2562
2563 UHC4_ORXBYTE(0x32,0x01);
2564 MsOS_DelayTask(10);
2565 //UHCREG(0x32)&=0xfe;
2566 UHC4_ANDXBYTE(0x32,0xfe);
2567 }
2568
MDrv_UsbSendTestPacket_Port4(void)2569 void MDrv_UsbSendTestPacket_Port4(void)
2570 {
2571 drvUSBHost_TurnOffPowerDownMode_Port4();
2572 MsOS_DelayTask(500);
2573 Port3_IssueTestPacket_Initial();
2574 MDrv_SendTestPacketByHW_Port4();
2575 }
2576
MDrv_UsbSendSE0_Port4(void)2577 void MDrv_UsbSendSE0_Port4(void)
2578 {
2579 drvUSBHost_TurnOffPowerDownMode_Port4();
2580 MsOS_DelayTask(500);
2581 Port3_IssueTestPacket_Initial();
2582 IssueSE0_Port4();
2583 }
2584
MDrv_UsbSendTestJ_Port4(void)2585 void MDrv_UsbSendTestJ_Port4(void)
2586 {
2587 drvUSBHost_TurnOffPowerDownMode_Port4();
2588 MsOS_DelayTask(500);
2589 Port3_IssueTestPacket_Initial();
2590 IssueTestJ_Port4();
2591 }
2592
MDrv_UsbSendTestK_Port4(void)2593 void MDrv_UsbSendTestK_Port4(void)
2594 {
2595 drvUSBHost_TurnOffPowerDownMode_Port4();
2596 MsOS_DelayTask(500);
2597 Port3_IssueTestPacket_Initial();
2598 IssueTestK_Port4();
2599 }
2600
2601
MDrv_GetUsbDeviceType_Port4()2602 U8 MDrv_GetUsbDeviceType_Port4()
2603 {
2604 U8 u8DevType;
2605
2606 if ( (gUsbDeviceState_Port4==BAD_DEVICE) ||
2607 (gUsbDeviceState_Port4==NO_DEVICE) ||
2608 (gUsbDeviceState_Port4==POWER_SAVING) )
2609 return USB_INTERFACE_CLASS_NONE;
2610
2611 u8DevType = psAttachDevice_Port4->saCD[0].sInterface[0].bInterfaceClass;
2612
2613 return (u8DevType);
2614 }
2615
MDrv_GetUsbString_Port4(U8 u8StrID,S8 * pStrBuf,U8 u8BufLen)2616 void MDrv_GetUsbString_Port4(U8 u8StrID, S8 *pStrBuf, U8 u8BufLen)
2617 {
2618 U8 ii;
2619
2620 pStrBuf[0] = 0;
2621
2622 if (u8StrID == USB_STR_VENDOR)
2623 {
2624 for (ii=0; ii<u8BufLen; ii++)
2625 {
2626 pStrBuf[ii] = psAttachDevice_Port4->bStringManufacture[ii];
2627 if (pStrBuf[ii] == 0)
2628 break;
2629 }
2630 }
2631 else if (u8StrID == USB_STR_PRODUCT)
2632 {
2633 for (ii=0; ii<u8BufLen; ii++)
2634 {
2635 pStrBuf[ii] = psAttachDevice_Port4->bStringProduct[ii];
2636 if (pStrBuf[ii] == 0)
2637 break;
2638 }
2639 }
2640
2641 }
2642
MDrv_USBGetqTDTimeoutValue_Port4(void)2643 U8 MDrv_USBGetqTDTimeoutValue_Port4(void)
2644 {
2645 return gUsbTimeout_Port4;
2646 }
2647
MDrv_USBSetqTDTimeoutValue_Port4(U8 u8Value)2648 void MDrv_USBSetqTDTimeoutValue_Port4(U8 u8Value)
2649 {
2650 gUsbTimeout_Port4= u8Value;
2651 }
2652
MDrv_USBGetIORetryCount_Port4(void)2653 U8 MDrv_USBGetIORetryCount_Port4(void)
2654 {
2655 return gUsbRetryCount_Port4;
2656 }
2657
MDrv_USBSetIORetryCount_Port4(U8 u8Value)2658 void MDrv_USBSetIORetryCount_Port4(U8 u8Value)
2659 {
2660 gUsbRetryCount_Port4= u8Value;
2661 }
2662
MDrv_USBGetVIDPID_Port4(U16 * pVID,U16 * pPID)2663 void MDrv_USBGetVIDPID_Port4(U16 *pVID, U16 *pPID)
2664 {
2665 *pVID = ((U16) psAttachDevice_Port4->sDD.bVIDHighByte << 8 ) |
2666 (U16) psAttachDevice_Port4->sDD.bVIDLowByte;
2667
2668 *pPID = ((U16) psAttachDevice_Port4->sDD.bPIDHighByte<< 8 ) |
2669 (U16) psAttachDevice_Port4->sDD.bPIDLowByte;
2670 }
2671
MDrv_GetUsbStorString_Port4(U8 uLun,U8 u8StrID,S8 * pStrBuf,U8 u8BufLen)2672 void MDrv_GetUsbStorString_Port4(U8 uLun, U8 u8StrID, S8 *pStrBuf, U8 u8BufLen)
2673 {
2674 U8 ii;
2675
2676 pStrBuf[0] = 0;
2677
2678 if (u8StrID == USB_STR_VENDOR)
2679 {
2680 for (ii=0; ii<u8BufLen; ii++)
2681 {
2682 if (ii >= 8)
2683 break;
2684
2685 pStrBuf[ii] = Mass_stor_us1_port4.Mass_stor_device[uLun].u8VendorID[ii];
2686 }
2687 pStrBuf[ii] = 0; //Null terminal
2688 }
2689 else if (u8StrID == USB_STR_PRODUCT)
2690 {
2691 for (ii=0; ii<u8BufLen; ii++)
2692 {
2693 if (ii >= 16)
2694 break;
2695
2696 pStrBuf[ii] = Mass_stor_us1_port4.Mass_stor_device[uLun].u8ProductID[ii];
2697 }
2698 pStrBuf[ii] = 0; //Null terminal
2699 }
2700
2701 }
2702
MDrv_GetUsbDevInterfaceClass_Port4(void)2703 U8 MDrv_GetUsbDevInterfaceClass_Port4(void)
2704 {
2705 U8 u8DevType;
2706
2707 u8DevType = psAttachDevice_Port4->saCD[0].sInterface[0].bInterfaceClass;
2708
2709 return (u8DevType);
2710 }
2711 #endif //#if defined(MSOS_TYPE_NOS)
2712
2713