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