RA Flexible Software Package Documentation  Release v6.3.0

 
Functions
USB HAUD (r_usb_haud)
Modules » Connectivity

Functions

fsp_err_t R_USB_HAUD_DeviceInfoGet (usb_ctrl_t *const p_api_ctrl, usb_haud_device_info_t *p_info, uint8_t device_address)
 Check audio version of connected device. More...
 
fsp_err_t R_USB_HAUD_ClockSourceGet (usb_ctrl_t *const p_api_ctrl, usb_haud_sampling_t *p_info, uint8_t direction, uint8_t device_address)
 Get the Clock Souuce (Audio 2.0 support only) More...
 
fsp_err_t R_USB_HAUD_AlternateNumberGet (usb_ctrl_t *const p_api_ctrl, usb_haud_sampling_t *p_info, uint8_t direction, uint8_t device_address)
 Get the alternate number for SET_INTERFACE. (Audio 1.0 support only) More...
 
fsp_err_t R_USB_HAUD_PipeSet (usb_ctrl_t *const p_api_ctrl, uint32_t interface_number, uint32_t alternate_number, uint8_t device_address)
 Find the interface descriptor for streaming data transfer and configure the pipe. More...
 

Detailed Description

This module provides a USB Peripheral Audio Device Class Driver (HAUD). It implements the USB HAUD Interface.

Functions

Refer to USB (r_usb_basic) for the common API (r_usb_basic) to be called from the application.

Detailed Description

Overview

The r_usb_haud module combines with the r_usb_basic module to provide USB Host Audio Device Class (HAUD) driver.

Features

The r_usb_haud module has the following key features:

Clock Configuration

Refer to the USB (r_usb_basic) module.

Pin Configuration

Refer to the USB (r_usb_basic) module.

Usage Notes

Class Requests (Host to Peripheral)

This driver notifies the application when receiving the following class requests:

Request Code Description
SET_CUR 0x01 Current setting attribute
GET_CUR 0x81 Current setting attribute

Note:

For details about each device class, please refer to Audio Class specification.

Limitations

Examples

USB HAUD Example

  1. Example code for Audio 1.0
