/*FUNCTION*----------------------------------------------------------------
*
* Function Name : _usb_host_ch9_set_configuration
* Returned Value : USB_OK, or error status
* Comments :
* Function to process standard device request in Chapter 9.
* See Table 9-3 p. 250 of USB 2.0 specification.
*
*END*--------------------------------------------------------------------*/
USB_STATUS _usb_host_ch9_set_configuration
(
/* usb device */
_usb_device_instance_handle dev_handle,
/* configuration value */
uint_16 config
)
{ /* Body */
USB_SETUP request = req_prototype;
USB_STATUS error = USB_OK;
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("_usb_host_ch9_set_configuration");
#endif
USB_lock();
request.BMREQUESTTYPE = REQ_TYPE_DEVICE | REQ_TYPE_OUT;
request.BREQUEST = REQ_SET_CONFIGURATION;
*(uint_16*)request.WVALUE = HOST_TO_LE_SHORT(config);
error = usb_host_ch9_dev_req(dev_handle, &request, NULL);
USB_unlock();
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("_usb_host_ch9_set_configuration SUCCESSFUL");
#endif
return USB_log_error(__FILE__,__LINE__,error);
} /* EndBody */
/*FUNCTION*----------------------------------------------------------------
*
* Function Name : _usb_device_call_service
* Returned Value : USB_OK or error code
* Comments :
* Calls the appropriate service for the specified type, if one is
* registered. Used internally only.
*
*END*--------------------------------------------------------------------*/
USB_STATUS _usb_device_call_service
(
/* [IN] Type of service or endpoint */
uint_8 type,
/* [IN] pointer to event structure */
PTR_USB_EVENT_STRUCT event
)
{ /* Body */
USB_DEV_STATE_STRUCT_PTR usb_dev_ptr;
SERVICE_STRUCT _PTR_ service_ptr;
usb_dev_ptr = (USB_DEV_STATE_STRUCT_PTR)event->handle;
/* Needs mutual exclusion */
USB_lock();
/* Search for an existing entry for type */
for (service_ptr = usb_dev_ptr->SERVICE_HEAD_PTR;
service_ptr;
service_ptr = service_ptr->NEXT)
{
if (service_ptr->TYPE == type)
{
service_ptr->SERVICE(event,service_ptr->arg);
USB_unlock();
return USB_OK;
} /* Endif */
} /* Endfor */
USB_unlock();
return USBERR_CLOSED_SERVICE;
} /* EndBody */
/*FUNCTION*----------------------------------------------------------------
*
* Function Name : _usb_host_ch9_set_address
* Returned Value : USB_OK, or error status
* Comments :
* Function to process standard device request in Chapter 9.
* See Table 9-3 p. 250 of USB 2.0 specification.
*
*END*--------------------------------------------------------------------*/
USB_STATUS _usb_host_ch9_set_address
(
/* usb device */
_usb_device_instance_handle dev_handle
)
{ /* Body */
DEV_INSTANCE_PTR dev_ptr = (DEV_INSTANCE_PTR)dev_handle;
USB_SETUP request = req_prototype;
USB_STATUS error = USB_OK;
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("_usb_host_ch9_set_address");
#endif
USB_lock();
request.BMREQUESTTYPE = REQ_TYPE_DEVICE | REQ_TYPE_OUT;
request.BREQUEST = REQ_SET_ADDRESS;
*(uint_16*)request.WVALUE = HOST_TO_LE_SHORT(dev_ptr->address);
error = usb_host_ch9_dev_req(dev_handle, &request, NULL);
USB_unlock();
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("_usb_host_ch9_set_address,SUCCESSFUL");
#endif
return USB_log_error(__FILE__,__LINE__,error);
} /* EndBody */
/*FUNCTION*----------------------------------------------------------------
*
* Function Name : _usb_host_ch9_get_configuration
* Returned Value : USB_OK, or error status
* Comments :
* Function to process standard device request in Chapter 9.
* See Table 9-3 p. 250 of USB 2.0 specification.
*
*END*--------------------------------------------------------------------*/
USB_STATUS _usb_host_ch9_get_configuration
(
/* [IN] usb device */
_usb_device_instance_handle dev_handle,
/* [OUT] configuration value */
uchar_ptr buffer
)
{ /* Body */
USB_SETUP request = req_prototype;
USB_STATUS error = USB_OK;
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("_usb_host_ch9_get_configuration");
#endif
USB_lock();
request.BMREQUESTTYPE = REQ_TYPE_DEVICE | REQ_TYPE_IN;
request.BREQUEST = REQ_GET_CONFIGURATION;
*(uint_16*)request.WLENGTH = HOST_TO_LE_SHORT_CONST(1);
error = usb_host_ch9_dev_req(dev_handle, &request, buffer);
USB_unlock();
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("_usb_host_ch9_get_configuration, SUCCESSFUL");
#endif
return USB_log_error(__FILE__,__LINE__,error);
} /* EndBody */
void _usb_device_free_XD
(
/* [IN] the dTD to enqueue */
pointer xd_ptr
)
{ /* Body */
int lockKey;
USB_DEV_STATE_STRUCT_PTR usb_dev_ptr;
usb_dev_ptr = (USB_DEV_STATE_STRUCT_PTR)(((XD_STRUCT_PTR)xd_ptr)->SCRATCH_PTR->PRIVATE);
ARC_DEBUG_TRACE(ARC_DEBUG_FLAG_TRACE, "free_XD: xd_ptr=0x%x\n", (unsigned)xd_ptr);
ARC_DEBUG_CODE(ARC_DEBUG_FLAG_STATS, (usb_dev_ptr->STATS.free_XD_count++));
/*
** This function can be called from any context, and it needs mutual
** exclusion with itself.
*/
lockKey = USB_lock();
/*
** Add the XD to the free XD queue (linked via PRIVATE) and
** increment the tail to the next descriptor
*/
USB_XD_QADD(usb_dev_ptr->XD_HEAD, usb_dev_ptr->XD_TAIL, (XD_STRUCT_PTR)xd_ptr);
usb_dev_ptr->XD_ENTRIES++;
USB_unlock(lockKey);
} /* Endbody */
void _usb_device_free_XD
(
_usb_device_handle handle,
/* [IN] the dTD to enqueue */
pointer xd_ptr
)
{ /* Body */
USB_DEV_STATE_STRUCT_PTR usb_dev_ptr = (USB_DEV_STATE_STRUCT_PTR)
handle;
/*
** This function can be called from any context, and it needs mutual
** exclusion with itself.
*/
USB_lock();
/*
** Add the XD to the free XD queue (linked via PRIVATE) and
** increment the tail to the next descriptor
*/
USB_XD_QADD(usb_dev_ptr->XD_HEAD, usb_dev_ptr->XD_TAIL, (struct xd_struct *)xd_ptr);
usb_dev_ptr->XD_ENTRIES++;
USB_unlock();
} /* Endbody */
USB_STATUS usb_class_hub_get_descriptor
(
/* [IN] The communication device common command structure */
HUB_COMMAND_PTR com_ptr,
/* [IN] descriptor buffer */
uchar_ptr buffer,
/* [IN] buffer length (or, better said, how many bytes to read) */
uchar len
)
{ /* Body */
USB_STATUS error = USB_OK;
USB_lock();
error = usb_class_hub_cntrl_common(
com_ptr,
REQ_TYPE_DEVICE | REQ_TYPE_IN | REQ_TYPE_CLASS,
REQ_GET_DESCRIPTOR,
0,
0,
len,
buffer
);
USB_unlock();
return error;
} /* EndBody */
static USB_STATUS usb_class_hid_cntrl_common
(
/* [IN] The communication device common command structure */
HID_COMMAND_PTR com_ptr,
/* [IN] Bitmask of the request type */
uint_8 bmrequesttype,
/* [IN] Request code */
uint_8 brequest,
/* [IN] Value to copy into WVALUE field of the REQUEST */
uint_16 wvalue,
/* [IN] Length of the data associated with REQUEST */
uint_16 wlength,
/* [IN] Pointer to data buffer used to send/recv */
uchar_ptr data
)
{ /* Body */
USB_HID_CLASS_INTF_STRUCT_PTR if_ptr;
USB_SETUP req;
USB_STATUS status = USBERR_NO_INTERFACE;
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("usb_class_hid_cntrl_common");
#endif
USB_lock();
/* Validity checking */
if (usb_host_class_intf_validate(com_ptr->CLASS_PTR)) {
if_ptr =
(USB_HID_CLASS_INTF_STRUCT_PTR)com_ptr->CLASS_PTR->class_intf_handle;
status = usb_hostdev_validate(if_ptr->G.dev_handle);
} /* Endif */
if (!status && if_ptr->IN_SETUP) {
status = USBERR_TRANSFER_IN_PROGRESS;
} /* Endif */
if (!status) {
/* Save the higher level callback and ID */
if_ptr->USER_CALLBACK = com_ptr->CALLBACK_FN;
if_ptr->USER_PARAM = com_ptr->CALLBACK_PARAM;
/* Setup the request */
req.BMREQUESTTYPE = bmrequesttype;
req.BREQUEST = brequest;
*(uint_16*)req.WVALUE = HOST_TO_LE_SHORT(wvalue);
*(uint_16*)req.WINDEX = HOST_TO_LE_SHORT(((INTERFACE_DESCRIPTOR_PTR)if_ptr->G.intf_handle)->bInterfaceNumber);
*(uint_16*)req.WLENGTH = HOST_TO_LE_SHORT(wlength);
status = _usb_hostdev_cntrl_request(if_ptr->G.dev_handle, &req, data,
usb_class_hid_cntrl_callback, if_ptr);
if (status == USB_STATUS_TRANSFER_QUEUED) {
if_ptr->IN_SETUP = TRUE;
} /* Endif */
} /* Endif */
USB_unlock();
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("usb_class_hid_cntrl_common, SUCCESSFUL");
#endif
return status;
} /* Endbody */
/*FUNCTION*-------------------------------------------------------------
*
* Function Name : _usb_host_close_all_pipes
* Returned Value : None
* Comments :
* _usb_host_close_all_pipes routine removes the pipe from the open pipe list
*
*END*-----------------------------------------------------------------*/
void _usb_host_close_all_pipes
(
/* [IN] the USB Host state structure */
_usb_host_handle handle
)
{ /* Body */
int_16 i;
USB_HOST_STATE_STRUCT_PTR usb_host_ptr;
usb_host_ptr = (USB_HOST_STATE_STRUCT_PTR)handle;
USB_lock();
for (i=0; i < USBCFG_MAX_PIPES; i++) {
if (!(usb_host_ptr->PIPE_DESCRIPTOR_BASE_PTR[i].OPEN)) {
break;
} else {
/* Call the low-level routine to free the controller specific
** resources for this pipe
*/
_usb_host_close_pipe_call_interface (handle,
&usb_host_ptr->PIPE_DESCRIPTOR_BASE_PTR[i]);
/* de-initialise the pipe descriptor */
memset(&usb_host_ptr->PIPE_DESCRIPTOR_BASE_PTR[i],0,
sizeof(PIPE_DESCRIPTOR_STRUCT));
} /* Endif */
} /* Endfor */
USB_unlock();
} /* Endbody */
/*FUNCTION*-------------------------------------------------------------
*
* Function Name : _usb_device_cancel_transfer
* Returned Value : USB_OK or error code
* Comments :
* returns the status of the transaction on the specified endpoint.
*
*END*-----------------------------------------------------------------*/
uint_8 _usb_device_cancel_transfer
(
/* [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 */
uint_8 error = USB_OK;
int lockKey;
lockKey = USB_lock();
/* Cancel transfer on the specified endpoint for the specified
** direction
*/
error = _usb_dci_vusb20_cancel_transfer(handle, ep_num, direction);
USB_unlock(lockKey);
return error;
} /* EndBody */
USB_STATUS usb_class_cdc_install_driver
(
CLASS_CALL_STRUCT_PTR data_instance,
char_ptr device_name
)
{
USB_DATA_CLASS_INTF_STRUCT_PTR if_ptr;
USB_STATUS status = USB_OK;
USB_lock();
/* Validity checking, always needed when passing data to lower API */
if (usb_host_class_intf_validate(data_instance)) {
if_ptr = (USB_DATA_CLASS_INTF_STRUCT_PTR) data_instance->class_intf_handle;
f_usb->DEV_PTR->DRIVER_INIT_PTR = data_instance;
f_usb->DEV_PTR->IDENTIFIER = device_name;
f_usb->DEV_PTR->IO_OPEN = _io_cdc_serial_open;
f_usb->DEV_PTR->IO_CLOSE = _io_cdc_serial_close;
f_usb->DEV_PTR->IO_READ = _io_cdc_serial_read;
f_usb->DEV_PTR->IO_WRITE = _io_cdc_serial_write;
f_usb->DEV_PTR->IO_IOCTL = _io_cdc_serial_ioctl;
f_usb->DEV_PTR->IO_UNINSTALL = _io_cdc_serial_uninstall;
f_usb->DEV_PTR->DRIVER_TYPE = 0;
if (status == IO_OK)
if_ptr->device_name = device_name;
}
USB_unlock();
return status;
}
boolean usb_class_mass_storage_device_command_cancel
(
/* Handle to class struct with the key */
CLASS_CALL_STRUCT_PTR ccs_ptr,
/*Command */
COMMAND_OBJECT_PTR cmd_ptr
)
{ /* Body */
USB_MASS_CLASS_INTF_STRUCT_PTR intf_ptr;
USB_STATUS error = USBERR_NO_INTERFACE;
boolean result = FALSE;
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("usb_class_mass_storage_device_command_cancel");
#endif
/* Pointer validity-checking, clear memory, init header */
USB_lock();
if (usb_host_class_intf_validate(ccs_ptr)) {
intf_ptr = (USB_MASS_CLASS_INTF_STRUCT_PTR) ccs_ptr->class_intf_handle;
error = usb_hostdev_validate (intf_ptr->G.dev_handle);
} /* Endif */
if ((error == USB_OK) || (error == USB_STATUS_TRANSFER_QUEUED)) {
result = usb_class_mass_cancelq(intf_ptr, cmd_ptr);
}
USB_unlock();
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("usb_class_mass_storage_device_command_cancel, SUCCESSFUL");
#endif
return result;
} /* Endbody */
void usb_class_mass_init
(
/* [IN] structure with USB pipe information on the interface */
PIPE_BUNDLE_STRUCT_PTR pbs_ptr,
/* [IN] printer call struct pointer */
CLASS_CALL_STRUCT_PTR ccs_ptr
)
{ /* Body */
USB_MASS_CLASS_INTF_STRUCT_PTR intf_ptr = ccs_ptr->class_intf_handle;
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("usb_class_mass_init");
#endif
/* pointer2 validity-checking, clear memory, init header of intf_ptr */
if (usb_host_class_intf_init(pbs_ptr, intf_ptr, &mass_anchor))
{
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("usb_class_mass_init");
#endif
return;
}
USB_lock();
ccs_ptr->code_key = 0;
ccs_ptr->code_key = usb_host_class_intf_validate( ccs_ptr );
if (ccs_ptr->code_key == 0) goto Bad_Exit;
/* Start filling up the members of interface handle (general class already filled) */
intf_ptr->CONTROL_PIPE = usb_hostdev_get_pipe_handle(pbs_ptr,
USB_CONTROL_PIPE, 0);
intf_ptr->BULK_IN_PIPE = usb_hostdev_get_pipe_handle(pbs_ptr,
USB_BULK_PIPE, USB_RECV);
intf_ptr->BULK_OUT_PIPE = usb_hostdev_get_pipe_handle(pbs_ptr,
USB_BULK_PIPE, USB_SEND);
if (intf_ptr->CONTROL_PIPE &&
intf_ptr->BULK_IN_PIPE &&
intf_ptr->BULK_OUT_PIPE)
{
/* Initialize the queue for storing the local copy of interface handles */
usb_class_mass_q_init(intf_ptr);
USB_unlock();
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("usb_class_mass_init, Q init failed");
#endif
return;
} /* Endif */
Bad_Exit:
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("usb_class_mass_init, bad exit");
#endif
memset(intf_ptr, 0, sizeof(USB_MASS_CLASS_INTF_STRUCT_PTR));
ccs_ptr->class_intf_handle = NULL;
ccs_ptr->code_key = 0;
USB_unlock();
} /* Endbody */
/*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 */
/* uint_8 error = 0; */
USB_DEV_STATE_STRUCT_PTR usb_dev_ptr;
usb_dev_ptr = (USB_DEV_STATE_STRUCT_PTR)handle;
#ifdef _DEVICE_DEBUG_
DEBUG_LOG_TRACE("_usb_device_unstall_endpoint");
#endif
USB_lock();
_usb_dci_vusb20_unstall_endpoint(handle, ep_num, direction);
USB_unlock();
#ifdef _DEVICE_DEBUG_
DEBUG_LOG_TRACE("_usb_device_unstall_endpoint, SUCCESSFULL");
#endif
} /* EndBody */
void _usb_device_free_XD
(
/* [IN] the dTD to enqueue */
pointer xd_ptr
)
{ /* Body */
USB_DEV_STATE_STRUCT_PTR usb_dev_ptr = (USB_DEV_STATE_STRUCT_PTR)
(((XD_STRUCT_PTR)xd_ptr)->SCRATCH_PTR->PRIVATE);
/*
** This function can be called from any context, and it needs mutual
** exclusion with itself.
*/
#ifdef _DEVICE_DEBUG_
DEBUG_LOG_TRACE("_usb_device_free_XD");
#endif
USB_lock();
/*
** Add the XD to the free XD queue (linked via PRIVATE) and
** increment the tail to the next descriptor
*/
USB_XD_QADD(usb_dev_ptr->XD_HEAD, usb_dev_ptr->XD_TAIL,
(XD_STRUCT_PTR)xd_ptr);
usb_dev_ptr->XD_ENTRIES++;
USB_unlock();
#ifdef _DEVICE_DEBUG_
DEBUG_LOG_TRACE("_usb_device_free_XD, SUCCESSFUL");
#endif
} /* Endbody */
/*FUNCTION*-------------------------------------------------------------
*
* Function Name : _usb_device_get_transfer_status
* Returned Value : Status of the transfer
* Comments :
* returns the status of the transaction on the specified endpoint.
*
*END*-----------------------------------------------------------------*/
uint_8 _usb_device_get_transfer_status
(
/* [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 */
uint_8 status;
USB_DEV_STATE_STRUCT_PTR usb_dev_ptr;
#ifdef _DEVICE_DEBUG_
DEBUG_LOG_TRACE("_usb_device_get_transfer_status");
#endif
usb_dev_ptr = (USB_DEV_STATE_STRUCT_PTR)handle;
USB_lock();
status = _usb_dci_vusb20_get_transfer_status(handle, ep_num, direction);
USB_unlock();
#ifdef _DEVICE_DEBUG_
DEBUG_LOG_TRACE("_usb_device_get_transfer_status, SUCCESSFUL");
#endif
/* Return the status of the last queued transfer */
return (status);
} /* EndBody */
void usb_class_mass_deleteq
(
/* [IN] interface structure pointer */
USB_MASS_CLASS_INTF_STRUCT_PTR intf_ptr
)
{ /* Body */
MASS_QUEUE_STRUCT_PTR Q = &intf_ptr->QUEUE;
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("usb_class_mass_deleteq");
#endif
/* Remove current command and increment FIRST modulo the Q size */
USB_lock();
if (Q->COUNT) {
Q->ELEMENTS[Q->FIRST] = NULL;
Q->FIRST = MASSQ_NEXT(Q->FIRST);
// Q->AVAILABLE = TRUE;
Q->COUNT--;
}
USB_unlock();
//if (Q->COUNT >1) {
// printf("\nMASS q size now %d", Q->COUNT );
//}
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("usb_class_mass_deleteq, SUCCESSFUL");
#endif
} /* Endbody */
void usb_class_mass_get_pending_request
(
/* [IN] interface structure pointer */
USB_MASS_CLASS_INTF_STRUCT_PTR intf_ptr,
/* [OUT] pointer to pointer which will hold the pending request */
COMMAND_OBJECT_PTR *cmd_ptr_ptr
)
{ /* Body */
MASS_QUEUE_STRUCT_PTR Q = &intf_ptr->QUEUE;
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("usb_class_mass_get_pending_request");
#endif
USB_lock();
if (Q->COUNT) {
*cmd_ptr_ptr = (COMMAND_OBJECT_PTR)Q->ELEMENTS[Q->FIRST];
} else {
*cmd_ptr_ptr = NULL;
} /* Endif */
USB_unlock();
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("usb_class_mass_get_pending_request, SUCCESSFUL");
#endif
return;
} /* Endbody */
/*FUNCTION*-------------------------------------------------------------
*
* Function Name : _usb_device_get_transfer_status
* Returned Value : Status of the transfer
* Comments :
* returns the status of the transaction on the specified endpoint.
*
*END*-----------------------------------------------------------------*/
uint_8 _usb_device_get_transfer_status
(
/* [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 */
uint_8 status;
int lockKey;
lockKey = USB_lock();
status = _usb_dci_vusb20_get_transfer_status(handle, ep_num, direction);
USB_unlock(lockKey);
/* Return the status of the last queued transfer */
return (status);
} /* EndBody */
/*FUNCTION*----------------------------------------------------------------
*
* Function Name : _usb_hostdev_cntrl_request
* Returned Value : USB_OK, or error status
* Comments :
* Function to process class- or vendor-specific control pipe device
* requests.
*
*END*--------------------------------------------------------------------*/
USB_STATUS _usb_hostdev_cntrl_request
(
/* usb device */
_usb_device_instance_handle dev_handle,
/* Device Request to send */
USB_SETUP_PTR devreq,
/* buffer to send/receive */
uchar_ptr buff_ptr,
/* callback upon completion */
tr_callback callback,
/* [IN] the parameter to pass back to the callback function */
pointer callback_param
)
{ /* Body */
DEV_INSTANCE_PTR dev_ptr;
_usb_pipe_handle pipe_handle;
TR_INIT_PARAM_STRUCT tr;
USB_STATUS error = USB_OK;
/* Verify that device handle is valid */
USB_lock();
error = usb_hostdev_validate(dev_handle);
if (error != USB_OK) {
USB_unlock();
return USBERR_DEVICE_NOT_FOUND;
} /* Endif */
dev_ptr = (DEV_INSTANCE_PTR)dev_handle;
if (dev_ptr->state < DEVSTATE_ENUM_OK) {
USB_unlock();
return USBERR_DEVICE_NOT_FOUND;
} /* Endif */
pipe_handle = dev_ptr->control_pipe;
usb_hostdev_tr_init(&tr, callback, callback_param);
/* Set TR buffer length as required */
if ((REQ_TYPE_IN & devreq->BMREQUESTTYPE) != 0) {
tr.RX_BUFFER = buff_ptr;
tr.RX_LENGTH = utoh16(devreq->WLENGTH);
} else {
tr.TX_BUFFER = buff_ptr;
tr.TX_LENGTH = utoh16(devreq->WLENGTH);
} /* EndIf */
tr.DEV_REQ_PTR = (uchar_ptr)devreq;
error = _usb_host_send_setup(dev_ptr->host, pipe_handle, &tr);
USB_unlock();
return error;
} /* EndBody */
/*FUNCTION*----------------------------------------------------------------
*
* Function Name : _usb_host_ch9_set_interface
* Returned Value : USB_OK, or error status
* Comments :
* Function to process standard device request in Chapter 9.
* See Table 9-3 p. 250 of USB 2.0 specification.
*
*END*--------------------------------------------------------------------*/
USB_STATUS _usb_host_ch9_set_interface
(
/* usb device */
_usb_device_instance_handle dev_handle,
/* alternate setting */
uint_8 alternate,
/* interface */
uint_8 intf
)
{ /* Body */
USB_SETUP request = req_prototype;
USB_STATUS error = USB_OK;
USB_lock();
request.BMREQUESTTYPE = REQ_TYPE_INTERFACE | REQ_TYPE_OUT;
request.BREQUEST = REQ_SET_INTERFACE;
htou16(request.WVALUE, alternate);
htou16(request.WINDEX, intf);
error = usb_host_ch9_dev_req(dev_handle, &request, NULL);
USB_unlock();
return error;
} /* EndBody */
/*FUNCTION*----------------------------------------------------------------
*
* Function Name : _usb_host_ch9_synch_frame
* Returned Value : USB_OK, or error status
* Comments :
* Function to process standard device request in Chapter 9.
* See Table 9-3 p. 250 of USB 2.0 specification.
*
*END*--------------------------------------------------------------------*/
USB_STATUS _usb_host_ch9_synch_frame
(
/* usb device */
_usb_device_instance_handle dev_handle,
/* interface index */
uint_8 intf,
/* configuration buffer */
uchar_ptr buffer
)
{ /* Body */
USB_SETUP request = req_prototype;
USB_STATUS error = USB_OK;
USB_lock();
request.BMREQUESTTYPE = REQ_TYPE_ENDPOINT | REQ_TYPE_IN;
request.BREQUEST = REQ_SYNCH_FRAME;
htou16(request.WINDEX, intf);
htou16(request.WLENGTH, 2);
error = usb_host_ch9_dev_req(dev_handle, &request, buffer);
USB_unlock();
return error;
} /* EndBody */
/*FUNCTION*----------------------------------------------------------------
*
* Function Name : _usb_host_ch9_get_interface
* Returned Value : USB_OK, or error status
* Comments :
* Function to process standard device request in Chapter 9.
* See Table 9-3 p. 250 of USB 2.0 specification.
*
*END*--------------------------------------------------------------------*/
USB_STATUS _usb_host_ch9_get_interface
(
/* usb device */
_usb_device_instance_handle dev_handle,
/* interface index */
uint_8 interface,
/* alternate setting buffer */
uchar_ptr buffer
)
{ /* Body */
USB_SETUP request = req_prototype;
USB_STATUS error = USB_OK;
USB_lock();
request.BMREQUESTTYPE = REQ_TYPE_INTERFACE | REQ_TYPE_IN;
request.BREQUEST = REQ_GET_INTERFACE;
htou16(request.WINDEX, interface);
htou16(request.WLENGTH, 1);
error = usb_host_ch9_dev_req(dev_handle, &request, buffer);
USB_unlock();
return error;
} /* EndBody */
/*FUNCTION*----------------------------------------------------------------
*
* Function Name : _usb_host_ch9_set_configuration
* Returned Value : USB_OK, or error status
* Comments :
* Function to process standard device request in Chapter 9.
* See Table 9-3 p. 250 of USB 2.0 specification.
*
*END*--------------------------------------------------------------------*/
USB_STATUS _usb_host_ch9_set_configuration
(
/* usb device */
_usb_device_instance_handle dev_handle,
/* configuration value */
uint_16 config
)
{ /* Body */
USB_SETUP request = req_prototype;
USB_STATUS error = USB_OK;
USB_lock();
request.BMREQUESTTYPE = REQ_TYPE_DEVICE | REQ_TYPE_OUT;
request.BREQUEST = REQ_SET_CONFIGURATION;
htou16(request.WVALUE, config);
error = usb_host_ch9_dev_req(dev_handle, &request, NULL);
USB_unlock();
return error;
} /* EndBody */
/*FUNCTION*----------------------------------------------------------------
*
* Function Name : _usb_host_ch9_get_descriptor
* Returned Value : USB_OK, or error status
* Comments :
* Function to process standard device request in Chapter 9.
* See Table 9-3 p. 250 of USB 2.0 specification.
*
*END*--------------------------------------------------------------------*/
USB_STATUS _usb_host_ch9_get_descriptor
(
/* usb device */
_usb_device_instance_handle dev_handle,
/* descriptor type & index */
uint_16 type_index,
/* Language ID or 0 */
uint_16 lang_id,
/* buffer length */
uint_16 buflen,
/* descriptor buffer */
uchar_ptr buffer
)
{ /* Body */
USB_SETUP request;
USB_STATUS error = USB_OK;
USB_lock();
request.BMREQUESTTYPE = REQ_TYPE_DEVICE | REQ_TYPE_IN;
request.BREQUEST = REQ_GET_DESCRIPTOR;
htou16(request.WVALUE, type_index);
htou16(request.WINDEX, lang_id);
htou16(request.WLENGTH, buflen);
error = usb_host_ch9_dev_req(dev_handle, &request, buffer);
USB_unlock();
return error;
} /* EndBody */
/*FUNCTION*----------------------------------------------------------------
*
* Function Name : _usb_host_ch9_get_configuration
* Returned Value : USB_OK, or error status
* Comments :
* Function to process standard device request in Chapter 9.
* See Table 9-3 p. 250 of USB 2.0 specification.
*
*END*--------------------------------------------------------------------*/
USB_STATUS _usb_host_ch9_get_configuration
(
/* [IN] usb device */
_usb_device_instance_handle dev_handle,
/* [OUT] configuration value */
uchar_ptr buffer
)
{ /* Body */
USB_SETUP request = req_prototype;
USB_STATUS error = USB_OK;
USB_lock();
request.BMREQUESTTYPE = REQ_TYPE_DEVICE | REQ_TYPE_IN;
request.BREQUEST = REQ_GET_CONFIGURATION;
htou16(request.WLENGTH, 1);
error = usb_host_ch9_dev_req(dev_handle, &request, buffer);
USB_unlock();
return error;
} /* EndBody */
/*FUNCTION*----------------------------------------------------------------
*
* Function Name : _usb_host_register_ch9_callback
* Returned Value : USB_OK, or error status
* Comments :
* This function registers a callback function that will be called
* to notify the user of a ch9 command completion. This should be used
* only after enumeration is completed
*
*END*--------------------------------------------------------------------*/
USB_STATUS _usb_host_register_ch9_callback
(
/* usb device */
_usb_device_instance_handle dev_handle,
/* Callback upon completion */
tr_callback callback,
/* User provided callback param */
pointer callback_param
)
{ /* Body */
DEV_INSTANCE_PTR dev_inst_ptr;
USB_STATUS error;
/* Verify that device handle is valid */
USB_lock();
error = usb_hostdev_validate(dev_handle);
if (error != USB_OK) {
USB_unlock();
return USBERR_DEVICE_NOT_FOUND;
} /* Endif */
dev_inst_ptr = (DEV_INSTANCE_PTR)dev_handle;
/* This will be called if the device is already enumerated */
dev_inst_ptr->control_callback = callback;
dev_inst_ptr->control_callback_param = callback_param;
USB_unlock();
return USB_OK;
} /* EndBody */
int32_t usb_class_mass_q_insert
(
/* [IN] interface structure pointer */
USB_MASS_CLASS_INTF_STRUCT_PTR intf_ptr,
/* [IN] command object to be inserted in the queue*/
COMMAND_OBJECT_PTR pCmd
)
{ /* Body */
MASS_QUEUE_STRUCT_PTR Q = &intf_ptr->QUEUE;
int32_t tmp = -1;
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("usb_class_mass_q_insert");
#endif
/*
** Insert into queue, update LAST, check if full and return queue position.
** If queue is full -1 will be returned
*/
USB_lock();
if (Q->COUNT < QUEUE_SIZE) {
Q->ELEMENTS[Q->LAST] = pCmd;
tmp = Q->LAST;
Q->LAST = MASSQ_NEXT(Q->LAST);
Q->COUNT++;
} /* Endif */
USB_unlock();
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("usb_class_mass_q_insert, SUCCESSFUL");
#endif
return tmp;
} /* Endbody */
/*FUNCTION*----------------------------------------------------------------
*
* Function Name : usb_class_audio_stream_init
* Returned Value : None
* Comments :
* This function is called by common class to initialize the class driver
* for audio stream interface. It is called in response to a select
* interface call by application.
*
*END*--------------------------------------------------------------------*/
void usb_class_audio_stream_init
(
/* [IN] structure with USB pipe information on the interface */
PIPE_BUNDLE_STRUCT_PTR pbs_ptr,
/* [IN] stream call struct pointer */
CLASS_CALL_STRUCT_PTR ccs_ptr
)
{ /* Body */
AUDIO_STREAM_INTERFACE_STRUCT_PTR if_ptr = ccs_ptr->class_intf_handle;
USB_STATUS status;
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("usb_class_audio_stream_init");
#endif
/* Make sure the device is still attached */
USB_lock();
status = usb_host_class_intf_init(pbs_ptr, if_ptr, &audio_stream_anchor);
if (status == USB_OK) {
/* Check the audio stream interface alternating 1 */
if (0 != (((INTERFACE_DESCRIPTOR_PTR)if_ptr->AUDIO_G.G.intf_handle)->bNumEndpoints)) {
/*
** We generate a code_key based on the attached device. This is used to
** verify that the device has not been detached and replaced with another.
*/
ccs_ptr->code_key = 0;
ccs_ptr->code_key = usb_host_class_intf_validate(ccs_ptr);
if_ptr->AUDIO_G.IFNUM = ((INTERFACE_DESCRIPTOR_PTR)if_ptr->AUDIO_G.G.intf_handle)->bInterfaceNumber;
if_ptr->iso_in_pipe = usb_hostdev_get_pipe_handle(pbs_ptr, USB_ISOCHRONOUS_PIPE, USB_RECV);
if_ptr->iso_out_pipe = usb_hostdev_get_pipe_handle(pbs_ptr, USB_ISOCHRONOUS_PIPE, USB_SEND);
if ((if_ptr->iso_in_pipe == NULL) && (if_ptr->iso_out_pipe == NULL))
status = USBERR_OPEN_PIPE_FAILED;
} else {
status = USBERR_INIT_FAILED;
}
} /* Endif */
/* Signal that an error has occured by setting the "code_key" */
if (status) {
ccs_ptr->code_key = 0;
} /* Endif */
USB_unlock();
#ifdef _HOST_DEBUG_
if (status)
DEBUG_LOG_TRACE("usb_class_audio_stream_init, SUCCESSFUL");
else
DEBUG_LOG_TRACE("usb_class_audio_stream_init, FAILED");
#endif
} /* Endbody */
/*FUNCTION*----------------------------------------------------------------
*
* Function Name : usb_dev_list_get_memory
* Returned Value : USB_OK if memory allocated, else error code
* Comments :
* Memory is added at the end of a linked list, whose
* anchor is device.memlist-->
*
*END*--------------------------------------------------------------------*/
USB_STATUS usb_dev_list_get_memory
(
/* [IN] Pointer to the USB device */
DEV_INSTANCE_PTR dev_ptr,
/* [IN] Size of memory payload required */
uint_32 mem_size,
/* [IN] Type of memory payload required */
memory_type mem_type,
/* [OUT] Pointer to memory block's header */
pointer2 _PTR_ header_ptr
)
{ /* Body */
DEV_MEMORY_PTR mem_ptr, list_ptr;
USB_STATUS error;
USB_lock();
error = usb_hostdev_validate((pointer2)dev_ptr);
USB_unlock();
if (error != USB_OK) {
return error;
}
if ((mem_type <= USB_MEMTYPE_MIN_VALUE) ||
(mem_type >= USB_MEMTYPE_MAX_VALUE))
{
return USBERR_INVALID_MEM_TYPE;
} /* Endif */
/* get memory for header + payload, rounded up to 4-byte */
mem_ptr = (DEV_MEMORY_PTR) malloc((mem_size+MEM_HEADER_LEN+3)&0xFFFC);
if (mem_ptr == NULL) {
return USBERR_GET_MEMORY_FAILED;
}
//_mem_set_type(mem_ptr, MEM_TYPE_USB_HOST_DEVICE);
if (dev_ptr->memlist == NULL) {
dev_ptr->memlist = mem_ptr;
} else {
list_ptr = dev_ptr->memlist;
while (list_ptr->next != NULL)
list_ptr = list_ptr->next;
list_ptr->next = mem_ptr;
} /* EndIf */
mem_ptr->next = NULL;
mem_ptr->blktype = mem_type;
mem_ptr->blksize = mem_size;
*header_ptr = (pointer2)mem_ptr;
return USB_OK;
} /* Endbody */
