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