| /*******************************************************************************
|
|
|
| This software file (the "File") is distributed by Marvell International Ltd.
|
| or its affiliate(s) under the terms of the GNU General Public License Version 2,
|
| June 1991 (the "License"). You may use, redistribute and/or modify this File
|
| in accordance with the terms and conditions of the License, a copy of which
|
| is available along with the File in the license.txt file or by writing to the
|
| Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
|
| or on the worldwide web at http://www.gnu.org/licenses/gpl.txt.
|
|
|
| THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE IMPLIED
|
| WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE ARE EXPRESSLY
|
| DISCLAIMED. The GPL License provides additional details about this warranty
|
| disclaimer.
|
|
|
| (C) Copyright 2004 - 2007 Marvell Semiconductor Israel Ltd. All Rights Reserved.
|
| (C) Copyright 1999 - 2004 Chipidea Microelectronica, S.A. All Rights Reserved.
|
|
|
| *******************************************************************************/
|
| |
| #include "usb/api/mvUsbDevApi.h" |
| #include "usb/device/mvUsbDevPrv.h" |
| |
| |
| /*FUNCTION*------------------------------------------------------------- |
| * |
| * Function Name : _usb_device_unstall_endpoint |
| * Returned Value : USB_OK or error code |
| * Comments : |
| * Unstalls the endpoint in specified direction |
| * |
| *END*-----------------------------------------------------------------*/ |
| void _usb_device_unstall_endpoint |
| ( |
| /* [IN] the USB_USB_dev_initialize state structure */ |
| _usb_device_handle handle, |
| |
| /* [IN] the Endpoint number */ |
| uint_8 ep_num, |
| |
| /* [IN] direction */ |
| uint_8 direction |
| ) |
| { /* Body */ |
| USB_DEV_STATE_STRUCT_PTR usb_dev_ptr; |
| int lockKey; |
| |
| usb_dev_ptr = (USB_DEV_STATE_STRUCT_PTR)handle; |
| |
| lockKey = USB_lock(); |
| |
| _usb_dci_vusb20_unstall_endpoint(handle, ep_num, direction); |
| |
| USB_unlock(lockKey); |
| |
| } /* EndBody */ |
| |
| /*FUNCTION*---------------------------------------------------------------- |
| * |
| * Function Name : _usb_device_get_status |
| * Returned Value : USB_OK or error code |
| * Comments : |
| * Provides API to access the USB internal state. |
| * |
| *END*--------------------------------------------------------------------*/ |
| uint_8 _usb_device_get_status |
| ( |
| /* [IN] Handle to the USB device */ |
| _usb_device_handle handle, |
| |
| /* [IN] What to get the status of */ |
| uint_8 component, |
| |
| /* [OUT] The requested status */ |
| uint_16_ptr status |
| ) |
| { /* Body */ |
| USB_DEV_STATE_STRUCT_PTR usb_dev_ptr; |
| int lockKey; |
| |
| usb_dev_ptr = (USB_DEV_STATE_STRUCT_PTR)handle; |
| |
| lockKey = USB_lock(); |
| |
| switch (component) |
| { |
| case ARC_USB_STATUS_DEVICE_STATE: |
| *status = usb_dev_ptr->USB_STATE; |
| break; |
| |
| case ARC_USB_STATUS_DEVICE: |
| *status = usb_dev_ptr->USB_DEVICE_STATE; |
| break; |
| |
| case ARC_USB_STATUS_INTERFACE: |
| *status = 0; |
| break; |
| |
| case ARC_USB_STATUS_ADDRESS: |
| *status = usb_dev_ptr->DEVICE_ADDRESS; |
| break; |
| |
| case ARC_USB_STATUS_CURRENT_CONFIG: |
| *status = usb_dev_ptr->USB_CURR_CONFIG; |
| break; |
| |
| case ARC_USB_STATUS_SOF_COUNT: |
| *status = usb_dev_ptr->USB_SOF_COUNT; |
| break; |
| |
| default: |
| USB_unlock(lockKey); |
| USB_printf("_usb_device_get_status, bad status\n"); |
| return USBERR_BAD_STATUS; |
| |
| } /* Endswitch */ |
| USB_unlock(lockKey); |
| |
| return USB_OK; |
| } /* EndBody */ |
| |
| /*FUNCTION*---------------------------------------------------------------- |
| * |
| * Function Name : _usb_device_set_status |
| * Returned Value : USB_OK or error code |
| * Comments : |
| * Provides API to set internal state |
| * |
| *END*--------------------------------------------------------------------*/ |
| uint_8 _usb_device_set_status |
| ( |
| /* [IN] Handle to the usb device */ |
| _usb_device_handle handle, |
| |
| /* [IN] What to set the status of */ |
| uint_8 component, |
| |
| /* [IN] What to set the status to */ |
| uint_16 setting |
| ) |
| { /* Body */ |
| USB_DEV_STATE_STRUCT_PTR usb_dev_ptr; |
| int lockKey; |
| |
| ARC_DEBUG_TRACE(ARC_DEBUG_FLAG_STATUS, |
| "set_status: component=0x%x, value=0x%x\n", component, setting); |
| |
| usb_dev_ptr = (USB_DEV_STATE_STRUCT_PTR)handle; |
| lockKey = USB_lock(); |
| |
| switch (component) |
| { |
| case ARC_USB_STATUS_DEVICE_STATE: |
| usb_dev_ptr->USB_STATE = setting; |
| break; |
| |
| case ARC_USB_STATUS_DEVICE: |
| usb_dev_ptr->USB_DEVICE_STATE = setting; |
| break; |
| |
| case ARC_USB_STATUS_INTERFACE: |
| break; |
| |
| case ARC_USB_STATUS_CURRENT_CONFIG: |
| usb_dev_ptr->USB_CURR_CONFIG = setting; |
| break; |
| |
| case ARC_USB_STATUS_SOF_COUNT: |
| usb_dev_ptr->USB_SOF_COUNT = setting; |
| break; |
| |
| case ARC_USB_FORCE_FULL_SPEED: |
| _usb_dci_vusb20_set_speed_full((pointer)usb_dev_ptr, setting); |
| break; |
| |
| case ARC_USB_PHY_LOW_POWER_SUSPEND: |
| _usb_dci_vusb20_suspend_phy((pointer)usb_dev_ptr, setting); |
| break; |
| |
| case ARC_USB_STATUS_ADDRESS: |
| usb_dev_ptr->DEVICE_ADDRESS = setting; |
| |
| _usb_dci_vusb20_set_address((pointer)usb_dev_ptr, setting); |
| break; |
| |
| case ARC_USB_STATUS_TEST_MODE: |
| _usb_dci_vusb20_set_test_mode(handle, setting); |
| break; |
| |
| default: |
| USB_unlock(lockKey); |
| USB_printf("_usb_device_set_status, bad status\n"); |
| return USBERR_BAD_STATUS; |
| |
| } /* Endswitch */ |
| |
| USB_unlock(lockKey); |
| |
| return USB_OK; |
| } /* EndBody */ |
| |
| /*FUNCTION*------------------------------------------------------------- |
| * |
| * Function Name : _usb_device_stall_endpoint |
| * Returned Value : USB_OK or error code |
| * Comments : |
| * Stalls the endpoint. |
| * |
| *END*-----------------------------------------------------------------*/ |
| void _usb_device_stall_endpoint |
| ( |
| /* [IN] the USB_USB_dev_initialize state structure */ |
| _usb_device_handle handle, |
| |
| /* [IN] the Endpoint number */ |
| uint_8 ep_num, |
| |
| /* [IN] direction */ |
| uint_8 direction |
| ) |
| { /* Body */ |
| USB_DEV_STATE_STRUCT_PTR usb_dev_ptr; |
| int lockKey;
|
| |
| usb_dev_ptr = (USB_DEV_STATE_STRUCT_PTR)handle; |
| |
| lockKey = USB_lock();
|
|
|
| _usb_dci_vusb20_stall_endpoint(handle, ep_num, direction);
|
|
|
| USB_unlock(lockKey); |
| |
| } /* EndBody */ |
|
|
| /*FUNCTION*-------------------------------------------------------------
|
| *
|
| * Function Name : _usb_device_is_endpoint_stalled
|
| * Returned Value : USB_OK or error code
|
| * Comments :
|
| * Stalls the endpoint.
|
| *
|
| *END*-----------------------------------------------------------------*/
|
| uint_8 _usb_device_is_endpoint_stalled
|
| (
|
| /* [IN] the USB_USB_dev_initialize state structure */
|
| _usb_device_handle handle,
|
|
|
| /* [IN] the Endpoint number */
|
| uint_8 ep_num,
|
|
|
| /* [IN] direction */
|
| uint_8 direction
|
| )
|
| { /* Body */
|
| USB_DEV_STATE_STRUCT_PTR usb_dev_ptr;
|
| uint_8 val;
|
| int lockKey;
|
|
|
| usb_dev_ptr = (USB_DEV_STATE_STRUCT_PTR)handle;
|
|
|
| lockKey = USB_lock();
|
|
|
| val = _usb_dci_vusb20_is_endpoint_stalled(handle, ep_num, direction);
|
|
|
| USB_unlock(lockKey);
|
|
|
| return val;
|
|
|
| } /* EndBody */
|
|
|
| |
| /*FUNCTION*------------------------------------------------------------- |
| * |
| * Function Name : _usb_device_process_resume |
| * Returned Value : USB_OK or error code |
| * Comments : |
| * Process Resume event |
| * |
| *END*-----------------------------------------------------------------*/ |
| void _usb_device_assert_resume |
| ( |
| /* [IN] the USB_USB_dev_initialize state structure */ |
| _usb_device_handle handle |
| ) |
| { /* Body */ |
| USB_DEV_STATE_STRUCT_PTR usb_dev_ptr; |
| |
| usb_dev_ptr = (USB_DEV_STATE_STRUCT_PTR)handle; |
| |
| _usb_dci_vusb20_assert_resume(handle); |
| |
| } /* EndBody */ |
| |
| |
| /***************************/ |
| /* ARC USB Debug functions */ |
| /***************************/ |
| void _usb_status(void* usbHandle) |
| { |
| USB_DEV_STATE_STRUCT* pUsbDev = (USB_DEV_STATE_STRUCT*)usbHandle; |
| |
| if(pUsbDev == NULL) |
| { |
| USB_printf("USB Device core is not initialized\n"); |
| return; |
| } |
| |
| USB_printf("\n\tUSB Status\n\n"); |
| |
| USB_printf("DEV_NUM=%d, DEV_ADDR=%d, CAP_REGS=0x%x, DEV_REGS=0x%x, MAX_EP=%d\n", |
| pUsbDev->DEV_NUM, |
| pUsbDev->DEVICE_ADDRESS, |
| (unsigned)pUsbDev->CAP_REGS_PTR, |
| (unsigned)pUsbDev->DEV_PTR, |
| pUsbDev->MAX_ENDPOINTS); |
| |
| USB_printf("BUS_RESET=%s, STATE=0x%02x, DEV_STATE=0x%02x, SPEED=%d, ERRORS=%d, ERROR_STATE=0x%04x\n", |
| pUsbDev->BUS_RESETTING ? "Yes" : "No", |
| pUsbDev->USB_STATE, |
| pUsbDev->USB_DEVICE_STATE, |
| pUsbDev->SPEED, |
| pUsbDev->ERRORS, |
| pUsbDev->ERROR_STATE);
|
| |
| USB_printf("EP_QUEUE_HEAD: SIZE=%d, BASE=%p (0x%08x), ALIGNED=%p, SERVICE_HEAD=%p\n", |
| pUsbDev->EP_QUEUE_HEAD_SIZE, |
| pUsbDev->EP_QUEUE_HEAD_BASE, |
| pUsbDev->EP_QUEUE_HEAD_PHYS, |
| pUsbDev->EP_QUEUE_HEAD_PTR, |
| pUsbDev->SERVICE_HEAD_PTR); |
| |
| USB_printf("XD: BASE=%p, HEAD=%p, TAIL=%p, ENTRIES=%d, SCRATCH=%p, TEMP=%p\n", |
| pUsbDev->XD_BASE, |
| pUsbDev->XD_HEAD, |
| pUsbDev->XD_TAIL, |
| pUsbDev->XD_ENTRIES, |
| pUsbDev->XD_SCRATCH_STRUCT_BASE, |
| pUsbDev->TEMP_XD_PTR); |
| |
| USB_printf("DTD: SIZE=%d, BASE=%p (0x%08x), ALIGNED=%p, HEAD=0x%08x, TAIL=0x%08x, ENTRIES=%d, SCRATCH=%p\n", |
| pUsbDev->DTD_SIZE, |
| pUsbDev->DTD_BASE_PTR, |
| pUsbDev->DTD_BASE_PHYS, |
| pUsbDev->DTD_ALIGNED_BASE_PTR, |
| pUsbDev->DTD_HEAD, |
| pUsbDev->DTD_TAIL, |
| pUsbDev->DTD_ENTRIES, |
| pUsbDev->SCRATCH_STRUCT_BASE); |
| } |
| |
| void _usb_stats(void* usbHandle) |
| { |
| USB_DEV_STATE_STRUCT* pUsbDev = (USB_DEV_STATE_STRUCT*)usbHandle; |
| USB_STATS* pUsbStats = &pUsbDev->STATS; |
| int i; |
| |
| USB_printf("\n\tUSB Statistics\n\n"); |
| |
| USB_printf("isr=%u, empty_isr=%u, reset=%u, setup=%u, read_setup=%u\n", |
| pUsbStats->usb_isr_count, pUsbStats->usb_empty_isr_count, |
| pUsbStats->usb_reset_count, pUsbStats->usb_setup_count, |
| pUsbStats->usb_read_setup_count); |
| |
| USB_printf("recv=%u, send=%u, add=%u (%u), cancel=%u\n", |
| pUsbStats->usb_recv_count, pUsbStats->usb_send_count, |
| pUsbStats->usb_add_count, pUsbStats->usb_add_not_empty_count, |
| pUsbStats->usb_cancel_count); |
| |
| USB_printf("free_XD=%u, free_dTD=%u\n", |
| pUsbStats->free_XD_count, pUsbStats->free_dTD_count); |
| |
| USB_printf("complete_isr=%u, complete=%u, empty_complete=%u, max_complete=%u\n", |
| pUsbStats->usb_complete_isr_count, pUsbStats->usb_complete_count, |
| pUsbStats->usb_empty_complete_count, pUsbStats->usb_complete_max_count); |
| |
| USB_printf("port_change=%u, suspend=%u\n", |
| pUsbStats->usb_port_change_count, pUsbStats->usb_suspend_count); |
| for(i=0; i<(pUsbDev->MAX_ENDPOINTS); i++) |
| { |
| if( (pUsbStats->usb_complete_ep_count[i*2] == 0) && |
| (pUsbStats->usb_complete_ep_count[i*2+1] == 0) ) |
| continue; |
| |
| USB_printf("EP #%d: RECV (OUT) = %3u, \tSEND (IN) = %u\n", i, |
| pUsbStats->usb_complete_ep_count[i*2], |
| pUsbStats->usb_complete_ep_count[i*2+1]); |
| } |
| USB_printf("\n"); |
| } |
| |
| void _usb_clear_stats(void* usbHandle) |
| { |
| USB_DEV_STATE_STRUCT* pUsbDev = (USB_DEV_STATE_STRUCT*)usbHandle; |
| |
| USB_memzero(&pUsbDev->STATS, sizeof(pUsbDev->STATS)); |
| } |
| |
| void _usb_regs(void* usbHandle) |
| { |
| USB_DEV_STATE_STRUCT* pUsbDev = (USB_DEV_STATE_STRUCT*)usbHandle; |
| VUSB20_REG_STRUCT* cap_regs, *dev_regs; |
| int dev_num; |
| |
| if(pUsbDev == NULL) |
| { |
| USB_printf("USB Device core is not initialized\n"); |
| return; |
| } |
| USB_printf("\n\tUSB Capability Registers\n\n"); |
| |
| cap_regs = pUsbDev->CAP_REGS_PTR; |
| USB_printf("CAPLENGTH_HCIVER (0x%08x) = 0x%08x\n", |
| (unsigned)&cap_regs->REGISTERS.CAPABILITY_REGISTERS.CAPLENGTH_HCIVER, |
| (unsigned)USB_32BIT_LE(cap_regs->REGISTERS.CAPABILITY_REGISTERS.CAPLENGTH_HCIVER)); |
| |
| USB_printf("DCI_VERSION (0x%08x) = 0x%08x\n", |
| (unsigned)&cap_regs->REGISTERS.CAPABILITY_REGISTERS.DCI_VERSION, |
| (unsigned)USB_32BIT_LE(cap_regs->REGISTERS.CAPABILITY_REGISTERS.DCI_VERSION)); |
| |
| USB_printf("DCC_PARAMS (0x%08x) = 0x%08x\n", |
| (unsigned)&cap_regs->REGISTERS.CAPABILITY_REGISTERS.DCC_PARAMS, |
| (unsigned)USB_32BIT_LE(cap_regs->REGISTERS.CAPABILITY_REGISTERS.DCC_PARAMS)); |
| |
| dev_regs = pUsbDev->DEV_PTR; |
| dev_num = pUsbDev->DEV_NUM; |
| USB_printf("\n\tUSB Device Operational Registers\n\n"); |
| |
| USB_printf("USB_CMD (0x%08x) = 0x%08x\n", |
| (unsigned)&dev_regs->REGISTERS.OPERATIONAL_DEVICE_REGISTERS.USB_CMD, |
| (unsigned)USB_32BIT_LE(dev_regs->REGISTERS.OPERATIONAL_DEVICE_REGISTERS.USB_CMD)); |
| |
| USB_printf("USB_STS (0x%08x) = 0x%08x\n", |
| (unsigned)&dev_regs->REGISTERS.OPERATIONAL_DEVICE_REGISTERS.USB_STS, |
| (unsigned)USB_32BIT_LE(dev_regs->REGISTERS.OPERATIONAL_DEVICE_REGISTERS.USB_STS)); |
| |
| USB_printf("USB_INTR (0x%08x) = 0x%08x\n", |
| (unsigned)&dev_regs->REGISTERS.OPERATIONAL_DEVICE_REGISTERS.USB_INTR, |
| (unsigned)USB_32BIT_LE(dev_regs->REGISTERS.OPERATIONAL_DEVICE_REGISTERS.USB_INTR)); |
| |
| USB_printf("USB_FRINDEX (0x%08x) = 0x%08x\n", |
| (unsigned)&dev_regs->REGISTERS.OPERATIONAL_DEVICE_REGISTERS.USB_FRINDEX, |
| (unsigned)USB_32BIT_LE(dev_regs->REGISTERS.OPERATIONAL_DEVICE_REGISTERS.USB_FRINDEX)); |
| |
| /* Skip CTRLDSSEGMENT register */ |
| USB_printf("DEVICE_ADDR (0x%08x) = 0x%08x\n", |
| (unsigned)&dev_regs->REGISTERS.OPERATIONAL_DEVICE_REGISTERS.DEVICE_ADDR, |
| (unsigned)USB_32BIT_LE(dev_regs->REGISTERS.OPERATIONAL_DEVICE_REGISTERS.DEVICE_ADDR)); |
| |
| USB_printf("EP_LIST_ADDR (0x%08x) = 0x%08x\n", |
| (unsigned)&dev_regs->REGISTERS.OPERATIONAL_DEVICE_REGISTERS.EP_LIST_ADDR, |
| (unsigned)USB_32BIT_LE(dev_regs->REGISTERS.OPERATIONAL_DEVICE_REGISTERS.EP_LIST_ADDR)); |
| |
| /* Skip CONFIG_FLAG register */ |
| |
| /* Skip PORTSCX[0..15] registers*/ |
| USB_printf("PORTSCX[0] (0x%08x) = 0x%08x\n", |
| (unsigned)&dev_regs->REGISTERS.OPERATIONAL_DEVICE_REGISTERS.PORTSCX[0], |
| (unsigned)USB_32BIT_LE(dev_regs->REGISTERS.OPERATIONAL_DEVICE_REGISTERS.PORTSCX[0])); |
| |
| /* Skip OTGSC register */ |
| |
| USB_printf("USB_MODE (0x%08x) = 0x%08x\n", |
| (unsigned)&dev_regs->REGISTERS.OPERATIONAL_DEVICE_REGISTERS.USB_MODE, |
| (unsigned)USB_32BIT_LE(dev_regs->REGISTERS.OPERATIONAL_DEVICE_REGISTERS.USB_MODE)); |
| |
| USB_printf("ENDPT_SETUP_STAT (0x%08x) = 0x%08x\n", |
| (unsigned)&dev_regs->REGISTERS.OPERATIONAL_DEVICE_REGISTERS.ENDPT_SETUP_STAT, |
| (unsigned)USB_32BIT_LE(dev_regs->REGISTERS.OPERATIONAL_DEVICE_REGISTERS.ENDPT_SETUP_STAT)); |
| |
| USB_printf("ENDPTPRIME (0x%08x) = 0x%08x\n", |
| (unsigned)&dev_regs->REGISTERS.OPERATIONAL_DEVICE_REGISTERS.ENDPTPRIME, |
| (unsigned)USB_32BIT_LE(dev_regs->REGISTERS.OPERATIONAL_DEVICE_REGISTERS.ENDPTPRIME)); |
| |
| USB_printf("ENDPTFLUSH (0x%08x) = 0x%08x\n", |
| (unsigned)&dev_regs->REGISTERS.OPERATIONAL_DEVICE_REGISTERS.ENDPTFLUSH, |
| (unsigned)USB_32BIT_LE(dev_regs->REGISTERS.OPERATIONAL_DEVICE_REGISTERS.ENDPTFLUSH)); |
| |
| USB_printf("ENDPTSTATUS (0x%08x) = 0x%08x\n", |
| (unsigned)&dev_regs->REGISTERS.OPERATIONAL_DEVICE_REGISTERS.ENDPTSTATUS, |
| (unsigned)USB_32BIT_LE(dev_regs->REGISTERS.OPERATIONAL_DEVICE_REGISTERS.ENDPTSTATUS)); |
| |
| USB_printf("ENDPTCOMPLETE (0x%08x) = 0x%08x\n", |
| (unsigned)&dev_regs->REGISTERS.OPERATIONAL_DEVICE_REGISTERS.ENDPTCOMPLETE, |
| (unsigned)USB_32BIT_LE(dev_regs->REGISTERS.OPERATIONAL_DEVICE_REGISTERS.ENDPTCOMPLETE)); |
| } |
| |
| |
| void _usb_ep_status(void* usbHandle, int ep_num, int direction) |
| { |
| USB_DEV_STATE_STRUCT* pUsbDev = (USB_DEV_STATE_STRUCT*)usbHandle; |
| int i, ep_idx; |
| VUSB20_EP_QUEUE_HEAD_STRUCT_PTR ep_queue_head_ptr; |
| VUSB20_EP_TR_STRUCT_PTR dTD_ptr, head_dTD_ptr, tail_dTD_ptr, next_dTD_ptr; |
| XD_STRUCT_PTR xd_ptr, next_xd_ptr; |
| VUSB20_REG_STRUCT_PTR dev_regs; |
| |
| if(pUsbDev == NULL) |
| { |
| USB_printf("USB Device core is not initialized\n"); |
| return; |
| } |
| |
| USB_printf("\n\tUSB Endpoint #%d - %s status\n\n", ep_num, |
| (direction == ARC_USB_SEND) ? "SEND (IN)" : "RECV (OUT)" ); |
| |
| ep_idx = ep_num*2 + direction; |
| dev_regs = pUsbDev->DEV_PTR; |
| |
| USB_printf("ENDPTCTRLX[%d] (0x%08x) = 0x%08x\n", ep_num, |
| (unsigned)&dev_regs->REGISTERS.OPERATIONAL_DEVICE_REGISTERS.ENDPTCTRLX[ep_num], |
| (unsigned)USB_32BIT_LE(dev_regs->REGISTERS.OPERATIONAL_DEVICE_REGISTERS.ENDPTCTRLX[ep_num])); |
| |
| ep_queue_head_ptr = (VUSB20_EP_QUEUE_HEAD_STRUCT_PTR)pUsbDev->EP_QUEUE_HEAD_PTR + ep_idx; |
| |
| head_dTD_ptr = pUsbDev->EP_DTD_HEADS[ep_idx]; |
| tail_dTD_ptr = pUsbDev->EP_DTD_TAILS[ep_idx]; |
| |
| USB_printf("EP_QH=0x%08x: MAX_PKT=0x%x, SIZE_IOC_INT_STS=0x%x, CURR_DTD=0x%x, NEXT_DTD=0x%x\n", |
| (unsigned)ep_queue_head_ptr, (unsigned)USB_32BIT_LE(ep_queue_head_ptr->MAX_PKT_LENGTH), |
| (unsigned)USB_32BIT_LE(ep_queue_head_ptr->SIZE_IOC_INT_STS), |
| (unsigned)USB_32BIT_LE(ep_queue_head_ptr->CURR_DTD_PTR), |
| (unsigned)USB_32BIT_LE(ep_queue_head_ptr->NEXT_DTD_PTR)); |
| |
| USB_printf("\tBUF_0=0x%08x, BUF_1=0x%08x, BUF_2=0x%08x, BUF_3=0x%08x, BUF_4=0x%08x\n", |
| (unsigned)USB_32BIT_LE(ep_queue_head_ptr->BUFF_PTR0), |
| (unsigned)USB_32BIT_LE(ep_queue_head_ptr->BUFF_PTR1), |
| (unsigned)USB_32BIT_LE(ep_queue_head_ptr->BUFF_PTR2), |
| (unsigned)USB_32BIT_LE(ep_queue_head_ptr->BUFF_PTR3), |
| (unsigned)USB_32BIT_LE(ep_queue_head_ptr->BUFF_PTR4)); |
| |
| USB_printf("\tSETUP_BUFFER (%p): ", ep_queue_head_ptr->SETUP_BUFFER); |
| for(i=0; i<sizeof(ep_queue_head_ptr->SETUP_BUFFER); i++) |
| USB_printf("%02x", ep_queue_head_ptr->SETUP_BUFFER[i] & 0xFF); |
| USB_printf("\n"); |
| |
| USB_printf("\ndTD_HEAD=0x%08x, dTD_TAIL=0x%08x\n", |
| (unsigned)head_dTD_ptr, (unsigned)tail_dTD_ptr); |
| |
| dTD_ptr = head_dTD_ptr; |
| i = 0; |
| while(dTD_ptr != NULL) |
| { |
| USB_printf("%d. dTD=0x%08x (0x%08x), SIZE_IOC_STS=0x%08x, BUF_0=0x%08x, NEXT=0x%08x\n", |
| i, (unsigned)dTD_ptr, USB_DTD_VIRT_TO_PHYS(pUsbDev, dTD_ptr), |
| (unsigned)USB_32BIT_LE(dTD_ptr->SIZE_IOC_STS), |
| (unsigned)USB_32BIT_LE(dTD_ptr->BUFF_PTR0), |
| (unsigned)USB_32BIT_LE(dTD_ptr->NEXT_TR_ELEM_PTR)); |
| |
| xd_ptr = dTD_ptr->SCRATCH_PTR->XD_FOR_THIS_DTD; |
| |
| next_dTD_ptr = (VUSB20_EP_TR_STRUCT_PTR)USB_DTD_PHYS_TO_VIRT(pUsbDev, |
| (uint_32)(USB_32BIT_LE(dTD_ptr->NEXT_TR_ELEM_PTR) & VUSBHS_TD_ADDR_MASK)); |
| if(next_dTD_ptr != NULL) |
| next_xd_ptr = next_dTD_ptr->SCRATCH_PTR->XD_FOR_THIS_DTD; |
| else |
| next_xd_ptr = NULL; |
| |
| if(next_xd_ptr != xd_ptr) |
| { |
| USB_printf("\tXD=0x%08x, ADDR=0x%08x, SIZE=%u, STATUS=0x%02x\n", |
| (unsigned)xd_ptr, (unsigned)xd_ptr->WSTARTADDRESS, |
| (unsigned)xd_ptr->WTOTALLENGTH, xd_ptr->BSTATUS); |
| } |
| i++; |
| dTD_ptr = next_dTD_ptr; |
| } |
| } |
| |
| |
| /* DEBUG */ |
| uint_32 usbDebugFlags = ARC_DEBUG_FLAG_STATS |
| | ARC_DEBUG_FLAG_INIT |
| | ARC_DEBUG_FLAG_ERROR |
| | ARC_DEBUG_FLAG_STALL |
| | ARC_DEBUG_FLAG_RESET; |
| /*| ARC_DEBUG_FLAG_TRANSFER;*/ |
| |
| void _usb_debug_set_flags(uint_32 flags) |
| { |
| usbDebugFlags = (flags); |
| } |
| |
| uint_32 _usb_debug_get_flags(void) |
| { |
| return usbDebugFlags; |
| } |
| |
| #if defined(MV_USB_TRACE_LOG) |
| |
| uint_16 DEBUG_TRACE_ARRAY_COUNTER = 0; |
| char DEBUG_TRACE_ARRAY[TRACE_ARRAY_SIZE][MAX_STRING_SIZE]; |
| |
| void _usb_debug_init_trace_log(void) |
| { |
| USB_memzero(DEBUG_TRACE_ARRAY, TRACE_ARRAY_SIZE*MAX_STRING_SIZE); |
| DEBUG_TRACE_ARRAY_COUNTER =0; |
| } |
| |
| void _usb_debug_print_trace_log(void) |
| { |
| int i; |
| |
| USB_printf("USB Trace log: start=0x%x, end=0x%x, idx=%d, flags=0x%x\n\n", |
| &DEBUG_TRACE_ARRAY[0][0], &DEBUG_TRACE_ARRAY[TRACE_ARRAY_SIZE-1][0], |
| DEBUG_TRACE_ARRAY_COUNTER, usbDebugFlags); |
| |
| for(i=DEBUG_TRACE_ARRAY_COUNTER; i<TRACE_ARRAY_SIZE; i++) |
| { |
| if(DEBUG_TRACE_ARRAY[i][0] == '\0') |
| continue; |
| |
| USB_printf("%3d. %s", i, DEBUG_TRACE_ARRAY[i]); |
| } |
| for(i=0; i<DEBUG_TRACE_ARRAY_COUNTER; i++) |
| { |
| if(DEBUG_TRACE_ARRAY[i][0] == '\0') |
| continue; |
| USB_printf("%3d. %s", i, DEBUG_TRACE_ARRAY[i]); |
| } |
| _usb_debug_init_trace_log(); |
| } |
| #else |
| void _usb_debug_init_trace_log(void) |
| { |
| } |
| |
| void _usb_debug_print_trace_log(void) |
| { |
| USB_printf("USB trace log is not supported\n"); |
| } |
| #endif /* MV_USB_TRACE_LOG */ |
| |
| |
| |
| |