#define CONTROL_BUFFER_SIZE (256)
#define AUDIO_BUFFER_SIZE (3 * 1024) + 1024
#define REQUEST_SIZE (3 * 1024)
#define FIRST_PACKET_TEST_SIZE (200) /* for Test Device (USBX-PAUD Sample Project : EK-RA6M5 Board) */
/* The first 200 bytes of the loopback data are all 0x00. */
#define READ_REQUEST_SIZE (REQUEST_SIZE + FIRST_PACKET_TEST_SIZE)
#define BMREQUESTTYPEDIR (0x0080U)
#define BMREQUESTTYPETYPE (0x0060U)
#define ALT_NUM_0 (0)
#define SAMPLING_FREQUENCY_CHANNNELS (2)
#define SAMPLING_FREQUENCY_FREQUENCY (48000)
#define SAMPLING_FREQUENCY_RESOLUTION (16)
#define SAMPLING_FREQUENCY_DATA_SIZE (3)
/******************************************************************************
* Exported global functions (to be accessed by other files)
******************************************************************************/
void usb_haud_example(void);
#if (BSP_CFG_RTOS == 2)
void usb_apl_callback(usb_event_info_t * p_event_info, usb_hdl_t cur_task, usb_onoff_t usb_state);
#endif
/******************************************************************************
* Private global variables and functions
******************************************************************************/
#if (BSP_CFG_RTOS == 2)
static volatile usb_event_info_t * p_usb_event = NULL;
extern QueueHandle_t g_usb_queue;
#else
static usb_event_info_t event_info = {0};
static volatile usb_event_info_t * p_usb_event = &event_info;
#endif
/* Private variables */
static uint8_t g_buf[CONTROL_BUFFER_SIZE] BSP_ALIGN_VARIABLE(4) = {RESET_VALUE}; // Class request data buffer
static uint8_t g_send_buffer[AUDIO_BUFFER_SIZE] BSP_ALIGN_VARIABLE(4);
static uint8_t g_recv_buffer[AUDIO_BUFFER_SIZE] BSP_ALIGN_VARIABLE(4);
static uint8_t g_usb_dummy = RESET_VALUE; // dummy variable to send
static volatile bool g_err_flag = false; // flag bit
static uint8_t g_device_address = 0;
static uint32_t g_completed_read_transfer_length_total = 0;
static usb_haud_sampling_t g_sampling_tx;
static usb_haud_sampling_t g_sampling_rx;
/* Private functions */
static void haud_app_data_buffer_init(void);
static void haud_app_standard_request_complete(void);
static void haud_app_audio_class_request_complete(void);
static fsp_err_t haud_app_interface_set(uint32_t value, uint32_t index);
static fsp_err_t haud_app_sampling_frequency_set(uint8_t ep_address, uint32_t frequency);
static fsp_err_t haud_app_sampling_frequency_get(uint8_t ep_address);
static void handle_error(fsp_err_t err, char * err_str);
extern const usb_cfg_t g_basic0_cfg;
extern usb_instance_ctrl_t g_basic0_ctrl;
/*******************************************************************************************************************
* Function Name : usb_haud_example
* Description : Host Audio application main process
* Arguments : none
* Return value : none
*******************************************************************************************************************/
void usb_haud_example (void)
{
fsp_err_t err = FSP_SUCCESS;
#if (BSP_CFG_RTOS == 2)
BaseType_t err_queue = USB_FALSE;
#endif
usb_haud_device_info_t device_info;
err = R_USB_Open(&g_basic0_ctrl, &g_basic0_cfg);
/* Error Handle */
if (FSP_SUCCESS != err)
{
APP_ERR_TRAP
}
haud_app_data_buffer_init();
while (true)
{
/* Handle error if queue send fails*/
if (true == g_err_flag)
{
handle_error(FSP_ERR_ABORTED, "Error in sending usb event through queue");
}
#if (BSP_CFG_RTOS == 2)
/* Receive message from queue and analyzing the received message*/
err_queue = xQueueReceive(g_usb_queue, &p_usb_event, (portMAX_DELAY));
/* Handle error */
if (USB_TRUE != err_queue)
{
handle_error(FSP_ERR_ABORTED, "Error in receiving USB event message through queue");
}
#else
/* Obtain USB related events */
err = R_USB_EventGet(&event_info, &event_info.event);
/* Handle error */
if (FSP_SUCCESS != err)
{
APP_ERR_TRAP
}
#endif
switch (p_usb_event->event)
{
case USB_STATUS_CONFIGURED:
{
g_device_address = p_usb_event->device_address;
/* Get device information (Audio version) */
err = R_USB_HAUD_DeviceInfoGet(&g_basic0_ctrl, &device_info, g_device_address);
if (FSP_SUCCESS != err)
{
APP_ERR_TRAP
}
if (USB_HAUD_PROTOCOL_IP_VERSION_01_00 == device_info.protocol)
{
g_sampling_tx.channels = SAMPLING_FREQUENCY_CHANNNELS;
g_sampling_tx.frequency = SAMPLING_FREQUENCY_FREQUENCY;
g_sampling_tx.resolution = SAMPLING_FREQUENCY_RESOLUTION;
/* Get Alternate number for Isochronous-OUT IF */
err =
R_USB_HAUD_AlternateNumberGet(&g_basic0_ctrl, &g_sampling_tx, USB_EP_DIR_OUT, g_device_address);
if (FSP_SUCCESS != err)
{
APP_ERR_TRAP
}
/* SET_INTERFACE (Use the acquired ALT number) */
err = haud_app_interface_set(g_sampling_tx.alternate_number, g_sampling_tx.interface_number);
if (FSP_SUCCESS != err)
{
APP_ERR_TRAP
}
}
else
{
/* Do nothing. (Audio 2.0 and later are not supported.) */
}
break;
}
case USB_STATUS_READ_COMPLETE:
{
if ((FSP_SUCCESS == p_usb_event->status) || (FSP_ERR_USB_SIZE_SHORT == p_usb_event->status))
{
g_completed_read_transfer_length_total += p_usb_event->data_size;
if (READ_REQUEST_SIZE > g_completed_read_transfer_length_total)
{
err = R_USB_Read(&g_basic0_ctrl,
g_recv_buffer + g_completed_read_transfer_length_total,
g_sampling_rx.max_packet_size,
g_device_address);
/* Handle Error */
if (FSP_SUCCESS != err)
{
handle_error(err, "**R_USB_Read API FAILED**");
}
}
else
{
if (0 == memcmp(g_send_buffer, g_recv_buffer + FIRST_PACKET_TEST_SIZE, REQUEST_SIZE))
{
/* SET_INTERFACE (ALT number : 0) */
err = haud_app_interface_set(ALT_NUM_0, g_sampling_rx.interface_number);
if (FSP_SUCCESS != err)
{
APP_ERR_TRAP
}
}
else
{
APP_ERR_TRAP
}
}
}
else
{
APP_ERR_TRAP
}
break;
}
case USB_STATUS_WRITE_COMPLETE:
{
if (FSP_SUCCESS == p_usb_event->status)
{
/* SET_INTERFACE (ALT number : 0) */
err = haud_app_interface_set(ALT_NUM_0, g_sampling_tx.interface_number);
if (FSP_SUCCESS != err)
{
APP_ERR_TRAP
}
}
else
{
APP_ERR_TRAP
}
break;
}
case USB_STATUS_REQUEST_COMPLETE:
{
switch (BMREQUESTTYPETYPE & p_usb_event->setup.request_type)
{
case USB_STANDARD:
{
haud_app_standard_request_complete();
break;
}
case USB_CLASS:
{
haud_app_audio_class_request_complete();
break;
}
}
break;
}
case USB_STATUS_DETACH:
{
memset(&g_sampling_tx, 0, sizeof(g_sampling_tx));
memset(&g_sampling_rx, 0, sizeof(g_sampling_rx));
g_device_address = 0;
g_completed_read_transfer_length_total = 0;
break;
}
default:
{
/* No operation to do */
break;
}
}
}
} /* End of function usb_haud_example */
/*******************************************************************************************************************
* Function Name : haud_app_data_buffer_init
* Description : Initializes test write data.
* Arguments : none
* Return value : none
*******************************************************************************************************************/
static void haud_app_data_buffer_init (void)
{
uint32_t i = 0;
uint32_t j = 0;
/* Set data to the send buffer. */
for ( ; i < AUDIO_BUFFER_SIZE; i++)
{
if (i % (VALUE_FFH + 1))
{
(g_send_buffer)[i] = (uint8_t) i;
}
else
{
(g_send_buffer)[i] = (uint8_t) j;
j++;
}
}
} /* End of function haud_app_data_buffer_init */
/*******************************************************************************************************************
* Function Name : haud_app_standard_request_complete
* Description : Standard request (such as SET_INTERFACE) completion event processing.
* Arguments : none
* Return value : none
*******************************************************************************************************************/
static void haud_app_standard_request_complete (void)
{
fsp_err_t err = FSP_SUCCESS;
if (USB_SET_INTERFACE == (p_usb_event->setup.request_type & USB_BREQUEST))
{
if ((g_sampling_tx.interface_number == p_usb_event->setup.request_index) &&
(g_sampling_tx.alternate_number == p_usb_event->setup.request_value))
{
g_sampling_tx.alternate_setting = USB_TRUE;
err = R_USB_HAUD_PipeSet(&g_basic0_ctrl,
g_sampling_tx.interface_number,
g_sampling_tx.alternate_number,
g_device_address);
if (FSP_SUCCESS != err)
{
APP_ERR_TRAP
}
g_sampling_tx.frequency_setting = USB_TRUE;
/* If there is only one frequency, no need to set it to device. */
if ((g_sampling_tx.p_sampling_descriptor[7] == 1) || /* bSamFreqType : There is one frequency */
((g_sampling_tx.p_sampling_descriptor[7] == 0) && /* bSamFreqType : There is Low(=High) frequency */
(g_sampling_tx.
p_sampling_descriptor[8] == g_sampling_tx.p_sampling_descriptor[11]) && /* tSamFreq (low) */
(g_sampling_tx.
p_sampling_descriptor[9] == g_sampling_tx.p_sampling_descriptor[12]) && /* tSamFreq (middle) */
(g_sampling_tx.
p_sampling_descriptor[10] == g_sampling_tx.p_sampling_descriptor[13]))) /* tSamFreq (high)*/
{
g_sampling_tx.frequency_setting = USB_FALSE; /* No need to set frequency */
}
if (g_sampling_tx.frequency_setting)
{
/* Send SET_CUR requests to set frequency. */
err = haud_app_sampling_frequency_set(g_sampling_tx.endpoint_address, g_sampling_tx.frequency);
if (FSP_SUCCESS != err)
{
APP_ERR_TRAP
}
}
}
else if ((g_sampling_tx.interface_number == p_usb_event->setup.request_index) &&
(ALT_NUM_0 == p_usb_event->setup.request_value))
{
g_sampling_tx.alternate_setting = USB_FALSE;
g_sampling_rx.channels = SAMPLING_FREQUENCY_CHANNNELS;
g_sampling_rx.frequency = SAMPLING_FREQUENCY_FREQUENCY;
g_sampling_rx.resolution = SAMPLING_FREQUENCY_RESOLUTION;
/* Get Alternate number for Isochronous-IN IF */
err = R_USB_HAUD_AlternateNumberGet(&g_basic0_ctrl, &g_sampling_rx, USB_EP_DIR_IN, g_device_address);
if (FSP_SUCCESS != err)
{
APP_ERR_TRAP
}
/* SET_INTERFACE (Use the acquired ALT number) */
err = haud_app_interface_set(g_sampling_rx.alternate_number, g_sampling_rx.interface_number);
if (FSP_SUCCESS != err)
{
APP_ERR_TRAP
}
}
else if ((g_sampling_rx.interface_number == p_usb_event->setup.request_index) &&
(g_sampling_rx.alternate_number == p_usb_event->setup.request_value))
{
g_sampling_rx.alternate_setting = USB_TRUE;
err = R_USB_HAUD_PipeSet(&g_basic0_ctrl,
g_sampling_rx.interface_number,
g_sampling_rx.alternate_number,
g_device_address);
if (FSP_SUCCESS != err)
{
APP_ERR_TRAP
}
g_sampling_rx.frequency_setting = USB_TRUE;
/* If there is only one frequency, no need to set it to device. */
if ((g_sampling_rx.p_sampling_descriptor[7] == 1) || /* bSamFreqType : There is one frequency */
((g_sampling_rx.p_sampling_descriptor[7] == 0) && /* bSamFreqType : There is Low(=High) frequency */
(g_sampling_rx.
p_sampling_descriptor[8] == g_sampling_rx.p_sampling_descriptor[11]) && /* tSamFreq (low) */
(g_sampling_rx.
p_sampling_descriptor[9] == g_sampling_rx.p_sampling_descriptor[12]) && /* tSamFreq (middle) */
(g_sampling_rx.
p_sampling_descriptor[10] == g_sampling_rx.p_sampling_descriptor[13]))) /* tSamFreq (high) */
{
g_sampling_rx.frequency_setting = USB_FALSE; /* No need to set frequency */
}
if (g_sampling_rx.frequency_setting)
{
/* Send SET_CUR requests to set frequency. */
err = haud_app_sampling_frequency_set(g_sampling_rx.endpoint_address, g_sampling_rx.frequency);
if (FSP_SUCCESS != err)
{
APP_ERR_TRAP
}
}
}
else if ((g_sampling_rx.interface_number == p_usb_event->setup.request_index) &&
(ALT_NUM_0 == p_usb_event->setup.request_value))
{
g_sampling_rx.alternate_setting = USB_FALSE;
}
else
{
APP_ERR_TRAP
}
}
} /* End of function haud_app_standard_request_complete */
/*******************************************************************************************************************
* Function Name : haud_app_audio_class_request_complete
* Description : Audio class request completion event processing.
* Arguments : none
* Return value : none
*******************************************************************************************************************/
static void haud_app_audio_class_request_complete (void)
{
uint32_t value;
fsp_err_t err = FSP_SUCCESS;
/* SET_CUR (Isochronous-OUT IF's EP) completed */
if ((USB_HAUD_AUDIO10_SET_CUR == (p_usb_event->setup.request_type & USB_BREQUEST)) &&
(g_sampling_tx.endpoint_address == p_usb_event->setup.request_index))
{
/* GET_CUR Request (Check whether the sampling frequency specified by SET_CUR has been set on the device.) */
err = haud_app_sampling_frequency_get(g_sampling_tx.endpoint_address);
if (FSP_SUCCESS != err)
{
APP_ERR_TRAP
}
}
/* SET_CUR (Isochronous-IN IF's EP) completed */
else if ((USB_HAUD_AUDIO10_SET_CUR == (p_usb_event->setup.request_type & USB_BREQUEST)) &&
(g_sampling_rx.endpoint_address == p_usb_event->setup.request_index))
{
/* GET_CUR Request (Check whether the sampling frequency specified by SET_CUR has been set on the device.) */
err = haud_app_sampling_frequency_get(g_sampling_rx.endpoint_address);
if (FSP_SUCCESS != err)
{
APP_ERR_TRAP
}
}
/* GET_CUR (Isochronous-OUT IF's EP) completed */
else if ((USB_HAUD_AUDIO10_GET_CUR == (p_usb_event->setup.request_type & USB_BREQUEST)) &&
(g_sampling_tx.endpoint_address == p_usb_event->setup.request_index))
{
/* The fourth byte has no data so it is cleared. */
g_buf[3] = 0;
value = (ULONG) g_buf[0];
value |= (ULONG) g_buf[1] << 8;
value |= (ULONG) g_buf[2] << 16;
value |= (ULONG) g_buf[3] << 24;
if (value != g_sampling_tx.frequency)
{
/* Sampling frequency requested is not set to device. */
APP_ERR_TRAP
}
/* Data Write (Isochronous-OUT) */
err =
R_USB_Write(&g_basic0_ctrl, (uint8_t *) g_send_buffer, REQUEST_SIZE, g_device_address);
if (FSP_SUCCESS != err)
{
handle_error(err, "**R_USB_Write API FAILED**");
}
}
/* GET_CUR (Isochronous-IN IF's EP) completed */
else if ((USB_HAUD_AUDIO10_GET_CUR == (p_usb_event->setup.request_type & USB_BREQUEST)) &&
(g_sampling_rx.endpoint_address == p_usb_event->setup.request_index))
{
/* The fourth byte has no data so it is cleared. */
g_buf[3] = 0;
value = (ULONG) g_buf[0];
value |= (ULONG) g_buf[1] << 8;
value |= (ULONG) g_buf[2] << 16;
value |= (ULONG) g_buf[3] << 24;
if (value != g_sampling_rx.frequency)
{
/* Sampling frequency requested is not set to device. */
APP_ERR_TRAP
}
/* Data Read (Isochronous-IN) */
err = R_USB_Read(&g_basic0_ctrl, g_recv_buffer, g_sampling_rx.max_packet_size, g_device_address);
/* Handle Error */
if (FSP_SUCCESS != err)
{
handle_error(err, "**R_USB_Read API FAILED**");
}
}
else
{
APP_ERR_TRAP
}
} /* End of function haud_app_audio_class_request_complete */
/*******************************************************************************************************************
* Function Name : haud_app_interface_set
* Description : This function does a SET_INTERFACE with the specified Alternate number and interface number.
* Arguments : uint32_t value : Alternate number
* : uint32_t index : Interface number
* Return value : fsp_err_t err : Result of a control transfer request
*******************************************************************************************************************/
static fsp_err_t haud_app_interface_set (uint32_t value, uint32_t index)
{
fsp_err_t err = FSP_SUCCESS;
usb_setup_t setup;
setup.request_type = USB_SET_INTERFACE | USB_HOST_TO_DEV | USB_STANDARD | USB_INTERFACE;
setup.request_value = (uint16_t) value;
setup.request_index = (uint16_t) index;
setup.request_length = 0;
err = R_USB_HostControlTransfer(&g_basic0_ctrl, &setup, &g_usb_dummy, g_device_address);
return err;
} /* End of function haud_app_interface_set */
/*******************************************************************************************************************
* Function Name : haud_app_sampling_frequency_set
* Description : This function sets the sampling frequency on the device using the SET_CUR request.
* Arguments : uint8_t ep_address : End Point Address
* : uint32_t frequency : Sampling Furequency
* Return value : fsp_err_t err : Result of a control transfer request
*******************************************************************************************************************/
static fsp_err_t haud_app_sampling_frequency_set (uint8_t ep_address, uint32_t frequency)
{
fsp_err_t err = FSP_SUCCESS;
usb_setup_t setup;
setup.request_type = USB_HAUD_AUDIO10_SET_CUR | USB_HOST_TO_DEV | USB_CLASS | USB_ENDPOINT;
setup.request_value = USB_HAUD_AUDIO10_EP_SAMPLING_FREQ_CONTROL << 8;
setup.request_index = (uint16_t) ep_address;
setup.request_length = SAMPLING_FREQUENCY_DATA_SIZE;
g_buf[0] = (uint8_t) frequency;
g_buf[1] = (uint8_t) (frequency >> 8);
g_buf[2] = (uint8_t) (frequency >> 16);
g_buf[3] = 0;
/* Request Control transfer */
err = R_USB_HostControlTransfer(&g_basic0_ctrl, &setup, g_buf, g_device_address);
return err;
} /* End of function haud_app_sampling_frequency_set */
/*******************************************************************************************************************
* Function Name : haud_app_sampling_frequency_get
* Description : This function uses a GET_CUR request to get the sampling frequency of the device.
* Arguments : uint8_t ep_address : End Point Address
* Return value : fsp_err_t err : Result of a control transfer request
*******************************************************************************************************************/
static fsp_err_t haud_app_sampling_frequency_get (uint8_t ep_address)
{
fsp_err_t err = FSP_SUCCESS;
usb_setup_t setup;
setup.request_type = USB_HAUD_AUDIO10_GET_CUR | USB_DEV_TO_HOST | USB_CLASS | USB_ENDPOINT;
setup.request_value = USB_HAUD_AUDIO10_EP_SAMPLING_FREQ_CONTROL << 8;
setup.request_index = ep_address;
setup.request_length = SAMPLING_FREQUENCY_DATA_SIZE;
err = R_USB_HostControlTransfer(&g_basic0_ctrl, &setup, g_buf, g_device_address);
return err;
} /* End of function haud_app_sampling_frequency_get */
/*******************************************************************************************************************
* Function Name : handle_error
* Description : Print and traps error
* Arguments : fsp_err_t err
* : char * err_str
* Return value : none
*******************************************************************************************************************/
static void handle_error (fsp_err_t err, char * err_str)
{
fsp_err_t error = FSP_SUCCESS;
FSP_PARAMETER_NOT_USED(err);
FSP_PARAMETER_NOT_USED(err_str);
/* close opened USB module */
error = R_USB_Close(&g_basic0_ctrl);
/* Handle error */
if (FSP_SUCCESS != error)
{
APP_ERR_TRAP
}
} /* End of function handle_error() */
#if (BSP_CFG_RTOS == 2)
/*******************************************************************************************************************
* Function Name : usb_apl_callback
* Description : This function is callback for USB
* Arguments : usb_event_info_t *p_event_info
* : usb_hdl_t handler
* : usb_onoff_t usb_state
* Return value : none
*******************************************************************************************************************/
void usb_apl_callback (usb_event_info_t * p_event_info, usb_hdl_t handler, usb_onoff_t usb_state)
{
FSP_PARAMETER_NOT_USED(handler);
FSP_PARAMETER_NOT_USED(usb_state);
/* Send event received to queue */
if (USB_TRUE != (xQueueSend(g_usb_queue, (const void *) &p_event_info, (TickType_t) (NO_WAIT_TIME))))
{
g_err_flag = true;
}
} /* End of function usb_rtos_callback */
#endif
  1. Example code for Audio 2.0
