/*FUNCTION*----------------------------------------------------------------
*
* Function Name : usb_audio_recv_data
* Returned Value : USB status
* Comments :
* Receive data on isochronous IN pipe.
*
*END*--------------------------------------------------------------------*/
USB_STATUS usb_audio_recv_data
(
/* [IN] class-interface control pointer */
CLASS_CALL_STRUCT_PTR control_ptr,
/* [IN] class-interface stream pointer */
CLASS_CALL_STRUCT_PTR stream_ptr,
/* [IN] callback upon completion */
tr_callback callback,
/* [IN] user parameter returned by callback */
void *call_parm,
/* [IN] data length */
uint32_t buf_size,
/* [IN] buffer pointer */
unsigned char *buffer
)
{ /* Body */
AUDIO_STREAM_INTERFACE_STRUCT_PTR stream_if_ptr;
AUDIO_CONTROL_INTERFACE_STRUCT_PTR control_if_ptr;
TR_INIT_PARAM_STRUCT tr;
USB_STATUS status = USBERR_NO_INTERFACE;
USB_lock();
/* Validity checking, always needed when passing data to lower API */
if (!usb_host_class_intf_validate(control_ptr)) {
USB_unlock();
return USBERR_NO_INTERFACE;
}
stream_if_ptr = (AUDIO_STREAM_INTERFACE_STRUCT_PTR) stream_ptr->class_intf_handle;
control_if_ptr = (AUDIO_CONTROL_INTERFACE_STRUCT_PTR) control_ptr->class_intf_handle;
/* Do the device use OUT pipe? */
if (stream_if_ptr->iso_in_pipe == NULL) {
USB_unlock();
return USBERR_OPEN_PIPE_FAILED;
}
/* Validity checking, always needed when passing data to lower API */
if (!usb_host_class_intf_validate(control_ptr)) {
USB_unlock();
return USBERR_NO_INTERFACE;
}
usb_hostdev_tr_init(&tr, (tr_callback) callback, (void *) call_parm);
tr.G.RX_BUFFER = (unsigned char *) buffer;
tr.G.RX_LENGTH = buf_size;
status = _usb_host_recv_data(control_if_ptr->AUDIO_G.G.host_handle,
stream_if_ptr->iso_in_pipe, &tr);
USB_unlock();
return status;
} /* Endbody */
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 */
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;
}
CLASS_CALL_STRUCT_PTR usb_class_audio_get_ctrl_interface
(
/* [IN] pointer to interface handle */
pointer intf_handle
)
{
CLASS_CALL_STRUCT_PTR control_parser;
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("usb_class_audio_get_ctrl_interface");
#endif
/* find this control interface in the list with interface descriptor */
for (control_parser = audio_control_anchor; control_parser != NULL; control_parser = control_parser->next)
if (usb_host_class_intf_validate(control_parser))
if (((AUDIO_CONTROL_INTERFACE_STRUCT_PTR) control_parser->class_intf_handle)->AUDIO_G.G.intf_handle == intf_handle)
break;
#ifdef _HOST_DEBUG_
if (control_parser != NULL)
DEBUG_LOG_TRACE("usb_class_audio_get_ctrl_interface, SUCCESSFULL");
else
DEBUG_LOG_TRACE("usb_class_audio_get_ctrl_interface, FAILED");
#endif
return control_parser;
}
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 */
static void usb_class_cdc_bind_ctrl_interface
(
/* [IN] pointer to data interface */
CLASS_CALL_STRUCT_PTR data_class_ptr,
/* [IN] pointer to (control) interface desriptor to be used to control */
pointer2 control_descriptor_ptr
)
{
CLASS_CALL_STRUCT_PTR ccs_control_interface = ctrl_anchor;
USB_CDC_GENERAL_CLASS_PTR control_interface;
/* Search for all registered control interfaces */
while (ccs_control_interface != NULL) {
if (usb_host_class_intf_validate(ccs_control_interface)) {
control_interface = ccs_control_interface->class_intf_handle;
/* test if interface descriptor matches */
if (control_interface->G.intf_handle == control_descriptor_ptr) {
((USB_DATA_CLASS_INTF_STRUCT_PTR) data_class_ptr->class_intf_handle)->BOUND_CONTROL_INTERFACE = ccs_control_interface;
break;
}
}
ccs_control_interface = ccs_control_interface->next;
}
}
static void usb_class_cdc_bind_data_interface
(
/* [IN] pointer to control interface call struct */
CLASS_CALL_STRUCT_PTR control_class_ptr,
/* [IN] pointer to (data) interface desriptor to be controlled */
pointer2 data_descriptor_ptr
)
{
CLASS_CALL_STRUCT_PTR ccs_data_interface = data_anchor;
USB_DATA_CLASS_INTF_STRUCT_PTR data_interface;
/* Search for all registered data interfaces */
while (ccs_data_interface != NULL) {
if (usb_host_class_intf_validate(ccs_data_interface)) {
data_interface = ccs_data_interface->class_intf_handle;
/* test if interface descriptor matches */
if (data_interface->CDC_G.G.intf_handle == data_descriptor_ptr) {
data_interface->BOUND_CONTROL_INTERFACE = control_class_ptr;
break;
}
}
ccs_data_interface = ccs_data_interface->next;
}
}
void usb_class_hub_init
(
/* [IN] structure with USB pipe information on the interface */
PIPE_BUNDLE_STRUCT_PTR pbs_ptr,
/* [IN] hub call struct pointer */
CLASS_CALL_STRUCT_PTR ccs_ptr
)
{ /* Body */
USB_STATUS status;
USB_HUB_CLASS_INTF_STRUCT_PTR if_ptr = ccs_ptr->class_intf_handle;
/* Make sure the device is still attached */
status = usb_host_class_intf_init(pbs_ptr, if_ptr, &hub_anchor);
if (status == USB_OK) {
/*
** 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->P_CONTROL = usb_hostdev_get_pipe_handle(pbs_ptr, USB_CONTROL_PIPE,
0);
if_ptr->P_INT_IN = usb_hostdev_get_pipe_handle(pbs_ptr,
USB_INTERRUPT_PIPE, USB_RECV);
} /* Endif */
/* Signal that an error has occured by setting the "code_key" to 0 */
if (status || !if_ptr->P_INT_IN || !if_ptr->P_CONTROL) {
ccs_ptr->code_key = 0;
} /* Endif */
} /* 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 */
USB_STATUS usb_class_mass_storage_device_command
(
/* 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;
int temp;
USB_STATUS error = USBERR_NO_INTERFACE;
CBW_STRUCT_PTR pCbw = (CBW_STRUCT_PTR) cmd_ptr->CBW_PTR;
boolean empty;
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("usb_class_mass_storage_device_command");
#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)) {
/* Fill in the remaining CBW fields as per the USB Mass Storage specs */
htou32(pCbw->DCBWSIGNATURE, CBW_SIGNATURE);
/* CBW is ready so queue it and update status */
empty = USB_CLASS_MASS_IS_Q_EMPTY(intf_ptr);
temp = usb_class_mass_q_insert(intf_ptr, cmd_ptr);
if (temp >= 0) {
cmd_ptr->STATUS = STATUS_QUEUED_IN_DRIVER;
/* The tag for the command packet is its queue number. */
htou32(pCbw->DCBWTAG, temp);
/*
** If queue was empty send CBW to USB immediately, otherwise it will be
** taken from queue later by a callback function
*/
if (empty) {
error = usb_class_mass_pass_on_usb(intf_ptr);
} /* Endif */
} else {
error = (USB_STATUS)USB_MASS_QUEUE_FULL;
} /* Endif */
} /* Endif */
USB_unlock();
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("usb_class_mass_storage_device_command, SUCCESSFUL");
#endif
return error;
} /* Endbody */
/*FUNCTION*----------------------------------------------------------------
*
* Function Name : usb_class_audio_init_ipipe
* Returned Value : Success as USB_OK
* Comments :
* Starts interrupt endpoint to poll for interrupt on specified device.
*END*--------------------------------------------------------------------*/
USB_STATUS usb_class_audio_init_ipipe
(
/* control interface instance */
CLASS_CALL_STRUCT_PTR audio_instance,
/* Callback to application */
tr_callback user_callback,
/* Callback parameter */
void *user_callback_param
)
{ /* Body */
TR_INIT_PARAM_STRUCT tr;
USB_STATUS status = USBERR_NO_INTERFACE;
AUDIO_CONTROL_INTERFACE_STRUCT_PTR if_ptr;
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("usb_class_audio_init_ipipe");
#endif
USB_lock();
/* Validity checking, always needed when passing data to lower API */
if (usb_host_class_intf_validate(audio_instance)) {
if_ptr = (AUDIO_CONTROL_INTERFACE_STRUCT_PTR) audio_instance->class_intf_handle;
if_ptr->interrupt_callback = user_callback;
if_ptr->interrupt_callback_param = user_callback_param;
if (if_ptr->interrupt_pipe != NULL) {
usb_hostdev_tr_init(&tr, (tr_callback) usb_class_audio_int_callback, (void *) audio_instance);
tr.G.RX_BUFFER = (unsigned char *) &if_ptr->interrupt_buffer;
tr.G.RX_LENGTH = sizeof(if_ptr->interrupt_buffer);
if (USB_STATUS_TRANSFER_QUEUED == (status = _usb_host_recv_data(
if_ptr->AUDIO_G.G.host_handle,
if_ptr->interrupt_pipe,
&tr
)))
{
status = USB_OK;
}
}
else
status = USBERR_OPEN_PIPE_FAILED;
}/* Endif */
USB_unlock();
#ifdef _HOST_DEBUG_
if (!status)
DEBUG_LOG_TRACE("usb_class_audio_init_ipipe, SUCCESSFUL");
else
DEBUG_LOG_TRACE("usb_class_audio_init_ipipe, FAILED");
#endif
return status;
} /* End Body */
void usb_class_audio_control_init
(
/* [IN] structure with USB pipe information on the interface */
PIPE_BUNDLE_STRUCT_PTR pbs_ptr,
/* [IN] audio call struct pointer */
CLASS_CALL_STRUCT_PTR ccs_ptr
)
{ /* Body */
AUDIO_CONTROL_INTERFACE_STRUCT_PTR if_ptr = ccs_ptr->class_intf_handle;
USB_STATUS status;
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("usb_class_audio_control_init");
#endif
/* Make sure the device is still attached */
USB_lock();
status = usb_host_class_intf_init(pbs_ptr, if_ptr, &audio_control_anchor);
if (status == USB_OK) {
/*
** 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->interrupt_pipe = usb_hostdev_get_pipe_handle(pbs_ptr, USB_INTERRUPT_PIPE, 0);
if (MQX_OK != (status = _lwevent_create(&if_ptr->control_event, 0))) {
status = USBERR_INIT_FAILED;
}
else {
/* prepare events to be auto or manual */
_lwevent_set_auto_clear(&if_ptr->control_event, USB_AUDIO_CTRL_PIPE_FREE | USB_AUDIO_CTRL_INT_PIPE_FREE);
/* pre-set events */
_lwevent_set(&if_ptr->control_event, USB_AUDIO_CTRL_PIPE_FREE | USB_AUDIO_CTRL_INT_PIPE_FREE);
}
} /* 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_control_init, SUCCESSFUL");
else
DEBUG_LOG_TRACE("usb_class_audio_control_init, FAILED");
#endif
} /* Endbody */
USB_STATUS usb_class_hub_cntrl_common
(
/* [IN] The communication device common command structure */
HUB_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 windex,
/* [IN] Index field of CTRL packet */
uint_16 wlength,
/* [IN] Pointer to data buffer used to send/recv */
uchar_ptr data
)
{ /* Body */
USB_HUB_CLASS_INTF_STRUCT_PTR if_ptr;
USB_SETUP req;
USB_STATUS status = USBERR_NO_INTERFACE;
USB_lock();
/* Validity checking */
if (usb_host_class_intf_validate(com_ptr->CLASS_PTR)) {
if_ptr =
(USB_HUB_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;
htou16(req.WVALUE, wvalue);
htou16(req.WINDEX, windex);
htou16(req.WLENGTH, wlength);
status = _usb_hostdev_cntrl_request(if_ptr->G.dev_handle, &req, data,
usb_class_hub_cntrl_callback, if_ptr);
if (status == USB_STATUS_TRANSFER_QUEUED) {
if_ptr->IN_SETUP = TRUE;
} /* Endif */
} /* Endif */
USB_unlock();
return status;
} /* Endbody */
static void usb_class_cdc_in_data_callback
(
/* [IN] pointer to pipe */
_usb_pipe_handle pipe,
/* [IN] user-defined parameter */
pointer param,
/* [IN] buffer address */
pointer buffer,
/* [IN] length of data transferred */
uint_32 len,
/* [IN] status, hopefully USB_OK or USB_DONE */
uint_32 status
)
{ /* Body */
FILE_CDC_PTR fd_ptr = (FILE_CDC_PTR) param;
CLASS_CALL_STRUCT_PTR data_instance = (CLASS_CALL_STRUCT_PTR) fd_ptr->DEV_PTR->DRIVER_INIT_PTR;
USB_DATA_CLASS_INTF_STRUCT_PTR if_ptr;
CLASS_CALL_STRUCT_PTR acm_instance;
USB_ACM_CLASS_INTF_STRUCT_PTR acm_if_ptr;
UNUSED(pipe)
if_ptr = (USB_DATA_CLASS_INTF_STRUCT_PTR) data_instance->class_intf_handle;
acm_instance = if_ptr->BOUND_CONTROL_INTERFACE;
if ((acm_instance == NULL) || !usb_host_class_intf_validate(acm_instance))
len = 0;
else if (((CDC_SERIAL_INIT_PTR) fd_ptr->FLAGS)->FLAGS & USB_UART_HW_FLOW) {
acm_if_ptr = (USB_ACM_CLASS_INTF_STRUCT_PTR) acm_instance->class_intf_handle;
/* check the state of DCD signal for HW flow control files */
if (!(acm_if_ptr->interrupt_buffer.bmStates & USB_ACM_STATE_RX_CARRIER))
len = 0; /* ignore all received bytes is DCD is not set */
/* check the state of DTR signal */
if (!(acm_if_ptr->ctrl_state.bmStates[1] & USB_ACM_LINE_STATE_DTR))
len = 0; /* ignore all sent bytes if DTR is not set */
}
/* in the case we have less data than expected, status is not USB_OK, but buffer is not NULL */
if ((status != USB_OK) && (buffer == NULL)) /* if no data received */
len = 0;
if (if_ptr->RX_BUFFER_DRV != NULL)
if_ptr->RX_BUFFER_DRV += len;
if_ptr->RX_READ = len;
_usb_event_set(&if_ptr->data_event, USB_DATA_READ_COMPLETE); /* signal that we have completed transfer on input pipe */
} /*EndBody */
USB_STATUS usb_class_mass_getmaxlun_bulkonly
(
CLASS_CALL_STRUCT_PTR ccs_ptr,
uint_8_ptr pLUN,
tr_callback callback
)
{ /* Body */
USB_STATUS status = USBERR_NO_INTERFACE;
USB_SETUP request;
USB_MASS_CLASS_INTF_STRUCT_PTR intf_ptr;
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("usb_class_mass_getmaxlun_bulkonly");
#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;
status = usb_hostdev_validate(intf_ptr->G.dev_handle);
} /* Endif */
if (status) {
USB_unlock();
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("usb_class_mass_getmaxlun_bulkonly, error status");
#endif
return status;
} /* Endif */
/* Get the number of logical units on the device */
request.BMREQUESTTYPE = REQ_TYPE_CLASS | REQ_TYPE_INTERFACE | REQ_TYPE_IN;
request.BREQUEST = GET_MAX_LUN;
htou16(request.WVALUE, 0);
htou16(request.WINDEX, ((INTERFACE_DESCRIPTOR_PTR)intf_ptr->G.intf_handle)->bInterfaceNumber);
htou16(request.WLENGTH, 1);
/* Send request */
status = _usb_hostdev_cntrl_request (intf_ptr->G.dev_handle,
&request, (uchar_ptr)pLUN, callback, NULL);
USB_unlock();
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("usb_class_mass_getmaxlun_bulkonly, SUCCESSFUL");
#endif
return status;
} /* Endbody */
void usb_class_hid_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_HID_CLASS_INTF_STRUCT_PTR if_ptr = ccs_ptr->class_intf_handle;
USB_STATUS status;
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("usb_class_hid_init");
#endif
/* Make sure the device is still attached */
USB_lock();
status = usb_host_class_intf_init(pbs_ptr, if_ptr, &hid_anchor);
if (status == USB_OK) {
/*
** 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->IFNUM =
// ((INTERFACE_DESCRIPTOR_PTR)if_ptr->G.intf_handle)->bInterfaceNumber;
// if_ptr->P_CONTROL = usb_hostdev_get_pipe_handle(pbs_ptr, USB_CONTROL_PIPE,
// 0);
// if_ptr->P_INT_IN = usb_hostdev_get_pipe_handle(pbs_ptr,
// USB_INTERRUPT_PIPE, USB_RECV);
} /* Endif */
/* Signal that an error has occured by setting the "code_key" to 0 */
// if (status || !if_ptr->P_INT_IN || !if_ptr->P_CONTROL) {
// ccs_ptr->code_key = 0;
// } /* Endif */
USB_unlock();
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("usb_class_hid_init, SUCCESSFUL");
#endif
} /* Endbody */
USB_STATUS usb_class_cdc_unbind_acm_interface
(
CLASS_CALL_STRUCT_PTR ccs_ptr
)
{
USB_DATA_CLASS_INTF_STRUCT_PTR if_ptr;
if (usb_host_class_intf_validate(ccs_ptr)) {
if_ptr = (USB_DATA_CLASS_INTF_STRUCT_PTR) ccs_ptr->class_intf_handle;
usb_class_cdc_unregister_interface(ccs_ptr, &data_anchor);
if_ptr->BOUND_CONTROL_INTERFACE = NULL;
}
return USB_OK;
}
USB_STATUS usb_printer_class_verify
(
/* [IN] class-interface data pointer + key */
CLASS_CALL_STRUCT_PTR cc_ptr,
/* [IN] TR memory already allocated, initialized here */
TR_INIT_PARAM_STRUCT_PTR tr_ptr,
/* [IN] callback for completion/status */
tr_callback callback,
/* [IN] user parameter returned by callback */
pointer call_parm
)
{ /* Body */
PRINTER_INTERFACE_STRUCT_PTR pis_ptr;
USB_STATUS error = USBERR_NO_INTERFACE;
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("usb_printer_class_verify");
#endif
USB_lock ();
if (usb_host_class_intf_validate (cc_ptr)) {
pis_ptr = (PRINTER_INTERFACE_STRUCT_PTR)
cc_ptr->class_intf_handle;
error = usb_hostdev_validate (pis_ptr->dev_handle);
if (error == USB_OK) {
if (callback == NULL) {
error = USBERR_NULL_CALLBACK;
} else {
usb_hostdev_tr_init (tr_ptr, callback, call_parm);
} /* Endif */
} /* EndIf */
} /* Endif */
USB_unlock ();
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("usb_printer_class_verify, SUCCESSFUL");
#endif
return error;
} /* Endbody */
CLASS_CALL_STRUCT_PTR usb_class_cdc_get_data_interface
(
/* [IN] pointer to interface handle */
pointer2 intf_handle
)
{
CLASS_CALL_STRUCT_PTR data_parser;
/* find this acm interface in the list with interface descriptor */
for (data_parser = data_anchor; data_parser != NULL; data_parser = data_parser->next)
if (usb_host_class_intf_validate(data_parser))
if (((USB_ACM_CLASS_INTF_STRUCT_PTR) data_parser->class_intf_handle)->CDC_G.G.intf_handle == intf_handle)
break;
return data_parser;
}
USB_STATUS usb_class_audio_control_set_descriptors
(
/* [IN] class call struct pointer */
CLASS_CALL_STRUCT_PTR ccs_ptr,
/* [IN] header descriptor pointer */
USB_AUDIO_CTRL_DESC_HEADER_PTR header_desc,
/* [IN] input terminal descriptor pointer */
USB_AUDIO_CTRL_DESC_IT_PTR it_desc,
/* [IN] output terminal descriptor pointer */
USB_AUDIO_CTRL_DESC_OT_PTR ot_desc,
/* [IN] feature unit descriptor pointer */
USB_AUDIO_CTRL_DESC_FU_PTR fu_desc
)
{ /* Body */
AUDIO_CONTROL_INTERFACE_STRUCT_PTR if_ptr;
USB_STATUS status = USBERR_NO_INTERFACE;
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("usb_class_audio_control_set_descriptors");
#endif
/* Make sure the device is still attached */
USB_lock();
/* Validity checking */
if (usb_host_class_intf_validate(ccs_ptr)) {
if_ptr = (AUDIO_CONTROL_INTERFACE_STRUCT_PTR)ccs_ptr->class_intf_handle;
if_ptr->header_desc = header_desc;
if_ptr->it_desc = it_desc;
if_ptr->ot_desc = ot_desc;
if_ptr->fu_desc = fu_desc;
} /* Endif */
USB_unlock();
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("usb_class_audio_control_set_descriptors, SUCCESSFUL");
#endif
return status;
} /* Endbody */
/*FUNCTION*----------------------------------------------------------------
*
* Function Name : usb_class_audio_feature_command
* Returned Value : USB_OK if command has been passed on USB
* Comments :
* This function is called by the application to get or set feature units
* of audio device
*END*--------------------------------------------------------------------*/
USB_STATUS usb_class_audio_feature_command
(
/* [IN] Class Interface structure pointer */
AUDIO_COMMAND_PTR com_ptr,
/* [IN] channel number */
uint8_t channel_no,
/* [IN] Buffer to send data */
void *buf,
/* [IN] The command to perform */
uint32_t cmd
)
{ /* Body */
uint16_t wIndex;
uint16_t request_value;
AUDIO_CONTROL_INTERFACE_STRUCT_PTR if_ptr;
USB_AUDIO_COMMAND_PTR p_feature_command;
USB_STATUS status = USBERR_ERROR;
if_ptr = (AUDIO_CONTROL_INTERFACE_STRUCT_PTR)com_ptr->CLASS_PTR->class_intf_handle;
/* Validity checking: for audio interface */
status = usb_host_class_intf_validate(if_ptr);
if (USB_OK == status)
{
/* pointer to command */
p_feature_command = &(usb_audio_feature_commands[cmd]);
/* get request value */
request_value = (uint16_t)((p_feature_command->request_value << 8) | channel_no);
wIndex = (uint16_t)(((if_ptr->fu_desc->bUnitID)<<8)|(if_ptr->AUDIO_G.IFNUM));
/* Check whether this attribute valid or not */
status = check_valid_fu(if_ptr->fu_desc,p_feature_command->control_mask,if_ptr->fu_desc->bControlSize*channel_no);
if (USB_OK == status)
{
status = usb_class_audio_cntrl_common(com_ptr,
p_feature_command->request_type,
p_feature_command->request_code,
request_value,
wIndex,
p_feature_command->length,
buf);
}
}
return status;
}
void usb_class_cdc_acm_init
(
/* [IN] structure with USB pipe information on the interface */
PIPE_BUNDLE_STRUCT_PTR pbs_ptr,
/* [IN] acm call struct pointer2 */
CLASS_CALL_STRUCT_PTR ccs_ptr
)
{ /* Body */
USB_ACM_CLASS_INTF_STRUCT_PTR acm_anchor = NULL;
USB_ACM_CLASS_INTF_STRUCT_PTR if_ptr = ccs_ptr->class_intf_handle;
USB_STATUS status;
/* Make sure the device is still attached */
USB_lock();
status = usb_host_class_intf_init(pbs_ptr, if_ptr, &acm_anchor_abstract);
if (status == USB_OK) {
/*
** 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->CDC_G.IFNUM = ((INTERFACE_DESCRIPTOR_PTR)if_ptr->CDC_G.G.intf_handle)->bInterfaceNumber;
if_ptr->interrupt_pipe = usb_hostdev_get_pipe_handle(pbs_ptr, USB_INTERRUPT_PIPE, 0);
if (USB_OK != (status = _usb_event_init(&if_ptr->acm_event))) {
status = USBERR_INIT_FAILED;
}
else {
/* prepare events to be auto or manual */
//_lwevent_set_auto_clear(&if_ptr->acm_event, USB_ACM_CTRL_PIPE_FREE | USB_ACM_INT_PIPE_FREE);
/* pre-set events */
_usb_event_set(&if_ptr->acm_event, USB_ACM_CTRL_PIPE_FREE | USB_ACM_INT_PIPE_FREE);
}
} /* Endif */
/* Signal that an error has occured by setting the "code_key" */
if (status) {
ccs_ptr->code_key = 0;
} /* Endif */
USB_unlock();
} /* Endbody */
USB_STATUS usb_printer_class_send
(
/* [IN] class-interface data pointer + key */
CLASS_CALL_STRUCT_PTR cc_ptr,
/* [IN] TR containing setup packet to be sent */
TR_INIT_PARAM_STRUCT_PTR tr_ptr
)
{ /* Body */
DESCRIPTOR_UNION desc;
PRINTER_INTERFACE_STRUCT_PTR pis_ptr;
USB_STATUS error = USBERR_NO_INTERFACE;
USB_SETUP_PTR dev_req;
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("usb_printer_class_send");
#endif
USB_lock ();
if (usb_host_class_intf_validate (cc_ptr)) {
pis_ptr = (PRINTER_INTERFACE_STRUCT_PTR)
cc_ptr->class_intf_handle;
desc.pntr = pis_ptr->intf_handle;
dev_req = (USB_SETUP_PTR)tr_ptr->DEV_REQ_PTR;
*(uint_16*)dev_req->WVALUE = HOST_TO_LE_SHORT_CONST(0);
dev_req->WINDEX[0] = desc.intf->bAlternateSetting;
dev_req->WINDEX[1] = desc.intf->bInterfaceNumber;
*(uint_16*)dev_req->WLENGTH = HOST_TO_LE_SHORT(tr_ptr->G.RX_LENGTH);
error = _usb_host_send_setup (pis_ptr->host_handle,
pis_ptr->control_pipe,
tr_ptr);
} /* EndIf */
USB_unlock ();
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("usb_printer_class_send, SUCCESSFUL");
#endif
return error;
} /* Endbody */
USB_STATUS usb_printer_bulk_inout
(
/* [IN] class-interface data pointer + key */
CLASS_CALL_STRUCT_PTR cc_ptr,
/* [IN] TR containing setup packet to be sent */
TR_INIT_PARAM_STRUCT_PTR tr_ptr,
/* [IN] send_flag = TRUE means send, = FALSE means receive */
boolean send_flag
)
{ /* Body */
PRINTER_INTERFACE_STRUCT_PTR pis_ptr;
USB_STATUS error = USBERR_NO_INTERFACE;
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("usb_printer_bulk_inout");
#endif
USB_lock ();
if (usb_host_class_intf_validate(cc_ptr)) {
pis_ptr = (PRINTER_INTERFACE_STRUCT_PTR)
cc_ptr->class_intf_handle;
if (send_flag) {
error = _usb_host_send_data (pis_ptr->host_handle,
pis_ptr->bulk_out_pipe, tr_ptr);
} else {
error = _usb_host_recv_data (pis_ptr->host_handle,
pis_ptr->control_pipe, tr_ptr);
} /* EndIf */
} /* Endif */
USB_unlock ();
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("usb_printer_bulk_inout, SUCCESSFUL");
#endif
return error;
} /* Endbody */
USB_STATUS usb_class_cdc_unbind_data_interfaces
(
CLASS_CALL_STRUCT_PTR ccs_ptr
)
{
CLASS_CALL_STRUCT_PTR data_parser;
for (data_parser = data_anchor; data_parser != NULL; data_parser = data_parser->next)
{
if (usb_host_class_intf_validate(data_parser))
if (((USB_DATA_CLASS_INTF_STRUCT_PTR) (data_parser->class_intf_handle))->BOUND_CONTROL_INTERFACE == ccs_ptr)
((USB_DATA_CLASS_INTF_STRUCT_PTR) (data_parser->class_intf_handle))->BOUND_CONTROL_INTERFACE = NULL;
}
/* Delete control interface for data interfaces included later */
usb_class_cdc_unregister_interface(ccs_ptr, &ctrl_anchor);
return USB_OK;
}
USB_STATUS usb_class_audio_stream_set_descriptors
(
/* [IN] class call struct pointer */
CLASS_CALL_STRUCT_PTR ccs_ptr,
/* [IN] audio stream interface descriptor pointer */
USB_AUDIO_STREAM_DESC_SPEPIFIC_AS_IF_PTR as_itf_desc,
/* [IN] format type descriptor pointer */
USB_AUDIO_STREAM_DESC_FORMAT_TYPE_PTR frm_type_desc,
/* [IN] isochonous endpoint specific descriptor pointer */
USB_AUDIO_STREAM_DESC_SPECIFIC_ISO_ENDP_PTR iso_endp_spec_desc
)
{ /* Body */
AUDIO_STREAM_INTERFACE_STRUCT_PTR if_ptr;
USB_STATUS status = USBERR_NO_INTERFACE;
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("usb_class_audio_stream_set_descriptors");
#endif
/* Make sure the device is still attached */
USB_lock();
/* Validity checking */
if (usb_host_class_intf_validate(ccs_ptr)) {
if_ptr = (AUDIO_STREAM_INTERFACE_STRUCT_PTR)ccs_ptr->class_intf_handle;
if_ptr->as_itf_desc = as_itf_desc;
if_ptr->frm_type_desc = frm_type_desc;
if_ptr->iso_endp_spec_desc = iso_endp_spec_desc;
} /* Endif */
USB_unlock();
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("usb_class_audio_control_set_descriptors, SUCCESSFUL");
#endif
return status;
} /* Endbody */
USB_STATUS usb_class_cdc_uninstall_driver
(
CLASS_CALL_STRUCT_PTR data_instance
)
{
USB_DATA_CLASS_INTF_STRUCT_PTR if_ptr;
USB_STATUS status = USBERR_NO_INTERFACE;
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;
//status = _io_dev_uninstall(if_ptr->device_name);
}
USB_unlock();
return status;
}
USB_STATUS usb_class_cdc_set_acm_descriptors
(
/* [IN] acm call struct pointer */
CLASS_CALL_STRUCT_PTR ccs_ptr,
/* [IN] acm functional descriptor pointer */
USB_CDC_DESC_ACM_PTR acm_desc,
/* [IN] acm functional descriptor pointer */
USB_CDC_DESC_CM_PTR cm_desc,
/* [IN] header functional descriptor pointer */
USB_CDC_DESC_HEADER_PTR header_desc,
/* [IN] union functional descriptor pointer */
USB_CDC_DESC_UNION_PTR union_desc
)
{ /* Body */
USB_ACM_CLASS_INTF_STRUCT_PTR if_ptr;
USB_STATUS status = USBERR_NO_INTERFACE;
/* Make sure the device is still attached */
USB_lock();
/* Validity checking */
if (usb_host_class_intf_validate(ccs_ptr)) {
if_ptr = (USB_CDC_GENERAL_CLASS_PTR)ccs_ptr->class_intf_handle;
if_ptr->acm_desc = acm_desc;
if_ptr->header_desc = header_desc;
if_ptr->union_desc = union_desc;
} /* Endif */
USB_unlock();
return status;
} /* Endbody */
USB_STATUS usb_class_cdc_init_ipipe
(
/* ACM interface instance */
CLASS_CALL_STRUCT_PTR acm_instance
)
{ /* Body */
TR_INIT_PARAM_STRUCT tr;
USB_STATUS status = USBERR_NO_INTERFACE;
USB_ACM_CLASS_INTF_STRUCT_PTR if_ptr;
USB_lock();
/* Validity checking, always needed when passing data to lower API */
if (usb_host_class_intf_validate(acm_instance)) {
if_ptr = (USB_ACM_CLASS_INTF_STRUCT_PTR) acm_instance->class_intf_handle;
if (if_ptr->interrupt_pipe != NULL) {
usb_hostdev_tr_init(&tr, (tr_callback)usb_class_cdc_int_acm_callback, (pointer) acm_instance);
tr.RX_BUFFER = (uchar_ptr)&if_ptr->interrupt_buffer;
tr.RX_LENGTH = sizeof(if_ptr->interrupt_buffer);
if (USB_STATUS_TRANSFER_QUEUED == (status = _usb_host_recv_data(
if_ptr->CDC_G.G.host_handle,
if_ptr->interrupt_pipe,
&tr
)))
{
status = USB_OK;
}
}
else
status = USBERR_OPEN_PIPE_FAILED;
}
USB_unlock();
return status;
}
