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 #if defined(MSOS_TYPE_NOS)
79 #include "../USBHostConfig_2.h"
80 #include "../../include/hal_arch.h"
81 #include "../../include/hal_cache.h"
82 #ifndef ATV_SERISE_USE
83 #include <stdio.h>
84 #endif
85 #include <string.h>
86 #ifndef ATV_SERISE_USE
87 #include "../../include/datatype.h"
88 #else
89 #include "UsbHostDataDef.h"
90 #endif
91 #include "../drvHostLib_2.h"
92 #include "../drvUsbMain_2.h"
93 #ifndef ATV_SERISE_USE
94
95 #endif
96 #ifdef ATV_SERISE_USE
97 #include "Board.h"
98 #include "common.h"
99 #include "uart.h"
100 #endif
101 #include "../../include/_drvUSB.h"
102 #include "../drvscsi_2.h"
103
104 #include "../../include/drvGlobal.h"
105
106 #include "MsCommon.h"
107 #include "MsIRQ.h"
108 #include "MsOS.h"
109
110 #define DEBUG_USB(msg) //msg
111 #define MINI_DEBUG2(x) //x;
112 #define HOSTLIB_MSG(x) MS_CRITICAL_MSG(x)
113
114 extern void msAPI_Timer_ResetWDT(void);
115 #if defined(CPU_TYPE_MIPS) || defined(CPU_TYPE_ARM)
116 extern void MAsm_CPU_Sync(void);
117 void USB_Chip_Read_Memory_Port2(void);
118 void USB_Chip_Flush_Memory_Port2(void);
119
120 #endif
121
122 code UINT8 OTGH_GETDESCRIPTOR_DEVICE_8_PORT2[] = {0x80,0x06,0x00,0x01,0x00,0x00,0x08,0x00};
123 code UINT8 OTGH_GETDESCRIPTOR_DEVICE_PORT2[] = {0x80,0x06,0x00,0x01,0x00,0x00,0x12,0x00};
124 code UINT8 OTGH_GETDESCRIPTOR_CONFIG_PORT2[] = {0x80,0x06,0x00,0x02,0x00,0x00,0x08,0x00};
125
126 code UINT8 OTGH_SETADDRESS_PORT2[] = {0x00,0x05,03,0x00,0x00,0x00,0x00,0x00};
127
128 code UINT8 OTGH_SETCONFIGURATION_PORT2[] = {0x00,0x09,0x01,0x00,0x00,0x00,0x00,0x00};
129 code UINT8 OTGH_GETDESCRIPTOR_STR_PORT2[] = {0x80,0x06,0x00,0x03,0x00,0x00,0x02,0x00}; //Get String Descriptor
130 //code UINT8 OTGH_SET_FEATURE_OTG[] = {0x00,0x03,0x03,0x00,0x00,0x00,0x00,0x00};
131 //code UINT8 OTGH_SETDESCRIPTOR_DEVICE[] = {0x00,0x07,0x00,0x01,0x00,0x00,0x12,0x00}; //Set Device Descriptor
132 //code UINT8 OTGH_GETDESCRIPTOR_STR70[] = {0x80,0x06,0x70,0x03,0x00,0x00,0x06,0x00}; //Get String80 Descriptor
133 //code UINT8 OTGH_SETDESCRIPTOR_STR70[] = {0x00,0x07,0x70,0x03,0x00,0x00,0x06,0x00}; //Set String80 Descriptor
134 //code UINT8 OTGH_GETDESCRIPTOR_STR80[] = {0x80,0x06,0x80,0x03,0x00,0x00,0x12,0x00}; //Get String80 Descriptor
135 //code UINT8 OTGH_SETDESCRIPTOR_STR80[] = {0x00,0x07,0x80,0x03,0x00,0x00,0x12,0x00}; //Set String80 Descriptor
136 //code UINT8 waIntervalMap[11]={1,2,4,8,16,32,64,128,256,512,1024};
137
138
139 //qHD_Structure xdata Host20_qHD_List_Control0_Port2 _at_ Host20_STRUCTURE_qHD_BASE_ADDRESS ;
140 //qHD_Structure xdata Host20_qHD_List_Control1_Port2 _at_ (Host20_STRUCTURE_qHD_BASE_ADDRESS+Host20_qHD_SIZE) ;
141 //qHD_Structure xdata Host20_qHD_List_Bulk0_Port2 _at_ (Host20_STRUCTURE_qHD_BASE_ADDRESS+2*Host20_qHD_SIZE);
142 //qHD_Structure xdata Host20_qHD_List_Bulk1_Port2 _at_ (Host20_STRUCTURE_qHD_BASE_ADDRESS+3*Host20_qHD_SIZE);
143 qHD_Structure Host20_qHD_List_Control0_Port2 __attribute__ ((aligned (32)));
144 qHD_Structure Host20_qHD_List_Control1_Port2 __attribute__ ((aligned (32)));
145 qHD_Structure Host20_qHD_List_Bulk0_Port2 __attribute__ ((aligned (32)));
146 qHD_Structure Host20_qHD_List_Bulk1_Port2 __attribute__ ((aligned (32)));
147
148 qHD_Structure *pHost20_qHD_List_Control0,*pHost20_qHD_List_Control1;
149 qHD_Structure *pHost20_qHD_List_Bulk0,*pHost20_qHD_List_Bulk1;
150
151 qHD_Structure *pHost20_qHD_List_Control0_Port2;
152 qHD_Structure *pHost20_qHD_List_Control1_Port2;
153 qHD_Structure *pHost20_qHD_List_Bulk0_Port2;
154 qHD_Structure *pHost20_qHD_List_Bulk1_Port2;
155 UINT8 xdata Host20_qTD_Manage_Port2[Host20_qTD_MAX]; //1=>Free 2=>used
156 //Host20_Attach_Device_Structure xdata sAttachDevice_port2 _at_ Host20_Attach_Device_DATA;
157 Host20_Attach_Device_Structure sAttachDevice_Port2 __attribute__ ((aligned (8)));
158 Host20_Attach_Device_Structure *psAttachDevice_Port2 = (Host20_Attach_Device_Structure*) &sAttachDevice_Port2;
159 BOOLEAN FirstBulkOutPort2,FirstBulkInPort2;
160 //Host20_Attach_Device_Structure xdata *psDevice_AP;
161
162 U8 *pUsbCtrlBuf_Port2;
163 U8 UsbCtrlBuf_Port2[CONTROL_DMA_BUF_LEN] __attribute__ ((aligned (4096)));
164 UINT8 pUsbData_Port2[CONTROL_BUF_LEN] __attribute__ ((aligned (16))) ;
165 U8 QtdBuf_Port2[Host20_qTD_SIZE*Host20_qTD_MAX+0x20] __attribute__ ((aligned (32)));
166 U8 *Host20_STRUCTURE_qTD_BASE_ADDRESS_Port2,*Host20_STRUCTURE_qHD_BASE_ADDRESS_Port2;
167 U8 *qTD_Base_Buf_Port2;
168
169 UINT8 gSpeed_Port2;
170 U16 TotalBytes_Port2;
171 //volatile UINT32 gwLastqTDSendOK;
172 extern U8 gUsbTimeout_Port2;
173 extern U8 gUsbStatus_Port2;
174 U8 DataToggleBackupPort2;
175 extern U8 RecoveryFlag_Port2;
176 //extern BOOLEAN gDeviceFatalError;
177 extern U8 gUsbDeviceState_Port2;
178 extern U8 NowIsHubPort2;
179 extern U16 MDrv_USBGetChipID_Port2(void);
180 extern U8 MDrv_USBGetChipVersion_Port2(void);
181
182 U8 usb_temp_buf_Port2[Scsi_Max_Transfer_Len] __attribute__ ((aligned (128)));
183
184 #define USB_DMA_SIGNATURE1 0x55661234
185
186 void EnterTestMode_Port2(void);
187
188 //************************************************************************************************************
189 //************************************************************************************************************
190 // *** Group-1:Main Function ***
191 //*************************************************************************************************************
192 //************************************************************************************************************
mwHost20Port_Port2(int bOffset)193 unsigned char mwHost20Port_Port2(int bOffset)
194 {
195 return UHC2_READXBYTE((U8) bOffset);
196 }
mwHost20Port_wr_Port2(int bOffset,int value)197 void mwHost20Port_wr_Port2(int bOffset,int value)
198 {
199 UHC2_SETXBYTE((U8) bOffset, (U8) value);
200 }
201
mwHost20Bit_Rd_Port2(int bByte,int wBitNum)202 int mwHost20Bit_Rd_Port2(int bByte,int wBitNum)
203 {
204 return (mwHost20Port_Port2(bByte)&wBitNum);
205 }
mwHost20Bit_Set_Port2(int bByte,int wBitNum)206 void mwHost20Bit_Set_Port2(int bByte,int wBitNum)
207 {
208 U8 temp;
209 temp=mwHost20Port_Port2(bByte);
210 temp|=wBitNum;
211 mwHost20Port_wr_Port2(bByte,temp);
212
213 }
mwHost20Bit_Clr_Port2(int bByte,int wBitNum)214 void mwHost20Bit_Clr_Port2(int bByte,int wBitNum)
215 {
216 U8 temp;
217 temp=mwHost20Port_Port2(bByte);
218 temp&=~wBitNum;
219
220 mwHost20Port_wr_Port2(bByte,temp);
221 }
222
223 //====================================================================
224 // * Function Name: flib_OTGH_Init_Port2
225 // * Description: Init the Host HW and prepare the ED/TD
226 // <1>.Init All the Data Structure
227 // <1.1>.Build control list
228 // <1.2>.Build Bulk list
229 // <1.3>.Build Interrupt list
230 // <1.4>.Build ISO list (Reserved)
231 // <2>.Reset the chip
232 // <3>.Set HW register
233 // <3.1>.Enable FIFO-Enable(0x100->Bit5) & FPGA-Mode-Half-Speed (0x100->Bit1)
234 // <3.2>.Enable interrupts
235 // <3.3>.Periodic List Base Address register
236 // <3.4>.USBCMD (Interrupt/Threshod/Frame List/Run-Stop)
237 //
238 // * Input: wTimeWaitForConnect_ms:The time of waitting for connecting
239 // * OutPut: 0:Device do not connect
240 // 1:Host init ok
241 // 2:Bus Rest Fail
242 //====================================================================
243 #ifdef ATV_SERISE_USE
244 extern U8 jpCVBS5_Get_Device_Define(void);
245 #endif
246
247 #define wTimeWaitForConnect_ms 1500
248
flib_OTGH_Init_Port2(UINT8 wForDevice_B)249 UINT8 flib_OTGH_Init_Port2(UINT8 wForDevice_B)
250 {
251 UINT8 wValue;
252 UINT16 wTimer_ms;
253
254 MsOS_DelayTask(2);//2ms
255 UTMI2_ANDXBYTE(0,0xfe);
256 MsOS_DelayTask(2);//2ms
257
258 //<1>.Waiting for the Device connect
259 #if 1
260 if (wForDevice_B==0) {
261 mbHost20_USBCMD_HCReset_Set(); //host controller reset
262 while(mbHost20_USBCMD_HCReset_Rd()>0);
263 }
264 #endif
265
266 if (MDrv_USBGetChipID_Port2()==CHIPID_EUCLID) // Euclid
267 {
268 mwHost20Bit_Set_Port2(0x81,(BIT6|BIT7));
269 }
270
271 wValue=0;
272 wTimer_ms=0;
273 do {
274 wValue=mwHost20_PORTSC_ConnectStatus_Rd();
275 //printf("wValue:%02bx\n",wValue);
276
277 if (wValue==0) {
278 MsOS_DelayTask(1);//10, wait 1 ms
279 wTimer_ms++;
280 }
281 //if (mwHost20_PORTSC_ConnectStatus_Rd()==0) return 0;
282 if (wTimer_ms>wTimeWaitForConnect_ms) // Case1:Waiting for 10 sec=10000
283 { // Case2:Waiting for 100 ms =100
284 DEBUG_USB(printf("??? Waiting for Peripheral Connecting Fail...\n"));
285 return (0);
286 }
287 }while(wValue==0);
288
289 //mwHost20_Misc_EOF1Time_Set(Host20_EOF1Time);
290 //printf("34:%02bx\n",XBYTE[0x2434]);
291 //<2>.Init All the Data Structure & write Base Address register
292 flib_Host20_InitStructure_Port2();
293
294 //Write Base Address to Register
295 // Host20_STRUCTURE_BASE_ADDRESS
296 mwHost20_CurrentAsynchronousAddr_Set(VirtoPhyAddr((U32)Host20_STRUCTURE_qHD_BASE_ADDRESS_Port2));
297
298 //mwHost20_CurrentAsynchronousAddr_Set(VirtoPhyAddr((U16)&Host20_qHD_List_Work));
299 // printf("qhead:%x\n",VirtoPhyAddr(Host20_STRUCTURE_qHD_BASE_ADDRESS));
300
301 //<4>.Enable interrupts
302 mwHost20_USBINTR_Set( HOST20_USBINTR_SystemError |
303
304 HOST20_USBINTR_IntOnAsyncAdvance |
305 HOST20_USBINTR_USBError |
306 HOST20_USBINTR_CompletionOfTransaction);
307
308 #ifdef ATV_SERISE_USE
309 if(jpCVBS5_Get_Device_Define())
310 UHC_XBYTE(0x40)|=0x80;//force enter FSmode
311 #endif
312
313 #ifdef ENABLE_FORCE_FS
314 UHC_XBYTE(0x40)|=0x80;//force enter FSmode
315 #endif
316
317 if (wForDevice_B==0) {
318 if (flib_Host20_PortBusReset_Port2()>0)
319 return(2);
320 }
321
322 return (1);
323 }
USB_Write_REG32_Port2(UINT8 addr,UINT32 val)324 void USB_Write_REG32_Port2(UINT8 addr,UINT32 val)
325 {
326 UHC2_SETXBYTE(addr, (U8) val & 0xFF);
327 UHC2_SETXBYTE(addr+1, (U8) (val>>8) & 0xFF);
328 UHC2_SETXBYTE(addr+2, (U8) (val>>16) & 0xFF);
329 UHC2_SETXBYTE(addr+3, (U8) (val>>24) & 0xFF);
330 }
331
332 //====================================================================
333 // * Function Name: flib_Host20_Close_Port2
334 // * Description:
335 // <1>.Suspend Host
336 // <2>.Disable the interrupt
337 // <3>.Clear Interrupt Status
338 // <4>.Issue HW Reset
339 // <5>.Free the Allocated Memory
340 // * Input:
341 // * OutPut:
342 //====================================================================
flib_Host20_Close_Port2(void)343 UINT8 flib_Host20_Close_Port2(void)
344 {
345 #if 0 //We don't need to suspend the bus.
346 UINT32 wTemp;
347
348 if (mwHost20_USBINTR_Rd()>0) {
349 //<1>.Suspend Host
350 flib_Host20_Suspend_Port2();
351
352 //<2>.Disable the interrupt
353 mwHost20_USBINTR_Set(0);
354
355 //<3>.Clear Interrupt Status
356 wTemp=mwHost20_USBSTS_Rd();
357 wTemp=wTemp&0x0000003F;
358 mwHost20_USBSTS_Set(wTemp);
359 }
360 #endif
361
362 return (1);
363 }
364
365 //====================================================================
366 // * Function Name: flib_Host20_StopRun_Setting_Port2
367 // * Description:
368 // * Input:
369 // * OutPut:
370 //====================================================================
flib_Host20_StopRun_Setting_Port2(UINT8 bOption)371 void flib_Host20_StopRun_Setting_Port2(UINT8 bOption)
372 {
373 if (bOption==HOST20_Enable) {
374 if (mbHost20_USBCMD_RunStop_Rd()>0)
375 return;
376
377 mbHost20_USBCMD_RunStop_Set();
378
379 while(mbHost20_USBCMD_RunStop_Rd()==0);
380 }
381 else {
382 if (mbHost20_USBCMD_RunStop_Rd()==0)
383 return;
384
385 mbHost20_USBCMD_RunStop_Clr();
386
387 while(mbHost20_USBCMD_RunStop_Rd()>0);
388 }
389
390 }
391 #if 0
392 //====================================================================
393 // * Function Name: flib_Host20_Asynchronous_Setting
394 // * Description:
395 // * Input:
396 // * OutPut:
397 //====================================================================
398 void flib_Host20_Asynchronous_Setting(UINT8 bOption)
399 {
400 if (bOption==HOST20_Enable) {
401 if (mwHost20_USBSTS_AsynchronousStatus_Rd()>0)
402 return;
403
404 mbHost20_USBCMD_AsynchronousEnable_Set();
405
406 while(mwHost20_USBSTS_AsynchronousStatus_Rd()==0);
407 }
408 else{
409 if (mwHost20_USBSTS_AsynchronousStatus_Rd()==0)
410 return;
411
412 mbHost20_USBCMD_AsynchronousEnable_Clr();
413
414 while(mwHost20_USBSTS_AsynchronousStatus_Rd()>0);
415 }
416
417 }
418 #endif
419 //void _noop_()
420 //{
421 // int i=0;
422 //}
423 //====================================================================
424 // * Function Name: flib_Host20_PortBusReset_Port2
425 // * Description:
426 // <1>.Waiting for HCHalted=0
427 // <2>.Write PortEnable=0(Reserved for Faraday-IP)
428 // <3>.Write PortReset=0
429 // <4>.Wait time
430 // <5>.Write PortReset=0
431 // <6>.Waiting for IRS->PortChangeDetect
432 // * Input:
433 // * OutPut:
434 //====================================================================
flib_Host20_PortBusReset_Port2(void)435 UINT8 flib_Host20_PortBusReset_Port2(void)
436 {
437 UINT8 bExitLoop;
438 //UINT8 ttt;
439 UINT32 wTmp;
440 //flib_Host20_ForceSpeed(0);
441
442 //<1>.Disable RunStop
443 // bResetDuringRun=0;
444
445 //printf("disable run\n");
446 //if (mbHost20_USBCMD_RunStop_Rd()>0)
447 flib_Host20_StopRun_Setting_Port2(HOST20_Disable);
448 //printf("0x10 ->%02bx \n",XBYTE[0x2410]);
449
450 if ( (MDrv_USBGetChipID_Port2() == CHIPID_NEPTUNE) ||
451 (MDrv_USBGetChipID_Port2() == CHIPID_ERIS) ||
452 (MDrv_USBGetChipID_Port2() == CHIPID_TITANIA) ||
453 (MDrv_USBGetChipID_Port2() == CHIPID_PLUTO) ||
454 (MDrv_USBGetChipID_Port2() == CHIPID_TRITON) ||
455 (MDrv_USBGetChipID_Port2() == CHIPID_TITANIA2) )
456 {
457 UTMI2_ANDXBYTE(0x2c,0x3E);
458 UTMI2_ANDXBYTE(0x2d,~0x03);
459 UTMI2_ANDXBYTE(0x2f,~0x4A);
460 UTMI2_SETXBYTE(0x2a,0xd0);
461 }
462 else //for T3 later
463 {
464 UTMI2_SETXBYTE(0x2c,0x10);
465 UTMI2_SETXBYTE(0x2d,0);
466 UTMI2_SETXBYTE(0x2e,0);
467 UTMI2_SETXBYTE(0x2f,0);
468 UTMI2_SETXBYTE(0x2a,0x80);//Chirp K detection level: 0x80 => 400mv, 0x20 => 575mv
469 }
470
471 //<2>.Write PortReset=0
472 mwHost20_PORTSC_PortReset_Set();
473
474
475 //<3>.Wait time=>55ms
476 //flib_Host20_TimerEnable(55);
477 //MsOS_DelayTask(100);
478 MsOS_DelayTask(80);
479 if ( (MDrv_USBGetChipID_Port2() == CHIPID_EINSTEIN) ||
480 (MDrv_USBGetChipID_Port2() == CHIPID_NAPOLI) )
481 UTMI2_SETXBYTE(0x2a,0x60); // disconnect level 625 mV for 28 nm process
482 else
483 UTMI2_SETXBYTE(0x2a,0);
484 MsOS_DelayTask(20);
485 //flib_Debug_LED_Off_All();; //GPIO-High
486
487 mwHost20_PORTSC_PortReset_Clr();
488
489 if ( (MDrv_USBGetChipID_Port2() == CHIPID_NEPTUNE) ||
490 (MDrv_USBGetChipID_Port2() == CHIPID_ERIS) ||
491 (MDrv_USBGetChipID_Port2() == CHIPID_TITANIA) ||
492 (MDrv_USBGetChipID_Port2() == CHIPID_PLUTO) ||
493 (MDrv_USBGetChipID_Port2() == CHIPID_TRITON) ||
494 (MDrv_USBGetChipID_Port2() == CHIPID_TITANIA2) )
495 {
496 UTMI2_ORXBYTE(0x2c,0xC1);
497 UTMI2_ORXBYTE(0x2d,0x03);
498 UTMI2_ORXBYTE(0x2f,0x4a);
499 }
500 else if ((MDrv_USBGetChipID_Port2() == CHIPID_TITANIA3) ||
501 (MDrv_USBGetChipID_Port2() == CHIPID_TITANIA4) ||
502 (MDrv_USBGetChipID_Port2() == CHIPID_TITANIA7) ||
503 (MDrv_USBGetChipID_Port2() == CHIPID_TITANIA8) ||
504 (MDrv_USBGetChipID_Port2() == CHIPID_TITANIA9) ||
505 (MDrv_USBGetChipID_Port2() == CHIPID_TITANIA12) ||
506 (MDrv_USBGetChipID_Port2() == CHIPID_TITANIA13) ||
507 (MDrv_USBGetChipID_Port2() == CHIPID_JANUS) ||
508 (MDrv_USBGetChipID_Port2() == CHIPID_JANUS2) ||
509 (MDrv_USBGetChipID_Port2() == CHIPID_AMBER6) )
510 {
511 UTMI2_SETXBYTE(0x2c,0x10);
512 UTMI2_SETXBYTE(0x2d,0x02);
513 UTMI2_SETXBYTE(0x2f,0x81);
514 }
515 else if ((MDrv_USBGetChipID_Port2()==CHIPID_AMBER1) ||
516 (MDrv_USBGetChipID_Port2()==CHIPID_AMBER5) ||
517 (MDrv_USBGetChipID_Port2()==CHIPID_AMBER7) ||
518 (MDrv_USBGetChipID_Port2()==CHIPID_AMBER3) ||
519 (MDrv_USBGetChipID_Port2()==CHIPID_AMETHYST) ||
520 (MDrv_USBGetChipID_Port2()==CHIPID_EAGLE))
521 {
522 //for Amber1 later 40nm before Agate
523 UTMI2_SETXBYTE(0x2c,0x98);
524 UTMI2_SETXBYTE(0x2d,0x02);
525 UTMI2_SETXBYTE(0x2e,0x10);
526 UTMI2_SETXBYTE(0x2f,0x01);
527 }
528 else if ( (MDrv_USBGetChipID_Port2() == CHIPID_EDISON) ||
529 (MDrv_USBGetChipID_Port2() == CHIPID_EIFFEL) )
530 {
531 //for Agate later 40nm, same as 55nm setting2
532 UTMI2_SETXBYTE(0x2c,0x90);
533 UTMI2_SETXBYTE(0x2d,0x02);
534 UTMI2_SETXBYTE(0x2f,0x81);
535 }
536 else //for Agate later 40nm, same as 55nm setting1
537 {
538 UTMI2_SETXBYTE(0x2c,0x10);
539 UTMI2_SETXBYTE(0x2d,0x02);
540 UTMI2_SETXBYTE(0x2f,0x81);
541 }
542 //printf("Host Speed:%02bx\n",mwOTG20_Control_HOST_SPD_TYP_Rd());
543
544 //<5>.Waiting for IRS->PortChangeDetect
545 //printf("wait reset\n");
546 #if 1
547 bExitLoop=0;
548 wTmp=0;
549
550 do {
551 if (mwHost20_PORTSC_PortReset_Rd()==0)
552 bExitLoop=1;
553 //USBDELAY(100);
554 //if (mwHost20_PORTSC_ConnectStatus_Rd()==0) return 1;
555 wTmp++;
556 if (wTmp>20000) {
557 DEBUG_USB(printf("??? Error waiting for Bus Reset Fail...==> Reset HW Control\n"));
558 mbHost20_USBCMD_HCReset_Set();
559 //while(mbHost20_USBCMD_HCReset_Rd()==1);
560 return (1);
561 }
562 }
563 while(bExitLoop==0);
564 #endif
565 //<6>.Enable RunStop Bit
566 #if 0
567 if (mwHost20_PORTSC_ForceSuspend_Rd())
568 {
569 printf("port suspend\n");
570 mwHost20_PORTSC_ForceResume_Set(); //force resume
571 USBDELAY(14);
572 mwHost20_PORTSC_ForceResume_Clr();
573 }
574 #endif
575 //mwHost20_PORTSC_ConnectChange_Set(); //clear connection change bit
576
577 UTMI2_ORXBYTE(0x06,0x03); //reset UTMI
578 UTMI2_ANDXBYTE(0x06,0xfc);
579 flib_Host20_StopRun_Setting_Port2(HOST20_Enable);
580
581 //flib_Debug_LED_On_All(); //GPIO-Low
582 MsOS_DelayTask(50);
583
584 //<7>.Detect Speed
585 gSpeed_Port2= mwOTG20_Control_HOST_SPD_TYP_Rd();
586 //ttt=mwOTG20_Control_HOST_SPD_TYP_Rd();
587 HOSTLIB_MSG(printf("\r\n Host type:%x", gSpeed_Port2));
588 //<8>.Delay 20 ms
589 //flib_Host20_TimerEnable(5);//After Reset => Host must reserve 20 ms for Device init
590
591 if (gSpeed_Port2==2) //high speed
592 {
593 UTMI2_ORXBYTE(9,0x80); //HS rx robust enable
594 mwHost20_Misc_EOF1Time_Set(3);
595 gUsbDeviceState_Port2=USB20_DEVICE;
596 }
597 else //full speed
598 {
599 UTMI2_ANDXBYTE(9,0x7f);
600 mwHost20_Misc_EOF1Time_Set(2);
601 gUsbDeviceState_Port2=USB11_DEVICE;
602 }
603
604 flib_Host20_QHD_Control_Init_Port2();
605 //printf("return 1");
606 #if 0 //Try to support HID class
607 if(gSpeed_Port2==0x01)
608 {
609 MINI_DEBUG2(printf("Port2 Low speed device\n"));
610 return (2); //not support Low Speed device
611 }
612 #endif
613 return (0);
614 }
615
616 //====================================================================
617 // * Function Name: flib_Host20_Suspend_Port2
618 // * Description:
619 // <1>.Make sure PortEnable=1
620 // <2>.Write PORTSC->Suspend=1
621 // <3>.Waiting for the ISR->PORTSC->Suspend=1
622 // * Input:
623 // * OutPut: 0:OK
624 // 1:Fail
625 //====================================================================
flib_Host20_Suspend_Port2(void)626 void flib_Host20_Suspend_Port2(void)
627 {
628 #if 0
629 if (mbHost20_USBCMD_RunStop_Rd()==0)
630 return(1);
631
632 //<1>.Make sure PortEnable=1
633 if (mwHost20_PORTSC_EnableDisable_Rd()==0)
634 return(1);
635 #endif
636 //<2>.Write PORTSC->Suspend=1
637 flib_Host20_StopRun_Setting_Port2(HOST20_Disable);//For Faraday HW request
638
639 //<3>.Write PORTSC->Suspend=1
640 mwHost20_PORTSC_ForceSuspend_Set();
641
642 //<4>.Waiting for the ISR->PORTSC->Suspend=1
643 #if 0
644 flib_Host20_TimerEnable_UnLock(1);//1sec
645 bExitFlag=0;
646
647 do {
648 if (mwHost20_PORTSC_ForceSuspend_Rd()>0)
649 bExitFlag=1;
650
651 if (gwOTG_Timer_Counter>5) {
652 bExitFlag=1;
653 printf(">>> Fail => Time Out for Waiting ForceSuspend...\n");
654 }
655 }
656 while(bExitFlag==0);
657 #else
658 while(mwHost20_PORTSC_ForceSuspend_Rd()==0);
659 #endif
660
661 }
662
663
664
665
666 //====================================================================
667 // * Function Name: flib_Host20_Control_Command_Request_Port2
668 // * Description:
669 // * Input: none
670 // * OutPut: none
671 //====================================================================
flib_Host20_Control_Command_Request_Port2(Host20_Control_Command_Structure * pbCMD,UINT8 bmRequestType_Temp,UINT8 bRequest_Temp,UINT16 wValue_Temp,UINT16 wIndex_Temp,UINT16 wLength_Temp)672 void flib_Host20_Control_Command_Request_Port2(Host20_Control_Command_Structure *pbCMD,UINT8 bmRequestType_Temp,UINT8 bRequest_Temp,UINT16 wValue_Temp,UINT16 wIndex_Temp,UINT16 wLength_Temp)
673 {
674 UINT8 i;
675 UINT8 *pbTemp;
676
677 pbTemp=(UINT8*)pbCMD;
678 for (i=0;i<8;i++)
679 *pbTemp++=0x00;
680 pbCMD->bmRequestType=bmRequestType_Temp; //Byte-0:In/Standard/Device
681 pbCMD->bRequest=bRequest_Temp;
682
683 pbCMD->wValueLow=(UINT8)wValue_Temp;
684 pbCMD->wValueHigh=(UINT8)(wValue_Temp>>8);
685
686 pbCMD->wIndexLow=(UINT8)wIndex_Temp;
687 pbCMD->wIndexHigh=(UINT8)(wIndex_Temp>>8);
688
689 pbCMD->wLengthLow=(UINT8)wLength_Temp;
690 pbCMD->wLengthHigh=(UINT8)(wLength_Temp>>8);
691 }
692 #if 0
693 void FillBufferArray_Port2(qTD_Structure xdata *spTempqTD, UINT16 bpDataPage)
694 {
695
696 U32 temp;
697 temp=VirtoPhyAddr(bpDataPage);
698 spTempqTD->ArrayBufferPointer[0].Byte1=(UINT8)(temp>>8)&0xf0;
699 spTempqTD->ArrayBufferPointer[0].Byte2=(UINT8)(temp>>16)&0xff;
700 spTempqTD->ArrayBufferPointer[0].Byte3=(UINT8)(temp>>24)&0xff;
701
702 }
703 #endif
704
705 void Dump_QTD_Port2(UINT16 addr);
706 void Dump_Data_Port2(UINT16 addr,UINT16 sz);
707 #if 0
708 void Dump_Data_Port2(UINT16 addr,UINT16 sz)
709 {
710 UINT16 i;
711 printf("addr:%x -> \r\n",addr);
712 for (i=0; i < sz ; i++)
713 printf("%02bx ",*(unsigned char volatile xdata *)(addr+i));
714 }
715 #endif
716
717 #ifdef ENABLE_CBI_HOST
flib_Host20_Issue_Control_CBI_Port2(UINT8 * pbCmd,UINT16 hwDataSize,UINT8 * pbData)718 UINT8 flib_Host20_Issue_Control_CBI_Port2(UINT8* pbCmd,UINT16 hwDataSize,UINT8* pbData)
719 {
720 qTD_Structure *spTempqTD;
721 // U32 bpDataPage;
722 U8 bReturnValue;
723 // U8 i;
724 qHD_Structure *qh_ptr;
725
726 qh_ptr=pHost20_qHD_List_Control1_Port2;
727
728 //<0>.Allocate qTD & Data Buffer
729 spTempqTD=flib_Host20_GetStructure_Port2(Host20_MEM_TYPE_qTD);//0=>qTD
730 // bpDataPage=sAttachDevice.bDataBuffer; //2//2k buffer
731
732 //<2.1>.Setup packet
733 //<A>.Fill qTD
734 spTempqTD->bPID=HOST20_qTD_PID_SETUP; //Bit8~9
735 spTempqTD->bTotalBytes=8; //Bit16~30
736
737 spTempqTD->bDataToggle=0; //Bit31
738 // FillBufferArray(spTempqTD, bpDataPage);
739 memcpy(pUsbCtrlBuf_Port2,pbCmd,8);
740
741 spTempqTD->ArrayBufferPointer_Word[0]=VirtoPhyAddr((U32)pUsbCtrlBuf_Port2);
742
743 // printf("bpDataPage:%x\n",bpDataPage);
744 // memcpy((U8 *)bpDataPage,pbCmd,8);
745
746 //<B>.Send qTD
747 // Dump_QTD(spTempqTD);
748
749 // Dump_Data(0x2400,0x50);
750 // bReturnValue=flib_Host20_Send_qTD(spTempqTD ,psHost20_qHD_List_Control[bEdNum],5);
751 bReturnValue=flib_Host20_Send_qTD_Port2(spTempqTD ,qh_ptr,gUsbTimeout_Port2);
752
753 if (bReturnValue>0)
754 goto exit_issue_control;
755
756 //<4.2>.Out packet
757 //<A>.Fill qTD
758 spTempqTD=flib_Host20_GetStructure_Port2(Host20_MEM_TYPE_qTD);//0=>qTD
759 spTempqTD->bPID=HOST20_qTD_PID_OUT; //Bit8~9
760 spTempqTD->bTotalBytes=hwDataSize; //Bit16~30
761 spTempqTD->bDataToggle=1; //Bit31
762 spTempqTD->ArrayBufferPointer_Word[0]=VirtoPhyAddr((U32)pUsbCtrlBuf_Port2);
763 // FillBufferArray(spTempqTD, bpDataPage);
764
765 memcpy(pUsbCtrlBuf_Port2,pbData,hwDataSize);
766
767 //<B>.Send qTD
768 // bReturnValue=flib_Host20_Send_qTD(spTempqTD ,psHost20_qHD_List_Control[bEdNum],5);
769 bReturnValue=flib_Host20_Send_qTD_Port2(spTempqTD ,qh_ptr,gUsbTimeout_Port2);
770
771 if (bReturnValue>0)
772 goto exit_issue_control;
773
774 //<4.3>.In packet
775 //<A>.Fill qTD
776 spTempqTD=flib_Host20_GetStructure_Port2(Host20_MEM_TYPE_qTD);//0=>qTD
777 spTempqTD->bPID=HOST20_qTD_PID_IN; //Bit8~9
778 spTempqTD->bTotalBytes=0; //Bit16~30
779 spTempqTD->bDataToggle=1; //Bit31
780
781 //<B>.Send qTD
782 // bReturnValue=flib_Host20_Send_qTD(spTempqTD ,psHost20_qHD_List_Control[bEdNum],5);
783 bReturnValue=flib_Host20_Send_qTD_Port2(spTempqTD ,qh_ptr,gUsbTimeout_Port2);
784
785 if (bReturnValue>0)
786 goto exit_issue_control;
787
788 return (0);
789 exit_issue_control:
790
791 return (bReturnValue);
792 }
793 #endif
794
795 //====================================================================
796 //For Control-Single qTD// * Function Name: flib_Host20_Issue_Control_Port2
797 // * Description:
798 // <1>.Analysis the Controller Command => 3 type
799 // <2>.Case-1:"Setup/In/Out' Format..."
800 // (get status/get descriptor/get configuration/get interface)
801 // <3>.Case-2:'Setup/In' Format... => Faraday Driver will not need
802 // (clear feature/set feature/set address/set Configuration/set interface )
803 // <4>.Case-3:'Setup/Out/In'
804 // (set descriptor)
805 // * Input:
806 // * OutPut: 0: OK
807 // X:>0 => Fail
808 //====================================================================
flib_Host20_Issue_Control_Port2(U8 bEdNum,U8 * pbCmd,U16 hwDataSize,U8 * pbData)809 U8 flib_Host20_Issue_Control_Port2(U8 bEdNum,U8* pbCmd,U16 hwDataSize,U8* pbData)
810 {
811 qTD_Structure *spTempqTD;
812 //U32 bpDataPage;
813 U8 bReturnValue;
814 //U8 i;
815 qHD_Structure *qh_ptr;
816 U32 *dnaptr;
817 U32 dwTimes;
818
819 if (bEdNum==0)
820 qh_ptr=pHost20_qHD_List_Control0_Port2;
821 else
822 qh_ptr=pHost20_qHD_List_Control1_Port2;
823
824 //<0>.Allocate qTD & Data Buffer
825 spTempqTD=(qTD_Structure *) flib_Host20_GetStructure_Port2(Host20_MEM_TYPE_qTD);//0=>qTD
826 //bpDataPage=psAttachDevice_Port2->bDataBuffer; //2//2k buffer
827
828 //<2.1>.Setup packet
829 //<A>.Fill qTD
830 spTempqTD->bPID=HOST20_qTD_PID_SETUP; //Bit8~9
831 spTempqTD->bTotalBytes=8; //Bit16~30
832
833 spTempqTD->bDataToggle=0; //Bit31
834 //FillBufferArray_Port2(spTempqTD, bpDataPage);
835 memcpy(pUsbCtrlBuf_Port2,pbCmd,8);
836
837 spTempqTD->ArrayBufferPointer_Word[0]=VirtoPhyAddr((U32)pUsbCtrlBuf_Port2);
838
839 //printf("bpDataPage:%x\n",bpDataPage);
840 //memcpy((U8 xdata *)bpDataPage,pbCmd,8);
841
842 #if 1
843 //<B>.Send qTD
844 //Dump_QTD_Port2(spTempqTD);
845
846 //Dump_Data(0x2400,0x50);
847 //bReturnValue=flib_Host20_Send_qTD_Port2(spTempqTD ,psHost20_qHD_List_Control[bEdNum],5);
848 bReturnValue=flib_Host20_Send_qTD_Port2(spTempqTD ,qh_ptr,gUsbTimeout_Port2);
849
850 if (bReturnValue>0)
851 goto exit_issue_control;
852
853 //printf("c3");
854
855 //<1>.Analysis the Controller Command
856 switch (*(pbCmd+1)) { // by Standard Request codes
857 // <2>.Case-1:"Setup/In/Out' Format..."
858 case 0: // get status
859 case 6: // get descriptor
860 case 8: // get configuration
861 case 10: // get interface
862 case 0xfe: //get Max Lun
863 //<2.2>.In packet
864
865 //<A>.Fill qTD
866 spTempqTD=(qTD_Structure *)flib_Host20_GetStructure_Port2(Host20_MEM_TYPE_qTD);//0=>qTD
867 spTempqTD->bPID=HOST20_qTD_PID_IN; //Bit8~9
868 spTempqTD->bTotalBytes=hwDataSize; //Bit16~30
869
870 spTempqTD->bDataToggle=1; //Bit31
871
872 //spTempqTD->ArrayBufferPointer_Word[0]=VirtoPhyAddr(bpDataPage);
873 //FillBufferArray_Port2(spTempqTD, bpDataPage);
874 spTempqTD->ArrayBufferPointer_Word[0]=VirtoPhyAddr((U32)pUsbCtrlBuf_Port2);
875
876 //MAKE THE SIGNATURE
877 dnaptr= (U32*)(U32)pUsbCtrlBuf_Port2;
878 if (hwDataSize>3)
879 {
880 dnaptr+=(hwDataSize/4) - 1;
881 *dnaptr=USB_DMA_SIGNATURE1;
882 }
883
884 //<B>.Send qTD
885 //bReturnValue=flib_Host20_Send_qTD_Port2(spTempqTD ,psHost20_qHD_List_Control[bEdNum],5);
886 bReturnValue=flib_Host20_Send_qTD_Port2(spTempqTD ,qh_ptr,gUsbTimeout_Port2);
887 if (bReturnValue>0)
888 goto exit_issue_control;
889 //printf("c4");
890
891 if (((hwDataSize-TotalBytes_Port2)==hwDataSize) && (hwDataSize>3))
892 {
893 dwTimes=MsOS_GetSystemTime();
894 while (*dnaptr==USB_DMA_SIGNATURE1)
895 {
896 if ((MsOS_GetSystemTime()-dwTimes) >= 10)
897 {
898 //printf("MIU DMA not finished yet\n");
899 break; //timeout
900 }
901 }
902 }
903
904 //<C>.Waiting for result
905 memcpy(( U8 *)pbData,pUsbCtrlBuf_Port2,hwDataSize);
906
907 //Dump_Data((U16)pbData,hwDataSize);
908
909 //<2.3>.Out packet
910
911 //<A>.Fill qTD
912 spTempqTD=(qTD_Structure *)flib_Host20_GetStructure_Port2(Host20_MEM_TYPE_qTD);//0=>qTD
913 spTempqTD->bPID=HOST20_qTD_PID_OUT; //Bit8~9
914 spTempqTD->bTotalBytes=0; //Bit16~30
915
916 spTempqTD->bDataToggle=1; //Bit31
917
918 //<B>.Send qTD
919 //bReturnValue=flib_Host20_Send_qTD_Port2(spTempqTD ,psHost20_qHD_List_Control[bEdNum],5);
920 bReturnValue=flib_Host20_Send_qTD_Port2(spTempqTD ,qh_ptr,gUsbTimeout_Port2);
921
922 if (bReturnValue>0)
923 goto exit_issue_control;
924
925
926 break;
927
928 //<3>.Case-2:'Setup/In' Format... => Faraday Driver will not need
929 case 1: // clear feature
930 case 3: // set feature
931 case 5: // set address
932 case 9: // set Configuration
933 case 11: // set interface
934
935 //<3.2>.In packet
936
937 //<A>.Fill qTD
938 spTempqTD=(qTD_Structure *)flib_Host20_GetStructure_Port2(Host20_MEM_TYPE_qTD);//0=>qTD
939 spTempqTD->bPID=HOST20_qTD_PID_IN; //Bit8~9
940 spTempqTD->bTotalBytes=hwDataSize; //Bit16~30
941 spTempqTD->bDataToggle=1; //Bit31
942 spTempqTD->ArrayBufferPointer_Word[0]=VirtoPhyAddr((U32)pUsbCtrlBuf_Port2);
943 //FillBufferArray(spTempqTD, bpDataPage);
944
945 //<B>.Send qTD
946 //bReturnValue=flib_Host20_Send_qTD_Port2(spTempqTD ,psHost20_qHD_List_Control[bEdNum],5);
947 bReturnValue=flib_Host20_Send_qTD_Port2(spTempqTD ,qh_ptr,gUsbTimeout_Port2);
948
949 if (bReturnValue>0)
950 goto exit_issue_control;
951 //<C>.Copy Result
952 //memcpy(pbData,(UINT8*)pUsbCtrlBuf_Port2,hwDataSize);
953 break;
954
955 //<4>.Case-3:'Setup/Out/In'
956 case 7: // set descriptor
957 //<4.2>.Out packet
958 //<A>.Fill qTD
959 spTempqTD=(qTD_Structure *)flib_Host20_GetStructure_Port2(Host20_MEM_TYPE_qTD);//0=>qTD
960 spTempqTD->bPID=HOST20_qTD_PID_OUT; //Bit8~9
961 spTempqTD->bTotalBytes=hwDataSize; //Bit16~30
962 spTempqTD->bDataToggle=1; //Bit31
963 spTempqTD->ArrayBufferPointer_Word[0]=VirtoPhyAddr((U32)pUsbCtrlBuf_Port2);
964 // FillBufferArray(spTempqTD, bpDataPage);
965
966 memcpy(pUsbCtrlBuf_Port2,pbData,hwDataSize);
967
968 //<B>.Send qTD
969 //bReturnValue=flib_Host20_Send_qTD_Port2(spTempqTD ,psHost20_qHD_List_Control[bEdNum],5);
970 bReturnValue=flib_Host20_Send_qTD_Port2(spTempqTD ,qh_ptr,gUsbTimeout_Port2);
971
972 if (bReturnValue>0)
973 goto exit_issue_control;
974
975
976 //<4.3>.In packet
977 //<A>.Fill qTD
978 spTempqTD=(qTD_Structure *)flib_Host20_GetStructure_Port2(Host20_MEM_TYPE_qTD);//0=>qTD
979 spTempqTD->bPID=HOST20_qTD_PID_IN; //Bit8~9
980 spTempqTD->bTotalBytes=0; //Bit16~30
981 spTempqTD->bDataToggle=1; //Bit31
982
983 //<B>.Send qTD
984 //bReturnValue=flib_Host20_Send_qTD_Port2(spTempqTD ,psHost20_qHD_List_Control[bEdNum],5);
985 bReturnValue=flib_Host20_Send_qTD_Port2(spTempqTD ,qh_ptr,gUsbTimeout_Port2);
986
987 if (bReturnValue>0)
988 goto exit_issue_control;
989
990 break;
991
992 default:
993 break;
994 }
995 #endif
996 return (0);
997 exit_issue_control:
998
999 return (bReturnValue);
1000
1001 }
1002
1003 #if 0
1004 void Dump_QTD_Port2(UINT16 addr)
1005 {
1006 UINT8 i;
1007 // kcj 2007-06-07 printf("QTD:%x -> \n",addr);
1008 // kcj 2007-06-07 for (i=0; i < 0x20 ; i++)
1009 // kcj 2007-06-07 printf("%02bx ",*(unsigned char volatile xdata *)(addr+i));
1010
1011
1012 }
1013 void Dump_Data(UINT16 addr,UINT16 sz)
1014 {
1015 UINT16 i;
1016 // kcj 2007-06-07 printf("addr:%x -> \n",addr);
1017 // kcj 2007-06-07 for (i=0; i < sz ; i++)
1018 // kcj 2007-06-07 printf("%02bx ",*(unsigned char volatile xdata *)(addr+i));
1019
1020
1021 }
1022 #endif
1023
1024 //====================================================================
1025 // * Function Name: flib_Host20_Issue_Bulk_Port2
1026 // * Description: Input data must be 4K-Alignment
1027 // <1>.MaxSize=20 K
1028 // <2>.Support Only 1-TD
1029 // * Input:
1030 // * OutPut:
1031 //====================================================================
flib_Host20_Issue_Bulk_Port2(U8 bArrayListNum,U16 hwSize,U32 pwBuffer,U8 bDirection)1032 U8 flib_Host20_Issue_Bulk_Port2 (U8 bArrayListNum,U16 hwSize,U32 pwBuffer,U8 bDirection)
1033 {
1034 qTD_Structure *spTempqTD;
1035 U8 bTemp,i;
1036 U16 count;
1037 U32 addr;
1038 U32 mybuf,workbuf;
1039 qHD_Structure *spTempqH;
1040 U32 *dnaptr=NULL;
1041 U32 dwTimes;
1042
1043
1044
1045 mybuf=0;
1046
1047 if ( pwBuffer !=(U32) KSEG02KSEG1(pwBuffer) )
1048 {
1049 if (pwBuffer & 0x7) //flush should be 8 bytes aligned
1050 {
1051 // printf(" buf ");
1052 #if 0
1053 mybuf=(U32)msAPI_Memory_Allocate(hwSize, BUF_ID_USB_HOST ); //temporarily buffer for USB control
1054 if ( mybuf == 0 )
1055 {
1056 printf("Memory allocate failed\n");
1057 return HOST20_FATAL;
1058 }
1059 mybuf = (U32)KSEG02KSEG1(mybuf);
1060 #else
1061 mybuf = (U32)KSEG02KSEG1(usb_temp_buf_Port2);
1062 pwBuffer=(U32)KSEG02KSEG1(pwBuffer);
1063 #endif
1064
1065 }
1066 else
1067 {
1068 // printf(" fuh ");
1069 MY_HAL_DCACHE_FLUSH((U32)pwBuffer,(U32)hwSize); //flush buffer to uncached buffer
1070 pwBuffer=(U32)KSEG02KSEG1(pwBuffer);
1071 }
1072 }
1073 else
1074 {
1075 if (pwBuffer & 0x7)
1076 {
1077 // printf(" buf ");
1078 #if 0
1079 mybuf=(U32)msAPI_Memory_Allocate(hwSize, BUF_ID_USB_HOST ); //temporarily buffer for USB control
1080 if ( mybuf == 0 )
1081 {
1082 printf("Memory allocate failed\n");
1083 return HOST20_FATAL;
1084 }
1085 mybuf = (U32)KSEG02KSEG1(mybuf);
1086 #else
1087 mybuf = (U32)KSEG02KSEG1(usb_temp_buf_Port2);
1088 pwBuffer=(U32)KSEG02KSEG1(pwBuffer);
1089 #endif
1090 }
1091 }
1092
1093 spTempqTD =flib_Host20_GetStructure_Port2(Host20_MEM_TYPE_qTD); //The qTD will be release in the function "Send"
1094 spTempqTD->bTotalBytes=hwSize ;
1095
1096 // FillBufferArray2(spTempqTD,pwBufferArray,hwSize); //use global buffer , because it is 4k alignment
1097 #if 0
1098 spTempqTD->ArrayBufferPointer_Word[0]=pwBufferArray;
1099 if (((pwBufferArray&0xfff)+hwSize) > 0xfff) //goto page 2
1100 spTempqTD->ArrayBufferPointer_Word[1]=pwBufferArray+0x1000; //+4K
1101 if (hwSize > (0x1000+0x1000-(pwBufferArray&0xfff))
1102 #endif
1103 //not allow buffer over 16K for my usage
1104 if (mybuf==0) //use original buf
1105 workbuf=pwBuffer;
1106 else
1107 workbuf=mybuf;
1108
1109 dnaptr=(U32 *)(U32)workbuf;
1110 spTempqTD->ArrayBufferPointer_Word[0] = VirtoPhyAddr(workbuf);
1111
1112 count = 0x1000 - (workbuf & 0x0fff); /* rest of that page */
1113 if ( hwSize < count) /* ... iff needed */
1114 count = hwSize;
1115 else
1116 {
1117 workbuf += 0x1000;
1118 workbuf &= ~0x0fff;
1119
1120 /* per-qtd limit: from 16K to 20K (best alignment) */
1121 for (i = 1; count < hwSize && i < 5; i++)
1122 {
1123 addr = workbuf;
1124 spTempqTD->ArrayBufferPointer_Word[i] = VirtoPhyAddr(addr);
1125 // lastnums++;
1126 workbuf += 0x1000;
1127 if ((count + 0x1000) < hwSize)
1128 count += 0x1000;
1129 else
1130 count = hwSize;
1131 }
1132
1133 }
1134 if (bArrayListNum==0)
1135 spTempqH=pHost20_qHD_List_Bulk0_Port2;
1136 else // if (bArrayListNum==1)
1137 spTempqH=pHost20_qHD_List_Bulk1_Port2;
1138
1139 //<2>.Analysis the Direction
1140 if (bDirection==OTGH_Dir_IN)
1141 {
1142 spTempqTD->bPID=HOST20_qTD_PID_IN;
1143 if (FirstBulkInPort2)
1144 {
1145 spTempqTD->bDataToggle=0;
1146 spTempqH->bDataToggleControl=1;
1147 }
1148
1149 //MAKE THE SIGNATURE
1150 if (hwSize>3)
1151 {
1152 dnaptr+=(hwSize/4) - 1;
1153 *dnaptr=USB_DMA_SIGNATURE1;
1154 }
1155
1156 }
1157 else
1158 {
1159 spTempqTD->bPID=HOST20_qTD_PID_OUT;
1160 if (FirstBulkOutPort2)
1161 {
1162 spTempqTD->bDataToggle=0;
1163 spTempqH->bDataToggleControl=1;
1164
1165 }
1166 if (mybuf) memcpy((void*)mybuf,(void*)pwBuffer,hwSize); //copy buffer
1167 }
1168
1169
1170 //<3>.Send TD
1171
1172 //if (bArrayListNum==0)
1173 //bTemp=flib_Host20_Send_qTD_Port2(spTempqTD ,spTempqH,gUsbTimeout_Port2);
1174 //else if (bArrayListNum==1)
1175 //bTemp=flib_Host20_Send_qTD_Port2(spTempqTD ,pHost20_qHD_List_Bulk1_Port2,gUsbTimeout);
1176 bTemp=flib_Host20_Send_qTD_Port2(spTempqTD ,spTempqH,gUsbTimeout_Port2);
1177
1178 if ((FirstBulkInPort2)&&(bDirection==OTGH_Dir_IN))
1179 {
1180 spTempqH->bDataToggleControl=0;
1181 FirstBulkInPort2=FALSE;
1182 }
1183 if ((FirstBulkOutPort2)&&(bDirection==OTGH_Dir_Out))
1184 {
1185 spTempqH->bDataToggleControl=0;
1186 FirstBulkOutPort2=FALSE;
1187 }
1188
1189 if (bDirection==OTGH_Dir_IN)
1190 {
1191 if (((hwSize-TotalBytes_Port2)==hwSize) && (hwSize>3))
1192 {
1193 dwTimes=MsOS_GetSystemTime();
1194 while (*dnaptr==USB_DMA_SIGNATURE1)
1195 {
1196 if ((MsOS_GetSystemTime()-dwTimes) >= 10)
1197 {
1198 //printf("MIU DMA not finished yet\n");
1199 break; //timeout
1200 }
1201 }
1202 }
1203 #if defined(CPU_TYPE_MIPS) || defined(CPU_TYPE_ARM)
1204 USB_Chip_Read_Memory_Port2();
1205 #endif
1206 if (mybuf)
1207 memcpy((void*)pwBuffer,(void*)mybuf,hwSize); //copy buffer
1208 }
1209
1210 #if 0
1211 if (mybuf)
1212 {
1213 mybuf = (U32)KSEG12KSEG0(mybuf);
1214 msAPI_Memory_Free((void*)mybuf,BUF_ID_USB_HOST);
1215 }
1216 #endif
1217 // printf("Z");
1218 return (bTemp);
1219
1220
1221 }
1222 //====================================================================
1223 // * Function Name: flib_Host20_AnalysisConfigyration_Port2
1224 // * Description:
1225 // * Input:
1226 //
1227 // * OutPut:
1228 //====================================================================
flib_Host20_AnalysisConfigyration_Port2(UINT8 * pbData)1229 UINT8 flib_Host20_AnalysisConfigyration_Port2 (UINT8 *pbData)
1230 {
1231 #if 1
1232 UINT8 i = 0;
1233 // UINT8 *pBuf, j;
1234 UINT8 ept_idx = 0;
1235 int RemainLen;
1236
1237 //<1>.Copy Configuration 1~2
1238 if (psAttachDevice_Port2->sDD.bCONFIGURATION_NUMBER>HOST20_CONFIGURATION_NUM_MAX)
1239 {
1240 //while(1);
1241 }
1242
1243 memcpy((U8 *)&(psAttachDevice_Port2->saCD[i]),pbData,HOST20_CONFIGURATION_LENGTH);
1244 pbData=pbData+HOST20_CONFIGURATION_LENGTH;
1245
1246 #if 0
1247 printf("Got a Config Descriptor: \n");
1248 pBuf = (U8 *)&(psAttachDevice_Port2->saCD[i]);
1249 for (j=0; j<HOST20_CONFIGURATION_LENGTH; j++)
1250 printf(" %02X", pBuf[j]);
1251 printf("\n\n");
1252 #endif
1253
1254 RemainLen = (int)psAttachDevice_Port2->saCD[i].bTotalLengthLowByte +
1255 ((int)psAttachDevice_Port2->saCD[i].bTotalLengthHighByte << 8) - HOST20_CONFIGURATION_LENGTH;
1256
1257 //intf_idx = 0;
1258 while (RemainLen > 0)
1259 {
1260 #if 0
1261 printf("RemainLen: 0x%x\n", RemainLen);
1262
1263 printf("Find a descriptor:\n");
1264 pBuf = pbData;
1265 for (j=0; j<pbData[0]; j++)
1266 printf(" %02X", pBuf[j]);
1267 printf("\n\n");
1268 #endif
1269
1270 if (pbData[1] == 4) /*INTERFACE*/
1271 {
1272 // printf("Get a interface descriptor\n");
1273 memcpy((U8 *)&(psAttachDevice_Port2->saCD[i].sInterface[0]),pbData,HOST20_INTERFACE_LENGTH);
1274 ept_idx = 0;
1275 if (psAttachDevice_Port2->saCD[i].sInterface[0].bEP_NUMBER>HOST20_ENDPOINT_NUM_MAX)
1276 {
1277 // printf("endpoint number is over HOST20_ENDPOINT_NUM_MAX\n");
1278 }
1279 }
1280 else if (pbData[1] == 5) /*ENDPOINT*/
1281 {
1282 // printf("Get a endpoint descriptor\n");
1283 memcpy((U8 *)&(psAttachDevice_Port2->saCD[i].sInterface[0].sED[ept_idx]),pbData,HOST20_ENDPOINT_LENGTHX);
1284 ept_idx++;
1285 }
1286
1287 RemainLen -= pbData[0];
1288 pbData = pbData + pbData[0];
1289
1290 if (ept_idx == psAttachDevice_Port2->saCD[i].sInterface[0].bEP_NUMBER) //All endpoints are collected
1291 {
1292 //intf_idx++;
1293 if ( (psAttachDevice_Port2->saCD[i].sInterface[0].bInterfaceClass == USB_INTERFACE_CLASS_MSD) ||
1294 (psAttachDevice_Port2->saCD[i].sInterface[0].bInterfaceClass == USB_INTERFACE_CLASS_HUB) ||
1295 (psAttachDevice_Port2->saCD[i].sInterface[0].bInterfaceClass == USB_INTERFACE_CLASS_IMAGE) ||
1296 (psAttachDevice_Port2->saCD[i].sInterface[0].bInterfaceClass == USB_INTERFACE_CLASS_HID) )
1297 break;
1298 }
1299 }
1300
1301 // printf("End the config analyzing\n");
1302
1303 return (1);
1304 #else
1305 UINT8 i,j,k;
1306
1307
1308 //<1>.Copy Configuration 1~2
1309 if (psAttachDevice_Port2->sDD.bCONFIGURATION_NUMBER>HOST20_CONFIGURATION_NUM_MAX)
1310 {
1311 // kcj 2007-06-07 printf("??? Analysis Configuration Fail(bCONFIGURATION_NUMBER>Max)...");
1312 //while(1);
1313 }
1314 //for (i=0;i<psAttachDevice_Port2->sDD.bCONFIGURATION_NUMBER;i++)
1315 i=0;
1316 {
1317
1318 memcpy((U8 *)&(psAttachDevice_Port2->saCD[i]),pbData,HOST20_CONFIGURATION_LENGTH);
1319 pbData=pbData+HOST20_CONFIGURATION_LENGTH;
1320
1321 //<2>.Copy Interface 1~5
1322 if (psAttachDevice_Port2->saCD[i].bINTERFACE_NUMBER>HOST20_INTERFACE_NUM_MAX)
1323 {
1324 // kcj 2007-06-07 printf("??? Analysis Interface Fail(bINTERFACE_NUMBER>Max)...");
1325 //while(1);
1326 }
1327 for (j=0;j<psAttachDevice_Port2->saCD[i].bINTERFACE_NUMBER;j++)
1328 {
1329 memcpy((U8 *)&(psAttachDevice_Port2->saCD[i].sInterface[j]),pbData,HOST20_INTERFACE_LENGTH);
1330 pbData=pbData+HOST20_INTERFACE_LENGTH;
1331
1332 //<3>.Copy Class HID
1333 if (psAttachDevice_Port2->saCD[i].sInterface[j].bInterfaceClass ==3)
1334 {//Only support 1 class
1335 memcpy((U8 *)&(psAttachDevice_Port2->saCD[i].sInterface[j].sClass[0]),pbData,*pbData);
1336 pbData=pbData+(*pbData);
1337 }
1338
1339 //<4>.Copy Endpoint 1~5
1340 if (psAttachDevice_Port2->saCD[i].sInterface[j].bEP_NUMBER>HOST20_ENDPOINT_NUM_MAX)
1341 {
1342 // kcj 2007-06-07 printf("??? Analysis Endpoint Fail(bEP_NUMBER>Max)...");
1343 //while(1);
1344 }
1345 for (k=0;k<psAttachDevice_Port2->saCD[i].sInterface[j].bEP_NUMBER;k++)
1346 {
1347 memcpy((U8 *)&(psAttachDevice_Port2->saCD[i].sInterface[j].sED[k]),pbData,HOST20_ENDPOINT_LENGTHX);
1348 pbData=pbData+HOST20_ENDPOINT_LENGTHX;
1349 }//Endpoint
1350
1351 }//Interface
1352
1353 }//Configuration
1354
1355
1356 //<4>.Checkong the OTG Descriptor
1357 //if (*pbData==3)
1358 //{ if (*(pbData+1)==9)
1359 // {
1360 // psAttachDevice_Port2->sOTG.bED_OTG_Length=3;
1361 // psAttachDevice_Port2->sOTG.bED_OTG_bDescriptorType=9;
1362 // psAttachDevice_Port2->sOTG.bED_OTG_bAttributes=*(pbData+2);
1363 // }
1364 //}
1365
1366 return (1);
1367 #endif
1368
1369 }
1370
1371 //====================================================================
1372 // * Function Name: flib_Host20_FirstTransfer_Port2 ==>51ok
1373 // * Description:
1374 // * Input:
1375 //
1376 // * OutPut:
1377 //====================================================================
flib_Host20_FirstTransfer_Port2(void)1378 UINT8 flib_Host20_FirstTransfer_Port2 (void)
1379 {
1380
1381 UINT8 bLoop;
1382 UINT8 bCMD[8];
1383 bLoop=0;
1384 do{
1385 bLoop++;
1386 //<1>.GetDescriptor - Device (8 Bytes)
1387 //while (1)
1388 //{
1389
1390 memcpy(bCMD,OTGH_GETDESCRIPTOR_DEVICE_8_PORT2,8);
1391
1392 if (flib_Host20_Issue_Control_Port2 (0,bCMD,8,(UINT8*)&(psAttachDevice_Port2->sDD))==0)
1393 {
1394
1395 return (0);//ok
1396 }
1397 //}
1398 //<2>.Suspend the Bus
1399 //printf("first\n");
1400 if (gUsbStatus_Port2==USB_TIMEOUT) return 1;
1401 #if 1
1402 flib_Host20_Close_Port2();
1403 //
1404 UTMI2_ORXBYTE(0x06,0x03); //reset UTMI
1405 UTMI2_ANDXBYTE(0x06,0xfc);
1406 mbHost20_USBCMD_HCReset_Set();
1407 MsOS_DelayTask(100);
1408
1409 //<3>.Reset Port
1410 flib_Host20_PortBusReset_Port2();
1411 #endif
1412 }while(bLoop<6);
1413 gUsbStatus_Port2=USB_INIT_FAIL;
1414
1415 return(1);
1416
1417 }
1418 #if 1
1419 code UINT8 SET_FEATURE_PORT_POWER_PORT2[] = {0x23,0x03,0x08,0x00,0x01,0x00,0x00,0x00};
1420 code UINT8 CLEAR_FEATURE_C_PORT_CONNECTION_PORT2[]={0x23,0x01,0x10,0,0x01,0,0,0};
1421 code UINT8 SET_FEATURE_PORT_RESET_PORT2[] = {0x23,0x03,0x04,0x00,0x01,0x00,0x00,0x00};
1422 code UINT8 CLEAR_FEATURE_C_PORT_RESET_PORT2[]={0x23,0x01,0x14,0,0x01,0,0,0};
1423 code UINT8 OTGH_GETDESCRIPTOR_HUBCLASS_PORT2[]={0xA0,0x06,0x00,0x00,0x00,0x00,0x09,0x00};
1424 code UINT8 GET_PORT_STATUS_PORT2[]={0xA3,0x00,0x00,0x00,0x01,0x00,0x04,0x00};
Usb_Hub_Port_Num_Port2()1425 U8 Usb_Hub_Port_Num_Port2()
1426 {
1427 UINT8 bCMD[8];
1428 U8 PortNum,i;
1429
1430 memcpy(bCMD,OTGH_GETDESCRIPTOR_HUBCLASS_PORT2,8);
1431
1432 if (flib_Host20_Issue_Control_Port2 (1,bCMD,0x09,pUsbData_Port2)>0)
1433 {
1434 return FALSE;
1435 }
1436 PortNum=*(pUsbData_Port2+2);
1437 #if 1
1438 for(i=1;i<=PortNum;i++)
1439 {
1440 //set feature port power
1441 memcpy(bCMD,SET_FEATURE_PORT_POWER_PORT2,8);
1442 bCMD[4]=i;
1443 if ( flib_Host20_Issue_Control_Port2 (1,bCMD,0,NULL)>0)
1444 {
1445 DEBUG_USB(printf("set port power failed\n"));
1446 return PortNum;
1447 }
1448 }
1449 MsOS_DelayTask(125);
1450
1451 for(i=1;i<=PortNum;i++)
1452 {
1453 //clear feature c_port_connection
1454 memcpy(bCMD,CLEAR_FEATURE_C_PORT_CONNECTION_PORT2,8);
1455 bCMD[4]=i;
1456 if (flib_Host20_Issue_Control_Port2 (1,bCMD,0,NULL)>0)
1457 {
1458 DEBUG_USB(printf("clear feature failed\n"));
1459 return PortNum;
1460 }
1461 }
1462 #endif
1463 return PortNum;
1464 }
USB_Hub_Handle_Port2(U8 port)1465 BOOLEAN USB_Hub_Handle_Port2(U8 port)
1466 {
1467 UINT8 bCMD[8];
1468
1469 MsOS_DelayTask(10);//10, wait 1 ms
1470
1471 //get all prot status
1472
1473
1474 //get prot status
1475 memcpy(bCMD,GET_PORT_STATUS_PORT2,8);
1476 bCMD[4]=port;
1477 if (flib_Host20_Issue_Control_Port2 (1,bCMD,0x04,pUsbData_Port2)>0)
1478 {
1479 DEBUG_USB(printf("Get port status failed\n"));
1480
1481 return FALSE;
1482 }
1483
1484 DEBUG_USB(printf(" Port:%02bx Status=%02bx",port,(*pUsbData_Port2)));
1485 if(!((*pUsbData_Port2)&0x01))
1486 return FALSE;
1487 //for (i=0 ; i < 3 ; i++)
1488 {
1489 DEBUG_USB(printf("Port %02bx have device.\n",port));
1490 //set feature port_reset
1491 memcpy(bCMD,SET_FEATURE_PORT_RESET_PORT2,8);
1492 bCMD[4]=port;
1493 if (flib_Host20_Issue_Control_Port2 (1,bCMD,0,NULL)>0)
1494 return FALSE;
1495 MsOS_DelayTask(10);//10, wait 1 ms
1496
1497 memcpy(bCMD,GET_PORT_STATUS_PORT2,8);
1498 bCMD[4]=port;
1499 if (flib_Host20_Issue_Control_Port2 (1,bCMD,0x04,pUsbData_Port2)>0)
1500 {
1501 DEBUG_USB(printf("Get port status failed\n"));
1502
1503 return FALSE;
1504 }
1505
1506 #if 1
1507 DEBUG_USB(printf(" Port:%02bx Status=%02bx",port,(*pUsbData_Port2)));
1508 //clear feature c_port_reset
1509 memcpy(bCMD,CLEAR_FEATURE_C_PORT_RESET_PORT2,8);
1510 bCMD[4]=port;
1511 if (flib_Host20_Issue_Control_Port2 (1,bCMD,0,NULL)>0)
1512 return FALSE;
1513
1514 memcpy(bCMD,GET_PORT_STATUS_PORT2,8);
1515 bCMD[4]=port;
1516 if (flib_Host20_Issue_Control_Port2 (1,bCMD,0x04,pUsbData_Port2)>0)
1517 {
1518 DEBUG_USB(printf("Get port status failed\n"));
1519
1520 return FALSE;
1521 }
1522 #endif
1523 // flib_Host20_Interrupt_Init_Port2(1,1,1);
1524 //if (pUsbData_Port2[2]!=0)
1525 //{
1526 // OTGH_PT_Bulk_Init_for_Int();
1527 // result=flib_Host20_Issue_Bulk_Port2 (0,1,pUsbData_Port2,OTGH_Dir_IN);
1528 // // flib_Host20_Issue_Interrupt_Port2(1,HOST20_qTD_PID_IN);
1529
1530 MsOS_DelayTask(30);//10, wait 1 ms
1531 }
1532 return TRUE;
1533 }
1534 #endif
1535
1536 #ifdef Enable_Issue_TestPacket
1537 extern void IssueTestPacket_Port2(U8 xdata *TestData);
USB_DACHE_FLUSH_Port2(U32 addr,U32 length)1538 void USB_DACHE_FLUSH_Port2(U32 addr, U32 length)
1539 {
1540 MY_HAL_DCACHE_FLUSH(addr, length);
1541 }
1542
1543 #endif
1544
1545 //====================================================================
1546 // * Function Name: flib_Host20_Enumerate_Port2
1547 // * Description:
1548 // * Input:
1549 //
1550 // * OutPut:
1551 //====================================================================
1552 #ifndef DEVICE_ENUM_SEGMENT
flib_Host20_Enumerate_Port2(UINT8 bNormalEnumerate,UINT8 bAddress)1553 UINT8 flib_Host20_Enumerate_Port2 (UINT8 bNormalEnumerate,UINT8 bAddress)
1554 {
1555 UINT8 bCMD[8];
1556 UINT16 wLength;
1557 UINT16 ii, jj;
1558 //UINT32 i;
1559 //UINT8 bFaradayAP[4]={0x10,0x23,0x78,0x56};
1560 //UINT8 pbData[128]; //yuwen ,move to USB global SDRAM
1561 //UINT32 wSizeTemp;
1562 UINT8 bReturn;
1563
1564 // printf("flib_Host20_Enumerate_Port2 \n");
1565
1566 //printf("\r\n Enumerate",0);
1567 #if defined(Enable_Issue_TestPacket) && !defined(ENABLE_HOST_TEST)
1568 MY_HAL_DCACHE_FLUSH((U32)pUsbData_Port2, 128);
1569 IssueTestPacket_Port2(pUsbData_Port2);
1570 #endif
1571
1572 bReturn=1;
1573 //psAttachDevice_Port2->bISOTransferEnable=0;
1574 gUsbTimeout_Port2=3;
1575
1576 //<1>.GetDescriptor - Device (8 Bytes)
1577 MsOS_DelayTask(10);
1578 if (flib_Host20_FirstTransfer_Port2()>0)
1579 {
1580 return(0);//Fail
1581 }
1582 gUsbTimeout_Port2=11; //extend usb timeout , for some really slow response HD
1583
1584 //Set the ep0 max packet size
1585
1586 pHost20_qHD_List_Control0_Port2->bMaxPacketSize=psAttachDevice_Port2->sDD.bEP0MAXPACKETSIZE;
1587 //psHost20_qHD_List_Control[0]->bMaxPacketSize1=psAttachDevice_Port2->sDD.bEP0MAXPACKETSIZE>>8;
1588
1589 pHost20_qHD_List_Control1_Port2->bMaxPacketSize=psAttachDevice_Port2->sDD.bEP0MAXPACKETSIZE;
1590 //psHost20_qHD_List_Control[1]->bMaxPacketSize1=psAttachDevice_Port2->sDD.bEP0MAXPACKETSIZE>>8;
1591
1592 //printf("max packet:%02bx\n",psAttachDevice_Port2->sDD.bEP0MAXPACKETSIZE);
1593 //printf("max packet:%02bx\n",pHost20_qHD_List_Control0_Port2->bMaxPacketSize0);
1594
1595 MsOS_DelayTask(10);
1596 #if 1
1597 //<2>.bNormalEnumerate =>Issue the Bus Reset
1598 //Issue Bus Reset
1599 //flib_Host20_Suspend_Port2();//Bruce;;add;;06102005
1600 //flib_Host20_TimerEnable(55);//Bruce;;add;;06102005
1601 //printf("bus reset again...\n");
1602 if(!NowIsHubPort2)
1603 flib_Host20_PortBusReset_Port2();
1604 #endif
1605 //<2.2>.Get Descriptor again
1606 memcpy(bCMD,OTGH_GETDESCRIPTOR_DEVICE_PORT2,8);
1607
1608 if (flib_Host20_Issue_Control_Port2 (0,bCMD,0x12,(UINT8*)&(psAttachDevice_Port2->sDD))>0)
1609 {
1610 return(0);//Fail
1611 }
1612 MsOS_DelayTask(10);
1613 #if defined(Enable_Issue_TestPacket) && !defined(ENABLE_HOST_TEST)
1614 IssueTestPacket_Port2(pUsbData_Port2);
1615 #endif
1616 #ifdef Enable_SOF_Only
1617 printf("Repeat FS SOF...\n");
1618 while (1)
1619 {
1620 MsOS_DelayTask(100);
1621 }
1622 #endif
1623
1624
1625 //if (bNormalEnumerate>0)
1626 // if (memcmp(bFaradayAP,&(psAttachDevice_Port2->sDD.bVIDLowByte),4)>0)
1627 // {//This is not the Faraday Test AP
1628 // printf(">>>Error:This is not the Faraday Test AP...\n");
1629 // flib_DumpDeviceDescriptor(&(psAttachDevice_Port2->sDD));
1630 // bReturn=2;
1631 // }
1632
1633 //<3>.Set Address to i
1634 memcpy(bCMD,OTGH_SETADDRESS_PORT2,8);
1635 psAttachDevice_Port2->bAdd=bAddress;
1636 pHost20_qHD_List_Control1_Port2->bDeviceAddress=psAttachDevice_Port2->bAdd;
1637 bCMD[2]=psAttachDevice_Port2->bAdd;
1638 if (flib_Host20_Issue_Control_Port2(0,bCMD,0,OTGH_NULL)>0)
1639 {
1640 return(0);//Fail
1641 }
1642 MsOS_DelayTask(100); //leave some time to wait device to be ready
1643
1644 //<4>.GetDescriptor - Configuration (8Bytes)
1645 memcpy(bCMD,OTGH_GETDESCRIPTOR_CONFIG_PORT2,8);
1646 //pbData=USBMALLOC(1000 );
1647 //for (i=0;i<1000;i++)
1648 // *(pbData+i)=0;
1649 if (flib_Host20_Issue_Control_Port2 (1,bCMD,0x08,pUsbData_Port2)>0)
1650 {
1651 return(0);//Fail
1652 }
1653 MsOS_DelayTask(10);
1654 wLength=*(pUsbData_Port2+2)+((*(pUsbData_Port2+3))<<8);
1655
1656 //<5>.GetDescriptor - Configuration (Y-Bytes = wLength)
1657 if (wLength > CONTROL_BUF_LEN)
1658 {
1659 HOSTLIB_MSG(printf("Warning too long descriptor\n"));
1660 return(0);//Fail
1661 }
1662
1663 bCMD[6]=*(pUsbData_Port2+2);//Low Byte
1664 bCMD[7]=*(pUsbData_Port2+3) ;//High Byte
1665 if (flib_Host20_Issue_Control_Port2 (1,bCMD,wLength,pUsbData_Port2)>0)
1666 {
1667 return(0);//Fail
1668 }
1669 MsOS_DelayTask(10);
1670
1671
1672 //printf("pUsbData:%x\n",wLength);
1673 //Dump_Data((UINT16)pUsbData,wLength);
1674 flib_Host20_AnalysisConfigyration_Port2(pUsbData_Port2);
1675
1676 //Give it a try
1677
1678 //-----------do test mode -------------
1679
1680 #ifdef ENABLE_HOST_TEST
1681 if ((psAttachDevice_Port2->sDD.bVIDHighByte==0x1a)&&(psAttachDevice_Port2->sDD.bVIDLowByte==0x0a))
1682 {
1683 EnterTestMode_Port2();
1684 }
1685 #endif
1686 //--- test mode end---------------
1687
1688 //<6>.If OTG-Descriptor exist => then return to issue the HNP_Enable
1689 if (bNormalEnumerate==0)
1690 {//To check the OTG Descriptor
1691 if (psAttachDevice_Port2->sOTG.bED_OTG_bDescriptorType==9)
1692 {
1693 return(1);//Fail
1694 }
1695 }
1696 MsOS_DelayTask(10);
1697
1698 //<7>.Get String
1699 //psAttachDevice_Port2->bStringLanguage[0]=0;
1700 //psAttachDevice_Port2->bStringManufacture[0]=0;
1701 //psAttachDevice_Port2->bStringProduct[0]=0;
1702 //psAttachDevice_Port2->bStringSerialN[0]=0;
1703
1704 psAttachDevice_Port2->bStringLanguage[0]=0;
1705 psAttachDevice_Port2->bStringManufacture[0]=0;
1706 psAttachDevice_Port2->bStringProduct[0]=0;
1707
1708 if ((psAttachDevice_Port2->sDD.bManufacturer == 0) && (psAttachDevice_Port2->sDD.bProduct == 0))
1709 goto Get_Str_Done;
1710
1711 memcpy(bCMD, OTGH_GETDESCRIPTOR_STR_PORT2, 8);
1712 bCMD[6] = 4;
1713 if (flib_Host20_Issue_Control_Port2 (1,bCMD,4, pUsbData_Port2)>0)
1714 {
1715 goto Get_Str_Done;
1716 //return(0);//Fail
1717 }
1718 MsOS_DelayTask(1);
1719 psAttachDevice_Port2->bStringLanguage[0] = pUsbData_Port2[2];
1720 psAttachDevice_Port2->bStringLanguage[1] = pUsbData_Port2[3];
1721
1722 if (psAttachDevice_Port2->sDD.bManufacturer != 0)
1723 {
1724 memcpy(bCMD, OTGH_GETDESCRIPTOR_STR_PORT2, 8);
1725 bCMD[2] = psAttachDevice_Port2->sDD.bManufacturer;
1726 bCMD[4] = psAttachDevice_Port2->bStringLanguage[0];
1727 bCMD[5] = psAttachDevice_Port2->bStringLanguage[1];
1728 bCMD[6] = 2;
1729
1730 if (flib_Host20_Issue_Control_Port2 (1,bCMD,2, pUsbData_Port2)>0)
1731 {
1732 return(0);//Fail
1733 }
1734 MsOS_DelayTask(1);
1735
1736 bCMD[6] = pUsbData_Port2[0]; //real string length
1737 if (flib_Host20_Issue_Control_Port2 (1,bCMD,bCMD[6], pUsbData_Port2)>0)
1738 {
1739 return(0);//Fail
1740 }
1741 MsOS_DelayTask(1);
1742
1743 for (ii=2, jj=0; ii<pUsbData_Port2[0]; ii+=2, jj++)
1744 psAttachDevice_Port2->bStringManufacture[jj] = pUsbData_Port2[ii];
1745
1746 psAttachDevice_Port2->bStringManufacture[jj] = 0;
1747
1748 #if 0
1749 printf("bStringManufacture: ");
1750
1751 for (ii=0; ii<64; ii++)
1752 {
1753 printf("%c", psAttachDevice_Port2->bStringManufacture[ii]);
1754 if (psAttachDevice_Port2->bStringManufacture[ii] == 0)
1755 break;
1756 }
1757
1758 printf("\n");
1759 #endif
1760 }
1761
1762 if (psAttachDevice_Port2->sDD.bProduct != 0)
1763 {
1764 memcpy(bCMD, OTGH_GETDESCRIPTOR_STR_PORT2, 8);
1765 bCMD[2] = psAttachDevice_Port2->sDD.bProduct;
1766 bCMD[4] = psAttachDevice_Port2->bStringLanguage[0];
1767 bCMD[5] = psAttachDevice_Port2->bStringLanguage[1];
1768 bCMD[6] = 2;
1769
1770 if (flib_Host20_Issue_Control_Port2 (1,bCMD,2, pUsbData_Port2)>0)
1771 {
1772 return(0);//Fail
1773 }
1774 MsOS_DelayTask(1);
1775
1776 bCMD[6] = pUsbData_Port2[0]; //real string length
1777 if(bCMD[6] > 128)
1778 {//Alan.yu 2010.12.17 : for some bad devices return wrong length larger then 128, which will over-write the memory after pUsbData_Port2[]
1779 bCMD[6] = 128;
1780 }
1781
1782 if (flib_Host20_Issue_Control_Port2 (1,bCMD,bCMD[6], pUsbData_Port2)>0)
1783 {
1784 return(0);//Fail
1785 }
1786 MsOS_DelayTask(1);
1787
1788 for (ii=2, jj=0; ii<pUsbData_Port2[0]; ii+=2, jj++)
1789 psAttachDevice_Port2->bStringProduct[jj] = pUsbData_Port2[ii];
1790
1791 psAttachDevice_Port2->bStringProduct[jj] = 0;
1792
1793 #if 0
1794 printf("bStringProduct: ");
1795
1796 for (ii=0; ii<64; ii++)
1797 {
1798 printf("%c", psAttachDevice_Port2->bStringProduct[ii]);
1799 if (psAttachDevice_Port2->bStringProduct[ii] == 0)
1800 break;
1801 }
1802
1803 printf("\n");
1804 #endif
1805 }
1806 //#endif //Skip Get String
1807
1808 Get_Str_Done:
1809 //<8>.Set Configurarion to 0
1810 memcpy(bCMD,OTGH_SETCONFIGURATION_PORT2,8);
1811 bCMD[2]=psAttachDevice_Port2->saCD[0].bConfigurationValue;
1812 if (flib_Host20_Issue_Control_Port2 (1,bCMD,0x00,OTGH_NULL)>0)
1813 {
1814 return(0);//Fail
1815 }
1816 MsOS_DelayTask(USB_ENUM_DELAY); //leave some time to wait device to be ready
1817
1818 //<9>.Printf the Device-Descriptor/Configuration-Descriptor
1819
1820 return (bReturn);
1821 }
1822 #else // support device enumeration dividable
_flib_Host20_Enumerate_Port2(UINT8 bNormalEnumerate,UINT8 bAddress)1823 UINT8 _flib_Host20_Enumerate_Port2 (UINT8 bNormalEnumerate,UINT8 bAddress)
1824 {
1825 UINT8 bCMD[8];
1826 UINT16 wLength;
1827 UINT16 ii, jj;
1828 //UINT32 i;
1829 //UINT8 bFaradayAP[4]={0x10,0x23,0x78,0x56};
1830 //UINT8 pbData[128]; //yuwen ,move to USB global SDRAM
1831 //UINT32 wSizeTemp;
1832 UINT8 bReturn;
1833
1834 // printf("flib_Host20_Enumerate_Port2 \n");
1835
1836 //printf("\r\n Enumerate",0);
1837 #if defined(Enable_Issue_TestPacket) && !defined(ENABLE_HOST_TEST)
1838 MY_HAL_DCACHE_FLUSH((U32)pUsbData_Port2, 128);
1839 IssueTestPacket_Port2(pUsbData_Port2);
1840 #endif
1841
1842 bReturn=1;
1843 //psAttachDevice_Port2->bISOTransferEnable=0;
1844 gUsbTimeout_Port2=3;
1845
1846 //<1>.GetDescriptor - Device (8 Bytes)
1847 MsOS_DelayTask(10);
1848 if (flib_Host20_FirstTransfer_Port2()>0)
1849 {
1850 return(0);//Fail
1851 }
1852 gUsbTimeout_Port2=11; //extend usb timeout , for some really slow response HD
1853
1854 //Set the ep0 max packet size
1855
1856 pHost20_qHD_List_Control0_Port2->bMaxPacketSize=psAttachDevice_Port2->sDD.bEP0MAXPACKETSIZE;
1857 //psHost20_qHD_List_Control[0]->bMaxPacketSize1=psAttachDevice_Port2->sDD.bEP0MAXPACKETSIZE>>8;
1858
1859 pHost20_qHD_List_Control1_Port2->bMaxPacketSize=psAttachDevice_Port2->sDD.bEP0MAXPACKETSIZE;
1860 //psHost20_qHD_List_Control[1]->bMaxPacketSize1=psAttachDevice_Port2->sDD.bEP0MAXPACKETSIZE>>8;
1861
1862 //printf("max packet:%02bx\n",psAttachDevice_Port2->sDD.bEP0MAXPACKETSIZE);
1863 //printf("max packet:%02bx\n",pHost20_qHD_List_Control0_Port2->bMaxPacketSize0);
1864
1865 MsOS_DelayTask(10);
1866 #if 1
1867 //<2>.bNormalEnumerate =>Issue the Bus Reset
1868 //Issue Bus Reset
1869 //flib_Host20_Suspend_Port2();//Bruce;;add;;06102005
1870 //flib_Host20_TimerEnable(55);//Bruce;;add;;06102005
1871 //printf("bus reset again...\n");
1872 if(!NowIsHubPort2)
1873 flib_Host20_PortBusReset_Port2();
1874 #endif
1875 //<2.2>.Get Descriptor again
1876 memcpy(bCMD,OTGH_GETDESCRIPTOR_DEVICE_PORT2,8);
1877
1878 if (flib_Host20_Issue_Control_Port2 (0,bCMD,0x12,(UINT8*)&(psAttachDevice_Port2->sDD))>0)
1879 {
1880 return(0);//Fail
1881 }
1882 MsOS_DelayTask(10);
1883 #if defined(Enable_Issue_TestPacket) && !defined(ENABLE_HOST_TEST)
1884 IssueTestPacket_Port2(pUsbData_Port2);
1885 #endif
1886 #ifdef Enable_SOF_Only
1887 printf("Repeat FS SOF...\n");
1888 while (1)
1889 {
1890 MsOS_DelayTask(100);
1891 }
1892 #endif
1893
1894
1895 //if (bNormalEnumerate>0)
1896 // if (memcmp(bFaradayAP,&(psAttachDevice_Port2->sDD.bVIDLowByte),4)>0)
1897 // {//This is not the Faraday Test AP
1898 // printf(">>>Error:This is not the Faraday Test AP...\n");
1899 // flib_DumpDeviceDescriptor(&(psAttachDevice_Port2->sDD));
1900 // bReturn=2;
1901 // }
1902
1903 //<3>.Set Address to i
1904 memcpy(bCMD,OTGH_SETADDRESS_PORT2,8);
1905 psAttachDevice_Port2->bAdd=bAddress;
1906 pHost20_qHD_List_Control1_Port2->bDeviceAddress=psAttachDevice_Port2->bAdd;
1907 bCMD[2]=psAttachDevice_Port2->bAdd;
1908 if (flib_Host20_Issue_Control_Port2(0,bCMD,0,OTGH_NULL)>0)
1909 {
1910 return(0);//Fail
1911 }
1912 MsOS_DelayTask(100); //leave some time to wait device to be ready
1913
1914 //<4>.GetDescriptor - Configuration (8Bytes)
1915 memcpy(bCMD,OTGH_GETDESCRIPTOR_CONFIG_PORT2,8);
1916 //pbData=USBMALLOC(1000 );
1917 //for (i=0;i<1000;i++)
1918 // *(pbData+i)=0;
1919 if (flib_Host20_Issue_Control_Port2 (1,bCMD,0x08,pUsbData_Port2)>0)
1920 {
1921 return(0);//Fail
1922 }
1923 MsOS_DelayTask(10);
1924 wLength=*(pUsbData_Port2+2)+((*(pUsbData_Port2+3))<<8);
1925
1926 //<5>.GetDescriptor - Configuration (Y-Bytes = wLength)
1927 if (wLength > CONTROL_BUF_LEN)
1928 {
1929 HOSTLIB_MSG(printf("Warning too long descriptor\n"));
1930 return(0);//Fail
1931 }
1932
1933 bCMD[6]=*(pUsbData_Port2+2);//Low Byte
1934 bCMD[7]=*(pUsbData_Port2+3) ;//High Byte
1935 if (flib_Host20_Issue_Control_Port2 (1,bCMD,wLength,pUsbData_Port2)>0)
1936 {
1937 return(0);//Fail
1938 }
1939 MsOS_DelayTask(10);
1940
1941
1942 //printf("pUsbData:%x\n",wLength);
1943 //Dump_Data((UINT16)pUsbData,wLength);
1944 flib_Host20_AnalysisConfigyration_Port2(pUsbData_Port2);
1945
1946 //Give it a try
1947
1948 //-----------do test mode -------------
1949
1950 #ifdef ENABLE_HOST_TEST
1951 if ((psAttachDevice_Port2->sDD.bVIDHighByte==0x1a)&&(psAttachDevice_Port2->sDD.bVIDLowByte==0x0a))
1952 {
1953 EnterTestMode_Port2();
1954 }
1955 #endif
1956 //--- test mode end---------------
1957
1958 //<6>.If OTG-Descriptor exist => then return to issue the HNP_Enable
1959 if (bNormalEnumerate==0)
1960 {//To check the OTG Descriptor
1961 if (psAttachDevice_Port2->sOTG.bED_OTG_bDescriptorType==9)
1962 {
1963 return(1);//Fail
1964 }
1965 }
1966 MsOS_DelayTask(10);
1967
1968 //<7>.Get String
1969 //psAttachDevice_Port2->bStringLanguage[0]=0;
1970 //psAttachDevice_Port2->bStringManufacture[0]=0;
1971 //psAttachDevice_Port2->bStringProduct[0]=0;
1972 //psAttachDevice_Port2->bStringSerialN[0]=0;
1973
1974 psAttachDevice_Port2->bStringLanguage[0]=0;
1975 psAttachDevice_Port2->bStringManufacture[0]=0;
1976 psAttachDevice_Port2->bStringProduct[0]=0;
1977
1978 if ((psAttachDevice_Port2->sDD.bManufacturer == 0) && (psAttachDevice_Port2->sDD.bProduct == 0))
1979 goto Get_Str_Done;
1980
1981 memcpy(bCMD, OTGH_GETDESCRIPTOR_STR_PORT2, 8);
1982 bCMD[6] = 4;
1983 if (flib_Host20_Issue_Control_Port2 (1,bCMD,4, pUsbData_Port2)>0)
1984 {
1985 goto Get_Str_Done;
1986 //return(0);//Fail
1987 }
1988 MsOS_DelayTask(1);
1989 psAttachDevice_Port2->bStringLanguage[0] = pUsbData_Port2[2];
1990 psAttachDevice_Port2->bStringLanguage[1] = pUsbData_Port2[3];
1991
1992 if (psAttachDevice_Port2->sDD.bManufacturer != 0)
1993 {
1994 memcpy(bCMD, OTGH_GETDESCRIPTOR_STR_PORT2, 8);
1995 bCMD[2] = psAttachDevice_Port2->sDD.bManufacturer;
1996 bCMD[4] = psAttachDevice_Port2->bStringLanguage[0];
1997 bCMD[5] = psAttachDevice_Port2->bStringLanguage[1];
1998 bCMD[6] = 2;
1999
2000 if (flib_Host20_Issue_Control_Port2 (1,bCMD,2, pUsbData_Port2)>0)
2001 {
2002 return(0);//Fail
2003 }
2004 MsOS_DelayTask(1);
2005
2006 bCMD[6] = pUsbData_Port2[0]; //real string length
2007 if (flib_Host20_Issue_Control_Port2 (1,bCMD,bCMD[6], pUsbData_Port2)>0)
2008 {
2009 return(0);//Fail
2010 }
2011 MsOS_DelayTask(1);
2012
2013 for (ii=2, jj=0; ii<pUsbData_Port2[0]; ii+=2, jj++)
2014 psAttachDevice_Port2->bStringManufacture[jj] = pUsbData_Port2[ii];
2015
2016 psAttachDevice_Port2->bStringManufacture[jj] = 0;
2017
2018 #if 0
2019 printf("bStringManufacture: ");
2020
2021 for (ii=0; ii<64; ii++)
2022 {
2023 printf("%c", psAttachDevice_Port2->bStringManufacture[ii]);
2024 if (psAttachDevice_Port2->bStringManufacture[ii] == 0)
2025 break;
2026 }
2027
2028 printf("\n");
2029 #endif
2030 }
2031
2032 if (psAttachDevice_Port2->sDD.bProduct != 0)
2033 {
2034 memcpy(bCMD, OTGH_GETDESCRIPTOR_STR_PORT2, 8);
2035 bCMD[2] = psAttachDevice_Port2->sDD.bProduct;
2036 bCMD[4] = psAttachDevice_Port2->bStringLanguage[0];
2037 bCMD[5] = psAttachDevice_Port2->bStringLanguage[1];
2038 bCMD[6] = 2;
2039
2040 if (flib_Host20_Issue_Control_Port2 (1,bCMD,2, pUsbData_Port2)>0)
2041 {
2042 return(0);//Fail
2043 }
2044 MsOS_DelayTask(1);
2045
2046 bCMD[6] = pUsbData_Port2[0]; //real string length
2047 if(bCMD[6] > 128)
2048 {//Alan.yu 2010.12.17 : for some bad devices return wrong length larger then 128, which will over-write the memory after pUsbData_Port2[]
2049 bCMD[6] = 128;
2050 }
2051
2052 if (flib_Host20_Issue_Control_Port2 (1,bCMD,bCMD[6], pUsbData_Port2)>0)
2053 {
2054 return(0);//Fail
2055 }
2056 MsOS_DelayTask(1);
2057
2058 for (ii=2, jj=0; ii<pUsbData_Port2[0]; ii+=2, jj++)
2059 psAttachDevice_Port2->bStringProduct[jj] = pUsbData_Port2[ii];
2060
2061 psAttachDevice_Port2->bStringProduct[jj] = 0;
2062
2063 #if 0
2064 printf("bStringProduct: ");
2065
2066 for (ii=0; ii<64; ii++)
2067 {
2068 printf("%c", psAttachDevice_Port2->bStringProduct[ii]);
2069 if (psAttachDevice_Port2->bStringProduct[ii] == 0)
2070 break;
2071 }
2072
2073 printf("\n");
2074 #endif
2075 }
2076 //#endif //Skip Get String
2077
2078 Get_Str_Done:
2079 //<8>.Set Configurarion to 0
2080 memcpy(bCMD,OTGH_SETCONFIGURATION_PORT2,8);
2081 bCMD[2]=psAttachDevice_Port2->saCD[0].bConfigurationValue;
2082 if (flib_Host20_Issue_Control_Port2 (1,bCMD,0x00,OTGH_NULL)>0)
2083 {
2084 return(0);//Fail
2085 }
2086
2087 return (bReturn);
2088 }
flib_Host20_Enumerate_Port2(UINT8 bNormalEnumerate,UINT8 bAddress)2089 UINT8 flib_Host20_Enumerate_Port2 (UINT8 bNormalEnumerate,UINT8 bAddress)
2090 {
2091 UINT8 bReturn;
2092
2093 bReturn = _flib_Host20_Enumerate_Port2(bNormalEnumerate, bAddress);
2094 if (!bReturn)
2095 return(bReturn);
2096
2097 MsOS_DelayTask(USB_ENUM_DELAY); //leave some time for device to be ready
2098
2099 return (1);
2100 }
2101 #endif
2102
2103
2104
2105
2106
2107 //************************************************************************************************************
2108 //************************************************************************************************************
2109 // *** Group-4:Structure Function ***
2110 //*************************************************************************************************************
2111 //************************************************************************************************************
2112 //====================================================================
2113 // * Function Name: flib_Host20_InitStructure_Port2
2114 // * Description:
2115 // 1.Init qHD for Control
2116 // qHD_C-->qHD_C-->qHD_C
2117 // 2.Init qHD for Bulk
2118 // |-------------------------|
2119 // qHD_C-->qHD_C-->qHD_B-->qHD_B
2120 //
2121 // 3.Init qHD for Interrupt
2122 // 4.Init iTD for ISO (Reserved for feature)
2123 // * Input:Type =0 =>iTD
2124 // =1 =>qTD
2125 // =2
2126 // * OutPut: 0:Fail
2127 // 1:ok
2128 //====================================================================
flib_Host20_InitStructure_Port2(void)2129 void flib_Host20_InitStructure_Port2(void)
2130 {
2131 U16 i;
2132 U8 *pData;
2133
2134 //<1>.Clear memory
2135 //pData=(UINT8*)Host20_STRUCTURE_qHD_BASE_ADDRESS;
2136
2137 //for ( i=0 ; i < Host20_qHD_SIZE*Host20_qHD_MAX ; i++)
2138 //XBYTE[Host20_STRUCTURE_qHD_BASE_ADDRESS_Port2+i]=0x00;
2139 pUsbCtrlBuf_Port2=(U8*) KSEG02KSEG1(UsbCtrlBuf_Port2);
2140 MY_HAL_DCACHE_FLUSH((U32)UsbCtrlBuf_Port2, sizeof(UsbCtrlBuf_Port2));
2141
2142
2143 //printf("QtdBuf size: %d\n", sizeof(QtdBuf));
2144 qTD_Base_Buf_Port2=(U8*) KSEG02KSEG1(QtdBuf_Port2);
2145 MY_HAL_DCACHE_FLUSH((U32)QtdBuf_Port2, Host20_qTD_SIZE*Host20_qTD_MAX+0x20);
2146
2147 // ASSERT(qTD_Base_Buf != NULL)
2148 Host20_STRUCTURE_qTD_BASE_ADDRESS_Port2=qTD_Base_Buf_Port2;
2149
2150 pData=qTD_Base_Buf_Port2;
2151 for (i=0 ; i < (Host20_qTD_SIZE*Host20_qTD_MAX+0x20) ; i++)
2152 pData[i]=0;
2153
2154 if ((U32)Host20_STRUCTURE_qTD_BASE_ADDRESS_Port2& 0x10)
2155 Host20_STRUCTURE_qTD_BASE_ADDRESS_Port2+=0x10; //make it aligned with 32
2156 pHost20_qHD_List_Control0_Port2=(qHD_Structure*)KSEG02KSEG1(&Host20_qHD_List_Control0_Port2);
2157 pHost20_qHD_List_Control1_Port2=(qHD_Structure*)KSEG02KSEG1(&Host20_qHD_List_Control1_Port2);
2158 pHost20_qHD_List_Bulk0_Port2=(qHD_Structure*)KSEG02KSEG1(&Host20_qHD_List_Bulk0_Port2);
2159 pHost20_qHD_List_Bulk1_Port2=(qHD_Structure*)KSEG02KSEG1(&Host20_qHD_List_Bulk1_Port2);
2160 MY_HAL_DCACHE_FLUSH((U32)&Host20_qHD_List_Control0_Port2, sizeof(qHD_Structure));
2161 MY_HAL_DCACHE_FLUSH((U32)&Host20_qHD_List_Control1_Port2, sizeof(qHD_Structure));
2162 MY_HAL_DCACHE_FLUSH((U32)&Host20_qHD_List_Bulk0_Port2, sizeof(qHD_Structure));
2163 MY_HAL_DCACHE_FLUSH((U32)&Host20_qHD_List_Bulk1_Port2, sizeof(qHD_Structure));
2164
2165 pData=(U8*)pHost20_qHD_List_Control0_Port2;
2166 for ( i=0 ; i < sizeof(qHD_Structure); i++)
2167 pData[i]=0;
2168 pData=(U8*)pHost20_qHD_List_Control1_Port2;
2169 for ( i=0 ; i < sizeof(qHD_Structure); i++)
2170 pData[i]=0;
2171 pData=(U8*)pHost20_qHD_List_Bulk0_Port2;
2172 for ( i=0 ; i < sizeof(qHD_Structure); i++)
2173 pData[i]=0;
2174 pData=(U8*)pHost20_qHD_List_Bulk1_Port2;
2175 for ( i=0 ; i < sizeof(qHD_Structure); i++)
2176 pData[i]=0;
2177
2178 Host20_STRUCTURE_qHD_BASE_ADDRESS_Port2=(U8*)pHost20_qHD_List_Control0_Port2;
2179
2180 DEBUG_USB(printf("qhd:%lx\n",(U32)pHost20_qHD_List_Control0_Port2));
2181 //<2>.For qTD & iTD & 4K-Buffer Manage init
2182 for (i=0;i<Host20_qTD_MAX;i++)
2183 Host20_qTD_Manage_Port2[i]=Host20_MEM_FREE;
2184
2185
2186 //psAttachDevice_Port2->bDataBuffer=flib_Host20_GetStructure_Port2(Host20_MEM_TYPE_4K_BUFFER);//For Control
2187
2188
2189 //
2190 //printf("List_control 0:%x\n",(UINT16) pHost20_qHD_List_Control0_Port2);
2191 #if 1
2192 //psHost20_qHD_List_Control[0]->bType=HOST20_HD_Type_QH;
2193 flib_Host20_Allocate_QHD_Port2(pHost20_qHD_List_Control0_Port2,HOST20_HD_Type_QH,0,1,0,8);//Address=0,Head=1,EndPt=0,Size
2194
2195 flib_Host20_Allocate_QHD_Port2(pHost20_qHD_List_Control1_Port2,HOST20_HD_Type_QH,1,0,0,64);//Address=1,Head=0,EndPt=0,Size
2196
2197 #endif
2198
2199
2200
2201 #if 1
2202 flib_Host20_Allocate_QHD_Port2(pHost20_qHD_List_Bulk0_Port2,HOST20_HD_Type_QH,1,0,1,64);//Address=1,Head=0,EndPt=1,Size
2203 flib_Host20_Allocate_QHD_Port2(pHost20_qHD_List_Bulk1_Port2,HOST20_HD_Type_QH,1,0,2,64);//Address=1,Head=0,EndPt=2,Size
2204 #endif
2205
2206
2207 //<3.3>.Link the qHD (contol)
2208 #if 1
2209 pHost20_qHD_List_Control0_Port2->bNextQHDPointer=(VirtoPhyAddr((U32)pHost20_qHD_List_Control1_Port2)>>5);
2210 pHost20_qHD_List_Control1_Port2->bNextQHDPointer=(VirtoPhyAddr((U32)pHost20_qHD_List_Control0_Port2)>>5);
2211 //SetPointer_Port2(&(pHost20_qHD_List_Control0_Port2->bNextQHDPointer3),VirtoPhyAddr((UINT16)pHost20_qHD_List_Control1_Port2));
2212 //SetPointer_Port2(&(pHost20_qHD_List_Control1_Port2->bNextQHDPointer3),VirtoPhyAddr((UINT16)pHost20_qHD_List_Control0_Port2));
2213 //SetPointer_Port2(&(Host20_qHD_List_Work.bNextQHDPointer3),VirtoPhyAddr((UINT16)&Host20_qHD_List_Work));
2214 #endif
2215
2216 }
2217
2218 //====================================================================
2219 // * Function Name: flib_Host20_GetStructure_Port2
2220 // * Description:
2221 //
2222 // * Input:Type =0 =>qTD
2223 // =1 =>iTD
2224 // =2 =>4K Buffer
2225 // * OutPut: 0:Fail
2226 // ~0:Addrress
2227 //====================================================================
flib_Host20_GetStructure_Port2(U8 Type)2228 qTD_Structure *flib_Host20_GetStructure_Port2(U8 Type)
2229 {
2230 U32 i;
2231 U8 bFound;
2232 //U16 spTempqTD;
2233 qTD_Structure *spTempqTD;
2234 //iTD_Structure *spTempiTD;
2235 //siTD_Structure *spTempsiTD;
2236 bFound=0;
2237
2238 switch(Type)
2239 {
2240 case Host20_MEM_TYPE_qTD:
2241
2242 //For qTD
2243
2244 for (i=0;i<Host20_qTD_MAX;i++)
2245 if (Host20_qTD_Manage_Port2[i]==Host20_MEM_FREE)
2246 {
2247 bFound=1;
2248 Host20_qTD_Manage_Port2[i]=Host20_MEM_USED;
2249 break;
2250 }
2251
2252
2253 if (bFound==1)
2254 {
2255 //printf("USB base:%lx \n",USB_BUFFER_START_ADR);
2256
2257 spTempqTD=(qTD_Structure *)((U32)Host20_STRUCTURE_qTD_BASE_ADDRESS_Port2+i*Host20_qTD_SIZE);
2258 memset((unsigned char *)spTempqTD ,0, Host20_qTD_SIZE);
2259 spTempqTD->bTerminate=1; //Bit0
2260 spTempqTD->bStatus_Active=0; //Bit7
2261 spTempqTD->bInterruptOnComplete=1; //Bit15
2262
2263 spTempqTD->bAlternateTerminate=1;
2264 spTempqTD->bErrorCounter=3;
2265 return (spTempqTD);
2266 }
2267 else
2268 {
2269 HOSTLIB_MSG(printf("QTD underrun!\n"));
2270 }
2271
2272
2273
2274 break;
2275
2276 default:
2277 return 0;
2278 break;
2279
2280 }
2281
2282 //Not Found...
2283 //while(1)
2284 //{
2285 // printf("i:%d",i);
2286 //}
2287
2288 return (0);
2289
2290 }
2291
2292
2293 //====================================================================
2294 // * Function Name: flib_Host20_ReleaseStructure_Port2
2295 // * Description:
2296 //
2297 // * Input:Type =0 =>qTD
2298 // =1 =>iTD
2299 // =2
2300 // * OutPut: 0:Fail
2301 // ~0:Addrress
2302 //====================================================================
flib_Host20_ReleaseStructure_Port2(U8 Type,U32 pwAddress)2303 void flib_Host20_ReleaseStructure_Port2(U8 Type,U32 pwAddress)
2304 {
2305 //U8 i;
2306 U16 wReleaseNum;
2307 U8 *pData;
2308
2309 //printf("release QTD:%x\n",pwAddress);
2310 pData=(U8*)pwAddress;
2311
2312 switch(Type)
2313 {
2314 case Host20_MEM_TYPE_qTD:
2315
2316 if (pwAddress<(U32)Host20_STRUCTURE_qTD_BASE_ADDRESS_Port2)
2317 {
2318 HOSTLIB_MSG(printf("??? Memory release area fail...\n"));
2319 //while(1);
2320 }
2321
2322 if ((pwAddress-(U32)Host20_STRUCTURE_qTD_BASE_ADDRESS_Port2)==0)
2323 wReleaseNum=0;
2324 else
2325 wReleaseNum=(pwAddress-(U32)Host20_STRUCTURE_qTD_BASE_ADDRESS_Port2)/Host20_qTD_SIZE;
2326
2327 if (wReleaseNum>=Host20_qTD_MAX)//ERROR FIX Prevent Tool 070522
2328 {
2329 HOSTLIB_MSG(printf("Memory release area fail...\n"));
2330 return;
2331 //while(1);
2332 }
2333
2334
2335 Host20_qTD_Manage_Port2[wReleaseNum]=Host20_MEM_FREE;
2336
2337 // Removed, for improve the performance,
2338 // because we will clear qtd structure when we get it, so don��t have to do it when release it.
2339 //for (i=0;i<Host20_qTD_SIZE ;i++) //qTD size=32 bytes
2340 // *(pData+i)=0;
2341
2342
2343 break;
2344
2345 default:
2346
2347 //printf("??? Memory release type fail...\n");
2348 //while(1);
2349
2350 break;
2351
2352 }
2353
2354
2355 }
2356 //====================================================================
2357 // * Function Name: flib_Host20_QHD_Control_Init_Port2
2358 // * Description:
2359 //
2360 // * Input:Type =0 =>qTD
2361 // =1 =>iTD
2362 // =2
2363 // * OutPut: 0:Fail
2364 // ~0:Addrress
2365 //====================================================================
flib_Host20_QHD_Control_Init_Port2(void)2366 void flib_Host20_QHD_Control_Init_Port2(void)
2367 {
2368
2369
2370 //<1>.Init Control-0/1
2371 pHost20_qHD_List_Control0_Port2->bEdSpeed=gSpeed_Port2;
2372 //printf("bEdSpeed:%bx\n",psAttachDevice_Port2->bSpeed);
2373 pHost20_qHD_List_Control0_Port2->bInactiveOnNextTransaction=0;
2374 pHost20_qHD_List_Control0_Port2->bDataToggleControl=1;
2375
2376 pHost20_qHD_List_Control1_Port2->bEdSpeed=gSpeed_Port2;
2377 pHost20_qHD_List_Control1_Port2->bInactiveOnNextTransaction=0;
2378 pHost20_qHD_List_Control1_Port2->bDataToggleControl=1;
2379
2380 //<2>.Init Bulk-0/1
2381 pHost20_qHD_List_Bulk0_Port2->bEdSpeed=gSpeed_Port2;
2382 pHost20_qHD_List_Bulk0_Port2->bInactiveOnNextTransaction=0;
2383 pHost20_qHD_List_Bulk0_Port2->bDataToggleControl=0;
2384
2385 pHost20_qHD_List_Bulk1_Port2->bEdSpeed=gSpeed_Port2;
2386 pHost20_qHD_List_Bulk1_Port2->bInactiveOnNextTransaction=0;
2387 pHost20_qHD_List_Bulk1_Port2->bDataToggleControl=0;
2388
2389
2390 //printf("enable aynch \n");
2391 //<12>.Enable Asynchronous
2392
2393 //mbHost20_USBCMD_AsynchronousEnable_Set(); //Temp;;Bruce
2394 //printf("0x10:%02bx",XBYTE[0x2410]);
2395
2396
2397 }
2398
2399 //====================================================================
2400 // * Function Name: flib_Host20_Allocate_QHD_Port2
2401 // * Description:
2402 //
2403 // * Input:Type =0 =>qTD
2404 // =1 =>iTD
2405 // =2
2406 // * OutPut: 0:Fail
2407 // ~0:Addrress
2408 //====================================================================
flib_Host20_Allocate_QHD_Port2(qHD_Structure * psQHTemp,U8 bNextType,U8 bAddress,U8 bHead,U8 bEndPt,U32 wMaxPacketSize)2409 void flib_Host20_Allocate_QHD_Port2(qHD_Structure *psQHTemp,U8 bNextType,U8 bAddress,U8 bHead,U8 bEndPt, U32 wMaxPacketSize)
2410 {
2411 qTD_Structure *spTempqTD;
2412 //UINT32 sp;
2413
2414 psQHTemp->bTerminate=0; //Bit0
2415 psQHTemp->bType=bNextType; //Bit2~1
2416
2417 psQHTemp->bDeviceAddress=bAddress; //Bit0~6
2418 psQHTemp->bEdNumber=bEndPt; //Bit11~8
2419 psQHTemp->bHeadOfReclamationListFlag=bHead; //Bit15
2420 psQHTemp->bMaxPacketSize=wMaxPacketSize; //Bit16~26
2421 psQHTemp->bNakCounter=Host20_QHD_Nat_Counter;
2422
2423 psQHTemp->bOverlay_NextTerminate=1;
2424 psQHTemp->bOverlay_AlternateNextTerminate=1;
2425
2426 //<2>.allocate dumy qTD
2427 #if 1
2428 //<2.1>.Allocate qTD
2429 spTempqTD=(qTD_Structure *)flib_Host20_GetStructure_Port2(0);//0=>qTD
2430 psQHTemp->bOverlay_NextqTD=(VirtoPhyAddr((U32)spTempqTD)>>5);
2431 #endif
2432 //<2.3>.Active the qTD
2433 psQHTemp->bOverlay_NextTerminate=0;
2434
2435 }
2436
2437 //====================================================================
2438 // * Function Name: flib_Host20_CheckingForResult_QHD_Port2
2439 // * Description:
2440 // * Input:Type
2441 // * OutPut:
2442 //====================================================================
flib_Host20_CheckingForResult_QHD_Port2(qHD_Structure * spTempqHD)2443 UINT8 flib_Host20_CheckingForResult_QHD_Port2(qHD_Structure *spTempqHD)
2444 {
2445 UINT8 bQHStatus;
2446 U16 wIntStatus;
2447
2448 wIntStatus=mwHost20_USBSTS_Rd();
2449 //printf("USB int:%x\n",wIntStatus);
2450
2451 //<2>.Checking for the Error type interrupt => Halt the system
2452 if (wIntStatus&HOST20_USBINTR_SystemError)
2453 {
2454 DEBUG_USB(printf("???System Error... Halt the system...\n "));
2455 psAttachDevice_Port2->bSendStatusError=1;
2456
2457 }
2458 if (wIntStatus&HOST20_USBINTR_USBError) {
2459 mwHost20_USBSTS_USBError_Set();
2460 psAttachDevice_Port2->bSendStatusError=1;
2461 }
2462
2463 if (psAttachDevice_Port2->bSendStatusError==0)
2464 return HOST20_OK;
2465
2466 //<1>.Analysis the qHD Status
2467 psAttachDevice_Port2->bSendStatusError=0;
2468 //printf("??? USB Error Interrupt Event...\n");
2469 bQHStatus=spTempqHD->bOverlay_Status;
2470
2471 if (bQHStatus&HOST20_qTD_STATUS_Halted)
2472 {
2473 if (bQHStatus&HOST20_qTD_STATUS_TransactionError)
2474 {
2475 //printf("\r\n transaction error!!",0);
2476 gUsbStatus_Port2=USB_TRANS_ERROR; //trans error
2477 return HOST20_TRANSACTION_ERROR;
2478 }
2479
2480 //printf("??? qHD Status => Halted (<1>.Stall/<2>.Babble/<3>.Error Counter=0)...(Device Not Supported...)\n");
2481 spTempqHD->bOverlay_Status=0; //clear halt status
2482 spTempqHD->bOverlay_TotalBytes=0;
2483 spTempqHD->bOverlay_Direction=0;
2484 spTempqHD->bOverlay_CurrentOffset=0; //clear offset
2485 if (bQHStatus==HOST20_qTD_STATUS_Halted) //no other error status
2486 {
2487 //printf("STALL\n");
2488 return HOST20_DEVICE_STALL;
2489 }
2490 }
2491 if (bQHStatus&HOST20_qTD_STATUS_BufferError)
2492 {
2493 // kcj 2007-06-07 printf("??? qHD Status => HOST20_qTD_STATUS_BufferError...\n");
2494 }
2495 if (bQHStatus&HOST20_qTD_STATUS_Babble)
2496 {
2497 DEBUG_USB(printf("??? qHD Status => HOST20_qTD_STATUS_Babble...\n"));
2498 //psAttachDevice_Port2->bSendStatusError=0; //don't fix babble error for Bert
2499 #ifdef Enable_Low_Temperature_Patch
2500 if(gSpeed_Port2==0)
2501 {
2502 //printf("\r\n CDR toggle!!",0);
2503 UTMI2_SETXBYTE(0x0a,UTMI2_READXBYTE(0x0a)^0x10); //invert CDR_CLOCK
2504 UTMI2_ORXBYTE(0x06,0x03); //reset UTMI
2505 UTMI2_ANDXBYTE(0x06,0xfc);
2506 }
2507 #endif
2508 spTempqHD->bOverlay_Status=0;
2509 return HOST20_OK;
2510
2511 }
2512 if (bQHStatus&HOST20_qTD_STATUS_MissMicroFrame)
2513 {
2514 // kcj 2007-06-07 printf("??? qHD Status => HOST20_qTD_STATUS_MissMicroFrame...\n");
2515 }
2516 //<2>.Clear the status
2517 spTempqHD->bOverlay_Status=0;
2518
2519 return HOST20_FAIL;
2520
2521
2522 }
2523
2524 #if defined(CPU_TYPE_MIPS) || defined(CPU_TYPE_ARM)
2525 extern void MsOS_FlushMemory(void);
2526 extern void MsOS_ReadMemory(void);
USB_Chip_Read_Memory_Port2(void)2527 void USB_Chip_Read_Memory_Port2(void)
2528 {
2529 #if 0
2530 volatile unsigned int *pu8;
2531 volatile unsigned int t ;
2532
2533 // Transfer the memory to noncache memory
2534 pu8 = ((volatile unsigned int *)0xA0380000);
2535 t = pu8[0] ;
2536 t = pu8[64] ;
2537 #else
2538 MsOS_ReadMemory();
2539 #endif
2540 }
USB_Chip_Flush_Memory_Port2(void)2541 void USB_Chip_Flush_Memory_Port2(void)
2542
2543 {
2544 MsOS_FlushMemory();
2545 }
2546 #endif
2547
2548 #if 1
2549
2550 //====================================================================
2551 // * Function Name: flib_Host20_Send_qTD_Port2
2552 // * Description:
2553 // Case-1:1qTD
2554 // Case-2:2qTD
2555 // Case-3:3qTD above
2556 // * Input:Type
2557 // * OutPut: 0 => OK
2558 // 1 => TimeOut
2559 //====================================================================
flib_Host20_Send_qTD_Port2(qTD_Structure * spHeadqTD,qHD_Structure * spTempqHD,U16 wTimeOutSec)2560 UINT8 flib_Host20_Send_qTD_Port2(qTD_Structure *spHeadqTD ,qHD_Structure *spTempqHD,U16 wTimeOutSec)
2561 {
2562 UINT8 bExitLoop,bReturnValue;
2563 qTD_Structure *spNewDumyqTD;
2564 qTD_Structure *spOldDumyqTD;
2565 qTD_Structure *spReleaseqTD;
2566 qTD_Structure *spReleaseqTDNext;
2567 qTD_Structure *spLastqTD;
2568 //UINT32 wDummyTemp;
2569 //UINT32 xdata *pwData;
2570 #ifdef ATV_SERISE_USE
2571 UINT32 wTimes;
2572 UINT32 StartTime=0;
2573 #else
2574 UINT16 wTimes;
2575 UINT32 StartTime;
2576 UINT32 LastTime;
2577 UINT16 FrameIdx=0;
2578
2579 #endif
2580
2581 #ifdef ATV_SERISE_USE
2582 wTimeOutSec=wTimeOutSec;
2583 #endif
2584
2585 gUsbStatus_Port2=USB_OK;
2586 //if (wTimeOutSec==0)
2587 //{
2588 // DEBUG_USB(printf("error, timeout sec is zero\n"));
2589 //}
2590 spOldDumyqTD=(qTD_Structure*)PhytoVirAddr((( U32)(spTempqHD->bOverlay_NextqTD))<<5);
2591
2592 //spTempqHD->bOverlay_Status|=HOST20_qTD_STATUS_Halted;
2593 while (mbHost20_USBCMD_AsynchronousEnable_Rd())
2594 {
2595 mbHost20_USBCMD_AsynchronousEnable_Clr();//pause asynchronous scheduler
2596 }
2597
2598 //spHeadqTD->bTerminate=1; //set to terminate
2599 memcpy(spOldDumyqTD,spHeadqTD,Host20_qTD_SIZE);
2600 //spOldDumyqTD->bStatus_Halted=1;
2601 if(RecoveryFlag_Port2&0x1)
2602 spOldDumyqTD->bDataToggle=DataToggleBackupPort2;
2603
2604 //spOldDumyqTD->bStatus_Active=0;
2605
2606 //<2>.Prepare new dumy qTD
2607 spNewDumyqTD=spHeadqTD;
2608 memset((void *)spNewDumyqTD ,0, Host20_qTD_SIZE);
2609 spNewDumyqTD->bTerminate=1;
2610 //spNewDumyqTD->bAlternateTerminate=1;
2611 //spNewDumyqTD->bStatus_Halted=1;
2612 //<3>.Find spLastqTD & link spLastqTD to NewDumyqTD & Set NewDumyqTD->T=1
2613 spLastqTD=spOldDumyqTD;
2614 while(spLastqTD->bTerminate==0) {
2615 spLastqTD=(qTD_Structure*)PhytoVirAddr(((U32)(spLastqTD->bNextQTDPointer))<<5);
2616 };
2617
2618 spLastqTD->bNextQTDPointer=VirtoPhyAddr((U32)spNewDumyqTD)>>5;
2619
2620 spLastqTD->bTerminate=0;
2621
2622 //Link Alternate qTD pointer
2623 spLastqTD->bAlternateQTDPointer=(VirtoPhyAddr((U32)spNewDumyqTD)>>5);
2624
2625 spLastqTD->bAlternateTerminate=0;
2626
2627
2628
2629 //<4>.Set OldDumyqTD->Active=1
2630 //gwLastqTDSendOK=0;
2631 //psAttachDevice_Port2->psSendLastqTD=spLastqTD;
2632 psAttachDevice_Port2->bSendStatusError=0;
2633
2634 //Dump_QTD_Port2(spOldDumyqTD);
2635 //Dump_QTD_Port2(spNewDumyqTD);
2636
2637 while (mwHost20_USBSTS_Rd() & 0x3b)
2638 {
2639 mwHost20_USBSTS_Set(0x3b); //clear interrupt, don't clear port change int
2640 }
2641 //bExitLoop=0;
2642 //spOldDumyqTD->bStatus_Halted=0;
2643 //spOldDumyqTD->bStatus_Halted=0;
2644 spOldDumyqTD->bStatus_Active=1;
2645 #if defined(CPU_TYPE_MIPS) || defined(CPU_TYPE_ARM)
2646 USB_Chip_Flush_Memory_Port2();
2647 #endif
2648
2649 while (mbHost20_USBCMD_AsynchronousEnable_Rd()==0)
2650 {
2651 mbHost20_USBCMD_AsynchronousEnable_Set();//re start asynchronous scheduler
2652 }
2653 //spTempqHD->bOverlay_Status&=~HOST20_qTD_STATUS_Halted;
2654
2655 //wait until asynchronous scheduler is idle
2656
2657 //mbHost20_USBCMD_RunStop_Set();
2658
2659 //spTempqHD->bOverlay_Status&=~0x40; //clr HALT bit, start this queue head
2660 //XBYTE[0x2410]|=1;//start run
2661 //wDummyTemp=0;
2662 wTimes=0;
2663 #ifndef ATV_SERISE_USE
2664 StartTime=MsOS_GetSystemTime();
2665 LastTime=StartTime;
2666 FrameIdx=mwHost20_FrameIndex_Rd();
2667 #endif
2668 //<5>.Waiting for result
2669 //EAL=0;
2670 while (1)
2671 {
2672 #ifndef ATV_SERISE_USE
2673 msAPI_Timer_ResetWDT();
2674 #endif
2675
2676 #ifdef ATV_SERISE_USE
2677 wTimes++;
2678 #endif
2679 if(mwHost20_USBSTS_Rd()& HOST20_USBINTR_CompletionOfTransaction) //wait until Status_Active become 0
2680 {
2681 #if defined(CPU_TYPE_MIPS) || defined(CPU_TYPE_ARM)
2682 USB_Chip_Read_Memory_Port2();
2683 #endif
2684 if (spOldDumyqTD->bStatus_Active==0)
2685 {
2686 bReturnValue=HOST20_OK;
2687 break;
2688 }
2689 }
2690 //if (bExitLoop) break;
2691 #if 1
2692 if (mwHost20_USBSTS_Rd()&(HOST20_USBINTR_SystemError+HOST20_USBINTR_USBError))
2693 {
2694 bReturnValue=HOST20_OK;
2695 //if (spOldDumyqTD->bStatus_Active==1)
2696 //{
2697 // printf("something wrong..USBINTR:%02bx\n",mwHost20_USBSTS_Rd());
2698 // printf("QH status:%02bx\n",spTempqHD->bOverlay_Status);
2699 //}
2700 break; //USB interrupt happened
2701 }
2702 #endif
2703 #if 1
2704 //if (gwOTG_Timer_Counter>wTimeOutSec)
2705 // wTimes++;
2706 //if (wTimes > wTimeOutSec*400)
2707 if (mwHost20_PORTSC_ConnectStatus_Rd()==0)
2708 {
2709 //return HOST20_FATAL;
2710 bReturnValue = HOST20_FATAL;
2711 break;
2712 }
2713 //if (mwHost20_PORTSC_ConnectChange_Rd())
2714 //{
2715 // gDeviceFatalError=TRUE;
2716 // mwHost20_PORTSC_ConnectChange_Set();
2717 // return HOST20_FATAL; //usb has been plug out and in
2718 //}
2719 #ifndef ATV_SERISE_USE
2720 if (MsOS_Timer_DiffTimeFromNow(LastTime) >(U32)3) //over 1 mini sec
2721 {
2722
2723 if (mwHost20_FrameIndex_Rd()==FrameIdx)
2724 {
2725 HOSTLIB_MSG(printf("1C stop,timeout !!\n"));
2726 gUsbStatus_Port2=USB_TIMEOUT;
2727 bReturnValue=HOST20_FATAL; //ESD , USB hang,should be timeout
2728 break;
2729 }
2730 FrameIdx=mwHost20_FrameIndex_Rd();
2731 LastTime=MsOS_GetSystemTime();
2732
2733 }
2734 if (MsOS_Timer_DiffTimeFromNow(StartTime) > (U32)wTimeOutSec *1000)
2735 #else
2736 if(wTimes>0x80000)
2737 #endif
2738 {
2739 #if 0
2740 printf("\nQH1:\n");
2741 Dump_Data(0xf800,0x30);
2742 printf("\nQH2:\n");
2743 Dump_Data(0xf840,0x30);
2744 printf("\nQH3:\n");
2745 Dump_Data(0xf880,0x30);
2746 printf("\nQH4:\n");
2747 Dump_Data(0xf8c0,0x30);
2748 printf("\n");
2749 Dump_Data(0xfa80,0x20);
2750 printf("\n");
2751 Dump_Data(0xfb00,0x20);
2752 printf("\n");
2753 Dump_Data(0xfae0,0x20);
2754 printf("\n");
2755 Dump_Data(0xfaa0,0x20);
2756 printf("\n");
2757 Dump_Data(0xfac0,0x20);
2758
2759 printf("\nQH->%x\n",(U16)spTempqHD);
2760 //Dump_Data((U16)spTempqHD,0x30);
2761
2762 printf("\nqtd->\n");
2763 Dump_Data((U16)spOldDumyqTD,0x20);
2764 printf("\nEHCI REG:\n");
2765 Dump_Data(0x2400,0x50);
2766 #endif
2767 bExitLoop=2;
2768 bReturnValue=HOST20_FATAL;
2769 gUsbStatus_Port2=USB_TIMEOUT;
2770 //gDeviceFatalError=TRUE;
2771
2772 //MINI_DEBUG2(printf("Time Out:%02bx\n",XBYTE[0x2430]));
2773 HOSTLIB_MSG(printf("USB timeout !!\n"));
2774 break;
2775 }
2776
2777 #endif
2778 //}
2779 }
2780 #ifndef ATV_SERISE_USE
2781 msAPI_Timer_ResetWDT(); //in case spend too much time at polling
2782 #endif
2783 while (mbHost20_USBCMD_AsynchronousEnable_Rd())
2784 {
2785 mbHost20_USBCMD_AsynchronousEnable_Clr();//pause asynchronous scheduler
2786 }
2787
2788 //<6>.Checking the Result
2789 if (bReturnValue!=HOST20_FATAL)
2790 bReturnValue=flib_Host20_CheckingForResult_QHD_Port2(spTempqHD);
2791 if (bReturnValue==HOST20_TRANSACTION_ERROR)
2792 {
2793 //printf("Transaction Error\n");
2794
2795 spTempqHD->bOverlay_Status=0; //clear halt status
2796 //SetPointer_Port2(&(spTempqHD->bOverlay_NextqTD3),0);
2797 //SetPointer_Port2(&(spTempqHD->bOverlay_AlternateqTD3),0);
2798 //SetPointer_Port2(&(spTempqHD->bOverlay_CurqTD3),VirtoPhyAddr((UINT16)spNewDumyqTD));
2799 spTempqHD->bOverlay_CurrentqTD=(VirtoPhyAddr((U32)spNewDumyqTD)>>5);
2800
2801 //printf("TotalBytes_Port2:%x\n",TotalBytes_Port2);
2802
2803 //printf("spNewDumyqTD->%x\n",(U16)spNewDumyqTD);
2804 //printf("spOldDumyqTD->%x\n",(U16)spOldDumyqTD);
2805 //Dump_Data((U16)spOldDumyqTD,0x20);
2806 //printf("\nQH->%x\n",(U16)spTempqHD);
2807 //Dump_Data((U16)spTempqHD,0x20);
2808
2809 }
2810 TotalBytes_Port2= spOldDumyqTD->bTotalBytes;
2811
2812 //<5>.Release the all the qTD (Not include spNewDumyqTD)
2813 #if 1
2814 spReleaseqTD=spOldDumyqTD;
2815 do {
2816 //spReleaseqTDNext=((UINT32)(spReleaseqTD->bNextQTDPointerL))<<5 + ((UINT32)(spReleaseqTD->bNextQTDPointerH))<<16 ;
2817 spReleaseqTDNext=(qTD_Structure*)PhytoVirAddr(((U32)(spReleaseqTD->bNextQTDPointer))<<5);
2818 DataToggleBackupPort2=spOldDumyqTD->bDataToggle;
2819
2820 flib_Host20_ReleaseStructure_Port2(Host20_MEM_TYPE_qTD,(U32)spReleaseqTD);
2821
2822 spReleaseqTD=spReleaseqTDNext;
2823 } while(((UINT32)spReleaseqTD)!=((UINT32)spNewDumyqTD));
2824 #endif
2825
2826 // Double Check the QH overlay status. Adjust it if need.
2827 if( spTempqHD->bOverlay_NextqTD != (VirtoPhyAddr(( U32)spNewDumyqTD)>>5)
2828 || spTempqHD->bOverlay_Status & BIT7 )
2829 {
2830 // If chain qTDs after disconnection/qTD timeout, QH overlay will not be advanced by HW.
2831 // It muss up qTD chain layout. QH doesn't stop at old dumy and stare at new dumy.
2832 // SW advance QH overlay manually no matter HW advancing or not.
2833 // Run bit is cleared by HQ when disconnection, so it is safe to modify the QH.
2834
2835 HOSTLIB_MSG(printf("[Warning] Adjust bad qTD chain..\r\n"));
2836
2837 spTempqHD->bOverlay_Status = spTempqHD->bOverlay_Status & ~BIT7;
2838 spTempqHD->bOverlay_CurrentqTD = (VirtoPhyAddr(( U32)spOldDumyqTD)>>5);
2839 spTempqHD->bOverlay_NextqTD = (VirtoPhyAddr(( U32)spNewDumyqTD)>>5);
2840 spTempqHD->bOverlay_AlternateqTD = (VirtoPhyAddr(( U32)spNewDumyqTD)>>5);
2841 }
2842
2843 return (bReturnValue);
2844 }
2845 #endif
2846
2847 #ifdef ENABLE_HOST_TEST
2848 extern void MDrv_UsbSendSE0_Port2(void);
2849 extern void MDrv_UsbSendTestJ_Port2(void);
2850 extern void MDrv_UsbSendTestK_Port2(void);
2851 extern void MDrv_UsbSendTestPacket_Port2(void);
2852
flib_Host20_Issue_Control_Test_Mode_Port2(UINT8 bEdNum,UINT8 * pbCmd,UINT16 hwDataSize,UINT8 * pbData)2853 UINT8 flib_Host20_Issue_Control_Test_Mode_Port2 (UINT8 bEdNum,UINT8* pbCmd,UINT16 hwDataSize,UINT8* pbData)
2854 {
2855 qTD_Structure *spTempqTD;
2856 //UINT16 bpDataPage;
2857 UINT8 bReturnValue;
2858 //UINT8 i;
2859 qHD_Structure *qh_ptr;
2860
2861 if (bEdNum==0)
2862 qh_ptr=pHost20_qHD_List_Control0_Port2;
2863 else
2864 qh_ptr=pHost20_qHD_List_Control1_Port2;
2865
2866 //<0>.Allocate qTD & Data Buffer
2867 spTempqTD=flib_Host20_GetStructure_Port2(Host20_MEM_TYPE_qTD);//0=>qTD
2868 //bpDataPage=sAttachDevice.bDataBuffer; //2//2k buffer
2869 //bpDataPage=sAttachDevice.bDataBuffer;
2870 //<2.1>.Setup packet
2871 //<A>.Fill qTD
2872 spTempqTD->bPID=HOST20_qTD_PID_SETUP; //Bit8~9
2873 spTempqTD->bTotalBytes=8; //Bit16~30
2874
2875 spTempqTD->bDataToggle=0; //Bit31
2876 //FillBufferArray(spTempqTD, bpDataPage);
2877 memcpy(pUsbCtrlBuf_Port2,pbCmd,8);
2878
2879 spTempqTD->ArrayBufferPointer_Word[0]=VirtoPhyAddr((U32)pUsbCtrlBuf_Port2);
2880
2881 bReturnValue=flib_Host20_Send_qTD_Port2(spTempqTD ,qh_ptr,gUsbTimeout_Port2);
2882
2883 if (bReturnValue>0)
2884 return bReturnValue;
2885
2886 MsOS_DelayTask(15000); //FOR TEST MODE
2887 //<A>.Fill qTD
2888 spTempqTD=flib_Host20_GetStructure_Port2(Host20_MEM_TYPE_qTD);//0=>qTD
2889 spTempqTD->bPID=HOST20_qTD_PID_IN; //Bit8~9
2890 spTempqTD->bTotalBytes=hwDataSize; //Bit16~30
2891
2892 spTempqTD->bDataToggle=1; //Bit31
2893
2894 spTempqTD->ArrayBufferPointer_Word[0]=VirtoPhyAddr((U32)pUsbCtrlBuf_Port2);
2895
2896 bReturnValue=flib_Host20_Send_qTD_Port2(spTempqTD ,qh_ptr,gUsbTimeout_Port2);
2897
2898 if (bReturnValue>0)
2899 return bReturnValue;
2900 //printf("c4");
2901
2902
2903 //<C>.Waiting for result
2904 memcpy(pbData,pUsbCtrlBuf_Port2,hwDataSize);
2905
2906 //Dump_Data((UINT16)pbData,hwDataSize);
2907
2908 //<2.3>.Out packet
2909
2910 //<A>.Fill qTD
2911 spTempqTD=flib_Host20_GetStructure_Port2(Host20_MEM_TYPE_qTD);//0=>qTD
2912 spTempqTD->bPID=HOST20_qTD_PID_OUT; //Bit8~9
2913 spTempqTD->bTotalBytes=0; //Bit16~30
2914
2915 spTempqTD->bDataToggle=1; //Bit31
2916
2917 //<B>.Send qTD
2918 //bReturnValue=flib_Host20_Send_qTD(spTempqTD ,psHost20_qHD_List_Control[bEdNum],5);
2919 bReturnValue=flib_Host20_Send_qTD_Port2(spTempqTD ,qh_ptr,gUsbTimeout_Port2);
2920
2921 return (bReturnValue);
2922 }
2923
GetDeviceDescriptor_Port2(void)2924 void GetDeviceDescriptor_Port2(void)
2925 {
2926 UINT8 bCMD[8];
2927
2928 memcpy(bCMD,OTGH_GETDESCRIPTOR_DEVICE_8_PORT2,8);
2929
2930 flib_Host20_Issue_Control_Port2(1,bCMD,8,(UINT8*)&(psAttachDevice_Port2->sDD));
2931 }
2932
EnterTestMode_Port2(void)2933 void EnterTestMode_Port2(void)
2934 {
2935 UINT8 bCMD[8];
2936 #if 0
2937 if ((sAttachDevice.sDD.bPIDHighByte==0x01)&&(sAttachDevice.sDD.bPIDLowByte==0x06))
2938 {
2939 //--- do suspend resume test
2940 // first, SOF for 15 seconds
2941 StartTime=MDrv_Timer_GetTime0();
2942
2943 printf("\r\n start sending SOF..",0);
2944 while (1)
2945 {
2946 msAPI_Timer_ResetWDT(); //in case watchdog timer is too short
2947
2948 if ((MDrv_Timer_GetTime0()-StartTime) > 1000) //SOF for 15 sec
2949 break;
2950
2951 }
2952 printf("\r\n suspend",0);
2953 mbHost20_USBCMD_RunStop_Clr();
2954 mwHost20_PORTSC_ForceSuspend_Set(); //suspend the device
2955 StartTime=MDrv_Timer_GetTime0();
2956
2957 while (1)
2958 {
2959 msAPI_Timer_ResetWDT(); //in case watchdog timer is too short
2960
2961 if ((MDrv_Timer_GetTime0()-StartTime) > 1000) //SOF for 15 sec
2962 break;
2963 }
2964 printf("\r\n resume\n",0);
2965 mwHost20_PORTSC_ForceResume_Set();
2966 mbHost20_USBCMD_RunStop_Set();
2967
2968 }
2969 else
2970 #endif
2971 if ((psAttachDevice_Port2->sDD.bPIDHighByte==0x01)&&(psAttachDevice_Port2->sDD.bPIDLowByte==0x01))
2972 // test_SE0
2973 {
2974 MDrv_UsbSendSE0_Port2();
2975 }
2976 else if ((psAttachDevice_Port2->sDD.bPIDHighByte==0x01)&&(psAttachDevice_Port2->sDD.bPIDLowByte==0x02))
2977 // test_J
2978 {
2979 MDrv_UsbSendTestJ_Port2();
2980 }
2981 else if ((psAttachDevice_Port2->sDD.bPIDHighByte==0x01)&&(psAttachDevice_Port2->sDD.bPIDLowByte==0x03))
2982 // test_J
2983 {
2984 MDrv_UsbSendTestK_Port2();
2985 }
2986 else if ((psAttachDevice_Port2->sDD.bPIDHighByte==0x01)&&(psAttachDevice_Port2->sDD.bPIDLowByte==0x04))
2987 // test_J
2988 {
2989 MDrv_UsbSendTestPacket_Port2();
2990 }
2991 else if ((psAttachDevice_Port2->sDD.bPIDHighByte==0x01)&&(psAttachDevice_Port2->sDD.bPIDLowByte==0x07))
2992 //single step get device descriptor
2993 {
2994 printf("\r\n start sending SOF..\n");
2995
2996 MsOS_DelayTask(15000);
2997
2998 printf("\r\n Get device descriptor.\n");
2999
3000 GetDeviceDescriptor_Port2();
3001 }
3002 else if ((psAttachDevice_Port2->sDD.bPIDHighByte==0x01)&&(psAttachDevice_Port2->sDD.bPIDLowByte==0x08))
3003 //single step get device descriptor
3004 {
3005 printf("\r\n Get device descriptor.\n");
3006 memcpy(bCMD,OTGH_GETDESCRIPTOR_DEVICE_PORT2,8);
3007
3008 flib_Host20_Issue_Control_Test_Mode_Port2(1,bCMD,0x12,(UINT8*)&(psAttachDevice_Port2->sDD));
3009 }
3010
3011 }
3012
3013 #endif //ENABLE_HOST_TEST
3014 #endif //#if defined(MSOS_TYPE_NOS)
3015
3016