#define CONTROL_BUFFER_SIZE (256)
#define AUDIO_BUFFER_SIZE (3 * 1024) + 1024
#define REQUEST_SIZE (3 * 1024)
#define FIRST_PACKET_TEST_SIZE (200) /* for Test Device (USBX-PAUD Sample Project : EK-RA6M5 Board) */
/* The first 200 bytes of the loopback data are all 0x00. */
#define READ_REQUEST_SIZE (REQUEST_SIZE + FIRST_PACKET_TEST_SIZE)
#define BMREQUESTTYPEDIR (0x0080U)
#define BMREQUESTTYPETYPE (0x0060U)
#define ALT_NUM_0 (0)
#define SAMPLING_FREQUENCY_CHANNNELS (2)
#define SAMPLING_FREQUENCY_FREQUENCY (48000)
#define SAMPLING_FREQUENCY_RESOLUTION (16)
#define SAMPLING_FREQUENCY_DATA_SIZE_2 (2)
#define SAMPLING_FREQUENCY_DATA_SIZE_3 (3)
#define SAMPLING_FREQUENCY_DATA_SIZE_14 (14)
#define SAMPLING_FREQUENCY_SUB_RANGE (4 * 3)
/******************************************************************************
* Exported global functions (to be accessed by other files)
******************************************************************************/
void usb_haud_example(void);
#if (BSP_CFG_RTOS == 2)
void usb_apl_callback(usb_event_info_t * p_event_info, usb_hdl_t cur_task, usb_onoff_t usb_state);
#endif
/******************************************************************************
* Private global variables and functions
******************************************************************************/
#if (BSP_CFG_RTOS == 2)
static volatile usb_event_info_t * p_usb_event = NULL;
extern QueueHandle_t g_usb_queue;
#else
static usb_event_info_t event_info = {0};
static volatile usb_event_info_t * p_usb_event = &event_info;
#endif
/* Private variables */
static uint8_t g_buf[CONTROL_BUFFER_SIZE] BSP_ALIGN_VARIABLE(4) = {RESET_VALUE}; // Class request data buffer
static uint8_t g_send_buffer[AUDIO_BUFFER_SIZE] BSP_ALIGN_VARIABLE(4);
static uint8_t g_recv_buffer[AUDIO_BUFFER_SIZE] BSP_ALIGN_VARIABLE(4);
static uint8_t g_usb_dummy = RESET_VALUE; // dummy variable to send
static volatile bool g_err_flag = false; // flag bit
static uint8_t g_device_address = 0;
static uint8_t g_device_protocol = VALUE_FFH;
static uint32_t g_completed_read_transfer_length_total = 0;
static uint32_t g_num_sub_ranges = 0;
static usb_haud_sampling_t g_sampling_tx;
static usb_haud_sampling_t g_sampling_rx;
/* Private functions */
static void haud_app_data_buffer_init(void);
static void haud_app_standard_request_complete_aud10(void);
static void haud_app_standard_request_complete_aud20(void);
static void haud_app_audio_class_request_complete_aud10(void);
static void haud_app_audio_class_request_complete_aud20(void);
static fsp_err_t haud_app_interface_set(uint32_t value, uint32_t index);
static fsp_err_t haud_app_sampling_frequency_set(uint8_t ep_address, uint32_t frequency);
static fsp_err_t haud_app_sampling_frequency_get_aud10(uint8_t ep_address);
static fsp_err_t haud_app_sampling_frequency_get_aud20(uint8_t ep_address, uint16_t length);
static void handle_error(fsp_err_t err, char * err_str);
extern const usb_cfg_t g_basic0_cfg;
extern usb_instance_ctrl_t g_basic0_ctrl;
/*******************************************************************************************************************
* Function Name : usb_haud_example
* Description : Host Audio application main process
* Arguments : none
* Return value : none
*******************************************************************************************************************/
void usb_haud_example (void)
{
fsp_err_t err = FSP_SUCCESS;
#if (BSP_CFG_RTOS == 2)
BaseType_t err_queue = USB_FALSE;
#endif
usb_haud_device_info_t device_info;
err = R_USB_Open(&g_basic0_ctrl, &g_basic0_cfg);
/* Error Handle */
if (FSP_SUCCESS != err)
{
APP_ERR_TRAP
}
haud_app_data_buffer_init();
while (true)
{
/* Handle error if queue send fails*/
if (true == g_err_flag)
{
handle_error(FSP_ERR_ABORTED, "Error in sending usb event through queue");
}
#if (BSP_CFG_RTOS == 2)
/* Receive message from queue and analyzing the received message*/
err_queue = xQueueReceive(g_usb_queue, &p_usb_event, (portMAX_DELAY));
/* Handle error */
if (USB_TRUE != err_queue)
{
handle_error(FSP_ERR_ABORTED, "Error in receiving USB event message through queue");
}
#else
/* Obtain USB related events */
err = R_USB_EventGet(&event_info, &event_info.event);
/* Handle error */
if (FSP_SUCCESS != err)
{
APP_ERR_TRAP
}
#endif
switch (p_usb_event->event)
{
case USB_STATUS_CONFIGURED:
{
g_device_address = p_usb_event->device_address;
/* Get device information (Audio version) */
err = R_USB_HAUD_DeviceInfoGet(&g_basic0_ctrl, &device_info, g_device_address);
if (FSP_SUCCESS != err)
{
APP_ERR_TRAP
}
if (USB_HAUD_PROTOCOL_IP_VERSION_01_00 == device_info.protocol)
{
g_device_protocol = USB_HAUD_PROTOCOL_IP_VERSION_01_00;
g_sampling_tx.channels = SAMPLING_FREQUENCY_CHANNNELS;
g_sampling_tx.frequency = SAMPLING_FREQUENCY_FREQUENCY;
g_sampling_tx.resolution = SAMPLING_FREQUENCY_RESOLUTION;
/* Get Alternate number for Isochronous-OUT IF */
err =
R_USB_HAUD_AlternateNumberGet(&g_basic0_ctrl, &g_sampling_tx, USB_EP_DIR_OUT, g_device_address);
if (FSP_SUCCESS != err)
{
APP_ERR_TRAP
}
/* SET_INTERFACE (Use the acquired ALT number) */
err = haud_app_interface_set(g_sampling_tx.alternate_number, g_sampling_tx.interface_number);
if (FSP_SUCCESS != err)
{
APP_ERR_TRAP
}
}
else if (USB_HAUD_PROTOCOL_IP_VERSION_02_00 == device_info.protocol)
{
g_device_protocol = USB_HAUD_PROTOCOL_IP_VERSION_02_00;
g_sampling_tx.channels = SAMPLING_FREQUENCY_CHANNNELS;
g_sampling_tx.frequency = SAMPLING_FREQUENCY_FREQUENCY;
g_sampling_tx.resolution = SAMPLING_FREQUENCY_RESOLUTION;
err =
R_USB_HAUD_ClockSourceGet(&g_basic0_ctrl, &g_sampling_tx, USB_EP_DIR_OUT, g_device_address);
if (FSP_SUCCESS != err)
{
APP_ERR_TRAP
}
err = haud_app_sampling_frequency_get_aud20(USB_EP_DIR_OUT, SAMPLING_FREQUENCY_DATA_SIZE_2);
if (FSP_SUCCESS != err)
{
APP_ERR_TRAP
}
}
else
{
/* Do nothing. (not supported) */
}
break;
}
case USB_STATUS_READ_COMPLETE:
{
if ((FSP_SUCCESS == p_usb_event->status) || (FSP_ERR_USB_SIZE_SHORT == p_usb_event->status))
{
g_completed_read_transfer_length_total += p_usb_event->data_size;
if (READ_REQUEST_SIZE > g_completed_read_transfer_length_total)
{
err = R_USB_Read(&g_basic0_ctrl,
g_recv_buffer + g_completed_read_transfer_length_total,
g_sampling_rx.max_packet_size,
g_device_address);
/* Handle Error */
if (FSP_SUCCESS != err)
{
handle_error(err, "**R_USB_Read API FAILED**");
}
}
else
{
if (0 == memcmp(g_send_buffer, g_recv_buffer + FIRST_PACKET_TEST_SIZE, REQUEST_SIZE))
{
/* SET_INTERFACE (ALT number : 0) */
err = haud_app_interface_set(ALT_NUM_0, g_sampling_rx.interface_number);
if (FSP_SUCCESS != err)
{
APP_ERR_TRAP
}
}
else
{
APP_ERR_TRAP
}
}
}
else
{
APP_ERR_TRAP
}
break;
}
case USB_STATUS_WRITE_COMPLETE:
{
if (FSP_SUCCESS == p_usb_event->status)
{
/* SET_INTERFACE (ALT number : 0) */
err = haud_app_interface_set(ALT_NUM_0, g_sampling_tx.interface_number);
if (FSP_SUCCESS != err)
{
APP_ERR_TRAP
}
}
else
{
APP_ERR_TRAP
}
break;
}
case USB_STATUS_REQUEST_COMPLETE:
{
switch (BMREQUESTTYPETYPE & p_usb_event->setup.request_type)
{
case USB_STANDARD:
{
if (USB_HAUD_PROTOCOL_IP_VERSION_01_00 == g_device_protocol)
{
haud_app_standard_request_complete_aud10();
}
else if (USB_HAUD_PROTOCOL_IP_VERSION_02_00 == g_device_protocol)
{
haud_app_standard_request_complete_aud20();
}
else
{
/* Do nothing */
}
break;
}
case USB_CLASS:
{
if (USB_HAUD_PROTOCOL_IP_VERSION_01_00 == g_device_protocol)
{
haud_app_audio_class_request_complete_aud10();
}
else if (USB_HAUD_PROTOCOL_IP_VERSION_02_00 == g_device_protocol)
{
haud_app_audio_class_request_complete_aud20();
}
else
{
/* Do nothing */
}
break;
}
}
break;
}
case USB_STATUS_DETACH:
{
memset(&g_sampling_tx, 0, sizeof(g_sampling_tx));
memset(&g_sampling_rx, 0, sizeof(g_sampling_rx));
g_device_address = 0;
g_device_protocol = VALUE_FFH;
g_num_sub_ranges = 0;
g_completed_read_transfer_length_total = 0;
break;
}
default:
{
/* No operation to do */
break;
}
}
}
} /* End of function usb_haud_example */
/*******************************************************************************************************************
* Function Name : haud_app_data_buffer_init
* Description : Initializes test write data.
* Arguments : none
* Return value : none
*******************************************************************************************************************/
static void haud_app_data_buffer_init (void)
{
uint32_t i = 0;
uint32_t j = 0;
/* Set data to the send buffer. */
for ( ; i < AUDIO_BUFFER_SIZE; i++)
{
if (i % (VALUE_FFH + 1))
{
(g_send_buffer)[i] = (uint8_t) i;
}
else
{
(g_send_buffer)[i] = (uint8_t) j;
j++;
}
}
} /* End of function haud_app_data_buffer_init */
/*******************************************************************************************************************
* Function Name : haud_app_standard_request_complete_aud10
* Description : Standard request (such as SET_INTERFACE) completion event processing.
* Arguments : none
* Return value : none
*******************************************************************************************************************/
static void haud_app_standard_request_complete_aud10 (void)
{
fsp_err_t err = FSP_SUCCESS;
if (USB_SET_INTERFACE == (p_usb_event->setup.request_type & USB_BREQUEST))
{
if ((g_sampling_tx.interface_number == p_usb_event->setup.request_index) &&
(g_sampling_tx.alternate_number == p_usb_event->setup.request_value))
{
g_sampling_tx.alternate_setting = USB_TRUE;
err = R_USB_HAUD_PipeSet(&g_basic0_ctrl,
g_sampling_tx.interface_number,
g_sampling_tx.alternate_number,
g_device_address);
if (FSP_SUCCESS != err)
{
APP_ERR_TRAP
}
g_sampling_tx.frequency_setting = USB_TRUE;
/* If there is only one frequency, no need to set it to device. */
if ((g_sampling_tx.p_sampling_descriptor[7] == 1) || /* bSamFreqType : There is one frequency */
((g_sampling_tx.p_sampling_descriptor[7] == 0) && /* bSamFreqType : There is Low(=High) frequency */
(g_sampling_tx.
p_sampling_descriptor[8] == g_sampling_tx.p_sampling_descriptor[11]) && /* tSamFreq (low) */
(g_sampling_tx.
p_sampling_descriptor[9] == g_sampling_tx.p_sampling_descriptor[12]) && /* tSamFreq (middle) */
(g_sampling_tx.
p_sampling_descriptor[10] == g_sampling_tx.p_sampling_descriptor[13]))) /* tSamFreq (high)*/
{
g_sampling_tx.frequency_setting = USB_FALSE; /* No need to set frequency */
}
if (g_sampling_tx.frequency_setting)
{
/* Send SET_CUR requests to set frequency. */
err = haud_app_sampling_frequency_set(g_sampling_tx.endpoint_address, g_sampling_tx.frequency);
if (FSP_SUCCESS != err)
{
APP_ERR_TRAP
}
}
}
else if ((g_sampling_tx.interface_number == p_usb_event->setup.request_index) &&
(ALT_NUM_0 == p_usb_event->setup.request_value))
{
g_sampling_tx.alternate_setting = USB_FALSE;
g_sampling_rx.channels = SAMPLING_FREQUENCY_CHANNNELS;
g_sampling_rx.frequency = SAMPLING_FREQUENCY_FREQUENCY;
g_sampling_rx.resolution = SAMPLING_FREQUENCY_RESOLUTION;
/* Get Alternate number for Isochronous-IN IF */
err = R_USB_HAUD_AlternateNumberGet(&g_basic0_ctrl, &g_sampling_rx, USB_EP_DIR_IN, g_device_address);
if (FSP_SUCCESS != err)
{
APP_ERR_TRAP
}
/* SET_INTERFACE (Use the acquired ALT number) */
err = haud_app_interface_set(g_sampling_rx.alternate_number, g_sampling_rx.interface_number);
if (FSP_SUCCESS != err)
{
APP_ERR_TRAP
}
}
else if ((g_sampling_rx.interface_number == p_usb_event->setup.request_index) &&
(g_sampling_rx.alternate_number == p_usb_event->setup.request_value))
{
g_sampling_rx.alternate_setting = USB_TRUE;
err = R_USB_HAUD_PipeSet(&g_basic0_ctrl,
g_sampling_rx.interface_number,
g_sampling_rx.alternate_number,
g_device_address);
if (FSP_SUCCESS != err)
{
APP_ERR_TRAP
}
g_sampling_rx.frequency_setting = USB_TRUE;
/* If there is only one frequency, no need to set it to device. */
if ((g_sampling_rx.p_sampling_descriptor[7] == 1) || /* bSamFreqType : There is one frequency */
((g_sampling_rx.p_sampling_descriptor[7] == 0) && /* bSamFreqType : There is Low(=High) frequency */
(g_sampling_rx.
p_sampling_descriptor[8] == g_sampling_rx.p_sampling_descriptor[11]) && /* tSamFreq (low) */
(g_sampling_rx.
p_sampling_descriptor[9] == g_sampling_rx.p_sampling_descriptor[12]) && /* tSamFreq (middle) */
(g_sampling_rx.
p_sampling_descriptor[10] == g_sampling_rx.p_sampling_descriptor[13]))) /* tSamFreq (high) */
{
g_sampling_rx.frequency_setting = USB_FALSE; /* No need to set frequency */
}
if (g_sampling_rx.frequency_setting)
{
/* Send SET_CUR requests to set frequency. */
err = haud_app_sampling_frequency_set(g_sampling_rx.endpoint_address, g_sampling_rx.frequency);
if (FSP_SUCCESS != err)
{
APP_ERR_TRAP
}
}
}
else if ((g_sampling_rx.interface_number == p_usb_event->setup.request_index) &&
(ALT_NUM_0 == p_usb_event->setup.request_value))
{
g_sampling_rx.alternate_setting = USB_FALSE;
}
else
{
APP_ERR_TRAP
}
}
} /* End of function haud_app_standard_request_complete_aud10 */
/*******************************************************************************************************************
* Function Name : haud_app_standard_request_complete_aud20
* Description : Standard request (such as SET_INTERFACE) completion event processing.
* Arguments : none
* Return value : none
*******************************************************************************************************************/
static void haud_app_standard_request_complete_aud20 (void)
{
fsp_err_t err = FSP_SUCCESS;
uint32_t request_size;
if (USB_SET_INTERFACE == (p_usb_event->setup.request_type & USB_BREQUEST))
{
if ((g_sampling_tx.interface_number == p_usb_event->setup.request_index) &&
(g_sampling_tx.alternate_number == p_usb_event->setup.request_value))
{
g_sampling_tx.alternate_setting = USB_TRUE;
err = R_USB_HAUD_PipeSet(&g_basic0_ctrl,
g_sampling_tx.interface_number,
g_sampling_tx.alternate_number,
g_device_address);
if (FSP_SUCCESS != err)
{
APP_ERR_TRAP
}
/* Data Write (Isochronous-OUT) */
err =
R_USB_Write(&g_basic0_ctrl, (uint8_t *) g_send_buffer, REQUEST_SIZE, g_device_address);
if (FSP_SUCCESS != err)
{
handle_error(err, "**R_USB_Write API FAILED**");
}
}
else if ((g_sampling_tx.interface_number == p_usb_event->setup.request_index) &&
(ALT_NUM_0 == p_usb_event->setup.request_value))
{
g_sampling_tx.alternate_setting = USB_FALSE;
/* Starts processing related to obtaining an ALT number for isochronous IN transfer. */
g_sampling_rx.channels = SAMPLING_FREQUENCY_CHANNNELS;
g_sampling_rx.frequency = SAMPLING_FREQUENCY_FREQUENCY;
g_sampling_rx.resolution = SAMPLING_FREQUENCY_RESOLUTION;
err =
R_USB_HAUD_ClockSourceGet(&g_basic0_ctrl, &g_sampling_rx, USB_EP_DIR_IN, g_device_address);
if (FSP_SUCCESS != err)
{
APP_ERR_TRAP
}
err = haud_app_sampling_frequency_get_aud20(USB_EP_DIR_IN, SAMPLING_FREQUENCY_DATA_SIZE_2);
if (FSP_SUCCESS != err)
{
APP_ERR_TRAP
}
}
else if ((g_sampling_rx.interface_number == p_usb_event->setup.request_index) &&
(g_sampling_rx.alternate_number == p_usb_event->setup.request_value))
{
g_sampling_rx.alternate_setting = USB_TRUE;
err = R_USB_HAUD_PipeSet(&g_basic0_ctrl,
g_sampling_rx.interface_number,
g_sampling_rx.alternate_number,
g_device_address);
if (FSP_SUCCESS != err)
{
APP_ERR_TRAP
}
if (0 == READ_REQUEST_SIZE % g_sampling_rx.max_packet_size)
{
request_size = READ_REQUEST_SIZE;
}
else
{
request_size =
(uint32_t) (g_sampling_rx.max_packet_size *
((READ_REQUEST_SIZE / g_sampling_rx.max_packet_size) + 1));
}
/* Data Read (Isochronous-IN) */
err = R_USB_Read(&g_basic0_ctrl, g_recv_buffer, request_size, g_device_address);
/* Handle Error */
if (FSP_SUCCESS != err)
{
handle_error(err, "**R_USB_Read API FAILED**");
}
}
else if ((g_sampling_rx.interface_number == p_usb_event->setup.request_index) &&
(ALT_NUM_0 == p_usb_event->setup.request_value))
{
g_sampling_rx.alternate_setting = USB_FALSE;
}
else
{
APP_ERR_TRAP
}
}
} /* End of function haud_app_standard_request_complete_aud20 */
/*******************************************************************************************************************
* Function Name : haud_app_audio_class_request_complete_aud10
* Description : Audio class request completion event processing.
* Arguments : none
* Return value : none
*******************************************************************************************************************/
static void haud_app_audio_class_request_complete_aud10 (void)
{
uint32_t value;
fsp_err_t err = FSP_SUCCESS;
/* SET_CUR (Isochronous-OUT IF's EP) completed */
if ((USB_HAUD_AUDIO10_SET_CUR == (p_usb_event->setup.request_type & USB_BREQUEST)) &&
(g_sampling_tx.endpoint_address == p_usb_event->setup.request_index))
{
/* GET_CUR Request (Check whether the sampling frequency specified by SET_CUR has been set on the device.) */
err = haud_app_sampling_frequency_get_aud10(g_sampling_tx.endpoint_address);
if (FSP_SUCCESS != err)
{
APP_ERR_TRAP
}
}
/* SET_CUR (Isochronous-IN IF's EP) completed */
else if ((USB_HAUD_AUDIO10_SET_CUR == (p_usb_event->setup.request_type & USB_BREQUEST)) &&
(g_sampling_rx.endpoint_address == p_usb_event->setup.request_index))
{
/* GET_CUR Request (Check whether the sampling frequency specified by SET_CUR has been set on the device.) */
err = haud_app_sampling_frequency_get_aud10(g_sampling_rx.endpoint_address);
if (FSP_SUCCESS != err)
{
APP_ERR_TRAP
}
}
/* GET_CUR (Isochronous-OUT IF's EP) completed */
else if ((USB_HAUD_AUDIO10_GET_CUR == (p_usb_event->setup.request_type & USB_BREQUEST)) &&
(g_sampling_tx.endpoint_address == p_usb_event->setup.request_index))
{
/* The fourth byte has no data so it is cleared. */
g_buf[3] = 0;
value = (ULONG) g_buf[0];
value |= (ULONG) g_buf[1] << 8;
value |= (ULONG) g_buf[2] << 16;
value |= (ULONG) g_buf[3] << 24;
if (value != g_sampling_tx.frequency)
{
/* Sampling frequency requested is not set to device. */
APP_ERR_TRAP
}
/* Data Write (Isochronous-OUT) */
err =
R_USB_Write(&g_basic0_ctrl, (uint8_t *) g_send_buffer, REQUEST_SIZE, g_device_address);
if (FSP_SUCCESS != err)
{
handle_error(err, "**R_USB_Write API FAILED**");
}
}
/* GET_CUR (Isochronous-IN IF's EP) completed */
else if ((USB_HAUD_AUDIO10_GET_CUR == (p_usb_event->setup.request_type & USB_BREQUEST)) &&
(g_sampling_rx.endpoint_address == p_usb_event->setup.request_index))
{
/* The fourth byte has no data so it is cleared. */
g_buf[3] = 0;
value = (ULONG) g_buf[0];
value |= (ULONG) g_buf[1] << 8;
value |= (ULONG) g_buf[2] << 16;
value |= (ULONG) g_buf[3] << 24;
if (value != g_sampling_rx.frequency)
{
/* Sampling frequency requested is not set to device. */
APP_ERR_TRAP
}
/* Data Read (Isochronous-IN) */
err = R_USB_Read(&g_basic0_ctrl, g_recv_buffer, g_sampling_rx.max_packet_size, g_device_address);
/* Handle Error */
if (FSP_SUCCESS != err)
{
handle_error(err, "**R_USB_Read API FAILED**");
}
}
else
{
APP_ERR_TRAP
}
} /* End of function haud_app_audio_class_request_complete_aud10 */
/*******************************************************************************************************************
* Function Name : haud_app_audio_class_request_complete_aud20
* Description : Audio class request completion event processing.
* Arguments : none
* Return value : none
*******************************************************************************************************************/
static void haud_app_audio_class_request_complete_aud20 (void)
{
uint32_t value;
uint32_t offset;
uint32_t request_length;
uint8_t direction;
fsp_err_t err = FSP_SUCCESS;
uint32_t frequency_low;
uint32_t frequency_high;
usb_haud_sampling_t * p_haud_sampling;
uint8_t * p_buf;
/* RANGE(IN) completed */
if ((USB_HAUD_AUDIO20_RANGE == (p_usb_event->setup.request_type & USB_BREQUEST)) &&
(USB_DEV_TO_HOST == (p_usb_event->setup.request_type & BMREQUESTTYPEDIR)))
{
if (g_sampling_tx.interface_number == (uint32_t) (p_usb_event->setup.request_index & VALUE_FFH))
{
/* Isochronous-OUT IF */
direction = USB_EP_DIR_OUT;
p_haud_sampling = &g_sampling_tx;
}
else
{
/* Isochronous-IN IF */
direction = USB_EP_DIR_IN;
p_haud_sampling = &g_sampling_rx;
}
if (SAMPLING_FREQUENCY_DATA_SIZE_2 == p_usb_event->setup.request_length)
{
/* Get wNumSubRanges */
g_num_sub_ranges = (uint32_t) (*(uint16_t *) g_buf);
if (0 == g_num_sub_ranges)
{
APP_ERR_TRAP
}
/* Calculate parameter length */
request_length = g_num_sub_ranges * SAMPLING_FREQUENCY_SUB_RANGE;
if (request_length > VALUE_FFFFH)
{
APP_ERR_TRAP
}
request_length += 2;
if (request_length > VALUE_FFFFH)
{
APP_ERR_TRAP
}
err = haud_app_sampling_frequency_get_aud20(direction, (uint16_t) request_length);
if (FSP_SUCCESS != err)
{
APP_ERR_TRAP
}
}
else
{
/* Parse ranges */
for (offset = 2; offset < p_usb_event->setup.request_length; offset += SAMPLING_FREQUENCY_SUB_RANGE)
{
p_buf = g_buf;
/* Save frequency (low) */
value = (uint32_t) *(p_buf++ + offset);
value |= ((uint32_t) *(p_buf++ + offset) << 8);
value |= ((uint32_t) *(p_buf++ + offset) << 16);
value |= ((uint32_t) *(p_buf++ + offset) << 24);
frequency_low = value;
frequency_low *= p_haud_sampling->clock_numerator;
frequency_low /= p_haud_sampling->clock_denominator;
/* Save frequency (high) */
value = (uint32_t) *(p_buf++ + offset);
value |= ((uint32_t) *(p_buf++ + offset) << 8);
value |= ((uint32_t) *(p_buf++ + offset) << 16);
value |= ((uint32_t) *(p_buf++ + offset) << 24);
frequency_high = value;
frequency_high *= p_haud_sampling->clock_numerator;
frequency_high /= p_haud_sampling->clock_denominator;
/* Check channels */
if (p_haud_sampling->channels != p_haud_sampling->found_channels)
{
APP_ERR_TRAP
}
/* Check resolution */
if (p_haud_sampling->resolution != p_haud_sampling->found_resolution)
{
APP_ERR_TRAP
}
/* Check frequency */
if ((frequency_low > p_haud_sampling->frequency) ||
(frequency_high < p_haud_sampling->frequency))
{
APP_ERR_TRAP
}
/* Sampling frequency settings and confirmation are OK */
/* SET_INTERFACE (Use the acquired ALT number) */
err = haud_app_interface_set(p_haud_sampling->alternate_number, p_haud_sampling->interface_number);
if (FSP_SUCCESS != err)
{
APP_ERR_TRAP
}
}
}
}
} /* End of function haud_app_audio_class_request_complete_aud20 */
/*******************************************************************************************************************
* Function Name : haud_app_interface_set
* Description : This function does a SET_INTERFACE with the specified Alternate number and interface number.
* Arguments : uint32_t value : Alternate number
* : uint32_t index : Interface number
* Return value : fsp_err_t err : Result of a control transfer request
*******************************************************************************************************************/
static fsp_err_t haud_app_interface_set (uint32_t value, uint32_t index)
{
fsp_err_t err = FSP_SUCCESS;
usb_setup_t setup;
setup.request_type = USB_SET_INTERFACE | USB_HOST_TO_DEV | USB_STANDARD | USB_INTERFACE;
setup.request_value = (uint16_t) value;
setup.request_index = (uint16_t) index;
setup.request_length = 0;
err = R_USB_HostControlTransfer(&g_basic0_ctrl, &setup, &g_usb_dummy, g_device_address);
return err;
} /* End of function haud_app_interface_set */
/*******************************************************************************************************************
* Function Name : haud_app_sampling_frequency_set
* Description : This function sets the sampling frequency on the device using the SET_CUR request.
* Arguments : uint8_t ep_address : End Point Address
* : uint32_t frequency : Sampling Furequency
* Return value : fsp_err_t err : Result of a control transfer request
*******************************************************************************************************************/
static fsp_err_t haud_app_sampling_frequency_set (uint8_t ep_address, uint32_t frequency)
{
fsp_err_t err = FSP_SUCCESS;
usb_setup_t setup;
setup.request_type = USB_HAUD_AUDIO10_SET_CUR | USB_HOST_TO_DEV | USB_CLASS | USB_ENDPOINT;
setup.request_value = USB_HAUD_AUDIO10_EP_SAMPLING_FREQ_CONTROL << 8;
setup.request_index = (uint16_t) ep_address;
setup.request_length = SAMPLING_FREQUENCY_DATA_SIZE_3;
g_buf[0] = (uint8_t) frequency;
g_buf[1] = (uint8_t) (frequency >> 8);
g_buf[2] = (uint8_t) (frequency >> 16);
g_buf[3] = 0;
/* Request Control transfer */
err = R_USB_HostControlTransfer(&g_basic0_ctrl, &setup, g_buf, g_device_address);
return err;
} /* End of function haud_app_sampling_frequency_set */
/*******************************************************************************************************************
* Function Name : haud_app_sampling_frequency_get_aud10
* Description : This function uses a GET_CUR request to get the sampling frequency of the device.
* Arguments : uint8_t ep_address : End Point Address
* Return value : fsp_err_t err : Result of a control transfer request
*******************************************************************************************************************/
static fsp_err_t haud_app_sampling_frequency_get_aud10 (uint8_t ep_address)
{
fsp_err_t err = FSP_SUCCESS;
usb_setup_t setup;
if (USB_HAUD_PROTOCOL_IP_VERSION_01_00 == g_device_protocol)
{
setup.request_type = USB_HAUD_AUDIO10_GET_CUR | USB_DEV_TO_HOST | USB_CLASS | USB_ENDPOINT;
setup.request_value = USB_HAUD_AUDIO10_EP_SAMPLING_FREQ_CONTROL << 8;
setup.request_index = ep_address;
setup.request_length = SAMPLING_FREQUENCY_DATA_SIZE_3;
err = R_USB_HostControlTransfer(&g_basic0_ctrl, &setup, g_buf, g_device_address);
}
else
{
err = FSP_ERR_USB_FAILED;
}
return err;
} /* End of function haud_app_sampling_frequency_get_aud10 */
/*******************************************************************************************************************
* Function Name : haud_app_sampling_frequency_get_aud20
* Description : This function uses a RANGE(IN) request to get the sampling frequency of the device.
* Arguments : uint8_t ep_address : End Point Address
* : uint16_t length : Request length
* Return value : fsp_err_t err : Result of a control transfer request
*******************************************************************************************************************/
static fsp_err_t haud_app_sampling_frequency_get_aud20 (uint8_t ep_address, uint16_t length)
{
fsp_err_t err = FSP_SUCCESS;
usb_setup_t setup;
if (USB_HAUD_PROTOCOL_IP_VERSION_02_00 == g_device_protocol)
{
if (USB_EP_DIR_OUT == (ep_address & USB_EP_DIR))
{
if (0 != g_sampling_tx.clock_source_id)
{
setup.request_type = USB_HAUD_AUDIO20_RANGE | USB_DEV_TO_HOST | USB_CLASS | USB_INTERFACE;
setup.request_value = 0 | USB_HAUD_AUDIO20_CS_SAM_FREQ_CONTROL << 8;
setup.request_index =
(uint16_t) (g_sampling_tx.interface_number | (g_sampling_tx.clock_source_id << 8));
setup.request_length = length;
err = R_USB_HostControlTransfer(&g_basic0_ctrl, &setup, g_buf, g_device_address);
}
}
else
{
if (0 != g_sampling_rx.clock_source_id)
{
setup.request_type = USB_HAUD_AUDIO20_RANGE | USB_DEV_TO_HOST | USB_CLASS | USB_INTERFACE;
setup.request_value = 0 | USB_HAUD_AUDIO20_CS_SAM_FREQ_CONTROL << 8;
setup.request_index =
(uint16_t) (g_sampling_rx.interface_number | (g_sampling_rx.clock_source_id << 8));
setup.request_length = length;
err = R_USB_HostControlTransfer(&g_basic0_ctrl, &setup, g_buf, g_device_address);
}
}
}
else
{
err = FSP_ERR_USB_FAILED;
}
return err;
} /* End of function haud_app_sampling_frequency_get_aud20 */
/*******************************************************************************************************************
* Function Name : handle_error
* Description : Print and traps error
* Arguments : fsp_err_t err
* : char * err_str
* Return value : none
*******************************************************************************************************************/
static void handle_error (fsp_err_t err, char * err_str)
{
fsp_err_t error = FSP_SUCCESS;
FSP_PARAMETER_NOT_USED(err);
FSP_PARAMETER_NOT_USED(err_str);
/* close opened USB module */
error = R_USB_Close(&g_basic0_ctrl);
/* Handle error */
if (FSP_SUCCESS != error)
{
APP_ERR_TRAP
}
} /* End of function handle_error() */
#if (BSP_CFG_RTOS == 2)
/*******************************************************************************************************************
* Function Name : usb_apl_callback
* Description : This function is callback for USB
* Arguments : usb_event_info_t *p_event_info
* : usb_hdl_t handler
* : usb_onoff_t usb_state
* Return value : none
*******************************************************************************************************************/
void usb_apl_callback (usb_event_info_t * p_event_info, usb_hdl_t handler, usb_onoff_t usb_state)
{
FSP_PARAMETER_NOT_USED(handler);
FSP_PARAMETER_NOT_USED(usb_state);
/* Send event received to queue */
if (USB_TRUE != (xQueueSend(g_usb_queue, (const void *) &p_event_info, (TickType_t) (NO_WAIT_TIME))))
{
g_err_flag = true;
}
} /* End of function usb_rtos_callback */
#endif

