razzor/uboot-1.1.4-kirkwood
1
0
Fork 0
Code
ac82ba9f6b
uboot-1.1.4-kirkwood/board/mv_feroceon/mv_hal/usb/device/mvUsbDevUtl.c

636 lines
22 KiB
C
Raw Normal View History

u-boot-1.1.4_for_kw
2024-01-09 13:43:28 +01:00
/*******************************************************************************
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 */
Copy Permalink