2021-12-13 21:39:13 -08:00
|
|
|
/**
|
|
|
|
**************************************************************************
|
|
|
|
* @file usbh_ctrl.c
|
|
|
|
* @brief usb host control request
|
|
|
|
**************************************************************************
|
|
|
|
* Copyright notice & Disclaimer
|
|
|
|
*
|
2022-04-11 04:50:25 -07:00
|
|
|
* The software Board Support Package (BSP) that is made available to
|
|
|
|
* download from Artery official website is the copyrighted work of Artery.
|
|
|
|
* Artery authorizes customers to use, copy, and distribute the BSP
|
|
|
|
* software and its related documentation for the purpose of design and
|
|
|
|
* development in conjunction with Artery microcontrollers. Use of the
|
2021-12-13 21:39:13 -08:00
|
|
|
* software is governed by this copyright notice and the following disclaimer.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED ON "AS IS" BASIS WITHOUT WARRANTIES,
|
|
|
|
* GUARANTEES OR REPRESENTATIONS OF ANY KIND. ARTERY EXPRESSLY DISCLAIMS,
|
|
|
|
* TO THE FULLEST EXTENT PERMITTED BY LAW, ALL EXPRESS, IMPLIED OR
|
|
|
|
* STATUTORY OR OTHER WARRANTIES, GUARANTEES OR REPRESENTATIONS,
|
|
|
|
* INCLUDING BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT.
|
|
|
|
*
|
|
|
|
**************************************************************************
|
|
|
|
*/
|
|
|
|
#include "usbh_ctrl.h"
|
|
|
|
#include "usbh_core.h"
|
|
|
|
#include "usb_std.h"
|
|
|
|
|
|
|
|
/** @addtogroup AT32F435_437_middlewares_usbh_drivers
|
|
|
|
* @{
|
|
|
|
*/
|
2022-04-11 04:50:25 -07:00
|
|
|
|
2021-12-13 21:39:13 -08:00
|
|
|
/** @defgroup USBH_drivers_control
|
|
|
|
* @brief usb host drivers control
|
|
|
|
* @{
|
2022-04-11 04:50:25 -07:00
|
|
|
*/
|
2021-12-13 21:39:13 -08:00
|
|
|
|
|
|
|
/** @defgroup USBH_ctrl_private_functions
|
|
|
|
* @{
|
|
|
|
*/
|
2022-04-11 04:50:25 -07:00
|
|
|
|
|
|
|
/* control timeout 5s */
|
2022-03-03 03:49:19 -08:00
|
|
|
#define CTRL_TIMEOUT 5000
|
2021-12-13 21:39:13 -08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief usb host control send setup packet
|
|
|
|
* @param uhost: to the structure of usbh_core_type
|
|
|
|
* @param buffer: usb control setup send buffer
|
|
|
|
* @param hc_num: channel number
|
|
|
|
* @retval status: usb_sts_type status
|
|
|
|
*/
|
|
|
|
usb_sts_type usbh_ctrl_send_setup(usbh_core_type *uhost, uint8_t *buffer, uint8_t hc_num)
|
|
|
|
{
|
|
|
|
uhost->hch[hc_num].dir = 0;
|
|
|
|
uhost->hch[hc_num].data_pid = HCH_PID_SETUP;
|
|
|
|
uhost->hch[hc_num].trans_buf = buffer;
|
|
|
|
uhost->hch[hc_num].trans_len = 8; /*setup */
|
2022-04-11 04:50:25 -07:00
|
|
|
|
2021-12-13 21:39:13 -08:00
|
|
|
return usbh_in_out_request(uhost, hc_num);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief usb host control receive data from device
|
|
|
|
* @param uhost: to the structure of usbh_core_type
|
|
|
|
* @param buffer: usb control receive data buffer
|
|
|
|
* @param length: usb control receive data length
|
|
|
|
* @param hc_num: channel number
|
|
|
|
* @retval status: usb_sts_type status
|
|
|
|
*/
|
2022-04-11 04:50:25 -07:00
|
|
|
usb_sts_type usbh_ctrl_recv_data(usbh_core_type *uhost, uint8_t *buffer,
|
2022-08-25 23:56:40 -07:00
|
|
|
uint16_t length, uint16_t hc_num)
|
2021-12-13 21:39:13 -08:00
|
|
|
{
|
|
|
|
uhost->hch[hc_num].dir = 1;
|
|
|
|
uhost->hch[hc_num].data_pid = HCH_PID_DATA1;
|
|
|
|
uhost->hch[hc_num].trans_buf = buffer;
|
2022-04-11 04:50:25 -07:00
|
|
|
uhost->hch[hc_num].trans_len = length;
|
|
|
|
|
2021-12-13 21:39:13 -08:00
|
|
|
return usbh_in_out_request(uhost, hc_num);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief usb host control send data packet
|
|
|
|
* @param uhost: to the structure of usbh_core_type
|
|
|
|
* @param buffer: usb control send data buffer
|
|
|
|
* @param length: usb control send data length
|
|
|
|
* @param hc_num: channel number
|
|
|
|
* @retval status: usb_sts_type status
|
|
|
|
*/
|
2022-04-11 04:50:25 -07:00
|
|
|
usb_sts_type usbh_ctrl_send_data(usbh_core_type *uhost, uint8_t *buffer,
|
2022-08-25 23:56:40 -07:00
|
|
|
uint16_t length, uint16_t hc_num)
|
2021-12-13 21:39:13 -08:00
|
|
|
{
|
|
|
|
uhost->hch[hc_num].dir = 0;
|
|
|
|
uhost->hch[hc_num].trans_buf = buffer;
|
|
|
|
uhost->hch[hc_num].trans_len = length;
|
2022-04-11 04:50:25 -07:00
|
|
|
|
2021-12-13 21:39:13 -08:00
|
|
|
if(length == 0)
|
|
|
|
{
|
|
|
|
uhost->hch[uhost->ctrl.hch_out].toggle_out = 1;
|
|
|
|
}
|
|
|
|
if(uhost->hch[uhost->ctrl.hch_out].toggle_out == 0)
|
|
|
|
{
|
|
|
|
uhost->hch[hc_num].data_pid = HCH_PID_DATA0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
uhost->hch[hc_num].data_pid = HCH_PID_DATA1;
|
|
|
|
}
|
|
|
|
return usbh_in_out_request(uhost, hc_num);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief usb host control setup request handler
|
|
|
|
* @param uhost: to the structure of usbh_core_type
|
|
|
|
* @retval status: usb_sts_type status
|
|
|
|
*/
|
|
|
|
usb_sts_type usbh_ctrl_setup_handler(usbh_core_type *uhost)
|
|
|
|
{
|
2022-04-11 04:50:25 -07:00
|
|
|
usbh_ctrl_send_setup(uhost, (uint8_t *)(&uhost->ctrl.setup),
|
2021-12-13 21:39:13 -08:00
|
|
|
uhost->ctrl.hch_out);
|
|
|
|
uhost->ctrl.state = CONTROL_SETUP_WAIT;
|
|
|
|
return USB_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief usb host control setup request wait handler
|
|
|
|
* @param uhost: to the structure of usbh_core_type
|
|
|
|
* @param timeout: pointer of wait timeout
|
|
|
|
* @retval status: usb_sts_type status
|
|
|
|
*/
|
|
|
|
usb_sts_type usbh_ctrl_setup_wait_handler(usbh_core_type *uhost, uint32_t *timeout)
|
|
|
|
{
|
|
|
|
urb_sts_type urb_state;
|
|
|
|
usb_sts_type status = USB_WAIT;
|
|
|
|
uint8_t dir;
|
|
|
|
urb_state = uhost->urb_state[uhost->ctrl.hch_out];
|
|
|
|
if(urb_state == URB_DONE)
|
|
|
|
{
|
|
|
|
dir = uhost->ctrl.setup.bmRequestType & USB_REQUEST_DIR_MASK;
|
|
|
|
if(uhost->ctrl.setup.wLength != 0)
|
|
|
|
{
|
|
|
|
*timeout = DATA_STAGE_TIMEOUT;
|
|
|
|
if(dir == USB_DIR_D2H) //in
|
|
|
|
{
|
|
|
|
uhost->ctrl.state = CONTROL_DATA_IN;
|
|
|
|
}
|
|
|
|
else //out
|
|
|
|
{
|
|
|
|
uhost->ctrl.state = CONTROL_DATA_OUT;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
*timeout = NODATA_STAGE_TIMEOUT;
|
|
|
|
if(dir == USB_DIR_D2H) //no data, send status
|
|
|
|
{
|
|
|
|
uhost->ctrl.state = CONTROL_STATUS_OUT;
|
|
|
|
}
|
|
|
|
else //out
|
|
|
|
{
|
|
|
|
uhost->ctrl.state = CONTROL_STATUS_IN;
|
|
|
|
}
|
|
|
|
}
|
2023-02-27 19:07:11 -08:00
|
|
|
uhost->ctrl.timer = uhost->timer;
|
2021-12-13 21:39:13 -08:00
|
|
|
status = USB_OK;
|
|
|
|
}
|
2022-03-03 03:49:19 -08:00
|
|
|
else if(urb_state == URB_ERROR || urb_state == URB_NOTREADY)
|
2021-12-13 21:39:13 -08:00
|
|
|
{
|
|
|
|
uhost->ctrl.state = CONTROL_ERROR;
|
|
|
|
uhost->ctrl.sts = CTRL_XACTERR;
|
|
|
|
status = USB_ERROR;
|
|
|
|
}
|
2022-03-03 03:49:19 -08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
/* wait nak timeout 5s*/
|
|
|
|
if(uhost->timer - uhost->ctrl.timer > CTRL_TIMEOUT)
|
|
|
|
{
|
|
|
|
uhost->ctrl.state = CONTROL_ERROR;
|
|
|
|
uhost->ctrl.sts = CTRL_XACTERR;
|
|
|
|
status = USB_ERROR;
|
|
|
|
}
|
|
|
|
}
|
2021-12-13 21:39:13 -08:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief usb host control data in request handler
|
|
|
|
* @param uhost: to the structure of usbh_core_type
|
|
|
|
* @retval status: usb_sts_type status
|
|
|
|
*/
|
|
|
|
usb_sts_type usbh_ctrl_data_in_handler(usbh_core_type *uhost)
|
|
|
|
{
|
|
|
|
usb_sts_type status = USB_OK;
|
2022-04-11 04:50:25 -07:00
|
|
|
usbh_ctrl_recv_data(uhost, uhost->ctrl.buffer,
|
2021-12-13 21:39:13 -08:00
|
|
|
uhost->ctrl.len,
|
|
|
|
uhost->ctrl.hch_in);
|
|
|
|
uhost->ctrl.state = CONTROL_DATA_IN_WAIT;
|
2022-04-11 04:50:25 -07:00
|
|
|
|
2021-12-13 21:39:13 -08:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief usb host control data in wait handler
|
|
|
|
* @param uhost: to the structure of usbh_core_type
|
|
|
|
* @param timeout: wait timeout
|
|
|
|
* @retval status: usb_sts_type status
|
|
|
|
*/
|
|
|
|
usb_sts_type usbh_ctrl_data_in_wait_handler(usbh_core_type *uhost, uint32_t timeout)
|
|
|
|
{
|
|
|
|
usb_sts_type status = USB_OK;
|
|
|
|
urb_sts_type urb_state;
|
|
|
|
urb_state = uhost->urb_state[uhost->ctrl.hch_in];
|
2022-04-11 04:50:25 -07:00
|
|
|
|
2021-12-13 21:39:13 -08:00
|
|
|
if(urb_state == URB_DONE)
|
|
|
|
{
|
|
|
|
uhost->ctrl.state = CONTROL_STATUS_OUT;
|
|
|
|
}
|
|
|
|
else if(urb_state == URB_STALL)
|
|
|
|
{
|
|
|
|
uhost->ctrl.state = CONTROL_STALL;
|
|
|
|
}
|
|
|
|
else if(urb_state == URB_ERROR)
|
|
|
|
{
|
|
|
|
uhost->ctrl.state = CONTROL_ERROR;
|
|
|
|
}
|
2022-03-03 03:49:19 -08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
/* wait nak timeout 5s*/
|
|
|
|
if(uhost->timer - uhost->ctrl.timer > CTRL_TIMEOUT)
|
|
|
|
{
|
|
|
|
uhost->ctrl.state = CONTROL_ERROR;
|
|
|
|
uhost->ctrl.sts = CTRL_XACTERR;
|
|
|
|
status = USB_ERROR;
|
|
|
|
}
|
2022-04-11 04:50:25 -07:00
|
|
|
|
2022-03-03 03:49:19 -08:00
|
|
|
}
|
2021-12-13 21:39:13 -08:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief usb host control data out request handler
|
|
|
|
* @param uhost: to the structure of usbh_core_type
|
|
|
|
* @retval status: usb_sts_type status
|
|
|
|
*/
|
|
|
|
usb_sts_type usbh_ctrl_data_out_handler(usbh_core_type *uhost)
|
|
|
|
{
|
|
|
|
usb_sts_type status = USB_OK;
|
|
|
|
uhost->hch[uhost->ctrl.hch_out].toggle_out = 1;
|
2022-04-11 04:50:25 -07:00
|
|
|
|
|
|
|
usbh_ctrl_send_data(uhost, uhost->ctrl.buffer,
|
2021-12-13 21:39:13 -08:00
|
|
|
uhost->ctrl.len,
|
|
|
|
uhost->ctrl.hch_out);
|
|
|
|
uhost->ctrl.state = CONTROL_DATA_OUT_WAIT;
|
2022-04-11 04:50:25 -07:00
|
|
|
|
2021-12-13 21:39:13 -08:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief usb host control data out wait handler
|
|
|
|
* @param uhost: to the structure of usbh_core_type
|
|
|
|
* @param timeout: wait timeout
|
|
|
|
* @retval status: usb_sts_type status
|
|
|
|
*/
|
|
|
|
usb_sts_type usbh_ctrl_data_out_wait_handler(usbh_core_type *uhost, uint32_t timeout)
|
|
|
|
{
|
|
|
|
usb_sts_type status = USB_OK;
|
|
|
|
urb_sts_type urb_state;
|
|
|
|
urb_state = uhost->urb_state[uhost->ctrl.hch_out];
|
|
|
|
if(urb_state == URB_DONE)
|
|
|
|
{
|
|
|
|
uhost->ctrl.state = CONTROL_STATUS_IN;
|
|
|
|
}
|
|
|
|
else if(urb_state == URB_STALL)
|
|
|
|
{
|
|
|
|
uhost->ctrl.state = CONTROL_STALL;
|
|
|
|
}
|
|
|
|
else if(urb_state == URB_ERROR)
|
|
|
|
{
|
|
|
|
uhost->ctrl.state = CONTROL_ERROR;
|
|
|
|
}
|
|
|
|
else if(urb_state == URB_NOTREADY)
|
|
|
|
{
|
|
|
|
uhost->ctrl.state = CONTROL_DATA_OUT;
|
|
|
|
}
|
2023-02-27 19:07:11 -08:00
|
|
|
|
|
|
|
/* wait nak timeout 5s*/
|
|
|
|
if((uhost->timer - uhost->ctrl.timer > CTRL_TIMEOUT) && (urb_state == URB_NOTREADY))
|
2022-03-03 03:49:19 -08:00
|
|
|
{
|
2023-02-27 19:07:11 -08:00
|
|
|
uhost->ctrl.state = CONTROL_ERROR;
|
|
|
|
uhost->ctrl.sts = CTRL_XACTERR;
|
|
|
|
status = USB_ERROR;
|
2022-03-03 03:49:19 -08:00
|
|
|
}
|
2021-12-13 21:39:13 -08:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief usb host control status data in handler
|
|
|
|
* @param uhost: to the structure of usbh_core_type
|
|
|
|
* @retval status: usb_sts_type status
|
|
|
|
*/
|
|
|
|
usb_sts_type usbh_ctrl_status_in_handler(usbh_core_type *uhost)
|
|
|
|
{
|
|
|
|
usb_sts_type status = USB_OK;
|
|
|
|
usbh_ctrl_recv_data(uhost, 0, 0,
|
|
|
|
uhost->ctrl.hch_in);
|
|
|
|
uhost->ctrl.state = CONTROL_STATUS_IN_WAIT;
|
2022-04-11 04:50:25 -07:00
|
|
|
|
|
|
|
|
2021-12-13 21:39:13 -08:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief usb host control status data in wait handler
|
|
|
|
* @param uhost: to the structure of usbh_core_type
|
|
|
|
* @param timeout: wait timeout
|
|
|
|
* @retval status: usb_sts_type status
|
|
|
|
*/
|
|
|
|
usb_sts_type usbh_ctrl_status_in_wait_handler(usbh_core_type *uhost, uint32_t timeout)
|
|
|
|
{
|
|
|
|
usb_sts_type status = USB_OK;
|
|
|
|
urb_sts_type urb_state;
|
|
|
|
urb_state = uhost->urb_state[uhost->ctrl.hch_in];
|
|
|
|
if(urb_state == URB_DONE)
|
|
|
|
{
|
|
|
|
uhost->ctrl.state = CONTROL_COMPLETE;
|
|
|
|
}
|
|
|
|
else if(urb_state == URB_STALL)
|
|
|
|
{
|
|
|
|
uhost->ctrl.state = CONTROL_STALL;
|
|
|
|
status = USB_NOT_SUPPORT;
|
|
|
|
}
|
|
|
|
else if(urb_state == URB_ERROR)
|
|
|
|
{
|
|
|
|
uhost->ctrl.state = CONTROL_ERROR;
|
|
|
|
}
|
2022-03-03 03:49:19 -08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
/* wait nak timeout 5s*/
|
|
|
|
if(uhost->timer - uhost->ctrl.timer > CTRL_TIMEOUT)
|
|
|
|
{
|
|
|
|
uhost->ctrl.state = CONTROL_ERROR;
|
|
|
|
uhost->ctrl.sts = CTRL_XACTERR;
|
|
|
|
status = USB_ERROR;
|
|
|
|
}
|
|
|
|
}
|
2021-12-13 21:39:13 -08:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief usb host control status data out wait handler
|
|
|
|
* @param uhost: to the structure of usbh_core_type
|
|
|
|
* @retval status: usb_sts_type status
|
|
|
|
*/
|
|
|
|
usb_sts_type usbh_ctrl_status_out_handler(usbh_core_type *uhost)
|
|
|
|
{
|
|
|
|
usb_sts_type status = USB_OK;
|
|
|
|
uhost->hch[uhost->ctrl.hch_out].toggle_out ^= 1;
|
2022-04-11 04:50:25 -07:00
|
|
|
|
2021-12-13 21:39:13 -08:00
|
|
|
usbh_ctrl_send_data(uhost, 0, 0, uhost->ctrl.hch_out);
|
|
|
|
uhost->ctrl.state = CONTROL_STATUS_OUT_WAIT;
|
2022-04-11 04:50:25 -07:00
|
|
|
|
2021-12-13 21:39:13 -08:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief usb host control status data out wait handler
|
|
|
|
* @param uhost: to the structure of usbh_core_type
|
|
|
|
* @param timeout: wait timeout
|
|
|
|
* @retval status: usb_sts_type status
|
|
|
|
*/
|
|
|
|
usb_sts_type usbh_ctrl_status_out_wait_handler(usbh_core_type *uhost, uint32_t timeout)
|
|
|
|
{
|
|
|
|
usb_sts_type status = USB_OK;
|
|
|
|
urb_sts_type urb_state;
|
|
|
|
urb_state = uhost->urb_state[uhost->ctrl.hch_out];
|
|
|
|
if(urb_state == URB_DONE)
|
|
|
|
{
|
|
|
|
uhost->ctrl.state = CONTROL_COMPLETE;
|
|
|
|
}
|
|
|
|
else if(urb_state == URB_STALL)
|
|
|
|
{
|
|
|
|
uhost->ctrl.state = CONTROL_STALL;
|
|
|
|
}
|
|
|
|
else if(urb_state == URB_ERROR)
|
|
|
|
{
|
|
|
|
uhost->ctrl.state = CONTROL_ERROR;
|
|
|
|
}
|
|
|
|
else if(urb_state == URB_NOTREADY)
|
|
|
|
{
|
|
|
|
uhost->ctrl.state = CONTROL_STATUS_OUT;
|
|
|
|
}
|
2023-02-27 19:07:11 -08:00
|
|
|
/* wait nak timeout 5s*/
|
|
|
|
if((uhost->timer - uhost->ctrl.timer > CTRL_TIMEOUT) && (urb_state == URB_NOTREADY))
|
2022-03-03 03:49:19 -08:00
|
|
|
{
|
2023-02-27 19:07:11 -08:00
|
|
|
uhost->ctrl.state = CONTROL_ERROR;
|
|
|
|
uhost->ctrl.sts = CTRL_XACTERR;
|
|
|
|
status = USB_ERROR;
|
2022-03-03 03:49:19 -08:00
|
|
|
}
|
2021-12-13 21:39:13 -08:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief usb host control error handler
|
|
|
|
* @param uhost: to the structure of usbh_core_type
|
|
|
|
* @retval status: usb_sts_type status
|
|
|
|
*/
|
|
|
|
usb_sts_type usbh_ctrl_error_handler(usbh_core_type *uhost)
|
|
|
|
{
|
|
|
|
usb_sts_type status = USB_WAIT;
|
|
|
|
if(++ uhost->ctrl.err_cnt <= USBH_MAX_ERROR_COUNT)
|
|
|
|
{
|
|
|
|
uhost->ctrl.state = CONTROL_SETUP;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
uhost->ctrl.sts = CTRL_FAIL;
|
2022-03-03 03:49:19 -08:00
|
|
|
uhost->global_state = USBH_ERROR_STATE;
|
2022-01-21 00:05:17 -08:00
|
|
|
uhost->ctrl.err_cnt = 0;
|
2022-03-03 03:49:19 -08:00
|
|
|
USBH_DEBUG("control error: **** Device No Response ****");
|
2022-01-21 00:05:17 -08:00
|
|
|
status = USB_ERROR;
|
2021-12-13 21:39:13 -08:00
|
|
|
}
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief usb host control stall handler
|
|
|
|
* @param uhost: to the structure of usbh_core_type
|
|
|
|
* @retval usb_sts_type
|
|
|
|
*/
|
|
|
|
usb_sts_type usbh_ctrl_stall_handler(usbh_core_type *uhost)
|
|
|
|
{
|
|
|
|
return USB_NOT_SUPPORT;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief usb host control complete handler
|
|
|
|
* @param uhost: to the structure of usbh_core_type
|
|
|
|
* @retval status: usb_sts_type status
|
|
|
|
*/
|
|
|
|
usb_sts_type usbh_ctrl_complete_handler(usbh_core_type *uhost)
|
|
|
|
{
|
|
|
|
return USB_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief usb host control transfer loop function
|
|
|
|
* @param uhost: to the structure of usbh_core_type
|
|
|
|
* @retval status: usb_sts_type status
|
|
|
|
*/
|
|
|
|
usb_sts_type usbh_ctrl_transfer_loop(usbh_core_type *uhost)
|
|
|
|
{
|
|
|
|
usb_sts_type status = USB_WAIT;
|
|
|
|
static uint32_t timeout = 0;
|
|
|
|
uhost->ctrl.sts = CTRL_START;
|
2022-04-11 04:50:25 -07:00
|
|
|
|
2021-12-13 21:39:13 -08:00
|
|
|
switch(uhost->ctrl.state)
|
|
|
|
{
|
|
|
|
case CONTROL_SETUP:
|
|
|
|
usbh_ctrl_setup_handler(uhost);
|
2022-03-03 03:49:19 -08:00
|
|
|
uhost->ctrl.timer = uhost->timer;
|
2021-12-13 21:39:13 -08:00
|
|
|
break;
|
2022-04-11 04:50:25 -07:00
|
|
|
|
2021-12-13 21:39:13 -08:00
|
|
|
case CONTROL_SETUP_WAIT:
|
|
|
|
usbh_ctrl_setup_wait_handler(uhost, &timeout);
|
|
|
|
break;
|
2022-04-11 04:50:25 -07:00
|
|
|
|
2021-12-13 21:39:13 -08:00
|
|
|
case CONTROL_DATA_IN:
|
|
|
|
usbh_ctrl_data_in_handler(uhost);
|
|
|
|
break;
|
2022-04-11 04:50:25 -07:00
|
|
|
|
2021-12-13 21:39:13 -08:00
|
|
|
case CONTROL_DATA_IN_WAIT:
|
|
|
|
usbh_ctrl_data_in_wait_handler(uhost, timeout);
|
|
|
|
break;
|
2022-04-11 04:50:25 -07:00
|
|
|
|
2021-12-13 21:39:13 -08:00
|
|
|
case CONTROL_DATA_OUT:
|
|
|
|
usbh_ctrl_data_out_handler(uhost);
|
|
|
|
break;
|
2022-04-11 04:50:25 -07:00
|
|
|
|
2021-12-13 21:39:13 -08:00
|
|
|
case CONTROL_DATA_OUT_WAIT:
|
|
|
|
usbh_ctrl_data_out_wait_handler(uhost, timeout);
|
|
|
|
break;
|
2022-04-11 04:50:25 -07:00
|
|
|
|
2021-12-13 21:39:13 -08:00
|
|
|
case CONTROL_STATUS_IN:
|
|
|
|
usbh_ctrl_status_in_handler(uhost);
|
|
|
|
break;
|
2022-04-11 04:50:25 -07:00
|
|
|
|
2021-12-13 21:39:13 -08:00
|
|
|
case CONTROL_STATUS_IN_WAIT:
|
|
|
|
usbh_ctrl_status_in_wait_handler(uhost, timeout);
|
|
|
|
break;
|
2022-04-11 04:50:25 -07:00
|
|
|
|
2021-12-13 21:39:13 -08:00
|
|
|
case CONTROL_STATUS_OUT:
|
|
|
|
usbh_ctrl_status_out_handler(uhost);
|
|
|
|
break;
|
2022-04-11 04:50:25 -07:00
|
|
|
|
2021-12-13 21:39:13 -08:00
|
|
|
case CONTROL_STATUS_OUT_WAIT:
|
|
|
|
usbh_ctrl_status_out_wait_handler(uhost, timeout);
|
|
|
|
break;
|
|
|
|
case CONTROL_STALL:
|
|
|
|
status = usbh_ctrl_stall_handler(uhost);
|
|
|
|
break;
|
|
|
|
case CONTROL_ERROR:
|
|
|
|
status = usbh_ctrl_error_handler(uhost);
|
|
|
|
break;
|
|
|
|
case CONTROL_COMPLETE:
|
|
|
|
status = usbh_ctrl_complete_handler(uhost);
|
|
|
|
break;
|
2022-04-11 04:50:25 -07:00
|
|
|
|
2021-12-13 21:39:13 -08:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2022-04-11 04:50:25 -07:00
|
|
|
|
2021-12-13 21:39:13 -08:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief usb host control request
|
|
|
|
* @param uhost: to the structure of usbh_core_type
|
|
|
|
* @param buffer: usb request buffer
|
|
|
|
* @param length: usb request length
|
|
|
|
* @retval status: usb_sts_type status
|
|
|
|
*/
|
|
|
|
usb_sts_type usbh_ctrl_request(usbh_core_type *uhost, uint8_t *buffer, uint16_t length)
|
|
|
|
{
|
|
|
|
usb_sts_type status = USB_OK;
|
|
|
|
if(uhost->req_state == CMD_SEND)
|
|
|
|
{
|
|
|
|
uhost->req_state = CMD_WAIT;
|
|
|
|
uhost->ctrl.buffer = buffer;
|
|
|
|
uhost->ctrl.len = length;
|
|
|
|
uhost->ctrl.state = CONTROL_SETUP;
|
|
|
|
}
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief usb host get device descriptor
|
|
|
|
* @param uhost: to the structure of usbh_core_type
|
|
|
|
* @param length: get descriptor request length
|
|
|
|
* @param req_type: usb request type
|
|
|
|
* @param wvalue: usb wvalue
|
|
|
|
* @param buffer: request buffer
|
|
|
|
* @retval status: usb_sts_type status
|
|
|
|
*/
|
|
|
|
usb_sts_type usbh_get_descriptor(usbh_core_type *uhost, uint16_t length,
|
2022-04-11 04:50:25 -07:00
|
|
|
uint8_t req_type, uint16_t wvalue,
|
2021-12-13 21:39:13 -08:00
|
|
|
uint8_t *buffer)
|
|
|
|
{
|
|
|
|
usb_sts_type status;
|
|
|
|
uhost->ctrl.setup.bmRequestType = USB_DIR_D2H | req_type;
|
|
|
|
uhost->ctrl.setup.bRequest = USB_STD_REQ_GET_DESCRIPTOR;
|
|
|
|
uhost->ctrl.setup.wValue = wvalue;
|
|
|
|
uhost->ctrl.setup.wLength = length;
|
2022-04-11 04:50:25 -07:00
|
|
|
|
2021-12-13 21:39:13 -08:00
|
|
|
if((wvalue & 0xFF00) == ((USB_DESCIPTOR_TYPE_STRING << 8) & 0xFF00))
|
|
|
|
{
|
|
|
|
uhost->ctrl.setup.wIndex = 0x0409;
|
|
|
|
}
|
2022-04-11 04:50:25 -07:00
|
|
|
else
|
2021-12-13 21:39:13 -08:00
|
|
|
{
|
|
|
|
uhost->ctrl.setup.wIndex = 0;
|
|
|
|
}
|
2022-04-11 04:50:25 -07:00
|
|
|
|
2021-12-13 21:39:13 -08:00
|
|
|
status = usbh_ctrl_request(uhost, buffer, length);
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief usb host parse device descriptor
|
|
|
|
* @param uhost: to the structure of usbh_core_type
|
|
|
|
* @param buffer: usb device descriptor buffer
|
|
|
|
* @param length: usb device descriptor length
|
|
|
|
* @retval status: usb_sts_type status
|
|
|
|
*/
|
|
|
|
void usbh_parse_dev_desc(usbh_core_type *uhost, uint8_t *buffer, uint16_t length)
|
|
|
|
{
|
|
|
|
usbh_dev_desc_type *desc = &(uhost->dev);
|
2022-04-11 04:50:25 -07:00
|
|
|
|
2021-12-13 21:39:13 -08:00
|
|
|
desc->dev_desc.bLength = *(uint8_t *)(buffer + 0);
|
|
|
|
desc->dev_desc.bDescriptorType = *(uint8_t *)(buffer + 1);
|
|
|
|
desc->dev_desc.bcdUSB = SWAPBYTE(buffer + 2);
|
|
|
|
desc->dev_desc.bDeviceClass = *(uint8_t *)(buffer + 4);
|
|
|
|
desc->dev_desc.bDeviceSubClass = *(uint8_t *)(buffer + 5);
|
|
|
|
desc->dev_desc.bDeviceProtocol = *(uint8_t *)(buffer + 6);
|
|
|
|
desc->dev_desc.bMaxPacketSize0 = *(uint8_t *)(buffer + 7);
|
2022-04-11 04:50:25 -07:00
|
|
|
|
2021-12-13 21:39:13 -08:00
|
|
|
if(length > 8)
|
|
|
|
{
|
|
|
|
desc->dev_desc.idVendor = SWAPBYTE(buffer + 8);
|
|
|
|
desc->dev_desc.idProduct = SWAPBYTE(buffer + 10);
|
|
|
|
desc->dev_desc.bcdDevice = SWAPBYTE(buffer + 12);
|
|
|
|
desc->dev_desc.iManufacturer = *(uint8_t *)(buffer + 14);
|
|
|
|
desc->dev_desc.iProduct = *(uint8_t *)(buffer + 15);
|
|
|
|
desc->dev_desc.iSerialNumber = *(uint8_t *)(buffer + 16);
|
|
|
|
desc->dev_desc.bNumConfigurations = *(uint8_t *)(buffer + 17);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief usb host get next header
|
|
|
|
* @param buffer: usb data buffer
|
|
|
|
* @param index_len: pointer of index len
|
|
|
|
* @retval status: usb_sts_type status
|
|
|
|
*/
|
|
|
|
usb_header_desc_type *usbh_get_next_header(uint8_t *buf, uint16_t *index_len)
|
|
|
|
{
|
|
|
|
*index_len += ((usb_header_desc_type *)buf)->bLength;
|
|
|
|
return (usb_header_desc_type *)
|
|
|
|
((uint8_t *)buf + ((usb_header_desc_type *)buf)->bLength);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief usb host parse interface descriptor
|
|
|
|
* @param intf: usb interface description type
|
|
|
|
* @param buf: interface description data buffer
|
|
|
|
* @retval none
|
|
|
|
*/
|
|
|
|
void usbh_parse_interface_desc(usb_interface_desc_type *intf, uint8_t *buf)
|
|
|
|
{
|
|
|
|
intf->bLength = *(uint8_t *)buf;
|
|
|
|
intf->bDescriptorType = *(uint8_t *)(buf + 1);
|
|
|
|
intf->bInterfaceNumber = *(uint8_t *)(buf + 2);
|
|
|
|
intf->bAlternateSetting = *(uint8_t *)(buf + 3);
|
|
|
|
intf->bNumEndpoints = *(uint8_t *)(buf + 4);
|
|
|
|
intf->bInterfaceClass = *(uint8_t *)(buf + 5);
|
|
|
|
intf->bInterfaceSubClass = *(uint8_t *)(buf + 6);
|
|
|
|
intf->bInterfaceProtocol = *(uint8_t *)(buf + 7);
|
|
|
|
intf->iInterface = *(uint8_t *)(buf + 8);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief usb host parse endpoint descriptor
|
|
|
|
* @param ept_desc: endpoint type
|
|
|
|
* @param buf: endpoint description data buffer
|
|
|
|
* @retval none
|
|
|
|
*/
|
|
|
|
void usbh_parse_endpoint_desc(usb_endpoint_desc_type *ept_desc, uint8_t *buf)
|
|
|
|
{
|
|
|
|
ept_desc->bLength = *(uint8_t *)(buf + 0);
|
|
|
|
ept_desc->bDescriptorType = *(uint8_t *)(buf + 1);
|
|
|
|
ept_desc->bEndpointAddress = *(uint8_t *)(buf + 2);
|
|
|
|
ept_desc->bmAttributes = *(uint8_t *)(buf + 3);
|
|
|
|
ept_desc->wMaxPacketSize = SWAPBYTE(buf + 4);
|
|
|
|
ept_desc->bInterval = *(uint8_t *)(buf + 6);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief usb host parse configure descriptor
|
|
|
|
* @param uhost: to the structure of usbh_core_type
|
|
|
|
* @param buffer: configure buffer
|
|
|
|
* @param length: configure length
|
|
|
|
* @retval status: usb_sts_type status
|
|
|
|
*/
|
2022-04-11 04:50:25 -07:00
|
|
|
usb_sts_type usbh_parse_configure_desc(usbh_core_type *uhost,
|
2021-12-13 21:39:13 -08:00
|
|
|
uint8_t *buffer, uint16_t length)
|
|
|
|
{
|
|
|
|
usb_cfg_desc_type *cfg_desc = &(uhost->dev.cfg_desc);
|
|
|
|
usb_interface_desc_type *intf_desc;
|
|
|
|
usb_endpoint_desc_type *ept_desc;
|
|
|
|
usb_header_desc_type *desc;
|
|
|
|
uint16_t index_len;
|
|
|
|
uint8_t index_intf = 0;
|
|
|
|
uint8_t index_ept = 0;
|
2022-04-11 04:50:25 -07:00
|
|
|
|
2021-12-13 21:39:13 -08:00
|
|
|
desc = (usb_header_desc_type *)buffer;
|
|
|
|
cfg_desc->cfg.bLength = *(uint8_t *)buffer;
|
|
|
|
cfg_desc->cfg.bDescriptorType = *(uint8_t *)(buffer + 1);
|
|
|
|
cfg_desc->cfg.wTotalLength = SWAPBYTE(buffer + 2);
|
|
|
|
cfg_desc->cfg.bNumInterfaces = *(uint8_t *)(buffer + 4);
|
|
|
|
cfg_desc->cfg.bConfigurationValue = *(uint8_t *)(buffer + 5);
|
|
|
|
cfg_desc->cfg.iConfiguration = *(uint8_t *)(buffer + 6);
|
|
|
|
cfg_desc->cfg.bmAttributes = *(uint8_t *)(buffer + 7);
|
|
|
|
cfg_desc->cfg.bMaxPower = *(uint8_t *)(buffer + 8);
|
2022-04-11 04:50:25 -07:00
|
|
|
|
2021-12-13 21:39:13 -08:00
|
|
|
if(length > USB_DEVICE_CFG_DESC_LEN)
|
|
|
|
{
|
|
|
|
index_len = USB_DEVICE_CFG_DESC_LEN;
|
2022-04-11 04:50:25 -07:00
|
|
|
|
2021-12-13 21:39:13 -08:00
|
|
|
while((index_intf < USBH_MAX_INTERFACE) && index_len < cfg_desc->cfg.wTotalLength)
|
|
|
|
{
|
|
|
|
desc = usbh_get_next_header((uint8_t *)desc, &index_len);
|
|
|
|
if(desc->bDescriptorType == USB_DESCIPTOR_TYPE_INTERFACE)
|
|
|
|
{
|
|
|
|
index_ept = 0;
|
|
|
|
intf_desc = &cfg_desc->interface[index_intf].interface;
|
|
|
|
usbh_parse_interface_desc(intf_desc, (uint8_t *)desc);
|
2022-04-11 04:50:25 -07:00
|
|
|
|
2021-12-13 21:39:13 -08:00
|
|
|
while(index_ept < intf_desc->bNumEndpoints && index_len < cfg_desc->cfg.wTotalLength)
|
|
|
|
{
|
|
|
|
desc = usbh_get_next_header((uint8_t *)desc, &index_len);
|
|
|
|
if(desc->bDescriptorType == USB_DESCIPTOR_TYPE_ENDPOINT)
|
|
|
|
{
|
|
|
|
ept_desc = &(cfg_desc->interface[index_intf].endpoint[index_ept]);
|
|
|
|
usbh_parse_endpoint_desc(ept_desc, (uint8_t *)desc);
|
|
|
|
index_ept ++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
index_intf ++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return USB_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief usb host find interface
|
|
|
|
* @param uhost: to the structure of usbh_core_type
|
|
|
|
* @param class_code: class code
|
|
|
|
* @param sub_class: subclass code
|
|
|
|
* @param protocol: prtocol code
|
|
|
|
* @retval idx: interface index
|
|
|
|
*/
|
|
|
|
uint8_t usbh_find_interface(usbh_core_type *uhost, uint8_t class_code, uint8_t sub_class, uint8_t protocol)
|
|
|
|
{
|
|
|
|
uint8_t idx = 0;
|
|
|
|
usb_itf_desc_type *usbitf;
|
|
|
|
for(idx = 0; idx < uhost->dev.cfg_desc.cfg.bNumInterfaces; idx ++)
|
|
|
|
{
|
|
|
|
usbitf = &uhost->dev.cfg_desc.interface[idx];
|
|
|
|
if(((usbitf->interface.bInterfaceClass == class_code) || (class_code == 0xFF)) &&
|
|
|
|
((usbitf->interface.bInterfaceSubClass == sub_class) || (sub_class == 0xFF)) &&
|
|
|
|
((usbitf->interface.bInterfaceProtocol == protocol) || (protocol == 0xFF))
|
|
|
|
)
|
|
|
|
{
|
|
|
|
return idx;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0xFF;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief usbh parse string descriptor
|
|
|
|
* @param src: string source pointer
|
|
|
|
* @param dest: string destination pointer
|
|
|
|
* @param length: string length
|
|
|
|
* @retval none
|
|
|
|
*/
|
|
|
|
void usbh_parse_string_desc(uint8_t *src, uint8_t *dest, uint16_t length)
|
|
|
|
{
|
|
|
|
uint16_t len;
|
|
|
|
uint16_t i_index;
|
2022-04-11 04:50:25 -07:00
|
|
|
|
2021-12-13 21:39:13 -08:00
|
|
|
if(src[1] == USB_DESCIPTOR_TYPE_STRING)
|
|
|
|
{
|
|
|
|
len = ((src[0] - 2) <= length ? (src[0] - 2) : length);
|
|
|
|
src += 2;
|
|
|
|
for(i_index = 0; i_index < len; i_index += 2)
|
|
|
|
{
|
|
|
|
*dest = src[i_index];
|
|
|
|
dest ++;
|
|
|
|
}
|
|
|
|
*dest = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief usb host get device descriptor
|
|
|
|
* @param uhost: to the structure of usbh_core_type
|
|
|
|
* @param length: get device descriptor length
|
|
|
|
* @retval status: usb_sts_type status
|
|
|
|
*/
|
|
|
|
usb_sts_type usbh_get_device_descriptor(usbh_core_type *uhost, uint16_t length)
|
|
|
|
{
|
|
|
|
usb_sts_type status = USB_WAIT;
|
|
|
|
uint8_t bm_req;
|
|
|
|
uint16_t wvalue;
|
2022-04-11 04:50:25 -07:00
|
|
|
|
2021-12-13 21:39:13 -08:00
|
|
|
bm_req = USB_REQ_RECIPIENT_DEVICE | USB_REQ_TYPE_STANDARD;
|
|
|
|
wvalue = (USB_DESCIPTOR_TYPE_DEVICE << 8) & 0xFF00;
|
2022-04-11 04:50:25 -07:00
|
|
|
|
|
|
|
status = usbh_get_descriptor(uhost, length, bm_req,
|
2021-12-13 21:39:13 -08:00
|
|
|
wvalue, uhost->rx_buffer);
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief usb host get configure descriptor
|
|
|
|
* @param uhost: to the structure of usbh_core_type
|
|
|
|
* @param length: get device configure length
|
|
|
|
* @retval status: usb_sts_type status
|
|
|
|
*/
|
|
|
|
usb_sts_type usbh_get_configure_descriptor(usbh_core_type *uhost, uint16_t length)
|
|
|
|
{
|
|
|
|
usb_sts_type status = USB_WAIT;
|
|
|
|
uint8_t bm_req;
|
|
|
|
uint16_t wvalue;
|
2022-04-11 04:50:25 -07:00
|
|
|
|
2021-12-13 21:39:13 -08:00
|
|
|
bm_req = USB_REQ_RECIPIENT_DEVICE | USB_REQ_TYPE_STANDARD;
|
|
|
|
wvalue = (USB_DESCIPTOR_TYPE_CONFIGURATION << 8) & 0xFF00;
|
2022-04-11 04:50:25 -07:00
|
|
|
|
|
|
|
status = usbh_get_descriptor(uhost, length, bm_req,
|
2021-12-13 21:39:13 -08:00
|
|
|
wvalue, uhost->rx_buffer);
|
2022-04-11 04:50:25 -07:00
|
|
|
|
2021-12-13 21:39:13 -08:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief usb host get string descriptor
|
|
|
|
* @param uhost: to the structure of usbh_core_type
|
|
|
|
* @param string_id: string id
|
|
|
|
* @param buffer: receive data buffer
|
|
|
|
* @param length: get device string length
|
|
|
|
* @retval status: usb_sts_type status
|
|
|
|
*/
|
|
|
|
usb_sts_type usbh_get_sting_descriptor(usbh_core_type *uhost, uint8_t string_id,
|
|
|
|
uint8_t *buffer, uint16_t length)
|
|
|
|
{
|
|
|
|
usb_sts_type status = USB_WAIT;
|
|
|
|
uint8_t bm_req;
|
|
|
|
uint16_t wvalue;
|
2022-04-11 04:50:25 -07:00
|
|
|
|
2021-12-13 21:39:13 -08:00
|
|
|
bm_req = USB_REQ_RECIPIENT_DEVICE | USB_REQ_TYPE_STANDARD;
|
|
|
|
wvalue = (USB_DESCIPTOR_TYPE_STRING << 8) | string_id;
|
2022-04-11 04:50:25 -07:00
|
|
|
|
|
|
|
status = usbh_get_descriptor(uhost, length, bm_req,
|
2021-12-13 21:39:13 -08:00
|
|
|
wvalue, uhost->rx_buffer);
|
|
|
|
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief usb host set configurtion
|
|
|
|
* @param uhost: to the structure of usbh_core_type
|
|
|
|
* @param config: usb configuration
|
|
|
|
* @retval status: usb_sts_type status
|
|
|
|
*/
|
|
|
|
usb_sts_type usbh_set_configuration(usbh_core_type *uhost, uint16_t config)
|
|
|
|
{
|
|
|
|
usb_sts_type status = USB_WAIT;
|
|
|
|
uint8_t bm_req;
|
|
|
|
bm_req = USB_REQ_RECIPIENT_DEVICE | USB_REQ_TYPE_STANDARD;
|
2022-04-11 04:50:25 -07:00
|
|
|
|
2021-12-13 21:39:13 -08:00
|
|
|
uhost->ctrl.setup.bmRequestType = USB_DIR_H2D | bm_req;
|
|
|
|
uhost->ctrl.setup.bRequest = USB_STD_REQ_SET_CONFIGURATION;
|
|
|
|
uhost->ctrl.setup.wValue = config;
|
|
|
|
uhost->ctrl.setup.wLength = 0;
|
|
|
|
uhost->ctrl.setup.wIndex = 0;
|
|
|
|
status = usbh_ctrl_request(uhost, 0, 0);
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief usb host set device address
|
|
|
|
* @param uhost: to the structure of usbh_core_type
|
|
|
|
* @param address: device address
|
|
|
|
* @retval status: usb_sts_type status
|
|
|
|
*/
|
|
|
|
usb_sts_type usbh_set_address(usbh_core_type *uhost, uint8_t address)
|
|
|
|
{
|
|
|
|
usb_sts_type status = USB_WAIT;
|
|
|
|
uint8_t bm_req;
|
|
|
|
bm_req = USB_REQ_RECIPIENT_DEVICE | USB_REQ_TYPE_STANDARD;
|
2022-04-11 04:50:25 -07:00
|
|
|
|
2021-12-13 21:39:13 -08:00
|
|
|
uhost->ctrl.setup.bmRequestType = USB_DIR_H2D | bm_req;
|
|
|
|
uhost->ctrl.setup.bRequest = USB_STD_REQ_SET_ADDRESS;
|
|
|
|
uhost->ctrl.setup.wValue = (uint16_t)address;
|
|
|
|
uhost->ctrl.setup.wLength = 0;
|
|
|
|
uhost->ctrl.setup.wIndex = 0;
|
|
|
|
status = usbh_ctrl_request(uhost, 0, 0);
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief usb host set interface
|
|
|
|
* @param uhost: to the structure of usbh_core_type
|
|
|
|
* @param ept_num: endpoint number
|
|
|
|
* @param altsetting: alter setting
|
|
|
|
* @retval status: usb_sts_type status
|
|
|
|
*/
|
|
|
|
usb_sts_type usbh_set_interface(usbh_core_type *uhost, uint8_t ept_num, uint8_t altsetting)
|
|
|
|
{
|
|
|
|
usb_sts_type status = USB_WAIT;
|
|
|
|
uint8_t bm_req;
|
|
|
|
bm_req = USB_REQ_RECIPIENT_INTERFACE | USB_REQ_TYPE_STANDARD;
|
2022-04-11 04:50:25 -07:00
|
|
|
|
2021-12-13 21:39:13 -08:00
|
|
|
uhost->ctrl.setup.bmRequestType = USB_DIR_H2D | bm_req;
|
|
|
|
uhost->ctrl.setup.bRequest = USB_STD_REQ_SET_INTERFACE;
|
|
|
|
uhost->ctrl.setup.wValue = (uint16_t)altsetting;
|
|
|
|
uhost->ctrl.setup.wLength = 0;
|
|
|
|
uhost->ctrl.setup.wIndex = ept_num;
|
|
|
|
status = usbh_ctrl_request(uhost, 0, 0);
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief usb host set feature
|
|
|
|
* @param uhost: to the structure of usbh_core_type
|
|
|
|
* @param feature: feature number
|
|
|
|
* @param index: index number
|
|
|
|
* @retval status: usb_sts_type status
|
|
|
|
*/
|
|
|
|
usb_sts_type usbh_set_feature(usbh_core_type *uhost, uint8_t feature, uint16_t index)
|
|
|
|
{
|
|
|
|
usb_sts_type status = USB_WAIT;
|
|
|
|
uint8_t bm_req;
|
|
|
|
bm_req = USB_REQ_RECIPIENT_DEVICE | USB_REQ_TYPE_STANDARD;
|
2022-04-11 04:50:25 -07:00
|
|
|
|
2021-12-13 21:39:13 -08:00
|
|
|
uhost->ctrl.setup.bmRequestType = USB_DIR_H2D | bm_req;
|
|
|
|
uhost->ctrl.setup.bRequest = USB_STD_REQ_SET_FEATURE;
|
|
|
|
uhost->ctrl.setup.wValue = (uint16_t)feature;
|
|
|
|
uhost->ctrl.setup.wLength = 0;
|
|
|
|
uhost->ctrl.setup.wIndex = index;
|
|
|
|
status = usbh_ctrl_request(uhost, 0, 0);
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief usb host clear device feature
|
|
|
|
* @param uhost: to the structure of usbh_core_type
|
|
|
|
* @param feature: feature number
|
|
|
|
* @param index: index number
|
|
|
|
* @retval status: usb_sts_type status
|
|
|
|
*/
|
|
|
|
usb_sts_type usbh_clear_dev_feature(usbh_core_type *uhost, uint8_t feature, uint16_t index)
|
|
|
|
{
|
|
|
|
usb_sts_type status = USB_WAIT;
|
|
|
|
uint8_t bm_req;
|
|
|
|
bm_req = USB_REQ_RECIPIENT_DEVICE | USB_REQ_TYPE_STANDARD;
|
2022-04-11 04:50:25 -07:00
|
|
|
|
2021-12-13 21:39:13 -08:00
|
|
|
uhost->ctrl.setup.bmRequestType = USB_DIR_H2D | bm_req;
|
|
|
|
uhost->ctrl.setup.bRequest = USB_STD_REQ_CLEAR_FEATURE;
|
|
|
|
uhost->ctrl.setup.wValue = (uint16_t)feature;
|
|
|
|
uhost->ctrl.setup.wLength = 0;
|
|
|
|
uhost->ctrl.setup.wIndex = index;
|
|
|
|
status = usbh_ctrl_request(uhost, 0, 0);
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief usb host clear endpoint feature
|
|
|
|
* @param uhost: to the structure of usbh_core_type
|
|
|
|
* @param ept_num: endpoint number
|
|
|
|
* @param hc_num: host channel number
|
|
|
|
* @retval status: usb_sts_type status
|
|
|
|
*/
|
|
|
|
usb_sts_type usbh_clear_ept_feature(usbh_core_type *uhost, uint8_t ept_num, uint8_t hc_num)
|
|
|
|
{
|
|
|
|
usb_sts_type status = USB_WAIT;
|
|
|
|
uint8_t bm_req;
|
|
|
|
if(uhost->ctrl.state == CONTROL_IDLE )
|
|
|
|
{
|
|
|
|
bm_req = USB_REQ_RECIPIENT_ENDPOINT | USB_REQ_TYPE_STANDARD;
|
2022-04-11 04:50:25 -07:00
|
|
|
|
2021-12-13 21:39:13 -08:00
|
|
|
uhost->ctrl.setup.bmRequestType = USB_DIR_H2D | bm_req;
|
|
|
|
uhost->ctrl.setup.bRequest = USB_STD_REQ_CLEAR_FEATURE;
|
|
|
|
uhost->ctrl.setup.wValue = USB_FEATURE_EPT_HALT;
|
|
|
|
uhost->ctrl.setup.wLength = 0;
|
|
|
|
uhost->ctrl.setup.wIndex = ept_num;
|
|
|
|
usbh_ctrl_request(uhost, 0, 0);
|
|
|
|
}
|
|
|
|
if(usbh_ctrl_result_check(uhost, CONTROL_IDLE, ENUM_IDLE) == USB_OK)
|
|
|
|
{
|
|
|
|
status = USB_OK;
|
|
|
|
}
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @}
|
2022-04-11 04:50:25 -07:00
|
|
|
*/
|
2021-12-13 21:39:13 -08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @}
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @}
|
|
|
|
*/
|