Function Documentation

◆ R_USB_HAUD_DeviceInfoGet()

fsp_err_t R_USB_HAUD_DeviceInfoGet ( usb_ctrl_t *const  p_api_ctrl,
usb_haud_device_info_t *  p_info,
uint8_t  device_address 
)

Check audio version of connected device.

Return values
FSP_SUCCESSSuccessfully completed.
FSP_ERR_USB_FAILEDThe function could not be completed successfully.
FSP_ERR_ASSERTIONParameter Null pointer error.
FSP_ERR_USB_PARAMETERParameter error.
Note
(1). Interrupt function.
(2). Callback function ( for RTOS ).

◆ R_USB_HAUD_ClockSourceGet()

fsp_err_t R_USB_HAUD_ClockSourceGet ( usb_ctrl_t *const  p_api_ctrl,
usb_haud_sampling_t *  p_info,
uint8_t  direction,
uint8_t  device_address 
)

Get the Clock Souuce (Audio 2.0 support only)

Restriction: This API does not support fallback handling if a Clock Source descriptor is not found.

Return values
FSP_SUCCESSSuccessfully completed.
FSP_ERR_USB_FAILEDThe function could not be completed successfully.
FSP_ERR_ASSERTIONParameter Null pointer error.
FSP_ERR_USB_PARAMETERParameter error.
Note
(1). Interrupt function.
(2). Callback function ( for RTOS ).

◆ R_USB_HAUD_AlternateNumberGet()

fsp_err_t R_USB_HAUD_AlternateNumberGet ( usb_ctrl_t *const  p_api_ctrl,
usb_haud_sampling_t *  p_info,
uint8_t  direction,
uint8_t  device_address 
)

Get the alternate number for SET_INTERFACE. (Audio 1.0 support only)

Return values
FSP_SUCCESSSuccessfully completed.
FSP_ERR_USB_FAILEDThe function could not be completed successfully.
FSP_ERR_ASSERTIONParameter Null pointer error.
FSP_ERR_USB_PARAMETERParameter error.
Note
(1). Interrupt function.
(2). Callback function ( for RTOS ).

◆ R_USB_HAUD_PipeSet()

fsp_err_t R_USB_HAUD_PipeSet ( usb_ctrl_t *const  p_api_ctrl,
uint32_t  interface_number,
uint32_t  alternate_number,
uint8_t  device_address 
)

Find the interface descriptor for streaming data transfer and configure the pipe.

Return values
FSP_SUCCESSSuccessfully completed.
FSP_ERR_USB_FAILEDThe function could not be completed successfully.
FSP_ERR_ASSERTIONParameter Null pointer error.
FSP_ERR_USB_PARAMETERParameter error.
Note
(1). Interrupt function.
(2). Callback function ( for RTOS ).